Академический Документы
Профессиональный Документы
Культура Документы
Elementos do Grupo:
1. Introdução:
Os principais objectivos do trabalho são os seguintes: familiarização com a linguagem
Prolog e os paradigmas de programação em lógica; desenvolvimento de um jogo muito
interessante e a possibilidade de conseguir trabalhar já um pouco com inteligência
artificial, que é algo muito motivador.
Efectuamos a escolha deste jogo pois achamos que, não tendo um elevado grau de
dificuldade, é desafiante tanto no âmbito do jogador humano como para o
programador que terá de desenvolver o programa de modo que o computador
“pense” e efectue a cada momento a melhor jogada possível.
Pensamos que tratando-se uma linguagem não procedimental, e nunca por nós
utilizada até ao momento, e o grau de “inteligência” que terá de ser fornecida ao
computador, nos trará motivação extra para a implementação deste jogo.
O jogo envolve dois jogadores que utilizam como única peça de jogo um cavalo de
Xadrez. Os movimentos dessa peça serão idênticos aos movimentos num tabuleiro de
Xadrez, isto é, cada cavalo movimenta-se em L, duas casas para direita e uma casa para
baixo, por exemplo. Os objectivos do jogo são, fundamentalmente, dois: acumular
mais pontos que o adversário e ir prejudicando ou limitando as movimentações
possíveis do adversário.
A primeira jogada consiste em colocar o cavalo branco numa das casas da primeira
linha, isto é, numa das casas entre A1 e J1. O número da casa escolhida ficará a ser a
pontuação inicial do cavalo branco. Se esse número for um número com dois
algarismos diferentes, por exemplo 35, então o número “trocado”, isto é, o número
que resulta da troca dos dois algarismos, neste caso o 53 é retirado do tabuleiro,
ficando essa casa inacessível a cada um dos dois cavalos durante o resto do jogo. Se o
número da casa escolhida pelo cavalo for um número “duplo”, isto é, com dois
algarismos iguais, por exemplo 44, então esse jogador terá a possibilidade de retirar, à
À primeira jogada do cavalo branco segue-se a primeira jogada do cavalo preto que irá
ser colocado numa das casas da última linha do tabuleiro, isto é, numa das casas entre
A10 e J10. O número da casa será a pontuação inicial do cavalo preto e a casa
correspondente ao número trocado será removida do tabuleiro e a posição ficará
inacessível durante o resto do jogo.
Após a colocação das duas peças, as jogadas seguintes serão efectuadas através do
típico saldo de cavalo, utilizado no Xadrez tradicional.
Obviamente, um cavalo nunca poderá saltar para uma casa que esteja inacessível nem
para a casa onde se encontre o cavalo adversário.
O tabuleiro inicial é construído da seguinte forma: é criada uma lista com os números
de 0 a 99 por ordem decrescente, em seguida essa lista é baralhada para que fiquem
distribuídos de forma aleatória.
1
Se porventura posteriormente entendermos ser mais fácil utilizar uma lista de listas, efectuaremos as
alterações necessárias.
2
Representamos a lista referida em modo de texto de forma que se visualize um tabuleiro 10X10.
Representamos as colunas por letras de A a J e as linhas com números de 1 a 10.
4. Representação de um movimento:
3
Estes predicados poderão sofrer alterações até ao final do trabalho, na medida em que se encontre ou
não, alternativas mais eficientes.
visualiza_estado(Tabuleiro):- escreve([],_).
write(' Tabuleiro de Jogo '),nl, escreve([A,B,C,D,E,F,G,H,I,J|Tail],N):-
write(' Luta de Cavalos '),nl, N =< 10,
write(' A B C D E F G H I J'),nl, M is N,
write(' ______________________________'),nl, write1(M),write(' |'),
escreve(Tabuleiro,1), write1(A),write('|'),
write(' ______________________________'),nl, write1(B),write('|'),
write(' A B C D E F G H I J'),nl. write1(C),write('|'),
write1(D),write('|'),
write1(E),write('|'),
write1(F),write('|'),
write1(G),write('|'),
write1(H),write('|'),
write1(I),write('|'),
write1(J),write('| '),write1(M),nl,
escreve(Tail,M+1).
lista(0,[]):-!. % cria a lista ordenada. write1(X):-
lista(N,[A|Tail]):- integer(X),
X >= 10, write(X).
A is N-1, write1(X):-
lista(A,Tail). integer(X),
%cria uma lista que representa o estado X < 10, write('0'),write(X).
inicial do tabuleiro write1(X):-
write(X).
cria_tabuleiro(Tab):-
lista(100,TabOrdenado),
shuffle(TabOrdenado,Tab).
Tabela 1: Predicados que permite visualizar o tabuleiro
As figuras 1 até 6 representam estados dos tabuleiros à medida que o jogo vai
decorrendo.
Analisando o trabalho efectuado até ao momento podemos concluir que está correr
como previsto e de uma forma satisfatória. Tratando-se de uma linguagem e de um
paradigma de programação para os quais não estavam habituados em utilizar, a sua
assimilação está a ser feita um pouco lentamente, no entanto, estamos optimistas que
conseguiremos alcançar os resultados desejados.
Bibliografia:
[Stobo, John] Problem Solving with Prolog, Taylor & Francis e-Library, 2005.
/*==========================================================================
=
===========================================================================
==*/
/*criar uma lista com os n.os interios de 0 a 99 e baralhar os elementos dessa lista*/
%lista(+N,-L).
%devolve no segundo argumento uma lista com N inteiros por ordem decrescente
lista(0,[]):-!.
lista(N,[A|Tail]):-
A is N-1,
lista(A,Tail).
cria_tabuleiro(Tab):-
lista(100,TabOrdenado),
shuffle(TabOrdenado,Tab),
visualiza_estado(Tab),!.
lista_de_listas([],[]):-!.
lista_de_listas([A,B,C,D,E,F,G,H,I,J|Tail1],[[A,B,C,D,E,F,G,H,I,J]|Tail2]):-
lista_de_listas(Tail1,Tail2).
http://ozone.wordpress.com/2006/02/22/little-prolog-challenge/ */
4
O código apresentado está ainda numa fase inicial, muitos dos predicados apresentados são apenas
para efectuar testes.
shuffle([], []).
shuffle(List, [Element|Rest]) :-
choose(List, Element),
shuffle(NewList, Rest).
choose([], []).
choose(List, Elt) :-
length(List, Length),
visualiza_estado(Tabuleiro):-
write(' A B C D E F G H I J'),nl,
write(' ______________________________'),nl,
escreve(Tabuleiro,1),
write(' ______________________________'),nl,
write(' A B C D E F G H I J'),nl.
escreve([],_).
escreve([A,B,C,D,E,F,G,H,I,J|Tail],N):-
N =< 10,
M is N,
write1(M),write(' |'),
write1(A),write('|'),
write1(B),write('|'),
write1(C),write('|'),
write1(D),write('|'),
write1(E),write('|'),
write1(G),write('|'),
write1(H),write('|'),
write1(I),write('|'),
write1(J),write('| '),write1(M),nl,
escreve(Tail,M+1).
write1(X):-
integer(X),
write1(X):-
integer(X),
write1(X):-
write(X).
%calcula o número Y com dois algarismos que é o número que resulta da troca dos
%vezes o valor de X.
troca(X,Y):-
DigitoDezenas is (X-DigitoUnidades)/10,
Y is DigitoDezenas+10*DigitoUnidades.
troca(X,Y):-
Y is X*10.
/*==========================================================================
==
zona de testes
===========================================================================
===*/
troca_lista([X|Cauda1],[Y|Cauda2]):-
troca(X,Y),
troca_lista(Cauda1, Cauda2).
joga_teste:-
cria_tabuleiro(_).
inicio:-
cria_tabuleiro(Tab),
primeira_jogada(Tab,Tab2),
visualiza_estado(Tab2),
lista_jogadas(Tab2,ListaJogadas),
nl,write(ListaJogadas).
primeira_jogada([X|Tail1],[c1|Tail2]):-
troca(X,Y),
subst(Y,'##',Tail1,Tail2).
jogada(Coluna,Linha,Cavalo,Tab1,Tab2):-
Pos is 10*(Linha-1)+(Coluna-1),
nth0(Pos,Tab1,Num),
subst(Num,Cavalo,Tab1,Tab3),
troca(Num,NumTrocado),
subst(NumTrocado,'##',Tab3,Tab2).
teste:-
cria_tabuleiro(Tab),
jogada(5,1,cb,Tab,Tab2),
jogada(2,10,cp,Tab2,Tab3),
subst(cb,'##',Tab3,Tab4),
jogada(6,3,cb,Tab4,Tab5),
subst(cp,'##',Tab5,Tab6),
jogada(4,9,cp,Tab6,Tab7),
subst(cb,'##',Tab7,Tab8),
visualiza_estado(Tab9).
subst(_,_,[],[]):-!.
subst(X,Y,[X|Tail1],[Y|Tail2]):- subst(X,Y,Tail1,Tail2).
lista_jogadas(Tab,ListaJogadas):-
nth0(Pos,Tab,c1),
P1 is Pos-8,P2 is Pos+8,
P3 is Pos-12,P4 is Pos+12,
P5 is Pos-19,P6 is Pos+19,
P7 is Pos-21,P8 is Pos+21,
L=[P1,P2,P3,P4,P5,P6,P7,P8],