Getr rid of TurnInPlayResult and use MoveResult instead

1 files changed, 11 insertions, 33 deletions

diff --git a/protocol/src/bridge_engine.rs b/protocol/src/bridge_engine.rs
index fb4efa7..0acdca9 100644
--- a/protocol/src/bridge_engine.rs
+++ b/protocol/src/bridge_engine.rs
@@ -3,7 +3,7 @@ use crate::{
     play_result::MoveResult,
 };
 use anyhow::{anyhow, bail};
-use log::{error, info};
+use log::info;
 use rand::{
     distributions::Standard,
     prelude::{Distribution, SliceRandom},
@@ -122,12 +122,6 @@ pub struct TurnInPlay {
     pub trick: Trick,
 }
 
-#[derive(PartialEq, Eq, Debug)]
-pub enum TurnInPlayResult {
-    InProgress(TurnInPlay),
-    Trick(Trick),
-}
-
 impl TurnInPlay {
     pub fn new(p: Player) -> TurnInPlay {
         TurnInPlay {
@@ -154,12 +148,12 @@ impl TurnInPlay {
         &self.trick.cards_played[..]
     }
 
-    pub fn play(mut self: TurnInPlay, card: Card) -> TurnInPlayResult {
+    pub fn play(mut self: TurnInPlay, card: Card) -> MoveResult<TurnInPlay, Trick> {
         self.trick.cards_played.push(card);
         if self.trick.cards_played.len() >= 4 {
-            return TurnInPlayResult::Trick(self.trick);
+            return MoveResult::Next(self.trick);
         }
-        TurnInPlayResult::InProgress(self)
+        MoveResult::Current(self)
     }
 
     pub fn current_player(&self) -> Player {
@@ -243,13 +237,13 @@ impl DealInPlay {
         player_cards.remove(i);
 
         Ok(match self.in_progress.play(card) {
-            TurnInPlayResult::InProgress(turn) => {
+            MoveResult::Current(turn) => {
                 DealInPlayResult::InProgress(Self {
                     in_progress: turn,
                     ..self
                 })
             }
-            TurnInPlayResult::Trick(trick) => {
+            MoveResult::Next(trick) => {
                 let trick_winner = trick.winner(self.trump_suit);
                 let mut tricks = self.tricks_played;
                 tricks.push(trick);
@@ -1156,33 +1150,17 @@ mod tests {
         assert_eq!(Player::South, Player::South.many_next(4 * 1234567890));
     }
 
-    fn as_turn(p: TurnInPlayResult) -> TurnInPlay {
-        if let TurnInPlayResult::InProgress(t) = p {
-            t
-        } else {
-            panic!("expected PlayResult::InProgress(): {:?}", p);
-        }
-    }
-
-    fn as_trick(p: TurnInPlayResult) -> Trick {
-        if let TurnInPlayResult::Trick(t) = p {
-            t
-        } else {
-            panic!("expected PlayResult::Trick(): {:?}", p);
-        }
-    }
-
     #[test]
     fn play_turn() {
         let turn = TurnInPlay::new(Player::South);
         assert_eq!(turn.current_player(), Player::South);
-        let turn = as_turn(turn.play("♣4".parse().unwrap()));
+        let turn = turn.play("♣4".parse().unwrap()).current().unwrap();
         assert_eq!(turn.current_player(), Player::West);
-        let turn = as_turn(turn.play("♥A".parse().unwrap()));
+        let turn = turn.play("♥A".parse().unwrap()).current().unwrap();
         assert_eq!(turn.current_player(), Player::North);
-        let turn = as_turn(turn.play("♣4".parse().unwrap()));
+        let turn = turn.play("♣4".parse().unwrap()).current().unwrap();
         assert_eq!(turn.current_player(), Player::East);
-        let trick = as_trick(turn.play("♣A".parse().unwrap()));
+        let trick = turn.play("♣A".parse().unwrap()).next().unwrap();
         assert_eq!(
             trick,
             Trick {
@@ -1199,7 +1177,7 @@ mod tests {
     fn lead_suit() {
         let turn = TurnInPlay::new(Player::South);
         assert_eq!(turn.suit(), None);
-        let turn = as_turn(turn.play("♣4".parse().unwrap()));
+        let turn = turn.play("♣4".parse().unwrap()).current().unwrap();
         assert_eq!(turn.suit(), Some("♣".parse().unwrap()));
     }