Relatório de Avaliação Intercalar do 1º Trabalho Prático da Disciplina de

Programação em Lógica

Spider 4 em Linha
(Trabalho 12)

Grupo 55 (Turma 5)
80509011 – ei08011@fe.up.pt – André Daniel Moreira Pinto Riboira
70509052 – ei07052@fe.up.pt – João Guilherme Ribeiro de Brito

Página 1 de 10
Resumo
Este trabalho pretende implementar o jogo “Spider 4 em Linha” em linguagem Prolog,
possibilitando jogos com dois adversários humanos, com um adversário humano e um
computador ou com dois adversários computadores.
Para mais informações relativamente às regras deste jogo por favor consulte o capítulo
“Descrição do Problema”.

Introdução
O objectivo deste trabalho é adquirir conhecimentos de programação lógica utilizando a
linguagem de programação Prolog, bem como utilizar conceitos lógicos para resolução de
problemas associados a regras e jogadas de jogos de tabuleiro.
A escolha deste jogo deve-se sobretudo à simplicidade das regras, que permite a rápida
compreensão por qualquer jogador que nunca o tenha jogado, embora possibilite
estratégias de jogo interessantes.
Este jogo tem algumas particularidades que o distinguem da maioria dos restantes jogos
de tabuleiro, nomeadamente o facto das peças serem atraídas para as extremidades do
tabuleiro, tal como se estivessem sujeitas a forças magnéticas.
A maior motivação para a escolha deste jogo foi sem dúvida o facto de derivar de um jogo
extremamente simples (o 4 em Linha) mas ter o desafio da lei da gravidade a que está
sujeito o jogo original ser nesta versão substituída por forças em 4 direcções distintas, o
que possibilita jogadas e estratégias que surpreendem o jogador menos atento.

Descrição do Problema
Este jogo é composto por um tabuleiro de 64 casas (8 casas por 8 casas), e poderá ser
jogado por dois jogadores. O funcionamento é muito semelhante ao “4 em Linha”
tradicional, mas com a diferença que os jogadores podem inserir peças a partir de
qualquer um dos lados do tabuleiro, o que vai alterar radicalmente a estratégia do jogo.

Página 2 de 10
Exemplo do tabuleiro na posição inicial:

T1 T2 T3 T4 T5 T6 T7 T8

E1 D1

E2 D2

E3 D3

E4 D4

E5 D5

E6 D6

E7 D7

E8 D8

F1 F2 F3 F4 F5 F6 F7 F8

As casas T1 a T8, F1 a F8, E1 a E8 e D1 a D8 representam as entradas a partir das quais

os jogadores podem inserir as suas peças. As casas T1 a T8 representam as entradas do
topo, as casas F1 a F8 representam as entradas do fundo, as casas E1 a E8 representam
as entradas da esquerda e, por fim, as entradas D1 a D8 representam as entradas da
direita. Estas casas apenas são representadas aqui para facilitar a compreensão do jogo,
pois não fazem parte das casas do jogo.

Objectivo do Jogo
O objectivo deste jogo, tal como do “4 em Linha” original, é conseguir um alinhamento de
4 peças da cor do jogador no tabuleiro. Esse alinhamento poderá ser horizontal, vertical
ou diagonal.

Desenvolvimento de uma partida

Os jogadores jogam à vez, e apenas uma jogada de cada vez. Em cada jogada podem
colocar uma peça no tabuleiro, a partir de qualquer uma das entradas laterais. As peças
de cada jogador possuem cores distintas. A peça colocada a partir de uma das entradas
do tabuleiro é atraída para o lado oposto da entrada, ocupando o lugar disponível o mais
afastado possível da entrada escolhida, não podendo ficar sobreposta a qualquer peça já
inserida no tabuleiro.

Página 3 de 10
Exemplo de uma jogada inicial do jogador com as peças brancas, inserindo a peça a partir da
entrada D4:

T1 T2 T3 T4 T5 T6 T7 T8

E1 D1

E2 D2

E3 D3

E4 D4

E5 D5

E6 D6

E7 D7

E8 D8

F1 F2 F3 F4 F5 F6 F7 F8

Exemplo de uma jogada do jogador com as peças pretas, inserindo a peça a partir da entrada T4:

T1 T2 T3 T4 T5 T6 T7 T8

E1 D1

E2 D2

E3 D3

E4 D4

E5 D5

E6 D6

E7 D7

E8 D8

F1 F2 F3 F4 F5 F6 F7 F8

Página 4 de 10
Exemplo de uma jogada do jogador com as peças brancas, inserindo a peça a partir da entrada F1:

T1 T2 T3 T4 T5 T6 T7 T8

E1 D1

E2 D2

E3 D3

E4 D4

E5 D5

E6 D6

E7 D7

E8 D8

F1 F2 F3 F4 F5 F6 F7 F8

Exemplo de uma jogada do jogador com as peças pretas, inserindo a peça a partir da entrada D4:

T1 T2 T3 T4 T5 T6 T7 T8

E1 D1

E2 D2

E3 D3

E4 D4

E5 D5

E6 D6

E7 D7

E8 D8

F1 F2 F3 F4 F5 F6 F7 F8

Vencedor da Partida
O jogador que conseguir colocar 4 peças seguidas da sua cor (válido em leituras
horizontais, verticais ou diagonais) ganha o jogo.

Página 5 de 10
Exemplo de uma jogada do jogador com as peças brancas, inserindo a peça a partir da entrada F1 e
ganhando o jogo:

T1 T2 T3 T4 T5 T6 T7 T8

E1 D1

E2 D2

E3 D3

E4 D4

E5 D5

E6 D6

E7 D7

E8 D8

F1 F2 F3 F4 F5 F6 F7 F8

Fim da Partida
A partida deste jogo chega ao final se for encontrado um vencedor, ou caso nenhum
jogador consiga esse objectivo e todas as casas do tabuleiro sejam preenchidas com
peças, o jogo acaba em empate.

Tempo de Duração de uma Partida

As partidas não possuem limite de tempo pré-definido, mas têm uma duração média entre
10 a 20 minutos.

Representação do Estado do Jogo

Sabendo que este jogo assenta num tabuleiro de 8 linhas e 8 colunas, estando as casas
de jogo organizadas ortogonalmente, optamos por representar o referido tabuleiro através
de uma lista de listas em que cada um dos elementos representa uma casa. Cada casa
poderá ter 3 estados: V de vazio, B de branca e P de preta, indicando respectivamente se
a casa está vazia, se possui uma peça branca ou uma peça preta.
Possível estado inicial:
estado = [ [ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ] ] .

Página 6 de 10
Possível estado intermédio:
estado = [ [ B, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ B, P, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, P, V, V, V, V ] ] .
Possível estado final:
estado = [ [ B, V, V, V, V, V, V, V ],
[ B, V, V, V, V, V, V, V ],
[ B, V, V, V, V, V, V, V ],
[ B, P, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, V, V, V, V, V ],
[ V, V, V, P, V, V, V, V ],
[ V, V, V, P, V, V, V, V ] ] .

Representação de um Movimento
Em cada jogada, o jogador apenas terá que indicar qual a entrada através da qual
pretende inserir a peça no tabuleiro. A representação deste movimento poderá ser
efectuada da seguinte forma:
inserir_peca(Jogador, Entrada, Posicao, Tabuleiro, NovoTabuleiro).

Nesta situação, o programa recebe o jogador, a entrada (T: topo, F: fundo, E: esquerda, D:
direita) e a posição da entrada (de 1 a 8). Recebe também o tabuleiro actual e guarda o
tabuleiro com o resultado em NovoTabuleiro.
Para efectuar uma jogada, iremos desenvolver diversos predicados de manipulação da
matriz, de forma a que o predicado da jogada seja um único para qualquer uma das
entradas do tabuleiro. Assim sendo, iremos desenvolver um predicado que troque as
colunas de uma matriz pelas suas linhas (de forma a tratarmos as entradas do topo e do
fundo), um que inverta uma linha (de forma a tratarmos as entradas do topo e da
esquerda), e predicados para efectuar a jogada (retornando uma matriz com o resultado).
O procedimento a seguir será o seguinte:
● Verifica se a entrada é a de topo ou do fundo. Se for, troca as colunas pelas linhas
da matriz.
● Obtém a linha correspondente à jogada.
● Verifica se a entrada é a de topo ou da esquerda. Se for, inverte a linha obtida.
● Efectua a jogada: procura a primeira ocorrência de “v” (vazio) e substitui-a pela
letra associada ao jogador.
● Gera a matriz com a nova linha gerada pela jogada e retorna-a como resultado
(novo tabuleiro).

Página 7 de 10
Visualização do Tabuleiro
O tabuleiro do jogo será representado em modo de texto, sobre forma de uma matriz de
caracteres. Para uma melhor visualização será utilizado o caracter “O” para representar
as peças brancas e o caracter “X” para as peças pretas. Além do tabuleiro de jogo serão
também representadas as entradas do tabuleiro. Assim sendo, um exemplo de uma
possível representação de um tabuleiro seria o seguinte:
T1 T2 T3 T4 T5 T6 T7 T8
+---+---+---+---+---+---+---+---+
E1 | O | | | | | | | | D1
+---+---+---+---+---+---+---+---+
E2 | | | | | | | | | D2
+---+---+---+---+---+---+---+---+
E3 | | | | | | | | | D3
+---+---+---+---+---+---+---+---+
E4 | O | X | | | | | | | D4
+---+---+---+---+---+---+---+---+
E5 | | | | | | | | | D5
+---+---+---+---+---+---+---+---+
E6 | | | | | | | | | D6
+---+---+---+---+---+---+---+---+
E7 | | | | | | | | | D7
+---+---+---+---+---+---+---+---+
E8 | | | | X | | | | | D8
+---+---+---+---+---+---+---+---+
F1 F2 F3 F4 F5 F6 F7 F8

Conclusões e Perspectivas de Desenvolvimento

Após a análise do trabalho realizado, podemos concluir que atingimos parte dos
objectivos a que nos propusemos. A implementação do jogo “Spider 4 em Linha” poderá
ser realizada com sucesso através da utilização da linguagem Prolog, e será certamente
possível jogar o mesmo através do interface criado em ambiente de texto.
Apesar de ainda ser uma versão preliminar, já temos noção dos algoritmos que irão ser
utilizados, bem como a interface final do jogo. Neste momento já é possível representar o
tabuleiro de jogo e realizar algumas operações sobre o mesmo, que irá possibilitar a
realização de jogadas entre dois humanos. Assim sendo, estimamos que já atingimos o
marco dos 25% do trabalho realizado considerado como necessário para que o jogo atinja
a versão final.
Falta ainda implementar um procedimento para gerar a matriz com o resultado da jogada,
que irá consistir na substituição na matriz recebida da linha gerada pela jogada. Após este
desenvolvimento será possível realizar jogos entre dois humanos. Falta também
implementar os processos que irão permitir que um humano jogue contra o computador,
ou que dois computadores joguem entre si.

Página 8 de 10
Bibliografia
Para realização do trabalho:
[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://www.fe.up.pt/~eol/LP/0809 (Consultado em
Outubro de 2008).
[2] Vários Autores, SICStus Prolog User’s Manual, Release 3.10.1, Abril de 2003.
Para a realização do relatório:
[3] Vários Autores, BrainKing – Regras do Jogo (Spider 4 em Linha), disponível online em
http://brainking.com/pt/GameRules?tp=16 (Consultado em Outubro de 2008)

Página 9 de 10
Anexos
Representação do Estado Inicial
tabuleiro( [ [ v, v, v, v, v, v, v, v ],
[ v, v, v, v, v, v, v, v ],
[ v, v, v, v, v, v, v, v ],
[ v, v, v, v, v, v, v, v ],
[ v, v, v, v, v, v, v, v ],
[ v, v, v, v, v, v, v, v ],
[ v, v, v, v, v, v, v, v ],
[ v, v, v, v, v, v, v, v ] ] ).

Cabeçalhos de alguns Predicados de Jogada

% joga_linha( linha, resultado, jogador ).
joga_linha( [v|A], [J|A], J ).
joga_linha( [X|A], [X|B], J ):- joga_linha( A, B, J ).

% inverte_linha( linha, resultado ).

inverte_linha( A, B ):- rev( A, [], B ).
rev( [X|A], B, R ):- rev( A, [X|B], R ).
rev( [], R, R ).

% --- obtém uma determinada linha de uma matriz

%linha_tabuleiro( matriz, resultado, numero_linha ).
linha_tabuleiro([A|_], A, 1).
linha_tabuleiro([_|A], B, N):- N1 is N-1, linha_tabuleiro(A, B, N1).

% --- troca as linhas pelas colunas da matriz “tabuleiro”

espelha_matriz:- tabuleiro(A), roda_matriz(A,R), write(R).

% roda_matriz(matriz, resultado)
roda_matriz([HE|T],R):- A=HE, linhas(T,B,TB), linhas(TB,C,TC), linhas(TC,D,TD),
linhas(TD,E,TE), linhas(TE,F,TF), linhas(TF,G,TG),
linhas(TG,H,_), colunas(A,B,C,D,E,F,G,H,R).

linhas([H|T],H,T).

colunas([],[],[],[],[],[],[],[],[]).
colunas([HA|TA],[HB|TB],[HC|TC],[HD|TD],[HE|TE],[HF|TF],[HG|TG],[HH|TH],[H|T]):-
colunas(TA,TB,TC,TD,TE,TF,TG,TH,T),H=[HA,HB,HC,HD,HE,HF,HG,HH].

Predicado que Permite a Visualização Simples do Tabuleiro (Modo de Texto)

linha( [] ).
linha( [v|T2] ) :- print('| '), linha(T2).
linha( [T1|T2] ) :- print('| ') , print(T1), print(' '), linha(T2).

imprime_tabuleiro( T ):- print(' T1 T2 T3 T4 T5 T6 T7 T8\n'),

matriz(T, 0).

matriz( [T1|T2], Contador ) :- Contador2 is Contador + 1,

print(' +---+---+---+---+---+---+---+---+\n'),
print('E'), print(Contador2), print(' '),
linha(T1), print('| '), print('D'),
print(Contador2), print('\n'),
matriz(T2, Contador2).

matriz( [] , _) :- print(' +---+---+---+---+---+---+---+---+\n'),

print(' F1 F2 F3 F4 F5 F6 F7 F8\n').

Página 10 de 10