Merge pull request #34 from JollyPixel/engine-actor-tree

Engine actor tree

Author: fraxken

package-lock.json

@@ -21,6 +21,7 @@
   "author": "GENTILHOMME Thomas <gentilhomme.thomas@gmail.com>",
   "license": "MIT",
   "dependencies": {
+    "picomatch": "^4.0.3",
     "stats.js": "^0.17.0",
     "three": "^0.179.1"
   }

packages/engine/package.json

@@ -4,6 +4,7 @@ import * as THREE from "three";
 // Import Internal Dependencies
 import { type GameInstance } from "./systems/GameInstance.js";
 import { type Component } from "./ActorComponent.js";
+import { ActorTree } from "./ActorTree.js";
 import { Behavior } from "./Behavior.js";
 import { Transform } from "./Transform.js";
 
@@ -21,13 +22,12 @@ export interface ActorOptions {
   layer?: number | number[];
 }
 
-export class Actor {
+export class Actor extends ActorTree {
   gameInstance: GameInstance;
 
   name: string;
   awoken = false;
   parent: Actor | null = null;
-  children: Actor[] = [];
   components: Component[] = [];
   behaviors: Record<string, Behavior<any>[]> = {};
   transform: Transform;
@@ -39,7 +39,8 @@ export class Actor {
     gameInstance: GameInstance,
     options: ActorOptions
   ) {
-    const { name, parent = null, visible = true, layer = 0 } = options;
+    super();
+    const { name, parent = null, visible = true, layer } = options;
 
     if (parent !== null && parent.pendingForDestruction) {
       throw new Error("Cannot add actor to a parent that is pending for destruction.");
@@ -53,16 +54,18 @@ export class Actor {
     this.threeObject.name = this.name;
     this.threeObject.userData.isActor = true;
 
-    const layers = Array.isArray(layer) ? layer : [layer];
-    for (const layer of layers) {
-      this.threeObject.layers.enable(layer);
-      this.gameInstance.threeScene.layers.enable(layer);
+    if (layer) {
+      const layers = Array.isArray(layer) ? layer : [layer];
+      for (const layer of layers) {
+        this.threeObject.layers.enable(layer);
+        this.gameInstance.threeScene.layers.enable(layer);
+      }
     }
 
     this.transform = new Transform(this.threeObject);
 
     if (parent) {
-      parent.children.push(this);
+      parent.add(this);
       parent.threeObject.add(this.threeObject);
       this.threeObject.updateMatrixWorld(false);
     }
@@ -118,44 +121,17 @@ export class Actor {
     }
     else {
       this.parent.threeObject.remove(this.threeObject);
-      this.parent.children.splice(this.parent.children.indexOf(this), 1);
+      this.parent.remove(this);
     }
 
     this.threeObject.clear();
   }
 
   markDestructionPending() {
     this.pendingForDestruction = true;
-    this.children.forEach((child) => child.markDestructionPending());
-  }
-
-  getChild(name: string) {
-    const nameParts = name.split("/");
-
-    const findChildByPath = (currentActor: Actor, pathParts: string[]): Actor | null => {
-      if (pathParts.length === 0) {
-        return currentActor;
-      }
-
-      const [nextName, ...remainingParts] = pathParts;
-      const foundChild = Array.from(this.gameInstance.tree.walkFromNode(currentActor))
-        .find(({ actor }) => actor.name === nextName && !actor.isDestroyed());
-
-      return foundChild ?
-        findChildByPath(foundChild.actor, remainingParts) :
-        null;
-    };
-
-    const result = findChildByPath(this, nameParts);
-
-    return result === this ? null : result;
-  }
-
-  getChildren(): Actor[] {
-    return this.children.filter((child) => !child.isDestroyed());
+    this.destroyAllActors();
   }
 
-  // Behaviors
   addBehavior<T extends new(...args: any) => Behavior>(
     behaviorClass: T,
     properties: ConstructorParameters<T>[0] = Object.create(null)
@@ -229,16 +205,16 @@ export class Actor {
       this.transform.getGlobalMatrix(Transform.Matrix);
     }
 
-    const oldSiblings = (this.parent === null) ? this.gameInstance.tree.root : this.parent.children;
-    oldSiblings.splice(oldSiblings.indexOf(this), 1);
+    const oldSiblings = (this.parent === null) ? this.gameInstance.tree : this.parent;
+    oldSiblings.remove(this);
     this.threeObject.parent?.remove(this.threeObject);
 
     this.parent = newParent;
 
     const siblings = (newParent === null) ?
-      this.gameInstance.tree.root :
-      newParent.children;
-    siblings.push(this);
+      this.gameInstance.tree :
+      newParent;
+    siblings.add(this);
     const threeParent = (newParent === null) ?
       this.gameInstance.threeScene :
       newParent.threeObject;

packages/engine/src/Actor.ts

@@ -1,3 +1,6 @@
+// Import Third-party Dependencies
+import pm from "picomatch";
+
 // Import Internal Dependencies
 import { Actor } from "./Actor.js";
 
@@ -15,10 +18,11 @@ export class ActorTree extends EventTarget {
   #addCallback?: (actor: Actor) => void;
   #removeCallback?: (actor: Actor) => void;
 
-  root: Actor[] = [];
-  actorsToBeDestroyed: Actor[] = [];
+  children: Actor[] = [];
 
-  constructor(options: ActorTreeOptions = {}) {
+  constructor(
+    options: ActorTreeOptions = {}
+  ) {
     super();
     this.#addCallback = options.addCallback;
     this.#removeCallback = options.removeCallback;
@@ -27,21 +31,119 @@ export class ActorTree extends EventTarget {
   add(
     actor: Actor
   ): void {
-    this.root.push(actor);
+    this.children.push(actor);
     this.#addCallback?.(actor);
   }
 
   remove(actor: Actor): void {
-    const index = this.root.indexOf(actor);
+    const index = this.children.indexOf(actor);
     if (index !== -1) {
-      this.root.splice(index, 1);
+      this.children.splice(index, 1);
       this.#removeCallback?.(actor);
     }
   }
 
+  * getActors(
+    pattern: string
+  ): IterableIterator<Actor> {
+    if (pattern.includes("/")) {
+      yield* this.#getActorsByPatternPath(pattern);
+
+      return;
+    }
+
+    const isPatternMatching = pm(pattern);
+
+    for (const { actor } of this.walk()) {
+      if (isPatternMatching(actor.name) && !actor.pendingForDestruction) {
+        yield actor;
+      }
+    }
+  }
+
+  * #getActorsByPatternPath(
+    pattern: string
+  ): IterableIterator<Actor> {
+    const parts = pattern.split("/").filter((part) => part !== "");
+
+    for (const rootActor of this.children) {
+      if (!rootActor.pendingForDestruction) {
+        yield* this.#matchActorPath(rootActor, parts, 0);
+      }
+    }
+  }
+
+  * #matchActorPath(
+    actor: Actor,
+    patternParts: string[],
+    patternIndex: number
+  ): IterableIterator<Actor> {
+    if (patternIndex >= patternParts.length) {
+      return;
+    }
+
+    const currentPattern = patternParts[patternIndex];
+    const isLastPattern = patternIndex === patternParts.length - 1;
+
+    // eslint-disable-next-line func-style
+    const matchSinglePattern = (name: string, pattern: string) => pm(pattern)(name);
+
+    if (currentPattern === "**") {
+      if (isLastPattern) {
+        for (const { actor: descendant } of this.#walkDepthFirstGenerator(actor)) {
+          if (!descendant.pendingForDestruction) {
+            yield descendant;
+          }
+        }
+
+        return;
+      }
+
+      const nextPattern = patternParts[patternIndex + 1];
+      for (const { actor: descendant } of this.#walkDepthFirstGenerator(actor)) {
+        if (descendant.pendingForDestruction) {
+          continue;
+        }
+
+        if (matchSinglePattern(descendant.name, nextPattern)) {
+          if (patternIndex + 1 === patternParts.length - 1) {
+            yield descendant;
+          }
+          else {
+            yield* this.#matchActorPath(descendant, patternParts, patternIndex + 2);
+          }
+        }
+      }
+
+      return;
+    }
+
+    if (matchSinglePattern(actor.name, currentPattern)) {
+      if (isLastPattern) {
+        if (!actor.pendingForDestruction) {
+          yield actor;
+        }
+      }
+      else {
+        for (const child of actor.children) {
+          yield* this.#matchActorPath(child, patternParts, patternIndex + 1);
+        }
+      }
+    }
+  }
+
+  /**
+   * @example
+   * const player = actor.children.getActor("player");
+   * const playerPhysicsBox = actor.children.getActor("player/physics_box");
+   */
   getActor(
     name: string
   ): Actor | null {
+    if (name.includes("/")) {
+      return this.#getActorByPath(name);
+    }
+
     for (const { actor } of this.walk()) {
       if (actor.name === name && !actor.pendingForDestruction) {
         return actor;
@@ -51,8 +153,31 @@ export class ActorTree extends EventTarget {
     return null;
   }
 
+  #getActorByPath(
+    path: string
+  ): Actor | null {
+    const parts = path.split("/").filter((part) => part !== "");
+    const parentNode = this.getActor(parts[0]);
+    if (!parentNode) {
+      return null;
+    }
+
+    let currentNode: Actor | null = parentNode;
+    for (let i = 1; i < parts.length; i++) {
+      if (!currentNode) {
+        break;
+      }
+
+      currentNode = [...currentNode.children].find(
+        (child) => child.name === parts[i]
+      ) ?? null;
+    }
+
+    return currentNode;
+  }
+
   * getRootActors(): IterableIterator<Actor> {
-    for (const rootActor of this.root) {
+    for (const rootActor of this.children) {
       if (!rootActor.pendingForDestruction) {
         yield rootActor;
       }
@@ -69,7 +194,6 @@ export class ActorTree extends EventTarget {
     actor: Actor
   ) {
     if (!actor.pendingForDestruction) {
-      this.actorsToBeDestroyed.push(actor);
       actor.markDestructionPending();
     }
   }
@@ -94,7 +218,7 @@ export class ActorTree extends EventTarget {
   }
 
   * walk(): IterableIterator<ActorTreeNode> {
-    for (const child of this.root) {
+    for (const child of this.children) {
       yield* this.#walkDepthFirstGenerator(child, undefined);
     }
   }
@@ -106,4 +230,12 @@ export class ActorTree extends EventTarget {
       yield* this.#walkDepthFirstGenerator(child, rootNode);
     }
   }
+
+  * [Symbol.iterator](): IterableIterator<Actor> {
+    for (const actor of this.children) {
+      if (!actor.pendingForDestruction) {
+        yield actor;
+      }
+    }
+  }
 }