Struct Player 

pub struct Player {
    pub x: i32,
    pub y: i32,
    pub vx: f32,
    pub vy: f32,
    pub facing: i32,
    pub mode: Mode,
    pub air_jumps: u8,
    pub dashes: u8,
    pub stamina: f32,
    /* private fields */
}

The hero’s body. What a game or an Ability may change is public: position (a nudge; Player::teleport for a jump elsewhere), speed, facing, mode and refills. The movement’s own state (timers, latches, what it stands on) is read through methods: written by hand it could leave the body in a state the movement never produces.

Fields

x: i32

Left edge of the hitbox, units (the movement’s space; see docs/scale.md).

y: i32

Top edge of the hitbox, units.

vx: f32

Horizontal speed, units/s (pixels/s only at a scale of 1; see docs/scale.md).

vy: f32

Vertical speed, units/s, positive down.

facing: i32

1 facing right, -1 facing left.

mode: Mode

What the body is busy with.

air_jumps: u8

Air jumps left.

dashes: u8

Dashes left.

stamina: f32

Climbing stamina left.

Implementations

impl Player

pub fn at((x, y): (i32, i32), t: &Tuning) -> Self

Standing with its hitbox’s top-left at x, y (units), with everything refilled.

pub fn launch(&mut self, vx: f32, vy: f32)

Set the speed from outside: a spring, a bounce pad, knockback. Whatever the body was busy with ends (a dash, a dive, a climb), a jump in progress can no longer be sustained or cut, and going up leaves the ground for good (no coyote jump).

pub fn teleport(&mut self, x: i32, y: i32)

Put the hitbox’s top-left at x, y (units) without moving through what’s between: a door, a portal. The sub-pixel remainder is dropped and the airtime starts over; speed and state stay (follow with Player::launch to stop it). Teleported into the air while standing, it walks off as if from a ledge.

pub fn refill(&mut self, t: &Tuning)

Refill dashes, air jumps and climbing stamina, as touching the ground does.

pub fn rect(&self) -> Rect

The hitbox.

pub fn exact_pos(&self) -> (f32, f32)

Position with the sub-pixel remainder, for drawing between steps.

pub fn step( &mut self, level: &dyn Terrain, i: &Intent, moves: &Moves, t: &Tuning, dt: f32, ev: &mut Vec<Event>, )

One step of dt seconds (see the module docs for the order), with the built-in moves moves allows.

pub fn mode_time(&self) -> f32

Seconds in the current timed mode (0 for untimed ones).

pub fn wall(&self, level: &dyn Terrain, side: i32) -> bool

Whether a solid wall touches the hitbox on side (-1 left, 1 right).

pub fn climbable(&self, level: &dyn Terrain, side: i32) -> bool

Whether a wall the character may hold on to touches the hitbox on side: solid, and its super::Surface climbable.

pub fn feet(&self) -> Rect

The row just under the hitbox.

pub fn beside(&self, side: i32) -> Rect

The column just beside the hitbox on side (-1 left, 1 right).

pub fn riding(&self) -> Option<Rect>

What the body rides on: the row under its feet while standing, the column beside it while holding on to a wall, or nothing.

pub fn ride( &mut self, level: &dyn Terrain, carry: Option<(f32, f32)>, t: &Tuning, dt: f32, )

Carried dx, dy units in a step of dt by the moving ground (or moving wall) it rides, or None when it rides nothing. Moved through the same unit-by-unit collision, testing only the edge it moves toward, so the ground it rides (now overlapping the feet when rising) doesn’t hold it back. Its speed becomes Player::lift, which a jump keeps for Tuning::coyote_time after leaving.

impl Player

The movement’s own state, to read (drivers, debug overlays).

pub fn w(&self) -> i32

Hitbox width in units, from Tuning::size.

pub fn h(&self) -> i32

Hitbox height in units, from Tuning::size.

pub fn grounded(&self) -> bool

Standing on something.

pub fn coyote(&self) -> f32

Coyote time left.

pub fn buffer(&self) -> f32

Jump buffer time left: a press waiting to become a jump.

pub fn dash_buffer(&self) -> f32

Dash buffer time left: a press waiting to become a dash.

pub fn var_jump(&self) -> f32

Variable-jump time left: holding jump keeps the upward speed.

pub fn dash_cooldown(&self) -> f32

Seconds until the next dash may start.

pub fn force_move(&self) -> f32

Seconds the stick is overridden after a wall jump.

pub fn drop_through(&self) -> f32

Seconds platforms still let the hero through after dropping.

pub fn wall_slide(&self) -> i32

Side of the wall being slid down (-1, 1), or 0.

pub fn wall_stick(&self) -> f32

Wall-stick time left: pressing away from the wall slid down doesn’t let go yet.

pub fn slipping(&self) -> bool

Holding on to a wall but sliding down it (a slipping or tired grip).

pub fn regrab(&self) -> f32

Seconds before a wall can be grabbed again after hopping over its top.

pub fn look(&self) -> i32

Looking up (-1) or down (1) while standing still, or 0.

pub fn look_time(&self) -> f32

Seconds the current look has been held.

pub fn gliding(&self) -> bool

Gliding.

pub fn peak_y(&self) -> i32

Highest (smallest) y of this airtime (units), for the drop height on landing.

pub fn lift(&self) -> (f32, f32)

The speed of the moving ground (or wall) ridden, units/s, smoothed over about LIFT_SMOOTHING seconds: a jump keeps it.

pub fn contacts(&self) -> Contacts

What its movement ran into in the last step.

Trait Implementations

impl Clone for Player

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Player

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

Formats the value using the given formatter.

impl PartialEq for Player

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Player