Enum Fluff 

#[non_exhaustive]
pub enum Fluff {
    Beep,
    Happened,
    BlockFault(BlockFault),
    PlaceBlockGeneric,
    #[non_exhaustive]
    BlockImpact {
        velocity: PositiveSign<f32>,
    },
}

Momentary decorative and informative effects produced by the game world, such as sound and particles.

Each Fluff value represents the beginning of such an effect. It does not specify anything about the exact duration; the intent is that they should all be negligibly short.

Some fluff refers to events happening in a Space. In that case, the position and extent is communicated separately via SpaceFluff.

Currently, all Fluff is an item from a fixed list. In the future, it will be able to refer to audio and visual assets defined in a Universe.

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.

Beep

A standard beep/“bell” sound, as might be used for a notification or error.

Happened

A sound suitable for “something was activated or done”, e.g. a button was clicked.

BlockFault(BlockFault)

Something went wrong with the operation of a block present as placed in a Space.

PlaceBlockGeneric

Sound and visual effect from a block having been placed in the game world by player action, without any more specific overriding styling.

#[non_exhaustive]

BlockImpact

Collision between a block and a moving object.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

velocity: PositiveSign<f32>

Closing velocity in m/s.

Implementations

impl Fluff

pub fn sound(&self) -> Option<(&'static SoundDef, f32)>

Returns the sound that should be played and the amplitude multiplier with which it should be played.

Whether or not this sound should be spatialized depends on the context in which the Fluff was delivered.

TODO: The return value shouldn’t be 'static but a Handle; this is a development placeholder.

Trait Implementations

impl Clone for Fluff

fn clone(&self) -> Fluff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Fluff

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

Formats the value using the given formatter.

impl Hash for Fluff

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 Fluff

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl VisitHandles for Fluff

fn visit_handles(&self, _: &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 Fluff

impl StructuralPartialEq for Fluff