Meh

engine/Entity.ts

@@ -1,5 +1,7 @@
 import { createVector, type Vector } from "#/lib/Vector.ts";
 
+export type Indirect = never;
+
 export type Entity<T> = {
 	id: string;
 	position: Vector;
@@ -14,10 +16,10 @@ export type Animate<T> = (
 export type Process<T> = (entity: Entity<T>, delta: number) => void;
 
 export const entityMap = new Map<string, Entity<unknown>>();
-export const entityAnimateMap = new Map<string, Animate<never>>();
-export const entityProcessMap = new Map<string, Process<never>>();
+export const entityAnimateMap = new Map<string, Animate<Indirect>>();
+export const entityProcessMap = new Map<string, Process<Indirect>>();
 
-export function useEntity<T>(
+export function useEntity<T extends object>(
 	id: string,
 	data: T,
 ): {
@@ -31,10 +33,10 @@ export function useEntity<T>(
 	});
 
 	return {
-		animate(fn: Animate<T>): void {
+		animate(fn) {
 			entityAnimateMap.set(id, fn);
 		},
-		process(fn: Process<T>): void {
+		process(fn) {
 			entityProcessMap.set(id, fn);
 		},
 	};

engine/Scene.ts

@@ -1,10 +1,11 @@
-import type { Vector } from "#/lib/Vector.ts";
+import { type Graph, getNeighbours } from "#/lib/Graph.ts";
 import {
 	type Animate as AnimateEntity,
 	type Entity,
 	entityAnimateMap,
 	entityMap,
 	entityProcessMap,
+	type Indirect,
 	type Process as ProcessEntity,
 } from "./Entity.ts";
 
@@ -12,22 +13,21 @@ export type SceneData = {
 	id: string;
 	width: number;
 	height: number;
-	entities: Array<{
-		id: string;
-		position: Vector;
-	}>;
+	entities: Array<Entity<unknown>>;
 };
 
+export type EntityInstanceMap = Map<
+	string,
+	{
+		animate: AnimateEntity<Indirect>;
+		process: ProcessEntity<Indirect>;
+		instances: Array<Entity<unknown>>;
+	}
+>;
+
 export type Scene = {
 	data: SceneData;
-	entityMap: Map<
-		string,
-		{
-			animate: AnimateEntity<never>;
-			process: ProcessEntity<never>;
-			entities: Array<Entity<unknown>>;
-		}
-	>;
+	entityInstanceMap: EntityInstanceMap;
 	process: Process;
 };
 
@@ -35,10 +35,10 @@ export type Process = (ctx: CanvasRenderingContext2D, delta: number) => void;
 
 export type SceneChangeCallback = (from: Scene, to: Scene) => void;
 
-let sceneChangeCallback: SceneChangeCallback = (): void => {};
-
 const sceneDataMap = new Map<string, SceneData>();
 const sceneProcessMap = new Map<string, Process>();
+const sceneEntiyMap = new Map<string, EntityInstanceMap>();
+const sceneGraph: Graph<string> = new Map();
 
 export const currentScene: Scene = {
 	data: {
@@ -48,33 +48,50 @@ export const currentScene: Scene = {
 		entities: [],
 	},
 	process: () => {},
-	entityMap: new Map(),
+	entityInstanceMap: new Map(),
 };
 
 function animateEntities(ctx: CanvasRenderingContext2D, delta: number): void {
-	for (const entry of currentScene.entityMap.values()) {
-		for (const entity of entry.entities) {
-			entry.animate(entity as Entity<never>, ctx, delta);
+	for (const entity of currentScene.entityInstanceMap.values()) {
+		for (const instance of entity.instances) {
+			entity.animate(instance as Entity<Indirect>, ctx, delta);
 		}
 	}
 }
 
 function processEntities(delta: number): void {
-	for (const entry of currentScene.entityMap.values()) {
-		for (const entity of entry.entities) {
-			entry.process(entity as Entity<never>, delta);
+	for (const entity of currentScene.entityInstanceMap.values()) {
+		for (const instance of entity.instances) {
+			entity.process(instance as Entity<Indirect>, delta);
 		}
 	}
 }
 
+function linkScenes(a: string, b: string): void {
+	if (sceneGraph.has(a)) {
+		sceneGraph.get(a)!.push(b);
+	} else {
+		sceneGraph.set(a, [b]);
+	}
+}
+
 export function useScene(data: SceneData): {
+	linkScenes: (ids: string[]) => () => Promise<void>;
 	process: (fn: Process) => void;
 } {
 	sceneDataMap.set(data.id, data);
+	sceneEntiyMap.set(data.id, new Map());
 
 	return {
-		process(fn: Process): void {
-			sceneProcessMap.set(data.id, (ctx, delta): void => {
+		linkScenes(ids) {
+			for (const id of ids) {
+				linkScenes(data.id, id);
+			}
+
+			return async () => {};
+		},
+		process(fn) {
+			sceneProcessMap.set(data.id, (ctx, delta) => {
 				animateEntities(ctx, delta);
 				processEntities(delta);
 				fn(ctx, delta);
@@ -83,43 +100,35 @@ export function useScene(data: SceneData): {
 	};
 }
 
-export function setSceneChangeCallback(callback: SceneChangeCallback) {
-	sceneChangeCallback = callback;
-}
+export async function loadScene(id: string): Promise<void> {
+	await import(`#/scenes/${id}/index.ts`);
 
-export function changeScene(scene: Scene): void {
-	sceneChangeCallback(currentScene, scene);
-	currentScene.data = scene.data;
-	currentScene.process = scene.process;
-}
+	const data = sceneDataMap.get(id)!;
+	const process = sceneProcessMap.get(id)!;
+	const entityInstanceMap = sceneEntiyMap.get(id)!;
 
-export async function loadScene(name: string): Promise<void> {
-	await import(`#/scenes/${name}/index.ts`);
+	Promise.all(
+		data.entities.map(async (entity: Entity<unknown>) => {
+			await import(`#/entities/${entity.id}/index.ts`);
+
+			if (!entityInstanceMap.has(entity.id)) {
+				entityInstanceMap.set(entity.id, {
+					animate: entityAnimateMap.get(entity.id) ?? (() => {}),
+					process: entityProcessMap.get(entity.id) ?? (() => {}),
+					instances: [],
+				});
+			}
+
+			const instance: Entity<unknown> = {
+				...structuredClone(entityMap.get(entity.id)!),
+				position: entity.position,
+			};
+
+			entityInstanceMap.get(entity.id)!.instances.push(instance);
+		}),
+	);
 
-	const data = sceneDataMap.get(name)!;
 	currentScene.data = data;
-
-	for (const entityData of data.entities) {
-		await import(`#/entities/${entityData.id}/index.ts`);
-
-		const entity = entityMap.get(entityData.id) as Entity<unknown>;
-		const instance: Entity<unknown> = {
-			...structuredClone(entity),
-			position: entityData.position,
-		};
-
-		if (currentScene.entityMap.has(entity.id)) {
-			const entry = currentScene.entityMap.get(entity.id);
-			entry!.entities.push(instance);
-		} else {
-			currentScene.entityMap.set(entity.id, {
-				animate: entityAnimateMap.get(entityData.id) ?? (() => {}),
-				process: entityProcessMap.get(entityData.id) ?? (() => {}),
-				entities: [instance],
-			});
-		}
-	}
-
-	const process = sceneProcessMap.get(name)!;
 	currentScene.process = process;
+	currentScene.entityInstanceMap = entityInstanceMap;
 }