Struct DealerHand 

pub struct DealerHand { /* private fields */ }

The dealer’s hand.

Implementations

impl DealerHand

pub const fn new() -> Self

Creates a new empty dealer hand.

pub fn add_card(&mut self, card: Card)

Adds a card to the hand.

pub fn cards(&self) -> &[Card]

Returns all cards in the hand.

Examples found in repository

examples/cli_blackjack.rs (line 337)

fn format_dealer(dealer: &bjrs::DealerHand) -> String {
    if dealer.cards().is_empty() {
        return "(no cards)".to_string();
    }

    if dealer.is_hole_revealed() {
        dealer
            .cards()
            .iter()
            .map(format_card)
            .collect::<Vec<_>>()
            .join(" ")
    } else {
        let mut parts = Vec::new();
        if let Some(card) = dealer.up_card() {
            parts.push(format_card(card));
        }
        if dealer.len() > 1 {
            parts.push("??".to_string());
        }
        parts.join(" ")
    }
}

pub fn up_card(&self) -> Option<&Card>

Returns the visible card (first card).

Examples found in repository

examples/cli_blackjack.rs (line 350)

fn format_dealer(dealer: &bjrs::DealerHand) -> String {
    if dealer.cards().is_empty() {
        return "(no cards)".to_string();
    }

    if dealer.is_hole_revealed() {
        dealer
            .cards()
            .iter()
            .map(format_card)
            .collect::<Vec<_>>()
            .join(" ")
    } else {
        let mut parts = Vec::new();
        if let Some(card) = dealer.up_card() {
            parts.push(format_card(card));
        }
        if dealer.len() > 1 {
            parts.push("??".to_string());
        }
        parts.join(" ")
    }
}

pub const fn is_hole_revealed(&self) -> bool

Returns whether the hole card is revealed.

Examples found in repository

examples/cli_blackjack.rs (line 175)

fn print_table(game: &Game, player_id: u8) {
    let remaining = game.cards_remaining();
    println!("\nShoe: {remaining} cards remaining");

    let dealer = game.get_dealer_hand();
    let dealer_view = format_dealer(&dealer);
    let dealer_value = if dealer.is_hole_revealed() {
        dealer.value()
    } else {
        dealer.visible_value()
    };
    println!("\nDealer: {dealer_view} (value {dealer_value})");

    let hands = game.get_hands(player_id).unwrap_or_default();
    let turn = game.current_turn();
    for (index, hand) in hands.iter().enumerate() {
        let marker = if index == turn.hand_index { "*" } else { " " };
        println!(
            "{} Hand {}: {} | value {} | bet {} | {:?}",
            marker,
            index,
            format_hand(hand),
            hand.value(),
            hand.bet(),
            hand.status()
        );
    }
    println!();
}

fn print_table_final(game: &Game, player_id: u8) {
    let remaining = game.cards_remaining();
    println!("\nShoe: {remaining} cards remaining");

    let dealer = game.get_dealer_hand();
    println!(
        "\nDealer: {} (value {})",
        format_dealer(&dealer),
        dealer.value()
    );

    let hands = game.get_hands(player_id).unwrap_or_default();
    for (index, hand) in hands.iter().enumerate() {
        println!(
            "Hand {}: {} | value {} | bet {} | {:?}",
            index,
            format_hand(hand),
            hand.value(),
            hand.bet(),
            hand.status()
        );
    }
    println!();
}

fn format_actions(game: &Game, player_id: u8) -> String {
    let availability = available_actions(game, player_id);
    let mut parts = Vec::new();
    parts.push(format_action("hit", "h", availability.hit));
    parts.push(format_action("stand", "s", availability.stand));
    parts.push(format_action("double", "d", availability.double));
    parts.push(format_action("split", "p", availability.split));
    parts.push(format_action("surrender", "u", availability.surrender));
    format!("Actions: {}", parts.join(" "))
}

fn format_action(label: &str, key: &str, allowed: bool) -> String {
    let text = format!("[{key}]{label}");
    if allowed {
        colorize(&text, "32")
    } else {
        colorize(&text, "90")
    }
}

fn colorize(text: &str, code: &str) -> String {
    format!("\u{1b}[{code}m{text}\u{1b}[0m")
}

struct ActionAvailability {
    hit: bool,
    stand: bool,
    double: bool,
    split: bool,
    surrender: bool,
}

fn available_actions(game: &Game, player_id: u8) -> ActionAvailability {
    if *game.state.lock() != GameState::PlayerTurn {
        return ActionAvailability {
            hit: false,
            stand: false,
            double: false,
            split: false,
            surrender: false,
        };
    }

    if game.current_player() != Some(player_id) {
        return ActionAvailability {
            hit: false,
            stand: false,
            double: false,
            split: false,
            surrender: false,
        };
    }

    let hands = game.get_hands(player_id).unwrap_or_default();
    let turn = game.current_turn();
    let Some(hand) = hands.get(turn.hand_index) else {
        return ActionAvailability {
            hit: false,
            stand: false,
            double: false,
            split: false,
            surrender: false,
        };
    };

    if hand.status() != HandStatus::Active {
        return ActionAvailability {
            hit: false,
            stand: false,
            double: false,
            split: false,
            surrender: false,
        };
    }

    let money = game.get_money(player_id).unwrap_or(0);
    let bet = hand.bet();
    let has_funds_for_double = money >= bet;
    let has_funds_for_split = money >= bet;

    let can_double_value = match game.options.double {
        DoubleOption::Any => true,
        DoubleOption::NineOrTen => hand.value() == 9 || hand.value() == 10,
        DoubleOption::NineThrough11 => (9..=11).contains(&hand.value()),
        DoubleOption::NineThrough15 => (9..=15).contains(&hand.value()),
        DoubleOption::None => false,
        _ => panic!("unhandled double option"),
    };

    let can_double = hand.len() == 2
        && (!hand.is_from_split() || game.options.double_after_split)
        && can_double_value
        && has_funds_for_double;

    let is_ace = hand.cards().first().is_some_and(|c| c.rank == 1);
    let max_splits_reached = hands.len() > game.options.split as usize;
    let can_split = hand.can_split()
        && !max_splits_reached
        && has_funds_for_split
        && !(is_ace && hand.is_from_split() && game.options.split_aces_only_once);

    let can_surrender = game.options.surrender && hand.len() == 2 && !hand.is_from_split();

    ActionAvailability {
        hit: true,
        stand: true,
        double: can_double,
        split: can_split,
        surrender: can_surrender,
    }
}

fn format_dealer(dealer: &bjrs::DealerHand) -> String {
    if dealer.cards().is_empty() {
        return "(no cards)".to_string();
    }

    if dealer.is_hole_revealed() {
        dealer
            .cards()
            .iter()
            .map(format_card)
            .collect::<Vec<_>>()
            .join(" ")
    } else {
        let mut parts = Vec::new();
        if let Some(card) = dealer.up_card() {
            parts.push(format_card(card));
        }
        if dealer.len() > 1 {
            parts.push("??".to_string());
        }
        parts.join(" ")
    }
}

pub const fn reveal_hole(&mut self)

Reveals the hole card.

pub fn visible_value(&self) -> u8

Calculates the visible value (only up card if hole not revealed).

Examples found in repository

examples/cli_blackjack.rs (line 178)

fn print_table(game: &Game, player_id: u8) {
    let remaining = game.cards_remaining();
    println!("\nShoe: {remaining} cards remaining");

    let dealer = game.get_dealer_hand();
    let dealer_view = format_dealer(&dealer);
    let dealer_value = if dealer.is_hole_revealed() {
        dealer.value()
    } else {
        dealer.visible_value()
    };
    println!("\nDealer: {dealer_view} (value {dealer_value})");

    let hands = game.get_hands(player_id).unwrap_or_default();
    let turn = game.current_turn();
    for (index, hand) in hands.iter().enumerate() {
        let marker = if index == turn.hand_index { "*" } else { " " };
        println!(
            "{} Hand {}: {} | value {} | bet {} | {:?}",
            marker,
            index,
            format_hand(hand),
            hand.value(),
            hand.bet(),
            hand.status()
        );
    }
    println!();
}

pub fn value(&self) -> u8

Calculates the full value of the hand.

Examples found in repository

examples/cli_blackjack.rs (line 176)

fn print_table(game: &Game, player_id: u8) {
    let remaining = game.cards_remaining();
    println!("\nShoe: {remaining} cards remaining");

    let dealer = game.get_dealer_hand();
    let dealer_view = format_dealer(&dealer);
    let dealer_value = if dealer.is_hole_revealed() {
        dealer.value()
    } else {
        dealer.visible_value()
    };
    println!("\nDealer: {dealer_view} (value {dealer_value})");

    let hands = game.get_hands(player_id).unwrap_or_default();
    let turn = game.current_turn();
    for (index, hand) in hands.iter().enumerate() {
        let marker = if index == turn.hand_index { "*" } else { " " };
        println!(
            "{} Hand {}: {} | value {} | bet {} | {:?}",
            marker,
            index,
            format_hand(hand),
            hand.value(),
            hand.bet(),
            hand.status()
        );
    }
    println!();
}

fn print_table_final(game: &Game, player_id: u8) {
    let remaining = game.cards_remaining();
    println!("\nShoe: {remaining} cards remaining");

    let dealer = game.get_dealer_hand();
    println!(
        "\nDealer: {} (value {})",
        format_dealer(&dealer),
        dealer.value()
    );

    let hands = game.get_hands(player_id).unwrap_or_default();
    for (index, hand) in hands.iter().enumerate() {
        println!(
            "Hand {}: {} | value {} | bet {} | {:?}",
            index,
            format_hand(hand),
            hand.value(),
            hand.bet(),
            hand.status()
        );
    }
    println!();
}

pub fn is_blackjack(&self) -> bool

Returns whether the hand is a blackjack.

pub fn is_bust(&self) -> bool

Returns whether the hand is bust.

pub fn is_soft(&self) -> bool

Returns whether the hand is soft (contains an ace counted as 11).

pub fn len(&self) -> usize

Returns the number of cards.

Examples found in repository

examples/cli_blackjack.rs (line 353)

fn format_dealer(dealer: &bjrs::DealerHand) -> String {
    if dealer.cards().is_empty() {
        return "(no cards)".to_string();
    }

    if dealer.is_hole_revealed() {
        dealer
            .cards()
            .iter()
            .map(format_card)
            .collect::<Vec<_>>()
            .join(" ")
    } else {
        let mut parts = Vec::new();
        if let Some(card) = dealer.up_card() {
            parts.push(format_card(card));
        }
        if dealer.len() > 1 {
            parts.push("??".to_string());
        }
        parts.join(" ")
    }
}

pub fn is_empty(&self) -> bool

Returns whether the hand is empty.

pub fn clear(&mut self)

Clears the hand for a new round.

Trait Implementations

impl Clone for DealerHand

fn clone(&self) -> DealerHand

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DealerHand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DealerHand

fn default() -> Self

Returns the “default value” for a type.