Untitled

:- consult('grille.pl').

/* Spécifications de notre jeu
	- : case vide
	x : coup joué par l'utilisateur
	o : coup joué par l'IA
*/

/*********************************************************
Fonctions aidant à la logique applicative
*********************************************************/
/*vérifie si un nombre est entre 0 et une borne supérieure N*/
range(X,X).
range(X,N) :- X > 0, X < N.

/* Incrémente un nombre X */
incremente_nombre(X, X1) :- X1 is X + 1.

/*retourne une copie/abstraction de la variable*/
abstraire(A, A).

/*Associe un numéro de colonne à une liste */
associer_liste_colonne([], _, 8, _).
associer_liste_colonne([H|_], C, N, M):- H = C, M is N.
associer_liste_colonne([_|T], C, N, M):- N1 is N+1, associer_liste_colonne(T, C, N1, M).

/* Trouvre la première colonne qui est libre */
trouve_colonne_vide([], 8, _).
trouve_colonne_vide([H|T], N, M):- not(member('-', H)), N1 is N+1, trouve_colonne_vide(T, N1, M).
trouve_colonne_vide([H|_], N, M):-M is N, member('-', H).

/* find 3 characters in 3 lists are at the same indices, or increasing decreasing order */
row3(X,Y,Z):- length(X,N),length(Y,N),length(Z,N).
rightD3(X,Y,Z):- length(X,N1),length(Y,N2),length(Z,N3), N2 is N1+1, N3 is N2+1.
leftD3(X,Y,Z):- length(X,N1),length(Y,N2),length(Z,N3), N2 is N1-1, N3 is N2-1.


/*********************************************************
Fin de la section sur les fonctions aidant à la logique applicative
*********************************************************/

/*Point d'entrée du programme*/
commencer :- write('Bonjour, veuillez chosir votre prochain coup par le biais du clavier (touches 1 a 7) \n\r'), nl,
				get_grille(X),
				afficher_grille(X), nl, nl,
				mouvement_joueur(X, _).


/*Vérifie si l'utilisateur entre un numéro de colonne cohérent*/
lecture_no_colonne(X) :- nl,
                          write("*---------------------------*"), nl,
						  write("|                           |"), nl,
                          write("|Entrer le numero de colonne|"), nl,
                          read(NoColonne),
                          write("|                           |"), nl,
                          write("*---------------------------*"), nl,nl,
						  integer(NoColonne),range(NoColonne,7) ->  X is NoColonne;
						  write('Le numero de colonne est invalide').


/*Trouve une colonne libre pour le jeton*/
trouver_colonne(Jeton, [A|B], [A|B2], N, M) :- N \== M,incremente_nombre(M, M2),abstraire(A, A),trouver_colonne(Jeton, B, B2, N, M2).

/*Ajoute un jeton à une colonne*/
trouver_colonne(Jeton, [A|B], [A1|B], N, M) :- N == M,abstraire(B, B),insere_jeton_colonne(Jeton, A, A1).

/*Deplace un jeton dans une colonne spécifique */
deplacer_jeton(Jeton, grille(Y), grille(Y2), N) :- trouver_colonne(Jeton, Y, Y2, N, 1).

/* Mouvement de base de l'utilisateur */
mouvement_joueur(X, X2) :- lecture_no_colonne(N),
						   deplacer_jeton('x', X, X2, N),
						   afficher_grille(X2), nl, nl,
						   changer_tour('o', X2, _).

/* vérifications concernant les déplacements de jeton et déplacement d'un jeton */
insere_jeton_colonne(X, ['-'], [X]).
insere_jeton_colonne(X, ['-', A|B], [X, A|B]) :- A \== '-'.
insere_jeton_colonne(X, ['-', A|B], ['-', A1|B1]) :- (A == '-'),
insere_jeton_colonne(X, [A|B], [A1|B1]).
insere_jeton_colonne(_, [A|_], _) :- A \== '-',write('Votre coup etait hors des limites de la grille, vous avez ete redirige vers une nouvelle partie.'), nl, commencer.

/* Logique concernant le changement de tour et la victoire d'une partie */
changer_tour('o', X, _) :- etat_final_humain(X, 'x').
changer_tour('x', X, _) :- etat_final_ordi(X, 'o').
changer_tour(_, X, _):- etat_final_egal(X).
changer_tour('o', X, X2) :- analyseIA(X, X2).
changer_tour('x', X, X2) :- mouvement_joueur(X, X2).


/*********************************************************
Logique concernant la gestion d'une victoire ou partie nulle
*********************************************************/
/* colonne de quatre */
etat_final(grille(X), R):- append(_,[C|_], X) ,
                          append(_,[R,R,R,R|_],C).


/* rangee de quatre, ou diagonale de chaque direction */
etat_final(grille(X), R):-
    append(_,[Col1, Col2, Col3, Col4|_], X),
    append(P1, [R|_], Col1),
    append(P2, [R|_], Col2),
    append(P3, [R|_], Col3),
    append(P4, [R|_], Col4),
 (row(P1,P2,P3,P4) ; rightD(P1,P2,P3,P4) ; leftD(P1,P2,P3,P4)).


/* partie nulle*/
etat_final(grille([])).
etat_final(grille([H|T])):- not(member('-', H)), etat_final(grille(T)).


/* fonctions pour determiner si c'est une rang�e, ou diagonale. */
row(W,X,Y,Z):- length(W,N),length(X,N),length(Y,N),length(Z,N).
rightD(W,X,Y,Z):- length(W,N1),length(X,N2),length(Y,N3),length(Z,N4), N2 is N1+1, N3 is N2+1, N4 is N3+1.
leftD(W,X,Y,Z):- length(W,N1),length(X,N2),length(Y,N3),length(Z,N4), N2 is N1-1, N3 is N2-1, N4 is N3-1.


/*Les états conclusifs. Dependant du gagnant, un message different s'affiche. */
etat_final_humain(X, R):- etat_final(X, R), R = 'x', write_gagnant(), nl, nl.
etat_final_ordi(X, R):- etat_final(X, R), R = 'o', write_perdant(), nl, nl.
etat_final_egal(X):- etat_final(X), write('Partie Nul!').

write_gagnant() :- write_haut(),
                   write("|--+  Vous avez gagne !  +--|"), nl,
                   write_bas().

write_perdant() :- write_haut(),
                   write("|--+  Vous avez perdu !  +--|"), nl,
                   write_bas().

write_haut() :- write("+--------+----*----+--------+"), nl,
                write("|------+             +------|"), nl,
                write("|----+                 +----|"), nl.

write_bas() :-  write("|----+                 +----|"), nl,
                write("|------+             +------|"), nl,
                write("+--------+----*----+--------+").


/*********************************************************
Fin de la section sur la logique concernant la gestion d'une victoire ou partie nulle
*********************************************************/


/* JOUEUR IA */
/* Ici, l'ordi a plusieurs actions qu'il peut completer. En ordre de priorite:
 *  1. Bloque une colonne, rangee, ou diagonale gagnante du joueur
 *  humain.
 *  2. Jouer un jeton gagnant.
 *  3. Bloque l'avance d'un joueur qui pourrait l'amener a gagner.
 *  4. Joueur un jeton adjacent a ses autres, pour s'avancer vers une
 *  victoire.
 *  5. Dans le cas ou aucune de ses actions demeurent possible,
 *  l'ordinateur joue dans une colonne vide. */
/* L'ordinateur cherche une colonne ou les conditions s'appliquent, et il joue dans la colonne. */

/* colonne de 3 */
analyseIA(grille(X), X2):- (append(,[C|_], X), append(,['-','x','x','x'|_],C)) ->
							(associer_liste_colonne(X, C, 1, M), member('-', C), coup_IA(X, X2, M)).

analyseIA(grille(X), X2):- (append(,[C|_], X), append(,['-','o','o','o'|_],C)) ->
						   (associer_liste_colonne(X, C, 1, M), member('-', C), coup_IA(X, X2, M)).

/* rangee, ou diagonale de deux ou plus */
analyseIA(grille(X), X2):-
    (append(_,[Col1, Col2, Col3|_], X)
    append(P1, ['-'|_], Col1),
    append(P2, ['o'|_], Col2),
    append(P3, ['o'|_], Col3),    (row3(P1,P2,P3); rightD3(P1,P2,P3); leftD3(P1,P2,P3)))
    -> (associer_liste_colonne(X, Col3, 1, M),
       member('-', Col3),
       coup_IA(X, X2, M)).

analyseIA(grille(X), X2):-
    (   append(_,[Col1, Col2, Col3|_], X),
    append(P1, ['o'|_], Col1),
    append(P2, ['o'|_], Col2),
    append(P3, ['-'|_], Col3),    (row3(P1,P2,P3); rightD3(P1,P2,P3); leftD3(P1,P2,P3)))
    -> (associer_liste_colonne(X, Col1, 1, M),
       member('-', Col1),
       coup_IA(X, X2, M)).

analyseIA(grille(X), X2):-
    (   append(_,[Col1, Col2, Col3|_], X),
    append(P1, ['x'|_], Col1),
    append(P2, ['x'|_], Col2),
    append(P3, ['-'|_], Col3),    (row3(P1,P2,P3); rightD3(P1,P2,P3); leftD3(P1,P2,P3)))
    -> (associer_liste_colonne(X, Col3, 1, M),
       member('-', Col3),
       coup_IA(X, X2, M)).

analyseIA(grille(X), X2):-
    (   append(_,[Col1, Col2, Col3|_], X),
    append(P1, ['-'|_], Col1),
    append(P2, ['x'|_], Col2),
    append(P3, ['x'|_], Col3),    (row3(P1,P2,P3); rightD3(P1,P2,P3); leftD3(P1,P2,P3)))
    -> (associer_liste_colonne(X, Col1, 1, M),
       member('-', Col1),
       coup_IA(X, X2, M)).

/* colonne de deux */
analyseIA(grille(X), X2):- (append(_,[C|_], X),
                         append(_,['-','-','x','x'|_],C))
                       ->(associer_liste_colonne(X, C, 1, M),
                         member('-', C),
                           coup_IA(X, X2, M)).
analyseIA(grille(X), X2):- (append(_,[C|_], X),
                         append(_,['-','-','o','o'|_],C))
                       ->(associer_liste_colonne(X, C, 1, M),
                         member('-', C),
                           coup_IA(X, X2, M)).
/* colonne de un 'o' */
analyseIA(grille(X), X2):- (append(_,[C|_], X),
                         append(_,['-','-','-','o'|_],C))
                       ->(associer_liste_colonne(X, C, 1, M),
                         member('-', C),
                           coup_IA(X, X2, M)).


/*  dans le cas exception ou aucune des conditions s'appliquent */
analyseIA(grille(X), X2):- trouve_colonne_vide(X, 1, M),coup_IA(X, X2, M).

/*  l'action de jouer un jeton */
coup_IA(X, X2, C):-  deplacer_jeton('o', grille(X), X2, C),
                          afficher_grille(X2), nl, nl,
                          changer_tour('x', X2, _).