game.zig

//! The game side of mods' scripts ([#498](https://github.com/OpenReliant/openreliant/issues/498)):
//! the scripts that decide what happens in the game, while a game runs. A game runs from the moment
//! the front end starts a campaign, loads a saved game or flies a mission on its own (or
//! `--mission` starts one), until the front end's main menu comes back, or OpenReliant quits.
//!
//! - A mod's `Global` scripts start as the game starts, in load order, and each mod's in the order
//!   its manifest lists them. They run for the whole game.
//! - Its `[Missions]` scripts start as their mission begins, before the mission's ships are made,
//!   and stop once it ends; each attempt at a mission starts them afresh. A key of `[Missions]` is
//!   a mission's file name, such as `mission40.dte`, in any case.
//! - Its object scripts start on each object of a class (`Fighter=`) or a type
//!   (`Type.predator=`) as the object is added to the mission, and on one object when a global
//!   script adds them (`object:add_script`). They stop as their object leaves the mission, or as
//!   the mission ends. Each object a mod's scripts run on has the mod opened for it on its own, so
//!   its scripts have their own globals.
//! - Its missile scripts (`Missile=`) start on each missile as it's launched, and stop as its
//!   flight ends, or as the mission ends. Each missile has the mod opened for it on its own, as an
//!   object has.
//! - Its turret scripts (`Turret=`) start on each turret of an object as the object is added, after
//!   the object's own scripts, and stop with them. Each turret has the mod opened for it on its own.
//! - The engine calls the scripts' handlers in the order the scripts started: the global and
//!   mission scripts', then each object's, by slot, then each missile's, by record. Events sent between scripts wait for the next
//!   update (`events.zig`).
//! - `math.random` starts again at each mission's start, from the game's random numbers, so it
//!   gives the same numbers on every machine for the same game.
//!
//! An engine handler that raises an error is logged and isn't called again. If no mod has global,
//! mission or object scripts, no Luau state is created.

const std = @import("std");
const Allocator = std.mem.Allocator;
const Io = std.Io;
const log = std.log.scoped(.scripts);

const openreliant = @import("openreliant");
const mods = openreliant.engine.game.bigfile.mods;
const Mod = mods.Mod;
const create = openreliant.engine.game.create;
const engine_missiles = openreliant.engine.game.missiles;
const gameobj = openreliant.engine.game.gameobj;
const aigeneric = openreliant.engine.game.aigeneric;
const winmain = openreliant.engine.game.winmain;
const engine_hooks = openreliant.engine.hooks;
const Object = engine_hooks.Object;
const script = @import("script.zig");
const runtime = @import("runtime.zig");
const Runtime = runtime.Runtime;
const Context = runtime.Context;
const records = @import("records.zig");
const packages = @import("packages.zig");
const hooks = @import("hooks.zig");
const objects = @import("objects.zig");
const missiles = @import("missiles.zig");
const turrets = @import("turrets.zig");
const values = @import("values.zig");
const load = @import("load.zig");
const data = @import("data.zig");
const api = @import("api.zig");
const Call = api.Call;
const running = @import("running.zig");
const interfaces = @import("interfaces.zig");
const world = @import("world.zig");

/// Limits for game scripts: 100 milliseconds per call, since they run as the game plays, and
/// 64 MiB per mod.
pub const limits: runtime.Limits = .{ .time = .fromMilliseconds(100), .memory = runtime.memory_per_mod };

/// The game side of mods' scripts while a game runs.
pub const Game = struct {
    gpa: Allocator,
    runtime: *Runtime,
    /// The scripts that run, with their events and interfaces.
    runner: running.Runner,
    /// The global and mission scripts that run, then each object's, by slot, then each missile's,
    /// by record (`global`, `onObject`, `onMissile`).
    lists: [1 + gameobj.max_objects + engine_missiles.max_missiles]running.List = @splat(.empty),
    /// The handlers the scripts add to hooks.
    hooks: hooks.Hooks,
    /// What the engine calls (`create.Objects.scripts`).
    scripts: engine_hooks.Scripts,
    /// The objects of the game, which handles stand for.
    objects: *create.Objects,
    /// The mods opened for the mission's scripts, which close as it ends.
    mission_mods: std.ArrayList(*Context) = .empty,
    /// The mission that runs, if any.
    mission: ?MissionHeld = null,

    /// The mission that runs, kept from its start.
    const MissionHeld = struct {
        number: u16,
        file: [winmain.mission_path_size]u8,
        file_len: u8,

        fn of(mission: engine_hooks.Mission) MissionHeld {
            var held: MissionHeld = .{ .number = mission.number, .file = undefined, .file_len = @intCast(mission.file.len) };
            @memcpy(held.file[0..mission.file.len], mission.file);
            return held;
        }

        pub fn view(held: *const MissionHeld) engine_hooks.Mission {
            return .{ .number = held.number, .file = held.file[0..held.file_len] };
        }
    };

    /// Starts a game's scripts for `all`, the game's objects: the `Global` scripts of `opened`,
    /// which can read `held`, the records. `version` is OpenReliant's version. Returns null if no
    /// mod has global, mission or object scripts.
    /// Where `loading`, the scripts start for a saved game, whose state `snapshot.restore` puts
    /// back, so they don't get `on_init` yet.
    pub fn start(gpa: Allocator, io: Io, opened: []const Mod, held: *records.Records, version: []const u8, all: *create.Objects, shared: runtime.Shared, loading: bool) Allocator.Error!?*Game {
        const any = for (opened) |*mod| {
            var listed = globalScripts(mod);
            if (listed.next() != null) break true;
            var keys = mod.manifest.keys(script.missions_section);
            if (keys.next() != null) break true;
            if (attachesScripts(mod)) break true;
            var missile_scripts = missileScripts(mod);
            if (missile_scripts.next() != null) break true;
        } else false;
        if (!any) return null;

        const game = try gpa.create(Game);
        const scripts = Runtime.create(gpa, io, opened, .{ .side = .game, .limits = limits, .seed = load.seed, .version = version, .shared = shared }) catch |err| {
            gpa.destroy(game);
            return err;
        };
        game.* = .{
            .gpa = gpa,
            .runtime = scripts,
            .runner = undefined,
            .hooks = undefined,
            .scripts = .{ .context = game, .vtable = &vtable },
            .objects = all,
        };
        game.runner = .init(gpa, scripts, &game.lists);
        game.hooks = .init(gpa, scripts, &game.scripts);
        game.runner.hooks = &game.hooks;
        errdefer game.stop();
        const state = scripts.state;
        records.register(state);
        records.push(state, held, false);
        scripts.setPackage(.records);
        packages.push(scripts);
        hooks.Hooks.register(state);
        game.hooks.push(state);
        scripts.setPackage(.hooks);
        objects.register(scripts);
        missiles.register(scripts);
        turrets.register(scripts);
        interfaces.Interfaces.register(state);
        game.runner.interfaces.push(state);
        scripts.setPackage(.interfaces);
        scripts.objects = all;
        scripts.game = game;
        scripts.runner = &game.runner;
        all.scripts = &game.scripts;
        // An object's scripts stop as it leaves the mission, so the engine tells the scripts of
        // every object that leaves, and of every object added where manifests attach scripts.
        game.hooks.want(.object_removed);
        for (opened) |*mod| if (attachesScripts(mod)) game.hooks.want(.object_added);
        // A missile's scripts start as it's launched, and stop as its flight ends.
        for (opened) |*mod| {
            var listed = missileScripts(mod);
            if (listed.next() == null) continue;
            game.hooks.want(.missile_added);
            game.hooks.want(.missile_removed);
        }

        for (opened, 0..) |*mod, at| {
            var listed = globalScripts(mod);
            if (listed.next() == null) continue;
            listed = globalScripts(mod);
            const context = try scripts.open(@intCast(at), .global, null);
            while (listed.next()) |name| _ = try game.startScript(game.global(), context, name, false, null, loading);
        }
        return game;
    }

    /// Stops the game's scripts, as the game ends.
    pub fn stop(game: *Game) void {
        game.runtime.custom_orders.endMission(game.runtime);
        game.objects.scripts = null;
        game.stopMissionScripts();
        game.runner.deinit();
        game.mission_mods.deinit(game.gpa);
        game.hooks.deinit();
        game.runtime.destroy();
        game.gpa.destroy(game);
    }

    /// The game whose scripts make `call`. Raises an error where no game runs.
    pub fn of(call: Call) *Game {
        return call.runtime().game orelse call.raise("can only be used while a game runs", .{});
    }

    /// The global and mission scripts that run.
    pub fn global(game: *Game) *running.List {
        return &game.lists[0];
    }

    /// The scripts that run on the object in slot `index`.
    pub fn onObject(game: *Game, index: u16) *running.List {
        return &game.lists[1 + @as(usize, index)];
    }

    /// The scripts that run on the missile in record `record`.
    pub fn onMissile(game: *Game, record: u8) *running.List {
        return &game.lists[1 + gameobj.max_objects + @as(usize, record)];
    }

    /// `Runner.start`, which also has the engine tell the scripts of each object added where the
    /// script handles that.
    fn startScript(game: *Game, list: *running.List, context: *Context, name: []const u8, mission: bool, payload: ?data.Data, loading: bool) Allocator.Error!?usize {
        const at = try game.runner.start(list, context, name, mission, payload, loading) orelse return null;
        if (list.items[at].offered.handlers.get(.on_object_added) != null) game.hooks.want(.object_added);
        return at;
    }

    /// Stops the scripts of the mission, and closes the mods opened for them.
    fn stopMissionScripts(game: *Game) void {
        game.runner.walking += 1;
        defer game.runner.leave();
        const list = game.global();
        for (list.items, 0..) |held, at| {
            if (held.mission) game.runner.stopScript(list, at);
        }
        for (game.mission_mods.items) |context| {
            if (!context.closed) game.runner.closeContext(context);
        }
        game.mission_mods.clearRetainingCapacity();
    }

    /// Stops every object's and every missile's scripts, as a mission ends.
    fn stopObjectScripts(game: *Game) void {
        for (game.lists[1..]) |*list| game.runner.stopAll(list);
    }

    /// Starts the scripts that mods' manifests attach to the object in slot `index`, as it's added
    /// to the mission.
    fn objectAdded(game: *Game, index: u16) void {
        const slot = &game.objects.slots[index];
        const class = if (slot.combat) |combat| combat.class else null;
        for (game.runtime.mods, 0..) |*mod, at| {
            var keys = mod.manifest.keys(script.section);
            var context: ?*Context = null;
            while (keys.next()) |key| {
                const attachment = script.Attachment.parse(key, mod.name) orelse continue;
                const matches = switch (attachment) {
                    .kind => |kind| kind.class() != null and kind.class() == class,
                    .object_type => |object_type| object_type == slot.object.type,
                };
                if (!matches) continue;
                var listed: script.List = .of(mod.manifest.value(script.section, key) orelse "");
                while (listed.next()) |name| {
                    const opened = context orelse game.runtime.open(@intCast(at), .object, .{ .object = .of(game.objects, index) }) catch |err| {
                        log.warn("{s}: the scripts of object {d} can't start: {s}", .{ mod.name, index, @errorName(err) });
                        return;
                    };
                    context = opened;
                    _ = game.startScript(game.onObject(index), opened, name, false, null, false) catch |err| {
                        log.warn("{s}: {s} can't start on object {d}: {s}", .{ mod.name, name, index, @errorName(err) });
                    };
                }
            }
            if (context) |opened| game.runner.closeUnused(game.onObject(index), opened);
        }
        game.turretsAdded(index);
    }

    /// Starts the turret scripts of mods' manifests on each turret of the object in slot `index`, as
    /// it's added to the mission.
    fn turretsAdded(game: *Game, index: u16) void {
        const listed = turrets.on(game.objects, index);
        if (listed.len == 0) return;
        for (game.runtime.mods, 0..) |*mod, at| {
            var names = turretScripts(mod);
            if (names.next() == null) continue;
            for (listed.slice()) |turret| {
                var each = turretScripts(mod);
                const opened = game.runtime.open(@intCast(at), .object, .{ .turret = .of(game.objects, turret) }) catch |err| {
                    log.warn("{s}: the scripts of turret {d} of object {d} can't start: {s}", .{ mod.name, turret.gun, index, @errorName(err) });
                    return;
                };
                while (each.next()) |name| _ = game.startScript(game.onObject(index), opened, name, false, null, false) catch |err| {
                    log.warn("{s}: {s} can't start on turret {d} of object {d}: {s}", .{ mod.name, name, turret.gun, index, @errorName(err) });
                };
                game.runner.closeUnused(game.onObject(index), opened);
            }
        }
    }

    /// Calls the `on_removed` of the scripts of the object in slot `index`, and stops them, as it
    /// leaves the mission.
    fn objectRemoved(game: *Game, index: u16) void {
        game.runner.callEach(game.onObject(index), .on_removed, .{});
        game.runner.stopAll(game.onObject(index));
    }

    /// Starts the missile scripts of mods' manifests on the missile in record `record`, as it's
    /// launched.
    fn missileAdded(game: *Game, record: u8) void {
        for (game.runtime.mods, 0..) |*mod, at| {
            var listed = missileScripts(mod);
            var context: ?*Context = null;
            while (listed.next()) |name| {
                const opened = context orelse game.runtime.open(@intCast(at), .object, .{ .missile = .of(game.objects, record) }) catch |err| {
                    log.warn("{s}: the scripts of missile {d} can't start: {s}", .{ mod.name, record, @errorName(err) });
                    return;
                };
                context = opened;
                _ = game.startScript(game.onMissile(record), opened, name, false, null, false) catch |err| {
                    log.warn("{s}: {s} can't start on missile {d}: {s}", .{ mod.name, name, record, @errorName(err) });
                };
            }
            if (context) |opened| game.runner.closeUnused(game.onMissile(record), opened);
        }
    }

    /// Calls the `on_removed` of the scripts of the missile in record `record`, and stops them, as
    /// its flight ends.
    fn missileRemoved(game: *Game, record: u8) void {
        game.runner.callEach(game.onMissile(record), .on_removed, .{});
        game.runner.stopAll(game.onMissile(record));
    }

    /// Delivers the events sent since the last update (`events.zig`).
    fn deliver(game: *Game) void {
        var pending = game.runner.events.take();
        defer pending.deinit(game.gpa);
        for (pending.items) |*sent| {
            defer game.runtime.release(sent.data.ref);
            const list = switch (sent.to) {
                .global => game.global(),
                .object => |handle| if (handle.valid(game.objects)) game.onObject(handle.slot) else continue,
            };
            game.runner.deliverTo(list, sent);
        }
    }

    fn ofScripts(context: *anyopaque) *Game {
        return @ptrCast(@alignCast(context));
    }

    const vtable: engine_hooks.Scripts.VTable = .{
        .call = hookCall,
        .begin = begin,
        .frame = frame,
        .started = started,
        .ended = ended,
        .update = update,
        .step = step,
        .order_info = orderInfo,
        .order_run = orderRun,
    };

    fn orderInfo(context: *anyopaque, order: openreliant.engine.game.ai.orders.Order) ?openreliant.engine.game.ai.orders.Info {
        return ofScripts(context).runtime.custom_orders.info(order);
    }

    fn orderRun(context: *anyopaque, ctx: aigeneric.Context, index: u16, order: openreliant.engine.game.ai.orders.Order, role: openreliant.engine.game.ai.routines.Role) bool {
        const game = ofScripts(context);
        return game.runtime.custom_orders.run(game.runtime, ctx, index, order, role);
    }

    fn hookCall(context: *anyopaque, hook_call: *engine_hooks.Call) void {
        const game = ofScripts(context);
        switch (hook_call.hook) {
            .object_added => {
                const index = objectOf(hook_call);
                game.objectAdded(index);
                game.runner.callEach(game.global(), .on_object_added, .{ .object = .of(index) });
            },
            .object_removed => {
                const index = objectOf(hook_call);
                if (game.runtime.orders) |ctx| aigeneric.forgetCustom(ctx, index);
                game.runner.callEach(game.global(), .on_object_removed, .{ .object = .of(index) });
                game.objectRemoved(index);
            },
            .missile_added => game.missileAdded(missileOf(hook_call)),
            .missile_removed => game.missileRemoved(missileOf(hook_call)),
            else => {},
        }
        game.hooks.run(hook_call);
    }

    /// The missile of a `missile_added` or `missile_removed` call.
    fn missileOf(hook_call: *engine_hooks.Call) u8 {
        const fields: *const engine_hooks.Fields(.missile_added) = @ptrCast(@alignCast(hook_call.fields));
        return fields.missile.record();
    }

    /// The object of an `object_added` or `object_removed` call.
    fn objectOf(hook_call: *engine_hooks.Call) u16 {
        const fields: *const engine_hooks.Fields(.object_added) = @ptrCast(@alignCast(hook_call.fields));
        return fields.object.slot();
    }

    fn begin(context: *anyopaque, orders: aigeneric.Context, mission: engine_hooks.Mission, seed: u64) void {
        const game = ofScripts(context);
        game.stopObjectScripts();
        game.stopMissionScripts();
        game.runtime.reseed(seed);
        game.runtime.orders = orders;
        game.mission = .of(mission);
        for (game.runtime.mods, 0..) |*mod, at| {
            var listed = missionScripts(mod, mission.file) orelse continue;
            game.startMissionScripts(@intCast(at), &listed) catch |err| log.warn("{s}: the scripts of {s} can't start: {s}", .{ mod.name, mission.file, @errorName(err) });
        }
    }

    /// Starts the scripts of a mission that runs already, as the scripts are reloaded partway
    /// through it: the mission's scripts, and the scripts manifests attach to each object in it,
    /// as its start would have them (`begin`), but without `on_mission_start` or
    /// `on_object_added`.
    pub fn resumeMission(game: *Game, orders: aigeneric.Context, mission: engine_hooks.Mission, seed: u64) void {
        begin(game, orders, mission, seed);
        for (0..game.objects.slots.len) |index| {
            if (world.inMission(game.objects, @intCast(index))) game.objectAdded(@intCast(index));
        }
    }

    fn startMissionScripts(game: *Game, mod: u16, listed: *script.List) Allocator.Error!void {
        try game.mission_mods.ensureUnusedCapacity(game.gpa, 1);
        const context = try game.runtime.open(mod, .global, null);
        game.mission_mods.appendAssumeCapacity(context);
        while (listed.next()) |name| _ = try game.startScript(game.global(), context, name, true, null, false);
    }

    /// Keeps the world the frame has as what the scripts' orders run against, while a mission runs:
    /// the copy `begin` kept holds pointers that can change between frames.
    fn frame(context: *anyopaque, orders: aigeneric.Context) void {
        const game = ofScripts(context);
        if (game.runtime.orders != null) game.runtime.orders = orders;
    }

    fn started(context: *anyopaque, mission: engine_hooks.Mission) void {
        const game = ofScripts(context);
        game.runner.callEach(game.global(), .on_mission_start, .{ .mission = mission });
        engine_hooks.tell(&game.scripts, .mission_started, mission);
    }

    fn ended(context: *anyopaque, outcome: engine_hooks.Outcome) void {
        const game = ofScripts(context);
        game.runner.callEach(game.global(), .on_mission_end, .{ .outcome = outcome });
        engine_hooks.tell(&game.scripts, .mission_ended, outcome);
        game.runtime.custom_orders.endMission(game.runtime);
        game.stopObjectScripts();
        game.stopMissionScripts();
        game.runtime.orders = null;
        game.mission = null;
    }

    fn update(context: *anyopaque, seconds: f32) void {
        const game = ofScripts(context);
        game.deliver();
        game.runner.advance(seconds);
        game.runner.callAll(.on_update, .{ .seconds = seconds });
    }

    fn step(context: *anyopaque) void {
        ofScripts(context).runner.callAll(.on_step, .{});
    }
};

/// The `Global` scripts `mod` lists, in order.
fn globalScripts(mod: *const Mod) script.List {
    return .of(mod.manifest.value(script.section, script.Kind.global.key()) orelse "");
}

/// The scripts `mod` runs on each turret.
fn turretScripts(mod: *const Mod) script.List {
    return .of(mod.manifest.value(script.section, script.Kind.turret.key()) orelse "");
}

/// The scripts `mod` runs on each missile in flight.
fn missileScripts(mod: *const Mod) script.List {
    return .of(mod.manifest.value(script.section, script.Kind.missile.key()) orelse "");
}

/// Whether `mod`'s manifest attaches scripts to objects by their class or type, or to their turrets.
fn attachesScripts(mod: *const Mod) bool {
    var keys = mod.manifest.keys(script.section);
    while (keys.next()) |key| {
        const attachment = script.Attachment.parse(key, mod.name) orelse continue;
        switch (attachment) {
            .kind => |kind| if (kind.class() != null or kind == .turret) return true,
            .object_type => return true,
        }
    }
    return false;
}

/// The scripts `mod` lists under `[Missions]` for the mission file `file`, if any.
fn missionScripts(mod: *const Mod, file: []const u8) ?script.List {
    var keys = mod.manifest.keys(script.missions_section);
    while (keys.next()) |key| {
        if (!std.ascii.eqlIgnoreCase(key, file)) continue;
        return .of(mod.manifest.value(script.missions_section, key) orelse "");
    }
    return null;
}

/// `object:add_script(name, data)`.
pub fn addScript(call: Call, object: Object, name: []const u8, payload: ?data.Data) bool {
    // Luau's errors skip Zig's defers, so the payload is let go by hand before each.
    const drop = struct {
        fn drop(scripts: *Runtime, given: ?data.Data) void {
            if (given) |held| scripts.release(held.ref);
        }
    }.drop;
    const scripts = call.runtime();
    if (call.context.family != .global) {
        drop(scripts, payload);
        call.raise("only global scripts can add scripts", .{});
    }
    const game = scripts.game orelse {
        drop(scripts, payload);
        call.raise("can only be used while a game runs", .{});
    };
    const mod = call.context.modOf();
    const file = script.find(mod, name) orelse {
        drop(scripts, payload);
        call.raise("mod {s} has no script {s}", .{ mod.name, name });
    };
    const index = object.slot();
    const list = game.onObject(index);
    for (list.items) |held| {
        if (held.stopped or held.context.mod != call.context.mod) continue;
        if (std.ascii.eqlIgnoreCase(held.name, file)) {
            drop(scripts, payload);
            return false;
        }
    }
    const context = for (list.items) |held| {
        if (!held.stopped and held.context.mod == call.context.mod) break held.context;
    } else scripts.open(call.context.mod, .object, .{ .object = .of(game.objects, index) }) catch {
        drop(scripts, payload);
        call.raise("out of memory", .{});
    };
    const started = game.startScript(list, context, file, false, payload, false) catch {
        game.runner.closeUnused(list, context);
        call.raise("out of memory", .{});
    };
    if (started == null) game.runner.closeUnused(list, context);
    return started != null;
}

/// `object:remove_script(name)`.
pub fn removeScript(call: Call, object: Object, name: []const u8) bool {
    const game = Game.of(call);
    if (call.context.family != .global) call.raise("only global scripts can remove scripts", .{});
    const list = game.onObject(object.slot());
    for (list.items, 0..) |held, at| {
        if (held.stopped or held.context.mod != call.context.mod) continue;
        if (!script.isNamed(held.name, name)) continue;
        game.runner.stopScript(list, at);
        return true;
    }
    return false;
}

/// `object:send_event(name, data)`.
pub fn sendEvent(call: Call, object: Object, name: []const u8, payload: data.Data) void {
    const game = call.runtime().game orelse {
        call.runtime().release(payload.ref);
        call.raise("events can only be sent while a game runs", .{});
    };
    game.runner.events.send(call, .{ .object = .of(game.objects, object.slot()) }, name, payload);
}

/// `core.send_global_event(name, data)`.
pub fn sendGlobalEvent(call: Call, name: []const u8, payload: data.Data) void {
    if (call.runtime().presentation) |shown| return shown.sendToGame(call, name, payload);
    const game = call.runtime().game orelse {
        call.runtime().release(payload.ref);
        call.raise("events can only be sent while a game runs", .{});
    };
    game.runner.events.send(call, .global, name, payload);
}

/// A game with the mods `made`, each a folder of files, over a mission that holds the player's
/// Predator and a Sabre.
const Fixture = struct {
    tmp: std.testing.TmpDir,
    mods: mods.Mods,
    arena: std.heap.ArenaAllocator,
    held: records.Records,
    mission: gameobj.testing.Mission,
    game: *Game,
    sabre: u16,

    const collision = openreliant.engine.game.collision;

    fn init(fixture: *Fixture, made: []const struct { []const u8, []const struct { []const u8, []const u8 } }) !void {
        return fixture.initShared(made, .{});
    }

    /// `init`, with what the mods share; where it has a registry of options, the load scripts run
    /// first, to declare the pages the others read.
    fn initShared(fixture: *Fixture, made: []const struct { []const u8, []const struct { []const u8, []const u8 } }, shared: runtime.Shared) !void {
        const gpa = std.testing.allocator;
        const io = std.testing.io;
        fixture.tmp = std.testing.tmpDir(.{ .iterate = true });
        errdefer fixture.tmp.cleanup();
        try load.testing.makeMods(io, fixture.tmp.dir, made);
        fixture.mods = try .open(gpa, io, fixture.tmp.dir, null);
        errdefer fixture.mods.close(gpa);
        fixture.arena = .init(gpa);
        errdefer fixture.arena.deinit();
        fixture.held = try load.testing.records3(fixture.arena.allocator());
        try fixture.mission.init(gpa);
        errdefer fixture.mission.deinit();
        _ = try fixture.mission.add(.of(.predator), @splat(0));
        if (shared.option_pages != null) try load.run(gpa, io, fixture.mods.list, &fixture.held, "0.7.0", shared);
        fixture.game = (try Game.start(gpa, io, fixture.mods.list, &fixture.held, "0.7.0", fixture.mission.objects, shared, false)).?;
        fixture.sabre = try fixture.mission.add(.of(.sabre), .{ 0, 0, 1000 });
    }

    fn deinit(fixture: *Fixture) void {
        fixture.game.stop();
        fixture.mission.deinit();
        fixture.arena.deinit();
        fixture.mods.close(std.testing.allocator);
        fixture.tmp.cleanup();
    }

    /// What the game's difficulty makes of `value`, dealt to the object in slot `index` by a
    /// missile, through the hooks.
    fn scaled(fixture: *Fixture, index: u16, value: f32) f32 {
        return collision.byDifficulty(fixture.mission.world(), index, .missile, value);
    }

    /// Begins mission 5, as the engine does before its ships are made.
    fn begin(fixture: *Fixture) void {
        fixture.game.scripts.begin(fixture.mission.orders(), .{ .number = 5, .file = "mission5.dte" }, 1);
    }
};

test "custom orders use qualified names, lifecycle callbacks and the engine stack" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{
            "a",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
                .{
                    "a.luau",
                    \\local orders = require("openreliant.orders")
                    \\local world = require("openreliant.world")
                    \\local started, updated, exited = 0, 0, 0
                    \\local own
                    \\own = orders.register("hold", {
                    \\    priority = 2, flags = {avoidance = true},
                    \\    init = function(ship, target) started += 1; assert(target == world.objects()[1]) end,
                    \\    update = function(ship, target, seconds)
                    \\        updated += 1; ship.throttle = 0.25
                    \\        assert(ship.order == "a:hold" and orders.stack(ship)[1].order == own)
                    \\        return updated < 2
                    \\    end,
                    \\    exit = function(ship) exited += 1; ship.throttle = 0.5 end,
                    \\})
                    \\assert(own == "a:hold")
                    \\assert(not pcall(function() orders.register("hold", {update = function() end}) end))
                    \\return { engine_handlers = {on_mission_start = function()
                    \\    local ships = world.objects(); local ship = ships[2]
                    \\    assert(orders.info(own).priority == 2 and orders.info(own).flags.avoidance)
                    \\    assert(orders.info("b:hold") ~= nil and orders.info("hold").name == own)
                    \\    assert(not ships[1]:give_order(own))
                    \\    assert(ship:give_order("do_nothing") and ship:give_order(own, ships[1]))
                    \\end, on_update = function()
                    \\    assert(started == 1 and updated == 2 and exited == 1)
                    \\end} }
                },
            },
        },
        .{ "b", &.{ .{ "mod.ini", "[Scripts]\nGlobal=b.luau\n" }, .{ "b.luau", "assert(require('openreliant.orders').register('hold', {update = function() end}) == 'b:hold')" } } },
    });
    defer fixture.deinit();
    fixture.begin();
    fixture.game.scripts.started(.{ .number = 5, .file = "mission5.dte" });
    const ctx = fixture.mission.orders();
    aigeneric.objectOrders(ctx, fixture.sabre);
    try std.testing.expectEqual(0.25, fixture.mission.slot(fixture.sabre).object.throttle);
    try std.testing.expectError(error.OrderConflict, aigeneric.push(ctx, fixture.sabre, .fly_aimlessly, .none));
    aigeneric.objectOrders(ctx, fixture.sabre);
    try std.testing.expectEqual(0.5, fixture.mission.slot(fixture.sabre).object.throttle);
    try std.testing.expect(fixture.game.runtime.custom_orders.entries.items[1].enabled);
    try std.testing.expectEqual(.do_nothing, fixture.mission.slot(fixture.sabre).current().?.order);
    fixture.game.scripts.update(0.04);
    try std.testing.expect(fixture.game.runtime.custom_orders.entries.items[0].enabled);
}

test "a script launches a ship from a carrier's gate" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local world = require("openreliant.world")
                \\return { engine_handlers = {on_mission_start = function()
                \\    local carrier, ship = world.objects()[1], world.objects()[2]
                \\    assert(not ship:start_launch())
                \\    assert(not pcall(ship.give_order, ship, "launch", nil, 1))
                \\    assert(not pcall(ship.give_order, ship, "launch", carrier, 256))
                \\    assert(ship:give_order("launch", carrier, 1))
                \\    assert(ship:start_launch())
                \\end} }
            },
        },
    }});
    defer fixture.deinit();
    fixture.begin();
    fixture.game.scripts.started(.{ .number = 5, .file = "mission5.dte" });
    const launch = fixture.mission.slot(fixture.sabre).firstOrder(.launch).?;
    try std.testing.expectEqual(1, launch.target.part().?);
    try std.testing.expect(launch.data.launch.go);
}

test "custom order failures disable callbacks and context closure removes stacked orders" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local orders = require("openreliant.orders")
                \\local world = require("openreliant.world")
                \\orders.register("broken", {update = function(ship) ship:give_order("do_nothing") end})
                \\orders.register("hold", {priority = 3, update = function() end, exit = function(ship) ship.throttle = 0.75 end})
                \\return {engine_handlers = {on_mission_start = function()
                \\    local ship = world.objects()[2]
                \\    assert(ship:give_order("do_nothing") and ship:give_order("a:broken"))
                \\end}}
            },
        },
    }});
    defer fixture.deinit();
    fixture.begin();
    fixture.game.scripts.started(.{ .number = 5, .file = "mission5.dte" });
    const ctx = fixture.mission.orders();
    aigeneric.objectOrders(ctx, fixture.sabre);
    try std.testing.expect(!fixture.game.runtime.custom_orders.entries.items[0].enabled);
    try std.testing.expectEqual(.do_nothing, fixture.mission.slot(fixture.sabre).current().?.order);
    const hold = fixture.game.runtime.custom_orders.find("a:hold").?;
    try std.testing.expect(aigeneric.give(ctx, fixture.sabre, hold, .none));
    aigeneric.objectOrders(ctx, fixture.sabre);
    fixture.game.runtime.close(fixture.game.runtime.custom_orders.entries.items[1].context);
    try std.testing.expectEqual(0.75, fixture.mission.slot(fixture.sabre).object.throttle);
    try std.testing.expectEqual(.do_nothing, fixture.mission.slot(fixture.sabre).current().?.order);
    try std.testing.expectEqual(null, fixture.game.runtime.custom_orders.find("a:hold"));
}

test "one-shot custom orders skip init and exit and mission end removes custom stacks" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local orders = require("openreliant.orders")
                \\local world = require("openreliant.world")
                \\orders.register("hold", {update = function() end, exit = function(ship) ship.throttle = 0.75 end})
                \\orders.register("once", {flags = {one_shot = true, players = true},
                \\    init = function() error("must not init") end,
                \\    update = function(ship) ship.throttle = 0.5 end,
                \\    exit = function() error("must not exit") end})
                \\return {engine_handlers = {on_mission_start = function()
                \\    local ship = world.objects()[2]
                \\    assert(ship:give_order("do_nothing") and ship:give_order("a:hold") and ship:give_order("a:once"))
                \\end}}
            },
        },
    }});
    defer fixture.deinit();
    fixture.begin();
    fixture.game.scripts.started(.{ .number = 5, .file = "mission5.dte" });
    aigeneric.objectOrders(fixture.mission.orders(), fixture.sabre);
    const hold = fixture.game.runtime.custom_orders.find("a:hold").?;
    try std.testing.expectEqual(hold, fixture.mission.slot(fixture.sabre).current().?.order);
    try std.testing.expectEqual(0.5, fixture.mission.slot(fixture.sabre).object.throttle);
    fixture.game.scripts.ended(.{ .ending = .playing, .rating = .success });
    try std.testing.expectEqual(0.75, fixture.mission.slot(fixture.sabre).object.throttle);
    try std.testing.expectEqual(.do_nothing, fixture.mission.slot(fixture.sabre).current().?.order);
    // Global registrations remain available in the next mission, with the same qualified names.
    try std.testing.expectEqual(hold, fixture.game.runtime.custom_orders.find("a:hold").?);
}

test "mission order registrations close and register again without stale numeric IDs" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "a", &.{
        .{ "mod.ini", "[Missions]\nmission5.dte=a.luau\n" },
        .{ "a.luau", "require('openreliant.orders').register('hold', {update = function() end})" },
    } }});
    defer fixture.deinit();
    fixture.begin();
    const old = fixture.game.runtime.custom_orders.find("a:hold").?;
    try std.testing.expect(aigeneric.give(fixture.mission.orders(), fixture.sabre, old, .none));
    aigeneric.objectOrders(fixture.mission.orders(), fixture.sabre);
    // Starting the context again models the shutdown/restart path used on reload.
    fixture.begin();
    const new = fixture.game.runtime.custom_orders.find("a:hold").?;
    try std.testing.expect(old != new);
    try std.testing.expectEqual(0, fixture.mission.slot(fixture.sabre).object.order_count);
    try std.testing.expect(aigeneric.give(fixture.mission.orders(), fixture.sabre, new, .none));
}

test "the custom order example runs and completes its throttle pulse" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "custom-order", &.{
        .{ "mod.ini", @embedFile("custom-order/mod.ini") },
        .{ "pulse.luau", @embedFile("custom-order/pulse.luau") },
    } }});
    defer fixture.deinit();
    fixture.begin();
    fixture.game.scripts.started(.{ .number = 5, .file = "mission5.dte" });
    const pulse = fixture.game.runtime.custom_orders.find("custom-order:pulse").?;
    try std.testing.expectEqual(pulse, fixture.mission.slot(fixture.sabre).current().?.order);
    fixture.mission.clock.frame_duration = 100;
    aigeneric.objectOrders(fixture.mission.orders(), fixture.sabre);
    try std.testing.expectEqual(0.25, fixture.mission.slot(fixture.sabre).object.throttle);
    aigeneric.objectOrders(fixture.mission.orders(), fixture.sabre);
    try std.testing.expectEqual(0, fixture.mission.slot(fixture.sabre).object.order_count);
    try std.testing.expectEqual(0, fixture.mission.slot(fixture.sabre).object.throttle);
}

test "handlers run newest mod first, in the order each mod added them" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{ "a", &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{ "a.luau", "require('openreliant.hooks').add('damage_by_difficulty', function(e) e.value = e.value * 10 + 1 end)" },
        } },
        .{
            "b",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=b.luau\n" },
                .{
                    "b.luau",
                    \\local hooks = require("openreliant.hooks")
                    \\hooks.add("damage_by_difficulty", function(e) e.value = e.value * 10 + 2 end)
                    \\hooks.add("damage_by_difficulty", function(e) e.value = e.value * 10 + 3 end)
                    \\hooks.after("damage_by_difficulty", function(e) e.result += 1000 end, { type = "sabre" })
                    \\-- A hit by the player on a Sabre does nothing.
                    \\hooks.add("object_damage", function(e)
                    \\    if e.attacker.is_player and e.object.type == "sabre" then return false end
                    \\end)
                },
            },
        },
    });
    defer fixture.deinit();
    // Mod b's two, in order, then mod a's; the handler after the function is only for the Sabre.
    try std.testing.expectEqual(1231, fixture.scaled(fixture.sabre, 0));
    // The player's ship takes half at medium difficulty.
    try std.testing.expectEqual(115.5, fixture.scaled(0, 0));

    const shields = &fixture.mission.objects.slots[fixture.sabre].object.shields;
    shields.* = .all(100);
    Fixture.collision.damage(fixture.mission.world(), fixture.sabre, .fore, 50, 1, 0, .bullet);
    try std.testing.expectEqual(100, shields.get(.fore));
}

test "a script stops and retargets the orders given, and keeps one from ending" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local hooks = require("openreliant.hooks")
                \\local orders = require("openreliant.orders")
                \\hooks.add("order_push", function(e)
                \\    -- No ship runs away, and an order aimed at the player is aimed at the ship itself.
                \\    if e.order == "run_away" then return false end
                \\    if e.target.object ~= nil and e.target.object.is_player then
                \\        assert(e.target.component == nil and e.target.flight_group == nil)
                \\        e.target = { object = e.object }
                \\    end
                \\end)
                \\hooks.after("order_push", function(e) assert(e.result == "taken" or e.result == "refused") end)
                \\-- An escort never ends.
                \\hooks.add("order_pop", function(e)
                \\    if orders.stack(e.object)[1].order == "escort" then return false end
                \\end)
                \\hooks.add("missile_launch", function(e) assert(e.target.object == nil) end)
            },
        },
    }});
    defer fixture.deinit();
    const ctx = fixture.mission.orders();
    const slot = fixture.mission.slot(fixture.sabre);
    const pushed_before = slot.stack().len;
    // Stopped, the order isn't pushed.
    try std.testing.expect(!aigeneric.give(ctx, fixture.sabre, .run_away, .at(0, null)));
    try std.testing.expectEqual(pushed_before, slot.stack().len);
    // Aimed at the player, it is aimed at the Sabre itself.
    try std.testing.expect(aigeneric.give(ctx, fixture.sabre, .escort, .at(0, null)));
    try std.testing.expectEqual(aigeneric.Target.at(fixture.sabre, null), slot.current().?.target);
    // A target the scripts don't change goes through as it was, a squad's too.
    try std.testing.expect(aigeneric.give(ctx, fixture.sabre, .fly_aimlessly, .group(.squad, 3)));
    try std.testing.expectEqual(aigeneric.Target.group(.squad, 3), slot.current().?.target);
    // The order on top ends, and the escort under it doesn't.
    try std.testing.expect(aigeneric.pop(ctx, fixture.sabre));
    try std.testing.expect(!aigeneric.pop(ctx, fixture.sabre));
    try std.testing.expectEqual(openreliant.engine.game.ai.orders.Order.escort, slot.current().?.order);
}

test "a script stops or changes the radio's lines" {
    const radio_module = openreliant.engine.game.radio;
    const hog_snd = openreliant.engine.game.hog_snd;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local hooks = require("openreliant.hooks")
                \\hooks.add("radio_say", function(e)
                \\    if e.speech:find("ms_hudtr", 1, true) then return false end
                \\    if e.speech == "plck_001.ut" then e.speech = "moolnd_001.ut" end
                \\end)
            },
        },
    }});
    defer fixture.deinit();
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var archives: radio_module.testing.Archives = undefined;
    try archives.init(gpa, io, &.{}, &.{});
    defer archives.deinit();
    var speaker: hog_snd.testing.Speaker = undefined;
    try speaker.init(2, null);
    defer speaker.deinit();
    var radio = archives.radio(gpa, io);
    defer radio.deinit();
    const ctx: radio_module.Context = .{ .sounds = &speaker.asked, .windows = null, .all = fixture.mission.objects, .frame_start = 0 };
    var line: radio_module.Line = .{ .film = "pilots\\static.fm8", .speech = "ms_speech\\ms_hudtr_001.ut", .name = null, .object = radio_module.nobody };

    // The simulator's line is stopped: nothing waits.
    radio.say(ctx, line, .queued);
    try std.testing.expectEqual(0, radio.count);
    // Another is said in place of the one asked for, and the rest as they are.
    line.speech = "plck_001.ut";
    radio.say(ctx, line, .queued);
    line.speech = "mphud_001.ut";
    radio.say(ctx, line, .queued);
    try std.testing.expectEqual(2, radio.count);
    try std.testing.expectEqualStrings("moolnd_001.ut", radio.queue[0].speech.slice());
    try std.testing.expectEqualStrings("pilots\\static.fm8", radio.queue[0].film.slice());
    try std.testing.expectEqualStrings("mphud_001.ut", radio.queue[1].speech.slice());
}

test "a script says lines on the radio, as the comms commands do" {
    const radio_module = openreliant.engine.game.radio;
    const hog_snd = openreliant.engine.game.hog_snd;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local radio = require("openreliant.radio")
                \\local world = require("openreliant.world")
                \\-- Between missions, nothing is said.
                \\assert(not radio.say_pilot("diceman", "ms_dice22_001.ut"))
                \\return {
                \\    engine_handlers = {
                \\        on_mission_start = function()
                \\            assert(radio.say_pilot("diceman", "ms_dice22_001.ut", { mode = "queued" }))
                \\            assert(radio.say(world.player, "ms_dice22_002.ut", { mode = "queued", face = "laughing", once = true }))
                \\        end,
                \\    },
                \\}
            },
        },
    }});
    defer fixture.deinit();
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var archives: radio_module.testing.Archives = undefined;
    try archives.init(gpa, io, &.{}, &.{});
    defer archives.deinit();
    var speaker: hog_snd.testing.Speaker = undefined;
    try speaker.init(2, null);
    defer speaker.deinit();
    var radio = archives.radio(gpa, io);
    defer radio.deinit();
    var heard = fixture.mission.world();
    heard.radio = &radio;
    speaker.hear(&heard);
    fixture.game.scripts.begin(.of(heard), .{ .number = 22, .file = "mission22.dte" }, 1);
    fixture.game.scripts.started(.{ .number = 22, .file = "mission22.dte" });

    // Diceman by his pilot, his face talking and looping; the player's ship by its pilot's face,
    // laughing, played once.
    try std.testing.expectEqual(2, radio.count);
    const diceman = radio.queue[0];
    try std.testing.expectEqualStrings("ms_dice22_001.ut", diceman.speech.slice());
    try std.testing.expectEqual(radio_module.pilot_base + @backingInt(openreliant.engine.game.pilots.GamePilot.diceman), diceman.object);
    try std.testing.expectEqual(openreliant.engine.game.hudmovie.Flags.looping, diceman.flags);
    const ship = radio.queue[1];
    try std.testing.expectEqualStrings("ms_dice22_002.ut", ship.speech.slice());
    try std.testing.expectEqual(@as(i32, fixture.mission.objects.player), ship.object);
    try std.testing.expectEqual(openreliant.engine.game.hudmovie.Flags.once, ship.flags);
}

test "a script sets the state of a mission's objectives, as SetObjective does" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local world = require("openreliant.world")
                \\-- Between missions, nothing changes.
                \\assert(not world.set_objective(0, "current"))
                \\return {
                \\    engine_handlers = {
                \\        on_mission_start = function()
                \\            assert(world.set_objective(1, "listed"))
                \\            assert(world.set_objective(2, "current"))
                \\            assert(world.set_objective(0, "hidden"))
                \\            assert(not pcall(world.set_objective, 10, "listed"))
                \\            assert(not pcall(world.set_objective, 0, "finished"))
                \\        end,
                \\    },
                \\}
            },
        },
    }});
    defer fixture.deinit();
    var display: openreliant.engine.game.hud.State = .{};
    display.objectives.reset(22, false, null);
    var shown = fixture.mission.world();
    shown.display = &display;
    fixture.game.scripts.begin(.of(shown), .{ .number = 22, .file = "mission22.dte" }, 1);
    fixture.game.scripts.started(.{ .number = 22, .file = "mission22.dte" });
    try std.testing.expectEqual(.hidden, display.objectives.states[0]);
    try std.testing.expectEqual(.listed, display.objectives.states[1]);
    try std.testing.expectEqual(.current, display.objectives.states[2]);
    try std.testing.expectEqual(2, display.objectives.shown);
}

test "a script reads and sets the game's variables, a mod's by its name" {
    const variables_added = openreliant.engine.game.additions.variables;
    var added = [_]variables_added.Added{.{ .name = "a:pirates_beaten", .mod = "a", .base = {}, .based = false, .extra = .{} }};
    variables_added.install(&added);
    defer variables_added.reset();
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local world = require("openreliant.world")
                \\-- Between missions, there are none.
                \\assert(world.variable("krasnaya_alive") == nil and not world.set_variable("krasnaya_alive", 1))
                \\return {
                \\    engine_handlers = {
                \\        on_mission_start = function()
                \\            assert(world.variable("krasnaya_alive") == 1 and world.variable(17) == 1)
                \\            assert(world.variable("mission_success") == -1)
                \\            assert(world.set_variable("krasnaya_alive", 0))
                \\            -- The mod's own, by its own name or its qualified one.
                \\            assert(world.set_variable("pirates_beaten", 3))
                \\            assert(world.variable("a:pirates_beaten") == 3)
                \\            assert(not pcall(world.variable, "pirates"))
                \\        end,
                \\    },
                \\}
            },
        },
    }});
    defer fixture.deinit();
    var variables: openreliant.engine.vm.Variables = .{};
    variables.krasnaya_alive = 1;
    variables.mission_success = .total_failure;
    var shown = fixture.mission.world();
    shown.variables = &variables;
    fixture.game.scripts.begin(.of(shown), .{ .number = 22, .file = "mission22.dte" }, 1);
    fixture.game.scripts.started(.{ .number = 22, .file = "mission22.dte" });
    try std.testing.expectEqual(0, variables.krasnaya_alive);
    try std.testing.expectEqual(3, variables.slot(variables_added.first).*);
}

test "scripts list a ship's parts, destroy it, and set the player's targets" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local world = require("openreliant.world")
                \\return {
                \\    engine_handlers = {
                \\        on_mission_start = function()
                \\            local sabre = world.objects()[2]
                \\            local parts = sabre:parts()
                \\            assert(#parts == 2 and #sabre:attachments() == 0)
                \\            -- Its hull is already destroyed, and keeps its number.
                \\            assert(parts[1].class == "hull" and parts[1].destroyed and parts[1].component == 0)
                \\            assert(parts[2].class == "engine" and not parts[2].destroyed and parts[2].component == 1)
                \\            assert(not sabre:destroy_component(0))
                \\            assert(not pcall(sabre.destroy_component, sabre, 2))
                \\            assert(sabre:destroy_component(1))
                \\            assert(world.set_primary_target(sabre, 1))
                \\            assert(not world.set_player_target(sabre, 0))
                \\            -- With no hull left to lose, it explodes.
                \\            assert(sabre:destroy())
                \\            assert(sabre.order == "explode" and not sabre:destroy())
                \\        end,
                \\    },
                \\}
            },
        },
    }});
    defer fixture.deinit();
    // The Sabre's hull and engine are components, and the hull is destroyed.
    const engine_objects = openreliant.engine.game.objects;
    var parts: engine_objects.testing.Parts(2) = undefined;
    parts.init();
    parts.components(.{ true, true }, .{ 1, 2 });
    parts.data[0].part.class = .hull;
    parts.data[1].part.class = .engine;
    const slot = &fixture.mission.objects.slots[fixture.sabre];
    slot.model = try parts.create(std.testing.allocator);
    slot.object.flags.components = true;
    create.collectComponents(slot);
    engine_objects.destroyPart(slot, .{ .model = &slot.model.?, .index = 0 });
    fixture.begin();
    fixture.game.scripts.started(.{ .number = 5, .file = "mission5.dte" });
    try std.testing.expect(slot.model.?.destroyed and slot.model.?.parts[1].armor < 0);
    try std.testing.expectEqual(fixture.sabre, fixture.mission.player.primary_target.?.index);
    try std.testing.expectEqual(1, fixture.mission.player.primary_target.?.component);
    try std.testing.expect(slot.object.flags.exploding);
}

test "a script chooses the movies of a mission's end, and the restart screen's choice" {
    const engine_game = openreliant.engine.game;
    const movie = engine_game.xtrabits.movie;
    const restart = engine_game.interface.restart;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local hooks = require("openreliant.hooks")
                \\hooks.add("mission_lost", function(e)
                \\    if e.ending == "destroyed" and e.movie == nil then e.movie = "prequel_funeral.bik" end
                \\end)
                \\hooks.after("career_over", function(e) e.result = nil end)
                \\hooks.add("medal_ceremony", function(e)
                \\    if e.medal == "silver" then return false end
                \\end)
                \\hooks.add("restart_screen", function(e)
                \\    e.result = "replay_from_launch"
                \\    return false
                \\end)
            },
        },
    }});
    defer fixture.deinit();
    const all = fixture.mission.objects;

    // A game mode's lost mission plays the script's movie, and the campaign's capture its own.
    try std.testing.expectEqualStrings("prequel_funeral.bik", std.mem.sliceTo(&engine_game.winmain.lostMovie(all, .destroyed, .failure, 1, null).?, 0));
    const capture = movie.nameOf("int.bik").?;
    try std.testing.expectEqual(capture, engine_game.winmain.lostMovie(all, .captured, .failure, 5, capture).?);
    // The career ends without a movie, and the silver medal's ceremony doesn't play.
    try std.testing.expectEqual(null, engine_game.winmain.careerOverMovie(all, .rescued, .success, 5, capture));
    try std.testing.expectEqual(null, engine_game.gameflow.ceremonyMovie(all, .silver, 6, movie.nameOf("new_silver.bik")));
    const valour = movie.nameOf("new_valour.bik").?;
    try std.testing.expectEqual(valour, engine_game.gameflow.ceremonyMovie(all, .valour, 16, valour).?);
    // The script flies the mission again from its launch without showing the restart screen.
    const never: restart.Shown = .{ .context = undefined, .run = struct {
        fn run(_: *anyopaque) restart.Choice {
            unreachable;
        }
    }.run };
    try std.testing.expectEqual(.replay_from_launch, restart.choose(all, never));
}

test "built-in interfaces provide existing APIs beneath mod overrides" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local I = require("openreliant.interfaces")
                \\assert(I.Flight.look_at(vector.create(0, 0, 1)).forward == vector.create(0, 0, 1))
                \\assert(I.AI.info("fight").name == "Fight")
                \\assert(I.Camera == nil and I.HUD == nil)
                \\I.Combat.add_hook("damage_by_difficulty", function(e) e.value *= 2 end)
                \\return {interface_name = "AI", interface = {custom = true}, engine_handlers = {
                \\    on_interface_override = function(base) assert(base.info("fight").name == "Fight") end,
                \\    on_update = function() assert(I.AI.custom) end,
                \\}}
            },
        },
    }});
    defer fixture.deinit();
    try std.testing.expectEqual(4, fixture.scaled(fixture.sabre, 2));
    fixture.game.scripts.update(0.04);
    const context = fixture.game.global().items[0].context;
    fixture.game.runner.stopAll(fixture.game.global());
    try std.testing.expect(context.closed);
    const reopened = try fixture.game.runtime.open(0, .global, null);
    try @import("bind.zig").testing.runSource(reopened.thread,
        \\local I = require("openreliant.interfaces")
        \\assert(I.AI.custom == nil and I.AI.info("fight").name == "Fight")
    );
}

test "a handler can stop a call, or run the rest of it itself" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{
            "a",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
                .{
                    "a.luau",
                    \\local hooks = require("openreliant.hooks")
                    \\hooks.add("object_destroyed", function(e) return false end, { class = { "fighter" }, side = "hostile" })
                    \\hooks.add("damage_by_difficulty", function(e)
                    \\    local scaled = e:original()
                    \\    e.result = scaled + 1
                    \\    assert(not pcall(function() e:original() end))
                    \\end)
                    \\hooks.add("damage_by_difficulty", function(e) e.value = 7 end)
                },
            },
        },
    });
    defer fixture.deinit();
    // The second handler runs inside the first's call of the rest, and the function once.
    try std.testing.expectEqual(8, fixture.scaled(fixture.sabre, 3));
    // The Sabre's end is stopped.
    openreliant.engine.game.ai.objectDestroyed(fixture.mission.orders(), fixture.sabre, false, false);
    try std.testing.expectEqual(0, fixture.mission.objects.slots[fixture.sabre].object.order_count);
}

test "two mods that wrap a function run it once" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{
            "a",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
                .{
                    "a.luau",
                    \\require("openreliant.hooks").add("damage_by_difficulty", function(e)
                    \\    e.result = e:original() + 1
                    \\end)
                },
            },
        },
        .{
            "b",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=b.luau\n" },
                .{
                    "b.luau",
                    \\require("openreliant.hooks").add("damage_by_difficulty", function(e)
                    \\    e.result = e:original() * 10
                    \\end)
                },
            },
        },
    });
    defer fixture.deinit();
    // b's handler runs first, as the newer mod's. The function runs inside a's `e:original()`,
    // which b's runs, and b's then returns a's result rather than running the function again.
    try std.testing.expectEqual(40, fixture.scaled(fixture.sabre, 3));
}

test "mods can intercept warp orders and receive filtered Undocked events" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local hooks = require("openreliant.hooks")
                \\local seen = false
                \\hooks.add("undocked", function(e)
                \\    assert(e.object.type == "sabre")
                \\    seen = true
                \\end, { type = "sabre" })
                \\hooks.add("order_warp_out", function(e)
                \\    assert(seen)
                \\    e.object.throttle = 0.75
                \\    return false
                \\end, { type = "sabre" })
            },
        },
    }});
    defer fixture.deinit();
    const game = openreliant.engine.game;
    const ctx = fixture.mission.orders();
    try std.testing.expect(try game.aigeneric.pushShip(ctx, fixture.sabre, .warp_out, 0, null));
    openreliant.engine.hooks.tell(fixture.mission.world(), .undocked, .{ .object = .of(0) });
    openreliant.engine.hooks.tell(fixture.mission.world(), .undocked, .{ .object = .of(fixture.sabre) });
    game.aigeneric.objectOrders(ctx, fixture.sabre);
    try std.testing.expectEqual(0.75, fixture.mission.slot(fixture.sabre).object.throttle);
    try std.testing.expectEqual(0, fixture.mission.slot(fixture.sabre).state.warp.step);
}

test "a script chooses a mod's combat maneuver, and acts as the ship flies it" {
    const aidefend = openreliant.engine.game.aidefend;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local hooks = require("openreliant.hooks")
                \\-- The mod's maneuver, number 10, and then none.
                \\local chosen = 0
                \\hooks.add("fight_choose_maneuver", function(e)
                \\    chosen += 1
                \\    if chosen == 1 then e.result = 10 end
                \\    return false
                \\end)
                \\-- After its script has run, the ship slows down further.
                \\hooks.after("maneuver_run", function(e)
                \\    if e.object.maneuver == 10 then e.object.throttle *= 0.5 end
                \\end)
            },
        },
    }});
    defer fixture.deinit();
    defer aidefend.installOriginal();
    // The load scripts would add the maneuver to `records.maneuvers`.
    const drift = [_][]const u8{ "SetSpeed(0.5)", "Wait(100)" };
    const added = aidefend.Compiled.original ++ [_]aidefend.Compiled{.{
        .definition = .{ .name = "drift", .min_ticks = 1000, .max_ticks = 1000, .script = &drift },
        .program = &comptime aidefend.script.compile(&drift),
    }};
    aidefend.install(&added);

    // Fight's init chooses the maneuver, its length from its range, and the first update starts
    // and runs it.
    const ctx = fixture.mission.orders();
    try std.testing.expect(try aigeneric.pushShip(ctx, fixture.sabre, .fight, 0, null));
    aigeneric.objectOrders(ctx, fixture.sabre);
    const slot = fixture.mission.slot(fixture.sabre);
    try std.testing.expectEqual(10, @backingInt(slot.state.fight.maneuver));
    try std.testing.expectEqual(1000, slot.state.fight.maneuver_end);
    try std.testing.expectEqual(0.25, slot.object.throttle);

    // Once its time is up, the ship flies no maneuver, and Fight chooses again on its next update.
    fixture.mission.clock.frame_start = 1001;
    aigeneric.objectOrders(ctx, fixture.sabre);
    try std.testing.expectEqual(aidefend.maneuvers.Maneuver.none, slot.state.fight.maneuver);
    try std.testing.expectEqual(1001, slot.state.fight.maneuver_end);
    try std.testing.expectEqual(0.25, slot.object.throttle);
}

test "a script changes or stops the mission script's commands, and hears of ships close by" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local hooks = require("openreliant.hooks")
                \\hooks.add("vm_command", function(e)
                \\    if e.command == "print_ship_name" then
                \\        assert(e.arguments[1] == 42 and e.arguments[2] == 3 and e.arguments[3] == 0)
                \\        e.result = 9
                \\        return false
                \\    elseif e.command == "print_debug_message" then
                \\        return false
                \\    end
                \\end)
                \\hooks.add("proximity_close", function(e)
                \\    assert(e.other.type == "sabre" and e.distance == 2.5)
                \\    e.other.throttle = 0.5
                \\end)
            },
        },
    }});
    defer fixture.deinit();
    const vm = openreliant.engine.vm;
    var machine: vm.Machine = .{ .gpa = std.testing.allocator, .mission = undefined, .random = undefined, .game = fixture.mission.orders() };
    // The handler reads the command's arguments and gives its own result.
    var arguments: openreliant.engine.game.executor.Arguments = @splat(0);
    arguments[0] = 42;
    arguments[1] = 3;
    try std.testing.expectEqual(@as(vm.machine.CommandResult, @fromBackingInt(9)), machine.runCommand(0, .print_ship_name, arguments));
    // A command stopped lets the script's thread run on.
    try std.testing.expectEqual(.run_on, machine.runCommand(0, .print_debug_message, @splat(0)));
    openreliant.engine.hooks.tell(fixture.mission.world(), .proximity_close, .{ .object = .of(0), .other = .of(fixture.sabre), .distance = 2.5 });
    try std.testing.expectEqual(0.5, fixture.mission.slot(fixture.sabre).object.throttle);
}

test "a script holds a mission command, whose thread runs it again on its next run" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local hooks = require("openreliant.hooks")
                \\local seen = 0
                \\hooks.add("vm_command", function(e)
                \\    if e.command == "destroy_timer" then
                \\        assert(e.arguments[1] == 7)
                \\        seen += 1
                \\        if seen < 3 then
                \\            e.result = "hold"
                \\            return false
                \\        end
                \\    end
                \\end)
            },
        },
    }});
    defer fixture.deinit();
    const vm = openreliant.engine.vm;
    const gpa = std.testing.allocator;
    // DestroyTimer(7), then one added to global 0.
    const code = try vm.machine.testing.assemble(gpa, struct {
        fn build(r: *vm.machine.testing.Routine) !void {
            try r.op(.push_byte, &.{7});
            try r.command("DestroyTimer");
            try r.op(.select_global, &.{0});
            try r.op(.push_byte, &.{1});
            try r.op(.add_assign, &.{});
            try r.op(.push_byte, &.{1});
            try r.op(.@"return", &.{});
        }
    }.build);
    defer gpa.free(code);
    var mission: vm.machine.testing.Fixture = undefined;
    try mission.init(gpa, &.{.{ .code = code, .start = true }}, .{ .globals = &.{0} });
    defer mission.deinit();
    mission.machine.game = fixture.mission.orders();
    // Held twice, the command waits; the third time it runs, on the same argument, and the
    // thread goes on past it.
    try mission.machine.start();
    try std.testing.expectEqual(0, mission.global(0));
    mission.machine.runThreads();
    try std.testing.expectEqual(0, mission.global(0));
    mission.machine.runThreads();
    try std.testing.expectEqual(1, mission.global(0));
}

test "a handler that fails is removed, and its changes undone" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{
            "a",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
                .{
                    "a.luau",
                    \\local hooks = require("openreliant.hooks")
                    \\hooks.add("damage_by_difficulty", function(e) e.value = 100; error("broken") end)
                    \\-- e can't be used once its call is over.
                    \\local kept = nil
                    \\hooks.add("damage_by_difficulty", function(e)
                    \\    if kept then assert(not pcall(function() return kept.value end)) end
                    \\    kept = e
                    \\    e.value += 1
                    \\end)
                    \\hooks.add("object_removed", function(e) e.object = e.object end)
                },
            },
        },
    });
    defer fixture.deinit();
    try std.testing.expectEqual(4, fixture.scaled(fixture.sabre, 3));
    try std.testing.expectEqual(4, fixture.scaled(fixture.sabre, 3));
    // An event's fields can't be changed, so its handler fails. The engine still tells the scripts
    // of objects that leave, whose own scripts stop with them.
    const hooked = &fixture.game.scripts.hooked;
    create.resetSlot(fixture.mission.orders(), fixture.sabre);
    try std.testing.expect(fixture.game.hooks.handlers.get(.object_removed).items.len == 0);
    try std.testing.expect(hooked.contains(.object_removed));
}

test "a handler that runs out of time is kept until it does so three times in a row" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
            .{
                "a.luau",
                \\local hooks = require("openreliant.hooks")
                \\local calls = 0
                \\hooks.add("damage_by_difficulty", function(e)
                \\    calls += 1
                \\    e.value = 7
                \\    if calls ~= 3 then while true do end end
                \\end)
            },
        },
    }});
    defer fixture.deinit();
    const handlers = &fixture.game.hooks.handlers.getPtr(.damage_by_difficulty).items;
    // Its first two calls run out of time: their changes are undone, and it stays.
    for (0..2) |_| try std.testing.expectEqual(3, fixture.scaled(fixture.sabre, 3));
    try std.testing.expectEqual(1, handlers.len);
    // A call that returns starts the count again.
    try std.testing.expectEqual(7, fixture.scaled(fixture.sabre, 3));
    for (0..runtime.max_timeouts - 1) |_| try std.testing.expectEqual(3, fixture.scaled(fixture.sabre, 3));
    try std.testing.expectEqual(1, handlers.len);
    try std.testing.expectEqual(3, fixture.scaled(fixture.sabre, 3));
    try std.testing.expectEqual(0, handlers.len);
}

test "the scripts give their orders against the world as each frame has it" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "a", &.{ .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" }, .{ "a.luau", "" } } }});
    defer fixture.deinit();
    var orders = fixture.mission.orders();
    orders.world.light_maps = false;
    // Before a mission, the frame changes nothing.
    fixture.game.scripts.frame(orders);
    try std.testing.expectEqual(null, fixture.game.runtime.orders);
    // During one, the scripts keep the frame's.
    fixture.begin();
    try std.testing.expect(fixture.game.runtime.orders.?.world.light_maps);
    fixture.game.scripts.frame(orders);
    try std.testing.expect(!fixture.game.runtime.orders.?.world.light_maps);
}

test "a mod's scripts that fail to start leave no context open" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=a.luau\nType.sabre=fails.luau\nMissile=fails.luau\n" },
            .{
                "a.luau",
                \\local world = require("openreliant.world")
                \\return { engine_handlers = { on_mission_start = function()
                \\    for _ = 1, 3 do assert(not world.objects()[2]:add_script("fails")) end
                \\end } }
            },
            .{ "fails.luau", "error('broken')" },
        },
    }});
    defer fixture.deinit();
    fixture.begin();
    // The Sabre's script fails as the Sabre joins the mission, and so does a missile's as it flies.
    openreliant.engine.hooks.tell(fixture.mission.world(), .object_added, .{ .object = .of(fixture.sabre) });
    const all = fixture.mission.objects;
    const slot: create.Slot = .{ .object = std.mem.zeroes(gameobj.GameObject) };
    const record = all.missiles.add(.{ .slot = slot, .launcher = 0, .launcher_reuses = all.reuses[0], .type = .of(.raptor), .target = .at(fixture.sabre, null) }).?;
    openreliant.engine.hooks.tell(fixture.mission.world(), .missile_added, .{ .missile = .of(record), .launcher = .of(0) });
    fixture.game.scripts.started(.{ .number = 5, .file = "mission5.dte" });
    // Only the global script's context stays open.
    var open: usize = 0;
    for (fixture.game.runtime.contexts.items) |context| open += @intFromBool(!context.closed);
    try std.testing.expectEqual(1, open);
}

test "the engine calls the scripts' handlers, and a mission's scripts run with it" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{
            "a",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=game.luau\n[Missions]\nMISSION5.dte=mission.luau\n" },
                .{
                    "game.luau",
                    \\local factor = 1
                    \\require("openreliant.hooks").add("damage_by_difficulty", function(e) e.value *= factor end)
                    \\return { engine_handlers = {
                    \\    on_mission_start = function(mission) assert(mission.file == "mission5.dte"); factor = mission.number end,
                    \\    on_update = function(seconds) factor += seconds end,
                    \\    on_mission_end = function(outcome) if outcome.ending == "destroyed" then factor = 100 end end,
                    \\} }
                },
                .{ "mission.luau", "require('openreliant.hooks').add('damage_by_difficulty', function(e) e.value += 1 end)" },
            },
        },
    });
    defer fixture.deinit();
    const scripts = &fixture.game.scripts;
    const mission: engine_hooks.Mission = .{ .number = 5, .file = "mission5.dte" };
    fixture.begin();
    scripts.started(mission);
    try std.testing.expectEqual(11, fixture.scaled(fixture.sabre, 2));
    scripts.update(0.5);
    try std.testing.expectEqual(12, fixture.scaled(fixture.sabre, 2));
    // As the mission ends, its script stops.
    scripts.ended(.{ .ending = .destroyed, .rating = .failure });
    try std.testing.expectEqual(200, fixture.scaled(fixture.sabre, 2));
}

test "scripts reloaded partway through a mission start on its objects, without its start" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{
            "a",
            &.{
                .{ "mod.ini", "[Scripts]\nFighter=wing.luau\n[Missions]\nMISSION5.dte=mission.luau\n" },
                .{
                    "wing.luau",
                    \\local self = require("openreliant.self")
                    \\self:hook("damage_by_difficulty", function(e) e.value *= 0.5 end)
                },
                .{
                    "mission.luau",
                    \\local factor = 3
                    \\require("openreliant.hooks").add("damage_by_difficulty", function(e) e.value *= factor end)
                    \\return { engine_handlers = { on_mission_start = function() factor = 100 end } }
                },
            },
        },
    });
    defer fixture.deinit();
    // The Sabre is in the mission already: its script starts on it, and the mission's script
    // starts without hearing the mission start.
    fixture.game.resumeMission(fixture.mission.orders(), .{ .number = 5, .file = "mission5.dte" }, 1);
    try std.testing.expectEqual(1, fixture.game.onObject(fixture.sabre).items.len);
    try std.testing.expectEqual(3, fixture.scaled(fixture.sabre, 2));
}

test "object scripts run on the objects their manifest names, each with its own globals" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{
            "a",
            &.{
                .{ "mod.ini", "[Scripts]\nFighter=wing.luau\nType.sabre=sabre.luau\n" },
                .{
                    "wing.luau",
                    \\local self = require("openreliant.self")
                    \\count = 0
                    \\local hooks = require("openreliant.hooks")
                    \\-- Each fighter's own hits land at half strength, counted by its own global.
                    \\self:hook("damage_by_difficulty", function(e) count += 1; e.value *= 0.5 end)
                    \\return { engine_handlers = {
                    \\    on_update = function() if count == 2 then self.throttle = 0.25 end end,
                    \\    on_removed = function() print("removed", self.slot) end,
                    \\} }
                },
                .{
                    "sabre.luau",
                    \\local self = require("openreliant.self")
                    \\return { engine_handlers = { on_added = function() self.yaw_input = 1 end } }
                },
            },
        },
    });
    defer fixture.deinit();
    fixture.begin();
    // The Sabre made before the mission began has no scripts; one made now has both.
    const sabre = try fixture.mission.add(.of(.sabre), .{ 0, 0, 2000 });
    const all = fixture.mission.objects;
    try std.testing.expectEqual(2, fixture.game.onObject(sabre).items.len);
    try std.testing.expectEqual(1, all.slots[sabre].object.yaw_input);
    try std.testing.expectEqual(1.5, fixture.scaled(sabre, 3));
    try std.testing.expectEqual(1.5, fixture.scaled(sabre, 3));
    // The first Sabre's hits aren't halved, and don't count for the other.
    try std.testing.expectEqual(3, fixture.scaled(fixture.sabre, 3));
    fixture.game.scripts.update(0.1);
    try std.testing.expectEqual(0.25, all.slots[sabre].object.throttle);
    // As it leaves, its scripts stop with it.
    create.resetSlot(fixture.mission.orders(), sabre);
    try std.testing.expectEqual(0, fixture.game.onObject(sabre).items.len);
}

test "missile scripts run on each missile from its launch to its end, and see it as their own" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=watch.luau\nMissile=raptor.luau\n" },
            .{
                "watch.luau",
                \\local world = require("openreliant.world")
                \\local hooks = require("openreliant.hooks")
                \\hooks.add("missile_added", function(e) assert(e.launcher.type == "predator") end)
                \\return { event_handlers = {
                \\    launched = function(kind) if kind == "raptor" and #world.missiles() == 1 then world.objects()[2].throttle = 0.5 end end,
                \\    ended = function() world.objects()[2].throttle = 0.25 end,
                \\} }
            },
            .{
                "raptor.luau",
                \\local self = require("openreliant.self")
                \\local core = require("openreliant.core")
                \\count = 0
                \\return { engine_handlers = {
                \\    on_added = function()
                \\        assert(self.launcher.slot == 0 and self.target.object.type == "sabre")
                \\        core.send_global_event("launched", self.type)
                \\    end,
                \\    on_update = function() count += 1; if count == 2 then self:detonate() end end,
                \\    on_removed = function() core.send_global_event("ended", count) end,
                \\} }
            },
        },
    }});
    defer fixture.deinit();
    fixture.begin();
    const all = fixture.mission.objects;
    const slot: create.Slot = .{ .object = std.mem.zeroes(gameobj.GameObject) };
    const record = all.missiles.add(.{ .slot = slot, .launcher = 0, .launcher_reuses = all.reuses[0], .type = .of(.raptor), .target = .at(fixture.sabre, null) }).?;
    openreliant.engine.hooks.tell(fixture.mission.world(), .missile_added, .{ .missile = .of(record), .launcher = .of(0) });
    try std.testing.expectEqual(1, fixture.game.onMissile(record).items.len);
    fixture.game.scripts.update(0.1);
    try std.testing.expectEqual(0.5, all.slots[fixture.sabre].object.throttle);
    // Its second update sets it off: its scripts hear their end and stop with it.
    fixture.game.scripts.update(0.1);
    try std.testing.expectEqual(null, all.missiles.get(record));
    try std.testing.expectEqual(0, fixture.game.onMissile(record).items.len);
    fixture.game.scripts.update(0.1);
    try std.testing.expectEqual(0.25, all.slots[fixture.sabre].object.throttle);
}

test "turret scripts run on each turret of an object, and aim it" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=watch.luau\nTurret=turret.luau\n" },
            .{
                "watch.luau",
                \\local world = require("openreliant.world")
                \\local seen = 0
                \\return { event_handlers = { turret = function(kind)
                \\    seen += 1
                \\    if seen == 2 then world.objects()[2].throttle = 0.5 end
                \\end } }
            },
            .{
                "turret.luau",
                \\local self = require("openreliant.self")
                \\local core = require("openreliant.core")
                \\local nearby = require("openreliant.nearby")
                \\return { engine_handlers = { on_added = function()
                \\    local ship = self.object
                \\    assert(ship.type == "sabre" and #ship:turrets() == 2)
                \\    if self.kind == "launcher" then
                \\        assert(not self.destroyed and self.gun_type == nil and self.target.object == nil)
                \\        self.target = { object = nearby.objects(5000)[1] }
                \\    else
                \\        assert(self.destroyed and self.kind == nil and self.position == nil and self.target == nil)
                \\    end
                \\    core.send_global_event("turret", self.kind or "destroyed")
                \\end } }
            },
        },
    }});
    defer fixture.deinit();
    fixture.begin();
    const gpa = std.testing.allocator;
    // The Sabre carries a missile turret, and a turret destroyed with its base.
    var parts: openreliant.engine.game.objects.testing.Parts(2) = undefined;
    parts.init();
    parts.turret(0, .missile_turret, .missile, 1, 0);
    parts.member(1, 1, 1);
    var model = try parts.create(gpa);
    defer model.deinit(gpa);
    const slot = &fixture.mission.objects.slots[fixture.sabre];
    slot.guns = try gpa.alloc(openreliant.engine.game.guns.Fitted, 2);
    slot.guns[0] = .{ .turret = .gone };
    slot.guns[1] = .{ .turret = .{ .missile = .{ .model = &model, .base = 0, .launcher = 1 } } };
    openreliant.engine.hooks.tell(fixture.mission.world(), .object_added, .{ .object = .of(fixture.sabre) });
    // Each turret's script runs with its own globals, and the launcher's aims it at the Predator.
    try std.testing.expectEqual(2, fixture.game.onObject(fixture.sabre).items.len);
    try std.testing.expectEqual(0, slot.guns[1].turret.missile.target.slot().?);
    fixture.game.scripts.update(0.1);
    try std.testing.expectEqual(0.5, slot.object.throttle);
}

test "global scripts add scripts to objects, send them events, and share interfaces" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{
            "a",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=game.luau\n" },
                .{
                    "game.luau",
                    \\local world = require("openreliant.world")
                    \\local heard = {}
                    \\return {
                    \\    interface_name = "Wing",
                    \\    interface = { heard = function() return heard end },
                    \\    engine_handlers = {
                    \\        on_mission_start = function()
                    \\            for _, object in world.objects() do
                    \\                if object.type == "sabre" then
                    \\                    assert(object:add_script("escort", { leader = world.player }))
                    \\                    assert(not object:add_script("ESCORT.luau"))
                    \\                    object:send_event("Hello", { from = "game" })
                    \\                end
                    \\            end
                    \\        end,
                    \\    },
                    \\    event_handlers = {
                    \\        Reported = function(data) table.insert(heard, data.leader) end,
                    \\    },
                    \\}
                },
                .{
                    "escort.luau",
                    \\local core = require("openreliant.core")
                    \\local leader
                    \\return {
                    \\    engine_handlers = { on_init = function(data) leader = data.leader end },
                    \\    event_handlers = {
                    \\        Hello = function(data)
                    \\            assert(data.from == "game")
                    \\            core.send_global_event("Reported", { leader = leader })
                    \\        end,
                    \\    },
                    \\}
                },
            },
        },
        .{
            "b",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=check.luau\n" },
                .{
                    "check.luau",
                    \\local world = require("openreliant.world")
                    \\local I = require("openreliant.interfaces")
                    \\local base
                    \\return {
                    \\    -- Mod b's Wing takes the place of mod a's, and calls through to it.
                    \\    interface_name = "Wing",
                    \\    interface = { heard = function() return base.heard() end, newer = true },
                    \\    engine_handlers = {
                    \\        on_interface_override = function(earlier) base = earlier end,
                    \\        on_update = function()
                    \\            local heard = I.Wing.heard()
                    \\            if I.Wing.newer and #heard == 1 and heard[1] == world.player then
                    \\                world.player.yaw_input = -1
                    \\            end
                    \\        end,
                    \\    },
                    \\}
                },
            },
        },
    });
    defer fixture.deinit();
    fixture.begin();
    const scripts = &fixture.game.scripts;
    scripts.started(.{ .number = 5, .file = "mission5.dte" });
    try std.testing.expectEqual(1, fixture.game.onObject(fixture.sabre).items.len);
    const player = &fixture.mission.objects.slots[0].object;
    // The first update delivers the greeting before the scripts' on_update, and the second the
    // report it sends back, which mod b then finds through the interface.
    scripts.update(0.1);
    try std.testing.expectEqual(0, player.yaw_input);
    scripts.update(0.1);
    try std.testing.expectEqual(-1, player.yaw_input);
}

test "a mod can't reach another mod's globals or change its interface" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{
            "a",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=a.luau\n" },
                .{
                    "a.luau",
                    \\secret = 1
                    \\local offered = { secret = function() return secret end }
                    \\return {
                    \\    interface_name = "Secrets",
                    \\    interface = offered,
                    \\    -- Its own table stays its own to change, but the others got a copy.
                    \\    engine_handlers = { on_update = function() offered.later = true end },
                    \\}
                },
            },
        },
        .{
            "b",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=b.luau\n" },
                .{
                    "b.luau",
                    \\local world = require("openreliant.world")
                    \\local I = require("openreliant.interfaces")
                    \\local updates = 0
                    \\return {
                    \\    engine_handlers = {
                    \\        on_update = function()
                    \\            updates += 1
                    \\            assert(getfenv == nil and setfenv == nil)
                    \\            assert(not pcall(function() I.Secrets.secret = function() return 2 end end))
                    \\            assert(I.Secrets.secret() == 1 and I.Secrets.later == nil)
                    \\            if updates == 2 then world.player.yaw_input = -1 end
                    \\        end,
                    \\    },
                    \\}
                },
            },
        },
    });
    defer fixture.deinit();
    fixture.begin();
    const scripts = &fixture.game.scripts;
    scripts.started(.{ .number = 5, .file = "mission5.dte" });
    // By b's second update, a has changed its own table at least once.
    scripts.update(0.1);
    scripts.update(0.1);
    try std.testing.expectEqual(-1, fixture.mission.objects.slots[0].object.yaw_input);
}

test "object scripts read the world around them, and give their object orders" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{
            "a",
            &.{
                .{ "mod.ini", "[Scripts]\nGlobal=game.luau\nFighter=wing.luau\n" },
                .{
                    "game.luau",
                    \\local world = require("openreliant.world")
                    \\return { engine_handlers = { on_mission_start = function()
                    \\    assert(world.mission.number == 5 and world.mission.file == "mission5.dte")
                    \\    assert(world.player.is_player and #world.objects() == 4)
                    \\end } }
                },
                .{
                    "wing.luau",
                    \\local self = require("openreliant.self")
                    \\local nearby = require("openreliant.nearby")
                    \\return { engine_handlers = { on_update = function()
                    \\    if self.is_player or self.order == "run_away" then return end
                    \\    local around = nearby.objects(1500)
                    \\    if #around == 0 then return end
                    \\    -- Without itself; the other Sabres are out of reach.
                    \\    assert(#around == 1 and around[1].is_player)
                    \\    assert(not pcall(function() around[1].throttle = 1 end))
                    \\    assert(self:give_order("run_away", around[1]))
                    \\end } }
                },
            },
        },
    });
    defer fixture.deinit();
    fixture.begin();
    const sabre = try fixture.mission.add(.of(.sabre), .{ 0, 0, -1000 });
    _ = try fixture.mission.add(.of(.sabre), .{ 0, 0, 50000 });
    fixture.game.scripts.started(.{ .number = 5, .file = "mission5.dte" });
    fixture.game.scripts.update(0.1);
    try std.testing.expectEqual(openreliant.engine.game.ai.orders.Order.run_away, fixture.mission.objects.slots[sabre].current().?.order);
}

test "the wingmen example: a badly damaged wingman runs from its attacker, and rejoins later" {
    const storage_module = @import("storage.zig");
    const options = @import("options.zig");
    const mod_options = openreliant.engine.game.interface.mod_options;
    var storage: storage_module.Storage = .{ .gpa = std.testing.allocator };
    defer storage.deinit();
    var pages: options.Registry = .init(std.testing.allocator, &storage);
    defer pages.deinit();
    var fixture: Fixture = undefined;
    try fixture.initShared(&.{.{ "wingmen", &.{
        .{ "mod.ini", @embedFile("wingmen/mod.ini") },
        .{ "options.luau", @embedFile("wingmen/options.luau") },
        .{ "wingman.luau", @embedFile("wingmen/wingman.luau") },
        .{ "wingmen.luau", @embedFile("wingmen/wingmen.luau") },
        .{ "status.luau", @embedFile("wingmen/status.luau") },
    } }}, .{ .storage = &storage, .option_pages = &pages });
    defer fixture.deinit();
    // Its options, under two headings, are the defaults until the player sets them.
    try std.testing.expectEqual(7, pages.page("wingmen").?.options.len);
    try std.testing.expectEqual(mod_options.Value{ .number = 0.3 }, pages.value("wingmen", "pull_out_below").?);
    fixture.begin();
    const wingman = try fixture.mission.add(.of(.wolverine), .{ 0, 0, -1000 });
    const scripts = &fixture.game.scripts;
    scripts.started(.{ .number = 5, .file = "mission5.dte" });
    const slot = &fixture.mission.objects.slots[wingman];
    slot.object.side = .friendly;
    // Untouched, it stays in the fight.
    scripts.update(0.1);
    try std.testing.expect(slot.current() == null or slot.current().?.order != .run_away);
    // With its armour nearly gone, it runs from the Sabre that hit it.
    slot.object.armor = .all(1);
    slot.object.last_attacker = .of(fixture.sabre);
    scripts.update(0.1);
    try std.testing.expectEqual(.run_away, slot.current().?.order);
    try std.testing.expectEqual(fixture.sabre, @as(u16, @intCast(slot.current().?.target.index)));
    // Its report reaches the global script at the next update, and 20 seconds on it rejoins the
    // player's formation.
    scripts.update(0.1);
    scripts.update(20);
    try std.testing.expectEqual(.formation, slot.current().?.order);
    try std.testing.expectEqual(0, slot.current().?.target.index);
}