Struct ClientWorld 

pub struct ClientWorld {
    pub entities: BTreeMap<NetworkId, SabSlot>,
    pub player_network_id: Option<NetworkId>,
    pub latest_tick: u64,
    pub system_manifest: BTreeMap<String, String>,
    pub shared_world_ref: Option<usize>,
    pub input_history: VecDeque<InputRecord>,
    pub last_reconciled_tick: u64,
    pub prediction_enabled: bool,
    pub room_bounds: Option<RoomBounds>,
}

A simplified client-side world that tracks entity states using SabSlot.

Fields

entities: BTreeMap<NetworkId, SabSlot>

Map of NetworkId to the last known authoritative state.

player_network_id: Option<NetworkId>

The network ID of the player’s own ship, if known.

latest_tick: u64

The latest tick received from the server.

system_manifest: BTreeMap<String, String>

Manifest of system-wide metadata.

shared_world_ref: Option<usize>

Optional shared world to push room bounds into directly (stored as usize for Send/Sync).

input_history: VecDeque<InputRecord>

History of inputs applied for Client-Side Prediction reconciliation.

last_reconciled_tick: u64

The latest server tick that has been reconciled.

prediction_enabled: bool

When true, the client simulates input locally and replays unacknowledged inputs on top of server snapshots (client-side prediction + reconciliation). When false, the client is pure server-authority: position is only updated from server transforms and no local simulation is performed for the local player.

room_bounds: Option<RoomBounds>

Authoritative world boundaries received from the server. Used for toroidal wrapping in Sandbox mode.

Implementations

impl ClientWorld

pub fn new() -> Self

Creates a new, empty ClientWorld.

prediction_enabled controls whether client-side prediction is active. Pass false for pure server-authority mode (recommended during debugging). Pass true to enable local simulation + reconciliation for responsive feel.

pub fn with_prediction(prediction_enabled: bool) -> Self

Creates a ClientWorld with explicit prediction setting.

impl ClientWorld

pub fn handle_game_event(&mut self, event: &GameEvent)

Handles discrete game events from the server.

impl ClientWorld

pub fn playground_apply_input( &mut self, move_x: f32, move_y: f32, actions_mask: u32, ) -> bool

Applies playground input to the local player entity. Used for Sandbox mode simulation.

Trait Implementations

impl Debug for ClientWorld

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

Formats the value using the given formatter.

impl Default for ClientWorld

fn default() -> Self

Returns the “default value” for a type.

impl WorldState for ClientWorld

fn get_local_id(&self, network_id: NetworkId) -> Option<LocalId>

Maps a protocol-level NetworkId to the ECS’s local entity handle.

fn get_network_id(&self, local_id: LocalId) -> Option<NetworkId>

Maps a local ECS entity handle back to its protocol-level NetworkId.

fn extract_deltas(&mut self) -> Vec<ReplicationEvent>

Extracts replication deltas for all components modified since the last tick.

fn apply_updates(&mut self, updates: &[(ClientId, ComponentUpdate)])

Injects parsed state updates from the network into the ECS.

fn simulate(&mut self)

Runs a single simulation frame for the ECS.

fn spawn_networked(&mut self) -> NetworkId

Spawns a new network-replicated entity and returns its NetworkId.

fn spawn_networked_for(&mut self, _client_id: ClientId) -> NetworkId

Spawns a new network-replicated entity owned by a specific client.

fn despawn_networked(&mut self, network_id: NetworkId) -> Result<(), WorldError>

Despawn a network-replicated entity by its NetworkId.

fn stress_test(&mut self, _count: u16, _rotate: bool)

Triggers a bulk spawn of entities for stress testing.

fn spawn_kind(&mut self, _kind: u16, _x: f32, _y: f32, _rot: f32) -> NetworkId

Spawns a new network-replicated entity of a specific kind.

fn clear_world(&mut self)

Despawns all entities from the world.

fn state_hash(&self) -> u64

Returns a deterministic hash of the entire world state.

fn extract_reliable_events(&mut self) -> Vec<(Option<ClientId>, WireEvent)>

Extracts discrete game events that should be sent reliably.

fn advance_tick(&mut self)

Advances the world change tick at the start of each server tick, before inputs are applied.

fn post_extract(&mut self)

Called once per tick after extract_deltas, before the next advance_tick.

fn spawn_kind_for( &mut self, kind: u16, x: f32, y: f32, rot: f32, _client_id: ClientId, ) -> NetworkId

Spawns a new network-replicated entity of a specific kind for a specific client.

fn spawn_session_ship( &mut self, kind: u16, x: f32, y: f32, rot: f32, client_id: ClientId, ) -> NetworkId

Spawns the authoritative session ship for a client and marks it as the possession target.

fn queue_reliable_event( &mut self, _client_id: Option<ClientId>, _event: GameEvent, )

Queues a reliable game event to be sent to a specific client (or all if None).

fn setup_world(&mut self)

Setups the initial world state (e.g. Master Room).

fn get_entity_room(&self, _network_id: NetworkId) -> Option<NetworkId>

Returns the Room network_id for a given entity, if any.

fn get_client_room(&self, _client_id: ClientId) -> Option<NetworkId>

Returns the Room network_id for a client’s session ship, if any.