Kreis innerhalb Kreis Kollision

In einem meiner Projekte habe ich einen Spielbereich in Form eines Kreises. Innerhalb dieses Kreises bewegt sich ein weiterer kleiner Kreis. Ich möchte verhindern, dass sich der kleine Kreis außerhalb des größeren Kreises bewegt. Unten sehen Sie, dass sich in Bild 2 der kleine Kreis teilweise außerhalb befindet. Ich brauche eine Möglichkeit, ihn zurück zu verschieben, kurz bevor er sich nach außen bewegt. Wie kann das gemacht werden?

Außerdem benötige ich den Kollisionspunkt entlang des Bogens des großen Kreises, damit ich die Geschwindigkeit des kleinen Kreises aktualisieren kann. Wie würde man diesen Punkt berechnen?

Bevor ich den kleinen Kreis bewege, sage ich seine nächste Position voraus und wenn er außerhalb liegt, finde ich die Kollisionszeit zwischen t = 0 und t = 1 (t = 1 Vollzeitschritt). Wenn ich die Kollisionszeit t habe, bewege ich einfach den kleinen Kreis während t anstelle eines Vollzeitschritts. Aber auch hier ist das Problem, dass ich nicht weiß, wie ich zu diesem Zeitpunkt die Kollision erkennen kann, wenn es um zwei Kreise geht und einer im anderen liegt.

BEARBEITEN:

Beispiel für einen Kollisionspunkt (grün), den ich finden möchte. Vielleicht ist das Bild ein bisschen anders, aber Sie haben die Idee.

Nehmen wir an, der große Kreis hat Mittelpunkt Aund Radius Rund der kleine Kreis hat Mittelpunkt Bund Radius, die rsich in Richtung Position bewegen C.

Es gibt eine elegante Möglichkeit, dieses Problem mithilfe von Minkovski-Summen (eigentlich Subtraktionen) zu lösen : Ersetzen Sie die Scheibe mit dem Radius Rdurch eine Scheibe mit dem Radius R-rund die Scheibe mit dem Radius rdurch eine Scheibe mit dem Radius 0, d. H. ein einfacher Punkt bei B. Das Problem wird zu einem Linien-Kreis-Schnittpunktproblem.

Sie müssen dann nur noch prüfen, ob der Abstand ACkleiner als ist R-r. Wenn dies der Fall ist, kollidieren die Kreise nicht. Wenn es größer ist , finden Sie den Punkt Dauf , BCim Abstand R-rvon Aund das ist die neue Position der Mitte des kleinen Kreises. Dies ist gleichbedeutend mit der Feststellung k, dass:

  vec(BD) = k*vec(BC)
and
  norm(vec(AD)) = R-r

Ersetzen vec(AD)durch vec(AB) + vec(BD)ergibt:

AB² + k² BC² + 2k vec(AB).vec(BC) = (R-r)²

Vorausgesetzt, die Anfangsposition lag innerhalb des großen Kreises, hat diese quadratische Gleichung in keine positive Wurzel. So lösen Sie die Gleichung im Pseudocode:

b = - vec(AB).vec(BC) / BC²    // dot product
c = (AB² - (R-r)²) / BC²
d = b*b - c
k = b - sqrt(d)
if (k < 0)
    k = b + sqrt(d)
if (k < 0)
    // no solution! we must be slightly out of the large circle

Mit diesem Wert von kliegt der neue Mittelpunkt des kleinen Kreises Dso, dass BD = kBC.

Bearbeiten : quadratische Gleichungslösung hinzufügen

Angenommen, der große Kreis ist Kreis A und der kleine Kreis ist Kreis B.

Überprüfen Sie, ob sich B in A befindet:

distance = sqrt((B.x - A.x)^2 + (B.y - A.y)^2))
if(distance > A.Radius + B.Radius) { // B is outside A }

Wenn in Bild n-1B innerhalb von A und in Bild nB außerhalb von A war und die Zeit zwischen den Bildern nicht zu groß war (auch bekannt als B bewegte sich nicht zu schnell), können wir den Kollisionspunkt approximieren, indem wir nur die kartesischen Koordinaten von B relativ ermitteln zu einer:

collision.X = B.X - A.X;
collision.Y = B.Y - A.Y;

Wir können diese Punkte dann in einen Winkel umwandeln:

collision.Normalize(); //not 100% certain if this step is necessary     
radians = atan2(collision.Y, collision.X)

Wenn Sie zum tersten Mal genauer wissen möchten, an welcher Stelle B außerhalb von A liegt, können Sie in jedem Frame eine Strahlenkreuzung durchführen und dann vergleichen, ob die Entfernung von B zum Kollisionspunkt größer ist, als die Entfernung, die B zurücklegen kann momentane Geschwindigkeit. In diesem Fall können Sie den genauen Zeitpunkt der Kollision berechnen.

Sei (Xa, Ya) die Position des großen Kreises und sein Radius R und (Xb, Yb) die Position des kleineren Kreises und sein Radius r.

Sie können überprüfen, ob diese beiden Kreise kollidieren, wenn

DistanceTest = sqrt(((Xa - Xb) ^ 2) + ((Ya - Yb) ^ 2)) >= (R - r)

Um die Position der Kollision herauszufinden, ermitteln Sie den genauen Zeitpunkt der Kollision der Kreise mithilfe einer binären Suche, jedoch mit einer festen Anzahl von Schritten. Abhängig davon, wie Ihr Spiel erstellt wurde, können Sie diesen Teil des Codes optimieren (ich habe diese Lösung bereitgestellt, um unabhängig vom Verhalten des kleinen Balls zu sein. Wenn er eine konstante Beschleunigung oder Geschwindigkeit aufweist, kann dieser Teil des Codes optimiert werden und durch eine einfache Formel ersetzt).

left = 0 //the frame with no collision
right = 1 //the frame after collision
steps = 8 //or some other value, depending on how accurate you want it to be
while (steps > 0)
    checktime = left + (right - left) / 2
    if DistanceTest(checktime) is inside circle //if at the moment in the middle of the interval [left;right] the small circle is still inside the bigger one
        then left = checktime //the collision is after this moment of time
        else right = checktime //the collision is before
    steps -= 1
finaltime = left + (right - left) / 2 // the moment of time will be somewhere in between, so we take the moment in the middle of interval to have a small overall error

Wenn Sie die Kollisionszeit kennen, berechnen Sie die Positionen der beiden Kreise zum endgültigen Zeitpunkt und der endgültige Kollisionspunkt ist

CollisionX = (Xb - Xa)*R/(R-r) + Xa
CollisionY = (Yb - Ya)*R/(R-r) + Ya

Ich habe eine Demo eines Balls implementiert, der in einem Kreis auf jsfiddle mit dem von Sam Hocevar beschriebenen Algorithmus springt :

http://jsfiddle.net/klenwell/3ZdXf/

Hier ist das Javascript, das den Kontaktpunkt identifiziert:

find_contact_point: function(world, ball) {
    // see /gamedev//a/29658
    var A = world.point();
    var B = ball.point().subtract(ball.velocity());
    var C = ball.point();
    var R = world.r;
    var r = ball.r;

    var AB = B.subtract(A);
    var BC = C.subtract(B);
    var AB_len = AB.get_length();
    var BC_len = BC.get_length();

    var b = AB.dot(BC) / Math.pow(BC_len, 2) * -1;
    var c = (Math.pow(AB_len, 2) - Math.pow(R - r, 2)) / Math.pow(BC_len, 2);
    var d = b * b - c;
    var k = b - Math.sqrt(d);

    if ( k < 0 ) {
        k = b + Math.sqrt(d);
    }

    var BD = C.subtract(B);
    var BD_len = BC_len * k;
    BD.set_length(BD_len);

    var D = B.add(BD);
    return D;
}