twentyone 0.2.0

A blackjack engine for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

#[cfg(test)]
mod tests {
    use twentyone::game::{Dealer, DealerRequest, Player, PlayerAction};
    use twentyone::{cards, game};

    #[test]
    fn deck_tests() {
        let mut deck = cards::create_deck();
        cards::shuffle_deck(&mut deck);
        let card = deck.get(0).unwrap().clone();
        // Draw card (returns first card of deck and removes it from the vector)
        assert_eq!(cards::draw_card(&mut deck).unwrap(), card);
        // Ensure that the vector length has been reduced from 52 to 51
        assert_eq!(deck.len(), 51);
    }

    #[test]
    fn shoe_tests() {
        let mut shoe = cards::create_shoe(6);
        cards::shuffle_deck(&mut shoe);
        let card = shoe.get(0).unwrap().clone();
        // Draw card (returns first card of deck and removes it from the vector)
        assert_eq!(cards::draw_card(&mut shoe).unwrap(), card);
        // Ensure that the vector length has been reduced from 312 to 311
        assert_eq!(shoe.len(), 311);
    }

    #[test]
    fn hand_tests() {
        let mut deck = cards::create_deck();
        cards::shuffle_deck(&mut deck);
        let mut hand: Vec<[char; 2]> = Vec::new();
        let card = deck.get(0).unwrap().clone();
        // Hit card from deck to hand
        cards::hit_card(&mut deck, &mut hand);
        assert_eq!(card, hand[0]);
    }

    #[test]
    fn game_tests() {
        let mut deck = cards::create_deck();
        // Test hand value calculation
        let deck_slice = &deck[..13].iter().cloned().collect();
        assert_eq!(game::get_hand_value(&deck_slice, false), 95);

        cards::shuffle_deck(&mut deck);
        let mut hand = Vec::new();
        cards::hit_card(&mut deck, &mut hand);
        cards::hit_card(&mut deck, &mut hand);
        // Test hand splitting checks
        assert_eq!(game::can_split(&hand), hand[0][1] == hand[1][1]);
    }

    #[test]
    fn player_dealer_tests() {
        fn callback(request: DealerRequest, player: Option<&Player>, _: &Dealer) -> PlayerAction {
            match request {
                DealerRequest::Play(i) => {
                    println!("Dealer requested play");
                    let value = game::get_hand_value(&player.unwrap().hands()[i], true);
                    if value < 17 {
                        println!("Hand is <17, hitting");
                        PlayerAction::Hit
                    } else {
                        println!("Hand is >=17, standing");
                        PlayerAction::Stand
                    }
                }
                DealerRequest::Bet => {
                    println!("Dealer requested bet");
                    PlayerAction::Bet(10)
                }
                DealerRequest::UpCard(card) => {
                    println!("Dealer up card: {}{}", card[0], card[1]);
                    PlayerAction::None
                }
                DealerRequest::HitCard(card) => {
                    println!("Dealer hit card: {}{}", card[0], card[1]);
                    PlayerAction::None
                }
                DealerRequest::DealerHand(hand) => {
                    println!(
                        "Dealer hand value was {}",
                        game::get_hand_value(&hand, true)
                    );
                    PlayerAction::None
                }
                DealerRequest::Error(_) => {
                    println!("Dealer returned an error");
                    PlayerAction::None
                }
                DealerRequest::LowCards => {
                    println!("Dealer low on cards, automatically creating new shoe");
                    PlayerAction::None
                }
            }
        }

        let mut shoe = cards::create_shoe(6);
        cards::shuffle_deck(&mut shoe);
        let mut dealer = Dealer::new(shoe, game::DEFAULT_CONFIG, &callback);
        // Mutable reference to players vector
        let players = dealer.players_mut();

        let player = Player::new(1000);
        players.push(player);

        // Try playing 5 rounds
        for _ in 0..5 {
            println!("--- New Round ---");
            dealer.play_round(true);
        }
    }
}