private static string[] InvokeCrop(ComputationRequest request)
{
dim size = new dim
{
x = (uint)request.Width,
y = (uint)request.Height
};
dim zoom_size = new dim
{
x = (uint)request.PartialWidth,
y = (uint)request.PartialHeight
};
dim offset = new dim
{
x = (uint)request.Col,
y = (uint)request.Row
};
StringBuilder sb = new StringBuilder(4 * (int)request.Limit);
crop(sb, request.Limit, request.RMin, request.IMin, request.RMax, request.IMax, size, zoom_size, offset);
string str = sb.ToString();
return(new[]
{
str.Substring(0 * (int)request.Limit, (int)request.Limit),
str.Substring(1 * (int)request.Limit, (int)request.Limit),
str.Substring(2 * (int)request.Limit, (int)request.Limit),
str.Substring(3 * (int)request.Limit, (int)request.Limit)
});
}
private bool SelfWin(int[dim, dim] arr, out int row, out int col)
{
for (int i = 0; i < dim; i++)
{
Program.Win
}
}
public void goHome(int[,] casillas, Pos posI)
{
dim posD = new dim(tam - 1, 0);
dim aux = new dim(posI.j, posI.i);
Resolutor resolutor = new Resolutor(casillas, aux, posD);
StartCoroutine(home(resolutor.camino, aux, posD));
}
public void GoTo(dim Posicion)
{
//Llama al método resolutor con esa posición y la posicion del elemento seleccionado
int coche = (int)(Seleccion_) - 1;
Resolutor resolutor = new Resolutor(matriz, pSeleccion_, Posicion);
if (!resolutor.imposible)
{
StartCoroutine(resolver(resolutor.camino, pSeleccion_, Posicion, coche));
}
//Quita la selección
Seleccion_ = Seleccion.none;
}
IEnumerator home(List <dim> camino, dim origen, dim destino)
{
//Mirar camino mover bicho
for (int i = 1; i <= camino.Count - 1; i++)
{
Debug.Log(camino [i].x + " " + camino [i].y);
Transform childT;
childT = assetsField.GetChild(7);
Transform aux = Piezas.GetChild(camino [i].x * tam + camino [i].y);
if (aux != null)
{
childT.transform.position = aux.position;
}
yield return(new WaitForSecondsRealtime(0.5f));
}
}
IEnumerator resolver(List <dim> camino, dim origen, dim destino, int coche)
{
Transform pieza = Piezas.GetChild(origen.x + origen.y * 10);
TilePR2 logica = pieza.GetComponent <TilePR2>();
Image tileColor = pieza.GetComponent <Image>();
tileColor.color = colores[coche + 1];
bool avanzar = true;
int i;
for (i = 1; avanzar && i <= camino.Count; i++)
{
logica.vuelve();
matriz[camino[i - 1].x, camino[i - 1].y] = logica.estado;
float aux = (float)matriz[camino[i - 1].x, camino[i - 1].y] + 1;
pieza = Piezas.GetChild(camino[i - 1].x + camino[i - 1].y * 10);
logica = pieza.GetComponent <TilePR2>();
tileColor = pieza.GetComponent <Image>();
tileColor.color = colores[coche + 1];
avanzar = logica.avanza(coche);
if (!avanzar)
{
pieza = Piezas.GetChild(camino[i - 2].x + camino[i - 2].y * 10);
logica = pieza.GetComponent <TilePR2>();
logica.avanza(coche);
matriz[camino[i - 2].x, camino[i - 2].y] = logica.estado;
aux = 0;
}
yield return(new WaitForSecondsRealtime(0.5f * aux));
}
actualizaTablero(camino);
if (!avanzar)
{
recalcula(camino[i - 3], destino, coche);
}
}
private static int[] InvokeCompute(ComputationRequest request)
{
int[] iframe = new int[request.PartialWidth * request.PartialHeight];
dim size = new dim
{
x = (uint)request.Width,
y = (uint)request.Height
};
dim partial = new dim
{
x = (uint)request.PartialWidth,
y = (uint)request.PartialHeight
};
dim offset = new dim
{
x = (uint)request.Col * partial.x,
y = (uint)request.Row * partial.y
};
IntPtr ptr = Marshal.AllocHGlobal(sizeof(int) * request.PartialWidth * request.PartialHeight);
try
{
compute(ptr, request.RMin, request.IMin, request.RMax, request.IMax, size, partial, offset, request.Limit);
Marshal.Copy(ptr, iframe, 0, request.PartialWidth * request.PartialHeight);
}
finally
{
Marshal.FreeHGlobal(ptr);
}
return(iframe);
}
public int Seleccionado(dim Posicion, eCasilla estado)
{
matriz[(int)Posicion.x, (int)Posicion.y] = estado;
if ((int)estado > 2) //Es uno de los coches
{
if (Seleccion_ == (Seleccion)((int)estado - 2))
{
Seleccion_ = Seleccion.none;
}
else
{
Seleccion_ = (Seleccion)((int)estado - 2);
pSeleccion_.Set(Posicion.x, Posicion.y);
}
}
else if (estado == eCasilla.bloqueado && Seleccion_ != Seleccion.none)
{
Seleccion_ = Seleccion.none;
}
Fondo.color = colores[(int)Seleccion_];
return((int)(Seleccion_) - 1);
}
///Este es el método que resuelve el problema y devuelve una lista con todas las casillas por las que tiene que pasar
///desde el origen hasta el destino, utilizando el algoritmo A*
public Resolutor(eCasilla[,] estado, dim posOrigen, dim posDestino)
{
//Este será el camino que rellenaremos al final
camino = new List <dim>();
tablero = new Nodo[10, 10];
estados = estado;
destino = posDestino;
origen = posOrigen;
//Cola de prioridad para los nodos adyacentes no checkeados
//Lista con los nodos ya vistos y por los que no hay que volver a pasar
List <Nodo> aCheckear = new List <Nodo>();
//List<Nodo> aCheckear = new List<Nodo>();
List <Nodo> vistos = new List <Nodo>();
CrearNodos();
//Cogemos la casilla inicial y se mete a la lista de no chequeados
Nodo inicio = tablero[origen.x, origen.y];
inicio.padre = inicio;
inicio.G = inicio.g = 0;
inicio.F = inicio.G + inicio.H;
aCheckear.Add(inicio);
bool encontrado = false;
while (aCheckear.Count > 0 && !encontrado)
{
//Cogemos el nodo de menor F de la lista, lo quitamos de ella y lo metemos en los ya checkeados
int pos = 0;
int valorMax = 10000000;
for (int i = 0; i < aCheckear.Count; i++)
{
if (aCheckear[i].F < valorMax)
{
valorMax = aCheckear[i].F;
pos = i;
}
}
Nodo actual = aCheckear[pos];
// Nodo actual = aCheckear.Dequeue();
aCheckear.Remove(actual);
vistos.Add(actual);
//Se miran los adyacentes y se les coloca el nodo actual como padre
//se les pone como valor G su valor actual sumado al de su padre y se calcula su nuevo F
foreach (Pair <int, int> dir in dirs)
{
//Comprobamos si el adyacente está en el tablero
dim nuevaPos = new dim(); nuevaPos.Set(actual.Posicion.x + dir.First, actual.Posicion.y + dir.Second);
if (dentroTablero(nuevaPos))
{
//Comprobamos si el adyacente ya está entre los vistos
if (!vistos.Contains(tablero[nuevaPos.x, nuevaPos.y]))
{
//Comprobamos si el adyacente es una casilla bloqueada
if (tablero[nuevaPos.x, nuevaPos.y].noPasar == true)
{
vistos.Add(tablero[nuevaPos.x, nuevaPos.y]);
}
//Si no lo es, calculamos sus nuevos valores y lo metemos en la lista de pendientes
else
{
//Comprobamos si es nuestro destino y si no, seguimos
if (isGoal(nuevaPos))
{
encontrado = true;
tablero[nuevaPos.x, nuevaPos.y].padre = actual;
}
else
{
//Miramos si es un camino menos costoso que el anterior
int nuevoG = actual.G + tablero[nuevaPos.x, nuevaPos.y].g;
if (nuevoG < tablero[nuevaPos.x, nuevaPos.y].G && aCheckear.Contains(tablero[nuevaPos.x, nuevaPos.y]))
{
tablero[nuevaPos.x, nuevaPos.y].G = nuevoG;
tablero[nuevaPos.x, nuevaPos.y].padre = actual;
}
else if (!aCheckear.Contains(tablero[nuevaPos.x, nuevaPos.y]))
{
tablero[nuevaPos.x, nuevaPos.y].padre = actual;
}
tablero[nuevaPos.x, nuevaPos.y].F = tablero[nuevaPos.x, nuevaPos.y].G + tablero[nuevaPos.x, nuevaPos.y].H;
aCheckear.Add(tablero[nuevaPos.x, nuevaPos.y]);
}
}
}
}
}
}
if (encontrado)
{
calculaCamino();
}
else
{
imposible = true;
}
}
private bool dentroTablero(dim pos)
{
return(pos.x >= 0 && pos.x < 10 && pos.y >= 0 && pos.y < 10);
}
private bool isGoal(dim A)
{
return(A.x == destino.x && A.y == destino.y);
}
private void recalcula(dim origen, dim destino, int coche)
{
Resolutor resolutor = new Resolutor(matriz, origen, destino);
StartCoroutine(resolver(resolutor.camino, origen, destino, coche));
}
private static extern void compute(IntPtr iframe, string r_min, string i_min, string r_max, string i_max, dim size, dim partial_size, dim idx, uint limit);
private static extern void crop(StringBuilder str, uint str_length, string r_min, string i_min, string r_max, string i_max, dim size, dim zoom_size, dim offset);
