presentation.zig

//! The presentation side of mods' scripts ([#498](https://github.com/OpenReliant/openreliant/issues/498)):
//! player and menu scripts, which decide what the player sees, hears and does, in a Luau state of
//! their own.
//!
//! - A mod's `Menu` scripts start as OpenReliant starts, and run until it quits, in the menus and
//!   over the missions.
//! - Its `Player` scripts start as a game starts, and stop as it ends, as the global scripts do.
//! - Both get `on_frame` each frame drawn, even while the game is paused; `on_key_press` and
//!   `on_key_release` as keys go down and up; `on_action` as the controls bound to an action are
//!   used in flight; `on_window_resized` as the window changes size; `on_room_changed` as the
//!   player moves through the carrier's rooms; and `on_music_changed` as the music changes.
//! - They play sounds and music (`audio.zig`). Sounds started by player scripts stop when the game
//!   ends, and sounds started by menu scripts stop when the menu scripts reload.
//! - They draw over the flight display and the menus (`drawing.zig`), and change the game only by
//!   sending events to the global scripts (`core.send_global_event`), which wait until the game
//!   next runs and then have their data copied into the game's state, as it would be sent to
//!   another machine (`Presentation.sendEvents`).
//!
//! If no mod has player or menu 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 engine = openreliant.engine;
const mods = engine.game.bigfile.mods;
const Mod = mods.Mod;
const create = engine.game.create;
const hud = engine.game.hud;
const camera = engine.game.camera;
const hog_snd = engine.game.hog_snd;
const input = engine.input;
const mod_options = engine.game.interface.mod_options;
const rooms = engine.game.interface.rooms;
const postprocessing = @import("postprocessing.zig");
const shaders = @import("shaders.zig");
const game_modes = @import("game_modes.zig");
const front_end = @import("front_end.zig");
const interf = engine.genilib.interf;
const srtexture = engine.surrender.surrenderlib.srtexture;
const controls = engine.input.controls;
const device = engine.surrender.srd3d.device;
const engine_hooks = engine.hooks;
const script = @import("script.zig");
const runtime = @import("runtime.zig");
const Runtime = runtime.Runtime;
const records = @import("records.zig");
const packages = @import("packages.zig");
const objects = @import("objects.zig");
const interfaces = @import("interfaces.zig");
const running = @import("running.zig");
const drawing = @import("drawing.zig");
const audio = @import("audio.zig");
const data = @import("data.zig");
const events = @import("events.zig");
const api = @import("api.zig");
const Call = api.Call;
const load = @import("load.zig");
const game_module = @import("game.zig");

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

/// The scripts of each kind that runs on the presentation side.
const Place = enum { menu, player };

/// The kinds of keys a keyboard reports, by scan code (`input.Key`).
const key_codes = std.math.maxInt(@typeInfo(input.Key).@"enum".tag_type) + 1;

/// What the driver tells the scripts of a frame.
pub const Host = struct {
    /// The seconds of real time since the last frame.
    seconds: f32,
    /// The keyboard, the joystick and the bindings.
    devices: *input.Devices,
    /// The window's size in pixels.
    window: [2]u32,
    /// What each layer is drawn on this frame; null for one that isn't shown.
    views: std.EnumArray(drawing.Which, ?drawing.View) = .initFill(null),
    /// The camera, while a mission is shown.
    camera: ?Camera = null,
    /// The flight display's state and the player's, which `openreliant.hud` reads, while a
    /// mission is shown.
    flight: ?Flight = null,
    /// The sound, where any is heard.
    sound: ?*hog_snd.Sound = null,
    /// The scene 3D sounds play in, during a mission.
    scene: ?hog_snd.Scene = null,
    /// Whether the player is flying, which is when the controls' actions mean anything.
    flying: bool = false,
    /// Where the player is in the carrier's rooms, while they're on screen (`openreliant.rooms`).
    rooms: ?Rooms = null,

    pub const Rooms = struct {
        carrier: rooms.Carrier,
        /// The view the player stands in, or walks into, by its index in the rooms' views,
        /// counting from 0 (`records.room_views` counts from 1).
        view: u8,
        /// The place whose screen shows, or the news report while it plays; null while the player
        /// walks the rooms.
        place: ?rooms.Place = null,
        /// The page the CD player shows, while it's open.
        cd_player_page: ?usize = null,
    };

    pub const Flight = struct {
        hud: *const hud.State,
        /// What drawing keeps of the display, as it last drew it: what flashed, where each
        /// instrument drew, and how far the launch's caption has typed.
        drawing: *const hud.Drawing,
        player: *const input.Player,
        /// What the display's frame draws the clock, the view's name, the caption and the status
        /// lights from (`hud.Frame`): the time played, the game's variables, last frame's view, the
        /// game's strings, and whether the game is a network one.
        play: engine.game.main.PlayTime = .{},
        variables: ?*const engine.vm.Variables = null,
        last_view: camera.View = .cockpit,
        strings: ?*const engine.game.language.Language = null,
        multiplayer: bool = false,
        /// The ship whose line the radio's window names, which the radar marks
        /// (`radio.Radio.speakingShip`); none for nobody's.
        speaker: ?u16 = null,
        /// The string of the speaker's name the radio's window writes (`radio.Radio.shownName`);
        /// none while it writes none.
        speaker_name: ?u16 = null,
    };

    pub const Camera = struct {
        /// The camera, which cuts to a script's switch of view at once and asks the game for it
        /// (`camera.Camera.ask`).
        camera: *camera.Camera,
        /// The drawn frame's copy of the view (`main.Drawn.player`), which a script's switch of view
        /// switches at once, and which the switch goes by.
        viewing: *camera.Viewing,
        bounds: camera.Viewing.Bounds = .{},
        /// The time the camera's views switch by (`main.Clock.viewTime`).
        now: u32,
        /// The player's ship, which a view follows unless a script names another object.
        player: u16,
    };
};

/// Where the player is in the rooms, as `on_room_changed` tells it: the view, and the place whose
/// screen shows.
const Room = struct {
    view: u8,
    place: ?rooms.Place,
};

/// The presentation side of mods' scripts.
pub const Presentation = struct {
    gpa: Allocator,
    runtime: *Runtime,
    runner: running.Runner,
    lists: std.EnumArray(Place, running.List) = .initFill(.empty),
    layers: std.EnumArray(drawing.Which, drawing.Layer) = .initFill(.{}),
    assets: drawing.Assets = .{},
    /// The menu scripts' screens that stand in for the front end's own (`front_end.zig`).
    standing: front_end.Standing = .{},
    /// What each layer is drawn on this frame.
    views: std.EnumArray(drawing.Which, ?drawing.View) = .initFill(null),
    /// What the driver told of the last frame, which the packages reach the game through.
    host: ?Host = null,
    /// The game's scripts while a game runs, which the scripts' events go to.
    game: ?*game_module.Game = null,
    /// The events the scripts sent to the game's scripts since the game last ran, whose data is
    /// still in this state (`sendEvents`).
    waiting: events.Events,
    /// The keys held, which presses and releases are told against.
    keys: std.bit_set.Static(key_codes) = .empty,
    /// The actions whose controls were held last frame.
    actions: std.EnumSet(controls.Action) = .empty,
    /// The window's size last frame.
    window: ?[2]u32 = null,
    /// Where the player was in the rooms last frame; null while they weren't on screen.
    room: ?Room = null,
    /// The page a script asked the CD player to turn to (`rooms.set_cd_player_page`), until the CD
    /// player takes it (`takeCdPlayerPage`).
    cd_player_request: ?usize = null,
    /// The script sounds and their cache.
    sounds: audio.Sounds = .{},
    /// The path of the piece of music that was playing last frame, for detecting changes
    /// (`on_music_changed`); null if none was.
    music: ?hog_snd.Music.Path = null,

    /// Starts the `Menu` scripts of `opened`, which can read `held`, the records. `version` is
    /// OpenReliant's version. Returns null if no mod has player or menu scripts.
    pub fn start(gpa: Allocator, io: Io, opened: []const Mod, held: *records.Records, version: []const u8, shared: runtime.Shared) Allocator.Error!?*Presentation {
        const any = for (opened) |*mod| {
            if (hasScripts(mod)) break true;
        } else false;
        if (!any) return null;

        const shown = try gpa.create(Presentation);
        const scripts = Runtime.create(gpa, io, opened, .{ .side = .presentation, .limits = limits, .seed = load.seed, .version = version, .shared = shared }) catch |err| {
            gpa.destroy(shown);
            return err;
        };
        shown.* = .{ .gpa = gpa, .runtime = scripts, .runner = undefined, .waiting = .{ .gpa = gpa, .runtime = scripts } };
        shown.runner = .init(gpa, scripts, &shown.lists.values);
        errdefer shown.stop();
        const state = scripts.state;
        records.register(state);
        records.push(state, held, false);
        scripts.setPackage(.records);
        packages.push(scripts);
        objects.register(scripts);
        interfaces.Interfaces.register(state);
        shown.runner.interfaces.push(state);
        scripts.setPackage(.interfaces);
        scripts.presentation = shown;
        scripts.runner = &shown.runner;
        try shown.startScripts(.menu, false);
        return shown;
    }

    /// Stops the scripts, as OpenReliant quits.
    pub fn stop(shown: *Presentation) void {
        shown.waiting.deinit();
        shown.runner.deinit();
        shown.sounds.deinit(shown.gpa);
        for (&shown.layers.values) |*layer| layer.deinit(shown.gpa);
        shown.assets.deinit(shown.gpa);
        shown.standing.deinit(shown.gpa);
        shown.runtime.destroy();
        shown.gpa.destroy(shown);
    }

    /// Reads the folder mods' scripts again, and starts the menu scripts again, with `on_init`, as
    /// the console's `reload` does. The player scripts start again with the game's
    /// (`startGame`).
    pub fn reload(shown: *Presentation) Allocator.Error!void {
        shown.runner.stopAll(shown.lists.getPtr(.menu));
        shown.sounds.stop(.menu);
        try shown.runtime.recompileFolders();
        try shown.startScripts(.menu, false);
    }

    /// The presentation side whose script makes `call`. Raises an error from a game script.
    pub fn of(call: Call) *Presentation {
        return call.runtime().presentation orelse call.raise("only player and menu scripts can use it", .{});
    }

    /// What the driver told of the last frame. Raises an error before the first.
    pub fn hostOf(call: Call) Host {
        return of(call).host orelse call.raise("can only be used once frames are drawn", .{});
    }

    /// Starts the scripts each mod lists for `place`, in load order.
    fn startScripts(shown: *Presentation, comptime place: Place, loading: bool) Allocator.Error!void {
        for (shown.runtime.mods, 0..) |*mod, at| {
            var listed = listedScripts(mod, place);
            if (listed.next() == null) continue;
            listed = listedScripts(mod, place);
            const context = try shown.runtime.open(@intCast(at), familyOf(place), null);
            while (listed.next()) |name| _ = try shown.runner.start(shown.lists.getPtr(place), context, name, false, null, loading);
        }
    }

    /// Starts the `Player` scripts as a game starts, with `game`, the game's scripts if any mod
    /// has some, and `all`, the game's objects; `loading` as `Game.start` has it.
    pub fn startGame(shown: *Presentation, game: ?*game_module.Game, all: *create.Objects, loading: bool) Allocator.Error!void {
        shown.endGame();
        shown.game = game;
        shown.runtime.objects = all;
        try shown.startScripts(.player, loading);
    }

    /// Stops the `Player` scripts as the game ends.
    pub fn endGame(shown: *Presentation) void {
        shown.resetRegisteredCamera();
        shown.runner.stopAll(shown.lists.getPtr(.player));
        shown.sounds.stop(.player);
        shown.runtime.mod_shaders.forgetGiven();
        shown.runtime.dropPlayerSelf();
        shown.waiting.clear();
        shown.game = null;
        shown.runtime.objects = null;
    }

    /// Points the player scripts' `self` at the mission's player ship, then tells the scripts that
    /// `mission` has started.
    pub fn missionStarted(shown: *Presentation, mission: engine_hooks.Mission) void {
        shown.runtime.followPlayer();
        shown.runner.callAll(.on_mission_start, .{ .mission = mission });
    }

    /// Tells the scripts that the mission has ended as `outcome` says.
    pub fn missionEnded(shown: *Presentation, outcome: engine_hooks.Outcome) void {
        shown.resetRegisteredCamera();
        shown.runner.callAll(.on_mission_end, .{ .outcome = outcome });
    }

    /// A mission transition must not keep a camera callback's subject from the previous scene.
    fn resetRegisteredCamera(shown: *Presentation) void {
        shown.runtime.registries.resetCamera(shown.runtime);
    }

    /// Sets what compiles and draws the scripts' post effects, or null for nothing
    /// (`postprocessing.Registry.setHost`). Call it with null before the host is destroyed.
    pub fn setEffectHost(shown: *Presentation, host: ?postprocessing.EffectHost) void {
        shown.runtime.post_effects.setHost(host);
    }

    /// Gives the objects of `all`, the drawn frame's copy, the surface functions the player
    /// scripts gave them (`shaders.Registry.dress`), once the scripts' frame has run.
    pub fn dressObjects(shown: *Presentation, all: *create.Objects) void {
        shown.runtime.mod_shaders.dress(all);
    }

    /// The menu scripts' screens that stand in for the front end's own, as the front end reaches
    /// them (`front_end.scripted`).
    pub fn scripted(shown: *Presentation) @import("openreliant").engine.genilib.interf.Scripted {
        return front_end.scripted(shown);
    }

    /// The movie a menu script asked to play (`ui.play_movie`), if one did, which stays valid until
    /// the next is asked for.
    pub fn takeMovie(shown: *Presentation) ?[]const u8 {
        return front_end.takeMovie(shown);
    }

    /// Sets what compiles and draws the scripts' surface and lighting functions, or null for nothing
    /// (`shaders.Registry.setHost`). Call it with null before the host is destroyed.
    pub fn setShaderHost(shown: *Presentation, host: ?shaders.ShaderHost) void {
        shown.runtime.mod_shaders.setHost(host);
    }

    /// What finds the surface functions the planets name for their atmospheres
    /// (`shaders.Registry.surfaceNames`).
    pub fn surfaceNames(shown: *Presentation) openreliant.engine.game.create.atmosphere.SurfaceNames {
        return shown.runtime.mod_shaders.surfaceNames();
    }

    /// The passes of the post effects the scripts have enabled, in the order they draw.
    pub fn effectPasses(shown: *const Presentation, buffer: *[postprocessing.max_effects]postprocessing.Pass) []const postprocessing.Pass {
        return shown.runtime.post_effects.passes(buffer);
    }

    /// The page a script asked the CD player to turn to since the CD player last took one; null
    /// for none.
    pub fn takeCdPlayerPage(shown: *Presentation) ?usize {
        defer shown.cd_player_request = null;
        return shown.cd_player_request;
    }

    /// Tells the scripts of the mod `mod` that the player set its option `option` to `value`.
    pub fn optionChanged(shown: *Presentation, mod: []const u8, option: []const u8, value: mod_options.Value) void {
        shown.runner.callMod(mod, .on_option_changed, .{ .key = option, .value = value });
    }

    /// Tells the scripts that `key` went down or up. A key held down that the window repeats is
    /// told once.
    pub fn key(shown: *Presentation, pressed: input.Key, down: bool) void {
        const code = @backingInt(pressed);
        if (shown.keys.isSet(code) == down) return;
        shown.keys.setValue(code, down);
        shown.runtime.registries.input(shown.runtime, pressed, down);
        if (down) {
            shown.runner.callAll(.on_key_press, .{ .key = pressed });
        } else {
            shown.runner.callAll(.on_key_release, .{ .key = pressed });
        }
    }

    /// Runs a frame of the scripts: clears the last frame's drawing, reports changes to the window
    /// size, the player's place in the rooms, the music and the actions used, then calls
    /// `on_frame`.
    pub fn frame(shown: *Presentation, host: Host) void {
        shown.host = host;
        shown.views = host.views;
        for (&shown.layers.values) |*layer| layer.clear();
        shown.assets.startFrame();
        shown.sounds.forgetEnded();
        if (shown.window) |last| {
            if (!std.mem.eql(u32, &last, &host.window)) shown.runner.callAll(.on_window_resized, .{ .width = host.window[0], .height = host.window[1] });
        }
        shown.window = host.window;
        const room: ?Room = if (host.rooms) |where| .{ .view = where.view, .place = where.place } else null;
        if (!std.meta.eql(room, shown.room)) {
            shown.room = room;
            shown.runner.callAll(.on_room_changed, if (room) |now| .{ .view = @as(u32, now.view) + 1, .place = now.place } else .{ .view = null, .place = null });
        }
        shown.tellMusic(if (host.sound) |sound| sound.pieceOn() else null);
        var held: std.EnumSet(controls.Action) = .empty;
        if (host.flying) {
            for (std.enums.values(controls.Action)) |action| {
                if (!host.devices.active(action, false)) continue;
                held.insert(action);
                if (!shown.actions.contains(action)) shown.runner.callAll(.on_action, .{ .action = @tagName(action) });
            }
        }
        shown.actions = held;
        const registry = &shown.runtime.input_actions;
        host.devices.mod_actions = registry;
        // Callbacks may register or close contexts; fixed entry slots keep the walk valid.
        const count = registry.count;
        for (0..count) |index| {
            if (registry.pressed(index, host.devices, host.flying)) {
                // A handler can reload registration slots. Keep this event's name stable.
                const name = registry.entries[index].name;
                shown.runner.callAll(.on_action, .{ .action = std.mem.sliceTo(&name, 0) });
            }
        }
        shown.runner.advance(host.seconds);
        shown.runner.callAll(.on_frame, .{ .seconds = host.seconds });
        shown.runtime.registries.frame(shown.runtime, host.seconds);
    }

    /// Calls `on_music_changed` if the piece playing, given by its `path` or null for none, differs
    /// from last frame's.
    fn tellMusic(shown: *Presentation, path: ?[]const u8) void {
        if (samePiece(path, if (shown.music) |*last| last.slice() else null)) return;
        shown.music = if (path) |playing| .of(playing) else null;
        shown.runner.callAll(.on_music_changed, .{ .piece = if (path) |playing| hog_snd.pieceName(playing) else null });
    }

    /// Where the mods' displays put the game's instruments of the flight display this frame, and
    /// which they stand in for: none while the display's layer isn't shown, as the displays don't
    /// draw then.
    pub fn instrumentPlacements(shown: *const Presentation) std.EnumArray(hud.Instrument, hud.Placement) {
        if (shown.views.get(.hud) == null) return .initFill(.{});
        return shown.runtime.registries.placements();
    }

    /// Where the displays put the parts of the game's instruments this frame
    /// (`hud.Frame.parts`).
    pub fn partPlacements(shown: *const Presentation) std.EnumArray(hud.parts.Part, hud.parts.Placement) {
        if (shown.views.get(.hud) == null) return .initFill(.{});
        return shown.runtime.registries.partPlacements();
    }

    /// Draws what the scripts drew on `which` this frame into `into`, where it's shown. `sight`
    /// places what they drew in the world. First, the pictures taken out of the cache are freed
    /// (`drawing.Assets.release`).
    pub fn draw(shown: *Presentation, which: drawing.Which, into: device.Device, sight: ?hud.Sight) Allocator.Error!void {
        shown.assets.release(shown.gpa);
        const view = shown.views.get(which) orelse return;
        try shown.layers.getPtrConst(which).draw(into, view, sight);
    }

    /// `core.send_global_event` from a player or menu script: the event waits until the game
    /// next runs, when it goes to the game's scripts (`sendEvents`). Takes `payload` over.
    pub fn sendToGame(shown: *Presentation, call: Call, name: []const u8, payload: data.Data) void {
        if (shown.game == null) {
            shown.runtime.release(payload.ref);
            call.raise("events can only be sent while a game runs", .{});
        }
        shown.waiting.send(call, .global, name, payload);
    }

    /// Hands the events the scripts sent since the game last ran over to the game's scripts, in the
    /// order they were sent, with their data copied into the game's state (`data.transfer`). The
    /// game's next update delivers them (`events.zig`). The driver calls it before the game runs
    /// again, so the game's scripts get the events at the same update as if they had gone over at
    /// once.
    pub fn sendEvents(shown: *Presentation) void {
        var sent = shown.waiting.take();
        defer sent.deinit(shown.gpa);
        for (sent.items) |event| {
            defer shown.runtime.release(event.data.ref);
            const game = shown.game orelse continue;
            shown.handOver(game, event) catch log.warn("out of memory sending the event {s}", .{event.name.slice()});
        }
    }

    /// Queues `event` for `game`'s scripts, with its data copied into the game's state.
    fn handOver(shown: *Presentation, game: *game_module.Game, event: events.Pending) Allocator.Error!void {
        const copied = data.transfer(shown.runtime.state, event.data.ref, game.runtime) orelse return error.OutOfMemory;
        try game.runner.events.add(.{ .to = event.to, .name = event.name, .data = .{ .ref = copied } });
    }
};

/// Whether the music paths `one` and `other` name the same piece, ignoring case as Windows does.
/// Two nulls, for no music, count as the same.
fn samePiece(one: ?[]const u8, other: ?[]const u8) bool {
    const first = one orelse return other == null;
    const second = other orelse return false;
    return std.ascii.eqlIgnoreCase(first, second);
}

test samePiece {
    try std.testing.expect(samePiece(null, null));
    try std.testing.expect(samePiece("music\\New_Pensive.wav", "MUSIC\\new_pensive.wav"));
    try std.testing.expect(!samePiece("music\\one.wav", null));
    try std.testing.expect(!samePiece(null, "music\\one.wav"));
    try std.testing.expect(!samePiece("music\\one.wav", "music\\two.wav"));
}

/// The family of the scripts of `place`.
fn familyOf(place: Place) script.Family {
    return switch (place) {
        .menu => .menu,
        .player => .player,
    };
}

/// Whether `mod` lists player or menu scripts.
fn hasScripts(mod: *const Mod) bool {
    for (std.enums.values(Place)) |place| {
        var listed = listedScripts(mod, place);
        if (listed.next() != null) return true;
    }
    return false;
}

/// The scripts `mod` lists for `place`, in order.
fn listedScripts(mod: *const Mod, place: Place) script.List {
    const kind: script.Kind = switch (place) {
        .menu => .menu,
        .player => .player,
    };
    return .of(mod.manifest.value(script.section, kind.key()) orelse "");
}

/// Player and menu scripts from the mods `made`, each a folder of files, and the game's scripts
/// over a mission that holds the player's Predator.
const Fixture = struct {
    tmp: std.testing.TmpDir,
    mods: mods.Mods,
    arena: std.heap.ArenaAllocator,
    held: records.Records,
    mission: engine.game.gameobj.testing.Mission,
    shown: *Presentation,
    devices: input.Devices = .{},
    font: hud.Opened,
    /// Where the frames have the player in the rooms; null while they aren't on screen.
    rooms: ?Host.Rooms = null,
    /// The sound system for the frames, if any.
    sound: ?*hog_snd.Sound = null,

    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 }), .mods = undefined, .arena = .init(gpa), .held = undefined, .mission = undefined, .shown = undefined, .font = .open(try openreliant.fnt.Font.parse(comptime openreliant.fnt.testing.font(false)), null) };
        errdefer fixture.tmp.cleanup();
        errdefer fixture.arena.deinit();
        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.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.shown = (try Presentation.start(gpa, io, fixture.mods.list, &fixture.held, "0.7.0", shared)).?;
    }

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

    /// A frame of `seconds`, in a window of `window`, with the menus shown, and the player where
    /// `rooms` says.
    fn frame(fixture: *Fixture, seconds: f32, window: [2]u32) void {
        var host: Host = .{ .seconds = seconds, .devices = &fixture.devices, .window = window, .rooms = fixture.rooms, .sound = fixture.sound };
        host.views.set(.ui, .{ .font = &fixture.font, .gpa = std.testing.allocator, .screen = window, .scale = 2 });
        fixture.shown.frame(host);
    }
};

test "menu actions dispatch qualified press edges in flight and close on reload" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nMenu=a.luau\n" },
            .{
                "a.luau",
                \\local input = require("openreliant.input")
                \\local action = input.register_action("pulse", {label = "Pulse", key = "f12", modifier = "shift"})
                \\local count = 0
                \\assert(action == "a:pulse")
                \\assert(not pcall(function() input.register_action("pulse", {label = "Duplicate"}) end))
                \\return {engine_handlers = {on_action = function(name)
                \\    if name == action then
                \\        count += 1; assert(count == 1 and input.action_down(action) and input.action_down("pulse"))
                \\    end
                \\end, on_frame = function()
                \\    require("openreliant.ui").text(vector.zero, tostring(count))
                \\end}}
            },
        },
    }});
    defer fixture.deinit();
    const index = fixture.shown.runtime.input_actions.find("a:pulse").?;
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .flying = true };
    fixture.shown.frame(host);
    fixture.devices.keyboard.down[@backingInt(input.Key.f12)] = true;
    fixture.devices.keyboard.down[input.scan.left_shift] = true;
    fixture.shown.frame(host);
    try std.testing.expect(fixture.shown.runtime.input_actions.entries[index].held);
    try std.testing.expectEqualStrings("1", fixture.shown.layers.get(.ui).text.items);
    fixture.shown.frame(host);
    host.flying = false;
    fixture.shown.frame(host);
    try std.testing.expect(!fixture.shown.runtime.input_actions.entries[index].held);
    try fixture.shown.reload();
    host.flying = true;
    fixture.shown.frame(host);
    try std.testing.expect(!fixture.shown.runtime.input_actions.entries[index].ready);
}

test "registered views, displays and screens execute and close with their contexts" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=player.luau\nMenu=menu.luau\n" },
            .{
                "player.luau",
                \\local camera = require("openreliant.camera")
                \\local hud = require("openreliant.hud")
                \\local util = require("openreliant.util")
                \\local view = camera.register_view("follow", {letterbox = true, frame = function(ship, seconds)
                \\    return {position = ship.position + vector.create(0, -50, -100), orientation = util.from_angles(vector.zero)}
                \\end})
                \\hud.register_display("status", {frame = function() hud.text(vector.zero, "registered display") end})
                \\-- Within the mod, its own names work as well as the qualified ones.
                \\assert(hud.set_display_enabled("status", true) and hud.set_display_enabled("a:status", true))
                \\assert(not hud.set_display_enabled("b:status", true) and not hud.set_display_enabled("no such", true))
                \\return {engine_handlers = {on_frame = function()
                \\    assert(camera.set_view("follow") and camera.view == view)
                \\    assert(camera.set_view(view))
                \\    assert(camera.view == view)
                \\end}}
            },
            .{
                "menu.luau",
                \\local ui = require("openreliant.ui")
                \\local screen = ui.register_screen("panel", {frame = function() ui.text(vector.zero, "registered screen") end,
                \\    key = function(key, down) if key == "escape" and down then assert(ui.show_screen(nil)) end end})
                \\assert(ui.show_screen("panel") and ui.show_screen(screen))
            },
        },
    }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 } };
    const layer: drawing.View = .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1 };
    host.views.set(.hud, layer);
    host.views.set(.ui, layer);
    fixture.shown.frame(host);
    try std.testing.expectEqualStrings("registered display", fixture.shown.layers.get(.hud).text.items);
    try std.testing.expectEqualStrings("registered screen", fixture.shown.layers.get(.ui).text.items);
    try engine.surrender.math.testing.expectVector(.{ 0, -50, -100 }, view.place.position);
    try std.testing.expectEqual(engine.game.camera.letterbox, view.bars);
    fixture.shown.key(.escape, true);
    try std.testing.expectEqual(null, fixture.shown.runtime.registries.selected_screen);
    fixture.shown.endGame();
    try std.testing.expectEqual(engine.game.camera.View.cockpit, viewing.view);
    try std.testing.expectEqual(null, fixture.shown.runtime.registries.find(.display, "a:status"));
    try fixture.shown.reload();
    try std.testing.expect(fixture.shown.runtime.registries.find(.screen, "a:panel") != null);
}

test "a display stands in for the game's instruments and reads what they show" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=player.luau\n" },
            .{
                "player.luau",
                \\local hud = require("openreliant.hud")
                \\local frames = 0
                \\hud.register_display("radar", {replaces = {"gunnery", "radar"}, layout = {clock = {offset = vector.create(10, -5, 0), scale = 1.5}},
                \\    parts = {radio_speaker = {offset = vector.create(4, 0, 0), align = "right", text = "COMMS"}, radio_face = {scale = 2, hidden = true}}, frame = function()
                \\    frames += 1
                \\    if frames == 3 then error("broken") end
                \\end})
                \\assert(not pcall(hud.register_display, "bad", {replaces = {"nothing"}, frame = function() end}))
                \\assert(not pcall(hud.register_display, "small", {layout = {clock = {scale = 0}}, frame = function() end}))
                \\assert(not pcall(hud.register_display, "where", {layout = {nothing = {scale = 2}}, frame = function() end}))
                \\-- A picture takes no text, a part must be one of the game's, and its text short enough.
                \\assert(not pcall(hud.register_display, "face", {parts = {radio_face = {text = "x"}}, frame = function() end}))
                \\assert(not pcall(hud.register_display, "part", {parts = {nothing = {scale = 2}}, frame = function() end}))
                \\assert(not pcall(hud.register_display, "long", {parts = {radio_speaker = {text = string.rep("x", 65)}}, frame = function() end}))
                \\return {engine_handlers = {on_frame = function()
                \\    local guns, missiles, radar, target = hud.guns, hud.missiles, hud.radar, hud.target
                \\    hud.text(vector.zero, string.format("%s %s %d %s %d %s %d %d %s %s %d %d %s", tostring(hud.instruments_shown),
                \\        table.concat(hud.replaced, ","), radar.range, tostring(radar.zooming), hud.kills, missiles.armed,
                \\        missiles.left, #missiles.ring, table.concat(hud.open_windows, ","), tostring(guns.all), target.component,
                \\        hud.bounds("radar").right, tostring(hud.bounds("clock"))))
                \\    hud.text(vector.zero, string.format("|%d %s %s", hud.part_bounds("radio_speaker").right, hud.speaker_name, tostring(hud.part_bounds("radio_face"))))
                \\end}}
            },
        },
    }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    var state: hud.State = .{};
    var hud_drawing: hud.Drawing = .{};
    state.radar_range = 1;
    state.missiles.entries[0] = .{ .count = 2, .type = .of(.screamer) };
    state.missiles.entries[1] = .{ .count = 4, .type = .of(.raptor) };
    state.missiles.armed = 1;
    state.windows.status.getPtr(.gunnery).phase = .open;
    state.target = .{ .target = .at(0, 3), .slot = 0 };
    hud_drawing.bounds.set(.radar, .{ .left = 1, .top = 2, .right = 30, .bottom = 40 });
    hud_drawing.part_bounds.set(.radio_speaker, .{ .left = 5, .top = 6, .right = 50, .bottom = 16 });
    var player: input.Player = .{};
    player.kills.count = 7;
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    var strings_table: [2][]const u8 = .{ "", "Moose" };
    const strings: engine.game.language.Language = .{ .strings = &strings_table };
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 }, .flight = .{ .hud = &state, .drawing = &hud_drawing, .player = &player, .strings = &strings, .speaker_name = 2 } };
    host.views.set(.hud, .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1 });
    fixture.shown.frame(host);
    // The scripts read the replaced instruments in the game's order, as the display has them.
    const placed = fixture.shown.instrumentPlacements();
    try std.testing.expect(placed.get(.radar).hidden and placed.get(.gunnery).hidden and !placed.get(.clock).hidden);
    try std.testing.expectEqual(hud.Placement{ .offset = .{ 10, -5 }, .scale = 1.5 }, placed.get(.clock));
    try std.testing.expectEqualStrings("true radar,gunnery 1 false 7 raptor 4 2 gunnery true 3 30 nil|50 Moose nil", fixture.shown.layers.get(.hud).text.items);
    // The parts it places: the speaker's name moved, aligned right and given other words, and the
    // face drawn larger, but hidden.
    const parts = fixture.shown.partPlacements();
    const speaker = parts.get(.radio_speaker);
    try std.testing.expectEqual(hud.Placement{ .offset = .{ 4, 0 } }, speaker.place);
    try std.testing.expectEqual(hud.Align.right, speaker.alignment.?);
    try std.testing.expectEqualStrings("COMMS", speaker.words.?.slice());
    try std.testing.expectEqual(hud.Placement{ .scale = 2, .hidden = true }, parts.get(.radio_face).place);
    // While the display's layer isn't shown, the displays don't draw, and the instruments are as
    // the game has them.
    var shut = host;
    shut.views.set(.hud, null);
    fixture.shown.frame(shut);
    try std.testing.expectEqual(hud.Placement{}, fixture.shown.instrumentPlacements().get(.radar));
    // As its frame fails, the game's instruments come back as they were.
    fixture.shown.frame(host);
    try std.testing.expect(fixture.shown.instrumentPlacements().get(.radar).hidden);
    fixture.shown.frame(host);
    try std.testing.expectEqual(hud.Placement{}, fixture.shown.instrumentPlacements().get(.radar));
    try std.testing.expectEqual(hud.Placement{}, fixture.shown.instrumentPlacements().get(.clock));
    fixture.shown.endGame();
}

test "a display changes its layout after it registers" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=player.luau\n" },
            .{
                "player.luau",
                \\local hud = require("openreliant.hud")
                \\hud.register_display("radio", {layout = {clock = {scale = 2}}, parts = {radio_face = {scale = 2}}, frame = function() end})
                \\-- The layout follows the window, and the parts stay, as the table leaves them out.
                \\assert(hud.set_display_layout("radio", {layout = {clock = {offset = vector.create(5, 0, 0)}}}))
                \\-- A mistake changes nothing, and a name not registered isn't one.
                \\assert(not pcall(hud.set_display_layout, "radio", {layout = {clock = {scale = 0}}, parts = {}}))
                \\assert(not pcall(hud.set_display_layout, "radio", {placement = {}}))
                \\assert(not hud.set_display_layout("b:radio", {}) and not hud.set_display_layout("nothing", {}))
            },
        },
    }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    defer fixture.shown.endGame();
    // The displays place the instruments while the flight display's layer shows.
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 } };
    host.views.set(.hud, .{ .font = &fixture.font, .gpa = std.testing.allocator, .screen = .{ 640, 480 }, .scale = 1 });
    fixture.shown.frame(host);
    try std.testing.expectEqual(hud.Placement{ .offset = .{ 5, 0 } }, fixture.shown.instrumentPlacements().get(.clock));
    try std.testing.expectEqual(hud.Placement{ .scale = 2 }, fixture.shown.partPlacements().get(.radio_face).place);
}

test "a display reads the cockpit's instruments in any view" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=player.luau\n" },
            .{
                "player.luau",
                \\local hud = require("openreliant.hud")
                \\return {engine_handlers = {on_frame = function()
                \\    local g, s, c = hud.gauges, hud.ship_status, hud.clock
                \\    hud.text(vector.zero, string.format("%d %d %.2f %.2f %.2f %.2f %s|%d %d %d %d %d %d|%d %d|%s|%d:%02d|%s|%s|%d %d",
                \\        g.speed, g.asked, g.speed_share, g.throttle_share, g.throttle_brightness, g.charge, tostring(g.nova),
                \\        s.shields.left, s.shields.aft, s.armor.left, s.armor.right, s.reserve_fore, s.reserve_aft,
                \\        hud.fuel, hud.countermeasures, table.concat(hud.lights, ","), c.minutes, c.seconds,
                \\        hud.view_name, hud.caption, #hud.view_name, #hud.caption))
                \\end}}
            },
        },
    }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    const all = fixture.mission.objects;
    all.mission_number = 1;
    const slot = fixture.mission.slot(0);
    const combat = slot.combat.?;
    // Half throttle at a quarter of its top speed, and its guns half charged.
    slot.object.throttle = 0.5;
    slot.object.speed = slot.flight.?.max_speed / 4;
    slot.object.gun_charge = combat.gun_energy / 2;
    slot.object.afterburner_fuel = 7 * engine.game.main.ticks_per_second + 50;
    slot.object.countermeasures = 12;
    slot.object.reverse_thrust = true;
    // Full shields, its left armour down to two arcs' worth, and five arcs' worth shifted fore.
    slot.object.shields = .all(combat.fullShields());
    slot.object.armor = .all(combat.fullArmor());
    slot.object.armor.left = @floatFromInt(combat.armor_class * 2);
    var player: input.Player = .{};
    player.matching_speed = true;
    player.shield_reserves = .{ .fore = 5 * @as(f32, @floatFromInt(combat.shield_power)) };
    var state: hud.State = .{};
    var hud_drawing: hud.Drawing = .{};
    state.smart_targeting = true;
    state.showIcon(.ecm, .flash);
    state.devices.getPtr(.cloak).setting = .absent;
    state.caption = .{ .on = true };
    hud_drawing.caption = .{ .shown = 6 };
    // The strings for the date of mission 1 and the name of the chase view.
    var strings_table: [1000][]const u8 = @splat(" ");
    strings_table[hud.Caption.date(1).? - 1] = "Mai 3\xE9";
    const chase_name = engine.game.camera.View.chase.name().?;
    strings_table[chase_name - 1] = "Chase";
    const strings: engine.game.language.Language = .{ .strings = &strings_table };
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    viewing.view = .chase;
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 }, .flight = .{
        .hud = &state,
        .drawing = &hud_drawing,
        .player = &player,
        .play = .{ .minutes = 3, .seconds = 7 },
        .last_view = .chase,
        .strings = &strings,
    } };
    host.views.set(.hud, .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1 });
    fixture.shown.frame(host);
    const asked, const made = hud.Cluster.Gauges.of(slot).?.figures();
    var expected: [256]u8 = undefined;
    // In the chase view, where the game draws none of them, the readings are as the instruments
    // would show them; the caption has typed the date's six letters, the last from the game's code
    // page, which takes two bytes in UTF-8 and goes back to one as the display draws it.
    const text = try std.mem.print(&expected, "{d} {d} 0.25 0.50 0.75 0.50 false|5 5 1 5 4 0|7 12|match_speed,smart_targeting,ecm,reverse_thrust|3:07|Chase|Mai 3\xE9|5 7", .{ made, asked });
    try std.testing.expectEqualStrings(text, fixture.shown.layers.get(.hud).text.items);
    fixture.shown.endGame();
}

test "a display reads the radar's contacts and the target display" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=player.luau\n" },
            .{
                "player.luau",
                \\local hud = require("openreliant.hud")
                \\return {engine_handlers = {on_frame = function()
                \\    local contact, shown = hud.radar.contacts[1], hud.target_display
                \\    hud.text(vector.zero, string.format("%d %d %s %d %d %d|%s %s %s %d %d %d %d %s %s %.2f %s %s",
                \\        #hud.radar.contacts, contact.object.slot, contact.look, contact.at.x, contact.at.y, contact.height,
                \\        shown.form, shown.name, tostring(shown.pilot), shown.range, shown.speed, shown.shields.left,
                \\        shown.armor.aft, shown.subtarget_class, shown.subtarget, shown.subtarget_armor, tostring(shown.hull),
                \\        table.concat(shown.hits, ",")))
                \\end}}
            },
        },
    }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    const all = fixture.mission.objects;
    // A hostile Sabre ahead, which is the player's target and the display's, its type named.
    const sabre = try fixture.mission.add(.of(.sabre), .{ 0, 0, 40000 });
    const slot = fixture.mission.slot(sabre);
    slot.object.flags.targetable = true;
    slot.object.side = .hostile;
    fixture.mission.tables.combat[engine.game.gameobj.Type.of(.sabre).number()].name = 700;
    var strings_table: [2000][]const u8 = @splat(" ");
    strings_table[700 - 1] = "Sabre";
    // The player's order picks out its engine, a quarter of whose armour is left.
    var part: engine.game.objects.Model.Part = .{ .hidden = false, .parent = null, .origin = @splat(0), .object = .{ .flags = .{}, .position = @splat(0), .radius = 0, .levels = &.{} } };
    part.class = .engine;
    part.component_armor = 200;
    part.armor = 50;
    slot.components[0] = ∂
    slot.object.component_count = 1;
    fixture.mission.slot(0).orders[0].target = .at(sabre, 0);
    strings_table[hud.target_display.named(.engine).?.name - 1] = "Engine";
    // Its pilot, as the game gives a hostile ship until the mission names another.
    strings_table[hud.target_display.pilotName(all, slot).? - 1] = "Ace";
    const strings: engine.game.language.Language = .{ .strings = &strings_table };
    var state: hud.State = .{};
    var hud_drawing: hud.Drawing = .{};
    state.target = .{ .target = .at(sabre, null), .slot = sabre };
    // Its fore quadrant flashes on its schematic.
    hud_drawing.flashes.target_hits = .initOne(.fore);
    var player: input.Player = .{};
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 }, .flight = .{ .hud = &state, .drawing = &hud_drawing, .player = &player, .strings = &strings } };
    host.views.set(.hud, .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1 });
    fixture.shown.frame(host);
    // The radar shows the Sabre alone, as the target, up the screen; the target display its name,
    // its pilot's, its range, its rings, its engine and the hit on it, and no hull bar, the Sabre
    // having no model.
    var contacts: hud.Radar.Contacts = .of(all, state.radar_range, null);
    const contact = contacts.next().?;
    const facts: hud.target_display.Facts = .of(all, sabre);
    const rings = hud.ShipStatus.rings(slot).?;
    const form = hud.target_display.Form.of(hud.targetWindow(slot)).?;
    var expected: [256]u8 = undefined;
    const text = try std.mem.print(&expected, "1 {d} target {d} {d} {d}|{s} Sabre Ace {d} {d} {d} {d} engine Engine 0.26 nil fore", .{
        sabre,                                                        contact.at[0], contact.at[1], contact.height,
        @tagName(form),                                               facts.range,   facts.speed,   std.math.clamp(rings.shields[0], 0, hud.ShipStatus.arc_levels),
        std.math.clamp(rings.armor[3], 0, hud.ShipStatus.arc_levels),
    });
    try std.testing.expectEqualStrings(text, fixture.shown.layers.get(.hud).text.items);
    try std.testing.expect(contact.at[1] < 0);
    fixture.shown.endGame();
}

test "a display reads the windows and the display's text" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=player.luau\n" },
            .{
                "player.luau",
                \\local hud = require("openreliant.hud")
                \\return {engine_handlers = {on_frame = function()
                \\    local d, p, w, o = hud.damage, hud.power, hud.wingmen, hud.objectives
                \\    hud.text(vector.zero, string.format("%.2f %.2f %.2f|%d %d %d|%d %d %d %.2f|%d %d %s %s %d %s|%s|%s|%s|%s|%s",
                \\        d.weapons, d.engines, d.shields, p.shields, p.weapons, p.engines,
                \\        #w, w[1].object.slot, w[1].number, w[1].armor,
                \\        o.showing, #o.list, o.list[1].name, tostring(o.list[1].current), o.list[2].number, tostring(o.list[2].name),
                \\        table.concat(hud.comms, ","), table.concat(hud.messages, ","), hud.subtitle, hud.key_prompt,
                \\        hud.jump_prompt))
                \\    hud.power_ball(vector.create(10, 20, 0), vector.create(40, 30, 0), {alpha = 0.5})
                \\    hud.power_ball(vector.zero)
                \\end}}
            },
        },
    }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    const all = fixture.mission.objects;
    const slot = fixture.mission.slot(0);
    // The player's ship: its systems worn, its power shifted, and the only ship of its wing.
    slot.object.gun_condition = 0.25;
    slot.object.armor_speed_factor = 0.5;
    slot.object.shield_condition = 1;
    slot.object.power_setting = .{ .x = 0.2, .y = -0.1, .z = 0 };
    engine.game.mission.listPlayerWing(all, &.{0});
    // Objectives: the first current, the second listed with no name, the rest hidden; the window
    // shows the second.
    var state: hud.State = .{};
    const hud_drawing: hud.Drawing = .{};
    const names: hud.Objectives.Names = .{ "Patrol", null, null, null, null, null, null, null, null, null };
    state.objectives.own = &names;
    state.objectives.states[0] = .current;
    state.objectives.states[1] = .listed;
    state.objectives.shown = 1;
    state.messages.add("Bogey", 0);
    state.subtitle.show(5);
    state.key_prompt.action = .comms_window;
    var player: input.Player = .{};
    player.menu.items[0] = .{ .label = .{ .string = 4 }, .page = .top, .addressed = -1 };
    player.menu.count = 1;
    var variables: engine.vm.Variables = .{};
    variables.ready.jump = .shown;
    var strings_table: [10][]const u8 = @splat(" ");
    strings_table[4 - 1] = "Target";
    strings_table[5 - 1] = "Sub";
    const strings: engine.game.language.Language = .{ .strings = &strings_table };
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 }, .flight = .{
        .hud = &state,
        .drawing = &hud_drawing,
        .player = &player,
        .variables = &variables,
        .strings = &strings,
    } };
    const picture = try hud.power.testing.picture(gpa);
    defer picture.deinit(gpa);
    const ball: *hud.power.Ball = try .create(gpa, picture);
    defer ball.destroy(gpa);
    host.views.set(.hud, .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1, .power_ball = ball });
    fixture.shown.frame(host);
    // The power balls turn with the player's setting: one in a box of the script's, one at its size
    // on the display.
    const commands = fixture.shown.layers.get(.hud).commands.items;
    const setting = engine.input.power.point(&slot.object);
    try std.testing.expectEqual(setting, commands[1].power_ball.setting);
    try std.testing.expectEqual([2]f32{ 40, 30 }, commands[1].power_ball.size);
    try std.testing.expectEqual(0.5, commands[1].power_ball.colour[3]);
    try std.testing.expectEqual([2]f32{ hud.power.size, hud.power.size }, commands[2].power_ball.size);
    // Drawn, a ball fills its box with the ball's square of the image, without the room for the
    // shake.
    var recorder: device.testing.Recorder = .{ .gpa = gpa };
    defer recorder.deinit();
    try fixture.shown.draw(.hud, recorder.interface(), null);
    const drawn = recorder.drawn(recorder.draws.items.len - 2);
    try std.testing.expectEqual(10, drawn[0].x);
    try std.testing.expectEqual(50, drawn[2].x);
    try std.testing.expectEqual(50, drawn[2].y);
    try std.testing.expectEqual(hud.power.ball_across, drawn[2].u);
    const shares = hud.power.percentages(setting);
    var buffer: [engine.game.mission.wing_size]hud.wing_status.Entry = undefined;
    const wing = hud.wing_status.entries(all, &buffer);
    var expected: [256]u8 = undefined;
    const text = try std.mem.print(&expected, "0.25 0.50 1.00|{d} {d} {d}|1 0 1 {d:.2}|2 2 Patrol true 2 nil|Target|Bogey|Sub|comms_window|jump", .{
        shares.get(.shields), shares.get(.guns), shares.get(.engines), wing[0].armorShare(),
    });
    try std.testing.expectEqualStrings(text, fixture.shown.layers.get(.hud).text.items);
    fixture.shown.endGame();
}

test "a display reads what flashes, the charges, and how far the windows and the radar have moved" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=player.luau\n" },
            .{
                "player.luau",
                \\local hud = require("openreliant.hud")
                \\return {engine_handlers = {on_frame = function()
                \\    local c, g, m = hud.charges, hud.guns, hud.missiles
                \\    local gunnery, comms = hud.window_state("gunnery"), hud.window_state("comms")
                \\    hud.text(vector.zero, string.format("%s|%s|%.2f %s %.2f|%s|%s %.2f %s %.2f %s|%.1f|%d %d|%s %d",
                \\        table.concat(hud.lights_lit, ","), tostring(hud.countermeasures_lit),
                \\        c.ecm, tostring(c.cloak), c.spectral_shields, table.concat(hud.ship_status.hits, ","),
                \\        gunnery.phase, gunnery.opened, comms.phase, comms.opened, tostring(hud.window_state("radar")),
                \\        hud.radar.rings, m.ring[1].place, m.ring[2].place, tostring(g.paired), g.rounds))
                \\end}}
            },
        },
    }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    const slot = fixture.mission.slot(0);
    // A Wolverine, which counts its rounds.
    slot.object.type = .of(.wolverine);
    slot.object.rounds = 3000;
    // The lock warning lit and the ECM's light, the countermeasures lit, and hits on the left and
    // aft; the ECM half charged, no cloak, and the spectral shields full.
    var state: hud.State = .{};
    var hud_drawing: hud.Drawing = .{};
    hud_drawing.flashes = .{ .lights = .{ .enemy_lock = true, .ecm = true }, .countermeasures = true, .hits = .initMany(&.{ .left, .aft }) };
    state.devices.getPtr(.ecm).ticks = @divExact(hud.Device.ecm.spec().full, 2);
    state.devices.getPtr(.cloak).setting = .absent;
    // The radar's rings two steps out from the closest range's.
    state.radar_rings = hud.Radar.range_rings[0] + 2;
    // A Screamer one place round from the armed Raptor.
    state.missiles.entries[0] = .{ .count = 2, .place = 1, .type = .of(.screamer) };
    state.missiles.entries[1] = .{ .count = 4, .place = 0, .type = .of(.raptor) };
    state.missiles.armed = 1;
    // The gunnery window half open, and the comms' second window open.
    state.windows.status.set(.gunnery, .{ .phase = .opening, .progress = @divExact(hud.windows.opening_ticks, 2) });
    state.windows.status.set(.other_comms, .{ .phase = .open, .progress = hud.windows.opening_ticks });
    var player: input.Player = .{};
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 }, .flight = .{ .hud = &state, .drawing = &hud_drawing, .player = &player } };
    host.views.set(.hud, .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1 });
    fixture.shown.frame(host);
    var expected: [256]u8 = undefined;
    const text = try std.mem.print(&expected, "enemy_lock,ecm|true|0.50 nil 1.00|left,aft|opening 0.50 open 1.00 nil|0.4|1 0|{} 3000", .{hud.gunnery.pairShown(slot)});
    try std.testing.expectEqualStrings(text, fixture.shown.layers.get(.hud).text.items);
    fixture.shown.endGame();
}

test "a player script's self follows the player's ship from mission to mission" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=player.luau\n" },
            .{
                "player.luau",
                \\local hud = require("openreliant.hud")
                \\local self = require("openreliant.self")
                \\-- Asked for again each frame, it is the same handle.
                \\hud.register_display("self", {frame = function()
                \\    hud.text(vector.zero, tostring(self:is_valid() and rawequal(require("openreliant.self"), self)))
                \\end})
            },
        },
    }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 } };
    host.views.set(.hud, .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1 });
    fixture.shown.frame(host);
    try std.testing.expectEqualStrings("true", fixture.shown.layers.get(.hud).text.items);
    // The next mission fills the player's slot anew: until it starts, the old handle is gone.
    const all = fixture.mission.objects;
    all.reuses[all.player] +%= 1;
    fixture.shown.frame(host);
    try std.testing.expectEqualStrings("false", fixture.shown.layers.get(.hud).text.items);
    // As it starts, self is the player's ship again.
    fixture.shown.missionStarted(.{ .number = 2, .file = "mission2.dte" });
    fixture.shown.frame(host);
    try std.testing.expectEqualStrings("true", fixture.shown.layers.get(.hud).text.items);
    try std.testing.expect(fixture.shown.runtime.player_self != null);
    fixture.shown.endGame();
    try std.testing.expectEqual(null, fixture.shown.runtime.player_self);
}

test "camera locks take precedence and failed registry callbacks fall back safely" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=player.luau\nMenu=menu.luau\n" },
            .{ "menu.luau", "local ui = require('openreliant.ui'); ui.register_screen('bad', {frame = function() ui.text(vector.zero, 'partial'); error('broken screen') end})" },
            .{
                "player.luau",
                \\local camera = require("openreliant.camera")
                \\local view = camera.register_view("bad", {frame = function() return {position = vector.zero} end})
                \\return {engine_handlers = {on_frame = function() camera.set_view(view) end}}
            },
        },
    }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{ .locked = true, .view = .director };
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 } };
    fixture.shown.frame(host);
    try std.testing.expectEqual(engine.game.camera.View.director, viewing.view);
    viewing.locked = false;
    fixture.shown.frame(host);
    try std.testing.expectEqual(engine.game.camera.View.cockpit, viewing.view);
    try std.testing.expectEqual(null, fixture.shown.runtime.registries.find(.camera, "a:bad"));
    host.views.set(.ui, .{ .font = &fixture.font, .gpa = std.testing.allocator, .screen = .{ 640, 480 }, .scale = 1 });
    fixture.shown.runtime.registries.selected_screen = fixture.shown.runtime.registries.find(.screen, "a:bad");
    fixture.shown.frame(host);
    try std.testing.expectEqual(null, fixture.shown.runtime.registries.selected_screen);
    try std.testing.expectEqual(0, fixture.shown.layers.get(.ui).commands.items.len);
}

test "camera callbacks that select an original view do not apply their returned pose" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=a.luau\n" },
            .{
                "a.luau",
                \\local camera = require("openreliant.camera")
                \\local util = require("openreliant.util")
                \\local name = camera.register_view("switch", {frame = function()
                \\    assert(camera.set_view("external"))
                \\    return {position = vector.create(999, 999, 999), orientation = util.from_angles(vector.zero)}
                \\end})
                \\return {engine_handlers = {on_frame = function() camera.set_view(name) end}}
            },
        },
    }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    fixture.shown.frame(.{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 } });
    try std.testing.expectEqual(engine.game.camera.View.external, viewing.view);
    try engine.surrender.math.testing.expectVector(@splat(0), view.place.position);
    try std.testing.expectEqual(null, fixture.shown.runtime.registries.selected_camera);
}

test "presentation names isolate mods and failed loads remove only new registrations" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{
        .{ "a", &.{
            .{ "mod.ini", "[Scripts]\nMenu=good.luau,bad.luau\n" },
            .{ "good.luau", "local ui = require('openreliant.ui'); assert(ui.register_screen('panel', {frame = function() end}) == 'a:panel'); assert(not pcall(ui.register_screen, 'panel', {frame = function() end}))" },
            .{ "bad.luau", "require('openreliant.ui').register_screen('discard', {frame = function() end}); error('bad load')" },
        } },
        .{ "b", &.{ .{ "mod.ini", "[Scripts]\nMenu=b.luau\n" }, .{ "b.luau", "assert(require('openreliant.ui').register_screen('panel', {frame = function() end}) == 'b:panel')" } } },
    });
    defer fixture.deinit();
    try std.testing.expect(fixture.shown.runtime.registries.find(.screen, "a:panel") != null);
    try std.testing.expect(fixture.shown.runtime.registries.find(.screen, "b:panel") != null);
    try std.testing.expectEqual(null, fixture.shown.runtime.registries.find(.screen, "a:discard"));
}

test "the hud-layout example stands in for the radar and places the cluster and the clock" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "hud-layout", &.{
        .{ "mod.ini", @embedFile("hud-layout/mod.ini") },
        .{ "hud.luau", @embedFile("hud-layout/hud.luau") },
    } }});
    defer fixture.deinit();
    // A ship ahead of the player's, within the radar's reach.
    _ = try fixture.mission.add(.of(.sabre), .{ 0, 0, 1000 });
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    defer fixture.shown.endGame();
    var state: hud.State = .{};
    var hud_drawing: hud.Drawing = .{};
    hud_drawing.bounds.set(.radar, .{ .left = 270, .top = 380, .right = 370, .bottom = 470 });
    var player: input.Player = .{};
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 }, .flight = .{ .hud = &state, .drawing = &hud_drawing, .player = &player } };
    host.views.set(.hud, .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1 });
    fixture.shown.frame(host);
    const placed = fixture.shown.instrumentPlacements();
    try std.testing.expect(placed.get(.radar).hidden);
    try std.testing.expectEqual(1.25, placed.get(.gauges).scale);
    try std.testing.expectEqual([2]f32{ -120, 70 }, placed.get(.clock).offset);
    // Its radar's ring and the line ahead, the ship on it, and the guns' line.
    var lines: usize = 0;
    var blips: usize = 0;
    for (fixture.shown.layers.get(.hud).commands.items) |command| switch (command) {
        .line => lines += 1,
        .rectangle => blips += 1,
        else => {},
    };
    try std.testing.expectEqual(33, lines);
    try std.testing.expectEqual(1, blips);
    try std.testing.expectEqualStrings("ALL GUNS  100%", fixture.shown.layers.get(.hud).text.items);
}

test "the strafe-run example combines registries and built-in interfaces" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "strafe-run", &.{
        .{ "mod.ini", @embedFile("strafe-run/mod.ini") },
        .{ "order.luau", @embedFile("strafe-run/order.luau") },
        .{ "actions.luau", @embedFile("strafe-run/actions.luau") },
        .{ "display.luau", @embedFile("strafe-run/display.luau") },
    } }});
    defer fixture.deinit();
    const sabre = try fixture.mission.add(.of(.sabre), .{ 0, 0, 1000 });
    const scripts = (try game_module.Game.start(std.testing.allocator, std.testing.io, fixture.mods.list, &fixture.held, "0.7.0", fixture.mission.objects, .{}, false)).?;
    defer scripts.stop();
    try fixture.shown.startGame(scripts, fixture.mission.objects, false);
    defer fixture.shown.endGame();
    scripts.scripts.begin(fixture.mission.orders(), .{ .number = 0, .file = "mission0.dte" }, 1);
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .flying = true, .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 } };
    const layer: drawing.View = .{ .font = &fixture.font, .gpa = std.testing.allocator, .screen = .{ 640, 480 }, .scale = 1 };
    host.views.set(.hud, layer);
    host.views.set(.ui, layer);
    fixture.shown.frame(host);
    try std.testing.expectEqualStrings("Shift F12: strafe run", fixture.shown.layers.get(.hud).text.items);
    fixture.devices.keyboard.down[input.scan.left_shift] = true;
    fixture.devices.keyboard.down[@backingInt(input.Key.f12)] = true;
    fixture.shown.frame(host);
    fixture.shown.sendEvents();
    scripts.scripts.update(0.04);
    try std.testing.expectEqual(scripts.runtime.custom_orders.find("strafe-run:strafe_run").?, fixture.mission.slot(sabre).current().?.order);
    engine.game.aigeneric.objectOrders(fixture.mission.orders(), sabre);
    try std.testing.expectEqual(0.25, fixture.mission.slot(sabre).object.yaw_input);
    fixture.devices.keyboard.down[@backingInt(input.Key.f10)] = true;
    fixture.shown.frame(host);
    try std.testing.expectEqualStrings("strafe-run:chase", fixture.shown.runtime.registries.cameraName(viewing.view).?);
    try engine.surrender.math.testing.expectVector(.{ 0, -200, -1000 }, view.place.position);
    fixture.devices.keyboard.down[@backingInt(input.Key.f9)] = true;
    fixture.shown.frame(host);
    try std.testing.expect(fixture.shown.runtime.registries.selected_screen != null);
    try std.testing.expect(fixture.shown.layers.get(.ui).commands.items.len == 3);
}

test "the example action sends a game event that starts its custom order" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "custom-order", &.{
        .{ "mod.ini", @embedFile("custom-order/mod.ini") },
        .{ "pulse.luau", @embedFile("custom-order/pulse.luau") },
        .{ "action.luau", @embedFile("custom-order/action.luau") },
    } }});
    defer fixture.deinit();
    const sabre = try fixture.mission.add(.of(.sabre), .{ 0, 0, 1000 });
    const game_scripts = (try game_module.Game.start(std.testing.allocator, std.testing.io, fixture.mods.list, &fixture.held, "0.7.0", fixture.mission.objects, .{}, false)).?;
    defer game_scripts.stop();
    try fixture.shown.startGame(game_scripts, fixture.mission.objects, false);
    defer fixture.shown.endGame();
    game_scripts.scripts.begin(fixture.mission.orders(), .{ .number = 0, .file = "mission0.dte" }, 1);
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 }, .flying = true };
    fixture.shown.frame(host);
    fixture.devices.keyboard.down[@backingInt(input.Key.f12)] = true;
    fixture.devices.keyboard.down[input.scan.left_shift] = true;
    fixture.shown.frame(host);
    fixture.shown.sendEvents();
    game_scripts.scripts.update(0.04);
    const pulse = game_scripts.runtime.custom_orders.find("custom-order:pulse").?;
    try std.testing.expectEqual(pulse, fixture.mission.slot(sabre).current().?.order);
    engine.game.aigeneric.objectOrders(fixture.mission.orders(), sabre);
    try std.testing.expectEqual(0.25, fixture.mission.slot(sabre).object.throttle);
    host.flying = false;
    fixture.shown.frame(host);
}

test "menu scripts draw over the menus, and hear keys and the window" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nMenu=menu.luau\n" },
            .{
                "menu.luau",
                \\local ui = require("openreliant.ui")
                \\local presses = 0
                \\local resized = nil
                \\return { engine_handlers = {
                \\    on_key_press = function(key) if key == "escape" then presses += 1 end end,
                \\    on_window_resized = function(width, height) resized = width end,
                \\    on_frame = function(seconds)
                \\        assert(ui.width == (resized or 800))
                \\        -- Code 1 is two pixels wide and tall, drawn at twice the game's size.
                \\        local size = ui.measure("\1\1", 2)
                \\        assert(size.width == 16 and size.height == 8)
                \\        ui.text(vector.create(10, 20, 0), "pressed " .. presses, { color = vector.create(1, 0, 0), align = "center" })
                \\        ui.rectangle(vector.create(0, 0, 0), vector.create(5, 5, 0), { alpha = 0.5 })
                \\        if resized then ui.line(vector.create(0, 0, 0), vector.create(resized, 0, 0)) end
                \\        assert(not pcall(ui.text, vector.create(0, 0, 0), "x", { colur = 1 }))
                \\    end,
                \\} }
            },
        },
    }});
    defer fixture.deinit();
    const shown = fixture.shown;
    fixture.frame(0.016, .{ 800, 600 });
    try std.testing.expectEqual(2, shown.layers.get(.ui).commands.items.len);
    // A key held down that the window repeats is told once.
    shown.key(.escape, true);
    shown.key(.escape, true);
    shown.key(.escape, false);
    fixture.frame(0.016, .{ 800, 600 });
    const layer = shown.layers.getPtr(.ui);
    try std.testing.expectEqualStrings("pressed 1", layer.text.items);
    try std.testing.expectEqual(hud.Align.centre, layer.commands.items[0].text.alignment);
    // A new size is told before the frame, which draws a line across the new width.
    fixture.frame(0.016, .{ 1024, 768 });
    try std.testing.expectEqual(3, layer.commands.items.len);
    try std.testing.expectEqual(1024, layer.commands.items[2].line.to.screen[0]);
}

test "ui.pointer is in the window's pixels" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nMenu=menu.luau\n" },
            .{
                "menu.luau",
                \\local ui = require("openreliant.ui")
                \\return { engine_handlers = { on_frame = function()
                \\    local pointer = ui.pointer
                \\    ui.text(vector.zero, if pointer then `{pointer.at.x} {pointer.at.y} {pointer.down}` else "none")
                \\end } }
            },
        },
    }});
    defer fixture.deinit();
    const layer = fixture.shown.layers.getPtr(.ui);
    fixture.frame(0.016, .{ 800, 600 });
    try std.testing.expectEqualStrings("none", layer.text.items);
    // The window gives the pointer's place as fractions of its size.
    fixture.devices.mouse.at = .{ 0.5, 0.25 };
    fixture.devices.mouse.buttons.left = true;
    fixture.frame(0.016, .{ 800, 600 });
    try std.testing.expectEqualStrings("400 150 true", layer.text.items);
}

test "menu scripts follow the rooms and turn the CD player's pages" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nMenu=menu.luau\n" },
            .{
                "menu.luau",
                \\local rooms = require("openreliant.rooms")
                \\local told = {}
                \\return { engine_handlers = {
                \\    on_room_changed = function(view, place) table.insert(told, tostring(view) .. " " .. tostring(place)) end,
                \\    on_frame = function()
                \\        require("openreliant.ui").text(vector.zero, table.concat(told, ","))
                \\        if rooms.place == "cd_player" then
                \\            assert(rooms.carrier == "reliant" and rooms.view == 5 and rooms.cd_player_page == 1)
                \\            -- A requested page reads back as the page until the CD player turns to it.
                \\            assert(rooms.set_cd_player_page(2) and rooms.cd_player_page == 2)
                \\            assert(rooms.cd_player_pages == 2 and not pcall(rooms.set_cd_player_page, 3))
                \\        else
                \\            assert(not rooms.set_cd_player_page(2) and rooms.cd_player_page == nil)
                \\        end
                \\    end,
                \\} }
            },
        },
    }});
    defer fixture.deinit();
    const shown = fixture.shown;
    // Outside the rooms, no event fires.
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqualStrings("", shown.layers.get(.ui).text.items);
    // The player walks into view 5 and opens the CD player there: each fires one event.
    fixture.rooms = .{ .carrier = .reliant, .view = 4 };
    fixture.frame(0.016, .{ 640, 480 });
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(null, shown.takeCdPlayerPage());
    fixture.rooms = .{ .carrier = .reliant, .view = 4, .place = .cd_player, .cd_player_page = 0 };
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(1, shown.takeCdPlayerPage().?);
    try std.testing.expectEqual(null, shown.takeCdPlayerPage());
    // Leaving the rooms fires an event with nil.
    fixture.rooms = null;
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqualStrings("5 nil,5 cd_player,nil nil", shown.layers.get(.ui).text.items);
}

test "scripts play their mods' sounds, control the music, and hear it change" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nMenu=menu.luau\nPlayer=player.luau\n" },
            .{ "beep.wav", hog_snd.testing.sound_file },
            .{ "notes.txt", "not a sound" },
            .{ "broken.wav", "not a WAVE file" },
            .{
                "menu.luau",
                \\local audio = require("openreliant.audio")
                \\local told = {}
                \\local beep
                \\local frames = 0
                \\return { engine_handlers = {
                \\    on_music_changed = function(piece) table.insert(told, tostring(piece)) end,
                \\    on_frame = function()
                \\        frames += 1
                \\        if frames == 1 then
                \\            beep = audio.play_sound("BEEP.wav", {volume = 0.5, pitch = 2, loop = true, pan = -1})
                \\            assert(beep and audio.sound_playing(beep))
                \\            -- A file the mod hasn't got, one that isn't a sound, and wrong options are errors.
                \\            for _, name in {"missing.wav", "notes.txt", "broken.wav", "../beep.wav"} do
                \\                assert(not pcall(audio.play_sound, name))
                \\            end
                \\            assert(not pcall(audio.play_sound, "beep.wav", {pitch = 0}))
                \\            assert(not pcall(audio.play_sound, "beep.wav", {near = 10, far = 5}))
                \\            -- In 3D outside a mission, or the game's sound without its bank, nothing plays.
                \\            assert(audio.play_sound("beep.wav", {at = vector.zero}) == nil)
                \\            assert(audio.play_sound(0) == nil)
                \\            assert(not audio.sound_playing(nil))
                \\            audio.play_music("one.wav")
                \\        elseif frames == 2 then
                \\            assert(audio.music == "one.wav")
                \\            audio.stop_sound(beep)
                \\            assert(not audio.sound_playing(beep))
                \\            audio.play_music("two.wav", {after_fade = true, loop = false})
                \\        elseif frames == 3 then
                \\            assert(audio.music == "two.wav")
                \\            audio.stop_music()
                \\        end
                \\        require("openreliant.ui").text(vector.zero, table.concat(told, ","))
                \\    end,
                \\} }
            },
            .{
                "player.luau",
                \\local audio = require("openreliant.audio")
                \\local hum
                \\return { engine_handlers = { on_frame = function()
                \\    hum = hum or audio.play_sound("beep.wav", {loop = true})
                \\end } }
            },
        },
    }});
    defer fixture.deinit();
    const shown = fixture.shown;
    var speaker: hog_snd.testing.Speaker = undefined;
    try speaker.init(4, null);
    const driver = speaker.mixer.driver();
    const sound = &speaker.sound;
    try fixture.tmp.dir.createDirPath(io, "music");
    try fixture.tmp.dir.writeFile(io, .{ .sub_path = "music/one.wav", .data = hog_snd.testing.sound_file });
    try fixture.tmp.dir.writeFile(io, .{ .sub_path = "music/two.wav", .data = hog_snd.testing.sound_file });
    sound.files = .{ .gpa = gpa, .io = io, .dir = fixture.tmp.dir };
    defer sound.closeMusic();
    fixture.sound = sound;
    const scripted = struct {
        fn voice(of: *const hog_snd.Sound) ?u8 {
            for (of.starters[0..of.voice_count], 0..) |starter, v| {
                if (starter != .game) return @intCast(v);
            }
            return null;
        }
    }.voice;

    // The menu script's sound plays at twice its rate, panned left, and the music starts.
    fixture.frame(0.016, .{ 640, 480 });
    const v = scripted(sound).?;
    const state = speaker.mixer.samples[@backingInt(sound.voices[v].sample)].state;
    try std.testing.expectEqual(2 * hog_snd.testing.Speaker.rate, state.playing.?.rate);
    try std.testing.expectEqual(0, state.pan);
    // The sound stops, and the next piece is queued until the music fades out.
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(engine.mss.Status.done, driver.sampleStatus(sound.voices[v].sample));
    try std.testing.expect(sound.music.fading and sound.music.queued != null);
    var ticks: u32 = 0;
    while (sound.music.stream != null) : (ticks += 6) sound.timerTick(ticks);
    sound.updateMusic();
    // The music stops, and the queue is empty.
    fixture.frame(0.016, .{ 640, 480 });
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(null, sound.pieceOn());
    try std.testing.expectEqualStrings("one.wav,two.wav,nil", shown.layers.get(.ui).text.items);

    // A player script's sound uses the same cached file, and stops when the game ends.
    try shown.startGame(null, fixture.mission.objects, false);
    fixture.frame(0.016, .{ 640, 480 });
    const hum = scripted(sound).?;
    try std.testing.expectEqual(engine.mss.Status.playing, driver.sampleStatus(sound.voices[hum].sample));
    try std.testing.expectEqual(1, shown.sounds.files.items.len);
    shown.endGame();
    try std.testing.expectEqual(engine.mss.Status.done, driver.sampleStatus(sound.voices[hum].sample));
}

test "the audio example chimes as a piece starts, drops a beacon, and fades the music" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "audio", &.{
        .{ "mod.ini", @embedFile("audio/mod.ini") },
        .{ "now_playing.luau", @embedFile("audio/now_playing.luau") },
        .{ "beacon.luau", @embedFile("audio/beacon.luau") },
        .{ "chime.wav", @embedFile("audio/chime.wav") },
        .{ "beacon.wav", @embedFile("audio/beacon.wav") },
    } }});
    defer fixture.deinit();
    const shown = fixture.shown;
    var speaker: hog_snd.testing.Speaker = undefined;
    try speaker.init(4, null);
    const sound = &speaker.sound;
    const smp3d = comptime hog_snd.testing.bank(80);
    sound.open3D(try openreliant.fat.Bank.parse(&smp3d), &.{});
    try fixture.tmp.dir.createDirPath(io, "music");
    try fixture.tmp.dir.writeFile(io, .{ .sub_path = "music/New_Pensive.wav", .data = hog_snd.testing.sound_file });
    sound.files = .{ .gpa = gpa, .io = io, .dir = fixture.tmp.dir };
    defer sound.closeMusic();
    try shown.startGame(null, fixture.mission.objects, false);
    var view: engine.game.camera.Camera = .{};
    var viewing: engine.game.camera.Viewing = .{};
    var host: Host = .{
        .seconds = 0.04,
        .devices = &fixture.devices,
        .window = .{ 640, 480 },
        .sound = sound,
        .camera = .{ .camera = &view, .viewing = &viewing, .now = 1, .player = 0 },
        .scene = .{ .objects = fixture.mission.objects, .camera = .{ .position = @splat(0), .orientation = engine.surrender.math.identity }, .view = .chase, .clock = &fixture.mission.clock },
    };
    const layer: drawing.View = .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1 };
    host.views.set(.hud, layer);
    host.views.set(.ui, layer);
    const press = struct {
        fn press(on: *Presentation, key: input.Key) void {
            on.key(key, true);
            on.key(key, false);
        }
    }.press;
    shown.frame(host);
    fixture.devices.keyboard.down[@backingInt(input.Key.left_shift)] = true;

    // Shift F2 starts the main menu's piece. When it starts, the chime plays and its name shows.
    press(shown, .f2);
    sound.updateMusic();
    shown.frame(host);
    try std.testing.expectEqualStrings("NOW PLAYING: NEW_PENSIVE", shown.layers.get(.ui).text.items);
    const chimes = for (sound.starters[0..sound.voice_count]) |starter| {
        if (starter != .game) break true;
    } else false;
    try std.testing.expect(chimes);
    // Shift F4 drops a beacon at the ship, which loops in 3D until Shift F4 is pressed again.
    const beacon = struct {
        fn playing(of: *const hog_snd.Sound) bool {
            for (of.starters_3d[0..of.voice_3d_count], of.voices_3d[0..of.voice_3d_count]) |starter, voice| {
                if (starter != .game and !voice.isFree()) return true;
            }
            return false;
        }
    }.playing;
    press(shown, .f4);
    try std.testing.expect(beacon(sound));
    press(shown, .f4);
    try std.testing.expect(!beacon(sound));
    // Shift F2 fades the music out.
    press(shown, .f2);
    try std.testing.expect(sound.music.fading);
}

test "a script draws the shapes of a sprite set it names" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    const sprite = try openreliant.spr.testing.paletteAndShape(gpa);
    defer gpa.free(sprite);
    try openreliant.hog.testing.write(gpa, io, tmp.dir, "resource.hog", &.{.{ .name = "frntend5.spr", .data = sprite }});
    var archive: engine.game.bigfile.Hog = try .open(gpa, io, tmp.dir, "resource.hog");
    defer archive.close(gpa);
    var fixture: Fixture = undefined;
    try fixture.initShared(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nMenu=menu.luau\n" },
            .{
                "menu.luau",
                \\local ui = require("openreliant.ui")
                \\return { engine_handlers = { on_frame = function()
                \\    -- By its name in the archive, with or without its folder: read once.
                \\    ui.shape(vector.zero, 1, { sprites = "frntend5.spr" })
                \\    ui.shape(vector.zero, 1, { sprites = "interface\\frntend5.spr", scale = 2 })
                \\    local ok, err = pcall(ui.shape, vector.zero, 5, { sprites = "frntend5.spr" })
                \\    assert(not ok and string.find(err, "no shape 5 in frntend5.spr", 1, true))
                \\    ok, err = pcall(ui.shape, vector.zero, 1, { sprites = "none.spr" })
                \\    assert(not ok and string.find(err, "sprite set none.spr: neither the mods nor the game's resource.hog have it", 1, true))
                \\    -- The menus have no set of their own here.
                \\    assert(not pcall(ui.shape, vector.zero, 1))
                \\end } }
            },
        },
    }}, .{ .files = archive });
    defer fixture.deinit();
    fixture.frame(0.016, .{ 640, 480 });
    const commands = fixture.shown.layers.get(.ui).commands.items;
    try std.testing.expectEqual(2, commands.len);
    try std.testing.expect(commands[0].shape.sprites != null);
    try std.testing.expectEqual(1, fixture.shown.assets.sprite_sets.items.len);
}

test "scripts draw cached mod pictures, game shapes and measured custom fonts" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nMenu=a.luau\n" },
            .{ "font.ttf", "face" },
            .{ "bad.ttf", "not a font" },
            .{ "bad.png", "not a PNG" },
            .{
                "a.luau",
                \\local ui = require("openreliant.ui")
                \\return {engine_handlers = {on_frame = function()
                \\    local style = {font = "font.ttf", base_font = "menu_large", scale = 2}
                \\    local size = ui.measure("AH", style)
                \\    assert(size.width == 24 and size.height == 16)
                \\    -- Where the letters' pixels fall, which a right alignment puts before the point.
                \\    local ink = size.ink
                \\    assert(ink.left < ink.right and ink.top < ink.bottom)
                \\    local right = ui.measure("AH", {font = "font.ttf", base_font = "menu_large", scale = 2, align = "right"}).ink
                \\    assert(right.left == ink.left - 24 and right.right == ink.right - 24)
                \\    assert(ui.measure("  ", style).ink == nil)
                \\    ui.text(vector.create(1, 2, 0), "AH", style)
                \\    ui.text(vector.zero, "AH", {font = "menu_large"})
                \\    -- Over a font whose letters use palette colours too, as the display's do.
                \\    ui.text(vector.zero, "AH", {font = "font.ttf", base_font = "hud"})
                \\    ui.picture(vector.create(10, 20, 0), "icon.png", vector.create(12, 8, 0), {alpha = 0.5})
                \\    ui.shape(vector.create(30, 40, 0), 1, {scale = 2})
                \\    assert(not pcall(ui.picture, vector.zero, "bad.png"))
                \\    local ok, err = pcall(ui.text, vector.zero, "AH", {font = "bad.ttf", base_font = "menu_large"})
                \\    assert(not ok and string.find(err, "can't be read as a TrueType or OpenType font", 1, true))
                \\    assert(not pcall(ui.picture, vector.zero, "../icon.png"))
                \\end}}
            },
        },
    }});
    defer fixture.deinit();
    var png: std.Io.Writer.Allocating = .init(gpa);
    defer png.deinit();
    try openreliant.png.writeRgba(gpa, &png.writer, 1, 1, &.{ 255, 0, 0, 255 });
    const mod = fixture.mods.list[0];
    try mod.source.folder.dir.writeFile(std.testing.io, .{ .sub_path = "icon.png", .data = png.written() });
    // Folder lookup is inventoried at open, so reopen after adding the synthetic picture.
    fixture.shown.stop();
    fixture.mods.close(gpa);
    fixture.mods = try .open(gpa, std.testing.io, fixture.tmp.dir, null);
    fixture.shown = (try Presentation.start(gpa, std.testing.io, fixture.mods.list, &fixture.held, "0.7.0", .{})).?;
    var boxes: hud.outline.testing.Boxes = .{};
    defer std.debug.assert(boxes.open_faces == 0);
    // Close cached faces before checking the rasterizer's lifetime.
    defer fixture.shown.assets.deinit(gpa);
    var font: hud.Opened = .ramp(try openreliant.fnt.Font.parse(hud.outline.testing.font));
    defer font.deinit(gpa);
    const palette = comptime palette: {
        var colours: [openreliant.spr.palette_size]u8 = @splat(0);
        colours[160 * 3 ..][0..3].* = .{ 0, 0x20, 0x3F };
        break :palette colours;
    };
    // The display's font, drawn in one colour as scripts write in it.
    var blue: hud.Opened = .monochrome(try openreliant.fnt.Font.parse(comptime hud.outline.testing.fontInked(.{ 12, 160, 160 }, palette)));
    defer blue.deinit(gpa);
    const sprite_bytes = try openreliant.spr.testing.paletteAndShape(gpa);
    defer gpa.free(sprite_bytes);
    var art = try hud.Art.init(gpa, try openreliant.spr.Sprite.parse(sprite_bytes), null, null);
    defer art.deinit(gpa);
    var view: drawing.View = .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1, .art = &art, .rasterizer = boxes.rasterizer() };
    view.fonts.set(.menu_large, &font);
    view.fonts.set(.hud, &blue);
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 } };
    host.views.set(.ui, view);
    fixture.shown.frame(host);
    try std.testing.expectEqual(5, fixture.shown.layers.get(.ui).commands.items.len);
    try std.testing.expectEqual(1, fixture.shown.assets.pictures.items.len);
    try std.testing.expectEqual(2, fixture.shown.assets.fonts.items.len);
    // The font over it is fitted and drawn like it.
    const over_blue = fixture.shown.assets.fonts.items[1].opened;
    try std.testing.expectEqual(blue.paint.inked, over_blue.paint.inked);
    try std.testing.expect(over_blue.outline != null);
    var recorder: device.testing.Recorder = .{ .gpa = gpa };
    defer recorder.deinit();
    try fixture.shown.draw(.ui, recorder.interface(), null);
    try std.testing.expect(recorder.draws.items.len > 2);
    // The frame ran to its end, every assertion holding, so it runs again.
    fixture.shown.frame(host);
    try std.testing.expectEqual(5, fixture.shown.layers.get(.ui).commands.items.len);
    try std.testing.expectEqual(1, fixture.shown.assets.pictures.items.len);
    try fixture.shown.reload();
    fixture.shown.frame(host);
    try std.testing.expectEqual(2, fixture.shown.assets.pictures.items.len);
    try std.testing.expectEqual(4, fixture.shown.assets.fonts.items.len);
}

test "a script draws more pictures over time than the cache holds" {
    const gpa = std.testing.allocator;
    var arena: std.heap.ArenaAllocator = .init(gpa);
    defer arena.deinit();
    var png: std.Io.Writer.Allocating = .init(gpa);
    defer png.deinit();
    try openreliant.png.writeRgba(gpa, &png.writer, 1, 1, &.{ 255, 0, 0, 255 });
    // A picture for each frame, one more than the cache holds.
    const pictures = drawing.max_assets + 1;
    var files: std.ArrayList(struct { []const u8, []const u8 }) = .empty;
    try files.append(arena.allocator(), .{ "mod.ini", "[Scripts]\nMenu=a.luau\n" });
    try files.append(arena.allocator(), .{ "a.luau", "local n = 0\nreturn {engine_handlers = {on_frame = function() n += 1; require('openreliant.ui').picture(vector.zero, 'p' .. n .. '.png') end}}" });
    for (1..pictures + 1) |n| try files.append(arena.allocator(), .{ try arena.allocator().print("p{d}.png", .{n}), png.written() });
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "a", files.items }});
    defer fixture.deinit();
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 } };
    host.views.set(.ui, .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1 });
    // Each frame is drawn, and the device makes a texture of each picture.
    var recorder: device.testing.Recorder = .{ .gpa = gpa, .textures = .{} };
    defer recorder.deinit();
    for (0..pictures - 1) |_| {
        fixture.shown.frame(host);
        try fixture.shown.draw(.ui, recorder.interface(), null);
    }
    fixture.shown.frame(host);
    // The last picture drew, and the first, drawn longest ago, made room for it.
    try std.testing.expectEqual(1, fixture.shown.layers.get(.ui).commands.items.len);
    try std.testing.expectEqual(drawing.max_assets, fixture.shown.assets.pictures.items.len);
    try std.testing.expectEqual(1, fixture.shown.assets.taken_out.items.len);
    // Drawing the frame frees it, and its texture goes back to the device.
    try fixture.shown.draw(.ui, recorder.interface(), null);
    try std.testing.expectEqual(1, recorder.textures.?.released);
    try std.testing.expectEqual(0, fixture.shown.assets.taken_out.items.len);
}

test "with outline fonts off, a script's outline font is drawn in its base font" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "a", &.{
        .{ "mod.ini", "[Scripts]\nMenu=a.luau\n" },
        .{ "font.ttf", "face" },
        .{ "a.luau", "return {engine_handlers = {on_frame = function() require('openreliant.ui').text(vector.zero, 'AH', {font = 'font.ttf', base_font = 'menu_large'}) end}}" },
    } }});
    defer fixture.deinit();
    defer fixture.shown.assets.deinit(gpa);
    var font: hud.Opened = .ramp(try openreliant.fnt.Font.parse(hud.outline.testing.font));
    defer font.deinit(gpa);
    var view: drawing.View = .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 640, 480 }, .scale = 1 };
    view.fonts.set(.menu_large, &font);
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 } };
    host.views.set(.ui, view);
    fixture.shown.frame(host);
    const commands = fixture.shown.layers.get(.ui).commands.items;
    try std.testing.expectEqual(1, commands.len);
    try std.testing.expectEqual(&font, commands[0].text.font.?);
    try std.testing.expectEqual(0, fixture.shown.assets.fonts.items.len);
}

test "the drawing assets example handles absent optional files" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "drawing-assets", &.{
        .{ "mod.ini", @embedFile("drawing-assets/mod.ini") },
        .{ "drawing.luau", @embedFile("drawing-assets/drawing.luau") },
    } }});
    defer fixture.deinit();
    var view: drawing.View = .{ .font = &fixture.font, .gpa = std.testing.allocator, .screen = .{ 640, 480 }, .scale = 1 };
    view.fonts.set(.menu_large, &fixture.font);
    var host: Host = .{ .seconds = 0.04, .devices = &fixture.devices, .window = .{ 640, 480 } };
    host.views.set(.ui, view);
    fixture.shown.frame(host);
    try std.testing.expectEqualStrings("Drawing assets", fixture.shown.layers.get(.ui).text.items);
    try std.testing.expectEqual(1, fixture.shown.layers.get(.ui).commands.items.len);
}

test "menu scripts reload from their files, and start again" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "a", &.{
        .{ "mod.ini", "[Scripts]\nMenu=menu.luau\n" },
        .{ "menu.luau", "local frames = 0\nreturn { engine_handlers = { on_frame = function() frames += 1; require('openreliant.ui').text(vector.zero, 'old ' .. frames) end } }" },
    } }});
    defer fixture.deinit();
    const layer = fixture.shown.layers.getPtr(.ui);
    fixture.frame(0.016, .{ 800, 600 });
    fixture.frame(0.016, .{ 800, 600 });
    try std.testing.expectEqualStrings("old 2", layer.text.items);
    // The file saved again, the menu script starts again with the new code.
    try fixture.tmp.dir.writeFile(std.testing.io, .{ .sub_path = "mods/a/menu.luau", .data = "local frames = 0\nreturn { engine_handlers = { on_frame = function() frames += 1; require('openreliant.ui').text(vector.zero, 'new ' .. frames) end } }" });
    try fixture.shown.reload();
    fixture.frame(0.016, .{ 800, 600 });
    try std.testing.expectEqualStrings("new 1", layer.text.items);
}

test "player scripts run with the game, and send it events" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nGlobal=game.luau\nPlayer=player.luau\nMenu=menu.luau\n" },
            .{
                "game.luau",
                \\return { event_handlers = {
                \\    Throttle = function(data) data.ship.throttle = data.to end,
                \\} }
            },
            .{
                "player.luau",
                \\local core = require("openreliant.core")
                \\local nearby = require("openreliant.nearby")
                \\local sent = false
                \\return {
                \\    interface_name = "Pilot",
                \\    interface = { sent = function() return sent end },
                \\    engine_handlers = { on_frame = function()
                \\        if sent then return end
                \\        -- Its own object is the player's ship.
                \\        assert(require("openreliant.self").is_player)
                \\        -- A player script can't change the game itself, only send it events.
                \\        assert(not pcall(require, "openreliant.world"))
                \\        local ships = nearby.objects(1000)
                \\        assert(#ships == 1 and ships[1].type == "sabre")
                \\        assert(not pcall(function() ships[1].throttle = 0.5 end))
                \\        core.send_global_event("Throttle", { ship = ships[1], to = 0.5 })
                \\        sent = true
                \\    end },
                \\}
            },
            .{
                "menu.luau",
                \\local I = require("openreliant.interfaces")
                \\local ui = require("openreliant.ui")
                \\return { engine_handlers = { on_frame = function()
                \\    if I.Pilot and I.Pilot.sent() then ui.text(vector.create(0, 0, 0), "seen") end
                \\end } }
            },
        },
    }});
    defer fixture.deinit();
    const gpa = std.testing.allocator;
    const game = (try game_module.Game.start(gpa, std.testing.io, fixture.mods.list, &fixture.held, "0.7.0", fixture.mission.objects, .{}, false)).?;
    defer game.stop();
    const sabre = try fixture.mission.add(.of(.sabre), .{ 0, 0, 500 });
    try std.testing.expectEqual(1, fixture.shown.lists.get(.menu).items.len);
    try fixture.shown.startGame(game, fixture.mission.objects, false);
    try std.testing.expectEqual(1, fixture.shown.lists.get(.player).items.len);
    // The player script's event waits until it goes over to the game's scripts (`sendEvents`),
    // then reaches the global script at the game's next update, with the Sabre's handle.
    fixture.frame(0.016, .{ 800, 600 });
    game.scripts.update(0.1);
    try std.testing.expect(fixture.mission.objects.slots[sabre].object.throttle != 0.5);
    fixture.shown.sendEvents();
    game.scripts.update(0.1);
    try std.testing.expectEqual(0.5, fixture.mission.objects.slots[sabre].object.throttle);
    // The menu script sees the player script's interface.
    fixture.frame(0.016, .{ 800, 600 });
    try std.testing.expectEqualStrings("seen", fixture.shown.layers.get(.ui).text.items);
    // As the game ends, the player script stops, and so does its interface.
    fixture.shown.endGame();
    try std.testing.expectEqual(0, fixture.shown.lists.get(.player).items.len);
    fixture.frame(0.016, .{ 800, 600 });
    try std.testing.expectEqual(0, fixture.shown.layers.get(.ui).commands.items.len);
}

test "the bouncing DVD logo example drifts, bounces and changes colour" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "dvd", &.{
        .{ "mod.ini", @embedFile("dvd/mod.ini") },
        .{ "dvd.luau", @embedFile("dvd/dvd.luau") },
    } }});
    defer fixture.deinit();
    const layer = fixture.shown.layers.getPtr(.ui);
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(2, layer.commands.items.len);
    const first = layer.commands.items[0].text;
    // It drifts down and to the right, and after long enough it has bounced and changed colour.
    fixture.frame(0.5, .{ 640, 480 });
    const moved = layer.commands.items[0].text;
    try std.testing.expect(moved.at.screen[0] > first.at.screen[0] and moved.at.screen[1] > first.at.screen[1]);
    try std.testing.expectEqualDeep(first.colour, moved.colour);
    fixture.frame(3, .{ 640, 480 });
    const bounced = layer.commands.items[0].text;
    try std.testing.expect(!std.meta.eql(first.colour, bounced.colour));
    // While the menus aren't shown, it draws nothing.
    fixture.shown.frame(.{ .seconds = 0.016, .devices = &fixture.devices, .window = .{ 640, 480 } });
    try std.testing.expectEqual(0, layer.commands.items.len);
}

test "the wingmen example's panel lists the wingmen nearby, and calls them back" {
    const storage_module = @import("storage.zig");
    const options = @import("options.zig");
    const gpa = std.testing.allocator;
    var storage: storage_module.Storage = .{ .gpa = gpa };
    defer storage.deinit();
    var pages: options.Registry = .init(gpa, &storage);
    defer pages.deinit();
    const shared: runtime.Shared = .{ .storage = &storage, .option_pages = &pages };
    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") },
    } }}, shared);
    defer fixture.deinit();
    const game = (try game_module.Game.start(gpa, std.testing.io, fixture.mods.list, &fixture.held, "0.7.0", fixture.mission.objects, shared, false)).?;
    defer game.stop();
    game.scripts.begin(fixture.mission.orders(), .{ .number = 5, .file = "mission5.dte" }, 1);
    const wingman = try fixture.mission.add(.of(.wolverine), .{ 0, 0, -1000 });
    fixture.mission.objects.slots[wingman].object.side = .friendly;
    try fixture.shown.startGame(game, fixture.mission.objects, false);
    // Over the flight display, the panel's title and the wingman's line.
    var host: Host = .{ .seconds = 0.016, .devices = &fixture.devices, .window = .{ 1024, 768 }, .flying = true };
    host.views.set(.hud, .{ .font = &fixture.font, .gpa = gpa, .screen = .{ 1024, 768 }, .scale = 1 });
    fixture.shown.frame(host);
    const layer = fixture.shown.layers.getPtr(.hud);
    try std.testing.expectEqual(2, layer.commands.items.len);
    try std.testing.expect(std.mem.endsWith(u8, layer.text.items, "1  97%"));
    // F9 hides it.
    fixture.shown.key(.f9, true);
    fixture.shown.frame(host);
    try std.testing.expectEqual(0, layer.commands.items.len);
    // With the wingman out of the fight, Shift+F9 calls it back to the formation at the game's
    // next update.
    const slot = &fixture.mission.objects.slots[wingman];
    slot.object.armor = .all(1);
    slot.object.last_attacker = .of(0);
    game.scripts.update(0.1);
    try std.testing.expectEqual(.run_away, slot.current().?.order);
    game.scripts.update(0.1);
    fixture.shown.key(.f9, false);
    fixture.devices.keyboard.down[@backingInt(input.Key.left_shift)] = true;
    fixture.shown.key(.f9, true);
    fixture.shown.frame(host);
    fixture.shown.sendEvents();
    game.scripts.update(0.1);
    game.scripts.update(0.1);
    try std.testing.expectEqual(.formation, slot.current().?.order);
}

test "menu scripts are told of their own mod's options" {
    var fixture: Fixture = undefined;
    const handler =
        \\local ui = require("openreliant.ui")
        \\local heard = "nothing"
        \\return { engine_handlers = {
        \\    on_option_changed = function(key, value) heard = key .. "=" .. tostring(value) end,
        \\    on_frame = function() ui.text(vector.create(0, 0, 0), heard) end,
        \\} }
    ;
    try fixture.init(&.{
        .{ "a", &.{ .{ "mod.ini", "[Scripts]\nMenu=menu.luau\n" }, .{ "menu.luau", handler } } },
        .{ "b", &.{ .{ "mod.ini", "[Scripts]\nMenu=menu.luau\n" }, .{ "menu.luau", handler } } },
    });
    defer fixture.deinit();
    fixture.shown.optionChanged("b", "flee", .{ .number = 0.35 });
    fixture.shown.optionChanged("b", "show", .{ .boolean = false });
    fixture.frame(0.016, .{ 800, 600 });
    // Mod a heard nothing, and mod b the last of its changes.
    try std.testing.expectEqualStrings("nothingshow=false", fixture.shown.layers.getPtr(.ui).text.items);
}

test "player scripts register post effects, which draw in order and end with their scripts" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "retro",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=effects.luau, failing.luau\n" },
            .{ "a.frag", "void main() {}" },
            .{ "broken.frag", "broken" },
            .{
                "effects.luau",
                \\local post = require("openreliant.postprocessing")
                \\assert(post.register({ name = "late", shader = "a.frag", stage = "after_hud" }) == "retro:late")
                \\post.register({ name = "second", shader = "a.frag", order = 5, parameters = { 1, 2 } })
                \\post.register({ name = "first", shader = "a.frag", order = -1 })
                \\post.register({ name = "off", shader = "a.frag", enabled = false })
                \\local ok, message = pcall(post.register, { name = "late", shader = "a.frag" })
                \\assert(not ok and string.find(message, "registered already", 1, true), message)
                \\ok, message = pcall(post.register, { name = "bad", shader = "broken.frag" })
                \\assert(not ok and string.find(message, "broken.frag:2", 1, true), message)
                \\ok, message = pcall(post.register, { name = "gone", shader = "missing.frag" })
                \\assert(not ok and string.find(message, "no file missing.frag", 1, true), message)
                \\ok, message = pcall(post.register, { name = "no good", shader = "a.frag" })
                \\assert(not ok and string.find(message, "identifier", 1, true), message)
                \\assert(post.set_parameters("retro:first", { 0.5 }) and post.set_enabled("off", true))
                \\assert(not post.set_enabled("nothing", true))
            },
            .{
                "failing.luau",
                \\require("openreliant.postprocessing").register({ name = "rolled_back", shader = "a.frag" })
                \\error("this script fails to load")
            },
        },
    }});
    defer fixture.deinit();
    var host: postprocessing.testing.Host = .{};
    defer host.deinit();
    fixture.shown.setEffectHost(host.effectHost());
    defer fixture.shown.setEffectHost(null);
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    // The failing script's effect was taken back as it failed to load.
    try std.testing.expectEqual(5, host.added);
    try std.testing.expectEqualSlices(u32, &.{4}, host.removed.items);
    // Before the display by order (first, then off, which was turned on, then second), then after
    // it.
    var buffer: [postprocessing.max_effects]postprocessing.Pass = undefined;
    const passes = fixture.shown.effectPasses(&buffer);
    try std.testing.expectEqual(4, passes.len);
    const expected = [_]struct { u32, postprocessing.Stage }{ .{ 2, .before_hud }, .{ 3, .before_hud }, .{ 1, .before_hud }, .{ 0, .after_hud } };
    for (expected, passes) |want, pass| {
        try std.testing.expectEqual(want[0], pass.effect);
        try std.testing.expectEqual(want[1], pass.stage);
    }
    try std.testing.expectEqual([4]f32{ 0.5, 0, 0, 0 }, passes[0].parameters);
    try std.testing.expectEqual([4]f32{ 1, 2, 0, 0 }, passes[2].parameters);
    // The game's end stops the player scripts, and their effects go.
    fixture.shown.endGame();
    try std.testing.expectEqual(0, fixture.shown.effectPasses(&buffer).len);
    try std.testing.expectEqual(5, host.removed.items.len);
}

test "without a host, effects register and draw nothing" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "retro", &.{
        .{ "mod.ini", "[Scripts]\nPlayer=effects.luau\n" },
        .{ "a.frag", "void main() {}" },
        .{ "effects.luau", "assert(require('openreliant.postprocessing').register({ name = 'crt', shader = 'a.frag' }) == 'retro:crt')" },
    } }});
    defer fixture.deinit();
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    var buffer: [postprocessing.max_effects]postprocessing.Pass = undefined;
    try std.testing.expectEqual(0, fixture.shown.effectPasses(&buffer).len);
}

test "the CRT example registers its effect, and Shift F8 and Shift F7 change it" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "crt", &.{
        .{ "mod.ini", @embedFile("crt/mod.ini") },
        .{ "crt.luau", @embedFile("crt/crt.luau") },
        .{ "crt.frag", @embedFile("crt/crt.frag") },
    } }});
    defer fixture.deinit();
    var host: postprocessing.testing.Host = .{};
    defer host.deinit();
    fixture.shown.setEffectHost(host.effectHost());
    defer fixture.shown.setEffectHost(null);
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    fixture.frame(0.016, .{ 800, 600 });
    var buffer: [postprocessing.max_effects]postprocessing.Pass = undefined;
    var passes = fixture.shown.effectPasses(&buffer);
    try std.testing.expectEqual(1, passes.len);
    try std.testing.expectEqual(.after_hud, passes[0].stage);
    try std.testing.expectEqual(0.3, passes[0].parameters[0]);
    // Shift F7 steps the scanlines on; Shift F8 turns the effect off.
    fixture.devices.keyboard.down[@backingInt(input.Key.left_shift)] = true;
    fixture.shown.key(.f7, true);
    passes = fixture.shown.effectPasses(&buffer);
    try std.testing.expectEqual(0.5, passes[0].parameters[0]);
    fixture.shown.key(.f8, true);
    try std.testing.expectEqual(0, fixture.shown.effectPasses(&buffer).len);
}

test "player scripts register surface and lighting functions, which the host draws and objects take" {
    const gpa = std.testing.allocator;
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "cel",
        &.{
            .{ "mod.ini", "[Scripts]\nPlayer=cel.luau, failing.luau\n" },
            .{ "bands.glsl", "float lighting(float cosine, vec4 parameters) { return cosine; }" },
            .{ "ink.glsl", "// Ink.\n#include \"edges.glsl\"\nvoid surface(inout Surface s, vec4 parameters, float time) {}" },
            .{ "edges.glsl", "float edge(float x) { return x; }\n" },
            .{ "lost.glsl", "#include \"nowhere.glsl\"\n" },
            .{ "broken.glsl", "broken" },
            .{
                "cel.luau",
                \\local shaders = require("openreliant.shaders")
                \\assert(shaders.register_lighting({ name = "bands", shader = "bands.glsl", parameters = { 3 } }) == "cel:bands")
                \\shaders.register_surface({ name = "ink", shader = "ink.glsl", textures = { "hull.tga" }, everywhere = true, parameters = { 2, 8 }, bloom = 0.25 })
                \\local ok, message = pcall(shaders.register_surface, { name = "ink", shader = "ink.glsl" })
                \\assert(not ok and string.find(message, "registered already", 1, true), message)
                \\ok, message = pcall(shaders.register_surface, { name = "glare", shader = "ink.glsl", bloom = 2 })
                \\assert(not ok and string.find(message, "bloom must be from 0 to 1", 1, true), message)
                \\ok, message = pcall(shaders.register_surface, { name = "bad", shader = "broken.glsl" })
                \\assert(not ok and string.find(message, "broken.glsl:2", 1, true), message)
                \\ok, message = pcall(shaders.register_lighting, { name = "gone", shader = "missing.glsl" })
                \\assert(not ok and string.find(message, "no file missing.glsl", 1, true), message)
                \\ok, message = pcall(shaders.register_surface, { name = "lost", shader = "lost.glsl" })
                \\assert(not ok and string.find(message, "cel/lost.glsl:1: the mod cel has no file nowhere.glsl", 1, true), message)
                \\assert(shaders.set_parameters("ink", { 4 }) and shaders.set_enabled("cel:bands", false))
                \\assert(not shaders.set_enabled("nothing", true))
                \\local player = require("openreliant.self")
                \\assert(player:set_surface("ink", { 1, 2 }))
                \\assert(not player:set_surface("nothing"))
                \\ok, message = pcall(player.set_surface, player, "bands")
                \\assert(not ok and string.find(message, "lighting function", 1, true), message)
            },
            .{
                "failing.luau",
                \\require("openreliant.shaders").register_surface({ name = "rolled_back", shader = "ink.glsl" })
                \\error("this script fails to load")
            },
        },
    }});
    defer fixture.deinit();
    // The player's ship has a model of two parts, which take the surface function.
    var model: engine.game.objects.testing.Parts(2) = undefined;
    model.init();
    try model.fit(gpa, fixture.mission.slot(0));
    var host: shaders.testing.Host = .{};
    defer host.deinit();
    fixture.shown.setShaderHost(host.shaderHost());
    defer fixture.shown.setShaderHost(null);
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    // The failing script's function was taken back as it failed to load.
    try std.testing.expectEqual(3, host.added);
    try std.testing.expectEqualSlices(u16, &.{3}, host.removed.items);
    // ink.glsl came to the host cut where it includes edges.glsl.
    try std.testing.expectEqual(3, host.parts);
    // The host draws both, the lighting function turned off, the surface function's parameters
    // changed.
    try std.testing.expectEqual(2, host.drawn.items.len);
    const bands = host.drawn.items[0];
    try std.testing.expect(bands.kind == .lighting and bands.function == 1 and !bands.enabled);
    const ink = host.drawn.items[1];
    try std.testing.expect(ink.kind == .surface and ink.enabled and ink.everywhere);
    try std.testing.expectEqual([4]f32{ 4, 0, 0, 0 }, ink.parameters);
    try std.testing.expectEqual(0.25, ink.bloom);
    try std.testing.expectEqualStrings("hull.tga", ink.textures[0]);
    // The function the script gave the player's ship goes on its parts only as a drawn frame's
    // copy of the objects is dressed (`dressObjects`), here the test's own objects, with the
    // function's share of bloom.
    const ship = fixture.mission.slot(0);
    for (ship.model.?.parts) |part| try std.testing.expectEqual(null, part.object.surface);
    fixture.shown.dressObjects(fixture.mission.objects);
    for (ship.model.?.parts) |part| {
        try std.testing.expectEqual(srtexture.ModSurface{ .function = 2, .parameters = .{ 1, 2, 0, 0 }, .bloom = 0.25 }, part.object.surface.?);
    }
    // The object that takes the slot next doesn't get it.
    const shaders_registry = &fixture.shown.runtime.mod_shaders;
    fixture.mission.objects.reuses[0] +%= 1;
    fixture.shown.dressObjects(fixture.mission.objects);
    try std.testing.expectEqual(null, shaders_registry.given[0]);
    fixture.mission.objects.reuses[0] -%= 1;
    // A planet's atmosphere finds a surface function by its qualified name, but no lighting
    // function and no name no mod registered.
    const names = fixture.shown.surfaceNames();
    try std.testing.expectEqual(srtexture.ModSurface{ .function = 2, .bloom = 0.25 }, names.find(names.context, "cel:ink").?);
    try std.testing.expectEqual(null, names.find(names.context, "cel:bands"));
    try std.testing.expectEqual(null, names.find(names.context, "cel:nothing"));
    // The game's end stops the player scripts, and their functions go, as do those they gave the
    // objects.
    shaders_registry.given[0] = .{ .reuse = 0, .surface = .{ .function = 2 } };
    fixture.shown.endGame();
    try std.testing.expectEqual(null, shaders_registry.given[0]);
    try std.testing.expectEqual(0, host.drawn.items.len);
    try std.testing.expectEqualSlices(u16, &.{ 3, 1, 2 }, host.removed.items);
}

test "the cel-shading example registers its functions, and Shift F6 and Shift F5 change them" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "cel-shading", &.{
        .{ "mod.ini", @embedFile("cel-shading/mod.ini") },
        .{ "cel.luau", @embedFile("cel-shading/cel.luau") },
        .{ "bands.glsl", @embedFile("cel-shading/bands.glsl") },
        .{ "ink.glsl", @embedFile("cel-shading/ink.glsl") },
    } }});
    defer fixture.deinit();
    var host: shaders.testing.Host = .{};
    defer host.deinit();
    fixture.shown.setShaderHost(host.shaderHost());
    defer fixture.shown.setShaderHost(null);
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    fixture.frame(0.016, .{ 800, 600 });
    try std.testing.expectEqual(2, host.drawn.items.len);
    try std.testing.expectEqual(3, host.drawn.items[0].parameters[0]);
    try std.testing.expect(host.drawn.items[1].everywhere and host.drawn.items[1].enabled);
    // Shift F5 steps to four bands; Shift F6 turns both off.
    fixture.devices.keyboard.down[@backingInt(input.Key.left_shift)] = true;
    fixture.shown.key(.f5, true);
    try std.testing.expectEqual(4, host.drawn.items[0].parameters[0]);
    fixture.shown.key(.f6, true);
    for (host.drawn.items) |function| try std.testing.expect(!function.enabled);
}

test "menu scripts register game modes as OpenReliant starts, and player scripts read the one that runs" {
    const gpa = std.testing.allocator;
    var modes: game_modes.Registry = .init(gpa, null);
    defer modes.deinit();
    var fixture: Fixture = undefined;
    try fixture.initShared(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nMenu=menu.luau\nPlayer=player.luau\n" },
            .{
                "menu.luau",
                \\local core = require("openreliant.core")
                \\assert(core.register_game_mode({ name = "arena", label = "ARENA", missions = { 29, 30 }, ship = "phoenix", loop = true }) == "a:arena")
                \\local ok, message = pcall(core.register_game_mode, { name = "arena", label = "AGAIN", missions = { 1 } })
                \\assert(not ok and string.find(message, "registered already", 1, true), message)
                \\ok, message = pcall(core.register_game_mode, { name = "empty", label = "EMPTY", missions = {} })
                \\assert(not ok and string.find(message, "needs missions", 1, true), message)
                \\ok, message = pcall(core.register_game_mode, { name = "tour", label = "TOUR", missions = { 1 }, loop = true, campaign = true })
                \\assert(not ok and string.find(message, "can't loop", 1, true), message)
                \\ok, message = pcall(core.register_game_mode, { name = "own", label = "OWN", missions = { 1 }, records = "missing.luau" })
                \\assert(not ok and string.find(message, "has no script missing.luau", 1, true), message)
                \\assert(core.register_game_mode({ name = "own", label = "OWN", records = "PLAYER", briefing_room = "yamato", wing_pilots = { "none", "ronin_leader" },
                \\    missions = { 90, { number = 91, as = 1, objectives = { "Patrol", "Caf\u{e9}" }, hologram = "own_m01.bik" } } }) == "a:own")
                \\assert(core.game_mode == nil and core.game_mode_mission == nil)
            },
            .{
                "player.luau",
                \\local core = require("openreliant.core")
                \\assert(core.game_mode == "a:arena", tostring(core.game_mode))
                \\local mission = core.game_mode_mission
                \\assert(mission.number == 29 and mission.place == 1 and mission.count == 2)
                \\local ok, message = pcall(core.register_game_mode, { name = "late", label = "LATE", missions = { 1 } })
                \\assert(not ok and string.find(message, "player scripts can't register", 1, true), message)
            },
        },
    }}, .{ .modes = &modes });
    defer fixture.deinit();
    modes.close();
    try std.testing.expectEqual(2, modes.modes.items.len);
    // The records script is found whatever its case, without its extension.
    const own = modes.modes.items[1];
    try std.testing.expectEqualStrings("player.luau", own.records.?);
    // A mission given as a number, and one given as a table, flown as mission 1 and naming two of
    // its objectives in the game's code page.
    try std.testing.expectEqual(game_modes.Entry{ .file = 90, .number = 90 }, own.missions[0]);
    try std.testing.expectEqual(91, own.missions[1].file);
    try std.testing.expectEqual(1, own.missions[1].number);
    const names = own.missions[1].objectives.?;
    try std.testing.expectEqualStrings("Patrol", names[0].?);
    try std.testing.expectEqualStrings("Caf\xe9", names[1].?);
    try std.testing.expectEqual(null, names[2]);
    // Briefed in the Yamato's briefing room, with the mod's movie, and Enriquez silent; Alpha 3 is
    // the Ronin wing's leader.
    try std.testing.expectEqual(.yamato, own.briefing_room.?);
    try std.testing.expectEqualSlices(engine.game.pilots.Number, &.{ .none, .named(.ronin_leader) }, own.wing_pilots.?);
    try std.testing.expectEqualStrings("own_m01.bik", own.missions[1].hologram.?);
    try std.testing.expectEqual(null, own.missions[1].last_word);
    const arena = modes.modes.items[0];
    try std.testing.expectEqualStrings("a:arena", arena.name);
    try std.testing.expectEqualDeep(&[_]game_modes.Entry{ .{ .file = 29, .number = 29 }, .{ .file = 30, .number = 30 } }, arena.missions);
    try std.testing.expectEqual(engine.game.gameobj.Type.of(.phoenix), arena.ship.?);
    try std.testing.expectEqual(.loop, arena.kind);
    try std.testing.expectEqualStrings("ARENA", modes.shown.items[0].label);
    try std.testing.expectEqual(2, modes.shown.items[0].missions);
    // The player scripts start knowing the mode; their own asserts would have failed them.
    modes.start(0);
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    try std.testing.expect(fixture.shown.runtime.contexts.items.len > 0);
    for (fixture.shown.runtime.contexts.items) |context| try std.testing.expect(!context.closed);
}

test "the arena example registers its game mode, and its board runs within it" {
    const gpa = std.testing.allocator;
    var storage: @import("storage.zig").Storage = .{ .gpa = gpa };
    defer storage.deinit();
    var modes: game_modes.Registry = .init(gpa, null);
    defer modes.deinit();
    var fixture: Fixture = undefined;
    try fixture.initShared(&.{.{ "arena", &.{
        .{ "mod.ini", @embedFile("arena/mod.ini") },
        .{ "menu.luau", @embedFile("arena/menu.luau") },
        .{ "board.luau", @embedFile("arena/board.luau") },
    } }}, .{ .storage = &storage, .modes = &modes });
    defer fixture.deinit();
    try std.testing.expectEqualStrings("arena:arena", modes.modes.items[0].name);
    try std.testing.expectEqualDeep(&[_]game_modes.Entry{.{ .file = 29, .number = 29 }}, modes.modes.items[0].missions);
    try std.testing.expectEqual(engine.game.gameobj.Type.of(.phoenix), modes.modes.items[0].ship.?);
    modes.start(0);
    try fixture.shown.startGame(null, fixture.mission.objects, false);
    fixture.frame(0.016, .{ 800, 600 });
    for (fixture.shown.runtime.contexts.items) |context| try std.testing.expect(!context.closed);
}

test "a menu script's screen stands in for the front end's own, and asks it to go on" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{
        "a",
        &.{
            .{ "mod.ini", "[Scripts]\nMenu=menu.luau\n" },
            .{
                "menu.luau",
                \\local ui = require("openreliant.ui")
                \\local frames = 0
                \\local screen = ui.register_screen("main", { frame = function()
                \\    frames += 1
                \\    if frames == 2 then ui.go_to("pilot_roster") end
                \\end })
                \\assert(ui.replace_screen("main_menu", screen))
                \\assert(not ui.replace_screen("game_options", "nothing"))
                \\assert(ui.pointer == nil)
            },
        },
    }});
    defer fixture.deinit();
    const scripted = fixture.shown.scripted();
    try std.testing.expect(scripted.vtable.replaces(scripted.context, .main_menu));
    try std.testing.expect(!scripted.vtable.replaces(scripted.context, .game_options));
    scripted.vtable.show(scripted.context, .main_menu);
    try std.testing.expect(fixture.shown.runtime.registries.selected_screen != null);
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(null, scripted.vtable.take(scripted.context));
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(interf.Request{ .go = .pilot_roster }, scripted.vtable.take(scripted.context).?);
    try std.testing.expectEqual(null, scripted.vtable.take(scripted.context));
    scripted.vtable.show(scripted.context, null);
    try std.testing.expectEqual(null, fixture.shown.runtime.registries.selected_screen);
}

test "the main menu example stands in for the game's" {
    var fixture: Fixture = undefined;
    try fixture.init(&.{.{ "main-menu", &.{
        .{ "mod.ini", @embedFile("main-menu/mod.ini") },
        .{ "menu.luau", @embedFile("main-menu/menu.luau") },
    } }});
    defer fixture.deinit();
    const scripted = fixture.shown.scripted();
    try std.testing.expect(scripted.vtable.replaces(scripted.context, .main_menu));
    scripted.vtable.show(scripted.context, .main_menu);
    fixture.frame(0.016, .{ 640, 480 });
    // Down twice and Enter choose OPTIONS.
    for ([_]input.Key{ .down, .down, .enter }) |key| {
        fixture.shown.key(key, true);
        fixture.shown.key(key, false);
    }
    try std.testing.expectEqual(interf.Request{ .go = .game_options }, scripted.vtable.take(scripted.context).?);
}

test "the CD player pages example turns the CD player's pages" {
    const gpa = std.testing.allocator;
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    // The front end's set, with a shape in each block up to the arrows' lit halves.
    const sprite = try openreliant.spr.testing.paletteAndShapes(gpa, 0x31);
    defer gpa.free(sprite);
    try openreliant.hog.testing.write(gpa, io, tmp.dir, "resource.hog", &.{.{ .name = "frntend5.spr", .data = sprite }});
    var archive: engine.game.bigfile.Hog = try .open(gpa, io, tmp.dir, "resource.hog");
    defer archive.close(gpa);
    var fixture: Fixture = undefined;
    try fixture.initShared(&.{.{ "cd-player-pages", &.{
        .{ "mod.ini", @embedFile("cd-player-pages/mod.ini") },
        .{ "pages.luau", @embedFile("cd-player-pages/pages.luau") },
    } }}, .{ .files = archive });
    defer fixture.deinit();
    const shown = fixture.shown;
    const layer = shown.layers.getPtr(.ui);
    // As the player walks the rooms, it draws nothing.
    fixture.rooms = .{ .carrier = .reliant, .view = 5 };
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(0, layer.commands.items.len);
    // The Reliant's CD player opens: it turns to its own page, to number its rows as the pages
    // do, and shows the arrows and the first of two pages.
    fixture.rooms = .{ .carrier = .reliant, .view = 5, .place = .cd_player, .cd_player_page = 0 };
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(0, shown.takeCdPlayerPage().?);
    try std.testing.expectEqual(2, layer.commands.items.len);
    try std.testing.expectEqualStrings("1/2", layer.text.items);
    // Page Down asks for the second page, the Yamato's list.
    shown.key(.page_down, true);
    shown.key(.page_down, false);
    try std.testing.expectEqual(1, shown.takeCdPlayerPage().?);
    // A press on the left arrow, lit under the pointer, turns back round to the last page. The
    // window gives the pointer's place as fractions of its size, which is the screen's here.
    fixture.devices.mouse.at = .{ 515.0 / 640.0, 425.0 / 480.0 };
    fixture.devices.mouse.buttons.left = true;
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(1, shown.takeCdPlayerPage().?);
    try std.testing.expectEqual(3, layer.commands.items.len);
    try std.testing.expectEqualStrings("2/2", layer.text.items);
    // Held, it turns no further.
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(null, shown.takeCdPlayerPage());
}

test "the campaign example briefs each of its missions, and plays its movie first" {
    const gpa = std.testing.allocator;
    var storage: @import("storage.zig").Storage = .{ .gpa = gpa };
    defer storage.deinit();
    var modes: game_modes.Registry = .init(gpa, &storage);
    defer modes.deinit();
    var fixture: Fixture = undefined;
    try fixture.initShared(&.{.{ "campaign", &.{
        .{ "mod.ini", @embedFile("campaign/mod.ini") },
        .{ "menu.luau", @embedFile("campaign/menu.luau") },
    } }}, .{ .storage = &storage, .modes = &modes });
    defer fixture.deinit();
    modes.close();
    const tour = modes.modes.items[0];
    try std.testing.expectEqualStrings("campaign:first_tour", tour.name);
    try std.testing.expectEqual(.campaign, tour.kind);
    try std.testing.expectEqualDeep(&[_]game_modes.Entry{ .{ .file = 1, .number = 1 }, .{ .file = 2, .number = 2 }, .{ .file = 3, .number = 3 } }, tour.missions);
    // Its briefing stands in for the mode's briefing only while the mode runs.
    const scripted = fixture.shown.scripted();
    try std.testing.expect(!scripted.vtable.replaces(scripted.context, .mode_briefing));
    modes.start(0);
    try std.testing.expect(scripted.vtable.replaces(scripted.context, .mode_briefing));
    scripted.vtable.show(scripted.context, .mode_briefing);
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqualStrings("thread01.bik", fixture.shown.takeMovie().?);
    try std.testing.expectEqual(null, fixture.shown.takeMovie());
    // Enter launches the mission.
    fixture.shown.key(.enter, true);
    fixture.shown.key(.enter, false);
    try std.testing.expectEqual(interf.Request.launch_mission, scripted.vtable.take(scripted.context).?);
    // The next mission's briefing plays no movie, and Escape leaves for the main menu.
    _ = modes.goesOn(.playing, .success);
    fixture.frame(0.016, .{ 640, 480 });
    try std.testing.expectEqual(null, fixture.shown.takeMovie());
    fixture.shown.key(.escape, true);
    try std.testing.expectEqual(interf.Request{ .go = .main_menu }, scripted.vtable.take(scripted.context).?);
    fixture.shown.key(.escape, false);
    // After its last mission, its ending, which a key leaves for the main menu.
    try std.testing.expectEqualStrings("campaign:ending", tour.ending.?);
    try std.testing.expect(scripted.vtable.replaces(scripted.context, .mode_ending));
    scripted.vtable.show(scripted.context, .mode_ending);
    fixture.frame(0.016, .{ 640, 480 });
    fixture.shown.key(.enter, true);
    try std.testing.expectEqual(interf.Request{ .go = .main_menu }, scripted.vtable.take(scripted.context).?);
    for (fixture.shown.runtime.contexts.items) |context| try std.testing.expect(!context.closed);
}