:- dynamic interdit/1.

/* recherche dans un graphe d'etats */

/*recherche(EtatCourant,EtatFinal,ListeTaboue,ListeOp) tous donnes sauf ListeOp */
recherche(Ec,Ec,_,[]):-!.
recherche(Ec,Ef,Ltaboue,[Op|Lop]) :- 
	operateur(Ec,Op,Es),
	not(interdit(Es)),
	not(member(Es,Ltaboue)),
	%write(Ec), write(' '), write(Op), write(' '),write(Es),nl,
	recherche(Es,Ef,[Es|Ltaboue],Lop).

resoudre(Sol) :- etatInitial(Ei),etatFinal(Ef),
	recherche(Ei,Ef,[Ei],Sol).

				
/* probleme du labyrinthe */

/*etatInitial(entree).
etatFinal(sortie).

interdit(minotaure).

operateur(E1,[E1,E2],E2) :- couloir(E1,E2).
operateur(E1,[E1,E2],E2) :- couloir(E2,E1).


couloir(entree, thesee).
couloir(entree, ariane).
couloir(thesee, minotaure).
couloir(thesee,sombre).
couloir(claire, sombre).
couloir(claire, sortie).
couloir(minotaure, sortie).
couloir(ariane, claire).
couloir(sombre,sortie).*/



/* probleme des 2 cruches de 3 et 4 L */

/* on représente un état par un couple (contenu cruche 3L, contenu cruche 4L) */

/*etatInitial([0,0]).
etatFinal([2,_]).
etatFinal([_,2]).

:-dynamic interdit/1.

operateur([_,X],remplir3L,[3,X]).
operateur([X,_],remplir4L,[X,4]).
operateur([_,X],vider3L,[0,X]).
operateur([X,_],vider4L,[X,0]).
operateur([X,Y],transvaser3Ldans4L,[0,NY]):- Place is 4-Y, X=<Place, NY is Y+X.
operateur([X,Y],transvaser3Ldans4L,[NX,4]):- Place is 4-Y, X>Place, NX is X-Place.
operateur([X,Y],transvaser4Ldans3L,[NX,0]):- Place is 3-X, Y=<Place, NX is X+Y.
operateur([X,Y],transvaser4Ldans3L,[3,NY]):- Place is 3-X, Y>Place, NY is Y-Place.*/


/* probleme du fermier */

/*etatInitial([g,g,g,g]).
etatFinal([d,d,d,d]).

operateur([F1,L,C,O],batSeul,[F2,L,C,O]):-autreRive(F1,F2).
operateur([F1,F1,C,O],batLoup,[F2,F2,C,O]):-autreRive(F1,F2).
operateur([F1,L,F1,O],batChevre,[F2,L,F2,O]):-autreRive(F1,F2).
operateur([F1,L,C,F1],batChou,[F2,L,C,F2]):-autreRive(F1,F2).

autreRive(g,d).
autreRive(d,g).

interdit([F,X,X,_]):- autreRive(F,X).
interdit([F,_,X,X]):- autreRive(F,X).*/

/* On trouve deux solutions :
?- resoudre(S).
[g, g, g, g] batChevre [d, g, d, g]
[d, g, d, g] batSeul [g, g, d, g]
[g, g, d, g] batLoup [d, d, d, g]
[d, d, d, g] batChevre [g, d, g, g]
[g, d, g, g] batChou [d, d, g, d]
[d, d, g, d] batSeul [g, d, g, d]
[g, d, g, d] batChevre [d, d, d, d]
[batChevre, batSeul, batLoup, batChevre, batChou, batSeul, batChevre]

S = [batChevre, batSeul, batLoup, batChevre, batChou, batSeul, batChevre] ;

[d, d, g, d] batLoup [g, g, g, d] /* ici un retour
[g, g, g, d] batChevre [d, g, d, d] arriere qui ne donne rien */
[g, g, d, g] batChou [d, g, d, d] /* là le retour arriere qui donne la 2eme solution */
[d, g, d, d] batChevre [g, g, g, d]
[g, g, g, d] batLoup [d, d, g, d]
[d, d, g, d] batSeul [g, d, g, d]
[g, d, g, d] batChevre [d, d, d, d]
[batChevre, batSeul, batChou, batChevre, batLoup, batSeul, batChevre]

S = [batChevre, batSeul, batChou, batChevre, batLoup, batSeul, batChevre] ;

[d, d, g, d] batChou [g, d, g, g] /* ici un retour
[g, d, g, g] batChevre [d, d, d, g] arriere qui ne donne rien */

No
*/


/* probleme du singe */
/* A GENERALISER AVEC DES VARIABLES POUR LES HAUTEURS ET LES POSITIONS */

/* etat = signe - banane - caisse avec position et hauteur
et le fait que le singe possède ou non la banane */

/* etatInitial([[posA,1,[]],[posB,2],[posC,1]]).
etatFinal([[posA,1,[banane]],[posA,1],[posC,1]]).

operateur([[PosSinge,HauteurSinge,[]],[PosSinge,HauteurSinge],DetailsCaisse], saisirBanane,
    [[PosSinge,HauteurSinge,[banane]],[PosSinge,HauteurSinge],DetailsCaisse]).

operateur([[PosSinge,HauteurSinge,[banane]],[PosSinge,HauteurSinge],DetailsCaisse], poserBanane,
    [[PosSinge,HauteurSinge,[]],[PosSinge,HauteurSinge],DetailsCaisse]).

operateur([[PosSinge,1,Possede],DetailsBanane,[PosSinge,1]], grimper,
    [[PosSinge,2,Possede],DetailsBanane,[PosSinge,1]]).

operateur([[PosSinge,2,Possede],DetailsBanane,[PosSinge,1]], descendre,
    [[PosSinge,1,Possede],DetailsBanane,[PosSinge,1]]).

operateur([[PosSinge,1,[banane]],_, DetailsCaisse], allerEnA,
    [[posA,1,[banane]],[posA,1], DetailsCaisse]) :- PosSinge \== posA.
operateur([[PosSinge,1,[banane]],_, DetailsCaisse], allerEnB,
    [[posB,1,[banane]],[posB,1], DetailsCaisse]) :- PosSinge \== posB.
operateur([[PosSinge,1,[banane]],_, DetailsCaisse], allerEnC,
    [[posC,1,[banane]],[posC,1], DetailsCaisse]) :- PosSinge \== posC.

operateur([[PosSinge,1,[]],DetailsBanane, DetailsCaisse], allerEnA,
    [[posA,1,[]],DetailsBanane, DetailsCaisse]) :- PosSinge \== posA.
operateur([[PosSinge,1,[]],DetailsBanane, DetailsCaisse], allerEnB,
    [[posB,1,[]],DetailsBanane, DetailsCaisse]) :- PosSinge \== posB.
operateur([[PosSinge,1,[]],DetailsBanane, DetailsCaisse], allerEnC,
    [[posC,1,[]],DetailsBanane, DetailsCaisse]) :- PosSinge \== posC.

operateur([[PosSinge,1,[banane]],_,[PosSinge,1]], deplacerCaisseVersA,
    [[posA,1,[banane]],[posA,1],[posA,1]]) :- PosSinge \== posA.
operateur([[PosSinge,1,[banane]],_,[PosSinge,1]], deplacerCaisseVersB,
    [[posB,1,[banane]],[posB,1],[posB,1]]) :- PosSinge \== posB.
operateur([[PosSinge,1,[banane]],_,[PosSinge,1]], deplacerCaisseVersC,
    [[posC,1,[banane]],[posC,1],[posC,1]]) :- PosSinge \== posC.

operateur([[PosSinge,1,[]],DetailsBanane,[PosSinge,1]], deplacerCaisseVersA,
    [[posA,1,[]],DetailsBanane,[posA,1]]) :- PosSinge \== posA.
operateur([[PosSinge,1,[]],DetailsBanane,[PosSinge,1]], deplacerCaisseVersB,
    [[posB,1,[]],DetailsBanane,[posB,1]]) :- PosSinge \== posB.
operateur([[PosSinge,1,[]],DetailsBanane,[PosSinge,1]], deplacerCaisseVersC,
    [[posC,1,[]],DetailsBanane,[posC,1]]) :- PosSinge \== posC. */


/* ?- findall(S, (resoudre(S),length(S,N), N<8), L), write(L).
[[allerEnC,deplacerCaisseVersB,grimper,saisirBanane,descendre,deplacerCaisseVersC,allerEnA]]
L = [[allerEnC, deplacerCaisseVersB, grimper, saisirBanane, descendre, deplacerCaisseVersC, allerEnA]].
*/