@zylem/behaviors 0.8.9 → 0.8.11

package/dist/chunk-LMMF7KXF.js

@@ -0,0 +1,178 @@
+// src/lib/behaviors/turn-based-rpg/types.ts
+var BATTLE_ABILITIES = [
+  "priority-speed-turn-order",
+  "type-effectiveness-matrix",
+  "turn-duration-status",
+  "capture-attempt-resolution",
+  "conditional-evolution",
+  "timed-battle-action-command",
+  "active-partner-swap",
+  "budgeted-passive-loadout",
+  "field-first-strike",
+  "escape-attempt"
+];
+var BATTLE_EVENTS = [
+  ...BATTLE_ABILITIES,
+  "action-command-timeout"
+];
+function battleData(o) {
+  return [
+    o.swapCost ?? 1,
+    o.actionPoints ?? 3,
+    o.passiveBudget ?? 6,
+    o.captureItems ?? 3,
+    o.escapeCost ?? 1,
+    o.escapeBaseChance ?? 0.25,
+    o.escapeRetryBonus ?? 0.2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+  ];
+}
+function battleOperation(a) {
+  switch (a.type) {
+    case "queue-action":
+      return {
+        op: 0,
+        data: [a.row, a.actionId, a.priority, a.speed, a.tieKey]
+      };
+    case "freeze-order":
+      return { op: 1, data: [a.turn] };
+    case "next-action":
+      return { op: 2, data: [] };
+    case "clear-order":
+      return { op: 3, data: [] };
+    case "type-row":
+      return { op: 4, data: [a.attackType, a.defenderType, a.multiplier] };
+    case "resolve-type":
+      return {
+        op: 5,
+        data: [
+          a.attackType,
+          a.defenderType,
+          a.secondType ?? 4,
+          a.raw,
+          a.damageSerial
+        ]
+      };
+    case "status-apply":
+      return {
+        op: 8,
+        data: [a.id, a.turns, a.phaseMask, Number(a.restrict), a.amount]
+      };
+    case "status-phase":
+      return { op: 9, data: [a.turn, a.phase] };
+    case "status-remove":
+      return { op: 10, data: [a.id] };
+    case "capture":
+      return {
+        op: 12,
+        data: [
+          a.attemptSerial,
+          a.seed,
+          a.health,
+          a.maximumHealth,
+          a.catchRate,
+          a.itemBonus,
+          a.statusBonus,
+          Number(a.eligible),
+          a.itemId
+        ]
+      };
+    case "capture-stock":
+      return { op: 13, data: [a.count] };
+    case "creature":
+      return {
+        op: 16,
+        data: [a.species, a.level, a.friendship, ...a.stats, ...a.moves]
+      };
+    case "evolution-rule":
+      return {
+        op: 17,
+        data: [
+          a.row,
+          a.from,
+          a.to,
+          a.level,
+          a.item,
+          a.friendship,
+          a.context,
+          ...a.stats,
+          a.keepMovesMask
+        ]
+      };
+    case "evolve":
+      return { op: 18, data: [a.evolutionSerial, a.item, a.context] };
+    case "creature-progress":
+      return { op: 19, data: [a.level, a.friendship] };
+    case "timing-start":
+      return {
+        op: 20,
+        data: [
+          a.moveSerial,
+          a.count,
+          a.window,
+          a.bonus,
+          ...a.times,
+          ...a.buttons
+        ]
+      };
+    case "timing-input":
+      return { op: 21, data: [a.button, a.timestamp] };
+    case "timing-finish":
+      return { op: 22, data: [] };
+    case "partner-register":
+      return { op: 24, data: [a.row, a.health, a.maximumHealth] };
+    case "partner-swap":
+      return { op: 25, data: [a.row] };
+    case "partner-health":
+      return { op: 26, data: [a.row, a.health] };
+    case "partner-turn":
+      return { op: 27, data: [a.turn, a.points] };
+    case "passive-row":
+      return {
+        op: 28,
+        data: [
+          a.row,
+          a.id,
+          a.cost,
+          a.group,
+          a.stat,
+          a.amount,
+          a.maximumStacks
+        ]
+      };
+    case "passive-equip":
+      return { op: 29, data: [...a.counts] };
+    case "passive-budget":
+      return { op: 30, data: [a.budget] };
+    case "passive-clear":
+      return { op: 31, data: [] };
+    case "field-contact":
+      return { op: 32, data: [a.side, a.attackId] };
+    case "opening-transfer":
+      return { op: 33, data: [a.encounterSerial] };
+    case "escape":
+      return {
+        op: 36,
+        data: [a.seed, a.speed, a.enemySpeed, Number(a.eligible)]
+      };
+    case "escape-turn":
+      return { op: 37, data: [a.turn, a.points] };
+    case "battle-end":
+      return { op: 39, data: [a.outcome] };
+  }
+}
+
+export {
+  BATTLE_ABILITIES,
+  BATTLE_EVENTS,
+  battleData,
+  battleOperation
+};

package/dist/chunk-LWGJ3QQZ.js

@@ -0,0 +1,107 @@
+// src/lib/behaviors/rhythm-performance/types.ts
+var RHYTHM_ABILITIES = [
+  "timestamped-rhythm-judgment",
+  "hold-release-rhythm",
+  "call-and-response-pattern",
+  "tempo-map-chart-player",
+  "fret-chord-strum",
+  "hammer-on-pull-off-chain",
+  "sustain-note-tracking",
+  "phrase-earned-score-power",
+  "rhythm-scene-remix",
+  "performance-failure-meter"
+];
+var RHYTHM_EVENTS = [
+  ...RHYTHM_ABILITIES,
+  "chart-or-clock",
+  "note-result",
+  "failed",
+  "scene-changed",
+  "cue"
+];
+function rhythmData(o) {
+  return [
+    o.perfectMs ?? 30,
+    o.goodMs ?? 80,
+    o.lateMs ?? 120,
+    o.latencyMs ?? 0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+  ];
+}
+function rhythmOperation(a) {
+  switch (a.type) {
+    case "hit":
+      return { op: 0, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "hold-press":
+      return { op: 4, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "hold-release":
+      return { op: 5, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "call":
+      return { op: 8, data: [a.start, a.response, a.duration] };
+    case "cue":
+      return { op: 9, data: [a.offset, a.lanes] };
+    case "response":
+      return { op: 10, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "tempo":
+      return { op: 12, data: [a.beat, a.bpm] };
+    case "beat-note":
+      return { op: 13, data: [a.beat, a.lanes, a.scene] };
+    case "chart-hit":
+      return { op: 14, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "seek":
+      return { op: 15, data: [a.timestamp] };
+    case "strum":
+      return { op: 16, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "chain-strum":
+      return { op: 20, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "fret-edge":
+      return { op: 21, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "sustain-press":
+      return { op: 24, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "sustain-release":
+      return { op: 25, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "phrase":
+      return { op: 28, data: [a.first, a.last, a.reward] };
+    case "activate-power":
+      return { op: 29, data: [a.timestamp] };
+    case "power-hit":
+      return { op: 30, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "transition":
+      return { op: 32, data: [a.timestamp, a.scene] };
+    case "remix-hit":
+      return { op: 33, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "performance":
+      return { op: 36, data: [a.initial, a.hitGain, a.missLoss, a.threshold] };
+    case "performance-hit":
+      return { op: 37, data: [a.note, a.timestamp, a.lanes, a.scene] };
+    case "note":
+      return {
+        op: 40,
+        data: [a.kind, a.timestamp, a.end, a.lanes, a.scene, a.eligible]
+      };
+    case "start":
+      return { op: 41, data: [] };
+    case "clock":
+      return { op: 42, data: [a.timestamp] };
+    case "pause":
+      return { op: 43, data: [a.paused] };
+  }
+}
+
+export {
+  RHYTHM_ABILITIES,
+  RHYTHM_EVENTS,
+  rhythmData,
+  rhythmOperation
+};

package/dist/chunk-MPNGQLHZ.js

@@ -0,0 +1,132 @@
+import {
+  COMBAT_ABILITIES
+} from "./chunk-V4M46BF6.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/melee-combat/index.ts
+var CombatSystem = class {
+  constructor(key, abilities, runtime, links) {
+    this.key = key;
+    this.abilities = abilities;
+    this.runtime = runtime;
+    this.links = links;
+  }
+  key;
+  abilities;
+  runtime;
+  links;
+  attached = /* @__PURE__ */ new Map();
+  update() {
+    if (!this.runtime) return;
+    const links = [...this.links?.(this.key) ?? []];
+    for (const [entity, { slot, ref }] of this.attached) {
+      if (!links.some(
+        (link) => link.entity === entity && link.ref === ref
+      ) || entity.runtimeHandle !== slot)
+        this.detach({ entity, ref });
+    }
+    for (const link of links) {
+      const entity = link.entity;
+      entity.$combat ??= {};
+      entity.combatState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachCombat(
+          slot,
+          this.abilities,
+          link.ref.options
+        )) {
+          throw new Error(
+            "Combat requires exclusive motion ownership, a dynamic solid body with gravityScale=0, and compatible rotation locks."
+          );
+        }
+        this.attached.set(entity, { slot, ref: link.ref });
+      }
+      this.runtime.combatInput(slot, entity.$combat);
+    }
+  }
+  postUpdate() {
+    for (const [entity, { slot }] of this.attached)
+      entity.combatState = this.runtime?.queryCombat(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachCombat(slot) && this.runtime.queryCombat(slot))
+      throw new Error("Failed to release combat ownership.");
+    this.attached.delete(link.entity);
+    link.entity.combatState = null;
+  }
+  destroy() {
+    for (const [entity, { ref }] of this.attached)
+      this.detach({ entity, ref });
+  }
+};
+function descriptor(name, abilities) {
+  return defineBehavior({
+    name,
+    metadata: BUILTIN_BEHAVIORS[name],
+    defaultOptions: {
+      gravity: 18,
+      speed: 5
+    },
+    systemFactory: (ctx) => new CombatSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      abilities,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var MeleeCombatBehavior = descriptor("melee-combat", COMBAT_ABILITIES);
+var AttackPhaseHitboxesBehavior = descriptor("attack-phase-hitboxes", [
+  "attack-phase-hitboxes"
+]);
+var DamageScaledKnockbackBehavior = descriptor(
+  "damage-scaled-knockback",
+  ["damage-scaled-knockback"]
+);
+var CombatHitstopBehavior = descriptor("combat-hitstop", [
+  "combat-hitstop"
+]);
+var DepletingShieldBehavior = descriptor("depleting-shield", [
+  "depleting-shield"
+]);
+var TimedPerfectGuardBehavior = descriptor("timed-perfect-guard", [
+  "timed-perfect-guard"
+]);
+var GrabHoldThrowBehavior = descriptor("grab-hold-throw", [
+  "grab-hold-throw"
+]);
+var AirDodgeRecoveryBehavior = descriptor("air-dodge-recovery", [
+  "air-dodge-recovery"
+]);
+var DirectionalInfluenceBehavior = descriptor(
+  "directional-influence",
+  ["directional-influence"]
+);
+var ImpactTechWindowBehavior = descriptor("impact-tech-window", [
+  "impact-tech-window"
+]);
+var GroundedAttackChainBehavior = descriptor("grounded-attack-chain", [
+  "grounded-attack-chain"
+]);
+
+export {
+  MeleeCombatBehavior,
+  AttackPhaseHitboxesBehavior,
+  DamageScaledKnockbackBehavior,
+  CombatHitstopBehavior,
+  DepletingShieldBehavior,
+  TimedPerfectGuardBehavior,
+  GrabHoldThrowBehavior,
+  AirDodgeRecoveryBehavior,
+  DirectionalInfluenceBehavior,
+  ImpactTechWindowBehavior,
+  GroundedAttackChainBehavior
+};

package/dist/chunk-OH5LJAEJ.js

@@ -0,0 +1,135 @@
+import {
+  ENCOUNTER_ABILITIES
+} from "./chunk-73MHJY6R.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/combat-ai/index.ts
+var EncounterSystem = class {
+  constructor(key, abilities, runtime, links) {
+    this.key = key;
+    this.abilities = abilities;
+    this.runtime = runtime;
+    this.links = links;
+  }
+  key;
+  abilities;
+  runtime;
+  links;
+  attached = /* @__PURE__ */ new Map();
+  update() {
+    if (!this.runtime) return;
+    const links = [...this.links?.(this.key) ?? []];
+    for (const [entity, { slot, ref }] of this.attached) {
+      if (!links.some(
+        (link) => link.entity === entity && link.ref === ref
+      ) || entity.runtimeHandle !== slot)
+        this.detach({ entity, ref });
+    }
+    for (const link of links) {
+      const entity = link.entity;
+      entity.encounterState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachEncounters(
+          slot,
+          this.abilities,
+          link.ref.options
+        )) {
+          throw new Error(
+            "Encounter attachment requires valid options and an available AI component slot."
+          );
+        }
+        this.attached.set(entity, { slot, ref: link.ref });
+      }
+    }
+  }
+  postUpdate() {
+    for (const [entity, { slot }] of this.attached)
+      entity.encounterState = this.runtime?.queryEncounters(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachEncounters(slot) && this.runtime.queryEncounters(slot))
+      throw new Error("Failed to detach encounter policy.");
+    this.attached.delete(link.entity);
+    link.entity.encounterState = null;
+  }
+  destroy() {
+    for (const [entity, { ref }] of this.attached)
+      this.detach({ entity, ref });
+  }
+};
+function descriptor(name, abilities) {
+  return defineBehavior({
+    name,
+    metadata: BUILTIN_BEHAVIORS[name],
+    defaultOptions: {
+      health: 100,
+      team: 1
+    },
+    systemFactory: (ctx) => new EncounterSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      abilities,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var CombatAIBehavior = descriptor("combat-ai", ENCOUNTER_ABILITIES);
+var SquadFlankAssignmentBehavior = descriptor(
+  "squad-flank-assignment",
+  ["squad-flank-assignment"]
+);
+var LeaderLossMoraleBehavior = descriptor("leader-loss-morale", [
+  "leader-loss-morale"
+]);
+var GrenadeDangerEvasionBehavior = descriptor(
+  "grenade-danger-evasion",
+  ["grenade-danger-evasion"]
+);
+var CoverPeekCycleBehavior = descriptor("cover-peek-cycle", [
+  "cover-peek-cycle"
+]);
+var ThreatTargetSelectionBehavior = descriptor(
+  "threat-target-selection",
+  ["threat-target-selection"]
+);
+var TacticalBurstSelectionBehavior = descriptor(
+  "tactical-burst-selection",
+  ["tactical-burst-selection"]
+);
+var LatentAmbushActivationBehavior = descriptor(
+  "latent-ambush-activation",
+  ["latent-ambush-activation"]
+);
+var BossPhaseControllerBehavior = descriptor("boss-phase-controller", [
+  "boss-phase-controller"
+]);
+var LocalizedWeakPointDamageBehavior = descriptor(
+  "localized-weak-point-damage",
+  ["localized-weak-point-damage"]
+);
+var ShootableProjectileInterceptionBehavior = descriptor(
+  "shootable-projectile-interception",
+  ["shootable-projectile-interception"]
+);
+
+export {
+  CombatAIBehavior,
+  SquadFlankAssignmentBehavior,
+  LeaderLossMoraleBehavior,
+  GrenadeDangerEvasionBehavior,
+  CoverPeekCycleBehavior,
+  ThreatTargetSelectionBehavior,
+  TacticalBurstSelectionBehavior,
+  LatentAmbushActivationBehavior,
+  BossPhaseControllerBehavior,
+  LocalizedWeakPointDamageBehavior,
+  ShootableProjectileInterceptionBehavior
+};

package/dist/{chunk-57GLKGEX.js → chunk-P6TMZSWF.js}

@@ -1,16 +1,19 @@
-import {
-  SyncStateMachine,
-  import_typescript_fsm
-} from "./chunk-OBF6BIA2.js";
 import {
   STAGE_INPUT_BUTTON_JUMP,
   STAGE_INPUT_BUTTON_RUN,
   StagePlatformerShapeSource,
   readBehaviorSnapshot
-} from "./chunk-GZ3DQIIZ.js";
+} from "./chunk-BR33KT4Z.js";
+import {
+  SyncStateMachine,
+  import_typescript_fsm
+} from "./chunk-CBQSC6W3.js";
 import {
   defineBehavior
-} from "./chunk-YDLO5M7S.js";
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
 
 // src/lib/behaviors/platformer-2d/components.ts
 function createPlatformer2DMovementComponent(options = {}) {
@@ -145,7 +148,8 @@ var Platformer2DFSM = class {
     const currentState = this.getState();
     const hasInput = Math.abs(input.moveX) > 0.1;
     const isRunning = input.run;
-    if (currentState === "falling" /* Falling */ && state.grounded) {
+    const airborne = currentState === "falling" /* Falling */ || currentState === "jumping" /* Jumping */;
+    if (airborne && state.grounded) {
       this.dispatch("land" /* Land */);
     }
     if (state.grounded) {
@@ -176,6 +180,15 @@ var FSM_STATE_BY_INDEX = [
   "falling" /* Falling */,
   "landing" /* Landing */
 ];
+function syncStateFromSnapshot(state, snapshot) {
+  const fsmState = FSM_STATE_BY_INDEX[snapshot.fsmState];
+  state.grounded = snapshot.grounded;
+  state.jumping = fsmState === "jumping" /* Jumping */;
+  state.falling = fsmState === "falling" /* Falling */;
+  state.jumpCount = snapshot.jumpCount;
+  state.currentSpeed = snapshot.speed;
+  state.verticalVelocity = snapshot.verticalVelocity;
+}
 var defaultOptions = {
   walkSpeed: 8,
   runSpeed: 14,
@@ -234,6 +247,15 @@ var Platformer2DBehaviorSystem = class {
   wasmStage;
   getBehaviorLinks;
   attachedRuntimeSlots = /* @__PURE__ */ new Set();
+  snapshot = {
+    grounded: false,
+    fsmState: 0,
+    jumpCount: 0,
+    verticalVelocity: 0,
+    speed: 0,
+    yaw: 0,
+    pitch: 0
+  };
   update(_ecs, _delta) {
     const links = this.getBehaviorLinks?.(PLATFORMER_2D_BEHAVIOR_KEY);
     if (!links) return;
@@ -261,6 +283,8 @@ var Platformer2DBehaviorSystem = class {
         this.wasmStage.writeInputButton(handle, STAGE_INPUT_BUTTON_JUMP, !!input.jump);
         this.wasmStage.writeInputButton(handle, STAGE_INPUT_BUTTON_RUN, !!input.run);
       }
+      const snapshot = this.wasmStage.readSnapshot(handle, this.snapshot);
+      if (snapshot) syncStateFromSnapshot(gameEntity.platformer2DState, snapshot);
     }
   }
   ensureWasmAttached(handle, options, gameEntity) {
@@ -292,6 +316,7 @@ var Platformer2DBehaviorSystem = class {
 };
 var Platformer2DBehavior = defineBehavior({
   name: "platformer-2d",
+  metadata: BUILTIN_BEHAVIORS["platformer-2d"],
   defaultOptions,
   systemFactory: (ctx) => new Platformer2DBehaviorSystem(
     ctx.wasmStage ?? null,