Struct GitWaypoint 

pub struct GitWaypoint {
    pub tag: String,
    pub localized_name: GffLocalizedString,
    pub commandable: Option<bool>,
    pub map_note: Option<GitMapNote>,
    pub x_orientation: f32,
    pub y_orientation: f32,
    pub z_orientation: Option<f32>,
    pub object_id: Option<ObjectId>,
    pub x_position: f32,
    pub y_position: f32,
    pub z_position: f32,
}

A waypoint placed in the area (struct type 5).

Waypoints are the one object list with a single form. LoadWaypoints ignores UseTemplates and always reads inline data, so there is no static / saved split here and Git::waypoints is a plain Vec.

Dead fields this type does not model

TemplateResRef and LinkedTo are universal in a real install and read by nothing; docs/src/formats/gff/utw.md carries both the engine side and the corpus figures. docs/src/architecture.md’s projection rule uses this type’s TemplateResRef as its worked example of prevalence not being a criterion for modelling.

Tag, in contrast, is live and modelled. A waypoint is always inline with no blueprint behind it, so unlike GitDoor there is no second copy for the placement’s to lose to.

The map note is one value, not a flag plus two optionals

The engine gates the note behind HasMapNote and then discards the whole trio unless MapNote itself was there, so neither half alone produces a note and there is no state to model between them.

Read the flag, not the text. Keying the note off MapNote alone passes against the fixture saves, where the two never disagree, and a larger corpus does not support it. docs/src/testing.md carries that as a worked example of a corpus too small to tell a relationship from a constant.

Fields

tag: String

Object tag (Tag).

localized_name: GffLocalizedString

Displayed name (LocalizedName).

commandable: Option<bool>

Accepts scripted commands (Commandable). Whether the object takes scripted commands (Commandable).

One of the base-object labels CSWSObject::LoadObjectState reads, and that read runs only on the save-instance branch, so a static placement never reaches it. SaveObjectState writes it whenever anything is saved, which is why every saved element carries it and no install element does. A waypoint is the one owner this reaches, because WaypointList has no static arm to keep it off.

map_note: Option<GitMapNote>

Map note, when this waypoint carries one.

The two labels sit at this level rather than under one of their own, so the member is flattened. Whether it is there at all is a rule no attribute states: git.md has an absent MapNote discarding the whole HasMapNote/MapNoteEnabled/MapNote trio, and the flag is derived from this member on write so the two cannot disagree.

x_orientation: f32

X orientation (XOrientation).

y_orientation: f32

Y orientation (YOrientation).

z_orientation: Option<f32>

Z orientation (ZOrientation). Z orientation (ZOrientation), which only a saved form carries.

object_id: Option<ObjectId>

Runtime object ID (ObjectId). Runtime object id (ObjectId), which only a saved form carries.

The area-level dispatcher reads it once per element ahead of the static-versus-saved branch, so the engine reads it on both forms and the liveness below is right. What it does not do is author it: every element the engine saves carries one and no element the toolset shipped does. Held as the absence so writing a static placement back does not invent a runtime id for it.

x_position: f32

X position (XPosition).

y_position: f32

Y position (YPosition).

z_position: f32

Z position (ZPosition).

Implementations

impl GitWaypoint

pub const SCHEMA: [Field; 15]

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.

impl GitWaypoint

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

Reads one waypoint, resolving the map-note group.

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

Writes one waypoint, deriving the flag from whether the note is there.

Trait Implementations

impl Clone for GitWaypoint

fn clone(&self) -> GitWaypoint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GitWaypoint

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

Formats the value using the given formatter.

impl Default for GitWaypoint

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 GitWaypoint

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 GitWaypoint

fn eq(&self, other: &GitWaypoint) -> 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 StructuralPartialEq for GitWaypoint