]> git.scottworley.com Git - pluta-lesnura/blob - src/lib.rs
0ad69ea1470a7fcac876d99e08437bbf08faa98f
[pluta-lesnura] / 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 fn random(&self) -> Option<&Card> {
182 self.cards.choose(&mut rand::thread_rng())
183 }
184 }
185
186 #[derive(Copy, Clone)]
187 pub struct PlayerIndex(usize);
188 impl PlayerIndex {
189 fn next(self, num_players: usize) -> Self {
190 Self((self.0 + 1) % num_players)
191 }
192 }
193
194 #[derive(Copy, Clone, Debug)]
195 pub enum Play {
196 Play(Card),
197 Draw,
198 }
199
200 #[derive(Eq, PartialEq)]
201 pub enum Phase {
202 Play,
203 Momentum,
204 }
205
206 #[derive(Debug)]
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 impl Player {
399 #[must_use]
400 pub fn new<T>(f: T) -> Self
401 where
402 T: FnMut(&Game) -> Play + 'static,
403 {
404 Self(Box::new(f))
405 }
406 }
407
408 #[must_use]
409 pub fn random_player(game: &Game) -> Play {
410 match game.phase {
411 Phase::Play => Play::Play(
412 *game
413 .current_player_hand()
414 .random()
415 .expect("I always have a card to play because I just drew one"),
416 ),
417 Phase::Momentum => {
418 if rand::thread_rng().gen_bool(0.5) {
419 Play::Draw
420 } else {
421 match game.current_player_hand().random() {
422 Some(card) => Play::Play(*card),
423 None => Play::Draw,
424 }
425 }
426 }
427 }
428 }
429
430 /// # Errors
431 ///
432 /// Will return `Err` on invalid plays, like trying to draw during Play phase,
433 /// or trying to play a card that's not in your hand.
434 pub fn play(mut game: Game, mut players: Vec<Player>) -> Result<GameOutcome, &'static str> {
435 game.draw_for_player(game.turn);
436 loop {
437 if let PlayOutcome::End(game_outcome) = game.play(players[game.turn.0].0(&game))? {
438 return Ok(game_outcome);
439 }
440 }
441 }
442
443 #[cfg(test)]
444 mod tests {
445 use super::*;
446
447 #[test]
448 fn path_length_info_random_reveal() {
449 let length = PathLength(Rank(7));
450 let mut pli = PathLengthInfo::default();
451 for _ in 0..12 {
452 let old_pli = PathLengthInfo::clone(&pli);
453 match pli.reveal_random(length) {
454 None => panic!("Nothing revealed?"),
455 Some(r) => {
456 assert!(!old_pli.is_showing(r));
457 assert!(pli.is_showing(r));
458 }
459 }
460 assert_eq!(pli.0.count_ones(), 1 + old_pli.0.count_ones());
461 }
462 assert!(pli.reveal_random(length).is_none());
463 }
464
465 #[test]
466 fn test_deck() {
467 use WithOrWithoutJokers::*;
468 let d = deck(WithoutJokers);
469 let rank_sum: u32 = d
470 .iter()
471 .map(Card::rank)
472 .flatten()
473 .map(|r| u32::from(r.value()))
474 .sum();
475 assert_eq!(rank_sum, 364);
476 let _dj = deck(WithJokers);
477 }
478
479 #[test]
480 fn test_library() {
481 let mut lib = Library::new(vec![Card(7)]);
482 let mut dis = Discard::default();
483 dis.discard(Card(8));
484 dis.discard(Card(9));
485 assert_eq!(lib.draw(&mut dis), Some(Card(7)));
486 assert_eq!(lib.draw(&mut dis), Some(Card(8)));
487 assert_eq!(lib.draw(&mut dis), None);
488 }
489
490 #[test]
491 fn test_hand() {
492 let mut h = Hand::default();
493 assert!(h.remove(Card(4)).is_err());
494 h.add(Card(4));
495 assert!(h.remove(Card(3)).is_err());
496 assert!(h.remove(Card(4)).is_ok());
497 assert!(h.remove(Card(4)).is_err());
498 }
499
500 #[test]
501 fn test_game() {
502 for num_players in 1..10 {
503 let players: Vec<_> = std::iter::from_fn(|| Some(Player::new(random_player)))
504 .take(num_players)
505 .collect();
506 let mut game = Game::default();
507 for _ in 0..num_players {
508 game.add_player();
509 }
510 assert!(play(game, players).is_ok());
511 }
512 }
513 }