Struct game::app::PerMap

pub struct PerMap {
    pub map: Map,
    pub draw_map: DrawMap,
    pub sim: Sim,
    pub current_selection: Option<ID>,
    pub current_flags: Flags,
    pub last_warped_from: Option<(Pt2D, f64)>,
    pub sim_cb: Option<Box<dyn SimCallback>>,
    pub show_zorder: isize,
    pub zorder_range: (isize, isize),
    pub dirty_from_edits: bool,
    pub has_modified_trips: bool,
    pub unedited_map: RefCell<Option<Map>>,
    pub layer: Option<Box<dyn Layer>>,
    pub suspended_sim: Option<Sim>,
    prebaked: Option<(MapName, String, Analytics)>,
    pub scenario: Option<Scenario>,
}

All of the state that's bound to a specific map.

Fields

map: Map

draw_map: DrawMap

sim: Sim

current_selection: Option<ID>

current_flags: Flags

last_warped_from: Option<(Pt2D, f64)>

sim_cb: Option<Box<dyn SimCallback>>

show_zorder: isize

zorder_range: (isize, isize)

dirty_from_edits: bool

If we ever left edit mode and resumed without restarting from midnight, this is true.

has_modified_trips: bool

Any ScenarioModifiers in effect?

unedited_map: RefCell<Option<Map>>

Sometimes we need the map before any edits have been applied. Cache it here.

layer: Option<Box<dyn Layer>>

suspended_sim: Option<Sim>

Only filled out in edit mode. Stored here once to avoid lots of clones. Used for preview.

prebaked: Option<(MapName, String, Analytics)>

Only exists in some gameplay modes. Must be carefully reset otherwise. Has the map and scenario name too.

scenario: Option<Scenario>

The most recent Scenario loaded from a file. Don't depend on it always matching the current gameplay mode; always verify the name matches what's needed.

Storing this may cost some memory, but otherwise resetting to midnight would require loading it again from a file. This is particularly painful on the web!

Implementations

impl PerMap

fn map_loaded(
    map: Map,
    sim: Sim,
    splash: bool,
    flags: Flags,
    opts: &Options,
    cs: &ColorScheme,
    ctx: &mut EventCtx<'_>,
    timer: &mut Timer<'_>
) -> PerMap

pub fn clear_sim(&mut self) -> Sim

Returns whatever was there

pub fn calculate_unedited_map(&self)

If needed, makes sure the unedited_map is populated. Callers can then do self.unedited_map.borrow().unwrap_or(&self.map).