#![forbid(unsafe_code)]
#![warn(missing_docs)]
use std::collections::BTreeSet;
use std::error::Error as StdError;
use std::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Suit {
Clubs,
Diamonds,
Hearts,
Spades,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum Rank {
Three = 0,
Four = 1,
Five = 2,
Six = 3,
Seven = 4,
Eight = 5,
Nine = 6,
Ten = 7,
Jack = 8,
Queen = 9,
King = 10,
Ace = 11,
Two = 12,
}
impl Rank {
const ALL: [Self; 13] = [
Self::Three,
Self::Four,
Self::Five,
Self::Six,
Self::Seven,
Self::Eight,
Self::Nine,
Self::Ten,
Self::Jack,
Self::Queen,
Self::King,
Self::Ace,
Self::Two,
];
pub const fn strength(self) -> u8 {
self as u8
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Card {
Suited {
suit: Suit,
rank: Rank,
},
Joker(u8),
}
impl Card {
pub const fn suited(suit: Suit, rank: Rank) -> Self {
Self::Suited { suit, rank }
}
pub const fn rank(self) -> Option<Rank> {
match self {
Self::Suited { rank, .. } => Some(rank),
Self::Joker(_) => None,
}
}
pub const fn is_spade_three(self) -> bool {
matches!(
self,
Self::Suited {
suit: Suit::Spades,
rank: Rank::Three
}
)
}
}
pub fn standard_deck(joker_count: u8) -> Result<Vec<Card>, Error> {
if joker_count > 2 {
return Err(Error::TooManyJokers(joker_count));
}
let mut deck = Vec::with_capacity(52 + usize::from(joker_count));
for suit in [Suit::Clubs, Suit::Diamonds, Suit::Hearts, Suit::Spades] {
for rank in Rank::ALL {
deck.push(Card::suited(suit, rank));
}
}
for index in 0..joker_count {
deck.push(Card::Joker(index));
}
Ok(deck)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Controller {
Human,
Humanoid,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Player {
id: String,
controller: Controller,
}
impl Player {
pub fn new(id: impl Into<String>, controller: Controller) -> Result<Self, Error> {
let id = id.into();
if id.trim().is_empty() {
return Err(Error::EmptyPlayerId);
}
Ok(Self { id, controller })
}
pub fn id(&self) -> &str {
&self.id
}
pub const fn controller(&self) -> Controller {
self.controller
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Rules {
pub revolution: bool,
pub eight_cut: bool,
pub spade_three_over_joker: bool,
pub joker_wildcards: bool,
}
impl Default for Rules {
fn default() -> Self {
Self {
revolution: true,
eight_cut: true,
spade_three_over_joker: true,
joker_wildcards: true,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Meld {
cards: Vec<Card>,
effective_rank: Option<Rank>,
lone_joker: bool,
}
impl Meld {
pub fn analyze(cards: impl IntoIterator<Item = Card>, rules: Rules) -> Result<Self, Error> {
let mut cards: Vec<_> = cards.into_iter().collect();
cards.sort_unstable();
if cards.is_empty() || cards.len() > 4 {
return Err(Error::InvalidMeldSize(cards.len()));
}
if cards.windows(2).any(|pair| pair[0] == pair[1]) {
return Err(Error::DuplicateCardInAction);
}
let jokers = cards
.iter()
.filter(|card| matches!(card, Card::Joker(_)))
.count();
if cards.len() == 1 && jokers == 1 {
return Ok(Self {
cards,
effective_rank: None,
lone_joker: true,
});
}
if jokers > 0 && !rules.joker_wildcards {
return Err(Error::JokerWildcardDisabled);
}
let ranks: BTreeSet<_> = cards.iter().filter_map(|card| card.rank()).collect();
if ranks.len() != 1 {
return Err(Error::MixedRanks);
}
let effective_rank = ranks.iter().next().copied().ok_or(Error::AllJokerGroup)?;
Ok(Self {
cards,
effective_rank: Some(effective_rank),
lone_joker: false,
})
}
pub fn cards(&self) -> &[Card] {
&self.cards
}
pub fn size(&self) -> usize {
self.cards.len()
}
pub const fn effective_rank(&self) -> Option<Rank> {
self.effective_rank
}
pub const fn is_lone_joker(&self) -> bool {
self.lone_joker
}
fn beats(&self, previous: &Self, revolution: bool, rules: Rules) -> bool {
if self.size() != previous.size() {
return false;
}
if previous.lone_joker {
return rules.spade_three_over_joker
&& self.cards.len() == 1
&& self.cards[0].is_spade_three();
}
if self.lone_joker {
return true;
}
let candidate = self.effective_rank.expect("non-joker meld has rank");
let top = previous.effective_rank.expect("non-joker meld has rank");
if revolution {
candidate.strength() < top.strength()
} else {
candidate.strength() > top.strength()
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Action {
Play(Vec<Card>),
Pass,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum GamePhase {
Playing,
Complete,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct Seat {
player: Player,
hand: Vec<Card>,
finished: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OpponentView {
pub id: String,
pub controller: Controller,
pub hand_count: usize,
pub finished: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PlayerView {
player_id: String,
hand: Vec<Card>,
opponents: Vec<OpponentView>,
current_player_id: Option<String>,
top_meld: Option<Meld>,
revolution: bool,
legal_actions: Vec<Action>,
finish_order: Vec<String>,
}
impl PlayerView {
pub fn player_id(&self) -> &str {
&self.player_id
}
pub fn hand(&self) -> &[Card] {
&self.hand
}
pub fn opponents(&self) -> &[OpponentView] {
&self.opponents
}
pub fn current_player_id(&self) -> Option<&str> {
self.current_player_id.as_deref()
}
pub const fn top_meld(&self) -> Option<&Meld> {
self.top_meld.as_ref()
}
pub const fn revolution(&self) -> bool {
self.revolution
}
pub fn legal_actions(&self) -> &[Action] {
&self.legal_actions
}
pub fn finish_order(&self) -> &[String] {
&self.finish_order
}
}
pub trait Agent {
type Error;
fn choose_action(&mut self, view: &PlayerView) -> Result<Action, Self::Error>;
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StepError<E> {
Game(Error),
Agent(E),
}
impl<E: fmt::Display> fmt::Display for StepError<E> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Game(error) => write!(f, "game step failed: {error}"),
Self::Agent(error) => write!(f, "agent failed: {error}"),
}
}
}
impl<E> StdError for StepError<E>
where
E: StdError + 'static,
{
fn source(&self) -> Option<&(dyn StdError + 'static)> {
match self {
Self::Game(error) => Some(error),
Self::Agent(error) => Some(error),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Game {
seats: Vec<Seat>,
rules: Rules,
phase: GamePhase,
current: Option<usize>,
pile: Option<Meld>,
last_player: Option<usize>,
passed: BTreeSet<usize>,
revolution: bool,
finish_order: Vec<usize>,
}
impl Game {
pub fn deal(
players: impl IntoIterator<Item = Player>,
deck: impl IntoIterator<Item = Card>,
rules: Rules,
) -> Result<Self, Error> {
let players: Vec<_> = players.into_iter().collect();
if !(2..=8).contains(&players.len()) {
return Err(Error::InvalidPlayerCount(players.len()));
}
let mut ids = BTreeSet::new();
for player in &players {
if !ids.insert(player.id.clone()) {
return Err(Error::DuplicatePlayerId(player.id.clone()));
}
}
let deck: Vec<_> = deck.into_iter().collect();
if deck.is_empty() {
return Err(Error::EmptyDeck);
}
let unique: BTreeSet<_> = deck.iter().copied().collect();
if unique.len() != deck.len() {
return Err(Error::DuplicateCardInDeck);
}
let mut seats: Vec<_> = players
.into_iter()
.map(|player| Seat {
player,
hand: Vec::new(),
finished: false,
})
.collect();
let seat_count = seats.len();
for (index, card) in deck.into_iter().enumerate() {
seats[index % seat_count].hand.push(card);
}
for seat in &mut seats {
seat.hand.sort_unstable();
}
let club_three = Card::suited(Suit::Clubs, Rank::Three);
let current = seats
.iter()
.position(|seat| seat.hand.contains(&club_three))
.unwrap_or(0);
Ok(Self {
seats,
rules,
phase: GamePhase::Playing,
current: Some(current),
pile: None,
last_player: None,
passed: BTreeSet::new(),
revolution: false,
finish_order: Vec::new(),
})
}
pub const fn phase(&self) -> GamePhase {
self.phase
}
pub fn current_player_id(&self) -> Option<&str> {
self.current.map(|index| self.seats[index].player.id())
}
pub const fn revolution(&self) -> bool {
self.revolution
}
pub const fn top_meld(&self) -> Option<&Meld> {
self.pile.as_ref()
}
pub fn finish_order(&self) -> impl Iterator<Item = &str> {
self.finish_order
.iter()
.map(|index| self.seats[*index].player.id())
}
pub fn view_for(&self, player_id: &str) -> Result<PlayerView, Error> {
let index = self.player_index(player_id)?;
let opponents = self
.seats
.iter()
.enumerate()
.filter(|(other, _)| *other != index)
.map(|(_, seat)| OpponentView {
id: seat.player.id.clone(),
controller: seat.player.controller,
hand_count: seat.hand.len(),
finished: seat.finished,
})
.collect();
let legal_actions = if self.current == Some(index) {
self.legal_actions_for(index)
} else {
Vec::new()
};
Ok(PlayerView {
player_id: player_id.to_owned(),
hand: self.seats[index].hand.clone(),
opponents,
current_player_id: self.current_player_id().map(str::to_owned),
top_meld: self.pile.clone(),
revolution: self.revolution,
legal_actions,
finish_order: self.finish_order().map(str::to_owned).collect(),
})
}
pub fn apply(&mut self, player_id: &str, action: Action) -> Result<(), Error> {
if self.phase != GamePhase::Playing {
return Err(Error::GameComplete);
}
let player = self.player_index(player_id)?;
if self.current != Some(player) {
return Err(Error::NotPlayersTurn(player_id.to_owned()));
}
match action {
Action::Pass => self.apply_pass(player),
Action::Play(cards) => self.apply_play(player, cards),
}
}
pub fn step_with<A: Agent>(
&mut self,
player_id: &str,
agent: &mut A,
) -> Result<(), StepError<A::Error>> {
if self.current_player_id() != Some(player_id) {
return Err(StepError::Game(Error::NotPlayersTurn(player_id.to_owned())));
}
let view = self.view_for(player_id).map_err(StepError::Game)?;
let action = agent.choose_action(&view).map_err(StepError::Agent)?;
self.apply(player_id, action).map_err(StepError::Game)
}
fn apply_play(&mut self, player: usize, cards: Vec<Card>) -> Result<(), Error> {
let meld = Meld::analyze(cards, self.rules)?;
for card in meld.cards() {
if !self.seats[player].hand.contains(card) {
return Err(Error::CardNotInHand(*card));
}
}
if let Some(previous) = &self.pile
&& !meld.beats(previous, self.revolution, self.rules)
{
return Err(Error::MeldDoesNotBeatPile);
}
for card in meld.cards() {
let position = self.seats[player]
.hand
.iter()
.position(|owned| owned == card)
.expect("ownership checked");
self.seats[player].hand.remove(position);
}
let eight_cut = self.rules.eight_cut && meld.effective_rank == Some(Rank::Eight);
let revolution = self.rules.revolution && meld.size() == 4;
self.pile = Some(meld);
self.last_player = Some(player);
if revolution {
self.revolution = !self.revolution;
}
if self.seats[player].hand.is_empty() {
self.finish_player(player);
if self.complete_if_one_remains() {
return Ok(());
}
}
if eight_cut {
self.clear_trick_from(player);
} else {
self.advance_or_clear_from(player);
}
Ok(())
}
fn apply_pass(&mut self, player: usize) -> Result<(), Error> {
if self.pile.is_none() {
return Err(Error::CannotPassOnLead);
}
self.passed.insert(player);
self.advance_or_clear_from(player);
Ok(())
}
fn advance_or_clear_from(&mut self, from: usize) {
if let Some(next) = self.next_contender_after(from) {
self.current = Some(next);
} else {
let leader = self.last_player.expect("open pile has last player");
self.clear_trick_from(leader);
}
}
fn clear_trick_from(&mut self, leader: usize) {
self.pile = None;
self.last_player = None;
self.passed.clear();
self.current = if !self.seats[leader].finished {
Some(leader)
} else {
self.next_active_after(leader)
};
}
fn next_contender_after(&self, from: usize) -> Option<usize> {
let leader = self.last_player?;
(1..=self.seats.len())
.map(|offset| (from + offset) % self.seats.len())
.find(|index| {
*index != leader && !self.seats[*index].finished && !self.passed.contains(index)
})
}
fn next_active_after(&self, from: usize) -> Option<usize> {
(1..=self.seats.len())
.map(|offset| (from + offset) % self.seats.len())
.find(|index| !self.seats[*index].finished)
}
fn finish_player(&mut self, player: usize) {
if !self.seats[player].finished {
self.seats[player].finished = true;
self.passed.remove(&player);
self.finish_order.push(player);
}
}
fn complete_if_one_remains(&mut self) -> bool {
let remaining: Vec<_> = self
.seats
.iter()
.enumerate()
.filter(|(_, seat)| !seat.finished)
.map(|(index, _)| index)
.collect();
if remaining.len() == 1 {
self.finish_player(remaining[0]);
self.phase = GamePhase::Complete;
self.current = None;
self.pile = None;
self.last_player = None;
self.passed.clear();
true
} else {
false
}
}
fn legal_actions_for(&self, player: usize) -> Vec<Action> {
if self.phase != GamePhase::Playing || self.seats[player].finished {
return Vec::new();
}
let hand = &self.seats[player].hand;
let mut card_sets = Vec::new();
for size in 1..=4.min(hand.len()) {
combinations(hand, size, 0, &mut Vec::new(), &mut card_sets);
}
let mut actions: Vec<_> = card_sets
.into_iter()
.filter_map(|cards| {
let meld = Meld::analyze(cards.clone(), self.rules).ok()?;
let legal = self
.pile
.as_ref()
.is_none_or(|previous| meld.beats(previous, self.revolution, self.rules));
legal.then_some(Action::Play(cards))
})
.collect();
if self.pile.is_some() {
actions.push(Action::Pass);
}
actions
}
fn player_index(&self, player_id: &str) -> Result<usize, Error> {
self.seats
.iter()
.position(|seat| seat.player.id == player_id)
.ok_or_else(|| Error::UnknownPlayer(player_id.to_owned()))
}
}
fn combinations(
hand: &[Card],
remaining: usize,
start: usize,
current: &mut Vec<Card>,
output: &mut Vec<Vec<Card>>,
) {
if remaining == 0 {
output.push(current.clone());
return;
}
if hand.len().saturating_sub(start) < remaining {
return;
}
for index in start..=hand.len() - remaining {
current.push(hand[index]);
combinations(hand, remaining - 1, index + 1, current, output);
current.pop();
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum Error {
TooManyJokers(u8),
EmptyPlayerId,
InvalidPlayerCount(usize),
DuplicatePlayerId(String),
EmptyDeck,
DuplicateCardInDeck,
InvalidMeldSize(usize),
DuplicateCardInAction,
JokerWildcardDisabled,
MixedRanks,
AllJokerGroup,
UnknownPlayer(String),
NotPlayersTurn(String),
GameComplete,
CardNotInHand(Card),
MeldDoesNotBeatPile,
CannotPassOnLead,
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::TooManyJokers(count) => {
write!(f, "standard deck supports at most 2 jokers: {count}")
}
Self::EmptyPlayerId => f.write_str("player ID cannot be empty"),
Self::InvalidPlayerCount(count) => write!(f, "player count must be 2..=8: {count}"),
Self::DuplicatePlayerId(id) => write!(f, "duplicate player ID: {id}"),
Self::EmptyDeck => f.write_str("deck cannot be empty"),
Self::DuplicateCardInDeck => f.write_str("deck contains a duplicate card"),
Self::InvalidMeldSize(size) => write!(f, "meld size must be 1..=4: {size}"),
Self::DuplicateCardInAction => f.write_str("action contains a duplicate card"),
Self::JokerWildcardDisabled => f.write_str("joker wildcards are disabled"),
Self::MixedRanks => f.write_str("group contains multiple ordinary ranks"),
Self::AllJokerGroup => f.write_str("all-joker groups are unsupported"),
Self::UnknownPlayer(id) => write!(f, "unknown player: {id}"),
Self::NotPlayersTurn(id) => write!(f, "it is not player {id}'s turn"),
Self::GameComplete => f.write_str("game is complete"),
Self::CardNotInHand(card) => write!(f, "card is not in hand: {card:?}"),
Self::MeldDoesNotBeatPile => f.write_str("meld does not beat current pile"),
Self::CannotPassOnLead => f.write_str("cannot pass while leading an empty trick"),
}
}
}
impl StdError for Error {}
#[cfg(test)]
mod tests {
use super::*;
fn c(suit: Suit, rank: Rank) -> Card {
Card::suited(suit, rank)
}
fn players(count: usize) -> Vec<Player> {
(0..count)
.map(|index| {
Player::new(
format!("p{index}"),
if index == 1 {
Controller::Humanoid
} else {
Controller::Human
},
)
.unwrap()
})
.collect()
}
#[test]
fn deck_is_unique_and_unshuffled() {
let deck = standard_deck(2).unwrap();
assert_eq!(deck.len(), 54);
assert_eq!(deck[0], c(Suit::Clubs, Rank::Three));
assert_eq!(deck[53], Card::Joker(1));
assert_eq!(deck.iter().copied().collect::<BTreeSet<_>>().len(), 54);
}
#[test]
fn view_hides_opponent_cards_but_exposes_counts() {
let game = Game::deal(players(3), standard_deck(1).unwrap(), Rules::default()).unwrap();
let view = game.view_for("p0").unwrap();
assert_eq!(view.hand().len(), 18);
assert_eq!(view.opponents().len(), 2);
assert_eq!(
view.opponents().iter().map(|o| o.hand_count).sum::<usize>(),
35
);
assert_eq!(view.opponents()[0].controller, Controller::Humanoid);
}
#[test]
fn holder_of_club_three_starts() {
let deck = [c(Suit::Hearts, Rank::Ace), c(Suit::Clubs, Rank::Three)];
let game = Game::deal(players(2), deck, Rules::default()).unwrap();
assert_eq!(game.current_player_id(), Some("p1"));
}
#[test]
fn normal_and_revolution_strength_are_opposite() {
let rules = Rules::default();
let five = Meld::analyze([c(Suit::Clubs, Rank::Five)], rules).unwrap();
let six = Meld::analyze([c(Suit::Clubs, Rank::Six)], rules).unwrap();
assert!(six.beats(&five, false, rules));
assert!(five.beats(&six, true, rules));
}
#[test]
fn spade_three_beats_only_lone_joker() {
let rules = Rules::default();
let joker = Meld::analyze([Card::Joker(0)], rules).unwrap();
let spade_three = Meld::analyze([c(Suit::Spades, Rank::Three)], rules).unwrap();
let club_three = Meld::analyze([c(Suit::Clubs, Rank::Three)], rules).unwrap();
assert!(spade_three.beats(&joker, false, rules));
assert!(!club_three.beats(&joker, false, rules));
}
#[test]
fn legal_actions_match_group_size_and_include_pass() {
let deck = [
c(Suit::Clubs, Rank::Three),
c(Suit::Clubs, Rank::Four),
c(Suit::Diamonds, Rank::Three),
c(Suit::Diamonds, Rank::Five),
c(Suit::Hearts, Rank::Six),
c(Suit::Spades, Rank::Seven),
];
let mut game = Game::deal(players(2), deck, Rules::default()).unwrap();
game.apply("p0", Action::Play(vec![c(Suit::Clubs, Rank::Three)]))
.unwrap();
let view = game.view_for("p1").unwrap();
assert!(view.legal_actions().contains(&Action::Pass));
assert!(
view.legal_actions()
.contains(&Action::Play(vec![c(Suit::Clubs, Rank::Four)]))
);
}
#[test]
fn passes_clear_trick_and_last_player_leads_again() {
let deck = [
c(Suit::Clubs, Rank::Three),
c(Suit::Clubs, Rank::Four),
c(Suit::Diamonds, Rank::Five),
c(Suit::Diamonds, Rank::Six),
c(Suit::Hearts, Rank::Seven),
c(Suit::Hearts, Rank::Nine),
];
let mut game = Game::deal(players(3), deck, Rules::default()).unwrap();
game.apply("p0", Action::Play(vec![c(Suit::Clubs, Rank::Three)]))
.unwrap();
game.apply("p1", Action::Pass).unwrap();
game.apply("p2", Action::Pass).unwrap();
assert!(game.top_meld().is_none());
assert_eq!(game.current_player_id(), Some("p0"));
}
#[test]
fn four_card_group_toggles_revolution() {
let deck = [
c(Suit::Clubs, Rank::Three),
c(Suit::Clubs, Rank::Four),
c(Suit::Diamonds, Rank::Three),
c(Suit::Diamonds, Rank::Four),
c(Suit::Hearts, Rank::Three),
c(Suit::Hearts, Rank::Four),
c(Suit::Spades, Rank::Three),
c(Suit::Spades, Rank::Four),
c(Suit::Clubs, Rank::Five),
c(Suit::Clubs, Rank::Six),
];
let mut game = Game::deal(players(2), deck, Rules::default()).unwrap();
game.apply(
"p0",
Action::Play(vec![
c(Suit::Clubs, Rank::Three),
c(Suit::Diamonds, Rank::Three),
c(Suit::Hearts, Rank::Three),
c(Suit::Spades, Rank::Three),
]),
)
.unwrap();
assert!(game.revolution());
}
#[test]
fn eight_cut_clears_and_same_player_leads() {
let deck = [
c(Suit::Clubs, Rank::Three),
c(Suit::Clubs, Rank::Four),
c(Suit::Diamonds, Rank::Eight),
c(Suit::Diamonds, Rank::Nine),
c(Suit::Hearts, Rank::Ten),
c(Suit::Hearts, Rank::Jack),
];
let mut game = Game::deal(players(2), deck, Rules::default()).unwrap();
game.apply("p0", Action::Play(vec![c(Suit::Clubs, Rank::Three)]))
.unwrap();
game.apply("p1", Action::Play(vec![c(Suit::Clubs, Rank::Four)]))
.unwrap();
game.apply("p0", Action::Play(vec![c(Suit::Diamonds, Rank::Eight)]))
.unwrap();
assert!(game.top_meld().is_none());
assert_eq!(game.current_player_id(), Some("p0"));
}
#[test]
fn finishing_order_completes_with_last_player() {
let deck = [c(Suit::Clubs, Rank::Three), c(Suit::Clubs, Rank::Four)];
let mut game = Game::deal(players(2), deck, Rules::default()).unwrap();
game.apply("p0", Action::Play(vec![c(Suit::Clubs, Rank::Three)]))
.unwrap();
assert_eq!(game.phase(), GamePhase::Complete);
assert_eq!(game.finish_order().collect::<Vec<_>>(), ["p0", "p1"]);
}
#[test]
fn humanoid_agent_can_take_a_turn_from_private_view() {
struct FirstLegal;
impl Agent for FirstLegal {
type Error = std::convert::Infallible;
fn choose_action(&mut self, view: &PlayerView) -> Result<Action, Self::Error> {
Ok(view.legal_actions()[0].clone())
}
}
let deck = [
c(Suit::Clubs, Rank::Four),
c(Suit::Clubs, Rank::Three),
c(Suit::Diamonds, Rank::Five),
c(Suit::Diamonds, Rank::Six),
];
let mut game = Game::deal(players(2), deck, Rules::default()).unwrap();
assert_eq!(game.current_player_id(), Some("p1"));
game.step_with("p1", &mut FirstLegal).unwrap();
assert_ne!(game.current_player_id(), Some("p1"));
}
}