@rpgm-tools/neo-angband-core 0.10.0

package/src/obj/value.ts

@@ -0,0 +1,215 @@
+/**
+ * Object valuation, ported from the pricing half of reference/src/obj-power.c
+ * (Angband 4.2.6): object_value_base, object_value_real, object_value.
+ *
+ * The variable-power path (weapons, launchers, ammo, armour, jewelry, lights)
+ * is priced from object_power (see power.ts); constant-price kinds (potions,
+ * scrolls, food, wands, staves, rods, ...) are priced from the kind's base
+ * cost, plus a per-charge premium for wands and staves.
+ *
+ * object_value dispatches by flavor-awareness (supplied by the caller's
+ * FlavorKnowledge) and item class. For variable-power items upstream prices the
+ * obj->known partial-knowledge twin (obj-power.c L1257-1259); a caller that
+ * supplies an ObjectValueKnowledge context makes object_value synthesise that
+ * twin (the port's on-demand known shadow) and price it, so an item with
+ * still-unknown runes is valued from what the player actually knows. A caller
+ * with no context prices the real object, which is exact for a fully-known item
+ * (store stock, identified gear) and over-values only an item with unknown runes.
+ */
+
+import { OF, TV } from "../generated/index.js";
+import { INT_MAX, INT_MIN } from "../guard.js";
+import type { Player } from "../player/player.js";
+import type { ObjRegistry } from "./bind.js";
+import type { KnownDesc } from "./known-object.js";
+import { objectKnownShadow } from "./known-object.js";
+import type { RuneEnv } from "./knowledge.js";
+import {
+  tvalCanHaveCharges,
+  tvalCanHaveFlavor,
+  tvalHasVariablePower,
+  tvalIsAmmo,
+  tvalIsLight,
+} from "./object.js";
+import type { GameObject } from "./object.js";
+import { objectPower } from "./power.js";
+
+/**
+ * AMMO_RESCALER (obj-power.h): a stack of this many pieces of ammo (or plain
+ * torches) is worth one weapon of the same damage output.
+ */
+const AMMO_RESCALER = 20;
+
+/**
+ * object_value_base (obj-power.c L1060): a guess at the value of a non-aware
+ * item. `aware` is object_flavor_is_aware(obj); when the item's flavor is known
+ * the kind's real cost is used, otherwise a flat per-tval estimate.
+ */
+export function objectValueBase(obj: GameObject, aware: boolean): number {
+  /* Use template cost for aware objects. */
+  if (aware) return obj.kind.cost;
+
+  /* Analyze the type. */
+  switch (obj.tval) {
+    case TV.FOOD:
+    case TV.MUSHROOM:
+      return 5;
+    case TV.POTION:
+    case TV.SCROLL:
+      return 20;
+    case TV.RING:
+    case TV.AMULET:
+      return 45;
+    case TV.WAND:
+      return 50;
+    case TV.STAFF:
+      return 70;
+    case TV.ROD:
+      return 90;
+    default:
+      return 0;
+  }
+}
+
+/**
+ * object_value_real (obj-power.c L1099): the real price of a known (or partly
+ * known) item, for a stack of `qty`.
+ *
+ * Wearables and ammo are priced by object_power via a quadratic
+ * value = power * (power * a + b) (a = 1, b = 5), scaled down by AMMO_RESCALER
+ * for ammo and non-ego burning torches. Constant-price kinds use kind.cost,
+ * with a per-charge premium for wands and staves.
+ */
+export function objectValueReal(
+  reg: ObjRegistry,
+  obj: GameObject,
+  qty: number,
+): number {
+  /* Quadratic (a) and linear (b) coefficients; both must be non-negative. */
+  const a = 1;
+  const b = 5;
+  let value = 0;
+  let totalValue: number;
+
+  /* Wearables and ammo vary by individual item properties. */
+  if (tvalHasVariablePower(obj.tval)) {
+    const power = objectPower(reg, obj);
+
+    /* Protect against overflow. */
+    if (power > 0) {
+      if (a > 0) {
+        if (power <= Math.trunc((Math.trunc(INT_MAX / power) - b) / a)) {
+          value = power * (power * a + b);
+        } else {
+          value = INT_MAX;
+        }
+      } else if (b > 0) {
+        value = power <= Math.trunc(INT_MAX / b) ? power * b : INT_MAX;
+      } else {
+        value = 0;
+      }
+    } else if (power < 0) {
+      if (a > 0) {
+        if (
+          power > INT_MIN &&
+          power >= Math.trunc((Math.trunc(INT_MIN / -power) + b) / a)
+        ) {
+          value = -power * (power * a - b);
+        } else {
+          value = INT_MIN;
+        }
+      } else if (b > 0) {
+        value = power >= Math.trunc(INT_MIN / b) ? power * b : INT_MIN;
+      } else {
+        value = 0;
+      }
+    } else {
+      value = 0;
+    }
+
+    /* Rescale for expendables. */
+    if (
+      (tvalIsLight(obj.tval) && obj.flags.has(OF.BURNS_OUT) && !obj.ego) ||
+      tvalIsAmmo(obj.tval)
+    ) {
+      value = Math.trunc(value / AMMO_RESCALER);
+    }
+
+    /* Round up so things like cloaks are not worthless. */
+    if (value === 0) value = 1;
+
+    totalValue = value * qty;
+    if (totalValue < 0) totalValue = 0;
+  } else {
+    /* Worthless items. */
+    if (!obj.kind.cost) return 0;
+
+    /* Base cost. */
+    value = obj.kind.cost;
+
+    /* Analyze the item type and quantity. */
+    if (tvalCanHaveCharges(obj.tval)) {
+      totalValue = value * qty;
+
+      /* Calculate number of charges, rounded up. */
+      let charges = Math.floor((obj.pval * qty) / obj.number);
+      if ((obj.pval * qty) % obj.number !== 0) charges++;
+
+      /* Pay extra for charges, depending on standard number of charges. */
+      totalValue += Math.floor((value * charges) / 20);
+    } else {
+      totalValue = value * qty;
+    }
+
+    /* No negative value. */
+    if (totalValue < 0) totalValue = 0;
+  }
+
+  return totalValue;
+}
+
+/**
+ * The knowledge context object_value needs to synthesise the obj->known twin
+ * (the port's on-demand known shadow) for a variable-power item, mirroring
+ * upstream's object_value_real(obj->known) at obj-power.c L1258-1259.
+ */
+export interface ObjectValueKnowledge {
+  /** The pricing player (upstream `player`; obj->known is built from p->obj_k). */
+  p: Player;
+  /** The rune/curse registries the shadow synthesis reads. */
+  env: RuneEnv;
+  /** Flavour-awareness deps the shadow synthesis reads. */
+  deps: KnownDesc;
+}
+
+/**
+ * object_value (obj-power.c L1253): the price of an item (qty one or a stack),
+ * including plusses and charges, never noticing unknown bonuses.
+ *
+ * `aware` is object_flavor_is_aware(obj), supplied by the caller's
+ * FlavorKnowledge. For a variable-power item upstream prices obj->known
+ * (L1258-1259): when `known` is supplied this synthesises that twin from the
+ * player's rune knowledge and prices it (so unknown runes are not paid for);
+ * without it the real object is priced (exact for a fully-known item).
+ */
+export function objectValue(
+  reg: ObjRegistry,
+  obj: GameObject,
+  qty: number,
+  aware: boolean,
+  known?: ObjectValueKnowledge,
+): number {
+  /* Variable-power items are assessed by what is known about them. */
+  if (tvalHasVariablePower(obj.tval)) {
+    const priced = known
+      ? objectKnownShadow(obj, known.p, known.env, known.deps)
+      : obj;
+    return objectValueReal(reg, priced, qty);
+  }
+  /* Flavoured kinds the player is aware of price at their real cost. */
+  if (tvalCanHaveFlavor(obj.kind.tval) && aware) {
+    return objectValueReal(reg, obj, qty);
+  }
+  /* Otherwise, a flat base guess. */
+  return objectValueBase(obj, aware) * qty;
+}

package/src/player/abilities.ts

@@ -0,0 +1,142 @@
+/**
+ * The race/class abilities browser's data model, ported from
+ * reference/src/player-properties.c (class_has_ability, race_has_ability,
+ * view_abilities).
+ *
+ * Upstream keeps one flat player_ability list (player_abilities), each row
+ * typed "player" (a PF_* player flag), "object" (an OF_* object flag) or
+ * "element" (a resistance/immunity/vulnerability level on a specific
+ * element). do_cmd_abilities scans that list twice - once testing
+ * class_has_ability against player->class, once testing race_has_ability
+ * against player->race - and shows the two runs back to back (class first,
+ * then race).
+ *
+ * The port's bound player_property records (players.properties,
+ * PlayerPropertyRecordJson via bind.ts) are a direct, UNEXPANDED parse of
+ * player_property.txt: the three "element" template rows (Resistance /
+ * Immunity / Vulnerability) still read as single records, whereas upstream's
+ * finish_parse_player_prop (init.c L1362) expands each of them into one row
+ * per element (new->index = element index, name = "<Elem> <Template>", desc
+ * = "<template desc> <elem>.") before the game ever runs. This module
+ * performs that same expansion at read time instead of at load time - same
+ * result, since playerAbilities is the only reader of the element rows.
+ *
+ * PlayerProperty carries no numeric index (the bound record keeps only the
+ * PF_/OF_ *name*, in `code`); resolveIndex maps it through the generated PF /
+ * OF tables, mirroring the game's numeric player_ability->index. An
+ * unresolvable code is skipped rather than throwing, so a future data/flag
+ * drift degrades gracefully instead of crashing the browser.
+ */
+
+import type { GameState } from "../game/context.js";
+import type { PlayerClass, PlayerProperty, PlayerRace } from "./types.js";
+import { OF } from "../generated/object-flags.js";
+import { PF } from "../generated/player-flags.js";
+
+/** One row of the abilities browser: an ability's display name/desc/group. */
+export interface AbilityRow {
+  name: string;
+  desc: string;
+  group: "class" | "race" | "special";
+}
+
+/** Deps playerAbilities needs beyond GameState (registry data, not core state). */
+export interface PlayerAbilitiesDeps {
+  /** players.properties: the raw (unexpanded) player_property records. */
+  properties: readonly PlayerProperty[];
+  /**
+   * projections[i].name for element index i (element-type projections are
+   * bound first, in list-elements.h order - see obj/object-info.ts's
+   * raceOrigin/projections use for the same convention). Only entries up to
+   * the number of elements on PlayerRace.elInfo are consulted.
+   */
+  elementNames: readonly string[];
+}
+
+/** PF_/OF_ name -> numeric index, or null when the code is absent/unmapped. */
+function resolveIndex(prop: PlayerProperty): number | null {
+  if (prop.code === null) return null;
+  if (prop.type === "player") return (PF as Record<string, number>)[prop.code] ?? null;
+  if (prop.type === "object") return (OF as Record<string, number>)[prop.code] ?? null;
+  return null;
+}
+
+/** class_has_ability (player-properties.c L28). */
+function classHasAbility(cls: PlayerClass, prop: PlayerProperty): boolean {
+  const idx = resolveIndex(prop);
+  if (idx === null) return false;
+  if (prop.type === "player") return cls.pflags.has(idx);
+  if (prop.type === "object") return cls.flags.has(idx);
+  return false;
+}
+
+/** race_has_ability (player-properties.c L41), excluding the element branch
+ * (handled separately by expandElementRows since it fans one record out
+ * into one row per matching element). */
+function raceHasAbility(race: PlayerRace, prop: PlayerProperty): boolean {
+  const idx = resolveIndex(prop);
+  if (idx === null) return false;
+  if (prop.type === "player") return race.pflags.has(idx);
+  if (prop.type === "object") return race.flags.has(idx);
+  return false;
+}
+
+/** ODESC_CAPITAL-style single-word/phrase capitalisation (my_strcap on the element name). */
+function capitalize(s: string): string {
+  return s.length ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+}
+
+/**
+ * Expand one "element" template property into its per-element ability rows
+ * (finish_parse_player_prop, init.c L1362-1387): one row for every element
+ * whose el_info[i].resLevel matches the template's value (1 = resist, 3 =
+ * immune, -1 = vulnerable).
+ */
+function expandElementRows(
+  prop: PlayerProperty,
+  race: PlayerRace,
+  elementNames: readonly string[],
+): AbilityRow[] {
+  const rows: AbilityRow[] = [];
+  const n = Math.min(elementNames.length, race.elInfo.length);
+  for (let i = 0; i < n; i++) {
+    if ((race.elInfo[i]?.resLevel ?? 0) !== prop.value) continue;
+    const elemName = elementNames[i] ?? "";
+    rows.push({
+      name: `${capitalize(elemName)} ${prop.name}`,
+      desc: `${prop.desc} ${elemName}.`,
+      group: "race",
+    });
+  }
+  return rows;
+}
+
+/**
+ * view_abilities (player-properties.c L62): the ability_list the abilities
+ * browser shows - every class ability the player has, then every racial one
+ * (including the per-element resist/immune/vulnerable rows), in
+ * player_property.txt declaration order within each pass.
+ */
+export function playerAbilities(state: GameState, deps: PlayerAbilitiesDeps): AbilityRow[] {
+  const player = state.actor.player;
+  const rows: AbilityRow[] = [];
+
+  for (const prop of deps.properties) {
+    if (prop.type === "element") continue; // no class-side element abilities
+    if (classHasAbility(player.cls, prop)) {
+      rows.push({ name: prop.name, desc: prop.desc, group: "class" });
+    }
+  }
+
+  for (const prop of deps.properties) {
+    if (prop.type === "element") {
+      rows.push(...expandElementRows(prop, player.race, deps.elementNames));
+      continue;
+    }
+    if (raceHasAbility(player.race, prop)) {
+      rows.push({ name: prop.name, desc: prop.desc, group: "race" });
+    }
+  }
+
+  return rows;
+}

package/src/player/best-digger.ts

@@ -0,0 +1,118 @@
+/**
+ * player_best_digger (player-util.c L744) plus the swap-and-recompute tail that
+ * do_cmd_tunnel_aux (cmd-cave.c L546-588) and compute_rubble_penalty
+ * (player-path.c L219-256) share, ported from Angband 4.2.6.
+ *
+ * Digging normally uses the wielded weapon's DIGGING skill, but a better digger
+ * carried in the pack is temporarily wielded first: upstream finds the pack's
+ * best melee weapon (by the DIGGING skill it would grant), and if it differs
+ * from the current weapon and the current weapon can be removed, recomputes the
+ * bonuses with it swapped in and reads that DIGGING. This module reproduces that
+ * choice and returns the DIGGING skill to feed into the existing dig roll.
+ *
+ * RNG: player_best_digger and the swap are RNG-FREE - they only change the INPUT
+ * (the DIGGING skill) to the caller's existing randint0(1600) draw. calc_bonuses
+ * takes no Rng, so `computeDigging` draws nothing; the caller's draw count and
+ * order are unchanged. This is deliberately input-only (do not add or reorder
+ * any draw here).
+ */
+
+import { OF } from "../generated/index.js";
+import type { GameObject } from "../obj/object.js";
+import { tvalIsMeleeWeapon } from "../obj/object.js";
+
+/**
+ * player_best_digger + the do_cmd_tunnel_aux / compute_rubble_penalty swap:
+ * return the DIGGING skill the dig should use, given the live per-body-slot
+ * equipment, every carried object (upstream p->gear, pack + equipped), the
+ * weapon body-slot index, and a `computeDigging` that runs calc_bonuses over a
+ * candidate equipment array and returns its SKILL_DIGGING (update=false, so no
+ * side effects and no RNG).
+ *
+ * The best pack digger is the qualifying melee weapon whose wielded DIGGING is
+ * highest (upstream's strict `score > best_score`, so ties keep the first-seen
+ * object - immaterial here since ties share the same DIGGING value). The swap
+ * only applies when that object differs from the current weapon AND the current
+ * weapon can be taken off (obj_can_takeoff: not sticky-cursed); otherwise the
+ * current wielded DIGGING stands.
+ */
+export function playerBestDiggerDigging(
+  liveEquipment: readonly (GameObject | null)[],
+  gearObjects: readonly GameObject[],
+  weaponSlot: number,
+  computeDigging: (equipment: (GameObject | null)[]) => number,
+): number {
+  const { swap, best } = bestDiggerSwap(
+    liveEquipment,
+    gearObjects,
+    weaponSlot,
+    computeDigging,
+  );
+  if (swap) {
+    const equip = liveEquipment.slice();
+    if (weaponSlot >= 0) equip[weaponSlot] = best;
+    return computeDigging(equip);
+  }
+  return computeDigging(liveEquipment.slice());
+}
+
+/**
+ * tunnel_aux's `with_clause` (cmd-cave.c:541, :552): what every tunnel message
+ * says the player is digging with. Derived from the SAME swap decision as
+ * playerBestDiggerDigging, so the message and the roll can never disagree.
+ */
+export function playerBestDiggerWithClause(
+  liveEquipment: readonly (GameObject | null)[],
+  gearObjects: readonly GameObject[],
+  weaponSlot: number,
+  computeDigging: (equipment: (GameObject | null)[]) => number,
+): string {
+  const { swap, currentWeapon } = bestDiggerSwap(
+    liveEquipment,
+    gearObjects,
+    weaponSlot,
+    computeDigging,
+  );
+  if (swap) return "with your swap digger";
+  return currentWeapon === null ? "with your hands" : "with your weapon";
+}
+
+/** The shared swap decision: which digger wins, and whether it displaces. */
+function bestDiggerSwap(
+  liveEquipment: readonly (GameObject | null)[],
+  gearObjects: readonly GameObject[],
+  weaponSlot: number,
+  computeDigging: (equipment: (GameObject | null)[]) => number,
+): { best: GameObject | null; swap: boolean; currentWeapon: GameObject | null } {
+  const currentWeapon =
+    weaponSlot >= 0 ? (liveEquipment[weaponSlot] ?? null) : null;
+
+  /* player_best_digger: prefer any qualifying melee weapon over unarmed
+     (best == null), scoring each with it temporarily in the weapon slot. */
+  let best: GameObject | null = null;
+  let bestScore = -1;
+  for (const obj of gearObjects) {
+    if (!tvalIsMeleeWeapon(obj.tval)) continue;
+    /* forbid_stack is false here, so any positive-count item qualifies. */
+    if (obj.number < 1) continue;
+    /* Don't use it if it has a sticky curse (obj_can_takeoff). */
+    if (obj.flags.has(OF.STICKY)) continue;
+
+    const candidate = liveEquipment.slice();
+    if (weaponSlot >= 0) candidate[weaponSlot] = obj;
+    const score = computeDigging(candidate);
+    if (score > bestScore) {
+      best = obj;
+      bestScore = score;
+    }
+  }
+
+  /* do_cmd_tunnel_aux / compute_rubble_penalty swap condition: only swap when
+     the best differs from the current weapon and the current weapon can come
+     off (a null current weapon - unarmed - always can). */
+  const swap =
+    best !== currentWeapon &&
+    (currentWeapon === null || !currentWeapon.flags.has(OF.STICKY));
+
+  return { best, swap, currentWeapon };
+}