@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-DDJLDOUX.mjs

@@ -0,0 +1,217 @@
+import { sha256Into, SHA256_BYTES } from './chunk-5YWN6H5Q.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/replay-clip.ts
+var REPLAY_FORMAT_VERSION = 1, REPLAY_MAGIC = 1280332355, REPLAY_FLAG_PLAY_FROM_HERE = 1, REPLAY_HEADER_BYTES = 96, MAX_REPLAY_SECTIONS = 65535, MAGIC_AT = 0, VERSION_AT = 4, FLAGS_AT = 6, TICK_HZ_AT = 8, STRIDE_AT = 10, START_AT = 12, TICKS_AT = 16, STATE_BYTES_AT = 20, SECTIONS_AT = 24, ID_BYTES_AT = 26, REVISION_BYTES_AT = 28, STATE_DIGEST_AT = 32, FINAL_DIGEST_AT = (32) + SHA256_BYTES, SECTION_BYTES = 4, MAX_U16 = 65535, HEX = 16, LITTLE_ENDIAN = true, NO_TICK = -1;
+function hexOf(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) out += bytes[i].toString((16)).padStart(2, "0");
+  return out;
+}
+function bytesOfHex(text, out, at) {
+  if (text.length !== SHA256_BYTES * 2) throw new GameError("invalid_argument", "a replay digest is 32 bytes of hex");
+  for (let i = 0; i < SHA256_BYTES; i++) out[at + i] = Number.parseInt(text.slice(i * 2, i * 2 + 2), (16));
+}
+function bytesOf(view) {
+  return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+}
+var StateLayout = class {
+  constructor(states) {
+    this.states = states;
+    this.views = [];
+    this.known = [];
+    this.laid = false;
+    this.bytes = 0;
+  }
+  changed() {
+    let index = 0, known = this.known;
+    for (let s = 0; s < this.states.length; s++) {
+      let views = this.states[s].rollbackViews();
+      for (let v = 0; v < views.length; v++) {
+        if (known[index] !== views[v]) return true;
+        index++;
+      }
+    }
+    return index !== known.length || !this.laid;
+  }
+  relayout() {
+    this.laid = true;
+    let known = [], views = [], bytes = 0;
+    for (let state of this.states)
+      for (let view of state.rollbackViews()) {
+        known.push(view);
+        let raw = bytesOf(view);
+        views.push(raw), bytes += raw.byteLength;
+      }
+    this.known = known, this.views = views, this.bytes = bytes;
+  }
+  sections() {
+    return this.views.map((view) => view.byteLength);
+  }
+  save(out, at) {
+    let offset = at, views = this.views;
+    for (let i = 0; i < views.length; i++)
+      out.set(views[i], offset), offset += views[i].byteLength;
+  }
+  load(from) {
+    let offset = 0, views = this.views;
+    for (let i = 0; i < views.length; i++) {
+      let length = views[i].byteLength;
+      views[i].set(from.subarray(offset, offset + length)), offset += length;
+    }
+  }
+};
+function stateDigest(states) {
+  let layout = new StateLayout(states);
+  layout.relayout();
+  let scratch = new Uint8Array(layout.bytes);
+  layout.save(scratch, 0);
+  let out = new Uint8Array(SHA256_BYTES);
+  return sha256Into(scratch, out), hexOf(out);
+}
+function digestOf(bytes) {
+  let out = new Uint8Array(SHA256_BYTES);
+  return sha256Into(bytes, out), hexOf(out);
+}
+var encoder = new TextEncoder(), decoder = new TextDecoder();
+function encodeReplay(clip) {
+  let manifest = clip.manifest, id = encoder.encode(manifest.interactive_id), revision = encoder.encode(manifest.revision);
+  if (id.length > (65535) || revision.length > (65535) || manifest.sections.length > (65535))
+    throw new GameError("invalid_argument", "the replay names or layout are too long");
+  if (clip.inputs.length !== manifest.ticks * manifest.input_stride) throw new GameError("invalid_argument", "the replay inputs do not cover its ticks");
+  let sectionsBytes = manifest.sections.length * (4), size = (96) + sectionsBytes + id.length + revision.length + clip.state.length + clip.inputs.length, out = new Uint8Array(size), view = new DataView(out.buffer);
+  view.setUint32((0), (1280332355), (true)), view.setUint16((4), (1), (true)), view.setUint16((6), manifest.play_from_here ? (1) : 0, (true)), view.setUint16((8), manifest.tick_hz, (true)), view.setUint16((10), manifest.input_stride, (true)), view.setUint32((12), manifest.start_tick >>> 0, (true)), view.setUint32((16), manifest.ticks >>> 0, (true)), view.setUint32((20), clip.state.length, (true)), view.setUint16((24), manifest.sections.length, (true)), view.setUint16((26), id.length, (true)), view.setUint16((28), revision.length, (true)), bytesOfHex(manifest.state_digest, out, (32)), bytesOfHex(manifest.final_digest, out, FINAL_DIGEST_AT);
+  let at = (96);
+  for (let section of manifest.sections)
+    view.setUint32(at, section, (true)), at += (4);
+  return out.set(id, at), at += id.length, out.set(revision, at), at += revision.length, out.set(clip.state, at), at += clip.state.length, out.set(clip.inputs, at), out;
+}
+function replayFlags(bytes) {
+  if (bytes.length < (96)) return null;
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return view.getUint32((0), (true)) !== (1280332355) ? null : { version: view.getUint16((4), (true)), play_from_here: (view.getUint16((6), (true)) & (1)) !== 0 };
+}
+function decodeReplay(bytes) {
+  let flags = replayFlags(bytes);
+  if (flags === null) throw new GameError("invalid_argument", "this is not a replay");
+  if (flags.version > (1)) throw new GameError("unsupported_feature", `replay format ${flags.version} is newer than this player`);
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), stride = view.getUint16((10), (true)), ticks = view.getUint32((16), (true)), stateBytes = view.getUint32((20), (true)), sectionCount = view.getUint16((24), (true)), idBytes = view.getUint16((26), (true)), revisionBytes = view.getUint16((28), (true)), sectionsEnd = (96) + sectionCount * (4), stateAt = sectionsEnd + idBytes + revisionBytes, inputsAt = stateAt + stateBytes;
+  if (inputsAt + ticks * stride !== bytes.length) throw new GameError("invalid_argument", "the replay is truncated or padded");
+  let sections = [], total = 0;
+  for (let at = (96); at < sectionsEnd; at += (4)) {
+    let section = view.getUint32(at, (true));
+    sections.push(section), total += section;
+  }
+  if (total !== stateBytes) throw new GameError("invalid_argument", "the replay state does not match its layout");
+  let state = bytes.slice(stateAt, inputsAt), stateDigestHex = hexOf(bytes.subarray((32), (32) + SHA256_BYTES));
+  if (digestOf(state) !== stateDigestHex) throw new GameError("invalid_argument", "the replay state does not match its digest");
+  return {
+    manifest: {
+      version: flags.version,
+      interactive_id: decoder.decode(bytes.subarray(sectionsEnd, sectionsEnd + idBytes)),
+      revision: decoder.decode(bytes.subarray(sectionsEnd + idBytes, stateAt)),
+      tick_hz: view.getUint16((8), (true)),
+      start_tick: view.getUint32((12), (true)),
+      ticks,
+      input_stride: stride,
+      sections,
+      play_from_here: flags.play_from_here,
+      state_digest: stateDigestHex,
+      final_digest: hexOf(bytes.subarray(FINAL_DIGEST_AT, FINAL_DIGEST_AT + SHA256_BYTES))
+    },
+    state,
+    inputs: bytes.slice(inputsAt)
+  };
+}
+var ReplayClipRecorder = class {
+  constructor(sim, options) {
+    this.options = options;
+    this.slots = new Uint8Array(0);
+    this.last = (-1);
+    this.first = (-1);
+    this.breaks = 0;
+    if (!Number.isInteger(options.keyframe_every) || options.keyframe_every < 1) throw new GameError("invalid_argument", "keyframes come every whole number of ticks");
+    this.layout = new StateLayout(sim.states), this.keyframes = Math.ceil(options.window_ticks / options.keyframe_every) + 1, this.keyTicks = new Float64Array(this.keyframes).fill((-1)), this.inputTicks = options.window_ticks + options.keyframe_every, this.inputs = new Uint8Array(this.inputTicks * options.input_stride);
+  }
+  reset() {
+    this.first !== (-1) && this.breaks++, this.keyTicks.fill((-1)), this.first = (-1), this.last = (-1);
+  }
+  record(tick, input) {
+    if (this.layout.changed() && (this.layout.relayout(), this.slots.length !== this.layout.bytes * this.keyframes && (this.slots = new Uint8Array(this.layout.bytes * this.keyframes)), this.reset()), this.last !== (-1) && tick !== this.last + 1 && this.reset(), this.first === (-1)) {
+      if (tick % this.options.keyframe_every !== 0) return;
+      this.first = tick;
+    }
+    if (tick % this.options.keyframe_every === 0) {
+      let slot = tick / this.options.keyframe_every % this.keyframes;
+      this.layout.save(this.slots, slot * this.layout.bytes), this.keyTicks[slot] = tick;
+    }
+    let stride = this.options.input_stride, at = tick % this.inputTicks * stride, inputs = this.inputs;
+    for (let i = 0; i < stride; i++) inputs[at + i] = i < input.length ? input[i] : 0;
+    this.last = tick;
+  }
+  get recordedTicks() {
+    return this.first === (-1) ? 0 : this.last - this.first + 1;
+  }
+  keyframeFor(ticks) {
+    let end = this.last + 1, target = end - ticks, oldestInput = end - this.inputTicks, best = (-1), oldest = (-1);
+    for (let slot = 0; slot < this.keyframes; slot++) {
+      let tick = this.keyTicks[slot];
+      tick === (-1) || tick < oldestInput || tick < this.first || tick > this.last || ((oldest === (-1) || tick < oldest) && (oldest = tick), tick <= target && tick > best && (best = tick));
+    }
+    return best === (-1) ? oldest : best;
+  }
+  keep(ticks) {
+    if (this.first === (-1)) return null;
+    let start = this.keyframeFor(ticks);
+    if (start === (-1)) return null;
+    let layout = this.layout, slot = start / this.options.keyframe_every % this.keyframes, state = this.slots.slice(slot * layout.bytes, (slot + 1) * layout.bytes), count = this.last - start + 1, stride = this.options.input_stride, inputs = new Uint8Array(count * stride);
+    for (let t = 0; t < count; t++) {
+      let from = (start + t) % this.inputTicks * stride;
+      inputs.set(this.inputs.subarray(from, from + stride), t * stride);
+    }
+    let current = new Uint8Array(layout.bytes);
+    return layout.save(current, 0), {
+      manifest: {
+        version: (1),
+        interactive_id: this.options.interactive_id,
+        revision: this.options.revision,
+        tick_hz: this.options.tick_hz,
+        start_tick: start,
+        ticks: count,
+        input_stride: stride,
+        sections: layout.sections(),
+        play_from_here: this.options.play_from_here,
+        state_digest: digestOf(state),
+        final_digest: digestOf(current)
+      },
+      state,
+      inputs
+    };
+  }
+};
+function simulateReplay(clip, sim) {
+  let layout = new StateLayout(sim.states);
+  layout.relayout();
+  let sections = layout.sections(), expected = clip.manifest.sections;
+  if (sections.length !== expected.length || sections.some((bytes, i) => bytes !== expected[i]))
+    throw new GameError("invalid_argument", "this replay was recorded with a different game state layout");
+  layout.load(clip.state);
+  let stride = clip.manifest.input_stride, input = new Uint8Array(stride), start = clip.manifest.start_tick;
+  for (let t = 0; t < clip.manifest.ticks; t++) {
+    let from = t * stride;
+    for (let i = 0; i < stride; i++) input[i] = clip.inputs[from + i];
+    sim.step(start + t, input);
+  }
+  let current = new Uint8Array(layout.bytes);
+  layout.save(current, 0);
+  let digest = digestOf(current);
+  return { digest, matches: digest === clip.manifest.final_digest, next_tick: start + clip.manifest.ticks };
+}
+function playFromReplay(clip, sim) {
+  if (!clip.manifest.play_from_here) throw new GameError("unsupported_feature", "this game does not let a replay be played on from");
+  let run = simulateReplay(clip, sim);
+  if (!run.matches) throw new GameError("invalid_argument", "this replay does not reproduce on this device");
+  return run;
+}
+
+export { REPLAY_FORMAT_VERSION, ReplayClipRecorder, decodeReplay, encodeReplay, playFromReplay, replayFlags, simulateReplay, stateDigest };