Struct map_model::Map

pub struct Map {
    roads: Vec<Road>,
    lanes: Vec<Lane>,
    intersections: Vec<Intersection>,
    turns: BTreeMap<TurnID, Turn>,
    buildings: Vec<Building>,
    bus_stops: BTreeMap<BusStopID, BusStop>,
    bus_routes: Vec<BusRoute>,
    areas: Vec<Area>,
    parking_lots: Vec<ParkingLot>,
    boundary_polygon: Polygon,
    stop_signs: BTreeMap<IntersectionID, ControlStopSign>,
    traffic_signals: BTreeMap<IntersectionID, ControlTrafficSignal>,
    gps_bounds: GPSBounds,
    bounds: Bounds,
    config: MapConfig,
    pathfinder: Pathfinder,
    pathfinder_dirty: bool,
    zones: Vec<Zone>,
    name: MapName,
    edits: MapEdits,
}

Fields

roads: Vec<Road>

lanes: Vec<Lane>

intersections: Vec<Intersection>

turns: BTreeMap<TurnID, Turn>

buildings: Vec<Building>

bus_stops: BTreeMap<BusStopID, BusStop>

bus_routes: Vec<BusRoute>

areas: Vec<Area>

parking_lots: Vec<ParkingLot>

boundary_polygon: Polygon

stop_signs: BTreeMap<IntersectionID, ControlStopSign>

traffic_signals: BTreeMap<IntersectionID, ControlTrafficSignal>

gps_bounds: GPSBounds

bounds: Bounds

config: MapConfig

pathfinder: Pathfinder

pathfinder_dirty: bool

zones: Vec<Zone>

name: MapName

edits: MapEdits

Implementations

impl Map

pub fn new_edits(&self) -> MapEdits

pub fn get_edits(&self) -> &MapEdits

pub fn unsaved_edits(&self) -> bool

pub fn get_r_edit(&self, r: RoadID) -> EditRoad

pub fn edit_road_cmd<F: Fn(&mut EditRoad)>(&self, r: RoadID, f: F) -> EditCmd

pub fn get_i_edit(&self, i: IntersectionID) -> EditIntersection

Panics on borders

pub fn save_edits(&self)

pub fn must_apply_edits(
    &mut self,
    new_edits: MapEdits
) -> (BTreeSet<RoadID>, BTreeSet<TurnID>, BTreeSet<TurnID>, BTreeSet<IntersectionID>)

pub fn try_apply_edits(&mut self, new_edits: MapEdits)

fn apply_edits(
    &mut self,
    new_edits: MapEdits,
    enforce_valid: bool
) -> (BTreeSet<RoadID>, BTreeSet<TurnID>, BTreeSet<TurnID>, BTreeSet<IntersectionID>)

pub fn recalculate_pathfinding_after_edits(&mut self, timer: &mut Timer<'_>)

This can expensive, so don't constantly do it while editing in the UI. But this must happen before the simulation resumes.

pub fn incremental_edit_traffic_signal(&mut self, signal: ControlTrafficSignal)

Since the player is in the middle of editing, the signal may not be valid. Don't go through the entire apply_edits flow.

impl Map

pub fn create_from_raw(
    raw: RawMap,
    build_ch: bool,
    keep_bldg_tags: bool,
    timer: &mut Timer<'_>
) -> Map

impl Map

pub fn import_minimal(
    name: MapName,
    bounds: Bounds,
    gps_bounds: GPSBounds,
    intersections: Vec<Intersection>,
    roads: Vec<Road>,
    lanes: Vec<Lane>,
    turns: Vec<Turn>
) -> Map

Use for creating a map directly from some external format, not from a RawMap.

impl Map

pub fn new(path: String, timer: &mut Timer<'_>) -> Map

pub fn map_loaded_directly(&mut self)

If you have to deserialize a Map directly, call this after. Prefer using Map::new though.

pub fn blank() -> Map

Just for temporary std::mem::replace tricks.

pub fn all_roads(&self) -> &Vec<Road>

pub fn all_lanes(&self) -> &Vec<Lane>

pub fn all_intersections(&self) -> &Vec<Intersection>

pub fn all_turns(&self) -> &BTreeMap<TurnID, Turn>

pub fn all_buildings(&self) -> &Vec<Building>

pub fn all_areas(&self) -> &Vec<Area>

pub fn all_parking_lots(&self) -> &Vec<ParkingLot>

pub fn all_zones(&self) -> &Vec<Zone>

pub fn maybe_get_r(&self, id: RoadID) -> Option<&Road>

pub fn maybe_get_l(&self, id: LaneID) -> Option<&Lane>

pub fn maybe_get_i(&self, id: IntersectionID) -> Option<&Intersection>

pub fn maybe_get_t(&self, id: TurnID) -> Option<&Turn>

pub fn maybe_get_b(&self, id: BuildingID) -> Option<&Building>

pub fn maybe_get_pl(&self, id: ParkingLotID) -> Option<&ParkingLot>

pub fn maybe_get_a(&self, id: AreaID) -> Option<&Area>

pub fn maybe_get_bs(&self, id: BusStopID) -> Option<&BusStop>

pub fn maybe_get_stop_sign(
    &self,
    id: IntersectionID
) -> Option<&ControlStopSign>

pub fn maybe_get_traffic_signal(
    &self,
    id: IntersectionID
) -> Option<&ControlTrafficSignal>

pub fn maybe_get_br(&self, route: BusRouteID) -> Option<&BusRoute>

pub fn get_r(&self, id: RoadID) -> &Road

pub fn get_l(&self, id: LaneID) -> &Lane

pub fn get_i(&self, id: IntersectionID) -> &Intersection

pub fn get_t(&self, id: TurnID) -> &Turn

pub fn get_b(&self, id: BuildingID) -> &Building

pub fn get_a(&self, id: AreaID) -> &Area

pub fn get_pl(&self, id: ParkingLotID) -> &ParkingLot

pub fn get_stop_sign(&self, id: IntersectionID) -> &ControlStopSign

pub fn get_traffic_signal(&self, id: IntersectionID) -> &ControlTrafficSignal

pub fn get_turns_in_intersection(&self, id: IntersectionID) -> Vec<&Turn>

pub fn get_turns_from_lane(&self, l: LaneID) -> Vec<&Turn>

The turns may belong to two different intersections!

pub fn get_turns_to_lane(&self, l: LaneID) -> Vec<&Turn>

pub fn get_turn_between(
    &self,
    from: LaneID,
    to: LaneID,
    parent: IntersectionID
) -> Option<TurnID>

pub fn get_next_turns_and_lanes(
    &self,
    from: LaneID,
    parent: IntersectionID
) -> Vec<(&Turn, &Lane)>

pub fn get_turns_for(
    &self,
    from: LaneID,
    constraints: PathConstraints
) -> Vec<&Turn>

pub fn get_next_roads(&self, from: RoadID) -> BTreeSet<RoadID>

pub fn get_parent(&self, id: LaneID) -> &Road

pub fn get_gps_bounds(&self) -> &GPSBounds

pub fn get_bounds(&self) -> &Bounds

pub fn get_city_name(&self) -> &String

pub fn get_name(&self) -> &MapName

pub fn all_bus_stops(&self) -> &BTreeMap<BusStopID, BusStop>

pub fn get_bs(&self, stop: BusStopID) -> &BusStop

pub fn get_br(&self, route: BusRouteID) -> &BusRoute

pub fn all_bus_routes(&self) -> &Vec<BusRoute>

pub fn get_bus_route(&self, name: &str) -> Option<&BusRoute>

pub fn get_routes_serving_stop(&self, stop: BusStopID) -> Vec<&BusRoute>

pub fn building_to_road(&self, id: BuildingID) -> &Road

pub fn all_incoming_borders(&self) -> Vec<&Intersection>

This and all_outgoing_borders are expensive to constantly repeat

pub fn all_outgoing_borders(&self) -> Vec<&Intersection>

pub fn save(&self)

pub fn find_driving_lane_near_building(&self, b: BuildingID) -> LaneID

Cars trying to park near this building should head for the driving lane returned here, then start their search. Some parking lanes are connected to driving lanes that're "parking blackholes" -- if there are no free spots on that lane, then the roads force cars to a border.

pub fn get_boundary_polygon(&self) -> &Polygon

pub fn pathfind(&self, req: PathRequest) -> Result<Path>

pub fn pathfind_avoiding_lanes(
    &self,
    req: PathRequest,
    avoid: BTreeSet<LaneID>
) -> Option<Path>

pub fn should_use_transit(
    &self,
    start: Position,
    end: Position
) -> Option<(BusStopID, Option<BusStopID>, BusRouteID)>

pub fn get_movement(&self, t: TurnID) -> Option<MovementID>

pub fn find_r_by_osm_id(&self, id: OriginalRoad) -> Result<RoadID>

pub fn find_i_by_osm_id(&self, id: NodeID) -> Result<IntersectionID>

pub fn find_b_by_osm_id(&self, id: OsmID) -> Option<BuildingID>

pub fn find_br(&self, id: RelationID) -> Option<BusRouteID>

pub fn hack_override_offstreet_spots(&mut self, spots_per_bldg: usize)

pub fn hack_override_offstreet_spots_individ(
    &mut self,
    b: BuildingID,
    spots: usize
)

pub fn hack_override_bldg_type(
    &mut self,
    b: BuildingID,
    bldg_type: BuildingType
)

pub fn hack_override_orig_spawn_times(
    &mut self,
    br: BusRouteID,
    times: Vec<Time>
)

pub fn get_languages(&self) -> BTreeSet<&str>

pub fn get_config(&self) -> &MapConfig

pub fn simple_path_btwn(
    &self,
    i1: IntersectionID,
    i2: IntersectionID
) -> Option<Vec<RoadID>>

Simple search along undirected roads

Trait Implementations

impl<'de> Deserialize<'de> for Map

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for Map

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.