Círculo dentro da colisão do círculo

Em um dos meus projetos, tenho uma área de jogo na forma de um círculo. Dentro deste círculo, outro pequeno círculo está se movendo. O que eu quero fazer é impedir que o pequeno círculo se mova para fora do maior. Abaixo, você pode ver que, no quadro 2, o pequeno círculo está parcialmente fora, preciso de uma maneira de recolocá-lo antes que ele esteja prestes a sair. Como isso pode ser feito?

Além disso, preciso do ponto de colisão ao longo do arco do grande círculo para poder atualizar a velocidade do pequeno círculo. Como alguém calcularia esse ponto?

O que eu gostaria de fazer é antes de mover o pequeno círculo, prevejo sua próxima posição e, se estiver fora, encontro o tempo de colisão entre t = 0 et = 1 (t = 1 etapa em tempo integral). Se eu tiver o tempo de colisão t, basta mover o pequeno círculo durante t em vez de uma etapa em tempo integral. Mas, novamente, o problema é que não sei como detectar naquele momento a colisão quando se trata de dois círculos e um dentro do outro.

EDITAR:

Exemplo de ponto de colisão (verde) que desejo encontrar. Talvez a imagem esteja um pouco errada, mas você entendeu.

Vamos supor que o círculo grande tenha centro Ae raio Re o pequeno círculo tenha centro Be raio se rmovendo em direção à localização C.

Existe uma maneira elegante de resolver esse problema, usando somas de Minkovski (subtrações, na verdade): substitua o disco de raio Rpor um disco de raio R-re o disco de raio rpor um disco de raio 0, ou seja. um ponto simples localizado em B. O problema se torna um problema de interseção de círculo de linha.

Você só precisa verificar se a distância ACé menor que R-r. Se for, os círculos não colidem. Se for maior, basta encontrar o ponto Dem BCuma distância R-rde Ae esta é a nova localização do centro de seu pequeno círculo. Isso é equivalente a encontrar ktais que:

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

Substituindo vec(AD)por vec(AB) + vec(BD)dá:

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

Desde que a posição inicial estivesse dentro do círculo maior, essa equação quadrática em ktem uma raiz positiva. Aqui está como resolver a equação, no 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

Com esse valor de k, o novo centro do pequeno círculo é Dtal que BD = kBC.

Editar : adicionar solução de equação quadrática

Digamos que o grande círculo seja o círculo A e o pequeno círculo seja o círculo B.

Verifique se 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 }

Se no quadro n-1B estava dentro de A e no quadro nB está fora de A e o tempo entre os quadros não era muito grande (também conhecido como B não estava se movendo muito rápido), podemos aproximar o ponto de colisão encontrando as coordenadas cartesianas de B relativas para A:

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

Podemos então converter esses pontos em um ângulo:

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

Se você quiser saber mais exatamente o que tB está fora de A pela primeira vez, poderá fazer uma interseção de círculo de raios a cada quadro e comparar se a distância de B ao ponto de colisão é maior, então a distância que B pode percorrer, velocidade atual. Nesse caso, você pode calcular o tempo exato da colisão.

Deixe (Xa, Ya) a posição do grande círculo e seu raio R, e (Xb, Yb) a posição do círculo menor e seu raio r.

Você pode verificar se esses dois círculos colidem se

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

Para descobrir a posição da colisão, encontre o momento exato em que os círculos colidem, usando uma pesquisa binária, mas com um número fixo de etapas. Dependendo de como o seu jogo é feito, você pode otimizar essa parte do código (eu forneci esta solução para ser independente de como a pequena bola se comporta. Se ela tem aceleração constante ou velocidade constante, essa parte do código pode ser otimizada e substituído por uma fórmula simples).

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

Depois de conhecer o tempo de colisão, calcule as posições dos dois círculos no momento final e o ponto de colisão final será

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

Implementei uma demonstração de uma bola quicando em círculo no jsfiddle usando o algoritmo descrito por Sam Hocevar :

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

Aqui está o javascript que identifica o ponto de contato:

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