Struct World 

pub struct World {
    pub player: Player,
    pub tuning: Tuning,
    pub spawn: Spot,
    pub respawn: bool,
    pub tick: u64,
    pub events: Vec<Event>,
    pub abilities: Vec<Box<dyn Ability>>,
    /* private fields */
}

The character’s movement: its body, its feel, and the bookkeeping between steps. The world around it is a Terrain passed to every World::step, so it stays yours.

Fields

player: Player

The character’s body.

tuning: Tuning

The movement feel.

spawn: Spot

Where it starts, and comes back to after falling out (units).

respawn: bool

Put it back at World::spawn when it falls out (an Event::FellOut is reported either way).

tick: u64

Steps taken so far.

events: Vec<Event>

What happened in the last step.

abilities: Vec<Box<dyn Ability>>

Moves of your own, run in every step in this order (see Ability).

Implementations

impl World

pub fn new(tuning: Tuning, spawn: Spot) -> Self

A character standing at spawn (units).

pub fn scale(&self) -> i32

Pixels of the game’s terrain per unit: 1 for a world stepped on its own, k under a crate::Platformer with a Builder::scale(k). Abilities get it as Step::scale, to ask a terrain they find in its pixels.

pub fn on(level: &Level, tuning: Tuning) -> Self

A character at level’s spawn tile.

pub fn ability<T: Ability + 'static>(&self) -> Option<&T>

The first ability of type T, to read its state (a charge level, a phase): for a driver of its animation, or the game.

pub fn ability_mut<T: Ability + 'static>(&mut self) -> Option<&mut T>

World::ability, to change.

pub fn step(&mut self, terrain: &mut dyn Terrain, intent: &Intent)

Advance one step of DT with intent in terrain. World::events then holds what happened in this step.

It runs World::act, the terrain’s Terrain::update and World::settle; several characters on one terrain run those apart, so the terrain updates once per step (see crate::Party).

pub fn act(&mut self, terrain: &mut dyn Terrain, intent: &Intent)

The first part of a step: the character moves (your abilities, the built-in moves, refills, bouncy ground), the terrain doesn’t update yet.

pub fn act_among( &mut self, terrain: &mut dyn Terrain, intent: &Intent, others: &[Rect], )

World::act beside other characters, whose bodies its abilities see in Step::others (a crate::Party passes them).

pub fn settle(&mut self, terrain: &mut dyn Terrain, extra: Option<(f32, f32)>)

The last part of a step, after the terrain’s update: moving ground (and conveyor belts) carry the character (extra adds to how far, for riding on other characters), and it may be squished or fall out.

pub fn respawn_at(&mut self, at: Spot)

Start over at at (units): a fresh body, standing, with everything refilled, and an Event::Respawned in World::events. For hazards and checkpoints; World::spawn stays as it is.

Trait Implementations

impl Clone for World

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 World

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

Formats the value using the given formatter.

impl Driver<World> for HeroDriver

fn drive(&mut self, w: &World, p: &mut Params)

Set params from subject: bools and floats every time, triggers when something happened.