@bloopjs/bloop 0.0.9 → 0.0.11

package/jsr.json

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

package/package.json

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

package/src/context.ts

@@ -1,8 +1,8 @@
 import type { InputSnapshot } from "@bloopjs/engine";
-import type { GameSchema } from "./data/schema";
+import type { BloopSchema } from "./data/schema";
 
 export type Context<
-  GS extends GameSchema = GameSchema,
+  GS extends BloopSchema = BloopSchema,
   // Q extends Query<GS["CS"]> = Query<GS["CS"]>,
   // QS extends readonly Query<GS["CS"]>[] = readonly Query<GS["CS"]>[],
 > = {

package/src/data/schema.ts

@@ -1,6 +1,6 @@
 import type { Bag } from "./bag";
 
-export type GameSchema<
+export type BloopSchema<
   // CS extends ComponentSchema = ComponentSchema,
   B extends Bag = Bag,
   // IM extends InputMap = InputMap,

package/src/mod.ts

@@ -1,4 +1,4 @@
-import type { GameSchema } from "./data/schema";
+import type { BloopSchema } from "./data/schema";
 import type { Bag } from "./data/bag";
 import type { System } from "./system";
 import { EngineInputs, type PlatformEvent } from "@bloopjs/engine";
@@ -25,15 +25,14 @@ export type BloopOpts<B extends Bag> = {
 	// schema: GS;
 };
 
-type MakeGS<B extends Bag> = GameSchema<B>;
+type MakeGS<B extends Bag> = BloopSchema<B>;
 
-export class Bloop<GS extends GameSchema> {
+export class Bloop<GS extends BloopSchema> {
 	#systems: System<GS>[] = [];
-	#bag: GS["B"];
 	#context: Context<GS>;
 
 	/**
-   * Bloop.create() is the way to create a new game instance.
+   * Bloop.create() is the way to create a new bloop instance.
    */
   static create<
     // S extends Schema,
@@ -52,9 +51,8 @@ export class Bloop<GS extends GameSchema> {
 			);
 		}
 
-		this.#bag = opts.bag ?? {};
 		this.#context = {
-      bag: this.#bag,
+      bag: opts.bag ?? {},
       inputs: new EngineInputs.InputSnapshot(new DataView(new ArrayBuffer(100))),
       time: {
 				dt: 0,
@@ -67,14 +65,44 @@ export class Bloop<GS extends GameSchema> {
 	}
 
 	get bag() {
-		return this.#bag;
+		return this.#context.bag;
+	}
+
+	/**
+	 * 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 buffer = new Uint8Array(1024*1024);
+		const view = new DataView(buffer.buffer);
+		let offset = 0;
+		view.setUint32(0, textBytes.length, true);
+		offset += 4;
+		buffer.set(textBytes, offset);
+		offset += textBytes.length;
+		return buffer;
+	}
+
+	restore(snapshot: Uint8Array) {
+		const view = new DataView(snapshot.buffer);
+		let offset = 0;
+		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;

package/src/system.ts

@@ -5,9 +5,9 @@ import type {
   MouseWheelEvent,
 } from "@bloopjs/engine";
 import type { Context } from "./context";
-import type { GameSchema } from "./data/schema";
+import type { BloopSchema } from "./data/schema";
 
-export type System<GS extends GameSchema = GameSchema> = {
+export type System<GS extends BloopSchema = BloopSchema> = {
   label?: string;
 
   update?: (context: Context<GS>) => void;

package/test/inputs.test.ts

@@ -156,4 +156,7 @@ describe("loop", () => {
       mouseup: true,
     });
   });
+
+  it.skip("handles multiple frames between accumulated inputs", async () => {});
+  it.skip("handles down and up between frames", async () => {});
 });

package/test/tape.test.ts

@@ -0,0 +1,33 @@
+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);
+    });
+  });
+});