@jgengine/core 0.8.0 → 0.10.0

package/dist/runtime/gameContext.js

@@ -24,26 +24,34 @@ import { createItemUse, } from "../item/use.js";
 import { createWeaponStats } from "../item/weapon.js";
 import { createPoseState } from "../movement/poseState.js";
 import { createPaintLayer } from "../scene/paintLayer.js";
-import { createEntityStatsApi, seedStatValues, setStatValue, } from "../scene/entityStats.js";
+import { createEntityStatsApi, hydrateEntityStats, seedStatValues, setStatValue, snapshotEntityStats, } from "../scene/entityStats.js";
 import { createForms } from "../scene/form.js";
+import { scaledObjectColliders } from "../scene/colliders.js";
 import { raycastObjects, raycastObjectsAll } from "../scene/objectQuery.js";
-import { createObjectStore } from "../scene/objectStore.js";
+import { createObjectStore, objectVisualScale } from "../scene/objectStore.js";
 import { createRoster } from "../scene/roster.js";
+import { createConnectedPlayers } from "../game/connectedPlayers.js";
 import { createPossession } from "../scene/possession.js";
+import { createSceneRaycast, } from "../scene/sceneRaycast.js";
 import { createSpatialApi } from "../scene/spatial.js";
 import { createTargeting } from "../scene/targeting.js";
 import { createStats } from "../stats/statModifiers.js";
 import { createChangeSignal, notifyAfter } from "../store/changeSignal.js";
 import { createObservableKeyedStore } from "../store/observableKeyedStore.js";
+import { applyWorldSnapshot, composeWorldSnapshot, } from "./worldSnapshot.js";
 import { createSimClock } from "../time/simClock.js";
 import { createTurnLoop } from "../turn/turnLoop.js";
+import { RaceState } from "../game/race.js";
 import { createCameraDirector } from "./cameraDirector.js";
 import { createInputSnapshot } from "./inputSnapshot.js";
 import { createMotionIntents } from "./motionIntents.js";
 export function createGameContext(options) {
     const { definition, content, player } = options;
     const now = options.now ?? Date.now;
+    const occluder = options.occluder;
     const signal = createChangeSignal();
+    let actingUserId = null;
+    const activeUserId = () => actingUserId ?? player.userId;
     const time = createSimClock({ config: definition.time, onChange: signal.notify });
     const ground = groundFieldFor(definition.world);
     const entities = definition.scene;
@@ -68,12 +76,54 @@ export function createGameContext(options) {
         const object = objects.get(instanceId);
         return object === null ? undefined : content.objectById?.(object.catalogId);
     }
+    let spatialGeneration = 0;
+    const candidateIds = [];
+    let candidateIdsDirty = true;
+    function refreshCandidateIds() {
+        if (!candidateIdsDirty)
+            return candidateIds;
+        candidateIds.length = 0;
+        for (const entity of entities.list())
+            candidateIds.push(entity.id);
+        candidateIdsDirty = false;
+        return candidateIds;
+    }
     const spatial = createSpatialApi({
         resolvePosition: (instanceId) => entities.get(instanceId)?.position,
-        candidates: () => entities.list().map((entity) => entity.id),
+        candidates: refreshCandidateIds,
+        grid: { cellSize: 8 },
+        getVersion: () => spatialGeneration,
+        ...(occluder !== undefined ? { occluder } : {}),
+    });
+    entities.subscribe(() => {
+        candidateIdsDirty = true;
+        spatialGeneration += 1;
+        spatial.invalidate();
     });
+    const entityColliders = new Map();
+    const objectColliders = new Map();
+    function entityCollidersOf(instanceId) {
+        const override = entityColliders.get(instanceId);
+        if (override !== undefined)
+            return override;
+        return catalogEntry(instanceId)?.colliders ?? null;
+    }
+    function objectCollidersOf(instanceId) {
+        const override = objectColliders.get(instanceId);
+        if (override !== undefined)
+            return override;
+        const catalog = catalogObject(instanceId);
+        if (catalog?.colliders !== undefined)
+            return catalog.colliders;
+        if (catalog?.halfExtents !== undefined)
+            return null;
+        const object = objects.get(instanceId);
+        if (object === null || object.visual?.scale === undefined)
+            return null;
+        return scaledObjectColliders(objectVisualScale(object.visual));
+    }
     const targeting = notifyAfter(createTargeting({
-        candidates: () => entities.list().map((entity) => entity.id),
+        candidates: () => [...refreshCandidateIds()],
         classify(_fromId, toId) {
             const role = catalogEntry(toId)?.role;
             return role === "enemy" || role === "hostile" ? "hostile" : "friendly";
@@ -82,9 +132,43 @@ export function createGameContext(options) {
     }), ["setTarget", "cycleTarget"], signal.notify);
     const combatSpatial = {
         inRadius: (center, radius) => spatial.inRadius(center, radius),
-        hasLineOfSight: (from, to) => typeof from === "string" ? spatial.hasLineOfSight(from, to) : entities.get(to) !== null,
+        hasLineOfSight: (from, to) => {
+            if (typeof from === "string")
+                return spatial.hasLineOfSight(from, to);
+            const toPos = entities.get(to)?.position;
+            if (toPos === undefined)
+                return false;
+            if (occluder === undefined)
+                return true;
+            return !occluder(from, toPos);
+        },
         positionOf: (instanceId) => entities.get(instanceId)?.position,
     };
+    const sceneRaycast = createSceneRaycast({
+        entities: {
+            list: () => entities.list().map((entity) => ({
+                id: entity.id,
+                position: entity.position,
+                rotationY: entity.rotationY,
+                name: entity.name,
+            })),
+            collidersOf: entityCollidersOf,
+            inRadius: (center, radius) => spatial.inRadius(center, radius),
+            get: (id) => {
+                const entity = entities.get(id);
+                if (entity === null)
+                    return null;
+                return { id: entity.id, position: entity.position, rotationY: entity.rotationY, name: entity.name };
+            },
+        },
+        objects: {
+            list: () => objects.list(),
+            inBox: (min, max) => objects.inBox(min, max),
+            collidersOf: objectCollidersOf,
+            halfExtentsOf: (catalogId) => content.objectById?.(catalogId)?.halfExtents ?? null,
+        },
+        terrain: ground,
+    });
     const weapon = createWeaponStats((itemId) => content.itemById?.(itemId));
     const rawEvents = createGameEvents();
     const events = {
@@ -98,34 +182,55 @@ export function createGameContext(options) {
     const feed = createGameFeed(definition.feed);
     const lootRegistry = createLootRegistry();
     const unlocks = notifyAfter(createUnlocks(), ["grant", "hydrate"], signal.notify);
-    const rawSocial = createSocial({
-        events,
-        now,
-        emotes: {
-            entities: { get: (id) => entities.get(id) },
-            spatial: { inRadius: (center, radius, filter) => spatial.inRadius(center, radius, filter) },
-        },
-    });
-    const social = {
-        friends: notifyAfter(rawSocial.friends, ["request", "accept", "decline", "remove", "block", "hydrate"], signal.notify),
-        party: notifyAfter(rawSocial.party, ["invite", "accept", "decline", "kick", "leave", "promote"], signal.notify),
-        presence: rawSocial.presence,
-        emotes: rawSocial.emotes,
-        worldInvites: notifyAfter(rawSocial.worldInvites, ["invite", "accept", "decline"], signal.notify),
-    };
-    const chat = notifyAfter(createChat({
-        events,
-        now,
-        party: rawSocial.party,
-        proximity: {
-            entities: { get: (id) => entities.get(id) },
-            spatial: { inRadius: (center, radius, filter) => spatial.inRadius(center, radius, filter) },
-        },
-        blockedBy: (userId) => rawSocial.friends.snapshot(userId).blocked,
-    }), ["register", "send", "whisper", "hydrate"], signal.notify);
-    const leaderboard = notifyAfter(createLeaderboard(), ["increment", "hydrate"], signal.notify);
-    const roster = notifyAfter(createRoster({ now }), ["capture", "release", "setEquipped", "hydrate"], signal.notify);
-    const playerStats = createStats({});
+    const features = definition.features ?? {};
+    const rawSocial = features.social || features.chat
+        ? createSocial({
+            events,
+            now,
+            emotes: {
+                entities: { get: (id) => entities.get(id) },
+                spatial: { inRadius: (center, radius, filter) => spatial.inRadius(center, radius, filter) },
+            },
+        })
+        : null;
+    let social;
+    if (features.social && rawSocial !== null) {
+        social = {
+            friends: notifyAfter(rawSocial.friends, ["request", "accept", "decline", "remove", "block", "hydrate"], signal.notify),
+            party: notifyAfter(rawSocial.party, ["invite", "accept", "decline", "kick", "leave", "promote"], signal.notify),
+            presence: rawSocial.presence,
+            emotes: rawSocial.emotes,
+            worldInvites: notifyAfter(rawSocial.worldInvites, ["invite", "accept", "decline"], signal.notify),
+        };
+    }
+    let chat;
+    if (features.chat && rawSocial !== null) {
+        chat = notifyAfter(createChat({
+            events,
+            now,
+            party: rawSocial.party,
+            proximity: {
+                entities: { get: (id) => entities.get(id) },
+                spatial: { inRadius: (center, radius, filter) => spatial.inRadius(center, radius, filter) },
+            },
+            blockedBy: (userId) => rawSocial.friends.snapshot(userId).blocked,
+        }), ["register", "send", "whisper", "hydrate"], signal.notify);
+    }
+    const leaderboard = features.leaderboard
+        ? notifyAfter(createLeaderboard(), ["increment", "hydrate"], signal.notify)
+        : undefined;
+    const roster = features.roster
+        ? notifyAfter(createRoster({ now }), ["capture", "release", "setEquipped", "hydrate"], signal.notify)
+        : undefined;
+    const playerStatsByUser = new Map();
+    function playerStatsFor(userId) {
+        let stats = playerStatsByUser.get(userId);
+        if (stats === undefined) {
+            stats = createStats({});
+            playerStatsByUser.set(userId, stats);
+        }
+        return stats;
+    }
     const pose = createPoseState((instanceId) => catalogEntry(instanceId)?.movement);
     const commandRegistry = createCommandRegistry();
     const itemUse = createItemUse((itemId) => content.itemById?.(itemId)?.use);
@@ -140,7 +245,15 @@ export function createGameContext(options) {
         layouts[inventoryId] = { slots: declaration.slots, accepts: declaration.accepts };
     }
     const traits = Object.values(inventoryDeclarations).find((declaration) => declaration.traits !== undefined)?.traits ?? { stackLimit: () => Number.POSITIVE_INFINITY };
-    const inventory = notifyAfter(createInventorySet(layouts, traits), ["put", "take", "move", "replaceState"], signal.notify);
+    const inventoryByUser = new Map();
+    function inventoryFor(userId) {
+        let set = inventoryByUser.get(userId);
+        if (set === undefined) {
+            set = notifyAfter(createInventorySet(layouts, traits), ["put", "take", "move", "replaceState"], signal.notify);
+            inventoryByUser.set(userId, set);
+        }
+        return set;
+    }
     const wallets = new Map();
     const walletOf = (userId) => wallets.get(userId) ?? createEmptyWallet();
     const economy = {
@@ -158,7 +271,8 @@ export function createGameContext(options) {
             return null;
         },
     };
-    function putIntoAnyInventory(itemId, count) {
+    function putIntoAnyInventory(userId, itemId, count) {
+        const inventory = inventoryFor(userId);
         for (const inventoryId of inventoryIds) {
             if (inventory.put(inventoryId, itemId, count).status === "ok")
                 return;
@@ -170,7 +284,7 @@ export function createGameContext(options) {
         roll: lootRegistry.roll,
         grantToPlayer(userId, drops, source) {
             grantDrops(drops, {
-                putItem: (itemId, count) => putIntoAnyInventory(itemId, count),
+                putItem: (itemId, count) => putIntoAnyInventory(userId, itemId, count),
                 grantCurrency: (currencyId, amount) => economy.grant(userId, currencyId, amount),
             });
             const event = { userId, drops };
@@ -182,17 +296,17 @@ export function createGameContext(options) {
     const trade = createTradeSystem({
         resolveTrade: (itemId) => content.itemById?.(itemId)?.trade,
         wallet: {
-            canAfford: (costs) => (walletCanAfford(walletOf(player.userId), costs) ? null : "insufficient-funds"),
+            canAfford: (costs) => (walletCanAfford(walletOf(activeUserId()), costs) ? null : "insufficient-funds"),
             charge(costs) {
-                const result = walletChargeAll(walletOf(player.userId), costs);
+                const result = walletChargeAll(walletOf(activeUserId()), costs);
                 if (result.status === "ok") {
-                    wallets.set(player.userId, result.state);
+                    wallets.set(activeUserId(), result.state);
                     signal.notify();
                 }
             },
             grant(gains) {
                 for (const [currencyId, amount] of Object.entries(gains)) {
-                    economy.grant(player.userId, currencyId, amount);
+                    economy.grant(activeUserId(), currencyId, amount);
                 }
             },
         },
@@ -200,16 +314,16 @@ export function createGameContext(options) {
             put(inventoryId, itemId, count) {
                 if (layouts[inventoryId] === undefined)
                     return { reason: `unknown inventory "${inventoryId}"` };
-                const result = inventory.put(inventoryId, itemId, count);
+                const result = inventoryFor(activeUserId()).put(inventoryId, itemId, count);
                 return result.status === "ok" ? null : { reason: result.reason };
             },
             take(inventoryId, itemId, count) {
                 if (layouts[inventoryId] === undefined)
                     return { reason: `unknown inventory "${inventoryId}"` };
-                const result = inventory.take(inventoryId, itemId, count);
+                const result = inventoryFor(activeUserId()).take(inventoryId, itemId, count);
                 return result.status === "ok" ? null : { reason: result.reason };
             },
-            count: (inventoryId, itemId) => inventory.count(inventoryId, itemId),
+            count: (inventoryId, itemId) => inventoryFor(activeUserId()).count(inventoryId, itemId),
         },
     });
     function seedUserPool(userId, statId, pool) {
@@ -227,11 +341,9 @@ export function createGameContext(options) {
             },
             grantEconomy: (userId, currencyId, amount) => economy.grant(userId, currencyId, amount),
             grantItem(userId, inventoryId, itemId, count) {
-                if (userId !== player.userId)
-                    return { reason: `unknown user "${userId}"` };
                 if (layouts[inventoryId] === undefined)
                     return { reason: `unknown inventory "${inventoryId}"` };
-                const result = inventory.put(inventoryId, itemId, count);
+                const result = inventoryFor(userId).put(inventoryId, itemId, count);
                 return result.status === "ok" ? null : { reason: result.reason };
             },
             grantUnlock: (userId, unlockId) => unlocks.grant(userId, unlockId),
@@ -241,7 +353,8 @@ export function createGameContext(options) {
     const quest = notifyAfter(rawQuest, ["accept", "abandon", "progress", "turnIn", "grant", "revoke", "hydrate"], signal.notify);
     const loadouts = notifyAfter(createLoadouts({
         inventory: {
-            begin() {
+            begin(userId) {
+                const inventory = inventoryFor(userId);
                 const staged = new Map();
                 return {
                     put(inventoryId, itemId, count, slot) {
@@ -282,6 +395,7 @@ export function createGameContext(options) {
         statsByInstance.delete(instanceId);
         targeting.clearAll(instanceId);
         pose.clear(instanceId);
+        entityColliders.delete(instanceId);
         return existed;
     }
     function resetAllToSpawn(filter) {
@@ -422,13 +536,14 @@ export function createGameContext(options) {
         if (input.dir !== undefined)
             telegraphEvent.dir = input.dir;
         events.emit("combat.telegraph", telegraphEvent);
+        const cancelVisual = () => events.emit("combat.telegraphCancelled", { id });
         const bound = input.effect;
         if (bound === undefined)
-            return () => { };
+            return cancelVisual;
         const config = { shape: input.shape, at: input.at, windupMs: input.windupMs };
         if (input.dir !== undefined)
             config.dir = input.dir;
-        return time.after(input.windupMs / 1000, () => {
+        const cancelEffect = time.after(input.windupMs / 1000, () => {
             const targets = entities.list().filter((entity) => pointInTelegraph(config, entity.position));
             for (const target of targets) {
                 applyEffectAndFloat({
@@ -439,6 +554,10 @@ export function createGameContext(options) {
                 });
             }
         });
+        return () => {
+            cancelEffect();
+            cancelVisual();
+        };
     }
     function applyHitReaction(input) {
         const attacker = entities.get(input.from);
@@ -499,10 +618,51 @@ export function createGameContext(options) {
         preview: effects.preview,
         applyEffect: applyEffectAndFloat,
     };
+    const projectileObstacles = definition.physics?.projectileObstacles === true;
+    const projectileSceneRaycast = {
+        raycast(input) {
+            return sceneRaycast.raycast({
+                ...input,
+                filter: {
+                    entities: true,
+                    objects: projectileObstacles,
+                    terrain: false,
+                    walls: projectileObstacles,
+                    ...input.filter,
+                },
+            });
+        },
+        raycastAll(input) {
+            return sceneRaycast.raycastAll({
+                ...input,
+                filter: {
+                    entities: true,
+                    objects: projectileObstacles,
+                    terrain: false,
+                    walls: projectileObstacles,
+                    ...input.filter,
+                },
+            });
+        },
+    };
     const projectiles = notifyAfter(createProjectileSystem({
         effects: floatingEffects,
         spatial: combatSpatial,
         getStat: weapon.getStat,
+        sceneRaycast: projectileSceneRaycast,
+        objects: projectileObstacles
+            ? {
+                list: () => objects.list(),
+                inBox: (min, max) => objects.inBox(min, max),
+                halfExtents: (catalogId) => {
+                    const half = content.objectById?.(catalogId)?.halfExtents;
+                    return half === undefined ? null : [half[0], half[1], half[2]];
+                },
+                collidersOf: objectCollidersOf,
+            }
+            : undefined,
+        entityCollidersOf,
+        rotationYOf: (instanceId) => entities.get(instanceId)?.rotationY,
         now,
         onSettle(report) {
             events.emit("projectile.settled", {
@@ -517,10 +677,21 @@ export function createGameContext(options) {
     const sceneObjects = {
         ...objects,
         catalog: (instanceId) => catalogObject(instanceId) ?? null,
-        raycast: (input) => raycastObjects(objects.list(), input),
-        raycastAll: (input) => raycastObjectsAll(objects.list(), input),
+        raycast: (input) => raycastObjects(objects, input),
+        raycastAll: (input) => raycastObjectsAll(objects, input),
+        setColliders(instanceId, colliders) {
+            if (colliders === null)
+                objectColliders.delete(instanceId);
+            else
+                objectColliders.set(instanceId, colliders);
+            signal.notify();
+        },
+        collidersOf: objectCollidersOf,
     };
-    const store = notifyAfter(createObservableKeyedStore(), ["set", "delete"], signal.notify);
+    const store = notifyAfter(createObservableKeyedStore(), ["set", "delete", "hydrate"], signal.notify);
+    const players = features.players
+        ? notifyAfter(createConnectedPlayers(), ["join", "leave"], signal.notify)
+        : undefined;
     const cardPiles = new Map();
     function pile(id, config) {
         const existing = cardPiles.get(id);
@@ -542,7 +713,7 @@ export function createGameContext(options) {
             throw new Error(`turn loop "${id}" has not been created yet; pass a config on first access`);
         }
         const raw = createTurnLoop(config);
-        const wrappedCommit = notifyAfter(raw.commit, ["submit", "expected", "commit", "rewind", "clear"], signal.notify);
+        const wrappedCommit = notifyAfter(raw.commit, ["submit", "expected", "commit", "discard", "clear"], signal.notify);
         const wrapped = {
             ...notifyAfter(raw, [
                 "setOrder",
@@ -561,9 +732,101 @@ export function createGameContext(options) {
         turnLoops.set(id, wrapped);
         return wrapped;
     }
-    const camera = notifyAfter(createCameraDirector(), ["follow", "setCinematic"], signal.notify);
+    class NotifyingRaceState extends RaceState {
+        addRacer(racerId, startTime) {
+            super.addRacer(racerId, startTime);
+            signal.notify();
+        }
+        removeRacer(racerId) {
+            super.removeRacer(racerId);
+            signal.notify();
+        }
+        reset() {
+            super.reset();
+            signal.notify();
+        }
+        eliminate(racerId) {
+            super.eliminate(racerId);
+            signal.notify();
+        }
+        update(now, positions) {
+            const raceEvents = super.update(now, positions);
+            if (raceEvents.length > 0)
+                signal.notify();
+            return raceEvents;
+        }
+    }
+    const raceStates = new Map();
+    function raceState(id, config) {
+        const existing = raceStates.get(id);
+        if (existing !== undefined)
+            return existing;
+        if (config === undefined) {
+            throw new Error(`race "${id}" has not been created yet; pass a config on first access`);
+        }
+        const created = new NotifyingRaceState(config);
+        raceStates.set(id, created);
+        return created;
+    }
+    const camera = notifyAfter(createCameraDirector(), ["follow", "setCinematic", "setChaseTuning"], signal.notify);
     const input = createInputSnapshot();
-    const motion = createMotionIntents();
+    const motionByUser = new Map();
+    function motionFor(userId) {
+        let queue = motionByUser.get(userId);
+        if (queue === undefined) {
+            queue = createMotionIntents();
+            motionByUser.set(userId, queue);
+        }
+        return queue;
+    }
+    const snapshotModules = [
+        { key: "entities", snapshot: () => entities.snapshot(), hydrate: (data) => entities.hydrate(data) },
+        {
+            key: "stats",
+            snapshot: () => snapshotEntityStats(statsByInstance),
+            hydrate: (data) => hydrateEntityStats(statsByInstance, data),
+        },
+        {
+            key: "store",
+            snapshot: () => store.snapshot(),
+            hydrate: (data) => store.hydrate(data),
+        },
+        { key: "feed", snapshot: () => feed.snapshot(), hydrate: (data) => feed.hydrate(data) },
+        {
+            key: "inventory",
+            snapshot: () => {
+                const byUser = {};
+                for (const [userId, set] of inventoryByUser) {
+                    const states = {};
+                    for (const inventoryId of inventoryIds)
+                        states[inventoryId] = set.state(inventoryId);
+                    byUser[userId] = states;
+                }
+                return byUser;
+            },
+            hydrate: (data) => {
+                for (const [userId, states] of Object.entries(data)) {
+                    const set = inventoryFor(userId);
+                    for (const [inventoryId, state] of Object.entries(states))
+                        set.replaceState(inventoryId, state);
+                }
+            },
+        },
+    ];
+    if (leaderboard) {
+        snapshotModules.push({
+            key: "leaderboard",
+            snapshot: () => leaderboard.snapshot(),
+            hydrate: (data) => leaderboard.hydrate(data),
+        });
+    }
+    if (chat) {
+        snapshotModules.push({
+            key: "chat",
+            snapshot: () => chat.snapshot(),
+            hydrate: (data) => chat.hydrate(data),
+        });
+    }
     const ctx = {
         scene: {
             object: sceneObjects,
@@ -572,11 +835,13 @@ export function createGameContext(options) {
                 despawn: despawnEntity,
                 update: entities.update,
                 setPose: entities.setPose,
+                setPoseConstraint: entities.setPoseConstraint,
                 get: entities.get,
                 list: entities.list,
                 spawnPoseOf: entities.spawnPoseOf,
                 resetToSpawn: entities.resetToSpawn,
                 resetAllToSpawn,
+                blackboard: entities.blackboard,
                 stats: entityStats,
                 floatText: emitFloatText,
                 telegraph: fireTelegraph,
@@ -595,6 +860,15 @@ export function createGameContext(options) {
                 hasLineOfSight: spatial.hasLineOfSight,
                 queryArc: spatial.queryArc,
                 moveToward: spatial.moveToward,
+                invalidateSpatial: spatial.invalidate,
+                setColliders(instanceId, colliders) {
+                    if (colliders === null)
+                        entityColliders.delete(instanceId);
+                    else
+                        entityColliders.set(instanceId, colliders);
+                    signal.notify();
+                },
+                collidersOf: entityCollidersOf,
                 form: forms,
                 paint: paintLayer,
             },
@@ -606,6 +880,8 @@ export function createGameContext(options) {
                 pickup: pickupWorldItem,
                 consume: worldItems.remove,
             },
+            raycast: (input) => sceneRaycast.raycast(input),
+            raycastAll: (input) => sceneRaycast.raycastAll(input),
         },
         world: {
             ground,
@@ -621,8 +897,27 @@ export function createGameContext(options) {
                     signal.notify();
                     return result;
                 },
+                runAs(actorUserId, name, input) {
+                    const previous = actingUserId;
+                    actingUserId = actorUserId;
+                    try {
+                        const result = commandRegistry.run(ctx, name, input);
+                        signal.notify();
+                        return result;
+                    }
+                    finally {
+                        actingUserId = previous;
+                    }
+                },
+                actor: () => actingUserId,
             },
             events,
+            playEntityAnimation: (instanceId, event) => events.emit("entity.animation", { instanceId, event }),
+            audio: {
+                play: (sound, at) => events.emit("audio.play", at === undefined ? { sound } : { sound, at }),
+                music: (theme, transpose) => events.emit("audio.music", transpose === undefined ? { theme } : { theme, transpose }),
+                resume: () => events.emit("audio.resume", {}),
+            },
             feed: {
                 bind: (action) => feed.bind(action, events),
                 push(action, entry) {
@@ -647,20 +942,33 @@ export function createGameContext(options) {
             leaderboard,
             roster,
             store,
-            cards: { pile },
-            turn: { loop },
+            cards: features.cards ? { pile } : undefined,
+            turn: features.turn ? { loop } : undefined,
+            race: features.race ? { state: raceState } : undefined,
+            players,
         },
         player: {
-            userId: player.userId,
+            get userId() {
+                return activeUserId();
+            },
             isNew: player.isNew,
-            inventory,
-            stats: playerStats,
+            get inventory() {
+                return inventoryFor(activeUserId());
+            },
+            inventoryFor,
+            get stats() {
+                return playerStatsFor(activeUserId());
+            },
+            statsFor: playerStatsFor,
             loadout: loadouts,
             applyLoadout: loadouts.applyLoadout,
             movement: pose,
             possession,
             cosmetics,
-            motion,
+            get motion() {
+                return motionFor(activeUserId());
+            },
+            motionFor,
         },
         item: {
             use: {
@@ -680,6 +988,11 @@ export function createGameContext(options) {
         input,
         subscribe: signal.subscribe,
         version: signal.version,
+        snapshot: () => composeWorldSnapshot(snapshotModules),
+        hydrate(snapshot) {
+            applyWorldSnapshot(snapshotModules, snapshot);
+            signal.notify();
+        },
     };
     return ctx;
 }