Que dois-je faire pour empêcher mes monstres de quitter les plates-formes?

J'ai une question qui me rend fou parce que je pense qu'il devrait être assez facile de trouver un tutoriel dessus. J'utilise actuellement XNA et Farseer pour créer un jeu de plateforme simple. Je suis sur le point d'en finir, mais je veux que mes monstres soient plus intelligents. Dans ce cas, cela signifie que je ne veux pas que mes monstres tombent des falaises.

Pour faire simple, je veux quelque chose qui vérifie la zone devant mon "monstre" afin de déterminer quand le monstre doit changer de direction. Pourriez-vous me diriger dans la bonne direction?

Que suis-je censé utiliser, il devrait exister une solution simple ou un algorithme simple pour vérifier cela, non?

Je n'ai jamais travaillé avec XNA auparavant et je pense qu'il apparaîtra de meilleures solutions que la mienne. Mais une solution de contournement qui pourrait fonctionner est que vous pourriez mettre un objet invisible aux extrémités des falaises et que le monstre pourrait vérifier la collision avec cet objet. S'il entre en collision, il change de direction.

Une façon naïve de l'implémenter est d'utiliser le raycasting.

Calculez où votre monstre sera dans un petit morceau de temps (probablement un cadre). À partir de cette position (ou si vous voulez être plus robuste, cette position +/- la zone de délimitation de votre ennemi) faites un lancer de rayons vers le bas. Si elle ne touche pas quelque chose dans une plage appropriée (selon l'endroit où vous lancez votre raycast verticalement, la hauteur du personnage, la "taille de pas" souhaitée, etc.), vous pouvez comprendre qu'il y a une falaise où le personnage veut être, et décidez de changer les directions de manière appropriée.

Avec mon IA, je vérifie simplement s'il y a une plate-forme en dessous et dans la direction de son déplacement (sans utiliser un système de tuiles, juste un système de collision groovy). S'il n'y en a pas - ou s'il frappe un bloc solide, il obtient un aspect confus et se retourne.

De cette façon, vous pouvez avoir des cartes dynamiques et toujours avoir une IA fonctionnelle (terme utilisé librement).

Je soupçonne que vous utilisez une carte de tuiles, auquel cas l'une des solutions serait de le faire sur la base d'indices de tuiles. Vous devez trouver sur quelle tuile votre monstre se trouve actuellement, avec les formules suivantes:

int tileX = (int)(monster.Position.X / TILE_WIDTH);
int tileY = (int(monster.Position.Y / TILE_HEIGHT);

Une fois que vous les connaissez, vous devez trouver dans quelle direction X vous allez (afin de vérifier les blocs à venir):

int direction = 0;
if (monster.Velocity > 0f)
    direction = 1;
if (monster.Velocity < 0f)
    direction = -1;

Vous avez maintenant une direction X normalisée avec laquelle travailler.

Ensuite, vous voudrez vérifier les blocs autour pour voir si vous devez changer de direction:

if (GetTileCollision(tileX + direction, tileY) == TileCollision.Impassable || // going into a wall
    GetTileCollision(tileX + direction, tileY) == TIleCollision.Passable &&
    GetTileCollision(tileX + direction, tileY + 1) == TileCollision.Passable)) // we're going to fall down a block
    ChangeDirection(); // we change direction

Vous avez l'idée générale. Assurez-vous que vous retournez TileCollision.Impassable(ou quoi que ce soit) si les indices de tuile sont en dehors de la carte, pour empêcher votre programme de planter avec un index non valide, et cela empêche également les monstres de sortir de la carte.

Je suppose que cela dépend vraiment de la façon dont vous manipulez les carreaux, mais c'est la solution qui a fonctionné pour moi.

Basé sur les tutoriels de http://www.sgtconker.com/ (bien que le site Web soit en panne au moment où j'écris ceci)

Définissez une boîte à l'extérieur de la plate-forme qui se trouve sur un calque séparé et demandez aux monstres de le vérifier, afin qu'ils ne tombent pas mais que le joueur puisse le faire.