magician/components/web_client_tcp.gd

class_name WebClientTCP
extends Node

#var _tcp := StreamPeerTCP.new()
var _socket := WebSocketPeer.new()

var _new_status: int = WebSocketPeer.STATE_CLOSED
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

var _currently_connected_client_names: Array[String] = []

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, currently_connected_client_names: Array[String])
signal client_left_lobby(client_name: String, currently_connected_client_names: Array[String])

signal received_connection_message(message: 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:
	_socket.poll()
	_new_status = _socket.get_ready_state()
	if not _processed_status == _new_status:
		match _new_status:
			WebSocketPeer.STATE_OPEN:
				print("open")
				_stop_thread = false
				#_thread = Thread.new()
				#_thread.start(_listen_for_data)
				connected_to_server.emit()
				connection_status_changed.emit(ConnectionStatus.LOBBYLESS)
			WebSocketPeer.STATE_CONNECTING:
				print("connecting")
				connection_status_changed.emit(ConnectionStatus.ATTEMPTING_CONNECTION)
			WebSocketPeer.STATE_CLOSING:
				print("closing")
				pass
			WebSocketPeer.STATE_CLOSED:
				print("closed")
				#_clean_up_thread()
				connection_status_changed.emit(ConnectionStatus.DISCONNECTED)
			
		_processed_status = _new_status
	
	if _processed_status == WebSocketPeer.STATE_OPEN:
		while _socket.get_available_packet_count():
			cached_response = _socket.get_packet().get_string_from_utf8()
			print(cached_response)
			#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 _listen_for_data() -> void:
	while true:
		if _socket.get_available_packet_count():
			cached_response = _socket.get_packet().get_string_from_utf8()
			print(cached_response)
			if cached_response.ends_with("}"):
				_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_response":
			_handle_join(data)
		"client_joined_lobby":
			_currently_connected_client_names.assign(data["connected_client_names"])
			client_joined_lobby.emit.call_deferred(data["new_client_name"], _currently_connected_client_names)
			print(_currently_connected_client_names)
		"leave_lobby_request":
			leave_lobby()
		"leave_lobby":
			if data["status"] == "ok":
				client_left_lobby.emit.call_deferred(data["client_name"])
		"client_left_lobby":
			_currently_connected_client_names.assign(data["connected_client_names"])
			print(_currently_connected_client_names)
			client_left_lobby.emit.call_deferred(data["client_name"], _currently_connected_client_names)
		"receive_chat_message":
			received_chat_message.emit.call_deferred(data["client_name"], data["message"])

func _handle_join(data) -> void:
	match data["status"]:
		"lobby_not_found":
			received_connection_message.emit.call_deferred("Could not join; lobby does not exist")
			connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)
		"lobby_full":
			received_connection_message.emit.call_deferred("Could not join; lobby is full")
			connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)
		"ok":
			_client_id = data["client_id"]
			connected_to_lobby.emit.call_deferred(_lobby_id)
			connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)

func  _exit_tree() -> void:
	disconnect_from_server()

func connect_to_server(text: String) -> void:
	var err = _socket.connect_to_url(text)
	if err != OK:
		print("didn't work!")

func disconnect_from_server() -> void:
	_socket.close()
	disconnected_from_server.emit()
	connection_status_changed.emit(ConnectionStatus.DISCONNECTED)

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))
	connection_status_changed.emit.call_deferred(ConnectionStatus.ATTEMPTING_JOIN)

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:
	_socket.send_text(message)