nv-moba/scripts/networking.gd

extends Node

# Public variables
# ================

onready var matchmaking = preload("res://scripts/matchmaking.gd").new()

remote var players = {}
var global_server_ip = "nv.cosinegaming.com"
var matchmaker_tcp

var level

signal info_updated

# Public methods
# ==============

func start_client(ip="", port=0):
	if not ip:
		ip = util.args.get_value("-ip")
	ip = IP.resolve_hostname(ip)
	if not port:
		port = util.args.get_value("-port")
	var peer = NetworkedMultiplayerENet.new()
	print("Connecting to " + ip + ":" + str(port))
	peer.create_client(ip, port)
	get_tree().set_network_peer(peer)
	get_tree().change_scene("res://scenes/lobby.tscn")

remote func reconnect(ip, port):
	# Reset previously known players
	players = {}
	start_client(ip, port)

func start_server(port=0):
	if not port:
		port = util.args.get_value("-port")
	var peer = NetworkedMultiplayerENet.new()
	print("Starting server on port " + str(port))
	peer.create_server(port, matchmaking.GAME_SIZE)
	get_tree().set_network_peer(peer)
	# As soon as we're listening, let the matchmaker know
	_connect_to_matchmaker(port)
	_register_player(get_tree().get_network_unique_id())
	if util.args.get_value("-silent"):
		set_info("spectating", true)
	get_tree().change_scene("res://scenes/lobby.tscn")

master func set_info(key, value, peer=0):
	if not peer:
		peer = get_tree().get_network_unique_id()
	rpc("_set_info", str(key), value, peer)

# When connectivity is not yet guaranteed, the only one we know is always
# connected to everyone is the server. So in initial handshakes, it's better to
# tell the server what to tell everyone to do
func set_info_from_server(key, value, peer=0):
	if not peer:
		peer = get_tree().get_network_unique_id()
	rpc_id(1, "set_info", key, value, peer)

func start_game():
	rpc_id(1, "_start_game")

sync func reset_state():
	for p in players:
		players[p].begun = false
		# TODO: Do I in fact want to unready everyone automatically?
		players[p].ready = false
	get_node("/root/Level").queue_free()


# Private methods
# ===============

func _ready():
	add_child(matchmaking)

	get_tree().connect("network_peer_disconnected", self, "_unregister_player")
	get_tree().connect("network_peer_connected", self, "_register_player")
	get_tree().connect("connected_to_server", self, "_on_connect")

	connect("info_updated", self, "_check_info")

remote func _register_player(new_peer):
	if get_tree().is_network_server():
		# I tell new player about all the existing people
		_send_all_info(new_peer)
		set_info("is_right_team", _right_team_next(), new_peer)

sync func _unregister_player(peer):
	players.erase(peer)
	var p = util.get_player(peer)
	if p:
		p.queue_free()
	emit_signal("info_updated")

func _connect_to_matchmaker(game_port):
	var matchmaker_peer = StreamPeerTCP.new()
	matchmaker_peer.connect_to_host("127.0.0.1", matchmaking.SERVER_TO_SERVER_PORT)
	var matchmaker_tcp = PacketPeerStream.new()
	matchmaker_tcp.set_stream_peer(matchmaker_peer)
	matchmaker_tcp.put_var(matchmaking.messages.ready_to_connect)
	matchmaker_tcp.put_var(game_port)

master func _start_game():
	rpc("_pre_configure_game", level)

func _send_all_info(new_peer):
	for p in players:
		if p != new_peer:
			for key in players[p]:
				var val = players[p][key]
				# TODO: This broadcasts every connected peer,
				# which isn't really a problem but it's lazy
				set_info(key, val, p)

func _right_team_next():
	var right_team_count = 0
	for p in players:
		var player = players[p]
		if player.has("is_right_team") and player.is_right_team:
			right_team_count += 1
	return (right_team_count <= players.size() / 2)

sync func _set_info(key, value, peer):
	if not players.has(peer):
		players[peer] = {}
	players[peer][key] = value
	emit_signal("info_updated")

func _on_connect():
	_register_player(get_tree().get_network_unique_id())
	emit_signal("info_updated")

func _check_info():
	# Check for "everyone is ready"
	# Only have 1 person check this, might as well be server
	if get_tree().is_network_server():
		var ready = true
		var all_done = true
		for p in players:
			if not players[p].has("spectating") or not players[p].spectating:
				if not players[p].has("ready") or not players[p].ready:
					ready = false
				if not players[p].has("begun") or not players[p].begun:
					all_done = false
		if all_done:
			rpc("_post_configure_game")
		elif ready:
			# If we're all done, then we don't need to even check a start_game
			start_game()

sync func _spawn_player(p):
	var hero = 0
	if players[p].has("hero"):
		hero = players[p].hero
	var player = load("res://scenes/heroes/" + str(hero) + ".tscn").instance()
	player.set_name(str(p))
	player.set_network_master(p)
	player.player_info = players[p]
	get_node("/root/Level/Players").add_child(player)

func _begin_player(p):
	var player = util.get_player(p)
	player.begin()

sync func _pre_configure_game(level):

	var self_peer_id = get_tree().get_network_unique_id()
	var self_begun = players[self_peer_id].begun

	if not self_begun:
		get_node("/root/Lobby").hide()

		var world = load("res://scenes/levels/%d.tscn" % level).instance()
		get_node("/root").add_child(world)

	# Load all players (including self)
	for p in players:
		if not players[p].spectating:
			var existing_player = util.get_player(p)
			if not self_begun or not existing_player:
				_spawn_player(p)
	for p in players:
		if not players[p].spectating:
			# Begin requires all players
			_begin_player(p)

	# Why do we check first? Weird error. It's because set_info triggers a
	# start_game if everyone is ready
	# This causes a stack overflow if we call it from here repeatedly
	# So we only change it once, only start_game twice, and avoida segfault
	if not self_begun:
		set_info("begun", true)

sync func _post_configure_game():
	# Begin all players (including self)
	# TODO: What do? Maybe, unpause game?
	pass