aqui esta el del gato para los niños
Publicado por
ricardo (1 intervención) el 11/04/2007 17:41:52
Domains
elem=integer
lis_elem=integer*
/* Definiciones de los elementos (enteros) y la lista que representa el gato */
Predicates
append(lis_elem,lis_elem,lis_elem)
/* Entran dos listas, sale una con los elementos de ambas */
lon_lis(lis_elem,elem)
/* Regresa la longitud (n£mero de elementos) de una lista */
member(elem,lis_elem)
/* Verifica si un elemento se encuentra o no a una lista */
pon_tablero(lis_elem,lis_elem)
/* Lee las dos listas (X y O) y despliega el tablero */
checa(elem,lis_elem,lis_elem)
/* Verifica que existe en el juego X,O o libre */
juega_tu(lis_elem,lis_elem)
juega_yo(lis_elem,lis_elem)
/* Procedimientos que calculan donde tirar o permiten tirar incrementando
las listas */
pon(lis_elem,lis_elem,string)
/* Se agrega a la lista el elemento que es del tipo string */
gano(lis_elem,symbol)
/* Verifica si ya gano alguien */
gato(lis_elem,lis_elem)
/* Verifica si ya se hizo gato */
tiros(lis_elem,lis_elem,elem)
/* Secuencia de tiros programada: Primero para hacer gato, segundo para
ponerle una "trampa" (tir¢ en una impar) al contrario, luego para
evitar que el contrario nos ponga una "trampa", y al final intenta
ganar el centro o las esquinas */
tiro(lis_elem,lis_elem,elem,elem)
/* Implementaci¢n del tiro: Matem tica */
trans(elem,string)
/* Traduce de integer a string */
juguemos(string)
empieza()
Clauses
append([],List,List).
append([X|List1],List2,[X|List3]):-append(List1,List2,List3).
lon_lis([],0).
lon_lis([_|Tail],Number):-lon_lis(Tail,Count),Number=Count+1.
member(X,[X|_]).
member(X,[_|Y]):-member(X,Y).
checa(N,X,_):-member(N,X),write(" X ").
checa(N,_,O):-member(N,O),write(" O ").
checa(N,_,_):-write(" ",N," ").
pon_tablero(X,O):-checa(8,X,O),write(" | "),checa(3,X,O),write(" | "),checa(4,X,O),nl,
write("----+-----+----"),nl,
checa(1,X,O),write(" | "),checa(5,X,O),write(" | "),checa(9,X,O),nl,
write("----+-----+----"),nl,
checa(6,X,O),write(" | "),checa(7,X,O),write(" | "),checa(2,X,O),nl.
/* checa y pon_tablero leen dos listas: X y O y dependiendo de que haya en
dichas listas despliegan el tablero */
trans(1,"1").trans(2,"2").trans(3,"3").trans(4,"4").trans(5,"5").trans(6,"6").
trans(7,"7").trans(8,"8").trans(9,"9").
pon(Z,[1|Z],"1").pon(Z,[2|Z],"2").pon(Z,[3|Z],"3").pon(Z,[4|Z],"4").pon(Z,[5|Z],"5").
pon(Z,[6|Z],"6").pon(Z,[7|Z],"7").pon(Z,[8|Z],"8").pon(Z,[9|Z],"9").
juega_tu(X,O):-nl,not(gato(X,O)),write("¨D¢nde quieres poner tu marca? "),
readln(R),trans(I,R),not(member(I,X)),not(member(I,O)),
pon(X,X1,R),!,not(gano(X1,x)),juega_yo(X1,O).
juega_tu(X,O):-write("Esa casilla ya esta ocupada"),juega_tu(X,O).
/* juega_tu recibe las dos listas (X,O), verifica que no se haya hecho gato,
pregunta y lee donde quiere tirar, traduce lo leido de string a integer,
verifica que la marca no se haya hecho ya (ni por la computadora ni por el otro),
agrega a la lista X la marca, ve si x ya gan¢, de lo contrario juega la computadora.*/
tiros(X,O,I):-tiro(X,O,I,15).
tiros([3],[5],2).tiros([1],[5],4).tiros([7],[5],8).tiros([9],[5],6).
tiros(X,O,I):-tiro(X,O,I,21).tiros(X,O,I):-tiro(X,O,I,17). /* Para entender el concepto "poner trampa" se sugiere poner */
tiros(X,O,I):-tiro(X,O,I,13).tiros(X,O,I):-tiro(X,O,I,9). /* este par de l¡neas en comentarios y empezar el juego con 7,4,2...*/
tiros(_,_,5).tiros(_,_,8).tiros(_,_,6).tiros(_,_,2).tiros(_,_,4).
tiro(_,[A,B|_],I,N):-A<>N-A-B,B<>N-A-B,N-A-B<=9,I=N-A-B.
tiro(X,[A,_|O],I,N):-tiro(X,[A|O],I,N).
tiro(X,[_,B|O],I,N):-tiro(X,[B|O],I,N).
tiro([A,B|_],_,I,N):-A<>N-A-B,B<>N-A-B,N-A-B<=9,I=N-A-B.
tiro([A,_|X],O,I,N):-tiro([A|X],O,I,N).
tiro([_,B|X],O,I,N):-tiro([B|X],O,I,N).
/* tiro analiza primero la lista de marcas del contrario tomando dos n£meros
cada vez y verificando si se puede hacer una marca que sumadas a las dos ya
hechas de como resultado el n£mero N. Si N=15 entonces evita que el contrario
gane. 21,17,13, y 9 son secuencias para evitar "trampas". Los otros son tiros
directos para cuando no se cumplan ciertos requisitos en el tablero. Este
mismo an lisis se hace con la lista propia para ganar o intentar poner trampas.*/
juega_yo(X,O):-nl,not(gato(X,O)),tiros(X,O,I),trans(I,R),
not(member(I,X)),not(member(I,O)),pon(O,O1,R),
pon_tablero(X,O1),!,not(gano(O1,o)),juega_tu(X,O1).
/* juega_yo recibe las dos listas (X,O), verifica que no se haya hecho gato,
calcula la marca que debe jugar seg£n la secuencia explicada en tiros,
traduce lo calculado de integer a string, verifica que la marca no se haya hecho,
agrega la marca a la lista O, reescribe el tablero, ve si o ya gan¢, de lo
contrario le da el turno a juega_tu. */
gano([A,B,C|_],o):-A+B+C=15,nl,write(" Gan‚"),empieza.
gano([A,B,C|_],x):-A+B+C=15,nl,write(" Ganaste"),empieza.
gano([_,B,C|X],T):-gano([B,C|X],T).
gano([A,_,C|X],T):-gano([A,C|X],T).
gano([A,B,_|X],T):-gano([A,B|X],T).
/* Para ver si ya gan¢ alguien se analizan todas las combinaciones de 3 marcas
que est‚n en la lista. Si una de esas combinaciones da 15 entonces gan¢ el
due¤o de la lista (x,o). */
gato(A,B):-append(A,B,C),lon_lis(C,9),nl,
write(" Ya se hizo Gato."),empieza.
/* Para ver si ya se hizo gato £nicamente se hace un append de las marcas ya
hechas, si la lista resultante tiene una longitud de 9, ya se hizo gato. */
juguemos("yo"):-nl,pon_tablero([],[]),juega_tu([],[]).
juguemos("tu"):-juega_yo([],[]).
juguemos(_):-exit.
/* Lo importante aqui es empezar con listas vac¡as (o se podr¡a hacer trampa).*/
empieza:-nl,write("¨Quien empieza? (tu/yo) "),
readln(R),juguemos(R).
Goal makewindow(1,7,7,"Vamos a Jugar al Gato",1,16,22,58),empieza.
