malc-game-engine 1.0.1 → 1.0.3

package/malc.js

@@ -1,6 +1,6 @@
 /**
  * MALC Game Engine Library
- * Version: 1.0.0
+ * Version: 1.0.3
  * Description: A comprehensive 2D game engine for p5.js
  */
 
@@ -17,6 +17,9 @@
     }
 }(typeof self !== 'undefined' ? self : this, function(p5) {
 
+// Store reference to p5 instance
+const _p5 = p5;
+
 // ========== GLOBAL ARRAYS ==========
 const MALCgameObjects = [];
 const MALCbuttons = [];
@@ -37,1121 +40,1213 @@ function generateId(prefix) {
     return `${prefix}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
 }
 
-// ========== GAME OBJECT CLASS WITH GRAVITY ==========
-class gameObject {
-    static objects = [];
-    static started = false;
-    static gravity = GRAVITY;
-    static terminalVelocity = TERMINAL_VELOCITY;
+// ========== COLORED TEXT FUNCTIONS (SAFE VERSION) ==========
+function parseColoredLine(str) {
+    const regex = /\\([^|\\\n]+)\|([^|]+)\|/g;
+    const parts = [];
+    let lastIndex = 0;
+    let match;
     
-    static render() {
-        MALCgameObjects.forEach(o => {
-            if (o.active) o.render();
+    while ((match = regex.exec(str)) !== null) {
+        if (match.index > lastIndex) {
+            parts.push({
+                text: str.substring(lastIndex, match.index),
+                color: null
+            });
+        }
+        
+        parts.push({
+            text: match[2],
+            color: match[1]
         });
+        
+        lastIndex = match.index + match[0].length;
     }
     
-    static update() {
-        this.started = true;
-        this.objects = MALCgameObjects;
-        
-        // Update all active objects
-        MALCgameObjects.forEach(o => {
-            if (o.active) o.update();
+    if (lastIndex < str.length) {
+        parts.push({
+            text: str.substring(lastIndex),
+            color: null
         });
     }
+    
+    return parts.length ? parts : [{ text: str, color: null }];
+}
 
-    static initialize() {
-        console.log("MALC gameObjects initialized");
+function parseColoredText(str) {
+    const lines = str.split('\n');
+    const result = [];
+    
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const parts = parseColoredLine(line);
         
-        // Add objects to their scenes
-        MALCgameObjects.forEach(o => {
-            o.scenes.forEach(sceneId => {
-                let scene = Scene.getSceneById(sceneId);
-                if (scene && !scene.objects.includes(o)) {
-                    scene.objects.push(o);
-                }
+        result.push(...parts);
+        
+        if (i < lines.length - 1) {
+            result.push({
+                text: '\n',
+                color: null,
+                isNewline: true
             });
+        }
+    }
+    
+    return result;
+}
+
+function renderColoredText(p, str, x, y, horizontal, vertical, maxWidth) {
+    const parts = parseColoredText(str);
+    let currentX = x;
+    let currentY = y;
+    
+    p.push();
+    p.textAlign(horizontal, vertical);
+    
+    for (const part of parts) {
+        if (part.isNewline) {
+            currentX = x;
+            currentY += p.textLeading() || p.textSize() * 1.2;
+            continue;
+        }
+        
+        if (part.color) {
+            try {
+                p.fill(part.color);
+            } catch (e) {
+                p.fill(255);
+            }
+        }
+        
+        p.text(part.text, currentX, currentY, maxWidth);
+        currentX += p.textWidth(part.text);
+    }
+    
+    p.pop();
+}
+
+// ========== SCENE CLASS (DEFINED FIRST) ==========
+class Scene {
+    static scenes = [];
+    static activeScene = "blank";
+    static started = false;
+    static sceneHistory = [];
+    static historyLimit = 10;
+
+    static update() {
+        this.started = true;
+        this.scenes = MALCScene;
+        
+        let activeSceneFound = false;
+        
+        this.scenes.forEach(S => {
+            if (S.id == this.activeScene) {
+                activeSceneFound = true;
+                
+                this.scenes.forEach(s => {
+                    if (s != S) {
+                        s._active = false;
+                        s.active = false;
+                        
+                        s.objects.forEach(o => {
+                            if (o && typeof o.active !== 'undefined') o.active = false;
+                        });
+                    }
+                });
+                
+                S.active = true;
+                
+                if (!S._active) {
+                    S.activated = MALC.time.getTime();
+                    if (typeof S.onActivate == 'function') S.onActivate();
+                }
+                
+                S._active = true;
+                S.timeActive = MALC.time.getTime() - S.activated;
+                
+                S.objects.forEach(o => {
+                    if (o && typeof o.active !== 'undefined') o.active = true;
+                });
+                
+                _p5.prototype.push();
+                if (window.camera && typeof window.camera.render == 'function') {
+                    window.camera.render();
+                }
+                
+                S.render();
+                
+                _p5.prototype.pop();
+            }
         });
+        
+        if (!activeSceneFound && this.activeScene != "blank") {
+            console.warn(`Scene "${this.activeScene}" not found, switching to blank`);
+            this.activeScene = "blank";
+        }
     }
     
-    static getObjectByIndex(index) {
-        return MALCgameObjects[index] || null;
+    static getSceneById(id) {
+        return MALCScene.find(scene => scene.id == id) || null;
     }
     
-    static getActiveObjects() {
-        return MALCgameObjects.filter(o => o.active);
+    static getActiveScene() {
+        return this.getSceneById(this.activeScene);
     }
     
-    static getObjectsInScene(sceneId) {
-        let scene = Scene.getSceneById(sceneId);
-        return scene ? scene.objects : [];
+    static switchToScene(id, addToHistory = true) {
+        let scene = this.getSceneById(id);
+        if (scene) {
+            if (addToHistory && this.activeScene) {
+                this.sceneHistory.push(this.activeScene);
+                if (this.sceneHistory.length > this.historyLimit) {
+                    this.sceneHistory.shift();
+                }
+            }
+            this.activeScene = id;
+        } else {
+            console.error(`Cannot switch to scene "${id}" - not found`);
+        }
     }
     
-    static setGlobalGravity(value) {
-        this.gravity = value;
+    static goBack() {
+        if (this.sceneHistory.length > 0) {
+            let previousScene = this.sceneHistory.pop();
+            this.switchToScene(previousScene, false);
+            return true;
+        }
+        return false;
     }
     
-    static getGlobalGravity() {
-        return this.gravity;
+    static getAllScenes() {
+        return [...MALCScene];
+    }
+    
+    static getScenesWithObject(object) {
+        return MALCScene.filter(scene => scene.objects.includes(object));
+    }
+    
+    static getScenesByTag(tag) {
+        return MALCScene.filter(scene => scene.hasTag(tag));
     }
 
-    constructor(x = 0, y = 0, w = 20, h = 20, ...scenes) {
-        this.id = generateId('gameObject');
-        this.x = x;
-        this.y = y;
-        this.width = w;
-        this.height = h;
-        this.rotation = 0;
-        this.rotationMode = "degrees";
-        this.velocity = [0, 0];
-        this.velocityMatrix = [0, 0];
-        this.velocityMode = "polar";
-        this.rvm = "unlinked";
-        
-        // Gravity properties
-        this.gravity = {
-            enabled: false,
-            velocity: 0,
-            grounded: false,
-            groundTolerance: 1, // pixels
-            mass: 1,
-            bounce: 0, // 0 = no bounce, 1 = full bounce
-            friction: 0.1 // ground friction
-        };
+    constructor(id, backgroundColor, ...scripts) {
+        MALCScene.forEach(s => {
+            if (s.id == id || typeof id != "string") {
+                throw new Error(`Scenes must have unique IDs and be strings. Duplicate/Invalid ID: "${id}"`);
+            }
+        });
         
-        this.formatting = {
-            outline: [false, 0, "black"],
-            color: "white",
-        };
+        this.id = id;
+        this.backColor = backgroundColor;
+        this.scripts = scripts;
         
-        this.collition = true;
+        this.objects = [];
+        this.uiPlanes = [];
         
-        this.scripts = [];
-        this.scenes = scenes.length < 1 ? ["blank"] : [...new Set(scenes)];
         this.active = false;
-        this.visible = true;
-        this.parentScene = null;
-        
-        this.debug = false;
-        this.hitbox = {
-            x: 0,
-            y: 0,
-            width: 0,
-            height: 0,
-            rotation: 0,
-            parts: null,
-            outline: 1,
-        };
+        this._active = false;
+        this.activated = 0;
+        this.timeActive = -1;
         
-        this.objectInstance = MALCgameObjects.length;
-        this.lastGroundY = y;
+        this.tags = [];
+        this.paused = false;
+        this.transition = null;
+        this.onActivateCallbacks = [];
+        this.onDeactivateCallbacks = [];
+        this.onUpdateCallbacks = [];
         
-        MALCgameObjects.push(this);
+        this.sceneInstance = MALCScene.length;
+        MALCScene.push(this);
     }
     
-    // Enable gravity for this object
-    enableGravity() {
-        this.gravity.enabled = true;
-        return this;
-    }
-    
-    // Disable gravity for this object
-    disableGravity() {
-        this.gravity.enabled = false;
-        this.gravity.velocity = 0;
-        return this;
-    }
-    
-    // Set gravity parameters
-    setGravity(options = {}) {
-        if (options.enabled !== undefined) this.gravity.enabled = options.enabled;
-        if (options.mass !== undefined) this.gravity.mass = Math.max(0.1, options.mass);
-        if (options.bounce !== undefined) this.gravity.bounce = Math.min(1, Math.max(0, options.bounce));
-        if (options.friction !== undefined) this.gravity.friction = Math.min(1, Math.max(0, options.friction));
-        if (options.groundTolerance !== undefined) this.gravity.groundTolerance = options.groundTolerance;
-        return this;
-    }
-    
-    // Apply gravity to this object
-    applyGravity() {
-        if (!this.gravity.enabled) return;
-        
-        // Apply gravity acceleration (scaled by mass)
-        this.gravity.velocity += gameObject.gravity * this.gravity.mass;
+    render() {
+        if (this.paused) return;
         
-        // Limit to terminal velocity
-        this.gravity.velocity = Math.min(this.gravity.velocity, gameObject.terminalVelocity);
+        if (this.transition) {
+            this.applyTransition();
+        }
         
-        // Store last position before moving
-        let lastY = this.y;
+        _p5.prototype.background(this.backColor);
         
-        // Apply vertical movement
-        this.y += this.gravity.velocity;
+        this.scripts.forEach(exe => {
+            if (typeof exe == "function") exe(this);
+        });
         
-        // Check for ground collision with other objects
-        this.checkGroundCollision();
+        this.onUpdateCallbacks.forEach(cb => {
+            if (typeof cb == "function") cb(this);
+        });
         
-        // If we just landed, stop downward velocity
-        if (this.gravity.grounded) {
-            this.gravity.velocity = 0;
-            
-            // Apply ground friction to horizontal movement
-            if (this.gravity.friction > 0 && this.velocityMode === "polar") {
-                this.velocity[0] *= (1 - this.gravity.friction);
-                if (Math.abs(this.velocity[0]) < 0.01) this.velocity[0] = 0;
+        this.objects.forEach(o => {
+            if (o && typeof o.update == "function") {
+                o.update(true);
             }
-        }
-    }
-    
-    // Check if this object is standing on another object
-    checkGroundCollision() {
-        if (!this.collition || !this.gravity.enabled) return;
-        
-        let wasGrounded = this.gravity.grounded;
-        this.gravity.grounded = false;
+            if (o && typeof o.render == "function") {
+                o.render();
+            }
+        });
         
-        // Check collision with other objects in the same scene
-        if (this.parentScene && this.parentScene.objects) {
-            this.parentScene.objects.forEach(other => {
-                // Skip self and inactive objects
-                if (other.id === this.id || !other.active) return;
-                
-                // Only check if gravity is enabled on this object and we're moving downward
-                if (this.gravity.velocity <= 0) return;
-                
-                // Check if other object is below this one
-                let verticalDistance = (other.y - other.height/2) - (this.y + this.height/2);
-                
-                // If within ground tolerance and horizontally overlapping
-                if (Math.abs(verticalDistance) <= this.gravity.groundTolerance &&
-                    this.x + this.width/2 > other.x - other.width/2 &&
-                    this.x - this.width/2 < other.x + other.width/2) {
-                    
-                    this.gravity.grounded = true;
-                    this.lastGroundY = other.y - other.height/2 - this.height/2;
-                    
-                    // Apply bounce if enabled
-                    if (this.gravity.bounce > 0 && wasGrounded === false) {
-                        this.gravity.velocity = -this.gravity.velocity * this.gravity.bounce;
-                        
-                        // If bounce velocity is very small, just set to zero
-                        if (Math.abs(this.gravity.velocity) < 0.1) {
-                            this.gravity.velocity = 0;
-                        }
-                    } else {
-                        // Position exactly on ground
-                        this.y = this.lastGroundY;
-                    }
+        if (typeof UIPlanes !== 'undefined' && UIPlanes.length > 0) {
+            UIPlanes.forEach(ui => {
+                if (ui && typeof ui.belongsToScene == "function" && ui.belongsToScene(this.id)) {
+                    ui.render();
                 }
             });
         }
-    }
-    
-    update() {
-        if (!this.active) return;
-        
-        // Apply gravity if enabled
-        this.applyGravity();
         
-        let vel = this.velocity[0];
-        let angle = this.velocity[1];
-        
-        if (this.velocityMode == "polar") {
-            let linked = false;
-            if (!/unlinked/i.test(this.rvm) && /linked/i.test(this.rvm)) {
-                this.velocity[1] = this.rotation;
-                linked = true;
-            }
-
-            let rot = linked ? 
-                (this.rotationMode == "degrees" ? (this.rotation) : radians(this.rotation)) : 
-                (this.rotationMode == "degrees" ? (this.velocity[1]) : (this.velocity[1]));
-            
-            if(isNaN(rot)){
-                vel = 0;
-                rot = 0;
-            }
-            
-            let vx = vel * cos(rot);
-            let vy = vel * sin(rot);
-
-            this.velocityMatrix = [vx, vy];
-            
-            // Don't apply horizontal movement if gravity is enabled and we're grounded with friction
-            if (!(this.gravity.enabled && this.gravity.grounded && this.gravity.friction > 0)) {
-                this.x += vx;
-            }
-            
-            // Vertical movement is handled by gravity when enabled
-            if (!this.gravity.enabled) {
-                this.y += vy;
-            }
-        } else {
-            // Cartesian velocity mode
-            if (!(this.gravity.enabled && this.gravity.grounded && this.gravity.friction > 0)) {
-                this.x += vel;
-            }
-            if (!this.gravity.enabled) {
-                this.y += angle;
+        this.uiPlanes.forEach(ui => {
+            if (ui && typeof ui.render == "function") {
+                ui.render();
             }
-        }
-        
-        // Update parent scene reference
-        this.updateParentScene();
+        });
         
-        MALCgameObjects[this.objectInstance] = this;
+        MALCScene[this.sceneInstance] = this;
     }
     
-    render() {
-        if (!this.active) return;
-        
-        this.scripts.forEach(s => {
-            if(typeof s == "function")s(this);
-        });
+    applyTransition() {
+        if (!this.transition || !this.transition.active) return;
         
-        let outline = this.formatting.outline;
-        let hb = this.hitbox;
+        this.transition.progress += 1/60;
         
-        // Draw debug hitbox if enabled
-        if (this.debug) {
-            push();
-            translate(this.x, this.y);
-            rectMode(CENTER);
-            if (this.rotationMode == "degrees") angleMode(DEGREES);
-            rotate(this.rotation + hb.rotation);
-
-            stroke("#00FF27");
-            strokeWeight(hb.outline);
-            noFill();
-            rect(hb.x, hb.y, this.width + hb.width, this.height + hb.height);
-            
-            // Draw gravity indicator if enabled
-            if (this.gravity.enabled) {
-                stroke(0, 255, 0, 100);
-                line(0, 0, 0, this.gravity.velocity * 5);
-            }
-            
-            pop();
+        if (this.transition.progress >= this.transition.duration) {
+            this.transition.active = false;
+            this.transition = null;
+            return;
         }
         
-        if (!this.visible) return;
-        
-        push();
-        translate(this.x, this.y);
-        rectMode(CENTER);
-        if (this.rotationMode == "degrees") angleMode(DEGREES);
-        rotate(this.rotation);
+        let t = this.transition.progress / this.transition.duration;
         
-        if (outline[0]) {
-            strokeWeight(outline[1]);
-            stroke(outline[2]);
-        } else {
-            noStroke();
+        _p5.prototype.push();
+        switch(this.transition.type) {
+            case "fade":
+                _p5.prototype.fill(0, 255 * (1 - t));
+                _p5.prototype.rect(0, 0, _p5.prototype.width, _p5.prototype.height);
+                break;
+            case "slide":
+                _p5.prototype.translate(_p5.prototype.width * (1 - t), 0);
+                break;
         }
-        
-        fill(this.formatting.color);
-        rect(0, 0, this.width, this.height);
-        pop();
-    }
-
-    // ========== HELPFUL METHODS ==========
-    
-    belongsToScene(sceneId) {
-        return this.scenes.includes(sceneId);
+        _p5.prototype.pop();
     }
     
-    addToScene(sceneId) {
-        if (!this.scenes.includes(sceneId)) {
-            this.scenes.push(sceneId);
-            let scene = Scene.getSceneById(sceneId);
-            if (scene && !scene.objects.includes(this)) {
-                scene.objects.push(this);
+    addObject(object) {
+        if (object && !this.objects.includes(object)) {
+            this.objects.push(object);
+            if (typeof object.addToScene == "function") {
+                object.addToScene(this.id);
             }
         }
         return this;
     }
     
-    removeFromScene(sceneId) {
-        this.scenes = this.scenes.filter(id => id != sceneId);
-        let scene = Scene.getSceneById(sceneId);
-        if (scene) {
-            scene.objects = scene.objects.filter(obj => obj != this);
+    addObjects(objects) {
+        objects.forEach(obj => this.addObject(obj));
+        return this;
+    }
+    
+    removeObject(object) {
+        this.objects = this.objects.filter(obj => obj != object);
+        if (object && typeof object.removeFromScene == "function") {
+            object.removeFromScene(this.id);
         }
         return this;
     }
     
-    removeFromAllScenes() {
-        this.scenes.forEach(sceneId => {
-            let scene = Scene.getSceneById(sceneId);
-            if (scene) {
-                scene.objects = scene.objects.filter(obj => obj != this);
+    clearObjects() {
+        this.objects.forEach(obj => {
+            if (obj && typeof obj.removeFromScene == "function") {
+                obj.removeFromScene(this.id);
             }
         });
-        this.scenes = [];
+        this.objects = [];
         return this;
     }
     
-    updateParentScene() {
-        if (Scene.activeScene) {
-            let activeScene = Scene.getSceneById(Scene.activeScene);
-            if (activeScene && this.belongsToScene(activeScene.id)) {
-                this.parentScene = activeScene;
-            }
+    getObjects(filter) {
+        if (typeof filter == "function") {
+            return this.objects.filter(filter);
+        } else if (filter == "button") {
+            return this.objects.filter(obj => obj instanceof Button);
+        } else if (filter == "gameObject") {
+            return this.objects.filter(obj => obj instanceof gameObject);
         }
+        return this.objects;
     }
     
-    distanceTo(target) {
-        let dx = target.x !== undefined ? target.x - this.x : target[0] - this.x;
-        let dy = target.y !== undefined ? target.y - this.y : target[1] - this.y;
-        return Math.sqrt(dx * dx + dy * dy);
+    getObjectById(id) {
+        return this.objects.find(obj => obj && obj.id == id);
     }
     
-    collidesWith(other) {
-        return (this.x < other.x + other.width &&
-                this.x + this.width > other.x &&
-                this.y < other.y + other.height &&
-                this.y + this.height > other.y);
+    addUIPlane(uiPlane) {
+        if (uiPlane && !this.uiPlanes.includes(uiPlane)) {
+            this.uiPlanes.push(uiPlane);
+            if (typeof uiPlane.addToScene == "function") {
+                uiPlane.addToScene(this.id);
+            }
+        }
+        return this;
     }
     
-    directionTo(x, y, err = 0.5) {
-        let pa = [x - this.x, y - this.y];
-        
-        let angle = (x && y) ? atan(pa[1]/pa[0]) : this.rotation;
-        var quads = [
-            pa[0] < -err && pa[1] > err,
-            pa[0] < -err && pa[1] < -err,
-            pa[0] > err && pa[1] > err,
-            pa[0] > err && pa[1] < -err,
-            (pa[0] < err && pa[0] > -err),
-            (pa[1] < err && pa[1] > -err),
-        ];
-        
-        let da = (Math.atan(pa[1]/pa[0])*180)/Math.PI;
-        
-        if((pa[1] > -err && pa[1] < err) && (pa[0] > -err && pa[0] < err)){
-            angle = NaN;
-        } else if(quads[0]){
-            angle = da+180;
-        } else if(quads[1]){
-            angle = da+180;
-        } else if(quads[2]){
-            angle = da;
-        } else if(quads[3]){
-            angle = da;
-        } else if(quads[4]){
-            if(pa[1] < -err) {
-                angle = -90;
-            } else if(pa[1] > err) {
-                angle = 90;
-            }
-        } else if(quads[5]){
-            if(pa[0] < -err) {
-                angle = 180;
-            } else if(pa[0] > err) {
-                angle = 0;
+    removeUIPlane(uiPlane) {
+        this.uiPlanes = this.uiPlanes.filter(ui => ui != uiPlane);
+        if (uiPlane && typeof uiPlane.removeFromScene == "function") {
+            uiPlane.removeFromScene(this.id);
+        }
+        return this;
+    }
+    
+    clearUIPlanes() {
+        this.uiPlanes.forEach(ui => {
+            if (ui && typeof ui.removeFromScene == "function") {
+                ui.removeFromScene(this.id);
             }
+        });
+        this.uiPlanes = [];
+        return this;
+    }
+    
+    addScript(script) {
+        if (typeof script == "function" && !this.scripts.includes(script)) {
+            this.scripts.push(script);
         }
-        
-        return angle;
+        return this;
     }
     
-    pointTo(target) {
-        this.rotation = this.directionTo(target);
+    removeScript(script) {
+        this.scripts = this.scripts.filter(s => s != script);
         return this;
     }
     
-    setPosition(x, y) {
-        this.x = x;
-        this.y = y;
+    clearScripts() {
+        this.scripts = [];
         return this;
     }
     
-    move(dx, dy) {
-        this.x += dx;
-        this.y += dy;
+    onActivate(callback) {
+        if (typeof callback == "function") {
+            this.onActivateCallbacks.push(callback);
+        }
         return this;
     }
     
-    setVelocity(speed, x, y, err = 0.5){
-        let angle = this.directionTo(x,y,err);
-        
-        if(isNaN(angle)){
-            angle = 0;
-            speed = 0;
+    onDeactivate(callback) {
+        if (typeof callback == "function") {
+            this.onDeactivateCallbacks.push(callback);
         }
-        
-        this.velocity = [speed, angle]; 
-        return this.velocity;
+        return this;
     }
     
-    destroy() {
-        this.removeFromAllScenes();
-        let index = MALCgameObjects.indexOf(this);
-        if (index > -1) {
-            MALCgameObjects.splice(index, 1);
+    onUpdate(callback) {
+        if (typeof callback == "function") {
+            this.onUpdateCallbacks.push(callback);
         }
+        return this;
     }
     
-    clone() {
-        let clone = new gameObject(this.x, this.y, this.width, this.height, ...this.scenes);
-        clone.rotation = this.rotation;
-        clone.rotationMode = this.rotationMode;
-        clone.velocity = [...this.velocity];
-        clone.velocityMode = this.velocityMode;
-        clone.rvm = this.rvm;
-        clone.formatting = JSON.parse(JSON.stringify(this.formatting));
-        clone.gravity = JSON.parse(JSON.stringify(this.gravity));
-        clone.debug = this.debug;
-        clone.hitbox = JSON.parse(JSON.stringify(this.hitbox));
-        return clone;
+    pause() {
+        this.paused = true;
+        return this;
     }
-
-    screenToWorld(screenX, screenY) {
-        if (window.camera && typeof camera.screenToWorld == "function") {
-            return camera.screenToWorld(screenX, screenY);
+    
+    resume() {
+        this.paused = false;
+        return this;
+    }
+    
+    setTransition(type, duration = 1.0) {
+        this.transition = {
+            type: type,
+            duration: duration,
+            progress: 0,
+            active: true
+        };
+        return this;
+    }
+    
+    addTag(tag) {
+        if (!this.tags.includes(tag)) {
+            this.tags.push(tag);
         }
-        return { x: screenX, y: screenY };
+        return this;
     }
     
-    isOnScreen() {
-        if (!window.camera) return true;
+    removeTag(tag) {
+        this.tags = this.tags.filter(t => t != tag);
+        return this;
+    }
+    
+    hasTag(tag) {
+        return this.tags.includes(tag);
+    }
+    
+    reset() {
+        this.clearObjects();
+        this.clearUIPlanes();
+        this.clearScripts();
+        this.onActivateCallbacks = [];
+        this.onDeactivateCallbacks = [];
+        this.onUpdateCallbacks = [];
+        this.tags = [];
+        this.paused = false;
+        this.transition = null;
+        this.timeActive = 0;
+        return this;
+    }
+    
+    destroy() {
+        let index = MALCScene.indexOf(this);
+        if (index > -1) {
+            MALCScene.splice(index, 1);
+        }
         
-        let cameraPos = camera.getOrientation();
-        let screenRight = cameraPos[0] + camera.width;
-        let screenBottom = cameraPos[1] + camera.height;
+        this.clearObjects();
+        this.clearUIPlanes();
         
-        return (this.x + this.width/2 > cameraPos[0] &&
-                this.x - this.width/2 < screenRight &&
-                this.y + this.height/2 > cameraPos[1] &&
-                this.y - this.height/2 < screenBottom);
+        if (Scene.activeScene == this.id) {
+            Scene.activeScene = "blank";
+        }
+    }
+    
+    clone(newId) {
+        let clone = new Scene(newId || this.id + "_copy", this.backColor, ...this.scripts);
+        clone.objects = [...this.objects];
+        clone.uiPlanes = [...this.uiPlanes];
+        clone.tags = [...this.tags];
+        return clone;
+    }
+    
+    getInfo() {
+        return {
+            id: this.id,
+            active: this.active,
+            timeActive: this.timeActive,
+            objectCount: this.objects.length,
+            uiPlaneCount: this.uiPlanes.length,
+            scriptCount: this.scripts.length,
+            tags: this.tags,
+            paused: this.paused
+        };
     }
 }
 
-// ========== BUTTON CLASS ==========
-class Button extends gameObject {
-    static buttons = [];
+// ========== GAME OBJECT CLASS WITH GRAVITY ==========
+class gameObject {
+    static objects = [];
+    static started = false;
+    static gravity = GRAVITY;
+    static terminalVelocity = TERMINAL_VELOCITY;
     
-    static updateButton() {
-        this.startedButtons = true;
-        this.buttons = MALCbuttons;
-        
-        this.buttons.forEach(b => {
-            if (!b.active) return;
-            
-            b.isHovered = b.events.hover();
-            
-            if (MALCbuttons.every(b => !b.events.hover())) {
-                cursor();
-            } else if (b.isHovered) {
-                cursor(b.cursor);
-            }
+    static render() {
+        MALCgameObjects.forEach(o => {
+            if (o.active) o.render();
         });
     }
     
-    static getButtonByIndex(index) {
-        return MALCbuttons[index] || null;
+    static update() {
+        this.started = true;
+        this.objects = MALCgameObjects;
+        
+        // Update all active objects
+        MALCgameObjects.forEach(o => {
+            if (o.active) o.update();
+        });
+    }
+
+    static initialize() {
+        console.log("MALC gameObjects initialized");
+        
+        // Add objects to their scenes
+        MALCgameObjects.forEach(o => {
+            o.scenes.forEach(sceneId => {
+                let scene = Scene.getSceneById(sceneId);
+                if (scene && !scene.objects.includes(o)) {
+                    scene.objects.push(o);
+                }
+            });
+        });
     }
     
-    static getHoveredButton() {
-        return MALCbuttons.find(b => b.active && b.events.hover());
+    static getObjectByIndex(index) {
+        return MALCgameObjects[index] || null;
     }
     
-    static getPressedButton() {
-        return MALCbuttons.find(b => b.active && b.events.pressed());
+    static getActiveObjects() {
+        return MALCgameObjects.filter(o => o.active);
     }
     
-    constructor(x = 0, y = 0, w = 20, h = 20, displayText = "Button", ...scenes) {
-        super(x, y, w, h, ...scenes);
-        
-        this.formatting.button = {
-            hover: 220,
-            clicked: 190,
-            text: {
-                color: 0,
-                size: 14,
-                style:"normal",
-                display: displayText,
-            },
-            colors: {
-                normal: 255,
-                hover: 220,
-                pressed: 190,
-                disabled: 150
-            }
-        };
-        
-        this.cursor = "pointer";
-        this.isHovered = false;
-        this.isPressed = false;
-        this.isDisabled = false;
-        this.clickCooldown = 100;
-        this.lastClickTime = 0;
-        this.cooldownActive = false;
-        
-        this.events = {
-            hover: (err = 0) => {
-                return !this.isDisabled && (
-                    mouse.x < this.x + this.width / 2 + err &&
-                    mouse.x > this.x - (this.width / 2 + err) &&
-                    mouse.y < this.y + this.height / 2 + err &&
-                    mouse.y > this.y - (this.height / 2 + err)
-                );
-            },
-            pressed: () => {
-                return this.events.hover() && mouse.down;
-            },
-            clicked: () => {
-                let wasPressed = this.wasPressed;
-                let isHovering = this.events.hover();
-                let mouseReleased = !mouse.down && wasPressed;
-
-                this.wasPressed = mouse.down && isHovering;
-
-                return mouseReleased && isHovering;
-            }
-        };
-
-        this.wasPressed = false;
-        this.onClick = null;
-        
-        this.buttonIndex = MALCbuttons.length;
-        MALCbuttons.push(this);
+    static getObjectsInScene(sceneId) {
+        let scene = Scene.getSceneById(sceneId);
+        return scene ? scene.objects : [];
     }
-
-    update(boolean) {
-        super.update(boolean);
-
-        if (this.cooldownActive) {
-            let currentTime = Date.now();
-            if (currentTime - this.lastClickTime >= this.clickCooldown) {
-                this.cooldownActive = false;
-            }
-        }
-
-        this.isHovered = this.events.hover();
-        this.isPressed = this.events.pressed();
-
-        if (this.events.clicked() && this.onClick && !this.isDisabled && !this.cooldownActive) {
-            this.onClick(this);
-            this.lastClickTime = Date.now();
-            this.cooldownActive = true;
-        }
-
-        MALCbuttons[this.buttonIndex] = this;
+    
+    static setGlobalGravity(value) {
+        this.gravity = value;
+    }
+    
+    static getGlobalGravity() {
+        return this.gravity;
     }
 
-    render() {
-        if (!this.active) return;
-        
-        let btnFormat = this.formatting.button;
-        let buttonColor;
+    constructor(x = 0, y = 0, w = 20, h = 20, ...scenes) {
+        this.id = generateId('gameObject');
+        this.x = x;
+        this.y = y;
+        this.width = w;
+        this.height = h;
+        this.rotation = 0;
+        this.rotationMode = "degrees";
+        this.velocity = [0, 0];
+        this.velocityMatrix = [0, 0];
+        this.velocityMode = "polar";
+        this.rvm = "unlinked";
         
-        if (this.isDisabled) {
-            buttonColor = btnFormat.colors.disabled;
-        } else if (this.isPressed) {
-            buttonColor = btnFormat.colors.pressed;
-        } else if (this.isHovered) {
-            buttonColor = btnFormat.colors.hover;
-        } else {
-            buttonColor = btnFormat.colors.normal;
-        }
+        // Gravity properties
+        this.gravity = {
+            enabled: false,
+            velocity: 0,
+            grounded: false,
+            groundTolerance: 1, // pixels
+            mass: 1,
+            bounce: 0, // 0 = no bounce, 1 = full bounce
+            friction: 0.1 // ground friction
+        };
         
-        let originalColor = this.formatting.color;
-        this.formatting.color = buttonColor;
+        this.formatting = {
+            outline: [false, 0, "black"],
+            color: "white",
+        };
         
-        super.render();
+        this.collition = true;
         
-        if(!this.visible) return;
+        this.scripts = [];
+        this.scenes = scenes.length < 1 ? ["blank"] : [...new Set(scenes)];
+        this.active = false;
+        this.visible = true;
+        this.parentScene = null;
         
-        push();
-        translate(this.x, this.y);
-        if (this.rotationMode == "degrees") angleMode(DEGREES);
-        rotate(this.rotation);
+        this.debug = false;
+        this.hitbox = {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            rotation: 0,
+            parts: null,
+            outline: 1,
+        };
         
-        textStyle(btnFormat.text.style);
-        textSize(btnFormat.text.size);
-        fill(btnFormat.text.color);
-        coloredText(btnFormat.text.display, 0, 0, CENTER, CENTER);
-        pop();
+        this.objectInstance = MALCgameObjects.length;
+        this.lastGroundY = y;
         
-        this.formatting.color = originalColor;
+        MALCgameObjects.push(this);
     }
     
-    // ========== BUTTON-SPECIFIC HELPER METHODS ==========
+    // Enable gravity for this object
+    enableGravity() {
+        this.gravity.enabled = true;
+        return this;
+    }
     
-    setText(text) {
-        this.formatting.button.text.display = text;
+    // Disable gravity for this object
+    disableGravity() {
+        this.gravity.enabled = false;
+        this.gravity.velocity = 0;
         return this;
     }
     
-    getRGBFromColor(colorInput) {
-        let c = color(colorInput);
-        return [red(c), green(c), blue(c)];
+    // Set gravity parameters
+    setGravity(options = {}) {
+        if (options.enabled !== undefined) this.gravity.enabled = options.enabled;
+        if (options.mass !== undefined) this.gravity.mass = Math.max(0.1, options.mass);
+        if (options.bounce !== undefined) this.gravity.bounce = Math.min(1, Math.max(0, options.bounce));
+        if (options.friction !== undefined) this.gravity.friction = Math.min(1, Math.max(0, options.friction));
+        if (options.groundTolerance !== undefined) this.gravity.groundTolerance = options.groundTolerance;
+        return this;
     }
     
-    getBrightness(colorInput) {
-        let rgb = this.getRGBFromColor(colorInput);
-        return 0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2];
+    // Apply gravity to this object
+    applyGravity() {
+        if (!this.gravity.enabled) return;
+        
+        // Apply gravity acceleration (scaled by mass)
+        this.gravity.velocity += gameObject.gravity * this.gravity.mass;
+        
+        // Limit to terminal velocity
+        this.gravity.velocity = Math.min(this.gravity.velocity, gameObject.terminalVelocity);
+        
+        // Store last position before moving
+        let lastY = this.y;
+        
+        // Apply vertical movement
+        this.y += this.gravity.velocity;
+        
+        // Check for ground collision with other objects
+        this.checkGroundCollision();
+        
+        // If we just landed, stop downward velocity
+        if (this.gravity.grounded) {
+            this.gravity.velocity = 0;
+            
+            // Apply ground friction to horizontal movement
+            if (this.gravity.friction > 0 && this.velocityMode === "polar") {
+                this.velocity[0] *= (1 - this.gravity.friction);
+                if (Math.abs(this.velocity[0]) < 0.01) this.velocity[0] = 0;
+            }
+        }
     }
     
-    scaleColor(baseColor, scaleFactor) {
-        let rgb = this.getRGBFromColor(baseColor);
-        let scaledRGB = rgb.map(val => constrain(val * scaleFactor, 0, 255));
-        return color(scaledRGB);
+    // Check if this object is standing on another object
+    checkGroundCollision() {
+        if (!this.collition || !this.gravity.enabled) return;
+        
+        let wasGrounded = this.gravity.grounded;
+        this.gravity.grounded = false;
+        
+        // Check collision with other objects in the same scene
+        if (this.parentScene && this.parentScene.objects) {
+            this.parentScene.objects.forEach(other => {
+                // Skip self and inactive objects
+                if (other.id === this.id || !other.active) return;
+                
+                // Only check if gravity is enabled on this object and we're moving downward
+                if (this.gravity.velocity <= 0) return;
+                
+                // Check if other object is below this one
+                let verticalDistance = (other.y - other.height/2) - (this.y + this.height/2);
+                
+                // If within ground tolerance and horizontally overlapping
+                if (Math.abs(verticalDistance) <= this.gravity.groundTolerance &&
+                    this.x + this.width/2 > other.x - other.width/2 &&
+                    this.x - this.width/2 < other.x + other.width/2) {
+                    
+                    this.gravity.grounded = true;
+                    this.lastGroundY = other.y - other.height/2 - this.height/2;
+                    
+                    // Apply bounce if enabled
+                    if (this.gravity.bounce > 0 && wasGrounded === false) {
+                        this.gravity.velocity = -this.gravity.velocity * this.gravity.bounce;
+                        
+                        // If bounce velocity is very small, just set to zero
+                        if (Math.abs(this.gravity.velocity) < 0.1) {
+                            this.gravity.velocity = 0;
+                        }
+                    } else {
+                        // Position exactly on ground
+                        this.y = this.lastGroundY;
+                    }
+                }
+            });
+        }
     }
     
-    setColors(normal, hover = null, pressed = null, disabled = null) {
-        if (hover === null && pressed === null) {
-            let originalNormal = this.formatting.button.colors.normal;
-            let originalHover = this.formatting.button.colors.hover;
-            let originalPressed = this.formatting.button.colors.pressed;
+    update() {
+        if (!this.active) return;
+        
+        // Apply gravity if enabled
+        this.applyGravity();
+        
+        let vel = this.velocity[0];
+        let angle = this.velocity[1];
+        
+        if (this.velocityMode == "polar") {
+            let linked = false;
+            if (!/unlinked/i.test(this.rvm) && /linked/i.test(this.rvm)) {
+                this.velocity[1] = this.rotation;
+                linked = true;
+            }
+
+            let rot = linked ? 
+                (this.rotationMode == "degrees" ? (this.rotation) : _p5.prototype.radians(this.rotation)) : 
+                (this.rotationMode == "degrees" ? (this.velocity[1]) : (this.velocity[1]));
             
-            let normalBrightness = this.getBrightness(originalNormal);
-            let hoverBrightness = this.getBrightness(originalHover);
-            let pressedBrightness = this.getBrightness(originalPressed);
+            if(isNaN(rot)){
+                vel = 0;
+                rot = 0;
+            }
             
-            let hoverScale = normalBrightness !== 0 ? hoverBrightness / normalBrightness : 0.86;
-            let pressedScale = normalBrightness !== 0 ? pressedBrightness / normalBrightness : 0.75;
+            let vx = vel * _p5.prototype.cos(rot);
+            let vy = vel * _p5.prototype.sin(rot);
+
+            this.velocityMatrix = [vx, vy];
             
-            hover = this.scaleColor(normal, hoverScale);
-            pressed = this.scaleColor(normal, pressedScale);
+            // Don't apply horizontal movement if gravity is enabled and we're grounded with friction
+            if (!(this.gravity.enabled && this.gravity.grounded && this.gravity.friction > 0)) {
+                this.x += vx;
+            }
+            
+            // Vertical movement is handled by gravity when enabled
+            if (!this.gravity.enabled) {
+                this.y += vy;
+            }
         } else {
-            hover = color(hover);
-            pressed = color(pressed);
+            // Cartesian velocity mode
+            if (!(this.gravity.enabled && this.gravity.grounded && this.gravity.friction > 0)) {
+                this.x += vel;
+            }
+            if (!this.gravity.enabled) {
+                this.y += angle;
+            }
         }
         
-        let normalColor = color(normal);
-        let disabledColor = disabled !== null ? color(disabled) : null;
-        
-        this.formatting.button.colors.normal = normalColor;
-        this.formatting.button.colors.hover = hover;
-        this.formatting.button.colors.pressed = pressed;
-        if (disabledColor !== null) {
-            this.formatting.button.colors.disabled = disabledColor;
-        }
+        // Update parent scene reference
+        this.updateParentScene();
         
-        return this;
-    }
-    
-    textStyle(color, size) {
-        if (color !== undefined) this.formatting.button.text.color = color;
-        if (size !== undefined) this.formatting.button.text.size = size;
-        return this;
-    }
-    
-    Disable(disabled = true) {
-        this.isDisabled = disabled;
-        return this;
+        MALCgameObjects[this.objectInstance] = this;
     }
     
-    click(call) {
-        if(typeof call == "function" && this.events.pressed()){
-            call();
-        }
-        return this.events.clicked();
-    }
-}
-
-// ========== SCENE CLASS ==========
-class Scene {
-    static scenes = [];
-    static activeScene = "blank";
-    static started = false;
-    static sceneHistory = [];
-    static historyLimit = 10;
-
-    static update() {
-        this.started = true;
-        this.scenes = MALCScene;
+    render() {
+        if (!this.active) return;
         
-        let activeSceneFound = false;
+        this.scripts.forEach(s => {
+            if(typeof s == "function")s(this);
+        });
         
-        this.scenes.forEach(S => {
-            if (S.id == this.activeScene) {
-                activeSceneFound = true;
-                
-                this.scenes.forEach(s => {
-                    if (s != S) {
-                        s._active = false;
-                        s.active = false;
-                        
-                        s.objects.forEach(o => {
-                            if (o && typeof o.active !== 'undefined') o.active = false;
-                        });
-                    }
-                });
-                
-                S.active = true;
-                
-                if (!S._active) {
-                    S.activated = MALC.time.getTime();
-                    if (typeof S.onActivate == 'function') S.onActivate();
-                }
-                
-                S._active = true;
-                S.timeActive = MALC.time.getTime() - S.activated;
-                
-                S.objects.forEach(o => {
-                    if (o && typeof o.active !== 'undefined') o.active = true;
-                });
-                
-                push();
-                if (window.camera && typeof camera.render == 'function') {
-                    camera.render();
-                }
-                
-                S.render();
-                
-                pop();
+        let outline = this.formatting.outline;
+        let hb = this.hitbox;
+        
+        // Draw debug hitbox if enabled
+        if (this.debug) {
+            _p5.prototype.push();
+            _p5.prototype.translate(this.x, this.y);
+            _p5.prototype.rectMode(_p5.prototype.CENTER);
+            if (this.rotationMode == "degrees") _p5.prototype.angleMode(_p5.prototype.DEGREES);
+            _p5.prototype.rotate(this.rotation + hb.rotation);
+
+            _p5.prototype.stroke("#00FF27");
+            _p5.prototype.strokeWeight(hb.outline);
+            _p5.prototype.noFill();
+            _p5.prototype.rect(hb.x, hb.y, this.width + hb.width, this.height + hb.height);
+            
+            // Draw gravity indicator if enabled
+            if (this.gravity.enabled) {
+                _p5.prototype.stroke(0, 255, 0, 100);
+                _p5.prototype.line(0, 0, 0, this.gravity.velocity * 5);
             }
-        });
+            
+            _p5.prototype.pop();
+        }
         
-        if (!activeSceneFound && this.activeScene != "blank") {
-            console.warn(`Scene "${this.activeScene}" not found, switching to blank`);
-            this.activeScene = "blank";
+        if (!this.visible) return;
+        
+        _p5.prototype.push();
+        _p5.prototype.translate(this.x, this.y);
+        _p5.prototype.rectMode(_p5.prototype.CENTER);
+        if (this.rotationMode == "degrees") _p5.prototype.angleMode(_p5.prototype.DEGREES);
+        _p5.prototype.rotate(this.rotation);
+        
+        if (outline[0]) {
+            _p5.prototype.strokeWeight(outline[1]);
+            _p5.prototype.stroke(outline[2]);
+        } else {
+            _p5.prototype.noStroke();
         }
+        
+        _p5.prototype.fill(this.formatting.color);
+        _p5.prototype.rect(0, 0, this.width, this.height);
+        _p5.prototype.pop();
     }
+
+    // ========== HELPFUL METHODS ==========
     
-    static getSceneById(id) {
-        return MALCScene.find(scene => scene.id == id) || null;
-    }
-    
-    static getActiveScene() {
-        return this.getSceneById(this.activeScene);
+    belongsToScene(sceneId) {
+        return this.scenes.includes(sceneId);
     }
     
-    static switchToScene(id, addToHistory = true) {
-        let scene = this.getSceneById(id);
-        if (scene) {
-            if (addToHistory && this.activeScene) {
-                this.sceneHistory.push(this.activeScene);
-                if (this.sceneHistory.length > this.historyLimit) {
-                    this.sceneHistory.shift();
-                }
+    addToScene(sceneId) {
+        if (!this.scenes.includes(sceneId)) {
+            this.scenes.push(sceneId);
+            let scene = Scene.getSceneById(sceneId);
+            if (scene && !scene.objects.includes(this)) {
+                scene.objects.push(this);
             }
-            this.activeScene = id;
-        } else {
-            console.error(`Cannot switch to scene "${id}" - not found`);
         }
+        return this;
     }
     
-    static goBack() {
-        if (this.sceneHistory.length > 0) {
-            let previousScene = this.sceneHistory.pop();
-            this.switchToScene(previousScene, false);
-            return true;
+    removeFromScene(sceneId) {
+        this.scenes = this.scenes.filter(id => id != sceneId);
+        let scene = Scene.getSceneById(sceneId);
+        if (scene) {
+            scene.objects = scene.objects.filter(obj => obj != this);
         }
-        return false;
-    }
-    
-    static getAllScenes() {
-        return [...MALCScene];
-    }
-    
-    static getScenesWithObject(object) {
-        return MALCScene.filter(scene => scene.objects.includes(object));
+        return this;
     }
     
-    static getScenesByTag(tag) {
-        return MALCScene.filter(scene => scene.hasTag(tag));
-    }
-
-    constructor(id, backgroundColor, ...scripts) {
-        MALCScene.forEach(s => {
-            if (s.id == id || typeof id != "string") {
-                throw new Error(`Scenes must have unique IDs and be strings. Duplicate/Invalid ID: "${id}"`);
+    removeFromAllScenes() {
+        this.scenes.forEach(sceneId => {
+            let scene = Scene.getSceneById(sceneId);
+            if (scene) {
+                scene.objects = scene.objects.filter(obj => obj != this);
             }
         });
-        
-        this.id = id;
-        this.backColor = backgroundColor;
-        this.scripts = scripts;
-        
-        this.objects = [];
-        this.uiPlanes = [];
-        
-        this.active = false;
-        this._active = false;
-        this.activated = 0;
-        this.timeActive = -1;
-        
-        this.tags = [];
-        this.paused = false;
-        this.transition = null;
-        this.onActivateCallbacks = [];
-        this.onDeactivateCallbacks = [];
-        this.onUpdateCallbacks = [];
-        
-        this.sceneInstance = MALCScene.length;
-        MALCScene.push(this);
+        this.scenes = [];
+        return this;
     }
     
-    render() {
-        if (this.paused) return;
-        
-        if (this.transition) {
-            this.applyTransition();
-        }
-        
-        background(this.backColor);
-        
-        this.scripts.forEach(exe => {
-            if (typeof exe == "function") exe(this);
-        });
-        
-        this.onUpdateCallbacks.forEach(cb => {
-            if (typeof cb == "function") cb(this);
-        });
-        
-        this.objects.forEach(o => {
-            if (o && typeof o.update == "function") {
-                o.update(true);
-            }
-            if (o && typeof o.render == "function") {
-                o.render();
-            }
-        });
-        
-        if (typeof UIPlanes !== 'undefined' && UIPlanes.length > 0) {
-            UIPlanes.forEach(ui => {
-                if (ui && typeof ui.belongsToScene == "function" && ui.belongsToScene(this.id)) {
-                    ui.render();
-                }
-            });
-        }
-        
-        this.uiPlanes.forEach(ui => {
-            if (ui && typeof ui.render == "function") {
-                ui.render();
+    updateParentScene() {
+        if (Scene.activeScene) {
+            let activeScene = Scene.getSceneById(Scene.activeScene);
+            if (activeScene && this.belongsToScene(activeScene.id)) {
+                this.parentScene = activeScene;
             }
-        });
-        
-        MALCScene[this.sceneInstance] = this;
+        }
     }
     
-    applyTransition() {
-        if (!this.transition || !this.transition.active) return;
-        
-        this.transition.progress += 1/60;
+    distanceTo(target) {
+        let dx = target.x !== undefined ? target.x - this.x : target[0] - this.x;
+        let dy = target.y !== undefined ? target.y - this.y : target[1] - this.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    
+    collidesWith(other) {
+        return (this.x < other.x + other.width &&
+                this.x + this.width > other.x &&
+                this.y < other.y + other.height &&
+                this.y + this.height > other.y);
+    }
+    
+    directionTo(x, y, err = 0.5) {
+        let pa = [x - this.x, y - this.y];
         
-        if (this.transition.progress >= this.transition.duration) {
-            this.transition.active = false;
-            this.transition = null;
-            return;
-        }
+        let angle = (x && y) ? _p5.prototype.atan(pa[1]/pa[0]) : this.rotation;
+        var quads = [
+            pa[0] < -err && pa[1] > err,
+            pa[0] < -err && pa[1] < -err,
+            pa[0] > err && pa[1] > err,
+            pa[0] > err && pa[1] < -err,
+            (pa[0] < err && pa[0] > -err),
+            (pa[1] < err && pa[1] > -err),
+        ];
         
-        let t = this.transition.progress / this.transition.duration;
+        let da = (_p5.prototype.atan(pa[1]/pa[0]) * 180)/Math.PI;
         
-        push();
-        switch(this.transition.type) {
-            case "fade":
-                fill(0, 255 * (1 - t));
-                rect(0, 0, width, height);
-                break;
-            case "slide":
-                translate(width * (1 - t), 0);
-                break;
-        }
-        pop();
-    }
-    
-    addObject(object) {
-        if (object && !this.objects.includes(object)) {
-            this.objects.push(object);
-            if (typeof object.addToScene == "function") {
-                object.addToScene(this.id);
+        if((pa[1] > -err && pa[1] < err) && (pa[0] > -err && pa[0] < err)){
+            angle = NaN;
+        } else if(quads[0]){
+            angle = da+180;
+        } else if(quads[1]){
+            angle = da+180;
+        } else if(quads[2]){
+            angle = da;
+        } else if(quads[3]){
+            angle = da;
+        } else if(quads[4]){
+            if(pa[1] < -err) {
+                angle = -90;
+            } else if(pa[1] > err) {
+                angle = 90;
+            }
+        } else if(quads[5]){
+            if(pa[0] < -err) {
+                angle = 180;
+            } else if(pa[0] > err) {
+                angle = 0;
             }
         }
-        return this;
+        
+        return angle;
     }
     
-    addObjects(objects) {
-        objects.forEach(obj => this.addObject(obj));
+    pointTo(target) {
+        this.rotation = this.directionTo(target);
         return this;
     }
     
-    removeObject(object) {
-        this.objects = this.objects.filter(obj => obj != object);
-        if (object && typeof object.removeFromScene == "function") {
-            object.removeFromScene(this.id);
-        }
+    setPosition(x, y) {
+        this.x = x;
+        this.y = y;
         return this;
     }
     
-    clearObjects() {
-        this.objects.forEach(obj => {
-            if (obj && typeof obj.removeFromScene == "function") {
-                obj.removeFromScene(this.id);
-            }
-        });
-        this.objects = [];
+    move(dx, dy) {
+        this.x += dx;
+        this.y += dy;
         return this;
     }
     
-    getObjects(filter) {
-        if (typeof filter == "function") {
-            return this.objects.filter(filter);
-        } else if (filter == "button") {
-            return this.objects.filter(obj => obj instanceof Button);
-        } else if (filter == "gameObject") {
-            return this.objects.filter(obj => obj instanceof gameObject);
+    setVelocity(speed, x, y, err = 0.5){
+        let angle = this.directionTo(x,y,err);
+        
+        if(isNaN(angle)){
+            angle = 0;
+            speed = 0;
         }
-        return this.objects;
+        
+        this.velocity = [speed, angle]; 
+        return this.velocity;
     }
     
-    getObjectById(id) {
-        return this.objects.find(obj => obj && obj.id == id);
+    destroy() {
+        this.removeFromAllScenes();
+        let index = MALCgameObjects.indexOf(this);
+        if (index > -1) {
+            MALCgameObjects.splice(index, 1);
+        }
     }
     
-    addUIPlane(uiPlane) {
-        if (uiPlane && !this.uiPlanes.includes(uiPlane)) {
-            this.uiPlanes.push(uiPlane);
-            if (typeof uiPlane.addToScene == "function") {
-                uiPlane.addToScene(this.id);
-            }
+    clone() {
+        let clone = new gameObject(this.x, this.y, this.width, this.height, ...this.scenes);
+        clone.rotation = this.rotation;
+        clone.rotationMode = this.rotationMode;
+        clone.velocity = [...this.velocity];
+        clone.velocityMode = this.velocityMode;
+        clone.rvm = this.rvm;
+        clone.formatting = JSON.parse(JSON.stringify(this.formatting));
+        clone.gravity = JSON.parse(JSON.stringify(this.gravity));
+        clone.debug = this.debug;
+        clone.hitbox = JSON.parse(JSON.stringify(this.hitbox));
+        return clone;
+    }
+
+    screenToWorld(screenX, screenY) {
+        if (window.camera && typeof window.camera.screenToWorld == "function") {
+            return window.camera.screenToWorld(screenX, screenY);
         }
-        return this;
+        return { x: screenX, y: screenY };
     }
     
-    removeUIPlane(uiPlane) {
-        this.uiPlanes = this.uiPlanes.filter(ui => ui != uiPlane);
-        if (uiPlane && typeof uiPlane.removeFromScene == "function") {
-            uiPlane.removeFromScene(this.id);
-        }
-        return this;
+    isOnScreen() {
+        if (!window.camera) return true;
+        
+        let cameraPos = window.camera.getOrientation();
+        let screenRight = cameraPos[0] + window.camera.width;
+        let screenBottom = cameraPos[1] + window.camera.height;
+        
+        return (this.x + this.width/2 > cameraPos[0] &&
+                this.x - this.width/2 < screenRight &&
+                this.y + this.height/2 > cameraPos[1] &&
+                this.y - this.height/2 < screenBottom);
     }
+}
+
+// ========== BUTTON CLASS ==========
+class Button extends gameObject {
+    static buttons = [];
     
-    clearUIPlanes() {
-        this.uiPlanes.forEach(ui => {
-            if (ui && typeof ui.removeFromScene == "function") {
-                ui.removeFromScene(this.id);
+    static updateButton() {
+        this.startedButtons = true;
+        this.buttons = MALCbuttons;
+        
+        this.buttons.forEach(b => {
+            if (!b.active) return;
+            
+            b.isHovered = b.events.hover();
+            
+            if (MALCbuttons.every(b => !b.events.hover())) {
+                _p5.prototype.cursor();
+            } else if (b.isHovered) {
+                _p5.prototype.cursor(b.cursor);
             }
         });
-        this.uiPlanes = [];
-        return this;
     }
     
-    addScript(script) {
-        if (typeof script == "function" && !this.scripts.includes(script)) {
-            this.scripts.push(script);
-        }
-        return this;
+    static getButtonByIndex(index) {
+        return MALCbuttons[index] || null;
     }
     
-    removeScript(script) {
-        this.scripts = this.scripts.filter(s => s != script);
-        return this;
+    static getHoveredButton() {
+        return MALCbuttons.find(b => b.active && b.events.hover());
     }
     
-    clearScripts() {
-        this.scripts = [];
-        return this;
+    static getPressedButton() {
+        return MALCbuttons.find(b => b.active && b.events.pressed());
     }
     
-    onActivate(callback) {
-        if (typeof callback == "function") {
-            this.onActivateCallbacks.push(callback);
+    constructor(x = 0, y = 0, w = 20, h = 20, displayText = "Button", ...scenes) {
+        super(x, y, w, h, ...scenes);
+        
+        this.formatting.button = {
+            hover: 220,
+            clicked: 190,
+            text: {
+                color: 0,
+                size: 14,
+                style:"normal",
+                display: displayText,
+            },
+            colors: {
+                normal: 255,
+                hover: 220,
+                pressed: 190,
+                disabled: 150
+            }
+        };
+        
+        this.cursor = "pointer";
+        this.isHovered = false;
+        this.isPressed = false;
+        this.isDisabled = false;
+        this.clickCooldown = 100;
+        this.lastClickTime = 0;
+        this.cooldownActive = false;
+        
+        this.events = {
+            hover: (err = 0) => {
+                return !this.isDisabled && (
+                    window.mouse.x < this.x + this.width / 2 + err &&
+                    window.mouse.x > this.x - (this.width / 2 + err) &&
+                    window.mouse.y < this.y + this.height / 2 + err &&
+                    window.mouse.y > this.y - (this.height / 2 + err)
+                );
+            },
+            pressed: () => {
+                return this.events.hover() && window.mouse.down;
+            },
+            clicked: () => {
+                let wasPressed = this.wasPressed;
+                let isHovering = this.events.hover();
+                let mouseReleased = !window.mouse.down && wasPressed;
+
+                this.wasPressed = window.mouse.down && isHovering;
+
+                return mouseReleased && isHovering;
+            }
+        };
+
+        this.wasPressed = false;
+        this.onClick = null;
+        
+        this.buttonIndex = MALCbuttons.length;
+        MALCbuttons.push(this);
+    }
+
+    update(boolean) {
+        super.update(boolean);
+
+        if (this.cooldownActive) {
+            let currentTime = Date.now();
+            if (currentTime - this.lastClickTime >= this.clickCooldown) {
+                this.cooldownActive = false;
+            }
         }
-        return this;
+
+        this.isHovered = this.events.hover();
+        this.isPressed = this.events.pressed();
+
+        if (this.events.clicked() && this.onClick && !this.isDisabled && !this.cooldownActive) {
+            this.onClick(this);
+            this.lastClickTime = Date.now();
+            this.cooldownActive = true;
+        }
+
+        MALCbuttons[this.buttonIndex] = this;
     }
-    
-    onDeactivate(callback) {
-        if (typeof callback == "function") {
-            this.onDeactivateCallbacks.push(callback);
+
+    render() {
+        if (!this.active) return;
+        
+        let btnFormat = this.formatting.button;
+        let buttonColor;
+        
+        if (this.isDisabled) {
+            buttonColor = btnFormat.colors.disabled;
+        } else if (this.isPressed) {
+            buttonColor = btnFormat.colors.pressed;
+        } else if (this.isHovered) {
+            buttonColor = btnFormat.colors.hover;
+        } else {
+            buttonColor = btnFormat.colors.normal;
         }
-        return this;
+        
+        let originalColor = this.formatting.color;
+        this.formatting.color = buttonColor;
+        
+        super.render();
+        
+        if(!this.visible) return;
+        
+        _p5.prototype.push();
+        _p5.prototype.translate(this.x, this.y);
+        if (this.rotationMode == "degrees") _p5.prototype.angleMode(_p5.prototype.DEGREES);
+        _p5.prototype.rotate(this.rotation);
+        
+        _p5.prototype.textStyle(btnFormat.text.style);
+        _p5.prototype.textSize(btnFormat.text.size);
+        _p5.prototype.fill(btnFormat.text.color);
+        
+        // Use colored text if available, otherwise use normal text
+        if (_p5.prototype.coloredText) {
+            _p5.prototype.coloredText(btnFormat.text.display, 0, 0, _p5.prototype.CENTER, _p5.prototype.CENTER);
+        } else {
+            _p5.prototype.text(btnFormat.text.display, 0, 0);
+        }
+        
+        _p5.prototype.pop();
+        
+        this.formatting.color = originalColor;
     }
     
-    onUpdate(callback) {
-        if (typeof callback == "function") {
-            this.onUpdateCallbacks.push(callback);
-        }
+    // ========== BUTTON-SPECIFIC HELPER METHODS ==========
+    
+    setText(text) {
+        this.formatting.button.text.display = text;
         return this;
     }
     
-    pause() {
-        this.paused = true;
-        return this;
+    getRGBFromColor(colorInput) {
+        let c = _p5.prototype.color(colorInput);
+        return [_p5.prototype.red(c), _p5.prototype.green(c), _p5.prototype.blue(c)];
     }
     
-    resume() {
-        this.paused = false;
-        return this;
+    getBrightness(colorInput) {
+        let rgb = this.getRGBFromColor(colorInput);
+        return 0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2];
     }
     
-    setTransition(type, duration = 1.0) {
-        this.transition = {
-            type: type,
-            duration: duration,
-            progress: 0,
-            active: true
-        };
-        return this;
+    scaleColor(baseColor, scaleFactor) {
+        let rgb = this.getRGBFromColor(baseColor);
+        let scaledRGB = rgb.map(val => _p5.prototype.constrain(val * scaleFactor, 0, 255));
+        return _p5.prototype.color(scaledRGB);
     }
     
-    addTag(tag) {
-        if (!this.tags.includes(tag)) {
-            this.tags.push(tag);
+    setColors(normal, hover = null, pressed = null, disabled = null) {
+        if (hover === null && pressed === null) {
+            let originalNormal = this.formatting.button.colors.normal;
+            let originalHover = this.formatting.button.colors.hover;
+            let originalPressed = this.formatting.button.colors.pressed;
+            
+            let normalBrightness = this.getBrightness(originalNormal);
+            let hoverBrightness = this.getBrightness(originalHover);
+            let pressedBrightness = this.getBrightness(originalPressed);
+            
+            let hoverScale = normalBrightness !== 0 ? hoverBrightness / normalBrightness : 0.86;
+            let pressedScale = normalBrightness !== 0 ? pressedBrightness / normalBrightness : 0.75;
+            
+            hover = this.scaleColor(normal, hoverScale);
+            pressed = this.scaleColor(normal, pressedScale);
+        } else {
+            hover = _p5.prototype.color(hover);
+            pressed = _p5.prototype.color(pressed);
+        }
+        
+        let normalColor = _p5.prototype.color(normal);
+        let disabledColor = disabled !== null ? _p5.prototype.color(disabled) : null;
+        
+        this.formatting.button.colors.normal = normalColor;
+        this.formatting.button.colors.hover = hover;
+        this.formatting.button.colors.pressed = pressed;
+        if (disabledColor !== null) {
+            this.formatting.button.colors.disabled = disabledColor;
         }
+        
         return this;
     }
     
-    removeTag(tag) {
-        this.tags = this.tags.filter(t => t != tag);
+    textStyle(color, size) {
+        if (color !== undefined) this.formatting.button.text.color = color;
+        if (size !== undefined) this.formatting.button.text.size = size;
         return this;
     }
     
-    hasTag(tag) {
-        return this.tags.includes(tag);
-    }
-    
-    reset() {
-        this.clearObjects();
-        this.clearUIPlanes();
-        this.clearScripts();
-        this.onActivateCallbacks = [];
-        this.onDeactivateCallbacks = [];
-        this.onUpdateCallbacks = [];
-        this.tags = [];
-        this.paused = false;
-        this.transition = null;
-        this.timeActive = 0;
+    Disable(disabled = true) {
+        this.isDisabled = disabled;
         return this;
     }
     
-    destroy() {
-        let index = MALCScene.indexOf(this);
-        if (index > -1) {
-            MALCScene.splice(index, 1);
-        }
-        
-        this.clearObjects();
-        this.clearUIPlanes();
-        
-        if (Scene.activeScene == this.id) {
-            Scene.activeScene = "blank";
+    click(call) {
+        if(typeof call == "function" && this.events.pressed()){
+            call();
         }
-    }
-    
-    clone(newId) {
-        let clone = new Scene(newId || this.id + "_copy", this.backColor, ...this.scripts);
-        clone.objects = [...this.objects];
-        clone.uiPlanes = [...this.uiPlanes];
-        clone.tags = [...this.tags];
-        return clone;
-    }
-    
-    getInfo() {
-        return {
-            id: this.id,
-            active: this.active,
-            timeActive: this.timeActive,
-            objectCount: this.objects.length,
-            uiPlaneCount: this.uiPlanes.length,
-            scriptCount: this.scripts.length,
-            tags: this.tags,
-            paused: this.paused
-        };
+        return this.events.clicked();
     }
 }
 
@@ -1351,20 +1446,20 @@ class UIPlane {
     }
     
     render() {
-        push();
+        _p5.prototype.push();
         
         this.applyOrientation();
         this.applyTextFormatting();
         
         if (this.formatting.objectScale !== 1) {
-            scale(this.formatting.objectScale);
+            _p5.prototype.scale(this.formatting.objectScale);
         }
         
         if (typeof this.executable == "function") {
             this.executable(this);
         }
         
-        pop();
+        _p5.prototype.pop();
     }
     
     applyOrientation() {
@@ -1378,21 +1473,21 @@ class UIPlane {
                 } else {
                     cameraPos = [window.camera.x || 0, window.camera.y || 0];
                 }
-                translate(cameraPos[0] + offsetX, cameraPos[1] + offsetY);
+                _p5.prototype.translate(cameraPos[0] + offsetX, cameraPos[1] + offsetY);
             } else {
-                translate(offsetX, offsetY);
+                _p5.prototype.translate(offsetX, offsetY);
             }
         } else if (mode.toLowerCase() == "screen") {
-            translate(offsetX, offsetY);
+            _p5.prototype.translate(offsetX, offsetY);
         } else if (mode.includes(",")) {
             try {
                 let coords = mode.split(",").map(Number);
                 if (coords.length >= 2) {
                     if (window.camera && typeof window.camera.worldToScreen == "function") {
                         let screenPos = window.camera.worldToScreen(coords[0], coords[1]);
-                        translate(screenPos.x + offsetX, screenPos.y + offsetY);
+                        _p5.prototype.translate(screenPos.x + offsetX, screenPos.y + offsetY);
                     } else {
-                        translate(coords[0] + offsetX, coords[1] + offsetY);
+                        _p5.prototype.translate(coords[0] + offsetX, coords[1] + offsetY);
                     }
                 }
             } catch (e) {
@@ -1402,46 +1497,46 @@ class UIPlane {
     }
     
     applyTextFormatting() {
-        textSize(this.formatting.txt.base);
-        fill(this.formatting.txt.color);
-        textAlign(LEFT, TOP);
+        _p5.prototype.textSize(this.formatting.txt.base);
+        _p5.prototype.fill(this.formatting.txt.color);
+        _p5.prototype.textAlign(_p5.prototype.LEFT, _p5.prototype.TOP);
     }
     
     drawText(str, x, y, hAlign = LEFT, vAlign = TOP) {
-        push();
+        _p5.prototype.push();
         
         if (str.startsWith("[title]")) {
-            textSize(this.formatting.txt.title);
+            _p5.prototype.textSize(this.formatting.txt.title);
             str = str.replace("[title]", "");
         } else if (str.startsWith("[heading]")) {
-            textSize(this.formatting.txt.heading);
+            _p5.prototype.textSize(this.formatting.txt.heading);
             str = str.replace("[heading]", "");
         } else if (str.startsWith("[subtitle]")) {
-            textSize(this.formatting.txt.subtitle);
+            _p5.prototype.textSize(this.formatting.txt.subtitle);
             str = str.replace("[subtitle]", "");
         } else {
-            textSize(this.formatting.txt.base);
+            _p5.prototype.textSize(this.formatting.txt.base);
         }
         
-        fill(this.formatting.txt.color);
-        textAlign(hAlign, vAlign);
-        text(str, x, y);
+        _p5.prototype.fill(this.formatting.txt.color);
+        _p5.prototype.textAlign(hAlign, vAlign);
+        _p5.prototype.text(str, x, y);
         
-        pop();
+        _p5.prototype.pop();
     }
     
     drawButton(button, x, y) {
-        push();
+        _p5.prototype.push();
         
         if (this.formatting.objectScale !== 1) {
-            scale(this.formatting.objectScale);
+            _p5.prototype.scale(this.formatting.objectScale);
         }
         
         if (button && typeof button.render == "function") {
             button.render();
         }
         
-        pop();
+        _p5.prototype.pop();
     }
     
     belongsToScene(sceneId) {
@@ -1591,7 +1686,7 @@ class Camera {
         }
         
         let [translateX, translateY] = this.getOrientation();
-        translate(-translateX, -translateY);
+        _p5.prototype.translate(-translateX, -translateY);
     }
     
     unlink() {
@@ -2130,14 +2225,14 @@ class GameController {
           back: null,
           primary: null,
           secondary: null,
-          leftbumber: null,      // Fixed: changed from leftBumber
-          rightbumber: null,      // Fixed: changed from rightBumber
-          lefttrigger: null,      // Fixed: changed from leftTrigger
-          righttrigger: null,     // Fixed: changed from rightTrigger
+          leftbumber: null,
+          rightbumber: null,
+          lefttrigger: null,
+          righttrigger: null,
           view: null,
           menu: null,
-          leftstick: null,        // Fixed: changed from leftStick
-          rightstick: null,       // Fixed: changed from rightStick
+          leftstick: null,
+          rightstick: null,
           up: null,
           down: null,
           left: null,
@@ -2262,100 +2357,6 @@ function refreshLoop() {
     });
 }
 
-// ========== COLORED TEXT FUNCTION ==========
-p5.prototype._parseColoredText = function(str) {
-    const lines = str.split('\n');
-    const result = [];
-    
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const parts = this._parseColoredLine(line);
-        
-        result.push(...parts);
-        
-        if (i < lines.length - 1) {
-            result.push({
-                text: '\n',
-                color: null,
-                isNewline: true
-            });
-        }
-    }
-    
-    return result;
-};
-
-p5.prototype._parseColoredLine = function(str) {
-    const regex = /\\([^|\\\n]+)\|([^|]+)\|/g;
-    const parts = [];
-    let lastIndex = 0;
-    let match;
-    
-    while ((match = regex.exec(str)) !== null) {
-        if (match.index > lastIndex) {
-            parts.push({
-                text: str.substring(lastIndex, match.index),
-                color: null
-            });
-        }
-        
-        parts.push({
-            text: match[2],
-            color: match[1]
-        });
-        
-        lastIndex = match.index + match[0].length;
-    }
-    
-    if (lastIndex < str.length) {
-        parts.push({
-            text: str.substring(lastIndex),
-            color: null
-        });
-    }
-    
-    return parts.length ? parts : [{ text: str, color: null }];
-};
-
-p5.prototype.coloredText = function(str, x, y, horizontal = LEFT, vertical = BASELINE, maxWidth) {
-    const parts = this._parseColoredText(str);
-    let currentX = x;
-    let currentY = y;
-    
-    const originalFill = this.drawingContext.fillStyle;
-    const originalAlign = this.drawingContext.textAlign;
-    const originalBaseline = this.drawingContext.textBaseline;
-    
-    this.textAlign(horizontal, vertical);
-    
-    for (const part of parts) {
-        if (part.isNewline) {
-            currentX = x;
-            currentY += this.textLeading() || this.textSize() * 1.2;
-            continue;
-        }
-        
-        if (part.color) {
-            try {
-                this.fill(part.color);
-            } catch (e) {
-                this.fill(originalFill);
-            }
-        }
-        
-        this.text(part.text, currentX, currentY, maxWidth);
-        currentX += this.textWidth(part.text);
-    }
-    
-    this.fill(originalFill);
-    if (originalAlign && originalBaseline) {
-        this.drawingContext.textAlign = originalAlign;
-        this.drawingContext.textBaseline = originalBaseline;
-    }
-    
-    return this;
-};
-
 // ========== FPS ACCESSOR ==========
 function getFPS() {
     return fps;
@@ -2366,7 +2367,7 @@ const helpDocs = {
     // Game Engine Overview
     overview: `
         MALC Game Engine - A comprehensive 2D game engine for p5.js
-        Version: 1.0.0
+        Version: 1.0.3
         
         Core Features:
         - Scene management system
@@ -2520,8 +2521,8 @@ const helpDocs = {
                 isButtonPressed: "Check button by index",
                 getButtonValue: "Get analog button value"
             },
-            buttonNames: ["select", "back", "primary", "secondary", "leftBumber", "rightBumber", 
-                         "leftTrigger", "rightTrigger", "view", "menu", "leftStick", "rightStick",
+            buttonNames: ["select", "back", "primary", "secondary", "leftbumber", "rightbumber", 
+                         "lefttrigger", "righttrigger", "view", "menu", "leftstick", "rightstick",
                          "up", "down", "left", "right", "home"]
         }
     },
@@ -2542,10 +2543,10 @@ const helpDocs = {
         }
         
         // 2. Create a scene
-        let gameScene = new Scene("game", 220);
+        let gameScene = new MALC.Scene("game", 220);
         
         // 3. Create a game object with gravity
-        let player = new gameObject(100, 100, 50, 50, "game")
+        let player = new MALC.gameObject(100, 100, 50, 50, "game")
             .enableGravity()
             .setGravity({ mass: 1, bounce: 0.3 });
         
@@ -2558,7 +2559,7 @@ const helpDocs = {
 
 // ========== MALC MAIN OBJECT ==========
 const MALC = {
-    version: "1.0.0",
+    version: "1.0.3",
     
     // Core classes
     gameObject: gameObject,
@@ -2675,7 +2676,7 @@ const MALC = {
     
     // Initialize the engine
     init: function(canvasX, canvasY) {
-        createCanvas(canvasX, canvasY);
+        _p5.prototype.createCanvas(canvasX, canvasY);
         
         this.time = new Date();
         this.startTime = this.time.getTime();
@@ -2687,25 +2688,49 @@ const MALC = {
         this.mouse = new MouseHandler();
         window.mouse = this.mouse;
         
+        // Add coloredText method to p5 instance safely
+        if (!_p5.prototype.coloredText) {
+            _p5.prototype.coloredText = function(str, x, y, horizontal, vertical, maxWidth) {
+                renderColoredText(this, str, x, y, horizontal || LEFT, vertical || BASELINE, maxWidth);
+                return this;
+            };
+        }
+        
         // Start FPS tracking
         refreshLoop();
         
         // Create default scenes
         new Scene("blank", 70);
         new Scene("loading", 50, function(self) {
-            textSize(24);
-            let timed = (self.timeActive / 250 % 4);
-            let dots = "";
-            
-            if (timed < 1) dots = ".";
-            else if (timed < 2) dots = "..";
-            else if (timed < 3) dots = "...";
-            
-            coloredText(`\\lime|Loading Game${dots}| `, 120, 200, LEFT, CENTER);
-            textSize(16);
-            
-            let num = (Math.floor(self.timeActive / 100) / 10);
-            coloredText(`\\red|${ Math.round((10 - num) * 10) / 10 + ((num + "").length < 2 ? ".0" : "")}|`, 200, 225, CENTER, CENTER);
+            try {
+                _p5.prototype.textSize(24);
+                let timed = (self.timeActive / 250 % 4);
+                let dots = "";
+                
+                if (timed < 1) dots = ".";
+                else if (timed < 2) dots = "..";
+                else if (timed < 3) dots = "...";
+                
+                if (_p5.prototype.coloredText) {
+                    _p5.prototype.coloredText(`\\lime|Loading Game${dots}| `, 120, 200, _p5.prototype.LEFT, _p5.prototype.CENTER);
+                } else {
+                    _p5.prototype.text(`Loading Game${dots}`, 120, 200);
+                }
+                
+                _p5.prototype.textSize(16);
+                
+                let num = (Math.floor(self.timeActive / 100) / 10);
+                let percentText = `${ Math.round((10 - num) * 10) / 10 + ((num + "").length < 2 ? ".0" : "")}`;
+                
+                if (_p5.prototype.coloredText) {
+                    _p5.prototype.coloredText(`\\red|${percentText}|`, 200, 225, _p5.prototype.CENTER, _p5.prototype.CENTER);
+                } else {
+                    _p5.prototype.text(percentText, 200, 225);
+                }
+            } catch (e) {
+                // Fallback if coloredText fails
+                _p5.prototype.text(`Loading Game...`, 120, 200);
+            }
         });
         
         Scene.activeScene = "loading";
@@ -2720,11 +2745,11 @@ const MALC = {
         this.timer = this.time - this.startTime;
         
         if (this.mouse) {
-            this.mouse.rawX = mouseX;
-            this.mouse.rawY = mouseY;
-            this.mouse.x = this.mouse.rawX + camera.getOrientation()[0];
-            this.mouse.y = this.mouse.rawY + camera.getOrientation()[1];
-            this.mouse.down = mouseIsPressed;
+            this.mouse.rawX = _p5.prototype.mouseX;
+            this.mouse.rawY = _p5.prototype.mouseY;
+            this.mouse.x = this.mouse.rawX + window.camera.getOrientation()[0];
+            this.mouse.y = this.mouse.rawY + window.camera.getOrientation()[1];
+            this.mouse.down = _p5.prototype.mouseIsPressed;
         }
         
         controller.update();
@@ -2734,8 +2759,8 @@ const MALC = {
         
         this.fps = fps;
         
-        if (typeof camera.render == "function") {
-            camera.render();
+        if (typeof window.camera.render == "function") {
+            window.camera.render();
         }
         Scene.update();
     }