@jgengine/core 0.6.0 → 0.7.0

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/economy/sharedWallet.d.ts

@@ -0,0 +1,28 @@
+import { type WalletState } from "./wallet.js";
+export type WalletScope = {
+    kind: "user";
+    userId: string;
+} | {
+    kind: "group";
+    groupId: string;
+};
+export declare function scopeKey(scope: WalletScope): string;
+export declare function userScope(userId: string): WalletScope;
+export declare function groupScope(groupId: string): WalletScope;
+export interface WalletBook {
+    scopes: Readonly<Record<string, WalletState>>;
+    contributions: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, number>>>>>>;
+}
+export type BookChargeResult = {
+    status: "ok";
+    book: WalletBook;
+} | {
+    status: "rejected";
+    reason: "insufficient-funds";
+};
+export declare function createWalletBook(): WalletBook;
+export declare function balanceIn(book: WalletBook, scope: WalletScope, currency: string): number;
+export declare function grantTo(book: WalletBook, scope: WalletScope, currency: string, amount: number, by?: string): WalletBook;
+export declare function chargeFrom(book: WalletBook, scope: WalletScope, currency: string, amount: number, by?: string): BookChargeResult;
+export declare function contributionOf(book: WalletBook, groupId: string, userId: string): Readonly<Record<string, number>>;
+export declare function contributorsOf(book: WalletBook, groupId: string): string[];

package/dist/economy/sharedWallet.js

@@ -0,0 +1,62 @@
+import { balance, charge, createEmptyWallet, grant } from "./wallet.js";
+export function scopeKey(scope) {
+    return scope.kind === "user" ? `user:${scope.userId}` : `group:${scope.groupId}`;
+}
+export function userScope(userId) {
+    return { kind: "user", userId };
+}
+export function groupScope(groupId) {
+    return { kind: "group", groupId };
+}
+export function createWalletBook() {
+    return { scopes: {}, contributions: {} };
+}
+function scopeState(book, key) {
+    return book.scopes[key] ?? createEmptyWallet();
+}
+export function balanceIn(book, scope, currency) {
+    return balance(scopeState(book, scopeKey(scope)), currency);
+}
+function withScope(book, key, state) {
+    return { ...book, scopes: { ...book.scopes, [key]: state } };
+}
+function recordContribution(book, groupKey, userId, currency, delta) {
+    const group = book.contributions[groupKey] ?? {};
+    const perUser = group[userId] ?? {};
+    const next = (perUser[currency] ?? 0) + delta;
+    return {
+        ...book,
+        contributions: {
+            ...book.contributions,
+            [groupKey]: {
+                ...group,
+                [userId]: { ...perUser, [currency]: next },
+            },
+        },
+    };
+}
+export function grantTo(book, scope, currency, amount, by) {
+    const key = scopeKey(scope);
+    let next = withScope(book, key, grant(scopeState(book, key), currency, amount));
+    if (scope.kind === "group" && by !== undefined) {
+        next = recordContribution(next, key, by, currency, amount);
+    }
+    return next;
+}
+export function chargeFrom(book, scope, currency, amount, by) {
+    const key = scopeKey(scope);
+    const result = charge(scopeState(book, key), currency, amount);
+    if (result.status === "rejected")
+        return result;
+    let next = withScope(book, key, result.state);
+    if (scope.kind === "group" && by !== undefined) {
+        next = recordContribution(next, key, by, currency, -amount);
+    }
+    return { status: "ok", book: next };
+}
+export function contributionOf(book, groupId, userId) {
+    return book.contributions[scopeKey(groupScope(groupId))]?.[userId] ?? {};
+}
+export function contributorsOf(book, groupId) {
+    return Object.keys(book.contributions[scopeKey(groupScope(groupId))] ?? {});
+}

package/dist/economy/techTree.d.ts

@@ -0,0 +1,40 @@
+import type { UnlockDef, UnlockState } from "../game/unlocks.js";
+export interface TechNodeDef extends UnlockDef {
+    requires?: readonly string[];
+    cost?: Readonly<Record<string, number>>;
+    grants?: readonly string[];
+    recipe?: string;
+}
+export type TechState = UnlockState;
+export type TechRejection = {
+    reason: "unknown-node";
+} | {
+    reason: "already-unlocked";
+} | {
+    reason: "missing-prerequisites";
+    missing: readonly string[];
+};
+export type TechCheck = {
+    ok: true;
+} | ({
+    ok: false;
+} & TechRejection);
+export declare function techPrerequisitesMet(state: TechState, node: TechNodeDef): boolean;
+export declare function missingPrerequisites(state: TechState, node: TechNodeDef): string[];
+export declare function canUnlockTech(defs: readonly TechNodeDef[], state: TechState, id: string): TechCheck;
+export declare function grantTech(state: TechState, node: TechNodeDef): string[];
+export declare function availableTech(defs: readonly TechNodeDef[], state: TechState): TechNodeDef[];
+export declare function unlockedRecipes(defs: readonly TechNodeDef[], state: TechState): string[];
+export interface TechTree {
+    has(userId: string, id: string): boolean;
+    canUnlock(userId: string, id: string): TechCheck;
+    unlock(userId: string, id: string): TechCheck;
+    available(userId: string): TechNodeDef[];
+    recipes(userId: string): string[];
+    list(userId: string): string[];
+    tree(categoryId: string): UnlockDef[];
+    node(id: string): TechNodeDef | null;
+    snapshot(userId: string): string[];
+    hydrate(userId: string, ids: string[]): void;
+}
+export declare function createTechTree(defs?: readonly TechNodeDef[]): TechTree;

package/dist/economy/techTree.js

@@ -0,0 +1,66 @@
+import { createUnlocks, grantUnlock, hasUnlock, unlockTree } from "../game/unlocks.js";
+export function techPrerequisitesMet(state, node) {
+    const requires = node.requires ?? [];
+    return requires.every((id) => hasUnlock(state, id));
+}
+export function missingPrerequisites(state, node) {
+    return (node.requires ?? []).filter((id) => !hasUnlock(state, id));
+}
+export function canUnlockTech(defs, state, id) {
+    const node = defs.find((n) => n.id === id);
+    if (node === undefined)
+        return { ok: false, reason: "unknown-node" };
+    if (hasUnlock(state, id))
+        return { ok: false, reason: "already-unlocked" };
+    const missing = missingPrerequisites(state, node);
+    if (missing.length > 0)
+        return { ok: false, reason: "missing-prerequisites", missing };
+    return { ok: true };
+}
+export function grantTech(state, node) {
+    let next = grantUnlock(state, node.id);
+    for (const extra of node.grants ?? [])
+        next = grantUnlock(next, extra);
+    return next;
+}
+export function availableTech(defs, state) {
+    return defs.filter((node) => !hasUnlock(state, node.id) && techPrerequisitesMet(state, node));
+}
+export function unlockedRecipes(defs, state) {
+    const recipes = [];
+    for (const node of defs) {
+        if (node.recipe !== undefined && hasUnlock(state, node.id))
+            recipes.push(node.recipe);
+    }
+    return recipes;
+}
+export function createTechTree(defs = []) {
+    const nodes = new Map();
+    for (const def of defs)
+        nodes.set(def.id, def);
+    const unlocks = createUnlocks(defs.map((d) => ({ id: d.id, category: d.category })));
+    function stateOf(userId) {
+        return unlocks.list(userId);
+    }
+    return {
+        has: (userId, id) => unlocks.has(userId, id),
+        canUnlock: (userId, id) => canUnlockTech(defs, stateOf(userId), id),
+        unlock(userId, id) {
+            const check = canUnlockTech(defs, stateOf(userId), id);
+            if (!check.ok)
+                return check;
+            const node = nodes.get(id);
+            unlocks.grant(userId, node.id);
+            for (const extra of node.grants ?? [])
+                unlocks.grant(userId, extra);
+            return { ok: true };
+        },
+        available: (userId) => availableTech(defs, stateOf(userId)),
+        recipes: (userId) => unlockedRecipes(defs, stateOf(userId)),
+        list: (userId) => unlocks.list(userId),
+        tree: (categoryId) => unlockTree(defs, categoryId),
+        node: (id) => nodes.get(id) ?? null,
+        snapshot: (userId) => unlocks.snapshot(userId),
+        hydrate: (userId, ids) => unlocks.hydrate(userId, ids),
+    };
+}

package/dist/game/cosmetics.d.ts

@@ -0,0 +1,25 @@
+export interface CosmeticLoadoutDef {
+    slots: Record<string, string>;
+}
+export interface CosmeticsChangedEvent {
+    userId: string;
+    slots: Record<string, string>;
+}
+export interface CosmeticsEvents {
+    emit(name: "cosmetics.changed", payload: CosmeticsChangedEvent): void;
+}
+export interface CosmeticsDeps {
+    events?: CosmeticsEvents;
+}
+export interface Cosmetics {
+    register(defs: Record<string, CosmeticLoadoutDef>): void;
+    has(loadoutId: string): boolean;
+    apply(userId: string, loadoutId: string): {
+        reason: string;
+    } | null;
+    equip(userId: string, slot: string, cosmeticId: string | null): void;
+    get(userId: string): Readonly<Record<string, string>>;
+    snapshot(userId: string): Record<string, string>;
+    hydrate(userId: string, state: Record<string, string>): void;
+}
+export declare function createCosmetics(deps?: CosmeticsDeps): Cosmetics;

package/dist/game/cosmetics.js

@@ -0,0 +1,51 @@
+const EMPTY_SLOTS = Object.freeze({});
+export function createCosmetics(deps = {}) {
+    const definitions = new Map();
+    const equipped = new Map();
+    function slotsOf(userId) {
+        let slots = equipped.get(userId);
+        if (slots === undefined) {
+            slots = {};
+            equipped.set(userId, slots);
+        }
+        return slots;
+    }
+    function notify(userId) {
+        deps.events?.emit("cosmetics.changed", { userId, slots: { ...slotsOf(userId) } });
+    }
+    return {
+        register(defs) {
+            for (const [loadoutId, def] of Object.entries(defs))
+                definitions.set(loadoutId, def);
+        },
+        has(loadoutId) {
+            return definitions.has(loadoutId);
+        },
+        apply(userId, loadoutId) {
+            const def = definitions.get(loadoutId);
+            if (def === undefined)
+                return { reason: `unknown cosmetic loadout "${loadoutId}"` };
+            const slots = slotsOf(userId);
+            Object.assign(slots, def.slots);
+            notify(userId);
+            return null;
+        },
+        equip(userId, slot, cosmeticId) {
+            const slots = slotsOf(userId);
+            if (cosmeticId === null)
+                delete slots[slot];
+            else
+                slots[slot] = cosmeticId;
+            notify(userId);
+        },
+        get(userId) {
+            return equipped.get(userId) ?? EMPTY_SLOTS;
+        },
+        snapshot(userId) {
+            return { ...slotsOf(userId) };
+        },
+        hydrate(userId, state) {
+            equipped.set(userId, { ...state });
+        },
+    };
+}

package/dist/game/defineGame.d.ts

@@ -1,5 +1,6 @@
 import type { ActionCodesMap } from "../input/actionBindings.js";
 import type { ItemTraits } from "../inventory/inventoryModel.js";
+import type { StorageTier } from "../inventory/storageTier.js";
 import type { SaveConfig } from "../runtime/save.js";
 import type { AssetCatalog, ModelAssetRef } from "../scene/assetCatalog.js";
 import { type EntityStore } from "../scene/entityStore.js";
@@ -14,6 +15,7 @@ export interface InventoryDeclaration {
     accepts?: string | readonly string[];
     traits?: ItemTraits;
     applyModifiers?: boolean;
+    tier?: StorageTier;
 }
 export type GameServerConfig = "persistent" | {
     mode: string;

package/dist/game/events.d.ts

@@ -1,3 +1,5 @@
+import type { TelegraphShape } from "../combat/telegraph.js";
+import type { CameraShake } from "../combat/hitReaction.js";
 export type DeathReason = {
     kind: "player_kill";
     killerUserId: string;
@@ -72,6 +74,24 @@ export interface EntityFloatTextEvent {
     text: string;
     kind: string;
     amount?: number;
+    hitType?: string;
+    element?: string;
+    crit?: boolean;
+    scale?: number;
+}
+export interface CombatTelegraphEvent {
+    id: number;
+    shape: TelegraphShape;
+    position: [number, number, number];
+    dir?: number;
+    windupMs: number;
+    kind: string;
+}
+export interface CombatHitReactionEvent {
+    instanceId?: string;
+    position: [number, number, number];
+    hitstopMs: number;
+    shake?: CameraShake;
 }
 export interface ProjectileSettledEvent {
     from: string;
@@ -80,9 +100,45 @@ export interface ProjectileSettledEvent {
     effect: string;
     hit: boolean;
 }
+export interface WorldItemDroppedEvent {
+    instanceId: string;
+    itemId: string;
+    rarity: string;
+    count: number;
+    position: [number, number, number];
+    source?: string;
+}
+export interface WorldItemPickedUpEvent {
+    instanceId: string;
+    userId: string;
+    itemId: string;
+    rarity: string;
+    count: number;
+}
+export interface CosmeticsChangedEvent {
+    userId: string;
+    slots: Record<string, string>;
+}
+export interface EmotePlayedEvent {
+    from: string;
+    emoteId: string;
+    at: readonly [number, number, number];
+    recipients: readonly string[];
+}
+export interface PossessionSwappedEvent {
+    userId: string;
+    entityId: string;
+    previousEntityId: string;
+}
+export interface FormChangedEvent {
+    instanceId: string;
+    formId: string | null;
+}
 export interface GameEventMap {
     "entity.died": EntityDiedEvent;
     "entity.floatText": EntityFloatTextEvent;
+    "combat.telegraph": CombatTelegraphEvent;
+    "combat.hitReaction": CombatHitReactionEvent;
     "loot.granted": LootGrantedEvent;
     "inventory.added": InventoryAddedEvent;
     "quest.accepted": QuestAcceptedEvent;
@@ -93,6 +149,12 @@ export interface GameEventMap {
     "social.party.left": SocialPartyLeftEvent;
     "stat.levelUp": StatLevelUpEvent;
     "projectile.settled": ProjectileSettledEvent;
+    "worldItem.dropped": WorldItemDroppedEvent;
+    "worldItem.picked_up": WorldItemPickedUpEvent;
+    "cosmetics.changed": CosmeticsChangedEvent;
+    "emote.played": EmotePlayedEvent;
+    "possession.swapped": PossessionSwappedEvent;
+    "form.changed": FormChangedEvent;
 }
 export type GameEventHandler<TPayload> = (payload: TPayload) => void;
 export interface GameEvents<TMap extends GameEventMap = GameEventMap> {