Jogo de Estratégia Militar.

Transcrição

CRISTIANO PALMER
MARIO CESAR MELNIK
JOGO DE ESTRATÉGIA MILITAR
Curitiba
1º Semestre / 2005
CRISTIANO PALMER
MARIO CESAR MELNIK
Trabalho de Conclusão do Curso de Bacharelado em Ciência da
Computação, do Centro Universitário Campos de Andrade –
UNIANDRADE, como requisito final à obtenção do título de
Bacharel em Ciência da Computação.
Orientador: Prof. M.Sc. Edson Luiz Machado.
Curitiba
1º Semestre / 2005
AGRADECIMENTOS
A Deus.
Ao Prof. M.Sc. Felipe Marcon, por esclarecer as dúvidas que ocorreram até o momento
referentes à parte teórica do projeto e normas, auxiliando-nos para melhorá-lo.
Ao Prof. M.Sc. Edson Luiz Machado, por esclarecer as dúvidas que ocorreram até o
momento referentes à parte prática do projeto, sanando muitas dúvidas referentes às técnicas
de Inteligência Artificial.
Ao Prof. M.Sc. Ionildo José Sanches, pelo material e ajuda prática sobre as bibliotecas
de OPEN-GL, auxiliando no que diz respeito a computação gráfica existente no nosso projeto
final.
Ao amigo e colega de trabalho Cesar Augusto Felber pelo auxílio no que diz respeito a
desenvolvimento de jogos, por já possuir conhecimento prático e teórico em desenvolvimento
dessa natureza.
ii
SUMÁRIO
LISTA DE ABREVIATURAS E SIGLAS .............................................................................viii
RESUMO ..................................................................................................................................ix
ABSTRACT .................................................................................................................................x
1 INTRODUÇÃO....................................................................................................................... 1
1.1 CONTEXTUALIZAÇÃO ................................................................................................ 1
1.2 DESCRIÇÃO DO PROBLEMA ...................................................................................... 1
1.3 MOTIVAÇÕES ................................................................................................................ 2
1.4 OBJETIVO GERAL......................................................................................................... 2
1.5 OBJETIVOS ESPECÍFICOS ........................................................................................... 2
1.6 FINALIDADE .................................................................................................................. 3
1.7 VISÃO GERAL DO TRABALHO .................................................................................. 3
2 FUNDAMENTAÇÃO TEÓRICA .......................................................................................... 5
2.1 INTELIGÊNCIA ARTIFICIAL ....................................................................................... 5
2.1.1 Definições de IA......................................................................................................... 5
2.1.2 Lógica ........................................................................................................................ 6
2.1.2.1 Histórico ............................................................................................................. 6
2.1.3 Árvore BSP................................................................................................................ 7
2.1.4 Métodos de Busca...................................................................................................... 7
2.1.4.1 Busca Heurística ................................................................................................. 8
2.1.4.1.1 Busca em profundidade: ............................................................................... 8
2.1.4.1.2 Busca em largura: ......................................................................................... 8
2.1.4.1.3 Gera e Testa:................................................................................................. 9
2.1.4.1.4 Busca em feixe: ............................................................................................ 9
2.1.4.1.5 Subindo o morro: ........................................................................................ 10
2.1.4.2 Utilização da Busca Heurística......................................................................... 10
2.1.5 Inteligência Artificial Aplicada em Jogos .............................................................. 10
2.1.5.1 Mini Max .......................................................................................................... 11
2.1.5.2 Alfa Beta........................................................................................................... 12
2.2 LINGUAGEM DE PROGRAMAÇÃO.......................................................................... 12
2.2.1 Linguagem C ............................................................................................................ 13
2.2.2 Linguagem C++........................................................................................................ 13
iii
2.3 COMPUTAÇÃO GRÁFICA.......................................................................................... 13
2.3.1 OPEN-GL ................................................................................................................. 14
2.4 ANÁLISE DE PROJETO ESTRUTURADO ................................................................ 14
2.5 JOGOS ELETRÔNICOS ............................................................................................... 15
3 DESENVOLVIMENTO........................................................................................................ 17
3.1 RECURSOS NECESSÁRIOS........................................................................................ 17
3.2 ESPECIFICAÇÃO E DESENVOLVIMENTO DO PROJETO .................................... 18
3.2.1 Especificações Técnicas .......................................................................................... 18
3.2.2 Diagrama de desenvolvimento ................................................................................ 19
3.3 AMBIENTE DE EXECUÇÃO DO PROJETO.............................................................. 21
3.4 PONTOS FORTES E FRACOS..................................................................................... 22
3.5 CRONOGRAMA DE ATIVIDADES............................................................................ 22
3.5.1 Detalhamento do Cronograma.................................................................................. 23
4 RESULTADOS ..................................................................................................................... 26
4.1 INTRODUÇÃO.............................................................................................................. 26
4.2 DISTRIBUIÇÃO DE PEÇAS ........................................................................................ 26
4.3 REALIZAÇÃO DE JOGADAS ..................................................................................... 28
4.4 INTERFACE GRÁFICA................................................................................................ 29
5 DISCUSSÃO E CONCLUSÕES .......................................................................................... 32
5.1 ANÁLISE DOS RESULTADOS ................................................................................... 32
5.2 CONCLUSÕES .............................................................................................................. 33
5.3 TRABALHOS FUTUROS ............................................................................................. 33
REFERÊNCIAS BIBLIOGRÁFICAS ..................................................................................... 34
GLOSSÁRIO............................................................................................................................ 37
APENDICE A: MANUAL ..................................................................................................... 38
1.REQUISITOS DO JOGO...................................................................................................... 42
2.INSTALAÇÃO...................................................................................................................... 42
3.TABULEIRO ........................................................................................................................ 45
4.DISPONIBILIZAÇÃO DAS PEÇAS ................................................................................... 47
5.JOGADAS ............................................................................................................................. 49
6.ATAQUE............................................................................................................................... 50
7.QUEM GANHA O JOGO..................................................................................................... 52
8.SAIR ...................................................................................................................................... 52
iv
9.DICAS IMPORTANTES ...................................................................................................... 52
APENDICE B: FONTES DO JOGO DE ESTRATÉGIA MILITAR................................55
v
LISTA DE FIGURAS
1
Busca em Profundidade...................................................................................... 8
2
Busca em Amplitude.......................................................................................... 9
3
Corte Beta........................................................................................................... 12
4
Simbologia utilizada para Análise Estruturada / Análise Essencial................... 15
5
Modelo Ambiental.............................................................................................. 20
6
Tela com peças................................................................................................... 29
7
Jogada sobre Jogador.......................................................................................... 30
8
Movimentação de bomba.................................................................................... 30
vi
LISTA DE TABELAS
1
Forma geral.............................................................................................................
14
2
Custos referentes ao desenvolvimento do projeto...................................................
17
3
Custos para execução do sistema............................................................................
21
4
Etapas de desenvolvimento do projeto....................................................................
22
5
Teste de Posicionamento da Torre..........................................................................
26
6
Teste de posicionamento de peças..........................................................................
27
7
Jogada do soldado...................................................................................................
28
8
Execução do maior valor.........................................................................................
28
vii
LISTA DE ABREVIATURAS E SIGLAS
2D
- Bidimensional
API
- Aplication Programming Interface (Interface de Programação de Aplicativo)
BSP
- Binary Space Partitionig Truee (Árvore Binaria de Partição de Espaço)
CD-ROM - Compact Disc Read Only Memory (Disco Compacto de Memória Somente
Leitura)
FIFO
- First In First Out (Primeiro a Entrar Primeiro a Sair)
GNU/GPL - General Public License (Licença Pública Geral)
GCC
- GNU Compiler Collection (Coleção de Compiladores GNU)
IA
- Inteligência Artificial
ISO
- International Standards Organization (Organização de Padrões Internacionais)
OPEN-GL - Open Graphics Library (Biblioteca Gráfica Aberta)
POO
- Programação Orientada a Objeto
SO
- Sistema Operacional
VGA
- Video Graphics Array (Dispositivo Gráfico de Vídeo)
viii
RESUMO
Este projeto visa o desenvolvimento de um algoritmo que utiliza técnicas de Inteligência
Artificial, aplicadas a um software recreativo baseado em um jogo tradicional, denominado
COMBATE. A utilização de técnicas de Inteligência Artificial visa melhorar determinados
aspectos do jogo, além de melhorar a estratégia de jogo, aplicando algoritmos que determinam
os melhores caminhos para alcançar o objetivo. Constituiu-se de várias alterações em contexto
do jogo original para ser aplicado a este trabalho.
PALAVRAS CHAVES
Jogos, Inteligência Artificial, Computação Gráfica.
ix
ABSTRACT
This project aims at the development of an algorithm that uses techniques of Artificial
Intelligence, applying them in a based recreation software in a traditional game, called
STRATEGO. The use of techniques of Artificial Intelligence aims at to improve definitive
aspects do game, besides improving the game strategy, applying algorithms that determine the
best ways to reach the objective. The original game had some alterations in its context to be
applied to this work.
KEY-WORDS
Games, Artificial Intelligence, Graphical Computation.
x
1
CAPÍTULO 1
INTRODUÇÃO
1.1 CONTEXTUALIZAÇÃO
A Inteligência Artificial (IA) é um ramo na Ciência da Computação que foi construído a
partir de idéias filosóficas, científicas e tecnológicas herdadas de outras ciências, como por
exemplo, lógica, matemática, psicologia, lingüística, neurociências, etc. (BITTENCOURT,
1996).
O objetivo geral da Inteligência Artificial é a criação de teorias e modelos para a
capacidade cognitiva. Esses modelos são implementados utilizando-se como ferramenta o
computador. A validade de um modelo ou de uma teoria de IA é demonstrada diretamente
através da ação inteligente do programa computacional.
Os jogos eletrônicos desenvolvidos na atualidade fazem uso das técnicas de IA em muitas
de suas aplicações, como por exemplo, controle das ações que os agentes envolvidos nos jogos
devem tomar.
Os primeiros jogos eletrônicos, mostravam a capacidade das máquinas eletrônicas de
representar “ações” onde os homens poderiam participar. Em 1962, foi feita a demonstração de
“Space War”, o primeiro jogo eletrônico, tendo um monitor como “interface de visualização”.
Na década de 70, foi apresentada uma versão para o grande público de “Space War”, chamado
“Computer Space”, e com esse jogo Nolan Bushnell passou a ser considerado o pai dos jogos
eletrônicos. Os jogos eletrônicos abriram o caminho para que a interatividade entrasse nas
massas, principalmente nas décadas de 80 e 90 em suas versões em CD-ROM (Compact Disc
Read Only Memory) (LEMOS,2004).
1.2 DESCRIÇÃO DO PROBLEMA
Desenvolver um algoritmo para o jogador eletrônico, introduzir novas regras, e utilizar
técnicas de IA como previsão (heurística) ou dedução de localização de peças inimigas, a partir
de certa altura do jogo, pois inicialmente o algoritmo só terá a localização das peças
controladas por ele.
2
1.3 MOTIVAÇÕES
A oportunidade de pesquisar uma área vasta como a IA, capaz de proporcionar boa base
e experiência para uma especialização no assunto. Aplicar as técnicas aprendidas em outros
jogos, já que a área de IA e de desenvolvimento de jogos é promissora, possuindo um interesse
muito grande, principalmente do público jovem.
1.4 OBJETIVO GERAL
O propósito do projeto é a criação de um software destinado ao entretenimento,
complementando e melhorando o jogo tradicional. Para isto, tem-se o objetivo de desenvolver
um algoritmo que tem por função executar o posicionamento inicial das peças, movimentação e
ataque das mesmas, até o término do jogo com a tomada da torre, uma vez que o objetivo foi
alterado para proporcionar um novo desafio, sabendo-se que o jogo Combate é apenas uma
base para este trabalho.
Serão de grande utilidade as técnicas de IA durante decorrer do jogo, pois permitirão
escolher os melhores caminhos para alcançar o objetivo, ou seja, ampliando possibilidade de
ganhar o jogo.
O principal atrativo na utilização destas estratégias é o desconhecimento do valor das
peças adversárias que ao decorrer do jogo são desvendadas através do confronto direto dos
combatentes.
1.5 OBJETIVOS ESPECÍFICOS
Desenvolvimento de um software com interface 2D (bidimensional) no qual são
utilizadas técnicas de IA e computação gráfica.
Construir graficamente um tabuleiro com dimensões 15 linhas por 15 colunas: O
tabuleiro constituído de forma gráfica apresenta a interface principal entre o usuário e o
software.
Construir um algoritmo que utilize técnicas inteligentes para a realização de
posicionamento de peças do computador, este algoritmo não deve repetir o mesmo
posicionamento.
Construir um algoritmo que utilize técnicas de inteligência Artificial para a realização
de jogadas do computador.
3
Este jogo tem como principal atribuição o duelo entre as partes integrantes: computador X
homem. O software é apresentado em forma de um tabuleiro, tendo esse como sua interface
principal.
Tanto a análise quanto o desenvolvimento serão baseados em forma estruturada, a fim de
facilitar a compreensão do domínio do problema, permitindo a visualização do sistema de uma
forma realista através dos mesmos. Normalmente na análise estruturada esta visualização está
direcionada aos processos, o que dificulta o entendimento e a abstração dos dados.
O jogo disponibiliza as peças do computador no tabuleiro para um melhor aproveitamento
das jogadas, possuindo um algoritmo desenvolvido para isso. De modo a evitar que o
computador utilize sempre a mesma formação, o algoritmo executará rotinas de distribuição
evitando a mesma formação sempre que um novo jogo for iniciado. Deve existir um algoritmo
para tratar especialmente das jogadas, assim como das estratégias de defesa e ataque que
deverão ser utilizadas.
Na análise do estado atual do tabuleiro é verificado se o jogo chegou em seu fim ou se
pode continuar a partida, e sempre que o jogador ou o computador jogar deve haver essa
verificação. Essa análise é de suma importância, pois é com ela que o computador fará a
verificação do vencedor ou se ocorreu um empate.
A IA também irá atuar na situação em que existe um objetivo a ser alcançado no jogo,
porém esse objetivo poderá ser alcançada através de dedução de peças não reveladas, para
então verificar as jogadas possíveis e escolher a melhor.
1.6 FINALIDADE
Apresentar algoritmos que através de IA tenham reações coerentes com seu objetivo
sem ao menos conhecê-lo, podendo escolher caminhos no decorrer do jogo (heurística).
Inclusão do jogador eletrônico, com o objetivo de divertimento de pessoas de várias
idades, contribuindo para o desenvolvimento do raciocínio lógico do jogador, criando
estratégias para vencer o seu oponente (o computador), que tem por função executar desde o
posicionamento inicial das peças, condução das jogadas até a conclusão do jogo.
1.7 VISÃO GERAL DO TRABALHO
No Capítulo 1 é apresentada uma breve introdução, a motivação e foi detalhado os
objetivos do trabalho.
4
No Capítulo 2 é feita a apresentação e fundamentação do trabalho, apresentando
técnicas utilizadas em uso tanto nos jogos quanto na IA.
No Capítulo 3 são apresentados os recursos utilizados para o seu desenvolvimento, tanto
teórico quanto prático, o ambiente que o software deve ser instalado, e o Cronograma das
atividades.
No Capítulo 4 é apresentado os resultados esperados e obtidos do projeto como um
todo.
No Capítulo 5 é feita uma conclusão do trabalho até o momento citando projetos futuros
que podem ser realizados.
5
CAPÍTULO 2
FUNDAMENTAÇÃO TEÓRICA
2.1 INTELIGÊNCIA ARTIFICIAL
O avanço da ciência em determinadas áreas provoca reações que têm origem no medo da
inversão da ordem natural das coisas. O avanço nas experiências genéticas, por exemplo, faz
muitas pessoas ficarem admiradas, prevendo diversas aplicações benéficas, e no entanto, faz
outros tantos reagirem de forma negativa, antevendo o incorreto uso deste conhecimento
(FERNANDES,2003).
Na IA não foi diferente. Se por um lado, algumas pessoas tinham expectativas benéficas
muito elevadas, outras não acreditavam que fosse possível criar máquinas com inteligência e,
mesmo que fosse possível, isso seria algo extremamente negativo. No entanto, a ciência
avançou alheia às críticas, e seu avanço se deu justamente pela capacidade do homem de
ignorar as críticas e ousar (SIMONS,1998).
Embora o estudo sobre a inteligência tenha se iniciado dentro do campo da filosofia, o
mesmo extrapolou o âmbito filosófico e a inteligência passou a ser estudada de forma científica
por outros campos do saber humano, tais como engenharia, psicologia, pedagogia, ciência
cognitiva, neurologia, lingüística, computação, entre outros, visando aspectos práticos e
comerciais (GANASCIA,1993).
Da mesma maneira que ocorreu com outras ciências, que antes pertenciam ao campo da
filosofia e depois se tornaram ciências independentes ou ramos de outras ciências, aconteceu
com o estudo da inteligência, que hoje é alvo de estudo da ciência conhecida como IA. A IA
tem se destacado na busca por compreender a inteligência e englobar diversos campos do
conhecimento com o objetivo de simular a inteligência (GANASCIA,1993).
2.1.1 Definições de IA
“O objetivo da IA é o estudo e a modelagem da inteligência tratada como um fenômeno.
A inteligência é algo extremamente complexo, resultado de milhões de anos de evolução.
Entendê-la não é tarefa fácil. Embora existam muitas conclusões relevantes, ainda há muito a
6
ser desvendado, uma vez que não existe uma teoria completa sobre a mente humana e os
processos de raciocínio” (FERNANDES, 2003).
“IA é a parte da Ciência da Computação que compreende o projeto de sistemas
computacionais que exibam características associadas à inteligência no comportamento humano
- compreensão de linguagem, aprendizagem, raciocínio, resolução de problemas, e assim por
diante” (BARR, FEIGENBAUM, 1981).
“Se nós podemos imaginar um artefato capaz de colecionar, conciliar, de escolher entre,
de compreender, de distinguir e de saber, então temos a inteligência artificial”
(FEIGENBAUM, MCCORDUCK, 1983).
“A IA é o uso de programas de computadores e técnicas de programação para clarificar os
princípios da inteligência em geral e do pensamento humano em particular” (BODEN, 1977).
As definições convergem para um mesmo ponto: o estudo de conceitos que permitem aos
computadores exibirem comportamento inteligentes.
2.1.2 Lógica
A adequação da lógica como método de representação de conhecimento é discutida
desde os primórdios da IA. Os primeiros sistemas que receberam o qualificativo de aplicações
de IA foram sistemas baseados em lógica, e ainda hoje grande parte das pesquisas na área estão
ligadas direta ou indiretamente à lógica (BITTENCOURT, 2001).
A lógica tema a vatagem pedagógica de ser um exemplo simples de representação para
agentes baseados em conhecimento, mas ela representa algumas limitações severas (RUSSELL,
NORVIG, 1995)..
2.1.2.1 Histórico
A lógica possui uma longa história, mais de 23 séculos, que remonta aos antigos
filósofos gregos, principalmente Aristóteles, que estabeleceu os fundamentos da lógica de
maneira sistemática (BITTENCOURT, 2001).
Os conceitos fundamentais da lógica são: verdade e prova. Estes conceitos foram
investigados durante séculos por filósofos. A lógica entra para o campo da matemática em
1847, uma linguagem formal que permite a realização de inferências. A lógica moderna tem
início em 1879, quando foi publicada a primeira versão do que é conhecido hoje como cálculo
de predicados. No fim do século XIX, a lógica passou a ser utilizada como base formal para
7
outros campos matemática, e seus métodos e limites passaram a ser estudados com rigor
(BITTENCOURT, 2001).
Em lógica, a definição é mais precisa. A semântica da linguagem define a verdade de
cada sentença com relação a cada mundo possível (RUSSELL, NORVIG, 1995).
De maneira geral, um sistema lógico consiste em um conjunto de fórmulas e um conjunto
de regras de inferência. As fórmulas são sentenças pertencentes a uma linguagem formal cuja
sintaxe é dada. Cada fórmula pode ser associada a um valor verdadeiro, isto é, ao valor
verdadeiro (V) ou ao falso (F). A parte da lógica que estuda os valores verdade é chamada
teoria de modelos. Dois problemas importantes estão relacionados com o valor verdade de uma
fórmula: o problema da validade, isto é, se é possível que uma dada fórmula apresente o valor
verdadeiro, e o problema da tautologia, isto é, se uma fórmula é ou não sempre verdadeira
As regras de inferência fornecem uma estrutura dedutiva à linguagem lógica. Uma regra
de inferência é uma regra sintática que, quando aplicada repetidamente a uma ou mais fórmulas
verdadeiras, gera apenas novas fórmulas verdadeiras. As regras de inferência fornecem uma
estrutura dedutiva à linguagem lógica. A seqüência de fórmulas geradas através da aplicação de
regras de inferência sobre um conjunto inicial de fórmulas é chamada de prova. A parte da
lógica que estudas as provas é chamada de teoria de provas (BITTENCOURT, 2001).
A teoria da resolução parte da transformação da expressão a ser provada para a forma
canônica conhecida como forma normal conjuntiva ou forma clausal. O método é baseado em
uma regra de inferência única, chamada regra de resolução, e utiliza intensivamente um
algoritmo de casamento de padrões chamado algoritmo de unificação (BITTENCOURT, 2001).
2.1.3 Árvore BSP
Apresenta uma estrutura de dados que proporciona a subdivisão do espaço em volumes
livres de obstáculos (SANTOS, 2002).
A Árvore BSP (Binary Space Partitioning Truee) particiona o espaço dividindo-o em
duas partes a cada nível utilizando um plano de divisão (SANTOS, 2002).
No campo da Computação Gráfica, tem aplicações na remoção de superfícies ocultas.
2.1.4 Métodos de Busca
8
Muitos problemas de IA necessitam de métodos de casamento (matching) e busca
(search), durante o processo de solução (NASCIMENTO, YONEYAMA, 2000).
2.1.4.1 Busca Heurística
Dentre as técnicas de IA, tem-se a busca heurística. A busca heurística proporciona um
meio de solucionar problemas complexos, para os quais não há disponível uma abordagem
mais direta nem uma estrutura na qual qualquer técnica direta disponível possa ser inserida.
A heurística é um procedimento para resolver problemas através de um enfoque intuitivo,
em geral racional, no qual a estrutura do problema passa a ser interpretada e explorada
inteligentemente para obter uma solução razoável. Para os estudiosos de IA, as heurísticas são
critérios, métodos ou princípios para decidir, entre vários cursos de ação alternativos, aquele
que parecer mais atraente para atingir algum objetivo.
As técnicas de busca heurísticas são (FERNANDES,2003):
2.1.4.1.1 Busca em profundidade:
É também denominada de “primeiro em profundidade” (ou depth first) e explora o
caminho para o objetivo, dando preferência aos nós que estão mais distantes da raiz da árvore
de busca. É aplicável quando as soluções são total e igualmente desejadas ou quando, em uma
varredura prévia, direções incorretas são detectadas. Conforme figura 1, que mostra a ordem
em que os nodos são visitados.
Figura 1. Busca em Profundidade.
2.1.4.1.2 Busca em largura:
Esta é o oposto de depth first e trabalha com o critério FIFO (First In First Out). É
também denominada de busca em amplitude, em nível ou breadth first. Todos os nós de certo
9
nível da árvore são examinados antes dos níveis abaixo, caso exista uma solução e se o grafo é
finito, a solução será encontrada. Existem alguns inconvenientes na utilização desta técnica:
requer muita memória (pois o número de nós é exponencial em relação à profundidade); exige
um esforço computacional relativamente grande se o comprimento dos caminhos não for
pequeno, o esforço com os operadores de pouca importância assume as mesmas proporções que
com os operadores mais importantes. Na figura 2, observa-se como é feita essa varredura pelo
algoritmo, que escolhe visitar os nodos mais próximos do nodos iniciais, mantendo sempre um
conjunto de caminhos candidatos que é a verdadeira podendo ser estendida até algum nodo
objetivo.
Figura 2. Busca em Amplitude.
2.1.4.1.3 Gera e Testa:
É um procedimento de busca em profundidade, pois as soluções devem estar completas
para serem testadas. A sua forma aleatória, não garante que alguma solução seja encontrada e
também que todas elas sejam geradas. A forma mais adequada de implementar o método é usar
a busca em profundidade adicionando backtracking (ato de retroceder na busca a um nível
anterior, em geral com o objetivo de tentar uma outra alternativa de solução). É aceitável
quando se trata da solução de problemas simples ou quando for usado como método auxiliar de
outra técnica.
2.1.4.1.4 Busca em feixe:
É uma alternativa do método de busca em largura. Existe uma restrição ao número de nós
que serão considerados em cada nível. Por exemplo, se este número não ultrapassar três, então,
no máximo será explorada três vezes a profundidade de nós. Isto reduz o esforço de busca e
proporciona bons resultados quando houver bons critérios para escolha de nós.
10
2.1.4.1.5 Subindo o morro:
Também chamada de subida de encosta (ou subida da montanha, ou Hill Climbing) pode
ser uma variante do gera e testa, acrescentando-se as informações que ajudam a decidir em qual
direção prosseguir. É um método que usa a idéia de que o objetivo deve ser atingido com o
menor número de passos. O suporte é dado pela idéia heurística de que o número de passos
para atingir um objetivo é inversamente proporcional ao seu tamanho.
2.1.4.2 Utilização da Busca Heurística
Para a utilização de busca heurística, o objetivo a ser alcançado deve estar explícito,
porém dentro do contexto desse jogo, o objetivo de alcançar a torre adversária não é explícito,
pois não se tem a localização exata da mesma, tendo isso em vista a busca heurística será
utilizada a partir de determinada parte do jogo, e não do seu início.
A busca heurística pode ser utilizada em vista de outro objetivo, o de eliminar peças
com patentes altas. Após a descoberta de uma determinada patente com essas características, a
busca heurística avalia e efetua uma busca para eliminá-la.
2.1.5 Inteligência Artificial Aplicada em Jogos
Os jogos eletrônicos acuparam as faculdades intelectuais dos homens, e chegando
algumas vezes a um gráu alarmante. (RUSSELL, NORVIG, 1995).
Quando se trata de criar um oponente eletrônico, isso compete muitas incertezas, pois
nunca se sabe o que um jogador venha a fazer, pois o jogador tentará até onde for possível
minimizar o seu oponente eletrônico (RUSSELL, NORVIG, 1995).
A IA procura simular o cérebro humano através de algoritmos e heurísticas, com o
objetivo de criar programas que imitem a maneira de pensar dos seres humanos. Projetando
esse objetivo ao limite, espera-se que no futuro, seja possível interagir com um programa de
computador e não saber se nosso interlocutor é de fato uma máquina ou uma outra pessoa. É
exatamente isso que o jogador espera dos comportamentos de jogos (SANTOS, 2002).
Para atingir esse realismo, torna-se cada vez mais comum nos jogos a implementação de
algoritmos clássicos das mais variadas áreas de IA (SANTOS, 2002).
11
Nos jogos, uma outra espécie de busca é feita, como damas e xadrez. Os nós em uma
árvore de jogo, naturalmente, representam configurações do tabuleiro, e são ligadas por meio
de ramos que transformam uma situação em outra. Naturalmente há uma nova guinada, pois as
decisões são tomadas por duas pessoas, atuando como adversárias, cada uma tomando uma
decisão por sua vez (WINSTON, 1988).
Programas como jogos foram muito importantes para a área de IA, pelo esclarecimento
trazido a respeito da importância relativa dos diversos aspectos envolvidos em uma atividade
inteligente (BITTENCOURT, 1996).
Consideremos jogos com dois jogadores, que chamaremos de MAX e MIN por razões
que logo ficarão óbvias. MAX faz o primeiro movimento, e depois eles se revezam até o jogo
terminar onde um jogo pode ser definido como uma espécie de roblema de busca (RUSSELL,
NORVIG, 1995).
2.1.5.1 Mini Max
Em jogos é necessário levar em conta as possíveis jogadas do oponente, os nodos
(pontos ou vértices) da árvore de busca são divididos em dois tipos: os nodos “OU”, que
representam situações no qual o mecanismo de busca é livre para escolher a próxima jogada, e
os nodos “E”, que representam situações onde o oponente deve jogar (BITTENCOURT, 1996).
A primeira técnica para busca em árvores de jogos foi o procedimento Mini Max. O
procedimento funciona da seguinte forma: inicialmente é construída uma árvore completa onde
a raiz corresponde à situação atual do jogo e as folhas correspondem a situações sem sucessores
(vitórias, empates ou derrotas). Em seguida, atribui-se uma avaliação estática para cada
situação, essa avaliação geralmente é representada por uma função simétrica onde existe o
estado de vitória, derrota ou empate. O próximo passo é propagar essas avaliações em direção à
raiz do grafo, respeitando a liberdade do oponente escolher sua jogada. Isto é feito da seguinte
maneira: a cada nodo tipo “OU”, com sucessores já avaliados, atribui-se o valor máximo dentre
as avaliações dos sucessores, pois este tipo de nodo corresponde a situação onde a próxima
jogada pode ser escolhida pelo procedimento, os nodos do tipo “E” atribui-se o valor mínimo
das avaliações dos sucessores, pois supõe-se, neste caso, que o oponente escolherá a jogada que
lhe seja mais proveitosa, que no ponto de vista do procedimento é a que recebe a pior avaliação
O nodo raiz é sempre um nodo do tipo “OU” pois o procedimento visa determinar qual
é a melhor jogada do ponto de vista do próprio procedimento. Ao terminar a propagação, o
12
sucessor da raiz com a melhor avaliação corresponderá a melhor jogada. O resultado do
procedimento pode conter mais informações do que apenas a melhor jogada, pois pode
armazenar também um ponteiro para o nodo que corresponde àquela avaliação, de maneira que
ao atingir a raiz disponha-se de todo o caminho que, do ponto de vista do procedimento,
corresponde ao jogo ideal a partir da situação inicial dada. Quando o jogo se torna complexo,
esta informação adicional pode economizar o trabalho necessário para a determinação das
jogadas futuras (BITTENCOURT, 1996).
2.1.5.2 Alfa Beta
“O procedimento Mini Max pode ser otimizado, na medida em que é possível construir
um outro procedimento que obtém sempre os mesmos resultados e que, no entanto, dependendo
da situação, examina menos nodos da árvore de busca” (BITTENCOURT, 1996).
O procedimento Alfa-Beta confia no fato de que o oponente esteja seguro de que um
movimento é desastroso, não tendo mais a necessidade de explorar mais esse movimento
(WINSTON, 1988).
A situação chamada Corte Beta é a situação mostrada na Figura 3 (BITTENCOURT,
1996).
a: <=10
b: 10
d: 5
c: >= 20
e: 10
f: 20
g: ?
Figura 3: Corte Beta.
Neste caso, ao encontrar o valor 10 para “b”, sabe-se que o valor de “a” será inferior a
10. O valor 20 de “f” com que o valor de “c” seja necessariamente maior ou igual a 20,
tornando irrelevante do ponto de vista de “a”, o valor de “g”. O procedimento que inclui esse
refinamento é chamado de Alfa Beta (BITTENCOURT, 1996).
2.2 LINGUAGEM DE PROGRAMAÇÃO
13
Uma linguagem de programação é um conjunto de termos (vocábulos) e de regras
(sintaxe) que permitem a formulação de instruções a um computador.
2.2.1 Linguagem C
A Linguagem C foi desenvolvida na década de 1970, nos laboratórios Bell. Essa
linguagem foi construída a partir da Linguagem B que foi criada no final da década de 1960 por
Ken Thompson e Dennis M. Ritchie (HICKSON, 2002).
Pode ser considerada uma linguagem de programação de médio nível, pois possui tanto
instruções de alto nível e estruturada, como também instruções tão próximas da máquina, que
só o Assembler possui. Contudo, utilizando a Linguagem C podemos construir programas
organizados e concisos, ocupando pouco espaço de memória com alta velocidade de execução
(HICKSON, 2002).
2.2.2 Linguagem C++
O projeto de linguagem de programação é um processo em constante evolução. Uma
nova linguagem é criada a partir de lições aprendidas com linguagens anteriores ou para
introduzir novos recursos e facilidades a uma linguagem existente (HICKSON, 2002).
A Linguagem C++ foi desenvolvida a partir da linguagem de programação C, e com
poucas exceções a Linguagem C++ mantém a Linguagem C como subconjunto
(STROUSTRUP, 2000).
A Linguagem C++ é orientada a objeto. Programação orientada a objeto é uma reação a
problemas que foram percebidos pela primeira vez em programas muito extensos
desenvolvidos na década de 1970. Todas as linguagens de orientação a objeto tentam atingir
três objetivos, como uma forma de impedir que ocorram os problemas inerentes a projetos
muito grandes: abstração do softwares, objeto e polimorfismo (HICKSON, 2002).
2.3 COMPUTAÇÃO GRÁFICA
A Computação Gráfica é a sub-área da Ciência da Computação que representa
graficamente as informações através de algoritmos, técnicas e metodologias que possibilitam a
criação, o armazenamento e manipulação de modelos de objetos e suas imagens via
computador (SANCHES, 2004).
14
“Segundo a ISO (International Standards Organization), a Computação Gráfica pode
ser definida como o conjunto de métodos e técnicas utilizados para converter dados para um
dispositivo gráfico, via computador” (SANCHES, 2004).
2.3.1 OPEN-GL
O OPEN-GL (Open Graphics Library) é uma biblioteca de rotinas gráficas para
trabalhar em duas ou três dimensões (SANCHES, 2004).
Criada pela empresa Silicon Graphics oferece vários recursos aos programadores,
proporcionando maior facilidade de programação, muito utilizada na criação de jogos. São
API’s (Aplication Programming Interface) que fazem chamadas aos recursos de hardware
oferecidas pelos processadores gráficos (VANZIN, 2001).
O OPEN-GL foi desenvolvido para trabalhar de maneira eficiente mesmo se o
computador que mostra os gráficos não é o computador que contêm o hardware gráfico. Para
atingir tais qualidades, nenhum comando para realizar operações de janela ou obtenção de
dados do usuário é incluído no OPEN-GL, ao invés disso deve-se trabalhar através do
controlador de janelas específico para o hardware que está sendo utilizado.
Devido às funcionalidades providas pelo OPEN-GL, esta API tem se tornado um padrão
largamente utilizado em diversos setores, pois, possui rotinas estáveis e boa documentação.
As funções seguem um padrão em relação às suas notações, de forma geral, podemos
esquematizar conforme a tabela 1:
Tabela 1: Forma geral
1
Nome da função
Nº de variáveis Tipo de variáveis
Forma vetorial
argumentos
Porém, nem todas as funções seguem exatamente esse formato. Por exemplo, o OPENGL possui funções que não recebem parâmetros, como o “glFlush()” , ou que só podem receber
um tipo, como “glClearColor()”, não possuindo nenhum tipo de referências ao argumento.
O OPEN-GL funciona como uma máquina de estados, ou seja, uma parte da memória é
reservada para armazenar o estado atual das diversas variáveis envolvidas no processo de
renderização.
2.4 ANÁLISE DE PROJETO ESTRUTURADO
15
Uma das técnicas para modelagem de sistemas é a Análise Estruturada que surgiu na
década de 1970 e que é bastante utilizada por empresas de desenvolvimento. Foi criada por
Tom De Marco e adaptada por outros autores, sendo um deles Gane&Sarson, popularizando-se
como o “método de Gane”.(GANE, 1983)
A Figura 4 mostra os símbolos utilizados para a modelagem, nível de análise, dos
conceitos apresentados anteriormente. Salienta-se que há algumas alterações nos símbolos
utilizados de autor para autor.
Figura 4 – Simbologia utilizada para Análise Estruturada / Análise Essencial.
2.5 JOGOS ELETRÔNICOS
Os jogos eletrônicos sempre representaram um grande mercado econômico, mas essa
popularidade comercial não costuma se refletir no meio acadêmico. Entretanto, embora estejam
associados ao divertimento, os jogos eletrônicos são uma importante classe de sistemas.
Utilizando técnicas inovadoras de computação e ciências correlatas, os jogos são um
interessante domínio de aplicação para o desenvolvimento e validação de novas técnicas
computacionais, visto que possuem características críticas, como execução em tempo real e
pouca capacidade de processamento (ANDRADE, 2004).
O desenvolvimento de jogos eletrônicos apresenta características diferentes do
desenvolvimento de software, principalmente por serem projetos relativamente grandes, e por
serem constituídos de produtos artísticos até certo ponto (TATAI, 2004).
As linhas gerais de jogos a ser desenvolvidos envolvem alguns casos (TATAI, 2004):
Idealização das linhas a serem desenvolvidas, envolvendo em alguns casos story-boards,
arte-conceito, etc;
16
Implementação do mecanismo do jogo, implementação de protótipo, implementação de
ferramentas para artistas / projetistas de jogos (game-designers);
Realização do projeto de fases (level-designers), juntamente com á realização do trabalho
de arte e som;
Depuração, teste do jogo (play-testing, realizado por jogadores) documentação;
Documentação do jogo.
A arquitetura de um jogo de computador envolve os seguintes componentes (TATAI,
2004):
Motor (engine): O motor é responsável por implementar o módulo de renderização gráfica
do jogo, freqüentemente coordena os outros componentes.
Rede: O componente de rede é responsável pela comunicação externa, tanto com outro
jogador ou com algum servidor.
Som: Fortemente integrado ao motor, responsável para gerenciar os sons e músicas que
compõem o jogo.
IA: Componente responsável por implementar o controle dos oponentes ou aliados
automatizados que fazem parte do jogo.
17
CAPÍTULO 3
DESENVOLVIMENTO
3.1 RECURSOS NECESSÁRIOS
O software deve ser desenvolvido em plataforma de linguagem C/C++, mais
especificamente DEV-C++ como compilador, pois é um compilador de entendimento fácil por
causa de sua interface. È um ambiente integrado, dando suporte a compiladores baseados no
GCC (GNU Compiler Collection). A licença GNU/GPL (General Public License) é utilizada
para software de domínio publico, isso é, não é necessário comprá-lo para poder utilizá-lo.
A linguagem C/C++ foi escolhida por trabalhar em perfeitamente com componentes de
hardware, seu arquivo compilado é de execução rápida, e pode ser compilado em muitos SO
(Sistema Operacional), com poucas alterações em seu código.
O OPEN-GL disponibiliza bibliotecas gráficas que contribuem para o desenvolvimento da
interface gráfica, proporcionando um ambiente amigável ao jogador.
O SO deve ser o Microsoft Windows, por esse ser um sistema comercial, deve ser
adquirida uma licença do Microsoft Windows 98 ou superior.
Os custos referentes ao desenvolvimento estão em licença do SO, equipamento e a hora
técnica trabalhada, que deve ser utilizada um total de 230 horas de trabalho.
Tabela 2: Custos referentes ao desenvolvimento do projeto
Qtd.
Descrição
Custo
01
Licença do Sistema Operacional Windows 98.
R$ 250,00
01
Editores de texto e softwares administrativos (OPEN OFFICE).
R$ 0,00
01
Biblioteca de desenvolvimento gráfico (OPEN-GL)
R$ 0,00
01
Linguagem de programação e compulador (DEV C++, GCC).
R$ 0,00
01
Equipamento de desenvolvimento com gravador de CD (AMD- R$ 1200,00
Duron 1.3, 128 MB RAM).
01
Mídia de Backup (CD-RW)
R$ 10,00
01
Hora técnica de desenvolvimento
R$ 20,00
18
Totalizando R$ 9.200,00 no que se diz respeito à mão de obra, isso inclui
desenvolvimento e pesquisa, individualmente o valor é de R$ 4.600,00.
O total em custos para o desenvolvimento, incluindo equipamento, licença, softwares e
desenvolvimento / pesquisa é de R$ 10.680,00.
3.2 ESPECIFICAÇÃO E DESENVOLVIMENTO DO PROJETO
3.2.1 Especificações Técnicas
O Jogo de Estratégia Militar foi dividido em várias partes no que diz respeito a seu
desenvolvimento, são elas:
3.2.1.1 Protótipo gráfico:
Implementação em linguagem C++ utilizando as API´s do OPEN-GL para sua
construção.
Este protótipo consolida a representação do sistema para o usuário, pois todas as
operações realizadas serão visualizadas pelo protótipo gráfico.
Além de representar graficamente o sistema esse protótipo possui uma matriz gráfica na
qual é responsável pela distribuição das peças do jogador, atualizando as matrizes do console.
3.2.1.2 Protótipo console:
Implementação em linguagem C++ utilizando recursos não Orientados a Objetos com a
finalidade de ganhar desempenho.
O console se responsabiliza pela distribuição das peças do computador, realização dos
confrontos e verificação do vencedor.
A distribuição de peças segue o objetivo de não repetir sua distribuição sempre que o
jogo seja iniciado. Se um algoritmo inteligente fosse implementado para essa operação todas as
vezes que o jogo fosse iniciado a formação seria a mesma, uma vez que o computador
encontrou a melhor distribuição, para evitar isso a maioria das peças é colocada de forma
aleatória no tabuleiro, porém segue algumas regras de estratégias básicas para isso.
O protótipo gráfico possui um total de três matrizes para a realização de suas tarefas, a
cada jogada todas a matrizes são atualizadas com seus respectivos valores, as matrizes são:
Matriz de propriedade: Essa matriz possui a representação de todas as peças, verificando
se a peça é do jogador ou do computador, também é marcado os locais livres e com lagos
19
(locais no tabuleiro que não é permitida a jogada), a verificação se a jogada é valida ou se
existe algum confronto é diretamente ligada a esse matriz.
Matriz de patentes: Essa matriz armazena a posição de todas as patentes, tanto do jogador
quanto do computador, apesar de possuir esse matriz internamente os algoritmos de busca e o
jogador não possuem acesso a ela, a finalidade dessa matriz esta ligada diretamente aos
confrontos, pois a resposta do vencedor sairá dessa matriz.
Matriz do computador: Essa matriz possui o posicionamento das peças do computador e
as do jogador caso estas estejam abertas, sendo a única matriz que o algoritmo de busca tem
acesso, as jogadas realizadas pelo computador são todas nessa matriz, atualizando as outras
matrizes do console.
3.2.2 Diagrama de desenvolvimento
A representação de diagramas realizadas no projeto foram feitas com base em análise
estruturada.
Podemos apontar como principais estruturas os seguintes itens:
- JOGO
- TABULEIRO
- JOGADOR
- PEÇA
- COMPUTADOR
- PESSOA
Estes itens recebem o nome de processo, cada processo é uma operação do sistema, sendo
através do processo temos o processamento de dados e a conseqüência transformação de dados
de entrada em resultados na saída do processo.
Os processos são interligados pelo Modelo ambiental, a Figura 5 representa este modelo
20
Figura 5: Modelo Ambiental.
Esse diagrama apresenta o jogo como principal processo, responsável pelo inicio das
operações realizadas como inicio e término.
O tabuleiro apresenta processos como inicializar as matrizes, analisar movimentos,
efetivar ataque e atualizar derrotas.
As peças que são processos completos, na qual armazenam valores, estes valores são
atribuídas individualmente a elas, uma vez que no Jogo de Estratégia Militar estes são
21
atribuídos pela sua patente, que é armazenada na sua descrição, sendo responsável pela
indicação de um vencedor em um determinado confronto entre peças.
O processo Jogador é responsável pela efetivação de jogadas, tanto do jogador quanto do
computador, este processo recebe a linha e coluna atual e as novas linhas e colunas, sendo
responsável pela sua movimentação e atualização do processo tabuleiro.
O processo Computador é responsável para dar pesos as jogadas, sendo este processo que
indica qual jogada será efetuada, possuindo em seu interior uma lista de decisões que deverão
ser tomadas no decorrer do jogo.
Pessoa é um processo que representa apenas as movimentações realizadas pelo jogador
humano que interage com o jogo.
3.3 AMBIENTE DE EXECUÇÃO DO PROJETO
O software pode ser jogado em equipamentos padrão ou compatíveis com o IBM-PC,
com sistema operacional Windows 98 ou superior, é preciso ter uma placa de vídeo com
suporte ao VGA (Video Graphics Array) para a apresentação gráfica, e é aconselhável no
mínimo 4 MB de memória RAM de vídeo, pois o processamento gráfico do equipamento não
necessita ser muito avançado.
O equipamento deve possuir um mínimo de 64 MB de memória principal, processador
de 500 MHz e 20 MB de memória em disco principal, uma unidade de entrada de dados, pode
ser Internet, CD-ROM ou disquete, para que o jogo possa ser instalado. Recomenda-se uma
Placa com suporte OPEN-GL, pois a mesma possui os cálculos gráficos processados por ela
sem a utilização do processador para realizar tal tarefa.
Tabela 3: Custos para execução do sistema
Qtd.
Descrição
Custo
01
Licença do Sistema Operacional Windows 98
R$ 250,00
01
Equipamento para execução (AMD-K6 500, 64 MB RAM)
R$ 700,00
01
Bibliotecas Gráficas OPEN-GL
R$ 0,00
O total de custos para a execução do sistema é de R$ 950,00, levando em consideração
que não há custos para a aquisição do software.
22
3.4 PONTOS FORTES E FRACOS
Um dos pontos fortes desse projeto é a utilização de softwares de domínio público e
softwares grátis, o seu desenvolvimento, por se tratar de uma linguagem existente em muitas
plataformas, a compilação e execução em outro SO é facilitada, isto é, qualquer computador
com um compilador C/C++ pode executá-lo com poucas alterações em seu código fonte.
Com base na licença GNU, o software assim como seus fontes são de livre distribuição,
assim pode ser classificado como “open source”.
Como desvantagem, por possuir gráficos desenvolvido em OPEN-GL, sua execução
pode não ser satisfatória em máquinas que utilizam cálculo gráfico via software (placas sem
suporte OPEN-GL), podendo ter sua execução prejudicada.
O programa não possui uma opção para jogar em rede, sendo seu uso restrito a apenas
um computador e um jogador, impossibilitando de ser jogado em duas pessoas, uma vez que no
contexto do jogo ele não pode ser jogado por duas pessoas no mesmo computador.
3.5 CRONOGRAMA DE ATIVIDADES
O cronograma é um instrumento que nos auxiliará no desenvolvimento do projeto,
possibilitando ter um visão dos acontecimentos ocorrido em um período de tempo, a Tabela 4
demonstra claramente o que deve ser desenvolvido e em quanto tempo se levou em cada etapa
do projeto seguindo com um detalhamento de todas as fases implementadas.
Tabela 4: Etapas de desenvolvimento do projeto.
Período
P
01/02/2004 – 14/02/2004
R
01/02/2004 – 14/02/2004
P
14/02/2004 – 04/03/2004
R
14/02/2004 – 04/03/2004
P
04/03/2004 – 10/03/2004
R
04/03/2004 – 10/03/2004
P
10/04/2004 – 20/04/2004
R
10/04/2004 – 20/04/2004
Atividade
Concepção da idéia e modificações.
Elaboração do pré-projeto.
Redação do projeto teórico.
Pesquisa de viabilidade do protótipo gráfico.
continuação
23
conclusão
P
20/04/2004 – 05/05/2004
Protótipo gráfico.
R
20/04/2004 – 05/05/2004
P
05/05/2004 – 22/05/2004
R
05/05/2004 – 22/05/2004
P
22/05/2004 – 30/05/2004
R
22/05/2004 – 30/05/2004
P
30/05/2004 – 10/06/2004
R
30/05/2004 – 15/06/2004
P
10/06/2004 – 26/06/2004
R
15/06/2004 – 26/06/2004
P
26/06/2004 – 03/07/2004
R
26/06/2004 – 03/07/2004
P
03/07/2004 – 30/07/2004
R
03/07/2004 – 15/03/2005
P
31/08/2004 – 30/09/2004
R
15/08/2004 – 30/10/2004
P
01/10/2004 – 30/11/2004
R
01/10/2004 – 15/03/2005
P
31/11/2004 – 10/12/2004
R
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
P
10/12/2004 – 15/03/2005
R
10/12/2004 – 15/03/2005
P
15/03/2005 – 30/06/2005
Implementação e Aplicação das Funções de Inteligência
R
15/03/2005 – 30/06/2005
Artificial e correções apresentadas no trabalho escrito
P
30/06/2005 – 11/07/2005
R
30/06/2005 – 11/07/2005
Redação do trabalho escrito.
Correções e alterações necessárias.
Aprimoramento do protótipo.
Redação e fundamentação do trabalho escrito.
Preparação para defesa do trabalho escrito.
Implementação do protótipo de Inteligência Artificial.
Redação das documentações necessárias.
Correções de eventuais problemas.
Preparação para defesa do trabalho como um todo.
Aprimoramento das jogadas do computador
Preparação para a defesa final do trabalho
P= Cronograma Previsto
3.5.1 Detalhamento do Cronograma
R= Cronograma Realizado
24
Concepção da idéia e modificações: Nascimento da idéia de desenvolver um software de
entretenimento que deve utilizar técnicas de IA. Elaboração teórica do que deve ser feito para a
avaliação do projeto.
Elaboração do pré-projeto: Descrição do documento assim com a escolha do professor
orientador. Esclarecimento de dúvidas relacionadas ao pré-projeto adequando o mesmo para o
projeto.
Redação do projeto teórico: Elaboração do documento a ser entregue conforme normas
estipuladas.
Pesquisa de viabilidade do protótipo gráfico: Aquisição de ferramentas e estudo das
melhores ferramentas para o desenvolvimento do protótipo.
Protótipo gráfico: Implementação do protótipo gráfico, com a ferramenta escolhida.
Redação do trabalho escrito: Escritura da documentação a ser entregue na data estipulada,
juntamente com a primeira versão do pôster.
Correções e alterações necessárias: Realização de correções que eventualmente venham a
ser encontradas no trabalho escrito.
Aprimoramento do protótipo: Implementação de novos comandos, viabilizando uma
melhor resolução do jogo.
Redação e fundamentação do trabalho escrito: Entrega de toda a documentação definitiva
juntamente com o pôster.
Preparação para a defesa do trabalho escrito: Preparação para a defesa junto a banca
examinadora, do trabalho desenvolvido.
Implementação do protótipo de Inteligência Artificial: Não realizada.
Realização de testes para a verificação de desempenho: Não realizada.
Redação das documentações necessárias: Elaboração do documento que mostrará os
relatórios dos desempenhos alcançados com os testes realizados.
Correções de eventuais problemas: Nessa etapa é feita uma revisão de toda a
documentação gerada, dando os seus ajustes finais, preparando para a defesa.
Preparação para a defesa do trabalho com um todo : Não realizado.
Aprimoramento das jogadas do computador : Serão implementadas as jogadas especiais
que o computador realizará em cada jogada, obedecendo as regras do jogo.
Implementação e Aplicação das Funções de Inteligência Artificial e correções
apresentadas no trabalho escrito: A implementação das jogadas de inteligência artificial é
melhor estudada e aplicada de forma que possa ter um comportamento condizente com o
25
objetivo proposto, juntamente será feita as correções no trabalho escrito que forem propostos
pelo orientador.
Preparação para a defesa final do trabalho : Preparação do material de apoio que será
usado na defesa.
26
CAPÍTULO 4
RESULTADOS
4.1 INTRODUÇÃO
Com base nos objetivos do projeto, tem-se a necessidade de apresentar os resultados
obtidos na execução do projeto provenientes de testes.
4.2 DISTRIBUIÇÃO DE PEÇAS
O hardware não é peça fundamental para a realização dos teste que são executados, uma
vez pode ser feita em qualquer outra máquina desde que possua as configurações mínimas
exigidas para o projeto, não influenciando nos resultados dos testes.
Os teste com relação a realização do objetivos tiveram sucesso, pois todas as execuções
geraram posicionamento diferente na maioria das peças.
Esse objetivo foi alcançado graças a grande utilização de alocação de peças de forma
aleatórias, a Tabela 5 mostra um exemplo de resultado obtido após 3 execuções do algoritmo, a
peça em questão possui a patente número 12 (torre), sendo a principal peça estática do jogo de
estratégia militar.
A patente 12 sempre estará posicionada na linha 0.
Tabela 5: Teste de Posicionamento da Torre.
Execução
Patente
Linha
Coluna
1º
2º
3º
12
12
12
0
0
0
3
8
2
O Algoritmo de posicionamento posiciona a torre sempre na linha 0 tendo sempre a
variação na coluna, porém ela nunca será posicionada nas extremidades do tabuleiro, ou seja,
jamais estarão na coluna 0 ou 14.
Outro teste realizado condizente a distribuição da torre é que as bombas sempre estarão
posicionadas ao seu redor, resultado este obtido com sucesso.
As peças restantes foram testadas em duas execuções, onde podemos observar que:
27
As Minas Terrestres estão presentes em todas a linhas, mas diferenciando nas colunas,
propiciando assim uma melhor estratégia.
O Espião estará posicionado na 3ª linha, mudando sempre de lugar nas colunas, sendo que
nunca estará na 4ª fila, ficando de fronte com o inimigo imediato, evitando sua perda precoce.
Os Soldados estão sempre espalhados pelo tabuleiro, tendo em vista que é a de maior
quantidade no jogo.
Devido também a um numero grande de peças, será sempre encontrada por todas as partes
do tabuleiro, ajudando assim na descoberta das Minas e das Bombas.
As patentes 5, 6, 7,e 8 como podemos observar, estarão presentes em quase todas as
linhas, diversificando as colunas, fazendo uma movimentação essencial para o desarmamento
das estratégias inimigas.
Nos testes ocorreram que as peças de maior grau hierárquico estão sempre postadas nas 3ª
e 4ª fileiras, podendo assim desfazer um possível ataque de peça de grau elevada, ocorrendo
uma perda excessiva de peças do contingente.
Podemos observar na tabela 6, de como foi o resultado obtidos nos teste de execução para
a disponibilização das peças feita pelo computador, obtendo resultados satisfatórios.
Tabela 6: Teste de Posicionamento das Peças
Patente
Linhas
s
1ª
Execução
1
2ª
1ª Execução
2ª Execução
1ª,2ª,3ª,4
0ª,6ª,12ª,14ª
0ª,2ª,7ª
Execução
1ª,2ª,3ª,4
ª
Colunas
ª
2
3ª
3ª
8ª
10ª
3
1ª,2ª,3ª,4
1ª,2ª,4ª
5ª ~ 14ª
1ª ~ 10ª
1ª,3ª,4ª
1ª,3ª,4ª
3ª,4ª,8ª,9ª,10ª,1
9ª,10ª,11ª,12ª
2ª,4ª,5ª,7ª
2ª,6ª,8ª,9ª,10ª,1
ª
4
1ª
5
1ª,2ª,3ª,4
ª
1ª,2ª,3ª,4
ª
1ª
6
3ª,4ª
2ª,3ª,4ª
0ª,1ª,3ª,4ª,5ª
0ª,1ª,3ª,4ª,8ª,9ª
7
1ª,2ª,3ª
1ª,2ª,3ª
1ª,2ª,3ª
1ª,2ª,5ª,6ª
8
1ª,2ª
1ª,2ª
1ª,2ª,7ª
3ª,4ª,7ª
28
9
2ª,3ª,4ª
2ª,3ª
9ª
13ª,14ª
10
4ª
3ª
8ª
9ª
11
3ª
2ª
7ª
12ª
O jogador também pode utilizar dessa funcionalidade para seu uso observando uma
adaptação para o mesmo algoritmo segundo a mesma lógica de posicionamento e obtendo os
mesmos resultados.
4.3 REALIZAÇÃO DE JOGADAS
Com as técnicas de minimax, foram feitas as jogadas do computador, onde é realizado
as movimentações das peças, verificando a localização do seu oponente e em que direção deve
ser jogada a peça, podendo ser a um possível confronto ou recuo da peça.
Para simplicicar esta afirmação, podemos demonstrar com alguns exemplos de
execução.
Na Tabela 7, consta o comparativo de duas peças e das linhas subseqüentes, note que o
Soldado avança uma linha e o cabo armeiro continua parado, mesmo tendo um valor maior na
execução, neste caso compreendamos que a jogada do soldado é melhor, pois temos vários
fatores que podem não executar a jogada representada neste como Cabo Armeiro, estes fatores
podem tanto ser um lago na sua frente, como uma peça do próprio jogador.
Tabela 7: Jogada do Soldado.
PEÇA
VALOR
LINHA ANTERIOR
LINHA POSTERIOR
Soldado
10
3
4
Cabo Armeiro
100
5
5
Em um outro exemplo de execução, tendo ambas as peças condições de execução, o
Cabo Armeiro seria a escolha do algoritmo para realizar a jogada, como demonstrado no Tabela
8, note que neste exemplo o maior valor executa a jogada, tendo como principio que está é a
melhor jogada.
Tabela 8: Execução do maior valor.
PEÇA
VALOR
LINHA ANTERIOR
LINHA POSTERIOR
Soldado
10
3
3
29
Cabo Armeiro
100
12
13
Todas as jogadas são encaradas como melhor desde que siga conceitos básicos do jogo,
como não podendo realizar uma jogada sobre suas prórpias peças, ou sobre os lagos, também é
correto afirmar que o algoritmo impõem valores maiores a execução de confrontos, pois está é
a única forma de abrir as peças do adversário, podendo colocar valores diferentes de execuções
para as peças abertas. Os lagos aqui mecionados são mais fácil visualizado no item 4.4, na qual
apresenta a Interface do Jogo de Estratégia Militar.
4.4 INTERFACE GRÁFICA
Um jogo é representado de vários estados no que diz respeito a interfaces gráficas,
sendo uma tarefa impossível descrever todos os possíveis estados do jogo ou tabuleiro. Porém o
Jogo de Estratégia Militar possui algumas interfaces que podem ser consideradas principais,
como a própria imagem do tabuleiro representado na Figura 6.
Figura 6: Tela com peças
30
A Figura 6 mostra o tabuleiro com as peças posicionadas em sua matriz gráfica, as
peças são distinguidas pelo jogador através de sua cor, sendo as peças vermelhas do jogador e
as azuis do computador. No tabuleiro existem dois quadrados azuis que representam os lagos,
não é permitido realizar jogadas passando pelos lagos, sendo uma dificuldade implementada no
jogo.
Vale lembrar que o jogador nunca sabe as peças do computador assim como o
computador não sabe a posição das peças do jogador.
No lado direito da tela o jogador tem acesso ao nome das patentes e sua representação
numérica, também é identificado a forma de sair do jogo, que vem a ser utilizando a tecla
“ESCAPE” do teclado.
O jogo possui verificações de jogadas validas, não permitindo por exemplo que o
jogador ataque suas próprias peças emitindo a mensagem de erro representada na Figura 7.
Figura 7: Jogada sobre Jogador.
Quando uma jogada desse tipo é realizada o jogador deve realizar outra jogada, uma vez
que a jogada não foi efetivada.
O jogo possui alguma peças estáticas como bombas, minas terrestres e a própria torre,
quando uma dessas peças tenta ser movimentada uma mensagem é exibida avisando ao jogador
que ele está tentando movimentar um peça estática, a Figura 8 representa a tentativa de
movimentar uma bomba.
Figura 8: Movimentação de bomba.
31
Da mesma forma de uma jogada inválida, o sistema volta a interação do jogador, tendo
que realizar outra jogada.
32
CAPÍTULO 5
DISCUSSÃO E CONCLUSÕES
5.1 ANÁLISE DOS RESULTADOS
Os resultados obtidos até então estão satisfatórios se analisados pelo objetivo, como o
algoritmo responsável por tal feito não possui uma base de conhecimentos para a distribuição
de peças pelo motivo já comentado no item 3.2.1 Especificações técnicas.
Analisando os resultados obtidos no capítulo anterior, pode observar que a distribuição
das peças feito pelo computador encontra-se dentro do esperado, pois a torre não está
posicionada sempre em um mesmo lugar, ocorrendo assim uma dificuldade ao jogador em
saber a localização da torre, e sempre ao redor da mesma haverá minas e bombas que
protegerão de possíveis ataques. As peças de menor patentes estarão sendo posicionadas nas
linhas 1, 2 e 3 aleatoriamente, não havendo a possibilidade de serem postas em outras linhas do
tabuleiro.
O posicionamento das peças do jogador, possui uma demora na colocação, tendo em
vista que o jogador deve colocar as peças uma de cada vez clicando com o mouse e arrastando a
peça até o local desejado, mas que terá a restrição de linhas para o posicionamento que é das
linhas 11 à 14 do tabuleiro ( parte inferior da tela), montando sua estratégia de jogo, para só
então dar início a partida.
A interface gráfica do jogo, está condizendo com o esperado, estando de fácil
entendimento das peças, lagos e espaço para que se possa fazer as jogadas, estando com cores
distintas para facilitar a visualização, possui uma legenda dos números e as patentes a que elas
correspondem, e uma opção de tecla para que se possa interromper a partida a qualquer
momento.
A cada jogada realizada, é verificada se é válida ou não, interagindo com o jogador
mostrando uma MensageBox, avisando as jogadas invalidas e na tentativa de movimentação de
bombas, minas e torre.
Com relação a movimentação das peças, está ocorrendo conforme projetado, tendo a
peça soldado podendo pular quantas casas quiser na vertical ou horizontal, mas não podendo
passar sobre os lagos existentes, as demais peças podem pular somente uma casa de cada vez,
no confronto, as peças de menor grau ( patentes) estão saindo do tabuleiro e dando lugar a peça
33
vitoriosa, ocorrendo confronto de patentes iguais estão saindo as duas peças de dando lugar a
espaços em branco, que poderão ser utilizadas por outras peças no decorrer da partida.
A pertir das técnicas de MiniMax esclarecidas no item 2.1.5.1, na qual o algoritmo é
responsável por impor valores para a realização de jogadas, sendo o Mini as jogadas de valores
baixos, as quais o algoritmo entende como jogadas ruins e o Max sendo o inverso, escolhendo
assim a jogada com valor maximo realizando as assim definidas.
5.2 CONCLUSÕES
A definição de um projeto voltado à diversão eletrônica demonstra a princípio um certo
grau de simplicidade, porém após um maior aprofundamento em sua análise observa-se a
necessidade da utilização de ferramentas específicas que auxiliem no seu desenvolvimento.
Dentre estas ferramentas, deve-se enfatizar a Análise Estruturada, que proporciona uma
otimização muito grande com relação a outras técnicas de desenvolvimento, além de induzir a
uma fácil e rápida divisão das partes do projeto através das funções e seus complementos.
A IA vem complementar esse projeto adicionando uma carga positiva como uma grande
porta aberta auxiliando para a absorção de novos conhecimentos.
5.3 TRABALHOS FUTUROS
O software proposto para a utilização de IA é um jogo eletrônico, futuramente pode-se
construir mecanismos para a utilização do sistema em rede, fazendo o jogo possuir um modo
multi player, podendo melhorar graficamente o projeto assim como implementar fases.
Podem ser feita alterações para que o mesmo seja portado a outros SO´s, assim abrindo
mais suas opções de distribuição.
34
REFERÊNCIAS BIBLIOGRÁFICAS
ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. NBR 14724: Informação e
documentação: trabalhos acadêmicos: apresentação. Rio de Janeiro, 2002. 6 p.
documentação: citações em documentos: apresentação. Rio de Janeiro, 2002. 7 p.
documentação: referências: elaboração. Rio de Janeiro, 2002. 24 p.
ANDRADE G. D., Graduação em Ciência da Computação, proposta de D. Sc.,
UNIVERSIDADE
FEDERAL
DE
PERNAMBUCO.
Disponível
em
<http://www.cin.ufpe.br/~tg/2003-2/gda-proposta.doc.> Acesso em 10 mai. 2004, 13:20:00.
BARR, A., FEIGNENBAUM, E. A., The Handbook of Artificial Intelligence, Pitman
1981.
BODEN, M. A., Artificial Intelligence and Natural Man, Havester Press, 1977.
BITTENCOURT, M. L., Métodos Iterativos e Multigrid Adaptáveis em Malhas Nãoestruturadas, tese de D. Sc., UNICAMP, Julho, 1996.
BITTENCOURT,
G.,
Inteligência
Artificial.
Ferramentas
e
Teorias,
2.ed,
Florianópolis, 2001.
BOOCH, G., RUMBAUGH, J., JACOBSON, I., UML Guia do Usuário, Ed. Campus,
Rio de Janeiro, 5ª Tiragem, 2000.
FERNANDES, A. M. R., Inteligência Artificial. Noções Gerais. Ed. Visual Books,
2003.
GANASCIA, J. G., Inteligência Artificial. Ed. Ática, 1993.
35
GANE,
C.
Análise
estruturada
de
sistema.
Rio
de
Janeiro:
Livros
Técnicos Científicos, 1983.
GIRARDI,
R.
Reuso
de
Software,
2003
.
Disponível
em:
<maae.deinf.ufma.br/Ensino/ES/CGCC/ Reuso%20de%20software.pdf > Acesso em 11 mai.
2004, 11:45:00
HALABAN,
S.
Combate.
Disponível
em:
<www.ludomania.com.br/Modernos/combate.html>. Acesso em 15 abr. 2004, 11:41:00.
HICKSON R., Aprenda a Programar em C, C++ e C#, Editora Campus, Rio de
Janeiro, 2002.
LEMOS, A. Anjos interativos e retribalização do mundo. Sobre interatividade e
interfaces
digitais.
Disponível
em:
<
http://www.facom.ufba.br/ciberpesquisa/lemos/interac.html >. Acesso em: 10 abr. 2004,
22:04:00.
MARTINS, M., Paradigmas de programação III. Grafos. Disponível em <http://
sim.di.uminho.pt/disciplinas/ppiii-lesi/0304/APT_GRAFOS_0304.pdf >. Acesso em: 01 jun.
2004, 12:28:00.
MULLER, N. D., Grafos. Disponível em <http://www.ulbra.tche.br/~danielnm/ed/B/
polB.html>. Acesso em 07 jun. 2004, 16:15:00.
NASCIMENTO, C., YONEYAMA, T., Inteligência Artificial em controle e
automação, Editora Edgard Blücher LTDA, São Paulo, 2000.
RICH,
E., Inteligência Artificial. Editora Kapelusz, São Paulo, 1988.
RUSSELL, S. NORVIG P., Artificial Intelligence A Modern Approach, Prantice Hall,
New Jersey, 1995
36
SANCHES, I., Computação Gráfica. Disponível em: <www.ionildo.pop.com.br>
Acesso em 24 Jun. 2004.
SANTOS, G. L., Inteligência Artificial em jogos 3D. Disponível em: <www.
paralelo.com.br/documentos/Real-Time%20BSP-Based%20Path%20Planning%20with%20AStar%20(Full-Portuguese).pdf> Acesso em: 7 mai. 2004.
SCHWABE, D., CARVALHO, R. L. de Engenharia do Conhecimento e Sistemas
Especialistas. Editora Kapelusz: Buenos Aires, 1987.
SIMONS, G.T., Introdução a Inteligência Artificial. Ed. Classe,1998.
STROUSTRUP, B., A Linguagem de Programação C++. Ed. Bookman, Porto Alegre,
2000.
TATAI, V. K., Técnicas de Sistemas Inteligentes Aplicadas ao Desenvolvimento de
Jogos de Computador. tese de D. Sc., UNIVERSIDADE ESTATUAL DE CAMPINAS.
Disponível em <www.dca.fee.unicamp.br/~gudwin/ ftp/publications/TeseTatai.pdf > Acesso
em: 11 de mai. 2004.
VANZIN,
A.
M.,
Placas
de
Video
Placas
3D.
Disponível
em
<www.leoviotti.com/hardcia/tutoriais/pl_3d.html> . Acesso em: 7 mai. 2004.
WINSTON, P. H., Inteligência Artificial. Livros Técnicos e Científicos Editora LTDA:
Rio de Janeiro, 1988
37
GLOSSÁRIO
Árvore de Decisão: Conceitos são organizados em forma de árvores, decisões são
ramificações da árvore.
Grafos: Forma de representar elementos de um conjunto e relações entre esses elementos
de forma sucinta.
Heurística: Palavra que vem do grego “heuriskein”, que significa descobrir.
Interface: Meio de comunicação entre o software e o usuário.
Lógica: Um modo de declaração que representa o conhecimento.
Nodo: Estado entre uma relação e outra.
38
APENDICE A: MANUAL
JOGO DE ESTRATEGIA MILITAR
CURITIBA
2005
39
MANUAL
SUMARIO
1.REQUISITOS DO JOGO............................................................................................. 42
2.INSTALAÇÃO..............................................................................................................42
3.TABULEIRO.................................................................................................................45
5.JOGADAS.....................................................................................................................49
6.ATAQUE......................................................................................................................50
7.QUEM GANHA O JOGO............................................................................................52
8.SAIR.............................................................................................................................52
9.DICAS IMPORTANTES.............................................................................................52
40
LISTA DE FIGURAS
Figura 1: Ícone de Instalação........................................................................................... 42
Figura 2: Tela de Bem-vindo........................................................................................... 42
Figura 3: Local de Instalação........................................................................................... 43
Figura 4: Pasta do Menu Iniciar. ..................................................................................... 43
Figura 5: Atalho da Áreas de Trabalho. .......................................................................... 44
Figura 6: Confirmação de Instalação............................................................................... 44
Figura 7: Progresso de Instalação.................................................................................... 45
Figura 8: Conclusão da Instalação................................................................................... 45
Figura 9: Tabuleiro. ......................................................................................................... 47
Figura 10: Inicio do jogo. ................................................................................................ 48
Figura 11: Peças sendo posicionadas .............................................................................. 48
Figura 12: Peças distribuídas no Tabuleiro. .................................................................... 48
Figura 13 Exemplo de movimentação. ............................................................................ 49
Figura 14: Movimentação do Computador...................................................................... 50
Figura 15: Jogadas Realizadas......................................................................................... 50
Figura 16: Confronto entre patentes. ............................................................................... 52
Figura 17: Ícone Uninstall. .............................................................................................. 53
Figura 18: Confirmação de desinstalação........................................................................ 53
Figura 19: Sucesso na remoção do jogo. ......................................................................... 54
41
LISTA DE TABELAS
Tabela 1: Total de peças. ............................................................................................. 46
42
MANUAL
1.REQUISITOS DO JOGO
O Sistema Operacional deve ser o Microsoft Windows 98 ou superior.
CPU 500 MHz ou superior.
Memória 64 MB (recomendado 128 MB).
Espaço em disco de 2 MB ou mais.
2.INSTALAÇÃO
Insirir o CD do jogo na unidade de leitura de CD-ROW, com o mouse dê dois cliques
como botão esquerdo sobre o ícone de instalação.
Figura 1: Ícone de Instalação.
Aparecerá a tela de Bem-vindo ao Assistente de Instalação, conforme apresentado na
figura 2.
Figura 2: Tela de Bem-vindo.
43
Ao clicar em avançar, é pedido o local de instalação, como padrão o jogo é instalado no
diretório c:\arquivos de programas, como mostrado na figura 3.
Figura 3: Local de Instalação.
Na próxima tela deve ser informado a pasta que aparecerá no menu iniciar, como
ilustrado na figura 4.
Figura 4: Pasta do Menu Iniciar.
44
Na tela que segue, será apresentado se deseja incluir atalho na área de trabalho, como na
figura 5.
Figura 5: Atalho da Áreas de Trabalho.
Aparecerá a confirmação de instalação, no qual é apresentado a pasta de instalação e o
local da pasta no menu iniciar, representado na figura 6:
Figura 6: Confirmação de Instalação.
45
Será iniciado então a instalação, representando o progresso em uma barra gráfica de
instalação, conforme figura 7:
Figura 7: Progresso de Instalação.
Finalmente a instalação é concluída, e então é apresentado a opção de executar ou não a
instalação, como ilustrado a figura 8.
Figura 8: Conclusão da Instalação.
3.TABULEIRO
46
O jogo de Estratégia Militar consiste num tabuleiro 15 X 15, contendo 60 peças para cada
jogador que é posicionada na parte inferior para o jogador em vermelho e superior para o
computador em azul, conforme a figura 9 do manual, que mostra o tabuleiro contendo 2 lagos
em azuis, uma legenda com a descrição e a representação das peças e um modo para se
interromper a partida. A linha amarela do tabuleiro representa a posição inicial das peças do
jogador, de onde elas serão posicionadas para a construção das estratégias de jogadas que é
realizada pelo participante. O Tabuleiro é composto por 120 (cento e vinte) peças, pertencendo
metade ao jogador, e metade ao computador, essas sendo dividida por patentes como mostra a
Tabela 1.
Tabela 1: Total de peças.
Nome
Total
Soldado
14
Sargento
6
Cabo Armeiro
7
Tenente
6
Capitão
6
Major
4
Coronel
3
General
1
Marechal
1
Torre
1
Mina
6
Bomba
4
Espião
1
47
Figura 9: Tabuleiro.
A figura 9 representa a primeira tela apresentada ao jogador, com as opções de
disponibilizar as peças automaticamente, pressionando a tecla “a” ou manualmente
pressionando a tecla “s”.
3.1.Disponibilização de peças manualmente.
Caso o jogador opte por distribuir suas peças manualmente, o jogador disponibilizar
suas peças, clicando com o botão esquerdo do mouse na peça desejada e arrastando até o local
de destino, que poderá ser feita apenas nas 4 primeiras linhas de baixo para cima. Como mostra
as figuras 10 e 11.
48
Figura 10: Inicio do jogo.
Figura 11: Peças sendo posicionadas
Após a distribuição das peças, poderá ser dado o início do jogo, a figura 12 representa a
tela com as peças distribuídas no tabuleiro.
Figura 12: Peças distribuídas no Tabuleiro.
49
5.JOGADAS
As jogadas devem ser realizadas utilizando o mouse, clicando em cima peça e a
arrastando para seu destino, da mesma forma do posicionamento inicial, mas agora em direção
das peças do computador, uma casa por vez, não podendo pular uma peça sobre a outra e nem
passar pelos lagos.
Todas as peças podem se movimentar uma casa na vertical ou na horizontal, com
exceção das bombas, minas e da torre que são estáticas.
A primeira jogada deve ser executada pelo jogador, a figura 12 dá um exemplo de
primeira movimentação, jogando um soldado para o espaço livre à sua frente.
Figura 13 Exemplo de movimentação.
A figura 14 representa a continuação do jogo com uma peça do computador sendo
movimentada da mesma forma.
50
Figura 14: Movimentação do Computador.
O jogo deve seguir tendo uma movimentação de cada participante do jogo (jogador /
computador), conforme representado na figura 15.
Figura 15: Jogadas Realizadas.
6.ATAQUE
51
Quando a peça estiver na frente, ao lado ou atrás de uma peça adversária, você pode
atacar, se quiser. Lembre-se que as peças de maior grau na hierarquia derrotam as peças de
menor grau.
Para atacar, coloque as peças na casa do adversário, a cada ataque será mostrada a as
peças que estão sendo confrontadas, a peça derrotada sai do jogo, dando lugar a peça
vencedora.
Quando o grau de sua peça for o mesmo da peça do computador,as duas saem do jogo.
O grau do Espião e o menor: só 2, mas se atacar o Marechal do adversário, ganha o
ataque. Porém se o marechal o atacar primeiro, o Espião sai do jogo.
Cuidado com as Bombas e as Minas, existem duas peças semelhantes porém com
objetivos diferentes, são elas as bombas e as minas, a grande diferença entre elas vem a ser que
as bombas só saem do jogo quando um cabo armeiro a ataca, permanecendo quando outra peça
assim a fizer, a mina também só pode ser desarmada pelo cabo armeiro porém possui uma
diferença vital quando outras peças a atacam, a peça que ataca e a mina são retiradas do jogo,
independente de quem atacou.
Quando ocorrer um confronto é apresentado uma mensagem na tela de jogador vencedor,
logo em seguida é informada a patente vitoriosa, conforme a figura 16 apresenta.
Nesta figura representa a jogada de um soldado do jogador (patente 3) confrontando um
Cabo Armeiro do Computador (patente 4), na representação é mostrada as duas mensagens,
porém elas são apresentadas uma a uma, primeiro a mensagem de quem foi vitorioso, depois a
da patente vitoriosa.
52
Figura 16: Confronto entre patentes.
7.QUEM GANHA O JOGO
O primeiro exército que capturar a Torre adversária vence o jogo. E tem mais! Se o
jogador ficar só com as Bombas, as Minas e a Torre no final do jogo, dará a vitória ao exército
inimigo.
8.SAIR
Ao término da partida deverá ser pressionada a tecla ‘ESC’ do teclado para encerrar o
programa do jogo, podendo ser usada a qualquer momento durante a partida também.
9.DICAS IMPORTANTES
Quando o jogador distribuir as peças no tabuleiro, deixar a Torre num dos cantos do seu
território , e use 2 ou 3 Bombas para defendê-la.
53
Espalhar as Bombas restantes e as Minas para despistar o adversário.
É bom colocar os Soldados na 1ª fila, para iniciarem os ataques.Assim, você fica sabendo
logo o grau das peças do adversário.
Você também pode colocar as peças de maior grau na 1ª fileira, mas aí corre o risco de
perdê-las e ficar sem elementos de ataque.
É melhor que os Cabos Armeiros fiquem na retaguarda, pois são os únicos que desarmam
as Bombas.
Prestar bastante atenção nos movimentos do Computador para descobrir a estratégia, a
posição das Bombas e onde está a Torre.
10. DESINSTALAÇÃO DO PROGRAMA.
O Jogo de Estratégia Militar conta com um dispositivo de “Uninstall”, que reverte o
processo de instalação, o ícone para desinstalar o programa está representado na figura 17.
Figura 17: Ícone Uninstall.
Uma vez acionado este dispositivo, será interrogado se o usuário realmente deseja
retirar o programa e seus dispositivos, conforme apresentado na figura 18.
.
Figura 18: Confirmação de desinstalação.
Após aceito a opção o dispositivo iniciará a remoção do jogo, e então será apresentada a
tela de sucesso na remoção, conforme apresentado na figura 19.
54
Figura 19: Sucesso na remoção do jogo.
55
APENDICE B: FONTES DO JOGO DE ESTRATÉGIA MILITAR
CURITIBA 2005
56
/*
Projeto Desenvolvido por:
Cristiano Palmer
Mario Cesar Melnik
*/
/* Includes requeridos */
#ifdef _WIN32
#include <windows.h>
#endif
#include <GL/gl.h>
#include <GL/glut.h>
#include <stdio.h>
#include <string>
int ncol;
int linha,graf_lin;
int coluna;
int nlinha;
int ncoluna;
int cont;
int donodajogada ;
int njogada = 0;
int atuallinha=0;
int atualcoluna=0;
int linhaquente=0;
int colunaquente=0;
#include "escrit.h"
#include "posicaoinic.h"
#include "objpecjog.h"
#include "objpecComp.h"
#include "Tabuleiro.h"
void confronto(int ataque, int atacado);
int inversor(int T);
int atualiza_matriz_computador();
int marca_jogadores_computador();
void valor();
void realiza_jogada(int jogada,int flag);
void movimenta(int movimento,int peca,int linhaquente,int colunaquente);
#include "disponibiliza.h"
#include "mov_inic.h"
#include "movimento.h"
57
#include "mouseped.h"
#include "IA.h"
#include "real_jog.h"
/* Executada sempre que é necessario re-exibir a imagem */
void display(void)
{
glMatrixMode(GL_MODELVIEW);
glClear(GL_COLOR_BUFFER_BIT);
mat(); Inic_Pecas();
telaescrita();
Peca_Jog1(); Peca_Jog2(); Peca_Jog3();
Peca_Jog4(); Peca_Jog5();
Peca_Jog6(); Peca_Jog7(); Peca_Jog8();
Peca_Jog9(); Peca_Jog10();
Peca_Jog11();Peca_Jog12();Peca_Jog13(); Peca_Jog14();
Peca_Jog_Cab1(); Peca_Jog_Cab2(); Peca_Jog_Cab3(); Peca_Jog_Cab4();
Peca_Jog_Cab5(); Peca_Jog_Cab6(); Peca_Jog_Cab7();
Peca_Jog_Sar1();Peca_Jog_Sar2();Peca_Jog_Sar3();
Peca_Jog_Sar4();Peca_Jog_Sar5();Peca_Jog_Sar6();
Peca_Jog_Ten1();Peca_Jog_Ten2();Peca_Jog_Ten3();
Peca_Jog_Ten4();Peca_Jog_Ten5();Peca_Jog_Ten6();
Peca_Jog_Cap1();Peca_Jog_Cap2();Peca_Jog_Cap3();
Peca_Jog_Cap4();Peca_Jog_Cap5();Peca_Jog_Cap6();
Peca_Jog_Maj1();Peca_Jog_Maj2();
Peca_Jog_Maj3();Peca_Jog_Maj4();
Peca_Jog_Cor1();Peca_Jog_Cor2();Peca_Jog_Cor3();
Peca_Jog_Gen();Peca_Jog_Mar();Peca_Jog_Esp();
Peca_Jog_Bom1();Peca_Jog_Bom2();Peca_Jog_Bom3();
Peca_Jog_Bom4();Peca_Jog_Bom5();Peca_Jog_Bom6();
Peca_Jog_Min1();Peca_Jog_Min2();
Peca_Jog_Min3();Peca_Jog_Min4();
Peca_Jog_Tor();
58
Peca_Com1(); Peca_Com2(); Peca_Com3();
Peca_Com4();
Peca_Com5();
Peca_Com6(); Peca_Com7(); Peca_Com8();
Peca_Com9();
Peca_Com10();
Peca_Com11();Peca_Com12();Peca_Com13(); Peca_Com14();
Peca_Com_Cab1(); Peca_Com_Cab2(); Peca_Com_Cab3(); Peca_Com_Cab4();
Peca_Com_Cab5(); Peca_Com_Cab6(); Peca_Com_Cab7();
Peca_Com_Sar1();Peca_Com_Sar2();Peca_Com_Sar3();
Peca_Com_Sar4();Peca_Com_Sar5();Peca_Com_Sar6();
Peca_Com_Ten1();Peca_Com_Ten2();Peca_Com_Ten3();
Peca_Com_Ten4();Peca_Com_Ten5();Peca_Com_Ten6();
Peca_Com_Cap1();Peca_Com_Cap2();Peca_Com_Cap3();
Peca_Com_Cap4();Peca_Com_Cap5();Peca_Com_Cap6();
Peca_Com_Maj1();Peca_Com_Maj2();
Peca_Com_Maj3();Peca_Com_Maj4();
Peca_Com_Cor1();Peca_Com_Cor2();Peca_Com_Cor3();
Peca_Com_Gen();Peca_Com_Mar();Peca_Com_Esp();
Peca_Com_Bom1();Peca_Com_Bom2();Peca_Com_Bom3();
Peca_Com_Bom4();Peca_Com_Bom5();Peca_Com_Bom6();
Peca_Com_Min1();Peca_Com_Min2();
Peca_Com_Min3();Peca_Com_Min4();
Peca_Com_Tor();
//jogada_jogador();
glutSwapBuffers();
}
/* Função ativada qdo a janela é aberta pela primeira vez e toda vez
59
que a janela é reconfigurada (movida ou modificado o tamanho) */
void myReshape(int w, int h)
{
glViewport (0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-10.0, 10.0, -10.0, 10.0, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
/* Função ativada qdo alguma tecla é pressionada */
void Key(unsigned char key, int x, int y)
{
switch (key) {
case 'a':op=1;
/*
MessageBox(0,"ESTE PROJETO FOI DESENVOLVIDO POR:
"
Cristiano Palmer
"
"
E
Mario Cesar Melnik
INART",MB_OK);
*/
it0=5,jt0=2;
it01=2,jt01=4;
tabpec[13][4]=3;
tabpec[11][1]=3;
it02=3,jt02=4;
tabpec[11][2]=3;
it03=4,jt03=4;
tabpec[11][3]=3;
it04=5,jt04=4;
tabpec[11][4]=3;
it05=6,jt05=4;
tabpec[11][5]=3;
it06=7,jt06=4;
tabpec[11][6]=3;
it07=8,jt07=4;
tabpec[11][7]=3;
it08=9,jt08=4;
tabpec[11][8]=3;
it09=10,jt09=4;
tabpec[11][9]=3;
it010=11,jt010=4; tabpec[11][10]=3;
it011=12,jt011=4; tabpec[11][11]=3;
it012=13,jt012=4; tabpec[11][12]=3;
it013=14,jt013=4; tabpec[11][13]=3;
\n "
\n "
\n "
","Mensagem
60
it101=1,jt101=3;
tabpec[12][0]=4;
it102=2,jt102=3;
tabpec[12][1]=4;
it103=3,jt103=3;
tabpec[12][2]=4;
it104=4,jt104=3;
tabpec[12][3]=4;
it105=5,jt105=3;
tabpec[12][4]=4;
it106=6,jt106=3;
tabpec[12][5]=4;
it107=7,jt107=3;
tabpec[12][6]=4;
it201=8,jt201=3;
tabpec[12][7]=5;
it202=9,jt202=3;
tabpec[12][8]=5;
it203=10,jt203=3; tabpec[12][9]=5;
it204=11,jt204=3; tabpec[12][10]=5;
it205=12,jt205=3; tabpec[12][11]=5;
it206=13,jt206=3; tabpec[12][12]=5;
it301=14,jt301=3; tabpec[12][13]=6;
it302=15,jt302=3; tabpec[12][14]=6;
it303=1,jt303=2;
tabpec[13][0]=6;
it304=2,jt304=2;
tabpec[13][1]=6;
it305=3,jt305=2;
tabpec[13][2]=6;
it306=4,jt306=2;
tabpec[13][3]=6;
it401=1,jt401=4;
tabpec[11][0]=7;
it402=6,jt402=2;
tabpec[13][5]=7;
it403=7,jt403=2;
tabpec[13][6]=7;
it404=8,jt404=2;
tabpec[13][7]=7;
it405=9,jt405=2;
tabpec[13][8]=7;
it406=10,jt406=2; tabpec[13][9]=7;
it501=11,jt501=2; tabpec[13][10]=8;
it502=12,jt502=2; tabpec[13][11]=8;
it503=13,jt503=2; tabpec[13][12]=8;
it504=14,jt504=2; tabpec[13][13]=8;
it601=15,jt601=2; tabpec[13][14]=9;
it602=1,jt602=1;
tabpec[14][0]=9;
it603=2,jt603=1;
tabpec[14][1]=9;
it7=3,jt7=1;
tabpec[14][2]=10;
it8=4,jt8=1;
tabpec[14][3]=11;
61
it9=5,jt9=1;
tabpec[14][4]=2;
it1001=6,jt1001=1;tabpec[14][5]=0;
it1002=7,jt1002=1;tabpec[14][6]=0;
it1003=8,jt1003=1;tabpec[14][7]=0;
it1004=9,jt1004=1;tabpec[14][8]=0;
it1005=10,jt1005=1;tabpec[14][9]=0;
it1006=11,jt1006=1;tabpec[14][10]=0;
it1101=12,jt1101=1;
tabpec[14][11]=1;
it1102=13,jt1102=1;
tabpec[14][12]=1;
it1103=14,jt1103=1;
tabpec[14][13]=1;
it1104=15,jt1104=1;
tabpec[14][14]=1;
it12=15,jt12=4;tabpec[11][14]=12;
for(i=0;i<=60;i++){Vetor[i]=-1;}
dispCOM();
break;
case 's':op=2;
it0=1,jt0=0;
it01=1,jt01=0;
it02=1,jt02=0;
it03=1,jt03=0;
it04=1,jt04=0;
it05=1,jt05=0;
it06=1,jt06=0;
it07=1,jt07=0;it08=1,jt08=0;
it09=1,jt09=0;
it010=1,jt010=0; it011=1,jt011=0; it012=1,jt012=0; it013=1,jt013=0;
it105=2,jt105=0; it106=2,jt106=0; it107=2,jt107=0;
it205=3,jt205=0; it206=3,jt206=0;
it301=4,jt301=0; it302=4,jt302=0; it303=4,jt303=0;
it304=4,jt304=0; it305=4,jt305=0; it306=4,jt306=0;
it401=5,jt401=0; it402=5,jt402=0; it403=5,jt403=0;
it404=5,jt404=0; it405=5,jt405=0; it406=5,jt406=0;
62
it601=7,jt601=0; it602=7,jt602=0; it603=7,jt603=0;
it7=8,jt7=0; it8=9,jt8=0; it9=10,jt9=0;
it1001=11,jt1001=0; it1002=11,jt1002=0; it1003=11,jt1003=0;
it1004=11,jt1004=0; it1005=11,jt1005=0; it1006=11,jt1006=0;
it1101=12,jt1101=0; it1102=12,jt1102=0; it1103=12,jt1103=0;
it1104=12,jt1104=0;
it12=13,jt12=0;
dispCOM();
break;
case 27: exit(1); break;
default: break;
}
printf("\n Valor de op na Key : %d", op);
//jogada_jogador();
mostra01();
printf("\n");
mostra02();
glutPostRedisplay();
}
/* Jogada do Jogdor*/
/* Inicializações do programa */
void myInit(void)
{
glClearColor(1.0, 1.0, 1.0, -10.0);
}
/* Parte principal - ponto de início de execução */
int main(int argc, char** argv)
63
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(800, 600);
glutInitWindowPosition(0,0);
glutCreateWindow("Jogo de Estrategia Militar");
myInit();
glutMouseFunc(MOUSE);
glutDisplayFunc(display);
glutReshapeFunc(myReshape);
glutKeyboardFunc(Key);
glutMainLoop();
return(0);
}
// DEMO DE JOGADAS tabuleiro visto pelo computador
/*
int flag; //variavel de posicjogada 1-Jogada ofensiva na horizontal da
peça
//
2-Jogada defensiva na horizontal da peça
//
3-Jogada ofensiva na vertical da peça
//
4 -Jogada defensiva na vertical da peça
int jogada; //variavel que guarda valor da jogada
C\L
0
1
2
3
4
5
6
7
8
9
10 11 12 13 14
0 221-221-221-221-221-221-221-221-221-221-221-221-221-221-221
1 221-221-221-221-221-221-221-221-221-221-221-221-221-221-221
2 221-221-221-221-221-221-221-221-221-221-221-221-221-221-221
3 221-221-221-221-221-221-221-221-221-221-221-221-221-221-221
4 000-000-000-000-000-000-000-000-000-000-000-000-000-000-000
5 000-000-000-000-000-000-000-000-000-##-##-##-##-000-000
6 000-000-##-##-##-##-000-000-000-##-##-##-##-000-000
7 000-000-##-##-##-##-000-000-000-##-##-##-##-000-000
8 000-000-##-##-##-##-000-000-000-##-##-##-##-000-000
9 000-000-##-##-##-##-000-000-000-000-000-000-000-000-000
10
00-00-00-00-00-00-00-00-00-00-00-00-00-00-000
11
332-332-332-332-332-332-332-332-332-332-332-332-332-332-332
12
332-332-332-332-332-332-332-332-332-332-332-332-332-332-332
13
332-332-332-332-332-332-332-332-332-332-332-332-332-332-332
64
14
332-332-332-332-332-332-332-332-332-332-332-332-332-332-332
*/
//Ideia, substituir todos os "22" pelas peças do computador
//Substituir todos os 33 pelas peças abertas do jogador
//Sendo a matriz de visualização do computado
// quando a peça tiver o numero 1 no final é do computador
// quando a peça tiver o numero 2 no final é do jogador
// quando a peça tiver o numero 0 no final é em branco
int tabcomp[15][15]={
221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,
221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,
221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,
221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,
000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,
000,000,000,000,000,000,000,000,000,999,999,999,999,000,000,
000,000,999,999,999,999,000,000,000,999,999,999,999,000,000,
000,000,999,999,999,999,000,000,000,999,999,999,999,000,000,
000,000,999,999,999,999,000,000,000,999,999,999,999,000,000,
000,000,999,999,999,999,000,000,000,000,000,000,000,000,000,
000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,
332,332,332,332,332,332,332,332,332,332,332,332,332,332,332,
332,332,332,332,332,332,332,332,332,332,332,332,332,332,332,
332,332,332,332,332,332,332,332,332,332,332,332,332,332,332,
332,332,332,332,332,332,332,332,332,332,332,332,332,332,332
};
int atualiza_matriz_computador(){
int coluna=0;
int linha=0;
for(linha=0;linha<4;linha++){
for(coluna=0;coluna<15;coluna++){
tabcomp[linha][coluna]=tabpec[linha][coluna];
}
}
printf("\n atualiza matriz");
for(x=0;x<=14;x++){
printf("\n");
for(y=0;y<=14;y++){
printf("|");
65
printf("%d",tabcomp[x][y]);
}
}
}
int marca_jogadores_computador(){
for(linha=0;linha<4;linha++){
tabcomp[linha][coluna]=tabcomp[linha][coluna]*10+1;
}
}printf("\n marca jogadores");
for(x=0;x<=14;x++){
printf("\n");
for(y=0;y<=14;y++){
printf("|");
}
}
}
int zara_linha_tabcomp(){
tabcomp[linha][coluna]=000;
}
void armazena_peca(){
atuallinha=linha;
atualcoluna=coluna;
}
void valor(){
printf("\n ENTROU NA IA ");
if((tabini[linha][coluna]=='C')&&(linha<15)&&(linha>0)&&(coluna<15)&&(
coluna>0)){
if (tabcomp[13][coluna]==332){
armazena_peca();
jogada=10000;
flag=1;
realiza_jogada(jogada,flag);
}
}
66
}
for(coluna=12;coluna<=12;coluna++){
if((tabini[linha][coluna]=='C')&&(linha<15)&&(linha>0)&&(coluna<15)&&(
coluna>0)){
if (tabcomp[12][coluna]==41){
armazena_peca();
jogada=1000;
flag=1;
}
}
}
for(linha=0;linha<=14;linha++){
if((tabini[linha][coluna]=='J')&&(linha<15)&&(linha>0)&&(coluna<15)&&(
coluna>0)){
if (tabcomp[linha][coluna]==112){
if(tabcomp[linha-1][coluna]==21){
armazena_peca();
jogada=1001;
flag=1;
}
}
}
}
}
if(tabini[linha][coluna]=='J'){
if
((tabcomp[linha][coluna]==112)&&(linha<15)&&(linha>0)&&(coluna<15)&&(coluna>
0)){
if(tabcomp[linha+1][coluna]==21){
armazena_peca();
jogada=1001;
67
flag=2;
}
}
}
}
}
if
0)){
if(tabcomp[linha][coluna-1]==21){
armazena_peca();
jogada=1001;
flag=3;
}
}
}
}
}
if
0)){
if(tabcomp[linha][coluna+1]==21){
armazena_peca();
jogada=1001;
flag=4;
}
}
}
}
}
68
if(tabini[linha][coluna]=='C'){
if((tabcomp[linha][coluna]==71)&&(linha<15)&&(linha>0)&&(coluna<15)&&(
coluna>0)){
armazena_peca();
jogada=10;
flag=1;
}
armazena_peca();
jogada=10;
flag=2;
}
armazena_peca();
jogada=15;
flag=3;
}
armazena_peca();
jogada=10;
flag=4;
}
}
}
}
}
if(tabcomp[linha][coluna]==71){
69
if(((tabcomp[linha1][coluna]<=52)&&(tabcomp[linha-1][coluna]!=2)&&(tabini[linha1][coluna]!='C'))&&(linha<15)&&(linha>0)&&(coluna<15)&&(coluna>0)){
armazena_peca();
jogada=10;
flag=1;
}
if(((tabcomp[linha+1][coluna]<=52)&&(tabcomp[linha+1][coluna]!=2)&&(ta
bini[linha+1][coluna]!='C'))&&(linha<15)&&(linha>0)&&(coluna<15)&&(coluna>0)
){
armazena_peca();
jogada=10;
flag=2;
}
if(((tabcomp[linha][coluna+1]<=52)&&(tabcomp[linha][coluna+1]!=2)&&(ta
bini[linha][coluna+1]!='C')&&(linha<15)&&(linha>0)&&(coluna<15)&&(coluna>0))
){
armazena_peca();
jogada=100;
flag=3;
}
if(((tabcomp[linha][coluna1]<=52)&&(tabcomp[linha][coluna-1]!=2)&&(tabini[linha][coluna1]!='C'))&&(linha<15)&&(linha>0)&&(coluna<15)&&(coluna>0)){
armazena_peca();
jogada=10;
flag=4;
}
}
}
}
}
70
if((tabcomp[linha][coluna]>71)&&(linha<15)&&(linha>0)&&(coluna<15)&&(c
oluna>0)){
armazena_peca();
jogada=15;
flag=1;
}
armazena_peca();
jogada=10;
flag=2;
}
armazena_peca();
jogada=10;
flag=3;
}
armazena_peca();
jogada=10;
flag=4;
}
}
}
}
}
71
if((tabcomp[linha][coluna]>71)&&(linha<15)&&(linha>0)&&(coluna<15)&&(c
oluna>0)){
if((tabcomp[linha1][coluna]<=52)&&(tabcomp[linha-1][coluna]!=2)&&(tabini[linha1][coluna]!='C')){
armazena_peca();
jogada=10;
flag=1;
}
if((tabcomp[linha+1][coluna]<=52)&&(tabcomp[linha+1][coluna]!=2)&&(tab
ini[linha+1][coluna]!='C')){
armazena_peca();
jogada=10;
flag=2;
}
if((tabcomp[linha][coluna+1]<=52)&&(tabcomp[linha][coluna+1]!=2)&&(tab
ini[linha][coluna+1]!='C')){
armazena_peca();
jogada=100;
flag=3;
}
if((tabcomp[linha][coluna1]<=52)&&(tabcomp[linha][coluna-1]!=2)&&(tabini[linha][coluna-1]!='C')){
armazena_peca();
jogada=10;
flag=4;
}
}
}
}
}
72
if((tabcomp[linha][coluna]==111)&&(linha<15)&&(linha>0)&&(coluna<15)&&
(coluna>0)){
armazena_peca();
jogada=10;
flag=1;
}
armazena_peca();
jogada=10;
flag=2;
}
armazena_peca();
jogada=80;
flag=3;
}
armazena_peca();
jogada=10;
flag=4;
}
}
}
}
}
73
(coluna>0)){
armazena_peca();
jogada=80;
flag=1;
}
if((tabcomp[linha+1][coluna]<=102)&&(tabcomp[linha+1][coluna]!=2)&&(ta
bini[linha+1][coluna]!='C')){
armazena_peca();
jogada=10;
flag=2;
}
if((tabcomp[linha][coluna+1]<=102)&&(tabcomp[linha][coluna+1]!=2)&&(ta
bini[linha][coluna+1]!='C')){
armazena_peca();
jogada=10;
flag=3;
}
armazena_peca();
jogada=10;
flag=4;
}
}
}
}
}
74
coluna>0)){
armazena_peca();
jogada=10;
flag=1;
}
armazena_peca();
jogada=10;
flag=2;
}
armazena_peca();
jogada=80;
flag=3;
}
armazena_peca();
jogada=10;
flag=4;
}
}
}
}
}
if(tabcomp[linha][coluna]==51){
75
if(((tabcomp[linha1][coluna]<=42)&&(tabcomp[linha-1][coluna]!=2)&&(tabini[linha1][coluna]!='C'))&&(linha<15)&&(linha>0)&&(coluna<15)&&(coluna>0)){
armazena_peca();
jogada=80;
flag=1;
}
if(((tabcomp[linha+1][coluna]<=42)&&(tabcomp[linha+1][coluna]!=2)&&(ta
bini[linha+1][coluna]!='C'))&&(linha<15)&&(linha>0)&&(coluna<15)&&(coluna>0)
){
armazena_peca();
jogada=10;
flag=2;
}
if(((tabcomp[linha][coluna+1]<=42)&&(tabcomp[linha][coluna+1]!=2)&&(ta
bini[linha][coluna+1]!='C'))&&(linha<15)&&(linha>0)&&(coluna<15)&&(coluna>0)
){
armazena_peca();
jogada=10;
flag=3;
}
if(((tabcomp[linha][coluna1]<=42)&&(tabcomp[linha][coluna-1]!=2)&&(tabini[linha][coluna1]!='C'))&&(linha<15)&&(linha>0)&&(coluna<15)&&(coluna>0)){
armazena_peca();
jogada=10;
flag=4;
}
}
}
}
}
76
coluna>0)){
armazena_peca();
jogada=10;
flag=1;
}
armazena_peca();
jogada=10;
flag=2;
}
armazena_peca();
jogada=80;
flag=3;
}
armazena_peca();
jogada=10;
flag=4;
}
}
}
}
}
77
coluna>0)){
if((tabcomp[linha1][coluna]<=32)||(tabcomp[linha-1][coluna]==2)&&(tabini[linha1][coluna]!='C')){
armazena_peca();
jogada=80;
flag=1;
}
if((tabcomp[linha+1][coluna]<=32)||(tabcomp[linha+1][coluna]==2)&&(tab
armazena_peca();
jogada=70;
flag=2;
}
if((tabcomp[linha][coluna+1]<=32)||(tabcomp[linha][coluna+1]==2)&&(tab
armazena_peca();
jogada=70;
flag=3;
}
if((tabcomp[linha][coluna1]<=32)||(tabcomp[linha][coluna-1]==2)&&(tabini[linha][coluna-1]!='C')){
armazena_peca();
jogada=70;
flag=4;
}
}
}
}
}
78
coluna>0)){
if((tabcomp[linha1][coluna]<=32)||(tabcomp[linha-1][coluna]!=12)&&(tabini[linha1][coluna]!='C')){
armazena_peca();
jogada=80;
flag=1;
}
if((tabcomp[linha+1][coluna]<=32)||(tabcomp[linha+1][coluna]!=12)&&(ta
armazena_peca();
jogada=70;
flag=2;
}
if((tabcomp[linha][coluna+1]<=32)||(tabcomp[linha][coluna+1]!=12)&&(ta
armazena_peca();
jogada=70;
flag=3;
}
if((tabcomp[linha][coluna1]<=32)||(tabcomp[linha][coluna-1]!=12)&&(tabini[linha][coluna-1]!='C')){
armazena_peca();
jogada=70;
flag=4;
}
79
}
}
}
}
(coluna>0)){
armazena_peca();
jogada=0;
flag=1;
}
armazena_peca();
jogada=100;
flag=2;
}
armazena_peca();
jogada=0;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
80
}
}
}
}
coluna>0)){
armazena_peca();
jogada=100000;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=100000;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
}
81
//
}
for(coluna=0;coluna <=14;coluna++){
for(linha=0;linha <=14;linha++){
coluna>0)){
armazena_peca();
jogada=20;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=0;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
}
82
coluna>0)){
armazena_peca();
jogada=0;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=20;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
83
}
coluna>0)){
armazena_peca();
jogada=20;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=0;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
}
84
coluna>0)){
armazena_peca();
jogada=0;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=20;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
}
85
coluna>0)){
armazena_peca();
jogada=20;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=0;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
}
86
coluna>0)){
armazena_peca();
jogada=0;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=20;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
87
}
coluna>0)){
armazena_peca();
jogada=20;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=0;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
}
88
coluna>0)){
armazena_peca();
jogada=0;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=20;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
}
89
(coluna>0)){
armazena_peca();
jogada=20;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=0;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
}
90
(coluna>0)){
armazena_peca();
jogada=0;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=20;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
}
91
(coluna>0)){
armazena_peca();
jogada=20;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=0;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
}
92
(coluna>0)){
armazena_peca();
jogada=0;
flag=1;
}
armazena_peca();
jogada=0;
flag=2;
}
armazena_peca();
jogada=20;
flag=3;
}
armazena_peca();
jogada=0;
flag=4;
}
}
}
}
93
}
(coluna>0)){
armazena_peca();
jogada=1;
flag=1;
}
armazena_peca();
jogada=2;
flag=2;
}
armazena_peca();
jogada=1;
flag=3;
}
armazena_peca();
jogada=2;
flag=4;
}
}
}
}
}
for(coluna<=14;coluna=0;coluna--){
94
coluna>0)){
armazena_peca();
jogada=1;
flag=1;
}
armazena_peca();
jogada=2;
flag=2;
}
armazena_peca();
jogada=1;
flag=3;
}
armazena_peca();
jogada=2;
flag=4;
}
}
}
}
}
for(linha<=14;linha<=0;linha--){
(coluna>0)){
95
armazena_peca();
jogada=1;
flag=1;
}
armazena_peca();
jogada=2;
flag=2;
}
armazena_peca();
jogada=1;
flag=3;
}
armazena_peca();
jogada=2;
flag=4;
}
}
}
}
}
for(coluna<=14;coluna=0;coluna--){
for(linha<=14;linha<=0;linha--){
(coluna>0)){
armazena_peca();
jogada=1;
flag=1;
96
}
armazena_peca();
jogada=2;
flag=2;
}
armazena_peca();
jogada=1;
flag=3;
}
armazena_peca();
jogada=2;
flag=4;
}
}
}
}
}
coluna>0)){
armazena_peca();
jogada=1;
flag=1;
}
armazena_peca();
97
jogada=1;
flag=2;
}
armazena_peca();
jogada=1;
flag=3;
}
armazena_peca();
jogada=1;
flag=4;
}
}
}
}
}
for(x=0;x<=14;x++){
printf("\n");
for(y=0;y<=14;y++){
printf("|");
}
}
printf("\n peca jogada
:%d",peca);
printf("\n Valor da jogada em IA
:%d",jogada);
printf("\n Valor do FLAG em IA
:%d",flag);
printf("\n Valor de linhaquente
:%d",linhaquente);
printf("\n Valor de colunaquente
:%d",colunaquente);
//realiza_jogada(jogada,flag);
//movimenta(flag,peca,linhaquente,colunaquente);
}
98
printf("\n FLAG saindo de movimenta :%d",flag);
printf("\n peca em movimenta
:%d",peca);
}
void realiza_jogada(int jogada,int flag){
printf("\n LINHA ATUAL %d", atuallinha);
printf("\n COLUNA ATUAL %d", atualcoluna);
printf("\n JOGADA ATUAL %d", jogada);
printf("\n FLAG ATUAL %d", flag);
if(jog_real < jogada){
jog_real=jogada;
linhaquente=atuallinha;
colunaquente=atualcoluna;
}
printf("\n JOGADA VALIDA %d",jog_real);
printf("\n LINHA QUENTE %d",linhaquente);
printf("\n COLUNA QUENTE %d",colunaquente);
}
/*void realiza_jogada(int jogada,int flag){
int sera;
sera = jogada;
if(jog_real != sera){
//
printf("\n Entrou no primeiro IF \n");
//
printf("\n valor de jog_real
:%d",jog_real);
//
printf("\n valor de sera
:%d", sera);
if(jog_real < sera){
printf("\n ATUALIZA VALORES \n");
linhaquente=atuallinha;
colunaquente=atualcoluna;
printf("\n FUNCAO EXECUTADA \n");
printf("\n peca jogada
:%d",peca);
printf("\n Valor da jogada em IA
:%d",jog_real);
printf("\n Valor do FLAG em IA
:%d",flag);
printf("\n Valor de linhaquente
:%d",linhaquente);
printf("\n Valor de colunaquente
:%d",colunaquente);
movimenta(flag,peca,linhaquente,colunaquente);
jog_real = jogada;
}
}
99
}
void movimenta(int movimento,int peca,int linhaquente,int colunaquente){
flag=movimento;
printf("\n FLAG dentro de movimenta :%d",flag);
if(flag == 1 && peca ==3){
linha = linha + 1;
tabpec[linha][coluna]=3;
linha = linha - 1;
tabpec[linha][coluna]=-1;
if(ident_c==0){ic0=coluna,jc0=linha;}
}
if(flag == 2 && tabpec[linha][coluna]==3){
linha = linha - 1;
linha = linha + 1;
100
}
coluna = coluna + 1;
coluna = coluna - 1;
}
coluna = coluna - 1;
coluna = coluna + 1;
101
}
void mov(int linha,int coluna, int linhaant, int colunaant){
if((linhaant == linha +1 && colunaant != coluna)||
(linhaant == linha -1 && colunaant != coluna)||
(linhaant == linha +1 && colunaant != coluna)||
(linhaant == linha -1 && colunaant != coluna) ||
(coluna+1!=colunaant)&&(coluna-1!=colunaant)&&
(linha+1!=linhaant)&&(linha-1!=linhaant)){
pecapeg = tabpec[lin][col-1];
printf("\n Peca Atribuida para pecapeg :%d",pecapeg);
bem = tabini[lin][col-1];
printf("\n Localizacao em TABINI :%c ",bem);
printf("\nA PECA buscada e da patente: ");
printf("%d",tabpec[lin][col-1]);
printf("\nPertencente ao :");
if(tabini[lin][col-1]=='B'){
printf("BRANCO");
MessageBox(0,"LUGAR EM BRANCO","MSG INART",MB_OK);
}
if(tabini[lin][col-1]=='C'){
printf("COMPUTADOR");
printf("\nNao e permitido pegar pecas do computador");
printf("\n PECA PEGA : %d",ident_c);
MessageBox(0,"PECA DO COMPUTADOR","MSG INART",MB_OK);
}
if(tabini[lin][col-1]=='J'){
printf("JOGADOR");
if(pecapeg == 3){
goto SOLDADO;
}
if((lin == nlin +1 && col != ncol) ||
102
(lin == nlin -1 && col != ncol)||
(lin == nlin +1 && col != ncol) ||
(lin == nlin -1 && col != ncol) ||
(ncol+1!=col)&&(ncol-1!=col)&&
(nlin+1!=lin)&&(nlin-1!=lin)){
MessageBox(0,"JOGADA
INVALIDA('jogada
jogador')","MSG
INART",MB_OK);
}
else{
SOLDADO:
if((lin == nlin +1 && col != ncol) ||
(lin == nlin -1 && col != ncol)){
/* for(lin=5; lin < 10; lin++){
lin == '#';
}
*/
MessageBox(0,"JOGADA
INVALIDA
\n
if
soldado","MSG
INART",MB_OK);
}
}
if((ataque > atacado)){
int nLIN,COL;
if((ident == 101)||(ident == 102)||
(ident == 103)||(ident == 104)||
(ident == 105)||(ident == 106)||(ident == 107)){
MessageBox(0,"VITÓRIA DO JOGADOR","MSG INART",MB_OK);
printf("\n peca do COMP
: %d",ident_c);
printf("\n peca do jogador
: %d",ident);
tabpec[lin][col-1] = -1;
tabini[lin][col-1] = 'B';
tabini[nlin][ncol-1] = 'J';
tabpec[nlin][ncol-1] = pecapeg;
INVERSO_NLin(nlin);
nLIN=nlin;
COL=ncol;
printf("\n linha dentro de vitoria 'nLIN'
//it401=ncol,jt401=nLIN;
if(ident == 101){it101=ncol,jt101=nLIN;}
:%d", nLIN);
103
switch(ident_c){
case 0:ic0=1,jc0=0;break;
case
9:ic9=0,jc9=0;MessageBox(0,"Voce
acaba
de
derrotar
o
ESPIAO ","MSG INART",MB_OK); break;
case
acaba
de
acaba
de
acaba
de
acaba
de
acaba
de
acaba
de
acaba
de
acaba
de
acaba
de
acaba
de
DESARMAR UMA BOMBA ","MSG INART",MB_OK); break;
case
case
case
case
case
case
DESARMAR UMA MINA","MSG INART",MB_OK);break;
case
case
case
}
104
mostra01();mostra02();
}
if((atacado!=0)&&(atacado!=1)){
if((ident
==
0)||(ident
==
100)||(ident
==
200)||(ident
==
500)||(ident
==
600)||(ident
==
1000)||(ident
==
300)||
(ident
==
400)||(ident
==
(ident
==
800)||(ident
==
700)||
900)||(ident
==
1100)||
(ident == 1200)||(ident == 1300)){
: %d",ident_c);
: %d",ident);
INVERSO_NLin(nlin);
nLIN=nlin;
COL=ncol;
:%d", nLIN);
//it401=ncol,jt401=nLIN; if(ident == 0){it0=0,jt0=0;}
switch(ident_c){
case 9:ic9=0,jc9=0;
MessageBox(0,"Voce
INART",MB_OK);
break;
acaba
de
derrotar
o
ESPIAO
","MSG
105
}
}
if((ident == 201)||(ident == 202)||(ident == 203)||
: %d",ident_c);
: %d",ident);
INVERSO_NLin(nlin);
nLIN=nlin;
COL=ncol;
:%d", nLIN);
switch(ident_c){
case
acaba
de
derrotar
um
SOLDADO ","MSG INART",MB_OK); break;
case 100:ic01=1,jc01=0;MessageBox(0,"Voce acaba de derrotar um
106
case 1000:ic010=1,jc010=0;MessageBox(0,"Voce acaba de derrotar
um SOLDADO ","MSG INART",MB_OK); break;
case
acaba
de
derrotar
o
um CABO ARMEIRO ","MSG INART",MB_OK); break;
}
}
if((ident == 301)||(ident == 302)||(ident == 303)||
: %d",ident_c);
: %d",ident);
INVERSO_NLin(nlin);
107
nLIN=nlin;
COL=ncol;
:%d", nLIN);
switch(ident_c){
case
acaba
de
derrotar
um
108
case
acaba
de
derrotar
o
um SARGENTO ","MSG INART",MB_OK); break;
}
mostra01(); mostra02();
}
}
void MOUSE(int tecla, int estado, int x, int y){
int K =0;
switch(tecla){
case GLUT_LEFT_BUTTON:
if(estado == GLUT_DOWN){
if(x>=60 && x<=99 && y>=72 && y<=103){
iant=1;
jant=15;
109
verif();
}
if(x>=100 && x<=139 && y>=72 && y<=103){
iant=2;
jant=15;
verif();
}
if(x>=140 && x<=179 && y>=72 && y<=103){
iant=3;
jant=15;
verif();
}
if(x>=180 && x<=219 && y>=72 && y<=103){
iant=4;
jant=15;
verif();
}
if(x>=220 && x<=259 && y>=72 && y<=103){
iant=5;
jant=15;
verif();
}
if(x>=260 && x<=299 && y>=72 && y<=103){
iant=6;
jant=15;
verif();
}
if(x>=300 && x<=339 && y>=72 && y<=103){
iant=7;
jant=15;
verif();
}
if(x>=340 && x<=379 && y>=72 && y<=103){
iant=8;
jant=15;
verif();
}
if(x>=380 && x<=419 && y>=72 && y<=103){
iant=9;
jant=15;
verif();
110
}
if(x>=420 && x<=459 && y>=72 && y<=103){
iant=10;
jant=15;
verif();
}
if(x>=460 && x<=499 && y>=72 && y<=103){
iant=11;
jant=15;
verif();
}
if(x>=500 && x<=539 && y>=72 && y<=103){
iant=12;
jant=15;
verif();
}
if(x>=540 && x<=579 && y>=72 && y<=103){
iant=13;
jant=15;
verif();
}
if(x>=580 && x<=619 && y>=72 && y<=103){
iant=14;
jant=15;
verif();
}
if(x>=620 && x<=659 && y>=72 && y<=103){
iant=15;
jant=15;
verif();
}
//*********************************************************
if(x>=60 && x<=99 && y>=101 && y<=133){
iant=1;
jant=14;
verif();
}
if(x>=100 && x<=139 && y>=101 && y<=133){
iant=2;
jant=14;
verif();
111
}
if(x>=140 && x<=179 && y>=101 && y<=133){
iant=3;
jant=14;
verif();
}
if(x>=180 && x<=219 && y>=101 && y<=133){
iant=4;
jant=14;
verif();
}
if(x>=220 && x<=259 && y>=101 && y<=133){
iant=5;
jant=14;
verif();
}
if(x>=260 && x<=299 && y>=101 && y<=133){
iant=6;
jant=14;
verif();
}
if(x>=300 && x<=339 && y>=101 && y<=133){
iant=7;
jant=14;
verif();
}
if(x>=340 && x<=379 && y>=101 && y<=133){
iant=8;
jant=14;
verif();
}
if(x>=380 && x<=419 && y>=101 && y<=133){
iant=9;
jant=14;
verif();
}
if(x>=420 && x<=459 && y>=101 && y<=133){
iant=10;
jant=14;
verif();
}
112
if(x>=460 && x<=499 && y>=101 && y<=133){
iant=11;
jant=14;
verif();
}
if(x>=500 && x<=539 && y>=101 && y<=133){
iant=12;
jant=14;
verif();
}
if(x>=540 && x<=579 && y>=101 && y<=133){
iant=13;
jant=14;
verif();
}
if(x>=580 && x<=619 && y>=101 && y<=133){
iant=14;
jant=14;
verif();
}
if(x>=620 && x<=659 && y>=101 && y<=133){
iant=15;
jant=14;
verif();
}
//*********************************************************
if(x>=60 && x<=99 && y>=131 && y<=163){
iant=1;
jant=13;
verif();
}
if(x>=100 && x<=139 && y>=131 && y<=163){
iant=2;
jant=13;
verif();
}
if(x>=140 && x<=179 && y>=131 && y<=163){
iant=3;
jant=13;
verif();
}
113
if(x>=180 && x<=219 && y>=131 && y<=163){
iant=4;
jant=13;
verif();
}
if(x>=220 && x<=259 && y>=131 && y<=163){
iant=5;
jant=13;
verif();
}
if(x>=260 && x<=299 && y>=131 && y<=163){
iant=6;
jant=13;
verif();
}
if(x>=300 && x<=339 && y>=131 && y<=163){
iant=7;
jant=13;
verif();
}
if(x>=340 && x<=379 && y>=131 && y<=163){
iant=8;
jant=13;
verif();
}
if(x>=380 && x<=419 && y>=131 && y<=163){
iant=9;
jant=13;
verif();
}
if(x>=420 && x<=459 && y>=131 && y<=163){
iant=10;
jant=13;
verif();
}
if(x>=460 && x<=499 && y>=131 && y<=163){
iant=11;
jant=13;
verif();
}
if(x>=500 && x<=539 && y>=131 && y<=163){
114
iant=12;
jant=13;
verif();
}
if(x>=540 && x<=579 && y>=131 && y<=163){
iant=13;
jant=13;
verif();
}
if(x>=580 && x<=619 && y>=131 && y<=163){
iant=14;
jant=13;
verif();
}
if(x>=620 && x<=659 && y>=131 && y<=163){
iant=15;
jant=13;
verif();
}
//*********************************************************
if(x>=60 && x<=99 && y>=158 && y<=193){
iant=1;
jant=12;
verif();
}
if(x>=100 && x<=139 && y>=158 && y<=193){
iant=2;
jant=12;
verif();
}
if(x>=140 && x<=179 && y>=158 && y<=193){
iant=3;
jant=12;
verif();
}
if(x>=180 && x<=219 && y>=158 && y<=193){
iant=4;
jant=12;
verif();
}
if(x>=220 && x<=259 && y>=158 && y<=193){
115
iant=5;
jant=12;
verif();
}
if(x>=260 && x<=299 && y>=158 && y<=193){
iant=6;
jant=12;
verif();
}
if(x>=300 && x<=339 && y>=158 && y<=193){
iant=7;
jant=12;
verif();
}
if(x>=340 && x<=379 && y>=158 && y<=193){
iant=8;
jant=12;
verif();
}
if(x>=380 && x<=419 && y>=158 && y<=193){
iant=9;
jant=12;
verif();
}
if(x>=420 && x<=459 && y>=158 && y<=193){
iant=10;
jant=12;
verif();
}
if(x>=460 && x<=499 && y>=158 && y<=193){
iant=11;
jant=12;
verif();
}
if(x>=500 && x<=539 && y>=158 && y<=193){
iant=12;
jant=12;
verif();
}
if(x>=540 && x<=579 && y>=158 && y<=193){
iant=13;
116
jant=12;
verif();
}
if(x>=580 && x<=619 && y>=158 && y<=193){
iant=14;
jant=12;
verif();
}
if(x>=620 && x<=659 && y>=158 && y<=193){
iant=15;
jant=12;
verif();
}
}
int inversor(int T){
int B;
B = T;
switch(B){
case 0:jj=15;break;
case 1:jj=14;break;
case 2:jj=13;break;
case 3:jj=12;break;
case 4:jj=11;break;
case 5:jj=10;break;
case 6:jj=9;break;
case 7:jj=8;break;
case 8:jj=7;break;
case 9:jj=6;break;
case 10:jj=5;break;
case 11:jj=4;break;
case 12:jj=3;break;
case 13:jj=2;break;
case 14:jj=1;break;
case 15:jj=0;break;
return(jj);
}
}

Jogo de Estratégia Militar.

Transcrição

Documentos relacionados

Cuba Gooding Jr. retorna como protagonista em “Jogada de Rei”

flagon ep/pv f

flagon ep/s

Passando na Zona Gelada

flagon ts

O USO DE JOGOS ON-LINE COMO POSSIBILIDADE

A bandeira do Canadá, a Maple Leaf Flag, é constituída por um

Jogo da Batalha Naval (hundir la flota) - DT

A origem da Bandeira Americana

SILVER ART DETALHES DE ACABAMENTO

edital_242013 - Prefeitura de Lontras