Struct MonteCarloBot 

pub struct MonteCarloBot<R: Rng> { /* private fields */ }

A determinized Monte Carlo player

At every decision the bot samples hidden worlds consistent with its View — the opponent holds every card they are known to have taken, and the remaining unseen cards are distributed between their hand and the stock, biased toward the meld-rich hands a real opponent collects — plays each world out with the greedy policy on both seats, and picks the action with the best expected value for the game: each rollout’s result lands on the running game scores, a result that reaches game_target counts as the win or loss of the game it is, and anything short of one counts its round points. The same worlds are reused across candidate actions (common random numbers), and the bot deviates from the greedy baseline only when the paired samples show a statistically clear gain. Worlds are rolled in growing batches, and a challenger the incumbent already statistically dominates is dropped at a batch boundary — once none remain, the remaining worlds are never rolled at all — so an easy decision costs a fraction of the full sample count.

The bot owns its random number generator, so a seeded generator makes its play reproducible.

Implementations

impl<R: Rng> MonteCarloBot<R>

pub const fn new(rng: R) -> Self

A bot with default strength: 128 worlds per decision

pub const fn samples(self, samples: u32) -> Self

Set how many worlds each decision samples

More samples play stronger and slower. At the default of 128 the bot wins about 65% of decisive rounds against the default HeuristicBot — which is tuned for whole-game play and so concedes single rounds — at roughly 10 ms per average turn in release builds (easy decisions stop at a fraction of the budget; a hard first discard, where every shed stays plausible, runs the full count for ~25 ms); 32 keeps a smaller edge at a quarter of the cost. The parallel feature divides any of these by most of a machine’s cores.

pub fn assess(&mut self, view: &View<'_>) -> Vec<Assessment>

Assess every candidate action for the current decision, each with its Monte Carlo equity and expected round points, ranked by equity with the bot’s own pick flagged — the read a solver or hint view shows

The candidates and the flagged pick mirror the matching Strategy method on the same sampled worlds, so the recommended row is the move the bot would play — with one deliberate contraction: a knock’s shed is not a real choice (dropping the largest deadwood is always the best knock), so the discard phase lists a single knock rather than one per shed. Returns empty when the seat has no real choice: a forced stock draw, the layoff phase, or a finished round.

Trait Implementations

impl<R: Rng> Strategy for MonteCarloBot<R>

fn offer_upcard(&mut self, view: &View<'_>) -> UpcardAction

Take or pass the initial upcard

fn choose_draw(&mut self, view: &View<'_>) -> DrawAction

Draw from the stock or the discard pile

fn play_turn(&mut self, view: &View<'_>) -> TurnAction

Discard, knock, or declare big gin

fn choose_layoff(&mut self, view: &View<'_>) -> Option<Layoff>

Lay one card off onto the knocker’s spread, or None to finish

fn name(&self) -> &str

A display name for tournament output