public Unidad buscarPorNombre(string duenyo, string nombre, bool sacar = false)
{
if (areColumnsEmpty() && areRowsEmpty())
{
return(null);
}
NodoAux <Orto <Unidad> > pivote = cabezera_fila;
Orto <Unidad> actual;
Unidad encontrado;
while (pivote != null) //reviso hasta que ya no tenga mas filas
{
actual = pivote.Item.der; //el primer item solo es la raiz, el primer nodo es item.der
while (actual != null) //reviso los nodos en la fila actual
{
encontrado = buscarEnZ(duenyo, nombre, actual, sacar);
if (encontrado != null)//si encontre la unidad
{
return(encontrado);
}
actual = actual.der;
}
pivote = pivote.siguiente;
}
return(null);
}
public bool insertar(Unidad item)//insertar principal
{
Unidad auxiliar = buscarPorPosicion(item.Fila_y, item.Col_x, item.Nivel_z);
if (auxiliar != null) //si ya hay algo en ese espacio
{
return(false); //regreso false y no hago nada mas
}
NodoAux <Orto <Unidad> > row = buscarRow(item.Fila_y);
NodoAux <Orto <Unidad> > col = buscarCol(item.Col_x);
if (row == null)
{
addRow(item.Fila_y);
row = buscarRow(item.Fila_y);//en teoria ya no deberia ser null en este punto
}
if (col == null)
{
addColumn(item.Col_x);
col = buscarCol(item.Col_x);//en teoria ya no deberia ser null en este punto
}
Orto <Unidad> aux = insertarEnColumna(col.item, col.item.down, item, item.Fila_y, item.Col_x);
if (aux == null) //el espacio esta ocupado
{
return(false); //esto ya no deberia ocurrir gracias a la inclusion de buscar, pero de todas formas
}//en caso de un error podria llegar aqui y es mejor que regrese false a que tire una excepcion
insertarEnFila(row.item, row.item.der, aux);
return(true);
}
private static string codigoDisperso(MatrizOrtogonal tablero, int nivel, bool vivos)
{
string salida = "digraph g{\n";
NodoAux <Orto <Unidad> > fila = tablero.cabezera_fila;
NodoAux <Orto <Unidad> > columna = tablero.cabezera_columna;
//Node<NodoO> aux = tablero.esquina;
salida += "{rank=same;\n esquina[color=white,label=\"\"];\n";
salida += codigoColumna(columna);
salida += codigoFila(fila);
salida += codigoNodos(fila, nivel, vivos);//aqui veo que nivel quiero graficar
salida += "}";
return(salida);
}
public NodoAux <Orto <Unidad> > buscarRow(int fila)
{
NodoAux <Orto <Unidad> > aux = cabezera_fila;
while (aux != null)
{
if (aux.Key == fila)
{
break;
}
else if (aux.Key > fila)//ya se paso
{
return(null);
}
aux = aux.siguiente;
}
return(aux);
}
private NodoAux <Orto <Unidad> > buscarCol(string columna)
{
NodoAux <Orto <Unidad> > aux = cabezera_columna;
while (aux != null)
{
if (aux.Key_.Equals(columna))
{
break;
}
else if (aux.Key_.CompareTo(columna) > 0)//ya se paso
{
return(null);
}
aux = aux.siguiente;
}
return(aux);
}
public Unidad buscarPorPosicion(int fila, string columna, int z)
{
NodoAux <Orto <Unidad> > row = buscarRow(fila);
if (row != null)//si la fila existe es porque mínimo hay un nodo en esa fila
{
//NodoO aux = buscarUnidad(row.item, row.item.der, fila, columna);
Orto <Unidad> aux = buscarNodoUnidad(row.item.der, row.item.der.der, fila, columna);
if (aux == null)//si no se encontro algo en fila,columna
{
return(null);
}
aux = buscarZ(z, aux);
if (aux != null)//si se encontro algo en fila, columna, z
{
return(aux.Item);
}
}
return(null);//si no encontro el valor
}
private void addColumn(NodoAux <Orto <Unidad> > actual, NodoAux <Orto <Unidad> > siguiente, string key_)
{
if (siguiente == null)
{
actual.siguiente = new NodoAux <Orto <Unidad> >(new Orto <Unidad>());
actual.siguiente.anterior = actual;
actual.siguiente.Key_ = key_;
}
else if (siguiente.Key_.CompareTo(key_) < 0)//el nuevo va mas a la derecha
{
addColumn(siguiente, siguiente.siguiente, key_);
}
else if (siguiente.Key_.CompareTo(key_) > 0) //el nuevo va despues de actual, pero antes de siguiente
{
actual.siguiente = new NodoAux <Orto <Unidad> >(new Orto <Unidad>()); //actual apunta al nuevo
actual.siguiente.anterior = actual; //el nuevo apunta a actual
actual.siguiente.siguiente = siguiente; //nuevo apunta al siguiente
siguiente.anterior = actual.siguiente; //siguiente apunta al nuevo
actual.siguiente.Key_ = key_; //nuevo
}
//si el valor es repetido se descarta
}
private void addRow(NodoAux <Orto <Unidad> > actual, NodoAux <Orto <Unidad> > siguiente, int key)
{
if (siguiente == null)
{
actual.siguiente = new NodoAux <Orto <Unidad> >(new Orto <Unidad>());
actual.siguiente.anterior = actual;
actual.siguiente.Key = key;
}
else if (siguiente.Key < key)//el nuevo va mas a la derecha
{
addRow(siguiente, siguiente.siguiente, key);
}
else if (siguiente.Key > key) //el nuevo va despues de actual, pero antes de siguiente
{
actual.siguiente = new NodoAux <Orto <Unidad> >(new Orto <Unidad>()); //actual apunta al nuevo
actual.siguiente.Key = key;
actual.siguiente.anterior = actual; //el nuevo apunta a actual
actual.siguiente.siguiente = siguiente; //nuevo apunta al siguiente
siguiente.anterior = actual.siguiente; //siguiente apunta al nuevo
}
//si el valor es repetido se descarta
}
private void addRow(int key)
{
if (areRowsEmpty())
{
cabezera_fila = new NodoAux <Orto <Unidad> >(new Orto <Unidad>()); //lo hago vacio porque los nodos columnas tienen un ortogonal de raiz que solo apunta a los verdaderos nodos, pero el no lleva nada dentro
cabezera_fila.Key = key; //le agrego el titulo a la nueva columna
}
else
{
if (key < cabezera_fila.Key)
{
cabezera_fila.anterior = new NodoAux <Orto <Unidad> >(new Orto <Unidad>()); //raiz apunta al nuevo, que va antes
cabezera_fila.anterior.siguiente = cabezera_fila; //el nuevo apunta a la raiz
cabezera_fila = cabezera_fila.anterior; //se actualiza la raiz
cabezera_fila.Key = key;
}
else
{
addRow(cabezera_fila, cabezera_fila.siguiente, key);
}
}
}
private void addColumn(string key_)
{
if (areColumnsEmpty())
{
cabezera_columna = new NodoAux <Orto <Unidad> >(new Orto <Unidad>()); //lo hago vacio porque los nodos columnas tienen un ortogonal de raiz que solo apunta a los verdaderos nodos, pero el no lleva nada dentro
cabezera_columna.Key_ = key_; //le agrego el titulo a la nueva columna
}
else
{
if (key_.CompareTo(cabezera_columna.Key_) < 0)
{
cabezera_columna.anterior = new NodoAux <Orto <Unidad> >(new Orto <Unidad>()); //raiz apunta al nuevo, que va antes
cabezera_columna.anterior.siguiente = cabezera_columna; //el nuevo apunta a la raiz
cabezera_columna = cabezera_columna.anterior; //se actualiza la raiz
cabezera_columna.Key_ = key_;
}
else
{
addColumn(cabezera_columna, cabezera_columna.siguiente, key_);
}
}
}
private static string codigoFila(NodoAux <Orto <Unidad> > fila)
{
string salida = "subgraph cluster_fila{\n";
NodoAux <Orto <Unidad> > aux = fila;
while (aux != null)
{
salida += "row" + aux.Key + "[label=\"" + aux.Key + "\";shape=box;height=.7;width=.7;fixedsize=true];\n";
if (aux.anterior != null)
{
salida += "row" + aux.Key + "->row" + aux.anterior.Key + ";\n";
salida += "row" + aux.anterior.Key + "->row" + aux.Key + ";\n";
}
aux = aux.siguiente;
}
if (fila != null)
{
salida += "esquina->row" + fila.Key + "[color=transparent];\n";
}
salida += "}\n";
return(salida);
}
private static string codigoColumna(NodoAux <Orto <Unidad> > columna)
{
string salida = "subgraph cluster_columna{\n";
NodoAux <Orto <Unidad> > aux = columna;
while (aux != null)
{
salida += "col" + aux.Key_ + "[label=\"" + aux.Key_ + "\";shape=box;height=.7;width=.7;fixedsize=true];\n";
if (aux.anterior != null)
{
salida += "col" + aux.Key_ + "->col" + aux.anterior.Key_ + ";\n";
salida += "col" + aux.anterior.Key_ + "->col" + aux.Key_ + ";\n";
}
aux = aux.siguiente;
}
if (columna != null)
{
salida += "esquina->col" + columna.Key_ + "[color=transparent];\n";
}
salida += "}\n}\n";
return(salida);
}
private void eliminarFila(int fila)
{
NodoAux <Orto <Unidad> > aux = buscarRow(fila);
if (aux.anterior == null && aux.siguiente == null)//es la unica fila
{
cabezera_fila = null;
}
else if (aux.anterior == null) //es la raiz
{
aux.siguiente.anterior = null; //elimio el puntero a este
cabezera_fila = aux.siguiente; //muevo la raiz
}
else if (aux.siguiente == null) //es el ultimio
{
aux.anterior.siguiente = null; //simplemente elimino el puntero a este
}
else//esta en medio
{
aux.anterior.siguiente = aux.siguiente; //anterior apunta a siguiente de aux
aux.siguiente.anterior = aux.anterior; //siguiente apunta a anterior de aux
}
}
public NodoAux()
{
anterior = siguiente = null;
}
private static string codigoTableroCompleto(MatrizOrtogonal tablero, int nivel)//siempre muestra solo los vivos, este es solo para clientes
{
string salida = "digraph g{\n"
+ "node[shape=plaintext];\n";
salida += "matriz[label=<<TABLE border=\"0\" cellspacing=\"0\" cellborder=\"1\">\n";
NodoAux <Orto <Unidad> > fila = tablero.cabezera_fila;
char char_1 = (char)65;
char char_2 = (char)64;
//char char_3;
#region Encabezados columnas
salida += "<TR>";
salida += "<TD width=\"100\" height=\"100\" fixedsize=\"true\"></TD>\n"; //esta es la esquina
for (int i = 0; i < tablero.Max_columnas; i++) //headers
{
if (i < 26) //una letra
{
salida += "<TD width=\"100\" height=\"100\" fixedsize=\"true\">" + char_1 + "</TD>\n";
char_1++;
}
else if (i >= 26 && i < 702)//dos letras
{
if (char_1 > 90)
{
char_1 = (char)65;//regresa a ser A
char_2++;
}
salida += "<TD width=\"100\" height=\"100\" fixedsize=\"true\">" + char_2 + char_1 + "</TD>\n";
char_1++;
}//que ganas hacer mas letras
}
salida += "</TR>\n";
#endregion
#region Filas y todo lo demas
for (int i = 1; i <= tablero.Max_filas; i++)
{
salida += "<TR>\n";
if (i < 10)
{
salida += "<TD width=\"100\" height=\"100\" fixedsize=\"true\">" + i + "</TD>\n";//cabezera de fila
}
else
{
salida += "<TD width=\"100\" height=\"100\" fixedsize=\"true\">" + i + "</TD>\n";//cabezera de fila
}
NodoAux <Orto <Unidad> > aux = tablero.buscarRow(i);
char_1 = (char)65; //reseteamos las columnas
char_2 = (char)64; //de busqueda
if (aux != null) //si la fila existe
{
for (int j = 1; j <= tablero.Max_columnas; j++, char_1++) //reviso todos los espacios
{
if (char_1 > 90) //si me paso de z
{
char_1 = (char)65;
char_2++; //uso otra letra
}
Unidad actual; //busco a la unidad
if (j < 26)
{
actual = tablero.buscarPorPosicion(i, char_1.ToString(), nivel);
}
else
{
string row = char_2.ToString() + char_1.ToString();
actual = tablero.buscarPorPosicion(i, row, nivel);
}
if (actual != null && actual.Vivo == true) //si encuentro algo y esta vivo(no es necesario el true pero por si acaso)
{
salida += "<TD width=\"100\" height=\"100\" fixedsize=\"true\">" + actual.Nombre + "<br/>HP:" + actual.Hp + "<br/>" + actual.Duenyo + "</TD>\n"; //agrego su info
}
else
{
salida += "<TD width=\"100\" height=\"100\" fixedsize=\"true\"></TD>\n";
}
}
}
else//si la fila no existe
{
for (int j = 0; j < tablero.Max_columnas; j++)
{
salida += "<TD width=\"100\" height=\"100\" fixedsize=\"true\"></TD>\n";
}
}
salida += "</TR>";
}
#endregion
salida += "</TABLE>>];\n"
+ "}";
return(salida);
}
private static string codigoNodos(NodoAux <Orto <Unidad> > fila, int nivel, bool vivo)
{
string salida = "";
NodoAux <Orto <Unidad> > aux = fila;
Orto <Unidad> actual;
Orto <Unidad> actual_Z;
while (aux != null)
{
actual = aux.item;
actual = actual.der;//el primero es la raiz y ese no tiene nada
salida += "{rank=same;\n";
while (actual != null)
{
actual_Z = buscarZ(nivel, actual); //este seria el nodo en el nivel que estoy buscando
if (actual_Z != null && actual_Z.Item.Vivo == vivo) //si hay algo en ese nivel, y es el estado que quiero
{
Unidad coso = actual_Z.Item;
salida += "orto" + coso.Fila_y + "_" + coso.Col_x
+ "[label=\"" + coso.Tipo + "\nVida:" + coso.Hp + "\nMov:" + coso.Movimiento
+ "\nRango:" + coso.Alcance + "\";shape=box;height=.7;width=.7;fixedsize=true;fontsize=8];\n";
if (actual.izq.Item == null)//apunta a la raiz que esta dentro de la fila, necesito usar a nodo raiz, no a nodo Z
{
salida += "row" + aux.Key + "->orto" + coso.Fila_y + "_" + coso.Col_x + "[dir=both;weight=0];\n";
}
if (actual.izq.Item != null) //apunta a una unidad
{
Orto <Unidad> companyero_izq = buscarZ(nivel, actual.izq); //busco a ver si tiene un compañero
if (companyero_izq != null && companyero_izq.Item.Vivo == vivo) //el codigo no necesita que lo haga con actual Z o companyero, eso da igual
{
salida += "orto" + actual.izq.Item.Fila_y + "_" + actual.izq.Item.Col_x + "->orto" + coso.Fila_y + "_" + coso.Col_x + "[dir=both;weight=0];\n";
}
}
}
actual = actual.der;
}
salida += "}\n";
actual = aux.item;
actual = actual.der; //el primero es la raiz y ese no tiene nada
while (actual != null) //columnas
{
actual_Z = buscarZ(nivel, actual); //para terminar, con las columnas
if (actual_Z != null)
{
Unidad coso = actual_Z.Item;
if (actual.up.Item != null) //no es la raiz
{
Orto <Unidad> companyero_izq = buscarZ(nivel, actual.up); //busco a ver si tiene un compañero
salida += "orto" + actual.up.Item.Fila_y + "_" + actual.up.Item.Col_x + "->orto" + actual.Item.Fila_y + "_" + actual.Item.Col_x + "[dir=both];\n";
}
else// (actual.up.item == null)
{
salida += "col" + actual.Item.Col_x + "->orto" + actual.Item.Fila_y + "_" + actual.Item.Col_x + "[dir=both];\n";
}
}
actual = actual.der;
}
salida += "\n";
aux = aux.siguiente;
}
return(salida);
}
public MatrizOrtogonal()
{
cabezera_columna = cabezera_fila = null;
}