@jgengine/core 0.6.0 → 0.8.0

package/dist/inventory/shapedGrid.js

@@ -0,0 +1,176 @@
+function cellKey(cell) {
+    return `${cell[0]},${cell[1]}`;
+}
+export function normalizeFootprint(footprint) {
+    if (footprint.length === 0)
+        return [];
+    let minC = Infinity;
+    let minR = Infinity;
+    for (const [c, r] of footprint) {
+        if (c < minC)
+            minC = c;
+        if (r < minR)
+            minR = r;
+    }
+    const shifted = footprint.map(([c, r]) => [c - minC, r - minR]);
+    shifted.sort((a, b) => (a[1] === b[1] ? a[0] - b[0] : a[1] - b[1]));
+    const seen = new Set();
+    const out = [];
+    for (const cell of shifted) {
+        const key = cellKey(cell);
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(cell);
+        }
+    }
+    return out;
+}
+export function rotateFootprint(footprint, rotation) {
+    const turns = ((rotation % 4) + 4) % 4;
+    let cells = footprint.map(([c, r]) => [c, r]);
+    for (let i = 0; i < turns; i++) {
+        cells = cells.map(([c, r]) => [-r, c]);
+    }
+    return normalizeFootprint(cells);
+}
+export function occupiedCells(footprint, origin, rotation) {
+    const rotated = rotateFootprint(footprint, rotation);
+    return rotated.map(([c, r]) => [c + origin[0], r + origin[1]]);
+}
+export function createShapedGrid(width, height) {
+    if (width <= 0 || height <= 0)
+        throw new Error("shaped grid needs positive dimensions");
+    return { width, height, placements: [] };
+}
+function inBounds(grid, cells) {
+    return cells.every(([c, r]) => c >= 0 && r >= 0 && c < grid.width && r < grid.height);
+}
+function occupancyMap(grid, ignoreId) {
+    const map = new Map();
+    for (const placement of grid.placements) {
+        if (placement.id === ignoreId)
+            continue;
+        for (const cell of occupiedCells(placement.footprint, placement.origin, placement.rotation)) {
+            map.set(cellKey(cell), placement.id);
+        }
+    }
+    return map;
+}
+export function canPlace(grid, footprint, origin, rotation, ignoreId) {
+    const cells = occupiedCells(footprint, origin, rotation);
+    if (!inBounds(grid, cells))
+        return "out-of-bounds";
+    const occupied = occupancyMap(grid, ignoreId);
+    for (const cell of cells) {
+        if (occupied.has(cellKey(cell)))
+            return "overlap";
+    }
+    return null;
+}
+export function placeShaped(grid, item, origin, rotation = 0) {
+    if (grid.placements.some((p) => p.id === item.id)) {
+        return { status: "rejected", reason: "duplicate-id", detail: item.id };
+    }
+    const rejection = canPlace(grid, item.footprint, origin, rotation);
+    if (rejection !== null)
+        return { status: "rejected", reason: rejection };
+    const placement = {
+        id: item.id,
+        value: item.value,
+        footprint: item.footprint,
+        origin,
+        rotation,
+    };
+    return { status: "ok", grid: { ...grid, placements: [...grid.placements, placement] } };
+}
+export function removeShaped(grid, id) {
+    if (!grid.placements.some((p) => p.id === id)) {
+        return { status: "rejected", reason: "unknown-id", detail: id };
+    }
+    return { status: "ok", grid: { ...grid, placements: grid.placements.filter((p) => p.id !== id) } };
+}
+export function moveShaped(grid, id, origin, rotation) {
+    const existing = grid.placements.find((p) => p.id === id);
+    if (existing === undefined)
+        return { status: "rejected", reason: "unknown-id", detail: id };
+    const nextRotation = rotation ?? existing.rotation;
+    const rejection = canPlace(grid, existing.footprint, origin, nextRotation, id);
+    if (rejection !== null)
+        return { status: "rejected", reason: rejection };
+    return {
+        status: "ok",
+        grid: {
+            ...grid,
+            placements: grid.placements.map((p) => p.id === id ? { ...p, origin, rotation: nextRotation } : p),
+        },
+    };
+}
+export function cellOccupant(grid, cell) {
+    return occupancyMap(grid).get(cellKey(cell)) ?? null;
+}
+const ORTHOGONAL = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+];
+const DIAGONAL = [
+    [1, 1],
+    [1, -1],
+    [-1, 1],
+    [-1, -1],
+];
+export function gridAdjacencyQuery(grid, options = {}) {
+    const directions = options.diagonal ? [...ORTHOGONAL, ...DIAGONAL] : ORTHOGONAL;
+    const cellsById = new Map();
+    const owner = new Map();
+    for (const placement of grid.placements) {
+        const cells = occupiedCells(placement.footprint, placement.origin, placement.rotation);
+        cellsById.set(placement.id, cells);
+        for (const cell of cells)
+            owner.set(cellKey(cell), placement.id);
+    }
+    const cellsOf = (id) => cellsById.get(id) ?? [];
+    const neighborsOf = (id) => {
+        const found = new Set();
+        for (const cell of cellsOf(id)) {
+            for (const [dc, dr] of directions) {
+                const key = cellKey([cell[0] + dc, cell[1] + dr]);
+                const other = owner.get(key);
+                if (other !== undefined && other !== id)
+                    found.add(other);
+            }
+        }
+        return [...found];
+    };
+    return {
+        cellsOf,
+        neighborsOf,
+        touching: (idA, idB) => neighborsOf(idA).includes(idB),
+        adjacentCells(cells) {
+            const own = new Set(cells.map(cellKey));
+            const found = new Set();
+            const out = [];
+            for (const cell of cells) {
+                for (const [dc, dr] of directions) {
+                    const target = [cell[0] + dc, cell[1] + dr];
+                    const key = cellKey(target);
+                    if (own.has(key) || found.has(key))
+                        continue;
+                    if (target[0] < 0 || target[1] < 0 || target[0] >= grid.width || target[1] >= grid.height) {
+                        continue;
+                    }
+                    found.add(key);
+                    out.push(target);
+                }
+            }
+            return out;
+        },
+    };
+}
+export function cellFromPoint(point, cellSize, gridOrigin = { x: 0, y: 0 }) {
+    return [
+        Math.floor((point.x - gridOrigin.x) / cellSize),
+        Math.floor((point.y - gridOrigin.y) / cellSize),
+    ];
+}

package/dist/inventory/storageTier.d.ts

@@ -0,0 +1,52 @@
+export type StorageTier = "carried" | "banked";
+export interface ItemStack {
+    itemId: string;
+    count: number;
+}
+export interface ContainerSnapshot {
+    inventoryId: string;
+    tier: StorageTier;
+    items: readonly ItemStack[];
+}
+export interface DeathPartition {
+    kept: readonly ItemStack[];
+    lost: readonly ItemStack[];
+}
+export declare function tierOf(tiers: Record<string, StorageTier>, inventoryId: string): StorageTier;
+export declare function partitionOnDeath(containers: readonly ContainerSnapshot[]): DeathPartition;
+export interface DeliveryEntry {
+    id: string;
+    userId: string;
+    inventoryId: string;
+    items: readonly ItemStack[];
+    deliverAt: number;
+}
+export interface ScheduledDelivery {
+    userId: string;
+    inventoryId: string;
+    items: readonly ItemStack[];
+    deliverAt: number;
+}
+export interface DeliveryQueue {
+    schedule(entry: ScheduledDelivery & {
+        id?: string;
+    }): DeliveryEntry;
+    due(now: number): readonly DeliveryEntry[];
+    claimDue(now: number): readonly DeliveryEntry[];
+    pending(userId?: string): readonly DeliveryEntry[];
+    cancel(id: string): boolean;
+}
+export declare function createDeliveryQueue(): DeliveryQueue;
+export interface InsurancePolicy {
+    isInsured(itemId: string): boolean;
+    returnInventoryId: string;
+    delaySeconds: number | [number, number];
+}
+export declare function insureLost(lost: readonly ItemStack[], policy: InsurancePolicy, userId: string, now: number, rng?: () => number): ScheduledDelivery | null;
+export interface ConsolationPolicy {
+    loadoutId: string;
+    when?: "always" | "if-carried-empty";
+}
+export declare function resolveConsolation(policy: ConsolationPolicy, partition: DeathPartition): {
+    loadoutId: string;
+} | null;

package/dist/inventory/storageTier.js

@@ -0,0 +1,77 @@
+export function tierOf(tiers, inventoryId) {
+    return tiers[inventoryId] ?? "carried";
+}
+function mergeStacks(stacks) {
+    const totals = new Map();
+    for (const stack of stacks)
+        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 partitionOnDeath(containers) {
+    const kept = [];
+    const lost = [];
+    for (const container of containers) {
+        (container.tier === "banked" ? kept : lost).push(...container.items);
+    }
+    return { kept: mergeStacks(kept), lost: mergeStacks(lost) };
+}
+export function createDeliveryQueue() {
+    const entries = new Map();
+    let counter = 0;
+    return {
+        schedule(entry) {
+            const id = entry.id ?? `delivery_${(counter += 1)}`;
+            const stored = {
+                id,
+                userId: entry.userId,
+                inventoryId: entry.inventoryId,
+                items: entry.items,
+                deliverAt: entry.deliverAt,
+            };
+            entries.set(id, stored);
+            return stored;
+        },
+        due(now) {
+            return [...entries.values()].filter((e) => e.deliverAt <= now);
+        },
+        claimDue(now) {
+            const ready = [...entries.values()].filter((e) => e.deliverAt <= now);
+            for (const entry of ready)
+                entries.delete(entry.id);
+            return ready;
+        },
+        pending(userId) {
+            const all = [...entries.values()];
+            return userId === undefined ? all : all.filter((e) => e.userId === userId);
+        },
+        cancel(id) {
+            return entries.delete(id);
+        },
+    };
+}
+function resolveDelay(delay, rng) {
+    if (typeof delay === "number")
+        return delay;
+    const [min, max] = delay;
+    return min + rng() * (max - min);
+}
+export function insureLost(lost, policy, userId, now, rng = Math.random) {
+    const items = lost.filter((stack) => policy.isInsured(stack.itemId));
+    if (items.length === 0)
+        return null;
+    return {
+        userId,
+        inventoryId: policy.returnInventoryId,
+        items,
+        deliverAt: now + resolveDelay(policy.delaySeconds, rng),
+    };
+}
+export function resolveConsolation(policy, partition) {
+    if (policy.when === "if-carried-empty" && partition.lost.length > 0)
+        return null;
+    return { loadoutId: policy.loadoutId };
+}

package/dist/item/affix.d.ts

@@ -0,0 +1,54 @@
+export type AffixOp = "add" | "mul";
+export interface AffixDef {
+    id: string;
+    stat: string;
+    op?: AffixOp;
+    roll: number | [number, number];
+    weight: number;
+    namePart?: {
+        position: "prefix" | "suffix";
+        text: string;
+    };
+}
+export interface AffixPool {
+    id: string;
+    affixes: readonly AffixDef[];
+}
+export interface RarityTier {
+    id: string;
+    weight: number;
+    affixCount: number | [number, number];
+    statScale?: number;
+    namePart?: string;
+    pools?: readonly string[];
+}
+export interface ItemBaseDef {
+    id: string;
+    name: string;
+    baseStats: Record<string, number>;
+    pools: readonly string[];
+}
+export interface RollerConfig {
+    pools: readonly AffixPool[];
+    rarities: readonly RarityTier[];
+}
+export interface RolledAffix {
+    id: string;
+    stat: string;
+    op: AffixOp;
+    value: number;
+}
+export interface RolledItem {
+    baseId: string;
+    rarity: string;
+    name: string;
+    affixes: readonly RolledAffix[];
+    stats: Record<string, number>;
+}
+export { seededRng } from "../random/rng.js";
+export interface AffixRoller {
+    rollRarity(rng: () => number): RarityTier;
+    roll(base: ItemBaseDef, rarityId: string, rng: () => number): RolledItem;
+    rollRandom(base: ItemBaseDef, rng: () => number): RolledItem;
+}
+export declare function createAffixRoller(config: RollerConfig): AffixRoller;

package/dist/item/affix.js

@@ -0,0 +1,115 @@
+import { pickWeighted } from "../world/scatterItems.js";
+export { seededRng } from "../random/rng.js";
+function resolveRoll(roll, rng) {
+    if (typeof roll === "number")
+        return roll;
+    const [min, max] = roll;
+    return min + rng() * (max - min);
+}
+function resolveCount(count, rng) {
+    if (typeof count === "number")
+        return count;
+    const [min, max] = count;
+    return min + Math.floor(rng() * (max - min + 1));
+}
+function assertConfig(config) {
+    if (config.rarities.length === 0)
+        throw new Error("affix roller must have at least one rarity tier");
+    for (const tier of config.rarities) {
+        if (!(tier.weight > 0))
+            throw new Error(`rarity "${tier.id}" weight must be positive`);
+    }
+}
+export function createAffixRoller(config) {
+    assertConfig(config);
+    const poolById = new Map(config.pools.map((p) => [p.id, p]));
+    const rarityById = new Map(config.rarities.map((r) => [r.id, r]));
+    const rarityEntries = config.rarities.map((value) => ({ value, weight: value.weight }));
+    function candidatesFor(base, rarity) {
+        const allowed = rarity.pools;
+        const out = [];
+        for (const poolId of base.pools) {
+            if (allowed !== undefined && !allowed.includes(poolId))
+                continue;
+            const pool = poolById.get(poolId);
+            if (pool === undefined)
+                continue;
+            for (const affix of pool.affixes)
+                out.push(affix);
+        }
+        return out;
+    }
+    function drawAffixes(candidates, count, rng) {
+        const remaining = candidates.slice();
+        const drawn = [];
+        const target = Math.min(count, remaining.length);
+        for (let i = 0; i < target; i++) {
+            const picked = pickWeighted(remaining.map((value) => ({ value, weight: value.weight })), rng());
+            if (picked === null)
+                break;
+            remaining.splice(remaining.indexOf(picked), 1);
+            drawn.push({ id: picked.id, stat: picked.stat, op: picked.op ?? "add", value: resolveRoll(picked.roll, rng) });
+        }
+        return drawn;
+    }
+    function computeStats(base, rarity, affixes) {
+        const scale = rarity.statScale ?? 1;
+        const stats = {};
+        for (const [key, value] of Object.entries(base.baseStats))
+            stats[key] = value * scale;
+        for (const affix of affixes) {
+            if (affix.op === "add")
+                stats[affix.stat] = (stats[affix.stat] ?? 0) + affix.value;
+        }
+        for (const affix of affixes) {
+            if (affix.op === "mul")
+                stats[affix.stat] = (stats[affix.stat] ?? 0) * affix.value;
+        }
+        return stats;
+    }
+    function composeName(base, rarity, affixes) {
+        const prefix = affixes.find((a) => affixNameFor(a)?.position === "prefix");
+        const suffix = affixes.find((a) => affixNameFor(a)?.position === "suffix");
+        const parts = [];
+        if (rarity.namePart !== undefined)
+            parts.push(rarity.namePart);
+        if (prefix !== undefined)
+            parts.push(affixNameFor(prefix).text);
+        parts.push(base.name);
+        if (suffix !== undefined)
+            parts.push(affixNameFor(suffix).text);
+        return parts.join(" ");
+    }
+    const nameByAffixId = new Map();
+    for (const pool of config.pools) {
+        for (const affix of pool.affixes)
+            if (affix.namePart !== undefined)
+                nameByAffixId.set(affix.id, affix.namePart);
+    }
+    function affixNameFor(affix) {
+        return nameByAffixId.get(affix.id);
+    }
+    return {
+        rollRarity(rng) {
+            const picked = pickWeighted(rarityEntries, rng());
+            return picked ?? config.rarities[config.rarities.length - 1];
+        },
+        roll(base, rarityId, rng) {
+            const rarity = rarityById.get(rarityId);
+            if (rarity === undefined)
+                throw new Error(`unknown rarity tier: ${rarityId}`);
+            const count = resolveCount(rarity.affixCount, rng);
+            const affixes = drawAffixes(candidatesFor(base, rarity), count, rng);
+            return {
+                baseId: base.id,
+                rarity: rarity.id,
+                name: composeName(base, rarity, affixes),
+                affixes,
+                stats: computeStats(base, rarity, affixes),
+            };
+        },
+        rollRandom(base, rng) {
+            return this.roll(base, this.rollRarity(rng).id, rng);
+        },
+    };
+}

package/dist/item/durability.d.ts

@@ -0,0 +1,51 @@
+export interface RepairMaterial {
+    item: string;
+    perPoint: number;
+}
+export interface RepairSpec {
+    materials: readonly RepairMaterial[];
+    station?: string;
+    qualityLossPerRepair?: number;
+}
+export interface DurabilitySpec {
+    max: number;
+    wearPerUse?: number;
+    wearPerHit?: number;
+    disableAtZero?: boolean;
+    repair?: RepairSpec;
+}
+export interface DurabilityState {
+    current: number;
+    max: number;
+}
+export type WearKind = "use" | "hit";
+export interface RepairCost {
+    item: string;
+    count: number;
+}
+export interface RepairQuote {
+    materials: readonly RepairCost[];
+    restored: number;
+    state: DurabilityState;
+}
+export declare function createDurability(spec: DurabilitySpec): DurabilityState;
+export declare function durabilityFraction(state: DurabilityState): number;
+export declare function isBroken(state: DurabilityState): boolean;
+export declare function isDisabled(spec: DurabilitySpec, state: DurabilityState): boolean;
+export declare function wearAmount(spec: DurabilitySpec, kind: WearKind): number;
+export declare function applyWear(state: DurabilityState, amount: number): DurabilityState;
+export declare function wear(spec: DurabilitySpec, state: DurabilityState, kind: WearKind, times?: number): DurabilityState;
+export declare function canRepairAt(spec: DurabilitySpec, stationId?: string): boolean;
+export declare function repairQuote(spec: DurabilitySpec, state: DurabilityState, options?: {
+    to?: number;
+    station?: string;
+}): RepairQuote | null;
+export interface DurabilityTracker {
+    init(instanceId: string, spec: DurabilitySpec): DurabilityState;
+    get(instanceId: string): DurabilityState | null;
+    set(instanceId: string, state: DurabilityState): void;
+    wear(instanceId: string, spec: DurabilitySpec, kind: WearKind, times?: number): DurabilityState | null;
+    isDisabled(instanceId: string, spec: DurabilitySpec): boolean;
+    remove(instanceId: string): void;
+}
+export declare function createDurabilityTracker(): DurabilityTracker;

package/dist/item/durability.js

@@ -0,0 +1,78 @@
+function clamp(value, min, max) {
+    return value < min ? min : value > max ? max : value;
+}
+export function createDurability(spec) {
+    const max = Math.max(0, spec.max);
+    return { current: max, max };
+}
+export function durabilityFraction(state) {
+    return state.max <= 0 ? 0 : clamp(state.current / state.max, 0, 1);
+}
+export function isBroken(state) {
+    return state.current <= 0;
+}
+export function isDisabled(spec, state) {
+    return isBroken(state) && spec.disableAtZero !== false;
+}
+export function wearAmount(spec, kind) {
+    return kind === "use" ? spec.wearPerUse ?? 0 : spec.wearPerHit ?? 0;
+}
+export function applyWear(state, amount) {
+    if (amount <= 0)
+        return state;
+    return { current: clamp(state.current - amount, 0, state.max), max: state.max };
+}
+export function wear(spec, state, kind, times = 1) {
+    return applyWear(state, wearAmount(spec, kind) * Math.max(0, times));
+}
+export function canRepairAt(spec, stationId) {
+    const repair = spec.repair;
+    if (repair === undefined)
+        return false;
+    return repair.station === undefined || repair.station === stationId;
+}
+export function repairQuote(spec, state, options) {
+    const repair = spec.repair;
+    if (repair === undefined)
+        return null;
+    if (repair.station !== undefined && repair.station !== options?.station)
+        return null;
+    const loss = repair.qualityLossPerRepair ?? 0;
+    const newMax = Math.max(1, state.max - loss);
+    const capped = Math.min(state.current, newMax);
+    const target = clamp(options?.to ?? newMax, capped, newMax);
+    const restored = Math.max(0, target - capped);
+    const materials = repair.materials.map((m) => ({ item: m.item, count: Math.ceil(m.perPoint * restored) }));
+    return { materials, restored, state: { current: target, max: newMax } };
+}
+export function createDurabilityTracker() {
+    const states = new Map();
+    return {
+        init(instanceId, spec) {
+            const state = createDurability(spec);
+            states.set(instanceId, state);
+            return state;
+        },
+        get(instanceId) {
+            return states.get(instanceId) ?? null;
+        },
+        set(instanceId, state) {
+            states.set(instanceId, state);
+        },
+        wear(instanceId, spec, kind, times) {
+            const current = states.get(instanceId);
+            if (current === undefined)
+                return null;
+            const next = wear(spec, current, kind, times);
+            states.set(instanceId, next);
+            return next;
+        },
+        isDisabled(instanceId, spec) {
+            const state = states.get(instanceId);
+            return state !== undefined && isDisabled(spec, state);
+        },
+        remove(instanceId) {
+            states.delete(instanceId);
+        },
+    };
+}

package/dist/item/modularItem.d.ts

@@ -0,0 +1,46 @@
+export interface MountSlotDef {
+    id: string;
+    accepts: string | readonly string[];
+    required?: boolean;
+}
+export interface ModularItemDef {
+    id: string;
+    baseStats: Record<string, number>;
+    slots: readonly MountSlotDef[];
+}
+export interface PartDef {
+    id: string;
+    category: string;
+    stats?: Record<string, number>;
+    multipliers?: Record<string, number>;
+}
+export interface InstalledPart {
+    slotId: string;
+    part: PartDef;
+}
+export type InstallResult = {
+    status: "ok";
+    installed: readonly InstalledPart[];
+} | {
+    status: "rejected";
+    reason: "unknown-slot" | "wrong-category" | "slot-occupied";
+};
+export declare function slotById(def: ModularItemDef, slotId: string): MountSlotDef | null;
+export declare function slotAccepts(slot: MountSlotDef, category: string): boolean;
+export declare function install(def: ModularItemDef, installed: readonly InstalledPart[], slotId: string, part: PartDef): InstallResult;
+export declare function uninstall(installed: readonly InstalledPart[], slotId: string): readonly InstalledPart[];
+export declare function partInSlot(installed: readonly InstalledPart[], slotId: string): PartDef | null;
+export declare function computeEffectiveStats(def: ModularItemDef, installed: readonly InstalledPart[]): Record<string, number>;
+export declare function missingRequiredSlots(def: ModularItemDef, installed: readonly InstalledPart[]): string[];
+export declare function isComplete(def: ModularItemDef, installed: readonly InstalledPart[]): boolean;
+export interface ModularItem {
+    readonly def: ModularItemDef;
+    parts(): readonly InstalledPart[];
+    install(slotId: string, part: PartDef): InstallResult;
+    uninstall(slotId: string): readonly InstalledPart[];
+    partInSlot(slotId: string): PartDef | null;
+    effectiveStats(): Record<string, number>;
+    missingRequired(): string[];
+    isComplete(): boolean;
+}
+export declare function createModularItem(def: ModularItemDef, initial?: readonly InstalledPart[]): ModularItem;