@bloopjs/bloop 0.0.12 → 0.0.13

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloop/bloop",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "license": "MIT",
   "exports": "./src/mod.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloopjs/bloop",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "type": "module",
   "exports": {
     ".": {
@@ -23,7 +23,7 @@
     "@types/bun": "latest"
   },
   "dependencies": {
-    "@bloopjs/engine": "0.0.12"
+    "@bloopjs/engine": "0.0.13"
   },
   "peerDependencies": {
     "typescript": "^5"

package/src/context.ts

@@ -1,4 +1,4 @@
-import type { InputSnapshot } from "@bloopjs/engine";
+import type { EngineTiming, InputSnapshot } from "@bloopjs/engine";
 import type { BloopSchema } from "./data/schema";
 
 export type Context<
@@ -21,67 +21,5 @@ export type Context<
   /** The input snapshot */
   inputs: InputSnapshot;
   /** The timing information for the current frame */
-  time: TimingSnapshot;
+  time: EngineTiming.TimingSnapshot;
 };
-
-export type TimingSnapshot = {
-  /** The number of seconds (usually fractional) since the last frame */
-  dt: number;
-  /** The total number of seconds since the engine started */
-  time: number;
-  /** The number of frames rendered since the engine started */
-  frame: number;
-
-  /** The current frame rate of the engine in frames per second */
-  // fps: number;
-  /** The number of frames rendered since the engine started */
-  highResFrame: bigint;
-  /** The total number of milliseconds since the engine started */
-  highResTime: bigint;
-};
-
-export const TIMING_SNAPSHOT_SIZE = 32;
-
-// these functions should go in engine
-export function encodeTimingSnapshot(
-  ts: TimingSnapshot,
-  target: Uint8Array,
-): number {
-  if (target.byteLength !== TIMING_SNAPSHOT_SIZE) {
-    throw new Error("Target buffer must be exactly 32 bytes");
-  }
-  const view = new DataView(
-    target.buffer,
-    target.byteOffset,
-    target.byteLength,
-  );
-  view.setFloat32(0, ts.dt, true);
-  view.setFloat32(4, ts.time, true);
-  view.setBigUint64(8, ts.highResFrame, true);
-  view.setBigUint64(16, ts.highResTime, true);
-  view.setUint32(24, ts.frame, true);
-  return TIMING_SNAPSHOT_SIZE;
-}
-
-export function decodeTimingSnapshot(
-  source: Uint8Array,
-  target: TimingSnapshot,
-): number {
-  if (source.byteLength !== TIMING_SNAPSHOT_SIZE) {
-    throw new Error(
-      `Source buffer must be exactly ${TIMING_SNAPSHOT_SIZE} bytes`,
-    );
-  }
-  const view = new DataView(
-    source.buffer,
-    source.byteOffset,
-    source.byteLength,
-  );
-  target.dt = view.getFloat32(0, true);
-  target.time = view.getFloat32(4, true);
-  target.highResFrame = view.getBigUint64(8, true);
-  target.highResTime = view.getBigUint64(16, true);
-  target.frame = view.getUint32(24, true);
-
-  return TIMING_SNAPSHOT_SIZE;
-}

package/src/mod.ts

@@ -1,8 +1,9 @@
 import type { BloopSchema } from "./data/schema";
 import type { Bag } from "./data/bag";
 import type { System } from "./system";
-import { EngineInputs, type PlatformEvent } from "@bloopjs/engine";
-import { decodeTimingSnapshot, encodeTimingSnapshot, TIMING_SNAPSHOT_SIZE, type Context } from "./context";
+import { EngineTiming, EngineInputs, type PlatformEvent } from "@bloopjs/engine";
+import { type Context } from "./context";
+import { TIMING_SNAPSHOT_SIZE } from "../../engine/js/timing";
 
 export type BloopOpts<B extends Bag> = {
   /** defaults to "Game" */
@@ -65,7 +66,7 @@ export class Bloop<GS extends BloopSchema> {
     };
 	}
 
-	get bag() {
+	get bag(): GS["B"] {
 		return this.#context.bag;
 	}
 
@@ -82,11 +83,11 @@ export class Bloop<GS extends BloopSchema> {
 		const encoder = new TextEncoder();
 		const textBytes = encoder.encode(str);
 
-		const size = TIMING_SNAPSHOT_SIZE + 4 + textBytes.length;
+		const size = EngineTiming.TIMING_SNAPSHOT_SIZE + 4 + textBytes.length;
 
 		const buffer = new Uint8Array(size);
 		const view = new DataView(buffer.buffer);
-		let offset = encodeTimingSnapshot(this.#context.time, buffer.subarray(0, TIMING_SNAPSHOT_SIZE));
+		let offset = EngineTiming.encodeTimingSnapshot(this.#context.time, buffer.subarray(0, EngineTiming.TIMING_SNAPSHOT_SIZE));
 		view.setUint32(offset, textBytes.length, true);
 		offset += 4;
 
@@ -96,16 +97,15 @@ export class Bloop<GS extends BloopSchema> {
 	}
 
 	restore(snapshot: Uint8Array) {
-		const size = decodeTimingSnapshot(new Uint8Array(snapshot.buffer, 0, 32), this.#context.time);
+		const size = EngineTiming.decodeTimingSnapshot(new Uint8Array(snapshot.buffer, 0, EngineTiming.TIMING_SNAPSHOT_SIZE), this.#context.time);
 		const view = new DataView(snapshot.buffer);
 		let offset = size;
-		const length = view.getUint32(0, true);
+		const length = view.getUint32(offset, true);
 		offset += 4;
 		const bagBytes = snapshot.slice(offset, offset + length);
 		const decoder = new TextDecoder();
 		const str = decoder.decode(bagBytes);
 		this.#context.bag = JSON.parse(str);
-
 	}
 
 	/**

package/test/tape.test.ts

@@ -30,13 +30,22 @@ describe("tapes", () => {
       expect(bloop.bag.cool).toEqual(43);
     });
 
-    it("snapshots time", async () => {
+    it("can snapshot the bag on frame 0", async () => {
       const bloop = Bloop.create({
         bag: {
-          nope: 10,
+          score: 10,
         },
       });
 
+      await mount(bloop);
+      const snapshot = bloop.snapshot();
+      bloop.restore(snapshot);
+      expect(bloop.bag.score).toEqual(10);
+    });
+
+    it("snapshots time", async () => {
+      const bloop = Bloop.create();
+
       const timeCheck = {
         dt: 0,
         time: 0,
@@ -77,4 +86,42 @@ describe("tapes", () => {
       expect(bloop.context.time.frame).toEqual(2);
     });
   });
+
+  describe("playback", () => {
+    it("can play back inputs", async () => {
+      const bloop = Bloop.create({
+        bag: {
+          clicks: 0,
+        },
+      });
+
+      bloop.system("countClicks", {
+        update({ bag, inputs }) {
+          if (inputs.mouse.left.down) {
+            bag.clicks++;
+          }
+        },
+      });
+
+      const { runtime, emitter } = await mount(bloop);
+
+      runtime.record();
+      emitter.mousedown("Left");
+      runtime.step();
+      expect(bloop.context.time.frame).toEqual(1);
+      expect(bloop.bag.clicks).toEqual(1);
+      emitter.mouseup("Left");
+      runtime.step();
+      expect(bloop.context.time.frame).toEqual(2);
+      expect(bloop.bag.clicks).toEqual(1);
+
+      runtime.stepBack();
+      expect(bloop.context.time.frame).toEqual(1);
+      expect(bloop.bag.clicks).toEqual(1);
+
+      runtime.stepBack();
+      expect(bloop.context.time.frame).toEqual(0);
+      expect(bloop.bag.clicks).toEqual(0);
+    });
+  });
 });