Struct PlanBox 

pub struct PlanBox {
    pub node: NodeId,
    pub min: Option<[i64; 2]>,
    pub extent: [NonZeroU32; 2],
    pub floor: Floor,
    pub ceiling: Ceiling,
    pub base: Base,
    pub atmosphere: Option<AtmosphereId>,
    pub roof: Option<Roof>,
}

One place, embedded: a cuboid of the world.

A box is a 3D region. Its min/extent are the two horizontal axes; its vertical extent is three declared planes — PlanBox::floor, the one authority for the walk plane; PlanBox::ceiling, the headroom over it (a lid, or exactly n courses of sky); and PlanBox::base, what it stands on (the site’s ground, or n underside courses hung in the air). Two places conflict only where their cuboids overlap (DW0827); a cell no place claims is the whole’s — on an open site, walkable ground and sky.

A box is the PLAY SPACE, and connected boxes are separated by exactly one cell. extent is the interior a body can stand in; the shell the blockout derivation builds is not inside it. That shell stands in the one-cell gap between two neighbours, and on the course under the floor and over the ceiling. So two places that connect are placed one cell apart on the face they share — that cell is the wall they have in common, written once — and two boxes placed flush have no wall for a seam to be cut through, which DW0828 refuses. Worked: a box at min: [4, 4] with extent: [4, 4] occupies x 4..7, so its eastern neighbour’s min x is 9, never 8.

The consequence is what makes the checks say what they look like they say: extent is the play space the author declared, and a plan never states a wall’s thickness anywhere, because the gap is where the wall is.

Fields

node: NodeId

The graph node this box embeds.

The ordering tooth, at the type level: there is no way to write a box that does not name a place, so a site plan cannot describe a space the layout graph has not declared (spec-0049 §7.1).

min: Option<[i64; 2]>

A pin: the low corner [x, z] in world coordinates, when the author chooses where this box stands. Optional (spec-0059 §2): a box with no pin stands where the packing puts it — one cell beyond the face of the box its first seam in document order hangs it off. At least one box of every connected component of the seam graph is pinned, or nothing places the component (DW0883); a pinned box the packing also reaches at a different corner is refused naming both (DW0883). Two horizontal numbers, never three — the vertical position is floor.

extent: [NonZeroU32; 2]

Interior footprint [dx, dz], in blocks — any whole number on either axis. Two horizontal numbers, never three — the vertical size is ceiling.

This is play space, not the building. The box covers min to min + extent - 1 inclusive, and the walls stand outside it, in the one-cell gap that separates connected places (DW0828).

floor: Floor

The walk plane.

ceiling: Ceiling

What closes it overhead.

base: Base

What it stands on: "ground" (the default) or {"aloft": n}.

atmosphere: Option<AtmosphereId>

The sky this place stands under from the first tick (spec-0080 §3.2): one of world.atmospheres[], painted at world setup over the box’s play space grown as far as the client’s biome blend reads — the same capability areas[].atmosphere is, on the other class of place with a world box. Absent: the horizon’s biome.

roof: Option<Roof>

The roof the whole reserves over this place (spec-0098 §3): how many courses it rises above the ceiling course and how far it overhangs the shell on each horizontal side. Massed solid at stage 5 so a walker sees the volume the building will take; drawn by the place’s own piece once detailed. Absent: a flat lid one course thick, which the piece owns too. Refused on a sky-open box, and where its courses rise into another place (DW0988); its eaves stop at a neighbour’s wall.

Trait Implementations

impl Clone for PlanBox

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PlanBox

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PlanBox

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for PlanBox

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for PlanBox

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for PlanBox

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PlanBox