gameobj.zig

//! `C:\lancer\game\gameobj.cpp`: the game's live objects, the ships, stations, gates, missiles and
//! markers of a running mission. `object_alloc` (`0x00475DD0`) allocates one.
//!
//! `create_object` (`0x00466C10`) fills a slot of `game_objects`, which it calls the GO array: 400
//! pointers to objects, a mission ship's slot being its index among the mission's ship records.
//! [`create.Objects`](create.zig) is OpenReliant's. Each object embeds the root of a hierarchy of
//! nodes, one for each part of its model.

const std = @import("std");
const assert = std.debug.assert;

const layout = @import("../../formats/layout.zig");
const dte = @import("../../formats/dte.zig");
const shp = @import("../../formats/shp.zig");
const math = @import("../surrender/math.zig");
const Vector = math.Vector;
const camera = @import("camera.zig");
const engine = @import("../../engine.zig");
const aigeneric = @import("aigeneric.zig");
const objects = @import("objects.zig");
const Node = objects.Node;
const Pointer = engine.Pointer;
const create = @import("create.zig");
const additions = @import("additions.zig");
const guns = @import("guns.zig");
const missiles = @import("missiles.zig");
const Random = @import("../random.zig").Random;
const motion = @import("motion.zig");
const input = @import("../input.zig");
const Clock = @import("main.zig").Clock;
const collision = @import("collision.zig");
const hooks = @import("../hooks.zig");

/// A slot of the object array as an object names one, or `none` for no slot, which the game holds
/// as -1.
pub const Slot = enum(i32) {
    none = -1,
    _,

    pub fn of(slot: u16) Slot {
        return @fromBackingInt(slot);
    }

    /// The slot `index` names, or none.
    pub fn from(found: ?u16) Slot {
        return if (found) |slot| of(slot) else .none;
    }

    /// The slot it names, or null for none.
    pub fn index(slot: Slot) ?u16 {
        return if (slot == .none) null else @intCast(@backingInt(slot));
    }
};

/// One of the positional voices (`hog_snd.Sound.voices3d`) as an object names the one following
/// it, or `none`, which the game holds as `0xFFFF`.
pub const Voice = enum(u16) {
    none = 0xFFFF,
    _,

    pub fn of(voice: u8) Voice {
        return @fromBackingInt(voice);
    }

    /// The voice it names, or null for none.
    pub fn index(voice: Voice) ?u8 {
        return if (voice == .none) null else @intCast(@backingInt(voice));
    }
};

test Voice {
    try std.testing.expectEqual(null, Voice.none.index());
    try std.testing.expectEqual(3, Voice.of(3).index());
}

/// Code that acts for the object in a slot: its `motion`, which moves it for one update, such as
/// `motion_forward` (`0x004744C0`), which flies it forward by the flight model, and the routines
/// of its orders.
pub const Routine = engine.Code("void __fastcall (int slot)");

/// Slots in `game_objects`. `create_object` stops the game with a fatal error past the last.
pub const max_objects = 400;

/// Whose side something is on: an object's (`GameObject.side`, four bytes) and a ship type's
/// (`create.ShipCombat.side`, two). The Alliance's types start friendly and the Coalition's
/// hostile; `SetHostile` makes an object one or the other. Two objects on different sides are
/// enemies.
pub fn Side(comptime Tag: type) type {
    return enum(Tag) {
        /// On the player's side.
        friendly = 0,
        hostile = 1,
        neutral = 2,
        _,
    };
}

/// How far harm reaches an object (`GameObject.invulnerable`). The first four are the values
/// `SetInvulnerability`'s catalogue entry lists; the game sets the last two itself. Any but `none`
/// keeps its armour whole (`collision.armorDamage`).
pub const Invulnerability = enum(u8) {
    none = 0,
    /// Only a player's ship can harm it: an ejected pilot, until it is picked up
    /// (`order_eject_spin`).
    player_can_hit = 1,
    /// Nothing harms it: what the Ripper has grabbed, and some types as they are created.
    full = 2,
    /// Its pilot ejects before it explodes.
    eject_before_exploding = 3,
    /// **Unknown.** Set as some types are created and as a deathmatch ship respawns. Shots pass its
    /// shields to the hull (`guns.bulletHit`).
    _unknown_4 = 4,
    /// **Unknown.** Its shields are emptied each step (`rechargeShields`), shots pass them to the
    /// hull, and a shield generator does not soften a component's hits.
    _unknown_5 = 5,
    _,

    /// Whether it keeps off a hit: always under `full`, and under `player_can_hit` where a player's
    /// ship did not deal it.
    pub fn protects(invulnerable: Invulnerability, by_player: bool) bool {
        return switch (invulnerable) {
            .full => true,
            .player_can_hit => !by_player,
            else => false,
        };
    }
};

test "Invulnerability.protects" {
    try std.testing.expect(Invulnerability.full.protects(true));
    try std.testing.expect(Invulnerability.player_can_hit.protects(false));
    try std.testing.expect(!Invulnerability.player_can_hit.protects(true));
    try std.testing.expect(!Invulnerability.none.protects(false));
}

/// A deathmatch power-up (`GameObject.power_up`): its record of 0x28 bytes in the table at
/// `0x0050C510`, which gives how long it lasts and the routines that start and end it. `0x004B1C00`
/// hands one out, by the weights at `0x005DB4C4` where none is named, and `0x004B18E0` ends it
/// once it runs out. **Unknown:** what most of them do.
pub const PowerUp = enum(i32) {
    none = -1,
    /// **Unknown.** In a multiplayer game, `0x00412820` and `0x00491520` act differently while the
    /// player holds it.
    _unknown_5 = 5,
    /// The player's throttle goes no higher than half (`player_controls`).
    half_throttle = 7,
    /// Its shields don't recharge (`rechargeShields`).
    no_shield_recharge = 8,
    /// The player's controls steer the other way round (`player_controls`).
    reversed_controls = 9,
    _,
};

/// A value for each quadrant of an object's shields or armour (`collision.Quadrant`), in the order
/// the game keeps them.
pub const Quadrants = extern struct {
    left: f32,
    right: f32,
    fore: f32,
    aft: f32,

    /// The same value in each.
    pub fn all(value: f32) Quadrants {
        return .{ .left = value, .right = value, .fore = value, .aft = value };
    }

    pub fn get(quadrants: Quadrants, quadrant: collision.Quadrant) f32 {
        return switch (quadrant) {
            inline else => |named| @field(quadrants, @tagName(named)),
        };
    }

    pub fn at(quadrants: *Quadrants, quadrant: collision.Quadrant) *f32 {
        return switch (quadrant) {
            inline else => |named| &@field(quadrants, @tagName(named)),
        };
    }

    /// Each, in the game's order.
    pub fn values(quadrants: Quadrants) [4]f32 {
        return .{ quadrants.left, quadrants.right, quadrants.fore, quadrants.aft };
    }

    /// The least of the four.
    pub fn weakest(quadrants: Quadrants) f32 {
        const each = quadrants.values();
        return @reduce(.Min, @as(@Vector(each.len, f32), each));
    }

    /// The four added together.
    pub fn total(quadrants: Quadrants) f32 {
        const each = quadrants.values();
        return @reduce(.Add, @as(@Vector(each.len, f32), each));
    }

    comptime {
        for (std.enums.values(collision.Quadrant), @typeInfo(Quadrants).@"struct".field_names) |quadrant, name| {
            assert(std.mem.eql(u8, @tagName(quadrant), name));
            assert(@offsetOf(Quadrants, name) == @as(usize, @backingInt(quadrant)) * @sizeOf(f32));
        }
        assert(@sizeOf(Quadrants) == 0x10);
    }
};

/// Components an object can list.
pub const max_components = 60;

/// A part of an object that events and scripts can name by its index in `GameObject.components`,
/// such as a capital ship's turret: a trigger's qualifier, a squad member's component.
pub const Component = extern struct {
    node: Pointer(Node),
    /// Where the node's parent lists it.
    slot: Pointer(Pointer(Node)),
    /// The invulnerability `SetInvulnerability` gives the component (`protects`); 0 for none.
    invulnerable: u16,
    _unknown_0a: u16,

    /// Whether its invulnerability keeps off a hit, as `component_damage` (`0x004645C0`) compares
    /// the halfword: 2 keeps off every hit, and 1 every hit a player's ship did not deal, as
    /// `Invulnerability.protects` reads an object's. Any other value keeps off none.
    pub fn protects(component: Component, by_player: bool) bool {
        return component.invulnerability().protects(by_player);
    }

    /// Its invulnerability, named as an object's is; `none` for a value too large for one.
    pub fn invulnerability(component: Component) Invulnerability {
        const invulnerable = std.math.cast(u8, component.invulnerable) orelse return .none;
        return @fromBackingInt(invulnerable);
    }

    comptime {
        assert(@sizeOf(Component) == 0x0C);
    }
};

/// Missile racks an object can carry: one for each of its missile hardpoints.
pub const max_racks = 20;

/// One of an object's missile racks (`GameObject + 0x158`): what a missile hardpoint of its model
/// holds, a pod of missiles or one missile hung on a rail, and how many are left.
pub const Rack = extern struct {
    type: missiles.Type,
    _unknown_02: u16 = 0,
    /// Where the node of the part that carries the hardpoint lists the hung pod or missile.
    slot: Pointer(Pointer(Node)) = .null,
    /// Missiles left: a pod's capacity, or 1 for a rail, when fitted; -1 once an empty pod is let
    /// fall.
    count: i32 = 0,

    comptime {
        assert(@sizeOf(Rack) == 0x0C);
    }
};

/// Flags for the multiplayer code about an object (`GameObject + 0x0C`).
pub const NetworkFlags = packed struct(u32) {
    /// Set by `object_move` when the object moves, and by code that places it. The multiplayer
    /// code (`0x004BB2D0`) then sends the object's position.
    moved: bool,
    /// Set by `object_move` when the object turns. The multiplayer code then sends its
    /// orientation.
    turned: bool,
    /// Set on a ship while it runs Scoop Up (`order_scoop_up_init`, cleared by
    /// `order_scoop_up_exit`), and on its pod as Scoop Up draws it in (`order_scoop_up`). The
    /// multiplayer code's round of updates (`0x004BBEF0`) skips the object.
    scooping: bool,
    _unknown_3: u29,
};

/// The wing a mission lists an object in, by its flight group (`mission.listPlayerWing`), which
/// the object keeps (`GameObject.wing`).
/// Whether a player's ship is to be sent home for its friendly fire (`GameObject.sent_home`,
/// `+0x678`), which `friendly_fire.sendHome` reads.
pub const SentHome = enum(i32) {
    none = 0,
    /// It destroyed a friend (`friendly_fire.friendDestroyed`).
    friend_destroyed = 1,
    /// In a multiplayer game, it destroyed a pilot's pod only a player could harm, which the
    /// other players are told of; its carrier aborts the mission.
    told = 2,
    /// **Unknown:** as `told`, which a multiplayer game's code sets; the mission's ending is then
    /// `main.Ending._unknown_7`.
    _unknown_3 = 3,
    _,
};

pub const Wing = enum(u16) {
    /// The player's: the wing status window shows its ships, and an AI pilot in it may eject.
    player = 0,
    /// Two more wings a mission can list. **Unknown:** what reads them.
    second = 1,
    third = 2,
    /// None, as the object is created.
    none = 0xFFFF,
    _,
};

/// The game's object types, by their numbers: for a ship, missile, mine or asteroid its record in
/// `shipstats.bin`, and past those what else the game places, markers and nav points among them,
/// which have no stats. Every type up to 255 has a name, from its record's name in `shipstats.bin`
/// where the game's code doesn't single it out. An object holds its type as a `Type`, whose `base`
/// is one of these.
pub const GameType = enum(u32) {
    predator = 0x00,
    naginata = 0x01,
    /// The Grendel, the Wolverine and the Reaper, whose guns fire rounds, which the gunnery display
    /// counts.
    grendel = 0x02,
    crusader = 0x03,
    coyote = 0x04,
    mirage = 0x05,
    tempest = 0x06,
    patriot = 0x07,
    wolverine = 0x08,
    reaper = 0x09,
    shroud = 0x0A,
    /// The Phoenix (`uspf_phx.shp`), which carries the Nova Cannon.
    phoenix = 0x0B,
    reliant = 0x0C,
    /// The Yamato (`yamato.shp`), the carrier that takes the place of the ship the player launched
    /// from once that ship explodes.
    yamato = 0x0D,
    alsace = 0x0E,
    kestrel = 0x0F,
    falco = 0x10,
    /// The Victorious (`victorious.shp`), and the carriers after it whose ships launch from a bay
    /// as its do: the Endeavour, the Mitchell and the Bremen.
    victorious = 0x11,
    endeavour = 0x12,
    mitchell = 0x13,
    bremen = 0x14,
    arc_ship = 0x15,
    /// The Ulysses (`ulysses.shp`), whose escape pods launch even as it is lost.
    ulysses = 0x16,
    sai = 0x17,
    /// The Nanny (`nanny.shp`).
    nanny = 0x18,
    galahad = 0x19,
    hades = 0x1A,
    mule = 0x1B,
    lonestar = 0x1C,
    /// The limpet car (`limpet_t_car.shp`).
    limpet_car = 0x1D,
    /// The Prowler (`us_prowler.shp`).
    prowler = 0x1E,
    /// The Ripper (`ripper_2.shp`), which carries cargo pods in its beams
    /// ([`airipper.zig`](airipper.zig)).
    ripper = 0x1F,
    lueneburg = 0x20,
    /// The Mammoth (`a_mammoth.shp`), a freighter the Ripper loads with cargo pods.
    mammoth = 0x21,
    intruder = 0x22,
    sentry = 0x23,
    goodwill = 0x24,
    /// The Stork (`stork.shp`).
    stork = 0x25,
    sky_hawk = 0x26,
    haidar = 0x27,
    karak = 0x28,
    salin = 0x29,
    azan = 0x2A,
    sabre = 0x2B,
    lagg = 0x2C,
    kamov = 0x2D,
    saracen = 0x2E,
    salamander = 0x2F,
    scimitar = 0x30,
    basilisk = 0x31,
    kossac = 0x32,
    yao = 0x33,
    /// The Ramases (`ramases.shp`).
    ramases = 0x34,
    kozlov = 0x35,
    morzov = 0x36,
    /// The Badanov (`cs_badanov.shp`), the smallest of the Coalition's capital ships.
    badanov = 0x37,
    /// The Pukov (`pukov.shp`).
    pukov = 0x38,
    xia = 0x39,
    riza = 0x3A,
    cyclops = 0x3B,
    /// The Kurgan (`rus_kurgan.shp`).
    kurgan = 0x3C,
    /// The Sharov (`sharov.shp`).
    sharov = 0x3D,
    /// The Gurevich (`rmc_gurevich.shp`).
    gurevich = 0x3E,
    berijev = 0x3F,
    kirov = 0x40,
    loki = 0x41,
    kalan_shuttle = 0x42,
    /// Capital ships (`saladin.shp`, `stalag.shp`, `antanov.shp`, `kronstadt.shp`, `boridin.shp`).
    saladin = 0x43,
    /// The Dark Reign (`darkreign.shp`).
    darkreign = 0x44,
    stalag = 0x45,
    antanov = 0x46,
    kronstadt = 0x47,
    boridin = 0x48,
    /// The Russian troop car (`rus_troopcar.shp`).
    troop_car = 0x49,
    torpedo = 0x4A,
    /// The Ulysses' back (`ulysses2.shp`), which it throws off as its top goes
    /// (`explode/ulysses.zig`).
    ulysses_back = 0x4B,
    /// The Ulysses' fin (`ulysses3.shp`), which it throws off as its fin or its top goes.
    ulysses_fin = 0x4C,
    /// An escape pod (`uly_escape.shp`).
    escape_pod = 0x4D,
    /// The first of ten pieces of debris an explosion throws out (`deb_1.shp` to `deb_10.shp`).
    debris = 0x4E,
    debris_1 = 0x4F,
    debris_2 = 0x50,
    debris_3 = 0x51,
    debris_4 = 0x52,
    debris_5 = 0x53,
    debris_6 = 0x54,
    debris_7 = 0x55,
    debris_8 = 0x56,
    debris_9 = 0x57,
    /// The first of four bodies an explosion throws out (`rus_man1.shp` to `rus_man4.shp`).
    crewman = 0x58,
    crewman_1 = 0x59,
    crewman_2 = 0x5A,
    crewman_3 = 0x5B,
    /// The Russian torpedo (`rus_torp.shp`).
    russian_torpedo = 0x5C,
    mammoth_back = 0x5D,
    baxter = 0x5E,
    /// The planets with an atmosphere (`create.atmosphere`): Neptune (`neptune_hi_1.shp`), Uranus
    /// (`uranus_hi_1.shp`), Jupiter (`jupiter_hi_1.shp`) and Venus (`venus1_hi_1.shp`), and their
    /// models of less detail below.
    neptune_hi = 0x5F,
    triton_hi = 0x60,
    uranus_hi = 0x61,
    saturn_hi = 0x62,
    titan_hi = 0x63,
    jupiter_hi = 0x64,
    europa_hi = 0x65,
    ganymede_hi = 0x66,
    io_hi = 0x67,
    calisto_hi = 0x68,
    venus_hi = 0x69,
    earth = 0x6A,
    kronstadt_wreck = 0x6B,
    planet_placeholder_4 = 0x6C,
    /// The Coalition's gates: the prototype (`coalprotogate.shp`) and the advanced one
    /// (`coaladvgate.shp`).
    proto_gate = 0x6D,
    advanced_gate = 0x6E,
    /// The proximity mine (`mine_prox.shp`).
    proximity_mine = 0x6F,
    /// A black box (`black_box.shp`).
    black_box = 0x70,
    satellite = 0x71,
    /// The wrecks a capital ship leaves as it splits (`explode.split`), which burn
    /// (`create.wreckMade`): the Mammoth's front and back (`mamdest.shp`, `mamdest2.shp`), the
    /// Badanov's back and front (`cs_baddead.shp`, `cs_baddead2.shp`), and the Kurgan's
    /// (`rus_kurgan_dest.shp`).
    mammoth_wreck_front = 0x72,
    mammoth_wreck_back = 0x73,
    proto_gate_panel = 0x74,
    badanov_wreck_back = 0x75,
    badanov_wreck_front = 0x76,
    kurgan_wreck = 0x77,
    /// The Krasnaya (`krasnaya.shp`).
    krasnaya = 0x78,
    asteroid_1 = 0x79,
    asteroid_2 = 0x7A,
    asteroid_3 = 0x7B,
    asteroid_4 = 0x7C,
    asteroid_5 = 0x7D,
    asteroid_6 = 0x7E,
    asteroid_7 = 0x7F,
    research_station = 0x80,
    /// The Latov (`latov.shp`).
    latov = 0x81,
    gurevich_wreck_back = 0x82,
    training_hoop = 0x83,
    /// The Czar, docked (`czar_docked.shp`).
    czar_docked = 0x84,
    turret_asteroid_1 = 0x85,
    turret_asteroid_2 = 0x86,
    turret_asteroid_3 = 0x87,
    turret_asteroid_4 = 0x88,
    turret_asteroid_5 = 0x89,
    turret_asteroid_6 = 0x8A,
    turret_asteroid_7 = 0x8B,
    powerup_random = 0x8C,
    dm_beacon_gate = 0x8D,
    /// A deathmatch beacon (`DMBeacon.shp`).
    dm_beacon = 0x8E,
    pukov_wreck_back = 0x8F,
    /// Another escape pod (`ber_escape.shp`).
    other_escape_pod = 0x90,
    /// A cargo pod (`us_cargo.shp`), which the Ripper carries.
    cargo_pod = 0x91,
    other_cargo_pod = 0x92,
    grazer_gun_sat = 0x93,
    archer_missile_sat = 0x94,
    /// The Kafelnikof (`kafelnikof.shp`).
    kafelnikof = 0x95,
    reliant_wreck_back = 0x96,
    stalag_doors = 0x97,
    stalag_duct_cover = 0x98,
    /// The Yakob Shuttle, a support ship, which the StarLancer trial's executable makes a fighter
    /// for its pirates.
    yakob_shuttle = 0x99,
    /// The Krasny (`krasny.shp`), whose ships launch as the Badanov's do.
    krasny = 0x9A,
    /// The Varyag (`varyag.shp`), and a second Ramases and Mitchell, of the same models.
    varyag = 0x9B,
    other_ramases = 0x9C,
    fort_carter = 0x9D,
    koenig = 0x9E,
    washington = 0x9F,
    other_mitchell = 0xA0,
    ufelsky = 0xA1,
    kresta = 0xA2,
    krasnaya_left_arm = 0xA3,
    krasnaya_right_arm = 0xA4,
    /// The rogue base (`rogue_base.shp`).
    rogue_base = 0xA5,
    kronstadt_arm = 0xA6,
    boridin_gun_dome = 0xA7,
    /// The part of the Boridin that breaks away (`boridin breakaway.shp`).
    boridin_breakaway = 0xA8,
    darkreign_wreck_hat = 0xA9,
    yamato_wreck_back = 0xAA,
    maintenance_droid = 0xAB,
    maintenance_astronaut = 0xAC,
    rogue_base_wreck_top = 0xAD,
    tank = 0xAE,
    training_target = 0xAF,
    /// The Zakov (`zakov.shp`).
    zakov = 0xB0,
    /// The Turret Flak's shell (`shell.shp`).
    shell = 0xB1,
    /// The first of five chunks of rock (`rockchunk00.SHP` to `rockchunk04.SHP`).
    rock_chunk = 0xB2,
    rock_chunk_tiny_1 = 0xB3,
    rock_chunk_tiny_2 = 0xB4,
    rock_chunk_tiny_3 = 0xB5,
    rock_chunk_tiny_4 = 0xB6,
    latov_wreck_1 = 0xB7,
    latov_wreck_2 = 0xB8,
    czar = 0xB9,
    zakov_wreck_back = 0xBA,
    sharov_wreck_back = 0xBB,
    /// The limpet pod, which rides on a hull.
    limpet_pod = 0xBC,
    stalag_wreck_1 = 0xBD,
    stalag_wreck_2 = 0xBE,
    saladin_wreck = 0xBF,
    gegarin = 0xC0,
    krelov = 0xC1,
    /// The Kiev (`kiev.shp`).
    kiev = 0xC2,
    kiev_wreck_back = 0xC3,
    baxter_wreck_top = 0xC4,
    victorious_wreck_front = 0xC5,
    mitchell_wreck_back = 0xC6,
    fort_bear = 0xC7,
    fort_sherman = 0xC8,
    /// The planets with an atmosphere in less detail: `neptune_lo_1.shp`, `uranus_lo_1.shp`,
    /// `jupiter_lo_1.shp` and `venus1_lo_1.shp`.
    neptune_lo = 0xC9,
    triton_lo = 0xCA,
    uranus_lo = 0xCB,
    saturn_lo = 0xCC,
    titan_lo = 0xCD,
    jupiter_lo = 0xCE,
    europa_lo = 0xCF,
    ganymede_lo = 0xD0,
    io_lo = 0xD1,
    calisto_lo = 0xD2,
    venus_lo = 0xD3,
    /// The Yamato's launch tube (`yam_tube.shp`), shown as the player's hangar (`0x00419544`).
    yamato_hangar = 0xD4,
    /// The Yamato's landing bay (`yamhanger.shp`), the cutaway the Yamato's landing shows the
    /// player's ship come down in (`land_yamato_init`, `0x0040EB60`).
    yamato_landing_bay = 0xD5,
    /// The Reliant's hangar (`reliant_hang.shp`): the cutaway the Reliant's launch shows the
    /// player's ship in.
    reliant_hangar = 0xD6,
    /// A comms relay (`comms relay.shp`).
    comms_relay = 0xD7,
    saladin_link = 0xD8,
    varyag_wreck_front = 0xD9,
    churchill = 0xDA,
    bokov = 0xDB,
    bulatov = 0xDC,
    shinnik = 0xDD,
    kovtun = 0xDE,
    /// Escape pods again, of the same models as `escape_pod` and `other_escape_pod`.
    late_escape_pod = 0xDF,
    other_late_escape_pod = 0xE0,
    /// A fuel pod (`fuel_pod1.shp`), which a jump that clears its way marks jumping wherever it is
    /// (`jump.markJumping`).
    fuel_pod = 0xE1,
    yevstafiy = 0xE2,
    mammoth_gulliver = 0xE3,
    mammoth_santa_maria = 0xE4,
    mammoth_rosario = 0xE5,
    mammoth_larsons_pride = 0xE6,
    mammoth_brittania = 0xE7,
    mammoth_sierra_madre = 0xE8,
    mammoth_mayan_gold = 0xE9,
    mammoth_dawn_chorus = 0xEA,
    mammoth_calysto = 0xEB,
    mammoth_sundown = 0xEC,
    mammoth_krenna = 0xED,
    mammoth_seabound = 0xEE,
    mammoth_crimson_sky = 0xEF,
    asteroid_with_hole_1 = 0xF0,
    asteroid_with_hole_2 = 0xF1,
    asteroid_with_hole_3 = 0xF2,
    asteroid_with_hole_4 = 0xF3,
    /// The second set of the player's ships, the same twelve with the `t_` twins of their models
    /// (`player_twins_first`).
    t_predator = 0xF4,
    t_naginata = 0xF5,
    t_grendel = 0xF6,
    t_crusader = 0xF7,
    t_coyote = 0xF8,
    t_mirage = 0xF9,
    t_tempest = 0xFA,
    t_patriot = 0xFB,
    t_wolverine = 0xFC,
    t_reaper = 0xFD,
    t_shroud = 0xFE,
    /// A second Phoenix (`t_uspf_phx.shp`), the last type of the table.
    t_phoenix = 0xFF,
    /// The markers `backdrop_place` reads a mission's sun and nebula from.
    sun_marker = 0x3DC,
    nebula_marker = 0x3DD,
    /// The deathmatch maps' markers, named after the objects their designers placed: the arena's
    /// centre (`dm_sphere_centre`), the objects named `beacon1` to `beacon6`, beside the beacons
    /// themselves (`dm_beacon`), the players' spawn points and the power-ups'. The game singles out
    /// the players' spawn points alone, which `multiplayer_list_spawns` (`0x004AF5C0`) lists as a
    /// multiplayer game starts; it sizes the arena round every object (`arena_frame`).
    dm_sphere_centre = 0x3DF,
    beacon_marker = 0x3E0,
    spawn_player = 0x3E1,
    spawn_powerup = 0x3E2,
    /// What `mission_ship_create` makes of a mission's nav points and markers, and the mission's
    /// start of the camera's marker.
    marker = 1000,
    /// What a slot holds until `create_object` fills it, and what a destroyed object becomes.
    stand_in = 1001,
    _,

    /// What is made of rock: the asteroids, `ast_1.shp` to `ast_7.shp`; the turret asteroids,
    /// `turast_1.shp` to `turast_7.shp`; and the holes, `ast_hole1.shp` to `ast_hole4.shp`.
    pub const Rock = enum { asteroid, turret, hole };
    const rocks: std.EnumArray(Rock, [2]GameType) = .init(.{
        .asteroid = .{ .asteroid_1, .asteroid_7 },
        .turret = .{ .turret_asteroid_1, .turret_asteroid_7 },
        .hole = .{ .asteroid_with_hole_1, .asteroid_with_hole_4 },
    });

    comptime {
        // The numbers are the game's own, so the models they stand for say which types they are.
        const models = [_]struct { GameType, []const u8 }{
            .{ .predator, "uslf_prd.shp" },
            .{ .phoenix, "uspf_phx.shp" },
            .{ .t_phoenix, "t_uspf_phx.shp" },
            .{ .reliant, "reliant.shp" },
            .{ .nanny, "nanny.shp" },
            .{ .victorious, "victorious.shp" },
            .{ .darkreign, "darkreign.shp" },
            .{ .mammoth_wreck_front, "mamdest.shp" },
            .{ .mammoth_wreck_back, "mamdest2.shp" },
            .{ .badanov_wreck_back, "cs_baddead.shp" },
            .{ .badanov_wreck_front, "cs_baddead2.shp" },
            .{ .kurgan_wreck, "rus_kurgan_dest.shp" },
            .{ .latov, "latov.shp" },
            .{ .czar_docked, "czar_docked.shp" },
            .{ .kafelnikof, "kafelnikof.shp" },
            .{ .prowler, "us_prowler.shp" },
            .{ .stalag, "stalag.shp" },
            .{ .antanov, "antanov.shp" },
            .{ .limpet_car, "limpet_t_car.shp" },
            .{ .ripper, "ripper_2.shp" },
            .{ .mammoth, "a_mammoth.shp" },
            .{ .sharov, "sharov.shp" },
            .{ .cargo_pod, "us_cargo.shp" },
            .{ .sabre, "rus_sabre.shp" },
            .{ .kamov, "rus_kamov.shp" },
            .{ .scimitar, "scimitar.shp" },
            .{ .badanov, "cs_badanov.shp" },
            .{ .kurgan, "rus_kurgan.shp" },
            .{ .gurevich, "rmc_gurevich.shp" },
            .{ .troop_car, "rus_troopcar.shp" },
            .{ .saladin, "saladin.shp" },
            .{ .kronstadt, "kronstadt.shp" },
            .{ .boridin, "boridin.shp" },
            .{ .proto_gate, "coalprotogate.shp" },
            .{ .advanced_gate, "coaladvgate.shp" },
            .{ .boridin_breakaway, "boridin breakaway.shp" },
            .{ .torpedo, "torpedo.shp" },
            .{ .russian_torpedo, "rus_torp.shp" },
            .{ .proximity_mine, "mine_prox.shp" },
            .{ .black_box, "black_box.shp" },
            .{ .dm_beacon, "DMBeacon.shp" },
            .{ .comms_relay, "comms relay.shp" },
            .{ .satellite, "stork_sat.shp" },
            .{ .escape_pod, "uly_escape.shp" },
            .{ .other_escape_pod, "ber_escape.shp" },
            .{ .late_escape_pod, "uly_escape.shp" },
            .{ .other_late_escape_pod, "ber_escape.shp" },
            .{ .debris, "deb_1.shp" },
            .{ .debris_9, "deb_10.shp" },
            .{ .crewman, "rus_man1.shp" },
            .{ .crewman_3, "rus_man4.shp" },
            .{ .rock_chunk, "rockchunk00.SHP" },
            .{ .rock_chunk_tiny_4, "rockchunk04.SHP" },
            .{ .shell, "shell.shp" },
            .{ .limpet_pod, "limpet_pod.shp" },
            .{ .asteroid_1, "ast_1.shp" },
            .{ .asteroid_7, "ast_7.shp" },
            .{ .turret_asteroid_1, "turast_1.shp" },
            .{ .turret_asteroid_7, "turast_7.shp" },
            .{ .asteroid_with_hole_1, "ast_hole1.shp" },
            .{ .asteroid_with_hole_4, "ast_hole4.shp" },
        };
        for (models) |named| assert(std.mem.eql(u8, create.models.ship_types[named[0].number()].model.?, named[1]));
    }

    pub fn number(object_type: GameType) u32 {
        return @backingInt(object_type);
    }

    /// Where the second set of the player's ship types starts: the types from `t_predator` to
    /// `t_phoenix`, whose models are the first twelve's `t_` twins, are the same twelve ships.
    pub const player_twins_first = GameType.t_predator.number();

    /// The type it stands for among the player's ships: one of the second set, from
    /// `player_twins_first`, stands for the first set's in the same place, and any other for itself.
    pub fn untwinned(object_type: GameType) GameType {
        const at = object_type.number();
        return @fromBackingInt(if (at >= player_twins_first) at - player_twins_first else at);
    }

    /// How many of the player's ship types have twins: the first twelve, from 0.
    pub const player_twins = 0x100 - player_twins_first;

    /// Whether the player can fly a ship of this type, a twin as the ship it twins: one of the
    /// first twelve, the Predator to the Phoenix, which the start fits a cockpit to
    /// (`main.player_ships`).
    pub fn playerFlies(object_type: GameType) bool {
        return object_type.untwinned().number() < player_twins;
    }

    /// Its twin among the second set of the player's ship types, for one of the first set's; null
    /// for any other.
    pub fn twin(object_type: GameType) ?GameType {
        const at = object_type.number();
        return if (at < player_twins) @fromBackingInt(at + player_twins_first) else null;
    }

    /// Whether it is a Phoenix, the ship that carries the Nova Cannon, or its twin.
    pub fn carriesNova(object_type: GameType) bool {
        return object_type == .phoenix or object_type == .t_phoenix;
    }

    /// What rock it is, if any.
    pub fn rock(object_type: GameType) ?Rock {
        const n = object_type.number();
        for (std.enums.values(Rock)) |kind| {
            const range = rocks.get(kind);
            if (n >= range[0].number() and n <= range[1].number()) return kind;
        }
        return null;
    }

    pub fn isAsteroid(object_type: GameType) bool {
        return object_type.rock() == .asteroid;
    }

    /// Whether it is one of the torpedoes, the Allies' or the Russians', by type (a ship's combat
    /// class may also be `.torpedo`).
    pub fn isTorpedo(object_type: GameType) bool {
        return switch (object_type) {
            .torpedo, .russian_torpedo => true,
            else => false,
        };
    }

    /// Asteroid `n`, from `ast_1.shp`, round and round the seven.
    pub fn asteroid(n: usize) GameType {
        const range = rocks.get(.asteroid);
        const first = range[0].number();
        return @fromBackingInt(@intCast(first + n % (range[1].number() - first + 1)));
    }

    /// The child of the root the AI aims at on an object of this type, where it aims at a part
    /// rather than the whole (`0x004018F0`): the Saladin's and the troop car's twenty-first, the
    /// Kronstadt's eighteenth, the Boridin's twentieth.
    pub fn aimedChild(object_type: GameType) ?usize {
        return switch (object_type) {
            .saladin, .troop_car => 0x14,
            .kronstadt => 0x11,
            .boridin => 0x13,
            else => null,
        };
    }

    pub fn format(object_type: GameType, writer: *std.Io.Writer) std.Io.Writer.Error!void {
        return layout.formatTagAs(GameType, object_type, "type", writer);
    }
};

/// An object's type by its number (`GameObject.type`): one of the game's (`GameType`), or one a mod
/// adds past them (`additions.ships`). The code that singles out a type asks for its base (`base`), so
/// that a type a mod adds acts as the game's type it is based on.
pub const Type = enum(u32) {
    /// The name scripts know these values by, and the names they know: the game's types', and the
    /// qualified names of the types the mods add (`scriptName`).
    pub const script_name = "ShipType";
    pub const Named = GameType;

    _,

    /// The game's type `game`.
    pub fn of(game: GameType) Type {
        return @fromBackingInt(@backingInt(game));
    }

    /// The game's type it acts as: itself for one of the game's, and for one a mod adds, the type
    /// it is based on.
    pub fn base(object_type: Type) GameType {
        const from_mod = additions.ships.get(object_type.number()) orelse return @fromBackingInt(object_type.number());
        return from_mod.base;
    }

    /// The type a mod adds that it is, if it is one.
    pub fn added(object_type: Type) ?*const additions.ships.Added {
        return additions.ships.get(object_type.number());
    }

    /// The game's type it is; null for one a mod adds.
    pub fn gameType(object_type: Type) ?GameType {
        if (object_type.added() != null) return null;
        return @fromBackingInt(object_type.number());
    }

    pub fn number(object_type: Type) u32 {
        return @backingInt(object_type);
    }

    /// Whether it has a record in the ship tables: one of the game's 256, or one a mod adds.
    pub fn hasStats(object_type: Type) bool {
        return object_type.number() < create.ship_type_count or object_type.added() != null;
    }

    /// The type it stands for among the player's ships (`GameType.untwinned`); a type a mod adds
    /// stands for itself.
    pub fn untwinned(object_type: Type) Type {
        if (object_type.added() != null) return object_type;
        return .of(object_type.base().untwinned());
    }

    /// Its twin among the second set of the player's ship types (`GameType.twin`); a type a mod adds
    /// has none.
    pub fn twin(object_type: Type) ?Type {
        if (object_type.added() != null) return null;
        return .of(object_type.base().twin() orelse return null);
    }

    /// Asteroid `n` (`GameType.asteroid`).
    pub fn asteroid(n: usize) Type {
        return .of(GameType.asteroid(n));
    }

    /// The name scripts know it by, if it has one: its qualified name for a type a mod adds.
    pub fn scriptName(object_type: Type) ?[]const u8 {
        if (object_type.added()) |from_mod| return from_mod.name;
        return layout.tagName(GameType, object_type.base());
    }

    /// The type scripts name `text`, if there is one.
    pub fn fromScriptName(text: []const u8) ?Type {
        if (additions.ships.find(text)) |found| return @fromBackingInt(found);
        return .of(std.meta.stringToEnum(GameType, text) orelse return null);
    }

    pub fn format(object_type: Type, writer: *std.Io.Writer) std.Io.Writer.Error!void {
        if (object_type.added()) |from_mod| return writer.writeAll(from_mod.name);
        return object_type.base().format(writer);
    }
};

/// A list of objects the avoidance code steers round (`avoidance_scan`), `max_avoided` at most.
pub const Avoided = extern struct {
    count: i32,
    slots: [max_avoided]i32,

    pub fn list(avoided: *const Avoided) []const i32 {
        return avoided.slots[0..@intCast(std.math.clamp(avoided.count, 0, max_avoided))];
    }

    /// Adds `slot`, where there is room.
    pub fn add(avoided: *Avoided, slot: u16) void {
        if (avoided.count >= max_avoided) return;
        avoided.slots[@intCast(avoided.count)] = slot;
        avoided.count += 1;
    }

    comptime {
        assert(@sizeOf(Avoided) == 0x2C);
    }
};

pub const max_avoided = 10;

/// A live object (`gameobj.cpp`), allocated at `0x00475DD0`.
pub const GameObject = extern struct {
    type: Type,
    /// Its slot in `game_objects`.
    index: u32,
    flags: Flags,
    network: NetworkFlags,
    combat: Pointer(create.ShipCombat),
    flight: Pointer(create.FlightModel),
    /// The type's model, as loaded.
    model: Pointer(anyopaque),
    /// Data kept for the ship type and shared by its objects.
    type_data: Pointer(anyopaque),
    /// The renderer's object for it, or null.
    render: Pointer(anyopaque),
    /// The shape the wing status window shows it by, which the mission's start gives each ship of
    /// the player's wing by its type (`main.startWing`); 0 for none, as created (`wingIcon`).
    wing_icon: u16,
    _unknown_26: u16,
    /// The root of its model hierarchy.
    root: Node,
    /// **Unknown.** 1.0 when created; the collision sweep multiplies `radius` by it.
    /// How far off it stays worth drawing, over the distance its radius alone would give it
    /// (`node_draw`). `object_alloc` and `create_object` both leave it at 1, so nothing in the
    /// shipped game sees further or less far than its size says.
    visibility: f32,
    /// Its guns: `gun_count` records of 0x60 bytes at `guns`, which `create_object` walks to set up
    /// the gun groups (#131).
    gun_count: i16,
    _unknown_132: u16,
    guns: Pointer(anyopaque),
    /// The count each gun keeps of the steps it has been firing (`guns.Fitted.sounded`), which
    /// the game allocates with the guns, one word each.
    _unknown_138: u32,
    /// The rounds its guns have left: `ShipCombat.rounds` when created, one for each shot of a gun
    /// of kind `rounds` (`guns.step`). The gunnery window shows them.
    rounds: i32,
    /// The guns' charge: `ShipCombat.gun_energy` when created, which the guns recharge to
    /// (`0x00477114`). The display's right arc shows it against that.
    gun_charge: f32,
    /// How its guns fire, which the gun keys set.
    gun_mode: GunMode,
    _unknown_146: u16,
    /// How far a gun that charges up before it fires has charged, from 0 to 1, which scales its
    /// damage. Only gun type 11, the Nova Cannon, uses it. Its guns' charge does not recharge
    /// while it is not zero (`guns.step`).
    nova_charge: f32,
    /// Which side of a gun group fires next, 0 or 1, while the ship fires one group out of step
    /// (`guns.step`).
    gun_turn: guns.GroupSide,
    /// Its missile racks, `rack_count` of them, which `create_object` fits from its missile
    /// hardpoints and each launch takes from.
    rack_count: i16,
    component_count: i16,
    /// For an object that lists components, how many part nodes it has, its model's and those of
    /// the models mounted on it (`object_number_parts`).
    part_count: i16,
    _unknown_156: [2]u8,
    racks: [max_racks]Rack,
    /// The parts of its model whose flags mark them as components, in the order `0x00468760`
    /// finds them: each node's marked children, then each child's in turn.
    components: [max_components]Component,
    /// For an object that lists components, its part nodes by their numbers
    /// (`object_number_parts`), which a shot's candidates name its parts by; null for any other.
    part_nodes: Pointer(Pointer(objects.Node)),
    /// How many knocks, from collisions and explosions, the object has taken since its last move
    /// (`knock`). The next `object_move` applies them in place of the object's own motion
    /// (`applyKnocks`).
    knocks: u32,
    /// The sum of its parts' masses (`object_recentre`).
    mass: f32,
    /// How far `object_recentre` moved the object's origin to its centre of mass
    /// (`objects.Model.centre`).
    centre: shp.Vec3,
    /// The sum of the forces of the knocks since the last move.
    impulse: shp.Vec3,
    /// The sum of each knock's force × lever, in world coordinates: the opposite of the torque.
    angular_impulse: shp.Vec3,
    /// The inverse of the object's inertia tensor, which `object_recentre` builds from its parts
    /// (`object_bounds`) and inverts (`0x004AD9F0`). `applyKnocks` turns the angular impulse by it.
    angular_response: [9]f32,
    /// The turn applied to its orientation each update, which `object_steer` builds from the
    /// angular rates.
    rotation: [9]f32,
    /// Added to its position each update.
    velocity: shp.Vec3,
    /// The radius of the sphere collisions test it by.
    radius: f32,
    /// **Unverified:** the corners of its model's bounding box, which `object_recentre`
    /// (`0x004769F0`) accumulates.
    bounds_min: shp.Vec3,
    bounds_max: shp.Vec3,
    /// Up to 1 in flight, 2 while `afterburner` is set, and -1 while `reverse_thrust` is.
    throttle: f32,
    /// Steering inputs, each between -1 and 1.
    roll_input: f32,
    pitch_input: f32,
    yaw_input: f32,
    /// Pushes it sideways: its lateral speed follows a quarter of its cruise speed times this.
    lateral_input: f32,
    /// Set while the afterburner burns, 4 units of `afterburner_fuel` an update.
    afterburner: bool,
    /// Set while reverse thrust burns: the throttle is -1, and it uses afterburner fuel.
    reverse_thrust: bool,
    _unknown_5ce: u16,
    /// Engines in its model: parts of subsystem class 5.
    engines: u32,
    /// The share of its engines left: 1.0 when created, less `1 / engines` for each one destroyed.
    engines_intact: f32,
    /// The length of `velocity`.
    speed: f32,
    /// Angular rates, which `object_steer` moves toward the inputs.
    roll_rate: f32,
    pitch_rate: f32,
    yaw_rate: f32,
    /// In hundredths of a second: `100 * ShipCombat.afterburner_fuel` when created, or zero in one
    /// of the game's modes.
    afterburner_fuel: i32,
    /// Countermeasures left, which the display shows under its coil. 29 when the object is created
    /// (`create_object`, `object_alloc`), and `object_spend_countermeasure` (`0x00462550`) takes
    /// one at a time; with none left, the player's COUNTERMEASURES key gets only the display's
    /// sound 3.
    countermeasures: u16,
    _unknown_5ee: u16,
    /// Each `6 * ShipCombat.shield_power - 1` when created.
    shields: Quadrants,
    /// Each `6 * ShipCombat.armor_class - 1` when created. `ship_damage_value` reports the lowest.
    armor: Quadrants,
    /// What the explosions' routines note of it as it comes apart.
    ends: Ends,
    /// The routine in `explode.cpp` that `create_object` gives most capital ships, bases and
    /// stations, which `node_draw` runs as one of the object's components is destroyed. OpenReliant
    /// leaves it null and picks the routine by type as it needs it (`explode.ComponentLoss`).
    component_loss: Pointer(Routine),
    /// The slots of two objects it passes through: the collision sweep of `objects_update` tests
    /// no pair where either names the other. Both are `none` when created.
    passes_through: [2]Slot,
    /// The slot of the ship Fight has it attack: Fight sets it as it starts (`order_fight_init`),
    /// an attack run leaves it clear until it is done, and a new order clears it. None when created.
    fighting: Slot,
    _unknown_624: u8,
    _unknown_625: [3]u8,
    _unknown_628: shp.Vec3,
    /// Where its lights stand in their blinks, in ticks added to the mission's clock
    /// (`node_draw`): from 0 to 100 at random when allocated (`blinkOffset`), so that ships of one
    /// type don't blink together.
    blink_offset: i16,
    _unknown_636: u16,
    /// The seed of its own random numbers (`object_random`): C's `rand()` when created.
    random_seed: u32,
    /// Its cloak's state, 0x2C bytes that `object_cloak` allocates; null until then.
    cloak: Pointer(anyopaque),
    /// Moves it each update; `motion_forward` when created.
    motion: Pointer(Routine),
    /// Its side: its type's (`ShipCombat.side`) when created, save for other players' ships in a
    /// multiplayer game, and hostile or friendly once `SetHostile` says.
    side: Side(i32),
    /// The loadout tier a re-arm fits its racks by (`order_dock`, `cmd_ReplenishWeapons`).
    /// **Unverified:** nothing writes it, so it holds what the allocator leaves.
    loadout_tier: u32,
    /// Nonzero while a missile homes on it, which lights the display's missile warning.
    /// `mission_frame` zeroes it on every object each frame, and `missiles_update` (`0x004960F0`)
    /// then sets it on the object each live missile's order targets. **Unverified:** the
    /// conditions it sets it under, which are not all read.
    missile_homing: i32,
    /// The throttle of the last update.
    last_throttle: f32,
    /// Until when a shockwave that harms what it passes leaves it alone, having harmed it
    /// (`shockwave.Shockwave.harmPlayer`).
    shockwave_until: i32,
    /// Its smoke's template, which its level picks (`0x00494400`), and its smoke's emitter, or
    /// null for none. OpenReliant keeps its smoke in its slot (`create.Slot.smoke`).
    smoke_template: Pointer(@import("particles.zig").Template),
    smoke: Pointer(anyopaque),
    /// How damaged it shows itself to be, by its smoke (`smoke.Level.of`).
    smoke_level: @import("main/smoke.zig").Level,
    _unknown_661: [3]u8,
    /// How well its shields recharge as its armour wears: a quarter of each quadrant's armour over
    /// its full armour, added up (`armorConditions`). 1 when created. The damage display's shield
    /// bar shows it.
    shield_condition: f32,
    /// Scales the cruise speed as its armor falls, which `object_cruise_speed` applies unless the
    /// camera is in view 13 or the object is invulnerable: a quarter, and three quarters of the
    /// aft quadrant's armour over its full armour (`armorConditions`). 1 when created.
    armor_speed_factor: f32,
    /// How well its guns work as its armour wears: half the fore quadrant's armour over its full
    /// armour, and a quarter of each side's (`armorConditions`). 1 when created. The guns
    /// recharge by it, and below 0.9 each shot goes off only as often as it plus a tenth
    /// (`0x004770E0`).
    gun_condition: f32,
    /// The gun type its spectral shields are tuned to, which turning them on sets
    /// (`player_spectral_shields_set`): the one most dangerous near it.
    spectral_gun_type: i32,
    /// Nonzero while blind fire aims the guns at the target: `hud_draw` sets it each frame it
    /// draws the reticle.
    blind_fire_aim: i32,
    /// Whether it is to be sent home for its friendly fire (`friendly_fire.sendHome`).
    sent_home: SentHome,
    /// The frame (`Clock.frame_start`) it was last heard flying past the camera
    /// (`sound3d.engineUpdate`). OpenReliant's sound keeps it (`hog_snd.Sound.flybys`), so that
    /// the sound writes nothing into the objects; this stays 0.
    flyby_at: i32,
    /// Orders on its stack.
    order_count: i16,
    _unknown_682: u16,
    /// Its order stack, the current order first: `aigeneric.max_stack` entries, allocated with its
    /// first order.
    orders: Pointer(aigeneric.Entry),
    /// Set while the current order has yet to start: `object_orders` runs its `init` first.
    order_starting: bool,
    _unknown_689: [3]u8,
    /// What the current order keeps between updates, allocated with the stack.
    order_state: Pointer(aigeneric.State),
    /// Damage of kinds 0, 1 and 5 taken since `orders_update` last zeroed it, which it does every
    /// 500 ticks.
    recent_damage: f32,
    /// The slot of the object that last damaged it.
    last_attacker: Slot,
    /// The first ship of the last walk of a script command's ships that ran for it, or none where
    /// it was the first (`for_each_ship_note`, `0x0045D720`). **Unknown:** what reads it.
    _unknown_698: dte.Reference,
    /// Fight's timers: until when it holds its fire, until when it holds its missiles, and until
    /// when it holds its countermeasures, each from the pilot's `timings`.
    fire_at: i32,
    missile_at: i32,
    countermeasure_at: i32,
    /// How many Fight orders have taken it as their target.
    fought_by: u32,
    /// A target Find New Target does not pick to fight until `game_ticks` pass `set_aside_until`,
    /// which BACK OFF sets to the player's target for 3000 ticks (`0x0045517F`,
    /// `radio.wingmen`); none when created.
    set_aside: Slot,
    set_aside_until: u32,
    /// What `avoidance_scan` finds the ship could hit, for the avoidance code: the objects that
    /// list components (`ai.avoidNear`), and the rest (`ai.avoidAhead`).
    avoid_near: Avoided,
    avoid_ahead: Avoided,
    /// A number from 0 to 99 the object draws from its own seed when created: where a mission lets
    /// the pilot eject, it does below `ai.eject_below` (`object_destroyed`). The `WillsBlag`
    /// command sets it to 100, which never does.
    eject_roll: i32,
    /// For each point of an order's sequence, a bit for each player who has reached it, which a
    /// network game waits on (`ai_sequence_sync`, `0x00401000`). Dark reign shoot's exit clears
    /// them all.
    sync_points: [16]u8,
    /// The object of the nav point the display points to, set by the mission's `SetNavPoint` and
    /// `nav_point_next` (`0x004152A0`), which passes on to the next the player's ship has not
    /// reached; none when created.
    nav_point: Slot,
    /// The object whose place the escort point's marker shows, set by the mission's
    /// `SetEscortPoint` for the player's ship (`cmd_SetEscortPoint_ship`, `0x00459310`); none when
    /// created.
    escort_point: Slot,
    /// Where the power distribution stands on the power ball (`input.power`): a point within a disc
    /// of radius 64, in `x` and `y`. `z` is 1 when created, and moving the point sets it to 0.
    /// `create_object` puts the point at (1, 1).
    power_setting: shp.Vec3,
    /// How fast its guns recharge, from its share of the power: 0.5 to 1.5, 1 for an even third
    /// (`input.power.distribute`). 1 when created.
    gun_factor: f32,
    /// Scales the cruise speed: the engines' share of the power, as `gun_factor` is the guns'.
    /// 1 when created.
    speed_factor: f32,
    /// How fast its shields recharge (`rechargeShields`): the shields' share of the power, as
    /// `gun_factor` is the guns'. 1 when created.
    shield_factor: f32,
    /// Its pilot: the record in `pilotstats.bin`, which `object_set_pilot` gives it.
    pilot: i32,
    /// Its pilot's face (`pilot_faces`, `0x005048D8`), which `object_set_pilot` points it at; null
    /// for a stand-in. OpenReliant leaves it null and looks the face up by `pilot`
    /// (`create.Objects.faces`).
    pilot_record: Pointer(anyopaque),
    pilot_stats: Pointer(@import("pilots.zig").Pilot),
    /// The wing the mission lists it in (`mission.listPlayerWing`).
    wing: Wing,
    _unknown_74e: u16,
    _unknown_750: u32,
    /// The deathmatch power-up it holds.
    power_up: PowerUp,
    /// **Unknown.** Set as a power-up is handed out, where it is given (`0x004B1C00`).
    _unknown_758: i32,
    /// The frame (`Clock.frame_start`) the power-up runs out at, or -1 for never.
    power_up_until: i32,
    /// The frame it was handed out at, from which the display flashes its icon (`hud_draw`).
    power_up_since: i32,
    /// **Unknown.** -1 when allocated.
    _unknown_764: i32,
    _unknown_768: [0x424]u8,
    /// Orders from other players waiting for their frame, in a multiplayer game.
    queued_order_count: i32,
    /// Its queue of `aigeneric.max_queued` entries, allocated when the first order arrives.
    queued_orders: Pointer(aigeneric.Queued),
    /// Set once `create_object` has filled the slot; it stops with a fatal error if it is set
    /// already.
    created: bool,
    /// How far harm reaches it (`SetInvulnerability`).
    invulnerable: Invulnerability,
    /// The 3D voice following it: `sound_3d_voice_end` sets it back to none, and the missiles'
    /// code reads it (`0x00495CF0`). OpenReliant's sound keeps it (`hog_snd.Sound.missile_voices`),
    /// so that the sound writes nothing into the objects; this stays none.
    sound_voice: Voice,

    /// The names of the script commands that set a bit are the developers' own.
    /// What the explosions' routines note of an object as it comes apart (`+0x610`).
    pub const Ends = packed struct(u32) {
        /// The Ulysses has lost its fin (`explode_ulysses_component`).
        fin_lost: bool = false,
        /// Its split has ended (`split_update`), or the Ulysses' top has come away
        /// (`ulysses_split_update`), which each does once.
        split_ended: bool = false,
        _unknown_2: u30 = 0,
    };

    pub const Flags = packed struct(u32) {
        /// Not drawn: `camera_set_view` sets it on the object whose cockpit the camera is in, and
        /// the warp orders while it warps. `mission_frame` hands `node_draw` flag `0x10` for it,
        /// which adds none of its parts to the scene.
        hidden: bool = false,
        /// Its components are listed, as its model's header asks. The collision code treats such
        /// objects apart.
        components: bool = false,
        /// The collision sweep of `objects_update` leaves it out.
        no_collisions: bool = false,
        /// `object_move` runs no motion routine for it, so it drifts at its velocity; knocks still
        /// move it. Set while the object is disrupted (`order_disrupted_init`) and once it is
        /// wrecked, and together with `frozen` during gate jumps and warps and by `object_reset`.
        unpowered: bool = false,
        /// `object_move` isn't run for it (`objects_update`), and returns straight away if it is.
        frozen: bool = false,
        /// Set on objects of types above 255, such as the type-1001 stand-in an empty slot holds;
        /// the per-object loops skip them.
        stand_in: bool = false,
        /// Set as it starts to explode. It takes no more orders.
        exploding: bool = false,
        /// Reverse thrust works only while it is set: `object_orders` clears `reverse_thrust`
        /// otherwise.
        can_reverse: bool = false,
        /// Set by `object_cloak`, which posts the Cloaked event.
        cloaked: bool = false,
        /// `SetTargetable` for the whole object, which sets it only when the word at `+0x24` of its
        /// combat stats is nonzero.
        targetable: bool = false,
        /// Not processed: `DisableObject`, and `DisableObjectAtNextJump` at the next jump.
        disabled: bool = false,
        /// Set once its pilot ejects. It takes no more orders, and destroying it now makes it
        /// explode.
        ejected: bool = false,
        /// Held in a ship's tractor beams, which Scoop Up sets and lets go of (`tractor.scoopUp`):
        /// no second ship takes it.
        tractored: bool = false,
        /// `DisableLights`.
        lights_disabled: bool = false,
        /// It has a shield generator, a part of subsystem class 6, which destroying the part
        /// clears.
        shield_generator: bool = false,
        /// `DisableGuns`. `orders_update` skips `0x0047C950` for it.
        guns_disabled: bool = false,
        /// `DisableMissiles`.
        missiles_disabled: bool = false,
        /// `DisableEngines`. `object_orders` holds its throttle at zero and stops both burns.
        engines_disabled: bool = false,
        /// `DisableEject`. The player cannot eject.
        eject_disabled: bool = false,
        /// `DoNotDisturb`: "dont disturb". It does not retaliate either.
        do_not_disturb: bool = false,
        /// `SetShipAvoidance` with "Disable Avoidance code": the avoidance code passes it over.
        no_avoidance: bool = false,
        /// Set during the jump orders: it cannot fire, and the avoidance code passes it over.
        jumping: bool = false,
        /// Set while the Dock and Ripper orders hold it to another object; their ends clear it.
        attached: bool = false,
        _unknown_23: bool = false,
        /// The ship a pilot has left, set by `eject_separate`: its smoke goes (`smoke.frame`), and
        /// a spin-out trails only every other bit (`aiexplode.spin`).
        abandoned: bool = false,
        /// Set by `create_object` on an object whose model has an eject point
        /// (`shp.Attachment.Kind.eject_point`). **Unknown:** what reads it.
        eject_point: bool = false,
        /// Its ECM is on: `player_ecm_set` (`0x00415370`).
        ecm: bool = false,
        /// Its spectral shields are on: `player_spectral_shields_set` (`0x00415430`).
        spectral_shields: bool = false,
        /// Sent off: set as a player's ship is sent home for its friendly fire, into Friendly Fire
        /// (`friendly_fire.sendHome`), and again as that order ends and lands it; a multiplayer
        /// game sends the other players' ships off into Jump Out. It takes no orders while it is
        /// set.
        sent_off: bool = false,
        /// `DisableListing`, "stop listing": a torpedo does not make the capital ship lurch
        /// (`collision.lurch`).
        listing_disabled: bool = false,
        _unknown_30: u2 = 0,

        /// What a slot holds until `create_object` fills it (`objects_reset`, `object_reset`), and
        /// what an object of a type above 255 is given: it takes no part in collisions, never
        /// moves, and the loops over the objects pass it over.
        pub const standing_in: Flags = .{ .no_collisions = true, .unpowered = true, .frozen = true, .stand_in = true };

        /// Lets the object move again: its motion routine runs, and `object_move` is run for it
        /// (`unpowered` and `frozen` cleared together).
        pub fn thaw(flags: *Flags) void {
            flags.unpowered = false;
            flags.frozen = false;
        }

        /// Whether the object is out of the action: exploding, its pilot ejected, or being sent
        /// off (`sent_off`). It takes no orders then, and the AI passes over a player's ship
        /// that is.
        pub fn outOfAction(flags: Flags) bool {
            return flags.exploding or flags.ejected or flags.sent_off;
        }

        /// Whether `mission_frame`'s passes over the objects pass it over: a stand-in, or a
        /// disabled or jumping object.
        pub fn outOfFrame(flags: Flags) bool {
            return flags.stand_in or flags.disabled or flags.jumping;
        }

        /// Whether the AI's searches pass it over: a stand-in, or an exploding or disabled object.
        pub fn outOfSearch(flags: Flags) bool {
            return flags.stand_in or flags.exploding or flags.disabled;
        }

        /// The flags set in either.
        pub fn with(flags: Flags, more: Flags) Flags {
            return @bitCast(word(flags) | word(more));
        }

        /// The flags set in both.
        pub fn within(flags: Flags, other: Flags) Flags {
            return @bitCast(word(flags) & word(other));
        }

        /// The flags set here but not in `other`.
        pub fn without(flags: Flags, other: Flags) Flags {
            return @bitCast(word(flags) & ~word(other));
        }

        /// Whether any flag is set.
        pub fn any(flags: Flags) bool {
            return word(flags) != 0;
        }

        fn word(flags: Flags) u32 {
            return @bitCast(flags);
        }
    };

    /// The shape the wing status window shows it by (`wing_icon`), if it has one.
    pub fn wingIcon(object: *const GameObject) ?u16 {
        return if (object.wing_icon != 0) object.wing_icon else null;
    }

    /// Where it stands (`root.position`): a step behind `nextPosition` until the next step.
    pub fn position(object: *const GameObject) Vector {
        return object.root.position.vector();
    }

    /// Where it will stand at the next step (`root.next_position`), which the AI, the collisions
    /// and the sounds go by.
    pub fn nextPosition(object: *const GameObject) Vector {
        return object.root.next_position.vector();
    }

    /// Lets go of the turns: no roll, pitch or yaw.
    pub fn holdTurns(object: *GameObject) void {
        object.roll_input = 0;
        object.pitch_input = 0;
        object.yaw_input = 0;
    }

    /// Lets go of the controls: no throttle and no turns.
    pub fn letGo(object: *GameObject) void {
        object.throttle = 0;
        object.holdTurns();
    }

    /// Whether it has gone from the mission as the orders that work on it see it: a stand-in in
    /// its slot, or exploding (`order_scoop_up`, `order_ripper_grabs_target_object`,
    /// `order_launch`).
    pub fn gone(object: *const GameObject) bool {
        return object.type.base() == .stand_in or object.flags.exploding;
    }

    /// Holds the turns and stops turning: no roll, pitch or yaw input, and no rate of turn.
    pub fn holdStill(object: *GameObject) void {
        object.holdTurns();
        object.yaw_rate = 0;
        object.pitch_rate = 0;
        object.roll_rate = 0;
    }

    /// Whether its sphere and `other`'s, their radii together `widen` wider, overlap where the
    /// next step has them: the collision sweep's test (`objects_update`, `objects_collide`), and
    /// `avoidance_scan`'s for an object that lists components.
    pub fn overlaps(object: *const GameObject, other: *const GameObject, widen: f32) bool {
        const reach = object.radius + other.radius + widen;
        return math.lengthSquared(object.nextPosition() - other.nextPosition()) < reach * reach;
    }

    /// Where its root stands at `step`: its committed place, or its next.
    pub fn placeAt(object: *const GameObject, step: objects.Model.Step) math.Place {
        return switch (step) {
            .now => .{ .position = object.position(), .orientation = object.root.orientation },
            .next => .{ .position = object.nextPosition(), .orientation = object.root.next_orientation },
        };
    }

    /// Its racks, `rack_count` of them.
    pub fn fittedRacks(object: *const GameObject) []const Rack {
        return object.racks[0..@intCast(@max(object.rack_count, 0))];
    }

    /// The way its nose will point at the next step.
    pub fn nextHeading(object: *const GameObject) Vector {
        return math.forward(object.root.next_orientation);
    }

    /// How wide its model is across, its bounds' X from least to most, which a jump's flare is
    /// scaled by (`order_jump_out`, `order_jump_in`) and a missile's trail spaces its rings by.
    pub fn width(object: *const GameObject) f32 {
        return object.bounds_max.x - object.bounds_min.x;
    }

    comptime {
        assert(@bitOffsetOf(Flags, "components") == 1);
        assert(@bitOffsetOf(Flags, "unpowered") == 3);
        assert(@bitOffsetOf(Flags, "stand_in") == 5);
        assert(@bitOffsetOf(Flags, "disabled") == 10);
        assert(@bitOffsetOf(Flags, "shield_generator") == 14);
        assert(@bitOffsetOf(Flags, "engines_disabled") == 17);
        assert(@bitOffsetOf(Flags, "attached") == 22);
        assert(@bitOffsetOf(Flags, "ecm") == 26);
        assert(@bitOffsetOf(Flags, "spectral_shields") == 27);
        assert(@bitOffsetOf(Flags, "listing_disabled") == 29);
        assert(@offsetOf(GameObject, "combat") == 0x10);
        assert(@offsetOf(GameObject, "root") == 0x28);
        assert(@offsetOf(GameObject, "visibility") == 0x12C);
        assert(@offsetOf(GameObject, "gun_charge") == 0x140);
        assert(@offsetOf(GameObject, "gun_mode") == 0x144);
        assert(@offsetOf(GameObject, "component_count") == 0x152);
        assert(@offsetOf(GameObject, "part_count") == 0x154);
        assert(@offsetOf(GameObject, "part_nodes") == 0x518);
        assert(@offsetOf(GameObject, "components") == 0x248);
        assert(@offsetOf(GameObject, "engines") == 0x5D0);
        assert(@offsetOf(GameObject, "afterburner_fuel") == 0x5E8);
        assert(@offsetOf(GameObject, "countermeasures") == 0x5EC);
        assert(@offsetOf(GameObject, "shields") == 0x5F0);
        assert(@offsetOf(GameObject, "armor") == 0x600);
        assert(@offsetOf(GameObject, "knocks") == 0x51C);
        assert(@offsetOf(GameObject, "centre") == 0x524);
        assert(@offsetOf(GameObject, "impulse") == 0x530);
        assert(@offsetOf(GameObject, "angular_impulse") == 0x53C);
        assert(@offsetOf(GameObject, "angular_response") == 0x548);
        assert(@offsetOf(GameObject, "rotation") == 0x56C);
        assert(@offsetOf(GameObject, "roll_rate") == 0x5DC);
        assert(@offsetOf(GameObject, "pitch_rate") == 0x5E0);
        assert(@offsetOf(GameObject, "yaw_rate") == 0x5E4);
        assert(@offsetOf(GameObject, "velocity") == 0x590);
        assert(@offsetOf(GameObject, "throttle") == 0x5B8);
        assert(@offsetOf(GameObject, "afterburner") == 0x5CC);
        assert(@offsetOf(GameObject, "speed") == 0x5D8);
        assert(@offsetOf(GameObject, "blink_offset") == 0x634);
        assert(@offsetOf(GameObject, "random_seed") == 0x638);
        assert(@offsetOf(GameObject, "motion") == 0x640);
        assert(@offsetOf(GameObject, "side") == 0x644);
        assert(@offsetOf(GameObject, "gun_count") == 0x130);
        assert(@offsetOf(GameObject, "guns") == 0x134);
        assert(@offsetOf(GameObject, "rounds") == 0x13C);
        assert(@offsetOf(GameObject, "gun_turn") == 0x14C);
        assert(@offsetOf(GameObject, "ends") == 0x610);
        assert(@offsetOf(GameObject, "component_loss") == 0x614);
        assert(@offsetOf(GameObject, "passes_through") == 0x618);
        assert(@offsetOf(GameObject, "_unknown_624") == 0x624);
        assert(@offsetOf(GameObject, "_unknown_628") == 0x628);
        assert(@offsetOf(GameObject, "smoke") == 0x65C);
        assert(@offsetOf(GameObject, "smoke_level") == 0x660);
        assert(@offsetOf(GameObject, "gun_condition") == 0x66C);
        assert(@offsetOf(GameObject, "sent_home") == 0x678);
        assert(@offsetOf(GameObject, "set_aside") == 0x6AC);
        assert(@offsetOf(GameObject, "avoid_near") == 0x6B4);
        assert(@offsetOf(GameObject, "avoid_ahead") == 0x6E0);
        assert(@offsetOf(GameObject, "eject_roll") == 0x70C);
        assert(@offsetOf(GameObject, "sync_points") == 0x710);
        assert(@offsetOf(GameObject, "nav_point") == 0x720);
        assert(@offsetOf(GameObject, "wing") == 0x74C);
        assert(@offsetOf(GameObject, "_unknown_764") == 0x764);
        assert(@bitOffsetOf(Flags, "frozen") == 4);
        assert(@as(u32, @bitCast(Flags.standing_in)) == 0x3C);
        assert(@offsetOf(GameObject, "missile_homing") == 0x64C);
        assert(@offsetOf(GameObject, "spectral_gun_type") == 0x670);
        assert(@offsetOf(GameObject, "blind_fire_aim") == 0x674);
        assert(@offsetOf(GameObject, "last_throttle") == 0x650);
        assert(@offsetOf(GameObject, "armor_speed_factor") == 0x668);
        assert(@offsetOf(GameObject, "shield_condition") == 0x664);
        assert(@offsetOf(GameObject, "power_setting") == 0x728);
        assert(@offsetOf(GameObject, "gun_factor") == 0x734);
        assert(@offsetOf(GameObject, "speed_factor") == 0x738);
        assert(@offsetOf(GameObject, "shield_factor") == 0x73C);
        assert(@offsetOf(GameObject, "power_up") == 0x754);
        assert(@offsetOf(GameObject, "order_count") == 0x680);
        assert(@offsetOf(GameObject, "orders") == 0x684);
        assert(@offsetOf(GameObject, "order_state") == 0x68C);
        assert(@offsetOf(GameObject, "last_attacker") == 0x694);
        assert(@offsetOf(GameObject, "queued_orders") == 0xB90);
        assert(@offsetOf(GameObject, "pilot") == 0x740);
        assert(@offsetOf(GameObject, "created") == 0xB94);
        assert(@sizeOf(GameObject) == 0xB98);
    }
};

test {
    std.testing.refAllDecls(@This());
}

/// How many countermeasures an object is created with (`0x00407AAE`, `0x0045A0A4`).
pub const countermeasures_when_created: u16 = 29;

/// How a ship's guns fire (`GameObject.gun_mode`): the group chosen, and the two ways of firing
/// them all. `create_object` gives a ship of one group of guns `0x20` and one of more `0x30`.
pub const GunMode = packed struct(u16) {
    /// The group of guns chosen. GUNNERY WINDOW moves to the next, going round, or only clears
    /// `all` if it is set.
    group: u3,
    _unknown_3: bool,
    /// Every group fires: FULL GUNS flips it on a ship of more than one group. It keeps the
    /// display's blind fire light out.
    all: bool,
    /// SYNCHRONISE GUNS flips it. **Unverified:** that it has the guns fire together rather than
    /// in turn, which the manual's CTRL and G does.
    synchronised: bool,
    _unknown_6: u10,

    /// What `create_object` starts a ship on, by how many groups of guns it has.
    pub fn created(groups: i16) GunMode {
        return .{ .group = 0, ._unknown_3 = false, .all = groups != 1, .synchronised = true, ._unknown_6 = 0 };
    }
};

test "Type.gameType" {
    try std.testing.expectEqual(GameType.kiev, Type.of(.kiev).gameType().?);
    // A type a mod adds is none of the game's, though it acts as its base.
    var list = [_]additions.ships.Added{.{ .name = "a:pot", .mod = "a", .base = .predator, .extra = .{ .model = "pot.shp" } }};
    additions.ships.install(&list);
    defer additions.ships.reset();
    const pot: Type = @fromBackingInt(additions.ships.first);
    try std.testing.expectEqual(null, pot.gameType());
    try std.testing.expectEqual(GameType.predator, pot.base());
}

test "GameObject.wingIcon" {
    var object = std.mem.zeroes(GameObject);
    try std.testing.expectEqual(null, object.wingIcon());
    object.wing_icon = 0xFC;
    try std.testing.expectEqual(0xFC, object.wingIcon().?);
}

test "Type.untwinned" {
    try std.testing.expectEqual(Type.of(.predator), Type.untwinned(.of(.t_predator)));
    try std.testing.expectEqual(Type.of(.grendel), Type.untwinned(.of(.t_grendel)));
    try std.testing.expectEqual(Type.of(.grendel), Type.of(.grendel).untwinned());
    try std.testing.expectEqual(Type.of(.asteroid_with_hole_4), Type.untwinned(.of(.asteroid_with_hole_4)));
}

test "GameObject.Flags" {
    const flags: GameObject.Flags = .{ .stand_in = true, .targetable = true };
    try std.testing.expectEqual(GameObject.Flags{ .stand_in = true, .targetable = true, .frozen = true }, flags.with(.{ .frozen = true }));
    try std.testing.expectEqual(GameObject.Flags{ .targetable = true }, flags.without(.{ .stand_in = true }));
    try std.testing.expectEqual(GameObject.Flags{ .stand_in = true }, flags.within(.{ .stand_in = true, .frozen = true }));
    try std.testing.expect(flags.any());
    try std.testing.expect(!flags.within(.{ .frozen = true }).any());
    try std.testing.expect(flags.outOfSearch());
    // A stand-in thawed moves again, and keeps its other flags.
    var thawed = GameObject.Flags.standing_in;
    thawed.thaw();
    try std.testing.expectEqual(GameObject.Flags{ .no_collisions = true, .stand_in = true }, thawed);
}

test "GameObject.overlaps" {
    var object = testing.object();
    var other = testing.object();
    object.radius = 100;
    other.radius = 50;
    other.root.next_position = .{ .x = 0, .y = 0, .z = 149 };
    try std.testing.expect(object.overlaps(&other, 0));
    // Touching is not overlapping; widened, they overlap again.
    other.root.next_position.z = 150;
    try std.testing.expect(!object.overlaps(&other, 0));
    try std.testing.expect(object.overlaps(&other, 1));
    // Only where the next step has them counts, not where they stand now.
    other.root.position = .{ .x = 0, .y = 0, .z = 10 };
    try std.testing.expect(!other.overlaps(&object, 0));
}

test "GameObject.letGo" {
    var object = testing.object();
    object.throttle = 1;
    object.yaw_input = 0.5;
    object.pitch_input = -0.5;
    object.roll_input = 0.25;
    object.letGo();
    try std.testing.expectEqual(0, object.throttle);
    try std.testing.expectEqual(0, object.yaw_input);
    try std.testing.expectEqual(0, object.pitch_input);
    try std.testing.expectEqual(0, object.roll_input);
}

test "GameObject.gone" {
    var object = testing.object();
    object.type = .of(.predator);
    try std.testing.expect(!object.gone());
    object.flags.exploding = true;
    try std.testing.expect(object.gone());
    object.flags.exploding = false;
    object.type = .of(.stand_in);
    try std.testing.expect(object.gone());
}

test "GameObject.holdStill" {
    var object = testing.object();
    object.throttle = 1;
    object.yaw_input = 0.5;
    object.pitch_input = -0.5;
    object.roll_input = 0.25;
    object.yaw_rate = 0.1;
    object.pitch_rate = -0.2;
    object.roll_rate = 0.3;
    object.holdStill();
    for ([_]f32{ object.yaw_input, object.pitch_input, object.roll_input, object.yaw_rate, object.pitch_rate, object.roll_rate }) |held| {
        try std.testing.expectEqual(0, held);
    }
    // The throttle stays.
    try std.testing.expectEqual(1, object.throttle);
}

test "GameObject.width" {
    var object = testing.object();
    object.bounds_min = .{ .x = -30, .y = -5, .z = -80 };
    object.bounds_max = .{ .x = 20, .y = 5, .z = 90 };
    try std.testing.expectEqual(50, object.width());
}

test "Type.format" {
    var buffer: [16]u8 = undefined;
    try std.testing.expectEqualStrings("reliant", try std.mem.print(&buffer, "{f}", .{Type.of(.reliant)}));
    try std.testing.expectEqualStrings("type 4096", try std.mem.print(&buffer, "{f}", .{@as(Type, @fromBackingInt(0x1000))}));
}

test "Type.twin" {
    // The first twelve types have their twins from `player_twins_first`, which stand for them again.
    try std.testing.expectEqual(Type.of(.t_phoenix), Type.of(.phoenix).twin().?);
    try std.testing.expectEqual(Type.of(.grendel), Type.of(.grendel).twin().?.untwinned());
    try std.testing.expectEqual(null, Type.of(.reliant).twin());
    try std.testing.expectEqual(null, Type.of(.t_phoenix).twin());
}

test "GameType.playerFlies" {
    // The Predator to the Phoenix and their twins, and nothing past them.
    try std.testing.expect(GameType.predator.playerFlies() and GameType.phoenix.playerFlies());
    try std.testing.expect(GameType.t_phoenix.playerFlies());
    try std.testing.expect(!GameType.reliant.playerFlies() and !GameType.basilisk.playerFlies());
}

test "GameType.rock" {
    try std.testing.expectEqual(.asteroid, GameType.asteroid_7.rock());
    try std.testing.expectEqual(.turret, GameType.turret_asteroid_1.rock());
    try std.testing.expectEqual(.hole, GameType.asteroid_with_hole_4.rock());
    try std.testing.expectEqual(null, GameType.research_station.rock());
    try std.testing.expectEqual(null, GameType.predator.rock());
    try std.testing.expect(!GameType.turret_asteroid_1.isAsteroid());
    try std.testing.expectEqual(Type.of(.asteroid_1), Type.asteroid(0));
    try std.testing.expectEqual(Type.of(.asteroid_7), Type.asteroid(6));
    try std.testing.expectEqual(Type.of(.asteroid_1), Type.asteroid(7));
}

test "GameType.isTorpedo" {
    try std.testing.expect(GameType.torpedo.isTorpedo());
    try std.testing.expect(GameType.russian_torpedo.isTorpedo());
    try std.testing.expect(!GameType.sabre.isTorpedo());
}

test GunMode {
    try std.testing.expectEqual(0x20, @as(u16, @bitCast(GunMode.created(1))));
    try std.testing.expectEqual(0x30, @as(u16, @bitCast(GunMode.created(3))));
}

/// `object_knock` (`0x004763C0`): a push of `force` on the object at the world point `at`, from a
/// collision or an explosion. The force is added to the impulse, and force × lever, the lever
/// running from the object's position to `at`, to the angular impulse. The next move applies both
/// (`applyKnocks`).
pub fn knock(object: *GameObject, force: math.Vector, at: math.Vector) void {
    const lever = at - object.position();
    object.impulse = .of(object.impulse.vector() + force);
    object.angular_impulse = .of(object.angular_impulse.vector() + math.cross(force, lever));
    object.knocks += 1;
}

/// `object_knock_local` (`0x00476430`): `knock` with `force` in the object's own frame and the
/// lever given directly. The Disrupted order pushes a ship with it, with no lever
/// (`order_disrupted_init`).
pub fn knockLocal(object: *GameObject, force: math.Vector, lever: math.Vector) void {
    const push = math.transform(object.root.orientation, force);
    object.impulse = .of(object.impulse.vector() + push);
    object.angular_impulse = .of(object.angular_impulse.vector() + math.cross(push, lever));
    object.knocks += 1;
}

/// `object_apply_knocks` (`0x00476270`): applies the knocks taken since the last move, then
/// clears them. The impulse divided by the mass is added to the velocity. The angular impulse is
/// converted to the object's frame and multiplied by `angular_response`, and `rotation` is turned
/// by the result, to first order, and orthonormalized. The angular rates are set to the angles of
/// the new rotation, so the object keeps spinning until its steering takes over again.
pub fn applyKnocks(object: *GameObject) void {
    if (object.knocks == 0) return;
    object.knocks = 0;
    // `vec3_divide_by` multiplies by the reciprocal.
    const impulse = object.impulse.vector() * @as(math.Vector, @splat(1 / object.mass));
    object.velocity = .of(object.velocity.vector() + impulse);
    const angular = object.angular_impulse.vector();
    if (@reduce(.Or, angular != @as(math.Vector, @splat(0)))) {
        const turn = math.transform(object.angular_response, math.transformTransposed(object.root.orientation, angular));
        // The angular impulse is the opposite of the torque, so the object turns by its negative.
        object.rotation = math.orthonormalize(math.product(object.rotation, math.smallTurn(-turn)));
        const rates = math.angles(object.rotation);
        object.pitch_rate = rates[0];
        object.yaw_rate = rates[1];
        object.roll_rate = rates[2];
    }
    object.impulse = .of(@splat(0));
    object.angular_impulse = .of(@splat(0));
}

/// What the player has shifted into the fore and aft shields beyond their full charge with SHIELD
/// BALANCING (`input.power.balanceShields`), which keeps the other side's charge down as the
/// shields recharge (`rechargeShields`).
pub const ShieldReserves = struct {
    /// Beyond the fore shield, `shields.fore` (`0x0051CF78`).
    fore: f32 = 0,
    /// Beyond the aft shield, `shields.aft` (`0x0051CF34`).
    aft: f32 = 0,

    /// The reserve a hit on `quadrant` draws on before the shield does, where it has one.
    pub fn of(reserves: *ShieldReserves, quadrant: collision.Quadrant) ?*f32 {
        return switch (quadrant) {
            .fore => &reserves.fore,
            .aft => &reserves.aft,
            .left, .right => null,
        };
    }

    /// A shot, a knock or a missile of `amount` on `quadrant`, taken off the reserve there while it
    /// holds anything (`bullet_hit`, `collision_damage`, `missiles.collide`): whether it held,
    /// sparing the shield. One that
    /// runs out is emptied, and the shield takes the whole hit.
    pub fn spare(reserves: *ShieldReserves, quadrant: collision.Quadrant, amount: f32) bool {
        const reserve = reserves.of(quadrant) orelse return false;
        if (!(reserve.* > 0)) return false;
        reserve.* -= amount;
        if (reserve.* > 0) return true;
        reserve.* = 0;
        return false;
    }
};

test ShieldReserves {
    var reserves: ShieldReserves = .{ .fore = 1, .aft = 2 };
    try std.testing.expectEqual(&reserves.fore, reserves.of(.fore).?);
    try std.testing.expectEqual(&reserves.aft, reserves.of(.aft).?);
    try std.testing.expectEqual(null, reserves.of(.left));

    // A hit the fore reserve holds spares the shield; one it runs out on doesn't, and empties it.
    try std.testing.expect(reserves.spare(.fore, 0.5));
    try std.testing.expectEqual(0.5, reserves.fore);
    try std.testing.expect(!reserves.spare(.fore, 1));
    try std.testing.expectEqual(0, reserves.fore);
    try std.testing.expect(!reserves.spare(.fore, 1));
    try std.testing.expect(!reserves.spare(.left, 1));
}

/// `object_recharge_shields` (`0x00476FC0`), which `simulation_step` runs for every object after
/// its node update. Each shield gains its full charge, `6 * ShipCombat.shield_power - 1`, times
/// `shield_factor` and `shield_condition`, over `ShipCombat.shield_recharge` seconds of steps,
/// and stops at the full charge. For the player's ship, `reserves` are the shields shifted fore or
/// aft: the full charge of the fore and aft shields is lower by however far the other one and its
/// reserve go beyond it.
///
/// An object whose components are listed recharges no shields here, and neither does one holding
/// the `no_shield_recharge` power-up. One whose `invulnerable` is `_unknown_5` has its shields
/// emptied instead. **Unknown:** what that value means. Not ported: the case in a multiplayer game
/// where the player's shields aren't recharged (`0x005D76F0` at 4 with `0x005DB538` naming the
/// player) ([#55](https://github.com/OpenReliant/openreliant/issues/55)).
pub fn rechargeShields(object: *GameObject, combat: *const create.ShipCombat, reserves: ?ShieldReserves) void {
    if (object.flags.components) return;
    if (object.invulnerable == ._unknown_5) {
        object.shields = .all(0);
        return;
    }
    if (object.power_up == .no_shield_recharge) return;
    const full = combat.fullShields() - 1;
    const rate = full * object.shield_factor * object.shield_condition / (combat.shield_recharge * recharge_steps);
    for (std.enums.values(collision.Quadrant)) |quadrant| {
        const shield = object.shields.at(quadrant);
        var most = full;
        if (reserves) |shifted| {
            const other: ?f32 = switch (quadrant) {
                .fore => shifted.aft + object.shields.aft,
                .aft => shifted.fore + object.shields.fore,
                .left, .right => null,
            };
            if (other) |beside| if (beside > most) {
                most -= beside - most;
            };
        }
        shield.* = rate + shield.*;
        if (shield.* > most) shield.* = most;
    }
}

/// Simulation steps a second, which `ShipCombat.shield_recharge` is counted in (`0x004DC7F0`).
const recharge_steps: f32 = 25;

/// A new object's `blink_offset` (`object_alloc`, `0x00475DD0`): C's `rand()` over its largest
/// value (`Random.fraction`), times `blink_range`, truncated.
pub fn blinkOffset(random: *Random) i16 {
    return @intFromFloat(random.fraction() * blink_range);
}

/// The ticks a new object's lights may stand into their blinks, at most (`0x004DC440`).
const blink_range: f32 = 100;

/// `object_alloc` (`0x00475DD0`): a new object of `object_type`. `SR_MEM_allocate` clears what
/// it hands out, so everything the allocation doesn't set starts at zero: the object is at rest,
/// turned by nothing each update, and has no motion, orders or renderer's object. Its root is
/// flagged as a component, and it draws its `blink_offset` from `random`.
pub fn objectAlloc(object_type: Type, random: *Random) GameObject {
    var object = std.mem.zeroes(GameObject);
    object.type = object_type;
    object.rotation = math.identity;
    object.power_up = .none;
    object._unknown_764 = -1;
    object.root.flags.component = true;
    object.sound_voice = .none;
    object.blink_offset = blinkOffset(random);
    object.visibility = 1;
    return object;
}

test objectAlloc {
    var random: Random = .{};
    const object = objectAlloc(.of(.stand_in), &random);
    try std.testing.expectEqual(Type.of(.stand_in), object.type);
    try std.testing.expectEqual(math.identity, object.rotation);
    try std.testing.expect(object.root.flags.component);
    try std.testing.expectEqual(1, object.visibility);
    // Its blink offset comes from the next random number.
    var same: Random = .{};
    try std.testing.expectEqual(blinkOffset(&same), object.blink_offset);
    try std.testing.expect(!object.created);
}

// --- The simulation's step ---------------------------------------------------------------

/// The game ticks a simulation step takes: it steps on every fourth.
pub const ticks_per_step = 4;

/// The simulation steps due at tick `now` since tick `paced_at`, which moves on by them: for what
/// OpenReliant paces by the steps where the game paces it by the frames, so that it keeps its pace
/// whatever the frame rate.
pub fn stepsDue(paced_at: *i32, now: i32) u32 {
    const due: u32 = @intCast(@divFloor(@max(now -% paced_at.*, 0), ticks_per_step));
    paced_at.* +%= @intCast(due * ticks_per_step);
    return due;
}

test stepsDue {
    var paced_at: i32 = 100;
    // Short of a step, none is due, and the pace holds.
    try std.testing.expectEqual(0, stepsDue(&paced_at, 103));
    try std.testing.expectEqual(100, paced_at);
    // Two steps and a tick on, two are due, and the tick left over counts toward the next.
    try std.testing.expectEqual(2, stepsDue(&paced_at, 109));
    try std.testing.expectEqual(108, paced_at);
    try std.testing.expectEqual(1, stepsDue(&paced_at, 112));
    // A clock that ran back brings none.
    try std.testing.expectEqual(0, stepsDue(&paced_at, 50));
}

/// What progress counts in: a thousandth for each tick (`0x004DC418`), as the jumps and the gates
/// move theirs on. With a hundred ticks to the second, a rate of 1 runs from 0 to 1 in 10 seconds.
pub const progress_per_tick: f32 = 0.001;

/// The ticks from tick `updated` to `now`, which `updated` moves on to, wrapping across the limit
/// of the ticks as the game's subtraction does.
pub fn ticksSince(updated: *i32, now: i32) i32 {
    defer updated.* = now;
    return now -% updated.*;
}

/// The ticks since tick `updated`, which moves on to `now` (`ticksSince`), as progress counts them
/// (`progress_per_tick`).
pub fn progressSince(updated: *i32, now: i32) f32 {
    return @as(f32, @floatFromInt(ticksSince(updated, now))) * progress_per_tick;
}

test ticksSince {
    var updated: i32 = 100;
    try std.testing.expectEqual(250, ticksSince(&updated, 350));
    try std.testing.expectEqual(350, updated);
    // Across the limit of the ticks it wraps.
    updated = std.math.maxInt(i32) - 99;
    try std.testing.expectEqual(250, ticksSince(&updated, std.math.minInt(i32) + 150));
    try std.testing.expectEqual(std.math.minInt(i32) + 150, updated);
}

test progressSince {
    var updated: i32 = 100;
    // A thousandth for each tick, and the tick moves on.
    try std.testing.expectEqual(0.25, progressSince(&updated, 350));
    try std.testing.expectEqual(350, updated);
    try std.testing.expectEqual(0, progressSince(&updated, 350));
    // Across the limit of the ticks it wraps, as the game's subtraction does.
    updated = std.math.maxInt(i32) - 99;
    try std.testing.expectEqual(0.25, progressSince(&updated, std.math.minInt(i32) + 150));
    try std.testing.expectEqual(std.math.minInt(i32) + 150, updated);
}

/// What a simulation step works on besides the clock and the devices, which the game keeps in
/// globals: the live objects, the player's controls, and the camera's view and shake. The cruise
/// speed reads the view (`object_cruise_speed`), and the player's speed raises the shake
/// (`object_move`).
pub const World = struct {
    objects: *create.Objects,
    player: *input.Player,
    /// The mission's clocks, whose `frame_start` the game's code reads as a global.
    clock: *const Clock,
    /// The game's difficulty, which scales damage (`collision.byDifficulty`).
    difficulty: collision.Difficulty = .medium,
    /// How far the launch's hangar's beacons reach.
    hangar_beacons: objects.HangarBeacons = .to_the_ship,
    /// The Yamato launch steam's brightness, with the original emission behavior.
    launch_steam: @import("launch/yamato.zig").Steam = .soft,
    /// How the Reliant's landing brings the ship down.
    touchdown: @import("ailand.zig").Touchdown = .level,
    /// When the player hears their own ship jump in.
    arrival_sound: @import("jump.zig").ArrivalSound = .heard,
    /// `light_maps` (`0x005D5618`): whether the parts flagged `lightmap` are drawn with their light
    /// maps (`winmain.Details.light_maps`), which the orders that turn a ship's lights on and off
    /// go by.
    light_maps: bool = true,
    /// The camera's shake from hits (`hit_shake`, `0x00588724`), which hits, shockwaves, launches,
    /// jumps, the worm between gates and the player's speed raise, and which dies away a tick at a
    /// time (`main.gameFrames`, `camera.Cockpit.faded`). The game keeps it, and drawing only reads
    /// it: the camera, the display and the controller's shake.
    shake: *f32,
    /// The game's random numbers (`Random`), from which the guns' step draws a damaged gun's
    /// misfire.
    random: *Random,
    /// **Improvement:** the random numbers of the effects only drawn or heard, the particles, the
    /// explosions' fireballs, bits and sounds' pitch, the sparks and the rays, apart from the
    /// game's. The game draws those from its own numbers, but only where the effects are drawn or
    /// heard, so a world that draws or hears nothing would go on from different numbers. They are
    /// apart from drawing's numbers too, so that drawing can run beside the game frames. Null where
    /// nothing is drawn, as in a test (`effectsRandom`).
    effects_random: ?*Random = null,
    /// What the game frames ask of the sound, which the main thread plays after them; null where
    /// nothing is heard.
    sounds: ?*@import("hog_snd.zig").commands.Commands = null,
    /// What the explosions leave for the frames after them (`explode.cpp`); null where nothing
    /// explodes.
    explosions: ?*@import("explode.zig").Explosions = null,
    /// The pool particles come from; null where none are sent out.
    particles: ?*@import("particles.zig").Pool = null,
    /// The shockwaves spreading (`shockwave.cpp`); null where none spread.
    shockwaves: ?*@import("shockwave.zig").Shockwaves = null,
    /// What the game frames ask of drawing, such as a missile's trail or a planet's atmosphere,
    /// which drawing takes up as the next drawn frame begins (`main.cues`); null where nothing is
    /// drawn.
    cues: ?*@import("main/cues.zig").Cues = null,
    /// The countermeasures in flight (`cloak.cpp`); null where none are dropped.
    countermeasures: ?*@import("cloak.zig").Countermeasures = null,
    /// The capital ships' shields showing (`shield.cpp`); null where none show.
    capital_shields: ?*@import("shield.zig").Capital = null,
    /// The electric rays (`erayfx.cpp`); null where none are made.
    rays: ?*@import("erayfx.zig").Rays = null,
    /// The tractors (`tractor.cpp`); null where no ship takes another aboard.
    tractors: ?*@import("tractor.zig").Tractors = null,
    /// What the Rippers carry, and their beams (`airipper.cpp`); null where no Ripper carries.
    rippers: ?*@import("airipper.zig").Rippers = null,
    /// What the jumps show (`jump.effect`).
    jump_effects: ?*@import("jump/effect.zig").Effects = null,
    /// The gates' tunnels and the worm (`wgate.cpp`); null where no gate opens.
    gates: ?*@import("wgate.zig").Gates = null,
    /// The ion cannons firing (`aiioncan.cpp`); null where none fire.
    ion_cannons: ?*@import("aiioncan.zig").Cannons = null,
    /// The textures a few types' extras are drawn over (`create.extra`), such as the Dark Reign's
    /// hat; null where no type has one made.
    extras: ?*const @import("create/extra.zig").Images = null,
    /// The screen's flash (`main.cpp`); null where nothing flashes.
    flash: ?*@import("main/flash.zig").Flash = null,
    /// The force feedback the player's controller plays; null where it plays none.
    forces: ?*input.force.Forces = null,
    /// The sparks flying (`sparks.cpp`); null where none are thrown.
    sparks: ?*@import("sparks.zig").Sparks = null,
    /// The head-up display's state (`hud.cpp`'s globals), which smart targeting and the target
    /// display answer the player's hits through; null where there is none.
    display: ?*@import("hud.zig").State = null,
    /// The pools a damaged ship's smoke comes from; null where none is sent out.
    smoke: ?*@import("main/smoke.zig").Pools = null,
    /// The guns' pools, a flak shell's burst's and the spent cases'; null where none are sent out.
    gun_particles: ?*@import("guns.zig").effects.Pools = null,
    /// What objects are made from while the mission runs, as a capital ship's split makes its
    /// other half (`create_object`), and the ship types' flight models, which the plain motions fly
    /// fighters by (`motion.Flight`); null where none are made.
    spawn: ?Spawn = null,
    /// The mission's records, through which an order aimed at a flight group or a squad reaches
    /// their ships (`ai.eachShip`); null where no mission is bound, as in a test.
    mission: ?*const @import("mission/bind.zig").Mission = null,
    /// What the mission's script asks of its space (`environfx.cpp`); null where nothing is drawn.
    environment: ?*@import("environfx.zig").Environment = null,
    /// The mission's events, which the game's code posts as they happen for the script's triggers
    /// (`mission.events`); null where no mission runs, as in a test.
    events: ?*@import("mission/events.zig").Events = null,
    /// The game's variables the mission's script reads and writes (`vm.Variables`); null where no
    /// mission runs, as in a test.
    variables: ?*@import("../vm.zig").Variables = null,
    /// The radio, whose lines the pilots say (`radio`); null where nothing is heard.
    radio: ?*@import("radio.zig").Radio = null,

    /// The ship types' stats and their models.
    pub const Spawn = struct {
        tables: *create.Stats,
        types: create.Types,
    };

    /// What particles are sent out with, as the camera sees them, their sparks going to the
    /// explosions; null where nothing is seen.
    pub fn sending(world: World) ?@import("particles.zig").Sending {
        const seen = world.seenFrom() orelse return null;
        return .{ .view = seen, .clock = world.clock, .random = world.effectsRandom(), .explosions = @import("explode.zig").drawnIn(world) };
    }

    /// The view the camera shows, as the game keeps it (`input.Player.viewing`).
    pub fn view(world: World) camera.View {
        return world.player.viewing.view;
    }

    /// Where the camera stood as the last frame was drawn, as the game keeps it
    /// (`camera.Viewing.seen_from`); null where nothing is drawn.
    pub fn seenFrom(world: World) ?camera.Place {
        return world.player.viewing.seen_from;
    }

    /// The random numbers the effects only drawn take (`effects_random`), the game's where it has
    /// none.
    pub fn effectsRandom(world: World) *Random {
        return world.effects_random orelse world.random;
    }

    /// The bound mission's curves (section `curves`): none where no mission is bound, or where its
    /// file's section cannot be read.
    pub fn missionCurves(world: World) []align(1) const dte.Curve {
        const bound = world.mission orelse return &.{};
        return bound.file.curves() catch &.{};
    }

    /// The bound mission's ships (section `ships`), as its records place them: none where no
    /// mission is bound, or where its file's section cannot be read.
    pub fn missionShips(world: World) []align(1) const dte.Ship {
        const bound = world.mission orelse return &.{};
        return bound.file.ships() catch &.{};
    }
};

/// `simulation_step` (`0x004774D0`): the work of every fourth tick, so 25 times a second, which
/// is why the [flight model](../../../docs/engine/objects.md#motion) moves at that rate.
/// **Unverified:** it and `game_tick` lie after this file's known code, before `guns.cpp`'s. It
/// reads the input devices and moves `simulation_turn` on (`nextTurn`). Then each live object in
/// the loops' order (`create.Objects.walk`), stand-ins and disabled ones passed over, has its own
/// updates: the one whose turn it is is orthonormalized (`orthonormalizeTurn`), then comes its
/// node update (`updateTree`), its shields' recharge (`rechargeShields`) and its guns' step
/// (`guns.step`). Then
/// the player's controls fly the player's ship, `objects_update` moves them all
/// (`create.objectsUpdate`), and the missiles (`missiles.move`) and the shots (`guns.moveBullets`)
/// move after them. Last, mods' scripts run their `on_step` handlers. Returns whether it did that
/// work.
///
/// The player's own order runs here as well as once a frame, while its top order is Player
/// Control, so the controls are read on every step.
pub fn simulationStep(clock: *Clock, devices: *input.Devices, world: World) bool {
    clock.simulation_counter += 1;
    if (clock.simulation_counter < ticks_per_step) return false;
    devices.read();
    clock.simulation_counter = 0;
    const all = world.objects;
    const turn = nextTurn(clock, all.count);
    var slots = all.walk();
    while (slots.next()) |index| {
        const slot = &all.slots[index];
        const object = &slot.object;
        if (object.flags.stand_in or object.flags.disabled) continue;
        if (index == turn) orthonormalizeTurn(&object.root);
        var live = world;
        updateTree(&object.root, if (slot.model) |*model| model else null, guns.clipEvents(&live, @intCast(index)));
        const combat = slot.combat orelse continue;
        rechargeShields(object, combat, if (index == all.player) world.player.shield_reserves else null);
        guns.step(world, clock, index);
    }
    // The player's own order runs again here, before the objects move, so the controls tell on
    // every step rather than once a frame.
    const player = &all.slots[all.player];
    if (player.running(.player_control) != null) {
        aigeneric.objectOrders(.{ .world = world, .devices = devices }, all.player);
    }
    create.objectsUpdate(world);
    missiles.move(world.objects);
    guns.moveBullets(world);
    if (all.scripts) |scripts| scripts.step();
    return true;
}

/// Moves `simulation_turn` on to the next of `objects` live objects, as `simulation_step` does
/// once a step before the objects' own updates, and returns it. That object's orientation is
/// orthonormalized this step (`orthonormalizeTurn`), so each object gets its turn in rotation.
pub fn nextTurn(clock: *Clock, objects_live: u32) u32 {
    clock.simulation_turn += 1;
    if (clock.simulation_turn >= objects_live) clock.simulation_turn = 0;
    return clock.simulation_turn;
}

/// `game_tick` (`0x00477850`): one tick of the mission. Paused, it counts the tick and does
/// nothing else. Every `countdown_ticks` of the mission it takes a second off the countdown, game
/// variable 33 (`vm.Variables.countdown`, `0x00477889`), which mission 29 sets and the display
/// shows (`hud.clockTime`). Returns whether the simulation stepped.
///
/// Not ported: the timed sections it brackets the tick with outside a network game.
pub fn gameTick(clock: *Clock, devices: *input.Devices, world: World) bool {
    if (clock.paused) {
        clock.paused_ticks +%= 1;
        return false;
    }
    clock.mission_ticks +%= 1;
    if (@rem(clock.mission_ticks, countdown_ticks) == 0) if (world.variables) |variables| {
        variables.countdown -%= 1;
    };
    return simulationStep(clock, devices, world);
}

/// The mission's ticks to a second of the countdown (`0x0047787E`).
pub const countdown_ticks = 100;

/// What `simulation_step` does for the object whose turn it is (`Clock.nextTurn`), before its node
/// update: orthonormalizes the root's next orientation (`mat3_orthonormalize`), so that rounding
/// doesn't build up in the matrix from one step to the next. The game does the same to the
/// orientation at `GameObject + 0x7A4`, which a multiplayer game draws other players' ships by;
/// OpenReliant doesn't keep that one yet (#55).
pub fn orthonormalizeTurn(root: *objects.Node) void {
    root.next_orientation = math.orthonormalize(root.next_orientation);
}

// --- The node tree -------------------------------------------------------------------------

/// `object_link_parts` (`0x00476130`): links each part to the part it names, or to the root
/// (`linkPart`), then moves the object's origin to its parts' centre of mass (`recentre`).
/// `source` is the model the parts come from.
pub fn linkParts(model: *objects.Model, source: *const shp.Model) void {
    for (0..model.parts.len) |index| linkPart(model, index);
    recentre(model, source);
}

/// `object_link_part` (`0x00476180`) once the part hangs from its parent: poses it as its track
/// has it at the start (`node_animate` at time zero), which is its first unless one was started,
/// and takes the place that gives it, but not the pose, as its node's place and its frame's. Its
/// next place stays in the node, and the four flags the steps and the frames keep of it are
/// cleared: pending, committed, unframed and posed.
pub fn linkPart(model: *objects.Model, index: usize) void {
    const part = &model.parts[index];
    model.animate(index, 0);
    const a = &part.animation;
    a.now.place = a.next.place;
    part.origin = a.next.place.position;
    part.turn = a.next.place.orientation;
    a.pending = false;
    a.committed = false;
    a.unframed = false;
    a.posed = false;
}

/// `object_recentre` (`0x004769F0`) for a live object in `slot`: moves its origin to the centre of
/// mass of its shown parts (`recentre`), its root's place and next place, and its frame, going
/// with it, so that it stays where it was, and keeps what that works out.
pub fn recentreObject(slot: *create.Slot) void {
    const model = if (slot.model) |*live| live else return;
    const source = (slot.type orelse return).model;
    const object = &slot.object;
    const before = model.centre;
    recentre(model, source);
    objects.shift(object, &slot.drawn, math.transform(object.root.orientation, model.centre - before));
    object.mass = model.mass;
    object.centre = .of(model.centre);
    object.radius = model.radius;
    object.angular_response = model.angular_response;
    object.bounds_min = .of(model.bounds[0]);
    object.bounds_max = .of(model.bounds[1]);
}

/// `node_mass_add` (`0x004764A0`) on the node of part `index` of `model`: the part's mass, its
/// density times its volume, and that of each shown part of each model the part carries, however
/// deep (`MassSum.addCarried`). The parts linked to the part are not among the node's children:
/// linking a part sets its node's parent and leaves it in the root's child list
/// (`object_link_part`, `0x00476180`).
pub fn nodeMass(model: *const objects.Model, index: usize) f32 {
    var sum: MassSum = .{};
    sum.addCarried(model, index);
    if (model.partData(index)) |data| sum.add(@splat(0), data.part);
    return sum.mass;
}

/// What `node_mass_add` (`0x004764A0`) sums over the nodes it walks, each node's children before
/// it: their mass, and their first moments about the object's origin, which `object_recentre`
/// divides by the mass for the centre.
const MassSum = struct {
    mass: f32 = 0,
    moment: Vector = @splat(0),

    /// Adds a part of record `part` whose origin stands `at` in the object's frame: its density
    /// times its origin times its volume plus its own first moment, and its density times its
    /// volume.
    fn add(sum: *MassSum, at: Vector, part: shp.Part) void {
        const first: Vector = part.first_moments;
        sum.moment = (at * @as(Vector, @splat(part.volume)) + first) * @as(Vector, @splat(part.density)) + sum.moment;
        sum.mass = part.density * part.volume + sum.mass;
    }

    /// Adds each shown part of each model that part `index` of `model` carries, however deep, where
    /// the models were last placed: a mounted model's root is one of the node's children, and its
    /// parts are its root's (`node_mount`, `0x00499A10`).
    fn addCarried(sum: *MassSum, model: *const objects.Model, index: usize) void {
        var each = model.carriedBy(index);
        while (each.next()) |mount| for (mount.model.parts, 0..) |part, at| {
            if (part.hidden) continue;
            sum.addCarried(&mount.model, at);
            if (mount.model.partData(at)) |data| sum.add(part.object.position, data.part);
        };
    }
};

/// What `object_bounds` (`0x00476680`) sums over every node under the root: the bounding box and
/// the radius over the vertices of each part's finest level, and the inertia tensor of the shown
/// parts (`partInertia`).
///
/// **Fix:** the game takes each part's current level, the one it last drew, so the bounds and the
/// radius change with how far the camera was. OpenReliant takes the finest, the same wherever the
/// camera is.
const Extent = struct {
    bounds: [2]Vector = .{ @splat(std.math.floatMax(f32)), @splat(-std.math.floatMax(f32)) },
    radius: f32 = 0,
    tensor: math.Matrix = @splat(0),

    /// Adds `part`, of record `data`, where the model was last placed.
    fn add(extent: *Extent, part: *const objects.Model.Part, data: ?shp.PartData) void {
        if (part.object.finest()) |mesh| {
            for (mesh.positions) |position| {
                const at = math.transform(part.object.orientation, position) + part.object.position;
                const low = @min(extent.bounds[0], at);
                const high = @max(extent.bounds[1], at);
                extent.bounds = .{ low, high };
                extent.radius = @max(extent.radius, math.length(at));
            }
        }
        if (part.hidden) return;
        const record = data orelse return;
        for (&extent.tensor, partInertia(part.object.position, &record.part)) |*sum, term| sum.* += term;
    }

    /// Adds each part of each model that part `index` of `model` carries, however deep, but those
    /// taken out of their model, hidden ones too.
    fn addCarried(extent: *Extent, model: *const objects.Model, index: usize) void {
        var each = model.carriedBy(index);
        while (each.next()) |mount| for (mount.model.parts, 0..) |*part, at| {
            if (part.removed) continue;
            extent.add(part, mount.model.partData(at));
            extent.addCarried(&mount.model, at);
        };
    }
};

/// Moves the object's origin to its parts' centre of mass, as `object_link_parts` ends
/// (`object_recentre`, `0x004769F0`). `node_mass_add` (`0x004764A0`) sums, over the shown parts,
/// and the shown parts of the models mounted on them, the density times the part's first moment
/// about the root, its origin times its volume plus its own first moment; over the parts' masses,
/// density times volume, that is the centre (`MassSum`). `object_bounds` (`0x00476680`) takes it off
/// each part's origin, then finds the object's radius and bounding box over the vertices of each
/// part's current level, hidden ones too but not those taken out of the model
/// (`objects.Model.Part.removed`), whose nodes the game has gone from the root, and the mounted
/// models' parts the same, and sums its inertia over the shown ones (`Extent`). `source` is the
/// model the parts come from.
///
/// **Fix:** the game adds up the places of a part's frames without turning each by the frame it
/// hangs from, as it works out the centre, so a part under a turned frame, such as a turret mounted
/// upside down, counts where it does not stand. OpenReliant counts each part where it stands, as the
/// game does for the bounds and the inertia.
pub fn recentre(model: *objects.Model, source: *const shp.Model) void {
    // Each part's origin in the model, which is where it stands with the root at rest.
    model.place(@splat(0), math.identity);
    var sum: MassSum = .{};
    for (model.parts, source.parts, 0..) |part, data, index| {
        if (part.hidden) continue;
        sum.addCarried(model, index);
        sum.add(part.object.position, data.part);
    }
    model.mass = sum.mass;
    if (sum.mass > 0) sum.moment *= @splat(1 / sum.mass);
    const centre = sum.moment;
    model.centre += centre;
    // Only a part standing at the root moves: one hanging from another keeps the origin it has
    // in its parent, and follows it. What stands on a part likewise moves with the part.
    // `object_bounds` moves the node's place, its next place and its frame alike.
    for (model.parts) |*part| {
        if (part.parent != null) continue;
        part.origin -= centre;
        part.animation.now.place.position -= centre;
        part.animation.next.place.position -= centre;
    }

    model.place(@splat(0), math.identity);
    var extent: Extent = .{};
    for (model.parts, source.parts, 0..) |*part, data, index| {
        if (part.removed) continue;
        extent.add(part, data);
        extent.addCarried(model, index);
    }
    model.bounds = extent.bounds;
    model.radius = extent.radius;
    var tensor = extent.tensor;
    // The tensor is built as its own lower half, which the upper half mirrors before it is
    // inverted, since the two are the same for it.
    tensor[1] = tensor[3];
    tensor[2] = tensor[6];
    tensor[5] = tensor[7];
    // A model whose parts have no volume, as a few do, leaves a tensor that cannot be inverted: the
    // game divides by its determinant whatever it is, and OpenReliant leaves nothing to turn by.
    model.angular_response = math.inverse(tensor) orelse @splat(0);
}

/// What a part adds to its object's inertia tensor (`object_bounds`), with `at` its origin in the
/// object's frame: its second moments about the two other axes on the diagonal and its products off
/// it, each with the term its distance from the object's own origin adds, all times its density.
///
/// The part's own frame is not taken into account, so a part that its model turns counts as though
/// it stood square.
fn partInertia(at: math.Vector, part: *const shp.Part) math.Matrix {
    const first = part.first_moments;
    const second = part.second_moments;
    const products = part.products;
    const volume = part.volume;
    var own: math.Matrix = @splat(0);
    own[0] = -(2 * at[1] * first[1] + 2 * at[2] * first[2] + at[2] * at[2] * volume + at[1] * at[1] * volume + second[1] + second[2]);
    own[4] = -(2 * at[0] * first[0] + 2 * at[2] * first[2] + at[2] * at[2] * volume + at[0] * at[0] * volume + second[0] + second[2]);
    own[8] = -(2 * at[1] * first[1] + 2 * at[0] * first[0] + at[1] * at[1] * volume + at[0] * at[0] * volume + second[1] + second[0]);
    own[3] = at[1] * first[0] + (at[1] * volume + first[1]) * at[0] + products[0];
    own[6] = at[2] * first[0] + (at[2] * volume + first[2]) * at[0] + products[2];
    own[7] = at[2] * first[1] + (at[2] * volume + first[2]) * at[1] + products[1];
    for (&own) |*term| term.* *= -part.density;
    return own;
}

/// `node_tree_update` (`0x00476C90`), which `simulation_step` runs for every live object at the
/// start of each step, before the objects move. For the object's root and each descendant that is
/// animating, it commits the node's pending next place (`Node.commitNext`), advances the node's
/// animation and fires its keyframe events. So an object moves from the place the previous step
/// worked out, and until the next step its `position` stays one step behind `next_position`, which
/// is what the rest of the game reads as its place.
///
/// The root has no part, so it plays no track of its own: it stays marked as animating while a part
/// standing at it does. OpenReliant keeps the part nodes in the object's `Model`, which goes on
/// with the walk (`walk`).
pub fn updateTree(root: *Node, model: ?*objects.Model, events: ?Events) void {
    root.commitNext();
    root.flags.animating = if (model) |parts| walk(parts, events) else false;
}

/// The nodes `node_tree_update` can hold on its stack at once, which is as far into a model as
/// OpenReliant's walks go.
pub const walk_room = 500;

/// The spans of a track's time whose events `node_tree_update` sets off as a node passes
/// them: two, each from its first figure up to but not including its second. The game keeps
/// them from node to node, so a node that sets neither checks the last node's.
const Windows = struct {
    first: [2]i32 = .{ 0, 0 },
    second: [2]i32 = .{ 0, 0 },

    fn passes(windows: Windows, time: i32) bool {
        return (windows.first[0] <= time and time < windows.first[1]) or
            (windows.second[0] <= time and time < windows.second[1]);
    }
};

/// The part nodes' share of `node_tree_update` (`updateTree`), once each simulation step. It keeps
/// a stack of nodes: the root pushes each of its children that is shown and animating, which is
/// every part whatever it is linked to, in part order; the node on top is taken off and visited,
/// and pushes in turn the roots of the models it carries that are animating, and each of those its
/// own parts. So the nodes are visited depth first, the last pushed first. A visit commits the
/// place the last step worked out, moves the node on through its track, poses the part for the
/// next step, and sets off the track's events it passes; a node playing no track stops animating,
/// but one that pushes an animating node stays marked. Returns whether the root pushed any part,
/// which keeps the root marked.
///
/// The game marks a node animating and every node it hangs from, up through a model's root to the
/// part carrying it (`node_mark_animating`); OpenReliant marks up to a model's root
/// (`objects.Model.markAnimating`), and takes a part as animating, or a model's root, while it
/// carries a model that has an animating part.
fn walk(model: *objects.Model, events: ?Events) bool {
    var windows: Windows = .{};
    var stack: Stack = .{};
    const any = stack.pushParts(model);
    while (stack.pop()) |node| switch (node) {
        .root => |held| _ = stack.pushParts(held),
        .part => |at| {
            visit(at.model, at.index, &windows, events);
            var each = at.model.carriedBy(at.index);
            while (each.next()) |mount| {
                if (!rootAnimating(&mount.model)) continue;
                stack.push(.{ .root = &mount.model });
                at.model.parts[at.index].animation.animating = true;
            }
        },
    };
    return any;
}

/// `node_tree_update`'s stack of nodes still to visit (`walk_room` of them): a model's root, or one
/// of its parts. A node past its room is passed over, where the game writes past the stack.
const Stack = struct {
    nodes: [walk_room]Entry = undefined,
    count: usize = 0,

    const Entry = union(enum) {
        root: *objects.Model,
        part: objects.PartRef,
    };

    fn push(stack: *Stack, node: Entry) void {
        if (stack.count == walk_room) return;
        stack.nodes[stack.count] = node;
        stack.count += 1;
    }

    fn pop(stack: *Stack) ?Entry {
        if (stack.count == 0) return null;
        stack.count -= 1;
        return stack.nodes[stack.count];
    }

    /// A root's visit: each of its parts, in order, that is shown and animating. Whether it pushed
    /// any.
    fn pushParts(stack: *Stack, model: *objects.Model) bool {
        var any = false;
        for (0..model.parts.len) |index| {
            if (!pushed(model, index)) continue;
            stack.push(.{ .part = .{ .model = model, .index = index } });
            any = true;
        }
        return any;
    }
};

/// Whether its root pushes part `index` of `model`: one that is shown and animating, or carries a
/// model whose root is.
fn pushed(model: *const objects.Model, index: usize) bool {
    const part = &model.parts[index];
    return !part.hidden and (part.animation.animating or carriesAnimating(model, index));
}

/// Whether a model's root is marked animating: while it pushes any of its parts.
fn rootAnimating(model: *const objects.Model) bool {
    for (0..model.parts.len) |index| {
        if (pushed(model, index)) return true;
    }
    return false;
}

fn carriesAnimating(model: *const objects.Model, index: usize) bool {
    var each = model.carriedBy(index);
    while (each.next()) |mount| {
        if (rootAnimating(&mount.model)) return true;
    }
    return false;
}

/// One part node's visit in `node_tree_update`.
fn visit(model: *objects.Model, index: usize, windows: *Windows, events: ?Events) void {
    const a = &model.parts[index].animation;
    a.committed = false;
    a.posed = false;
    if (a.pending) {
        a.now = a.next;
        a.pending = false;
        a.committed = true;
        a.unframed = true;
    }
    if (a.mode == .none or a.speed == 0) {
        a.animating = false;
        return;
    }
    if (a.track >= a.tracks.len) return;
    const track = &a.tracks[a.track];
    const was = a.time;
    const time = a.speed + a.time;
    a.time = time;
    const length: f32 = @floatFromInt(track.clip.length);
    if (length > 0) switch (a.mode) {
        .once => {
            // To the end, or back to the start, and there it stops.
            if (time >= length) {
                a.time = length;
                a.speed = 0;
            }
            if (!(a.time > 0)) {
                a.time = 0;
                a.speed = 0;
            }
            const span: [2]i32 = .{ math.round(was), math.round(a.time) };
            windows.* = .{ .first = span, .second = span };
            model.animate(index, a.time);
        },
        .loop => {
            const span: [2]i32 = .{ math.round(was), math.round(time) };
            windows.* = .{ .first = span, .second = span };
            // Past the end it starts again: the events from where it was to the end go off,
            // then those from the start to where it is.
            if (a.time > length) {
                windows.second[0] = 0;
                while (true) {
                    a.time -= length;
                    windows.first = .{ math.round(was), math.round(length) };
                    windows.second[1] = math.round(a.time);
                    if (!(a.time > length)) break;
                }
            }
            model.animate(index, a.time);
        },
        .swing => {
            // Out to the end over the first length and back over the second; no events go off.
            const both = length + length;
            if (time > both) {
                while (true) {
                    a.time -= both;
                    if (!(a.time > both)) break;
                }
            }
            model.animate(index, if (a.time > length) both - a.time else a.time);
            windows.* = .{};
        },
        else => {},
    };
    const sink = events orelse return;
    for (track.events) |event| {
        if (!windows.passes(event.time)) continue;
        switch (event.kind) {
            .muzzles, .puff => sink.fire(sink.context, sink.owner, model, index, event.kind),
            _ => {},
        }
    }
}

/// Whoever sets off the effects of the events the tracks of the model of the object in slot
/// `owner` pass: the game's own (`guns.clipEvents`), or a test's.
pub const Events = struct {
    context: *anyopaque,
    owner: u16 = 0,
    fire: *const fn (context: *anyopaque, owner: u16, model: *objects.Model, part: usize, kind: shp.ClipEvent.Kind) void,
};

/// Fixtures for the tests here and in the modules that move objects.
pub const testing = struct {
    /// A light fighter's flight stats, near the Predator's.
    pub const flight: create.FlightModel = .{
        .max_speed = 320,
        .roll_rate = 3,
        .pitch_rate = 2,
        .yaw_rate = 1.5,
        .inertia = 0.9,
        .roll_inertia = 0.8,
        .pitch_inertia = 0.8,
        .yaw_inertia = 0.8,
        .speed_per_pitch_rate = 160,
        .turns = .banking,
        ._unknown_26 = 0,
    };

    /// An object as `create_object` leaves one: undamaged, at rest, facing along its own nose.
    pub fn object() GameObject {
        var made: GameObject = std.mem.zeroes(GameObject);
        made.root.orientation = math.identity;
        made.root.next_orientation = math.identity;
        made.speed_factor = 1;
        made.armor_speed_factor = 1;
        made.engines_intact = 1;
        return made;
    }

    /// A mission with nothing in it but what a test puts there: objects with no models, the stats
    /// they are made from, and what their world points at. It stays where `init` fills it in, as
    /// the world points into it.
    pub const Mission = struct {
        random: Random,
        objects: *create.Objects,
        tables: create.Stats,
        player: input.Player,
        shake: f32,
        clock: Clock,

        /// Fills in every field, so a field added here has to be filled in too. The player watches
        /// from the chase view.
        pub fn init(mission: *Mission, gpa: std.mem.Allocator) !void {
            mission.* = .{
                .random = .{},
                .objects = undefined,
                .tables = create.testing.tables(),
                .player = .{ .viewing = .{ .view = .chase, .last = .chase } },
                .shake = 0,
                .clock = .{},
            };
            mission.objects = try .create(gpa, &mission.random);
        }

        pub fn deinit(mission: *Mission) void {
            mission.objects.destroy();
        }

        pub fn world(mission: *Mission) World {
            return .{ .objects = mission.objects, .player = &mission.player, .clock = &mission.clock, .shake = &mission.shake, .random = &mission.random };
        }

        /// What the objects' orders run against.
        pub fn orders(mission: *Mission) aigeneric.Context {
            return .of(mission.world());
        }

        /// The clock moves on `ticks`, and the orders of the object in slot `index` run against
        /// `ctx` (`aigeneric.objectOrders`).
        pub fn ordersAfter(mission: *Mission, ctx: aigeneric.Context, index: u16, ticks: i32) void {
            mission.clock.frame_start += ticks;
            aigeneric.objectOrders(ctx, index);
        }

        /// An object of `ship_type` at `at`, in the next slot, with no model.
        pub fn add(mission: *Mission, ship_type: Type, at: Vector) !u16 {
            return mission.addWith(create.testing.no_models, ship_type, at);
        }

        /// An object of `ship_type` at `at`, in the next slot, of the model `types` gives it.
        pub fn addWith(mission: *Mission, types: create.Types, ship_type: Type, at: Vector) !u16 {
            return create.createObject(mission.objects, &mission.tables, types, null, ship_type, 0, at, &mission.random);
        }

        /// What the world makes its ships from: the mission's stats, and the models `types` gives
        /// (`World.spawn`).
        pub fn spawn(mission: *Mission, types: create.Types) World.Spawn {
            return .{ .tables = &mission.tables, .types = types };
        }

        /// A ship that is nobody's, at `at`, which takes the orders the player's refuses: the
        /// player holds the first slot, so the ship comes after it.
        pub fn addOther(mission: *Mission, at: Vector) !u16 {
            if (mission.objects.count == 0) _ = try mission.add(.of(.predator), @splat(0));
            return mission.add(.of(.predator), at);
        }

        pub fn slot(mission: *Mission, index: u16) *create.Slot {
            return &mission.objects.slots[index];
        }
    };
};

test "World.missionCurves and World.missionShips" {
    const ships = dte.testing.ships(2, 0);
    var game: @import("../vm.zig").machine.testing.Game = undefined;
    try game.init(std.testing.allocator, &.{}, .{ .ships = &ships, .curves = &.{dte.testing.curve(0, 1, .{ 0, 0, 0 }, .{ 0, 0, 1000 })} });
    defer game.deinit();
    // With no mission bound, none.
    try std.testing.expectEqual(0, game.mission.world().missionCurves().len);
    try std.testing.expectEqual(0, game.mission.world().missionShips().len);
    // Bound, its own.
    const world = game.world();
    try std.testing.expectEqual(1, world.missionCurves().len);
    try std.testing.expectEqual(1, world.missionCurves()[0].end.index);
    try std.testing.expectEqual(2, world.missionShips().len);
    try std.testing.expectEqual(1, world.missionShips()[1].object_id);
}

test "World.sending" {
    var mission: testing.Mission = undefined;
    try mission.init(std.testing.allocator);
    defer mission.deinit();
    const world = mission.world();
    // Where nothing is drawn, no particles go out for the camera.
    try std.testing.expectEqual(null, world.sending());
    // Once a frame is drawn, they go out as seen from where the camera stood for it.
    mission.player.viewing.seen_from = .{ .position = .{ 1, 2, 3 } };
    try std.testing.expectEqual(math.Vector{ 1, 2, 3 }, world.sending().?.view.position);
}

test Quadrants {
    var shields: Quadrants = .all(5);
    shields.at(.aft).* = 2;
    // Each quadrant is the field of its name, and in the game's order among them.
    try std.testing.expectEqual(2, shields.aft);
    try std.testing.expectEqual(5, shields.get(.fore));
    try std.testing.expectEqual([4]f32{ 5, 5, 5, 2 }, shields.values());
    try std.testing.expectEqual(17, shields.total());
    try std.testing.expectEqual(2, shields.weakest());
}

test "a knock pushes and turns an object" {
    var object = testing.object();
    object.rotation = math.identity;
    object.mass = 4;
    object.angular_response = math.identity;
    object.throttle = 1;
    // A push to the side on the nose: the object moves off to that side and turns its nose there.
    knock(&object, .{ 0.02, 0, 0 }, .{ 0, 0, 1 });
    try std.testing.expectEqual(1, object.knocks);
    motion.move(&object, .{ .own = &testing.flight }, .chase, .forward, null, .{});
    try std.testing.expectEqual(0, object.knocks);
    // The knock replaces the motion routine, so the throttle adds nothing this update.
    try std.testing.expectEqual(math.Vector{ 0.005, 0, 0 }, object.velocity.vector());
    try std.testing.expectApproxEqAbs(0.02, object.yaw_rate, 2e-4);
    try std.testing.expectApproxEqAbs(0, object.pitch_rate, 2e-4);
    try std.testing.expectApproxEqAbs(0, object.roll_rate, 2e-4);
    try std.testing.expect(object.root.next_orientation[2] > 0);
    try std.testing.expectEqual(math.Vector{ 0, 0, 0 }, object.impulse.vector());
    try std.testing.expectEqual(math.Vector{ 0, 0, 0 }, object.angular_impulse.vector());
}

test knockLocal {
    // Facing +X, a push forward in its own frame moves the object along +X.
    var object = testing.object();
    object.root.orientation = math.rotation(.y, std.math.pi / 2.0);
    object.rotation = math.identity;
    object.mass = 2;
    knockLocal(&object, .{ 0, 0, 4 }, .{ 0, 0, 0 });
    applyKnocks(&object);
    try std.testing.expectApproxEqAbs(2, object.velocity.x, 1e-6);
    try std.testing.expectApproxEqAbs(0, object.velocity.z, 1e-6);
    // With no lever, it doesn't turn.
    try std.testing.expectEqual(0, object.yaw_rate);
}

test blinkOffset {
    var random: Random = .{};
    for (0..1000) |_| {
        const offset = blinkOffset(&random);
        try std.testing.expect(offset >= 0 and offset <= 100);
    }
    // The largest number makes 100: its share rounds up to 1 in single precision.
    try std.testing.expectEqual(1, Random.share(Random.max));
}

test rechargeShields {
    var object = testing.object();
    object.shield_factor = 1;
    object.shield_condition = 1;
    const combat = std.mem.zeroInit(create.ShipCombat, .{ .shield_power = 8, .shield_recharge = 10 });
    // From empty, the full charge, 47, comes back over the ten seconds of steps, and no further.
    for (0..249) |_| rechargeShields(&object, &combat, null);
    try std.testing.expect(object.shields.left < 47);
    rechargeShields(&object, &combat, null);
    try std.testing.expectApproxEqAbs(47, object.shields.left, 1e-3);
    rechargeShields(&object, &combat, null);
    try std.testing.expectEqual(47, object.shields.left);
    // With shields shifted aft beyond its full charge, the fore one charges only as far as the
    // full charge less the excess.
    object.shields = .{ .left = 47, .right = 47, .fore = 45, .aft = 40 };
    rechargeShields(&object, &combat, .{ .aft = 9 });
    try std.testing.expectEqual(45, object.shields.fore);
    // One holding the power-up that stops them recharges none.
    object.shields = .all(0);
    object.power_up = .no_shield_recharge;
    rechargeShields(&object, &combat, null);
    try std.testing.expectEqual(Quadrants.all(0), object.shields);
    object.power_up = .none;
    // An object whose `invulnerable` is `_unknown_5` loses its shields.
    object.invulnerable = ._unknown_5;
    rechargeShields(&object, &combat, null);
    try std.testing.expectEqual(Quadrants.all(0), object.shields);
}

test "a step updates and moves every live object" {
    const gpa = std.testing.allocator;
    var mission: testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    const all = mission.objects;
    const player = try mission.add(.of(.predator), @splat(0));
    const other = try mission.add(.of(.sabre), .{ 0, 0, 1000 });
    const off = try mission.add(.of(.sabre), .{ 0, 0, 2000 });
    all.slots[other].object.throttle = 1;
    all.slots[off].object.throttle = 1;
    all.slots[off].object.flags.disabled = true;
    // Its shields down, the player's recharge.
    all.slots[player].object.shields = .all(0);
    var devices: input.Devices = .{};
    var steps: usize = 0;
    for (0..ticks_per_step * 10) |_| {
        if (gameTick(&mission.clock, &devices, mission.world())) steps += 1;
    }
    try std.testing.expectEqual(10, steps);
    // The other ship has flown on along its nose, its committed place a step behind.
    const flown = all.slots[other].object.root;
    try std.testing.expect(flown.next_position.z > 1000);
    try std.testing.expect(flown.position.z > 1000 and flown.position.z < flown.next_position.z);
    // The disabled one is passed over: never moved, nothing committed.
    try std.testing.expectEqual(2000, all.slots[off].object.root.next_position.z);
    try std.testing.expect(!all.slots[off].object.root.flags.next_pending);
    // No key held, the player's throttle stays at nothing, and it stays where it was.
    try std.testing.expectEqual(0, all.slots[player].object.root.next_position.z);
    try std.testing.expect(all.slots[player].object.shields.left > 0);
}

test "the countdown loses a second every hundred ticks" {
    const gpa = std.testing.allocator;
    var mission: testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    var variables: @import("../vm.zig").Variables = .{ .countdown = 110 };
    var world = mission.world();
    world.variables = &variables;
    var devices: input.Devices = .{};
    for (0..countdown_ticks - 1) |_| _ = gameTick(&mission.clock, &devices, world);
    try std.testing.expectEqual(110, variables.countdown);
    _ = gameTick(&mission.clock, &devices, world);
    try std.testing.expectEqual(109, variables.countdown);
    // Paused, the mission's ticks stop, and so does the countdown.
    mission.clock.paused = true;
    for (0..countdown_ticks * 2) |_| _ = gameTick(&mission.clock, &devices, world);
    try std.testing.expectEqual(109, variables.countdown);
}

test "each object's turn comes round in rotation" {
    var clock: Clock = .{};
    var turns: [4]u32 = undefined;
    for (&turns) |*turn| turn.* = nextTurn(&clock, 3);
    try std.testing.expectEqual([4]u32{ 1, 2, 0, 1 }, turns);
    // With one object, every step is its turn.
    clock = .{};
    for (0..3) |_| try std.testing.expectEqual(0, nextTurn(&clock, 1));
}

test recentreObject {
    const gpa = std.testing.allocator;
    var mission: testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    var model: create.testing.Model = undefined;
    try model.init(gpa);
    defer model.deinit(gpa);
    const index = try mission.addWith(model.types(), .of(.predator), .{ 0, 0, 100 });
    const slot = mission.slot(index);
    try std.testing.expect(slot.object.radius > 0);
    // A part taken out of the model, as an ejection takes the ship off the pod, counts toward
    // neither the object's size nor its mass, and the object stays where it was.
    slot.model.?.parts[0].removed = true;
    slot.model.?.parts[0].hidden = true;
    recentreObject(slot);
    try std.testing.expectEqual(0, slot.object.radius);
    try std.testing.expectEqual(0, slot.object.mass);
    try std.testing.expectEqual(Vector{ 0, 0, 100 }, slot.drawn.position);
}

test nodeMass {
    const gpa = std.testing.allocator;
    var gun: create.testing.Model = undefined;
    try gun.init(gpa);
    defer gun.deinit(gpa);
    var carrier: objects.testing.Carrier = undefined;
    carrier.init(.{ 100, 0, 0 });
    carrier.parts.data[0].part.volume = 5;
    carrier.parts.data[0].part.density = 2;
    var model = try carrier.build(gpa, &gun);
    defer model.deinit(gpa);
    // The part's own 10, and the 6 of the one part of the gun mounted on it.
    try std.testing.expectEqual(16, nodeMass(&model, 0));
    // The gun's part hidden counts for nothing.
    model.mounts[0].model.parts[0].hidden = true;
    try std.testing.expectEqual(10, nodeMass(&model, 0));
}

test "recentre counts the models mounted on the parts" {
    const gpa = std.testing.allocator;
    var gun: create.testing.Model = undefined;
    try gun.init(gpa);
    defer gun.deinit(gpa);
    // A hull of mass 10 carrying a gun of mass 6, a square 200 across, 100 along X.
    var carrier: objects.testing.Carrier = undefined;
    carrier.init(.{ 100, 0, 0 });
    carrier.parts.data[0].part.volume = 5;
    carrier.parts.data[0].part.density = 2;
    var model = try carrier.build(gpa, &gun);
    defer model.deinit(gpa);
    recentre(&model, &carrier.parts.source);
    // The centre lies six sixteenths of the way to the gun, and the gun's square widens the bounds.
    try std.testing.expectEqual(16, model.mass);
    try std.testing.expectEqual(Vector{ 37.5, 0, 0 }, model.centre);
    try std.testing.expectEqual(Vector{ -37.5, -100, 0 }, model.bounds[0]);
    try std.testing.expectEqual(Vector{ 162.5, 100, 0 }, model.bounds[1]);
    try std.testing.expectApproxEqAbs(@sqrt(162.5 * 162.5 + 100.0 * 100.0), model.radius, 1e-3);

    // Turned a quarter turn about Y, the gun's square stands across Z instead.
    var turned: objects.testing.Carrier = undefined;
    turned.init(.{ 100, 0, 0 });
    turned.attachments[0].orientation = math.rotation(.y, std.math.pi / 2.0);
    var other = try turned.build(gpa, &gun);
    defer other.deinit(gpa);
    recentre(&other, &turned.parts.source);
    try std.testing.expectApproxEqAbs(other.bounds[0][0], other.bounds[1][0], 1e-3);
    try std.testing.expectApproxEqAbs(200, other.bounds[1][2] - other.bounds[0][2], 1e-3);
}

test orthonormalizeTurn {
    // A skewed next orientation comes back square, keeping its forward axis.
    var root: Node = std.mem.zeroes(objects.Node);
    root.next_orientation = .{ 1.01, 0.02, 0, 0, 0.99, 0, 0.01, 0, 1 };
    orthonormalizeTurn(&root);
    const m = root.next_orientation;
    const back = math.product(math.transpose(m), m);
    try math.testing.expectMatrixWithin(math.identity, back, 1e-6);
    try std.testing.expectEqual(0, m[2]);
    try std.testing.expectEqual(0, m[5]);
}

test "where an object stands, and where it will stand at the next step" {
    var object = testing.object();
    object.root.position = .{ .x = 1, .y = 2, .z = 3 };
    object.root.next_position = .{ .x = 4, .y = 5, .z = 6 };
    try std.testing.expectEqual(Vector{ 1, 2, 3 }, object.position());
    try std.testing.expectEqual(Vector{ 4, 5, 6 }, object.nextPosition());
}