godot-webrtc-mplayer-testing/scripts/screens/multiplayer_lobby.gd

extends MarginContainer

onready var peers_grid = $v/body/peers/p/peers
onready var lobby_name = $v/head/lobby_info
onready var peers_list_label = $v/body/peers/label
onready var chat = $v/body/v/messages
onready var chat_edit = $v/body/v/h/chat
onready var send_button = $v/body/v/h/send
onready var auto_scroll_chk = $v/body/v/chat_head/auto_scroll
onready var max_players = $v/head/max_players
onready var ready_up = $v/head/ready_up
onready var lock = $v/head/lock
onready var start = $v/head/start

onready var peer = preload("res://objects/peer.tscn")
onready var peers = {}
onready var peers_id_mappings = {}
onready var is_host = false

func _ready():
	Global.client.connect("peer_created", self, "_peer_created")
	Global.client.connect("peer_left", self, "_peer_left")
	Global.client.connect("lobby_left", self, "_lobby_left")
	Global.client.connect("lobby_data", self, "_lobby_data")
	Global.client.connect("lobby_joined", self, "_lobby_joined")

	Global.client.connect("signaller_disconnected", self, "_signaller_disconnected")
	Global.client.connect("webrtc_connection_succeeded", self, "_webrtc_connection_succeeded")
	Global.client.connect("webrtc_peer_connected", self, "_webrtc_peer_connected")

	# lobby_name.text = "%s" % Global.client.lobby_name

	# call_deferred("add_chat", "#  to %s" % Global.client.get_lobby_name())

	# hide/show controls depending on whether or not we're the host
	_update_ui()
	
func _signaller_disconnected():
	Global.main_menu()

func _lobby_joined(data):
	add_chat("# Connected to %s" % data.name)
	lobby_name.text = data.name
	_update_ui()
	_add_peer(data.id, {
		connected = true,
		ready = int(data.id) == 1,
		name = Global.client.display_name,
		id = int(data.id),
	})
	Global.client.request_peer_list()

func _webrtc_connection_succeeded():
	if !is_host:
		ready_up.disabled = false
		send_button.disabled = false
		chat_edit.editable = true
	Global.client.request_peer_list()

func _peer_created(p):
	call_deferred("update_player_count")
	if is_host: call_deferred("update_can_start")
	if peers.has(p.id): _update_peer(p.id, p)
	else: _add_peer(p.id, p)
			
func _add_peer(id, p):
	call_deferred("update_player_count")
	var new_peer = peer.instance()
	if p.id == 1: p.ready = true
	new_peer.set_with_dict(p)
	peers_grid.add_child(new_peer)
	peers[int(id)] = new_peer
	add_chat("> %s joined the lobby" % new_peer.display_name)

func _update_peer(id, peer_data):
	if peer_data.ready != peers[id].ready:
		var update_text = "now ready" if peer_data.ready else "no longer ready"
		add_chat("! %s is %s" % [peers[id].display_name, update_text])
	peers[id].set_with_dict(peer_data)

func _webrtc_peer_connected(id):
	print("WebRTC Peer Connected: %s" % id)
	if id != get_tree().get_network_unique_id():
		print("Sending ready state from %s to %s: %s" % [get_tree().get_network_unique_id(), id, "true" if peers[get_tree().get_network_unique_id()].ready else "false"])
		call_deferred("rpc_id", int(id), "set_ready", peers[get_tree().get_network_unique_id()].ready)

func _peer_left(id):
	call_deferred("update_player_count")
	if peers.has(id):
		var peer_id = peers[id].peerId
		call_deferred("add_chat", "< %s left the lobby" % peers[id].display_name)
		peers[id].queue_free()
		peers.erase(id)
		peers_id_mappings.erase(peer_id)
	
remotesync func add_chat(message):
	if auto_scroll_chk.pressed: call_deferred("scroll_chat_to_bottom")
	else:
		call_deferred("preserve_chat_scroll", chat.cursor_get_line(), chat.get_selection_to_line(), chat.get_selection_from_line(), chat.get_selection_to_column(), chat.get_selection_from_column())
	chat.text += "\n" + message

func scroll_chat_to_bottom():
	chat.cursor_set_line(chat.get_line_count() + 1)
	chat.scroll_vertical = 1000000000

func preserve_chat_scroll(n, tl, fl, tc, fc):
	chat.cursor_set_line(n)
	chat.select(fl, fc, tl, tc)
	chat.center_viewport_to_cursor()

func send_chat_message():
	var message = chat_edit.text
	if message != "":
		rpc("add_chat", "%s: %s" % [Global.client.display_name, message])
		chat_edit.text = ""

func update_can_start():
	var can_start = true
	for p in peers:
		var peer = peers[p]
		if !peer.ready:
			can_start = false
			break
	if can_start: add_chat("! All players ready - game may now be started")
	start.disabled = !can_start

func _on_start_pressed():
	if is_host: rpc("start_game")

remotesync func start_game():
	# TODO: seal lobby
	get_tree().refuse_new_network_connections = true
	Global.goto_game()

remotesync func set_ready(ready):
	var from = get_tree().get_rpc_sender_id()
	print("Set Ready: %s %s" % [from, ready])
	peers[from].ready = ready
	if is_host: update_can_start()

func _on_TextEdit_text_entered(_new_text):
	if !send_button.disabled:
		send_chat_message()

remotesync func set_lobby_name(new_lobby_name: String):
	if is_host: Global.client.set_lobby_name(new_lobby_name)
	else: lobby_name.text = new_lobby_name

remotesync func set_max_players(new_max_players: String):
	if int(new_max_players) <= 0: return
	if is_host: Global.client.set_lobby_max_players(int(new_max_players))
	else: max_players.text = str(int(new_max_players))

func _update_ui():
	is_host = Global.client.is_host()
	ready_up.visible = !is_host
	lobby_name.editable = is_host
	max_players.editable = is_host
	start.visible = is_host
	lock.visible = is_host
	var is_in_lobby = Global.client.is_in_lobby()
	ready_up.disabled = !is_in_lobby
	chat_edit.editable = is_in_lobby
	send_button.disabled = !is_in_lobby

func _on_max_players_text_changed(new_text:String): rpc("set_max_players", new_text)
func _lobby_left(_id): Global.lobby_browser()
func _on_leave_button_pressed(): Global.client.leave_lobby()
func update_player_count(): peers_list_label.text = "Players: %d" % peers.size()
func _on_Button_pressed(): send_chat_message()
func _on_ready_up_toggled(button_pressed: bool): rpc("set_ready", button_pressed)
func _on_lobby_info_text_changed(new_text: String): rpc("set_lobby_name", new_text)