Struct HeadlessRunner 

pub struct HeadlessRunner<S> { /* private fields */ }

Headless game runner

Unlike GameRunner, this runner does not require a TUI or any rendering. It simply executes the game loop at a specified tick rate.

Example

use issun::prelude::*;
use issun::engine::HeadlessRunner;

#[tokio::main]
async fn main() -> Result<()> {
    let game = GameBuilder::new()
        .with_plugin(EconomyPlugin::default())?
        .build()
        .await?;

    let director = SceneDirector::new(
        MySimulation::new(),
        game.services,
        game.systems,
        game.resources,
    ).await;

    let runner = HeadlessRunner::new(director)
        .with_tick_rate(Duration::from_millis(100))
        .with_max_ticks(1000);

    runner.run().await?;
    Ok(())
}

Implementations

impl<S: Scene> HeadlessRunner<S>

pub fn new(director: SceneDirector<S>) -> Self

Create a headless runner with default tick rate (100ms).

pub fn with_tick_rate(self, tick_rate: Duration) -> Self

Override the tick rate (frame interval).

pub fn with_max_ticks(self, max_ticks: u64) -> Self

Set maximum number of ticks before stopping.

Useful for testing or running simulations for a fixed duration. If not set, the runner will continue until the director requests quit.

pub fn director(&self) -> &SceneDirector<S>

Borrow the underlying director.

pub fn director_mut(&mut self) -> &mut SceneDirector<S>

Mutable access to the director.

pub async fn run(self) -> Result<()>

Run the headless game loop until the director requests quit or max_ticks is reached.

impl<S: Scene> HeadlessRunner<S>

pub fn with_command_channel<Cmd: Event + Clone + Serialize>( self, command_rx: Receiver<Cmd>, ) -> ChannelHeadlessRunner<S, Cmd>

Add a command channel to create a ChannelHeadlessRunner.

Commands sent through the channel will be published to the EventBus immediately, allowing for low-latency (<1ms) command processing.

The command type must implement the Event trait and Serialize to be published to the EventBus.