Enum Mode 

#[non_exhaustive]
pub enum Mode {
    Normal,
    Roll {
        t: f32,
    },
    HardLand {
        t: f32,
    },
    Dash {
        t: f32,
        dx: f32,
        dy: f32,
    },
    Climb,
    Dive {
        t: f32,
    },
    SuperCharge {
        t: f32,
        wall: i32,
    },
    SuperDash {
        dir: i32,
    },
    DiveLand {
        t: f32,
    },
    Custom {
        id: CustomId,
        t: f32,
    },
}

What the body is busy with, beyond plain running and jumping. New moves bring new modes, so matches need a _ arm.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Normal

Free movement.

Roll

Rolling out of a high landing.

Fields

t: f32

Seconds since the roll started.

HardLand

Recovering from a hard landing.

Fields

t: f32

Seconds since touching down.

Dash

Dashing in a fixed direction, gravity off.

Fields

t: f32

Seconds since the dash started.

dx: f32

Horizontal direction (normalized with dy).

dy: f32

Vertical direction, positive down.

Climb

Holding on to the wall on the facing side.

Dive

Diving: a short hang, then straight down.

Fields

t: f32

Seconds since the dive started.

SuperCharge

Charging a super dash, standing (wall 0) or holding on to the wall on side wall.

Fields

t: f32

Seconds charged.

wall: i32

Side of the wall held, or 0 on the ground.

SuperDash

Flying a super dash: straight and level until a wall or a cancel.

Fields

dir: i32

Direction, -1 or 1.

DiveLand

Recovering from a dive’s impact.

Fields

t: f32

Seconds since the impact.

Custom

A move of your own (super::Ability) has the body: no built-in move starts or runs, no gravity; it still moves by its speed, collides and lands.

Fields

id: CustomId

Which of your moves (see super::CustomId; the same kind of id as Event::Custom).

t: f32

Seconds since it started (counted by the movement).

Trait Implementations

impl Clone for Mode

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Mode

impl Debug for Mode

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

Formats the value using the given formatter.

impl PartialEq for Mode

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Mode