1 files changed, 31 insertions, 31 deletions

diff --git a/webapp/src/bridge_engine.rs b/webapp/src/bridge_engine.rs
index b13d715..0552d3f 100644
--- a/webapp/src/bridge_engine.rs
+++ b/webapp/src/bridge_engine.rs
@@ -59,19 +59,19 @@ impl Trick {
 }
 
 #[derive(PartialEq, Eq, Debug, Clone)]
-pub struct PlayTurn {
+pub struct TurnInPlay {
     trick: Trick,
 }
 
 #[derive(PartialEq, Eq, Debug)]
-pub enum PlayResult {
-    InProgress(PlayTurn),
+pub enum TurnInPlayResult {
+    InProgress(TurnInPlay),
     Trick(Trick),
 }
 
-impl PlayTurn {
-    pub fn new(p: Player) -> PlayTurn {
-        PlayTurn {
+impl TurnInPlay {
+    pub fn new(p: Player) -> TurnInPlay {
+        TurnInPlay {
             trick: Trick {
                 leader: p,
                 cards_played: Vec::with_capacity(4),
@@ -87,12 +87,12 @@ impl PlayTurn {
         &self.trick.cards_played[..]
     }
 
-    pub fn play(mut self: PlayTurn, card: Card) -> PlayResult {
+    pub fn play(mut self: TurnInPlay, card: Card) -> TurnInPlayResult {
         self.trick.cards_played.push(card);
         if self.trick.cards_played.len() >= 4 {
-            return PlayResult::Trick(self.trick);
+            return TurnInPlayResult::Trick(self.trick);
         }
-        PlayResult::InProgress(self)
+        TurnInPlayResult::InProgress(self)
     }
 
     pub fn next_player(&self) -> Player {
@@ -101,28 +101,28 @@ impl PlayTurn {
 }
 
 #[derive(Clone, Debug)]
-pub struct PlayingDeal {
+pub struct DealInPlay {
     deal: Deal,
     tricks_played: Vec<Trick>,
-    in_progress: PlayTurn,
+    in_progress: TurnInPlay,
 }
 
 #[derive(Debug)]
-pub enum PlayingDealResult {
-    InProgress(PlayingDeal),
+pub enum DealInPlayResult {
+    InProgress(DealInPlay),
     PlayFinished(Vec<Trick>),
 }
 
-impl PlayingDeal {
-    pub fn new(leader: Player, deal: Deal) -> PlayingDeal {
-        PlayingDeal {
+impl DealInPlay {
+    pub fn new(leader: Player, deal: Deal) -> DealInPlay {
+        DealInPlay {
             deal,
             tricks_played: Vec::with_capacity(13),
-            in_progress: PlayTurn::new(leader),
+            in_progress: TurnInPlay::new(leader),
         }
     }
 
-    pub fn trick_in_play(&self) -> &PlayTurn {
+    pub fn trick_in_play(&self) -> &TurnInPlay {
         &self.in_progress
     }
 
@@ -130,7 +130,7 @@ impl PlayingDeal {
         &self.deal
     }
 
-    pub fn play(mut self: Self, card: Card) -> Result<PlayingDealResult, anyhow::Error> {
+    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);
 
@@ -146,12 +146,12 @@ impl PlayingDeal {
         player_cards.remove(i);
 
         Ok(match self.in_progress.play(card) {
-            PlayResult::InProgress(turn) => PlayingDealResult::InProgress(Self {
+            TurnInPlayResult::InProgress(turn) => DealInPlayResult::InProgress(Self {
                 in_progress: turn,
                 ..self
             }),
-            PlayResult::Trick(trick) => PlayingDealResult::InProgress(Self {
-                in_progress: PlayTurn::new(trick.winner()),
+            TurnInPlayResult::Trick(trick) => DealInPlayResult::InProgress(Self {
+                in_progress: TurnInPlay::new(trick.winner()),
                 tricks_played: {
                     let mut tricks = self.tricks_played;
                     tricks.push(trick);
@@ -588,16 +588,16 @@ mod tests {
         assert_eq!(Player::South, Player::South.many_next(4 * 1234567890));
     }
 
-    fn as_turn(p: PlayResult) -> PlayTurn {
-        if let PlayResult::InProgress(t) = p {
+    fn as_turn(p: TurnInPlayResult) -> TurnInPlay {
+        if let TurnInPlayResult::InProgress(t) = p {
             t
         } else {
             panic!("expected PlayResult::InProgress(): {:?}", p);
         }
     }
 
-    fn as_trick(p: PlayResult) -> Trick {
-        if let PlayResult::Trick(t) = p {
+    fn as_trick(p: TurnInPlayResult) -> Trick {
+        if let TurnInPlayResult::Trick(t) = p {
             t
         } else {
             panic!("expected PlayResult::Trick(): {:?}", p);
@@ -606,7 +606,7 @@ mod tests {
 
     #[test]
     fn play_turn() {
-        let turn = PlayTurn::new(Player::South);
+        let turn = TurnInPlay::new(Player::South);
         assert_eq!(turn.next_player(), Player::South);
         let turn = as_turn(turn.play("♣4".parse().unwrap()));
         assert_eq!(turn.next_player(), Player::West);
@@ -653,10 +653,10 @@ mod tests {
         }
     }
 
-    fn as_playing_hand(result: PlayingDealResult) -> PlayingDeal {
+    fn as_playing_hand(result: DealInPlayResult) -> DealInPlay {
         match result {
-            PlayingDealResult::InProgress(r) => r,
-            PlayingDealResult::PlayFinished(_) => {
+            DealInPlayResult::InProgress(r) => r,
+            DealInPlayResult::PlayFinished(_) => {
                 panic!("expected PlayingDealResult::InProgress(): {:?}", result)
             }
         }
@@ -664,7 +664,7 @@ mod tests {
 
     #[test]
     fn play_hand() {
-        let deal = PlayingDeal::new(Player::West, mini_deal());
+        let deal = DealInPlay::new(Player::West, mini_deal());
         assert_eq!(deal.tricks_played, vec!());
         {
             let err = deal.clone().play(mkcard("♥9")).unwrap_err().to_string();