Struct Pedestrian 

#[non_exhaustive]
pub struct Pedestrian {
    pub pos: Vec2,
    pub vel: Vec2,
    pub radius: f64,
    pub desired_speed: f64,
    pub destination: Vec2,
}

A single pedestrian agent as seen by every model in this crate.

This is intentionally a small, copy-friendly struct so model step functions can be called on &mut [Pedestrian] without any indirection.

Construction

Outside this crate, construct via Pedestrian::new, not struct literal syntax: the type is #[non_exhaustive] so that adding a field in a future minor version is a non-breaking change for downstream callers. Field-access (ped.pos, ped.vel = …) remains stable and is intentionally left pub so the SoA-friendly hot path stays indirection-free.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

pos: Vec2

Position in metres.

vel: Vec2

Velocity in m/s.

radius: f64

Body radius in metres (typical pedestrian: 0.2–0.3 m).

desired_speed: f64

Desired free-flow walking speed in m/s (Weidmann mean: 1.34 m/s).

destination: Vec2

Target destination in metres.

Implementations

impl Pedestrian

pub fn new( pos: Vec2, vel: Vec2, radius: f64, desired_speed: f64, destination: Vec2, ) -> Self

Constructs a Pedestrian from its five core fields.

This is the stable construction path for downstream callers: because Pedestrian is #[non_exhaustive], adding a field in a future minor version will not break callers that go through Pedestrian::new. Each new field will get a paired with_* setter (e.g. a hypothetical with_target_floor) so the extension stays additive.

pub fn to_destination(&self) -> Vec2

Vector from pos to destination.

pub fn desired_direction(&self) -> Vec2

Unit vector pointing at the destination, or [0, 0] if already there.

pub fn speed(&self) -> f64

Current speed |vel|.

pub fn distance_to_destination(&self) -> f64

Euclidean distance from pos to destination.

pub fn has_arrived(&self, arrival_radius: f64) -> bool

Returns true if the pedestrian is inside its arrival radius.

pub fn effective_desired_speed(&self, arrival_radius: f64) -> f64

Speed the pedestrian should aim for given how close it is to its destination. Produces a smooth linear taper from the full desired_speed at d ≥ arrival_radius down to 0 at d = 0, so agents do not overshoot their goal and then oscillate back toward it.

arrival_radius ≤ 0 disables the taper (returns desired_speed unchanged).

Trait Implementations

impl Clone for Pedestrian

fn clone(&self) -> Pedestrian

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Pedestrian

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Pedestrian

fn eq(&self, other: &Pedestrian) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Pedestrian

impl StructuralPartialEq for Pedestrian