@jgengine/core 0.6.0 → 0.7.0

package/dist/board/laneBoard.js

@@ -0,0 +1,114 @@
+function emptyLane(sides) {
+    const cells = {};
+    for (const side of sides)
+        cells[side] = [];
+    return cells;
+}
+export function createLaneBoardState(config) {
+    if (config.laneCount <= 0)
+        throw new Error("laneBoard needs at least one lane");
+    if (config.sides.length === 0)
+        throw new Error("laneBoard needs at least one side");
+    const lanes = [];
+    for (let i = 0; i < config.laneCount; i++)
+        lanes.push(emptyLane(config.sides));
+    return { lanes };
+}
+function validLane(state, lane) {
+    return Number.isInteger(lane) && lane >= 0 && lane < state.lanes.length;
+}
+export function placeCard(state, config, lane, side, card) {
+    if (!validLane(state, lane))
+        return { status: "rejected", reason: "invalid-lane" };
+    if (!config.sides.includes(side))
+        return { status: "rejected", reason: "invalid-side" };
+    const lanes = state.lanes.slice();
+    const cell = lanes[lane];
+    lanes[lane] = { ...cell, [side]: [...cell[side], card] };
+    return { status: "ok", state: { lanes } };
+}
+export function removeCard(state, lane, side, predicate) {
+    if (!validLane(state, lane))
+        return { status: "rejected", reason: "invalid-lane" };
+    const cell = state.lanes[lane];
+    if (cell[side] === undefined)
+        return { status: "rejected", reason: "invalid-side" };
+    const lanes = state.lanes.slice();
+    lanes[lane] = { ...cell, [side]: cell[side].filter((card, index) => !predicate(card, index)) };
+    return { status: "ok", state: { lanes } };
+}
+export function laneAggregate(state, config, lane, side) {
+    const cards = state.lanes[lane]?.[side] ?? [];
+    let subtotal = 0;
+    for (const card of cards)
+        subtotal += config.power(card);
+    const rule = config.laneRules?.[lane] ?? null;
+    const total = rule ? rule.apply({ lane, side, cards, subtotal }) : subtotal;
+    return { lane, side, subtotal, total, count: cards.length };
+}
+export function laneOutcome(state, config, lane) {
+    const totals = {};
+    let winner = null;
+    let best = -Infinity;
+    let tie = false;
+    for (const side of config.sides) {
+        const total = laneAggregate(state, config, lane, side).total;
+        totals[side] = total;
+        if (total > best) {
+            best = total;
+            winner = side;
+            tie = false;
+        }
+        else if (total === best) {
+            tie = true;
+        }
+    }
+    return { lane, totals, winner: tie ? null : winner };
+}
+export function boardTotals(state, config) {
+    const totals = {};
+    for (const side of config.sides)
+        totals[side] = 0;
+    for (let lane = 0; lane < state.lanes.length; lane++) {
+        for (const side of config.sides) {
+            totals[side] += laneAggregate(state, config, lane, side).total;
+        }
+    }
+    return totals;
+}
+export function lanesWon(state, config) {
+    const won = {};
+    for (const side of config.sides)
+        won[side] = 0;
+    for (let lane = 0; lane < state.lanes.length; lane++) {
+        const outcome = laneOutcome(state, config, lane);
+        if (outcome.winner !== null)
+            won[outcome.winner] += 1;
+    }
+    return won;
+}
+export function createLaneBoard(config) {
+    let state = createLaneBoardState(config);
+    return {
+        state: () => state,
+        place(lane, side, card) {
+            const result = placeCard(state, config, lane, side, card);
+            if (result.status === "ok")
+                state = result.state;
+            return result;
+        },
+        remove(lane, side, predicate) {
+            const result = removeCard(state, lane, side, predicate);
+            if (result.status === "ok")
+                state = result.state;
+            return result;
+        },
+        aggregate: (lane, side) => laneAggregate(state, config, lane, side),
+        outcome: (lane) => laneOutcome(state, config, lane),
+        totals: () => boardTotals(state, config),
+        lanesWon: () => lanesWon(state, config),
+        reset(next) {
+            state = next ?? createLaneBoardState(config);
+        },
+    };
+}

package/dist/board/timelineBoard.d.ts

@@ -0,0 +1,36 @@
+export interface TimelineSlotConfig {
+    id: string;
+    cooldownMs: number;
+    enabled?: boolean;
+    offsetMs?: number;
+}
+export interface TimelineSlot {
+    readonly id: string;
+    readonly cooldownMs: number;
+    readonly remainingMs: number;
+    readonly enabled: boolean;
+}
+export interface TimelineBoardState {
+    readonly slots: readonly TimelineSlot[];
+    readonly elapsedMs: number;
+}
+export interface TimelineFire {
+    slotId: string;
+    slotIndex: number;
+    atMs: number;
+}
+export interface TimelineTickResult {
+    state: TimelineBoardState;
+    fires: readonly TimelineFire[];
+}
+export declare function createTimelineBoardState(slots: readonly TimelineSlotConfig[]): TimelineBoardState;
+export declare function tickTimeline(state: TimelineBoardState, dtMs: number): TimelineTickResult;
+export declare function setSlotEnabled(state: TimelineBoardState, slotId: string, enabled: boolean): TimelineBoardState;
+export declare function resetSlot(state: TimelineBoardState, slotId: string, remainingMs?: number): TimelineBoardState;
+export interface TimelineBoard {
+    state(): TimelineBoardState;
+    tick(dtMs: number): readonly TimelineFire[];
+    setEnabled(slotId: string, enabled: boolean): void;
+    reset(slotId?: string, remainingMs?: number): void;
+}
+export declare function createTimelineBoard(slots: readonly TimelineSlotConfig[]): TimelineBoard;

package/dist/board/timelineBoard.js

@@ -0,0 +1,70 @@
+export function createTimelineBoardState(slots) {
+    const seen = new Set();
+    const built = [];
+    for (const slot of slots) {
+        if (slot.cooldownMs <= 0)
+            throw new Error(`timeline slot "${slot.id}" needs a positive cooldown`);
+        if (seen.has(slot.id))
+            throw new Error(`duplicate timeline slot id: ${slot.id}`);
+        seen.add(slot.id);
+        built.push({
+            id: slot.id,
+            cooldownMs: slot.cooldownMs,
+            remainingMs: slot.offsetMs ?? slot.cooldownMs,
+            enabled: slot.enabled ?? true,
+        });
+    }
+    return { slots: built, elapsedMs: 0 };
+}
+export function tickTimeline(state, dtMs) {
+    if (dtMs <= 0)
+        return { state, fires: [] };
+    const fires = [];
+    const nextSlots = state.slots.map((slot, slotIndex) => {
+        if (!slot.enabled)
+            return slot;
+        let remaining = slot.remainingMs;
+        let t = remaining;
+        while (t <= dtMs) {
+            fires.push({ slotId: slot.id, slotIndex, atMs: state.elapsedMs + t });
+            t += slot.cooldownMs;
+        }
+        remaining = t - dtMs;
+        return { ...slot, remainingMs: remaining };
+    });
+    fires.sort((a, b) => (a.atMs === b.atMs ? a.slotIndex - b.slotIndex : a.atMs - b.atMs));
+    return {
+        state: { slots: nextSlots, elapsedMs: state.elapsedMs + dtMs },
+        fires,
+    };
+}
+export function setSlotEnabled(state, slotId, enabled) {
+    return {
+        ...state,
+        slots: state.slots.map((slot) => (slot.id === slotId ? { ...slot, enabled } : slot)),
+    };
+}
+export function resetSlot(state, slotId, remainingMs) {
+    return {
+        ...state,
+        slots: state.slots.map((slot) => slot.id === slotId ? { ...slot, remainingMs: remainingMs ?? slot.cooldownMs } : slot),
+    };
+}
+export function createTimelineBoard(slots) {
+    const initial = slots;
+    let state = createTimelineBoardState(slots);
+    return {
+        state: () => state,
+        tick(dtMs) {
+            const result = tickTimeline(state, dtMs);
+            state = result.state;
+            return result.fires;
+        },
+        setEnabled(slotId, enabled) {
+            state = setSlotEnabled(state, slotId, enabled);
+        },
+        reset(slotId, remainingMs) {
+            state = slotId === undefined ? createTimelineBoardState(initial) : resetSlot(state, slotId, remainingMs);
+        },
+    };
+}

package/dist/cards/cardPile.d.ts

@@ -0,0 +1,63 @@
+export type ZoneName = string;
+export interface CardPileConfig {
+    zones: readonly ZoneName[];
+    drawFrom?: ZoneName;
+    discardTo?: ZoneName;
+    handZone?: ZoneName;
+    handLimit?: number;
+    reshuffleFrom?: ZoneName;
+}
+export interface CardPileState {
+    readonly zones: Readonly<Record<ZoneName, readonly string[]>>;
+}
+export interface DrawResult {
+    state: CardPileState;
+    drawn: readonly string[];
+    reshuffled: boolean;
+}
+export type PileRejection = "unknown-zone" | "card-not-in-zone" | "hand-limit" | "empty-source";
+export interface PileMoveResult {
+    status: "ok";
+    state: CardPileState;
+}
+export interface PileMoveRejected {
+    status: "rejected";
+    reason: PileRejection;
+    detail?: string;
+}
+export type PileResult = PileMoveResult | PileMoveRejected;
+export declare function pileRng(seed: string | number): () => number;
+export declare function shuffleWithRng<T>(values: readonly T[], rng: () => number): T[];
+export declare function createCardPileState(config: CardPileConfig, initial?: Partial<Record<ZoneName, readonly string[]>>): CardPileState;
+export declare function zoneOf(state: CardPileState, cardId: string): ZoneName | null;
+export declare function countIn(state: CardPileState, zone: ZoneName): number;
+export declare function peek(state: CardPileState, zone: ZoneName, n?: number): readonly string[];
+export declare function shuffleZone(state: CardPileState, zone: ZoneName, seed: string | number): CardPileState;
+export declare function moveCards(state: CardPileState, ids: readonly string[], from: ZoneName, to: ZoneName, position?: "top" | "bottom"): PileResult;
+export declare function draw(state: CardPileState, n: number, options: {
+    from: ZoneName;
+    to: ZoneName;
+    handLimit?: number;
+    reshuffleFrom?: ZoneName;
+    seed?: string | number;
+}): DrawResult;
+export interface CardPile {
+    state(): CardPileState;
+    zones(): readonly ZoneName[];
+    count(zone: ZoneName): number;
+    peek(zone: ZoneName, n?: number): readonly string[];
+    zoneOf(cardId: string): ZoneName | null;
+    shuffle(zone: ZoneName | undefined, seed: string | number): void;
+    draw(n: number, options?: {
+        from?: ZoneName;
+        to?: ZoneName;
+    }): readonly string[];
+    discard(ids: readonly string[], options?: {
+        from?: ZoneName;
+        to?: ZoneName;
+    }): PileResult;
+    exhaust(ids: readonly string[], exhaustZone: ZoneName, from?: ZoneName): PileResult;
+    move(ids: readonly string[], from: ZoneName, to: ZoneName, position?: "top" | "bottom"): PileResult;
+    reset(next: CardPileState): void;
+}
+export declare function createCardPile(config: CardPileConfig, initial?: Partial<Record<ZoneName, readonly string[]>>): CardPile;

package/dist/cards/cardPile.js

@@ -0,0 +1,166 @@
+function fnv1a(text) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+export function pileRng(seed) {
+    let a = (typeof seed === "number" ? seed >>> 0 : fnv1a(seed)) >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export function shuffleWithRng(values, rng) {
+    const out = values.slice();
+    for (let i = out.length - 1; i > 0; i--) {
+        const j = Math.floor(rng() * (i + 1));
+        const tmp = out[i];
+        out[i] = out[j];
+        out[j] = tmp;
+    }
+    return out;
+}
+function assertZone(state, zone) {
+    if (!(zone in state.zones))
+        throw new Error(`unknown card-pile zone: ${zone}`);
+}
+export function createCardPileState(config, initial) {
+    if (config.zones.length === 0)
+        throw new Error("card pile needs at least one zone");
+    const zones = {};
+    for (const zone of config.zones)
+        zones[zone] = (initial?.[zone] ?? []).slice();
+    const guard = (zone, label) => {
+        if (zone !== undefined && !(zone in zones)) {
+            throw new Error(`${label} names an undeclared zone: ${zone}`);
+        }
+    };
+    guard(config.drawFrom, "drawFrom");
+    guard(config.discardTo, "discardTo");
+    guard(config.handZone, "handZone");
+    guard(config.reshuffleFrom, "reshuffleFrom");
+    return { zones };
+}
+export function zoneOf(state, cardId) {
+    for (const [zone, cards] of Object.entries(state.zones)) {
+        if (cards.includes(cardId))
+            return zone;
+    }
+    return null;
+}
+export function countIn(state, zone) {
+    assertZone(state, zone);
+    return state.zones[zone].length;
+}
+export function peek(state, zone, n = 1) {
+    assertZone(state, zone);
+    return state.zones[zone].slice(0, Math.max(0, n));
+}
+export function shuffleZone(state, zone, seed) {
+    assertZone(state, zone);
+    return { zones: { ...state.zones, [zone]: shuffleWithRng(state.zones[zone], pileRng(seed)) } };
+}
+export function moveCards(state, ids, from, to, position = "top") {
+    assertZone(state, from);
+    assertZone(state, to);
+    const source = state.zones[from];
+    for (const id of ids) {
+        if (!source.includes(id))
+            return { status: "rejected", reason: "card-not-in-zone", detail: id };
+    }
+    const idSet = new Set(ids);
+    const nextFrom = source.filter((id) => !idSet.has(id));
+    const dest = state.zones[to];
+    const nextTo = position === "top" ? [...ids, ...dest] : [...dest, ...ids];
+    return { status: "ok", state: { zones: { ...state.zones, [from]: nextFrom, [to]: nextTo } } };
+}
+export function draw(state, n, options) {
+    assertZone(state, options.from);
+    assertZone(state, options.to);
+    if (options.reshuffleFrom !== undefined)
+        assertZone(state, options.reshuffleFrom);
+    let current = state;
+    let reshuffled = false;
+    const drawn = [];
+    const wanted = Math.max(0, Math.floor(n));
+    for (let i = 0; i < wanted; i++) {
+        if (options.handLimit !== undefined && current.zones[options.to].length >= options.handLimit) {
+            break;
+        }
+        if (current.zones[options.from].length === 0) {
+            if (options.reshuffleFrom === undefined || current.zones[options.reshuffleFrom].length === 0) {
+                break;
+            }
+            const seed = options.seed ?? drawn.length + i;
+            const shuffledSource = shuffleWithRng(current.zones[options.reshuffleFrom], pileRng(seed));
+            current = {
+                zones: { ...current.zones, [options.from]: shuffledSource, [options.reshuffleFrom]: [] },
+            };
+            reshuffled = true;
+        }
+        const source = current.zones[options.from];
+        const top = source[0];
+        drawn.push(top);
+        current = {
+            zones: {
+                ...current.zones,
+                [options.from]: source.slice(1),
+                [options.to]: [...current.zones[options.to], top],
+            },
+        };
+    }
+    return { state: current, drawn, reshuffled };
+}
+export function createCardPile(config, initial) {
+    let state = createCardPileState(config, initial);
+    const drawFrom = config.drawFrom ?? config.zones[0];
+    const handZone = config.handZone ?? config.zones[Math.min(1, config.zones.length - 1)];
+    const discardTo = config.discardTo ?? config.zones[config.zones.length - 1];
+    return {
+        state: () => state,
+        zones: () => config.zones,
+        count: (zone) => countIn(state, zone),
+        peek: (zone, n) => peek(state, zone, n),
+        zoneOf: (cardId) => zoneOf(state, cardId),
+        shuffle(zone, seed) {
+            state = shuffleZone(state, zone ?? drawFrom, seed);
+        },
+        draw(n, options) {
+            const result = draw(state, n, {
+                from: options?.from ?? drawFrom,
+                to: options?.to ?? handZone,
+                handLimit: config.handLimit,
+                reshuffleFrom: config.reshuffleFrom,
+            });
+            state = result.state;
+            return result.drawn;
+        },
+        discard(ids, options) {
+            const result = moveCards(state, ids, options?.from ?? handZone, options?.to ?? discardTo, "top");
+            if (result.status === "ok")
+                state = result.state;
+            return result;
+        },
+        exhaust(ids, exhaustZone, from) {
+            const result = moveCards(state, ids, from ?? handZone, exhaustZone, "top");
+            if (result.status === "ok")
+                state = result.state;
+            return result;
+        },
+        move(ids, from, to, position) {
+            const result = moveCards(state, ids, from, to, position);
+            if (result.status === "ok")
+                state = result.state;
+            return result;
+        },
+        reset(next) {
+            state = next;
+        },
+    };
+}

package/dist/cards/modifierPipeline.d.ts

@@ -0,0 +1,33 @@
+export interface Modifier<V> {
+    id: string;
+    source?: string;
+    apply: (value: V, context: PipelineContext<V>) => V;
+}
+export interface PipelineContext<V> {
+    base: V;
+    index: number;
+    trace: readonly TraceStep<V>[];
+}
+export interface TraceStep<V> {
+    id: string;
+    source?: string;
+    index: number;
+    before: V;
+    after: V;
+    changed: boolean;
+}
+export interface PipelineResult<V> {
+    base: V;
+    value: V;
+    trace: readonly TraceStep<V>[];
+}
+export declare function runPipeline<V>(base: V, modifiers: readonly Modifier<V>[], equals?: (a: V, b: V) => boolean): PipelineResult<V>;
+export interface ModifierPipeline<V> {
+    add(modifier: Modifier<V>): void;
+    insertAt(index: number, modifier: Modifier<V>): void;
+    remove(id: string): boolean;
+    clear(): void;
+    list(): readonly Modifier<V>[];
+    run(base: V): PipelineResult<V>;
+}
+export declare function createModifierPipeline<V>(initial?: readonly Modifier<V>[], equals?: (a: V, b: V) => boolean): ModifierPipeline<V>;

package/dist/cards/modifierPipeline.js

@@ -0,0 +1,48 @@
+export function runPipeline(base, modifiers, equals = Object.is) {
+    const trace = [];
+    let value = base;
+    let index = 0;
+    for (const modifier of modifiers) {
+        const before = value;
+        const after = modifier.apply(before, { base, index, trace });
+        trace.push({
+            id: modifier.id,
+            source: modifier.source,
+            index,
+            before,
+            after,
+            changed: !equals(before, after),
+        });
+        value = after;
+        index += 1;
+    }
+    return { base, value, trace };
+}
+export function createModifierPipeline(initial = [], equals = Object.is) {
+    const modifiers = initial.slice();
+    return {
+        add(modifier) {
+            modifiers.push(modifier);
+        },
+        insertAt(index, modifier) {
+            const clamped = Math.max(0, Math.min(modifiers.length, Math.floor(index)));
+            modifiers.splice(clamped, 0, modifier);
+        },
+        remove(id) {
+            const at = modifiers.findIndex((m) => m.id === id);
+            if (at === -1)
+                return false;
+            modifiers.splice(at, 1);
+            return true;
+        },
+        clear() {
+            modifiers.length = 0;
+        },
+        list() {
+            return modifiers.slice();
+        },
+        run(base) {
+            return runPipeline(base, modifiers, equals);
+        },
+    };
+}

package/dist/combat/abilityKit.d.ts

@@ -0,0 +1,42 @@
+export type AbilityCastType = "instant" | "projectile" | "channel" | "targeted";
+export type AbilitySlotState = "ready" | "cooldown" | "no-resource" | "just-cast";
+export interface AbilitySlotConfig {
+    id: string;
+    cooldownMs: number;
+    chargesMax?: number;
+    resourceCost?: number;
+    castType?: AbilityCastType;
+    flashMs?: number;
+}
+export interface AbilitySlotSnapshot {
+    id: string;
+    state: AbilitySlotState;
+    castType: AbilityCastType;
+    resourceCost: number;
+    charges: number;
+    chargesMax: number;
+    cooldownRemainingMs: number;
+    cooldownFraction: number;
+    justCast: boolean;
+    ready: boolean;
+}
+export type AbilityCastReason = "unknown-slot" | "cooldown" | "no-resource";
+export type AbilityCastResult = {
+    ok: true;
+    slot: AbilitySlotSnapshot;
+} | {
+    ok: false;
+    reason: AbilityCastReason;
+    slot: AbilitySlotSnapshot | null;
+};
+export interface AbilityKit {
+    slots(): readonly string[];
+    config(slotId: string): AbilitySlotConfig | null;
+    state(slotId: string, resourceAvailable?: number): AbilitySlotSnapshot | null;
+    snapshot(resourceAvailable?: number): AbilitySlotSnapshot[];
+    canCast(slotId: string, resourceAvailable?: number): AbilityCastResult;
+    cast(slotId: string, resourceAvailable?: number): AbilityCastResult;
+    tick(dtSeconds: number): void;
+    reset(slotId?: string): void;
+}
+export declare function createAbilityKit(configs: readonly AbilitySlotConfig[]): AbilityKit;