@jgengine/core 0.5.0 → 0.7.0

package/dist/combat/downed.js

@@ -0,0 +1,104 @@
+export function createDownedState(config) {
+    const bleedoutSeconds = Math.max(0, config.bleedoutSeconds);
+    const reviveSeconds = config.reviveSeconds !== undefined ? Math.max(0, config.reviveSeconds) : 0;
+    const reviveHealthFraction = config.reviveHealthFraction ?? 1;
+    const bannerSeconds = config.banner?.expireSeconds;
+    const entries = new Map();
+    function toDead(instanceId, entry, reason, events) {
+        entry.phase = "dead";
+        entry.bleedoutRemaining = 0;
+        entry.reviveProgress = 0;
+        events.push({ kind: "died", instanceId, reason });
+        if (bannerSeconds !== undefined) {
+            entry.bannerRemaining = bannerSeconds;
+            events.push({ kind: "banner.created", instanceId });
+        }
+        else {
+            entry.bannerRemaining = null;
+        }
+    }
+    return {
+        down(instanceId) {
+            const existing = entries.get(instanceId);
+            if (existing !== undefined && existing.phase === "downed")
+                return null;
+            entries.set(instanceId, {
+                phase: "downed",
+                bleedoutRemaining: bleedoutSeconds,
+                reviveProgress: 0,
+                bannerRemaining: null,
+            });
+            return { kind: "downed", instanceId };
+        },
+        revive(instanceId, dt) {
+            const entry = entries.get(instanceId);
+            if (entry === undefined || entry.phase !== "downed" || dt <= 0)
+                return null;
+            entry.reviveProgress += dt;
+            if (entry.reviveProgress >= reviveSeconds) {
+                entry.phase = "alive";
+                entry.reviveProgress = 0;
+                entry.bleedoutRemaining = 0;
+                return { kind: "revived", instanceId, reviveHealthFraction };
+            }
+            return { kind: "reviving", instanceId };
+        },
+        interruptRevive(instanceId) {
+            const entry = entries.get(instanceId);
+            if (entry !== undefined && entry.phase === "downed")
+                entry.reviveProgress = 0;
+        },
+        finish(instanceId, reason) {
+            const entry = entries.get(instanceId);
+            if (entry === undefined || entry.phase !== "downed")
+                return null;
+            const events = [];
+            toDead(instanceId, entry, reason ?? "finished", events);
+            return events[0] ?? null;
+        },
+        tick(dt) {
+            if (dt <= 0)
+                return [];
+            const events = [];
+            for (const [instanceId, entry] of entries) {
+                if (entry.phase === "downed") {
+                    entry.bleedoutRemaining -= dt;
+                    if (entry.bleedoutRemaining <= 0)
+                        toDead(instanceId, entry, "bleedout", events);
+                }
+                else if (entry.phase === "dead" && entry.bannerRemaining !== null) {
+                    entry.bannerRemaining -= dt;
+                    if (entry.bannerRemaining <= 0) {
+                        entry.bannerRemaining = null;
+                        events.push({ kind: "banner.expired", instanceId });
+                    }
+                }
+            }
+            return events;
+        },
+        respawnFromBanner(instanceId) {
+            const entry = entries.get(instanceId);
+            if (entry === undefined || entry.phase !== "dead" || entry.bannerRemaining === null)
+                return null;
+            entry.phase = "alive";
+            entry.bannerRemaining = null;
+            entry.bleedoutRemaining = 0;
+            entry.reviveProgress = 0;
+            return { kind: "respawned", instanceId, reviveHealthFraction };
+        },
+        phase: (instanceId) => entries.get(instanceId)?.phase ?? "alive",
+        get: (instanceId) => {
+            const entry = entries.get(instanceId);
+            return entry === undefined ? null : { ...entry };
+        },
+        clear: (instanceId) => {
+            entries.delete(instanceId);
+        },
+        snapshot: () => {
+            const out = {};
+            for (const [instanceId, entry] of entries)
+                out[instanceId] = { ...entry };
+            return out;
+        },
+    };
+}

package/dist/combat/effects.d.ts

@@ -45,6 +45,17 @@ export interface CombatSpatialDeps {
     hasLineOfSight(from: EntityPosition | string, to: string): boolean;
     positionOf(instanceId: string): EntityPosition | undefined;
 }
+export interface AreaTargetInput {
+    at: EntityPosition;
+    radius: number;
+    falloff?: "linear" | "none";
+    los?: boolean;
+}
+export interface AreaTarget {
+    instanceId: string;
+    scale: number;
+}
+export declare function resolveAreaTargets(spatial: CombatSpatialDeps, input: AreaTargetInput, accept?: (instanceId: string) => boolean): AreaTarget[];
 export interface EffectSystemDeps {
     resolveReceive(instanceId: string): ReceiveMap | null | undefined;
     resolveStats(instanceId: string): StatValueMap | undefined;

package/dist/combat/effects.js

@@ -1,5 +1,25 @@
 import { applyPoolDelta } from "../scene/entityStats.js";
 import { distanceBetween } from "../scene/spatial.js";
+export function resolveAreaTargets(spatial, input, accept) {
+    const falloff = input.falloff ?? "none";
+    const los = input.los ?? true;
+    const targets = [];
+    for (const instanceId of spatial.inRadius(input.at, input.radius)) {
+        if (los && !spatial.hasLineOfSight(input.at, instanceId))
+            continue;
+        let scale = 1;
+        if (falloff === "linear") {
+            const position = spatial.positionOf(instanceId);
+            if (position === undefined)
+                continue;
+            scale = Math.max(0, 1 - distanceBetween(input.at, position) / input.radius);
+        }
+        if (accept !== undefined && !accept(instanceId))
+            continue;
+        targets.push({ instanceId, scale });
+    }
+    return targets;
+}
 const DEFAULT_DRAIN_STAT = "damage";
 export function createEffectSystem(deps) {
     function resolveRule(instanceId, effect) {
@@ -85,20 +105,9 @@ export function createEffectSystem(deps) {
                 const result = applyTo(input.to, input.effect, input.via, input.from, 1);
                 return result === null ? [] : [result];
             }
-            const falloff = input.falloff ?? "none";
-            const los = input.los ?? true;
             const results = [];
-            for (const instanceId of deps.spatial.inRadius(input.at, input.radius)) {
-                if (los && !deps.spatial.hasLineOfSight(input.at, instanceId))
-                    continue;
-                let scale = 1;
-                if (falloff === "linear") {
-                    const position = deps.spatial.positionOf(instanceId);
-                    if (position === undefined)
-                        continue;
-                    scale = Math.max(0, 1 - distanceBetween(input.at, position) / input.radius);
-                }
-                const result = applyTo(instanceId, input.effect, input.via, input.from, scale);
+            for (const target of resolveAreaTargets(deps.spatial, input)) {
+                const result = applyTo(target.instanceId, input.effect, input.via, input.from, target.scale);
                 if (result !== null)
                     results.push(result);
             }

package/dist/combat/hitReaction.d.ts

@@ -0,0 +1,23 @@
+import type { EntityPosition } from "../scene/entityStore.js";
+export interface CameraShake {
+    amplitude: number;
+    decay: number;
+}
+export interface HitReactionConfig {
+    hitstopMs: number;
+    knockback: number;
+    vertical?: number;
+    shake?: CameraShake;
+}
+export interface HitReactionInput {
+    attackerPos: EntityPosition;
+    targetPos: EntityPosition;
+    power?: number;
+}
+export interface HitReaction {
+    hitstopMs: number;
+    impulse: [number, number, number];
+    shake: CameraShake | null;
+}
+export declare function resolveHitReaction(config: HitReactionConfig, input: HitReactionInput): HitReaction;
+export declare function applyImpulse(position: EntityPosition, impulse: [number, number, number]): EntityPosition;

package/dist/combat/hitReaction.js

@@ -0,0 +1,20 @@
+export function resolveHitReaction(config, input) {
+    const power = input.power ?? 1;
+    const dx = input.targetPos[0] - input.attackerPos[0];
+    const dz = input.targetPos[2] - input.attackerPos[2];
+    const planar = Math.hypot(dx, dz);
+    const nx = planar === 0 ? 0 : dx / planar;
+    const nz = planar === 0 ? 0 : dz / planar;
+    const magnitude = config.knockback * power;
+    const shake = config.shake === undefined
+        ? null
+        : { amplitude: config.shake.amplitude * power, decay: config.shake.decay };
+    return {
+        hitstopMs: config.hitstopMs,
+        impulse: [nx * magnitude, (config.vertical ?? 0) * power, nz * magnitude],
+        shake,
+    };
+}
+export function applyImpulse(position, impulse) {
+    return [position[0] + impulse[0], position[1] + impulse[1], position[2] + impulse[2]];
+}

package/dist/combat/resistance.d.ts

@@ -0,0 +1,13 @@
+export type ResistVerdict = "immune" | "resist" | "normal" | "vulnerable";
+export interface ResistanceMatrix {
+    categories: Record<string, Record<string, ResistVerdict>>;
+    multipliers?: Partial<Record<ResistVerdict, number>>;
+    default?: ResistVerdict;
+}
+export interface ResistanceResult {
+    verdict: ResistVerdict;
+    multiplier: number;
+    immune: boolean;
+}
+export declare function resolveResistance(matrix: ResistanceMatrix, category: string, targetProperties: readonly string[]): ResistanceResult;
+export declare function resistanceScale(matrix: ResistanceMatrix, category: string, targetProperties: readonly string[]): number;

package/dist/combat/resistance.js

@@ -0,0 +1,46 @@
+const DEFAULT_MULTIPLIERS = {
+    immune: 0,
+    resist: 0.5,
+    normal: 1,
+    vulnerable: 2,
+};
+function multiplierFor(matrix, verdict) {
+    return matrix.multipliers?.[verdict] ?? DEFAULT_MULTIPLIERS[verdict];
+}
+function summaryVerdict(matrix, immune, net) {
+    if (immune)
+        return "immune";
+    const normal = multiplierFor(matrix, "normal");
+    if (net > normal)
+        return "vulnerable";
+    if (net < normal)
+        return "resist";
+    return "normal";
+}
+export function resolveResistance(matrix, category, targetProperties) {
+    const byProperty = matrix.categories[category] ?? {};
+    const fallback = matrix.default ?? "normal";
+    let net = 1;
+    let matched = false;
+    let immune = false;
+    for (const property of targetProperties) {
+        const verdict = byProperty[property];
+        if (verdict === undefined)
+            continue;
+        matched = true;
+        if (verdict === "immune")
+            immune = true;
+        net *= multiplierFor(matrix, verdict);
+    }
+    if (!matched) {
+        if (fallback === "immune")
+            return { verdict: "immune", multiplier: 0, immune: true };
+        const multiplier = multiplierFor(matrix, fallback);
+        return { verdict: fallback, multiplier, immune: false };
+    }
+    const multiplier = immune ? 0 : net;
+    return { verdict: summaryVerdict(matrix, immune, multiplier), multiplier, immune };
+}
+export function resistanceScale(matrix, category, targetProperties) {
+    return resolveResistance(matrix, category, targetProperties).multiplier;
+}

package/dist/combat/telegraph.d.ts

@@ -0,0 +1,27 @@
+import type { EntityPosition } from "../scene/entityStore.js";
+export type TelegraphShape = {
+    kind: "circle";
+    radius: number;
+} | {
+    kind: "ring";
+    radius: number;
+    innerRadius: number;
+} | {
+    kind: "cone";
+    radius: number;
+    angle: number;
+} | {
+    kind: "line";
+    length: number;
+    width: number;
+};
+export interface TelegraphConfig {
+    shape: TelegraphShape;
+    at: EntityPosition;
+    dir?: number;
+    windupMs: number;
+    kind?: string;
+}
+export declare function telegraphProgress(windupMs: number, startedAtMs: number, nowMs: number): number;
+export declare function telegraphFired(windupMs: number, startedAtMs: number, nowMs: number): boolean;
+export declare function pointInTelegraph(config: TelegraphConfig, point: EntityPosition): boolean;

package/dist/combat/telegraph.js

@@ -0,0 +1,37 @@
+export function telegraphProgress(windupMs, startedAtMs, nowMs) {
+    if (windupMs <= 0)
+        return 1;
+    return Math.max(0, Math.min(1, (nowMs - startedAtMs) / windupMs));
+}
+export function telegraphFired(windupMs, startedAtMs, nowMs) {
+    return nowMs - startedAtMs >= windupMs;
+}
+function planarDelta(config, point) {
+    return { dx: point[0] - config.at[0], dz: point[2] - config.at[2] };
+}
+export function pointInTelegraph(config, point) {
+    const { shape } = config;
+    const { dx, dz } = planarDelta(config, point);
+    const dist = Math.hypot(dx, dz);
+    const dir = config.dir ?? 0;
+    if (shape.kind === "circle")
+        return dist <= shape.radius;
+    if (shape.kind === "ring")
+        return dist >= shape.innerRadius && dist <= shape.radius;
+    if (shape.kind === "cone") {
+        if (dist > shape.radius || dist === 0)
+            return dist === 0;
+        const angleTo = Math.atan2(dx, dz);
+        let delta = angleTo - dir;
+        while (delta > Math.PI)
+            delta -= Math.PI * 2;
+        while (delta < -Math.PI)
+            delta += Math.PI * 2;
+        return Math.abs(delta) <= shape.angle / 2;
+    }
+    const forwardX = Math.sin(dir);
+    const forwardZ = Math.cos(dir);
+    const along = dx * forwardX + dz * forwardZ;
+    const lateral = Math.abs(dx * forwardZ - dz * forwardX);
+    return along >= 0 && along <= shape.length && lateral <= shape.width / 2;
+}

package/dist/crafting/crop.d.ts

@@ -0,0 +1,59 @@
+import type { RecipeItem } from "./recipe.js";
+export type SoilState = "untilled" | "tilled";
+export interface CropDef {
+    id: string;
+    stages: readonly number[];
+    regrowDays?: number;
+    needsDailyWater?: boolean;
+    harvest?: RecipeItem;
+}
+export interface CropTileState {
+    soil: SoilState;
+    watered: boolean;
+    cropId: string | null;
+    stage: number;
+    stageProgress: number;
+    harvestable: boolean;
+}
+export type CropCatalog = (cropId: string) => CropDef | null;
+export declare function emptyTile(): CropTileState;
+export declare function canTill(state: CropTileState): boolean;
+export declare function tillTile(state: CropTileState): CropTileState;
+export declare function canPlant(state: CropTileState): boolean;
+export declare function plantCrop(state: CropTileState, cropId: string): CropTileState;
+export declare function waterTile(state: CropTileState): CropTileState;
+export declare function maturityDays(def: CropDef): number;
+export declare function advanceCropDay(def: CropDef, state: CropTileState): CropTileState;
+export interface HarvestResult {
+    state: CropTileState;
+    yield: RecipeItem | null;
+}
+export declare function harvestCrop(def: CropDef, state: CropTileState): HarvestResult;
+export type TileCoord = readonly [number, number];
+export type TilePattern = readonly TileCoord[];
+export declare function tileKey(coord: TileCoord): string;
+export declare function singleTile(): TilePattern;
+export declare function squarePattern(radius: number): TilePattern;
+export declare function diamondPattern(radius: number): TilePattern;
+export declare function rectPattern(width: number, depth: number): TilePattern;
+export declare function patternAt(center: TileCoord, pattern: TilePattern): TileCoord[];
+export interface ApplyToolResult {
+    tiles: Map<string, CropTileState>;
+    changed: TileCoord[];
+}
+export declare function applyToolToTiles(tiles: ReadonlyMap<string, CropTileState>, center: TileCoord, pattern: TilePattern, apply: (state: CropTileState, coord: TileCoord) => CropTileState, fill?: () => CropTileState): ApplyToolResult;
+export interface DayTicker {
+    tick(currentDay: number): number;
+    day(): number;
+}
+export declare function createDayTicker(startDay?: number): DayTicker;
+export interface CropField {
+    get(coord: TileCoord): CropTileState;
+    till(coord: TileCoord, pattern?: TilePattern): TileCoord[];
+    plant(coord: TileCoord, cropId: string): boolean;
+    water(coord: TileCoord, pattern?: TilePattern): TileCoord[];
+    harvest(coord: TileCoord): RecipeItem | null;
+    advanceDay(days?: number): void;
+    tiles(): ReadonlyMap<string, CropTileState>;
+}
+export declare function createCropField(catalog?: CropCatalog): CropField;

package/dist/crafting/crop.js

@@ -0,0 +1,181 @@
+export function emptyTile() {
+    return { soil: "untilled", watered: false, cropId: null, stage: 0, stageProgress: 0, harvestable: false };
+}
+export function canTill(state) {
+    return state.soil === "untilled" && state.cropId === null;
+}
+export function tillTile(state) {
+    if (!canTill(state))
+        return state;
+    return { ...state, soil: "tilled" };
+}
+export function canPlant(state) {
+    return state.soil === "tilled" && state.cropId === null;
+}
+export function plantCrop(state, cropId) {
+    if (!canPlant(state))
+        return state;
+    return { ...state, cropId, stage: 0, stageProgress: 0, harvestable: false };
+}
+export function waterTile(state) {
+    if (state.soil !== "tilled" || state.watered)
+        return state;
+    return { ...state, watered: true };
+}
+export function maturityDays(def) {
+    return def.stages.reduce((sum, days) => sum + Math.max(0, days), 0);
+}
+export function advanceCropDay(def, state) {
+    const rested = state.watered ? { ...state, watered: false } : state;
+    if (state.cropId === null)
+        return rested;
+    const needsWater = def.needsDailyWater !== false;
+    if (needsWater && !state.watered)
+        return rested;
+    if (state.stage < def.stages.length) {
+        const threshold = Math.max(1, def.stages[state.stage] ?? 1);
+        const stageProgress = state.stageProgress + 1;
+        if (stageProgress < threshold)
+            return { ...rested, stageProgress };
+        const stage = state.stage + 1;
+        const harvestable = stage >= def.stages.length;
+        return { ...rested, stage, stageProgress: 0, harvestable };
+    }
+    if (!state.harvestable && def.regrowDays !== undefined && def.regrowDays > 0) {
+        const stageProgress = state.stageProgress + 1;
+        if (stageProgress < def.regrowDays)
+            return { ...rested, stageProgress };
+        return { ...rested, stageProgress: 0, harvestable: true };
+    }
+    return rested;
+}
+export function harvestCrop(def, state) {
+    if (!state.harvestable || state.cropId === null)
+        return { state, yield: null };
+    const produce = def.harvest ?? { itemId: state.cropId, count: 1 };
+    if (def.regrowDays !== undefined && def.regrowDays > 0) {
+        return {
+            state: { ...state, harvestable: false, stageProgress: 0, stage: def.stages.length },
+            yield: produce,
+        };
+    }
+    return {
+        state: { ...state, soil: "tilled", cropId: null, stage: 0, stageProgress: 0, harvestable: false },
+        yield: produce,
+    };
+}
+export function tileKey(coord) {
+    return `${coord[0]},${coord[1]}`;
+}
+export function singleTile() {
+    return [[0, 0]];
+}
+export function squarePattern(radius) {
+    const r = Math.max(0, Math.floor(radius));
+    const tiles = [];
+    for (let dx = -r; dx <= r; dx++)
+        for (let dz = -r; dz <= r; dz++)
+            tiles.push([dx, dz]);
+    return tiles;
+}
+export function diamondPattern(radius) {
+    const r = Math.max(0, Math.floor(radius));
+    const tiles = [];
+    for (let dx = -r; dx <= r; dx++)
+        for (let dz = -r; dz <= r; dz++)
+            if (Math.abs(dx) + Math.abs(dz) <= r)
+                tiles.push([dx, dz]);
+    return tiles;
+}
+export function rectPattern(width, depth) {
+    const w = Math.max(1, Math.floor(width));
+    const d = Math.max(1, Math.floor(depth));
+    const x0 = -Math.floor((w - 1) / 2);
+    const z0 = -Math.floor((d - 1) / 2);
+    const tiles = [];
+    for (let dx = 0; dx < w; dx++)
+        for (let dz = 0; dz < d; dz++)
+            tiles.push([x0 + dx, z0 + dz]);
+    return tiles;
+}
+export function patternAt(center, pattern) {
+    return pattern.map(([dx, dz]) => [center[0] + dx, center[1] + dz]);
+}
+export function applyToolToTiles(tiles, center, pattern, apply, fill = emptyTile) {
+    const next = new Map(tiles);
+    const changed = [];
+    for (const coord of patternAt(center, pattern)) {
+        const key = tileKey(coord);
+        const before = next.get(key) ?? fill();
+        const after = apply(before, coord);
+        if (after !== before) {
+            next.set(key, after);
+            changed.push(coord);
+        }
+    }
+    return { tiles: next, changed };
+}
+export function createDayTicker(startDay = 0) {
+    let last = Math.floor(startDay);
+    return {
+        tick(currentDay) {
+            const now = Math.floor(currentDay);
+            const crossed = Math.max(0, now - last);
+            last = now;
+            return crossed;
+        },
+        day: () => last,
+    };
+}
+export function createCropField(catalog = () => null) {
+    let grid = new Map();
+    function read(coord) {
+        return grid.get(tileKey(coord)) ?? emptyTile();
+    }
+    return {
+        get: read,
+        till(coord, pattern = singleTile()) {
+            const result = applyToolToTiles(grid, coord, pattern, tillTile);
+            grid = result.tiles;
+            return result.changed;
+        },
+        plant(coord, cropId) {
+            const before = read(coord);
+            const after = plantCrop(before, cropId);
+            if (after === before)
+                return false;
+            grid.set(tileKey(coord), after);
+            return true;
+        },
+        water(coord, pattern = singleTile()) {
+            const result = applyToolToTiles(grid, coord, pattern, waterTile);
+            grid = result.tiles;
+            return result.changed;
+        },
+        harvest(coord) {
+            const state = read(coord);
+            if (state.cropId === null)
+                return null;
+            const def = catalog(state.cropId);
+            if (def === null)
+                return null;
+            const result = harvestCrop(def, state);
+            grid.set(tileKey(coord), result.state);
+            return result.yield;
+        },
+        advanceDay(days = 1) {
+            for (let i = 0; i < days; i++) {
+                for (const [key, state] of grid) {
+                    if (state.cropId === null) {
+                        if (state.watered)
+                            grid.set(key, { ...state, watered: false });
+                        continue;
+                    }
+                    const def = catalog(state.cropId);
+                    grid.set(key, def === null ? state : advanceCropDay(def, state));
+                }
+            }
+        },
+        tiles: () => grid,
+    };
+}

package/dist/crafting/production.d.ts

@@ -0,0 +1,64 @@
+import type { RecipeItem } from "./recipe.js";
+export interface ProductionBuildingDef {
+    id: string;
+    inputs: readonly RecipeItem[];
+    outputs: readonly RecipeItem[];
+    rate: number;
+    power?: number;
+    bufferMultiplier?: number;
+}
+export interface ProductionBuildingConfig {
+    id: string;
+    inputs?: readonly RecipeItem[];
+    outputs: readonly RecipeItem[];
+    rate: number;
+    power?: number;
+    bufferMultiplier?: number;
+}
+export type ItemCounts = Readonly<Record<string, number>>;
+export interface ProductionState {
+    buffer: ItemCounts;
+    output: ItemCounts;
+    progress: number;
+    active: boolean;
+}
+export interface ProductionTickInput {
+    dt: number;
+    powered?: boolean;
+}
+export declare function productionBuilding(config: ProductionBuildingConfig): ProductionBuildingDef;
+export declare function createProductionState(): ProductionState;
+export declare function acceptsInput(def: ProductionBuildingDef, state: ProductionState, itemId: string): boolean;
+export declare function feedProduction(def: ProductionBuildingDef, state: ProductionState, itemId: string, count: number): {
+    state: ProductionState;
+    accepted: number;
+};
+export declare function drainOutput(state: ProductionState, itemId: string, count?: number): {
+    state: ProductionState;
+    taken: number;
+};
+export declare function tickProduction(def: ProductionBuildingDef, state: ProductionState, input: ProductionTickInput): ProductionState;
+export interface TransportItem {
+    itemId: string;
+    count: number;
+    position: number;
+}
+export interface TransportPath {
+    length: number;
+    speed: number;
+}
+export declare function advanceTransport(path: TransportPath, items: readonly TransportItem[], dt: number): {
+    items: TransportItem[];
+    delivered: TransportItem[];
+};
+export interface PowerConsumer {
+    id: string;
+    demand: number;
+}
+export interface PowerGridResult {
+    powered: ReadonlySet<string>;
+    supply: number;
+    demand: number;
+    deficit: number;
+}
+export declare function resolvePowerGrid(supply: number, consumers: readonly PowerConsumer[]): PowerGridResult;