public override int descartarUnaCarta() { // Dependiendo el valor de la función heuristica, si es a favor de la IA, se muestra de color verde, sino de rojo. Console.WriteLine("Turno IA\nCartas disponibles:"); foreach (var carta in estado.getCartasIA()) // Se recorren todas las cartas que tenga disponible la IA { var funcHeuristicaAux = 0; foreach (var nodo in jugadaActual.getHijos()) { if (carta == nodo.getDatoRaiz().getCarta()) { funcHeuristicaAux = nodo.getDatoRaiz().getFuncHeursitica(); } } if (funcHeuristicaAux == 1) { Console.ForegroundColor = ConsoleColor.DarkGreen; Console.Write("(" + carta + ", " + "+" + funcHeuristicaAux + ") "); Console.ResetColor(); } else { Console.ForegroundColor = ConsoleColor.DarkRed; Console.Write("(" + carta + ", " + funcHeuristicaAux + ") "); Console.ResetColor(); } } return(_descartarUnaCarta(jugadaActual)); }
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 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 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 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 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()); }
private void setEstado(int carta) { foreach (var nodo in estado.getHijos()) { if (nodo.getDatoRaiz() == carta) { estado = nodo; } } }
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 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); }
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 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 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(); } } }
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 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========================================================================================================================"); }
public ArbolGeneral <T> CortarArbol(int UltimaCartaUsuario) { Cola <ArbolGeneral <T> > c = new Cola <ArbolGeneral <T> >(); ArbolGeneral <T> arbolAux = new ArbolGeneral <T>(null); c.encolar(this); while (!c.esVacia()) { arbolAux = c.desencolar(); if (Convert.ToInt32(arbolAux.getDatoRaiz()) == UltimaCartaUsuario) { return(arbolAux); } if (!this.esHoja()) { foreach (var hijo in arbolAux.getHijos()) { c.encolar(hijo); } } } return(arbolAux); }
private void ConsultaB() { ArbolGeneral <DatosJugada> referencia = computer.getReferencia(); //Uso de referencia a la carta en la posicion que se encuentra el juego. bool rta = true; //Condicion para terminar las jugadas bool turno = true; computer.ImprimirCartas(); while (rta) { if (turno == true) { Console.WriteLine("Ingrese la carta que jugaría usted:"); string carta = Console.ReadLine(); bool aux = false; while (aux == false) { try { Int32.Parse(carta); aux = true; } catch (Exception) { Console.WriteLine("El valor no es correcto."); carta = Console.ReadLine(); } } foreach (var cartas in referencia.getHijos()) { if (cartas.getDatoRaiz().carta == Int32.Parse(carta)) { referencia = cartas; turno = false; Console.WriteLine("Ok"); break; //Una vez que encuentra la carta pasada se rompe el foreach y evaulua el turno } } if (referencia.getDatoRaiz().carta != Int32.Parse(carta)) //Si donde esta ubicado el arbol en ese momento no coincide con la carta entonces quiere decir que un valor es incorrecto. // O quiere decir que se paso del limite. { Console.WriteLine("La carta no esta disponible o se a alcanzado el limite del maso. Volviendo a la jugada..."); return; } } if (turno == false) { Console.WriteLine("Ingrese la carta que tiraría computer:"); string carta = Console.ReadLine(); bool aux = false; while (aux == false) { try { Int32.Parse(carta); aux = true; } catch (Exception) { Console.WriteLine("El valor no es correcto."); carta = Console.ReadLine(); } } foreach (var cartas in referencia.getHijos()) { if (cartas.getDatoRaiz().carta == Int32.Parse(carta)) { referencia = cartas; turno = true; Console.WriteLine("Ok"); break; //Una vez que encuentra la carta pasada se rompe el foreach y consulta si quiere terminar la jugada o seguir agregando mas jugadas. } } if (referencia.getDatoRaiz().carta != Int32.Parse(carta)) //Si donde esta ubicado el arbol en ese momento no coincide con la carta entonces quiere decir que un valor es incorrecto. { Console.WriteLine("La carta no esta disponible o se a alcanzado el limite del maso. Volviendo a la jugada..."); return; } } Console.WriteLine("Desea continuar la jugada?: Cualquier tecla para Si u oprima 'N' para no"); string rta2 = Console.ReadLine().ToUpper(); if (rta2 == "N") { rta = !rta; } } Console.WriteLine("Los posibles resultados para la jugada que acaba de ingresar son:"); Console.WriteLine(); computer.ImprimirHojas(referencia); //Imprime posibles resultados }
private void ArmarArbolMinimaxAux(Estatus estado, ArbolGeneral <Dupla> raiz) { if (estado.returnJuegaHumano() == true) { foreach (int carta in estado.getCartasHumano()) { ArbolGeneral <Dupla> h = new ArbolGeneral <Dupla>(new Dupla(carta, 0)); raiz.agregarHijo(h); if (estado.getLimite() - carta >= 0 && estado.getCartasIA().Count > 0) { List <int> nuevasCartaH = new List <int>(); nuevasCartaH.AddRange(estado.getCartasHumano()); nuevasCartaH.Remove(carta); Estatus estadoNuevo = new Estatus(); estadoNuevo.setCartasHumano(nuevasCartaH); estadoNuevo.setCartasIA(estado.getCartasIA()); estadoNuevo.setLimite(estado.getLimite() - carta); estadoNuevo.setJuegaHumanoFalse(); ArmarArbolMinimaxAux(estadoNuevo, h); bool existe = false; foreach (ArbolGeneral <Dupla> hijo in h.getHijos()) { if (hijo.getDatoRaiz().getValorFuncionHeuristica() == 1) { existe = true; } } if (existe == true) { h.getDatoRaiz().setFuncionHeuristica(1); } else { h.getDatoRaiz().setFuncionHeuristica(-1); } } else { h.getDatoRaiz().setFuncionHeuristica(1); } } } else { foreach (int carta in estado.getCartasIA()) { ArbolGeneral <Dupla> h = new ArbolGeneral <Dupla>(new Dupla(carta, 0)); raiz.agregarHijo(h); if (estado.getLimite() - carta >= 0 && estado.getCartasHumano().Count > 0) { List <int> nuevasCartaIA = new List <int>(); nuevasCartaIA.AddRange(estado.getCartasIA()); nuevasCartaIA.Remove(carta); Estatus estadoNuevo = new Estatus(); estadoNuevo.setCartasIA(nuevasCartaIA); estadoNuevo.setCartasHumano(estado.getCartasHumano()); estadoNuevo.setLimite(estado.getLimite() - carta); estadoNuevo.setJuegaHumanoTrue(); ArmarArbolMinimaxAux(estadoNuevo, h); bool existe = false; foreach (ArbolGeneral <Dupla> hijo in h.getHijos()) { if (hijo.getDatoRaiz().getValorFuncionHeuristica() == -1) { existe = true; } } if (existe == true) { h.getDatoRaiz().setFuncionHeuristica(-1); } else { h.getDatoRaiz().setFuncionHeuristica(1); } } else { h.getDatoRaiz().setFuncionHeuristica(-1); } } } }
private void crearArbol(List <int> cartasPropias, List <int> cartasOponente, int limite, bool turno, ArbolGeneral <DatosJugada> aux) { List <int> cartas = new List <int>(); //creo una lista vacia, que se llenara de cartas //al determinar que primero juegue el humano, siempre se ejecutará el IF if (turno) { // Si es el turno del usuario agrego las cartas del oponente cartas.AddRange(cartasOponente); } else { // Si es el turno de la IA agrego las cartas propias cartas.AddRange(cartasPropias); } //comienzo a llenar el arbol minimax con las cartas del humano (cada una sera un subarbol) foreach (int carta in cartas) //crea, por ende, 6 hijos a la raíz null del minmax { //----------------------------------------------------------------------------------- DatosJugada jugada = new DatosJugada(0, 0, true); // Creo subarboles hijos PARA cada carta ArbolGeneral <DatosJugada> hijo = new ArbolGeneral <DatosJugada>(jugada); //agrego la carta a la raiz hijo.getDatoRaiz().carta = carta; // Agrego los hijos al arbol minmax aux.agregarHijo(hijo); // Disminuyo el limite para cada carta int nuevoLimite = limite - carta; // Tendremos una lista de cartas auxiliares para hacer la llamada recursiva sin la carta que ya se jugo List <int> cartasAux = new List <int>(); cartasAux.AddRange(cartas); cartasAux.Remove(carta); //saca la primer carta que juega el humano y a partir de ahí sigue // Chequeo el limite, si no se supero hago las llamadas recursivas y cambio el turno if (nuevoLimite >= 0) { bool Noencontro_Humano = false; //Variables que serviran para la busqueda heuristica bool Noencontro_Computer = false; //---------------------------crea un nuevo nivel o no (dependiendo del if anterior) invirtiendo el turno---------------------------------------- // Si es turno del usuario, paso las cartas auxiliares como cartas del oponente if (turno) { crearArbol(cartasPropias, cartasAux, nuevoLimite, !turno, hijo); //paso como arbol, a los arboles hijos de la raiz. sucesivamente // Comparo las funciones heuristicas de los hijos foreach (var hijos in hijo.getHijos()) { // Si hay una con valor 1, se la seteo al padre //esto hace que el -1 o 1 vaya subiendo y se setee desde la hoja hasta los hijos del primer nivel if (hijos.getDatoRaiz().valorDeConveniencia == -1) { hijo.getDatoRaiz().valorDeConveniencia = -1; } else { Noencontro_Humano = true; } } if (Noencontro_Humano) { Noencontro_Humano = !Noencontro_Humano; //Si no encuentra quiere decir que no hay un hijo con valor -1 y entonces se le sete 1 al padre. hijo.getDatoRaiz().valorDeConveniencia = 1; } } // Si es el turno de la IA paso cartas auxiliares como cartas propias else { crearArbol(cartasAux, cartasOponente, nuevoLimite, !turno, hijo); // Comparo las funciones heuristicas de los hijos foreach (var hijos in hijo.getHijos()) { // Si hay una con valor -1, se la seteo al padre if (hijos.getDatoRaiz().valorDeConveniencia == 1) { hijo.getDatoRaiz().valorDeConveniencia = 1; } else { Noencontro_Computer = true; } } if (Noencontro_Computer) { Noencontro_Computer = !Noencontro_Computer; //Si no encuentra quiere decir que no hay un hijo con valor 1 y entonces se le sete 1 al padre. hijo.getDatoRaiz().valorDeConveniencia = -1; } } } //---------------------------------------------------------------------------------- // Si se supera el limite verifico quien gano (-1 gana humano, 1 gana pc) // acá se asigna el valor a las hojas ... else { if (turno) { hijo.getDatoRaiz().valorDeConveniencia = 1; //se pasa de limite el humano } else { hijo.getDatoRaiz().valorDeConveniencia = -1; //se pasa de limite la computadora } } referencia = minimax; //Referencia la vamos a usar para saber en que cartas estamos. } }
private void createArbol(Estado estado, ArbolGeneral <Carta> raiz) { if (estado.getTurnoH()) // turno del Humano { foreach (int cartaH in estado.getCartasH()) { Carta carta = new Carta(cartaH, 0); ArbolGeneral <Carta> hijo = new ArbolGeneral <Carta>(carta); raiz.agregarHijo(hijo); int nuevoLimite = estado.getLimite() - cartaH; if (nuevoLimite >= 0) // si no es el caso base, actualizo el estado y sigo armando el arbol. { List <int> nuevasCartasH = new List <int>(); nuevasCartasH.AddRange(estado.getCartasH()); nuevasCartasH.Remove(cartaH); Estado nuevoEstado = new Estado(estado.getCartasIA(), nuevasCartasH, nuevoLimite, false); createArbol(nuevoEstado, hijo); // Función heuristica MiniMax bool max = false; foreach (var nodo in hijo.getHijos()) { if (nodo.getDatoRaiz().getFuncHeursitica() == 1) // Si existe al menos un hijo con FH +1, se maximiza { max = true; break; // agrego un break para cortar la busqueda. } } if (max) { hijo.getDatoRaiz().setFuncHeuristica(1); } else { hijo.getDatoRaiz().setFuncHeuristica(-1); } } else // si es el caso base, entonces asigno la funcion heuristica al nodo hijo. { hijo.getDatoRaiz().setFuncHeuristica(1); // Pierde el humano, gana la IA. } } } else// turno de la IA { foreach (int cartaIA in estado.getCartasIA()) { Carta carta = new Carta(cartaIA, 0); ArbolGeneral <Carta> hijo = new ArbolGeneral <Carta>(carta); raiz.agregarHijo(hijo); int nuevoLimite = estado.getLimite() - cartaIA; if (nuevoLimite >= 0) // si no es el caso base, actualizo el estado y sigo armando el arbol. { List <int> nuevasCartasIA = new List <int>(); nuevasCartasIA.AddRange(estado.getCartasIA()); nuevasCartasIA.Remove(cartaIA); Estado nuevoEstado = new Estado(nuevasCartasIA, estado.getCartasH(), nuevoLimite, true); createArbol(nuevoEstado, hijo); // Se sigue armando el arbol hasta que haya un nodo hoja. // Función heuristica MiniMax bool min = false; foreach (var nodo in hijo.getHijos()) // Se recorren los hijos del hijo raiz { if (nodo.getDatoRaiz().getFuncHeursitica() == -1) // Si existe al menos un hijo con FH -1, se minimiza { min = true; break; // Agrego un break para cortar la busqueda. } } if (min) { hijo.getDatoRaiz().setFuncHeuristica(-1); } else { hijo.getDatoRaiz().setFuncHeuristica(1); } } else // si es el caso base, entonces asigno la funcion heuristica al nodo hijo. { hijo.getDatoRaiz().setFuncHeuristica(-1); // Pierde la IA, gana el Humano. } } } }
private void _inicializar(List <int> cartasPropias, List <int> cartasOponente, int limite, bool turno, ArbolGeneral <int> raiz) { //Creo una lista de cards auxiliar para no modificar las originales List <int> cards = new List <int>(); if (turno == true) //Human turn { cards.AddRange(cartasOponente); } else //AI Turn { cards.AddRange(cartasPropias); } //Para cada card foreach (var card in cards) { //Creo un arbol auxiliar con la card como dato ArbolGeneral <int> hijo = new ArbolGeneral <int>(card); //Agrego el arbol auxiliar como hijo de la raíz raiz.agregarHijo(hijo); //Disminuyo el limite int limiteaux = limite - card; //Creo una lista de cards auxiliar para eliminar la card sin perder información de la lista "cards" List <int> cartasRestantes = new List <int>(); cartasRestantes.AddRange(cards); cartasRestantes.Remove(card); //Si el límite es mayor o igual a 0 sigo agregando hijos a los subárboles if (limiteaux >= 0) { //Si es el turno del humano, llamo recursivamente a la funcion con la lista de cards auxiliares como nueva lista de cards del humano. if (turno == true) { _inicializar(cartasPropias, cartasRestantes, limiteaux, !turno, hijo); //Asignamos función heurística a cada nodo cuando volvemos de la recursión List <ArbolGeneral <int> > hijos = raiz.getHijos(); raiz.setFuncionHeuristica(-1); foreach (var h in hijos) { if (h.getFuncionHeuristicaRaiz() == 1) { raiz.setFuncionHeuristica(1); break; } } } //Si es el turno de la IA, llamamos a la función recursivamente con la lista de cartas auxiliares como nueva lista de cartas de la IA. else { _inicializar(cartasRestantes, cartasOponente, limiteaux, !turno, hijo); //Asignamos función heurística a cada nodo cuando volvemos de la recursión. List <ArbolGeneral <int> > hijos = raiz.getHijos(); raiz.setFuncionHeuristica(1); foreach (var h in hijos) { if (h.getFuncionHeuristicaRaiz() == -1) { raiz.setFuncionHeuristica(-1); break; } } } } //Si se pasó el límite else { //Asignamos función heurística a cada hoja //(1 IA Gana ; -1 Human Gana) if (turno == true) { hijo.setFuncionHeuristica(1); } else { hijo.setFuncionHeuristica(-1); } } } Game.setEstadoInicial(raiz); }