nv-moba/scripts/networking.gd

extends Node

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

var players = []
# TODO: Should we abstract server so variables like this aren't cluttering everything up?
var players_done = []
var begun = false
# TODO: This needs to go. It carries nothing of value
# ALL server negotiation should happen before ANY data is investigated (in lobby)
var my_info = {}

func _ready():
	add_child(matchmaking)

	get_tree().connect("network_peer_connected", self, "_player_connected")
	get_tree().connect("network_peer_disconnected", self, "_player_disconnected")
	get_tree().connect("connected_to_server", self, "_connected_ok")

# func connect_global_server(): TODO
# 	ip = global_server_ip
# 	_client_init()

func start_client(ip, port):
	# collect_info() TODO
	var peer = NetworkedMultiplayerENet.new()
	print("Connecting to " + ip + ":" + str(port))
	peer.create_client(ip, port)
	get_tree().set_network_peer(peer)
	# get_node("CustomGame/Client").set_text("Clienting!") TODO

# func singleplayer_init(): TODO
# 	# collect_info() TODO
# 	var peer = NetworkedMultiplayerENet.new()
# 	peer.create_server(port, 1)
# 	get_tree().set_network_peer(peer)
# 	players[1] = my_info
# 	start_game()

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)

func start_server(port):
	# collect_info() TODO
	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)
	# is_connected = true TODO
	# get_node("CustomGame/Server").set_text("Serving!")
	# get_node("JoinedGameLobby").show()
	# if server_playing:
	# 	players[1] = my_info
	# if "start_game" in my_info and my_info.start_game: TODO
	# 	start_game()

# sync func start_game(): TODO
	# my_info.level = get_node("CustomGame/LevelSelect").get_selected_id() TODO
	# rpc("_pre_configure_game", my_info.level)

func disconnect_player(id):
	if get_tree().is_network_server():
		rpc("unregister_player", id)
	# call_deferred("render_player_list") TODO

func connect_player():
	rpc("_register_player", get_tree().get_network_unique_id(), {})
	if util.args.get_value("-start-game"):
		rpc_id(1, "start_game")
	# is_connected = true TODO

remote func _register_player(new_peer, info):
	players[new_peer] = info
	render_player_list()
	if (get_tree().is_network_server()):
		var right_team_count = 0
		# Send current players' info to new player
		for old_peer in players:
			# Send new player, old player's info
			rpc_id(new_peer, "_register_player", old_peer, players[old_peer])
			if old_peer != new_peer:
				# We need to assign team later, so count current
				if players[old_peer].is_right_team:
					right_team_count += 1
				# You'd think this part could be met with a simple `rpc(`, but actually it can't
				# My best guess is this is because we haven't registered the names yet, but I'm not sure (TODO)
				if old_peer != 1:
					# Send old player, new player's info (not us, no infinite loop)
					rpc_id(old_peer, "_register_player", new_peer, info)
				if begun:
					rpc_id(old_peer, "_spawn_player", new_peer)
					rpc_id(old_peer, "_begin_player_deferred", new_peer) # Spawning is deferred
		# if not server_playing: TODO
		# 	# We didn't catch this in players
		# 	rpc_id(1, "_spawn_player", new_peer)
		# 	rpc_id(1, "_begin_player_deferred", new_peer) # Spawning is deferred
		var assign_right_team = right_team_count * 2 < players.size()
		rpc("assign_team", new_peer, assign_right_team)
		if not begun and players.size() == matchmaking.GAME_SIZE:
			start_game()
		if begun:
			rpc_id(new_peer, "_pre_configure_game", my_info.level)
			rpc_id(new_peer, "_post_configure_game")

sync func _unregister_player(peer):
	players.erase(peer)
	get_node("/root/Level/Players/%d" % peer).queue_free()

sync func _spawn_player(p):
	var 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.players = players[p]
	get_node("/root/Level/Players").call_deferred("add_child", player)

sync func _pre_configure_game(level):
	begun = true
	my_info.level = level # Remember the level for future player registration

	var self_peer_id = get_tree().get_network_unique_id()

	# Remove the interface so as to not fuck with things
	# But we still need the lobby alive to deal with networking!
	for element in get_node("/root/Lobby").get_children():
		element.queue_free()

	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:
		players[p].level = level
		spawn_player(p)

	rpc_id(1, "done_preconfiguring", self_peer_id)

sync func _done_preconfiguring(who):
	players_done.append(who)
	if players_done.size() == players.size():
		# We call deferred in case singleplayer has placing the player in queue still
		call_deferred("rpc", "post_configure_game")

sync func _post_configure_game():
	# Begin all players (including self)
	for p in players:
		_begin_player_deferred(p)

func _begin_player(peer):
	get_node("/root/Level/Players/%d" % peer).begin()

remote func _begin_player_deferred(peer):
	call_deferred("_begin_player", peer)

sync func reset_state():
	players_done = []
	get_node("/root/Level").queue_free()