@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-KPA6K5IB.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var chunkNH654HAT_js = require('./chunk-NH654HAT.js');
+var chunkYXGZQPUD_js = require('./chunk-YXGZQPUD.js');
+
+// src/game/kit/feel/juice.ts
+var DEFAULT_STIFFNESS = 320, DEFAULT_DAMPING = 16, MAX_SUBSTEP_SECONDS = 1 / 120, REST_EPSILON = 1e-4, Springs = class {
+  constructor(capacity) {
+    this.dt = new Float64Array(1);
+    this.count = 0;
+    this.capacity = capacity, this.values = new Float64Array(capacity), this.velocities = new Float64Array(capacity), this.targets = new Float64Array(capacity), this.stiffness = new Float64Array(capacity), this.damping = new Float64Array(capacity), this.awake = new Uint8Array(capacity), this.impulses = new Float64Array(capacity);
+  }
+  create(rest = 0, options = {}) {
+    if (this.count >= this.capacity) throw new chunkNH654HAT_js.KitError("capacity_exceeded", `at most ${this.capacity} springs`);
+    let i = this.count++;
+    return this.values[i] = rest, this.targets[i] = rest, this.velocities[i] = 0, this.stiffness[i] = options.stiffness ?? (320), this.damping[i] = options.damping ?? (16), i;
+  }
+  punch(slot, velocity) {
+    this.impulses[slot] = velocity, this.awake[slot] = 1;
+  }
+  setTarget(slot, target) {
+    this.targets[slot] = target, this.awake[slot] = 1;
+  }
+  snap(slot, value) {
+    this.values[slot] = value, this.targets[slot] = value, this.velocities[slot] = 0, this.awake[slot] = 0;
+  }
+  update(time) {
+    this.dt[0] = time.values[chunkYXGZQPUD_js.FRAME_SECONDS_SLOT], this.run();
+  }
+  advance(seconds) {
+    this.dt[0] = seconds, this.run();
+  }
+  squash(slot, out, offset) {
+    let y = 1 + this.values[slot], xz = y > 0 ? 1 / Math.sqrt(y) : 1;
+    out[offset] = xz, out[offset + 1] = y, out[offset + 2] = xz;
+  }
+  run() {
+    let seconds = this.dt[0];
+    if (seconds <= 0) return;
+    let steps = Math.ceil(seconds / MAX_SUBSTEP_SECONDS), h = seconds / steps, v = this.values, vel = this.velocities, target = this.targets, k = this.stiffness, c = this.damping, awake = this.awake, impulses = this.impulses;
+    for (let i = 0; i < this.count; i++) {
+      if (awake[i] === 0) continue;
+      let x = v[i], u = vel[i] + impulses[i];
+      impulses[i] = 0;
+      let t = target[i];
+      for (let s = 0; s < steps; s++)
+        u += (-k[i] * (x - t) - c[i] * u) * h, x += u * h;
+      v[i] = x, vel[i] = u, Math.abs(x - t) < (1e-4) && Math.abs(u) < (1e-4) && (v[i] = t, vel[i] = 0, awake[i] = 0);
+    }
+  }
+}, F_INTENSITY = 3, F_FADE = 4, F_COUNT = 5, CHANNEL_MAX = 255, NO_FLASH = -1, R_SECONDS = 0, R_INTENSITY = 1, R_COUNT = 2, ScreenFlash = class {
+  constructor() {
+    this.color = new Float32Array((5));
+    this.request = new Float64Array((2));
+    this.pendingRgb = (-1);
+  }
+  get intensity() {
+    return this.absorb(), this.color[(3)];
+  }
+  trigger(rgb, seconds, intensity = 1) {
+    this.request[(0)] = seconds, this.request[(1)] = intensity, this.pendingRgb = rgb;
+  }
+  update(time) {
+    this.absorb();
+    let c = this.color;
+    if (c[(3)] <= 0) return;
+    let next = c[(3)] - c[(4)] * time.values[chunkYXGZQPUD_js.FRAME_SECONDS_SLOT];
+    c[(3)] = next > 0 ? next : 0;
+  }
+  absorb() {
+    let rgb = this.pendingRgb;
+    if (rgb === (-1)) return;
+    this.pendingRgb = (-1);
+    let c = this.color, r = this.request;
+    c[0] = (rgb >> 16 & (255)) / (255), c[1] = (rgb >> 8 & (255)) / (255), c[2] = (rgb & (255)) / (255), c[(3)] = r[(1)], c[(4)] = r[(0)] > 0 ? r[(1)] / r[(0)] : r[(1)];
+  }
+};
+
+exports.ScreenFlash = ScreenFlash;
+exports.Springs = Springs;

package/dist/chunk-KU7O4IXU.mjs

@@ -0,0 +1,260 @@
+import { thirdPersonCharacter, TOUCH_CONTROLS } from './chunk-ZCY6YKKP.mjs';
+import { KitError } from './chunk-4DYKAYFO.mjs';
+import { BoxBatch } from './chunk-QDYFLATW.mjs';
+import { digestFloats, templateFrameStamp } from './chunk-KGHJH5KJ.mjs';
+import { FOLLOW_YAW, CHAR_SPEED } from './chunk-ECDK6QBF.mjs';
+import { CENTERED_MAX_EXTENT, CENTERED_FIXED_UNITS, STAGE_X, STAGE_TIME } from './chunk-22BD3RHN.mjs';
+import { __export } from './chunk-25T4JHEA.mjs';
+
+// 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 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 KitError("capacity_exceeded", "the keep-out areas are full");
+    let fx = Math.trunc(x * CENTERED_FIXED_UNITS), fz = Math.trunc(z * CENTERED_FIXED_UNITS), fr = Math.trunc(radius * CENTERED_FIXED_UNITS);
+    if (!(Math.abs(fx) < FIXED_LIMIT && Math.abs(fz) < FIXED_LIMIT && fr >= 0 && fr < FIXED_LIMIT))
+      throw new KitError("invalid_declaration", `keep-out areas must lie within ${FIXED_LIMIT / 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 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 >= CENTERED_MAX_EXTENT)
+      throw new KitError("invalid_declaration", `respawn needs a whole half extent from 1 to ${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(TOUCH_CONTROLS.moveX), this.slotY = input.virtualControl(TOUCH_CONTROLS.moveY), this.slotJump = input.virtualControl(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[FOLLOW_YAW], sy = Math.sin(yaw), cy = Math.cos(yaw), stage = input.stage, t = templateFrameStamp(frame);
+    stage[STAGE_X] = cy * wx - sy * wz, stage[STAGE_TIME] = t, input.virtualStaged(this.slotX), stage[STAGE_X] = -sy * wx - cy * wz, stage[STAGE_TIME] = t, input.virtualStaged(this.slotY), this.jumpEvery > (0) && frame % this.jumpEvery === 0 && rig.motor.state[CHAR_SPEED] > 0 && (this.jumpHeld = this.jumpHold), stage[STAGE_X] = this.jumpHeld > 0 ? 1 : 0, stage[STAGE_TIME] = t, input.virtualStaged(this.slotJump), this.jumpHeld > 0 && this.jumpHeld--;
+  }
+};
+
+// src/game/kit/templates/courier.ts
+var courier_exports = {};
+__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 = thirdPersonCharacter(game, { position: [0, 0, -COURIER.dropRadius * 2], register: false }), this.boxes = new 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 digestFloats(d, (6));
+  }
+};
+
+export { CIRCLE_RADIUS, CIRCLE_WORDS, CIRCLE_X, CIRCLE_Z, COURIER, CourierPlaza, GOAL_X, GOAL_Z, KEEP_OUT_STRIDE, KeepOut, MAX_SCATTER_TRIES, NO_PICKUP, PICKUP_STRIDE, Pickups, SeekBot, courierTemplate, courier_exports, daylight, staticBox, walledArena, withinCircle, withinRadius };