Struct Engine 

pub struct Engine { /* private fields */ }

The central game engine object.

Engine owns the World and Schedule and exposes a builder API for wiring up systems and plugins before (or during) the game loop.

Example

use galeon_engine::{Engine, Plugin, QueryMut, Component};

#[derive(Component)]
struct Score(u32);

fn add_score(mut scores: QueryMut<'_, Score>) {
    for (_, s) in scores.iter_mut() { s.0 += 1; }
}

struct MyPlugin;
impl Plugin for MyPlugin {
    fn build(&self, engine: &mut Engine) {
        engine.add_system::<(QueryMut<'_, Score>,)>("update", "add_score", add_score);
    }
}

let mut engine = Engine::new();
engine.add_plugin(MyPlugin);
engine.run_once();

Implementations

impl Engine

pub fn new() -> Self

Create a new engine with an empty World and Schedule.

pub fn world(&self) -> &World

Immutable reference to the world.

pub fn world_mut(&mut self) -> &mut World

Mutable reference to the world.

pub fn schedule(&self) -> &Schedule

Immutable reference to the schedule.

pub fn add_system<P>( &mut self, stage: &'static str, name: &'static str, func: impl IntoSystem<P>, ) -> &mut Self

Add a system to the schedule.

Accepts any parameterized function like fn(Res<T>, QueryMut<U>).

Delegates to Schedule::add_system. Returns &mut Self for chaining.

pub fn add_plugin(&mut self, plugin: impl Plugin) -> &mut Self

Apply a plugin to this engine.

Calls Plugin::build with self. Returns &mut Self for chaining.

pub fn set_tick_rate(&mut self, hz: f64) -> &mut Self

Set the fixed-timestep tick rate in Hz.

Common values: 10 Hz (RTS/tycoon), 20 Hz (strategy), 30 Hz (action), 60 Hz (platformer/FPS). If not called, defaults to 10 Hz on first tick.

pub fn insert_resource<T: Send + 'static>(&mut self, value: T) -> &mut Self

Insert a resource into the world.

Delegates to World::insert_resource. Returns &mut Self for chaining.

pub fn register_render_channel<T: ExtractToFloats>( &mut self, name: &str, ) -> &mut Self

Register a named render data channel.

The component type must implement ExtractToFloats. During frame extraction, this channel will produce a flat Vec<f32> with T::STRIDE floats per entity.

Lazily inserts a RenderChannelRegistry resource if not already present. Returns &mut Self for chaining.

pub fn tick(&mut self, elapsed: f64) -> u32

Advance the simulation by elapsed seconds using a fixed timestep.

If a FixedTimestep resource has not been inserted yet this method inserts the default RTS timestep (10 Hz) automatically. Returns the number of ticks executed.

pub fn run_once(&mut self)

Run the schedule exactly once without any fixed-timestep logic.

Useful for integration tests or non-game-loop scenarios.

pub fn pause(&mut self)

Pause the simulation. Ticks will produce zero simulation steps.

Lazily inserts a default VirtualTime if not already present.

pub fn resume(&mut self)

Resume the simulation after a pause.

Lazily inserts a default VirtualTime if not already present.

pub fn set_speed(&mut self, scale: f64)

Set the simulation speed multiplier (clamped to [0.0, 8.0] at tick time).

• 1.0 = normal speed
• 2.0 = double speed (RTS fast-forward)
• 0.5 = half speed (slow-mo)

Lazily inserts a default VirtualTime if not already present.

pub fn is_paused(&self) -> bool

Returns true if the simulation is paused.

Trait Implementations

impl Default for Engine

fn default() -> Self

Returns the “default value” for a type.