@zylem/behaviors 0.8.10 → 0.8.11

package/dist/catalog.js

@@ -0,0 +1,9 @@
+import {
+  BUILTIN_BEHAVIORS,
+  getRequiredRuntimeBehaviors
+} from "./chunk-S44ZHYE6.js";
+import "./chunk-JSBRDJBE.js";
+export {
+  BUILTIN_BEHAVIORS,
+  getRequiredRuntimeBehaviors
+};

package/dist/chunk-2BE5BW7D.js

@@ -0,0 +1,130 @@
+import {
+  BATTLE_ABILITIES
+} from "./chunk-LMMF7KXF.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/turn-based-rpg/index.ts
+var BattleSystem = 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.battleState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachBattle(
+          slot,
+          this.abilities,
+          link.ref.options
+        )) {
+          throw new Error(
+            "Battle attachment requires valid options and an available battle component slot."
+          );
+        }
+        this.attached.set(entity, { slot, ref: link.ref });
+      }
+    }
+  }
+  postUpdate() {
+    for (const [entity, { slot }] of this.attached)
+      entity.battleState = this.runtime?.queryBattle(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachBattle(slot) && this.runtime.queryBattle(slot))
+      throw new Error("Failed to detach battle policy.");
+    this.attached.delete(link.entity);
+    link.entity.battleState = 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: {
+      actionPoints: 3,
+      passiveBudget: 6
+    },
+    systemFactory: (ctx) => new BattleSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      abilities,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var TurnBasedRpgBehavior = descriptor("turn-based-rpg", BATTLE_ABILITIES);
+var PrioritySpeedTurnOrderBehavior = descriptor(
+  "priority-speed-turn-order",
+  ["priority-speed-turn-order"]
+);
+var TypeEffectivenessMatrixBehavior = descriptor(
+  "type-effectiveness-matrix",
+  ["type-effectiveness-matrix"]
+);
+var TurnDurationStatusBehavior = descriptor("turn-duration-status", [
+  "turn-duration-status"
+]);
+var CaptureAttemptResolutionBehavior = descriptor(
+  "capture-attempt-resolution",
+  ["capture-attempt-resolution"]
+);
+var ConditionalEvolutionBehavior = descriptor("conditional-evolution", [
+  "conditional-evolution"
+]);
+var TimedBattleActionCommandBehavior = descriptor(
+  "timed-battle-action-command",
+  ["timed-battle-action-command"]
+);
+var ActivePartnerSwapBehavior = descriptor("active-partner-swap", [
+  "active-partner-swap"
+]);
+var BudgetedPassiveLoadoutBehavior = descriptor(
+  "budgeted-passive-loadout",
+  ["budgeted-passive-loadout"]
+);
+var FieldFirstStrikeBehavior = descriptor("field-first-strike", [
+  "field-first-strike"
+]);
+var EscapeAttemptBehavior = descriptor("escape-attempt", [
+  "escape-attempt"
+]);
+
+export {
+  TurnBasedRpgBehavior,
+  PrioritySpeedTurnOrderBehavior,
+  TypeEffectivenessMatrixBehavior,
+  TurnDurationStatusBehavior,
+  CaptureAttemptResolutionBehavior,
+  ConditionalEvolutionBehavior,
+  TimedBattleActionCommandBehavior,
+  ActivePartnerSwapBehavior,
+  BudgetedPassiveLoadoutBehavior,
+  FieldFirstStrikeBehavior,
+  EscapeAttemptBehavior
+};

package/dist/{chunk-VNQLMRWC.js → chunk-2QCCLHJC.js}

@@ -7,17 +7,20 @@ import {
   VEC3_ZERO,
   toThreeVector3
 } from "./chunk-LWM346FW.js";
+import {
+  STAGE_INPUT_BUTTON_RUN,
+  readBehaviorSnapshot
+} from "./chunk-BR33KT4Z.js";
 import {
   SyncStateMachine,
   import_typescript_fsm
 } from "./chunk-CBQSC6W3.js";
-import {
-  STAGE_INPUT_BUTTON_RUN,
-  readBehaviorSnapshot
-} from "./chunk-GZ3DQIIZ.js";
 import {
   defineBehavior
-} from "./chunk-YDLO5M7S.js";
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
 
 // src/lib/behaviors/first-person/first-person-fsm.ts
 var FirstPersonState = /* @__PURE__ */ ((FirstPersonState2) => {
@@ -291,6 +294,7 @@ var FirstPersonBehaviorSystem = class {
 };
 var FirstPersonBehavior = defineBehavior({
   name: "first-person-controller",
+  metadata: BUILTIN_BEHAVIORS["first-person-controller"],
   defaultOptions,
   systemFactory: (ctx) => new FirstPersonBehaviorSystem(ctx.wasmStage ?? null, ctx.getBehaviorLinks),
   // Handles read the runtime snapshot buffer (previous-step values). The

package/dist/chunk-2UGT4MIF.js

@@ -0,0 +1,94 @@
+// src/lib/behaviors/racing-vehicles/types.ts
+var RACING_ABILITIES = [
+  "drift-charge-boost",
+  "slipstream-drafting",
+  "position-weighted-race-items",
+  "track-following-homing-item",
+  "ordered-lap-checkpoints",
+  "hover-track-suspension",
+  "energy-funded-race-boost",
+  "vehicle-side-attack",
+  "vehicle-damage-progression",
+  "vehicle-seat-entry-exit"
+];
+function racingData(o) {
+  return [
+    o.driftTierTime ?? 0.6,
+    o.boostDuration ?? 1,
+    o.minimumSpeed ?? 2,
+    o.draftRange ?? 12,
+    o.draftDwell ?? 1,
+    o.rideHeight ?? 1.5,
+    o.spring ?? 20,
+    o.damping ?? 4,
+    o.maxAcceleration ?? 30,
+    o.energyCapacity ?? 100,
+    o.boostDrain ?? 20,
+    o.rechargeRate ?? 15,
+    o.attackDuration ?? 0.3,
+    o.attackCooldown ?? 1,
+    o.burnDuration ?? 3,
+    o.seatRange ?? 3
+  ];
+}
+function racingOperation(a) {
+  switch (a.type) {
+    case "drift-input":
+      return {
+        op: 0,
+        data: [+a.held, +a.supported, a.slipAngle, a.steering]
+      };
+    case "draft-target":
+      return { op: 4, data: [] };
+    case "clear-draft":
+      return { op: 5, data: [] };
+    case "item-weight":
+      return { op: 8, data: [a.firstRank, a.lastRank, a.item, a.weight] };
+    case "draw-item":
+      return { op: 9, data: [a.rank, a.racers, a.seed] };
+    case "use-item":
+      return { op: 10, data: [] };
+    case "route-point":
+      return { op: 12, data: [...a.position] };
+    case "launch-item":
+      return { op: 13, data: [] };
+    case "cancel-item":
+      return { op: 14, data: [] };
+    case "checkpoint":
+      return { op: 16, data: [...a.position, ...a.normal, a.radius] };
+    case "start-race":
+      return { op: 17, data: [a.laps] };
+    case "hover-track":
+      return { op: 20, data: [] };
+    case "clear-hover":
+      return { op: 21, data: [] };
+    case "boost-input":
+      return { op: 24, data: [+a.held] };
+    case "recharge-zone":
+      return { op: 25, data: [a.radius] };
+    case "energy-damage":
+      return { op: 26, data: [a.amount] };
+    case "side-attack":
+      return { op: 28, data: [a.direction] };
+    case "attack-contact":
+      return { op: 29, data: [] };
+    case "vehicle-damage":
+      return { op: 32, data: [a.amount] };
+    case "repair":
+      return { op: 33, data: [a.amount] };
+    case "reserve-seat":
+      return { op: 36, data: [a.seat, ...a.local] };
+    case "complete-entry":
+      return { op: 37, data: [] };
+    case "exit-seat":
+      return { op: 38, data: [...a.position] };
+    case "release-seat":
+      return { op: 39, data: [] };
+  }
+}
+
+export {
+  RACING_ABILITIES,
+  racingData,
+  racingOperation
+};

package/dist/chunk-3J3ISPFQ.js

@@ -0,0 +1,99 @@
+// src/lib/behaviors/skate-snowboard/types.ts
+var SKATE_ABILITIES = [
+  "rail-grind-balance",
+  "wall-ride",
+  "manual-balance",
+  "ramp-lip-launch",
+  "unbanked-trick-combo",
+  "repeated-trick-devaluation",
+  "air-grab-trick",
+  "prewound-spin",
+  "landing-alignment-bail",
+  "trick-earned-boost-meter"
+];
+function skateData(o) {
+  return [
+    o.supportDistance ?? 0.4,
+    o.snapDistance ?? 0.8,
+    o.minimumSpeed ?? 2,
+    o.wallDuration ?? 1,
+    o.lipWindow ?? 0.2,
+    o.grabReleaseLead ?? 0.15,
+    o.minimumUpDot ?? 0.85,
+    o.minimumTravelDot ?? 0.8,
+    o.maximumImpactSpeed ?? 12,
+    o.minimumGrabTime ?? 0.2,
+    o.maximumSpinRate ?? 8,
+    o.maximumSpinAngle ?? 12.566371,
+    o.boostCapacity ?? 100,
+    o.boostDrain ?? 20,
+    o.boostPerPoint ?? 0.05,
+    o.jumpSpeed ?? 4
+  ];
+}
+function skateOperation(a) {
+  switch (a.type) {
+    case "grind":
+      return { op: 0, data: [...a.start, ...a.end] };
+    case "grind-balance":
+      return { op: 1, data: [a.correction] };
+    case "dismount":
+      return { op: 2, data: [...a.position] };
+    case "wall-attach":
+      return { op: 4, data: [...a.direction] };
+    case "wall-exit":
+      return { op: 5, data: [...a.direction] };
+    case "manual":
+      return { op: 8, data: [] };
+    case "manual-balance":
+      return { op: 9, data: [a.correction] };
+    case "end-manual":
+      return { op: 10, data: [] };
+    case "ramp-sample":
+      return { op: 12, data: [...a.tangent, +a.jump] };
+    case "trick":
+      return { op: 16, data: [a.trick, a.points] };
+    case "begin-combo":
+      return { op: 17, data: [] };
+    case "land-combo":
+      return { op: 18, data: [] };
+    case "bail-combo":
+      return { op: 19, data: [] };
+    case "preview-repeat":
+      return { op: 20, data: [a.trick] };
+    case "practice-repeat":
+      return { op: 21, data: [a.trick] };
+    case "reset-history":
+      return { op: 22, data: [] };
+    case "grab":
+      return { op: 24, data: [a.trick] };
+    case "release-grab":
+      return { op: 25, data: [] };
+    case "land-grab":
+      return { op: 26, data: [] };
+    case "wind":
+      return { op: 28, data: [a.direction] };
+    case "spin-takeoff":
+      return { op: 29, data: [] };
+    case "land-spin":
+      return { op: 30, data: [] };
+    case "begin-landing":
+      return { op: 32, data: [] };
+    case "resolve-landing":
+      return { op: 33, data: [] };
+    case "boost-trick":
+      return { op: 36, data: [a.trick, a.points] };
+    case "boost-input":
+      return { op: 37, data: [+a.held] };
+    case "land-boost":
+      return { op: 38, data: [] };
+    case "bail-boost":
+      return { op: 39, data: [] };
+  }
+}
+
+export {
+  SKATE_ABILITIES,
+  skateData,
+  skateOperation
+};

package/dist/chunk-3LBGEWT6.js

@@ -0,0 +1,124 @@
+import {
+  RPG_ABILITIES
+} from "./chunk-VU4LTE2X.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/action-rpg/index.ts
+var RpgSystem = 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.rpgState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachRpg(slot, this.abilities, link.ref.options)) {
+          throw new Error(
+            "Rpg attachment requires valid options and an available rpg component slot."
+          );
+        }
+        this.attached.set(entity, { slot, ref: link.ref });
+      }
+    }
+  }
+  postUpdate() {
+    for (const [entity, { slot }] of this.attached)
+      entity.rpgState = this.runtime?.queryRpg(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachRpg(slot) && this.runtime.queryRpg(slot))
+      throw new Error("Failed to detach rpg policy.");
+    this.attached.delete(link.entity);
+    link.entity.rpgState = 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: {
+      maximumHealth: 100,
+      maximumMana: 50
+    },
+    systemFactory: (ctx) => new RpgSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      abilities,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var ActionRpgBehavior = descriptor("action-rpg", RPG_ABILITIES);
+var EquipmentStatAggregationBehavior = descriptor(
+  "equipment-stat-aggregation",
+  ["equipment-stat-aggregation"]
+);
+var DurabilityAndRepairBehavior = descriptor("durability-and-repair", [
+  "durability-and-repair"
+]);
+var AffixBudgetGenerationBehavior = descriptor("affix-budget-generation", [
+  "affix-budget-generation"
+]);
+var DeathDropOwnershipBehavior = descriptor("death-drop-ownership", [
+  "death-drop-ownership"
+]);
+var ConsumableBeltSlotsBehavior = descriptor("consumable-belt-slots", [
+  "consumable-belt-slots"
+]);
+var SeededLootTableBehavior = descriptor("seeded-loot-table", [
+  "seeded-loot-table"
+]);
+var DamageToResourceLeechBehavior = descriptor("damage-to-resource-leech", [
+  "damage-to-resource-leech"
+]);
+var TypedResistanceResolutionBehavior = descriptor(
+  "typed-resistance-resolution",
+  ["typed-resistance-resolution"]
+);
+var AutonomousFamiliarBehavior = descriptor("autonomous-familiar", [
+  "autonomous-familiar"
+]);
+var ResourceDrainingTransformationBehavior = descriptor(
+  "resource-draining-transformation",
+  ["resource-draining-transformation"]
+);
+
+export {
+  ActionRpgBehavior,
+  EquipmentStatAggregationBehavior,
+  DurabilityAndRepairBehavior,
+  AffixBudgetGenerationBehavior,
+  DeathDropOwnershipBehavior,
+  ConsumableBeltSlotsBehavior,
+  SeededLootTableBehavior,
+  DamageToResourceLeechBehavior,
+  TypedResistanceResolutionBehavior,
+  AutonomousFamiliarBehavior,
+  ResourceDrainingTransformationBehavior
+};

package/dist/{chunk-UUMH3DC3.js → chunk-3QBNWT7B.js}

@@ -1,6 +1,9 @@
 import {
   defineBehavior
-} from "./chunk-YDLO5M7S.js";
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
 
 // src/lib/behaviors/cooldown/cooldown-store.ts
 import { proxy } from "valtio/vanilla";
@@ -101,6 +104,7 @@ function ensureCooldownEntriesRegistered(ref) {
 }
 var CooldownBehavior = defineBehavior({
   name: "cooldown",
+  metadata: BUILTIN_BEHAVIORS["cooldown"],
   defaultOptions: { cooldowns: {} },
   systemFactory: (ctx) => new CooldownSystem(ctx.getBehaviorLinks),
   createHandle: createCooldownHandle

package/dist/chunk-3T44EDXU.js

@@ -0,0 +1,114 @@
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/spatial-puzzles/index.ts
+var PuzzleSystem = class {
+  constructor(key, ability, runtime, links) {
+    this.key = key;
+    this.ability = ability;
+    this.runtime = runtime;
+    this.links = links;
+  }
+  key;
+  ability;
+  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((l) => l.entity === entity && l.ref === ref) || entity.runtimeHandle !== slot)
+        this.detach({ entity, ref });
+    for (const link of links) {
+      const e = link.entity, slot = e.runtimeHandle;
+      e.$puzzle ??= [];
+      e.puzzleState ??= null;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(e)) {
+        if (!this.runtime.attachPuzzle(
+          slot,
+          this.ability,
+          link.ref.options
+        ))
+          throw new Error(
+            "Puzzle requires a compatible body and exclusive ownership."
+          );
+        this.attached.set(e, { slot, ref: link.ref });
+      }
+      while (e.$puzzle.length) {
+        if (!this.runtime.puzzleCommand(slot, e.$puzzle[0])) break;
+        e.$puzzle.shift();
+      }
+    }
+  }
+  postUpdate() {
+    for (const [e, { slot }] of this.attached)
+      e.puzzleState = this.runtime?.queryPuzzle(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachPuzzle(slot) && this.runtime.queryPuzzle(slot))
+      throw new Error(
+        "Platform needs clearance before restoring collision and detaching."
+      );
+    this.attached.delete(link.entity);
+    link.entity.puzzleState = null;
+  }
+  destroy() {
+    for (const [entity, { ref }] of this.attached)
+      this.detach({ entity, ref });
+  }
+};
+function descriptor(name) {
+  return defineBehavior({
+    name,
+    metadata: BUILTIN_BEHAVIORS[name],
+    defaultOptions: {},
+    systemFactory: (ctx) => new PuzzleSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      name,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var WeightedPressureSwitchBehavior = descriptor(
+  "weighted-pressure-switch"
+);
+var GridConstrainedPushBlockBehavior = descriptor(
+  "grid-constrained-push-block"
+);
+var MirrorBeamRoutingBehavior = descriptor("mirror-beam-routing");
+var ConductiveContactNetworkBehavior = descriptor(
+  "conductive-contact-network"
+);
+var MaterialIgnitionSpreadBehavior = descriptor(
+  "material-ignition-spread"
+);
+var FreezeAndShatterBehavior = descriptor("freeze-and-shatter");
+var StasisImpulseStorageBehavior = descriptor(
+  "stasis-impulse-storage"
+);
+var MagneticObjectManipulationBehavior = descriptor(
+  "magnetic-object-manipulation"
+);
+var WaterLevelMechanismBehavior = descriptor("water-level-mechanism");
+var TimedSolidPlatformBehavior = descriptor("timed-solid-platform");
+
+export {
+  WeightedPressureSwitchBehavior,
+  GridConstrainedPushBlockBehavior,
+  MirrorBeamRoutingBehavior,
+  ConductiveContactNetworkBehavior,
+  MaterialIgnitionSpreadBehavior,
+  FreezeAndShatterBehavior,
+  StasisImpulseStorageBehavior,
+  MagneticObjectManipulationBehavior,
+  WaterLevelMechanismBehavior,
+  TimedSolidPlatformBehavior
+};