@rpgm-tools/neo-angband-core 0.10.0

package/dist/game/display.js

@@ -0,0 +1,684 @@
+/**
+ * The DATA half of the sidebar and status line, ported from the display
+ * functions of reference/src/ui-display.c (Angband 4.2.6).
+ *
+ * Upstream each prt_* handler both COMPUTES a coloured string and DRAWS it
+ * with Term_* at a fixed row/column. This module ports only the computation:
+ * for every sidebar field and status-line indicator it returns the ordered
+ * list of coloured text runs. The terminal draw half - row/column positioning,
+ * the "%-11s" / "%-13s" field padding of prt_speed / prt_depth, and the
+ * screen-size priority culling of update_sidebar (L844) - stays with each
+ * front-end shell.
+ *
+ * The status-line handlers return a width (col += return in
+ * update_statusline_aux) that already includes exactly ONE trailing gap column
+ * after each active segment; an idle prt_state still reserves one column. Each
+ * status builder below bakes that single trailing gap into its runs text, so a
+ * shell renders the segments back-to-back with NO external gap and reproduces
+ * the reference layout exactly.
+ *
+ * sidebarModel returns the 18 real fields of side_handlers[] (L810, the four
+ * NULL spacer rows are not fields), in table order. statusLineModel returns
+ * the 11 entries of status_handlers[] (L1296) in table order. A field or
+ * indicator that upstream would draw as blank / return 0 for is represented by
+ * an EMPTY runs array rather than being dropped, so the returned order always
+ * matches the handler tables and a shell simply skips the empty ones.
+ *
+ * Seams for the struct player / world members the port does not carry on
+ * GameState arrive through DisplayDeps; each has a sensible default and is
+ * listed in parity/ledger/ui-display.yaml.
+ */
+import { COLOUR_BLUE, COLOUR_DARK, COLOUR_GREEN, COLOUR_L_BLUE, COLOUR_L_DARK, COLOUR_L_GREEN, COLOUR_L_PURPLE, COLOUR_L_RED, COLOUR_L_TEAL, COLOUR_L_UMBER, COLOUR_ORANGE, COLOUR_PURPLE, COLOUR_RED, COLOUR_UMBER, COLOUR_VIOLET, COLOUR_WHITE, COLOUR_YELLOW, colorCharToAttr, } from "../color.js";
+import { MON_TMD, SQUARE, STAT, TMD } from "../generated/index.js";
+import { nextGrid } from "../world/view.js";
+import { EXTRACT_ENERGY } from "../mon/monster.js";
+import { monsterIsVisible } from "../mon/predicate.js";
+import { PY_MAX_LEVEL, STAT_MAX, TMD_MAX } from "../player/types.js";
+import { modifyStatValue, player_exp, playerHpAttr, playerSpAttr } from "../player/calcs.js";
+import { playerIsResting, playerRestingCount } from "./context.js";
+/**
+ * player->state.stat_use fallback: apply only the race + class stat modifiers
+ * to stat_cur (modify_stat_value), matching calc_bonuses when the character
+ * wears nothing and carries no timed effect.
+ */
+function defaultStatUse(player) {
+    const out = new Array(STAT_MAX).fill(0);
+    for (let i = 0; i < STAT_MAX; i++) {
+        const add = (player.race.statAdj[i] ?? 0) + (player.cls.statAdj[i] ?? 0);
+        out[i] = modifyStatValue(player.statCur[i] ?? 0, add);
+    }
+    return out;
+}
+function resolveDeps(state, deps) {
+    const player = state.actor.player;
+    return {
+        hitpointWarn: deps.hitpointWarn ?? state.options?.hitpointWarn ?? 3,
+        effectiveSpeed: deps.effectiveSpeed ?? state.options?.get("effective_speed") ?? false,
+        birthFeelings: deps.birthFeelings ?? state.options?.get("birth_feelings") ?? true,
+        feelingNeed: deps.feelingNeed ?? 10,
+        timedEffects: deps.timedEffects ?? [],
+        statUse: deps.statUse ?? defaultStatUse(player),
+        numMoves: deps.numMoves ?? 0,
+        healthWho: deps.healthWho ?? state.healthWho ?? null,
+        unignoring: deps.unignoring ?? false,
+        isResting: deps.isResting ?? playerIsResting(state),
+        restingCount: deps.restingCount ?? playerRestingCount(state),
+        nRepeats: deps.nRepeats ?? 0,
+        wizard: deps.wizard ?? false,
+        totalWinner: deps.totalWinner ?? false,
+        bookHasUnlearnedSpells: deps.bookHasUnlearnedSpells ?? true,
+        objectAttr: deps.objectAttr ?? ((obj) => colorCharToAttr(obj.kind.dAttr)),
+        objectChar: deps.objectChar ?? ((obj) => obj.kind.dChar),
+    };
+}
+/* ------------------------------------------------------------------ */
+/* Small formatting helpers                                            */
+/* ------------------------------------------------------------------ */
+/** printf "%<width>d": right-justify a base-ten integer, space-padded. */
+function rjust(value, width) {
+    return String(value).padStart(width, " ");
+}
+/** my_strcap: capitalise the first character. */
+function strcap(s) {
+    if (!s)
+        return s;
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/**
+ * cnv_stat (ui-display.c L115): a modified stat value as a six-char, right-
+ * justified string. Values over 18 use the "18/NN" encoding.
+ */
+export function cnvStat(val) {
+    if (val > 18) {
+        const bonus = val - 18;
+        if (bonus >= 220)
+            return "18/***";
+        if (bonus >= 100)
+            return `18/${String(bonus).padStart(3, "0")}`;
+        return ` 18/${String(bonus).padStart(2, "0")}`;
+    }
+    return `    ${rjust(val, 2)}`;
+}
+/**
+ * fmt_title (ui-display.c L173), short_mode == false: the character title -
+ * wizard, winner, shape name, or the class level title. Returns "" only if a
+ * shape has an empty name (never in stock data).
+ */
+export function fmtTitle(player, deps) {
+    if (deps.wizard)
+        return "[=-WIZARD-=]";
+    if (deps.totalWinner || player.lev > PY_MAX_LEVEL)
+        return "***WINNER***";
+    if (playerIsShapechanged(player))
+        return strcap(player.shape?.name ?? "");
+    const idx = Math.trunc((player.lev - 1) / 5);
+    return player.cls.titles[idx] ?? "";
+}
+/**
+ * player_is_shapechanged (player-util.c L1065): a non-"normal" shape.
+ *
+ * NOT exported - game/obj-cmd.ts already exports a GameState-taking copy of this
+ * same C function, and that is the one callers outside this module use. The two
+ * agree because effect-general.ts:868 normalizes the "normal" shape to null when
+ * it assigns, so `shape === null` is exactly `name === "normal"`; the extra name
+ * test here is what makes this copy safe if that invariant ever slips.
+ */
+function playerIsShapechanged(player) {
+    return player.shape !== null && player.shape.name !== "normal";
+}
+/**
+ * fmt_depth (ui-display.c L519): "Town" at depth 0, else "<feet>' (L<depth>)".
+ * The port's current depth is the live chunk depth (upstream player->depth ==
+ * cave->depth).
+ */
+export function fmtDepth(depth) {
+    if (!depth)
+        return "Town";
+    return `${depth * 50}' (L${depth})`;
+}
+/**
+ * prt_speed_aux (ui-display.c L475): the speed label ("Fast" / "Slow") and its
+ * colour, or an empty string at normal speed (110). With effectiveSpeed the
+ * "(%d.%dx)" multiplier form is used, otherwise the "(%+d)" delta form.
+ */
+export function prtSpeedAux(speed, effectiveSpeed) {
+    let color = COLOUR_WHITE;
+    let type = null;
+    if (speed > 110) {
+        color = COLOUR_L_GREEN;
+        type = "Fast";
+    }
+    else if (speed < 110) {
+        color = COLOUR_L_UMBER;
+        type = "Slow";
+    }
+    if (!type)
+        return { text: "", color };
+    if (!effectiveSpeed) {
+        const delta = speed - 110;
+        return { text: `${type} (${delta >= 0 ? "+" : ""}${delta})`, color };
+    }
+    const norm = EXTRACT_ENERGY[110];
+    const cur = EXTRACT_ENERGY[Math.min(Math.max(speed, 0), EXTRACT_ENERGY.length - 1)];
+    const multiplier = Math.trunc((10 * cur) / norm);
+    const intMul = Math.trunc(multiplier / 10);
+    const decMul = multiplier % 10;
+    return { text: `${type} (${intMul}.${decMul}x)`, color };
+}
+/**
+ * monster_health_attr (ui-display.c L365): the colour of a tracked monster's
+ * health bar. `image` is whether the player is hallucinating (TMD_IMAGE).
+ */
+export function monsterHealthAttr(mon, image) {
+    if (!mon)
+        return COLOUR_DARK;
+    if (!monsterIsVisible(mon) || mon.hp < 0 || image)
+        return COLOUR_WHITE;
+    let attr = COLOUR_RED;
+    const pct = Math.trunc((100 * mon.hp) / mon.maxhp);
+    if (pct >= 10)
+        attr = COLOUR_L_RED;
+    if (pct >= 25)
+        attr = COLOUR_ORANGE;
+    if (pct >= 60)
+        attr = COLOUR_YELLOW;
+    if (pct >= 100)
+        attr = COLOUR_L_GREEN;
+    if (mon.mTimed[MON_TMD.FEAR])
+        attr = COLOUR_VIOLET;
+    if (mon.mTimed[MON_TMD.DISEN])
+        attr = COLOUR_L_UMBER;
+    if (mon.mTimed[MON_TMD.COMMAND])
+        attr = COLOUR_L_PURPLE;
+    if (mon.mTimed[MON_TMD.CONF])
+        attr = COLOUR_UMBER;
+    if (mon.mTimed[MON_TMD.STUN])
+        attr = COLOUR_L_BLUE;
+    if (mon.mTimed[MON_TMD.SLEEP])
+        attr = COLOUR_BLUE;
+    if (mon.mTimed[MON_TMD.HOLD])
+        attr = COLOUR_BLUE;
+    return attr;
+}
+/* ------------------------------------------------------------------ */
+/* Sidebar (side_handlers[], ui-display.c L810)                        */
+/* ------------------------------------------------------------------ */
+/** stat_names[STAT_MAX] (ui-display.c L98). */
+const STAT_NAMES = ["STR: ", "INT: ", "WIS: ", "DEX: ", "CON: "];
+/** stat_names_reduced[STAT_MAX] (ui-display.c L107). */
+const STAT_NAMES_REDUCED = ["Str: ", "Int: ", "Wis: ", "Dex: ", "Con: "];
+/** prt_field text as a single COLOUR_L_BLUE run, or empty runs when blank. */
+function field(text) {
+    return text ? [{ text, color: COLOUR_L_BLUE }] : [];
+}
+/**
+ * prt_stat (ui-display.c:153-171) for one stat index. The 5-char label is drawn
+ * at col 0, but the 6-char cnv_stat value is drawn at col+6 (c_put_str at
+ * col + 6, L161/L165) - there is a blank column at col 5. We reproduce that gap
+ * by padding the label run to width 6 so the following value run begins at col
+ * 6 exactly. The "!" natural-maximum indicator still overwrites index 3.
+ */
+function statRuns(player, stat, deps) {
+    const cur = player.statCur[stat] ?? 0;
+    const max = player.statMax[stat] ?? 0;
+    const drained = cur < max;
+    let label = drained
+        ? STAT_NAMES_REDUCED[stat] ?? ""
+        : STAT_NAMES[stat] ?? "";
+    /* Natural maximum indicator: put_str("!", col + 3) overwrites the label's
+       fourth character (L169-170). */
+    if (max === 18 + 100) {
+        label = label.slice(0, 3) + "!" + label.slice(4);
+    }
+    const value = cnvStat(deps.statUse[stat] ?? 0);
+    return [
+        { text: label.padEnd(6), color: COLOUR_WHITE },
+        { text: value, color: drained ? COLOUR_YELLOW : COLOUR_L_GREEN },
+    ];
+}
+/** prt_level (ui-display.c L207). */
+function levelRuns(player) {
+    const value = rjust(player.lev, 6);
+    const atMax = player.lev >= player.maxLev;
+    return [
+        { text: atMax ? "LEVEL " : "Level ", color: COLOUR_WHITE },
+        { text: value, color: atMax ? COLOUR_L_GREEN : COLOUR_YELLOW },
+    ];
+}
+/**
+ * prt_exp (ui-display.c:226-250). The 3-char label ("EXP"/"NXT"/"Exp"/"Nxt") is
+ * drawn at col 0, but the 8-char "%8ld" value is drawn at col+4 (c_put_str at
+ * col + 4, L245/L248) - there is a blank column at col 3. We pad the label run
+ * to width 4 so the value run begins at col 4 exactly.
+ */
+function expRuns(player) {
+    const levMax = player.lev === PY_MAX_LEVEL;
+    let xp = player.exp;
+    if (!levMax) {
+        const base = player_exp[player.lev - 1] ?? 0;
+        xp = Math.trunc((base * player.expFactor) / 100) - player.exp;
+    }
+    const value = rjust(xp, 8);
+    const atMax = player.exp >= player.maxExp;
+    const label = levMax ? (atMax ? "EXP" : "Exp") : atMax ? "NXT" : "Nxt";
+    return [
+        { text: label.padEnd(4), color: COLOUR_WHITE },
+        { text: value, color: atMax ? COLOUR_L_GREEN : COLOUR_YELLOW },
+    ];
+}
+/** prt_gold (ui-display.c L256). */
+function goldRuns(player) {
+    return [
+        { text: "AU ", color: COLOUR_WHITE },
+        { text: rjust(player.au, 9), color: COLOUR_L_GREEN },
+    ];
+}
+/** prt_equippy (ui-display.c L269): one single-char run per body slot. */
+function equippyRuns(state, deps) {
+    const player = state.actor.player;
+    const runs = [];
+    for (let i = 0; i < player.body.count; i++) {
+        const handle = player.equipment[i] ?? 0;
+        const obj = state.gear.store.get(handle) ?? null;
+        if (obj) {
+            runs.push({ text: deps.objectChar(obj), color: deps.objectAttr(obj) });
+        }
+        else {
+            runs.push({ text: " ", color: COLOUR_WHITE });
+        }
+    }
+    return runs;
+}
+/** prt_ac (ui-display.c L301): "Cur AC " + (ac + to_a). */
+function acRuns(state) {
+    const c = state.actor.combat;
+    return [
+        { text: "Cur AC ", color: COLOUR_WHITE },
+        { text: rjust(c.ac + c.toA, 5), color: COLOUR_L_GREEN },
+    ];
+}
+/** prt_hp (ui-display.c L314). */
+function hpRuns(player, deps) {
+    return [
+        { text: "HP ", color: COLOUR_WHITE },
+        { text: rjust(player.chp, 4), color: playerHpAttr(player, deps.hitpointWarn) },
+        { text: "/", color: COLOUR_WHITE },
+        { text: rjust(player.mhp, 4), color: COLOUR_L_GREEN },
+    ];
+}
+/** prt_sp (ui-display.c L332): empty unless the class has mana at this level. */
+function spRuns(player, deps) {
+    const magic = player.cls.magic;
+    if (!magic.totalSpells || player.lev < magic.spellFirst) {
+        /* An experience-drain clear (L344) leaves the field blank either way. */
+        return [];
+    }
+    return [
+        { text: "SP ", color: COLOUR_WHITE },
+        { text: rjust(player.csp, 4), color: playerSpAttr(player, deps.hitpointWarn) },
+        { text: "/", color: COLOUR_WHITE },
+        { text: rjust(player.msp, 4), color: COLOUR_L_GREEN },
+    ];
+}
+/** prt_health / prt_health_aux (ui-display.c L425). */
+function healthRuns(player, deps) {
+    const mon = deps.healthWho;
+    if (!mon)
+        return [];
+    const image = (player.timed[TMD.IMAGE] ?? 0) > 0;
+    const attr = monsterHealthAttr(mon, image);
+    if (!monsterIsVisible(mon) || image || mon.hp < 0) {
+        return [{ text: "[----------]", color: attr }];
+    }
+    const pct = Math.trunc((100 * mon.hp) / mon.maxhp);
+    const len = pct < 10 ? 1 : pct < 90 ? Math.trunc(pct / 10) + 1 : 10;
+    const runs = [{ text: "[", color: COLOUR_WHITE }];
+    if (len > 0)
+        runs.push({ text: "*".repeat(len), color: attr });
+    if (len < 10)
+        runs.push({ text: "-".repeat(10 - len), color: COLOUR_WHITE });
+    runs.push({ text: "]", color: COLOUR_WHITE });
+    return runs;
+}
+/** prt_speed (ui-display.c L508). */
+function speedRuns(state, deps) {
+    const s = prtSpeedAux(state.actor.speed, deps.effectiveSpeed);
+    return s.text ? [{ text: s.text, color: s.color }] : [];
+}
+/** prt_depth (ui-display.c L532). */
+function depthRuns(state) {
+    return [{ text: fmtDepth(state.chunk.depth), color: COLOUR_WHITE }];
+}
+/**
+ * sidebarModel: the 18 real side_handlers[] fields in table order (the four
+ * NULL spacer rows are not represented). update_sidebar's priority culling is
+ * a draw-half concern each shell applies.
+ */
+export function sidebarModel(state, deps = {}) {
+    const d = resolveDeps(state, deps);
+    const player = state.actor.player;
+    const shape = playerIsShapechanged(player);
+    return [
+        { key: "race", runs: field(shape ? "" : player.race.name) },
+        { key: "title", runs: field(fmtTitle(player, d)) },
+        { key: "class", runs: field(shape ? "" : player.cls.name) },
+        { key: "level", runs: levelRuns(player) },
+        { key: "exp", runs: expRuns(player) },
+        { key: "gold", runs: goldRuns(player) },
+        { key: "equippy", runs: equippyRuns(state, d) },
+        { key: "str", runs: statRuns(player, STAT.STR, d) },
+        { key: "int", runs: statRuns(player, STAT.INT, d) },
+        { key: "wis", runs: statRuns(player, STAT.WIS, d) },
+        { key: "dex", runs: statRuns(player, STAT.DEX, d) },
+        { key: "con", runs: statRuns(player, STAT.CON, d) },
+        { key: "ac", runs: acRuns(state) },
+        { key: "hp", runs: hpRuns(player, d) },
+        { key: "sp", runs: spRuns(player, d) },
+        { key: "health", runs: healthRuns(player, d) },
+        { key: "speed", runs: speedRuns(state, d) },
+        { key: "depth", runs: depthRuns(state) },
+    ];
+}
+/* ------------------------------------------------------------------ */
+/* Status line (status_handlers[], ui-display.c L1296)                 */
+/* ------------------------------------------------------------------ */
+/** obj_feeling_color[] (ui-display.c L1019). */
+const OBJ_FEELING_COLOR = [
+    COLOUR_WHITE,
+    COLOUR_L_PURPLE,
+    COLOUR_L_RED,
+    COLOUR_ORANGE,
+    COLOUR_YELLOW,
+    COLOUR_YELLOW,
+    COLOUR_L_GREEN,
+    COLOUR_L_GREEN,
+    COLOUR_L_GREEN,
+    COLOUR_L_BLUE,
+    COLOUR_L_BLUE,
+];
+/** mon_feeling_color[] (ui-display.c L1035). */
+const MON_FEELING_COLOR = [
+    COLOUR_WHITE,
+    COLOUR_RED,
+    COLOUR_ORANGE,
+    COLOUR_ORANGE,
+    COLOUR_YELLOW,
+    COLOUR_YELLOW,
+    COLOUR_GREEN,
+    COLOUR_GREEN,
+    COLOUR_BLUE,
+    COLOUR_BLUE,
+];
+/**
+ * prt_level_feeling (ui-display.c:1053-1124). Draws "LF:<mon>-<obj>"; the
+ * reference return width is new_col - col == 3 + strlen(mon) + 1 + strlen(obj)
+ * + 1 (L1121-1123), i.e. the text plus exactly ONE trailing gap column. We bake
+ * that single gap in with a trailing " " run so the segment renders with no
+ * external gap.
+ */
+function levelFeelingRuns(state, deps) {
+    if (!deps.birthFeelings)
+        return [];
+    const depth = state.chunk.depth;
+    if (!depth)
+        return [];
+    const objFeeling = Math.trunc(state.chunk.feeling / 10);
+    const monFeeling = state.chunk.feeling - 10 * objFeeling;
+    let objStr;
+    let objColor;
+    if (state.chunk.feelingSquares < deps.feelingNeed) {
+        objStr = "?";
+        objColor = COLOUR_WHITE;
+    }
+    else {
+        objColor = OBJ_FEELING_COLOR[objFeeling] ?? COLOUR_WHITE;
+        if (objFeeling === 0)
+            objStr = "*";
+        else if (objFeeling === 1)
+            objStr = "$";
+        else
+            objStr = String(11 - objFeeling);
+    }
+    const monStr = monFeeling === 0 ? "?" : String(10 - monFeeling);
+    const monColor = MON_FEELING_COLOR[monFeeling] ?? COLOUR_WHITE;
+    return [
+        { text: "LF:", color: COLOUR_WHITE },
+        { text: monStr, color: monColor },
+        { text: "-", color: COLOUR_WHITE },
+        { text: objStr, color: objColor },
+        { text: " ", color: COLOUR_WHITE },
+    ];
+}
+/** prt_light (ui-display.c L1129). */
+function lightRuns(state) {
+    const light = state.chunk.light(state.actor.grid);
+    return [
+        {
+            text: `Light ${light} `,
+            color: light > 0 ? COLOUR_YELLOW : COLOUR_PURPLE,
+        },
+    ];
+}
+/** prt_moves (ui-display.c L1145). */
+function movesRuns(deps) {
+    const i = deps.numMoves;
+    if (i > 0)
+        return [{ text: `Moves +${i} `, color: COLOUR_L_TEAL }];
+    if (i < 0)
+        return [{ text: `Moves -${Math.abs(i)} `, color: COLOUR_L_TEAL }];
+    return [];
+}
+/**
+ * prt_unignore (ui-display.c:1280-1289). Draws "Unignoring", returns
+ * strlen(str) + 1 (L1285) - the text width includes one trailing gap column. We
+ * bake that gap into the text ("Unignoring ").
+ */
+function unignoreRuns(deps) {
+    return deps.unignoring
+        ? [{ text: "Unignoring ", color: COLOUR_WHITE }]
+        : [];
+}
+/**
+ * prt_recall (ui-display.c:925-933). Draws "Recall", returns sizeof "Recall" ==
+ * 7 (L929) - the text width includes one trailing gap column. We bake that gap
+ * into the text ("Recall ").
+ */
+function recallRuns(player) {
+    return player.wordRecall
+        ? [{ text: "Recall ", color: COLOUR_WHITE }]
+        : [];
+}
+/**
+ * prt_descent (ui-display.c:939-947). Draws "Descent", returns sizeof "Descent"
+ * == 8 (L943) - the text width includes one trailing gap column. We bake that
+ * gap into the text ("Descent ").
+ */
+function descentRuns(player) {
+    return player.deepDescent
+        ? [{ text: "Descent ", color: COLOUR_WHITE }]
+        : [];
+}
+/** I2D: a decimal digit as its character (util.c). */
+function i2d(n) {
+    return String.fromCharCode("0".charCodeAt(0) + n);
+}
+/**
+ * prt_state (ui-display.c:957-1017): "Rest" plus a ten-char count field, or the
+ * repeat count. The rest field is always exactly ten characters wide. The
+ * reference returns strlen(text) + 1 (L1016) - the width always includes one
+ * trailing gap column, and when idle (text == "") it still returns 1, reserving
+ * a single blank column. We bake the gap in: an active state emits its field
+ * plus a trailing space; an idle state emits a single space run.
+ */
+function stateRuns(deps) {
+    let text = "";
+    if (deps.isResting) {
+        const n = deps.restingCount;
+        /* "Rest" followed by six spaces (a ten-char field). */
+        const t = "Rest      ".split("");
+        if (n >= 1000) {
+            let i = Math.trunc(n / 100);
+            t[9] = "0";
+            t[8] = "0";
+            t[7] = i2d(i % 10);
+            if (i >= 10) {
+                i = Math.trunc(i / 10);
+                t[6] = i2d(i % 10);
+                if (i >= 10)
+                    t[5] = i2d(Math.trunc(i / 10));
+            }
+        }
+        else if (n >= 100) {
+            let i = n;
+            t[9] = i2d(i % 10);
+            i = Math.trunc(i / 10);
+            t[8] = i2d(i % 10);
+            t[7] = i2d(Math.trunc(i / 10));
+        }
+        else if (n >= 10) {
+            t[9] = i2d(n % 10);
+            t[8] = i2d(Math.trunc(n / 10));
+        }
+        else if (n > 0) {
+            t[9] = i2d(n);
+        }
+        else if (n === -1) {
+            /* REST_ALL_POINTS (player-util.h L54). */
+            t[5] = t[6] = t[7] = t[8] = t[9] = "*";
+        }
+        else if (n === -2) {
+            /* REST_COMPLETE (player-util.h L53). */
+            t[5] = t[6] = t[7] = t[8] = t[9] = "&";
+        }
+        else if (n === -3) {
+            /* REST_SOME_POINTS (player-util.h L55). */
+            t[5] = t[6] = t[7] = t[8] = t[9] = "!";
+        }
+        text = t.join("");
+    }
+    else if (deps.nRepeats) {
+        const n = deps.nRepeats;
+        text =
+            n > 999
+                ? `Rep. ${rjust(Math.trunc(n / 100), 3)}00`
+                : `Repeat ${rjust(n, 3)}`;
+    }
+    /* strlen(text) + 1: bake the one trailing gap in; idle reserves one column. */
+    return [{ text: text ? `${text} ` : " ", color: COLOUR_WHITE }];
+}
+/**
+ * prt_study (ui-display.c:1226-1245). Draws "Study (%d)", returns strlen(text)
+ * + 1 (L1241) - the text width includes one trailing gap column. We bake that
+ * gap into the text ("Study (N) ").
+ */
+function studyRuns(player, deps) {
+    const n = player.upkeep.newSpells;
+    if (!n)
+        return [];
+    const color = deps.bookHasUnlearnedSpells ? COLOUR_WHITE : COLOUR_L_DARK;
+    return [{ text: `Study (${n}) `, color }];
+}
+/**
+ * prt_tmd (ui-display.c L1251): walk every active timed effect to the grade
+ * whose max covers the current duration, and emit its name (and, for
+ * TMD_FOOD, the percentage meter). Each named piece carries a trailing space,
+ * reproducing upstream's "len += strlen + 1" internal spacing.
+ */
+function tmdRuns(player, deps) {
+    const runs = [];
+    for (let i = 0; i < TMD_MAX; i++) {
+        const dur = player.timed[i] ?? 0;
+        if (!dur)
+            continue;
+        const effect = deps.timedEffects[i];
+        if (!effect)
+            continue;
+        const grades = effect.grades;
+        let k = 0;
+        while (k < grades.length - 1 && dur > grades[k].max) {
+            k++;
+        }
+        const grade = grades[k];
+        if (!grade || grade.name === null)
+            continue;
+        runs.push({ text: `${grade.name} `, color: grade.color });
+        if (i === TMD.FOOD) {
+            runs.push({ text: `${Math.trunc(dur / 100)} % `, color: grade.color });
+        }
+    }
+    return runs;
+}
+/** prt_dtrap (ui-display.c L1207). */
+function dtrapRuns(state) {
+    const grid = state.actor.grid;
+    if (!squareIsDtrap(state, grid))
+        return [];
+    const color = squareDtrapEdge(state, grid) ? COLOUR_YELLOW : COLOUR_L_GREEN;
+    return [{ text: "DTrap ", color }];
+}
+/** square_isdtrap (cave-square.c L570). */
+function squareIsDtrap(state, grid) {
+    return state.chunk.sqinfoHas(grid, SQUARE.DTRAP);
+}
+/** square_dtrap_edge (cave-square.c L841): a dtrap grid bordering a non-dtrap. */
+function squareDtrapEdge(state, grid) {
+    if (!squareIsDtrap(state, grid))
+        return false;
+    const c = state.chunk;
+    /* Keypad DIR_S/E/N/W = 2/6/8/4 (next_grid). */
+    for (const dir of [2, 6, 8, 4]) {
+        const g = nextGrid(grid, dir);
+        if (c.inBoundsFully(g) && !squareIsDtrap(state, g))
+            return true;
+    }
+    return false;
+}
+/**
+ * prt_terrain (ui-display.c L1184): the player's trap (unless invisible) or
+ * feature name, capitalised, in its display colour, with a trailing space.
+ */
+function terrainRuns(state) {
+    const grid = state.actor.grid;
+    const idx = grid.y * state.chunk.width + grid.x;
+    const trap = state.traps.get(idx)?.[0] ?? null;
+    let name;
+    let color;
+    /* square_isinvis (cave-square.c:498): the unknown-trap mark, read here as
+     * ui-display.c:1191 does (prt_terrain). */
+    if (trap && !state.chunk.sqinfoHas(grid, SQUARE.INVIS)) {
+        name = trap.kind.name;
+        color = colorCharToAttr(trap.kind.color);
+    }
+    else {
+        const feat = state.chunk.feature(grid);
+        name = feat.name;
+        color = colorCharToAttr(feat.dAttr);
+    }
+    return [{ text: `${strcap(name)} `, color }];
+}
+/**
+ * statusLineModel: the 11 status_handlers[] indicators in table order. An
+ * indicator upstream returns 0 for is represented by an empty runs array
+ * (shells skip it). Each active segment bakes its single trailing gap column
+ * into its runs (matching the reference return width), so shells render the
+ * segments back-to-back with no external gap; idle prt_state reserves one blank
+ * column.
+ */
+export function statusLineModel(state, deps = {}) {
+    const d = resolveDeps(state, deps);
+    const player = state.actor.player;
+    return [
+        { key: "level_feeling", runs: levelFeelingRuns(state, d) },
+        { key: "light", runs: lightRuns(state) },
+        { key: "moves", runs: movesRuns(d) },
+        { key: "unignore", runs: unignoreRuns(d) },
+        { key: "recall", runs: recallRuns(player) },
+        { key: "descent", runs: descentRuns(player) },
+        { key: "state", runs: stateRuns(d) },
+        { key: "study", runs: studyRuns(player, d) },
+        { key: "tmd", runs: tmdRuns(player, d) },
+        { key: "dtrap", runs: dtrapRuns(state) },
+        { key: "terrain", runs: terrainRuns(state) },
+    ];
+}
+//# sourceMappingURL=display.js.map