Struct TurnState 

pub struct TurnState {

    pub active_player: u8,
    pub starting_player: u8,
    pub turn_number: u32,
    pub phase: Phase,
    pub mulligan_done: [bool; 2],
    pub mulligan_selected: [u64; 2],
    pub main_passed: bool,
    pub decision_count: u32,
    pub tick_count: u32,
    pub attack: Option<AttackContext>,
    pub attack_subphase_count: u8,
    pub pending_level_up: Option<u8>,
    pub encore_queue: Vec<EncoreRequest>,
    pub encore_step_player: Option<u8>,
    pub pending_triggers: Vec<PendingTrigger>,
    pub pending_triggers_sorted: bool,
    pub active_window: Option<TimingWindow>,
    pub end_phase_window_done: bool,
    pub end_phase_discard_done: bool,
    pub end_phase_climax_done: bool,
    pub end_phase_cleanup_done: bool,
    pub encore_window_done: bool,
    pub pending_losses: [bool; 2],
    pub damage_resolution_target: Option<u8>,
    pub cost_payment_depth: u8,
    pub pending_resolution_cleanup: Vec<(u8, CardInstanceId)>,
    pub cannot_use_auto_encore: [bool; 2],
    pub rule_overrides: Vec<RuleOverrideKind>,
    pub granted_abilities: Vec<GrantedAbilityInstance>,
    pub next_grant_id: u64,
    pub phase_step: u8,
    pub attack_phase_begin_done: bool,
    pub attack_decl_check_done: bool,
    pub encore_begin_done: bool,
    pub trigger_order: Option<TriggerOrderState>,
    pub choice: Option<ChoiceState>,
    pub target_selection: Option<TargetSelectionState>,
    pub pending_cost: Option<CostPaymentState>,
    pub priority: Option<PriorityState>,
    pub stack: Vec<StackItem>,
    pub pending_stack_groups: VecDeque<StackOrderState>,
    pub stack_order: Option<StackOrderState>,
    pub derived_attack: Option<DerivedAttackState>,
    pub next_trigger_id: u32,
    pub next_trigger_group_id: u32,
    pub next_choice_id: u32,
    pub next_stack_group_id: u32,
    pub next_damage_event_id: u32,
    pub next_effect_instance_id: u32,
    pub end_phase_pending: bool,
}

Turn-level state tracking.

Fields

active_player: u8

Seat whose turn it currently is.

starting_player: u8

Seat that started the game.

turn_number: u32

Turn counter (starting at 0 for mulligan).

phase: Phase

Current phase within the turn.

mulligan_done: [bool; 2]

Per-seat mulligan completion flags.

mulligan_selected: [u64; 2]

Per-seat packed mulligan selections.

main_passed: bool

Whether the main phase has been passed.

decision_count: u32

Decision counter for the episode.

tick_count: u32

Tick counter for the episode.

attack: Option<AttackContext>

Active attack context, if any.

attack_subphase_count: u8

Counter used to advance attack subphases deterministically.

pending_level_up: Option<u8>

Seat that must level up next, if any.

encore_queue: Vec<EncoreRequest>

Queue of encore requests to resolve.

encore_step_player: Option<u8>

Seat currently choosing encore, if any.

pending_triggers: Vec<PendingTrigger>

Pending triggers awaiting ordering/resolution.

pending_triggers_sorted: bool

Whether pending_triggers is already sorted for resolution.

active_window: Option<TimingWindow>

Current timing window for priority/auto effects.

end_phase_window_done: bool

Whether end-phase window has been processed.

end_phase_discard_done: bool

Whether end-phase discard has been processed.

end_phase_climax_done: bool

Whether end-phase climax cleanup has been processed.

end_phase_cleanup_done: bool

Whether end-phase general cleanup has been processed.

encore_window_done: bool

Whether encore window has been processed.

pending_losses: [bool; 2]

Per-seat pending loss flags.

damage_resolution_target: Option<u8>

Seat currently taking damage, if any.

cost_payment_depth: u8

Nested cost payment depth (re-entrancy guard).

pending_resolution_cleanup: Vec<(u8, CardInstanceId)>

Pending cleanup operations for the resolution zone.

cannot_use_auto_encore: [bool; 2]

Per-seat flag to disable auto-encore.

rule_overrides: Vec<RuleOverrideKind>

Active rule overrides for this turn.

granted_abilities: Vec<GrantedAbilityInstance>

Runtime granted abilities active this turn.

next_grant_id: u64

Next grant id allocator.

phase_step: u8

Internal step counter within the current phase.

attack_phase_begin_done: bool

Whether attack-phase begin effects have run.

attack_decl_check_done: bool

Whether attack declaration legality checks have run.

encore_begin_done: bool

Whether encore begin effects have run.

trigger_order: Option<TriggerOrderState>

Active trigger ordering prompt, if any.

choice: Option<ChoiceState>

Active choice prompt, if any.

target_selection: Option<TargetSelectionState>

Active target selection prompt, if any.

pending_cost: Option<CostPaymentState>

Active cost payment state, if any.

priority: Option<PriorityState>

Active priority window, if any.

stack: Vec<StackItem>

Effect stack items awaiting resolution.

pending_stack_groups: VecDeque<StackOrderState>

Pending stack groups awaiting an ordering decision.

stack_order: Option<StackOrderState>

Active stack ordering prompt, if any.

derived_attack: Option<DerivedAttackState>

Cached derived attack state, if any.

next_trigger_id: u32

Next trigger id allocator.

next_trigger_group_id: u32

Next trigger group id allocator.

next_choice_id: u32

Next choice id allocator.

next_stack_group_id: u32

Next stack group id allocator.

next_damage_event_id: u32

Next damage event id allocator.

next_effect_instance_id: u32

Next effect instance id allocator.

end_phase_pending: bool

Whether the end phase is currently pending execution.

Trait Implementations

impl Clone for TurnState

fn clone(&self) -> TurnState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TurnState

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

Formats the value using the given formatter.

impl Hash for TurnState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.