Empêcher le tunneling avec cette configuration?

Question

J'ai un schéma simple de collision rectangle-carreau mis en place, et il fonctionne magnifiquement.

Le seul problème est lorsque vous commencez à tomber d'un rebord. Votre vitesse atteint le point où le changement dans Y/X chaque image est assez grand pour que vous puissiez découper en objets solides et pépins.

Fondamentalement, ma configuration est la suivante:

Pour commencer, a sa vitesse ajouté, la position du joueur pour le joueur est maintenant à l'endroit où il serait le prochain cadre si aucune collision se produisent. La liste ci-dessous est une seule fonction, checkIntersectTiles (Vector2 maskPos); Calculez les tuiles autour du caractère à vérifier.

Traversez des tuiles, y compris celles à l'intérieur des tuiles de délimitation.

Vérifiez le rectangle de collision du joueur contre chacune de ces tuiles.

S'il y a une intersection, déplacez le plus grand axe offensant hors de la tuile, puis réglez la vitesse de cet axe sur 0.

Continuez les vérifications. Lorsque vous découpez dans le sol, vous tremblez à l'intérieur, car mon algorithme tente de vous faire sortir de la case qui est le plus en collision avec vous.

Ma solution: Vérifiez chaque position depuis la position du joueur, jusqu'à la vélocité pos + du joueur. Je suis coincé sur ce bit.

Quelqu'un peut-il me donner un coup de main?

Answer 1

Je suppose que votre code pour sortir le joueur de la tuile de collision le fait en une seule étape. Donc, si le joueur entre en collision avec une tuile, vous déterminez que la profondeur de pénétration est de 5 dans la direction Y, vous ajustez immédiatement la position Y du joueur de -5.

Comme vous le suggérez, vérifiez la position du lecteur à chaque étape. Donc, si la vélocité Y est de 5, vous pouvez ajuster la position Y des joueurs de 1, vérifier la collision et répéter 4 fois de plus. Voir plus loin pour les calculs traitant le pas de temps. Ce qui suit est juste un pseudo-code de base et juste dans la direction Y.

player.Y += vel; 
if (player.CheckCollisions()) 
{ 
    // handle collision 
} 

Devient

for (int i = 0; i < vel; ++i) 
{ 
    player.Y += 1; 
    if (player.CheckCollisions()) 
    { 
    // handle collision 
    break; 
    } 
} 

C'est la version simple si vous n'êtes pas le temps de réglage pour ellaped. Si vous êtes, alors vous plutôt effectuer de temps plus petites étapes

Alors

player.Y += vel * elapsedTime; 
if (player.CheckCollisions()) 
{ 
    // handle collision 
} 

Devient

float currentTimeStep = 0; 
Position startY = player.Y; 
while (currentTimeStep < elapsedTime) 
{ 
    currentTimeStep = Math.Min(currentTimeStep + stepDelta, elapsedTime); // You need to tune the stepDelta 
    player.Y = startY + vel * currentTimeStep; 
    if (player.CheckCollisions()) 
    { 
    // handle collision 
    break; 
    }  
} 

Dans ce qui précède, vous aurez besoin de régler le delta pas de temps pour vous assurer d'équilibrer les performances avec précision. Vous pourriez envisager de calculer dynamiquement le delta de chaque image pour vous assurer que le réglage est proche de 1 pixel.