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

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.

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:

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):

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

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.