Enum all_is_cubes::inv::Tool

#[non_exhaustive]
pub enum Tool {
    Activate,
    RemoveBlock {
        keep: bool,
    },
    Block(Block),
    InfiniteBlocks(Block),
    CopyFromSpace,
    EditBlock,
    PushPull,
    Jetpack {
        active: bool,
    },
    Custom {
        op: Operation,
        icon: Block,
    },
    ExternalAction {
        function: EphemeralOpaque<dyn Fn(&ToolInput) + Send + Sync>,
        icon: Block,
    },
}

A Tool is an object which a character can use to have some effect in the game, such as placing or removing a block. In particular, a tool use usually corresponds to a click.

Currently, Tools also play the role of “inventory items”. This may change in the future.

Serialization stability warning

This type implements serde::Serialize and serde::Deserialize, but serialization support is still experimental (as is the game data model in general). We do not guarantee that future versions of all-is-cubes will be able to deserialize data which is serialized by this version.

Additionally, the serialization schema is designed with serde_json in mind. It is not guaranteed that using a different data format crate, which may use a different subset of the information exposed via serde::Serialize, will produce stable results.

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.

Activate

“Click”, or “push button”, or generally “activate the function of this” as opposed to editing it.

This can activate an ActivatableRegion. It may have more functions in the future.

RemoveBlock

Fields

keep: bool

If true, move it to inventory. If false, discard it entirely.

Delete any targeted block from the space.

Block(Block)

Move the given block out of inventory (consuming this tool) into the targeted empty space.

InfiniteBlocks(Block)

Places copies of the given block in targeted empty space. Infinite uses.

CopyFromSpace

Copy block from space to inventory.

EditBlock

Teleport into a block’s space for editing.

TODO: This is not yet actually implemented.

PushPull

Push targeted block into adjacent cube.

Jetpack

Fields

active: bool

Actually currently flying?

Allows flight.

TODO: This should probably be a feature a tool can have rather than a single-purpose item, but we don’t yet have a plan for programmable items.

Custom

Fields

op: Operation

Operation to perform when the tool is used.

icon: Block

Icon for the tool.

A tool which performs an arbitrary Operation.

ExternalAction

Fields

function: EphemeralOpaque<dyn Fn(&ToolInput) + Send + Sync>

Function that will be called when the tool is activated.

icon: Block

Icon for the tool.

A tool which calls an arbitrary function. TODO: This is not used and should perhaps be folded into Custom

Implementations

impl Tool

pub fn use_tool( self, input: &ToolInput ) -> Result<(Option<Self>, UniverseTransaction), ToolError>

Computes the effect of using the tool.

The effect consists of both mutations to self and a UniverseTransaction. If the result is None then the tool is deleted. If the transaction does not succeed, the original Tool value should be kept.

TODO: Return type is inelegant

pub fn use_immutable_tool( &self, input: &ToolInput ) -> Result<UniverseTransaction, ToolError>

As Self::use_tool, except that it does not allow the tool to modify itself.

This operation is used for special cases where an action is expressed by a tool but the tool is not a “game item”.

pub fn icon<'a>( &'a self, predefined: &'a BlockProvider<Icons> ) -> Cow<'a, Block>

Return a block to use as an icon for this tool. For tools that place blocks, has the same appearance as the block to be placed. The display name of the block should be the display name of the tool.

TODO (API instability): Eventually we will probably want additional decorations that probably should not need to be painted into the block itself.

Trait Implementations

impl Clone for Tool

fn clone(&self) -> Tool

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tool

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tool

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Tool> for Slot

fn from(tool: Tool) -> Self

Converts to this type from the input type.

impl Hash for Tool

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 Tool

fn eq(&self, other: &Tool) -> 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 Serialize for Tool

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl VisitRefs for Tool

fn visit_refs(&self, visitor: &mut dyn RefVisitor)

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

impl Eq for Tool

impl StructuralEq for Tool

impl StructuralPartialEq for Tool