@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-A7BU3BK4.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var chunkVVE3Y76O_js = require('./chunk-VVE3Y76O.js');
+
+// src/interactives/meters/delivery.ts
+var MS_PER_SECOND = 1e3;
+function openSeconds(bytes, requests, link) {
+  return bytes <= 0 || requests <= 0 ? 0 : Math.ceil(requests / Math.max(1, link.concurrency)) * link.latencyMs / (1e3) + bytes / link.bytesPerSecond;
+}
+function openVerdict(seconds) {
+  return seconds < chunkVVE3Y76O_js.INSTANT_OPEN_SECONDS ? "instant" : seconds <= chunkVVE3Y76O_js.SLOW_OPEN_SECONDS ? "quick" : "slow";
+}
+function forTier(part, tier) {
+  return part.tier === null || part.tier === tier;
+}
+function deliveryMeter(parts, tier, link = chunkVVE3Y76O_js.THREE_G_LINK) {
+  let firstPlay = 0, download = 0, requests = 0, firstPlayParts = [];
+  for (let part of parts)
+    forTier(part, tier) && (download += part.bytes, part.beforePlay && (firstPlay += part.bytes, requests++, firstPlayParts.push({ label: part.label, cost: part.bytes })));
+  let seconds = openSeconds(firstPlay, requests, link), budget = chunkVVE3Y76O_js.DELIVERY_BUDGETS[tier];
+  return {
+    tier,
+    firstPlayBytes: firstPlay,
+    downloadBytes: download,
+    firstPlayRequests: requests,
+    openSeconds: seconds,
+    open: openVerdict(seconds),
+    fitsDownload: download <= budget.downloadBytes,
+    fitsFirstPlay: firstPlay <= budget.firstPlayBytes,
+    causes: chunkVVE3Y76O_js.rankCauses(firstPlayParts)
+  };
+}
+
+// src/interactives/meters/outcome.ts
+var CHEAPER_PHONES = "low";
+function outcomeMeters(parts, live, calibrations = [], tier = CHEAPER_PHONES) {
+  let delivery = deliveryMeter(parts, tier, chunkVVE3Y76O_js.THREE_G_LINK), calibration = chunkVVE3Y76O_js.calibrationFor(calibrations, tier), seconds = chunkVVE3Y76O_js.isCalibrated(calibration) ? delivery.openSeconds * calibration.openScale : delivery.openSeconds, measuring = live !== null && live.tier === tier;
+  return {
+    opensOn3g: { seconds, open: openVerdict(seconds), calibrated: chunkVVE3Y76O_js.isCalibrated(calibration) },
+    firstLoadBytes: delivery.firstPlayBytes,
+    delivery,
+    cheaperPhones: measuring ? live.frames : null,
+    memory: measuring ? live.memory : null,
+    heat: measuring ? live.heat : null
+  };
+}
+
+exports.CHEAPER_PHONES = CHEAPER_PHONES;
+exports.deliveryMeter = deliveryMeter;
+exports.openSeconds = openSeconds;
+exports.openVerdict = openVerdict;
+exports.outcomeMeters = outcomeMeters;

package/dist/chunk-A7MQSN2V.mjs

@@ -0,0 +1,77 @@
+import { KitError } from './chunk-4DYKAYFO.mjs';
+import { FRAME_SECONDS_SLOT } from './chunk-IDLW4NWA.mjs';
+
+// 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 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[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[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)];
+  }
+};
+
+export { ScreenFlash, Springs };

package/dist/chunk-A7V4L2IT.mjs

@@ -0,0 +1,416 @@
+import { KitError } from './chunk-4DYKAYFO.mjs';
+import { addSceneCamera, BoxBatch, BOX_X, BOX_Y, BOX_Z, BOX_SX, BOX_SY, BOX_SZ } from './chunk-QDYFLATW.mjs';
+import { templateFrameStamp, digestInts } from './chunk-KGHJH5KJ.mjs';
+import { SeededRandom } from './chunk-22BD3RHN.mjs';
+import { FRAME_STEP_SECONDS_SLOT } from './chunk-IDLW4NWA.mjs';
+import { __export } from './chunk-25T4JHEA.mjs';
+
+// src/game/kit/turns/turn-engine.ts
+var NO_WINNER = -1, TURN_PASS_ACTION = -2147483648, TurnGame = class {
+  constructor(rules, room, status = null, copy = null) {
+    this.turnValue = 0;
+    this.listeners = [];
+    this.unsubscribes = [];
+    this.resyncing = null;
+    this.onMove = (turn, seat, move) => this.receive(turn, seat, move);
+    this.onReset = (seed) => {
+      this.rules.reset(this.state, seed), this.turnValue = 0, this.changed();
+    };
+    this.onRejected = () => {
+      this.resync();
+    };
+    if (room.seats < rules.minSeats || room.seats > rules.maxSeats)
+      throw new KitError("invalid_declaration", `this game seats ${rules.minSeats} to ${rules.maxSeats} players`);
+    this.rules = rules, this.room = room, this.status = status, this.copy = copy, this.state = rules.create(room.seats, room.seed);
+  }
+  get turn() {
+    return this.turnValue;
+  }
+  get activeSeat() {
+    return this.rules.activeSeat(this.state);
+  }
+  get winner() {
+    return this.rules.winner(this.state);
+  }
+  get myTurn() {
+    return this.isTurnOf(this.room.seat);
+  }
+  isTurnOf(seat) {
+    return this.rules.winner(this.state) === (-1) && this.rules.activeSeat(this.state) === seat;
+  }
+  onChange(listener) {
+    return this.listeners.push(listener), () => {
+      let i = this.listeners.indexOf(listener);
+      i >= 0 && this.listeners.splice(i, 1);
+    };
+  }
+  attach() {
+    this.unsubscribes.length > 0 || this.unsubscribes.push(this.room.onMove(this.onMove), this.room.onReset(this.onReset));
+  }
+  start() {
+    return this.attach(), this.resync();
+  }
+  play(move) {
+    if (!this.myTurn || !this.rules.legal(this.state, this.room.seat, move)) return false;
+    let pending = this.room.submit(this.turnValue, move);
+    return pending !== void 0 && pending.then(void 0, this.onRejected), true;
+  }
+  stop() {
+    for (let i = 0; i < this.unsubscribes.length; i++) this.unsubscribes[i]();
+    this.unsubscribes.length = 0;
+  }
+  receive(turn, seat, move) {
+    if (!(turn < this.turnValue)) {
+      if (turn > this.turnValue || !this.step(seat, move)) {
+        this.resync();
+        return;
+      }
+      this.changed();
+    }
+  }
+  step(seat, move) {
+    let rules = this.rules, state = this.state;
+    if (rules.winner(state) !== (-1) || seat !== rules.activeSeat(state)) return false;
+    if (move === (-2147483648))
+      rules.pass !== void 0 ? rules.pass(state, seat) : rules.apply(state, seat, move);
+    else {
+      if (!rules.legal(state, seat, move)) return false;
+      rules.apply(state, seat, move);
+    }
+    return this.turnValue++, true;
+  }
+  resync() {
+    return this.resyncing !== null ? this.resyncing : (this.resyncing = this.room.history().then((history) => {
+      this.rules.reset(this.state, history.seed), this.turnValue = 0;
+      for (let i = 0; i < history.count && this.step(history.seats[i], history.moves[i]); i++) ;
+      this.changed();
+    }).finally(() => {
+      this.resyncing = null;
+    }), this.resyncing);
+  }
+  changed() {
+    let status = this.status, copy = this.copy;
+    if (status !== null && copy !== null) {
+      let winner = this.winner;
+      winner === this.room.seat ? status.waiting(copy.won) : winner !== (-1) ? status.waiting(copy.finished) : this.myTurn ? status.turn(copy.yourTurn) : status.waiting(copy.waiting);
+    }
+    for (let i = 0; i < this.listeners.length; i++) this.listeners[i]();
+  }
+}, DEFAULT_TURN_LOG_CAPACITY = 4096, TurnLog = class {
+  constructor(seed, capacity) {
+    this.count = 0;
+    this.moveListeners = [];
+    this.resetListeners = [];
+    this.seed = seed, this.seats = new Int32Array(capacity), this.moves = new Int32Array(capacity);
+  }
+  append(seat, move) {
+    if (this.count === this.seats.length) {
+      let seats = new Int32Array(this.count * 2), moves = new Int32Array(this.count * 2);
+      seats.set(this.seats), moves.set(this.moves), this.seats = seats, this.moves = moves;
+    }
+    this.seats[this.count] = seat, this.moves[this.count] = move, this.count++;
+  }
+};
+function remove(list, item) {
+  let i = list.indexOf(item);
+  i >= 0 && list.splice(i, 1);
+}
+var LocalTurnRoom = class _LocalTurnRoom {
+  constructor(seat, seats, log) {
+    this.seat = seat, this.seats = seats, this.log = log;
+  }
+  static table(seats, seed, capacity = (4096)) {
+    let log = new TurnLog(seed, capacity), out = [];
+    for (let i = 0; i < seats; i++) out.push(new _LocalTurnRoom(i, seats, log));
+    return out;
+  }
+  get seed() {
+    return this.log.seed;
+  }
+  get turns() {
+    return this.log.count;
+  }
+  submitAs(seat, turn, move) {
+    let log = this.log;
+    if (turn !== log.count || seat < 0 || seat >= this.seats) return false;
+    log.append(seat, move);
+    let listeners = log.moveListeners;
+    for (let i = 0; i < listeners.length; i++) listeners[i](turn, seat, move);
+    return true;
+  }
+  submit(turn, move) {
+    return this.submitAs(this.seat, turn, move) ? void 0 : Promise.reject(new KitError("illegal_move", `turn ${turn} is stale`));
+  }
+  reset(seed) {
+    let log = this.log;
+    log.seed = seed, log.count = 0;
+    for (let i = 0; i < log.resetListeners.length; i++) log.resetListeners[i](seed);
+  }
+  onMove(listener) {
+    return this.log.moveListeners.push(listener), () => remove(this.log.moveListeners, listener);
+  }
+  onReset(listener) {
+    return this.log.resetListeners.push(listener), () => remove(this.log.resetListeners, listener);
+  }
+  history() {
+    let log = this.log;
+    return Promise.resolve({ seed: log.seed, count: log.count, seats: log.seats.slice(0, log.count), moves: log.moves.slice(0, log.count) });
+  }
+};
+
+// src/game/kit/templates/ludo.ts
+var ludo_exports = {};
+__export(ludo_exports, {
+  IN_YARD: () => (-1),
+  LUDO: () => LUDO,
+  LudoMove: () => LudoMove,
+  LudoScene: () => LudoScene,
+  LudoState: () => LudoState,
+  anyMovable: () => anyMovable,
+  chooseLudoMove: () => chooseLudoMove,
+  ludoRules: () => ludoRules,
+  ludoTemplate: () => ludoTemplate,
+  squareOf: () => squareOf
+});
+var LUDO = {
+  colors: 4,
+  tokens: 4,
+  track: 52,
+  lastTrackStep: 50,
+  home: 56,
+  dieFaces: 6,
+  maxSixes: 3,
+  sideSquares: 13
+}, LudoMove = { Roll: 4, Pass: 5 }, IN_YARD = -1, NO_DICE = 0, SIX = 6, SAFE = new Uint8Array(LUDO.track);
+for (let s of [0, 8, 13, 21, 26, 34, 39, 47]) SAFE[s] = 1;
+var SEAT_COLORS = [[], [], [0, 2], [0, 1, 2], [0, 1, 2, 3]], LudoState = class {
+  constructor() {
+    this.seats = 0;
+    this.progress = new Int8Array(LUDO.colors * LUDO.tokens);
+    this.colors = new Int8Array(LUDO.colors);
+    this.home = new Int8Array(LUDO.colors);
+    this.random = new SeededRandom(0);
+    this.dice = (0);
+    this.active = 0;
+    this.sixes = 0;
+    this.winner = (-1);
+    this.lastCapture = 0;
+  }
+};
+function squareOf(state, seat, token) {
+  let p = state.progress[seat * LUDO.tokens + token];
+  return p < 0 || p > LUDO.lastTrackStep ? -1 : (state.colors[seat] * LUDO.sideSquares + p) % LUDO.track;
+}
+function movable(state, seat, token) {
+  let p = state.progress[seat * LUDO.tokens + token];
+  return p === (-1) ? state.dice === (6) : p < LUDO.home && p + state.dice <= LUDO.home;
+}
+function anyMovable(state, seat) {
+  for (let t = 0; t < LUDO.tokens; t++) if (movable(state, seat, t)) return true;
+  return false;
+}
+function capturesAt(state, seat, square) {
+  if (square < 0 || SAFE[square] === 1) return 0;
+  let captured = 0;
+  for (let other = 0; other < state.seats; other++)
+    if (other !== seat)
+      for (let t = 0; t < LUDO.tokens; t++)
+        squareOf(state, other, t) === square && (state.progress[other * LUDO.tokens + t] = (-1), captured++);
+  return captured;
+}
+function nextSeat(state) {
+  state.active = (state.active + 1) % state.seats;
+}
+var ludoRules = {
+  minSeats: 2,
+  maxSeats: 4,
+  create(seats, seed) {
+    let state = new LudoState();
+    state.seats = seats;
+    let colors = SEAT_COLORS[seats];
+    for (let i = 0; i < seats; i++) state.colors[i] = colors[i];
+    return this.reset(state, seed), state;
+  },
+  reset(state, seed) {
+    state.progress.fill((-1)), state.home.fill(0), state.random.reseed(seed), state.dice = (0), state.active = 0, state.sixes = 0, state.winner = (-1), state.lastCapture = 0;
+  },
+  activeSeat: (state) => state.active,
+  winner: (state) => state.winner,
+  legal(state, seat, move) {
+    return state.winner !== (-1) || seat !== state.active ? false : state.dice === (0) ? move === LudoMove.Roll : move === LudoMove.Pass ? !anyMovable(state, seat) : move >= 0 && move < LUDO.tokens && movable(state, seat, move);
+  },
+  apply(state, seat, move) {
+    if (move === LudoMove.Roll) {
+      state.dice = state.random.int(1, LUDO.dieFaces), state.dice === (6) && ++state.sixes === LUDO.maxSixes && (state.dice = (0), state.sixes = 0, nextSeat(state));
+      return;
+    }
+    let extra = false;
+    if (move !== LudoMove.Pass) {
+      let i = seat * LUDO.tokens + move, p = state.progress[i];
+      state.progress[i] = p === (-1) ? 0 : p + state.dice, state.lastCapture = capturesAt(state, seat, squareOf(state, seat, move)), extra = state.dice === (6) || state.lastCapture > 0, state.progress[i] === LUDO.home && (extra = true, ++state.home[seat] === LUDO.tokens && (state.winner = seat));
+    }
+    state.dice = (0), extra || (state.sixes = 0, nextSeat(state));
+  }
+};
+function chooseLudoMove(state, seat) {
+  if (state.dice === (0)) return LudoMove.Roll;
+  if (!anyMovable(state, seat)) return LudoMove.Pass;
+  let best = LudoMove.Pass, bestScore = -1;
+  for (let t = 0; t < LUDO.tokens; t++) {
+    if (!movable(state, seat, t)) continue;
+    let p = state.progress[seat * LUDO.tokens + t], to = p === (-1) ? 0 : p + state.dice, score = to;
+    if (to === LUDO.home && (score += 200), p === (-1) && (score += 120), to <= LUDO.lastTrackStep) {
+      let square = (state.colors[seat] * LUDO.sideSquares + to) % LUDO.track;
+      SAFE[square] === 1 ? score += 30 : threatened(state, seat, square) && (score += 150);
+    }
+    score > bestScore && (bestScore = score, best = t);
+  }
+  return best;
+}
+function threatened(state, seat, square) {
+  for (let other = 0; other < state.seats; other++)
+    if (other !== seat) {
+      for (let t = 0; t < LUDO.tokens; t++) if (squareOf(state, other, t) === square) return true;
+    }
+  return false;
+}
+var COLOR_RGB = [1096065, 16096779, 3900150, 15680580], SQUARE_RGB = 16317180, SAFE_RGB = 13358561, BOARD_RGB = 1976635, THINK_SECONDS = 0.18, HUMAN_PASS_SECONDS = 0.5, GAME_OVER_SECONDS = 2, TOKEN_HEIGHT = 0.7, TOKEN_SIZE = 0.45, SQUARE_SIZE = 0.92, HALF_TRACK = 7, YARD_OFFSET = 4.5, YARD_SPREAD = 0.8, CAMERA_HEIGHT = 18, CAMERA_FOV = 55, CAMERA_PITCH = -Math.PI / 2, TOKEN_KEYS = ["Digit1", "Digit2", "Digit3", "Digit4"], AXES = 2, SEED_MAX = 1073741823, LudoScene = class {
+  constructor(options = {}) {
+    this.name = "ludo";
+    this.gamesFinished = 0;
+    this.tokensHome = 0;
+    this.squares = new Float32Array(LUDO.track * (2));
+    this.lanes = new Float32Array(LUDO.colors * (LUDO.home - LUDO.lastTrackStep) * (2));
+    this.thinkSeconds = 0;
+    this.overSeconds = 0;
+    this.roll = null;
+    this.tokenActions = [];
+    this.diceSlot = null;
+    this.turnSlot = null;
+    this.homeSlot = null;
+    this.board = null;
+    this.pieces = null;
+    this.lastHome = 0;
+    this.rooms = LocalTurnRoom.table(options.seats ?? LUDO.colors, options.seed ?? 1), this.turns = new TurnGame(ludoRules, this.rooms[0], options.status ?? null, options.copy ?? null), this.turns.attach();
+  }
+  get state() {
+    return this.turns.state;
+  }
+  enter(game) {
+    addSceneCamera(game, 0, (18), 0, (55), CAMERA_PITCH), this.layout(), this.board = new BoxBatch(game, LUDO.track + this.lanes.length / (2) + 1), this.pieces = new BoxBatch(game, LUDO.colors * LUDO.tokens), this.drawBoard(), this.roll = game.input.defineButton("roll", [{ device: "key", code: "Space" }, { device: "virtual", control: "roll" }]);
+    for (let t = 0; t < LUDO.tokens; t++)
+      this.tokenActions.push(game.input.defineButton(`token${t + 1}`, [{ device: "key", code: TOKEN_KEYS[t] }, { device: "virtual", control: `token${t + 1}` }]));
+    this.diceSlot = game.ui.hudNumber("dice"), this.turnSlot = game.ui.hudNumber("turn"), this.homeSlot = game.ui.hudNumber("home");
+  }
+  fixedUpdate(game) {
+    let dt = game.loop.time.values[FRAME_STEP_SECONDS_SLOT], state = this.turns.state;
+    if (state.winner !== (-1)) {
+      this.overSeconds += dt, this.overSeconds >= (2) && (this.overSeconds = 0, this.gamesFinished++, this.rooms[0].reset(game.random.int(1, (1073741823))));
+      return;
+    }
+    let seat = state.active;
+    seat === this.rooms[0].seat ? this.human(game) : (this.thinkSeconds += dt, this.thinkSeconds >= (0.18) && (this.thinkSeconds = 0, this.rooms[seat].submitAs(seat, this.turns.turn, chooseLudoMove(state, seat)))), this.countHome(game);
+  }
+  update() {
+    this.drawPieces();
+  }
+  human(game) {
+    let dt = game.loop.time.values[FRAME_STEP_SECONDS_SLOT], state = this.turns.state, input = game.input;
+    if (state.dice === (0))
+      this.roll !== null && input.justPressed(this.roll) && this.turns.play(LudoMove.Roll);
+    else if (!anyMovable(state, state.active))
+      this.thinkSeconds += dt, this.thinkSeconds >= (0.5) && (this.thinkSeconds = 0, this.turns.play(LudoMove.Pass));
+    else
+      for (let t = 0; t < LUDO.tokens; t++) input.justPressed(this.tokenActions[t]) && this.turns.play(t);
+    this.diceSlot !== null && game.ui.setNumber(this.diceSlot, state.dice), this.turnSlot !== null && game.ui.setNumber(this.turnSlot, state.active);
+  }
+  countHome(game) {
+    let state = this.turns.state, home = 0;
+    for (let s = 0; s < state.seats; s++) home += state.home[s];
+    home > this.lastHome && (this.tokensHome += home - this.lastHome), this.lastHome = home, this.homeSlot !== null && game.ui.setNumber(this.homeSlot, state.home[this.rooms[0].seat]);
+  }
+  layout() {
+    let side = LUDO.sideSquares;
+    for (let s = 0; s < LUDO.track; s++) {
+      let edge = Math.floor(s / side), j = s % side, o = s * (2), along = j - (side - 1) / 2;
+      edge === 0 ? (this.squares[o] = along, this.squares[o + 1] = (7)) : edge === 1 ? (this.squares[o] = (7), this.squares[o + 1] = -along) : edge === 2 ? (this.squares[o] = -along, this.squares[o + 1] = -(7)) : (this.squares[o] = -(7), this.squares[o + 1] = along);
+    }
+    let lane = LUDO.home - LUDO.lastTrackStep;
+    for (let c = 0; c < LUDO.colors; c++) {
+      let start = c * side * (2), x = this.squares[start], z = this.squares[start + 1], length = Math.sqrt(x * x + z * z);
+      for (let h = 0; h < lane; h++) {
+        let o = (c * lane + h) * (2), k = 1 - (h + 1) / (lane + 1);
+        this.lanes[o] = x / length * (7) * k, this.lanes[o + 1] = z / length * (7) * k;
+      }
+    }
+  }
+  drawBoard() {
+    let board = this.board;
+    if (board === null) return;
+    let b = board.box;
+    board.begin(), b[BOX_X] = 0, b[BOX_Y] = -0.3, b[BOX_Z] = 0, b[BOX_SX] = (7) * 2 + 2, b[BOX_SY] = 0.2, b[BOX_SZ] = (7) * 2 + 2, board.add((1976635)), b[BOX_Y] = -0.1, b[BOX_SX] = (0.92), b[BOX_SY] = 0.1, b[BOX_SZ] = (0.92);
+    for (let s = 0; s < LUDO.track; s++)
+      b[BOX_X] = this.squares[s * (2)], b[BOX_Z] = this.squares[s * (2) + 1], board.add(SAFE[s] === 1 ? (13358561) : (16317180));
+    let lane = LUDO.home - LUDO.lastTrackStep;
+    for (let i = 0; i < this.lanes.length / (2); i++)
+      b[BOX_X] = this.lanes[i * (2)], b[BOX_Z] = this.lanes[i * (2) + 1], board.add(COLOR_RGB[Math.floor(i / lane)]);
+    board.end();
+  }
+  drawPieces() {
+    let pieces = this.pieces;
+    if (pieces === null) return;
+    let state = this.turns.state, b = pieces.box;
+    pieces.begin(), b[BOX_SX] = (0.45), b[BOX_SY] = (0.7), b[BOX_SZ] = (0.45), b[BOX_Y] = (0.7) / 2;
+    let lane = LUDO.home - LUDO.lastTrackStep;
+    for (let seat = 0; seat < state.seats; seat++) {
+      let color = state.colors[seat], cornerX = (color === 0 || color === 3 ? -1 : 1) * (4.5), cornerZ = (color < 2 ? 1 : -1) * (4.5);
+      for (let t = 0; t < LUDO.tokens; t++) {
+        let p = state.progress[seat * LUDO.tokens + t];
+        if (p === (-1))
+          b[BOX_X] = cornerX + ((t & 1) - 0.5) * (0.8) * 2, b[BOX_Z] = cornerZ + ((t >> 1) - 0.5) * (0.8) * 2;
+        else if (p <= LUDO.lastTrackStep) {
+          let square = squareOf(state, seat, t);
+          b[BOX_X] = this.squares[square * (2)], b[BOX_Z] = this.squares[square * (2) + 1];
+        } else {
+          let h = p - LUDO.lastTrackStep - 1, o = (color * lane + (h < lane ? h : lane - 1)) * (2);
+          b[BOX_X] = this.lanes[o], b[BOX_Z] = this.lanes[o + 1];
+        }
+        pieces.add(COLOR_RGB[color]);
+      }
+    }
+    pieces.end();
+  }
+}, BOT_HOLD_FRAMES = 3, LudoBot = class {
+  constructor() {
+    this.held = null;
+    this.frames = 0;
+  }
+  drive(scene, game, frame) {
+    let t = templateFrameStamp(frame);
+    if (this.held !== null) {
+      if (++this.frames < (3)) return;
+      game.input.keyEvent(this.held, false, t), this.held = null, this.frames = 0;
+      return;
+    }
+    if (++this.frames < (3)) return;
+    let state = scene.state, seat = scene.rooms[0].seat;
+    if (state.winner !== (-1) || state.active !== seat) return;
+    let move = chooseLudoMove(state, seat);
+    move !== LudoMove.Pass && (this.held = move === LudoMove.Roll ? "Space" : TOKEN_KEYS[move], this.frames = 0, game.input.keyEvent(this.held, true, t));
+  }
+}, DIGEST_FIELDS = LUDO.colors * LUDO.tokens + 4, digestScratch = new Int32Array(DIGEST_FIELDS), ludoTemplate = {
+  id: "ludo",
+  title: "Ludo",
+  sources: ["src/game/kit/templates/ludo.ts", "src/game/kit/turns/turn-engine.ts"],
+  economy: null,
+  scene: () => new LudoScene({ seed: 5 }),
+  bot: () => new LudoBot(),
+  progress: (scene) => scene.tokensHome + scene.gamesFinished * LUDO.tokens * LUDO.colors,
+  digest(scene) {
+    let s = scene.state, d = digestScratch;
+    for (let i = 0; i < s.progress.length; i++) d[i] = s.progress[i];
+    return d[s.progress.length] = scene.turns.turn, d[s.progress.length + 1] = s.active, d[s.progress.length + 2] = scene.gamesFinished, d[s.progress.length + 3] = scene.tokensHome, digestInts(d, DIGEST_FIELDS);
+  }
+};
+
+export { DEFAULT_TURN_LOG_CAPACITY, IN_YARD, LUDO, LocalTurnRoom, LudoMove, LudoScene, LudoState, NO_WINNER, TURN_PASS_ACTION, TurnGame, anyMovable, chooseLudoMove, ludoRules, ludoTemplate, ludo_exports, squareOf };