RELATÓRIO DE AVALIAÇÃO INTERCALAR DO 1º TRABALHO PRÁTICO DA DISCIPLINA DE PROGRAMAÇÃO EM LÓGICA

R

ELATÓRIO DE AVALIAÇÃO INTERCALAR DO

1

º

T

RABALHO PRÁTICO DA DISCIPLINA DE

P

ROGRAMAÇÃO EM

L

ÓGICA

Jogo seleccionado:

Angela Silva – angela.silva@fe.up.pt

Carlos Aldeias – carlos.aldeias@fe.up.pt

Faculdade de Engenharia da Universidade do Porto

Departamento de Engenharia Electrotécnica e de Computadores

Rua Roberto Frias, s/n, 4200-465 Porto, Portugal

Í

NDICE

Índice

RESUMO... 1

INTRODUÇÃO... 1

DESCRIÇÃO DO PROBLEMA... 2

O

BJECTIVO DO

J

OGO

... 2

R

EGRAS DO

J

OGO

... 2

P

ONTUAÇÃO

... 3

F

IM DO JOGO E VENCEDOR DA PARTIDA

... 4

REPRESENTAÇÃO DO ESTADO DO JOGO... 5

R

EPRESENTAÇÃO DA SITUAÇÃO DAS POSIÇÕES

... 6

R

EPRESENTAÇÃO DE UMA JOGADA

... 6

VISUALIZAÇÃO DO TABULEIRO ... 8

Í

NDICE

Lista de ilustrações

I

LUSTRAÇÃO

1

–

E

XEMPLO DE UM TABULEIRO DE

P

AH

T

UM

... 2

I

LUSTRAÇÃO

2

–

T

ABULEIRO COM ALGUMAS JOGADAS

... 3

I

LUSTRAÇÃO

3

–

P

ONTUAÇÃO ORIGINAL

... 3

I

LUSTRAÇÃO

4

–

P

ONTUAÇÃO ADICIONAL

... 3

I

LUSTRAÇÃO

5

–

P

REDICADO QUE CRIA UMA LISTA DE LISTAS COM DIMENSÃO VARIÁVEL

... 5

I

LUSTRAÇÃO

6

–

P

REDICADO QUE GERA OS

‘

BURACOS NEGROS

’ ... 6

I

LUSTRAÇÃO

7

–

D

ESCRIÇÃO DOS VALORES PARA AS POSIÇÕES

... 6

I

LUSTRAÇÃO

8

–

D

IAGRAMA DE UMA JOGADA

... 7

I

LUSTRAÇÃO

9

–

P

REDICADO INSERE

_

PECA

... 7

I

LUSTRAÇÃO

10

–

V

ALIDAÇÃO DA DIMENSÃO DO TABULEIRO

... 8

I

LUSTRAÇÃO

11

-

V

ISUALIZAÇÃO DO TABULEIRO

... 9

I

LUSTRAÇÃO

12

–V

ALIDAÇÃO DAS COORDENADAS

... 9

I

LUSTRAÇÃO

13

–

E

XECUÇÃO DE UMA JOGADA

... 10

R

ESUMO E

I

NTRODUÇÃO

Resumo

O trabalho resume-se ao desenvolvimento do jogo de tabuleiro Pahtum, utilizando a

lin-guagem Prolog para a sua implementação. Neste projecto constará um módulo de

visuali-zação gráfica 3D, desenvolvido em linguagem C++, recorrendo à tecnologia OpenGL.

A versão final da aplicação deve permitir o jogo entre dois humanos, ou entre um humano

e um computador ou ainda entre computador-computador. O jogador pode escolher o nível

de dificuldade e o tamanho do tabuleiro.

Introdução

A realização deste

t

rabalho pretende fundamentar o contacto com o paradigma da

programa-ção em lógica,

utilizando

metodologias lógicas de resolução de problemas, essencialmente

importantes no domínio da teoria dos jogos.

O projecto de desenvolvimento deste jogo demonstra-se bastante apelativo uma vez que,

ape-sar de ser desconhecido aos elementos do grupo e tratar-se de um jogo simples e com poucas

regras, permite focar a atenção do grupo em aspectos importantes duma implementação neste

âmbito.

Sem alterar as regras básicas do jogo, decidimos introduzir o conceito de tabuleiro com

tama-nho variável, contornando o tamatama-nho original (7 x 7). Assim, decidimos permitir tabuleiros de

jogo quadrados, com

tamanhos

entre 7 a 14. Esta inovação acarretou também decisões nas

regras de pontuação, mas que adicionaram uma motivação extra de maneira a enriquecer este

trabalho.

D

ESCRIÇÃO DO

P

ROBLEMA

Descrição do problema

O jogo PahTum é um dos jogos mais antigos, tendo-se encontrado tabuleiros ancestrais

em escavações antigas em Old Mezopotamia and Asyria.

Este jogo assenta num tabuleiro quadrado, com tamanho original de 7x7, contendo um

número ímpar de ‘buracos negros’ que são gerados aleatoriamente para cada jogo [2]. A

figura seguinte, ilustra um possível tabuleiro.

Ilustração 1 – Exemplo de um tabuleiro de PahTum

Nesta implementação introduzimos a possibilidade de alterar o tamanho do tabuleiro,

permitindo a utilização de tabuleiros quadrados de tamanho 7 a 14.

Objectivo do Jogo

O objectivo deste jogo é preencher um tabuleiro de forma a obter o maior número de peças

contíguas, segundo os alinhamentos horizontal e vertical.

Regras do Jogo

Cada jogagor posiciona pedras brancas e pretas, sendo a cor afecta a cada jogador

atribuí-da inicialmente. Caatribuí-da jogador só pode colocar uma única pedra por turno. Um pedra só

pode ser posicionada num quadrado disponível, ou seja, sem nenhuma pedra já lá colocada

(sua ou do opositor) ou que seja um ‘buraco negro’. A figura seguinte, apresenta um

tabuleiro após algumas jogadas.

D

ESCRIÇÃO DO

P

ROBLEMA

Ilustração 2 – Tabuleiro com algumas jogadas

Pontuação

A pontuação é atribuída aos jogadores consoante o número de peças contíguas da cor

res-pectiva, encontrando-se estas alinhadas na vertical ou horizontal. A pontuação original

previa atribuição de pontos até 7 pedras contíguas, uma vez que seria esta a situação

ópti-ma verificada para cada linha vertical ou horizontal de pedras (não são contabilizadas as

pedras contíguas nas direcções diagonais. Uma vez que a versão que propomos

implemen-tar permite tabuleiros até dimensões de 14x14, tornou-se necessário coimplemen-tar as situações não

previstas pelo sistema de pontuação original [2]. Assim, mantendo-se as pontuações

origi-nais até 7 pedras juntas, acrescentamos as pontuações para as novas situações possíveis,

como se verifica nas tabelas seguintes:

Ilustração 3 – Pontuação original

Ilustração 4 – Pontuação adicional

Nº Pedras

Pontos

1

0

2

0

3

3

4

10

5

25

6

56

7

119

Nº Pedras

Pontos

8

246

9

501

10

1012

11

2035

12

4082

13

8177

14

16368

D

ESCRIÇÃO DO

P

ROBLEMA

O sistema de pontuação segue a seguinte relação:

i i i

P

S

P



2



_1



i



3

onde:

P

i

– Pontuação a obter;

P

i-1

– Pontuação a obter;

S

i

– Número de pedras.

Fim do jogo e vencedor da partida

O jogo termina quando já não existirem jogadas válidas para para posicionar pedras. A

pontuação de cada jogador é somada de acordo com as especificações da pontuação. O

jogador que obtiver a maior pontuação é o vencedor da partida.

R

EPRESENTAÇÃO DO

E

STADO DO

J

OGO

Representação do estado do jogo

Os jogos de tabuleiro assentam em estruturas semelhantes, mais ou menos complexas, que

permitem a representação do estado do jogo. Assim, como o PahTum consiste em

tabulei-ros quadrados, a representação óptima em Prolog consiste numa lista de listas, onde cada

um dos elementos representa uma pedra(branca ou preta), uma casa vazia ou um buraco.

A introdução de tabuleiros de vários tamanhos suscitou a criação de um predicado que

construa essa lista de listas que corresponde ao tabuleiro, indicando a dimensão necessária.

A imagem seguinte ilustra esse predicado.

Ilustração 5 – Predicado que cria uma lista de listas com dimensão variável

Com a utilização de tabuleiros dimensionáveis, optámos por definir um critério mais claro

quanto à geração aleatória de ‘buracos negros’. Segundo as regras obtidas na referência

[2], existe alguma ambiguidade quanto a este aspecto. Assim, como limite inferior,

defi-nimos 5. Para o tecto máximo possível, optámos por indexar ao tamanho do tabuleiro,

considerando o limite superior de 25%*Dim

2

. onde Dim representa a dimensão do

tabulei-ro.

A verificação do número de ‘buracos negros’ ser ímpar não é de todo descurada, sendo

também validada esta situação. O predicado seguinte efectua essa funcionalidade.

R

EPRESENTAÇÃO DO

E

STADO DO

J

OGO

Ilustração 6 – Predicado que gera os ‘buracos negros’

Representação da situação das posições

Cada posição do tabuleiro, representada na lista de listas, podem assumir diferentes

valo-res consoante a sua situação de disponibilidade. A tabela seguinte repvalo-resenta essa

associa-ção:

Representação de uma jogada

A jogada efectuada em cada iteração deve ser validada de acordo com as regras definidas

para este jogo. Assim, um jogador que lhe tem anexado uma determinada cor, insere a

posição onde pretende colocar uma nova peça. Essa indicação é validada e em caso de

falha (por posição inválida), é novamente pedido ao jogador para inserir as coordenadas.

Sendo válidas essas coordenadas, é em seguida verificada a disponibilidade da posição

indicada pelo jogador. Recorde-se que um jogador apenas pode posicionar uma pedra

Valor

Descrição

0

Posição do tabuleiro vazia

1

Posição do tabuleiro ocupada com pedra do jogador 1

2

Posição do tabuleiro ocupada com pedra do jogador 2

3

Posição do tabuleiro com ‘buraco negro’

R

EPRESENTAÇÃO DO

E

STADO DO

J

OGO

numa casa vazia. Caso isso se verifique, é finalmente posicionada essa pedra nas

coorde-nadas pretendidas.

A seguinte ilustração representa essa ordem de chamada dos procedimentos.

Ilustração 8 – Diagrama de uma jogada

O excerto do código que a seguir se apresenta, refere-se ao predicado responsável pela

inserção de uma pedra, numa posição válida.

Ilustração 9 – Predicado insere_peca

Pede a posição

para a jogada

Valida as

coorde-nadas

Verifica a

disponi-bilidade da posição

erro

Insere pedra no

tabuleiro

V

ISUALIZAÇÃO DO TABULEIRO

Visualização do Tabuleiro

A visualização do tabuleiro do jogo original do PahTum não traria grandes dificuldades.

Contudo, a opção de existirem tabuleiros de tamanhos variáveis, introduz algum esforço

adicional, que convém não descuidar em qualquer das etapas.

À parte deste pormenor, a visualização resume-se à adaptação do código do jogo ‘Damas’

disponibilizado pelo professor Luís Paulo Reis [1], para a nossa realidade.

Em seguida, apresentam-se algumas representações de tabuleiros ao longo de um jogo.

V

ISUALIZAÇÃO DO TABULEIRO

Ilustração 11 - Visualização do tabuleiro

Ilustração 12 –Validação das

coorde-nadas

V

ISUALIZAÇÃO DO TABULEIRO

V

ISUALIZAÇÃO DO TABULEIRO

C

ONCLUSÃO

Conclusões e perspectivas de desenvolvimento

Neste momento intermédio de avaliação do trabalho já desenvolvido, constatámos que

estão atingidos os objectivos iniciais propostos para esta fase do projecto, estando já

mes-mo implementado a jogabilidade de humano contra humano, com validação de jogadas.

A opção por disponibilizar aos jogadores a possibilidade de alterar a dimensão do

tabulei-ro contribuiu para a inovação de um jogo de fácil implementação, permitindo, deste modo,

um maior leque de opções por parte do jogador, e mais cuidado na implementação, por

parte do programador.

Até ao momento, estimamos ter produzido cerca de 40% do trabalho proposto.

A perspectiva de integração deste jogo com uma interface gráfica criada em OpenGL

pro-porciona uma motivação crescente, prevendo que exista uma maior jogabilidade no jogo.

R

EFERÊNCIAS

B

IBLIOGRÁFICAS

Referências Bibliográficas

[1] Eugénio Oliveira e Luís Paulo Reis, Materiais da Disciplina de Programação em

Lógica, disponível online a partir de http://paginas.fe.up.pt/~eol/LP/0809 (consultado

em Outubro de 2008).

[2] Vários autores, BrainKing – Game Rules (PahTum), disponível online a partir de

http://brainking.com/en/GameRules?tp=72 (consultado em Outubro de 2008).

A

NEXOS

- i -

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% JOGO PAHTUM EM PROLOG - Angela Silva & Carlos Aldeias - 23/09/2008 %%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

:-use_module(library(lists)).

:- dynamic vazio/1. % numero que representa a casa vazia no tabuleiro :- dynamic buraco/1. % numero que representa o buraco no tabuleiro :- dynamic dim_max/1. % dimensao maxima do tabuleiro

:- dynamic dim_min/1. % dimensao minima do tabuleiro

:- dynamic numB/1. % valor que permite calcular o numero de buracos no %tabuleiro em funcao da dimensao do tabuleiro

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%% PREDICADOS CENTRAIS DO JOGO %%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

inicio:- inicializacao, apresentacao,

pede_dim(D), % pede dimensao do tabuleiro assert(dim(D)), % guarda a dimensao do tabuleiro cria_tab(Tab), % cria tabuleiro vazio com dimensao D cria_buracos(Tab,NovTab), % cria um novo tabuleiro com buracos joga(1,1,NovTab). % inicia jogo

inicializacao:- abolish(dim/1), % declaracao da "variavel" dim abolish(jogador/1), % declaracao da "variavel" jogador assert(vazio(0)), % atribuicao do valor 0 a casa vazia assert(buraco(3)), % atribuicao do valor 3 a casa com buraco assert(dim_max(14)), % atribuicao do valor 14 a dimensao maxima assert(dim_min(7)), % atribuicao do valor 7 a dimensao minima assert(numB(4)), % atribuicao do valor 4 ao numB

assert(jogador(1)), assert(jogador(2)).

apresentacao:-

write('PahTum em Prolog - 23/09/2008 - Angela Silva e Carlos Aldeias'), nl, nl.

joga(N,J,Tab):- write('Jogada: '), write(N), write(' Jogador:'), write(J), nl, visualiza_estado(Tab), jogador(J),

pede_jogada(X,Y,Tab), executa_movimento(X-Y, J, Tab, NovoTab), write(X-Y),nl,write('---'),nl, (finaliza(J,NovoTab) ; continua(N,J,NovoTab)).

continua(N,J,Tab):- N2 is N+1, troca(J,J2), joga(N2,J2,Tab).

finaliza(_, Tab):- fim_jogo(Tab), visualiza_estado(Tab), write('Fim do Jogo.'), nl.

%troca(J,J2). troca(1,2). troca(2,1).

A

NEXOS

- ii -

% pede a dimensao do tabuleiro ate esta ser valida

pede_dim(X):- dim_max(DimMax), dim_min(DimMin),

write('Insira a dimensao do tabuleiro ('),

write(DimMin), write(' a '), write(DimMax), write('):'), nl, read(Y), integer(Y), Y =< DimMax, Y >= DimMin, X is Y. pede_dim(X):- write('Dimensao invalida!'), nl, nl, pede_dim(X).

% pede a posicao para a jogada ate essa posicao ser valida

pede_jogada(X,Y,Tab):- write('Insere posicao X:'),nl, read(X), integer(X), verifica_limite(X), write('Insere posicao Y:'),nl, read(Y), integer(Y), verifica_limite(Y),

movimento_valido(X-Y, Tab).

pede_jogada(X,Y,Tab):- write('Posicao invalida!'), nl, nl, pede_jogada(X,Y,Tab).

% verifica se X esta dentro dos limites do tabuleiro verifica_limite(X):- dim(D), X > 0, X =< D.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%% MANIPULACAO DO TABULEIRO %%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% cria um tabuleiro com a dimensao X cria_tab(Tab):- cria_tab_aux(Tab,0). cria_tab_aux([],X):- dim(Y), X is Y.

cria_tab_aux([H|R],N):- cria_linha(H,0), N1 is N+1, cria_tab_aux(R,N1).

cria_linha([],X):- dim(Y), X is Y.

cria_linha([H|R],N):- vazio(H), N1 is N+1, cria_linha(R,N1).

% insere a peca no tabuleiro na posicao(X,Y)

insere_peca(Peca,X,Y,Tab,NovoTab):- ins_peca_aux(1,Peca,X,Y,Tab,NovoTab),!. ins_peca_aux(_,_,_,_,[],[]). ins_peca_aux(Y,Peca,X,Y,[Lin|R],[NovLin|R2]):-ins_peca_lin(1,Peca,X,Lin,NovLin), N2 is Y+1, ins_peca_aux(N2,Peca,X,Y,R,R2). ins_peca_aux(N,Peca,X,Y,[Lin|R],[Lin|R2]):- N\=Y, N2 is N+1, ins_peca_aux(N2,Peca,X,Y,R,R2). ins_peca_lin(_,_,_,[],[]). ins_peca_lin(X,Peca,X,[_|R],[Peca|R2]):-N2 is X+1, ins_peca_lin(N2,Peca,X,R,R2). ins_peca_lin(N,Peca,X,[H|R],[H|R2]):- N\=X, N2 is N+1, ins_peca_lin(N2,Peca,X,R,R2).

% devolve a peca que esta na posicao(X,Y) do tabuleiro busca_peca(X,Y,Peca,Tab):- busca_peca_aux(1,X,Y,Peca,Tab). busca_peca_aux(Y,X,Y,Peca,[Lin|_]):- busca_peca_lin(1,X,Peca,Lin),!. busca_peca_aux(N,X,Y,Peca,[_|R]):- N\=Y, N1 is N+1, busca_peca_aux(N1,X,Y,Peca,R). busca_peca_lin(X,X,Peca,[Peca|_]). busca_peca_lin(N,X,Peca,[_|R]):- N\=X, N1 is N+1, busca_peca_lin(N1,X,Peca,R). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Insere um numero N aleatorio (em que N pode ser no maximo igual a 1/4 da % % dimensao do tabuleiro(DxD)) de buracos calculados tambem aleatoriamente e % % "devolve" em NovTab o novo tabuleiro ja com os buracos inseridos %

A

NEXOS

- iii -

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% cria_buracos(Tab,NovTab):- numB(B), dim(X),

L is (X*X)//B, % o numero de buracos pode ser no maximo 1/4 da %dimensao do tabuleiro(DxD)

num_burac(N,L), % gera aleatoriamente N buracos em que 5<N<DxD/4 cria_burac(N,Tab,NovTab).% cria um novo tabuleiro com os N buracos

cria_burac(N,Tab,NovTab):- cria_burac2(0,N,[],Tab,NovTab).

cria_burac2(X,X,_,Tab,Tab). % se o num de buracos inseridos for igual ao %num de buracos previsto "devolve" o tabuleiro cria_burac2(X,N,List,Tab,NovTab):-

dim(D),B is random(D*D), % gera aleatoriamente um numero N que é a %posicao do buraco no tabureiro em que 0<N<D*D not(member(B,List))-> % verifica se o N ja esta na lista de buracos (insere_buraco(B,Tab,NovTab2), % se nao insere esse buraco N no tabureiro, X1 is X+1, L2 = [B|List], % incrementa o numero de buracos no tabuleiro %e insere esse buraco na lista de buracos, cria_burac2(X1,N,L2,NovTab2,NovTab));% e chama outra vez o predicado mas % agora com o novo tabuleiro

cria_burac2(X,N,List,Tab,NovTab).% caso esse numero ja esteja na lista chama %outra vez o predicado sem alterar o

%tabuleiro e o numero de buracos inseridos

% Insere o buraco N no tabuleiro Tab e "devolve" em NovTab o novo tabuleiro insere_buraco(N,Tab,NovTab):-

dim(D), X is (N mod D)+1, Y is (N//D)+1, % calcula a posicao(X,Y) tendo em % conta a posicao N

buraco(B),insere_peca(B,X,Y,Tab,NovTab). % insere o buraco no tabuleiro

num_burac(N,L):- % Calcula aleatoriamente o numero de buracos X is random(L-5)+5, % coloca em X um numero aleatorio em que 5<X<L-5 verifica_impar(X)-> N is X; % verifica se X é impar se for "devolve" em N %esse valor

num_burac(N,L). % caso contrario chama novamente o procedimento %para gerar um novo numero

verifica_impar(N):- % Verifica se um numero N é impar

X is N mod 2, % coloca em X o resto da divisao interira por 2 X \= 0. % se X for diferente de 0 o numero é impar caso %contrario o numero é par

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%% VALIDACAO E EXECUCAO DE MOVIMENTOS %%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % predicado que verifica se um dado movimento e valido ou "devolve" em X-Y um % movimento valido, isto e usado para obter todas as jogadas possiveis

%movimento_valido(?X-?Y, ?Tab)

movimento_valido(X-Y, Tab):- dim(D), cria_lista(D,Lista), member(X, Lista), member(Y, Lista), verifica_limite(X),

verifica_limite(Y), busca_peca(X,Y,Peca,Tab), vazio(V), Peca = V. cria_lista(D,Lista):- cria_lista_aux(1,D,Lista). cria_lista_aux(D,D,[D]). cria_lista_aux(N,D,[N|R]):- N < D, N1 is N+1, cria_lista_aux(N1,D,R).

A

NEXOS

- iv -

% verifica se o movimento e valido e executa-o caso seja valido

%executa_movimento(+X-+Y,+Peca,+Tab,-NovTab)

executa_movimento(X-Y,Peca,Tab,NovTab):- movimento_valido(X-Y, Tab), insere_peca(Peca,X,Y,Tab,NovTab).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%% AVALIACAO DO ESTADO DO JOGO - TABULEIRO %%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %pontos(+NumPedras, -Pontos) pontos(1,0). pontos(2,0). pontos(3,3). pontos(4,10). pontos(5,25). pontos(6,56). pontos(7,119). pontos(8,246). pontos(9,501). pontos(10,1012). pontos(11,2035). pontos(12,4082). pontos(13,8177). pontos(14,16368). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%% DETERMINACAO DO FINAL DO JOGO %%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % verifica se existe alguma jogada possivel, se nao existir e porque o jogo %acabou pois o tabuleiro ja esta cheio

fim_jogo(Tab):- findall(X-Y,movimento_valido(X-Y, Tab),Lista), Lista = [].

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%% CALCULO DA JOGADA DO COMPUTADOR %%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%% VISUALIZACAO DO ESTADO DO JOGO - MODO DE TEXTO %%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%visualiza_estado(+Tabuleiro)

visualiza_estado(Tab):- write(' '), dim(D), cria_lista(D,Lis),

mostra_lista(Lis), nl, write(' '),mostra_divisao, mostra_linhas(1,Tab),

write(' '), mostra_lista(Lis),nl,!.

mostra_linhas(_,[]).

mostra_linhas(N,[Lin|R]):- N<10, write(' '), write(N), write(' |'), mostra_linha(Lin), write(' '), write(N), nl, N2 is N+1,write(' '),mostra_divisao, mostra_linhas(N2, R).

mostra_linhas(N,[Lin|R]):- write(N), write(' |'), mostra_linha(Lin),write(' '), write(N), nl, N2 is N+1,write(' '), mostra_divisao, mostra_linhas(N2, R).

A

NEXOS

- v -

mostra_linha([H|R]):- escreve(H), write('|'), mostra_linha(R).

mostra_lista([]).

mostra_lista([H|R]):- H > 9, write(' ') , write(H), write(' '), mostra_lista(R). mostra_lista([H|R]):- write(' '), write(H), write(' '), mostra_lista(R).

mostra_divisao:- mostra_divisao_aux(1).

mostra_divisao_aux(D):- dim(D), write('+---+'),nl.

mostra_divisao_aux(N):- N1 is N+1, write('+---'), mostra_divisao_aux(N1).

escreve(0):-write(' ').

escreve(1):-write(' 0 '). % jogador 1 escreve(2):-write(' O '). % jogador 2 escreve(3):-write(' # ').

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%% TESTES DIVERSOS PARA DEBUG %%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

teste1:- abolish(dim/1),assert(dim(8)), assert(vazio(0)), cria_tab(Tab), findall(X-Y,movimento_valido(X-Y, Tab),Lista), write(Lista),nl. teste2:- abolish(dim/1),assert(dim(8)), assert(vazio(0)), cria_tab(Tab), fim_jogo(Tab).