Danilo Cezar Alves da Fonseca Silva 0802449 8 Semestre

UMA METODOLOGIA PARA USO DE AGENTE INTELIGENTE NA SOLUO DE PROBLEMAS ENVOLVENDO JOGOS. (Labirinto)

Jaguarina 2008

Danilo Cezar Alves da Fonseca Silva 0802449 8 Semestre

UMA METODOLOGIA PARA USO DE AGENTE INTELIGENTE NA SOLUO DE PROBLEMAS ENVOLVENDO JOGOS. (Labirinto)

Monografia apresentada disciplina Trabalho de Graduao, do curso de Cincia da Computao da Faculdade de Jaguarina, sob orientao do Prof. Silvio Petroli Neto, como exigncia para concluso do curso de graduao.

Jaguarina 2008
1

SILVA, Danilo Cezar Alves da Fonseca. Uma metodologia para uso de Agente Inteligente na soluo de problemas envolvendo jogos (Labirinto). Monografia defendida e aprovada na FAJ em 10 de dezembro de 2008 pela banca examinadora constituda pelos professores:

Prof. Silvio Petroli Neto Orientador FAJ - Faculdade de Jaguarina

______________________________________________

_____________________________________________ Prof. MS. Guilherme Palermo Coelho FEEC- Unicamp

_____________________________________________ Prof. MS. Christiane Novo Barbato FAJ - Faculdade de Jaguarina

Aos meus pais: Roberto e Cida, e meus irmos: Aglis e Marcelo. Pessoas incrveis, cuja pacincia, compreenso e amor, me auxiliam trilhar o caminho do bem apoiando verdadeiramente as minhas escolhas.

AGRADECIMENTO
Agradeo em primeiro lugar a Deus, por presentear-me com uma vida repleta de realizaes, pelas oportunidades em minha vida e por me dar foras para superar todos os obstculos que encontro nos caminhos que escolho. Agradeo aos meus pais, Roberto e Cida, pois me deram a vida e me ensinaram a viv-la com dignidade, iluminaram o meu caminho com afeto e dedicao para que eu trilhasse sem medo e cheio de esperana, se doaram inteiros e renunciaram aos seus sonhos para que eu e meus irmos pudssemos realizar os nossos, porque como verdadeiros amigos sempre me deram fora e me ajudaram a vencer. Aos meus irmos, Aglis e Marcelo, pelo incentivo e pela pacincia. Aos meus amigos que surgiram durante esses anos de curso que se fizeram presentes quando precisei: Diogo, Allen e Carlo. Sei que encontrei amizades verdadeiras que permanecero para o resto de nossas vidas. A tia Ju, que, com todo o carinho e amizade, me ajudou a conseguir esse incrvel material em um formato impresso justamente nos momentos em que no pude estar presente para faz-lo. Ao meu orientador Silvio Petroli Neto, pela ajuda com seu conhecimento, pacincia e dedicao na realizao deste trabalho. A todos os professores, que ao longo desses quatro anos, partilharam comigo seus conhecimentos, e me fizeram me apaixonar cada dia mais pela Cincia da Computao. Aos meus velhos amigos e a todos aqueles que, embora no mencionados aqui, contriburam de maneira direta ou indireta para a concretizao deste projeto, muito obrigado.

Conhea-te a ti mesmo Scrates

SILVA, Danilo Cezar Alves da Fonseca. Uma metodologia para uso de Agente Inteligente na soluo de problemas envolvendo jogos (Labirinto). Monografia (Bacharelado em Cincias da Computao) Curso de Cincias da Computao da Faculdade de Jaguarina, Jaguarina.

RESUMO
Durante algum tempo tentou-se representar formalmente a idia de pensamento para que os seres conseguissem representa-lo computacionalmente. O fato de se estudar, na computao, esta rea do pensamento o que conhecemos pelo estudo da Inteligncia Artificial, uma rea muito jovem. Dentre os estudos desta rea, surgem os agentes inteligentes que consistem de mecanismos de buscas inteligentes e que se construdos coerentemente so capazes de fornecer resultados esperados de forma muito rpida. Muito utilizados em jogos como, por exemplo, em situaes quando se precisa trilhar um determinado caminho para se atingir o alvo ou quando precisa-se perseguir algo que est em movimento e dentre outras aplicaes. Portanto neste trabalho ser aplicada uma soluo simples para o problema do jogo do labirinto, onde o resultado final apresentar o melhor caminho para se atingir a sada. Palavras chaves: INTELIGNCIA ARTIFICIAL, AGENTE INTELIGNTE, LABIRINTO

LISTA DE FIGURAS
FIGURA 1: Exemplo estado inicial e final...........................................................................17 FIGURA 2: Posio das peas do puzzle...........................................................................17 FIGURA 3: rvore de estados (Puzzle)..............................................................................18 FIGURA 4: O labirinto, estado inicial e final ........................................................................20 FIGURA 5: Apresentao do labirinto no prompt de comando...........................................20 FIGURA 6: Identificando movimentos.................................................................................22 FIGURA 7: Clculo do movimento......................................................................................22 FIGURA 8: Mtodo de Manhattan......................................................................................23 FIGURA 9: Custo da distncia para atingir B.....................................................................25 FIGURA 10: Custo do movimento para atingir B..................................................................25 FIGURA 11: Variveis globais do labirinto............................................................................27 FIGURA 12: Matrizes do labirinto.........................................................................................28 FIGURA 13: Blocos de condies........................................................................................29 FIGURA 14: Matriz tabuleiro................................................................................................30 FIGURA 15: Condies para realizar movimento................................................................30 FIGURA 16: Calculando o custo dos ns vizinhos...............................................................31 FIGURA 17: Calculando o menor custo...............................................................................32 FIGURA 18: rvore para visualizao do movimento 1.......................................................33 FIGURA 19: rvore para visualizao do movimento 2.......................................................33 FIGURA 20: Varivel guia para condio de chegada.........................................................34 FIGURA 21: Comportamento recursivo 1.............................................................................34 FIGURA 22: Comportamento recursivo 2.............................................................................35 FIGURA 23: Armazenando o melhor caminho estimado......................................................35 FIGURA 24: Caminho sem sada.........................................................................................36 FIGURA 25: Executando nova pesquisa..............................................................................36 FIGURA 26: Encontrando a sada........................................................................................38

SUMRIO
RESUMO ...............................................................................................................................6 LISTA DE FIGURAS ............................................................................................................7 1. INTRODUO..................................................................................................................9 1.1 Motivao ....................................................................................................................... 10 1.2 O Problema ..................................................................................................................... 10 1.2.1 Formas de resolver o problema ............................................................................... 11 2. INTELIGNCIA ARTIFICIAL....................................................................................... 12 2.1 Mecanismos de busca ..................................................................................................... 14 2.1.1 Buscas no-informadas............................................................................................ 14 2.1.2 Buscas informadas................................................................................................... 15 2.2 Algoritmo A*(star) ..................................................................................................... 15 3. O Labirinto .......................................................................................................................18 3.1 Navegao pelo Labirinto........................................................................................... 20 3.2 Calculando g ............................................................................................................... 20 3.3 Calculando h ............................................................................................................... 22 3.4 Calculando f................................................................................................................ 24 3.5 O Agente Inteligente................................................................................................... 26 4. DISCUSSO ....................................................................................................................38 5. concluso ..........................................................................................................................39 6. REFERNCIAS BIBLIOGRFICAS .............................................................................40 APNDICE I labirinto 1 ...................................................................................................41 APNDICE II labirinto 2 ..................................................................................................42 APNDICE III O cdigo fonte .........................................................................................43

1. INTRODUO
Em muitas empresas, sendo elas pequenas, mdias, grandes ou multinacionais, precisa-se de um controle do desperdcio de tempo, em relao movimentao de mercadorias, tanto no caso de transportes de produtos para o comrcio, como tambm o transporte de cargas de combustveis, matrias primas e equipamentos em geral. Pode-se entender que, dentro de uma empresa existe uma grande preocupao com relao ao desempenho de sua equipe de logstica em conseguir, diariamente, conquistar os menores custos de tempo e combustvel para a entrega de seus produtos a seus clientes/consumidores. Nesse caso, essas equipes se utilizam de algoritmos para atingir os menores caminhos entre cidades, ou pases, ou ainda caminhos de menor custo possvel, dependendo da urgncia da entrega do produto. Esses caminhos so determinados pelas interligaes entre pontos, representados pelas cidades ou pases. Os caminhos de interligao so chamados de arestas, e quanto aos pontos so chamados de ns. A existncia de ns interligados atravs de arestas implica a definio de Grafos. Em relao ao tema proposto, encontramos a mesma dificuldade para encontrar o melhor caminho para a soluo do problema do labirinto, que aqui representa tambm um problema de logstica. Ficando assim, a critrio do algoritmo de busca desenvolvido, conseguir, atravs de recursos e conhecimentos prprios, percorrer o labirinto de um grafo e encontrar a melhor soluo para o problema. Desta forma ele ser capaz de atingir o final do labirinto (sada) percorrendo o caminho de menor custo. Percebe-se que, resolver esse tipo de problema, envolve desenvolver algoritmos consistentes com caractersticas associadas inteligncia comportamental dos seres humanos. Essas caractersticas se do pela compreenso da linguagem, o aprendizado, o raciocnio e resoluo de problemas. [RUSSEL, 2004]. Esses algoritmos inteligentes so denominados agentes. Segundo RUSSEL (2004),
Um agente simplesmente algo que age. No entanto espera-se que um agente computacional tenha outros atributos que possam distingui-los de meros programas, tais como operar sob controle autnomo, perceber seu ambiente, persistir por um perodo de tempo prolongado, adaptar-se a mudanas e ser capaz de assumir metas de outros. Um agente racional aquele que age para alcanar o melhor resultado ou, quando h incerteza, o melhor resultado esperado.

O grafo gerado no problema representa os estados de solues possveis. Cada n do grafo representa um estado e o agente inteligente dever encontrar qual o menor caminho do estado inicial at o estado final (soluo do problema).

1.1 Motivao
Ao longo dos anos a indstria de jogos, que atinge um pblico cada vez menos jovem, vem aumentando significativamente. Segundo estimativas da Associao de Softwares de Entretenimento (ASE), divulgadas em maio de 2006, com base nos dados da consultoria Price Waterhouse Coopers, indicou que em 2004 as vendas totais da indstria atingiram U$ 10,3 bilhes de dlares, sendo U$ 7,7 bilhes dlares referente indstria de jogos e eletrnicos. O ndice de crescimento na rea de desenvolvimento de jogos at 2010 se manter alto, pois foi previsto que at l os Estados Unidos tero cerca de 75 milhes de jogadores. Economicamente, a indstria de jogos tambm ter indcio de crescimento referente ao emprego nesta rea, que dever pular 144 mil empregados para 265 mil at o final de 2009. [IDGNOW,2006] Segundo a companhia francesa UBISOFT (2008),
Ubisoft aposta que os prximos anos sero especialmente otimistas para o mercado mundial de videogames. "Pode haver um pico nos mercados dos consoles em 2009, o que significa um pico no mercado de games em 2010 ou 2011", disse Yves Guillemot em entrevista Reuters.

E quanto a ABRAGAMES (2008),

Observa-se um crescimento significavo do setor nos ltimos dois anos e a expectativa de um crescimento ainda maior em 2009, graas recente vinda de estdios internacionais para o Brasil.

Portanto torna-se interessante o estudo na rea de jogos, que, alm de ser uma rea a qual economicamente acredita-se em um constante crescimento na indstria, se encaixa perfeitamente o estudo da Inteligncia Artificial aplicada a jogos.

1.2 O Problema
O problema a ser estudado envolve elementos computacionais relacionados a grafos e conseqentemente Inteligncia Artificial conforme proposto. Existe um caminho a ser percorrido dentro de um universo de possibilidades. O universo do jogo nada mais que um conjunto de linhas e colunas formando uma tabela. Os espaos linha/coluna podem ser chamados de clulas. Dentro de cada clula existem informaes a respeito do mundo ao redor da clula corrente. Essas informaes so importantes para identificar onde esto localizadas as paredes e os corredores de um labirinto. O objetivo do jogo estimar o melhor caminho at a sada desse labirinto. Para resolver esse problema surgiu a idia de se criar um algoritmo inteligente/agente inteligente capaz de resolver o problema da mesma forma em que um ser
10

humano o faria. Neste caso, ao invs de um jogador interagir com o labirinto, um agente inteligente ser inserido nesse labirinto para descobrir a sada e resolver o jogo. O algoritmo deve ter o conhecimento de como solucionar o problema da melhor forma possvel. A cada novo jogo pode ser modificado o universo onde o agente ser inserido, no entanto este agente ser capaz de resolver o problema da mesma forma em que um ser humano faria.

1.2.1 Formas de resolver o problema

A necessidade de se criar um algoritmo para resolver o problema do labirinto, da mesma forma que um ser humano faria, indica, para este caso, a possibilidade de se aplicar algoritmos utilizando Inteligncia Artificial (IA). Durante a pesquisa feita, pode-se identificar que existem alguns tipos de algoritmos que possivelmente resolveriam o problema deste jogo. Dentre os algoritmos a serem estudados esto os algoritmos de busca heurstica do tipo Best-Search First, conhecidos por Busca Gulosa e algoritmo A* (star). Porm, o enfoque deste trabalho ser dado somente ao algoritmo A* (star) enquanto a Busca Gulosa ser apenas comentada. Um algoritmo de busca heurstica se difere de algoritmos de busca mais comuns, pois ele no percorre todos os estados de um dado problema, na verdade ele estima os melhores estados para a soluo do problema. A busca gulosa um tipo de busca informada que, atravs de uma funo h1, seleciona um n baseado na estimativa feita pela funo heurstica h tentando expandir apenas o n mais prximo do n objetivo no expandindo os ns fora do caminho. Semelhante busca em profundidade por escolher seguir um nico caminho at o objetivo, ela pode se perder e nunca retroceder para fazer a busca em novos ns. No considerada completa, pois pode entrar em loop infinito e no encontrar a soluo e tambm no tima por no garantir o melhor caminho. O algoritmo de busca A* ao invs de utilizar apenas uma funo que busca obter foradamente o melhor caminho como a busca gulosa o faz, ele utiliza duas funes que informam quantos estados do problema ela j resolveu estimando quantos estados ainda faltam para atingir de melhor forma possvel o estado objetivo. Essa estimativa para alcanar o estado objetivo tem de ser coerente, pois no se pode estimar um valor de custo de caminho maior do realmente vale, e ainda essa estimativa tem de ser um pouco menor, mas prxima do valor real do custo. No superestimar o custo indica que uma busca admissvel. [RUSSEL,2004] O algoritmo escolhido para solucionar da melhor maneira possvel o problema do jogo do labirinto foi o algoritmo de busca A*(star) por ser bem conhecido e bastante difundido na rea de jogos.
11

2. INTELIGNCIA ARTIFICIAL
Apesar de reconhecida como sendo uma disciplina bastante nova na rea da cincia e da computao no se sabe ao certo a data precisa de quando se iniciou o estudo relacionado a IA. Tendo em vista que, a Inteligncia Artificial se dirige a diversos estudos para se conseguir produzir mquinas e sistemas inteligentes capazes de produzir comportamento e raciocnio humano, primeiramente teria que se estudar o funcionamento da mente do homem e entender como ele pensa. Sendo assim comumente a todas as outras disciplinas existentes para explicar de alguma forma o mundo que nos envolve, a Inteligncia Artificial, no diferente, possui suas razes anexadas Filosofia desde Aristteles (384-322 a.C.). Segundo RUSSEL (2004),
Aristteles (384-322 a.C) foi o primeiro a formular um conjunto preciso de leis que governam a parte racional da mente. Ele desenvolveu um sistema informal de silogismos para raciocnio apropriado que, a princpio, permitiram gerar concluses mecanicamente, dadas as premissas iniciais.

Esses silogismos forneceram padres para estruturas de argumentos que, ao receberem premissas corretas, sempre resultavam em concluses corretas. Exemplificando, o filsofo sugere o seguinte silogismo implicando a lgica de que se Scrates um homem; todos os homens so mortais; ento, Scrates mortal. O estudo das leis do pensamento que trabalha essa abordagem se defronta com alguns obstculos, dentre eles est a dificuldade em representar o conhecimento informal em termos formais exigidos pela lgica, assim como a diferena entre resolver os princpios de um problema e resolver o mesmo problema na prtica. Sendo este ultimo relacionado capacidade computacional para resoluo do problema. O fato de a inteligncia exigir ao implica que essa ao provenha de um raciocnio prvio e correto. Um sistema inteligente precisa pensar racionalmente e agir racionalmente. Porm nem sempre uma ao representar uma racionalidade correta. Isso ocorre em situaes onde se faz necessria aes que envolvam reflexo e que no requerem nveis de racionalidade. Por exemplo, quando tocamos um objeto quente ou quando giramos o volante numa situao inesperada durante um passeio de carro, agimos por reflexo sem que exista um raciocnio correto prvio, a ao muito rpida e no garante sucesso. A partir dos silogismos de Aristteles surge o estudo do campo da lgica, e, desta forma, conseqentemente surgem maiores estudos e trocas de idias entre filsofos contribuindo para o progresso desta rea. Porm, apesar dos filsofos demarcarem a maioria das idias importantes sobre a IA, mais adiante exigiu-se um certo nvel de formalizao matemtica em trs reas fundamentais. A lgica, a computao e a probabilidade.
12

As definies de Inteligncia Artificial so diversas e afirma-se que esta rea interessante, mas no descrevemos ao certo o que ela . Alguns autores arriscam algumas definies interessantes que de alguma forma exemplifica o que seria a descrio da IA apesar de toda sua complexidade. De acordo com Poole (1998) A inteligncia Computacional o estudo do projeto de agentes inteligentes. O primeiro trabalho reconhecido como IA realizado por Warren McCulloch e Walter Pitts a partir de 1943 a 1955 em que eles propuseram um modelo de neurnios artificiais onde mostram como exemplo que qualquer funo computvel podia ser calculada por uma rede de neurnios conectados, e que todas as conexes lgicas podiam ser implementadas por estrutura de redes simples e sugeriram tambm que tais redes definidas adequadamente seriam capazes de aprender. A partir de ento surgiram vrios trabalhos que podem ser considerados de carter da IA, porm em 1950 foi Alan Turing quem articulou uma viso completa da IA onde ele apresenta a aprendizagem de mquinas. Esse importante trabalho proposto por Alan Turing em 1950 sugere um teste baseado na impossibilidade de se distinguir, atravs de uma comunicao via computador, entre um sistema provido de inteligncia a um ser humano. O sistema passar no teste se uma pessoa, atravs do teclado, ao interrogar o sistema no conseguir distinguir atravs das respostas dadas se ela esta conversando com um ser humano ou com o computador. Para se projetar um sistema para o teste de Turing o computador precisaria ter capacidade de processar a linguagem natural, um idioma, conseguir armazenar o que sabe ou ouve, raciocinar automaticamente e conseguir aprender. Um teste de Turing total inclui sinais de vdeo, viso de computador para perceber objetos e robtica para manipular objeto como tambm para mover-se. [RUSSEL,2004] O nascimento da Inteligncia Artificial acontece em Princeton durante o famoso seminrio do Dartmouth College. O termo usado "Inteligncia Artificial" foi criado por John McCarthy durante este evento que tomou aproximadamente dois meses do vero de 1956. Este seminrio foi o primeiro encontro de cientistas organizado oficialmente apenas para discutir assuntos de inteligncia e tambm sua implementao. Durante aqueles meses conseguiu-se alguns experimentos relativamente bem sucedidos, mesmo tendo como suporte computadores no to potentes e linguagens de programao disponveis. Um dos desenvolvimentos mais significativos dos anos que se seguiram foi o GPS (General Problem Solver), criado por Allen Newell e Herbert Simon para simular os mtodos humanos de resoluo de problemas. [INTELLIWISE,2006] Dentre vrios outros estudos e tcnicas utilizadas em Inteligncia Artificial, tendo em vista a idia de pensamento, raciocnio e ao, preciso se fazer pesquisas antes de executar as aes. Quando agimos, precisamos conhecer nossos objetivos, aquilo que queremos fazer. Logo depois de traarmos metas de como atingir nossos objetivos da
13

melhor maneira possvel, somente da ento agimos. Essa forma inteligente de agir em relao a determinado problema, leva aos sistemas inteligentes a necessidade de se utilizar mecanismos de busca para uma melhor soluo. O sistema inteligente proposto para resolver o problema do jogo do labirinto um sistema baseado em mecanismos de buscas.

2.1 Mecanismos de busca

Alguns tipos de problemas para serem solucionados passam por determinados estados, gerando assim o que conhecemos por rvores ou grafos, onde cada n desta rvore ou grafo representa um estado. O mecanismo de busca um mtodo algortmico no qual se busca o estado final de um problema partindo se do estado inicial. [GANASCIA,1997]

2.1.1 Buscas no-informadas

As buscas no-informadas so tipos de busca que percorrem todos os estados possveis de uma arvore ou grafo para encontrar a soluo. Os algoritmos mais comuns so os de busca em largura e profundidade. As buscas no-informadas so consideradas completas, pois so capazes de encontrar a soluo se esta existir. Porm no so consideradas timas, porque apesar de percorrerem todos os estados possveis no garantem o melhor custo para solucionar o problema. Uma busca em largura um mtodo de busca no-informada que expande e verifica todos os ns de uma rvore, em busca de uma soluo. Podemos dizer que o algoritmo realiza uma busca exaustiva numa rvore inteira, at que ele encontre o objetivo. Este tipo de busca considerada completa apenas se a rvore a ser pesquisada tiver um nmero finito de ns e a busca alcanar todos esses ns. E considerada tima se o custo da pesquisa for o menor possvel. J um algoritmo de busca em profundidade realiza uma busca no-informada que expande do primeiro n filho da rvore e se aprofunda at atingir o n objetivo ou at que ele se depare com um n que no possui filhos (n folha). Desta forma a busca retrocede (backtrack) e comea no prximo n. [RUSSEL,2004]

14

2.1.2 Buscas informadas

Buscas informadas em geral utilizam funes heursticas especficas para solucionar tipos diferentes de problemas. Uma heurstica capaz de estimar o melhor caminho provendo menor custo a partir do n inicial ao n final. As funes de busca informada tambm so baseadas em objetivo, porm durante uma pesquisa a funo heurstica faz uma estimativa determinando quanto melhor um caminho para atingir o n objetivo em relao a outro caminho qualquer. [ARARIBOIA,1989] Vale lembrar que as heursticas no retornam o valor exato referente ao melhor caminho, mas atentam estimando o menor custo, pois conseguem durante a pesquisa quantificar o custo do caminho a ser percorrido do n inicial at o n final. Avaliamos um tipo de busca heurstica segundo sua completude, a sua complexidade temporal, a sua complexidade de memria e se ela tima. - A completude de uma busca refere-se ao fato de que se existir uma soluo para o problema o algoritmo de busca ir de certo encontr-la (completa). - A complexidade temporal refere-se demora ou eficincia do tempo que a busca levar para encontrar a soluo para o problema. - A complexidade da memria refere-se questo de quanto de memria ser necessrio para se fazer a busca. - A busca tima quando encontrada a melhor soluo quando esta existe. [RUSSEL,2004] O algoritmo de busca heurstica que veremos a seguir conhecido pelo nome A*(star), que ser o mtodo utilizado para solucionar o problema do jogo do labirinto.

2.2 Algoritmo A*(star)

A busca pela melhor escolha conhecida pelo nome A*, avalia os estados de um problema combinando uma funo que verifica o custo para alcanar cada estado, a uma funo que verifica o custo para ir do estado n corrente a at o estado objetivo. Pode-se construir ento a funo heurstica A* desta forma: f(n) = g(n) + h(n) Onde g(n) fornece o custo do caminho desde o estado inicial at o estado n corrente, e h(n) fornece o custo estimado do caminho de custo mais baixo desde o estado n corrente at o estado objetivo. Desta forma encontramos f(n), que indica o custo estimado da soluo

15

de custo mais baixo deste o estado n corrente ao estado objetivo, ou seja, uma estimativa da soluo completa. Uma busca A* considerada tima desde que a sua funo heurstica h(n) satisfaa certas condies. Ser tima somente se a heurstica for admissvel. Uma busca admissvel indica que a busca no superestimar o custo real de uma soluo ao passar pelo estado n corrente para alcanar o estado objetivo do problema. [RUSSEL,2004] Um exemplo para entender o funcionamento da heurstica o problema do jogo de quebra-cabea de 8(oito) peas, onde o objetivo mover os blocos nos sentidos vertical ou horizontal para um espao vazio organizando os nmeros at que se atinja o estado objetivo que geralmente a ordem crescente de 1(um) 8(oito). Ser preciso identificar todos estados possveis para todas as jogadas. Quando o espao do meio esta vazio temos quatro possibilidades de jogadas, quando o espao de algum dos cantos est vazio temos duas possibilidades de jogadas e quando o espao de alguma borda est vazio temos trs possibilidades de jogadas. Como segue o exemplo. [COSTA, 2004] Temos o estado inicial e o estado objetivo referente ao jogo de quebra-cabeas.

Estado inicial

Estado objetivo

FIGURA 1: Exemplo estado inicial e final Podemos observar que existem 4 (quatro) peas fora do lugar que precisam ser movidas para satisfazer o estado objetivo. Elas so as peas de n 2, 8, 1 e 6. E as nicas peas que, no estado inicial, se encontram nas posies corretas, so as peas de n 3, 4, 5 e 7.

Estado inicial

Estado objetivo

FIGURA 2: Posio das peas do puzzle Uma busca heurstica A*(star) para este caso poder identificar atravs de uma funo g(n) o estado em que se encontra o problema, que inicialmente o estado igual a 0

16

(zero). Neste caso tambm poder identificar atravs de uma funo h(n) as peas que esto fora do lugar que precisaro ser organizadas. A funo g(h) precisar decidir qual n/estado ir expandir a pesquisa, mas para isso ela precisar da informao da funo h(n) que retornar, para cada estado selecionado, os nmeros de peas que esto fora do lugar. Da ento o algoritmo ter de analisar cada estado e expandir o n que provavelmente contiver o menor nmero de peas fora do lugar. Pode acontecer, em determinado instante em um mesmo nvel de uma rvore, de dois estados A e B conter um mesmo nmero de peas fora do lugar. Se o primeiro n A expandido contiver outros estados de menor valor de peas fora do lugar, a pesquisa prosseguir por estes ns, mas caso contrrio a pesquisa retornar ao n B para verificar melhores possibilidades. [RUSSEL,2004] A rvore de estados a que se segue.

FIGURA 3: rvore de estados (Puzzle) Perceba que ao lado de cada estado existem dois nmeros informando a situao de cada estado. Neste exemplo, se analisarmos o primeiro estado, verificamos que existe o nmero 0 (zero) mais (+) o nmero 4(quatro). O nmero 0 (zero) o resultado oferecido pela funo g(n) que indica quantos estados j foram percorridos em relao ao estado inicial. Se
17

este 0 (zero) isso significa que este estado o estado inicial. Em contrapartida, o nmero 4(quatro) o resultado oferecido por h(n) que indica quantas peas ainda esto fora do lugar. Percebe-se que para cada estado expandido o nmero fornecido por g(n) incrementado em um, sendo que o nmero fornecido por h(n) pode ser o mesmo ou pode ser diferente para cada estado expandido. O critrio utilizado para expandir o n est implcito nos resultados da funo heurstica A* f(n) = g(n) + h(n). Antes de escolher o n a expandir, a heurstica f(n) retorna uma estimativa dos valores de todos os ns a expandir. Ento se verifica o estado de menor valor estimado para expanso. Existiro casos em que a pesquisa ter de retroceder a busca para um n anterior, ao verificar que os valores dos ns expandidos so maiores ou iguais ao estado que os expandiu. Como em nossa imagem de exemplo quando g(n) igual a 4(quatro) e h(n) igual a 1(um) indicar que o resultado estimado de f(n) igual a 5(cinco). Ao expandir esse n o prximo estado mais esquerda tambm ser igual a 5(cinco). Ento a pesquisa retroceder para verificar outro n de menor valor, porm o que ela encontra um n de valor estimado 7(sete) maior que o esperado. Sendo assim a busca volta para o estado de estimativa de igual valor 5(cinco) em que j estava. Verifica-se ento que neste ultimo estado o h(n) igual a 0 (zero), que significa que no existe mais nenhuma pea fora do lugar. O problema foi resolvido atravs do melhor caminho possvel. [DEPARTAMENTO DE INFORMATICA, 2008]. Esta busca considerada admissvel porque no superestima o valor real da soluo do problema. E considerada completa e tima porque alm de atingir o objetivo esperado ela tambm encontra o melhor caminho para atingir a esta soluo do problema.

3. O LABIRINTO
O jogo de labirinto proposto, desenvolvido em linguagem C, consiste de um vetor dinmico bidimensional simples de tamanho 10x10, onde cada clula, ou n, representa cada estado por onde o agente inteligente decidir passar ou no para atingir o estado final (a sada do labirinto). Durante o estudo realizado, foi focada somente a parte funcional do sistema, no existiu uma preocupao quanto parte grfica do mesmo. Portanto, para esse sistema no existe uma viso grfica atraente para a sua visualizao. Nesse caso, para as paredes do labirinto, os caminhos a serem percorridos, o caminho percorrido e o melhor caminho sero levados em considerao apenas valores numricos. No entanto, se existisse uma interface grfica mais agradvel o labirinto proposto nesse trabalho poderia ser visualizado conforme descrito na figura 4. Onde, os blocos cinza representam as paredes, os blocos brancos
18

representam os corredores e os blocos vermelhos e verdes representam o estado inicial e final respectivamente.

FIGURA 4: O labirinto, estado inicial e final A princpio conheceremos os valores que representam nosso labirinto, e como, computacionalmente, o agente compreender o que caminho e o que parede. Ser construdo um labirinto o qual ser nomeado de tabuleiro. Este tabuleiro ser o responsvel por conter a localizao dos corredores e paredes do labirinto e tambm por informar a posio inicial, onde se encontra nosso agente inteligente, e a posio final que a soluo para o problema (a sada do labirinto). Segue os valores que representaro nosso labirinto: - Os corredores (passagens livres) sero representados pelo valor 0 (zero), numrico do tipo inteiro. - As paredes sero representadas pelo valor 1 (um), numrico do tipo inteiro. - O estado inicial ser representado pelo valor 5 (cinco), numrico do tipo inteiro. - O estado final ser representado pelo valor 3 (trs), numrico do tipo inteiro. - Os caminhos j percorridos sero representados pelo valor 9 (nove), numrico do tipo inteiro. - O melhor caminho ser representado pelo valor 8 (oito), numrico do tipo inteiro. Essa representao visual, para o sistema proposto, apresentada na tela do prompt de comando (MS-DOS) conforme descrito na figura 5. Porm sero utilizados desenhos com um visual mais amigvel para fins didticos.

19

FIGURA 5: Apresentao do labirinto no prompt de comando

3.1 Navegao pelo Labirinto

No incio do sistema, aps a inicializao das variveis, o agente inteligente dever solicitar uma chamada a uma funo, enviando para esta os valores referentes sua posio inicial (x, y). Aps verificar algumas condies relacionadas qual caminho seguir, essa funo ir solicitar uma chamada a ela mesma e repetir as verificaes de condies e chamadas recursivas de funo at que o melhor caminho estimado seja encontrado. [NEVES, 2008] Conforme citado no pargrafo anterior, importante lembrar que esse algoritmo inteligente foi desenvolvido com base em operaes recursivas. A recursividade pode ser entendida com um mtodo utilizado para se resolver problemas atravs da repetio de procedimentos. No caso deste algoritmo, ele consiste de uma funo que apresenta condies para tomada de deciso e que pode chamar a si mesma. Portanto o algoritmo recursivo deve dividir o problema em vrios outros problemas menores, resolvendo os menores para conseguir atingir o resultado esperado se este existir. No entanto, vale lembrar que uma condio de parada deve ser considerada para que o algoritmo entenda quanto ao termino de uma chamada funo, caso contrrio o algoritmo poder permanecer em recursividade infinita. [NEVES, 2008] Conforme NEVES (2008),
Recurso o processo pelo qual uma funo chama a si mesma repetidamente um nmero finito de vezes.

A navegao atravs do labirinto proposto baseia-se na movimentao do agente em relao s posies x e y da matriz tabuleiro, sendo que este movimento depender de determinadas condies. Quanto s direes de movimentao, foi proposto apenas movimentos ortogonais (vertical e horizontal), pois o labirinto possui corredores muito estreitos no possibilitando movimentos na diagonal. Para determinar qual caminho seguir, o algoritmo A*(star) depender do resultado retornado pela funo heurstica f = g+ h.

3.2 Calculando g
Dividir a rea de procura em linhas e colunas para este tabuleiro, representa a simplificao dessa rea de pesquisa para encontrar o melhor caminho. Pois nesse contexto, essa rea est sendo representada por um conjunto de quadrados de tamanhos iguais colados uns aos outros. Esta rea ainda poderia ser representada por um conjunto de
20

outras formas geomtricas diferentes, como por exemplo, hexgonos, tringulos, entre outras. Porm, para calcular as distncias entre os ns ser utilizada a forma do quadrado. Simplifica porque o custo do movimento d-se pelo clculo da distncia entre dois pontos e utilizando quadrados perfeitos teremos sempre o mesmo custo para cada tipo de movimento (diagonais e ortogonais). Entretanto, para se entender melhor o clculo da distncia entre um quadrado e outro deve se imaginar a existncia de pontos exatamente posicionados no centro de cada quadrado conforme representado na figura 6. Esses pontos representam os ns ou estados do problema a ser solucionado.

FIGURA 6: Identificando movimentos Perceba que as ligaes entre esses pontos formam semi-retas. Essas semi-retas indicam a direo do movimento e seu custo que possivelmente pode ser executado em um ambiente representado por quadrados. Ainda fica visvel que as ligaes entre esses pontos considerando os movimentos diagonais, formam tringulos retngulos. Portanto, para calcular o custo de g para movimentar de um ponto a outro, aplicou-se o teorema de Pitgoras para calcular as distancias em relao a movimentos ortogonais e diagonais. [DANTE, 2001]

FIGURA 7: Clculo do movimento Portanto para se calcular o custo do movimento em um ambiente simples semelhante a este proposto, pode ser utilizado o valor 1 para custo dos movimentos ortogonais e 1,41 para os movimentos diagonais. [DANTE, 2001] No entanto importante observar que o valor 2 referente ao custo do movimento da diagonal pode ser considerado oneroso dependendo da complexidade do problema. Por ser um nmero irracional este deve ser representado computacionalmente por variveis do tipo
21

ponto flutuante e termos de processamento seria mais aconselhvel a utilizao de nmeros inteiros. Neste caso para evitar calcular a raiz quadrada poderia ser utilizada uma soluo mais simples, porm no considerada cem por cento correta, que multiplicar esses valores por 10. Ter-se-ia para o custo dos movimentos ortogonais os valores 10 e 14 para os movimentos ortogonais e diagonais respectivamente. Porm, para este trabalho sero considerados apenas os movimentos ortogonais, pois os corredores do labirinto proposto so muito estreitos e no permitem movimentos na diagonal. O movimento diagonal foi esclarecido apenas por fins didticos para se compreender os custos de cada movimento.

3.3 Calculando h
Para que exista a possibilidade de se obter resultados satisfatrios para se estimar o melhor caminho possvel atravs da funo heurstica, calcular somente o custo g para o movimento no o suficiente para atingir tal objetivo. Deve-se calcular o custo h da distncia entre um determinado ponto A e outro B considerando suas coordenadas (x, y) onde esto localizados. Sabe-se que o menor caminho entre dois pontos A e B um segmento de reta. Dado esses dois pontos apresentando-os em um plano cartesiano, possvel encontrar o valor da distncia entre eles. Porm, para este caso especfico no ser possvel realizar o clculo da distncia utilizando uma frmula geomtrica analtica (euclidiana). Pois a geometria analtica (euclidiana) desconsidera obstculos entre os pontos (A,B) considerando apenas a distncia entre esses dois pontos de uma forma direta traando uma semi-reta AB. Por esse motivo, optou-se pela utilizao de uma frmula geomtrica no-euclidiana representada pelo Mtodo de Manhattan no sentido em que a idia de distncia no a mesma traando-se uma semi-reta direta de A para B. O Mtodo de Manhattan deve considerar os obstculos encontrados entre esses dois pontos. O agente no poder percorrer o caminho direto de A para B. Primeiramente ele ter de visitar outros pontos at atingir o ponto B. Essa distncia percorrida diferente da euclidiana. [DEVITO,2008]

22

FIGURA 8: Mtodo de Manhattan Repare a figura 8. A semi-reta verde apresentada nesta imagem liga os pontos A e B diretamente. Ela representa a o clculo da distncia entre dois pontos, considerado pela geometria analtica (euclidiana). Pode ser representado atravs da seguinte forma:

Distncia Euclidiana = Onde B. Os segmentos de reta de cor azul tambm so responsveis por ligar os pontos A e B, porm o faz indiretamente. Perceba que, para calcular essa distncia entre os pontos A e B existem vrios outros pontos intermedirios. Isso ocorre porque a geometria noeuclidiana representada pelo mtodo de manhattan leva em considerao os obstculos encontrados entre esses dois pontos. Esse clculo pode ser representado atravs da seguinte forma: Distncia de Manhattan = Onde , so as coordenadas de um determinado ponto X e , so as , so as coordenadas do ponto A e , so as coordenadas do ponto

coordenadas de um determinado ponto Y at que A atinja B. Ou seja, A W B, onde W representa os pontos intermedirios entre A e B. Note que a geometria euclidiana admite apenas um percurso, enquanto a geometria no-euclidiana utilizando o Mtodo de Manhattan admite vrios percursos.

23

3.4 Calculando f
O clculo de f d-se pela funo f = g + h. Para esclarecer o funcionamento desta funo ser apresentado agora um exemplo simples levemente relacionado ao problema proposto. Deve se imaginar um universo simples onde se parte de um ponto inicial pretendendo-se atingir um ponto final. Considera-se que, por conta de alguns obstculos, so fornecidos quatro pontos A, W, Z e B e que, para atingir o ponto final B, partindo do ponto A, existem dois caminhos possveis, W e Z . Supondo-se que o agente precisa sair do ponto A e chegar ao ponto B. Primeiramente calcula-se a diferena entre a coordenada x do n a ser alcanado (B) e a coordenada x do ponto corrente (A, W ou Z). Aps calcular as diferenas entre as coordenadas x para esses dois pontos calcula-se tambm a diferena entre as coordenadas y para ambos os pontos. Ao obter os resultados das diferenas entre x e y de cada ponto em relao ao ponto final, soma-se esse resultado. O total resultante o valor da distncia entre determinado ponto at atingir o ponto B conforme a figura 9.

FIGURA 9: Custo da distncia para atingir B Considera-se que a distncia entre: - A e B igual a 50. - Z e B igual a 30. - W e B igual a 20. Agora que se tem conhecimento da distncia entre cada ponto (A, W e Z) e o ponto final (B) possvel determinar qual o melhor caminho para se atingir o ponto B. Para isso deve-se utilizar o clculo de g em conjunto ao clculo de h para se obter f. Neste exemplo ser considerado os seguintes custos para G:

FIGURA 10: Custo do movimento para atingir B

24

- O custo do movimento para se mover de A Z igual a 1. - O custo do movimento para se mover de A W igual a 2. - O custo do movimento para se mover de Z B igual a 1. - O custo do movimento para se mover de W B igual a 1. Aps obter os valores de h e g possvel entender o funcionamento da funo heurstica. Sabe-se que o valor inicial de f igual a f = 0 + 50, portando f = 50, ou seja, o custo estimado para atingir o ponto B de 50. Lembrando que, nenhum passo foi dado ainda. Para decidir qual caminho seguir, deve-se comparar os caminhos possveis a seguir para atingir o ponto B. Analisando os valores de h e g obteremos os resultados de f para o primeiro movimento: - A partir de A Z, sendo g igual a 1 e h igual a 30. A funo heurstica ser montada: f = 1 + 30; - A partir de A W, sendo g igual a 2 e h igual a 20. A funo heurstica ser montada: f = 2 + 20; Portando a heurstica deve comparar qual dos dois ns possuem o menor custo estimado. O resultado obtido de AZ = 31 e AW=22. Nesse caso o algoritmo deve escolher o caminho AW antes de chegar em B. Analisando os resultados perceba que o custo total de movimentos de g , partindo do ponto A, para atingir o ponto B passando por Z igual a 2, enquanto o custo total de movimentos de g passando por W igual a 3. Ou seja, em relao ao custo do movimento o ideal seria passar por Z j que este custo menor que o custo do movimento atravs de W. O que influenciou o algoritmo escolher o caminho atravs de W foi o custo de h para este caso. Pois o algoritmo, ao verificar os valores de h para os pontos Z e W, estimou que distncia restante para atingir o ponto B partindo do ponto W menor do que a distncia restante partindo do ponto Z. Porque quando o agente est localizado em W, ainda resta 20 para chegar em B e quando o agente est em Z, ainda resta 30 para chegar em B. Perceba que a heurstica estimou o melhor caminho possvel para atingir B. Pois, saindo do ponto A para atingir o ponto B passando por W obteve-se o custo estimado para f = 22 enquanto que partindo do ponto A para atingir o ponto B passando por Z obteve-se o custo estimado para f = 31. Nesse instante decidiu-se caminhar atravs de W.

25

3.5 O Agente Inteligente

Agora, neste ultimo captulo, ser descrito o funcionamento do algoritmo proposto. Optou-se por utilizar somente um arquivo cpp composto por apenas duas funes, apresentando a prpria funo principal main() e a funo encontrar_caminho(int ,int) que implementa o algoritmo A* (star). Logo no incio do sistema foram declaradas variveis globais para simplificar o problema. Pois, ao realizar uma chama funo encontrar_caminho(int ,int) no existir preocupao alguma referente aos tipos de variveis ou quanto forma que devero ser enviadas as informaes para essa funo. Portanto, a cada item que sofrer alteraes dentro dessa funo, ser refletido em todo o sistema. Alm disso, os nicos parmetros que sero enviados a ela, sero as coordenadas x e y. Abaixo sero descritas as variveis globais do sistema e quais suas utilidades.

FIGURA 11: Variveis globais do labirinto No primeiro bloco de variveis globais sero encontradas algumas variveis de controle para o algoritmo. As variveis i e j, do tipo inteiro, foram declaradas como globais, porm somente para manter uma certa organizao no cdigo. Elas servem apenas para inicializar as matrizes utilizadas pelo algoritmo. A varivel chegou, do tipo inteiro, uma das variveis mais importantes do algoritmo. Ela representa um guia, pois inteiramente responsvel por informar ao sistema se foi j atingido o ponto final esperado, que nada mais que a soluo para o problema. A funcionalidade desta varivel ser explanada mais adiante no ponto em que discutiremos o algoritmo A*(star). Perceba agora que as prximas variveis globais foram declaradas com o tipo const, pois elas no sofrero alteraes durante a execuo do algoritmo. Essas variveis so denominadas constantes.

26

As constantes larguraX e alturaY, do tipo inteiro,

representam a quantidade de

linhas e colunas que sero aplicadas s matrizes. Essas duas constantes poderiam ser resumidas a apenas uma constante de valor igual 10 (dez) definida com o nome Tamanho, levando em considerao que o algoritmo trabalha apenas com matrizes quadradas. Porm, por questes de visualizao e melhor entendimento do sistema optou-se pela utilizao individual para as dimenses. A constante FIM, do tipo inteiro, como o prprio nome acusa, responsvel por informar ao algoritmo que a sada do labirinto foi encontrada. Essa constante responsvel pelo valor que receber a varivel chegou que ainda veremos mais a frente neste documento. A constante parede, do tipo inteiro, apenas informa as paredes do labirinto. Foi utilizada para que a visualizao das funcionalidades do algoritmo ficassem mais claras, evitando assim a utilizao de muitos nmeros para representar o labirinto. Repare que muitas outras constantes tambm seguem essa mesma lgica de nomenclatura justamente para facilitar a leitura do cdigo. A constante ja_passou, do tipo inteiro, representa os caminhos onde o algoritmo j percorreu. A cada movimento atravs das clulas ou ns do labirinto, armazenado o valor 9 (nove) para esse n. Durante a iterao da funo recursiva ela ser til quanto deciso de qual caminho tomar. Se o algoritmo j passou por aquele caminho no precisar passar novamente se o n corrente apresentar o valor ja_passou. A constante maior_custo, do tipo inteiro, auxilia o algoritmo na tomada de decises, que so aquelas que se referem a qual caminho pegar identificando o menor custo. Essa varivel apenas uma auxiliar para encontrar o custo de menor valor. A constante melhor_caminho, do tipo inteiro, tem uma finalidade semelhante constante j_passou e est relacionada diretamente com a varivel chegou j descrita nesse captulo. A sua utilidade a representao do melhor caminho encontrado pelo algoritmo que estar sendo guiado pela varivel achou. As constantes inicialX, InicialY, finalX e finalY, do tipo inteiro, representam as coordenadas do ponto inicial, onde est inicialmente localizado o agente, e as coordenadas do ponto final que a sada do labirinto. As constantes do ponto inicial sero utilizadas apenas uma vez, que durante a primeira chamada da funo heurstica. No caso das constantes do ponto final sero utilizadas apenas para auxiliar o calculo os valores de h. Seguindo com o cdigo, em seguida sero apresentadas as matrizes que sero utilizadas no sistema e suas utilidades.

27

FIGURA 12: Matrizes do labirinto A matriz caminho, do tipo inteiro, responsvel por guardar toda a informao referente aos caminhos que podem ser percorridos no labirinto. Essa matriz na verdade uma cpia idntica da matriz tabuleiro que a matriz principal do sistema. Apesar de ser uma cpia do labirinto, sua utilidade de marcar os caminhos j percorridos pelo algoritmo. Ela deve gravar em sua posio (x, y) corrente os valores referentes s variveis j_passou e melhor_caminho. A matriz guarda_caminho, do tipo inteiro, tambm uma cpia da matriz tabuleiro. Porm, nela ser gravado somente o melhor caminho encontrado pelo algoritmo para fins de impresso do melhor caminho na tela do sistema. Poderia ter sido utilizada a prpria matriz tabuleiro para tal finalidade. A matriz menor_custo, do tipo inteiro, responsvel por armazenar os custos dos ns vizinhos ao n corrente. Atravs dos resultados obtidos referente aos custos dos ns vizinhos o algoritmo decidir qual caminho seguir. A matriz F, do tipo inteiro, responsvel por armazenar os valores de menor custo estimado para cada movimento do agente. A matriz G, do tipo inteiro, responsvel por armazenar o custo do movimento para cada passo que o agente executar. A matriz H, do tipo inteiro, responsvel por armazenar o valor mais baixo estimado da distncia para todas as posies em relao ao n final. Basicamente essas so as variveis julgadas necessrias para se resolver o problema proposto. A seguir ser descrita toda a estrutura do sistema conforme figura 13.

28

FIGURA 13: Blocos de condies Conforme j descrito, o sistema possui apenas duas funes. A funo principal e a funo heurstica que implementa o algoritmo A*(star). A funo principal tem como funcionalidade a inicializao das variveis e matrizes do sistema. atravs dela que se torna possvel a chamada para a funo heurstica A*(star). Alguns itens so configurados nessa funo principal antes que a chamada funo heurstica seja solicitada. Portanto, inicializado a matriz tabuleiro informando os possveis caminhos e suas paredes.

FIGURA 14: Matriz tabuleiro Aps a declarao da matriz tabuleiro so criadas duas cpias dessa matriz que so as matrizes caminho e guarda_caminho j descritas anteriormente. Aps a configurao dessas cpias, so inicializadas com o valor zero as matrizes F e G e com o valor 999 (novecentos e noventa e nove) a matriz menor_custo. Essa ultima configurada com um custo alto, pois servir de base para o clculo do menor custo estimado pela funo heurstica. Logo em seguida efetuado o calculo de h para todas as posies da matriz. Esse clculo poderia ser executado durante as verificaes da funo heurstica, mas resolveu-se calcular h antes da chama a funo apenas para tornar o cdigo mais limpo.
29

A funo heurstica tem como finalidade encontrar o melhor caminho possvel dentro do universo proposto. Aps verificadas e configuradas as variveis na funo principal, o sistema est pronto para chamar a funo heurstica. Essa funo bem simples. Ela deve receber apenas dois parmetros, inicialX e inicialY, que representam o ponto inicial onde est localizado nosso agente inteligente. O agente precisa percorrer os ns at atingir o n objetivo. Esse trajeto se d atravs das movimentaes das coordenadas x e y da matriz caminho conforme condies impostas pela funo heurstica. Para entender o movimento ser apresentado na figura 15 um bloco de exemplo.

FIGURA 15: Condies para realizar movimento Perceba que dependendo das condies encontradas em determinado instante, ser indicado se o algoritmo dever executar um movimento horizontal para a direita (x+1, y), um movimento horizontal para a esquerda (x-1, y), um movimento vertical de subida (x, y+1) ou um movimento vertical de descida (x, y-1). Essas verificaes a essas condies para execuo do movimento devem ser executadas todas as vezes em que o for necessrio o movimento para o prximo n. Alm da condio de parada, existem dois tipos de blocos de condies que influenciam na deciso de qual caminho tomar. No primeiro bloco tem-se:

FIGURA 16: Calculando o custo dos ns vizinhos Essa clausula if verifica, antes que o algoritmo possa tentar executar qualquer movimento, se o prximo n a ser visitado caminhvel, onde caminho[x+1][y] != 1. Ainda dever verificar se este n seguinte j no foi visitado. E por ultimo ele verifica se o caminho
30

j no foi encontrado. Os clculos dentro desta condio somente sero executados se todas as regras de condies forem verdadeiras. Satisfazendo todas as regras de condies o algoritmo ir calcular o custo do movimento g para o n que ser visitado. Portanto, muito antes de executar o movimento ele far o clculo e gravar no n que ainda ser visitado. Aps o clculo de g ser calculado f tambm para esse n que ser visitado. Finalmente o algoritmo ir gravar na matriz menor_custo, do n a ser visitado, o custo para seguir por esse caminho. Caso as regras de condies no forem satisfeitas o algoritmo ir atribuir um valor alto, maior_custo, a esse n apenas para garantir os clculos que sero executados no prximo bloco de condies. Nesse exemplo esta sendo descrito apenas o movimento horizontal para a direita. Porm, a idia mostrar que o algoritmo ir armazenar o melhor custo estimado dos quatro possveis caminhos a serem percorridos movimentando-se verticalmente e horizontalmente. No segundo bloco tem-se:

FIGURA 17: Calculando o menor custo Perceba que nesse bloco existem trs clausulas if que o algoritmo ter de identificar antes de executar qualquer ao. A primeira deve verificar as mesmas condies que a anterior. Durante a verificao do primeiro bloco de condies, o algoritmo ainda no tomou nenhuma deciso de se movimentar para uma das quatro opes de escolha, ele somente calculou os custos estimados de seus vizinhos para futuramente fazer uma comparao entre eles para distinguir ento qual melhor caminho seguir. A segunda, a terceira e a quarta condio trabalham em conjunto. Elas so responsveis por comparar os custos dos ns vizinhos candidatos ao prximo movimento. Nesse exemplo estamos comparando o n candidato da direita com todos os outros ns possveis. Se todas as condies forem satisfeitas significa que o n da direita, candidato ao prximo movimento, o n de menor custo. Portanto, o agente inteligente deve mover-se para esse n. No entanto, antes do agente se movimentar, ele deve marcar esse caminho como j percorrido. Para isso gravado na matriz caminho a varivel j_passou para essa posio. Aps o agente inteligente ter decidido qual caminho seguir ele solicitar novamente uma chamada funo.
31

Nesse exemplo esta sendo descrito apenas as condies para movimento horizontal para a direita. Porm, alm de servir para todos os movimentos, a idia entender como decidido o movimento por qual caminho seguir. Para uma melhor visualizao de como o algoritmo decide qual caminho ele dever tomar ser apresentado agora o grafo para duas situaes de deciso que ocorrem durante o percurso pelo labirinto. Primeiro:

FIGURA 18: rvore para visualizao do movimento 1 Nesta figura pode-se identificar o primeiro movimento executado pelo algoritmo. Em poder das informaes necessrias para a tomada de deciso, o algoritmo compara o melhor custo estimado para cada um dos movimentos possveis. Perceba que no primeiro passo o custo da distncia de h para o movimento horizontal esquerda de 110 (cento de dez), enquanto o custo da distncia de h para o movimento vertical de subida de 90 (noventa). O custo de g para se movimentar um passo o mesmo para esses dois movimentos. Portanto, atravs do resultado do clculo da funo heurstica f = g+h o algoritmo consegue identificar que o melhor custo estimado para este movimento o movimento vertical de subida, pois f = 100 menor que f = 120. Uma outra situao que ocorre durante a execuo desse algoritmo a seguinte:

FIGURA 19: rvore para visualizao do movimento 2

32

Novamente preciso fazer uma comparao entre as possibilidades de movimentao. Essa situao descrita na figura 19 a mesma que ocorre na primeira situao descrita (figura 18). Aparentemente neste momento d a impresso de que existem trs possibilidades de movimentao. Pois existem trs corredores que podem levar o algoritmo para um lugar qualquer. No entanto, na figura perceba que os ns coloridos de amarelo representam os ns j visitados. O que significa que o algoritmo ir desconsiderar os ns amarelos quanto tomada de deciso. Fica claro nesse momento que aps a tomada de deciso para mover-se para o prximo n a funo heurstica solicitar novamente uma chamada a ela mesma entrando em um ciclo recursivo. Sabendo-se que para toda funo recursiva deve-se existir uma condio de parada, ser apresentado como o agente inteligente entende que a soluo foi encontrada e quando retroceder. Analisando a condio seguinte:

FIGURA 20: Varivel guia para condio de chegada A primeira condio especificada no incio da funo heurstica tem como objetivo verificar se o algoritmo j encontrou a sada do labirinto. Se a informao contida no n corrente for igual a FIM, ou seja, se essa informao for igual a trs, significa que o algoritmo encontrou o caminho. Mas ento surge a dvida de como o algoritmo entende que esse caminho foi encontrado. Durante toda a execuo desta funo perceba que para todas as condies verificada a situao da varivel guia denominada chegou.

33

FIGURA 21: Comportamento recursivo 1 Quando ocorre a primeira solicitao de chamada funo heurstica, a varivel chegou possui o valor zero atribudo a ela, ou seja, o agente ir varrer os ns candidatos e enquanto essa varivel for igual a zero ele verificar e executar somente as operaes das condies do bloco de condies 1 (um) e 2 (dois). No instante em que essa varivel obter o valor 1 (um) atribudo a ela o algoritmo entende como encontrado o caminho, pois ele no mais verificar e executar as operaes das condies desses 2 (dois) blocos de condies . Ento se a ultima chamada funo foi resolvida ou terminada, significa que a chamada anterior tambm foi resolvida e a que precede esta tambm e assim sucessivamente. Ou seja, no existem mais opes de movimento, conseqentemente a funo finalizada.

FIGURA 22: Comportamento recursivo 2 O que ocorre durante as resolues das chamadas funo o armazenamento do melhor caminho estimado na matriz guarda_caminho. Perceba que a ultima condio especificada no cdigo ser satisfeita somente quando a varivel chegou for igual a 1 (um).

FIGURA 23: Armazenando o melhor caminho estimado

34

A finalidade desta condio armazenar o melhor caminho. Pode-se perceber que durante a execuo da pesquisa por um melhor caminho, o agente inteligente armazena na matriz caminho os caminhos por onde ele j percorreu. Nesse instante a varivel chegou igual a 0 (zero). Portanto o algoritmo no ir salvar esses caminhos na matriz guarda_caminho. A razo disso que pode acontecer do algoritmo estimar um melhor caminho e este caminho direciona-lo a um corredor sem sada.

FIGURA 24: Caminho sem sada Quando isso ocorre a chamada funo, aps verificar as condies dos blocos de condies e identificar que nenhuma delas foram satisfeitas, finalizada e termina retornando para a funo que a chamou. Esta por sua vez executar as mesmas verificaes e obter os mesmos resultados e consequentemente terminar retornando para a funo que a chamou. Perceba que as chamadas s funes vo sendo finalizadas retornando para as anteriores que as chamaram at que alguma dessas chamadas consiga validar e satisfazer alguma condio dos blocos de condies e tentar seguir para um novo caminho.

35

FIGURA 25: Executando nova pesquisa Quando ocorre esta situao, para o labirinto proposto o agente retornar at a posio inicial de onde partiu a primeira chamada funo heurstica, pois todas as condies declaradas na funo heurstica anulam ela prpria. Porm, neste ponto a funo heurstica no retornar para a funo principal, no ainda. Pois na primeira chamada funo heurstica, escolheu-se um dos dois caminhos possveis e de menor custo para encontrar o n objetivo. No entanto, esse caminho direcionou o agente a um corredor sem sada. Na medida em que as chamadas de funo vo terminando, o agente verifica as condies dos blocos de condies de cada chamada. Enquanto retrocede, para cada n, tenta-se escolher um caminho para seguir, mas no encontra algum resultando no termino da chamada da funo corrente. No momento em que o agente atinge o ponto inicial ele far novamente a verificao e identificar um novo caminho a seguir. A partir de ento ocorrer novas avaliaes para estimar o melhor caminho possvel conforme figura 25. Durante as novas avaliaes o algoritmo ir identificar os ns candidatos at atingir o ponto final que a sada do labirinto. Quando isso acontecer, o algoritmo ir atribuir o valor 1 (um) para a varivel achou. A partir do momento em que a varivel achou recebe o valor 1 (um), o algoritmo verifica novamente alguma outra condio desta chamada para executar alguma operao se as condies forem satisfeitas. Nesse ponto ele resolve a ultima condio da funo heurstica que at ento jamais fora visitada. Identifica que o caminho foi encontrado e atribui a varivel melhor_caminho para o n corrente. Aps marcar o primeiro n do melhor caminho estimado a funo termina, pois acabaram-se todas as condies para aquela chamada. Comea ento novamente o processo de finalizao das chamadas de funo uma a uma retornando para as anteriores que as chamaram. No entanto, conforme mudado
36

o valor da varivel guia achou de 0 (zero) para o valor 1 (um), nenhum outro caminho ser percorrido, pois para executar qualquer operao dos 2 (dois) blocos de condies requerido qualquer valor diferente de 1 (um) para a varivel guia. A partir do momento em que a varivel guia passa de 0 para 1, o algoritmo ir finalizar todas as chamadas de funo marcando o caminho at o ponto inicial de partida.

FIGURA 26: Encontrando a sada Aps ser resolvida a funo heurstica, o sistema retornar para a funo main. Nesse instante a matriz guarda_caminho estar atualizada com o melhor caminho estimado para encontrar a soluo. O sistema ento imprime essa estimativa de melhor caminho na tela apresentando o resultado, concluindo a busca inteligente. importante notar que o algoritmo A* (star) no visita todos os ns da matriz. Para encontrar o melhor caminho estimado, o agente percorrer somente os caminhos de menor custo evitando gastos em relao ao tempo para encontrar esse caminho. O algoritmo produzido por essa pesquisa pode ser estudado atravs do Apndice III, onde se encontra o cdigo fonte completo para o problema do labirinto proposto. O algoritmo tambm funciona corretamente ao se utilizar diferentes coordenadas iniciais e finais. Para tanto, tambm est disponvel nos Apndices I e II coordenadas iniciais e finais distintas para execuo de testes. At ento todos os resultados foram satisfatrios.

37

4. DISCUSSO
Durante a criao deste agente inteligente foram identificados pequenos fatores que diretamente influenciaram para o funcionamento do mesmo. comum encontrar certas dificuldades, para se resolver determinado tipo problema, nos primeiros instantes quando ainda no se conhece profundamente o problema em si. Para este problema proposto, por exemplo, sabe-se que existe um labirinto onde, em algum lugar dentro deste labirinto, existe um agente que deve encontrar o melhor caminho possvel para atingir a sada. Ao analisar essa situao, pensou-se em construir o algoritmo utilizando listas ligadas ao invs de utilizar matrizes dinmicas. O processo tornou-se confuso, quanto a utilizao de ponteiros, no momento em que se tentava calcular f para os ns vizinhos. Surgiu ento a necessidade de encontrar uma outra soluo mais simples para armazenar esse clculo, que foi a utilizao de matrizes dinmicas. Com a ajuda das variveis i e j foi possvel armazenar para cada n, os custos para os ns vizinhos. No entanto surge outra dvida para conseguir armazenar o pai de cada filho que se movimenta. Foi pesquisado em alguns sites de jogos, tutoriais para se entender o clculo para o custo do movimento. No estava claro ainda. De repente, enquanto pesquisava-se o clculo para encontrar a distncia entre dois pontos, a resposta para o custo do movimento encotrada atravs do teorema de Pitgoras. Pois, nos sites que so encontrados hoje na internet, no informado explicitamente de onde aparecem tais valores, sendo eles os movimentos ortogonais e diagonais. Em um dos vrios sites visitados informava que o custo para se mover na diagonal era igual raiz de 2 (dois), que nada mais que a tangente de um tringulo retngulo cujos catetos possuem mesma medida 1(um). Ainda encontrou-se o problema para identificar o clculo da distncia entre dois pontos. Para este, a geometria analtica (euclidiana) no ajudaria, pois ela desconsidera todas as paredes existentes no labirinto o que torna impossvel o agente atingir a sada do mesmo. Partindo deste outro problema foi identificado o mtodo de Manhattan, que se utiliza de uma geometria no-euclidiana que considera os obstculos encontrados no ambiente se utilizando de vrios outros pontos intermedirios entre os pontos inicial e final. Foram eliminados todos os operadores for para a funo heurstica. O algoritmo estava ficando muito extenso e confuso. Foi seguido o conselho do orientador para com a utilizao de mecanismos recursivos o que resultaria na eliminao de todos os operadores for. A recursividade no somente melhorou a visibilidade do cdigo, mas tambm solucionou o problema para se armazenar o pai de cada filho que se movimenta. Sendo o pai o n anterior ao corrente, que o filho.

38

5. CONCLUSO
Atravs de pesquisas relacionadas rea da Inteligncia Artificial tendo como enfoque o estudo de Agentes Inteligentes, e ainda em paralelo o estudo e pesquisa referentes s condies de ambiente relacionadas ao problema proposto, foi possvel a elaborao de um algoritmo eficiente capaz de percorrer somente os estados necessrios para se obter o resultado esperado da melhor forma possvel. O objetivo deste trabalho, inicialmente era demonstrar apenas um agente inteligente verificando corredores estreitos at descobrir o melhor caminho possvel para atingir a sada de um labirinto. O que tornou o trabalho ainda mais interessante foi perceber como um simples algoritmo aplicado a um jogo pode envolver diversos outros fatores relacionados ao ambiente e s aes que o agente dever entender e executar neste ambiente, como por exemplo, jogos que envolvem gravidade, velocidade, impacto, emoo, cansao, etc. Portanto, este trabalho pode ser considerado um exemplo simples para o auxlio na iniciao ao estudo na rea de jogos, que uma rea atualmente em grande expanso.

39

6. REFERNCIAS BIBLIOGRFICAS

ABRAGAMES. A Indstria Brasileira de Jogos Eletrnicos. Disponvel via URL em: http://www.abragames.org/docs/Abragames-Pesquisa2008.pdf. Acesso em: 3 de ago. de 2008. ARARIBOIA, G. Inteligncia Artificial: um curso prtico. Rio de Janeiro; So Paulo: Livros Tcnicos e Cientficos, c1989. COSTA, Ernesto, SIMES, Anabela. Inteligncia Artificial Fundamentos e Aplicaes. FCA, Fev. 2004 cap.3. DANTE, Luiz Roberto. Matemtica, Contexto & Aplicaes. 2 e. So Paulo: tica, 2001. DEPARTAMENTO DE INFORMATICA, Din. Apresenta texto sobre o Algoritmo A*. Disponvel via URL em: http://www.din.uem.br/ia/a_multid/planejamento/algoritmos.htm. Acesso em: 05 de mai. de 2007. DEVITO, Andr, FREITAS, Araone K., PEREIRA, Knia C.. Geometrias NoEuclidianas Geometria do Motorista de Taxi. Disponvel via URL em: www.ime.unicamp.br/~eliane/ma241/trabalhos.htm. Acesso em: 20 de mai. de 2008. GAMEWORLD. Mercado de games dobrar at 2011. Disponvel via URL em: http://www.gameworld.com.br/index.php?option=com_content&task=view&id=2600&It emid=28. Acesso em: 25 de out. de 2007. GANASCIA, J. G. .Inteligncia Artificial. Traduo Reginaldo Carmello Correa de Moraes. So Paulo: tica, 1997. Titulo original> Lintelligence artificielle. IDGNOW, Tecnologia em Primeiro Lugar. Indstria dos games tem impacto de US$ 18 bi na economia dos EUA, diz estudo. Disponvel via URL em: http://idgnow.uol.com.br/computacao_pessoal/2006/05/11/idgnoticia.2006-0511.7706011084/IDGNoticia_view. Acesso em: 25 de mai. de 2007. INTELLIWISE, Research and Training. Inteligncia Artificial, Educao de Crianas e o Crebro Humano. Disponvel via URL em: http://www.intelliwise.com/reports/p4port.htm. Acesso em: 30 de nov. de 2007. NEVES, Luiz A. P. Udesc Aula 4 Recursividade. Disponvel via URL em: www.joinville.udesc.br/sbs/professores/neves/materiais/LPG1_Aula4_recursividade.p df. Acesso em: 5 de ago. de 2008. RUSSELL, Stuart J., NORVIG, Peter. Inteligncia Artificial. 2 e. Rio de Janeiro: Campus, 2004. UBISOFT. Ubisoft: 2009 ser dos games. Disponvel via URL em: http://www.baguete.com.br/noticiasDetalhes.php?id=25207. Acesso em: 15 de jul. de 2008.

40

APNDICE I LABIRINTO 1
int tabuleiro[larguraX][alturaY]= {{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, {1, 0, 0, 0, 0, 0, 0, 0, 0, 3}, {1, 0, 1, 0, 1, 1, 1, 1, 1, 1}, {1, 0, 1, 0, 1, 1, 0, 0, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 0, 0, 0, 0, 5, 1, 0, 1}, {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}};

41

APNDICE II LABIRINTO 2
int tabuleiro[larguraX][alturaY]= {{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, {3, 0, 0, 0, 0, 0, 0, 0, 0, 1}, {1, 0, 1, 0, 1, 1, 1, 1, 1, 1}, {1, 0, 1, 0, 1, 1, 0, 0, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 0, 0, 0, 0, 5, 1, 0, 1}, {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}};

42

APNDICE III O CDIGO FONTE

#include<stdio.h> #include<iostream.h> int i,j, chegou=0; const int larguraX =10, alturaY=10; const int FIM = 3; const int parede = 1; const int ja_passou = 9; const int maior_custo = 9999; const int melhor_caminho = 8; //coordenadas do ponto Inicial const int inicialX = 8; const int inicialY = 6; //coordenadas do ponto final para encontrar os valores de H const int finalX = 1; const int finalY = 9; //o caminho a ser percorrido int caminho[larguraX][alturaY]; int guarda_caminho[larguraX][alturaY]; int menor_custo[larguraX][alturaY]; //Armazenar as infos da funo Astar int F[larguraX][alturaY]; int G[larguraX][alturaY]; int H[larguraX][alturaY]; //prototipo da funo A*(star) void encontrar_caminho(int x, int y);

main(){ //linha 39 int tabuleiro[larguraX][alturaY]= {{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, {1, 0, 0, 0, 0, 0, 0, 0, 0, 3}, {1, 0, 1, 0, 1, 1, 1, 1, 1, 1}, {1, 0, 1, 0, 1, 1, 0, 0, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 1, 0, 1, 1, 0, 1, 0, 1}, {1, 0, 0, 0, 0, 0, 5, 1, 0, 1}, {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}}; //configurar o caminho com informaes do tabuleiro for(i=0; i<larguraX; i++){ for(j=0; j<alturaY; j++){ caminho[i][j] = tabuleiro[i][j]; guarda_caminho[i][j] = tabuleiro[i][j]; } } //configurar o caminho com informaes do tabuleiro for(i=0; i<larguraX; i++){ for(j=0; j<alturaY; j++){ menor_custo[larguraX][alturaY]=999; } }

43

//zerar F e G for(i=0; i<larguraX; i++){ for(j=0; j<alturaY; j++){ F[i][j]=0; // linha 64 G[i][j]=0; } } //calcular custo de H de cada clula do tabuleiro for(i=0;i<alturaY;i++){ for(j=0;j<larguraX;j++){ H[i][j] = 10*(abs(i-finalX) + abs(j-finalY)); } } // Iniciar o sistema aqui i,j =0; encontrar_caminho(inicialX, inicialY);

int c=0; printf("\n=============================================================\n"); printf(" :: O melhor caminho representado pelo smbolo: \" * \"\n"); printf("=============================================================\n"); //imprimir o melhor caminho for(i=0;i<alturaY;i++){ for(j=0;j<larguraX;j++){ if(guarda_caminho[i][j]==8){ printf(" * "); }else{ printf(" %d ",guarda_caminho[i][j]); } c++; if(c==10){ printf("\n"); c=0; } } } printf("\n=============================================================\n"); printf(" :: ::\n"); printf("=============================================================\n"); } ////////////////////FUNES//////////////////////////////// // funco para descobrir o caminho void encontrar_caminho(int x, int y) { printf("\n %d %d %d", x,y, chegou); system("pause"); if(guarda_caminho[x][y]==FIM){ chegou=1; } if((caminho[x+1][y]!=parede)&&(caminho[x+1][y]!=ja_passou)&&(chegou !=1)){ G[x+1][y] = G[x][y] + 10; F[x+1][y] = G[x+1][y] + H[x+1][y]; menor_custo[x+1][y]=F[x+1][y];

44

}else{

menor_custo[x+1][y]=maior_custo; } if ((caminho[x-1][y]!=parede)&&(caminho[x-1][y]!=ja_passou)&&chegou !=1){ G[x-1][y] = G[x][y] + 10; F[x-1][y] = G[x-1][y] + H[x-1][y]; menor_custo[x-1][y]=F[x-1][y]; }else{ menor_custo[x-1][y]=maior_custo; } if ((caminho[x][y+1]!=parede)&&(caminho[x][y+1]!=ja_passou)&&chegou !=1){ G[x][y+1] = G[x][y+1] + 10; F[x][y+1] = G[x][y+1] + H[x][y+1]; menor_custo[x][y+1]=F[x][y+1]; }else{ menor_custo[x][y+1]=maior_custo; } if ((caminho[x][y-1]!=parede)&&(caminho[x][y-1]!=ja_passou)&&chegou !=1){ G[x][y-1] = G[x][y-1] + 10; F[x][y-1] = G[x][y-1] + H[x][y-1]; menor_custo[x][y-1]=F[x][y-1]; }else{ menor_custo[x][y-1]=maior_custo; } // verificar o menor custo entre os quatro possveis caminhos if(caminho[x+1][y] != ja_passou && caminho[x+1][y] != parede && chegou != 1){ if(menor_custo[x+1][y] < menor_custo[x-1][y]){ if(menor_custo[x+1][y] < menor_custo[x][y+1]){ if(menor_custo[x+1][y] < menor_custo[x][y-1]){ caminho[x+1][y]=ja_passou; encontrar_caminho(x+1, y); } } } } if(caminho[x-1][y] != ja_passou && caminho[x-1][y] != parede && chegou != 1){ if(menor_custo[x-1][y] < menor_custo[x][y+1]){ if(menor_custo[x-1][y] < menor_custo[x][y-1]){ caminho[x-1][y]=ja_passou; encontrar_caminho(x-1, y); } } } if(caminho[x][y+1] != ja_passou && caminho[x][y+1] != parede && chegou != 1){ if(menor_custo[x][y+1] < menor_custo[x][y-1]){ caminho[x][y+1]=ja_passou; encontrar_caminho(x, y+1); } } if(caminho[x][y-1] != ja_passou && caminho[x][y-1] != parede && chegou != 1){ caminho[x][y-1]=ja_passou; encontrar_caminho(x, y-1); } } if( chegou == 1 )guarda_caminho[x][y] = melhor_caminho;

45