@rpgm-tools/neo-angband-core 0.10.0

package/dist/game/inscription-confirm.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The `!` / `^` inscription safety net - Angband's oldest and most-used way of
+ * protecting yourself from your own fingers. Inscribe `!q` on a Potion of Death
+ * and quaffing it asks first; `^t` on your body armour and every Take off asks;
+ * `!*` or `^*` covers every command at once.
+ *
+ * Two upstream functions, both of which the port was missing entirely:
+ *
+ * - `key_confirm_command` (ui-input.c:1995-2020) scans the WORN EQUIPMENT for
+ *   `^*` and `^<key>` and asks "Are you sure? " once per occurrence found, before
+ *   the command key is turned into a command at all (ui-game.c:565; also
+ *   ui-context.c:155, :349, :353, :585 for the context menus).
+ * - `get_item_allow` (ui-object.c:634-679) scans the SELECTED OBJECT for
+ *   `!<key>` - plus `!*` unless the command is harmless - and asks
+ *   verify_object's "Really <verb> <the object>? " once per occurrence, from the
+ *   item menu as a row is chosen (ui-object.c:958) and from the context menu's
+ *   object actions (ui-context.c:855).
+ *
+ * The census found only "Are you sure? " here, because get_item_allow's prompt
+ * is assembled by strnfmt and its literal fragments ("Really ", " %s? ") are
+ * shorter than the anchor floor. The behaviour behind the one string it did find
+ * is the whole feature.
+ *
+ * Both are pure counts and strings: core decides how many confirmations are owed
+ * and what to say, and the shell awaits them, the same division walkTerrainPrompt
+ * uses (game/player-turn.ts) because the core command path cannot block on UI.
+ */
+import type { Player } from "../player/player.js";
+import type { GameObject } from "../obj/object.js";
+import type { Gear } from "./gear.js";
+import type { CommandCode } from "../cmd.js";
+/** get_check's prompt in key_confirm_command (ui-input.c:2014), verbatim. */
+export declare const KEY_CONFIRM_PROMPT = "Are you sure? ";
+/** cmd_verb's fallback when a command has no verb (ui-object.c:664-665). */
+export declare const ITEM_ALLOW_FALLBACK_VERB = "do that with";
+/**
+ * UN_KTRL_CAP (ui-event.h:135): a control code becomes its CAPITAL letter, not
+ * the lower-case one UN_KTRL would give. The comment there explains why - the
+ * roguelike ignore command is Ctrl-D, and UN_KTRL would turn that into 'd', the
+ * drop command in both keysets, so `!d` would fire on an ignore.
+ */
+export declare function unKtrlCap(key: string): string;
+/**
+ * key_confirm_command (ui-input.c:1995-2020): how many times "Are you sure? "
+ * must be answered before command key `key` may run. Zero almost always.
+ *
+ * Upstream asks per equipment slot and aborts on the first refusal, so a total
+ * is equivalent - every prompt must be accepted for the command to proceed.
+ *
+ * The `key === "*"` case counts DOUBLE, and that is upstream's arithmetic, not a
+ * slip here: verify_inscrip starts life as the string "^*" and only its second
+ * byte is overwritten, so for '*' both terms of the sum count the same
+ * inscription. Kept because core keeps upstream's warts.
+ *
+ * `key` is used RAW - no unKtrlCap. get_item_allow shifts a control code to its
+ * capital and this function pointedly does not, so a roguelike Ctrl-chord looks
+ * for a `^` plus a control byte, which no inscription can hold, and asks nothing.
+ * That asymmetry is upstream's; do not tidy it.
+ */
+export declare function keyConfirmCount(player: Player, gear: Gear, key: string): number;
+/** What get_item_allow owes: a prompt and how many times to ask it. */
+export interface ItemAllowPrompt {
+    /** verify_object's finished question (obj-util.c:1085), trailing space and all. */
+    readonly prompt: string;
+    /** How many matching inscriptions were found; each one asks again. */
+    readonly count: number;
+}
+/**
+ * get_item_allow (ui-object.c:634-679): the confirmations `obj` demands before
+ * command key `key` may act on it, or null when it demands none.
+ *
+ * `isHarmless` is upstream's IS_HARMLESS flag - a harmless command (inspecting,
+ * for instance) ignores a blanket `!*` but still honours its own `!<key>`.
+ *
+ * `describe` is object_desc(ODESC_PREFIX | ODESC_FULL) (obj-util.c:1082); the
+ * shell passes its own namer so the format string stays here, next to the C
+ * line it copies.
+ */
+export declare function itemAllowPrompt(obj: GameObject, key: string, cmd: CommandCode | null, isHarmless: boolean, describe: (obj: GameObject) => string): ItemAllowPrompt | null;
+//# sourceMappingURL=inscription-confirm.d.ts.map

package/dist/game/inscription-confirm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inscription-confirm.d.ts","sourceRoot":"","sources":["../../src/game/inscription-confirm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAI7C,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB,mBAAmB,CAAC;AAEnD,4EAA4E;AAC5E,eAAO,MAAM,wBAAwB,iBAAiB,CAAC;AAEvD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAS/E;AAED,uEAAuE;AACvE,MAAM,WAAW,eAAe;IAC9B,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,UAAU,EACf,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,WAAW,GAAG,IAAI,EACvB,UAAU,EAAE,OAAO,EACnB,QAAQ,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,MAAM,GACpC,eAAe,GAAG,IAAI,CASxB"}

package/dist/game/inscription-confirm.js

@@ -0,0 +1,95 @@
+/**
+ * The `!` / `^` inscription safety net - Angband's oldest and most-used way of
+ * protecting yourself from your own fingers. Inscribe `!q` on a Potion of Death
+ * and quaffing it asks first; `^t` on your body armour and every Take off asks;
+ * `!*` or `^*` covers every command at once.
+ *
+ * Two upstream functions, both of which the port was missing entirely:
+ *
+ * - `key_confirm_command` (ui-input.c:1995-2020) scans the WORN EQUIPMENT for
+ *   `^*` and `^<key>` and asks "Are you sure? " once per occurrence found, before
+ *   the command key is turned into a command at all (ui-game.c:565; also
+ *   ui-context.c:155, :349, :353, :585 for the context menus).
+ * - `get_item_allow` (ui-object.c:634-679) scans the SELECTED OBJECT for
+ *   `!<key>` - plus `!*` unless the command is harmless - and asks
+ *   verify_object's "Really <verb> <the object>? " once per occurrence, from the
+ *   item menu as a row is chosen (ui-object.c:958) and from the context menu's
+ *   object actions (ui-context.c:855).
+ *
+ * The census found only "Are you sure? " here, because get_item_allow's prompt
+ * is assembled by strnfmt and its literal fragments ("Really ", " %s? ") are
+ * shorter than the anchor floor. The behaviour behind the one string it did find
+ * is the whole feature.
+ *
+ * Both are pure counts and strings: core decides how many confirmations are owed
+ * and what to say, and the shell awaits them, the same division walkTerrainPrompt
+ * uses (game/player-turn.ts) because the core command path cannot block on UI.
+ */
+import { cmdVerb } from "../cmd.js";
+import { checkForInscrip } from "./pickup.js";
+/** get_check's prompt in key_confirm_command (ui-input.c:2014), verbatim. */
+export const KEY_CONFIRM_PROMPT = "Are you sure? ";
+/** cmd_verb's fallback when a command has no verb (ui-object.c:664-665). */
+export const ITEM_ALLOW_FALLBACK_VERB = "do that with";
+/**
+ * UN_KTRL_CAP (ui-event.h:135): a control code becomes its CAPITAL letter, not
+ * the lower-case one UN_KTRL would give. The comment there explains why - the
+ * roguelike ignore command is Ctrl-D, and UN_KTRL would turn that into 'd', the
+ * drop command in both keysets, so `!d` would fire on an ignore.
+ */
+export function unKtrlCap(key) {
+    const code = key.charCodeAt(0);
+    return code < 0x20 ? String.fromCharCode(code + 64) : key;
+}
+/**
+ * key_confirm_command (ui-input.c:1995-2020): how many times "Are you sure? "
+ * must be answered before command key `key` may run. Zero almost always.
+ *
+ * Upstream asks per equipment slot and aborts on the first refusal, so a total
+ * is equivalent - every prompt must be accepted for the command to proceed.
+ *
+ * The `key === "*"` case counts DOUBLE, and that is upstream's arithmetic, not a
+ * slip here: verify_inscrip starts life as the string "^*" and only its second
+ * byte is overwritten, so for '*' both terms of the sum count the same
+ * inscription. Kept because core keeps upstream's warts.
+ *
+ * `key` is used RAW - no unKtrlCap. get_item_allow shifts a control code to its
+ * capital and this function pointedly does not, so a roguelike Ctrl-chord looks
+ * for a `^` plus a control byte, which no inscription can hold, and asks nothing.
+ * That asymmetry is upstream's; do not tidy it.
+ */
+export function keyConfirmCount(player, gear, key) {
+    let n = 0;
+    for (let i = 0; i < player.body.count; i++) {
+        const handle = player.equipment[i] ?? 0;
+        const obj = handle ? gear.store.get(handle) : undefined;
+        if (!obj)
+            continue;
+        n += checkForInscrip(obj, "^*") + checkForInscrip(obj, `^${key}`);
+    }
+    return n;
+}
+/**
+ * get_item_allow (ui-object.c:634-679): the confirmations `obj` demands before
+ * command key `key` may act on it, or null when it demands none.
+ *
+ * `isHarmless` is upstream's IS_HARMLESS flag - a harmless command (inspecting,
+ * for instance) ignores a blanket `!*` but still honours its own `!<key>`.
+ *
+ * `describe` is object_desc(ODESC_PREFIX | ODESC_FULL) (obj-util.c:1082); the
+ * shell passes its own namer so the format string stays here, next to the C
+ * line it copies.
+ */
+export function itemAllowPrompt(obj, key, cmd, isHarmless, describe) {
+    const ch = unKtrlCap(key);
+    let count = checkForInscrip(obj, `!${ch}`);
+    if (!isHarmless)
+        count += checkForInscrip(obj, "!*");
+    if (!count)
+        return null;
+    const verb = (cmd ? cmdVerb(cmd) : null) ?? ITEM_ALLOW_FALLBACK_VERB;
+    /* strnfmt "Really %s" (ui-object.c:667) then verify_object's "%s %s? "
+     * (obj-util.c:1085) - one prompt built in two steps upstream. */
+    return { prompt: `Really ${verb} ${describe(obj)}? `, count };
+}
+//# sourceMappingURL=inscription-confirm.js.map

package/dist/game/inscription-confirm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inscription-confirm.js","sourceRoot":"","sources":["../../src/game/inscription-confirm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAMH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,6EAA6E;AAC7E,MAAM,CAAC,MAAM,kBAAkB,GAAG,gBAAgB,CAAC;AAEnD,4EAA4E;AAC5E,MAAM,CAAC,MAAM,wBAAwB,GAAG,cAAc,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,GAAW;IACnC,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAC/B,OAAO,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AAC5D,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAAC,MAAc,EAAE,IAAU,EAAE,GAAW;IACrE,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACxC,MAAM,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACxD,IAAI,CAAC,GAAG;YAAE,SAAS;QACnB,CAAC,IAAI,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,eAAe,CAAC,GAAG,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;IACpE,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAUD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAC7B,GAAe,EACf,GAAW,EACX,GAAuB,EACvB,UAAmB,EACnB,QAAqC;IAErC,MAAM,EAAE,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;IAC1B,IAAI,KAAK,GAAG,eAAe,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;IAC3C,IAAI,CAAC,UAAU;QAAE,KAAK,IAAI,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IACrD,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,wBAAwB,CAAC;IACrE;qEACiE;IACjE,OAAO,EAAE,MAAM,EAAE,UAAU,IAAI,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC;AAChE,CAAC"}

package/dist/game/known.d.ts

@@ -0,0 +1,297 @@
+/**
+ * The player's map knowledge, a reduction of the upstream player->cave twin
+ * chunk (cave.c cave_know_*, cave-square.c square_memorize / square_forget /
+ * square_know_pile / square_sense_pile, and cave-view.c note_spot).
+ *
+ * Upstream duplicates the whole chunk for the player's knowledge so memory
+ * can go stale (you remember the door you saw, not the open floor it has
+ * since become). This port keeps the same staleness property with a flat
+ * remembered-feat array plus a remembered-floor-object marker per grid;
+ * that is exactly what detection, magic mapping and the renderer's
+ * remembered-terrain display need. The full twin (known traps as objects,
+ * per-object known twins) rides later batches and is ledgered.
+ *
+ * noteSpots() is the note_spot pass over the current field of view: every
+ * SEEN grid is memorized with its floor pile. It then runs updateMonsters()
+ * - the faithful port of update_mon (mon-util.c) - to refresh every live
+ * monster's visibility flags from telepathy, infravision, see-invisible and
+ * illumination. The session and front end call it after every updateView.
+ *
+ * update_mon only READS MFLAG_MARK; the detection-fade lifecycle
+ * (MFLAG_MARK / MFLAG_SHOW clearing, game-world.c process_world) lives in
+ * tickMonsterMarks() until the world-clock port absorbs it.
+ */
+import type { Loc } from "../loc.js";
+import { type ViewerState } from "../world/view.js";
+import type { Monster } from "../mon/monster.js";
+import type { GameObject } from "../obj/object.js";
+import type { GameState } from "./context.js";
+/**
+ * A remembered floor object: the pile head's display glyph, or a null
+ * glyph for a sensed-but-unidentified something (upstream's
+ * unknown_item_kind / unknown_gold_kind markers).
+ */
+export interface KnownObjectMemory {
+    /** Display char of the remembered pile head; null = sensed-unknown. */
+    ch: string | null;
+    /** Display color char of the remembered pile head. */
+    attr: string;
+}
+/** The player's knowledge of the current level. */
+export interface KnownMap {
+    width: number;
+    height: number;
+    /** Remembered feat per grid; -1 = unknown. May be stale, as upstream. */
+    feat: Int16Array;
+    /** Remembered floor objects by grid index (y * width + x). */
+    objects: Map<number, KnownObjectMemory>;
+}
+/** A blank (all-unknown) knowledge map for a fresh level. */
+export declare function newKnownMap(width: number, height: number): KnownMap;
+/** square_memorize: remember the grid's current terrain. */
+export declare function squareMemorize(state: GameState, grid: Loc): void;
+/**
+ * square_forget (cave-square.c:1580-1583): forget the grid's TERRAIN only.
+ * Upstream is `square_set_known_feat(c, grid, FEAT_NONE)` and nothing else -
+ * it does not touch the remembered object pile, and map_info's object loop
+ * (cave-map.c:155-169) is NOT gated on square_isknown, so an object remembered
+ * on a grid whose terrain has been forgotten stays on the player's map. The
+ * remembered pile is dropped only by forget_remembered_objects, i.e. through
+ * squareKnowPile / squareSensePile.
+ */
+export declare function squareForget(state: GameState, grid: Loc): void;
+/**
+ * cave_illuminate (cave-map.c L555), the runtime version: the generation-time
+ * flag subset (gen/cave.ts caveIlluminate) plus the player-knowledge half
+ * (square_memorize / square_forget), gated per grid on the same "light" test
+ * upstream computes over the 9-entry ddgrid_ddd (the 8 neighbors plus self,
+ * cave.c L72-73): a floor or stairs grid nearby makes the boundary worth
+ * remembering. RNG-free.
+ *
+ * DEFERRED: PU_UPDATE_VIEW | PU_MONSTERS and the PR_MAP / PR_MONLIST /
+ * PR_ITEMLIST redraws (cave-map.c L608-612) - the front end's updateView +
+ * noteSpots pass already runs unconditionally after every state-changing
+ * action (packages/web/src/main.ts), so there is no separate dirty-flag
+ * mechanism to set here, matching the other knowledge-writing effect handlers
+ * (game/effect-detect.ts) which don't re-trigger it either.
+ */
+export declare function caveIlluminateKnown(state: GameState, daytime: boolean): void;
+/**
+ * cave_known (cave-map.c:633-660): memorize town terrain except interior
+ * wall/lava regions.
+ *
+ * MUST run BEFORE caveIlluminateKnown, as generate.c:1547-1550 does. The order
+ * is load-bearing and not interchangeable: cave_illuminate writes player memory
+ * too -- square_memorize at cave-map.c:582 and, at night, square_forget on
+ * boring floor grids at :586-587. So upstream deliberately memorizes the whole
+ * town here and then lets night-time illumination FORGET the boring floors
+ * again. Running this second would leave a night town fully mapped, which is the
+ * opposite of upstream.
+ */
+export declare function caveKnown(state: GameState): void;
+/** square_isknown: the player remembers some terrain here. */
+export declare function squareIsKnown(state: GameState, grid: Loc): boolean;
+/** The remembered feat at a grid (-1 = unknown). */
+export declare function knownFeat(state: GameState, grid: Loc): number;
+/**
+ * square_isbelievedwall (cave-square.c L901-912): out-of-bounds is a wall,
+ * unknown terrain is not believed to be a wall, and known terrain is tested
+ * against the remembered feature rather than the live map.
+ */
+export declare function squareIsBelievedWall(state: GameState, grid: Loc): boolean;
+/**
+ * square_isrubble(player->cave, grid): is the terrain the player REMEMBERS here
+ * rubble? Upstream freely runs the square predicates against player->cave to
+ * ask "what does the player think is there", which is how the bump-into-terrain
+ * paths decide whether their message contradicts the player's memory
+ * (cmd-cave.c:1112, :1243). Unknown terrain is not remembered as anything.
+ */
+export declare function knownIsRubble(state: GameState, grid: Loc): boolean;
+/**
+ * square_isperm(player->cave, grid): PERMANENT and ROCK, remembered.
+ * do_cmd_tunnel_test MEMORIZES rather than forgets on this one - hitting
+ * permanent rock the player did not know about teaches them it is there
+ * (cmd-cave.c:462-468).
+ */
+export declare function knownIsPerm(state: GameState, grid: Loc): boolean;
+/** square_isopendoor(player->cave, grid): a remembered closable door. */
+export declare function knownIsOpenDoor(state: GameState, grid: Loc): boolean;
+/** square_isbrokendoor(player->cave, grid): remembered, passable, unclosable. */
+export declare function knownIsBrokenDoor(state: GameState, grid: Loc): boolean;
+/**
+ * square_isdiggable(player->cave, grid): remembered mineral wall, secret door
+ * or rubble - square_ismineral || square_issecretdoor || square_isrubble
+ * (cave-square.c), evaluated on the remembered feature index.
+ */
+export declare function knownIsDiggable(state: GameState, grid: Loc): boolean;
+/**
+ * square_iscloseddoor(player->cave, grid): does the player REMEMBER a closed
+ * door here? The open / close / disarm tests use it to spot a stale memory - a
+ * remembered door where the real grid has none is forgotten rather than left to
+ * mislead the map (cmd-cave.c:160-163, :243-246).
+ */
+export declare function knownIsClosedDoor(state: GameState, grid: Loc): boolean;
+/**
+ * square_ispassable || square_isrubble || square_iscloseddoor on player->cave
+ * (cmd-cave.c:1126-1128, :1253-1255): the player remembers something they could
+ * have walked into here. Discovering a wall instead means the memory was wrong
+ * and upstream forgets the grid.
+ */
+export declare function knownIsEnterable(state: GameState, grid: Loc): boolean;
+/**
+ * square_ismemorybad: the player remembers terrain here that no longer
+ * matches the live cave.
+ */
+export declare function squareMemoryBad(state: GameState, grid: Loc): boolean;
+/**
+ * square_apparent_name (cave-square.c): the mimic-resolved name of the
+ * grid's remembered terrain (the look/target UI's "You see <name>").
+ */
+export declare function squareApparentName(state: GameState, grid: Loc): string;
+/**
+ * square_apparent_look_prefix (cave-square.c): the indefinite article (or a
+ * feature-specific override) that precedes squareApparentName. Overrides are
+ * reproduced verbatim from terrain.txt, trailing space and all - stores'
+ * "the entrance to the " carries one, LAVA's "some" does not (upstream data,
+ * not a port bug).
+ */
+export declare function squareApparentLookPrefix(state: GameState, grid: Loc): string;
+/**
+ * square_apparent_look_in_preposition (cave-square.c): the preposition (or a
+ * feature-specific override) used for the player's own grid ("You are
+ * <preposition><name>."). Overrides are reproduced verbatim from terrain.txt
+ * (e.g. doors' "in" carries no trailing space, unlike the "on " default).
+ */
+export declare function squareApparentLookInPreposition(state: GameState, grid: Loc): string;
+/**
+ * square_isinteresting (cave-square.c), read against the player's knowledge
+ * (as target_accept and the look UI's terrain handler do): a memorized grid
+ * whose feature carries TF_INTERESTING.
+ */
+export declare function squareIsInteresting(state: GameState, grid: Loc): boolean;
+/** The remembered floor object at a grid, if any. */
+export declare function knownObject(state: GameState, grid: Loc): KnownObjectMemory | null;
+/**
+ * square_know_pile (reduced): remember the (first matching) floor object
+ * exactly; forget a remembered object that is no longer there. Without a
+ * predicate the whole pile is considered (the note_spot case).
+ *
+ * forget_remembered_objects (cave-square.c:1106, called at :1156 and :1186):
+ * upstream walks player->cave's shadow pile and excises/deletes any known
+ * twin whose original is no longer on the grid. The port's knowledge is one
+ * glyph per grid (state.known.objects), so that whole walk collapses to the
+ * "nothing here any more -> delete the entry" branch at the end of this
+ * function and of squareSensePile.
+ */
+export declare function squareKnowPile(state: GameState, grid: Loc, pred?: (obj: GameObject) => boolean): void;
+/**
+ * update_player_object_knowledge (obj-knowledge.c L1218): after any rune-learn,
+ * re-run player_know_object over every object the player can currently see or
+ * hold, so a newly-learned rune propagates awareness across ALL of them - not
+ * just the object that taught it. This is the sweep the audit's KN-03 flagged
+ * missing: e.g. wielding a Ring of Strength learns the STR modifier rune, and it
+ * is this sweep (not object_learn_on_wield itself) that then makes the ring's
+ * kind flavour-aware, so it stops reading as an unidentified "Steel Ring".
+ *
+ * The port keeps rune knowledge in typed player stores and synthesises each
+ * object's known-twin on demand for display, so the only persistent side effect
+ * that needs a home here is player_know_object's awareness half (L1163-1198): a
+ * carried/floor jewel whose non-curse runes are now all known becomes
+ * flavour-aware (L1163-1167, KN-03), a special artifact becomes aware outright
+ * (L1168-1175), and a first reveal of a name/ego prints "You have %s (%c)." /
+ * "On the ground: %s." (L1184-1198, KN-04).
+ *
+ * Scope vs upstream: flavour awareness is per-KIND and global to the game (the
+ * shared FlavorKnowledge), so making a kind aware from a carried jewel already
+ * covers every store / curse-template instance of that kind - the port need only
+ * sweep the player's gear and the floor, not the store/curse lists C also walks
+ * purely to rewrite their per-object display twins. Called at the live rune-learn
+ * sites (wield, being hit, identify), exactly where C's player_learn_rune
+ * tail-calls it (L1373).
+ */
+export declare function updatePlayerObjectKnowledge(state: GameState): void;
+/**
+ * square_sense_pile (reduced): become aware that something matching is
+ * here without learning what (the null-glyph marker), keeping an exact
+ * memory if one exists; forget stale memories like squareKnowPile.
+ */
+export declare function squareSensePile(state: GameState, grid: Loc, pred?: (obj: GameObject) => boolean): void;
+/**
+ * update_mon (mon-util.c): recompute a single monster's visibility. When
+ * `full`, recompute its distance to the player (mon->cdis); otherwise use the
+ * stored one. Sets MFLAG_VISIBLE / MFLAG_VIEW from telepathy, infravision,
+ * see-invisible and illumination, learns the associated lore flags, and
+ * disturbs the player on appearance / disappearance. Draws no RNG.
+ *
+ * The player's derived flags (OF_TELEPATHY / OF_SEE_INVIS) and see_infra come
+ * from the last calc_bonuses (state.playerState); the blind check reads
+ * player->timed[TMD_BLIND] directly. update_mon only READS MFLAG_MARK - the
+ * MARK / SHOW detection-fade lives in tickMonsterMarks.
+ */
+export declare function updateMon(state: GameState, mon: Monster, full: boolean): void;
+/**
+ * become_aware (mon-util.c L711): reveal a camouflaged mimic. Clears
+ * MFLAG_CAMOUFLAGE and, when the race has RF_UNAWARE, learns that flag into
+ * its lore. If the monster was mimicking a floor object, names it (ODESC_BASE)
+ * in a message when its square is seen, breaks the mimicry link on both
+ * sides, removes the fake item from the floor, and refreshes the monster's
+ * own visibility now that mimicry no longer masks it (update_mon). A no-op
+ * monster that is not camouflaged. Draws no RNG.
+ *
+ * Object-mimic placement is wired for live-placed (summoned / bred) mimics
+ * via game/mon-place.ts monCreateMimickedObject, which links mon.mimickedObj
+ * and the object's mimickingMIdx back-reference at the monster's grid; the
+ * object branch below fires for those and for any hand-built Monster/
+ * GameObject pair in tests. (SEAM: generation-spawned mimics still need the
+ * handoff to call monCreateMimickedObject - see that function's docstring.)
+ *
+ * RF_MIMIC_INV's "give the monster a copy of the object before deleting it"
+ * (mon-util.c L740-758) is now ported via obj/object.ts objectCopy (memcpy, no
+ * RNG); only the known twin is DEFERRED with the knowledge subsystem. The
+ * upkeep/redraw bits (PU_UPDATE_VIEW | PU_MONSTERS, PR_MONLIST | PR_ITEMLIST,
+ * square_note_spot, square_light_spot) are presentation (#25), matching the
+ * redraw deferral already noted for updateMon above.
+ */
+export declare function becomeAware(state: GameState, mon: Monster): void;
+/**
+ * move_mimicked_object (mon-util.c L620-650): move the fake floor object with
+ * a camouflaged monster swap. The copied object keeps its mimic back-link;
+ * if the destination cannot carry it, RF_MIMIC_INV gives it to the monster.
+ * This operation is presentation/RNG-free.
+ */
+export declare function moveMimickedObject(state: GameState, mon: Monster, from: Loc, to: Loc): void;
+/** update_monsters (mon-util.c): update every live (non-dead) monster. */
+export declare function updateMonsters(state: GameState, full: boolean): void;
+/**
+ * The five player fields updateView reads, taken off a live GameState.
+ *
+ * One definition because there were two, and they agreed on the wrong thing.
+ * `level` is `p->lev` (cave-view.c:778, the UNLIGHT view radius
+ * `2 + p->lev / 6 - cur_light`), and both the web shell and the MCP session were
+ * passing `chunk.depth` - the dungeon depth. Only an UNLIGHT player carrying no
+ * light can see the difference, which is exactly the kind of field that stays
+ * wrong for a year in two copies and is right once in one.
+ */
+export declare function viewerStateOf(state: GameState): ViewerState;
+/**
+ * note_spot pass: memorize every currently seen grid with its floor pile,
+ * then refresh all monster visibility via update_mon.
+ *
+ * Called after every updateView. Upstream, movement sets PU_DISTANCE and
+ * update() runs update_monsters(TRUE) - cdis and visibility recompute in one
+ * pass - while a view-only change runs update_monsters(FALSE). Since cdis is
+ * purely geometric (idempotent when nothing moved, correct when the player
+ * did), noteSpots recomputes it here (full=true) so the d <= max_sight and
+ * d <= see_infra gates never read a stale distance after a step.
+ */
+export declare function noteSpots(state: GameState): void;
+/**
+ * The MFLAG_NICE / MFLAG_MARK / MFLAG_SHOW housekeeping process_world runs at
+ * the end of a player turn (game-world.c:882-908): clear NICE; where a monster
+ * is MARKed but no longer SHOWn, drop the mark and re-run update_mon; then
+ * clear every SHOW. This keeps a freshly detected monster displayed for one
+ * more refresh before fading. Interim home until the world-clock / process_world
+ * port absorbs it (the NICE clear must be preserved when it does).
+ */
+export declare function tickMonsterMarks(state: GameState): void;
+//# sourceMappingURL=known.d.ts.map

package/dist/game/known.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"known.d.ts","sourceRoot":"","sources":["../../src/game/known.ts"],"names":[],"mappings":"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"}