added part library

Author: sojs-coder

Parts/Children/AnimatedSprite.ts

@@ -33,7 +33,18 @@ export class AnimatedSprite extends Renderer {
         this.webEngine = webEngine; // Set the web engine flag
         this.type = "AnimatedSprite";
     }
-
+    destroy() {
+        super.destroy();
+        // Clean up the loaded spritesheet image
+        if (this.loadedSheet) {
+            this.loadedSheet.src = ""; // Release the image source
+            this.loadedSheet = undefined;
+        }
+        // Clear the frames
+        this.frames = {};
+        this.spritesheetData = undefined; // Clear the spritesheet data
+        this.spritesheet = ""; // Clear the spritesheet path
+    }
     async onMount(parent: Part) {
         super.onMount(parent);
         parent.setSuperficialDimensions(this.width, this.height); // Set dimensions for the parent part

Parts/Game.ts

@@ -1,3 +1,4 @@
+import { Sound } from "../engine/bundle";
 import { getDebugInfo } from "../helpers";
 import { Part } from "./Part";
 import { Scene } from "./Scene";
@@ -168,10 +169,13 @@ export class Game extends Part {
 
     pause() {
         this._isPaused = true;
+        SoundManager.pauseGame();
+
     }
 
     resume() {
         this._isPaused = false;
+        SoundManager.resumeGame();
     }
 
     stop() {
@@ -182,6 +186,11 @@ export class Game extends Part {
             this._animationFrameId = undefined;
         }
         SoundManager.stopGame();
+
+        // Dump everything from memory
+        this.childrenArray.forEach(scene => {
+            scene.destroy();
+        });
     }
 
     get isRunning(): boolean {

Parts/Input.ts

@@ -15,6 +15,13 @@ export class Input extends Part {
     currentMousePos: { x: number, y: number } = { x: 0, y: 0 };
     lastClickPos: { x: number, y: number } | null = null;
     initialized: boolean; // Have the event listeners been initialized?
+    private mousemoveDef?: (event: MouseEvent) => void; // Store the mousemove event handler (definite)
+    private clickDef?: (event: MouseEvent) => void; // Store the click event handler (definite)
+    private mousedownDef?: (event: MouseEvent) => void;
+    private mouseupDef?: (event: MouseEvent) => void;
+    private keydownDef?: (event: KeyboardEvent) => void;
+    private keyupDef?: (event: KeyboardEvent) => void;
+
     constructor({
         key,
         keyup,
@@ -36,7 +43,7 @@ export class Input extends Part {
         this.type = "Input";
     }
     initialize(canvas: HTMLCanvasElement) {
-        canvas.addEventListener("mousemove", (event) => {
+        this.mousemoveDef = (event: MouseEvent) => {
             const game = this.top as Game;
             if (!game || !game.currentScene || game.currentScene !== this.parent || !game.currentScene?.activeCamera) {
                 return;
@@ -66,9 +73,8 @@ export class Input extends Part {
 
 
             this.currentMousePos = { x: finalX, y: finalY };
-        });
-
-        canvas.addEventListener("click", (event) => {
+        }
+        this.clickDef =  (event) => {
            const game = this.top as Game;
             if (!game || !game.currentScene || game.currentScene !== this.parent || !game.currentScene?.activeCamera) {
                 return;
@@ -98,33 +104,51 @@ export class Input extends Part {
 
 
             this.lastClickPos = { x: finalX, y: finalY };
-        });
-        canvas.addEventListener("mousedown", (event) => {
+        }
+        this.mousedownDef = (event) => {
             const game = this.top as Game;
             if (game.hovering) {
                 game.hovering.onmousedown(event);
             }
-        });
-        canvas.addEventListener("mouseup", (event) => {
+        }
+        this.mouseupDef = (event) => {
             const game = this.top as Game;
             if (game.hovering) {
                 game.hovering.onmouseup(event);
             }
-        });
-
-        document.addEventListener("keydown", (event) => {
+        }
+        this.keydownDef = (event) => {
             this.downkeys.add(event.key);
-        });
-        document.addEventListener("keyup", (event) => {
+        }
+        this.keyupDef = (event) => {
             this.downkeys.delete(event.key);
             if (typeof this.keyup == "function") {
                 this.keyup(event);
             }
-        });
+        }
+        canvas.addEventListener("mousemove", this.mousemoveDef);
+        canvas.addEventListener("click",this.clickDef);
+        canvas.addEventListener("mousedown", this.mousedownDef);
+        canvas.addEventListener("mouseup", this.mouseupDef);
+
+        document.addEventListener("keydown", this.keydownDef);
+        document.addEventListener("keyup", this.keyupDef);
         this.initialized = true; // Mark as initialized after setting up listeners
     }
 
-
+    destroy(): void {
+        super.destroy();
+        const canvas = this.top?.canvas;
+        if (canvas) {
+            // Remove all event listeners
+            canvas.removeEventListener("mousemove", this.mousemoveDef!);
+            canvas.removeEventListener("click", this.clickDef!);
+            canvas.removeEventListener("mousedown", this.mousedownDef!);
+            canvas.removeEventListener("mouseup", this.mouseupDef!);
+            document.removeEventListener("keydown", this.keydownDef!);
+            document.removeEventListener("keyup", this.keyupDef!);
+        }
+    }
     act(delta: number) {
         super.act(delta);
         if (!this.initialized) {

Parts/Part.ts

@@ -6,9 +6,9 @@ import type { Collider } from "./Children/Collider";
 import type { Scene } from "./Scene";
 
 type Tie<T extends Part = Part, L extends keyof T = keyof T, R extends keyof Part = keyof Part> = {
-  target: T;
-  localAttribute: R;
-  targetAttribute: L;
+    target: T;
+    localAttribute: R;
+    targetAttribute: L;
 };
 
 
@@ -42,6 +42,7 @@ export class Part {
         this.parent = undefined;
         this.top = undefined;
         this.ready = true;
+        this.type = this.constructor.name || "Part"; // Default type is the class name
         this.debugEmoji = "🧩"; // Default emoji for debugging
     }
     tie<T extends Part>(
@@ -54,7 +55,9 @@ export class Part {
         if (target.hasOwnProperty(targetAttribute as string)) {
             this.ties.add({
                 target,
+                // @ts-ignore - Intentionally allowing flexible typing for ties
                 localAttribute,
+                // @ts-ignore - Intentionally allowing flexible typing for ties
                 targetAttribute
             });
         }
@@ -128,13 +131,15 @@ export class Part {
         switch (attribute) {
             case "parent":
                 this.parent = undefined; // Clear parent reference
-                this.registrations.layer.flats.colliders = this.registrations.layer.flats.colliders.filter((c: Collider) => c as any !== this as any);
+                if (this.registrations.layer && this.registrations.layer.flats) {
+                    this.registrations.layer.flats.colliders = this.registrations.layer.flats.colliders.filter((c: Collider) => c as any !== this as any);
+                }
                 break;
             case "top":
                 this.top = undefined; // Clear top reference
                 break;
             case "layer":
-                if (this.registrations.layer) {
+                if (this.registrations.layer && this.registrations.layer.flats) {
                     this.registrations.layer.flats.colliders = this.registrations.layer.flats.colliders.filter((c: Collider) => c as any !== this as any);
                 }
                 break;
@@ -176,7 +181,7 @@ export class Part {
         }
     }
     attr<T>(attribute: string, value?: T): T | undefined {
-        if (!value ) {
+        if (!value) {
             return (this as any)[attribute] as T;
         }
         (this as any)[attribute] = value;

Parts/ParticleEmitter.ts

@@ -22,6 +22,11 @@ class Particle extends Part {
         }));
         this.addChild(new ColorRender({ width: size, height: size, color }));
     }
+    destroy(): void {
+        super.destroy();
+        this.velocity = Vector.From(0); // Reset velocity
+        this.lifetime = 0;
+    }
 
     act(delta: number) {
         super.act(delta);
@@ -79,6 +84,13 @@ export class ParticleEmitter extends Part {
         super.onMount(parent);
         if (this.top?.devmode) parent.addChild(new ColorRender({ width: 100, height: 100, color: "rgba(255, 255, 255, 0.5)" }));
     }
+    destroy(): void {
+        super.destroy();
+        // Clean up particles
+        this.particles = [];
+        this.lastEmissionTime = 0;
+        this.emittedCount = 0;
+    }
     act(delta: number) {
         super.act(delta);
         const now = Date.now();
@@ -95,7 +107,6 @@ export class ParticleEmitter extends Part {
                     lifetime: this.particleLifetime
                 });
                 this.addChild(particle);
-                console.log(this);
                 particle.child<Transform>("Transform")!.position = transform.position.clone(); // Start at emitter's position
                 this.emittedCount++;
                 this.lastEmissionTime = now;

Parts/PhysicsEngine.ts

@@ -20,7 +20,14 @@ export class PhysicsEngine extends Part {
         this.debugEmoji = "⚛️";
         this.type = "PhysicsEngine";
     }
-
+    destroy(): void {
+        super.destroy();
+        // Clean up the physics engine
+        if (this.world) {
+            World.clear(this.world, false); // Clear the world without resetting the engine
+            this.engine = Engine.create(); // Reset the engine
+        }
+    }
     onMount(parent: Part) {
         super.onMount(parent);
     }

Parts/SoundManager.ts

@@ -22,8 +22,17 @@ class SoundManagerController {
     }
 
     public unregisterSound(sound: Sound): void {
+        sound.stop(); // Stop the sound before unregistering
         this.sounds = this.sounds.filter(s => s !== sound);
     }
+    public pauseGame(): void {
+        this.isGameRunning = false;
+        this.sounds.forEach(sound => sound.pause());
+    }
+    public resumeGame(): void {
+        this.isGameRunning = true;
+        this.sounds.forEach(sound => sound.play({ restart: true }));
+    }
 
     public startGame(): void {
         this.isGameRunning = true;
@@ -33,10 +42,17 @@ class SoundManagerController {
             }
         });
     }
-
+    public unregisterAllSounds(): void {
+        this.sounds.forEach(sound => sound.stop());
+        this.sounds = [];
+    }
     public stopGame(): void {
         this.isGameRunning = false;
         this.sounds.forEach(sound => sound.stop());
+        // Dump sounds from memory
+        SoundManager.unregisterAllSounds();
+
+        // 
     }
 
     public getIsGameRunning(): boolean {

docs/api-reference.md

@@ -16,6 +16,9 @@ This section provides a detailed reference for the core classes and components i
 -   [Transform](./api/Transform.md)
 -   [Camera](./api/Camera.md)
 -   [Input](./api/Input.md)
+-   [Sound](./api/Sound.md)
+-   [ParallaxLayer](./api/ParallaxLayer.md)
+
 
 ### Renderers
 -   [Renderer](./api/Renderer.md) (Base class)
@@ -25,11 +28,38 @@ This section provides a detailed reference for the core classes and components i
 -   [TextRender](./api/TextRender.md)
 -   [Button](./api/Button.md)
 
+
 ### Colliders
 -   [Collider](./api/Collider.md) (Base class)
 -   [BoxCollider](./api/BoxCollider.md)
 -   [PolygonCollider](./api/PolygonCollider.md)
+-   [AreaTrigger](./api/AreaTrigger.md)
+
+
+
+### Game Logic
+
+-   [CameraShake](./api/CameraShake.md)
+-   [CharacterMovement](./api/CharacterMovement.md)
+-   [Follow](./api/Follow.md)
+-   [Health](./api/Health.md)
+-   [HealthBar](./api/HealthBar.md)
+-   [ParticleEmitter](./api/ParticleEmitter.md)
+-   [Projectile](./api/Projectile.md)
+-   [Spawner](./api/Spawner.md)
+-   [Timer](./api/Timer.md)
+-   [WaypointFollower](./api/WaypointFollower.md)
+- 
+
+### Phyiscs
+-   [PhysicsBody](./api/PhysicsBody.md)
+-   [PhysicsEngine](./api/PhysicsEngine.md)
+
+### Misc.
+-   [Rotator](./api/Rotator.md)
+-   [Scaler](./api/Scaler.md)
 
 ## Math
 
--   [Vector](./api/Vector.md)
+-   [Vector](./api/Vector.md)
+