@rpgm-tools/neo-angband-mod-sdk 0.18.0 → 0.19.0

package/bin/neo-angband-mod-build.mjs

@@ -329,11 +329,12 @@ function pluginProblem(plugin) {
   if (
     plugin.hooks === undefined &&
     plugin.register === undefined &&
-    plugin.controller === undefined
+    plugin.controller === undefined &&
+    plugin.frontend === undefined
   ) {
-    return "plugin.js declares no hooks, register or controller, so it would do nothing";
+    return "plugin.js declares no hooks, register, controller or frontend, so it would do nothing";
   }
-  for (const name of ["hooks", "register", "controller", "uninstall"]) {
+  for (const name of ["hooks", "register", "controller", "frontend", "uninstall"]) {
     if (plugin[name] !== undefined && typeof plugin[name] !== "function") {
       return `plugin.js: ${name} is not a function`;
     }

package/bin/neo-angband-mod-check.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+/**
+ * Check a mod folder against the requirements the game enforces.
+ *
+ *   neo-angband-mod-check [path]            check the folder (default: .)
+ *   neo-angband-mod-check --list            print every rule and why it exists
+ *   neo-angband-mod-check --write-docs      regenerate docs/modding/REQUIREMENTS.md
+ *
+ * WHY A CLI AND NOT A DOCUMENT. An author following a document finds out whether they
+ * got it right when somebody else's install fails. This runs the SAME rules the game
+ * runs at install time - literally the same functions, imported from the SDK - so a
+ * green run here means the game will accept the mod, and a red one names the field.
+ *
+ * ARCHIVES. If the folder holds committed .zip files, they are read as the payload
+ * the way the installer reads them, so the "does this mod ship plugin.js" questions
+ * are asked of the UNPACKED contents. Checking the repository's file list instead
+ * would have answered "no plugin.js" for every mod that ships a pack, which is the
+ * shape of wrong answer that makes a checker worse than nothing.
+ *
+ * Exit 0 when nothing REQUIRED failed. Advice never changes the exit code: a check
+ * that fails a build over a missing description is a check authors route around.
+ */
+
+import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+
+import { MOD_REQUIREMENTS, checkMod, requirementsMarkdown } from "../dist/index.js";
+
+const argv = process.argv.slice(2);
+const flag = (name) => argv.includes(name);
+
+/** Every file under `dir`, relative, with forward slashes. */
+function walk(dir, base = dir) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    /* Skip what is never part of a mod, so the report is about the mod rather than
+     * about node_modules. Mirrors mod-source.ts's NOT_PAYLOAD in spirit; the game's
+     * own list is the authority for what actually installs. */
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walk(full, base));
+    else out.push(relative(base, full).split(sep).join("/"));
+  }
+  return out;
+}
+
+/**
+ * The installed file list, unpacking any committed archive the manifest declares.
+ *
+ * Uses the same reasoning as the installer: a declared archive contributes its
+ * CONTENTS, and its own path does not survive the install.
+ */
+async function installedFiles(root, repoFiles, declared) {
+  const archives = declared?.archives ?? [];
+  if (archives.length === 0) return repoFiles;
+  let unzipSync;
+  try {
+    ({ unzipSync } = await import("fflate"));
+  } catch {
+    /* fflate is the game's unzip, not the SDK's dependency. Without it the archive
+     * contents cannot be seen - so say so rather than reporting a mod as missing the
+     * files that are inside a zip this could not open. */
+    console.error(
+      "note: fflate is not installed, so declared archives were not opened.\n" +
+        "      Rules about the mod's files may be reported wrongly.\n" +
+        "      Install it (npm i -D fflate) for an accurate check.",
+    );
+    return repoFiles;
+  }
+  const files = repoFiles.filter((f) => !archives.includes(f));
+  for (const archive of archives) {
+    let bytes;
+    try {
+      bytes = readFileSync(resolve(root, archive));
+    } catch {
+      console.error(`note: payload.archives names ${archive}, which is not there`);
+      continue;
+    }
+    try {
+      for (const name of Object.keys(unzipSync(bytes))) {
+        if (!name.endsWith("/")) files.push(name);
+      }
+    } catch (e) {
+      console.error(`note: ${archive} is not a readable zip (${e.message})`);
+    }
+  }
+  return files;
+}
+
+if (flag("--list")) {
+  for (const r of MOD_REQUIREMENTS) {
+    console.log(`${r.level === "required" ? "MUST " : "SHOULD"}  ${r.title}`);
+    console.log(`        ${r.id}`);
+    console.log(`        ${r.why}\n`);
+  }
+  process.exit(0);
+}
+
+if (flag("--write-docs")) {
+  /* Written relative to this script, so it works from any directory - and it is the
+   * ONLY writer of that file, which is what lets a test assert the two agree. */
+  const out = resolve(import.meta.dirname, "..", "..", "..", "docs", "modding", "REQUIREMENTS.md");
+  writeFileSync(out, `${requirementsMarkdown()}\n`, "utf8");
+  console.log(`wrote ${out}`);
+  process.exit(0);
+}
+
+const root = resolve(argv.find((a) => !a.startsWith("-")) ?? ".");
+try {
+  if (!statSync(root).isDirectory()) throw new Error("not a directory");
+} catch {
+  console.error(`${root} is not a folder this can check.`);
+  process.exit(2);
+}
+
+const repoFiles = walk(root);
+let manifestText = null;
+try {
+  manifestText = readFileSync(join(root, "manifest.json"), "utf8");
+} catch {
+  /* manifest-present reports this; reading it here must not be fatal. */
+}
+
+let declared;
+try {
+  declared = manifestText === null ? undefined : JSON.parse(manifestText).payload;
+} catch {
+  /* manifest-json reports this. */
+}
+
+const files = await installedFiles(root, repoFiles, declared);
+const report = checkMod({ files, manifestText, repoFiles, declaredPayload: declared });
+
+const show = (findings, label) => {
+  if (findings.length === 0) return;
+  console.log(`\n${label}\n`);
+  for (const f of findings) {
+    console.log(`  ${f.title}`);
+    console.log(`    ${f.problem}`);
+    console.log(`    (${f.id})`);
+  }
+};
+
+console.log(`checked ${root}`);
+console.log(`  ${String(files.length)} installed file(s), ${String(MOD_REQUIREMENTS.length)} rules`);
+show(report.errors, "MUST FIX - the game will refuse to install this:");
+show(report.advice, "SHOULD FIX - players will notice:");
+
+if (report.ok && report.advice.length === 0) console.log("\nAll clear.");
+else if (report.ok) console.log("\nInstallable. The advice above is optional.");
+
+process.exit(report.ok ? 0 : 1);

package/dist/authoring.d.ts

@@ -0,0 +1,239 @@
+/**
+ * The shortcuts: what a new record needs, what values are typical, and what an
+ * author is about to forget.
+ *
+ * THE PROBLEM. Adding a record to a pack has never been hard - it is JSON, and
+ * composition takes it. Adding a record that WORKS is hard, and it is hard in a
+ * way no error message reaches: an object with no `alloc` is legal, loads
+ * cleanly, and never appears in the dungeon. A monster whose `base` is
+ * misspelled is legal, loads cleanly, and binds to nothing. A forty-first
+ * potion is legal, loads cleanly, and consumes the last unused flavour so that
+ * some other potion becomes unidentifiable. Nothing in the pipeline can say any
+ * of that, because nothing in the pipeline knows what a working record LOOKS
+ * like.
+ *
+ * Core's own 3,279 records know. This file is the three ways of asking them:
+ *
+ *  - `templateRecord(file)` - the fields core always writes, filled with core's
+ *    typical values. The starting point, so nobody has to reverse-engineer a
+ *    record shape out of a 6,000-line JSON file.
+ *  - `suggestFields(file, draft, records)` - what core's own comparable records
+ *    do. A price for a level-20 sword is the median price of core's level-20
+ *    swords, which is a derivation rather than a guess and is what the author
+ *    actually wanted when they asked "what should this cost".
+ *  - `checkRecords(subject, all)` - every way the draft will silently do
+ *    nothing, named.
+ *
+ * WHY THIS IS NOT A SCHEMA. A schema says what is allowed; core's data cannot,
+ * because the whole point of the mod system is that a mod may do things core
+ * never does. So every check here is graded - `error` only where the record
+ * cannot work at all, `warn` where it will not do what the author meant, `hint`
+ * where it is worth a look - and NOTHING here refuses anything. The refusals
+ * live in manifest.ts and fields.ts, where the rules are the engine's own.
+ */
+import type { FieldShape, RecordBlueprint } from "./blueprints.js";
+import type { JsonRecord, JsonValue } from "./compose.js";
+/**
+ * How much a finding costs.
+ *
+ * - `error`: the record cannot work. A required field is absent.
+ * - `warn`: the record loads and will not do what it looks like it does. A
+ *   dangling reference, a missing `alloc`.
+ * - `hint`: worth a look. An unfamiliar value, a companion step, a field core
+ *   always writes and this record does not.
+ */
+export type FindingLevel = "error" | "warn" | "hint";
+/** One thing worth saying about one record. */
+export interface AuthoringFinding {
+    readonly level: FindingLevel;
+    /** Pack file stem. */
+    readonly file: string;
+    /** The record's name, for the message. */
+    readonly record: string;
+    /** The field path, when the finding is about one. */
+    readonly field?: string;
+    /** A full sentence naming the record, the field and what to do. */
+    readonly message: string;
+    /** Stable id of the rule that produced it, so a host can filter. */
+    readonly rule: string;
+}
+/** The blueprint for a record file, or undefined if core ships no such file. */
+export declare function blueprintFor(file: string): RecordBlueprint | undefined;
+/** Every record file core ships, sorted. */
+export declare const BLUEPRINT_FILES: readonly string[];
+/**
+ * The fields EVERY one of core's records in this file carries.
+ *
+ * This is the definition of "required" used throughout, and it is a measurement
+ * rather than a schema: if all 624 monsters have `base`, a monster without one
+ * is missing something core has never once omitted.
+ */
+export declare function requiredFields(file: string): readonly string[];
+/** One field of a record file, with how much of core's data uses it. */
+export interface FieldUsage {
+    readonly name: string;
+    readonly shape: FieldShape;
+    /** Fraction of the file's records that carry it, 0 to 1. */
+    readonly share: number;
+}
+/** Every field of a record file, most-used first. */
+export declare function fieldUsage(file: string): readonly FieldUsage[];
+/** How much of a file's data a template includes. */
+export type TemplateScope = "required" | "common" | "all";
+/**
+ * A starting record for `file`, with core's typical value in every field.
+ *
+ * TYPICAL VALUES RATHER THAN EMPTY ONES, deliberately. An author handed
+ * `{"name":"","level":0,"weight":0}` has been handed the shape and none of the
+ * knowledge; handed `{"name":"","level":25,"weight":150,"cost":150}` they can
+ * see at a glance what scale the game works on and change what they mean to
+ * change. `name` is the one field left empty, because it is the one field
+ * nobody wants a default for.
+ *
+ * Scope `common` (the default) adds the fields at least half of core's records
+ * carry - which for an object is the difference between a shape and a working
+ * item, since `alloc` is on 352 of 375 and is exactly what a new object is
+ * likeliest to be missing.
+ */
+export declare function templateRecord(file: string, scope?: TemplateScope): JsonRecord;
+/** The comparable records a suggestion or a model is drawn from. */
+export interface PeerSet {
+    /** Core's records comparable to the draft, nearest first when depth is known. */
+    readonly peers: readonly JsonRecord[];
+    /** Which records these are, in a sentence, for the evidence line. */
+    readonly because: string;
+}
+/**
+ * Core's own records that are comparable to `draft`, narrowed twice: to the
+ * same peer field (all swords), then to the nearest in depth (level-20 swords).
+ *
+ * Shared by suggestFields and draftRecord so a suggested number and the record
+ * it lands in are measured against the SAME set. Two different notions of
+ * "comparable" in one drafted record would produce a coherent-looking item
+ * whose price came from somewhere else.
+ */
+export declare function peersFor(file: string, draft: JsonRecord, records?: Readonly<Record<string, readonly JsonRecord[]>>): PeerSet;
+/** One suggested value, with the evidence behind it. */
+export interface Suggestion {
+    readonly field: string;
+    readonly value: JsonValue;
+    /** Where the number came from, so an author can disagree with it knowingly. */
+    readonly because: string;
+}
+/**
+ * What core's comparable records would put in the fields this draft leaves out.
+ *
+ * THIS IS THE ANSWER TO "WHAT SHOULD IT COST". A price is not derivable from
+ * first principles - Angband's costs are hand-set - but it is derivable from
+ * precedent, and precedent is what core's 375 objects are. A draft that says
+ * `{type: "sword", level: 20}` gets the median cost, weight and to-hit of the
+ * seven core swords nearest level 20, and every suggestion carries the sentence
+ * explaining which records it came from.
+ *
+ * `records` is the composed data - core plus any packs already loaded - so a
+ * mod that has added its own tval gets suggestions from its OWN records once it
+ * has more than none. With no records supplied the numbers fall back to the
+ * blueprint's file-wide medians, which is weaker and says so.
+ *
+ * Only NUMERIC fields are suggested. A name, a description or a set of flags is
+ * a design decision, and filling those in from a neighbour would produce a
+ * record that reads like core's and is not what the author meant.
+ */
+export declare function suggestFields(file: string, draft: JsonRecord, records?: Readonly<Record<string, readonly JsonRecord[]>>): Suggestion[];
+/**
+ * A companion step: something the record itself is fine without and the AUTHOR
+ * is not.
+ *
+ * Expressed as data rather than as code so the whole list can be read at once,
+ * printed by a scaffolder, and extended without touching the checker. A rule
+ * fires when the record carries every path in `present` and none of the paths
+ * in `absent`.
+ */
+export interface CompanionRule {
+    readonly id: string;
+    readonly file: string;
+    /** Fires only if the record carries a value at every one of these. */
+    readonly present?: readonly string[];
+    /** Fires only if the record carries a value at NONE of these. */
+    readonly absent?: readonly string[];
+    readonly level: FindingLevel;
+    /** What is missing and what to do about it. */
+    readonly message: string;
+}
+/**
+ * Every "you will not find out until you play it" rule, written down.
+ *
+ * These are Angband's rules, not the port's, and each one is a real way a
+ * well-formed record does nothing. They are all `warn` or `hint` because every
+ * one of them is legal: an object with no `alloc` is exactly how core defines
+ * an item that only ever comes from a store or an artifact.
+ */
+export declare const COMPANION_RULES: readonly CompanionRule[];
+/** Options for checkRecords. */
+export interface CheckOptions {
+    /** Findings at or above this level only. Default: everything. */
+    readonly minLevel?: FindingLevel;
+}
+/**
+ * Every way the records in `subject` will silently not work, named.
+ *
+ * TWO ARGUMENTS, AND THE SPLIT IS THE WHOLE DESIGN. `subject` is what is
+ * reported on - the mod's own records. `all` is what they are allowed to resolve
+ * against - core plus every loaded pack, as composition produced it. Checking a
+ * mod against itself would report every reference to core as broken; reporting
+ * on everything would drown the author in upstream's own warts, of which there
+ * are real ones (see references.ts). Pass the same object twice to audit
+ * everything, which is what the tests do.
+ */
+export declare function checkRecords(subject: Readonly<Record<string, readonly JsonRecord[]>>, all: Readonly<Record<string, readonly JsonRecord[]>>, options?: CheckOptions): AuthoringFinding[];
+/** A drafted record, with everything that was decided for the author. */
+export interface DraftedRecord {
+    /** The record itself: the model, the suggestions, then the author's values. */
+    readonly record: JsonRecord;
+    /** Every number that was chosen for them, and on what evidence. */
+    readonly suggestions: readonly Suggestion[];
+    /** Everything still worth saying about it. */
+    readonly findings: readonly AuthoringFinding[];
+    /**
+     * The core record the shape was taken from, when there was one.
+     *
+     * Named so the author can go and read it. "Modelled on the Main Gauche" is a
+     * far more useful thing to know than any list of defaults.
+     */
+    readonly modelledOn?: string;
+}
+/**
+ * The whole workflow for one new record, in one call.
+ *
+ * THIS IS THE SHORTCUT. An author who knows what they want ("a sludge-brand
+ * dagger for around dungeon level 20") should not have to learn what an
+ * Angband object record contains before they can have one:
+ *
+ *   draftRecord("object", { name: "& Sludge Dagger~", type: "sword", level: 20 }, core)
+ *
+ * comes back with a complete record - cost, weight, to-hit, alloc and graphics
+ * all taken from core's own level-20 swords - a list of which numbers were
+ * chosen and why, and a list of what is still wrong with it. Every step is
+ * separately callable (templateRecord / suggestFields / checkRecords); this is
+ * the order they go in.
+ *
+ * THE AUTHOR'S VALUES ALWAYS WIN, and a value they supplied is never
+ * "suggested" over. The suggestions fill the gaps that remain, which is the
+ * only place a derived number is better than no number.
+ *
+ * MODELLED ON A REAL RECORD, NOT ASSEMBLED FROM AVERAGES. The first version of
+ * this built the shape from the blueprint's file-wide statistics, and produced
+ * a sword carrying `armor` - because 59% of core's objects have `armor`, even
+ * though no sword does. Field frequency across a whole file is not a statement
+ * about any record in it. So the shape comes from core's nearest comparable
+ * record, minus everything that would confer behaviour (MODEL_EXCLUDE), and
+ * only the numbers are averaged. When there is no comparable record at all it
+ * falls back to `templateRecord`, which is weaker and says so in the findings.
+ */
+export declare function draftRecord(file: string, values?: JsonRecord, records?: Readonly<Record<string, readonly JsonRecord[]>>, scope?: TemplateScope): DraftedRecord;
+/**
+ * A short human summary of what a record file wants, for a scaffolder or a
+ * `--help`.
+ */
+export declare function describeFile(file: string): string;
+//# sourceMappingURL=authoring.d.ts.map

package/dist/authoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring.d.ts","sourceRoot":"","sources":["../src/authoring.ts"],"names":[],"mappings":"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"}