magician/components/web_client_tcp.gd

class_name WebClientTCP
extends Node

var _tcp := StreamPeerTCP.new()

var _new_status: int = -1
var _processed_status: int = -1

var _lobby_id: String
var _client_id: String
var _client_name: String

var received_data: Array
var cached_response: String

var _thread: Thread
var _stop_thread: bool = false

signal connected_to_server()
signal connection_error_occurred()
signal disconnected_from_server()

signal connected_to_lobby(lobby_id: String)
signal disconnected_from_lobby()

signal client_joined_lobby(client_name: String)
signal client_left_lobby(client_name: String)

signal received_chat_message(client_name: String, message: String)

signal connection_status_changed(new_status: ConnectionStatus)

enum ConnectionStatus {
	DISCONNECTED,
	ATTEMPTING_CONNECTION,
	LOBBYLESS, # == connected
	ATTEMPTING_JOIN,
	JOINED,
}

func _process(_delta: float) -> void:
	_tcp.poll()
	_new_status = _tcp.get_status()
	# Ensure status change is only processed once
	if not _processed_status == _new_status:
		match _new_status:
			StreamPeerTCP.Status.STATUS_NONE:
				_clean_up_thread()
				connection_status_changed.emit(ConnectionStatus.DISCONNECTED)
			StreamPeerTCP.Status.STATUS_CONNECTING:
				connection_status_changed.emit(ConnectionStatus.ATTEMPTING_CONNECTION)
			StreamPeerTCP.Status.STATUS_CONNECTED:
				_stop_thread = false
				_thread = Thread.new()
				_thread.start(_listen_for_data)
				connected_to_server.emit()
				connection_status_changed.emit(ConnectionStatus.LOBBYLESS)
			StreamPeerTCP.Status.STATUS_ERROR:
				connection_error_occurred.emit()
				connection_status_changed.emit(ConnectionStatus.DISCONNECTED)
		
		_processed_status = _new_status
	

func _listen_for_data() -> void:
	while not _stop_thread:
		received_data = _tcp.get_data(1)
		
		# Error (e.g. abrupt disconnect), stop listening
		if not received_data[0] == OK:
			disconnected_from_server.emit.call_deferred()
			return
		
		cached_response += (received_data[1] as PackedByteArray).get_string_from_utf8()
		if cached_response.ends_with("}"):
			print(cached_response)
			_handle_response(cached_response)
			cached_response = ""

func _handle_response(response: String) -> void:
	var data = JSON.parse_string(response)
	match data["response"]:
		"create_lobby":
			if data["status"] == "ok":
				_lobby_id = data["lobby_id"]
				_client_id = data["client_id"]
				connected_to_lobby.emit.call_deferred(_lobby_id)
				connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)
		"join_lobby":
			if data["status"] == "ok":
				_client_id = data["client_id"]
				connected_to_lobby.emit.call_deferred(_lobby_id)
				connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)
		"client_joined_lobby":
			client_joined_lobby.emit.call_deferred(data["new_client_name"])
		"leave_lobby_request":
			leave_lobby()
		"leave_lobby":
			if data["status"] == "ok":
				client_left_lobby.emit.call_deferred(data["client_name"])
		"client_left_lobby":
			client_left_lobby.emit.call_deferred(data["client_name"])
		"receive_chat_message":
			received_chat_message.emit.call_deferred(data["client_name"], data["message"])

func  _exit_tree() -> void:
	disconnect_from_server()

func connect_to_server() -> void:
	_tcp.connect_to_host("127.0.0.1", 9974)
	_tcp.set_no_delay(true)

func disconnect_from_server() -> void:
	_tcp.disconnect_from_host()
	_clean_up_thread()
	disconnected_from_server.emit()
	connection_status_changed.emit(ConnectionStatus.DISCONNECTED)

func _clean_up_thread() -> void:
	_stop_thread = true
	if _thread:
		_thread.wait_to_finish()
		_thread = null

func create_lobby(client_name: String) -> void:
	_client_name = client_name
	
	_send_message(TCPMessages.create_lobby(client_name))

func join_lobby(lobby_id: String, client_name: String) -> void:
	_lobby_id = lobby_id
	_client_name = client_name
	
	_send_message(TCPMessages.join_lobby(_lobby_id, client_name))

func leave_lobby() -> void:
	_send_message(TCPMessages.leave_lobby(_lobby_id, _client_id))
	
	_lobby_id = ""
	_client_id = ""
	_client_name = ""
	
	disconnected_from_lobby.emit.call_deferred()
	connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)

func send_chat_message(message: String) -> void:
	_send_message(TCPMessages.send_chat_message(_lobby_id, _client_id, message))

func _send_message(message: String) -> void:
	_tcp.put_data(message.to_utf8_buffer())