Pente. Autores André Santos Cardoso João Nuno Ferrreira Batista Ricardo Simão Garcez

Transcrição

1 Aplicação em Prolog para um Jogo de Tabuleiro: Pente Autores André Santos Cardoso João Nuno Ferrreira Batista Ricardo Simão Garcez Faculdade de Engenharia da Universidade do Porto Departamento de Engenharia Informática 6 de Outubro de 2008

2 Aplicação em Prolog para um Jogo de Tabuleiro: Pente Autores André Santos Cardoso João Nuno Ferrreira Batista Ricardo Simão Garcez Trabalho realizado no âmbito da disciplina de Programação em Lógica, do 1 o semestre do 3 o ano, do Mestrado Integrado em Eng. Informática e Computação, da Faculdade de Engenharia da Universidade do Porto Docentes Daniel Moura daniel.c.moura@gmail.com Eugénio da Costa Oliveira eco@fe.up.pt Luís Paulo Reis lpreis@fe.up.pt Faculdade de Engenharia da Universidade do Porto Departamento de Engenharia Informática 6 de Outubro de 2008

3 Resumo Este trabalho visa a implementação do jogo de tabuleiro Pente em linguagem Prolog. O Pente é um jogo para 2 pessoas, com peças circulares cuja cor corresponde a cada um dos jogadores, que se colocam nas intersecções de uma matriz de 19X19, sendo as linhas horizontais do tabuleiro numeradas de 1 a 19 e as linhas verticais assinaladas por letras de A a T. O objectivo do jogo é formar linhas com 5 peças da mesma cor, em qualquer direcção possível, sendo que o primeiro jogador a conseguir fazê-lo ganha o jogo. A implementação final deverá permitir os seguintes modos de jogo: humano humano; humano computador; computador computador; Este relatório apresentará a primeira fase do projecto, descrevendo a representação do estado do jogo, como se processa uma jogada e como se visualiza o tabuleiro em modo de texto. Serão apresentados os predicados em Prolog que permitem a implementação do estado do jogo, visualização do tabuleiro e efectuar jogadas, assim como alguns algoritmos considerados relevantes neste contexto. Palavras-chave: Prolog, lógica, jogo, tabuleiro, Pente; iii

4 Conteúdo Resumo Conteúdo Lista de Figuras Listagens de Código iii iv v vi 1 Introdução 1 2 Descrição do Problema Background histórico do jogo Pente Regras do jogo de tabuleiro Pente Nomenclatura de Algumas Formações Restrições aplicadas para equilibrar o jogo entre brancas e pretas Captura das peças do adversário Implementação do jogo em Prolog Representação do tabuleiro/estado do jogo Representação de uma Jogada Visualização do Tabuleiro Conclusão e Perspectivas de Desenvolvimento 11 Referências 12 A Código Implementado em Prolog i B Exemplo de Funcionamento vi iv

5 Lista de Figuras 2.1 Tabuleiro de pente, evidenciando as peças do jogo Representação de um tabuleiro de Pente Primeira jogada das Brancas Captura Antes da jogada das Pretas Depois da jogada das Pretas as peças são capturadas Estado final Captura Múltipla Antes da jogada das Pretas Depois da jogada das Pretas as peças são capturadas Estado final B.1 Apresentação do tabuleiro vi B.2 Jogada das Brancas, Risco de Captura vii B.3 Captura viii B.4 Jogada Pretas ix B.5 Jogada Sobreposta x v

6 Listagens de Código 3.1 Representação do Tabuleiro Representação do Tabuleiro, após algumas jogadas Predicados para as Jogadas Predicados para Visualização do Tabuleiro A.1 Código Prolog para o Pente i vi

7

8 Capítulo 1 Introdução A implementação de um jogo de tabuleiro, que não implique elementos de sorte, serve como forma de aquisição de conhecimentos na área da programação em lógica onde, fazendo uso da linguagem de programação Prolog, seremos introduzidos a um novo paradigma da programação que, fazendo uso das regras de lógica, será aplicado à resolução de problemas facilitando a implementação correcta da mecânica de jogo e, numa fase mais avançada, uma inteligência artificial que se oponha a um jogador. Importa também referir que, até este momento, utilizamos quase exclusivamente linguagens de programação procedimental, sendo que este trabalho servirá também como uma primeira abordagem séria à programação em lógica usando Prolog. O grupo de trabalho desenvolveu o trabalho aqui apresentado em vários ambientes, nomeadamente diferentes sistemas operativos e interpretadores de prolog: Windows/Linux e Swi- Prolog/Sicstus Prolog. O objectivo do trabalho é desenvolver um módulo computacional em Prolog capaz de concretizar o jogo de tabuleiro Pente. Este é um jogo para 2 pessoas, no qual o objectivo é formar linhas de cinco peças consecutivas numa qualquer direcção. Para tal, é necessário desenvolver métodos de representar o estado do jogo em Prolog, assim como algoritmos que permitam a visualização do tabuleiro e toda a interacção com os jogadores. Além disto, será necessário implementar técnicas que permitam a inclusão de uma certa inteligência computacional de forma a que a aplicação permita modos de jogo humano computador e computador computador. Para este efeito, espera-se ainda incluir alguns algoritmos da área da Teoria dos Jogos como, por exemplo, MiniMax. Nesta primeira fase, interessa principalmente definir qual a representação mais adequada para o estado do jogo em Prolog, implementar o predicado que permita a visualização correcta do tabuleiro e os cabeçalhos dos predicados Prolog que permitam efectuar uma jogada. As próximas secções deste documento apresentam: Alguma história do jogo de tabuleiro Pente; As regras do jogo; Representação do estado do jogo em Prolog; Representação de uma jogada em Prolog; Visualização do tabuleiro e código Prolog para o efectuar; Conclusões acerca do trabalho efectuado sob um ponto de vista crítico; Todo o código escrito até ao momento assim como exemplos do módulo a funcionar. 1

9 Capítulo 2 Descrição do Problema O projecto baseia-se na implementação do jogo Pente para computador, utilizando Prolog como linguagem de programação. Este é um jogo de tabuleiro para duas pessoas, cujo objectivo é colocar as peças do jogo nas intersecções de uma matriz de 19 x 19 de forma a formar linhas de 5 peças consecutivas em qualquer direcção: horizontal, diagonal ou vertical. 2.1 Background histórico do jogo Pente O Pente foi criado em 1987 por Gary Gabrel. Diz-se que Gary inventou o jogo durante o seu trabalho como lavador de pratos numa pizzaria chamada The Hideaway em Stillwater, Oklahoma. Foi criado como uma simplificação do jogo Japonês ninuki-renju, uma variante de gomoku jogado num tabuleiro de Go de 19 x 19 intersecções, com peças brancas e pretas. O objectivo do jogo é formar linhas de 5 peças da mesma cor consecutivas, daí o seu nome Pente que significa em Grego cinco (5). A partir do jogo original, Rollie Tesh o então campeão de Pente, propôs uma mudança de regras para equilibrar o jogo ele afirmava que as brancas podiam sempre ganhar com um conjunto de jogadas apropriadas surgindo então uma variação de Pente chamada Keryo- Pente. A companhia Hasbro era quem detinha o direitos do jogo Pente. A Hasbro deixou de distribuir este jogo de tabuleiro em 1993, licenciando mais tarde o jogo à Winning Moves que trouxe de novo o jogo às lojas em 2004 [1]. 2.2 Regras do jogo de tabuleiro Pente Neste jogo existem dois tipos de peças brancas e pretas correspondendo a dois jogadores (figura 2.1). Cada jogador tem a sua vez após uma (1) jogada do adversário. Define-se jogada como sendo a colocação da peça do jogador correspondente numa intersecção vazia. O fim do jogo atinge-se no momento em que um jogador consegue formar uma linha de 5 peças suas consecutivas numa determinada direcção ou quando consegue capturar 10 peças do adversário. Esta situação corresponde à vitória do jogador. Por outro lado, também existe a possibilidade do jogo acabar em empate, quando todas as intersecções do tabuleiro se encontram usadas e nenhuma das situações anteriores se verificam. No entanto, esta é uma situação rara devido às características do jogo relativas à captura de peças. 2

10 Figura 2.1: Tabuleiro de pente, evidenciando as peças do jogo Figura 2.2: Representação de um tabuleiro de Pente O tabuleiro do jogo é como um tabuleiro de damas, apenas maior, com 19 x 19 intersecções(figura 2.2), em que as peças são jogadas não nos quadrados mas nas intersecções. 2.3 Nomenclatura de Algumas Formações Existem algumas formações/disposições de peças que são perigosas para o adversário e que podem levar ao fim do jogo. Estas têm nomes específicos: Tessera É uma linha com quatro peças, com pelo menos uma ponta aberta. Existem duas situações a analisar neste momento: se ambas as pontas da tessera estiverem abertas, então o jogador que formou a tessera irá ganhar na jogada seguinte, a não ser que o jogador adversário consiga capturar as peças do primeiro que formam a tessera. 3

11 Figura 2.3: Brancas Primeira jogada das se apenas uma das pontas estiver aberta, então o adversário tem oportunidade de bloquear a tessera, evitando assim a derrota. Tria Corresponde a uma linha com três peças de uma mesma cor consecutivas, com as pontas abertas. Esta situação está apenas a duas jogadas do Pente e da vitória do jogador. Se o jogador adversário não bloquear uma das pontas, na jogada a seguir forma-se uma tessera não bloqueável e o jogo encontra-se ganho. Pente Corresponde a uma situação de vitória, em que um jogador consegue formar uma linha com cinco das suas peças seguidas. É habitual o jogador que consegue atingir estas formações alertar o jogador adversário da situação[4]. 2.4 Restrições aplicadas para equilibrar o jogo entre brancas e pretas Como o jogador que inicia o jogo poderá ter maior probabilidade de ganhar o jogo, existem várias restrições aplicadas ao jogo de modo a equilibrar o jogo entre brancas e pretas. São as seguintes: As brancas iniciam o jogo. As brancas são obrigadas a iniciar o jogo no centro do tabuleiro 1 (figura 2.3). A segunda jogada das brancas é feita obrigatoriamente a pelo menos três intersecções de distância do centro do tabuleiro, onde a primeira jogada foi feita; Não existem restrições quanto às jogadas das peças pretas. 2.5 Captura das peças do adversário O Pente também inclui a possibilidade da captura de pares de peças adversárias. Para poder capturar peças adversárias, é necessário colocar as suas próprias peças nas "pontas"de uma 1 Na realidade, as regras originais publicadas pela Hasbro dizem que se deve tirar à sorte para ver qual o jogador que começa o jogo e este deve iniciar com uma jogada no centro do tabuleiro [2]. No entanto, este projecto não se aplica a jogos com qualquer componente de sorte, sendo esta regra posta de parte neste implementação. 4

12 2.4.1: Antes da jogada das Pretas 2.4.2: Depois da jogada das Pretas as peças são capturadas 2.4.3: Estado final Figura 2.4: Captura linha consecutiva de peças adversárias. A captura apenas se verifica quando o jogador consegue encurralar duas, e apenas duas, peças adversárias. É impossível capturar três peças adversárias, por exemplo. O processo de captura está evidenciado nas figuras 2.4.1, e Existe também a possibilidade de uma jogador fazer uma captura múltipla, encurralando mais do que um par de peças adversárias (nunca vários pares de peças consecutivas), por exemplo, colocando uma peça sua de modo a formar um vértice comum a duas linhas de peças adversárias, tal como está evidenciado nas figuras 2.5.1, e As peças apenas podem ser capturadas por "iniciativa"do adversário, ou seja, apenas são capturadas após uma jogada do jogador que captura. Portanto, se um jogador colocar uma peça numa posição tal que satisfaça uma situação de captura das suas próprias peças, estas não podem ser capturadas pelo adversário. 5

13 2.5.1: Antes da jogada das Pretas 2.5.2: Depois da jogada das Pretas as peças são capturadas 2.5.3: Estado final Figura 2.5: Captura Múltipla 6

14 Capítulo 3 Implementação do jogo em Prolog Aqui se apresentam algumas estruturas em prolog escolhidas para a implementação do jogo em Prolog, assim como algumas descrições dos algoritmos que irão ser utilizados para implementar as jogadas. 3.1 Representação do tabuleiro/estado do jogo Este jogo desenrola-se num tabuleiro quadrado de 19 X 19, portanto optou-se por uma representação em Prolog através de uma lista de listas. Listagem 3.1: Representação do Tabuleiro t a b u l e i r o _ i n i c i a l ( [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], ] ). A representação em 3.1 mostra o estado inicial do tabuleiro, que corresponde também à jogada inicial das peças brancas, representadas pelo número 1. Esta jogada das brancas é obrigatória, portanto optou-se por incluí-la automaticamente no estado inicial dando a vez imediatamente ao jogador preto. Por exemplo, se existe nas coordenadas (1, 1) uma peça branca e em (2, 2) uma peça preta, a estrutura que alberga a representação do tabuleiro teria os dados mostrados no código

15 Listagem 3.2: Representação do Tabuleiro, após algumas jogadas. t a b u l e i r o _ i n i c i a l ( [ [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], 4 [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], 8 12 [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], ] ). 3.2 Representação de uma Jogada No Pente o jogador pode efectuar uma jogada em qualquer posição do tabuleiro desde que esta se encontre vazia (com excepção da segunda jogada das brancas), assim sendo, uma jogada pode ser representada apenas pelo jogador que a efectua, respectivamente um 0 ou e pelas coordenadas de colocação da peça. O processo de realização de uma jogada envolve dois passos distintos: um de validação e um subsequente que faz definitivamente a jogada, caso seja válida. O primeiro passo faz recurso ao predicado valida_jogada(x,y,tabuleiro,incremento), onde X e Y são as coordenadas do local onde se pretende fazer a jogada, Tabuleiro é o objecto onde se guardam as informações do tabuleiro e o Incremento é uma variável auxiliar de modo a se verificar se se atingiu o elemento pretendido da lista. Esta função percorre a lista de listas Tabuleiro e verifica se o elemento que está no local em que se pretende jogar (X e Y) é um 0, ou seja, se a intersecção estiver vazia, e não um 1 ou -1. O segundo passo recorre ao predicado joga(x, Y, Tabuleiro, Peca, Resto, Incremento) para colocar a peça no local pretendido, sendo a única informação adicional necessária, além da utilizada no predicado anterior, a peça, que representa a qual dos jogadores pertence a jogada (ou -1 ou 1). Ambos predicados são chamados pelo predicado jogar_jogador que apenas irá permitir que uma jogada seja feita se for indicada uma jogada válida. Este e outros predicados podem ser vistos no código 3.3. Para já, apenas existe este tipo de verificação, onde se decide se uma jogada é válida em determinada posição. Não se encontra implementado qualquer outro tipo de verificação como, por exemplo, o fim do jogo ou captura de peças. % I n i c i a o Jogo Listagem 3.3: Predicados para as Jogadas 8

16 s t a r t : t a b u l e i r o _ i n i c i a l ( T a b u l e i r o ), % I n i c i a o t a b u l e i r o 4 j o g a r ( T a b u l e i r o, 1,0,0). % Comeca a j o g a r %j o g a r (+ T a b u l e i r o,+ Jogador,+ ContagemJogador1,+ ContagemJogador2 ) 8 % T a b u l e i r o : % Jogador : % ContagemJogador1 : % ContagemJogador2 : 12 j o g a r ( T a b u l e i r o, Jogador, ContagemJogador1, ContagemJogador2 ) : ContagemJogador1 >= 10, % V e r i f i c a se o j o g a d o r 1 ganhou 16 w r i t e ( 'Ganhou jogador 1!!! ' ),! ; ContagemJogador2 >= 10, % V e r i f i c a se o j o g a d o r 2 ganhou w r i t e ( 'Ganhou jogador 2!!! ' ),! 20 ; % Faz j o g a d a s ( d e s e n h a _ t a b u l e i r o ( T a b u l e i r o ), 24 j o g a r _ j o g a d o r ( T a b u l e i r o, T a b u l e i r o F i n a l, Jogador, X,Y), O u t r o _ j o g a d o r i s Jogador, j o g a r ( T a b u l e i r o F i n a l, O u t r o _ j o g a d o r, ContagemJogador1, ContagemJogador2 ) ). 28 j o g a r _ j o g a d o r ( T a b u l e i r o, T a b u l e i r o F i n a l, Jogador, X, Y) : i f t h e n e l s e ( l e r _ j o g a d a (X, Y, Jogador, T a b u l e i r o ), 32 w r i t e ( 'Jogada valida!' ), ( w r i t e ( 'Jogada invalida!' ), nl, j o g a r _ j o g a d o r ( T a b u l e i r o, T a b u l e i r o F i n a l, Jogador, X, Y) ) ), J o g a d o r A d v e r s a r i o i s Jogador, % acho que i s t o e s t a a mais j o g a (X, Y, T a b u l e i r o, Jogador, T a b u l e i r o F i n a l, 1 ). l e r _ j o g a d a (X, Y, Jogador, T a b u l e i r o ) : 40 w r i t e ( 'Jogador ' ), w r i t e ( J o g a d o r ), nl, w r i t e ( 'X:' ), read (X), nl, 44 w r i t e ( 'Y:' ), read (Y), j o g a d a _ v a l i d a (X, Y, T a b u l e i r o, 1 ). 3.3 Visualização do Tabuleiro Para a visualização do tabuleiro, sendo este uma lista de listas em Prolog, utiliza-se um algoritmo que itera sobre cada uma das listas, chamando uma outra função que itera sobre este lista e, para cada elemento da lista, utiliza um predicada para o imprimir. Temos portanto três níveis: iterar sobre o tabuleiro, iterar sobre uma lista do tabuleiro e imprimir um elemento do tabuleiro. Para desenvolver estes predicados, o grupo baseou-se na implementação do jogo de damas disponível na página da disciplina [7]. 9

17 Os predicados que efectuam a escrita do tabuleiro em modo de texto podem ser vistos na listagem de código 3.4. Listagem 3.4: Predicados para Visualização do Tabuleiro d e s e n h a _ t a b u l e i r o ( T a b u l e i r o ) : nl, w r i t e ( ' A B C D E F G H I J L M N O P Q R S T' ), nl, ( m o s t r a _ l i n h a s ( 1, T a b u l e i r o ) ), 4 w r i t e ( ' A B C D E F G H I J L M N O P Q R S T' ), nl,!. %apenas mostra uma l i n h a com mais de 2 e l e m e n t o s % m o s t r a _ l i n h a s ( _, [ ] ). m o s t r a _ l i n h a s (N, [ Linha Resto ] ) : (N>9; N<10, w r i t e ( ' ' ) ), 12 w r i t e (N), w r i t e ( ' ' ), m o s t r a _ l i n h a ( Linha ), w r i t e ( ' ' ), w r i t e (N), nl, N2 i s N+1, m o s t r a _ l i n h a s ( N2, Resto ). 16 m o s t r a _ l i n h a ( [ ] ). m o s t r a _ l i n h a ( [ Elemento Resto ] ) : 20 t r a d u z ( Elemento ), m o s t r a _ l i n h a ( Resto ). 24 t r a d u z ( 0 ) : w r i t e ( '+ ' ). t r a d u z ( 1 ) : 28 w r i t e ( '0 ' ). t r a d u z ( 1): w r i t e ( '@ ' ). 10

18 Capítulo 4 Conclusão e Perspectivas de Desenvolvimento Cremos que os objectivos propostos para esta primeira entrega se encontram atingidos: a representação do estado do jogo encontra-se definida, a visualização do tabuleiro em modo de texto está também concluída, além dos predicados para a colocação de peças pelo jogador que estão também implementados. Além do referido acima, já existem também predicados que verificam se uma jogada pode ou não ser feita consoante a sua posição, ou seja, se a jogada não corresponde a uma casa do tabuleiro já ocupada. O jogo, tal como está, não inclui ainda nenhum tipo de inteligência, permitindo apenas o jogo entre humanos. Algo que ainda falta implementar são os predicados para verificação de fim do jogo. Portanto, o que existe neste momento corresponde a uma aplicação que mostra um tabuleiro e permite colocar peças em posições vazias do tabuleiro, não incluindo nenhum tipo de verificação de fim do jogo. Além disto, iremos também substituir o mecanismo de inserção de coordenadas, de modo a ser coerente com a representação do tabuleiro: inteiros para as linhas e letras maiúsculas para as colunas. Até ao momento de entrega deste relatório, esta situação não foi corrigida. Perante o trabalho efectuado, estimamos que foram atingidos cerca de 20% do trabalho necessário para o finalizar. Os objectivos mais próximos que são necessários atingir e nos quais o grupo centra a sua atenção de momento são a implementação dos predicados para verificação do fim do jogo e para verificar se existe ou não uma situação de captura de peças. 11

19 Referências [1] Board game encyclopedia: Pente. Pente.htm. Breves notas históricas acerca do Pente. Consultado em Outubro de [2] Pente, the classic game of skill. PDF, Regras originais do Pente. Consultado em Outubro de [3] Pente Descrição do jogo Pente. Consultado em Setembro de [4] Pente. Setembro Desrição do jogo Pente. Consultado em Setembro de [5] Patrick Blackburn, Johan Bos, and Kristina Striegnitz. Learn prolog now! coli.uni-saarland.de/~kris/learn-prolog-now/lpnpage.php?pageid=online, Tutorial online de Prolog. Consultado em Setembro de [6] Faculdade de Engenharia da Universidade do Porto. TRABALHOS PRÁTICOS DA DIS- CIPLINA DE PROGRAMAÇÃO EM LÓGICA, LP/0809/documents/Trabalhos/Trabalhos2008_09_PL.pdf Descrição dos trabalhos da disciplina. Consultado em Setembro de [7] Luis Paulo Reis. Programação em lógica 2008/ LP/0809/, Página da disciplina de Programação em Lógica. Materiais Diversos. 12

20 Apêndice A Código Implementado em Prolog Aqui se lista todo o código escrito, até ao momento, para a implementação do jogo Pente. Listagem A.1: Código Prolog para o Pente %Devido a problemas com o LATEX, por f a v o r, nao i n c l u i r c o m e n t a r i o s com 4 %a c e n t o s ou o u t r o s c a r a c t e r e s e s p e c i a i s n e s t e f i c h e i r o! %%%%%%%%%%%%%%%%%%%%%% TABULEIRO %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 8 % % 12 %t a b u l e i r o de 19 x19 %os e l e m e n t o s da l i s t a r e p r e s e n t a m i n t e r s e c c o e s ( e a melhor maneira?) %a p r i m e i r a jogada ( nao n e g o c i a v e l ) das brancas e no c e n t r o do t a b u l e i r o, 16 %p o r t a n t o, o e s t a d o i n i c i a l pode c o n t a r i m e d i a t a m e n t e com e s s a jogada % %o e s t a d o tambem tem de c o n t a r com o numero de c a p t u r a s para cada j o g a d o r %assim como um v a l o r booleano para se poder d e c i d i r se as brancas j a podem 20 %j o g a r d e n t r o do quadrado r e s t r i c t o na p r i m e i r a jogada t a b u l e i r o _ i n i c i a l ( [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], i

21 44 ). [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] ] %%%%%%%%%%%%%%%%%%%%%%%%%% VISUALIZACAO %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 48 d e s e n h a _ t a b u l e i r o ( T a b u l e i r o ) : nl, w r i t e ( ' A B C D E F G H I J L M N O P Q R S T' ), nl, 52 ( m o s t r a _ l i n h a s ( 1, T a b u l e i r o ) ), w r i t e ( ' A B C D E F G H I J L M N O P Q R S T' ), nl,!. 56 %apenas mostra uma l i n h a com mais de 2 e l e m e n t o s.... % m o s t r a _ l i n h a s ( _, [ ] ). m o s t r a _ l i n h a s (N, [ Linha Resto ] ) : 60 (N>9; N<10, w r i t e ( ' ' ) ), w r i t e (N), w r i t e ( ' ' ), m o s t r a _ l i n h a ( Linha ), w r i t e ( ' ' ), w r i t e (N), nl, N2 i s N+1, 64 m o s t r a _ l i n h a s ( N2, Resto ). m o s t r a _ l i n h a ( [ ] ). 68 m o s t r a _ l i n h a ( [ Elemento Resto ] ) : t r a d u z ( Elemento ), m o s t r a _ l i n h a ( Resto ). 72 t r a d u z ( 0 ) : w r i t e ( '+ ' ). 76 t r a d u z ( 1 ) : w r i t e ( '0 ' ). t r a d u z ( 1): 80 w r i t e ( '@ ' ). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% JOGAR %%%%%%%%%%%%%%%%%%%%%%%%%%%%% 84 % I n i c i a o Jogo s t a r t : t a b u l e i r o _ i n i c i a l ( T a b u l e i r o ), % I n i c i a o t a b u l e i r o 88 j o g a r ( T a b u l e i r o, 1,0,0). % Comeca a j o g a r %j o g a r (+ T a b u l e i r o,+ Jogador,+ ContagemJogador1,+ ContagemJogador2 ) 92 % T a b u l e i r o : % Jogador : % ContagemJogador1 : % ContagemJogador2 : 96 ii

22 j o g a r ( T a b u l e i r o, Jogador, ContagemJogador1, ContagemJogador2 ) : ContagemJogador1 >= 10, % V e r i f i c a se o j o g a d o r 1 ganhou 100 w r i t e ( 'Ganhou jogador 1!!! ' ),! ; ContagemJogador2 >= 10, % V e r i f i c a se o j o g a d o r 2 ganhou w r i t e ( 'Ganhou jogador 2!!! ' ),! 104 ; % Faz j o g a d a s ( d e s e n h a _ t a b u l e i r o ( T a b u l e i r o ), 108 j o g a r _ j o g a d o r ( T a b u l e i r o, T a b u l e i r o F i n a l, Jogador, X,Y), O u t r o _ j o g a d o r i s Jogador, j o g a r ( T a b u l e i r o F i n a l, O u t r o _ j o g a d o r, ContagemJogador1, ContagemJogador2 ) ). 112 j o g a r _ j o g a d o r ( T a b u l e i r o, T a b u l e i r o F i n a l, Jogador, X, Y) : i f t h e n e l s e ( l e r _ j o g a d a (X, Y, Jogador, T a b u l e i r o ), 116 w r i t e ( 'Jogada valida!' ), ( w r i t e ( 'Jogada invalida!' ), nl, j o g a r _ j o g a d o r ( T a b u l e i r o, T a b u l e i r o F i n a l, Jogador, X, Y) ) ), j o g a (X, Y, T a b u l e i r o, Jogador, T a b u l e i r o F i n a l, 1 ). 120 l e r _ j o g a d a (X, Y, Jogador, T a b u l e i r o ) : w r i t e ( 'Jogador ' ), 124 w r i t e ( J o g a d o r ), nl, w r i t e ( 'X:' ), read (X), nl, w r i t e ( 'Y:' ), 128 read (Y), j o g a d a _ v a l i d a (X, Y, T a b u l e i r o, 1 ) %%%%%%%%%%%%%%%%%%%%%%%%%% VALIDACAO %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 140 %j o g a d a _ v a l i d a ( X, Y, L i s t a s, I n c r e m e n t o ). %p e r c o r r e r o t a b u l e i r o a t e as coordenadas dadas para a jogada e v e r i f i c a r se o %e l e m e n t o n e s s a s coordenadas c o r r e s p o n d e a uma casa v a z i a j o g a d a _ v a l i d a ( _, _, [ ], _ ). %: w r i t e ( j o g a d a _ v a l i d a 0 ), n l. 144 % X d u p l i c a d o de modo a t e s t a r se os v a l o r e s da v a r i a v e i s sao i g u a i s j o g a d a _ v a l i d a (X, Y, [ Z Kr ],X) : %w r i t e ( j o g a d a _ v a l i d a 1 ), nl, 148 j o g a d a _ v a l i d a _ a l t (Y, Z, 1 ), X1 i s X+1, j o g a d a _ v a l i d a (X, Y, Kr, X1 ). 152 iii

23 j o g a d a _ v a l i d a (X, Y, [ K Kr ], I ) : %w r i t e ( j o g a d a _ v a l i d a 2 ), nl, 156 X\= I, I1 i s I +1, j o g a d a _ v a l i d a (X, Y, Kr, I1 ) %j o g a d a _ v a l i d a _ a l t ( X, L i s t a, I n c r e m e n t o ) j o g a d a _ v a l i d a _ a l t ( _, [ ], _ ). j o g a d a _ v a l i d a _ a l t (X, [ 0 Kr ],X) : X1 i s X+1, j o g a d a _ v a l i d a _ a l t (X, Kr, X1 ). j o g a d a _ v a l i d a _ a l t (X, [ K Kr ], I ) : I \=X, 172 I1 i s I +1, j o g a d a _ v a l i d a _ a l t (X, Kr, I1 ). 176 %joga ( X, Y, T a b u l e i r o, Peca, Resto, I n c r e m e n t o ). j o g a ( _, _, [ ], _, [ ], _ ). %: w r i t e ( joga0 ), n l. 180 j o g a (X, Y, [ K Kr ], Peca, [ Z J r ],X) : %w r i t e ( joga1 ), nl, j o g a _ a l t (Y, K, Peca, Z, 1 ), X1 i s X+1, 184 j o g a (X, Y, Kr, Peca, Jr, X1 ). j o g a (X, Y, [ K Kr ], Peca, [ K J r ], I ) : 188 %w r i t e ( joga2 ), nl, X\= I, I1 i s I +1, j o g a (X, Y, Kr, Peca, Jr, I1 ). 192 %j o g a _ a l t ( X, L i s t a, Peca, Resto, I n c r e m e n t o ) 196 j o g a _ a l t ( _, [ ], _, [ ], _ ). %: w r i t e ( j o g a _ a l t _ 0 ), n l. j o g a _ a l t (X, [ K Kr ], Peca, [ Peca J r ],X) : %w r i t e ( j o g a _ a l t _ 1 ), nl, 200 X1 i s X+1, j o g a _ a l t (X, Kr, Peca, Jr, X1 ). 204 j o g a _ a l t (X, [ K Kr ], Peca, [ K J r ], I ) : %w r i t e ( j o g a _ a l t _ 2 ), nl, I \=X, 208 I1 i s I +1, j o g a _ a l t (X, Kr, Peca, Jr, I1 ). iv

24 212 %%%%%%%%%%%%%%%%%%%%%%%%%%% Funcoes a u x i l i a r e s %%%%%%%%%%%%%%%%%%%% i f t h e n e l s e (X, Y, Z ) : X,!, Y. i f t h e n e l s e (X, Y, Z ) : Z. v

25 Apêndice B Exemplo de Funcionamento Este anexo apresenta alguns screenshots do interpretador Swi-Prolog a correr com a nossa implementação de Pente. Figura B.1: Depois de carregar o script apresentado no anexo A, inicia-se o jogo utilizando o predicado start/0. O tabuleiro é apresentado, já com a jogada inicial das brancas, e é perguntado ao jogador as coordenadas onde deseja jogar. vi

26 Figura B.2: Esta figura mostra-nos o tabuleiro já com algumas peças colocadas. Surge agora uma situação em que a próxima jogada das Pretas pode levar a uma situação de captura. vii

27 Figura B.3: Esta figura mostra-nos uma situação onde existe captura das peças brancas que estão encurraladas entre duas peças pretas. No entanto, este mecanismo de captura ainda não está implementado. viii

28 Figura B.4: Aqui, logo após o iniciar do jogo, as pretas jogam na casa (1, 1). Esta casa torna-se ocupada, portanto, é impossível jogar novamente nesta mesma casa. ix

29 Figura B.5: Após a jogada anterior, o jogador branco tenta jogar sobre a casa (1, 1). Esta figura mostra como a implementação do jogo detecta essa tentativa e não o permite, voltando a perguntar, ao mesmo jogar, uma nova casa para jogar. x