@jgengine/core 0.6.0 → 0.7.0

package/dist/runtime/gameContext.d.ts

@@ -1,7 +1,10 @@
 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 GameEventMap, type GameEvents } from "../game/events.js";
 import { type GameFeed } from "../game/feed.js";
@@ -9,18 +12,23 @@ 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 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 EntityStatsApi, type StatCatalog } from "../scene/entityStats.js";
-import type { EntityPose, SceneEntity, SpawnOptions } from "../scene/entityStore.js";
+import type { EntityPose, EntityPosition, SceneEntity, SpawnOptions } from "../scene/entityStore.js";
+import { type Forms } from "../scene/form.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";
@@ -29,6 +37,10 @@ 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 +51,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 +60,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;
@@ -70,6 +86,31 @@ 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;
@@ -79,6 +120,8 @@ export interface SceneEntityContext {
     list(): readonly SceneEntity[];
     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;
@@ -93,6 +136,21 @@ export interface SceneEntityContext {
     hasLineOfSight: SpatialApi["hasLineOfSight"];
     queryArc: SpatialApi["queryArc"];
     moveToward: SpatialApi["moveToward"];
+    form: Forms;
+}
+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;
 }
 export interface GameContextCommands {
     define<TInput>(name: string, definition: CommandDefinition<GameContext, TInput>): void;
@@ -126,6 +184,7 @@ export interface GameContext {
     scene: {
         object: SceneObjectContext;
         entity: SceneEntityContext;
+        worldItem: SceneWorldItemContext;
     };
     game: {
         commands: GameContextCommands;
@@ -138,6 +197,7 @@ export interface GameContext {
         unlocks: Unlocks;
         economy: GameContextEconomy;
         leaderboard: Leaderboard;
+        roster: Roster;
     };
     player: {
         userId: string;
@@ -149,6 +209,8 @@ export interface GameContext {
             reason: string;
         } | null;
         movement: PoseState;
+        possession: Possession;
+        cosmetics: Cosmetics;
     };
     item: {
         use: GameContextItemUse;

package/dist/runtime/gameContext.js

@@ -1,14 +1,18 @@
-import { createDeathSystem, deathReasonFromEffect } from "../combat/death.js";
+import { createDeathSystem, deathReasonFromEffect, normalizeOnDeath } from "../combat/death.js";
 import { createEffectSystem, } from "../combat/effects.js";
 import { createProjectileSystem } from "../combat/projectiles.js";
+import { resolveHitReaction, } from "../combat/hitReaction.js";
+import { pointInTelegraph, } from "../combat/telegraph.js";
 import { createCommandRegistry, } from "../commands/commandRegistry.js";
 import { balance as walletBalance, canAfford as walletCanAfford, charge as walletCharge, chargeAll as walletChargeAll, createEmptyWallet, grant as walletGrant, } from "../economy/wallet.js";
+import { createCosmetics } from "../game/cosmetics.js";
 import { createGameEvents } from "../game/events.js";
 import { createGameFeed } from "../game/feed.js";
 import { createLeaderboard } from "../game/leaderboard.js";
 import { createLoadouts } from "../game/loadout.js";
 import { createLootRegistry, grantDrops } from "../game/lootTable.js";
 import { createQuestJournal } from "../game/quest.js";
+import { createWorldItemStore, resolveDeathDrops, DEFAULT_RARITY, WORLD_ITEM_ENTITY_NAME, } from "../game/worldItem.js";
 import { createSocial } from "../game/social.js";
 import { createTradeSystem } from "../game/trade.js";
 import { createUnlocks } from "../game/unlocks.js";
@@ -17,7 +21,10 @@ import { createItemUse, } from "../item/use.js";
 import { createWeaponStats } from "../item/weapon.js";
 import { createPoseState } from "../movement/poseState.js";
 import { createEntityStatsApi, seedStatValues, setStatValue, } from "../scene/entityStats.js";
+import { createForms } from "../scene/form.js";
 import { createObjectStore } from "../scene/objectStore.js";
+import { createRoster } from "../scene/roster.js";
+import { createPossession } from "../scene/possession.js";
 import { createSpatialApi } from "../scene/spatial.js";
 import { createTargeting } from "../scene/targeting.js";
 import { createStats } from "../stats/statModifiers.js";
@@ -80,17 +87,29 @@ export function createGameContext(options) {
     const feed = createGameFeed();
     const lootRegistry = createLootRegistry();
     const unlocks = notifyAfter(createUnlocks(), ["grant", "hydrate"], signal.notify);
-    const rawSocial = createSocial({ events, now });
+    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", "remove", "block", "hydrate"], signal.notify),
         party: notifyAfter(rawSocial.party, ["invite", "accept", "kick", "leave", "promote"], signal.notify),
         presence: rawSocial.presence,
+        emotes: rawSocial.emotes,
     };
     const leaderboard = notifyAfter(createLeaderboard(), ["increment", "hydrate"], signal.notify);
+    const roster = notifyAfter(createRoster({ now }), ["capture", "release", "setEquipped", "hydrate"], signal.notify);
     const playerStats = createStats({});
     const pose = createPoseState((instanceId) => catalogEntry(instanceId)?.movement);
     const commandRegistry = createCommandRegistry();
     const itemUse = createItemUse((itemId) => content.itemById?.(itemId)?.use);
+    const possession = notifyAfter(createPossession({ entities, events }), ["possess", "own", "disown"], signal.notify);
+    const forms = notifyAfter(createForms({ entities, time, events }), ["shapeshift", "revert"], signal.notify);
+    const cosmetics = notifyAfter(createCosmetics({ events }), ["apply", "equip", "hydrate"], signal.notify);
     const inventoryDeclarations = definition.inventories ?? {};
     const inventoryIds = Object.keys(inventoryDeclarations);
     const layouts = {};
@@ -242,6 +261,37 @@ export function createGameContext(options) {
         pose.clear(instanceId);
         return existed;
     }
+    const worldItems = notifyAfter(createWorldItemStore({
+        spawnEntity: (position) => entities.spawn(WORLD_ITEM_ENTITY_NAME, { position, role: "prop" }),
+        despawnEntity,
+        resolvePosition: (instanceId) => entities.get(instanceId)?.position,
+    }), ["spawn", "take"], signal.notify);
+    function spawnWorldItem(input) {
+        const record = worldItems.spawn(input);
+        events.emit("worldItem.dropped", {
+            instanceId: record.instanceId,
+            itemId: record.itemId,
+            rarity: record.rarity,
+            count: record.count,
+            position: [input.position[0], input.position[1], input.position[2]],
+            ...(record.source !== undefined ? { source: record.source } : {}),
+        });
+        return record;
+    }
+    function pickupWorldItem(instanceId, userId) {
+        const record = worldItems.take(instanceId);
+        if (record === null)
+            return { status: "rejected", reason: "not-found" };
+        loot.grantToPlayer(userId, [{ item: record.itemId, count: record.count }], "worldItem.pickup");
+        events.emit("worldItem.picked_up", {
+            instanceId,
+            userId,
+            itemId: record.itemId,
+            rarity: record.rarity,
+            count: record.count,
+        });
+        return { status: "ok", record };
+    }
     const death = createDeathSystem({
         resolveOnDeath: (instanceId) => catalogEntry(instanceId)?.onDeath,
         resolveIdentity(instanceId) {
@@ -268,7 +318,10 @@ export function createGameContext(options) {
         getStat: weapon.getStat,
         spatial: combatSpatial,
         onLethal(instanceId, lethalCtx) {
-            const catalogId = entities.get(instanceId)?.name;
+            const dyingEntity = entities.get(instanceId);
+            const catalogId = dyingEntity?.name;
+            const position = dyingEntity?.position;
+            const normalizedOnDeath = normalizeOnDeath(catalogEntry(instanceId)?.onDeath);
             const reason = deathReasonFromEffect({
                 ...lethalCtx,
                 userIdOf: (id) => (id === player.userId ? player.userId : undefined),
@@ -278,7 +331,23 @@ export function createGameContext(options) {
                 resolution.drops.length > 0 &&
                 reason.kind === "player_kill" &&
                 reason.killerUserId === player.userId) {
-                loot.grantToPlayer(player.userId, resolution.drops, catalogId);
+                if (normalizedOnDeath.dropMode === "world" && position !== undefined) {
+                    const resolved = resolveDeathDrops(resolution.drops, {
+                        mode: "world",
+                        origin: position,
+                        resolveRarity: (itemId) => content.itemById?.(itemId)?.rarity ?? DEFAULT_RARITY,
+                        resolveBaseType: (itemId) => content.itemById?.(itemId)?.baseType ?? itemId,
+                        scatter: normalizedOnDeath.scatter,
+                        ...(catalogId !== undefined ? { source: catalogId } : {}),
+                    });
+                    for (const spawn of resolved.worldSpawns)
+                        spawnWorldItem(spawn);
+                    if (resolved.grants.length > 0)
+                        loot.grantToPlayer(player.userId, resolved.grants, catalogId);
+                }
+                else {
+                    loot.grantToPlayer(player.userId, resolution.drops, catalogId);
+                }
             }
         },
     }), ["applyEffect"], signal.notify);
@@ -297,8 +366,76 @@ export function createGameContext(options) {
             event.instanceId = input.instanceId;
         if (input.amount !== undefined)
             event.amount = input.amount;
+        if (input.hitType !== undefined)
+            event.hitType = input.hitType;
+        if (input.element !== undefined)
+            event.element = input.element;
+        if (input.crit !== undefined)
+            event.crit = input.crit;
+        if (input.scale !== undefined)
+            event.scale = input.scale;
         events.emit("entity.floatText", event);
     }
+    let telegraphSeq = 0;
+    function fireTelegraph(input) {
+        const id = telegraphSeq++;
+        const telegraphEvent = {
+            id,
+            shape: input.shape,
+            position: [input.at[0], input.at[1], input.at[2]],
+            windupMs: input.windupMs,
+            kind: input.kind ?? "danger",
+        };
+        if (input.dir !== undefined)
+            telegraphEvent.dir = input.dir;
+        events.emit("combat.telegraph", telegraphEvent);
+        const bound = input.effect;
+        if (bound === undefined)
+            return () => { };
+        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 targets = entities.list().filter((entity) => pointInTelegraph(config, entity.position));
+            for (const target of targets) {
+                applyEffectAndFloat({
+                    from: input.from,
+                    to: target.id,
+                    effect: bound.effect,
+                    ...(bound.via === undefined ? {} : { via: bound.via }),
+                });
+            }
+        });
+    }
+    function applyHitReaction(input) {
+        const attacker = entities.get(input.from);
+        const target = entities.get(input.to);
+        if (target === null)
+            return null;
+        const attackerPos = attacker?.position ?? target.position;
+        const reaction = resolveHitReaction(input.config, {
+            attackerPos,
+            targetPos: target.position,
+            ...(input.power === undefined ? {} : { power: input.power }),
+        });
+        entities.setPose(input.to, {
+            position: [
+                target.position[0] + reaction.impulse[0],
+                target.position[1] + reaction.impulse[1],
+                target.position[2] + reaction.impulse[2],
+            ],
+            rotationY: target.rotationY,
+        });
+        const reactionEvent = {
+            instanceId: input.to,
+            position: [target.position[0], target.position[1], target.position[2]],
+            hitstopMs: reaction.hitstopMs,
+        };
+        if (reaction.shake !== null)
+            reactionEvent.shake = reaction.shake;
+        events.emit("combat.hitReaction", reactionEvent);
+        return reaction;
+    }
     function applyEffectAndFloat(input) {
         const positionsBefore = new Map();
         for (const entity of entities.list())
@@ -359,6 +496,8 @@ export function createGameContext(options) {
                 list: entities.list,
                 stats: entityStats,
                 floatText: emitFloatText,
+                telegraph: fireTelegraph,
+                hitReaction: applyHitReaction,
                 setTarget: targeting.setTarget,
                 getTarget: targeting.getTarget,
                 cycleTarget: targeting.cycleTarget,
@@ -373,6 +512,14 @@ export function createGameContext(options) {
                 hasLineOfSight: spatial.hasLineOfSight,
                 queryArc: spatial.queryArc,
                 moveToward: spatial.moveToward,
+                form: forms,
+            },
+            worldItem: {
+                spawn: spawnWorldItem,
+                get: worldItems.get,
+                list: worldItems.list,
+                nearestInRadius: worldItems.nearestInRadius,
+                pickup: pickupWorldItem,
             },
         },
         game: {
@@ -408,6 +555,7 @@ export function createGameContext(options) {
             unlocks,
             economy,
             leaderboard,
+            roster,
         },
         player: {
             userId: player.userId,
@@ -417,6 +565,8 @@ export function createGameContext(options) {
             loadout: loadouts,
             applyLoadout: loadouts.applyLoadout,
             movement: pose,
+            possession,
+            cosmetics,
         },
         item: {
             use: {

package/dist/runtime/hostPersistence.d.ts

@@ -1,13 +1,26 @@
 import type { LeaderboardScope } from "../game/leaderboard.js";
+import type { NormalizedScenarioReset } from "./persistenceScope.js";
 import type { SaveConfig } from "./save.js";
 import type { GameRuntimeSnapshot, RuntimeChunkRow, RuntimePlayerRow, RuntimeServerRow } from "./snapshot.js";
 export type GameServerStatus = "open" | "running" | "closed";
+export type SessionVisibility = "public" | "private";
+export type SessionAttributes = {
+    label?: string;
+    mode?: string;
+    visibility?: SessionVisibility;
+    joinCode?: string;
+    tags?: string[];
+};
 export type GameServerRecord = {
     serverId: string;
     gameId: string;
     status: GameServerStatus;
     mode?: string;
     modeConfig?: unknown;
+    label?: string;
+    visibility?: SessionVisibility;
+    joinCode?: string;
+    tags?: string[];
     memberUserIds: string[];
     slotsPerServer: number;
     save: SaveConfig;
@@ -58,11 +71,16 @@ export type ServerListing = {
     memberCount: number;
     slotsPerServer: number;
     mode?: string;
+    label?: string;
+    visibility?: SessionVisibility;
+    joinCode?: string;
+    tags?: string[];
     updatedAt: number;
 };
 export declare function toServerListing(record: GameServerRecord): ServerListing;
 export type HostPersistence = {
     savePlan?: (plan: ServerPersistPlan) => Promise<void>;
+    resetScenario?: (reset: NormalizedScenarioReset) => Promise<void>;
     loadServer: (serverId: string) => Promise<GameServerRecord | null>;
     saveServer: (record: GameServerRecord) => Promise<void>;
     listServers: (gameId: string) => Promise<GameServerRecord[]>;

package/dist/runtime/hostPersistence.js

@@ -42,6 +42,10 @@ export function toServerListing(record) {
         memberCount: record.memberUserIds.length,
         slotsPerServer: record.slotsPerServer,
         mode: record.mode,
+        label: record.label,
+        visibility: record.visibility,
+        joinCode: record.joinCode,
+        tags: record.tags,
         updatedAt: record.updatedAt,
     };
 }

package/dist/runtime/persistenceScope.d.ts

@@ -0,0 +1,32 @@
+import type { PlayerProfileRecord } from "./hostPersistence.js";
+import type { RuntimePlayerRow } from "./snapshot.js";
+export type PersistenceScope = "run" | "meta";
+export interface ScopeSchema {
+    run: readonly string[];
+}
+export interface ScopedState<T = Record<string, unknown>> {
+    meta: Partial<T>;
+    run: Partial<T>;
+}
+export declare function partitionScopes<T extends Record<string, unknown>>(state: T, schema: ScopeSchema): ScopedState<T>;
+export declare function resetRun<T extends Record<string, unknown>>(scoped: ScopedState<T>): ScopedState<T>;
+export declare function mergeScopes<T extends Record<string, unknown>>(scoped: ScopedState<T>): Partial<T>;
+export declare function clearRunFields(player: RuntimePlayerRow, runFields: readonly string[]): RuntimePlayerRow;
+export declare function applyRunReset(profile: PlayerProfileRecord, runFields: readonly string[], now: number): PlayerProfileRecord;
+export interface ScenarioReset {
+    gameId: string;
+    serverId?: string;
+    wipeChunks?: boolean;
+    wipeServerSession?: boolean;
+    resetPlayers?: PersistenceScope | "none";
+    runFields?: readonly string[];
+}
+export interface NormalizedScenarioReset {
+    gameId: string;
+    serverId: string | null;
+    wipeChunks: boolean;
+    wipeServerSession: boolean;
+    resetPlayers: "run" | "none";
+    runFields: readonly string[];
+}
+export declare function planScenarioReset(reset: ScenarioReset): NormalizedScenarioReset;

package/dist/runtime/persistenceScope.js

@@ -0,0 +1,64 @@
+export function partitionScopes(state, schema) {
+    const runKeys = new Set(schema.run);
+    const meta = {};
+    const run = {};
+    for (const key of Object.keys(state)) {
+        if (runKeys.has(key))
+            run[key] = state[key];
+        else
+            meta[key] = state[key];
+    }
+    return { meta, run };
+}
+export function resetRun(scoped) {
+    return { meta: scoped.meta, run: {} };
+}
+export function mergeScopes(scoped) {
+    return { ...scoped.meta, ...scoped.run };
+}
+const RUN_FIELD_DEFAULTS = {
+    inventories: {},
+    economy: {},
+    unlocks: [],
+    quests: undefined,
+    social: undefined,
+    leaderboard: {},
+    session: {},
+};
+export function clearRunFields(player, runFields) {
+    const next = { ...player };
+    for (const field of runFields) {
+        if (field === "userId")
+            continue;
+        const key = field;
+        if (key in RUN_FIELD_DEFAULTS) {
+            const template = RUN_FIELD_DEFAULTS[key];
+            if (template === undefined)
+                delete next[field];
+            else
+                next[field] = Array.isArray(template) ? [...template] : { ...template };
+        }
+        else {
+            delete next[field];
+        }
+    }
+    return next;
+}
+export function applyRunReset(profile, runFields, now) {
+    return {
+        ...profile,
+        playerState: clearRunFields(profile.playerState, runFields),
+        revision: profile.revision + 1,
+        updatedAt: now,
+    };
+}
+export function planScenarioReset(reset) {
+    return {
+        gameId: reset.gameId,
+        serverId: reset.serverId ?? null,
+        wipeChunks: reset.wipeChunks ?? true,
+        wipeServerSession: reset.wipeServerSession ?? true,
+        resetPlayers: reset.resetPlayers === "run" ? "run" : "none",
+        runFields: reset.runFields ?? [],
+    };
+}

package/dist/scene/autoTarget.d.ts

@@ -0,0 +1,15 @@
+export type AutoTargetPolicy = "nearest" | "farthest" | "random" | "strongest" | "weakest" | "first" | "last";
+export interface AutoTargetDeps {
+    candidates: (fromId: string) => readonly string[];
+    distance: (fromId: string, toId: string) => number | null;
+    strength?: (toId: string) => number;
+    progress?: (toId: string) => number;
+    rng?: () => number;
+}
+export declare function selectAutoTarget(policy: AutoTargetPolicy, fromId: string, deps: AutoTargetDeps): string | null;
+export interface AutoTargeter {
+    policy(): AutoTargetPolicy;
+    setPolicy(policy: AutoTargetPolicy): void;
+    pick(fromId: string): string | null;
+}
+export declare function createAutoTargeter(policy: AutoTargetPolicy, deps: AutoTargetDeps): AutoTargeter;

package/dist/scene/autoTarget.js

@@ -0,0 +1,54 @@
+function metric(policy, fromId, toId, deps) {
+    switch (policy) {
+        case "nearest":
+        case "farthest":
+            return deps.distance(fromId, toId);
+        case "strongest":
+        case "weakest":
+            return deps.strength?.(toId) ?? 0;
+        case "first":
+        case "last":
+            return deps.progress?.(toId) ?? 0;
+        case "random":
+            return 0;
+    }
+}
+function prefersHigher(policy) {
+    return policy === "farthest" || policy === "strongest" || policy === "first";
+}
+export function selectAutoTarget(policy, fromId, deps) {
+    const candidates = deps.candidates(fromId).filter((id) => id !== fromId);
+    if (candidates.length === 0)
+        return null;
+    if (policy === "random") {
+        const rng = deps.rng ?? Math.random;
+        return candidates[Math.min(candidates.length - 1, Math.floor(rng() * candidates.length))];
+    }
+    const higher = prefersHigher(policy);
+    let best = null;
+    let bestScore = higher ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
+    for (const id of candidates) {
+        const score = metric(policy, fromId, id, deps);
+        if (score === null)
+            continue;
+        if (best === null || (higher ? score > bestScore : score < bestScore)) {
+            best = id;
+            bestScore = score;
+        }
+    }
+    return best;
+}
+export function createAutoTargeter(policy, deps) {
+    let current = policy;
+    return {
+        policy() {
+            return current;
+        },
+        setPolicy(next) {
+            current = next;
+        },
+        pick(fromId) {
+            return selectAutoTarget(current, fromId, deps);
+        },
+    };
+}

package/dist/scene/behaviors.d.ts

@@ -1,8 +1,15 @@
 import { type ProximityPrompt } from "../interaction/proximityPrompt.js";
+import type { Waypoint } from "../nav/pathFollow.js";
 export interface WanderBehavior {
     kind: "wander";
     radius: number;
 }
+export interface PatrolBehavior {
+    kind: "patrol";
+    waypoints: readonly Waypoint[];
+    speed: number;
+    loop: boolean;
+}
 export interface PromptableBehavior {
     kind: "promptable";
     prompt: ProximityPrompt;
@@ -10,10 +17,15 @@ export interface PromptableBehavior {
 export interface PlayerBehavior {
     kind: "player";
 }
-export type BehaviorDescriptor = WanderBehavior | PromptableBehavior | PlayerBehavior;
+export type BehaviorDescriptor = WanderBehavior | PatrolBehavior | PromptableBehavior | PlayerBehavior;
 export declare function wander({ radius }: {
     radius: number;
 }): WanderBehavior;
+export declare function patrol({ waypoints, speed, loop, }: {
+    waypoints: readonly Waypoint[];
+    speed: number;
+    loop?: boolean;
+}): PatrolBehavior;
 export declare function promptable(prompt: ProximityPrompt): PromptableBehavior;
 export declare function talkable(dialogueId: string): PromptableBehavior;
 export declare function player(): PlayerBehavior;

package/dist/scene/behaviors.js

@@ -2,6 +2,9 @@ import { command, keybind, proximityPrompt, } from "../interaction/proximityProm
 export function wander({ radius }) {
     return { kind: "wander", radius };
 }
+export function patrol({ waypoints, speed, loop = true, }) {
+    return { kind: "patrol", waypoints, speed, loop };
+}
 export function promptable(prompt) {
     return { kind: "promptable", prompt };
 }

package/dist/scene/captureCheck.d.ts

@@ -0,0 +1,7 @@
+export interface CaptureCheckInput {
+    hpFraction: number;
+    catchPower: number;
+    difficulty?: number;
+}
+export declare function captureChance(input: CaptureCheckInput): number;
+export declare function rollCapture(input: CaptureCheckInput, rng?: () => number): boolean;