@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-CVSRWM6W.js

@@ -0,0 +1,418 @@
+'use strict';
+
+var chunkEQUZYCGO_js = require('./chunk-EQUZYCGO.js');
+var chunkWHYKAT7G_js = require('./chunk-WHYKAT7G.js');
+var chunkH5DFSCJ6_js = require('./chunk-H5DFSCJ6.js');
+var chunkNYWNA5CF_js = require('./chunk-NYWNA5CF.js');
+var chunkY4K22JL6_js = require('./chunk-Y4K22JL6.js');
+var chunkRCQ2MPBV_js = require('./chunk-RCQ2MPBV.js');
+var chunkYXGZQPUD_js = require('./chunk-YXGZQPUD.js');
+var chunkJGBCIKJV_js = require('./chunk-JGBCIKJV.js');
+
+// src/game/kit/templates/danfo.ts
+var danfo_exports = {};
+chunkJGBCIKJV_js.__export(danfo_exports, {
+  DANFO: () => DANFO,
+  DANFO_BUS_ATLAS: () => DANFO_BUS_ATLAS,
+  DANFO_BUS_ITEM: () => DANFO_BUS_ITEM,
+  DANFO_BUS_MODEL: () => DANFO_BUS_MODEL,
+  DanfoRoute: () => DanfoRoute,
+  STOPS: () => STOPS,
+  STOP_NAMES: () => STOP_NAMES,
+  danfoRouteTemplate: () => danfoRouteTemplate,
+  loopAhead: () => loopAhead,
+  pointOnLoop: () => pointOnLoop,
+  pointOnLoopAt: () => pointOnLoopAt,
+  projectOnLoop: () => projectOnLoop,
+  projectOnLoopInto: () => projectOnLoopInto,
+  roundedLoop: () => roundedLoop,
+  takeDanfoArt: () => takeDanfoArt
+});
+var DANFO = {
+  halfWidth: 60,
+  halfDepth: 40,
+  cornerRadius: 14,
+  roadHalfWidth: 6,
+  laneOffset: 3,
+  seats: 14,
+  baseFare: 200,
+  farePerStop: 100,
+  stopRadius: 7,
+  stoppedSpeed: 1.5,
+  boardSeconds: 0.35,
+  refillSeconds: 6,
+  maxWaiting: 6,
+  traffic: 4,
+  chassisLift: 1.2
+}, STOP_NAMES = ["Ridgeway Junction", "Palm Market", "Harbour Gate", "Old Mill", "Sunrise Estate"], STOPS = STOP_NAMES.length, STOP_ANCHORS = [
+  [20, -DANFO.halfDepth],
+  [DANFO.halfWidth, 0],
+  [25, DANFO.halfDepth],
+  [-25, DANFO.halfDepth],
+  [-DANFO.halfWidth, 0]
+], ARC_SEGMENTS = 8, CORNERS = 4, SHELTER_OFFSET = 8.5, STEER_KEYS_LEFT = ["ArrowLeft", "KeyA"], STEER_KEYS_RIGHT = ["ArrowRight", "KeyD"], GAS_KEYS = ["ArrowUp", "KeyW"], BRAKE_KEYS = ["ArrowDown", "KeyS"], HORN_KEY = "Space", TOUCH_STEER_PIXELS = 90, TOUCH_BRAKE_PIXELS = 70, CAMERA_BACK = 12, CAMERA_HEIGHT = 6.5, CAMERA_FOV = 62, CAMERA_PITCH = -0.32, GROUND_HALF = 400, GROUND_DEPTH = 0.5, GROUND_COLOR = 7044426, SKY_COLOR = 16174998, FOG_NEAR = 70, FOG_FAR = 260, EXPOSURE = 1.15, FILL_INTENSITY = 0.9, ROAD_COLOR = 3816770, KERB_COLOR = 14078916, MARK_COLOR = 16118246, DANFO_YELLOW = 16040461, STRIPE_COLOR = 1118481, GLASS_COLOR = 2307135, WHEEL_COLOR = 1776411, SHELTER_COLOR = 1013358, SIGN_COLOR = 16436245, RIDER_COLOR = 8141549, BUILDING_COLORS = [15327952, 14263361, 6269088, 14252682, 9416920, 13222578], TRAFFIC_COLORS = [16347926, 15067115, 2450411, 1483594], TRAFFIC_SPEEDS = [8.5, 7.5, 9.5, 8], TRAFFIC_GAP = 9, DASH_LENGTH = 3, DASH_EVERY = 7, STATIC_CAPACITY = 256, DYNAMIC_CAPACITY = 64, AXES = 3, DANFO_BUS_ITEM = "cimplify/danfo-bus", DANFO_BUS_MODEL = "content/cimplify/danfo-bus/danfo.glb", DANFO_BUS_ATLAS = "content/cimplify/lagos-street-atlas/atlas.ktx2", DANFO_MODEL_DROP = -1.17;
+function ownedBuffer(bytes) {
+  return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes.buffer : bytes.slice().buffer;
+}
+async function takeOrNull(assets, asset) {
+  try {
+    return await assets.take(asset);
+  } catch {
+    return null;
+  }
+}
+async function takeDanfoArt(assets) {
+  let model = await takeOrNull(assets, DANFO_BUS_MODEL);
+  if (model === null) return null;
+  let atlas = await takeOrNull(assets, DANFO_BUS_ATLAS);
+  return { model: ownedBuffer(model), atlas: atlas === null ? null : ownedBuffer(atlas) };
+}
+function roundedLoop(halfWidth, halfDepth, radius) {
+  let count = (4) * ((8) + 1), x = new Float64Array(count), z = new Float64Array(count), s = new Float64Array(count + 1), cx = halfWidth - radius, cz = halfDepth - radius, centres = [
+    [-cx, -cz],
+    [cx, -cz],
+    [cx, cz],
+    [-cx, cz]
+  ], i = 0;
+  for (let c = 0; c < (4); c++) {
+    let start = Math.PI + c * Math.PI / 2;
+    for (let k = 0; k <= (8); k++) {
+      let a = start + k / (8) * (Math.PI / 2);
+      x[i] = centres[c][0] + radius * Math.cos(a), z[i] = centres[c][1] + radius * Math.sin(a), i++;
+    }
+  }
+  for (let p = 0; p < count; p++) {
+    let n = (p + 1) % count;
+    s[p + 1] = s[p] + Math.hypot(x[n] - x[p], z[n] - z[p]);
+  }
+  return { x, z, s, count, length: s[count] };
+}
+var LOOP_X = 0, LOOP_Z = 1, LOOP_ALONG = 2, loopScratch = new Float64Array((3));
+function projectOnLoop(path, px, pz) {
+  return loopScratch[(0)] = px, loopScratch[(1)] = pz, projectOnLoopInto(path, loopScratch), loopScratch[(2)];
+}
+function projectOnLoopInto(path, point) {
+  let px = point[(0)], pz = point[(1)], best = 0, bestDistance = 1 / 0;
+  for (let p = 0; p < path.count; p++) {
+    let n = (p + 1) % path.count, ax = path.x[p], az = path.z[p], dx = path.x[n] - ax, dz = path.z[n] - az, len2 = dx * dx + dz * dz, t = len2 > 0 ? ((px - ax) * dx + (pz - az) * dz) / len2 : 0;
+    t = t < 0 ? 0 : t > 1 ? 1 : t;
+    let qx = ax + dx * t - px, qz = az + dz * t - pz, d = qx * qx + qz * qz;
+    d < bestDistance && (bestDistance = d, best = path.s[p] + t * (path.s[p + 1] - path.s[p]));
+  }
+  point[(2)] = best;
+}
+function pointOnLoop(path, along, out) {
+  loopScratch[(2)] = along, pointOnLoopAt(path, loopScratch, (2), out);
+}
+function pointOnLoopAt(path, alongs, slot, out) {
+  let s = alongs[slot] % path.length;
+  s < 0 && (s += path.length);
+  let p = 0;
+  for (; p < path.count - 1 && path.s[p + 1] < s; ) p++;
+  let n = (p + 1) % path.count, span = path.s[p + 1] - path.s[p], t = span > 0 ? (s - path.s[p]) / span : 0, dx = path.x[n] - path.x[p], dz = path.z[n] - path.z[p];
+  out[0] = path.x[p] + dx * t, out[1] = path.z[p] + dz * t, out[2] = Math.atan2(dx, dz);
+}
+function loopAhead(path, from, to) {
+  let d = (to - from) % path.length;
+  return d < 0 ? d + path.length : d;
+}
+function wrapAngle(a) {
+  let r = a;
+  for (; r > Math.PI; ) r -= 2 * Math.PI;
+  for (; r < -Math.PI; ) r += 2 * Math.PI;
+  return r;
+}
+function clamp(v, lo, hi) {
+  return v < lo ? lo : v > hi ? hi : v;
+}
+var DanfoRoute = class {
+  constructor(results = null, art = null) {
+    this.name = "danfo-route";
+    this.lane = roundedLoop(DANFO.halfWidth - DANFO.laneOffset, DANFO.halfDepth - DANFO.laneOffset, DANFO.cornerRadius - DANFO.laneOffset);
+    this.trafficLane = roundedLoop(DANFO.halfWidth + DANFO.laneOffset, DANFO.halfDepth + DANFO.laneOffset, DANFO.cornerRadius + DANFO.laneOffset);
+    this.stopAlong = new Float64Array(STOPS);
+    this.waiting = new Int32Array(STOPS);
+    this.seats = new Int8Array(DANFO.seats).fill(-1);
+    this.trafficAlong = new Float64Array(DANFO.traffic);
+    this.trafficSpeed = new Float64Array(DANFO.traffic);
+    this.phase = "driving";
+    this.fares = 0;
+    this.boarded = 0;
+    this.alighted = 0;
+    this.honks = 0;
+    this.x = 0;
+    this.z = 0;
+    this.yaw = Math.PI / 2;
+    this.speed = 0;
+    this.along = 0;
+    this.laps = 0;
+    this.stopAt = -1;
+    this.nextStop = 0;
+    this.kit = null;
+    this.body = 0;
+    this.camera = 0;
+    this.dynamic = null;
+    this.drive = { throttle: 0, brake: 0, steer: 0, handbrake: 0 };
+    this.position = new chunkRCQ2MPBV_js.Vec3();
+    this.rotation = new chunkRCQ2MPBV_js.Quat();
+    this.point = new Float64Array((3));
+    this.cameraPose = new Float64Array(chunkNYWNA5CF_js.POSE_PITCH + 1);
+    this.touch = new Float64Array(2);
+    this.touchStart = new Float64Array(2);
+    this.touching = false;
+    this.boardTimer = 0;
+    this.refillTimer = 0;
+    this.steerAction = null;
+    this.gasAction = null;
+    this.brakeAction = null;
+    this.hornAction = null;
+    this.faresSlot = null;
+    this.ridersSlot = null;
+    this.speedSlot = null;
+    this.stopSlot = null;
+    this.shownStop = -1;
+    this.cameraReady = false;
+    this.parts = [];
+    this.dressed = Promise.resolve(false);
+    this.results = results, this.art = art;
+    for (let i = 0; i < STOPS; i++) this.stopAlong[i] = projectOnLoop(this.lane, STOP_ANCHORS[i][0], STOP_ANCHORS[i][1]);
+  }
+  modelReady() {
+    return this.dressed;
+  }
+  async dress(game, shell, art) {
+    let gfx = game.graphics;
+    try {
+      let [model, atlas] = await Promise.all([gfx.loadModel({ bytes: art.model }), art.atlas === null ? Promise.resolve(null) : gfx.loadTexture({ bytes: art.atlas })]);
+      if (gfx.instantiate(shell, model.id), atlas !== null) for (let material of model.materials) gfx.setMaterialTexture(material, "map", atlas);
+      for (let node of this.parts) gfx.setVisible(node, !1);
+      return !0;
+    } catch {
+      return false;
+    }
+  }
+  get riders() {
+    let n = 0;
+    for (let i = 0; i < DANFO.seats; i++) this.seats[i] >= 0 && n++;
+    return n;
+  }
+  enter(game) {
+    let gfx = game.graphics, random = game.random, ground = game.world.spawn();
+    game.transforms.add(ground, 0, -(0.5), 0), game.physics.addCollider(ground, { shape: { kind: "cuboid", halfExtents: [(400), (0.5), (400)] }, friction: 1 }), this.camera = chunkWHYKAT7G_js.addSceneCamera(game, 0, (6.5), -(12), (62), (-0.32)), gfx.setEnvironment({ background: { color: (16174998) }, fog: { color: (16174998), near: (70), far: (260) }, exposure: (1.15) });
+    let fill = game.world.spawn();
+    game.transforms.add(fill), gfx.create(fill, { kind: "light", light: "hemisphere", intensity: (0.9), color: (16174998), groundColor: (7044426) });
+    let start = this.lane.s[(8)];
+    pointOnLoop(this.lane, start, this.point), this.x = this.point[0], this.z = this.point[1], this.yaw = this.point[2], this.along = start, this.body = game.world.spawn(), game.transforms.add(this.body, this.x, DANFO.chassisLift, this.z);
+    let h = this.yaw / 2;
+    game.transforms.setRotation(this.body, 0, Math.sin(h), 0, Math.cos(h)), this.kit = chunkEQUZYCGO_js.KitVehicle.spawn(game.physics, this.body, chunkEQUZYCGO_js.vehiclePreset("danfo", "arcade"));
+    let part = (w, ht, d, x, y, z, color) => {
+      let e = game.world.spawn();
+      game.transforms.add(e, x, y, z), game.transforms.setParent(e, this.body), this.parts.push(gfx.mesh(e, gfx.createGeometry(chunkY4K22JL6_js.boxGeometry(w, ht, d)), gfx.createMaterial({ kind: "standard", color, roughness: 0.55 })));
+    };
+    part(1.9, 1.55, 4.6, 0, 0.12, 0, (16040461)), part(1.92, 0.16, 4.62, 0, -0.2, 0, (1118481)), part(1.94, 0.5, 3.2, 0, 0.5, -0.3, (2307135)), part(1.7, 0.55, 0.05, 0, 0.45, 2.3, (2307135));
+    for (let wx of [0.81, -0.81]) for (let wz of [1.25, -1.2]) part(0.3, 0.66, 0.66, wx, -0.62, wz, (1776411));
+    if (this.art !== null) {
+      let shell = game.world.spawn();
+      game.transforms.add(shell, 0, (-1.17), 0), game.transforms.setParent(shell, this.body), this.dressed = this.dress(game, shell, this.art);
+    }
+    this.buildCity(game);
+    for (let i = 0; i < STOPS; i++) this.waiting[i] = 2 + random.int(0, 2);
+    for (let i = 0; i < DANFO.traffic; i++)
+      this.trafficAlong[i] = this.trafficLane.length * (i + 0.5) / DANFO.traffic, this.trafficSpeed[i] = TRAFFIC_SPEEDS[i % TRAFFIC_SPEEDS.length];
+    this.dynamic = new chunkWHYKAT7G_js.BoxBatch(game, (64));
+    let input = game.input;
+    this.steerAction = input.defineAxis("steer", [
+      { device: "virtual", control: "steer" },
+      { device: "keys", negative: STEER_KEYS_LEFT[0], positive: STEER_KEYS_RIGHT[0] },
+      { device: "keys", negative: STEER_KEYS_LEFT[1], positive: STEER_KEYS_RIGHT[1] }
+    ]), this.gasAction = input.defineButton("gas", [{ device: "virtual", control: "gas" }, { device: "key", code: GAS_KEYS[0] }, { device: "key", code: GAS_KEYS[1] }]), this.brakeAction = input.defineButton("brake", [{ device: "virtual", control: "brake" }, { device: "key", code: BRAKE_KEYS[0] }, { device: "key", code: BRAKE_KEYS[1] }]), this.hornAction = input.defineButton("horn", [{ device: "virtual", control: "horn" }, { device: "key", code: HORN_KEY }]), this.faresSlot = game.ui.hudNumber("fares"), this.ridersSlot = game.ui.hudNumber("riders"), this.speedSlot = game.ui.hudNumber("speed"), this.stopSlot = game.ui.hudText("next stop", STOP_NAMES[0]);
+  }
+  fixedUpdate(game) {
+    let kit = this.kit;
+    if (kit === null) return;
+    let dt = game.loop.time.values[chunkYXGZQPUD_js.FRAME_STEP_SECONDS_SLOT];
+    this.readControls(game), kit.drive(this.drive, dt), game.transforms.position(this.body, this.position);
+    let q = game.transforms.rotation(this.body, this.rotation);
+    this.x = this.position.x, this.z = this.position.z, this.yaw = Math.atan2(2 * (q.x * q.z + q.w * q.y), 1 - 2 * (q.x * q.x + q.y * q.y)), this.speed = kit.vehicle.speed;
+    let probe = this.point;
+    probe[0] = this.x, probe[1] = this.z, projectOnLoopInto(this.lane, probe);
+    let along = probe[2];
+    along < this.along - this.lane.length / 2 && this.laps++, this.along = along, this.serveStops(game, dt), this.updateNextStop(game), this.moveTraffic(dt), this.refill(game, dt), this.speedSlot !== null && game.ui.setNumber(this.speedSlot, kit.wholeKmh);
+  }
+  update(game) {
+    let dt = game.time.values[chunkYXGZQPUD_js.FRAME_SECONDS_SLOT], c = this.cameraPose, fx = Math.sin(this.yaw), fz = Math.cos(this.yaw), tx = this.x - fx * (12), tz = this.z - fz * (12), k = this.cameraReady ? 1 - Math.exp(-4 * dt) : 1;
+    c[0] += (tx - c[0]) * k, c[1] = (6.5), c[2] += (tz - c[2]) * k, this.cameraReady = true, c[chunkNYWNA5CF_js.POSE_YAW] = Math.atan2(this.x - c[0], this.z - c[2]) + Math.PI, c[chunkNYWNA5CF_js.POSE_PITCH] = (-0.32), chunkNYWNA5CF_js.placeCamera(game.transforms, this.camera, c, 0), this.draw();
+  }
+  readControls(game) {
+    let input = game.input, d = this.drive, steer = this.steerAction === null ? 0 : input.value(this.steerAction), gas = this.gasAction !== null && input.pressed(this.gasAction) ? 1 : 0, brake = this.brakeAction !== null && input.pressed(this.brakeAction) ? 1 : 0;
+    if (input.pointerCount() > 0 && input.pointerAt(0, this.touch)) {
+      this.touching || (this.touchStart[0] = this.touch[0], this.touchStart[1] = this.touch[1], this.touching = true);
+      let dx = this.touch[0] - this.touchStart[0], dy = this.touch[1] - this.touchStart[1];
+      steer = clamp(steer + dx / (90), -1, 1), dy > (70) ? brake = 1 : gas = 1;
+    } else
+      this.touching = false;
+    this.hornAction !== null && input.justPressed(this.hornAction) && (this.honks++, game.ui.haptic("light")), d.steer = clamp(steer, -1, 1), d.throttle = gas, d.brake = brake;
+  }
+  serveStops(game, dt) {
+    let at = -1;
+    if ((this.speed < 0 ? -this.speed : this.speed) < DANFO.stoppedSpeed)
+      for (let i = 0; i < STOPS; i++) {
+        pointOnLoopAt(this.lane, this.stopAlong, i, this.point);
+        let dx = this.point[0] - this.x, dz = this.point[1] - this.z;
+        dx * dx + dz * dz < DANFO.stopRadius * DANFO.stopRadius && (at = i);
+      }
+    if (at !== this.stopAt && (this.stopAt = at, this.boardTimer = 0), at < 0) {
+      this.phase = "driving";
+      return;
+    }
+    if (this.phase = "boarding", this.boardTimer += dt, !(this.boardTimer < DANFO.boardSeconds)) {
+      this.boardTimer -= DANFO.boardSeconds;
+      for (let s = 0; s < DANFO.seats; s++)
+        if (this.seats[s] === at) {
+          this.seats[s] = -1, this.alighted++, this.publishRiders(game);
+          return;
+        }
+      if (!(this.waiting[at] <= 0))
+        for (let s = 0; s < DANFO.seats; s++) {
+          if (this.seats[s] >= 0) continue;
+          let hops = 1 + game.random.int(0, STOPS - 2);
+          this.seats[s] = (at + hops) % STOPS, this.waiting[at]--;
+          let fare = DANFO.baseFare + DANFO.farePerStop * hops;
+          this.fares += fare, this.boarded++, this.faresSlot !== null && game.ui.setNumber(this.faresSlot, this.fares), this.publishRiders(game), game.ui.haptic("light"), this.results?.fareTaken(at, fare);
+          return;
+        }
+    }
+  }
+  get stopDone() {
+    let at = this.stopAt;
+    if (at < 0) return true;
+    for (let s = 0; s < DANFO.seats; s++) if (this.seats[s] === at) return false;
+    return this.waiting[at] <= 0 || this.riders >= DANFO.seats;
+  }
+  updateNextStop(game) {
+    let next = this.nextStop, served = this.stopAt === next && this.stopDone, behind = this.lane.length - loopAhead(this.lane, this.along, this.stopAlong[next]), missed = this.stopAt !== next && behind > DANFO.stopRadius && behind < this.lane.length / 2;
+    !served && !missed || (this.nextStop = (next + 1) % STOPS, this.stopSlot !== null && this.shownStop !== this.nextStop && (this.shownStop = this.nextStop, game.ui.setText(this.stopSlot, STOP_NAMES[this.nextStop])));
+  }
+  publishRiders(game) {
+    this.ridersSlot !== null && game.ui.setNumber(this.ridersSlot, this.riders);
+  }
+  moveTraffic(dt) {
+    let n = DANFO.traffic, length = this.trafficLane.length;
+    for (let i = 0; i < n; i++) {
+      let gap = 1 / 0;
+      for (let j = 0; j < n; j++) {
+        if (j === i) continue;
+        let d = loopAhead(this.trafficLane, this.trafficAlong[i], this.trafficAlong[j]);
+        d < gap && (gap = d);
+      }
+      let v = gap < (9) ? this.trafficSpeed[i] * (gap / (9)) : this.trafficSpeed[i];
+      this.trafficAlong[i] = (this.trafficAlong[i] + v * dt) % length;
+    }
+  }
+  refill(game, dt) {
+    if (this.refillTimer += dt, this.refillTimer < DANFO.refillSeconds) return;
+    this.refillTimer -= DANFO.refillSeconds;
+    let stop = game.random.int(0, STOPS - 1);
+    stop !== this.stopAt && this.waiting[stop] < DANFO.maxWaiting && this.waiting[stop]++;
+  }
+  buildCity(game) {
+    let boxes = new chunkWHYKAT7G_js.BoxBatch(game, (256), 0.85), b = boxes.box, random = game.random, W = DANFO.halfWidth, H = DANFO.halfDepth, R = DANFO.roadHalfWidth;
+    boxes.begin();
+    let flat = (x, z, sx, sz, y, sy, color) => {
+      b[chunkWHYKAT7G_js.BOX_X] = x, b[chunkWHYKAT7G_js.BOX_Y] = y, b[chunkWHYKAT7G_js.BOX_Z] = z, b[chunkWHYKAT7G_js.BOX_SX] = sx, b[chunkWHYKAT7G_js.BOX_SY] = sy, b[chunkWHYKAT7G_js.BOX_SZ] = sz, boxes.add(color);
+    };
+    flat(0, 0, (400) * 2, (400) * 2, -0.02, 0.02, (7044426)), flat(0, -H, 2 * (W + R), 2 * R, 0.01, 0.02, (3816770)), flat(0, H, 2 * (W + R), 2 * R, 0.01, 0.02, (3816770)), flat(-W, 0, 2 * R, 2 * (H - R), 0.01, 0.02, (3816770)), flat(W, 0, 2 * R, 2 * (H - R), 0.01, 0.02, (3816770)), flat(0, -H + R, 2 * (W - R), 0.4, 0.1, 0.2, (14078916)), flat(0, H - R, 2 * (W - R), 0.4, 0.1, 0.2, (14078916)), flat(-W + R, 0, 0.4, 2 * (H - R), 0.1, 0.2, (14078916)), flat(W - R, 0, 0.4, 2 * (H - R), 0.1, 0.2, (14078916)), flat(0, -H - R, 2 * (W + R), 0.4, 0.1, 0.2, (14078916)), flat(0, H + R, 2 * (W + R), 0.4, 0.1, 0.2, (14078916)), flat(-W - R, 0, 0.4, 2 * (H + R), 0.1, 0.2, (14078916)), flat(W + R, 0, 0.4, 2 * (H + R), 0.1, 0.2, (14078916));
+    for (let x = -W + R + (7); x < W - R; x += (7))
+      flat(x, -H, (3), 0.25, 0.03, 0.01, (16118246)), flat(x, H, (3), 0.25, 0.03, 0.01, (16118246));
+    for (let z = -H + R + (7); z < H - R; z += (7))
+      flat(-W, z, 0.25, (3), 0.03, 0.01, (16118246)), flat(W, z, 0.25, (3), 0.03, 0.01, (16118246));
+    let building = (x, z, sx, sz) => {
+      let height = 5 + random.int(0, 14);
+      flat(x, z, sx, sz, height / 2, height, BUILDING_COLORS[random.int(0, BUILDING_COLORS.length - 1)]);
+      let e = game.world.spawn();
+      game.transforms.add(e, x, height / 2, z), game.physics.addCollider(e, { shape: { kind: "cuboid", halfExtents: [sx / 2, height / 2, sz / 2] } });
+    };
+    for (let gx = -1.5; gx <= 1.5; gx++) for (let gz = -1; gz <= 1; gz++) building(gx * 22, gz * 18, 14, 10);
+    for (let x = -70; x <= 70; x += 20)
+      building(x, -H - 20, 14, 10), building(x, H + 20, 14, 10);
+    for (let z = -30; z <= 30; z += 20)
+      building(-W - 20, z, 10, 14), building(W + 20, z, 10, 14);
+    for (let i = 0; i < STOPS; i++) {
+      pointOnLoopAt(this.lane, this.stopAlong, i, this.point);
+      let nx = -Math.cos(this.point[2]), nz = Math.sin(this.point[2]), sx = this.point[0] + nx * ((8.5) - DANFO.laneOffset), sz = this.point[1] + nz * ((8.5) - DANFO.laneOffset), along = Math.abs(nx) > 0.5;
+      flat(sx, sz, along ? 1.2 : 4, along ? 4 : 1.2, 2.6, 0.15, (1013358)), flat(sx, sz, 0.15, 0.15, 1.3, 2.6, (1013358)), flat(sx - nx * 0.5, sz - nz * 0.5, along ? 0.1 : 0.9, along ? 0.9 : 0.1, 3.2, 0.6, (16436245));
+    }
+    boxes.end();
+  }
+  draw() {
+    let boxes = this.dynamic;
+    if (boxes === null) return;
+    boxes.begin();
+    let b = boxes.box;
+    for (let i = 0; i < DANFO.traffic; i++) {
+      pointOnLoopAt(this.trafficLane, this.trafficAlong, i, this.point);
+      let h = this.point[2] / 2;
+      b[chunkWHYKAT7G_js.BOX_X] = this.point[0], b[chunkWHYKAT7G_js.BOX_Y] = 0.8, b[chunkWHYKAT7G_js.BOX_Z] = this.point[1], b[chunkWHYKAT7G_js.BOX_ROTATION] = 0, b[chunkWHYKAT7G_js.BOX_ROTATION + 1] = Math.sin(h), b[chunkWHYKAT7G_js.BOX_ROTATION + 2] = 0, b[chunkWHYKAT7G_js.BOX_ROTATION + 3] = Math.cos(h), b[chunkWHYKAT7G_js.BOX_SX] = 1.8, b[chunkWHYKAT7G_js.BOX_SY] = 1.4, b[chunkWHYKAT7G_js.BOX_SZ] = 4.2, boxes.add(TRAFFIC_COLORS[i % TRAFFIC_COLORS.length]);
+    }
+    b[chunkWHYKAT7G_js.BOX_ROTATION + 1] = 0, b[chunkWHYKAT7G_js.BOX_ROTATION + 3] = 1, b[chunkWHYKAT7G_js.BOX_SX] = 0.45, b[chunkWHYKAT7G_js.BOX_SY] = 1.6, b[chunkWHYKAT7G_js.BOX_SZ] = 0.45, b[chunkWHYKAT7G_js.BOX_Y] = 0.8;
+    for (let i = 0; i < STOPS; i++) {
+      pointOnLoopAt(this.lane, this.stopAlong, i, this.point);
+      let nx = -Math.cos(this.point[2]), nz = Math.sin(this.point[2]), tx = Math.sin(this.point[2]), tz = Math.cos(this.point[2]);
+      for (let k = 0; k < this.waiting[i]; k++) {
+        let off = (k - (this.waiting[i] - 1) / 2) * 0.7;
+        b[chunkWHYKAT7G_js.BOX_X] = this.point[0] + nx * ((8.5) - DANFO.laneOffset - 1.2) + tx * off, b[chunkWHYKAT7G_js.BOX_Z] = this.point[1] + nz * ((8.5) - DANFO.laneOffset - 1.2) + tz * off, boxes.add((8141549));
+      }
+    }
+    boxes.end();
+  }
+}, BOT_LOOKAHEAD = 7, BOT_LOOKAHEAD_PER_SPEED = 0.5, BOT_STEER_GAIN = 1.8, BOT_CRUISE = 11, BOT_CORNER = 7, BOT_APPROACH = 26, BOT_STOP_WINDOW = 2.5, BOT_CURVE_PROBE = 18, BOT_STILL = 0.4, PROBE_AHEAD = 0, PROBE_HERE = 1, PROBE_CURVE = 2, BOT_PROBES = 3, DanfoBot = class {
+  constructor() {
+    this.point = new Float64Array((3));
+    this.probes = new Float64Array((3));
+  }
+  drive(scene, game, frame) {
+    let lane = scene.lane, speed = scene.speed, probes = this.probes;
+    probes[(0)] = scene.along + (7) + Math.max(0, speed) * (0.5), probes[(1)] = scene.along, probes[(2)] = scene.along + (18), pointOnLoopAt(lane, probes, (0), this.point);
+    let desired = Math.atan2(this.point[0] - scene.x, this.point[1] - scene.z), steer = clamp(-wrapAngle(desired - scene.yaw) * (1.8), -1, 1);
+    pointOnLoopAt(lane, probes, (1), this.point);
+    let here = this.point[2];
+    pointOnLoopAt(lane, probes, (2), this.point);
+    let target = Math.abs(wrapAngle(this.point[2] - here)) > 0.3 ? (7) : (11), toStop = loopAhead(lane, scene.along, scene.stopAlong[scene.nextStop]), passed = lane.length - toStop;
+    toStop < (26) && toStop > (2.5) && (target = Math.min(target, 1 + toStop * 0.3));
+    let hold = toStop <= (2.5) || passed < DANFO.stopRadius - 1 || scene.stopAt >= 0 && !scene.stopDone, time = chunkH5DFSCJ6_js.templateFrameStamp(frame), input = game.input;
+    if (input.virtualEvent("steer", steer, time), hold) {
+      input.virtualEvent("gas", 0, time), input.virtualEvent("brake", Math.abs(speed) > (0.4) ? 1 : 0, time);
+      return;
+    }
+    input.virtualEvent("gas", speed < target ? 1 : 0, time), input.virtualEvent("brake", speed > target + 2 ? 1 : 0, time);
+  }
+}, DIGEST_FIELDS = 8, digestScratch = new Float64Array((8)), danfoRouteTemplate = {
+  id: "danfo-route",
+  title: "Danfo route",
+  sources: ["src/game/kit/templates/danfo.ts"],
+  economy: null,
+  scene: () => new DanfoRoute(),
+  bot: () => new DanfoBot(),
+  progress: (scene) => scene.fares,
+  digest(scene) {
+    let d = digestScratch;
+    return d[0] = scene.fares, d[1] = scene.boarded, d[2] = scene.alighted, d[3] = scene.x, d[4] = scene.z, d[5] = scene.along, d[6] = scene.laps, d[7] = scene.speed, chunkH5DFSCJ6_js.digestFloats(d, (8));
+  }
+};
+
+exports.DANFO = DANFO;
+exports.DANFO_BUS_ATLAS = DANFO_BUS_ATLAS;
+exports.DANFO_BUS_ITEM = DANFO_BUS_ITEM;
+exports.DANFO_BUS_MODEL = DANFO_BUS_MODEL;
+exports.DanfoRoute = DanfoRoute;
+exports.STOPS = STOPS;
+exports.STOP_NAMES = STOP_NAMES;
+exports.danfoRouteTemplate = danfoRouteTemplate;
+exports.danfo_exports = danfo_exports;
+exports.loopAhead = loopAhead;
+exports.pointOnLoop = pointOnLoop;
+exports.pointOnLoopAt = pointOnLoopAt;
+exports.projectOnLoop = projectOnLoop;
+exports.projectOnLoopInto = projectOnLoopInto;
+exports.roundedLoop = roundedLoop;
+exports.takeDanfoArt = takeDanfoArt;

package/dist/chunk-CYBMFMJD.mjs

@@ -0,0 +1,247 @@
+import { peakCurve, STATE_SPEED, INPUT_THROTTLE, INPUT_BRAKE, INPUT_STEER, GEAR_AUTO, INPUT_GEAR, GEAR_REVERSE, STATE_HEADER, WHEEL_STRIDE, WHEEL_SLIP, INPUT_HANDBRAKE, WHEEL_CENTER, WHEEL_STEER, WHEEL_SPIN, WHEEL_OMEGA } from './chunk-RUVGVNOF.mjs';
+
+// src/game/kit/vehicles/vehicle.ts
+var KMH_PER_MS = 3.6, STOPPED_SPEED = 0.6, REVERSE_HOLD = 0.25, DRIVE_SPIN = 5, DRIVE_LOCK = 6, DRIVE_WORDS = 7, KitVehicle = class _KitVehicle {
+  constructor(vehicle, spec) {
+    this.reversing = false;
+    this.stoppedFor = 0;
+    this.io = new Float64Array((7));
+    this.vehicle = vehicle, this.spec = spec;
+  }
+  static spawn(physics, entity, spec) {
+    let c = spec.chassis;
+    physics.addBody(entity, { kind: "dynamic", canSleep: false, linearDamping: c.linearDamping, angularDamping: c.angularDamping });
+    let ballast = c.mass * c.ballastShare;
+    return physics.addCollider(entity, { shape: { kind: "cuboid", halfExtents: c.halfExtents }, mass: c.mass - ballast, friction: 0.4 }), ballast > 0 && physics.addCollider(entity, {
+      shape: { kind: "cuboid", halfExtents: [c.halfExtents[0] * 0.5, 0.05, c.halfExtents[2] * 0.5] },
+      offset: [0, -c.ballastDrop, 0],
+      mass: ballast,
+      friction: 0.4
+    }), new _KitVehicle(physics.createVehicle(entity, spec.desc), spec);
+  }
+  get speedKmh() {
+    return this.vehicle.speed * (3.6);
+  }
+  get wholeKmh() {
+    let kmh = this.vehicle.stateView[this.vehicle.stateOffset + STATE_SPEED] * (3.6);
+    return Math.round(kmh < 0 ? -kmh : kmh);
+  }
+  drive(controls, dt) {
+    let assists = this.spec.assists, v = this.vehicle, io = this.io, t0 = controls.throttle;
+    io[INPUT_THROTTLE] = t0 > 0 ? t0 < 1 ? t0 : 1 : 0;
+    let b0 = controls.brake;
+    io[INPUT_BRAKE] = b0 > 0 ? b0 < 1 ? b0 : 1 : 0;
+    let s0 = controls.steer;
+    if (io[INPUT_STEER] = s0 < -1 ? -1 : s0 > 1 ? 1 : s0, io[INPUT_GEAR] = GEAR_AUTO, assists) {
+      let states = v.stateView, base = v.stateOffset, speed = states[base + STATE_SPEED], absSpeed = speed < 0 ? -speed : speed;
+      if (assists.autoReverse) {
+        absSpeed < (0.6) ? this.stoppedFor += dt : this.stoppedFor = 0;
+        let throttle = io[INPUT_THROTTLE], brake = io[INPUT_BRAKE];
+        if (!this.reversing && brake > 0 && throttle === 0 && this.stoppedFor > (0.25) ? this.reversing = true : this.reversing && throttle > 0 && brake === 0 && (this.reversing = false), this.reversing) {
+          io[INPUT_GEAR] = GEAR_REVERSE, io[INPUT_THROTTLE] = brake;
+          let t1 = controls.throttle;
+          io[INPUT_BRAKE] = t1 > 0 ? t1 < 1 ? t1 : 1 : 0;
+        }
+      }
+      let ratio = absSpeed / assists.steerFadeSpeed;
+      io[INPUT_STEER] *= 1 - assists.steerFade * (ratio > 1 ? 1 : ratio);
+      let wheels = this.spec.desc.wheels, sign = io[INPUT_GEAR] === GEAR_REVERSE ? -1 : 1;
+      io[(5)] = 0, io[(6)] = 0;
+      for (let w = 0; w < v.wheelCount; w++) {
+        let slip = states[base + STATE_HEADER + w * WHEEL_STRIDE + WHEEL_SLIP] * sign;
+        (wheels[w].drive ?? 0) > 0 && slip > io[(5)] && (io[(5)] = slip), -slip > io[(6)] && (io[(6)] = -slip);
+      }
+      io[INPUT_THROTTLE] > 0 && io[(5)] > assists.tractionSlip && (io[INPUT_THROTTLE] *= assists.tractionSlip / io[(5)]), io[INPUT_BRAKE] > 0 && io[(6)] > assists.brakeSlip && (io[INPUT_BRAKE] *= assists.brakeSlip / io[(6)]);
+    }
+    let h = controls.handbrake;
+    io[INPUT_HANDBRAKE] = h > 0 ? h < 1 ? h : 1 : 0, v.driveFrom(io, 0);
+  }
+  wheelPosition(index, out, offset = 0) {
+    let v = this.vehicle;
+    out[offset] = v.wheel(index, WHEEL_CENTER), out[offset + 1] = v.wheel(index, WHEEL_CENTER + 1), out[offset + 2] = v.wheel(index, WHEEL_CENTER + 2);
+  }
+  wheelRotation(index, chassis, chassisOffset, out, offset = 0) {
+    let v = this.vehicle, yaw = -v.wheel(index, WHEEL_STEER) * 0.5, pitch = v.wheel(index, WHEEL_SPIN) * 0.5, sy = Math.sin(yaw), cy = Math.cos(yaw), sp = Math.sin(pitch), cp = Math.cos(pitch), lx = cy * sp, ly = sy * cp, lz = -sy * sp, lw = cy * cp, qx = chassis[chassisOffset], qy = chassis[chassisOffset + 1], qz = chassis[chassisOffset + 2], qw = chassis[chassisOffset + 3];
+    out[offset] = qw * lx + qx * lw + qy * lz - qz * ly, out[offset + 1] = qw * ly - qx * lz + qy * lw + qz * lx, out[offset + 2] = qw * lz + qx * ly - qy * lx + qz * lw, out[offset + 3] = qw * lw - qx * lx - qy * ly - qz * lz;
+  }
+  wheelSpeed(index) {
+    return this.vehicle.wheel(index, WHEEL_OMEGA);
+  }
+};
+
+// src/game/kit/vehicles/presets.ts
+var ROAD_LONGITUDINAL = peakCurve(0.12, 1.05, 0.8, 0.8), ROAD_LATERAL = peakCurve(0.18, 1, 0.9, 0.75), VAN_LATERAL = peakCurve(0.16, 0.82, 0.9, 0.65), ARCADE_GRIP = 1.35, ARCADE_ANTI_ROLL = 2.5, ARCADE_BALLAST = 0.45, ARCADE_FORCE_HEIGHT = 0.8, ARCADE_ASSISTS = {
+  tractionSlip: 0.35,
+  brakeSlip: 0.3,
+  steerFade: 0.55,
+  steerFadeSpeed: 25,
+  autoReverse: true,
+  yawDamping: 0.35
+};
+function axle(layout, z, front, base) {
+  let x = layout.track * 0.5;
+  return [
+    { ...base, position: [x, layout.height, z], radius: layout.radius, steer: front ? 1 : 0, axle: front ? 0 : 1 },
+    { ...base, position: [-x, layout.height, z], radius: layout.radius, steer: front ? 1 : 0, axle: front ? 0 : 1 }
+  ];
+}
+function danfo() {
+  let layout = { front: 1.25, rear: -1.2, track: 1.62, height: -0.62, radius: 0.33 }, wheel = {
+    inertia: 1.6,
+    restLength: 0.32,
+    travel: 0.16,
+    stiffness: 52e3,
+    compressionDamping: 3800,
+    relaxationDamping: 5200,
+    maxSuspensionForce: 6e4,
+    brakeTorque: 2200,
+    longitudinal: ROAD_LONGITUDINAL,
+    lateral: VAN_LATERAL
+  };
+  return {
+    name: "danfo",
+    model: "sim",
+    chassis: { mass: 2100, halfExtents: [0.95, 0.95, 2.25], ballastShare: 0.15, ballastDrop: 0.7, linearDamping: 0.02, angularDamping: 0.3 },
+    desc: {
+      wheels: [
+        ...axle(layout, layout.front, true, { ...wheel, drive: 0 }),
+        ...axle(layout, layout.rear, false, { ...wheel, drive: 1, handbrakeTorque: 3e3 })
+      ],
+      engine: { torque: { x: [900, 2e3, 3200, 4600], y: [125, 165, 172, 140] }, idleRpm: 850, maxRpm: 5e3, engineBraking: 45, inertia: 0.3 },
+      gearbox: { ratios: [3.78, 2.06, 1.26, 0.88], reverse: 3.28, finalDrive: 4.86, shiftUpRpm: 4300, shiftDownRpm: 1700, shiftSeconds: 0.35 },
+      maxSteerRadians: 0.62,
+      steerRate: 2.2,
+      ackermann: 1,
+      antiRoll: 6e3,
+      drag: 0.75,
+      rollingResistance: 0.03,
+      handbrakeGrip: 0.55
+    },
+    assists: null
+  };
+}
+function keke() {
+  let wheel = {
+    inertia: 0.25,
+    restLength: 0.2,
+    travel: 0.09,
+    stiffness: 16e3,
+    compressionDamping: 1100,
+    relaxationDamping: 1500,
+    maxSuspensionForce: 12e3,
+    brakeTorque: 450,
+    longitudinal: ROAD_LONGITUDINAL,
+    lateral: ROAD_LATERAL
+  }, radius = 0.2;
+  return {
+    name: "keke",
+    model: "sim",
+    chassis: { mass: 360, halfExtents: [0.65, 0.85, 1.35], ballastShare: 0.2, ballastDrop: 0.55, linearDamping: 0.03, angularDamping: 0.4 },
+    desc: {
+      wheels: [
+        { ...wheel, position: [0, -0.68, 1], radius, steer: 1, drive: 0 },
+        { ...wheel, position: [0.6, -0.68, -0.72], radius, drive: 1, handbrakeTorque: 700, axle: 1 },
+        { ...wheel, position: [-0.6, -0.68, -0.72], radius, drive: 1, handbrakeTorque: 700, axle: 1 }
+      ],
+      engine: { torque: { x: [2e3, 4e3, 5500, 7e3], y: [8, 10.5, 11.2, 9] }, idleRpm: 1400, maxRpm: 7500, engineBraking: 4, inertia: 0.02 },
+      gearbox: { ratios: [3, 1.9, 1.35, 1], reverse: 3.2, finalDrive: 9.5, shiftUpRpm: 6800, shiftDownRpm: 3e3, shiftSeconds: 0.3 },
+      maxSteerRadians: 0.7,
+      steerRate: 3.2,
+      antiRoll: 1500,
+      drag: 0.55,
+      rollingResistance: 0.04,
+      handbrakeGrip: 0.6
+    },
+    assists: null
+  };
+}
+function okada() {
+  let wheel = {
+    inertia: 0.3,
+    restLength: 0.18,
+    travel: 0.1,
+    stiffness: 14e3,
+    compressionDamping: 900,
+    relaxationDamping: 1200,
+    maxSuspensionForce: 9e3,
+    brakeTorque: 380,
+    longitudinal: ROAD_LONGITUDINAL,
+    lateral: ROAD_LATERAL
+  };
+  return {
+    name: "okada",
+    model: "sim",
+    chassis: { mass: 210, halfExtents: [0.22, 0.45, 0.95], ballastShare: 0.25, ballastDrop: 0.3, linearDamping: 0.02, angularDamping: 0.5 },
+    desc: {
+      wheels: [
+        { ...wheel, position: [0, -0.32, 0.68], radius: 0.3, steer: 1 },
+        { ...wheel, position: [0, -0.32, -0.66], radius: 0.3, drive: 1, handbrakeTorque: 300 }
+      ],
+      engine: { torque: { x: [2e3, 4500, 6500, 8e3], y: [8, 11, 12, 10] }, idleRpm: 1400, maxRpm: 8500, engineBraking: 3, inertia: 0.015 },
+      gearbox: { ratios: [2.9, 1.9, 1.4, 1.1, 0.95], reverse: 2.9, finalDrive: 8.2, shiftUpRpm: 7800, shiftDownRpm: 3500, shiftSeconds: 0.15 },
+      maxSteerRadians: 0.4,
+      steerRate: 2.5,
+      drag: 0.3,
+      rollingResistance: 0.03,
+      lean: { maxAngle: 0.6, stiffness: 1200, damping: 220, fullSpeed: 9 }
+    },
+    assists: null
+  };
+}
+function car() {
+  let layout = { front: 1.35, rear: -1.3, track: 1.56, height: -0.18, radius: 0.32 }, wheel = {
+    inertia: 1.1,
+    restLength: 0.33,
+    travel: 0.14,
+    stiffness: 38e3,
+    compressionDamping: 3200,
+    relaxationDamping: 4200,
+    maxSuspensionForce: 4e4,
+    brakeTorque: 1800,
+    longitudinal: ROAD_LONGITUDINAL,
+    lateral: ROAD_LATERAL
+  };
+  return {
+    name: "car",
+    model: "sim",
+    chassis: { mass: 1250, halfExtents: [0.88, 0.38, 2.15], ballastShare: 0.1, ballastDrop: 0.25, linearDamping: 0.01, angularDamping: 0.2 },
+    desc: {
+      wheels: [
+        ...axle(layout, layout.front, true, { ...wheel, drive: 0.4 }),
+        ...axle(layout, layout.rear, false, { ...wheel, drive: 0.6, handbrakeTorque: 3500 })
+      ],
+      engine: { torque: { x: [1e3, 2500, 4500, 6200], y: [170, 235, 250, 205] }, idleRpm: 850, maxRpm: 6700, engineBraking: 55, inertia: 0.2 },
+      gearbox: { ratios: [3.4, 2.1, 1.45, 1.1, 0.9], reverse: 3.3, finalDrive: 3.9, shiftUpRpm: 6e3, shiftDownRpm: 2200, shiftSeconds: 0.18 },
+      maxSteerRadians: 0.6,
+      steerRate: 3,
+      ackermann: 1,
+      antiRoll: 9e3,
+      downforce: 0.35,
+      drag: 0.42,
+      rollingResistance: 0.02,
+      handbrakeGrip: 0.45
+    },
+    assists: null
+  };
+}
+function arcade(spec) {
+  return {
+    ...spec,
+    model: "arcade",
+    chassis: { ...spec.chassis, ballastShare: Math.max(spec.chassis.ballastShare, (0.45)), angularDamping: spec.chassis.angularDamping * 2 },
+    desc: {
+      ...spec.desc,
+      antiRoll: (spec.desc.antiRoll ?? 0) * (2.5),
+      forceHeight: spec.desc.lean ? 0 : (0.8),
+      wheels: spec.desc.wheels.map((w) => ({ ...w, grip: (w.grip ?? 1) * (1.35) })),
+      steerRate: (spec.desc.steerRate ?? 3) * 1.5
+    },
+    assists: ARCADE_ASSISTS
+  };
+}
+function vehiclePreset(name, model = "arcade") {
+  let base = name === "danfo" ? danfo() : name === "keke" ? keke() : name === "okada" ? okada() : car();
+  return model === "arcade" ? arcade(base) : base;
+}
+
+export { KitVehicle, vehiclePreset };