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 capture(mut src BlockSource, box Box) !&Snapshot

capture reads every block in box from src into a fresh Snapshot. Returns an error if the box exceeds max_volume so a runaway box can't exhaust memory.

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_box(x1 int, y1 int, z1 int, x2 int, y2 int, z2 int) Box

new_box normalizes the two corners so the caller need not order them.

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 new_random(seed u32) Random

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 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. Restore goes through this so a reset looks identical to normal block edits.

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; tests use an in-memory grid.

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

fn (b AABB) offset_by(dx f32, dy f32, dz f32) AABB

offset_by shifts b along each axis by a floating point delta.

fn (b AABB) offset_x(other AABB, delta f32) f32

offset_x clamps the requested X movement so b stops before entering other. The box is ignored unless they already overlap on Y and Z.

Resolve a full move by applying the axis offsets in sequence and translating the box after each one.

fn (b AABB) offset_y(other AABB, delta f32) f32

offset_y clamps the requested Y movement so b stops before entering other. The box is ignored unless they already overlap on X and Z.

Resolve a full move by applying the axis offsets in sequence and translating the box after each one.

fn (b AABB) offset_z(other AABB, delta f32) f32

offset_z clamps the requested Z movement so b stops before entering other. The box is ignored unless they already overlap on X and Y.

Resolve a full move by applying the axis offsets in sequence and translating the box after each one.

struct Block {
pub:
	name       string
	network_id int
}

struct BlockEntry {
pub:
	x  int
	y  int
	z  int
	id int
}

BlockEntry is one captured block's absolute position and id. Exposed so a caller can restore a snapshot across several bounded slices instead of only through one unbounded restore() pass.

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 horizontal face directly. Top and bottom faces can't carve a pumpkin.

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 Box {
pub:
	min_x int
	min_y int
	min_z int
	max_x int
	max_y int
	max_z int
}

Box is an axis-aligned block region, normalized so min <= max on every axis.

fn (b Box) volume() i64

volume is the number of blocks the box covers (inclusive on both corners). Computed in i64 so a huge box can't overflow int32 and slip past the cap.

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) estimated_bytes() i64

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 Random {
mut:
	x u32
	y u32
	z u32
	w u32
}

Random is a xorshift128 pseudo random generator. Chunk population has to be reproducible, so populators seed one of these from the chunk coordinates alone rather than drawing from a shared global source.

fn (mut r Random) set_seed(seed u32)

fn (mut r Random) next_int() int

next_int returns a non negative value spread over the full positive int range.

fn (mut r Random) next_float() f64

fn (mut r Random) next_bounded_int(bound int) int

fn (mut r Random) next_range(start int, end int) int

next_range returns a value in [start, end].

struct Snapshot {
pub:
	box Box
mut:
	ids []int
}

Snapshot holds the block ids of a Box captured at some point in time. It is a flat array so a full restore is a single linear pass. Memory cost is 4 bytes per block - a 64^3 arena is ~1 MB.

fn (s &Snapshot) restore(mut sink BlockSink)

restore writes every captured block back through sink in the same order it was captured, so viewers see the arena reset to its saved state.

fn (s &Snapshot) len() int

len is the number of blocks stored in the snapshot.

fn (s &Snapshot) entry_at(i int) BlockEntry

entry_at returns the block captured at flat index i, in the same order capture and restore already iterate: y outermost, then x, then z.

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