Eu tenho objetos estáticos e objetos móveis. As colisões são detectadas usando o teorema do eixo separador.
Por exemplo, nessa situação, tenho dois objetos estáticos (em vermelho):
e um objeto móvel entre os dois:
Meu algoritmo é capaz de calcular a colisão entre dois desses objetos e também cospe um vetor de resolução perfeita (significando um vetor de deslocamento mínimo) para a colisão.
Por exemplo, quando eu checo a colisão entre o retângulo verde e o retângulo vermelho direito, o algoritmo cospe um vetor que me diz como eu preciso mover o retângulo verde para resolver a colisão:
Observe que eu desenhei isso rapidamente no MSPaint, então nessa imagem pode ser que o vetor de tradução mínimo empurre o retângulo verde para cima, mas presumo que o empurre para a esquerda / certo é realmente mais curto.
A maneira geral de abordar isso seria resolver apenas a colisão de uma colisão por quadro, em vez de todos de uma vez. Mas no meu caso, isso resultaria em flip-flopping:
Primeiro, o solucionador detecta duas colisões, mas apenas resolve a colisão entre o retângulo direito e o retângulo verde:
Em seguida, no próximo quadro, ele detecta apenas uma colisão que está entre o retângulo vermelho esquerdo e o retângulo verde e o resolve:
Como você pode ver, isso realmente não resolve a colisão (por exemplo, empurrando o retângulo verde para cima) e, em vez disso, apenas inverta os flops infinitamente.
Como posso resolver isso?
Respostas:
Dependendo exatamente do que você está tentando alcançar (alta precisão física ou apenas uma simulação em tempo real suficientemente próxima), você pode tentar usar contatos especulativos.
Aqui estão os detalhes: http://www.wildbunny.co.uk/blog/2011/03/25/speculative-contacts-an-continuous-collision-engine-approach-part-1/
Ele descreve nesse artigo o que você precisa saber para implementá-lo, e é muito simples comparado a outras abordagens (como projeção de esferas e classificação das resoluções de colisão por tempo de impacto).
Se você precisar / quiser mais, poderá comprar o código-fonte por US $ 7 (IIRC).
Aqui está um vídeo da minha implementação em 3D: http://www.youtube.com/watch?v=JvT2H1RmOas
Observe como a simulação é estável com apenas uma única iteração. Você poderia facilmente usar várias iterações por quadro para resolver várias colisões para um estado estável, o que seria mais preciso.
fonte
Você pode primeiro calcular todos os vetores necessários para resolver cada colisão e depois calcular uma resultante deles.
O único caso em que isso pode ser byte é se esses vetores se anulam, como no seu exemplo. Nesse caso, a colisão não pode ser resolvida.
fonte
Se você olhar atentamente, esse estado de objetos é (ou deveria ser) inatingível.
Deixe a forma vermelha mais à esquerda ter a forma R1 e a forma vermelha mais à direita ter a forma R2. Deixe a forma verde ser G.
Dado o tamanho e a geometria dos três objetos, e considerando que todos os objetos não são penetráveis:
Agora, tudo se resume a isso: se seu algoritmo consulta seus objetos um por um, é uma questão de simultaneidade, ou seja, de certa forma, o algoritmo deve verificar TODOS os objetos ao mesmo tempo, mas o algoritmo limita você a fazer objetos e processá-los um de cada vez ...
Se G é checado contra R1 depois de checado com R2, então G parece legalmente estar à direita de R1 (se G diz aproxima-se de R1 com a direção do vetor <-1, -1> com magnitude (ou distância) arbitrária ), porque a verificação entre R1 e G permite isso e esquece a verificação entre R2 e G, que foi feita antes.
Uma solução que você pode fazer é coletar todos os vetores de deslocamento mínimo em uma matriz ou em qualquer estrutura de dados desejada e escolher uma que seja legal para TODOS os Objetos.
Observe que em um determinado quadro, o objeto (G, por exemplo) pode ter apenas UMA direção. (oh cara, parece a boyband ...)
fonte