private void ConsultaC()
{
ArbolGeneral <DatosJugada> minimaxAux = new ArbolGeneral <DatosJugada>(null);
minimaxAux = computer.getMinimax();
Console.WriteLine();
Console.WriteLine("Indique una profundidad");
string rta = Console.ReadLine();
bool aux = false;
while (aux == false) //Se comprueba que haya ingresado un valor coherente
{
try
{
Int32.Parse(rta);
aux = true; //Si puede parsear el valor sale del while e imprime en dicha profundidad
}
catch (Exception)
{
Console.WriteLine("El valor no es correcto. Intente de nuevo");
rta = Console.ReadLine();
}
}
Console.WriteLine("Se mostraran las cartas en el nivel " + rta + ". Oprima cualquier tecla para continuar");
Console.ReadKey();
computer.imprimirNivel(Int32.Parse(rta), minimaxAux);
}
public void recoridoPorNiveles(Cola <ArbolGeneral <int> > cola, Cola <ArbolGeneral <int> > colaRepe, int nivel)
{
if (cola.esVacia() == true)
{
Console.WriteLine("Se termino");
}
if (cola.esVacia() == false)
{
while (cola.esVacia() == false)
{
ArbolGeneral <int> arboli = cola.desencolar();
Console.Write(arboli.getDatoRaiz() + ", ");
colaRepe.encolar(arboli);
}
while (colaRepe.esVacia() == false)
{
ArbolGeneral <int> arbolito = colaRepe.desencolar();
foreach (ArbolGeneral <int> hijos in arbolito.getHijos())
{
cola.encolar(hijos);
}
}
if (nivel % 2 == 1)
{
Console.WriteLine("Usuario");
}
if (nivel % 2 == 0)
{
Console.WriteLine("Computer");
}
nivel++;
recoridoPorNiveles(cola, colaRepe, nivel);
}
}
public ArbolGeneral <int> InstalacionHeuristica(ArbolGeneral <int> ArbolMiniMax, bool Turno, int limite)
{
//Si mi funcion Heuristica, es decir si la base de mi ABGeneral tiene "getDatoRaiz=-1" gana Usuario
//si tiene "getDatoRaiz=-2" gana Maquina...
if (limite < 0)
{
//En el nodo de mi arbol que se sobrepase el limite se corta y se debe poner como hijo de este el dato heuristico (-1 gano maquina,-2 gano usuario)
//dependiendo de quien sea el turno.
if (Turno == true)
{
ArbolMiniMax.ConvertirEnHoja(); //El nodo en el que se alcanza el limite se convierte en Hoja y en este se agrega el dato heuristico
ArbolGeneral <int> Heuristic = new ArbolGeneral <int>(-1);
ArbolMiniMax.agregarHijo(Heuristic);
}
else
{
ArbolMiniMax.ConvertirEnHoja();
ArbolGeneral <int> Heuristic = new ArbolGeneral <int>(-2);
ArbolMiniMax.agregarHijo(Heuristic);
}
}
//Mientras no se supere el limite recorro los hijos de mi nodo
else
{
foreach (var hijo in ArbolMiniMax.getHijos())
{
int LimiteAux = limite - hijo.getDatoRaiz();
InstalacionHeuristica(hijo, !Turno, LimiteAux);
}
}
return(ArbolMiniMax);
}
public void ImprimirHojas(ArbolGeneral <DatosJugada> arbol)
{
Cola <ArbolGeneral <DatosJugada> > c = new Cola <ArbolGeneral <DatosJugada> >();
ArbolGeneral <DatosJugada> aux;
c.encolar(arbol); //encola minimax
while (!c.esVacia())
{
aux = c.desencolar();
if (!aux.esHoja())
{
foreach (var nodo in aux.getHijos())
{
c.encolar(nodo);
}
}
if (aux.esHoja() && aux.getDatoRaiz().valorDeConveniencia == 1)
{
Console.Write("|(" + aux.getDatoRaiz().carta + ")[Pierde]|, ");
}
if (aux.esHoja() && aux.getDatoRaiz().valorDeConveniencia == -1)
{
Console.Write("|(" + aux.getDatoRaiz().carta + ")[Gana], ");
}
}
}
public override int descartarUnaCarta()
{
int cartaJugada = 0;
//la primera vez referencia es null(recien arranca el arbol minimax)
foreach (ArbolGeneral <DatosJugada> cartas in referencia.getHijos()) //itera el nivel de cartas del humano (cuando referencia es el nivel de cartas de cumputer,
//referencia.getHijos sera de nuevo un nivel de cartas del humano)
{
if (cartas.getDatoRaiz().carta == UltimaCartaHumano) //busca la arbol que tenga como dato la carta que tiro el humano y se poseciona ahí
{
referencia = cartas; //Nos ubicamos en los hijos del arbol correspondiente a la carta que tiro el humano
foreach (ArbolGeneral <DatosJugada> cartatirar in cartas.getHijos()) //itera el nivel de cartas de computer que corresponde al arbol de la carta que tiro el humano.
{
if (cartatirar.getDatoRaiz().valorDeConveniencia == 1)
{
referencia = cartatirar; //deja ubicado el arbol en el nivel de computer
cartaJugada = cartatirar.getDatoRaiz().carta;
return(cartaJugada);
}
else
{
//Si no encuentra con valor 1 tirara la primera que encuentre
}
{
referencia = cartatirar; //deja ubicado el arbol en el nivel de computer
cartaJugada = cartatirar.getDatoRaiz().carta;
}
}
}
}
//referencia.porNiveles();
return(cartaJugada);
}
public ArbolGeneral <int> CompletarRama(ArbolGeneral <int> Hijo, List <int> CartasUsuario, List <int> CartasMaquina, bool Turno, int limite)
{
//Empieza Jugando Usuario->Turno=true(Juega Usuario)->Turno=false(Juega Maquina)
List <int> cartas = new List <int>();
if (Turno == true)
{
cartas.AddRange(CartasUsuario); //Si Juega Usuario guardo todas las cartas de este en la variable "cartas"
}
else
{
cartas.AddRange(CartasMaquina); //Si Juega Maquina guardo todas las cartas de este en la variable "cartas"
}
foreach (int carta in cartas) //Recorre la lista de cartas Correspondiente al Jugador
{
ArbolGeneral <int> hijo = new ArbolGeneral <int>(carta); //Realiza una instancia de ArbolGeneral con DatoRaiz carta
Hijo.agregarHijo(hijo); //Agrega al Arbol la instancia hijo creada anteriormente
int limiteaAux = limite - carta; //Decrementa el limite en base a el dato de la carta
List <int> cartasrestantes = new List <int>();
cartasrestantes.AddRange(cartas); //Guardo todas las cartas en lista cartas restantes
cartasrestantes.Remove(carta); // y elimino la carta que se esta recorriendo de la lista "cartas".
if (limite >= 0) //Si limite es menor a cero empieza a armar la siguiente rama
{
if (Turno == true)
{
CompletarRama(hijo, cartasrestantes, CartasMaquina, !Turno, limiteaAux); //Hace llamada recursiva cambia el turno, envia la lista con
} //la carta eliminada y el limite reducido
else
{
CompletarRama(hijo, CartasUsuario, cartasrestantes, !Turno, limiteaAux);
}
}
}
return(Hijo);
}
public void PorNiveles()
{
Cola <ArbolGeneral <T> > cola = new Cola <ArbolGeneral <T> >();
cola.encolar(this);
while (!cola.esVacia())
{
int n = cola.cantidad();
while (n > 0)
{
ArbolGeneral <T> p = cola.tope();
cola.desencolar();
Console.Write(p.getDatoRaiz() + " ");
foreach (var v in p.getHijos())
{
cola.encolar(v);
}
n--;
}
Console.WriteLine();
Console.WriteLine();
}
}
public void generarArbol(ArbolGeneral <Jugada> nodoCarta, List <int> cartasPropias, List <int> cartasOponente, int limite)
{
List <int> cartasPropiasSinJugar = new List <int>(cartasPropias);
cartasPropiasSinJugar.Remove(nodoCarta.getDatoRaiz().carta);
int limiteActualizado = nodoCarta.getDatoRaiz().limiteActual - nodoCarta.getDatoRaiz().carta;
if (limiteActualizado < 0)
{
if (nodoCarta.getDatoRaiz().miAI)
{
nodoCarta.getDatoRaiz().ganadas = -1;
}
else
{
nodoCarta.getDatoRaiz().ganadas = 1;
}
}
else
{
foreach (int cartaOponente in cartasOponente)
{
Jugada movimientoOponente = new Jugada(cartaOponente, limiteActualizado, 0, nodoCarta.getDatoRaiz().miAI);
ArbolGeneral <Jugada> nodoCartaOponente = new ArbolGeneral <Jugada>(movimientoOponente);
generarArbol(nodoCartaOponente, cartasOponente, cartasPropiasSinJugar, limiteActualizado);
nodoCarta.agregarHijo(nodoCartaOponente);
nodoCarta.getDatoRaiz().ganadas += nodoCartaOponente.getDatoRaiz().ganadas;
}
}
}
public void encolarParaRecorrer(ArbolGeneral <int> arbol)
{
Cola <ArbolGeneral <int> > cola = new Cola <ArbolGeneral <int> >();
Cola <ArbolGeneral <int> > colaVacia = new Cola <ArbolGeneral <int> >();
cola.encolar(arbol);
recoridoPorNiveles(cola, colaVacia, 0);
}
//Método inicializar crea árbol general con todos los estados posibles
public override void incializar(List <int> cartasPropias, List <int> cartasOponente, int limite)
{
this.raiz = new ArbolGeneral <int>(0);
this.estado = raiz;
bool turnoH = true;
_inicializar(cartasPropias, cartasOponente, limite, turnoH, this.raiz);
}
//Funcion para armar el arbol MiniMax, a partir del estadoInicial
private ArbolGeneral <Dupla> ArmarArbolMinimax(Estatus estado)
{
ArbolGeneral <Dupla> nuevo = new ArbolGeneral <Dupla>(new Dupla(0, 0));
ArmarArbolMinimaxAux(estado, nuevo);
return(nuevo);
}
public override void incializar(List <int> cartasPropias, List <int> cartasOponente, int limite)
{
bool turnoHumano = true;
estado = new Estado(cartasPropias, cartasOponente, limite, turnoHumano);
createArbol(estado, miniMax);
jugadaActual = miniMax;
consulta.setJugadaActual(jugadaActual);
}
public override void incializar(List <int> cartasPropias, List <int> cartasOponente, int limite)
{
Jugada comienzo = new Jugada(-1, limite, 0, true);
arbol = new ArbolGeneral <Jugada>(comienzo);
generarArbol(this.arbol, cartasPropias, cartasOponente, limite);
Console.WriteLine(this.arbol.getHijos().Count);
}
private void setEstado(int carta)
{
foreach (var nodo in estado.getHijos())
{
if (nodo.getDatoRaiz() == carta)
{
estado = nodo;
}
}
}
public override void cartaDelOponente(int carta)
{
foreach (var nodo in this.estado.getHijos())
{
if (nodo.getDatoRaiz() == carta)
{
this.estado = nodo;
}
}
}
public void imprimirNivel(int nivel, ArbolGeneral <DatosJugada> arbol)
{
Cola <ArbolGeneral <DatosJugada> > c = new Cola <ArbolGeneral <DatosJugada> >();
//ArbolGeneral<DatosJugada> aux;
int contador = 0;
bool NivelEncontrado = false;
c.encolar(referencia);
c.encolar(null);
while (!c.esVacia())
{
arbol = c.desencolar();
if (arbol != null)
{
if (contador == nivel)
{
NivelEncontrado = true;
if (arbol.getDatoRaiz().valorDeConveniencia == 1)
{
Console.Write(arbol.getDatoRaiz().carta + " " + "[Pierde], ");
}
if (arbol.getDatoRaiz().valorDeConveniencia == -1)
{
Console.Write(arbol.getDatoRaiz().carta + " " + "[Gana], ");
}
}
}
if (arbol == null)
{
if (!c.esVacia())
{
c.encolar(null);
}
contador++;
}
else
{
if (!referencia.esHoja())
{
foreach (var hijo in arbol.getHijos())
{
c.encolar(hijo);
}
}
}
}
if (NivelEncontrado == false)
{
Console.WriteLine("No se encontro la profunidad. Regresando al juego....");
}
}
public override void incializar(List <int> cartasPropias, List <int> cartasOponente, int limite)
{
DatosJugada datosJugada = new DatosJugada(0, limite, true);
minimax = new ArbolGeneral <DatosJugada>(datosJugada);
bool turno = true; //esta variable se debe declarar como atributo de clase
naipes = cartasPropias;
crearArbol(cartasPropias, cartasOponente, limite, turno, minimax);
Console.WriteLine(minimax.getHijos().Count);
}
public override void cartaDelOponente(int carta)
{
//lo que hay que hacer es elegir al hijo que corresponde a esa carta
//implementar
foreach (ArbolGeneral <DatosJugadas> hijo in this.arbol.getHijos())
{
if (hijo.getDatoRaiz().Carta == carta)
{
this.arbol = hijo;
return;
}
}
}
public override void cartaDelOponente(int carta)
{
ArbolGeneral <int> mejor = new ArbolGeneral <int>(0);
foreach (ArbolGeneral <int> NuevaRaiz in arbol.getHijos())
{
if (NuevaRaiz.getDatoRaiz() == carta)
{
arbol.setRaiz(NuevaRaiz.Raiz);
}
}
limite = limite - carta;
}
public override void cartaDelOponente(int cartaH)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("\nEl humano ha descartado la carta: " + cartaH.ToString() + "\n");
Console.ResetColor();
foreach (ArbolGeneral <Carta> hijo in jugadaActual.getHijos())
{
if (hijo.getDatoRaiz().getCarta() == cartaH)
{
jugadaActual = hijo; // jugada actual apunta a la carta que tiro el humano
break;
}
}
consulta.setJugadaActual(jugadaActual);
}
public void recorridoEntreNiveles(int a, int b)
{
if (esVacio())
{
return;
}
Cola <ArbolGeneral <T> > cola = new Cola <ArbolGeneral <T> >();
cola.encolar(this);
int nivel = 0;
while (!cola.esVacia())
{
nivel++;
int n = cola.cantidad();
while (n > 0)
{
ArbolGeneral <T> p = cola.tope();
cola.desencolar();
if (nivel >= a && nivel <= b)
{
Console.Write(p.getDatoRaiz() + " ");
}
if (!p.esVacio())
{
foreach (var v in p.getHijos())
{
cola.encolar(v);
}
}
n--;
}
if (nivel >= a && nivel <= b)
{
Console.WriteLine();
}
}
}
public override int descartarUnaCarta()
{
int mejoropcion = -1;
ArbolGeneral <int> nueopcion = null;
foreach (ArbolGeneral <int> opciones in arbol.getHijos())
{
if (opciones.Raiz.Datpri > mejoropcion)
{
nueopcion = opciones;
mejoropcion = opciones.Raiz.Datpri;
}
}
arbol.setRaiz(nueopcion.Raiz);
Console.WriteLine("La maquina escogio la carta " + nueopcion.getDatoRaiz());
return(nueopcion.getDatoRaiz());
}
public override int descartarUnaCarta()
{
Console.Write("Naipes disponibles (Maquina):");
for (int i = 0; i < naipesComputer.Count; i++)
{
Console.Write("[" + naipesComputer[i].ToString() + "]"); //Muestra las cartas que tiene disponible la Maquina
}
Console.WriteLine();
ArbolGeneral <int> NuevoArbol = ArbolEuristico.CortarArbol(UltimaCartaUsuario); //Corta el arbol en la ultima jugada que realizo el Usuario
ArbolEuristico = NuevoArbol;
List <int> SiguienteJugada = NuevoArbol.BuscarJugada(new List <int>()); //En el arbol cortado busca el camino que tenga como dato Heuristico -2
//y lo guarda en la lista SiguienteJugada
Console.WriteLine("Carta de La Maquina: " + "[" + SiguienteJugada[1] + "]");
//Devuelve la carta a jugar. Esta seria la carta que se ecuentra en la
return(SiguienteJugada[1]);; //posicion 1 de mi lista que guardo el camino que tiene el dato Heuristico -2.
}
private int _descartarUnaCarta(ArbolGeneral <Carta> raiz)
{
// Con el siguiente algoritmo se guardan las cartas donde la IA tiene una jugada aseguarada para ganar el juego.
Random random = new Random();
List <ArbolGeneral <Carta> > opciones = new List <ArbolGeneral <Carta> >(); // Lista que almacena todas las posibilidades de victoria.
int i = 0;
// Se crea la lista de opciones de cartas donde la IA tiene asegurada una victoria.
foreach (var hijo in raiz.getHijos())
{
if (hijo.getDatoRaiz().getFuncHeursitica() == 1) // Si tiene un hijo con FH +1, entonces se lo agrega a la lista de opciones.
{
opciones.Add(hijo);
}
}
if (opciones.Count == 0) // Si la IA no tiene una jugada asegurada de victoria, entonces tira la última carta.
{
foreach (var hijo in raiz.getHijos())
{
if (hijo.getDatoRaiz().getFuncHeursitica() == -1)
{
jugadaActual = hijo;
}
}
}
else // Si la IA tiene opciones aseguradas para ganar.
{
int opcion = random.Next(1, opciones.Count); // Se crea un valor random entre 1 y la cantidad de opciones que haya.
foreach (var o in opciones) // Se recorren todas las opciones.
{
i++; // Se incrementa el contador a medida que se recorren las opciones.
if (i == opcion) // Si el contador es igual a el número de opción aleatoria.
{
jugadaActual = o; // Entonces, jugadaActual apunta a esa opción.
break;
}
}
}
return(jugadaActual.getDatoRaiz().getCarta()); // Se retorna la carta elegida.
}
public override void incializar(List <int> cartasPropias, List <int> cartasOponente, int limite)
{
bool Turno = true; //comienza tirando el usuario!
List <int> usuario = new List <int>()
{
1, 2, 3
};
List <int> maquina = new List <int>()
{
4, 5, 6
};
naipesComputer = maquina;
ArbolGeneral <int> ArbolCompleto = CompletarRama(new ArbolGeneral <int>(0), usuario, maquina, Turno, limite);
ArbolGeneral <int> Arbol = InstalacionHeuristica(ArbolCompleto, Turno, 7);
ArbolEuristico = Arbol; //Guarda el Arbol Heuristico en el Campo de la clase base llamado "ArbolEuristico" para que todas las
//clases que hereden de esta clase base tambien tengan disponible este dato.
}
public override int descartarUnaCarta()
{
int mejoropcion = -1;
ArbolGeneral <int> nueopcion = null;
foreach (ArbolGeneral <int> opciones in arbolMiniMax.getHijos())
{
if (opciones.Raiz.cuantasVecesPerdio > mejoropcion)
{
nueopcion = opciones;
mejoropcion = opciones.Raiz.CuantasVecesPerdio;
}
}
arbolMiniMax.Raiz = nueopcion.Raiz;
Console.WriteLine("La maquina escogio la carta " + nueopcion.getDatoRaiz());
return(nueopcion.getDatoRaiz());
encolarParaRecorrer(arbolMiniMax);
}
private ArbolGeneral <Carta> _consultaB(ArbolGeneral <Carta> jugadaActual)
{
Console.Write("Ingrese una secuencia de cartas separadas por comas: ");
string numeros = Console.ReadLine();
string[] cartas = numeros.Split(','); // se Splitea las cartas que haya escrito el usuario en la secuencia
ArbolGeneral <Carta> aux = jugadaActual; // aux apunta a la jugada actual
foreach (string carta in cartas) // se recorre carta de la secuencia
{
foreach (ArbolGeneral <Carta> hijo in aux.getHijos()) //se reccoren los hijos del arbol aux
{
if (hijo.getDatoRaiz().getCarta() == Convert.ToInt32(carta)) // si existe
{
aux = hijo; // Aux apunta a la carta actual
break;
}
}
}
return(aux);
}
private List <ArbolGeneral <Carta> > _consultaA(ArbolGeneral <Carta> jugadaActual)
{
camino.Add(jugadaActual);
if (jugadaActual.esHoja()) // Si se encuentra un nodo hoja, se lo agrega y se agrega un separador.
{
// camino.Add(new ArbolGeneral<Carta>(new Carta(0, 0)));
imprimir(camino);
Console.WriteLine();
}
else
{
foreach (ArbolGeneral <Carta> hijo in jugadaActual.getHijos())
{
_consultaA(hijo);
camino.Remove(hijo);
}
}
return(camino);
}
public void recorreHijos(ArbolGeneral <int> arbol)
{
// foreach (ArbolGeneral<int> hijos in arbol.getHijos())
// {
// if(hijos.esHoja()==true)
// {
// if(hijos.Raiz.PerdioUsuario==1)
// {
// return 1;
// }
// else
// {
// return 0;
// }
// }
// else
// {
// return recorreHijos(hijos);
// }
// }
}
public void PorNivelesMarcadoFin()
{
Cola <ArbolGeneral <T> > cola = new Cola <ArbolGeneral <T> >(); //Intancia una cola vacia
cola.encolar(this); //Obtiene el Nodo Raiz y lo encola
cola.encolar(null); //Encola null (para determinar cuando empieza el nuevo nivel)
int nivel = 1;
Console.WriteLine("=======================================================================================================================");
Console.Write("[Nivel-" + nivel + "]: ");
while (cola.esVacia() != true)
{
ArbolGeneral <T> NodoDesencolado = cola.desencolar(); //Quita de la cola el dato(cola[0]) y lo almacena en la variable
if (NodoDesencolado == null)
{
cola.encolar(null); //Si el dato es NULL, encola NULL para señalar el comienzo de un nuevo nivel
if (cola.tope() == NodoDesencolado)
{
cola.desencolar(); //Si el dato en la cola, anterior a el dato NodoDesencolado, es tambien NULL se desencola
//pero no se almacena en ninguna variable temporal.
}
else
{
nivel++; //Si el dato no es NULL, es nodo, nivel incrementa y se comienza a imprimir el nuevo nivel
Console.Write("\n========================================================================================================================");
Console.Write("[Nivel-" + nivel + "]: ");
}
}
else //Si el dato desencolado es un NODO se encola e imprimen los hijos de este
{
foreach (var Nodo in NodoDesencolado.getHijos())
{
cola.encolar(Nodo);
}
Console.Write("[" + NodoDesencolado.getDatoRaiz() + "]");
}
}
Console.Write("\n========================================================================================================================");
}