@adatechnology/game-runtime 0.0.0-stage → 0.2.0

package/dist/index.global.js

@@ -0,0 +1,573 @@
+"use strict";
+var GameRuntime = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    COMMAND_SYSTEM_ORDER: () => COMMAND_SYSTEM_ORDER,
+    DEFERRED_PRIORITY: () => DEFERRED_PRIORITY,
+    FRAME_PHASES: () => FRAME_PHASES,
+    createCommandBuffer: () => createCommandBuffer,
+    createFrameBudget: () => createFrameBudget,
+    createScheduler: () => createScheduler,
+    startLoop: () => startLoop
+  });
+
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var FRAME_PHASES = ["input", "fixedSimulate", "lateSimulate", "present", "render", "idle"];
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing) => `land_${surface}_${landing}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+
+  // src/budget-entry.ts
+  var DEFAULT_MIN_EVERY_FRAMES = 4;
+  function createQueueEntry(queue, options) {
+    return {
+      queue,
+      phase: options.phase ?? "idle",
+      priority: options.priority,
+      minEveryFrames: options.minEveryFrames ?? DEFAULT_MIN_EVERY_FRAMES,
+      reserveMs: options.reserveMs ?? 0,
+      reserveLeft: 0,
+      waitingFrames: 0,
+      maxWaitingFrames: 0,
+      ranUnits: 0,
+      spentMs: 0,
+      forced: 0,
+      lastPending: 0
+    };
+  }
+  function insertByPriority(entries, entry) {
+    let index = entries.length;
+    while (index > 0 && entries[index - 1].priority < entry.priority) index--;
+    entries.splice(index, 0, entry);
+  }
+  function queueStats(entry) {
+    return {
+      id: entry.queue.id,
+      pending: entry.lastPending,
+      ranUnits: entry.ranUnits,
+      spentMs: entry.spentMs,
+      framesWaiting: entry.waitingFrames,
+      maxFramesWaiting: entry.maxWaitingFrames,
+      forced: entry.forced
+    };
+  }
+
+  // src/clock.ts
+  var MICROS_PER_SECOND = 1e6;
+  var toMicros = (seconds) => Math.round(seconds * MICROS_PER_SECOND);
+  function defaultClock() {
+    if (typeof performance !== "undefined" && typeof performance.now === "function") return () => performance.now();
+    return () => Date.now();
+  }
+
+  // src/budget.ts
+  var DEFAULT_MS = 4;
+  var MAX_RESERVE_SHARE = 0.5;
+  function createFrameBudget(options = {}) {
+    const clock = options.clock ?? defaultClock();
+    const entries = [];
+    const reportedQueues = /* @__PURE__ */ new Set();
+    let frame = 0;
+    let frameOpen = false;
+    let debt = 0;
+    let common = 0;
+    let spentThisFrame = 0;
+    let unbounded = false;
+    const reservedTotal = () => entries.reduce((sum, entry) => sum + entry.reserveMs, 0);
+    const beginFrame = () => {
+      frame++;
+      frameOpen = true;
+      spentThisFrame = 0;
+      let available = budget.ms;
+      for (const entry of entries) {
+        entry.reserveLeft = 0;
+        if (entry.reserveMs <= 0 || entry.queue.pending(frame) <= 0) continue;
+        entry.reserveLeft = Math.min(entry.reserveMs, available);
+        available -= entry.reserveLeft;
+      }
+      common = Math.max(0, available - debt);
+      debt = 0;
+    };
+    const reportError = (error, entry) => {
+      if (options.onError) return options.onError(error, { id: entry.queue.id, phase: entry.phase });
+      if (reportedQueues.has(entry.queue.id)) return;
+      reportedQueues.add(entry.queue.id);
+      console.error(`game-runtime: queue ${entry.queue.id} threw`, error);
+    };
+    const runQueue = (entry, deadline) => {
+      try {
+        return entry.queue.run(deadline, clock);
+      } catch (error) {
+        reportError(error, entry);
+        return 0;
+      }
+    };
+    const runEntry = (entry, deadline) => {
+      const started = clock();
+      const ran = runQueue(entry, deadline);
+      const spent = Math.max(0, clock() - started);
+      entry.ranUnits += ran;
+      entry.spentMs += spent;
+      entry.waitingFrames = 0;
+      spentThisFrame += spent;
+      if (unbounded) return;
+      const fromReserve = Math.min(entry.reserveLeft, spent);
+      entry.reserveLeft -= fromReserve;
+      common -= spent - fromReserve;
+      if (common < 0) {
+        debt = Math.min(budget.ms, debt - common);
+        common = 0;
+      }
+    };
+    const drainEntry = (entry) => {
+      entry.lastPending = entry.queue.pending(frame);
+      if (entry.lastPending <= 0) {
+        entry.waitingFrames = 0;
+        return;
+      }
+      if (unbounded) return runEntry(entry, Infinity);
+      const allowance = entry.reserveLeft + common;
+      if (allowance > 0) return runEntry(entry, clock() + allowance);
+      entry.waitingFrames++;
+      entry.maxWaitingFrames = Math.max(entry.maxWaitingFrames, entry.waitingFrames);
+      if (entry.waitingFrames < entry.minEveryFrames) return;
+      entry.forced++;
+      runEntry(entry, clock());
+    };
+    const budget = {
+      ms: options.ms ?? DEFAULT_MS,
+      register(queue, queueOptions) {
+        if (entries.some((candidate) => candidate.queue === queue)) throw new Error(`budget.register(${queue.id}): this queue is already registered`);
+        const reserveMs = queueOptions.reserveMs ?? 0;
+        if (reservedTotal() + reserveMs > budget.ms * MAX_RESERVE_SHARE) {
+          throw new Error(`budget.register(${queue.id}): the reserves would pass half of the ${budget.ms} ms budget`);
+        }
+        const entry = createQueueEntry(queue, queueOptions);
+        insertByPriority(entries, entry);
+        queue.attach?.();
+        return () => {
+          const at = entries.indexOf(entry);
+          if (at < 0) return;
+          entries.splice(at, 1);
+          queue.detach?.();
+        };
+      },
+      beginFrame,
+      drain(phase) {
+        if (phase === "present" && !frameOpen) beginFrame();
+        for (const entry of [...entries]) if (entry.phase === phase) drainEntry(entry);
+        if (phase === "idle") frameOpen = false;
+      },
+      flushAll() {
+        for (const entry of entries) entry.queue.flush();
+      },
+      get unbounded() {
+        return unbounded;
+      },
+      set unbounded(value) {
+        unbounded = value;
+      },
+      stats() {
+        return {
+          ms: budget.ms,
+          spentMs: spentThisFrame,
+          debtMs: debt,
+          queues: entries.map(queueStats)
+        };
+      },
+      dispose() {
+        for (const entry of entries.splice(0)) entry.queue.detach?.();
+      }
+    };
+    return budget;
+  }
+
+  // src/commands.ts
+  var COMMAND_SYSTEM_ORDER = -1e4;
+  var NONE = [];
+  function createCommandBuffer(nextTick) {
+    let pending = [];
+    return {
+      push(kind, payload, tick) {
+        pending.push({ kind, payload, tick: tick ?? nextTick() });
+      },
+      take(tick) {
+        if (pending.length === 0) return NONE;
+        const due = [];
+        const later = [];
+        for (const command of pending) (command.tick <= tick ? due : later).push(command);
+        pending = later;
+        return due;
+      },
+      clear() {
+        pending = [];
+      }
+    };
+  }
+
+  // src/loop.ts
+  function startLoop(scheduler, options = {}) {
+    const requestFrame = options.requestFrame ?? globalThis.requestAnimationFrame?.bind(globalThis);
+    const cancelFrame = options.cancelFrame ?? globalThis.cancelAnimationFrame?.bind(globalThis);
+    if (!requestFrame) throw new Error("startLoop: no requestAnimationFrame here, pass requestFrame");
+    let last = options.startMs ?? (typeof performance !== "undefined" ? performance.now() : 0);
+    let handle = 0;
+    let stopped = false;
+    const onFrame = (nowMs) => {
+      if (stopped) return;
+      handle = requestFrame(onFrame);
+      const gap = options.minFrameMs?.() ?? 0;
+      if (gap > 0 && nowMs - last < gap) return;
+      const realSeconds = (nowMs - last) / 1e3;
+      last = nowMs;
+      options.onFrame?.(realSeconds);
+      scheduler.frame(realSeconds, options.skipSimulation?.() ? { simulate: false } : void 0);
+    };
+    const onVisibility = () => {
+      if (document.visibilityState !== "visible") return;
+      if (typeof performance !== "undefined") last = performance.now();
+      scheduler.resetClock();
+    };
+    const hasDocument = typeof document !== "undefined" && typeof document.addEventListener === "function";
+    if (hasDocument) document.addEventListener("visibilitychange", onVisibility);
+    handle = requestFrame(onFrame);
+    return () => {
+      stopped = true;
+      cancelFrame?.(handle);
+      if (hasDocument) document.removeEventListener("visibilitychange", onVisibility);
+    };
+  }
+
+  // src/frame-time.ts
+  var sanitizeSeconds = (seconds) => Number.isFinite(seconds) && seconds > 0 ? seconds : 0;
+  var sanitizeTimeScale = (scale) => Number.isFinite(scale) ? Math.max(0, scale) : 1;
+  function resolveFrameTime(realSeconds, exact, residual, config) {
+    const given = sanitizeSeconds(realSeconds);
+    if (exact) return { seconds: given, micros: toMicros(given), residual };
+    const clamped = Math.min(given, config.maxFrameSeconds);
+    const micros = toMicros(clamped) + residual;
+    const wholeSteps = Math.round(micros / config.fixedMicros);
+    const drift = micros - wholeSteps * config.fixedMicros;
+    if (config.snapMicros > 0 && wholeSteps >= 1 && Math.abs(drift) <= config.snapMicros) {
+      return { seconds: wholeSteps * config.fixedDt, micros: wholeSteps * config.fixedMicros, residual: drift };
+    }
+    return { seconds: clamped, micros, residual: 0 };
+  }
+
+  // src/phase-runner.ts
+  function createPhaseRunner(deps) {
+    const { clock, ctx, lists, reportError, fixedDt } = deps;
+    const phaseMs = Object.fromEntries(FRAME_PHASES.map((phase) => [phase, 0]));
+    let tick = 0;
+    const runEntries = (phase) => {
+      for (const entry of lists[phase].entries) {
+        if (entry.dead) continue;
+        try {
+          entry.fn(ctx);
+        } catch (error) {
+          reportError(error, { id: entry.id, phase });
+        }
+      }
+    };
+    return {
+      runPhase(phase, dt) {
+        const started = clock();
+        ctx.dt = dt;
+        runEntries(phase);
+        phaseMs[phase] = clock() - started;
+      },
+      runFixed(steps) {
+        const started = clock();
+        ctx.dt = fixedDt;
+        for (let substep = 0; substep < steps; substep++) {
+          ctx.substep = substep;
+          ctx.tick = tick;
+          runEntries("fixedSimulate");
+          tick++;
+        }
+        ctx.substep = 0;
+        ctx.tick = tick;
+        phaseMs.fixedSimulate = clock() - started;
+      },
+      get tick() {
+        return tick;
+      },
+      phaseMs
+    };
+  }
+
+  // src/phases.ts
+  function createSystemList(isRunning) {
+    let entries = [];
+    const waiting = [];
+    const insert = (entry) => {
+      let index = entries.length;
+      while (index > 0 && entries[index - 1].order > entry.order) index--;
+      entries.splice(index, 0, entry);
+    };
+    return {
+      add(entry) {
+        if (isRunning()) waiting.push(entry);
+        else insert(entry);
+      },
+      remove(entry) {
+        entry.dead = true;
+        if (!isRunning()) entries = entries.filter((candidate) => candidate !== entry);
+      },
+      get entries() {
+        return entries;
+      },
+      settle() {
+        if (entries.some((entry) => entry.dead)) entries = entries.filter((entry) => !entry.dead);
+        for (const entry of waiting.splice(0)) if (!entry.dead) insert(entry);
+      },
+      clear() {
+        for (const entry of entries) entry.dead = true;
+        for (const entry of waiting.splice(0)) entry.dead = true;
+        entries = isRunning() ? entries : [];
+      }
+    };
+  }
+
+  // src/scheduler.ts
+  function createScheduler(options = {}) {
+    const fixedDt = options.fixedDt ?? 1 / 60;
+    const fixedMicros = toMicros(fixedDt);
+    const maxSubsteps = options.maxSubsteps ?? 4;
+    const timeConfig = { fixedMicros, fixedDt, maxFrameSeconds: options.maxFrameSeconds ?? 0.25, snapMicros: Math.round((options.snapMs ?? 0.25) * 1e3) };
+    const clock = options.clock ?? defaultClock();
+    let accumulator = 0;
+    let residual = 0;
+    let droppedMicros = 0;
+    let substepsLastFrame = 0;
+    let running = false;
+    let disposed = false;
+    let paused = false;
+    let scripted = false;
+    let timeScale = 1;
+    let nextSystem = 0;
+    const reportedErrors = /* @__PURE__ */ new Set();
+    const lists = Object.fromEntries(FRAME_PHASES.map((phase) => [phase, createSystemList(() => running)]));
+    const ctx = { dt: 0, realDt: 0, fixedDt, alpha: 0, frame: 0, tick: 0, substep: 0, simTime: 0, paused: false, scripted: false, simulated: true };
+    const reportError = options.onError ?? ((error, system) => {
+      if (reportedErrors.has(system.id)) return;
+      reportedErrors.add(system.id);
+      console.error(`game-runtime: system ${system.id} (${system.phase}) threw`, error);
+    });
+    const budget = createFrameBudget({ ms: options.budgetMs ?? 4, clock, onError: (error, queue) => reportError(error, { id: `queue:${queue.id}`, phase: queue.phase }) });
+    const runner = createPhaseRunner({ clock, ctx, lists, reportError, fixedDt });
+    const { runPhase, runFixed } = runner;
+    const settleAll = () => {
+      for (const phase of FRAME_PHASES) lists[phase].settle();
+    };
+    const begin = () => {
+      running = true;
+      budget.beginFrame();
+      ctx.frame++;
+      ctx.paused = paused;
+      ctx.scripted = scripted;
+      ctx.tick = runner.tick;
+    };
+    const end = () => {
+      running = false;
+      settleAll();
+    };
+    const simulate = (seconds, micros, exact) => {
+      runPhase("input", seconds);
+      if (paused) return;
+      accumulator += Math.round(micros * timeScale);
+      let steps = Math.floor(accumulator / fixedMicros);
+      if (!exact && steps > maxSubsteps) {
+        droppedMicros += accumulator - maxSubsteps * fixedMicros;
+        steps = maxSubsteps;
+        accumulator = maxSubsteps * fixedMicros;
+      }
+      accumulator -= steps * fixedMicros;
+      substepsLastFrame = steps;
+      runFixed(steps);
+      ctx.alpha = accumulator / fixedMicros;
+      ctx.simTime += seconds * timeScale;
+      runPhase("lateSimulate", seconds * timeScale);
+    };
+    const frame = (realSeconds, run = {}) => {
+      if (running) throw new Error("scheduler.frame: re-entrant call");
+      if (disposed) throw new Error("scheduler.frame: the scheduler was disposed");
+      const time = resolveFrameTime(realSeconds, run.exact === true, residual, timeConfig);
+      residual = time.residual;
+      const seconds = time.seconds;
+      begin();
+      try {
+        ctx.simulated = run.simulate !== false;
+        ctx.realDt = seconds;
+        ctx.alpha = accumulator / fixedMicros;
+        substepsLastFrame = 0;
+        if (ctx.simulated) simulate(seconds, time.micros, run.exact === true);
+        ctx.alpha = accumulator / fixedMicros;
+        runPhase("present", paused ? 0 : seconds * timeScale);
+        budget.drain("present");
+        if (run.render !== false) runPhase("render", seconds);
+        runPhase("idle", seconds);
+        budget.drain("idle");
+      } finally {
+        ctx.simulated = true;
+        end();
+      }
+    };
+    const advanceStep = (dt, steps) => {
+      begin();
+      try {
+        ctx.simulated = true;
+        ctx.realDt = dt;
+        ctx.alpha = 0;
+        runPhase("input", dt);
+        if (!paused) {
+          runFixed(steps);
+          ctx.simTime += dt;
+          runPhase("lateSimulate", dt);
+        }
+        runPhase("present", paused ? 0 : dt);
+        budget.drain("present");
+        runPhase("idle", dt);
+        budget.drain("idle");
+      } finally {
+        end();
+      }
+    };
+    const advance = (seconds, advanceOptions = {}) => {
+      if (running) throw new Error("scheduler.advance: re-entrant call");
+      if (disposed) throw new Error("scheduler.advance: the scheduler was disposed");
+      const dt = sanitizeSeconds(advanceOptions.dt ?? fixedDt) || fixedDt;
+      const iterations = Math.max(1, Math.round(sanitizeSeconds(seconds) / dt));
+      const steps = Math.max(1, Math.round(dt / fixedDt));
+      const wasUnbounded = budget.unbounded;
+      budget.unbounded = true;
+      scripted = true;
+      accumulator = 0;
+      residual = 0;
+      scheduler.commands.clear();
+      try {
+        for (let i = 0; i < iterations; i++) advanceStep(dt, steps);
+      } finally {
+        scripted = false;
+        ctx.scripted = false;
+        budget.unbounded = wasUnbounded;
+        accumulator = 0;
+        ctx.alpha = 0;
+      }
+    };
+    const scheduler = {
+      add(system, systemOptions) {
+        if (disposed) return () => void 0;
+        const entry = {
+          id: systemOptions.id ?? `${systemOptions.phase}#${nextSystem++}`,
+          phase: systemOptions.phase,
+          fn: system,
+          order: systemOptions.order ?? 0,
+          dead: false
+        };
+        lists[entry.phase].add(entry);
+        return () => lists[entry.phase].remove(entry);
+      },
+      frame,
+      advance,
+      pause() {
+        paused = true;
+      },
+      resume() {
+        paused = false;
+      },
+      get paused() {
+        return paused;
+      },
+      get timeScale() {
+        return timeScale;
+      },
+      set timeScale(value) {
+        timeScale = sanitizeTimeScale(value);
+      },
+      resetClock() {
+        accumulator = 0;
+        residual = 0;
+      },
+      budget,
+      commands: createCommandBuffer(() => runner.tick),
+      stats() {
+        return { frame: ctx.frame, tick: runner.tick, substepsLastFrame, droppedSeconds: droppedMicros / MICROS_PER_SECOND, phaseMs: { ...runner.phaseMs }, budget: budget.stats() };
+      },
+      dispose() {
+        disposed = true;
+        budget.dispose();
+        for (const phase of FRAME_PHASES) lists[phase].clear();
+        settleAll();
+      }
+    };
+    return scheduler;
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map