git.scottworley.com Git - pluta-lesnura/blob - src/lib.rs

   1 use rand::seq::SliceRandom;
   2 use rand::Rng;
   3
   4 pub const NUM_RANKS: usize = 13;
   5 pub const NUM_SUITS: usize = 4;
   6 pub const NUM_JOKERS: usize = 2;
   7 pub const NUM_CARDS: usize = NUM_RANKS * NUM_SUITS + NUM_JOKERS;
   8
   9 pub const STARTING_CARDS: u8 = 3;
  10 pub const STARTING_MAD_SCIENCE_TOKENS: i8 = 15;
  11 pub const STARTING_PROGRESS: i8 = -10;
  12
  13 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
  14 pub struct Rank(u8);
  15 impl Rank {
  16     #[must_use]
  17     pub fn value(&self) -> u8 {
  18         self.0 + 1
  19     }
  20     #[must_use]
  21     pub fn is_face(&self) -> bool {
  22         self.value() > 10
  23     }
  24     #[must_use]
  25     pub fn random() -> Self {
  26         Self(
  27             rand::thread_rng()
  28                 .gen_range(0..NUM_RANKS)
  29                 .try_into()
  30                 .expect("Too many ranks?"),
  31         )
  32     }
  33 }
  34
  35 #[derive(Clone, Copy, Eq, PartialEq)]
  36 pub struct Suit(u8);
  37
  38 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
  39 pub struct Card(u8);
  40 impl Card {
  41     #[must_use]
  42     pub fn is_joker(&self) -> bool {
  43         usize::from(self.0) >= NUM_RANKS * NUM_SUITS
  44     }
  45     #[must_use]
  46     pub fn rank(&self) -> Option<Rank> {
  47         (!self.is_joker()).then_some(Rank(self.0 >> 2))
  48     }
  49     #[must_use]
  50     pub fn suit(&self) -> Option<Suit> {
  51         (!self.is_joker()).then_some(Suit(self.0 & 3))
  52     }
  53 }
  54
  55 #[derive(Clone, Copy)]
  56 pub enum WithOrWithoutJokers {
  57     WithJokers,
  58     WithoutJokers,
  59 }
  60
  61 #[must_use]
  62 pub fn deck(j: WithOrWithoutJokers) -> Vec<Card> {
  63     let limit = u8::try_from(match j {
  64         WithOrWithoutJokers::WithJokers => NUM_CARDS,
  65         WithOrWithoutJokers::WithoutJokers => NUM_SUITS * NUM_RANKS,
  66     })
  67     .expect("Too many cards?");
  68     (0..limit).map(Card).collect()
  69 }
  70
  71 fn shuffle(cards: &mut Vec<Card>) {
  72     cards.shuffle(&mut rand::thread_rng());
  73 }
  74 #[must_use]
  75 fn shuffled(mut cards: Vec<Card>) -> Vec<Card> {
  76     shuffle(&mut cards);
  77     cards
  78 }
  79
  80 #[derive(Clone, Copy, Debug)]
  81 pub struct PathLength(Rank);
  82 impl PathLength {
  83     #[must_use]
  84     pub fn random() -> Self {
  85         Self(Rank::random())
  86     }
  87 }
  88
  89 #[derive(Clone, Copy, Default)]
  90 pub struct PathLengthInfo(u16);
  91 impl PathLengthInfo {
  92     #[must_use]
  93     pub fn is_showing(&self, i: Rank) -> bool {
  94         (self.0 >> i.0) & 1 == 1
  95     }
  96     fn reveal(&mut self, i: Rank) {
  97         self.0 |= 1 << i.0;
  98     }
  99     pub fn reveal_random(&mut self, true_length: PathLength) -> Option<Rank> {
 100         let showing = usize::try_from(self.0.count_ones()).expect("There aren't that many bits");
 101         let not_showing = NUM_RANKS - showing;
 102         if not_showing <= 1 {
 103             return None;
 104         }
 105
 106         let mut show = rand::thread_rng().gen_range(0..not_showing - 1);
 107         for i in 0..NUM_RANKS {
 108             let r = Rank(u8::try_from(i).expect("Too many cards?"));
 109             if !self.is_showing(r) && r != true_length.0 {
 110                 if show == 0 {
 111                     self.reveal(r);
 112                     return Some(r);
 113                 }
 114                 show -= 1;
 115             }
 116         }
 117         unreachable!()
 118     }
 119 }
 120
 121 #[derive(Default)]
 122 pub struct Discard {
 123     cards: Vec<Card>,
 124 }
 125 impl Discard {
 126     pub fn discard(&mut self, card: Card) {
 127         self.cards.push(card);
 128     }
 129     #[must_use]
 130     pub fn top(&self) -> Option<&Card> {
 131         self.cards.last()
 132     }
 133     fn len(&self) -> usize {
 134         self.cards.len()
 135     }
 136 }
 137
 138 pub struct Library {
 139     cards: Vec<Card>,
 140 }
 141 impl Library {
 142     #[must_use]
 143     pub fn new(cards: Vec<Card>) -> Self {
 144         Self { cards }
 145     }
 146     pub fn draw(&mut self, discard: &mut Discard) -> Option<Card> {
 147         if self.cards.is_empty() {
 148             if let Some(top_discard) = discard.cards.pop() {
 149                 std::mem::swap(&mut self.cards, &mut discard.cards);
 150                 discard.discard(top_discard);
 151                 shuffle(&mut self.cards);
 152             }
 153         }
 154         self.cards.pop()
 155     }
 156     fn len(&self) -> usize {
 157         self.cards.len()
 158     }
 159 }
 160
 161 #[derive(Debug, Default)]
 162 pub struct Hand {
 163     cards: Vec<Card>,
 164 }
 165 impl Hand {
 166     fn add(&mut self, card: Card) {
 167         self.cards.push(card);
 168     }
 169     fn remove(&mut self, card: Card) -> Result<(), &'static str> {
 170         let i = self
 171             .cards
 172             .iter()
 173             .position(|&e| e == card)
 174             .ok_or("That card is not in your hand")?;
 175         self.cards.swap_remove(i);
 176         Ok(())
 177     }
 178     fn len(&self) -> usize {
 179         self.cards.len()
 180     }
 181     #[cfg(test)]
 182     fn random(&self) -> Option<&Card> {
 183         self.cards.choose(&mut rand::thread_rng())
 184     }
 185 }
 186
 187 #[derive(Copy, Clone)]
 188 pub struct PlayerIndex(usize);
 189 impl PlayerIndex {
 190     fn next(self, num_players: usize) -> Self {
 191         Self((self.0 + 1) % num_players)
 192     }
 193 }
 194
 195 #[derive(Copy, Clone, Debug)]
 196 pub enum Play {
 197     Play(Card),
 198     Draw,
 199 }
 200
 201 #[derive(Eq, PartialEq)]
 202 pub enum Phase {
 203     Play,
 204     Momentum,
 205 }
 206
 207 pub enum GameOutcome {
 208     Loss,
 209     Win,
 210 }
 211
 212 pub enum PlayOutcome {
 213     Continue,
 214     End(GameOutcome),
 215 }
 216
 217 pub struct Game {
 218     mad_science_tokens: i8,
 219     progress: [i8; NUM_SUITS],
 220     path_lengths: [PathLength; NUM_SUITS],
 221     path_length_info: [PathLengthInfo; NUM_SUITS],
 222     library: Library,
 223     discard: Discard,
 224     hands: Vec<Hand>,
 225     turn: PlayerIndex,
 226     phase: Phase,
 227 }
 228 impl Game {
 229     pub fn add_player(&mut self) {
 230         self.hands.push(Hand::default());
 231         for _ in 0..STARTING_CARDS {
 232             self.draw_for_player(PlayerIndex(self.hands.len() - 1));
 233         }
 234     }
 235     /// # Errors
 236     ///
 237     /// Will return `Err` on invalid plays, like trying to draw during Play phase,
 238     /// or trying to play a card that's not in your hand.
 239     pub fn play(&mut self, play: Play) -> Result<PlayOutcome, &'static str> {
 240         match play {
 241             Play::Play(card) => self.play_card(card),
 242             Play::Draw => self.draw_for_momentum(),
 243         }
 244     }
 245
 246     #[must_use]
 247     pub fn current_player_hand(&self) -> &Hand {
 248         &self.hands[self.turn.0]
 249     }
 250     fn player_hand_mut(&mut self, pi: PlayerIndex) -> &mut Hand {
 251         &mut self.hands[pi.0]
 252     }
 253     fn current_player_hand_mut(&mut self) -> &mut Hand {
 254         self.player_hand_mut(self.turn)
 255     }
 256
 257     fn play_card(&mut self, card: Card) -> Result<PlayOutcome, &'static str> {
 258         let momentum = self.apply_card(card)?;
 259         if self.phase == Phase::Play && momentum {
 260             self.phase = Phase::Momentum;
 261             Ok(PlayOutcome::Continue)
 262         } else {
 263             Ok(self.end_of_turn())
 264         }
 265     }
 266     fn draw_for_momentum(&mut self) -> Result<PlayOutcome, &'static str> {
 267         if self.phase != Phase::Momentum {
 268             return Err("You don't have momentum");
 269         }
 270         self.draw_for_player(self.turn);
 271         Ok(self.end_of_turn())
 272     }
 273
 274     fn draw_for_player(&mut self, pi: PlayerIndex) {
 275         loop {
 276             if let Some(card) = self.library.draw(&mut self.discard) {
 277                 if card.is_joker() {
 278                     self.remove_mad_science_token();
 279                     self.discard.discard(card);
 280                 } else {
 281                     self.player_hand_mut(pi).add(card);
 282                     break;
 283                 }
 284             } else {
 285                 println!("Library ran out of cards");
 286             }
 287         }
 288     }
 289     fn remove_mad_science_token(&mut self) {
 290         loop {
 291             self.mad_science_tokens -= 1;
 292             if self.mad_science_tokens != 0 {
 293                 break;
 294             }
 295         }
 296     }
 297     fn make_progress(&mut self, card: Card) {
 298         let rank = card.rank().expect("Can't play jokers").0;
 299         if rank < 6 {
 300             let roll = rand::thread_rng().gen_range(1..=6);
 301             if roll > rank {
 302                 self.remove_mad_science_token();
 303             }
 304         }
 305         self.progress[usize::from(card.suit().expect("Can't play jokers").0)] += 1;
 306     }
 307     fn forecast(&mut self, card: Card) {
 308         let suit = usize::from(card.suit().expect("Can't play jokers").0);
 309         self.path_length_info[suit].reveal_random(self.path_lengths[suit]);
 310     }
 311     // Returns whether or not this play grants momentum
 312     fn apply_card(&mut self, card: Card) -> Result<bool, &'static str> {
 313         self.current_player_hand_mut().remove(card)?;
 314         if card.rank().expect("Can't play jokers").is_face() {
 315             self.forecast(card);
 316         } else {
 317             self.make_progress(card);
 318         }
 319         let suits_match = self
 320             .discard
 321             .top()
 322             .map_or(false, |dis| dis.suit() == card.suit());
 323         self.discard.discard(card);
 324         Ok(suits_match)
 325     }
 326     fn valid(&self) -> bool {
 327         108 == (self.library.len()
 328             + self.discard.len()
 329             + self.hands.iter().map(Hand::len).sum::<usize>())
 330     }
 331     fn roll_mad_science(&mut self) -> PlayOutcome {
 332         let mut tokens = std::iter::from_fn(|| Some(rand::thread_rng().gen_bool(0.5)))
 333             .take(usize::try_from(self.mad_science_tokens.abs()).expect("wat?"));
 334         let keep_going = if self.mad_science_tokens > 0 {
 335             tokens.any(|t| !t)
 336         } else {
 337             tokens.all(|t| !t)
 338         };
 339         if keep_going {
 340             PlayOutcome::Continue
 341         } else {
 342             PlayOutcome::End(self.final_score())
 343         }
 344     }
 345     fn final_score(&self) -> GameOutcome {
 346         if self
 347             .progress
 348             .iter()
 349             .zip(self.path_lengths.iter())
 350             .any(|(&prog, len)| prog >= len.0 .0.try_into().expect("wat?"))
 351         {
 352             GameOutcome::Win
 353         } else {
 354             GameOutcome::Loss
 355         }
 356     }
 357     fn end_of_turn(&mut self) -> PlayOutcome {
 358         assert!(self.valid());
 359         self.phase = Phase::Play;
 360         self.turn = self.turn.next(self.hands.len());
 361         if self.turn.0 == 0 {
 362             if let PlayOutcome::End(game_outcome) = self.roll_mad_science() {
 363                 return PlayOutcome::End(game_outcome);
 364             }
 365         }
 366         self.draw_for_player(self.turn);
 367         assert!(self.valid());
 368         PlayOutcome::Continue
 369     }
 370 }
 371 impl Default for Game {
 372     fn default() -> Self {
 373         Self {
 374             mad_science_tokens: STARTING_MAD_SCIENCE_TOKENS,
 375             progress: [STARTING_PROGRESS; NUM_SUITS],
 376             path_lengths: std::iter::from_fn(|| Some(PathLength::random()))
 377                 .take(NUM_SUITS)
 378                 .collect::<Vec<_>>()
 379                 .try_into()
 380                 .expect("wat?"),
 381             path_length_info: [PathLengthInfo::default(); NUM_SUITS],
 382             library: Library::new(shuffled(
 383                 [
 384                     deck(WithOrWithoutJokers::WithJokers),
 385                     deck(WithOrWithoutJokers::WithJokers),
 386                 ]
 387                 .concat(),
 388             )),
 389             discard: Discard::default(),
 390             hands: vec![],
 391             turn: PlayerIndex(0),
 392             phase: Phase::Play,
 393         }
 394     }
 395 }
 396
 397 pub struct Player(Box<dyn FnMut(&Game) -> Play>);
 398
 399 #[cfg(test)]
 400 fn random_player(game: &Game) -> Play {
 401     match game.phase {
 402         Phase::Play => Play::Play(
 403             *game
 404                 .current_player_hand()
 405                 .random()
 406                 .expect("I always have a card to play because I just drew one"),
 407         ),
 408         Phase::Momentum => {
 409             if rand::thread_rng().gen_bool(0.5) {
 410                 Play::Draw
 411             } else {
 412                 match game.current_player_hand().random() {
 413                     Some(card) => Play::Play(*card),
 414                     None => Play::Draw,
 415                 }
 416             }
 417         }
 418     }
 419 }
 420
 421 /// # Errors
 422 ///
 423 /// Will return `Err` on invalid plays, like trying to draw during Play phase,
 424 /// or trying to play a card that's not in your hand.
 425 pub fn play(mut game: Game, mut players: Vec<Player>) -> Result<GameOutcome, &'static str> {
 426     game.draw_for_player(game.turn);
 427     loop {
 428         if let PlayOutcome::End(game_outcome) = game.play(players[game.turn.0].0(&game))? {
 429             return Ok(game_outcome);
 430         }
 431     }
 432 }
 433
 434 #[cfg(test)]
 435 mod tests {
 436     use super::*;
 437
 438     #[test]
 439     fn path_length_info_random_reveal() {
 440         let length = PathLength(Rank(7));
 441         let mut pli = PathLengthInfo::default();
 442         for _ in 0..12 {
 443             let old_pli = PathLengthInfo::clone(&pli);
 444             match pli.reveal_random(length) {
 445                 None => panic!("Nothing revealed?"),
 446                 Some(r) => {
 447                     assert!(!old_pli.is_showing(r));
 448                     assert!(pli.is_showing(r));
 449                 }
 450             }
 451             assert_eq!(pli.0.count_ones(), 1 + old_pli.0.count_ones());
 452         }
 453         assert!(pli.reveal_random(length).is_none());
 454     }
 455
 456     #[test]
 457     fn test_deck() {
 458         use WithOrWithoutJokers::*;
 459         let d = deck(WithoutJokers);
 460         let rank_sum: u32 = d
 461             .iter()
 462             .map(Card::rank)
 463             .flatten()
 464             .map(|r| u32::from(r.value()))
 465             .sum();
 466         assert_eq!(rank_sum, 364);
 467         let _dj = deck(WithJokers);
 468     }
 469
 470     #[test]
 471     fn test_library() {
 472         let mut lib = Library::new(vec![Card(7)]);
 473         let mut dis = Discard::default();
 474         dis.discard(Card(8));
 475         dis.discard(Card(9));
 476         assert_eq!(lib.draw(&mut dis), Some(Card(7)));
 477         assert_eq!(lib.draw(&mut dis), Some(Card(8)));
 478         assert_eq!(lib.draw(&mut dis), None);
 479     }
 480
 481     #[test]
 482     fn test_hand() {
 483         let mut h = Hand::default();
 484         assert!(h.remove(Card(4)).is_err());
 485         h.add(Card(4));
 486         assert!(h.remove(Card(3)).is_err());
 487         assert!(h.remove(Card(4)).is_ok());
 488         assert!(h.remove(Card(4)).is_err());
 489     }
 490
 491     #[test]
 492     fn test_game() {
 493         for num_players in 1..10 {
 494             let players: Vec<_> = std::iter::from_fn(|| Some(Player(Box::new(random_player))))
 495                 .take(num_players)
 496                 .collect();
 497             let mut game = Game::default();
 498             for _ in 0..num_players {
 499                 game.add_player();
 500             }
 501             assert!(play(game, players).is_ok());
 502         }
 503     }
 504 }