Players build houses, towers and castles from modular pieces: walls, floors, stairs, ramps, ladders, roofs, pillars and beams. The server must respect these pieces. A wall stops a player, a mob and an arrow. Stairs lead to an upper floor. A castle under siege loses pieces every second.

This page is about the server side of that. The client draws each piece as a hand-made mesh. It only needs the collision data to predict its own steps.

Requirements link

Why a separate step height link

The terrain step comes from the slope rule: a step may rise 1 m × tan 60° ≈ 1.73 m per tile. That is a steep but fair hillside. On a built floor it is wrong. A master could step onto a 1.5 m table, and stairs would not need to be stairs.

So a step where either end is a built surface may rise at most 0.5 m. A stair piece rises 0.5 m per tile. A 3 m storey takes six tiles of stairs, or a stair that turns.

Alternatives link

We build B. It is the only option with thin walls, piece identity, worker-thread rebuilds and per-entity doors together. A stays the fallback if we ever accept 1 m thick walls.

The cell overlay link

Pieces and cells link

A piece kind lists its cells in local coordinates. A cell is one 1 m voxel position and has:

• a shape: SOLID (fills the cell) or FLOOR (filled from the bottom up to a top fraction),
• edge walls on its north, east, south and west border, each with a vertical band.

A piece kind also has flags: blocks movement, blocks sight, blocks water. And a material and HP.

The rasterizer turns a placed piece (kind, origin, quarter turns) into cells, split by chunk. It writes an edge wall on both cells next to the border. So a walk table build never needs to look into the neighbour chunk.

A wall is an edge, not a cell. A 4 × 4 room has a 4 × 4 floor inside, not 2 × 2.

A quarter turn turns a piece the way the client turns a model by the same yaw: x+ becomes y−. The client keeps its own copy of the pieces and the rasterizer, to predict steps. Both are checked against one golden file, structure-cells.golden.json.

The first pieces, from structure-pieces.yml:

A storey is 3 m: a floor stands at 0.5, the next one at 3.5, and six tiles of stairs connect them.

Nothing hangs in the air link

Every piece has a stability. A piece with a cell on terrain has 1. Two pieces touch when a cell of one is in, beside, above or below a cell of the other. A piece takes the best stability of the pieces it touches, less a loss set by its material:

A piece below the minimum cannot be placed. A floor on a wall has 0.875 and carries three more floors out beside it: a balcony or a short bridge stands, a long one does not. A pillar put under it makes it stable again.

The stability is settled from the ground up whenever a piece stands or falls. When a piece falls, the pieces it held may drop below the minimum. Collapsing them is slice 4; until then they stay.

Building link

Wall, floor and stairs kits put a piece down through the normal kit flow, up to 6 tiles from the builder. On the client the kit holds a see-through ghost. A ray from the pointer walks the voxels and stops at the first built cell, wall or terrain:

• The ghost goes into the free cell in front of what was hit.
• Aimed at the top metre of a wall, it goes on top of the wall. This is how a ceiling snaps onto walls.
• A wall aimed at a floor stands in the floor’s half cell, so walls line up across a house.

The ghost is red where its cells are taken or nothing holds it, and a click there is not sent. The client does not check the stability, so a piece reaching too far out can still be refused by the server.

Walk table link

The walk table (WalkableTile) already holds several standing surfaces per column: cave floors, bridges, building floors. It is built from the merged terrain voxels. Now it also reads the overlay:

• A structure cell counts as solid, with its top fraction. This is the same rule as a partly filled voxel.
• Each surface remembers whether it stands on terrain or a structure. That decides the step height.
• Each surface gets an exit mask: four bits, one per side. A bit is set when an edge wall overlaps the agent’s body, [surface, surface + height). A 1 m fence on an edge blocks. A 3 m wall blocks. A wall that starts above the head does not.

A step between two columns now checks the exit masks of both surfaces, then the height.

Diagonals: a diagonal step is allowed only if both orthogonal steps around it are allowed too. Without this rule, a player walks through the corner where two walls meet. The rule also applies to terrain, so the client changes with it.

Rebuilds link

StructureCellIndex holds the cells per chunk on the tick thread. A change to a piece:

1. updates the cells,
2. takes an immutable snapshot of that chunk’s cells,
3. marks the walk tables of the touched chunks as dirty.

The walk table is then rebuilt by the existing queue, on a worker thread, from the snapshot. A structure change does not touch the terrain’s revision or edit journal.

Slice 1 rebuilds the whole chunk. A siege needs a cheaper path: rescan only the touched columns (slice 5).

Line of sight link

A lazy bit set per chunk: one bit per voxel, set if the voxel or a structure cell blocks sight. 32 KB per chunk. A ray walks through it with the Amanatides-Woo algorithm, one voxel at a time, and also checks the edge walls it crosses. This replaces today’s stub, which always answers “yes”.

Doors, later link

A door is an edge with a third state: passable for some. The step check gets the moving entity, and asks the door’s state and owner at query time. Opening a door never rebuilds a walk table.

Slices link

Each slice is one branch and one pull request, stacked on the previous.

1. Collision core. Walls, floors and stairs block movement and lead to an upper floor. Server rules and client prediction agree. Pieces need support to be placed, and kits with a snapping build mode put them up. Pieces are drawn as the cells they block until they have models. Still open: re-grounding whoever stood on a piece that is removed.
2. Line of sight for attacks and spells, terrain included.
3. AI perception through line of sight, cached per observer and target for a few ticks.
4. HP, support, undermining. Pieces take damage and die. Support is a search down to the ground. A piece whose ground is dug away collapses. Collapses have a budget per tick.
5. Siege performance. Rescan only touched columns. Decide if a piece is one entity, or a whole structure is.
6. Ladders. A vertical link between two surfaces in one column.
7. Big mobs. A clearance value per surface, or one walk table per body size.
8. Water, shelter, fire read the overlay.
9. Town buildings are made of the same pieces.
10. Doors and wall breaking. A mob may plan through a breakable edge at a high cost, and then attacks it.

Performance targets link