@rpgm-tools/neo-angband-core 0.10.0

package/src/color.ts

@@ -0,0 +1,267 @@
+/**
+ * The Angband color palette, ported from reference/src/z-color.h and
+ * z-color.c (Angband 4.2.6): 28 named colors plus four zero-initialized
+ * color_table rows, their pref-file attr characters, the classic RGB values
+ * front ends render with, and the color_table[].color_translate[] matrix
+ * (z-color.c L66-155) used by get_color() to remap colors for mono/16-color
+ * terms, torchlight/darkness, mouse highlight, and metallic shimmer.
+ */
+
+export const COLOUR_DARK = 0;
+export const COLOUR_WHITE = 1;
+export const COLOUR_SLATE = 2;
+export const COLOUR_ORANGE = 3;
+export const COLOUR_RED = 4;
+export const COLOUR_GREEN = 5;
+export const COLOUR_BLUE = 6;
+export const COLOUR_UMBER = 7;
+export const COLOUR_L_DARK = 8;
+export const COLOUR_L_WHITE = 9;
+export const COLOUR_L_PURPLE = 10;
+export const COLOUR_YELLOW = 11;
+export const COLOUR_L_RED = 12;
+export const COLOUR_L_GREEN = 13;
+export const COLOUR_L_BLUE = 14;
+export const COLOUR_L_UMBER = 15;
+export const COLOUR_PURPLE = 16;
+export const COLOUR_VIOLET = 17;
+export const COLOUR_TEAL = 18;
+export const COLOUR_MUD = 19;
+export const COLOUR_L_YELLOW = 20;
+export const COLOUR_MAGENTA = 21;
+export const COLOUR_L_TEAL = 22;
+export const COLOUR_L_VIOLET = 23;
+export const COLOUR_L_PINK = 24;
+export const COLOUR_MUSTARD = 25;
+export const COLOUR_BLUE_SLATE = 26;
+export const COLOUR_DEEP_L_BLUE = 27;
+export const COLOUR_SHADE = 28;
+
+/** z-color.h:77-78: the table has 32 rows, 29 of them basic colours. */
+export const MAX_COLORS = 32;
+export const BASIC_COLORS = 29;
+
+/**
+ * Column indices into ColorInfo.translate, matching z-color.h's
+ * ATTR_* defines (MAX_ATTR = 9). The column order mirrors the
+ * "full mono vga blind lighter darker highlight metallic misc"
+ * comment above color_table[] in z-color.c.
+ */
+export const ATTR_FULL = 0;
+export const ATTR_MONO = 1;
+export const ATTR_VGA = 2;
+export const ATTR_BLIND = 3;
+export const ATTR_LIGHT = 4;
+export const ATTR_DARK = 5;
+export const ATTR_HIGH = 6;
+export const ATTR_METAL = 7;
+export const ATTR_MISC = 8;
+export const MAX_ATTR = 9;
+
+export interface ColorInfo {
+  /** The pref-file attr character (color_table[].index_char). */
+  char: string;
+  /** The human-readable name (color_table[].name). */
+  name: string;
+  /** Default RGB for named rows; shade RGB exists only in angbandColorTable. */
+  rgb: readonly [number, number, number];
+  /**
+   * color_table[].color_translate[]: one COLOUR_* index per ATTR_*
+   * column (full/mono/vga/blind/lighter/darker/highlight/metallic/misc).
+   * Index 28 (Shade) has no explicit row in z-color.c -- the C array
+   * relies on static zero-initialization, so it translates to
+   * COLOUR_DARK (0) in every column here as well.
+   */
+  translate: readonly number[];
+}
+
+/** Indexed by COLOUR_* value. */
+export const COLOR_TABLE: readonly ColorInfo[] = [
+  // full mono vga blind lighter darker highlight metallic misc
+  { char: "d", name: "Dark", rgb: [0x00, 0x00, 0x00],
+    translate: [0, 0, 0, 0, 8, 0, 8, 8, 0] },
+  { char: "w", name: "White", rgb: [0xff, 0xff, 0xff],
+    translate: [1, 1, 1, 1, 11, 9, 14, 11, 1] },
+  { char: "s", name: "Slate", rgb: [0x80, 0x80, 0x80],
+    translate: [2, 1, 2, 2, 9, 8, 9, 9, 2] },
+  { char: "o", name: "Orange", rgb: [0xff, 0x80, 0x00],
+    translate: [3, 1, 3, 9, 11, 2, 11, 11, 3] },
+  { char: "r", name: "Red", rgb: [0xc0, 0x00, 0x00],
+    translate: [4, 1, 4, 2, 12, 2, 12, 12, 4] },
+  { char: "g", name: "Green", rgb: [0x00, 0x80, 0x40],
+    translate: [5, 1, 5, 2, 13, 2, 13, 13, 5] },
+  { char: "b", name: "Blue", rgb: [0x00, 0x40, 0xff],
+    translate: [6, 1, 6, 2, 14, 2, 14, 14, 6] },
+  { char: "u", name: "Umber", rgb: [0x80, 0x40, 0x00],
+    translate: [7, 1, 7, 8, 15, 8, 15, 15, 7] },
+  { char: "D", name: "Light Dark", rgb: [0x60, 0x60, 0x60],
+    translate: [8, 1, 8, 8, 2, 8, 2, 2, 8] },
+  { char: "W", name: "Light Slate", rgb: [0xc0, 0xc0, 0xc0],
+    translate: [9, 1, 9, 9, 1, 2, 1, 1, 2] },
+  { char: "P", name: "Light Purple", rgb: [0xff, 0x00, 0xff],
+    translate: [10, 1, 10, 2, 11, 2, 11, 11, 10] },
+  { char: "y", name: "Yellow", rgb: [0xff, 0xff, 0x00],
+    translate: [11, 1, 11, 9, 20, 9, 1, 1, 11] },
+  { char: "R", name: "Light Red", rgb: [0xff, 0x40, 0x40],
+    translate: [12, 1, 12, 9, 11, 4, 11, 11, 12] },
+  { char: "G", name: "Light Green", rgb: [0x00, 0xff, 0x00],
+    translate: [13, 1, 13, 9, 11, 5, 11, 11, 13] },
+  { char: "B", name: "Light Blue", rgb: [0x00, 0xff, 0xff],
+    translate: [14, 1, 14, 9, 11, 6, 11, 11, 14] },
+  { char: "U", name: "Light Umber", rgb: [0xc0, 0x80, 0x40],
+    translate: [15, 1, 15, 9, 11, 7, 11, 11, 15] },
+  { char: "p", name: "Purple", rgb: [0x90, 0x00, 0x90],
+    translate: [16, 1, 10, 2, 10, 2, 10, 10, 10] },
+  { char: "v", name: "Violet", rgb: [0x90, 0x20, 0xff],
+    translate: [17, 1, 10, 2, 10, 2, 10, 10, 10] },
+  { char: "t", name: "Teal", rgb: [0x00, 0xa0, 0xa0],
+    translate: [18, 1, 6, 2, 22, 2, 22, 22, 14] },
+  { char: "m", name: "Mud", rgb: [0x6c, 0x6c, 0x30],
+    translate: [19, 1, 5, 2, 25, 2, 25, 25, 7] },
+  { char: "Y", name: "Light Yellow", rgb: [0xff, 0xff, 0x90],
+    translate: [20, 1, 11, 1, 1, 11, 1, 1, 20] },
+  { char: "i", name: "Magenta-Pink", rgb: [0xff, 0x00, 0xa0],
+    translate: [21, 1, 12, 2, 24, 4, 24, 24, 10] },
+  { char: "T", name: "Light Teal", rgb: [0x20, 0xff, 0xdc],
+    translate: [22, 1, 14, 9, 11, 18, 11, 11, 14] },
+  { char: "V", name: "Light Violet", rgb: [0xb8, 0xa8, 0xff],
+    translate: [23, 1, 10, 9, 11, 17, 11, 11, 10] },
+  { char: "I", name: "Light Pink", rgb: [0xff, 0x80, 0x80],
+    translate: [24, 1, 12, 9, 11, 21, 11, 11, 10] },
+  { char: "M", name: "Mustard", rgb: [0xb4, 0xb4, 0x00],
+    translate: [25, 1, 11, 2, 11, 2, 11, 11, 11] },
+  { char: "z", name: "Blue Slate", rgb: [0xa0, 0xc0, 0xd0],
+    translate: [26, 1, 9, 2, 27, 2, 27, 27, 9] },
+  { char: "Z", name: "Deep Light Blue", rgb: [0x00, 0xb0, 0xff],
+    translate: [27, 1, 14, 9, 14, 26, 14, 14, 14] },
+  // z-color.c:154-155: rows 28-31 are zero-initialised; shade has no
+  // index_char or name in color_table (its RGB is below, in angbandColorTable).
+  { char: "", name: "", rgb: [0, 0, 0],
+    translate: [0, 0, 0, 0, 0, 0, 0, 0, 0] },
+  { char: "", name: "", rgb: [0, 0, 0],
+    translate: [0, 0, 0, 0, 0, 0, 0, 0, 0] },
+  { char: "", name: "", rgb: [0, 0, 0],
+    translate: [0, 0, 0, 0, 0, 0, 0, 0, 0] },
+  { char: "", name: "", rgb: [0, 0, 0],
+    translate: [0, 0, 0, 0, 0, 0, 0, 0, 0] },
+];
+
+/** color_char_to_attr (z-color.c:165-184): NUL/space are dark; unknown is white. */
+export function colorCharToAttr(ch: string): number {
+  if (ch === "" || ch === "\0" || ch === " ") return COLOUR_DARK;
+  for (let i = 0; i < BASIC_COLORS; i++) {
+    const info = COLOR_TABLE[i];
+    if (info && info.char === ch) return i;
+  }
+  return COLOUR_WHITE;
+}
+
+/** color_text_to_attr (z-color.c:191-201): unknown names default to white. */
+export function colorTextToAttr(name: string): number {
+  const lower = name.toLowerCase();
+  for (let i = 0; i < MAX_COLORS; i++) {
+    const info = COLOR_TABLE[i];
+    if (info && info.name.toLowerCase() === lower) return i;
+  }
+  return COLOUR_WHITE;
+}
+
+/**
+ * angband_color_table (z-color.c): the LIVE colour values, mutable exactly like
+ * the C global, one [K, R, G, B] row per COLOUR_* index. Initialised from
+ * COLOR_TABLE with K = 0 (upstream's leading 0x00 byte). do_cmd_colors
+ * (colors_modify) edits these bytes and colorToCss reads R,G,B from here, so an
+ * edit takes effect immediately (Term_xtra REACT + redraw). K is the extra
+ * "kv" channel upstream keeps for palette backends; the web renderer ignores it
+ * but the editor still shows and edits it for faithfulness. Persisted by the
+ * front end as a user pref (like graphics/font), not in the character save.
+ */
+const angbandColorTable: [number, number, number, number][] = COLOR_TABLE.map(
+  (c, i) => i === COLOUR_SHADE
+    ? [0, 0x28, 0x28, 0x28]
+    : [0, c.rgb[0], c.rgb[1], c.rgb[2]],
+);
+
+/** Clamp to a uint8 with C wraparound (colors_modify's (uint8_t)(x +/- 1)). */
+function u8(n: number): number {
+  return ((n % 256) + 256) % 256;
+}
+
+/** angband_color_table[attr][channel] (0=K, 1=R, 2=G, 3=B). */
+export function colorChannel(attr: number, channel: 0 | 1 | 2 | 3): number {
+  return angbandColorTable[attr]?.[channel] ?? 0;
+}
+
+/** Set one live colour channel (wraps uint8), like colors_modify's k/K/r/R/... */
+export function setColorChannel(attr: number, channel: 0 | 1 | 2 | 3, value: number): void {
+  const row = angbandColorTable[attr];
+  if (row) row[channel] = u8(value);
+}
+
+/** The live [K,R,G,B] rows, copied - for persisting the user's colour edits. */
+export function colorTableSnapshot(): [number, number, number, number][] {
+  return angbandColorTable.map((r) => [r[0], r[1], r[2], r[3]]);
+}
+
+/** Restore live colours from a snapshot (front-end pref load); ignores extras. */
+export function restoreColorTable(rows: readonly (readonly number[])[]): void {
+  for (let i = 0; i < angbandColorTable.length && i < rows.length; i++) {
+    const src = rows[i];
+    const dst = angbandColorTable[i];
+    if (src && dst) {
+      dst[0] = u8(src[0] ?? 0);
+      dst[1] = u8(src[1] ?? dst[1]);
+      dst[2] = u8(src[2] ?? dst[2]);
+      dst[3] = u8(src[3] ?? dst[3]);
+    }
+  }
+}
+
+/** Reset every live colour to z-color.c:30-61 defaults (K = 0). */
+export function resetColorTable(): void {
+  for (let i = 0; i < COLOR_TABLE.length; i++) {
+    const c = COLOR_TABLE[i]!;
+    angbandColorTable[i] = i === COLOUR_SHADE
+      ? [0, 0x28, 0x28, 0x28]
+      : [0, c.rgb[0], c.rgb[1], c.rgb[2]];
+  }
+}
+
+/** attr_to_text (z-color.c:208-214): basic attrs expose their table name. */
+export function attrToText(attr: number): string {
+  return attr >= 0 && attr < BASIC_COLORS
+    ? COLOR_TABLE[attr]!.name
+    : "Icky";
+}
+
+/** CSS hex string for a COLOUR_* index (front-end convenience). Reads the LIVE
+ * angband_color_table so do_cmd_colors edits are reflected immediately. */
+export function colorToCss(attr: number): string {
+  const row = angbandColorTable[attr] ?? angbandColorTable[COLOUR_WHITE]!;
+  const hex = (n: number) => n.toString(16).padStart(2, "0");
+  return `#${hex(row[1])}${hex(row[2])}${hex(row[3])}`;
+}
+
+/**
+ * get_color(a, attr, n): translate color `a` through the color_translate
+ * matrix, `n` times, using the `attr` column (one of ATTR_*).
+ *
+ * Graphical tile attrs (high bit set, a & 0x80) pass through unchanged,
+ * and attr === ATTR_FULL (0) is treated as "no translation" -- matching
+ * upstream's `if (!attr) return (a);` full-color-term short-circuit, so
+ * ATTR_FULL is never actually used to index color_translate[0] at runtime.
+ */
+export function getColor(a: number, attr: number, n: number): number {
+  if (a & 0x80) return a;
+  if (!attr) return a;
+
+  let result = a;
+  for (let i = 0; i < n; i++) {
+    const info = COLOR_TABLE[result];
+    if (!info) return result;
+    const next = info.translate[attr];
+    if (next === undefined) return result;
+    result = next;
+  }
+  return result;
+}

package/src/combat/brand-slay.ts

@@ -0,0 +1,360 @@
+/**
+ * Brand and slay selection for combat, ported VERBATIM from
+ * reference/src/obj-slays.c (Angband 4.2.6): get_monster_brand_multiplier and
+ * improve_attack_modifier, plus the small object bonus accessors from
+ * obj-util.c (object_to_hit / object_to_dam). object_weight_one now lives in
+ * obj/object.ts (its curse-aware home); combat imports it from there.
+ *
+ * These live in the combat domain rather than obj/ because they are combat
+ * math and the obj domain does not export them; obj/ owns the Brand/Slay
+ * record shapes and the bound brands[]/slays[] arrays, which are passed in.
+ *
+ * Temporary brands/slays (improve_attack_modifier's obj == NULL path and the
+ * learn helper's allow_temp path, obj-slays.c:378-406,501-503,558-560) are now
+ * ported: the player_has_temporary_brand/slay lookups (obj-slays.c:287-317)
+ * become an injected TempBrandSlay predicate, since the TMD->brand/slay binding
+ * (player_timed.txt brand:/slay:) is resolved by the caller (game layer). Only
+ * melee's py_attack_real / learn_brand_slay_from_melee consult it upstream
+ * (allow_temp = true); the launcher/throw paths pass allow_temp = false.
+ *
+ * DEFERRED (ledgered in parity/ledger/combat-melee.yaml):
+ * - Curse contributions to object_to_hit/to_dam (obj->curses); no object
+ *   carries curses through combat yet. object_weight_one's curse adjustment is
+ *   likewise skipped there, since combat does not thread the curse table.
+ */
+
+import type { Brand, Slay } from "../obj/types.js";
+import type { GameObject } from "../obj/object.js";
+import { tvalIsLauncher, tvalIsWeapon } from "../obj/object.js";
+import type { MonsterRace } from "../mon/types.js";
+import type { Player } from "../player/player.js";
+import type { RuneEnv } from "../obj/knowledge.js";
+import {
+  playerKnowsBrand,
+  playerKnowsSlay,
+  playerLearnBrand,
+  playerLearnSlay,
+} from "../obj/knowledge.js";
+
+/** The monster fields brand/slay selection reads. */
+export interface BrandSlayTarget {
+  race: MonsterRace;
+}
+
+/**
+ * player_has_temporary_brand / player_has_temporary_slay (obj-slays.c:287-317),
+ * as an injected predicate over brand/slay indices. The caller builds it from
+ * the player's active timed effects and each effect's temp_brand / temp_slay
+ * binding (player_timed.txt brand: / slay:), which combat cannot reach directly.
+ */
+export interface TempBrandSlay {
+  /** whether a temporary brand with the given index is active. */
+  hasBrand(idx: number): boolean;
+  /** whether a temporary slay with the given index is active. */
+  hasSlay(idx: number): boolean;
+}
+
+/** object_to_hit(obj): the object's to-hit bonus (curses DEFERRED). */
+export function objectToHit(obj: GameObject): number {
+  return obj.toH;
+}
+
+/** object_to_dam(obj): the object's to-dam bonus (curses DEFERRED). */
+export function objectToDam(obj: GameObject): number {
+  return obj.toD;
+}
+
+/**
+ * get_monster_brand_multiplier: the multiplicative factor for a brand hitting
+ * a monster. Elemental vulnerability doubles the extra damage; resistances are
+ * accounted for by the caller (improve_attack_modifier skips resisted brands).
+ */
+export function getMonsterBrandMultiplier(
+  mon: BrandSlayTarget,
+  b: Brand,
+  isOCombat: boolean,
+): number {
+  let mult = isOCombat ? b.oMultiplier : b.multiplier;
+
+  if (b.vulnFlag && mon.race.flags.has(b.vulnFlag)) {
+    /* Especially vulnerable: apply a factor of two to the extra damage. */
+    if (isOCombat) {
+      mult = 2 * (mult - 10) + 10;
+    } else {
+      mult *= 2;
+    }
+  }
+
+  return mult;
+}
+
+/**
+ * A best-of brand/slay selection accumulator. `brand` and `slay` are indices
+ * into the brands[]/slays[] arrays (0 = none), mirroring the upstream
+ * *brand_used / *slay_used out-parameters.
+ */
+export interface AttackModifier {
+  brand: number;
+  slay: number;
+  /** Attack verb, updated as the best brand/slay changes ("smite", etc). */
+  verb: string;
+}
+
+/**
+ * react_to_specific_slay (obj-slays.c): does this slay affect this monster?
+ */
+function reactToSpecificSlay(s: Slay, mon: BrandSlayTarget): boolean {
+  if (!s.name) return false;
+  /* Upstream also requires mon->race->base; every bound race has one. */
+  if (s.raceFlag && mon.race.flags.has(s.raceFlag)) return true;
+  if (s.base && s.base === mon.race.base.name) return true;
+  return false;
+}
+
+/**
+ * react_to_slay (obj-slays.c L435): does `obj` carry a slay that would affect
+ * `mon`? Iterates the object's slay runes and returns true on the first whose
+ * race flag or base name matches (react_to_specific_slay). Draws no RNG. Used
+ * by the thief blows (a slay-bearing item resists being stolen) and by the
+ * monster-turn item-pickup guard.
+ */
+export function reactToSlay(
+  obj: GameObject,
+  mon: BrandSlayTarget,
+  slays: readonly (Slay | null)[],
+): boolean {
+  if (!obj.slays) return false;
+  for (let i = 0; i < slays.length; i++) {
+    const s = slays[i];
+    if (s && obj.slays[i] && reactToSpecificSlay(s, mon)) return true;
+  }
+  return false;
+}
+
+/**
+ * improve_attack_modifier: fold the best applicable brand or slay for `obj`
+ * against `mon` into `mod`, updating mod.brand/mod.slay/mod.verb.
+ *
+ * Faithful to upstream, including the quirk that the brand loop sets
+ * mod.brand without clearing mod.slay (only the slay loop clears mod.brand);
+ * the damage code then prefers a set slay. When `obj` is null the loops read
+ * temporary brands/slays from `temp` (player_has_temporary_brand/slay), exactly
+ * as improve_attack_modifier(p, NULL, ...) does; passing no `temp` leaves the
+ * obj == null call a no-op (no temporary brand/slay active).
+ *
+ * \param isOCombat selects the O-combat multipliers (birth_percent_damage);
+ * the standard path passes false.
+ * \param temp temporary brand/slay predicate, consulted only when obj is null.
+ */
+export function improveAttackModifier(
+  obj: GameObject | null,
+  mon: BrandSlayTarget,
+  brands: readonly (Brand | null)[],
+  slays: readonly (Slay | null)[],
+  mod: AttackModifier,
+  range: boolean,
+  isOCombat = false,
+  temp?: TempBrandSlay,
+): void {
+  let bestMult = 1;
+
+  /* Set the current best multiplier from any already-chosen brand/slay. */
+  if (mod.brand) {
+    const b = brands[mod.brand] as Brand;
+    bestMult = Math.max(bestMult, getMonsterBrandMultiplier(mon, b, isOCombat));
+  } else if (mod.slay) {
+    const s = slays[mod.slay] as Slay;
+    const mult = isOCombat ? s.oMultiplier : s.multiplier;
+    bestMult = Math.max(bestMult, mult);
+  }
+
+  /* Brands */
+  for (let i = 1; i < brands.length; i++) {
+    const b = brands[i];
+    if (!b) continue;
+    if (obj) {
+      if (!obj.brands || !obj.brands[i]) continue;
+    } else {
+      /* Temporary brand (player_has_temporary_brand). */
+      if (!temp || !temp.hasBrand(i)) continue;
+    }
+
+    /* Is the monster vulnerable (not resistant)? */
+    if (!mon.race.flags.has(b.resistFlag)) {
+      const mult = getMonsterBrandMultiplier(mon, b, isOCombat);
+      if (bestMult < mult) {
+        bestMult = mult;
+        mod.brand = i;
+        mod.verb = range ? `${b.verb}s` : b.verb;
+      }
+    }
+  }
+
+  /* Slays */
+  for (let i = 1; i < slays.length; i++) {
+    const s = slays[i];
+    if (!s) continue;
+    if (obj) {
+      if (!obj.slays || !obj.slays[i]) continue;
+    } else {
+      /* Temporary slay (player_has_temporary_slay). */
+      if (!temp || !temp.hasSlay(i)) continue;
+    }
+
+    if (reactToSpecificSlay(s, mon)) {
+      const mult = isOCombat ? s.oMultiplier : s.multiplier;
+      if (bestMult < mult) {
+        bestMult = mult;
+        mod.brand = 0;
+        mod.slay = i;
+        mod.verb = range ? s.rangeVerb : s.meleeVerb;
+      }
+    }
+  }
+}
+
+/** The monster fields brand/slay LEARNING reads (visibility gates slays). */
+export interface BrandSlayLearnTarget extends BrandSlayTarget {
+  /** monster_is_visible(mon). */
+  visible: boolean;
+  /**
+   * The monster's lore record (mon/lore.ts getLore), for the
+   * lore_learn_flag_if_visible learns. Optional: absent (worldless
+   * tests), only the player-rune half runs.
+   */
+  lore?: import("../mon/lore.js").MonsterLore;
+}
+
+/** lore_learn_flag_if_visible over the reduced learn target. */
+function loreLearnFlag(mon: BrandSlayLearnTarget, flag: number): void {
+  if (flag && mon.lore && mon.visible) mon.lore.flags.on(flag);
+}
+
+/**
+ * learn_brand_slay_helper (obj-slays.c L463): after an attack, learn the
+ * brand/slay runes carried by the objects involved (and, for melee/throws,
+ * by off-weapon equipment) that the monster did not resist, and note the
+ * monster's resist/vulnerability flags in its lore. Slays are only
+ * learned on visible monsters; brands teach whenever they bite.
+ *
+ * `allowTemp` enables the temporary-brand/slay path (obj-slays.c:501,558):
+ * a temporary brand/slay whose rune the objects do NOT carry still teaches the
+ * monster's lore (resist/vuln/race flags), but does NOT teach the rune itself
+ * (upstream guards player_learn_* on `learn`, which stays false for temp-only).
+ */
+function learnBrandSlayHelper(
+  p: Player,
+  env: RuneEnv,
+  obj1: GameObject | null,
+  obj2: GameObject | null,
+  mon: BrandSlayLearnTarget,
+  allowOff: boolean,
+  allowTemp: boolean,
+  temp?: TempBrandSlay,
+): void {
+  /* Handle brands. */
+  for (let i = 1; i < env.brands.length; i++) {
+    const b = env.brands[i];
+    if (!b) continue;
+    let learn = Boolean(obj1?.brands?.[i]) || Boolean(obj2?.brands?.[i]);
+    if (allowOff && !learn) {
+      for (let j = 0; j < p.body.count; j++) {
+        const obj = env.slotObject(j);
+        if (
+          obj?.brands?.[i] &&
+          !tvalIsWeapon(obj.tval) &&
+          !tvalIsLauncher(obj.tval)
+        ) {
+          learn = true;
+        }
+      }
+    }
+    /* Temporary brand: relevant only if not already carried by an object. */
+    if (!learn && !(allowTemp && (temp?.hasBrand(i) ?? false))) continue;
+
+    if (!b.resistFlag || !mon.race.flags.has(b.resistFlag)) {
+      /* Learn the rune only from a real object, not a temporary brand. */
+      if (learn) playerLearnBrand(p, env, i);
+      /* Learn about the monster (the flag's known absence / presence). */
+      loreLearnFlag(mon, b.resistFlag);
+      loreLearnFlag(mon, b.vulnFlag);
+    } else if (playerKnowsBrand(p, i)) {
+      /* A known brand fizzles: learn the monster resists. */
+      loreLearnFlag(mon, b.resistFlag);
+    }
+  }
+
+  /* Handle slays. */
+  for (let i = 1; i < env.slays.length; i++) {
+    const s = env.slays[i];
+    if (!s) continue;
+    let learn = Boolean(obj1?.slays?.[i]) || Boolean(obj2?.slays?.[i]);
+    if (allowOff && !learn) {
+      for (let j = 0; j < p.body.count; j++) {
+        const obj = env.slotObject(j);
+        if (
+          obj?.slays?.[i] &&
+          !tvalIsWeapon(obj.tval) &&
+          !tvalIsLauncher(obj.tval)
+        ) {
+          learn = true;
+        }
+      }
+    }
+    /* Temporary slay: relevant only if not already carried by an object. */
+    if (!learn && !(allowTemp && (temp?.hasSlay(i) ?? false))) continue;
+
+    if (reactToSpecificSlay(s, mon)) {
+      /* Learn about the monster. */
+      loreLearnFlag(mon, s.raceFlag);
+      /* Learn the rune only from a real object on a visible monster. */
+      if (mon.visible && learn) playerLearnSlay(p, env, i);
+    } else if (playerKnowsSlay(p, i)) {
+      /* Learn about unaffected monsters. */
+      loreLearnFlag(mon, s.raceFlag);
+    }
+  }
+}
+
+/**
+ * learn_brand_slay_from_melee: weapon (or unarmed) plus off-weapon gear, plus
+ * temporary brands/slays (allow_off = true, allow_temp = true).
+ */
+export function learnBrandSlayFromMelee(
+  p: Player,
+  env: RuneEnv,
+  weapon: GameObject | null,
+  mon: BrandSlayLearnTarget,
+  temp?: TempBrandSlay,
+): void {
+  learnBrandSlayHelper(p, env, weapon, null, mon, true, true, temp);
+}
+
+/**
+ * learn_brand_slay_from_launch: missile and launcher only (allow_off = false,
+ * allow_temp = false).
+ */
+export function learnBrandSlayFromLaunch(
+  p: Player,
+  env: RuneEnv,
+  missile: GameObject,
+  launcher: GameObject | null,
+  mon: BrandSlayLearnTarget,
+): void {
+  learnBrandSlayHelper(p, env, missile, launcher, mon, false, false);
+}
+
+/**
+ * learn_brand_slay_from_throw: thrown object only (allow_off = false,
+ * allow_temp = false) - obj-slays.c:633. The previous port passed allow_off
+ * true, which wrongly taught brand/slay runes from worn off-weapon gear on a
+ * throw (gap 3.1).
+ */
+export function learnBrandSlayFromThrow(
+  p: Player,
+  env: RuneEnv,
+  missile: GameObject,
+  mon: BrandSlayLearnTarget,
+): void {
+  learnBrandSlayHelper(p, env, missile, null, mon, false, false);
+}