use crate::{Strategy, View};
use hearts::{Card, Hand, Holding, Rank, Seat, Suit, Trick};
fn below(rank: Rank) -> Holding {
Holding::from_bits_truncate((1u16 << rank.get()) - 1)
}
pub(crate) fn pass_score(hand: Hand, card: Card, config: HeuristicConfig) -> i32 {
let mut score = i32::from(card.rank.get());
let guards = (hand[Suit::Spades] & below(Rank::Q)).len();
if card.suit == Suit::Spades && guards < usize::from(config.spade_guards) {
if card == Card::QUEEN_OF_SPADES {
score += 100;
} else if card.rank == Rank::A {
score += 90;
} else if card.rank == Rank::K {
score += 80;
}
}
if card.suit == Suit::Hearts {
score += i32::from(config.heart_weight) * i32::from(card.rank.get());
}
if card == Card::TWO_OF_CLUBS {
score += i32::from(config.two_of_clubs_bonus);
}
if card.suit == Suit::Spades
&& card.rank.get() < Rank::Q.get()
&& !hand.contains(Card::QUEEN_OF_SPADES)
{
score -= i32::from(config.queen_insurance);
}
let len = hand[card.suit].len() as i32;
if card.suit != Suit::Spades && len <= 3 {
score += i32::from(config.void_weight) * (8 - 2 * len);
}
score
}
const fn danger(card: Card) -> u8 {
match card.suit {
Suit::Spades if card.rank.get() >= Rank::Q.get() => 4,
Suit::Spades => 0,
suit => suit as u8 + 1,
}
}
pub(crate) fn pass_key(hand: Hand, card: Card, config: HeuristicConfig) -> (i32, u8, u8) {
(
pass_score(hand, card, config),
danger(card),
card.rank.get(),
)
}
pub(crate) fn greedy_pass(mut hand: Hand, config: HeuristicConfig) -> [Card; 3] {
[(); 3].map(|()| {
let current = hand;
let pick = current
.into_iter()
.max_by_key(|&card| pass_key(current, card, config))
.expect("a passing hand holds thirteen cards");
hand.remove(pick);
pick
})
}
fn winning_card(trick: Trick) -> Option<Card> {
trick.winner().and_then(|seat| trick.card_from(seat))
}
fn best_dump(legal: Hand, played: Hand) -> Card {
if legal.contains(Card::QUEEN_OF_SPADES) {
return Card::QUEEN_OF_SPADES;
}
if !played.contains(Card::QUEEN_OF_SPADES)
&& let Some(rank) = [Rank::A, Rank::K]
.into_iter()
.find(|&rank| legal[Suit::Spades].contains(rank))
{
return Card {
suit: Suit::Spades,
rank,
};
}
if let Some(rank) = legal[Suit::Hearts].iter().next_back() {
return Card {
suit: Suit::Hearts,
rank,
};
}
legal
.into_iter()
.max_by_key(|card| card.rank)
.expect("legal plays are never empty on turn")
}
pub(crate) fn greedy_play(legal: Hand, trick: Trick, played: Hand) -> Card {
let Some(led) = trick.suit() else {
if !played.contains(Card::QUEEN_OF_SPADES)
&& !legal.contains(Card::QUEEN_OF_SPADES)
&& (legal[Suit::Spades] - below(Rank::Q)).is_empty()
{
let low_spades = legal[Suit::Spades] & below(Rank::Q);
if let Some(rank) = low_spades.iter().next() {
return Card {
suit: Suit::Spades,
rank,
};
}
}
return legal
.into_iter()
.min_by_key(|card| (legal[card.suit].len(), card.rank))
.expect("legal plays are never empty on turn");
};
let follow = legal[led];
if follow.is_empty() {
return best_dump(legal, played);
}
let winner = winning_card(trick).expect("a led trick has a winning card");
if led == Suit::Spades && follow.contains(Rank::Q) && winner.rank > Rank::Q {
return Card::QUEEN_OF_SPADES;
}
if trick.len() == 3 && trick.plays().all(|(_, card)| card.points() == 0) {
let mut winners = follow - below(winner.rank) - Holding::from_rank(winner.rank);
if led == Suit::Spades {
winners -= Holding::from_rank(Rank::Q);
}
if let Some(rank) = winners.iter().next() {
return Card { suit: led, rank };
}
}
if let Some(rank) = (follow & below(winner.rank)).iter().next_back() {
return Card { suit: led, rank };
}
let safe = if led == Suit::Spades {
let others = follow - Holding::from_rank(Rank::Q);
if others.is_empty() { follow } else { others }
} else {
follow
};
let rank = if trick.len() == 3 {
safe.iter().next_back().expect("checked non-empty")
} else {
safe.iter().next().expect("checked non-empty")
};
Card { suit: led, rank }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct HeuristicConfig {
pub moon_defense: u8,
pub void_weight: u8,
pub heart_weight: u8,
pub spade_guards: u8,
pub two_of_clubs_bonus: u8,
pub queen_insurance: u8,
}
impl HeuristicConfig {
#[must_use]
pub const fn new() -> Self {
Self {
moon_defense: 8,
void_weight: 1,
heart_weight: 0,
spade_guards: 4,
two_of_clubs_bonus: 6,
queen_insurance: 4,
}
}
}
impl Default for HeuristicConfig {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct HeuristicBot {
config: HeuristicConfig,
}
impl HeuristicBot {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub const fn with_config(config: HeuristicConfig) -> Self {
Self { config }
}
}
fn moon_threat(view: &View<'_>, threshold: u8) -> Option<Seat> {
let mut sweeper = None;
for seat in Seat::ALL {
if view.points_taken(seat) > 0 {
if sweeper.is_some() {
return None;
}
sweeper = Some(seat);
}
}
sweeper.filter(|&seat| seat != view.seat() && view.points_taken(seat) >= threshold)
}
pub(crate) fn moon_defense(view: &View<'_>, threshold: u8) -> Option<Card> {
let threat = moon_threat(view, threshold)?;
let trick = view.current_trick()?;
if trick.winner() != Some(threat) {
return None;
}
beat_threat(view.legal_plays(), trick)
}
fn beat_threat(legal: Hand, trick: Trick) -> Option<Card> {
let led = trick.suit()?;
let winner = winning_card(trick).expect("a led trick has a winning card");
let follow = legal[led];
if follow.is_empty() {
let harmless = legal - Hand::PENALTIES;
return harmless.into_iter().max_by_key(|card| card.rank);
}
let mut beat = follow - below(winner.rank) - Holding::from_rank(winner.rank);
if led == Suit::Spades {
beat -= Holding::from_rank(Rank::Q);
}
if let Some(rank) = beat.iter().next() {
return Some(Card { suit: led, rank });
}
let mut duck = follow & below(winner.rank);
if led == Suit::Spades {
let harmless = duck - Holding::from_rank(Rank::Q);
if !harmless.is_empty() {
duck = harmless;
}
}
duck.iter().next_back().map(|rank| Card { suit: led, rank })
}
impl Strategy for HeuristicBot {
fn pass_cards(&mut self, view: &View<'_>) -> [Card; 3] {
greedy_pass(view.hand(), self.config)
}
fn play_card(&mut self, view: &View<'_>) -> Card {
if let Some(card) = moon_defense(view, self.config.moon_defense) {
return card;
}
let legal = view.legal_plays();
let trick = view.current_trick().expect("a play decision has a trick");
greedy_play(legal, trick, view.played())
}
fn name(&self) -> &str {
"greedy"
}
}
#[cfg(any(feature = "rand", test))]
pub(crate) fn shoot_play(legal: Hand, trick: Trick, played: Hand) -> Card {
let highest = |cards: Hand| {
cards
.into_iter()
.max_by_key(|card| card.rank)
.expect("the set was checked non-empty")
};
let Some(led) = trick.suit() else {
return highest(legal);
};
let follow = legal[led];
if follow.is_empty() {
let junk = legal - Hand::PENALTIES;
let shed = if junk.is_empty() { legal } else { junk };
return shed
.into_iter()
.min_by_key(|card| card.rank)
.expect("legal plays are never empty on turn");
}
let winner = winning_card(trick).expect("a led trick has a winning card");
match (follow - below(winner.rank) - Holding::from_rank(winner.rank))
.iter()
.next_back()
{
Some(rank) => Card { suit: led, rank },
None => greedy_play(legal, trick, played),
}
}
#[cfg(feature = "rand")]
pub(crate) fn rollout_play(
round: &hearts::Round,
seat: Seat,
shooter: Option<Seat>,
played: Hand,
) -> Card {
let legal = round.legal_plays(seat);
let trick = round.current_trick().expect("a playing round has a trick");
if let Some(shooter) = shooter {
let alive = Seat::ALL
.into_iter()
.all(|other| other == shooter || round.points_taken(other) == 0);
if !alive {
return greedy_play(legal, trick, played);
}
if seat == shooter {
return shoot_play(legal, trick, played);
}
if trick.winner() == Some(shooter)
&& round.points_taken(shooter) >= HeuristicConfig::default().moon_defense
&& let Some(card) = beat_threat(legal, trick)
{
return card;
}
}
greedy_play(legal, trick, played)
}
#[cfg(test)]
mod tests {
use super::*;
fn card(text: &str) -> Card {
text.parse().expect("a valid card")
}
fn hand(text: &str) -> Hand {
text.parse().expect("a valid hand")
}
fn flat_pass(dealt: Hand, config: HeuristicConfig) -> [Card; 3] {
let mut cards: Vec<Card> = dealt.into_iter().collect();
cards.sort_by_key(|&card| -pass_score(dealt, card, config));
[cards[0], cards[1], cards[2]]
}
#[test]
fn passing_dumps_the_unprotected_queen() {
let dealt = hand("234567.89.A.2Q");
let picks = greedy_pass(dealt, HeuristicConfig::default());
assert!(picks.contains(&card("Q♠")));
assert!(picks.contains(&card("A♥")));
let guarded = hand("234.8.9A.234567Q");
let picks = greedy_pass(guarded, HeuristicConfig::default());
assert!(!picks.contains(&card("Q♠")));
}
#[test]
fn passing_completes_a_void_instead_of_scattering() {
let dealt = hand("234679.2K.6A.68J");
let config = HeuristicConfig {
queen_insurance: 0,
..HeuristicConfig::default()
};
assert_eq!(
greedy_pass(dealt, config),
[card("A♥"), card("K♦"), card("6♥")],
);
assert_eq!(
flat_pass(dealt, config),
[card("A♥"), card("K♦"), card("J♠")],
"the flat form scatters, which is what this replaced",
);
}
#[test]
fn queen_insurance_keeps_a_low_spade_without_her() {
let dealt = hand("2345.2345.234.29");
let uninsured = HeuristicConfig {
queen_insurance: 0,
..HeuristicConfig::default()
};
assert!(greedy_pass(dealt, uninsured).contains(&card("9♠")));
assert!(!greedy_pass(dealt, HeuristicConfig::default()).contains(&card("9♠")));
let config = HeuristicConfig::default();
assert_eq!(pass_score(hand("2345.2345.23.29Q"), card("9♠"), config), 9);
assert_eq!(pass_score(dealt, card("9♠"), config), 5);
}
#[test]
fn the_pass_tie_break_is_designed_not_inherited() {
assert!(danger(card("Q♠")) > danger(card("A♥")));
assert!(danger(card("A♥")) > danger(card("A♦")));
assert!(danger(card("A♦")) > danger(card("A♣")));
assert!(danger(card("A♣")) > danger(card("J♠")));
let nines = hand("2349.2349.2349.9");
assert_eq!(
greedy_pass(nines, HeuristicConfig::default()),
[card("9♥"), card("9♦"), card("9♣")],
);
assert_eq!(
flat_pass(nines, HeuristicConfig::default()),
[card("9♣"), card("9♦"), card("9♥")],
"sort stability used to reach for the clubs first",
);
assert_eq!(
greedy_pass(hand("234K..23K.23456K"), HeuristicConfig::default()),
[card("K♥"), card("K♠"), card("K♣")],
);
}
#[test]
fn the_forced_lead_is_worth_passing() {
let dealt = hand("2345.234.234.234");
assert_eq!(
greedy_pass(dealt, HeuristicConfig::default()),
[card("2♣"), card("5♣"), card("4♣")],
"the shipped bonus sends the forced lead, then works the suit",
);
let unpriced = HeuristicConfig {
two_of_clubs_bonus: 0,
..HeuristicConfig::default()
};
assert_eq!(
greedy_pass(dealt, unpriced),
[card("4♥"), card("3♥"), card("2♥")],
);
}
#[test]
fn shooting_takes_every_trick_it_can() {
let lead = Trick::new(Seat::North);
assert_eq!(shoot_play(hand("2.3.A.4"), lead, Hand::EMPTY), card("A♥"));
let mut trick = Trick::new(Seat::North);
trick.play(card("9♦")).unwrap();
let held = hand(".2378Q..");
assert_eq!(shoot_play(held, trick, Hand::EMPTY), card("Q♦"));
assert_eq!(
greedy_play(held, trick, Hand::EMPTY),
card("8♦"),
"the greedy policy ducks the same holding"
);
}
#[test]
fn a_dead_trick_costs_the_shooter_nothing() {
let mut trick = Trick::new(Seat::North);
trick.play(card("9♦")).unwrap();
let held = hand(".2378..A");
assert_eq!(
shoot_play(held, trick, Hand::EMPTY),
greedy_play(held, trick, Hand::EMPTY)
);
assert_eq!(shoot_play(hand("29..3A.Q"), trick, Hand::EMPTY), card("2♣"));
assert_eq!(shoot_play(hand("..3A.Q"), trick, Hand::EMPTY), card("3♥"));
}
#[test]
fn ducking_under_the_winner() {
let mut trick = Trick::new(Seat::North);
trick.play(card("9♦")).unwrap();
assert_eq!(
greedy_play(hand(".2378Q.."), trick, Hand::EMPTY),
card("8♦")
);
}
#[test]
fn last_hand_takes_only_a_point_free_trick() {
let mut clean = Trick::new(Seat::North);
for text in ["5♦", "2♦", "3♦"] {
clean.play(card(text)).unwrap();
}
assert_eq!(
greedy_play(hand(".47.."), clean, Hand::EMPTY),
card("7♦"),
"take control when nobody can add points"
);
let mut costly = Trick::new(Seat::North);
for text in ["5♣", "2♥", "3♣"] {
costly.play(card(text)).unwrap();
}
assert_eq!(
greedy_play(hand("47..."), costly, Hand::EMPTY),
card("4♣"),
"duck when the trick already carries a point"
);
}
#[test]
fn leading_works_the_shortest_suit() {
let trick = Trick::new(Seat::North);
let played = Hand::QUEEN_OF_SPADES;
assert_eq!(greedy_play(hand("234.5.67.89"), trick, played), card("5♦"));
}
#[test]
fn void_dumps_the_queen_first() {
let mut trick = Trick::new(Seat::North);
trick.play(card("9♦")).unwrap();
assert_eq!(greedy_play(hand("2..A.QA"), trick, Hand::EMPTY), card("Q♠"));
assert_eq!(greedy_play(hand("2..A.A"), trick, Hand::EMPTY), card("A♠"));
assert_eq!(
greedy_play(hand("2..A.A"), trick, Hand::QUEEN_OF_SPADES),
card("A♥")
);
}
#[test]
fn dead_queen_rides() {
let mut trick = Trick::new(Seat::North);
trick.play(card("2♠")).unwrap();
trick.play(card("A♠")).unwrap();
assert_eq!(greedy_play(hand("...5Q"), trick, Hand::EMPTY), card("Q♠"));
}
#[test]
fn forced_above_the_winner() {
let mut trick = Trick::new(Seat::North);
trick.play(card("5♠")).unwrap();
trick.play(card("2♠")).unwrap();
trick.play(card("3♠")).unwrap();
assert_eq!(greedy_play(hand("...QK"), trick, Hand::EMPTY), card("K♠"));
let mut early = Trick::new(Seat::North);
early.play(card("5♠")).unwrap();
assert_eq!(greedy_play(hand("...9K"), early, Hand::EMPTY), card("9♠"));
}
#[test]
fn moon_defense_never_spends_or_gifts_the_queen() {
use crate::Table;
use hearts::{PassDirection, Round, Rules};
let hands = [
hand("23456789TJQ...QK"), hand("A.23456789TJQ..J"), hand("..23456789TJQKA."), hand("K.KA..23456789TA"), ];
let round = Round::from_deal(Rules::new(), PassDirection::Hold, hands).unwrap();
let mut table = Table::new(round);
let config = HeuristicConfig {
moon_defense: 1,
..HeuristicConfig::default()
};
let mut defender = HeuristicBot::with_config(config);
for (seat, text) in [
(Seat::North, "2♣"),
(Seat::East, "A♣"),
(Seat::South, "2♥"),
(Seat::West, "K♣"),
] {
struct Fixed(Card);
impl Strategy for Fixed {
fn pass_cards(&mut self, _: &View<'_>) -> [Card; 3] {
unreachable!()
}
fn play_card(&mut self, _: &View<'_>) -> Card {
self.0
}
}
assert_eq!(table.turn(), Some(seat));
table.step(&mut Fixed(card(text))).unwrap();
}
for text in ["J♠", "3♥", "2♠"] {
struct Fixed(Card);
impl Strategy for Fixed {
fn pass_cards(&mut self, _: &View<'_>) -> [Card; 3] {
unreachable!()
}
fn play_card(&mut self, _: &View<'_>) -> Card {
self.0
}
}
let seat = table.turn().unwrap();
table.step(&mut Fixed(card(text))).unwrap();
let _ = seat;
}
assert_eq!(table.turn(), Some(Seat::North));
assert_eq!(defender.play_card(&table.view(Seat::North)), card("K♠"));
}
#[test]
fn smoke_out_the_queen() {
let trick = Trick::new(Seat::North);
let played = hand("2345...");
assert_eq!(greedy_play(hand("9.9.9.29"), trick, played), card("2♠"));
assert_eq!(greedy_play(hand("9.9..29Q"), trick, played), card("9♣"));
assert_eq!(greedy_play(hand("4.9..9Q"), trick, played), card("4♣"));
assert_eq!(greedy_play(hand("9.9.9.29K"), trick, played), card("9♣"));
assert_eq!(greedy_play(hand("9.9.9.2A"), trick, played), card("9♣"));
}
}