Trait sim::mechanics::parking::ParkingSim[−][src]

pub trait ParkingSim {

Show methods    fn handle_live_edits(
        &mut self, 
        map: &Map, 
        timer: &mut Timer<'_>
    ) -> (Vec<ParkedCar>, Vec<CarID>);

    fn get_free_onstreet_spots(&self, l: LaneID) -> Vec<ParkingSpot>;

    fn get_free_offstreet_spots(&self, b: BuildingID) -> Vec<ParkingSpot>;

    fn get_free_lot_spots(&self, pl: ParkingLotID) -> Vec<ParkingSpot>;

    fn reserve_spot(&mut self, spot: ParkingSpot, car: CarID);

    fn unreserve_spot(&mut self, car: CarID);

    fn remove_parked_car(&mut self, p: ParkedCar);

    fn add_parked_car(&mut self, p: ParkedCar);

    fn get_draw_cars(&self, id: LaneID, map: &Map) -> Vec<DrawCarInput>;

    fn get_draw_cars_in_lots(&self, id: LaneID, map: &Map) -> Vec<DrawCarInput>;

    fn get_draw_car(&self, id: CarID, map: &Map) -> Option<DrawCarInput>;

    fn canonical_pt(&self, id: CarID, map: &Map) -> Option<Pt2D>;

    fn get_all_draw_cars(&self, map: &Map) -> Vec<DrawCarInput>;

    fn is_free(&self, spot: ParkingSpot) -> bool;

    fn get_car_at_spot(&self, spot: ParkingSpot) -> Option<&ParkedCar>;

    fn get_all_free_spots(
        &self, 
        driving_pos: Position, 
        vehicle: &Vehicle, 
        target: BuildingID, 
        map: &Map
    ) -> Vec<(ParkingSpot, Position)>;

    fn spot_to_driving_pos(
        &self, 
        spot: ParkingSpot, 
        vehicle: &Vehicle, 
        map: &Map
    ) -> Position;

    fn spot_to_sidewalk_pos(&self, spot: ParkingSpot, map: &Map) -> Position;

    fn get_owner_of_car(&self, id: CarID) -> Option<PersonID>;

    fn lookup_parked_car(&self, id: CarID) -> Option<&ParkedCar>;

    fn get_all_parking_spots(&self) -> (Vec<ParkingSpot>, Vec<ParkingSpot>);

    fn path_to_free_parking_spot(
        &self, 
        start: LaneID, 
        vehicle: &Vehicle, 
        target: BuildingID, 
        map: &Map
    ) -> Option<(Vec<PathStep>, ParkingSpot, Position)>;

    fn collect_events(&mut self) -> Vec<Event>;

    fn all_parked_car_positions(&self, map: &Map) -> Vec<(Position, PersonID)>;

    fn bldg_to_parked_cars(&self, b: BuildingID) -> Vec<CarID>;

}

Manages the state of parked cars. There are two implementations:

Required methods

fn handle_live_edits(
    &mut self,
    map: &Map,
    timer: &mut Timer<'_>
) -> (Vec<ParkedCar>, Vec<CarID>)[src]

Returns any cars that got very abruptly evicted from existence, and also cars actively moving into a deleted spot.

fn get_free_onstreet_spots(&self, l: LaneID) -> Vec<ParkingSpot>[src]

fn get_free_offstreet_spots(&self, b: BuildingID) -> Vec<ParkingSpot>[src]

fn get_free_lot_spots(&self, pl: ParkingLotID) -> Vec<ParkingSpot>[src]

fn reserve_spot(&mut self, spot: ParkingSpot, car: CarID)[src]

fn unreserve_spot(&mut self, car: CarID)[src]

Needed when abruptly deleting a car, in case they’re being deleted during their last step.

fn remove_parked_car(&mut self, p: ParkedCar)[src]

fn add_parked_car(&mut self, p: ParkedCar)[src]

fn get_draw_cars(&self, id: LaneID, map: &Map) -> Vec<DrawCarInput>[src]

fn get_draw_cars_in_lots(&self, id: LaneID, map: &Map) -> Vec<DrawCarInput>[src]

fn get_draw_car(&self, id: CarID, map: &Map) -> Option<DrawCarInput>[src]

fn canonical_pt(&self, id: CarID, map: &Map) -> Option<Pt2D>[src]

There’s no DrawCarInput for cars parked offstreet, so we need this.

fn get_all_draw_cars(&self, map: &Map) -> Vec<DrawCarInput>[src]

fn is_free(&self, spot: ParkingSpot) -> bool[src]

fn get_car_at_spot(&self, spot: ParkingSpot) -> Option<&ParkedCar>[src]

fn get_all_free_spots(
    &self,
    driving_pos: Position,
    vehicle: &Vehicle,
    target: BuildingID,
    map: &Map
) -> Vec<(ParkingSpot, Position)>[src]

The vehicle’s front is currently at the given driving_pos. Returns all valid spots and their driving position.

fn spot_to_driving_pos(
    &self,
    spot: ParkingSpot,
    vehicle: &Vehicle,
    map: &Map
) -> Position[src]

fn spot_to_sidewalk_pos(&self, spot: ParkingSpot, map: &Map) -> Position[src]

fn get_owner_of_car(&self, id: CarID) -> Option<PersonID>[src]

fn lookup_parked_car(&self, id: CarID) -> Option<&ParkedCar>[src]

fn get_all_parking_spots(&self) -> (Vec<ParkingSpot>, Vec<ParkingSpot>)[src]

(Filled, available)

fn path_to_free_parking_spot(
    &self,
    start: LaneID,
    vehicle: &Vehicle,
    target: BuildingID,
    map: &Map
) -> Option<(Vec<PathStep>, ParkingSpot, Position)>[src]

Unrealistically assumes the driver has knowledge of currently free parking spots, even if they’re far away. Since they don’t reserve the spot in advance, somebody else can still beat them there, producing some nice, realistic churn if there’s too much contention. But the implementation has some internal jitter between different vehicles, to discourage everybody near one spot from all competing for it. Note the first PathStep is the turn after start, NOT PathStep::Lane(start).

fn collect_events(&mut self) -> Vec<Event>[src]

fn all_parked_car_positions(&self, map: &Map) -> Vec<(Position, PersonID)>[src]

fn bldg_to_parked_cars(&self, b: BuildingID) -> Vec<CarID>[src]

Loading content...

Implementors

impl ParkingSim for ParkingSimState[src]

fn handle_live_edits(
    &mut self,
    __enum_dispatch_arg_0: &Map,
    __enum_dispatch_arg_1: &mut Timer<'_>
) -> (Vec<ParkedCar>, Vec<CarID>)[src]

Returns any cars that got very abruptly evicted from existence, and also cars actively moving into a deleted spot.

fn unreserve_spot(&mut self, __enum_dispatch_arg_0: CarID)[src]

Needed when abruptly deleting a car, in case they’re being deleted during their last step.

fn canonical_pt(
    &self,
    __enum_dispatch_arg_0: CarID,
    __enum_dispatch_arg_1: &Map
) -> Option<Pt2D>[src]

There’s no DrawCarInput for cars parked offstreet, so we need this.

fn get_all_free_spots(
    &self,
    __enum_dispatch_arg_0: Position,
    __enum_dispatch_arg_1: &Vehicle,
    __enum_dispatch_arg_2: BuildingID,
    __enum_dispatch_arg_3: &Map
) -> Vec<(ParkingSpot, Position)>[src]

The vehicle’s front is currently at the given driving_pos. Returns all valid spots and their driving position.

fn get_all_parking_spots(&self) -> (Vec<ParkingSpot>, Vec<ParkingSpot>)[src]

(Filled, available)

fn path_to_free_parking_spot(
    &self,
    __enum_dispatch_arg_0: LaneID,
    __enum_dispatch_arg_1: &Vehicle,
    __enum_dispatch_arg_2: BuildingID,
    __enum_dispatch_arg_3: &Map
) -> Option<(Vec<PathStep>, ParkingSpot, Position)>[src]

Unrealistically assumes the driver has knowledge of currently free parking spots, even if they’re far away. Since they don’t reserve the spot in advance, somebody else can still beat them there, producing some nice, realistic churn if there’s too much contention. But the implementation has some internal jitter between different vehicles, to discourage everybody near one spot from all competing for it. Note the first PathStep is the turn after start, NOT PathStep::Lane(start).

impl ParkingSim for InfiniteParkingSimState[src]

impl ParkingSim for NormalParkingSimState[src]

Loading content...