I'm human

backend/src/blackjack/blackjack_game.rs

@@ -190,6 +190,10 @@ impl BlackjackGame {
             }
             (GameState::Over, PlayMoves::Deal { players })
             | (GameState::Starting, PlayMoves::Deal { players }) => {
+                // Reset everything
+                self.dealer_hand = Hand::new();
+                self.players = Vec::new();
+
                 // Create players
                 for _ in 0..players {
                     self.players.push(Player::new());

backend/src/cards/card_suit.rs

@@ -4,9 +4,13 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Copy, Serialize, Deserialize)]
 pub enum CardSuit {
+    #[serde(rename = "S")]
     Spades,
+    #[serde(rename = "C")]
     Clubs,
+    #[serde(rename = "H")]
     Hearts,
+    #[serde(rename = "D")]
     Diamonds,
 }
 

backend/src/cards/hand.rs

@@ -122,7 +122,6 @@ impl<'de> Deserialize<'de> for Hand {
     where
         D: Deserializer<'de>,
     {
-        // Deserialize into a Vec directly and wrap it in MyVecWrapper
         let cards = Vec::<Card>::deserialize(deserializer)?;
         Ok(Hand { cards })
     }

backend/src/webserver.rs

@@ -6,10 +6,15 @@ use rocket::{
     Build, Rocket, State,
 };
 
-use crate::{blackjack::{blackjack_game::BlackjackGame, gamestate::GameState, play_moves::PlayMoves, player::Player}, cards::card::Card};
+use crate::{
+    blackjack::{
+        blackjack_game::BlackjackGame, gamestate::GameState, play_moves::PlayMoves, player::Player,
+    },
+    cards::{card::Card, hand::Hand},
+};
 
 #[get("/state")]
-fn get_state(state: &State<MyState>) -> Json<GamestateJson> {
+fn get_state(state: &State<MyState>) -> Json<ExtendedGameState> {
     Json(gamestate_as_json(&state.game.lock().unwrap()))
 }
 
@@ -17,8 +22,8 @@ fn get_state(state: &State<MyState>) -> Json<GamestateJson> {
 fn post_move(
     state: &State<MyState>,
     request: Json<PlayMoves>,
-) -> Result<Json<GamestateJson>, Status> {
-    let action = request.0;
+) -> Result<Json<ExtendedGameState>, Status> {
+    let action = request.into_inner();
 
     if state.game.lock().unwrap().play(action) {
         Ok(Json(gamestate_as_json(&state.game.lock().unwrap())))
@@ -32,23 +37,35 @@ struct MyState {
 }
 
 #[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct GamestateJson {
-    state: GameState,
-    dealer_upcard: Option<Card>,
-    players: Vec<Player>,
+#[serde(tag = "type", rename_all = "camelCase", rename_all_fields = "camelCase")]
+enum ExtendedGameState {
+    Over {
+        dealer_hand: Hand,
+        players: Vec<Player>,
+    },
+    Playing {
+        dealer_upcard: Card,
+        player_turn: usize,
+        hand_turn: usize,
+        players: Vec<Player>,
+    },
+    Starting,
 }
 
-fn gamestate_as_json(game: &BlackjackGame) -> GamestateJson {
+fn gamestate_as_json(game: &BlackjackGame) -> ExtendedGameState {
     match game.get_state() {
-        GameState::Starting => GamestateJson {
-            state: *game.get_state(),
-            dealer_upcard: None,
-            players: Vec::new(),
+        GameState::Starting => ExtendedGameState::Starting,
+        GameState::Over => ExtendedGameState::Over {
+            dealer_hand: game.get_dealer_hand().clone(),
+            players: game.get_players().clone(),
         },
-        GameState::Over | GameState::PlayerTurn { .. } => GamestateJson {
-            state: *game.get_state(),
-            dealer_upcard: game.get_dealer_upcard().copied(),
+        GameState::PlayerTurn {
+            player_index,
+            hand_index,
+        } => ExtendedGameState::Playing {
+            dealer_upcard: *game.get_dealer_upcard().unwrap(),
+            player_turn: *player_index,
+            hand_turn: *hand_index,
             players: game.get_players().clone(),
         },
     }