Add `TableView` for representing player hands in the app

1 files changed, 52 insertions, 3 deletions

diff --git a/protocol/src/bridge_engine.rs b/protocol/src/bridge_engine.rs
index e9c09f6..261f650 100644
--- a/protocol/src/bridge_engine.rs
+++ b/protocol/src/bridge_engine.rs
@@ -11,7 +11,7 @@ use strum_macros::{EnumCount as EnumCountMacro, EnumIter, FromRepr};
 
 pub const SUIT_DISPLAY_ORDER: [Suit; 4] = [Suit::Diamond, Suit::Club, Suit::Heart, Suit::Spade];
 
-#[derive(PartialEq, Eq, Clone, Copy, Debug, FromRepr, EnumCountMacro, Serialize, Deserialize)]
+#[derive(PartialEq, Eq, Clone, Copy, Debug, FromRepr, EnumCountMacro, Serialize, Deserialize, EnumIter)]
 #[repr(u8)]
 pub enum Player {
     West = 0,
@@ -38,7 +38,16 @@ impl Player {
         }
     }
 
-    pub fn get_cards<'a>(&self, deal: &'a mut Deal) -> &'a mut Vec<Card> {
+    pub fn get_cards<'a>(&self, deal: &'a Deal) -> &'a Vec<Card> {
+        match self {
+            Self::West => &deal.west,
+            Self::North => &deal.north,
+            Self::East => &deal.east,
+            Self::South => &deal.south,
+        }
+    }
+
+    pub fn get_cards_mut<'a>(&self, deal: &'a mut Deal) -> &'a mut Vec<Card> {
         match self {
             Self::West => &mut deal.west,
             Self::North => &mut deal.north,
@@ -147,7 +156,7 @@ impl DealInPlay {
 
     pub fn play(mut self: Self, card: Card) -> Result<DealInPlayResult, anyhow::Error> {
         let player = self.in_progress.next_player();
-        let player_cards = player.get_cards(&mut self.deal);
+        let player_cards = player.get_cards_mut(&mut self.deal);
 
         info!(
             "Next player is {:?}, playing card {} from {:?}",
@@ -484,6 +493,7 @@ pub enum GameState {
         bidding: Bidding,
     },
     Play {
+        dealer: Player,
         playing_deal: DealInPlay,
         contract: Contract,
         bidding: Bidding,
@@ -498,6 +508,14 @@ impl GameState {
             Self::Play { playing_deal, .. } => &playing_deal.deal(),
         }
     }
+
+    pub fn dealer(&self) -> Player {
+        match *self {
+            Self::Bidding { dealer, .. } => dealer,
+            Self::PassedOut { dealer, .. } => dealer,
+            Self::Play { dealer, .. } => dealer,
+        }
+    }
 }
 
 pub fn deal() -> Deal {
@@ -507,6 +525,23 @@ pub fn deal() -> Deal {
     deal
 }
 
+#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct TableView {
+    dealer: Player,
+    player_position: Player,
+    hand: Vec<Card>,
+}
+
+impl TableView {
+    pub fn from_game_state(game_state: &GameState, player_position: Player) -> Self {
+        TableView {
+            dealer: game_state.dealer(),
+            player_position,
+            hand: player_position.get_cards(game_state.deal()).clone(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -711,6 +746,20 @@ mod tests {
         }
     }
 
+    #[test]
+    fn table_view() {
+        crate::tests::test_setup();
+        let game_state = GameState::Bidding { dealer: Player::East, deal: mini_deal() };
+        info!("Game state: {game_state:?}");
+        for p in Player::iter() {
+            info!("Testing view for {p:?}");
+            let view = TableView::from_game_state(&game_state, p);
+            assert_eq!(view.player_position, p);
+            assert_eq!(view.dealer, Player::East);
+            assert_eq!(&view.hand, p.get_cards_mut(&mut mini_deal()));
+        }
+    }
+
     fn as_playing_hand(result: DealInPlayResult) -> DealInPlay {
         match result {
             DealInPlayResult::InProgress(r) => r,