@jgengine/core 0.18.1 → 0.21.0

package/dist/runtime/cameraDirector.js

@@ -1,9 +1,145 @@
+const RIG_KINDS = ["orbit", "first", "topDown", "rts", "shoulder", "lockOn", "chase", "observer", "turntable", "sideScroll", "inspection", "none"];
+const number = (value) => typeof value === "number" && Number.isFinite(value);
+const response = (value) => number(value) || value === Number.POSITIVE_INFINITY;
+const boolean = (value) => typeof value === "boolean";
+const string = (value) => typeof value === "string";
+const oneOf = (...values) => (value) => typeof value === "string" && values.includes(value);
+const shape = (fields, required = []) => (value) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+        return false;
+    const row = value;
+    return required.every((key) => row[key] !== undefined) && Object.entries(row).every(([key, field]) => Object.hasOwn(fields, key) && (field === undefined || fields[key](field)));
+};
+function numbers(...keys) {
+    return Object.fromEntries(keys.map((key) => [key, number]));
+}
+const point = shape(numbers("x", "y", "z"));
+const target3d = shape(numbers("x", "y", "z"), ["x", "y", "z"]);
+const topDownFields = {
+    ...numbers("height", "pitch", "yaw", "followSmoothing"), targetOffset: point,
+    zoom: shape(numbers("min", "max", "speed")),
+};
+const chaseFields = (allowInfinity) => ({
+    ...numbers("distance", "height", "lookHeight", "springDamping", "shakePerSpeed"),
+    headingSource: oneOf("body", "input"), view: oneOf("chase", "cockpit", "hood", "rear"),
+    yawResponse: allowInfinity ? response : number,
+    fov: shape({ ...numbers("base", "max", "speedForMax"), response: allowInfinity ? response : number }),
+    distanceBySpeed: shape(numbers("extra", "speedForMax"), ["extra"]),
+    pitchFollow: shape(numbers("blend", "max", "response")), fovKick: shape(numbers("decay", "max")),
+    lookBackAction: string,
+    collision: (value) => boolean(value) || shape(numbers("radius", "minDistance"))(value),
+    lead: shape(numbers("time", "max"), ["time"]), bank: shape(numbers("perYawRate", "max", "damping"), ["perYawRate"]),
+    velocityYaw: shape(numbers("blend", "minSpeed", "response")),
+});
+const cinematic = shape({
+    loop: boolean,
+    keyframes: (value) => Array.isArray(value) && value.every(shape({
+        position: target3d, lookAt: target3d, ...numbers("fov", "duration"), ease: oneOf("linear", "smooth"),
+    }, ["position", "lookAt"])),
+}, ["keyframes"]);
+const rigConfig = shape({
+    ...numbers("transitionSeconds", "minDistance", "maxDistance", "targetHeight", "initialDistance", "initialHeight", "initialYaw", "initialPitch", "rotateSpeed", "zoomSpeed", "dampingFactor", "targetSmoothing", "dragTargetSmoothing", "distanceSmoothing", "minPolarAngle", "maxPolarAngle"),
+    perspective: oneOf("third", "first"), targetOffset: point, followLock: boolean, followEnabled: boolean,
+    followEntityId: (value) => value === null || string(value),
+    pitchClamp: (value) => Array.isArray(value) && value.length === 2 && value.every(number),
+    collision: shape({ enabled: boolean, ...numbers("padding", "minTargetDistance") }),
+    firstPerson: shape({ ...numbers("eyeHeight", "sensitivity", "maxPitch"), reticle: boolean, viewmodel: boolean }),
+    topDown: shape(topDownFields),
+    rts: shape({ ...topDownFields, ...numbers("panSpeed", "rotateSpeed"), pan: boolean,
+        edgeScroll: (value) => boolean(value) || shape(numbers("margin", "speed"))(value),
+        bounds: shape(numbers("minX", "maxX", "minZ", "maxZ")), start: shape(numbers("x", "z")),
+    }),
+    shoulder: shape({ ...numbers("shoulderOffset", "heightOffset", "distance", "adsTransitionSpeed", "sensitivity", "fov"),
+        side: oneOf("left", "right"), ads: shape(numbers("distance", "shoulderOffset", "fov", "heightOffset")), reticleOffset: shape(numbers("x", "y")),
+    }),
+    lockOn: shape({ ...numbers("distance", "height", "lookHeight", "framingBias", "yawSmoothing"), targetEntityId: string }),
+    chase: shape({ ...chaseFields(true), seatOffsets: shape({ cockpit: point, hood: point, rear: point }) }),
+    observer: shape({ ...numbers("distance", "height", "lookHeight", "orbitSpeed", "startAngle", "fov"),
+        bind: (value) => shape({ kind: oneOf("entity"), entityId: string }, ["kind", "entityId"])(value) ||
+            shape({ kind: oneOf("point"), position: target3d }, ["kind", "position"])(value),
+    }),
+    turntable: shape({ ...numbers("distance", "height", "lookHeight", "orbitSpeed", "startAngle", "fov"), target: target3d }),
+    sideScroll: shape({ ...numbers("distance", "height", "lookHeight", "followSmoothing", "fov"), axis: oneOf("x", "z") }),
+    inspection: shape({ ...numbers("initialDistance", "minDistance", "maxDistance", "minPolarAngle", "maxPolarAngle", "rotateSpeed", "zoomSpeed", "dampingFactor"),
+        anchor: oneOf("target", "cursor", "center"), target: point, initialPosition: point, pan: boolean,
+    }),
+    shake: shape(numbers("maxOffset", "maxRoll", "decayPerSecond", "exponent", "frequency")), cinematic,
+});
+/** @internal */
+export function validateCameraRig(kind, config = {}) {
+    if (!RIG_KINDS.includes(kind) || !rigConfig(config))
+        throw new Error("invalid camera rig override");
+}
+/** @internal */
+export function validateChaseCameraTuning(tuning) {
+    if (tuning !== null && !shape(chaseFields(true))(tuning))
+        throw new Error("invalid chase camera tuning");
+}
+function reviveNumbers(raw) {
+    if (Array.isArray(raw))
+        return raw.map(reviveNumbers);
+    if (raw === null || typeof raw !== "object")
+        return raw;
+    if (Object.getPrototypeOf(raw) !== Object.prototype && Object.getPrototypeOf(raw) !== null)
+        return raw;
+    if (Object.keys(raw).length === 1 && "$cameraNumber" in raw && raw.$cameraNumber === "Infinity")
+        return Infinity;
+    return Object.fromEntries(Object.entries(raw).map(([key, value]) => [key, reviveNumbers(value)]));
+}
+function decodeCameraState(raw) {
+    try {
+        raw = reviveNumbers(raw);
+    }
+    catch {
+        return null;
+    }
+    if (raw === null || typeof raw !== "object")
+        return null;
+    const state = raw;
+    if (state.followEntityId !== undefined && state.followEntityId !== null && typeof state.followEntityId !== "string")
+        return null;
+    if (!("rig" in state) || !("cinematic" in state) || !("chase" in state))
+        return null;
+    try {
+        if (state.rig !== null) {
+            if (!shape({ kind: oneOf(...RIG_KINDS), config: rigConfig }, ["kind", "config"])(state.rig))
+                return null;
+        }
+        if (state.cinematic !== null && !cinematic(state.cinematic))
+            return null;
+        if (state.chase !== null && !shape(chaseFields(true))(state.chase))
+            return null;
+        return structuredClone(state);
+    }
+    catch {
+        return null;
+    }
+}
+/** Default order {@link nextChaseView} cycles through. */
+export const CHASE_VIEWS = ["chase", "hood", "cockpit"];
+/**
+ * The view after `current` in `views`, wrapping at the end; a view missing from the list starts the cycle over.
+ * Pair with `setChaseTuning` to bind a "change camera" key:
+ * `ctx.camera.setChaseTuning({ ...ctx.camera.chaseTuning(), view: nextChaseView(view) })`.
+ *
+ * @capability chase-view-cycle cycle a vehicle camera between chase, hood and cockpit views at runtime
+ */
+export function nextChaseView(current, views = CHASE_VIEWS) {
+    if (views.length === 0)
+        return current;
+    const index = views.indexOf(current);
+    return views[(index + 1) % views.length];
+}
 /** @internal */
 export function createCameraDirector() {
     const listeners = new Set();
     let followEntity = undefined;
     let cinematicConfig = null;
     let chaseTuningPatch = null;
+    let rigOverride = null;
+    let pendingFovKick = 0;
     function notify() {
         for (const listener of listeners)
             listener();
@@ -14,6 +150,13 @@ export function createCameraDirector() {
             notify();
         },
         followedEntityId: () => followEntity,
+        setRig(kind, config = {}) {
+            if (kind !== null)
+                validateCameraRig(kind, config);
+            rigOverride = kind === null ? null : { kind, config: structuredClone(config) };
+            notify();
+        },
+        rig: () => rigOverride,
         setCinematic(config) {
             cinematicConfig = config;
             notify();
@@ -24,9 +167,53 @@ export function createCameraDirector() {
             notify();
         },
         chaseTuning: () => chaseTuningPatch,
+        kickFov(degrees) {
+            if (Number.isFinite(degrees))
+                pendingFovKick += degrees;
+        },
+        takeFovKick() {
+            const kick = pendingFovKick;
+            pendingFovKick = 0;
+            return kick;
+        },
+        snapshot: () => JSON.parse(JSON.stringify({ ...(followEntity === undefined ? {} : { followEntityId: followEntity }), rig: rigOverride, cinematic: cinematicConfig, chase: chaseTuningPatch }, (_key, value) => {
+            if (value === Infinity)
+                return { $cameraNumber: "Infinity" };
+            if (typeof value === "number" && !Number.isFinite(value))
+                throw new Error("invalid camera number");
+            return value;
+        })),
+        restore(state) {
+            const decoded = decodeCameraState(state);
+            if (decoded === null)
+                throw new Error("invalid camera director state");
+            followEntity = decoded.followEntityId;
+            rigOverride = decoded.rig;
+            cinematicConfig = decoded.cinematic;
+            chaseTuningPatch = decoded.chase;
+            pendingFovKick = 0;
+            notify();
+        },
+        reset() {
+            followEntity = undefined;
+            rigOverride = null;
+            cinematicConfig = null;
+            chaseTuningPatch = null;
+            pendingFovKick = 0;
+            notify();
+        },
         subscribe(listener) {
             listeners.add(listener);
             return () => listeners.delete(listener);
         },
     };
 }
+/** Local camera policy is saved, never broadcast to another player's presentation. @internal */
+export function installCameraPersistence(ctx) {
+    ctx.game.registerSave?.({
+        key: "camera",
+        snapshot: ctx.camera.snapshot,
+        hydrate: ctx.camera.restore,
+        decode: decodeCameraState,
+    });
+}

package/dist/runtime/commandDispatch.d.ts

@@ -0,0 +1,14 @@
+import type { CommandResult } from "../commands/commandRegistry.js";
+import type { GameContext } from "./gameContext.js";
+import type { LiveGameBackend } from "./transport.js";
+/** A UI command completes locally or after its authoritative host acknowledges it. */
+export type DispatchedCommandResult = CommandResult<GameContext> | Promise<CommandResult<GameContext>>;
+type Route = {
+    transport: LiveGameBackend["transport"];
+    serverId: () => string | null;
+};
+/** Bind UI command dispatch to the host for this context. A missing join rejects; it never mutates the local replica. */
+export declare function bindCommandTransport(ctx: GameContext, route: Route): () => void;
+/** Dispatch a player's command through the bound host, or locally for an unbound offline context. Await the result before showing success. */
+export declare function dispatchCommand(ctx: GameContext, name: string, input: unknown): DispatchedCommandResult;
+export {};

package/dist/runtime/commandDispatch.js

@@ -0,0 +1,19 @@
+const routes = new WeakMap();
+/** Bind UI command dispatch to the host for this context. A missing join rejects; it never mutates the local replica. */
+export function bindCommandTransport(ctx, route) {
+    routes.set(ctx, route);
+    return () => { if (routes.get(ctx) === route)
+        routes.delete(ctx); };
+}
+/** Dispatch a player's command through the bound host, or locally for an unbound offline context. Await the result before showing success. */
+export function dispatchCommand(ctx, name, input) {
+    const route = routes.get(ctx);
+    if (route === undefined)
+        return ctx.game.commands.run(name, input);
+    const serverId = route.serverId();
+    if (serverId === null)
+        return { status: "rejected", reason: "not-joined" };
+    return route.transport.runCommand({ serverId, command: name, input }).then((result) => result.ok
+        ? { status: "applied", state: ctx }
+        : { status: "rejected", reason: result.reason }, (error) => ({ status: "rejected", reason: error instanceof Error ? error.message : "Command transport failed" }));
+}

package/dist/runtime/commandInput.d.ts

@@ -13,3 +13,40 @@ export declare function readQuantity(value: unknown, options?: {
     min?: number;
     max?: number;
 }): QuantityResult;
+/** Narrow an untrusted value to a plain object, rejecting arrays and null. */
+export declare function isInputRecord(value: unknown): value is Record<string, unknown>;
+/** Read a non-empty string of at most `maxLength` characters, or `null`. */
+export declare function readInputString(value: unknown, options?: {
+    maxLength?: number;
+}): string | null;
+/**
+ * Read a finite number inside `[min, max]`, or `null`. `NaN` and `±Infinity` are always rejected, so a
+ * coordinate can never drive an unbounded loop; `integer` also rejects fractions instead of flooring them.
+ * @capability command-number validate finite, bounded numbers and integers at command boundaries
+ */
+export declare function readInputNumber(value: unknown, options?: {
+    min?: number;
+    max?: number;
+    integer?: boolean;
+}): number | null;
+/** Read one of a fixed set of values, or `null`. */
+export declare function readInputOneOf<const T extends string | number>(value: unknown, allowed: readonly T[]): T | null;
+/** Read an `{ x, y, z }` point whose axes are finite and within `maxAbs`, or `null`. */
+export declare function readInputPoint3(value: unknown, options?: {
+    maxAbs?: number;
+}): {
+    x: number;
+    y: number;
+    z: number;
+} | null;
+/** Read an `{ x, z }` ground point whose axes are finite and within `maxAbs`, or `null`. */
+export declare function readInputPoint2(value: unknown, options?: {
+    maxAbs?: number;
+}): {
+    x: number;
+    z: number;
+} | null;
+/** Read an array of at most `maxItems` entries, each accepted by `readItem`; any rejected entry rejects the whole array. */
+export declare function readInputArray<T>(value: unknown, readItem: (item: unknown) => T | null, options?: {
+    maxItems?: number;
+}): T[] | null;

package/dist/runtime/commandInput.js

@@ -11,3 +11,61 @@ export function readQuantity(value, options = {}) {
         ? { ok: true, quantity: value }
         : { ok: false, reason: "invalid-quantity" };
 }
+/** Narrow an untrusted value to a plain object, rejecting arrays and null. */
+export function isInputRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Read a non-empty string of at most `maxLength` characters, or `null`. */
+export function readInputString(value, options = {}) {
+    return typeof value === "string" && value.length > 0 && value.length <= (options.maxLength ?? 256) ? value : null;
+}
+/**
+ * Read a finite number inside `[min, max]`, or `null`. `NaN` and `±Infinity` are always rejected, so a
+ * coordinate can never drive an unbounded loop; `integer` also rejects fractions instead of flooring them.
+ * @capability command-number validate finite, bounded numbers and integers at command boundaries
+ */
+export function readInputNumber(value, options = {}) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    if (options.integer === true && !Number.isSafeInteger(value))
+        return null;
+    if (value < (options.min ?? -Number.MAX_VALUE) || value > (options.max ?? Number.MAX_VALUE))
+        return null;
+    return value;
+}
+/** Read one of a fixed set of values, or `null`. */
+export function readInputOneOf(value, allowed) {
+    return allowed.includes(value) ? value : null;
+}
+/** Read an `{ x, y, z }` point whose axes are finite and within `maxAbs`, or `null`. */
+export function readInputPoint3(value, options = {}) {
+    if (!isInputRecord(value))
+        return null;
+    const bound = { min: -(options.maxAbs ?? Number.MAX_VALUE), max: options.maxAbs ?? Number.MAX_VALUE };
+    const x = readInputNumber(value.x, bound);
+    const y = readInputNumber(value.y, bound);
+    const z = readInputNumber(value.z, bound);
+    return x === null || y === null || z === null ? null : { x, y, z };
+}
+/** Read an `{ x, z }` ground point whose axes are finite and within `maxAbs`, or `null`. */
+export function readInputPoint2(value, options = {}) {
+    if (!isInputRecord(value))
+        return null;
+    const bound = { min: -(options.maxAbs ?? Number.MAX_VALUE), max: options.maxAbs ?? Number.MAX_VALUE };
+    const x = readInputNumber(value.x, bound);
+    const z = readInputNumber(value.z, bound);
+    return x === null || z === null ? null : { x, z };
+}
+/** Read an array of at most `maxItems` entries, each accepted by `readItem`; any rejected entry rejects the whole array. */
+export function readInputArray(value, readItem, options = {}) {
+    if (!Array.isArray(value) || value.length > (options.maxItems ?? 256))
+        return null;
+    const items = [];
+    for (const entry of value) {
+        const item = readItem(entry);
+        if (item === null)
+            return null;
+        items.push(item);
+    }
+    return items;
+}

package/dist/runtime/commandRunner.d.ts

@@ -16,7 +16,26 @@ export type CommandScope = {
 export type CommandScopeDefinition = Omit<CommandScope, "players"> & {
     players?: readonly string[] | "actor";
 };
+/** Who may send a command: any client through the public transport, or only trusted host code. */
+export type CommandAccess = "client" | "server";
+/** Reason every host returns when a command's `parse` rejects its input. */
+export declare const MALFORMED_COMMAND_INPUT_REASON = "Malformed command input";
+/** Reason a public transport returns for a {@link CommandDef} marked `access: "server"`. */
+export declare const SERVER_ONLY_COMMAND_REASON = "Command is server-only";
 export type CommandDef<TInput = unknown> = {
+    /**
+     * `"server"` when `input` carries facts only the host may decide (unlock state, prices, multipliers):
+     * public transports then refuse it and only trusted host calls such as `helpers.runCommand` run it.
+     * Defaults to `"client"`, so every field of `input` must be validated as untrusted.
+     */
+    access?: CommandAccess;
+    /**
+     * Turns the untrusted wire value into the command's input, or `null` to refuse it with
+     * {@link MALFORMED_COMMAND_INPUT_REASON} before `scope`, `validate` or `apply` run. Those then only ever see
+     * parsed input, so a field checked here can't be skipped in one of them. Build it from the readers in
+     * `runtime/commandInput`; declare typed commands with {@link defineCommand}.
+     */
+    parse?: (input: unknown) => TInput | null;
     /**
      * What this command reads and writes, derived from its own input. A host that hydrates through a
      * scope loads only this slice instead of the whole world, and refuses the command if `apply` then
@@ -55,3 +74,11 @@ export type RunCommandResult = {
 };
 /** @internal */
 export declare function runCommand<TInput>(snapshot: import("./snapshot.js").GameRuntimeSnapshot, commands: Record<string, CommandDef<TInput>>, commandName: string, input: TInput, actorUserId: string, nowMs?: number): RunCommandResult;
+/**
+ * Declare a command with a typed input: `parse` narrows the wire value once, and `scope`, `validate` and
+ * `apply` receive the parsed type. Returns the untyped {@link CommandDef} a runtime's command table holds.
+ * @capability command-parse parse untrusted command input once so every command stage sees typed, bounded values
+ */
+export declare function defineCommand<TInput>(definition: CommandDef<TInput> & {
+    parse: (input: unknown) => TInput | null;
+}): CommandDef;

package/dist/runtime/commandRunner.js

@@ -1,10 +1,23 @@
+/** Reason every host returns when a command's `parse` rejects its input. */
+export const MALFORMED_COMMAND_INPUT_REASON = "Malformed command input";
+/** Reason a public transport returns for a {@link CommandDef} marked `access: "server"`. */
+export const SERVER_ONLY_COMMAND_REASON = "Command is server-only";
 /**
  * The resolved scope, defaulting to the actor and no chunks.
  * Evaluate it before hydration: the actor and the command's own input are both known by then.
  * @internal
  */
 export function resolveCommandScope(commands, commandName, input, actorUserId) {
-    const scope = commands[commandName]?.scope?.(input, actorUserId) ?? { players: "actor", chunkKeys: [] };
+    const command = commands[commandName];
+    let declared;
+    if (command?.parse === undefined) {
+        declared = command?.scope?.(input, actorUserId);
+    }
+    else {
+        const parsed = command.parse(input);
+        declared = parsed === null ? undefined : command.scope?.(parsed, actorUserId);
+    }
+    const scope = declared ?? { players: "actor", chunkKeys: [] };
     const { players, ...rest } = scope;
     return players === undefined ? rest : { ...rest, players: players === "actor" ? [actorUserId] : players };
 }
@@ -42,11 +55,18 @@ export function runCommand(snapshot, commands, commandName, input, actorUserId,
     if (!command) {
         return { ok: false, reason: `Unknown command: ${commandName}` };
     }
-    const validationError = command.validate(snapshot, input, actorUserId, nowMs);
+    let parsed = input;
+    if (command.parse !== undefined) {
+        const result = command.parse(input);
+        if (result === null)
+            return { ok: false, reason: MALFORMED_COMMAND_INPUT_REASON };
+        parsed = result;
+    }
+    const validationError = command.validate(snapshot, parsed, actorUserId, nowMs);
     if (validationError) {
         return { ok: false, reason: validationError.reason };
     }
-    const next = command.apply(snapshot, input, actorUserId, nowMs);
+    const next = command.apply(snapshot, parsed, actorUserId, nowMs);
     return {
         ok: true,
         snapshot: {
@@ -62,3 +82,11 @@ export function runCommand(snapshot, commands, commandName, input, actorUserId,
         },
     };
 }
+/**
+ * Declare a command with a typed input: `parse` narrows the wire value once, and `scope`, `validate` and
+ * `apply` receive the parsed type. Returns the untyped {@link CommandDef} a runtime's command table holds.
+ * @capability command-parse parse untrusted command input once so every command stage sees typed, bounded values
+ */
+export function defineCommand(definition) {
+    return definition;
+}

package/dist/runtime/context/combat.d.ts

@@ -1,11 +1,11 @@
 import { type DeathSystem } from "../../combat/death.js";
 import { type CombatSpatialDeps, type EffectSystem } from "../../combat/effects.js";
-import { type ProjectileSystem } from "../../combat/projectiles.js";
+import { type ProjectileSystem, type ProjectileTravelDeps } from "../../combat/projectiles.js";
 import type { PhysicsConfig } from "../../game/defineGame.js";
 import type { GameEvents } from "../../game/events.js";
 import { type VfxInstanceStore } from "../../game/vfxInstance.js";
 import type { LootRegistry } from "../../game/lootTable.js";
-import type { EntityColliderSet } from "../../scene/colliders.js";
+import { type EntityColliderSet } from "../../scene/colliders.js";
 import type { EntityStore } from "../../scene/entityStore.js";
 import type { ObjectStore } from "../../scene/objectStore.js";
 import type { SceneRaycastApi } from "../../scene/sceneRaycast.js";
@@ -34,9 +34,16 @@ export interface CombatSubsystemDeps {
     lootRegistry: LootRegistry;
     spawnWorldItem: (input: WorldItemSpawnInput) => WorldItemRecord;
     despawnEntity: (instanceId: string) => boolean;
-    runCommand: (name: string, args: unknown) => void;
-    localUserId: string;
+    runCommand: (name: string, args: unknown, actorUserId?: string) => void;
+    userIdOf: (instanceId: string) => string | undefined;
+    rng: () => number;
     physics?: PhysicsConfig;
+    projectileTravel?: Pick<ProjectileTravelDeps, "acceleration" | "sweep" | "maxActive" | "maxRetained"> & {
+        /** Bounded collision source; omit for the context's entities. */
+        targets?(): readonly string[];
+        /** Reject an oversized collision source rather than silently missing targets. Default 2048. */
+        maxTargets?: number;
+    };
 }
 /** @internal Effects, projectiles, death, and combat presentation surface. */
 export interface CombatSubsystem {
@@ -46,6 +53,7 @@ export interface CombatSubsystem {
     projectiles: ProjectileSystem;
     combatFx: CombatFx;
     vfxInstances: VfxInstanceStore;
+    captureProjectileTargets(gameDt: number): void;
 }
 /** @internal */
 export declare function createCombatSubsystem(d: CombatSubsystemDeps): CombatSubsystem;