use crate::Suit;
use crate::hand::{Card, Hand};
use crate::seat::Seat;
use core::fmt;
use thiserror::Error;
#[derive(Debug, Error, Clone, Copy, PartialEq, Eq, Hash)]
#[error("The trick already has four cards")]
pub struct TrickFull;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(
feature = "serde",
derive(serde::Serialize, serde::Deserialize),
serde(into = "repr::TrickRepr", try_from = "repr::TrickRepr")
)]
pub struct Trick {
leader: Seat,
cards: [Option<Card>; 4],
}
impl Trick {
#[must_use]
#[inline]
pub const fn new(leader: Seat) -> Self {
Self {
leader,
cards: [None; 4],
}
}
#[must_use]
#[inline]
pub const fn leader(self) -> Seat {
self.leader
}
#[must_use]
#[inline]
pub fn len(self) -> usize {
self.cards.iter().flatten().count()
}
#[must_use]
#[inline]
pub fn is_empty(self) -> bool {
self.cards[0].is_none()
}
#[must_use]
#[inline]
pub fn is_complete(self) -> bool {
self.cards[3].is_some()
}
#[must_use]
#[inline]
pub fn suit(self) -> Option<Suit> {
self.cards[0].map(|card| card.suit)
}
#[must_use]
pub fn current(self) -> Option<Seat> {
let mut seat = self.leader;
for card in self.cards {
if card.is_none() {
return Some(seat);
}
seat = seat.left();
}
None
}
#[must_use]
pub fn card_from(self, seat: Seat) -> Option<Card> {
self.plays().find(|&(s, _)| s == seat).map(|(_, card)| card)
}
pub fn play(&mut self, card: Card) -> Result<(), TrickFull> {
let slot = self
.cards
.iter_mut()
.find(|c| c.is_none())
.ok_or(TrickFull)?;
*slot = Some(card);
Ok(())
}
#[must_use]
pub fn winner(self) -> Option<Seat> {
let suit = self.suit()?;
self.plays()
.filter(|(_, card)| card.suit == suit)
.max_by_key(|(_, card)| card.rank)
.map(|(seat, _)| seat)
}
#[must_use]
pub fn cards(self) -> Hand {
self.cards.iter().flatten().copied().collect()
}
#[must_use]
pub fn points(self) -> u8 {
self.cards().points()
}
pub fn plays(self) -> impl Iterator<Item = (Seat, Card)> {
let mut seat = self.leader;
self.cards.into_iter().flatten().map(move |card| {
let play = (seat, card);
seat = seat.left();
play
})
}
}
impl fmt::Display for Trick {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self.is_empty() {
return write!(f, "{}:", self.leader.letter());
}
for (i, (seat, card)) in self.plays().enumerate() {
if i > 0 {
f.write_str(" ")?;
}
write!(f, "{}:{card}", seat.letter())?;
}
Ok(())
}
}
#[cfg(feature = "serde")]
mod repr {
use super::Trick;
use crate::hand::{Card, Hand};
use crate::seat::Seat;
use thiserror::Error;
#[derive(Debug, Error, Clone, Copy, PartialEq, Eq, Hash)]
#[error("Trick cards must fill a contiguous prefix of distinct cards")]
pub struct InvalidTrick;
#[derive(Clone, Copy, serde::Serialize, serde::Deserialize)]
pub struct TrickRepr {
leader: Seat,
cards: [Option<Card>; 4],
}
impl From<Trick> for TrickRepr {
fn from(trick: Trick) -> Self {
Self {
leader: trick.leader,
cards: trick.cards,
}
}
}
impl TryFrom<TrickRepr> for Trick {
type Error = InvalidTrick;
fn try_from(repr: TrickRepr) -> Result<Self, InvalidTrick> {
let contiguous = repr
.cards
.windows(2)
.all(|pair| pair[0].is_some() || pair[1].is_none());
let played: Hand = repr.cards.iter().flatten().copied().collect();
if contiguous && played.len() == repr.cards.iter().flatten().count() {
Ok(Self {
leader: repr.leader,
cards: repr.cards,
})
} else {
Err(InvalidTrick)
}
}
}
}
#[cfg(feature = "serde")]
pub use repr::InvalidTrick;
#[cfg(test)]
mod tests {
use super::*;
fn card(s: &str) -> Card {
s.parse().unwrap()
}
#[test]
fn play_order_and_winner() {
let mut trick = Trick::new(Seat::West);
assert!(trick.is_empty());
assert_eq!(trick.current(), Some(Seat::West));
assert_eq!(trick.winner(), None);
assert_eq!(trick.suit(), None);
trick.play(card("2♣")).unwrap();
assert_eq!(trick.suit(), Some(Suit::Clubs));
assert_eq!(trick.current(), Some(Seat::North));
assert_eq!(trick.winner(), Some(Seat::West));
trick.play(card("A♥")).unwrap();
assert_eq!(trick.winner(), Some(Seat::West));
trick.play(card("T♣")).unwrap();
assert_eq!(trick.winner(), Some(Seat::East));
assert!(!trick.is_complete());
trick.play(card("Q♠")).unwrap();
assert!(trick.is_complete());
assert_eq!(trick.current(), None);
assert_eq!(trick.winner(), Some(Seat::East));
assert_eq!(trick.play(card("3♣")), Err(TrickFull));
assert_eq!(trick.len(), 4);
assert_eq!(trick.points(), 14);
assert_eq!(trick.card_from(Seat::North), Some(card("A♥")));
assert_eq!(trick.cards().len(), 4);
assert_eq!(trick.to_string(), "W:2♣ N:A♥ E:T♣ S:Q♠");
}
#[test]
fn led_suit_max_wins() {
let mut trick = Trick::new(Seat::North);
for text in ["5♦", "K♦", "A♦", "6♦"] {
trick.play(card(text)).unwrap();
}
assert_eq!(trick.winner(), Some(Seat::South));
assert_eq!(trick.points(), 0);
}
}