@zylem/behaviors 0.2.0

package/dist/chunk-K3UNLQ7W.js

@@ -0,0 +1,118 @@
+import {
+  defineBehavior
+} from "./chunk-EZNCCO4L.js";
+
+// src/lib/behaviors/cooldown/cooldown-store.ts
+import { proxy } from "valtio";
+var cooldownStore = proxy({});
+function registerCooldown(name, duration, immediate = true) {
+  cooldownStore[name] = {
+    name,
+    duration,
+    elapsed: immediate ? duration : 0,
+    ready: immediate,
+    progress: immediate ? 1 : 0,
+    active: !immediate
+  };
+}
+function getCooldown(name) {
+  return cooldownStore[name];
+}
+function fireCooldown(name) {
+  const entry = cooldownStore[name];
+  if (!entry) return;
+  entry.elapsed = 0;
+  entry.ready = false;
+  entry.progress = 0;
+  entry.active = true;
+}
+function resetCooldown(name) {
+  const entry = cooldownStore[name];
+  if (!entry) return;
+  entry.elapsed = entry.duration;
+  entry.ready = true;
+  entry.progress = 1;
+  entry.active = false;
+}
+function tickCooldowns(delta) {
+  for (const name in cooldownStore) {
+    const entry = cooldownStore[name];
+    if (!entry.active) continue;
+    entry.elapsed += delta;
+    if (entry.elapsed >= entry.duration) {
+      entry.elapsed = entry.duration;
+      entry.ready = true;
+      entry.progress = 1;
+      entry.active = false;
+    } else {
+      entry.progress = entry.duration > 0 ? entry.elapsed / entry.duration : 1;
+    }
+  }
+}
+function getCooldownStore() {
+  return cooldownStore;
+}
+
+// src/lib/behaviors/cooldown/cooldown-behavior.ts
+var COOLDOWN_BEHAVIOR_KEY = /* @__PURE__ */ Symbol.for("zylem:behavior:cooldown");
+var CooldownSystem = class {
+  constructor(getBehaviorLinks) {
+    this.getBehaviorLinks = getBehaviorLinks;
+  }
+  getBehaviorLinks;
+  update(_ecs, delta) {
+    const links = this.getBehaviorLinks?.(COOLDOWN_BEHAVIOR_KEY);
+    if (links) {
+      for (const link of links) {
+        ensureCooldownEntriesRegistered(link.ref);
+      }
+    }
+    tickCooldowns(delta);
+  }
+  destroy(_ecs) {
+  }
+};
+function createCooldownHandle(ref) {
+  ensureCooldownEntriesRegistered(ref);
+  return {
+    isReady: (name) => getCooldown(name)?.ready ?? false,
+    fire: (name) => fireCooldown(name),
+    reset: (name) => resetCooldown(name),
+    getProgress: (name) => getCooldown(name)?.progress ?? 1
+  };
+}
+function getCompiledCooldownEntries(ref) {
+  const compiled = ref.__compiledCooldownEntries;
+  if (compiled) return compiled;
+  const entries = Object.entries(ref.options.cooldowns).map(([name, config]) => ({
+    name,
+    duration: config.duration,
+    immediate: config.immediate ?? true
+  }));
+  ref.__compiledCooldownEntries = entries;
+  return entries;
+}
+function ensureCooldownEntriesRegistered(ref) {
+  if (ref.__cooldownsRegistered) return;
+  for (const entry of getCompiledCooldownEntries(ref)) {
+    registerCooldown(entry.name, entry.duration, entry.immediate);
+  }
+  ref.__cooldownsRegistered = true;
+}
+var CooldownBehavior = defineBehavior({
+  name: "cooldown",
+  defaultOptions: { cooldowns: {} },
+  systemFactory: (ctx) => new CooldownSystem(ctx.getBehaviorLinks),
+  createHandle: createCooldownHandle
+});
+
+export {
+  registerCooldown,
+  getCooldown,
+  fireCooldown,
+  resetCooldown,
+  tickCooldowns,
+  getCooldownStore,
+  CooldownBehavior
+};
+//# sourceMappingURL=chunk-K3UNLQ7W.js.map

package/dist/chunk-K3UNLQ7W.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/behaviors/cooldown/cooldown-store.ts","../src/lib/behaviors/cooldown/cooldown-behavior.ts"],"sourcesContent":["import { proxy } from 'valtio';\n\n/**\n * A single cooldown entry in the global store.\n */\nexport interface CooldownEntry {\n\t/** Identifier for this cooldown */\n\tname: string;\n\t/** Total cooldown time in seconds */\n\tduration: number;\n\t/** Time accumulated since last fire */\n\telapsed: number;\n\t/** Whether the cooldown is ready (elapsed >= duration) */\n\tready: boolean;\n\t/** Normalized progress 0..1 (0 = just fired, 1 = ready) */\n\tprogress: number;\n\t/** Whether this cooldown is currently counting down */\n\tactive: boolean;\n}\n\n/**\n * Global reactive cooldown registry (valtio proxy).\n * Accessible from entities, behaviors, and UI components.\n */\nconst cooldownStore = proxy<Record<string, CooldownEntry>>({});\n\n/**\n * Register a named cooldown in the global store.\n * If a cooldown with the same name already exists, it is overwritten.\n *\n * @param name Unique cooldown identifier\n * @param duration Cooldown duration in seconds\n * @param immediate If true, the cooldown starts ready (default: true)\n */\nexport function registerCooldown(\n\tname: string,\n\tduration: number,\n\timmediate: boolean = true,\n): void {\n\tcooldownStore[name] = {\n\t\tname,\n\t\tduration,\n\t\telapsed: immediate ? duration : 0,\n\t\tready: immediate,\n\t\tprogress: immediate ? 1 : 0,\n\t\tactive: !immediate,\n\t};\n}\n\n/**\n * Get a cooldown entry by name.\n * Returns undefined if the cooldown has not been registered.\n */\nexport function getCooldown(name: string): CooldownEntry | undefined {\n\treturn cooldownStore[name];\n}\n\n/**\n * Fire (trigger) a cooldown, resetting its timer.\n * Sets the cooldown to not-ready and starts the countdown.\n */\nexport function fireCooldown(name: string): void {\n\tconst entry = cooldownStore[name];\n\tif (!entry) return;\n\tentry.elapsed = 0;\n\tentry.ready = false;\n\tentry.progress = 0;\n\tentry.active = true;\n}\n\n/**\n * Force a cooldown to ready immediately.\n */\nexport function resetCooldown(name: string): void {\n\tconst entry = cooldownStore[name];\n\tif (!entry) return;\n\tentry.elapsed = entry.duration;\n\tentry.ready = true;\n\tentry.progress = 1;\n\tentry.active = false;\n}\n\n/**\n * Advance all active cooldowns by delta seconds.\n * Called once per frame by the CooldownBehavior system.\n */\nexport function tickCooldowns(delta: number): void {\n\tfor (const name in cooldownStore) {\n\t\tconst entry = cooldownStore[name];\n\t\tif (!entry.active) continue;\n\n\t\tentry.elapsed += delta;\n\t\tif (entry.elapsed >= entry.duration) {\n\t\t\tentry.elapsed = entry.duration;\n\t\t\tentry.ready = true;\n\t\t\tentry.progress = 1;\n\t\t\tentry.active = false;\n\t\t} else {\n\t\t\tentry.progress = entry.duration > 0 ? entry.elapsed / entry.duration : 1;\n\t\t}\n\t}\n}\n\n/**\n * Get the raw cooldown store (for advanced/debugging use).\n */\nexport function getCooldownStore(): Record<string, CooldownEntry> {\n\treturn cooldownStore;\n}\n","/**\n * CooldownBehavior\n *\n * A stage-scoped behavior that manages named cooldowns via the global CooldownStore.\n * Entities use this to register, check, and fire cooldowns.\n * UI components (CooldownIcon) can read from the same store.\n */\n\nimport { defineBehavior, type BehaviorRef } from '../behavior-descriptor';\nimport type { BehaviorEntityLink, BehaviorSystem } from '../behavior-system';\nimport {\n\tregisterCooldown,\n\tgetCooldown,\n\tfireCooldown,\n\tresetCooldown,\n\ttickCooldowns,\n} from './cooldown-store';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Options\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface CooldownConfig {\n\t/** Duration in seconds */\n\tduration: number;\n\t/** Whether the cooldown starts ready (default: true) */\n\timmediate?: boolean;\n}\n\nexport interface CooldownOptions {\n\t/**\n\t * Named cooldowns to register.\n\t * Keys are the cooldown names, values are their config.\n\t */\n\tcooldowns: Record<string, CooldownConfig>;\n}\n\ninterface CompiledCooldownEntry {\n\tname: string;\n\tduration: number;\n\timmediate: boolean;\n}\n\nconst COOLDOWN_BEHAVIOR_KEY = Symbol.for('zylem:behavior:cooldown');\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Handle\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Handle methods returned by entity.use(CooldownBehavior, ...).\n */\nexport interface CooldownHandle {\n\t/** Check if a named cooldown is ready */\n\tisReady(name: string): boolean;\n\t/** Fire (trigger) a named cooldown, resetting its timer */\n\tfire(name: string): void;\n\t/** Force a cooldown to ready immediately */\n\treset(name: string): void;\n\t/** Get cooldown progress 0..1 (0 = just fired, 1 = ready) */\n\tgetProgress(name: string): number;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// System\n// ─────────────────────────────────────────────────────────────────────────────\n\nclass CooldownSystem implements BehaviorSystem {\n\tconstructor(\n\t\tprivate getBehaviorLinks?: (key: symbol) => Iterable<BehaviorEntityLink>,\n\t) { }\n\n\tupdate(_ecs: unknown, delta: number): void {\n\t\tconst links = this.getBehaviorLinks?.(COOLDOWN_BEHAVIOR_KEY);\n\t\tif (links) {\n\t\t\tfor (const link of links) {\n\t\t\t\tensureCooldownEntriesRegistered(link.ref as BehaviorRef<CooldownOptions>);\n\t\t\t}\n\t\t}\n\n\t\ttickCooldowns(delta);\n\t}\n\n\tdestroy(_ecs: unknown): void { }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Handle factory\n// ─────────────────────────────────────────────────────────────────────────────\n\nfunction createCooldownHandle(ref: BehaviorRef<CooldownOptions>): CooldownHandle {\n\tensureCooldownEntriesRegistered(ref);\n\n\treturn {\n\t\tisReady: (name: string) => getCooldown(name)?.ready ?? false,\n\t\tfire: (name: string) => fireCooldown(name),\n\t\treset: (name: string) => resetCooldown(name),\n\t\tgetProgress: (name: string) => getCooldown(name)?.progress ?? 1,\n\t};\n}\n\nfunction getCompiledCooldownEntries(\n\tref: BehaviorRef<CooldownOptions>,\n): CompiledCooldownEntry[] {\n\tconst compiled = (ref as any).__compiledCooldownEntries as CompiledCooldownEntry[] | undefined;\n\tif (compiled) return compiled;\n\n\tconst entries = Object.entries(ref.options.cooldowns).map(([name, config]) => ({\n\t\tname,\n\t\tduration: config.duration,\n\t\timmediate: config.immediate ?? true,\n\t}));\n\t(ref as any).__compiledCooldownEntries = entries;\n\treturn entries;\n}\n\nfunction ensureCooldownEntriesRegistered(ref: BehaviorRef<CooldownOptions>): void {\n\tif ((ref as any).__cooldownsRegistered) return;\n\n\tfor (const entry of getCompiledCooldownEntries(ref)) {\n\t\tregisterCooldown(entry.name, entry.duration, entry.immediate);\n\t}\n\n\t(ref as any).__cooldownsRegistered = true;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Behavior Definition\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * CooldownBehavior\n *\n * @example\n * ```ts\n * import { CooldownBehavior } from '@zylem/game-lib/behavior';\n * import { moveBy } from '@zylem/game-lib/actions';\n *\n * const hero = createBox({ ... });\n * const cd = hero.use(CooldownBehavior, {\n *   cooldowns: {\n *     attack: { duration: 5 },\n *     dash: { duration: 2, immediate: false },\n *   },\n * });\n *\n * hero.onUpdate(({ me, inputs }) => {\n *   if (cd.isReady('attack') && inputs.p1.buttons.A.pressed) {\n *     cd.fire('attack');\n *     // perform attack\n *   }\n *   if (cd.isReady('dash') && inputs.p1.buttons.B.pressed) {\n *     cd.fire('dash');\n *     me.runAction(moveBy({ x: 10, duration: 0.3 }));\n *   }\n * });\n * ```\n */\nexport const CooldownBehavior = defineBehavior<CooldownOptions, CooldownHandle>({\n\tname: 'cooldown',\n\tdefaultOptions: { cooldowns: {} },\n\tsystemFactory: (ctx) =>\n\t\tnew CooldownSystem(ctx.getBehaviorLinks),\n\tcreateHandle: createCooldownHandle,\n});\n"],"mappings":"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","names":[]}

package/dist/chunk-KDY5N6J4.js

@@ -0,0 +1,82 @@
+// src/lib/behaviors/shared/bounds-2d.ts
+function createBounds2DRect({
+  width,
+  height,
+  centerX = 0,
+  centerY = 0
+}) {
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  return {
+    minX: centerX - halfWidth,
+    maxX: centerX + halfWidth,
+    minY: centerY - halfHeight,
+    maxY: centerY + halfHeight
+  };
+}
+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 };
+}
+function wrapPoint2D(position, bounds) {
+  let x = position.x;
+  let y = position.y;
+  let wrapped = false;
+  if (position.x < bounds.minX) {
+    x = bounds.maxX - (bounds.minX - position.x);
+    wrapped = true;
+  } else if (position.x > bounds.maxX) {
+    x = bounds.minX + (position.x - bounds.maxX);
+    wrapped = true;
+  }
+  if (position.y < bounds.minY) {
+    y = bounds.maxY - (bounds.minY - position.y);
+    wrapped = true;
+  } else if (position.y > bounds.maxY) {
+    y = bounds.minY + (position.y - bounds.maxY);
+    wrapped = true;
+  }
+  return { x, y, wrapped };
+}
+function getBounds2DNormalFromHits(hits) {
+  let x = 0;
+  let y = 0;
+  if (hits.left) x = 1;
+  if (hits.right) x = -1;
+  if (hits.bottom) y = 1;
+  if (hits.top) y = -1;
+  return { x, y };
+}
+
+export {
+  createBounds2DRect,
+  computeBounds2DHits,
+  hasAnyBounds2DHit,
+  constrainMovementToBounds2D,
+  wrapPoint2D,
+  getBounds2DNormalFromHits
+};
+//# sourceMappingURL=chunk-KDY5N6J4.js.map

package/dist/chunk-KDY5N6J4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/behaviors/shared/bounds-2d.ts"],"sourcesContent":["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"],"mappings":";AAgCO,SAAS,mBAAmB;AAAA,EAClC;AAAA,EACA;AAAA,EACA,UAAU;AAAA,EACV,UAAU;AACX,GAA+B;AAC9B,QAAM,YAAY,QAAQ;AAC1B,QAAM,aAAa,SAAS;AAC5B,SAAO;AAAA,IACN,MAAM,UAAU;AAAA,IAChB,MAAM,UAAU;AAAA,IAChB,MAAM,UAAU;AAAA,IAChB,MAAM,UAAU;AAAA,EACjB;AACD;AAEO,SAAS,oBACf,UACA,QACe;AACf,QAAM,OAAqB;AAAA,IAC1B,KAAK;AAAA,IACL,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,OAAO;AAAA,EACR;AAEA,MAAI,SAAS,KAAK,OAAO,KAAM,MAAK,OAAO;AAAA,WAClC,SAAS,KAAK,OAAO,KAAM,MAAK,QAAQ;AAEjD,MAAI,SAAS,KAAK,OAAO,KAAM,MAAK,SAAS;AAAA,WACpC,SAAS,KAAK,OAAO,KAAM,MAAK,MAAM;AAE/C,SAAO;AACR;AAEO,SAAS,kBAAkB,MAA6B;AAC9D,SAAO,KAAK,QAAQ,KAAK,SAAS,KAAK,OAAO,KAAK;AACpD;AAEO,SAAS,4BACf,MACA,OACA,OACmC;AACnC,MAAI,YAAY;AAChB,MAAI,YAAY;AAEhB,MAAK,KAAK,QAAQ,QAAQ,KAAO,KAAK,SAAS,QAAQ,GAAI;AAC1D,gBAAY;AAAA,EACb;AAEA,MAAK,KAAK,UAAU,QAAQ,KAAO,KAAK,OAAO,QAAQ,GAAI;AAC1D,gBAAY;AAAA,EACb;AAEA,SAAO,EAAE,OAAO,WAAW,OAAO,UAAU;AAC7C;AAEO,SAAS,YACf,UACA,QACqB;AACrB,MAAI,IAAI,SAAS;AACjB,MAAI,IAAI,SAAS;AACjB,MAAI,UAAU;AAEd,MAAI,SAAS,IAAI,OAAO,MAAM;AAC7B,QAAI,OAAO,QAAQ,OAAO,OAAO,SAAS;AAC1C,cAAU;AAAA,EACX,WAAW,SAAS,IAAI,OAAO,MAAM;AACpC,QAAI,OAAO,QAAQ,SAAS,IAAI,OAAO;AACvC,cAAU;AAAA,EACX;AAEA,MAAI,SAAS,IAAI,OAAO,MAAM;AAC7B,QAAI,OAAO,QAAQ,OAAO,OAAO,SAAS;AAC1C,cAAU;AAAA,EACX,WAAW,SAAS,IAAI,OAAO,MAAM;AACpC,QAAI,OAAO,QAAQ,SAAS,IAAI,OAAO;AACvC,cAAU;AAAA,EACX;AAEA,SAAO,EAAE,GAAG,GAAG,QAAQ;AACxB;AAEO,SAAS,0BACf,MAC2B;AAC3B,MAAI,IAAI;AACR,MAAI,IAAI;AAER,MAAI,KAAK,KAAM,KAAI;AACnB,MAAI,KAAK,MAAO,KAAI;AACpB,MAAI,KAAK,OAAQ,KAAI;AACrB,MAAI,KAAK,IAAK,KAAI;AAElB,SAAO,EAAE,GAAG,EAAE;AACf;","names":[]}

package/dist/chunk-KOZUNIIE.js

@@ -0,0 +1,413 @@
+import {
+  StageRicochetDim,
+  StageRicochetReflection
+} from "./chunk-Y6UJOUE5.js";
+import {
+  SyncStateMachine,
+  t
+} from "./chunk-4URF65BR.js";
+import {
+  defineBehavior
+} from "./chunk-EZNCCO4L.js";
+
+// src/lib/behaviors/ricochet-2d/ricochet-2d-fsm.ts
+var Ricochet2DState = /* @__PURE__ */ ((Ricochet2DState2) => {
+  Ricochet2DState2["Idle"] = "idle";
+  Ricochet2DState2["Ricocheting"] = "ricocheting";
+  return Ricochet2DState2;
+})(Ricochet2DState || {});
+var Ricochet2DEvent = /* @__PURE__ */ ((Ricochet2DEvent2) => {
+  Ricochet2DEvent2["StartRicochet"] = "start-ricochet";
+  Ricochet2DEvent2["EndRicochet"] = "end-ricochet";
+  return Ricochet2DEvent2;
+})(Ricochet2DEvent || {});
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+var Ricochet2DFSM = class {
+  machine;
+  lastResult = null;
+  lastUpdatedAtMs = null;
+  currentTimeMs = 0;
+  listeners = /* @__PURE__ */ new Set();
+  constructor() {
+    this.machine = new SyncStateMachine(
+      "idle" /* Idle */,
+      [
+        t("idle" /* Idle */, "start-ricochet" /* StartRicochet */, "ricocheting" /* Ricocheting */),
+        t("ricocheting" /* Ricocheting */, "end-ricochet" /* EndRicochet */, "idle" /* Idle */),
+        // Self transitions (no-ops)
+        t("idle" /* Idle */, "end-ricochet" /* EndRicochet */, "idle" /* Idle */),
+        t("ricocheting" /* Ricocheting */, "start-ricochet" /* StartRicochet */, "ricocheting" /* Ricocheting */)
+      ]
+    );
+  }
+  /**
+   * Add a listener for ricochet events.
+   * @returns Unsubscribe function
+   */
+  addListener(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  /**
+   * Emit result to all listeners.
+   */
+  emitToListeners(result) {
+    for (const callback of this.listeners) {
+      try {
+        callback(result);
+      } catch (e) {
+        console.error("[Ricochet2DFSM] Listener error:", e);
+      }
+    }
+  }
+  getState() {
+    return this.machine.getState();
+  }
+  /**
+   * Returns the last computed ricochet result, or null if none.
+   */
+  getLastResult() {
+    return this.lastResult;
+  }
+  /**
+   * Best-effort timestamp (ms) of the last computation.
+   */
+  getLastUpdatedAtMs() {
+    return this.lastUpdatedAtMs;
+  }
+  /**
+   * Set current game time (called by system each frame).
+   * Used for cooldown calculations.
+   */
+  setCurrentTimeMs(timeMs) {
+    this.currentTimeMs = timeMs;
+  }
+  /**
+   * Check if ricochet is on cooldown (to prevent rapid duplicate applications).
+   * @param cooldownMs Cooldown duration in milliseconds (default: 50ms)
+   */
+  isOnCooldown(cooldownMs = 50) {
+    if (this.lastUpdatedAtMs === null) return false;
+    return this.currentTimeMs - this.lastUpdatedAtMs < cooldownMs;
+  }
+  /**
+   * Reset cooldown state (e.g., on entity respawn).
+   */
+  resetCooldown() {
+    this.lastUpdatedAtMs = null;
+  }
+  /**
+   * Compute a ricochet result from collision context.
+   * Returns the result for the consumer to apply, or null if invalid input.
+   */
+  computeRicochet(ctx, options = {}) {
+    const {
+      minSpeed = 2,
+      maxSpeed = 20,
+      speedMultiplier = 1.05,
+      reflectionMode = "angled",
+      maxAngleDeg = 60
+    } = options;
+    const { selfVelocity, selfPosition, otherPosition, otherSize } = this.extractDataFromEntities(ctx);
+    if (!selfVelocity) {
+      this.dispatch("end-ricochet" /* EndRicochet */);
+      return null;
+    }
+    const speed = Math.hypot(selfVelocity.x, selfVelocity.y);
+    if (speed === 0) {
+      this.dispatch("end-ricochet" /* EndRicochet */);
+      return null;
+    }
+    const normal = ctx.contact.normal ?? this.computeNormalFromPositions(selfPosition, otherPosition);
+    if (!normal) {
+      this.dispatch("end-ricochet" /* EndRicochet */);
+      return null;
+    }
+    let reflected = this.computeBasicReflection(selfVelocity, normal);
+    if (reflectionMode === "angled") {
+      reflected = this.computeAngledDeflection(
+        selfVelocity,
+        normal,
+        speed,
+        maxAngleDeg,
+        speedMultiplier,
+        selfPosition,
+        otherPosition,
+        otherSize,
+        ctx.contact.position
+      );
+    }
+    reflected = this.applySpeedClamp(reflected, minSpeed, maxSpeed);
+    const result = {
+      velocity: { x: reflected.x, y: reflected.y, z: 0 },
+      speed: Math.hypot(reflected.x, reflected.y),
+      normal: { x: normal.x, y: normal.y, z: 0 }
+    };
+    this.lastResult = result;
+    this.lastUpdatedAtMs = this.currentTimeMs;
+    this.dispatch("start-ricochet" /* StartRicochet */);
+    this.emitToListeners(result);
+    return result;
+  }
+  /**
+   * Extract velocity, position, and size data from entities or context.
+   */
+  extractDataFromEntities(ctx) {
+    let selfVelocity = ctx.selfVelocity;
+    let selfPosition = ctx.selfPosition;
+    let otherPosition = ctx.otherPosition;
+    let otherSize = ctx.otherSize;
+    if (ctx.entity?.body) {
+      const vel = ctx.entity.body.linvel();
+      selfVelocity = selfVelocity ?? { x: vel.x, y: vel.y, z: vel.z };
+      const pos = ctx.entity.body.translation();
+      selfPosition = selfPosition ?? { x: pos.x, y: pos.y, z: pos.z };
+    }
+    if (ctx.otherEntity?.body) {
+      const pos = ctx.otherEntity.body.translation();
+      otherPosition = otherPosition ?? { x: pos.x, y: pos.y, z: pos.z };
+    }
+    if (ctx.otherEntity && "size" in ctx.otherEntity) {
+      const size = ctx.otherEntity.size;
+      if (size && typeof size.x === "number") {
+        otherSize = otherSize ?? { x: size.x, y: size.y, z: size.z };
+      }
+    }
+    return { selfVelocity, selfPosition, otherPosition, otherSize };
+  }
+  /**
+   * Compute collision normal from entity positions using AABB heuristic.
+   */
+  computeNormalFromPositions(selfPosition, otherPosition) {
+    if (!selfPosition || !otherPosition) return null;
+    const dx = selfPosition.x - otherPosition.x;
+    const dy = selfPosition.y - otherPosition.y;
+    if (Math.abs(dx) > Math.abs(dy)) {
+      return { x: dx > 0 ? 1 : -1, y: 0, z: 0 };
+    } else {
+      return { x: 0, y: dy > 0 ? 1 : -1, z: 0 };
+    }
+  }
+  /**
+   * Compute basic reflection using the formula: v' = v - 2(v·n)n
+   */
+  computeBasicReflection(velocity, normal) {
+    const vx = velocity.x;
+    const vy = velocity.y;
+    const dotProduct = vx * normal.x + vy * normal.y;
+    return {
+      x: vx - 2 * dotProduct * normal.x,
+      y: vy - 2 * dotProduct * normal.y
+    };
+  }
+  /**
+   * Compute angled deflection for paddle-style reflections.
+   */
+  computeAngledDeflection(velocity, normal, speed, maxAngleDeg, speedMultiplier, selfPosition, otherPosition, otherSize, contactPosition) {
+    const maxAngleRad = maxAngleDeg * Math.PI / 180;
+    let tx = -normal.y;
+    let ty = normal.x;
+    if (Math.abs(normal.x) > Math.abs(normal.y)) {
+      if (ty < 0) {
+        tx = -tx;
+        ty = -ty;
+      }
+    } else {
+      if (tx < 0) {
+        tx = -tx;
+        ty = -ty;
+      }
+    }
+    const offset = this.computeHitOffset(
+      velocity,
+      normal,
+      speed,
+      tx,
+      ty,
+      selfPosition,
+      otherPosition,
+      otherSize,
+      contactPosition
+    );
+    const angle = clamp(offset, -1, 1) * maxAngleRad;
+    const cosA = Math.cos(angle);
+    const sinA = Math.sin(angle);
+    const newSpeed = speed * speedMultiplier;
+    return {
+      x: newSpeed * (normal.x * cosA + tx * sinA),
+      y: newSpeed * (normal.y * cosA + ty * sinA)
+    };
+  }
+  /**
+   * Compute hit offset for angled deflection (-1 to 1).
+   */
+  computeHitOffset(velocity, normal, speed, tx, ty, selfPosition, otherPosition, otherSize, contactPosition) {
+    if (otherPosition && otherSize) {
+      const useY = Math.abs(normal.x) > Math.abs(normal.y);
+      const halfExtent = useY ? otherSize.y / 2 : otherSize.x / 2;
+      if (useY) {
+        const selfY = selfPosition?.y ?? contactPosition?.y ?? 0;
+        const paddleY = otherPosition.y;
+        return (selfY - paddleY) / halfExtent;
+      } else {
+        const selfX = selfPosition?.x ?? contactPosition?.x ?? 0;
+        const paddleX = otherPosition.x;
+        return (selfX - paddleX) / halfExtent;
+      }
+    }
+    return (velocity.x * tx + velocity.y * ty) / speed;
+  }
+  /**
+   * Apply speed constraints to the reflected velocity.
+   */
+  applySpeedClamp(velocity, minSpeed, maxSpeed) {
+    const currentSpeed = Math.hypot(velocity.x, velocity.y);
+    if (currentSpeed === 0) return velocity;
+    const targetSpeed = clamp(currentSpeed, minSpeed, maxSpeed);
+    const scale = targetSpeed / currentSpeed;
+    return {
+      x: velocity.x * scale,
+      y: velocity.y * scale
+    };
+  }
+  /**
+   * Clear the ricochet state (call after consumer has applied the result).
+   */
+  clearRicochet() {
+    this.dispatch("end-ricochet" /* EndRicochet */);
+  }
+  dispatch(event) {
+    if (this.machine.can(event)) {
+      this.machine.syncDispatch(event);
+    }
+  }
+};
+
+// src/lib/behaviors/ricochet-2d/ricochet-2d.descriptor.ts
+var defaultOptions = {
+  minSpeed: 2,
+  maxSpeed: 20,
+  speedMultiplier: 1.05,
+  reflectionMode: "angled",
+  maxAngleDeg: 60
+};
+var RICOCHET_BEHAVIOR_KEY = /* @__PURE__ */ Symbol.for("zylem:behavior:ricochet-2d");
+function createRicochet2DHandle(ref) {
+  return {
+    getRicochet: (ctx) => {
+      const fsm = ref.fsm;
+      if (!fsm) return null;
+      return fsm.computeRicochet(ctx, ref.options);
+    },
+    applyRicochet: (ctx) => {
+      const fsm = ref.fsm;
+      if (!fsm) return false;
+      if (fsm.isOnCooldown()) return false;
+      const result = fsm.computeRicochet(ctx, ref.options);
+      if (!result) return false;
+      const entity = ctx.entity;
+      if (entity?.transformStore) {
+        entity.transformStore.velocity.x = result.velocity.x;
+        entity.transformStore.velocity.y = result.velocity.y;
+        entity.transformStore.velocity.z = result.velocity.z ?? 0;
+        entity.transformStore.dirty.velocity = true;
+      }
+      return true;
+    },
+    getLastResult: () => {
+      const fsm = ref.fsm;
+      return fsm?.getLastResult() ?? null;
+    },
+    onRicochet: (callback) => {
+      const fsm = ref.fsm;
+      if (!fsm) {
+        if (!ref.pendingListeners) {
+          ref.pendingListeners = [];
+        }
+        ref.pendingListeners.push(callback);
+        return () => {
+          const pending = ref.pendingListeners;
+          const idx = pending.indexOf(callback);
+          if (idx >= 0) pending.splice(idx, 1);
+        };
+      }
+      return fsm.addListener(callback);
+    }
+  };
+}
+var Ricochet2DSystem = class {
+  constructor(world, wasmStage, getBehaviorLinks) {
+    this.world = world;
+    this.wasmStage = wasmStage;
+    this.getBehaviorLinks = getBehaviorLinks;
+  }
+  world;
+  wasmStage;
+  getBehaviorLinks;
+  elapsedMs = 0;
+  attachedRuntimeSlots = /* @__PURE__ */ new Set();
+  update(_ecs, delta) {
+    this.elapsedMs += delta * 1e3;
+    const links = this.getBehaviorLinks?.(RICOCHET_BEHAVIOR_KEY);
+    if (!links) return;
+    for (const link of links) {
+      const ricochetRef = link.ref;
+      const gameEntity = link.entity;
+      if (!ricochetRef.fsm) {
+        ricochetRef.fsm = new Ricochet2DFSM();
+        const pending = ricochetRef.pendingListeners;
+        if (pending) {
+          for (const cb of pending) {
+            ricochetRef.fsm.addListener(cb);
+          }
+          ricochetRef.pendingListeners = [];
+        }
+      }
+      ricochetRef.fsm.setCurrentTimeMs(this.elapsedMs);
+      const handle = gameEntity?.runtimeHandle ?? -1;
+      if (this.wasmStage && handle >= 0) {
+        this.ensureWasmAttached(handle, ricochetRef.options);
+      }
+    }
+  }
+  ensureWasmAttached(handle, options) {
+    if (!this.wasmStage || this.attachedRuntimeSlots.has(handle)) return;
+    const reflectionMode = options.reflectionMode === "simple" ? StageRicochetReflection.Mirror : StageRicochetReflection.Angled;
+    this.wasmStage.attachRicochet(handle, StageRicochetDim.Two, {
+      minSpeed: options.minSpeed,
+      maxSpeed: options.maxSpeed,
+      speedMultiplier: options.speedMultiplier,
+      maxAngleDeg: options.maxAngleDeg,
+      reflectionMode
+    });
+    this.attachedRuntimeSlots.add(handle);
+  }
+  destroy(_ecs) {
+    const links = this.getBehaviorLinks?.(RICOCHET_BEHAVIOR_KEY);
+    if (links) {
+      for (const link of links) {
+        const ricochetRef = link.ref;
+        if (ricochetRef?.fsm) {
+          ricochetRef.fsm.resetCooldown();
+        }
+      }
+    }
+    this.attachedRuntimeSlots.clear();
+  }
+};
+var Ricochet2DBehavior = defineBehavior({
+  name: "ricochet-2d",
+  defaultOptions,
+  systemFactory: (ctx) => new Ricochet2DSystem(ctx.world, ctx.wasmStage ?? null, ctx.getBehaviorLinks),
+  createHandle: createRicochet2DHandle
+});
+
+export {
+  Ricochet2DState,
+  Ricochet2DEvent,
+  Ricochet2DFSM,
+  Ricochet2DBehavior
+};
+//# sourceMappingURL=chunk-KOZUNIIE.js.map