Struct BlockDef 

pub struct BlockDef {

    pub id: String,
    pub hardness: f32,
    pub resistance: f32,
    pub name: Option<String>,
    pub shape: Option<[f32; 6]>,
    pub light_level: u8,
    pub sound: Option<String>,
    pub requires_tool: bool,
    pub no_collision: bool,
    pub slipperiness: f32,
    pub connects: bool,
    pub connect_groups: Vec<String>,
    pub inventory_id: Option<String>,
    pub redstone_source: bool,
    pub facing: Option<Facing>,
    pub placement: Placement,
    pub attach: bool,
    pub waterlogged: bool,
    pub properties: Vec<BlockProperty>,
    pub powered: Option<String>,
    pub comparator: Option<String>,
    pub accepts_items: bool,
    pub no_occlusion: bool,
    pub kind: String,
    pub base: Option<String>,
    pub set: Option<String>,
    pub press_ticks: u32,
    pub mobs_only: bool,
}

A custom block to register; it also gets a matching block-item.

Fields

id: String

hardness: f32

resistance: f32

name: Option<String>

shape: Option<[f32; 6]>

Optional collision/outline box in pixel units (0–16): [x1,y1,z1,x2,y2,z2]. None = full cube.

light_level: u8

Light emitted by this block (0 = none, 15 = max, like a torch).

sound: Option<String>

Its [SoundGroup]: one of the game’s by name ("stone", "amethyst", "copper" — [SoundGroup::built_in]) or a mod’s ("mymod:crystal"). None = stone (Minecraft default).

requires_tool: bool

If true, the correct tool (from the block’s tags) is required for drops.

no_collision: bool

If true, entities pass through this block (like flowers or torches).

slipperiness: f32

Friction coefficient. 0.0 = default (0.6). Ice = 0.989.

connects: bool

If true, this block dynamically grows arms toward neighbors it’s compatible with (fence/pipe-style): the Java host tracks N/S/E/W/U/D boolean blockstate properties, recomputed on placement and on neighbor change, and grows the collision/outline shape from the shape core box (or a default post) out to each connected side.

connect_groups: Vec<String>

Connection compatibility tags (configured in code via .connect_groups(&[...]) — see that method’s docs for how this drives which blocks link up). Independent of connects: a block can carry tags purely as a connection target (e.g. an ALU accepting a Digital Cable) without dynamically growing its own shape.

inventory_id: Option<String>

Id of a YogInventoryDef this block is backed by — None = plain block (default). See yog_inventory’s DESIGN.md.

redstone_source: bool

Gives off redstone power — how much, per position, the mod sets with block::set_redstone_output.

facing: Option<Facing>

How it turns when placed (a facing property); None: it doesn’t.

placement: Placement

Which way it turns when placed.

attach: bool

It hangs on a floor, wall or ceiling, as a button (a face property and a horizontal facing).

waterlogged: bool

It can stand in water (a waterlogged property).

properties: Vec<BlockProperty>

Properties of its own.

powered: Option<String>

A yes/no property the block keeps on while it gets redstone power.

comparator: Option<String>

A yes/no property a comparator reads 15 from while it’s on.

accepts_items: bool

Hoppers and droppers can put items into it (on_item_insert).

no_occlusion: bool

It doesn’t hide the faces behind it or stop light (as glass, a door).

kind: String

One of the game’s kinds of block it is (stairs, slab, door, trapdoor, button, pressure_plate, fence, fence_gate): the host makes it of the game’s class, with that class’s states; "": a block of Yog’s own.

base: Option<String>

The block a kind is made from (stairs act as it).

set: Option<String>

A kind’s set — a registered block set by name (oak, iron…; a fence gate’s wood type); None: oak.

press_ticks: u32

How long a button stays pressed, ticks.

mobs_only: bool

Only living things set off a button or a pressure plate (not items or arrows).

Implementations

impl BlockDef

pub fn new(id: impl Into<String>) -> Self

pub fn strength(self, hardness: f32, resistance: f32) -> Self

Mining hardness and blast resistance (defaults 1.5 / 6.0).

pub fn name(self, name: impl Into<String>) -> Self

Display name shown in-game.

pub fn shape(self, [x1, y1, z1]: [f32; 3], [x2, y2, z2]: [f32; 3]) -> Self

Custom hitbox/outline in pixel units (0–16): its lowest corner and its highest.

pub fn light_level(self, level: u8) -> Self

Emitted light level (0–15).

pub fn sound(self, group: impl Into<String>) -> Self

Sound group: one of the game’s ("stone", "amethyst"…) or a mod’s [SoundGroup] ("mymod:crystal").

pub fn requires_tool(self) -> Self

Correct tool required for loot drops (equivalent to requiresTool()).

pub fn no_collision(self) -> Self

No physical collision — entities pass through (like flowers).

pub fn slipperiness(self, value: f32) -> Self

Friction (default 0.6). Set to 0.989 for ice-like slipperiness.

pub fn connects_to_neighbors(self) -> Self

Dynamically grow arms toward compatible neighbors — fence/pipe-style. “Compatible” means the neighbor also has a connect_groups tag in common (set here, or via connect_groups alone on a static target block). Call .connect_groups(&[...]) too, or this connects to nothing. See the connects field doc.

pub fn connect_groups(self, groups: &[&str]) -> Self

Connection compatibility tags — two blocks link up (for connects_to_neighbors arm growth, and as valid connection targets generally) when their tag sets share at least one entry. Example: analog_cable and redstone_port both carry "analog"; digital_cable carries "digital"; an ALU block carries both, so it accepts either cable while a Redstone Port only accepts the analog one.

pub fn redstone_source(self) -> Self

Back this block with a real Container/Menu inventory screen, whose shape/layout was registered separately via Registry::register_inventory — see yog_inventory::InventoryDef. id is that def’s id. A redstone power source: what each placed block gives off is set with block::set_redstone_output (0 until then).

pub fn facing(self, ways: Facing, placement: Placement) -> Self

Turns when placed: "horizontal" or "all" ways, its front (the model’s north side) "toward" the placer or "away" (the way they look).

pub fn attach(self) -> Self

Hangs on a floor, wall or ceiling, as a button.

pub fn waterlogged(self) -> Self

Can stand in water.

pub fn property(self, name: &str, values: &[&str]) -> Self

A property of its own: values, the first the default.

pub fn powered(self, name: &str) -> Self

Keeps yes/no property name on while it gets redstone power.

pub fn comparator(self, name: &str) -> Self

A comparator reads 15 from it while yes/no property name is on.

pub fn accepts_items(self) -> Self

Hoppers and droppers can put items into it (on_item_insert).

pub fn inventory(self, id: impl Into<String>) -> Self

pub fn no_occlusion(self) -> Self

Doesn’t hide the faces behind it or stop light (as glass).

pub fn kind(self, kind: &str) -> Self

One of the game’s kinds of block ("stairs", "door"…).

pub fn base(self, id: impl Into<String>) -> Self

The block a kind is made from.

pub fn set(self, name: &str) -> Self

A kind’s block set ("oak", "dark_oak", "iron"…).

pub fn press_ticks(self, ticks: u32) -> Self

How long a button stays pressed, ticks (30 by default).

pub fn mobs_only(self) -> Self

Only living things set off a button or a pressure plate.

Trait Implementations

impl Clone for BlockDef

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 BlockDef

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

Formats the value using the given formatter.

impl Fields for BlockDef

const FIELDS: &'static [(&'static str, &'static str)]

impl Schema for BlockDef

fn encode(&self, __yog_w: &mut Writer)

Writes itself in the binary form, straight — Schema::write’s value encoded, unless the type knows better (derived ones do).

fn decode(__yog_d: &mut Decoder<'_>) -> Option<Self>

Reads itself from the binary form, straight; None when it isn’t what Schema::encode writes — then read_bytes reads the slow way, which says what’s wrong. Through a value unless the type knows better (derived ones do).

fn pack(&self, __yog_p: &mut Packer)

Packs itself into a frame (crate::frame): its binary form as bytes, unless the type packs itself (derived ones and plain types do).

fn unpack(__yog_u: &mut Unpacker<'_>) -> Option<Self>

Reads itself out of a frame; None if the bytes aren’t what Schema::pack writes.

fn shape() -> Shape

What the format looks like.

fn read(v: &ValueRef<'_>, cx: &mut Reader<'_>) -> Option<Self>

Reads v. Problems go to cx at its current path; None when the value couldn’t be read (the problem is in cx).

fn write(&self) -> Value

The value, as the format writes it.

fn absent() -> Option<Self>

The value of a field that isn’t there — None: the field is required.

fn skip(&self) -> bool

Whether a struct leaves this field out when writing it.

fn pack_list(items: &[Self], p: &mut Packer)

A list of these packed: a count, then each one (floats raw).

fn unpack_list(u: &mut Unpacker<'_>) -> Option<Vec<Self>>

A list of these out of a frame.

fn encode_list(items: &[Self], w: &mut Writer)

A list of these written straight (numbers pack theirs).

fn decode_list(d: &mut Decoder<'_>) -> Option<Vec<Self>>

A list of these read straight.