Círculo dentro del círculo colisión

En uno de mis proyectos tengo un área de juego en forma de círculo. Dentro de este círculo se mueve otro círculo pequeño. Lo que quiero hacer es evitar que el círculo pequeño se mueva fuera del más grande. A continuación puede ver que en el cuadro 2 el círculo pequeño está parcialmente afuera, necesito una forma de moverlo de regreso justo antes de que esté a punto de moverse afuera. ¿Cómo se puede hacer esto?

Además, necesito el punto de colisión a lo largo del arco del círculo grande para poder actualizar la velocidad del círculo pequeño. ¿Cómo se podría calcular este punto?

Lo que me gustaría hacer es antes de mover el círculo pequeño, predigo su próxima posición y si está afuera encuentro el tiempo de colisión entre t = 0 y t = 1 (t = 1 paso de tiempo completo). Si tengo el tiempo de colisión t, entonces solo muevo el círculo pequeño durante t en lugar de un paso de tiempo completo. Pero nuevamente, el problema es que no sé cómo detectar en ese momento que la colisión ocurre cuando se trata de dos círculos y uno está dentro del otro.

EDITAR:

Ejemplo de punto de colisión (verde) que quiero encontrar. Tal vez la imagen está un poco apagada, pero entiendes la idea.

Supongamos que el círculo grande tiene centro Ay radio Ry el círculo pequeño tiene centro By radio rmoviéndose hacia la ubicación C.

Hay una manera elegante de resolver este problema, utilizando sumas de Minkovski (sustracciones, en realidad): reemplazar el disco de radio Rcon un disco de radio R-ry el disco de radio rcon un disco de radio 0, es decir. un punto simple ubicado en B. El problema se convierte en un problema de intersección línea-círculo.

Entonces solo necesita verificar si la distancia ACes menor que R-r. Si es así, los círculos no chocan. Si es mayor, acaba de encontrar el punto Den BCa una distancia R-rde Ay esta es la nueva ubicación del centro de su pequeño círculo. Esto es equivalente a encontrar ktal que:

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

Sustituyendo vec(AD)con vec(AB) + vec(BD)da:

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

Siempre que la posición inicial estuviera dentro del círculo grande, esta ecuación cuadrática ktiene una raíz positiva. Aquí se explica cómo resolver la ecuación, en pseudocódigo:

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

Con este valor de k, el nuevo centro del círculo pequeño es Dtal que BD = kBC.

Editar : agregar solución de ecuación cuadrática

Digamos que el círculo grande es el círculo A y el círculo pequeño es el círculo B.

Verifique si B está dentro 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 en el cuadro n-1B estaba dentro de A y en el cuadro nB está fuera de A y el tiempo entre cuadros no era demasiado grande (también conocido como B no se movía demasiado rápido), podemos aproximar el punto de colisión simplemente encontrando las coordenadas cartesianas de B relativo a A:

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

Luego podemos convertir estos puntos en un ángulo:

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

Si quiere saber más exactamente qué tB está fuera de A por primera vez, puede hacer una intersección de círculo de rayos en cada cuadro y luego comparar si la distancia desde B hasta el punto de colisión es mayor, entonces la distancia B puede viajar dado que es velocidad actual. Si es así, puede calcular el tiempo exacto de colisión.

Deje (Xa, Ya) la posición del círculo grande y su radio R, y (Xb, Yb) la posición del círculo más pequeño y su radio r.

Puede verificar si estos dos círculos colisionan si

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

Para averiguar la posición de la colisión, encuentre el momento exacto en que los círculos colisionan, utilizando una búsqueda binaria pero con un número fijo de pasos. Dependiendo de cómo esté hecho su juego, puede optimizar esta parte del código (proporcioné esta solución para que sea independiente de cómo se comporta la bola pequeña. Si tiene aceleración constante o velocidad constante, esta parte del código puede optimizarse y reemplazado con una fórmula 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

Una vez que sepa el tiempo de colisión, calcule las posiciones de los dos círculos en el momento final y el punto de colisión final es

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

He implementado una demostración de una pelota que rebota en un círculo en jsfiddle usando el algoritmo descrito por Sam Hocevar :

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

Aquí está el javascript que identifica el punto de contacto:

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;
}