@jgengine/core 0.6.0 → 0.8.0

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;

package/dist/crafting/production.js

@@ -0,0 +1,130 @@
+export function productionBuilding(config) {
+    return {
+        id: config.id,
+        inputs: config.inputs ?? [],
+        outputs: config.outputs,
+        rate: config.rate,
+        power: config.power,
+        bufferMultiplier: config.bufferMultiplier,
+    };
+}
+export function createProductionState() {
+    return { buffer: {}, output: {}, progress: 0, active: false };
+}
+function addCount(counts, itemId, amount) {
+    const next = { ...counts };
+    const total = (next[itemId] ?? 0) + amount;
+    if (total <= 0)
+        delete next[itemId];
+    else
+        next[itemId] = total;
+    return next;
+}
+function bufferCapacity(def, required) {
+    const multiplier = def.bufferMultiplier !== undefined && def.bufferMultiplier > 0 ? def.bufferMultiplier : 2;
+    return Math.max(required, Math.ceil(required * multiplier));
+}
+export function acceptsInput(def, state, itemId) {
+    const input = def.inputs.find((i) => i.itemId === itemId);
+    if (input === undefined)
+        return false;
+    const held = state.buffer[itemId] ?? 0;
+    return held < bufferCapacity(def, input.count);
+}
+export function feedProduction(def, state, itemId, count) {
+    const input = def.inputs.find((i) => i.itemId === itemId);
+    if (input === undefined || count <= 0)
+        return { state, accepted: 0 };
+    const capacity = bufferCapacity(def, input.count);
+    const held = state.buffer[itemId] ?? 0;
+    const accepted = Math.min(count, Math.max(0, capacity - held));
+    if (accepted === 0)
+        return { state, accepted: 0 };
+    return { state: { ...state, buffer: addCount(state.buffer, itemId, accepted) }, accepted };
+}
+export function drainOutput(state, itemId, count) {
+    const held = state.output[itemId] ?? 0;
+    const taken = count === undefined ? held : Math.min(count, held);
+    if (taken <= 0)
+        return { state, taken: 0 };
+    return { state: { ...state, output: addCount(state.output, itemId, -taken) }, taken };
+}
+function hasInputs(def, buffer) {
+    return def.inputs.every((i) => (buffer[i.itemId] ?? 0) >= i.count);
+}
+function consume(def, buffer) {
+    let next = buffer;
+    for (const input of def.inputs)
+        next = addCount(next, input.itemId, -input.count);
+    return next;
+}
+function emit(def, output) {
+    let next = output;
+    for (const out of def.outputs)
+        next = addCount(next, out.itemId, out.count);
+    return next;
+}
+export function tickProduction(def, state, input) {
+    const powerNeeded = def.power !== undefined && def.power > 0;
+    if (powerNeeded && input.powered !== true)
+        return state;
+    if (!(def.rate > 0) || input.dt <= 0)
+        return state;
+    const secondsPerCycle = 1 / def.rate;
+    let buffer = state.buffer;
+    let output = state.output;
+    let progress = state.progress;
+    let active = state.active;
+    if (!active) {
+        if (!hasInputs(def, buffer))
+            return state;
+        buffer = consume(def, buffer);
+        active = true;
+        progress = 0;
+    }
+    progress += input.dt;
+    let guard = 0;
+    while (active && progress >= secondsPerCycle) {
+        progress -= secondsPerCycle;
+        output = emit(def, output);
+        if (hasInputs(def, buffer)) {
+            buffer = consume(def, buffer);
+        }
+        else {
+            active = false;
+            progress = 0;
+        }
+        guard += 1;
+        if (guard >= 10_000)
+            break;
+    }
+    return { buffer, output, progress, active };
+}
+export function advanceTransport(path, items, dt) {
+    if (dt <= 0 || !(path.speed > 0))
+        return { items: items.slice(), delivered: [] };
+    const moving = [];
+    const delivered = [];
+    const step = path.speed * dt;
+    for (const item of items) {
+        const position = item.position + step;
+        if (position >= path.length)
+            delivered.push({ ...item, position: path.length });
+        else
+            moving.push({ ...item, position });
+    }
+    return { items: moving, delivered };
+}
+export function resolvePowerGrid(supply, consumers) {
+    const powered = new Set();
+    let used = 0;
+    let demand = 0;
+    for (const consumer of consumers) {
+        demand += Math.max(0, consumer.demand);
+        if (used + consumer.demand <= supply) {
+            used += consumer.demand;
+            powered.add(consumer.id);
+        }
+    }
+    return { powered, supply, demand, deficit: Math.max(0, demand - supply) };
+}

package/dist/crafting/recipe.d.ts

@@ -0,0 +1,62 @@
+import type { Vec2 } from "../world/geometry.js";
+import type { InventoryLayout, InventoryState, ItemTraits } from "../inventory/inventoryModel.js";
+export interface RecipeItem {
+    itemId: string;
+    count: number;
+}
+export interface RecipeDef {
+    id: string;
+    inputs: readonly RecipeItem[];
+    outputs: readonly RecipeItem[];
+    seconds?: number;
+    station?: string;
+    stationRange?: number;
+    requires?: readonly string[];
+    category?: string;
+}
+export interface StationInstance {
+    catalogId: string;
+    position: Vec2;
+}
+export interface CraftContext {
+    origin?: Vec2;
+    stations?: readonly StationInstance[];
+    unlocked?: (id: string) => boolean;
+}
+export type CraftRejection = {
+    reason: "missing-inputs";
+    missing: readonly RecipeItem[];
+} | {
+    reason: "no-station";
+    station: string;
+} | {
+    reason: "locked";
+    requires: readonly string[];
+} | {
+    reason: "no-output-space";
+};
+export type CraftCheck = {
+    ok: true;
+} | ({
+    ok: false;
+} & CraftRejection);
+export type CraftResult = {
+    status: "ok";
+    state: InventoryState;
+} | ({
+    status: "rejected";
+} & CraftRejection);
+export declare function craftSeconds(recipe: RecipeDef): number;
+export declare function missingInputs(state: InventoryState, recipe: RecipeDef): RecipeItem[];
+export declare function hasRecipeInputs(state: InventoryState, recipe: RecipeDef): boolean;
+export declare function stationSatisfied(recipe: RecipeDef, context: CraftContext): boolean;
+export declare function canCraft(state: InventoryState, layout: InventoryLayout, traits: ItemTraits, recipe: RecipeDef, context?: CraftContext): CraftCheck;
+export declare function craft(state: InventoryState, layout: InventoryLayout, traits: ItemTraits, recipe: RecipeDef, context?: CraftContext): CraftResult;
+export interface RecipeGraph {
+    all(): readonly RecipeDef[];
+    get(id: string): RecipeDef | null;
+    producing(itemId: string): RecipeDef[];
+    using(itemId: string): RecipeDef[];
+    category(categoryId: string): RecipeDef[];
+}
+export declare function createRecipeGraph(defs?: readonly RecipeDef[]): RecipeGraph;

package/dist/crafting/recipe.js

@@ -0,0 +1,101 @@
+import { countItem, putItem, takeItem } from "../inventory/inventoryModel.js";
+export function craftSeconds(recipe) {
+    return recipe.seconds !== undefined && recipe.seconds > 0 ? recipe.seconds : 0;
+}
+export function missingInputs(state, recipe) {
+    const missing = [];
+    for (const input of recipe.inputs) {
+        const have = countItem(state, input.itemId);
+        if (have < input.count)
+            missing.push({ itemId: input.itemId, count: input.count - have });
+    }
+    return missing;
+}
+export function hasRecipeInputs(state, recipe) {
+    return missingInputs(state, recipe).length === 0;
+}
+export function stationSatisfied(recipe, context) {
+    if (recipe.station === undefined)
+        return true;
+    const range = recipe.stationRange !== undefined && recipe.stationRange > 0 ? recipe.stationRange : Infinity;
+    const origin = context.origin;
+    const stations = context.stations ?? [];
+    for (const station of stations) {
+        if (station.catalogId !== recipe.station)
+            continue;
+        if (range === Infinity || origin === undefined)
+            return true;
+        const dx = station.position[0] - origin[0];
+        const dz = station.position[1] - origin[1];
+        if (dx * dx + dz * dz <= range * range)
+            return true;
+    }
+    return false;
+}
+function lockedRequirements(recipe, context) {
+    if (recipe.requires === undefined || recipe.requires.length === 0)
+        return [];
+    const unlocked = context.unlocked;
+    if (unlocked === undefined)
+        return [];
+    return recipe.requires.filter((id) => !unlocked(id));
+}
+function outputsFit(state, layout, traits, recipe) {
+    let projected = state;
+    for (const output of recipe.outputs) {
+        const put = putItem(projected, layout, traits, output.itemId, output.count);
+        if (put.status !== "ok")
+            return false;
+        projected = put.state;
+    }
+    return true;
+}
+function consumedState(state, recipe) {
+    let projected = state;
+    for (const input of recipe.inputs) {
+        const take = takeItem(projected, input.itemId, input.count);
+        if (take.status === "ok")
+            projected = take.state;
+    }
+    return projected;
+}
+export function canCraft(state, layout, traits, recipe, context = {}) {
+    const locked = lockedRequirements(recipe, context);
+    if (locked.length > 0)
+        return { ok: false, reason: "locked", requires: locked };
+    if (!stationSatisfied(recipe, context))
+        return { ok: false, reason: "no-station", station: recipe.station };
+    const missing = missingInputs(state, recipe);
+    if (missing.length > 0)
+        return { ok: false, reason: "missing-inputs", missing };
+    if (!outputsFit(consumedState(state, recipe), layout, traits, recipe))
+        return { ok: false, reason: "no-output-space" };
+    return { ok: true };
+}
+export function craft(state, layout, traits, recipe, context = {}) {
+    const check = canCraft(state, layout, traits, recipe, context);
+    if (!check.ok) {
+        const { ok: _ok, ...rejection } = check;
+        return { status: "rejected", ...rejection };
+    }
+    let projected = consumedState(state, recipe);
+    for (const output of recipe.outputs) {
+        const put = putItem(projected, layout, traits, output.itemId, output.count);
+        if (put.status !== "ok")
+            return { status: "rejected", reason: "no-output-space" };
+        projected = put.state;
+    }
+    return { status: "ok", state: projected };
+}
+export function createRecipeGraph(defs = []) {
+    const byId = new Map();
+    for (const def of defs)
+        byId.set(def.id, def);
+    return {
+        all: () => defs,
+        get: (id) => byId.get(id) ?? null,
+        producing: (itemId) => defs.filter((r) => r.outputs.some((o) => o.itemId === itemId)),
+        using: (itemId) => defs.filter((r) => r.inputs.some((i) => i.itemId === itemId)),
+        category: (categoryId) => defs.filter((r) => r.category === categoryId),
+    };
+}

package/dist/data/dataSource.d.ts

@@ -0,0 +1,26 @@
+export type DataSourceStatus = "idle" | "loading" | "ready" | "error";
+export interface DataSourceState<T> {
+    readonly status: DataSourceStatus;
+    readonly data: T | undefined;
+    readonly error: Error | undefined;
+}
+export interface DataSourceClock {
+    setInterval(handler: () => void, intervalMs: number): unknown;
+    clearInterval(handle: unknown): void;
+}
+export interface DataSourceOptions {
+    intervalMs?: number;
+    clock?: DataSourceClock;
+}
+export interface RefreshOptions {
+    force?: boolean;
+}
+export interface DataSource<T> {
+    getState(): DataSourceState<T>;
+    subscribe(listener: (state: DataSourceState<T>) => void): () => void;
+    refresh(options?: RefreshOptions): Promise<void>;
+    startPolling(intervalMs?: number): void;
+    stopPolling(): void;
+    dispose(): void;
+}
+export declare function createDataSource<T>(load: (signal: AbortSignal) => Promise<T>, options?: DataSourceOptions): DataSource<T>;

package/dist/data/dataSource.js

@@ -0,0 +1,93 @@
+const defaultClock = {
+    setInterval: (handler, intervalMs) => globalThis.setInterval(handler, intervalMs),
+    clearInterval: (handle) => globalThis.clearInterval(handle),
+};
+export function createDataSource(load, options = {}) {
+    const clock = options.clock ?? defaultClock;
+    const listeners = new Set();
+    let state = { status: "idle", data: undefined, error: undefined };
+    let controller;
+    let inFlight;
+    let pollHandle;
+    let disposed = false;
+    function setState(next) {
+        state = next;
+        for (const listener of listeners)
+            listener(state);
+    }
+    async function run() {
+        const ownController = new AbortController();
+        controller = ownController;
+        setState({ status: "loading", data: state.data, error: undefined });
+        try {
+            const data = await load(ownController.signal);
+            if (ownController.signal.aborted)
+                return;
+            setState({ status: "ready", data, error: undefined });
+        }
+        catch (error) {
+            if (ownController.signal.aborted)
+                return;
+            setState({
+                status: "error",
+                data: state.data,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+        finally {
+            if (controller === ownController)
+                controller = undefined;
+        }
+    }
+    function refresh(refreshOptions = {}) {
+        if (disposed)
+            return Promise.resolve();
+        if (inFlight !== undefined) {
+            if (!refreshOptions.force)
+                return inFlight;
+            controller?.abort();
+        }
+        const promise = run().finally(() => {
+            if (inFlight === promise)
+                inFlight = undefined;
+        });
+        inFlight = promise;
+        return promise;
+    }
+    function stopPolling() {
+        if (pollHandle !== undefined) {
+            clock.clearInterval(pollHandle);
+            pollHandle = undefined;
+        }
+    }
+    function startPolling(intervalMs) {
+        stopPolling();
+        const resolvedInterval = intervalMs ?? options.intervalMs;
+        if (resolvedInterval === undefined) {
+            throw new Error("startPolling requires an intervalMs (pass one, or set options.intervalMs at creation)");
+        }
+        void refresh();
+        pollHandle = clock.setInterval(() => {
+            void refresh();
+        }, resolvedInterval);
+    }
+    function dispose() {
+        disposed = true;
+        stopPolling();
+        controller?.abort();
+        listeners.clear();
+    }
+    if (options.intervalMs !== undefined)
+        startPolling(options.intervalMs);
+    return {
+        getState: () => state,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        refresh,
+        startPolling,
+        stopPolling,
+        dispose,
+    };
+}

package/dist/data/devProxy.d.ts

@@ -0,0 +1,11 @@
+export interface DevProxyTable {
+    readonly [routeName: string]: string;
+}
+export interface ProxiedUrlOptions {
+    dev?: boolean;
+    table?: DevProxyTable;
+    prefix?: string;
+}
+export declare function parseDevProxyTable(raw: string | undefined): DevProxyTable;
+export declare const DEFAULT_DEV_PROXY_PREFIX = "/proxy";
+export declare function proxiedUrl(target: string, options?: ProxiedUrlOptions): string;