Struct game::sandbox::SandboxMode

pub struct SandboxMode {
    gameplay: Box<dyn GameplayState>,
    pub gameplay_mode: GameplayMode,
    pub controls: SandboxControls,
    recalc_unzoomed_agent: Option<Time>,
    last_cs: ColorSchemeChoice,
}

Fields

gameplay: Box<dyn GameplayState>

gameplay_mode: GameplayMode

controls: SandboxControls

recalc_unzoomed_agent: Option<Time>

last_cs: ColorSchemeChoice

Implementations

impl SandboxMode

pub fn simple_new(app: &mut App, mode: GameplayMode) -> Box<dyn State<App>>

If you don’t need to chain any transitions after the SandboxMode that rely on its resources being loaded, use this. Otherwise, see async_new.

pub fn async_new(
    app: &mut App,
    mode: GameplayMode,
    finalize: Box<dyn FnOnce(&mut EventCtx<'_>, &mut App) -> Vec<Transition<App>>>
) -> Box<dyn State<App>>

This does not immediately initialize anything (like loading the correct map, instantiating the scenario, etc). That means if you’re chaining this call with other transitions, you probably need to defer running them using finalize.

pub fn start_from_savestate(app: &App) -> Box<dyn State<App>>

Assumes that the map and simulation have already been set up, and starts by loading prebaked data.

pub fn contextual_actions(&self) -> Actions

Trait Implementations

impl State<App> for SandboxMode

fn event(&mut self, ctx: &mut EventCtx<'_>, app: &mut App) -> Transition<App>

Respond to a UI event, such as input or time passing.

fn draw(&self, g: &mut GfxCtx<'_>, app: &App)

Draw

fn on_destroy(&mut self, _: &mut EventCtx<'_>, app: &mut App)

Before this state is popped or replaced, call this.

fn draw_baselayer(&self) -> DrawBaselayer

Specifies what to draw before draw()

fn recreate(
    &mut self,
    &mut EventCtx<'_>,
    &mut A
) -> Box<dyn State<A> + 'static, Global>

Respond to Transition::Recreate by assuming state in the app has changed, but preserving the State-specific state appropriately.