:-lib(clpr).
:-[flux]. 

  
% Helping predicates

% Opposite for lock operation

opposite(high, low).
opposite(low, high).  

% Adjacent places
 
adjacent(X, Y, D, X1, Y1) :- [X,X1] :: 1..4, [Y,Y1] :: 1..3, D :: 1..4, 
(D#=1) #/\ (X1#=X) #/\ (Y1#=Y+1) % north 
#\/ (D#=2) #/\ (X1#=X+1) #/\ (Y1#=Y) % east 
#\/ (D#=3) #/\ (X1#=X) #/\ (Y1#=Y-1) % south 
#\/ (D#=4) #/\ (X1#=X-1) #/\ (Y1#=Y). % west



% Defined predicates



lockplace(lock1,1,3).
lockplace(lock2,1,1).
lockplace(lock3,2,2).


      
duration(lock1, high, 4.0).
duration(lock1, low, 3.0).
duration(lock2, high, 6.0).
duration(lock2, low, 2.0).
duration(lock3, high, 2.0).
duration(lock3, low, 2.0).


directions(1,1,[2]).
directions(1,2,[1,3]).
directions(1,3,[2]).
directions(2,1,[1,2]).
directions(2,2,[2]).
directions(2,3,[2]).



% Defined actions         

action(gobyship(_)).

%  Natural action declarations.

natural(A) :- A = turntide(L,_),
              (L = lock1; L = lock2; L = lock3).
     
             

%   Least-natural-time point.

nextnattime(T,Z) :- natural(A), poss(A,T,Z),
             not (natural(A1), poss(A1,T1,Z), {T1 < T}), !.         


nextnatactions(C,T,Z) :- nextnattime(T,Z), 
 setof(A, (natural(A), poss(A, T, Z)), C).


%  Action precondition axioms.         



poss(turntide(L,W),T,Z) :-
 (W=high, knows_val([L,TR],tide(L,low,TR),Z),
  duration(L,low,D);
  W=low, knows_val([L,TR],tide(L,high,TR),Z),
  duration(L,high,D)),
 {T =:= TR + D}.


                         
                       
poss(gobyship(D),T,Z) :-
 knows_val([X,Y],at(X,Y,_),Z),
 directions(X,Y,DL), member(D,DL),
 adjacent(X,Y,D,X1,Y1),
 ((lockplace(L,X1,Y1),
  knows_val([L,W,T0],tide(L,W,T0),Z),
  (W=high; W=low,
   duration(L,low,TD), {T>=T0+TD}));
  not (lockplace(L,X1,Y1))).


% State Update Axioms        

state_update(Z1,turntide(L,W),T,Z2) :-
 holds(tide(L,W0,T0),Z1),
 (W=high, update(Z1,[tide(L,high,T)],
                   [tide(L,W0,T0)],Z2);
  W=low, update(Z1,[tide(L,low,T)],
                  [tide(L,W0,T0)],Z2)).

state_update(Z1,gobyship(D),T,Z2) :-
 knows_val([X,Y],at(X,Y,T0),Z1),
 holds(starttime(ST),Z1), !, {T >= ST + 1.0},
 adjacent(X,Y,D,X1,Y1),
 update(Z1,[at(X1,Y1,T)],[at(X,Y,T0)],Z2).


       

% One step resolution

res(Z1,S1,[],T,Z2,S1) :-
 holds(starttime(T0), Z1),!,
 update(Z1,[starttime(T)],[starttime(T0)],Z2).

res(Z1,S1,[A|L],T,Z2,do([A|L],T,S1)) :-
 update([A|L],[],[A],L1),
 state_update(Z1, A, T, Z3),
 res(Z3,_,L1,T,Z2,_).

   
% N step resolution


exec(Z1,S1,Z1,S1,0).

exec(Z1,S1,Z2,S2,Depth) :-
 Depth>0, nextnatactions(C,T,Z1),
 ({T1=T}, C1=C;
  (action(A), poss(A,TA,Z1),
   holds(starttime(T0),Z1), {TA>=T0},
  ({TA<T, T1=TA}, C1=[A];
   {TA=T, T1=T}, append([A],C,C1)))),
 res(Z1,S1,C1,T1,Z3,S3), Depth1 is Depth-1,
 exec(Z3,S3,Z2,S2,Depth1).



% Goal state          

goal(Z) :- knows_val([X,Y],at(X,Y,_), Z),X=3,Y=2.

% Find a plan

ida(Z0, S0, Z, S, E, N) :- exec(Z0, S0, Z, S, N),
                           goal(Z),
                           E is N;
                           N1 is N+1,
                           ida(Z0, S0, Z, S, E, N1).       


%  Initial state

init(Z0) :-
 Z0=[at(1,2,0.0),tide(lock1,high,0.0),tide(
     lock2,high,0.0),tide(lock3,high,0.0),starttime(0.0)|Z],
 not_holds_all(at(_,_,_),Z),
 not_holds_all(tide(_,_,_),Z).


% init(Z0), res(Z0,s0,[gobyship(3),turntide(lock3,low)],2.0,Z1,S1).
% init(Z0), ida(Z0, s0, Z, S, E, 1).