@jgengine/core 0.9.0 → 0.11.0

package/dist/runtime/descriptors/baseline.js

@@ -0,0 +1,134 @@
+import { hydrateEntityStats, snapshotEntityStats, } from "../../scene/entityStats.js";
+/** @internal */
+export const baselineDescriptors = [
+    {
+        key: "entities",
+        create: (d) => ({
+            replicate: {
+                key: "entities",
+                snapshot: () => d.entities.snapshot(),
+                hydrate: (data) => d.entities.hydrate(data),
+            },
+        }),
+    },
+    {
+        key: "stats",
+        create: (d) => ({
+            replicate: {
+                key: "stats",
+                snapshot: () => snapshotEntityStats(d.statsByInstance),
+                hydrate: (data) => hydrateEntityStats(d.statsByInstance, data),
+            },
+        }),
+    },
+    {
+        key: "store",
+        create: (d) => ({
+            replicate: {
+                key: "store",
+                snapshot: () => d.store.snapshot(),
+                hydrate: (data) => d.store.hydrate(data),
+            },
+        }),
+    },
+    {
+        key: "feed",
+        create: (d) => ({
+            replicate: {
+                key: "feed",
+                snapshot: () => d.feed.snapshot(),
+                hydrate: (data) => d.feed.hydrate(data),
+            },
+        }),
+    },
+    {
+        key: "inventory",
+        create: (d) => ({
+            replicate: {
+                key: "inventory",
+                snapshot: () => {
+                    const byUser = {};
+                    for (const [userId, set] of d.inventoryByUser) {
+                        const states = {};
+                        for (const inventoryId of d.inventoryIds)
+                            states[inventoryId] = set.state(inventoryId);
+                        byUser[userId] = states;
+                    }
+                    return byUser;
+                },
+                hydrate: (data) => {
+                    for (const [userId, states] of Object.entries(data)) {
+                        const set = d.inventoryFor(userId);
+                        for (const [inventoryId, state] of Object.entries(states))
+                            set.replaceState(inventoryId, state);
+                    }
+                },
+            },
+        }),
+    },
+    {
+        key: "economy",
+        create: (d) => ({
+            save: {
+                key: "economy",
+                snapshot: () => Object.fromEntries(d.wallets),
+                hydrate: (data) => {
+                    d.wallets.clear();
+                    for (const [userId, state] of Object.entries(data)) {
+                        d.wallets.set(userId, state);
+                    }
+                    d.signalNotify();
+                },
+            },
+        }),
+    },
+    {
+        key: "time",
+        create: (d) => ({
+            save: {
+                key: "time",
+                snapshot: () => d.time.snapshot(),
+                hydrate: (data) => d.time.hydrate(data),
+            },
+        }),
+    },
+    {
+        key: "pose",
+        create: (d) => ({
+            save: {
+                key: "pose",
+                snapshot: () => d.pose.snapshotAll(),
+                hydrate: (data) => d.pose.hydrateAll(data),
+            },
+        }),
+    },
+    {
+        key: "possession",
+        create: (d) => ({
+            save: {
+                key: "possession",
+                snapshot: () => d.possession.snapshotAll(),
+                hydrate: (data) => d.possession.hydrateAll(data),
+            },
+        }),
+    },
+    {
+        key: "motion",
+        create: (d) => ({
+            save: {
+                key: "motion",
+                snapshot: () => {
+                    const out = {};
+                    for (const [userId, queue] of d.motionByUser)
+                        out[userId] = queue.snapshot();
+                    return out;
+                },
+                hydrate: (data) => {
+                    for (const [userId, batch] of Object.entries(data)) {
+                        d.motionFor(userId).hydrate(batch);
+                    }
+                },
+            },
+        }),
+    },
+];

package/dist/runtime/descriptors/features.d.ts

@@ -0,0 +1,74 @@
+import type { CardPile, CardPileConfig } from "../../cards/cardPile.js";
+import type { CommandRegistry } from "../../commands/commandRegistry.js";
+import { type WalletState } from "../../economy/wallet.js";
+import type { GameFeatures } from "../../game/defineGame.js";
+import type { GameEvents } from "../../game/events.js";
+import { type Social } from "../../game/social.js";
+import type { InventoryLayout, InventorySet } from "../../inventory/inventoryModel.js";
+import type { StatValueMap } from "../../scene/entityStats.js";
+import type { EntityStore } from "../../scene/entityStore.js";
+import type { SpatialApi } from "../../scene/spatial.js";
+import type { ObservableKeyedStore } from "../../store/observableKeyedStore.js";
+import type { SnapshotModule } from "../worldSnapshot.js";
+import type { TurnLoop, TurnLoopConfig } from "../../turn/turnLoop.js";
+import type { RaceState, RaceStateConfig } from "../../game/race.js";
+import type { GameContext, GameContextContent, GameContextEconomy } from "../gameContext.js";
+/**
+ * Shared wiring every optional-feature descriptor draws from — the live core subsystems (entities,
+ * spatial, economy, inventory) plus reactive plumbing (`signalNotify`) and a `feature` reader for the
+ * few features that reference another (quest reads unlocks). Handed to each {@link FeatureDescriptor}'s
+ * `create` so a new opt-in subsystem plugs into one registration, never a new `features.x ?` branch.
+ * @internal
+ */
+export interface FeatureDeps {
+    features: GameFeatures;
+    signalNotify: () => void;
+    events: GameEvents;
+    now: () => number;
+    entities: EntityStore;
+    spatial: SpatialApi;
+    store: ObservableKeyedStore<unknown>;
+    commandRegistry: CommandRegistry<GameContext>;
+    economy: GameContextEconomy;
+    content: GameContextContent;
+    activeUserId: () => string;
+    walletOf: (userId: string) => WalletState;
+    setWallet: (userId: string, state: WalletState) => void;
+    layouts: Record<string, InventoryLayout>;
+    inventoryFor: (userId: string) => InventorySet<string>;
+    ensureInstanceStats: (instanceId: string) => StatValueMap;
+    seedUserPool: (userId: string, statId: string, pool: {
+        current: number;
+        max?: number;
+        min?: number;
+    }) => void;
+    sharedSocial: () => Social;
+    pile: (id: string, config?: CardPileConfig) => CardPile;
+    loop: (id: string, config?: TurnLoopConfig) => TurnLoop;
+    cardPiles: ReadonlyMap<string, CardPile>;
+    turnLoops: ReadonlyMap<string, TurnLoop>;
+    raceState: (id: string, config?: RaceStateConfig) => RaceState;
+    feature: <T>(key: keyof GameFeatures) => T | undefined;
+}
+/** @internal What a descriptor produces: the `ctx`-facing value plus its optional replication/save modules. */
+export interface FeatureBuild {
+    value: unknown;
+    /** Registered into the host→client replication set when present (`ctx.snapshot`/`ctx.hydrate`). */
+    replicate?: SnapshotModule;
+    /** Registered into the whole-world save-only set when present (`ctx.game.save`). */
+    save?: SnapshotModule;
+}
+/**
+ * One opt-in subsystem expressed as data: which `features` flag turns it on, how it wires itself from
+ * {@link FeatureDeps}, and whether it replicates or persists. `createGameContext` iterates the
+ * descriptor list instead of hand-wiring each `features.x ? create : undefined` branch — the seam a
+ * new feature extends through.
+ * @internal
+ */
+export interface FeatureDescriptor {
+    readonly key: keyof GameFeatures;
+    enabled(features: GameFeatures): boolean;
+    create(deps: FeatureDeps): FeatureBuild;
+}
+/** @internal */
+export declare const featureDescriptors: readonly FeatureDescriptor[];

package/dist/runtime/descriptors/features.js

@@ -0,0 +1,281 @@
+import { canAfford as walletCanAfford, chargeAll as walletChargeAll, } from "../../economy/wallet.js";
+import { createCosmetics } from "../../game/cosmetics.js";
+import { createLeaderboard } from "../../game/leaderboard.js";
+import { createGameDialogue } from "../../game/dialogue.js";
+import { createQuestJournal } from "../../game/quest.js";
+import { createChat } from "../../game/chat.js";
+import {} from "../../game/social.js";
+import { createTradeSystem } from "../../game/trade.js";
+import { createUnlocks } from "../../game/unlocks.js";
+import { createRoster } from "../../scene/roster.js";
+import { createConnectedPlayers } from "../../game/connectedPlayers.js";
+import { notifyAfter } from "../../store/changeSignal.js";
+/** @internal */
+export const featureDescriptors = [
+    {
+        key: "unlocks",
+        enabled: (f) => f.unlocks === true,
+        create(d) {
+            const unlocks = notifyAfter(createUnlocks(), ["grant", "hydrate"], d.signalNotify);
+            return {
+                value: unlocks,
+                save: {
+                    key: "unlocks",
+                    snapshot: () => unlocks.snapshotAll(),
+                    hydrate: (data) => unlocks.hydrateAll(data),
+                },
+            };
+        },
+    },
+    {
+        key: "social",
+        enabled: (f) => f.social === true,
+        create(d) {
+            const raw = d.sharedSocial();
+            const social = {
+                friends: notifyAfter(raw.friends, ["request", "accept", "decline", "remove", "block", "hydrate"], d.signalNotify),
+                party: notifyAfter(raw.party, ["invite", "accept", "decline", "kick", "leave", "promote"], d.signalNotify),
+                presence: raw.presence,
+                emotes: raw.emotes,
+                worldInvites: notifyAfter(raw.worldInvites, ["invite", "accept", "decline"], d.signalNotify),
+                snapshot: raw.snapshot,
+                hydrate: (data) => {
+                    raw.hydrate(data);
+                    d.signalNotify();
+                },
+            };
+            return {
+                value: social,
+                replicate: {
+                    key: "social",
+                    snapshot: () => social.snapshot(),
+                    hydrate: (data) => social.hydrate(data),
+                },
+            };
+        },
+    },
+    {
+        key: "chat",
+        enabled: (f) => f.chat === true,
+        create(d) {
+            const raw = d.sharedSocial();
+            const chat = notifyAfter(createChat({
+                events: d.events,
+                now: d.now,
+                party: raw.party,
+                proximity: {
+                    entities: { get: (id) => d.entities.get(id) },
+                    spatial: { inRadius: (center, radius, filter) => d.spatial.inRadius(center, radius, filter) },
+                },
+                blockedBy: (userId) => raw.friends.snapshot(userId).blocked,
+            }), ["register", "send", "whisper", "hydrate"], d.signalNotify);
+            return {
+                value: chat,
+                replicate: {
+                    key: "chat",
+                    snapshot: () => chat.snapshot(),
+                    hydrate: (data) => chat.hydrate(data),
+                },
+            };
+        },
+    },
+    {
+        key: "leaderboard",
+        enabled: (f) => f.leaderboard === true,
+        create(d) {
+            const leaderboard = notifyAfter(createLeaderboard(), ["increment", "hydrate"], d.signalNotify);
+            return {
+                value: leaderboard,
+                replicate: {
+                    key: "leaderboard",
+                    snapshot: () => leaderboard.snapshot(),
+                    hydrate: (data) => leaderboard.hydrate(data),
+                },
+            };
+        },
+    },
+    {
+        key: "roster",
+        enabled: (f) => f.roster === true,
+        create(d) {
+            const roster = notifyAfter(createRoster({ now: d.now }), ["capture", "release", "setEquipped", "hydrate"], d.signalNotify);
+            return {
+                value: roster,
+                save: {
+                    key: "roster",
+                    snapshot: () => roster.snapshotAll(),
+                    hydrate: (data) => roster.hydrateAll(data),
+                },
+            };
+        },
+    },
+    {
+        key: "cosmetics",
+        enabled: (f) => f.cosmetics === true,
+        create(d) {
+            const cosmetics = notifyAfter(createCosmetics({ events: d.events }), ["apply", "equip", "hydrate"], d.signalNotify);
+            return {
+                value: cosmetics,
+                save: {
+                    key: "cosmetics",
+                    snapshot: () => cosmetics.snapshotAll(),
+                    hydrate: (data) => cosmetics.hydrateAll(data),
+                },
+            };
+        },
+    },
+    {
+        key: "trade",
+        enabled: (f) => f.trade === true,
+        create(d) {
+            return {
+                value: createTradeSystem({
+                    resolveTrade: (itemId) => d.content.itemById?.(itemId)?.trade,
+                    wallet: {
+                        canAfford: (costs) => walletCanAfford(d.walletOf(d.activeUserId()), costs) ? null : "insufficient-funds",
+                        charge(costs) {
+                            const result = walletChargeAll(d.walletOf(d.activeUserId()), costs);
+                            if (result.status === "ok") {
+                                d.setWallet(d.activeUserId(), result.state);
+                                d.signalNotify();
+                            }
+                        },
+                        grant(gains) {
+                            for (const [currencyId, amount] of Object.entries(gains)) {
+                                d.economy.grant(d.activeUserId(), currencyId, amount);
+                            }
+                        },
+                    },
+                    inventory: {
+                        put(inventoryId, itemId, count) {
+                            if (d.layouts[inventoryId] === undefined)
+                                return { reason: `unknown inventory "${inventoryId}"` };
+                            const result = d.inventoryFor(d.activeUserId()).put(inventoryId, itemId, count);
+                            return result.status === "ok" ? null : { reason: result.reason };
+                        },
+                        take(inventoryId, itemId, count) {
+                            if (d.layouts[inventoryId] === undefined)
+                                return { reason: `unknown inventory "${inventoryId}"` };
+                            const result = d.inventoryFor(d.activeUserId()).take(inventoryId, itemId, count);
+                            return result.status === "ok" ? null : { reason: result.reason };
+                        },
+                        count: (inventoryId, itemId) => d.inventoryFor(d.activeUserId()).count(inventoryId, itemId),
+                    },
+                }),
+            };
+        },
+    },
+    {
+        key: "quest",
+        enabled: (f) => f.quest === true,
+        create(d) {
+            const quest = notifyAfter(createQuestJournal({
+                events: d.events,
+                rewards: {
+                    grantXp(userId, amount) {
+                        const existing = d.ensureInstanceStats(userId)["xp"];
+                        const current = (existing?.current ?? 0) + amount;
+                        d.seedUserPool(userId, "xp", { current, max: Math.max(existing?.max ?? 0, current) });
+                    },
+                    grantEconomy: (userId, currencyId, amount) => d.economy.grant(userId, currencyId, amount),
+                    grantItem(userId, inventoryId, itemId, count) {
+                        if (d.layouts[inventoryId] === undefined)
+                            return { reason: `unknown inventory "${inventoryId}"` };
+                        const result = d.inventoryFor(userId).put(inventoryId, itemId, count);
+                        return result.status === "ok" ? null : { reason: result.reason };
+                    },
+                    grantUnlock: (userId, unlockId) => d.feature("unlocks")?.grant(userId, unlockId),
+                },
+                hasUnlock: (userId, id) => d.feature("unlocks")?.has(userId, id) ?? false,
+            }), ["accept", "abandon", "progress", "turnIn", "grant", "revoke", "hydrate"], d.signalNotify);
+            return {
+                value: quest,
+                save: {
+                    key: "quest",
+                    snapshot: () => quest.snapshotAll(),
+                    hydrate: (data) => quest.hydrateAll(data),
+                },
+            };
+        },
+    },
+    {
+        key: "dialogue",
+        enabled: (f) => f.dialogue === true,
+        create(d) {
+            const dialogue = createGameDialogue(d.store);
+            d.commandRegistry.define("dialogue.open", {
+                apply(state, input) {
+                    const id = input.id;
+                    if (id !== undefined)
+                        state.game.dialogue?.open(id);
+                },
+            });
+            d.commandRegistry.define("dialogue.close", {
+                apply(state) {
+                    state.game.dialogue?.close();
+                },
+            });
+            return { value: dialogue };
+        },
+    },
+    {
+        key: "players",
+        enabled: (f) => f.players === true,
+        create(d) {
+            return { value: notifyAfter(createConnectedPlayers(), ["join", "leave"], d.signalNotify) };
+        },
+    },
+    {
+        key: "cards",
+        enabled: (f) => f.cards === true,
+        create(d) {
+            return {
+                value: { pile: d.pile },
+                save: {
+                    key: "cards",
+                    snapshot: () => {
+                        const out = {};
+                        for (const [id, cardPile] of d.cardPiles)
+                            out[id] = cardPile.state();
+                        return out;
+                    },
+                    hydrate: (data) => {
+                        for (const [id, state] of Object.entries(data)) {
+                            d.cardPiles.get(id)?.reset(state);
+                        }
+                    },
+                },
+            };
+        },
+    },
+    {
+        key: "turn",
+        enabled: (f) => f.turn === true,
+        create(d) {
+            return {
+                value: { loop: d.loop },
+                save: {
+                    key: "turn",
+                    snapshot: () => {
+                        const out = {};
+                        for (const [id, turnLoop] of d.turnLoops)
+                            out[id] = turnLoop.capture();
+                        return out;
+                    },
+                    hydrate: (data) => {
+                        for (const [id, state] of Object.entries(data)) {
+                            d.turnLoops.get(id)?.restore(state);
+                        }
+                    },
+                },
+            };
+        },
+    },
+    {
+        key: "race",
+        enabled: (f) => f.race === true,
+        create(d) {
+            return { value: { state: d.raceState } };
+        },
+    },
+];