Struct GridTerrain 

pub struct GridTerrain<G>(pub G);

A Grid as a Terrain: solid tiles, one-way platforms, surfaces and pits by the grid’s answers. Wrap a borrow of your map (GridTerrain(&map)) to step through it each frame, or own it.

It builds on nothing and isn’t findable by find_mut (it may borrow). An ability that needs your map: write the Terrain yourself, forwarding to the grid’s Grid::overlaps_solid, Grid::on_platform and Grid::surface_of.

Tuple Fields

0: G

Trait Implementations

impl<G: Clone> Clone for GridTerrain<G>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G: Copy> Copy for GridTerrain<G>

impl<G: Debug> Debug for GridTerrain<G>

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

Formats the value using the given formatter.

impl<G: Grid> Terrain for GridTerrain<G>

fn solid(&self, r: Rect) -> bool

Whether r overlaps anything solid (walls, floors, ceilings, moving solids).

fn platform(&self, r: Rect) -> bool

Whether r stands exactly on top of a one-way platform (its bottom edge on the platform’s top). One-way platforms hold from above, let the character jump up through them, and drop it on down + jump.

fn surface(&self, r: Rect) -> Surface

What kind of ground or wall r touches: the row under the feet while standing, the column beside the body at a wall. Ice, conveyor belts, walls that can’t be climbed, bouncy pads (see Surface). Default: the base’s, or Surface::DEFAULT.

fn fell_out(&self, r: Rect) -> bool

Whether r is out of the world (fell into a pit).

fn base(&self) -> Option<&dyn Terrain>

The terrain this one builds on, which the defaults forward to, or None. terrain_layer! writes it with Terrain::base_mut and Terrain::as_any_mut. Required, so a wrapper can’t lose its base’s platforms, refills and pits by forgetting it.

fn refill(&mut self, r: Rect) -> bool

The character’s body r touches a dash refill: use it up and return true (it’s only asked when a dash is spent).

fn tick(&mut self, _dt: f32, _bodies: &[Rect])

This layer’s own update, once per step after the characters moved, with their bodies (one, unless several share the terrain through a crate::Party): let things fall onto them, refills come back, platforms move. Only this layer’s state: Terrain::update runs the bases’ ticks by itself. Default: nothing.

fn update(&mut self, dt: f32, bodies: &[Rect])

The whole terrain’s update: Terrain::tick on this layer, then on every base down the chain. Don’t write it; write Terrain::tick. Only an adapter that hands its base something else than it got (converted bodies, say) writes it, and then calls the base’s update.

fn carry(&self, r: Rect) -> (f32, f32)

How far the solid (or one-way platform) overlapping r moved in the last Terrain::update, in units: moving platforms, elevators.

fn base_mut(&mut self) -> Option<&mut dyn Terrain>

Terrain::base, to change. Return the same terrain from both (checked in debug builds).

fn as_any_mut(&mut self) -> Option<&mut dyn Any>

This terrain as itself, so an Ability can reach your type through find_mut (break a block, flip a switch): Some(self), which terrain_layer! writes. Default: None, it isn’t found (its Terrain::base still is).

fn as_any(&self) -> Option<&dyn Any>

Terrain::as_any_mut, to read: what find looks at. terrain_layer! writes both. Default: None.