Struct WorldManager 

pub struct WorldManager { /* private fields */ }

Manages World state with concurrent access support.

WorldManager owns the World and processes state modifications through a command queue. This enables multiple ChannelRunners to modify the World without holding locks.

Thread Safety

• Reads: Via Arc<RwLock<World>> clone (parallel reads allowed)
• Writes: Via command queue (sequential, no contention)

Example

let (manager, cmd_tx) = WorldManager::new();

// Clone for read access
let world_read = manager.world();

// Spawn the manager loop
tokio::spawn(manager.run());

// Send commands
cmd_tx.send(WorldCommand::Kill { id, reason }).await?;

Implementations

impl WorldManager

pub fn new() -> (WorldManager, Sender<WorldCommand>)

Creates a new WorldManager with an empty World.

Returns the manager and a sender for commands.

Example

let (manager, cmd_tx) = WorldManager::new();
tokio::spawn(manager.run());

pub fn with_world(world: World) -> (WorldManager, Sender<WorldCommand>)

Creates a WorldManager with an existing World.

Use this when you need to initialize the World before starting the manager (e.g., creating the IO channel).

Example

let mut world = World::new();
let io = world.create_channel(ChannelConfig::interactive());

let (manager, cmd_tx) = WorldManager::with_world(world);

pub fn world(&self) -> Arc<RwLock<World>>

Returns a clone of the World handle for read access.

The returned Arc<RwLock<World>> can be shared across tasks for concurrent read access.

pub async fn run(self)

Runs the command processing loop.

This method consumes the manager and runs until:

• A Shutdown command is received
• All command senders are dropped (channel closed)

Example

let (manager, cmd_tx) = WorldManager::new();
let handle = tokio::spawn(manager.run());

// ... use cmd_tx ...

cmd_tx.send(WorldCommand::Shutdown).await?;
handle.await?;