@rpgm-tools/neo-angband-core 0.10.0

package/dist/save/integrity.js

@@ -0,0 +1,103 @@
+/**
+ * Save integrity: a tamper-DETERRENT layer over the raw savefile bytes.
+ *
+ * Context (see ./buffer and the save-scum policy): upstream Angband
+ * stamps each block with a 32-bit additive checksum for corruption
+ * detection. That is trivially recomputable. This module adds an
+ * optional whole-file digest so that a casual hand-edit of the stored
+ * bytes (e.g. via browser DevTools on an IndexedDB save) no longer
+ * verifies, which raises the bar against save-scumming.
+ *
+ * HONEST CEILING: any verifier that runs on the client also ships to the
+ * client, so a determined user can read it and recompute the digest.
+ * This is a DETERRENT, not real protection. Unforgeable anti-tamper
+ * requires a secret the client never holds - i.e. server-authoritative
+ * saves, which belong to the networking seam (a plugin), not core.
+ *
+ * MODDABILITY: the digest is a seam. A host or mod may inject a stronger
+ * provider (for example SHA-256 via SubtleCrypto, or an HMAC keyed by a
+ * server secret in a networked deployment) by implementing SaveIntegrity.
+ */
+/**
+ * The built-in default: FNV-1a (64-bit, emitted as 16 hex chars). It is
+ * a NON-CRYPTOGRAPHIC hash - far more diffusing than an additive sum, so
+ * it catches casual edits, but not a security primitive. Zero-dependency
+ * and synchronous so core stays environment-neutral.
+ */
+export const fnv1aIntegrity = {
+    id: "fnv1a-64",
+    digest(bytes) {
+        // 64-bit FNV-1a maintained as two 32-bit halves (hi, lo) to stay in
+        // safe integer math. offset basis 0xcbf29ce484222325, prime 0x100000001b3.
+        let hi = 0xcbf29ce4;
+        let lo = 0x84222325;
+        for (let i = 0; i < bytes.length; i++) {
+            lo ^= bytes[i];
+            // Multiply the 64-bit value by the FNV prime (0x100000001b3):
+            // that is 2^40 + 2^8 + 0x1b3. Do it via 16-bit limbs to be exact.
+            const a0 = lo & 0xffff;
+            const a1 = lo >>> 16;
+            const a2 = hi & 0xffff;
+            const a3 = hi >>> 16;
+            // prime limbs: p0=0x01b3, p1=0x0001, p2=0x0100, p3=0x0000
+            let c0 = a0 * 0x01b3;
+            let c1 = a1 * 0x01b3 + a0 * 0x0001 + (c0 >>> 16);
+            let c2 = a2 * 0x01b3 + a1 * 0x0001 + a0 * 0x0100 + (c1 >>> 16);
+            let c3 = a3 * 0x01b3 + a2 * 0x0001 + a1 * 0x0100 + (c2 >>> 16);
+            lo = ((c1 & 0xffff) << 16) | (c0 & 0xffff);
+            hi = ((c3 & 0xffff) << 16) | (c2 & 0xffff);
+            lo >>>= 0;
+            hi >>>= 0;
+        }
+        const hex = (n) => (n >>> 0).toString(16).padStart(8, "0");
+        return hex(hi) + hex(lo);
+    },
+};
+/** Marker appended after the digest so the trailer is self-describing. */
+const TRAILER_MAGIC = "\nNGISTMP1\n";
+/**
+ * Append an integrity trailer (provider id + digest) to a savefile byte
+ * stream. The trailer sits after the block data and is excluded from the
+ * digest, so verification digests exactly the original bytes.
+ */
+export function stampSavefile(bytes, provider = fnv1aIntegrity) {
+    const digest = provider.digest(bytes);
+    const trailer = `${TRAILER_MAGIC}${provider.id}:${digest}`;
+    const tbytes = new TextEncoder().encode(trailer);
+    const out = new Uint8Array(bytes.length + tbytes.length);
+    out.set(bytes, 0);
+    out.set(tbytes, bytes.length);
+    return out;
+}
+/**
+ * Split off and verify an integrity trailer. A caller decides policy: a
+ * no-save-scum build should reject `verified === false`, while still
+ * tolerating `unstamped` legacy saves if it chooses. Verification uses
+ * the supplied provider (whose id must match the trailer's).
+ */
+export function verifyStampedSavefile(bytes, provider = fnv1aIntegrity) {
+    const magicBytes = new TextEncoder().encode(TRAILER_MAGIC);
+    const at = lastIndexOf(bytes, magicBytes);
+    if (at < 0) {
+        return { payload: bytes, verified: false, unstamped: true };
+    }
+    const payload = bytes.subarray(0, at);
+    const trailer = new TextDecoder().decode(bytes.subarray(at + magicBytes.length));
+    const colon = trailer.indexOf(":");
+    const providerId = colon >= 0 ? trailer.slice(0, colon) : trailer;
+    const recorded = colon >= 0 ? trailer.slice(colon + 1) : "";
+    const verified = providerId === provider.id && provider.digest(payload) === recorded;
+    return { payload, verified, unstamped: false, providerId };
+}
+/** Find the last occurrence of `needle` in `hay`, or -1. */
+function lastIndexOf(hay, needle) {
+    outer: for (let i = hay.length - needle.length; i >= 0; i--) {
+        for (let j = 0; j < needle.length; j++) {
+            if (hay[i + j] !== needle[j])
+                continue outer;
+        }
+        return i;
+    }
+    return -1;
+}
+//# sourceMappingURL=integrity.js.map

package/dist/save/integrity.js.map

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

package/dist/score/display.d.ts

@@ -0,0 +1,40 @@
+/**
+ * High-score row formatting, ported from reference/src/ui-score.c
+ * (Angband 4.2.6) display_score_page (L30). The C draws three lines per record
+ * with Term calls; this produces the same strings as DATA (ScoreRow), leaving
+ * the Term paging/scroll/keypress loop (display_scores_aux, L117) to the shell.
+ *
+ * The number fields the C reads back from the fixed-width record (pts printed
+ * with "%9s"; user/gold/turns are the space-padded numbers with their leading
+ * whitespace stripped) are reconstructed here from the typed HighScore, giving
+ * byte-identical output.
+ */
+import type { HighScore, ScoreRow } from "./types.js";
+/**
+ * Resolvers for the race/class name a record's indices map to
+ * (player_id2race / player_id2class in display_score_page). Return null for an
+ * unknown index; the C prints "<none>" then. Supply from a PlayerRegistry:
+ * `{ raceName: (i) => reg.races[i]?.name ?? null, ... }`.
+ */
+export interface ScoreNameResolver {
+    raceName(ridx: number): string | null;
+    className(cidx: number): string | null;
+}
+/**
+ * Build the three display lines for a single record at `start`, highlighted
+ * when start === highlight. Faithful to the body of display_score_page's loop.
+ */
+export declare function scoreRow(scores: readonly HighScore[], start: number, highlight: number, names: ScoreNameResolver): ScoreRow;
+/**
+ * display_score_page (ui-score.c L30): the rows for one page - up to 5 entries
+ * starting at `start`, stopping at `count`. `highlight` is the index to draw in
+ * L_GREEN (or -1 for none).
+ */
+export declare function scorePageRows(scores: readonly HighScore[], start: number, count: number, highlight: number, names: ScoreNameResolver): ScoreRow[];
+/**
+ * All rows for the inclusive-exclusive range [from, to) clamped to the real
+ * record count, in one flat list (convenience over paging). `highlight` is the
+ * highlighted index or -1. Useful for a scroll surface that renders every row.
+ */
+export declare function scoreRows(scores: readonly HighScore[], from: number, to: number, highlight: number, names: ScoreNameResolver): ScoreRow[];
+//# sourceMappingURL=display.d.ts.map

package/dist/score/display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../../src/score/display.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACtC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CACxC;AAmBD;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,iBAAiB,GACvB,QAAQ,CA+BV;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,iBAAiB,GACvB,QAAQ,EAAE,CAMZ;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,iBAAiB,GACvB,QAAQ,EAAE,CAQZ"}

package/dist/score/display.js

@@ -0,0 +1,86 @@
+/**
+ * High-score row formatting, ported from reference/src/ui-score.c
+ * (Angband 4.2.6) display_score_page (L30). The C draws three lines per record
+ * with Term calls; this produces the same strings as DATA (ScoreRow), leaving
+ * the Term paging/scroll/keypress loop (display_scores_aux, L117) to the shell.
+ *
+ * The number fields the C reads back from the fixed-width record (pts printed
+ * with "%9s"; user/gold/turns are the space-padded numbers with their leading
+ * whitespace stripped) are reconstructed here from the typed HighScore, giving
+ * byte-identical output.
+ */
+import { COLOUR_L_GREEN, COLOUR_WHITE } from "../color.js";
+import { SCORES_PER_PAGE } from "./types.js";
+/** printf "%Ns": right-justify a string into at least N columns. */
+function padStart(s, width) {
+    return s.length >= width ? s : " ".repeat(width - s.length) + s;
+}
+/**
+ * Clean up the stored "when" for display (ui-score.c L100): an "@YYYYMMDD"
+ * stamp (a leading '@' with total length 9) becomes "YYYY-MM-DD"; anything
+ * else (e.g. "TODAY") is shown unchanged.
+ */
+function formatWhen(day) {
+    if (day.startsWith("@") && day.length === 9) {
+        return `${day.slice(1, 5)}-${day.slice(5, 7)}-${day.slice(7, 9)}`;
+    }
+    return day;
+}
+/**
+ * Build the three display lines for a single record at `start`, highlighted
+ * when start === highlight. Faithful to the body of display_score_page's loop.
+ */
+export function scoreRow(scores, start, highlight, names) {
+    const score = scores[start];
+    const highlighted = start === highlight;
+    const color = highlighted ? COLOUR_L_GREEN : COLOUR_WHITE;
+    const race = names.raceName(score.pRace);
+    const cls = names.className(score.pClass);
+    const clev = score.curLev;
+    const mlev = score.maxLev;
+    const cdun = score.curDun;
+    const mdun = score.maxDun;
+    // Line 1: "%3d.%9s  %s the %s %s, level %d" (+ " (Max %d)" if mlev > clev).
+    let line1 = `${padStart(String(start + 1), 3)}.${padStart(String(score.pts), 9)}` +
+        `  ${score.who} the ${race ?? "<none>"} ${cls ?? "<none>"}, level ${clev}`;
+    if (mlev > clev)
+        line1 += ` (Max ${mlev})`;
+    // Line 2: town vs dungeon death (+ " (Max %d)" if mdun > cdun).
+    let line2 = !cdun
+        ? `Killed by ${score.how} in the town`
+        : `Killed by ${score.how} on dungeon level ${cdun}`;
+    if (mdun > cdun)
+        line2 += ` (Max ${mdun})`;
+    // Line 3: "(User %s, Date %s, Gold %s, Turn %s)." - the numeric fields are
+    // the stripped (no leading space) decimal values.
+    const line3 = `(User ${score.uid}, Date ${formatWhen(score.day)}, ` +
+        `Gold ${score.gold}, Turn ${score.turns}).`;
+    return { rank: start + 1, highlighted, color, line1, line2, line3 };
+}
+/**
+ * display_score_page (ui-score.c L30): the rows for one page - up to 5 entries
+ * starting at `start`, stopping at `count`. `highlight` is the index to draw in
+ * L_GREEN (or -1 for none).
+ */
+export function scorePageRows(scores, start, count, highlight, names) {
+    const rows = [];
+    for (let n = 0; start < count && n < SCORES_PER_PAGE; start++, n++) {
+        rows.push(scoreRow(scores, start, highlight, names));
+    }
+    return rows;
+}
+/**
+ * All rows for the inclusive-exclusive range [from, to) clamped to the real
+ * record count, in one flat list (convenience over paging). `highlight` is the
+ * highlighted index or -1. Useful for a scroll surface that renders every row.
+ */
+export function scoreRows(scores, from, to, highlight, names) {
+    const start = Math.max(0, from);
+    const end = Math.min(to, scores.length);
+    const rows = [];
+    for (let i = start; i < end; i++) {
+        rows.push(scoreRow(scores, i, highlight, names));
+    }
+    return rows;
+}
+//# sourceMappingURL=display.js.map

package/dist/score/display.js.map

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

package/dist/score/score.d.ts

@@ -0,0 +1,166 @@
+/**
+ * High-score logic, ported from reference/src/score.c and score-util.c
+ * (Angband 4.2.6): the scoring formula, the build/where/add/count/regularize
+ * table operations, and the enter-score gating. All operations here are pure
+ * over an in-memory HighScore[]; persistence arrives through the injected
+ * ScoreStore seam (types.ts), never a filesystem.
+ *
+ * The port operates on a COMPACT list (only real records, no empty padding),
+ * capped at MAX_HISCORES, rather than the C's fixed array of MAX_HISCORES
+ * records with empty slots at the tail. The observable results (insert slot,
+ * shift-and-truncate on add, sort order, count) are identical; see
+ * parity/ledger/high-scores.yaml for the equivalence argument.
+ */
+import type { Player } from "../player/player.js";
+import type { HighScore, ScoreStore } from "./types.js";
+/**
+ * total_points (score.c L28): the whole score is max experience plus a flat
+ * bonus per deepest dungeon level reached. Ported EXACTLY.
+ */
+export declare function totalPoints(p: Player): number;
+/**
+ * The non-Player state build_score reads (score.c build_score, L216). Upstream
+ * pulls these from globals (turn, player_uid, buildid) or the live world
+ * (p->depth is the current cave depth, distinct from p->max_depth). The port
+ * keeps them off Player, so buildScore takes them as deps, matching the
+ * char-sheet's deps idiom (game/char-sheet.ts).
+ */
+export interface BuildScoreDeps {
+    /** died_from: the method-of-death string (p->died_from, or "nobody (yet!)"). */
+    diedFrom: string;
+    /** turn (game-world.c): the game-turn counter at death. */
+    turn: number;
+    /** p->depth: the LIVE dungeon depth (cur_dun), not max_depth. */
+    depth: number;
+    /** p->full_name: the character's name (only first 15 chars are kept). */
+    fullName?: string;
+    /** player_uid: the OS player id. Default 0 (the port has no OS uid). */
+    uid?: number;
+    /** buildid the record is stamped with (what[]). Default ENGINE_VERSION. */
+    buildid?: string;
+    /**
+     * The time of death, for the "@YYYYMMDD" day stamp. NULL/undefined (the
+     * player is not dead) yields "TODAY", exactly as build_score.
+     */
+    deathTime?: Date | null;
+}
+/**
+ * build_score (score.c L216): fill a score record from the player plus the
+ * death-time and cause. The C truncates who to 15 chars ("%-.15s") and how to
+ * 31 (my_strcpy into how[32]); reproduced here. `what` marks the record in
+ * use (a non-empty build id).
+ */
+export declare function buildScore(p: Player, deps: BuildScoreDeps): HighScore;
+/**
+ * highscore_valid (score-util.c L95): a non-empty record must have parseable
+ * numeric fields. With typed storage the only ways a record can be invalid are
+ * a blank build id (treated as empty) or a non-finite number in a numeric
+ * field; NaN/Infinity would break the strtol-equivalent ordering, so they are
+ * rejected exactly as an unparseable C field would be.
+ */
+export declare function highscoreValid(s: HighScore): boolean;
+/**
+ * highscore_cmp (score-util.c L43): order two records best-first. Winners
+ * (how == WINNING_HOW) precede non-winners; then more points precede fewer;
+ * ties keep their existing order (the C uses the record address, which for a
+ * contiguous array is the current order - a stable sort reproduces this).
+ * Returns <0 if a precedes b, >0 if a follows b, 0 for a true tie.
+ */
+export declare function highscoreCmp(a: HighScore, b: HighScore): number;
+/**
+ * highscore_where (score-util.c L276): the index a new (valid, non-empty)
+ * entry would take in a best-first list. Ties prefer the NEW entry
+ * (entry_pts >= score_pts). If it does not fit before any existing record it
+ * takes the first free slot (list length while below the cap) or, when the
+ * list is full, replaces the last record (index MAX_HISCORES - 1).
+ */
+export declare function highscoreWhere(entry: HighScore, scores: readonly HighScore[]): number;
+/**
+ * highscore_add (score.c L72): insert an entry at its slot, shifting lower
+ * records down and dropping anything past MAX_HISCORES. Mutates `scores` in
+ * place (like the C on its array) and returns the slot used.
+ *
+ * The full-list case matches the C's memmove-with-zero-count: highscoreWhere
+ * returns MAX_HISCORES - 1, splicing there pushes the old last record off the
+ * end, and the truncation drops it - i.e. the last entry is replaced.
+ */
+export declare function highscoreAdd(entry: HighScore, scores: HighScore[]): number;
+/** highscore_count (score.c L84): number of real records. */
+export declare function highscoreCount(scores: readonly HighScore[]): number;
+/**
+ * highscore_regularize (score-util.c L199): force the list valid and ordered.
+ * Invalid or empty records are dropped, and the remainder is stable-sorted
+ * best-first (winners, then points, ties in place). Returns a NEW list plus a
+ * flag reporting whether anything changed (the C's `irregular` return).
+ */
+export declare function highscoreRegularize(scores: readonly HighScore[]): {
+    scores: HighScore[];
+    irregular: boolean;
+};
+/**
+ * The outcome of enterScore: either entered (with its slot) or rejected with
+ * the reason the C would msg() about. The C is void + msg(); the port returns
+ * the decision so the shell owns the message.
+ */
+export type EnterScoreOutcome = {
+    entered: true;
+    slot: number;
+} | {
+    entered: false;
+    reason: "cheater" | "wizard" | "borg" | "interrupted" | "retired";
+};
+/**
+ * The gating inputs enter_score checks (score.c L272). The port has no options
+ * table or noscore flags on Player yet, so they arrive as an explicit seam
+ * (defaults = a clean, scored character).
+ */
+export interface EnterScoreGating {
+    /** Any OP_SCORE ("cheating") option is on (score.c L277 loop). */
+    cheated?: boolean;
+    /** p->noscore & (NOSCORE_WIZARD | NOSCORE_DEBUG): a wizard/debug character. */
+    noscore?: boolean;
+    /**
+     * p->noscore & NOSCORE_BORG (score.c:291, the !SCORE_BORGS branch): played by
+     * the Borg. Checked AFTER the wizard bits, so a character that is both is
+     * reported as a wizard, matching the C's else-if chain.
+     */
+    borg?: boolean;
+    /** p->total_winner: a winner is scored even when interrupted/retiring. */
+    totalWinner?: boolean;
+    /** p->died_from (score.c L299/L302): "Interrupting" / "Retiring" are gated. */
+    diedFrom: string;
+}
+/** The host's score gate: Angband NOSCORE bits plus the port-only mod ratchet. */
+export declare function scoreGateNoscore(playerNoscore: boolean, modNoscore: boolean): boolean;
+/**
+ * enter_score (score.c L272): enter a character on the high-score table "if
+ * legal". Cheaters, wizards/debug characters, and non-winning interrupted or
+ * retiring deaths are not scored (in that priority order). Otherwise the entry
+ * is built and added to the store's list.
+ *
+ * Faithful divergence from the C's read/add/write: here read/write go through
+ * the injected ScoreStore, and highscoreAdd already truncates at MAX_HISCORES.
+ */
+export declare function enterScore(store: ScoreStore, player: Player, build: BuildScoreDeps, gating: EnterScoreGating): EnterScoreOutcome;
+/** The score range and highlight predict_score resolves for display. */
+export interface PredictedScores {
+    /** The score list to page over (the provisional entry inserted if alive). */
+    scores: HighScore[];
+    /** First index to show (from). */
+    from: number;
+    /** One past the last index to show (to). */
+    to: number;
+    /** The index to highlight (the current character), or -1 for none. */
+    highlight: number;
+}
+/**
+ * predict_score (ui-score.c L193): find where the current character sits and
+ * pick the neighbourhood to show. A dead character is already in `scores`
+ * (enter_score ran), so we only locate it (highscore_where); a live character
+ * is provisionally inserted (highscore_add) so it appears in the table. On the
+ * top ten we show ranks 1..15; otherwise a window around the entry.
+ *
+ * This is the DATA half; the shell (display_scores_aux) owns the paging loop.
+ */
+export declare function predictScore(scores: HighScore[], entry: HighScore, isDead: boolean): PredictedScores;
+//# sourceMappingURL=score.d.ts.map

package/dist/score/score.d.ts.map

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

package/dist/score/score.js

@@ -0,0 +1,244 @@
+/**
+ * High-score logic, ported from reference/src/score.c and score-util.c
+ * (Angband 4.2.6): the scoring formula, the build/where/add/count/regularize
+ * table operations, and the enter-score gating. All operations here are pure
+ * over an in-memory HighScore[]; persistence arrives through the injected
+ * ScoreStore seam (types.ts), never a filesystem.
+ *
+ * The port operates on a COMPACT list (only real records, no empty padding),
+ * capped at MAX_HISCORES, rather than the C's fixed array of MAX_HISCORES
+ * records with empty slots at the tail. The observable results (insert slot,
+ * shift-and-truncate on add, sort order, count) are identical; see
+ * parity/ledger/high-scores.yaml for the equivalence argument.
+ */
+import { ENGINE_VERSION } from "../version.js";
+import { MAX_HISCORES, WINNING_HOW } from "./types.js";
+/**
+ * Default build id stamped into a record's `what` (score.c build_score uses the
+ * global `buildid`). The web shell may pass a specific build id via
+ * BuildScoreDeps.buildid.
+ *
+ * This was a hardcoded copy of the version, on the reasoning that importing the
+ * barrel's ENGINE_VERSION would make a cycle. True of the barrel, but version.ts
+ * exists precisely so a core module can cite the version without it - and the
+ * copy did exactly what a copy does: the port went to 0.9.0 and every score kept
+ * being stamped 0.1.0.
+ */
+const DEFAULT_BUILDID = ENGINE_VERSION;
+/**
+ * total_points (score.c L28): the whole score is max experience plus a flat
+ * bonus per deepest dungeon level reached. Ported EXACTLY.
+ */
+export function totalPoints(p) {
+    return p.maxExp + 100 * p.maxDepth;
+}
+/** strftime "@%Y%m%d" in LOCAL time (build_score L235 uses localtime). */
+function formatDay(deathTime) {
+    if (!deathTime)
+        return "TODAY";
+    const y = String(deathTime.getFullYear()).padStart(4, "0");
+    const m = String(deathTime.getMonth() + 1).padStart(2, "0");
+    const d = String(deathTime.getDate()).padStart(2, "0");
+    return `@${y}${m}${d}`;
+}
+/**
+ * build_score (score.c L216): fill a score record from the player plus the
+ * death-time and cause. The C truncates who to 15 chars ("%-.15s") and how to
+ * 31 (my_strcpy into how[32]); reproduced here. `what` marks the record in
+ * use (a non-empty build id).
+ */
+export function buildScore(p, deps) {
+    return {
+        what: (deps.buildid ?? DEFAULT_BUILDID).slice(0, 7),
+        pts: totalPoints(p),
+        gold: p.au,
+        turns: deps.turn,
+        day: formatDay(deps.deathTime),
+        who: (deps.fullName ?? "").slice(0, 15),
+        uid: deps.uid ?? 0,
+        pRace: p.race.ridx,
+        pClass: p.cls.cidx,
+        curLev: p.lev,
+        curDun: deps.depth,
+        maxLev: p.maxLev,
+        maxDun: p.maxDepth,
+        how: deps.diedFrom.slice(0, 31),
+    };
+}
+/** A record is "empty"/unused when its build-id marker is blank (what[0]). */
+function isEmpty(s) {
+    return s.what.length === 0;
+}
+/**
+ * highscore_valid (score-util.c L95): a non-empty record must have parseable
+ * numeric fields. With typed storage the only ways a record can be invalid are
+ * a blank build id (treated as empty) or a non-finite number in a numeric
+ * field; NaN/Infinity would break the strtol-equivalent ordering, so they are
+ * rejected exactly as an unparseable C field would be.
+ */
+export function highscoreValid(s) {
+    if (isEmpty(s))
+        return true; // an empty record is valid (all-empty in C)
+    const nums = [
+        s.pts,
+        s.gold,
+        s.turns,
+        s.uid,
+        s.pRace,
+        s.pClass,
+        s.curLev,
+        s.curDun,
+        s.maxLev,
+        s.maxDun,
+    ];
+    return nums.every((n) => Number.isFinite(n));
+}
+/**
+ * highscore_cmp (score-util.c L43): order two records best-first. Winners
+ * (how == WINNING_HOW) precede non-winners; then more points precede fewer;
+ * ties keep their existing order (the C uses the record address, which for a
+ * contiguous array is the current order - a stable sort reproduces this).
+ * Returns <0 if a precedes b, >0 if a follows b, 0 for a true tie.
+ */
+export function highscoreCmp(a, b) {
+    const ae = isEmpty(a);
+    const be = isEmpty(b);
+    if (ae)
+        return be ? 0 : 1; // empty records sort after non-empty ones
+    if (be)
+        return -1;
+    const awinner = a.how === WINNING_HOW;
+    const bwinner = b.how === WINNING_HOW;
+    if (awinner !== bwinner)
+        return awinner ? -1 : 1;
+    if (a.pts !== b.pts)
+        return a.pts > b.pts ? -1 : 1;
+    return 0; // true tie: stable sort keeps current order
+}
+/**
+ * highscore_where (score-util.c L276): the index a new (valid, non-empty)
+ * entry would take in a best-first list. Ties prefer the NEW entry
+ * (entry_pts >= score_pts). If it does not fit before any existing record it
+ * takes the first free slot (list length while below the cap) or, when the
+ * list is full, replaces the last record (index MAX_HISCORES - 1).
+ */
+export function highscoreWhere(entry, scores) {
+    const entryWinner = entry.how === WINNING_HOW;
+    const entryPts = entry.pts;
+    for (let i = 0; i < scores.length; i++) {
+        const s = scores[i];
+        const scoreWinner = s.how === WINNING_HOW;
+        if (entryWinner !== scoreWinner) {
+            if (entryWinner)
+                return i;
+            continue;
+        }
+        if (entryPts >= s.pts)
+            return i;
+    }
+    // Did not fit before any record: first free slot, else replace the last.
+    return scores.length < MAX_HISCORES ? scores.length : MAX_HISCORES - 1;
+}
+/**
+ * highscore_add (score.c L72): insert an entry at its slot, shifting lower
+ * records down and dropping anything past MAX_HISCORES. Mutates `scores` in
+ * place (like the C on its array) and returns the slot used.
+ *
+ * The full-list case matches the C's memmove-with-zero-count: highscoreWhere
+ * returns MAX_HISCORES - 1, splicing there pushes the old last record off the
+ * end, and the truncation drops it - i.e. the last entry is replaced.
+ */
+export function highscoreAdd(entry, scores) {
+    const slot = highscoreWhere(entry, scores);
+    scores.splice(slot, 0, entry);
+    if (scores.length > MAX_HISCORES)
+        scores.length = MAX_HISCORES;
+    return slot;
+}
+/** highscore_count (score.c L84): number of real records. */
+export function highscoreCount(scores) {
+    let n = 0;
+    for (const s of scores) {
+        if (isEmpty(s))
+            break; // empties are tail-only; stop at the first
+        n++;
+    }
+    return n;
+}
+/**
+ * highscore_regularize (score-util.c L199): force the list valid and ordered.
+ * Invalid or empty records are dropped, and the remainder is stable-sorted
+ * best-first (winners, then points, ties in place). Returns a NEW list plus a
+ * flag reporting whether anything changed (the C's `irregular` return).
+ */
+export function highscoreRegularize(scores) {
+    const kept = [];
+    let irregular = false;
+    for (const s of scores) {
+        if (!highscoreValid(s) || isEmpty(s)) {
+            irregular = true; // an invalid/empty record in the body is an irregularity
+            continue;
+        }
+        kept.push(s);
+    }
+    // Detect out-of-order before sorting (stable sort would otherwise hide it).
+    for (let i = 1; i < kept.length; i++) {
+        if (highscoreCmp(kept[i - 1], kept[i]) > 0) {
+            irregular = true;
+            break;
+        }
+    }
+    kept.sort(highscoreCmp);
+    return { scores: kept, irregular };
+}
+/** The host's score gate: Angband NOSCORE bits plus the port-only mod ratchet. */
+export function scoreGateNoscore(playerNoscore, modNoscore) {
+    return playerNoscore || modNoscore;
+}
+/**
+ * enter_score (score.c L272): enter a character on the high-score table "if
+ * legal". Cheaters, wizards/debug characters, and non-winning interrupted or
+ * retiring deaths are not scored (in that priority order). Otherwise the entry
+ * is built and added to the store's list.
+ *
+ * Faithful divergence from the C's read/add/write: here read/write go through
+ * the injected ScoreStore, and highscoreAdd already truncates at MAX_HISCORES.
+ */
+export function enterScore(store, player, build, gating) {
+    if (gating.cheated)
+        return { entered: false, reason: "cheater" };
+    if (gating.noscore)
+        return { entered: false, reason: "wizard" };
+    if (gating.borg)
+        return { entered: false, reason: "borg" };
+    if (!gating.totalWinner && gating.diedFrom === "Interrupting") {
+        return { entered: false, reason: "interrupted" };
+    }
+    if (!gating.totalWinner && gating.diedFrom === "Retiring") {
+        return { entered: false, reason: "retired" };
+    }
+    const entry = buildScore(player, build);
+    const scores = store.read();
+    const slot = highscoreAdd(entry, scores);
+    store.write(scores);
+    return { entered: true, slot };
+}
+/**
+ * predict_score (ui-score.c L193): find where the current character sits and
+ * pick the neighbourhood to show. A dead character is already in `scores`
+ * (enter_score ran), so we only locate it (highscore_where); a live character
+ * is provisionally inserted (highscore_add) so it appears in the table. On the
+ * top ten we show ranks 1..15; otherwise a window around the entry.
+ *
+ * This is the DATA half; the shell (display_scores_aux) owns the paging loop.
+ */
+export function predictScore(scores, entry, isDead) {
+    const j = isDead
+        ? highscoreWhere(entry, scores)
+        : highscoreAdd(entry, scores);
+    if (j < 10) {
+        return { scores, from: 0, to: 15, highlight: j };
+    }
+    return { scores, from: j - 2, to: j + 7, highlight: j };
+}
+//# sourceMappingURL=score.js.map