server.block

fn combat_progression_blocks() []Block

fn container_blocks() []Block

fn decorative_blocks() []Block

fn farming_blocks() []Block

fn new_andesite() AndesiteBlock

fn new_bedrock_block() BedrockBlock

fn new_blue_ice() BlueIceBlock

fn new_calcite() CalciteBlock

fn new_clay() ClayBlock

fn new_coal_block() CoalBlock

fn new_coal_ore() CoalOreBlock

fn new_cobbled_deepslate() CobbledDeepslateBlock

fn new_cobblestone() CobblestoneBlock

fn new_copper_block() CopperBlock

fn new_copper_ore() CopperOreBlock

fn new_custom_registry() CustomRegistry

fn new_diamond_block() DiamondBlock

fn new_diamond_ore() DiamondOreBlock

fn new_diorite() DioriteBlock

fn new_dirt_block() DirtBlock

fn new_dripstone_block() DripstoneBlock

fn new_emerald_block() EmeraldBlock

fn new_emerald_ore() EmeraldOreBlock

fn new_end_bricks() EndBricksBlock

fn new_end_stone() EndStoneBlock

fn new_fern_block() FernBlock

fn new_glowstone() GlowstoneBlock

fn new_gold_block() GoldBlock

fn new_gold_ore() GoldOreBlock

fn new_granite() GraniteBlock

fn new_grass_block() GrassBlock

fn new_gravel() GravelBlock

fn new_ice() IceBlock

fn new_iron_block() IronBlock

fn new_iron_ore() IronOreBlock

fn new_lapis_block() LapisBlock

fn new_lapis_ore() LapisOreBlock

fn new_magma_block() MagmaBlock

fn new_mossy_cobblestone() MossyCobblestoneBlock

fn new_netherrack() NetherrackBlock

fn new_obsidian() ObsidianBlock

fn new_packed_ice() PackedIceBlock

fn new_polished_andesite() PolishedAndesiteBlock

fn new_polished_diorite() PolishedDioriteBlock

fn new_polished_granite() PolishedGraniteBlock

fn new_purpur_block() PurpurBlock

fn new_red_sand() RedSandBlock

fn new_redstone_block() RedstoneBlock

fn new_redstone_ore() RedstoneOreBlock

fn new_registry() Registry

new_registry builds a Registry pre-populated with the built-in block classes.

fn new_sand() SandBlock

fn new_sandstone() SandstoneBlock

fn new_short_grass_block() ShortGrassBlock

fn new_smooth_basalt() SmoothBasaltBlock

fn new_snow() SnowBlock

fn new_soul_sand() SoulSandBlock

fn new_soul_soil() SoulSoilBlock

fn new_stone_block() StoneBlock

fn new_tuff() TuffBlock

fn redstone_component_blocks() []Block

fn replaceable_plant_blocks() []Block

fn wood_blocks() []Block

interface Block {
	// identifier returns the namespaced block id.
	identifier() string
	// runtime_id is the network runtime id sent on the wire.
	runtime_id() int
	// hardness is how long the block resists breaking, in vanilla units.
	hardness() f32
	// breakable reports whether survival players can destroy this block.
	breakable() bool
}

Block is the behaviour contract every block class implements. Every block is its own class built on a family base struct (SimpleBlock, UnbreakableBlock) and registered in the Registry so the session layer can look it up by its runtime id or namespaced identifier.

interface Interactable {
	// interact runs this block's right click behaviour at (x, y, z).
	// Returns whether it did anything, false means fall through, letting
	// the session layer treat the click as an ordinary placement attempt.
	interact(x int, y int, z int, click_face int, mut w TickWorld) bool
}

Interactable is implemented by blocks with a behaviour on right click.

interface Punchable {
	// punch runs this block's left click behaviour at (x, y, z). Unlike
	// interact() there's no fall through decision to make, punching a
	// block always proceeds to the normal start break animation regardless.
	punch(x int, y int, z int, click_face int, mut w TickWorld)
}

Punchable is implemented by blocks with a behaviour on left click. the moment a player starts breaking it, separate from Interactable's right click behaviour and from anything that happens once the break actually completes.

interface RandomTicker {
	random_tick(x int, y int, z int, mut w TickWorld)
}

RandomTicker is implemented by blocks that may receive random updates. On each game tick, every eligible block position has a random_tick_speed / random_tick_chance_denominator chance of having random_tick called.

Examples include crop growth and leaf decay.

interface Replaceable {
	replaceable() bool
}

Replaceable is implemented by blocks that get silently overwritten by a placement instead of blocking it.

interface ScheduledTicker {
	scheduled_tick(x int, y int, z int, mut w TickWorld)
}

ScheduledTicker is implemented by blocks that need to perform a one time update after a delay. scheduled_tick is called delay game ticks after the block position is queued using TickWorld.schedule_tick.

Examples include liquid spreading and delayed redstone propagation.

interface TickWorld {
	block_id(x int, y int, z int) int
mut:
	set_block(x int, y int, z int, id int)
	schedule_tick(x int, y int, z int, delay int)
}

TickWorld provides the world operations available during block ticks. It allows tick handlers to read blocks, including neighbouring positions, update blocks and schedule a future tick for a position.

struct AndesiteBlock {
	SimpleBlock
}

AndesiteBlock is the class for 'minecraft:andesite'.

struct BedrockBlock {
	UnbreakableBlock
}

BedrockBlock is the class for 'minecraft:bedrock'.

struct BlueIceBlock {
	SimpleBlock
}

BlueIceBlock is the class for 'minecraft:blue_ice'.

struct BoxComponent {
pub:
	origin_x f32 = -8.0
	origin_y f32
	origin_z f32 = -8.0
	size_x   f32 = 16.0
	size_y   f32 = 16.0
	size_z   f32 = 16.0
}

BoxComponent is a collision or selection box: origin is the corner offset from the block origin (-8..8), size the extent in pixels (0..16).

struct CalciteBlock {
	SimpleBlock
}

CalciteBlock is the class for 'minecraft:calcite'.

struct ClayBlock {
	SimpleBlock
}

ClayBlock is the class for 'minecraft:clay'.

struct CoalBlock {
	SimpleBlock
}

CoalBlock is the class for 'minecraft:coal_block'.

struct CoalOreBlock {
	SimpleBlock
}

CoalOreBlock is the class for 'minecraft:coal_ore'.

struct CobbledDeepslateBlock {
	SimpleBlock
}

CobbledDeepslateBlock is the class for 'minecraft:cobbled_deepslate'.

struct CobblestoneBlock {
	SimpleBlock
}

CobblestoneBlock is the class for 'minecraft:cobblestone'.

struct CopperBlock {
	SimpleBlock
}

CopperBlock is the class for 'minecraft:copper_block'.

struct CopperOreBlock {
	SimpleBlock
}

CopperOreBlock is the class for 'minecraft:copper_ore'.

struct CustomBlockDefinition {
pub mut:
	id                   string
	display_name         string
	texture              string
	geometry             string
	materials            []MaterialInstance
	friction             f32 = 0.4
	break_hardness       f32 = 1.0
	explosion_resistance int = 5
	light_emission       int
	light_dampening      int = 15
	map_color            string
	creative_category    string = 'construction'
	creative_group       string
	collision            ?BoxComponent
	selection            ?BoxComponent
	runtime_id           int
}

CustomBlockDefinition describes a data-driven block a plugin registers. It is serialized to block property NBT and shipped in the StartGamePacket blocks list so the client can build render state for it.

fn (d &CustomBlockDefinition) network_entry() NetworkEntry

network_entry builds the block property NBT: a components compound, menu_category, molang version and the allocated runtime id under vanilla_block_data.

struct CustomRegistry {
mut:
	defs    []CustomBlockDefinition
	ids     map[string]int
	next_id int = custom_block_runtime_id_start
}

CustomRegistry owns every registered custom block definition and hands out runtime ids sequentially, starting at custom_block_runtime_id_start.

fn (mut r CustomRegistry) register(def CustomBlockDefinition) int

register allocates a runtime id for def and stores it. Registering the same id again returns the previously allocated runtime id unchanged.

fn (r &CustomRegistry) all() []CustomBlockDefinition

fn (r &CustomRegistry) len() int

fn (r &CustomRegistry) runtime_id(id string) ?int

fn (r &CustomRegistry) names() []string

struct DiamondBlock {
	SimpleBlock
}

DiamondBlock is the class for 'minecraft:diamond_block'.

struct DiamondOreBlock {
	SimpleBlock
}

DiamondOreBlock is the class for 'minecraft:diamond_ore'.

struct DioriteBlock {
	SimpleBlock
}

DioriteBlock is the class for 'minecraft:diorite'.

struct DirtBlock {
	SimpleBlock
}

DirtBlock is the class for 'minecraft:dirt'.

struct DripstoneBlock {
	SimpleBlock
}

DripstoneBlock is the class for 'minecraft:dripstone_block'.

struct EmeraldBlock {
	SimpleBlock
}

EmeraldBlock is the class for 'minecraft:emerald_block'.

struct EmeraldOreBlock {
	SimpleBlock
}

EmeraldOreBlock is the class for 'minecraft:emerald_ore'.

struct EndBricksBlock {
	SimpleBlock
}

EndBricksBlock is the class for 'minecraft:end_bricks'.

struct EndStoneBlock {
	SimpleBlock
}

EndStoneBlock is the class for 'minecraft:end_stone'.

struct FernBlock {
	SimpleBlock
}

fn (b FernBlock) replaceable() bool

struct GlowstoneBlock {
	SimpleBlock
}

GlowstoneBlock is the class for 'minecraft:glowstone'.

struct GoldBlock {
	SimpleBlock
}

GoldBlock is the class for 'minecraft:gold_block'.

struct GoldOreBlock {
	SimpleBlock
}

GoldOreBlock is the class for 'minecraft:gold_ore'.

struct GraniteBlock {
	SimpleBlock
}

GraniteBlock is the class for 'minecraft:granite'.

struct GrassBlock {
	SimpleBlock
}

GrassBlock is the class for 'minecraft:grass_block'.

struct GravelBlock {
	SimpleBlock
}

GravelBlock is the class for 'minecraft:gravel'.

struct IceBlock {
	SimpleBlock
}

IceBlock is the class for 'minecraft:ice'.

struct IronBlock {
	SimpleBlock
}

IronBlock is the class for 'minecraft:iron_block'.

struct IronOreBlock {
	SimpleBlock
}

IronOreBlock is the class for 'minecraft:iron_ore'.

struct LapisBlock {
	SimpleBlock
}

LapisBlock is the class for 'minecraft:lapis_block'.

struct LapisOreBlock {
	SimpleBlock
}

LapisOreBlock is the class for 'minecraft:lapis_ore'.

struct MagmaBlock {
	SimpleBlock
}

MagmaBlock is the class for 'minecraft:magma'.

struct MaterialInstance {
pub:
	face          string = '*'
	texture       string
	render_method string = 'opaque'
}

MaterialInstance is the render description for one face (or '*' for all).

struct MossyCobblestoneBlock {
	SimpleBlock
}

MossyCobblestoneBlock is the class for 'minecraft:mossy_cobblestone'.

struct NetherrackBlock {
	SimpleBlock
}

NetherrackBlock is the class for 'minecraft:netherrack'.

struct NetworkEntry {
pub:
	name       string
	properties nbt.RootTag
}

NetworkEntry is the wire form of a custom block: the name plus the block property NBT the session layer wraps into a protocol.BlockEntry.

struct ObsidianBlock {
	SimpleBlock
}

ObsidianBlock is the class for 'minecraft:obsidian'.

struct PackedIceBlock {
	SimpleBlock
}

PackedIceBlock is the class for 'minecraft:packed_ice'.

struct PaletteEntry {
pub:
	name       string
	network_id int
}

PaletteEntry is one block state from the wire palette, in palette order.

struct PolishedAndesiteBlock {
	SimpleBlock
}

PolishedAndesiteBlock is the class for 'minecraft:polished_andesite'.

struct PolishedDioriteBlock {
	SimpleBlock
}

PolishedDioriteBlock is the class for 'minecraft:polished_diorite'.

struct PolishedGraniteBlock {
	SimpleBlock
}

PolishedGraniteBlock is the class for 'minecraft:polished_granite'.

struct PurpurBlock {
	SimpleBlock
}

PurpurBlock is the class for 'minecraft:purpur_block'.

struct RedSandBlock {
	SimpleBlock
}

RedSandBlock is the class for 'minecraft:red_sand'.

struct RedstoneBlock {
	SimpleBlock
}

RedstoneBlock is the class for 'minecraft:redstone_block'.

struct RedstoneOreBlock {
	SimpleBlock
}

RedstoneOreBlock is the class for 'minecraft:redstone_ore'.

struct Registry {
mut:
	by_runtime map[int]Block
	by_name    map[string]Block
}

Registry maps block runtime ids and namespaced ids to their concrete Block class. The session layer holds one Registry and queries it for per-block behaviour (breakability, hardness, ...) instead of hard-coding runtime ids.

fn (mut r Registry) register(b Block)

register adds or overrides the class for a block.

fn (mut r Registry) register_fallbacks(entries []PaletteEntry)

fn (r &Registry) get(runtime_id int) ?Block

get returns the registered class for a runtime id, or none if unregistered.

fn (r &Registry) get_by_name(id string) ?Block

get_by_name returns the registered class for a namespaced id, or none if unregistered.

fn (r &Registry) breakable(runtime_id int) bool

breakable reports whether survival players may destroy the block with the given runtime id. Unregistered blocks fall back to breakable.

fn (r &Registry) hardness(runtime_id int) f32

hardness returns the break hardness for a runtime id, falling back to 1.0 for unregistered blocks.

fn (r &Registry) len() int

len is the number of registered block classes.

struct RepeaterBlock {
	SimpleBlock
	next_delay_id int
}

RepeaterBlock is the class for 'minecraft:unpowered_repeater'/ 'minecraft:powered_repeater'.

fn (b RepeaterBlock) interact(x int, y int, z int, click_face int, mut w TickWorld) bool

struct SandBlock {
	SimpleBlock
}

SandBlock is the class for 'minecraft:sand'.

struct SandstoneBlock {
	SimpleBlock
}

SandstoneBlock is the class for 'minecraft:sandstone'.

struct ShortGrassBlock {
	SimpleBlock
}

fn (b ShortGrassBlock) replaceable() bool

struct SimpleBlock {
pub:
	id             string
	block_runtime  int
	break_hardness f32 = 1.0
}

SimpleBlock is the base class for blocks that carry no special behaviour beyond a hardness value. Concrete blocks embed it and fill in their identity; anything unregistered behaves like a default SimpleBlock.

fn (b SimpleBlock) identifier() string

fn (b SimpleBlock) runtime_id() int

fn (b SimpleBlock) hardness() f32

fn (b SimpleBlock) breakable() bool

struct SmoothBasaltBlock {
	SimpleBlock
}

SmoothBasaltBlock is the class for 'minecraft:smooth_basalt'.

struct SnowBlock {
	SimpleBlock
}

SnowBlock is the class for 'minecraft:snow'.

struct SoulSandBlock {
	SimpleBlock
}

SoulSandBlock is the class for 'minecraft:soul_sand'.

struct SoulSoilBlock {
	SimpleBlock
}

SoulSoilBlock is the class for 'minecraft:soul_soil'.

struct StoneBlock {
	SimpleBlock
}

StoneBlock is the class for 'minecraft:stone'.

struct TuffBlock {
	SimpleBlock
}

TuffBlock is the class for 'minecraft:tuff'.

struct UnbreakableBlock {
pub:
	id            string
	block_runtime int
}

UnbreakableBlock is the base class for blocks survival players can never destroy (bedrock, barriers). Creative mode bypasses the check in the session layer. Concrete blocks embed it, one class per block.

fn (b UnbreakableBlock) identifier() string

fn (b UnbreakableBlock) runtime_id() int

fn (b UnbreakableBlock) hardness() f32

fn (b UnbreakableBlock) breakable() bool