Vous êtes sur la page 1sur 21

RELATÓRIO DE AVALIAÇÃO INTERCALAR DO

1º TRABALHO PRÁTICO DA DISCIPLINA DE


PROGRAMAÇÃ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

Outubro de 2008
ÍNDICE

Índice

RESUMO.................................................................................................................................................. 1

INTRODUÇÃO........................................................................................................................................ 1

DESCRIÇÃO DO PROBLEMA.............................................................................................................. 2

OBJECTIVO DO JOGO ............................................................................................................................ 2


REGRAS DO JOGO ................................................................................................................................. 2
PONTUAÇÃO .......................................................................................................................................... 3
FIM DO JOGO E VENCEDOR DA PARTIDA ................................................................................................ 4

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

REPRESENTAÇÃO DA SITUAÇÃO DAS POSIÇÕES ..................................................................................... 6


REPRESENTAÇÃO DE UMA JOGADA ....................................................................................................... 6

VISUALIZAÇÃO DO TABULEIRO ...................................................................................................... 8

CONCLUSÕES E PERSPECTIVAS DE DESENVOLVIMENTO ...................................................... 12

-I-
ÍNDICE

Lista de ilustrações

ILUSTRAÇÃO 1 – EXEMPLO DE UM TABULEIRO DE PAHT UM .......................................................................... 2


ILUSTRAÇÃO 2 – TABULEIRO COM ALGUMAS JOGADAS ................................................................................. 3
ILUSTRAÇÃO 3 – PONTUAÇÃO ORIGINAL ...................................................................................................... 3
ILUSTRAÇÃO 4 – PONTUAÇÃO ADICIONAL .................................................................................................... 3
ILUSTRAÇÃO 5 – PREDICADO QUE CRIA UMA LISTA DE LISTAS COM DIMENSÃO VARIÁVEL .............................. 5
ILUSTRAÇÃO 6 – PREDICADO QUE GERA OS ‘BURACOS NEGROS’.................................................................... 6
ILUSTRAÇÃO 7 – DESCRIÇÃO DOS VALORES PARA AS POSIÇÕES ..................................................................... 6
ILUSTRAÇÃO 8 – DIAGRAMA DE UMA JOGADA .............................................................................................. 7
ILUSTRAÇÃO 9 – PREDICADO INSERE_PECA .................................................................................................. 7
ILUSTRAÇÃO 10 – VALIDAÇÃO DA DIMENSÃO DO TABULEIRO ....................................................................... 8
ILUSTRAÇÃO 11 - VISUALIZAÇÃO DO TABULEIRO ......................................................................................... 9
ILUSTRAÇÃO 12 –VALIDAÇÃO DAS COORDENADAS....................................................................................... 9
ILUSTRAÇÃO 13 – E XECUÇÃO DE UMA JOGADA .......................................................................................... 10
ILUSTRAÇÃO 14 – FIM DO JOGO ................................................................................................................. 11

-I-
RESUMO E INTRODUÇÃ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 trabalho 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 tamanho 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.

-1-
DESCRIÇÃO DO PROBLEMA

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. Cada 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.

-2-
DESCRIÇÃO DO PROBLEMA

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 cotar 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:

Nº Pedras Pontos Ilustração 3 – Pontuação original


1 0
2 0
Nº Pedras Pontos
3 3
8 246
4 10
9 501
5 25
10 1012
6 56
11 2035
7 119
12 4082
13 8177
Ilustração 4 – Pontuação adicional 14 16368

-3-
DESCRIÇÃO DO PROBLEMA

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


Pi  2  Pi 1  S i i  3 Equação 1
onde:
Pi – Pontuação a obter;
Pi-1 – Pontuação a obter;
Si – 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.

-4-
REPRESENTAÇÃO DO ESTADO DO JOGO

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%*Dim2. 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.

-5-
REPRESENTAÇÃO DO ESTADO DO JOGO

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 representa essa associa-
ção:

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’
Ilustração 7 – Descrição dos valores para as posições

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

-6-
REPRESENTAÇÃO DO ESTADO DO JOGO
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.

Valida as coorde-
nadas

Pede a posição erro Verifica a disponi-


para a jogada bilidade da posição

Insere pedra no
tabuleiro

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

-7-
VISUALIZAÇÃ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.

Ilustração 10 – Validação da dimensão do tabuleiro

-8-
VISUALIZAÇÃO DO TABULEIRO

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

Ilustração 12 –Validação das coorde-


nadas

-9-
VISUALIZAÇÃO DO TABULEIRO

Ilustração 13 – Execução de uma jogada

- 10 -
VISUALIZAÇÃO DO TABULEIRO

Ilustração 14 – Fim do jogo

- 11 -
CONCLUSÃ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.

- 12 -
REFERÊNCIAS BIBLIOGRÁ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).

- 13 -
ANEXOS

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%% 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).

-i-
ANEXOS

% 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 %

- ii -
ANEXOS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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).

- iii -
ANEXOS
% 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).

mostra_linha([]).

- iv -
ANEXOS
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).

-v-