Construindo um Plattformer - Como determinar se um jogador pode pular?

Estou criando um jogo simples do Plattformer Jump n 'Run Style. Eu não uso peças - em vez disso, tenho formas geométricas para minhas entidades de nível (e o jogador também é um). Terminei meu código de detecção de colisão e tudo funciona bem até agora.

Em seguida, eu queria implementar o salto. Basta verificar se o jogador pressiona a tecla apropriada e adicionar alguma velocidade para cima. Funciona bem. Mas funciona mesmo que o jogador esteja no ar, o que não é o que eu quero. ;-)

Então, eu tenho que verificar se o jogador está em alguma coisa. Minha primeira idéia foi verificar se houve uma colisão no último quadro e marcar o jogador como "capaz de pular", mas isso seria acionado se o jogador atingisse uma parede no ar. Como minhas habilidades matemáticas não são tão boas, peço ajuda - até dicas sugeririam como implementar isso.

Obrigado!

Duas opções vêm à mente:

• O primeiro pensamento é marcar a geometria com um ID e depois verificar se a colisão está com a geometria marcada como piso. Isso oferece o máximo controle de superfícies saltáveis, mas a um custo no tempo de criação do nível.
• O segundo é verificar o normal da colisão, se estiver apontando para cima, permita o salto. Ou dentro de uma margem superior, depende se você possui pisos inclinados. Isso é flexível e não requer marcação, mas se você tiver pisos e paredes inclinados, poderá saltar onde não desejar.

Você certamente deve implementar algum tipo de tipo de superfície. Pense nisso, como você vai conseguir se consegue subir uma escada se não sabe se seu personagem acabou de colidir com uma parede ou uma escada? Você pode simplesmente usar o OOP para gerenciar uma hierarquia de tipos usando herança, mas eu sugiro que você use "categorias" implementadas usando um tipo enumerado:

Aqui está a idéia: Uma enumeração "Colisões" possui um sinalizador para cada categoria. Por exemplo:

namespace Collisions
{
    enum Type
    {
        None   = 0,
        Floor  = 1 << 0,
        Ladder = 1 << 1,
        Enemy  = 1 << 2,
        ... // And whatever else you need.

        // Then, you can construct named groups of flags.
        Player = Floor | Ladder | Enemy
    };
}

Com esse método, você poderá testar se o jogador justificou alguma coisa que deveria gerenciar, para que seu mecanismo possa chamar um método "colidido" da entidade:

void Player::Collided( Collisions::Type group )
{
   if ( group & Collisions::Ladder )
   {
      // Manage Ladder Collision
   }
   if ( group & Collisions::Floor )
   {
      // Manage Floor Collision
   }
   if ( group & Collisions::Enemy )
   {
      // Manage Enemy Collision
   }
}

O método usa sinalizadores bit a bit e o operador "Or" bit a bit para garantir que cada grupo tenha um valor diferente, com base no valor binário da categoria. Esse método funciona bem e é facilmente escalável para que você possa criar grupos de colisão alfandegária. Cada entidade (jogador, inimigo, etc.) do seu jogo possui alguns bits chamados de "filtro", que são usados ​​para determinar com o que ela pode colidir. Seu código de colisão deve verificar se os bits correspondem e reagem de acordo, com algum código que pode se parecer com:

void PhysicEngine::OnCollision(...)
{
    mPhysics.AddContact( body1, body1.GetFilter(), body2, body2.GetFilter() );
}

Se você considerar o pé do seu personagem sempre sob o personagem por uma certa distância, e se você não estiver se afastando da superfície, seu personagem estará no chão.

Em pseudo-código aproximado:

bool isOnGround(Character& chr)
{
   // down vector is opposite from your characters current up vector.
   // if you want to support wall jumps, animate the vecToFoot as appropriate.
   vec vecToFoot = -chr.up * chr.footDistanceFromCentre;


// if feet are moving away from any surface, can't be on the ground
   if (dot(chr.velocity, down) < 0.0f)
     return false;


// generate line from character centre to the foot position
   vec linePos0 = chr.position;
   vec linePos1 = chr.position + vecToFoot;


// test line against world. If it returns a hit surface, we're on the ground
   if (testLineAgainstWorld(line0, line1, &surface)
     return true;


return false;
}