Costruire un Plattformer - Come determinare se un giocatore può saltare?

Sto costruendo un semplice gioco Jump n 'Run Style Plattformer. Non uso le tessere, invece ho forme geometriche per le mie entità di livello (e anche il giocatore è uno). Ho finito il mio codice di rilevamento delle collisioni e tutto funziona bene finora.

Successivamente, volevo implementare il salto. Basta controllare se il giocatore preme il tasto appropriato e aggiungere un po 'di velocità verso l'alto. Funziona bene. Ma funziona anche se il giocatore è in aria, il che non è quello che voglio. ;-)

Quindi, devo controllare se il giocatore si trova su qualcosa. La mia prima idea è stata quella di verificare se ci fosse una collisione nell'ultimo fotogramma e contrassegnare il giocatore come "in grado di saltare", ma ciò si innescherebbe anche se il giocatore colpisce un muro in aria. Poiché le mie abilità matematiche non sono così buone, chiedo aiuto - anche i suggerimenti farebbero come implementarlo.

Grazie!

Mi vengono in mente due opzioni:

• Il primo pensiero è di contrassegnare la geometria con un ID e quindi verificare se la collisione è con la geometria contrassegnata come pavimento. Ciò offre il massimo controllo delle superfici saltabili ma a un costo in termini di tempo di creazione del livello.
• Il secondo è controllare la normale della collisione, se è rivolta verso l'alto, quindi consentire il salto. O entro un certo margine, dipende da se si hanno piani inclinati. Questo è flessibile e non richiede alcun tag, ma se hai pavimenti e pareti inclinati potresti saltare un po 'dove non lo desideri.

Dovresti sicuramente implementare un qualche tipo di tipo di superficie. Pensaci, come farai se riesci a salire una scala se non sai se il tuo personaggio si è appena scontrato contro un muro o una scala? Potresti semplicemente usare OOP per gestire una gerarchia di tipi usando heritage, ma ti suggerirei di usare le "categorie" implementate usando un tipo enumerato:

Ecco l'idea: un'enumerazione "Collisioni" ha un flag per ogni categoria. Per esempio:

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

Con questo metodo, sarai in grado di verificare se il juste del giocatore ha scontrato qualcosa che dovresti gestire, in modo che il tuo motore possa chiamare un metodo "Collided" dell'entità:

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

Il metodo usa flag bit a bit e l'operatore bit a bit "Or" per assicurare che ogni gruppo abbia un valore diverso, basato sul valore binario della categoria. Questo metodo funziona bene ed è facilmente scalabile in modo da poter creare gruppi di collisioni doganali. Ogni Entità (Giocatore, Nemico, ecc.) Nel tuo gioco ha alcuni bit chiamati "filtro", che sono usati per determinare con cosa possono scontrarsi. Il codice di collisione dovrebbe verificare se i bit corrispondono e reagiscono di conseguenza, con un codice che potrebbe apparire come:

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

Se consideri il piede del tuo personaggio sempre sotto il personaggio di una certa distanza e se non ti stai allontanando dalla superficie, il tuo personaggio è a terra.

In pseudo-codice approssimativo:

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