JSFiddle - React, Tailwind, and code Playground

by tmuecksch

JavaScript

Math.toRadians = function(degrees) {
  return degrees * Math.PI / 180;
};
 
Math.toDegrees = function(radians) {
  return radians * 180 / Math.PI;
};


var A = {
    winkel: 0,             // in GRAD!
    mittelpunkt: [30,3],    // x, y
    vector: [1,2]          // x, y
};

var B = {
    winkel: 90,             // in GRAD!
    mittelpunkt: [3,3],    // x, y
    vector: [1,2]          // x, y
};

function checkIntersection (A, B) {
    var ARect = createRectangle(A.mittelpunkt, rotateVector(A.vector, Math.toRadians(A.winkel)));
    var BRect = createRectangle(B.mittelpunkt, rotateVector(B.vector, Math.toRadians(B.winkel)));
    
    return isecRects(ARect, BRect);
};

function rotateVector (vector, radians) {
    var x = vector[0] * Math.cos(radians) - vector[1] * Math.sin(radians);
    var y = vector[0] * Math.sin(radians) + vector[1] * Math.cos(radians);

    return [x, y];
};

function createRectangle (mittelpunkt, vector) {
    var x = vector[0],
    y = vector[1],
    
    x1 = mittelpunkt[0] + x,
    y1 = mittelpunkt[1] + y,
    
    x2 = mittelpunkt[0] + x,
    y2 = mittelpunkt[1] - y,
    
    x3 = mittelpunkt[0] - x,
    y3 = mittelpunkt[1] - y,
    
    x4 = mittelpunkt[0] - x,
    y4 = mittelpunkt[1] + y;
    
    return [x1, y1, x2, y2, x3, y3, x4, y4];
};

function edgeTest(p1, p2, p3, r2) {
    var rot = [ -(p2[1] - p1[1]),
                  p2[0] - p1[0] ];

    var ref = (rot[0] * (p3[0] - p1[0]) +
               rot[1] * (p3[1] - p1[1])) >= 0;

    for (var i = 0, il = r2.length; i < il; i+=2) {
        if (((rot[0] * (r2[i]   - p1[0]) +
              rot[1] * (r2[i+1] - p1[1])) >= 0) === ref) return false;
    }

    return true;
};

function isecRects (r1, r2) {
    if (!r1 || !r2) throw new Error('Rects are not accessible');

    var pn, px;
    for (var pi = 0, pl = r1.length; pi < pl; pi += 2) {
        pn = (pi === (pl - 2)) ? 0 : pi + 2; // next point
        px = (pn === (pl - 2)) ? 0 : pn + 2;
        if (edgeTest([r1[pi], r1[pi+1]],
   ...