@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-J2KZXIU3.js

@@ -0,0 +1,51 @@
+'use strict';
+
+// src/internal/base64.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var WHITESPACE = [9, 10, 12, 13, 32], DECODE = buildDecodeTable();
+function buildDecodeTable() {
+  let table = new Uint8Array(128).fill(255);
+  for (let i = 0; i < ALPHABET.length; i++) table[ALPHABET.charCodeAt(i)] = i;
+  table[45] = table[43], table[95] = table[47];
+  for (let code of WHITESPACE) table[code] = 254;
+  return table;
+}
+function sixtet(code) {
+  return code < 128 ? DECODE[code] : 255;
+}
+function decodeBase64(text) {
+  let end = text.length;
+  for (; end > 0 && (text.charCodeAt(end - 1) === 61 || sixtet(text.charCodeAt(end - 1)) === 254); ) end--;
+  let chars = 0;
+  for (let i = 0; i < end; i++) {
+    let value = sixtet(text.charCodeAt(i));
+    if (value === 255) throw new Error("the text is not valid base64");
+    value !== 254 && chars++;
+  }
+  if (chars % 4 === 1) throw new Error("the text is not valid base64");
+  let out = new Uint8Array(Math.floor(chars * 6 / 8)), bits = 0, pending = 0, at = 0;
+  for (let i = 0; i < end; i++) {
+    let value = sixtet(text.charCodeAt(i));
+    value !== 254 && (bits = (bits << 6 | value) & 16777215, pending += 6, pending >= 8 && (pending -= 8, out[at++] = bits >> pending & 255));
+  }
+  return out;
+}
+function encodeBase64(bytes) {
+  let out = "", i = 0;
+  for (; i + 3 <= bytes.length; i += 3) {
+    let group = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    out += ALPHABET[group >> 18 & 63] + ALPHABET[group >> 12 & 63] + ALPHABET[group >> 6 & 63] + ALPHABET[group & 63];
+  }
+  let rest = bytes.length - i;
+  if (rest === 1) {
+    let group = bytes[i] << 16;
+    out += `${ALPHABET[group >> 18 & 63]}${ALPHABET[group >> 12 & 63]}==`;
+  } else if (rest === 2) {
+    let group = bytes[i] << 16 | bytes[i + 1] << 8;
+    out += `${ALPHABET[group >> 18 & 63]}${ALPHABET[group >> 12 & 63]}${ALPHABET[group >> 6 & 63]}=`;
+  }
+  return out;
+}
+
+exports.decodeBase64 = decodeBase64;
+exports.encodeBase64 = encodeBase64;

package/dist/chunk-J2U6PJSO.js

@@ -0,0 +1,91 @@
+'use strict';
+
+// src/game/backends/engine/threads.ts
+var STACK_POINTER_EXPORT = "__stack_pointer", INIT_TLS_EXPORT = "__wasm_init_tls", TLS_SIZE_EXPORT = "__tls_size", TLS_ALIGN_EXPORT = "__tls_align";
+var WORKER_STACK_BYTES = 1 << 20, STACK_ALIGN = 16, MIN_LANES = 2, MAX_ENGINE_WORKERS = 15, RESERVED_CORES = 1, WORKER_START_TIMEOUT_MS = 5e3, POLL_MS = 1, MEMORY_MODULE = "env", MEMORY_FIELD = "memory", FUNCTION_KIND = "function", SHARED_MEMORY_PROBE = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 2, 9, 1, 1, 101, 1, 109, 2, 3, 1, 1]);
+function wasmThreadsSupported() {
+  if (typeof WebAssembly != "object" || typeof WebAssembly.validate != "function") return false;
+  try {
+    return WebAssembly.validate(SHARED_MEMORY_PROBE);
+  } catch {
+    return false;
+  }
+}
+function threadsAvailable(scope = globalThis) {
+  return scope.crossOriginIsolated === true && typeof SharedArrayBuffer == "function" && typeof Worker == "function" && typeof Atomics == "object" && typeof URL.createObjectURL == "function" && wasmThreadsSupported();
+}
+function workerCount(scope = globalThis) {
+  let cores = scope.navigator?.hardwareConcurrency ?? 0, workers = Math.min((15), cores - (1));
+  return workers + 1 >= (2) ? workers : 0;
+}
+var WORKER_SOURCE = `"use strict";
+self.onmessage = (event) => {
+  const boot = event.data;
+  const imports = { ${JSON.stringify(MEMORY_MODULE)}: { ${JSON.stringify(MEMORY_FIELD)}: boot.memory } };
+  for (const [module, name] of boot.stubs) {
+    imports[module] = imports[module] || {};
+    imports[module][name] = () => { throw new Error("engine lane " + boot.index + " called the host import " + module + "." + name); };
+  }
+  WebAssembly.instantiate(boot.module, imports).then((instance) => {
+    const exports = instance.exports;
+    exports[${JSON.stringify(STACK_POINTER_EXPORT)}].value = boot.stack;
+    exports[${JSON.stringify(INIT_TLS_EXPORT)}](boot.tls);
+    self.postMessage(boot.index);
+    exports.engine_jobs_worker(boot.index);
+  }, (error) => self.postMessage(String(error)));
+};
+`;
+function hostImportStubs(module) {
+  let stubs = [];
+  for (let entry of WebAssembly.Module.imports(module))
+    entry.kind === FUNCTION_KIND && !(entry.module === MEMORY_MODULE && entry.name === MEMORY_FIELD) && stubs.push([entry.module, entry.name]);
+  return stubs;
+}
+function aligned(bytes, align) {
+  return Math.ceil(bytes / align) * align;
+}
+function globalValue(value) {
+  return Number(value.value);
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var BROWSER_WORKERS = { create: (url) => new Worker(url) };
+async function startEngineThreads(module, memory, exports, workers, factory = BROWSER_WORKERS) {
+  if (workers <= 0 || exports.engine_jobs_init(workers) < 0) return null;
+  let tlsAlign = Math.max((16), globalValue(exports[TLS_ALIGN_EXPORT])), tlsBytes = aligned(Math.max(globalValue(exports[TLS_SIZE_EXPORT]), 1), tlsAlign), stubs = hostImportStubs(module), url = URL.createObjectURL(new Blob([WORKER_SOURCE], { type: "text/javascript" })), spawned = [], started = [];
+  try {
+    for (let index = 0; index < workers; index++) {
+      let stack = exports.engine_alloc(WORKER_STACK_BYTES, (16)), tls = exports.engine_alloc(tlsBytes, tlsAlign);
+      if (stack === 0 || tls === 0) break;
+      let worker = factory.create(url);
+      spawned.push(worker), started.push(
+        new Promise((resolve) => {
+          worker.onmessage = (event) => resolve(event.data === index), worker.onerror = () => resolve(!1);
+        })
+      );
+      let boot = { module, memory, index, stack: stack + WORKER_STACK_BYTES, tls, stubs };
+      worker.postMessage(boot);
+    }
+    let ok = (await Promise.all(started)).every(Boolean), wanted = spawned.length + 1, deadline = Date.now() + (5e3);
+    for (; ok && exports.engine_jobs_lanes() < wanted && Date.now() < deadline; ) await delay((1));
+    if (!ok || exports.engine_jobs_lanes() < (2)) {
+      exports.engine_jobs_shutdown();
+      for (let worker of spawned) worker.terminate();
+      return null;
+    }
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+  return {
+    lanes: exports.engine_jobs_lanes(),
+    terminate() {
+      exports.engine_jobs_shutdown();
+      for (let worker of spawned) worker.terminate();
+    }
+  };
+}
+
+exports.startEngineThreads = startEngineThreads;
+exports.threadsAvailable = threadsAvailable;
+exports.workerCount = workerCount;

package/dist/chunk-J5AJNY2N.js

@@ -0,0 +1,283 @@
+'use strict';
+
+var chunk2AQ237Y4_js = require('./chunk-2AQ237Y4.js');
+var chunkNH654HAT_js = require('./chunk-NH654HAT.js');
+var chunkWHYKAT7G_js = require('./chunk-WHYKAT7G.js');
+var chunkH5DFSCJ6_js = require('./chunk-H5DFSCJ6.js');
+var chunk52YS45RR_js = require('./chunk-52YS45RR.js');
+var chunk5LH2QN3T_js = require('./chunk-5LH2QN3T.js');
+var chunkJGBCIKJV_js = require('./chunk-JGBCIKJV.js');
+
+// src/game/kit/blocks/pickups.ts
+var NO_PICKUP = -1, PICKUP_STRIDE = 3, KEEP_OUT_STRIDE = 3, MAX_SCATTER_TRIES = 64, FIXED_LIMIT = 1 << 23, SQUARE_SPLIT = 12, SQUARE_LOW = 4095, SQUARE_WORD = 24, SQUARE_WORD_MASK = 16777215, SQUARE_WORDS = 2, SCRATCH_WORDS = 4;
+function withinRadius(source, offset, cx, cz, radius) {
+  let dx = source[offset] - cx, dz = source[offset + 2] - cz;
+  return dx * dx + dz * dz < radius * radius;
+}
+var CIRCLE_X = 0, CIRCLE_Z = 1, CIRCLE_RADIUS = 2, CIRCLE_WORDS = 3;
+function withinCircle(source, offset, circle, at) {
+  let dx = source[offset] - circle[at + (0)], dz = source[offset + 2] - circle[at + (1)], radius = circle[at + (2)];
+  return dx * dx + dz * dz < radius * radius;
+}
+function requireCapacity(capacity, what) {
+  if (!Number.isInteger(capacity) || capacity <= 0) throw new chunkNH654HAT_js.KitError("invalid_declaration", `${what} need a positive whole capacity`);
+}
+function squareInto(out, at, a) {
+  let ah = a >>> (12), al = a & (4095), m = 2 * ah * al, low = al * al + ((m & (4095)) << (12));
+  out[at] = ah * ah + (m >>> (12)) + (low >>> (24)), low &= (16777215), out[at + 1] = low;
+}
+var KeepOut = class {
+  constructor(capacity) {
+    this.scratch = new Int32Array((4));
+    this.used = 0;
+    requireCapacity(capacity, "keep-out areas"), this.circles = new Float64Array(capacity * (3)), this.fixed = new Int32Array(capacity * (3)), this.squares = new Int32Array(capacity * (2));
+  }
+  get count() {
+    return this.used;
+  }
+  add(x, z, radius) {
+    if (this.used * (3) >= this.circles.length) throw new chunkNH654HAT_js.KitError("capacity_exceeded", "the keep-out areas are full");
+    let fx = Math.trunc(x * chunk5LH2QN3T_js.CENTERED_FIXED_UNITS), fz = Math.trunc(z * chunk5LH2QN3T_js.CENTERED_FIXED_UNITS), fr = Math.trunc(radius * chunk5LH2QN3T_js.CENTERED_FIXED_UNITS);
+    if (!(Math.abs(fx) < FIXED_LIMIT && Math.abs(fz) < FIXED_LIMIT && fr >= 0 && fr < FIXED_LIMIT))
+      throw new chunkNH654HAT_js.KitError("invalid_declaration", `keep-out areas must lie within ${FIXED_LIMIT / chunk5LH2QN3T_js.CENTERED_FIXED_UNITS} m of the origin`);
+    let o = this.used * (3);
+    return this.circles[o] = x, this.circles[o + 1] = z, this.circles[o + 2] = radius, this.fixed[o] = fx, this.fixed[o + 1] = fz, this.fixed[o + 2] = fr, squareInto(this.squares, this.used * (2), fr), this.used++;
+  }
+  clearFixed(candidate, at) {
+    let f = this.fixed, q = this.scratch, x = candidate[at], z = candidate[at + 1];
+    for (let i = 0; i < this.used; i++) {
+      let o = i * (3), r = f[o + 2], dx = Math.abs(x - f[o]), dz = Math.abs(z - f[o + 1]);
+      if (dx >= r || dz >= r) continue;
+      squareInto(q, 0, dx), squareInto(q, 2, dz);
+      let low = q[1] + q[3], high = q[0] + q[2] + (low >>> (24));
+      low &= (16777215);
+      let s = i * (2);
+      if (high < this.squares[s] || high === this.squares[s] && low < this.squares[s + 1]) return false;
+    }
+    return true;
+  }
+  clear(source, offset) {
+    let c = this.circles, x = source[offset], z = source[offset + 2];
+    for (let i = 0; i < this.used; i++) {
+      let o = i * (3), dx = x - c[o], dz = z - c[o + 1];
+      if (dx * dx + dz * dz < c[o + 2] * c[o + 2]) return false;
+    }
+    return true;
+  }
+}, Pickups = class {
+  constructor(capacity, radius) {
+    this.live = 0;
+    this.closest = new Float64Array(1);
+    this.candidate = new Int32Array(2);
+    if (requireCapacity(capacity, "pickups"), !(radius > 0)) throw new chunkNH654HAT_js.KitError("invalid_declaration", "pickups need a positive radius");
+    this.positions = new Float64Array(capacity * (3)), this.active = new Uint8Array(capacity), this.kinds = new Int32Array(capacity), this.radius = radius;
+  }
+  get capacity() {
+    return this.active.length;
+  }
+  get count() {
+    return this.live;
+  }
+  place(slot, x, y, z, kind = 0) {
+    let o = slot * (3);
+    this.positions[o] = x, this.positions[o + 1] = y, this.positions[o + 2] = z, this.activate(slot, kind);
+  }
+  scatter(slot, random, halfExtent, y, keepOut = null, kind = 0) {
+    let p = this.positions, o = slot * (3);
+    for (let tries = 0; tries < (64) && (random.rangeInto(p, o, -halfExtent, halfExtent), random.rangeInto(p, o + 2, -halfExtent, halfExtent), !(keepOut === null || keepOut.clear(p, o))); tries++)
+      ;
+    p[o + 1] = y, this.activate(slot, kind);
+  }
+  respawn(slot, random, halfExtent, keepOut = null) {
+    if ((halfExtent | 0) !== halfExtent || halfExtent < 1 || halfExtent >= chunk5LH2QN3T_js.CENTERED_MAX_EXTENT)
+      throw new chunkNH654HAT_js.KitError("invalid_declaration", `respawn needs a whole half extent from 1 to ${chunk5LH2QN3T_js.CENTERED_MAX_EXTENT - 1}`);
+    let p = this.positions, o = slot * (3), f = this.candidate;
+    for (let tries = 0; tries < (64) && (random.centeredInto(p, o, halfExtent, f, 0), random.centeredInto(p, o + 2, halfExtent, f, 1), !(keepOut === null || keepOut.clearFixed(f, 0))); tries++)
+      ;
+    this.activate(slot, this.kinds[slot]);
+  }
+  remove(slot) {
+    return this.active[slot] === 0 ? false : (this.active[slot] = 0, this.live--, true);
+  }
+  nearest(source, offset) {
+    let p = this.positions, x = source[offset], z = source[offset + 2], best = (-1), closest = this.closest;
+    closest[0] = 1 / 0;
+    for (let i = 0; i < this.active.length; i++) {
+      if (this.active[i] === 0) continue;
+      let dx = p[i * (3)] - x, dz = p[i * (3) + 2] - z, d = dx * dx + dz * dz;
+      d < closest[0] && (closest[0] = d, best = i);
+    }
+    return best;
+  }
+  collect(source, offset) {
+    let p = this.positions, x = source[offset], z = source[offset + 2], r2 = this.radius * this.radius;
+    for (let i = 0; i < this.active.length; i++) {
+      if (this.active[i] === 0) continue;
+      let dx = p[i * (3)] - x, dz = p[i * (3) + 2] - z;
+      if (!(dx * dx + dz * dz >= r2))
+        return this.remove(i), i;
+    }
+    return (-1);
+  }
+  activate(slot, kind) {
+    this.kinds[slot] = kind, this.active[slot] === 0 && this.live++, this.active[slot] = 1;
+  }
+};
+
+// src/game/kit/blocks/arena.ts
+function staticBox(game, x, y, z, hx, hy, hz) {
+  let entity = game.world.spawn();
+  return game.transforms.add(entity, x, y, z), game.physics.addCollider(entity, { shape: { kind: "cuboid", halfExtents: [hx, hy, hz] } }), entity;
+}
+function walledArena(game, options) {
+  let half = options.half, thickness = options.wallThickness ?? 0.4, depth = options.groundDepth ?? 0.5, rise = options.wallHeight * 0.5;
+  staticBox(game, 0, -depth, 0, half, depth, half);
+  for (let w = 0; w < 4; w++) {
+    let along = w < 2, sign = w % 2 === 0 ? 1 : -1;
+    along ? staticBox(game, 0, rise, sign * half, half, rise, thickness) : staticBox(game, sign * half, rise, 0, thickness, rise, half);
+  }
+}
+function daylight(game, options = {}) {
+  let sun = game.world.spawn();
+  game.transforms.add(sun, options.sunX ?? 3, options.sunY ?? 10, options.sunZ ?? 4), game.graphics.create(sun, { kind: "light", light: "directional", intensity: options.sun ?? 2 });
+  let sky = game.world.spawn();
+  game.transforms.add(sky), game.graphics.create(sky, { kind: "light", light: "hemisphere", intensity: options.sky ?? 0.7 });
+}
+
+// src/game/kit/blocks/seek-bot.ts
+var UNBOUND = -1, GOAL_X = 0, GOAL_Z = 1, DEFAULT_ARRIVE = 0.6, NEVER = 0, DEFAULT_JUMP_HOLD = 9, SeekBot = class {
+  constructor(options = {}) {
+    this.slotX = (-1);
+    this.slotY = (-1);
+    this.slotJump = (-1);
+    this.jumpHeld = 0;
+    this.arrive = options.arrive ?? (0.6), this.jumpEvery = options.jumpEvery ?? (0), this.jumpHold = options.jumpHold ?? (9);
+  }
+  drive(game, rig, goal, frame) {
+    let x = goal[(0)], z = goal[(1)], input = game.input;
+    this.slotX === (-1) && (this.slotX = input.virtualControl(chunk2AQ237Y4_js.TOUCH_CONTROLS.moveX), this.slotY = input.virtualControl(chunk2AQ237Y4_js.TOUCH_CONTROLS.moveY), this.slotJump = input.virtualControl(chunk2AQ237Y4_js.TOUCH_CONTROLS.jump));
+    let p = game.transforms.store.fields.position, o = game.transforms.row(rig.entity) * 3, wx = x - p[o], wz = z - p[o + 2], length = (wx * wx + wz * wz) ** 0.5;
+    length > this.arrive ? (wx /= length, wz /= length) : (wx = 0, wz = 0);
+    let yaw = rig.camera.state[chunk52YS45RR_js.FOLLOW_YAW], sy = Math.sin(yaw), cy = Math.cos(yaw), stage = input.stage, t = chunkH5DFSCJ6_js.templateFrameStamp(frame);
+    stage[chunk5LH2QN3T_js.STAGE_X] = cy * wx - sy * wz, stage[chunk5LH2QN3T_js.STAGE_TIME] = t, input.virtualStaged(this.slotX), stage[chunk5LH2QN3T_js.STAGE_X] = -sy * wx - cy * wz, stage[chunk5LH2QN3T_js.STAGE_TIME] = t, input.virtualStaged(this.slotY), this.jumpEvery > (0) && frame % this.jumpEvery === 0 && rig.motor.state[chunk52YS45RR_js.CHAR_SPEED] > 0 && (this.jumpHeld = this.jumpHold), stage[chunk5LH2QN3T_js.STAGE_X] = this.jumpHeld > 0 ? 1 : 0, stage[chunk5LH2QN3T_js.STAGE_TIME] = t, input.virtualStaged(this.slotJump), this.jumpHeld > 0 && this.jumpHeld--;
+  }
+};
+
+// src/game/kit/templates/courier.ts
+var courier_exports = {};
+chunkJGBCIKJV_js.__export(courier_exports, {
+  COURIER: () => COURIER,
+  CourierPlaza: () => CourierPlaza,
+  courierTemplate: () => courierTemplate
+});
+var COURIER = {
+  plazaHalf: 18,
+  wallHeight: 1.2,
+  crates: 6,
+  crateHalf: 0.8,
+  pickupRadius: 1.3,
+  dropX: 0,
+  dropZ: 0,
+  dropRadius: 2.2,
+  parcelSpread: 13,
+  parcelLift: 0.35,
+  carryLift: 2.1,
+  parcelSize: 0.5
+}, PLAYER_COLOR = 3113197, PARCEL_COLOR = 16103475, CRATE_COLOR = 9268835, DROP_COLOR = 3985274, DROP_HEIGHT = 0.05, PLAYER_WIDTH = 0.7, PLAYER_HEIGHT = 1.8, HALF = 0.5, BOXES = 16, DIGEST_WORDS = 6, BOT_ARRIVE = 0.6, BOT_JUMP_EVERY = 211, BOT_JUMP_HOLD = 9, DROP_KEEP_OUT = 2, PARCEL = 0, PARCEL_SIZE = COURIER.parcelSize, CARRY_LIFT = COURIER.carryLift, CRATE_SIZE = COURIER.crateHalf * 2, DROP_SIZE = COURIER.dropRadius * 2, DROP_POSE = Float64Array.of(COURIER.dropX, (0.05), COURIER.dropZ), DROP_CIRCLE = Float64Array.of(COURIER.dropX, COURIER.dropZ, COURIER.dropRadius), CourierPlaza = class {
+  constructor() {
+    this.name = "courier";
+    this.rig = null;
+    this.deliveries = 0;
+    this.pickups = new Pickups(1, COURIER.pickupRadius);
+    this.parcel = this.pickups.positions;
+    this.crates = new Float64Array(COURIER.crates * 3);
+    this.keepOut = new KeepOut(COURIER.crates + 1);
+    this.boxes = null;
+  }
+  get carrying() {
+    return this.pickups.active[(0)] === 0;
+  }
+  enter(game) {
+    walledArena(game, { half: COURIER.plazaHalf, wallHeight: COURIER.wallHeight }), this.keepOut.add(COURIER.dropX, COURIER.dropZ, COURIER.dropRadius * (2));
+    for (let c = 0; c < COURIER.crates; c++) {
+      let angle = c / COURIER.crates * Math.PI * 2, x = Math.cos(angle) * COURIER.parcelSpread * (0.5), z = Math.sin(angle) * COURIER.parcelSpread * (0.5);
+      this.crates.set([x, COURIER.crateHalf, z], c * 3), staticBox(game, x, COURIER.crateHalf, z, COURIER.crateHalf, COURIER.crateHalf, COURIER.crateHalf), this.keepOut.add(x, z, COURIER.crateHalf + COURIER.pickupRadius);
+    }
+    daylight(game), this.rig = chunk2AQ237Y4_js.thirdPersonCharacter(game, { position: [0, 0, -COURIER.dropRadius * 2], register: false }), this.boxes = new chunkWHYKAT7G_js.BoxBatch(game, (16)), this.pickups.scatter((0), game.random, COURIER.parcelSpread, COURIER.parcelLift, this.keepOut);
+  }
+  fixedUpdate(game) {
+    let rig = this.rig;
+    if (rig === null) return;
+    rig.fixedUpdate(game);
+    let p = game.transforms.store.fields.position, o = game.transforms.row(rig.entity) * 3;
+    this.carrying ? withinCircle(p, o, DROP_CIRCLE, 0) && (this.deliveries++, this.placeParcel(game)) : this.pickups.collect(p, o);
+  }
+  update(game) {
+    let rig = this.rig;
+    rig !== null && (rig.update(game), this.draw(game, rig.entity));
+  }
+  exit() {
+    this.rig?.dispose(), this.rig = null;
+  }
+  target(out) {
+    out[0] = this.carrying ? COURIER.dropX : this.parcel[0], out[1] = this.carrying ? COURIER.dropZ : this.parcel[2];
+  }
+  placeParcel(game) {
+    this.pickups.respawn((0), game.random, COURIER.parcelSpread, this.keepOut);
+  }
+  draw(game, player) {
+    let boxes = this.boxes;
+    if (boxes === null) return;
+    let p = game.transforms.store.fields.position, o = game.transforms.row(player) * 3;
+    boxes.begin(), boxes.sizes((0.7), (1.8), (0.7)), boxes.standAt(p, o, (3113197)), boxes.sizes(PARCEL_SIZE, PARCEL_SIZE, PARCEL_SIZE), boxes.addAt(this.carrying ? p : this.parcel, this.carrying ? o : 0, (16103475), this.carrying ? CARRY_LIFT : 0), boxes.sizes(DROP_SIZE, (0.05), DROP_SIZE).addAt(DROP_POSE, 0, (3985274)), boxes.sizes(CRATE_SIZE, CRATE_SIZE, CRATE_SIZE);
+    for (let c = 0; c < COURIER.crates; c++) boxes.addAt(this.crates, c * 3, (9268835));
+    boxes.end();
+  }
+}, CourierBot = class {
+  constructor() {
+    this.goal = new Float64Array(2);
+    this.seek = new SeekBot({ arrive: (0.6), jumpEvery: (211), jumpHold: (9) });
+  }
+  drive(scene, game, frame) {
+    scene.rig !== null && (scene.target(this.goal), this.seek.drive(game, scene.rig, this.goal, frame));
+  }
+}, digestScratch = new Float64Array((6)), courierTemplate = {
+  id: "courier",
+  title: "Third-person courier",
+  sources: ["src/game/kit/templates/courier.ts"],
+  economy: null,
+  scene: () => new CourierPlaza(),
+  bot: () => new CourierBot(),
+  progress: (scene) => scene.deliveries,
+  digest(scene, game) {
+    let d = digestScratch, rig = scene.rig;
+    if (d[0] = scene.deliveries, d[1] = scene.carrying ? 1 : 0, d[2] = scene.parcel[0], d[3] = scene.parcel[2], rig !== null) {
+      let p = game.transforms.store.fields.position, o = game.transforms.row(rig.entity) * 3;
+      d[4] = p[o], d[5] = p[o + 2];
+    }
+    return chunkH5DFSCJ6_js.digestFloats(d, (6));
+  }
+};
+
+exports.CIRCLE_RADIUS = (2);
+exports.CIRCLE_WORDS = (3);
+exports.CIRCLE_X = (0);
+exports.CIRCLE_Z = (1);
+exports.COURIER = COURIER;
+exports.CourierPlaza = CourierPlaza;
+exports.GOAL_X = (0);
+exports.GOAL_Z = (1);
+exports.KEEP_OUT_STRIDE = (3);
+exports.KeepOut = KeepOut;
+exports.MAX_SCATTER_TRIES = (64);
+exports.NO_PICKUP = (-1);
+exports.PICKUP_STRIDE = (3);
+exports.Pickups = Pickups;
+exports.SeekBot = SeekBot;
+exports.courierTemplate = courierTemplate;
+exports.courier_exports = courier_exports;
+exports.daylight = daylight;
+exports.staticBox = staticBox;
+exports.walledArena = walledArena;
+exports.withinCircle = withinCircle;
+exports.withinRadius = withinRadius;