@zylem/behaviors 0.8.9 → 0.8.11

package/dist/chunk-VSFWETXS.js

@@ -0,0 +1,127 @@
+import {
+  SQUAD_ABILITIES
+} from "./chunk-TSYXRRS4.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/squad-rts/index.ts
+var SquadSystem = 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.squadState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachSquad(slot, this.abilities, link.ref.options)) {
+          throw new Error(
+            "Squad attachment requires valid options and an available squad component slot."
+          );
+        }
+        this.attached.set(entity, { slot, ref: link.ref });
+      }
+    }
+  }
+  postUpdate() {
+    for (const [entity, { slot }] of this.attached)
+      entity.squadState = this.runtime?.querySquad(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0 && this.runtime && !this.runtime.detachSquad(slot) && this.runtime.querySquad(slot))
+      throw new Error("Failed to detach squad policy.");
+    this.attached.delete(link.entity);
+    link.entity.squadState = 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: {
+      speed: 2,
+      reach: 1.5
+    },
+    systemFactory: (ctx) => new SquadSystem(
+      /* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`),
+      abilities,
+      ctx.wasmStage ?? null,
+      ctx.getBehaviorLinks
+    )
+  });
+}
+var SquadRtsBehavior = descriptor("squad-rts", SQUAD_ABILITIES);
+var WhistleRecallBehavior = descriptor("whistle-recall", [
+  "whistle-recall"
+]);
+var SquadFormationFollowBehavior = descriptor(
+  "squad-formation-follow",
+  ["squad-formation-follow"]
+);
+var ThrownWorkerDeploymentBehavior = descriptor(
+  "thrown-worker-deployment",
+  ["thrown-worker-deployment"]
+);
+var CooperativeObjectTransportBehavior = descriptor(
+  "cooperative-object-transport",
+  ["cooperative-object-transport"]
+);
+var CooperativeConstructionWorkBehavior = descriptor(
+  "cooperative-construction-work",
+  ["cooperative-construction-work"]
+);
+var SurfaceLatchAttackBehavior = descriptor("surface-latch-attack", [
+  "surface-latch-attack"
+]);
+var SpeciesHazardAffinityBehavior = descriptor(
+  "species-hazard-affinity",
+  ["species-hazard-affinity"]
+);
+var GrowthStageMobilityBehavior = descriptor("growth-stage-mobility", [
+  "growth-stage-mobility"
+]);
+var DeliveredResourceConversionBehavior = descriptor(
+  "delivered-resource-conversion",
+  ["delivered-resource-conversion"]
+);
+var DayEndUnitRecallBehavior = descriptor("day-end-unit-recall", [
+  "day-end-unit-recall"
+]);
+
+export {
+  SquadRtsBehavior,
+  WhistleRecallBehavior,
+  SquadFormationFollowBehavior,
+  ThrownWorkerDeploymentBehavior,
+  CooperativeObjectTransportBehavior,
+  CooperativeConstructionWorkBehavior,
+  SurfaceLatchAttackBehavior,
+  SpeciesHazardAffinityBehavior,
+  GrowthStageMobilityBehavior,
+  DeliveredResourceConversionBehavior,
+  DayEndUnitRecallBehavior
+};

package/dist/chunk-VU4LTE2X.js

@@ -0,0 +1,147 @@
+// src/lib/behaviors/action-rpg/types.ts
+var RPG_ABILITIES = [
+  "equipment-stat-aggregation",
+  "durability-and-repair",
+  "affix-budget-generation",
+  "death-drop-ownership",
+  "consumable-belt-slots",
+  "seeded-loot-table",
+  "damage-to-resource-leech",
+  "typed-resistance-resolution",
+  "autonomous-familiar",
+  "resource-draining-transformation"
+];
+var RPG_EVENTS = [
+  ...RPG_ABILITIES,
+  "familiar-attack",
+  "familiar-support"
+];
+function rpgData(o) {
+  return [
+    o.strength ?? 10,
+    o.defense ?? 5,
+    o.speed ?? 3,
+    o.maximumHealth ?? 100,
+    o.maximumMana ?? 50,
+    o.currency ?? 100,
+    o.repairUnitCost ?? 2,
+    o.pickupRange ?? 2,
+    o.reservationSeconds ?? 3,
+    o.followDistance ?? 1,
+    o.familiarSpeed ?? 3,
+    o.actionRange ?? 1.5,
+    o.actionCooldown ?? 1,
+    o.leashRange ?? 10,
+    o.maximumDrain ?? 100,
+    o.maximumRadius ?? 3
+  ];
+}
+function rpgOperation(a) {
+  switch (a.type) {
+    case "equipment-register":
+      return {
+        op: 0,
+        data: [a.slotMask, a.requiredStrength, ...a.flat, ...a.percent]
+      };
+    case "equip":
+      return { op: 1, data: [a.slot] };
+    case "unequip":
+      return { op: 2, data: [a.slot] };
+    case "base-stats":
+      return { op: 3, data: [...a.values] };
+    case "durability-register":
+      return { op: 4, data: [a.current, a.maximum] };
+    case "wear":
+      return { op: 5, data: [a.amount, a.useSerial] };
+    case "repair":
+      return { op: 6, data: [a.amount] };
+    case "wallet":
+      return { op: 7, data: [a.currency] };
+    case "affix-row":
+      return {
+        op: 8,
+        data: [
+          a.row,
+          a.id,
+          a.cost,
+          a.level,
+          a.classMask,
+          a.group,
+          a.stat,
+          a.amount,
+          a.weight
+        ]
+      };
+    case "affix-roll":
+      return {
+        op: 9,
+        data: [a.seed, a.level, a.itemClass, a.budget, a.count]
+      };
+    case "affix-clear":
+      return { op: 10, data: [] };
+    case "drop-public":
+    case "drop-reserve":
+      return { op: 12, data: [a.itemType, a.rarity] };
+    case "death-drop":
+      return { op: 13, data: [a.deathSerial, a.lootSerial, a.affixSerial] };
+    case "drop-pickup":
+      return { op: 14, data: [] };
+    case "belt-stock":
+      return { op: 16, data: [a.slot, a.count, a.kind, a.potency] };
+    case "belt-use":
+      return { op: 17, data: [a.slot] };
+    case "belt-move":
+      return { op: 18, data: [a.from, a.to] };
+    case "belt-resources":
+      return { op: 19, data: [a.health, a.mana] };
+    case "loot-row":
+      return {
+        op: 20,
+        data: [a.row, a.itemType, a.weight, a.level, a.rarity]
+      };
+    case "loot-roll":
+      return { op: 21, data: [a.seed, a.level] };
+    case "loot-clear":
+      return { op: 22, data: [] };
+    case "leech-rates":
+      return { op: 24, data: [a.health, a.mana] };
+    case "leech":
+      return { op: 25, data: [a.damage, a.damageSerial, a.flags] };
+    case "leech-resources":
+      return { op: 26, data: [a.health, a.mana] };
+    case "resistance":
+      return { op: 28, data: [a.damageType, a.resistance, Number(a.immune)] };
+    case "resolve-damage":
+      return {
+        op: 29,
+        data: [
+          a.raw,
+          a.damageType,
+          a.damageSerial,
+          a.flags,
+          a.availableHealth
+        ]
+      };
+    case "familiar-bind":
+      return { op: 32, data: [a.role] };
+    case "familiar-candidate":
+      return { op: 33, data: [] };
+    case "familiar-stop":
+      return { op: 34, data: [] };
+    case "familiar-remove":
+      return { op: 35, data: [] };
+    case "transform":
+      return { op: 36, data: [a.form, a.radius, a.drain, a.speed] };
+    case "revert":
+      return { op: 37, data: [] };
+    case "form-mana":
+      return { op: 38, data: [a.mana] };
+  }
+}
+
+export {
+  RPG_ABILITIES,
+  RPG_EVENTS,
+  rpgData,
+  rpgOperation
+};

package/dist/chunk-WF6HC5U3.js

@@ -0,0 +1,8 @@
+// src/lib/behaviors/acrobatics-2d/types.ts
+var TRAVERSAL_ABILITIES = ["running-long-jump", "chained-jump", "crouch-backflip", "wall-kick", "ledge-hang-and-mantle", "pole-climb", "ceiling-hang-traverse", "ground-pound-impact", "dive-to-belly-slide", "temporary-actor-possession"];
+var ACROBATICS_ACTIONS = ["grounded", "jump", "long jump", "double jump", "triple jump", "backflip", "falling", "wall kick", "ledge hang", "pole climb", "ceiling hang", "pound windup", "pound descent", "impact recovery", "dive", "belly slide", "possessing", "mantle"];
+
+export {
+  TRAVERSAL_ABILITIES,
+  ACROBATICS_ACTIONS
+};

package/dist/chunk-WG5NCDS4.js

@@ -0,0 +1,99 @@
+import {
+  TRAVERSAL_ABILITIES
+} from "./chunk-WF6HC5U3.js";
+import {
+  defineBehavior
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
+
+// src/lib/behaviors/acrobatics-2d/index.ts
+var AcrobaticsSystem = 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.$acrobatics ??= { moveX: 0, jump: false, crouch: false };
+      entity.acrobaticsState ??= null;
+      const slot = entity.runtimeHandle;
+      if (!Number.isInteger(slot) || slot < 0) continue;
+      if (!this.attached.has(entity)) {
+        if (!this.runtime.attachAcrobatics(slot, this.abilities, link.ref.options)) {
+          throw new Error("Acrobatics requires exclusive motion ownership and a dynamic body with gravityScale=0 and a solid collider.");
+        }
+        this.attached.set(entity, { slot, ref: link.ref });
+      }
+      const input = entity.$acrobatics;
+      this.runtime.writeInputAxes(slot, input.moveX, input.moveY ?? 0);
+      this.runtime.writeInputButton(slot, 1, input.jump);
+      this.runtime.writeInputButton(slot, 4, input.crouch);
+      this.runtime.writeInputLook(slot, input.moveZ ?? 0, 0);
+      this.runtime.writeInputButton(slot, 8, input.action ?? false);
+      this.runtime.writeInputButton(slot, 16, input.grab ?? false);
+      this.runtime.writeInputButton(slot, 32, input.release ?? false);
+    }
+  }
+  postUpdate() {
+    for (const [entity, { slot }] of this.attached) entity.acrobaticsState = this.runtime?.queryAcrobatics(slot) ?? null;
+  }
+  detach(link) {
+    const slot = this.attached.get(link.entity)?.slot;
+    if (slot !== void 0) this.runtime?.detachAcrobatics(slot);
+    this.attached.delete(link.entity);
+    link.entity.acrobaticsState = 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: { moveSpeed: 6, jumpSpeed: 10, gravity: 24, chainWindow: 0.25 },
+    systemFactory: (ctx) => new AcrobaticsSystem(/* @__PURE__ */ Symbol.for(`zylem:behavior:${name}`), abilities, ctx.wasmStage ?? null, ctx.getBehaviorLinks)
+  });
+}
+var AcrobaticMovement2DBehavior = descriptor("acrobatics-2d", ["running-long-jump", "chained-jump", "crouch-backflip"]);
+var RunningLongJumpBehavior = descriptor("running-long-jump", ["running-long-jump"]);
+var ChainedJumpBehavior = descriptor("chained-jump", ["chained-jump"]);
+var CrouchBackflipBehavior = descriptor("crouch-backflip", ["crouch-backflip"]);
+var PlatformerTraversalBehavior = descriptor("platformer-traversal", TRAVERSAL_ABILITIES);
+var WallKickBehavior = descriptor("wall-kick", ["wall-kick"]);
+var LedgeHangAndMantleBehavior = descriptor("ledge-hang-and-mantle", ["ledge-hang-and-mantle"]);
+var PoleClimbBehavior = descriptor("pole-climb", ["pole-climb"]);
+var CeilingHangTraverseBehavior = descriptor("ceiling-hang-traverse", ["ceiling-hang-traverse"]);
+var GroundPoundImpactBehavior = descriptor("ground-pound-impact", ["ground-pound-impact"]);
+var DiveToBellySlideBehavior = descriptor("dive-to-belly-slide", ["dive-to-belly-slide"]);
+var TemporaryActorPossessionBehavior = descriptor("temporary-actor-possession", ["temporary-actor-possession"]);
+
+export {
+  AcrobaticMovement2DBehavior,
+  RunningLongJumpBehavior,
+  ChainedJumpBehavior,
+  CrouchBackflipBehavior,
+  PlatformerTraversalBehavior,
+  WallKickBehavior,
+  LedgeHangAndMantleBehavior,
+  PoleClimbBehavior,
+  CeilingHangTraverseBehavior,
+  GroundPoundImpactBehavior,
+  DiveToBellySlideBehavior,
+  TemporaryActorPossessionBehavior
+};

package/dist/{chunk-7LHXAEOZ.js → chunk-WUYHS6JZ.js}

@@ -8,10 +8,13 @@ import {
 } from "./chunk-VJ3UA6OD.js";
 import {
   StageTopDownPlane
-} from "./chunk-GZ3DQIIZ.js";
+} from "./chunk-BR33KT4Z.js";
 import {
   defineBehavior
-} from "./chunk-YDLO5M7S.js";
+} from "./chunk-5SMXQ6AU.js";
+import {
+  BUILTIN_BEHAVIORS
+} from "./chunk-S44ZHYE6.js";
 
 // src/lib/behaviors/top-down-movement/top-down-movement.descriptor.ts
 var defaultOptions = {
@@ -87,6 +90,7 @@ var TopDownMovementBehaviorSystem = class {
 };
 var TopDownMovementBehavior = defineBehavior({
   name: "top-down-movement",
+  metadata: BUILTIN_BEHAVIORS["top-down-movement"],
   defaultOptions,
   systemFactory: (ctx) => new TopDownMovementBehaviorSystem(ctx.wasmStage ?? null, ctx.getBehaviorLinks),
   createHandle: createTopDownMovementHandle

package/dist/chunk-XNRY6NOC.js

@@ -0,0 +1,120 @@
+// src/lib/behaviors/spatial-puzzles/types.ts
+var PUZZLE_ABILITIES = [
+  "weighted-pressure-switch",
+  "grid-constrained-push-block",
+  "mirror-beam-routing",
+  "conductive-contact-network",
+  "material-ignition-spread",
+  "freeze-and-shatter",
+  "stasis-impulse-storage",
+  "magnetic-object-manipulation",
+  "water-level-mechanism",
+  "timed-solid-platform"
+];
+function puzzleData(a, o) {
+  let data;
+  switch (a) {
+    case "weighted-pressure-switch":
+      data = [
+        o.threshold ?? 1,
+        o.releaseDelay ?? 0.2,
+        o.occupancy ? 1 : 0
+      ];
+      break;
+    case "grid-constrained-push-block":
+      data = [o.cellSize ?? 1];
+      break;
+    case "mirror-beam-routing":
+      data = [
+        ["emitter", "mirror", "receiver"].indexOf(
+          o.beamRole ?? "emitter"
+        ),
+        o.range ?? 20,
+        o.maxSegments ?? 8,
+        ...o.direction ?? [1, 0, 0]
+      ];
+      break;
+    case "conductive-contact-network":
+      data = [o.source ? 1 : 0, o.contactGap ?? 0.02];
+      break;
+    case "material-ignition-spread":
+      data = [
+        o.ignition ?? 1,
+        o.fuel ?? 5,
+        o.heatRate ?? 3,
+        o.cooling ?? 0.2,
+        o.spreadRadius ?? 2,
+        o.wetness ?? 0
+      ];
+      break;
+    case "freeze-and-shatter":
+      data = [
+        o.duration ?? 2,
+        o.coldThreshold ?? 1,
+        o.shatterThreshold ?? 2,
+        o.resistance ?? 0
+      ];
+      break;
+    case "stasis-impulse-storage":
+      data = [o.duration ?? 2, o.maxImpulse ?? 10];
+      break;
+    case "magnetic-object-manipulation":
+      data = [
+        o.range ?? 8,
+        o.stiffness ?? 12,
+        o.damping ?? 5,
+        o.maxForce ?? 50
+      ];
+      break;
+    case "water-level-mechanism":
+      data = [
+        o.low ?? 0,
+        o.high ?? 3,
+        o.speed ?? 1,
+        o.halfWidth ?? 5,
+        o.bottom ?? -3,
+        o.halfDepth ?? 5
+      ];
+      break;
+    case "timed-solid-platform":
+      data = [
+        o.solidDuration ?? 2,
+        o.warningDuration ?? 0.5,
+        o.absentDuration ?? 1
+      ];
+      break;
+  }
+  return [...data, ...Array(16 - data.length).fill(0)];
+}
+function puzzleCommandData(c) {
+  switch (c.type) {
+    case "push":
+      return [1, ...c.direction];
+    case "aim":
+      return [2, ...c.direction];
+    case "power":
+      return [3, c.enabled ? 1 : 0, 0, 0];
+    case "heat":
+      return [4, c.amount, 0, 0];
+    case "wetness":
+      return [5, c.value, 0, 0];
+    case "cold":
+      return [6, c.amount, 0, 0];
+    case "impact":
+      return [7, ...c.impulse];
+    case "activate":
+      return [8, 0, 0, 0];
+    case "release":
+      return [9, 0, 0, 0];
+    case "target":
+      return [10, ...c.position];
+    case "level":
+      return [11, c.high ? 1 : 0, 0, 0];
+  }
+}
+
+export {
+  PUZZLE_ABILITIES,
+  puzzleData,
+  puzzleCommandData
+};

package/dist/{chunk-55CFXXZH.js → chunk-XT47QZQ6.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-3d/components.ts
 function createPlatformer3DMovementComponent(options = {}) {
@@ -168,7 +171,8 @@ var Platformer3DFSM = class {
     const currentState = this.getState();
     const hasInput = Math.abs(input.moveX) > 0.1 || Math.abs(input.moveZ) > 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) {
@@ -201,6 +205,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: 12,
   runSpeed: 24,
@@ -256,6 +269,15 @@ var Platformer3DBehaviorSystem = 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_BEHAVIOR_KEY);
     if (!links) return;
@@ -283,6 +305,8 @@ var Platformer3DBehaviorSystem = 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.platformerState, snapshot);
     }
   }
   ensureWasmAttached(handle, options, gameEntity) {
@@ -311,6 +335,7 @@ var Platformer3DBehaviorSystem = class {
 };
 var Platformer3DBehavior = defineBehavior({
   name: "platformer-3d",
+  metadata: BUILTIN_BEHAVIORS["platformer-3d"],
   defaultOptions,
   systemFactory: (ctx) => new Platformer3DBehaviorSystem(
     ctx.wasmStage ?? null,

package/dist/chunk-Y5CCNMJI.js

@@ -0,0 +1,58 @@
+// src/lib/behaviors/adventure-tools/types.ts
+var ADVENTURE_ABILITIES = [
+  "combat-lock-on",
+  "hookshot-pull",
+  "grapple-swing",
+  "morph-ball-transition",
+  "magnetic-track-adhesion",
+  "scanning-and-discovery",
+  "fused-carryable-bomb",
+  "returning-boomerang",
+  "keyed-interaction-gate",
+  "carry-aim-and-throw"
+];
+var ADVENTURE_BUTTONS = [
+  "lock",
+  "cycle",
+  "hook",
+  "grapple",
+  "morph",
+  "magnet",
+  "scan",
+  "armBomb",
+  "boomerang",
+  "interact",
+  "carry",
+  "throw",
+  "release"
+];
+var ADVENTURE_FLAGS = {
+  target: 1,
+  hookAnchor: 2,
+  pullable: 4,
+  grappleAnchor: 8,
+  scannable: 16,
+  carryable: 32,
+  bomb: 64,
+  gate: 128,
+  magneticTrack: 256,
+  hittable: 512
+};
+var ADVENTURE_EVENT_KINDS = [
+  "unknown",
+  "lockChanged",
+  "discovered",
+  "detonated",
+  "toolHit",
+  "unlocked",
+  "pickedUp",
+  "released",
+  "formChanged"
+];
+
+export {
+  ADVENTURE_ABILITIES,
+  ADVENTURE_BUTTONS,
+  ADVENTURE_FLAGS,
+  ADVENTURE_EVENT_KINDS
+};