@rpgm-tools/neo-angband-core 0.18.0 → 0.19.0

package/src/obj/knowledge.ts

@@ -30,6 +30,8 @@ import { FLAG_START, FlagSet, NO_FLAG } from "../bitflag.js";
 import type { RandomValue } from "../rng.js";
 import type { GameObject } from "./object.js";
 import { sameMonstersSlain, tvalIsBodyArmor, tvalIsJewelry } from "./object.js";
+import { runeRegistry, seedRune } from "./rune-registry.js";
+import type { ModMessageHandler, RuneVariety } from "./rune-registry.js";
 import type {
   Brand,
   Curse,
@@ -81,6 +83,23 @@ export interface RuneEnv {
   flavor?: FlavorKnowledge;
   /** msg() sink for rune / flag / modifier messages. */
   msg?(text: string): void;
+  /**
+   * object_desc(o_name, ..., obj, ODESC_BASE, p) - the name the six rune /
+   * flag / curse messages in this file print (obj-knowledge.c L1644, L1732,
+   * L1827, L2108, L2147, L2192; exactly six ODESC_BASE calls upstream, exactly
+   * six `baseName` sites here).
+   *
+   * A seam rather than a direct call because the real `objectDesc` needs a
+   * `KnownDesc`, which is assembled from GameState fields (isAware, options,
+   * hasFlavor, flavorText, everseen) that this module cannot see. NOT a layering
+   * problem, contrary to the note this replaces: `objectDesc` lives in
+   * `obj/desc.ts`, next door - `game/describe.ts` is only a GameState wrapper
+   * around it. The obstacle was the knowledge bundle, not the directory.
+   *
+   * Absent (worldless callers) falls back to `objBaseName`, the plain kind name.
+   * PORT_TODO 3.23.
+   */
+  describeBase?(obj: GameObject): string;
 }
 
 /** Optional registry tables for makeRuneEnv (inert defaults when absent). */
@@ -92,6 +111,7 @@ export interface RuneEnvTables {
   elementNames?: readonly string[];
   flavor?: FlavorKnowledge;
   msg?(text: string): void;
+  describeBase?(obj: GameObject): string;
 }
 
 /**
@@ -110,6 +130,7 @@ export function makeRuneEnv(
     curses: tables.curses ?? [null],
     properties: tables.properties ?? [null],
     elementNames: tables.elementNames ?? [],
+    ...(tables.describeBase ? { describeBase: tables.describeBase } : {}),
     slotObject,
     randcalcVaries,
     ...(tables.flavor ? { flavor: tables.flavor } : {}),
@@ -216,11 +237,22 @@ function objectFlagName(flag: number): string {
   return OBJECT_FLAG_ENTRIES[flag - 1]?.name ?? "NONE";
 }
 
-/** ODESC_BASE approximation until object_desc lands: the kind's plain name. */
+/**
+ * The plain kind name, `~` and `&` stripped. This is the FALLBACK for a caller
+ * with no knowledge bundle (a worldless test), not the upstream behaviour:
+ * `object_desc` with ODESC_BASE still routes an unaware flavoured kind through
+ * its flavour ("a Murky Potion", not "Potion of Cure Light Wounds"), money
+ * through the "N gold pieces worth of" form, and an unknown item through
+ * "unknown item". PORT_TODO 3.23.
+ */
 export function objBaseName(obj: GameObject): string {
   return obj.kind.name.replace(/[~&]/g, "").trim();
 }
-const baseName = objBaseName;
+
+/** ODESC_BASE via the wired seam, or the plain-name fallback. */
+function baseName(env: RuneEnv, obj: GameObject): string {
+  return env.describeBase?.(obj) ?? objBaseName(obj);
+}
 
 /* ------------------------------------------------------------------ *
  * player_knows_* accessors.
@@ -467,7 +499,7 @@ export function objectCursesFindFlags(
 ): boolean {
   if (!obj.curses) return false;
   let found = false;
-  const oName = baseName(obj);
+  const oName = baseName(env, obj);
   for (let i = 1; i < env.curses.length; i++) {
     const c = env.curses[i];
     if (!obj.curses[i]?.power || !c) continue;
@@ -517,7 +549,7 @@ export function objectCursesFindElement(
 ): boolean {
   if (!obj.curses) return false;
   let found = false;
-  const oName = baseName(obj);
+  const oName = baseName(env, obj);
   for (let i = 1; i < env.curses.length; i++) {
     const c = env.curses[i];
     if (!obj.curses[i]?.power || !c) continue;
@@ -540,24 +572,9 @@ export function objectCursesFindElement(
 /** mod_message (obj-knowledge.c L1492): "You feel..." on noticing a modifier. */
 function modMessage(env: RuneEnv, obj: GameObject, mod: number): void {
   if (!env.msg) return;
-  const v = obj.modifiers[mod] ?? 0;
-  const both = (pos: string, neg: string): string | null =>
-    v > 0 ? pos : v < 0 ? neg : null;
-  let text: string | null = null;
-  switch (mod) {
-    case OBJ_MOD.STR: text = both("You feel stronger!", "You feel weaker!"); break;
-    case OBJ_MOD.INT: text = both("You feel smarter!", "You feel more stupid!"); break;
-    case OBJ_MOD.WIS: text = both("You feel wiser!", "You feel more naive!"); break;
-    case OBJ_MOD.DEX: text = both("You feel more dextrous!", "You feel clumsier!"); break;
-    case OBJ_MOD.CON: text = both("You feel healthier!", "You feel sicklier!"); break;
-    case OBJ_MOD.STEALTH: text = both("You feel stealthier.", "You feel noisier."); break;
-    case OBJ_MOD.SPEED: text = both("You feel strangely quick.", "You feel strangely sluggish."); break;
-    case OBJ_MOD.BLOWS: text = both("Your weapon tingles in your hands.", "Your weapon aches in your hands."); break;
-    case OBJ_MOD.SHOTS: text = both("Your missile weapon tingles in your hands.", "Your missile weapon aches in your hands."); break;
-    case OBJ_MOD.INFRA: text = "Your eyes tingle."; break;
-    case OBJ_MOD.LIGHT: text = "It glows!"; break;
-    default: break;
-  }
+  const text = runeRegistry().modMessage.handlerFor(mod)?.(
+    obj.modifiers[mod] ?? 0,
+  );
   if (text) env.msg(text);
 }
 
@@ -599,7 +616,7 @@ export function objectLearnOnWield(
   }
 
   /* Learn about obvious, previously unknown flags. */
-  const oName = baseName(obj);
+  const oName = baseName(env, obj);
   for (let flag = 1; flag < OF.MAX; flag++) {
     if (!obj.flags.has(flag) || !obviousMask.has(flag)) continue;
     if (!player.objKnown.flags.has(flag)) {
@@ -660,7 +677,12 @@ export function equipLearnOnDefend(p: Player, env: RuneEnv): void {
     objectCursesFindToA(p, env, obj);
     if (p.objKnown.toA) return;
   }
-  /* Shape to_a: shapes are bound raw; DEFERRED with the shapechange system. */
+  /* The shape's OWN to_a (obj-knowledge.c:1992-1998). Reached only when the
+   * gear taught nothing, because the loop returns the moment it does - so this
+   * is a tail, not a branch, and it is here in the same place upstream has it.
+   * `p.shape` is the bound record, so upstream's lookup_player_shape by name
+   * is a step this port does not need. */
+  if (p.shape && p.shape.toA !== 0) playerLearnCombat(p, env, "toA");
 }
 
 function slotIndexByType(p: Player, type: string): number {
@@ -670,6 +692,22 @@ function slotIndexByType(p: Player, type: string): number {
   return -1;
 }
 
+/**
+ * equipped_item_by_slot_name(p, "shooting"): the wielded launcher, or null.
+ *
+ * Upstream looks the slot up by NAME; the port's body slots carry a `type`, and
+ * `player/calcs.c`'s own launcher analysis already equates "shooting" with type
+ * `BOW` (calcs.ts's equipment loop, `isBowSlot`). This is the shared accessor so
+ * that equation lives in exactly one place: two consumers had DEFERRED notes
+ * saying they could not reach the launcher (`game/ui-entry.ts`'s PF_FAST_SHOT
+ * push and `game/char-sheet.ts`'s launcher seam) while the reach was three lines
+ * of body-slot walk. PORT_TODO 3.9.
+ */
+export function equippedLauncher(p: Player, env: RuneEnv): GameObject | null {
+  const slot = slotIndexByType(p, "BOW");
+  return slot < 0 ? null : env.slotObject(slot);
+}
+
 /**
  * equip_learn_on_ranged_attack: firing teaches the to-hit rune from any
  * off-standard equipment except the weapon and launcher.
@@ -686,6 +724,8 @@ export function equipLearnOnRangedAttack(p: Player, env: RuneEnv): void {
     objectCursesFindToH(p, env, obj);
     if (p.objKnown.toH) return;
   }
+  /* The shape's own to_h (obj-knowledge.c:2026-2032). */
+  if (p.shape && p.shape.toH !== 0) playerLearnCombat(p, env, "toH");
 }
 
 /**
@@ -705,6 +745,12 @@ export function equipLearnOnMeleeAttack(p: Player, env: RuneEnv): void {
     objectCursesFindToD(p, env, obj);
     if (p.objKnown.toH && p.objKnown.toD) return;
   }
+  /* The shape's own to_h and to_d (obj-knowledge.c:2066-2078). Both, and
+   * independently - a shape with only a damage bonus still teaches to_d. */
+  if (p.shape) {
+    if (p.shape.toH !== 0) playerLearnCombat(p, env, "toH");
+    if (p.shape.toD !== 0) playerLearnCombat(p, env, "toD");
+  }
 }
 
 /**
@@ -720,7 +766,7 @@ export function equipLearnFlag(p: Player, env: RuneEnv, flag: number): void {
     if (!obj) continue;
     if (obj.flags.has(flag)) {
       if (!p.objKnown.flags.has(flag)) {
-        flagMessage(env, flag, baseName(obj));
+        flagMessage(env, flag, baseName(env, obj));
         playerLearnFlagRune(p, env, flag);
       }
     }
@@ -740,7 +786,7 @@ export function equipLearnElement(p: Player, env: RuneEnv, element: number): voi
     const obj = env.slotObject(i);
     if (!obj) continue;
     if ((obj.elInfo[element]?.resLevel ?? 0) !== 0) {
-      if (p.upkeep.playing) env.msg?.(`Your ${baseName(obj)} glows.`);
+      if (p.upkeep.playing) env.msg?.(`Your ${baseName(env, obj)} glows.`);
       playerLearnResist(p, env, element);
     }
     /* obj->known element marking: DEFERRED (display). */
@@ -796,7 +842,7 @@ export function equipLearnAfterTime(p: Player, env: RuneEnv): void {
   for (let i = 0; i < p.body.count; i++) {
     const obj = env.slotObject(i);
     if (!obj) continue;
-    const oName = baseName(obj);
+    const oName = baseName(env, obj);
     for (let flag = 1; flag < OF.MAX; flag++) {
       if (!obj.flags.has(flag) || !timedMask.has(flag)) continue;
       if (!p.objKnown.flags.has(flag)) flagMessage(env, flag, oName);
@@ -844,15 +890,13 @@ export function playerLearnAllRunes(p: Player, env: RuneEnv): void {
  * knowledge screens.
  * ------------------------------------------------------------------ */
 
-/** enum rune_variety. */
-export type RuneVariety =
-  | "combat"
-  | "mod"
-  | "resist"
-  | "brand"
-  | "slay"
-  | "curse"
-  | "flag";
+/**
+ * enum rune_variety - no longer a closed union. Core's seven plus whatever a
+ * mod coins; defined in `rune-registry.ts`, which is also where the reason it
+ * had to open lives. Re-exported here because `Rune` is this module's type and
+ * every consumer already imports it from here.
+ */
+export type { CoreRuneVariety, RuneVariety } from "./rune-registry.js";
 
 /** struct rune, resolved: a variety, its per-variety index, and a name. */
 export interface Rune {
@@ -929,6 +973,11 @@ export function buildRuneList(env: RuneEnv): Rune[] {
     }
     runes.push({ variety: "flag", index: i, name: prop.name });
   }
+  /* Every mod-contributed rune, after core's, in registration order. This is
+   * what makes the six handler tables reachable: nothing in core ever asks
+   * about a rune that is not in this list, so a registry without a producer
+   * would be a seam its own callers walk past. */
+  runes.push(...runeRegistry().contributed(env));
   return runes;
 }
 
@@ -942,50 +991,12 @@ export function buildRuneList(env: RuneEnv): Rune[] {
  * curse (the C default falls through to NULL).
  */
 export function runeDesc(env: RuneEnv, rune: Rune): string {
-  switch (rune.variety) {
-    case "combat":
-      if (rune.index === 0)
-        return "Object magically increases the player's armor class";
-      if (rune.index === 1)
-        return "Object magically increases the player's chance to hit";
-      if (rune.index === 2)
-        return "Object magically increases the player's damage";
-      return "";
-    case "mod":
-      return `Object gives the player a magical bonus to ${rune.name}.`;
-    case "resist":
-      return `Object affects the player's resistance to ${rune.name}.`;
-    case "brand":
-      return `Object brands the player's attacks with ${rune.name}.`;
-    case "slay":
-      return `Object makes the player's attacks against ${rune.name} more powerful.`;
-    case "curse": {
-      const desc = env.curses[rune.index]?.desc;
-      return desc ? `Object ${desc}.` : "";
-    }
-    case "flag":
-      return `Object gives the player the property of ${rune.name}.`;
-  }
+  return runeRegistry().desc.handlerFor(rune.variety)?.(env, rune) ?? "";
 }
 
 /** player_knows_rune over the typed knowledge stores. */
 export function playerKnowsRune(p: Player, rune: Rune): boolean {
-  switch (rune.variety) {
-    case "combat":
-      return !!p.objKnown[COMBAT_RUNE[rune.index] as "toA" | "toH" | "toD"];
-    case "mod":
-      return !!p.objKnown.modifiers[rune.index];
-    case "resist":
-      return !!p.objKnown.elInfo[rune.index]?.resLevel;
-    case "brand":
-      return playerKnowsBrand(p, rune.index);
-    case "slay":
-      return playerKnowsSlay(p, rune.index);
-    case "curse":
-      return playerKnowsCurse(p, rune.index);
-    case "flag":
-      return p.objKnown.flags.has(rune.index);
-  }
+  return runeRegistry().knows.handlerFor(rune.variety)?.(p, rune) ?? false;
 }
 
 /** object_has_rune. */
@@ -994,36 +1005,9 @@ export function objectHasRune(
   obj: GameObject,
   rune: Rune,
 ): boolean {
-  switch (rune.variety) {
-    case "combat":
-      if (rune.index === 0) return obj.toA !== 0;
-      if (rune.index === 1) return !objectHasStandardToH(env, obj);
-      return obj.toD !== 0;
-    case "mod":
-      return (obj.modifiers[rune.index] ?? 0) !== 0;
-    case "resist":
-      return (obj.elInfo[rune.index]?.resLevel ?? 0) !== 0;
-    case "brand": {
-      if (!obj.brands) return false;
-      for (let i = 0; i < obj.brands.length; i++) {
-        if (obj.brands[i] && env.brands[i]?.name === rune.name) return true;
-      }
-      return false;
-    }
-    case "slay": {
-      if (!obj.slays) return false;
-      for (let i = 0; i < obj.slays.length; i++) {
-        if (obj.slays[i] && sameMonstersSlain(env.slays, rune.index, i)) {
-          return true;
-        }
-      }
-      return false;
-    }
-    case "curse":
-      return (obj.curses?.[rune.index]?.power ?? 0) !== 0;
-    case "flag":
-      return obj.flags.has(rune.index);
-  }
+  return (
+    runeRegistry().objectHas.handlerFor(rune.variety)?.(env, obj, rune) ?? false
+  );
 }
 
 /**
@@ -1052,27 +1036,10 @@ export function playerLearnRune(
   rune: Rune,
   message: boolean,
 ): boolean {
-  switch (rune.variety) {
-    case "combat":
-      return playerLearnCombat(
-        p,
-        env,
-        COMBAT_RUNE[rune.index] as "toA" | "toH" | "toD",
-        message,
-      );
-    case "mod":
-      return playerLearnMod(p, env, rune.index, message);
-    case "resist":
-      return playerLearnResist(p, env, rune.index, message);
-    case "brand":
-      return playerLearnBrand(p, env, rune.index, message);
-    case "slay":
-      return playerLearnSlay(p, env, rune.index, message);
-    case "curse":
-      return playerLearnCurse(p, env, rune.index, message);
-    case "flag":
-      return playerLearnFlagRune(p, env, rune.index, message);
-  }
+  return (
+    runeRegistry().learn.handlerFor(rune.variety)?.(p, env, rune, message) ??
+    false
+  );
 }
 
 /**
@@ -1492,18 +1459,9 @@ export function runeKey(rune: Rune): string {
  * "resist <x>", and the bare name for combat / modifier / flag runes.
  */
 export function runeName(rune: Rune): string {
-  switch (rune.variety) {
-    case "brand":
-      return `${rune.name} brand`;
-    case "slay":
-      return `slay ${rune.name}`;
-    case "curse":
-      return `${rune.name} curse`;
-    case "resist":
-      return `resist ${rune.name}`;
-    default:
-      return rune.name;
-  }
+  /* Upstream's `default` arm is the bare name, so an unregistered variety has a
+   * real fallback here rather than a hole - three of core's own seven take it. */
+  return runeRegistry().name.handlerFor(rune.variety)?.(rune) ?? rune.name;
 }
 
 /**
@@ -1575,3 +1533,197 @@ export function playerKnowObjectAwareness(
     flavor.objectFlavorAware(obj.kind, flavorDeps); // L1174
   }
 }
+
+/* ------------------------------------------------------------------ *
+ * Core's rune arms.
+ *
+ * Every body below is lifted VERBATIM from the switch it replaces - the
+ * bodies did not change, only where they are installed. `rune-vectors.json`
+ * (99 runes, both signs of all 16 modifiers) was recorded before this block
+ * existed and is what holds that claim.
+ *
+ * Registered at import time by the module that also READS these tables, so
+ * "knowledge.ts is loaded" and "core's arms are installed" cannot come apart.
+ * ------------------------------------------------------------------ */
+
+seedRune((reg) => {
+  /* rune_desc (obj-knowledge.c L344-403). */
+  reg.desc.set("combat", (_env, rune) => {
+    if (rune.index === 0)
+      return "Object magically increases the player's armor class";
+    if (rune.index === 1)
+      return "Object magically increases the player's chance to hit";
+    if (rune.index === 2)
+      return "Object magically increases the player's damage";
+    return "";
+  });
+  reg.desc.set(
+    "mod",
+    (_env, rune) => `Object gives the player a magical bonus to ${rune.name}.`,
+  );
+  reg.desc.set(
+    "resist",
+    (_env, rune) => `Object affects the player's resistance to ${rune.name}.`,
+  );
+  reg.desc.set(
+    "brand",
+    (_env, rune) => `Object brands the player's attacks with ${rune.name}.`,
+  );
+  reg.desc.set(
+    "slay",
+    (_env, rune) =>
+      `Object makes the player's attacks against ${rune.name} more powerful.`,
+  );
+  reg.desc.set("curse", (env, rune) => {
+    const desc = env.curses[rune.index]?.desc;
+    return desc ? `Object ${desc}.` : "";
+  });
+  reg.desc.set(
+    "flag",
+    (_env, rune) => `Object gives the player the property of ${rune.name}.`,
+  );
+
+  /* player_knows_rune, over the port's typed knowledge stores. */
+  reg.knows.set(
+    "combat",
+    (p, rune) =>
+      !!p.objKnown[COMBAT_RUNE[rune.index] as "toA" | "toH" | "toD"],
+  );
+  reg.knows.set("mod", (p, rune) => !!p.objKnown.modifiers[rune.index]);
+  reg.knows.set(
+    "resist",
+    (p, rune) => !!p.objKnown.elInfo[rune.index]?.resLevel,
+  );
+  reg.knows.set("brand", (p, rune) => playerKnowsBrand(p, rune.index));
+  reg.knows.set("slay", (p, rune) => playerKnowsSlay(p, rune.index));
+  reg.knows.set("curse", (p, rune) => playerKnowsCurse(p, rune.index));
+  reg.knows.set("flag", (p, rune) => p.objKnown.flags.has(rune.index));
+
+  /* object_has_rune. */
+  reg.objectHas.set("combat", (env, obj, rune) => {
+    if (rune.index === 0) return obj.toA !== 0;
+    if (rune.index === 1) return !objectHasStandardToH(env, obj);
+    return obj.toD !== 0;
+  });
+  reg.objectHas.set(
+    "mod",
+    (_env, obj, rune) => (obj.modifiers[rune.index] ?? 0) !== 0,
+  );
+  reg.objectHas.set(
+    "resist",
+    (_env, obj, rune) => (obj.elInfo[rune.index]?.resLevel ?? 0) !== 0,
+  );
+  reg.objectHas.set("brand", (env, obj, rune) => {
+    if (!obj.brands) return false;
+    for (let i = 0; i < obj.brands.length; i++) {
+      if (obj.brands[i] && env.brands[i]?.name === rune.name) return true;
+    }
+    return false;
+  });
+  reg.objectHas.set("slay", (env, obj, rune) => {
+    if (!obj.slays) return false;
+    for (let i = 0; i < obj.slays.length; i++) {
+      if (obj.slays[i] && sameMonstersSlain(env.slays, rune.index, i)) {
+        return true;
+      }
+    }
+    return false;
+  });
+  reg.objectHas.set(
+    "curse",
+    (_env, obj, rune) => (obj.curses?.[rune.index]?.power ?? 0) !== 0,
+  );
+  reg.objectHas.set("flag", (_env, obj, rune) => obj.flags.has(rune.index));
+
+  /* player_learn_rune. */
+  reg.learn.set("combat", (p, env, rune, message) =>
+    playerLearnCombat(
+      p,
+      env,
+      COMBAT_RUNE[rune.index] as "toA" | "toH" | "toD",
+      message,
+    ),
+  );
+  reg.learn.set("mod", (p, env, rune, message) =>
+    playerLearnMod(p, env, rune.index, message),
+  );
+  reg.learn.set("resist", (p, env, rune, message) =>
+    playerLearnResist(p, env, rune.index, message),
+  );
+  reg.learn.set("brand", (p, env, rune, message) =>
+    playerLearnBrand(p, env, rune.index, message),
+  );
+  reg.learn.set("slay", (p, env, rune, message) =>
+    playerLearnSlay(p, env, rune.index, message),
+  );
+  reg.learn.set("curse", (p, env, rune, message) =>
+    playerLearnCurse(p, env, rune.index, message),
+  );
+  reg.learn.set("flag", (p, env, rune, message) =>
+    playerLearnFlagRune(p, env, rune.index, message),
+  );
+
+  /* rune_name's decoration. Only four varieties decorate; combat, mod and flag
+   * take upstream's default arm, which is the bare name. */
+  reg.name.set("brand", (rune) => `${rune.name} brand`);
+  reg.name.set("slay", (rune) => `slay ${rune.name}`);
+  reg.name.set("curse", (rune) => `${rune.name} curse`);
+  reg.name.set("resist", (rune) => `resist ${rune.name}`);
+
+  /* mod_message (obj-knowledge.c L1492). Eleven of the sixteen modifiers say
+   * anything at all, and two of those eleven ignore sign. */
+  const both =
+    (pos: string, neg: string): ModMessageHandler =>
+    (v) =>
+      v > 0 ? pos : v < 0 ? neg : null;
+  const always =
+    (text: string): ModMessageHandler =>
+    () =>
+      text;
+  reg.modMessage.set(
+    OBJ_MOD.STR,
+    both("You feel stronger!", "You feel weaker!"),
+  );
+  reg.modMessage.set(
+    OBJ_MOD.INT,
+    both("You feel smarter!", "You feel more stupid!"),
+  );
+  reg.modMessage.set(
+    OBJ_MOD.WIS,
+    both("You feel wiser!", "You feel more naive!"),
+  );
+  reg.modMessage.set(
+    OBJ_MOD.DEX,
+    both("You feel more dextrous!", "You feel clumsier!"),
+  );
+  reg.modMessage.set(
+    OBJ_MOD.CON,
+    both("You feel healthier!", "You feel sicklier!"),
+  );
+  reg.modMessage.set(
+    OBJ_MOD.STEALTH,
+    both("You feel stealthier.", "You feel noisier."),
+  );
+  reg.modMessage.set(
+    OBJ_MOD.SPEED,
+    both("You feel strangely quick.", "You feel strangely sluggish."),
+  );
+  reg.modMessage.set(
+    OBJ_MOD.BLOWS,
+    both(
+      "Your weapon tingles in your hands.",
+      "Your weapon aches in your hands.",
+    ),
+  );
+  reg.modMessage.set(
+    OBJ_MOD.SHOTS,
+    both(
+      "Your missile weapon tingles in your hands.",
+      "Your missile weapon aches in your hands.",
+    ),
+  );
+  /* INFRA and LIGHT print the same line for either sign - upstream assigns the
+   * text unconditionally rather than through its two-armed helper. */
+  reg.modMessage.set(OBJ_MOD.INFRA, always("Your eyes tingle."));
+  reg.modMessage.set(OBJ_MOD.LIGHT, always("It glows!"));
+});