use crate::Rules;
use crate::round::RoundResult;
use crate::seat::{PassDirection, Seat};
use thiserror::Error;
#[derive(Debug, Error, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum GameError {
#[error("The game is already over")]
AlreadyOver,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[non_exhaustive]
pub struct FinalScore {
pub totals: [u16; 4],
}
impl FinalScore {
pub fn winners(&self) -> impl Iterator<Item = Seat> + '_ {
let min = *self.totals.iter().min().expect("four totals");
Seat::ALL
.into_iter()
.filter(move |&seat| self.totals[seat as usize] == min)
}
#[must_use]
pub fn winner(&self) -> Option<Seat> {
let mut winners = self.winners();
match (winners.next(), winners.next()) {
(Some(seat), None) => Some(seat),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Game {
rules: Rules,
scores: [u16; 4],
deals: u32,
}
impl Game {
#[must_use]
#[inline]
pub const fn new(rules: Rules) -> Self {
Self {
rules,
scores: [0; 4],
deals: 0,
}
}
#[must_use]
#[inline]
pub const fn rules(&self) -> &Rules {
&self.rules
}
#[must_use]
#[inline]
pub const fn score(&self, seat: Seat) -> u16 {
self.scores[seat as usize]
}
#[must_use]
#[inline]
pub const fn scores(&self) -> [u16; 4] {
self.scores
}
#[must_use]
#[inline]
pub const fn deals(&self) -> u32 {
self.deals
}
#[must_use]
#[inline]
pub const fn next_direction(&self) -> PassDirection {
PassDirection::from_deal_index(self.deals)
}
#[must_use]
pub const fn is_over(&self) -> bool {
let target = self.rules.game_target;
self.scores[0] >= target
|| self.scores[1] >= target
|| self.scores[2] >= target
|| self.scores[3] >= target
}
pub fn record(&mut self, result: RoundResult) -> Result<(), GameError> {
if self.is_over() {
return Err(GameError::AlreadyOver);
}
let scores = result.scores(&self.rules);
for seat in Seat::ALL {
let total = &mut self.scores[seat as usize];
*total = total.saturating_add(scores[seat as usize]);
}
self.deals += 1;
Ok(())
}
#[cfg(feature = "rand")]
#[must_use]
pub fn deal(&self, rng: &mut (impl rand::Rng + ?Sized)) -> crate::Round {
crate::Round::deal(self.rules, self.next_direction(), rng)
}
#[must_use]
pub const fn final_score(&self) -> Option<FinalScore> {
if self.is_over() {
Some(FinalScore {
totals: self.scores,
})
} else {
None
}
}
}