Programa Simulador de Robot en Prolog(Incompleto)

Este programa muestra a un robot dirigiéndose a alguna coordenada dada por el usuario o quien maneje el robot , la esencia del programa es la manera de evitar obstáculos automáticamente sin que el usuario le indique que están ahí, y que al final llegue al punto dado inicialmente.

goal:-
 assert(incrementos(1,1)),
 assert(incrementos(-1,1)),
 assert(incrementos(1,-1)),
 assert(incrementos(1,0)),
 assert(incrementos(0,1)),
 assert(incrementos(-1,-1)),
 assert(incrementos(0,-1)),
 assert(incrementos(0,0)),
 borrar,
 comenzar.

comenzar:-
cursor(0,0),
write("introdusca programa :"),nl,
obtener_programa(_),
borrar,
retract(posicionxy(_,_)),
assert(posicion(0,0)),
ejecutar.

/*ejcutar el programa */

ejecutar:-
analiazar.
ejecutar:-
purgar_xy,
purgar_programa,
purgar_incrementos,
purgar_almacenarprograma,
cursor(22,0),
write("ejecucion completa"),nl.

/*introducir programa*/

obtener_programa(P):-
write(": "),
read(S),
S=@="",
assertz(programa(S)),
S=@="enseñar",
obtener_programa(P).

obtener_programa(P):- /*convertir en lista*/
retract(programa("enseñar")),
borrar,
posicion,
enseñar,
borrar,
obtener_programa(P).

obtener_programa(P):-
hacer_lista([],P),
assert(almacenar_programa(P)),
re_almacenar(P).

hacer_lista(T,S):-
retract(programa(X)),
juntar(T,[X],S1),
hacer_lista(S1,S).

hacer_lista(S,S).

re_almacenar(P):- /*poner en la base de datos*/
ontener_linea(P,P2,S),
assertz(programa(S)),
re_almacenar(P2).
re_almacenar(_).

/*devolver la primera linea y el resto de la lista*/
obtener_linea([S|P2],P2,S).

/*enseñar al robot algunos movimientos*/

enseñar:- /*usar las teclas del cursos para enseñar*/
readchar(C),
C=@='1',
registrar(C),
enseñar.
enseñar.

/*registrar cada movimiento*/
registrar('2'):-
posicionxy(R,C),
R1 is R+1,
despejado(R1,C),
retract(posicionxy(R,C)),
assert(posicionxy(R1,C)),
mover_a(R1,C,R,C),
assertz(programa("mover abajo")).
registrar('8'):-
posicionxy(R,C),
R1 is R-1,
despejado(R1,C),
R1 is R-1,
despejado(R1,C),
retract(posicionxy(R,C)),
assert(posicionxy(R1,C)),
mover_a(R1,C,R,C),
assertz(programa("mover arriba")).
registrar('4'):-
posicionxy(R,C),
C1 is C-1,
despejado(R,C1),
despejado(R,C),
retract(posicionxy(R,C)),
assert(posicionxy(R,C1)),
mover_a(R,C1,R,C),
assertz(programa("mover izquierda")).
registrar('6'):-
posicionxy(R,C),
C1 is C+1,
despejado(R,C1),
retract(posicionxy(R,C)),
assert(posicionxy(R,C1)),
mover_a(R,C1,R,C),
assertz(programa("mover derecha")).
registrar('7'):-
assertz(programa("mover_a 0 0")),
retract(posicionxy(R,C)),
assert(posicionxy(0,0)),
mover_a(0,0,R,C),
registrar.
/*procesador de ordenes*/
analizar:-
retract(programa(S)),
siguiente_palabras(S,S2,C),
orden(C,S2),!,
cursos(0,0),
analizar.
orden(mover_a,S):- /*mover a una fila y col.determinadas*/
siguiente_palabras(S,T,R),
siguiente_palabras(T,_;C),
str_int(R,Ri), /*convertir a enteros*/
str_int(C,Ci),
posicionxy(X,Y),
mover_a(Ri,Ci,Y,X),
purgar_xy,
assert(posicion(Ri,Ci)),
purgar_puntos.
orden(encuentran_s,_):- /*encontrar un cuadrado*/
posicionxy(R,C),
encontrar_cuadrado(R,C,R1,C1),
retract(posicion(X,Y)),
C2 is C1-1,
purgar_puntos,
mover_a(0,0,Y,X),
mover_a(R1,C2,0,0),
assert(posicionxy(R1,C2)).

orden(mover,S):- /*mover en la direccion indicada*/
siguiente_palabra(S,_,D),
hacemover(D),
purgar_puntos.

orden(si_notas,S):- /*buscar objeto*/
siguiente_palabra(S,S2,D),
hacermover(D),
purgar_puntos.

orden(etiqueta,_). /*para usar con los ir a*/

orden(ir_a,S):- /*ir_a aetiqueta*/
siguiente_palabra(S,_,Name),
almacenar_programa(P), /*obtener copia*/
encontrar_etiqueta(Name,P,_).
orden(_,_):-
write("error en el programa"),
nl,fail.
/*diseccionar cada linea*/
/*encontrar un espacio o un punto*/

encontrar_delim(S,Count,C):-
fronchar(S,CH,S2),
CH=@='' ,
CH=@='.',
C2 is C+1,
encontrar_delim(S2,Count,C2).

encontrar_delim(_,Count,Count). /*obtener la sig.palabra*/
siguiente_palabra(S,S2,W):-
encontrar_delim(S,Count,0),!,
Count=@=0,
frontstr(Count,S,W,S3),
quitar_espacio(S3,S2).

quitar_espacio(S,S).
/******/
/*ejecutar las ordenes*/
/******/
/*hacer el ir_a*/
encontrar_etiqueta(N,P,P2):-
obtener_linea(P,P2,S),
siguiente_palabra(S,S2,L),
L=etiqueta,
siguiente_palabra(S2,_,Name),
N=Name,
purgar_programa,
re_almacenar(P2).
/*realmacena qel programa a partir de la etiqueta*/
encontrar_etiqueta(N,P,P2):-
obtener_linea(P,P3,_),
encontrar_etiqueta(N,P3,P2).
/*mover a la fila y columna especificada*/
mover_a(R,C,Rcurrent,Ccurrent):-
R=Rcurrent, C=Ccurrent,
assert(punto,(R,C)).

mover_a(R,C,Rcurrent,Ccurrent):-
Rcurrent<R,
R1=Rcurrent+1,
despejado(R1,Ccurrent),!, /* 1 no hya objeto en camino*/
cursor(Rcurrent,Ccurrent),
write('#'),
sound(5,100),
mover_a(R,C,R1,Ccurrent).

mover_a(R,C,Rcurrent,Ccurrent):-
Ccurrent<C,
C1 is Ccurrent+1,
despejado(Rcurrent,C1),!, /*2 no hay objetos en el camino*/
cursor(Rcurrent,Ccurrent),
write(''),
cursor(Rcurrent,C1),
write('#'),
sound(5,200),
mover_a(R,C,Rcurrent,C1).

mover_a(R,C,Rcurrent,Ccurrent):-
Ccurrent>C,
C1 is Ccurrent-1,
depejado(Rcurrent,C1),!, /*3 no hay objetos en el camino*/
cursor(Rcurrent,Ccurrent),
write(''),
cursor(Rcurrent,C1),
write('#'),
sound(5,300),
mover_a(R,C,Rcurrent,C1).

Descargar: https://drive.google.com/file/d/0B54zQ28WV9OEeFFNVWsyc1puR1U/view?usp=sharing