Trabajo Prctico de

Inteligencia Artificial
Juego TA-TE-TI
Integrantes del grupo:
Nombre y Apellido
Alonso, Gabriel
Giorcelli, Leonardo

Padrn
80895
80126

Docente: Cabrera, Jos Luis

Cuatrimestre/Ao: 1er. Cuatrimestre/2003

Consigna del TP

Partiendo de un estado inicial, determinar la secuencia de movidas que resulte

ptima para llegar a la solucin (es decir, que alguien gane el juego).
Implementar el programa en el lenguaje Prolog.

Cdigo Fuente en Prolog (comentado)

domains

estado=f(char,char,char,char,char,char,char,char,char)
/*El estado es un functor de 9 posiciones cada una de
las cuales representa una posicion (fila, columna) del tablero
de TA-TE-TI. Se expresa por filas, es decir las posiciones 1,2,3
del fuctor corresponde a las posiciones (fila 1, columna 1),
(fila 1, columna 2) y (fila 1, columna 3) del tablero. Lo mismo
sucede con las filas 2 y 3.*/
estadolis=estado*
/*Lista de estado donde se guardara la secuencia de estados
que resulte optima.*/
predicates
ingresardatos
/*Permite ingresar los datos del estado inicial.*/
inicio(estadolis,char,integer)
/*Busca soluciones para distintos niveles de profundidad,
comenzando por el nivel 1, siguiendo por el 2 y asi
sucesivamente. En cuanto encuentra una solucion para un
determinado nivel de profundidad termina la busqueda.*/
sol(estadolis,estadolis,integer,char)
/*Busca una solucion para un determinado nivel de profundidad.*/
mem(estado,estadolis)
/*Chequea que el nuevo estado no este en la lista de estados,
es decir que no haya repeticion de estados.*/
condterm(estado)
/*Evalua si se cumple o no la condicion de terminacion del
juego TA-TE-TI.*/
ponerficha(estado,estado,integer,char)
/*Coloca una ficha en el tablero y a partir de ello se obtiene
un nuevo estado.*/
deterturno(char,char)
/*Determina el turno, es decir la ficha ("X" o "O") que se debe
colocar en el tablero en la correspondiente movida.*/
imprilis(estadolis)
/*Imprime por pantalla la secuencia de estados para
llegar a la solucion optima.*/

clauses
ingresardatos:write("JUEGO TA-TE-TI \n"),
write("----- -- -- -- \n\n"),
write("Ingrese el Estado Inicial","\n\n"),
write("Fila 1 Columna 1 (ingrese 'X' o 'O' o '_'): "),
readchar(POS1),
write("\n"),
write("Fila 1 Columna 2 (ingrese 'X' o 'O' o '_'): "),
readchar(POS2),
write("\n"),
write("Fila 1 Columna 3 (ingrese 'X' o 'O' o '_'): "),
readchar(POS3),
write("\n"),
write("Fila 2 Columna 1 (ingrese 'X' o 'O' o '_'): "),
readchar(POS4),
write("\n"),
write("Fila 2 Columna 2 (ingrese 'X' o 'O' o '_'): "),
readchar(POS5),
write("\n"),
write("Fila 2 Columna 3 (ingrese 'X' o 'O' o '_'): "),
readchar(POS6),
write("\n"),
write("Fila 3 Columna 1 (ingrese 'X' o 'O' o '_'): "),
readchar(POS7),
write("\n"),
write("Fila 3 Columna 2 (ingrese 'X' o 'O' o '_'): "),
readchar(POS8),
write("\n"),
write("Fila 3 Columna 3 (ingrese 'X' o 'O' o '_'): "),
readchar(POS9),
write("\n\n"),
write("Seleccione quien comienza ('X' o 'O'): "),
readchar(TURNOINI),
write("\n\n"),
write("Presione una tecla para obtener la solucion optima"),
readchar(_),
inicio([f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9)],TURNOINI,1).
inicio(LISTAINI,INI,PROF):sol(LISTAINI,_,PROF,INI),!.
inicio(LISTAINI,INI,PROF):PROFN=PROF+1,
inicio(LISTAINI,INI,PROFN).

sol([X|L],[X|L],_,_):condterm(X),
clearwindow,
write("La solucion optima es: ","\n","\n"),
imprilis([X|L]),!.
sol([X|L],LS,N,TURNO):N1=N-1,N1>0,ponerficha(X,Y,_,TURNO),
deterturno(TURNO,TURNONUEVO),
not(mem(Y,[X|L])),sol([Y,X|L],LS,N1,TURNONUEVO).
ponerficha(X,Y,1,TURNO):X=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9),
POS1='_',
Y=f(TURNO,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9).
ponerficha(X,Y,2,TURNO):X=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9),
POS2='_',
Y=f(POS1,TURNO,POS3,POS4,POS5,POS6,POS7,POS8,POS9).
ponerficha(X,Y,3,TURNO):X=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9),
POS3='_',
Y=f(POS1,POS2,TURNO,POS4,POS5,POS6,POS7,POS8,POS9).
ponerficha(X,Y,4,TURNO):X=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9),
POS4='_',
Y=f(POS1,POS2,POS3,TURNO,POS5,POS6,POS7,POS8,POS9).
ponerficha(X,Y,5,TURNO):X=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9),
POS5='_',
Y=f(POS1,POS2,POS3,POS4,TURNO,POS6,POS7,POS8,POS9).
ponerficha(X,Y,6,TURNO):X=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9),
POS6='_',
Y=f(POS1,POS2,POS3,POS4,POS5,TURNO,POS7,POS8,POS9).
ponerficha(X,Y,7,TURNO):X=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9),
POS7='_',
Y=f(POS1,POS2,POS3,POS4,POS5,POS6,TURNO,POS8,POS9).

ponerficha(X,Y,8,TURNO):X=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9),
POS8='_',
Y=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,TURNO,POS9).
ponerficha(X,Y,9,TURNO):X=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9),
POS9='_',
Y=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,TURNO).
condterm(f(FICHA,FICHA,FICHA,_,_,_,_,_,_)):FICHA<>'_'.
condterm(f(_,_,_,FICHA,FICHA,FICHA,_,_,_)):FICHA<>'_'.
condterm(f(_,_,_,_,_,_,FICHA,FICHA,FICHA)):FICHA<>'_'.
condterm(f(FICHA,_,_,FICHA,_,_,FICHA,_,_)):FICHA<>'_'.
condterm(f(_,FICHA,_,_,FICHA,_,_,FICHA,_)):FICHA<>'_'.
condterm(f(_,_,FICHA,_,_,FICHA,_,_,FICHA)):FICHA<>'_'.
condterm(f(FICHA,_,_,_,FICHA,_,_,_,FICHA)):FICHA<>'_'.
condterm(f(_,_,FICHA,_,FICHA,_,FICHA,_,_)):FICHA<>'_'.
deterturno('X','O').
deterturno('O','X').
mem(X,[X|_]).
mem(X,[_|L]):-mem(X,L).
imprilis([]).
imprilis([X|L]):imprilis(L),
X=f(POS1,POS2,POS3,POS4,POS5,POS6,POS7,POS8,POS9),
write(POS1," ",POS2," ",POS3,"\n"),
write(POS4," ",POS5," ",POS6,"\n"),
write(POS7," ",POS8," ",POS9,"\n","\n"),
write("Presione un tecla para ir al siguiente estado"),
readchar(_),
write("\n\n\n").

goal
clearwindow,
/*Limpia la pantalla.*/
ingresardatos.
/*Llama a la clausula para ingresar los datos.*/

Informe Final

El programa en Prolog funciona de la siguiente manera:

Para comenzar, se pide al usuario que ingrese el estado inicial del tablero. A
partir de este estado, se busca la secuencia de movidas ptima (que ser la que
requiera de menor cantidad de pasos o secuencias). Para ello, el lenguaje
utiliza el mtodo de backtracking. Una vez ingresado el estado inicial, el
compilador busca soluciones para un nivel de profundidad igual a 1. Primero
se chequea la condicin de terminacin, sino se cumple se aplica una regla y
se chequea la condicin de terminacin sobre el nuevo estado obtenido. Esto
se realiza de manera recursiva hasta que se cumpla la condicin de
terminacin o no se pueda profundizar ms. Si se cumple la condicin, se
llega a la solucin y esta secuencia de estados se imprime por pantalla. En
caso contrario, se aumenta el nivel de profundidad en 1 y se repite el proceso
para este nuevo nivel de profundidad. Esto tambin se reitera de manera
recursiva hasta que se llega a la solucin (para algn nivel de profundidad
mayor o igual a 1).
Como se comienza por un nivel de profundidad 1, esto asegura que la solucin
hallada ser la que requiera de menor cantidad de secuencias de estado (sino
encuentra con nivel 1 prueba con nivel 2 y as sucesivamente).
Nota 1: No se encuentran validados los datos que debe ingresar el usuario.
Nota 2: Se adjunta un diskette con el archivo ejecutable y con el archivo
fuente.