cosine
/
nv-moba
1
1
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

Organize public and private methods within networking

master
Luna 7 years ago
parent
26441b49e5
commit
5693bcdab0
2 changed files with 74 additions and 64 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -3
      scripts/lobby.gd
  2. +71
    -61
      scripts/networking.gd

+ 3
- 3
scripts/lobby.gd View File

@ -13,7 +13,7 @@ func _ready():
ready_button.connect("toggled", self, "_set_info_callback", ["ready"])
start_game_button.connect("pressed", networking, "start_game")
# Connect (from networking)
networking.connect("info_updated", self, "render_player_list")
networking.connect("info_updated", self, "_render_player_list")
get_tree().connect("connected_to_server", self, "_connected")
# Connect (static)
@ -67,7 +67,7 @@ func _set_info_callback(value, key):
sync func set_hero(peer, hero):
networking.players[peer].hero = hero
render_player_list()
_render_player_list()
func _send_name():
var name = get_node("Username").text
@ -82,7 +82,7 @@ func _check_begun():
# The "Ready" toggle doesn't really make sense on a started game
ready_button.hide()
func render_player_list():
func _render_player_list():
_check_begun()
var list = ""
var hero_names = hero_select.hero_names


+ 71
- 61
scripts/networking.gd View File

@ -1,25 +1,20 @@
extends Node
# Public variables
# ================
onready var matchmaking = preload("res://scripts/matchmaking.gd").new()
remote var players = {}
var players_done = []
var global_server_ip = "nv.cosinegaming.com"
var matchmaker_tcp
var right_team_next = false
var level
signal info_updated
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")
# Public methods
# ==============
func start_client(ip="", port=0):
if not ip:
@ -38,14 +33,6 @@ remote func reconnect(ip, port):
players = {}
start_client(ip, port)
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=0):
if not port:
port = util.args.get_value("-port")
@ -55,18 +42,72 @@ func start_server(port=0):
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())
_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 _start_game():
rpc("_pre_configure_game", level)
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")
func send_all_info(new_peer):
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]:
@ -83,40 +124,14 @@ func _right_team_next():
right_team_count += 1
return (right_team_count <= players.size() / 2)
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")
sync func _set_info(key, value, peer):
if not players.has(peer):
players[peer] = {}
players[peer][key] = value
emit_signal("info_updated")
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 _on_connect():
register_player(get_tree().get_network_unique_id())
_register_player(get_tree().get_network_unique_id())
emit_signal("info_updated")
func _check_info():
@ -124,11 +139,17 @@ func _check_info():
# 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 ready:
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):
@ -173,20 +194,9 @@ sync func _pre_configure_game(level):
# So we only change it once, only start_game twice, and avoida segfault
if not self_begun:
set_info("begun", true)
rpc_id(1, "_done_preconfiguring", self_peer_id)
sync func _done_preconfiguring(who):
players_done.append(who)
if players_done.size() == players.size():
print("done")
rpc("_post_configure_game")
sync func _post_configure_game():
# Begin all players (including self)
# TODO: What do? Maybe, unpause game?
pass
sync func reset_state():
players_done = []
get_node("/root/Level").queue_free()

Write Preview
Loading…
Cancel
Save