Projeto de jogos RAD: Inteligência Artificial

Parte 1

Augusto Bülow

Unity3D : IA

IA: Simular comportamento inteligente em elementos autômatos no jogo

Planejamento básico: • O que o “robô” deve fazer?• Traduzir em estados– Separar ações individuais / diferentes– Criar mapa de estados

Unity3D : IA

• Elementos com IA = máquina de estados

Estados:Partes do comportamento

Diferentes ações

Tratados com códigos (partes) separados

Controlar estados por variável *

Criar regras para mudança de estados

Unity3D : IA

Resumindo:

1o passo: planejar o comportamento desejado

2o passo: identificar estados – separar ações diferentes (partes do comportamento)

3o passo: identificar mudança de estados – o que faz o robô mudar de um estado a outro

Programar regras – testar - adaptar

Unity3D : IA

Patrulha

Vê player

Foge

AtacaMorre

Inicializa

Visão Geral Estados

Unity3D : IA

Ataca Decide ataque

Ataque1

Move Lateral

Ataque2

Abaixa

Atira

Explodindo Bolhas:Detalhando

Unity3D : IA

Patrulha

Vê player

Distancia < 300

Distancia > 500

Decide ataque

Ataque1 Ataque2

Random:30%Random:

70%

Detalhando: Regras para mudança de estados

Unity3D : IA

• Conhecendo-se os estados e planejando-se as regras para mudanças de estado inicia-se a programação

- Traduzir o plano para código

- Estados = controle por variávelvar estado = 0;

....

if (estado == 1) {

.....

}

Unity3D : IA- Criar Cubo “inimigo”

- Criar Script Inimigo1.js

- Inimigo precisa cuidar de suas colisões, chão / cena

- Definir e adicionar Collider:

- RigidBody ou CharacterController

- Tipo collider = códigos específicos de movimento

- Nosso exemplo : CharacterController*

Unity3D : IA

PatrulhaPatrulha

Ataque1

Vai Ponto1 Observa Vai

Ponto2

Explodindo Bolhas:Detalhando

Observa

Unity3D : IA- Patrulhar detalhado = 4 estados

- Estados definíveis: 10, 11, 12, 13 = Patrulha

- Criar /Planejar regras de mudança de estados

- O que leva de um estado a outro?

- EX:

- Ir ponto1: checar distancia para o ponto

- Espera / Observa: timer simples (tempo)

- Inicia Ataque: player próximo inimigo (dist. min)

Unity3D : IA- Plano determinado = implementar código

- Variáveis iniciais identificadas:

var estado = 10;

var distancia_ok = 1.0;

var distancia_atual = 0.0;

var ponto1 : Vector3;

var ponto2 : Vector3;

var velocidade : Vector3;

var tempo = 0.0;

Unity3D : IA- Estado 10 : Ir ponto 1, perceber a chegada (distancia)

if (estado == 10) {

// virar / apontar para o ponto

transform.LookAt(ponto1);

transform.rotation.x = 0;

transform.rotation.z = 0;

// mover / andar = velocidade frente Z

velocidade.x = 0;

velocidade.y = 0;

velocidade.z = 0.1;

//Mudança de estado = distancia / chegou no ponto

distancia_atual = Vector3.Distance(transform.position, ponto1);

if (distancia_atual <= distancia_ok) {

estado = 11;

}

}

Unity3D : IA- Centralizamos código de movimento: controle apenas por

velocidade nos estados

//transforma velocidade para direção atual

velocidade = transform.TransformDirection(velocidade);

//Movimento unificado : controla velocidade nos estados

pointer = GetComponent(CharacterController);

pointer.Move(velocidade);

Unity3D : IA- Estado 11: aguarda tempo / observa, parado

if (estado == 11) {

// parar = sem velocidade

velocidade.x = 0;

velocidade.y = 0;

velocidade.z = 0;

// Timer básico

tempo += Time.deltaTime;

if (tempo >= 1) {

estado = 12;

}

}

Unity3D : IA- Start: inicialização básica, estado, pontos - destinos

function Start() {

//estado inicial

estado = 10;

//ponto 1: ex. posicao atual + variação

ponto1 = transform.position;

ponto1.z += 20;

// ponto2:

ponto2 = transform.position;

ponto2.z -= 10;

}

- Criar estados 12 e 13 = Finalizar Patrulha Básica

Unity3D : IA- Ataque básico: percebe player perto = distância

- (modo simplório)

- Entra em estado de ataque

- Regras adicionais atacando

- Persegue player (anda na sua direção)

- Distância mínima = tira saúde ( faz ataque)

- Distância máxima = fugiu, volta a patrulha

Unity3D : IA- Implementando ataque:

var distancia_player = 0.0;

var distancia_ataca = 15;

var distancia_hit = 2;

var distancia_fugiu = 30; ....

//Encontra player - multi uso

player = GameObject.Find("Player");

//Ativa ATAQUE AUTO - POR DISTANCIA

if (estado >= 10 && estado <= 13) {

distancia_player = Vector3.Distance(transform.position, player.transform.position);

if (distancia_player <= distancia_ataca) {

estado = 20;

}

}

Unity3D : IA//20. ATAQUE

if (estado == 20) {

// virar / apontar para o player

transform.LookAt(player.transform.position);

transform.rotation.x = 0;

transform.rotation.z = 0;

// mover / andar = velocidade frente Z

velocidade.x = 0;

velocidade.y = 0;

velocidade.z = 0.1;

}

Unity3D : IA- Implementando regras adicionais do estado//20. ATAQUE – PERSEGUE PLAYER

if (estado == 20) {

....

distancia_player = Vector3.Distance(transform.position,player.transform.position);

//Distancia fugiu = volta a patrulha

if (distancia_player >= distancia_fugiu) {

estado = 10;

}

}

Unity3D : IA- Implementando regras adicionais (2) do estado//20. ATAQUE – PERSEGUE PLAYER

if (estado == 20) {

....

distancia_player = Vector3.Distance(transform.position,player.transform.position);

//Distancia hit = estado ataque real – tira energia, etc

if (distancia_player <= distancia_hit) {

estado = 21;

}

}

Unity3D : IA//21. ATAQUE - REAL

if (estado == 21) {

// para de andar

velocidade = Vector3.zero;

//anima - (simula anima - FAZ GIRO BASICO)

aux_gira += 1 * Time.deltaTime;

transform.Rotate(Vector3(0, 3, 0));

if (aux_gira >= 1) { estado = 10; } // volta patulha tempo

//Criando efeito no player - acessa script dele, muda vars

//empurra trás, cima - única vez, uso var para controle

if (ataque_unico == 0) {

player.GetComponent("Player-anima").forca_move.y = 0.3;

player.GetComponent("Player-anima").forca_move.z = -2;

ataque_unico =1;

}

}