@bloopjs/bloop 0.0.12 → 0.0.14

package/jsr.json

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

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@bloopjs/bloop",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bloopgames/bloop"
+  },
   "exports": {
     ".": {
       "import": "./dist/mod.js",
@@ -23,7 +27,7 @@
     "@types/bun": "latest"
   },
   "dependencies": {
-    "@bloopjs/engine": "0.0.12"
+    "@bloopjs/engine": "0.0.14"
   },
   "peerDependencies": {
     "typescript": "^5"

package/src/bloop.ts

@@ -0,0 +1,239 @@
+import {
+  type EnginePointer,
+  Enums,
+  EVENT_PAYLOAD_ALIGN,
+  EVENT_PAYLOAD_SIZE,
+  EVENTS_OFFSET,
+  INPUT_CTX_OFFSET,
+  InputContext,
+  keyCodeToKey,
+  mouseButtonCodeToMouseButton,
+  TIME_CTX_OFFSET,
+  TimeContext,
+} from "@bloopjs/engine";
+import type { Context } from "./context";
+import type { Bag } from "./data/bag";
+import type { BloopSchema } from "./data/schema";
+import type {
+  InputEvent,
+  KeyEvent,
+  MouseButtonEvent,
+  MouseMoveEvent,
+  MouseWheelEvent,
+} from "./events";
+import type { DeserializeFn, SerializeFn } from "./runtime";
+import type { System } from "./system";
+
+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;
+};
+
+export class Bloop<GS extends BloopSchema> {
+  #systems: System<GS>[] = [];
+  #context: Context<GS>;
+  #engineBuffer: ArrayBuffer = new ArrayBuffer(0);
+
+  /**
+   * 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.",
+      );
+    }
+
+    this.#context = {
+      bag: opts.bag ?? {},
+      time: new TimeContext(),
+      inputs: new InputContext(),
+      rawPointer: -1,
+    };
+  }
+
+  get bag(): GS["B"] {
+    return this.#context.bag;
+  }
+
+  get context(): Readonly<Context<GS>> {
+    return this.#context;
+  }
+
+  /**
+   * Take a snapshot of the game state outside the engine
+   * @returns linear memory representation of the game state that the engine is unaware of
+   */
+  serialize = (): ReturnType<SerializeFn> => {
+    const str = JSON.stringify(this.#context.bag);
+    const encoder = new TextEncoder();
+    const textBytes = encoder.encode(str);
+
+    return {
+      size: textBytes.byteLength,
+      write: (buffer: ArrayBufferLike, ptr: EnginePointer) => {
+        const memoryView = new Uint8Array(buffer, ptr, textBytes.byteLength);
+        memoryView.set(textBytes);
+      },
+    };
+  };
+
+  /**
+   * Restore a snapshot of the game state outside the engine
+   * @returns linear memory representation of the game state that the engine is unaware of
+   */
+  deserialize: DeserializeFn = (buffer, ptr, len) => {
+    const bagBytes = new Uint8Array(buffer, ptr, len);
+    const decoder = new TextDecoder();
+    const str = decoder.decode(bagBytes);
+
+    try {
+      this.#context.bag = JSON.parse(str);
+    } catch (e) {
+      console.error("failed to deserialize bag", { json: str, error: e });
+    }
+  };
+
+  /**
+   * Register a system with the game loop.
+   *
+   */
+  system(label: string, system: System<GS>): number {
+    system.label ??= label;
+    this.#systems.push(system);
+    return this.#systems.length;
+  }
+
+  systemsCallback(system_handle: number, ptr: EnginePointer) {
+    // todo - move this to engine
+    const dv = new DataView(this.#engineBuffer, ptr);
+    const timeCtxPtr = dv.getUint32(TIME_CTX_OFFSET, true);
+    const inputCtxPtr = dv.getUint32(INPUT_CTX_OFFSET, true);
+    const eventsPtr = dv.getUint32(EVENTS_OFFSET, true);
+
+    this.#context.rawPointer = ptr;
+    this.#context.inputs.dataView = new DataView(
+      this.#engineBuffer,
+      inputCtxPtr,
+    );
+    this.#context.time.dataView = new DataView(this.#engineBuffer, timeCtxPtr);
+
+    const eventsDataView = new DataView(this.#engineBuffer, eventsPtr);
+
+    for (const system of this.#systems) {
+      system.update?.(this.#context);
+
+      const eventCount = eventsDataView.getUint32(0, true);
+
+      let offset = Uint32Array.BYTES_PER_ELEMENT;
+
+      for (let i = 0; i < eventCount; i++) {
+        const eventType = eventsDataView.getUint8(offset);
+        const payloadSize = EVENT_PAYLOAD_SIZE;
+        const payloadByte = eventsDataView.getUint8(
+          offset + EVENT_PAYLOAD_ALIGN,
+        );
+        const payloadVec2 = {
+          x: eventsDataView.getFloat32(offset + EVENT_PAYLOAD_ALIGN, true),
+          y: eventsDataView.getFloat32(
+            offset + EVENT_PAYLOAD_ALIGN + Float32Array.BYTES_PER_ELEMENT,
+            true,
+          ),
+        };
+
+        switch (eventType) {
+          case Enums.EventType.KeyDown: {
+            system.keydown?.(
+              attachEvent<KeyEvent, GS>(this.#context, {
+                key: keyCodeToKey(payloadByte),
+              }),
+            );
+            break;
+          }
+          case Enums.EventType.KeyUp:
+            system.keyup?.(
+              attachEvent<KeyEvent, GS>(this.#context, {
+                key: keyCodeToKey(payloadByte),
+              }),
+            );
+            break;
+          case Enums.EventType.MouseDown:
+            system.mousedown?.(
+              attachEvent<MouseButtonEvent, GS>(this.#context, {
+                button: mouseButtonCodeToMouseButton(payloadByte),
+              }),
+            );
+            break;
+          case Enums.EventType.MouseUp:
+            system.mouseup?.(
+              attachEvent<MouseButtonEvent, GS>(this.#context, {
+                button: mouseButtonCodeToMouseButton(payloadByte),
+              }),
+            );
+            break;
+          case Enums.EventType.MouseMove:
+            system.mousemove?.(
+              attachEvent<MouseMoveEvent, GS>(this.#context, {
+                x: payloadVec2.x,
+                y: payloadVec2.y,
+              }),
+            );
+            break;
+          case Enums.EventType.MouseWheel:
+            system.mousewheel?.(
+              attachEvent<MouseWheelEvent, GS>(this.#context, {
+                x: payloadVec2.x,
+                y: payloadVec2.y,
+              }),
+            );
+            break;
+          default:
+            throw new Error(`Unknown event type: ${eventType}`);
+        }
+        // the event type u8 + padding + payload
+        offset += EVENT_PAYLOAD_ALIGN + EVENT_PAYLOAD_SIZE;
+      }
+      (this.#context as any).event = undefined;
+    }
+  }
+
+  setBuffer(buffer: ArrayBuffer) {
+    this.#engineBuffer = buffer;
+  }
+}
+
+function attachEvent<IE extends InputEvent, GS extends BloopSchema>(
+  context: Context<GS>,
+  event: IE,
+): Context<GS> & { event: IE } {
+  (context as any).event = event;
+  return context as Context<GS> & { event: IE };
+}
+
+type MakeGS<B extends Bag> = BloopSchema<B>;

package/src/context.ts

@@ -1,4 +1,4 @@
-import type { InputSnapshot } from "@bloopjs/engine";
+import type { EnginePointer, InputContext, TimeContext } from "@bloopjs/engine";
 import type { BloopSchema } from "./data/schema";
 
 export type Context<
@@ -8,8 +8,6 @@ export type Context<
 > = {
   /** 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 */
@@ -18,70 +16,10 @@ export type Context<
   // 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 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: TimeContext;
+  /** The input snapshot */
+  inputs: InputContext;
+  /** The engine pointer to the injected system arguments (for advanced use cases) */
+  rawPointer: EnginePointer;
 };
-
-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/events.ts

@@ -0,0 +1,25 @@
+import type { Key, MouseButton } from "@bloopjs/engine";
+
+export type InputEvent =
+  | KeyEvent
+  | MouseButtonEvent
+  | MouseMoveEvent
+  | MouseWheelEvent;
+
+export type KeyEvent = {
+  key: Key;
+};
+
+export type MouseButtonEvent = {
+  button: MouseButton;
+};
+
+export type MouseMoveEvent = {
+  x: number;
+  y: number;
+};
+
+export type MouseWheelEvent = {
+  x: number;
+  y: number;
+};

package/src/mod.ts

@@ -1,201 +1,4 @@
-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 { decodeTimingSnapshot, encodeTimingSnapshot, TIMING_SNAPSHOT_SIZE, type Context } from "./context";
-
-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>[] = [];
-	#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."
-			);
-		}
-
-		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,
-				time: 0,
-				frame: 0,
-				highResFrame: 0n,
-				highResTime: 0n,
-			},
-    };
-	}
-
-	get 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<GS>): number {
-		system.label ??= label;
-		this.#systems.push(system);
-		return this.#systems.length;
-	}
-
-	// 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);
-
-			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;
-				}
-			}
-		}
-
-		// do this in the engine snapshot
-		this.#context.time.frame++;
-		this.#context.time.highResFrame += 1n;
-
-		this.#context.inputs.flush();
-	}
-}
+export * from "./runtime"
+export * from "./bloop"
 
+export * as Util from "./util";