@zylem/behaviors 0.8.10 → 0.8.11

package/dist/chunk-HQ2UFI3S.js

@@ -0,0 +1,116 @@
+import {
+  SKATE_ABILITIES
+} from "./chunk-3J3ISPFQ.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/skate-snowboard/index.ts
+var SkateSystem = 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.skateState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachSkate(slot, this.abilities, link.ref.options)) {
+          throw new Error(
+            "Skate attachment requires valid options and an available skate component slot."
+          );
+        }
+        this.attached.set(entity, { slot, ref: link.ref });
+      }
+    }
+  }
+  postUpdate() {
+    for (const [entity, { slot }] of this.attached)
+      entity.skateState = this.runtime?.querySkate(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachSkate(slot) && this.runtime.querySkate(slot))
+      throw new Error("Failed to detach skate policy.");
+    this.attached.delete(link.entity);
+    link.entity.skateState = 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: {
+      supportDistance: 0.4,
+      snapDistance: 0.8
+    },
+    systemFactory: (ctx) => new SkateSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      abilities,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var SkateSnowboardBehavior = descriptor("skate-snowboard", SKATE_ABILITIES);
+var RailGrindBalanceBehavior = descriptor("rail-grind-balance", [
+  "rail-grind-balance"
+]);
+var WallRideBehavior = descriptor("wall-ride", ["wall-ride"]);
+var ManualBalanceBehavior = descriptor("manual-balance", [
+  "manual-balance"
+]);
+var RampLipLaunchBehavior = descriptor("ramp-lip-launch", [
+  "ramp-lip-launch"
+]);
+var UnbankedTrickComboBehavior = descriptor("unbanked-trick-combo", [
+  "unbanked-trick-combo"
+]);
+var RepeatedTrickDevaluationBehavior = descriptor(
+  "repeated-trick-devaluation",
+  ["repeated-trick-devaluation"]
+);
+var AirGrabTrickBehavior = descriptor("air-grab-trick", ["air-grab-trick"]);
+var PrewoundSpinBehavior = descriptor("prewound-spin", ["prewound-spin"]);
+var LandingAlignmentBailBehavior = descriptor("landing-alignment-bail", [
+  "landing-alignment-bail"
+]);
+var TrickEarnedBoostMeterBehavior = descriptor("trick-earned-boost-meter", [
+  "trick-earned-boost-meter"
+]);
+
+export {
+  SkateSnowboardBehavior,
+  RailGrindBalanceBehavior,
+  WallRideBehavior,
+  ManualBalanceBehavior,
+  RampLipLaunchBehavior,
+  UnbankedTrickComboBehavior,
+  RepeatedTrickDevaluationBehavior,
+  AirGrabTrickBehavior,
+  PrewoundSpinBehavior,
+  LandingAlignmentBailBehavior,
+  TrickEarnedBoostMeterBehavior
+};

package/dist/chunk-I52PC5IU.js

@@ -0,0 +1,128 @@
+import {
+  LIFE_ABILITIES
+} from "./chunk-TZHO6P22.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/life-simulation/index.ts
+var LifeSystem = 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.lifeState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachLife(slot, this.abilities, link.ref.options)) {
+          throw new Error(
+            "Life attachment requires valid options and an available life component slot."
+          );
+        }
+        this.attached.set(entity, { slot, ref: link.ref });
+      }
+    }
+  }
+  postUpdate() {
+    for (const [entity, { slot }] of this.attached)
+      entity.lifeState = this.runtime?.queryLife(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachLife(slot) && this.runtime.queryLife(slot))
+      throw new Error("Failed to detach life policy.");
+    this.attached.delete(link.entity);
+    link.entity.lifeState = 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: {
+      seasonLength: 30,
+      reach: 5
+    },
+    systemFactory: (ctx) => new LifeSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      abilities,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var LifeSimulationBehavior = descriptor(
+  "life-simulation",
+  LIFE_ABILITIES
+);
+var CropGrowthStagesBehavior = descriptor("crop-growth-stages", [
+  "crop-growth-stages"
+]);
+var SoilMoistureCycleBehavior = descriptor("soil-moisture-cycle", [
+  "soil-moisture-cycle"
+]);
+var SeasonalCropEligibilityBehavior = descriptor(
+  "seasonal-crop-eligibility",
+  ["seasonal-crop-eligibility"]
+);
+var ExertionAndFatigueBehavior = descriptor("exertion-and-fatigue", [
+  "exertion-and-fatigue"
+]);
+var LivestockDailyCareBehavior = descriptor("livestock-daily-care", [
+  "livestock-daily-care"
+]);
+var CalendarNpcRoutineBehavior = descriptor("calendar-npc-routine", [
+  "calendar-npc-routine"
+]);
+var RelationshipEventMemoryBehavior = descriptor(
+  "relationship-event-memory",
+  ["relationship-event-memory"]
+);
+var FishingBiteAndHookBehavior = descriptor("fishing-bite-and-hook", [
+  "fishing-bite-and-hook"
+]);
+var HarvestableFruitRegrowthBehavior = descriptor(
+  "harvestable-fruit-regrowth",
+  ["harvestable-fruit-regrowth"]
+);
+var RoomFurniturePlacementBehavior = descriptor(
+  "room-furniture-placement",
+  ["room-furniture-placement"]
+);
+
+export {
+  LifeSimulationBehavior,
+  CropGrowthStagesBehavior,
+  SoilMoistureCycleBehavior,
+  SeasonalCropEligibilityBehavior,
+  ExertionAndFatigueBehavior,
+  LivestockDailyCareBehavior,
+  CalendarNpcRoutineBehavior,
+  RelationshipEventMemoryBehavior,
+  FishingBiteAndHookBehavior,
+  HarvestableFruitRegrowthBehavior,
+  RoomFurniturePlacementBehavior
+};

package/dist/{chunk-T7ST62OT.js → chunk-IAIJG2PB.js}

@@ -1,17 +1,20 @@
 import {
   createJumpInput3D
 } from "./chunk-F7E23E26.js";
+import {
+  STAGE_INPUT_BUTTON_JUMP,
+  readBehaviorSnapshot
+} from "./chunk-BR33KT4Z.js";
 import {
   SyncStateMachine,
   import_typescript_fsm
 } from "./chunk-CBQSC6W3.js";
-import {
-  STAGE_INPUT_BUTTON_JUMP,
-  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/jumper-3d/jumper-3d-fsm.ts
 var Jumper3DState = /* @__PURE__ */ ((Jumper3DState2) => {
@@ -156,6 +159,7 @@ var Jumper3DBehaviorSystem = class {
 };
 var Jumper3DBehavior = defineBehavior({
   name: "jumper-3d",
+  metadata: BUILTIN_BEHAVIORS["jumper-3d"],
   defaultOptions,
   systemFactory: (ctx) => new Jumper3DBehaviorSystem(
     ctx.wasmStage ?? null,

package/dist/{chunk-NDJO56BB.js → chunk-IJILTFEL.js}

@@ -13,7 +13,10 @@ import {
 } from "./chunk-LWM346FW.js";
 import {
   defineBehavior
-} from "./chunk-YDLO5M7S.js";
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
 
 // src/lib/behaviors/particle-emitter/particle-emitter.descriptor.ts
 import { Group, Quaternion, Vector3 } from "three";
@@ -320,6 +323,7 @@ var ParticleEmitterBehaviorSystem = class {
 };
 var ParticleEmitterBehavior = defineBehavior({
   name: "particle-emitter",
+  metadata: BUILTIN_BEHAVIORS["particle-emitter"],
   defaultOptions,
   systemFactory: (ctx) => new ParticleEmitterBehaviorSystem(ctx.scene, ctx.getBehaviorLinks, ctx.getGlobals),
   createHandle: createParticleEmitterHandle

package/dist/{chunk-6RIS4MGM.js → chunk-IRNU4JGV.js}

@@ -1,14 +1,17 @@
+import {
+  StageRicochetDim,
+  StageRicochetReflection
+} from "./chunk-BR33KT4Z.js";
 import {
   SyncStateMachine,
   import_typescript_fsm
 } from "./chunk-CBQSC6W3.js";
-import {
-  StageRicochetDim,
-  StageRicochetReflection
-} from "./chunk-GZ3DQIIZ.js";
 import {
   defineBehavior
-} from "./chunk-YDLO5M7S.js";
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
 
 // src/lib/behaviors/ricochet-3d/ricochet-3d-fsm.ts
 var Ricochet3DState = /* @__PURE__ */ ((Ricochet3DState2) => {
@@ -426,6 +429,7 @@ var Ricochet3DSystem = class {
 };
 var Ricochet3DBehavior = defineBehavior({
   name: "ricochet-3d",
+  metadata: BUILTIN_BEHAVIORS["ricochet-3d"],
   defaultOptions,
   systemFactory: (ctx) => new Ricochet3DSystem(ctx.wasmStage ?? null, ctx.getBehaviorLinks),
   createHandle: createRicochet3DHandle

package/dist/chunk-IRPBFVAK.js

@@ -0,0 +1,141 @@
+import {
+  ADVENTURE_ABILITIES
+} from "./chunk-Y5CCNMJI.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/adventure-tools/index.ts
+var AdventureSystem = 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.$adventure ??= {};
+      entity.adventureState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachAdventure(
+          slot,
+          this.abilities,
+          link.ref.options
+        )) {
+          throw new Error(
+            "Adventureal locomotion 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.writeAdventureInput(slot, entity.$adventure);
+    }
+  }
+  postUpdate() {
+    for (const [entity, { slot }] of this.attached)
+      entity.adventureState = this.runtime?.queryAdventure(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachAdventure(slot) && this.runtime.queryAdventure(slot))
+      throw new Error(
+        "Cannot detach a morphed controller until its upright shape has clearance."
+      );
+    this.attached.delete(link.entity);
+    link.entity.adventureState = 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: 9.81,
+      speed: 6,
+      range: 12,
+      scanDuration: 1,
+      maxCarryMass: 10
+    },
+    systemFactory: (ctx) => new AdventureSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      abilities,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var AdventureToolsBehavior = descriptor(
+  "adventure-tools",
+  ADVENTURE_ABILITIES
+);
+var CombatLockOnBehavior = descriptor("combat-lock-on", [
+  "combat-lock-on"
+]);
+var HookshotPullBehavior = descriptor("hookshot-pull", [
+  "hookshot-pull"
+]);
+var GrappleSwingBehavior = descriptor("grapple-swing", [
+  "grapple-swing"
+]);
+var MorphBallTransitionBehavior = descriptor("morph-ball-transition", [
+  "morph-ball-transition"
+]);
+var MagneticTrackAdhesionBehavior = descriptor(
+  "magnetic-track-adhesion",
+  ["magnetic-track-adhesion"]
+);
+var ScanningAndDiscoveryBehavior = descriptor(
+  "scanning-and-discovery",
+  ["scanning-and-discovery"]
+);
+var FusedCarryableBombBehavior = descriptor("fused-carryable-bomb", [
+  "fused-carryable-bomb"
+]);
+var ReturningBoomerangBehavior = descriptor("returning-boomerang", [
+  "returning-boomerang"
+]);
+var KeyedInteractionGateBehavior = descriptor(
+  "keyed-interaction-gate",
+  ["keyed-interaction-gate"]
+);
+var CarryAimAndThrowBehavior = descriptor("carry-aim-and-throw", [
+  "carry-aim-and-throw"
+]);
+
+export {
+  AdventureToolsBehavior,
+  CombatLockOnBehavior,
+  HookshotPullBehavior,
+  GrappleSwingBehavior,
+  MorphBallTransitionBehavior,
+  MagneticTrackAdhesionBehavior,
+  ScanningAndDiscoveryBehavior,
+  FusedCarryableBombBehavior,
+  ReturningBoomerangBehavior,
+  KeyedInteractionGateBehavior,
+  CarryAimAndThrowBehavior
+};

package/dist/chunk-JFBR4FNX.js

@@ -0,0 +1,140 @@
+import {
+  WEAPON_ABILITIES
+} from "./chunk-GYEKT5AY.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/weapon-systems/index.ts
+var WeaponSystem = 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.$weapon ??= {};
+      entity.weaponState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachWeapons(
+          slot,
+          this.abilities,
+          link.ref.options
+        )) {
+          throw new Error(
+            "Weapon 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.weaponInput(slot, entity.$weapon);
+    }
+  }
+  postUpdate() {
+    for (const [entity, { slot }] of this.attached)
+      entity.weaponState = this.runtime?.queryWeapons(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachWeapons(slot) && this.runtime.queryWeapons(slot))
+      throw new Error("Failed to release weapon ownership.");
+    this.attached.delete(link.entity);
+    link.entity.weaponState = 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 WeaponSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      abilities,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var WeaponSystemsBehavior = descriptor(
+  "weapon-systems",
+  WEAPON_ABILITIES
+);
+var DelayedShieldRegenerationBehavior = descriptor(
+  "delayed-shield-regeneration",
+  ["delayed-shield-regeneration"]
+);
+var WeaponHeatAndVentBehavior = descriptor("weapon-heat-and-vent", [
+  "weapon-heat-and-vent"
+]);
+var InterruptibleMagazineReloadBehavior = descriptor(
+  "interruptible-magazine-reload",
+  ["interruptible-magazine-reload"]
+);
+var StickyGrenadeAttachmentBehavior = descriptor(
+  "sticky-grenade-attachment",
+  ["sticky-grenade-attachment"]
+);
+var AlternateWeaponModeBehavior = descriptor("alternate-weapon-mode", [
+  "alternate-weapon-mode"
+]);
+var RemoteGuidedProjectileBehavior = descriptor(
+  "remote-guided-projectile",
+  ["remote-guided-projectile"]
+);
+var ChargeAndReleaseShotBehavior = descriptor(
+  "charge-and-release-shot",
+  ["charge-and-release-shot"]
+);
+var MaterialPenetratingShotBehavior = descriptor(
+  "material-penetrating-shot",
+  ["material-penetrating-shot"]
+);
+var BeamMissileCombinationBehavior = descriptor(
+  "beam-missile-combination",
+  ["beam-missile-combination"]
+);
+var StationaryAimModeBehavior = descriptor("stationary-aim-mode", [
+  "stationary-aim-mode"
+]);
+
+export {
+  WeaponSystemsBehavior,
+  DelayedShieldRegenerationBehavior,
+  WeaponHeatAndVentBehavior,
+  InterruptibleMagazineReloadBehavior,
+  StickyGrenadeAttachmentBehavior,
+  AlternateWeaponModeBehavior,
+  RemoteGuidedProjectileBehavior,
+  ChargeAndReleaseShotBehavior,
+  MaterialPenetratingShotBehavior,
+  BeamMissileCombinationBehavior,
+  StationaryAimModeBehavior
+};

package/dist/{chunk-ERS6SNA5.js → chunk-K34N2CBL.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/screen-visibility/screen-visibility.descriptor.ts
 import {
@@ -357,6 +360,7 @@ function createScreenVisibilityHandle(ref) {
 }
 var ScreenVisibilityBehavior = defineBehavior({
   name: "screen-visibility",
+  metadata: BUILTIN_BEHAVIORS["screen-visibility"],
   defaultOptions,
   systemFactory: (ctx) => new ScreenVisibilitySystem(ctx.scene, ctx.getBehaviorLinks),
   createHandle: createScreenVisibilityHandle