@rpgm-tools/neo-angband-core 0.10.0

package/src/game/target.ts

@@ -0,0 +1,424 @@
+/**
+ * Targeting, ported from reference/src/target.c (Angband 4.2.6): the
+ * player's persistent target (a monster or a location), the target-able
+ * test, the fix/release protocol that keeps a mid-spell target's grid
+ * alive after the monster dies, the interesting-grid scan the look/target
+ * UI walks, and target_set_closest.
+ *
+ * The upstream file-statics (target_set, target_fixed, target, old_target)
+ * live on GameState.target (a TargetState) so saves/tests stay explicit.
+ * The interactive half of targeting (ui-target.c: the * key browsing loop,
+ * panels, prompts) rides presentation (#25); this module is the complete
+ * bookkeeping half those menus drive, and effect handlers reach it through
+ * the aimed seam (obj-cmd / spell-cmd resolve DIR_TARGET through
+ * targetOkay + targetGet exactly as the upstream handlers do).
+ *
+ * Reductions, ledgered in parity/ledger/game-target.yaml: monster names use
+ * the full monster_desc grammar (mon/desc.ts), panel restriction is an
+ * injected predicate defaulting to "everything" (panels are UI state),
+ * ignore_known_item_ok treats no known objects as ignored (ignore is a
+ * later #24 slice), and monster_race_track is lore's (healthWho covers
+ * health_track).
+ */
+
+import { MON_TMD, TMD } from "../generated/index.js";
+import type { Loc } from "../loc.js";
+import { loc } from "../loc.js";
+import { MDESC, monsterDesc } from "../mon/desc.js";
+import type { Monster } from "../mon/monster.js";
+import {
+  monsterIsDestroyed,
+  monsterIsInView,
+  monsterIsObvious,
+  monsterIsVisible,
+} from "../mon/predicate.js";
+import { PROJECT, projectable } from "../world/project.js";
+import { squareIsSeen } from "../world/view.js";
+import type { GameState } from "./context.js";
+import { monsterAt, squareMonster } from "./context.js";
+import { knownObject, squareIsInteresting } from "./known.js";
+import { squareIsVisibleTrap } from "./trap.js";
+
+/** Bit flags for target_get_monsters / target_set_closest (target.h). */
+export const TARGET = {
+  KILL: 0x01,
+  LOOK: 0x02,
+  XTRA: 0x04,
+  GRID: 0x08,
+  QUIET: 0x10,
+} as const;
+
+/**
+ * The target.c file-statics: whether a target is set, whether it is fixed
+ * for the duration of a spell, the current target (monster index + grid)
+ * and the saved old target the release step inspects.
+ */
+export interface TargetState {
+  /** target_set. */
+  set: boolean;
+  /** target_fixed. */
+  fixed: boolean;
+  /** target.midx (0 = a location target or none). */
+  midx: number;
+  /** target.grid. */
+  grid: Loc;
+  /** old_target, saved by targetFix. */
+  oldMidx: number;
+  oldGrid: Loc;
+}
+
+/** A fresh, unset target. */
+export function newTargetState(): TargetState {
+  return {
+    set: false,
+    fixed: false,
+    midx: 0,
+    grid: loc(0, 0),
+    oldMidx: 0,
+    oldGrid: loc(0, 0),
+  };
+}
+
+/**
+ * look_mon_desc (L56): the monster health/status description ("wounded,
+ * asleep, afraid"). PROBE and the look UI read it.
+ */
+export function lookMonDesc(mon: Monster): string {
+  const living = !monsterIsDestroyed(mon);
+
+  let buf: string;
+  if (mon.hp >= mon.maxhp) {
+    buf = living ? "unhurt" : "undamaged";
+  } else {
+    const perc = Math.trunc((100 * mon.hp) / mon.maxhp);
+    if (perc >= 60) buf = living ? "somewhat wounded" : "somewhat damaged";
+    else if (perc >= 25) buf = living ? "wounded" : "damaged";
+    else if (perc >= 10) buf = living ? "badly wounded" : "badly damaged";
+    else buf = living ? "almost dead" : "almost destroyed";
+  }
+
+  if (mon.mTimed[MON_TMD.SLEEP]) buf += ", asleep";
+  if (mon.mTimed[MON_TMD.HOLD]) buf += ", held";
+  if (mon.mTimed[MON_TMD.DISEN]) buf += ", disenchanted";
+  if (mon.mTimed[MON_TMD.CONF]) buf += ", confused";
+  if (mon.mTimed[MON_TMD.FEAR]) buf += ", afraid";
+  if (mon.mTimed[MON_TMD.STUN]) buf += ", stunned";
+  if (mon.mTimed[MON_TMD.SLOW]) buf += ", slowed";
+  if (mon.mTimed[MON_TMD.FAST]) buf += ", hasted";
+  return buf;
+}
+
+/**
+ * target_able (L110): a reasonable target is an obvious monster the player
+ * could hit with a projection while not hallucinating.
+ */
+export function targetAble(state: GameState, mon: Monster | null): boolean {
+  return (
+    !!mon &&
+    !!mon.race &&
+    monsterIsObvious(mon) &&
+    projectable(
+      state.chunk,
+      state.actor.grid,
+      mon.grid,
+      PROJECT.NONE,
+      state.z.maxRange,
+    ) &&
+    !((state.actor.player.timed[TMD.IMAGE] ?? 0) > 0)
+  );
+}
+
+/**
+ * target_okay (L124): update (a monster target's grid follows the monster)
+ * and verify the target.
+ */
+export function targetOkay(state: GameState): boolean {
+  const t = state.target;
+  if (!t.set) return false;
+
+  if (t.midx > 0) {
+    const mon = monsterAt(state, t.midx);
+    if (targetAble(state, mon)) {
+      /* Get the monster location. */
+      t.grid = mon!.grid;
+      return true;
+    }
+  } else if (t.grid.x && t.grid.y) {
+    /* Allow a direction without a monster. */
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * target_set_monster (L152): set the target to a monster (or nobody); if
+ * the target is fixed, keep the grid so further effects of a spell that
+ * killed the monster still have somewhere to land.
+ */
+export function targetSetMonster(
+  state: GameState,
+  mon: Monster | null,
+): boolean {
+  const t = state.target;
+  if (mon && targetAble(state, mon)) {
+    t.set = true;
+    t.midx = mon.midx;
+    t.grid = mon.grid;
+    return true;
+  } else if (t.fixed) {
+    t.midx = 0;
+    return true;
+  }
+
+  t.set = false;
+  t.midx = 0;
+  t.grid = loc(0, 0);
+  return false;
+}
+
+/** target_set_location (L180): target a legal (fully in-bounds) grid. */
+export function targetSetLocation(state: GameState, grid: Loc): void {
+  const t = state.target;
+  if (state.chunk.inBoundsFully(grid)) {
+    t.set = true;
+    t.midx = 0;
+    t.grid = grid;
+    return;
+  }
+  t.set = false;
+  t.midx = 0;
+  t.grid = loc(0, 0);
+}
+
+/** target_is_set (L203). */
+export function targetIsSet(state: GameState): boolean {
+  return state.target.set;
+}
+
+/** target_fix (L211): freeze the target for the duration of a spell. */
+export function targetFix(state: GameState): void {
+  const t = state.target;
+  t.oldMidx = t.midx;
+  t.oldGrid = t.grid;
+  t.fixed = true;
+}
+
+/**
+ * target_release (L220): unfreeze; if the old target is a now-dead (or no
+ * longer viewed) monster, cancel the grid.
+ */
+export function targetRelease(state: GameState): void {
+  const t = state.target;
+  t.fixed = false;
+  if (t.oldMidx !== 0) {
+    const mon = monsterAt(state, t.oldMidx);
+    if (!mon || !mon.race || !monsterIsInView(mon)) {
+      t.grid = loc(0, 0);
+    }
+  }
+}
+
+/** The approximate double distance cmp_distance (L240) sorts by. */
+function doubleDistance(from: Loc, to: Loc): number {
+  const kx = Math.abs(to.x - from.x);
+  const ky = Math.abs(to.y - from.y);
+  return kx > ky ? kx + kx + ky : ky + ky + kx;
+}
+
+/**
+ * target_pick (L276): from a set of interesting points, pick the closest
+ * in (roughly) the given direction from (x1, y1). Returns the index into
+ * `targets`, or -1. The look UI's direction-key cycling drives it.
+ */
+export function targetPick(
+  y1: number,
+  x1: number,
+  dy: number,
+  dx: number,
+  targets: readonly Loc[],
+): number {
+  let bI = -1;
+  let bV = 9999;
+
+  for (let i = 0; i < targets.length; i++) {
+    const x2 = targets[i]!.x;
+    const y2 = targets[i]!.y;
+
+    /* Directed distance. */
+    const x3 = x2 - x1;
+    const y3 = y2 - y1;
+
+    /* Verify quadrant. */
+    if (dx && x3 * dx <= 0) continue;
+    if (dy && y3 * dy <= 0) continue;
+
+    const x4 = Math.abs(x3);
+    const y4 = Math.abs(y3);
+
+    /* Verify quadrant. */
+    if (dy && !dx && x4 > y4) continue;
+    if (dx && !dy && y4 > x4) continue;
+
+    /* Approximate double distance. */
+    const v = x4 > y4 ? x4 + x4 + y4 : y4 + y4 + x4;
+
+    if (bI >= 0 && v >= bV) continue;
+    bI = i;
+    bV = v;
+  }
+
+  return bI;
+}
+
+/**
+ * target_accept (L325): is a grid "interesting" (the look/target scan
+ * stops on it)? Player grid, obvious monsters, visible traps, remembered
+ * objects and remembered interesting terrain qualify; hallucination blanks
+ * everything but the player.
+ */
+export function targetAccept(state: GameState, grid: Loc): boolean {
+  /* Player grids are always interesting. */
+  if (state.chunk.mon(grid) < 0) return true;
+
+  /* Handle hallucination. */
+  if ((state.actor.player.timed[TMD.IMAGE] ?? 0) > 0) return false;
+
+  /* Obvious monsters. */
+  const mon = squareMonster(state, grid);
+  if (mon && monsterIsObvious(mon)) return true;
+
+  /* Traps. */
+  if (squareIsVisibleTrap(state, grid)) return true;
+
+  /* Memorized objects (ignore_known_item_ok rides the ignore slice). */
+  if (knownObject(state, grid)) return true;
+
+  /* Interesting memorized features. */
+  if (squareIsInteresting(state, grid)) return true;
+
+  return false;
+}
+
+/**
+ * coords_desc (L370): a location relative to the player, e.g.
+ * "12 S, 35 W".
+ */
+export function coordsDesc(state: GameState, grid: Loc): string {
+  const p = state.actor.grid;
+  const ns = grid.y > p.y ? "S" : "N";
+  const ew = grid.x < p.x ? "W" : "E";
+  return `${Math.abs(grid.y - p.y)} ${ns}, ${Math.abs(grid.x - p.x)} ${ew}`;
+}
+
+/** target_get (L395): the currently targeted location. */
+export function targetGet(state: GameState): Loc {
+  return state.target.grid;
+}
+
+/** target_get_monster (L405): the currently targeted monster, or null. */
+export function targetGetMonster(state: GameState): Monster | null {
+  return monsterAt(state, state.target.midx);
+}
+
+/**
+ * target_sighted (L414): the current target is in line of sight. The panel
+ * test is the UI's (#25); an injected predicate stands in, defaulting to
+ * everything on-panel.
+ */
+export function targetSighted(
+  state: GameState,
+  panelContains: (grid: Loc) => boolean = () => true,
+): boolean {
+  if (!targetOkay(state)) return false;
+  const t = state.target;
+  if (!panelContains(t.grid)) return false;
+  /* Either the target is a grid and is visible, or it is a monster that
+   * is visible. */
+  if (!t.midx) return squareIsSeen(state.chunk, t.grid);
+  const mon = monsterAt(state, t.midx);
+  return !!mon && monsterIsVisible(mon);
+}
+
+/**
+ * target_get_monsters (L437): the interesting locations, sorted by
+ * distance to the player. With TARGET.KILL only target-able monsters
+ * matching `pred` are included. Panel restriction is injected (upstream's
+ * restrict_to_panel); absent, the scan covers max_range around the player
+ * as the upstream else-branch does.
+ */
+export function targetGetMonsters(
+  state: GameState,
+  mode: number,
+  pred?: (mon: Monster) => boolean,
+  panel?: { minY: number; minX: number; maxY: number; maxX: number },
+): Loc[] {
+  const p = state.actor.grid;
+  const minY = panel ? panel.minY : p.y - state.z.maxRange;
+  const maxY = panel ? panel.maxY : p.y + state.z.maxRange + 1;
+  const minX = panel ? panel.minX : p.x - state.z.maxRange;
+  const maxX = panel ? panel.maxX : p.x + state.z.maxRange + 1;
+
+  const targets: Loc[] = [];
+  for (let y = minY; y < maxY; y++) {
+    for (let x = minX; x < maxX; x++) {
+      const grid = loc(x, y);
+      if (!state.chunk.inBoundsFully(grid)) continue;
+      if (!targetAccept(state, grid)) continue;
+
+      if (mode & TARGET.KILL) {
+        const mon = squareMonster(state, grid);
+        if (!mon) continue;
+        if (!targetAble(state, mon)) continue;
+        if (pred && !pred(mon)) continue;
+      }
+
+      targets.push(grid);
+    }
+  }
+
+  targets.sort(
+    (a, b) => doubleDistance(p, a) - doubleDistance(p, b),
+  );
+  return targets;
+}
+
+/**
+ * target_set_closest (L493): target the closest (target-able, matching)
+ * monster, announcing it and tracking its health. Returns false (with
+ * "No Available Target.") when nothing qualifies.
+ */
+export function targetSetClosest(
+  state: GameState,
+  mode: number,
+  pred?: (mon: Monster) => boolean,
+): boolean {
+  /* Cancel old target. */
+  targetSetMonster(state, null);
+
+  const targets = targetGetMonsters(state, mode, pred);
+  if (targets.length < 1) {
+    state.msg?.("No Available Target.");
+    return false;
+  }
+
+  /* Find the first monster in the queue. */
+  const mon = squareMonster(state, targets[0]!);
+  if (!targetAble(state, mon)) {
+    state.msg?.("No Available Target.");
+    return false;
+  }
+
+  /* Target the monster: monster_desc(mon, MDESC_CAPITAL | MDESC_COMMA)
+   * (target.c L523). */
+  if (!(mode & TARGET.QUIET)) {
+    state.msg?.(
+      `${monsterDesc(mon!, MDESC.CAPITAL | MDESC.COMMA)} is targeted.`,
+    );
+  }
+
+  /* monster_race_track rides lore; health_track is the healthWho field. */
+  state.healthWho = mon;
+  targetSetMonster(state, mon);
+  return true;
+}

package/src/game/thrust.ts

@@ -0,0 +1,174 @@
+/**
+ * thrust_away, ported from reference/src/project-mon.c L87 (Angband 4.2.6):
+ * knock the player or a monster away from the source of a projection
+ * (PROJ_FORCE), travelling up to gridsAway grids along the caster-to-target
+ * angle (rejecting directions more than 44 degrees off), passing weaker
+ * occupants by swapping places, entering but not leaving passable
+ * non-projectable grids, and stopping at walls.
+ *
+ * The angle table is world/project.ts GET_ANGLE_TO_GRID (gen-util.c); the
+ * direction order is DDGRID_DDD, and the RNG draw (randint0(8) per step)
+ * matches upstream so a seeded run reproduces the path. The occupant
+ * strength rules are exact: a monster cannot pass a monster with more mexp
+ * or a character with lev*2 > its level; the player cannot pass a monster
+ * with level > lev*2.
+ *
+ * player_handle_post_move (FOV refresh, traps at the landing grid) is the
+ * injected onPlayerPostMove hook. C project-mon.c:184-187 / 210-212 only
+ * checks mon(grid)<0 after the swap (player displaced onto the vacated
+ * side). When the player is the thrust source at grid, mon is at next after
+ * the swap, so the port also fires when mon(next)<0 so a force-pushed
+ * player gets landing post-move effects. The lava message fires from
+ * square_isfiery; fire damage itself is the terrain-damage pass on movement.
+ */
+
+import { SQUARE } from "../generated/index.js";
+import { DDGRID_DDD, loc, locSum } from "../loc.js";
+import type { Loc } from "../loc.js";
+import { GET_ANGLE_TO_GRID } from "../world/project.js";
+import { monsterSwap } from "./context.js";
+import type { GameState } from "./context.js";
+
+/** The seams thrust_away needs beyond the GameState. */
+export interface ThrustEnv {
+  msg?: (text: string) => void;
+  /** player_handle_post_move(player, true, true) after the player moves. */
+  onPlayerPostMove?: () => void;
+}
+
+/**
+ * monster_swap for thrust: player actor.grid and player_leaving (delayed
+ * traps) are handled inside monsterSwap (mon-util.c:609-672).
+ */
+function swapOccupants(state: GameState, g1: Loc, g2: Loc): void {
+  monsterSwap(state, g1, g2);
+}
+
+/**
+ * The per-direction angle rejection (project-mon.c L110): each of the eight
+ * DDD directions covers a 44-degree window of the (half-)angle table.
+ */
+function angleRejects(k: number, angle: number): boolean {
+  switch (k) {
+    case 0: /* 135 */
+      return angle > 157 || angle < 114;
+    case 1: /* 45 */
+      return angle > 66 || angle < 23;
+    case 2: /* 0 */
+      return angle > 21 && angle < 159;
+    case 3: /* 90 */
+      return angle > 112 || angle < 68;
+    case 4: /* 158 */
+      return angle > 179 || angle < 136;
+    case 5: /* 113 */
+      return angle > 134 || angle < 91;
+    case 6: /* 22 */
+      return angle > 44 || angle < 1;
+    case 7: /* 67 */
+      return angle > 89 || angle < 46;
+    default:
+      return true;
+  }
+}
+
+/**
+ * thrust_away: force whatever occupies `target` away from `centre` for up to
+ * `gridsAway` grids.
+ */
+export function thrustAway(
+  state: GameState,
+  centre: Loc,
+  target: Loc,
+  gridsAway: number,
+  env: ThrustEnv = {},
+): void {
+  const c = state.chunk;
+
+  /* Determine where target is in relation to caster, extend. */
+  const rel = loc(target.x - centre.x + 20, target.y - centre.y + 20);
+  /* The angle (/2) of the line from caster to target. */
+  const angle = GET_ANGLE_TO_GRID[rel.y]?.[rel.x] ?? 0;
+
+  /* Start at the target grid. */
+  let grid = target;
+
+  for (let i = 0; i < gridsAway; i++) {
+    /* Randomize initial direction. */
+    const firstD = state.rng.randint0(8);
+
+    /* Look around (two possibilities for most angles). */
+    for (let d = firstD; d < 8 + firstD; d++) {
+      const k = d % 8;
+      /* Reject angles more than 44 degrees from desired direction. */
+      if (angleRejects(k, angle)) continue;
+
+      /* Extract adjacent location */
+      const next = locSum(grid, DDGRID_DDD[k]!);
+      if (!c.inBounds(next)) continue;
+
+      /* There's someone there, try to switch places. */
+      if (c.mon(next) !== 0) {
+        /* A monster is trying to pass. */
+        if (c.mon(grid) > 0) {
+          const mon = state.monsters[c.mon(grid)];
+          if (c.mon(next) > 0) {
+            const mon1 = state.monsters[c.mon(next)];
+            /* Monsters cannot pass by stronger monsters. */
+            if (mon && mon1 && mon1.race.mexp > mon.race.mexp) continue;
+          } else {
+            /* Monsters cannot pass by stronger characters. */
+            if (mon && state.actor.player.lev * 2 > mon.race.level) continue;
+          }
+        }
+
+        /* The player is trying to pass. */
+        if (c.mon(grid) < 0 && c.mon(next) > 0) {
+          const mon1 = state.monsters[c.mon(next)];
+          /* Players cannot pass by stronger monsters. */
+          if (mon1 && mon1.race.level > state.actor.player.lev * 2) continue;
+        }
+      }
+
+      /* Check for obstruction. */
+      if (!c.isProjectable(next)) {
+        /* Some features allow entrance, but not exit. */
+        if (c.isPassable(next)) {
+          /* Travel down the path. */
+          swapOccupants(state, grid, next);
+          /*
+           * project-mon.c:184-187: C fires when mon(grid)<0 after swap
+           * (player was at next). Also fire when mon(next)<0 so a player
+           * thrust from grid still gets player_handle_post_move landing.
+           */
+          if (c.mon(grid) < 0 || c.mon(next) < 0) env.onPlayerPostMove?.();
+
+          /* Jump to new location; we can't travel any more. */
+          grid = next;
+          i = gridsAway;
+          break;
+        } else if (d === 8 + firstD - 1) {
+          /* If there are walls everywhere, stop here. */
+          if (c.mon(grid) < 0) env.msg?.("You come to rest next to a wall.");
+          i = gridsAway;
+        }
+      } else {
+        /* Travel down the path. */
+        swapOccupants(state, grid, next);
+        /* project-mon.c:210-212 + player-at-grid landing (see above). */
+        if (c.mon(grid) < 0 || c.mon(next) < 0) env.onPlayerPostMove?.();
+
+        /* Jump to new location. */
+        grid = next;
+        break;
+      }
+    }
+  }
+
+  /* Some special messages or effects for player or monster. */
+  if (c.isFiery(grid) && c.mon(grid) < 0) {
+    env.msg?.("You are thrown into molten lava!");
+  }
+
+  /* Clear the projection mark. */
+  c.sqinfoOff(grid, SQUARE.PROJECT);
+}