@netforge/engine 0.0.0-stage → 0.1.0

package/dist/rules/collector.d.ts

@@ -0,0 +1,161 @@
+/**
+ * The monster collector genre (template "collector"): a shared marsh where
+ * each player walks their keeper, meets wild creatures in tall grass,
+ * fights them turn by turn with a team of three, snares the ones worth
+ * keeping and levels them up, while the whole room wears down one warden
+ * before dusk.
+ *
+ * Every roll (encounters, accuracy, damage spread, snares, the foe's move)
+ * comes from the state's own PRNG, so a run replays exactly from its
+ * inputs. Battles are private: a player's view shows their own battle and
+ * team; the others see only the creature beside them.
+ */
+import type { GameManifest } from "../api/registry.js";
+import { type CreatureDef, type MarshDef, type MoveDef } from "../api/collector.js";
+import type { RulesContext, RulesGenre } from "./kit.js";
+/** Metres per tile. */
+export declare const MARSH_TILE = 2;
+/** Actions (RulesInput.act). */
+export declare const CollectorAct: {
+    readonly Pick: 1;
+    readonly Move: 2;
+    readonly Swap: 3;
+    readonly Snare: 4;
+    readonly Flee: 5;
+    readonly Challenge: 6;
+};
+/** What a battle log line says happened. */
+export declare const LogKind: {
+    readonly Hit: 1;
+    readonly Miss: 2;
+    readonly Heal: 3;
+    readonly Guard: 4;
+    readonly Swap: 5;
+    readonly Snared: 6;
+    readonly Slipped: 7;
+    readonly Fled: 8;
+    readonly Won: 9;
+    readonly Fainted: 10;
+    readonly Wiped: 11;
+    readonly Level: 12;
+    readonly Met: 13;
+    readonly Warden: 14;
+};
+export interface Mon {
+    species: number;
+    level: number;
+    hp: number;
+    xp: number;
+    guard: boolean;
+}
+export interface LogLine {
+    readonly n: number;
+    readonly kind: number;
+    /** 0: yours, 1: the foe. */
+    readonly who: 0 | 1;
+    readonly move?: number;
+    readonly dmg?: number;
+    /** 1 strong, -1 weak, 0 plain. */
+    readonly eff?: number;
+    readonly value?: number;
+}
+interface Battle {
+    foe: Mon;
+    warden: boolean;
+    turn: number;
+}
+interface Keeper {
+    team: Mon[];
+    active: number;
+    box: number;
+    snares: number;
+    snaresBought: number;
+    battle: Battle | null;
+    log: LogLine[];
+    logN: number;
+    lastTile: number;
+    cooldown: number;
+    toCamp: boolean;
+    catches: number;
+    wins: number;
+    wipes: number;
+    wardenDamage: number;
+    x: number;
+    z: number;
+    yaw: number;
+    joinedTick: number;
+}
+export interface CollectorState {
+    rng: {
+        s: number;
+    };
+    ctx: RulesContext;
+    tick: number;
+    dusk: number;
+    wardenHp: number;
+    wardenMax: number;
+    wardenDown: boolean;
+    /** Players who hurt the warden (they share its fall). */
+    wardenHurt: Set<number>;
+    keepers: Map<number, Keeper>;
+    activity: number;
+    battlesWon: number;
+    catches: number;
+    wipes: number;
+    peakBattles: number;
+}
+export interface CompiledMarsh {
+    readonly w: number;
+    readonly h: number;
+    readonly blocked: Uint8Array;
+    readonly water: Uint8Array;
+    /** Grass zone index + 1 per tile, 0 for none. */
+    readonly grass: Uint8Array;
+    readonly camp: readonly [number, number];
+    readonly warden: readonly [number, number];
+}
+export interface CompiledCollector {
+    readonly marsh: MarshDef;
+    readonly map: CompiledMarsh;
+    readonly creatures: readonly (CreatureDef & {
+        id: string;
+        el: number;
+        moveIdx: number[];
+    })[];
+    readonly moves: readonly (MoveDef & {
+        id: string;
+        el: number;
+    })[];
+    readonly starters: readonly number[];
+    readonly wardenSpecies: number;
+    readonly pools: readonly {
+        rate: number;
+        pool: {
+            species: number;
+            weight: number;
+            level: readonly [number, number];
+        }[];
+    }[];
+}
+export declare function compileCollector(m: GameManifest): CompiledCollector;
+/** Strong (1), weak (-1) or plain (0): each element beats the next in the cycle. */
+export declare function effectiveness(attack: number, defend: number): number;
+/** A stat at a level: +12% a level. */
+export declare const statAt: (base: number, level: number) => number;
+/** Max health at a level. */
+export declare const hpAt: (base: number, level: number) => number;
+/** XP to the next level. */
+export declare const xpNeed: (level: number) => number;
+/** The tile at a fixed-unit point (marsh centred on the origin), or -1 off the map. */
+export declare function marshTile(map: Pick<CompiledMarsh, "w" | "h">, x: number, z: number): number;
+/** A tile's centre in fixed units. */
+export declare function marshCenter(map: Pick<CompiledMarsh, "w" | "h">, tx: number, ty: number): {
+    x: number;
+    z: number;
+};
+/** Tiles from `from` to `goal` (excluding `from`), around blocked tiles; empty when there is no way. */
+export declare function marshRoute(map: CompiledMarsh, from: number, goal: number): number[];
+export declare function collectorGenre(m: GameManifest): RulesGenre<CollectorState> & {
+    readonly game: CompiledCollector;
+};
+export {};