realrobotshk
/
onlinecodesimulator
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

removed a bunch of functions that served the old, DIY physics system

master
Jake 2025-03-29 23:11:27 +08:00
parent 938d5790ae
commit f59c20686b
1 changed files with 0 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

145
gameworld.js
View File

@ -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();
}