@bloopjs/bloop 0.0.6 → 0.0.8

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloopjs/bloop",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "exports": {
     ".": {
@@ -14,12 +14,17 @@
   "scripts": {
     "build": "bun build src/mod.ts --outdir=dist --sourcemap=linked && bun run build:tsc",
     "build:tsc": "tsc -p publish/tsconfig.publish.json",
+    "ci": "bun run ci:tsc && bun run ci:jsr && bun run build",
     "ci:tsc": "tsc --noEmit",
+    "ci:jsr": "bunx jsr publish --dry-run --allow-dirty",
     "dev": "bun --watch src/mod.ts"
   },
   "devDependencies": {
     "@types/bun": "latest"
   },
+  "dependencies": {
+    "@bloopjs/engine": "0.0.8"
+  },
   "peerDependencies": {
     "typescript": "^5"
   }

package/src/context.ts

@@ -0,0 +1,7 @@
+import type { GameSchema } from "./schema";
+
+// export type Context<GS extends GameSchema> = {
+//   GS: GS;
+// };
+
+export type Context<GS extends GameSchema> = unknown;

package/src/mod.ts

@@ -1,3 +1,86 @@
-export function hello() {
-	console.log("hello");
+import type { System } from "./system";
+import { EngineInputs, type PlatformEvent } from "@bloopjs/engine";
+
+type BloopLoop = {
+	system: (label: string, system: System) => void;
+	systemsCallback: (events: PlatformEvent[]) => void;
 }
+
+export function Bloop(): BloopLoop {
+	const systems = [] as System[];
+
+	return {
+		system(label: string, system: System) {
+			systems.push(system);
+		},
+		systemsCallback: (events: PlatformEvent[]) => {
+			for (const system of systems) {
+				system.update?.();
+
+				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;
+					}
+				}
+			}
+		}
+	}
+}
+

package/src/schema.ts

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

package/src/system.ts

@@ -0,0 +1,54 @@
+import type {
+  KeyEvent,
+  MouseButtonEvent,
+  MousePositionEvent,
+  MouseWheelEvent,
+} from "@bloopjs/engine";
+import type { Context } from "./context";
+import type { GameSchema } from "./schema";
+
+export type System<GS extends GameSchema = GameSchema> = {
+  update?: () => void;
+
+  keydown?: (
+    context: Context<GS> & {
+      event: KeyEvent;
+    },
+  ) => void;
+
+  keyup?: (
+    context: Context<GS> & {
+      event: KeyEvent;
+    },
+  ) => void;
+
+  keyheld?: (
+    context: Context<GS> & {
+      event: KeyEvent;
+    },
+  ) => void;
+
+  mousedown?: (
+    context: Context<GS> & {
+      event: MouseButtonEvent;
+    },
+  ) => void;
+
+  mouseup?: (
+    context: Context<GS> & {
+      event: MouseButtonEvent;
+    },
+  ) => void;
+
+  mousemove?: (
+    context: Context<GS> & {
+      event: MousePositionEvent;
+    },
+  ) => void;
+
+  mousewheel?: (
+    context: Context<GS> & {
+      event: MouseWheelEvent;
+    },
+  ) => void;
+};

package/test/inputs.test.ts

@@ -0,0 +1,89 @@
+import { it, expect, describe } from "bun:test";
+import { mount, type Key, type MouseButton } from "@bloopjs/engine";
+import { Bloop } from "../src/mod";
+
+describe("loop", () => {
+  it("runs a single system", async () => {
+    const bloop = Bloop();
+    let count = 0;
+
+    bloop.system("test", {
+      update() {
+        count++;
+      },
+    });
+
+    const { runtime } = await mount(bloop);
+    runtime.step();
+
+    expect(count).toEqual(1);
+  });
+
+  it("passes through input events", async () => {
+    const bloop = Bloop();
+
+    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,
+    };
+
+    bloop.system("input", {
+      keydown({ event }) {
+        events.keydown = event.key;
+      },
+      keyup({ event }) {
+        events.keyup = event.key;
+      },
+      keyheld({ event }) {
+        events.keyheld = event.key;
+      },
+      mousemove({ event }) {
+        events.mousemove = { x: event.x, y: event.y };
+      },
+      mousedown({ event }) {
+        events.mousedown = event.button;
+      },
+      mouseup({ event }) {
+        events.mouseup = event.button;
+      },
+      mousewheel({ event }) {
+        events.mousewheel = event;
+      },
+    });
+
+    const { runtime, emitter } = await mount(bloop);
+
+    emitter.keydown("Space");
+    emitter.mousemove(100, 150);
+    emitter.mousedown("Left");
+    emitter.mousewheel(1, 2);
+
+    runtime.step();
+
+    expect(events.keydown).toEqual("Space");
+    expect(events.mousemove).toEqual({ x: 100, y: 150 });
+    expect(events.mousedown).toEqual("Left");
+    expect(events.mousewheel).toEqual({ x: 1, y: 2 });
+
+    emitter.keyup("Space");
+    emitter.mouseup("Left");
+    emitter.mousemove(3, 4);
+
+    runtime.step();
+
+    expect(events.keyup).toEqual("Space");
+    expect(events.mouseup).toEqual("Left");
+    expect(events.mousemove).toEqual({ x: 3, y: 4 });
+  });
+
+  it.skip("keeps track of keyboard and mouse snapshots", async () => {});
+
+  it.skip('synthesizes "keyheld" and "mouseheld" events', async () => {});
+});

package/tsconfig.json

@@ -30,5 +30,5 @@
     "declaration": true,
     "outDir": "dist",
   },
-  "include": ["src"]
+  "include": ["src", "test"]
 }