@rpgm-tools/neo-angband-content 0.11.0

package/src/specs/init.ts

@@ -0,0 +1,322 @@
+/**
+ * Specs for the gamedata files whose upstream parsers live in src/init.c:
+ * constants, world, player_property, names, trap, terrain (feat), body,
+ * history, p_race, realm, shape, class, flavor, hints.
+ *
+ * Format strings are copied verbatim from the parser_reg() calls.
+ */
+
+import type { FileSpec } from "../records.js";
+
+function validIntRange(range: string): boolean {
+  const match = /^\s*(-?\d+)\s+to\s+(-?\d+)\s*$/.exec(range);
+  if (!match) return false;
+  const lo = BigInt(match[1]!);
+  const hi = BigInt(match[2]!);
+  /* grab_int_range rejects INT_MIN and INT_MAX too (datafile.c:328-331). */
+  return lo > -2147483648n && lo < 2147483647n && hi > -2147483648n && hi < 2147483647n;
+}
+
+export const constantsSpec: FileSpec = {
+  name: "constants",
+  upstream: ["src/init.c"],
+  /* constants.txt fills a single struct angband_constants; the whole file
+   * compiles to one record of grouped, labelled values. */
+  recordStart: null,
+  directives: [
+    { fmt: "level-max sym label int value", repeat: true },
+    { fmt: "mon-gen sym label int value", repeat: true },
+    { fmt: "mon-play sym label int value", repeat: true },
+    { fmt: "dun-gen sym label int value", repeat: true },
+    { fmt: "world sym label int value", repeat: true },
+    { fmt: "carry-cap sym label int value", repeat: true },
+    { fmt: "store sym label int value", repeat: true },
+    { fmt: "obj-make sym label int value", repeat: true },
+    { fmt: "player sym label int value", repeat: true },
+    { fmt: "melee-critical sym label int value", repeat: true },
+    { fmt: "melee-critical-level int cutoff int mult int add str msg", repeat: true },
+    { fmt: "ranged-critical sym label int value", repeat: true },
+    { fmt: "ranged-critical-level int cutoff int mult int add str msg", repeat: true },
+    { fmt: "o-melee-critical sym label int value", repeat: true },
+    { fmt: "o-melee-critical-level uint chance uint dice str msg", repeat: true },
+    { fmt: "o-ranged-critical sym label int value", repeat: true },
+    { fmt: "o-ranged-critical-level uint chance uint dice str msg", repeat: true },
+  ],
+};
+
+export const worldSpec: FileSpec = {
+  name: "world",
+  upstream: ["src/init.c"],
+  recordStart: "level",
+  directives: [{ fmt: "level int depth sym name sym up sym down" }],
+};
+
+export const playerPropertySpec: FileSpec = {
+  name: "player_property",
+  upstream: ["src/init.c"],
+  recordStart: "type",
+  directives: [
+    { fmt: "type str type" },
+    { fmt: "code str code" },
+    { fmt: "desc str desc", repeat: true },
+    { fmt: "name str desc" },
+    { fmt: "value int value" },
+    { fmt: "bindui sym ui int aux sym uival" },
+  ],
+};
+
+export const namesSpec: FileSpec = {
+  name: "names",
+  upstream: ["src/init.c"],
+  recordStart: "section",
+  directives: [
+    { fmt: "section uint section" },
+    { fmt: "word str name", repeat: true },
+  ],
+};
+
+export const trapSpec: FileSpec = {
+  name: "trap",
+  upstream: ["src/init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name sym name str desc" },
+    { fmt: "graphics char glyph sym color" },
+    { fmt: "appear uint rarity uint mindepth uint maxnum" },
+    { fmt: "visibility str visibility" },
+    { fmt: "flags ?str flags", repeat: true },
+    { fmt: "effect sym eff ?sym type ?int radius ?int other", repeat: true },
+    { fmt: "effect-yx int y int x", childOf: ["effect"] },
+    { fmt: "dice str dice", childOf: ["effect"] },
+    { fmt: "expr sym name sym base str expr", childOf: ["effect"], repeat: true },
+    { fmt: "effect-xtra sym eff ?sym type ?int radius ?int other", repeat: true },
+    { fmt: "effect-yx-xtra int y int x", childOf: ["effect-xtra"] },
+    { fmt: "dice-xtra str dice", childOf: ["effect-xtra"] },
+    { fmt: "expr-xtra sym name sym base str expr", childOf: ["effect-xtra"], repeat: true },
+    { fmt: "save str flags" },
+    { fmt: "desc str text", repeat: true },
+    { fmt: "msg str text", repeat: true },
+    { fmt: "msg-good str text", repeat: true },
+    { fmt: "msg-bad str text", repeat: true },
+    { fmt: "msg-xtra str text", repeat: true },
+  ],
+};
+
+export const terrainSpec: FileSpec = {
+  name: "terrain",
+  upstream: ["src/init.c"],
+  recordStart: "code",
+  directives: [
+    { fmt: "code str code" },
+    /* parse_feat_name returns PARSE_ERROR_REPEATED_DIRECTIVE when f->name is set
+     * (init.c:2059-2060). */
+    { fmt: "name str name", rejectRepeated: () => true },
+    { fmt: "graphics char glyph sym color" },
+    { fmt: "mimic str feat" },
+    { fmt: "priority uint priority" },
+    { fmt: "flags ?str flags", repeat: true },
+    { fmt: "digging int dig" },
+    { fmt: "desc str text", repeat: true },
+    { fmt: "walk-msg str text", repeat: true },
+    { fmt: "run-msg str text", repeat: true },
+    { fmt: "hurt-msg str text", repeat: true },
+    { fmt: "die-msg str text", repeat: true },
+    { fmt: "confused-msg str text", repeat: true },
+    { fmt: "look-prefix str text", repeat: true },
+    { fmt: "look-in-preposition str text", repeat: true },
+    { fmt: "resist-flag sym flag", repeat: true },
+  ],
+};
+
+export const bodySpec: FileSpec = {
+  name: "body",
+  upstream: ["src/init.c"],
+  recordStart: "body",
+  directives: [
+    { fmt: "body str name" },
+    { fmt: "slot sym slot sym name", repeat: true },
+  ],
+};
+
+export const historySpec: FileSpec = {
+  name: "history",
+  upstream: ["src/init.c"],
+  recordStart: "chart",
+  directives: [
+    { fmt: "chart uint chart int next int roll" },
+    { fmt: "phrase str text", repeat: true },
+  ],
+};
+
+export const pRaceSpec: FileSpec = {
+  name: "p_race",
+  upstream: ["src/init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "stats int str int int int wis int dex int con" },
+    { fmt: "skill-disarm-phys int disarm" },
+    { fmt: "skill-disarm-magic int disarm" },
+    { fmt: "skill-device int device" },
+    { fmt: "skill-save int save" },
+    { fmt: "skill-stealth int stealth" },
+    { fmt: "skill-search int search" },
+    { fmt: "skill-melee int melee" },
+    { fmt: "skill-shoot int shoot" },
+    { fmt: "skill-throw int throw" },
+    { fmt: "skill-dig int dig" },
+    { fmt: "hitdie int mhp" },
+    { fmt: "exp int exp" },
+    { fmt: "infravision int infra" },
+    { fmt: "history uint hist" },
+    { fmt: "age int base_age int mod_age" },
+    { fmt: "height int base_hgt int mod_hgt" },
+    { fmt: "weight int base_wgt int mod_wgt" },
+    { fmt: "obj-flags ?str flags", repeat: true },
+    { fmt: "player-flags ?str flags", repeat: true },
+    { fmt: "values str values", repeat: true },
+  ],
+};
+
+export const realmSpec: FileSpec = {
+  name: "realm",
+  upstream: ["src/init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "stat sym stat" },
+    { fmt: "verb str verb" },
+    { fmt: "spell-noun str spell" },
+    { fmt: "book-noun str book" },
+  ],
+};
+
+export const shapeSpec: FileSpec = {
+  name: "shape",
+  upstream: ["src/init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "combat int to-h int to-d int to-a" },
+    { fmt: "skill-disarm-phys int disarm" },
+    { fmt: "skill-disarm-magic int disarm" },
+    { fmt: "skill-save int save" },
+    { fmt: "skill-stealth int stealth" },
+    { fmt: "skill-search int search" },
+    { fmt: "skill-melee int melee" },
+    { fmt: "skill-throw int throw" },
+    { fmt: "skill-dig int dig" },
+    { fmt: "obj-flags ?str flags", repeat: true },
+    { fmt: "player-flags ?str flags", repeat: true },
+    { fmt: "values str values", repeat: true },
+    { fmt: "effect sym eff ?sym type ?int radius ?int other", repeat: true },
+    { fmt: "effect-yx int y int x", childOf: ["effect"] },
+    { fmt: "dice str dice", childOf: ["effect"] },
+    { fmt: "expr sym name sym base str expr", childOf: ["effect"], repeat: true },
+    { fmt: "effect-msg str text", childOf: ["effect"], repeat: true },
+    { fmt: "blow str blow", repeat: true },
+  ],
+};
+
+export const classSpec: FileSpec = {
+  name: "class",
+  upstream: ["src/init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "stats int str int int int wis int dex int con" },
+    { fmt: "skill-disarm-phys int base int incr" },
+    { fmt: "skill-disarm-magic int base int incr" },
+    { fmt: "skill-device int base int incr" },
+    { fmt: "skill-save int base int incr" },
+    { fmt: "skill-stealth int base int incr" },
+    { fmt: "skill-search int base int incr" },
+    { fmt: "skill-melee int base int incr" },
+    { fmt: "skill-shoot int base int incr" },
+    { fmt: "skill-throw int base int incr" },
+    { fmt: "skill-dig int base int incr" },
+    { fmt: "hitdie int mhp" },
+    { fmt: "exp int exp" },
+    { fmt: "max-attacks int max-attacks" },
+    { fmt: "min-weight int min-weight" },
+    { fmt: "strength-multiplier int att-multiply" },
+    { fmt: "title str title", repeat: true },
+    { fmt: "equip sym tval sym sval uint min uint max sym eopts", repeat: true },
+    { fmt: "obj-flags ?str flags", repeat: true },
+    { fmt: "player-flags ?str flags", repeat: true },
+    /* parse_class_magic rejects once c->magic.books is non-NULL
+     * (init.c:3714-3716). */
+    { fmt: "magic uint first uint weight uint books", rejectRepeated: (prior) =>
+      (prior as { books?: number }).books !== 0 },
+    {
+      fmt: "book sym tval sym quality sym name uint spells str realm",
+      repeat: true,
+      /* parse_class_book checks the allocated magic-book capacity after tval
+       * resolution (init.c:3735-3746).  The registry-dependent tval half is
+       * intentionally deferred; this structural half is available here. */
+      validate: ({ record }) => {
+        const magic = record.magic as { books?: number } | undefined;
+        const books = (record.book as unknown[] | undefined)?.length ?? 0;
+        return magic === undefined || books >= (magic.books ?? 0)
+          ? "TOO_MANY_ENTRIES"
+          : undefined;
+      },
+    },
+    { fmt: "book-graphics char glyph sym color", childOf: ["book"], requireParent: true },
+    {
+      fmt: "book-properties int cost int common str minmax",
+      childOf: ["book"],
+      requireParent: true,
+      /* grab_int_range(..., "to") failures are INVALID_ALLOCATION
+       * (init.c:3823-3826). */
+      validate: ({ values }) =>
+        validIntRange(String(values.minmax))
+          ? undefined
+          : "INVALID_ALLOCATION",
+    },
+    {
+      fmt: "spell sym name int level int mana int fail int exp",
+      childOf: ["book"],
+      orphanError: "TOO_MANY_ENTRIES",
+      repeat: true,
+      /* parse_class_spell uses the current book's declared spell capacity
+       * (init.c:3842-3854). */
+      validate: ({ target }) => {
+        const spells = (target.spell as unknown[] | undefined)?.length ?? 0;
+        return spells >= Number(target.spells) ? "TOO_MANY_ENTRIES" : undefined;
+      },
+    },
+    /* parse_class_effect requires a preceding spell (and therefore a book and
+     * magic), while its effect-detail successors intentionally tolerate a
+     * missing effect (init.c:3877-3905, 3925-3939). */
+    {
+      fmt: "effect sym eff ?sym type ?int radius ?int other",
+      childOf: ["spell"],
+      requireParent: true,
+      repeat: true,
+    },
+    { fmt: "effect-yx int y int x", childOf: ["effect"] },
+    { fmt: "dice str dice", childOf: ["effect"] },
+    { fmt: "expr sym name sym base str expr", childOf: ["effect"], repeat: true },
+    { fmt: "effect-msg str text", childOf: ["effect"], repeat: true },
+    { fmt: "desc str desc", childOf: ["spell"], requireParent: true, repeat: true },
+  ],
+};
+
+export const flavorSpec: FileSpec = {
+  name: "flavor",
+  upstream: ["src/init.c"],
+  recordStart: "kind",
+  directives: [
+    { fmt: "kind sym tval char glyph" },
+    { fmt: "flavor uint index sym attr ?str desc", repeat: true },
+    { fmt: "fixed uint index sym sval sym attr ?str desc", repeat: true },
+  ],
+};
+
+export const hintsSpec: FileSpec = {
+  name: "hints",
+  upstream: ["src/init.c"],
+  recordStart: "H",
+  directives: [{ fmt: "H str text" }],
+};

package/src/specs/misc.ts

@@ -0,0 +1,153 @@
+/**
+ * Specs for gamedata files whose upstream parsers live in single-purpose
+ * sources: summon (src/mon-summon.c), chest_trap (src/obj-chest.c), quest
+ * (src/player-quest.c), player_timed (src/player-timed.c), store
+ * (src/store.c).
+ *
+ * Format strings are copied verbatim from the parser_reg() calls.
+ */
+
+import type { FileSpec } from "../records.js";
+
+export const summonSpec: FileSpec = {
+  name: "summon",
+  upstream: ["src/mon-summon.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "msgt sym type" },
+    { fmt: "uniques int allowed" },
+    { fmt: "base sym base", repeat: true },
+    { fmt: "race-flag sym flag" },
+    { fmt: "fallback str fallback" },
+    { fmt: "desc str desc" },
+  ],
+};
+
+export const chestTrapSpec: FileSpec = {
+  name: "chest_trap",
+  upstream: ["src/obj-chest.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "code str code" },
+    { fmt: "level int level" },
+    { fmt: "effect sym eff ?sym type ?int radius ?int other", repeat: true },
+    { fmt: "dice str dice", childOf: ["effect"] },
+    { fmt: "expr sym name sym base str expr", childOf: ["effect"], repeat: true },
+    { fmt: "destroy int val" },
+    { fmt: "magic int val" },
+    { fmt: "msg str text", repeat: true },
+    { fmt: "msg-death str text", repeat: true },
+  ],
+};
+
+export const questSpec: FileSpec = {
+  name: "quest",
+  upstream: ["src/player-quest.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "level uint level" },
+    { fmt: "race str race" },
+    { fmt: "number uint number" },
+  ],
+};
+
+/**
+ * player_timed.txt: the effect-* directives attach to whichever of
+ * on-begin-effect / on-end-effect was seen most recently, mirroring the
+ * upstream parse state.
+ */
+export const playerTimedSpec: FileSpec = {
+  name: "player_timed",
+  upstream: ["src/player-timed.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "desc str text", repeat: true },
+    { fmt: "on-end str text", repeat: true },
+    { fmt: "on-increase str text", repeat: true },
+    { fmt: "on-decrease str text", repeat: true },
+    { fmt: "msgt sym type" },
+    { fmt: "fail uint code str flag", repeat: true },
+    { fmt: "grade sym color int max sym name sym up_msg ?sym down_msg", repeat: true },
+    { fmt: "resist sym elem" },
+    { fmt: "brand sym name", repeat: true },
+    { fmt: "slay sym name", repeat: true },
+    { fmt: "flag-synonym sym code int exact", repeat: true },
+    { fmt: "on-begin-effect sym eff ?sym type ?int radius ?int other", repeat: true },
+    { fmt: "on-end-effect sym eff ?sym type ?int radius ?int other", repeat: true },
+    /* Unlike class.txt / object.txt / trap.txt, all four of player-timed.c's
+     * effect-detail handlers return PARSE_ERROR_MISSING_RECORD_HEADER when
+     * ps->e is NULL (player-timed.c L480, L496, L524, L557) instead of
+     * tolerating the orphan - hence requireParent (ptimed.c
+     * test_missing_effect0). `effect-dice` also dice_free()s any previous
+     * dice (L503-505), so a repeat is legal and the last wins
+     * (ptimed.c test_effectdice0). */
+    {
+      fmt: "effect-yx int y int x",
+      childOf: ["on-begin-effect", "on-end-effect"],
+      requireParent: true,
+    },
+    {
+      fmt: "effect-dice str dice",
+      childOf: ["on-begin-effect", "on-end-effect"],
+      requireParent: true,
+    },
+    {
+      fmt: "effect-expr sym name sym base str expr",
+      childOf: ["on-begin-effect", "on-end-effect"],
+      requireParent: true,
+      repeat: true,
+    },
+    {
+      fmt: "effect-msg str text",
+      childOf: ["on-begin-effect", "on-end-effect"],
+      requireParent: true,
+      repeat: true,
+    },
+    { fmt: "flags ?str flags", repeat: true },
+    { fmt: "lower-bound int bound" },
+  ],
+};
+
+/**
+ * store.txt: the grammar half of parse_store (store.c:132) and its sibling
+ * directive handlers. The semantic half - resolving the entrance feature, the
+ * owners and the stocking tables - is packages/core/src/store/bind.ts bindStore.
+ */
+export const storeSpec: FileSpec = {
+  name: "store",
+  upstream: ["src/store.c"],
+  recordStart: "store",
+  directives: [
+    { fmt: "store str feat" },
+    { fmt: "owner uint purse str name", repeat: true },
+    { fmt: "slots uint min uint max" },
+    { fmt: "turnover uint turnover" },
+    { fmt: "normal sym tval sym sval", repeat: true },
+    { fmt: "always sym tval ?sym sval", repeat: true },
+    { fmt: "buy str base", repeat: true },
+    { fmt: "buy-flag sym flag str base", repeat: true },
+  ],
+};
+
+/**
+ * ui_knowledge.txt: the thematic monster-knowledge categories for the '~' ->
+ * Monsters browser (upstream ui-knowledge.c init_ui_knowledge_parser). Each
+ * 'monster-category' begins a category; the mcat-include-* directives attach
+ * to it. The reserved "***Unclassified***" catch-all is appended by the
+ * consumer, not the file (finish_ui_knowledge_parser).
+ */
+export const uiKnowledgeSpec: FileSpec = {
+  name: "ui_knowledge",
+  upstream: ["src/ui-knowledge.c"],
+  recordStart: "monster-category",
+  directives: [
+    { fmt: "monster-category str name" },
+    { fmt: "mcat-include-base str name", repeat: true },
+    { fmt: "mcat-include-flag ?str flags", repeat: true },
+    { fmt: "mcat-include-other str name", repeat: true },
+  ],
+};

package/src/specs/mon-init.ts

@@ -0,0 +1,165 @@
+/**
+ * Specs for the gamedata files whose upstream parsers live in
+ * src/mon-init.c: blow_methods (meth_parser), blow_effects (eff_parser),
+ * pain, monster_spell, monster_base, monster, pit.
+ *
+ * Format strings are copied verbatim from the parser_reg() calls.
+ */
+
+import type { FileSpec } from "../records.js";
+
+export const blowMethodsSpec: FileSpec = {
+  name: "blow_methods",
+  upstream: ["src/mon-init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "cut uint cut" },
+    { fmt: "stun uint stun" },
+    { fmt: "miss uint miss" },
+    { fmt: "phys uint phys" },
+    { fmt: "msg ?str msg" },
+    { fmt: "act str act", repeat: true },
+    { fmt: "desc str desc", repeat: true },
+  ],
+};
+
+export const blowEffectsSpec: FileSpec = {
+  name: "blow_effects",
+  upstream: ["src/mon-init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "power int power" },
+    { fmt: "eval int eval" },
+    { fmt: "desc str desc", repeat: true },
+    { fmt: "lore-color-base sym color" },
+    { fmt: "lore-color-resist sym color" },
+    { fmt: "lore-color-immune sym color" },
+    { fmt: "effect-type str type" },
+    { fmt: "resist str resist" },
+    { fmt: "lash-type str type" },
+  ],
+};
+
+export const painSpec: FileSpec = {
+  name: "pain",
+  upstream: ["src/mon-init.c"],
+  recordStart: "type",
+  directives: [
+    { fmt: "type uint index" },
+    { fmt: "message str message", repeat: true },
+  ],
+};
+
+/**
+ * monster_spell.txt: each spell has an implicit first "level"; the
+ * power-cutoff directive starts another level, and the lore/message
+ * directives attach to the most recent level (the record itself until the
+ * first power-cutoff appears).
+ */
+export const monsterSpellSpec: FileSpec = {
+  name: "monster_spell",
+  upstream: ["src/mon-init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "msgt sym type" },
+    { fmt: "hit uint hit" },
+    { fmt: "effect sym eff ?sym type ?int radius ?int other", repeat: true },
+    { fmt: "effect-yx int y int x", childOf: ["effect"] },
+    { fmt: "dice str dice", childOf: ["effect"] },
+    { fmt: "expr sym name sym base str expr", childOf: ["effect"], repeat: true },
+    { fmt: "power-cutoff int power", repeat: true },
+    { fmt: "lore str text", childOf: ["power-cutoff"], repeat: true },
+    { fmt: "lore-color-base sym color", childOf: ["power-cutoff"] },
+    { fmt: "lore-color-resist sym color", childOf: ["power-cutoff"] },
+    { fmt: "lore-color-immune sym color", childOf: ["power-cutoff"] },
+    { fmt: "message-vis str text", childOf: ["power-cutoff"], repeat: true },
+    { fmt: "message-invis str text", childOf: ["power-cutoff"], repeat: true },
+    { fmt: "message-miss str text", childOf: ["power-cutoff"], repeat: true },
+    { fmt: "message-save str text", childOf: ["power-cutoff"], repeat: true },
+  ],
+};
+
+export const monsterBaseSpec: FileSpec = {
+  name: "monster_base",
+  upstream: ["src/mon-init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "glyph char glyph" },
+    { fmt: "pain uint pain" },
+    { fmt: "flags ?str flags", repeat: true },
+    { fmt: "desc str desc", repeat: true },
+  ],
+};
+
+export const monsterSpec: FileSpec = {
+  name: "monster",
+  upstream: ["src/mon-init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "plural ?str plural" },
+    { fmt: "base sym base" },
+    { fmt: "glyph char glyph" },
+    { fmt: "color sym color" },
+    { fmt: "speed int speed" },
+    { fmt: "hit-points int hp" },
+    { fmt: "light int light" },
+    { fmt: "hearing int hearing" },
+    { fmt: "smell int smell" },
+    { fmt: "armor-class int ac" },
+    { fmt: "sleepiness int sleep" },
+    { fmt: "depth int level" },
+    { fmt: "rarity int rarity" },
+    { fmt: "experience int mexp" },
+    { fmt: "blow sym method ?sym effect ?rand damage", repeat: true },
+    { fmt: "flags ?str flags", repeat: true },
+    { fmt: "flags-off ?str flags", repeat: true },
+    { fmt: "desc str desc", repeat: true },
+    { fmt: "innate-freq int freq" },
+    { fmt: "spell-freq int freq" },
+    { fmt: "spell-power uint power" },
+    { fmt: "spells str spells", repeat: true },
+    { fmt: "message-vis sym spell ?str message", repeat: true },
+    { fmt: "message-invis sym spell ?str message", repeat: true },
+    { fmt: "message-miss sym spell ?str message", repeat: true },
+    {
+      fmt: "drop sym tval sym sval uint chance uint min uint max",
+      repeat: true,
+      orderKey: "drop-order",
+    },
+    {
+      fmt: "drop-base sym tval uint chance uint min uint max",
+      repeat: true,
+      orderKey: "drop-order",
+    },
+    { fmt: "friends uint chance rand number sym name ?sym role", repeat: true },
+    { fmt: "friends-base uint chance rand number sym name ?sym role", repeat: true },
+    { fmt: "mimic sym tval sym sval", repeat: true },
+    { fmt: "shape str name", repeat: true },
+    { fmt: "color-cycle sym group sym cycle" },
+  ],
+};
+
+export const pitSpec: FileSpec = {
+  name: "pit",
+  upstream: ["src/mon-init.c"],
+  recordStart: "name",
+  directives: [
+    { fmt: "name str name" },
+    { fmt: "room uint type" },
+    { fmt: "alloc uint rarity uint level" },
+    { fmt: "obj-rarity uint obj_rarity" },
+    { fmt: "mon-base sym base", repeat: true },
+    { fmt: "mon-ban sym race", repeat: true },
+    { fmt: "color sym color", repeat: true },
+    { fmt: "flags-req ?str flags", repeat: true },
+    { fmt: "flags-ban ?str flags", repeat: true },
+    { fmt: "innate-freq int freq" },
+    { fmt: "spell-req ?str spells", repeat: true },
+    { fmt: "spell-ban ?str spells", repeat: true },
+  ],
+};