O que devo fazer para impedir que meus monstros saiam das plataformas?

Eu tenho uma pergunta que está me deixando louco, porque acho que deve ser bastante fácil encontrar um tutorial sobre ela. Atualmente, estou usando XNA e Farseer para criar um jogo de plataforma simples. Estou prestes a terminar, mas quero que meus monstros sejam mais inteligentes. Nesse caso, isso significa que não quero que meus monstros caiam dos penhascos.

Simplificando, quero algo que verifique a área na frente do meu "monstro" para determinar quando o monstro deve mudar de direção. Vocês poderiam me apontar na direção certa?

O que devo usar, deve existir uma solução simples ou um algoritmo simples para verificar isso, não?

Eu nunca trabalhei com XNA antes e acho que aparecerão melhores soluções do que as minhas. Mas uma solução alternativa que pode funcionar é que você pode colocar um objeto invisível nos extremos dos penhascos e o monstro pode verificar se há colisão com esse objeto. Se colidir, muda de direção.

Uma maneira ingênua de implementá-lo é usando o raycasting.

Calcule onde seu monstro estará em um pequeno pedaço de tempo (provavelmente um quadro). A partir dessa posição (ou se você quiser ser mais robusto, essa posição +/- a área delimitadora do seu inimigo) faça um radiodifusão. Se ele não atingir algo dentro de um intervalo apropriado (dependendo de onde você inicia seu raycast verticalmente, da altura do personagem, do "tamanho do passo" desejado etc.), você pode descobrir que existe um penhasco onde o personagem deseja estar, e decida alterar as direções adequadamente.

Com a minha IA, eu simplesmente verifico se há uma plataforma abaixo e a direção de sua viagem (sem usar um sistema de tiles, apenas um sistema de colisão groovy). Se não houver - ou se atingir um bloco sólido, ele fica com uma aparência confusa e se vira.

Dessa forma, você pode ter mapas dinâmicos e ainda ter uma IA funcional (termo usado livremente).

Suspeito que você esteja usando um mapa de blocos, caso em que a solução seria fazê-lo com base nos índices de blocos. Você precisa encontrar em qual bloco seu monstro está atualmente, com as seguintes fórmulas:

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

Depois de conhecê-los, você precisa descobrir em qual direção X você está indo (para verificar os blocos à frente):

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

Agora você tem uma direção X normalizada para trabalhar.

Em seguida, verifique os blocos para ver se deve mudar de direção:

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

Você entende a ideia geral. Certifique-se de retornarTileCollision.Impassable (ou o que for) se os índices do bloco estiverem fora do mapa, para impedir que seu programa caia com um índice inválido e também para impedir que monstros saiam do mapa.

Eu acho que depende realmente da maneira como você lida com os ladrilhos, mas esta é a solução que funcionou para mim.

Com base nos tutoriais de http://www.sgtconker.com/ (embora o site esteja em baixo enquanto eu escrevo isso)

Coloque uma caixa na parte externa da plataforma, em uma camada separada, e peça aos monstros que verifiquem isso, para que não caiam, mas o jogador ainda pode.