% Genere elementos desde un rango de números.
% ?- barajar(5,9,X).
% X = [5,6,7,8,9]
%Mantiene el banco de las cuarenta cartas en orden ascendente
cartas([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40]).
%********************************************************
%***********Simulando el primer paso del juego***********
%**********************Barajar***************************
%********************************************************
%Fin de recursividad de la generacion de los numeros
barajar(1,2,[],C):-!.
%Se hace solo primera vez, para cargar el banco
barajar(1,43,X,C):-
cartas(C2),
barajar(1,42,X,C2),!.
%Generacion de numeros aleatorios, entre un un limite
%inicial y un final. El limite final se decrementa
%en 1 en cada repeticion.
%Con el numero generado buscamos su ubicacion el la lista
%de cartas del banco -C-, obtenemos su valor y lo eliminamos
%de esta forma logramos sacar un archivo con todas las
%cartas pero en orden aleatorio.
barajar(1,Rf,[X|Ws],C):-
M is Rf -1,
random(1,M,Num),
elimina_elemento(C,Num,X,C2),
barajar(1,M,Ws,C2),
open('banco.txt',write,A),
write(A,[X|Ws]),
close(A).
%Eliminamos el elemento de una lista de acuerdo a la posicion
%y recuperamos el elemento eliminado.
elimina_elemento([X|Xc],1,X,Xc):-!.
elimina_elemento([X|Xc],N,E,[X|Ws]):-
M is N-1,
elimina_elemento(Xc,M,E,Ws).
%************************************
%Cartas para el jugador1
repartirJ1(C,0,[]):-!.
repartirJ1([X|Xc],N,[X|Cj1]):-
open('banco.txt',write,B),
write(B,Xc),
close(B),
M is N-1,
repartirJ1(Xc,M,Cj1),
ord_quicksort([X|Cj1],Ord),
open('cj1.txt',write,A),
write(A,Ord),
close(A).
cargar(C,0,[]):-!.
cargar([X|Xc],N,[X|Cj1]):-
M is N-1,
cargar(Xc,M,Cj1),
ord_quicksort([X|Cj1],Ord),
open('cj1.txt',write,A),
write(A,Ord),
close(A).
%************************************
%Cartas Pc
%
repartirPc(C,0,[]):-!.
repartirPc([X|Xc],N,[X|Cj1]):-
open('banco.txt',write,B),
write(B,Xc),
close(B),
M is N-1,
repartirJ1(Xc,M,Cj1),
ord_quicksort([X|Cj1],Ord),
open('cpc.txt',write,A),
write(A,Ord),
close(A).
%***********************************
tomarresto([C|Xc]):-
open('resto.txt',write,A),
write(A,Xc),
close(A).
tomarbanco([C|Xc]):-
open('banco.txt',write,A),
write(A,Xc),
close(A).
%***********************************
%Posicion de la PosCartaJugadorPc,Resto,CartasPc
lanzarcartaPc(C,R,J):-
eliminar(J,C,C,J2),
open('cpc.txt',write,A),
write(A,J2),
close(A),
open('resto.txt',write,B),
write(B),
close(B).
%Posicion de la carta jugadorPc,Resto,CartasJ1
lanzarcartaJ1(C,R,J):-
eliminar(J,C,_,J2),
open('cj1.txt',write,A),
write(A,J2),
close(A).
%*************************************
%Ordenar cartas
ord_quicksort([],[]).
ord_quicksort([X|R],Ordenada) :-
divide(X,R,Menores,Mayores),
ord_quicksort(Menores,MenoresOrdenados),
ord_quicksort(Mayores,MayoresOrdenados),
append(MenoresOrdenados,
[X|MayoresOrdenados],
Ordenada).
divide(_,[],[],[]).
divide(X,[Y|R],[Y|Menores],Mayores) :-
Y<x>
divide(X,R,Menores,Mayores).
divide(X,[Y|R],Menores,[Y|Mayores]) :-
divide(X,R,Menores,Mayores).
ordenarPc(X):-
ord_quicksort(X,C),
open('cpc.txt',write,A),
write(A,C),
close(A).
ordenarJ1(X):-
ord_quicksort(X,C),
open('cj1.txt',write,A),
write(A,C),
close(A).
%***************************************************
secuencia([1,2,3,4,5,6,7,8,9,10]).
secuencia([11,12,13,14,15,16,17,18,19,20]).
secuencia([21,22,23,24,25,26,27,28,29,30]).
secuencia([31,32,33,34,35,36,37,38,39,40]).
secuencia([1,8,9,10]).
secuencia([11,18,19,20]).
secuencia([21,28,29,30]).
secuencia([31,38,39,40]).
secuencia_esp([1,5,6,7,8,9,10]).
secuencia_esp([11,15,16,17,18,19,20]).
secuencia_esp([21,25,26,27,28,29,30]).
secuencia_esp([31,35,36,37,38,39,40]).
juego([1,11,21,31]).
juego([2,12,22,32]).
juego([3,13,23,33]).
juego([4,14,24,34]).
juego([5,15,25,35]).
juego([6,16,26,36]).
juego([7,17,27,37]).
juego([8,18,28,38]).
juego([9,19,29,39]).
juego([10,20,30,40]).
%**************************************************
% Verfica si una lista es parte de otra
parte_de([X|Xs],[X|Xs1]):-
comprueba([X|Xs],[X|Xs1]).
parte_de([X|Xs],M):-
parte_de(Xs,M).
comprueba([X|Xs],[X]).
comprueba([X|Xs],[X|Xs1]):-comprueba(Xs,Xs1).
%*************************************
% Separar juegos de mano
separar2([],[],_):-!.
separar2([W,X|Xc],[W,X],Xc):-
X is W+1,
A is X mod 10,
not(A=1),!.
separar2([W,X,Y|Xc],R,[W|Ss]):-
separar2([X,Y|Xc],R,Ss).
separar3([],[],_):-!.
separar3([W,X,Y|Xc],[W,X,Y],Xc):-
X is W+1,
Y is X+1,
A is Y mod 10,
not(A=1),
not(A=2),!.
separar3([W,X,Y|Xc],R,[W|Ss]):-
separar3([X,Y|Xc],R,Ss).
separar4([],[],_):-!.
separar4([W,X,Y,Z|Xc],[W,X,Y,Z],Xc):-
X is W+1,
Y is X+1,
Z is Y+1,
A is Z mod 10,
not(A=1),
not(A=2),
not(A=3),!.
separar4([W,X,Y,Z|Xc],R,[W|Ss]):-
separar4([X,Y,Z|Xc],R,Ss).
pares([],[],[]):-!.
pares([C|Cc],S2,R):-
pares2([C|Cc],C,R,S2),
length(S2,L),
L>=2.
pares([C|Cc],R,[C|S]):-
pares(Cc,R,S).
pares2([],_,[],[]):-!.
pares2([W|Wc],X,Rs,[W|Ss]):-
W2 is W mod 10,
X2 is X mod 10,
X2 is W2,
pares2(Wc,X,Rs,Ss).
pares2([W|Xc],X,[W|Rs],S):-
pares2(Xc,X,Rs,S).
%**************************************
cuatro(L,R,S):-
ord_quicksort(L,Lf),
separar4(Lf,R,S),
!.
cuatro(L,R,S):-
ord_quicksort(L,Lf),
pares(Lf,R,S),
length(R,Ln),
Ln=4,
!.
%************************************
tres(L,R,S):-
ord_quicksort(L,Lf),
separar3(Lf,R,S),
!.
tres(L,R,S):-
ord_quicksort(L,Lf),
pares(Lf,R,S),
length(R,Ln),
Ln=3,
!.
%************************************
dos(L,R,S):-
ord_quicksort(L,Lf),
separar2(Lf,R,S),
!.
dos(L,R,S):-
ord_quicksort(L,Lf),
pares(Lf,R,S),
length(R,Ln),
Ln=2,
!.
%************************************
%toma del resto
ganapc(L,C1,[C2|C2s],S,V):-
gana([C1|L],S,V,Res),
not(member(C1,Res)),
grabar([C1|L],S,V),
open('resto.txt',write,A),
write(A,S),
close(A),!.
%toma del banco
ganapc(L,C1,[C2|C2s],S,V):-
gana([C2|L],S,V,Res),
grabar([C2|L],S,V),
open('resto.txt',write,A),
write(A,S),
close(A),
open('banco.txt',write,B),
write(B,C2s),
close(B),!.
gana(L,S,V,[S|Sc]):-
cuatro(L,R,S1),
tres(S1,R1,[S|Sc]),
V is 1,
!.
gana(L,S,V,[S|Sc]):-
cuatro(L,R,S1),
dos(S1,R1,[S|Sc]),
V is 2,
!.
gana(L,S,V,[S|Sc]):-
cuatro(L,R,[S|Sc]),
V is 3,
!.
gana(L,S,V,[S|Sc]):-
tres(L,R,S1),
tres(S1,X,[S|Sc]),
V is 4,
!.
gana(L,S,V,[S|Sc]):-
tres(L,R,S1),
dos(S1,X,[S|Sc]),
V is 5,
!.
gana(L,S,V,[S|Sc]):-
tres(L,R,[S|Sc]),
V is 6,
!.
gana(L,S,V,[S|Sc]):-
dos(L,R,S1),
dos(S1,X,[S|Sc]),
V is 7,
!.
gana(L,S,V,[S|Sc]):-
dos(L,R,[S|Sc]),
V is 8,
!.
gana([L|Ls],S,L,[L|Ls]):-
V is 9,
!.
gane(L):-
gana(L,S,V,S2),
open('tmpj1.txt',write,B),
write(B,V),
close(B).
grabar(L,C,V):-
elimina(L,C,L2),
ord_quicksort(L2,Lf),
open('cpc.txt',write,A),
write(A,Lf),
close(A),
open('tmp.txt',write,B),
write(B,V),
close(B).
elimina([],_,[]):-!.
elimina([C|Ls],C,S):-
elimina(Ls,C,S).
elimina([C|Ls],X,[C|Ss]):-
elimina(Ls,X,Ss).
puntos(L,Sum):-
cuatro(L,R,S),
sumar(S,Sum).
puntos(L,Sum):-
tres(L,R,S),
tres(S,R1,S2),
sumar(S2,Sum).
puntos(L,Sum):-
tres(L,R,S),
tres(S,R1,S2),
sumar(S2,Sum).
puntos(L,Sum):-
sumar(L,Sum).
sumar([],0).
sumar([L|Ls],S):-
sumar(Ls,S2),
R is (L mod 10),
obtN(R,N),
S is S2+N.
obtN(0,10).
obtN(N,N).
puntosPc(L,Sum):-
puntos(L,Sum),
open('tmppc.txt',write,A),
write(A,Sum),
close(A).
puntosJ1(L,Sum):-
puntos(L,Sum),
open('tmpj1.txt',write,A),
write(A,Sum),
close(A).
No hay comentarios:
Publicar un comentario