server.world

fn absolute_boxes(model BlockModel, x int, y int, z int) []AABB

fn absolute_boxes_with_neighbors(model BlockModel, neighbors map[int]BlockModel, x int, y int, z int) []AABB

fn block_from_id(network_id int) Block

fn box(min_x f32, min_y f32, min_z f32, max_x f32, max_y f32, max_z f32) AABB

fn default_biome_for(dim Dimension) int

fn dimension_by_id(id int) ?Dimension

fn dimension_by_name(name string) ?Dimension

fn door_model(facing_face int, open bool) BlockModel

fn empty_model() BlockModel

fn fence_gate_model(facing_face int, open bool) BlockModel

fn fence_model() BlockModel

fn generate_flat() Chunk

fn generate_void() Chunk

fn is_door_name(name string) bool

fn is_fence_gate_name(name string) bool

fn is_trapdoor_name(name string) bool

fn ladder_model(facing_face int) BlockModel

fn load_palette(path string) !&BlockPalette

load_palette reads the gzipped big-endian block palette NBT and indexes every block state both by its network id and by its canonical name+states key.

fn look_facing(yaw f32) Facing

look_facing maps a player yaw (degrees) to the horizontal direction the player is looking. Bedrock yaw: 0 = south, 90 = west, 180 = north, 270 = east.

fn new_block(name string) Block

fn new_block_with_states(name string, states []BlockState) Block

fn new_chunk() Chunk

fn new_chunk_dim(dim Dimension) Chunk

new_chunk_dim builds an empty Chunk sized for dim's height range.

fn new_generator(name string) Generator

fn new_generator_registry() GeneratorRegistry

fn slab_model(double bool, top bool) BlockModel

fn solid_model() BlockModel

fn stair_model(facing_face int, upside_down bool) BlockModel

fn thin_model() BlockModel

fn trapdoor_model(facing_face int, open bool, top bool) BlockModel

fn wall_model(north string, east string, south string, west string, post bool) BlockModel

fn Facing.from[W](input W) !Facing

fn ModelKind.from[W](input W) !ModelKind

interface Generator {
	spawn_y() int
	uses_blocks() bool
	generate(chunk_x int, chunk_z int) Chunk
	block_at(x int, y int, z int) int
	biome_at(x int, z int) int
}

type GeneratorFactory = fn (dim Dimension) Generator

GeneratorFactory builds a fresh Generator sized for dim. Each lookup gets its own instance, mirroring entity.Registry's BehaviourFactory.

enum Facing {
	down
	up
	north
	south
	east
	west
}

Facing is a canonical block direction, independent of the many per-block state encodings (cardinal_direction string, weirdo_direction int, ...).

enum ModelKind {
	solid
	empty
	slab
	stair
	ladder
	thin
	fence
	wall
	fence_gate
	door
	trapdoor
}

struct AABB {
pub:
	min_x f32
	min_y f32
	min_z f32
	max_x f32
	max_y f32
	max_z f32
}

fn (b AABB) face_center_solid(face int) bool

fn (b AABB) translated(x int, y int, z int) AABB

fn (b AABB) overlaps(other AABB) bool

struct Block {
pub:
	name       string
	network_id int
}

struct BlockModel {
pub:
	kind        ModelKind
	facing_face int
	top         bool
	double      bool
	upside_down bool
	open        bool
	wall_north  string
	wall_east   string
	wall_south  string
	wall_west   string
	post        bool
}

fn (m BlockModel) boxes() []AABB

fn (m BlockModel) boxes_with_neighbors(neighbors map[int]BlockModel) []AABB

fn (m BlockModel) face_solid(face int) bool

fn (m BlockModel) face_center_solid(face int) bool

struct BlockPalette {
mut:
	by_id  map[int]BlockVariant
	by_key map[string]int
}

fn (p &BlockPalette) can_place_on_face(id int, click_face int) bool

can_place_on_face reports whether a block may be placed from the clicked face. It only covers attachment families with face specific restrictions; unknown blocks stay permissive.

fn (p &BlockPalette) can_place_on_support(id int, click_face int, support_id int) bool

fn (p &BlockPalette) carved_pumpkin_id(id int, click_face int) ?int

carved_pumpkin_id returns the carved_pumpkin id matching an uncarved pumpkin at id, facing the clicked face directly - or none if id isn't an uncarved pumpkin, or the click was on the top/bottom face. Matches Dragonfly's Pumpkin.Carve (the carved face is the one clicked, not its opposite - unlike oriented()'s player-facing placement logic above) and Shears.UseOnBlock (top/bottom faces can't be carved).

fn (p &BlockPalette) connected_block(id int, neighbors NeighborBlockIDs) int

fn (p &BlockPalette) door_pair_id(id int) ?int

fn (p &BlockPalette) door_placement(id int, yaw f32, neighbors NeighborBlockIDs) ?DoorPlacement

fn (p &BlockPalette) door_toggled_pair(clicked_id int, pair_id int) ?DoorToggle

fn (p &BlockPalette) is_door_top(id int) bool

fn (p &BlockPalette) len() int

fn (p &BlockPalette) merged_slab(existing_id int, placing_id int, click_face int, click_y f32, clicked bool) ?int

fn (p &BlockPalette) model(id int) BlockModel

fn (p &BlockPalette) oriented(id int, yaw f32, click_face int, click_y f32) int

oriented returns the network id the given block should be placed as, given the player's yaw and the clicked block face. Blocks with no known facing state are returned unchanged.

fn (p &BlockPalette) toggled_open(id int) ?int

fn (p &BlockPalette) variant(id int) ?BlockVariant

fn (p &BlockPalette) with_state(id int, key string, value string) ?int

with_state returns the network id of the same block with one state overridden. none when the id is unknown, the block lacks that state, or the resulting combination is not in the palette.

struct BlockState {
pub:
	key        string
	kind       int
	byte_value u8
	string_val string
	int_value  int
}

struct BlockVariant {
pub:
	name   string
	states map[string]string
}

BlockVariant is one entry of the canonical block palette - a block name plus its state values, every value normalized to its string form so variants can be compared and rebuilt regardless of the underlying NBT tag type.

struct Chunk {
mut:
	sections       [][]int
	min_y          int   = dimension_min_y
	subchunk_count int   = dimension_subchunk_count
	biomes         []int = []int{len: 256, init: plains_biome_id}
}

fn (c &Chunk) clone() Chunk

fn (c &Chunk) serialize_subchunk(abs_index int) ?[]u8

serialize_subchunk encodes a single subchunk (as used by SubChunkPacket responses to a SubChunkRequestPacket), addressed by its absolute Y index (block Y / 16 - e.g. -4 for the overworld's bottom section). Returns none if abs_index falls outside this chunk's height range.

fn (mut c Chunk) set_biome(x int, z int, biome_id int)

set_biome assigns the biome id for column (x, z), applied to the full height of the chunk.

fn (c &Chunk) biome_id(x int, z int) int

biome_id returns the biome id previously set for column (x, z).

fn (mut c Chunk) set_block(x int, y int, z int, b Block)

fn (mut c Chunk) set_section(index int, ids []int)

fn (c &Chunk) block_id(x int, y int, z int) int

fn (c &Chunk) height_map() []int

fn (c &Chunk) section_count() int

fn (c &Chunk) serialize() []u8

fn (c &Chunk) serialize_biomes() []u8

serialize_biomes encodes c.biomes (a per-column x/z grid) as one PalettedStorage, replicated across every y in a subchunk - same format as serialize_section, just varying by (x, z) only, not y.

struct Dimension {
pub:
	id                int
	min_y             int
	subchunk_count    int
	default_generator string
}

Dimension describes one Bedrock dimension's world height bounds, network id and default generator. min_y/subchunk_count size every Chunk generated or loaded for it.

fn (d Dimension) max_y() int

fn (d Dimension) name() string

struct DoorPlacement {
pub:
	lower int
	upper int
}

struct DoorToggle {
pub:
	clicked int
	pair    int
}

struct EndGenerator {
	dim Dimension = the_end
}

fn (g EndGenerator) spawn_y() int

fn (g EndGenerator) uses_blocks() bool

fn (g EndGenerator) generate(chunk_x int, chunk_z int) Chunk

fn (g EndGenerator) block_at(x int, y int, z int) int

fn (g EndGenerator) biome_at(x int, z int) int

struct FlatGenerator {
	dim Dimension = overworld
}

fn (g FlatGenerator) spawn_y() int

fn (g FlatGenerator) uses_blocks() bool

fn (g FlatGenerator) generate(chunk_x int, chunk_z int) Chunk

fn (g FlatGenerator) block_at(x int, y int, z int) int

fn (g FlatGenerator) biome_at(x int, z int) int

struct GeneratorRegistry {
mut:
	factories map[string]GeneratorFactory
}

fn (mut r GeneratorRegistry) register(name string, factory GeneratorFactory)

fn (r &GeneratorRegistry) create(name string, dim Dimension) ?Generator

create resolves name to a Generator sized for dim. An empty name or the literal name "default" both mean "whatever this dimension's own default generator is" (dim.default_generator - 'normal' for overworld, 'nether' for nether, 'end' for end), so callers (e.g. /world create ... default) don't need to know each dimension's concrete generator name.

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

struct NeighborBlockIDs {
pub:
	north int
	east  int
	south int
	west  int
	above int
	below int
}

struct NetherGenerator {
	dim Dimension = nether
}

fn (g NetherGenerator) spawn_y() int

fn (g NetherGenerator) uses_blocks() bool

fn (g NetherGenerator) generate(chunk_x int, chunk_z int) Chunk

fn (g NetherGenerator) block_at(x int, y int, z int) int

fn (g NetherGenerator) biome_at(x int, z int) int

struct NormalGenerator {
	dim Dimension = overworld
}

fn (g NormalGenerator) uses_blocks() bool

fn (g NormalGenerator) biome_at(x int, z int) int

fn (g NormalGenerator) block_at(x int, y int, z int) int

fn (g NormalGenerator) spawn_y() int

fn (g NormalGenerator) generate(chunk_x int, chunk_z int) Chunk

struct VoidGenerator {
	dim Dimension = overworld
}

fn (g VoidGenerator) spawn_y() int

fn (g VoidGenerator) uses_blocks() bool

fn (g VoidGenerator) generate(chunk_x int, chunk_z int) Chunk

fn (g VoidGenerator) block_at(x int, y int, z int) int

fn (g VoidGenerator) biome_at(x int, z int) int