Física e IA para jogos

Conceitos Introdutórios de Física
e Inteligência Artificial para jogos
André Kishimoto (Glu Mobile)
Rafael Oliveira Martins (EA Mobile)

Antes de começar...
• O conteúdo desse mini-curso é uma pesquisa
dos autores e não tem ligação com as
empresas em que trabalham
• As opiniões apresentadas são pessoais e não
refletem a opinião, posição e/ou visão das
empresas EA Mobile e Glu Mobile

Agenda
• Introdução
• Tecnologia e demonstração
• Trigonometria
– Deslocando e rotacionando objetos
• Física
– Velocidade, aceleração e desaceleração
– Colisão radial
• Inteligência Artificial
– FSM (Máquina de estados)
– Percorrendo um caminho pré-definido
– Perseguindo e fugindo do jogador
• Referências

Introdução
• Criamos esse mini-curso assumindo que o público
já tenha familiaridade com programação
• Dada a carga horária do mini-curso, tivemos que
selecionar apenas alguns tópicos sobre Física e IA
– Há muito mais a ser estudado e implementado sobre
essas áreas, por isso listamos diversas referências no
último slide
• Embora importante, não nos atentamos à parte
visual pois o foco desse mini-curso é a parte
técnica

Tecnologia e demonstração
• Para demonstrar os assuntos do mini-curso na prática,
tivemos que adotar uma ferramenta, que no caso foi o
Adobe Flash (e AS3.0)
• No entanto, os conceitos podem ser aplicados em qualquer
outra ferramenta e linguagem de programação
– Anteriormente escrevemos o mesmo conteúdo em Java ME
(mobile) e C++ para Windows
• Optamos também por trabalhar em 2D ao invés de 3D, para
simplificar o exemplo (novamente, os conceitos também se
aplicam em 3D, dada as devidas modificações)
• Quanto ao exemplo, reunimos todo o conteúdo do mini-
curso em uma demo estilo shooter com vista top-down

Trigonometria
• Grande parte dos jogos possuem objetos que se
movimentam pela tela
• Quando os movimentos são horizontais e
verticais, não há grandes complicações em
programar a movimentação
– Basta alterar valores (x,y) de um objeto
• Mas e quando os objetos podem ser
rotacionados e devem seguir a direção para onde
estão “olhando”?
– É aqui que entra a trigonometria

Trigonometria
• Imaginem uma bala de canhão sendo atirada no
espaço. O canhão possui uma certa direção, que
é a rotação da sua base.
• Na imagem abaixo, digamos que o ponto p seja a
direção inicial do canhão
• Queremos mover a mira do canhão
para o ponto p’
• Reparem que há um círculo de raio h,
indicando que a mira pode ser rota-
cionada em 360 graus.

Trigonometria
• Notem também que há um triângulo
retângulo formado pelos pontos (0, 0), (xp’, yp’)
e (xp’, 0). A relação trigonométrica de um
triângulo retângulo é (pela figura):
– sin(ang) = a / h
– cos(ang) = o / h
– tan(ang) = o / a
– (a = cateto adjacente, o = cateto
oposto e h = hipotenusa)

Trigonometria
• Para resolver o problema da bala de canhão,
usamos os valores de sin(ang) e cos(ang), pois
através do seno e cosseno, conseguimos
encontrar qualquer ponto no círculo, dado um
determinado ângulo
• Calculando alguns ângulos:
– Ângulo (x, y) cos() sin()
• 0 ou 360 (1, 0) 1 0
• 90 (0, 1) 0 1
• 180 (-1, 0) -1 0
• 270 (0, -1) 0 -1

Trigonometria
• Reparem nas colunas (x,y), sin() e cos() do slide
anterior
• Essa é a relação que os valores seno e cosseno
possuem com a coordenada (x,y) de um ponto p:
– cos(ang) equivale à coordenada x de p
– sin(ang) equivale à coordenada y de p
• Podemos adicionar uma velocidade ao
deslocamento, multiplicando tanto cos() como
sin() por um valor de velocidade

Trigonometria
• No exemplo desse mini-curso, a aplicação do
que acabamos de ver pode ser conferido no
clique de mouse (tiro) e na movimentação do
NPC:
// Desloca NPC baseado na direcao para onde ele esta olhando
var angle:Number = Constants.DEG_TO_RAD * this.rotation;
var deltaX:Number = m_velocityX * Math.cos( angle );
var deltaY:Number = m_velocityY * Math.sin( angle );
this.x += deltaX;
this.y += deltaY;

Trigonometria
• Podemos realizar a operação contrária, isto é,
a partir de duas coordenadas (x,y), queremos
descobrir o ângulo de rotação de um objeto
• Para isso, calculamos o arco tangente de dy/dx
• atan2(y, x) é uma variação da função do arco
tangente, recebendo dois parâmetros e
considerando o sinal de dx e dy

Trigonometria
• O exemplo implementa a obtenção de um ângulo a partir
da posição (x,y) do cursor do mouse com a posição (x,y) do
player, para que o player seja rotacionado apontando
sempre para o cursor do mouse:
public function followMouseCursor()
{
var deltaX:Number = stage.mouseX - this.x;
var deltaY:Number = stage.mouseY - this.y;
var angle:Number = Math.atan2( deltaY, deltaX );
var rotation:Number = angle * Constants.RAD_TO_DEG;
this.rotation = rotation;
}

Física
• Vimos que para movimentar um objeto pela tela,
basta alterar sua posição (x,y), seguindo ou não a
orientação do objeto
• Durante a movimentação, os objetos possuem
uma determinada velocidade, que é a razão da
distância percorrida no espaço em uma
determinada faixa de tempo (v = ds/dt)
• Em Física, aprendemos que a velocidade é em
metros/segundo, mas no computador podemos
indicar a velocidade de um objeto por pixels/fps

Física
• Assim, no código que realiza o update do jogo a uma taxa
de N fps, podemos aplicar uma velocidade para deslocar o
objeto
– No Flash o update pode ser feito em resposta ao evento
ENTER_FRAME, e a taxa de fps é definida no projeto (.fla)
• A nova posição s do objeto, dada uma velocidade v e
tempo t é s(t) = s0 + (v * t)
• Traduzindo para o computador (AS3):
public function enterFrame()
{
// Aplica velocidade ao objeto
this.x = this.x + m_velocityX;
this.y = this.y + m_velocityY;
}

Física
• O código anterior aplica uma velocidade constante ao objeto. Para
alterar essa velocidade e assim aplicarmos uma aceleração ao
objeto, podemos usar a equação de aceleração (a = dv/dt)
• A nova velocidade v do objeto, dada uma aceleração a e tempo t é
v(t) = v0 + (a * t)
• Traduzindo para o computador (AS3):
{
// Aplica aceleração
m_velocityX = m_velocityX + m_accelerationX;
m_velocityY= m_velocityY + m_accelerationY;
// Aplica velocidade ao objeto
this.x = this.x + m_velocityX;
this.y = this.y + m_velocityY;
}

Física
• A desaceleração de um objeto pode ser vista como uma aceleração
negativa
• Dessa forma, basta aplicar uma força negativa à velocidade ou reduzir a
aceleração e velocidade uma determinada porcentagem a cada passar de
tempo
• No exemplo, quando o jogador não está pressionando teclas de
movimentação, reduzimos a aceleração e velocidade em 20%:
{
if( !m_isMoving )
{
m_accelerationX = m_accelerationX * Constants.FRICTION; // FRICTION = 0.8
m_accelerationY = m_accelerationY * Constants.FRICTION;
m_velocityX= m_velocityX * Constants.FRICTION;
m_velocityY= m_velocityY * Constants.FRICTION;
}
}

Física
• A colisão entre objetos nos jogos nada mais é que
um problema matemático: intersecções de
figuras geométricas que podem ser calculadas e
resolvidas através de algumas equações
• Existem diversas maneiras para detectar colisões,
como interseção de duas retas, reta com
retângulo, reta com círculo, intersecção de dois
retângulos (talvez o mais comum), dois círculos,
retângulo e círculo, polígonos, etc.
– A escolha do método de colisão depende da forma
dos objetos do jogo

Física
• Para o exemplo, escolhemos o método de colisão entre dois
círculos:
– Dado dois círculos nas coordenadas A(x1, y1) e B(x2, y2) de raio r1 e r2,
respectivamente, a intersecção entre eles ocorre quando a distância
entre seus centros é menor ou igual a soma de seus raios:
– (x2 – x1)2 + (y2 – y1)2 <= (r1 + r2)2
public function checkRadialCollision(objA:MovieClip, radiusA:Number, objB:MovieClip,
radiusB:Number):Boolean
{
var distX:Number = objB.x - objA.x;
var distY:Number = objB.y - objA.y;
var radius:Number = radiusA + radiusB;
return( distX * distX + distY * distY <= radius * radius );
}

Inteligência Artificial
• Geralmente trabalhamos com sequências de entradas,
ações e transições que definem a progressão de qualquer
tipo de jogo ou aplicativo.
• Para gerenciar essas transições usamos o conceito de FSM
(Finite State Machines), onde definimos quais estados
utilizaremos e como definimos a ordem em que eles
estarão ativos ou inativos.
• Um exemplo de aplicação de FSM em um jogo pode ser
dado pela transição: Tela do Título -> Menu -> Novo Jogo ->
Fim de Jogo -> Menu

• Uma questão comum no desenvolvimento de jogos é,
“Como posso estruturar meu jogo?”.
• Uma maneira eficaz e concreta para resolver isso seria
pensar no seguinte cenário:
1. O jogo é carregado e a tela inicial ou de título aparece.
2. O jogador aperta Start/Enter e a tela de título é removida, dando vez a tela do menu
principal.
3. O jogador escolhe Iniciar Jogo, a tela do menu é removida e um sub-menu aparece.
4. O sub-menu mostra uma mensagem de que o jogo é Demo, e o jogador pode comprar o
jogo ou jogar a versão limitada.
5. O jogador aceita a mensagem, o sub-menu é removido e a tela de carregar o jogo aparece.
6. Após o carregamento do jogo, a tela de carregar fica inativa e a tela de jogo é exibida.
7. Durante o jogo, o jogador pressiona o botão Start e a tela de pausa assume o controle.

• Em nosso jogo exemplo, utilizamos em dois momentos o
uso de FSM, o primeiro é: Tela de Jogo e Tela de Pausa.
• Podemos tornar o fluxo do jogo mais complexo, utilizando
uma estrutura maior, como citado anteriormente.

• O comportamento do NPC é o segundo
momento em que usamos o conceito de FSM.
NPC
Patrolling
Seeking
Evading
//Patrulhando
//Perseguindo
//Fugindo

• Uma técnica fundamental para qualquer jogo que queira
demonstrar sinais de uso de IA é a determinação de caminhos e
buscas pré-definidas.
• Uma vez que precisamos nos deslocar, desviar de obstáculos e
seguir rotas, a implementação dessa técnica é necessária.
• Existem diversas maneiras de implementarmos o uso de caminhos,
rotas e buscas. Isso depende do problema a ser resolvido e de
quantas entidades vamos associar ao jogo.
• Nos jogos onde os NPCs se deslocam, é necessário traçar um
caminho para que eles percorram, seja na busca do jogador, do
inimigo, de um ítem ou até mesmo para chegarem a uma outra
extremidade utilizando o menor caminho.

• No jogo exemplo, o NPC tem uma rota definida, enquanto
está no estado de Patrulha.
• A rota do NPC é pré-definida por pontos nas extremidades
da tela (x,y), que definem sua posição atual em um
movimento retangular.
px0,py0 px1,py1
px2,py2px3,py3
Início

• Neste caso, o melhor meio de definirmos os pontos do caminho é criando um
Array de coordenadas na tela.
private var m_points:Array = [ px0, py0, px1, py1, px2, py2, px3, py3 ];
- Onde px = coordenada X e py = coordenada Y na tela
• Como temos 4 (quatro) coordenadas x,y na tela, definimos um número
máximo de coordenadas a serem atingidas pelo NPC:
public static const MAX_POINTS_IN_PREDEFINED_PATH:int = 3; // 0 à 3 = 4 coordenadas
• A cada ponto do caminho pré-definido em que o NPC atinge, seu próximo
passo é olhar para o próximo ponto e caminhar até ele.
• Atingindo o próximo ponto, sua posição atual é incrementada e é verificado se
ele atingiu o número máximo de coordenadas. Caso a posição atual seja maior
que o número máximo de coordenadas, logo o NPC concluiu o fim de seu
destino e retorna a posição inicial.

• Traduzindo para o computador (AS3)
switch( m_state )
{
case Constants.STATE_PATROLLING:
{
// Caminha ate o proximo ponto do caminho pre-definido
lookAtPoint( m_points[m_currentPoint * 2], m_points[m_currentPoint * 2 + 1], false );
gotoPoint( m_points[m_currentPoint * 2], m_points[m_currentPoint * 2 + 1] );
// Se atingiu o ponto, passa para o proximo
if ( reached() )
{
m_currentPoint ++;
// Volta ao primeiro ponto do caminho caso tenha atingido o ultimo
if ( m_currentPoint > Constants.MAX_POINTS_IN_PREDEFINED_PATH )
{
m_currentPoint = 0;
}
}
}
//......
}

• A idéia de perseguir, fugir, ficar em alerta, entre outras
dentro do contexto de IA é feito através do uso de agentes.
• Os agentes são todos elementos que percebem o ambiente
que estão por meio de sensores e atuam por meio de
atuadores.
• Há muito o que estudar dentro dessa área, mas para nosso
mini curso, as técnicas de Perseguir e Fugir são bons
exemplos do uso de agentes.

• No jogo exemplo, o NPC inicia no estado de Patrolling
(Patrulha), enquanto o Player pode caminhar pela tela.
• Caso haja colisão entre os dois ( via colisão entre círculos,
explicado anteriormente ), o NPC começa a perseguir o
Player e entra no estado de Seeking ( Perseguindo ).
// Caso player colidiu com NPC, muda estado do NPC para seeking
if ( checkRadialCollision( m_player, Constants.COLLISION_RADIUS, m_enemy,
Constants.COLLISION_RADIUS ) && m_enemy.getState() != Constants.STATE_EVADING )
{
m_enemy.setState( Constants.STATE_SEEKING );
}

case Constants.STATE_SEEKING:
{
// Persegue o player
lookAtPoint( m_playerX, m_playerY, false );
gotoPoint( m_playerX, m_playerY );
}
• O NPC ficará no estado Perseguindo, até que o Player acerte o 3 ( três ) vezes.
// Verifica se tiro atingiu NPC
if ( checkRadialCollision( m_bullet, Constants.BULLET_RADIUS, m_enemy, Constants.BULLET_RADIUS ) )
{
m_enemyHits ++;
if ( m_enemyHits > 2 )
{
m_enemyHits = 0;
m_enemy.setState( Constants.STATE_EVADING );
}
m_bIsShooting = false;
m_bullet.x = -100;
m_bullet.y = -100;
}

• Depois de atingido, o NPC sai do estado de Perseguindo e entra no
estado de Evading ( Fugindo ).
• Enquanto o NPC está a uma certa distância do Player, ele continua
fugindo. No nosso exemplo, enquanto a distância for menor que
200 pixels, ele permance no estado de Evading.
px0,py0 px1,py1
px2,py2px3,py3
Início
Player
NPC: Evading
< 200px

• Quando a distância entre NPC e Player atingir mais de 200px, o NPC caminha até o
ponto pré-definido mais próximo e retorna ao estado de Patrolling ( Patrulha ).
• Nesse caso, m_currentPoint guarda a última posição do estado de Patrulha do NPC.
case Constants.STATE_EVADING:
{
// Calcula distancia entre player e NPC, se for menor que 200 pixels, continua fugindo
var distance:Number = Math.sqrt( ( m_playerX - this.x ) * ( m_playerX - this.x ) + ( m_playerY - this.y ) * ( m_playerY - this.y ) );
if ( distance < 200 )
{
lookAtPoint( m_playerX, m_playerY, true );
gotoPoint( m_playerX, m_playerY );
}
// Caso contrario, vai para o proximo ponto do caminha prdefinido e ao atingir o ponto,
// muda estado para patrulhando novamente
else
{
lookAtPoint( m_points[m_currentPoint * 2], m_points[m_currentPoint * 2 + 1], false );
gotoPoint( m_points[m_currentPoint * 2], m_points[m_currentPoint * 2 + 1] );
if ( reached() )
{
setState( Constants.STATE_PATROLLING );
}
}
}
//…..

• Como vimos, o NPC utiliza de uma forma básica o conceito
de FSM juntamente comas técnicas de IA de acordo com as
regras utilizadas.
• As técnicas utilizadas nessa aula podem ser aplicadas à
qualquer tipo de linguagem ou plataforma de
desenvolvimento, dadas modificações de sintaxe, regras e
performance.

Referências
• Artificial Intelligence for Games
– Ian Millington. Morgan Kaufmann, 2006
• Programming Game AI by Example
– Mat Buckland. Wordware Publishing, Inc., 2004
• Real-Time Collision Detection
– Christer Ericson. Morgan Kaufmann, 2005
• Real-Time Rendering, 3rd Edition
– Tomas Akenine-Möller, Eric Haines, Naty Hoffman.
AK Peters, 2008

Referências
• Inteligência Artificial
- Stuart Russell. Peter Norvig.
Elsevier, 2004
• Microsoft XNA Game Studio 3.0 Unleashed
- Chad Carter. Sams, 2009

Contato (editado)
• André Kishimoto
andre@kishimoto.com.br
• Rafael Oliveira Martins

Física e IA para jogos

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Física e IA para jogos

Semelhante a Física e IA para jogos (20)

Física e IA para jogos