Skip to main content

Simulation

event_simulation

Trait Simulation 

Source 
pub trait Simulation: SimulationState {
    type LoadData;
    type StateLoadingError;

    // Required methods
    fn reload(
        &mut self,
        data: Self::LoadData,
    ) -> Result<(), Self::StateLoadingError>;
    unsafe fn call(&mut self, event: Self::Event);
    unsafe fn revert(&mut self, event: Self::Event);

    // Provided methods
    fn try_call(&mut self, event: Self::Event) -> bool { ... }
    fn try_revert(&mut self, event: Self::Event) -> bool { ... }
    fn prepare_call(&mut self) -> CallState<'_, Self, Call> { ... }
    fn prepare_revert(&mut self) -> CallState<'_, Self, Revert> { ... }
}
Expand description

The Simulation trait extends SimulationState by providing mutable access to modify the simulation state via events.

Required Associated Types§

Source

type LoadData

The type of data used to load the simulation state.

Source

type StateLoadingError

The error type returned when loading the simulation state fails.

Required Methods§

Source

fn reload( &mut self, data: Self::LoadData, ) -> Result<(), Self::StateLoadingError>

Reloads the simulation state from the provided data.

§Errors

Returns an error if a valid state cannot be loaded from data.

Source

unsafe fn call(&mut self, event: Self::Event)

Calls the provided event.

§Safety

The caller must ensure that the event is valid and can be called in the current simulation state.

Source

unsafe fn revert(&mut self, event: Self::Event)

Reverts the provided event.

§Safety

The caller must ensure that the event is valid and can be reverted in the current simulation state.

Provided Methods§

Source

fn try_call(&mut self, event: Self::Event) -> bool

Tries to call the provided event and returns if it was successful.

Examples found in repository?
examples/text_adventure.rs (line 159)
132fn main() {
133    let adventure = Adventure {
134        rooms: vec![
135            "You stand at a crossroads.".into(),
136            "A dark cave yawns before you.".into(),
137            "Sunlight breaks over a quiet meadow.".into(),
138        ],
139        passages: vec![
140            passage("Enter the cave", 0, 1),
141            passage("Walk to the meadow", 0, 2),
142            passage("Retreat from the cave", 1, 0),
143        ],
144    };
145
146    let mut simulation = OwnedSimulation::<Adventure>::new(adventure);
147
148    let describe =
149        |simulation: &OwnedSimulation<Adventure>| simulation.rooms[*simulation.data()].clone();
150
151    println!("{}", describe(&simulation));
152    for choice in simulation.callables() {
153        println!("  → {}", simulation.passages[choice.0].text);
154    }
155
156    let Some(first) = simulation.callables().next() else {
157        panic!("crossroads has choices");
158    };
159    assert!(simulation.try_call(first));
160    assert_eq!(simulation.state.room, 1);
161    println!("\n{}", describe(&simulation));
162
163    let Some(back) = simulation.revertables().next() else {
164        panic!("cave can be left");
165    };
166    assert!(simulation.try_revert(back));
167    assert_eq!(simulation.state.room, 0);
168    println!("\nBack: {}", describe(&simulation));
169}
Source

fn try_revert(&mut self, event: Self::Event) -> bool

Tries to revert the provided event and returns if it was successful.

Examples found in repository?
examples/text_adventure.rs (line 166)
132fn main() {
133    let adventure = Adventure {
134        rooms: vec![
135            "You stand at a crossroads.".into(),
136            "A dark cave yawns before you.".into(),
137            "Sunlight breaks over a quiet meadow.".into(),
138        ],
139        passages: vec![
140            passage("Enter the cave", 0, 1),
141            passage("Walk to the meadow", 0, 2),
142            passage("Retreat from the cave", 1, 0),
143        ],
144    };
145
146    let mut simulation = OwnedSimulation::<Adventure>::new(adventure);
147
148    let describe =
149        |simulation: &OwnedSimulation<Adventure>| simulation.rooms[*simulation.data()].clone();
150
151    println!("{}", describe(&simulation));
152    for choice in simulation.callables() {
153        println!("  → {}", simulation.passages[choice.0].text);
154    }
155
156    let Some(first) = simulation.callables().next() else {
157        panic!("crossroads has choices");
158    };
159    assert!(simulation.try_call(first));
160    assert_eq!(simulation.state.room, 1);
161    println!("\n{}", describe(&simulation));
162
163    let Some(back) = simulation.revertables().next() else {
164        panic!("cave can be left");
165    };
166    assert!(simulation.try_revert(back));
167    assert_eq!(simulation.state.room, 0);
168    println!("\nBack: {}", describe(&simulation));
169}
Source

fn prepare_call(&mut self) -> CallState<'_, Self, Call>

Prepares a safe helper to list callable elements and choose one to call.

Source

fn prepare_revert(&mut self) -> CallState<'_, Self, Revert>

Prepares a safe helper to list revertable elements and choose one to revert.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§