onlinecodesimulator/gameworld.js

import Matter from "https://cdn.jsdelivr.net/npm/matter-js@0.19.0/+esm";

export class GameWorld {
    constructor() {

        this.engine = Matter.Engine.create();
        this.world = this.engine.world;
        this.engine.world.gravity.y = 0;//0.01;
        Matter.Runner.run(this.engine);

        let ground = Matter.Bodies.rectangle(400, 600, 800, 50, { isStatic: true });
        Matter.World.add(this.world, ground);


        this.obstacles = [];
        this.robots = [];


        this.addObstacle([
            { x: -100, y: -100 },   // Vertex 1
            { x: 100, y: -100 },   // Vertex 2
            { x: 100, y: 100 },   // Vertex 3
            { x: -100, y: 100 }    // Vertex 4
        ], { x: 400, y: 300 });


        this.addObstacle([
            { x: 300, y: 380 },   // Vertex 1
            { x: 420, y: 380 },   // Vertex 2
            { x: 350, y: 550 },   // Vertex 3
            { x: 280, y: 420 }    // Vertex 4
        ], { x: 400, y: 0 });



    }

    update() {
        // Update the physics simulation

        for (let id in this.robots) {
            this.robots[id].update(this);
        }

        Matter.Engine.update(this.engine);


    }

    addObstacle(vertices, position = { x: 0, y: 0 }) {
        // Convert the polygon points into a Matter.js body
        let body = Matter.Bodies.fromVertices(position.x, position.y, [vertices], {
            isStatic: true, // Obstacles shouldn't move
        });

        // Add body to world and store it
        Matter.World.add(this.world, body);
        this.obstacles.push(body);
    }

    addRobot(robot) {
        console.log("added robot");
        // Create the robot's Matter.js body
        let robotBody = Matter.Bodies.fromVertices(robot.x, robot.y, [robot.hull], {
            friction: 0.05,
            frictionAir: 0.02,   // Air resistance slows it down naturally
            restitution: 0.2, // Slight bounce
        });

        // Add to the world
        Matter.World.add(this.world, robotBody);
        robot.body = robotBody;
        this.robots.push(robot);
    }

    // Return the floor color based on (x, y) coordinates
    getFloorColor(x, y) {
        return (x + y) % 50 < 25 ? "black" : "white"; // Example pattern
    }

    // Draw the game world (e.g., obstacles, background)
    draw(ctx) {
        // Draw obstacles
        ctx.strokeStyle = "gray"; // Obstacle outline color
        ctx.lineWidth = 2; // Optional: to make the outline thicker

        // Draw obstacles
        this.obstacles.forEach(body => {
            ctx.beginPath();
            let vertices = body.vertices;
            ctx.moveTo(vertices[0].x, vertices[0].y);
            for (let i = 1; i < vertices.length; i++) {
                ctx.lineTo(vertices[i].x, vertices[i].y);
            }
            ctx.closePath();
            ctx.stroke();
        });

        this.robots.forEach(robot => {
            let body = robot.body; // Get the Matter.js body from the robot object
            ctx.strokeStyle = "blue";

            let vertices = body.vertices;
            ctx.beginPath();
            ctx.moveTo(vertices[0].x, vertices[0].y);
            for (let i = 1; i < vertices.length; i++) {
                ctx.lineTo(vertices[i].x, vertices[i].y);
            }
            ctx.closePath();
            ctx.stroke();

            robot.draw(ctx); // Draw the robot's hull and sensors
        });

    }

    rayCast(startX, startY, endX, endY) {
        let closestIntersection = null;
        let startPoint = { x: startX, y: startY };
        let endPoint = { x: endX, y: endY };
        // // Loop through all obstacles
        // for (let i = 0; i < this.obstacles.length; i++) {
        //     let obstacle = this.obstacles[i];

        //     return this.lineIntersectsPolygon(startX, startY, endX, endY, obstacle);
        // }

        // Get all bodies in the world
        let allBodies = Matter.Composite.allBodies(this.engine.world);

        let hit = this.getRayHitPoint(startPoint, endPoint, allBodies);
        if (hit) {
            closestIntersection = hit.point;
        }
        return closestIntersection;
    }

    getRayHitPoint(start, end, bodies) {
        let closestHit = null;
        let minDistance = Infinity;
    
        bodies.forEach(body => {
            let vertices = body.vertices;
            
            // Loop through each edge of the polygon body
            for (let i = 0; i < vertices.length; i++) {
                let v1 = vertices[i];
                let v2 = vertices[(i + 1) % vertices.length]; // Wrap around to close the shape
    
                let intersection = this.getLineIntersection(start, end, v1, v2);
                if (intersection) {
                    let distance = Matter.Vector.magnitude(Matter.Vector.sub(intersection, start));
    
                    // Keep track of the closest intersection
                    if (distance < minDistance) {
                        minDistance = distance;
                        closestHit = { point: intersection, body };
                    }
                }
            }
        });
    
        return closestHit;
    }
    
    // Line intersection helper function
    getLineIntersection(p1, p2, p3, p4) {
        let denom = (p4.y - p3.y) * (p2.x - p1.x) - (p4.x - p3.x) * (p2.y - p1.y);
        
        if (denom === 0) return null; // Parallel lines, no intersection
    
        let ua = ((p4.x - p3.x) * (p1.y - p3.y) - (p4.y - p3.y) * (p1.x - p3.x)) / denom;
        let ub = ((p2.x - p1.x) * (p1.y - p3.y) - (p2.y - p1.y) * (p1.x - p3.x)) / denom;
    
        if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {
            return {
                x: p1.x + ua * (p2.x - p1.x),
                y: p1.y + ua * (p2.y - p1.y)
            };
        }
    
        return null; // No valid intersection
    }
    




}