@bloopjs/bloop 0.0.11 → 0.0.12

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloopjs/bloop",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "type": "module",
   "exports": {
     ".": {
@@ -23,7 +23,7 @@
     "@types/bun": "latest"
   },
   "dependencies": {
-    "@bloopjs/engine": "0.0.11"
+    "@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" */
@@ -53,6 +53,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,
@@ -68,6 +69,10 @@ export class Bloop<GS extends BloopSchema> {
 		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,25 +82,30 @@ export class Bloop<GS extends BloopSchema> {
 		const encoder = new TextEncoder();
 		const textBytes = encoder.encode(str);
 
-		const buffer = new Uint8Array(1024*1024);
+		const size = 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 = 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 = 0;
+		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);
+
 	}
 
 	/**
@@ -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,52 @@ describe("tapes", () => {
       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);
+    });
   });
 });