@jgengine/core 0.6.0 → 0.8.0

package/dist/runtime/adapter.js

@@ -2,11 +2,47 @@ export function convex(config) {
     return { kind: "convex", topology: config?.topology ?? "shared" };
 }
 export function ws(config) {
-    return { kind: "ws", topology: config?.topology ?? "shared" };
+    return { kind: "ws", topology: config?.topology ?? "shared", url: config?.url };
+}
+export function fly(config) {
+    return {
+        kind: "ws",
+        topology: config.topology ?? "shared",
+        url: `wss://${config.app}.fly.dev${config.path ?? "/ws"}`,
+    };
+}
+export function socketIo(config) {
+    return { kind: "socketio", topology: config?.topology ?? "shared", url: config?.url };
+}
+export function p2p(config) {
+    return { kind: "p2p", topology: config?.topology ?? "private", room: config?.room };
+}
+export function lan(config) {
+    return { kind: "lan", topology: config?.topology ?? "shared", port: config?.port, path: config?.path };
 }
 export function offline() {
     return { kind: "offline" };
 }
+const ADAPTER_KINDS = new Set(["convex", "ws", "socketio", "p2p", "lan", "offline"]);
+function isAdapterConfig(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const kind = value.kind;
+    return typeof kind === "string" && ADAPTER_KINDS.has(kind);
+}
+export function adapterOf(multiplayer) {
+    if (isAdapterConfig(multiplayer))
+        return multiplayer;
+    if (typeof multiplayer === "object" && multiplayer !== null) {
+        const nested = multiplayer.adapter;
+        if (isAdapterConfig(nested))
+            return nested;
+    }
+    return null;
+}
+export function multiplayerAdapterKind(multiplayer) {
+    return adapterOf(multiplayer)?.kind ?? null;
+}
 export function servers(config) {
     return config;
 }

package/dist/runtime/cameraDirector.d.ts

@@ -0,0 +1,10 @@
+import type { CinematicCameraConfig } from "../game/playableGame.js";
+export interface CameraDirector {
+    follow(entityId: string | null): void;
+    /** `undefined` means no runtime override — the shell falls back to the static `playable.camera.followEntityId`. `null` means explicitly follow nothing. */
+    followedEntityId(): string | null | undefined;
+    setCinematic(config: CinematicCameraConfig | null): void;
+    cinematic(): CinematicCameraConfig | null;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createCameraDirector(): CameraDirector;

package/dist/runtime/cameraDirector.js

@@ -0,0 +1,25 @@
+export function createCameraDirector() {
+    const listeners = new Set();
+    let followEntity = undefined;
+    let cinematicConfig = null;
+    function notify() {
+        for (const listener of listeners)
+            listener();
+    }
+    return {
+        follow(entityId) {
+            followEntity = entityId;
+            notify();
+        },
+        followedEntityId: () => followEntity,
+        setCinematic(config) {
+            cinematicConfig = config;
+            notify();
+        },
+        cinematic: () => cinematicConfig,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}

package/dist/runtime/gameContext.d.ts

@@ -1,34 +1,56 @@
+import { type CardPile, type CardPileConfig } from "../cards/cardPile.js";
 import { type OnDeathSpec } from "../combat/death.js";
-import { type EffectInput, type EffectResult, type ReceiveMap, type SingleTargetEffectInput } from "../combat/effects.js";
+import { type EffectInput, type EffectResult, type EffectVia, type ReceiveMap, type SingleTargetEffectInput } from "../combat/effects.js";
 import { type ProjectileSystem } from "../combat/projectiles.js";
+import { type HitReaction, type HitReactionConfig } from "../combat/hitReaction.js";
+import { type TelegraphShape } from "../combat/telegraph.js";
 import { type CommandDefinition, type CommandResult } from "../commands/commandRegistry.js";
+import { type Cosmetics } from "../game/cosmetics.js";
 import type { GameDefinition } from "../game/defineGame.js";
+import { type TerrainField } from "../world/terrain.js";
 import { type GameEventMap, type GameEvents } from "../game/events.js";
 import { type GameFeed } from "../game/feed.js";
 import { type Leaderboard } from "../game/leaderboard.js";
 import { type Loadouts } from "../game/loadout.js";
 import { type Drop, type LootTableDef } from "../game/lootTable.js";
 import { type QuestJournal } from "../game/quest.js";
+import { type WorldItemRecord, type WorldItemSpawnInput } from "../game/worldItem.js";
+import { type Chat } from "../game/chat.js";
 import { type Social } from "../game/social.js";
 import { type TradeField, type TradeSystem } from "../game/trade.js";
 import { type Unlocks } from "../game/unlocks.js";
 import { type InventoryLayout, type InventorySet } from "../inventory/inventoryModel.js";
+import type { ContextVerb } from "../interaction/contextMenu.js";
 import type { ProximityPrompt } from "../interaction/proximityPrompt.js";
 import { type ItemUseHandler, type ItemUseInput, type ItemUseRejection, type ItemUseResult } from "../item/use.js";
 import { type WeaponStats } from "../item/weapon.js";
 import { type PoseAllowedStates, type PoseState } from "../movement/poseState.js";
 import type { ModelAssetRef } from "../scene/assetCatalog.js";
+import { type PaintLayer } from "../scene/paintLayer.js";
 import { type EntityStatsApi, type StatCatalog } from "../scene/entityStats.js";
-import type { EntityPose, SceneEntity, SpawnOptions } from "../scene/entityStore.js";
+import type { EntityPose, EntityPosition, EntityStore, SceneEntity, SpawnOptions, SpawnPose } from "../scene/entityStore.js";
+import { type Forms } from "../scene/form.js";
+import { type ObjectRaycastHit, type ObjectRaycastInput } from "../scene/objectQuery.js";
 import { type ObjectStore } from "../scene/objectStore.js";
+import { type Roster } from "../scene/roster.js";
+import { type Possession } from "../scene/possession.js";
 import { type SpatialApi } from "../scene/spatial.js";
 import { type CycleTargetOptions } from "../scene/targeting.js";
 import { type Stats } from "../stats/statModifiers.js";
+import { type ObservableKeyedStore } from "../store/observableKeyedStore.js";
 import { type SimClock } from "../time/simClock.js";
+import { type TurnLoop, type TurnLoopConfig } from "../turn/turnLoop.js";
+import { type CameraDirector } from "./cameraDirector.js";
+import { type InputSnapshot } from "./inputSnapshot.js";
+import { type MotionIntents } from "./motionIntents.js";
 export interface GameContextItemEntry {
     use?: string;
     weapon?: Record<string, unknown>;
     trade?: TradeField;
+    /** Rarity id read by the `worldItem` loot-filter/render binding when this item drops to the ground (#32/#33). */
+    rarity?: string;
+    /** Base item type read by the loot-filter rule evaluator (#33); defaults to the item id when absent. */
+    baseType?: string;
 }
 export type CatalogEntityRole = "player" | "enemy" | "hostile" | "npc" | "vehicle";
 export interface GameContextEntityEntry {
@@ -39,6 +61,8 @@ export interface GameContextEntityEntry {
         walkSpeed?: number;
     };
     role?: CatalogEntityRole;
+    /** Right-click context-menu verbs for this entity (#31). */
+    verbs?: readonly ContextVerb[];
 }
 export interface GameContextObjectEntry {
     proximityPrompt?: ProximityPrompt;
@@ -46,6 +70,8 @@ export interface GameContextObjectEntry {
         baseBreakTime: number;
     };
     slotInventory?: InventoryLayout;
+    /** Right-click context-menu verbs for this object (#31). */
+    verbs?: readonly ContextVerb[];
 }
 export interface GameContextContent {
     itemById?(itemId: string): GameContextItemEntry | null | undefined;
@@ -63,6 +89,8 @@ export interface GameContextOptions<TAssetRef extends ModelAssetRef = ModelAsset
 }
 export interface SceneObjectContext extends ObjectStore {
     catalog(instanceId: string): GameContextObjectEntry | null;
+    raycast(input: ObjectRaycastInput): ObjectRaycastHit | null;
+    raycastAll(input: ObjectRaycastInput): readonly ObjectRaycastHit[];
 }
 export interface FloatTextInput {
     instanceId?: string;
@@ -70,19 +98,50 @@ export interface FloatTextInput {
     text?: string;
     kind?: string;
     amount?: number;
+    hitType?: string;
+    element?: string;
+    crit?: boolean;
+    scale?: number;
+}
+export interface TelegraphInput {
+    from: string;
+    shape: TelegraphShape;
+    at: [number, number, number];
+    dir?: number;
+    windupMs: number;
+    kind?: string;
+    effect?: {
+        effect: string;
+        via?: EffectVia;
+        radius?: number;
+        falloff?: "linear" | "none";
+        los?: boolean;
+    };
+}
+export interface HitReactionInput {
+    from: string;
+    to: string;
+    config: HitReactionConfig;
+    power?: number;
 }
 export interface SceneEntityContext {
     spawn(name: string, options?: SpawnOptions): string;
     despawn(instanceId: string): boolean;
+    update: EntityStore["update"];
     setPose(instanceId: string, pose: EntityPose): boolean;
     get(instanceId: string): SceneEntity | null;
     list(): readonly SceneEntity[];
+    spawnPoseOf(instanceId: string): SpawnPose | null;
+    resetToSpawn(instanceId: string): boolean;
+    resetAllToSpawn(filter?: (entity: SceneEntity) => boolean): number;
     stats: EntityStatsApi;
     floatText(input: FloatTextInput): void;
+    telegraph(input: TelegraphInput): () => void;
+    hitReaction(input: HitReactionInput): HitReaction | null;
     setTarget(fromId: string, toId: string | null): void;
     getTarget(fromId: string): string | null;
     cycleTarget(fromId: string, options?: CycleTargetOptions): string | null;
-    canReceive(instanceId: string, effect: string): string | null;
+    canReceive(instanceId: string, effect: string, magnitude?: number): string | null;
     preview(input: SingleTargetEffectInput): number;
     effect(input: EffectInput): EffectResult[];
     willHitProjectile: ProjectileSystem["willHitProjectile"];
@@ -93,6 +152,23 @@ export interface SceneEntityContext {
     hasLineOfSight: SpatialApi["hasLineOfSight"];
     queryArc: SpatialApi["queryArc"];
     moveToward: SpatialApi["moveToward"];
+    form: Forms;
+    paint: PaintLayer;
+}
+export type WorldItemPickupResult = {
+    status: "ok";
+    record: WorldItemRecord;
+} | {
+    status: "rejected";
+    reason: string;
+};
+export interface SceneWorldItemContext {
+    spawn(input: WorldItemSpawnInput): WorldItemRecord;
+    get(instanceId: string): WorldItemRecord | null;
+    list(): readonly WorldItemRecord[];
+    nearestInRadius(from: EntityPosition, radius: number, filter?: (record: WorldItemRecord) => boolean): string | null;
+    pickup(instanceId: string, userId: string): WorldItemPickupResult;
+    consume(instanceId: string): WorldItemRecord | null;
 }
 export interface GameContextCommands {
     define<TInput>(name: string, definition: CommandDefinition<GameContext, TInput>): void;
@@ -122,11 +198,25 @@ export interface GameContextItemUse {
     can(input: ItemUseInput): ItemUseRejection | null;
     use(input: ItemUseInput): ItemUseResult<GameContext>;
 }
+export interface GameContextWorld {
+    ground: TerrainField;
+    groundHeightAt(x: number, z: number): number;
+}
+export interface GameContextCards {
+    /** Lazily creates (on first call, `config` required) or returns the existing notify-wrapped pile for `id`. */
+    pile(id: string, config?: CardPileConfig): CardPile;
+}
+export interface GameContextTurn {
+    /** Lazily creates (on first call, `config` required) or returns the existing notify-wrapped turn loop for `id`. */
+    loop(id: string, config?: TurnLoopConfig): TurnLoop;
+}
 export interface GameContext {
     scene: {
         object: SceneObjectContext;
         entity: SceneEntityContext;
+        worldItem: SceneWorldItemContext;
     };
+    world: GameContextWorld;
     game: {
         commands: GameContextCommands;
         events: GameEvents;
@@ -135,9 +225,15 @@ export interface GameContext {
         trade: TradeSystem;
         quest: QuestJournal;
         social: Social;
+        chat: Chat;
         unlocks: Unlocks;
         economy: GameContextEconomy;
         leaderboard: Leaderboard;
+        roster: Roster;
+        /** Game-defined keyed reactive store slot (#163.1); mutations bump `ctx.version()`/notify `ctx.subscribe`. */
+        store: ObservableKeyedStore<unknown>;
+        cards: GameContextCards;
+        turn: GameContextTurn;
     };
     player: {
         userId: string;
@@ -149,12 +245,20 @@ export interface GameContext {
             reason: string;
         } | null;
         movement: PoseState;
+        possession: Possession;
+        cosmetics: Cosmetics;
+        /** Vertical-motion seam into the shell-owned FrameDriver (#162.4); see `MotionIntents`. */
+        motion: MotionIntents;
     };
     item: {
         use: GameContextItemUse;
         weapon: WeaponStats;
     };
     time: SimClock;
+    /** Runtime camera-follow/cinematic override (#196.2); the shell reads `followedEntityId()` each frame. */
+    camera: CameraDirector;
+    /** Held-input snapshot published by the shell each frame before `onTick` (#164.1). */
+    input: InputSnapshot;
     subscribe(listener: () => void): () => void;
     version(): number;
 }