public List <Planeta> CaminoPreOrden(ArbolGeneral <Planeta> arbol, List <Planeta> camino)
{
// Primero raiz
camino.Add(arbol.getDatoRaiz());
// si encontramos camino
if (arbol.getDatoRaiz().EsPlanetaDeLaIA())
{
return(camino);
}
else
{
//hijos recursivo...
foreach (var hijo in arbol.getHijos())
{
List <Planeta> caminoAux = CaminoPreOrden(hijo, camino);
if (caminoAux != null)
{
return(caminoAux);
}
//saco ultimo planeta del camino
camino.Remove(hijo.getDatoRaiz());
}
}
return(null);
}
public String Consulta3(ArbolGeneral <Planeta> arbol)
{
// calcular promedio poblacion por nivel de arbol (recorrido por niveles, sumar en total y cantidad y dividir por cantidad para sacar promedio)
Cola <ArbolGeneral <Planeta> > c = new Cola <ArbolGeneral <Planeta> >();
uint Conta1 = 0;
uint Conta2 = 0;
uint Conta3 = 0;
uint Conta4 = 0;
uint nivel1 = 0;
uint nivel2 = 0;
uint nivel3 = 0;
uint nivel4 = 0;
c.encolar(arbol);
while (!c.esVacia())
{
arbol = c.desencolar();
int conta = arbol.nivel(arbol.getDatoRaiz());
if (conta == 1)
{
nivel1 += arbol.getDatoRaiz().population;
Conta1++;
}
else if (conta == 2)
{
nivel2 += arbol.getDatoRaiz().population;
Conta2++;
}
else if (conta == 3)
{
nivel3 += arbol.getDatoRaiz().population;
Conta3++;
}
else
{
nivel4 += arbol.getDatoRaiz().population;
Conta4++;
}
foreach (var hijo in arbol.getHijos())
{
c.encolar(hijo);
}
}
nivel1 /= Conta1;
nivel2 /= Conta2;
nivel3 /= Conta3;
nivel4 /= Conta4;
return($"\r\n\r\n\r\n\r\n\r\n\r\nPromedio de poblacion segun nivel:\r\n" +
$"nivel 1: {nivel1}\r\n" +
$"nivel 2: {nivel2}\r\n" +
$"nivel 3: {nivel3}\r\n" +
$"nivel 4: {nivel4}\r\n");
}
public String Consulta2(ArbolGeneral <Planeta> arbol)
{
Cola <ArbolGeneral <Planeta> > c = new Cola <ArbolGeneral <Planeta> >();
uint nivel1 = 0;
uint nivel2 = 0;
uint nivel3 = 0;
uint nivel4 = 0;
c.encolar(arbol);
while (!c.esVacia())
{
arbol = c.desencolar();
int conta = arbol.nivel(arbol.getDatoRaiz());
if (arbol.getDatoRaiz().population > 10)
{
if (conta == 1)
{
nivel1++;
}
else if (conta == 2)
{
nivel2++;
}
else if (conta == 3)
{
nivel3++;
}
else
{
nivel4++;
}
}
foreach (var hijo in arbol.getHijos())
{
c.encolar(hijo);
}
}
//calcular cantidad de planetas con población > 10 en cada nivel del arbol (recorrido por niveles,con limitante de población)
return($"\r\nCantidad de planetas con poblacion mayor a 10 segun nivel:\r\n" +
$"nivel 1: {nivel1}\r\n" +
$"nivel 2: {nivel2}\r\n" +
$"nivel 3: {nivel3}\r\n" +
$"nivel 4: {nivel4}\r\n");
}
public int Distancia_Raiz(ArbolGeneral <Planeta> arbol)
{
if (arbol.getDatoRaiz().EsPlanetaDeLaIA())
{
return(0);
}
else
{
int nivel = 1;
List <ArbolGeneral <Planeta> > Lista_hijos = arbol.getHijos();
List <ArbolGeneral <Planeta> > Siguiente_nivel_hijos;
do
{
//lista vacia que tendra los nodos por nivel
Siguiente_nivel_hijos = new List <ArbolGeneral <Planeta> >();
foreach (ArbolGeneral <Planeta> Obtener_hijo in Lista_hijos)
{ //cuando encuentro un nodo que es ia retorno el nivel
if (Obtener_hijo.getDatoRaiz().EsPlanetaDeLaIA())
{
return(nivel);
}
//obtengo los hijos del nodo obtener hijos y lo agrego a la lista de nodos que tiene siguiente nivel
foreach (ArbolGeneral <Planeta> hijo in Obtener_hijo.getHijos())
{
Siguiente_nivel_hijos.Add(hijo);
}
}
Lista_hijos = Siguiente_nivel_hijos;
nivel++;
} while (Siguiente_nivel_hijos.Count > 0);
//-1 si no esta el dato
return(-1);
}
}
public String Consulta1(ArbolGeneral <Planeta> arbol) //Recorrido por niveles
{
Cola <ArbolGeneral <Planeta> > q = new Cola <ArbolGeneral <Planeta> >();
q.encolar(arbol);
int nivel = 0;
while (!q.esVacia())
{
int elementos = q.cantElementos();
nivel++;
while (elementos-- > 0)
{
ArbolGeneral <Planeta> nodoActual = q.desencolar();
if (nodoActual.getDatoRaiz().EsPlanetaDeLaIA())
{
nivel--;
string texto = nivel.ToString();
return("La distancia entre la raiz y el planeta del bot es de: " + texto);
}
foreach (ArbolGeneral <Planeta> hijo in nodoActual.getHijos())
{
q.encolar(hijo);
}
}
}
return("");
}
public Movimiento CalcularMovimiento(ArbolGeneral <Planeta> arbol)
{
if (!arbol.getDatoRaiz().EsPlanetaDeLaIA())
{
ArrayList lista = new ArrayList();
lista = preordenCaminoIA(lista, arbol);
Planeta origen = (Planeta)lista[lista.Count - 1];
Planeta destino = (Planeta)lista[lista.Count - 2];
return(new Movimiento(origen, destino));
}
else
{
ArrayList lista = new ArrayList();
lista = preordenCaminoJugador(lista, arbol);
int a = 0, b = 1;
Planeta origen = (Planeta)lista[a];
Planeta destino = (Planeta)lista[b];
for (int i = 0; i < lista.Count; i++)
{
Planeta elegido = (Planeta)lista[i];
Planeta elegidoMasUno = (Planeta)lista[i + 1];
if (elegido.EsPlanetaDeLaIA() && !elegidoMasUno.EsPlanetaDeLaIA())
{
return(new Movimiento(elegido, elegidoMasUno));
}
}
return(new Movimiento(origen, destino));
}
}
public String Consulta3(ArbolGeneral <Planeta> arbol)
{
Cola <ArbolGeneral <Planeta> > q = new Cola <ArbolGeneral <Planeta> >();
q.encolar(arbol);
int nivel = 0;
String mensaje = "";
while (!q.esVacia())
{
int elementos = q.cantElementos();
nivel++;
int cantidad = 0;
int total = 0;
while (elementos-- > 0)
{
ArbolGeneral <Planeta> nodoActual = q.desencolar();
total = total + nodoActual.getDatoRaiz().Poblacion();
cantidad++;
foreach (ArbolGeneral <Planeta> hijo in nodoActual.getHijos())
{
q.encolar(hijo);
}
}
double promedio = total / cantidad;
mensaje += "\n" + "\n" + "\n" + "Nivel " + nivel + ": " + promedio + "\n";
}
return(mensaje);
}
public String Consulta2(ArbolGeneral <Planeta> arbol)
{
Cola <ArbolGeneral <Planeta> > q = new Cola <ArbolGeneral <Planeta> >();
q.encolar(arbol);
int nivel = 0;
String mensaje = "";
while (!q.esVacia())
{
int elementos = q.cantElementos();
nivel++;
int cantidadPorNivel = 0;
while (elementos-- > 0)
{
ArbolGeneral <Planeta> nodoActual = q.desencolar();
if (nodoActual.getDatoRaiz().Poblacion() > 10)
{
cantidadPorNivel++;
}
foreach (ArbolGeneral <Planeta> hijo in nodoActual.getHijos())
{
q.encolar(hijo);
}
}
mensaje += "Nivel " + nivel + ": " + cantidadPorNivel + "\n";
}
return(mensaje);
}
public Movimiento CalcularMovimiento(ArbolGeneral <Planeta> arbol)
{
List <Planeta> caminoHaciaRaiz = null;
List <Planeta> caminoHaciaHumano = null;
caminoHaciaRaiz = CaminoIAaRaiz(arbol, new List <Planeta>());
caminoHaciaRaiz.Reverse();
caminoHaciaHumano = CaminoRaizAHumano(arbol, new List <Planeta>());
if (!arbol.getDatoRaiz().EsPlanetaDeLaIA())
{
Movimiento movARaiz = new Movimiento(caminoHaciaRaiz[0], caminoHaciaRaiz[1]);
return(movARaiz);
}
else
{
for (int index = 0; index < caminoHaciaHumano.Count(); index++)
{
if (caminoHaciaHumano[index].EsPlanetaDeLaIA() &&
(caminoHaciaHumano[index + 1].EsPlanetaNeutral() ||
caminoHaciaHumano[index + 1].EsPlanetaDelJugador()))
{
Movimiento movAhumano = new Movimiento(caminoHaciaHumano[index], caminoHaciaHumano[index + 1]);
return(movAhumano);
}
}
}
return(null);
}
public Movimiento CalcularMovimiento(ArbolGeneral <Planeta> arbol)
{
if (!arbol.getDatoRaiz().EsPlanetaDeLaIA()) //Si la raiz no pertenece al bot
{
List <Planeta> caminoIA = new List <Planeta>(); //Creo el camino
caminoIA = this.caminoRaizIa(arbol, caminoIA);
int count = caminoIA.Count;
Movimiento ataque = new Movimiento(caminoIA[count - 1], caminoIA[count - 2]); //Realizo el ataque
return(ataque);
}
else //Si la raiz le pertenece al bot
{
List <Planeta> caminoPlayer = new List <Planeta>(); //Creo el camino
caminoPlayer = this.caminoRaizPlayer(arbol, caminoPlayer);
for (int count = 0; count < caminoPlayer.Count; count++)
{
if (!caminoPlayer[count].EsPlanetaDeLaIA())
{
count--;
Movimiento ataque = new Movimiento(caminoPlayer[count], caminoPlayer[count + 1]); //Realizo el ataque
return(ataque);
}
}
return(null);
}
}
public String Consulta3(ArbolGeneral <Planeta> arbol) //Recorrido por niveles
{
Cola <ArbolGeneral <Planeta> > q = new Cola <ArbolGeneral <Planeta> >();
q.encolar(arbol);
int nivel = 0;
String mensaje = "";
while (!q.esVacia())
{
int elementos = q.cantElementos();
nivel++;
int cantidadPorNivel = 0;
int poblacionPorNivel = 0;
while (elementos-- > 0)
{
ArbolGeneral <Planeta> nodoActual = q.desencolar();
cantidadPorNivel++;
poblacionPorNivel += nodoActual.getDatoRaiz().Poblacion();
foreach (ArbolGeneral <Planeta> hijo in nodoActual.getHijos())
{
q.encolar(hijo);
}
}
mensaje += "Nivel " + nivel + ": " + poblacionPorNivel / cantidadPorNivel + "-----";
}
return(mensaje);
}
//El metodo caminoRaizPlayer consigue un camino desde la raiz al primer planeta del bot
private List <Planeta> caminoRaizPlayer(ArbolGeneral <Planeta> arbol, List <Planeta> camino)
{
camino.Add(arbol.getDatoRaiz()); //Agrego el planeta al camino
if (arbol.getDatoRaiz().EsPlanetaDelJugador())
{ //Si encuentro el planeta del jugdor retorno el camino
return(camino);
}
else
{
foreach (ArbolGeneral <Planeta> hijo in arbol.getHijos())
{
List <Planeta> caminoAux = this.caminoRaizPlayer(hijo, camino);
if (caminoAux != null) //Si esta condicion es verdadera significa que el metodo encontro el planeta del jugador
{
return(caminoAux);
}
camino.RemoveAt(camino.Count - 1); //En caso de llegar a un camino equivocado elimino el ultimo elemento
}
}
return(null);
}
public List <Planeta> CaminoIAaRaiz(ArbolGeneral <Planeta> arbol, List <Planeta> caminoDeLaIA)
{
caminoDeLaIA.Add(arbol.getDatoRaiz());
if (arbol.getDatoRaiz().EsPlanetaDeLaIA())
{
return(caminoDeLaIA);
}
else
{
foreach (var hijo in arbol.getHijos())
{
List <Planeta> caminoAux = CaminoIAaRaiz(hijo, caminoDeLaIA);
if (caminoAux != null)
{
return(caminoAux);
}
}
caminoDeLaIA.RemoveAt(caminoDeLaIA.Count() - 1);
}
return(null);
}
public Movimiento OpcionMover2ARaiz(ArbolGeneral <Planeta> arbol)
{
ArbolGeneral <Planeta> raiz = arbol;
//suponemos que estan en la raiz cosa que al iniciar el do while va a cambiar
ArbolGeneral <Planeta> nodoIA = raiz;
ArbolGeneral <Planeta> nodoUsuario = raiz;
ArbolGeneral <Planeta> nodoPadreIA = raiz;
int nivel = 1;
List <ArbolGeneral <Planeta> > Lista_hijos = new List <ArbolGeneral <Planeta> >();
Lista_hijos.Add(arbol);
//arbol.getHijos();
List <ArbolGeneral <Planeta> > Siguiente_nivel_hijos;
do
{
ArbolGeneral <Planeta> nodopadre;
//lista vacia que tendra los nodos por nivel
Siguiente_nivel_hijos = new List <ArbolGeneral <Planeta> >();
foreach (ArbolGeneral <Planeta> Obtener_hijo in Lista_hijos)
{
nodopadre = Obtener_hijo;
//obtengo los hijos del nodo obtener hijos y lo agrego a la lista de nodos que tiene siguiente nivel
foreach (ArbolGeneral <Planeta> hijo in Obtener_hijo.getHijos())
{
if (hijo.getDatoRaiz().EsPlanetaDeLaIA())
{
nodoIA = hijo;
nodoPadreIA = nodopadre;
break;
}
if (hijo.getDatoRaiz().EsPlanetaDelJugador())
{
nodoUsuario = hijo;
}
Siguiente_nivel_hijos.Add(hijo);
}
}
Lista_hijos = Siguiente_nivel_hijos;
nivel++;
} while (Siguiente_nivel_hijos.Count > 0);
//Movimiento(Planeta origen, Planeta destino)
Movimiento mover = new Movimiento(nodoIA.getDatoRaiz(), nodoPadreIA.getDatoRaiz());
return(mover);
}
public List <Planeta> CaminoRaizAHumano(ArbolGeneral <Planeta> arbol, List <Planeta> caminoDeRaizAHumano)
{
caminoDeRaizAHumano.Add(arbol.getDatoRaiz());
if (arbol.getDatoRaiz().EsPlanetaDelJugador())
{
return(caminoDeRaizAHumano);
}
else
{
foreach (var hijo in arbol.getHijos())
{
List <Planeta> caminoAux = CaminoRaizAHumano(hijo, caminoDeRaizAHumano);
if (caminoAux != null)
{
return(caminoAux);
}
}
caminoDeRaizAHumano.RemoveAt(caminoDeRaizAHumano.Count() - 1);
}
return(null);
}
public List <Planeta> CaminoJugador(ArbolGeneral <Planeta> arbol, List <Planeta> camino)
{
// Primero raiz
camino.Add(arbol.getDatoRaiz());
// si encontramos camino
if (arbol.getDatoRaiz().EsPlanetaDelJugador())
{
return(camino);
}
else
{
foreach (var hijo in arbol.getHijos())
{
List <Planeta> CaminoKill = CaminoJugador(hijo, camino);
if (CaminoKill != null)
{
return(CaminoKill);
}
camino.Remove(hijo.getDatoRaiz());
}
}
return(null);
}
public ArrayList preordenCaminoJugador(ArrayList lista, ArbolGeneral <Planeta> arbol)
{
Planeta planeta = arbol.getDatoRaiz();
lista.Add(planeta);
if (planeta.EsPlanetaDelJugador())
{
return(lista);
}
else
{
foreach (ArbolGeneral <Planeta> i in arbol.getHijos())
{
ArrayList lista2 = preordenCaminoJugador(lista, i);
if (lista2 != null)
{
return(lista2);
}
lista.RemoveAt(lista.Count - 1);
}
}
return(null);
}