Struct PlanBox 

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

One place, embedded: a footprint standing on a plane.

A box is a plan, not a prism. Its min/extent are the two horizontal axes and its vertical position is PlanBox::floor — one authority for the plane, where a y inside min beside a declared floor would have been two numbers with no rule about which the derivation believes.

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.

Two consequences follow, and they are what make the checks say what they look like they say: the size-class ladder judges extent directly (DW0832), its smallest rung 4 × 4 being exactly one kit quantum; 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, on the kit grid (DW0825). 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.

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.

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