Struct GitWaypoint 

pub struct GitWaypoint {
    pub tag: String,
    pub object_id: ObjectId,
    pub localized_name: GffLocalizedString,
    pub commandable: bool,
    pub map_note: Option<GitMapNote>,
    pub x_position: f32,
    pub y_position: f32,
    pub z_position: f32,
    pub x_orientation: f32,
    pub y_orientation: f32,
    pub z_orientation: 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.

TemplateResRef is dead here, and deliberately unmodelled

Every waypoint in a real install carries a TemplateResRef, and nothing reads it. No waypoint load path looks the label up under any name, including the script-spawn fallback, where the resref comes from the script’s own CreateObject argument rather than from the file. Unlike GitDoor, a waypoint placement never resolves a blueprint.

Present in every file is not a reason to model it. The projection rule has no prevalence threshold: a field the engine ignores is one the typed view can drop however common it is, and callers needing byte fidelity work with the raw Gff tree. Modelling it would also invite a resref-existence check on a name nothing opens, which is the concrete cost of treating prevalence as significance.

LinkedTo is dead here too

The transition group belongs to doors and triggers. A waypoint cannot carry the player anywhere, so a destination tag on one names a target for a transition that will never fire. Every waypoint in a real install carries the label and every one of them leaves it empty, which is what a field the toolset writes and nothing consumes looks like.

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.

A map note is one value rather than a flag plus two optionals: across every waypoint in the fixture saves, HasMapNote is set exactly when MapNote is present, so the states where they disagree cannot occur and are not worth being able to build.

Fields

tag: String

Object tag (Tag).

object_id: ObjectId

Runtime object ID (ObjectId).

localized_name: GffLocalizedString

Displayed name (LocalizedName).

commandable: bool

Accepts scripted commands (Commandable).

map_note: Option<GitMapNote>

Map note, when this waypoint carries one.

x_position: f32

X position (XPosition).

y_position: f32

Y position (YPosition).

z_position: f32

Z position (ZPosition).

x_orientation: f32

X orientation (XOrientation).

y_orientation: f32

Y orientation (YOrientation).

z_orientation: f32

Z orientation (ZOrientation).

Implementations

impl GitWaypoint

pub fn from_gff_struct(s: &GffStruct) -> Self

Reads one WaypointList element.

pub fn to_gff_struct(&self) -> GffStruct

Writes this waypoint back into a WaypointList element.

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() -> GitWaypoint

Returns the “default value” for a type.

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