Struct PlaneOrder 

pub struct PlaneOrder { /* private fields */ }

The order the planes of a launch take a level’s tiles in, where a plane level spans the launch rather than one cube (Levels::launch_planes): in blocks, each a box of tiles held by consecutive planes, the blocks taken in a CubeOrder over their grid.

A plane of the launch is numbered by its cube and its place in it, cube · planes_per_cube + UNIT_POS_Y, the cube read off the grid’s x and y. Where a block holds a cube’s planes, as it does unless cubes_of says otherwise, each cube takes one block, and the launch deals its tiles as a cube level with a plane level inside it would. Any order is right: the planes share nothing, so the order only says which tiles the planes of one cube take together.

Every plane the launch spawns walks one tile, as every plane of a cube level’s cube does: a plane past the last tile, of a block the edge cuts short or of a cube past the last block, walks one past the grid, which the binding masks (PlaneOrder::overruns). So the planes of a cube all reach any barrier one of them meets.

Implementations

impl PlaneOrder

pub fn new(block: &[(Axis, usize)], block_order: CubeOrder) -> Self

Blocks of block tiles, one tile a plane, taken in block_order, one block a cube: what a cube level holding a plane level of block hands out.

pub fn cubes_of(self, planes: usize) -> Self

This order with the launch’s cubes holding planes planes each, which need not be a block’s: a block then spans several cubes, or a cube several blocks.

pub fn planes_per_cube(&self) -> usize

pub fn block_along(&self, axis: Axis) -> usize

Tiles one block holds along axis.

pub fn block_order(&self) -> CubeOrder

Trait Implementations

impl Clone for PlaneOrder

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 PlaneOrder

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

Formats the value using the given formatter.

impl Eq for PlaneOrder

impl Hash for PlaneOrder

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PlaneOrder

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PlaneOrder