Added some Klondike stuffs

card_stuffs/src/lib.rs

@@ -2,6 +2,8 @@ use thiserror::Error;
 use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
 use std::fmt;
+use rand::seq::SliceRandom;
+use rand::rng;
 
 #[derive(PartialEq, Debug, EnumIter, Copy, Clone)]
 pub enum Suit {
@@ -95,7 +97,7 @@ impl fmt::Display for Value {
     }
 }
 
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Debug, Copy, Clone)]
 pub struct Card {
     pub suit: Suit,
     pub value: Value,
@@ -114,7 +116,7 @@ impl Default for Card {
         Card {
             suit: Suit::Spade,
             value: Value::Ace, // If you like to gamble...
-            visible: true,
+            visible: false,
         }
     }
 }
@@ -168,35 +170,67 @@ impl Default for Deck {
     }
 }
 
+enum Seed {
+    Unseeded,
+    SeedVal(u64),
+}
+
+impl Deck {
+    pub fn shuffle(&mut self, seed: Seed) {
+        match seed {
+            Seed::SeedVal(_s) => unimplemented!("Not yet"),
+            Seed::Unseeded => {
+                let mut rng = rng();
+                self.cards.shuffle(&mut rng);
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
 enum NumPassesThroughDeck {
     Unlimited,
     Limited(u64),
 }
 
+pub const NUM_PILES_KLONDIKE: usize = 7;
+
+#[derive(Debug)]
 pub struct Klondike {
-    piles: [Vec<Card>; 7],
-    deck: Vec<Card>,
-    waste: Vec<Card>,
-    foundation: [Vec<Card>; 4], // 4 = len of num suits
+    pub piles: [Vec<Card>; NUM_PILES_KLONDIKE],
+    pub deck: Vec<Card>,
+    pub waste: Vec<Card>,
+    pub foundation: [Vec<Card>; 4], // 4 = len of num suits
     max_num_passes_through_deck: NumPassesThroughDeck,
     current_num_passes_through_deck: u64,
     num_cards_turned: u8,
 }
 
-/*
 impl Default for Klondike {
     fn default() -> Self {
-        let mut deck = Deck::default;
-        // shuffle deck
-        // deal some cards
-        let mut
-        // set some settings?
+        let mut deck = Deck::default();
+        deck.shuffle(Seed::Unseeded);
+        let mut piles: [Vec<Card>; NUM_PILES_KLONDIKE] = [Vec::new(), Vec::new(), Vec::new(), Vec::new(), Vec::new(), Vec::new(), Vec::new()];
+        for pile in 0..NUM_PILES_KLONDIKE {
+            for num in 0..pile+1 {
+                let mut c = deck.cards.pop().unwrap();
+                if num == pile {
+                    c.visible = true;
+                }
+                piles[pile].push(c);
+            }
+        }
         Self {
-            piles:
+            piles,
+            deck: deck.cards,
+            waste: Vec::new(),
+            foundation: [Vec::new(), Vec::new(), Vec::new(), Vec::new()], // is this really the best way?
+            max_num_passes_through_deck: NumPassesThroughDeck::Unlimited,
+            current_num_passes_through_deck: 0,
+            num_cards_turned: 3,
         }
     }
 }
-*/
 
 #[cfg(test)]
 mod tests {
@@ -249,4 +283,10 @@ mod tests {
         assert_eq!(d.cards.len(), 52); // Probably should test whether all cards are in... eh
         println!("{:#?}", d);          //  A "manual" review looks alright
     }
+
+    #[test]
+    fn klondike() {
+        let k = Klondike::default();
+        println!("{:#?}", k);
+    }
 }