@zylem/game-lib 0.6.2 → 0.6.4

package/dist/behavior/world-boundary-2d.d.ts

@@ -0,0 +1,142 @@
+import { c as BehaviorDescriptor } from '../behavior-descriptor-BXnVR8Ki.js';
+import { S as SyncStateMachine } from '../sync-state-machine-CZyspBpj.js';
+import 'bitecs';
+import 'typescript-fsm';
+
+/**
+ * WorldBoundary2DFSM
+ *
+ * Minimal FSM + extended state to track which world boundaries were hit.
+ *
+ * Notes:
+ * - "Hit boundaries" is inherently a *set* (can hit left+bottom in one frame),
+ *   so we store it as extended state (`lastHits`) rather than a single FSM state.
+ * - The FSM state is still useful for coarse status like "inside" vs "touching".
+ */
+
+type WorldBoundary2DHit = 'top' | 'bottom' | 'left' | 'right';
+type WorldBoundary2DHits = Record<WorldBoundary2DHit, boolean>;
+interface WorldBoundary2DPosition {
+    x: number;
+    y: number;
+}
+interface WorldBoundary2DBounds {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+declare enum WorldBoundary2DState {
+    Inside = "inside",
+    Touching = "touching"
+}
+declare enum WorldBoundary2DEvent {
+    EnterInside = "enter-inside",
+    TouchBoundary = "touch-boundary"
+}
+/**
+ * Compute which boundaries are being hit for a position and bounds.
+ * This matches the semantics of the legacy `boundary2d` behavior:
+ * - left hit if x <= left
+ * - right hit if x >= right
+ * - bottom hit if y <= bottom
+ * - top hit if y >= top
+ */
+declare function computeWorldBoundary2DHits(position: WorldBoundary2DPosition, bounds: WorldBoundary2DBounds): WorldBoundary2DHits;
+declare function hasAnyWorldBoundary2DHit(hits: WorldBoundary2DHits): boolean;
+/**
+ * FSM wrapper with "extended state" (lastHits / lastPosition).
+ * Systems should call `update(...)` once per frame.
+ */
+declare class WorldBoundary2DFSM {
+    readonly machine: SyncStateMachine<WorldBoundary2DState, WorldBoundary2DEvent, never>;
+    private lastHits;
+    private lastPosition;
+    private lastUpdatedAtMs;
+    constructor();
+    getState(): WorldBoundary2DState;
+    /**
+     * Returns the last computed hits (always available after first update call).
+     */
+    getLastHits(): WorldBoundary2DHits;
+    /**
+     * Returns adjusted movement values based on boundary hits.
+     * If the entity is touching a boundary and trying to move further into it,
+     * that axis component is zeroed out.
+     *
+     * @param moveX - The desired X movement
+     * @param moveY - The desired Y movement
+     * @returns Adjusted { moveX, moveY } with boundary-blocked axes zeroed
+     */
+    getMovement(moveX: number, moveY: number): {
+        moveX: number;
+        moveY: number;
+    };
+    /**
+     * Returns the last position passed to `update`, if any.
+     */
+    getLastPosition(): WorldBoundary2DPosition | null;
+    /**
+     * Best-effort timestamp (ms) of the last `update(...)` call.
+     * This is optional metadata; systems can ignore it.
+     */
+    getLastUpdatedAtMs(): number | null;
+    /**
+     * Update FSM + extended state based on current position and bounds.
+     * Returns the computed hits for convenience.
+     */
+    update(position: WorldBoundary2DPosition, bounds: WorldBoundary2DBounds): WorldBoundary2DHits;
+    private dispatch;
+}
+
+interface WorldBoundary2DOptions {
+    /**
+     * World boundaries (in world units).
+     * - left hit if x <= left
+     * - right hit if x >= right
+     * - bottom hit if y <= bottom
+     * - top hit if y >= top
+     */
+    boundaries: WorldBoundary2DBounds;
+}
+/**
+ * Handle methods provided by WorldBoundary2DBehavior
+ */
+interface WorldBoundary2DHandle {
+    /**
+     * Get the last computed boundary hits.
+     * Returns null until entity is spawned and FSM is initialized.
+     */
+    getLastHits(): WorldBoundary2DHits | null;
+    /**
+     * Get adjusted movement values based on boundary hits.
+     * Zeros out movement into boundaries the entity is touching.
+     */
+    getMovement(moveX: number, moveY: number): {
+        moveX: number;
+        moveY: number;
+    };
+}
+/**
+ * WorldBoundary2DBehavior
+ *
+ * @example
+ * ```ts
+ * import { WorldBoundary2DBehavior } from "@zylem/game-lib";
+ *
+ * const ship = createSprite({ ... });
+ * const boundary = ship.use(WorldBoundary2DBehavior, {
+ *   boundaries: { left: -10, right: 10, bottom: -7.5, top: 7.5 },
+ * });
+ *
+ * ship.onUpdate(({ me }) => {
+ *   let moveX = ..., moveY = ...;
+ *   const hits = boundary.getLastHits(); // Fully typed!
+ *   ({ moveX, moveY } = boundary.getMovement(moveX, moveY));
+ *   me.moveXY(moveX, moveY);
+ * });
+ * ```
+ */
+declare const WorldBoundary2DBehavior: BehaviorDescriptor<WorldBoundary2DOptions, WorldBoundary2DHandle, unknown>;
+
+export { WorldBoundary2DBehavior, type WorldBoundary2DBounds, WorldBoundary2DEvent, WorldBoundary2DFSM, type WorldBoundary2DHandle, type WorldBoundary2DHit, type WorldBoundary2DHits, type WorldBoundary2DOptions, type WorldBoundary2DPosition, WorldBoundary2DState, computeWorldBoundary2DHits, hasAnyWorldBoundary2DHit };

package/dist/behavior/world-boundary-2d.js

@@ -0,0 +1,235 @@
+// src/lib/behaviors/behavior-descriptor.ts
+function defineBehavior(config) {
+  return {
+    key: /* @__PURE__ */ Symbol.for(`zylem:behavior:${config.name}`),
+    defaultOptions: config.defaultOptions,
+    systemFactory: config.systemFactory,
+    createHandle: config.createHandle
+  };
+}
+
+// src/lib/core/utility/sync-state-machine.ts
+import {
+  StateMachine as BaseStateMachine
+} from "typescript-fsm";
+import { t } from "typescript-fsm";
+var SyncStateMachine = class extends BaseStateMachine {
+  constructor(init, transitions = [], logger = console) {
+    super(init, transitions, logger);
+  }
+  dispatch(_event, ..._args) {
+    throw new Error("SyncStateMachine does not support async dispatch.");
+  }
+  syncDispatch(event, ...args) {
+    const found = this.transitions.some((transition) => {
+      if (transition.fromState !== this._current || transition.event !== event) {
+        return false;
+      }
+      const current = this._current;
+      this._current = transition.toState;
+      if (!transition.cb) {
+        return true;
+      }
+      try {
+        transition.cb(...args);
+        return true;
+      } catch (error) {
+        this._current = current;
+        this.logger.error("Exception in callback", error);
+        throw error;
+      }
+    });
+    if (!found) {
+      const errorMessage = this.formatErr(this._current, event);
+      this.logger.error(errorMessage);
+    }
+    return found;
+  }
+};
+
+// src/lib/behaviors/shared/bounds-2d.ts
+function computeBounds2DHits(position, bounds) {
+  const hits = {
+    top: false,
+    bottom: false,
+    left: false,
+    right: false
+  };
+  if (position.x <= bounds.minX) hits.left = true;
+  else if (position.x >= bounds.maxX) hits.right = true;
+  if (position.y <= bounds.minY) hits.bottom = true;
+  else if (position.y >= bounds.maxY) hits.top = true;
+  return hits;
+}
+function hasAnyBounds2DHit(hits) {
+  return hits.left || hits.right || hits.top || hits.bottom;
+}
+function constrainMovementToBounds2D(hits, moveX, moveY) {
+  let adjustedX = moveX;
+  let adjustedY = moveY;
+  if (hits.left && moveX < 0 || hits.right && moveX > 0) {
+    adjustedX = 0;
+  }
+  if (hits.bottom && moveY < 0 || hits.top && moveY > 0) {
+    adjustedY = 0;
+  }
+  return { moveX: adjustedX, moveY: adjustedY };
+}
+
+// src/lib/behaviors/world-boundary-2d/world-boundary-2d-fsm.ts
+var WorldBoundary2DState = /* @__PURE__ */ ((WorldBoundary2DState2) => {
+  WorldBoundary2DState2["Inside"] = "inside";
+  WorldBoundary2DState2["Touching"] = "touching";
+  return WorldBoundary2DState2;
+})(WorldBoundary2DState || {});
+var WorldBoundary2DEvent = /* @__PURE__ */ ((WorldBoundary2DEvent2) => {
+  WorldBoundary2DEvent2["EnterInside"] = "enter-inside";
+  WorldBoundary2DEvent2["TouchBoundary"] = "touch-boundary";
+  return WorldBoundary2DEvent2;
+})(WorldBoundary2DEvent || {});
+function computeWorldBoundary2DHits(position, bounds) {
+  return computeBounds2DHits(position, {
+    minX: bounds.left,
+    maxX: bounds.right,
+    minY: bounds.bottom,
+    maxY: bounds.top
+  });
+}
+function hasAnyWorldBoundary2DHit(hits) {
+  return hasAnyBounds2DHit(hits);
+}
+var WorldBoundary2DFSM = class {
+  machine;
+  lastHits = { top: false, bottom: false, left: false, right: false };
+  lastPosition = null;
+  lastUpdatedAtMs = null;
+  constructor() {
+    this.machine = new SyncStateMachine(
+      "inside" /* Inside */,
+      [
+        t("inside" /* Inside */, "touch-boundary" /* TouchBoundary */, "touching" /* Touching */),
+        t("touching" /* Touching */, "enter-inside" /* EnterInside */, "inside" /* Inside */),
+        // Self transitions (no-ops)
+        t("inside" /* Inside */, "enter-inside" /* EnterInside */, "inside" /* Inside */),
+        t("touching" /* Touching */, "touch-boundary" /* TouchBoundary */, "touching" /* Touching */)
+      ]
+    );
+  }
+  getState() {
+    return this.machine.getState();
+  }
+  /**
+   * Returns the last computed hits (always available after first update call).
+   */
+  getLastHits() {
+    return this.lastHits;
+  }
+  /**
+   * Returns adjusted movement values based on boundary hits.
+   * If the entity is touching a boundary and trying to move further into it,
+   * that axis component is zeroed out.
+   *
+   * @param moveX - The desired X movement
+   * @param moveY - The desired Y movement
+   * @returns Adjusted { moveX, moveY } with boundary-blocked axes zeroed
+   */
+  getMovement(moveX, moveY) {
+    return constrainMovementToBounds2D(this.lastHits, moveX, moveY);
+  }
+  /**
+   * Returns the last position passed to `update`, if any.
+   */
+  getLastPosition() {
+    return this.lastPosition;
+  }
+  /**
+   * Best-effort timestamp (ms) of the last `update(...)` call.
+   * This is optional metadata; systems can ignore it.
+   */
+  getLastUpdatedAtMs() {
+    return this.lastUpdatedAtMs;
+  }
+  /**
+   * Update FSM + extended state based on current position and bounds.
+   * Returns the computed hits for convenience.
+   */
+  update(position, bounds) {
+    const hits = computeWorldBoundary2DHits(position, bounds);
+    this.lastHits = hits;
+    this.lastPosition = { x: position.x, y: position.y };
+    this.lastUpdatedAtMs = Date.now();
+    if (hasAnyWorldBoundary2DHit(hits)) {
+      this.dispatch("touch-boundary" /* TouchBoundary */);
+    } else {
+      this.dispatch("enter-inside" /* EnterInside */);
+    }
+    return hits;
+  }
+  dispatch(event) {
+    if (this.machine.can(event)) {
+      this.machine.syncDispatch(event);
+    }
+  }
+};
+
+// src/lib/behaviors/world-boundary-2d/world-boundary-2d.descriptor.ts
+var defaultOptions = {
+  boundaries: { top: 0, bottom: 0, left: 0, right: 0 }
+};
+var WORLD_BOUNDARY_BEHAVIOR_KEY = /* @__PURE__ */ Symbol.for(
+  "zylem:behavior:world-boundary-2d"
+);
+function createWorldBoundary2DHandle(ref) {
+  return {
+    getLastHits: () => {
+      const fsm = ref.fsm;
+      return fsm?.getLastHits() ?? null;
+    },
+    getMovement: (moveX, moveY) => {
+      const fsm = ref.fsm;
+      return fsm?.getMovement(moveX, moveY) ?? { moveX, moveY };
+    }
+  };
+}
+var WorldBoundary2DSystem = class {
+  constructor(world, getBehaviorLinks) {
+    this.world = world;
+    this.getBehaviorLinks = getBehaviorLinks;
+  }
+  update(_ecs, _delta) {
+    const links = this.getBehaviorLinks?.(WORLD_BOUNDARY_BEHAVIOR_KEY);
+    if (!links) return;
+    for (const link of links) {
+      const gameEntity = link.entity;
+      const boundaryRef = link.ref;
+      if (!gameEntity.body) continue;
+      const options = boundaryRef.options;
+      if (!boundaryRef.fsm) {
+        boundaryRef.fsm = new WorldBoundary2DFSM();
+      }
+      const body = gameEntity.body;
+      const pos = body.translation();
+      boundaryRef.fsm.update(
+        { x: pos.x, y: pos.y },
+        options.boundaries
+      );
+    }
+  }
+  destroy(_ecs) {
+  }
+};
+var WorldBoundary2DBehavior = defineBehavior({
+  name: "world-boundary-2d",
+  defaultOptions,
+  systemFactory: (ctx) => new WorldBoundary2DSystem(ctx.world, ctx.getBehaviorLinks),
+  createHandle: createWorldBoundary2DHandle
+});
+export {
+  WorldBoundary2DBehavior,
+  WorldBoundary2DEvent,
+  WorldBoundary2DFSM,
+  WorldBoundary2DState,
+  computeWorldBoundary2DHits,
+  hasAnyWorldBoundary2DHit
+};
+//# sourceMappingURL=world-boundary-2d.js.map

package/dist/behavior/world-boundary-2d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/behaviors/behavior-descriptor.ts","../../src/lib/core/utility/sync-state-machine.ts","../../src/lib/behaviors/shared/bounds-2d.ts","../../src/lib/behaviors/world-boundary-2d/world-boundary-2d-fsm.ts","../../src/lib/behaviors/world-boundary-2d/world-boundary-2d.descriptor.ts"],"sourcesContent":["/**\n * BehaviorDescriptor\n *\n * Type-safe behavior descriptors that provide options inference.\n * Used with entity.use() to declaratively attach behaviors to entities.\n *\n * Each behavior can define its own handle type via `createHandle`,\n * providing behavior-specific methods with full type safety.\n */\n\nimport type { BehaviorSystemFactory } from './behavior-system';\n\n/**\n * Base handle returned by entity.use() for lazy access to behavior runtime.\n * FSM is null until entity is spawned and components are initialized.\n */\nexport interface BaseBehaviorHandle<\n  O extends Record<string, any> = Record<string, any>,\n> {\n  /** Get the FSM instance (null until entity is spawned) */\n  getFSM(): any | null;\n  /** Get the current options */\n  getOptions(): O;\n  /** Access the underlying behavior ref */\n  readonly ref: BehaviorRef<O>;\n}\n\n/**\n * Reference to a behavior stored on an entity\n */\nexport interface BehaviorRef<\n  O extends Record<string, any> = Record<string, any>,\n> {\n  /** The behavior descriptor */\n  descriptor: BehaviorDescriptor<O, any>;\n  /** Merged options (defaults + overrides) */\n  options: O;\n  /** Optional FSM instance - set lazily when entity is spawned */\n  fsm?: any;\n}\n\n/**\n * A typed behavior descriptor that associates a symbol key with:\n * - Default options (providing type inference)\n * - A system factory to create the behavior system\n * - An optional handle factory for behavior-specific methods\n */\nexport interface BehaviorDescriptor<\n  O extends Record<string, any> = Record<string, any>,\n  H extends Record<string, any> = Record<string, never>,\n  I = unknown,\n> {\n  /** Unique symbol identifying this behavior */\n  readonly key: symbol;\n  /** Default options (used for type inference) */\n  readonly defaultOptions: O;\n  /** Factory to create the behavior system */\n  readonly systemFactory: BehaviorSystemFactory;\n  /**\n   * Optional factory to create behavior-specific handle methods.\n   * These methods are merged into the handle returned by entity.use().\n   */\n  readonly createHandle?: (ref: BehaviorRef<O>) => H;\n}\n\n/**\n * The full handle type returned by entity.use().\n * Combines base handle with behavior-specific methods.\n */\nexport type BehaviorHandle<\n  O extends Record<string, any> = Record<string, any>,\n  H extends Record<string, any> = Record<string, never>,\n> = BaseBehaviorHandle<O> & H;\n\n/**\n * Configuration for defining a new behavior\n */\nexport interface DefineBehaviorConfig<\n  O extends Record<string, any>,\n  H extends Record<string, any> = Record<string, never>,\n  I = unknown,\n> {\n  /** Human-readable name for debugging */\n  name: string;\n  /** Default options - these define the type */\n  defaultOptions: O;\n  /** Factory function to create the system */\n  systemFactory: BehaviorSystemFactory;\n  /**\n   * Optional factory to create behavior-specific handle methods.\n   * The returned object is merged into the handle returned by entity.use().\n   *\n   * @example\n   * ```typescript\n   * createHandle: (ref) => ({\n   *   getLastHits: () => ref.fsm?.getLastHits() ?? null,\n   *   getMovement: (moveX, moveY) => ref.fsm?.getMovement(moveX, moveY) ?? { moveX, moveY },\n   * }),\n   * ```\n   */\n  createHandle?: (ref: BehaviorRef<O>) => H;\n}\n\n/**\n * Define a typed behavior descriptor.\n *\n * @example\n * ```typescript\n * export const WorldBoundary2DBehavior = defineBehavior({\n *   name: 'world-boundary-2d',\n *   defaultOptions: { boundaries: { top: 0, bottom: 0, left: 0, right: 0 } },\n *   systemFactory: (ctx) => new WorldBoundary2DSystem(ctx.world),\n *   createHandle: (ref) => ({\n *     getLastHits: () => ref.fsm?.getLastHits() ?? null,\n *     getMovement: (moveX: number, moveY: number) =>\n *       ref.fsm?.getMovement(moveX, moveY) ?? { moveX, moveY },\n *   }),\n * });\n *\n * // Usage - handle has getLastHits and getMovement with full types\n * const boundary = ship.use(WorldBoundary2DBehavior, { ... });\n * const hits = boundary.getLastHits(); // Fully typed!\n * ```\n */\nexport function defineBehavior<\n  O extends Record<string, any>,\n  H extends Record<string, any> = Record<string, never>,\n  I = unknown,\n>(\n  config: DefineBehaviorConfig<O, H, I>,\n): BehaviorDescriptor<O, H, I> {\n  return {\n    key: Symbol.for(`zylem:behavior:${config.name}`),\n    defaultOptions: config.defaultOptions,\n    systemFactory: config.systemFactory,\n    createHandle: config.createHandle,\n  };\n}\n","import {\n\tStateMachine as BaseStateMachine,\n\ttype ILogger,\n\ttype ITransition,\n\ttype SyncCallback,\n} from 'typescript-fsm';\n\nexport { t } from 'typescript-fsm';\nexport type { ILogger, ITransition, SyncCallback };\n\n/**\n * Local wrapper around typescript-fsm's SyncStateMachine.\n *\n * typescript-fsm@1.6.0 incorrectly reports callback-less transitions as\n * unhandled even after moving to the next state, which causes noisy\n * `No transition...` console errors for valid FSM dispatches.\n */\nexport class SyncStateMachine<\n\tSTATE extends string | number | symbol,\n\tEVENT extends string | number | symbol,\n\tCALLBACK extends Record<EVENT, SyncCallback> = Record<EVENT, SyncCallback>,\n> extends BaseStateMachine<STATE, EVENT, CALLBACK> {\n\tconstructor(\n\t\tinit: STATE,\n\t\ttransitions: ITransition<STATE, EVENT, CALLBACK[EVENT]>[] = [],\n\t\tlogger: ILogger = console,\n\t) {\n\t\tsuper(init, transitions, logger);\n\t}\n\n\tdispatch<E extends EVENT>(_event: E, ..._args: unknown[]): Promise<void> {\n\t\tthrow new Error('SyncStateMachine does not support async dispatch.');\n\t}\n\n\tsyncDispatch<E extends EVENT>(event: E, ...args: unknown[]): boolean {\n\t\tconst found = this.transitions.some((transition) => {\n\t\t\tif (transition.fromState !== this._current || transition.event !== event) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\tconst current = this._current;\n\t\t\tthis._current = transition.toState;\n\n\t\t\tif (!transition.cb) {\n\t\t\t\treturn true;\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\ttransition.cb(...args);\n\t\t\t\treturn true;\n\t\t\t} catch (error) {\n\t\t\t\tthis._current = current;\n\t\t\t\tthis.logger.error('Exception in callback', error);\n\t\t\t\tthrow error;\n\t\t\t}\n\t\t});\n\n\t\tif (!found) {\n\t\t\tconst errorMessage = this.formatErr(this._current, event);\n\t\t\tthis.logger.error(errorMessage);\n\t\t}\n\n\t\treturn found;\n\t}\n}\n","export interface Bounds2DPoint {\n\tx: number;\n\ty: number;\n}\n\nexport interface Bounds2DRect {\n\tminX: number;\n\tmaxX: number;\n\tminY: number;\n\tmaxY: number;\n}\n\nexport interface Bounds2DSize {\n\twidth: number;\n\theight: number;\n\tcenterX?: number;\n\tcenterY?: number;\n}\n\nexport interface Bounds2DHits {\n\tleft: boolean;\n\tright: boolean;\n\ttop: boolean;\n\tbottom: boolean;\n}\n\nexport interface Bounds2DWrapResult {\n\tx: number;\n\ty: number;\n\twrapped: boolean;\n}\n\nexport function createBounds2DRect({\n\twidth,\n\theight,\n\tcenterX = 0,\n\tcenterY = 0,\n}: Bounds2DSize): Bounds2DRect {\n\tconst halfWidth = width / 2;\n\tconst halfHeight = height / 2;\n\treturn {\n\t\tminX: centerX - halfWidth,\n\t\tmaxX: centerX + halfWidth,\n\t\tminY: centerY - halfHeight,\n\t\tmaxY: centerY + halfHeight,\n\t};\n}\n\nexport function computeBounds2DHits(\n\tposition: Bounds2DPoint,\n\tbounds: Bounds2DRect,\n): Bounds2DHits {\n\tconst hits: Bounds2DHits = {\n\t\ttop: false,\n\t\tbottom: false,\n\t\tleft: false,\n\t\tright: false,\n\t};\n\n\tif (position.x <= bounds.minX) hits.left = true;\n\telse if (position.x >= bounds.maxX) hits.right = true;\n\n\tif (position.y <= bounds.minY) hits.bottom = true;\n\telse if (position.y >= bounds.maxY) hits.top = true;\n\n\treturn hits;\n}\n\nexport function hasAnyBounds2DHit(hits: Bounds2DHits): boolean {\n\treturn hits.left || hits.right || hits.top || hits.bottom;\n}\n\nexport function constrainMovementToBounds2D(\n\thits: Bounds2DHits,\n\tmoveX: number,\n\tmoveY: number,\n): { moveX: number; moveY: number } {\n\tlet adjustedX = moveX;\n\tlet adjustedY = moveY;\n\n\tif ((hits.left && moveX < 0) || (hits.right && moveX > 0)) {\n\t\tadjustedX = 0;\n\t}\n\n\tif ((hits.bottom && moveY < 0) || (hits.top && moveY > 0)) {\n\t\tadjustedY = 0;\n\t}\n\n\treturn { moveX: adjustedX, moveY: adjustedY };\n}\n\nexport function wrapPoint2D(\n\tposition: Bounds2DPoint,\n\tbounds: Bounds2DRect,\n): Bounds2DWrapResult {\n\tlet x = position.x;\n\tlet y = position.y;\n\tlet wrapped = false;\n\n\tif (position.x < bounds.minX) {\n\t\tx = bounds.maxX - (bounds.minX - position.x);\n\t\twrapped = true;\n\t} else if (position.x > bounds.maxX) {\n\t\tx = bounds.minX + (position.x - bounds.maxX);\n\t\twrapped = true;\n\t}\n\n\tif (position.y < bounds.minY) {\n\t\ty = bounds.maxY - (bounds.minY - position.y);\n\t\twrapped = true;\n\t} else if (position.y > bounds.maxY) {\n\t\ty = bounds.minY + (position.y - bounds.maxY);\n\t\twrapped = true;\n\t}\n\n\treturn { x, y, wrapped };\n}\n\nexport function getBounds2DNormalFromHits(\n\thits: Bounds2DHits,\n): { x: number; y: number } {\n\tlet x = 0;\n\tlet y = 0;\n\n\tif (hits.left) x = 1;\n\tif (hits.right) x = -1;\n\tif (hits.bottom) y = 1;\n\tif (hits.top) y = -1;\n\n\treturn { x, y };\n}\n","/**\n * WorldBoundary2DFSM\n *\n * Minimal FSM + extended state to track which world boundaries were hit.\n *\n * Notes:\n * - \"Hit boundaries\" is inherently a *set* (can hit left+bottom in one frame),\n *   so we store it as extended state (`lastHits`) rather than a single FSM state.\n * - The FSM state is still useful for coarse status like \"inside\" vs \"touching\".\n */\n\nimport { SyncStateMachine, t } from '../../core/utility/sync-state-machine';\nimport {\n\tcomputeBounds2DHits,\n\tconstrainMovementToBounds2D,\n\thasAnyBounds2DHit,\n} from '../shared/bounds-2d';\n\nexport type WorldBoundary2DHit = 'top' | 'bottom' | 'left' | 'right';\nexport type WorldBoundary2DHits = Record<WorldBoundary2DHit, boolean>;\n\nexport interface WorldBoundary2DPosition {\n\tx: number;\n\ty: number;\n}\n\nexport interface WorldBoundary2DBounds {\n\ttop: number;\n\tbottom: number;\n\tleft: number;\n\tright: number;\n}\n\nexport enum WorldBoundary2DState {\n\tInside = 'inside',\n\tTouching = 'touching',\n}\n\nexport enum WorldBoundary2DEvent {\n\tEnterInside = 'enter-inside',\n\tTouchBoundary = 'touch-boundary',\n}\n\n/**\n * Compute which boundaries are being hit for a position and bounds.\n * This matches the semantics of the legacy `boundary2d` behavior:\n * - left hit if x <= left\n * - right hit if x >= right\n * - bottom hit if y <= bottom\n * - top hit if y >= top\n */\nexport function computeWorldBoundary2DHits(\n\tposition: WorldBoundary2DPosition,\n\tbounds: WorldBoundary2DBounds\n): WorldBoundary2DHits {\n\treturn computeBounds2DHits(position, {\n\t\tminX: bounds.left,\n\t\tmaxX: bounds.right,\n\t\tminY: bounds.bottom,\n\t\tmaxY: bounds.top,\n\t});\n}\n\nexport function hasAnyWorldBoundary2DHit(hits: WorldBoundary2DHits): boolean {\n\treturn hasAnyBounds2DHit(hits);\n}\n\n/**\n * FSM wrapper with \"extended state\" (lastHits / lastPosition).\n * Systems should call `update(...)` once per frame.\n */\nexport class WorldBoundary2DFSM {\n\tpublic readonly machine: SyncStateMachine<WorldBoundary2DState, WorldBoundary2DEvent, never>;\n\n\tprivate lastHits: WorldBoundary2DHits = { top: false, bottom: false, left: false, right: false };\n\tprivate lastPosition: WorldBoundary2DPosition | null = null;\n\tprivate lastUpdatedAtMs: number | null = null;\n\n\tconstructor() {\n\t\tthis.machine = new SyncStateMachine<WorldBoundary2DState, WorldBoundary2DEvent, never>(\n\t\t\tWorldBoundary2DState.Inside,\n\t\t\t[\n\t\t\t\tt(WorldBoundary2DState.Inside, WorldBoundary2DEvent.TouchBoundary, WorldBoundary2DState.Touching),\n\t\t\t\tt(WorldBoundary2DState.Touching, WorldBoundary2DEvent.EnterInside, WorldBoundary2DState.Inside),\n\n\t\t\t\t// Self transitions (no-ops)\n\t\t\t\tt(WorldBoundary2DState.Inside, WorldBoundary2DEvent.EnterInside, WorldBoundary2DState.Inside),\n\t\t\t\tt(WorldBoundary2DState.Touching, WorldBoundary2DEvent.TouchBoundary, WorldBoundary2DState.Touching),\n\t\t\t]\n\t\t);\n\t}\n\n\tgetState(): WorldBoundary2DState {\n\t\treturn this.machine.getState();\n\t}\n\n\t/**\n\t * Returns the last computed hits (always available after first update call).\n\t */\n\tgetLastHits(): WorldBoundary2DHits {\n\t\treturn this.lastHits;\n\t}\n\n\t/**\n\t * Returns adjusted movement values based on boundary hits.\n\t * If the entity is touching a boundary and trying to move further into it,\n\t * that axis component is zeroed out.\n\t *\n\t * @param moveX - The desired X movement\n\t * @param moveY - The desired Y movement\n\t * @returns Adjusted { moveX, moveY } with boundary-blocked axes zeroed\n\t */\n\tgetMovement(moveX: number, moveY: number): { moveX: number; moveY: number } {\n\t\treturn constrainMovementToBounds2D(this.lastHits, moveX, moveY);\n\t}\n\n\t/**\n\t * Returns the last position passed to `update`, if any.\n\t */\n\tgetLastPosition(): WorldBoundary2DPosition | null {\n\t\treturn this.lastPosition;\n\t}\n\n\t/**\n\t * Best-effort timestamp (ms) of the last `update(...)` call.\n\t * This is optional metadata; systems can ignore it.\n\t */\n\tgetLastUpdatedAtMs(): number | null {\n\t\treturn this.lastUpdatedAtMs;\n\t}\n\n\t/**\n\t * Update FSM + extended state based on current position and bounds.\n\t * Returns the computed hits for convenience.\n\t */\n\tupdate(position: WorldBoundary2DPosition, bounds: WorldBoundary2DBounds): WorldBoundary2DHits {\n\t\tconst hits = computeWorldBoundary2DHits(position, bounds);\n\n\t\tthis.lastHits = hits;\n\t\tthis.lastPosition = { x: position.x, y: position.y };\n\t\tthis.lastUpdatedAtMs = Date.now();\n\n\t\tif (hasAnyWorldBoundary2DHit(hits)) {\n\t\t\tthis.dispatch(WorldBoundary2DEvent.TouchBoundary);\n\t\t} else {\n\t\t\tthis.dispatch(WorldBoundary2DEvent.EnterInside);\n\t\t}\n\n\t\treturn hits;\n\t}\n\n\tprivate dispatch(event: WorldBoundary2DEvent): void {\n\t\tif (this.machine.can(event)) {\n\t\t\tthis.machine.syncDispatch(event);\n\t\t}\n\t}\n}\n","/**\n * WorldBoundary2DBehavior\n *\n * Tracks which 2D world boundaries an entity is touching.\n * Use `getMovement()` on the behavior handle to adjust movement based on hits.\n *\n * Source of truth: `entity.body` (Rapier rigid body), consistent with other new behaviors.\n */\n\nimport type { IWorld } from 'bitecs';\nimport { defineBehavior, type BehaviorRef } from '../behavior-descriptor';\nimport type { BehaviorEntityLink, BehaviorSystem } from '../behavior-system';\nimport {\n\tWorldBoundary2DFSM,\n\ttype WorldBoundary2DBounds,\n\ttype WorldBoundary2DHits,\n} from './world-boundary-2d-fsm';\n\nexport interface WorldBoundary2DOptions {\n\t/**\n\t * World boundaries (in world units).\n\t * - left hit if x <= left\n\t * - right hit if x >= right\n\t * - bottom hit if y <= bottom\n\t * - top hit if y >= top\n\t */\n\tboundaries: WorldBoundary2DBounds;\n}\n\n/**\n * Handle methods provided by WorldBoundary2DBehavior\n */\nexport interface WorldBoundary2DHandle {\n\t/**\n\t * Get the last computed boundary hits.\n\t * Returns null until entity is spawned and FSM is initialized.\n\t */\n\tgetLastHits(): WorldBoundary2DHits | null;\n\n\t/**\n\t * Get adjusted movement values based on boundary hits.\n\t * Zeros out movement into boundaries the entity is touching.\n\t */\n\tgetMovement(moveX: number, moveY: number): { moveX: number; moveY: number };\n}\n\nconst defaultOptions: WorldBoundary2DOptions = {\n\tboundaries: { top: 0, bottom: 0, left: 0, right: 0 },\n};\n\nconst WORLD_BOUNDARY_BEHAVIOR_KEY = Symbol.for(\n\t'zylem:behavior:world-boundary-2d',\n);\n\n/**\n * Creates behavior-specific handle methods for WorldBoundary2DBehavior.\n */\nfunction createWorldBoundary2DHandle(\n\tref: BehaviorRef<WorldBoundary2DOptions>\n): WorldBoundary2DHandle {\n\treturn {\n\t\tgetLastHits: () => {\n\t\t\tconst fsm = ref.fsm as WorldBoundary2DFSM | undefined;\n\t\t\treturn fsm?.getLastHits() ?? null;\n\t\t},\n\t\tgetMovement: (moveX: number, moveY: number) => {\n\t\t\tconst fsm = ref.fsm as WorldBoundary2DFSM | undefined;\n\t\t\treturn fsm?.getMovement(moveX, moveY) ?? { moveX, moveY };\n\t\t},\n\t};\n}\n\n/**\n * WorldBoundary2DSystem\n *\n * Stage-level system that:\n * - finds entities with this behavior attached\n * - computes and tracks boundary hits using the FSM\n */\nclass WorldBoundary2DSystem implements BehaviorSystem {\n\tconstructor(\n\t\tprivate world: any,\n\t\tprivate getBehaviorLinks?: (key: symbol) => Iterable<BehaviorEntityLink>,\n\t) {}\n\n\tupdate(_ecs: IWorld, _delta: number): void {\n\t\tconst links = this.getBehaviorLinks?.(WORLD_BOUNDARY_BEHAVIOR_KEY);\n\t\tif (!links) return;\n\n\t\tfor (const link of links) {\n\t\t\tconst gameEntity = link.entity as any;\n\t\t\tconst boundaryRef = link.ref as any;\n\t\t\tif (!gameEntity.body) continue;\n\n\t\t\tconst options = boundaryRef.options as WorldBoundary2DOptions;\n\n\t\t\t// Create FSM lazily on first update after spawn\n\t\t\tif (!boundaryRef.fsm) {\n\t\t\t\tboundaryRef.fsm = new WorldBoundary2DFSM();\n\t\t\t}\n\n\t\t\tconst body = gameEntity.body;\n\t\t\tconst pos = body.translation();\n\n\t\t\t// Update FSM with current position - consumers use getMovement() to act on hits\n\t\t\tboundaryRef.fsm.update(\n\t\t\t\t{ x: pos.x, y: pos.y },\n\t\t\t\toptions.boundaries\n\t\t\t);\n\t\t}\n\t}\n\n\tdestroy(_ecs: IWorld): void {\n\t\t// No explicit cleanup required (FSMs are stored on behavior refs)\n\t}\n}\n\n/**\n * WorldBoundary2DBehavior\n *\n * @example\n * ```ts\n * import { WorldBoundary2DBehavior } from \"@zylem/game-lib\";\n *\n * const ship = createSprite({ ... });\n * const boundary = ship.use(WorldBoundary2DBehavior, {\n *   boundaries: { left: -10, right: 10, bottom: -7.5, top: 7.5 },\n * });\n *\n * ship.onUpdate(({ me }) => {\n *   let moveX = ..., moveY = ...;\n *   const hits = boundary.getLastHits(); // Fully typed!\n *   ({ moveX, moveY } = boundary.getMovement(moveX, moveY));\n *   me.moveXY(moveX, moveY);\n * });\n * ```\n */\nexport const WorldBoundary2DBehavior = defineBehavior({\n\tname: 'world-boundary-2d',\n\tdefaultOptions,\n\tsystemFactory: (ctx) =>\n\t\tnew WorldBoundary2DSystem(ctx.world, ctx.getBehaviorLinks),\n\tcreateHandle: createWorldBoundary2DHandle,\n});\n"],"mappings":"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","names":["WorldBoundary2DState","WorldBoundary2DEvent"]}

package/dist/behavior/world-boundary-3d.d.ts

@@ -0,0 +1,76 @@
+import { c as BehaviorDescriptor } from '../behavior-descriptor-BXnVR8Ki.js';
+import { S as SyncStateMachine } from '../sync-state-machine-CZyspBpj.js';
+import 'bitecs';
+import 'typescript-fsm';
+
+interface Bounds3DPoint {
+    x: number;
+    y: number;
+    z: number;
+}
+interface Bounds3DPadding {
+    x: number;
+    y: number;
+    z: number;
+}
+type Bounds3DPaddingInput = number | Partial<Bounds3DPadding> | undefined;
+
+type WorldBoundary3DHit = 'top' | 'bottom' | 'left' | 'right' | 'back' | 'front';
+type WorldBoundary3DHits = Record<WorldBoundary3DHit, boolean>;
+interface WorldBoundary3DPosition extends Bounds3DPoint {
+}
+interface WorldBoundary3DBounds {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    back: number;
+    front: number;
+}
+declare enum WorldBoundary3DState {
+    Inside = "inside",
+    Touching = "touching"
+}
+declare enum WorldBoundary3DEvent {
+    EnterInside = "enter-inside",
+    TouchBoundary = "touch-boundary"
+}
+declare function computeWorldBoundary3DHits(position: WorldBoundary3DPosition, bounds: WorldBoundary3DBounds, padding?: Bounds3DPaddingInput): WorldBoundary3DHits;
+declare function hasAnyWorldBoundary3DHit(hits: WorldBoundary3DHits): boolean;
+declare class WorldBoundary3DFSM {
+    readonly machine: SyncStateMachine<WorldBoundary3DState, WorldBoundary3DEvent, never>;
+    private lastHits;
+    private lastPosition;
+    private lastClampedPosition;
+    private lastUpdatedAtMs;
+    constructor();
+    getState(): WorldBoundary3DState;
+    getLastHits(): WorldBoundary3DHits;
+    getMovement(moveX: number, moveY: number, moveZ: number): {
+        moveX: number;
+        moveY: number;
+        moveZ: number;
+    };
+    getLastPosition(): WorldBoundary3DPosition | null;
+    getLastClampedPosition(): WorldBoundary3DPosition | null;
+    getLastUpdatedAtMs(): number | null;
+    update(position: WorldBoundary3DPosition, bounds: WorldBoundary3DBounds, padding?: Bounds3DPaddingInput): WorldBoundary3DHits;
+    private dispatch;
+}
+
+interface WorldBoundary3DOptions {
+    boundaries: WorldBoundary3DBounds;
+    padding?: Bounds3DPaddingInput;
+}
+interface WorldBoundary3DHandle {
+    getLastHits(): WorldBoundary3DHits | null;
+    getMovement(moveX: number, moveY: number, moveZ: number): {
+        moveX: number;
+        moveY: number;
+        moveZ: number;
+    };
+    getLastClampedPosition(): WorldBoundary3DPosition | null;
+}
+declare const WorldBoundary3DBehavior: BehaviorDescriptor<WorldBoundary3DOptions, WorldBoundary3DHandle, unknown>;
+
+export { WorldBoundary3DBehavior, type WorldBoundary3DBounds, WorldBoundary3DEvent, WorldBoundary3DFSM, type WorldBoundary3DHandle, type WorldBoundary3DHit, type WorldBoundary3DHits, type WorldBoundary3DOptions, type WorldBoundary3DPosition, WorldBoundary3DState, computeWorldBoundary3DHits, hasAnyWorldBoundary3DHit };