Cercle à l'intérieur du cercle de collision

Dans l'un de mes projets, j'ai une zone de jeu en forme de cercle. À l'intérieur de ce cercle, un autre petit cercle se déplace. Ce que je veux faire, c'est empêcher le petit cercle de sortir du plus grand. Ci-dessous, vous pouvez voir que dans le cadre 2, le petit cercle est partiellement à l'extérieur, j'ai besoin d'un moyen de le ramener juste avant qu'il ne se déplace vers l'extérieur. Comment cela peut-il être fait?

De plus, j'ai besoin du point de collision le long de l'arc du grand cercle pour pouvoir mettre à jour la vitesse du petit cercle. Comment procéder pour calculer ce point?

Ce que je voudrais faire, c'est avant de déplacer le petit cercle, je prédis sa position suivante et s'il est à l'extérieur je trouve le temps de collision entre t = 0 et t = 1 (t = 1 pas à temps plein). Si j'ai le temps de collision t, je déplace simplement le petit cercle pendant t au lieu d'un pas à temps plein. Mais encore une fois, le problème est que je ne sais pas comment détecter à ce moment-là la collision se produit quand il s'agit de deux cercles et l'un à l'intérieur de l'autre.

ÉDITER:

Exemple de point de collision (vert) que je veux trouver. Peut-être que l'image est un peu décalée mais vous avez l'idée.

Supposons que le grand cercle ait le centre Aet le rayon Ret que le petit cercle ait le centre Bet le rayon se rdéplaçant vers l'emplacement C.

Il existe une manière élégante de résoudre ce problème, en utilisant des sommes de Minkovski (soustractions, en fait): remplacer le disque de rayon Rpar un disque de rayon R-r, et le disque de rayon rpar un disque de rayon 0, c'est-à - dire. un simple point situé à B. Le problème devient un problème d'intersection ligne-cercle.

Il vous suffit alors de vérifier si la distance ACest inférieure à R-r. Si c'est le cas, les cercles ne se heurtent pas. Si elle est plus grande, juste trouver le point Dsur BCà une distance R-rde Ace qui est le nouvel emplacement du centre de votre petit cercle. Cela revient à trouver ktel que:

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

La substitution vec(AD)par vec(AB) + vec(BD)donne:

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

À condition que la position initiale se trouve à l'intérieur du grand cercle, cette équation quadratique ka une racine positive. Voici comment résoudre l'équation, en 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

Avec cette valeur de k, le nouveau centre du petit cercle est Dtel BD = kBC.

Modifier : ajouter une solution d'équation quadratique

Disons que le grand cercle est le cercle A et le petit cercle est le cercle B.

Vérifiez si B est à l'intérieur de A:

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

Si dans l'image n-1B était à l'intérieur de A et dans l'image nB est à l'extérieur de A et le temps entre les images n'était pas trop grand (aka B ne se déplaçait pas trop vite), nous pouvons approximer le point de collision en trouvant simplement les coordonnées cartésiennes de B par rapport à A:

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

Nous pouvons ensuite convertir ces points en un angle:

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

Si vous voulez savoir plus exactement à quoi tB se trouve en dehors de A pour la première fois, vous pouvez faire une intersection cercle-rayon à chaque image, puis comparer si la distance entre B et le point de collision est plus grande que la distance que B peut parcourir étant donné que c'est vitesse actuelle. Si c'est le cas, vous pouvez calculer l'heure exacte de la collision.

Soit (Xa, Ya) la position du grand cercle et son rayon R, et (Xb, Yb) la position du petit cercle et son rayon r.

Vous pouvez vérifier si ces deux cercles entrent en collision si

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

Pour connaître la position de la collision, recherchez le moment exact où les cercles entrent en collision, en utilisant une recherche binaire mais avec un nombre fixe d'étapes. Selon la façon dont votre jeu est fait, vous pouvez optimiser cette partie du code (j'ai fourni cette solution pour être indépendante du comportement de la petite balle. Si elle a une accélération constante ou une vitesse constante, cette partie du code peut être optimisée et remplacé par une formule simple).

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

Une fois que vous connaissez le temps de collision, calculez les positions des deux cercles au moment final et le point de collision final est

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

J'ai implémenté une démo d'une balle rebondissant dans un cercle sur jsfiddle en utilisant l'algorithme décrit par Sam Hocevar :

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

Voici le javascript qui identifie le point de contact:

find_contact_point: function(world, ball) {
    // see https://gamedev.stackexchange.com/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;
}