From 2d3998b9d91b9016dd41fa871a2e2d9e2c15180a Mon Sep 17 00:00:00 2001
From: Scott Worley <scottworley@scottworley.com>
Date: Tue, 18 Jul 2023 12:21:47 -0700
Subject: [PATCH] Start adding smarter play: Try for momentum

---
 src/lib.rs  | 27 +++++++++++++++++++++++++++
 src/main.rs | 25 +++++++++++++++++++------
 2 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 09bd5fb..444b3fe 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -181,6 +181,17 @@ impl Hand {
     fn random(&self) -> Option<&Card> {
         self.cards.choose(&mut rand::thread_rng())
     }
+    /// Make a new Hand that contains only cards of the requested suit
+    fn filter_by_suit(&self, suit: Suit) -> Self {
+        Self {
+            cards: self
+                .cards
+                .iter()
+                .filter(|c| c.suit().expect("I shouldn't have jokers in my hand") == suit)
+                .copied()
+                .collect(),
+        }
+    }
 }
 
 #[derive(Copy, Clone)]
@@ -428,6 +439,22 @@ pub fn random_player(draw_chance: f64) -> impl FnMut(&Game) -> Play {
     }
 }
 
+/// When available, make plays that grant momentum.  Otherwise, play randomly.
+pub fn momentum_player(draw_chance: f64) -> impl FnMut(&Game) -> Play {
+    let mut fallback = random_player(draw_chance);
+    move |game: &Game| -> Play {
+        match (&game.phase, game.discard.top().and_then(Card::suit)) {
+            (Phase::Play, Some(suit)) => {
+                match game.current_player_hand().filter_by_suit(suit).random() {
+                    Some(card) => Play::Play(*card),
+                    _ => fallback(game),
+                }
+            }
+            _ => fallback(game),
+        }
+    }
+}
+
 /// # Errors
 ///
 /// Will return `Err` on invalid plays, like trying to draw during Play phase,
diff --git a/src/main.rs b/src/main.rs
index c7c1c92..b2924ee 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,5 @@
-use clap::{Parser, Subcommand};
-use pluta_lesnura::{play, random_player, Game, Player};
+use clap::{Parser, Subcommand, ValueEnum};
+use pluta_lesnura::{momentum_player, play, random_player, Game, Player};
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None, arg_required_else_help = true)]
@@ -8,6 +8,12 @@ struct Cli {
     command: Option<Commands>,
 }
 
+#[derive(Clone, Debug, ValueEnum)]
+enum Strategy {
+    Random,
+    Momentum,
+}
+
 #[derive(Subcommand)]
 enum Commands {
     /// Runs simulations
@@ -21,6 +27,9 @@ enum Commands {
         /// How many players?
         #[arg(short = 'p', long)]
         num_players: usize,
+        /// What strategy should players use?
+        #[arg(short = 's', long, value_enum)]
+        strategy: Strategy,
     },
 }
 
@@ -32,12 +41,16 @@ fn main() -> Result<(), &'static str> {
             draw_chance,
             num_games,
             num_players,
+            strategy,
         }) => {
+            let player = || match strategy {
+                Strategy::Random => Player::new(random_player(*draw_chance)),
+                Strategy::Momentum => Player::new(momentum_player(*draw_chance)),
+            };
             for _ in 0..*num_games {
-                let players: Vec<_> =
-                    std::iter::from_fn(|| Some(Player::new(random_player(*draw_chance))))
-                        .take(*num_players)
-                        .collect();
+                let players: Vec<_> = std::iter::from_fn(|| Some(player()))
+                    .take(*num_players)
+                    .collect();
                 let mut game = Game::default();
                 for _ in 0..*num_players {
                     game.add_player();
-- 
2.44.1