Enum all_is_cubes::block::Modifier

#[non_exhaustive]
pub enum Modifier {
    Quote(Quote),
    Rotate(GridRotation),
    Composite(Composite),
    Zoom(Zoom),
    Move(Move),
    Inventory(Inventory),
}

Modifiers can be applied to a Block to change the result of evaluate()ing it, and thus create variations, such as rotations or combinations of multiple blocks.

Usage

Most modifiers have their own dedicated structs, such as Composite; these may be converted to Modifier using their From implementations, or by constructing the enum variant (Modifier::Composite) explicitly. Some modifiers have specific functions for constructing their typical usages, such as Block::rotate().

Block::with_modifier() is provided to conveniently add a single modifier to a block; Block::modifiers() and Block::modifiers_mut() provide general direct access. Note that Block is a clone-on-write type for when modifiers are changed.

Arranging modifiers

Operations which add or remove modifiers, such as Block::rotate(), follow some general principles and special cases:

• There should not be consecutive Rotate modifiers, but a single one with the combined rotation. Block::rotate() maintains this property.
• It is preferable to have Rotate appear last, since rotation and unrotation is part of player interaction, and the identity of block modifiers, not just their final result, determines whether blocks are equal for purposes of inventory management.
  • Composite::compose_or_replace() avoids applying Composite after Rotate, so that rotated versions of the same combination are represented identically.

There is not yet any general “algebra” defining all cases where combinations of modifiers should be canonicalized to other forms. Future versions of All is Cubes may do so; that will be a breaking change (particularly since Block::modifiers_mut() exists, so no rules are currently enforceable).

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.

Quote(Quote)

Suppresses all behaviors of the Block that might affect the space around it, (or itself).

Rotate(GridRotation)

Rotate the block about its cube center by the given rotation.

This modifier should normally be used by means of Block::rotate().

Composite(Composite)

Combine the voxels of multiple blocks using some per-voxel rule.

Zoom(Zoom)

Zoom in on a portion of the block; become part of a multi-block structure whose parts are parts of the original block.

Move(Move)

Displace the block out of the grid, cropping it.

Inventory(Inventory)

The block has an inventory (e.g. a chest, a dropped item, a machine).

TODO(inventory): Define means for a block definition to specify the properties the inventory should have (its size, at least), and how it is rendered into the block.

Trait Implementations

impl<'arbitrary> Arbitrary<'arbitrary> for Modifier

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for Modifier

fn clone(&self) -> Modifier

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Modifier

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

Formats the value using the given formatter.

impl From<Composite> for Modifier

fn from(value: Composite) -> Self

Converts to this type from the input type.

impl From<Move> for Modifier

fn from(value: Move) -> Self

Converts to this type from the input type.

impl From<Quote> for Modifier

fn from(value: Quote) -> Self

Converts to this type from the input type.

impl From<Zoom> for Modifier

fn from(value: Zoom) -> Self

Converts to this type from the input type.

impl Hash for Modifier

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 Modifier

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl VisitHandles for Modifier

fn visit_handles(&self, visitor: &mut dyn HandleVisitor)

For each Handle contained within self that is reachable without traversing another Handle, call visitor with a reference to it.

impl Eq for Modifier

impl StructuralPartialEq for Modifier