@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-4C7I3ELN.js

@@ -0,0 +1,388 @@
+'use strict';
+
+var chunkATCURNUV_js = require('./chunk-ATCURNUV.js');
+var chunkA2MAX6S4_js = require('./chunk-A2MAX6S4.js');
+var chunk5325XSCH_js = require('./chunk-5325XSCH.js');
+var chunkKPA6K5IB_js = require('./chunk-KPA6K5IB.js');
+var chunkWHYKAT7G_js = require('./chunk-WHYKAT7G.js');
+var chunkH5DFSCJ6_js = require('./chunk-H5DFSCJ6.js');
+var chunkY4K22JL6_js = require('./chunk-Y4K22JL6.js');
+var chunkYXGZQPUD_js = require('./chunk-YXGZQPUD.js');
+var chunkJGBCIKJV_js = require('./chunk-JGBCIKJV.js');
+
+// src/game/kit/feel/camera-rig.ts
+var AXES = 3, DEFAULT_SMOOTH_SECONDS = 0.22, DEFAULT_FOV = 60, SMOOTH_A = 0.48, SMOOTH_B = 0.235, DEGREES_TO_RADIANS = Math.PI / 180, MIN_SMOOTH = 1e-4, S_DT = 0, S_DISTANCE = 1, S_OFFSET_SCALE = 2, S_COUNT = 3, CameraRig = class {
+  constructor(options = {}) {
+    this.position = new Float64Array((3));
+    this.offset = new Float64Array((3));
+    this.deadZone = new Float64Array((3));
+    this.min = new Float64Array((3)).fill(-1 / 0);
+    this.max = new Float64Array((3)).fill(1 / 0);
+    this.focus = new Float64Array((3));
+    this.velocity = new Float64Array((3));
+    this.goal = new Float64Array((3));
+    this.input = new Float64Array((3));
+    this.state = new Float64Array((3));
+    this.initialised = false;
+    this.smoothSeconds = Math.max((1e-4), options.smoothSeconds ?? (0.22)), this.lookAheadSeconds = options.lookAheadSeconds ?? 0, this.padding = options.padding ?? 0;
+    let halfVertical = (options.fovDegrees ?? (60)) * DEGREES_TO_RADIANS / 2, halfHorizontal = Math.atan(Math.tan(halfVertical) * (options.aspect ?? 1));
+    this.halfFov = halfVertical < halfHorizontal ? halfVertical : halfHorizontal;
+    for (let i = 0; i < (3); i++)
+      this.offset[i] = options.offset?.[i] ?? 0, this.deadZone[i] = options.deadZone?.[i] ?? 0, options.min && (this.min[i] = options.min[i]), options.max && (this.max[i] = options.max[i]);
+  }
+  follow(target, offset) {
+    for (let axis = 0; axis < (3); axis++) this.input[axis] = target[offset + axis];
+    this.track();
+  }
+  followMoving(target, offset, velocity, velocityOffset) {
+    let ahead = this.lookAheadSeconds;
+    for (let axis = 0; axis < (3); axis++) this.input[axis] = target[offset + axis] + velocity[velocityOffset + axis] * ahead;
+    this.track();
+  }
+  frame(points, count) {
+    if (count <= 0) return;
+    let f = this.focus;
+    for (let axis = 0; axis < (3); axis++) {
+      let lo = points[axis], hi = lo;
+      for (let i = 1; i < count; i++) {
+        let v = points[i * (3) + axis];
+        v < lo && (lo = v), v > hi && (hi = v);
+      }
+      f[axis] = (lo + hi) / 2;
+    }
+    let radiusSquared = 0;
+    for (let i = 0; i < count; i++) {
+      let dx = points[i * (3)] - f[0], dy = points[i * (3) + 1] - f[1], dz = points[i * (3) + 2] - f[2], d = dx * dx + dy * dy + dz * dz;
+      d > radiusSquared && (radiusSquared = d);
+    }
+    let o = this.offset, length = Math.sqrt(o[0] * o[0] + o[1] * o[1] + o[2] * o[2]), distance = (Math.sqrt(radiusSquared) + this.padding) / Math.sin(this.halfFov);
+    this.state[(1)] = distance, this.state[(2)] = length > 0 ? distance / length : 0, this.settleGoal();
+  }
+  get framedDistance() {
+    return this.state[(1)];
+  }
+  update(time) {
+    this.state[(0)] = time.values[chunkYXGZQPUD_js.FRAME_SECONDS_SLOT], this.run();
+  }
+  advance(seconds) {
+    this.state[(0)] = seconds, this.run();
+  }
+  snap() {
+    for (let i = 0; i < (3); i++)
+      this.position[i] = this.goal[i], this.velocity[i] = 0;
+  }
+  apply(transforms, camera, shake) {
+    let row = transforms.row(camera) * (3), out = transforms.store.fields.position, p = this.position;
+    if (shake === null) {
+      out[row] = p[0], out[row + 1] = p[1], out[row + 2] = p[2];
+      return;
+    }
+    let s = shake.offset;
+    out[row] = p[0] + s[chunk5325XSCH_js.SHAKE_X], out[row + 1] = p[1] + s[chunk5325XSCH_js.SHAKE_Y], out[row + 2] = p[2] + s[chunk5325XSCH_js.SHAKE_Z];
+  }
+  track() {
+    let f = this.focus, input = this.input;
+    for (let axis = 0; axis < (3); axis++) {
+      let value = input[axis];
+      if (!this.initialised) {
+        f[axis] = value;
+        continue;
+      }
+      let zone = this.deadZone[axis], delta = value - f[axis];
+      delta > zone ? f[axis] = value - zone : delta < -zone && (f[axis] = value + zone);
+    }
+    this.state[(2)] = 1, this.settleGoal();
+  }
+  settleGoal() {
+    let scale = this.state[(2)];
+    for (let i = 0; i < (3); i++) this.goal[i] = this.focus[i] + this.offset[i] * scale;
+    this.initialised || (this.initialised = true, this.snap());
+  }
+  run() {
+    let seconds = this.state[(0)], omega = 2 / this.smoothSeconds, x = omega * seconds, decay = 1 / (1 + x + (0.48) * x * x + (0.235) * x * x * x);
+    for (let i = 0; i < (3); i++) {
+      let change = this.position[i] - this.goal[i], temp = (this.velocity[i] + omega * change) * seconds;
+      this.velocity[i] = (this.velocity[i] - omega * temp) * decay;
+      let next = this.goal[i] + (change + temp) * decay;
+      next < this.min[i] ? next = this.min[i] : next > this.max[i] && (next = this.max[i]), this.position[i] = next;
+    }
+  }
+};
+
+// src/game/kit/blocks/lane-runner.ts
+var RUN_X = 0, RUN_Y = 1, RUN_Z = 2, RUN_VY = 3, RUN_SPEED = 4, RUN_DISTANCE = 5, RUN_BEST = 6, SLOTS = 7, LaneRunner = class {
+  constructor(tuning, laneX) {
+    this.tuning = tuning;
+    this.laneX = laneX;
+    this.state = new Float64Array((7));
+    this.state[(4)] = tuning.startSpeed;
+  }
+  get grounded() {
+    return this.state[(1)] === 0 && this.state[(3)] === 0;
+  }
+  reset(lane) {
+    let s = this.state;
+    s[(0)] = this.laneX[lane], s[(1)] = 0, s[(3)] = 0, s[(4)] = this.tuning.startSpeed, s[(5)] = 0;
+  }
+  jump() {
+    return this.grounded ? (this.state[(3)] = this.tuning.jumpVelocity, true) : false;
+  }
+  lift(height, velocity) {
+    this.state[(1)] = height, this.state[(3)] = velocity;
+  }
+  step(lane, time) {
+    let dt = time.values[chunkYXGZQPUD_js.FRAME_STEP_SECONDS_SLOT], s = this.state, t = this.tuning, speed = Math.min(t.maxSpeed, s[(4)] + t.acceleration * dt);
+    s[(4)] = speed, s[(2)] -= speed * dt, s[(5)] += speed * dt;
+    let target = this.laneX[lane], x = s[(0)], reach = t.laneSpeed * dt;
+    return s[(0)] = Math.abs(target - x) <= reach ? target : x + Math.sign(target - x) * reach, s[(1)] <= 0 && s[(3)] <= 0 || (s[(3)] += t.gravity * dt, s[(1)] += s[(3)] * dt, s[(1)] > 0) ? false : (s[(1)] = 0, s[(3)] = 0, true);
+  }
+  recordBest() {
+    let s = this.state;
+    s[(5)] > s[(6)] && (s[(6)] = s[(5)]);
+  }
+};
+
+// src/game/kit/templates/runner.ts
+var runner_exports = {};
+chunkJGBCIKJV_js.__export(runner_exports, {
+  EndlessRunner: () => EndlessRunner,
+  Obstacle: () => Obstacle,
+  RUNNER: () => RUNNER,
+  RUNNER_COLORS: () => RUNNER_COLORS,
+  coins: () => coins,
+  endlessRunnerTemplate: () => endlessRunnerTemplate,
+  runCoins: () => runCoins,
+  runnerEconomy: () => runnerEconomy
+});
+var RUNNER = {
+  lanes: 3,
+  laneWidth: 2,
+  laneSpeed: 12,
+  startSpeed: 9,
+  maxSpeed: 22,
+  acceleration: 0.18,
+  jumpVelocity: 7.5,
+  gravity: -24,
+  hurdleHeight: 0.6,
+  hitDepth: 0.6,
+  spawnAhead: 60,
+  despawnBehind: 8,
+  minGap: 10,
+  maxGap: 16,
+  restartSeconds: 1.2,
+  coinValue: 1,
+  obstacles: 32,
+  coins: 64
+}, Obstacle = { Hurdle: 0, Wall: 1 }, RUNNER_COLORS = { player: 1096065, hurdle: 16096779, wall: 15680580, coin: 16436245, ground: 2042167, laneLine: 3621201 }, coins = chunkA2MAX6S4_js.softCurrency("coins", "Coins"), runCoins = chunkA2MAX6S4_js.faucet("run-coins", coins, 1e3), runnerEconomy = { currencies: [coins], items: [], faucets: [runCoins] }, LEFT_KEYS = ["ArrowLeft", "KeyA"], RIGHT_KEYS = ["ArrowRight", "KeyD"], JUMP_KEYS = ["Space", "ArrowUp", "KeyW"], CAMERA_OFFSET = [0, 4.2, 7.5], CAMERA_FOV = 60, CAMERA_PITCH = -0.35, WALL_HEIGHT = 2, COIN_SIZE = 0.4, COIN_HEIGHT = 0.6, COIN_DEPTH = 0.1, COIN_POP_SCALE = 0.05, COINS_PER_ROW = 4, COIN_SPACING = 1.6, PERCENT = 99, SECOND_OBSTACLE_PERCENT = 35, COIN_ROW_PERCENT = 60, WALL_PERCENT = 50, GAP_STEP = 0.5, GAP_STEPS = (RUNNER.maxGap - RUNNER.minGap) / (0.5), GROUND_SEGMENTS = 12, GROUND_SEGMENT_LENGTH = 10, LANE_INDEX_SUM = RUNNER.lanes * (RUNNER.lanes - 1) / 2, SQUASH_PUNCH = 2, COIN_PUNCH = 6, PLAYER_HALF_HEIGHT = 0.5, CRASH_TRAUMA = 0.8, CRASH_STOP_SECONDS = 0.12, BATCH_CAPACITY = 128, NONE = -1, OBSTACLE_KINDS = 2, OBSTACLE_HEIGHTS = obstacleHeights(), T_STATE_SECONDS = 0, T_NEXT_ROW_Z = 1, TIMER_SLOTS = 2;
+function obstacleHeights() {
+  let heights = new Float64Array((2));
+  return heights[Obstacle.Hurdle] = RUNNER.hurdleHeight, heights[Obstacle.Wall] = (2), heights;
+}
+var LANE_X = laneCentres();
+function laneCentres() {
+  let centres = new Float64Array(RUNNER.lanes);
+  for (let lane = 0; lane < RUNNER.lanes; lane++) centres[lane] = (lane - (RUNNER.lanes - 1) / 2) * RUNNER.laneWidth;
+  return centres;
+}
+var EndlessRunner = class {
+  constructor(results = null, options = {}) {
+    this.name = "endless-runner";
+    this.state = "running";
+    this.lane = 1;
+    this.coinsThisRun = 0;
+    this.runs = 0;
+    this.obstacleZ = new Float64Array(RUNNER.obstacles);
+    this.obstacleLane = new Int8Array(RUNNER.obstacles);
+    this.obstacleKind = new Uint8Array(RUNNER.obstacles);
+    this.obstacleActive = new Uint8Array(RUNNER.obstacles);
+    this.coinZ = new Float64Array(RUNNER.coins);
+    this.coinLane = new Int8Array(RUNNER.coins);
+    this.coinActive = new Uint8Array(RUNNER.coins);
+    this.shake = new chunk5325XSCH_js.ScreenShake();
+    this.hitStop = new chunk5325XSCH_js.HitStop();
+    this.rig = new CameraRig({ offset: CAMERA_OFFSET, smoothSeconds: 0.12, deadZone: [0.4, 0.6, 0] });
+    this.springs = new chunkKPA6K5IB_js.Springs(2);
+    this.squash = 0;
+    this.coinPop = 0;
+    this.scale = new Float32Array(3);
+    this.pose = new Float64Array(3);
+    this.timers = new Float64Array((2));
+    this.player = 0;
+    this.camera = 0;
+    this.left = null;
+    this.right = null;
+    this.jump = null;
+    this.distanceSlot = null;
+    this.coinSlot = null;
+    this.bestSlot = null;
+    this.boxes = null;
+    this.results = results, this.body = new LaneRunner({ ...RUNNER, ...options.tuning }, LANE_X), this.colors = { ...RUNNER_COLORS, ...options.colors };
+  }
+  enter(game) {
+    let gfx = game.graphics;
+    this.player = game.world.spawn(), game.transforms.add(this.player, 0, 0.5, 0), gfx.mesh(this.player, gfx.createGeometry(chunkY4K22JL6_js.boxGeometry(0.8, 1, 0.8)), gfx.createMaterial({ kind: "standard", color: this.colors.player })), this.camera = chunkWHYKAT7G_js.addSceneCamera(game, CAMERA_OFFSET[0], CAMERA_OFFSET[1], CAMERA_OFFSET[2], (60), (-0.35)), this.boxes = new chunkWHYKAT7G_js.BoxBatch(game, (128)), this.squash = this.springs.create(0), this.coinPop = this.springs.create(0), this.left = game.input.defineButton("left", [{ device: "key", code: LEFT_KEYS[0] }, { device: "key", code: LEFT_KEYS[1] }, { device: "virtual", control: "left" }]), this.right = game.input.defineButton("right", [{ device: "key", code: RIGHT_KEYS[0] }, { device: "key", code: RIGHT_KEYS[1] }, { device: "virtual", control: "right" }]), this.jump = game.input.defineButton("jump", [{ device: "key", code: JUMP_KEYS[0] }, { device: "key", code: JUMP_KEYS[1] }, { device: "key", code: JUMP_KEYS[2] }, { device: "virtual", control: "jump" }]), this.distanceSlot = game.ui.hudNumber("distance"), this.coinSlot = game.ui.hudNumber("coins"), this.bestSlot = game.ui.hudNumber("best"), this.restart(game);
+  }
+  fixedUpdate(game) {
+    let dt = game.loop.time.values[chunkYXGZQPUD_js.FRAME_STEP_SECONDS_SLOT];
+    if (this.timers[(0)] += dt, !this.hitStop.freezeStep(game.time)) {
+      if (this.state === "crashed") {
+        this.timers[(0)] >= RUNNER.restartSeconds && this.restart(game);
+        return;
+      }
+      this.steer(game), this.body.step(this.lane, game.time) && this.springs.punch(this.squash, -(2)), this.spawnAhead(game), this.collide(game), this.distanceSlot !== null && game.ui.setNumber(this.distanceSlot, Math.floor(this.body.state[(5)]));
+    }
+  }
+  update(game) {
+    let time = game.time, pose = this.pose;
+    this.springs.update(time), this.shake.update(time), this.springs.squash(this.squash, this.scale, 0);
+    let body = this.body.state;
+    pose[0] = body[(0)], pose[1] = body[(1)], pose[2] = body[(2)], this.rig.follow(pose, 0), this.rig.update(time), this.rig.apply(game.transforms, this.camera, this.shake), pose[1] = body[(1)] + (0.5) * this.scale[1], chunkATCURNUV_js.writePosition(game.transforms, this.player, pose, 0), chunkATCURNUV_js.writeScale(game.transforms, this.player, this.scale, 0), this.draw();
+  }
+  nearestAhead(lane) {
+    let best = (-1), bestGap = 0;
+    for (let i = 0; i < RUNNER.obstacles; i++) {
+      if (this.obstacleActive[i] === 0 || this.obstacleLane[i] !== lane) continue;
+      let gap = this.body.state[(2)] - this.obstacleZ[i];
+      gap > -RUNNER.hitDepth && (best === (-1) || gap < bestGap) && (bestGap = gap, best = i);
+    }
+    return best;
+  }
+  steer(game) {
+    let input = game.input, swipe = input.swipe, dir = 0, jump = this.jump !== null && input.justPressed(this.jump);
+    if (this.left !== null && input.justPressed(this.left) && (dir = -1), this.right !== null && input.justPressed(this.right) && (dir = 1), swipe.ready && (Math.abs(swipe.deltaX) > Math.abs(swipe.deltaY) ? dir = swipe.deltaX < 0 ? -1 : 1 : swipe.deltaY < 0 && (jump = true)), dir !== 0) {
+      let next = this.lane + dir;
+      next >= 0 && next < RUNNER.lanes && (this.lane = next);
+    }
+    jump && this.body.jump() && this.springs.punch(this.squash, (2));
+  }
+  spawnAhead(game) {
+    let random = game.random, z = this.body.state[(2)], timers = this.timers;
+    for (; timers[(1)] > z - RUNNER.spawnAhead; ) {
+      let lane = random.int(0, RUNNER.lanes - 1);
+      this.place(lane, random.int(0, (99)) < (50) ? Obstacle.Wall : Obstacle.Hurdle);
+      let free = (lane + 1 + random.int(0, RUNNER.lanes - 2)) % RUNNER.lanes;
+      if (random.int(0, (99)) < (35) && (this.place(free, Obstacle.Hurdle), free = LANE_INDEX_SUM - lane - free), random.int(0, (99)) < (60))
+        for (let c = 0; c < (4); c++) this.placeCoin(free, c);
+      timers[(1)] -= RUNNER.minGap + random.int(0, GAP_STEPS) * (0.5);
+    }
+    for (let i = 0; i < RUNNER.obstacles; i++)
+      this.obstacleActive[i] === 1 && this.obstacleZ[i] > z + RUNNER.despawnBehind && (this.obstacleActive[i] = 0);
+    for (let i = 0; i < RUNNER.coins; i++)
+      this.coinActive[i] === 1 && this.coinZ[i] > z + RUNNER.despawnBehind && (this.coinActive[i] = 0);
+  }
+  place(lane, kind) {
+    for (let i = 0; i < RUNNER.obstacles; i++)
+      if (this.obstacleActive[i] !== 1) {
+        this.obstacleActive[i] = 1, this.obstacleLane[i] = lane, this.obstacleZ[i] = this.timers[(1)], this.obstacleKind[i] = kind;
+        return;
+      }
+  }
+  placeCoin(lane, index) {
+    for (let i = 0; i < RUNNER.coins; i++)
+      if (this.coinActive[i] !== 1) {
+        this.coinActive[i] = 1, this.coinLane[i] = lane, this.coinZ[i] = this.timers[(1)] + RUNNER.minGap / 2 - index * (1.6);
+        return;
+      }
+  }
+  collide(game) {
+    let half = RUNNER.laneWidth * 0.3, body = this.body.state, x = body[(0)], y = body[(1)], z = body[(2)];
+    for (let i = 0; i < RUNNER.obstacles; i++)
+      if (this.obstacleActive[i] !== 0 && !(Math.abs(this.obstacleZ[i] - z) > RUNNER.hitDepth) && !(Math.abs(LANE_X[this.obstacleLane[i]] - x) > half) && !(this.obstacleKind[i] === Obstacle.Hurdle && y > RUNNER.hurdleHeight)) {
+        this.crash(game);
+        return;
+      }
+    for (let i = 0; i < RUNNER.coins; i++)
+      this.coinActive[i] !== 0 && (Math.abs(this.coinZ[i] - z) > RUNNER.hitDepth || Math.abs(LANE_X[this.coinLane[i]] - x) > half || (this.coinActive[i] = 0, this.coinsThisRun += RUNNER.coinValue, this.springs.punch(this.coinPop, (6)), this.coinSlot !== null && game.ui.setNumber(this.coinSlot, this.coinsThisRun)));
+  }
+  crash(game) {
+    this.state = "crashed", this.timers[(0)] = 0, this.runs++, this.body.recordBest(), this.bestSlot !== null && game.ui.setNumber(this.bestSlot, Math.floor(this.body.state[(6)])), this.shake.add((0.8)), this.hitStop.trigger((0.12)), game.ui.haptic("heavy"), this.results?.runEnded(this.body.state[(5)], this.coinsThisRun);
+  }
+  restart(game) {
+    this.state = "running", this.timers[(0)] = 0, this.lane = 1, this.body.reset(this.lane), this.coinsThisRun = 0, this.obstacleActive.fill(0), this.coinActive.fill(0), this.timers[(1)] = this.body.state[(2)] - RUNNER.spawnAhead / 2, this.coinSlot !== null && game.ui.setNumber(this.coinSlot, 0);
+  }
+  draw() {
+    let boxes = this.boxes;
+    if (boxes === null) return;
+    boxes.begin();
+    let b = boxes.box, base = Math.floor(this.body.state[(2)] / (10)) * (10);
+    b[chunkWHYKAT7G_js.BOX_X] = 0, b[chunkWHYKAT7G_js.BOX_Y] = -0.05, b[chunkWHYKAT7G_js.BOX_SX] = RUNNER.lanes * RUNNER.laneWidth, b[chunkWHYKAT7G_js.BOX_SY] = 0.1, b[chunkWHYKAT7G_js.BOX_SZ] = (10) * 0.98;
+    for (let s = 0; s < (12); s++)
+      b[chunkWHYKAT7G_js.BOX_Z] = base - (s - 2) * (10), boxes.add(s % 2 === 0 ? this.colors.ground : this.colors.laneLine);
+    b[chunkWHYKAT7G_js.BOX_SX] = RUNNER.laneWidth * 0.8, b[chunkWHYKAT7G_js.BOX_SZ] = 0.4;
+    for (let i = 0; i < RUNNER.obstacles; i++) {
+      if (this.obstacleActive[i] === 0) continue;
+      let kind = this.obstacleKind[i], h = OBSTACLE_HEIGHTS[kind];
+      b[chunkWHYKAT7G_js.BOX_X] = LANE_X[this.obstacleLane[i]], b[chunkWHYKAT7G_js.BOX_Y] = h / 2, b[chunkWHYKAT7G_js.BOX_Z] = this.obstacleZ[i], b[chunkWHYKAT7G_js.BOX_SY] = h, boxes.add(kind === Obstacle.Wall ? this.colors.wall : this.colors.hurdle);
+    }
+    let size = (0.4) * (1 + this.springs.values[this.coinPop] * (0.05));
+    b[chunkWHYKAT7G_js.BOX_Y] = (0.6), b[chunkWHYKAT7G_js.BOX_SX] = size, b[chunkWHYKAT7G_js.BOX_SY] = size, b[chunkWHYKAT7G_js.BOX_SZ] = (0.1);
+    for (let i = 0; i < RUNNER.coins; i++)
+      this.coinActive[i] !== 0 && (b[chunkWHYKAT7G_js.BOX_X] = LANE_X[this.coinLane[i]], b[chunkWHYKAT7G_js.BOX_Z] = this.coinZ[i], boxes.add(this.colors.coin));
+    boxes.end();
+  }
+}, BOT_HOLD_FRAMES = 2, BOT_JUMP_LEAD_SECONDS = 0.16, BOT_DODGE_DISTANCE = 7, RunnerBot = class {
+  constructor() {
+    this.held = null;
+    this.holdFrames = 0;
+  }
+  drive(scene, game, frame) {
+    if (this.held !== null) {
+      if (--this.holdFrames > 0) return;
+      game.input.keyEvent(this.held, false, chunkH5DFSCJ6_js.templateFrameStamp(frame)), this.held = null;
+      return;
+    }
+    let body = scene.body.state;
+    if (scene.state !== "running" || body[(0)] !== LANE_X[scene.lane]) return;
+    let ahead = scene.nearestAhead(scene.lane);
+    if (ahead === (-1)) return;
+    let gap = body[(2)] - scene.obstacleZ[ahead];
+    if (scene.obstacleKind[ahead] === Obstacle.Hurdle) {
+      gap < body[(4)] * (0.16) + RUNNER.hitDepth && body[(1)] === 0 && this.press(game, JUMP_KEYS[0], frame);
+      return;
+    }
+    if (!(gap > (7)))
+      for (let d = -1; d <= 1; d += 2) {
+        let lane = scene.lane + d;
+        if (lane < 0 || lane >= RUNNER.lanes) continue;
+        let block = scene.nearestAhead(lane);
+        if (!(block !== (-1) && scene.obstacleKind[block] === Obstacle.Wall && body[(2)] - scene.obstacleZ[block] < (7))) {
+          this.press(game, d < 0 ? LEFT_KEYS[0] : RIGHT_KEYS[0], frame);
+          return;
+        }
+      }
+  }
+  press(game, key, frame) {
+    game.input.keyEvent(key, true, chunkH5DFSCJ6_js.templateFrameStamp(frame)), this.held = key, this.holdFrames = (2);
+  }
+}, DIGEST_FIELDS = 6, digestScratch = new Float64Array((6)), endlessRunnerTemplate = {
+  id: "endless-runner",
+  title: "Endless runner",
+  sources: ["src/game/kit/templates/runner.ts"],
+  economy: runnerEconomy,
+  scene: () => new EndlessRunner(),
+  bot: () => new RunnerBot(),
+  progress: (scene) => Math.max(scene.body.state[(6)], scene.body.state[(5)]),
+  digest(scene) {
+    let d = digestScratch, body = scene.body.state;
+    return d[0] = body[(5)], d[1] = body[(6)], d[2] = body[(0)], d[3] = body[(2)], d[4] = scene.coinsThisRun, d[5] = scene.runs, chunkH5DFSCJ6_js.digestFloats(d, (6));
+  }
+};
+
+exports.CameraRig = CameraRig;
+exports.EndlessRunner = EndlessRunner;
+exports.LaneRunner = LaneRunner;
+exports.Obstacle = Obstacle;
+exports.RUNNER = RUNNER;
+exports.RUNNER_COLORS = RUNNER_COLORS;
+exports.RUN_BEST = (6);
+exports.RUN_DISTANCE = (5);
+exports.RUN_SPEED = (4);
+exports.RUN_VY = (3);
+exports.RUN_X = (0);
+exports.RUN_Y = (1);
+exports.RUN_Z = (2);
+exports.coins = coins;
+exports.endlessRunnerTemplate = endlessRunnerTemplate;
+exports.runCoins = runCoins;
+exports.runnerEconomy = runnerEconomy;
+exports.runner_exports = runner_exports;

package/dist/chunk-4DYKAYFO.mjs

@@ -0,0 +1,8 @@
+// src/game/kit/errors.ts
+var KitError = class extends Error {
+  constructor(code, message) {
+    super(message), this.name = "KitError", this.code = code;
+  }
+};
+
+export { KitError };