Struct veloren_common::terrain::block::Block

pub struct Block {
    kind: BlockKind,
    data: [u8; 3],
}

Format

BBBBBBBB CCCCCCCC AAAAAIII IIIIIIII

• 0..8 : BlockKind
• 8..16 : Category
• 16..N : Attributes (many fields)
• N..32 : Sprite ID

N is per-category. You can match on the category byte to find the length of the ID field.

Attributes are also per-category. Each category specifies its own list of attribute fields.

Why is the sprite ID at the end? Simply put, it makes masking faster and easier, which is important because extracting the SpriteKind is a more commonly performed operation than extracting attributes.

Fields

kind: BlockKind

data: [u8; 3]

Implementations

impl Block

pub const MAX_HEIGHT: f32 = 3f32

pub const fn from_raw(kind: BlockKind, data: [u8; 3]) -> Self

pub const fn new(kind: BlockKind, color: Rgb<u8>) -> Self

pub fn unfilled(kind: BlockKind, sprite: SpriteKind) -> Self

pub fn air(sprite: SpriteKind) -> Self

pub const fn empty() -> Self

pub fn water(sprite: SpriteKind) -> Self

pub const fn get_sprite(&self) -> Option<SpriteKind>

pub(super) const fn sprite_category_byte(&self) -> u8

pub const fn sprite_category(&self) -> Option<Category>

pub fn with_attr<A: Attribute>( self, attr: A, ) -> Result<Self, AttributeError<Infallible>>

Build this block with the given sprite attribute set.

pub fn set_attr<A: Attribute>( &mut self, attr: A, ) -> Result<(), AttributeError<Infallible>>

Set the given attribute of this block’s sprite.

pub fn get_attr<A: Attribute>(&self) -> Result<A, AttributeError<A::Error>>

Get the given attribute of this block’s sprite.

pub(super) const fn data(&self) -> [u8; 3]

pub(super) const fn with_data(self, data: [u8; 3]) -> Self

pub(super) const fn to_be_u32(self) -> u32

pub fn get_color(&self) -> Option<Rgb<u8>>

pub fn get_ori(&self) -> Option<u8>

pub fn get_rtsim_resource(&self) -> Option<ChunkResource>

Returns the rtsim resource, if any, that this block corresponds to. If you want the scarcity of a block to change with rtsim’s resource depletion tracking, you can do so by editing this function.

pub fn get_glow(&self) -> Option<u8>

pub fn get_max_sunlight(&self) -> (u8, f32)

pub fn is_solid(&self) -> bool

pub fn valid_collision_dir( &self, entity_aabb: Aabb<f32>, block_aabb: Aabb<f32>, move_dir: Vec3<f32>, ) -> bool

pub fn explode_power(&self) -> Option<f32>

Can this block be exploded? If so, what ‘power’ is required to do so? Note that we don’t really define what ‘power’ is. Consider the units arbitrary and only important when compared to one-another.

pub fn collectible_id(&self) -> Option<Option<LootSpec<&'static str>>>

pub fn is_collectible(&self) -> bool

pub fn is_mountable(&self) -> bool

pub fn mount_offset(&self) -> Option<(Vec3<f32>, Vec3<f32>)>

Get the position and direction to mount this block if any.

pub fn is_controller(&self) -> bool

pub fn is_bonkable(&self) -> bool

pub fn is_owned(&self) -> bool

pub fn mine_tool(&self) -> Option<ToolKind>

The tool required to mine this block. For blocks that cannot be mined, None is returned.

pub fn is_opaque(&self) -> bool

pub fn solid_height(&self) -> f32

pub fn get_friction(&self) -> f32

Get the friction constant used to calculate surface friction when walking/climbing. Currently has no units.

pub fn get_traction(&self) -> f32

Get the traction permitted by this block as a proportion of the friction applied.

1.0 = default, 0.0 = completely inhibits movement, > 1.0 = potential for infinite acceleration (in a vacuum).

pub fn with_toggle_light(self, enable: bool) -> Option<Self>

Apply a light toggle to this block, if possible

pub fn kind(&self) -> BlockKind

pub fn with_data_of(self, other: Block) -> Self

If possible, copy the sprite/color data of the other block.

pub fn with_sprite(self, sprite: SpriteKind) -> Self

If this block is a fluid, replace its sprite.

pub fn with_ori(self, ori: u8) -> Option<Self>

If this block can have orientation, give it a new orientation.

pub fn with_adjacent_type(self, adj: RelativeNeighborPosition) -> Option<Self>

If this block can have adjacent sprites, give it its AdjacentType

pub fn into_vacant(self) -> Self

Remove the terrain sprite or solid aspects of a block

pub fn from_u32(x: u32) -> Option<Self>

Attempt to convert a u32 to a block

pub fn to_u32(self) -> u32

Methods from Deref<Target = BlockKind>

pub fn elim<'a, Elim, Context, S, Type>( &'a self, elim: Elim, context: Context, ) -> (Type, S)

where Elim: Typed<((&'a BlockKind,), Context), Type, S>,

pub fn elim_case_pure<'a, Type>(&self, cases: &'a PureCases<Type>) -> &'a Type

pub fn elim_case_weak<'a, 'b, Type>( &'a self, cases: &'b ElimWeak<Self, Type>, ) -> &'b Type

where WeakHead<Pure<Type>, Type>: SynthTyped<(), Type>, &'b ElimWeak<Self, Type>: Typed<((&'a BlockKind,), ()), &'b Type, ()>,

pub fn is_air(&self) -> bool

pub fn is_fluid(&self) -> bool

Determine whether the block kind is a gas or a liquid. This does not consider any sprites that may occupy the block (the definition of fluid is ‘a substance that deforms to fit containers’)

pub fn is_liquid(&self) -> bool

pub fn liquid_kind(&self) -> Option<LiquidKind>

pub fn is_filled(&self) -> bool

Determine whether the block is filled (i.e: fully solid). Right now, this is the opposite of being a fluid.

pub fn has_color(&self) -> bool

Determine whether the block has an RGB color stored in the attribute fields.

pub fn is_terrain(&self) -> bool

Determine whether the block is ‘terrain-like’. This definition is arbitrary, but includes things like rocks, soils, sands, grass, and other blocks that might be expected to the landscape. Plant matter and snow are not included.

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Block

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FilledVox for Block

fn default_non_filled() -> Self

fn is_filled(&self) -> bool

fn or(self, other: Self) -> Self

impl Hash for Block

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 Block

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Deref for Block

type Target = BlockKind

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Copy for Block

impl Eq for Block

impl StructuralPartialEq for Block