[tblima123] IA - Comportamento de Inimigos

Qualidade
Nome: IA - Comportamento de Inimigos
Blogueiro: tblima123
Descrissao: Tutorial avançado sobre IAs (recomendo ler)
Versao: Lite e Pro
Foto(s): (noops)

Tutorial:

Comportamento de Inimigos

Nível de dificuldade: Intermediário;
Requerimentos: Qualquer versão do GM;

Todo ser animado possui comportamentos. Comportamentos são ações previsíveis inerentes a todos os seres que realizam algum tipo de ato ou movimento. O comportamento de um rio por exemplo é bem simples: um movimento fixo numa dada direção.

Em jogos quase tudo tem um comportamento, geralmente bem simples. Vejamos por exemplo um Goomba Comum da série Mario. Os possíveis comportamentos deles se resumem a:

Depois de resumir no papel os possíveis comportamentos do inimigo no jogo, fica mais fácil programa-lo. Portanto, o primeiro passo para se programar o comportamento de um personagem é conhece-lo bem.

Programando um Inimigo Simples

Para este exemplo nós iremos começar com algo bem simples, um inimigo para um jogo maze. O comportamento dele será o seguinte:

• Iniciar com um movimento vertical para cima;
• Se colidir com algo, inverter direção.

Esse mesmo comportamento pode ser transcrito com a seguinte lógica:

• Definir uma direção para o movimento (para sima);
• Um movimento constante;
• Colidiu com uma parede? Inverter direção.

Então vamos implementar isso com código:

Primeiro crie um objeto qualquer com uma sprite qualquer;
Agora vamos programar;

Definir uma direção para o movimento (para sima):
//Evento Create

Código:

direcao = -1; //Define uma direção para o movimento, ela só pode ser igual a 1 e -1.

Um movimento constante
//Evento Step

Código:

vspeed = 5 * (direcao); //define velocidade vertical como 5 * direcao;

Inverter direção ao colidir
//Evento Step

Código:

if !place_free(x, y + vspeed){ //checa se há algum objeto sólido no caminho, se sim...

    direcao *= (-1);                  //inverte direção
}

Veja como é a lógica da coisa, é sempre muito importante você entender bem a lógica de um inimigo antes de programar seu comportamento.

Agora crie um objeto qualquer com uma sprite qualquer e marque como sólido, quando o nosso inimigo colidir com esse objeto ele mudará sua direção.

Tornando esse Inimigo um pouco mais complexo

Agora nós iremos dar um pouco mais de inteligencia a esse inimigo maze, o comportamento dele será o seguinte:

• Inicia com movimento vertical;
• Inverter direção ao colidir com parede;
• Checa se a posição vertical ou horizontal dele é igual a do player;
• Checa se não há nem uma parede entre ele e o player;
• Ataca!

Esse mesmo comportamento pode ser transcrito com a seguinte lógica:

• Inicia com movimento vertical;
• Colidiu com uma parede? Então inverter direção;
• Minha posição horizontal ou vertical é igual a do player? Então pergunta...;
• Há uma parede entre mim e o player? Se não...;
• Se mover em direção ao player.

Crie um objeto para ser a parede, o chame de obj_parede e o marque como sólido;
Crie um objeto para ser o player e o chame de obj_player;

Ponha esse código no obj_player, ele é um código bem simples meramente ilustrativo:
//Step

Código:

if place_snapped(32, 32){
   
    hspeed = 0;
    vspeed = 0;

    if (keyboard_check(vk_up) and place_free(x, y - 8)) {

        vspeed -= 8
    }

    else if (keyboard_check(vk_down) and place_free(x, y + 8)) {

        vspeed += 8
    }

    else if (keyboard_check(vk_right) and place_free(x + 8, y)) {

        hspeed += 8
    }

    else if (keyboard_check(vk_left) and place_free(x - 8, y)) {

        hspeed -= 8
    }
}

if collision_rectangle(x, y, x + 32, y + 32,obj_inimigo, 0, 1) {

    show_message("Você perdeu");
    game_end();
}

Crie um objeto para ser o inimigo e o chame de obj_inimigo.

Pronto, o cenário já está formado para programarmos nosso inimigo, e vamos começar a fazer isso agora:

Iniciar com movimento vertical
//Create

Código:

vspeed = -8; //inicia com movimento vertical

Inverter direção ao colidir com parede
//Step

Código:

if !place_free(x + hspeed, y + vspeed) { //se colidir com a parede no sentido do movimento...

    hspeed *= -1;                      //inverter o sinal das velocidades
    vspeed *= -1;
}

Restante do comportamento
//Step

Código:

//Se está na mesma linha ou mesma coluna que o player...
//Se não há uma parede entre o inimigo e o player...
//Mudar movimento para direção do player

if (((x == obj_player.x) or (y == obj_player.y)) and place_snapped(32, 32)){

    if !collision_line(x, y, obj_player.x, obj_player.y, obj_parede, 0, 0) {

        if (x == obj_player.x) {
       
            hspeed = 0;
            vspeed = (sign(obj_player.y - y)*8);
        }
        else if (y == obj_player.y) {
       
            hspeed = (sign(obj_player.x - x)*8);;
            vspeed = 0;
        }
    }
}

Use sprites 32 x 32 px para esse segundo experimento, monte uma room com locais onde o player possa se esconder do inimigo e faça o teste.

______________________________________________

Viu como é simples programar o comportamento de um inimigo? O segredo está em esmiuçar cada minimo detalhe que faz parte dos movimentos dele. Como você pode notar, tudo não passa de uma grande sequencia de condições que quando atendidas realizam algo.

Espero que vocês possam ter entendido. E qualquer duvida ou dica, postem aí!

Tchau
Creditos: Universo Maker