Como encontro o ponto de impacto com a detecção de colisão 2D por pixel?

7

Estou criando um jogo de plataformas e implementamos a detecção de colisões por pixel. No entanto, isso causou 2 obstáculos que ainda não descobri. O primeiro obstáculo, de que trata esta questão, é que não sei como encontrar com eficiência o ponto de impacto (meu outro problema provavelmente será uma pergunta diferente neste StackExchange).

Meu personagem cai ou pula em uma determinada taxa em pixels. Ou seja, todos os quadros em que o personagem pode cair 4 pixels ou pular 4 pixels, por exemplo. Se o personagem cair e cruzar um objeto, ele deverá pousar nele (e vice-versa, se estiver pulando e atingindo um objeto, deve começar a cair novamente). No entanto, se, por exemplo, um caractere cair 4 pixels e isso os colocar 3 pixels em um objeto, eles pararão de cair, mas não estarão no local apropriado. O personagem deve parecer parar no primeiro pixel de impacto.

Então, como posso encontrar com eficiência o ponto de impacto? Eu só tenho uma vaga idéia de comparar apenas os pixels do contorno, testar a colisão e aumentá-los para cima ou para baixo em um até que ocorra uma colisão, mas parece que pode ser complicado remover.

Se você quiser conhecer a plataforma, estou desenvolvendo usando o XNA para Windows Phone 7.

Prumo
fonte
3
Dupe relacionado e provável (em termos de respostas): gamedev.stackexchange.com/questions/2942/…
Tetrad
@ Tetrad, obrigado. Espero que você possa entender por que eu não acho que para procurar uma pergunta sobre míssil e colisão terreno: P Não é bem o jogo que eu estou desenvolvendo
Bob
Você já pensou em física Box2D?
user712092
Você pode entrar em um problema conhecido como encapsulamento .
user712092
Se ainda não o fez, adicione "varredura" às suas consultas de pesquisa. Os algoritmos dinâmicos de detecção de colisão costumam usar um parâmetro de varredura para obter o primeiro ponto de colisão.
sam hocevar

Respostas:

5

Eu li um artigo muito bom antes que descrevia como a detecção de colisão foi implementada nos jogos anteriores do Sonic.

Esse artigo teria sido uma excelente referência para este tópico, mas não consigo encontrá-lo no momento. Se fizer isso, atualizarei minha postagem. Enquanto isso, vou tentar tirar da memória!

Acredito que essa técnica seja muito interessante e possa resolver seus problemas, sem precisar mudar para um mecanismo de física nem deixar de lado a colisão por pixel.

Basicamente, o que o artigo descrito foi um mecanismo de plataforma baseado em bloco em que cada tipo de bloco tinha dados de colisão por pixel como este:

Telha

Mas seu personagem só tinha um conjunto limitado de pontos de contato. Por exemplo, no artigo, lembro que havia apenas 3 pixels perto da cabeça do sonic (um à esquerda do sprite, um no meio e outro à direita) que seriam usados ​​para detecção de colisão ao pular, 3 pixels perto dos pés do sonic para detectar colisões com o chão e 2 perto do meio de cada lado para detectar colisões com paredes.

Vou fazer uma rápida simulação do que me lembro. Algo como (não confie na precisão do meu posicionamento de pixel, eu apenas inventei):

sônica

Dessa forma, você só precisa verificar a colisão usando esses pontos individuais (quais dependem da situação, como pular ou cair) e, em caso de colisão, você só precisa ajustar o sprite com base nesses pontos. Por exemplo, se um dos pontos superiores colidir com algum pixel bloqueado no ladrilho do teto, você só precisará derrubar o sprite até que o ponto não colide mais.

Editar

Embora este ainda não seja o link que li originalmente, ele também menciona os pontos de colisão ( sensores nomeados ) e deve fornecer uma grande quantidade de informações. Leia também as outras seções do guia!

http://info.sonicretro.org/SPG:Solid_Tiles

David Gouveia
fonte
Isso me leva a lembrar quando eu era mais jovem, com 8 anos e fazer alguns jogos com o Multimedia Fusion. Costumávamos usar esses "sensores" como algumas barras abaixo, acima e pelo personagem. e conseguiu tudo muito bem!
Gustavo Maciel
2

Antes de tudo, eu não buscaria a detecção de colisão perfeita de pixels em um jogo de plataforma 2D móvel por razões óbvias de desempenho. Esse tipo de verificação consome muita CPU e, a menos que você faça uma verificação ampla para filtrar objetos separados, certamente afetará negativamente o seu jogo.

Eu usaria caixas e / ou esferas delimitadoras (dependendo das formas das entidades). A qualidade da detecção seria boa o suficiente. Você pode até usar mais de uma forma para modelar uma entidade. Os testes entre essas formas são fáceis e você pode conhecer pontos de impacto e corrigir posições de entidades.

Mas, se você não quiser implementar tudo sozinho, use o Box2DX (porta C # do Box2D) e use apenas a parte de detecção de colisão da biblioteca.

David Saltares
fonte
Obrigado pelo link para Box2D, vou olhar para ele. Quanto ao desempenho, meus sprites são muito pequenos e "antiquados", mas ampliados para que não haja muitos pixels para serem testados. Também verifico primeiro os retângulos delimitadores e só faço por pixel se os limites se cruzarem. Eu faço por pixel porque os pixels são tão grandes (sendo redimensionados) que parece que se eles não interagirem corretamente.
Bob