524 lines
23 KiB
TypeScript
524 lines
23 KiB
TypeScript
/**
|
|
* The scene's macros on the wire: the header fields, the reader, and the fake sim that produces
|
|
* them (`docs/design/macros.md` sections 6 and 12).
|
|
*
|
|
* What is being pinned here is mostly what *stays* true when the fields are absent or wrong,
|
|
* because the page these feed is a broadcast that runs for weeks: a raw-mode producer, an older
|
|
* producer with none of the five fields, and a producer that contradicts itself all have to leave
|
|
* the display with six rows and nothing lit.
|
|
*/
|
|
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import test from 'node:test';
|
|
import { fileURLToPath } from 'node:url';
|
|
import Ajv2020 from 'ajv/dist/2020.js';
|
|
|
|
import { decodeSnapshot, encodeSnapshot } from '../src/codec';
|
|
import { paletteView } from '../src/palette';
|
|
import {
|
|
MACRO_CHANNELS,
|
|
MACRO_SLOTS,
|
|
MACRO_TYPES,
|
|
macroChannel,
|
|
macroRateRole,
|
|
macroTypeIndex,
|
|
type FeedHeader,
|
|
type MacroOutcomeKind,
|
|
} from '../src/types';
|
|
import {
|
|
FAKE_CENTER_OVERWORLD,
|
|
FAKE_DIALOG_CHOICE,
|
|
FAKE_INDOOR_OVERWORLD,
|
|
FAKE_MACRO_TABLE,
|
|
MACRO_FRAME_CAP_MS,
|
|
} from '../src/fake/palette';
|
|
import { FakeFlysim } from '../src/fake/simulator';
|
|
|
|
const here = fileURLToPath(new URL('.', import.meta.url));
|
|
const schema = JSON.parse(readFileSync(join(here, '../src/schema.json'), 'utf8')) as object;
|
|
const validate = new Ajv2020({ strict: true }).compile(schema);
|
|
|
|
/** A minimal macros-mode header, hand-built so the shape is visible in the test. */
|
|
function macroHeader(): FeedHeader {
|
|
return {
|
|
protocol: 1,
|
|
seq: 7,
|
|
wallMs: 1_700_000_000_000,
|
|
status: 'running',
|
|
realtimeFactor: 1,
|
|
uptimeSeconds: 12,
|
|
runSeconds: 12,
|
|
brainMs: 12_000,
|
|
frame: 360,
|
|
buttons: 1,
|
|
rates: { command_0: 42, macro_go_out: 31 },
|
|
populationRate: 13,
|
|
spikeCount: 0,
|
|
learning: { enabled: true, updates: 1, changed: 0, synapses: 4_200_000, signal: 0 },
|
|
game: {
|
|
mode: 'OVERWORLD',
|
|
semanticRewards: true,
|
|
map: 1,
|
|
badges: 0,
|
|
uniqueLocations: 3,
|
|
rewardTotal: 0.1,
|
|
rewardCounts: { story: 0, explore: 1, area: 0, pokedex: 0, trainer: 0, wildwin: 0, badge: 0 },
|
|
scene: 'overworld',
|
|
macroMode: 'macros',
|
|
palette: [
|
|
{ slot: 0, name: 'GO OUT', gloss: 'leave here', channel: 'MB·OUT' },
|
|
{ slot: 1, name: 'TALK', gloss: 'press A', channel: 'MB·TALK' },
|
|
],
|
|
macro: { slot: 0, name: 'GO OUT', sinceMs: 420 },
|
|
macroOutcome: { slot: 1, name: 'TALK', outcome: 'done', atMs: 11_000 },
|
|
},
|
|
milestone: { rank: 2, label: 'Left the house', next: 'Reached Pallet Town', sinceSeconds: 30, attempts: 0 },
|
|
sugar: { active: false, remainingMs: 0, cooldownMs: 0, lastBy: null, todayCount: 0 },
|
|
events: [
|
|
{ id: 9, wallMs: 1_700_000_000_000, brainMs: 11_580, kind: 'macro', label: 'GO OUT start', value: 0 },
|
|
{ id: 8, wallMs: 1_699_999_999_000, brainMs: 11_000, kind: 'macro', label: 'TALK done', value: 1 },
|
|
],
|
|
attachments: [],
|
|
};
|
|
}
|
|
|
|
test('a macros-mode header round trips through the codec and validates', () => {
|
|
const header = macroHeader();
|
|
const decoded = decodeSnapshot(encodeSnapshot(header, {}));
|
|
|
|
assert.deepEqual(decoded.header, header);
|
|
assert.ok(validate(header), `macros header failed the schema: ${JSON.stringify(validate.errors)}`);
|
|
});
|
|
|
|
test('the 31 types and their channels are one table, in the contract\'s order', () => {
|
|
// Sections 12, 13 and 14's list, which is also the order a display lays the cells out in and,
|
|
// since section 14, the `slot` index itself.
|
|
assert.equal(MACRO_TYPES.length, 31);
|
|
assert.equal(MACRO_TYPES.length, MACRO_SLOTS, 'a slot per type');
|
|
assert.equal(MACRO_CHANNELS.length, MACRO_TYPES.length);
|
|
assert.deepEqual(MACRO_TYPES.slice(0, 3), ['GO OBJECTIVE', 'GO OUT', 'GO WARP']);
|
|
assert.deepEqual(MACRO_CHANNELS.slice(0, 3), ['MB·GOAL', 'MB·OUT', 'MB·WARP']);
|
|
assert.equal(MACRO_TYPES.at(-1), 'LEAVE');
|
|
assert.equal(MACRO_CHANNELS.at(-1), 'MB·LEAVE');
|
|
|
|
for (const [index, name] of MACRO_TYPES.entries()) {
|
|
assert.equal(macroTypeIndex(name), index, `${name} is not at ${index}`);
|
|
assert.equal(macroChannel(name), MACRO_CHANNELS[index]);
|
|
// A tag has to fit a cell glyph and a bar label, and it is written with an interpunct.
|
|
assert.ok((MACRO_CHANNELS[index] as string).length <= 8, `${MACRO_CHANNELS[index]} is too long for a cell`);
|
|
assert.match(MACRO_CHANNELS[index] as string, /^MB·[A-Z0-9]+$/);
|
|
}
|
|
assert.equal(new Set(MACRO_CHANNELS).size, MACRO_CHANNELS.length, 'two types share a channel');
|
|
assert.equal(macroTypeIndex('SOMERSAULT'), -1);
|
|
assert.equal(macroChannel('SOMERSAULT'), '');
|
|
});
|
|
|
|
test('a type\'s rate role is its name lowercased, spaces to underscores', () => {
|
|
// The rule the page finds a bound macro's rate in `brain.rates` by, and the rule the dataset
|
|
// generated the roles with (`tools/build_flywire.py`).
|
|
assert.equal(macroRateRole('GO OUT'), 'macro_go_out');
|
|
assert.equal(macroRateRole('BUY POTION'), 'macro_buy_potion');
|
|
assert.equal(macroRateRole('MOVE 1'), 'macro_move_1');
|
|
assert.equal(macroRateRole('THROW BALL'), 'macro_throw_ball');
|
|
const roles = MACRO_TYPES.map(macroRateRole);
|
|
assert.equal(new Set(roles).size, roles.length, 'two types share a rate role');
|
|
for (const role of roles) assert.match(role, /^macro_[a-z0-9_]+$/);
|
|
});
|
|
|
|
test('the five macro fields are optional, so an older producer and every old fixture stay valid', () => {
|
|
const header = macroHeader();
|
|
const { scene, macroMode, palette, macro, macroOutcome, ...game } = header.game;
|
|
void scene;
|
|
void macroMode;
|
|
void palette;
|
|
void macro;
|
|
void macroOutcome;
|
|
|
|
const older: FeedHeader = { ...header, game, events: [] };
|
|
assert.ok(validate(older), `a header without the macro fields failed: ${JSON.stringify(validate.errors)}`);
|
|
|
|
// And the reader is total over it: one row per type, nothing bound, nothing running, raw mode.
|
|
// Section 14: a dim cell still carries its type's tag, because the strip draws every button.
|
|
const view = paletteView(older);
|
|
assert.equal(view.mode, 'raw');
|
|
assert.equal(view.supported, false);
|
|
assert.equal(view.cells.length, MACRO_SLOTS);
|
|
assert.deepEqual(
|
|
view.cells.map((cell) => cell.row),
|
|
MACRO_TYPES.map((_, index) => index),
|
|
);
|
|
assert.ok(
|
|
view.cells.every((cell) => cell.entry === null),
|
|
'nothing is bound',
|
|
);
|
|
assert.deepEqual(
|
|
view.cells.map((cell) => cell.channel),
|
|
[...MACRO_CHANNELS],
|
|
);
|
|
assert.equal(view.macro, null);
|
|
assert.equal(view.outcome, null);
|
|
});
|
|
|
|
test('the schema refuses macros the display could not draw', () => {
|
|
const header = macroHeader();
|
|
const bad: unknown[] = [
|
|
{ slot: MACRO_SLOTS, name: 'GO OUT', gloss: 'leave here', channel: 'MB·OUT' },
|
|
{ slot: -1, name: 'GO OUT', gloss: 'leave here', channel: 'MB·OUT' },
|
|
{ slot: 1.5, name: 'GO OUT', gloss: 'leave here', channel: 'MB·OUT' },
|
|
{ slot: 0, name: '', gloss: 'leave here', channel: 'MB·OUT' },
|
|
{ slot: 0, name: 'A NAME THAT IS FAR TOO LONG', gloss: '', channel: 'MB·OUT' },
|
|
{ slot: 0, name: 'GO OUT', channel: 'MB·OUT' },
|
|
// The channel is not optional: a cell with no tag has no glyph to draw.
|
|
{ slot: 0, name: 'GO OUT', gloss: 'leave here' },
|
|
{ slot: 0, name: 'GO OUT', gloss: 'leave here', channel: '' },
|
|
{ slot: 0, name: 'GO OUT', gloss: 'leave here', channel: 'MB·OUT', extra: 1 },
|
|
];
|
|
for (const entry of bad) {
|
|
assert.equal(
|
|
validate({ ...header, game: { ...header.game, palette: [entry] } }),
|
|
false,
|
|
`schema accepted ${JSON.stringify(entry)}`,
|
|
);
|
|
}
|
|
|
|
// One entry past the type list cannot happen: the wire carries a slot per type and no more.
|
|
const overflow = Array.from({ length: MACRO_SLOTS + 1 }, (_, slot) => ({
|
|
slot: slot % MACRO_SLOTS,
|
|
name: 'NEXT',
|
|
gloss: 'advance it',
|
|
channel: 'MB·NEXT',
|
|
}));
|
|
assert.equal(validate({ ...header, game: { ...header.game, palette: overflow } }), false);
|
|
|
|
for (const outcome of ['ok', 'aborted', '', null]) {
|
|
assert.equal(
|
|
validate({ ...header, game: { ...header.game, macroOutcome: { slot: 0, name: 'GO OUT', outcome, atMs: 1 } } }),
|
|
false,
|
|
`schema accepted outcome ${JSON.stringify(outcome)}`,
|
|
);
|
|
}
|
|
for (const scene of ['battle_switch', 'Overworld', 'fishing']) {
|
|
assert.equal(validate({ ...header, game: { ...header.game, scene } }), false, `schema accepted scene ${scene}`);
|
|
}
|
|
// The two modes section 12 removed are not modes any more.
|
|
for (const mode of ['palette', 'plan']) {
|
|
assert.equal(validate({ ...header, game: { ...header.game, macroMode: mode } }), false, `schema accepted ${mode}`);
|
|
}
|
|
});
|
|
|
|
test('the reader ignores macros sent in raw mode, so the screen and the mode cannot disagree', () => {
|
|
const header = macroHeader();
|
|
const view = paletteView({ ...header, game: { ...header.game, macroMode: 'raw' } });
|
|
|
|
assert.equal(view.mode, 'raw');
|
|
assert.equal(view.supported, true, 'the producer does carry the fields');
|
|
assert.ok(view.cells.every((cell) => cell.entry === null), 'nothing is drawn as bound');
|
|
assert.equal(view.macro, null);
|
|
assert.equal(view.outcome, null);
|
|
});
|
|
|
|
test('the rows are the scene\'s macros in type order, whatever order they arrived in', () => {
|
|
// The screen's cell order is the contract's type order (section 12), so a macro is in the same
|
|
// place in every scene that binds it — which is the whole point of a channel per type.
|
|
const view = paletteView({
|
|
game: {
|
|
...macroHeader().game,
|
|
palette: [
|
|
{ slot: 0, name: 'MENU', gloss: 'open menu', channel: 'MB·MENU' },
|
|
{ slot: 1, name: 'GO ITEM', gloss: 'an object', channel: 'MB·ITEM' },
|
|
{ slot: 2, name: 'GO OUT', gloss: 'leave here', channel: 'MB·OUT' },
|
|
],
|
|
},
|
|
});
|
|
// Section 14: a cell per type, at its own index, lit when bound and dim when not.
|
|
const bound = view.cells.filter((cell) => cell.entry !== null);
|
|
assert.deepEqual(
|
|
bound.map((cell) => cell.entry?.name),
|
|
['GO OUT', 'GO ITEM', 'MENU'],
|
|
);
|
|
assert.deepEqual(
|
|
bound.map((cell) => cell.row),
|
|
[macroTypeIndex('GO OUT'), macroTypeIndex('GO ITEM'), macroTypeIndex('MENU')],
|
|
);
|
|
// Every cell knows its own tag, bound or not, because the strip draws all of them.
|
|
assert.deepEqual(
|
|
view.cells.map((cell) => cell.channel),
|
|
[...MACRO_CHANNELS],
|
|
);
|
|
assert.deepEqual(
|
|
view.cells.map((cell) => cell.type),
|
|
MACRO_TYPES.map((_, index) => index),
|
|
);
|
|
// The wire slot is carried through untouched: it is what `macro` and `macroOutcome` name.
|
|
assert.deepEqual(
|
|
bound.map((cell) => cell.entry?.slot),
|
|
[2, 1, 0],
|
|
);
|
|
});
|
|
|
|
test('the reader drops a duplicate slot, a repeated type and a nameless entry', () => {
|
|
const view = paletteView({
|
|
game: {
|
|
...macroHeader().game,
|
|
palette: [
|
|
{ slot: 1, name: 'GO NPC', gloss: 'a person', channel: 'MB·NPC' },
|
|
{ slot: 1, name: 'SHOULD NOT', gloss: 'win', channel: 'MB·NO' },
|
|
// One population per type, so the same macro cannot be on the pad twice.
|
|
{ slot: 2, name: 'GO NPC', gloss: 'a person', channel: 'MB·NPC' },
|
|
{ slot: 3, name: '', gloss: 'tile ahead', channel: 'MB·ITEM' },
|
|
],
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(
|
|
view.cells.filter((cell) => cell.entry !== null).map((cell) => cell.entry?.name),
|
|
['GO NPC'],
|
|
);
|
|
});
|
|
|
|
test('a missing channel is filled in from the name, and an unknown name still draws', () => {
|
|
const view = paletteView({
|
|
game: {
|
|
...macroHeader().game,
|
|
palette: [
|
|
{ slot: 0, name: 'SOMERSAULT', gloss: 'not a type', channel: 'MB·FLIP' },
|
|
{ slot: 1, name: 'MOVE 2', gloss: 'second' } as never,
|
|
],
|
|
},
|
|
});
|
|
// The tag belongs to the type, so the known name gets its own back, in its own cell...
|
|
const known = view.cells[macroTypeIndex('MOVE 2')];
|
|
assert.equal(known?.entry?.name, 'MOVE 2');
|
|
assert.equal(known?.channel, 'MB·MV2');
|
|
// ...and a name the contract does not have has no cell of its own, so it takes the first free
|
|
// one rather than being dropped, keeping its own tag.
|
|
const unknown = view.cells.find((cell) => cell.entry?.name === 'SOMERSAULT');
|
|
assert.equal(unknown?.channel, 'MB·FLIP');
|
|
assert.equal(unknown?.type, -1);
|
|
});
|
|
|
|
test('an unknown macro mode reads as raw rather than as itself', () => {
|
|
// The page says the mode on air, so a mode it does not know must not be published as one. The
|
|
// two removed modes are unknown modes now.
|
|
for (const mode of ['autopilot', 'palette', 'plan']) {
|
|
const view = paletteView({
|
|
game: {
|
|
...macroHeader().game,
|
|
macroMode: mode as never,
|
|
palette: [{ slot: 0, name: 'GO OUT', gloss: 'leave here', channel: 'MB·OUT' }],
|
|
macro: { slot: 0, name: 'GO OUT', sinceMs: 5 },
|
|
},
|
|
});
|
|
assert.equal(view.mode, 'raw', `${mode} came through as itself`);
|
|
assert.ok(view.cells.every((cell) => cell.entry === null));
|
|
assert.equal(view.macro, null);
|
|
}
|
|
});
|
|
|
|
test('every scene\'s macros are distinct types, inside the cell\'s limits', () => {
|
|
const sets: [string, readonly { name: string; gloss: string }[]][] = [
|
|
...Object.entries(FAKE_MACRO_TABLE),
|
|
['overworld indoors', FAKE_INDOOR_OVERWORLD],
|
|
['overworld in a centre', FAKE_CENTER_OVERWORLD],
|
|
['dialog with a choice', [...(FAKE_MACRO_TABLE.dialog ?? []), ...FAKE_DIALOG_CHOICE]],
|
|
];
|
|
for (const [scene, set] of sets) {
|
|
const names = set.map((cell) => cell.name);
|
|
assert.equal(new Set(names).size, names.length, `${scene} binds a type twice`);
|
|
for (const cell of set) {
|
|
assert.ok(MACRO_TYPES.includes(cell.name), `${scene}: "${cell.name}" is not one of the 31 types`);
|
|
assert.ok(cell.name.length <= 14, `${scene}: "${cell.name}" is longer than 14 characters`);
|
|
// Eleven, not twelve: the longest names are `GO OBJECTIVE` and `BUY ANTIDOTE`, and a row
|
|
// that gives twelve characters of Silkscreen to the name has eleven glyphs of VT323 left
|
|
// for the gloss in section 14's two-column strip (`apps/stage/src/lib/geometry.ts`).
|
|
assert.ok(cell.gloss.length <= 11, `${scene}: gloss "${cell.gloss}" is longer than the cell's column`);
|
|
assert.ok(cell.gloss.length > 0, `${scene}: "${cell.name}" has no gloss`);
|
|
}
|
|
}
|
|
});
|
|
|
|
test('the raw-mode fake claims no scene, no macros and no running macro', () => {
|
|
const sim = new FakeFlysim({ scenario: 'running', seed: 11 });
|
|
for (let i = 0; i < 400; i += 1) {
|
|
const { header } = sim.tick(100);
|
|
assert.ok(validate(header), `raw snapshot ${i} failed the schema: ${JSON.stringify(validate.errors)}`);
|
|
assert.equal(header.game.macroMode, 'raw');
|
|
assert.deepEqual(header.game.palette, []);
|
|
assert.equal(header.game.macro, null);
|
|
assert.equal(header.game.macroOutcome, null);
|
|
// `docs/feed-protocol.md`: the scene is `unknown` in raw mode, because nothing is bound and
|
|
// so no scene is claimed.
|
|
assert.equal(header.game.scene, 'unknown');
|
|
// And `game.mode` does not follow the scene into `UNKNOWN` just because raw mode claims none:
|
|
// it stays the word the fake has always published for a running game.
|
|
assert.equal(header.game.mode, header.status === 'booting' ? 'BOOT' : 'OVERWORLD');
|
|
assert.equal(
|
|
header.events.filter((event) => event.kind === 'macro').length,
|
|
0,
|
|
'raw mode produced a macro event',
|
|
);
|
|
}
|
|
});
|
|
|
|
test('the macros-mode fake deals scenes, runs macros and logs both ends of each one', () => {
|
|
const sim = new FakeFlysim({ scenario: 'running', seed: 0xbee, macroMode: 'macros' });
|
|
|
|
const scenes = new Set<string>();
|
|
const outcomes = new Map<MacroOutcomeKind, number>();
|
|
const labels: string[] = [];
|
|
let starts = 0;
|
|
let longestRunMs = 0;
|
|
let widestPad = 0;
|
|
let sawShortPad = false;
|
|
|
|
// 20 simulated minutes at 100 ms a step: about twenty scene changes and a few hundred macros.
|
|
for (let i = 0; i < 12_000; i += 1) {
|
|
const { header } = sim.tick(100);
|
|
assert.ok(validate(header), `macros snapshot ${i} failed the schema: ${JSON.stringify(validate.errors)}`);
|
|
|
|
const view = paletteView(header);
|
|
assert.equal(view.mode, 'macros');
|
|
scenes.add(view.scene);
|
|
const bound = view.cells.filter((cell) => cell.entry !== null).length;
|
|
widestPad = Math.max(widestPad, bound);
|
|
if (bound > 0 && bound < 4) sawShortPad = true;
|
|
|
|
// The rows are in type order, and each carries its type's own tag.
|
|
const types = view.cells.filter((cell) => cell.entry).map((cell) => cell.type);
|
|
assert.deepEqual(types, [...types].sort((a, b) => a - b), `snapshot ${i} is out of type order`);
|
|
for (const cell of view.cells) {
|
|
if (!cell.entry) continue;
|
|
assert.equal(cell.channel, macroChannel(cell.entry.name));
|
|
// And the population behind that channel is reporting a rate the page can draw.
|
|
assert.equal(typeof header.rates[macroRateRole(cell.entry.name)], 'number');
|
|
}
|
|
|
|
if (view.macro) {
|
|
longestRunMs = Math.max(longestRunMs, view.macro.sinceMs);
|
|
// A running macro is always one of the macros the scene bound.
|
|
const cell = view.cells.find((candidate) => candidate.entry?.slot === view.macro?.slot);
|
|
assert.ok(cell?.entry, `macro on unbound slot ${view.macro.slot} in scene ${view.scene}`);
|
|
assert.equal(cell?.entry?.name, view.macro.name);
|
|
}
|
|
if (view.outcome) outcomes.set(view.outcome.outcome, (outcomes.get(view.outcome.outcome) ?? 0) + 1);
|
|
|
|
for (const event of header.events) {
|
|
if (event.kind !== 'macro') continue;
|
|
labels.push(event.label);
|
|
if (event.label.endsWith(' start')) starts += 1;
|
|
assert.ok(
|
|
typeof event.value === 'number' && event.value >= 0 && event.value < MACRO_SLOTS,
|
|
event.label,
|
|
);
|
|
}
|
|
}
|
|
|
|
assert.ok(scenes.size >= 4, `only saw scenes ${[...scenes].join(', ')}`);
|
|
assert.ok(starts > 20, `only ${starts} macro starts in 20 minutes`);
|
|
// Section 14's own turn is nine buttons and the overworld is up to ten, so a pad wider than
|
|
// the six the wire used to carry is what the fake must be able to deal at all.
|
|
assert.ok(widestPad >= 7, `the widest pad was ${widestPad} macros`);
|
|
assert.ok(sawShortPad, 'never saw a scene with only a button or two');
|
|
assert.ok(longestRunMs <= MACRO_FRAME_CAP_MS + 200, `a macro ran ${longestRunMs} ms, past the 600-frame cap`);
|
|
|
|
// Every outcome the contract names shows up, and every label is `<NAME> <word>`.
|
|
for (const outcome of ['done', 'blocked', 'timeout', 'refused'] as MacroOutcomeKind[]) {
|
|
assert.ok((outcomes.get(outcome) ?? 0) > 0, `never saw outcome ${outcome}`);
|
|
}
|
|
const words = new Set(labels.map((label) => label.slice(label.lastIndexOf(' ') + 1)));
|
|
assert.deepEqual([...words].sort(), ['blocked', 'done', 'refused', 'start', 'timeout']);
|
|
});
|
|
|
|
test('the fake publishes a rate for all 22 channels, bound or not', () => {
|
|
// They are populations of real neurons (section 11), so they fire whatever the scene binds; the
|
|
// bound ones simply run higher. The SENSES panel's MACROS row reads exactly these.
|
|
const sim = new FakeFlysim({ scenario: 'running', seed: 7, macroMode: 'macros' });
|
|
let checked = 0;
|
|
for (let i = 0; i < 600; i += 1) {
|
|
const { header } = sim.tick(100);
|
|
for (const name of MACRO_TYPES) {
|
|
const rate = header.rates[macroRateRole(name)];
|
|
assert.equal(typeof rate, 'number', `${name} has no rate`);
|
|
assert.ok((rate as number) >= 0, `${name} reported ${String(rate)} Hz`);
|
|
}
|
|
const running = header.game.macro?.name;
|
|
if (running) {
|
|
checked += 1;
|
|
const unbound = MACRO_TYPES.filter(
|
|
(name) => !(header.game.palette ?? []).some((entry) => entry.name === name),
|
|
);
|
|
const quietest = Math.min(...unbound.map((name) => header.rates[macroRateRole(name)] as number));
|
|
assert.ok(quietest >= 0, 'a masked channel reported a negative rate');
|
|
}
|
|
}
|
|
assert.ok(checked > 0, 'no macro ran in a minute of simulation');
|
|
});
|
|
|
|
test('an outcome is kept until the next macro starts, and no longer', () => {
|
|
// `docs/feed-protocol.md`: "kept until the next one starts, so the page can light a cell's
|
|
// result for a beat rather than racing a single frame". The page shows it for a second of brain
|
|
// time (`apps/stage/src/App.tsx`); what the feed owes it is that the field is still there.
|
|
const sim = new FakeFlysim({ scenario: 'running', seed: 99, macroMode: 'macros' });
|
|
let held = false;
|
|
let previous = paletteView(sim.tick(50).header);
|
|
|
|
for (let i = 0; i < 6_000; i += 1) {
|
|
const view = paletteView(sim.tick(50).header);
|
|
|
|
// A macro that just started clears the previous outcome...
|
|
if (view.macro && !previous.macro) {
|
|
assert.equal(view.outcome, null, `a macro started with ${view.outcome?.name ?? ''} still on screen`);
|
|
}
|
|
// ...and one that just ended leaves its own there for as long as nothing else starts.
|
|
if (!view.macro && previous.macro) {
|
|
assert.ok(view.outcome, 'a macro ended and reported no outcome');
|
|
assert.equal(view.outcome?.name, previous.macro.name);
|
|
held = true;
|
|
}
|
|
previous = view;
|
|
}
|
|
|
|
assert.ok(held, 'no macro ended in five minutes');
|
|
});
|
|
|
|
test('a scene change ends the macro that was running under it', () => {
|
|
// Deterministic by construction rather than by seed: step until a snapshot shows a running macro
|
|
// and the next one shows a different scene, then the same tick must have logged its end.
|
|
const sim = new FakeFlysim({ scenario: 'running', seed: 4242, macroMode: 'macros' });
|
|
let previous = paletteView(sim.tick(50).header);
|
|
let checked = 0;
|
|
|
|
for (let i = 0; i < 40_000 && checked < 2; i += 1) {
|
|
const { header } = sim.tick(50);
|
|
const view = paletteView(header);
|
|
if (previous.macro && view.scene !== previous.scene) {
|
|
const ended = header.events.some(
|
|
(event) =>
|
|
event.kind === 'macro' &&
|
|
event.label.startsWith(`${previous.macro?.name ?? ''} `) &&
|
|
!event.label.endsWith(' start'),
|
|
);
|
|
assert.ok(ended, `scene went ${previous.scene} -> ${view.scene} with ${previous.macro.name} running and no end event`);
|
|
assert.equal(view.macro, null, 'a macro survived the scene change');
|
|
checked += 1;
|
|
}
|
|
previous = view;
|
|
}
|
|
|
|
assert.ok(checked > 0, 'never caught a scene change with a macro running');
|
|
});
|
|
|
|
test('the indoor and outdoor overworld differ by the door and the stairs', () => {
|
|
const outdoors = (FAKE_MACRO_TABLE.overworld ?? []).map((cell) => cell.name);
|
|
const indoors = FAKE_INDOOR_OVERWORLD.map((cell) => cell.name);
|
|
|
|
assert.ok(indoors.includes('GO OUT') && indoors.includes('GO WARP'), 'indoors has no way out');
|
|
assert.ok(!outdoors.includes('GO OUT') && !outdoors.includes('GO WARP'), 'outdoors has a door to leave by');
|
|
assert.ok(outdoors.includes('GO ROUTE'), 'outdoors has no route to the next area');
|
|
assert.ok(!indoors.includes('GO ROUTE'), 'indoors has a route out of the building');
|
|
|
|
// Everything else is the same set: the split is section 9.1's, not a different scene.
|
|
const rest = (names: string[]) => names.filter((name) => !['GO OUT', 'GO WARP', 'GO ROUTE'].includes(name));
|
|
assert.deepEqual(rest(indoors), rest(outdoors));
|
|
});
|