Relatorio PROG2

Jungle Game

Programação 2 Desenvolvimento do jogo de tabuleiro Jungle Game em C++

Relatório Final

Carlos André Soares Costa e Silva Flávio Daniel Moreira Ferreira

Faculdade de Engenharia da Universidade do Porto Rua Roberto Frias, s/n, 4200-465 4200 Porto, Portugal

Maio de 2008

Jungle Game

Programação 2 Desenvolvimento do jogo de tabuleiro Jungle Game em C++

Relatório Final

Carlos André Soares Costa e Silva Flávio Daniel Moreira Ferreira

Trabalho realizado no âmbito da disciplina de Programação 2, do 2º semestre, do 1º ano, do Mestrado Integrado em Engenharia Electrotécnica e de Computadores da Faculdade de Engenharia da Universidade do Porto, leccionada por Ana Paula Rocha, José Manuel de Magalhães Cruz, Luís Paulo Reis, Rui Carlos Camacho de Sousa Ferreira da Silva e como monitor, Rui Filipe Lourenço Guedes.

Faculdade de Engenharia da Universidade do Porto Rua Roberto Frias, s/n, 4200-465 Porto, Portugal

Maio de 2008

Jungle Game

Resumo Este projecto consiste na implementação do jogo de tabuleiro Jungle Game usando a linguagem de programação C++.

Este jogo poderá ser jogado numa única forma: humano - humano. Ao longo do jogo o utilizador poderá ver a posição das peças no tabuleiro e a partir daí elaborar uma estratégia de forma a derrotar o seu adversário.

A implementação deste jogo implica o desenvolvimento de procedimentos, cujos objectivos vão desde manipular o estado do jogo passando pela detecção do final do jogo, validação de uma jogada e visualização do estado do tabuleiro.

Jungle Game

Índice 1.Introdução 1.1 Motivação 1.2 Enquadramento 1.3 Objectivos 1.4 Estrutura do Relatório

2. Jungle Game – O Jogo 2.1 A História 2.2 O Tabuleiro 2.3 As Peças 2.4 As Regras do Jogo

3. Arquictetura do Sistema 4. Implementação 4.1 Representação do Estado do Jogo 4.2 Visualização do Estado do Jogo 4.3 Validação de Jogadas 4.4 Execução de Jogadas 4.5 Avaliação do Tabuleiro 4.6 Final do Jogo 4.7 Conclusões e Perspectivas de Desenvolvimento

5. Bibliografia 6. Anexos

Jungle Game

1. Introdução 1.1 Enquadramento Este trabalho é um projecto no âmbito da disciplina de Programação 2.

O presente relatório refere-se ao desenvolvimento do módulo lógico do jogo de tabuleiro Jungle Game em linguagem de programação C++. Neste módulo lógico, a visualização do posicionamento das várias peças no tabuleiro é realizada em modo de texto.

1.2 Motivação Este trabalho assume particular importância dado que é o primeiro contacto com a linguagem de programação C++ e respectivo paradigma, o paradigma da programação orientada a objectos. Irá proporcionar também o desenvolvimento de competências ao nível do raciocínio lógico e ao nível da representação e correspondente resolução de problemas de forma objectiva.

Para além das razões acima referidas, uma outra motivação muito forte é a própria concepção de um módulo lógico para um jogo. Pelo facto de se tratar de um jogo, por si só já acrescenta uma vertente lúdica ao processo de desenvolvimento da aplicação.

Jungle Game

1.3 Objectivos O objectivo deste trabalho é a implementação de um jogo, neste caso específico o Jungle Game, na linguagem de programação C++.

O C++ é uma linguagem de uso geral, com uma tendência para a programação de sistemas sendo uma linguagem C melhorada. Suporta abstracção de dados, programação orientada a objectos e programação genérica.

Como objectivos principais, tem-se o desenvolvimento do jogo para que este se desenrole respeitando rigorosamente todas as regras do Jungle Game e permitindo o modo de jogo Humano-Humano.

1.4 Estrutura do relatório Este trabalho encontra-se estruturado em 6 capítulos dos quais, o primeiro é composto por esta introdução ao trabalho. No segundo capítulo é apresentado o jogo, o tabuleiro, as peças e todas as regras que o definem. O terceiro capítulo consiste na descrição em linhas gerais do sistema, nomeadamente,

os

módulos

que

o

constituem

e

as

classes

C++

implementadas. No quarto capítulo descrevem-se aspectos da implementação, incluindo os módulos principais que possibilitam o desenrolar do jogo e algumas conclusões e perspectivas de desenvolvimento.

No quinto capítulo, encontram-se as referências bibliográficas usadas na realização deste trabalho.

O último capítulo contém o código do jogo Jungle Game em linguagem de programação C++ devidamente comentado.

Jungle Game

2. Jungle Game – O Jogo 2.1 A história O Jungle Game é um jogo de tabuleiro de origem chinesa. Este jogo, cujo nome original é Shou Dou Qi, é uma variante do Xadrez.

2.2 O tabuleiro É jogado num tabuleiro de 9 linhas e 7 colunas, tendo vários tipos de casas, nomeadamente, normal, água, armadilha e caverna.

Figura 1: Exemplo de um tabuleiro de Jungle Game

2.3 As peças Cada jogador começa com as seguintes peças: rato, gato, lobo, cão, pantera, tigre, leão e elefante. Estas peças têm os valores de 1 a 8, respectivamente.

Jungle Game

2.4 As regras do jogo • O vencedor deste jogo é o primeiro jogador que conseguir colocar qualquer uma das suas peças na caverna do adversário ou capturar todas as peças do adversário.

• Alternadamente, os jogadores movem as suas peças de uma em uma casa na vertical ou na horizontal mas nunca na diagonal.

• Para capturar uma peça do adversário, basta mover a sua peça para a posição ocupada pela peça adversária que se pretende capturar. Uma peça só pode ser capturada por outra peça de valor igual ou superior. A única excepção a esta regra é o elefante, que pode ser capturado pelo rato, desde que este não esteja a saltar de uma posição de água. Se uma peça se encontra numa casa de armadilha, esta pode ser capturada por qualquer peça adversária.

• Só o rato pode ocupar uma casa de água. Enquanto o rato estiver na água apenas pode ser capturado pelo rato adversário.

• O tigre e o leão podem saltar sobre a água, mas nenhuma das outras peças pode passar sobre uma casa de água. Se o tigre ou o leão saltam sobre a água e aterram numa casa ocupada por uma peça adversária de valor igual ou inferior, então essa peça é capturada. Nem o tigre nem o leão podem saltar sobre uma casa de água que esteja ocupada pelo rato adversário.

• Um jogador não pode mover nenhuma das suas peças para a sua caverna.

Jungle Game

3. Arquitectura do Sistema Na realização deste trabalho implementamos um total de cinco classes, Peca, Cell, Tabuleiro, MyException, Jogador e Jogo.

A partir do seguinte esquema é possível ver a ordem de grandeza que as classes assumem quando comparadas com as restantes: Basicamente existem 4 módulos fundamentais.

Jogador Jogo

Peca

Cell

main()

Tabuleiro MyException

Figura 2: Esquema que o modo como os vários módulos do código estão ligados entre si

Existe um módulo principal que inicia o jogo num nível virtual, interno, para isso define primeiramente que não existe vencedor, de seguida cria-se o jogo, isto é, constrói-se um objecto do tipo Jogo que contem um tabuleiro standart (sem pecas especificas, apenas com pecas vazias), dois objectos do tipo Jogador e define quem é o primeiro Jogador. Inicialmente o jogo começa sem vencedor (bool vencedor = false) e de seguida são inseridas as pecas iniciais no tabuleiro.

Após criação interna do Jogo é tempo para a interface. Tal como no exemplo do Jogo do Galo a nossa interface é também textual, existe assim um módulo responsável pela impressão. Inicialmente é pedido aos jogadores o nome, de seguida é inserido o cabeçalho do jogo (contém o nome do Jogo) e posteriormente a identificação dos jogadores e respectivo tabuleiro com peças iniciais.

Jungle Game Existe também um módulo responsável pela corrida do Jogo, que consiste na execução de uma série de funções que verificam as jogadas enquanto não existir um vencedor.

Estas funções que verificam a validade da jogada vão testar se aquela determinada jogada é correcta dentro dos parâmetros estabelecidos pelas regras do jogo, caso a jogada seja válida proceder-se-á a três funções que efectuam o movimento na matriz (duas delas retiram a peça do vector do jogador e da matriz e uma outra insere-a na matriz). Caso a jogada não se verifique correcta então será pedido ao jogador uma nova Jogada.

Para verificar se existe Vencedor recorre-se a duas funções, ou seja dois testes, um para averiguar se todas as peças de um jogador foram capturadas e outra para averiguar se as casas caverna estão ocupadas.

Se existir um vencedor este módulo acabará com a declaração do vencedor no ecrã, caso contrário, trocará de jogador para que o jogo possa continuar (ate que se encontre um vencedor).

Existe ainda um módulo responsável pelas excepções ocorridas ao longo do jogo, para aplicar o tratamento devido de excepções criou-se a classe MyException que contem apenas uma string, contudo é extremamente fundamental, uma vez que vai permitir ao jogador identificar correctamente o que causou aquela excepção. É importante salientar que o papel das classes Peca, Cell e Tabuleiro , Peca pois é uma “unidade” base de todo o jogo , Cell porque se manifesta como uma unidade mais complexa da Peca e Tabuleiro pois funciona como um órgão que sustenta o jogo.

Jungle Game Tem-se assim a seguinte comparação com o “Corpo Humano”:

Peca

Célula humana unicelular

Cell

Célula humana pluricelular

MyException

Tecido humano

Tabuleiro

Órgão humano

Jogador

Sistema Humano

Jogo

Humano—Ser Vivo completo

Jungle Game

4. Implementação 4.1 Representação do estado do jogo O estado do jogo, ou seja, o posicionamento das várias peças no tabuleiro, é guardado numa matriz. Essa matriz que representa o tabuleiro é constituída por nove linhas. Por sua vez, cada uma dessas nove linhas é constituída por sete colunas, em que cada uma delas representa uma casa de uma determinada linha.

Criou-se uma classe chamada Cell que contém dois membros dados, char casa e tipo Peca piece. Por sua vez, a class Peca contém dois membros dados, uma string representacao e um int valor que guarda as características da peça que está a ocupar uma célula, a sua representação e o valor respectivos.

A estrutura que guarda o estado do tabuleiro é a seguinte:

Figura 3: Estrutura que guarda o estado do tabuleiro (neste caso o estado inicial)

Na criação do tabuleiro, implementou-se um construtor não padrão do tabuleiro que recebe como argumento uma célula vazia. Esta, por sua vez, é composta por uma string que guarda o tipo de casa e por uma peça do tipo Peca, que possui como membros dados uma string que guarda a sua representação e um inteiro que guarda o valor de cada peça do tabuleiro. No

Jungle Game final, obtém-se como estado do jogo, algo semelhante ao representado na figura 2.

Os símbolos que identificam os tipos de casa especiais na representação do estado do jogo são: U – caverna do jogador 1;

w - casa água;

D – caverna do jogador 2;

t – casa armadilha;

n – casa normal;

Os símbolos que identificam os tipos de peças na representação do estado do jogo são: 1R – Rato do jogador 1;

2R – Rato do jogador 2;

1C – Gato do jogador 1;

2C – Gato do jogador 2;

1D – Cão do jogador 1;

2D – Cão do jogador 2;

1W – Lobo do jogador 1;

2W – Lobo do jogador 2;

1P – Pantera do jogador 1;

2P – Pantera do jogador 2;

1T – Tigre do jogador 1;

2T – Tigre do jogador 2;

1L – Leão do jogador 1;

2L – Leão do jogador 2;

1E – Elefante do jogador 1;

2E – Elefante do jogador 2;

Jungle Game

4.2 Visualização do estado do jogo A visualização do posicionamento das várias peças no tabuleiro é realizada em modo de texto. Cada coluna e cada linha é identificada por números que vão de um a nove para linhas e de um a sete para colunas.

O processo de visualização do tabuleiro baseia-se na função void imprimeTabuleiro(). Esta função vai preencher cada posição do tabuleiro com dois campos já definidos na classe Cell, casa e peça. Para isso definiu-se um vector matriz que é do tipo Cell e fazendo-o repetir várias por nove linhas e sete colunas obtém-se o respectivo tabuleiro.

Cada tipo de casa especial contém um símbolo que a identifica, seguida de um número que identifica qual o jogador a que a peça pertence, finalizada por uma letra maiúscula que identifica o tipo de peça.

Figura 2: Visualização do estado do jogo

Os símbolos que identificam os tipos de casa especiais são: o – caverna; # - armadilha;

~ - água.

Jungle Game

4.3 Validação de jogadas Para efeitos de validação de jogadas temos dois predicados. Um para validar uma jogada do humano e outro para validar uma jogada do computador.

Para validar uma jogada de um jogador humano é utilizada a função: •

bool isValido(int row, int col, Peca p)

em que col é a coluna de destino, row é a linha de destino, e p é a identificação da peça que se pretende mover.

Para validar uma jogada, são utilizadas diferentes funções: •

vertipoCasa(int row, int col, Peca p),

função que avalia

o tipo de casa de destino e aplica restrições relativas aos diferentes tipos de casa;

•

isLivre(int row, int col, Peca p) , verifica se a jogada esta dentro dos parâmetros do jogo; chama a função verDestino (verifica a condição da peça só se puder deslocar uma casa na horizontal ou na vertical) e verifica se não existem excepções;

•

avaliaPeca(int row, int col, Peca p) ,

certifica-se que a

peça pertence ao jogador oposto para que o jogador activo a possa capturar.

Os argumentos de cada uma destas funções, são exactamente os mesmos argumentos da função Jogada.isValido já explicados.

Jungle Game

4.4 Execução de jogadas A execução de jogadas reflecte-se na alteração do tabuleiro. No caso do Jungle Game, a execução de jogadas traduz-se na utilização da função bool executaJogada(). Após a validação da jogada, são chamadas três funções para a executarem.

A função void tiraPecaJogador(row - 1, col - 1), responsável por retirar a peça, que se encontra na posição de destino do tabuleiro, ao vector do jogador que não está activo atribuindo, a string “ “ ao membro dado representacao e o inteiro “0” ao membro dado valor da peça capturada, respectivamente.

A função void tiraPecaTab(origem) retira a peça da posição de origem atribuindo, a string “ “ ao membro dado representacao e o inteiro “0” ao membro dado valor da peça de origem no tabuleiro.

Por último, a função void inserePeca(row-1 , col-1, origem) insere a peça de origem na posição respectiva da matriz do tabuleiro, atribuindo ao campo representacao a representação da peça de origem e ao campo valor o seu valor respectivo.

O argumento origem indica a peça de origem que vai ser colocada na matriz nas coordenadas row e col, linha e coluna respectivamente. Desta forma, o membro dado valor da peça assume “0” quando row e col se referem à origem e assume o número da peça quando row e col se referem ao destino e o membro dado representacao da peça assume “ ” quando row e col se referem à origem e assume a representação da peça quando row e col se referem ao destino.

Jungle Game

4.5 Avaliação do tabuleiro A avaliação do tabuleiro, no caso do Jungle Game, não é aplicável pois, para ganhar o jogo, o jogador tem que ou capturar todas as peças do seu oponente ou ocupar a casa caverna do seu adversário e para isso, qualquer um deles, mesmo que só possuam uma peça em jogo, ainda têm hipótese de ganhar. Contudo a nossa Função existe e “imprime” o número de pecas do jogador

actual.

Tínhamos

também

planeado

acrescentar

uma

linha

“Proximidade da caverna:”, porem devido à falta de tempo não pudemos aprofundar essa ideia, assim como a impressão das pecas capturadas por cada jogador no ecrã.

4.6 Fim do jogo De cada vez que uma jogada é realizada, é necessário verificar se essa mesma jogada conduziu a uma situação de terminação do jogo (ir para a caverna adversária ou comer todas as peças do adversário). A função que verifica estas condições é a bool isVencedor(). Dentro desta função é utilizada a função int vencedor () que verifica qual é o vencedor naquele instante. Dentro desta função existem duas outras funções, int testeum() que avalia se as peças de algum dos jogadores foram todas capturadas, int testedois() que avalia se alguma casa caverna foi ocupada, ou seja, int isVencedor() verifica se o jogo chegou ao fim ou não. Caso tenha chegado ao fim, o vencedor será o jogador activo.

Jungle Game

4.7 Conclusões e Perspectivas de Desenvolvimento Todos os objectivos referidos no enunciado do trabalho foram atingidos.

No início do desenvolvimento do projecto sentimos algumas dificuldades, visto não estarmos totalmente familiarizados com o uso da linguegem orientada a objectos, C++. Como é natural, ao longo do tempo essas dificuldades passaram a ser cada vez menos. Apesar da nossa evolução quanto à compreensão do funcionamento do C++, estamos plenamente conscientes de que não aproveitamos ao máximo todas as potencialidades da linguagem.

Globalmente, achamos que este projecto nos deu a conhecer de forma mais profunda o paradigma de programação de C++, ensinando-nos a programar com base na orientação a objectos.

Uns melhoramentos para o trabalho desenvolvido, seriam a colocação de várias cores no tabuleiro, de forma a distinguir mais facilmente as peças de cada jogador, dar profundidade ao tabuleiro e reservar um espaço no ecrã para inserir as peças capturadas por cada jogador, de forma a ajudar os jogadores a formular a sua estratégia.

Ao nível da estruturação do código seria possível melhorar a eficácia e simplicidade de certos módulos, nomeadamente ser feita a codificação das casas em modo binário como alternativa há codificação deste trabalho realizada com o uso de strings.

Jungle Game

5. Bibliografia Ken Tidwell, JUNGLE GAME, A TRADITIONAL CHINESE BOARD GAME, 1994, em: < http://www.gamecabinet.com/rules/Jungle.html>, acesso em Marรงo, 2008;

Hans L. Bodlaender, Shou Dou Qi The Battle of Animals, 1997, em: <http://www.chessvariants.com/other.dir/animal.html>, acesso em Marรงo, 2008;

Wikipedia, JUNGLE (BOARD GAME), 2007, em: <http://en.wikipedia.org/wiki/Jungle_(board_game)>, 2008;

acesso

em

Marรงo,

Jungle Game

6. Anexos Código 7. FICHEIRO PECA.H 8.

9.

10.

11.

12.

13.

14.

15.

16.

17.

18.

19.

20.

21.

22.

23.

24.

25.

26.

27.

28.

29.

#ifndef PECA_H_ #define PECA_H_

#include <stdio.h> #include <string> class Peca{ public: string representacao; int valor; Peca(){}; //construtor padrao Peca(string rep, int value);// construtor de Peca para rep e value como dados virtual ~Peca(); void imprimePeca(); //funcao que imprime o membro representacao de uma peca };

30. FICHEIRO PECA.CPP 31.

32.

33.

34.

35.

36.

37.

38.

39.

40.

41.

42.

43.

44.

45.

46.

47.

48.

49.

50.

51.

using namespace std; #include "Peca.h" #include <iostream> #include <string> Peca::Peca(string rep, int value) { representacao = rep; valor = value; } Peca::~Peca() { } void Peca::imprimePeca(void) //imprime membro representacao de uma peca { cout << representacao; }

52. FICHEIRO CELL.H 53.

54.

55.

56.

57.

58.

59.

60.

61.

62.

63.

64.

65.

66.

67.

68.

#include <iostream> #include "Peca.h" #include <string>

class Cell{ public: char casa; Peca piece; Cell();//construtor padrao de Cell Cell(char sq, Peca z); //construtor de Cell com valores sq e z void imprimeCasa(); //função que faz a codificação do tipo de casa e a imprime };

Jungle Game

69. FICHEIRO CELL.CPP 70.

71.

72.

73.

74.

75.

76.

77.

78.

79.

80.

81.

82.

83.

84.

85.

86.

87.

88.

89.

90.

91.

92.

93.

94.

95.

96.

97.

98.

99.

100.

101.

102.

103.

using namespace std; #include "Cell.h" #include <iostream>

Cell::Cell()//contructor padrao de uma celula { casa ='n'; piece.representacao =" "; piece.valor = 0; } Cell::Cell(char sq ,Peca z)//contructor nao padrao de uma celula com dados a //inserir como argumentos { piece.representacao = z.representacao; piece.valor = z.valor; casa = sq; } void Cell::imprimeCasa()//para cada letra que se encontra na matriz interna //esta função vai imprimir um símbolo { if(casa=='n')cout<<" "; else{ if(casa=='t')cout<<"#"; else{ if(casa=='w')cout<<"~"; else cout<<"o"; } } }

104. FICHEIRO TABULEIRO.H 105.

106.

107.

108.

109.

110.

111.

112.

113.

114.

115.

116.

117.

118.

119.

120.

121.

122.

123.

124.

125.

126.

127.

128.

129.

130.

131.

132.

133.

134.

135.

136.

137.

138.

139.

140.

141.

142.

143.

#define TABULEIRO_ALTURA 9 #define TABULEIRO_COMPRIMENTO 7 using namespace std; #include <vector> #include <exception> #include "Peca.h" #include "MyException.h" #include "Cell.h" #include "Jogador.h" class Tabuleiro{ public: vector < vector < Cell > > matriz; /*matriz interna que representa o tabuleiro*/ Cell cellVazia;

// celula vazia do tab ,isto é, uma casa sem peça

bool vesetemRato(); /*funcao que verifica se existe uma peça do tipo Rato numa casa de água*/ void inserePeca(int row, int col, Peca p); /*função que insere uma peca p na matriz nas coordenadas row:col*/ void tiraPecaTab(Peca p);

// função que retira uma peca p do tabuleiro

Tabuleiro(Cell Vazia); /*construtor de tab com as respectivas casas e celulas vazias*/ Tabuleiro(){};

//construtor de tab padrao

void imprimeTabuleiro(); /*função que imprime o tab vazio, isto é, apenas com os diferentes tipos de casas e com as casas vazias ou seja sem peças*/ bool verDestino(int line, int col, Peca y ); /* funcao que avalia o destino que o jogador coloca para movimentar a peca; verifica se o movimento está correcto segundo as regras do jogo*/

Jungle Game

144.

145.

146.

147.

148.

149.

150.

151.

152.

153.

154.

155.

156.

157.

158.

159.

160.

161.

162.

163.

164.

165.

166.

167.

168.

169.

170.

171.

172.

173.

174.

175.

176.

177.

178.

179.

180.

181.

182.

183.

184.

185.

186.

187.

188.

189.

190.

191.

192.

193.

194.

195.

196.

197.

198.

199.

200.

201.

202.

203.

204.

205.

206.

207.

208.

209.

210.

211.

212.

213.

214.

215.

216.

217.

218.

bool isLivre(int row, int col, Peca p); /*verifica se a jogada esta dentro dos parametros do jogo; chama a função verDestino e verifica se não existem excepcoes*/ virtual ~Tabuleiro(); }; #endif /*TABULEIRO_H_*/

FICHEIRO TABULEIRO.CPP using namespace std; #include "Tabuleiro.h" #include <iostream> #include <string>

void Tabuleiro::inserePeca(int row, int col, Peca p) /*insere uma peca p nas coordenadas row:col*/ { matriz[row][col].piece = p; } void Tabuleiro::tiraPecaTab(Peca p) //tira uma peca p do tabuleiro { for (int i = 0 ; i < TABULEIRO_ALTURA;i++){ for(int j = 0; j < TABULEIRO_COMPRIMENTO;j++){ if(matriz[i][j].piece.representacao == p.representacao){ matriz[i][j].piece.representacao = " "; matriz[i][j].piece.valor = 0 } } } } /* procura na matriz a peca com aquela representacao especifica da peca p passado por argumento e quando a encontrar atribui-lhe os dados atribuídos anteriormente a uma peca do tipo vazia*/

bool Tabuleiro::vesetemRato()/*função que verifica se existe uma peca do tipo Rato numa casa de agua*/ {

bool resp=0; for (int i = 0 ; i < TABULEIRO_ALTURA;i++){ for(int j = 0; j < TABULEIRO_COMPRIMENTO;j++){ if(matriz[i][j].casa=='w'){ if(matriz[i][j].piece.valor==1) resp= 1 + resp; else resp= 0 + resp; } } } return resp; } /* primeiramente procura na matriz as casas do tipo 'w’, isto é, as casas do tipo água, quando as encontrar verifica se contêm uma peca com valor 1, ou seja se é uma peca do tipo Rato e se for então esta função irá retornar 1 senão retornará 0*/

Tabuleiro::Tabuleiro(Cell Vazia)

Jungle Game 219.

220.

221.

222.

223.

224.

225.

226.

227.

228.

229.

230.

231.

232.

233.

234.

235.

236.

237.

238.

239.

240.

241.

242.

243.

244.

245.

246.

247.

248.

249.

250.

251.

252.

253.

254.

255.

256.

257.

258.

259.

260.

261.

262.

263.

264.

265.

266.

267.

268.

269.

270.

271.

272.

273.

274.

275.

276.

277.

278.

279.

280.

281.

282.

283.

284.

285.

286.

287.

288.

289.

290.

291.

292.

293.

294.

295.

{ matriz.resize(TABULEIRO_ALTURA); //define o tamanho das colunas cellVazia = Vazia; for (int i = 0 ; i < TABULEIRO_ALTURA;i++){ matriz[i].resize(TABULEIRO_COMPRIMENTO); //define o tamanho das linhas for(int j = 0; j < TABULEIRO_COMPRIMENTO;j++){ /* começa a percorrer a matriz e, com os if's que se seguem, vai colocar as diferentes tipos de casa mas com pecas Vazias, daí os objectos que constituem as diferentes celulas possuírem casas distintas mas pecas semelhantes */

if((i+1==1 && j+1==3)||(i+1==1 && j+1==5)||(i+1==2 && j+1==4)||(i+1==9 && j+1==3)||(i+1==9 && j+1==5)||(i+1==8 && j+1==4)) { matriz[i][j].casa='t'; matriz[i][j].piece.representacao = Vazia.piece.representacao; matriz[i][j].piece.valor = Vazia.piece.valor; } else { if(i+1==1 && j+1==4) { matriz[i][j].casa='U'; matriz[i][j].piece.representacao = Vazia.piece.representacao; matriz[i][j].piece.valor = Vazia.piece.valor; } else { if(i+1==9 && j+1==4) { matriz[i][j].casa='D'; matriz[i][j].piece.representacao = Vazia.piece.representacao; matriz[i][j].piece.valor = Vazia.piece.valor; } else { if((i+1==4 && (j+1==2 || j+1==3 || j+1==5 || j+1==6)) || (i+1==5 && (j+1==2 || j+1==3 || j+1==5 || j+1==6)) || (i+1==6 && (j+1==2 || j+1==3 || j+1==5 || j+1==6))) { matriz[i][j].casa='w'; matriz[i][j].piece.representacao = Vazia.piece.representacao; matriz[i][j].piece.valor = Vazia.piece.valor; } else matriz[i][j] = Vazia; } } } } } } void Tabuleiro::imprimeTabuleiro() /*imprime a informacao contida na matriz anteriormante construida mais a "guarnicao" textual que constituirá o tabuleiro*/ { cout << endl << endl; cout << " 1 2 3 4 5 6 7 "; Cout << endl; cout << "

// orientacao para o jogador poder seleccionar as colunas +----++----++----++----++----++----++----+" <<endl;

for(int i=1;i <= TABULEIRO_ALTURA;i++){ cout<<" "<<i; // orientação para o jogador poder seleccionar as linhas for(int j=0; j<TABULEIRO_COMPRIMENTO;j++){ cout << "|" ; matriz[i-1][j].imprimeCasa(); cout<<" "; /*espaco de separação entre casa e peca para melhor perceber a dinâmica do jogo*/

Jungle Game 296.

297.

298.

299.

300.

301.

302.

303.

304.

305.

306.

307.

308.

309.

310.

311.

312.

313.

314.

315.

316.

317.

318.

319.

320.

321.

322.

323.

324.

325.

326.

327.

328.

329.

330.

331.

332.

333.

334.

335.

336.

337.

338.

339.

340.

341.

342.

343.

344.

345.

346.

347.

348.

349.

350.

351.

352.

353.

354.

355.

356.

357.

358.

359.

360.

361.

362.

363.

364.

365.

366.

367.

368.

369.

370.

371.

372.

matriz[i-1][j].piece.imprimePeca(); cout<<"|"; if(j==6){ cout<<i; cout << endl; cout << }

+----++----++----++----++----++----++----+" <<endl;

} } cout << " cout<<endl<<endl;

1

2

3

4

5

6

7

" <<endl;

} Tabuleiro::~Tabuleiro() { } bool Tabuleiro::verDestino(int line, int col, Peca y ) /*verifica condição de só andar uma casa na horizontal e vertical*/ /* percorre a matriz para encontrar as coordenadas da peca y, inserida pelo utilizador, quando encontrar da peca y, inserida pelo utilizador, quando encontrar guarda esses valores em variáveis*/ { int lineOrigem; int colOrigem; for(int i=0;i<TABULEIRO_ALTURA;i++){ for(int j=0;j<TABULEIRO_COMPRIMENTO;j++){ if(matriz[i][j].piece.representacao == y.representacao) { lineOrigem = i; colOrigem = j; } } } if(line==lineOrigem && (col==0 || col==3 || col==6) && line>=3 && line<=5 && (y.representacao == "1T" || y.representacao == "1L" || y.representacao =="2T" || y.representacao =="2L") && (col==colOrigem+3 || col==colOrigem-3) && vesetemRato()==0) return 1; else { if(col==colOrigem &&(line==2 || line==6) && (col==1 ||col==2 || col==4 || col==5) && (y.representacao == "1T" || y.representacao == "1L" || y.representacao =="2T" || y.representacao =="2L") && vesetemRato()==0) return 1; else{ if(col==colOrigem && (line == lineOrigem + 1 || line == lineOrigem - 1)) return true; else{ if(line == lineOrigem && (col == colOrigem + 1 || col == colOrigem - 1)) return true; else return false; } } } } /*com este ultimo segmento de código a função pode verificar se o movimento que o jogador quis fornecer à peca está correcto */ bool Tabuleiro::isLivre(int row, int col, Peca p)

Jungle Game 373.

374.

375.

376.

377.

378.

379.

380.

381.

382.

383.

384.

385.

386.

387.

388.

389.

390.

391.

392.

393.

394.

395.

396.

397.

398.

399.

/*verifica se a jogada esta dentro dos parâmetros do jogo; chama a função verDestino e verifica se n existem excepções*/ { if((row > 8 || col > 6) || (row < 0 || col < 0)) { throw MyException("Coordenadas invalidas!!!"); /*caso as coordenadas n estejam entre estes valores então tratar-se -á devidamente essa excepção*/ return false; } else { if(verDestino(row,col,p)==false ){ throw MyException("Movimento invalido!!"); return 0; } else return 1; } } /*verifica se o movimento esta correcto, caso n esteja procede-se ao devido tratamento da sua excepção */

400. FICHEIRO MYEXCEPTION.H 401.

402.

403.

404.

405.

406.

407.

408.

409.

410.

411.

412.

413.

414.

415.

416.

417.

418.

419.

420.

421.

422.

423.

424.

425.

426.

427.

428.

429.

430.

431.

432.

433.

434.

435.

436.

437.

438.

439.

440.

441.

442.

443.

#ifndef MYEXCEPTION_H_ #define MYEXCEPTION_H_ using namespace std; #include <string> class MyException{ public: string mensagem; MyException(string nome); };

#endif /*EXCEPTION_H_*/

FICHEIRO MYEXCEPTION.CPP using namespace std; #include "MyException.h" MyException::MyException(string nome) { mensagem = nome; }

444. FICHEIRO JOGADOR.H 445.

446.

447.

#ifndef JOGADOR_H_ #define JOGADOR_H

Jungle Game 448.

449.

450.

451.

452.

453.

454.

455.

456.

457.

458.

459.

460.

461.

462.

463.

464.

465.

466.

467.

468.

469.

470.

471.

472.

473.

474.

475.

using namespace std; #include "Peca.h" #include <string> class Jogador { public: Peca playerPeca[8];//array que contera as pecas do Jogador string nome; Jogador();//construtor padrao de um jogador bool verPeca(Peca x);//verifica se a peca pertence ao jogador activo void criapecasJogador(int numeroJogador); /*funcao que coloca pecas no vector playerPecas de um jogador*/ int somaValorPecas(); /*soma o valor d todas as pecas para verificar se as pecas foram todas capturadas ou não*/ virtual ~Jogador(); }; #endif /*JOGADOR_H_*/

476. FICHEIRO JOGADOR.CPP 477.

478.

479.

480.

481.

482.

483.

484.

485.

486.

487.

488.

489.

490.

491.

492.

493.

494.

495.

496.

497.

498.

499.

500.

501.

502.

503.

504.

505.

506.

507.

508.

509.

510.

511.

512.

513.

514.

515.

516.

517.

518.

519.

520.

521.

522.

523.

using namespace std; #include <iostream> #include <string> #include "Jogador.h" #include "Peca.h" Jogador::Jogador() { } bool Jogador::verPeca(Peca x) { bool retorno; for(int j=0;j<8;j++){ if(playerPeca[j].representacao == x.representacao)retorno=1+retorno; } return retorno; } void Jogador::criapecasJogador(int numeroJogador) { string representacoesJogador1[8]={"1R","1C","1D","1W","1P","1T","1L","1E"}; string representacoesJogador2[8]={"2R","2C","2D","2W","2P","2T","2L","2E"}; Peca jogador1[8]; Peca jogador2[8]; if(numeroJogador==1){ for(int i=0; i<8;i++) playerPeca[i] = Peca(representacoesJogador1[i],i+1); //constrói pecas que são inseridas no array do Jogador[0]

} else{ for(int j=0; j<8;j++) playerPeca[j] = Peca(representacoesJogador2[j],j+1); //constrói pecas que são inseridas no array do Jogador[0] } } int Jogador::somaValorPecas() /*função que soma o valor de todas as pecas que se encontram no array playerPeca de um jogador*/

Jungle Game 524.

525.

526.

527.

528.

529.

530.

531.

532.

533.

534.

535.

536.

537.

538.

539.

{ int sum=0; for(int i=1;i<9;i++){ sum = playerPeca[i].valor + sum; } return sum; } /*caso esse valor seja 0 entao é pq esse jogador nao possui pecas e portanto perdeu o jogo a funcao retornara assim 0*/ Jogador::~Jogador() { }

540. FICHEIRO JOGO.H 541.

542.

543.

544.

545.

546.

547.

548.

549.

550.

551.

552.

553.

554.

555.

556.

557.

558.

559.

560.

561.

562.

563.

564.

565.

566.

567.

568.

569.

570.

571.

572.

573.

574.

575.

576.

577.

578.

579.

580.

581.

582.

583.

584.

585.

586.

587.

588.

589.

590.

591.

592.

593.

594.

595.

596.

597.

598.

599.

#ifndef JOGO_H_ #define JOGO_H_ using namespace std; #define NJogadores 2 #include <stdio.h> #include "Peca.h" #include "Tabuleiro.h" class Jogo{ public: Jogo(); // construtor do jogo, cria jogo virtual ~Jogo(); int vencedor();

/*função que retorna 0 ou 1 caso o jogador 1 ou 2 ganhe ou -1 se ainda n houver vencedor*/ void avaliaTabuleiro(); /*funcao que imprime o numero de pecas actual do jogador activo no tabuleiro*/ int testedois();

int testeum();

/*função que verifica se existe alguma peca nas cavernas dos jogadores*/

//função que testa se todas as peças foram comidas ou não

void iniciaJogo();

/*função que inicia o jogo, isto é, pede nome e pecas aos jogadores*/

bool isValido(int row, int col, Peca p);

/*função "mãe" que verifica a validade da jogada*/

bool vertipoCasa(int row, int col, Peca p); /*função chamada pela isValido que aplica as restrições relativas as casas, verificando para tal qual o tipo de casa em questão*/ bool isVencedor();

// verifica resultado final do jogo

void tiraPecaJogador(int r, int c); /*função que retira a peca nas coordenadas r:c do array playerPeca do jogador*/ void trocaJogador();

// inverte o jogador para jogada seguinte

bool executaJogada(); /* executa a jogada pedindo peca, linha e coluna e inserindo a peca na matriz aplicando todas a verificações, ou seja chamando todas as funções de validação*/ bool avaliaPeca(int row , int col, Peca p); /*verifica que a peca inserida pelo Jogador n é uma peca do próprio jogador*/ bool verificaNumero(string tmp); /*função criada especialmente para converter a coluna e linha (strings) em codigo ascii e verificar se realmente são números e não letras ou símbolos*/ Tabuleiro myTab;

// inicia tabuleiro

Jungle Game 600.

601.

602.

603.

604.

605.

606.

607.

608.

609.

610.

611.

Peca pecaVazio; Cell vazia;

//peca vazia

//celula vazia

Jogador jogadores [NJogadores]; int jogadorActivo;

/*array de 2 jogadores do tipo Jogador

//numero do jogador activo , 0-jogador 1, 1-jogador 2

}; #endif /*JOGO_H_*/

612. FICHEIRO JOGO.CPP 613.

614.

615.

616.

617.

618.

619.

620.

621.

622.

623.

624.

625.

626.

627.

628.

629.

630.

631.

632.

633.

634.

635.

636.

637.

638.

639.

640.

641.

642.

643.

644.

645.

646.

647.

648.

649.

650.

651.

652.

653.

654.

655.

656.

657.

658.

659.

660.

661.

662.

663.

664.

665.

666.

667.

668.

669.

670.

671.

672.

673.

674.

675.

using namespace std; #include "Jogo.h" #include<iostream> #include<stdlib.h> Jogo::Jogo() { pecaVazio = Peca ("

",0);

// cria e define membros de uma peca vazia

vazia = Cell ('n', pecaVazio);

//cria e define membros de uma celula vazia

myTab = Tabuleiro(vazia); //cria um tabuleiro usando o construtor n padrĂŁo jogadores[0] = Jogador(); //cria jogador1 jogadores[1] = Jogador(); //cria jogador2 jogadores[0].criapecasJogador(1); /*coloca pecas no array playerPeca do jogador 1*/ jogadores[1].criapecasJogador(2);

/*coloca pecas no array playerPeca do jogador 2*/

jogadorActivo = 0; //define jogador[0] como sendo o primeiro a jogar } void Jogo::avaliaTabuleiro() { int sum=0; for(int i=0;i<8;i++){ if(jogadores[(jogadorActivo + 1) % 2].playerPeca[i].valor!=0) sum = sum +1; else sum= 0 + sum; } cout<<sum<< " pecas" <<endl; } void Jogo::tiraPecaJogador(int r, int c) //retira peça do array do jogador { if(jogadorActivo==0) { for(int i=0; i<8;i++) { if(jogadores[1].playerPeca[i].representacao == myTab.matriz[r][c].piece.representacao) { jogadores[1].playerPeca[i].valor=0; jogadores[1].playerPeca[i].representacao = " "; } } } else { for(int j=0; j<8;j++) { if(jogadores[0].playerPeca[j].representacao == myTab.matriz[r][c].piece.representacao) jogadores[0].playerPeca[j].valor = 0; } }

}

Jungle Game 676.

677.

678.

679.

680.

681.

682.

683.

684.

685.

686.

687.

688.

689.

690.

691.

692.

693.

694.

695.

696.

697.

698.

699.

700.

701.

702.

703.

704.

705.

706.

707.

708.

709.

710.

711.

712.

713.

714.

715.

716.

717.

718.

719.

720.

721.

722.

723.

724.

725.

726.

727.

728.

729.

730.

731.

732.

733.

734.

735.

736.

737.

738.

739.

740.

741.

742.

743.

744.

745.

746.

747.

748.

749.

750.

751.

752.

bool Jogo::vertipoCasa(int row, int col, Peca p)

/*aplica restriçþes relativas aos diferentes tipos de casas*/

{ switch (myTab.matriz[row][col].casa){ case 'n' : if(myTab.matriz[row][col].piece.valor <= p.valor) { return 1; break; } else{ if((p.representacao=="1R" || p.representacao =="2R") && (myTab.matriz[row][col].piece.representacao=="1E" || myTab.matriz[row][col].piece.representacao=="2E")) { return 1; break; } else{ throw MyException("Jogada nao permitida!!!"); return 0; break; } } case 't' : return 1;break; case 'w' : if((p.representacao == "1R") || (p.representacao == "2R")) { return 1; break; } else{ throw MyException("So o Rato pode andar nos Rios!!!"); return 0; break; } case 'U' : if(jogadorActivo == 1) { return 1; break; } else { throw MyException("Impossivel ocupar a propria caverna!!!"); return 0; break; } case 'D' : if(jogadorActivo == 0) { return 1; break; } else { throw MyException("Impossivel ocupar a propria caverna!!!"); return 0; break; } default: return 0; } } int Jogo::vencedor() { if(testeum()==1 || testedois()==1) return 1; else{

if(testeum()==0 || testedois()==0) return 0;

/*quando jogador 1 ganha, retorna 1*/

/*quando jogador 0 ganha, retorna 0*/

Jungle Game 753.

754.

755.

756.

757.

758.

759.

760.

761.

762.

763.

764.

765.

766.

767.

768.

769.

770.

771.

772.

773.

774.

775.

776.

777.

778.

779.

780.

781.

782.

783.

784.

785.

786.

787.

788.

789.

790.

791.

792.

793.

794.

795.

796.

797.

798.

799.

800.

801.

802.

803.

804.

805.

806.

807.

808.

809.

810.

811.

812.

813.

814.

815.

816.

817.

818.

819.

820.

821.

822.

823.

824.

825.

826.

827.

828.

829.

else return -1; }

//sem vencedor.....

}

int Jogo::testeum()

/*retorna 0 caso ganhe o jogador [0] , 1 caso ganhe o jogador [1] e -1 caso n exista ainda vencedor*/

{ if(jogadores[0].somaValorPecas()==0) return 1; else{ if(jogadores[1].somaValorPecas()==0) return 0; else return -1; } } int Jogo::testedois()

/*retorna 0 caso a caverna do jogador [1] esteja ocupada , 1 caso a caverna do jogador [0] esteja ocupada e -1 caso estejam as duas livres*/

{ if(myTab.matriz[8][3].piece.valor!=0) return 0; else { if(myTab.matriz[0][3].piece.valor!=0)return 1; else return -1; } } Jogo::~Jogo() { } void Jogo::iniciaJogo()

/*pede nomes dos jogadores e guarda-os de um objecto Jogagor*/

no membro nome

{ string nomeTmp; cout<<endl; cout << " Nome do Jogador 1: "; cin >> nomeTmp; jogadores[0].nome = nomeTmp; cout << " Nome do Jogador 2: "; cin >> nomeTmp; cout << endl; jogadores[1].nome = nomeTmp; } bool Jogo::avaliaPeca(int row, int col, Peca p) { bool retorno; for(int n=0; n<8; n++){ if(myTab.matriz[row][col].piece.valor != 0){ if(jogadores[jogadorActivo].playerPeca[n].representacao == myTab.matriz[row][col].piece.representacao){ retorno = 0; throw MyException("Nao e possivel capturar as proprias pecas!!!"); }

else retorno = 1; } else retorno = 1; } return retorno;

//retorna 0 se peca origem = peca destino e 1 se diferentes

} bool Jogo::isValido(int row, int col, Peca p) { bool ret1, ret2, ret3; try { ret1 = myTab.isLivre(row, col, p); /*avalia o movimento e verifica se o destino row:col pertence ao tabuleiro*/ }

Jungle Game 830.

831.

832.

833.

834.

835.

836.

837.

838.

839.

840.

841.

842.

843.

844.

845.

846.

847.

848.

849.

850.

851.

852.

853.

854.

855.

856.

857.

858.

859.

860.

861.

862.

863.

864.

865.

866.

867.

868.

869.

870.

871.

872.

873.

874.

875.

876.

877.

878.

879.

880.

881.

882.

883.

884.

885.

886.

887.

888.

889.

890.

891.

892.

893.

894.

895.

896.

897.

898.

899.

900.

901.

902.

903.

904.

905.

906.

catch (MyException e) { cout << " Erro de Jogada!! }

" << e.mensagem <<endl;

try { ret2 = vertipoCasa(row, col, p);

/*aplica restrições relativas ao tipo de casa de destino*/

} catch (MyException f) { cout << " Erro de Jogada!! " << f.mensagem <<endl; } try { ret3 = avaliaPeca(row, col, p); /*certifica-se que a peca pertence ao jogador oposto*/ } catch (MyException g) { cout << " Erro de Jogada!! }

" << g.mensagem <<endl;

if(ret1 == 1 && ret2 == 1 && ret3 == 1) return 1; /*caso estas 3 funções sejam verificadas então a jogada é valida e isValido retornará 1!*/ else return 0;

/*caso contrario retorna 0 e a jogada n sera valida e proceder-se-à ao devido tratamento de excepcao*/

} bool Jogo::isVencedor() //conclui se existe vencedor ou não { int testeWinner = vencedor(); if(testeWinner == 0 || testeWinner == 1) return true;

/*retorna 1 caso exista vencedor e 0 caso não exista*/

else return false; } void Jogo::trocaJogador() //passa o turno, isto é, muda de jogador { jogadorActivo = ((jogadorActivo + 1) % 2); } bool Jogo::verificaNumero(string tmp) { int sum =0; vector <char> c; c.resize(tmp.length()); for(int i=0; i < tmp.length();i++) { c[i]=tmp[i]; sum = toascii(c[i]) + sum;

/*converte cada carater do da string que esta a ser convertida para vector em código ascii e vai somando esse valor*/

} if(sum<=57 && sum>=49) return 1; /*se o valor dessa soma não estiver entre 49 e 58 ( números de 1 a 9) então devera retornar 0 , pois o jogador não colocou um numero valido*/ else{ cout<<" Coordenadas Invalidas!!!"<<endl; /*neste caso decidimos não proceder ao devido tratamento de excepção pois só iria dificultar a percepção do código*/ return 0; } } bool Jogo::executaJogada() {

/*função que pede ao jogador a peca, linha e coluna e avalia já alguns parâmetros*/

Jungle Game 907.

908.

909.

910.

911.

912.

913.

914.

915.

916.

917.

918.

919.

920.

921.

922.

923.

924.

925.

926.

927.

928.

929.

930.

931.

932.

933.

934.

935.

936.

937.

938.

939.

940.

941.

942.

943.

944.

945.

946.

947.

948.

949.

950.

951.

952.

953.

954.

955.

956.

957.

958.

959.

960.

961.

962.

963.

964.

965.

966.

967.

968.

969.

970.

971.

972.

973.

974.

975.

976.

977.

978.

979.

980.

981.

982.

983.

int row, col; string rowTmp, colTmp; bool valido = false; Peca origem; cout << " "<< "Turno do " <<jogadores[jogadorActivo].nome << endl; while(!valido) { cout << " Peca a movimentar:"; cin >> origem.representacao; while(jogadores[jogadorActivo].verPeca(origem)==false){ cout << " Erro de Jogada!! "<< endl<<" Peca a movimentar:"; cin >> origem.representacao; } if(jogadores[jogadorActivo].verPeca(origem)==true) /* verifica que a peca pertence ao jogador activo e que é uma peca valida!!*/ { for(int i=0; i<8; i++){ if(jogadores[jogadorActivo].playerPeca[i].representacao == origem.representacao) { origem = jogadores[jogadorActivo].playerPeca[i]; } } }

cout << " Linha: "; cin >> rowTmp; cout << " Coluna: "; cin >> colTmp; row = atoi(rowTmp.c_str()); col = atoi(colTmp.c_str()); while(verificaNumero(rowTmp)==0 || verificaNumero(colTmp)==0) /* Esta porção de código verifica se a string inserida como coluna e realmente do tipo inteiro não uma string! { cout << " cin cout << " cin

Linha: "; >> rowTmp; Coluna: "; >> colTmp;

row = atoi(rowTmp.c_str()); col = atoi(colTmp.c_str()); } valido = isValido(row - 1 , col - 1, origem);

//re-avalia a joga

} if(valido) /*se a jogada for valida então retira-se a peca do array do jogador, do tabuleiro e insere-se a nova peca*/ { tiraPecaJogador(row - 1, col - 1); myTab.tiraPecaTab(origem); myTab.inserePeca(row - 1 , col - 1, origem ); } return valido; //retorna 0 caso a jogada n seja valida e 1 caso seja } int main() { char saida;

/* variável a receber do jogador para saber o que deseja saber após existir um vencedor: sair do jogo ou não*/

string saidan;

// variavel a receber

bool vencedor = false; Jogo myJogo = Jogo();

para o jogador sair..

// inicialmente n existe vencedor //criação do jogo

Jungle Game 984.

985.

986.

987.

988.

989.

990.

991.

992.

993.

994.

995.

996.

997.

998.

999.

1000.

1001.

1002.

1003.

1004.

1005.

1006.

1007.

1008.

1009.

1010.

1011.

1012.

1013.

1014.

1015.

1016.

1017.

1018.

1019.

1020.

1021.

1022.

1023.

1024.

1025.

1026.

1027.

1028.

1029.

1030.

1031.

1032.

1033.

1034.

1035.

1036.

1037.

1038.

1039.

1040.

1041.

1042.

1043.

1044.

1045.

1046.

1047.

1048.

1049.

1050.

1051.

1052.

1053.

1054.

1055.

1056.

1057.

1058.

1059.

1060.

myJogo.myTab.inserePeca(1-1,1-1,myJogo.jogadores[0].playerPeca[6]); // colocaçao de pecas iniciais no tabuleiro myJogo.myTab.inserePeca(2-1,2-1,myJogo.jogadores[0].playerPeca[3]); myJogo.myTab.inserePeca(1-1,7-1,myJogo.jogadores[0].playerPeca[5]); myJogo.myTab.inserePeca(2-1,6-1,myJogo.jogadores[0].playerPeca[1]); myJogo.myTab.inserePeca(3-1,1-1,myJogo.jogadores[0].playerPeca[0]); myJogo.myTab.inserePeca(3-1,3-1,myJogo.jogadores[0].playerPeca[4]); myJogo.myTab.inserePeca(3-1,5-1,myJogo.jogadores[0].playerPeca[2]); myJogo.myTab.inserePeca(3-1,7-1,myJogo.jogadores[0].playerPeca[7]); myJogo.myTab.inserePeca(9-1,1-1,myJogo.jogadores[1].playerPeca[5]); myJogo.myTab.inserePeca(9-1,7-1,myJogo.jogadores[1].playerPeca[6]); myJogo.myTab.inserePeca(7-1,1-1,myJogo.jogadores[1].playerPeca[7]); myJogo.myTab.inserePeca(8-1,2-1,myJogo.jogadores[1].playerPeca[1]); myJogo.myTab.inserePeca(7-1,3-1,myJogo.jogadores[1].playerPeca[2]); myJogo.myTab.inserePeca(7-1,5-1,myJogo.jogadores[1].playerPeca[4]); myJogo.myTab.inserePeca(8-1,6-1,myJogo.jogadores[1].playerPeca[3]); myJogo.myTab.inserePeca(7-1,7-1,myJogo.jogadores[1].playerPeca[0]);

myJogo.iniciaJogo();

// e respectiva iniciação

cout<<"========================================================================= ======="<<endl; // Cabecalho do jogo cout<<"*********************************** Jungle Game ********************************"<<endl;// cout<<"========================================================================= ======="<<endl; cout<<endl; cout << "

Jogador 1 - "<<myJogo.jogadores[0].nome; /*impressao do nome dos jogador[0]*/

myJogo.myTab.imprimeTabuleiro();

//impressao do tabuleiro

cout << " Jogador 2 - "<<myJogo.jogadores[1].nome<<endl<<endl; //impressao do nome dos jogador[1] cout << " Avaliacao Pecas Jogador : 8 pecas " <<endl<<endl; while(!vencedor) { while(!myJogo.executaJogada()); system("CLS");//funcao que limpa o ecra cout<<endl<<endl<<endl<<endl;

cout<<"======================================================"<<endl; cout<<"*************** Jungle Game **********************"<<endl;

cout<==================================================================="<<endl; cout<<endl; cout <<endl<< " Jogador 1 - "<<myJogo.jogadores[0].nome; myJogo.myTab.imprimeTabuleiro(); cout << " Jogador 2 - "<<myJogo.jogadores[1].nome<<endl<<endl; cout << " Avaliacao Pecas Jogador : " ; myJogo.avaliaTabuleiro(); vencedor = myJogo.isVencedor(); // Verifica se ha vencedor if(vencedor) { cout << myJogo.jogadores[myJogo.jogadorActivo].nome << " Ganhou!" << endl; //se existir o jogo acaba nesse momento, imprimindo o nome do jogador que ganhou } else myJogo.trocaJogador(); //caso nao exista vencedor entao troca-se de jogador e o jogo continua...

Jungle Game 1061.

1062.

1063.

1064.

1065.

1066.

1067.

1068.

1069.

1070.

1071.

1072.

1073.

1074.

} cout << "

Deseja sair do Jogo?? <s/n>"; //Pergunta ao Jogador que ganhou se deseja sair do jogo cin >> saida; if(saida=='s') cout<<endl<<endl<<"

else { cout <<" cin>>saidan; } return 0; }

A sair...."<<" ...."<<" ...."<<" ...."<<endl;

prima qualquer tecla para abandonar o jogo....";