324 lines
10 KiB
GDScript
324 lines
10 KiB
GDScript
class_name WebClient
|
|
extends Node
|
|
|
|
## Sender tag for system messages displayed in the chat.
|
|
const SENDER_SYSTEM: String = "SYSTEM"
|
|
|
|
## Server address to connect to.
|
|
## Local: 127.0.0.1:9974
|
|
## Remote: wss://denizk0461.dev/magsrv
|
|
const SERVER_ADDRESS: String = "127.0.0.1:9974"
|
|
|
|
var _socket := WebSocketPeer.new()
|
|
|
|
var _new_status: int = WebSocketPeer.STATE_CLOSED
|
|
var _processed_status: int = -1
|
|
|
|
var _lobby_id: String
|
|
var _own_client_data: ClientData = ClientData.new()
|
|
var _playing_order: Array[ClientData]
|
|
#var _client_id: String
|
|
#var _client_name: String
|
|
var _is_host: bool
|
|
|
|
var received_data: Array
|
|
var cached_response: String
|
|
|
|
var _is_first_play: bool = false
|
|
|
|
|
|
|
|
|
|
@export var chat_panel: ChatPanel
|
|
|
|
signal connected_to_lobby(lobby_id: String, client_id: String)
|
|
|
|
signal connected_clients_changed(connected_clients: Array[ClientData])
|
|
|
|
signal received_chat_message(client_name: String, message: String)
|
|
|
|
signal connection_status_changed(new_status: ConnectionStatus)
|
|
|
|
# This signal is messy as fuck
|
|
signal client_order_received(playing_order: Array[ClientData])
|
|
|
|
signal client_played_card(client_id: String, card_id: int)
|
|
signal received_expected_bet(client_id: String, expected_bet: int)
|
|
signal new_round_started()
|
|
signal cards_received(cards: Dictionary)
|
|
signal trump_received(trump_id: int)
|
|
signal received_bet_request(disallowed_bet: int, current_round: int)
|
|
signal received_win()
|
|
signal received_winning_client(client_id: String)
|
|
signal notify_play_card_request()
|
|
signal reset_first_card()
|
|
signal received_first_card(card_id: int)
|
|
signal received_played_card(client_id: String, card_id: int)
|
|
signal received_play_winner_request()
|
|
signal received_end_game_request()
|
|
signal request_next_play()
|
|
signal request_next_round()
|
|
|
|
enum ConnectionStatus {
|
|
DISCONNECTED,
|
|
ATTEMPTING_CONNECTION,
|
|
LOBBYLESS, # == connected
|
|
ATTEMPTING_JOIN,
|
|
JOINED,
|
|
}
|
|
|
|
func _ready() -> void:
|
|
connect_to_server(SERVER_ADDRESS)
|
|
|
|
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:
|
|
chat_panel.put_chat_message(SENDER_SYSTEM, "You successfully connected to the server.")
|
|
connection_status_changed.emit(ConnectionStatus.LOBBYLESS)
|
|
WebSocketPeer.STATE_CONNECTING:
|
|
connection_status_changed.emit(ConnectionStatus.ATTEMPTING_CONNECTION)
|
|
WebSocketPeer.STATE_CLOSING:
|
|
pass
|
|
WebSocketPeer.STATE_CLOSED:
|
|
chat_panel.put_chat_message(SENDER_SYSTEM, "You lost connection to the server.")
|
|
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()
|
|
if cached_response.ends_with("}"):
|
|
_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"]:
|
|
"created_lobby":
|
|
_lobby_id = data["lobby_id"]
|
|
_own_client_data.client_id = data["client_id"]
|
|
chat_panel.put_chat_message(SENDER_SYSTEM, "You created and connected to lobby {lobby_id} with client ID {client_id}.".format({
|
|
"lobby_id": _lobby_id,
|
|
"client_id": _own_client_data.client_id,
|
|
}))
|
|
connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)
|
|
connected_to_lobby.emit.call_deferred(_lobby_id, _own_client_data.client_id)
|
|
"join_lobby_response":
|
|
_handle_join(data)
|
|
"joined_lobby":
|
|
_playing_order = _get_client_data(data)
|
|
connected_clients_changed.emit.call_deferred(_playing_order)
|
|
chat_panel.put_chat_message(SENDER_SYSTEM, "{client_name} joined the lobby.".format({
|
|
"client_name": data["client_name"],
|
|
}))
|
|
"leave_lobby_request":
|
|
leave_lobby()
|
|
"left_lobby":
|
|
_playing_order = _get_client_data(data)
|
|
connected_clients_changed.emit.call_deferred(_playing_order)
|
|
chat_panel.put_chat_message(SENDER_SYSTEM, "{client_name} left the lobby.".format({
|
|
"client_name": data["client_name"],
|
|
}))
|
|
|
|
## A chat message has been received
|
|
"receive_chat_message":
|
|
# Relay message to be displayed in the chat panel
|
|
chat_panel.put_chat_message(data["client_name"], data["message"])
|
|
|
|
"round_started":
|
|
if data["current_round"] == 1:
|
|
var playing_order: Array[String] = []
|
|
playing_order.assign(data["playing_order"])
|
|
client_order_received.emit.call_deferred(_playing_order)
|
|
|
|
var received_cards = data["cards"]
|
|
new_round_started.emit.call_deferred()
|
|
cards_received.emit.call_deferred(received_cards)
|
|
trump_received.emit.call_deferred(data["trump"])
|
|
"client_submitted_bet":
|
|
received_expected_bet.emit.call_deferred(
|
|
data["client_id"],
|
|
data["bet"],
|
|
)
|
|
"request_bet":
|
|
if data["client_id"] == _own_client_data.client_id:
|
|
received_bet_request.emit.call_deferred(data["disallowed_bet"], data["round"])
|
|
else:
|
|
pass # display currently betting person
|
|
"begin_playing_cards":
|
|
# all players know it's time to play
|
|
print(data)
|
|
_is_first_play = true
|
|
reset_first_card.emit.call_deferred()
|
|
"request_card":
|
|
# individual player asked to play card
|
|
notify_play_card_request.emit.call_deferred()
|
|
"begin_next_play":
|
|
print("beginning next play!")
|
|
_is_first_play = true
|
|
reset_first_card.emit.call_deferred()
|
|
"play_card":
|
|
print(data)
|
|
#client_played_card.emit.call_deferred(data["client_id"], data["played_card"])
|
|
"determine_play_winner_request": # single card go-around
|
|
received_play_winner_request.emit.call_deferred()
|
|
"end_game_request":
|
|
received_end_game_request.emit.call_deferred()
|
|
"client_played_card":
|
|
print("RECEIVED FOLLOWING CARD ID: " + str(data["played_card"]))
|
|
if _is_first_play:
|
|
print("set first card")
|
|
received_first_card.emit.call_deferred(data["played_card"])
|
|
if not CardManager.get_card_color(data["played_card"]) == Card.CardColor.WHITE:
|
|
_is_first_play = false
|
|
received_played_card.emit.call_deferred(data["client_id"], data["played_card"])
|
|
"client_won_play":
|
|
if data["client_id"] == _own_client_data.client_id:
|
|
received_win.emit.call_deferred()
|
|
received_winning_client.emit.call_deferred(data["client_id"])
|
|
|
|
func _get_client_data(data) -> Array[ClientData]:
|
|
var connected_client_ids = []
|
|
connected_client_ids.assign(data["connected_client_ids"])
|
|
var connected_client_names = []
|
|
connected_client_names.assign(data["connected_client_names"])
|
|
|
|
var order: Array[ClientData] = []
|
|
for index in connected_client_ids.size():
|
|
order.append(ClientData.new(connected_client_ids[index], connected_client_names[index]))
|
|
|
|
return order
|
|
|
|
func _handle_join(data) -> void:
|
|
match data["status"]:
|
|
"lobby_not_found":
|
|
chat_panel.put_chat_message(SENDER_SYSTEM, "Could not join; lobby does not exist.")
|
|
connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)
|
|
"lobby_full":
|
|
chat_panel.put_chat_message(SENDER_SYSTEM, "Could not join; lobby is full.")
|
|
connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)
|
|
"ok":
|
|
_own_client_data.client_id = data["client_id"]
|
|
chat_panel.put_chat_message(SENDER_SYSTEM, "You connected to lobby {lobby_id} with client ID {client_id}.".format({
|
|
"lobby_id": _lobby_id,
|
|
"client_id": _own_client_data.client_id,
|
|
}))
|
|
connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)
|
|
connected_to_lobby.emit.call_deferred(_lobby_id, _own_client_data.client_id)
|
|
|
|
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()
|
|
chat_panel.put_chat_message(SENDER_SYSTEM, "You were disconnected from the server.")
|
|
connection_status_changed.emit(ConnectionStatus.DISCONNECTED)
|
|
|
|
func send_chat_message(message: String) -> void:
|
|
#_send_message(TCPMessages.send_chat_message(_lobby_id, _client_id, message))
|
|
pass
|
|
|
|
func start_game() -> void:
|
|
_send_message(JSON.stringify({
|
|
"response": "start_game",
|
|
"lobby_id": _lobby_id,
|
|
"cards": CardManager.get_shuffled_cards(_playing_order, 1),
|
|
}))
|
|
|
|
func start_next_play() -> void:
|
|
_send_message(JSON.stringify({
|
|
"response": "start_next_play",
|
|
"lobby_id": _lobby_id,
|
|
}))
|
|
|
|
func start_next_round(round_count: int) -> void:
|
|
_send_message(JSON.stringify({
|
|
"response": "start_next_round",
|
|
"lobby_id": _lobby_id,
|
|
"round": round_count,
|
|
"cards": CardManager.get_shuffled_cards(_playing_order, round_count),
|
|
}))
|
|
|
|
func end_game() -> void:
|
|
_send_message(JSON.stringify({
|
|
"response": "end_game",
|
|
"lobby_id": _lobby_id,
|
|
}))
|
|
|
|
func play_card(card_id: int) -> void:
|
|
_send_message(JSON.stringify({
|
|
"response": "play_card",
|
|
"lobby_id": _lobby_id,
|
|
"client_id": _own_client_data.client_id,
|
|
"played_card": card_id,
|
|
}))
|
|
|
|
func submit_bet(bet: int, current_round: int) -> void:
|
|
_send_message(JSON.stringify({
|
|
"response": "submit_bet",
|
|
"lobby_id": _lobby_id,
|
|
"client_id": _own_client_data.client_id,
|
|
"round": current_round,
|
|
"bet": bet,
|
|
}))
|
|
|
|
func submit_play_winner(winning_client_id: String) -> void:
|
|
_send_message(JSON.stringify({
|
|
"response": "submit_play_winner",
|
|
"lobby_id": _lobby_id,
|
|
"client_id": winning_client_id,
|
|
}))
|
|
request_next_play.emit.call_deferred()
|
|
#request_next_round.emit.call_deferred()
|
|
|
|
func _send_message(message: String) -> void:
|
|
_socket.send_text(message)
|
|
|
|
|
|
|
|
|
|
func create_lobby(client_name: String) -> void:
|
|
_own_client_data.client_name = client_name
|
|
_send_message(PeerMessages.create_lobby(client_name))
|
|
|
|
func join_lobby(lobby_id: String, client_name: String) -> void:
|
|
_lobby_id = lobby_id
|
|
_own_client_data.client_name = client_name
|
|
_send_message(PeerMessages.join_lobby(_lobby_id, client_name))
|
|
connection_status_changed.emit.call_deferred(ConnectionStatus.ATTEMPTING_JOIN)
|
|
|
|
func leave_lobby() -> void:
|
|
_send_message(PeerMessages.leave_lobby(_lobby_id, _own_client_data.client_id))
|
|
|
|
connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)
|
|
|
|
# Notify user about disconnect
|
|
chat_panel.put_chat_message(SENDER_SYSTEM, "You were disconnected from the lobby {lobby_id}.".format({
|
|
"lobby_id": _lobby_id,
|
|
}))
|
|
|
|
# Reset saved data about lobby and client
|
|
_lobby_id = ""
|
|
_own_client_data = ClientData.new()
|
|
|
|
func _on_chat_panel_message_sent(message: String) -> void:
|
|
_send_message(PeerMessages.send_chat_message(_lobby_id, _own_client_data.client_id, message))
|