@rpgm-tools/neo-angband-core 0.10.0

package/src/world/feature.ts

@@ -0,0 +1,215 @@
+/**
+ * Terrain features, ported from reference/src/cave.h struct feature and
+ * the terrain.txt binding in init.c (Angband 4.2.6).
+ *
+ * Features bind from the compiled terrain.json; indices (fidx) follow
+ * the generated FEAT codes from list-terrain.h so square feats stay
+ * numerically identical to upstream.
+ */
+
+import { FlagSet } from "../bitflag.js";
+import { FEAT, RF, TERRAIN_FLAG_ENTRIES, TF } from "../generated/index.js";
+
+/** Byte size of a terrain FlagSet (upstream TF_SIZE). */
+export const TF_SIZE = Math.ceil(TERRAIN_FLAG_ENTRIES.length / 8);
+
+export interface Feature {
+  /** FEAT_* index (position in list-terrain.h). */
+  fidx: number;
+  /** The list-terrain.h code, e.g. "FLOOR", "GRANITE". */
+  code: string;
+  name: string;
+  desc: string;
+  /** Feature code to mimic for display, resolved to fidx, or null. */
+  mimic: number | null;
+  priority: number;
+  /** How hard to dig through (1..5 scale from digging:). */
+  dig: number;
+  flags: FlagSet;
+  /** Default display attr (color char) and glyph. */
+  dAttr: string;
+  dChar: string;
+  walkMsg: string;
+  runMsg: string;
+  hurtMsg: string;
+  dieMsg: string;
+  confusedMsg: string;
+  lookPrefix: string;
+  lookInPreposition: string;
+  /** RF_* monster resist flag index required to enter, or 0. */
+  resistFlag: number;
+}
+
+/** The compiled terrain.json record shape. */
+export interface TerrainRecordJson {
+  code: string;
+  name: string;
+  graphics?: { glyph: string; color: string };
+  priority?: number;
+  flags?: string[];
+  desc?: string[];
+  digging?: number;
+  mimic?: string;
+  "walk-msg"?: string[];
+  "run-msg"?: string[];
+  "hurt-msg"?: string[];
+  "die-msg"?: string[];
+  "confused-msg"?: string[];
+  /*
+   * These three are single-token directives, but the spec (like every other
+   * `repeat: true` field) compiles them to a one-element string array rather
+   * than a bare string; joinLines/resolveResistFlag below unwrap that.
+   */
+  "look-prefix"?: string[];
+  "look-in-preposition"?: string[];
+  "resist-flag"?: string[];
+}
+
+function parseFlagNames(lines: string[] | undefined): FlagSet {
+  const flags = new FlagSet(TF_SIZE);
+  if (!lines) return flags;
+  for (const line of lines) {
+    for (const raw of line.split("|")) {
+      const name = raw.trim();
+      if (!name) continue;
+      const value = (TF as Record<string, number>)[name];
+      if (value === undefined || value === 0) {
+        throw new Error(`terrain: unknown flag ${name}`);
+      }
+      flags.on(value);
+    }
+  }
+  return flags;
+}
+
+function joinLines(lines: string[] | undefined): string {
+  // string_append semantics: multi-line values concatenate with no
+  // separator; trailing spaces in the source lines are load-bearing.
+  return lines ? lines.join("") : "";
+}
+
+/**
+ * player.h's digging enum: DIGGING_RUBBLE = 0 .. DIGGING_DOORS = 4,
+ * DIGGING_MAX = 5. parse_feat_digging (init.c) accepts only
+ * `DIGGING_RUBBLE + 1 .. DIGGING_MAX`, i.e. 1..5 -- 0 and DIGGING_MAX + 1
+ * are both PARSE_ERROR_OUT_OF_BOUNDS (f-info.c test_digging_bad0). f->dig
+ * indexes calc_digging_chances()' `chances[DIGGING_MAX]`, so an
+ * out-of-range value is a live out-of-bounds read upstream too; upstream
+ * refuses the data rather than clamping, and so does this.
+ */
+const DIGGING_MIN_VALID = 1;
+const DIGGING_MAX_VALID = 5;
+
+function resolveDigging(code: string, dig: number | undefined): number {
+  if (dig === undefined) return 0;
+  if (dig < DIGGING_MIN_VALID || dig > DIGGING_MAX_VALID) {
+    throw new Error(
+      `terrain: ${code}: digging ${String(dig)} is out of bounds ` +
+        `(PARSE_ERROR_OUT_OF_BOUNDS; init.c parse_feat_digging accepts ` +
+        `${String(DIGGING_MIN_VALID)}..${String(DIGGING_MAX_VALID)})`,
+    );
+  }
+  return dig;
+}
+
+function resolveResistFlag(name: string | undefined): number {
+  if (!name) return 0;
+  const value = (RF as Record<string, number>)[name];
+  if (value === undefined) {
+    throw new Error(`terrain: unknown resist flag ${name}`);
+  }
+  return value;
+}
+
+/**
+ * The feature registry: features indexed by fidx (FEAT order) with
+ * lookups by code and name.
+ */
+export class FeatureRegistry {
+  private byIdx: (Feature | undefined)[] = [];
+  private byCode = new Map<string, Feature>();
+  private byName = new Map<string, Feature>();
+
+  constructor(records: TerrainRecordJson[]) {
+    const featMap = FEAT as Record<string, number>;
+    for (const rec of records) {
+      const fidx = featMap[rec.code];
+      if (fidx === undefined) {
+        throw new Error(`terrain: code not in list-terrain.h: ${rec.code}`);
+      }
+      const feature: Feature = {
+        fidx,
+        code: rec.code,
+        name: rec.name,
+        desc: joinLines(rec.desc),
+        mimic: null,
+        priority: rec.priority ?? 0,
+        dig: resolveDigging(rec.code, rec.digging),
+        flags: parseFlagNames(rec.flags),
+        dAttr: rec.graphics?.color ?? "w",
+        dChar: rec.graphics?.glyph ?? " ",
+        walkMsg: joinLines(rec["walk-msg"]),
+        runMsg: joinLines(rec["run-msg"]),
+        hurtMsg: joinLines(rec["hurt-msg"]),
+        dieMsg: joinLines(rec["die-msg"]),
+        confusedMsg: joinLines(rec["confused-msg"]),
+        lookPrefix: joinLines(rec["look-prefix"]),
+        lookInPreposition: joinLines(rec["look-in-preposition"]),
+        resistFlag: resolveResistFlag(rec["resist-flag"]?.[0]),
+      };
+      this.byIdx[fidx] = feature;
+      this.byCode.set(rec.code, feature);
+      this.byName.set(rec.name, feature);
+    }
+    // Second pass: resolve mimic references by code.
+    for (const rec of records) {
+      if (rec.mimic !== undefined) {
+        const f = this.byCode.get(rec.code) as Feature;
+        const target = this.byCode.get(rec.mimic);
+        if (!target) throw new Error(`terrain: mimic not found: ${rec.mimic}`);
+        f.mimic = target.fidx;
+      }
+    }
+  }
+
+  get(fidx: number): Feature {
+    const f = this.byIdx[fidx];
+    if (!f) throw new Error(`feature index not bound: ${fidx}`);
+    return f;
+  }
+
+  byCodeName(code: string): Feature {
+    const f = this.byCode.get(code);
+    if (!f) throw new Error(`feature code not bound: ${code}`);
+    return f;
+  }
+
+  /** Every bound feature, in code-registration order (for id enumeration). */
+  allFeatures(): Feature[] {
+    return [...this.byCode.values()];
+  }
+
+  /** lookup by full name (used by gamedata cross-references). */
+  lookupByName(name: string): Feature | null {
+    return this.byName.get(name) ?? null;
+  }
+
+  /**
+   * lookup_feat_code (cave.c L315): the feature with the given list-terrain.h
+   * code, or null (the C returns -1). Non-throwing companion to byCodeName,
+   * used by the graphics pref parser where an unknown code is skipped rather
+   * than fatal.
+   */
+  lookupByCode(code: string): Feature | null {
+    return this.byCode.get(code) ?? null;
+  }
+
+  count(): number {
+    return this.byCode.size;
+  }
+
+  /** Whether the feature has a terrain flag (feat_is_* style helper). */
+  featHas(fidx: number, tf: number): boolean {
+    return this.get(fidx).flags.has(tf);
+  }
+}

package/src/world/flow.ts

@@ -0,0 +1,128 @@
+/**
+ * Noise and scent heatmaps from game-world.c (make_noise, update_scent).
+ *
+ * Noise: a breadth-first flood from the player's grid; lower values are
+ * closer to the player, 0 is silence (or the player grid itself). Monsters
+ * home in by stepping to adjacent grids with lower noise.
+ *
+ * Scent: an aging trail; a 5x5 stamp around the player, aged by one each
+ * player turn. Grids never visited hold 0.
+ *
+ * Upstream provenance: reference/src/game-world.c.
+ */
+
+import { DDGRID_DDD } from "../loc.js";
+import type { Loc } from "../loc.js";
+import { loc } from "../loc.js";
+import type { Chunk } from "./chunk.js";
+import { featIsNoFlow, featIsNoScent } from "./chunk.js";
+
+/** The player fields the heatmaps read, injected like ViewerState. */
+export interface FlowSource {
+  grid: Loc;
+  /** True while TMD_COVERTRACKS is active. */
+  covertTracks: boolean;
+}
+
+/**
+ * make_noise: rebuild the noise heatmap by flooding outward from the
+ * source. Covered tracks quadruple the per-step noise increment.
+ */
+export function makeNoise(c: Chunk, p: FlowSource): void {
+  const noiseIncrement = p.covertTracks ? 4 : 1;
+  const queue: number[] = [];
+  let head = 0;
+
+  // Set all the grids to silence. Upstream only clears the interior
+  // (borders are permanent walls and never carry flow).
+  for (let y = 1; y < c.height - 1; y++) {
+    for (let x = 1; x < c.width - 1; x++) {
+      c.noise[y * c.width + x] = 0;
+    }
+  }
+
+  let noise = 0;
+  let next = p.grid;
+  c.noise[next.y * c.width + next.x] = noise;
+  queue.push(next.y * c.width + next.x);
+  noise += noiseIncrement;
+
+  while (head < queue.length) {
+    const i = queue[head++] as number;
+    next = loc(i % c.width, Math.trunc(i / c.width));
+
+    // Reached the current noise level: requeue it and step the level.
+    if (c.noise[i] === noise) {
+      queue.push(i);
+      noise += noiseIncrement;
+      continue;
+    }
+
+    for (let d = 0; d < 8; d++) {
+      const dir = DDGRID_DDD[d] as Loc;
+      const g = loc(next.x + dir.x, next.y + dir.y);
+      if (!c.inBounds(g)) continue;
+      /* square_isnoflow (cave-square.c:738). */
+      if (featIsNoFlow(c.features, c.feat(g))) continue;
+      const gi = g.y * c.width + g.x;
+      if (c.noise[gi] !== 0) continue;
+      if (g.x === p.grid.x && g.y === p.grid.y) continue;
+      c.noise[gi] = noise;
+      queue.push(gi);
+    }
+  }
+}
+
+/** The 5x5 stamp of fresh scent strengths centred on the player. */
+const SCENT_STRENGTH: readonly (readonly number[])[] = [
+  [2, 2, 2, 2, 2],
+  [2, 1, 1, 1, 2],
+  [2, 1, 0, 1, 2],
+  [2, 1, 1, 1, 2],
+  [2, 2, 2, 2, 2],
+];
+
+/**
+ * update_scent: age all existing scent by one, then lay fresh scent in a
+ * 5x5 stamp around the player. A stamped grid only takes scent when it is
+ * connected to the trail: it is the player grid, or it neighbours a grid
+ * whose scent is exactly one fresher (upstream's wall-leak guard).
+ */
+export function updateScent(c: Chunk, p: FlowSource): void {
+  for (let y = 1; y < c.height - 1; y++) {
+    for (let x = 1; x < c.width - 1; x++) {
+      const i = y * c.width + x;
+      if ((c.scent[i] as number) > 0) {
+        c.scent[i] = (c.scent[i] as number) + 1;
+      }
+    }
+  }
+
+  if (p.covertTracks) return;
+
+  for (let y = 0; y < 5; y++) {
+    for (let x = 0; x < 5; x++) {
+      const newScent = (SCENT_STRENGTH[y] as readonly number[])[
+        x
+      ] as number;
+      const scentGrid = loc(x + p.grid.x - 2, y + p.grid.y - 2);
+      if (!c.inBounds(scentGrid)) continue;
+      /* square_isnoscent (cave-square.c:746). */
+      if (featIsNoScent(c.features, c.feat(scentGrid))) continue;
+
+      let addScent = false;
+      for (let d = 0; d < 8; d++) {
+        const dir = DDGRID_DDD[d] as Loc;
+        const adj = loc(scentGrid.x + dir.x, scentGrid.y + dir.y);
+        if (!c.inBounds(adj)) continue;
+        if (x === 2 && y === 2) addScent = true;
+        if (c.scent[adj.y * c.width + adj.x] === newScent - 1) {
+          addScent = true;
+        }
+      }
+      if (!addScent) continue;
+
+      c.scent[scentGrid.y * c.width + scentGrid.x] = newScent;
+    }
+  }
+}