% Autor:
% Fecha: 28/05/2010

% Author: LFaletti y RFerroMoreno

% Prolog

:- dynamic recorrido/3.

:- dynamic ocupado/3.

%:- dynamic recorrido/3.

%jugada_Valida(COLOR,X,Y):-not ocupado(COLOR,X,Y), not suicidio(COLOR,X,Y).

jugada_Valida(COLOR,X,Y):- not(ocupado(_,X,Y)).



%es_capturada(COLOR,X,Y):-es_capturada(

%suicidio(b,X,Y):-





%solve(C,1):-clause(C,B), B==true.

%solve((C,C2),CANT):-solve(C,CANT1),solve(C2,CANT2),CANT is CANT1+CANT2.

%solve(C,CANT):-clause(C,BODY), BODY\==true, solve(BODY,CANT2), CANT is CANT2+1.





solve(true).

solve((A,B)):- solve(A), solve(B).

solve(A):- clause(A,B), B\==true, solve(B).



and(A,B):- solve(A), solve(B).

andE(A,B,C,D):- solve(A), solve(B), solve(C), solve(D).



%capt(C,X,Y):- X1 is X-1, X2 is X+1, Y1 is Y-1, Y2 is Y+1, NC\==C,

%              (ocupado(NC,X1,Y) ; (ocupado(C,X1,Y), recorrido(C,X1,Y)) ; (ocupado(C,X1,Y),not(recorrido(C,X1,Y)), assert(recorrido(C,X,Y)), capt(C,X1,Y), retract(recorrido(C,X,Y)))),

%              (ocupado(NC,X2,Y) ; (ocupado(C,X2,Y), recorrido(C,X2,Y)) ; (ocupado(C,X2,Y),not(recorrido(C,X2,Y)), assert(recorrido(C,X,Y)), capt(C,X2,Y), retract(recorrido(C,X,Y)))),

%              (ocupado(NC,X,Y1) ; (ocupado(C,X,Y1), recorrido(C,X,Y1)) ; (ocupado(C,X,Y1),not(recorrido(C,X,Y1)), assert(recorrido(C,X,Y)), capt(C,X,Y1), retract(recorrido(C,X,Y)))),

%              (ocupado(NC,X,Y2) ; (ocupado(C,X,Y2), recorrido(C,X,Y2)) ; (ocupado(C,X,Y2),not(recorrido(C,X,Y2)), assert(recorrido(C,X,Y)), capt(C,X,Y2), retract(recorrido(C,X,Y)))).



% capt(C,X,Y):- X1 is X-1, X2 is X+1, Y1 is Y-1, Y2 is Y+1, NC\==C,
%               ocupado(C1,X1,Y),
%               ocupado(C2,X2,Y),
%               ocupado(C3,X,Y1),
%               ocupado(C4,X,Y2),
%               (ocupado(NC,X1,Y) ; (ocupado(C,X1,Y), recorrido(C,X1,Y)) ; (ocupado(C,X1,Y),not(recorrido(C,X1,Y)),recorrido(C,X,Y),capt(C,X1,Y)) ; (ocupado(C,X1,Y),not(recorrido(C,X1,Y)), not(recorrido(C,X,Y)), assert(recorrido(C,X,Y)), capt(C,X1,Y))),
%
%               (ocupado(NC,X2,Y) ; (ocupado(C,X2,Y), recorrido(C,X2,Y)) ; (ocupado(C,X2,Y),not(recorrido(C,X2,Y)),recorrido(C,X,Y),capt(C,X2,Y)) ; (ocupado(C,X2,Y),not(recorrido(C,X2,Y)), not(recorrido(C,X,Y)), assert(recorrido(C,X,Y)), capt(C,X2,Y))),
%
%               (ocupado(NC,X,Y1) ; (ocupado(C,X,Y1), recorrido(C,X,Y1)) ; (ocupado(C,X,Y1),not(recorrido(C,X,Y1)),recorrido(C,X,Y),capt(C,X2,Y)) ; (ocupado(C,X,Y1),not(recorrido(C,X,Y1)), not(recorrido(C,X,Y)), assert(recorrido(C,X,Y)), capt(C,X,Y1))),
%
%               (ocupado(NC,X,Y2) ; (ocupado(C,X,Y2), recorrido(C,X,Y2)) ; (ocupado(C,X,Y2),not(recorrido(C,X,Y2)),recorrido(C,X,Y),capt(C,X,Y2)) ; (ocupado(C,X,Y2),not(recorrido(C,X,Y2)), not(recorrido(C,X,Y)), assert(recorrido(C,X,Y)), capt(C,X,Y2))).

limpiar:-retractall(recorrido(X,Y,Z)).

% verificar_captura(b,X,Y):-X1 is X-1, ocupado(n,X1,Y),capt(n,X1,Y).
% verificar_captura(b,X,Y):-X2 is X+1, ocupado(n,X2,Y),capt(n,X2,Y).
% verificar_captura(b,X,Y):-Y1 is Y-1, ocupado(n,X,Y1),capt(n,X,Y1).
% verificar_captura(b,X,Y):-Y2 is Y+1, ocupado(n,X,Y2),capt(n,X,Y2).
%
% verificar_captura(n,X,Y):-X1 is X-1, ocupado(b,X1,Y),capt(b,X1,Y).
% verificar_captura(n,X,Y):-X2 is X+1, ocupado(b,X2,Y),capt(b,X2,Y).
% verificar_captura(n,X,Y):-Y1 is Y-1, ocupado(b,X,Y1),capt(b,X,Y1).
% verificar_captura(n,X,Y):-Y2 is Y+1, ocupado(b,X,Y2),capt(b,X,Y2).

capt(b,X,Y):- X1 is X-1, X2 is X+1, Y1 is Y-1, Y2 is Y+1,
              ocupado(C1,X1,Y),
              ocupado(C2,X2,Y),
              ocupado(C3,X,Y1),
              ocupado(C4,X,Y2),
              ( ocupado(n,X1,Y) ; ocupado(p,X1,Y) ; ( ocupado(b,X1,Y), (recorrido(b,X1,Y) ; (not(recorrido(b,X1,Y)), assert(recorrido(b,X,Y)), capt(b,X1,Y))))),

              ( ocupado(n,X2,Y) ; ocupado(p,X2,Y) ; ( ocupado(b,X2,Y), (recorrido(b,X2,Y) ; (not(recorrido(b,X2,Y)), assert(recorrido(b,X,Y)), capt(b,X2,Y))))),

              ( ocupado(n,X,Y1) ; ocupado(p,X,Y1) ; ( ocupado(b,X,Y1), (recorrido(b,X,Y1) ; (not(recorrido(b,X,Y1)), assert(recorrido(b,X,Y)), capt(b,X,Y1))))),

              ( ocupado(n,X,Y2) ; ocupado(p,X,Y2) ; ( ocupado(b,X,Y2), (recorrido(b,X,Y2) ; (not(recorrido(b,X,Y2)), assert(recorrido(b,X,Y)), capt(b,X,Y2))))).

capt(n,X,Y):- X1 is X-1, X2 is X+1, Y1 is Y-1, Y2 is Y+1,
              ocupado(C1,X1,Y),
              ocupado(C2,X2,Y),
              ocupado(C3,X,Y1),
              ocupado(C4,X,Y2),
              ( ocupado(b,X1,Y) ; ocupado(p,X1,Y) ; ( ocupado(n,X1,Y), (recorrido(n,X1,Y) ; (not(recorrido(n,X1,Y)), assert(recorrido(n,X,Y)), capt(n,X1,Y))))),

              ( ocupado(b,X2,Y) ; ocupado(p,X2,Y) ; ( ocupado(n,X2,Y), (recorrido(n,X2,Y) ; (not(recorrido(n,X2,Y)), assert(recorrido(n,X,Y)), capt(n,X2,Y))))),

              ( ocupado(b,X,Y1) ; ocupado(p,X,Y1) ; ( ocupado(n,X,Y1), (recorrido(n,X,Y1) ; (not(recorrido(n,X,Y1)), assert(recorrido(n,X,Y)), capt(n,X,Y1))))),

              ( ocupado(b,X,Y2) ; ocupado(p,X,Y2) ; ( ocupado(n,X,Y2), (recorrido(n,X,Y2) ; (not(recorrido(n,X,Y2)), assert(recorrido(n,X,Y)), capt(n,X,Y2))))).


verif(b,X,Y):-X1 is X-1, X2 is X+1, Y1 is Y-1, Y2 is Y+1,
              ( color_capturado(n,X1,Y);color_capturado(n,X2,Y);color_capturado(n,X,Y1);color_capturado(n,X,Y2) ).

verif(n,X,Y):-X1 is X-1, X2 is X+1, Y1 is Y-1, Y2 is Y+1,
                 ( color_capturado(b,X1,Y);color_capturado(b,X2,Y);color_capturado(b,X,Y1);color_capturado(b,X,Y2) ).


algun_vacio(X,Y):- X1 is X-1, X2 is X+1, Y1 is Y-1, Y2 is Y+1,
                   ( not(ocupado(C1,X1,Y)) ; not(ocupado(C2,X2,Y)) ; not(ocupado(C3,X,Y1)) ; not(ocupado(C4,X,Y2)) ).

colores_alrededor(X,Y,IZQ,DER,ARR,ABA):- X1 is X-1, X2 is X+1, Y1 is Y-1, Y2 is Y+1,
                                     ( (not(ocupado(IZQ,X1,Y)), IZQ=v) ; ocupado(IZQ,X1,Y) ),
                                     ( (not(ocupado(DER,X2,Y)), DER=v) ; ocupado(DER,X2,Y) ),
                                     ( (not(ocupado(ABA,X,Y1)), ABA=v) ; ocupado(ABA,X,Y1) ),
                                     ( (not(ocupado(ARR,X,Y2)), ARR=v) ; ocupado(ARR,X,Y2) ).


%fucking mierda pero buscar no debe fallar nunca porque es un recorredor!
buscar(C,X,Y):-X1 is X-1, X2 is X+1, Y1 is Y-1, Y2 is Y+1,
                  %visitar
                  assert(recorrido(C,X,Y)),
                  %si a izquierda mismo color y no recorrido ent. buscar y no fallar, sino no fallar.
                  ( (ocupado(C,X1,Y), not(recorrido(C,X1,Y)), buscar(C,X1,Y)); ( not(ocupado(C,X1,Y));recorrido(C,X1,Y)) ),
                  %si a derecha mismo color y no recorrido ent. buscar y no fallar, sino no fallar.
                  ( (ocupado(C,X2,Y), not(recorrido(C,X2,Y)), buscar(C,X2,Y)); ( not(ocupado(C,X2,Y));recorrido(C,X2,Y)) ),
                  % arriba
                  ( (ocupado(C,X,Y2), not(recorrido(C,X,Y2)), buscar(C,X,Y2)); ( not(ocupado(C,X,Y2));recorrido(C,X,Y2)) ),
                  % abajo
                  ( (ocupado(C,X,Y1), not(recorrido(C,X,Y1)), buscar(C,X,Y1)); ( not(ocupado(C,X,Y1));recorrido(C,X,Y1)) ).


%Un color y coordenadas de punto de partida para buscar (por C)
color_capturado(C,X,Y):- %limpiar cualquier recorrido anterior
                         retractall(recorrido(X,Y,Z)),
                         %obtener bloque hipoteticamente capturado
                         buscar(C,X,Y),
                         % Verificar que cada ficha del bloque tiene en sus adyacentes:
                         %  una ficha de color contrario,
                         %  o bien una ficha del mismo color.

                         % Buscar por todos los recorridos tales que tengan algun espacio vacío alrededor
                         % si R es vacío entonces el conjunto está capturado por el color contrario,
                         % sino no hay captura
                         findall([X_,Y_], ( recorrido(C,X_,Y_),algun_vacio(X_,Y_) ), R),
                         R==[]. %hay captura.

verificar_captura(b,X,Y):-X1 is X-1, ocupado(n,X1,Y),color_capturado(n,X1,Y).
verificar_captura(b,X,Y):-X2 is X+1, ocupado(n,X2,Y),color_capturado(n,X2,Y).
verificar_captura(b,X,Y):-Y1 is Y-1, ocupado(n,X,Y1),color_capturado(n,X,Y1).
verificar_captura(b,X,Y):-Y2 is Y+1, ocupado(n,X,Y2),color_capturado(n,X,Y2).

verificar_captura(n,X,Y):-X1 is X-1, ocupado(b,X1,Y),color_capturado(b,X1,Y).
verificar_captura(n,X,Y):-X2 is X+1, ocupado(b,X2,Y),color_capturado(b,X2,Y).
verificar_captura(n,X,Y):-Y1 is Y-1, ocupado(b,X,Y1),color_capturado(b,X,Y1).
verificar_captura(n,X,Y):-Y2 is Y+1, ocupado(b,X,Y2),color_capturado(b,X,Y2).