@bloopjs/bloop 0.0.10 → 0.0.12

package/jsr.json

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

package/package.json

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

package/src/context.ts

@@ -39,3 +39,49 @@ export type TimingSnapshot = {
   /** 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

@@ -2,7 +2,7 @@ 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 { decodeTimingSnapshot, encodeTimingSnapshot, TIMING_SNAPSHOT_SIZE, type Context } from "./context";
 
 export type BloopOpts<B extends Bag> = {
   /** defaults to "Game" */
@@ -29,7 +29,6 @@ type MakeGS<B extends Bag> = BloopSchema<B>;
 
 export class Bloop<GS extends BloopSchema> {
 	#systems: System<GS>[] = [];
-	#bag: GS["B"];
 	#context: Context<GS>;
 
 	/**
@@ -52,9 +51,9 @@ export class Bloop<GS extends BloopSchema> {
 			);
 		}
 
-		this.#bag = opts.bag ?? {};
 		this.#context = {
-      bag: this.#bag,
+      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,
@@ -67,21 +66,66 @@ export class Bloop<GS extends BloopSchema> {
 	}
 
 	get bag() {
-		return this.#bag;
+		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
+	 */
+	snapshot(): Uint8Array {
+		const str = JSON.stringify(this.#context.bag);
+		const encoder = new TextEncoder();
+		const textBytes = encoder.encode(str);
+
+		const size = 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));
+		view.setUint32(offset, textBytes.length, true);
+		offset += 4;
+
+		buffer.set(textBytes, offset);
+		offset += textBytes.length;
+		return buffer;
+	}
+
+	restore(snapshot: Uint8Array) {
+		const size = decodeTimingSnapshot(new Uint8Array(snapshot.buffer, 0, 32), this.#context.time);
+		const view = new DataView(snapshot.buffer);
+		let offset = size;
+		const length = view.getUint32(0, 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);
+
 	}
 
 	/**
 	 * Register a system with the game loop.
 	 *
 	 */
-	system(label: string, system: System): number {
+	system(label: string, system: System<GS>): number {
 		system.label ??= label;
 		this.#systems.push(system);
 		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);
 
@@ -146,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

@@ -0,0 +1,80 @@
+import { it, expect, describe } from "bun:test";
+import { mount } from "@bloopjs/engine";
+import { Bloop } from "../src/mod";
+
+describe("tapes", () => {
+  describe("snapshots", () => {
+    it("can snapshot the bag", async () => {
+      const bloop = Bloop.create({
+        bag: {
+          cool: 42,
+        },
+      });
+
+      bloop.system("inc", {
+        update({ bag }) {
+          bag.cool++;
+        },
+      });
+
+      const { runtime } = await mount(bloop);
+      runtime.step();
+
+      expect(bloop.bag.cool).toEqual(43);
+      const snapshot = bloop.snapshot();
+
+      runtime.step();
+      expect(bloop.bag.cool).toEqual(44);
+
+      bloop.restore(snapshot);
+      expect(bloop.bag.cool).toEqual(43);
+    });
+
+    it("snapshots time", async () => {
+      const bloop = Bloop.create({
+        bag: {
+          nope: 10,
+        },
+      });
+
+      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);
+    });
+  });
+});