@rpgm-tools/neo-angband-core 0.10.0

package/dist/game/monster-turn.d.ts

@@ -0,0 +1,195 @@
+/**
+ * process_monster and the mon-move.c monster AI, ported from
+ * reference/src/mon-move.c (Angband 4.2.6) as faithfully as the ported
+ * subset of the world allows.
+ *
+ * PORTED:
+ * - get_move_find_range: min_range / best_range (fear flight distance, the
+ *   level/health comparison that scares weak monsters, the never-move /
+ *   never-blow stand-off bonus, turn_range "nearby monsters won't run").
+ * - get_move_advance: pass-wall beeline, line-of-sight beeline, then sound
+ *   (the cave->noise flow heatmap from world/flow) with the cardinal-first
+ *   8-direction scan, then scent. This is the flow-following core.
+ * - get_move: advance vs. the tracking fallback / random step, the afraid
+ *   flee branch, get_move_choose_direction (the vertical/horizontal/diagonal
+ *   preference with the turn-parity tie-break), MFLAG_TRACKING.
+ * - monster_turn_should_stagger: RAND_25 / RAND_50 erratic movement and the
+ *   confusion staggers (CONF_ERRATIC_CHANCE per confusion grade).
+ * - monster_turn: the 5-step side_dirs movement loop, the tracking early-out,
+ *   NEVER_MOVE, attack the player via combat.monMeleeAttack, push past / kill
+ *   a blocking monster, and the "paralysed by fear" fallback.
+ * - process_monster_timed (sleep/wake, timer decrement, hold/stun miss) and
+ *   monster_check_active.
+ *
+ * NOW WIRED (was deferred): make_ranged_attack via the state.monsterCast
+ * hook, monster_group_rouse before it, and group_monster_tracking in
+ * get_move's fallback branch.
+ *
+ * NOW PORTED (this pass, one coherent RNG-order-preserving change):
+ * - Fleeing geometry: get_move_find_safety (the dist_offsets ring scan for a
+ *   reachable out-of-view grid) and the swerving get_move_flee, wired into the
+ *   afraid branch of get_move exactly as upstream (find_safety -> flee for a
+ *   course, else leg it away). Both draw no RNG.
+ * - Terrain manipulation in monster_turn_can_move: OPEN_DOOR / BASH_DOOR
+ *   (with the confused one_in_(3) bash chance, the one_in_(2) open-vs-bash
+ *   choice, and the locked-door randint0(hp/10) strength test seamed to the
+ *   trap system) and KILL_WALL / SMASH_WALL (square_smash_wall's per-adjacent
+ *   granite/quartz/magma survival rolls) / PASS_WALL, plus the confused-move
+ *   self-stun. The "can move here" predicate stays distinct from "did the
+ *   terrain action" (the did-something flag that spends the turn).
+ * - Reproduction: monster_turn_multiply (the num_repro cap, arena block, the
+ *   3x3 neighbour count and the one_in_(k * repro_monster_rate) chance) calling
+ *   multiply_monster through the state.monsterMultiply hook. Runs before the
+ *   ranged attack, matching upstream's process_monster order.
+ * - Item pickup/crush: monster_turn_grab_objects (TAKE_ITEM copies the floor
+ *   object into the monster's held pile, KILL_ITEM crushes it; gold, mimics and
+ *   artifacts are left; draws no RNG).
+ * - Aggravation: monster_reduce_sleep consults player OF_AGGRAVATE first and
+ *   wakes the monster (drawing monster_wake's randint0(100) instead of the
+ *   notice roll), matching the upstream if/else.
+ * - Camouflage/mimic reveal: monster_turn_try_push reveals a camouflaged
+ *   blocker before it is trampled (mon-move.c L1352), and monster_turn itself
+ *   reveals a camouflaged mon that did_something on its turn (L1680), both via
+ *   the injected state.becomeAware hook (game/known.ts becomeAware, installed
+ *   by session/game.ts). monster_turn_multiply's "reveal a camouflaged child
+ *   of an already-revealed breeder" (L1002-1011) is ported alongside it in
+ *   game/mon-place.ts multiplyMonster. Draws no RNG.
+ *
+ * NOW PORTED (this pass):
+ * - Group AI: get_move_bodyguard (a bodyguard stays adjacent to its group
+ *   leader, wired into the top of get_move_advance) and the RF_GROUP_AI pack
+ *   ambush branch of get_move (the open-grid count around the player, then
+ *   get_move_find_hiding - the flow/projectable ring scan that finds a hidden
+ *   grid to lie in wait). Both draw no RNG.
+ * - Damaging terrain (square_isdamaging is feat_is_fiery / lava in 4.2.6, and
+ *   lava with resist-flag IM_FIRE IS modelled): monster_hates_grid (avoid it in
+ *   advance/random/find_safety/bodyguard/can_move) and monster_taking_terrain_
+ *   damage (the get_move terrain-flight branch, the get_move_flee early-out, and
+ *   the monster_check_active activation). All draw no RNG.
+ * - Glyph: monster_turn_attack_glyph (a monster on a warded grid rolls
+ *   randint1(glyph_hardness) < level to break the ward). Decoy: monster is
+ *   decoyed -> target the decoy (get_move_advance / get_move), attack-allowed in
+ *   can_move, and square_destroy_decoy when stepped on (draws no RNG; the decoy
+ *   is disambiguated from a glyph of warding by cave->decoy since both traps
+ *   share the GLYPH flag). Web: a webbed monster passes / clears / is stuck by
+ *   RF_PASS_WEB / RF_CLEAR_WEB / pass-walls (draws no RNG).
+ *
+ * DEFERRED (ledgered in parity/ledger/game-monster-ai.yaml):
+ * - monster_take_terrain_damage (the actual lava damage after the turn, called
+ *   from process_monster, not monster_turn): needs mon_take_nonplayer_hit
+ *   (monster_death / delete_monster_idx), which is not ported; only the
+ *   movement-driving predicate is ported here.
+ * - react_to_slay pickup safety, the confused-move / door-burst / glyph-break /
+ *   decoy-destroy UI messages and disturb, and the remaining monster-lore
+ *   updates. None of these draw RNG until taken, so the RNG order for the ported
+ *   paths is unaffected.
+ */
+import type { Loc } from "../loc.js";
+import type { Monster } from "../mon/monster.js";
+import type { GameState } from "./context.js";
+/** enum monster_stagger. */
+export declare const STAGGER: {
+    readonly NO: 0;
+    readonly CONFUSED: 1;
+    readonly INNATE: 2;
+};
+export type Stagger = (typeof STAGGER)[keyof typeof STAGGER];
+/**
+ * The PROJECT_SHORT projection range (project.c L370-373): max_range, quartered
+ * while the player covers tracks (TMD_COVERTRACKS). The port's projectable takes
+ * the range from the caller, so PROJECT.SHORT callers pass this.
+ */
+export declare function shortRange(state: GameState): number;
+/**
+ * monster_near_permwall (mon-move.c L65): whether a PASS_WALL / KILL_WALL
+ * monster should use the flow code instead of beelining - the player is out of
+ * (short) projection range and the direct PROJECT_ROCK path hits a permanent
+ * wall before reaching the player. Draws randint0(99) for the "occasionally
+ * flow for a turn anyway" 5% branch, exactly at the upstream stream position.
+ */
+export declare function monsterNearPermwall(mon: Monster, state: GameState): boolean;
+/**
+ * monster_is_decoyed (mon-predicate.c L308): a live decoy exists and the monster
+ * has line of sight to it. Draws no RNG.
+ */
+export declare function monsterIsDecoyed(mon: Monster, state: GameState): boolean;
+/**
+ * get_move_find_range (mon-move.c L207): set mon.minRange (flee distance) and
+ * mon.bestRange (preferred combat distance) - archers sit back +3, breathers
+ * with high innate frequency like point blank, other frequent casters sit back
+ * +3 (mon-move.c L287-300).
+ */
+export declare function getMoveFindRange(mon: Monster, state: GameState): void;
+/**
+ * get_move_bodyguard (mon-move.c L309): a bodyguard stays close to its group
+ * leader, but takes a step that is also closer to the player when it can. Sets
+ * mon.target.grid and returns true on success. Draws no RNG - the scan order is
+ * ddgrid_ddd and the tie-break is upstream's (first closer-to-leader grid, and a
+ * grid that is also closer to the player short-circuits the scan).
+ */
+export declare function getMoveBodyguard(mon: Monster, state: GameState): boolean;
+/**
+ * get_move_choose_direction: keypad direction (as a side_dirs row index)
+ * from an offset, with the turn-parity tie-break exactly as upstream.
+ */
+export declare function getMoveChooseDirection(offset: Loc, turn: number): number;
+/**
+ * get_move_find_hiding (mon-move.c L613): a pack monster looks for a hidden grid
+ * (out of the player's view but projectable from the monster) to lie in wait and
+ * lure the player into the open. Prefers the closest such grid that is still at
+ * least `min` away from the player, spreading outward a distance ring at a time.
+ * Sets mon.target.grid and returns true on success. Pure scan - draws no RNG.
+ * `gdis` persists across rings (as upstream) but the per-ring success return
+ * makes that moot; the dist_offsets ring order fixes the tie-break.
+ */
+export declare function getMoveFindHiding(mon: Monster, state: GameState): boolean;
+/** The outcome of get_move. */
+interface MoveDecision {
+    move: boolean;
+    /** side_dirs row index (0 when !move). */
+    dir: number;
+    /** *good / tracking: the move came from sound/scent tracking. */
+    tracking: boolean;
+}
+/**
+ * get_move: decide whether and where the monster wants to step. Returns the
+ * side_dirs row index for the movement loop. The RF_GROUP_AI pack-ambush branch
+ * (get_move_find_hiding) and the group-surround branch (mon-move.c L932, which
+ * draws randint0(8)) are both ported, so the RNG draw order matches upstream.
+ */
+export declare function getMove(mon: Monster, state: GameState): MoveDecision;
+/**
+ * monster_turn_should_stagger: whether the monster steps at random this turn
+ * (confusion staggers, then the cumulative RAND_25 / RAND_50 chances).
+ */
+export declare function monsterTurnShouldStagger(mon: Monster, state: GameState): Stagger;
+/**
+ * monster_turn_multiply (mon-move.c L1025): every monster is checked here so
+ * the RF_MULTIPLY lore is learnt when the crowd roll passes; only breeders that
+ * find room actually reproduce. Returns true if reproduction spent the turn.
+ *
+ * RNG order is exact: the level cap and arena gate draw nothing, then the 3x3
+ * neighbour count (k, which always includes the monster itself so k >= 1), then
+ * one_in_(k * repro_monster_rate) - and only on a passing roll does the breeder
+ * gate and multiply_monster (via the state.monsterMultiply hook) run.
+ */
+export declare function monsterTurnMultiply(mon: Monster, state: GameState): boolean;
+/**
+ * monster_turn: the monster acts. A ranged attack (spell / breath) is attempted
+ * first through the injected state.monsterCast hook (make_ranged_attack, wired by
+ * game/mon-ranged.ts installMonsterCasting); when it spends the turn we stop
+ * here, exactly as upstream's `if (make_ranged_attack(mon)) return;`.
+ * Item pickup, group behaviour and lore are partially DEFERRED (see the module
+ * header); this ports the movement/attack core plus web/glyph/decoy handling.
+ */
+export declare function monsterTurn(mon: Monster, state: GameState): void;
+/**
+ * process_monster_timed: decrement timed effects, wake sleepers. Returns
+ * true if the monster skips its turn (asleep, held, commanded, or a stunned
+ * miss). Message plumbing and lore are DEFERRED.
+ */
+export declare function processMonsterTimed(mon: Monster, state: GameState): boolean;
+/** monster_check_active: set/clear MFLAG_ACTIVE, return whether active. */
+export declare function monsterCheckActive(mon: Monster, state: GameState): boolean;
+export {};
+//# sourceMappingURL=monster-turn.d.ts.map

package/dist/game/monster-turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monster-turn.d.ts","sourceRoot":"","sources":["../../src/game/monster-turn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAcrC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAwCjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAyB9C,4BAA4B;AAC5B,eAAO,MAAM,OAAO;;;;CAIV,CAAC;AACX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,OAAO,OAAO,CAAC,CAAC;AAmH7D;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAInD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAqB3E;AAkFD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAIxE;AAiBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CA+DrE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CA6CxE;AA+GD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAyCxE;AAyFD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CA4CzE;AAED,+BAA+B;AAC/B,UAAU,YAAY;IACpB,IAAI,EAAE,OAAO,CAAC;IACd,0CAA0C;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,iEAAiE;IACjE,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,YAAY,CAqHpE;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,SAAS,GACf,OAAO,CAkBT;AA4PD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAoC3E;AA4GD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CA+LhE;AAwDD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CA+C3E;AAED,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAkB1E"}