% Auteur: Ira
% Date: 09/11/2010

% max( +, +, ? )
% max..
max( X, Y, X ) :- X >= Y, !.
max( _, Y, Y ) :- !.

% min( +, +, ? )
% min quoi ~~
min( X, Y, X ) :- X =< Y, !.
min( _, Y, Y ) :- !.

% minListe( +, ? )
% Retroune le plus petit nombre dans la liste
minListe( [X], X ).
minListe( [X, Y | Reste], Min ) :-
         minListe( [Y | Reste], MinReste ),
         min( X, MinReste, Min ),
         !.

% minListe( +, ? )
% Retroune le plus grand nombre dans la liste
maxListe( [X], X ).
maxListe( [X, Y | Reste], Max ) :-
         maxListe( [Y | Reste ], MaxReste ),
         max( X, MaxReste, Max ),
         !.

% ls_minX( +, +, ? )
% Renvoi le couple [X,Y] dont la composante X est la plus faible
% parmir les deux couples founi
% Si deux couples ont une composante X identique, celui avec la plus
% faible composante Y sera renvoyé (pour tester les carrés)
ls_minX( [A,X], [B,_], [A,X] ) :-
         B > A,
         !.

ls_minX( [A,X], [B,Y], [A,X] ) :-
         B =:= A,
         X =< Y,
         !.

ls_minX( _, [B,Y], [B,Y] ).

% ls_minListeX( +, ? )
% Renvoi le couple [X,Y] dont la composante X est la plus faible
% parmi la liste de couple fournie
ls_minListeX( [[A,X]], [A,X] ):- !.
ls_minListeX( [[A,X],[B,Y] | Reste], Min ) :-
              ls_minListeX( [[B,Y] | Reste], MinReste ),
              ls_minX( [A,X], MinReste, Min ),
              !.

% chk_line_ord( + )
% Verifie si c'est une ligne, les points doivent etre ordonnés (useless ?)
% chk_line_ord( [[1,1],[2,1],[3,1],[4,1]] ).
chk_line_ord( [[A,Y],[B,Y],[C,Y],[D,Y]] ) :-
              ( A =:= 0; A =:= 1 ),
              D =:= C+1,
              C =:= B+1,
              B =:= A+1,
              !.

% chk_row_ord( + )
% Verifie si c'est une colonne, les points doivent etre ordonnés (useless ?)
% chk_row_ord( [[0,0],[0,1],[0,2],[0,3]] ).
chk_row_ord( [[X,A],[X,B],[X,C],[X,D]] ) :-
             ( A =:= 0; A =:= 1 ),
             D =:= C+1,
             C =:= B+1,
             B =:= A+1,
             !.

% chk_suite( + )
% Vérifie si la liste de nombre fournie forme une suite
% chk_suite( [2,3,4,1] ).
chk_suite( [A,B,C,D] ) :-
           minListe( [A,B,C,D], Min ),
           ( Min =:= 0 ; Min =:= 1 ),
           chk_plus( [A,B,C,D], Min ),
           N is Min+1,
           chk_plus( [A,B,C,D], N ),
           N2 is N+1,
           chk_plus( [A,B,C,D], N2 ),
           !.

% chk_plus( +, + )
% Vérifie si N+1 est présent dans la liste fournie
chk_plus( [H|_], N ) :-
          H =:= N+1,
          !.

chk_plus( [_|R], N ) :-
          chk_plus( R, N ),
          !.

% chk_plus_diag_down( +, + )
% regarde si un couple [X+1,Y+1] existe dans la liste pour un couple
% [X,Y] donné
chk_plus_diag_down( [[X,Y]|_], [Xa,Ya] ) :-
               X =:= Xa+1,
               Y =:= Ya+1,
               !.

chk_plus_diag_down( [_|R], N ) :-
               chk_plus_diag_down( R, N ),
               !.

% chk_plus_diag_down( +, + )
% regarde si un couple [X+1,Y-1] existe dans la liste pour un couple
% [X,Y] donné
chk_plus_diag_up( [[X,Y]|_], [Xa,Ya] ) :-
               X =:= Xa+1,
               Y =:= Ya-1,
               !.

chk_plus_diag_up( [_|R], N ) :-
             chk_plus_diag_up( R, N ),
             !.

% chk_plus_right( +, + )
% regarde si un couple [X+1,Y] existe dans la liste pour un couple
% [X,Y] donné
chk_plus_right( [[X,Y]|_], [Xa,Ya] ) :-
               X =:= Xa+1,
               Y =:= Ya,
               !.

chk_plus_right( [_|R], N ) :-
             chk_plus_right( R, N ),
             !.

% chk_plus_bottom( +, + )
% regarde si un couple [X,Y+1] existe dans la liste pour un couple
% [X,Y] donné
chk_plus_bottom( [[X,Y]|_], [Xa,Ya] ) :-
               X =:= Xa,
               Y =:= Ya+1,
               !.

chk_plus_bottom( [_|R], N ) :-
             chk_plus_bottom( R, N ),
             !.

% chk_line( + )
% Véfirie si la liste de couple [X,Y] fournie forme une ligne
chk_line( [[A,Y],[B,Y],[C,Y],[D,Y]] ) :-
          chk_suite( [A,B,C,D] ),
          !.

% chk_row( + )
% Véfirie si la liste de couple [X,Y] fournie forme une colonne
chk_row( [[X,A],[X,B],[X,C],[X,D]] ) :-
          chk_suite( [A,B,C,D] ),
          !.

% chk_diag( + )
% Véfirie si la liste de couple [X,Y] fournie forme une diagonale
chk_diag( L ) :-
          ls_minListeX( L, [X,Y] ),
          X >= 0,
          X =< 1,
          ( chk_diag_down( L, X, Y ) ; chk_diag_up( L, X, Y ) ),
          !.

% chk_diag_down( +, +, + )
% Verifie si une diagonale descendante est présente
chk_diag_down( L, X, Y ) :-
               Y >= 0,
               Y =< 1,
               chk_plus_diag_down( L, [X,Y] ),
               X2 is X+1,
               Y2 is Y+1,
               chk_plus_diag_down( L, [X2,Y2] ),
               X3 is X2+1,
               Y3 is Y2+1,
               chk_plus_diag_down( L, [X3,Y3] ).

% chk_diag_up( +, +, + )
% Verifie si une diagonale montante est présente
chk_diag_up( L, X, Y ) :-
             Y >= 3,
             Y =< 4,
             chk_plus_diag_up( L, [X,Y] ),
             X2 is X+1,
             Y2 is Y-1,
             chk_plus_diag_up( L, [X2,Y2] ),
             X3 is X+2,
             Y3 is Y-2,
             chk_plus_diag_up( L, [X3,Y3] ).

% chk_square( + )
% Verifie si un carré est présent dans la liste
% chk_square( [[0,0],[1,1],[0,1],[1,0]] ).
chk_square( L ) :-
            ls_minListeX( L, [X,Y] ),
            chk_plus_right( L, [X,Y] ),
            chk_plus_bottom( L, [X,Y] ),
            chk_plus_diag_down( L, [X,Y] ).

% win( + )
% Détermine si la partie est gagnée pour la liste des pions donnée
% (oue spas francais, osef)
% win( [ [0,0],[0,1],[0,3],[0,2] ] ).
% win( [ [2,3],[1,3],[3,3],[4,3] ] ).
% win( [ [0,1],[2,3],[1,2],[3,4] ] ).
% win( [ [2,3],[1,4],[3,2],[4,1] ] ).
% win( [ [0,0],[1,1],[0,1],[1,0] ] ).
win( L ) :-
     ( chk_line( L ), ! );
     ( chk_row( L ), ! );
     ( chk_diag( L ), ! );
     chk_square( L ).