Struct World 

pub struct World {
    pub globals: Vec<Value>,
    pub visit_counts: HashMap<DefinitionId, u32>,
    pub turn_counts: HashMap<DefinitionId, u32>,
    pub turn_index: u32,
    pub rng_seed: i32,
    pub previous_random: i32,
    /* private fields */
}

Shared game state that lives above individual flows.

Holds globals, visit/turn tracking, and RNG state. This is the natural serialization boundary for save/load (deferred).

Multiple FlowInstances can share a single World (matching inklecate’s semantics where flow writes are immediately visible to other flows), or each flow can hold its own cloned World if the consumer wants fork/branch/rollback semantics. The runtime’s step functions take &mut World (or any &mut impl ContextAccess) without prescribing where it lives.

Fields

globals: Vec<Value>

visit_counts: HashMap<DefinitionId, u32>

turn_counts: HashMap<DefinitionId, u32>

turn_index: u32

rng_seed: i32

previous_random: i32

Implementations

impl World

pub fn new(program: &Program, policy: &WorldPolicy) -> Result<Self, PolicyError>

Create a fresh World for program, resolving policy against the program’s symbol table.

Globals are initialized from the program’s declared defaults; visit counts, turn counts, turn index, and RNG state start zeroed — identical to FlowInstance::new_at’s inline construction. Fails if policy names a variable or knot/stitch the program doesn’t declare (PolicyError::UnknownName).

WorldPolicy::default() (all-World) always resolves — see ResolvedPolicy::all_world — so passing it here can’t produce a PolicyError.

pub fn new_for_testing( globals: Vec<Value>, visit_counts: HashMap<DefinitionId, u32>, turn_counts: HashMap<DefinitionId, u32>, turn_index: u32, rng_seed: i32, previous_random: i32, ) -> Self

Construct a World directly from its field values, with the all-World policy. Only for test fixtures that need to hand-build a World without a Program (e.g. bevy-brink’s commit-merge tests) — production code should go through World::new.

Trait Implementations

impl Clone for World

fn clone(&self) -> World

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ContextAccess for World

fn global(&self, idx: u32) -> &Value

fn set_global(&mut self, idx: u32, value: Value)

fn visit_count(&self, id: DefinitionId) -> u32

fn increment_visit(&mut self, id: DefinitionId)

fn set_visit_count(&mut self, id: DefinitionId, count: u32)

Set a visit count directly, rather than incrementing it. Used by crate::load_state to reconcile a durable save, whose entries carry absolute counts rather than deltas.

fn turn_count(&self, id: DefinitionId) -> Option<u32>

fn set_turn_count(&mut self, id: DefinitionId, turn: u32)

fn turn_index(&self) -> u32

fn increment_turn_index(&mut self)

fn set_turn_index(&mut self, index: u32)

Set the turn index directly, rather than incrementing it. Used by crate::load_state to restore a saved turn index.

fn rng_seed(&self) -> i32

fn set_rng_seed(&mut self, seed: i32)

fn previous_random(&self) -> i32

fn set_previous_random(&mut self, val: i32)

fn next_random<R: StoryRng>(&self, seed: i32) -> i32

fn random_sequence<R: StoryRng>(&self, seed: i32, count: usize) -> Vec<i32>

impl Debug for World

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

Formats the value using the given formatter.