Enum Event 

#[non_exhaustive]
pub enum Event {
    Jumped {
        kind: JumpKind,
        buffered: bool,
    },
    JumpCut,
    Apex,
    LeftGround,
    DroppedThrough,
    Landed {
        impact: f32,
        drop: i32,
    },
    RollStarted,
    RollEnded,
    HardLanded,
    Recovered,
    Dashed {
        dx: f32,
        dy: f32,
    },
    DashEnded,
    Recharged {
        crystal: bool,
    },
    Grabbed,
    LetGo,
    ClimbHop,
    StaminaOut,
    DiveStarted,
    SuperCharged,
    SuperDashStarted {
        dir: i32,
    },
    SuperDashEnded {
        bonk: bool,
    },
    GlideStarted,
    GlideEnded,
    DiveImpact {
        drop: i32,
    },
    Bonked,
    CornerCorrected {
        dx: i32,
    },
    FellOut,
    Custom {
        id: CustomId,
        data: [f32; 4],
    },
    Squished,
    Respawned,
}

Something that happened in one step. New moves bring new events, 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.

Jumped

The hero jumped. buffered: the press came before the jump was possible and waited in the jump buffer.

Fields

kind: JumpKind

Which kind of jump.

buffered: bool

Whether the press was queued.

JumpCut

The hero let go of jump while rising and the jump was cut short.

Apex

Vertical speed crossed zero going up to down in the air.

LeftGround

The hero walked or rolled off the ground (not by jumping).

DroppedThrough

Down + jump on a one-way platform: dropping through it.

Landed

The hero touched down.

Fields

impact: f32

Downward speed at contact, units/s (pixels/s from a scaled crate::Platformer).

drop: i32

Units fallen from the highest point of the airtime (pixels from a scaled crate::Platformer).

RollStarted

A landing turned into a roll.

RollEnded

The roll ran out (not by jumping).

HardLanded

A landing from high up without moving: a heavy landing that costs control.

Recovered

A heavy landing or a dive impact is over.

Dashed

A dash started, in direction dx, dy (8-way, normalized, y down).

Fields

dx: f32

Horizontal direction.

dy: f32

Vertical direction.

DashEnded

The dash ran out and handed over its leftover speed.

Recharged

Dashes were refilled, on the ground or by a crystal.

Fields

crystal: bool

By a crystal (in the air), not by the ground.

Grabbed

Grabbed a wall.

LetGo

Let go of a wall (released grab, wall ended, or out of stamina).

ClimbHop

Climbed over the top of a wall with a small hop.

StaminaOut

Stamina ran out on a wall.

DiveStarted

A dive started: a short hang, then straight down.

SuperCharged

The super dash finished charging: release to launch.

SuperDashStarted

The super dash launched.

Fields

dir: i32

Direction, -1 or 1.

SuperDashEnded

The super dash is over.

Fields

bonk: bool

It hit a wall (otherwise it was cancelled).

GlideStarted

The cloak opened: gliding.

GlideEnded

The glide is over (jump released, landed, a wall, a dash).

DiveImpact

A dive hit the ground.

Fields

drop: i32

Units fallen from the dive’s start (pixels from a scaled crate::Platformer).

Bonked

The head hit a ceiling.

CornerCorrected

The head clipped a ceiling corner and was nudged past it.

Fields

dx: i32

Units nudged, signed (pixels from a scaled crate::Platformer).

FellOut

The character fell out of the world (the terrain said so).

Custom

Something of your own happened (an Ability reported it). Make one with Event::custom and add numbers with Event::with.

Fields

id: CustomId

Which of your events (see CustomId).

data: [f32; 4]

Up to four numbers of your own: a knockback’s speed, a hit target’s index, a charge level. Zero when unused.

Squished

Something solid moved into the character (moving ground carried it into a ceiling, a moving solid hit it): it’s stuck inside. Reported every step it stays so; usually a respawn.

Respawned

It was put back at its spawn point (after falling out, unless respawning is off).

Implementations

impl Event

pub const fn custom(id: CustomId) -> Self

A custom event id without data.

pub const fn with(self, data: [f32; 4]) -> Self

This event with data (only for Event::Custom; other events stay as they are).

pub fn in_pixels(self, k: i32) -> Self

This event with its distances and speeds in pixels, k per unit: a landing’s drop and impact, a dive impact’s drop, a corner correction’s dx. What a crate::Platformer with a crate::Builder::scale hands out; directions and Event::Custom data (yours, in units) stay as they are.

pub fn custom_data(&self, id: CustomId) -> Option<[f32; 4]>

The data of custom event id, if this is one.

Trait Implementations

impl Clone for Event

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 Event

impl Debug for Event

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

Formats the value using the given formatter.

impl PartialEq for Event

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Event