@maka/maka-cli 5.49.0 → 5.50.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/range.js

@@ -0,0 +1,69 @@
+import { Category } from '../types/shared/item-enum.js';
+const RANGE_BRACKETS = {
+    pistol: { short: 5, medium: 20, long: 40, extreme: 60 },
+    smg: { short: 5, medium: 15, long: 30, extreme: 50 },
+    // Indoor-capped: canon's assault-rifle extreme band (351-550m) never
+    // fits inside a room this engine can synthesize (huge tops out at
+    // ~34m diagonal) -- the bracket still orders correctly, it just never
+    // reaches its outer edge in play.
+    rifle: { short: 25, medium: 150, long: 350, extreme: 550 },
+    shotgun: { short: 15, medium: 30, long: 45, extreme: 60 },
+    throw: { short: 5, medium: 10, long: 20, extreme: 40 },
+};
+const NAME_HINTS = [
+    [/\b(assault rifle|sniper rifle|carbine|\brifle\b)\b/i, 'rifle'],
+    [/\bshotgun|scattergun\b/i, 'shotgun'],
+    [/\b(smg|submachine|machine pistol|uzi|mp5|mp7)\b/i, 'smg'],
+    [/\b(knife|blade|katana|sword|axe|club|bat|baton|monofilament|garrote|fist|unarmed)\b/i, 'melee'],
+    [/\b(grenade|throwing|shuriken)\b/i, 'throw'],
+];
+/** Melee category always wins outright; otherwise name keywords, then
+ *  a pistol default (see module doc). */
+export function classifyWeapon(item) {
+    if (!item)
+        return 'pistol';
+    if (item.category === Category.MeleeWeapon)
+        return 'melee';
+    for (const [re, cls] of NAME_HINTS) {
+        if (re.test(item.name))
+            return cls;
+    }
+    return 'pistol';
+}
+export function isFirearmClass(cls) {
+    return cls !== 'melee';
+}
+/** SR5 range-bracket dice-pool penalty (p.185): 0 / -1 / -3 / -6, or
+ *  'out-of-range' beyond the extreme band. Melee has no range penalty
+ *  -- callers gate melee through adjacency instead (see attack.ts). */
+export function rangePenalty(meters, cls) {
+    if (cls === 'melee')
+        return 0;
+    const b = RANGE_BRACKETS[cls];
+    if (meters <= b.short)
+        return 0;
+    if (meters <= b.medium)
+        return -1;
+    if (meters <= b.long)
+        return -3;
+    if (meters <= b.extreme)
+        return -6;
+    return 'out-of-range';
+}
+/** The bracket NAME a distance falls in, for narration/meta lines
+ *  ("~22 m, long range"). */
+export function rangeBracketName(meters, cls) {
+    if (cls === 'melee')
+        return 'short';
+    const b = RANGE_BRACKETS[cls];
+    if (meters <= b.short)
+        return 'short';
+    if (meters <= b.medium)
+        return 'medium';
+    if (meters <= b.long)
+        return 'long';
+    if (meters <= b.extreme)
+        return 'extreme';
+    return 'out-of-range';
+}
+//# sourceMappingURL=range.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/range.js.map

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

package/bundle/typescript/src/commands/game/sideQuest/utilities/room-grid.d.ts

@@ -0,0 +1,186 @@
+import { Direction } from '../types/shared/direction-enum.js';
+/**
+ * ROOM GRIDS (spatial wave, 2026-08-25; player ruling: barriers should
+ * be impassable TERRAIN removable by the proper mechanism, not a door
+ * lock -- which meant rooms first needed actual SPACE). Every room's
+ * size class maps to an x,y,z cell grid; every "at" spot (see
+ * utilities/spots.ts) anchors to a cell in it. This module is the pure
+ * spatial engine: layout synthesis, pathing, distance, and cover --
+ * NO Room/Scene import (map-view.ts precedent), so it stays safe in
+ * the server's engine graph (no import.meta anywhere reachable from
+ * headless.js).
+ *
+ * THE KEYSTONE (never violate): actors never gain coordinates. A
+ * Player's only position is still `atSpot: string` (spots.ts). This
+ * module only answers "where is spot X, and what lies between spots
+ * X and Y" -- spots.ts translates spot NAMES into grid queries, and
+ * nothing above that layer ever touches a GridCoord directly.
+ *
+ * DETERMINISM CONTRACT: `synthesizeGrid` is a pure function seeded by
+ * `roomName` (mulberry32 PRNG over an FNV-1a hash) -- identical input
+ * always produces an identical grid, on any machine, any process, any
+ * reload. The grid is therefore NEVER serialized into seeds or saves;
+ * it's recomputed on demand from data that already IS persisted (the
+ * room's spots/size/exits/puzzle hints). See Room.ensureGrid.
+ */
+export interface GridCoord {
+    x: number;
+    y: number;
+    z: number;
+}
+export declare const METERS_PER_CELL = 2;
+export declare const METERS_PER_LEVEL = 3;
+export declare const key: (c: GridCoord) => string;
+export type RoomSize = 'tiny' | 'small' | 'medium' | 'large' | 'huge';
+export type WallSide = 'north' | 'south' | 'east' | 'west';
+export type SpotPlace = WallSide | 'northeast corner' | 'northwest corner' | 'southeast corner' | 'southwest corner' | 'center';
+export type VerticalKind = 'stairs' | 'ladder' | 'climb';
+/** The x,y cell footprint a size class implies -- the same table
+ *  synthesis uses, exposed for DISPLAY-ONLY consumers that have no
+ *  grid to read (utilities/room-view.ts draws a spotless room's shell
+ *  from this; a spotless room never synthesizes a grid, THE COMPAT
+ *  RULE, and must not start doing so just to be drawn). */
+export declare function dimsForSize(size?: RoomSize): {
+    x: number;
+    y: number;
+};
+interface IVerticalLink {
+    kind: VerticalKind;
+    toZ: number;
+}
+export interface ITerrainRegion {
+    id: string;
+    label: string;
+    /** The puzzle whose solve/bypass clears this region (solve.ts /
+     *  bypass-command.ts call Room.clearTerrainFor(puzzleName)). */
+    puzzleName: string;
+    cells: GridCoord[];
+    cleared: boolean;
+    cover: 'partial' | 'good';
+    /** False when synthesis couldn't seal the guarded cell within the
+     *  footprint budget (an open room, a small footprint hint) -- the
+     *  region still renders and still gives cover, but movement is never
+     *  blocked by it. Logged at synthesis time; never bricks a room. */
+    blocking: boolean;
+}
+export interface IRoomGrid {
+    dims: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Cells permitting a z transition, keyed at the LOWER (from) cell.
+     *  Both directions are pathable (going down is always free; going up
+     *  costs a roll for 'climb' -- move.ts enforces that, this module
+     *  only tracks connectivity). */
+    vertical: Map<string, IVerticalLink>;
+    /** A spot's ANCHOR cell -- its address for distance, pathing targets
+     *  and terrain guarding. Always the first cell of its footprint. */
+    spotCells: Map<string, GridCoord>;
+    /** THE FURNITURE ITSELF (player ruling 2026-08-25: "bar, table,
+     *  booths can have larger geometry than just one cell"): every cell
+     *  a named place physically fills, anchor included. A long bar runs
+     *  three cells down its wall; a crate is one. Bodies never stand in
+     *  these (see spots.ts seatingIn) and movement routes around them. */
+    spotFootprints: Map<string, GridCoord[]>;
+    exitCells: Map<Direction, GridCoord>;
+    terrain: Map<string, ITerrainRegion>;
+}
+export interface IGridSynthesisSpot {
+    name: string;
+    place?: SpotPlace;
+    level?: number;
+    tags?: string[];
+}
+export interface IGridSynthesisExit {
+    direction: Direction;
+    spotName?: string;
+}
+export interface IGridSynthesisLevel {
+    name: string;
+    side: WallSide;
+    kind: 'catwalk' | 'balcony' | 'mezzanine';
+}
+export interface IGridSynthesisTerrainHint {
+    puzzleName: string;
+    label: string;
+    guards: {
+        kind: 'exit';
+        direction: Direction;
+    } | {
+        kind: 'spot';
+        spotName: string;
+    };
+    footprint: 'small' | 'medium' | 'large';
+}
+export interface IGridSynthesisInput {
+    roomName: string;
+    size?: RoomSize;
+    spots: IGridSynthesisSpot[];
+    exits: IGridSynthesisExit[];
+    levels?: IGridSynthesisLevel[];
+    terrainHints: IGridSynthesisTerrainHint[];
+}
+/** FNV-1a, 32-bit. Deterministic string -> uint32. */
+export declare function hashFnv1a(str: string): number;
+/** mulberry32: tiny, fast, deterministic PRNG -- () => [0,1). */
+export declare function mulberry32(seed: number): () => number;
+/** Whether an uncleared blocking region seals this cell -- the same
+ *  test pathing uses, exposed so spots.ts can seat bodies only on
+ *  ground they could actually stand on. */
+export declare function isCellBlocked(grid: IRoomGrid, c: GridCoord): boolean;
+/** BFS shortest path between two cells, or undefined if unreachable
+ *  through open (non-blocked, in-bounds) cells. `levelCells` recomputed
+ *  from the grid's synthesis metadata (kept on the grid via a WeakMap
+ *  so callers never have to pass it around -- see synthesizeGrid).
+ *
+ * FOUR PASSES, cheapest-and-safest first. Two things are avoided when
+ * anything else will do, and they are NOT equally bad:
+ *  1. a 'climb' link is the RISKY alternative to a level's own stairs
+ *     or ladder (move.ts rolls Athletics on it, and a failure is a
+ *     fall), so it is the LAST thing given up;
+ *  2. a cell holding somebody's body is merely in the way -- squeezing
+ *     past a bystander beats free-climbing a wall every time.
+ * Hence: (no climb, no squeeze) -> (no climb, squeeze) -> (climb, no
+ * squeeze) -> (climb, squeeze). Bodies never make a destination
+ * unreachable on their own; the worst they can do is force a squeeze,
+ * which move.ts narrates. `pathSqueezes` tells a caller which
+ * happened. */
+export declare function findPath(grid: IRoomGrid, from: GridCoord, to: GridCoord, occupied?: ReadonlySet<string>): GridCoord[] | undefined;
+/** Whether this route threads a cell somebody is standing in -- i.e.
+ *  findPath had to fall back past the no-squeeze passes. */
+export declare function pathSqueezes(path: GridCoord[], occupied?: ReadonlySet<string>): boolean;
+/** Straight-line 3D distance in meters between two cells. */
+export declare function distanceMeters(a: GridCoord, b: GridCoord): number;
+/** Every cell that exists at z-level `z`: ground (z=0) is implicitly the
+ *  whole x*y footprint; an upper level is only its declared strip. The
+ *  shape utilities/room-view.ts needs to draw each floor without
+ *  reaching into LEVEL_CELLS itself (module-private -- see
+ *  synthesizeGrid). Declared before LEVEL_CELLS below; fine at call
+ *  time (the const is bound long before any consumer runs). */
+export declare function levelFootprint(grid: IRoomGrid, z: number): GridCoord[];
+/** Cover between two cells: any uncleared terrain region (blocking OR
+ *  degraded-to-scenery -- both still occlude) whose cells intersect
+ *  the line of fire, excluding the two endpoints themselves. 'good'
+ *  wins over 'partial' when both are present. */
+export declare function coverBetween(grid: IRoomGrid, from: GridCoord, to: GridCoord): 'partial' | 'good' | undefined;
+/** Which uncleared blocking region is sealing the path from `from` to
+ *  `to`: re-runs BFS with each candidate region's cells excluded, and
+ *  returns the smallest one whose removal opens a path. Undefined when
+ *  no path exists even with every region cleared (a genuinely
+ *  disconnected room -- a synthesis bug, not a player-facing state). */
+export declare function blockingRegionFor(grid: IRoomGrid, from: GridCoord, to: GridCoord): ITerrainRegion | undefined;
+/** SR5 p.172 (RAG-verified): DV = meters fallen, only beyond 3m; AP-4
+ *  applies at the caller (resisted with Body+Armor -- move.ts's job). */
+export declare function fallDamageDV(zSteps: number): number;
+/** Does this path cross a 'climb' vertical link (the riskier route --
+ *  stairs/ladder never roll anything)? Returns the z-delta of the
+ *  riskiest crossing (for fallDamageDV), or undefined when the path
+ *  never touches one. */
+export declare function pathClimbSteps(grid: IRoomGrid, path: GridCoord[]): number | undefined;
+/** Deterministic synthesis -- see the module doc for the contract.
+ *  Order of operations below IS the contract; never reorder without
+ *  bumping every consumer of the determinism guarantee. */
+export declare function synthesizeGrid(input: IGridSynthesisInput): IRoomGrid;
+export declare const OPEN_FLOOR_NAME = "open floor";
+export {};