/* EL JUEGO DEL MICHI */

Domains
elem=integer
lis_elem=integer*
/* Definiciones de los elementos (enteros) y la lista que representa el michi */
Predicates

inserta(lis_elem,lis_elem,lis_elem)
/* Entran dos listas, sale una con los elementos de ambas */
lon_lis(lis_elem,elem)
/* Regresa la longitud (numero de elementos) de una lista */
miembro(elem,lis_elem) - nondeterm(i,i)
/* Verifica si un elemento se encuentra o no a una lista */

pon_tablero(lis_elem,lis_elem) - nondeterm(i,i)
/* Lee las dos listas (X y O) y despliega el tablero */
verifica(elem,lis_elem,lis_elem) -nondeterm(i,i,i)
/* 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,symbol)
/* Se agrega a la lista el elemento que es del tipo symbol */

gano(lis_elem,symbol) - nondeterm(i,i)
/* Verifica si ya gano alguien */
michi(lis_elem,lis_elem) - nondeterm(i,i)
/* Verifica si ya se hizo michi */

tiros(lis_elem,lis_elem,elem) - nondeterm(i,i,i), nondeterm(i,i,o)

/* Secuencia de tiros programada: Primero para hacer michi, segundo para ponerle una
"trampa" (tiro 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) - nondeterm(i,i,i,i),nondeterm(i,i,o,i)
trans(elem,string) % Traduce de integer a string
juguemos(string) -nondeterm(i)
empieza() - nondeterm()
Clauses
inserta([],List,List).
inserta([X|List1],List2,[X|List3]):-inserta(List1,List2,List3).

lon_lis([],0).
lon_lis([_|Cola],Numero):-lon_lis(Cola,Count),Numero=Count+1.

miembro(X,[X|_]).
miembro(X,[_|Y]):-miembro(X,Y).

verifica(N,X,_):-miembro(N,X),write(" X ").
 verifica(N,_,O):-miembro(N,O),write(" O ").
verifica(N,_,_):-write(" ",N," ").

% tablero
pon_tablero(X,O):-verifica(8,X,O),write(" | "),verifica(3,X,O),write(" |
"),verifica(4,X,O),nl,
write("----+-----+----"),nl,
verifica(1,X,O),write(" | "),verifica(5,X,O),write(" |
"),verifica(9,X,O),nl,
write("----+-----+----"),nl,
verifica(6,X,O),write(" | "),verifica(7,X,O),write(" |
"),verifica(2,X,O),nl.
/* verifica y pon_tablero leen dos listas: X y O y dependiendo de que haya en dichas listas
despliegan el tablero */

% pasa entero a string

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(michi(X,O)),write("Escribe el numero donde va tu juego? "),

readln(R),trans(I,R),not(miembro(I,X)),not(miembro(I,O)),
pon(X,X1,R),!,not(gano(X1,x)),juega_yo(X1,O).
juega_tu(X,O):-write("No haz escrito nada!!!! se mas atento."),juega_tu(X,O).

/* juega_tu recibe las dos listas (X,O), verifica que no se haya hecho michi, 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 gano, 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 lineas 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
numero 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(michi(X,O)),tiros(X,O,I),trans(I,R),
not(miembro(I,X)),not(miembro(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 michi, 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 gano, de lo contrario le da el turno a juega_tu. */

gano([A,B,C|_],o):-A+B+C=15,nl,write(" Te Gane!!!!!‚"),empieza.
gano([A,B,C|_],x):-A+B+C=15,nl,write(" Ganaste!!! muy bien...
Felicitaciones"),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 gane alguien se analiza todas las combinaciones de 3 marcas que están en la
lista. Si una de esas combinaciones da 15 entonces gana el dueno de la lista (x,o). */

michi(A,B):-inserta(A,B,C),lon_lis(C,9),nl,
write(" Empatamos!!!!!!."),empieza.

/* Para ver si ya se hizo michi unicamente se hace una insercion (inserta) de las marcas ya
hechas, si la lista resultante tiene una longitud de 9, ya se hizo michi. */

juguemos("yo"):-nl,pon_tablero([],[]),juega_tu([],[]).
juguemos("tu"):-juega_yo([],[]).
juguemos(_):-exit.

/* Lo importante aqui es empezar con listas vacias (o se podria hacer trampa).*/

empieza:-nl,write("Quien empieza a jugar? (tu/yo) "),

readln(R),juguemos(R).

Goal write("Juguemos al 3 en raya"),empieza.