feat(engine): implement type-safe GameInstance.context

Author: fraxken

.changeset/dirty-horses-rhyme.md

@@ -0,0 +1,5 @@
+---
+"@jolly-pixel/engine": minor
+---
+
+Implement type-safe GameInstance.context

packages/engine/src/actor/Actor.ts

@@ -11,36 +11,36 @@ import type {
   Component
 } from "../components/types.ts";
 
-type ComponentConstructor = new (actor: Actor, ...args: any[]) => Component;
+type ComponentConstructor = new (actor: Actor<any>, ...args: any[]) => Component;
 
 type RequiresOptions<T extends ComponentConstructor> =
-  T extends new (actor: Actor, options: infer O, ...args: any[]) => any
+  T extends new (actor: Actor<any>, options: infer O, ...args: any[]) => any
     ? undefined extends O ? false : true
     : false;
 
-export interface ActorOptions {
+export interface ActorOptions<TContext = Record<string, unknown>> {
   name: string;
-  parent?: Actor | null;
+  parent?: Actor<TContext> | null;
   visible?: boolean;
   layer?: number | number[];
 }
 
-export class Actor extends ActorTree {
-  gameInstance: GameInstance;
+export class Actor<TContext = Record<string, unknown>> extends ActorTree<TContext> {
+  gameInstance: GameInstance<any, TContext>;
 
   name: string;
   awoken = false;
-  parent: Actor | null = null;
+  parent: Actor<TContext> | null = null;
   components: Component[] = [];
-  behaviors: Record<string, Behavior<any>[]> = {};
+  behaviors: Record<string, Behavior<any, TContext>[]> = {};
   transform: Transform;
   pendingForDestruction = false;
 
   threeObject = new THREE.Group();
 
   constructor(
-    gameInstance: GameInstance<any>,
-    options: ActorOptions
+    gameInstance: GameInstance<any, any>,
+    options: ActorOptions<TContext>
   ) {
     super();
     const { name, parent = null, visible = true, layer } = options;
@@ -110,8 +110,8 @@ export class Actor extends ActorTree {
     return component as InstanceType<T>;
   }
 
-  getComponentByName<T extends ActorComponent>(
-    actor: Actor,
+  getComponentByName<T extends ActorComponent<TContext>>(
+    actor: Actor<TContext>,
     componentName: string
   ): T {
     const component = actor.components.find(
@@ -161,7 +161,7 @@ export class Actor extends ActorTree {
     this.destroyAllActors();
   }
 
-  addBehavior<T extends new(...args: any) => Behavior>(
+  addBehavior<T extends new(...args: any) => Behavior<any, TContext>>(
     behaviorClass: T,
     properties: ConstructorParameters<T>[0] = Object.create(null)
   ) {
@@ -220,7 +220,7 @@ export class Actor extends ActorTree {
   }
 
   setParent(
-    newParent: Actor,
+    newParent: Actor<TContext>,
     keepLocal = false
   ) {
     if (this.pendingForDestruction) {

packages/engine/src/actor/ActorComponent.ts

@@ -9,16 +9,16 @@ import type {
   FreeComponentEnum
 } from "../components/types.ts";
 
-export interface ActorComponentOptions {
-  actor: Actor;
+export interface ActorComponentOptions<TContext = Record<string, unknown>> {
+  actor: Actor<TContext>;
   typeName: FreeComponentEnum;
 }
 
 export type ActorComponentEvents = {
   metadataInitialized: [];
 };
 
-export class ActorComponent extends EventEmitter<ActorComponentEvents> implements Component {
+export class ActorComponent<TContext = Record<string, unknown>> extends EventEmitter<ActorComponentEvents> implements Component {
   protected static Id = 0;
 
   static generateNextId() {
@@ -30,13 +30,13 @@ export class ActorComponent extends EventEmitter<ActorComponentEvents> implement
   }
 
   id = ActorComponent.generateNextId();
-  actor: Actor;
+  actor: Actor<TContext>;
   typeName: FreeComponentEnum;
 
   pendingForDestruction = false;
 
   constructor(
-    options: ActorComponentOptions
+    options: ActorComponentOptions<TContext>
   ) {
     super();
     this.actor = options.actor;

packages/engine/src/actor/ActorTree.ts

@@ -4,37 +4,37 @@ import pm from "picomatch";
 // Import Internal Dependencies
 import { Actor } from "./Actor.ts";
 
-export type ActorTreeNode = {
-  actor: Actor;
-  parent?: Actor;
+export type ActorTreeNode<TContext = Record<string, unknown>> = {
+  actor: Actor<TContext>;
+  parent?: Actor<TContext>;
 };
 
-export interface ActorTreeOptions {
-  addCallback?: (actor: Actor) => void;
-  removeCallback?: (actor: Actor) => void;
+export interface ActorTreeOptions<TContext = Record<string, unknown>> {
+  addCallback?: (actor: Actor<TContext>) => void;
+  removeCallback?: (actor: Actor<TContext>) => void;
 }
 
-export class ActorTree {
-  #addCallback?: (actor: Actor) => void;
-  #removeCallback?: (actor: Actor) => void;
+export class ActorTree<TContext = Record<string, unknown>> {
+  #addCallback?: (actor: Actor<TContext>) => void;
+  #removeCallback?: (actor: Actor<TContext>) => void;
 
-  children: Actor[] = [];
+  children: Actor<TContext>[] = [];
 
   constructor(
-    options: ActorTreeOptions = {}
+    options: ActorTreeOptions<TContext> = {}
   ) {
     this.#addCallback = options.addCallback;
     this.#removeCallback = options.removeCallback;
   }
 
   add(
-    actor: Actor
+    actor: Actor<TContext>
   ): void {
     this.children.push(actor);
     this.#addCallback?.(actor);
   }
 
-  remove(actor: Actor): void {
+  remove(actor: Actor<TContext>): void {
     const index = this.children.indexOf(actor);
     if (index !== -1) {
       this.children.splice(index, 1);
@@ -44,7 +44,7 @@ export class ActorTree {
 
   * getActors(
     pattern: string
-  ): IterableIterator<Actor> {
+  ): IterableIterator<Actor<TContext>> {
     if (pattern.includes("/")) {
       yield* this.#getActorsByPatternPath(pattern);
 
@@ -62,7 +62,7 @@ export class ActorTree {
 
   * #getActorsByPatternPath(
     pattern: string
-  ): IterableIterator<Actor> {
+  ): IterableIterator<Actor<TContext>> {
     const parts = pattern.split("/").filter((part) => part !== "");
 
     for (const rootActor of this.children) {
@@ -73,10 +73,10 @@ export class ActorTree {
   }
 
   * #matchActorPath(
-    actor: Actor,
+    actor: Actor<TContext>,
     patternParts: string[],
     patternIndex: number
-  ): IterableIterator<Actor> {
+  ): IterableIterator<Actor<TContext>> {
     if (patternIndex >= patternParts.length) {
       return;
     }
@@ -138,7 +138,7 @@ export class ActorTree {
    */
   getActor(
     name: string
-  ): Actor | null {
+  ): Actor<TContext> | null {
     if (name.includes("/")) {
       return this.#getActorByPath(name);
     }
@@ -154,14 +154,14 @@ export class ActorTree {
 
   #getActorByPath(
     path: string
-  ): Actor | null {
+  ): Actor<TContext> | null {
     const parts = path.split("/").filter((part) => part !== "");
     const parentNode = this.getActor(parts[0]);
     if (!parentNode) {
       return null;
     }
 
-    let currentNode: Actor | null = parentNode;
+    let currentNode: Actor<TContext> | null = parentNode;
     for (let i = 1; i < parts.length; i++) {
       if (!currentNode) {
         break;
@@ -175,22 +175,22 @@ export class ActorTree {
     return currentNode;
   }
 
-  * getRootActors(): IterableIterator<Actor> {
+  * getRootActors(): IterableIterator<Actor<TContext>> {
     for (const rootActor of this.children) {
       if (!rootActor.pendingForDestruction) {
         yield rootActor;
       }
     }
   }
 
-  * getAllActors(): IterableIterator<Actor> {
+  * getAllActors(): IterableIterator<Actor<TContext>> {
     for (const { actor } of this.walk()) {
       yield actor;
     }
   }
 
   destroyActor(
-    actor: Actor
+    actor: Actor<TContext>
   ) {
     if (!actor.pendingForDestruction) {
       actor.markDestructionPending();
@@ -204,31 +204,31 @@ export class ActorTree {
   }
 
   * #walkDepthFirstGenerator(
-    node: Actor,
-    parentNode?: Actor
-  ): IterableIterator<ActorTreeNode> {
+    node: Actor<TContext>,
+    parentNode?: Actor<TContext>
+  ): IterableIterator<ActorTreeNode<TContext>> {
     yield { actor: node, parent: parentNode };
 
     for (const child of node.children) {
       yield* this.#walkDepthFirstGenerator(child, node);
     }
   }
 
-  * walk(): IterableIterator<ActorTreeNode> {
+  * walk(): IterableIterator<ActorTreeNode<TContext>> {
     for (const child of this.children) {
       yield* this.#walkDepthFirstGenerator(child, undefined);
     }
   }
 
   * walkFromNode(
-    rootNode: Actor
-  ): IterableIterator<ActorTreeNode> {
+    rootNode: Actor<TContext>
+  ): IterableIterator<ActorTreeNode<TContext>> {
     for (const child of rootNode.children) {
       yield* this.#walkDepthFirstGenerator(child, rootNode);
     }
   }
 
-  * [Symbol.iterator](): IterableIterator<Actor> {
+  * [Symbol.iterator](): IterableIterator<Actor<TContext>> {
     for (const actor of this.children) {
       if (!actor.pendingForDestruction) {
         yield actor;

packages/engine/src/adapters/global.ts

@@ -4,12 +4,12 @@ import {
 } from "../systems/GameInstance.ts";
 
 export interface GlobalsAdapter {
-  setGame(instance: GameInstance<any>): void;
+  setGame(instance: GameInstance<any, any>): void;
 }
 
 export class BrowserGlobalsAdapter implements GlobalsAdapter {
   setGame(
-    instance: GameInstance<any>
+    instance: GameInstance<any, any>
   ) {
     globalThis.game = instance;
   }

packages/engine/src/components/camera/Camera3DControls.ts

@@ -33,7 +33,7 @@ export class Camera3DControls extends Behavior {
   #movementSpeed: number;
 
   constructor(
-    actor: Actor,
+    actor: Actor<any>,
     options: Camera3DControlsOptions = {}
   ) {
     super(actor);

packages/engine/src/components/renderers/model/ModelRenderer.ts

@@ -25,15 +25,15 @@ export interface ModelRendererOptions {
   animations?: ModelRendererAnimationOptions;
 }
 
-export class ModelRenderer extends ActorComponent {
+export class ModelRenderer extends ActorComponent<any> {
   #asset: Systems.LazyAsset<Model>;
   #object: THREE.Group<THREE.Object3DEventMap>;
   #debug = false;
 
   animation = new ModelAnimation();
 
   constructor(
-    actor: Actor,
+    actor: Actor<any>,
     options: ModelRendererOptions
   ) {
     super({

packages/engine/src/components/renderers/sprite/SpriteRenderer.class.ts

@@ -19,7 +19,7 @@ export interface SpriteRendererOptions {
   };
 }
 
-export class SpriteRenderer extends ActorComponent {
+export class SpriteRenderer extends ActorComponent<any> {
   frameIndex: number;
   tileHorizontal: number;
   tileVertical: number;
@@ -33,7 +33,7 @@ export class SpriteRenderer extends ActorComponent {
   threeObject: THREE.Sprite;
 
   constructor(
-    actor: Actor,
+    actor: Actor<any>,
     options: SpriteRendererOptions
   ) {
     super({

packages/engine/src/components/renderers/text/TextRenderer.class.ts

@@ -15,13 +15,13 @@ export interface TextRendererOptions extends Omit<Text3DOptions, "font"> {
   text?: string;
 }
 
-export class TextRenderer extends ActorComponent {
+export class TextRenderer extends ActorComponent<any> {
   #asset: Systems.LazyAsset<Font>;
 
   text: Text3D;
 
   constructor(
-    actor: Actor,
+    actor: Actor<any>,
     options: TextRendererOptions
   ) {
     super({

packages/engine/src/components/renderers/tiled/TileMapRenderer.ts

@@ -19,12 +19,12 @@ export interface TiledMapRendererOptions {
   orientation?: TiledMapOrientation;
 }
 
-export class TiledMapRenderer extends ActorComponent {
+export class TiledMapRenderer extends ActorComponent<any> {
   #map: Systems.LazyAsset<TiledMapAsset>;
   #orientation: TiledMapOrientation;
 
   constructor(
-    actor: Actor,
+    actor: Actor<any>,
     options: TiledMapRendererOptions
   ) {
     const {