Struct GitDoorCommon 

pub struct GitDoorCommon {
    pub appearance: u32,
    pub linked_to: String,
    pub linked_to_flags: u8,
    pub linked_to_module: ResRef,
    pub object_id: Option<ObjectId>,
    pub transition_destination: GffLocalizedString,
}

A door instance placed in the area (struct type 8).

Doors use Bearing for orientation and X/Y/Z for position (not XPosition/YPosition/ZPosition).

Unlike GitWaypoint, a static door placement genuinely does resolve its TemplateResRef against a .utd blueprint, and it carries the same transition group a trigger does. This type modelled neither for a while, which meant round-tripping any vanilla module returned doors with no blueprint to instantiate from and no tag to reference. See docs/src/formats/gff/utd.md’s “Save versus Template Load Paths”.

Tag is dead here, and deliberately unmodelled

A templated door takes its tag from the .utd blueprint and the placement’s copy has no overlay to win through, so setting one is a modder trap rather than a harmless leftover: nothing happens, silently.

docs/src/architecture.md uses exactly this field as its worked example of the projection rule’s “at that path is the whole test”, and docs/src/formats/gff/git.md covers the consequence, that two placements sharing a blueprint end up with the same tag – for every templated object The part of a door entry that is what every door entry carries, whichever form it takes.

Both arms flatten it and the list’s element is it, so the labels here are one declaration reached from both forms rather than two copies.

Fields

appearance: u32

Visual model override (Appearance).

Read on a sparse placement as well as a saved one: LoadDoor and LoadPlaceable are the same field readers whichever path calls them, so a template-referencing placement carrying its own Appearance has that value read as an override on top of the blueprint’s. Read as a DWORD and truncated to a byte, which for a door keys doortypes.2da’s model columns. Defaults to 0 when absent. Read by LoadDoor and truncated to a byte, then used to key doortypes.2da. The absent value is the door struct’s own zero-initialized member rather than a literal, which is where this parts from the placeable’s otherwise identical field.

linked_to: String

Destination object tag within that module (LinkedTo).

linked_to_flags: u8

What Self::linked_to names (LinkedToFlags).

linked_to_module: ResRef

Destination module for a transition door (LinkedToModule).

object_id: Option<ObjectId>

Runtime object ID (ObjectId). Save-game only. 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.

transition_destination: GffLocalizedString

Player-facing name of the destination (TransitionDestin).

Implementations

impl GitDoorCommon

pub const SCHEMA: [Field; 6]

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 GitDoorCommon

fn clone(&self) -> GitDoorCommon

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GitDoorCommon

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

Formats the value using the given formatter.

impl Default for GitDoorCommon

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 GitDoorCommon

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 GitDoorCommon

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