From 499020b9040a8e55032573353f578e6ff3acdd80 Mon Sep 17 00:00:00 2001 From: Arthur Roberts Date: Mon, 24 Feb 2025 23:52:17 +0000 Subject: [PATCH] "Cleaned up" some things and started on a possible Klondike struct --- card_stuffs/src/lib.rs | 114 +++++++++++++++++++++++++++++------------ 1 file changed, 80 insertions(+), 34 deletions(-) diff --git a/card_stuffs/src/lib.rs b/card_stuffs/src/lib.rs index 5bdd237..eadc3e5 100644 --- a/card_stuffs/src/lib.rs +++ b/card_stuffs/src/lib.rs @@ -20,8 +20,8 @@ pub enum Colour { impl Suit { pub fn colour(&self) -> Colour { match *self { - Suit::Heart | Suit::Diamond => Colour::Red, - Suit::Club | Suit::Spade => Colour::Black, + Self::Heart | Suit::Diamond => Colour::Red, + Self::Club | Suit::Spade => Colour::Black, } } } @@ -29,10 +29,10 @@ impl Suit { impl fmt::Display for Suit { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - Suit::Heart => write!(f, "♥"), - Suit::Diamond => write!(f, "♦"), - Suit::Club => write!(f, "♣"), - Suit::Spade => write!(f, "♠"), + Self::Heart => write!(f, "♥"), + Self::Diamond => write!(f, "♦"), + Self::Club => write!(f, "♣"), + Self::Spade => write!(f, "♠"), } } } @@ -58,19 +58,19 @@ impl Value { fn indexed_values(&self) -> u8 { // It might also make sense for Ace to be high... depends on context match self { - Value::Ace => 1, - Value::Two => 2, - Value::Three => 3, - Value::Four => 4, - Value::Five => 5, - Value::Six => 6, - Value::Seven => 7, - Value::Eight => 8, - Value::Nine => 9, - Value::Ten => 10, - Value::Jack => 11, - Value::Queen => 12, - Value::King => 13, + Self::Ace => 1, + Self::Two => 2, + Self::Three => 3, + Self::Four => 4, + Self::Five => 5, + Self::Six => 6, + Self::Seven => 7, + Self::Eight => 8, + Self::Nine => 9, + Self::Ten => 10, + Self::Jack => 11, + Self::Queen => 12, + Self::King => 13, } } } @@ -78,19 +78,19 @@ impl Value { impl fmt::Display for Value { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - Value::Ace => write!(f, "A"), - Value::Two => write!(f, "2"), - Value::Three => write!(f, "3"), - Value::Four => write!(f, "4"), - Value::Five => write!(f, "5"), - Value::Six => write!(f, "6"), - Value::Seven => write!(f, "7"), - Value::Eight => write!(f, "8"), - Value::Nine => write!(f, "9"), - Value::Ten => write!(f, "T"), - Value::Jack => write!(f, "J"), - Value::Queen => write!(f, "Q"), - Value::King => write!(f, "K"), + Self::Ace => write!(f, "A"), + Self::Two => write!(f, "2"), + Self::Three => write!(f, "3"), + Self::Four => write!(f, "4"), + Self::Five => write!(f, "5"), + Self::Six => write!(f, "6"), + Self::Seven => write!(f, "7"), + Self::Eight => write!(f, "8"), + Self::Nine => write!(f, "9"), + Self::Ten => write!(f, "T"), + Self::Jack => write!(f, "J"), + Self::Queen => write!(f, "Q"), + Self::King => write!(f, "K"), } } } @@ -99,6 +99,7 @@ impl fmt::Display for Value { pub struct Card { pub suit: Suit, pub value: Value, + pub visible: bool, } @@ -108,6 +109,16 @@ impl fmt::Display for Card { } } +impl Default for Card { + fn default() -> Self { + Card { + suit: Suit::Spade, + value: Value::Ace, // If you like to gamble... + visible: true, + } + } +} + #[derive(Error, Debug, PartialEq)] pub enum StackingError { #[error("Trying to stack the same coloured suit")] @@ -138,7 +149,7 @@ pub struct Deck { } impl Default for Deck { - fn default() -> Deck { + fn default() -> Self { let mut array = Vec::new(); for suit in Suit::iter() { for value in Value::iter() { @@ -146,6 +157,7 @@ impl Default for Deck { Card { suit, value, + ..Default::default() } ); } @@ -156,6 +168,35 @@ impl Default for Deck { } } +enum NumPassesThroughDeck { + Unlimited, + Limited(u64), +} + +pub struct Klondike { + piles: [Vec; 7], + deck: Vec, + waste: Vec, + foundation: [Vec; 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? + Self { + piles: + } + } +} +*/ #[cfg(test)] mod tests { @@ -166,25 +207,30 @@ mod tests { let testing_card = Card { suit: Suit::Heart, value: Value::Five, + ..Default::default() }; let bad_same_suit = Card { suit: Suit::Heart, value: Value::Six, + ..Default::default() }; assert_eq!(testing_card.can_be_placed_on_top(&bad_same_suit), Err(StackingError::SameColour)); let bad_same_colour = Card { suit: Suit::Diamond, value: Value::Six, + ..Default::default() }; assert_eq!(testing_card.can_be_placed_on_top(&bad_same_colour), Err(StackingError::SameColour)); let should_stack_card = Card { suit: Suit::Club, value: Value::Six, + ..Default::default() }; assert_eq!(testing_card.can_be_placed_on_top(&should_stack_card), Ok(())); let value_too_high = Card { suit: Suit::Club, value: Value::Seven, + ..Default::default() }; let not_adj_error = testing_card.can_be_placed_on_top(&value_too_high); if let Err(e) = not_adj_error { @@ -201,6 +247,6 @@ mod tests { fn get_a_whole_deck() { let d = Deck::default(); assert_eq!(d.cards.len(), 52); // Probably should test whether all cards are in... eh - println!("{:#?}", d); + println!("{:#?}", d); // A "manual" review looks alright } }