Struct Playing 

pub struct Playing { /* private fields */ }

Represents the state of a game during the playing phase.

This structure aggregates all state required to execute card play, including score tracking, player roles, player hands, the current play-sequence state machine, and items specific to the round such as the crib, starter card, and any pending actions.

Implementations

impl Playing

pub const fn new( scoreboard: Scoreboard, roles: Roles, hands: Hands, play_state: PlayState, crib: Crib, starter_cut: StarterCut, pending: Pending, ) -> Self

Constructs a new Playing instance from all required subcomponents.

All inputs must represent a consistent state at the beginning of the playing phase. The function does not perform validation; callers are responsible for ensuring that the inputs are coherent and legal for the game being implemented.

pub fn play_card(&mut self, card: Card)

Plays a card from the next player in turn order.

This method:

1. Determines which player is next to act via play_state.next_to_play().
2. Removes the specified card from that player’s hand.
3. Forwards the card to the play_state state machine to update peg totals, legality, and transition conditions.

Callers should ensure that the card is legal to play under the rules enforced by PlayState.

pub fn go(&mut self)

Signals “go” for the next player in turn order.

A “go” occurs when a player cannot legally play any card without exceeding the allowable running total. This method delegates to the play_state state machine to record the event and update turn order.

Caller should ensure the player has no valid cards to play.

Trait Implementations

impl Clone for Playing

fn clone(&self) -> Playing

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Playing

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Playing

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Playing

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HasCrib for Playing

fn crib(&self) -> &Crib

Immutable access to the crib.

fn crib_mut(&mut self) -> &mut Crib

Mutable access to the crib.

impl HasHands for Playing

fn hands(&self) -> &Hands

Immutable access to all hands.

fn hands_mut(&mut self) -> &mut Hands

Mutable access to all hands.

fn hand(&self, player: Player) -> &Hand

Returns an immutable reference to the given player’s hand.

fn hand_mut(&mut self, player: Player) -> &mut Hand

Returns a mutable reference to the given player’s hand.

impl HasPegging for Playing

fn pegging(&self) -> Option<&Pegging>

Returns an immutable reference to optional pegging information. This is used to provide pegging scores for hands and crib. The optional return allows for the most recent “play” pegging to be returned, in the case where no scoring play has been made yet.

impl HasPending for Playing

fn pending(&self) -> &Pending

Immutable access to the pending set.

fn pending_mut(&mut self) -> &mut Pending

Mutable access to the pending set.

impl HasPlayState for Playing

fn play_state(&self) -> &PlayState

Returns an immutable reference to the play state.

fn play_state_mut(&mut self) -> &mut PlayState

Returns a mutable reference to the play state.

impl HasRoles for Playing

fn roles(&self) -> &Roles

Returns an immutable reference to the roles.

fn roles_mut(&mut self) -> &mut Roles

Returns a mutable reference to the roles.

fn dealer(&self) -> &Dealer

Returns an immutable reference to the dealer.

fn pone(&self) -> &Pone

Returns an immutable reference to the pone (non-dealer).

impl HasScoreboard for Playing

fn scoreboard(&self) -> &Scoreboard

Returns an immutable reference to the scoreboard.

fn scoreboard_mut(&mut self) -> &mut Scoreboard

Returns a mutable reference to the scoreboard.

impl HasStarterCut for Playing

fn starter_cut(&self) -> &StarterCut

Returns the current starter card.

impl PartialEq for Playing

fn eq(&self, other: &Playing) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Playing

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Playing

impl StructuralPartialEq for Playing