]> git.scottworley.com Git - pluta-lesnura/blame_incremental - src/lib.rs
Test with multiple players
[pluta-lesnura] / src / lib.rs
... / ...
CommitLineData
1use rand::seq::SliceRandom;
2use rand::Rng;
3
4pub const NUM_RANKS: usize = 13;
5pub const NUM_SUITS: usize = 4;
6pub const NUM_JOKERS: usize = 2;
7pub const NUM_CARDS: usize = NUM_RANKS * NUM_SUITS + NUM_JOKERS;
8
9pub const STARTING_CARDS: u8 = 3;
10pub const STARTING_MAD_SCIENCE_TOKENS: i8 = 15;
11pub const STARTING_PROGRESS: i8 = -10;
12
13#[derive(Clone, Copy, Debug, Eq, PartialEq)]
14pub struct Rank(u8);
15impl 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)]
36pub struct Suit(u8);
37
38#[derive(Clone, Copy, Debug, Eq, PartialEq)]
39pub struct Card(u8);
40impl 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)]
56pub enum WithOrWithoutJokers {
57 WithJokers,
58 WithoutJokers,
59}
60
61#[must_use]
62pub 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
71fn shuffle(cards: &mut Vec<Card>) {
72 cards.shuffle(&mut rand::thread_rng());
73}
74#[must_use]
75fn shuffled(mut cards: Vec<Card>) -> Vec<Card> {
76 shuffle(&mut cards);
77 cards
78}
79
80#[derive(Clone, Copy, Debug)]
81pub struct PathLength(Rank);
82impl PathLength {
83 #[must_use]
84 pub fn random() -> Self {
85 Self(Rank::random())
86 }
87}
88
89#[derive(Clone, Copy, Default)]
90pub struct PathLengthInfo(u16);
91impl 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)]
122pub struct Discard {
123 cards: Vec<Card>,
124}
125impl 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
138pub struct Library {
139 cards: Vec<Card>,
140}
141impl 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)]
162pub struct Hand {
163 cards: Vec<Card>,
164}
165impl 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)]
188pub struct PlayerIndex(usize);
189impl PlayerIndex {
190 fn next(self, num_players: usize) -> Self {
191 Self((self.0 + 1) % num_players)
192 }
193}
194
195#[derive(Copy, Clone, Debug)]
196pub enum Play {
197 Play(Card),
198 Draw,
199}
200
201#[derive(Eq, PartialEq)]
202pub enum Phase {
203 Play,
204 Momentum,
205}
206
207pub enum GameOutcome {
208 Loss,
209 Win,
210}
211
212pub enum PlayOutcome {
213 Continue,
214 End(GameOutcome),
215}
216
217pub 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}
228impl 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}
371impl 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
397pub struct Player(Box<dyn FnMut(&Game) -> Play>);
398
399#[cfg(test)]
400fn 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.
425pub 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)]
435mod 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}