@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-K3HW5I2A.mjs

@@ -0,0 +1,317 @@
+import { writePosition } from './chunk-GPS2THCL.mjs';
+import { softCurrency, premiumCurrency, softItem, premiumItem, faucet, softExchange, grant, randomExchange, discloseOdds, fixedOffer } from './chunk-3DAD2LDF.mjs';
+import { ScreenShake, HitStop } from './chunk-2UN4SFLR.mjs';
+import { ScreenFlash } from './chunk-A7MQSN2V.mjs';
+import { templateFrameStamp, digestInts } from './chunk-KGHJH5KJ.mjs';
+import { boxGeometry, sphereGeometry } from './chunk-GHPUYD4I.mjs';
+import { CharacterMove } from './chunk-HF5HPS4T.mjs';
+import { Vec3, Quat } from './chunk-XPG3N5CF.mjs';
+import { NO_ENTITY } from './chunk-T3AFF3L7.mjs';
+import { FRAME_STEP_SECONDS_SLOT } from './chunk-IDLW4NWA.mjs';
+import { __export } from './chunk-25T4JHEA.mjs';
+
+// src/game/kit/templates/shootout.ts
+var shootout_exports = {};
+__export(shootout_exports, {
+  PenaltyShootout: () => PenaltyShootout,
+  SHOOTOUT: () => SHOOTOUT,
+  buyClassicBall: () => buyClassicBall,
+  classicBall: () => classicBall,
+  goalTokens: () => goalTokens,
+  goldBoots: () => goldBoots,
+  goldBootsOffer: () => goldBootsOffer,
+  kente: () => kente,
+  kitDraw: () => kitDraw,
+  nightPitch: () => nightPitch,
+  penaltyShootoutTemplate: () => penaltyShootoutTemplate,
+  shootoutEconomy: () => shootoutEconomy,
+  starPack: () => starPack,
+  stars: () => stars,
+  tokens: () => tokens
+});
+
+// src/game/samples/penalty-kick.ts
+var PITCH = {
+  ballRadius: 0.11,
+  ballDensity: 77,
+  spotZ: 0,
+  goalLineZ: -11,
+  goalHalfWidth: 3.66,
+  goalHeight: 2.44,
+  postHalfThickness: 0.06,
+  netDepth: 1.6,
+  keeperHalfWidth: 0.35,
+  keeperHalfHeight: 0.95,
+  keeperHalfDepth: 0.2,
+  keeperDiveSpeed: 4.2,
+  keeperReactionSeconds: 0.18,
+  groundHalfExtent: 40
+}, SHOT = {
+  swipeSpeedToMetres: 14,
+  minSpeed: 8,
+  maxSpeed: 32,
+  lateralGain: 1.1,
+  loftPerSpeed: 0.22,
+  maxLoft: 7,
+  curlSpin: 28,
+  magnus: 45e-4,
+  settleSeconds: 3.5,
+  resetSeconds: 1.2
+}, BALL_ANGULAR_DAMPING = 0.4, KEEPER_LEFT = 0, KEEPER_RIGHT = 2, MS_PER_SECOND = 1e3, KEY_SHOT_SWIPE = -0.35, KEY_SHOT_DURATION_MS = 180, PITCH_COLOR = 3116870, BALL_COLOR = 16119285, POST_COLOR = 16777215, KEEPER_COLOR = 16756736, CAMERA_HEIGHT = 1.6, CAMERA_BACK = 4.5, CAMERA_FOV = 55, SUN_INTENSITY = 2.2, AMBIENT_INTENSITY = 0.6, SUN_PITCH = -0.9, PenaltyKick = class {
+  constructor(options = {}) {
+    this.name = "penalty-kick";
+    this.state = "ready";
+    this.goals = 0;
+    this.shots = 0;
+    this.ball = NO_ENTITY;
+    this.keeper = NO_ENTITY;
+    this.camera = NO_ENTITY;
+    this.goalSensor = NO_ENTITY;
+    this.kick = null;
+    this.stateSeconds = 0;
+    this.keeperTarget = 0;
+    this.keeperDelay = 0;
+    this.goalsSlot = null;
+    this.shotsSlot = null;
+    this.keeperController = -1;
+    this.keeperCollider = -1;
+    this.velocity = new Vec3();
+    this.spin = new Vec3();
+    this.force = new Vec3();
+    this.position = new Vec3();
+    this.desired = new Vec3();
+    this.orientation = new Quat();
+    this.move = new CharacterMove();
+    this.keeperAt = new Vec3();
+    this.lastBall = new Vec3();
+    this.contactEvents = options.contactEvents ?? true;
+  }
+  enter(game) {
+    let gfx = game.graphics, solid = (color) => gfx.createMaterial({ kind: "standard", color, roughness: 0.8 }), box = gfx.createGeometry(boxGeometry(1, 1, 1)), sphere = gfx.createGeometry(sphereGeometry(PITCH.ballRadius)), ground = this.block(game, 0, -0.5, 0, PITCH.groundHalfExtent, 0.5, PITCH.groundHalfExtent);
+    gfx.mesh(ground, box, solid((3116870))), game.transforms.setScale(ground, PITCH.groundHalfExtent * 2, 1, PITCH.groundHalfExtent * 2);
+    let postMaterial = solid((16777215)), t = PITCH.postHalfThickness, h = PITCH.goalHeight / 2;
+    for (let side of [-1, 1]) {
+      let post = this.block(game, side * (PITCH.goalHalfWidth + t), h, PITCH.goalLineZ, t, h, t);
+      gfx.mesh(post, box, postMaterial), game.transforms.setScale(post, t * 2, PITCH.goalHeight, t * 2);
+    }
+    let bar = this.block(game, 0, PITCH.goalHeight + t, PITCH.goalLineZ, PITCH.goalHalfWidth + 2 * t, t, t);
+    gfx.mesh(bar, box, postMaterial), game.transforms.setScale(bar, (PITCH.goalHalfWidth + 2 * t) * 2, t * 2, t * 2), this.block(game, 0, h, PITCH.goalLineZ - PITCH.netDepth, PITCH.goalHalfWidth + 1, h + 1, t), this.contactEvents && (this.goalSensor = game.world.spawn(), game.transforms.add(this.goalSensor, 0, h, PITCH.goalLineZ - PITCH.netDepth / 2 - PITCH.ballRadius), game.physics.addCollider(this.goalSensor, {
+      shape: { kind: "cuboid", halfExtents: [PITCH.goalHalfWidth, h, PITCH.netDepth / 2 - t] },
+      sensor: true
+    })), this.keeper = game.world.spawn(), game.transforms.add(this.keeper, 0, PITCH.keeperHalfHeight, PITCH.goalLineZ + 0.5), game.physics.addBody(this.keeper, { kind: "kinematic" }), this.keeperCollider = game.physics.addCollider(this.keeper, {
+      shape: { kind: "cuboid", halfExtents: [PITCH.keeperHalfWidth, PITCH.keeperHalfHeight, PITCH.keeperHalfDepth] },
+      events: this.contactEvents
+    }), this.keeperController = game.physics.createCharacterController({ offset: 0.01, snapToGround: 0.1 }), gfx.mesh(this.keeper, box, solid((16756736))), game.transforms.setScale(this.keeper, PITCH.keeperHalfWidth * 2, PITCH.keeperHalfHeight * 2, PITCH.keeperHalfDepth * 2), this.ball = game.world.spawn(), game.transforms.add(this.ball, 0, PITCH.ballRadius, PITCH.spotZ), game.physics.addBody(this.ball, { kind: "dynamic", ccd: true, linearDamping: 0.05, angularDamping: (0.4) }), game.physics.addCollider(this.ball, {
+      shape: { kind: "ball", radius: PITCH.ballRadius },
+      density: PITCH.ballDensity,
+      restitution: 0.55,
+      friction: 0.7,
+      events: this.contactEvents
+    }), gfx.mesh(this.ball, sphere, solid((16119285))), this.camera = game.world.spawn(), game.transforms.add(this.camera, 0, (1.6), PITCH.spotZ + (4.5)), gfx.camera(this.camera, (55)), game.audio.setListener(this.camera);
+    let sun = game.world.spawn();
+    game.transforms.add(sun, 4, 10, 6), game.transforms.setRotationQuat(sun, this.orientation.setEuler((-0.9), 0.4, 0)), gfx.create(sun, { kind: "light", light: "directional", intensity: (2.2), castShadow: true });
+    let sky = game.world.spawn();
+    game.transforms.add(sky), gfx.create(sky, { kind: "light", light: "hemisphere", intensity: (0.6), groundColor: (3116870) }), this.kick = game.input.defineButton("kick", [{ device: "key", code: "Space" }]), this.goalsSlot = game.ui.hudNumber("goals"), this.shotsSlot = game.ui.hudNumber("shots"), game.ui.defineAction("restart");
+  }
+  fixedUpdate(game) {
+    switch (this.stateSeconds += game.time.values[FRAME_STEP_SECONDS_SLOT], this.state) {
+      case "ready": {
+        let swipe = game.input.swipe;
+        swipe.ready ? this.shoot(game, swipe.deltaX, swipe.deltaY, swipe.durationMs, swipe.curl) : this.kick !== null && game.input.justPressed(this.kick) && this.shoot(game, 0, (-0.35), (180), 0);
+        break;
+      }
+      case "flight":
+        this.applyMagnus(game), this.driveKeeper(game), this.judge(game);
+        break;
+      default:
+        this.stateSeconds >= SHOT.resetSeconds && this.reset(game);
+        break;
+    }
+  }
+  shoot(game, deltaX, deltaY, durationMs, curl) {
+    if (deltaY >= 0) return;
+    let seconds = Math.max(durationMs, 1) / (1e3), swipeSpeed = Math.hypot(deltaX, deltaY) / seconds, speed = clamp(swipeSpeed * SHOT.swipeSpeedToMetres, SHOT.minSpeed, SHOT.maxSpeed), lateral = deltaX / -deltaY * SHOT.lateralGain, loft = Math.min(speed * SHOT.loftPerSpeed, SHOT.maxLoft);
+    game.physics.setLinearVelocity(this.ball, this.velocity.set(lateral * speed, loft, -speed)), game.physics.setAngularVelocity(this.ball, this.spin.set(0, -curl * SHOT.curlSpin, 0)), game.transforms.position(this.ball, this.lastBall), this.keeperTarget = (game.random.int((0), (2)) - 1) * (PITCH.goalHalfWidth - PITCH.keeperHalfWidth), this.keeperDelay = PITCH.keeperReactionSeconds, this.shots++, this.shotsSlot !== null && game.ui.setNumber(this.shotsSlot, this.shots), this.enterState("flight");
+  }
+  applyMagnus(game) {
+    let dt = game.time.values[FRAME_STEP_SECONDS_SLOT];
+    game.transforms.position(this.ball, this.position), this.velocity.copy(this.position).sub(this.lastBall).scale(1 / dt), this.lastBall.copy(this.position), this.spin.scale(1 - (0.4) * dt), this.force.cross(this.spin, this.velocity).scale(SHOT.magnus * dt), game.physics.applyImpulse(this.ball, this.force);
+  }
+  driveKeeper(game) {
+    let dt = game.time.values[FRAME_STEP_SECONDS_SLOT];
+    if (this.keeperDelay > 0) {
+      this.keeperDelay -= dt;
+      return;
+    }
+    game.transforms.position(this.keeper, this.position);
+    let reach = PITCH.keeperDiveSpeed * dt;
+    this.desired.set(clamp(this.keeperTarget - this.position.x, -reach, reach), 0, 0), game.physics.moveCharacter(this.keeperController, this.keeperCollider, this.desired, this.move);
+  }
+  judge(game) {
+    this.contactEvents ? this.judgeContacts(game) : this.judgeGeometry(game), this.state === "flight" && (game.transforms.position(this.ball, this.position), (this.stateSeconds >= SHOT.settleSeconds || this.position.z < PITCH.goalLineZ - PITCH.netDepth * 2) && this.enterState("missed"));
+  }
+  judgeContacts(game) {
+    let physics = game.physics;
+    for (let i = 0; i < physics.contactCount(); i++) {
+      if (!physics.contactStarted(i)) continue;
+      let a = physics.contactEntityA(i), b = physics.contactEntityB(i);
+      if (a === this.ball || b === this.ball) {
+        if (a === this.goalSensor || b === this.goalSensor) {
+          this.scoreGoal(game);
+          return;
+        }
+        if (a === this.keeper || b === this.keeper) {
+          this.saveShot(game);
+          return;
+        }
+      }
+    }
+  }
+  judgeGeometry(game) {
+    let ball = game.transforms.position(this.ball, this.position), keeper = game.transforms.position(this.keeper, this.keeperAt), r = PITCH.ballRadius;
+    if (Math.abs(ball.x - keeper.x) < PITCH.keeperHalfWidth + r && Math.abs(ball.y - keeper.y) < PITCH.keeperHalfHeight + r && Math.abs(ball.z - keeper.z) < PITCH.keeperHalfDepth + r) {
+      this.saveShot(game);
+      return;
+    }
+    ball.z < PITCH.goalLineZ - r && Math.abs(ball.x) < PITCH.goalHalfWidth && ball.y < PITCH.goalHeight && this.scoreGoal(game);
+  }
+  scoreGoal(game) {
+    this.goals++, this.goalsSlot !== null && game.ui.setNumber(this.goalsSlot, this.goals), game.ui.haptic("success"), this.enterState("goal");
+  }
+  saveShot(game) {
+    game.ui.haptic("heavy"), this.enterState("saved");
+  }
+  reset(game) {
+    game.physics.teleport(this.ball, this.desired.set(0, PITCH.ballRadius, PITCH.spotZ)), game.transforms.position(this.keeper, this.position), game.physics.moveCharacter(this.keeperController, this.keeperCollider, this.desired.set(-this.position.x, 0, 0), this.move), this.enterState("ready");
+  }
+  enterState(state) {
+    this.state = state, this.stateSeconds = 0;
+  }
+  block(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] }, friction: 0.8, restitution: 0.3 }), entity;
+  }
+};
+function clamp(value, min, max) {
+  return value < min ? min : value > max ? max : value;
+}
+
+// src/game/kit/templates/shootout.ts
+var SHOOTOUT = {
+  kicksPerSeries: 5,
+  seriesPauseSeconds: 1.5,
+  goalTrauma: 0.45,
+  saveTrauma: 0.3,
+  goalStopSeconds: 0.09,
+  goalFlashSeconds: 0.25,
+  goalFlash: 16777215
+}, tokens = softCurrency("tokens", "Tokens"), stars = premiumCurrency("stars", "Stars"), classicBall = softItem("classic-ball", "Classic ball", { stackable: false }), goldBoots = premiumItem("gold-boots", "Gold boots", { stackable: false }), kente = premiumItem("kente-kit", "Kente kit", { stackable: false }), nightPitch = premiumItem("night-pitch", "Night pitch", { stackable: false }), goalTokens = faucet("goal-tokens", tokens, 50), buyClassicBall = softExchange("buy-classic-ball", [grant(tokens, 200)], [grant(classicBall, 1)]), kitDraw = randomExchange(
+  "kit-draw",
+  "Kit draw",
+  grant(stars, 30),
+  discloseOdds([
+    { value: kente, quantity: 1, partsPerMillion: 6e5 },
+    { value: nightPitch, quantity: 1, partsPerMillion: 3e5 },
+    { value: goldBoots, quantity: 1, partsPerMillion: 1e5 }
+  ])
+), starPack = fixedOffer("star-pack", "Star pack", 25, [grant(stars, 60)]), goldBootsOffer = fixedOffer("gold-boots-offer", "Gold boots", 40, [grant(goldBoots, 1)]), shootoutEconomy = {
+  currencies: [tokens, stars],
+  items: [classicBall, goldBoots, kente, nightPitch],
+  faucets: [goalTokens],
+  exchanges: [buyClassicBall],
+  offers: [starPack, goldBootsOffer],
+  randomExchanges: [kitDraw]
+}, AXES = 3, PenaltyShootout = class {
+  constructor(results = null, rules = SHOOTOUT) {
+    this.rules = rules;
+    this.name = "penalty-shootout";
+    this.kick = new PenaltyKick({ contactEvents: false });
+    this.shake = new ScreenShake({ maxOffset: 0.18, maxRoll: 0.03 });
+    this.hitStop = new HitStop();
+    this.flash = new ScreenFlash();
+    this.phase = "playing";
+    this.series = 0;
+    this.seriesGoals = 0;
+    this.seriesKicks = 0;
+    this.totalGoals = 0;
+    this.bestSeries = 0;
+    this.cameraBase = new Float64Array((3));
+    this.cameraPose = new Float64Array((3));
+    this.previous = "ready";
+    this.pauseSeconds = 0;
+    this.kicksSlot = null;
+    this.bestSlot = null;
+    this.results = results;
+  }
+  get camera() {
+    return this.kick.camera;
+  }
+  enter(game) {
+    this.kick.enter(game);
+    let p = game.transforms.store.fields.position, row = game.transforms.row(this.kick.camera) * (3);
+    for (let i = 0; i < (3); i++) this.cameraBase[i] = p[row + i];
+    this.kicksSlot = game.ui.hudNumber("kicks left", this.rules.kicksPerSeries), this.bestSlot = game.ui.hudNumber("best series");
+  }
+  fixedUpdate(game) {
+    if (this.phase === "finished") {
+      this.pauseSeconds -= game.loop.time.values[FRAME_STEP_SECONDS_SLOT], this.pauseSeconds <= 0 && this.startSeries(game);
+      return;
+    }
+    this.kick.fixedUpdate(game);
+    let state = this.kick.state;
+    if (state === this.previous) return;
+    let was = this.previous;
+    this.previous = state, was === "flight" && (this.seriesKicks++, state === "goal" ? (this.seriesGoals++, this.totalGoals++, this.shake.add(SHOOTOUT.goalTrauma), this.hitStop.trigger(SHOOTOUT.goalStopSeconds), this.flash.trigger(this.rules.goalFlash, SHOOTOUT.goalFlashSeconds)) : state === "saved" && this.shake.add(SHOOTOUT.saveTrauma), this.kicksSlot !== null && game.ui.setNumber(this.kicksSlot, this.rules.kicksPerSeries - this.seriesKicks), this.seriesKicks >= this.rules.kicksPerSeries && this.finishSeries(game));
+  }
+  update(game) {
+    let time = game.time;
+    this.hitStop.drive(game.loop), this.shake.update(time), this.flash.update(time);
+    let o = this.shake.offset, pose = this.cameraPose;
+    for (let i = 0; i < (3); i++) pose[i] = this.cameraBase[i] + o[i];
+    writePosition(game.transforms, this.kick.camera, pose, 0);
+  }
+  finishSeries(game) {
+    this.phase = "finished", this.pauseSeconds = this.rules.seriesPauseSeconds, this.series++, this.seriesGoals > this.bestSeries && (this.bestSeries = this.seriesGoals), this.bestSlot !== null && game.ui.setNumber(this.bestSlot, this.bestSeries), game.ui.haptic(this.seriesGoals >= this.rules.kicksPerSeries ? "success" : "medium"), this.results?.seriesEnded(this.seriesGoals, this.seriesKicks);
+  }
+  startSeries(game) {
+    this.phase = "playing", this.seriesGoals = 0, this.seriesKicks = 0, this.kicksSlot !== null && game.ui.setNumber(this.kicksSlot, this.rules.kicksPerSeries);
+  }
+}, AIMS_X = new Float64Array([0.62, 0.38, 0.6, 0.4, 0.55]), AIM_Y = 0.44, START_X = 0.5, START_Y = 0.85, SWIPE_FRAMES = 9, SETTLE_FRAMES = 20, POINTER = 1, ShootoutBot = class {
+  constructor() {
+    this.phase = 0;
+    this.wait = 0;
+    this.aim = 0;
+  }
+  drive(scene, game, frame) {
+    let input = game.input, t = templateFrameStamp(frame);
+    if (this.phase === 0) {
+      if (scene.phase !== "playing" || scene.kick.state !== "ready") {
+        this.wait = 0;
+        return;
+      }
+      if (++this.wait < (20)) return;
+      input.pointerEvent("down", (1), (0.5), (0.85), t), this.phase = 1, this.wait = 0;
+      return;
+    }
+    if (++this.wait < (9)) {
+      let k = this.wait / (9);
+      input.pointerEvent("move", (1), (0.5) + (AIMS_X[this.aim] - (0.5)) * k, (0.85) + ((0.44) - (0.85)) * k, t);
+      return;
+    }
+    input.pointerEvent("up", (1), AIMS_X[this.aim], (0.44), t), this.aim = (this.aim + 1) % AIMS_X.length, this.phase = 0, this.wait = 0;
+  }
+}, DIGEST_FIELDS = 5, digestScratch = new Int32Array((5)), penaltyShootoutTemplate = {
+  id: "penalty-shootout",
+  title: "Penalty shootout",
+  sources: ["src/game/kit/templates/shootout.ts", "src/game/samples/penalty-kick.ts"],
+  economy: shootoutEconomy,
+  scene: () => new PenaltyShootout(),
+  bot: () => new ShootoutBot(),
+  progress: (scene) => scene.totalGoals,
+  digest(scene) {
+    let d = digestScratch;
+    return d[0] = scene.totalGoals, d[1] = scene.kick.shots, d[2] = scene.series, d[3] = scene.seriesKicks, d[4] = scene.bestSeries, digestInts(d, (5));
+  }
+};
+
+export { PenaltyShootout, SHOOTOUT, buyClassicBall, classicBall, goalTokens, goldBoots, goldBootsOffer, kente, kitDraw, nightPitch, penaltyShootoutTemplate, shootoutEconomy, shootout_exports, starPack, stars, tokens };

package/dist/chunk-K46SMZ66.mjs

@@ -0,0 +1,103 @@
+// src/interactives/runtime/network.ts
+var PREFETCH_DEPTH = {
+  open: { horizons: 3, prefetch: true, feed: "full", feed_bytes: 33554432, feed_concurrency: 2 },
+  cellular: { horizons: 3, prefetch: true, feed: "lead", feed_bytes: 8388608, feed_concurrency: 1 },
+  metered: { horizons: 2, prefetch: true, feed: "lead", feed_bytes: 2097152, feed_concurrency: 1 },
+  saver: { horizons: 1, prefetch: false, feed: "none", feed_bytes: 0, feed_concurrency: 0 }
+};
+function prefetchDepth(hint) {
+  return hint === null ? PREFETCH_DEPTH.open : hint.saver ? PREFETCH_DEPTH.saver : hint.metered ? PREFETCH_DEPTH.metered : hint.kind === "cellular" ? PREFETCH_DEPTH.cellular : PREFETCH_DEPTH.open;
+}
+var KIND_CODES = ["unknown", "wifi", "ethernet", "cellular"], METERED_FLAG = 1, SAVER_FLAG = 2, KIND_OFFSET = 1, FLAGS_OFFSET = 2, DOWNLINK_OFFSET = 3, NETWORK_MESSAGE_BYTES = 7;
+function writeNetworkHint(out, tag, hint) {
+  return out[0] = tag, out[(1)] = Math.max(0, KIND_CODES.indexOf(hint.kind)), out[(2)] = (hint.metered ? (1) : 0) | (hint.saver ? (2) : 0), new DataView(out.buffer, out.byteOffset, (7)).setUint32((3), Math.max(0, Math.round(hint.downlink_kbps ?? 0)) >>> 0, true), (7);
+}
+function readNetworkHint(bytes) {
+  if (bytes.length < (7)) return null;
+  let downlink = new DataView(bytes.buffer, bytes.byteOffset, (7)).getUint32((3), true), flags = bytes[(2)], hint = {
+    kind: KIND_CODES[bytes[(1)]] ?? "unknown",
+    metered: (flags & (1)) !== 0,
+    saver: (flags & (2)) !== 0
+  };
+  return downlink > 0 ? { ...hint, downlink_kbps: downlink } : hint;
+}
+var SLOW_EFFECTIVE_TYPES = /* @__PURE__ */ new Set(["slow-2g", "2g"]), KBPS_PER_MBPS = 1e3;
+function webConnection() {
+  return globalThis.navigator?.connection ?? null;
+}
+function networkHintFrom(connection) {
+  if (connection === null) return null;
+  let type = connection.type, kind = type === "wifi" || type === "ethernet" || type === "cellular" ? type : "unknown", slow = connection.effectiveType !== void 0 && SLOW_EFFECTIVE_TYPES.has(connection.effectiveType), saver = connection.saveData === true || slow, downlink = connection.downlink, hint = { kind, metered: kind === "cellular", saver };
+  return downlink !== void 0 && downlink > 0 ? { ...hint, downlink_kbps: Math.round(downlink * (1e3)) } : hint;
+}
+function webNetworkHint() {
+  return networkHintFrom(webConnection());
+}
+function watchWebNetwork(listener) {
+  let connection = webConnection();
+  if (connection === null || typeof connection.addEventListener != "function") return () => {
+  };
+  let changed = () => {
+    let hint = networkHintFrom(connection);
+    hint !== null && listener(hint);
+  };
+  return connection.addEventListener("change", changed), () => connection.removeEventListener?.("change", changed);
+}
+
+// src/game/hot.ts
+var NO_ASSETS = [], HotReloader = class {
+  constructor(scenes) {
+    this.scenes = scenes;
+    this.current = null;
+  }
+  get loaded() {
+    return this.current !== null;
+  }
+  load(next, assets = NO_ASSETS) {
+    let previous = this.current, kept = previous?.keep?.(), replaced = [], added = [], names = /* @__PURE__ */ new Set();
+    for (let scene of next.scenes ?? [])
+      names.add(scene.name), this.scenes.replace(scene) ? replaced.push(scene.name) : added.push(scene.name);
+    let dropped = (previous?.scenes ?? []).map((scene) => scene.name).filter((name) => !names.has(name)), before = previous?.systems ?? [], after = next.systems ?? [];
+    for (let i = 0; i < after.length; i++)
+      i < before.length && this.scenes.replaceSystem(before[i], after[i]) || this.scenes.addSystem(after[i]);
+    for (let i = after.length; i < before.length; i++) this.scenes.removeSystem(before[i]);
+    let restored = previous !== null && kept !== void 0 && next.restore !== void 0;
+    return restored && next.restore?.(kept), assets.length > 0 && next.assets?.(assets), this.current = next, { replaced, added, dropped, systems: after.length, kept: restored, assets };
+  }
+}, HOT_EXPORT = "hot", HOT_SLOT_KEY = "__cimplify_hot", sealedSlot = null;
+function slot() {
+  let scope = globalThis, existing = scope[HOT_SLOT_KEY] ?? sealedSlot;
+  if (existing != null) return existing;
+  let fresh = { reloader: null, reusing: false };
+  return Object.isExtensible(scope) ? scope[HOT_SLOT_KEY] = fresh : sealedSlot = fresh, fresh;
+}
+function acceptHot(scenes, module) {
+  let reloader = new HotReloader(scenes);
+  return slot().reloader = reloader, reloader.load(module);
+}
+function hotAccepted() {
+  return slot().reloader !== null;
+}
+function hotModuleOf(exports) {
+  if (typeof exports != "object" || exports === null) return null;
+  let hot = exports[HOT_EXPORT];
+  return typeof hot == "object" && hot !== null ? hot : null;
+}
+function applyHot(exports, assets = NO_ASSETS) {
+  let reloader = slot().reloader, module = hotModuleOf(exports);
+  return reloader === null || module === null ? null : reloader.load(module, assets);
+}
+function reusingDefinitions() {
+  return slot().reusing;
+}
+async function relinkingDefinitions(run) {
+  let held = slot();
+  held.reusing = true;
+  try {
+    return await run();
+  } finally {
+    held.reusing = false;
+  }
+}
+
+export { HOT_EXPORT, HotReloader, NETWORK_MESSAGE_BYTES, PREFETCH_DEPTH, acceptHot, applyHot, hotAccepted, prefetchDepth, readNetworkHint, relinkingDefinitions, reusingDefinitions, watchWebNetwork, webNetworkHint, writeNetworkHint };

package/dist/chunk-K4UDGE3Z.mjs

@@ -0,0 +1,6 @@
+// src/game/constants.ts
+var GAME_API_VERSION = "0.1.0";
+var NO_RESOURCE = 0;
+var ALL_LAYERS = 4294967295;
+
+export { ALL_LAYERS, GAME_API_VERSION, NO_RESOURCE };