You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
202 lines
5.7 KiB
202 lines
5.7 KiB
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
|
|
|