@bloopjs/bloop 0.0.8 → 0.0.10

package/jsr.json

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

package/package.json

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

package/src/context.ts

@@ -1,7 +1,41 @@
-import type { GameSchema } from "./schema";
+import type { InputSnapshot } from "@bloopjs/engine";
+import type { BloopSchema } from "./data/schema";
 
-// export type Context<GS extends GameSchema> = {
-//   GS: GS;
-// };
+export type Context<
+  GS extends BloopSchema = BloopSchema,
+  // Q extends Query<GS["CS"]> = Query<GS["CS"]>,
+  // QS extends readonly Query<GS["CS"]>[] = readonly Query<GS["CS"]>[],
+> = {
+  /** The wrapper to the engine instance */
+  // engine: Bridge<GS["CS"]>;
+  /** The engine pointer to the injected system arguments (for advanced use cases) */
+  // rawPointer: EnginePointer;
+  /** Result of any resources requested */
+  // resources: ResourcesResult<GS["RS"], R>;
+  /** Result of the main query if there was one */
+  // query: ResultsIterator<GS["CS"], Q>;
+  /** Results of multiple queries if there were any */
+  // queries: QueriesResults<GS["CS"], QS>;
+  /** The bag of values for the system */
+  bag: GS["B"];
+  /** The input snapshot */
+  inputs: InputSnapshot;
+  /** The timing information for the current frame */
+  time: TimingSnapshot;
+};
 
-export type Context<GS extends GameSchema> = unknown;
+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;
+};

package/src/data/bag.ts

@@ -0,0 +1,15 @@
+/**
+ * A bag of serializable values that can be recorded to a snapshot
+ */
+export interface Bag {
+  [key: string]: BagValue;
+}
+
+export type BagValue =
+  | string
+  | number
+  | boolean
+  | BagValue[]
+  | Bag
+  | Uint8Array
+  | null;

package/src/data/schema.ts

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

package/src/mod.ts

@@ -1,86 +1,152 @@
+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";
 
-type BloopLoop = {
-	system: (label: string, system: System) => void;
-	systemsCallback: (events: PlatformEvent[]) => void;
-}
+export type BloopOpts<B extends Bag> = {
+  /** defaults to "Game" */
+  name?: string;
+  /**
+   * component definitions, defaults to empty object
+   *
+   * use `defineComponents` to generate component definitions from a simple schema
+   */
+  // components?: SchemaWithLayout<CS>;
+  /**
+   * input map, defaults to empty object
+   */
+  // inputMap?: IM;
+  /**
+   * bag definition, defaults to empty object
+   *
+   */
+	bag?: B
+	// schema: GS;
+};
+
+type MakeGS<B extends Bag> = BloopSchema<B>;
+
+export class Bloop<GS extends BloopSchema> {
+	#systems: System<GS>[] = [];
+	#bag: GS["B"];
+	#context: Context<GS>;
+
+	/**
+   * Bloop.create() is the way to create a new bloop instance.
+   */
+  static create<
+    // S extends Schema,
+    // RS extends ResourceSchema,
+    B extends Bag,
+    // const IM extends InputMap,
+  // >(opts: GameOpts<S, RS, B, IM> = {}) {
+  >(opts: BloopOpts<B> = {}): Bloop<MakeGS<B>> {
+    return new Bloop<MakeGS<B>>(opts, "dontCallMeDirectly");
+  }
+
+	constructor(opts: BloopOpts<GS["B"]> = {}, dontCallMeDirectly: string) {
+		if (dontCallMeDirectly !== "dontCallMeDirectly") {
+			throw new Error(
+				"Bloop constructor is private. Use Bloop.create() to create a new game instance."
+			);
+		}
 
-export function Bloop(): BloopLoop {
-	const systems = [] as System[];
+		this.#bag = opts.bag ?? {};
+		this.#context = {
+      bag: this.#bag,
+      inputs: new EngineInputs.InputSnapshot(new DataView(new ArrayBuffer(100))),
+      time: {
+				dt: 0,
+				time: 0,
+				frame: 0,
+				highResFrame: 0n,
+				highResTime: 0n,
+			},
+    };
+	}
+
+	get bag() {
+		return this.#bag;
+	}
+
+	/**
+	 * Register a system with the game loop.
+	 *
+	 */
+	system(label: string, system: System): number {
+		system.label ??= label;
+		this.#systems.push(system);
+		return this.#systems.length;
+	}
 
-	return {
-		system(label: string, system: System) {
-			systems.push(system);
-		},
-		systemsCallback: (events: PlatformEvent[]) => {
-			for (const system of systems) {
-				system.update?.();
+	systemsCallback(events: PlatformEvent[]) {
+		this.#context.inputs.update(events);
+		for (const system of this.#systems) {
+			system.update?.(this.#context);
 
-				for (const event of events) {
-					switch(event.type) {
-						case "keydown":
-							system.keydown?.({
-								event: {
-									key: event.key,
-									pressure: 1,
-								}
-							})
-							break;
-						case "keyheld":
-							system.keyheld?.({
-								event: {
-									key: event.key,
-									pressure: 1,
-								}
-							})
-							break;
-						case "keyup":
-							system.keyup?.({
-								event: {
-									key: event.key,
-									pressure: 0,
-								}
-							})
-							break;
-						case "mousemove":
-							system.mousemove?.({
-								event: {
-									x: event.x,
-									y: event.y,
-								}
-							})
-							break;
-						case "mousedown":
-							system.mousedown?.({
-								event: {
-									button: event.button,
-									pressure: event.pressure,
-								}
-							})
-							break;
-						case "mouseup":
-							system.mouseup?.({
-								event: {
-									button: event.button,
-									pressure: event.pressure,
-								}
-							})
-							break;
-						case "mousewheel":
-							system.mousewheel?.({
-								event: {
-									x: event.x,
-									y: event.y,
-								}
-							})
-							break;
-						default:
-							break;
-					}
+			for (const event of events) {
+				switch(event.type) {
+					case "keydown":
+						system.keydown?.({
+							...this.#context,
+							event: {
+								key: event.key,
+								pressure: 1,
+							}
+						})
+						break;
+					case "keyup":
+						system.keyup?.({
+							...this.#context,
+							event: {
+								key: event.key,
+								pressure: 0,
+							}
+						})
+						break;
+					case "mousemove":
+						system.mousemove?.({
+							...this.#context,
+							event: {
+								x: event.x,
+								y: event.y,
+							}
+						})
+						break;
+					case "mousedown":
+						system.mousedown?.({
+							...this.#context,
+							event: {
+								button: event.button,
+								pressure: event.pressure,
+							}
+						})
+						break;
+					case "mouseup":
+						system.mouseup?.({
+							...this.#context,
+							event: {
+								button: event.button,
+								pressure: event.pressure,
+							}
+						})
+						break;
+					case "mousewheel":
+						system.mousewheel?.({
+							...this.#context,
+							event: {
+								x: event.x,
+								y: event.y,
+							}
+						})
+						break;
+					default:
+						break;
 				}
 			}
 		}
+		this.#context.inputs.flush();
 	}
 }
 

package/src/system.ts

@@ -5,10 +5,12 @@ import type {
   MouseWheelEvent,
 } from "@bloopjs/engine";
 import type { Context } from "./context";
-import type { GameSchema } from "./schema";
+import type { BloopSchema } from "./data/schema";
 
-export type System<GS extends GameSchema = GameSchema> = {
-  update?: () => void;
+export type System<GS extends BloopSchema = BloopSchema> = {
+  label?: string;
+
+  update?: (context: Context<GS>) => void;
 
   keydown?: (
     context: Context<GS> & {
@@ -22,12 +24,6 @@ export type System<GS extends GameSchema = GameSchema> = {
     },
   ) => void;
 
-  keyheld?: (
-    context: Context<GS> & {
-      event: KeyEvent;
-    },
-  ) => void;
-
   mousedown?: (
     context: Context<GS> & {
       event: MouseButtonEvent;

package/test/inputs.test.ts

@@ -4,7 +4,7 @@ import { Bloop } from "../src/mod";
 
 describe("loop", () => {
   it("runs a single system", async () => {
-    const bloop = Bloop();
+    const bloop = Bloop.create();
     let count = 0;
 
     bloop.system("test", {
@@ -20,16 +20,14 @@ describe("loop", () => {
   });
 
   it("passes through input events", async () => {
-    const bloop = Bloop();
+    const bloop = Bloop.create();
 
     const events = {
       keydown: null as Key | null,
       keyup: null as Key | null,
-      keyheld: null as Key | null,
 
       mousemove: null as { x: number; y: number } | null,
       mousedown: null as MouseButton | null,
-      mouseheld: null as MouseButton | null,
       mouseup: null as MouseButton | null,
       mousewheel: null as { x: number; y: number } | null,
     };
@@ -41,9 +39,6 @@ describe("loop", () => {
       keyup({ event }) {
         events.keyup = event.key;
       },
-      keyheld({ event }) {
-        events.keyheld = event.key;
-      },
       mousemove({ event }) {
         events.mousemove = { x: event.x, y: event.y };
       },
@@ -83,7 +78,85 @@ describe("loop", () => {
     expect(events.mousemove).toEqual({ x: 3, y: 4 });
   });
 
-  it.skip("keeps track of keyboard and mouse snapshots", async () => {});
+  it("keeps track of keyboard and mouse snapshots", async () => {
+    const bloop = Bloop.create({
+      bag: {
+        cool: "nice",
+      },
+    });
+
+    const events = {
+      keydown: null as boolean | null,
+      keyheld: null as boolean | null,
+      keyup: null as boolean | null,
+      mouseheld: null as boolean | null,
+      mousedown: null as boolean | null,
+      mouseup: null as boolean | null,
+    };
+
+    bloop.system("input snapshots", {
+      update({ inputs }) {
+        events.keydown = inputs.keys.space.down;
+        events.keyheld = inputs.keys.space.held;
+        events.keyup = inputs.keys.space.up;
+
+        events.mousedown = inputs.mouse.left.down;
+        events.mouseheld = inputs.mouse.left.held;
+        events.mouseup = inputs.mouse.left.up;
+      },
+    });
+
+    const { runtime, emitter } = await mount(bloop);
+
+    // Initial state
+    runtime.step();
+    expect(events).toEqual({
+      keydown: false,
+      keyheld: false,
+      keyup: false,
+      mousedown: false,
+      mouseheld: false,
+      mouseup: false,
+    });
+
+    // down and held are both true on the first frame of a key down
+    emitter.keydown("Space");
+    emitter.mousedown("Left");
+    runtime.step();
+    expect(events).toEqual({
+      keydown: true,
+      keyheld: true,
+      keyup: false,
+      mousedown: true,
+      mouseheld: true,
+      mouseup: false,
+    });
+
+    // held remains true, down goes false
+    runtime.step();
+    expect(events).toEqual({
+      keydown: false,
+      keyheld: true,
+      keyup: false,
+      mousedown: false,
+      mouseheld: true,
+      mouseup: false,
+    });
+
+    // on key up, up is true, held and down are false
+    emitter.keyup("Space");
+    emitter.mouseup("Left");
+    runtime.step();
+    expect(events).toEqual({
+      keydown: false,
+      keyheld: false,
+      keyup: true,
+      mousedown: false,
+      mouseheld: false,
+      mouseup: true,
+    });
+  });
 
-  it.skip('synthesizes "keyheld" and "mouseheld" events', async () => {});
+  it.skip("handles multiple frames between accumulated inputs", async () => {});
+  it.skip("handles down and up between frames", async () => {});
 });

package/src/schema.ts

@@ -1 +0,0 @@
-export type GameSchema = unknown;