Struct Placement 

pub struct Placement {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub bearing: f32,
}

Where a door or placeable sits in the area and which way it faces.

The consumer set is the four door and placeable types, blueprint-side placements and saved forms alike. Every one of them reads all four labels with the same zero fallback and writes all four unconditionally, so the block takes no per-consumer parameter.

Encounter and geometry points carry X, Y and Z identically and are still not consumers. A spawn point faces through Orientation rather than Bearing, so what counts as three of four shared labels is a position triple beside a differently-named field. Same shape that keeps a saved trigger’s trap fields off a saved door’s: shared concept, different label set. Sharing the triple alone across all eight is a real extraction and a wider one than this block.

What blocks it is that none of those paths has an audited absent value. All twenty declarations across the six schema tables are Unexamined, so merging would assert a sameness nobody has measured. Six of them, the coordinates under Ute.Geometry and Ute.SpawnPointList, are populated by no file in either corpus, which is why no further sweep can settle them and reading the pages is the only thing that can.

That condition covers the four labels this block already shares. Nothing moved when it was introduced, since all four consumers were already reading identical zeros, but an audit giving one path a different absent value now lands here rather than at four separate sites.

Fields

x: f32

X position (X).

y: f32

Y position (Y).

z: f32

Z position (Z).

bearing: f32

Facing angle in radians (Bearing).

Implementations

impl Placement

pub const SCHEMA: [Field; 4]

This view’s schema, one entry per declared field.

pub const PARTS: &'static [&'static [Field]]

This type’s schema in parts, which is what a container holding it references.

Own fields first, then one part per flattened child in the order they are declared.

pub fn read_declared(root: &GffStruct) -> Self

Reads every declared field off root.

Absent fields take the entry’s own answer, so a fallback is derived from the declaration rather than restated beside it.

A field declaring a hand-written read is left at that answer for the view to overwrite.

pub fn write_declared(&self, root: &mut GffStruct)

Writes every declared field onto root, leaving out the ones their entry says the engine’s own writer leaves out.

A field declaring a hand-written write is not touched here.

pub fn read_element(structure: &GffStruct) -> Self

Reads one element of a list of this type.

pub fn write_element(&self, structure: &mut GffStruct)

Writes one element of a list of this type.

Trait Implementations

impl Clone for Placement

fn clone(&self) -> Placement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Placement

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

Formats the value using the given formatter.

impl Default for Placement

fn default() -> Self

What a file omitting every label loads to, which is what makes an authored file land in a known state rather than at zero.

impl HasSchema for Placement

fn schema() -> &'static [Field]

The root field schema for this resource type.

fn parts() -> &'static [&'static [Field]]

The same schema in parts, own fields first.

impl PartialEq for Placement

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Placement

impl StructuralPartialEq for Placement