@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-YCDXAJKU.js

@@ -0,0 +1,175 @@
+'use strict';
+
+var chunkWHYKAT7G_js = require('./chunk-WHYKAT7G.js');
+var chunkH5DFSCJ6_js = require('./chunk-H5DFSCJ6.js');
+var chunkYXGZQPUD_js = require('./chunk-YXGZQPUD.js');
+var chunkJGBCIKJV_js = require('./chunk-JGBCIKJV.js');
+
+// src/game/kit/templates/word.ts
+var word_exports = {};
+chunkJGBCIKJV_js.__export(word_exports, {
+  Mark: () => Mark,
+  WORD: () => WORD,
+  WORD_COUNT: () => WORD_COUNT,
+  WORD_LIST: () => WORD_LIST,
+  WordPuzzle: () => WordPuzzle,
+  consistent: () => consistent,
+  evaluate: () => evaluate,
+  wordPuzzleTemplate: () => wordPuzzleTemplate
+});
+var WORD = { length: 5, attempts: 6, alphabet: 26, nextRoundSeconds: 2 }, Mark = { None: 0, Absent: 1, Present: 2, Correct: 3 }, WORDS = "about above actor adapt adult agent agree alarm album alert alive apple award beach begin bench birth black blend bless bloom board boost brain brave bread break bring broad brown build cabin candy cargo carry chain chair charm chart cheap check chest child civic claim class clean clear climb clock cloud coach coast craft crowd dance dream drink drive early earth enjoy equal event faith field flame floor focus fresh fruit giant glass grace grain grand green group guest happy heart honey house juice knife laugh learn light lucky magic march market music night ocean offer party peace phone piano plant plate power price pride proud queen quick quiet radio raise ready river robot round royal salad scale scene score share shine smile solid sound space spice sport stage stand start steam stone storm story sugar sunny table taste teach thank tiger toast today touch tower trade train treat trust truth uncle under unity value video visit voice water whale wheat world young youth zebra", LETTER_BASE = 96;
+function encodeWords(text) {
+  let words = text.split(" ").filter((w) => w.length === WORD.length), out = new Uint8Array(words.length * WORD.length);
+  for (let i = 0; i < words.length; i++)
+    for (let j = 0; j < WORD.length; j++) out[i * WORD.length + j] = words[i].charCodeAt(j) - (96);
+  return out;
+}
+var WORD_LIST = encodeWords(WORDS), WORD_COUNT = WORD_LIST.length / WORD.length, LETTERS = ["", ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("")], counts = new Int8Array(WORD.alphabet + 1);
+function evaluate(guess, guessOffset, answer, answerOffset, out, outOffset) {
+  counts.fill(0);
+  let correct = 0;
+  for (let i = 0; i < WORD.length; i++) {
+    let g = guess[guessOffset + i], a = answer[answerOffset + i];
+    g === a ? (out[outOffset + i] = Mark.Correct, correct++) : (out[outOffset + i] = Mark.Absent, counts[a]++);
+  }
+  for (let i = 0; i < WORD.length; i++) {
+    if (out[outOffset + i] === Mark.Correct) continue;
+    let g = guess[guessOffset + i];
+    counts[g] > 0 && (counts[g]--, out[outOffset + i] = Mark.Present);
+  }
+  return correct === WORD.length;
+}
+var ENTER = 27, BACKSPACE = 28, KEY_CODES = [...LETTERS.slice(1).map((l) => `Key${l}`), "Enter", "Backspace"], TILE_RGB = [3359061, 4674921, 16096779, 1096065], EMPTY_RGB = 1976635, TILE_SIZE = 0.9, TILE_GAP = 1.05, CAMERA_HEIGHT = 9, CAMERA_FOV = 50, CAMERA_PITCH = -Math.PI / 2, WordPuzzle = class {
+  constructor(results = null, answerIndex = -1) {
+    this.name = "word-puzzle";
+    this.grid = new Uint8Array(WORD.attempts * WORD.length);
+    this.marks = new Uint8Array(WORD.attempts * WORD.length);
+    this.keyboard = new Uint8Array(WORD.alphabet + 1);
+    this.answer = new Uint8Array(WORD.length);
+    this.status = "playing";
+    this.row = 0;
+    this.col = 0;
+    this.rounds = 0;
+    this.wins = 0;
+    this.actions = [];
+    this.slots = [];
+    this.roundSlot = null;
+    this.tiles = null;
+    this.waitSeconds = 0;
+    this.results = results, this.fixedAnswer = answerIndex;
+  }
+  enter(game) {
+    chunkWHYKAT7G_js.addSceneCamera(game, 0, (9), 0, (50), CAMERA_PITCH);
+    for (let k = 0; k < KEY_CODES.length; k++)
+      this.actions.push(game.input.defineButton(KEY_CODES[k], [{ device: "key", code: KEY_CODES[k] }, { device: "virtual", control: KEY_CODES[k] }]));
+    for (let i = 0; i < WORD.attempts * WORD.length; i++) this.slots.push(game.ui.hudText(`tile${i}`));
+    this.roundSlot = game.ui.hudNumber("round"), this.tiles = new chunkWHYKAT7G_js.BoxBatch(game, WORD.attempts * WORD.length), this.newRound(game);
+  }
+  fixedUpdate(game) {
+    if (this.status !== "playing") {
+      this.waitSeconds -= game.loop.time.values[chunkYXGZQPUD_js.FRAME_STEP_SECONDS_SLOT], this.waitSeconds <= 0 && this.newRound(game);
+      return;
+    }
+    let input = game.input;
+    for (let k = 0; k < this.actions.length; k++)
+      input.justPressed(this.actions[k]) && (k + 1 === (27) ? this.submit(game) : k + 1 === (28) ? this.erase(game) : this.type(game, k + 1));
+  }
+  update() {
+    let tiles = this.tiles;
+    if (tiles === null) return;
+    let b = tiles.box;
+    tiles.begin(), b[chunkWHYKAT7G_js.BOX_Y] = 0, b[chunkWHYKAT7G_js.BOX_SX] = (0.9), b[chunkWHYKAT7G_js.BOX_SY] = 0.1, b[chunkWHYKAT7G_js.BOX_SZ] = (0.9);
+    for (let r = 0; r < WORD.attempts; r++)
+      for (let c = 0; c < WORD.length; c++) {
+        let i = r * WORD.length + c;
+        b[chunkWHYKAT7G_js.BOX_X] = (c - (WORD.length - 1) / 2) * (1.05), b[chunkWHYKAT7G_js.BOX_Z] = (r - (WORD.attempts - 1) / 2) * (1.05), tiles.add(this.grid[i] === 0 ? (1976635) : TILE_RGB[this.marks[i]]);
+      }
+    tiles.end();
+  }
+  type(game, letter) {
+    if (this.col >= WORD.length) return;
+    let i = this.row * WORD.length + this.col;
+    this.grid[i] = letter, game.ui.setText(this.slots[i], LETTERS[letter]), this.col++;
+  }
+  erase(game) {
+    if (this.col === 0) return;
+    this.col--;
+    let i = this.row * WORD.length + this.col;
+    this.grid[i] = 0, game.ui.setText(this.slots[i], LETTERS[0]);
+  }
+  submit(game) {
+    if (this.col < WORD.length) return;
+    let offset = this.row * WORD.length, won = evaluate(this.grid, offset, this.answer, 0, this.marks, offset);
+    for (let c = 0; c < WORD.length; c++) {
+      let letter = this.grid[offset + c];
+      this.marks[offset + c] > this.keyboard[letter] && (this.keyboard[letter] = this.marks[offset + c]);
+    }
+    this.row++, this.col = 0, (won || this.row === WORD.attempts) && this.finish(game, won);
+  }
+  finish(game, won) {
+    this.status = won ? "won" : "lost", this.rounds++, won && this.wins++, this.waitSeconds = WORD.nextRoundSeconds, game.ui.haptic(won ? "success" : "warning"), this.results?.roundEnded(won, this.row);
+  }
+  newRound(game) {
+    let index = this.fixedAnswer >= 0 ? this.fixedAnswer : game.random.int(0, WORD_COUNT - 1);
+    for (let j = 0; j < WORD.length; j++) this.answer[j] = WORD_LIST[index * WORD.length + j];
+    this.grid.fill(0), this.marks.fill(Mark.None), this.keyboard.fill(Mark.None);
+    for (let i = 0; i < this.slots.length; i++) game.ui.setText(this.slots[i], LETTERS[0]);
+    this.row = 0, this.col = 0, this.status = "playing", this.roundSlot !== null && game.ui.setNumber(this.roundSlot, this.rounds + 1);
+  }
+}, candidateMarks = new Uint8Array(WORD.length);
+function consistent(scene, candidate) {
+  for (let r = 0; r < scene.row; r++) {
+    evaluate(scene.grid, r * WORD.length, WORD_LIST, candidate * WORD.length, candidateMarks, 0);
+    for (let c = 0; c < WORD.length; c++) if (candidateMarks[c] !== scene.marks[r * WORD.length + c]) return false;
+  }
+  return true;
+}
+var BOT_HOLD_FRAMES = 2, WordBot = class {
+  constructor() {
+    this.held = -1;
+    this.holdFrames = 0;
+    this.target = -1;
+  }
+  drive(scene, game, frame) {
+    let t = chunkH5DFSCJ6_js.templateFrameStamp(frame);
+    if (this.held >= 0) {
+      if (++this.holdFrames < (2)) return;
+      game.input.keyEvent(KEY_CODES[this.held], false, t), this.held = -1;
+      return;
+    }
+    if (scene.status !== "playing") {
+      this.target = -1;
+      return;
+    }
+    this.target < 0 && (this.target = this.pick(scene));
+    let key;
+    scene.col < WORD.length ? key = WORD_LIST[this.target * WORD.length + scene.col] - 1 : (key = (27) - 1, this.target = -1), game.input.keyEvent(KEY_CODES[key], true, t), this.held = key, this.holdFrames = 0;
+  }
+  pick(scene) {
+    for (let i = 0; i < WORD_COUNT; i++) if (consistent(scene, i)) return i;
+    return 0;
+  }
+}, digestScratch = new Int32Array(WORD.attempts * WORD.length + 3), wordPuzzleTemplate = {
+  id: "word-puzzle",
+  title: "Word puzzle",
+  sources: ["src/game/kit/templates/word.ts"],
+  economy: null,
+  scene: () => new WordPuzzle(),
+  bot: () => new WordBot(),
+  progress: (scene) => scene.wins,
+  digest(scene) {
+    let d = digestScratch;
+    for (let i = 0; i < scene.grid.length; i++) d[i] = scene.grid[i] * 4 + scene.marks[i];
+    return d[scene.grid.length] = scene.rounds, d[scene.grid.length + 1] = scene.wins, d[scene.grid.length + 2] = scene.row, chunkH5DFSCJ6_js.digestInts(d, d.length);
+  }
+};
+
+exports.Mark = Mark;
+exports.WORD = WORD;
+exports.WORD_COUNT = WORD_COUNT;
+exports.WORD_LIST = WORD_LIST;
+exports.WordPuzzle = WordPuzzle;
+exports.consistent = consistent;
+exports.evaluate = evaluate;
+exports.wordPuzzleTemplate = wordPuzzleTemplate;
+exports.word_exports = word_exports;

package/dist/chunk-YRDQCCIS.js

@@ -0,0 +1,152 @@
+'use strict';
+
+// src/game/input/dom.ts
+var POINTER_PHASES = {
+  pointerdown: "down",
+  pointermove: "move",
+  pointerup: "up",
+  pointercancel: "up"
+}, DOM_DELTA_LINE = 1, DOM_DELTA_PAGE = 2, WHEEL_LINE_PIXELS = 16, WHEEL_PAGE_PIXELS = 800, NO_BUTTONS = 0, PRIMARY_BUTTON = 1;
+function wheelPixels(delta, mode, pageHeight) {
+  return mode === (1) ? delta * (16) : mode === (2) ? delta * (pageHeight > 0 ? pageHeight : (800)) : delta;
+}
+var DomInputBridge = class {
+  constructor(input, surface, keyTarget, options) {
+    this.left = 0;
+    this.top = 0;
+    this.width = 1;
+    this.height = 1;
+    this.onPointer = (event) => this.pointer(event);
+    this.onKey = (event) => this.key(event);
+    this.onResize = () => this.measure();
+    this.onWheel = (event) => this.wheel(event);
+    this.onOrientation = (event) => this.orientation(event);
+    this.onContextMenu = (event) => event.preventDefault();
+    this.input = input, this.surface = surface, this.keyTarget = keyTarget, this.options = options;
+  }
+  attach() {
+    this.measure();
+    for (let type in POINTER_PHASES) this.surface.addEventListener(type, this.onPointer, { passive: true });
+    this.options.wheel !== false && this.surface.addEventListener("wheel", this.onWheel, { passive: this.options.preventWheel !== true }), this.options.preventContextMenu && this.surface.addEventListener("contextmenu", this.onContextMenu), this.options.orientation && this.keyTarget.addEventListener("deviceorientation", this.onOrientation), this.keyTarget.addEventListener("keydown", this.onKey), this.keyTarget.addEventListener("keyup", this.onKey), this.keyTarget.addEventListener("resize", this.onResize);
+  }
+  detach() {
+    for (let type in POINTER_PHASES) this.surface.removeEventListener(type, this.onPointer);
+    this.surface.removeEventListener("wheel", this.onWheel), this.surface.removeEventListener("contextmenu", this.onContextMenu), this.keyTarget.removeEventListener("deviceorientation", this.onOrientation), this.keyTarget.removeEventListener("keydown", this.onKey), this.keyTarget.removeEventListener("keyup", this.onKey), this.keyTarget.removeEventListener("resize", this.onResize);
+  }
+  measure() {
+    let rect = this.surface.getBoundingClientRect();
+    this.left = rect.left, this.top = rect.top, this.width = rect.width > 0 ? rect.width : 1, this.height = rect.height > 0 ? rect.height : 1;
+  }
+  pointer(event) {
+    let phase = POINTER_PHASES[event.type];
+    phase === "down" && this.measure();
+    let buttons = phase === "up" ? (0) : event.buttons === void 0 || event.buttons === 0 ? (1) : event.buttons;
+    this.input.pointerEvent(
+      phase,
+      event.pointerId,
+      (event.clientX - this.left) / this.width,
+      (event.clientY - this.top) / this.height,
+      event.timeStamp,
+      buttons
+    ), phase === "move" && (event.movementX || event.movementY) && this.input.motionEvent(event.movementX, event.movementY, event.timeStamp);
+  }
+  wheel(event) {
+    this.options.preventWheel && event.preventDefault();
+    let mode = event.deltaMode;
+    this.input.wheelEvent(
+      wheelPixels(event.deltaX, mode, this.height),
+      wheelPixels(event.deltaY, mode, this.height),
+      wheelPixels(event.deltaZ, mode, this.height),
+      (event.clientX - this.left) / this.width,
+      (event.clientY - this.top) / this.height,
+      event.timeStamp
+    );
+  }
+  orientation(event) {
+    event.alpha === null && event.beta === null && event.gamma === null || this.input.orientationEvent(event.alpha ?? 0, event.beta ?? 0, event.gamma ?? 0, event.timeStamp);
+  }
+  key(event) {
+    event.repeat || this.input.keyEvent(event.code, event.type === "keydown", event.timeStamp);
+  }
+};
+function attachDomInput(input, surface, keyTarget, options = {}) {
+  let bridge = new DomInputBridge(input, surface, keyTarget, options);
+  return bridge.attach(), () => bridge.detach();
+}
+async function requestPointerLock(target) {
+  try {
+    return await target.requestPointerLock(), !0;
+  } catch {
+    return false;
+  }
+}
+function exitPointerLock(doc) {
+  doc.pointerLockElement !== null && doc.exitPointerLock();
+}
+function isPointerLocked(doc, target) {
+  return doc.pointerLockElement !== null && doc.pointerLockElement === target;
+}
+async function requestOrientationPermission(source = globalThis.DeviceOrientationEvent) {
+  if (source == null) return false;
+  let request = source.requestPermission;
+  if (typeof request != "function") return true;
+  try {
+    return await request.call(source) === "granted";
+  } catch {
+    return false;
+  }
+}
+function screenOrientationDegrees(source = globalThis.screen) {
+  let angle = source?.orientation?.angle;
+  return typeof angle == "number" ? angle : 0;
+}
+var UNSEEN = Number.NaN;
+function ignore() {
+}
+var GamepadPoller = class {
+  constructor(source, index = 0) {
+    this.buttons = new Float32Array(32).fill(UNSEEN);
+    this.axes = new Float32Array(16).fill(UNSEEN);
+    this.connectedState = false;
+    this.source = source, this.index = index;
+  }
+  get connected() {
+    return this.connectedState;
+  }
+  poll(input, timeMs) {
+    let pad = this.pad();
+    if (this.connectedState = pad !== null, pad === null) return false;
+    let buttons = Math.min(pad.buttons.length, 32);
+    for (let i = 0; i < buttons; i++) {
+      let value = pad.buttons[i].value;
+      value !== this.buttons[i] && (this.buttons[i] = value, input.gamepadButtonEvent(i, value, timeMs));
+    }
+    let axes = Math.min(pad.axes.length, 16);
+    for (let i = 0; i < axes; i++) {
+      let value = pad.axes[i];
+      value !== this.axes[i] && (this.axes[i] = value, input.gamepadAxisEvent(i, value, timeMs));
+    }
+    return true;
+  }
+  rumble(strong, weak, durationMs) {
+    let actuator = this.pad()?.vibrationActuator;
+    return !actuator || typeof actuator.playEffect != "function" ? false : (actuator.playEffect("dual-rumble", {
+      duration: durationMs,
+      strongMagnitude: Math.max(0, Math.min(1, strong)),
+      weakMagnitude: Math.max(0, Math.min(1, weak))
+    }).catch(ignore), true);
+  }
+  pad() {
+    let pads = this.source.getGamepads(), pad = this.index < pads.length ? pads[this.index] : null;
+    return pad && pad.connected ? pad : null;
+  }
+};
+
+exports.GamepadPoller = GamepadPoller;
+exports.attachDomInput = attachDomInput;
+exports.exitPointerLock = exitPointerLock;
+exports.isPointerLocked = isPointerLocked;
+exports.requestOrientationPermission = requestOrientationPermission;
+exports.requestPointerLock = requestPointerLock;
+exports.screenOrientationDegrees = screenOrientationDegrees;
+exports.wheelPixels = wheelPixels;

package/dist/chunk-YV52DGSA.js

@@ -0,0 +1,111 @@
+'use strict';
+
+// src/game/render/clips.ts
+var HUMAN_BONES = [
+  "hips",
+  "spine",
+  "chest",
+  "upperChest",
+  "neck",
+  "head",
+  "leftEye",
+  "rightEye",
+  "jaw",
+  "leftUpperLeg",
+  "leftLowerLeg",
+  "leftFoot",
+  "leftToes",
+  "rightUpperLeg",
+  "rightLowerLeg",
+  "rightFoot",
+  "rightToes",
+  "leftShoulder",
+  "leftUpperArm",
+  "leftLowerArm",
+  "leftHand",
+  "rightShoulder",
+  "rightUpperArm",
+  "rightLowerArm",
+  "rightHand",
+  "leftThumbMetacarpal",
+  "leftThumbProximal",
+  "leftThumbDistal",
+  "leftIndexProximal",
+  "leftIndexIntermediate",
+  "leftIndexDistal",
+  "leftMiddleProximal",
+  "leftMiddleIntermediate",
+  "leftMiddleDistal",
+  "leftRingProximal",
+  "leftRingIntermediate",
+  "leftRingDistal",
+  "leftLittleProximal",
+  "leftLittleIntermediate",
+  "leftLittleDistal",
+  "rightThumbMetacarpal",
+  "rightThumbProximal",
+  "rightThumbDistal",
+  "rightIndexProximal",
+  "rightIndexIntermediate",
+  "rightIndexDistal",
+  "rightMiddleProximal",
+  "rightMiddleIntermediate",
+  "rightMiddleDistal",
+  "rightRingProximal",
+  "rightRingIntermediate",
+  "rightRingDistal",
+  "rightLittleProximal",
+  "rightLittleIntermediate",
+  "rightLittleDistal"
+];
+function animationLodInterval(interval) {
+  if (!Number.isFinite(interval) || interval < 1 || interval > 16)
+    throw new RangeError("animation LOD interval must be 1 to 16 frames");
+  return interval | 0;
+}
+var LOOP_CODES = { once: 0, repeat: 1, pingpong: 2 }, BLEND_SPACE_CODES = { "1d": 1, cartesian: 2, directional: 3 }, IK_CODES = { twoBone: 0, lookAt: 1, fabrik: 2, ccd: 3 }, CLIP_EVENT_KINDS = ["event", "loop", "finished"], INTERPOLATION_CODES = { linear: 0, step: 1, cubic: 2 }, MAX_PROPERTY_SIZE = 4, SYNC_MODE_CODES = { phase: 0, markers: 1 }, MAX_SYNC_MARKERS = 32, DEFAULT_BAKE_RATE = 60;
+function checkSyncMarkers(markers, duration) {
+  if (markers.length > (32)) throw new RangeError(`clips hold at most ${(32)} sync markers`);
+  for (let marker of markers)
+    if (!Number.isFinite(marker.time) || marker.time < 0 || marker.time > duration)
+      throw new RangeError(`sync marker time ${marker.time} is outside the clip`);
+}
+function bakeRate(options) {
+  let rate = options?.rate ?? (60);
+  if (!Number.isFinite(rate) || rate < 0) throw new RangeError(`bake rate ${rate} must be zero (source keys only) or a positive rate`);
+  return rate;
+}
+function propertySize(track) {
+  let size = track.size ?? track.rest.length;
+  if (size < 1 || size > (4) || track.rest.length !== size)
+    throw new RangeError(`property tracks hold 1 to ${(4)} values with a matching rest value`);
+  let stride = track.interpolation === "cubic" ? 3 : 1;
+  if (track.times.length === 0 || track.values.length !== track.times.length * size * stride)
+    throw new RangeError("property track values must hold one entry per key (three for cubic: in tangent, value, out tangent)");
+  return size;
+}
+var DEFAULT_IK_ITERATIONS = 16, DEFAULT_IK_TOLERANCE = 1e-3, ROOT_MOTION_WORDS = 4;
+function emptyClipState() {
+  return { time: 0, weight: 0, speed: 0, running: false, paused: false, finished: false };
+}
+function emptyClipEvent() {
+  return { action: 0, kind: "event", id: 0, time: 0 };
+}
+
+exports.BLEND_SPACE_CODES = BLEND_SPACE_CODES;
+exports.CLIP_EVENT_KINDS = CLIP_EVENT_KINDS;
+exports.DEFAULT_IK_ITERATIONS = (16);
+exports.DEFAULT_IK_TOLERANCE = (1e-3);
+exports.HUMAN_BONES = HUMAN_BONES;
+exports.IK_CODES = IK_CODES;
+exports.INTERPOLATION_CODES = INTERPOLATION_CODES;
+exports.LOOP_CODES = LOOP_CODES;
+exports.MAX_PROPERTY_SIZE = (4);
+exports.ROOT_MOTION_WORDS = (4);
+exports.SYNC_MODE_CODES = SYNC_MODE_CODES;
+exports.animationLodInterval = animationLodInterval;
+exports.bakeRate = bakeRate;
+exports.checkSyncMarkers = checkSyncMarkers;
+exports.emptyClipEvent = emptyClipEvent;
+exports.emptyClipState = emptyClipState;
+exports.propertySize = propertySize;

package/dist/chunk-YXGZQPUD.js

@@ -0,0 +1,94 @@
+'use strict';
+
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/loop.ts
+var FRAME_STEP_SECONDS_SLOT = 0, FRAME_SECONDS_SLOT = 1, FRAME_ALPHA_SLOT = 2, SLOT_ACCUMULATOR_MS = 3, SLOT_LAST_MS = 4, SLOT_DROPPED_MS = 5, TIME_SCALE_SLOT = 6, FRAME_TICK_SLOT = 7, FRAME_NOW_MS_SLOT = 8, SLOT_TICK = (7), SLOT_COUNT = 9, NO_FRAME_YET = -1, MAX_WHOLE_STEPS = 2147483647, FrameTime = class {
+  constructor() {
+    this.values = new Float64Array((9));
+  }
+  get stepSeconds() {
+    return this.values[(0)];
+  }
+  get frameSeconds() {
+    return this.values[(1)];
+  }
+  get alpha() {
+    return this.values[(2)];
+  }
+  get tick() {
+    return this.values[SLOT_TICK];
+  }
+}, FixedStepLoop = class {
+  constructor(options = {}) {
+    this.time = new FrameTime();
+    this.views = [this.time.values.subarray(SLOT_TICK, SLOT_TICK + 1)];
+    let hz = options.fixedHz ?? 60;
+    if (!(hz > 0)) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "fixedHz must be positive");
+    this.stepMs = 1e3 / hz, this.maxSubsteps = options.maxSubsteps ?? 5, this.maxFrameDeltaMs = options.maxFrameDeltaMs ?? 250;
+    let v = this.time.values;
+    v[(0)] = 1 / hz, v[(6)] = 1, v[(4)] = (-1);
+  }
+  rollbackViews() {
+    return this.views;
+  }
+  get stepSeconds() {
+    return this.time.values[(0)];
+  }
+  get alpha() {
+    return this.time.values[(2)];
+  }
+  get tick() {
+    return this.time.values[SLOT_TICK];
+  }
+  get frameDeltaSeconds() {
+    return this.time.values[(1)];
+  }
+  get droppedTimeMs() {
+    return this.time.values[(5)];
+  }
+  get timeScale() {
+    return this.time.values[(6)];
+  }
+  set timeScale(scale) {
+    this.time.values[(6)] = scale;
+  }
+  begin(nowMs) {
+    return this.time.values[(8)] = nowMs, this.beginAtClock();
+  }
+  beginAtClock() {
+    let v = this.time.values, last = v[(4)], delta = v[(8)] - last;
+    v[(4)] = v[(8)], (last < 0 || delta < 0) && (delta = 0), delta > this.maxFrameDeltaMs && (v[(5)] += delta - this.maxFrameDeltaMs, delta = this.maxFrameDeltaMs), delta *= v[(6)], v[(1)] = delta / 1e3;
+    let accumulator = v[(3)] + delta, whole = accumulator / this.stepMs, steps = whole < (2147483647) ? whole | 0 : (2147483647);
+    if (steps > this.maxSubsteps) {
+      let dropped = (steps - this.maxSubsteps) * this.stepMs;
+      v[(5)] += dropped, accumulator -= dropped, steps = this.maxSubsteps;
+    }
+    return accumulator -= steps * this.stepMs, v[(3)] = accumulator, v[(2)] = accumulator / this.stepMs, steps;
+  }
+  /** Keeps the clock at this frame without stepping, so a held game resumes without catching up the time it was held. */
+  hold() {
+    let v = this.time.values;
+    v[(4)] = v[(8)], v[(3)] = 0, v[(1)] = 0;
+  }
+  completeStep() {
+    this.time.values[SLOT_TICK]++;
+  }
+  settle(steps) {
+    let v = this.time.values;
+    v[(2)] = 1, v[(1)] = steps * v[(0)];
+  }
+  reset() {
+    let v = this.time.values;
+    v[(3)] = 0, v[(4)] = (-1), v[(2)] = 0, v[SLOT_TICK] = 0, v[(5)] = 0;
+  }
+};
+
+exports.FRAME_ALPHA_SLOT = (2);
+exports.FRAME_NOW_MS_SLOT = (8);
+exports.FRAME_SECONDS_SLOT = (1);
+exports.FRAME_STEP_SECONDS_SLOT = (0);
+exports.FRAME_TICK_SLOT = (7);
+exports.FixedStepLoop = FixedStepLoop;
+exports.FrameTime = FrameTime;
+exports.TIME_SCALE_SLOT = (6);

package/dist/chunk-Z3A3AFVU.mjs

@@ -0,0 +1,102 @@
+import { LAUNCH_HAIR_STYLES } from './chunk-JKGTBMU7.mjs';
+import { CURL_PATTERNS, NO_PART, decodeIdentity, isCatalogueHair } from './chunk-XD2PMH46.mjs';
+
+// src/avatars/face.ts
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", BASE64_PAD = "=", SIX_BITS = 6, BYTE_BITS = 8, BYTE_MASK = 255, LEVEL_MAX = 255, FACE_SIGMA_LIMIT = 3, WIDTH_PER_SIGMA = 0.03, LENGTH_PER_SIGMA = 0.025, AFRO_VOLUME = 0.55, LONG_LENGTH = 0.6, CROP_LENGTH = 0.2, COILY_FROM = CURL_PATTERNS.indexOf("4A"), CURLY_FROM = CURL_PATTERNS.indexOf("3A"), OUTFIT_PALETTE = [
+  [47, 111, 94],
+  [59, 91, 165],
+  [192, 90, 58],
+  [122, 78, 156],
+  [217, 164, 65],
+  [61, 61, 70],
+  [184, 59, 94],
+  [79, 143, 184]
+], BACKDROP_PALETTE = [
+  [227, 241, 234],
+  [230, 236, 248],
+  [248, 232, 223],
+  [239, 230, 246],
+  [248, 240, 220],
+  [233, 234, 238]
+], BASE_OUTFIT = [47, 111, 94], ACCENT_SHIFT = 5, OUTFIT_SLOTS = ["top", "full_body", "outerwear"], POSES = ["neutral", "warm", "cool", "playful"];
+function base64Bytes(text) {
+  let clean = text.replace(/[^A-Za-z0-9+/=_-]/g, "").replace(/-/g, "+").replace(/_/g, "/"), out = [], buffer = 0, bits = 0;
+  for (let char of clean) {
+    if (char === BASE64_PAD) break;
+    let value = BASE64.indexOf(char);
+    value < 0 || (buffer = buffer << (6) | value, bits += (6), bits >= (8) && (bits -= (8), out.push(buffer >> bits & (255))));
+  }
+  return Uint8Array.from(out);
+}
+function stableHash(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++)
+    hash ^= text.charCodeAt(i), hash = Math.imul(hash, 16777619) >>> 0;
+  return hash >>> 0;
+}
+function sourceOfRecord(record) {
+  let look = record.looks.find((entry) => entry.look === record.active_look) ?? record.looks[0];
+  return {
+    identity: record.identity,
+    hash: record.hash,
+    art_style: record.art_style,
+    pose_style: look?.pose_style ?? "neutral",
+    items: look?.items ?? [],
+    portrait_url: record.portrait_url
+  };
+}
+function level(value) {
+  return Math.max(0, Math.min(1, value / (255)));
+}
+function sigma(values, at) {
+  let value = at < values.length ? values[at] : 0;
+  return Math.max(-(3), Math.min((3), value));
+}
+function hairShapeOf(params) {
+  let block = params.hairBlock, pattern = CURL_PATTERNS.indexOf(block.pattern), volume = level(block.volume), length = level(block.length), named = isCatalogueHair(params.hairStyle) ? null : LAUNCH_HAIR_STYLES[params.hairStyle] ?? null;
+  return named === "none" ? "bald" : named === "buzzed" || named === "buzzed_soft" ? "crop" : named === "buns" ? "buns" : pattern >= COILY_FROM && volume >= (0.55) ? "afro" : length >= (0.6) ? "long" : length <= (0.2) ? "crop" : pattern >= CURLY_FROM ? "curls" : "cap";
+}
+function outfitOf(items) {
+  let worn = OUTFIT_SLOTS.map((slot) => items.find((item) => item.slot === slot)).find(
+    (item) => item !== void 0
+  );
+  return worn === void 0 ? BASE_OUTFIT : OUTFIT_PALETTE[stableHash(worn.item_id) % OUTFIT_PALETTE.length];
+}
+function avatarFaceOf(params, source) {
+  let block = params.hairBlock, pattern = CURL_PATTERNS.indexOf(block.pattern), hearing = params.assistive.find(
+    (part) => part.kind === "hearing_aid" || part.kind === "cochlear_implant"
+  ), pose = source.pose_style !== void 0 && POSES.includes(source.pose_style) ? source.pose_style : "neutral", seed = stableHash(source.hash);
+  return {
+    skin: params.skin,
+    hair: params.hair,
+    hairTip: params.hairTip,
+    eye: params.eye,
+    outfit: outfitOf(source.items ?? []),
+    accent: OUTFIT_PALETTE[(seed >>> (5)) % OUTFIT_PALETTE.length],
+    backdrop: BACKDROP_PALETTE[seed % BACKDROP_PALETTE.length],
+    hairShape: hairShapeOf(params),
+    hairVolume: level(block.volume),
+    hairLength: level(block.length),
+    coily: pattern < 0 ? 0 : pattern / (CURL_PATTERNS.length - 1),
+    covered: block.covering !== NO_PART,
+    brows: params.brows,
+    facialHair: params.facialHair,
+    width: 1 + sigma(params.face, 0) * (0.03),
+    length: 1 + sigma(params.face, 1) * (0.025),
+    pose,
+    glasses: params.assistive.some((part) => part.kind === "glasses"),
+    hearing: hearing === void 0 ? null : hearing.side,
+    patches: params.condition === "vitiligo" ? Math.max(1, Math.round(level(params.conditionAmount) * 5)) : 0,
+    seed: params.condition === "vitiligo" ? params.conditionSeed : seed
+  };
+}
+function avatarFace(source) {
+  let bytes = typeof source.identity == "string" ? base64Bytes(source.identity) : source.identity;
+  try {
+    return avatarFaceOf(decodeIdentity(bytes), source);
+  } catch {
+    return null;
+  }
+}
+
+export { avatarFace, avatarFaceOf, base64Bytes, sourceOfRecord, stableHash };