@zylem/behaviors 0.8.10 → 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-HZMC4LGW.js → chunk-P6TMZSWF.js}

@@ -1,16 +1,19 @@
-import {
-  SyncStateMachine,
-  import_typescript_fsm
-} from "./chunk-CBQSC6W3.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 = {}) {
@@ -313,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,

package/dist/chunk-PDHHOVVQ.js

@@ -0,0 +1,126 @@
+// src/lib/behaviors/survival-resources/types.ts
+var SURVIVAL_ABILITIES = [
+  "escort-follow-wait",
+  "companion-abduction-objective",
+  "environmental-vault-action",
+  "stagger-finisher-opportunity",
+  "adaptive-encounter-pressure",
+  "spatial-inventory-packing",
+  "ingredient-combination",
+  "weapon-upgrade-track",
+  "encounter-clear-lock",
+  "save-point-checkpoint"
+];
+function survivalData(o) {
+  return [
+    o.followDistance ?? 1.5,
+    o.maxTravelDistance ?? 20,
+    o.interactionRange ?? 3,
+    o.boundaryRadius ?? 1,
+    o.finisherRange ?? 2.5,
+    o.minPressure ?? 1,
+    o.maxPressure ?? 5,
+    o.columns ?? 6,
+    o.rows ?? 4,
+    o.pressureGain ?? 0.5,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+  ];
+}
+function survivalOperation(a) {
+  switch (a.type) {
+    case "follow":
+      return { op: 0, data: [] };
+    case "wait":
+      return { op: 1, data: [] };
+    case "seek-safe":
+      return { op: 2, data: [...a.position] };
+    case "capture":
+      return { op: 3, data: [...a.boundary] };
+    case "rescue":
+      return { op: 4, data: [] };
+    case "vault":
+      return { op: 5, data: [...a.landing, a.height, a.duration] };
+    case "cancel-vault":
+      return { op: 6, data: [] };
+    case "stagger":
+      return { op: 7, data: [a.class, a.duration] };
+    case "finish":
+      return { op: 8, data: [a.eligibleMask] };
+    case "performance":
+      return { op: 9, data: [a.score] };
+    case "begin-encounter":
+      return { op: 10, data: [] };
+    case "pack":
+      return {
+        op: 11,
+        data: [
+          a.kind,
+          a.quantity,
+          a.limit,
+          a.shape,
+          a.x,
+          a.y,
+          Number(a.rotated ?? false)
+        ]
+      };
+    case "move-item":
+      return {
+        op: 12,
+        data: [a.item, a.x, a.y, Number(a.rotated ?? false)]
+      };
+    case "stack":
+      return { op: 13, data: [a.item, a.into, a.quantity] };
+    case "stock":
+      return { op: 14, data: [a.kind, a.quantity, a.limit] };
+    case "recipe":
+      return {
+        op: 15,
+        data: [
+          a.id,
+          a.first,
+          a.firstCount,
+          a.second,
+          a.secondCount,
+          a.output,
+          a.outputCount,
+          a.limit
+        ]
+      };
+    case "combine":
+      return { op: 16, data: [a.recipe] };
+    case "credit":
+      return { op: 17, data: [a.amount] };
+    case "upgrade-level":
+      return { op: 18, data: [a.level, a.cost, a.gate, a.value] };
+    case "purchase":
+      return { op: 19, data: [a.unlockedGate] };
+    case "expect-spawns":
+      return { op: 20, data: [a.count] };
+    case "track-enemy":
+      return { op: 21, data: [a.id] };
+    case "resolve-enemy":
+      return {
+        op: 22,
+        data: [a.id, a.resolution === "defeated" ? 1 : 2]
+      };
+    case "link-gate":
+      return { op: 23, data: [] };
+    case "save-permission":
+      return { op: 24, data: [Number(a.allowed)] };
+    case "request-save":
+      return { op: 25, data: [a.checkpoint] };
+    case "complete-save":
+      return { op: 26, data: [a.saveRequest, Number(a.success)] };
+  }
+}
+
+export {
+  SURVIVAL_ABILITIES,
+  survivalData,
+  survivalOperation
+};