initial commit - basic TUI blackjack game

src/hand.rs

@@ -0,0 +1,179 @@
+use crate::card::Card;
+use itertools::Itertools;
+use std::fmt;
+use std::sync::{Arc, RwLock};
+
+pub struct Hand {
+    cards: Vec<Card>,
+    discard: Option<Arc<RwLock<Vec<Card>>>>,
+}
+
+impl Hand {
+    pub fn new() -> Self {
+        Self {
+            cards: Vec::new(),
+            discard: None,
+        }
+    }
+
+    pub fn with_discard(mut self, discard: Arc<RwLock<Vec<Card>>>) -> Self {
+        self.discard = Some(discard);
+        self
+    }
+
+    /// Returns the value of the hand. If there are any aces, this is the highest value without
+    /// busting.
+    pub fn value(&self) -> u8 {
+        // TODO: Return the highest value without busting? And maybe let the player function
+        // determine if they have an ace and want to hit instead.
+        // Basic Strategy actually says what to do in the case of an ace
+        let mut num_aces = 0;
+        let mut sum = 0;
+
+        // count up the value of everything that's not an ace
+        for card in &self.cards {
+            if card.value == "A" {
+                num_aces += 1;
+            } else {
+                sum += u8::from(card);
+            }
+        }
+
+        if num_aces == 0 {
+            return sum;
+        }
+
+        // Figure out the possible ace sums based on how many aces we have
+        let mut values: Vec<u8> = [1, 11]
+            .into_iter()
+            .combinations_with_replacement(num_aces)
+            .map(|a| a.iter().sum())
+            .collect();
+
+        // Find the highest value without busting, adding in the rest of the cards. If they all
+        // bust, then take the lowest value.
+        values.sort();
+        values.reverse();
+        let mut total = 0;
+        for v in values.iter() {
+            total = v + sum;
+            if total <= 21 {
+                break;
+            }
+        }
+
+        total
+    }
+
+    /// Returns true if the hand is a blackjack, meaning we have an ace and a 10-valued card
+    pub fn is_blackjack(&self) -> bool {
+        self.cards.len() == 2 && self.value() == 21
+    }
+
+    /// Returns true if hand has an ace
+    pub fn has_ace(&self) -> bool {
+        for card in &self.cards {
+            if card.value == "A" {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// Returns a copy of the cards in the hand
+    pub fn cards(&self) -> Vec<Card> {
+        self.cards.clone()
+    }
+
+    /// Add a card to the hand
+    pub fn push(&mut self, card: Card) {
+        self.cards.push(card)
+    }
+}
+
+impl From<Vec<Card>> for Hand {
+    fn from(cards: Vec<Card>) -> Self {
+        Self {
+            cards,
+            discard: None,
+        }
+    }
+}
+
+impl fmt::Display for Hand {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for (i, c) in self.cards.iter().enumerate() {
+            if i != 0 {
+                write!(f, " ")?;
+            }
+            write!(f, "{c}")?;
+        }
+        Ok(())
+    }
+}
+
+impl Drop for Hand {
+    fn drop(&mut self) {
+        match &mut self.discard {
+            Some(x) => {
+                let mut discard = x.write().unwrap();
+                discard.append(&mut self.cards)
+            }
+            None => {}
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::card::{Card, Suit};
+
+    #[test]
+    fn no_aces() {
+        let mut h = Hand::new();
+        h.cards.push(Card::new(Suit::Club, "K"));
+        h.cards.push(Card::new(Suit::Club, "7"));
+        assert_eq!(h.value(), 17);
+    }
+
+    #[test]
+    fn one_ace() {
+        let mut h = Hand::new();
+        h.cards.push(Card::new(Suit::Club, "K"));
+        h.cards.push(Card::new(Suit::Club, "A"));
+        assert_eq!(h.value(), 21);
+    }
+
+    #[test]
+    fn three_aces() {
+        let mut h = Hand::new();
+        h.cards.push(Card::new(Suit::Club, "3"));
+        h.cards.push(Card::new(Suit::Club, "A"));
+        h.cards.push(Card::new(Suit::Club, "A"));
+        h.cards.push(Card::new(Suit::Club, "A"));
+        assert_eq!(h.value(), 16);
+    }
+
+    #[test]
+    /// If we give the hand a discard pile, then it should throw its cards in there when it gets
+    /// dropped
+    fn discard_pile() {
+        let discard = Arc::new(RwLock::new(Vec::new()));
+
+        {
+            let hand =
+                Hand::from([Card::new(Suit::Heart, "1"), Card::new(Suit::Heart, "2")].to_vec())
+                    .with_discard(discard.clone());
+
+            assert_eq!(hand.value(), 3);
+
+            // Hand still in scope, so discard pile is empty
+            assert_eq!(discard.read().unwrap().len(), 0);
+        }
+
+        let d = discard.read().unwrap();
+        // Hand went out of scope and got discarded
+        assert_eq!(d.len(), 2);
+    }
+}