Struct View 

pub struct View<'a> { /* private fields */ }

What one seat may legally see of a round

The wrapped Round is private, and these accessors are the whitelist: the opponent’s hand and the stock order are structurally unreachable.

Implementations

impl<'a> View<'a>

pub const fn seat(&self) -> Player

The seat this view belongs to

pub const fn game_margin(&self) -> i32

This seat’s lead in the game score: its running total minus the opponent’s, in points

Positive when ahead in the game, negative when behind. Always zero for a standalone round played outside a Game, which has no scoreboard. The game score is public — both players see it — so it is part of the legal whitelist. The target to win is rules().game_target.

pub const fn game_scores(&self) -> [u16; 2]

The running game totals, this seat’s first: [mine, theirs]

Note the order: seat-relative, unlike Table::scores, which is indexed by Player. Both totals sit on the scoreboard in plain sight, so they are part of the legal whitelist. [0, 0] for a standalone round played outside a Game; the target to win is rules().game_target.

pub const fn rules(&self) -> &'a Rules

The scoring rules of the round

pub const fn dealer(&self) -> Player

The dealer of the round

pub const fn knock_limit(&self) -> u8

The knock limit in effect

pub const fn phase(&self) -> Phase

The current phase of the round

pub fn discard_pile(&self) -> &'a [Card]

The discard pile, oldest first — the last card is the top

pub fn upcard(&self) -> Option<Card>

The top of the discard pile

pub fn stock_len(&self) -> usize

How many cards remain in the stock — the order is never visible

pub fn spread(&self) -> impl Iterator<Item = Meld> + 'a

The knocker’s spread, extended by any layoffs so far

Empty before a knock. Enumeration order gives the meld indices that Layoff::meld addresses.

pub const fn knocker(&self) -> Option<Player>

The knocker, if the round has reached a knock

pub const fn hand(&self) -> Hand

This seat’s hand

pub const fn taken_discard(&self) -> Option<Card>

The card this seat took from the pile this turn, which may not be shed until the next turn

pub const fn can_take_discard(&self) -> bool

Whether taking the top of the discard pile is available

True at the upcard offer and on a normal draw, false on the forced stock draw after both players pass the upcard.

pub const fn opponent_known(&self) -> Hand

Cards known to be in the opponent’s hand: taken from the pile and not yet shed or laid off

pub const fn opponent_shed(&self) -> Hand

Every card the opponent has discarded, whether or not it is still in the pile

pub const fn opponent_passed(&self) -> Hand

Upcards the opponent declined during the upcard phase

pub const fn opponent_hand_len(&self) -> usize

How many cards the opponent holds — 10, or 11 mid-turn

pub fn unseen(&self) -> Hand

The cards this seat cannot locate: the whole deck minus its own hand, the discard pile, the opponent’s known cards, and the spread

Exactly the cards a determinizing bot must distribute between the stock and the hidden part of the opponent’s hand. Until a knock reveals the spread, unseen().len() == stock_len() + opponent_hand_len() - opponent_known().len(); afterwards the spread also counts as seen.

pub fn deadwood(&self) -> u8

The minimum deadwood of this seat’s hand

pub fn best_melds(&self) -> Melds

A deadwood-minimizing arrangement of this seat’s hand