ducy 0.2.0

A performant analysis library for poker.
Documentation
use crate::deck::{Card, Deck};
use crate::error::DucyError;

/// Shared state for flop-based poker games (community cards, hole cards, remaining deck).
#[derive(Clone)]
pub struct FlopGameState {
    hole_cards: Vec<Deck>,
    flop: Deck,
    turn: Option<Card>,
    river: Option<Card>,
    community_cards: Deck,
    remaining_cards_in_deck: Deck,
    num_hole_cards_per_player: u32,
}

impl FlopGameState {
    /// Creates a new game state with the specified number of hole cards per player.
    pub fn new(num_hole_cards_per_player: u32) -> Self {
        Self {
            hole_cards: vec![],
            flop: Deck::empty(),
            turn: None,
            river: None,
            community_cards: Deck::empty(),
            remaining_cards_in_deck: Deck::all_cards(),
            num_hole_cards_per_player,
        }
    }

    /// Adds community cards to the board (max 5 total).
    pub fn add_community_cards(&mut self, deck: &Deck) -> Result<(), DucyError> {
        if self.community_cards.num_cards() + deck.num_cards() > 5 {
            return Err(DucyError::TooManyCommunityCards);
        }
        self.community_cards |= *deck;
        Ok(())
    }

    pub fn enumerate_runout_community_cards(&self) -> impl Iterator<Item = Deck> + '_ {
        let cards_needed = if self.flop.is_empty() {
            5
        } else if self.turn.is_none() {
            2
        } else if self.river.is_none() {
            1
        } else {
            0
        };

        let base_community = self.community_cards;
        let complete = if cards_needed == 0 {
            Some(base_community)
        } else {
            None
        };

        let combos: Box<dyn Iterator<Item = Deck>> = if cards_needed > 0 {
            Box::new(
                self.remaining_cards_in_deck
                    .enumerate_combinations(cards_needed),
            )
        } else {
            Box::new(std::iter::empty())
        };

        complete
            .into_iter()
            .chain(combos.map(move |c| base_community | c))
    }

    pub fn hole_cards(&self) -> &[Deck] {
        &self.hole_cards
    }
}

impl FlopGame for FlopGameState {
    fn add_player(&mut self, cards: Deck) -> Result<(), DucyError> {
        if cards.num_cards() != self.num_hole_cards_per_player {
            return Err(DucyError::IncorrectCardCount);
        }
        if !self.remaining_cards_in_deck.has_cards(&cards) {
            return Err(DucyError::CardsNotAvailable);
        }

        self.remaining_cards_in_deck -= cards;
        self.hole_cards.push(cards);

        Ok(())
    }

    fn set_flop(&mut self, cards: Deck) -> Result<(), DucyError> {
        if cards.num_cards() != 3 {
            return Err(DucyError::IncorrectCardCount);
        }
        if !self.remaining_cards_in_deck.has_cards(&cards) {
            return Err(DucyError::CardsNotAvailable);
        }
        self.remaining_cards_in_deck -= cards;
        self.flop = cards;
        self.community_cards |= cards;

        Ok(())
    }

    fn set_turn(&mut self, card: Card) -> Result<(), DucyError> {
        if self.flop.is_empty() {
            return Err(DucyError::FlopNotSet);
        }
        if !self.remaining_cards_in_deck.has_card(&card) {
            return Err(DucyError::CardsNotAvailable);
        }
        self.remaining_cards_in_deck
            .remove_cards([card].into_iter());
        self.turn = Some(card);
        self.community_cards |= card;
        Ok(())
    }

    fn set_river(&mut self, card: Card) -> Result<(), DucyError> {
        if self.turn.is_none() {
            return Err(DucyError::TurnNotSet);
        }
        if !self.remaining_cards_in_deck.has_card(&card) {
            return Err(DucyError::CardsNotAvailable);
        }
        self.remaining_cards_in_deck
            .remove_cards([card].into_iter());
        self.river = Some(card);
        self.community_cards |= card;
        Ok(())
    }

    fn get_community_cards(&self) -> Deck {
        self.community_cards
    }

    fn get_player_hole_cards(&self) -> impl Iterator<Item = &Deck> {
        self.hole_cards.iter()
    }

    fn get_final_states<'a>(&'a self) -> impl Iterator<Item = Self> + 'a {
        if self.flop.is_empty() {
            FlopGameStateIterator::AllCards {
                iterator: CommunityCardIterator {
                    base_state: self.clone(),
                    iterator: Box::new(self.remaining_cards_in_deck.enumerate_combinations(5)),
                },
            }
        } else if self.turn.is_none() {
            FlopGameStateIterator::AllCards {
                iterator: CommunityCardIterator {
                    base_state: self.clone(),
                    iterator: Box::new(self.remaining_cards_in_deck.enumerate_combinations(2)),
                },
            }
        } else if self.river.is_none() {
            FlopGameStateIterator::AllCards {
                iterator: CommunityCardIterator {
                    base_state: self.clone(),
                    iterator: Box::new(self.remaining_cards_in_deck.enumerate_combinations(1)),
                },
            }
        } else {
            FlopGameStateIterator::Complete {
                game_state: self.clone(),
                iterated: false,
            }
        }
    }
}

enum FlopGameStateIterator {
    AllCards {
        iterator: CommunityCardIterator,
    },
    Complete {
        game_state: FlopGameState,
        iterated: bool,
    },
}

impl Iterator for FlopGameStateIterator {
    type Item = FlopGameState;

    fn next(&mut self) -> Option<Self::Item> {
        match self {
            FlopGameStateIterator::AllCards { iterator } => iterator.next(),
            FlopGameStateIterator::Complete {
                game_state,
                iterated,
            } => {
                if *iterated {
                    None
                } else {
                    *iterated = true;
                    Some(game_state.clone())
                }
            }
        }
    }
}

struct CommunityCardIterator {
    base_state: FlopGameState,
    iterator: Box<dyn Iterator<Item = Deck>>,
}

impl Iterator for CommunityCardIterator {
    type Item = FlopGameState;
    fn next(&mut self) -> Option<Self::Item> {
        self.iterator.next().map(|x| {
            let mut game_state = self.base_state.clone();
            game_state.add_community_cards(&x).unwrap();
            game_state
        })
    }
}

/// Trait for flop-based poker game variants (Hold'em, Omaha).
pub trait FlopGame {
    /// Returns the current community cards.
    fn get_community_cards(&self) -> Deck;
    /// Adds a player with the given hole cards.
    fn add_player(&mut self, cards: Deck) -> Result<(), DucyError>;
    /// Sets the three flop cards.
    fn set_flop(&mut self, cards: Deck) -> Result<(), DucyError>;
    /// Sets the turn card (requires flop to be set).
    fn set_turn(&mut self, card: Card) -> Result<(), DucyError>;
    /// Sets the river card (requires turn to be set).
    fn set_river(&mut self, card: Card) -> Result<(), DucyError>;
    /// Returns an iterator over each player's hole cards.
    fn get_player_hole_cards(&self) -> impl Iterator<Item = &Deck>;
    /// Returns an iterator over all possible final board states.
    fn get_final_states<'a>(&'a self) -> impl Iterator<Item = Self> + 'a;
}