]> git.scottworley.com Git - pluta-lesnura/commitdiff
Coordinate to grant momentum to the next player master
authorScott Worley <scottworley@scottworley.com>
Tue, 18 Jul 2023 20:25:23 +0000 (13:25 -0700)
committerScott Worley <scottworley@scottworley.com>
Tue, 18 Jul 2023 20:25:23 +0000 (13:25 -0700)
src/lib.rs
src/main.rs

index c46aa7dcf18eeca8ec17f76e0732a3dd24db828a..45b7b4527aa64f55b499f662a27e4ace0e86ce1a 100644 (file)
@@ -181,13 +181,24 @@ impl Hand {
     fn random(&self) -> Option<&Card> {
         self.cards.choose(&mut rand::thread_rng())
     }
     fn random(&self) -> Option<&Card> {
         self.cards.choose(&mut rand::thread_rng())
     }
+    /// Which suits are in this Hand?
+    fn suits(&self) -> Vec<Suit> {
+        self.cards
+            .iter()
+            .map(|c| c.suit().expect("I shouldn't have jokers in my hand"))
+            .collect()
+    }
     /// Make a new Hand that contains only cards of the requested suit
     fn filter_by_suit(&self, suit: Suit) -> Self {
     /// Make a new Hand that contains only cards of the requested suit
     fn filter_by_suit(&self, suit: Suit) -> Self {
+        self.filter_by_suits(&[suit])
+    }
+    /// Make a new Hand that contains only cards of the requested suits
+    fn filter_by_suits(&self, suits: &[Suit]) -> Self {
         Self {
             cards: self
                 .cards
                 .iter()
         Self {
             cards: self
                 .cards
                 .iter()
-                .filter(|c| c.suit().expect("I shouldn't have jokers in my hand") == suit)
+                .filter(|c| suits.contains(&c.suit().expect("I shouldn't have jokers in my hand")))
                 .copied()
                 .collect(),
         }
                 .copied()
                 .collect(),
         }
@@ -258,9 +269,15 @@ impl Game {
     pub fn current_player_hand(&self) -> &Hand {
         &self.hands[self.turn.0]
     }
     pub fn current_player_hand(&self) -> &Hand {
         &self.hands[self.turn.0]
     }
+    #[must_use]
+    pub fn next_player_hand(&self) -> &Hand {
+        &self.hands[self.turn.next(self.hands.len()).0]
+    }
+    #[must_use]
     fn player_hand_mut(&mut self, pi: PlayerIndex) -> &mut Hand {
         &mut self.hands[pi.0]
     }
     fn player_hand_mut(&mut self, pi: PlayerIndex) -> &mut Hand {
         &mut self.hands[pi.0]
     }
+    #[must_use]
     fn current_player_hand_mut(&mut self) -> &mut Hand {
         self.player_hand_mut(self.turn)
     }
     fn current_player_hand_mut(&mut self) -> &mut Hand {
         self.player_hand_mut(self.turn)
     }
@@ -455,6 +472,21 @@ pub fn momentum_player(mut fallback: Player) -> Player {
     }))
 }
 
     }))
 }
 
+/// Try to coordinate to give the next player a momentum opportunity.
+#[must_use]
+pub fn coordinating_player(mut fallback: Player) -> Player {
+    Player(Box::new(move |game: &Game| -> Play {
+        if let Some(card) = game
+            .current_player_hand()
+            .filter_by_suits(&game.next_player_hand().suits())
+            .random()
+        {
+            return Play::Play(*card);
+        }
+        fallback.0(game)
+    }))
+}
+
 /// # Errors
 ///
 /// Will return `Err` on invalid plays, like trying to draw during Play phase,
 /// # Errors
 ///
 /// Will return `Err` on invalid plays, like trying to draw during Play phase,
@@ -528,9 +560,11 @@ mod tests {
     #[test]
     fn test_game() {
         for num_players in 1..10 {
     #[test]
     fn test_game() {
         for num_players in 1..10 {
-            let players: Vec<_> = std::iter::from_fn(|| Some(momentum_player(random_player(0.5))))
-                .take(num_players)
-                .collect();
+            let players: Vec<_> = std::iter::from_fn(|| {
+                Some(momentum_player(coordinating_player(random_player(0.5))))
+            })
+            .take(num_players)
+            .collect();
             let mut game = Game::default();
             for _ in 0..num_players {
                 game.add_player();
             let mut game = Game::default();
             for _ in 0..num_players {
                 game.add_player();
index 31d95878815930d663acefc8ddbd74ff73144677..6a56b511b53b0ed7e805676e96d5fc0f874e6ca0 100644 (file)
@@ -1,5 +1,5 @@
 use clap::{Parser, Subcommand, ValueEnum};
 use clap::{Parser, Subcommand, ValueEnum};
-use pluta_lesnura::{momentum_player, play, random_player, Game};
+use pluta_lesnura::{coordinating_player, momentum_player, play, random_player, Game};
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None, arg_required_else_help = true)]
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None, arg_required_else_help = true)]
@@ -12,6 +12,7 @@ struct Cli {
 enum Strategy {
     Random,
     Momentum,
 enum Strategy {
     Random,
     Momentum,
+    Coordinate,
 }
 
 #[derive(Subcommand)]
 }
 
 #[derive(Subcommand)]
@@ -46,6 +47,9 @@ fn main() -> Result<(), &'static str> {
             let player = || match strategy {
                 Strategy::Random => random_player(*draw_chance),
                 Strategy::Momentum => momentum_player(random_player(*draw_chance)),
             let player = || match strategy {
                 Strategy::Random => random_player(*draw_chance),
                 Strategy::Momentum => momentum_player(random_player(*draw_chance)),
+                Strategy::Coordinate => {
+                    momentum_player(coordinating_player(random_player(*draw_chance)))
+                }
             };
             for _ in 0..*num_games {
                 let players: Vec<_> = std::iter::from_fn(|| Some(player()))
             };
             for _ in 0..*num_games {
                 let players: Vec<_> = std::iter::from_fn(|| Some(player()))