@jgengine/core 0.6.0 → 0.8.0

package/dist/session/roundState.js

@@ -0,0 +1,158 @@
+const DEFAULT_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));
+}
+function normalizeTeams(teams) {
+    if (teams.length === 0)
+        return [{ id: "a" }, { id: "b" }];
+    const normalized = [];
+    for (const team of teams) {
+        normalized.push(typeof team === "string" ? { id: team } : team);
+    }
+    return normalized;
+}
+function isConcludable(order, phase) {
+    const idx = order.indexOf(phase);
+    return idx > 0 && idx < order.length - 1;
+}
+export function createRoundState(config) {
+    const order = config.phaseOrder ?? DEFAULT_PHASE_ORDER;
+    const durations = config.phases;
+    const teamRecords = normalizeTeams(config.teams);
+    const teamIds = teamRecords.map((t) => t.id);
+    const roles = {};
+    const scores = {};
+    const lossStreaks = {};
+    for (const team of teamRecords) {
+        roles[team.id] = team.role;
+        scores[team.id] = 0;
+        lossStreaks[team.id] = 0;
+    }
+    let round = 1;
+    let phase = order[0];
+    let timeLeft = durations[phase] ?? 0;
+    let matchOver = false;
+    let pendingWinner = null;
+    const hooks = new Set();
+    function durationOf(next) {
+        return durations[next] ?? 0;
+    }
+    function nextPhaseOf(current) {
+        const idx = order.indexOf(current);
+        return idx >= order.length - 1 ? order[0] : order[idx + 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 teamIds) {
+            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 teamIds) {
+            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 === order[order.length - 1]) {
+            if (config.maxRounds !== undefined && round >= config.maxRounds) {
+                matchOver = true;
+                events.push({ kind: "phase.end", round, phase: ending, nextPhase: order[0] });
+                events.push({ kind: "match.end", round });
+                for (const hook of hooks)
+                    hook(ending, order[0], round);
+                return;
+            }
+            round += 1;
+            pendingWinner = null;
+        }
+        const next = nextPhaseOf(ending);
+        const endedRound = ending === order[order.length - 1] ? round - 1 : round;
+        events.push({ kind: "phase.end", round: endedRound, phase: ending, nextPhase: next });
+        for (const hook of hooks)
+            hook(ending, next, endedRound);
+        enter(next, events);
+    }
+    function currentSnapshot() {
+        return {
+            round,
+            phase,
+            timeLeft: Math.max(0, timeLeft),
+            scores: { ...scores },
+            lossStreaks: { ...lossStreaks },
+            roles: { ...roles },
+            matchOver,
+        };
+    }
+    function concludeRoundImpl(winner) {
+        if (matchOver || !isConcludable(order, phase))
+            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;
+    }
+    return {
+        tick(dt) {
+            if (dt <= 0 || matchOver)
+                return [];
+            const events = [];
+            timeLeft -= dt;
+            let guard = 0;
+            while (timeLeft <= 0 && !matchOver && guard < order.length + 2) {
+                const carry = timeLeft;
+                if (isConcludable(order, phase))
+                    pendingWinner = null;
+                endPhase(events);
+                if (!matchOver)
+                    timeLeft += carry;
+                guard += 1;
+            }
+            return events;
+        },
+        concludeRound: concludeRoundImpl,
+        evaluate() {
+            if (config.winCondition === undefined)
+                return [];
+            const winner = config.winCondition(currentSnapshot());
+            return winner === null ? [] : concludeRoundImpl(winner);
+        },
+        onPhaseEnd(hook) {
+            hooks.add(hook);
+            return () => {
+                hooks.delete(hook);
+            };
+        },
+        phase: () => phase,
+        round: () => round,
+        timeLeft: () => Math.max(0, timeLeft),
+        score: (team) => scores[team] ?? 0,
+        economyFor,
+        roleOf: (team) => roles[team],
+        snapshot: currentSnapshot,
+    };
+}

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 };
+}

package/dist/survival/decayMeter.d.ts

@@ -0,0 +1,59 @@
+import type { Moodle, MoodleSeverity } from "./moodle.js";
+export interface MeterThreshold {
+    /** Moodle id raised while the meter is on the wrong side of `at`. */
+    id: string;
+    label: string;
+    /** Boundary value. */
+    at: number;
+    /** Raise the moodle when the meter is `below` (hunger/thirst) or `above` (temperature, radiation) this value. */
+    when: "below" | "above";
+    severity?: MoodleSeverity;
+    icon?: string;
+}
+export interface DecayMeterConfig {
+    id: string;
+    max: number;
+    min?: number;
+    /** Starting value; defaults to `max` (a full stomach). */
+    start?: number;
+    /**
+     * Units changed per game-second at rate-modifier 1. Positive drains toward `min`
+     * (hunger, oxygen), negative fills toward `max` (a warmth meter recovering by a fire).
+     */
+    rate: number;
+    /** Status thresholds → moodles, distinct from the raw numeric bar. */
+    thresholds?: readonly MeterThreshold[];
+}
+export interface DecayMeterState {
+    id: string;
+    value: number;
+    max: number;
+    min: number;
+    /** 0..1 fill. */
+    fraction: number;
+}
+export interface DecayMeterSet {
+    /** Drain/fill every meter by `rate * rateModifier * dt`. Call once per game tick. */
+    tick(dt: number): void;
+    value(id: string): number;
+    state(id: string): DecayMeterState;
+    /** Consumable/action refill: `refill("hunger", 40)` after eating. Negative drains. */
+    refill(id: string, amount: number): void;
+    /** Overwrite the base drain rate (e.g. a game mode with harsher hunger). */
+    setRate(id: string, rate: number): void;
+    /** Multiply the drain rate this tick onward — cold biome speeds warmth loss, sprint burns stamina. */
+    setRateModifier(id: string, multiplier: number): void;
+    /** Moodles for every crossed threshold, worst-first per meter. */
+    moodles(): Moodle[];
+    /** True while any threshold with the given severity (or worse) is active — cheap game gate. */
+    snapshot(): Record<string, DecayMeterState>;
+    ids(): readonly string[];
+}
+/**
+ * Named decay meters — hunger, thirst, oxygen, sanity, warmth, stamina. Each drains
+ * (or recovers) on game-time `dt` at a configurable rate, refills from consumables or
+ * actions, and raises moodle statuses at thresholds. Rate modifiers let the environment
+ * drive them (colder → faster warmth loss; toxic biome → oxygen drops), so a game reads
+ * an environment field then calls `setRateModifier`.
+ */
+export declare function createDecayMeterSet(configs: readonly DecayMeterConfig[]): DecayMeterSet;

package/dist/survival/decayMeter.js

@@ -0,0 +1,95 @@
+function clamp(value, min, max) {
+    return value < min ? min : value > max ? max : value;
+}
+function toState(runtime) {
+    const span = runtime.max - runtime.min;
+    return {
+        id: runtime.config.id,
+        value: runtime.value,
+        max: runtime.max,
+        min: runtime.min,
+        fraction: span > 0 ? (runtime.value - runtime.min) / span : 0,
+    };
+}
+function crossed(threshold, value) {
+    return threshold.when === "below" ? value < threshold.at : value > threshold.at;
+}
+/**
+ * Named decay meters — hunger, thirst, oxygen, sanity, warmth, stamina. Each drains
+ * (or recovers) on game-time `dt` at a configurable rate, refills from consumables or
+ * actions, and raises moodle statuses at thresholds. Rate modifiers let the environment
+ * drive them (colder → faster warmth loss; toxic biome → oxygen drops), so a game reads
+ * an environment field then calls `setRateModifier`.
+ */
+export function createDecayMeterSet(configs) {
+    const meters = new Map();
+    const order = [];
+    for (const config of configs) {
+        const min = config.min ?? 0;
+        const max = config.max;
+        const value = clamp(config.start ?? max, min, max);
+        meters.set(config.id, { config, min, max, value, rate: config.rate, modifier: 1 });
+        order.push(config.id);
+    }
+    const require = (id) => {
+        const runtime = meters.get(id);
+        if (runtime === undefined)
+            throw new Error(`unknown decay meter "${id}"`);
+        return runtime;
+    };
+    return {
+        tick(dt) {
+            if (dt <= 0)
+                return;
+            for (const runtime of meters.values()) {
+                runtime.value = clamp(runtime.value - runtime.rate * runtime.modifier * dt, runtime.min, runtime.max);
+                runtime.modifier = 1;
+            }
+        },
+        value(id) {
+            return require(id).value;
+        },
+        state(id) {
+            return toState(require(id));
+        },
+        refill(id, amount) {
+            const runtime = require(id);
+            runtime.value = clamp(runtime.value + amount, runtime.min, runtime.max);
+        },
+        setRate(id, rate) {
+            require(id).rate = rate;
+        },
+        setRateModifier(id, multiplier) {
+            require(id).modifier = multiplier;
+        },
+        moodles() {
+            const out = [];
+            for (const id of order) {
+                const runtime = meters.get(id);
+                for (const threshold of runtime.config.thresholds ?? []) {
+                    if (!crossed(threshold, runtime.value))
+                        continue;
+                    out.push({
+                        id: threshold.id,
+                        label: threshold.label,
+                        severity: threshold.severity ?? "warning",
+                        source: "meter",
+                        stacks: 1,
+                        ...(threshold.icon === undefined ? {} : { icon: threshold.icon }),
+                        fraction: toState(runtime).fraction,
+                    });
+                }
+            }
+            return out;
+        },
+        snapshot() {
+            const out = {};
+            for (const id of order)
+                out[id] = toState(meters.get(id));
+            return out;
+        },
+        ids() {
+            return order;
+        },
+    };
+}

package/dist/survival/moodle.d.ts

@@ -0,0 +1,48 @@
+export type MoodleSeverity = "good" | "neutral" | "warning" | "critical";
+export type MoodleSource = "meter" | "ailment" | "buff";
+export interface Moodle {
+    id: string;
+    label: string;
+    severity: MoodleSeverity;
+    source: MoodleSource;
+    stacks: number;
+    icon?: string;
+    /** 0..1 progress ring — remaining buff time, wound treatment, meter fill. Absent = no ring. */
+    fraction?: number;
+    /** Free-form note surfaced under the label (e.g. "-3°C", "needs bandage"). */
+    note?: string;
+}
+export declare const MOODLE_SEVERITY_ORDER: Record<MoodleSeverity, number>;
+/**
+ * Merge any number of moodle groups into one stack — meters, ailments, and buffs
+ * share this display. Same-id moodles fold together (stacks add, worst severity wins);
+ * the result is ordered worst-first so the HUD reads critical statuses at a glance.
+ */
+export declare function stackMoodles(...groups: readonly (readonly Moodle[])[]): Moodle[];
+export interface TimedMoodleInput {
+    id: string;
+    label: string;
+    severity?: MoodleSeverity;
+    icon?: string;
+    note?: string;
+    stacks?: number;
+    /** Game-seconds until the moodle drops. Omit for a moodle that stays until removed. */
+    duration?: number;
+}
+export interface MoodleStack {
+    /** Add or refresh a timed moodle (Valheim food buff, a temporary shelter status). */
+    add(input: TimedMoodleInput): void;
+    remove(id: string): void;
+    has(id: string): boolean;
+    /** Advance timers by a game-time delta; drops expired moodles. */
+    tick(dt: number): void;
+    /** The live timed moodles (buffs, temporary statuses). */
+    list(): Moodle[];
+    clear(): void;
+}
+/**
+ * A stateful holder for timed status moodles (food buffs, temporary shelter, warmth).
+ * Meters and multi-region health derive their own moodles on read; combine all three
+ * through `stackMoodles(stack.list(), meterMoodles, ailmentMoodles)` for one display.
+ */
+export declare function createMoodleStack(): MoodleStack;