rakata_generics/

git.rs

//! GIT (`.git`) typed generic wrapper.
//!
//! GIT (Game Instance Template) resources are GFF-backed area instance data.
//! Each area has one GIT that holds positioned object instances (creatures,
//! items, doors, placeables, waypoints, sounds, triggers, stores, encounters,
//! area effects), area-level properties (music, ambient sounds, stealth XP),
//! and a camera list.
//!
//! ## Scope
//! - Typed access for all 10 instance list types with position/orientation.
//! - Typed `AreaProperties` with music, ambient sound, and stealth XP fields.
//! - Typed camera list with Position (Vector3) and Orientation (Quaternion).
//! - Full typed roundtrip for all engine-read fields.

use std::io::{Cursor, Read, Write};

use crate::gff_helpers::{
    get_bool, get_f32, get_i32, get_locstring, get_resref, get_string, get_u32, get_u8,
    upsert_field,
};
use crate::shared::GitTriggerPoint;
use rakata_core::{ResRef, StrRef};
use rakata_formats::{
    gff_schema::{FieldSchema, GffSchema, GffType},
    read_gff, read_gff_from_bytes, write_gff, Gff, GffBinaryError, GffLocalizedString, GffStruct,
    GffValue,
};
use thiserror::Error;

// =========================================================================
// Instance sub-types
// =========================================================================

/// A creature instance placed in the area (struct type 4).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitCreature {
    /// Template resref (`TemplateResRef`).
    pub template_resref: ResRef,
    /// X position (`XPosition`).
    pub x_position: f32,
    /// Y position (`YPosition`).
    pub y_position: f32,
    /// Z position (`ZPosition`).
    pub z_position: f32,
    /// X orientation (`XOrientation`).
    pub x_orientation: f32,
    /// Y orientation (`YOrientation`).
    pub y_orientation: f32,
    /// Z orientation (`ZOrientation`).
    pub z_orientation: f32,
    /// Runtime object ID (`ObjectId`). Save-game only.
    pub object_id: u32,
}

impl GitCreature {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            template_resref: get_resref(s, "TemplateResRef").unwrap_or_default(),
            x_position: get_f32(s, "XPosition").unwrap_or(0.0),
            y_position: get_f32(s, "YPosition").unwrap_or(0.0),
            z_position: get_f32(s, "ZPosition").unwrap_or(0.0),
            x_orientation: get_f32(s, "XOrientation").unwrap_or(0.0),
            y_orientation: get_f32(s, "YOrientation").unwrap_or(0.0),
            z_orientation: get_f32(s, "ZOrientation").unwrap_or(0.0),
            object_id: get_u32(s, "ObjectId").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(4);
        upsert_field(
            &mut s,
            "TemplateResRef",
            GffValue::ResRef(self.template_resref),
        );
        upsert_field(&mut s, "XPosition", GffValue::Single(self.x_position));
        upsert_field(&mut s, "YPosition", GffValue::Single(self.y_position));
        upsert_field(&mut s, "ZPosition", GffValue::Single(self.z_position));
        upsert_field(&mut s, "XOrientation", GffValue::Single(self.x_orientation));
        upsert_field(&mut s, "YOrientation", GffValue::Single(self.y_orientation));
        upsert_field(&mut s, "ZOrientation", GffValue::Single(self.z_orientation));
        upsert_field(&mut s, "ObjectId", GffValue::UInt32(self.object_id));
        s
    }
}

/// An item instance placed in the area (struct type 0).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitItem {
    /// Template resref (`TemplateResRef`).
    pub template_resref: ResRef,
    /// X position (`XPosition`).
    pub x_position: f32,
    /// Y position (`YPosition`).
    pub y_position: f32,
    /// Z position (`ZPosition`).
    pub z_position: f32,
    /// X orientation (`XOrientation`).
    pub x_orientation: f32,
    /// Y orientation (`YOrientation`).
    pub y_orientation: f32,
    /// Z orientation (`ZOrientation`).
    pub z_orientation: f32,
    /// Runtime object ID (`ObjectId`). Save-game only.
    pub object_id: u32,
}

impl GitItem {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            template_resref: get_resref(s, "TemplateResRef").unwrap_or_default(),
            x_position: get_f32(s, "XPosition").unwrap_or(0.0),
            y_position: get_f32(s, "YPosition").unwrap_or(0.0),
            z_position: get_f32(s, "ZPosition").unwrap_or(0.0),
            x_orientation: get_f32(s, "XOrientation").unwrap_or(0.0),
            y_orientation: get_f32(s, "YOrientation").unwrap_or(0.0),
            z_orientation: get_f32(s, "ZOrientation").unwrap_or(0.0),
            object_id: get_u32(s, "ObjectId").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        upsert_field(
            &mut s,
            "TemplateResRef",
            GffValue::ResRef(self.template_resref),
        );
        upsert_field(&mut s, "XPosition", GffValue::Single(self.x_position));
        upsert_field(&mut s, "YPosition", GffValue::Single(self.y_position));
        upsert_field(&mut s, "ZPosition", GffValue::Single(self.z_position));
        upsert_field(&mut s, "XOrientation", GffValue::Single(self.x_orientation));
        upsert_field(&mut s, "YOrientation", GffValue::Single(self.y_orientation));
        upsert_field(&mut s, "ZOrientation", GffValue::Single(self.z_orientation));
        upsert_field(&mut s, "ObjectId", GffValue::UInt32(self.object_id));
        s
    }
}

/// 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`). No `TemplateResRef` - doors are
/// matched to their layout definition by the engine.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitDoor {
    /// Facing angle in radians (`Bearing`).
    pub bearing: f32,
    /// X position (`X`).
    pub x: f32,
    /// Y position (`Y`).
    pub y: f32,
    /// Z position (`Z`).
    pub z: f32,
    /// Runtime object ID (`ObjectId`). Save-game only.
    pub object_id: u32,
}

impl GitDoor {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            bearing: get_f32(s, "Bearing").unwrap_or(0.0),
            x: get_f32(s, "X").unwrap_or(0.0),
            y: get_f32(s, "Y").unwrap_or(0.0),
            z: get_f32(s, "Z").unwrap_or(0.0),
            object_id: get_u32(s, "ObjectId").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(8);
        upsert_field(&mut s, "Bearing", GffValue::Single(self.bearing));
        upsert_field(&mut s, "X", GffValue::Single(self.x));
        upsert_field(&mut s, "Y", GffValue::Single(self.y));
        upsert_field(&mut s, "Z", GffValue::Single(self.z));
        upsert_field(&mut s, "ObjectId", GffValue::UInt32(self.object_id));
        s
    }
}

/// A placeable instance placed in the area (struct type 9).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitPlaceable {
    /// Template resref (`TemplateResRef`).
    pub template_resref: ResRef,
    /// Facing angle in radians (`Bearing`).
    pub bearing: f32,
    /// X position (`X`).
    pub x: f32,
    /// Y position (`Y`).
    pub y: f32,
    /// Z position (`Z`).
    pub z: f32,
    /// Runtime object ID (`ObjectId`). Save-game only.
    pub object_id: u32,
}

impl GitPlaceable {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            template_resref: get_resref(s, "TemplateResRef").unwrap_or_default(),
            bearing: get_f32(s, "Bearing").unwrap_or(0.0),
            x: get_f32(s, "X").unwrap_or(0.0),
            y: get_f32(s, "Y").unwrap_or(0.0),
            z: get_f32(s, "Z").unwrap_or(0.0),
            object_id: get_u32(s, "ObjectId").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(9);
        upsert_field(
            &mut s,
            "TemplateResRef",
            GffValue::ResRef(self.template_resref),
        );
        upsert_field(&mut s, "Bearing", GffValue::Single(self.bearing));
        upsert_field(&mut s, "X", GffValue::Single(self.x));
        upsert_field(&mut s, "Y", GffValue::Single(self.y));
        upsert_field(&mut s, "Z", GffValue::Single(self.z));
        upsert_field(&mut s, "ObjectId", GffValue::UInt32(self.object_id));
        s
    }
}

/// A waypoint instance placed in the area (struct type 5).
///
/// Waypoints carry only position - orientation and template are resolved
/// by the engine from the linked UTW resource.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitWaypoint {
    /// X position (`XPosition`).
    pub x_position: f32,
    /// Y position (`YPosition`).
    pub y_position: f32,
    /// Z position (`ZPosition`).
    pub z_position: f32,
    /// Runtime object ID (`ObjectId`). Save-game only.
    pub object_id: u32,
}

impl GitWaypoint {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            x_position: get_f32(s, "XPosition").unwrap_or(0.0),
            y_position: get_f32(s, "YPosition").unwrap_or(0.0),
            z_position: get_f32(s, "ZPosition").unwrap_or(0.0),
            object_id: get_u32(s, "ObjectId").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(5);
        upsert_field(&mut s, "XPosition", GffValue::Single(self.x_position));
        upsert_field(&mut s, "YPosition", GffValue::Single(self.y_position));
        upsert_field(&mut s, "ZPosition", GffValue::Single(self.z_position));
        upsert_field(&mut s, "ObjectId", GffValue::UInt32(self.object_id));
        s
    }
}

/// A sound instance placed in the area (struct type 6).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitSound {
    /// Template resref (`TemplateResRef`).
    pub template_resref: ResRef,
    /// Generated type (`GeneratedType`).
    pub generated_type: u32,
    /// X position (`XPosition`).
    pub x_position: f32,
    /// Y position (`YPosition`).
    pub y_position: f32,
    /// Z position (`ZPosition`).
    pub z_position: f32,
    /// Runtime object ID (`ObjectId`). Save-game only.
    pub object_id: u32,
}

impl GitSound {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            template_resref: get_resref(s, "TemplateResRef").unwrap_or_default(),
            generated_type: get_u32(s, "GeneratedType").unwrap_or(0),
            x_position: get_f32(s, "XPosition").unwrap_or(0.0),
            y_position: get_f32(s, "YPosition").unwrap_or(0.0),
            z_position: get_f32(s, "ZPosition").unwrap_or(0.0),
            object_id: get_u32(s, "ObjectId").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(6);
        upsert_field(
            &mut s,
            "TemplateResRef",
            GffValue::ResRef(self.template_resref),
        );
        upsert_field(
            &mut s,
            "GeneratedType",
            GffValue::UInt32(self.generated_type),
        );
        upsert_field(&mut s, "XPosition", GffValue::Single(self.x_position));
        upsert_field(&mut s, "YPosition", GffValue::Single(self.y_position));
        upsert_field(&mut s, "ZPosition", GffValue::Single(self.z_position));
        upsert_field(&mut s, "ObjectId", GffValue::UInt32(self.object_id));
        s
    }
}

/// A trigger instance placed in the area (struct type 1).
///
/// Triggers carry geometry (vertex polygon) and optional area-transition
/// fields (`LinkedToModule`, `LinkedTo`, `LinkedToFlags`,
/// `TransitionDestination`).
#[derive(Debug, Clone, PartialEq)]
pub struct GitTrigger {
    /// Template resref (`TemplateResRef`).
    pub template_resref: ResRef,
    /// Linked module resref (`LinkedToModule`). Area transition target.
    pub linked_to_module: ResRef,
    /// Transition destination text (`TransitionDestin`, truncated from
    /// `TransitionDestination` by the 16-byte GFF label limit).
    pub transition_destination: GffLocalizedString,
    /// Linked-to tag (`LinkedTo`). Waypoint tag in the target module.
    pub linked_to: String,
    /// Linked-to flags (`LinkedToFlags`).
    pub linked_to_flags: u8,
    /// X position (`XPosition`).
    pub x_position: f32,
    /// Y position (`YPosition`).
    pub y_position: f32,
    /// Z position (`ZPosition`).
    pub z_position: f32,
    /// Geometry polygon vertices (`Geometry`).
    pub geometry: Vec<GitTriggerPoint>,
    /// Runtime object ID (`ObjectId`). Save-game only.
    pub object_id: u32,
}

impl Default for GitTrigger {
    fn default() -> Self {
        Self {
            template_resref: ResRef::blank(),
            linked_to_module: ResRef::blank(),
            transition_destination: GffLocalizedString::new(StrRef::invalid()),
            linked_to: String::new(),
            linked_to_flags: 0,
            x_position: 0.0,
            y_position: 0.0,
            z_position: 0.0,
            geometry: Vec::new(),
            object_id: 0,
        }
    }
}

impl GitTrigger {
    fn from_gff_struct(s: &GffStruct) -> Self {
        let geometry = match s.field("Geometry") {
            Some(GffValue::List(elements)) => elements
                .iter()
                .map(GitTriggerPoint::from_gff_struct)
                .collect(),
            _ => Vec::new(),
        };

        Self {
            template_resref: get_resref(s, "TemplateResRef").unwrap_or_default(),
            linked_to_module: get_resref(s, "LinkedToModule").unwrap_or_default(),
            transition_destination: get_locstring(s, "TransitionDestin")
                .cloned()
                .unwrap_or_else(|| GffLocalizedString::new(StrRef::invalid())),
            linked_to: get_string(s, "LinkedTo").unwrap_or_default(),
            linked_to_flags: get_u8(s, "LinkedToFlags").unwrap_or(0),
            x_position: get_f32(s, "XPosition").unwrap_or(0.0),
            y_position: get_f32(s, "YPosition").unwrap_or(0.0),
            z_position: get_f32(s, "ZPosition").unwrap_or(0.0),
            geometry,
            object_id: get_u32(s, "ObjectId").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(1);
        upsert_field(
            &mut s,
            "TemplateResRef",
            GffValue::ResRef(self.template_resref),
        );
        upsert_field(
            &mut s,
            "LinkedToModule",
            GffValue::ResRef(self.linked_to_module),
        );
        upsert_field(
            &mut s,
            "TransitionDestin",
            GffValue::LocalizedString(self.transition_destination.clone()),
        );
        upsert_field(&mut s, "LinkedTo", GffValue::String(self.linked_to.clone()));
        upsert_field(
            &mut s,
            "LinkedToFlags",
            GffValue::UInt8(self.linked_to_flags),
        );
        upsert_field(&mut s, "XPosition", GffValue::Single(self.x_position));
        upsert_field(&mut s, "YPosition", GffValue::Single(self.y_position));
        upsert_field(&mut s, "ZPosition", GffValue::Single(self.z_position));
        let geom_structs: Vec<GffStruct> =
            self.geometry.iter().map(|p| p.to_gff_struct()).collect();
        upsert_field(&mut s, "Geometry", GffValue::List(geom_structs));
        upsert_field(&mut s, "ObjectId", GffValue::UInt32(self.object_id));
        s
    }
}

/// A store instance placed in the area (struct type 0xb).
///
/// Stores use `ResRef` (not `TemplateResRef`) for the template reference.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitStore {
    /// Template resref (`ResRef`). Note the non-standard field name.
    pub resref: ResRef,
    /// X orientation (`XOrientation`).
    pub x_orientation: f32,
    /// Y orientation (`YOrientation`).
    pub y_orientation: f32,
    /// Z orientation (`ZOrientation`).
    pub z_orientation: f32,
    /// X position (`XPosition`).
    pub x_position: f32,
    /// Y position (`YPosition`).
    pub y_position: f32,
    /// Z position (`ZPosition`).
    pub z_position: f32,
    /// Runtime object ID (`ObjectId`). Save-game only.
    pub object_id: u32,
}

impl GitStore {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            resref: get_resref(s, "ResRef").unwrap_or_default(),
            x_orientation: get_f32(s, "XOrientation").unwrap_or(0.0),
            y_orientation: get_f32(s, "YOrientation").unwrap_or(0.0),
            z_orientation: get_f32(s, "ZOrientation").unwrap_or(0.0),
            x_position: get_f32(s, "XPosition").unwrap_or(0.0),
            y_position: get_f32(s, "YPosition").unwrap_or(0.0),
            z_position: get_f32(s, "ZPosition").unwrap_or(0.0),
            object_id: get_u32(s, "ObjectId").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(11);
        upsert_field(&mut s, "ResRef", GffValue::ResRef(self.resref));
        upsert_field(&mut s, "XOrientation", GffValue::Single(self.x_orientation));
        upsert_field(&mut s, "YOrientation", GffValue::Single(self.y_orientation));
        upsert_field(&mut s, "ZOrientation", GffValue::Single(self.z_orientation));
        upsert_field(&mut s, "XPosition", GffValue::Single(self.x_position));
        upsert_field(&mut s, "YPosition", GffValue::Single(self.y_position));
        upsert_field(&mut s, "ZPosition", GffValue::Single(self.z_position));
        upsert_field(&mut s, "ObjectId", GffValue::UInt32(self.object_id));
        s
    }
}

/// A vertex in an encounter geometry polygon (`X`/`Y`/`Z`).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitEncounterPoint {
    /// X coordinate (`X`).
    pub x: f32,
    /// Y coordinate (`Y`).
    pub y: f32,
    /// Z coordinate (`Z`).
    pub z: f32,
}

impl GitEncounterPoint {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            x: get_f32(s, "X").unwrap_or(0.0),
            y: get_f32(s, "Y").unwrap_or(0.0),
            z: get_f32(s, "Z").unwrap_or(0.0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        upsert_field(&mut s, "X", GffValue::Single(self.x));
        upsert_field(&mut s, "Y", GffValue::Single(self.y));
        upsert_field(&mut s, "Z", GffValue::Single(self.z));
        s
    }
}

/// A spawn point within an encounter (`X`/`Y`/`Z`/`Orientation`).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitSpawnPoint {
    /// X coordinate (`X`).
    pub x: f32,
    /// Y coordinate (`Y`).
    pub y: f32,
    /// Z coordinate (`Z`).
    pub z: f32,
    /// Facing angle (`Orientation`).
    pub orientation: f32,
}

impl GitSpawnPoint {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            x: get_f32(s, "X").unwrap_or(0.0),
            y: get_f32(s, "Y").unwrap_or(0.0),
            z: get_f32(s, "Z").unwrap_or(0.0),
            orientation: get_f32(s, "Orientation").unwrap_or(0.0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        upsert_field(&mut s, "X", GffValue::Single(self.x));
        upsert_field(&mut s, "Y", GffValue::Single(self.y));
        upsert_field(&mut s, "Z", GffValue::Single(self.z));
        upsert_field(&mut s, "Orientation", GffValue::Single(self.orientation));
        s
    }
}

/// An encounter instance placed in the area (struct type 7).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitEncounter {
    /// Template resref (`TemplateResRef`).
    pub template_resref: ResRef,
    /// X position (`XPosition`).
    pub x_position: f32,
    /// Y position (`YPosition`).
    pub y_position: f32,
    /// Z position (`ZPosition`).
    pub z_position: f32,
    /// Geometry polygon vertices (`Geometry`).
    pub geometry: Vec<GitEncounterPoint>,
    /// Spawn point list (`SpawnPointList`).
    pub spawn_points: Vec<GitSpawnPoint>,
    /// Runtime object ID (`ObjectId`). Save-game only.
    pub object_id: u32,
}

impl GitEncounter {
    fn from_gff_struct(s: &GffStruct) -> Self {
        let geometry = match s.field("Geometry") {
            Some(GffValue::List(elements)) => elements
                .iter()
                .map(GitEncounterPoint::from_gff_struct)
                .collect(),
            _ => Vec::new(),
        };

        let spawn_points = match s.field("SpawnPointList") {
            Some(GffValue::List(elements)) => elements
                .iter()
                .map(GitSpawnPoint::from_gff_struct)
                .collect(),
            _ => Vec::new(),
        };

        Self {
            template_resref: get_resref(s, "TemplateResRef").unwrap_or_default(),
            x_position: get_f32(s, "XPosition").unwrap_or(0.0),
            y_position: get_f32(s, "YPosition").unwrap_or(0.0),
            z_position: get_f32(s, "ZPosition").unwrap_or(0.0),
            geometry,
            spawn_points,
            object_id: get_u32(s, "ObjectId").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(7);
        upsert_field(
            &mut s,
            "TemplateResRef",
            GffValue::ResRef(self.template_resref),
        );
        upsert_field(&mut s, "XPosition", GffValue::Single(self.x_position));
        upsert_field(&mut s, "YPosition", GffValue::Single(self.y_position));
        upsert_field(&mut s, "ZPosition", GffValue::Single(self.z_position));
        let geom_structs: Vec<GffStruct> =
            self.geometry.iter().map(|p| p.to_gff_struct()).collect();
        upsert_field(&mut s, "Geometry", GffValue::List(geom_structs));
        let spawn_structs: Vec<GffStruct> = self
            .spawn_points
            .iter()
            .map(|sp| sp.to_gff_struct())
            .collect();
        upsert_field(&mut s, "SpawnPointList", GffValue::List(spawn_structs));
        upsert_field(&mut s, "ObjectId", GffValue::UInt32(self.object_id));
        s
    }
}

/// An area-of-effect instance in the area (struct type 0xd).
///
/// Area effects use `OrientationX`/`PositionX` naming (not `XOrientation`
/// or `XPosition`).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitAreaEffect {
    /// X orientation (`OrientationX`).
    pub orientation_x: f32,
    /// Y orientation (`OrientationY`).
    pub orientation_y: f32,
    /// Z orientation (`OrientationZ`).
    pub orientation_z: f32,
    /// X position (`PositionX`).
    pub position_x: f32,
    /// Y position (`PositionY`).
    pub position_y: f32,
    /// Z position (`PositionZ`).
    pub position_z: f32,
    /// Runtime object ID (`ObjectId`). Save-game only.
    pub object_id: u32,
}

impl GitAreaEffect {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            orientation_x: get_f32(s, "OrientationX").unwrap_or(0.0),
            orientation_y: get_f32(s, "OrientationY").unwrap_or(0.0),
            orientation_z: get_f32(s, "OrientationZ").unwrap_or(0.0),
            position_x: get_f32(s, "PositionX").unwrap_or(0.0),
            position_y: get_f32(s, "PositionY").unwrap_or(0.0),
            position_z: get_f32(s, "PositionZ").unwrap_or(0.0),
            object_id: get_u32(s, "ObjectId").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(13);
        upsert_field(&mut s, "OrientationX", GffValue::Single(self.orientation_x));
        upsert_field(&mut s, "OrientationY", GffValue::Single(self.orientation_y));
        upsert_field(&mut s, "OrientationZ", GffValue::Single(self.orientation_z));
        upsert_field(&mut s, "PositionX", GffValue::Single(self.position_x));
        upsert_field(&mut s, "PositionY", GffValue::Single(self.position_y));
        upsert_field(&mut s, "PositionZ", GffValue::Single(self.position_z));
        upsert_field(&mut s, "ObjectId", GffValue::UInt32(self.object_id));
        s
    }
}

// =========================================================================
// Non-instance sub-types
// =========================================================================

/// Area-level properties (music, ambient sound, stealth XP, fog).
///
/// This is a single `Struct` in the GIT root (field label `AreaProperties`).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitAreaProperties {
    /// Unescapable flag (`Unescapable`).
    pub unescapable: bool,
    /// Stealth XP maximum (`StealthXPMax`).
    pub stealth_xp_max: u32,
    /// Current stealth XP count (`StealthXPCurrent`). Save-game state.
    pub stealth_xp_current: u32,
    /// Stealth XP loss per detection (`StealthXPLoss`).
    pub stealth_xp_loss: u32,
    /// Stealth XP enabled flag (`StealthXPEnabled`).
    pub stealth_xp_enabled: bool,
    /// Transition pending flag (`TransPending`). Save-game state.
    pub trans_pending: bool,
    /// Pending transition next ID (`TransPendNextID`). Save-game state.
    pub trans_pend_next_id: u8,
    /// Pending transition current ID (`TransPendCurrID`). Save-game state.
    pub trans_pend_curr_id: u8,
    /// Sun/fog color packed as RGBA (`SunFogColor`).
    pub sun_fog_color: u32,
    /// Music delay in ms (`MusicDelay`).
    pub music_delay: i32,
    /// Daytime music track ID (`MusicDay`). References ambientmusic.2da.
    pub music_day: i32,
    /// Night-time music track ID (`MusicNight`). References ambientmusic.2da.
    pub music_night: i32,
    /// Battle music track ID (`MusicBattle`). References ambientmusic.2da.
    pub music_battle: i32,
    /// Daytime ambient sound ID (`AmbientSndDay`). References ambientsound.2da.
    pub ambient_snd_day: i32,
    /// Night-time ambient sound ID (`AmbientSndNight`). References ambientsound.2da.
    pub ambient_snd_night: i32,
    /// Daytime ambient sound volume (`AmbientSndDayVol`).
    pub ambient_snd_day_vol: i32,
    /// Night-time ambient sound volume (`AmbientSndNitVol`).
    pub ambient_snd_nit_vol: i32,
}

impl GitAreaProperties {
    fn from_gff_struct(s: &GffStruct) -> Self {
        Self {
            unescapable: get_bool(s, "Unescapable").unwrap_or(false),
            stealth_xp_max: get_u32(s, "StealthXPMax").unwrap_or(0),
            stealth_xp_current: get_u32(s, "StealthXPCurrent").unwrap_or(0),
            stealth_xp_loss: get_u32(s, "StealthXPLoss").unwrap_or(0),
            stealth_xp_enabled: get_bool(s, "StealthXPEnabled").unwrap_or(false),
            trans_pending: get_bool(s, "TransPending").unwrap_or(false),
            trans_pend_next_id: get_u8(s, "TransPendNextID").unwrap_or(0),
            trans_pend_curr_id: get_u8(s, "TransPendCurrID").unwrap_or(0),
            sun_fog_color: get_u32(s, "SunFogColor").unwrap_or(0),
            music_delay: get_i32(s, "MusicDelay").unwrap_or(0),
            music_day: get_i32(s, "MusicDay").unwrap_or(0),
            music_night: get_i32(s, "MusicNight").unwrap_or(0),
            music_battle: get_i32(s, "MusicBattle").unwrap_or(0),
            ambient_snd_day: get_i32(s, "AmbientSndDay").unwrap_or(0),
            ambient_snd_night: get_i32(s, "AmbientSndNight").unwrap_or(0),
            ambient_snd_day_vol: get_i32(s, "AmbientSndDayVol").unwrap_or(0),
            ambient_snd_nit_vol: get_i32(s, "AmbientSndNitVol").unwrap_or(0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        upsert_field(
            &mut s,
            "Unescapable",
            GffValue::UInt8(u8::from(self.unescapable)),
        );
        upsert_field(
            &mut s,
            "StealthXPMax",
            GffValue::UInt32(self.stealth_xp_max),
        );
        upsert_field(
            &mut s,
            "StealthXPCurrent",
            GffValue::UInt32(self.stealth_xp_current),
        );
        upsert_field(
            &mut s,
            "StealthXPLoss",
            GffValue::UInt32(self.stealth_xp_loss),
        );
        upsert_field(
            &mut s,
            "StealthXPEnabled",
            GffValue::UInt8(u8::from(self.stealth_xp_enabled)),
        );
        upsert_field(
            &mut s,
            "TransPending",
            GffValue::UInt8(u8::from(self.trans_pending)),
        );
        upsert_field(
            &mut s,
            "TransPendNextID",
            GffValue::UInt8(self.trans_pend_next_id),
        );
        upsert_field(
            &mut s,
            "TransPendCurrID",
            GffValue::UInt8(self.trans_pend_curr_id),
        );
        upsert_field(&mut s, "SunFogColor", GffValue::UInt32(self.sun_fog_color));
        upsert_field(&mut s, "MusicDelay", GffValue::Int32(self.music_delay));
        upsert_field(&mut s, "MusicDay", GffValue::Int32(self.music_day));
        upsert_field(&mut s, "MusicNight", GffValue::Int32(self.music_night));
        upsert_field(&mut s, "MusicBattle", GffValue::Int32(self.music_battle));
        upsert_field(
            &mut s,
            "AmbientSndDay",
            GffValue::Int32(self.ambient_snd_day),
        );
        upsert_field(
            &mut s,
            "AmbientSndNight",
            GffValue::Int32(self.ambient_snd_night),
        );
        upsert_field(
            &mut s,
            "AmbientSndDayVol",
            GffValue::Int32(self.ambient_snd_day_vol),
        );
        upsert_field(
            &mut s,
            "AmbientSndNitVol",
            GffValue::Int32(self.ambient_snd_nit_vol),
        );
        s
    }
}

/// A static camera entry in the area.
///
/// `Position` is a GFF Vector3 and `Orientation` is a GFF Quaternion (Vector4).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct GitCamera {
    /// Camera ID (`CameraID`).
    pub camera_id: i32,
    /// Position as GFF Vector3 (`Position`).
    pub position: [f32; 3],
    /// Orientation as GFF Quaternion (`Orientation`).
    pub orientation: [f32; 4],
    /// Pitch angle (`Pitch`).
    pub pitch: f32,
    /// Height offset (`Height`).
    pub height: f32,
    /// Field of view (`FieldOfView`, engine default 55.0).
    pub field_of_view: f32,
    /// Microphone range (`MicRange`).
    pub mic_range: f32,
}

impl GitCamera {
    fn from_gff_struct(s: &GffStruct) -> Self {
        let position = match s.field("Position") {
            Some(GffValue::Vector3(v)) => *v,
            _ => [0.0, 0.0, 0.0],
        };
        let orientation = match s.field("Orientation") {
            Some(GffValue::Vector4(v)) => *v,
            _ => [0.0, 0.0, 0.0, 1.0],
        };

        Self {
            camera_id: get_i32(s, "CameraID").unwrap_or(-1),
            position,
            orientation,
            pitch: get_f32(s, "Pitch").unwrap_or(0.0),
            height: get_f32(s, "Height").unwrap_or(0.0),
            field_of_view: get_f32(s, "FieldOfView").unwrap_or(55.0),
            mic_range: get_f32(s, "MicRange").unwrap_or(0.0),
        }
    }

    fn to_gff_struct(&self) -> GffStruct {
        let mut s = GffStruct::new(0);
        upsert_field(&mut s, "CameraID", GffValue::Int32(self.camera_id));
        upsert_field(&mut s, "Position", GffValue::Vector3(self.position));
        upsert_field(&mut s, "Orientation", GffValue::Vector4(self.orientation));
        upsert_field(&mut s, "Pitch", GffValue::Single(self.pitch));
        upsert_field(&mut s, "Height", GffValue::Single(self.height));
        upsert_field(&mut s, "FieldOfView", GffValue::Single(self.field_of_view));
        upsert_field(&mut s, "MicRange", GffValue::Single(self.mic_range));
        s
    }
}

// =========================================================================
// Root GIT struct
// =========================================================================

/// Typed GIT model built from/to [`Gff`] data.
///
/// GIT is the area instance container. It places object instances by
/// referencing templates and providing position/orientation data. All
/// engine-read fields are typed; roundtrip is fully lossless for typed
/// fields.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Git {
    // --- Root scalars ---
    /// Current weather type (`CurrentWeather`).
    pub current_weather: u8,
    /// Weather active flag (`WeatherStarted`).
    pub weather_started: bool,
    /// Use-templates flag (`UseTemplates`).
    pub use_templates: bool,

    // --- Object instance lists (10) ---
    /// Creature instances (`Creature List`).
    pub creatures: Vec<GitCreature>,
    /// Item instances (`List`).
    pub items: Vec<GitItem>,
    /// Door instances (`Door List`).
    pub doors: Vec<GitDoor>,
    /// Placeable instances (`Placeable List`).
    pub placeables: Vec<GitPlaceable>,
    /// Waypoint instances (`WaypointList`).
    pub waypoints: Vec<GitWaypoint>,
    /// Sound instances (`SoundList`).
    pub sounds: Vec<GitSound>,
    /// Trigger instances (`TriggerList`).
    pub triggers: Vec<GitTrigger>,
    /// Store instances (`StoreList`).
    pub stores: Vec<GitStore>,
    /// Encounter instances (`Encounter List`).
    pub encounters: Vec<GitEncounter>,
    /// Area-of-effect instances (`AreaEffectList`).
    pub area_effects: Vec<GitAreaEffect>,

    // --- Nested structs ---
    /// Area-level properties (`AreaProperties`).
    pub area_properties: Option<GitAreaProperties>,

    // --- Camera list ---
    /// Static cameras (`CameraList`).
    pub cameras: Vec<GitCamera>,
}

impl Git {
    /// Creates an empty GIT value.
    pub fn new() -> Self {
        Self::default()
    }

    /// Builds typed GIT data from a parsed GFF container.
    pub fn from_gff(gff: &Gff) -> Result<Self, GitError> {
        if gff.file_type != *b"GIT " && gff.file_type != *b"GFF " {
            return Err(GitError::UnsupportedFileType(gff.file_type));
        }

        let root = &gff.root;

        fn read_list<T>(root: &GffStruct, label: &str, f: fn(&GffStruct) -> T) -> Vec<T> {
            match root.field(label) {
                Some(GffValue::List(elements)) => elements.iter().map(f).collect(),
                _ => Vec::new(),
            }
        }

        let area_properties = match root.field("AreaProperties") {
            Some(GffValue::Struct(s)) => Some(GitAreaProperties::from_gff_struct(s)),
            _ => None,
        };

        Ok(Self {
            current_weather: get_u8(root, "CurrentWeather").unwrap_or(0),
            weather_started: get_bool(root, "WeatherStarted").unwrap_or(false),
            use_templates: get_bool(root, "UseTemplates").unwrap_or(false),

            creatures: read_list(root, "Creature List", GitCreature::from_gff_struct),
            items: read_list(root, "List", GitItem::from_gff_struct),
            doors: read_list(root, "Door List", GitDoor::from_gff_struct),
            placeables: read_list(root, "Placeable List", GitPlaceable::from_gff_struct),
            waypoints: read_list(root, "WaypointList", GitWaypoint::from_gff_struct),
            sounds: read_list(root, "SoundList", GitSound::from_gff_struct),
            triggers: read_list(root, "TriggerList", GitTrigger::from_gff_struct),
            stores: read_list(root, "StoreList", GitStore::from_gff_struct),
            encounters: read_list(root, "Encounter List", GitEncounter::from_gff_struct),
            area_effects: read_list(root, "AreaEffectList", GitAreaEffect::from_gff_struct),

            area_properties,
            cameras: read_list(root, "CameraList", GitCamera::from_gff_struct),
        })
    }

    /// Converts this typed GIT value into a GFF container.
    pub fn to_gff(&self) -> Gff {
        let mut root = GffStruct::new(-1);

        upsert_field(
            &mut root,
            "CurrentWeather",
            GffValue::UInt8(self.current_weather),
        );
        upsert_field(
            &mut root,
            "WeatherStarted",
            GffValue::UInt8(u8::from(self.weather_started)),
        );
        upsert_field(
            &mut root,
            "UseTemplates",
            GffValue::UInt8(u8::from(self.use_templates)),
        );

        fn write_list<T>(root: &mut GffStruct, label: &str, items: &[T], f: fn(&T) -> GffStruct) {
            let structs: Vec<GffStruct> = items.iter().map(f).collect();
            upsert_field(root, label, GffValue::List(structs));
        }

        write_list(
            &mut root,
            "Creature List",
            &self.creatures,
            GitCreature::to_gff_struct,
        );
        write_list(&mut root, "List", &self.items, GitItem::to_gff_struct);
        write_list(&mut root, "Door List", &self.doors, GitDoor::to_gff_struct);
        write_list(
            &mut root,
            "Placeable List",
            &self.placeables,
            GitPlaceable::to_gff_struct,
        );
        write_list(
            &mut root,
            "WaypointList",
            &self.waypoints,
            GitWaypoint::to_gff_struct,
        );
        write_list(
            &mut root,
            "SoundList",
            &self.sounds,
            GitSound::to_gff_struct,
        );
        write_list(
            &mut root,
            "TriggerList",
            &self.triggers,
            GitTrigger::to_gff_struct,
        );
        write_list(
            &mut root,
            "StoreList",
            &self.stores,
            GitStore::to_gff_struct,
        );
        write_list(
            &mut root,
            "Encounter List",
            &self.encounters,
            GitEncounter::to_gff_struct,
        );
        write_list(
            &mut root,
            "AreaEffectList",
            &self.area_effects,
            GitAreaEffect::to_gff_struct,
        );

        if let Some(ref ap) = self.area_properties {
            upsert_field(
                &mut root,
                "AreaProperties",
                GffValue::Struct(Box::new(ap.to_gff_struct())),
            );
        }

        write_list(
            &mut root,
            "CameraList",
            &self.cameras,
            GitCamera::to_gff_struct,
        );

        Gff::new(*b"GIT ", root)
    }
}

/// Errors produced while reading or writing typed GIT data.
#[derive(Debug, Error)]
pub enum GitError {
    /// Source file type is not supported by this parser.
    #[error("unsupported GIT file type: {0:?}")]
    UnsupportedFileType([u8; 4]),
    /// Underlying GFF parser/writer error.
    #[error(transparent)]
    Gff(#[from] GffBinaryError),
}

/// Reads typed GIT data from a reader at the current stream position.
#[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "debug", skip(reader))
)]
pub fn read_git<R: Read>(reader: &mut R) -> Result<Git, GitError> {
    let gff = read_gff(reader)?;
    Git::from_gff(&gff)
}

/// Reads typed GIT data directly from bytes.
#[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "debug", skip(bytes), fields(bytes_len = bytes.len()))
)]
pub fn read_git_from_bytes(bytes: &[u8]) -> Result<Git, GitError> {
    let gff = read_gff_from_bytes(bytes)?;
    Git::from_gff(&gff)
}

/// Writes typed GIT data to an output writer.
#[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "debug", skip(writer, git))
)]
pub fn write_git<W: Write>(writer: &mut W, git: &Git) -> Result<(), GitError> {
    let gff = git.to_gff();
    write_gff(writer, &gff)?;
    Ok(())
}

/// Serializes typed GIT data into a byte vector.
#[cfg_attr(feature = "tracing", tracing::instrument(level = "debug", skip(git)))]
pub fn write_git_to_vec(git: &Git) -> Result<Vec<u8>, GitError> {
    let mut cursor = Cursor::new(Vec::new());
    write_git(&mut cursor, git)?;
    Ok(cursor.into_inner())
}

// =========================================================================
// Leaf sub-schemas (no nested children)
// =========================================================================

/// GIT `Creature List` entry child schema (struct type 4).
static CREATURE_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "ObjectId",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "TemplateResRef",
        expected_type: GffType::ResRef,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "XPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "YPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ZPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "XOrientation",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "YOrientation",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ZOrientation",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `List` (item) entry child schema (struct type 0).
static ITEM_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "ObjectId",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "TemplateResRef",
        expected_type: GffType::ResRef,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "XPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "YPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ZPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "XOrientation",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "YOrientation",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ZOrientation",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `Door List` entry child schema (struct type 8).
static DOOR_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "ObjectId",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Bearing",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "X",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Y",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Z",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `Placeable List` entry child schema (struct type 9).
static PLACEABLE_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "ObjectId",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "TemplateResRef",
        expected_type: GffType::ResRef,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Bearing",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "X",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Y",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Z",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `WaypointList` entry child schema (struct type 5).
static WAYPOINT_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "ObjectId",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "XPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "YPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ZPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `SoundList` entry child schema (struct type 6).
static SOUND_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "ObjectId",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "TemplateResRef",
        expected_type: GffType::ResRef,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "GeneratedType",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "XPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "YPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ZPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `TriggerList` geometry entry child schema (PointX/PointY/PointZ).
static TRIGGER_GEOMETRY_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "PointX",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "PointY",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "PointZ",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `TriggerList` entry child schema (struct type 1).
static TRIGGER_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "ObjectId",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "TemplateResRef",
        expected_type: GffType::ResRef,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "LinkedToModule",
        expected_type: GffType::ResRef,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "TransitionDestin",
        expected_type: GffType::LocalizedString,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "LinkedTo",
        expected_type: GffType::String,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "LinkedToFlags",
        expected_type: GffType::UInt8,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "XPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "YPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ZPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Geometry",
        expected_type: GffType::List,
        required: false,
        children: Some(TRIGGER_GEOMETRY_CHILDREN),
        constraint: None,
    },
];

/// GIT `StoreList` entry child schema (struct type 0xb).
static STORE_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "ObjectId",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ResRef",
        expected_type: GffType::ResRef,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "XOrientation",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "YOrientation",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ZOrientation",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "XPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "YPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ZPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `Encounter List` geometry entry child schema (X/Y/Z).
static ENCOUNTER_GEOMETRY_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "X",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Y",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Z",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `Encounter List` spawn point entry child schema (X/Y/Z/Orientation).
static ENCOUNTER_SPAWN_POINT_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "X",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Y",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Z",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Orientation",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `Encounter List` entry child schema (struct type 7).
static ENCOUNTER_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "ObjectId",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "TemplateResRef",
        expected_type: GffType::ResRef,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "XPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "YPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "ZPosition",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Geometry",
        expected_type: GffType::List,
        required: false,
        children: Some(ENCOUNTER_GEOMETRY_CHILDREN),
        constraint: None,
    },
    FieldSchema {
        label: "SpawnPointList",
        expected_type: GffType::List,
        required: false,
        children: Some(ENCOUNTER_SPAWN_POINT_CHILDREN),
        constraint: None,
    },
];

/// GIT `AreaEffectList` entry child schema (struct type 0xd).
static AREA_EFFECT_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "ObjectId",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "OrientationX",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "OrientationY",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "OrientationZ",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "PositionX",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "PositionY",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "PositionZ",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `AreaProperties` struct child schema.
static AREA_PROPERTIES_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "Unescapable",
        expected_type: GffType::UInt8,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "StealthXPMax",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "StealthXPCurrent",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "StealthXPLoss",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "StealthXPEnabled",
        expected_type: GffType::UInt8,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "TransPending",
        expected_type: GffType::UInt8,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "TransPendNextID",
        expected_type: GffType::UInt8,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "TransPendCurrID",
        expected_type: GffType::UInt8,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "SunFogColor",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    // --- Ambient sound fields (CSWSAmbientSound::Load) ---
    FieldSchema {
        label: "MusicDelay",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "MusicDay",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "MusicNight",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "MusicBattle",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "AmbientSndDay",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "AmbientSndNight",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "AmbientSndDayVol",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "AmbientSndNitVol",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `AreaMap` struct child schema. Save-game only.
static AREA_MAP_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "AreaMapResX",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "AreaMapResY",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "AreaMapDataSize",
        expected_type: GffType::UInt32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "AreaMapData",
        expected_type: GffType::Binary,
        required: false,
        children: None,
        constraint: None,
    },
];

/// GIT `CameraList` entry child schema. Client-side only. Max 50 entries.
static CAMERA_LIST_CHILDREN: &[FieldSchema] = &[
    FieldSchema {
        label: "CameraID",
        expected_type: GffType::Int32,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Position",
        expected_type: GffType::Vector3,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Orientation",
        expected_type: GffType::Vector4,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Pitch",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "Height",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "FieldOfView",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
    FieldSchema {
        label: "MicRange",
        expected_type: GffType::Single,
        required: false,
        children: None,
        constraint: None,
    },
];

impl GffSchema for Git {
    fn schema() -> &'static [FieldSchema] {
        static SCHEMA: &[FieldSchema] = &[
            // --- Root scalars ---
            FieldSchema {
                label: "CurrentWeather",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "WeatherStarted",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            FieldSchema {
                label: "UseTemplates",
                expected_type: GffType::UInt8,
                required: false,
                children: None,
                constraint: None,
            },
            // --- Object instance lists (10) ---
            FieldSchema {
                label: "Creature List",
                expected_type: GffType::List,
                required: false,
                children: Some(CREATURE_LIST_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "List",
                expected_type: GffType::List,
                required: false,
                children: Some(ITEM_LIST_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "Door List",
                expected_type: GffType::List,
                required: false,
                children: Some(DOOR_LIST_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "Placeable List",
                expected_type: GffType::List,
                required: false,
                children: Some(PLACEABLE_LIST_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "WaypointList",
                expected_type: GffType::List,
                required: false,
                children: Some(WAYPOINT_LIST_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "SoundList",
                expected_type: GffType::List,
                required: false,
                children: Some(SOUND_LIST_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "TriggerList",
                expected_type: GffType::List,
                required: false,
                children: Some(TRIGGER_LIST_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "StoreList",
                expected_type: GffType::List,
                required: false,
                children: Some(STORE_LIST_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "Encounter List",
                expected_type: GffType::List,
                required: false,
                children: Some(ENCOUNTER_LIST_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "AreaEffectList",
                expected_type: GffType::List,
                required: false,
                children: Some(AREA_EFFECT_LIST_CHILDREN),
                constraint: None,
            },
            // --- Nested structs (2) ---
            FieldSchema {
                label: "AreaProperties",
                expected_type: GffType::Struct,
                required: false,
                children: Some(AREA_PROPERTIES_CHILDREN),
                constraint: None,
            },
            FieldSchema {
                label: "AreaMap",
                expected_type: GffType::Struct,
                required: false,
                children: Some(AREA_MAP_CHILDREN),
                constraint: None,
            },
            // --- Camera list ---
            FieldSchema {
                label: "CameraList",
                expected_type: GffType::List,
                required: false,
                children: Some(CAMERA_LIST_CHILDREN),
                constraint: None,
            },
            // --- Variable table ---
            FieldSchema {
                label: "VarTable",
                expected_type: GffType::List,
                required: false,
                children: None,
                constraint: None,
            },
        ];
        SCHEMA
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Build a minimal GIT GFF for testing.
    fn make_test_git_gff() -> Gff {
        let mut root = GffStruct::new(-1);
        root.push_field("CurrentWeather", GffValue::UInt8(0));
        root.push_field("WeatherStarted", GffValue::UInt8(0));
        root.push_field("UseTemplates", GffValue::UInt8(1));

        // One creature.
        let mut creature = GffStruct::new(4);
        creature.push_field("TemplateResRef", GffValue::resref_lit("n_darthbandon"));
        creature.push_field("XPosition", GffValue::Single(10.0));
        creature.push_field("YPosition", GffValue::Single(20.0));
        creature.push_field("ZPosition", GffValue::Single(0.5));
        creature.push_field("XOrientation", GffValue::Single(0.0));
        creature.push_field("YOrientation", GffValue::Single(1.0));
        creature.push_field("ZOrientation", GffValue::Single(0.0));
        creature.push_field("ObjectId", GffValue::UInt32(0));
        root.push_field("Creature List", GffValue::List(vec![creature]));

        // One placeable.
        let mut placeable = GffStruct::new(9);
        placeable.push_field("TemplateResRef", GffValue::resref_lit("plc_footlkr"));
        placeable.push_field("Bearing", GffValue::Single(1.57));
        placeable.push_field("X", GffValue::Single(15.0));
        placeable.push_field("Y", GffValue::Single(25.0));
        placeable.push_field("Z", GffValue::Single(0.0));
        placeable.push_field("ObjectId", GffValue::UInt32(0));
        root.push_field("Placeable List", GffValue::List(vec![placeable]));

        // One trigger with geometry.
        let mut trigger = GffStruct::new(1);
        trigger.push_field("TemplateResRef", GffValue::resref_lit("newtransition9"));
        trigger.push_field("LinkedToModule", GffValue::resref_lit("tar_m02aa"));
        trigger.push_field(
            "TransitionDestin",
            GffValue::LocalizedString(GffLocalizedString::new(StrRef::from_raw(12345))),
        );
        trigger.push_field("LinkedTo", GffValue::String("wp_target".into()));
        trigger.push_field("LinkedToFlags", GffValue::UInt8(2));
        trigger.push_field("XPosition", GffValue::Single(5.0));
        trigger.push_field("YPosition", GffValue::Single(5.0));
        trigger.push_field("ZPosition", GffValue::Single(0.0));
        let mut pt0 = GffStruct::new(0);
        pt0.push_field("PointX", GffValue::Single(0.0));
        pt0.push_field("PointY", GffValue::Single(0.0));
        pt0.push_field("PointZ", GffValue::Single(0.0));
        let mut pt1 = GffStruct::new(0);
        pt1.push_field("PointX", GffValue::Single(5.0));
        pt1.push_field("PointY", GffValue::Single(0.0));
        pt1.push_field("PointZ", GffValue::Single(0.0));
        let mut pt2 = GffStruct::new(0);
        pt2.push_field("PointX", GffValue::Single(5.0));
        pt2.push_field("PointY", GffValue::Single(5.0));
        pt2.push_field("PointZ", GffValue::Single(0.0));
        trigger.push_field("Geometry", GffValue::List(vec![pt0, pt1, pt2]));
        trigger.push_field("ObjectId", GffValue::UInt32(0));
        root.push_field("TriggerList", GffValue::List(vec![trigger]));

        // AreaProperties.
        let mut props = GffStruct::new(0);
        props.push_field("Unescapable", GffValue::UInt8(0));
        props.push_field("StealthXPMax", GffValue::UInt32(100));
        props.push_field("StealthXPCurrent", GffValue::UInt32(0));
        props.push_field("StealthXPLoss", GffValue::UInt32(10));
        props.push_field("StealthXPEnabled", GffValue::UInt8(1));
        props.push_field("TransPending", GffValue::UInt8(0));
        props.push_field("TransPendNextID", GffValue::UInt8(0));
        props.push_field("TransPendCurrID", GffValue::UInt8(0));
        props.push_field("SunFogColor", GffValue::UInt32(0x00ABCDEF));
        props.push_field("MusicDelay", GffValue::Int32(6000));
        props.push_field("MusicDay", GffValue::Int32(48));
        props.push_field("MusicNight", GffValue::Int32(49));
        props.push_field("MusicBattle", GffValue::Int32(25));
        props.push_field("AmbientSndDay", GffValue::Int32(12));
        props.push_field("AmbientSndNight", GffValue::Int32(13));
        props.push_field("AmbientSndDayVol", GffValue::Int32(50));
        props.push_field("AmbientSndNitVol", GffValue::Int32(40));
        root.push_field("AreaProperties", GffValue::Struct(Box::new(props)));

        // Empty lists for remaining types.
        root.push_field("List", GffValue::List(vec![]));
        root.push_field("Door List", GffValue::List(vec![]));
        root.push_field("WaypointList", GffValue::List(vec![]));
        root.push_field("SoundList", GffValue::List(vec![]));
        root.push_field("StoreList", GffValue::List(vec![]));
        root.push_field("Encounter List", GffValue::List(vec![]));
        root.push_field("AreaEffectList", GffValue::List(vec![]));
        root.push_field("CameraList", GffValue::List(vec![]));

        Gff::new(*b"GIT ", root)
    }

    #[test]
    fn reads_root_scalars() {
        let gff = make_test_git_gff();
        let git = Git::from_gff(&gff).expect("valid GIT GFF must parse");

        assert_eq!(git.current_weather, 0);
        assert!(!git.weather_started);
        assert!(git.use_templates);
    }

    #[test]
    fn reads_creature_list() {
        let gff = make_test_git_gff();
        let git = Git::from_gff(&gff).expect("valid GIT GFF must parse");

        assert_eq!(git.creatures.len(), 1);
        let c = &git.creatures[0];
        assert_eq!(c.template_resref, "n_darthbandon");
        assert!((c.x_position - 10.0).abs() < f32::EPSILON);
        assert!((c.y_position - 20.0).abs() < f32::EPSILON);
        assert!((c.y_orientation - 1.0).abs() < f32::EPSILON);
    }

    #[test]
    fn reads_placeable_list() {
        let gff = make_test_git_gff();
        let git = Git::from_gff(&gff).expect("valid GIT GFF must parse");

        assert_eq!(git.placeables.len(), 1);
        let p = &git.placeables[0];
        assert_eq!(p.template_resref, "plc_footlkr");
        assert!((p.bearing - 1.57).abs() < 0.01);
        assert!((p.x - 15.0).abs() < f32::EPSILON);
    }

    #[test]
    fn reads_trigger_with_geometry() {
        let gff = make_test_git_gff();
        let git = Git::from_gff(&gff).expect("valid GIT GFF must parse");

        assert_eq!(git.triggers.len(), 1);
        let t = &git.triggers[0];
        assert_eq!(t.template_resref, "newtransition9");
        assert_eq!(t.linked_to_module, "tar_m02aa");
        assert_eq!(t.linked_to, "wp_target");
        assert_eq!(t.linked_to_flags, 2);
        assert_eq!(t.geometry.len(), 3);
        assert!((t.geometry[1].point_x - 5.0).abs() < f32::EPSILON);
    }

    #[test]
    fn reads_area_properties() {
        let gff = make_test_git_gff();
        let git = Git::from_gff(&gff).expect("valid GIT GFF must parse");

        let ap = git
            .area_properties
            .as_ref()
            .expect("test GFF includes AreaProperties");
        assert!(!ap.unescapable);
        assert_eq!(ap.stealth_xp_max, 100);
        assert!(ap.stealth_xp_enabled);
        assert_eq!(ap.music_day, 48);
        assert_eq!(ap.music_night, 49);
        assert_eq!(ap.music_battle, 25);
        assert_eq!(ap.ambient_snd_day_vol, 50);
        assert_eq!(ap.ambient_snd_nit_vol, 40);
    }

    #[test]
    fn all_fields_survive_synthetic_roundtrip() {
        let gff = make_test_git_gff();
        let git = Git::from_gff(&gff).expect("valid GIT GFF must parse");
        let bytes = write_git_to_vec(&git).expect("write succeeds");
        let reparsed = read_git_from_bytes(&bytes).expect("reparse succeeds");

        assert_eq!(reparsed, git);
    }

    #[test]
    fn typed_edits_roundtrip_through_gff_writer() {
        let gff = make_test_git_gff();
        let mut git = Git::from_gff(&gff).expect("valid GIT GFF must parse");
        git.creatures[0].template_resref = ResRef::new("n_sithsoldier").expect("valid test resref");
        git.creatures[0].x_position = 100.0;
        git.area_properties
            .as_mut()
            .expect("test GFF includes AreaProperties")
            .music_day = 99;

        let bytes = write_git_to_vec(&git).expect("write succeeds");
        let reparsed = read_git_from_bytes(&bytes).expect("reparse succeeds");

        assert_eq!(reparsed.creatures[0].template_resref, "n_sithsoldier");
        assert!((reparsed.creatures[0].x_position - 100.0).abs() < f32::EPSILON);
        assert_eq!(
            reparsed
                .area_properties
                .as_ref()
                .expect("roundtripped GIT must have AreaProperties")
                .music_day,
            99
        );
    }

    #[test]
    fn read_git_from_reader_matches_bytes_path() {
        let gff = make_test_git_gff();
        let bytes = {
            let mut c = Cursor::new(Vec::new());
            write_gff(&mut c, &gff).expect("GFF write to cursor always succeeds");
            c.into_inner()
        };

        let mut cursor = Cursor::new(&bytes);
        let via_reader = read_git(&mut cursor).expect("reader parse succeeds");
        let via_bytes = read_git_from_bytes(&bytes).expect("bytes parse succeeds");

        assert_eq!(via_reader, via_bytes);
    }

    #[test]
    fn rejects_non_git_file_type() {
        let mut gff = make_test_git_gff();
        gff.file_type = *b"UTW ";

        let err = Git::from_gff(&gff).expect_err("UTW must be rejected as GIT input");
        assert!(matches!(
            err,
            GitError::UnsupportedFileType(ft) if ft == *b"UTW "
        ));
    }

    #[test]
    fn write_git_matches_direct_gff_writer() {
        let gff = make_test_git_gff();
        let git = Git::from_gff(&gff).expect("valid GIT GFF must parse");

        let via_typed = write_git_to_vec(&git).expect("typed write succeeds");

        let mut direct = Cursor::new(Vec::new());
        write_gff(&mut direct, &git.to_gff()).expect("direct write succeeds");

        assert_eq!(via_typed, direct.into_inner());
    }

    // --- Fixture tests ---

    const TEST_GIT: &[u8] = include_bytes!(concat!(
        env!("CARGO_MANIFEST_DIR"),
        "/../../fixtures/test.git"
    ));
    const K1_GIT: &[u8] = include_bytes!(concat!(
        env!("CARGO_MANIFEST_DIR"),
        "/../../fixtures/k1_same_git_test.git"
    ));

    #[test]
    fn parses_test_git_fixture() {
        let git = read_git_from_bytes(TEST_GIT).expect("test.git must parse");
        // Should have at least some instance data.
        let total = git.creatures.len()
            + git.items.len()
            + git.doors.len()
            + git.placeables.len()
            + git.waypoints.len()
            + git.sounds.len()
            + git.triggers.len()
            + git.stores.len()
            + git.encounters.len()
            + git.area_effects.len();
        assert!(total > 0, "fixture should have some instance data");
    }

    #[test]
    fn parses_k1_git_fixture() {
        let git = read_git_from_bytes(K1_GIT).expect("k1 GIT must parse");
        let total = git.creatures.len()
            + git.items.len()
            + git.doors.len()
            + git.placeables.len()
            + git.waypoints.len()
            + git.sounds.len()
            + git.triggers.len()
            + git.stores.len()
            + git.encounters.len()
            + git.area_effects.len();
        assert!(total > 0, "K1 fixture should have some instance data");
    }

    #[test]
    fn all_fields_survive_typed_roundtrip() {
        let git = read_git_from_bytes(TEST_GIT).expect("test.git must parse");
        let bytes = write_git_to_vec(&git).expect("write succeeds");
        let reparsed = read_git_from_bytes(&bytes).expect("reparse succeeds");

        assert_eq!(reparsed, git);
    }

    #[test]
    fn all_fields_survive_typed_roundtrip_k1() {
        let git = read_git_from_bytes(K1_GIT).expect("k1 GIT must parse");
        let bytes = write_git_to_vec(&git).expect("write succeeds");
        let reparsed = read_git_from_bytes(&bytes).expect("reparse succeeds");

        assert_eq!(reparsed, git);
    }

    // --- Schema tests ---

    #[test]
    fn schema_field_count() {
        assert_eq!(Git::schema().len(), 17);
    }

    #[test]
    fn schema_no_duplicate_labels() {
        let schema = Git::schema();
        let mut labels: Vec<&str> = schema.iter().map(|f| f.label).collect();
        labels.sort();
        let before = labels.len();
        labels.dedup();
        assert_eq!(before, labels.len(), "duplicate labels in GIT schema");
    }

    #[test]
    fn schema_sub_schema_field_counts() {
        let schema = Git::schema();

        let creature = schema
            .iter()
            .find(|f| f.label == "Creature List")
            .expect("schema must contain Creature List");
        assert_eq!(
            creature.children.expect("Creature List has children").len(),
            8
        );

        let item = schema
            .iter()
            .find(|f| f.label == "List")
            .expect("schema must contain List");
        assert_eq!(item.children.expect("List has children").len(), 8);

        let door = schema
            .iter()
            .find(|f| f.label == "Door List")
            .expect("schema must contain Door List");
        assert_eq!(door.children.expect("Door List has children").len(), 5);

        let placeable = schema
            .iter()
            .find(|f| f.label == "Placeable List")
            .expect("schema must contain Placeable List");
        assert_eq!(
            placeable
                .children
                .expect("Placeable List has children")
                .len(),
            6
        );

        let waypoint = schema
            .iter()
            .find(|f| f.label == "WaypointList")
            .expect("schema must contain WaypointList");
        assert_eq!(
            waypoint.children.expect("WaypointList has children").len(),
            4
        );

        let sound = schema
            .iter()
            .find(|f| f.label == "SoundList")
            .expect("schema must contain SoundList");
        assert_eq!(sound.children.expect("SoundList has children").len(), 6);

        let trigger = schema
            .iter()
            .find(|f| f.label == "TriggerList")
            .expect("schema must contain TriggerList");
        assert_eq!(
            trigger.children.expect("TriggerList has children").len(),
            10
        );

        let store = schema
            .iter()
            .find(|f| f.label == "StoreList")
            .expect("schema must contain StoreList");
        assert_eq!(store.children.expect("StoreList has children").len(), 8);

        let encounter = schema
            .iter()
            .find(|f| f.label == "Encounter List")
            .expect("schema must contain Encounter List");
        assert_eq!(
            encounter
                .children
                .expect("Encounter List has children")
                .len(),
            7
        );

        let area_effect = schema
            .iter()
            .find(|f| f.label == "AreaEffectList")
            .expect("schema must contain AreaEffectList");
        assert_eq!(
            area_effect
                .children
                .expect("AreaEffectList has children")
                .len(),
            7
        );

        let area_props = schema
            .iter()
            .find(|f| f.label == "AreaProperties")
            .expect("schema must contain AreaProperties");
        assert_eq!(
            area_props
                .children
                .expect("AreaProperties has children")
                .len(),
            17
        );

        let area_map = schema
            .iter()
            .find(|f| f.label == "AreaMap")
            .expect("schema must contain AreaMap");
        assert_eq!(area_map.children.expect("AreaMap has children").len(), 4);

        let camera = schema
            .iter()
            .find(|f| f.label == "CameraList")
            .expect("schema must contain CameraList");
        assert_eq!(camera.children.expect("CameraList has children").len(), 7);
    }

    #[test]
    fn schema_trigger_geometry_has_children() {
        let schema = Git::schema();
        let trigger = schema
            .iter()
            .find(|f| f.label == "TriggerList")
            .expect("schema must contain TriggerList");
        let trigger_children = trigger.children.expect("TriggerList has children");
        let geometry = trigger_children
            .iter()
            .find(|f| f.label == "Geometry")
            .expect("TriggerList must contain Geometry");
        assert_eq!(geometry.children.expect("Geometry has children").len(), 3);
    }

    #[test]
    fn schema_encounter_nested_lists_have_children() {
        let schema = Git::schema();
        let encounter = schema
            .iter()
            .find(|f| f.label == "Encounter List")
            .expect("schema must contain Encounter List");
        let encounter_children = encounter.children.expect("Encounter List has children");

        let geometry = encounter_children
            .iter()
            .find(|f| f.label == "Geometry")
            .expect("Encounter List must contain Geometry");
        assert_eq!(geometry.children.expect("Geometry has children").len(), 3);

        let spawn_points = encounter_children
            .iter()
            .find(|f| f.label == "SpawnPointList")
            .expect("Encounter List must contain SpawnPointList");
        assert_eq!(
            spawn_points
                .children
                .expect("SpawnPointList has children")
                .len(),
            4
        );
    }

    #[test]
    fn schema_var_table_has_no_children() {
        let schema = Git::schema();
        let var_table = schema
            .iter()
            .find(|f| f.label == "VarTable")
            .expect("schema must contain VarTable");
        assert!(var_table.children.is_none());
    }
}