whoopee

Author: sojs-coder

.gitignore

@@ -173,3 +173,6 @@ dist
 
 # Finder (MacOS) folder config
 .DS_Store
+
+# Bun package manager files
+bun.lock

Math/Vector.ts

@@ -5,7 +5,9 @@ export class Vector {
         this.x = x;
         this.y = y;
     }
-
+    distance(other: Vector): number {
+        return Math.sqrt((this.x - other.x) ** 2 + (this.y - other.y) ** 2);
+    }
     add(other: number | Vector): Vector {
         if (other instanceof Vector) {
             return new Vector(this.x + other.x, this.y + other.y);

Parts/AreaTrigger.ts

@@ -6,11 +6,12 @@ export class AreaTrigger extends Part {
     onExit?: (other: Collider) => void;
     activeCollisions: Set<Collider> = new Set();
 
-    constructor({ name, onEnter, onExit }: { name?: string, onEnter?: (other: Collider) => void, onExit?: (other: Collider) => void }) {
-        super({ name: name || 'AreaTrigger' });
+    constructor({ onEnter, onExit }: { onEnter?: (other: Collider) => void, onExit?: (other: Collider) => void }) {
+        super({ name: 'AreaTrigger' });
         this.onEnter = onEnter;
         this.onExit = onExit;
         this.debugEmoji = "🧲";
+        this.type = "AreaTrigger";
     }
 
     act(delta: number) {

Parts/Camera.ts

@@ -7,11 +7,11 @@ import { Scene } from "./Scene";
 export class Camera extends Part {
     zoom: Vector;
 
-    constructor({ name }: { name: string, zoom?: Vector }) {
-        super();
-        this.name = name;
+    constructor({ name, zoom }: { name: string, zoom?: Vector }) {
+        super({ name });
         this.zoom = Vector.From(1);
         this.debugEmoji = "📷"; // Camera specific emoji for debugging
+        this.type = "Camera";
     }
 
     onMount(parent: Part) {
@@ -38,15 +38,20 @@ export class Camera extends Part {
 
     getViewMatrix(): { offset: Vector; scale: Vector } {
         // Could be used in rendering context
+        const transform = this.child<Transform>("Transform")
+        if (!transform) {
+            console.warn(`Camera <${this.name}> (${this.id}) does not have a Transform component. View matrix will not be calculated.`);
+            return { offset: Vector.From(0), scale: this.zoom };
+        }
         return {
-            offset: (this.children["Transform"] as Transform).worldPosition.multiply(-1), // View shift is inverse of camera
+            offset: (transform).worldPosition.multiply(-1), // View shift is inverse of camera
             scale: this.zoom
         };
     }
 
     act(delta: number) {
         super.act(delta);
-        const transform = this.children["Transform"] as Transform;
+        const transform = this.child<Transform>("Transform");
         if (transform) {
             this.zoom = transform.scale;
         } else {

Parts/CameraShake.ts

@@ -1,60 +1,68 @@
 import { Part } from "./Part";
-import { Camera } from "./Camera";
 import { Transform } from "./Children/Transform";
 import { Vector } from "../Math/Vector";
+import type { Follow } from "./Follow";
 
 export class CameraShake extends Part {
     intensity: number;
     duration: number;
+    initialized: boolean = false;
     private shakeTimer: number = 0;
     private originalCameraPosition: Vector | null = null;
 
-    constructor({ name, intensity = 5, duration = 60 }: { name?: string, intensity?: number, duration?: number }) {
-        super({ name: name || 'CameraShake' });
+    constructor({ intensity = 5, duration = 60 }: { intensity?: number, duration?: number }) {
+        super({ name:'CameraShake' });
         this.intensity = intensity;
         this.duration = duration;
         this.debugEmoji = " tremors";
+        this.type = "CameraShake";
     }
 
-    onMount(parent: Part) {
-        super.onMount(parent);
+    initialize() {
+        this.initialized = true;
         // Find the camera in the scene and store its original position
         const camera = this.top?.currentScene?.activeCamera;
         if (camera) {
-            const cameraTransform = camera.children["Transform"] as Transform | undefined;
+            const cameraTransform = camera.child<Transform>("Transform");
             if (cameraTransform) {
                 this.originalCameraPosition = cameraTransform.position.clone();
             }
         }
     }
-
     shake() {
         this.shakeTimer = this.duration;
     }
 
     act(delta: number) {
         super.act(delta);
+        if (!this.initialized) {
+            this.initialize();
+        }
+
+        const camera = this.top?.currentScene?.activeCamera;
+        const follow = camera?.child<Follow>("Follow");
+        const transform = camera?.child<Transform>("Transform");
+
         if (this.shakeTimer > 0) {
-            const camera = this.top?.currentScene?.activeCamera;
-            if (camera) {
-                const cameraTransform = camera.children["Transform"] as Transform | undefined;
-                if (cameraTransform) {
-                    const offsetX = (Math.random() - 0.5) * this.intensity;
-                    const offsetY = (Math.random() - 0.5) * this.intensity;
-                    cameraTransform.moveTo(this.originalCameraPosition!.add(new Vector(offsetX, offsetY)));
-                }
+            const offsetX = (Math.random() - 0.5) * this.intensity;
+            const offsetY = (Math.random() - 0.5) * this.intensity;
+
+            if (follow) {
+                follow.externalOffset.set(offsetX, offsetY);
+            } else if (transform && this.originalCameraPosition) {
+                transform.moveTo(this.originalCameraPosition.add(new Vector(offsetX, offsetY)));
             }
+
             this.shakeTimer--;
-        } else if (this.originalCameraPosition) {
-            // Reset camera position after shake
-            const camera = this.top?.currentScene?.activeCamera;
-            if (camera) {
-                const cameraTransform = camera.children["Transform"] as Transform | undefined;
-                if (cameraTransform) {
-                    cameraTransform.moveTo(this.originalCameraPosition);
-                }
+        } else {
+            if (follow) {
+                follow.externalOffset.set(0, 0);
+            } else if (transform && this.originalCameraPosition) {
+                transform.moveTo(this.originalCameraPosition);
             }
         }
+
         this.hoverbug = `Shaking: ${this.shakeTimer > 0 ? "✅" : "❌"}`;
     }
+
 }

Parts/CharacterMovement.ts

@@ -8,11 +8,12 @@ export class CharacterMovement extends Part {
     movementType: 'WASD' | 'ArrowKeys' | 'BOTH';
     input: Input | undefined;
 
-    constructor({ name, speed = 5, movementType = 'WASD', input }: { name?: string, speed?: number, movementType?: 'WASD' | 'ArrowKeys' | 'BOTH', input?: Input }) {
-        super({ name: name || 'CharacterMovement' });
+    constructor({ speed = 5, movementType = 'WASD', input }: { speed?: number, movementType?: 'WASD' | 'ArrowKeys' | 'BOTH', input?: Input }) {
+        super({ name: 'CharacterMovement' });
         this.speed = speed;
         this.movementType = movementType;
-        this.input = input
+        this.input = input;
+        this.type = "CharacterMovement";
     }
 
     act(_delta: number): void {
@@ -26,7 +27,6 @@ export class CharacterMovement extends Part {
         }
 
         const keys = this.input.downkeys;
-
         let dx = 0;
         let dy = 0;
 
@@ -64,7 +64,8 @@ export class CharacterMovement extends Part {
             dx *= Math.SQRT1_2; // 1 / sqrt(2)
             dy *= Math.SQRT1_2;
         }
-
-        transform.move(new Vector(dx * this.speed, dy * this.speed));
+        if (dx !== 0 || dy !== 0) {
+            transform.move(new Vector(dx * this.speed, dy * this.speed));
+        }
     }
 }

Parts/Children/AnimatedSprite.ts

@@ -17,6 +17,7 @@ export class AnimatedSprite extends Renderer {
     disableAntiAliasing: boolean = false; // Option to disable anti-aliasing
     webEngine: boolean = false; // Flag to indicate if this is running in a web engine context
     onAnimationComplete?: (animationName: string, sprite: AnimatedSprite) => void; // Callback for when an animation completes
+    spritesheetImage?: string; // Optional image for the spritesheet
     constructor({ spritesheet, spritesheetImage, width, height, startingAnimation, disableAntiAliasing = false, onAnimationComplete, webEngine = false }: { spritesheet: string, spritesheetImage?: string, width: number, height: number, startingAnimation?: string, disableAntiAliasing?: boolean, onAnimationComplete?: (animationName: string, sprite: AnimatedSprite) => void, webEngine?: boolean }) {
         super({ width, height }); // Call the parent constructor with empty imageSource
         this.name = "AnimatedSprite";
@@ -25,11 +26,12 @@ export class AnimatedSprite extends Renderer {
         this.width = width;
         this.height = height;
         this.ready = false;
-        this.spritesheetImage = spritesheetImage; // Optional image for the spritesheet
+        
         this.currentAnimation = startingAnimation || "default";
         this.disableAntiAliasing = disableAntiAliasing;
         this.onAnimationComplete = onAnimationComplete; // Set the callback for animation completion
         this.webEngine = webEngine; // Set the web engine flag
+        this.type = "AnimatedSprite";
     }
 
     async onMount(parent: Part) {

Parts/Children/BoxCollider.ts

@@ -19,6 +19,7 @@ export class BoxCollider extends Collider {
         this.end = new Vector(width / 2, height / 2);
         this.realWorldStart = this.start; // Will be updated in act(), onMount()
         this.realWorldEnd = this.end; // Will be updated in act(), onMount()
+        this.type = "BoxCollider";
     }
     onMount(parent: Part) {
         super.onMount(parent);
@@ -67,7 +68,6 @@ export class BoxCollider extends Collider {
                 rel.x * cos - rel.y * sin,
                 rel.x * sin + rel.y * cos
             );
-            console.log(transform);
 
             return transform.worldPosition.add(rotated.add(center));
         });

Parts/Children/Button.ts

@@ -5,11 +5,12 @@ import { Input } from "../Input";
 import { Scene } from "../Scene";
 import { Renderer } from "./Renderer";
 import { Sound } from "../Sound";
+import { isNamedTupleMember } from "typescript";
 
 export class Button extends Renderer {
     styles?: ButtonStyles;
-    private isHovered: boolean = false;
-    private isActive: boolean = false;
+    isHovered: boolean = false;
+    isActive: boolean = false;
     private onClickHandler: () => void;
     clickSound?: Sound;
     hoverSound?: Sound;
@@ -23,6 +24,7 @@ export class Button extends Renderer {
         this.clickSound = clickSound;
         this.hoverSound = hoverSound;
         this.activeSound = activeSound;
+        this.type = "Button";
 
         this.onclick = (event: MouseEvent, input: any) => {
             if (this.onClickHandler) {
@@ -62,7 +64,6 @@ export class Button extends Renderer {
             }
         };
     }
-
     onMount(parent: Part) {
         super.onMount(parent);
         if (!this.sibling("Transform")) {
@@ -74,10 +75,10 @@ export class Button extends Renderer {
         // Ensure an Input instance is attached to the scene
         if (this.parent instanceof Scene && !this.parent.sibling("Input")) {
             this.parent.addChild(new Input({
-                key: () => {},
-                keyup: () => {},
-                mousemove: () => {},
-                click: () => {},
+                key: () => { },
+                keyup: () => { },
+                mousemove: () => { },
+                click: () => { },
             }));
         }
 

Parts/Children/Collider.ts

@@ -6,8 +6,8 @@ export class Collider extends Part {
     colliding: boolean = false;
     collidingWith: Set<Collider> = new Set(); // List of colliding parts
     constructor() {
-        super();
-        this.name = "Collider";
+        super({ name: "Collider" });
+        this.type = "Collider";
     }
 
     onMount(parent: Part) {