Hands

[pluta-lesnura] / src / lib.rs

diff --git a/src/lib.rs b/src/lib.rs
index c90799e4b25adbb28473bf946d4a1a0aa094ba09..e2604dca8c6664a02741e38999aeb6de42e29efc 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,6 +1,139 @@
+use rand::Rng;
+
+pub const NUM_RANKS: usize = 13;
+pub const NUM_SUITS: usize = 4;
+pub const NUM_JOKERS: usize = 2;
+pub const NUM_CARDS: usize = NUM_RANKS * NUM_SUITS + NUM_JOKERS;
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct Rank(u8);
+impl Rank {
+    #[must_use]
+    pub fn value(&self) -> u8 {
+        self.0 + 1
+    }
+}
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct Suit(u8);
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Card(u8);
+impl Card {
+    #[must_use]
+    pub fn is_joker(&self) -> bool {
+        usize::from(self.0) >= NUM_RANKS * NUM_SUITS
+    }
+    #[must_use]
+    pub fn rank(&self) -> Option<Rank> {
+        (!self.is_joker()).then_some(Rank(self.0 >> 2))
+    }
+    #[must_use]
+    pub fn suit(&self) -> Option<Suit> {
+        (!self.is_joker()).then_some(Suit(self.0 & 3))
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum WithOrWithoutJokers {
+    WithJokers,
+    WithoutJokers,
+}
+
 #[must_use]
-pub fn add(left: usize, right: usize) -> usize {
-    left + right
+pub fn deck(j: WithOrWithoutJokers) -> Vec<Card> {
+    let limit = u8::try_from(match j {
+        WithOrWithoutJokers::WithJokers => NUM_CARDS,
+        WithOrWithoutJokers::WithoutJokers => NUM_SUITS * NUM_RANKS,
+    })
+    .expect("Too many cards?");
+    (0..limit).map(Card).collect()
+}
+
+#[derive(Clone, Copy)]
+pub struct PathLength(Rank);
+
+#[derive(Clone, Copy, Default)]
+pub struct PathLengthInfo(u16);
+impl PathLengthInfo {
+    #[must_use]
+    pub fn is_showing(&self, i: Rank) -> bool {
+        (self.0 >> i.0) & 1 == 1
+    }
+    fn reveal(&mut self, i: Rank) {
+        self.0 |= 1 << i.0;
+    }
+    pub fn reveal_random(&mut self, true_length: PathLength) -> Option<Rank> {
+        let showing = usize::try_from(self.0.count_ones()).expect("There aren't that many bits");
+        let not_showing = NUM_RANKS - showing;
+        if not_showing <= 1 {
+            return None;
+        }
+
+        let mut show = rand::thread_rng().gen_range(0..not_showing - 1);
+        for i in 0..NUM_RANKS {
+            let r = Rank(u8::try_from(i).expect("Too many cards?"));
+            if !self.is_showing(r) && r != true_length.0 {
+                if show == 0 {
+                    self.reveal(r);
+                    return Some(r);
+                }
+                show -= 1;
+            }
+        }
+        unreachable!()
+    }
+}
+
+#[derive(Default)]
+pub struct Discard {
+    cards: Vec<Card>,
+}
+impl Discard {
+    pub fn discard(&mut self, card: Card) {
+        self.cards.push(card);
+    }
+}
+
+pub struct Library {
+    cards: Vec<Card>,
+}
+impl Library {
+    #[must_use]
+    pub fn new(cards: Vec<Card>) -> Self {
+        Self { cards }
+    }
+    pub fn draw(&mut self, discard: &mut Discard) -> Option<Card> {
+        if self.cards.is_empty() {
+            if let Some(top_discard) = discard.cards.pop() {
+                std::mem::swap(&mut self.cards, &mut discard.cards);
+                discard.discard(top_discard);
+                // TODO: Shuffle
+            }
+        }
+        self.cards.pop()
+    }
+}
+
+#[cfg(test)]
+#[derive(Default)]
+struct Hand {
+    cards: Vec<Card>,
+}
+#[cfg(test)]
+impl Hand {
+    fn add(&mut self, card: Card) {
+        self.cards.push(card);
+    }
+    fn remove(&mut self, card: Card) -> Result<(), &'static str> {
+        let i = self
+            .cards
+            .iter()
+            .position(|&e| e == card)
+            .ok_or("That card is not in your hand")?;
+        self.cards.swap_remove(i);
+        Ok(())
+    }
 }
 
 #[cfg(test)]
@@ -8,8 +141,55 @@ mod tests {
     use super::*;
 
     #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
+    fn path_length_info_random_reveal() {
+        let length = PathLength(Rank(7));
+        let mut pli = PathLengthInfo::default();
+        for _ in 0..12 {
+            let old_pli = PathLengthInfo::clone(&pli);
+            match pli.reveal_random(length) {
+                None => panic!("Nothing revealed?"),
+                Some(r) => {
+                    assert!(!old_pli.is_showing(r));
+                    assert!(pli.is_showing(r));
+                }
+            }
+            assert_eq!(pli.0.count_ones(), 1 + old_pli.0.count_ones());
+        }
+        assert!(pli.reveal_random(length).is_none());
+    }
+
+    #[test]
+    fn test_deck() {
+        use WithOrWithoutJokers::*;
+        let d = deck(WithoutJokers);
+        let rank_sum: u32 = d
+            .iter()
+            .map(Card::rank)
+            .flatten()
+            .map(|r| u32::from(r.value()))
+            .sum();
+        assert_eq!(rank_sum, 364);
+        let _dj = deck(WithJokers);
+    }
+
+    #[test]
+    fn test_library() {
+        let mut lib = Library::new(vec![Card(7)]);
+        let mut dis = Discard::default();
+        dis.discard(Card(8));
+        dis.discard(Card(9));
+        assert_eq!(lib.draw(&mut dis), Some(Card(7)));
+        assert_eq!(lib.draw(&mut dis), Some(Card(8)));
+        assert_eq!(lib.draw(&mut dis), None);
+    }
+
+    #[test]
+    fn test_hand() {
+        let mut h = Hand::default();
+        assert!(h.remove(Card(4)).is_err());
+        h.add(Card(4));
+        assert!(h.remove(Card(3)).is_err());
+        assert!(h.remove(Card(4)).is_ok());
+        assert!(h.remove(Card(4)).is_err());
     }
 }