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 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 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)
{
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 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);
}
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 String Consulta1(ArbolGeneral <Planeta> arbol)
{
int distancia = Distancia_Raiz(arbol);
if (distancia < 1)
{
return("El bot Esta en la Raiz");
}
return("La distancia que existe entre el bot a la Raiz es " + distancia);
}
public String Consulta1(ArbolGeneral <Planeta> arbol)
{
ArrayList list = new ArrayList();
list = preordenCaminoIA(list, arbol);
int distancia = list.Count - 1;
string dist = distancia.ToString();
return("La distancia desde la raiz hasta el nodo mas cercano a la IA es: " + dist);
}
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 Movimiento CalcularMovimiento(ArbolGeneral <Planeta> arbol)
{
Movimiento probar = enviarMovimiento(arbol);
return(probar);
/*
* 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;
* }
* 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; */
}
int mov = 0; // cant de movimientos sin vencer al destino
public String Consulta1(ArbolGeneral <Planeta> arbol)
{
int d = 0;
List <Planeta> cami = new List <Planeta>();
CaminoPreOrden(arbol, cami);
d = cami.Count - 2;
// calcular y retornar un texto con distancia entre raiz y nodo del bot
return("la distancia entre la raiz y del bot es de : " + d);
}
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 String Consulta3(ArbolGeneral <Planeta> arbol)
{
Cola <ArbolGeneral <Planeta> > c = new Cola <ArbolGeneral <Planeta> >();
ArbolGeneral <Planeta> arbolaux;
c.encolar(arbol);
c.encolar(null);
int contarPlanetas = 0;
int nivel = 0;
int sumarPoblacion = 0;
float promedioPorNivel = 0;
string consultaPromedioDePlanetas = "";
string consulta3 = "CONSULTA 3:" + "\n";
while (!c.esVacia())
{
arbolaux = c.desencolar();
if (arbolaux != null)
{
if (arbolaux.getDatoRaiz().Poblacion() > 0)
{
contarPlanetas++;
sumarPoblacion = sumarPoblacion + arbolaux.getDatoRaiz().Poblacion();
promedioPorNivel = sumarPoblacion / contarPlanetas;
}
foreach (var hijo in arbolaux.getHijos())
{
c.encolar(hijo);
}
}
else
{
consultaPromedioDePlanetas += "El promedio poblacional en el nivel " + nivel + " es: " + promedioPorNivel + "\n";
contarPlanetas = 0;
nivel++;
promedioPorNivel = 0;
sumarPoblacion = 0;
if (!c.esVacia())
{
c.encolar(null);
}
}
}
return(consulta3 + consultaPromedioDePlanetas);
}
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 String Consulta2(ArbolGeneral <Planeta> arbol)
{
Cola <ArbolGeneral <Planeta> > c = new Cola <ArbolGeneral <Planeta> >();
ArbolGeneral <Planeta> arbolaux;
c.encolar(arbol);
c.encolar(null);
int contarPlanetas = 0;
int nivel = 0;
string consultaDePlanetas = "";
string consulta2 = "CONSULTA 2:" + "\n";
while (!c.esVacia())
{
arbolaux = c.desencolar();
if (arbolaux != null)
{
if (arbolaux.getDatoRaiz().Poblacion() > 10)
{
contarPlanetas++;
}
foreach (var hijo in arbolaux.getHijos())
{
c.encolar(hijo);
}
}
else
{
consultaDePlanetas += "La cant de planetas con poblacion mayor a 10 en el nivel " + nivel + " es: " + contarPlanetas + "\n";
contarPlanetas = 0;
nivel++;
if (!c.esVacia())
{
c.encolar(null);
}
}
}
return(consulta2 + consultaDePlanetas);
}
public String Consulta2(ArbolGeneral <Planeta> arbol)
{
/*Calcula y retorna en un texto la cantidad de planetas que tienen
* población mayor a 10 en cada nivel del árbol que es enviado como parámetro*/
string texto = "";
int cant_nodoNivel;
int cant_PlanetaMayorA10;
int nivel = 1;
List <ArbolGeneral <Planeta> > Lista_hijos = arbol.getHijos();
List <ArbolGeneral <Planeta> > Siguiente_nivel_hijos;
do
{
cant_nodoNivel = Lista_hijos.Count;
cant_PlanetaMayorA10 = 0;
//lista vacia que tendra los nodos por nivel
Siguiente_nivel_hijos = new List <ArbolGeneral <Planeta> >();
foreach (ArbolGeneral <Planeta> Obtener_hijo in Lista_hijos)
{
if (Obtener_hijo.getDatoRaiz().Poblacion() > 10)
{
cant_PlanetaMayorA10++;
}
//obtengo los nodos 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);
}
}
//texto += "\nEl nivel " + nivel + " tiene : " + cant_PlanetaMayorA10 + " nodos con una población mayor a 10\n";
texto += "El nivel " + nivel + " tiene : " + cant_PlanetaMayorA10 + " nodos con una población mayor a 10\n";
Lista_hijos = Siguiente_nivel_hijos;
nivel++;
} while (Siguiente_nivel_hijos.Count > 0);
return(texto + "\n");
}
public Movimiento CalcularMovimiento(ArbolGeneral <Planeta> arbol)
{
List <Planeta> cami = new List <Planeta>();
CaminoPreOrden(arbol, cami);
int Cant = cami.Count;
if (Cant > 1)
{
Movimiento T = new Movimiento(cami[Cant - 1], cami[Cant - 2]);
return(T);
}
CaminoJugador(arbol, cami);
List <Planeta> jugador = CaminoJugador(arbol, cami);
Movimiento kill = new Movimiento(cami[x], jugador[y]);
if (x < 3 && cami[x].Poblacion() / 2 > jugador[y].Poblacion() || jugador[y].EsPlanetaDeLaIA())
// si origen es menor a tres y la mitad de la poblacion de origen es menor que la poblacion del destino (osea no lo va vencer) o que el destino sea planeta de la ia
{
// sube uno de origen y uno de destino, y se resetea el contador mov
x++;
y++;
mov = 0;
}
//se incrementa mov en 1 si lo de arriba si no se cumple
else
{
mov++;
}
// si el contador mov llega a 2 (Se hicieron 2 movimientos sin poder capturar el planeta) se resetea el origen y el destino para llamar más naves desde root para capturar
if (mov == 2)
{
x = 0;
y = 1;
}
return(kill);
}
//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 String Consulta1(ArbolGeneral <Planeta> arbol)
{
Cola <ArbolGeneral <Planeta> > c = new Cola <ArbolGeneral <Planeta> >();
ArbolGeneral <Planeta> arbolaux;
c.encolar(arbol);
c.encolar(null);
int distancia = 0;
while (!c.esVacia())
{
arbolaux = c.desencolar();
if (arbolaux != null)
{
if (arbolaux.getDatoRaiz().EsPlanetaDeLaIA())
{
return("CONSULTA 1:" + "\n" + "La distancia de la raiz al planeta mas cercano de la IA es " + distancia);
}
else
{
foreach (var hijo in arbolaux.getHijos())
{
c.encolar(hijo);
}
}
}
else
{
distancia++;
c.encolar(null);
}
}
return("No se encontro ningun planeta");
}
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 String Consulta3(ArbolGeneral <Planeta> arbol)
{
/*Calcula y retorna en un texto el promedio poblacional por nivel del árbol que es enviado como parámetro. */
string texto = "\n";
int cant_nodoNivel;
int cant_Poblacion;
int nivel = 1;
List <ArbolGeneral <Planeta> > Lista_hijos = arbol.getHijos();
List <ArbolGeneral <Planeta> > Siguiente_nivel_hijos;
do
{
cant_nodoNivel = Lista_hijos.Count;
cant_Poblacion = 0;
//lista vacia que tendra los nodos por nivel
Siguiente_nivel_hijos = new List <ArbolGeneral <Planeta> >();
foreach (ArbolGeneral <Planeta> Obtener_hijo in Lista_hijos)
{
cant_Poblacion += Obtener_hijo.getDatoRaiz().Poblacion();
//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);
}
}
int promedio = 0;
if (cant_nodoNivel > 0)
{
promedio = (cant_Poblacion / cant_nodoNivel);
}
texto += "\nEl nivel " + nivel + " tiene en promedio poblicional : " + promedio; //+ "\n";
texto += "\ncant. nodo " + cant_nodoNivel + " cant. poblacion total " + cant_Poblacion + "\n";
Lista_hijos = Siguiente_nivel_hijos;
nivel++;
} while (Siguiente_nivel_hijos.Count > 0);
return(texto);
}
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 Movimiento enviarMovimiento(ArbolGeneral <Planeta> arbol)
{
List <ArbolGeneral <Planeta> > ListaPreorden = arbol.ListaPreOrden();
List <ArbolGeneral <Planeta> > ListaDeNodosIA = new List <ArbolGeneral <Planeta> >();
List <ArbolGeneral <Planeta> > ListaDeNodosUsuario = new List <ArbolGeneral <Planeta> >();
foreach (ArbolGeneral <Planeta> nodo in ListaPreorden)
{
if (nodo.getDatoRaiz().EsPlanetaDeLaIA())
{
ListaDeNodosIA.Add(nodo);
}
if (nodo.getDatoRaiz().EsPlanetaDelJugador())
{
ListaDeNodosUsuario.Add(nodo);
}
}
int menordistancia = -20;
ArbolGeneral <Planeta> nodoIAaMover = arbol;
foreach (ArbolGeneral <Planeta> nodoU in ListaDeNodosUsuario)
{
foreach (ArbolGeneral <Planeta> nodoIA in ListaDeNodosUsuario)
{
int distancia = Distancia_Nodo(arbol, nodoIA, nodoU);
if (Math.Abs(distancia) < menordistancia)
{
nodoIAaMover = nodoIA;
}
}
}
Movimiento mover = obtengoCamino(arbol, nodoIAaMover, menordistancia);
return(mover);
}
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);
}
public Movimiento obtengoCamino(ArbolGeneral <Planeta> arbol, ArbolGeneral <Planeta> ia, int sentido)
{
List <ArbolGeneral <Planeta> > ListaPreorden = arbol.ListaPreOrden();
Movimiento mover = null;
Planeta origen;
Planeta destino;
int posicioIA = -1;
for (int y = 0; y < ListaPreorden.Count; y++)
{
if (ListaPreorden[y].Equals(ia))
{
posicioIA = y;
}
}
if (sentido == -20)
{//ir a raiz
//Es hijo de la raiz
if (posicioIA - 1 % 3 == 0 || posicioIA == 1)
{
//si posicion-1 es divisible por 3 se que es uno de los nodos hijos de la raiz
origen = ListaPreorden[posicioIA].getDatoRaiz();
destino = ListaPreorden[0].getDatoRaiz();
mover = new Movimiento(origen, destino);
}
else
{
//no es hijo de la raiz
origen = ListaPreorden[posicioIA].getDatoRaiz();
destino = ListaPreorden[posicioIA - 1].getDatoRaiz();
mover = new Movimiento(origen, destino);
mover = OpcionMover2ARaiz(arbol);
}
}
else if (sentido > 0)
{
//me muevo para arriba
if (posicioIA - 1 % 3 == 0 || posicioIA == 1)
{
//si posicion-1 es divisible por 3 se que es uno de los nodos hijos de la raiz
origen = ListaPreorden[posicioIA].getDatoRaiz();
destino = ListaPreorden[0].getDatoRaiz();
mover = new Movimiento(origen, destino);
}
else
{
//no es hijo de la raiz
origen = ListaPreorden[posicioIA].getDatoRaiz();
destino = ListaPreorden[posicioIA - 1].getDatoRaiz();
mover = new Movimiento(origen, destino);
}
}
else
{
//me muevo para abajo
if (posicioIA - 1 % 3 == 0 || posicioIA == 1)
{
//si posicion-1 es divisible por 3 se que es uno de los nodos hijos de la raiz
origen = ListaPreorden[posicioIA].getDatoRaiz();
destino = ListaPreorden[posicioIA + 3].getDatoRaiz();
mover = new Movimiento(origen, destino);
}
else
{
//no es hijo de la raiz
origen = ListaPreorden[posicioIA].getDatoRaiz();
destino = ListaPreorden[posicioIA + 1].getDatoRaiz();
mover = new Movimiento(origen, destino);
}
}
return(mover);
}
public int Distancia_Nodo(ArbolGeneral <Planeta> arbol, ArbolGeneral <Planeta> ia, ArbolGeneral <Planeta> Usuario)
{
int nivel = 0;
int nivelIA = -1;
int nivelUsuario = -1;
int horizontal = 0;
int horizontalIA = -1;
int horizontalUsuario = -1;
ArbolGeneral <Planeta> raiz = arbol;
ArbolGeneral <Planeta> nodoIA = ia;
ArbolGeneral <Planeta> nodoUsuario = Usuario;
List <ArbolGeneral <Planeta> > Lista_hijos = new List <ArbolGeneral <Planeta> >();
Lista_hijos.Add(arbol);
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
horizontal = 0;
//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);
horizontal++;
//if (hijo.getDatoRaiz().EsPlanetaDeLaIA())
if (hijo.getDatoRaiz().Equals(nodoIA))
{
// nodoIA = hijo;
nivelIA = nivel;
horizontalIA = horizontal;
}
//if (hijo.getDatoRaiz().EsPlanetaDelJugador())
if (hijo.getDatoRaiz().Equals(nodoUsuario))
{
//nodoUsuario = hijo;
nivelUsuario = nivel;
horizontalUsuario = horizontal;
}
Siguiente_nivel_hijos.Add(hijo);
}
}
Lista_hijos = Siguiente_nivel_hijos;
nivel++;
} while (Siguiente_nivel_hijos.Count > 0);
int restahorizontal = horizontalUsuario - horizontalIA;
int diferenciaDenivel = -20;
if (restahorizontal == 0)
{
diferenciaDenivel = nivelIA - nivelUsuario;
}
//si es -20 significa que estan en otro camino de nodo
// si me da un numero positivo usuario esta arriba si me da negativo usuario esta abajo de
return(diferenciaDenivel);
}