Struct Engine 

pub struct Engine<SD, F>
where
    F: Fn(&mut SD, &Time),
{
    pub state_machine: StateMachine<SD>,
    pub state_data: SD,
    pub time: Time,
    /* private fields */
}

The main structure of the engine core loop. It holds the data necessary to the execution of a game engine.

Generics:

• SD: Type of the data passed to states.
• F: Post update function.

Fields

state_machine: StateMachine<SD>

The inner state machine. You can verify that it is still running using

engine.state_machine.is_running();

state_data: SD

The game data that we are using to drive the execution.

time: Time

The inner clock keeping track of time.

Implementations

impl<SD, F> Engine<SD, F>

where F: Fn(&mut SD, &Time),

pub fn new<I>( init_state: I, init_state_data: SD, post_update: F, max_fps: f32, ) -> Engine<SD, F>

where I: State<SD> + 'static,

Creates a new Engine. The initial state and state data will be used to initialize the state machine. The post update function will be stored. It is called at the end of game frames. max_fps specifies the maximum number of frames that can happen within a second.

Generics:

I: Initial state.

pub fn engine_frame(&mut self, sleep: bool) -> bool

Runs a single frame of the engine. Returns false if this was the last frame the engine will run and returns true if the engine can be run again. The sleep argument specifies if this function should take care of sleeping the thread. It is recommended to always have it to true, except in the case where you are using the engine in an async context. If set to false, the Time argument in the post_update callback will be meaningless and you will have to calculate the time difference yourself.

This function is most useful when called from WASM or in the context of another loop. For instance, winit and bracket-lib are both libraries that require control of the main loop, for compatibility with mobile and web platforms. Here, we can let them take care of the main loop and simple call engine_frame.

pub fn engine_loop(&mut self)

Runs the engine until the state machine quits. Generics:

• SD: The type of the data that is passed to states when updating.
• I: The type of the initial state. This is the first state that it started when the engine is started.
• F: The post update function. This function is called after each loop of of the engine. It receives the state data mutable and a reference to the structure keeping track of the time. This function is called after sleeping at the end of the frame, which means it is equivalent to the start of the next frame.