@zylem/behaviors 0.8.9 → 0.8.11

package/dist/chunk-5AJJ44QK.js

@@ -0,0 +1,129 @@
+// src/lib/behaviors/matching-pinball/types.ts
+var MATCHING_ABILITIES = [
+  "adjacent-panel-swap",
+  "simultaneous-match-clear",
+  "column-collapse",
+  "cascade-chain-credit",
+  "rising-stack-pressure",
+  "garbage-block-conversion",
+  "powered-pinball-flipper",
+  "spring-plunger-launch",
+  "active-bumper-kick",
+  "pinball-mode-objectives"
+];
+var MATCHING_EVENTS = [
+  ...MATCHING_ABILITIES,
+  "board-or-clock",
+  "bumper-contact"
+];
+function matchingData(o) {
+  return [
+    o.width ?? 6,
+    o.height ?? 8,
+    o.colors ?? 5,
+    o.swapMs ?? 100,
+    o.clearMs ?? 250,
+    o.settleMs ?? 150,
+    o.riseMs ?? 2e3,
+    o.dangerMs ?? 2e3,
+    o.chainWindowMs ?? 1500,
+    o.seed ?? 1,
+    o.launchReach ?? 1,
+    0,
+    0,
+    0,
+    0,
+    0
+  ];
+}
+function matchingOperation(a) {
+  switch (a.type) {
+    case "swap":
+      return { op: 0, data: [a.x, a.y, a.toX, a.toY] };
+    case "match":
+      return { op: 4, data: [] };
+    case "collapse":
+      return { op: 8, data: [] };
+    case "chain-match":
+      return { op: 12, data: [] };
+    case "chain-collapse":
+      return { op: 13, data: [] };
+    case "pressure":
+      return { op: 16, data: [] };
+    case "pause-rise":
+      return { op: 17, data: [a.duration] };
+    case "garbage":
+      return { op: 20, data: [a.x, a.y, a.width, a.height, a.region] };
+    case "garbage-match":
+      return { op: 21, data: [] };
+    case "flipper":
+      return {
+        op: 24,
+        data: [
+          a.pivotX,
+          a.pivotY,
+          a.pivotZ,
+          a.rest,
+          a.active,
+          a.stiffness,
+          a.damping,
+          a.maxForce
+        ]
+      };
+    case "flipper-input":
+      return { op: 25, data: [a.pressed] };
+    case "stage-ball":
+      return {
+        op: 28,
+        data: [a.directionX, a.directionY, a.directionZ, a.maxImpulse]
+      };
+    case "pull":
+      return { op: 29, data: [a.amount] };
+    case "launch":
+      return { op: 30, data: [] };
+    case "cancel-launch":
+      return { op: 31, data: [] };
+    case "bumper":
+      return { op: 32, data: [a.impulse, a.cooldown, a.reward] };
+    case "bumper-hit":
+      return { op: 33, data: [] };
+    case "mode":
+      return {
+        op: 36,
+        data: [
+          a.length,
+          a.duration,
+          a.reward,
+          a.target0,
+          a.target1,
+          a.target2,
+          a.target3,
+          a.target4,
+          a.target5,
+          a.target6,
+          a.target7
+        ]
+      };
+    case "mode-start":
+      return { op: 37, data: [] };
+    case "mode-hit":
+      return { op: 38, data: [a.row] };
+    case "mode-cancel":
+      return { op: 39, data: [] };
+    case "cell":
+      return { op: 40, data: [a.x, a.y, a.color] };
+    case "start-board":
+      return { op: 41, data: [] };
+    case "clock":
+      return { op: 42, data: [a.timestamp] };
+    case "mode-target":
+      return { op: 43, data: [a.row] };
+  }
+}
+
+export {
+  MATCHING_ABILITIES,
+  MATCHING_EVENTS,
+  matchingData,
+  matchingOperation
+};

package/dist/{chunk-YDLO5M7S.js → chunk-5SMXQ6AU.js}

@@ -2,6 +2,7 @@
 function defineBehavior(config) {
   return {
     key: /* @__PURE__ */ Symbol.for(`zylem:behavior:${config.name}`),
+    metadata: config.metadata,
     defaultOptions: config.defaultOptions,
     systemFactory: config.systemFactory,
     createHandle: config.createHandle

package/dist/chunk-5VJIP535.js

@@ -0,0 +1,71 @@
+// src/lib/behaviors/stealth-city/types.ts
+var CITY_ABILITIES = [
+  "vision-cone-awareness",
+  "last-seen-search",
+  "noise-investigation",
+  "footprint-trail-following",
+  "contextual-disguise",
+  "alarm-communication-network",
+  "wanted-level-escalation",
+  "pursuit-evasion-decay",
+  "pedestrian-panic-propagation",
+  "traffic-junction-yield"
+];
+var CITY_INTENTS = [
+  "hold",
+  "observe",
+  "search",
+  "investigate",
+  "track",
+  "flee",
+  "wait",
+  "drive"
+];
+var CITY_EVENTS = [
+  "none",
+  "awareness-changed",
+  "search-ended",
+  "noise-heard",
+  "clue-reached",
+  "disguise-changed",
+  "report-sent",
+  "alert-received",
+  "wanted-changed",
+  "panic",
+  "traffic-changed"
+];
+var CITY_LINKS = [
+  "target",
+  "radio",
+  "neighbor",
+  "junction",
+  "observer"
+];
+function cityData(o) {
+  return [
+    o.visionRange ?? 20,
+    o.coneCosine ?? 0.5,
+    o.suspicionRate ?? 1,
+    o.suspicionDecay ?? 0.5,
+    o.alertThreshold ?? 1,
+    o.searchDuration ?? 6,
+    o.searchRadius ?? 3,
+    o.hearingRange ?? 15,
+    o.noiseMemory ?? 3,
+    o.trailLifetime ?? 8,
+    o.disguiseModifier ?? 0.2,
+    o.reportDelay ?? 0.5,
+    o.wantedDecay ?? 2,
+    o.evasionDelay ?? 3,
+    o.panicDuration ?? 3,
+    o.trafficSpeed ?? 8
+  ];
+}
+
+export {
+  CITY_ABILITIES,
+  CITY_INTENTS,
+  CITY_EVENTS,
+  CITY_LINKS,
+  cityData
+};

package/dist/chunk-6DTIJB7B.js

@@ -0,0 +1,166 @@
+// src/lib/behaviors/tactical-grid/types.ts
+var TACTICS_ABILITIES = [
+  "terrain-movement-budget",
+  "min-max-attack-range",
+  "terrain-defense-modifier",
+  "counterattack-and-follow-up",
+  "weapon-advantage-cycle",
+  "persistent-unit-loss",
+  "progressive-building-capture",
+  "fuel-ammunition-resupply",
+  "transport-load-unload",
+  "commander-power-window"
+];
+var TACTICS_EVENTS = [...TACTICS_ABILITIES, "host-update"];
+function tacticsData(o) {
+  return [
+    o.width ?? 6,
+    o.height ?? 6,
+    o.followUpSpeedThreshold ?? 4,
+    o.captureStrength ?? 10,
+    o.maximumFuel ?? 100,
+    o.maximumAmmo ?? 10,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+  ];
+}
+function tacticsOperation(a) {
+  switch (a.type) {
+    case "movement-cost":
+      return { op: 0, data: [a.unitClass, a.terrain, a.cost] };
+    case "reachable":
+      return { op: 1, data: [a.row] };
+    case "move":
+      return { op: 2, data: [a.row, a.x, a.y] };
+    case "weapon-range":
+      return {
+        op: 4,
+        data: [a.row, a.minimum, a.maximum, Number(a.lineOfSight)]
+      };
+    case "range-map":
+      return { op: 5, data: [a.row] };
+    case "check-range":
+      return { op: 6, data: [a.attacker, a.defender] };
+    case "terrain-profile":
+      return {
+        op: 8,
+        data: [a.unitClass, a.terrain, a.defense, a.avoid, a.recovery]
+      };
+    case "terrain-evaluate":
+      return { op: 9, data: [a.row, a.raw, a.seed] };
+    case "terrain-recover":
+      return { op: 10, data: [a.row] };
+    case "combat-start":
+      return { op: 12, data: [a.attacker, a.defender, a.combatSerial, a.seed] };
+    case "combat-next":
+      return { op: 13, data: [] };
+    case "combat-cancel":
+      return { op: 14, data: [] };
+    case "weapon-durability":
+      return { op: 15, data: [a.row, a.durability] };
+    case "advantage-row":
+      return {
+        op: 16,
+        data: [a.attackerWeapon, a.defenderWeapon, a.damage, a.hit]
+      };
+    case "evaluate-advantage":
+      return { op: 17, data: [a.attacker, a.defender] };
+    case "defeat":
+      return { op: 20, data: [a.row] };
+    case "loss-exception":
+      return { op: 21, data: [a.row, Number(a.exempt)] };
+    case "recover":
+      return { op: 22, data: [a.row, a.health] };
+    case "capture-building":
+      return { op: 24, data: [a.row, a.structure] };
+    case "supply-profile":
+      return { op: 28, data: [a.row, a.classMask] };
+    case "spend-resources":
+      return { op: 29, data: [a.row, a.fuel, a.ammo, a.resourceSerial] };
+    case "resupply-unit":
+      return { op: 30, data: [a.supplier, a.recipient, a.fuel, a.ammo] };
+    case "resupply-facility":
+      return { op: 31, data: [a.row, a.structure, a.fuel, a.ammo] };
+    case "transport-profile":
+      return { op: 32, data: [a.row, a.capacity, a.classMask, a.size] };
+    case "load":
+      return { op: 33, data: [a.carrier, a.cargo] };
+    case "unload":
+      return { op: 34, data: [a.carrier, a.cargo, a.x, a.y] };
+    case "power-profile":
+      return {
+        op: 36,
+        data: [
+          a.team,
+          a.threshold,
+          a.duration,
+          a.attack,
+          a.defense,
+          a.movement
+        ]
+      };
+    case "power-charge":
+      return { op: 37, data: [a.team, a.amount, a.chargeSerial] };
+    case "power-activate":
+      return { op: 38, data: [a.team] };
+    case "power-cancel":
+      return { op: 39, data: [a.team] };
+    case "unit":
+      return {
+        op: 40,
+        data: [
+          a.row,
+          a.x,
+          a.y,
+          a.team,
+          a.unitClass,
+          a.health,
+          a.maximumHealth,
+          a.movement,
+          a.attack,
+          a.defense,
+          a.speed,
+          a.weapon,
+          a.minimumRange,
+          a.maximumRange,
+          a.fuel,
+          a.ammo
+        ]
+      };
+    case "tile":
+      return { op: 41, data: [a.x, a.y, a.terrain, Number(a.blocked)] };
+    case "begin-turn":
+      return { op: 42, data: [a.phase, a.team] };
+    case "structure":
+      return {
+        op: 43,
+        data: [
+          a.row,
+          a.x,
+          a.y,
+          a.owner,
+          a.maximumCapture,
+          a.fuel,
+          a.ammo,
+          a.classMask
+        ]
+      };
+    case "host-health":
+      return { op: 44, data: [a.row, a.health] };
+  }
+}
+
+export {
+  TACTICS_ABILITIES,
+  TACTICS_EVENTS,
+  tacticsData,
+  tacticsOperation
+};

package/dist/chunk-73MHJY6R.js

@@ -0,0 +1,78 @@
+// src/lib/behaviors/combat-ai/types.ts
+var ENCOUNTER_ABILITIES = [
+  "squad-flank-assignment",
+  "leader-loss-morale",
+  "grenade-danger-evasion",
+  "cover-peek-cycle",
+  "threat-target-selection",
+  "tactical-burst-selection",
+  "latent-ambush-activation",
+  "boss-phase-controller",
+  "localized-weak-point-damage",
+  "shootable-projectile-interception"
+];
+var ENCOUNTER_INTENTS = [
+  "hold",
+  "flank",
+  "retreat",
+  "evade",
+  "hide",
+  "peek",
+  "attack",
+  "reposition",
+  "dormant",
+  "dead",
+  "intercepted",
+  "impact"
+];
+var ENCOUNTER_EVENTS = [
+  "none",
+  "target-changed",
+  "flank-assigned",
+  "morale-changed",
+  "evasion",
+  "cover-changed",
+  "fire-request",
+  "activated",
+  "phase-changed",
+  "damage",
+  "stagger",
+  "intercepted",
+  "impact"
+];
+var ENCOUNTER_LINKS = [
+  "candidate",
+  "leader",
+  "ally",
+  "cover",
+  "hazard",
+  "region"
+];
+function encounterData(o) {
+  return [
+    o.health ?? 100,
+    o.team ?? 1,
+    o.squad ?? 0,
+    o.perceptionRange ?? 20,
+    o.flankRadius ?? 4,
+    o.retreatThreshold ?? 0.4,
+    o.leaderPenalty ?? 0.5,
+    o.casualtyPenalty ?? 0.2,
+    o.dangerHorizon ?? 3,
+    o.evadeSpeed ?? 6,
+    o.concealDuration ?? 0.7,
+    o.attackDuration ?? 0.4,
+    o.shotInterval ?? 0.15,
+    o.burstPause ?? 0.6,
+    o.activationDelay ?? 0.3,
+    o.targetHysteresis ?? 2
+  ];
+}
+
+export {
+  ENCOUNTER_ABILITIES,
+  ENCOUNTER_INTENTS,
+  ENCOUNTER_EVENTS,
+  ENCOUNTER_LINKS,
+  encounterData
+};

package/dist/chunk-73YASAYS.js

@@ -0,0 +1,137 @@
+import {
+  SURVIVAL_ABILITIES
+} from "./chunk-PDHHOVVQ.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/survival-resources/index.ts
+var SurvivalSystem = 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.survivalState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachSurvival(
+          slot,
+          this.abilities,
+          link.ref.options
+        )) {
+          throw new Error(
+            "Survival 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.survivalState = this.runtime?.querySurvival(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachSurvival(slot) && this.runtime.querySurvival(slot))
+      throw new Error("Failed to detach survival policy.");
+    this.attached.delete(link.entity);
+    link.entity.survivalState = 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: {
+      followDistance: 1.5,
+      columns: 6
+    },
+    systemFactory: (ctx) => new SurvivalSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      abilities,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var SurvivalResourcesBehavior = descriptor(
+  "survival-resources",
+  SURVIVAL_ABILITIES
+);
+var EscortFollowWaitBehavior = descriptor("escort-follow-wait", [
+  "escort-follow-wait"
+]);
+var CompanionAbductionObjectiveBehavior = descriptor(
+  "companion-abduction-objective",
+  ["companion-abduction-objective"]
+);
+var EnvironmentalVaultActionBehavior = descriptor(
+  "environmental-vault-action",
+  ["environmental-vault-action"]
+);
+var StaggerFinisherOpportunityBehavior = descriptor(
+  "stagger-finisher-opportunity",
+  ["stagger-finisher-opportunity"]
+);
+var AdaptiveEncounterPressureBehavior = descriptor(
+  "adaptive-encounter-pressure",
+  ["adaptive-encounter-pressure"]
+);
+var SpatialInventoryPackingBehavior = descriptor(
+  "spatial-inventory-packing",
+  ["spatial-inventory-packing"]
+);
+var IngredientCombinationBehavior = descriptor(
+  "ingredient-combination",
+  ["ingredient-combination"]
+);
+var WeaponUpgradeTrackBehavior = descriptor("weapon-upgrade-track", [
+  "weapon-upgrade-track"
+]);
+var EncounterClearLockBehavior = descriptor("encounter-clear-lock", [
+  "encounter-clear-lock"
+]);
+var SavePointCheckpointBehavior = descriptor("save-point-checkpoint", [
+  "save-point-checkpoint"
+]);
+
+export {
+  SurvivalResourcesBehavior,
+  EscortFollowWaitBehavior,
+  CompanionAbductionObjectiveBehavior,
+  EnvironmentalVaultActionBehavior,
+  StaggerFinisherOpportunityBehavior,
+  AdaptiveEncounterPressureBehavior,
+  SpatialInventoryPackingBehavior,
+  IngredientCombinationBehavior,
+  WeaponUpgradeTrackBehavior,
+  EncounterClearLockBehavior,
+  SavePointCheckpointBehavior
+};

package/dist/{chunk-LLDLVVG4.js → chunk-7HGDADLB.js}

@@ -3,18 +3,22 @@ import {
   computeBounds3DHits,
   constrainMovementToBounds3D,
   hasAnyBounds3DHit,
-  insetBounds3D
-} from "./chunk-WHKPWIQO.js";
+  insetBounds3D,
+  normalizeBounds3DPadding
+} from "./chunk-HMVEQB2T.js";
+import {
+  StageBoundaryDim
+} from "./chunk-BR33KT4Z.js";
 import {
   SyncStateMachine,
   import_typescript_fsm
-} from "./chunk-OBF6BIA2.js";
-import {
-  StageBoundaryDim
-} from "./chunk-GZ3DQIIZ.js";
+} from "./chunk-CBQSC6W3.js";
 import {
   defineBehavior
-} from "./chunk-YDLO5M7S.js";
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
 
 // src/lib/behaviors/world-boundary-3d/world-boundary-3d-fsm.ts
 var WorldBoundary3DState = /* @__PURE__ */ ((WorldBoundary3DState2) => {
@@ -134,6 +138,18 @@ function createWorldBoundary3DHandle(ref) {
     }
   };
 }
+function paddedRuntimeBounds(bounds, padding) {
+  const f32 = Math.fround;
+  const pad = normalizeBounds3DPadding(padding);
+  return {
+    left: f32(f32(bounds.left) + f32(pad.x)),
+    right: f32(f32(bounds.right) - f32(pad.x)),
+    bottom: f32(f32(bounds.bottom) + f32(pad.y)),
+    top: f32(f32(bounds.top) - f32(pad.y)),
+    back: f32(f32(bounds.back) + f32(pad.z)),
+    front: f32(f32(bounds.front) - f32(pad.z))
+  };
+}
 var WorldBoundary3DSystem = class {
   constructor(wasmStage, getBehaviorLinks) {
     this.wasmStage = wasmStage;
@@ -159,8 +175,7 @@ var WorldBoundary3DSystem = class {
       if (query) {
         boundaryRef.fsm.update(
           { x: query.clamped[0], y: query.clamped[1], z: query.clamped[2] },
-          options.boundaries,
-          options.padding
+          paddedRuntimeBounds(options.boundaries, options.padding)
         );
       }
     }
@@ -185,6 +200,7 @@ var WorldBoundary3DSystem = class {
 };
 var WorldBoundary3DBehavior = defineBehavior({
   name: "world-boundary-3d",
+  metadata: BUILTIN_BEHAVIORS["world-boundary-3d"],
   defaultOptions,
   systemFactory: (ctx) => new WorldBoundary3DSystem(ctx.wasmStage ?? null, ctx.getBehaviorLinks),
   createHandle: createWorldBoundary3DHandle