@bloopjs/bloop 0.0.11 → 0.0.13

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloopjs/bloop",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "type": "module",
   "exports": {
     ".": {
@@ -23,7 +23,7 @@
     "@types/bun": "latest"
   },
   "dependencies": {
-    "@bloopjs/engine": "0.0.11"
+    "@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,21 +21,5 @@ export type Context<
   /** The input snapshot */
   inputs: InputSnapshot;
   /** The timing information for the current frame */
-  time: 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;
+  time: EngineTiming.TimingSnapshot;
 };

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 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" */
@@ -53,6 +54,7 @@ export class Bloop<GS extends BloopSchema> {
 
 		this.#context = {
       bag: opts.bag ?? {},
+			// todo: this should be a pointer to memory managed by the engine
       inputs: new EngineInputs.InputSnapshot(new DataView(new ArrayBuffer(100))),
       time: {
 				dt: 0,
@@ -64,10 +66,14 @@ export class Bloop<GS extends BloopSchema> {
     };
 	}
 
-	get bag() {
+	get bag(): GS["B"] {
 		return this.#context.bag;
 	}
 
+	get context() : Readonly<Context<GS>> {
+		return this.#context;
+	}
+
 	/**
 	 * Take a snapshot of the game state
 	 * @returns linear memory representation of the game state
@@ -77,20 +83,24 @@ export class Bloop<GS extends BloopSchema> {
 		const encoder = new TextEncoder();
 		const textBytes = encoder.encode(str);
 
-		const buffer = new Uint8Array(1024*1024);
+		const size = EngineTiming.TIMING_SNAPSHOT_SIZE + 4 + textBytes.length;
+
+		const buffer = new Uint8Array(size);
 		const view = new DataView(buffer.buffer);
-		let offset = 0;
-		view.setUint32(0, textBytes.length, true);
+		let offset = EngineTiming.encodeTimingSnapshot(this.#context.time, buffer.subarray(0, EngineTiming.TIMING_SNAPSHOT_SIZE));
+		view.setUint32(offset, textBytes.length, true);
 		offset += 4;
+
 		buffer.set(textBytes, offset);
 		offset += textBytes.length;
 		return buffer;
 	}
 
 	restore(snapshot: Uint8Array) {
+		const size = EngineTiming.decodeTimingSnapshot(new Uint8Array(snapshot.buffer, 0, EngineTiming.TIMING_SNAPSHOT_SIZE), this.#context.time);
 		const view = new DataView(snapshot.buffer);
-		let offset = 0;
-		const length = view.getUint32(0, true);
+		let offset = size;
+		const length = view.getUint32(offset, true);
 		offset += 4;
 		const bagBytes = snapshot.slice(offset, offset + length);
 		const decoder = new TextDecoder();
@@ -108,8 +118,14 @@ export class Bloop<GS extends BloopSchema> {
 		return this.#systems.length;
 	}
 
-	systemsCallback(events: PlatformEvent[]) {
+	// todo - get data from ptr
+	systemsCallback(ptr: number, events: PlatformEvent[], dt: number) {
 		this.#context.inputs.update(events);
+		const dtSeconds = dt / 1000;
+		this.#context.time.dt = dtSeconds;
+		this.#context.time.time += dtSeconds;
+		this.#context.time.highResTime += BigInt(dt);
+
 		for (const system of this.#systems) {
 			system.update?.(this.#context);
 
@@ -174,6 +190,11 @@ export class Bloop<GS extends BloopSchema> {
 				}
 			}
 		}
+
+		// do this in the engine snapshot
+		this.#context.time.frame++;
+		this.#context.time.highResFrame += 1n;
+
 		this.#context.inputs.flush();
 	}
 }

package/test/tape.test.ts

@@ -29,5 +29,99 @@ describe("tapes", () => {
       bloop.restore(snapshot);
       expect(bloop.bag.cool).toEqual(43);
     });
+
+    it("can snapshot the bag on frame 0", async () => {
+      const bloop = Bloop.create({
+        bag: {
+          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,
+        frame: 0,
+      };
+
+      bloop.system("timeCheck", {
+        update({ time }) {
+          timeCheck.dt = time.dt;
+          timeCheck.time = time.time;
+          timeCheck.frame = time.frame;
+        },
+      });
+
+      const { runtime } = await mount(bloop);
+
+      runtime.step();
+
+      expect(timeCheck.dt).toBeCloseTo(0.016);
+      expect(timeCheck.time).toBeCloseTo(0.016);
+      expect(timeCheck.frame).toEqual(0);
+      expect(bloop.context.time.frame).toEqual(1);
+
+      const snapshot = bloop.snapshot();
+
+      runtime.step();
+      expect(timeCheck.dt).toBeCloseTo(0.016);
+      expect(timeCheck.time).toBeCloseTo(0.016 * 2);
+      expect(timeCheck.frame).toEqual(1);
+      expect(bloop.context.time.frame).toEqual(2);
+
+      bloop.restore(snapshot);
+      expect(bloop.context.time.frame).toEqual(1);
+      runtime.step();
+
+      expect(timeCheck.dt).toBeCloseTo(0.016);
+      expect(timeCheck.time).toBeCloseTo(0.016 * 2);
+      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);
+    });
   });
 });