added additional part functionality

sojs-coder · sojs-coder · commit bd0292166560 · 2025-08-22T23:05:45.000-07:00
diff --git a/Parts/Children/AnimatedSprite.ts b/Parts/Children/AnimatedSprite.ts
@@ -36,6 +36,7 @@ export class AnimatedSprite extends Renderer {
         this.onAnimationComplete = onAnimationComplete; // Set the callback for animation completion
         this.webEngine = webEngine; // Set the web engine flag
         this.type = "AnimatedSprite";
+        this.base = "Renderer";
     }
     clone(memo = new Map()): this {
         if (memo.has(this)) {
diff --git a/Parts/Children/BoxCollider.ts b/Parts/Children/BoxCollider.ts
@@ -20,6 +20,7 @@ export class BoxCollider extends Collider {
         this.realWorldStart = this.start; // Will be updated in act(), onMount()
         this.realWorldEnd = this.end; // Will be updated in act(), onMount()
         this.type = "BoxCollider";
+        this.base = "Collider";
     }
     onMount(parent: Part) {
         super.onMount(parent);
diff --git a/Parts/Children/Button.ts b/Parts/Children/Button.ts
@@ -49,7 +49,7 @@ export class Button extends Renderer {
         this.hoverSound = hoverSound;
         this.activeSound = activeSound;
         this.type = "Button";
-
+        this.base = "Renderer"
         this.onclick = (event: MouseEvent, input: any) => {
             if (this.onClickHandler) {
                 this.onClickHandler();
diff --git a/Parts/Children/Collider.ts b/Parts/Children/Collider.ts
@@ -1,4 +1,5 @@
-import type { Vector } from "../../engine/bundle";
+import { Vector } from "../../Math/Vector";
+import type { Camera } from "../Camera";
 import { Part } from "../Part";
 import type { Transform } from "./Transform";
 
@@ -8,6 +9,7 @@ export class Collider extends Part {
     constructor() {
         super({ name: "Collider" });
         this.type = "Collider";
+        this.base = "Collider";
     }
 
     clone(memo = new Map()): this {
@@ -68,4 +70,95 @@ export class Collider extends Part {
         this.hoverbug = `${this.colliding ? "🟥" : "🟩"} - ${Array.from(this.collidingWith).map(o => o.name).join(",")} objects`
 
     }
-}
+
+    isVisible(camera: Camera): boolean {
+        if (!this.top) {
+            throw new Error("Collider cannot calculate visibility without a 'top' (Game instance).");
+        }
+
+        // 1. Get camera's view boundaries in world space.
+        const { offset, scale } = camera.getViewMatrix();
+        // cameraPos is the world coordinate at the center of the camera's view.
+        const cameraPos = offset.multiply(-1);
+
+        const screenWidth = this.top.width;
+        const screenHeight = this.top.height;
+
+        // Calculate the width and height of the camera's view in world units.
+        const viewWidth = screenWidth / scale.x;
+        const viewHeight = screenHeight / scale.y;
+
+        // 2. Get collider's AABB in world space.
+        const vertices = this.vertices;
+        if (vertices.length === 0) {
+            return false; // No vertices means it has no shape to be visible.
+        }
+
+        const transform = this.sibling<Transform>("Transform");
+        if (!transform) {
+            throw new Error("Can not calculate visibility if transform sibling is not present");
+        }
+
+        const worldVertices = vertices.map(vertex => {
+            return vertex.add(transform.position)
+        });
+
+        const cameraVertices = [
+            new Vector(cameraPos.x - viewWidth / 2, cameraPos.y - viewHeight / 2),
+            new Vector(cameraPos.x + viewWidth / 2, cameraPos.y - viewHeight / 2),
+            new Vector(cameraPos.x + viewWidth / 2, cameraPos.y + viewHeight / 2),
+            new Vector(cameraPos.x - viewWidth / 2, cameraPos.y + viewHeight / 2)
+        ]
+
+
+        return this.checkVerticesAgainstVertices(worldVertices, cameraVertices);
+    }
+
+    protected checkVerticesAgainstVertices(vertices1: Vector[], vertices2: Vector[]) {
+        const axes1 = this.getAxes(vertices1);
+        const axes2 = this.getAxes(vertices2);
+
+        const axes = axes1.concat(axes2);
+
+        for(const axis of axes) {
+            const projection1 = this.project(vertices1, axis);
+            const projection2 = this.project(vertices2, axis);
+
+            if (!this.overlap(projection1, projection2)) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+    // Helper to get axes (normals) of a polygon's edges
+    protected getAxes(vertices: Vector[]): Vector[] {
+        const axes: Vector[] = [];
+        for (let i = 0; i < vertices.length; i++) {
+            const p1 = vertices[i];
+            const p2 = vertices[i === vertices.length - 1 ? 0 : i + 1];
+            const edge = p2.subtract(p1);
+            const normal = new Vector(-edge.y, edge.x).normalize(); // Perpendicular vector (normal)
+            axes.push(normal);
+        }
+        return axes;
+    }
+    // Helper to project a polygon onto an axis
+    protected project(vertices: Vector[], axis: Vector): { min: number, max: number } {
+        let min = axis.dot(vertices[0]);
+        let max = min;
+        for (let i = 1; i < vertices.length; i++) {
+            const p = axis.dot(vertices[i]);
+            if (p < min) {
+                min = p;
+            } else if (p > max) {
+                max = p;
+            }
+        }
+        return { min, max };
+    }
+    // Helper to check if two projections overlap
+    protected overlap(proj1: { min: number, max: number }, proj2: { min: number, max: number }): boolean {
+        return proj1.max >= proj2.min && proj2.max >= proj1.min;
+    }
+}
diff --git a/Parts/Children/ColorRender.ts b/Parts/Children/ColorRender.ts
@@ -22,6 +22,7 @@ export class ColorRender extends Renderer {
         this.color = color;
         this.debugEmoji = "🎨";
         this.type = "ColorRender";
+        this.base = "Renderer";
         this.vertices = vertices || [];
         if (this.vertices.length === 0) {
             this.vertices = [
diff --git a/Parts/Children/PolygonCollider.ts b/Parts/Children/PolygonCollider.ts
@@ -3,7 +3,6 @@ import { Part } from "../Part";
 import { Collider } from "./Collider";
 import type { Transform } from "./Transform";
 import { Game } from "../Game";
-import { drawBox } from "../../helpers"; // For debug drawing AABB of polygon
 import { BoxCollider } from "./BoxCollider"; // For collision with BoxCollider
 
 export class PolygonCollider extends Collider {
@@ -163,36 +162,5 @@ export class PolygonCollider extends Collider {
         return true; // No separating axis found, they are colliding
     }
 
-    // Helper to get axes (normals) of a polygon's edges
-    private getAxes(vertices: Vector[]): Vector[] {
-        const axes: Vector[] = [];
-        for (let i = 0; i < vertices.length; i++) {
-            const p1 = vertices[i];
-            const p2 = vertices[i === vertices.length - 1 ? 0 : i + 1];
-            const edge = p2.subtract(p1);
-            const normal = new Vector(-edge.y, edge.x).normalize(); // Perpendicular vector (normal)
-            axes.push(normal);
-        }
-        return axes;
-    }
 
-    // Helper to project a polygon onto an axis
-    private project(vertices: Vector[], axis: Vector): { min: number, max: number } {
-        let min = axis.dot(vertices[0]);
-        let max = min;
-        for (let i = 1; i < vertices.length; i++) {
-            const p = axis.dot(vertices[i]);
-            if (p < min) {
-                min = p;
-            } else if (p > max) {
-                max = p;
-            }
-        }
-        return { min, max };
-    }
-
-    // Helper to check if two projections overlap
-    private overlap(proj1: { min: number, max: number }, proj2: { min: number, max: number }): boolean {
-        return proj1.max >= proj2.min && proj2.max >= proj1.min;
-    }
 }
diff --git a/Parts/Children/Renderer.ts b/Parts/Children/Renderer.ts
@@ -14,6 +14,7 @@ export class Renderer extends Part {
         this.disableAntiAliasing = disableAntiAliasing || false; // Default to false if not provided
         this.debugEmoji = "🎨"; // Emoji for debugging Renderer
         this.type = "Renderer";
+        this.base = "Rednerer";
     }
 
     face(direction: Vector) {
diff --git a/Parts/Children/SpriteRender.ts b/Parts/Children/SpriteRender.ts
@@ -10,6 +10,7 @@ export class SpriteRender extends Renderer {
         super({ width, height });
         this.name = "SpriteRender";
         this.type = "SpriteRender";
+        this.base = "Renderer";
         this.ready = false;
         this.imageSource = imageSource;
         this.debugEmoji = "🖼️"; // Default emoji for debugging the sprite render 
diff --git a/Parts/Children/TextRender.ts b/Parts/Children/TextRender.ts
@@ -16,6 +16,7 @@ export class TextRender extends Renderer {
         this.color = color || 'black'; // Default color if not specified
         this.debugEmoji = "🅰️";
         this.type = "TextRender";
+        this.base = "Renderer";
     }
     onMount(parent: Part) {
         super.onMount(parent);
diff --git a/Parts/Game.ts b/Parts/Game.ts
@@ -175,6 +175,8 @@ export class Game extends Part {
         this._isRunning = true;
         this._isPaused = false;
         this._lastUpdateTime = performance.now();
+        this.onStart();
+
         SoundManager.startGame();
         this.loop();
     }
@@ -194,6 +196,7 @@ export class Game extends Part {
                 this.currentScene.debugTreeRender(this.canvas.width / 2, 10, { x: 10, y: 40 });
                 this.context.restore();
                 this.currentScene.act(delta);
+                this.currentScene.frameEnd(delta);
                 this.updateDebugToolTip();
                 this.context.fillStyle = "red";
                 this.context.fillRect(this.canvas.width / 2 - 2, this.canvas.height / 2 - 2, 4, 4);
@@ -267,7 +270,6 @@ export class Game extends Part {
             this.currentScene = scene;
         } else {
             console.error('Set unknown scene type- neither string nor Scene instance');
-            console.log(scene);
             let json;
             try {
                 json = JSON.stringify(scene);
@@ -277,7 +279,7 @@ export class Game extends Part {
             this.debug(`Trying to set scene to unknown type- neither string nor Scene instance. Got ${typeof scene} - ${json}`);
         }
     }
-    warn (...args: any[]) {
+    warn(...args: any[]) {
         if (this.messageHook && typeof this.messageHook === "function") {
             this.messageHook("warn", ...args);
             return true;
@@ -286,7 +288,7 @@ export class Game extends Part {
             return false;
         }
     }
-    error (...args: any[]) {
+    error(...args: any[]) {
         if (this.messageHook && typeof this.messageHook === "function") {
             this.messageHook("error", ...args);
             return true;
@@ -295,7 +297,7 @@ export class Game extends Part {
             return false;
         }
     }
-    debug (...args: any[]) {
+    debug(...args: any[]) {
         if (this.messageHook && typeof this.messageHook === "function") {
             this.messageHook("debug", ...args);
             return true;
diff --git a/Parts/Input.ts b/Parts/Input.ts
@@ -75,6 +75,7 @@ export class Input extends Part {
     }
     initialize(canvas: HTMLCanvasElement) {
         this.mousemoveDef = (event: MouseEvent) => {
+            if (event.target !== canvas)  return;
             const game = this.top as Game;
             if (!game || !game.currentScene || game.currentScene !== this.parent || !game.currentScene?.activeCamera) {
                 return;
diff --git a/Parts/Part.ts b/Parts/Part.ts
@@ -4,6 +4,7 @@ import type { AnimatedSprite } from "./Children/AnimatedSprite";
 import type { Game } from "./Game";
 import type { Collider } from "./Children/Collider";
 import { Vector } from "../Math/Vector";
+import type { Camera } from "./Camera";
 
 type Tie<T extends Part = Part, L extends keyof T = keyof T, R extends keyof Part = keyof Part> = {
     target: T;
@@ -31,6 +32,7 @@ export class Part {
     _superficialHeight: number = 0; // General height of object
     ties: Set<Tie> = new Set(); // Ties to other parts, allowing for dynamic attribute linking
     type: string;
+    base: string; // Base class
     warned: Set<string> = new Set(); // Set to track warnings for this part, preventing duplicate warnings
     private _childrenByName: { [name: string]: Part } = {}; // For quick access to children by name
     private _childrenByType: { [type: string]: Array<Part> } = {}; // For quick access to children by type
@@ -42,6 +44,7 @@ export class Part {
         this.parent = undefined;
         this.top = undefined;
         this.ready = true;
+        this.base = "Part";
         this.type = this.constructor.name || "Part"; // Default type is the class name
         this.debugEmoji = "🧩"; // Default emoji for debugging
     }
@@ -150,7 +153,18 @@ export class Part {
     onUnmount() {
         // This method can be overridden in subclasses to handle unmounting logic
     }
+    onStart() {
+        // before act is called, after start is called
+        this.childrenArray.forEach(child => {
+            if (typeof child.onStart === 'function') {
+                child.onStart();
+            }
+        });
+    }
     addChild(child: Part) {
+        if (child.name == "LightSource") {
+            console.log(this, child)
+        }
         if (this._childrenByName[child.name]) {
             this.top?.warn(`Child with name <${child.name}> already exists in <${this.name}>. Skipping addition. (Child has ID <${child.id}>).`);
             return;
@@ -202,6 +216,11 @@ export class Part {
             child.act(delta);
         });
     }
+    frameEnd(delta: number) {
+        this.childrenArray.forEach(child => {
+            child.frameEnd(delta);
+        });
+    }
 
     setAll(attribute: string, value: any) {
         const current = this.registrations[attribute];
@@ -450,4 +469,30 @@ export class Part {
         const clone = new (this.constructor as any)({ name: this.name }); // Default clone creation
         return this._cloneProperties(clone, memo) as this;
     }
+
+    isVisible(camera: Camera) {
+        return false;
+    }
+
+    getPart<T>(arg: (new (...args: any[]) => T) | string): T | undefined {
+        if (typeof arg === "string") {
+            return this.childrenArray.find(child => child.type === arg || child.base === arg) as T | undefined;
+        }
+        return this.childrenArray.find(child => child instanceof arg) as T | undefined;
+    }
+
+    getChildPartRecursive<T extends Part>(arg: (new (...args: any[]) => T) | string, found: T[] = []): T[] {
+        for (const child of this.childrenArray) {
+            if (typeof arg !== "string" && child instanceof arg) {
+                found.push(child as T);
+            } else if (child.type === arg || child.base === arg) {
+                found.push(child as T);
+            }
+            child.getChildPartRecursive(arg, found);
+        }
+        return found;
+    }
+    siblingOf<T extends Part>(...args: string[]) {
+        return this.parent?.childrenArray.find(child => args.includes(child.type) || args.includes(child.base)) as T | undefined;
+    }
 }
diff --git a/docs/api/Part.md b/docs/api/Part.md
@@ -67,6 +67,9 @@ The `Part` class is the fundamental building block of the entire Forge engine. E
 -   `type: string`
     The type of the part.
 
+-   `base: string`
+    The base class of the part. For example, `BoxCollider` and `PolygonCollider` are both of base `Collider`. `Button` and `AnimatedSprite` are both of base `Renderer`. Most parts are of base `Part`
+
 ## Methods
 
 -   `tie(target: Part, property: string, localAttribute: string)`
@@ -132,6 +135,25 @@ The `Part` class is the fundamental building block of the entire Forge engine. E
 -   `child<T extends Part>(name: string): T | undefined`
     Retrieves a child `Part` by its name or type.
 
+-   `onStart()`
+    Called before act() is called, when the scene is first started through `Game.start()`
+
+-   `frameEnd(delta: number)`
+    Called when the frame has ended. This is good if you want your Part to have final say in the scene. Eg: apply a filter some other form of post effects.
+
+-   `isVisible(camera: Camera): boolean`
+    Returns true or false if the object is visible in the camera. Needs to be called on a collider or implemented in a custom class, otherwise it will not work. This is good if a Part is computationally intensive, you can call a sibling collider's isVisible method and skip an intensive rending process if it is not visible (eg: lighting). You most likely want to override this method.
+
+-   `getPart<T extends Part>(arg: (string | new (...args: any[]) => T)): T | undefined`
+    Searches through children parts to find a part of that type. Example: `part.getPart<Collider>(Collider)`. It can also be used with strings, and can reference both base types and main types. Example: `part.getPart<Collider>("Collider")` - this would return the first collider child, which could be a BoxCollider, PolygonCollider, or Collider instance.
+
+-   `getChildPartRecursive<T extends Part>(arg: (string | new (...args: any[]) => T), found: T[] = []): T[]`
+    This goes through the child node graph and identifies any child of type T. (Same implementation as getPart- either string or type). For example `part.getChildPartRecursive<Collider>("Collider")` would get every BoxCollider, PolygonCollider, and Collider that is a child of `part`.
+
+-   `siblingOf<T extends Part>(...args: string[]): (T extends Part)[]`
+    Returns a list of parts that are of type in args, as a string. `part.siblinOf("Camera", "Input", "Renderer", "BoxCollider")` would return a list with every Camera, Input, Renderer, TextRender, ColorRender, AnimatedSprite, SpriteRender, Button, and BoxCollider that is a sibling of the part.
+
+
 ## Examples
 
 ### Creating a Custom Part
diff --git a/engine/bundle.js b/engine/bundle.js
diff --git a/engine/editor.js b/engine/editor.js
diff --git a/engine/editor/partLibrary.ts b/engine/editor/partLibrary.ts

Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ export class AnimatedSprite extends Renderer {`
`36`	`36`	`this.onAnimationComplete = onAnimationComplete; // Set the callback for animation completion`
`37`	`37`	`this.webEngine = webEngine; // Set the web engine flag`
`38`	`38`	`this.type = "AnimatedSprite";`
	`39`	`+ this.base = "Renderer";`
`39`	`40`	`}`
`40`	`41`	`clone(memo = new Map()): this {`
`41`	`42`	`if (memo.has(this)) {`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ export class BoxCollider extends Collider {`
`20`	`20`	`this.realWorldStart = this.start; // Will be updated in act(), onMount()`
`21`	`21`	`this.realWorldEnd = this.end; // Will be updated in act(), onMount()`
`22`	`22`	`this.type = "BoxCollider";`
	`23`	`+ this.base = "Collider";`
`23`	`24`	`}`
`24`	`25`	`onMount(parent: Part) {`
`25`	`26`	`super.onMount(parent);`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ export class Renderer extends Part {`
`14`	`14`	`this.disableAntiAliasing = disableAntiAliasing \|\| false; // Default to false if not provided`
`15`	`15`	`this.debugEmoji = "🎨"; // Emoji for debugging Renderer`
`16`	`16`	`this.type = "Renderer";`
	`17`	`+ this.base = "Rednerer";`
`17`	`18`	`}`
`18`	`19`
`19`	`20`	`face(direction: Vector) {`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@ export class TextRender extends Renderer {`
`16`	`16`	`this.color = color \|\| 'black'; // Default color if not specified`
`17`	`17`	`this.debugEmoji = "🅰️";`
`18`	`18`	`this.type = "TextRender";`
	`19`	`+ this.base = "Renderer";`
`19`	`20`	`}`
`20`	`21`	`onMount(parent: Part) {`
`21`	`22`	`super.onMount(parent);`