@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-MOMOZEUM.mjs

@@ -0,0 +1,88 @@
+// src/game/dev/inspector.ts
+var ENGINE_INSPECTOR_EXPORT_NAMES = ["engine_inspector_enable", "engine_inspector_watch", "engine_inspector_label", "engine_inspector_registers"];
+var DEV_CHANNEL_KEY = "__cimplify_dev";
+function pool(registers, at) {
+  return { live: registers[at], highWater: registers[at + 1], capacity: registers[at + 2] };
+}
+function decodeInspector(registers) {
+  return {
+    shown: registers[0] !== 0,
+    refreshes: registers[1],
+    error: registers[2],
+    arena: { highWaterBytes: registers[3] * 1024, committedBytes: registers[4] * 1024, ceilingBytes: registers[5] * 1024 },
+    stream: { missing: registers[10], urgent: registers[13], starvedFrames: registers[14] },
+    bodies: pool(registers, 19),
+    colliders: pool(registers, 22),
+    kernels: { budgetMs: registers[28] / 1e6, spentMs: registers[29] / 1e6 },
+    frameMs: registers[34] / 1e6
+  };
+}
+var sealedChannel = null;
+function channel() {
+  let scope = globalThis, existing = scope[DEV_CHANNEL_KEY] ?? sealedChannel;
+  if (existing != null) return existing;
+  let fresh = { wanted: false, supported: false, world: 0, stream: 0, listeners: /* @__PURE__ */ new Set() };
+  return Object.isExtensible(scope) ? scope[DEV_CHANNEL_KEY] = fresh : sealedChannel = fresh, fresh;
+}
+function notify() {
+  let dev2 = channel();
+  for (let listener of [...dev2.listeners]) listener(dev2.wanted);
+}
+function requestInspector(wanted) {
+  let dev2 = channel();
+  dev2.wanted !== wanted && (dev2.wanted = wanted, notify());
+}
+function noteInspectorWorld(world) {
+  let dev2 = channel();
+  dev2.world !== world && (dev2.world = world, notify());
+}
+function noteInspectorStream(stream) {
+  let dev2 = channel();
+  dev2.stream !== stream && (dev2.stream = stream, notify());
+}
+var EngineInspector = class _EngineInspector {
+  constructor(exports, memory, names) {
+    this.exports = exports;
+    this.memory = memory;
+    this.names = names;
+    this.view = new Uint32Array(0);
+    this.encoder = new TextEncoder();
+    this.shown = false;
+    let dev2 = channel();
+    dev2.supported = true;
+    let listener = (wanted) => this.apply(wanted);
+    dev2.listeners.add(listener), this.unsubscribe = () => dev2.listeners.delete(listener), dev2.wanted && this.apply(true);
+  }
+  static bind(symbols, memory, names) {
+    for (let name of [...ENGINE_INSPECTOR_EXPORT_NAMES, "engine_alloc", "engine_free"]) if (typeof symbols[name] != "function") return null;
+    let exports = symbols;
+    return exports.engine_inspector_watch(0, 0) < 0 ? null : new _EngineInspector(exports, memory, names);
+  }
+  apply(wanted) {
+    let dev2 = channel();
+    if (!(this.exports.engine_inspector_enable(wanted ? 1 : 0) < 0) && (this.shown = wanted, this.exports.engine_inspector_watch(dev2.world, dev2.stream), wanted))
+      for (let [space, binding, name] of this.names()) this.label(space, binding, name);
+  }
+  label(space, binding, name) {
+    if (!this.shown) return;
+    let bytes = this.encoder.encode(name).subarray(0, 24);
+    if (bytes.byteLength === 0) return;
+    let at = this.exports.engine_alloc(bytes.byteLength, 1);
+    at !== 0 && (new Uint8Array(this.memory.buffer, at, bytes.byteLength).set(bytes), this.exports.engine_inspector_label(space, binding, at, bytes.byteLength), this.exports.engine_free(at, bytes.byteLength, 1));
+  }
+  readout() {
+    let at = this.exports.engine_inspector_registers();
+    if (at === 0) return null;
+    let buffer = this.memory.buffer;
+    return (this.view.buffer !== buffer || this.view.byteOffset !== at) && (this.view = new Uint32Array(buffer, at, 40)), decodeInspector(this.view);
+  }
+  release() {
+    this.unsubscribe(), this.shown && this.exports.engine_inspector_enable(0), this.shown = false;
+  }
+}, dev = {
+  inspector(on = true) {
+    return requestInspector(on), channel().supported;
+  }
+};
+
+export { ENGINE_INSPECTOR_EXPORT_NAMES, EngineInspector, dev, noteInspectorStream, noteInspectorWorld, requestInspector };

package/dist/chunk-MRFUNRAP.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/ecs/entity.ts
+var NO_ENTITY = 4294967295;
+function entityIndex(entity) {
+  return entity & 1048575;
+}
+function entityGeneration(entity) {
+  return entity >>> 20 & 1023;
+}
+function pack(index, generation) {
+  return ((generation & 1023) << 20 | index) >>> 0;
+}
+var FREE = 0, HIGH_WATER = 1, LIVE = 2, FREE_HEAD = 3, COUNTERS = 4, EntityRegistry = class {
+  constructor(capacity) {
+    this.counters = new Uint32Array((4));
+    if (capacity <= 0 || capacity > 1048575)
+      throw new chunk2V7IL4HC_js.GameError("invalid_argument", `entity capacity must be 1..${1048575}`);
+    this.capacity = capacity, this.generations = new Uint16Array(capacity), this.live = new Uint8Array(capacity), this.freeList = new Uint32Array(capacity), this.views = [this.counters, this.generations, this.live, this.freeList];
+  }
+  get count() {
+    return this.counters[(2)];
+  }
+  rollbackViews() {
+    return this.views;
+  }
+  create() {
+    let c = this.counters, index;
+    if (c[(0)] > 0) {
+      let head = c[(3)];
+      index = this.freeList[head], c[(3)] = head + 1 === this.capacity ? 0 : head + 1, c[(0)]--;
+    } else {
+      if (c[(1)] >= this.capacity)
+        throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", `entity capacity ${this.capacity} reached`);
+      index = c[(1)]++;
+    }
+    return this.live[index] = 1, c[(2)]++, pack(index, this.generations[index]);
+  }
+  destroy(entity) {
+    if (!this.isAlive(entity)) return false;
+    let index = entityIndex(entity), c = this.counters;
+    this.live[index] = 0, this.generations[index] = this.generations[index] + 1 & 1023;
+    let tail = c[(3)] + c[(0)];
+    return this.freeList[tail >= this.capacity ? tail - this.capacity : tail] = index, c[(0)]++, c[(2)]--, true;
+  }
+  isAlive(entity) {
+    if (entity === (4294967295)) return false;
+    let index = entityIndex(entity);
+    return index < this.counters[(1)] && this.live[index] === 1 && this.generations[index] === entityGeneration(entity);
+  }
+  assertAlive(entity) {
+    if (!this.isAlive(entity))
+      throw new chunk2V7IL4HC_js.GameError("dead_entity", `entity ${entity} is not alive`);
+  }
+};
+
+exports.EntityRegistry = EntityRegistry;
+exports.NO_ENTITY = (4294967295);
+exports.entityGeneration = entityGeneration;
+exports.entityIndex = entityIndex;

package/dist/chunk-MTIHEW2M.js

@@ -0,0 +1,433 @@
+'use strict';
+
+var chunkNH654HAT_js = require('./chunk-NH654HAT.js');
+var chunkWHYKAT7G_js = require('./chunk-WHYKAT7G.js');
+var chunkH5DFSCJ6_js = require('./chunk-H5DFSCJ6.js');
+var chunk5LH2QN3T_js = require('./chunk-5LH2QN3T.js');
+var chunkYXGZQPUD_js = require('./chunk-YXGZQPUD.js');
+var chunkJGBCIKJV_js = require('./chunk-JGBCIKJV.js');
+
+// 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 chunkNH654HAT_js.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 chunkNH654HAT_js.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 = {};
+chunkJGBCIKJV_js.__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 chunk5LH2QN3T_js.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) {
+    chunkWHYKAT7G_js.addSceneCamera(game, 0, (18), 0, (55), CAMERA_PITCH), this.layout(), this.board = new chunkWHYKAT7G_js.BoxBatch(game, LUDO.track + this.lanes.length / (2) + 1), this.pieces = new chunkWHYKAT7G_js.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[chunkYXGZQPUD_js.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[chunkYXGZQPUD_js.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[chunkWHYKAT7G_js.BOX_X] = 0, b[chunkWHYKAT7G_js.BOX_Y] = -0.3, b[chunkWHYKAT7G_js.BOX_Z] = 0, b[chunkWHYKAT7G_js.BOX_SX] = (7) * 2 + 2, b[chunkWHYKAT7G_js.BOX_SY] = 0.2, b[chunkWHYKAT7G_js.BOX_SZ] = (7) * 2 + 2, board.add((1976635)), b[chunkWHYKAT7G_js.BOX_Y] = -0.1, b[chunkWHYKAT7G_js.BOX_SX] = (0.92), b[chunkWHYKAT7G_js.BOX_SY] = 0.1, b[chunkWHYKAT7G_js.BOX_SZ] = (0.92);
+    for (let s = 0; s < LUDO.track; s++)
+      b[chunkWHYKAT7G_js.BOX_X] = this.squares[s * (2)], b[chunkWHYKAT7G_js.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[chunkWHYKAT7G_js.BOX_X] = this.lanes[i * (2)], b[chunkWHYKAT7G_js.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[chunkWHYKAT7G_js.BOX_SX] = (0.45), b[chunkWHYKAT7G_js.BOX_SY] = (0.7), b[chunkWHYKAT7G_js.BOX_SZ] = (0.45), b[chunkWHYKAT7G_js.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[chunkWHYKAT7G_js.BOX_X] = cornerX + ((t & 1) - 0.5) * (0.8) * 2, b[chunkWHYKAT7G_js.BOX_Z] = cornerZ + ((t >> 1) - 0.5) * (0.8) * 2;
+        else if (p <= LUDO.lastTrackStep) {
+          let square = squareOf(state, seat, t);
+          b[chunkWHYKAT7G_js.BOX_X] = this.squares[square * (2)], b[chunkWHYKAT7G_js.BOX_Z] = this.squares[square * (2) + 1];
+        } else {
+          let h = p - LUDO.lastTrackStep - 1, o = (color * lane + (h < lane ? h : lane - 1)) * (2);
+          b[chunkWHYKAT7G_js.BOX_X] = this.lanes[o], b[chunkWHYKAT7G_js.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 = chunkH5DFSCJ6_js.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, chunkH5DFSCJ6_js.digestInts(d, DIGEST_FIELDS);
+  }
+};
+
+exports.DEFAULT_TURN_LOG_CAPACITY = (4096);
+exports.IN_YARD = (-1);
+exports.LUDO = LUDO;
+exports.LocalTurnRoom = LocalTurnRoom;
+exports.LudoMove = LudoMove;
+exports.LudoScene = LudoScene;
+exports.LudoState = LudoState;
+exports.NO_WINNER = (-1);
+exports.TURN_PASS_ACTION = (-2147483648);
+exports.TurnGame = TurnGame;
+exports.anyMovable = anyMovable;
+exports.chooseLudoMove = chooseLudoMove;
+exports.ludoRules = ludoRules;
+exports.ludoTemplate = ludoTemplate;
+exports.ludo_exports = ludo_exports;
+exports.squareOf = squareOf;

package/dist/chunk-N4RGGDEL.mjs

@@ -0,0 +1,73 @@
+// src/interactives/runtime/approved-wasm.ts
+var REAL = typeof WebAssembly > "u" ? null : WebAssembly, approved = /* @__PURE__ */ new WeakSet(), WasmGuardError = class extends Error {
+  constructor(member) {
+    super(`WebAssembly.${member} is not available to Interactives; only the platform's runtime modules instantiate`), this.name = "GuardError";
+  }
+}, withdrawn = false, sealed = null;
+function sealConstructors(real) {
+  return sealed ?? (sealed = {
+    Module: refusedClass("Module", real.Module.prototype, { imports: real.Module.imports, exports: real.Module.exports, customSections: real.Module.customSections }),
+    Instance: refusedClass("Instance", real.Instance.prototype, {})
+  }), sealed;
+}
+function withdrawWasm() {
+  withdrawn = true, REAL !== null && sealConstructors(REAL);
+}
+function wasmAvailable() {
+  return REAL !== null && !withdrawn;
+}
+async function compileApproved(bytes) {
+  if (REAL === null || withdrawn) throw new WasmGuardError("compile");
+  let module = await REAL.compile(bytes);
+  return approved.add(module), module;
+}
+async function approveCompiled(compiled) {
+  if (REAL === null || withdrawn) throw new WasmGuardError("compile");
+  let module = await compiled;
+  if (!(module instanceof REAL.Module)) throw new WasmGuardError("compile");
+  return approved.add(module), module;
+}
+function refuse(member) {
+  return () => {
+    throw new WasmGuardError(member);
+  };
+}
+function refusedClass(member, prototype, statics) {
+  let refused = function() {
+    throw new WasmGuardError(member);
+  };
+  for (let [name, value] of Object.entries(statics)) Object.defineProperty(refused, name, { value, writable: false, enumerable: true, configurable: false });
+  return Object.defineProperty(refused, "prototype", { value: prototype, writable: false, enumerable: false, configurable: false }), Object.defineProperty(prototype, "constructor", { value: refused, writable: false, enumerable: false, configurable: false }), Object.freeze(refused);
+}
+function checked(module, member) {
+  if (REAL === null || typeof module != "object" || module === null || !approved.has(module)) throw new WasmGuardError(member);
+  return module;
+}
+var guarded;
+function guardedWebAssembly() {
+  let real = REAL;
+  if (real !== null)
+    return guarded ?? (guarded = Object.freeze({
+      Memory: real.Memory,
+      Table: real.Table,
+      Global: real.Global,
+      CompileError: real.CompileError,
+      LinkError: real.LinkError,
+      RuntimeError: real.RuntimeError,
+      compile: refuse("compile"),
+      compileStreaming: refuse("compileStreaming"),
+      instantiateStreaming: refuse("instantiateStreaming"),
+      validate: refuse("validate"),
+      Module: sealConstructors(real).Module,
+      Instance: sealConstructors(real).Instance,
+      instantiate(module, imports) {
+        return real.instantiate(checked(module, "instantiate with bytes or an unapproved module"), imports);
+      }
+    })), guarded;
+}
+async function instantiateApproved(bytes, imports) {
+  let module = await compileApproved(bytes);
+  return REAL.instantiate(module, imports);
+}
+
+export { approveCompiled, compileApproved, guardedWebAssembly, instantiateApproved, wasmAvailable, withdrawWasm };

package/dist/chunk-NH654HAT.js

@@ -0,0 +1,10 @@
+'use strict';
+
+// src/game/kit/errors.ts
+var KitError = class extends Error {
+  constructor(code, message) {
+    super(message), this.name = "KitError", this.code = code;
+  }
+};
+
+exports.KitError = KitError;