server.block

fn apply_palette_fallbacks(entries []PaletteEntry)

apply_palette_fallbacks fills in every wire palette block that has no hand written class yet, so it's still placeable. Safe to call more than once. An already registered id is left untouched. Each Hub calls this with its own loaded palette since the palette itself comes from disk per Hub.

fn break_info(runtime_id int) BreakInfo

break_info returns the break time inputs for a runtime id, falling back to a plain hardness 1.0 no tool block for unregistered ids.

fn 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 combat_progression_blocks() []Block

fn combat_progression_items() []BlockItem

fn container_blocks() []Block

fn container_items() []BlockItem

fn crafting_table_blocks() []Block

fn decorative_blocks() []Block

fn decorative_items() []BlockItem

fn default_block_items() []BlockItem

default_block_items is the item form of every modelled block, one entry per placeable item. The item registry seeds itself from this list, so a block and the item that places it stay defined side by side in this package.

fn farming_blocks() []Block

fn farming_items() []BlockItem

fn get(runtime_id int) ?Block

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

fn get_by_name(id string) ?Block

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

fn hardness(runtime_id int) f32

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

fn loot_for_block(identifier string) ?BlockLoot

loot_for_block returns the override loot for a block's namespaced identifier.

fn new_andesite() AndesiteBlock

fn new_andesite_item() BlockItem

new_andesite_item is the item form of 'minecraft:andesite'.

fn new_bedrock_block() BedrockBlock

fn new_bedrock_item() BlockItem

new_bedrock_item is the item form of 'minecraft:bedrock'.

fn new_blue_ice() BlueIceBlock

fn new_blue_ice_item() BlockItem

new_blue_ice_item is the item form of 'minecraft:blue_ice'.

fn new_calcite() CalciteBlock

fn new_calcite_item() BlockItem

new_calcite_item is the item form of 'minecraft:calcite'.

fn new_clay() ClayBlock

fn new_clay_item() BlockItem

new_clay_item is the item form of 'minecraft:clay'.

fn new_coal_block() CoalBlock

fn new_coal_block_item() BlockItem

new_coal_block_item is the item form of 'minecraft:coal_block'.

fn new_coal_ore() CoalOreBlock

fn new_coal_ore_item() BlockItem

new_coal_ore_item is the item form of 'minecraft:coal_ore'.

fn new_cobbled_deepslate() CobbledDeepslateBlock

fn new_cobbled_deepslate_item() BlockItem

new_cobbled_deepslate_item is the item form of 'minecraft:cobbled_deepslate'.

fn new_cobblestone() CobblestoneBlock

fn new_cobblestone_item() BlockItem

new_cobblestone_item is the item form of 'minecraft:cobblestone'.

fn new_copper_block() CopperBlock

fn new_copper_block_item() BlockItem

new_copper_block_item is the item form of 'minecraft:copper_block'.

fn new_copper_ore() CopperOreBlock

fn new_copper_ore_item() BlockItem

new_copper_ore_item is the item form of 'minecraft:copper_ore'.

fn new_custom_registry() CustomRegistry

fn new_diamond_block() DiamondBlock

fn new_diamond_block_item() BlockItem

new_diamond_block_item is the item form of 'minecraft:diamond_block'.

fn new_diamond_ore() DiamondOreBlock

fn new_diamond_ore_item() BlockItem

new_diamond_ore_item is the item form of 'minecraft:diamond_ore'.

fn new_diorite() DioriteBlock

fn new_diorite_item() BlockItem

new_diorite_item is the item form of 'minecraft:diorite'.

fn new_dirt_block() DirtBlock

fn new_dirt_item() BlockItem

new_dirt_item is the item form of 'minecraft:dirt'.

fn new_dripstone_block() DripstoneBlock

fn new_dripstone_block_item() BlockItem

new_dripstone_block_item is the item form of 'minecraft:dripstone_block'.

fn new_emerald_block() EmeraldBlock

fn new_emerald_block_item() BlockItem

new_emerald_block_item is the item form of 'minecraft:emerald_block'.

fn new_emerald_ore() EmeraldOreBlock

fn new_emerald_ore_item() BlockItem

new_emerald_ore_item is the item form of 'minecraft:emerald_ore'.

fn new_end_bricks() EndBricksBlock

fn new_end_bricks_item() BlockItem

new_end_bricks_item is the item form of 'minecraft:end_bricks'.

fn new_end_stone() EndStoneBlock

fn new_end_stone_item() BlockItem

new_end_stone_item is the item form of 'minecraft:end_stone'.

fn new_falling() WaterState

new_falling is a falling column - it appears full but spreads like flowing.

fn new_fern_block() FernBlock

fn new_flowing(depth int) WaterState

new_flowing builds a flowing cell at the given depth.

fn new_glowstone() GlowstoneBlock

fn new_glowstone_item() BlockItem

new_glowstone_item is the item form of 'minecraft:glowstone'.

fn new_gold_block() GoldBlock

fn new_gold_block_item() BlockItem

new_gold_block_item is the item form of 'minecraft:gold_block'.

fn new_gold_ore() GoldOreBlock

fn new_gold_ore_item() BlockItem

new_gold_ore_item is the item form of 'minecraft:gold_ore'.

fn new_granite() GraniteBlock

fn new_granite_item() BlockItem

new_granite_item is the item form of 'minecraft:granite'.

fn new_grass_block() GrassBlock

fn new_grass_block_item() BlockItem

new_grass_block_item is the item form of 'minecraft:grass_block'.

fn new_gravel() GravelBlock

fn new_gravel_item() BlockItem

new_gravel_item is the item form of 'minecraft:gravel'.

fn new_ice() IceBlock

fn new_ice_item() BlockItem

new_ice_item is the item form of 'minecraft:ice'.

fn new_iron_block() IronBlock

fn new_iron_block_item() BlockItem

new_iron_block_item is the item form of 'minecraft:iron_block'.

fn new_iron_ore() IronOreBlock

fn new_iron_ore_item() BlockItem

new_iron_ore_item is the item form of 'minecraft:iron_ore'.

fn new_lapis_block() LapisBlock

fn new_lapis_block_item() BlockItem

new_lapis_block_item is the item form of 'minecraft:lapis_block'.

fn new_lapis_ore() LapisOreBlock

fn new_lapis_ore_item() BlockItem

new_lapis_ore_item is the item form of 'minecraft:lapis_ore'.

fn new_magma_block() MagmaBlock

fn new_magma_block_item() BlockItem

new_magma_block_item is the item form of 'minecraft:magma'.

fn new_manager(host Host) &LiquidManager

new_manager builds a LiquidManager bound to host and precomputes the water id table (all source, flowing and falling states) once.

fn new_mossy_cobblestone() MossyCobblestoneBlock

fn new_mossy_cobblestone_item() BlockItem

new_mossy_cobblestone_item is the item form of 'minecraft:mossy_cobblestone'.

fn new_netherrack() NetherrackBlock

fn new_netherrack_item() BlockItem

new_netherrack_item is the item form of 'minecraft:netherrack'.

fn new_obsidian() ObsidianBlock

fn new_obsidian_item() BlockItem

new_obsidian_item is the item form of 'minecraft:obsidian'.

fn new_packed_ice() PackedIceBlock

fn new_packed_ice_item() BlockItem

new_packed_ice_item is the item form of 'minecraft:packed_ice'.

fn new_polished_andesite() PolishedAndesiteBlock

fn new_polished_andesite_item() BlockItem

new_polished_andesite_item is the item form of 'minecraft:polished_andesite'.

fn new_polished_diorite() PolishedDioriteBlock

fn new_polished_diorite_item() BlockItem

new_polished_diorite_item is the item form of 'minecraft:polished_diorite'.

fn new_polished_granite() PolishedGraniteBlock

fn new_polished_granite_item() BlockItem

new_polished_granite_item is the item form of 'minecraft:polished_granite'.

fn new_purpur_block() PurpurBlock

fn new_purpur_block_item() BlockItem

new_purpur_block_item is the item form of 'minecraft:purpur_block'.

fn new_red_sand() RedSandBlock

fn new_red_sand_item() BlockItem

new_red_sand_item is the item form of 'minecraft:red_sand'.

fn new_red_shrub_block() RedShrubBlock

fn new_redstone_block() RedstoneBlock

fn new_redstone_block_item() BlockItem

new_redstone_block_item is the item form of 'minecraft:redstone_block'.

fn new_redstone_ore() RedstoneOreBlock

fn new_redstone_ore_item() BlockItem

new_redstone_ore_item is the item form of 'minecraft:redstone_ore'.

fn new_registry() Registry

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

fn new_sand() SandBlock

fn new_sand_item() BlockItem

new_sand_item is the item form of 'minecraft:sand'.

fn new_sandstone() SandstoneBlock

fn new_sandstone_item() BlockItem

new_sandstone_item is the item form of 'minecraft:sandstone'.

fn new_short_grass_block() ShortGrassBlock

fn new_smooth_basalt() SmoothBasaltBlock

fn new_smooth_basalt_item() BlockItem

new_smooth_basalt_item is the item form of 'minecraft:smooth_basalt'.

fn new_snow() SnowBlock

fn new_snow_item() BlockItem

new_snow_item is the item form of 'minecraft:snow'.

fn new_soul_sand() SoulSandBlock

fn new_soul_sand_item() BlockItem

new_soul_sand_item is the item form of 'minecraft:soul_sand'.

fn new_soul_soil() SoulSoilBlock

fn new_soul_soil_item() BlockItem

new_soul_soil_item is the item form of 'minecraft:soul_soil'.

fn new_source() WaterState

new_source is the full still water source.

fn new_stone_block() StoneBlock

fn new_stone_item() BlockItem

new_stone_item is the item form of 'minecraft:stone'.

fn new_tuff() TuffBlock

fn new_tuff_item() BlockItem

new_tuff_item is the item form of 'minecraft:tuff'.

fn note_jukebox_blocks() []Block

fn redstone_component_blocks() []Block

fn redstone_component_items() []BlockItem

fn register(b Block)

register adds or overrides the class for a block. Use this for a hand written Block; register_custom (custom.v) is the data driven form.

fn register_custom(def CustomBlockDefinition) int

register_custom registers a data driven block: allocates its runtime id and makes it resolvable everywhere immediately. Call it from your own setup, before server.new(). Registering the same id twice just returns the id already allocated to it.

fn registered_custom() []CustomBlockDefinition

registered_custom returns every block registered via register_custom so far, each with its runtime id filled in.

fn replaceable_plant_blocks() []Block

fn shelf_mushroom_blocks() []Block

fn wood_blocks() []Block

fn wood_items() []BlockItem

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 BlockSink {
mut:
	set_block_id(id int, x int, y int, z int)
}

BlockSink writes a block by network id and broadcasts the change to viewers. Every liquid write routes through this so a spread looks like a normal edit.

interface BlockSource {
mut:
	get_block(x int, y int, z int) int
}

BlockSource reads block network ids from a world by absolute coordinates. Hub satisfies it structurally; tests use an in-memory grid.

interface Host {
	BlockSource
	BlockSink
}

Host is what the LiquidManager needs from its world: read and write blocks. Hub satisfies it via get_block/set_block_id, so this module never imports session and stays unit-testable against a fake grid.

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.

interface ToolRequirement {
	tool_type() int
	harvest_level() int
}

ToolRequirement is implemented by block classes that pin their own tool family and tier. Blocks that don't implement it fall back to the shared name based defaults.

struct AndesiteBlock {
	SimpleBlock
}

AndesiteBlock is the class for 'minecraft:andesite'.

struct BedrockBlock {
	UnbreakableBlock
}

BedrockBlock is the class for 'minecraft:bedrock'.

struct BlockItem {
pub:
	id            string
	block_runtime int
	stack_max     int = 64
}

BlockItem is the class for items that place a block when used against a face. It carries the block runtime id the session should set in the world. Every block file builds its own item form from it (see item_registry.v), and the item registry seeds itself from that list.

fn (i BlockItem) identifier() string

fn (i BlockItem) max_stack_size() int

fn (i BlockItem) attack_damage() f32

fn (i BlockItem) nutrition() int

fn (i BlockItem) saturation() f32

fn (i BlockItem) block_runtime_id() int

fn (i BlockItem) durability() int

fn (i BlockItem) mining_speed() f32

fn (i BlockItem) armor_points() int

struct BlockLoot {
pub:
	item_name string
	min_count int = 1
	max_count int = 1
}

BlockLoot describes drops that differ from a block's normal item form. Blocks without custom loot are resolved through the block to item mapping.

This only models simple count ranges. Tool requirements, enchantments, growth stages and full vanilla loot table behavior are not yet supported.

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 BreakInfo {
pub:
	hardness      f32 = 1.0
	tool_type     int
	harvest_level int
}

BreakInfo is everything the break time formula needs about one block.

fn (i BreakInfo) breakable() bool

breakable reports whether the block can be destroyed at all.

fn (i BreakInfo) breaks_instantly() bool

breaks_instantly reports whether the block is destroyed within one tick regardless of the held item.

fn (i BreakInfo) tool_compatible(tool_type int, harvest_level int) bool

tool_compatible reports whether a tool of the given family and harvest level harvests this block, which decides both the break time multiplier and whether the block drops anything.

fn (i BreakInfo) break_seconds(tool_type int, harvest_level int, efficiency f32) f32

break_seconds is how long the block takes to break with a tool of the given family, harvest level and mining efficiency. Efficiency only counts when the tool family matches, so a diamond pickaxe is no faster than a hand on dirt.

struct CalciteBlock {
	SimpleBlock
}

CalciteBlock is the class for 'minecraft:calcite'.

struct ChestBlock {
	SimpleBlock
}

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 CraftingTableBlock {
	SimpleBlock
}

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 JukeboxBlock {
	SimpleBlock
}

struct LapisBlock {
	SimpleBlock
}

LapisBlock is the class for 'minecraft:lapis_block'.

struct LapisOreBlock {
	SimpleBlock
}

LapisOreBlock is the class for 'minecraft:lapis_ore'.

struct LiquidManager {
mut:
	host    Host
	pending map[string]Pos
	// water_states maps every known water network id to its resolved cell so the
	// manager can tell water apart from other blocks when it reads the world.
	water_states map[int]WaterState
	air_id       int
}

LiquidManager owns the set of block positions that still need a liquid update and processes them on the actor thread each tick. It holds no world of its own - the Host it is handed reads and writes blocks.

fn (mut m LiquidManager) place_source(x int, y int, z int)

place_source sets a water source at the position and queues it for spreading.

fn (mut m LiquidManager) enqueue(x int, y int, z int)

enqueue marks a cell as needing a liquid update on a later tick.

fn (mut m LiquidManager) on_block_changed(x int, y int, z int)

on_block_changed re-evaluates a cell and its neighbours after a block edit - placing water starts its flow, breaking a block frees a path for adjacent water to spread into. Only water cells actually do anything when processed.

fn (m &LiquidManager) pending_count() int

pending_count is the number of cells still queued. Used by tests.

fn (mut m LiquidManager) tick()

tick drains up to max_cells_per_tick queued cells and processes each. Cells a processed cell touches (neighbours it fills, or itself when it changes) are re-queued for the next call, so the flow advances one ring per call. The world runtime only calls this every few ticks, which is what sets the vanilla flow rate. Runs on the owning world's actor thread.

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 NoteBlock {
	SimpleBlock
}

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 RedShrubBlock {
	SimpleBlock
}

RedShrubBlock is the class for 'minecraft:red_shrub', one of the blocks the game drives from the block definitions rather than implementing natively.

fn (b RedShrubBlock) replaceable() bool

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) break_info(runtime_id int) BreakInfo

break_info returns the break time inputs for a runtime id, falling back to a plain hardness 1.0 no tool block for unregistered ids.

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 ShearsBlock {
	SimpleBlock
}

ShearsBlock is a block shears take apart. Wool keeps its family whatever shape it is cut into, which the name based tool fallback cannot tell from the name of a slab or a stair.

fn (b ShearsBlock) tool_type() int

fn (b ShearsBlock) harvest_level() int

struct ShelfMushroomBlock {
	SimpleBlock
}

ShelfMushroomBlock is the class for 'minecraft:shelf_mushroom'. It breaks instantly and takes a sword or shears the way the other fungi do.

fn (b ShelfMushroomBlock) tool_type() int

fn (b ShelfMushroomBlock) harvest_level() int

struct ShortGrassBlock {
	SimpleBlock
}

fn (b ShortGrassBlock) replaceable() bool

struct SignBlock {
	SimpleBlock
}

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

struct WaterState {
pub:
	depth   int
	falling bool
}

WaterState is a resolved water cell: its internal depth and whether it is falling. It knows how to encode itself into a Bedrock network id.

fn (w WaterState) is_source() bool

is_source reports whether this cell is a full still source.

fn (w WaterState) network_id() int

network_id resolves this water cell to its Bedrock runtime id. Source cells use minecraft:water, flowing/falling cells use minecraft:flowing_water.

struct WheatBlock {
	SimpleBlock
	next_growth_id int // 0 once fully grown (growth=7) - no further tick
	farmland_ids   []int
}

WheatBlock is the class for 'minecraft:wheat'. Its growth stages (0-7) tick forward via random_tick.

This is a deliberate simplification, not vanilla parity: it only checks for farmland underneath, not light level, haste, or bonemeal adjacent growth rate boosts.

fn (b WheatBlock) random_tick(x int, y int, z int, mut w TickWorld)