Merge pull request #1 from evanofslack/joker

Start of joker concepts

Cargo.toml

@@ -16,6 +16,7 @@ tracing = { version = "~0.1.40", optional = true}
 uuid  = {version = "~1.9.1", optional = true, features = ["v7"]}
 itertools = "0.13.0"
 indexmap = "2.6.0"
+strum = { version = "0.26", features = ["derive"] }
 
 [features]
 default = ["serde"]

src/core/action.rs

@@ -1,5 +1,6 @@
 use crate::core::card::Card;
 use crate::core::hand::SelectHand;
+use crate::core::joker::Jokers;
 use crate::core::stage::Blind;
 use std::fmt;
 
@@ -30,7 +31,7 @@ pub enum Action {
     Discard(SelectHand),
     MoveCard(MoveDirection, Card),
     CashOut(usize),
-    // BuyConsumable(Consumable)
+    BuyJoker(Jokers),
     NextRound(),
     SelectBlind(Blind),
     // SkipBlind(Blind),
@@ -51,6 +52,9 @@ impl fmt::Display for Action {
             Self::CashOut(reward) => {
                 write!(f, "CashOut: {:}", reward)
             }
+            Self::BuyJoker(joker) => {
+                write!(f, "BuyJoker: {:?}", joker)
+            }
             Self::NextRound() => {
                 write!(f, "NextRound")
             }

src/core/deck.rs

@@ -11,19 +11,13 @@ impl Deck {
     pub fn new() -> Self {
         Self { cards: Vec::new() }
     }
-    pub(crate) fn contains(&self, c: &Card) -> bool {
-        self.cards.contains(c)
-    }
-    pub(crate) fn remove(&mut self, c: &Card) -> bool {
+    pub fn remove(&mut self, c: &Card) -> bool {
         if let Some(pos) = self.cards.iter().position(|x| x == c) {
             self.cards.remove(pos);
             return true;
         }
         return false;
     }
-    pub(crate) fn push(&mut self, c: Card) {
-        self.cards.push(c)
-    }
     pub(crate) fn draw(&mut self, n: usize) -> Option<Vec<Card>> {
         if self.cards.len() < n {
             return None;
@@ -33,9 +27,6 @@ impl Deck {
     pub(crate) fn len(&self) -> usize {
         self.cards.len()
     }
-    pub(crate) fn is_empty(&self) -> bool {
-        self.cards.is_empty()
-    }
 
     pub(crate) fn shuffle(&mut self) {
         self.cards.shuffle(&mut thread_rng());

src/core/effect.rs

@@ -1,15 +1,53 @@
 use crate::core::game::Game;
+use crate::core::joker::{Joker, Jokers};
+use std::sync::Arc;
 
-pub trait Effect {
-    fn apply(&self, game: &mut Game);
+#[derive(Debug, Clone)]
+pub struct EffectRegistry {
+    pub on_play: Vec<Effects>,
+    pub on_discard: Vec<Effects>,
+    pub on_score: Vec<Effects>,
+    pub on_handrank: Vec<Effects>,
 }
 
-pub struct Joker {
-    pub name: String,
+impl EffectRegistry {
+    pub fn new() -> Self {
+        return Self {
+            on_play: Vec::new(),
+            on_discard: Vec::new(),
+            on_score: Vec::new(),
+            on_handrank: Vec::new(),
+        };
+    }
+    pub fn register_jokers(&mut self, jokers: Vec<Jokers>, game: &Game) {
+        for j in jokers.clone() {
+            for e in j.effects(game) {
+                match e {
+                    Effects::OnPlay(_) => self.on_play.push(e),
+                    Effects::OnDiscard(_) => self.on_discard.push(e),
+                    Effects::OnScore(_) => self.on_score.push(e),
+                    Effects::OnHandRank(_) => self.on_handrank.push(e),
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum Effects {
+    OnPlay(Arc<dyn Fn(&mut Game)>),
+    OnDiscard(Arc<dyn Fn(&mut Game)>),
+    OnScore(Arc<dyn Fn(&mut Game)>),
+    OnHandRank(Arc<dyn Fn(&mut Game)>),
 }
 
-impl Effect for Joker {
-    fn apply(&self, game: &mut Game) {
-        game.mult += 4;
+impl std::fmt::Debug for Effects {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::OnPlay(_) => write!(f, "OnPlay"),
+            Self::OnDiscard(_) => write!(f, "OnDiscard"),
+            Self::OnScore(_) => write!(f, "OnScore"),
+            Self::OnHandRank(_) => write!(f, "OnHandRank"),
+        }
     }
 }

src/core/error.rs

@@ -24,8 +24,10 @@ pub enum GameError {
     InvalidAction,
     #[error("No card match")]
     InvalidBlind,
-    #[error("Invalid blind")]
+    #[error("No card match")]
     NoCardMatch,
+    #[error("No joker match")]
+    NoJokerMatch,
     #[error("Invalid move direction")]
     InvalidMoveDirection,
 }

src/core/game.rs

@@ -2,14 +2,19 @@ use crate::core::action::{Action, MoveDirection};
 use crate::core::ante::Ante;
 use crate::core::card::Card;
 use crate::core::deck::Deck;
+use crate::core::effect::EffectRegistry;
 use crate::core::error::GameError;
 use crate::core::hand::{MadeHand, SelectHand};
+use crate::core::joker::Jokers;
+use crate::core::shop::Shop;
 use crate::core::stage::{Blind, End, Stage};
 use std::collections::HashSet;
 use std::fmt;
 
 use itertools::Itertools;
 
+use super::effect::Effects;
+
 const DEFAULT_ROUND_START: usize = 0;
 const DEFAULT_PLAYS: usize = 4;
 const DEFAULT_DISCARDS: usize = 4;
@@ -19,13 +24,13 @@ const DEFAULT_MONEY_PER_HAND: usize = 1;
 const DEFAULT_INTEREST_RATE: f32 = 0.2;
 const DEFAULT_INTEREST_MAX: usize = 5;
 const HAND_SIZE: usize = 8;
-const BASE_MULT: usize = 1;
+const BASE_MULT: usize = 0;
 const BASE_CHIPS: usize = 0;
 const BASE_SCORE: usize = 0;
 
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone)]
 pub struct Game {
+    pub shop: Shop,
     pub deck: Deck,
     pub available: Vec<Card>,
     pub discarded: Vec<Card>,
@@ -35,6 +40,10 @@ pub struct Game {
     pub action_history: Vec<Action>,
     pub round: usize,
 
+    // jokers and their effects
+    pub jokers: Vec<Jokers>,
+    pub effect_registry: EffectRegistry,
+
     // playing
     pub plays: usize,
     pub discards: usize,
@@ -50,6 +59,7 @@ pub struct Game {
 impl Game {
     pub fn new() -> Self {
         Self {
+            shop: Shop::new(),
             deck: Deck::default(),
             available: Vec::new(),
             discarded: Vec::new(),
@@ -58,6 +68,8 @@ impl Game {
             ante: Ante::One,
             action_history: Vec::new(),
             round: DEFAULT_ROUND_START,
+            jokers: Vec::new(),
+            effect_registry: EffectRegistry::new(),
             plays: DEFAULT_PLAYS,
             discards: DEFAULT_DISCARDS,
             reward: DEFAULT_REWARD,
@@ -159,11 +171,30 @@ impl Game {
         }
     }
 
-    pub fn calc_score(&self, hand: MadeHand) -> usize {
-        let base_mult = hand.rank.level().mult;
-        let base_chips = hand.rank.level().chips;
-        let hand_chips: usize = hand.hand.cards().iter().map(|c| c.chips()).sum();
-        return (hand_chips + base_chips) * base_mult;
+    pub fn calc_score(&mut self, hand: MadeHand) -> usize {
+        // compute chips and mult from hand level
+        self.chips += hand.rank.level().chips;
+        self.mult += hand.rank.level().mult;
+
+        // add chips for each played card
+        let card_chips: usize = hand.hand.cards().iter().map(|c| c.chips()).sum();
+        self.chips += card_chips;
+
+        // Apply effects that modify game.chips and game.mult
+        for e in self.effect_registry.on_score.clone() {
+            match e {
+                Effects::OnScore(f) => f(self),
+                _ => (),
+            }
+        }
+
+        // compute score
+        let score = self.chips * self.mult;
+
+        // reset chips and mult
+        self.mult = BASE_MULT;
+        self.chips = BASE_CHIPS;
+        return score;
     }
 
     pub fn required_score(&self) -> Result<usize, GameError> {
@@ -196,6 +227,16 @@ impl Game {
         return Ok(());
     }
 
+    pub fn buy_joker(&mut self, joker: Jokers) -> Result<(), GameError> {
+        if self.stage != Stage::Shop {
+            return Err(GameError::InvalidStage);
+        }
+        self.jokers.push(joker);
+        self.effect_registry
+            .register_jokers(self.jokers.clone(), &self.clone());
+        return Ok(());
+    }
+
     pub fn select_blind(&mut self, blind: Blind) -> Result<(), GameError> {
         // can only set blind if stage is pre blind
         if self.stage != Stage::PreBlind {
@@ -404,6 +445,15 @@ impl Game {
         }
     }
 
+    // get buy joker moves
+    pub fn gen_moves_buy_joker(&self) -> Option<impl Iterator<Item = Action>> {
+        // If stage is not shop, cannot buy
+        if self.stage != Stage::Shop {
+            return None;
+        }
+        return self.shop.gen_moves_buy_joker();
+    }
+
     // get all legal moves that can be executed given current state
     pub fn gen_moves(&self) -> impl Iterator<Item = Action> {
         let plays = self.gen_moves_play();
@@ -412,6 +462,7 @@ impl Game {
         let cashouts = self.gen_moves_cash_out();
         let nextrounds = self.gen_moves_next_round();
         let selectblinds = self.gen_moves_select_blind();
+        let buy_jokers = self.gen_moves_buy_joker();
 
         return plays
             .into_iter()
@@ -420,7 +471,8 @@ impl Game {
             .chain(move_cards.into_iter().flatten())
             .chain(cashouts.into_iter().flatten())
             .chain(nextrounds.into_iter().flatten())
-            .chain(selectblinds.into_iter().flatten());
+            .chain(selectblinds.into_iter().flatten())
+            .chain(buy_jokers.into_iter().flatten());
     }
 
     pub fn handle_action(&mut self, action: Action) -> Result<(), GameError> {
@@ -442,6 +494,10 @@ impl Game {
                 Stage::PostBlind => self.cashout(),
                 _ => Err(GameError::InvalidAction),
             },
+            Action::BuyJoker(joker) => match self.stage {
+                Stage::Shop => self.buy_joker(joker),
+                _ => Err(GameError::InvalidAction),
+            },
             Action::NextRound() => match self.stage {
                 Stage::Shop => self.next_round(),
                 _ => Err(GameError::InvalidAction),
@@ -481,7 +537,7 @@ mod tests {
         let g = Game::new();
         assert_eq!(g.available.len(), 0);
         assert_eq!(g.deck.len(), 52);
-        assert_eq!(g.mult, 1);
+        assert_eq!(g.mult, 0);
     }
 
     #[test]
@@ -522,7 +578,7 @@ mod tests {
 
     #[test]
     fn test_score() {
-        let g = Game::new();
+        let g = &mut Game::new();
         let ace = Card::new(Value::Ace, Suit::Heart);
         let king = Card::new(Value::King, Suit::Diamond);
         let jack = Card::new(Value::Jack, Suit::Club);