diff --git a/gameworld.js b/gameworld.js
index b80f079..db2e776 100644
--- a/gameworld.js
+++ b/gameworld.js
@@ -183,151 +183,6 @@ export class GameWorld {
     }
     
 
-    lineIntersection(line1Start, line1End, line2Start, line2End) {
-        let denom = (line1Start.x - line1End.x) * (line2Start.y - line2End.y) -
-            (line1Start.y - line1End.y) * (line2Start.x - line2End.x);
-
-        if (denom === 0) return null; // Lines are parallel
-
-        let t = ((line1Start.x - line2Start.x) * (line2Start.y - line2End.y) -
-            (line1Start.y - line2Start.y) * (line2Start.x - line2End.x)) / denom;
-        let u = ((line1Start.x - line2Start.x) * (line1Start.y - line1End.y) -
-            (line1Start.y - line2Start.y) * (line1Start.x - line1End.x)) / denom;
-
-        if (t >= 0 && t <= 1 && u >= 0 && u <= 1) {
-            let ix = line1Start.x + t * (line1End.x - line1Start.x);
-            let iy = line1Start.y + t * (line1End.y - line1Start.y);
-            return { x: ix, y: iy };
-        }
-
-        return null; // No intersection
-    }
-
-    lineIntersectsPolygon(startX, startY, endX, endY, polygon) {
-
-
-        let lineStart = { x: startX, y: startY };
-        let lineEnd = { x: endX, y: endY };
-
-        // Loop through all edges of the polygon
-        for (let i = 0; i < polygon.length; i++) {
-            let currentVertex = polygon[i];
-            let nextVertex = polygon[(i + 1) % polygon.length]; // Loop back to the first vertex
-
-            let intersection = this.lineIntersection(lineStart, lineEnd, currentVertex, nextVertex);
-            if (intersection) {
-                return intersection; // Return the first intersection found
-            }
-        }
-
-        return null; // No intersection with any edge of the polygon
-    }
-
-    lineSegmentIntersection(x1, y1, x2, y2, x3, y3, x4, y4) {
-        let den = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
-        if (den === 0) return null; // Parallel lines
-
-        let t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / den;
-        let u = -((x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3)) / den;
-
-        if (t >= 0 && t <= 1 && u >= 0 && u <= 1) {
-            return { x: x1 + t * (x2 - x1), y: y1 + t * (y2 - y1) };
-        }
-        return null;
-    }
-
-
-    polygonsIntersect(poly1, poly2) {
-        for (let i = 0; i < poly1.length; i++) {
-            let p1 = poly1[i];
-            let p2 = poly1[(i + 1) % poly1.length]; // Next point, wrap around
-
-            // Loop through each edge of the second polygon
-            for (let j = 0; j < poly2.length; j++) {
-                let p3 = poly2[j];
-                let p4 = poly2[(j + 1) % poly2.length]; // Next point, wrap around
-
-                let intersection = this.lineIntersection(p1, p2, p3, p4);
-                if (intersection) {
-                    // Calculate the normal of the intersecting edge
-                    let normal = this.calculateNormal(p1, p2);
-                    return { intersection, normal };
-                }
-            }
-        }
-        return null; // No intersection
-    }
-
-
-    calculateNormal(p1, p2) {
-        // Vector of the edge (from p1 to p2)
-        let dx = p2.x - p1.x;
-        let dy = p2.y - p1.y;
-
-        // The normal is the perpendicular vector to the edge
-        // We can rotate the vector 90 degrees counterclockwise (for a counterclockwise normal)
-        let normal = { x: -dy, y: dx };
-
-        // Normalize the normal vector
-        let length = Math.sqrt(normal.x * normal.x + normal.y * normal.y);
-        normal.x /= length;
-        normal.y /= length;
-
-        return normal;
-    }
-
-
-    polygonLineIntersection(polygon, p1, p2) {
-        for (let i = 0; i < polygon.length; i++) {
-            let p3 = polygon[i];
-            let p4 = polygon[(i + 1) % polygon.length]; // Next point, wrap around
-
-            let intersection = this.lineIntersection(p1, p2, p3, p4);
-            if (intersection) {
-                return intersection;
-            }
-        }
-        return null;
-    }
-
-
-
-    checkAndResolveCollision(robot) {
-        for (let obstacle of this.obstacles) {
-            let result = this.polygonsIntersect(robot.get_hull(), obstacle);
-            if (result) {
-                let { intersection, normal } = result;
-                //console.log("Intersection point:", intersection);
-                //console.log("Normal vector:", normal);
-
-                // Resolve the collision by sliding the robot along the normal
-                this.resolveSlide(robot, normal);
-                return true;
-            }
-        }
-        return false;
-    }
-
-
-    resolveSlide(robot, normal) {
-        const radians = (robot.angle * Math.PI) / 180;
-        let vx = Math.cos(radians) * robot.velocity;
-        let vy = Math.sin(radians) * robot.velocity;
-
-
-        let dot = vx * normal.x + vy * normal.y;
-
-        // Subtract the normal component from velocity to make it slide
-        vx -= 2 * dot * normal.x;  // Reflect velocity along the normal (away from the surface)
-        vy -= 2 * dot * normal.y;  // Reflect velocity along the normal (away from the surface)
-
-        // Apply the adjusted movement
-        robot.x = robot.prevX;
-        robot.y = robot.prevY;
-        robot.x += vx;
-        robot.y += vy;
-        //robot.updateHull();
-    }