fixed some things

cards/card_manager.gd

@@ -7,17 +7,17 @@ enum CardStyle {
 	STICKMAN,
 }
 
-func get_shuffled_cards(client_ids: Array[String], cards_to_pick: int) -> Dictionary: # Dictionary[String, Array[int]]
+func get_shuffled_cards(connected_clients: Array[ClientData], cards_to_pick: int) -> Dictionary: # Dictionary[String, Array[int]]
 	var dict: Dictionary = {}
 	var deck: Array[int] = full_deck.keys()
 	deck.shuffle()
 	var card_index = 0
-	for client_id in client_ids:
+	for client in connected_clients:
 		var player_deck: Array[int] = []
 		for j in cards_to_pick:
 			player_deck.append(deck[card_index])
 			card_index += 1
-		dict[client_id] = player_deck
+		dict[client.client_id] = player_deck
 	
 	# Add trump card, if there are cards left in the deck
 	if card_index == 60:

components/client_interface.gd

@@ -62,11 +62,13 @@ func _on_web_client_tcp_connection_status_changed(new_status: WebClient.Connecti
 			name_input.editable = false
 			lobby_code_input.editable = false
 
-func _update_connected_players(new_client_names: Array[String]) -> void:
+func _update_connected_players(connected_clients: Array[ClientData]) -> void:
-	connected_players_label.text = "Connected Players:\n" + "\n".join(new_client_names)
+	connected_players_label.text = "Connected Players:"
+	for client in connected_clients:
+		connected_players_label.text += "\n" + client.client_name
 
 func _on_web_client_connected_to_lobby(lobby_id: String, client_id: String) -> void:
 	lobby_code_input.text = lobby_id
 
-func _on_web_client_connected_clients_changed(connected_client_names: Array[String]) -> void:
+func _on_web_client_connected_clients_changed(connected_clients: Array[ClientData]) -> void:
-	_update_connected_players(connected_client_names)
+	_update_connected_players(connected_clients)

components/web_client.gd

@@ -15,8 +15,10 @@ var _new_status: int = WebSocketPeer.STATE_CLOSED
 var _processed_status: int = -1
 
 var _lobby_id: String
-var _client_id: String
+var _own_client_data: ClientData = ClientData.new()
-var _client_name: String
+var _playing_order: Array[ClientData]
+#var _client_id: String
+#var _client_name: String
 var _is_host: bool
 
 var received_data: Array
@@ -24,9 +26,6 @@ var cached_response: String
 
 var _is_first_play: bool = false
 
-var _connected_client_ids: Array[String] = []
-var _connected_client_names: Array[String] = []
-
 
 
 
@@ -34,14 +33,14 @@ var _connected_client_names: Array[String] = []
 
 signal connected_to_lobby(lobby_id: String, client_id: String)
 
-signal connected_clients_changed(connected_client_names: Array[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(client_ids: Array[String], client_ids_playing_order: Array[String], client_names: Array[String])
+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)
@@ -110,28 +109,26 @@ func _handle_response(response: String) -> void:
 	match data["response"]:
 		"created_lobby":
 			_lobby_id = data["lobby_id"]
-			_client_id = data["client_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": _client_id,
+				"client_id": _own_client_data.client_id,
 			}))
 			connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)
-			connected_to_lobby.emit.call_deferred(_lobby_id, _client_id)
+			connected_to_lobby.emit.call_deferred(_lobby_id, _own_client_data.client_id)
 		"join_lobby_response":
 			_handle_join(data)
 		"joined_lobby":
-			_connected_client_ids.assign(data["connected_client_ids"])
+			_playing_order = _get_client_data(data)
-			_connected_client_names.assign(data["connected_client_names"])
+			connected_clients_changed.emit.call_deferred(_playing_order)
-			connected_clients_changed.emit.call_deferred(_connected_client_names)
 			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":
-			_connected_client_ids.assign(data["connected_client_ids"])
+			_playing_order = _get_client_data(data)
-			_connected_client_names.assign(data["connected_client_names"])
+			connected_clients_changed.emit.call_deferred(_playing_order)
-			connected_clients_changed.emit.call_deferred(_connected_client_names)
 			chat_panel.put_chat_message(SENDER_SYSTEM, "{client_name} left the lobby.".format({
 				"client_name": data["client_name"],
 			}))
@@ -145,7 +142,7 @@ func _handle_response(response: String) -> void:
 			if data["current_round"] == 1:
 				var playing_order: Array[String] = []
 				playing_order.assign(data["playing_order"])
-				client_order_received.emit.call_deferred(playing_order, _connected_client_ids, _connected_client_names)
+				client_order_received.emit.call_deferred(_playing_order)
 			
 			var received_cards = data["cards"]
 			new_round_started.emit.call_deferred()
@@ -157,7 +154,10 @@ func _handle_response(response: String) -> void:
 				data["bet"],
 			)
 		"request_bet":
-			received_bet_request.emit.call_deferred(data["disallowed_bet"], data["round"])
+			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)
@@ -186,10 +186,22 @@ func _handle_response(response: String) -> void:
 					_is_first_play = false
 			received_played_card.emit.call_deferred(data["client_id"], data["played_card"])
 		"client_won_play":
-			if data["client_id"] == _client_id:
+			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":
@@ -199,13 +211,13 @@ func _handle_join(data) -> void:
 			chat_panel.put_chat_message(SENDER_SYSTEM, "Could not join; lobby is full.")
 			connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)
 		"ok":
-			_client_id = data["client_id"]
+			_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": _client_id,
+				"client_id": _own_client_data.client_id,
 			}))
 			connection_status_changed.emit.call_deferred(ConnectionStatus.JOINED)
-			connected_to_lobby.emit.call_deferred(_lobby_id, _client_id)
+			connected_to_lobby.emit.call_deferred(_lobby_id, _own_client_data.client_id)
 
 func  _exit_tree() -> void:
 	disconnect_from_server()
@@ -228,7 +240,7 @@ func start_game() -> void:
 	_send_message(JSON.stringify({
 		"response": "start_game",
 		"lobby_id": _lobby_id,
-		"cards": CardManager.get_shuffled_cards(_connected_client_ids, 1),
+		"cards": CardManager.get_shuffled_cards(_playing_order, 1),
 	}))
 
 func start_next_play() -> void:
@@ -242,7 +254,7 @@ func start_next_round(round_count: int) -> void:
 		"response": "start_next_round",
 		"lobby_id": _lobby_id,
 		"round": round_count,
-		"cards": CardManager.get_shuffled_cards(_connected_client_ids, round_count),
+		"cards": CardManager.get_shuffled_cards(_playing_order, round_count),
 	}))
 
 func end_game() -> void:
@@ -255,7 +267,7 @@ func play_card(card_id: int) -> void:
 	_send_message(JSON.stringify({
 		"response": "play_card",
 		"lobby_id": _lobby_id,
-		"client_id": _client_id,
+		"client_id": _own_client_data.client_id,
 		"played_card": card_id,
 	}))
 
@@ -263,7 +275,7 @@ func submit_bet(bet: int, current_round: int) -> void:
 	_send_message(JSON.stringify({
 		"response": "submit_bet",
 		"lobby_id": _lobby_id,
-		"client_id": _client_id,
+		"client_id": _own_client_data.client_id,
 		"round": current_round,
 		"bet": bet,
 	}))
@@ -284,17 +296,17 @@ func _send_message(message: String) -> void:
 
 
 func create_lobby(client_name: String) -> void:
-	_client_name = client_name
+	_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
-	_client_name = client_name
+	_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, _client_id))
+	_send_message(PeerMessages.leave_lobby(_lobby_id, _own_client_data.client_id))
 	
 	connection_status_changed.emit.call_deferred(ConnectionStatus.LOBBYLESS)
 	
@@ -305,8 +317,7 @@ func leave_lobby() -> void:
 	
 	# Reset saved data about lobby and client
 	_lobby_id = ""
-	_client_id = ""
+	_own_client_data = ClientData.new()
-	_client_name = ""
 
 func _on_chat_panel_message_sent(message: String) -> void:
-	_send_message(PeerMessages.send_chat_message(_lobby_id, _client_id, message))
+	_send_message(PeerMessages.send_chat_message(_lobby_id, _own_client_data.client_id, message))

elements/client_data.gd

@@ -0,0 +1,12 @@
+class_name ClientData
+extends Resource
+
+@export var client_id: String
+@export var client_name: String
+
+func _init(
+	client_id: String = "",
+	client_name: String = "",
+) -> void:
+	self.client_id = client_id
+	self.client_name = client_name

elements/client_data.gd.uid

@@ -0,0 +1 @@
+uid://bv3udyyv7j2f6

elements/player_hand.gd

@@ -30,6 +30,8 @@ var _allow_clicking_cards: bool = false
 var _trump_id: int = -1
 var _first_played_card_id: int = -1
 
+var _client_data: ClientData
+
 signal card_selected(card_id: int)
 signal card_played(card_id: int)
 
@@ -37,8 +39,9 @@ func _ready() -> void:
 	if hide_client_name:
 		name_label.hide()
 
-func set_player_name(player_name: String) -> void:
+func set_player_data(client_data: ClientData) -> void:
-	name_label.text = player_name
+	_client_data = client_data
+	name_label.text = _client_data.client_name
 
 func add_card(card: PlayingCard) -> void:
 	card_container.add_child(card)

environment_manager.gd

@@ -32,9 +32,11 @@ var _bets: Dictionary[String, Array] # Array[BetResult]
 var _plays: Array[Play]
 var _trump_id: int = -1
 
-func _on_web_client_tcp_client_order_received(client_ids: Array[String], client_ids_playing_order: Array[String], client_names: Array[String]) -> void:
+func _on_web_client_tcp_client_order_received(playing_order: Array[ClientData]) -> void:
 	var marker_positions: Array[Marker3D]
-	match client_ids.size():
+	var client_ids: Array[String] = []
+	client_ids.assign(playing_order.map(func(a: ClientData): return a.client_id))
+	match playing_order.size():
 		3:
 			marker_positions = hand_markers_3
 		4:
@@ -71,7 +73,12 @@ func _on_web_client_tcp_client_order_received(client_ids: Array[String], client_
 			hand = own_player_hand
 		else:
 			hand = player_hand_scene.instantiate()
-			hand.set_player_name(client_names[client_ids_playing_order.find(client_ids[index])])
+			var client_data: ClientData
+			for client in playing_order:
+				if client.client_id == client_ids[index]:
+					client_data = client
+					break
+			hand.set_player_data(client_data) # also for own hand?
 			marker_positions[index - 1].add_child(hand)
 		
 		hand_associations[client_ids[index]] = hand
@@ -92,7 +99,7 @@ func _on_web_client_tcp_received_play_winner_request() -> void:
 	if not $"../HBoxContainer/GameUI"._is_host:
 		return
 	
-	await get_tree().create_timer(1.5).timeout
+	await get_tree().create_timer(1.0).timeout
 	
 	var card_ids: Array[int] = []
 	card_ids.assign(_plays.map(func(p: Play): return p.card_id))

game_client.gd

@@ -102,5 +102,5 @@ func _on_web_client_tcp_request_next_play() -> void:
 	_start_next_play()
 
 
-func _on_web_client_connected_clients_changed(connected_client_names: Array[String]) -> void:
+func _on_web_client_connected_clients_changed(connected_clients: Array[ClientData]) -> void:
-	_update_player_count(connected_client_names.size())
+	_update_player_count(connected_clients.size())

server_tcp.py

@@ -198,11 +198,12 @@ class LobbyManager:
             )
     
     async def request_bet(self, lobby_id, client_id, disallowed_bet) -> None:
-        await self.send_message(
+        await self.broadcast_message(
             lobby_id,
-            client_id,
+            # client_id,
             json.dumps({
                 "response": "request_bet",
+                "client_id": client_id,
                 "disallowed_bet": disallowed_bet,
                 "round": self.get_lobby(lobby_id).current_round,
             })
@@ -451,6 +452,7 @@ async def process_input(message: str, websocket) -> None:
             lobby_id,
             json.dumps({
                 "response": "begin_next_play",
+                "playing_order": lobby_manager.get_lobby(lobby_id).current_playing_order,
             }),
         )
         await lobby_manager.send_message(