create.zig

//! `C:\lancer\game\Create.cpp`: creating live objects. `create_object` (`0x00466C10`) fills a slot
//! of `game_objects`, which OpenReliant keeps in `Objects`, with an object of a ship type, and
//! `objects_reset` (`0x00466630`) fills every slot with a stand-in as a mission starts.
//! `stats_load_ships` (`0x00466500`) fills `ship_flight_stats` and `ship_combat_stats` from
//! `shipstats.bin`, [`formats/stats.zig`](../../formats/stats.zig).
//! [`create/models.zig`](create/models.zig) names each ship type's and attachment's models,
//! [`create/flight.zig`](create/flight.zig) and [`create/combat.zig`](create/combat.zig) hold the
//! flight and combat stats' words that the executable keeps, and
//! [`create/library.zig`](create/library.zig) reads the models the types and their attachment
//! points use. **Unverified:** the loader, `objects_reset`, `ship_type_load` and the
//! ship type table lie between `collision.cpp`'s code and data and this file's, and `object_reset`
//! and `objects_update` after this file's known code, before `environfx.cpp`'s.

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

const engine = @import("../../engine.zig");
const hooks = @import("../hooks.zig");
const shp = @import("../../formats/shp.zig");
const stats = @import("../../formats/stats.zig");
const math = @import("../surrender/math.zig");
const Vector = math.Vector;
const Pointer = engine.Pointer;
const Random = @import("../random.zig").Random;
const ai = @import("ai.zig");
const ailand = @import("ailand.zig");
const camera = @import("camera.zig");
const cloak = @import("cloak.zig");
const aigeneric = @import("aigeneric.zig");
const collision = @import("collision.zig");
const gameobj = @import("gameobj.zig");
const gameflow = @import("gameflow.zig");
const guns = @import("guns.zig");
const missiles = @import("missiles.zig");
const WingSlots = @import("mission.zig").WingSlots;
const GameObject = gameobj.GameObject;
const main = @import("main.zig");
const motion = @import("motion.zig");
const objects = @import("objects.zig");
const Order = @import("ai/orders.zig").Order;
const pilots = @import("pilots.zig");
const shield = @import("shield.zig");
const environfx = @import("environfx.zig");
const explode = @import("explode.zig");
const smoke = @import("main/smoke.zig");
const srofiles = @import("srofiles.zig");
const table = @import("table.zig");
const Retired = @import("main/retired.zig").Retired;
const wgate = @import("wgate.zig");
const xtrabits = @import("xtrabits.zig");
const additions = @import("additions.zig");

pub const models = @import("create/models.zig");
pub const flight_stats = @import("create/flight.zig");
pub const combat_stats = @import("create/combat.zig");
pub const library = @import("create/library.zig");
pub const atmosphere = @import("create/atmosphere.zig");
pub const planets = @import("create/planets.zig");
pub const escort = @import("create/escort.zig");
pub const extra = @import("create/extra.zig");

/// Ship types: the records of `shipstats.bin`, and the entries of the tables they index. Types
/// above the last have no stats, markers and nav points among them, except the types mods add
/// (`max_ship_types`).
pub const ship_type_count = 256;

/// The ship types the tables hold rows for: the game's, then the types mods add, up to the
/// markers (`additions.ships`).
pub const max_ship_types = additions.ships.end;

/// A ship type's row in the tables, the game's types' and the mods'.
pub const TypeIndex = u16;

/// The files of ship type `number`'s model and schematic: the game's (`models.ship_types`), or a
/// mod's type's, whose schematic is its base's where it names none.
pub fn shipFiles(number: TypeIndex) models.ShipType {
    if (additions.ships.get(number)) |added| return .{
        .model = added.extra.model,
        .schematic = added.extra.schematic orelse models.ship_types[@backingInt(added.base)].schematic,
    };
    return if (number < models.ship_types.len) models.ship_types[number] else .{ .model = null, .schematic = null };
}

/// `ship_flight_stats` (`0x004F9E70`) and `ship_combat_stats` (`0x004FC670`): each ship type's
/// flight model and combat stats, which `create_object` points each object of the type at.
pub const Stats = struct {
    flight: [max_ship_types]FlightModel,
    combat: [max_ship_types]ShipCombat,
    /// OpenReliant's own: how the player lands on each type's ships, which each new object of the
    /// type starts with (`Slot.landing`); null where the player can't land on them.
    landing: [max_ship_types]?ailand.Style,

    /// The tables as the executable holds them before `stats_load_ships` runs: every figure zero,
    /// and each record's own words, how the AI turns the type and what its combat record says it
    /// is, with the landing the game offers on it (`ailand.Style.original`).
    pub const initial: Stats = built: {
        @setEvalBranchQuota(ship_type_count * 30);
        var tables: Stats = .{
            .flight = @splat(std.mem.zeroes(FlightModel)),
            .combat = @splat(std.mem.zeroes(ShipCombat)),
            .landing = @splat(null),
        };
        for (tables.flight[0..ship_type_count], 0..) |*flight, ship_type| flight.turns = flight_stats.turns(ship_type);
        for (tables.combat[0..ship_type_count], combat_stats.ship_types) |*record, static| record.take(static);
        for (tables.landing[0..ship_type_count], 0..) |*landing, ship_type| landing.* = ailand.Style.original(@fromBackingInt(ship_type));
        break :built tables;
    };

    /// `stats_load_ships` (`0x00466500`): each record of `shipstats.bin` in turn fills in its
    /// type's figures, up to the last type, and then every type's `speed_per_pitch_rate` is worked
    /// out. How each type turns stays as the executable has it. The combat stats keep in whole numbers what the runtime's `__ftol` cuts the record's
    /// figures down to, and a `shield_recharge` of zero becomes
    /// `stats.Ship.default_shield_recharge`.
    pub fn load(tables: *Stats, ships: []align(1) const stats.Ship) void {
        const count = @min(ships.len, max_ship_types);
        for (tables.flight[0..count], tables.combat[0..count], ships[0..count]) |*flight, *record, ship| {
            flight.max_speed = ship.max_speed;
            flight.roll_rate = ship.roll_rate;
            flight.pitch_rate = ship.pitch_rate;
            flight.yaw_rate = ship.yaw_rate;
            flight.inertia = ship.inertia;
            flight.roll_inertia = ship.roll_inertia;
            flight.pitch_inertia = ship.pitch_inertia;
            flight.yaw_inertia = ship.yaw_inertia;
            record.shield_power = std.math.lossyCast(i32, ship.shield_power);
            record.armor_class = std.math.lossyCast(i32, ship.armor_class);
            record.afterburner_fuel = std.math.lossyCast(i32, ship.afterburner_fuel);
            record.shield_recharge = if (ship.shield_recharge == 0) stats.Ship.default_shield_recharge else ship.shield_recharge;
            record.gun_energy = ship.gun_energy;
            record.gun_recharge = ship.gun_recharge;
            record.rounds = std.math.lossyCast(i32, ship.rounds);
        }
        for (&tables.flight) |*flight| flight.speed_per_pitch_rate = flight.max_speed / flight.pitch_rate;
    }

    /// OpenReliant's: gives each type the mods add (`additions.ships`) its base's way of turning.
    /// Its figures come from its record (`load`), and its words from its type record
    /// (`loadTypes`).
    pub fn addTypes(tables: *Stats) void {
        for (additions.ships.all(), additions.ships.first..) |added, number| {
            tables.flight[number].turns = tables.flight[@backingInt(added.base)].turns;
        }
    }

    /// OpenReliant's: gives each type the words of its type record (`typeRecords`), which the mods'
    /// scripts can change (`records.ship_types`), and the landing the record offers.
    ///
    /// **Improvement:** the game keeps them fixed in its executable.
    pub fn loadTypes(tables: *Stats, types: []const combat_stats.Static) void {
        const count = @min(types.len, max_ship_types);
        for (tables.combat[0..count], tables.landing[0..count], types[0..count]) |*record, *landing, static| {
            record.take(static);
            landing.* = static.landing;
        }
    }

    /// What `create_object` does for a type that is `from` under another number (`donor`): the
    /// type takes `from`'s flight model and its combat stats, save for its own gun groups and
    /// name.
    fn borrow(tables: *Stats, ship_type: TypeIndex, from: TypeIndex) void {
        const own = tables.combat[ship_type];
        tables.combat[ship_type] = tables.combat[from];
        tables.combat[ship_type].gun_groups = own.gun_groups;
        tables.combat[ship_type].gun_group_table = own.gun_group_table;
        tables.combat[ship_type].name = own.name;
        tables.flight[ship_type] = tables.flight[from];
    }
};

/// The type records that the mods' scripts can change (`records.ship_types`, `Stats.loadTypes`):
/// the words the executable holds for each of the game's types (`combat_stats.Static`), then one
/// for each type a mod adds, copied from its base's, with its own name where the mod gives one.
/// Each holds the landing its type offers before scripts change it (`ailand.Style.of`).
pub fn typeRecords(arena: Allocator) Allocator.Error![]combat_stats.Static {
    const made = try additions.ships.records(combat_stats.Static, arena, &combat_stats.ship_types, 0);
    for (made[additions.ships.first..], additions.ships.all()) |*record, added| {
        if (added.label_string) |name| record.name = name;
    }
    for (made, 0..) |*record, number| record.landing = ailand.Style.of(@fromBackingInt(@as(u32, @intCast(number))));
    return made;
}

/// The ship type a type is under another number, or null for none, as for a type a mod adds
/// (`create_object`): the Krasnaya, the Kiev, the Mitchell, the Zakov, the Kestrel and the Mammoth
/// are each more than one type, one model under several numbers. An object of such a type takes
/// the stats of the first (`Stats.borrow`), and then its number.
pub fn donor(ship_type: gameobj.Type) ?gameobj.Type {
    const game_type = ship_type.gameType() orelse return null;
    const first: gameobj.GameType = switch (game_type) {
        .kozlov, .bokov, .bulatov => .krasnaya,
        .morzov, .kirov, .shinnik, .kovtun => .kiev,
        .other_mitchell => .mitchell,
        .ufelsky, .kresta, .yevstafiy => .zakov,
        .churchill => .kestrel,
        .mammoth_gulliver,
        .mammoth_santa_maria,
        .mammoth_rosario,
        .mammoth_larsons_pride,
        .mammoth_brittania,
        .mammoth_sierra_madre,
        .mammoth_mayan_gold,
        .mammoth_dawn_chorus,
        .mammoth_calysto,
        .mammoth_sundown,
        .mammoth_krenna,
        .mammoth_seabound,
        .mammoth_crimson_sky,
        => .mammoth,
        else => return null,
    };
    return .of(first);
}

/// How a ship or a missile flies. `ship_flight_stats` holds one per ship, `missile_flight_stats`
/// one per missile; a missile's has only its speed and rates set.
pub const FlightModel = extern struct {
    /// `Ship.max_speed`, or `Missile.speed`.
    max_speed: f32,
    /// `Ship.roll_rate`, or `Missile.turn_rate`.
    roll_rate: f32,
    /// `Ship.pitch_rate`, or `Missile.turn_rate`.
    pitch_rate: f32,
    /// `Ship.yaw_rate`, or `Missile.turn_rate`.
    yaw_rate: f32,
    /// `Ship.inertia`.
    inertia: f32,
    roll_inertia: f32,
    pitch_inertia: f32,
    yaw_inertia: f32,
    /// `max_speed / pitch_rate`, which the ship loader computes after reading the file.
    speed_per_pitch_rate: f32,
    /// How the AI turns it (`ai_steer`). No file sets it: the executable holds it for each ship
    /// type ([`create/flight.zig`](create/flight.zig)) and each missile, and the loaders leave it.
    turns: Turns,
    _unknown_26: u16,

    /// How the AI turns a ship at a point, a word the game tests for zero.
    pub const Turns = enum(u16) {
        /// Rolling the point overhead, then pitching up at it (`0x00401710`): the fighters, and
        /// some support ships, the Nanny and the limpet car among them.
        banking = 0,
        /// Pitching and yawing at it together, never rolling (`0x00401690`): the capital ships,
        /// most other types that are not fighters, and every missile but the fuel pod.
        flat = 1,
        _,
    };

    comptime {
        assert(@offsetOf(FlightModel, "inertia") == 0x10);
        assert(@offsetOf(FlightModel, "speed_per_pitch_rate") == 0x20);
        assert(@offsetOf(FlightModel, "turns") == 0x24);
        assert(@sizeOf(FlightModel) == 0x28);
    }
};

/// A ship type's defences and what it is, one per type in `ship_combat_stats`: its figures from
/// `shipstats.bin` up to `+0x1C`, which `stats_load_ships` fills in, then the gun groups, which
/// the gun code works out at run time, then words the executable holds
/// ([`create/combat.zig`](create/combat.zig)).
pub const ShipCombat = extern struct {
    /// `Ship.shield_power`, truncated.
    shield_power: i32,
    /// `Ship.armor_class`, truncated.
    armor_class: i32,
    /// `Ship.afterburner_fuel`, truncated.
    afterburner_fuel: i32,
    /// `Ship.shield_recharge`, or 10 in place of zero.
    shield_recharge: f32,
    /// `Ship.gun_energy`: the most the guns' charge holds.
    gun_energy: f32,
    /// `Ship.gun_recharge`: the seconds the guns take to charge fully, over which the guns' step
    /// adds `gun_energy * gun_factor * gun_condition` to their charge (`guns.step`).
    gun_recharge: f32,
    /// `Ship.rounds`, truncated: the rounds a new object's guns have (`GameObject.rounds`).
    rounds: i32,
    /// The type's guns in groups, which `0x004667F0` works out from its first object's guns,
    /// pairing each gun with its mirror image across the ship; zero until then (#131).
    gun_groups: i16,
    _unknown_1e: u16,
    /// The groups, `0x00545900 + type * 0x78`, set with `gun_groups`.
    gun_group_table: Pointer(anyopaque),
    targeting: Targeting,
    /// The language string that names the type; 0 for none (`nameString`).
    name: u16,
    class: Class,
    /// The side the type's objects start on.
    side: gameobj.Side(i16),
    /// Which form of the target display shows the type's objects.
    display: TargetDisplay,

    /// Which form of the target display shows a type's objects: the small window
    /// (`hud.windows.Window.target`) for fighters and most small craft, the large one
    /// (`Window.big_target`) for most capital and support ships. `hud_ship_status` draws a small
    /// form's schematic mirrored and a large form's as it stands.
    pub const TargetDisplay = enum(u32) {
        /// The name scripts know these values by, for a ship type's and for the target display's
        /// form.
        pub const script_name = "TargetForm";

        small = 0,
        large = 1,
        _,
    };

    pub const Targeting = packed struct(u16) {
        /// The type's objects can be picked as targets: `object_set_targetable` sets an object's
        /// `targetable` flag only where this is set.
        targetable: bool = false,
        _unknown_1: u15 = 0,
    };

    /// What a ship type is, going by the models of each class.
    pub const Class = enum(u16) {
        /// The name scripts know these values by.
        pub const script_name = "ShipClass";

        /// The player's ships, their twins, and the Coalition's fighters.
        fighter = 1,
        /// Capital ships and their wrecks, and other large bodies such as the asteroids of types
        /// 0x79 to 0x7F.
        capital = 2,
        /// Bombers, transports, tugs, escape pods, some stations: what lies between fighters and
        /// capital ships.
        support = 3,
        /// Gates, containers, satellites, beacons, pods, rock chunks and the like.
        other = 4,
        torpedo = 5,
        /// Wreckage, floating crew, doors and plates. `create_object` gives an object of the class
        /// a tenth of its mass.
        debris = 6,
        /// The proximity mine, which `create_object` gives a radius of 2000.
        mine = 7,
        planet = 8,
        _,
    };

    /// The language string that names the type, if it has one (`name`).
    pub fn nameString(combat: *const ShipCombat) ?u16 {
        return if (combat.name != 0) combat.name else null;
    }

    /// Takes the words of a type record (`static`), the ones the executable holds rather than
    /// `shipstats.bin`.
    pub fn take(combat: *ShipCombat, static: combat_stats.Static) void {
        combat.targeting = .{ .targetable = static.targetable };
        combat.name = static.name;
        combat.class = static.class;
        combat.side = @fromBackingInt(@intCast(@backingInt(static.side)));
        combat.display = static.display;
    }

    /// Six times its `armor_class`: a quadrant's full armour, which the game measures the
    /// armour's wear against. `create_object` starts each quadrant one below it.
    pub fn fullArmor(combat: *const ShipCombat) f32 {
        return @floatFromInt(combat.armor_class * 6);
    }

    /// A quadrant's armour as `create_object` fills it, one short of `fullArmor`, which the
    /// armour's conditions and warning count from (`main.armorConditions`).
    pub fn startingArmor(combat: *const ShipCombat) f32 {
        return combat.fullArmor() - 1;
    }

    /// Six times its `shield_power`: a quadrant's full shields, likewise.
    pub fn fullShields(combat: *const ShipCombat) f32 {
        return @floatFromInt(combat.shield_power * 6);
    }

    /// The afterburner's fuel of a ship of the type, in the game's ticks: its `afterburner_fuel`
    /// in seconds, which a new object starts with (`arm`, fuel pods aside) and
    /// `ResetAfterBurners` fills again.
    pub fn fullFuel(combat: *const ShipCombat) i32 {
        return combat.afterburner_fuel * main.ticks_per_second;
    }

    /// OpenReliant's: the share of its armour a ship has left, its weakest quadrant of `armor`
    /// against `fullArmor`. A ship starts a little under 1 (`startingArmor`), and one with no
    /// armour class has nothing to lose, so it stays at 1.
    pub fn armorShare(combat: *const ShipCombat, armor: gameobj.Quadrants) f32 {
        const full = combat.fullArmor();
        if (full <= 0) return 1;
        return std.math.clamp(armor.weakest() / full, 0, 1);
    }

    comptime {
        assert(@offsetOf(ShipCombat, "shield_recharge") == 0x0C);
        assert(@offsetOf(ShipCombat, "gun_groups") == 0x1C);
        assert(@offsetOf(ShipCombat, "gun_group_table") == 0x20);
        assert(@offsetOf(ShipCombat, "targeting") == 0x24);
        assert(@offsetOf(ShipCombat, "name") == 0x26);
        assert(@offsetOf(ShipCombat, "class") == 0x28);
        assert(@offsetOf(ShipCombat, "side") == 0x2A);
        assert(@offsetOf(ShipCombat, "display") == 0x2C);
        assert(@sizeOf(ShipCombat) == 0x30);
    }
};

/// An entry of `ship_types`, one for each ship type; [`create/models.zig`](create/models.zig) has
/// the names.
pub const ShipType = extern struct {
    model_name: Pointer(u8),
    schematic_name: Pointer(u8),
    /// Objects of the type, which `create_object` counts up, loading the model for the first.
    objects: u16,
    _unknown_0a: u16,
    /// The model, once loaded.
    model: Pointer(anyopaque),
    /// What its objects keep as `GameObject.type_data`: the schematic `ship_type_load` loads with
    /// the model.
    type_data: Pointer(anyopaque),

    comptime {
        assert(@offsetOf(ShipType, "model") == 0x0C);
        assert(@sizeOf(ShipType) == 0x14);
    }
};

/// An entry of `attachment_models`: what attachment points of one kind and id mount, as loaded.
/// [`create/models.zig`](create/models.zig) has the file names.
pub const MountedModel = extern struct {
    model: Pointer(anyopaque),
    /// A second model: the missile, for a missile pod.
    second_model: Pointer(anyopaque),
    /// **Unknown.** 1 unless the loader sets it.
    count: u32,
    sprite: Pointer(anyopaque),

    comptime {
        assert(@sizeOf(MountedModel) == 0x10);
    }
};

/// A ship type's model as `ship_type_load` (`0x00466740`) loads it for the type's first object.
/// It loads the type's schematic as well, which OpenReliant leaves with whoever loads the model,
/// since the display draws it.
pub const Type = struct {
    model: *const shp.Model,
    loaded: *const srofiles.Loaded,
    /// What the type's objects light themselves with and mount.
    effects: objects.Effects = .{},
    /// The type's own sprite (`GameObject.type_data`), which for a ship is its schematic, where
    /// the game has one: the ship status indicator and the target display draw it.
    schematic: ?@import("hud.zig").TypeArt = null,
    /// OpenReliant's: the display's shapes, with the pictures a mod's type gives in place of its
    /// base's wire frame on the gunnery display (`gunnery`) and of its icon in the wing's window
    /// (`wing_status`); null for a type that gives none.
    wire_frame: ?@import("hud.zig").TypeArt = null,
    wing_icon: ?@import("hud.zig").TypeArt = null,
};

/// Where ship types' models come from: whoever has the game's files answers, as for
/// `objects.Mounts`.
pub const Types = struct {
    context: *anyopaque,
    /// Null for a type with no model, or one the game lacks or cannot read; whoever answers says
    /// why.
    load: *const fn (context: *anyopaque, ship_type: TypeIndex) ?*const Type,
};

/// What `ship_types` keeps of a ship type while a mission runs: how many objects of it
/// `create_object` has made, and what it loaded for the first.
pub const TypeUse = struct {
    objects: u16 = 0,
    loaded: ?*const Type = null,
};

/// OpenReliant's: ship types whose models stay loaded for what is only drawn, such as the
/// explosions' debris (`xtrabits.firstLevels`). A mission's start keeps them loaded along with the
/// types the objects are of (`library.TypeCache.sweep`).
pub const TypeSet = std.bit_set.Static(max_ship_types);

/// The slot the loops over the objects walk after those handed out (`0x0057E04E`), which the
/// mission's start sets to 399, the last. The cutaway scenes use it: in one of them only the
/// player's ship and this slot's object are drawn.
pub const cutaway_slot: u16 = gameobj.max_objects - 1;

/// A slot of `game_objects`: the object's record, and what OpenReliant keeps beside it where the
/// record holds the original's 32-bit pointers.
pub const Slot = struct {
    object: GameObject,
    /// Its type's stats in `Stats` (`GameObject.combat`, `flight`); null for a stand-in.
    combat: ?*const ShipCombat = null,
    flight: ?*const FlightModel = null,
    /// OpenReliant's own: how the player's ship lands on it (`ailand`). It starts as its type's
    /// (`Stats.landing`), and a mission's script can change it. Null where the player can't land
    /// on it, as on a stand-in.
    landing: ?ailand.Style = null,
    /// Its type's model as loaded (`GameObject.model`), and the nodes of the model's parts, which
    /// hang from its root; null for a stand-in, or a type the game has no model for.
    type: ?*const Type = null,
    model: ?objects.Model = null,
    /// What moves it each update (`GameObject.motion`); null for nothing.
    motion: ?motion.Motion = null,
    /// The motion a jump puts aside while it flies its own, and gives back as it ends
    /// (`jump.State.motion`, which the game keeps as the routine's address).
    motion_aside: ?motion.Motion = null,
    /// How far it goes a tick where the orders place it from tick to tick rather than move it: it
    /// is drawn that much further along for the time the frame is past its tick
    /// (`objects.frameTree`). The orders set it each frame they place it, and the frame's pass
    /// lets it go (`main.frameObjects`), keeping whether it glided, so that the frame after it is
    /// drawn back where it was placed.
    glide: Vector = @splat(0),
    glided: bool = false,
    /// The glide the last game frame framed it by: `glide` while it glided or the frame after,
    /// null otherwise. A drawn frame draws it on by this for the time past the tick (`main.Drawn`).
    drawn_glide: ?Vector = null,
    /// Where its root's frame has it drawn (`objects.frameTree`), which stays put between the
    /// steps that move it.
    drawn: objects.Model.Local = .{},
    /// The node it rides while it launches (`launch.State.node`, which the game keeps as the
    /// node's address); null for none.
    riding: ?objects.NodeOf = null,
    /// Its stack of orders, the current one first, `GameObject.order_count` of them
    /// (`GameObject.orders`), which the game allocates with the object's first order.
    orders: [aigeneric.max_stack]aigeneric.Entry = @splat(std.mem.zeroes(aigeneric.Entry)),
    /// What the current order keeps between its updates (`GameObject.order_state`), allocated with
    /// the stack.
    state: aigeneric.State = .{ .bytes = @splat(0) },
    /// Its queue of orders waiting for their tick, `GameObject.queued_order_count` of them
    /// (`GameObject.queued_orders`), which the game allocates with the first (`aigeneric.queue`).
    queued: [aigeneric.max_queued]aigeneric.Queued = @splat(std.mem.zeroes(aigeneric.Queued)),
    /// Its guns, one for each muzzle of its model (`GameObject.guns`), made in the objects'
    /// allocator.
    guns: []guns.Fitted = &.{},
    /// Its type's gun groups (`ShipCombat.gun_group_table`), in `Objects.gun_groups`.
    gun_groups: *const [guns.max_groups]guns.Group = &guns.no_groups,
    /// The parts of its model that count as components, `GameObject.component_count` of them, the
    /// models mounted on it among them (`GameObject.components`, which holds their nodes).
    components: [gameobj.max_components]?*objects.Model.Part = @splat(null),
    /// Its shields' bubble (`GameObject.render`), which a ship that lists no components and is not
    /// debris has.
    shield: ?*shield.Bubble = null,
    /// Its cloak, from the moment it starts to come on until it has gone (`GameObject.cloak`).
    cloak: ?cloak.Cloak = null,
    /// Its smoke, while its damage shows (`GameObject.smoke`).
    smoke: ?smoke.Stream = null,
    /// What its type carries on one of its parts beyond its model, such as the Dark Reign's hat
    /// (`extra.Extra`, which the game hangs on the part's frame).
    extra: ?*extra.Extra = null,

    /// Lets go of what the slot holds for its object: its cloak (`cloak.drop`), its model, its
    /// guns, its shield bubble and its extra (`object_free`). The extra, which a drawn frame's copy
    /// shares, goes through `retired`.
    pub fn release(slot: *Slot, gpa: Allocator, retired: ?*Retired) void {
        cloak.drop(slot);
        if (slot.model) |model| model.deinit(gpa);
        slot.dropGuns(gpa);
        slot.dropShield(gpa);
        if (slot.extra) |held| Retired.destroy(retired, gpa, held);
        slot.extra = null;
    }

    /// OpenReliant's: points the slot, a copy of `from`, at copies made in `arena` of the records
    /// `from` holds that the game changes as it runs: its guns, its shield bubble, and its model
    /// (`objects.Model.copy`), its components among the copy's parts.
    pub fn copyRecords(slot: *Slot, arena: Allocator, from: *const Slot) Allocator.Error!void {
        slot.guns = try arena.dupe(guns.Fitted, from.guns);
        if (from.shield) |bubble| slot.shield = try table.copyRecord(shield.Bubble, arena, bubble);
        const original = if (from.model) |*held| held else return;
        const copied = &slot.model.?;
        copied.* = try original.copy(arena);
        for (slot.components[0..slot.listed().len]) |*entry| {
            if (entry.*) |part| entry.* = original.counterpart(copied, part);
        }
    }

    /// Its current order, the first of its stack, where it has one (`stack`): as mutable as
    /// `slot` is.
    pub fn current(slot: anytype) ?@TypeOf(&slot.orders[0]) {
        if (slot.object.order_count <= 0) return null;
        return &slot.orders[0];
    }

    /// Its current order (`current`), where it is `order`: as mutable as `slot` is.
    pub fn running(slot: anytype, order: Order) ?@TypeOf(&slot.orders[0]) {
        const entry = slot.current() orelse return null;
        return if (entry.order == order) entry else null;
    }

    /// Its stack of orders, the current one first: `GameObject.order_count` of them, none for a
    /// count below 0 and no more than the stack holds: as mutable as `slot` is.
    pub fn stack(slot: anytype) Entries(@TypeOf(slot)) {
        const count = std.math.cast(usize, slot.object.order_count) orelse 0;
        return slot.orders[0..@min(count, slot.orders.len)];
    }

    /// The entries of a stack, as mutable as the slot pointed at by `SlotPointer` is.
    fn Entries(comptime SlotPointer: type) type {
        return if (@typeInfo(SlotPointer).pointer.attrs.@"const") []const aigeneric.Entry else []aigeneric.Entry;
    }

    /// The orders waiting in its queue: `GameObject.queued_order_count` of them, none for a count
    /// below 0 and no more than the queue holds.
    pub fn waiting(slot: *Slot) []aigeneric.Queued {
        const count = std.math.cast(usize, slot.object.queued_order_count) orelse 0;
        return slot.queued[0..@min(count, slot.queued.len)];
    }

    /// The first entry of its stack that is `order`, where there is one (`player_control_entry`,
    /// `0x00402860`, and `launch_start`, `0x00418DB0`).
    pub fn firstOrder(slot: *Slot, order: Order) ?*aigeneric.Entry {
        for (slot.stack()) |*entry| {
            if (entry.order == order) return entry;
        }
        return null;
    }

    /// The parts it lists as components, `GameObject.component_count` of them.
    pub fn listed(slot: *const Slot) []const ?*objects.Model.Part {
        return slot.components[0..@intCast(@max(slot.object.component_count, 0))];
    }

    /// Its component `n`, where it lists one there.
    pub fn component(slot: *const Slot, n: usize) ?*objects.Model.Part {
        const parts = slot.listed();
        return if (n < parts.len) parts[n] else null;
    }

    /// Where `part`, one of its model's parts or of a model that model carries, stands in the
    /// world, its frame brought up to date with those it hangs from (`SR_object_concate_parents`,
    /// `0x004C3570`), the root at its drawn place; null for an object without a model, or a part of
    /// neither.
    pub fn partPlace(slot: *Slot, part: *const objects.Model.Part) ?math.Place {
        const model = if (slot.model) |*live| live else return null;
        return model.placeOf(slot.drawn, part, .now);
    }

    /// `object_component_index` (`0x0045ADE0`): where it lists `part` among its components, by
    /// which the mission's events and its triggers name a component; null where it does not.
    pub fn componentIndex(slot: *const Slot, part: *const objects.Model.Part) ?u8 {
        for (slot.listed(), 0..) |entry, n| {
            if (entry == part) return @truncate(n);
        }
        return null;
    }

    /// The number `collectComponents` gave `part`, which the mission's events and triggers use for
    /// it; null for a part that isn't a component. Unlike `componentIndex`, it still works after the
    /// part is destroyed and removed from the list (`objects.destroyPart`).
    ///
    /// **Improvement:** the original only finds the number of a component that is still listed
    /// (`componentIndex`). Scripts read it after that too.
    pub fn componentNumber(slot: *Slot, part: *const objects.Model.Part) ?u8 {
        const model = if (slot.model) |*live| live else return null;
        if (!part.component) return null;
        const Counting = struct {
            sought: *const objects.Model.Part,
            counted: usize = 0,
            found: bool = false,

            fn visit(counting: *@This(), each: *objects.Model.Part) bool {
                if (each == counting.sought) {
                    counting.found = true;
                    return false;
                }
                counting.counted += 1;
                return counting.counted < gameobj.max_components;
            }
        };
        var counting: Counting = .{ .sought = part };
        _ = eachComponent(model, &counting);
        return if (counting.found) @intCast(counting.counted) else null;
    }

    /// Lets its guns go: it has none from now on.
    pub fn dropGuns(slot: *Slot, gpa: Allocator) void {
        gpa.free(slot.guns);
        slot.guns = &.{};
        slot.object.gun_count = 0;
    }

    /// Lets its shield bubble go: it has none from now on.
    pub fn dropShield(slot: *Slot, gpa: Allocator) void {
        if (slot.shield) |bubble| bubble.destroy(gpa);
        slot.shield = null;
    }

    /// How many groups of guns its type has (`ShipCombat.gun_groups`); none for a stand-in.
    pub fn groupCount(slot: *const Slot) i16 {
        const combat = slot.combat orelse return 0;
        return combat.gun_groups;
    }

    /// Draws the object at `size` of its own, as `explode_asteroid` makes its fragments: its
    /// `visibility`, which scales the sphere it collides by and how far off it is drawn, and the
    /// scale its model's first part is drawn at (that part's frame's `+0x48`).
    pub fn shrink(slot: *Slot, size: f32) void {
        slot.object.visibility = size;
        const model = if (slot.model) |*live| live else return;
        model.visibility = size;
        if (model.parts.len > 0) model.parts[0].object.scale = size;
    }

    /// The gun type leading its group `group` (`guns.groupLead`).
    pub fn groupLead(slot: *const Slot, group: usize) ?guns.GunType {
        return guns.groupLead(slot.guns, slot.gun_groups, group);
    }

    /// Its guns and their groups, for firing them from `frame_start` (`guns.fire`).
    pub fn trigger(slot: *const Slot, frame_start: i32) guns.Trigger {
        return .{ .fitted = slot.guns, .groups = slot.gun_groups, .frame_start = frame_start };
    }
};

/// `game_objects` (`0x00587CE0`), the GO array: 400 slots, none ever empty. As a mission starts
/// every slot gets a stand-in (`reset`), and `create_object` fills them with objects
/// (`createObject`), in turn or at the slot it is given, such as a mission ship's index among the
/// ship records. The loops over the objects walk the slots handed out, then the cutaway slot
/// (`walk`).
pub const Objects = struct {
    gpa: Allocator,
    /// OpenReliant's: where the objects' extras go as the game lets go of them, since a drawn
    /// frame's copy of the objects may still read them (`main.retired.Retired`); null lets them go
    /// at once.
    retired: ?*Retired = null,
    slots: [gameobj.max_objects]Slot,
    /// `game_object_count` (`0x00539AA0`): the slots `create_object` has handed out in turn.
    count: u16 = 0,
    /// `player_slots` (`0x0058832C`): the slots from the first that belong to players, one in a
    /// single-player game.
    players: u16 = 1,
    /// `player_index` (`0x005883FA`): the player's slot, the first in a single-player game.
    player: u16 = 0,
    /// `camera_marker` (`0x00588390`): the slot of the camera's marker, which the mission's start
    /// makes in the slot after the mission's ships, and which the Yamato's launch moves beside the
    /// player's bay; null until a mission's start makes it.
    camera_marker: ?u16 = null,
    /// `bombard_planet` (`0x005531A8`): the slot of the last Titan made, on which Planet Bombard's
    /// flashes burst (`environfx.bombard`); null until one is made.
    bombarded: ?u16 = null,
    types: [max_ship_types]TypeUse = @splat(.{}),
    /// Each ship type's gun groups (`0x00545900`), which `gun_groups_build` works out from an
    /// object of the type.
    gun_groups: [max_ship_types][guns.max_groups]guns.Group = @splat(@splat(.{})),
    /// `gun_stats` (`0x00500CA4`): every gun type's figures, which `stats_load_guns` fills from
    /// `gunstats.bin`.
    gun_stats: guns.Stats = .initial,
    /// `missile_stats` and `missile_flight_stats`: every missile type's figures, which
    /// `stats_load_missiles` fills from `missilestats.bin`.
    missile_stats: missiles.Table = .initial,
    /// `campaign_tier` (`0x00562DF0`): the loadout tier the campaign has reached, which a fighter
    /// asked for none is fitted by. 0 for a new pilot; the missions after the 11th, 19th and 21st
    /// raise it to 1, 2 and 3 (`mission_end_record`).
    campaign_tier: u2 = 0,
    /// The pilots of the player's wing and the pool of their replacements (`alpha_pilots`,
    /// `pilot_pool`), which the game keeps in `pilots.cpp`'s globals. OpenReliant keeps them here
    /// too, as it keeps the campaign's tier.
    wingmen: pilots.Wingmen = .{},
    /// `pilot_stats` (`0x0058A968`): every pilot, which `stats_load_pilots` fills from
    /// `pilotstats.bin`.
    pilots: pilots.Table = .{},
    /// `pilot_faces` (`0x005048D8`): every pilot's face, which the game keeps in its data and
    /// OpenReliant loads from the records.
    faces: pilots.Faces = .{},
    /// The shots in flight (`0x00563148`), which the game keeps in `guns.cpp`'s own globals.
    /// OpenReliant keeps them here, beside the objects they fly among.
    bullets: guns.Bullets = .{},
    /// The missiles in flight (`0x005887F0`), which the game keeps in `missiles.cpp`'s own globals.
    /// OpenReliant keeps them here too.
    missiles: missiles.Missiles = .{},
    /// The player's wing (`player_wing`, `0x00515D88`), which the game keeps in `mission.cpp`'s
    /// own globals and a mission lists (`mission.listPlayerWing`). OpenReliant keeps it here too.
    wing: WingSlots = @splat(null),
    /// The working lists of the collision sweep `objectsUpdate` runs.
    sweep: Sweep = .{},
    /// `0x005185AC`: the tick at which `aigeneric.ordersUpdate` next clears what every object has
    /// lately taken.
    damage_cleared_at: u32 = 0,
    /// `mission_number` (`0x00562DC8`): the number of the mission being played, from 1, or 0 for
    /// OpenReliant's mission 0. The game singles some missions out by it, which OpenReliant asks of
    /// the mission's settings instead (`rules`). The launch's caption and the objectives go by it,
    /// and Instant Action's mission and the training missions (`training`) have rules of their own.
    mission_number: u16 = 0,
    /// `mission25_second_part` (`0x00587CDC`): whether mission 25's first part is won and its
    /// second is played, before which the player flies a Kamov.
    mission25_second_part: bool = false,
    /// `0x005883F8`: set while the player's ship is inside a Stalag, having crossed into one of the
    /// Stalag's trigger polygons and not out again (`collision.crossTriggers`), which `holdsPlayer`
    /// reads. A mission's start clears it (`0x004935D7`).
    in_stalag: bool = false,
    /// The simulator the front end runs the mission in, where it does.
    simulator: Simulator = .{},
    /// The ship the loadout screen chose for each player's slot (`player_loadouts`, `0x00588400`,
    /// the first word of each), which `create_object` makes the player's ship of (`slotType`).
    /// OpenReliant's driver sets the player's from the loadout, from `--ship`, or as the test keys
    /// change it; where it sets none, the mission's own kind stands.
    loadout_ships: [max_loadouts]?gameobj.Type = @splat(null),
    /// The racks the loadout screen fitted for each player's slot (`player_loadouts + 4` on),
    /// which `create_object` and a re-arm fit a player's ship with outside the simulator
    /// (`loadoutRacks`); null where the mission starts without its briefing and loadout
    /// (`skip_briefing`, `0x005883B4`), when the ship is fitted by a tier instead.
    loadout_racks: [max_loadouts]?Racks = @splat(null),
    /// `0x005185A8`, while the byte at `0x005185B1` is set: the number the next order pushed takes
    /// (`aigeneric.Entry.sequence`), as `SetAI` numbers a group's orders
    /// (`aigeneric.startNumbering`); null otherwise, when an order takes 0.
    order_number: ?i32 = null,
    /// The sphere the action keeps to.
    action_sphere: aigeneric.ActionSphere = .default,
    /// The ships whose engine exhaust burns the player's ship, which the game keeps in
    /// `environfx.cpp`'s own globals. OpenReliant keeps them here, as `create_object` adds to them.
    exhaust: environfx.Exhaust = .{},
    /// OpenReliant's: the mods' scripts, which the hooked functions and events call while a game
    /// runs; null without them.
    scripts: ?*hooks.Scripts = null,
    /// OpenReliant's: how often each slot has had its object replaced, which the scripts' object
    /// handles keep, so that a handle to an object that has gone is no longer valid. A slot's count
    /// goes up as `create_object` fills it and as its object is removed (`resetSlot`, `retire`),
    /// and every slot's as a mission starts (`reset`).
    reuses: [gameobj.max_objects]u32 = @splat(0),

    /// Every slot standing in, as a mission's start leaves them (`reset`), made in `gpa`.
    pub fn create(gpa: Allocator, random: *Random) Allocator.Error!*Objects {
        const all = try gpa.create(Objects);
        all.* = .{ .gpa = gpa, .slots = @splat(.{ .object = undefined }) };
        all.reset(random);
        return all;
    }

    pub fn destroy(all: *Objects) void {
        all.missiles.reset(all.gpa);
        for (&all.slots) |*slot| slot.release(all.gpa, all.retired);
        all.gpa.destroy(all);
    }

    /// OpenReliant's: makes `drawn` a copy of the objects for drawing to work on (`main.Drawn`),
    /// with the models, the guns and the shield bubbles of the objects and the missiles copied into
    /// `arena` (`Slot.copyRecords`). The copy runs no scripts, so nothing drawing calls runs a mod's
    /// hook. It shares the objects' extras with the game, which leaves them as they were made and
    /// lets them go through `retired`: drawing only reads them, and makes what an extra shows for
    /// each frame (`extra.Glow.drawn`, `extra.Hanging.placed`).
    pub fn copyInto(all: *const Objects, drawn: *Objects, arena: Allocator) Allocator.Error!void {
        drawn.* = all.*;
        drawn.scripts = null;
        for (&drawn.slots, &all.slots) |*slot, *live| try slot.copyRecords(arena, live);
        for (&drawn.missiles.records, &all.missiles.records) |*record, *live| {
            if (record.*) |*missile| try missile.slot.copyRecords(arena, &live.*.?.slot);
        }
    }

    /// `objects_reset` (`0x00466630`), as a mission starts: every slot gets a new stand-in, of
    /// `gameobj.Type.stand_in` and flagged `stand_in` (`object_alloc`), no slot is handed out, and
    /// no ship type has objects or a model loaded. OpenReliant lets go of the objects' nodes as
    /// well, which the game frees as the mission before ends.
    ///
    /// The planets' atmospheres, whose texture it loads and whose table it empties, are
    /// `atmosphere.Atmospheres`.
    pub fn reset(all: *Objects, random: *Random) void {
        for (&all.slots) |*slot| {
            slot.release(all.gpa, all.retired);
            var object = gameobj.objectAlloc(.of(.stand_in), random);
            object.flags.stand_in = true;
            slot.* = .{ .object = object };
        }
        for (&all.reuses) |*count| count.* +%= 1;
        all.types = @splat(.{});
        all.count = 0;
        all.camera_marker = null;
        all.bombarded = null;
        all.in_stalag = false;
        // The game lets the exhaust's list go as the mission before ends (`exhaust_ships_reset`).
        all.exhaust.reset();
    }

    /// Whether the object in slot `index` is a Stalag with the player's ship inside it
    /// (`in_stalag`): its turrets aim anywhere, whatever their firing arcs (`turret_aim_angles`),
    /// and its shots may strike the Stalag itself (`bullet_place`).
    pub fn holdsPlayer(all: *const Objects, index: u16) bool {
        return all.in_stalag and all.slots[index].object.type.base() == .stalag;
    }

    /// A type's model, loaded for its first object where it isn't held, and one more object of it
    /// counted, so that it stays (`create_object`). Null where the game has no model for it.
    pub fn useType(all: *Objects, types: Types, ship_type: gameobj.Type) ?*const Type {
        const use = &all.types[ship_type.number()];
        if (use.objects == 0 and use.loaded == null) use.loaded = types.load(types.context, @intCast(ship_type.number()));
        use.objects += 1;
        return use.loaded;
    }

    /// Whether the display's clock counts down (`hud.clockTime`): in Instant Action's simulator,
    /// and in mission 29 however it is flown.
    pub fn countsDown(all: *const Objects) bool {
        return all.simulator.mode == .instant_action or all.mission_number == instant_action_mission;
    }

    /// Whether the player trains: in the simulator's training (`Simulator.Mode.training`), or in
    /// one of the training missions however it is flown (`training_missions`), as each of the
    /// game's checks reads it (`simulator_mode` 1, or missions 30 to 35). The flight instructor
    /// then speaks for the carrier and clears the player's ship to land (`radio`), the player's
    /// ship takes the training's missiles (`tierFit`), and `SetInvulnerability` reaches the
    /// players' ships too.
    pub fn training(all: *const Objects) bool {
        if (all.simulator.mode == .training) return true;
        return all.mission_number >= training_missions[0] and all.mission_number <= training_missions[1];
    }

    /// What the ship in slot `index` takes on its missile hardpoints where it is fitted by its
    /// loadout tier (`object_loadout_by_tier`, `0x0045E57A` on): the missiles `tier` names, but
    /// for the player's ship in training (`training`), the training's (`training_racks`),
    /// whatever the tier.
    pub fn tierFit(all: *const Objects, index: u16, tier: u2) Fit {
        if (index == all.player and all.training()) return .{ .loadout = &training_racks };
        return .{ .tier = tier };
    }

    /// The rules the mission played follows (`gameflow.campaignField`).
    pub fn rules(all: *const Objects) gameflow.CampaignMission.Rules {
        return gameflow.campaignField(all.mission_number, .rules);
    }

    /// Whether the player's wing flies Kamovs: in a mission whose rules say so, mission 25 in the
    /// original, but not in its second part.
    pub fn kamovPart(all: *const Objects) bool {
        return all.rules().kamov_wing and !all.mission25_second_part;
    }

    /// The type `create_object` makes an object asked for as `asked` of in slot `index`: in a
    /// player's slot, a Kamov in mission 25's first part (`kamovPart`), or else the ship the
    /// loadout chose, its `t_` twin in a mission whose rules say so (`wing_twins`, from mission 14
    /// in the original); in any other slot, `asked`.
    ///
    /// Left out: in the simulator's training, a Yamato the loadout chose becomes a Reliant
    /// (`0x00466CDF`), which never happens: the training puts the player in a Grendel, and its
    /// missions fly the twins, so the type is the twin already.
    ///
    /// Not ported: a multiplayer game, where every slot takes `asked`
    /// ([#55](https://github.com/OpenReliant/openreliant/issues/55)).
    pub fn slotType(all: *const Objects, index: u16, asked: gameobj.Type) gameobj.Type {
        if (index >= all.players or index >= all.loadout_ships.len) return asked;
        if (all.kamovPart()) return .of(.kamov);
        const chosen = all.loadout_ships[index] orelse return asked;
        if (!all.rules().wing_twins) return chosen;
        return chosen.twin() orelse chosen;
    }

    /// The racks the loadout screen fitted for the player's ship in slot `index`, which a re-arm
    /// fits it with (`cmd_ReplenishWeapons`, `0x0045A055`): a player's slot but the player's own
    /// in the simulator, where the loadout ran. `create_object` passes over mission 25's first
    /// part too (`createdRacks`).
    ///
    pub fn loadoutRacks(all: *const Objects, index: u16) ?*const Racks {
        if (index >= all.players or index >= all.loadout_racks.len) return null;
        if (index == all.player and all.simulator.simulated()) return null;
        if (all.loadout_racks[index]) |*racks| return racks;
        return null;
    }

    /// The racks `create_object` fits the ship it makes in slot `index` with (`0x00467690`):
    /// the loadout's, as a re-arm takes them, but in the simulator or in mission 25's first part,
    /// when the ship is fitted by its tier.
    fn createdRacks(all: *const Objects, index: u16) ?*const Racks {
        if (all.simulator.simulated() or all.kamovPart()) return null;
        return all.loadoutRacks(index);
    }

    /// The slots the loops over the objects walk, in their order.
    pub fn walk(all: *const Objects) Walk {
        return .{ .all = all };
    }

    /// Each slot handed out, from the first, then the cutaway slot. The loops read the count at
    /// every slot, so an object created on the way is walked as well.
    ///
    /// **Improvement:** with every slot handed out, the cutaway slot comes round again and again in
    /// the game's loops, which never end; OpenReliant walks it once.
    pub const Walk = struct {
        all: *const Objects,
        at: u16 = 0,

        pub fn next(w: *Walk) ?u16 {
            if (w.at < w.all.count) {
                defer w.at += 1;
                return w.at;
            }
            if (w.at > cutaway_slot) return null;
            w.at = cutaway_slot + 1;
            return cutaway_slot;
        }
    };
};

/// The players' loadouts `player_loadouts` (`0x00588400`) holds, a slot each.
pub const max_loadouts = 8;

/// The training missions, the first and the last (immediates in `cmd_SetInvulnerability_ship` and
/// `permission_to_land`).
pub const training_missions = [2]u16{ 30, 35 };

/// Mission 29, which INSTANT ACTION flies, and whose display counts down (`0x00486206`).
pub const instant_action_mission = 29;

/// The simulator the front end runs a mission in: `simulator_mode` (`0x00524FE4`), and `simulator`
/// (`0x0057E044`), which Instant Action sets as well. Out of the simulator, the wingmen hear their
/// keys (`frame_controls`), and the player's ship takes the loadout screen's weapons
/// (`create_object`, `cmd_ReplenishWeapons`).
pub const Simulator = struct {
    mode: Mode = .none,
    /// `simulator`: set while Instant Action runs, from the main menu or the simulator pod.
    instant_action: bool = false,

    /// What the simulator runs, as the loading screen names it (`0x004AD0A0`).
    pub const Mode = enum(u8) {
        /// No simulator: PREPARING FOR LAUNCH.
        none = 0,
        /// The Reliant's simulator's training: Calibrating Simulator.
        training = 1,
        /// Instant Action, mission 29: Preparing for Instant Action.
        instant_action = 2,
        _,
    };

    /// Whether the mission is simulated.
    pub fn simulated(simulator: Simulator) bool {
        return simulator.instant_action or simulator.mode != .none;
    }
};

test "Stats.loadTypes" {
    // A type takes the class and side its record gives it, and the other types keep theirs.
    const gpa = std.testing.allocator;
    const tables = try gpa.create(Stats);
    defer gpa.destroy(tables);
    tables.* = .initial;
    var types = combat_stats.ship_types;
    const shuttle = @backingInt(gameobj.GameType.yakob_shuttle);
    const victorious = @backingInt(gameobj.GameType.victorious);
    try std.testing.expectEqual(.support, tables.combat[shuttle].class);
    // Before the records, the game's landings: the Reliant's and the Yamato's alone.
    try std.testing.expectEqual(ailand.Style.reliant, tables.landing[@backingInt(gameobj.GameType.reliant)].?);
    try std.testing.expectEqual(ailand.Style.yamato, tables.landing[@backingInt(gameobj.GameType.yamato)].?);
    try std.testing.expectEqual(null, tables.landing[victorious]);
    types[shuttle].class = .fighter;
    types[shuttle].side = .neutral;
    types[victorious].landing = .bay;
    tables.loadTypes(&types);
    try std.testing.expectEqual(.fighter, tables.combat[shuttle].class);
    try std.testing.expectEqual(.neutral, tables.combat[shuttle].side);
    try std.testing.expectEqual(ailand.Style.bay, tables.landing[victorious].?);
    try std.testing.expectEqual(combat_stats.ship_types[0].name, tables.combat[0].name);
}

test typeRecords {
    // A mod's type takes its base's words, under its own name.
    var list = [_]additions.ships.Added{
        .{ .name = "a:pot", .mod = "a", .base = .predator, .label_string = 900, .extra = .{ .model = "pot.shp" } },
        // Based on the Reliant: in its model, in a model of its own, and in its model with a bay's
        // landing.
        .{ .name = "a:refit", .mod = "a", .base = .reliant, .extra = .{ .model = "RELIANT.SHP" } },
        .{ .name = "a:ark", .mod = "a", .base = .reliant, .extra = .{ .model = "ark.shp" } },
        .{ .name = "a:dock", .mod = "a", .base = .reliant, .extra = .{ .model = "RELIANT.SHP", .landing = .{ .offers = .bay } } },
    };
    additions.ships.install(&list);
    defer additions.ships.reset();
    const made = try typeRecords(std.testing.allocator);
    defer std.testing.allocator.free(made);
    try std.testing.expectEqual(additions.ships.first + list.len, made.len);
    const pot = made[additions.ships.first];
    try std.testing.expectEqual(combat_stats.ship_types[0].class, pot.class);
    try std.testing.expectEqual(900, pot.name);
    // The game's types offer the game's landings, the Reliant's and the Yamato's alone. A mod's type
    // offers its base's in its base's model, none in a model of its own, and the one it gives.
    try std.testing.expectEqual(ailand.Style.reliant, made[@backingInt(gameobj.GameType.reliant)].landing.?);
    try std.testing.expectEqual(ailand.Style.yamato, made[@backingInt(gameobj.GameType.yamato)].landing.?);
    try std.testing.expectEqual(null, made[@backingInt(gameobj.GameType.victorious)].landing);
    try std.testing.expectEqual(null, pot.landing);
    try std.testing.expectEqual(ailand.Style.reliant, made[additions.ships.first + 1].landing.?);
    try std.testing.expectEqual(null, made[additions.ships.first + 2].landing);
    try std.testing.expectEqual(ailand.Style.bay, made[additions.ships.first + 3].landing.?);
}

test "ShipCombat.nameString" {
    var combat = std.mem.zeroes(ShipCombat);
    try std.testing.expectEqual(null, combat.nameString());
    combat.name = 1104;
    try std.testing.expectEqual(1104, combat.nameString().?);
}

test "ShipCombat.armorShare" {
    var combat = std.mem.zeroes(ShipCombat);
    combat.armor_class = 5;
    // Its weakest quadrant counts, against six times the armour class.
    try std.testing.expectEqual(0.5, combat.armorShare(.{ .left = 15, .right = 30, .fore = 30, .aft = 30 }));
    try std.testing.expectEqual(0, combat.armorShare(.all(-3)));
    // With no armour class, there's nothing to lose.
    combat.armor_class = 0;
    try std.testing.expectEqual(1, combat.armorShare(.all(0)));
}

test Simulator {
    try std.testing.expect(!(Simulator{}).simulated());
    try std.testing.expect((Simulator{ .mode = .instant_action, .instant_action = true }).simulated());
    try std.testing.expect((Simulator{ .mode = .training }).simulated());
    var all: Objects = undefined;
    all.simulator = .{};
    all.mission_number = instant_action_mission;
    try std.testing.expect(all.countsDown());
    all.mission_number = 1;
    try std.testing.expect(!all.countsDown());
    all.simulator.mode = .instant_action;
    try std.testing.expect(all.countsDown());
}

/// What goes wrong in `create_object`, which stops the game with a fatal error for either.
pub const Error = error{
    /// "Overrun in GO array": the slot is past the last, or none is left to hand out.
    Overrun,
    /// "Trying to create object %s twice".
    CreatedTwice,
} || Allocator.Error;

/// The radius `create_object` gives an object of a type above the last ship type.
pub const stand_in_radius: f32 = 4000;

/// The pilot `create_object` gives the Coalition's types, record 66 of `pilotstats.bin`; every
/// other type gets record 0.
pub const coalition_pilot = 66;

/// A mine's radius (`ShipCombat.Class.mine`).
const mine_radius: f32 = 2000;

/// What a piece of debris's mass is scaled by (`ShipCombat.Class.debris`).
const debris_mass: f32 = 0.1;

/// A wreck's part that burns (`create_object`, `0x00466C10`): its name, and whether it shows first,
/// as a Badanov's half is hidden until then.
const Wreck = struct {
    part: []const u8,
    shown: bool = false,
};

/// The part each wreck burns.
fn wreckOf(object_type: gameobj.Type) ?Wreck {
    return switch (object_type.base()) {
        .mammoth_wreck_front => .{ .part = "Mam frnt dest 2" },
        .mammoth_wreck_back => .{ .part = "Mam back dest" },
        .badanov_wreck_back => .{ .part = "Bad dead back", .shown = true },
        .badanov_wreck_front => .{ .part = "BAD dead frnt", .shown = true },
        .kurgan_wreck => .{ .part = "Box07" },
        else => null,
    };
}

/// `create_object`'s set-up for single types (the switch at `0x004677A2`), as far as it needs no
/// more than the object and its model:
/// - An asteroid, a turret asteroid or an asteroid with a hole is fully invulnerable, so that no hit
///   destroys it, and attached, so that a knock leaves it where it is and a ship that bumps it
///   takes a fiftieth of the damage (`0x004683B6`).
/// - The Victorious, the Kurgan and the Washington have a shield generator, whatever their parts
///   (`0x00467937`).
/// - The Rogue base's meshes draw their first texture pass alone (`wgate.secondPasses`,
///   `0x004683D4`).
/// - The Saladin's parts loop their `middle spin` track from its start (`objects.Model.playNamedTree`,
///   `0x00467DF1`), outside a multiplayer game.
/// - The Dark Reign takes the mass of its `Dark Low Body`, and of the turrets mounted on it, a
///   second time (`gameobj.nodeMass`, `0x00467E94`), until the next recentring sums its mass again.
///
/// The routine that most capital ships, bases and stations get for a destroyed component, the
/// Ulysses' its own, OpenReliant picks by type as it needs it (`explode.ComponentLoss`).
///
/// Titan's last part takes Planet Bombard's routine (`0x0046841D`), for which `createObject` keeps
/// Titan's slot (`bombards`). Not ported: the comms relay, the deathmatch's
/// power-ups and beacons, multiplayer map 83 and the Dark Reign's slot in a multiplayer game
/// (`0x005DB500`), which only the multiplayer arenas have
/// ([#55](https://github.com/OpenReliant/openreliant/issues/55)). The wrecks, the gates, the planets
/// and the Dark Reign's hat are set up once they are in the world (`wreckMade`, `gateMade`,
/// `planetMade`, `extra.hatMade`).
fn typeMade(slot: *Slot, ship_type: gameobj.Type) void {
    const object = &slot.object;
    switch (ship_type.base()) {
        .asteroid_1, .asteroid_2, .asteroid_3, .asteroid_4, .asteroid_5, .asteroid_6, .asteroid_7 => standStill(object),
        .turret_asteroid_1, .turret_asteroid_2, .turret_asteroid_3, .turret_asteroid_4, .turret_asteroid_5, .turret_asteroid_6, .turret_asteroid_7 => standStill(object),
        .asteroid_with_hole_1, .asteroid_with_hole_2, .asteroid_with_hole_3, .asteroid_with_hole_4 => standStill(object),
        .victorious, .kurgan, .washington => object.flags.shield_generator = true,
        .rogue_base => wgate.secondPasses(slot, false),
        .saladin => if (slot.model) |*model| model.playNamedTree(saladin_spin, 0, .loop, 1),
        .darkreign => if (slot.model) |*model| if (model.partNamed(extra.dark_low_body)) |body| {
            object.mass += gameobj.nodeMass(body.model, body.index);
        },
        else => {},
    }
}

/// Whether objects of `ship_type` are Titan, whose last part `create_object` gives the routine that
/// moves Planet Bombard's flashes as the part is drawn (`bombard_hook`), keeping Titan's slot
/// (`0x0046840D`, `Objects.bombarded`).
pub fn bombards(ship_type: gameobj.Type) bool {
    return switch (ship_type.base()) {
        .titan_hi, .titan_lo => true,
        else => false,
    };
}

test bombards {
    try std.testing.expect(bombards(.of(.titan_hi)) and bombards(.of(.titan_lo)));
    try std.testing.expect(!bombards(.of(.saturn_hi)) and !bombards(.of(.predator)));
}

/// What an asteroid is made as (`typeMade`): fully invulnerable, and attached.
fn standStill(object: *GameObject) void {
    object.invulnerable = .full;
    object.flags.attached = true;
}

/// The track the Saladin's parts loop (`0x004F9D60`).
const saladin_spin = "middle spin";

/// The part of `create_object` for a wreck, once it is made where the world can see it: its part
/// burns for good, its rays flickering, with its burn lights and smoke (`explode.burnPart`).
/// OpenReliant does it once the object is made, whether a mission places it
/// (`executor.createShip`) or a split makes it (`explode.split`).
pub fn wreckMade(world: gameobj.World, index: u16) void {
    const slot = &world.objects.slots[index];
    const wreck = wreckOf(slot.object.type) orelse return;
    if (wreck.shown) if (slot.model) |*model| model.showNamed(wreck.part);
    explode.burnPart(world, index, wreck.part, .{ .forever = true, .flickers = true, .lights = true });
}

/// The part of `create_object` for a Coalition gate (`0x00467D2B`, `0x0046823A`), once it is made
/// where the world can see it: a tunnel stands in it, of a proto gate's colours for the prototype
/// and an advanced gate's for the advanced one (`wgate.Gates.make`), at the middle of the first two
/// points of the door list of the part that holds it, where that part stands from the one it hangs
/// from. A prototype's power core burns for good, with steady rays alone (`explode.burnPart`), and
/// each of the gate's parts plays its `Rotate End` track, an advanced gate's playing `Rotate Inner`
/// first at its inner ring's pace (`wgate.inner_ring_speed`), where it has either.
pub fn gateMade(world: gameobj.World, index: u16) void {
    const slot = &world.objects.slots[index];
    const kind: wgate.Kind, const holder: usize = switch (slot.object.type.base()) {
        .proto_gate => .{ .proto, proto_gate_holder },
        .advanced_gate => .{ .advanced, advanced_gate_holder },
        else => return,
    };
    const gates = world.gates orelse return;
    const model = if (slot.model) |*live| live else return;
    if (holder >= model.parts.len) return;
    const ref: objects.PartRef = .{ .model = model, .index = holder };
    const door = (ref.data() orelse return).pointList(.door) orelse return;
    if (door.points.len < 2) return;
    const middle = (door.points[0].position.vector() + door.points[1].position.vector()) * @as(Vector, @splat(0.5));
    if (kind == .proto) explode.burnPart(world, index, proto_power_core, .{ .forever = true, .flickers = false, .lights = false });
    _ = gates.make(world, index, kind, ref.part().frameWithin(.{}).point(middle)) catch |err| {
        std.log.warn("the gate in slot {d} opens no tunnel: {s}", .{ index, @errorName(err) });
    };
    for (0..model.parts.len) |part| {
        if (kind == .advanced) model.playNamed(part, rotate_inner, 0, null, wgate.inner_ring_speed);
        model.playNamed(part, rotate_end, 0, null, wgate.ring_speed);
    }
}

/// The part whose door list places a gate's tunnel, the prototype's and the advanced gate's
/// (`0x00467D2B`, `0x0046823A`); the prototype's power core (`0x004F9D78`); and the gates' tracks
/// (`0x004F9D6C`, `0x004F9DA4`).
const proto_gate_holder = 1;
const advanced_gate_holder = 6;
const proto_power_core = "Protogate Power core";
const rotate_end = "Rotate End";
const rotate_inner = "Rotate Inner";

/// Whether `ship_type` is a planet's, as the planets' table has it (`planets.of`).
pub fn isPlanet(ship_type: gameobj.Type) bool {
    return planets.of(ship_type) != null;
}

/// What each part hanging from a planet's root is drawn with (`0x00467BE9`): lit, always drawn,
/// and bit 20, in place of whatever its model gave it.
const planet_part_flags: @import("../surrender/surrenderlib/srapiext.zig").ObjectFlags = .{ .lit = true, .always_drawn = true, ._unknown_20 = true };

/// The lights that do not reach a planet's parts: the original keeps out all but the second key
/// light, mask `0x08`, which alone lights them (`0x00467BF0`, `0x37`). **Improvement:** they keep out
/// all six of the backdrop's lights and take the planets' own, mask `0x40`, which reaches only the
/// objects that ask for it (`backdrop.LightRole.planets_40`). It has the key lights' colour unless a
/// mod gives the planets another, so that a mod can light the planets without lighting every
/// other model with them.
pub const planet_light_mask: u32 = 0x7F;

/// The part of `create_object` for a planet (`0x00467BAB`), once its atmosphere is made, for those
/// that have one (`atmosphere.Atmospheres.made`): the object lists components, collides with
/// nothing and is frozen. Each part hanging from its root is drawn with `planet_part_flags`, lit
/// by the planets' light alone (`planet_light_mask`), and stands at the root's origin; each of
/// its levels is moved to stand on the middle of its vertices (`recentreMesh`), and the part
/// takes the radius of its last.
///
/// **Unknown:** what bit 20 of the parts' flags does. Titan's Planet Bombard, which the game hangs
/// on its model's last part as it makes it (`0x0046841D`), shows nothing (`typeMade`).
pub fn planetMade(all: *Objects, index: u16) void {
    const slot = &all.slots[index];
    if (!isPlanet(slot.object.type)) return;
    const object = &slot.object;
    object.flags.components = true;
    object.flags.no_collisions = true;
    object.flags.frozen = true;
    const model = if (slot.model) |*live| live else return;
    const loaded = (slot.type orelse return).loaded;
    for (model.parts, loaded.parts) |*part, *made| {
        if (part.parent != null) continue;
        part.object.flags = planet_part_flags;
        part.object.light_mask = planet_light_mask;
        part.origin = @splat(0);
        for (made.meshes) |*mesh| {
            recentreMesh(mesh);
            part.object.radius = mesh.radius;
        }
    }
}

/// `0x00467C43`: a planet's level moved to stand on the middle of its vertices (`Mesh.middle`);
/// then its polygons' planes, its vertices' normals and its bounds are worked out again
/// (`SR_mesh_calc_poly_normals`, `SR_mesh_calc_vertex_normals`, `SR_mesh_find_bounding_box`). The
/// models' levels are shared by every object of the type, so a second planet of a type moves them
/// by what is left, next to nothing.
fn recentreMesh(mesh: *@import("../surrender/surrenderlib/srapiext.zig").Mesh) void {
    const srapi = @import("../surrender/surrenderlib/srapi.zig");
    if (mesh.positions.len == 0) return;
    const middle = mesh.middle();
    for (mesh.positions) |*position| position.* -= middle;
    srapi.calcPolyNormals(mesh);
    srapi.calcVertexNormals(mesh);
    srapi.findBoundingBox(mesh);
}

/// `create_object` as the running mission makes an object (`gameobj.World.spawn`): of
/// `object_type`, in slot `wanted` or the next free, of tier 0 at the origin; null where the world
/// makes none.
pub fn make(world: gameobj.World, wanted: ?u16, object_type: gameobj.Type) Error!?u16 {
    const spawn = world.spawn orelse return null;
    return try createObject(world.objects, spawn.tables, spawn.types, wanted, object_type, 0, @splat(0), world.random);
}

/// `create_object` (`0x00466C10`): fills slot `wanted`, or the next where null, with an object of
/// `ship_type` at `at`, facing along the world's Z axis, and returns the slot. Types with no stats
/// (`gameobj.Type.hasStats`) are stand-ins for markers and nav points: `Flags.standing_in` and a
/// sphere of `stand_in_radius`, and nothing else. Any other is set up at rest, undamaged and flying
/// itself forward (`motion.Motion.forward`), on its type's side, with its model's parts playing
/// their `startup` tracks (`startUp`) and linked (`gameobj.linkParts`). A ship that lists no
/// components and is not debris gets its shields' bubble (`shield.Bubble`). A type that is another
/// under a second number takes the other's stats (`donor`), and its number once it is made.
///
/// It is armed by the loadout `tier` a mission's ship record asks for, as `settledTier` settles it
/// for the type asked for, or in a player's slot with the racks the loadout fitted, where it ran
/// (`Objects.createdRacks`, `arm`). Given a player's slot, it makes the type the loadout chose
/// (`Objects.slotType`).
///
/// Once the object is made, mods' scripts are told (`object_added`).
///
/// A single type, such as an asteroid, is set up as its own (`typeMade`).
///
/// Not ported: what differs in a multiplayer game
/// ([#55](https://github.com/OpenReliant/openreliant/issues/55)).
pub fn createObject(all: *Objects, tables: *Stats, types: Types, wanted: ?u16, asked: gameobj.Type, tier: i32, at: Vector, random: *Random) Error!u16 {
    const index = wanted orelse all.count;
    if (index >= gameobj.max_objects) return error.Overrun;
    const ship_type = if (wanted != null) all.slotType(index, asked) else asked;
    const slot = &all.slots[index];
    const object = &slot.object;
    if (object.created) return error.CreatedTwice;
    if (wanted == null) all.count += 1;
    all.reuses[index] +%= 1;

    object.type = ship_type;
    object.index = index;
    object.flags = .{};
    object.root.flags._unknown_9 = true;
    // At rest, and steering nothing.
    object.speed = 0;
    object.throttle = 0;
    object.holdStill();
    object.wing = .none;
    object.random_seed = random.rand();
    object.invulnerable = .none;
    object.visibility = 1;
    object.engines = 0;
    object.set_aside = .none;
    object.set_aside_until = 0;
    object.eject_roll = xtrabits.objectRandom15(object) % 100;
    objects.setPlace(object, &slot.drawn, .{ .position = at, .orientation = math.identity });
    // No orders, and no attacker yet.
    object.order_count = 0;
    object.orders = .null;
    object.created = true;
    object.last_attacker = .none;
    object.nav_point = .none;
    object.escort_point = .none;
    object.fought_by = 0;
    object.motion = .null;
    object.side = .neutral;
    object.smoke = .null;
    slot.smoke = null;
    // Its armour whole.
    object.shield_condition = 1;
    object.armor_speed_factor = 1;
    object.gun_condition = 1;
    object._unknown_750 = 0;
    object.sound_voice = .none;
    object.gun_turn = .first;
    object.blind_fire_aim = 0;
    object.sent_home = .none;
    object.sync_points = @splat(0);

    const stats_type: TypeIndex = if (ship_type.hasStats()) @intCast(ship_type.number()) else {
        object.type_data = .null;
        object.pilot_record = .null;
        object._unknown_628 = .zero;
        object.shields = .all(0);
        object.armor = .all(0);
        object.flags = .standing_in;
        object.radius = stand_in_radius;
        slot.landing = null;
        hooks.tell(all, .object_added, .{ .object = .of(index) });
        return index;
    };
    const becomes = donor(ship_type) orelse ship_type;
    if (becomes != ship_type) tables.borrow(stats_type, @intCast(becomes.number()));
    const combat = &tables.combat[stats_type];
    slot.combat = combat;
    slot.flight = &tables.flight[stats_type];
    slot.landing = tables.landing[stats_type];
    slot.motion = .forward;
    object.side = @fromBackingInt(@backingInt(combat.side));

    slot.type = all.useType(types, ship_type);
    if (slot.type) |loaded| {
        var model: objects.Model = try .create(all.gpa, loaded.model, loaded.loaded, loaded.effects);
        startUp(&model);
        for (loaded.model.parts) |part| {
            switch (part.part.class) {
                .shield_generator => object.flags.shield_generator = true,
                .engine => object.engines += 1,
                else => {},
            }
            for (part.attachments) |*attachment| switch (attachment.kind) {
                .eject_point => object.flags.eject_point = true,
                // `node_mount_glow` (`0x00499540`): a ship with a retro thruster can reverse.
                .engine_glow => if (objects.Model.Glow.burnsForward(attachment)) {
                    object.flags.can_reverse = true;
                },
                else => {},
            };
        }
        gameobj.linkParts(&model, loaded.model);
        slot.model = model;
        // `object_recentre` puts what it works out in the record.
        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]);
        objects.setPosition(object, &slot.drawn, at);
        switch (combat.class) {
            .debris => object.mass *= debris_mass,
            .mine => object.radius = mine_radius,
            else => {},
        }
        if (!loaded.model.header.flags.components and index >= all.players) object.flags.ecm = true;
        if (loaded.model.header.flags.components) {
            object.flags.components = true;
            object.flags.attached = true;
        }
        typeMade(slot, ship_type);
        if (bombards(ship_type)) all.bombarded = index;
    }
    object.wing_icon = 0;
    pilots.setPilot(object, if (combat.side == .hostile) coalition_pilot else 0);
    makeWhole(object, combat);
    if (!object.flags.components and combat.class != .debris) slot.shield = try shield.Bubble.create(all.gpa, object.radius, combat.side);

    object.engines_intact = 1;
    object.passes_through = @splat(.none);
    object.fighting = .none;
    object.power_up = .none;
    // The power shared evenly, at (1, 1) on the power ball.
    object.gun_factor = 1;
    object.speed_factor = 1;
    object.shield_factor = 1;
    object.power_setting = .{ .x = 1, .y = 1, .z = 1 };
    object.gun_count = 0;
    object.component_count = 0;
    // The components are listed once the count is clear, as the game lists them, and the guns are
    // fitted after them (`object_fit_guns`): a turret fires within its component's firing arc.
    if (object.flags.components) collectComponents(slot);
    if (slot.model) |*model| slot.guns = try guns.fit(all.gpa, model, .{
        .components = slot.listed(),
        .arcs = if (slot.type) |loaded| loaded.model.firing_arcs else &.{},
    });
    // OpenReliant's: a ship type a mod adds can name the gun all its guns fire.
    if (ship_type.added()) |added| if (added.extra.gun) |gun_type| guns.refit(slot.guns, gun_type);
    object.gun_count = @intCast(slot.guns.len);
    // The type's gun groups follow from this object's guns, and each gun learns its side.
    // `gun_groups_build` leaves a type with no model alone.
    if (slot.model != null and combat._unknown_1e == 0) {
        tables.combat[stats_type].gun_groups = @intCast(guns.buildGroups(slot.guns, &all.gun_groups[stats_type]));
    }
    slot.gun_groups = &all.gun_groups[stats_type];
    for (all.gun_groups[stats_type][0..@intCast(tables.combat[stats_type].gun_groups)]) |group| {
        const first, const second = group.members();
        const lead = guns.gunAt(slot.guns, first) orelse continue;
        lead.side = .first;
        if (guns.gunAt(slot.guns, second)) |other| other.side = .second;
    }
    object.gun_mode = .created(combat.gun_groups);
    const fit: Fit = if (all.createdRacks(index)) |racks| .{ .loadout = racks } else all.tierFit(index, settledTier(tier, asked, all.campaign_tier));
    try arm(all.gpa, slot, fit);
    ai.setTargetable(object, combat, true);
    all.exhaust.offer(all, index);
    object.type = becomes;
    hooks.tell(all, .object_added, .{ .object = .of(index) });
    return index;
}

/// The afterburner's fuel a fuel pod adds, in hundredths of a second: 50 seconds.
pub const fuel_pod_fuel = 5000;

/// The racks a player's loadout names (`player_loadouts + 4` on, the low word of each of 20
/// longs): a missile type for each rack, none (-1) where it holds nothing.
pub const Racks = [gameobj.max_racks]missiles.Type;

/// What `arm` fits a ship's racks by: a loadout tier (`object_loadout_by_tier`), or a player's
/// loadout, which each rack takes its type from in turn, as the training's missiles are fitted too
/// (`Objects.tierFit`).
pub const Fit = union(enum) {
    tier: u2,
    loadout: *const Racks,
};

/// The missiles the player's ship takes in training (`object_loadout_by_tier`, `0x0045E59F` to
/// `0x0045E5D5`): a Vagabond, a Jack Hammer and a Raptor on its missile hardpoints in turn, and
/// round again.
pub const training_racks: Racks = racks: {
    const turn = [_]missiles.GameMissile{ .vagabond, .jack_hammer, .raptor };
    var racks: Racks = undefined;
    for (&racks, 0..) |*rack, at| rack.* = .of(turn[at % turn.len]);
    break :racks racks;
};

/// The weapons `create_object` gives the object in `slot`, which a re-arm gives it again
/// (`order_dock`, `cmd_ReplenishWeapons`): racks as `fit` names them on its missile hardpoints,
/// fitted and filled (`fitRacks`), what hung there before let go; its countermeasures; the
/// afterburner's fuel of its type, 5000 more for each fuel pod; and its guns charged, with their
/// rounds.
///
/// Not ported: a multiplayer game, where a re-arm leaves the afterburner's fuel as it is
/// ([#55](https://github.com/OpenReliant/openreliant/issues/55)).
pub fn arm(gpa: Allocator, slot: *Slot, fit: Fit) Allocator.Error!void {
    const object = &slot.object;
    const combat = slot.combat orelse return;
    if (slot.model) |*model| {
        switch (fit) {
            .tier => |tier| loadoutByTier(object, model, tier),
            .loadout => |racks| for (&object.racks, racks) |*rack, missile| {
                rack.type = missile;
            },
        }
        try fitRacks(gpa, object, model, if (slot.type) |loaded| loaded.effects else .{});
    }
    object.countermeasures = gameobj.countermeasures_when_created;
    object.afterburner_fuel = combat.fullFuel();
    for (object.fittedRacks()) |rack| {
        if (rack.type.base() == .fuel_pod) object.afterburner_fuel += fuel_pod_fuel;
    }
    object.gun_charge = combat.gun_energy;
    object.rounds = combat.rounds;
}

/// Refills weapons and supplies as `dock_nanny_run` (`0x004079C9`) does. Player slots retain
/// the racks selected on the loadout screen; other ships use their stored loadout tier.
/// The shared `arm` path also rebuilds mounted missile models, preserving modded loadouts.
pub fn rearm(world: gameobj.World, index: u16) Allocator.Error!void {
    const all = world.objects;
    const slot = &all.slots[index];
    const fit: Fit = if (all.loadoutRacks(index)) |racks|
        .{ .loadout = racks }
    else
        all.tierFit(index, std.math.cast(u2, slot.object.loadout_tier) orelse 0);
    try arm(all.gpa, slot, fit);
    if (index == all.player) if (world.display) |display| display.missiles.build(&slot.object);
}

/// Each quadrant's shields and armour full, as `create_object` makes an object and
/// `cmd_ReplenishWeapons` makes it whole again, and what its armour does to it
/// (`main.armorConditions`).
pub fn makeWhole(object: *GameObject, combat: *const ShipCombat) void {
    object.shields = .all(combat.fullShields() - 1);
    object.armor = .all(combat.startingArmor());
    main.armorConditions(object, combat);
}

/// The last ship type the campaign's tier fits: the player's twelve fighters, the Predator to the
/// Phoenix.
pub const last_fighter: gameobj.GameType = .phoenix;

/// The loadout tier `create_object` settles on for an object of `ship_type` asked for `asked`: 5
/// is 4, and what lies outside 0 to 4 is 0. A fighter asked for 0 takes the campaign's `campaign`,
/// and then any 4 is 0. So a mission's record asks for the campaign's tier with 0 or 255, and for
/// tier 0 with 4 or 5.
pub fn settledTier(asked: i32, ship_type: gameobj.Type, campaign: u2) u2 {
    var tier: i32 = if (asked == 5) 4 else if (asked < 0 or asked > 4) 0 else asked;
    if (tier == 0 and ship_type.base().number() <= last_fighter.number()) tier = campaign;
    return if (tier == 4) 0 else @intCast(tier);
}

/// A missile hardpoint: an attachment of kind `missile` on a part of the model.
pub const Hardpoint = Hardpoints.Point;

/// The missile hardpoints the loadout walks, in turn (`object_fit_missiles`): those of each part in
/// the root's child list, every part in order whatever it is linked to, each part's in order.
pub fn hardpoints(model: *const objects.Model) Hardpoints {
    return .of(model);
}

pub const Hardpoints = objects.Model.RootAttachments(isHardpoint);

fn isHardpoint(attachment: shp.Attachment, _: usize) bool {
    return attachment.kind == .missile;
}

/// `object_loadout_by_tier` (`0x0045E500`): each missile hardpoint, in turn, takes a rack of the
/// missile its attachment names for `tier`. A ship type a mod adds can name the missile all its
/// hardpoints take, at every tier. The player's ship in training takes the training's missiles
/// instead (`Objects.tierFit`).
pub fn loadoutByTier(object: *GameObject, model: *const objects.Model, tier: u2) void {
    object.rack_count = 0;
    const named: ?missiles.Type = if (object.type.added()) |added| added.extra.missile else null;
    var each = hardpoints(model);
    while (each.next()) |hardpoint| {
        if (object.rack_count == gameobj.max_racks) break;
        object.racks[@intCast(object.rack_count)] = .{ .type = named orelse .fromId(hardpoint.attachment.idFor(tier)) };
        object.rack_count += 1;
    }
}

/// `object_fit_missiles` (`0x0045E1A0`): hangs on each missile hardpoint, in turn, what its rack
/// holds, a pod or a missile on its rail, and fills the rack: a pod's capacity, or 1. What hung
/// there before is let go first, as a re-arm does. A model the game lacks hangs nothing, and its
/// rack stays filled.
///
/// **Fix:** the game ends the loadout at a rack of no missile (`0x0045E24F`): its count is 0, and
/// each hardpoint after it reads the same rack, so stays empty. A pilot who leaves a rack empty on
/// the loadout screen flies without the missiles of every rack after it, and without any where it
/// is the first. OpenReliant leaves that hardpoint bare and takes the rack out, the racks after it
/// moving down, so that each hardpoint after it takes the rack the loadout fitted on it
/// ([#451](https://github.com/OpenReliant/openreliant/issues/451)). In every shipped model each tier
/// names a missile for each missile hardpoint, so a ship fitted by its tier flies as in the game.
pub fn fitRacks(gpa: Allocator, object: *GameObject, model: *objects.Model, effects: objects.Effects) Allocator.Error!void {
    if (model.hung.len == 0) {
        model.hung = try gpa.alloc(?objects.Model.Mount, gameobj.max_racks);
        @memset(model.hung, null);
    }
    for (model.hung) |*held| if (held.*) |mount| {
        mount.model.deinit(gpa);
        held.* = null;
    };
    object.rack_count = 0;
    var each = hardpoints(model);
    while (each.next()) |hardpoint| {
        if (object.rack_count == gameobj.max_racks) break;
        const at: usize = @intCast(object.rack_count);
        const rack = &object.racks[at];
        if (rack.type.index() == null) {
            @memmove(object.racks[at .. gameobj.max_racks - 1], object.racks[at + 1 ..]);
            object.racks[gameobj.max_racks - 1] = .{ .type = .none };
            continue;
        }
        const held = rack.type.mounted() orelse models.Attachment{};
        rack.count = @intCast(held.count);
        model.hung[at] = try hang(gpa, effects, hardpoint, held.model);
        object.rack_count += 1;
    }
}

/// What a hardpoint holds, built from `file` and standing on its own centre of mass at the
/// hardpoint's place; null where the game lacks the model.
fn hang(gpa: Allocator, effects: objects.Effects, hardpoint: Hardpoint, file: ?[]const u8) Allocator.Error!?objects.Model.Mount {
    const mounts = effects.mounts orelse return null;
    const mounted = mounts.load(mounts.context, file orelse return null) orelse return null;
    var built: objects.Model = try .create(gpa, mounted.model, mounted.loaded, effects);
    gameobj.linkParts(&built, mounted.model);
    return .{
        .part = hardpoint.part,
        .attachment = hardpoint.index,
        .origin = hardpoint.attachment.position.vector(),
        .orientation = hardpoint.attachment.orientation,
        .model = built,
    };
}

/// `objects_update` (`0x00468FA0`), once a simulation step after the objects' own updates: moves
/// each live object of a ship type (`motion.move`), in the loops' order, passing over stand-ins
/// and disabled and frozen objects. The player's shakes the camera (`shake`).
///
/// Then the collision sweep runs over every object that collides (`Sweep.run`).
///
/// Not ported: in a multiplayer game, what places the other players' ships
/// ([#55](https://github.com/OpenReliant/openreliant/issues/55)).
pub fn objectsUpdate(world: gameobj.World) void {
    const all = world.objects;
    var sweep = &all.sweep;
    sweep.count = 0;
    var walk = all.walk();
    while (walk.next()) |index| {
        const slot = &all.slots[index];
        const object = &slot.object;
        if (!object.type.hasStats() or object.flags.stand_in or object.flags.disabled) continue;
        // A frozen object stays where it is, and is still there to be run into.
        if (!object.flags.frozen) motion.moveSlot(world, index);
        if (object.flags.no_collisions) continue;
        sweep.add(index, object);
    }
    sweep.run(world);
}

/// The sweep for the pairs of objects that meet, which `objects_update` runs once every object has
/// moved. It holds what the game keeps in globals: an extent along X for each object that collides
/// (`0x0054D110`), the order they sort in (`0x0054E3D4`) and how many there are (`0x0054EA14`).
///
/// Sorting by the far end of each extent leaves every object that can reach a given one after it in
/// the order, so each object is tested against those that follow while their extents still reach
/// back to it. A pass that moves anything is followed by another, up to `passes` of them; the game
/// puts a "collision" message on the screen when the last one still finds a pair, which OpenReliant
/// leaves out.
pub const Sweep = struct {
    entries: [gameobj.max_objects]Entry = @splat(.{}),
    order: [gameobj.max_objects]u16 = @splat(0),
    count: u16 = 0,

    /// How many passes `objects_update` makes over the pairs at most.
    pub const passes = 10;

    pub const Entry = struct {
        index: u16 = 0,
        /// Its radius for the sweep: the sphere it collides by, times `visibility`.
        radius: f32 = 0,
        /// Where its sphere reaches along X, which the entries sort by.
        far: f32 = 0,
    };

    fn add(sweep: *Sweep, index: u16, object: *const gameobj.GameObject) void {
        const radius = object.radius * object.visibility;
        sweep.entries[sweep.count] = .{
            .index = index,
            .radius = radius,
            .far = object.root.next_position.x + radius,
        };
        sweep.order[sweep.count] = sweep.count;
        sweep.count += 1;
    }

    /// The far end of an entry's extent, which they sort by, the farthest first.
    fn farthestFirst(entries: []const Entry, a: u16, b: u16) bool {
        return entries[a].far > entries[b].far;
    }

    fn run(sweep: *Sweep, world: gameobj.World) void {
        const all = world.objects;
        for (0..passes) |pass| {
            std.mem.sort(u16, sweep.order[0..sweep.count], sweep.entries[0..sweep.count], farthestFirst);
            var moved = false;
            for (0..sweep.count) |first| {
                const near = sweep.entries[sweep.order[first]];
                const object = &all.slots[near.index].object;
                const back = object.root.next_position.x - near.radius;
                for (sweep.order[first + 1 .. sweep.count]) |entry| {
                    const far = sweep.entries[entry];
                    // Past the first entry that cannot reach back this far, neither can any after
                    // it.
                    if (far.far < back) break;
                    if (!meets(all, near.index, far.index)) continue;
                    if (!collision.collide(world, near.index, far.index, @intCast(pass))) continue;
                    moved = true;
                    // Both have been moved, so their extents are worked out again for the pass
                    // that follows.
                    sweep.entries[sweep.order[first]].far = object.root.next_position.x + near.radius;
                    sweep.entries[entry].far = all.slots[far.index].object.root.next_position.x + far.radius;
                }
            }
            if (!moved) break;
        }
    }

    /// Whether the two objects are near enough to collide and not a pair that passes through: each
    /// object names up to two slots it goes through, which a launch and the Ripper set.
    fn meets(all: *const Objects, first: u16, second: u16) bool {
        const near = &all.slots[first].object;
        const far = &all.slots[second].object;
        for (near.passes_through) |through| if (through.index() == second) return false;
        for (far.passes_through) |through| if (through.index() == first) return false;
        return near.overlaps(far, 0);
    }
};

/// `object_collect_components` (`0x00468760`): lists the parts of the object's model that count as
/// components, in the order missions, triggers and the display name them by. It walks a node's
/// child list, the marked children first, then each child's own list. `create_object` hangs every
/// part's node from the object's root, in part order (`object_add_part`, `0x004760C0`, in its loop
/// at `0x0046720C`), and linking a part to the one it hangs from leaves its node there
/// (`object_link_part`), so the model's own components come first, in part order, whatever they
/// hang from. A part node's own list holds what its attachment points mount (`node_mount`), so the
/// components of each model mounted on the model's parts follow, in turn. Each one is marked on
/// its part, and a part the model marks as targetable becomes targetable.
///
/// The game stops with a fatal error past `max_components`; OpenReliant leaves the rest unlisted,
/// since nothing can name them.
pub fn collectComponents(slot: *Slot) void {
    const model = if (slot.model) |*live| live else return;
    slot.object.component_count = 0;
    const Collecting = struct {
        slot: *Slot,

        fn visit(collecting: @This(), part: *objects.Model.Part) bool {
            const object = &collecting.slot.object;
            if (object.component_count >= gameobj.max_components) return false;
            collecting.slot.components[@intCast(object.component_count)] = part;
            object.component_count += 1;
            part.component = true;
            if (part.flags.targetable) part.targetable = true;
            return true;
        }
    };
    _ = eachComponent(model, Collecting{ .slot = slot });
}

/// Walks the parts of `model` that their records mark as components, in the order
/// `collectComponents` lists them: the model's own, in part order, then those of each model
/// mounted on its parts, in turn, which `model.mounts` holds in the order of the parts and their
/// attachment points. Calls `visitor.visit` for each part; it returns false to stop the walk.
/// Returns false if the walk was stopped.
fn eachComponent(model: *objects.Model, visitor: anytype) bool {
    for (model.parts) |*part| {
        if (!part.flags.component) continue;
        if (!visitor.visit(part)) return false;
    }
    for (model.mounts) |*mount| {
        if (!eachComponent(&mount.model, visitor)) return false;
    }
    return true;
}

/// How far `create_object` has a part's `startup` track move on each simulation step.
const startup_speed: f32 = 4;

/// What `create_object` starts on each part it adds: the part's `startup` track, from its start,
/// as the track says to play it, at 4 a step. The parts are linked after, so each starts from
/// where its `startup` track has it.
pub fn startUp(model: *objects.Model) void {
    for (model.parts, 0..) |part, index| {
        if (part.animation.tracks.len > 0) model.play(index, .startup, 0, null, startup_speed);
    }
}

/// Fixtures for the tests here and in the modules that use the objects.
pub const testing = struct {
    /// A model of one part, to create objects of: a mesh and a level, and a part of mass 6.
    pub const Model = struct {
        mesh: @import("../surrender/surrenderlib/srapiext.zig").Mesh,
        levels: [1]@import("../surrender/surrenderlib/srapiext.zig").Level,
        loaded_parts: [1]srofiles.LoadedPart,
        data: [1]shp.PartData,
        source: shp.Model,
        loaded: srofiles.Loaded,
        type: Type,
        /// A collision tree of one leaf over the part's two faces, which `withHull` hands the
        /// part, and the file's own record of those faces, which the tree's leaf names.
        nodes: [1]shp.TreeNode,
        faces: [2]u32,
        node_faces: [1][]u32,
        vertices: [4]shp.Vertex,
        triangles: [2]shp.Face,
        level: [1]shp.Mesh,

        /// Fills in every field, so a field added here has to be filled in too.
        pub fn init(model: *Model, gpa: Allocator) !void {
            const srmesh = @import("../surrender/surrenderlib/srmesh.zig");
            model.* = .{
                .mesh = try srmesh.testing.square(gpa),
                .levels = undefined,
                .loaded_parts = undefined,
                .data = .{objects.testing.part()},
                .source = undefined,
                .loaded = undefined,
                .type = undefined,
                .nodes = .{.{
                    ._unknown_00 = 0,
                    .orientation = math.identity,
                    .half_size = .{ .x = 100, .y = 100, .z = 10 },
                    .centre = .{ .x = 0, .y = 0, .z = 0 },
                    .children = .{ -1, -1 },
                }},
                .faces = .{ 0, 1 },
                .node_faces = undefined,
                .vertices = undefined,
                .triangles = undefined,
                .level = undefined,
            };
            // The square the test mesh draws, as the file holds it: two triangles facing -Z.
            const square = [_]shp.Vec3{
                .{ .x = -100, .y = -100, .z = 0 },
                .{ .x = 100, .y = -100, .z = 0 },
                .{ .x = 100, .y = 100, .z = 0 },
                .{ .x = -100, .y = 100, .z = 0 },
            };
            for (&model.vertices, square) |*vertex, at| {
                vertex.* = std.mem.zeroes(shp.Vertex);
                vertex.position = at;
            }
            for (&model.triangles, [_][3]u32{ .{ 0, 2, 1 }, .{ 0, 3, 2 } }) |*face, corners| {
                face.* = std.mem.zeroes(shp.Face);
                face.vertices = corners;
                face.normal = .{ .x = 0, .y = 0, .z = -1 };
            }
            model.level = .{.{ .lod = std.mem.zeroes(shp.Lod), .vertices = &model.vertices, .faces = &model.triangles, .materials = &.{} }};
            model.data[0].meshes = &model.level;
            // What points at the rest of the fixture, once it stands where it will stay.
            model.levels = .{.{ .mesh = &model.mesh, .until = std.math.inf(f32) }};
            model.loaded_parts = .{.{ .flags = .{}, .levels = &model.levels, .meshes = &.{} }};
            model.node_faces = .{&model.faces};
            model.data[0].part.volume = 2;
            model.data[0].part.density = 3;
            model.source = .{ .header = std.mem.zeroes(shp.Header), .parts = &model.data, .trailing_bytes = 0 };
            model.loaded = .{ .parts = &model.loaded_parts };
            model.type = .{ .model = &model.source, .loaded = &model.loaded };
        }

        /// Gives the part its collision tree, which a hull's objects are tested against.
        pub fn withHull(model: *Model) void {
            model.data[0].nodes = &model.nodes;
            model.data[0].node_faces = &model.node_faces;
        }

        /// Lists the part as the model's one component.
        pub fn withComponent(model: *Model) void {
            model.source.header.flags.components = true;
            model.data[0].part.flags.component = true;
        }

        /// Lets the model cloak, its part shimmering with `image` (`srofiles.Cloaking`).
        pub fn withCloak(model: *Model, gpa: Allocator, image: *@import("../surrender/surrenderlib/srtexture.zig").Image) Allocator.Error!void {
            model.source.header.flags.cloak = true;
            model.loaded_parts[0].cloaking = try .build(gpa, &model.levels, image);
        }

        pub fn deinit(model: *Model, gpa: Allocator) void {
            if (model.loaded_parts[0].cloaking) |cloaking| cloaking.deinit(gpa);
            model.mesh.deinit(gpa);
        }

        /// Has every hardpoint hold the fixture's own part, as its pod or missile.
        pub fn hangsItself(model: *Model) void {
            model.type.effects.mounts = model.mounts();
        }

        /// Mounts that answer every attachment with the fixture's model.
        pub fn mounts(model: *Model) objects.Mounts {
            return .{ .context = model, .load = mounted };
        }

        fn mounted(context: *anyopaque, _: []const u8) ?objects.Mounts.Mounted {
            const model: *Model = @ptrCast(@alignCast(context));
            return .{ .model = &model.source, .loaded = &model.loaded };
        }

        /// Answers every ship type with the one model.
        pub fn types(model: *Model) Types {
            return oneType(&model.type);
        }
    };

    /// Types that answer every ship type with `kind`.
    pub fn oneType(kind: *const Type) Types {
        return .{ .context = @constCast(kind), .load = loadOne };
    }

    fn loadOne(context: *anyopaque, _: TypeIndex) ?*const Type {
        return @ptrCast(@alignCast(context));
    }

    /// Types with no model at all.
    pub const no_models: Types = .{ .context = @constCast(&{}), .load = noModel };

    fn noModel(context: *anyopaque, ship_type: TypeIndex) ?*const Type {
        _ = context;
        _ = ship_type;
        return null;
    }

    /// The tables with a fighter's figures for every type.
    pub fn tables() Stats {
        var made: Stats = .initial;
        for (&made.flight) |*flight| flight.* = gameobj.testing.flight;
        for (&made.combat) |*record| {
            record.shield_power = 8;
            record.armor_class = 5;
            record.afterburner_fuel = 60;
            record.shield_recharge = 10;
            record.gun_energy = 100;
        }
        return made;
    }
};

/// `object_reset` (`0x004688B0`): pops the object's orders, running their `exit` routines
/// (`aigeneric.popAll`), then puts a new stand-in in slot `index`, flagged
/// `GameObject.Flags.standing_in`, and lets the old object's nodes go. Its type's count of objects
/// stays as it was. Mods' scripts are told first (`object_removed`). **Unverified:** it lies just
/// past this file's known code.
pub fn resetSlot(ctx: aigeneric.Context, index: u16) void {
    const all = ctx.world.objects;
    const slot = &all.slots[index];
    if (slot.object.type.base() != .stand_in) hooks.tell(ctx, .object_removed, .{ .object = .of(index) });
    aigeneric.popAll(ctx, index);
    slot.release(all.gpa, all.retired);
    var object = gameobj.objectAlloc(.of(.stand_in), ctx.world.random);
    object.flags = .standing_in;
    slot.* = .{ .object = object };
    all.reuses[index] +%= 1;
}

/// `object_retire` (`0x004688E0`): what the Explode order leaves of an object once it has blown
/// up: a stand-in in the same place, of type `stand_in`, flagged as a stand-in and as exploding.
/// Its orders pop, running their `exit` routines (`aigeneric.popAll`). Nothing moves, draws,
/// collides with or targets it. Mods' scripts are told first (`object_removed`).
/// **Unverified:** it lies just past this file's known code, after `object_reset`.
pub fn retire(ctx: aigeneric.Context, index: u16) void {
    const all = ctx.world.objects;
    const object = &all.slots[index].object;
    if (object.type.base() != .stand_in) hooks.tell(ctx, .object_removed, .{ .object = .of(index) });
    object.type = .of(.stand_in);
    object.flags = object.flags.with(.standing_in);
    object.flags.exploding = true;
    object.flags.targetable = false;
    aigeneric.popAll(ctx, index);
    all.reuses[index] +%= 1;
}

test "Slot.stack" {
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(std.testing.allocator);
    defer mission.deinit();
    const ctx = mission.orders();
    const ship = try mission.addOther(@splat(0));
    const slot = mission.slot(ship);
    const viewed: *const Slot = slot;
    try std.testing.expectEqual(0, slot.stack().len);
    try std.testing.expectEqual(null, slot.current());
    try std.testing.expectEqual(null, slot.firstOrder(.do_nothing));
    // The first of the stack that holds the order, from the current one down.
    try std.testing.expect(try aigeneric.push(ctx, ship, .do_nothing, .none));
    try std.testing.expect(try aigeneric.push(ctx, ship, .fly, .none));
    try std.testing.expectEqual(2, slot.stack().len);
    try std.testing.expectEqual(2, viewed.stack().len);
    try std.testing.expectEqual(&slot.orders[0], slot.current().?);
    try std.testing.expectEqual(&slot.orders[0], viewed.current().?);
    try std.testing.expectEqual(&slot.orders[1], slot.firstOrder(.do_nothing).?);
    try std.testing.expectEqual(&slot.orders[0], slot.firstOrder(.fly).?);
    try std.testing.expectEqual(null, slot.firstOrder(.launch));
    // Only the current order is running.
    try std.testing.expectEqual(&slot.orders[0], slot.running(.fly).?);
    try std.testing.expectEqual(&slot.orders[0], viewed.running(.fly).?);
    try std.testing.expectEqual(null, slot.running(.do_nothing));
    // A count past what the stack holds gives the whole stack.
    slot.object.order_count = aigeneric.max_stack + 5;
    try std.testing.expectEqual(aigeneric.max_stack, slot.stack().len);
    // A count below 0 holds none.
    slot.object.order_count = -1;
    try std.testing.expectEqual(0, slot.stack().len);
    try std.testing.expectEqual(null, slot.current());
    try std.testing.expectEqual(null, slot.firstOrder(.fly));
    try std.testing.expectEqual(null, slot.running(.fly));
}

test planetMade {
    const gpa = std.testing.allocator;
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    var hull: testing.Model = undefined;
    try hull.init(gpa);
    defer hull.deinit(gpa);
    // Its one level stands off the part's origin by 50 along Z.
    hull.loaded_parts[0].meshes = (&hull.mesh)[0..1];
    for (hull.mesh.positions) |*position| position.* += Vector{ 0, 0, 50 };
    const all = mission.objects;

    // Only a planet is set up as one.
    const ship = try mission.addWith(hull.types(), .of(.predator), @splat(0));
    planetMade(all, ship);
    try std.testing.expect(!all.slots[ship].object.flags.no_collisions);
    try std.testing.expectEqual(50, hull.mesh.positions[0][2]);

    const planet = try mission.addWith(hull.types(), .of(.triton_hi), @splat(0));
    const slot = &all.slots[planet];
    slot.model.?.parts[0].origin = .{ 0, 0, 7 };
    planetMade(all, planet);
    const flags = slot.object.flags;
    try std.testing.expect(flags.components and flags.no_collisions and flags.frozen);
    const part = &slot.model.?.parts[0];
    try std.testing.expectEqual(planet_part_flags, part.object.flags);
    try std.testing.expectEqual(planet_light_mask, part.object.light_mask);
    try std.testing.expectEqual(Vector{ 0, 0, 0 }, part.origin);
    // Its level stands on the middle of its vertices, its normals and bounds worked out again.
    try std.testing.expectEqual(0, hull.mesh.positions[0][2]);
    try std.testing.expectEqual(Vector{ -100, -100, 0 }, hull.mesh.bounds[0]);
    try std.testing.expectEqual(hull.mesh.radius, part.object.radius);
    try std.testing.expectApproxEqAbs(@sqrt(2.0) * 100, part.object.radius, 1e-3);
    // Lit by the planets' light alone.
    const lights = @import("backdrop.zig").initialLights();
    for (std.enums.values(@import("backdrop.zig").LightRole)) |role| {
        try std.testing.expectEqual(role == .planets_40, lights.get(role).reaches(part.object.light_mask));
    }
}

test gateMade {
    const gpa = std.testing.allocator;
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    var built: wgate.testing.Built = undefined;
    try built.init(gpa);
    defer built.deinit(gpa);
    var world = mission.world();
    world.gates = &built.gates;

    // A prototype whose part 1 stands 1000 up, its door's first two points either side of its
    // origin, 100 along.
    const point = struct {
        fn at(x: f32, y: f32, z: f32) shp.Point {
            return .{ ._unknown_00 = 0, .vertex = 0, .position = .{ .x = x, .y = y, .z = z } };
        }
    }.at;
    var door = [2]shp.Point{ point(-50, 0, 100), point(50, 0, 100) };
    var lists = [1]shp.PointList{.{ .kind = .door, .points = &door }};
    var data: [2]shp.PartData = @splat(objects.testing.part());
    data[1].point_lists = &lists;
    const source: shp.Model = .{ .header = std.mem.zeroes(shp.Header), .parts = &data, .trailing_bytes = 0 };
    var levels = [1]@import("../surrender/surrenderlib/srapiext.zig").Level{.{ .mesh = &srofiles.empty, .until = std.math.inf(f32) }};
    var parts: [2]objects.Model.Part = @splat(.{ .hidden = false, .parent = null, .origin = @splat(0), .object = .{ .flags = .{}, .position = @splat(0), .radius = 1, .levels = &levels } });
    parts[1].origin = .{ 0, 1000, 0 };
    const gate = try mission.add(.of(.proto_gate), @splat(0));
    const slot = mission.slot(gate);
    slot.model = .{ .source = &source, .parts = &parts, .order = &.{}, .lights = &.{}, .glows = &.{}, .mounts = &.{} };
    defer slot.model = null;
    gateMade(world, gate);
    const record = built.gates.of(gate).?;
    try std.testing.expectEqual(wgate.Kind.proto, record.kind);
    try std.testing.expectEqual(Vector{ 0, 1000, 100 }, record.at);

    // Any other type makes no tunnel.
    const other = try mission.add(.of(.predator), @splat(0));
    gateMade(world, other);
    try std.testing.expectEqual(null, built.gates.of(other));
}

test wreckMade {
    const gpa = std.testing.allocator;
    var stage: explode.testing.Stage = undefined;
    try stage.init();
    defer stage.deinit();
    var rays: @import("erayfx.zig").testing.Built = try .init(gpa);
    defer rays.deinit(gpa);
    var world = stage.world();
    world.rays = &rays.rays;

    // A Badanov's half shows its part, and burns for good, lit and smoking.
    const index = try stage.mission.add(.of(.badanov_wreck_back), @splat(0));
    const slot = stage.mission.slot(index);
    var burning: explode.testing.Burning = undefined;
    try burning.init(gpa, "Bad dead back");
    defer burning.deinit(gpa);
    burning.put(slot);
    defer burning.take(slot);
    wreckMade(world, index);
    try std.testing.expect(!burning.parts[0].hidden);
    try std.testing.expect(rays.rays.slots[0].?.flags.flickers);
    try std.testing.expect(stage.explosions.burn_lights[0] != null);

    // Another type burns nothing.
    try std.testing.expectEqual(null, wreckOf(.of(.badanov)));
    try std.testing.expectEqualStrings("Box07", wreckOf(.of(.kurgan_wreck)).?.part);
}

test resetSlot {
    const gpa = std.testing.allocator;
    // A ship scooping up a pod: its Scoop Up claims the pod and holds a tractor.
    var scoop: @import("tractor.zig").testing.Scoop = undefined;
    try scoop.init(gpa);
    defer scoop.deinit(gpa);
    const pod = &scoop.mission.slot(scoop.pod).object;
    try std.testing.expect(pod.flags.tractored);
    // After the reset, the slot holds a stand-in with no orders, and Scoop Up's exit has let go of
    // the pod and the tractor.
    resetSlot(scoop.ctx, scoop.nanny);
    const slot = scoop.mission.slot(scoop.nanny);
    try std.testing.expectEqual(GameObject.Flags.standing_in, slot.object.flags);
    try std.testing.expectEqual(0, slot.object.order_count);
    try std.testing.expect(!pod.flags.tractored);
    try std.testing.expectEqual(null, scoop.built.tractors.slots[0]);
}

test retire {
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(std.testing.allocator);
    defer mission.deinit();
    const ctx = mission.orders();
    const index = try mission.addOther(@splat(0));
    const object = &mission.objects.slots[index].object;
    object.flags.targetable = true;
    try std.testing.expect(try aigeneric.push(ctx, index, .do_nothing, .none));
    retire(ctx, index);
    try std.testing.expectEqual(gameobj.Type.of(.stand_in), object.type);
    try std.testing.expect(object.flags.stand_in and object.flags.no_collisions and object.flags.exploding);
    try std.testing.expect(!object.flags.targetable);
    try std.testing.expectEqual(0, object.order_count);
}

test "a mission starts with every slot standing in" {
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(std.testing.allocator);
    defer mission.deinit();
    const all = mission.objects;
    try std.testing.expectEqual(0, all.count);
    for (all.slots) |slot| {
        try std.testing.expect(slot.object.flags.stand_in and !slot.object.created);
        try std.testing.expectEqual(gameobj.Type.of(.stand_in), slot.object.type);
    }
    // With nothing handed out, the loops walk the cutaway slot alone.
    var walk = all.walk();
    try std.testing.expectEqual(cutaway_slot, walk.next().?);
    try std.testing.expectEqual(null, walk.next());
}

test "the loops walk the slots handed out, then the cutaway slot" {
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(std.testing.allocator);
    defer mission.deinit();
    const all = mission.objects;
    all.count = 3;
    var walked: std.ArrayList(u16) = .empty;
    defer walked.deinit(std.testing.allocator);
    var walk = all.walk();
    while (walk.next()) |index| {
        try walked.append(std.testing.allocator, index);
        // An object created on the way is walked as well.
        if (index == 1 and all.count == 3) all.count = 4;
    }
    try std.testing.expectEqualSlices(u16, &.{ 0, 1, 2, 3, cutaway_slot }, walked.items);
    // With every slot handed out, the cutaway slot is walked once, as the last.
    all.count = gameobj.max_objects;
    walk = all.walk();
    var count: usize = 0;
    var last: u16 = 0;
    while (walk.next()) |index| {
        count += 1;
        last = index;
    }
    try std.testing.expectEqual(gameobj.max_objects, count);
    try std.testing.expectEqual(cutaway_slot, last);
}

test collectComponents {
    const gpa = std.testing.allocator;
    // Four parts: one plain at the root, one component at the root, and a component under each.
    var parts: objects.testing.Parts(4) = undefined;
    parts.init();
    const parents = [_]i32{ -1, -1, 1, 0 };
    const marked = [_]bool{ false, true, true, true };
    for (&parts.data, parents, marked) |*part, parent, is_component| {
        part.part.parent = parent;
        part.part.flags.component = is_component;
    }
    parts.data[2].part.flags.targetable = true;
    var kind: Type = .{ .model = &parts.source, .loaded = &parts.loaded };

    var slot: Slot = .{ .object = std.mem.zeroes(gameobj.GameObject) };
    slot.model = try parts.model(gpa, .{});
    defer slot.model.?.deinit(gpa);
    slot.type = &kind;

    // A model of two components mounted on part 0.
    var mounted: objects.testing.Parts(2) = undefined;
    mounted.init();
    for (&mounted.data) |*part| part.part.flags.component = true;
    slot.model.?.mounts = try gpa.dupe(objects.Model.Mount, &.{.{ .part = 0, .attachment = 0, .origin = @splat(0), .orientation = math.identity, .model = try mounted.model(gpa, .{}) }});
    const turret = &slot.model.?.mounts[0].model;

    collectComponents(&slot);
    // The model's own come first, in part order whatever they hang from, then the mounted model's.
    try std.testing.expectEqual(5, slot.object.component_count);
    const listed = [_]*objects.Model.Part{ &slot.model.?.parts[1], &slot.model.?.parts[2], &slot.model.?.parts[3], &turret.parts[0], &turret.parts[1] };
    for (slot.components[0..5], listed) |component, part| try std.testing.expectEqual(part, component.?);
    for ([_]usize{ 1, 2, 3 }) |part| try std.testing.expect(slot.model.?.parts[part].component);
    try std.testing.expect(!slot.model.?.parts[0].component);
    // Only the part the model marks is targetable.
    try std.testing.expect(slot.model.?.parts[2].targetable);
    try std.testing.expect(!slot.model.?.parts[1].targetable);

    // A component keeps its number after it leaves the list, and the plain part has none.
    slot.components[1] = null;
    try std.testing.expectEqual(null, slot.componentIndex(&slot.model.?.parts[2]));
    for (listed, 0..) |part, number| try std.testing.expectEqual(number, slot.componentNumber(part).?);
    try std.testing.expectEqual(null, slot.componentNumber(&slot.model.?.parts[0]));

    // A model of nothing but components lists no more than the object holds.
    var crowded: objects.testing.Parts(gameobj.max_components + 4) = undefined;
    crowded.init();
    for (&crowded.data) |*part| part.part.flags.component = true;
    var crowded_kind: Type = .{ .model = &crowded.source, .loaded = &crowded.loaded };
    slot.model.?.deinit(gpa);
    slot.model = try crowded.model(gpa, .{});
    slot.type = &crowded_kind;
    collectComponents(&slot);
    try std.testing.expectEqual(gameobj.max_components, slot.object.component_count);
}

test "Objects.copyInto" {
    const gpa = std.testing.allocator;
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    var model: testing.Model = undefined;
    try model.init(gpa);
    defer model.deinit(gpa);
    model.withComponent();
    const index = try mission.addWith(model.types(), .of(.predator), @splat(0));
    const slot = mission.slot(index);
    const ship = try mission.add(.of(.sabre), .{ 0, 0, 1000 });
    const armed = mission.slot(ship);
    armed.guns = try gpa.dupe(guns.Fitted, &.{guns.testing.barrel(.of(.laser_cannon))});
    armed.object.gun_count = 1;
    armed.shield.?.struck = 10;
    var scripts: hooks.Scripts = undefined;
    mission.objects.scripts = &scripts;
    defer mission.objects.scripts = null;
    const drawn = try gpa.create(Objects);
    defer gpa.destroy(drawn);
    var arena: std.heap.ArenaAllocator = .init(gpa);
    defer arena.deinit();
    try mission.objects.copyInto(drawn, arena.allocator());

    // The copy's model is its own, its component among its own parts, and it runs no scripts.
    const copy = &drawn.slots[index];
    try std.testing.expect(copy.model.?.parts.ptr != slot.model.?.parts.ptr);
    try std.testing.expectEqual(&slot.model.?.parts[0], slot.component(0).?);
    try std.testing.expectEqual(&copy.model.?.parts[0], copy.component(0).?);
    try std.testing.expectEqual(null, drawn.scripts);

    // A ship's guns and shield bubble are the copy's own, as they were: what the game does to them
    // next leaves the copy as it is.
    const copied = &drawn.slots[ship];
    try std.testing.expect(copied.guns.ptr != armed.guns.ptr and copied.shield.? != armed.shield.?);
    armed.guns[0].next_shot = 50;
    armed.shield.?.struck = 20;
    try std.testing.expectEqual(0, copied.guns[0].next_shot);
    try std.testing.expectEqual(10, copied.shield.?.struck);

    // An effect that hangs from a part of the model finds the part in the objects, and its copy in
    // the copy of them.
    const on: objects.PartOf = .{ .object = index, .part = .{ .model = &slot.model.?, .index = 0 } };
    try std.testing.expectEqual(&slot.model.?.parts[0], on.live(mission.objects).?);
    try std.testing.expectEqual(&copy.model.?.parts[0], on.live(drawn).?);
}

test "Objects.slotType" {
    var random: Random = .{};
    const all = try Objects.create(std.testing.allocator, &random);
    defer all.destroy();
    // With no loadout, the player's slot takes the mission's own kind; other slots always do.
    try std.testing.expectEqual(gameobj.Type.of(.grendel), all.slotType(0, .of(.grendel)));
    all.loadout_ships[0] = .of(.reaper);
    try std.testing.expectEqual(gameobj.Type.of(.reaper), all.slotType(0, .of(.grendel)));
    try std.testing.expectEqual(gameobj.Type.of(.sabre), all.slotType(1, .of(.sabre)));
    // From the 14th mission on the loadout's twin, and in mission 25's first part a Kamov.
    all.mission_number = 14;
    try std.testing.expectEqual(gameobj.Type.of(.reaper).twin().?, all.slotType(0, .of(.grendel)));
    all.mission_number = 25;
    try std.testing.expectEqual(gameobj.Type.of(.kamov), all.slotType(0, .of(.grendel)));
    all.mission25_second_part = true;
    try std.testing.expectEqual(gameobj.Type.of(.reaper).twin().?, all.slotType(0, .of(.grendel)));
}

test settledTier {
    // A fighter asked for 0 or 255 takes the campaign's tier; asked for 4 or 5, tier 0.
    try std.testing.expectEqual(2, settledTier(0, .of(.predator), 2));
    try std.testing.expectEqual(2, settledTier(255, .of(.predator), 2));
    try std.testing.expectEqual(0, settledTier(4, .of(.predator), 2));
    try std.testing.expectEqual(0, settledTier(5, .of(.predator), 2));
    try std.testing.expectEqual(3, settledTier(3, .of(.predator), 2));
    // What isn't a fighter keeps what it was asked for.
    try std.testing.expectEqual(0, settledTier(0, .of(.sabre), 2));
}

test hardpoints {
    const srapiext = @import("../surrender/surrenderlib/srapiext.zig");
    var points: [2]shp.Attachment = @splat(std.mem.zeroes(shp.Attachment));
    for (&points) |*point| point.kind = .missile;
    const shown: srapiext.MeshObject = .{ .flags = .{}, .position = @splat(0), .radius = 0, .levels = &.{} };
    var parts = [_]objects.Model.Part{
        .{ .hidden = false, .parent = null, .origin = @splat(0), .object = shown, .attachments = points[0..1] },
        .{ .hidden = false, .parent = 0, .origin = @splat(0), .object = shown, .attachments = points[1..2] },
    };
    const model: objects.Model = .{ .parts = &parts, .order = &.{}, .lights = &.{}, .glows = &.{}, .mounts = &.{} };

    // A part linked to another is in the root's child list as well, and its hardpoints are walked.
    var each = hardpoints(&model);
    try std.testing.expectEqual(0, each.next().?.part);
    try std.testing.expectEqual(1, each.next().?.part);
    try std.testing.expectEqual(null, each.next());
    // One taken out of the model is not.
    parts[1].removed = true;
    each = hardpoints(&model);
    try std.testing.expectEqual(0, each.next().?.part);
    try std.testing.expectEqual(null, each.next());
}

test "a ship's racks are fitted by its tier" {
    const gpa = std.testing.allocator;
    var random: Random = .{};
    const all = try Objects.create(gpa, &random);
    defer all.destroy();
    var tables = testing.tables();
    var model: testing.Model = undefined;
    try model.init(gpa);
    defer model.deinit(gpa);
    // Four hardpoints: for tier 0 a Screamer pod, a Havoc, none, and a Raptor after the gap; for
    // tier 1 a fuel pod first. A light among them is passed over. Every hardpoint holds the
    // fixture's own part.
    var points: [5]shp.Attachment = @splat(std.mem.zeroes(shp.Attachment));
    for (&points, [_]u32{ 0, 2, 0xFFFF, 1, 0 }) |*point, id| {
        point.kind = .missile;
        point.id = id;
    }
    points[0].later_tiers[0] = 10;
    points[2].kind = .light;
    points[2].id = 0;
    points[3].id = 0xFFFF;
    points[4].id = 1;
    model.data[0].attachments = &points;
    model.hangsItself();
    var index = try createObject(all, &tables, model.types(), null, .of(.predator), 0, @splat(0), &random);
    var object = &all.slots[index].object;
    try std.testing.expectEqual(3, object.rack_count);
    try std.testing.expectEqual(missiles.Type.of(.screamer), object.racks[0].type);
    try std.testing.expectEqual(20, object.racks[0].count);
    try std.testing.expectEqual(missiles.Type.of(.havoc), object.racks[1].type);
    try std.testing.expectEqual(1, object.racks[1].count);
    // The gap's hardpoint stays bare, and the Raptor pod after it hangs on its own.
    try std.testing.expectEqual(missiles.Type.of(.raptor), object.racks[2].type);
    try std.testing.expectEqual(3, object.racks[2].count);
    const hung = all.slots[index].model.?.hung;
    try std.testing.expectEqual(0, hung[0].?.attachment);
    try std.testing.expectEqual(1, hung[1].?.attachment);
    try std.testing.expectEqual(4, hung[2].?.attachment);
    try std.testing.expectEqual(null, hung[3]);

    // At tier 1, the first holds a fuel pod, which adds to the afterburner's fuel.
    all.campaign_tier = 1;
    const fuel = object.afterburner_fuel;
    index = try createObject(all, &tables, model.types(), null, .of(.predator), 0, @splat(0), &random);
    object = &all.slots[index].object;
    try std.testing.expectEqual(missiles.Type.of(.fuel_pod), object.racks[0].type);
    try std.testing.expectEqual(fuel + fuel_pod_fuel, object.afterburner_fuel);
}

test "a player's ship takes the racks its loadout fitted" {
    const gpa = std.testing.allocator;
    var random: Random = .{};
    const all = try Objects.create(gpa, &random);
    defer all.destroy();
    var tables = testing.tables();
    var model: testing.Model = undefined;
    try model.init(gpa);
    defer model.deinit(gpa);
    var points: [3]shp.Attachment = @splat(std.mem.zeroes(shp.Attachment));
    for (&points) |*point| point.kind = .missile;
    model.data[0].attachments = &points;
    var racks: Racks = @splat(.none);
    racks[0] = .of(.imp);
    racks[1] = .of(.fuel_pod);
    racks[2] = .of(.raptor);
    all.loadout_racks[0] = racks;
    // The player's slot takes the loadout's, whatever its hardpoints name.
    const index = try createObject(all, &tables, model.types(), null, .of(.predator), 0, @splat(0), &random);
    const object = &all.slots[index].object;
    try std.testing.expectEqual(0, index);
    try std.testing.expectEqual(3, object.rack_count);
    try std.testing.expectEqual(missiles.Type.of(.imp), object.racks[0].type);
    try std.testing.expectEqual(missiles.Type.of(.fuel_pod), object.racks[1].type);
    try std.testing.expectEqual(missiles.Type.of(.raptor), object.racks[2].type);
    // Rearming restores the selected racks even if the ship's default tier differs.
    var clock: main.Clock = .{};
    var player: @import("../input.zig").Player = .{};
    var shake: f32 = 0;
    const world: gameobj.World = .{ .objects = all, .clock = &clock, .player = &player, .shake = &shake, .random = &random };
    object.loadout_tier = 3;
    object.racks[0].count = 0;
    object.countermeasures = 0;
    try rearm(world, index);
    try std.testing.expectEqual(missiles.Type.of(.imp), object.racks[0].type);
    try std.testing.expect(object.racks[0].count > 0);
    try std.testing.expectEqual(missiles.Type.of(.fuel_pod), object.racks[1].type);
    try std.testing.expectEqual(gameobj.countermeasures_when_created, object.countermeasures);
    // Not in the simulator, nor in mission 25's first part.
    try std.testing.expect(all.createdRacks(0) != null);
    all.simulator = .{ .mode = .training };
    try std.testing.expectEqual(null, all.loadoutRacks(0));
    all.simulator = .{};
    all.mission_number = 25;
    try std.testing.expectEqual(null, all.createdRacks(0));
    try std.testing.expect(all.loadoutRacks(0) != null);
    // Another slot has none.
    try std.testing.expectEqual(null, all.loadoutRacks(1));
}

test "the player's ship takes the training's missiles" {
    const gpa = std.testing.allocator;
    var random: Random = .{};
    const all = try Objects.create(gpa, &random);
    defer all.destroy();
    var tables = testing.tables();
    var model: testing.Model = undefined;
    try model.init(gpa);
    defer model.deinit(gpa);
    // Four hardpoints, each naming a Screamer at every tier.
    var points: [4]shp.Attachment = @splat(std.mem.zeroes(shp.Attachment));
    for (&points) |*point| point.kind = .missile;
    model.data[0].attachments = &points;
    // In the simulator's training, the player's ship takes a Vagabond, a Jack Hammer and a Raptor
    // in turn, and round again, and any other ship its tier's.
    all.simulator = .{ .mode = .training };
    const player = try createObject(all, &tables, model.types(), null, .of(.predator), 0, @splat(0), &random);
    const other = try createObject(all, &tables, model.types(), null, .of(.predator), 0, @splat(0), &random);
    try std.testing.expectEqual(all.player, player);
    const fitted = &all.slots[player].object;
    try std.testing.expectEqual(4, fitted.rack_count);
    for (fitted.racks[0..4], [_]missiles.GameMissile{ .vagabond, .jack_hammer, .raptor, .vagabond }) |rack, expected| {
        try std.testing.expectEqual(missiles.Type.of(expected), rack.type);
    }
    try std.testing.expectEqual(missiles.Type.of(.screamer), all.slots[other].object.racks[0].type);
    // So in a training mission flown without the loadout, as `--mission` flies it, and in no
    // other.
    all.simulator = .{};
    all.mission_number = training_missions[1];
    try std.testing.expectEqual(Fit{ .loadout = &training_racks }, all.tierFit(player, 2));
    try std.testing.expectEqual(Fit{ .tier = 2 }, all.tierFit(other, 2));
    all.mission_number = training_missions[1] + 1;
    try std.testing.expectEqual(Fit{ .tier = 2 }, all.tierFit(player, 2));
}

test "a rack left empty on the loadout leaves its hardpoint bare" {
    const gpa = std.testing.allocator;
    var random: Random = .{};
    const all = try Objects.create(gpa, &random);
    defer all.destroy();
    var tables = testing.tables();
    var model: testing.Model = undefined;
    try model.init(gpa);
    defer model.deinit(gpa);
    var points: [4]shp.Attachment = @splat(std.mem.zeroes(shp.Attachment));
    for (&points) |*point| point.kind = .missile;
    model.data[0].attachments = &points;
    model.hangsItself();
    // The first rack and the third taken off.
    var racks: Racks = @splat(.none);
    racks[1] = .of(.imp);
    racks[3] = .of(.raptor);
    all.loadout_racks[0] = racks;
    const index = try createObject(all, &tables, model.types(), null, .of(.predator), 0, @splat(0), &random);
    const object = &all.slots[index].object;
    // Each missile flies, on the hardpoint the loadout hung it on.
    try std.testing.expectEqual(2, object.rack_count);
    try std.testing.expectEqual(missiles.Type.of(.imp), object.racks[0].type);
    try std.testing.expectEqual(missiles.Type.of(.raptor), object.racks[1].type);
    const hung = all.slots[index].model.?.hung;
    try std.testing.expectEqual(1, hung[0].?.attachment);
    try std.testing.expectEqual(3, hung[1].?.attachment);
    try std.testing.expectEqual(null, hung[2]);
}

test createObject {
    const gpa = std.testing.allocator;
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    const all = mission.objects;
    var model: testing.Model = undefined;
    try model.init(gpa);
    defer model.deinit(gpa);
    mission.tables.combat[0x2B].side = .hostile;

    // The player first, in the next slot, at rest where it is put and facing along Z.
    const player = try createObject(all, &mission.tables, model.types(), null, .of(.predator), 0, .{ 0, 0, 500 }, &mission.random);
    try std.testing.expectEqual(0, player);
    try std.testing.expectEqual(1, all.count);
    const made = &all.slots[player];
    const object = &made.object;
    try std.testing.expect(object.created and !object.flags.stand_in);
    try std.testing.expectEqual(math.Vector{ 0, 0, 500 }, object.position());
    try std.testing.expectEqual(math.identity, object.root.orientation);
    try std.testing.expectEqual(motion.Motion.forward, made.motion.?);
    try std.testing.expectEqual(1, all.types[0].objects);
    try std.testing.expectEqual(.friendly, object.side);
    try std.testing.expectEqual(0, object.pilot);
    // Undamaged: each quadrant six times the type's figure, less one.
    try std.testing.expectEqual(gameobj.Quadrants.all(47), object.shields);
    try std.testing.expectEqual(gameobj.Quadrants.all(29), object.armor);
    try std.testing.expectEqual(1, object.shield_condition);
    try std.testing.expectEqual(6000, object.afterburner_fuel);
    try std.testing.expectEqual(100, object.gun_charge);
    try std.testing.expectEqual(gameobj.countermeasures_when_created, object.countermeasures);
    try std.testing.expectEqual([2]gameobj.Slot{ .none, .none }, object.passes_through);
    // Its model's one part, and the mass `object_recentre` put in the record.
    try std.testing.expectEqual(1, made.model.?.parts.len);
    try std.testing.expectEqual(6, object.mass);
    // The player's slot has no ECM on; every other slot's does.
    try std.testing.expect(!object.flags.ecm);

    // A Coalition fighter: hostile, flown by the Coalition's pilot, with its ECM on.
    const enemy = try createObject(all, &mission.tables, model.types(), null, .of(.sabre), 0, .{ 0, 0, 0 }, &mission.random);
    try std.testing.expectEqual(.hostile, all.slots[enemy].object.side);
    try std.testing.expectEqual(coalition_pilot, all.slots[enemy].object.pilot);
    try std.testing.expect(all.slots[enemy].object.flags.ecm);
    // It offers no landing; a ship of a type the tables give one offers that.
    try std.testing.expectEqual(null, all.slots[enemy].landing);
    mission.tables.landing[@backingInt(gameobj.GameType.sabre)] = .bay;
    const carrier = try createObject(all, &mission.tables, model.types(), null, .of(.sabre), 0, .{ 0, 0, 0 }, &mission.random);
    try std.testing.expectEqual(ailand.Style.bay, all.slots[carrier].landing.?);

    // A slot filled once is not filled again, and nothing lies past the last.
    try std.testing.expectError(error.CreatedTwice, createObject(all, &mission.tables, model.types(), player, .of(.predator), 0, @splat(0), &mission.random));
    try std.testing.expectError(error.Overrun, createObject(all, &mission.tables, model.types(), gameobj.max_objects, .of(.predator), 0, @splat(0), &mission.random));

    // Above the last ship type, a stand-in for a marker, at a slot of its own, which offers no
    // landing.
    all.slots[20].landing = .reliant;
    const marker = try createObject(all, &mission.tables, model.types(), 20, .of(.marker), 0, @splat(0), &mission.random);
    try std.testing.expectEqual(20, marker);
    try std.testing.expectEqual(3, all.count);
    const stand_in = all.slots[marker];
    try std.testing.expectEqual(GameObject.Flags.standing_in, stand_in.object.flags);
    try std.testing.expectEqual(stand_in_radius, stand_in.object.radius);
    try std.testing.expectEqual(null, stand_in.model);
    try std.testing.expectEqual(null, stand_in.combat);
    try std.testing.expectEqual(null, stand_in.landing);

    // Reset, the slot stands in again, and can be filled anew.
    resetSlot(mission.orders(), player);
    try std.testing.expectEqual(GameObject.Flags.standing_in, all.slots[player].object.flags);
    try std.testing.expectEqual(null, all.slots[player].model);
    _ = try createObject(all, &mission.tables, model.types(), player, .of(.predator), 0, @splat(0), &mission.random);
}

test make {
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(std.testing.allocator);
    defer mission.deinit();
    var world = mission.world();

    // A world that makes no objects makes none.
    try std.testing.expectEqual(null, try make(world, null, .of(.sabre)));
    try std.testing.expectEqual(0, mission.objects.count);

    // One that does makes it of the type, in the slot wanted or the next.
    world.spawn = mission.spawn(testing.no_models);
    try std.testing.expectEqual(0, (try make(world, null, .of(.sabre))).?);
    try std.testing.expectEqual(5, (try make(world, 5, .of(.predator))).?);
    try std.testing.expectEqual(gameobj.Type.of(.sabre), mission.objects.slots[0].object.type);
    try std.testing.expectEqual(gameobj.Type.of(.predator), mission.objects.slots[5].object.type);
}

test "an object is created with the guns its model holds" {
    const gpa = std.testing.allocator;
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    const all = mission.objects;
    var model: testing.Model = undefined;
    try model.init(gpa);
    defer model.deinit(gpa);
    // Two muzzles of one type, one either side of the nose.
    var muzzles: [2]shp.Attachment = @splat(std.mem.zeroes(shp.Attachment));
    for (&muzzles, [_]f32{ -100, 100 }) |*muzzle, x| {
        muzzle.kind = .gun_muzzle;
        muzzle.gun_type = 1;
        muzzle.position = .{ .x = x, .y = 0, .z = 0 };
    }
    model.data[0].attachments = &muzzles;

    const index = try mission.addWith(model.types(), .of(.patriot), @splat(0));
    const slot = &all.slots[index];
    // The guns are fitted after the count is cleared, so the object holds them all.
    try std.testing.expectEqual(2, slot.object.gun_count);
    try std.testing.expectEqual(2, slot.guns.len);
    // They make one group, whose two guns fire in turn as its left and right.
    try std.testing.expectEqual(1, mission.tables.combat[7].gun_groups);
    try std.testing.expectEqual(&all.gun_groups[7], slot.gun_groups);
    try std.testing.expectEqual(0, slot.gun_groups[0].first);
    try std.testing.expectEqual(1, slot.gun_groups[0].second);
    try std.testing.expectEqual(guns.GroupSide.first, slot.guns[0].side);
    try std.testing.expectEqual(guns.GroupSide.second, slot.guns[1].side);
    // One group of guns fires them in step (`GunMode.created`).
    try std.testing.expect(slot.object.gun_mode.synchronised);
    try std.testing.expect(!slot.object.gun_mode.all);
}

test "a ship with a retro thruster can reverse" {
    const gpa = std.testing.allocator;
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    const all = mission.objects;
    var model: testing.Model = undefined;
    try model.init(gpa);
    defer model.deinit(gpa);
    // A main engine, whose plume reaches back, and a retro thruster, whose plume reaches forward.
    var glows: [2]shp.Attachment = @splat(std.mem.zeroes(shp.Attachment));
    for (&glows, [_]f32{ -40, 40 }) |*glow, length| {
        glow.kind = .engine_glow;
        glow.orientation = math.identity;
        glow.size = .{ 10, 10, length };
    }
    model.data[0].attachments = glows[0..1];
    const plain = try mission.addWith(model.types(), .of(.patriot), @splat(0));
    try std.testing.expect(!all.slots[plain].object.flags.can_reverse);
    model.data[0].attachments = &glows;
    const retro = try mission.addWith(model.types(), .of(.patriot), @splat(0));
    try std.testing.expect(all.slots[retro].object.flags.can_reverse);
}

test "single types are made as their own" {
    const gpa = std.testing.allocator;
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    const all = mission.objects;
    var model: testing.Model = undefined;
    try model.init(gpa);
    defer model.deinit(gpa);
    // Every kind of asteroid stands still, and no hit destroys it.
    for ([_]gameobj.GameType{ .asteroid_1, .turret_asteroid_7, .asteroid_with_hole_2 }) |rock| {
        const object = &all.slots[try mission.addWith(model.types(), .of(rock), @splat(0))].object;
        try std.testing.expectEqual(.full, object.invulnerable);
        try std.testing.expect(object.flags.attached);
    }
    // The Kurgan has a shield generator whatever its parts; a Sabre doesn't.
    const kurgan = &all.slots[try mission.addWith(model.types(), .of(.kurgan), @splat(0))].object;
    try std.testing.expect(kurgan.flags.shield_generator and kurgan.invulnerable == .none);
    const sabre = &all.slots[try mission.addWith(model.types(), .of(.sabre), @splat(0))].object;
    try std.testing.expect(!sabre.flags.shield_generator and !sabre.flags.attached);
}

test "a type under another number takes its stats, then its number" {
    const gpa = std.testing.allocator;
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(gpa);
    defer mission.deinit();
    const all = mission.objects;
    const mammoth: TypeIndex = @intCast(gameobj.GameType.mammoth.number());
    const rosario: TypeIndex = @intCast(gameobj.GameType.mammoth_rosario.number());
    mission.tables.flight[mammoth].max_speed = 55;
    mission.tables.combat[mammoth].shield_power = 30;
    mission.tables.combat[rosario].name = 1123;
    mission.tables.combat[rosario].gun_groups = 2;
    const index = try mission.add(.of(.mammoth_rosario), @splat(0));
    const slot = all.slots[index];
    try std.testing.expectEqual(gameobj.Type.of(.mammoth), slot.object.type);
    try std.testing.expectEqual(55, slot.flight.?.max_speed);
    try std.testing.expectEqual(30, slot.combat.?.shield_power);
    // Its own name and guns stay.
    try std.testing.expectEqual(1123, slot.combat.?.name);
    try std.testing.expectEqual(2, slot.combat.?.gun_groups);
    // The table it points into is its own number's, which now holds the other's stats.
    try std.testing.expectEqual(&mission.tables.combat[rosario], slot.combat.?);
    try std.testing.expectEqual(gameobj.Type.of(.mammoth), donor(.of(.mammoth_rosario)));
    try std.testing.expectEqual(null, donor(.of(.mammoth)));
}

test "a type with no model still flies" {
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(std.testing.allocator);
    defer mission.deinit();
    const all = mission.objects;
    const index = try mission.add(.of(.crusader), @splat(0));
    try std.testing.expectEqual(null, all.slots[index].model);
    all.slots[index].object.throttle = 1;
    all.slots[index].object.rotation = math.identity;
    objectsUpdate(mission.world());
    try std.testing.expect(all.slots[index].object.root.flags.next_pending);
    try std.testing.expect(all.slots[index].object.velocity.z > 0);
}

test objectsUpdate {
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(std.testing.allocator);
    defer mission.deinit();
    const all = mission.objects;
    for (0..3) |_| _ = try mission.add(.of(.predator), @splat(0));
    all.slots[1].object.flags.disabled = true;
    all.slots[2].object.flags.frozen = true;
    // Each drifting, with no motion of its own.
    for (all.slots[0..3]) |*slot| {
        slot.object.velocity = .{ .x = 0, .y = 0, .z = 10 };
        slot.motion = null;
    }
    objectsUpdate(mission.world());
    // The first moves on; the disabled and the frozen ones stay where they are.
    try std.testing.expectEqual(10, all.slots[0].object.root.next_position.z);
    try std.testing.expectEqual(0, all.slots[1].object.root.next_position.z);
    try std.testing.expectEqual(0, all.slots[2].object.root.next_position.z);
}

test "the sweep pushes apart the objects that meet" {
    var mission: gameobj.testing.Mission = undefined;
    try mission.init(std.testing.allocator);
    defer mission.deinit();
    const all = mission.objects;
    const world = mission.world();

    // Three ships in a row, the first two of them overlapping, each 1000 units across and drifting
    // nowhere.
    const places = [_]math.Vector{ .{ -200, 0, 0 }, .{ 200, 0, 0 }, .{ 20000, 0, 0 } };
    for (places) |at| {
        const index = try mission.add(.of(.predator), at);
        all.slots[index].object.radius = 1000;
        all.slots[index].motion = null;
    }

    objectsUpdate(world);
    // The pair is set apart, and the ship far off is left where it was.
    try std.testing.expectApproxEqAbs(-1100, all.slots[0].object.root.position.x, 0.01);
    try std.testing.expectApproxEqAbs(1100, all.slots[1].object.root.position.x, 0.01);
    try std.testing.expectEqual(20000, all.slots[2].object.root.position.x);
    try std.testing.expectEqual(3, all.sweep.count);

    // A pair that passes through each other is left alone, and so is an object that collides with
    // nothing.
    objects.setPosition(&all.slots[0].object, &all.slots[0].drawn, .{ -200, 0, 0 });
    objects.setPosition(&all.slots[1].object, &all.slots[1].drawn, .{ 200, 0, 0 });
    all.slots[0].object.passes_through[0] = .of(1);
    objectsUpdate(world);
    try std.testing.expectEqual(-200, all.slots[0].object.root.position.x);

    all.slots[0].object.passes_through[0] = .none;
    all.slots[1].object.flags.no_collisions = true;
    objectsUpdate(world);
    try std.testing.expectEqual(-200, all.slots[0].object.root.position.x);
    try std.testing.expectEqual(2, all.sweep.count);
}

test "the tables hold the executable's words until the file fills in the figures" {
    const initial: Stats = .initial;
    // The Reliant, a capital ship of the player's side that can be targeted.
    try std.testing.expectEqual(.capital, initial.combat[0x0C].class);
    try std.testing.expectEqual(.friendly, initial.combat[0x0C].side);
    try std.testing.expect(initial.combat[0x0C].targeting.targetable);
    // The Sabre, a Coalition fighter.
    try std.testing.expectEqual(.fighter, initial.combat[0x2B].class);
    try std.testing.expectEqual(.hostile, initial.combat[0x2B].side);
    try std.testing.expectEqual(0, initial.combat[0x2B].shield_power);
    // The capital ships turn flat, and the fighters bank.
    try std.testing.expectEqual(.flat, initial.flight[0x0C].turns);
    try std.testing.expectEqual(.banking, initial.flight[0x2B].turns);

    var ship = std.mem.zeroes(stats.Ship);
    ship.max_speed = 320;
    ship.pitch_rate = 2;
    ship.shield_power = 8.9;
    var tables: Stats = .initial;
    tables.load((&ship)[0..1]);
    try std.testing.expectEqual(8, tables.combat[0].shield_power);
    try std.testing.expectEqual(stats.Ship.default_shield_recharge, tables.combat[0].shield_recharge);
    try std.testing.expectEqual(160, tables.flight[0].speed_per_pitch_rate);
    // The file's figures leave the executable's words alone.
    try std.testing.expectEqual(initial.combat[0].name, tables.combat[0].name);
    try std.testing.expectEqual(initial.flight[0].turns, tables.flight[0].turns);
}

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