@rpgm-tools/neo-angband-core 0.32.0 → 0.34.0

package/src/session/game.ts

@@ -1132,22 +1132,22 @@ function wireGame(
        * per lethal blow, duplicates included, so with no hook installed the
        * `?? true` below IS the faithful answer. `duplicate` tells a mod what it
        * needs to decide without core deciding anything. */
-      const what = `Killed ${mon.race.name}`;
-      const wanted =
-        state.modHooks?.historyAdd?.({
-          what,
-          type: HIST.SLAY_UNIQUE,
-          duplicate: alreadyDead,
-        }) ?? true;
+      const entry: import("../mod/hooks.js").HistoryAddEntry = {
+        what: `Killed ${mon.race.name}`,
+        type: HIST.SLAY_UNIQUE,
+        duplicate: alreadyDead,
+      };
+      const wanted = state.modHooks?.historyAdd?.(entry) ?? true;
       if (wanted) {
         const stamp = historyStamp(state);
         historyAdd(
           state.actor.player,
-          what,
+          entry.what,
           HIST.SLAY_UNIQUE,
           stamp.dlev,
           stamp.clev,
           stamp.turn,
+          entry.expandUserInput,
         );
       }
     }
@@ -2659,6 +2659,11 @@ function makeChangeLevel(
         state.traps = stash.traps;
         state.known = stash.known;
         if (stash.decoy) state.decoy = stash.decoy;
+        /* A level restored after single combat is the same kind of revisit as
+         * one recovered from birth_levels_persist.  Faithful core leaves every
+         * field untouched; an opt-in mod can update transient per-level state
+         * before the player and its monsters resume. */
+        state.modHooks?.levelRevisited?.(state.chunk, stash.turn, state.turn);
         const back = state.oldGrid ?? state.actor.grid;
         state.actor.grid = back;
         state.chunk.setMon(back, -1);
@@ -2788,6 +2793,12 @@ function makeChangeLevel(
          * the turns the level was frozen (turn - chunk->freeze-turn). */
         restoreMonsters(state, state.turn - stored.turn);
 
+        /* A restored persistent level is live again.  Core deliberately does
+         * nothing here, matching 4.2.6; a mod may observe the exact freeze and
+         * resume turns to update level-owned transient state before any monster
+         * can receive a turn. */
+        state.modHooks?.levelRevisited?.(state.chunk, stored.turn, state.turn);
+
         /* Place the player (prepare_next_level non-arena, L1497-1501): sanitize
          * the retained grid into a legal arrival square, then player_place.
          * DEFERRAL: exact stair-connector matching (dun->persist / one_off_*

package/src/session/save.ts

@@ -1401,6 +1401,8 @@ export interface SavedHistoryInfo {
   artifactName: string;
   turn: number;
   event: string;
+  /** A mod saved `event` as raw user input for display-time expansion. */
+  expandUserInput?: true;
   /** Legacy JSON saves used a numeric aIdx; never written by this version. */
   aIdx?: number;
 }
@@ -1455,6 +1457,7 @@ export function serializePlayer(
       artifactName: ids.artifactName(e.aIdx) ?? "",
       turn: e.turn,
       event: e.event,
+      ...(e.expandUserInput === true ? { expandUserInput: true } : {}),
     })),
     equipment: [...p.equipment],
     objKnown: {
@@ -1581,6 +1584,7 @@ export function deserializePlayer(
       aIdx,
       turn: e.turn,
       event: e.event,
+      ...(e.expandUserInput === true ? { expandUserInput: true } : {}),
     });
   }
   p.equipment = [...data.equipment];

package/src/version.ts

@@ -23,4 +23,4 @@ export const PARITY_BASELINE = "4.2.6";
  * released tag is iterated takes a MINOR bump, because a published tag is pinned
  * by digest in a catalogue and must never be moved.
  */
-export const ENGINE_VERSION = "0.32.0";
+export const ENGINE_VERSION = "0.34.0";

package/src/world/project.ts

@@ -290,7 +290,13 @@ export interface ProjectParams {
   origin: Loc;
   /** finish: the target grid, or a grid to travel toward. */
   finish: Loc;
-  /** rad: 0 = bolt/beam, 1..20 = ball radius, or max arc length. */
+  /**
+   * rad: 0 = bolt/beam, 1..20 = ball radius, or max arc length.
+   *
+   * The upper end is a convention rather than a rule - nothing in 4.2.6 checks
+   * it, and a radius above `maxRange` produces distances the damage table has
+   * no entry for. `resolveRadius` is where that can be decided.
+   */
   rad: number;
   /** typ: GF_ projection type, opaque to the driver; passed to the hooks. */
   typ: number;
@@ -312,6 +318,15 @@ export interface ProjectParams {
   believedWall?: (grid: Loc) => boolean;
   /** cave->decoy: PROJECT_STOP breaks the path here (project.c:218). */
   decoy?: Loc | null;
+  /**
+   * The mod behaviour seam for `rad` (ModHooks.projectionRadius), threaded in
+   * by the caller because this driver holds no GameState and must not learn
+   * about one. Absent is the faithful path: `rad` is used exactly as given.
+   *
+   * Called once, before any geometry is built, and given the same `maxRange`
+   * the damage table below is sized by.
+   */
+  resolveRadius?: (rad: number, maxRange: number) => number;
 }
 
 /** The computed blast: pure geometry + damage, no side effects. */
@@ -354,6 +369,15 @@ export function computeProjection(c: Chunk, p: ProjectParams): Projection {
   const degreesOfArc = p.degreesOfArc ?? 0;
   const diameterOfSource = p.diameterOfSource ?? 0;
 
+  /* THE RADIUS SEAM (ModHooks.projectionRadius, threaded in as resolveRadius).
+   * Faithful 4.2.6 takes the radius as given and never checks it against
+   * max_range, which is what leaves `damAtDist` below - sized max_range + 1 -
+   * short of the distances a larger radius produces. The upstream fix for that
+   * (issue #6671) is one clamp here, and it is a mod's to install: core carries
+   * the tag's behaviour, warts included, and holds only the point at which the
+   * radius can be decided. */
+  if (p.resolveRadius) rad = p.resolveRadius(rad, maxRange);
+
   /* No projection path - jump to target. */
   let start: Loc;
   if (flg & PROJECT.JUMP) {
@@ -518,7 +542,14 @@ export function computeProjection(c: Chunk, p: ProjectParams): Projection {
     }
   }
 
-  /* Calculate and store the actual damage at each distance. */
+  /* Calculate and store the actual damage at each distance.
+   *
+   * SIZED BY max_range, NOT BY rad, exactly as upstream sizes dam_at_dist. A
+   * radius above max_range therefore leaves the far distances with no entry at
+   * all, and every read of one is a hole the caller cannot see: the C reads
+   * stale memory, and this reads `undefined` straight into the damage a handler
+   * is handed. Whether the radius can get there is decided above, by
+   * resolveRadius. */
   const damAtDist: number[] = new Array(maxRange + 1);
   for (let i = 0; i <= maxRange; i++) {
     let damTemp: number;