use crate::deck::{Card, Deck};
use crate::error::DucyError;
#[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 {
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,
}
}
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
})
}
}
pub trait FlopGame {
fn get_community_cards(&self) -> Deck;
fn add_player(&mut self, cards: Deck) -> Result<(), DucyError>;
fn set_flop(&mut self, cards: Deck) -> Result<(), DucyError>;
fn set_turn(&mut self, card: Card) -> Result<(), DucyError>;
fn set_river(&mut self, card: Card) -> Result<(), DucyError>;
fn get_player_hole_cards(&self) -> impl Iterator<Item = &Deck>;
fn get_final_states<'a>(&'a self) -> impl Iterator<Item = Self> + 'a;
}