Much work fleshing out cards and hands.

src/main.rs

@@ -1,154 +1,41 @@
-use rand::Rng;
-use std::collections::HashMap;
-use std::fmt;
+#![allow(dead_code)]
+
 use std::vec;
 
-#[derive(Clone, Copy, Eq, PartialEq)]
-enum CardSuit {
-    Diamonds,
-    Clubs,
-    Hearts,
-    Spades,
-}
+mod card;
+mod hand;
 
-struct PlayingCard {
-    value: u8,
-    suit: CardSuit,
-}
-
-fn is_straight_flush(hand: &Vec<PlayingCard>) -> bool {
-    assert!(hand.len() == 5);
-
-    let suit = hand[0].suit;
-    let mut min_val = 15;
-    let mut max_val = 1;
-
-    // Must all be the same suit
-    for i in 0..5 {
-        let card = &hand[i];
-
-        for k in (i + 1)..5 {
-            if hand[k].value == card.value {
-                return false;
-            }
-        }
-
-        if card.value < min_val {
-            min_val = card.value;
-        };
-
-        if card.value > max_val {
-            max_val = card.value;
-        }
-
-        if card.suit != suit {
-            return false;
-        }
-    }
-
-    if max_val - min_val > 4 {
-        return false;
-    }
-
-    true
-}
-
-fn is_four_of_a_kind(hand: &Vec<PlayingCard>) -> bool {
-    let mut count: HashMap<u8, u8> = HashMap::new();
-
-    for card in hand {
-        *count.entry(card.value).or_insert(0) += 1;
-    }
-
-    for e in count {
-        if e.1 == 4 {
-            return true;
-        }
-    }
-
-    false
-}
-
-impl fmt::Display for PlayingCard {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let val = match self.value {
-            2 => "Two",
-            3 => "Three",
-            4 => "Four",
-            5 => "Five",
-            6 => "Six",
-            7 => "Seven",
-            8 => "Eight",
-            9 => "Nine",
-            10 => "Ten",
-            11 => "Jack",
-            12 => "King",
-            13 => "Queen",
-            14 => "Ace",
-            _ => "???",
-        };
-
-        let suit = match self.suit {
-            CardSuit::Clubs => "Clubs",
-            CardSuit::Diamonds => "Diamonds",
-            CardSuit::Hearts => "Hearts",
-            CardSuit::Spades => "Spades",
-        };
-
-        write!(f, "{} of {}", val, suit)
-    }
-}
-
-fn draw_card(deck: &mut Vec<PlayingCard>) -> PlayingCard {
-    let num = rand::thread_rng().gen_range(0..deck.len());
-    let card = deck.remove(num);
-
-    card
-}
-
-fn create_deck() -> Vec<PlayingCard> {
-    let mut deck: Vec<PlayingCard> = vec![];
-
-    for s in [
-        CardSuit::Diamonds,
-        CardSuit::Clubs,
-        CardSuit::Hearts,
-        CardSuit::Spades,
-    ] {
-        for i in 2..14 {
-            let card = PlayingCard { suit: s, value: i };
-            deck.insert(0, card);
-        }
-    }
-
-    deck
-}
+use crate::card::{create_deck, CardSuit, CardValue, PlayingCard};
+use crate::hand::HandType;
 
 fn main() {
     let mut deck = create_deck();
 
     let card1: PlayingCard = PlayingCard {
         suit: CardSuit::Clubs,
-        value: 2,
+        value: CardValue::Five,
     };
     let card2: PlayingCard = PlayingCard {
         suit: CardSuit::Clubs,
-        value: 2,
+        value: CardValue::Five,
     };
     let card3: PlayingCard = PlayingCard {
         suit: CardSuit::Clubs,
-        value: 2,
+        value: CardValue::Five,
     };
     let card4: PlayingCard = PlayingCard {
         suit: CardSuit::Clubs,
-        value: 2,
+        value: CardValue::Five,
     };
     let card5: PlayingCard = PlayingCard {
         suit: CardSuit::Clubs,
-        value: 3,
+        value: CardValue::Five,
     };
 
     let hand = vec![card1, card2, card3, card4, card5];
 
-    println!("{}", is_four_of_a_kind(&hand));
+    let hand1 = HandType::Flush;
+    let hand2 = HandType::StraightFlush;
+
+    println!("{}", hand1 >= hand2);
 }