Departamento de Computao

Trabalho de Concluso de Curso

EDUARDO FUJITA





ALGORITMOS DE IA PARA JOGOS










Londrina
2005


EDUARDO FUJITA





ALGORITMOS DE IA PARA JOGOS




Trabalho apresentado ao Curso de
Cincia da Computao, da Universidade
Estadual de Londrina, como requisito
obteno do ttulo de Bacharel.

Orientador: Prof. Dr. Pedro Paulo da Silva
Ayrosa





Londrina
2005



EDUARDO FUJITA


ALGORITMOS DE IA PARA JOGOS





COMISSO EXAMINADORA



______________________________________
Prof. Dr. Pedro Paulo da Silva Ayrosa
Universidade Estadual de Londrina



______________________________________
Prof. Ms. Liana Dessandre D. Garanhani
Universidade Estadual de Londrina



______________________________________
Prof. Ms. Rafael Robson Negro
Universidade Estadual de Londrina












Londrina, 1 de dezembro de 2005



























"If 0od does nof exisf in our worId,
fhen I wiII creofe 0od wifh my own hondsl".
IreIion - Xenogeors


AGRADECIMENTOS
Ao Prof. Dr. Pedro Paulo da Silva Ayrosa, por sua maneira descontrada de ministrar
as aulas e sua orientao na elaborao do presente trabalho.
minha famlia.
Aos amigos, professores e funcionrios do departamento de computao da UEL.



FUJITA, Eduardo. Algoritmos de IA para jogos. 2005. Monografia (Graduao em
Cincia da Computao) Universidade Estadual de Londrina.

RESUMO
Este trabalho aborda as principais tcnicas da Inteligncia Artificial (IA) aplicadas na
rea de desenvolvimento de jogos, como mquinas de estado finito, scripts,
algoritmos genticos e redes neurais. Apresenta de maneira sucinta a histria da IA
bem como as principais caractersticas do desenvolvimento de jogos. Demonstra a
importncia da IA como fator diferencial na criao de jogos mais atraentes ao
consumidor. Por fim, faz uma anlise do estado da arte nas pesquisas nesta rea e
conclui que a tendncia a criao de jogos que utilizem tcnicas no-
determinsticas, aprendendo com seus erros e adaptando-se ao modo de jogar de
seu adversrio humano.

Palavras-chave: Inteligncia Artificial; jogos.


FUJITA, Eduardo. AI algorithms for games. 2005. Monograph (Graduation in
Computer Science) Universidade Estadual de Londrina.


ABSTRACT
This work approaches the main Artificial Intelligence (AI) techniques applied in the
area of game development, like finite state machines, scripts, genetic algorithms and
neural networks. Presents in a succinct way the history of AI as well as the main
characteristics of game development. Demonstrates the importance of AI as a
differential factor in the creation of more attractive games for the final consumer.
Ultimately, makes an analysis of the state-of-the-art in the researches in this area
and concludes that the tendency is the creation of games using non-deterministic
techniques, learning with its own mistakes and adapting to the playing manner of its
human opponent.

Key-words: Artificial Intelligence; games.


LISTA DE TABELAS
Tabela 1 tabela de transio de dados ..................................................................40
Tabela 2 exemplo de codificao de um cromossomo...........................................55
Tabela 3 exemplo de crossover .............................................................................56



LISTA DE EQUAES
Equao 1: transformando coordenadas globais em locais......................................25
Equao 2: clculo da velocidade e posio relativa ................................................26
Equao 3: clculo do tempo de abordatem (T
A
) ......................................................26
Equao 4: posio da presa no tempo (T
A
) futuro...................................................27
Equao 5: funo de associatividade (frmula).......................................................33
Equao 6: funo de avaliao do A*......................................................................47


LISTA DE ILUSTRAES
Figura 1 - uma melhora alcanada utilizando a perseguio com linha de viso
(line-of-sight chasing) (BOURG e SEEMAN, 2004) ...........................................21
Figura 2 Perseguio simples (esq) e com linha de viso (dir) ..............................22
Figura 3 - o algoritmo de Bresenham (esq.) nunca desenha dois pixels adjacentes no
menor eixo da reta .............................................................................................23
Figura 4 - sistema de coordenadas em linha de viso para ambientes contnuos ....25
Figura 5 exemplo de funo de associatividade (grfico) ......................................33
Figura 6 mltiplas funes de associatividade .......................................................34
Figura 7 mquina de estados finitos (s: estados; t:transies)..............................39
Figura 8 heurstica para o jogo da velha ..............................................................42
Figura 9 - problema do ciclo no desvio de obstculos...............................................45
Figura 10 - problema do ciclo resolvido.....................................................................45
Figura 11 - Estrutura bsica de um neurnio ............................................................49
Figura 12 - neurnio artificial .....................................................................................50
Figura 13 - Rede feedforward de trs camadas ........................................................51
Figura 14 - rede feedforward tripla camada controlando uma unidade .....................52



LISTA DE CDIGOS
Cdigo 1: algoritmo bsico de perseguio ..............................................................20
Cdigo 2: algoritmo bsico de evao ......................................................................21
Cdigo 3: algoritmo de linha de viso para ambientes contnuos .............................24
Cdigo 4: algoritmo de interceptao........................................................................27
Cdigo 5: exemplo de arquivo script .........................................................................37
Cdigo 6: exemplo de script controlando a lgica do computador ............................37
Cdigo 7: algoritmo de pathfinding em pseudo-cdigo .............................................43
Cdigo 8: algoritmo gentico em pseudo-cdigo ......................................................56


SUMRIO
1 INTRODUO.....................................................................................................1
2 INTELIGNCIA ARTIFICIAL................................................................................3
2.1 Desenvolvimento da Teoria de IA........................................................................3
2.2 Nascimento da IA.................................................................................................5
2.3 IA Atualmente.......................................................................................................7
2.4 Definio ..............................................................................................................8
2.4.1 Sistemas que agem como humanos.............................................................9
2.4.2 Sistemas que pensam como humanos .......................................................10
2.4.3 Sistemas que agem racionalmente.............................................................11
2.4.4 Sistemas que pensam racionalmente .........................................................11
2.5 IA nos Jogos ......................................................................................................12
3 CARACTERSTICAS DO DESENVOLVIMENTO DE JOGOS...........................15
3.1 Categorias..........................................................................................................15
3.2 Pblico Alvo .......................................................................................................17
3.3 Plataforma..........................................................................................................18
3.4 rea de Atuao ................................................................................................18
4 ALGORITMOS DE IA PARA JOGOS.................................................................19
4.1 Perseguio e Fuga...........................................................................................20
4.1.1 Algoritmo bsico de perseguio: ...............................................................20
4.1.2 Exemplo de um algoritmo bsico de evaso:..............................................21
4.1.3 Perseguio com linha de viso .................................................................22
4.1.4 Linha de viso para ambientes contnuos...................................................24
4.1.5 Interceptao ..............................................................................................26
4.2 Sistemas Baseados em Regras.........................................................................28


4.2.1 Elementos de um sistema baseado em regras ...........................................28
4.2.2 Forward chaining.........................................................................................29
4.2.3 Backward chaining......................................................................................30
4.2.4 Aplicao em jogos.....................................................................................30
4.3 Lgica Nebulosa (fuzzy).....................................................................................31
4.3.1 Lgica nebulosa nos jogos..........................................................................31
4.3.2 Caractersticas ............................................................................................32
4.3.3 Fuzzificao................................................................................................32
4.3.4 Funes de associatividade........................................................................33
4.3.5 Sada fuzzy .................................................................................................34
4.3.6 Desfuzzificao...........................................................................................35
4.4 Scripts ................................................................................................................36
4.4.1 Construo..................................................................................................37
4.5 Mquinas de Estado Finito.................................................................................38
4.5.1 Caractersticas ............................................................................................39
4.5.2 Implementao ...........................................................................................39
4.5.3 Mquinas de estado finito no-determinsticas ...........................................40
4.6 Busca Heurstica................................................................................................41
4.7 Pathfinding .........................................................................................................42
4.7.1 Estratgias para desvio de obstculos........................................................43
4.7.2 Algoritmo A* ................................................................................................46
4.8 Redes Neurais ...................................................................................................48
4.8.1 O neurnio artificial .....................................................................................49
4.8.2 Redes neurais em jogos .............................................................................51
4.8.3 Mapeando o problema ................................................................................52
4.9 Algoritmos Genticos .........................................................................................53


4.9.1 Algoritmos genticos em jogos ...................................................................54
4.10 Flocking.............................................................................................................57
5 ALGORITMOS DE IA PARA JOGOS ESTADO DA ARTE..............................59
6 CONCLUSO ....................................................................................................62
REFERNCIAS BIBLIOGRFICAS..........................................................................63
BIBLIOGRAFIA CONSULTADA................................................................................64
ANEXOS ...................................................................................................................65
1
1 INTRODUO
A rea de jogos por computador uma das reas que mais
amadureceu nas ltimas dcadas; tanto em popularidade quanto em abrangncia
de reas. O seu desenvolvimento hoje requer investimentos milionrios em uma
grande equipe de programadores, artistas, msicos, escritores e tambm em
Inteligncia Artificial (IA).
Quando surgiram os primeiros consoles
1
populares, por volta das
dcadas de 60 e 70, o poder computacional oferecido pelos mesmos era bastante
escasso, portanto existia pouco espao para a implementao de algoritmos de IA.
Essa limitao perdurou at meados da dcada de 90, quando os computadores e
consoles avanaram muito em tecnologia, e assim os jogadores passaram a exigir
dos jogos um nvel de dificuldade compatvel com a de um ser humano, pois muitos
se queixavam de um alto grau de previsibilidade que os antigos jogos possuam.
Assim, o estudo da IA aplicada aos jogos foi ganhando apoio no
mundo acadmico, pois alm de ser uma rea nova e interessante do ponto de vista
mercadolgico, ela tem se mostrado til para a implementao de teorias da IA.
O prximo captulo far um breve resumo da histria da IA, desde os
primrdios at os dias atuais.
No terceiro captulo, so apontados os principais estilos de jogos, bem
como as caractersticas acerca do desenvolvimento dos mesmos.
O quarto captulo engloba o tema principal deste trabalho,
apresentando as principais tcnicas da IA aplicadas aos jogos, bem como exemplos
de tais aplicaes.
_____________
1
Este se difere de um computador pois seu hardware dedicado exclusivamente para a execuo de
jogos. Neste trabalho no h distino entre jogos para computador e jogos para consoles.
2
J no quinto captulo, feito um estudo do estado da arte da IA em
jogos, mostrando quais as reas mais promissoras para pesquisas futuras.
Finalmente, no sexto captulo, feita a concluso deste trabalho,
enfatizando as idias principais apresentadas no mesmo.


3
2 INTELIGNCIA ARTIFICIAL
2.1 Desenvolvimento da Teoria de IA
Muitos autores, tais como RUSSEL (2004), consideram o filsofo
grego Aristteles (384-322 A.C) como um dos principais precursores dos estudos de
IA. Segundo ele, o estudo sobre o pensamento era a base para todo o
conhecimento. Em uma de suas obras, Aristteles introduziu o conceito de
silogismo, que provia argumentos para provar a veracidade de certas sentenas a
partir de outras que so sabidamente verdadeiras. Um famoso exemplo de um
silogismo : Scrates homem; todos os homens so mortais; logo, Scrates
mortal.
Em sua obra Lgica, Aristteles desenvolveu um dos conceitos
fundamentais da IA e da Cincia Cognitiva. Segundo ele, a lgica um instrumento,
e o estudo do pensamento o alicerce para o conhecimento. Foi a partir desses
estudos da lgica, que bem mais tarde (por volta do sc.XX) foi concebida a Prova
Automtica de Teoremas.
Com a entrada do Renascimento, o homem percebeu certa distino
entre a mente e a matria, ou seja, entre aquilo que vemos e aquilo que realmente
existe:
Pela primeira vez, provavelmente, as nossas idias acerca do
mundo foram vistas como fundamentalmente distintas de sua
aparncia. (LUGER, 2004).
Esta separao entre mente e realidade foi de fundamental
importncia no entendimento do nosso pensamento, tendo sido esta idia reforada
por Ren Descartes (1596-1650), que discutiu as diferenas entre a mente e a
matria. Desta maneira, percebeu-se que os processos mentais vivem em um
mundo parte, tendo suas prprias leis.
4
Mais tarde, observou-se a necessidade de reagrupar os processos
fsicos com os mentais, visto que somos um sistema composto por estas duas
entidades. Assim, concluiu-se que tanto os processos mentais quanto os fsicos
podem ser caracterizados a partir da matemtica formal.
Tendo-se chegado concluso de que o pensamento uma forma de
computao, surgiu a necessidade de formaliz-lo. Tal formalizao veio com
Leibniz, que introduziu o primeiro sistema de lgica formal, e Euler, com a teoria dos
grafos; esta, de grande utilidade neste estudo: com os ns dos grafos, possvel
representar estados de um agente em determinado momento do jogo. Os arcos
representam eventos, que podem perpetuar a mudana de estado (n) e,
consequentemente, a mudana de comportamento do agente.
N sculo XIX, Charles Babbage e Ada Byron trabalharam no estudo
de mquinas mecnicas programveis para o clculo de valores de funes
polinomiais. Embora tal mquina no tenha sido construda com sucesso, seus
estudos contriburam muito com a Cincia da Computao, pois inclua conceitos
como a programabilidade, memria e abstrao de dados. Ada chegou at mesmo
a construir programas para estas mquinas, o que a torna talvez a primeira
programadora da histria.
Tambm no sculo XIX, o matemtico George Boole formalizou as leis
da lgica, desenvolvendo a lgebra Booleana, que a base de toda a Cincia da
Computao at os dias de hoje. Boole demonstrou que, com apenas os valores
booleanos 0 e 1 sera possvel captar todo o poderio da lgica.
J no inco do sculo XX, teve o incio da histria moderna da IA.
Alfred North Whitehead e Bertrand Russel, no Principia Mathematica, publicado em
1910-1913 tentaram derivar todas as verdades matemticas a partir de um conjunto
bem definido de axiomas e regras de inferncia para a lgica simblica, lidando com
a matemtica de uma maneira estritamente formal.
5
2.2 Nascimento da IA
Embora os avanos cientficos citados anteriormente tenham formado
a base para o estudo da IA moderna, somente na metade do sculo XX, com o
surgimento dos computadores que a IA se tornou vivel do ponto de vista
cientfico. Graas sua memria e velocidade de processamento, tornou-se muito
mais prtico a implementao de grafos, resoluo de sistemas de raciocnio formal
e heursticas, bem como fazer testes acerca dos mesmos. Alan Turing (1950) foi um
dos primeiros a tratar da inteligncia de mquina em relao ao computador digital
moderno. Ele props um teste emprico para verificar a qualidade da inteligncia de
mquina em relao ao desempenho humano. Apesar de algumas crticas, o teste
tem sobrevivido at os dias atuais.
Baseado na anlise da lgica proposicional de Russel, no
conhecimento fisiolgico e funcional dos neurnios no crebro, Warren McCulloch e
Walter Pitts proporam em 1943 um modelo de neurnios artificiais no qual cada
neurnio poderia estar em um estado ligado ou desligado. Quando um nmero
adequado de neurnios vizinhos estimulasse um certo neurnio, este podera
mudar do estado desligado para ligado, sendo que o estado de um neurnio
representa a proposio do qual ele resultado. Donald Hebb (1949) demonstrou
como a modificao dos pesos entre as conexes poderia acrescentar a
aprendizagem ao sistema. Em 1951 foi construdo o primeiro computador baseado
em redes neurais pelos estudantes Marvin Misky e Dean Edmonds ambos
graduados no curso de matemtica de Princeton. O computador simulava uma rede
de 40 neurnios.
Em 1956, John McCarthy convidou muitos pesquisadores renomeados
como o prprio Misky, alm de outros como Claude Shannon e Nathaniel Rochester
cujo interesse se baseava em tpicos avanados como teoria da computabilidade,
redes neurais, bem como o estudo da inteligncia. O principal objeto de estudo era
to novo que foi preciso designar a ele um novo nome: Inteligncia Artificial (IA).
6
O evento teve durao de dois meses e conhecido como A conferncia de IA de
vero (Summer AI Conference).
A conferncia teve grande repercusso e construiu a base para uma
pesquisa ambiciosa envolvendo diversas reas como a engenharia, matemtica,
cincia da computao, psicologia, entre outras. Muitos participantes se
convenceram de que com o avano acentuado da velocidade de processamento
conseguida atravs do hardware a cada ano, a possibilidade de se conceber
mquinas com capacidade intelectual humana deixaria de ser uma questo de
como e sim quando isto ocorreria. Embora cada um dos tpicos envolvidos
possussem objetivos similares, foi necessrio separar a IA como um ramo de
pesquisa completamente diferente, pois somente a IA abraou a idia de reproduzir
artificialmente habilidades humanas como o aprendizado e uso da linguagem.
O perodo que se sucedeu a esta conferncia foi um perodo de
grande euforia para a pesquisa em IA, pois at ento, os computadores eram vistos
apenas como simples mquinas aritmticas e nada mais. Uma criao importante
no perodo foi o GPS (General Problem Solver), que foi projetado para resolver
problemas como um ser humano o fara. Isto faz com que este tenha sido
provavelmente um dos primeiros exemplos da abordagem pensando como um
humano, que ser descrita um pouco mais adiante.
Uma das primeiras contribuies da IA na rea de jogos se deu por
volta de 1952, quando Arthur Samuel escreveu um programa que jogava damas.
Tal programa aprendeu a jogar to bem que chegou ao ponto de derrotar seu
prprio criador; provando que era possvel construir um programa que fosse alm
do que fora lhe ensinado.
Em 1958, John McCarthy contribuiu mais uma vez de maneira
histrica para a IA. Aps mudar-se de Dartmouth para o MIT, McCarthy concebeu
uma linguagem de alto nvel denominada Lisp, que mais tarde se tornara a
linguagem de IA predominante. Ainda no mesmo ano, McCarthy publicou um artigo
que descrevia o que pode ser considerado o primeiro sistema completo de IA.
Segundo McCarthy, o programa utilizaria uma base de conhecimentos na resoluo
7
de problemas. O diferencial deste em relao ao que havia sido pesquisado at
ento, que foi introduzido o conceito de senso comum, ou seja, um
conhecimento generalizado sobre o mundo. O programa, denominado Advice Taker
seria capaz, por exemplo, de exibir um plano para dirigir-se at o aeroporto, atravs
de simples axiomas. O programa tambm seria capaz de adquirir competncias em
novas reas, sem a necessidade de ser reprogramado; sendo portanto, capaz de
adquirir aprendizagem.
2.3 IA Atualmente
O desenvolvimento da Inteligncia Artificial foi to grande que seu
potencial de aplicao se tornou bastante abrangente. Algumas reas de aplicao
incluem:
planejamento e agendamento autnomo: usado pela NASA
para o controle de agentes remotos (robs enviados em
misses interplanetrias);
entretenimento: na forma de jogos eletrnicos ou no teste
cientfico do poder computacional da IA em comparao com o
de um ser humano, como foi feito pela IBM ao lanar o
programa jogador de xadrez Deep Blue;
medicina: atravs de sistemas especialistas possvel fazer
diagnsticos cuja qualidade fica prxima de um especialista
na rea.
robtica: sempre foi de interesse do homem desenvolver
mquinas sua semelhana. Atualmente elas no chegaram
neste nvel ainda, mas j executam tarefas simples como
varrer um casa e desviar-se de obstculos;
compreenso da linguagem: ainda no foi construdo um
8
programa capaz de compreender perfeitamente a linguagem
humana, devido a sua ambiguidade e contextualidade, mas
existem programas que traduzem com certa fidelidade alguns
textos de uma lngua para outra.
2.4 Definio
Computadores conseguem fazer clculos a velocidades infinitamente
maiores que a de um ser humano, e devido a sua grande capacidade de
armazenamento, essas mquinas podem ser muito mais inteligentes que qualquer
humano em certas tarefas como jogar xadrez ou calcular rotas atravs de um grafo
de distncias.
Todavia, no podemos dizer que tais sistemas possam ser
inteligentes, e sim inteligentes at certo ponto, pelo fato de os mesmos utilizarem
certos mecanismos intelectuais em detrimento de outros. Em um jogo de xadrez,
por exemplo, um computador analisa milhes de possveis caminhos de um grafo
de jogadas factveis, enquanto que um homem analisaria cerca de duas ou trs
delas em um mesmo intervalo de tempo. A razo pela qual um homem consegue
realizar uma mesma tarefa que a mquina mas com uma quantidade to pequena
de computao reside na capacidade de entendimento do problema que os seres
humanos possuem (McCarthy, 2004). Se algum dia for possvel desenvolver uma
mquina capaz de jogar xadrez analisando o tabuleiro da mesma forma como um
ser humano o faz, seria possvel desenvolver um programa to inteligente quanto o
Deep Blue, que derrotou o campeo Garry Kasparov em 1997, mas com um poder
computacional disponvel dcadas atrs.
Alguns autores consideram que o grau de inteligncia est fortemente
ligado complexidade do meio vivido pelo ser, e quanto mais complexo o
ambiente, mais inteligente sero os indivduos que vivem nele, pois estes devero
sobreviver em um ambiente em constante evoluo. Segundo estes autores,
inteligncia saber sobreviver. Esta viso difundida na abordagem dos agentes,
que ser vista mais adiante.
9
Muitos entram em contradio ao encontrar uma definiao do que
realmente a inteligncia. Segundo Russel (2004), existem dois ramos de
pensamento em relao ao significado de IA: o primeiro mede a inteligncia artificial
em termos de fidelidade ao desempenho humano, e a segunda, em termos de um
conceito ideal de inteligncia, denominado racionalidade. Um sistema dito racional
quando ele age de forma correta, segundo sua base de dados. Ainda segundo o
autor, para cada ramo, existem duas maneiras de se medir a inteligncia do
sistema, que analisar se ele age ou pensa humanamente, somando se a um
total de quatro abordagens, que sero discutidas a seguir. Devemos notar que
nenhuma das abordagens escapa da comparao entre a mquina e um ser
humano, pois a inteligncia humana sempre foi considerada o modelo ideal de
inteligncia.
2.4.1 Sistemas que agem como humanos
Como a maioria das definies sobre o que ou quais os requisitos
necessrios para se ter um ser inteligente recaem na subjetiva definio da prpria
inteligncia, Alan Turing (1950), tambm conhecido como o pai da computao por
suas contribuies teoria da computabilidade, props um teste emprico para
avaliar a inteligncia de um agente computacional. O teste consiste em colocar uma
mquina e um humano em salas separadas entre si, alm de um interrogador,
tambm humano, mas que no tem nenhum contato fsico ou visual com os dois
participantes (homem e mquina).
O interrogador no sabe qual dos participantes humano nem
tampouco qual deles a mquina e seu objetivo distinguir quem humano e
quem a mquina utilizando-se apenas de um dispositivo que utiliza a escrita como
forma de comunicao, enviando perguntas e recebendo respostas dos
participantes. O uso deste terminal muito importante para o teste, j que elimina
quaisquer diferenas fsicas entre humano e mquina, como habilidades mecnicas
ou uso da voz, embora esses traos possam ser considerados caractersticas de
seres inteligentes. A mquina aprovada no teste, ou seja, dotada de inteligncia
caso o interrogador, aps fazer determinadas perguntas, no conseguir distinguir o
10
humano da mquina.
Um computador capaz de passar no Teste de Turing, possuiria as
seguintes caractersticas:
processamento de linguagem natural: para que seja capaz
de comunicar com o interrogador. A compreenso da fala
humana vai muito alm de procurar o significado das palavras
em um dicionrio, recaindo na soluo de ambigidades da fala
e na anlise de todo o contexto do discurso;
representao de conhecimento: para armazenar
informaes recebidas necessrio desenvolver uma forma de
abstrao e armazenamento do conhecimento;
raciocnio automtico: usa sua base de dados para fazer
inferncias e chegar novas concluses;
aprendizado de mquina: um sistema computacional,
diferentemente de um ser humano, ir efetuar toda a
computao feita na resoluo de um problema, no importa
quantas vezes este mesmo problema lhe foi apresentado. Para
faz-lo adaptar-se novas situaes, alm de detectar e
transceder padres necessrio embutir alguma forma de
aprendizado nesses sistemas.
2.4.2 Sistemas que pensam como humanos
O homem s conseguiu criar o avio depois que parou de tentar criar
mquinas que imitam o vo dos pssaros e passou a focar nos estudos de
aerodinmica. dentro desta filosofica que se baseia a Cincia Cognitiva, uma rea
interdisciplinar que une IA com a psicologia. Segundo esta, somente tendo
conhecimento suficiente sobre nossas mentes, se torna possvel implement-las em
um programa de computador.
11
2.4.3 Sistemas que agem racionalmente
[..]definimos um agente como um elemento de uma sociedade que
pode perceber aspectos (freqentemente limitados) de seu ambiente
e afet-lo, quer diretamente ou atravs da cooperao com outros
agentes. (LUGER, 2004).
Agente vem do Latim agere, que significa fazer, e simplesmente
algo que age. Eles diferem de outros programas pelo fato de serem autnomos
(completa ou parcialmente), sendo que cada agente contribui com a soluo geral
do problema, podendo inclusive interagir com outros agentes.
Este tipo de abordagem visualiza a inteligncia como parte da cultura
de uma sociedade, e que as interaes entre seus agentes produz inteligncia.
Para que essas interaes sejam possveis, cada agente deve possuir uma
habilidade sensorial (sendo apto a perceber o que est sua volta), ser capaz de se
adaptar a mudanas, e, principalmente, ser orientado a objetivos. Mesmo que um
agente no saiba qual a sua verdadeira funo no sistema como um todo, o
conjunto de solues (aes) viabilizadas por cada um dos agentes produz um
resultado global.

2.4.4 Sistemas que pensam racionalmente
Estes sistemas so fortemente baseados nos estudos de lgica, que
se iniciaram desde os primeiros estudos sobre silogismos de Aristteles, at o
Solucionador Geral de Problemas de Newel e Simon (1963).
A lgica pode ser facilmente automatizada, pelo fato de ser um
sistema formal. Muitos problemas podem ser formulados e resolvidos atravs desta
abordagem, fato que serviu de motivao no desenvolvimento de provadores
automticos de teoremas.
12
No entanto, estes sistemas enfrentam duas grandes dificuldades:
s vezes, no possvel formular um problema em notao
lgica, pois a base de conhecimentos no completamente
verdadeira;
embora haja programas que resolvam problemas descritos em
notao lgica, pode no haver recursos computacionais
suficientes para a resoluo destes. Alguns sistemas lgicos
podem ter um nvel de complexidade suficiente para gerar
infinitos teoremas provveis.
A soluo para tais problemas est no uso de tcnicas heursticas.
Elas reduzem o tamanho do espao de busca atravs de passos que podem ajudar
a alcanar a soluo desejada, mas que no garantem que esta soluo ser tima.
Na maioria dos casos, quando no se alcana uma soluo tima, obtm-se uma
boa aproximao para a mesma.
2.5 IA nos Jogos
IA no contexto dos jogos implica que os oponentes controlados pelo
computador apresentem um certo grau de cognitividade (percepo, esperteza) ao
enfrentar o jogador humano. Existem vrias maneiras de se implement-la, mas o
mais importante que eles paream apresentar certo grau de inteligncia.
As tcnicas de IA no contexto de jogos foram usadas muito tempo
antes destes fazerem parte do ramo da computao. Inicialmente a IA fora utilizada
nas pesquisas em busca em espao de estados; em jogos como xadrez, damas e o
jogo-dos-15
2
. A vantagem do uso de jogos no estudo da IA reside no fato de os
mesmos possuirem regras bem definidas e serem fceis de se praticar.
_____________
2
Jogo estilo quebra-cabea onde quinze peas so embaralhadas e dispostas em uma matriz 4x4.
As peas s podem ser movidas em direo ao nico espao em branco, e o objetivo do jogo
restaurar a matriz ao seu estado original.
13
Deve-se atentar para as diferenas entre a utilizao de tcnicas
acadmicas de IA e do uso de cheating, termo comum entre os jogadores que
denomina o uso de trapaa pelo sistema, fazendo com que os jogadores tenham a
iluso de que o sistema inteligente. De acordo com Buckland (2005), uma
pesquisa foi feita entre vrios testadores do jogo de tiro Halo, e constatou-se que os
mesmos atribuam maior nota qualidade da IA do programa quando aumentaram-
se os pontos de vida dos NPCs
3
; e esta mesma nota foi menor quando tambm
propositalmente estes pontos de vida foram diminudos, fazendo com que os NPCs
ficassem mais fceis de se destruir.
Outra tcnica comum de trapaa o uso da vantagem de que o
sistema conhece todos os caminhos e perigos de um cenrio, tendo deste modo
uma viso muito mais ampla que a do jogador. Em um labirinto, por exemplo, pode-
se fazer com que o inimigo surpreenda o jogador, utilizando algoritmos de busca em
caminhos, que sero vistos mais adiante.
O aumento da capacidade computacional trouxe tambm mais
realismo aos jogos. Com o advento dos grficos em 3D, a IA ganhou ainda mais
espao nesta rea. Com ambientes cada vez mais complexos, de suma
importncia o uso de algoritmos de IA para evitar que os NPCs atravessem
paredes, fiquem presos em cantos do cenrio ou ajam de maneira indiferente a
estmulos visuais e sonoros produzidos pelo jogador.
Na prtica, o propsito da IA em um jogo controlar cada aspecto do
NPC, provendo as seguintes facilidades (CHAMPANDARD, 2003) :
Comportamentos primitivos: capturar itens, apertar botes,
usar objetos, gesticular, entre outros;
Movimento: entre determinadas reas do cenrio, desviando-
se de obstculos, plataformas, entre outros;
_____________
3
Non Player Character (Personagem no controlado pelo jogador, mas pela mquina).
14
Tomada de deciso: situa-se um nvel acima das outras
facilidades, computando as aes necessrias para cumprir
seus objetivos.
Tais facilidades podem at ser implementadas com a programao
tradicional, no entanto, a IA traz solues mais elegantes, gerando comportamentos
mais qualitativos. Isto possvel atravs da utilizao de funcionalidades tais como
o reconhecimento de padres, predio, aproximao e controle motor.
15
3 CARACTERSTICAS DO DESENVOLVIMENTO DE JOGOS
Para garantir o sucesso de um jogo no mercado, necessrio, alm
de uma boa equipe de desenvolvimento e capital financeiro, um bom planejamento
visando a fatia de mercado desejada e o pblico-alvo que se deseja alcanar. Os
aspectos fundamentais que devem ser levados em considerao antes mesmo de
se iniciar seu desenvolvimento so mostrados a seguir.
3.1 Categorias
H uma vasta gama de estilos diferentes de jogos no mercado, e,
dependendo do mesmo, seu grau de complexidade no tocante ao desenvolvimento
diferente. Jogos infantis e de plataforma possuem lgica relativamente simples se
comparados aos simuladores e RPGs, por exemplo.
No h uma frmula especfica para se enquadrar cada jogo dentro de
uma determinada categoria, visto que a cada ano surgem muitas novidades, e
alguns softwares so uma mesclagem de vrios estilos diferentes. Os principais
estilos vendidos no mercado so:
RPG: do ingls Role Playing Game, um jogo no qual o
jogador assume o papel de um personagem tomando todas as
suas decises no desenrolar da estria, que geralmente
assume propores picas. Como o jogador possui imensas
possibilidades de escolha que acarretaro em caminhos
diferentes na estria, os RPGs possuem uma complexa base de
dados. Exemplos: Final Fantasy da Squaresoft e Diablo da
Blizzard.
Aventura: no deve ser confundido com o RPG. Nesta classe
de software, a nfase dada resoluo de quebra-cabeas e
enigmas ao invs da construo de personagens, batalhas, etc.
16
Exemplos: The Dig e Full Throttle, ambas da Lucas Arts.
Simulao: seu foco principal a fsica do ambiente em
questo, proporcionando o maior grau de realismo possvel.
Estes jogos buscam elementos grficos de alta qualidade e
jogabilidade fiel realidade. A programao do software exige
muito conhecimento de fsica e matemtica, alm de possuir
grau de complexidade elevado no que tange seu
desenvolvimento. Uma boa IA fundamental para aumentar o
realismo da simulao. Exemplos: Flight Simulator da Microsoft
(simulador de vo) e Gran Turismo da Polyphony (simulador de
carros).
Esportes: simulam esportes como futebol, basquete, vlei,
golfe, entre outros. Assim como os jogos de simulao, tm
interfaces 3D bastante complexas e seu desenvolvimento
possui as mesmas dificuldades inerentes ao desenvolvimento
de um jogo estilo simulao (fsica, matemtica e IA). Exemplo:
FIFA Soccer da Electronic Arts (simula partidas de Futebol).
Plataforma: um dos estilos de jogos mais clssicos. Sua
lgica simples se comparado aos simuladores e RPGs:
basicamente, o jogador tem seus movimentos limitados ao eixo
X (no caso 2D); movendo-se para a direita ou esquerda e
pulando obstculos. Inicialmente, a maioria dos jogos de
plataforma eram 2D, mas devido aos avanos de hardware
muitos esto sendo feitos utilizando tecnologias 3D. Exemplos:
Sonic (SEGA) e Super Mario Bros. (Nintendo).
Educao/treinamento: Possuem um foco mais didtico e
pedaggico do que de entretenimento. So jogos educacionais
que podem ser utilizados no aprendizado e/ou treinamento, de
acordo com os critrios que se desejam transmitir. Exemplos:
Simuladores de vo para treino de pilotos, jogos de aventura
17
cujos enigmas envolvem o aprendizado de histria, matemtica,
entre outros.
Estratgia: so jogos que foram o jogador a utilizar o seu lado
intelectual ao invs dos reflexos com o controle. Atravs de uma
anlise cuidadosa da situao, o jogador toma decises crticas
que envolvem o planejamento de cidades (Sim City 3000,
Maxis) ou o comando de exrcitos (WarCraft, Blizzard) por
exemplo. Um algoritmo comumente utilizado em jogos de
estratgia o A* (A-estrela) na busca de caminhos
(pathfinding), que ser vista adiante.
Infantil: seu pblico alvo so as crianas e enfocam histrias
simples e quebra-cabeas com o intuito de educar e divertir a
criana. Possuem visual colorido e interface simples. O jogo
segue trajetria linear, por isso sua programao
relativamente simples. Exemplo: Putt Putt Joins the Circus
(Humongous).
Tabuleiro: seguem a linha dos jogos clssicos como xadrez,
damas, 8-peas, entre outros.
3.2 Pblico Alvo
Quando se desenvolve um jogo, necessrio definir um pblico-alvo
para o mesmo. Esta questo de grande relevncia, visto que ela pode afetar
inclusive o seu faturamento. Dependendo do estilo do enredo, falas ou da incluso
de cenas sugestivas, um jogo pode ser classificado em uma faixa-etria mais
elevada, fazendo com que uma menor variedade de consumidores tenham acesso
ao produto. Este tipo de classificao etria tambm varia de um pas para outro
devido s diferenas culturais entre estes. O maior consumidor de jogos eletrnicos
no o pblico infantil, mas so as pessoas jovens entre 16 a 25 anos em mdia.
18
Logo, necessrio definir antecipadamente produo, qual ser o
pblico-alvo do produto e tambm se este poder ser futuramente lanado em
outros pases, sendo traduzido para outras linguas.
3.3 Plataforma
Os jogos eletrnicos esto disponveis nas mais diversas plataformas,
sendo os computadores pessoais, consoles e os arcades
4
as plataformas mais
comuns. Atualmente, tem havido uma grande expanso na rea de jogos para
celulares, devido grande base de usurios em todo o mundo que tende a
ultrapassar a quantidade de dispositivos das outras plataformas. Geralmente, um
jogo lanado para uma plataforma-alvo e ento adaptado posteriormente para as
demais.
3.4 rea de Atuao
A rea de atuao no mercado de jogos ampla e pode variar em
cada companhia ou tipo de jogo. Alm disso, novos empregos surgem medida
que emergem novas tecnologias (tanto de software como hardware).
Apesar dessas disparidades, a maioria dos estdios de
desenvolvimento so formados por quatro equipes principais: design, artstica,
programao e testes. A equipe de design cuida dos conceitos bsicos do
funcionamento do jogo. A equipe artstica cria imagens e compe msicas e outros
efeitos sonoros. A de programao planeja e programa o cdigo para o
funcionamento do software. J a equipe de testes verifica quais so os erros de
cdigo (bugs) do jogo antes deste ser publicado.
_____________
4
Tambm conhecidos como fliperamas.
19
4 ALGORITMOS DE IA PARA JOGOS
As tcnicas de IA para jogos podem ser divididas em duas principais
categorias, que so denominadas determinsticas e no-determinsticas:
determinstica: tem comportamento previsvel, consome
poucos recursos da mquina e mais fcil de ser
implementada. Um exemplo de comportamento determinstico
o algoritmo bsico de perseguio (cap. 4.1.1). O problema
desta abordagem que se faz necessrio prever todas as
aes possveis em um determinado momento, fazendo-se uso
de muitas regras do tipo se-ento; alm disso, aps pouco
tempo de jogo, o jogador consegue prever facilmente o
comportamento da mquina, pois, para um mesmo conjunto de
entradas, as mesmas respostas so atribudas;
no-determinstica: possui um grau de incerteza, que pode
variar a cada implementao; um exemplo de comportamento
no determinstico inclui o aprendizado que um personagem da
mquina adquire ao jogar contra um humano aps um
determinado perodo. Tal aprendizado pode ser implementado
por uma rede neural ou algoritmo gentico, por exemplo.
possvel fazer com que a mquina possa inclusive exibir
comportamentos que vo alm do que lhe foi programado mas
h um porm, pois, em alguns casos, a mquina pode exibir um
comportamento no desejado. Outra dificuldade se encontra
nos testes, pois fica mais difcil testar todas as combinaes de
comportamento que a mquina poder exibir durante a
execuo do jogo.
20
4.1 Perseguio e Fuga
A locomoo uma das premissas bsicas de um agente. Tal
caracterstica fundamental para que este consiga atingir seus objetivos. Um
algoritmo de perseguio e fuga pode ser divido em duas partes (BOURG e
SEEMAN, 2004): uma, a tomada de deciso para que se inicie o processo, e outra
a ao propriamente dita. Pode-se dizer tambm que existe um terceiro processo
a ser considerado, que a evaso de possveis obstculos que possam estar no
caminho encontrado pelo algoritmo.
Um algoritmo de busca simples envolve o decremento das distncias
entre as coordenadas do caador e da presa.
4.1.1 Algoritmo bsico de perseguio:
Cdigo 1: algoritmo bsico de perseguio
se (caadorX > caaX)
caadorX--;
seno se (caadorX < caaX)
caadorX++;

se (caadorY > presaY)
caadorY--;
seno se (caadorY < presaY)
caadorY++;

Pra transformar o algoritmo de perseguio em um algoritmo de
evaso, basta fazer exatamente o oposto, invertendo as coordenadas da presa de
modo que sua distncia aumente em relao caa.
21
4.1.2 Exemplo de um algoritmo bsico de evaso:
Cdigo 2: algoritmo bsico de evao
se (presaX > caadorX)
presaX++;
seno se (presaX < caadorX)
presaX--;
se (presaY > caadorY)
presaY++;
seno se (presaY < caadorY)
presaY--;

Ambos os algoritmos anteriores no consideram a situao atual do
cenrio, ou seja, no levam em conta os obstculos que possam estar no caminho
do movimento entre o caador e a presa.
Outro revs, que o algoritmo no apresenta um movimento suave,
pois o perseguidor sempre comea com um movimento na diagonal em uma
coordenada, e depois termina fazendo um movimento reto na outra coordenada, o
que no aparenta ser um movimento natural. Vide figura a seguir:

Figura 1 - uma melhora alcanada utilizando a perseguio com linha de viso (line-of-
sight chasing) (BOURG e SEEMAN, 2004)
22
4.1.3 Perseguio com linha de viso
Na perseguio com linha de viso, o predador move-se em direo
presa atravs de uma linha reta traada entre as coordenadas deste e aquele. Se a
presa encontra-se inerte, o caminho ser uma reta; e, se a presa encontrar-se em
movimento, o caminho a ser seguido pelo predador ser formado por curvas pois,
a cada iterao do lao do jogo, o predador traar uma reta entre a sua posio e
a posio da presa, e, como esta encontra-se em alterao, esta reta ganhar nova
direo a cada iterao.

Figura 2 Perseguio simples (esq) e com linha de viso (dir)
Um algoritmo interessante na implementao da perseguio com
linha de viso o algoritmo de Bresenham, que muito utilizado na computao
grfica para o desenho de retas. A razo pela qual o algoritmo de Bresenham til
em perseguio e fuga o fato de que ele nunca desenha dois pixels
5
adjacentes
no menor eixo da reta, o que implica que ele sempre encontrar o caminho mais
curto entre ambos os pontos.
Observe que, devido sua natureza, o algoritmo de Bresenham s
funciona em jogos que usam tiles, ou seja, onde o cenrio formado por ladrilhos
dispostos em linhas e colunas. Uma verso do algoritmo de linha de viso ser
mostrada mais tarde.
_____________
5
Pixel: menor unidade que compe uma imagem em um monitor ou tela de televiso.
23

Figura 3 - o algoritmo de Bresenham (esq.) nunca desenha dois pixels adjacentes no menor
eixo da reta
Consulte o ANEXO A para ver o algoritmo de Bresenham na ntegra.
24
4.1.4 Linha de viso para ambientes contnuos
O algoritmo de Bresenham bastante satisfatrio para cenrios
compostos por tiles
6
. Para ambientes contnuos, nos quais os agentes (tanto os
controlados pelo computador quanto pelo jogador) so submetidos foras fsicas
como acelerao, velocidade e direo, existe um algoritmo de perseguio e fuga
bastante eficiente, que utiliza as tcnicas de linha de viso. Tendo conhecimento
das coordenadas da presa, o predador, a cada iterao do lao de jogo, ajusta a
direo de seu movimento para que este se dirija de encontro presa.
Aps o clculo da direo para qual o agente dever seguir, a
mecnica do jogo far o tratamento de tal locomoo, que deve ser limitada por
uma velocidade mxima e tambm por uma taxa de mudana de direo mxima.
Esta ltima no deve ser muito alta para que o agente no tenha uma trajetria
muito brusca.
Cdigo 3: algoritmo de linha de viso para ambientes contnuos
void DoLineOfSightChase (void)
{
Vector u;
bool left = false;
bool right = false;

u = VRotate2D(-Predator.fOrientation,
(Prey.vPosition - Predator.vPosition));
u.Normalize();

if (u.x < -_TOL)
left = true;
else if (u.x > _TOL)
right = true;

Predator.SetThrusters(left, right); //ajusta a direo
}

_____________
6
Tile: do ingls ladrilho. uma unidade que compe um cenrio em ambientes 2D. Cada cenrio
composto de uma matriz de tiles.
25
As variveis left e right indicaro quais foras de direo o agente
deve tomar. O cdigo Prey.vPosition - Predator.vPosition calcula o vetor distncia
relativa entre o predador e a presa em coordenadas globais, que ento passada
funo VRotate2D, que converte estas coordenadas globais para as coordenadas
locais do predador. Coordenadas globais so as coordenadas fixas (imutveis) do
sistema. J as coordenadas locais de um agente so mutveis e rotacionam
juntamente com o objeto ao qual esto aderidas.

Figura 4 - sistema de coordenadas em linha de viso para ambientes contnuos
possvel transformar coordenadas globais (X, Y) em coordenadas
locais (x, y) em termos da orientao do agente em relao ao sistema de
coordenadas globais (teta) com a seguinte frmula:
) cos( ) sin(
) sin( ) cos(


Y X y
Y X x
+ =
+ =

Equao 1: transformando coordenadas globais em locais
Agora o vetor u armazena a direo do predador presa. Assim
sendo, u ento normalizado para que ele contenha um valor unitrio. Com este
valor, podemos verificar se a presa encontra-se esquerda, direita, ou logo
frente do predador, de acordo com suas coordenadas locais. No primeiro caso, left
recebe true, no segundo, right recebe true, e, no terceiro, nada precisa ser feito,
pois no necessrio mudar de direo.
26
4.1.5 Interceptao
Os algoritmos vistos at aqui fazem com que, em dado momento, o
predador sempre v em direo presa. Porm, esta soluo nem sempre a mais
otimizada em termos de espao percorrido e tempo gasto. O algoritmo de linha de
viso na maioria das vezes faz com que o predador fique atrs da presa, ou, caso
ele seja mais rpido, ele acabar ultrapassando-a.
Pode-se imaginar que o problema da interceptao se resume a
encontrar o caminho perpendicular mais curto ao longo da trajetria da presa. Mas
isto poderia fazer com que o predador alcanasse este ponto muito rpidamente -e
ele tera que esperar pela presa (dando-lhe a oportunidade de fugir). Isto ocorre
quando no se leva em considerao a velocidade relativa entre os dois corpos.
Para que o predador possa prever corretamente o ponto de encontro
com a presa, alm de suas posies relativas, necessrio que o predador tenha
tambm o conhecimento de suas velocidades relativas:
Spredador - Spresa Sr
Vpredador - Vpresa Vr
=
=

Equao 2: clculo da velocidade e posio relativa
Com estas duas informaes, possvel calcular o tempo de
abordagem (T
A
), que o tempo mdio gasto para percorrer uma distncia igual S
r
,
uma velocidade V
r
:

T
A
= |S
r
|/|V
r
|
Equao 3: clculo do tempo de abordatem (T
A
)

Observe que S
r
e V
r
so vetores, portanto T
A
a magnitude de S
r

dividida pela magnitude de V
r
.
27
Agora possvel prever a posio da presa (S
f
) no tempo T
A
futuro:
S
f
= S
presa
+ (V
presa
)(T
A
)
Equao 4: posio da presa no tempo (T
A
) futuro

Agora, o ponto S
f
ser o ponto para o qual o predador dever seguir
no algoritmo de linha de viso em ambientes contnuos apresentado anteriormente.
Modificando aquele algoritmo, temos o algoritmo de interceptao:
Cdigo 4: algoritmo de interceptao
void DoIntercept(void)
{
Vector u;
Bool left = false;
Bool right = false;
Vector Vr, Sr, St;
Double tc

Vr = Prey.vVelocity - Predator.vVelocity;
Sr = Prey.vPosition - Predator.vPosition;
Ta = Sr.Magnitude() / Vr.Magnitude();
Sf = Prey.vPosition + (Prey.vVelocity * Ta);
u = VRotate2D(-Predator.fOrientation,(Sf - Predator.vPosition));

//daqui em diante, permanece o mesmo cdigo do algoritmo anterior
u.Normalize();
if (u.x < -_TOL)
left = true;
else if (u.x > _TOL)
right = true;

Predator.SetThrusters(left, right); //ajusta a direo
}
Uma grande vantagem do algoritmo de interceptao que o predador
no precisa necessariamente ser mais rpido que a presa. No algoritmo de linha de
viso, o predador na maioria dos casos acaba ficando atrs da presa; tendo que
alcan-la. Com a interceptao, suficiente que o predador seja rpido apenas o
suficiente para alcanar o ponto de interceptao dentro do tempo previsto; caso
contrrio, a interceptao no ser possvel.
Para conseguir um maior nvel de inteligncia, pode-se combinar os
algoritmos de perseguio e fuga com outros, que lidam com outras situaes do
problema como o desvio de obstculos, e a tomada de deciso quanto a efetuar
ou no a perseguio (fuga).
28
4.2 Sistemas Baseados em Regras
Sistemas baseados em regras so muito utilizados, tanto para
aplicaes da vida real quanto para jogos. So sistemas que consistem de
inmeras regras do tipo se-ento, que sero aplicadas a um conjunto de entradas.
De acordo com o conjunto de entrada, a parte ento da regra define qual ao
ser tomada.
Em IA, estes sistemas tambm so chamados de Sistemas
Especialistas, e so utilizados para substituir um especialista humano em uma
determinada rea do conhecimento, como o diagnstico de doenas, classificao
de doenas em determinada cultura, diagnstico de erros de engenharia, entre
outras. Uma grande vantagem dos sitemas especialistas que eles imitam a
maneira como o ser humano tende a pensar e raciocinar, dado um conjunto de fatos
e seu prprio conhecimento sobre um domnio de conhecimento (BOURG e
SEEMAN, 2004).
Outra vantagem em usar sistemas especialistas que devido sua
natureza modular, sua implementao fcil, e o conjunto de regras pode ser
disposto em qualquer ordem.
4.2.1 Elementos de um sistema baseado em regras
Todo sistema especialista ou baseado em regras deve possuir os
seguintes elementos:
memria de trabalho (working memory): guarda os fatos j
sabidos e tambm as asseres feitas pela aplicaes das
regras;
regras: conjunto de regras no estilo se-ento que operam
sobre os fatos gravados na memria de trabalho. Quando uma
29
regra aplicada, ela dispara a ao vinculada sua parte
ento, ou faz com que o sistema mude de estado, como numa
mquina de estado finito.
interpretador: tambm conhecido como motor de inferncias,
a parte do sistema responsvel pela escolha e aplicao de
determinada regra a partir de seu estado atual. O interpretador
utiliza duas maneiras para fazer inferncias: o forward e o
backward chaining.
4.2.2 Forward chaining
O sistema forward chaining (encadeamento progressivo) o mais
comum dos sistemas de inferncia. Nele, o sistema inicia com um conjunto de fatos,
e a partir destes, aplica as regras repetidamente at que o resultado desejado seja
alcanado. O mtodo dividido em trs etapas:
1. matching: nesta fase, o sistema procura identificar todas regras
que se aplicam ao conjunto de entrada, de acordo com seu
estado atual;
2. resoluo de conflitos: na primeira etapa, mais de uma regra
pode satisfazer o conjunto de entrada atual. Para resolver este
conflito, existem vrias abordagens, como por exemplo:
a. escolher sempre a primeira regra aplicvel;
b. escolher uma das regras aleatriamente;
c. atribuir pesos para as regras e escolher a de maior peso.
Tais pesos podem ser atualizados de acordo com a
frequncia com que cada regra escolhida.
3. execuo: depois de eliminadas as ambiguidades, a regra
30
escolhida executada, ou seja, a sua parte ento.
4.2.3 Backward chaining
O backward chaining, ou encadeamento regressivo, basicamente o
contrrio do forward chaining. A partir de um objetivo, o sistema verifica quais
regras poderam ser aplicadas para que o mesmo seja atingido. por este motivo
que o backward chaining dito ser um algoritmo dirijido ao objetivo (goal driven).
Devido sua natureza recursiva, o backward chaining no amplamente utilizado,
por questes computacionais.
4.2.4 Aplicao em jogos
Uma implementao pode conter os dois tipos de algoritmo. Em um
jogo de estratgia, por exemplo, considere o pequeno trecho de um sistema de
regras:
If (templo=true) then paladino=true
If (templo=true and trincheira=true) then soldado=true
O trecho de regras acima indica quais unidades o jogador pode
construir se possuir determinada construo. Por exemplo, se o jogador possuir um
templo, ento ele est apto a construir paladinos.
Sabendo que o jogador possui um templo, utilizando forward chaining,
o computador pode presumir que o jogador tem grandes chances de possuir
paladinos, desta forma, ele poder preparar sua defesa de modo que consiga
superar um possvel ataque de paladinos.
O contrrio tambm possivel -descobrindo que o jogador possui
soldados, o computador, utilizando backward chaining, pode presumir que o jogador
possui trincheiras. Desta forma, o computador pode armar seu exrcito de modo
31
que tenha fora suficiente para superar a trincheira.
4.3 Lgica Nebulosa (fuzzy)
Na lgica fuzzy, ou nebulosa, possvel mapear problemas discretos
ou booleanos da mesma maneira como seres humanos o fazem. Por exemplo, ao
invs de dizermos que um objeto est uma distncia de 0,5, 1 ou 10 metros,
podemos dizer que o mesmo est muito perto, perto ou longe.
Na lgica booleana tradicional, existiriam limites discretos para muito
perto, perto e longe. E tais limites so completamente disjuntos. J na lgica
fuzzy, todo o problema pode ser mapeado em vrios nveis, ou seja, reas
nebulosas, permitindo uma certa sobreposio entre os limites.
pelo fato de no ser determinstica, que a lgica nebulosa tem sido
bastante difundida em aplicaes da vida cotidiana. Um ar condicionado, por
exemplo, ao invs de ligar e desligar seu termostado constantemente quando a
temperatura ambiente se desvinculasse da temperatura estipulada, causando danos
ao aparelho, poderia simplesmente ajustar sua potncia de modo que a temperatura
ficasse prxima ideal. Utilizando lgica nebulosa, tambm sera possvel controlar
o sistema de freios de um metr, fazendo com que este parasse de maneira to
suave que seus passageiros teram a mnima sensao de desconforto.
4.3.1 Lgica nebulosa nos jogos
Pode-se trabalhar com lgica nebulosa nos jogos de maneira parecida
como construdo um sistema baseado em regras, ou uma mquina de estados
finitos. Contudo, a lgica nebulosa permite trabalharmos com variveis mais
prximas linguagem humana -ao invs de trabalharmos com valores discretos,
trabalhamos com variveis do tipo perto, longe, ou quente, muito quente, por
exemplo.
Veja a seguir um exemplo de uso de lgica nebulosa em um jogo.
32
Neste, o computador toma decises de acordo com o estado atual do jogador, que
medido segundo a lgica nebulosa:
Se (muito_forte) then fugir;
Se (forte) then procurar_arma;
Se (fraco) then atacar;
Note que muito_forte, forte e fraco so funes fuzzy, cujo clculo
ser visto adiante. relevante salientar que, se fosse utilizada a lgica tradicional,
teramos de estabelecer inmeros limites (regras) para definir qual o significado
de cada uma dessas funes, enquanto que na lgica nebulosa, possvel faz-lo
com um nmero bem menor de regras.
4.3.2 Caractersticas
O processo fuzzy dividido em trs etapas. Entrada (fuzzificao),
sada (sada fuzzy), e quantizao (defuzzificao).
4.3.3 Fuzzificao
Na fuzzificao, os dados (nmeros) so mapeados em dados
nebulosos. Este processo de mapeamento involve encontrar o grau de
associatividade entre os dados de entrada e os conjuntos fuzzy pr-definidos. No
exemplo acima, isto significaria descobrir, segundo os dados numricos de entrada,
em qual dos grupos se encontra a fora do jogador (muito forte, forte ou fraco). Isto
feito atravs de funes de associatividade.
33
4.3.4 Funes de associatividade
Praticamente qualquer funo pode ser usada como funo de
associtatividade, isto vai depender da facilidade de implementao, e tambm da
preciso que se deseja alcanar como resultado. O seu valor resultante ir dizer, no
nosso exemplo, o quo forte est o jogador que o computador ir enfrentar. Este
valor vai de 0 (zero, fraco) a 1 (um, forte). Veja a funo de associatividade abaixo:

Figura 5 exemplo de funo de associatividade (grfico)
Nesta, valores abaixo de x
0
indicam valor fraco, e valores acima de x
1
indicam valor muito forte. Um valor entre esses dois limites indica um certo grau de
fora. A formula para esta funo mostrada a seguir:

< <

=
1
1 0
0 1
0
0 1
0
; 1
;
; 0
) (
x x
x x x
x x
x
x x
x
x x
x f

Equao 5: funo de associatividade (frmula)
34
Geralmente utilizada uma funo de associatividade para cada grupo
de valores que se deseja avaliar. Veja o exemplo abaixo:

Figura 6 mltiplas funes de associatividade
Neste caso, h trs funes de associatividade. Note que existem
inmeras dessas funes, como a trapezoidal, e a triangular, cuja implementao
foge ao escopo deste trabalho. Maiores detalhes sobre tais funes podem ser
encontrados em (MCNEIL e THRO, 1994). O importante salientar que, tendo as
trs funes de associatividade, basta usar os valores de entrada como parmetro
em cada uma delas para obter cada um dos graus de associatividade.
Portanto, para uma dada entrada, podemos encontrar um valor de 0
para fraco, 0,75 para forte e 0,15 para muito forte. Da podemos inferir que o
jogador substancialmente forte.
4.3.5 Sada fuzzy
Depois de fuzzificar os valores de entrada, se faz necessrio produzir
uma sada, que ser a ao tomada pelo computador naquele momento. Isto feito
atravs da avaliao de regras, de maneira semelhante quela feita nos sistemas
baseados em regras. A diferena aqui que todas as regras so avaliadas e
produzem uma resposta cuja intensidade expressa segundo a lgica fuzzy. Os
operadores lgicos fuzzy so os seguintes:
Disjuno: VERDADE(A OU B) = MAX( VERDADE(A), VERDADE(B) )
Conjuno: VERDADE(A E B) = MIN (VERDADE (A), VERDADE(B) )
35
Negao: VERDADE(NO A) = 1 VERDADE(A)
Lembremos que na lgica fuzzy, o valor VERDADE um nmero
real, que varia de 0 a 1. Retomando nosso exemplo, poderamos increment-lo
adicionando novas variveis fuzzy, produzindo o seguinte conjunto de regras:
Se (inimigo.muito_forte E computador.desarmado) then fugir;
Se (inimigo.forte E desarmado) then procurar_arma;
Se (inimigo.fraco OU inimigo.desarmado) then atacar.
Este apenas um exemplo. Inmeras outras regras poderam ser
adicionadas para lidar com todas as possibilidades. O resultado da avaliao destas
regras podera ser o seguinte:
fugir com intensidade 0.5;
procurar arma com intensidade 0.2;
atacar com intensidade 0.76.
A intensidade associada a cada ao representa a fora de cada
regra. Uma maneira de escolher qual ser deciso tomada escolher a de maior
peso (neste caso, atacar). Note que os pesos acima no indicam a intensidade com
que ser feita a fuga, procura da arma ou ataque, e sim o peso de cada deciso. O
clculo intensidade com que a ao dever ser executada, quando necessria, ser
calculada na fase de desfuzzificao.
4.3.6 Desfuzzificao
A desfuzzificao necessria quando se deseja um sada
quantitativa, ou seja, um nmero como sada do sistema nebuloso. Em um caso de
perseguio e fuga, por exemplo, um sistema fuzzy podera indicar ao caador um
36
valor quantitativo de quanto ele devera mudar de direo esquerda ou direita
para interceptar a presa. Exemplos de funes de defuzzificao podem ser
encontrados em (MCNEIL e THRO, 1994).
4.4 Scripts
Scripts so linguagens de programao bastante simplificadas,
escritas especificamente para lidar com tarefas especficas dentro de um jogo,
como controle de fluxo de dilogos, controle de aes, entre outras.
Os scripts ficam em arquivos separados do cdigo principal do
programa, na forma de arquivos de texto simples. Para dificultar a alterao desses
arquivos de script, alguns desenvolvedores criam compiladores para a linguagem,
armazenando os mesmos na sua forma compilada -de modo que sua leitura seja
irreconhecvel ao usurio. Isto evita que os mesmos sejam alterados com intenes
maliciosas.
Uma grande vantagem da utilizao de scripts que, conforme o
tamanho do projeto aumenta, a alterao de constantes dentro do cdigo fica cada
vez mais difcil, j que o tempo de compilao bastante demorado. Armazenando
essas constantes na forma de scripts, o cdigo em linguagem de programao fica
separado do cdigo referente s regras do jogo, e isto permite ainda que pessoas
leigas em programao possam ser incumbidas de tal tarefa. Mas isso no tudo:
Uma linguagem script mais avanada aumenta a interao entre o script e o
executvel, permitindo no apenas inicializar variveis mas criar a lgica do jogo e at
mesmo objetos do jogo, tudo a partir de um ou mais arquivos de script. (BUCKLAND,
2005) (trad.nossa).
37
4.4.1 Construo
Para que os scripts funcionem de maneira independente do programa
executvel, necessrio que este ltimo tenha consigo um interpretador compatvel
com a sua linguagem. Este interpretador ir carregar o arquivo de script para
inicializar as variveis dentro do jogo, como no exemplo abaixo:
Cdigo 5: exemplo de arquivo script
FORCA = 30;
AGILIDADE=10;
VIDAS=2;
O exemplo acima um pequeno arquivo de script que especifica os
atributos de um personagem controlado pelo computador. Veja o exemplo abaixo:
Cdigo 6: exemplo de script controlando a lgica do computador
Se (Jogador.armado=TRUE) ento Fuja();
Seno Ataque();

Repare como a linguagem script pode ser utilizada para controlar
aspectos lgicos do computador. Este exemplo utiliza uma linguagem de alto nvel,
mais prxima linguagem natural. Scripts como este requerem maior tempo gasto
no desenvolvimento de interpretadores e compiladores para a linguagem, mas
permitem a criao de mods.
Mods so extenses de um jogo criadas atravs de scripts pelos
prprios jogadores. Atravs de sua linguagem, o desenvolvedor pode permitir quais
aspectos do jogo o jogador poder alterar, ou criar, dando a ele a oportunidade de
criar novos mundos, armas, inimigos, entre outros. Isto tem sido uma tendncia em
jogos recentes para aumentar o tempo de durao do jogo e alavancar as vendas.
Um grande exemplo de utilizao de mods o jogo Unreal Tournament 2004, da
Epic Games.
38
4.5 Mquinas de Estado Finito
As mquinas de estado finito ou finite state machines (FSMs) tm sido
h muito tempo a principal escolha na hora de implementar a IA de agentes para
jogos. Sua principal idia consiste em dividir o comportamento do agente em vrios
estados, com transies entre eles. A transio de um estado para outro depender
de fatores de entrada, que podem ser estmulos provocados pelo jogador ou pelo
ambiente. Historicamente, um dos mais famosos exemplos de FSM a Mquina de
Turing, que foi proposta por Alan Turing, em 1936.
Existem vrios motivos pelos quais o uso de FSMs tenha sobrevivido
at hoje, entre eles podemos citar:
facilidade de compreenso pois natural para ns humanos
pensarmos nos objetos como estando em um estado ou outro;
so fceis de serem implementados;
facilidade de teste como possuem um nmero finito de
estados, possvel traar a rota de eventos que causaram o
mal-funcionamento do agente defeituoso;
so rpidos h pouca sobregarga de processamento, pois
todas as regras so implementadas via programao e so da
forma se-ento;
so flexiveis estados e regras adicionais podem ser
implementados rapidamente. Alm disso, podem ser
combinadas com tcnicas no-determinsticas da IA, como
redes neurais e lgica nebulosa.
39
4.5.1 Caractersticas
Os elementos bsicos que constituem uma FSM so:
estados: representam uma posio no tempo que,
consequentemente ir influir no comportamento do agente;
transies: so ligaes entre os estados. Podem ser uni ou bi-
direcionais;
eventos: so aes que ocorrem externamente ao agente;
condies: so regras que devem ser preenchidas para que
ocorra a mudana de estado.

Figura 7 mquina de estados finitos (s: estados; t:transies)
4.5.2 Implementao
Para implementar uma FSM, necessrio ter uma varivel de
controle, que indicar o estado atual do agente. O valor inicial desta varivel ir
determinar o estado inicial. A partir disso, a cada interao do agente com seu
ambiente verificado seu estado atual, e, a partir deste, verificado se alguma
condio de transio satisfeita. Caso isto ocorra, a mudana do valor da varivel
de controle indica a mudana de estado. Isto pode ser feito atravs do uso de
condies se-ento ou atravs da declarao switch das linguagens C e Java.
40
A adio de estados adicionais pode resultar na dificuldade do
entendimento do cdigo. Uma soluo para o problema est na utilizao de
tabelas de transio de estados. Tais tabelas so divididas em colunas, que
contm a condio e o novo estado (transio), caso a condio seja satisfeita.
Tabela 1 tabela de transio de dados
Estado Atual Condio Novo estado
Fugindo Seguro Patrulhando
Atacando MaisFracoQueInimigo Fugindo
Patrulhando Ameacado E MaisForteQueInimigo Atacando
Patrulhando Ameacado E MaisFracoQueInimigo Fugindo
4.5.3 Mquinas de estado finito no-determinsticas
Uma grande desvantagem no uso de FSMs o fator previsibilidade,
que acaba tornando o jogo muito fcil para o jogador humano aps algum tempo de
jogo. Uma maneira de tornar as aes praticadas pelo agente mais difceis de se
prever misturar esta com um outra tcnica j mencionada neste trabalho: a lgica
nebulosa.
Deste modo, podemos tornar a FSM menos determinstica, utilizando
as tcnicas abaixo (BROWNLEE, 2005):
fuzzificar as condies de transio de estados. Quando for
encontrado um conflito, escolher a transio de maior valor
fuzzy;
fuzzificar os valores de entrada, representando a fora (peso)
com que determinado evento tenha ocorrido. O sistema ento
utilizaria esses dados numricos, disparando apenas as
transies de estado cujos pesos estiverem acima de um limiar.
41
Outra maneira de tornar o sistema menos determinstico
selecionando os estados de transio aleatriamente dentro de uma grande gama
de estados, criando uma sensao de imprevisibilidade.
4.6 Busca Heurstica
A busca heurstica uma tcnica antiga da IA e muito utilizada em
jogos de tabuleiro e, recentemente na busca de caminhos (pathfinding). Tais jogos
so bastante propcios para a implementao dessas tcnicas de IA, pois possuem
um espao de estados finito, mas suficientemente grande de modo que a busca
exaustiva (busca em largura, busca em profundidade, etc) seja proibitiva, pois no
conseguiriam encontrar uma soluo em um tempo computacional aceitvel.
As heursticas agilizam a busca de uma soluo pois utilizam de
informaes para escolher os ramos, dentre todos os ramos de uma rvore de
espao de estados, que possuem uma maior probabilidade de levarem a uma
soluo aceitvel para o problema (LUGER, 2004). No entanto, elas possuem um
revs, que a possibilidade de no ser encontrada uma soluo tima, ou ento
nem mesmo encontrar-se uma soluo. Isto pode ser contornado utilizando
heursticas ou algoritmos de busca mais eficientes (Garey e Johnson, 1979 apud
LUGER, 2004 pg.134).
Considere o jogo-da-velha. Uma busca exaustiva tera uma quantidade
de 9! ou 362880 jogadas. Esta ainda no uma quantidade to grande se
comparada ao tamanho do espao de busca de um jogo mais complexo como o
xadrez. No entanto, podemos reduzir drasticamente o espao de busca utilizando
uma heurstica simples: supondo que estejamos realizando a jogada do jogador X,
escolhemos sempre a posio que garante a X o maior nmero de vitrias
possvel.
42

Figura 8 heurstica para o jogo da velha
Segundo a heurstica do maior nmero de vitrias, a jogada escolhida
dentre as trs acima devera ser a segunda (4 vitrias). O limite superior
aproximado para a quantidade de estado utilizando essa tcnica de 72 estados
um nmero consideravelmente inferior quantidade inicial de 9! (nove fatorial)
estados.
Um algoritmo que utiliza a heurstica do maior nmero de vitrias a
subida de encosta:
As estratgias de subida de encosta expandem o estado corrente da busca
e avaliam os seus filhos. O melhor filho selecionado para expanso futura; nem os seus
irmos nem os seus pais so considerados. A busca pra quando ela alcana um estado
que melhor que qualquer um de seus filhos (LUGER, 2004).
Um algoritmo heurstico muito utilizado em jogos, principalmente os de
estratgia e tiro em primeira pessoa o A* (l-se A estrela), que ser visto adiante
quando for abordado o tpico pathfinding.
4.7 Pathfinding
Pathfinding, ou busca de caminhos um dos problemas mais comuns
acerca do desenvolvimento de jogos, e est presente na maioria dos gneros. Boa
parte das entidades de IA precisam do pathfinding: sejam elas tanques, pessoas,
veculo ou unidade de combate. E no apenas para movimentao que se aplica
o pathfinding; podemos utiliz-lo tambm para resolver problemas como:
patrulhamento: consiste na movimentao de uma unidade
43
atravs de pontos pr-estabelecidos do cenrio e em ordem.
Isto faz com que as unidades paream mais vivas e aumenta
as suas chances de encontrar inimigos;
desvio de obstculos: requer que a unidade tenha
conhecimento do que est ao seu redor, de modo que evite
colises com este;
perseguio: fazer com que a unidade v em direo ao seu
alvo, como abordado no tpico Perseguio e Fuga;
mirar e atirar: um problema que ocorre quando uma unidade
tenta atingir a outra que obstculos podem interromper a
tragetria. Uma unidade inteligente dever prever a existncia
de um obstculo na rota de coliso do tiro antes de efetu-lo (ou
mesmo mover-se para uma posio aonde o mesmo possa ser
efetuado).
Um algoritmo tpico de pathfinding com desvio de obstculos em
pseudo-cdigo funciona da seguinte maneira:
Cdigo 7: algoritmo de pathfinding em pseudo-cdigo
Incio
ENQUANTO no chegou ao destino
ESCOLHA um local prximo rumo ao destino
SE o local est vazio, mova-se at ele
SENO escolha outra direo segundo estratgia de desvio de obstculos
FIM ENQUANTO
Fim


4.7.1 Estratgias para desvio de obstculos
O problema de pathfinding sera demasiadamente simples se no
houvesse o problema de desvio de obstculos. Os algoritmos estudados
anteriormente no captulo sobre perseguio e fuga poderam ser facilmente
adaptados para o pathfinding. No desvio de obstculos, as seguintes estratgias
44
podem ser adotadas:
escolher uma direo aleatria: se os obstculos forem
pequenos, convexos
7
e distribudos de maneira dispersa, esta
tcnica funciona satisfatriamente e requer pouco
processamento se comparado a outras abordagens. Entretanto,
para cenrios com muitos quartos e passagens estreitas entre
eles, o uso desta tcnica no recomendado, pois pode fazer
com que o agente fique preso ou demore muito tempo para
encontrar o caminho correto;
contornar o obstculo: o agente controlado pelo computador
seguiria utilizando um algoritmo simples de pathfinding at
encontrar um obstculo; ocorrendo isto, o mesmo entraria em
um estado de contorno, seguindo as bordas do obstculo na
tentativa de contorn-lo. O problema aqui consiste em saber
quando o algoritmo deve parar de contornar o objeto, caso
contrrio h o risco de se retornar ao ponto inicial (quando o
agente entrou no estado de contorno). Isto pode ser
solucionado traando uma linha reta entre a posio atual e a
posio de destino, no momento em que o obstculo for
encontrado; logo, quando esta reta for cruzada, o agente saber
que o obstculo foi contornado e assim ele retomar o trajeto
original utilizando o algoritmo de pathfinding.
calcular o caminho antecipadamente: os mtodos anteriores
geralmente so satisfatrios, mas no lidam com problemas
que incluem regies com peso, como terrenos cujos custos das
rotas so variados (STOUT, 1997); estes problemas so
resolvidos com algoritmos de teoria de grafos, como o Breadth-
first search (BFS), Depth-first search e Dijkstra.
_____________
7
Um poliedro convexo aquele que, dados quaisquer dois pontos pertencentes a ele, o segmento
contendo estes pontos nas extremidades dever estar inteiramente contido no poliedro.
45

Figura 9 - problema do ciclo no desvio de obstculos


Figura 10 - problema do ciclo resolvido


46
4.7.2 Algoritmo A*
Este um algoritmo muito importante, tanto pra IA tradicional quanto
para a IA para jogos. Motivo pelo qual um tpico especfico foi dedicado a ele. O A*
(pronuncia-se A estrela) um algoritmo admissvel, ou seja, para qualquer grafo
ele encontrar um caminho timo entre os estados inicial e final, caso exista um
caminho entre esses estados.
Para utilizar o A* em jogos, dividimos o terreno de um cenrio ou mapa
em pequenos quadrados (ladrilhos) de igual tamanho, e consideramos cada ladrilho
como sendo um n no grafo. A distncia total a ser percorrida no pathfinding
corresponde ao nmero de ladrilhos percorridos pela unidade do ponto (estado)
inicial ao final. Os ns-filho de cada n so representados pelos ladrilhos adjacentes
ao ladrilho em questo.
O A* mantm duas listas: a de ns abertos e a de ns fechados. A
primeira armazena todos os ladrilhos que precisam ser verificados, sendo que um
deles ser escolhido como o prximo n-destino da entidade segundo uma
estratgia de escolha; j a segunda, armazena os ns que no precisam mais
serem verificados no momento.
O algoritmo realizado da seguinte maneira:
1) coloca-se o n (ladrilho inicial) na lista de abertos;
2) feito isto, colocamos todos os seus ns adjacentes (filhos)
tambm na lista de abertos, ignorando aqueles ladrilhos que
representam paredes ou outras reas do cenrio que no so
alcanveis, bem como aqueles que j se incluem na lista de
ns fechados;
3) coloca-se o ladrilho inicial na lista de ns fechados;
47
4) escolhe-se um dos ns da lista de abertos para continuar o
algoritmo. O n atual feito pai do n escolhido, para que seja
possvel traar o caminho a ser percorrido pela entidade; a
estratgia para escolher este n ser vista adiante;
5) o processo se repete at que o n-destino seja adicionado
lista de abertos (neste caso, basta fazer o caminho inverso na
rvore de estados para encontrar o caminho, e o algoritmo
termina em sucesso), ou a lista de abertos fique vazia
(indicando falha na busca de um caminho).
O ponto crucial aqui escolher qual dos ns far parte do caminho a
ser percorrido. Isto feito utilizando uma funo de avaliao F(n). Esta funo
resultado da soma da distncia percorrida do n inicial ao n avaliado, G(n), com
uma funo heurstica, H(n), onde n representa o n avaliado:
H(n) G(n) F(n) + =

Equao 6: funo de avaliao do A*
H(n) pode ser estimado de vrias maneiras, no entanto, deve ser
sempre menor ou igual a G(n), subestimando o custo real para chegar ao n-
destino. Um exemplo de funo heurstica calcular a mesma utilizando uma linha
reta entre o n atual e o n-destino, ignorando obstculos intermedirios.
Feito isto, escolhemos, dentre os ns abertos, aquele n que possuir o
menor valor F(n). Se o n escolhido j estiver na lista de abertos, verificamos se o
valor de G, utilizando o n atual para se chegar at ele menor. Se isto for
verdadeiro, fazemos o n atual ser o pai do n escolhido e recalculamos os valores
F e G para este n; caso contrrio, nada precisa ser feito.
Lester (LESTER, 2003), prope o uso de algumas melhorias para o
algoritmo A* se tornar ainda mais eficiente:
custo de terreno varivel: nem sempre o menor custo significa
encontrar a menor distncia entre os dois pontos. Certos mapas
48
possuem certas caractersticas como rampas, relevo
acidentado, armadilhas, entre outras. Pode-se adaptar o
algoritmo acima para este problema adicionando o custo de
atravessar tais empecilhos funo custo G de um dado
ladrilho;
caminhos suaves: o caminho resultante do A* timo, mas nem
sempre o mais visualmente aceitvel. No clculo do caminho,
pode-se penalizar a escolha de ladrilhos que resultariam numa
mudana brusca de direo, adicionando um custo sua
funo G;
lidar com reas inexploradas: dependendo do jogo, sera muito
irrealstico o computador ter conhecimento de toda a topologia
do mapa, sabendo exatamente que caminho percorrer em todas
as ocasies; uma soluo manter um vetor de ns
conhecidos para o computador, ou seja, todos os ns contidos
neste vetor j foram explorados por ele, e o resto do mapa
presumido andvel, at provado o contrrio. Com esta
abordagem, as unidades iro cometer erros, entrar em becos,
at explorarem o espao ao seu redor. Quando o mapa for
explorado em toda sua extenso, o pathfinding ser executado
normalmente;
outras unidades: o A* considera apenas a topologia do terreno,
ignorando outras unidades. Por isso, necessrio adapt-lo
para que detecte a coliso com outros elementos do jogo.
4.8 Redes Neurais
Foi s recentemente que as redes neurais, ou RNs, comearam a ser
utilizadas em jogos comerciais. Devido falta de recursos disponveis tanto nos
PCs quanto nos consoles das geraes passadas, era prefervel utilizar tcnicas
49
mais simples e determinsticas na implementao da IA. Mas conforme o tempo foi
passando, tanto a quantidade de memria quanto de processamento disponvel
evoluiu muito, e agora cada vez mais comum o uso das redes neurais em jogos.
As redes neurais so baseadas no modelo de ligaes entre neurnios
dos seres vivos, onde que cada neurnio possui trs partes bsicas: dendrito, corpo
celular e axnio. O crebro possui aproximadamente 100 bilhes desses neurnios,
que se comunicam atravs de sinais eletro-qumicos. A troca de informaes entre
neurnios denominada sinapse, que a ligao entre o axnio de um neurnio
com o dendrito de outro. Quando um neurnio recebe um sinal, ele executa uma
espcie de clculo, que, ao ultrapassar um limiar, dispara o neurnio, e este envia
um sinal ao prximo neurnio da rede, atravs de seu axnio.

Figura 11 - Estrutura bsica de um neurnio
4.8.1 O neurnio artificial
Redes neurais so formadas por vrios neurnios artificiais. Um
neurnio artificial modelado semelhana de um neurnio biolgico. Cada
neurnio possui um conjunto de entradas, uma funo de ativao e uma sada.
Cada entrada do neurnio possui um peso associado.
O nmero de neurnios do qual a rede formada depende da tarefa
que ela ir desempenhar, podendo variar de poucos neurnios (3 ou 4) a milhares
deles. Em aplicaes da vida real, as RNs so utilizadas no reconhecimento de
50
padres, categorizao, aprendizado, competio, auto-organizao, entre outras
reas.
Uma vez criada a rede, ela dever ser treinada para que funcione da
maneira esperada. Treinar uma rede neural nada mais que ajustar os pesos, ou
seja, a fora entre suas conexes. Cada peso est associado a uma entrada do
neurnio, e representado por um nmero de ponto flutuante negativo ou positivo
(exercendo influncia excitatria ou inibitria) na entrada. Quando uma entrada
apresentada ao neurnio, ela multiplicada pelo seu peso. O neurnio ento soma
todas essas entradas, gerando um valor de ativao. Se este valor for maior que um
certo limiar, o neurnio gera um sinal de sada, que dependendo da topologia da
rede pode ser a sada desejada, ou uma sada que servir como entrada para outro
neurnio.

Figura 12 - neurnio artificial
As principais vantagens das redes neurais so:
tolerncia a falhas: as redes neurais podem ser treinadas para
reconhecerem padres distorcidos e at mesmo incompletos,
alm serem capazes de operar, at certo ponto, mesmo quando
parte da rede for danificada;
compatibilidade com a tecnologia atual: possvel treinar uma
rede para executar uma tarefa especializada e depois
implement-la em um hardware de baixo-custo. Assim, elas
51
poem ser facilmente inseridas em sistemas existentes;
auto-organizao: redes neurais possuem uma capacidade de
aprendizagem adaptativa, auto-organizando as informaes
recebidas. Isto permite que a rede responda satisfatoriamente
mesmo quando forem apresentadas informaes novas.
4.8.2 Redes neurais em jogos
At o momento, no existem tcnicas para modelagem de uma rede
com inteligncia complexa (ao nvel de um animal, por exemplo), mesmo sendo
possvel, com a tecnologia de hoje, montar uma rede com milhares de neurnios. A
maioria das aplicaes atuais de RNs utilizam cerca de uma dzia ou mais
neurnios, e elas so feitas para desempenhar tarefas especficas. E em jogos isto
no diferente. Redes neurais so usadas em conjunto com outras tcnicas,
executando tarefas que necessitam um certo grau de aprendizado ou para realizar
tarefas em que as unidades controladas pelo computador sejam menos previsveis.
Uma das redes mais utilizadas em jogos a rede feedforward de trs
camadas. Ela assim chamada devido ao fato de seus neurnios enviarem suas
sadas prxima camada at que seja obtida a sada final da rede.

Figura 13 - Rede feedforward de trs camadas
52
A rede possui uma camada de entrada, uma camada escondida e uma
camada de sada. No h restries quanto ao nmero de neurnios em cada
camada, e a quantidade ideal deles depende do problema a ser resolvido. Cada
neurnio da camada de entrada ligado a todos os neurnios da camada
escondida, e cada neurnio da camada escondida ligado a todos os neurnios da
camada de sada. Maiores detalhes sobre o clculo de funes de ativao, bem
como de outros tipos de RN pode ser encontrados em FREEMAN 1991.
A rede podera ser utilizada, por exemplo, para controlar a direo de
uma unidade, tendo como entrada as informaes enviadas por seus sensores
visuais e como sada, para qual direo a unidade deve seguir. Observe que
apenas a parte da tomada de deciso controlada pela RN. Para a movimentao
pode-se utilizar um algoritmo simples de perseguio e fuga. Veja abaixo uma
ilustrao para o problema.

Figura 14 - rede feedforward tripla camada controlando uma unidade

4.8.3 Mapeando o problema
Toda rede neural recebe como entrada um conjunto de nmeros reais.
O problema ocorre quando precisamos utilizar outros tipos de valores de entrada,
como enumeraes e valores lgicos verdadeiro/falso o que comum na
implementao de jogos.
53
O mapeamento pode ser feito utilizando os valores 0 (zero) para o
valor lgico falso e 1 (um) para o valor lgico verdadeiro. Quando a varivel for
uma enumerao, utiliza-se um vetor de entrada, sendo que cada posio do vetor
possui valor 0 ou 1. Por exemplo: se temos uma varivel enumerada que pode
assumir os valores espada, revlver e canho, por exemplo, teramos um vetor
de trs posies com os valores {0, 0, 1}, caso o valor desta varivel seja
canho, por exemplo (aqui assumimos que as variveis se excluem mutuamente,
no podendo assumir mais de um valor ao mesmo tempo). Se a enumerao
tivesse um valor revlver, o vetor de entrada sera {0, 1, 0}.
Quando nosso problema j se encontra no domnio contnuo, apenas
precisamos enviar suas variveis como entrada na rede neural. Deve-se atentar
para entradas com diferenas acentuadas entre seus elementos. Por exemplo, se
uma rede possuir uma entrada com valor 20 e outra com valor 200, pode-se obter
um valor influenciado pela entrada de maior valor. Para tal problema, pode-se dividir
ambas as entradas pelo maior valor (200), obtendo valores em termos percentuais.
4.9 Algoritmos Genticos
A pesquisa em algoritmos genticos, assim como as redes neurais,
outra rea da IA influenciada pela biologia. Ela baseada nos estudos sobre a
evoluo das espcies, de Charles Darwin, moldando a populao de indivduos
atravs da sobrevivncia dos membros mais aptos a viver naquele ambiente.
No mundo real, as espcies evoluem constantemente na tentativa de
melhor se adaptarem aos seus ambientes. Os seres mais fortes e capazes de
sobreviver passam adiante suas caractersticas para a prxima gerao. Tais
caractersticas so codificadas nos cromossomos. A gerao resultante fruto da
combinao de dois cromossomos da gerao atual, num processo denominado
crossover. Nessa combinao podem ocorrer mutaes aleatrias, e, se estas
mutaes contriburem para a sobrevivncia da espcie, elas sero tambm
passadas para as geraes futuras.
54
4.9.1 Algoritmos genticos em jogos
No desenvolvimento de jogos, os algoritmos genticos visam a busca
de uma soluo tima para um determinado problema. Cada um dos indivdios
mencionados anteriormente so possveis solues para o problema em questo.
Geralmente, os algoritmos genticos so utilizados quando se deseja uma IA que
atue mesmo em situaes no previstas pelo desenvolvedor, como em tomadas de
deciso de acordo com o comportamento do jogador. Para problemas como o do
pathfinding, (nos quais j existem algoritmos slidos para sua resoluo) no
recomendado o uso dos algoritmos genticos, pois estes so mais custosos
computacionalmente.
A implementao dos algoritmos genticos em jogos pode ser dividida
em quatro etapas, que so a inicializao da populao, validao da aptido,
seleo e evoluo.
1) Inicializao: primeiramente, preciso definir um modo de codificar
os cromossomos da populao de criaturas de IA que iremos criar. Esta codificao
pode ser feita de maneira simples, utilizando um vetor de caracteres; cada ndice do
vetor pode representar uma caracterstica do ambiente externo e o valor contido
nesta posio representa a ao que a criatura dever executar.
Exemplo: Suponha que a populao de criaturas controladas pelo
computador tenham que responder de acordo com a arma em uso pelo jogador
(espada, arco, lana e machado), e as respostas possveis so: usarEscudo (1),
ataqueComEspada (2), fugir (3), esconder (4) e ataqueComArco (5). Ento os
cromomossomos destas criaturas sero representados por um vetor de quatro
posies, onde a posio 1 contm o identificador da ao a ser executada caso o
jogador tenha uma espada, a posio 2 ser executada caso o jogador tenha um
arco, e assim por diante. Cada posio do vetor assume um valor de 1 a 5.
Na etapa de inicializao, espera-se obter uma populao com alto
grau de variabilidade gentica, portanto atribui-se valores aleatrios para os
cromossomos. Veja o exemplo da tabela abaixo.
55
Tabela 2 exemplo de codificao de um cromossomo
Arma Espada Arco Lana Machado
Ao [1..5] [1..5] [1..5] [1..5]
Definidos os mtodos de codificao dos genes da populao,
inicializamos ela conforme descrito acima, com valores aleatrios para os
cromossomos das criaturas. Note que o exemplo acima possui apenas quatro
situaes possveis. Numa aplicao real poderamos ter um nmero muito maior
de situaes a considerar.
2) Validao da aptido: nesta etapa do processo evolucionrio, deve-
se avaliar quais indivduos da populao so os mais aptos a resolver o problema
em questo. Para isto, utilizamos uma funo de avaliao de aptido (tambm
denominada funo fitness). Para o exemplo acima, uma boa funo avaliao
contabilizar a diferena entre o dano que a criatura causou ao jogador e o dano
recebido. As criaturas com a maior aptido segundo esta funo tero a maior
probabilidade de passar seus genes gerao seguinte.
3) Seleo: nesta etapa utilizada a funo calculada na etapa
anterior para que sejam escolhidos os indivduos que participaro do processo
evolucionrio. Na vida real, geralmente dois pais contribuem com seus
cromossomos para a gerao seguinte. J no mundo dos jogos, podemos escolher
qualquer nmero dentre os melhores indivduos (segundo a funo de aptido).
4) Evoluo: nesta ltima etapa, sero criados os novos indivduos que
sero introduzidos no ambiente do jogo. So selecionados os melhores indivduos
e combinados seus genes no processo de crossover. Aqui tambm so introduzidas
mutaes aleatrias. Observe a tabela abaixo.
56
Tabela 3 exemplo de crossover
Pai 1 Pai 2 Filho
5 3 5
4 1 1
3 5 4
4 2 2
Observe que no terceiro cromossomo do indivduo resultante (terceira
linha da tabela) a caracterstica no foi herdada de nenhum dos pais. Isto
resultado de uma mutao aleatria. Por exemplo, na hora do crossover, podemos
fazer com que a caracterstica resultante tenha, digamos, 5% de chances de ser
gerada aleatriamente, ou seja, no estando presente em nenhum dos indivduos
da gerao anterior.
Agora o algoritmo retornar segunda etapa, e a cada iterao, sero
criados indivduos mais aptos a enfrentar o jogador em diferentes situaes.
A implementao do algoritmo gentico resumida abaixo, em
pseudo-cdigo.
Cdigo 8: algoritmo gentico em pseudo-cdigo
Procedimento algoritmo gentico
Incio
Inicialize a populao;
Enquanto a condio de parada no for satisfeita faa
Incio
Avalie a aptido de cada indivduo da populao;
Selecione os membros da populao com base na aptido;
Produza os descendentes destes pares;
Introduza esses descendentes na populao
Fim
Fim

57
4.10 Flocking
bastante comum na implementao de jogos a necessidade de
prover uma movimentao em grupos para personagens controlados pelo
computador, principalmente em jogos de estratgia e RPG. Estes grupos podem ser
de animais, pessoas, unidades de combate, entre outros. claro que tambm
possvel implementar esse tipo de movimentao com scripts bem elaborados, mas
a utilizao de flocking elimina a necessidade de criar um script para controlar cada
criatura do jogo ao invs disso, precisamos de apenas um script para controlar o
grupo como um todo.
Um algoritmo bsico de flocking foi apresentado por Craig Reynolds,
em seu artigo de 1987 intitulado Flocks, Herds, and Schools: A Distributed
Behavioral Model. A idia principal do algoritmo fazer os NPCs moverem-se de
maneira coerciva, como se houvesse um objetivo em comum o oposto de se ter
vrias unidades movendo-se de maneira independente, sem coordenaao alguma.
Para determinar a direo resultante de cada unidade, cada unidade
controlada pelo flocking mantm informaes sobre outras unidades em um raio
circular de tamanho pr-definido, centrado na prpria unidade. Este raio
denominado rio de vizinhana (neighborhood radius) (BUCKLAND, 2005). Ainda
segundo BUCKLAND, flocking tambm bastante utilizado em filmes, como em
Batman Returns e O Senhor dos Anis.
As trs principais regras que regem o algoritmo de flocking so:
separao, alinhamento e coeso:
separao: uma fora que faz com que as unidades
mantenham certa distncia uns dos outros, evitando colises
com seus vizinhos;
alinhamento: mantm a direo de cada unidade alinhada
direo de seus vizinhos. Isto feito calculando-se a mdia dos
58
vetores de direo de cada vizinho e subtraindo-se desta mdia
a direo atual da unidade. O resultado a direo que a
unidade deve seguir para manter-se em rumo com seus
vizinhos;
coeso: um tanto similar regra anterior, mas neste caso a
unidade dirige-se ao centro de massa (posio mdia) de seus
vizinhos. A mdia calculada levando em considerao o vetor
de posies dos vizinhos. O vetor resultante o centro de
massa da vizinhana e indica a posio qual a unidade deve
se dirigir.
Flocking considerado uma rea de estudo da Artificial Life, ou
simplesmente A-Life (vida artificial).
[...] Artificial Life (Alife) basicamente procura estudar a vida e suas
propriedades no computador criando a vida digitalmente dentro do computador,
simulando-a ou ambos. Alife pode ser especialmente interessante para pessoas de outras
reas como a teoria do caos, pois muitos aspectos so comuns entre ambas as reas.
(MATTHEWS, 2002, trad.nossa).
Para emular a vida, a A-Life faz uso de tcnicas como algoritmos
genticos, flocking, sistemas baseados em regras, entre outras. O comportamento
das criaturas dividido em problemas menores, que so mais tarde unidos por uma
hierarquia de decises que cada uma delas possui, determinando que aes devem
ser feitas para satisfazer suas necessidades. Segundo Woodcock (2000):
[...] as interaes que ocorrem entre comportamentos de baixo-nvel,
explicitamente codificados e as motivaoes/necessidades dos personagens causa o
surgimento de um comportamento de alto-nvel, mais inteligente, sem qualquer
programao explicta ou complexa. (trad.nossa).
59
5 ALGORITMOS DE IA PARA JOGOS ESTADO DA ARTE
Com o surgimento de placas aceleradoras grficas 3D para lidar
especificamente com grficos pesados, hoje h uma fatia muito maior da CPU para
processamento da IA. Alm disso, bons grficos deixaram de ser um diferencial e
passaram a ser algo essencial para o sucesso de vendas do produto. Deste modo,
a IA acaba tornando-se esse grande diferencial entre um produto e outro.
Segundo Woodcock, (1999) na maioria das empresas j existem
equipes especializadas em desenvolver a IA para o jogo algo incomum h pouco
tempo atrs. Em estdios menores, onde no h recursos financeiros para tal,
contratado pessoal terceirizado para trabalhar com a IA mostrando uma viabilidade
mercadolgica para pesquisadores de IA neste segmento.
Ultimamente, tem-se procurado muito a implementao de IA no-
determinstica, devido sua menor previsibilidade e de sua capacidade de aprender
com o jogador. Estes, por sua vez, esperam unidades de IA cada vez mais
inteligentes e desafiadoras, sem o uso de cheating.
A seguir, apresentaremos os principais tpicos de estudo da IA para
jogos atualmente.
IA extensvel: presente principalmente nos jogos de tiro em primeira
pessoa, um grande nmero de jogos recentes tem apresentado esta tcnica. Com
ela os jogadores podem criar sua prpria IA, seja atravs de uma linguagem script
criada especialmente para o jogo ou atravs de uma interface mais simples, pela
qual o jogador define o comportamento do computador. Exemplos de sucesso so
os jogos Quake e Unreal. Existem muitos lugares na internet aonde os jogadores
compartilham suas criaturas criadas atravs de IA extensvel aumentando o tempo
de vida til do produto.
Pathfinding: o algoritmo A* continua sendo o mais utilizado para o
pathfinding, seja na sua forma padro ou com a incluso de algumas modificaes
60
a comunidade de jogos considera este problema bem resolvido, e agora busca
implementaes especficas para cada jogo.
Atualmente, o que mais se tem pesquisado nesta rea a incluso da
anlise de terreno em pathfinding. A anlise de terreno procura por caractersticas
naturais do cenrio, como lugares para emboscadas e combates, recursos naturais,
entre outras; tais caractersticas so usadas na criao de um pathfinding mais
robusto.
Formaes: com o crescente sucesso de jogos de simulao militar,
este tpico tem sido alvo de muito estudo por desenvolvedores de IA. O objetivo
fazer grupos de unidades militares comportarem-se de maneira realstica. Sistemas
baseados em regras, flocking, mquinas de estado finito e lgica nebulosa so as
tcnicas preferidas devido a uma maior facilidade na implementao e testes, em
detrimento de tcnicas como algoritmos genticos e redes neurais.
A-Life e seu modo de quebrar o problema em situaes menores
tambm tem sido muito utilizada, dando uma viso hierrquica ao desenvolvimento
da IA. Jogos como Starfleet Command (Interplay) e Force 21 (Red Storm) utilizam
esta tcnica. Nesses jogos, as unidades so divididas em grupos, onde cada um
deles possui um comandante; as ordens cada grupo so interpretadas pelo
comandante, que ento atribui comandos cada unidade individualmente.
Aprendizagem: futuramente, espera-se criar jogos que evoluam
constantemente, aprendendo com o jogador e melhorando suas aptides mesmo
aps sarem das prateleiras. Existem dois principais problemas com relao a isso:
um deles a dificuldade de testar o produto, pois o comportamento de uma rede
neural, por exemplo, pode ser imprevisvel; outro problema a possibilidade de que
a IA, aps certo tempo de treinamento com o jogador possa tornar-se estpida ou
at mesmo difcil demais para o jogador uma soluo podera ser a incluso de
uma opo pela qual o jogador pudesse reiniciar o aprendizado da mquina para
suas configuraes de fbrica.
Outra abordagem para o problema a criao de um banco de dados
61
de situaes passadas, como foi feito no jogo Magic & Mayhem, da Mythos Games.
Diante da necessidade de atacar o jogador, o jogo recorre ao seu banco de dados
procurando aquelas estratgias que surtiram efeito em situaes parecidas que
ocorreram anteriormente.
Alguns jogos utilizam redes neurais que so treinadas pelos prprios
desenvolvedores e que so mais tarde desligadas antes de chegarem ao
consumidor. Tal abordagem pode criar uma boa IA, mas infelizmente anula
qualquer possibilidade de aprendizagem com o jogador.
Tambm importante ressaltar que os algoritmos genticos tm sido
pouco utilizados recentemente, ficando sua implementao mais limitada aos jogos
simuladores de vida. Mas em seu lugar, as tcnicas de flocking e A-Life continuam
sendo bastante utilizadas na IA para jogos.
62
6 CONCLUSO
bastante evidente a importncia que a IA tem mostrado na
implementao de jogos. Devido ao fato dos grficos deixarem de ser um grande
diferencial e devido aos avanos de hardware, h cada vez mais espao para a
implementao de tcnicas outrora consideradas muito acadmicas para uma
implementao comercial. Tambm pode-se observar cada vez mais a utilizao de
tcnicas no-determinsticas em conjunto com j conhecidas tcnicas como as
mquinas de estado finito, scripts e sistemas baseados em regras.
Muito se argumentava sobre a possibilidade da criao de jogos multi-
jogador via rede fazer com que as pesquisas em IA ficassem estagnadas, pois,
jogar contra humanos muito mais desafiador que faz-lo contra o computador. No
entanto, j foi comprovado que, seja por questes financeiras ou mesmo pessoais,
muitos ainda preferem jogar contra a mquina.
Futuramente, espera-se que a IA aprenda cada vez mais com o
jogador, utilizando redes neurais artificiais e at mesmo os algoritmos genticos,
que at o momento tm sido pouco utilizados, salvo em implementaes
especficas. Mesmo em tpicos em que j existem algoritmos de sucesso como o
pathfinding e seu A*, ainda h muito a ser pesquisado, o que torna esta uma rea
de pesquisa bastante promissora. E o resultado dessas pesquisas a criao de
jogos cada vez mais divertidos.
63
REFERNCIAS BIBLIOGRFICAS
BOURG, David; SEEMAN, Glenn. AI for Game Developers. OReilly, 2004.
BROWNLEE, Jason. Finite State Machines (FSM). AI Depot. Disponvel em:
<http://ai-depot.com/FiniteStateMachines/FSM.html>. Acesso em 15 out. 2005.
BUCKLAND, Mat. Programming Game AI by Example. Texas, EUA: Wordware
Publishing, Inc, 2005.
BUCKLAND, Mat. AI Techniques for Game Programming. Cincinnati, Ohio. EUA:
Premier Press, 2002.
CHAMPANDARD, Alex. AI Game Development: Synthetic Creatures with
Learning and Reactive Behaviors. New Riders Publishing, 2003.
FREEMAN, James A.; SKAPURA, David M. Neural Networks: Algorithms,
Applications and Programming Techniques. Loral Space Information Systems
and Adjunct Faculty, School of Natural and Applied Sciences University of Houston at
Clear Lake: Addison-Wesley Publishing Company, 1991.
LESTER, Patrick. A* Pathfinding for Beginners. GameDev.net. Disponvel
em:<http://www.gamedev.net/reference/articles/article2003.asp>. Acesso em 8 mar.
2005.
LUGER, George F. Inteligncia Artificial: estruturas e estratgias para a soluo
de problemas complexos. - 4.ed. - Porto Alegre: Bookmann, 2004.
MCCARTHY, John. What is Artificial Intelligence?. Stanford University, Computer
Science Department, 2004. Disponvel em:<http://www-
formal.stanford.edu/jmc/whatisai/>.
MCNEIL, Martin F.; THRO, Ellen. Fuzzy Logic: A Practical Approach. Chestnut
Hill, MA, EUA: AP Professional, 1994.
RUSSEL, Stuart J.; NORVIG, Peter. Inteligncia Artificial: Uma Abordagem
Moderna. So Paulo: Editora Campus, 2004.
STOUT, Brian. Smart Moves: Intelligent Pathfinding. Gamasutra, 1997. Disponvel
em:< http://www.gamasutra.com/features/19970801/pathfinding.htm>. Acesso em 24
mai. 2005.
WOODCOCK, Steve. Game AI: The State of the Industry. Gamasutra, 1999.
Disponvel em:<http://www.gamasutra.com/features/19990820/game_ai_01.htm>.
Acesso em 18 mai. 2005.
WOODCOCK, Steve. Game AI: The State of the Industry. Gamasutra, 2000.
Disponvel em:<http://www.gamasutra.com/features/20001101/woodcock_01.htm>.
Acesso em 18 mai. 2005.
64
BIBLIOGRAFIA CONSULTADA
CHAMPANDARD, Alex. The Future of Game AI: Intelligent Agents. Disponvel
em:< http://ai-depot.com/GameAI/Agent-Intelligence.html>. Acesso em 16 out. 2005.
FUNGE, John D.; TU, Xiaoyuan. Hardcore AI for Computer Games and
Animation. In: SIGGRAPH, 1998. Wesmont, Illinois. EUA.
LAMOTHE, Andre. Building Brains into Your Games. Gamasutra. Disponvel em:
<http://www.gamasutra.com/features/19970601/build_brains_into_games.htm>.
Acesso em 18 mai. 2005.
MATTHEWS, James.How to Get Started with Artificial Life. Generation5, 2002.
Disponvel em:<http://www.generation5.org/content/2002/howto04.asp>. Acesso em
1 nov. 2005.
PINTO, Paulo. Minimax Explained. AI Depot. Disponvel em:
<http://ai-depot.com/LogicGames/MiniMax.html>. Acesso em 2 nov. 2005.
SALTZMAN, Marc. Game Creation and Careers: Insider Secrets from Industry
Experts. New Riders Publishing, 2004.
SMITH, Leslie. An Introduction to Neural Networks. Centre for Cognitive and
Computational Neuroscience. University of Stirling. Disponvel
em:<http://www.cs.stir.ac.uk/~lss/NNIntro/InvSlides.html>. Acesso em 8 mar. 2005.
65
ANEXOS
ANEXO A Algoritmo de Bresenhan
void ai_Entity::BuildPathToTarget (void)
{
int nextCol=col; //col e row so valores iniciais do caminho
int nextRow=row;

//endRow e endCol so coordenadas de destino
//deltaRow e deltaCol so usados para determinar a direo
int deltaRow=endRow-row;
int deltaCol=endCol-col;
int stepCol, stepRow;
int currentStep, fraction;

for (currentStep=0;currentStep<kMaxPathLength; currentStep++)
{
//inicializao dos vetores do caminho
pathRow[currentStep]=-1;
pathCol[currentStep]=-1;
}

currentStep=0;
pathRowTarget=endRow;
pathColTarget=endCol;

//determina a direo usando os deltas
if (deltaRow < 0) stepRow=-1; else stepRow=1;
if (deltaCol < 0) stepCol=-1; else stepCol=1;

deltaRow=abs(deltaRow*2);
deltaCol=abs(deltaCol*2);

//inicia o caminho com as coordenadas atuais do predador
pathRow[currentStep]=nextRow;
pathCol[currentStep]=nextCol;
currentStep++;

if (deltaCol >deltaRow) //determina qual eixo o mais longo
{
fraction = deltaRow *2-deltaCol;
while (nextCol != endCol)
{
if (fraction >=0)
{
nextRow =nextRow +stepRow;
fraction =fraction -deltaCol;
}

nextCol=nextCol+stepCol;
fraction=fraction +deltaRow;
pathRow[currentStep]=nextRow;
pathCol[currentStep]=nextCol;
currentStep++;
}
}
else
{
66

fraction =deltaCol *2-deltaRow;
while (nextRow !=endRow)
{
if (fraction >=0)
{
nextCol=nextCol+stepCol;
fraction=fraction -deltaRow;
}

nextRow =nextRow +stepRow;
fraction=fraction +deltaCol;
pathRow[currentStep]=nextRow;
pathCol[currentStep]=nextCol;
currentStep++;

}
}

}