@jgengine/core 0.5.0 → 0.7.0

package/dist/session/extraction.js

@@ -0,0 +1,108 @@
+import { createDeliveryQueue, insureLost, partitionOnDeath, resolveConsolation, } from "../inventory/storageTier.js";
+import { createContestedChannel, } from "./contestedChannel.js";
+function mergeAll(containers) {
+    const totals = new Map();
+    for (const container of containers) {
+        for (const stack of container.items) {
+            totals.set(stack.itemId, (totals.get(stack.itemId) ?? 0) + stack.count);
+        }
+    }
+    const out = [];
+    for (const [itemId, count] of totals)
+        if (count > 0)
+            out.push({ itemId, count });
+    return out;
+}
+export function createRaidSession(config) {
+    const points = new Map();
+    for (const point of config.extracts)
+        points.set(point.id, point);
+    const attempts = new Map();
+    const statuses = new Map();
+    const queue = createDeliveryQueue();
+    function statusOf(userId) {
+        return statuses.get(userId) ?? "in-raid";
+    }
+    return {
+        beginExtract(userId, extractId, team) {
+            const point = points.get(extractId);
+            if (point === undefined)
+                return null;
+            if (statusOf(userId) === "extracted" || statusOf(userId) === "dead")
+                return null;
+            const channel = createContestedChannel({
+                duration: point.holdSeconds,
+                interruptOnDamage: point.interruptOnDamage ?? true,
+                favorability: point.favorability,
+            });
+            const event = channel.start(team ?? userId);
+            attempts.set(userId, { extractId, channel });
+            statuses.set(userId, "extracting");
+            return event;
+        },
+        tickExtract(userId, dt, occupants) {
+            const attempt = attempts.get(userId);
+            if (attempt === undefined)
+                return [];
+            const events = attempt.channel.tick(dt, occupants);
+            if (attempt.channel.phase() === "complete")
+                statuses.set(userId, "extracted");
+            return events;
+        },
+        damage(userId, reason) {
+            const attempt = attempts.get(userId);
+            if (attempt === undefined)
+                return null;
+            const event = attempt.channel.damage(reason);
+            if (attempt.channel.phase() === "interrupted")
+                statuses.set(userId, "in-raid");
+            return event;
+        },
+        cancelExtract(userId) {
+            attempts.delete(userId);
+            if (statusOf(userId) === "extracting")
+                statuses.set(userId, "in-raid");
+        },
+        resolveExtraction(userId, containers) {
+            const attempt = attempts.get(userId);
+            const extractId = attempt?.extractId ?? "";
+            attempts.delete(userId);
+            statuses.set(userId, "extracted");
+            return { userId, extractId, banked: mergeAll(containers) };
+        },
+        resolveDeath(userId, containers, now, rng) {
+            attempts.delete(userId);
+            statuses.set(userId, "dead");
+            const partition = partitionOnDeath(containers);
+            let scheduled = null;
+            if (config.insurance !== undefined) {
+                const insured = insureLost(partition.lost, config.insurance, userId, now, rng);
+                if (insured !== null)
+                    scheduled = queue.schedule(insured);
+            }
+            const consolation = config.consolation !== undefined ? resolveConsolation(config.consolation, partition) : null;
+            return {
+                userId,
+                kept: partition.kept,
+                lost: partition.lost,
+                scheduled,
+                consolationLoadoutId: consolation?.loadoutId ?? null,
+            };
+        },
+        claimDeliveries: (now) => queue.claimDue(now),
+        pendingDeliveries: (userId) => queue.pending(userId),
+        deliveries: () => queue,
+        extractPoint: (extractId) => points.get(extractId),
+        status: statusOf,
+        playerSnapshot: (userId) => {
+            const attempt = attempts.get(userId);
+            const channel = attempt?.channel;
+            return {
+                status: statusOf(userId),
+                extractId: attempt?.extractId ?? null,
+                progress: channel?.progress() ?? 0,
+                remaining: channel?.remaining() ?? 0,
+            };
+        },
+    };
+}

package/dist/session/ring.d.ts

@@ -0,0 +1,36 @@
+export type RingPoint = [number, number];
+export interface RingPhase {
+    startTime: number;
+    shrinkDuration: number;
+    fromRadius: number;
+    toRadius: number;
+    damagePerSecond: number;
+    center?: RingPoint;
+}
+export interface RingConfig {
+    center: RingPoint;
+    phases: readonly RingPhase[];
+}
+export interface RingSample {
+    center: RingPoint;
+    radius: number;
+    damagePerSecond: number;
+    phase: number;
+    shrinking: boolean;
+}
+export interface RingHit {
+    id: string;
+    damage: number;
+    distanceOutside: number;
+}
+export interface Ring {
+    at(time: number): RingSample;
+    isOutside(time: number, position: RingPoint): boolean;
+    distanceOutside(time: number, position: RingPoint): number;
+    damageOutside(time: number, dt: number, positions: Iterable<{
+        id: string;
+        position: RingPoint;
+    }>): RingHit[];
+}
+export declare function ringSampleAt(config: RingConfig, time: number): RingSample;
+export declare function createRing(config: RingConfig): Ring;

package/dist/session/ring.js

@@ -0,0 +1,88 @@
+function lerp(from, to, t) {
+    return from + (to - from) * t;
+}
+function lerpPoint(from, to, t) {
+    return [lerp(from[0], to[0], t), lerp(from[1], to[1], t)];
+}
+function distance(a, b) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+export function ringSampleAt(config, time) {
+    const phases = config.phases;
+    if (phases.length === 0) {
+        return { center: config.center, radius: 0, damagePerSecond: 0, phase: -1, shrinking: false };
+    }
+    const first = phases[0];
+    if (time < first.startTime) {
+        return {
+            center: config.center,
+            radius: first.fromRadius,
+            damagePerSecond: 0,
+            phase: -1,
+            shrinking: false,
+        };
+    }
+    let index = 0;
+    for (let i = 0; i < phases.length; i += 1) {
+        if (time >= phases[i].startTime)
+            index = i;
+        else
+            break;
+    }
+    const phase = phases[index];
+    const prevCenter = index === 0 ? config.center : centerAfter(config, index - 1);
+    const target = phase.center ?? prevCenter;
+    const elapsed = time - phase.startTime;
+    if (elapsed < phase.shrinkDuration && phase.shrinkDuration > 0) {
+        const t = elapsed / phase.shrinkDuration;
+        return {
+            center: lerpPoint(prevCenter, target, t),
+            radius: lerp(phase.fromRadius, phase.toRadius, t),
+            damagePerSecond: phase.damagePerSecond,
+            phase: index,
+            shrinking: true,
+        };
+    }
+    return {
+        center: target,
+        radius: phase.toRadius,
+        damagePerSecond: phase.damagePerSecond,
+        phase: index,
+        shrinking: false,
+    };
+}
+function centerAfter(config, index) {
+    let center = config.center;
+    for (let i = 0; i <= index; i += 1) {
+        const phase = config.phases[i];
+        if (phase.center !== undefined)
+            center = phase.center;
+    }
+    return center;
+}
+export function createRing(config) {
+    return {
+        at: (time) => ringSampleAt(config, time),
+        isOutside: (time, position) => {
+            const sample = ringSampleAt(config, time);
+            return distance(position, sample.center) > sample.radius;
+        },
+        distanceOutside: (time, position) => {
+            const sample = ringSampleAt(config, time);
+            return Math.max(0, distance(position, sample.center) - sample.radius);
+        },
+        damageOutside: (time, dt, positions) => {
+            const sample = ringSampleAt(config, time);
+            const hits = [];
+            if (dt <= 0 || sample.damagePerSecond <= 0)
+                return hits;
+            for (const { id, position } of positions) {
+                const distanceOutside = distance(position, sample.center) - sample.radius;
+                if (distanceOutside > 0) {
+                    hits.push({ id, damage: sample.damagePerSecond * dt, distanceOutside });
+                }
+            }
+            return hits;
+        },
+    };
+}

package/dist/session/roundState.d.ts

@@ -0,0 +1,55 @@
+export type RoundPhase = "buy" | "live" | "end";
+export interface RoundPhaseDurations {
+    buy: number;
+    live: number;
+    end: number;
+}
+export interface LossBonusRule {
+    base: number;
+    step: number;
+    max: number;
+}
+export interface RoundConfig {
+    phases: RoundPhaseDurations;
+    teams: readonly string[];
+    maxRounds?: number;
+    winReward?: number;
+    lossBonus?: LossBonusRule;
+}
+export type RoundEventKind = "phase.start" | "phase.end" | "round.win" | "round.economy" | "match.end";
+export interface RoundEconomy {
+    team: string;
+    reward: number;
+    won: boolean;
+    lossStreak: number;
+}
+export interface RoundEvent {
+    kind: RoundEventKind;
+    round: number;
+    phase?: RoundPhase;
+    nextPhase?: RoundPhase;
+    winner?: string;
+    economy?: RoundEconomy[];
+}
+export type PhaseEndHook = (endingPhase: RoundPhase, nextPhase: RoundPhase, round: number) => void;
+export interface RoundSnapshot {
+    round: number;
+    phase: RoundPhase;
+    timeLeft: number;
+    scores: Record<string, number>;
+    lossStreaks: Record<string, number>;
+    matchOver: boolean;
+}
+export interface RoundState {
+    tick(dt: number): RoundEvent[];
+    concludeRound(winner: string): RoundEvent[];
+    onPhaseEnd(hook: PhaseEndHook): () => void;
+    phase(): RoundPhase;
+    round(): number;
+    timeLeft(): number;
+    score(team: string): number;
+    economyFor(team: string): RoundEconomy;
+    snapshot(): RoundSnapshot;
+}
+export declare function lossBonusFor(rule: LossBonusRule | undefined, streak: number): number;
+export declare function createRoundState(config: RoundConfig): RoundState;

package/dist/session/roundState.js

@@ -0,0 +1,129 @@
+const PHASE_ORDER = ["buy", "live", "end"];
+export function lossBonusFor(rule, streak) {
+    if (rule === undefined)
+        return 0;
+    return Math.min(rule.max, rule.base + rule.step * Math.max(0, streak));
+}
+export function createRoundState(config) {
+    const durations = config.phases;
+    const teams = config.teams.length > 0 ? [...config.teams] : ["a", "b"];
+    const scores = {};
+    const lossStreaks = {};
+    for (const team of teams) {
+        scores[team] = 0;
+        lossStreaks[team] = 0;
+    }
+    let round = 1;
+    let phase = "buy";
+    let timeLeft = durations.buy;
+    let matchOver = false;
+    let pendingWinner = null;
+    const hooks = new Set();
+    function durationOf(next) {
+        return durations[next];
+    }
+    function nextPhaseOf(current) {
+        if (current === "end")
+            return "buy";
+        return PHASE_ORDER[PHASE_ORDER.indexOf(current) + 1];
+    }
+    function economyFor(team) {
+        const won = pendingWinner === team;
+        return {
+            team,
+            reward: won ? config.winReward ?? 0 : lossBonusFor(config.lossBonus, lossStreaks[team]),
+            won,
+            lossStreak: lossStreaks[team],
+        };
+    }
+    function settleEconomy(winner) {
+        const economy = [];
+        for (const team of teams) {
+            const won = team === winner;
+            const reward = won ? config.winReward ?? 0 : lossBonusFor(config.lossBonus, lossStreaks[team]);
+            economy.push({ team, reward, won, lossStreak: lossStreaks[team] });
+        }
+        for (const team of teams) {
+            if (team === winner)
+                lossStreaks[team] = 0;
+            else
+                lossStreaks[team] += 1;
+        }
+        return economy;
+    }
+    function enter(next, events) {
+        phase = next;
+        timeLeft = durationOf(next);
+        events.push({ kind: "phase.start", round, phase: next });
+    }
+    function endPhase(events) {
+        const ending = phase;
+        if (ending === "end") {
+            if (config.maxRounds !== undefined && round >= config.maxRounds) {
+                matchOver = true;
+                events.push({ kind: "phase.end", round, phase: ending, nextPhase: "buy" });
+                events.push({ kind: "match.end", round });
+                for (const hook of hooks)
+                    hook(ending, "buy", round);
+                return;
+            }
+            round += 1;
+            pendingWinner = null;
+        }
+        const next = nextPhaseOf(ending);
+        events.push({ kind: "phase.end", round: ending === "end" ? round - 1 : round, phase: ending, nextPhase: next });
+        for (const hook of hooks)
+            hook(ending, next, ending === "end" ? round - 1 : round);
+        enter(next, events);
+    }
+    return {
+        tick(dt) {
+            if (dt <= 0 || matchOver)
+                return [];
+            const events = [];
+            timeLeft -= dt;
+            let guard = 0;
+            while (timeLeft <= 0 && !matchOver && guard < PHASE_ORDER.length + 2) {
+                const carry = timeLeft;
+                if (phase === "live")
+                    pendingWinner = null;
+                endPhase(events);
+                if (!matchOver)
+                    timeLeft += carry;
+                guard += 1;
+            }
+            return events;
+        },
+        concludeRound(winner) {
+            if (matchOver || phase !== "live")
+                return [];
+            const events = [];
+            pendingWinner = winner;
+            scores[winner] = (scores[winner] ?? 0) + 1;
+            events.push({ kind: "round.win", round, winner });
+            const economy = settleEconomy(winner);
+            events.push({ kind: "round.economy", round, winner, economy });
+            endPhase(events);
+            return events;
+        },
+        onPhaseEnd(hook) {
+            hooks.add(hook);
+            return () => {
+                hooks.delete(hook);
+            };
+        },
+        phase: () => phase,
+        round: () => round,
+        timeLeft: () => Math.max(0, timeLeft),
+        score: (team) => scores[team] ?? 0,
+        economyFor,
+        snapshot: () => ({
+            round,
+            phase,
+            timeLeft: Math.max(0, timeLeft),
+            scores: { ...scores },
+            lossStreaks: { ...lossStreaks },
+            matchOver,
+        }),
+    };
+}

package/dist/stats/accumulatorMeter.d.ts

@@ -0,0 +1,31 @@
+export interface MeterTier {
+    id: string;
+    at: number;
+}
+export type MeterMode = "hold" | "reset";
+export interface AccumulatorMeterConfig {
+    max: number;
+    mode?: MeterMode;
+    decayPerSecond?: number;
+    decayDelayMs?: number;
+    tiers?: readonly MeterTier[];
+}
+export interface MeterAddResult {
+    value: number;
+    fired: boolean;
+    overflow: number;
+    tier: string | null;
+    tierChanged: boolean;
+}
+export interface AccumulatorMeter {
+    value(): number;
+    fraction(): number;
+    tier(): string | null;
+    broke(): boolean;
+    add(amount: number): MeterAddResult;
+    drain(amount: number): void;
+    reset(): void;
+    tick(dtSeconds: number): void;
+}
+export declare function tierAt(value: number, tiers: readonly MeterTier[]): string | null;
+export declare function createAccumulatorMeter(config: AccumulatorMeterConfig): AccumulatorMeter;

package/dist/stats/accumulatorMeter.js

@@ -0,0 +1,81 @@
+function sortedTiers(tiers) {
+    if (tiers === undefined)
+        return [];
+    return [...tiers].sort((a, b) => a.at - b.at);
+}
+export function tierAt(value, tiers) {
+    let current = null;
+    for (const tier of tiers) {
+        if (value >= tier.at)
+            current = tier.id;
+        else
+            break;
+    }
+    return current;
+}
+export function createAccumulatorMeter(config) {
+    const mode = config.mode ?? "hold";
+    const tiers = sortedTiers(config.tiers);
+    const decayPerSecond = config.decayPerSecond ?? 0;
+    const decayDelayMs = config.decayDelayMs ?? 0;
+    let value = 0;
+    let broken = false;
+    let idleMs = 0;
+    function clamp(next) {
+        return Math.max(0, Math.min(config.max, next));
+    }
+    return {
+        value() {
+            return value;
+        },
+        fraction() {
+            return config.max <= 0 ? 0 : value / config.max;
+        },
+        tier() {
+            return tierAt(value, tiers);
+        },
+        broke() {
+            return broken;
+        },
+        add(amount) {
+            idleMs = 0;
+            const tierBefore = tierAt(value, tiers);
+            const raw = value + amount;
+            const fired = amount > 0 && raw >= config.max && !(mode === "hold" && broken);
+            if (mode === "reset" && fired) {
+                value = clamp(raw - config.max);
+            }
+            else {
+                value = clamp(raw);
+                if (fired && mode === "hold")
+                    broken = true;
+            }
+            const tierAfter = tierAt(value, tiers);
+            return {
+                value,
+                fired,
+                overflow: fired && mode === "reset" ? Math.max(0, raw - config.max) : 0,
+                tier: tierAfter,
+                tierChanged: tierAfter !== tierBefore,
+            };
+        },
+        drain(amount) {
+            value = clamp(value - amount);
+            if (value <= 0)
+                broken = false;
+        },
+        reset() {
+            value = 0;
+            broken = false;
+            idleMs = 0;
+        },
+        tick(dtSeconds) {
+            if (dtSeconds <= 0)
+                return;
+            idleMs += dtSeconds * 1000;
+            if (broken || decayPerSecond <= 0 || idleMs < decayDelayMs)
+                return;
+            value = clamp(value - decayPerSecond * dtSeconds);
+        },
+    };
+}

package/dist/stats/eventMeter.d.ts

@@ -0,0 +1,34 @@
+import { type MeterMode, type MeterTier } from "./accumulatorMeter.js";
+export interface EventMeterConfig {
+    max: number;
+    mode?: MeterMode;
+    decayPerSecond?: number;
+    decayDelayMs?: number;
+    tiers?: readonly MeterTier[];
+    gains: Record<string, number>;
+    resets?: readonly string[];
+}
+export interface EventMeterFeedResult {
+    tag: string;
+    reset: boolean;
+    amount: number;
+    value: number;
+    fraction: number;
+    fired: boolean;
+    ready: boolean;
+    overflow: number;
+    tier: string | null;
+    tierChanged: boolean;
+}
+export interface EventMeter {
+    value(): number;
+    fraction(): number;
+    tier(): string | null;
+    ready(): boolean;
+    feed(tag: string, scale?: number): EventMeterFeedResult;
+    consume(): boolean;
+    drain(amount: number): void;
+    reset(): void;
+    tick(dtSeconds: number): void;
+}
+export declare function createEventMeter(config: EventMeterConfig): EventMeter;

package/dist/stats/eventMeter.js

@@ -0,0 +1,76 @@
+import { createAccumulatorMeter, } from "./accumulatorMeter.js";
+function readyOf(meter, mode) {
+    return mode === "hold" ? meter.broke() : meter.value() >= 0 && meter.fraction() >= 1;
+}
+export function createEventMeter(config) {
+    const mode = config.mode ?? "hold";
+    const resets = new Set(config.resets ?? []);
+    const meter = createAccumulatorMeter({
+        max: config.max,
+        mode,
+        decayPerSecond: config.decayPerSecond,
+        decayDelayMs: config.decayDelayMs,
+        tiers: config.tiers,
+    });
+    return {
+        value() {
+            return meter.value();
+        },
+        fraction() {
+            return meter.fraction();
+        },
+        tier() {
+            return meter.tier();
+        },
+        ready() {
+            return readyOf(meter, mode);
+        },
+        feed(tag, scale = 1) {
+            const tierBefore = meter.tier();
+            if (resets.has(tag)) {
+                meter.reset();
+                return {
+                    tag,
+                    reset: true,
+                    amount: 0,
+                    value: meter.value(),
+                    fraction: meter.fraction(),
+                    fired: false,
+                    ready: readyOf(meter, mode),
+                    overflow: 0,
+                    tier: meter.tier(),
+                    tierChanged: meter.tier() !== tierBefore,
+                };
+            }
+            const amount = (config.gains[tag] ?? 0) * scale;
+            const result = meter.add(amount);
+            return {
+                tag,
+                reset: false,
+                amount,
+                value: result.value,
+                fraction: meter.fraction(),
+                fired: result.fired,
+                ready: readyOf(meter, mode),
+                overflow: result.overflow,
+                tier: result.tier,
+                tierChanged: result.tierChanged,
+            };
+        },
+        consume() {
+            if (!readyOf(meter, mode))
+                return false;
+            meter.reset();
+            return true;
+        },
+        drain(amount) {
+            meter.drain(amount);
+        },
+        reset() {
+            meter.reset();
+        },
+        tick(dtSeconds) {
+            meter.tick(dtSeconds);
+        },
+    };
+}

package/dist/stats/rollCheck.d.ts

@@ -0,0 +1,15 @@
+export type CheckAdvantage = "advantage" | "disadvantage" | "normal";
+export interface CheckInput {
+    modifier: number;
+    dc: number;
+    advantage?: CheckAdvantage;
+    diceSides?: number;
+}
+export interface CheckResult {
+    rolls: readonly number[];
+    roll: number;
+    total: number;
+    success: boolean;
+    critical: "success" | "failure" | null;
+}
+export declare function rollCheck(input: CheckInput, rng?: () => number): CheckResult;

package/dist/stats/rollCheck.js

@@ -0,0 +1,15 @@
+export function rollCheck(input, rng = Math.random) {
+    const sides = input.diceSides ?? 20;
+    const advantage = input.advantage ?? "normal";
+    const rollDie = () => Math.floor(rng() * sides) + 1;
+    const rolls = advantage === "normal" ? [rollDie()] : [rollDie(), rollDie()];
+    const roll = advantage === "advantage"
+        ? Math.max(...rolls)
+        : advantage === "disadvantage"
+            ? Math.min(...rolls)
+            : rolls[0];
+    const total = roll + input.modifier;
+    const success = total >= input.dc;
+    const critical = roll === sides ? "success" : roll === 1 ? "failure" : null;
+    return { rolls, roll, total, success, critical };
+}