Struct Utw 

pub struct Utw {

    pub template_resref: ResRef,
    pub tag: String,
    pub name: GffLocalizedString,
    pub appearance_id: u8,
    pub has_map_note: bool,
    pub map_note_enabled: bool,
    pub map_note: GffLocalizedString,
    pub palette_id: u8,
    pub comment: String,
    pub linked_to: String,
    pub description: GffLocalizedString,
    pub x_position: f32,
    pub y_position: f32,
    pub z_position: f32,
    pub x_orientation: f32,
    pub y_orientation: f32,
    pub z_orientation: f32,
}

Typed UTW model built from/to Gff data.

Fields

template_resref: ResRef

Waypoint template resref (TemplateResRef).

tag: String

Waypoint tag (Tag).

name: GffLocalizedString

Localized waypoint name (LocalizedName).

appearance_id: u8

Waypoint appearance id (Appearance). Never read by the K1 engine.

has_map_note: bool

Has-map-note flag (HasMapNote).

map_note_enabled: bool

Map-note-enabled flag (MapNoteEnabled). Engine ignores this if has_map_note is false.

map_note: GffLocalizedString

Localized map note (MapNote). Engine ignores this if has_map_note is false.

palette_id: u8

Palette id (PaletteID).

comment: String

Toolset comment (Comment).

linked_to: String

Deprecated linked target (LinkedTo).

description: GffLocalizedString

Deprecated localized description (Description).

x_position: f32

World X position (XPosition).

y_position: f32

World Y position (YPosition).

z_position: f32

World Z position (ZPosition).

x_orientation: f32

Facing X component (XOrientation).

The engine normalizes the orientation vector at runtime if its magnitude is not 1.0. The write is hand-written because the condition is the whole vector rather than any one component. It is in to_gff.

y_orientation: f32

Facing Y component (YOrientation).

Written with the rest of the vector. See Utw::x_orientation.

z_orientation: f32

Facing Z component (ZOrientation).

Written with the rest of the vector. See Utw::x_orientation.

Implementations

impl Utw

pub const SCHEMA: [Field; 17]

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.

impl Utw

pub fn new() -> Self

Creates an empty UTW value.

pub fn from_gff(gff: &Gff) -> Result<Self, UtwError>

Builds typed UTW data from a parsed GFF container.

Errors

Returns UtwError::UnsupportedFileType for a container that is neither UTW nor the generic GFF form.

pub fn to_gff(&self) -> Gff

Converts this typed UTW value into a GFF container.

Trait Implementations

impl Clone for Utw

fn clone(&self) -> Utw

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Utw

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

Formats the value using the given formatter.

impl Default for Utw

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 FromGff for Utw

const MAGIC: [u8; 4]

The four bytes a container of this format carries.

type Error = UtwError

What reading this view out of a tree can fail with.

fn from_gff(gff: &Gff) -> Result<Self, Self::Error>

Reads the view. Anything the view does not model stays in gff.

impl HasSchema for Utw

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 Utw

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