protected override void OnResize(EventArgs e)
{
if (DesignMode || History == null)
{
return;
}
if (Width == 0 || Height == 0)
{
base.OnResize(e);
return;
}
DataHistory newHistory = new DataHistory(Width);
newHistory.FullMin = ValueMin;
newHistory.FullMax = ValueMax;
foreach (double value in History)
{
newHistory.UpdateValue(value);
}
History = newHistory;
Refresh();
base.OnResize(e);
}
//Codigo NReinas.
public Tuple <int[, ], bool> NReinas(int[,] board, int fil, int[,] boardVisualizer, List <int> vectorSolucion)
{
bool esSol;
if (fil >= tamaño)
{
esSol = true;
int[,] aux = new int[tamaño, tamaño];
for (int i = 0; i < tamaño; i++)
{
for (int j = 0; j < tamaño; j++)
{
aux[i, j] = boardVisualizer[i, j];
}
}
var factibles = EsFactible(board, fil, tamaño - 1);
data = new DataHistory(aux, fil, tamaño - 1, factibles.Item1, factibles.Item2, factibles.Item3, esSol);
//Guardamos el ultimo tablero y lo añadimos a la lista.
boardHistory.Add(data);
}
else
{
esSol = false;
int col = 0;
while (esSol == false && col < tamaño)
{
boardVisualizer[fil, col] = 1;
int[,] aux = new int[tamaño, tamaño];
for (int i = 0; i < tamaño; i++)
{
for (int j = 0; j < tamaño; j++)
{
aux[i, j] = boardVisualizer[i, j];
}
}
var factibles = EsFactible(board, fil, col);
data = new DataHistory(aux, fil, col, factibles.Item1, factibles.Item2, factibles.Item3);
//Añadimos cada uno de los tableros a la lista, con su correspondientes variables.
boardHistory.Add(data);
if (factibles.Item1 && factibles.Item2 && factibles.Item3)
{
board[fil, col] = 1;
var result = NReinas(board, fil + 1, boardVisualizer, vectorSolucion);
board = result.Item1;
esSol = result.Item2;
if (esSol == false)
{
board[fil, col] = 0;
}
}
if (esSol == false)
{
boardVisualizer[fil, col] = 0;
}
col += 1;
}
}
return(Tuple.Create(board, esSol));
}
//Pintamos el tablero pero esta vez pintando la diagonal2 en la que estamos de su color correspondiente.
public void printBoardDiag2(DataHistory boardHistory)
{
tablero.text = "Tab\n";
vectorSolucionText.text = "";
for (int i = 0; i < tamaño; i++)
{
reinas[i].GetComponent <Image>().color = Color.white;
for (int j = 0; j < tamaño; j++)
{
if (boardHistory.vectorSolucion != null && i == boardHistory.fil && j == boardHistory.col)
{
targetPosition.transform.position = piezasTablero[i, j].transform.position;
moverReina = true;
//reinas[i].transform.position = piezasTablero[i, j].transform.position;
if (boardHistory.diag2Ok)
{
reinas[i].GetComponent <Image>().color = Color.green;
piezasTablero[i, j].GetComponent <Image>().color = Color.green;
tablero.text += "<color=green>" + boardHistory.board[i, j] + "</color> ";
}
else
{
reinas[i].GetComponent <Image>().color = Color.red;
piezasTablero[i, j].GetComponent <Image>().color = Color.red;
tablero.text += "<color=red>" + boardHistory.board[i, j] + "</color> ";
}
}
else
{
if (boardHistory.diag2Ok && printDiag2(boardHistory.fil, boardHistory.col, i, j))
{
piezasTablero[i, j].GetComponent <Image>().color = Color.green;
tablero.text += "<color=green>" + boardHistory.board[i, j] + "</color> ";
}
else if (boardHistory.diag2Ok == false && printDiag2(boardHistory.fil, boardHistory.col, i, j))
{
piezasTablero[i, j].GetComponent <Image>().color = Color.red;
tablero.text += "<color=red>" + boardHistory.board[i, j] + "</color> ";
}
else
{
piezasTablero[i, j].GetComponent <Image>().color = Color.white;
tablero.text += boardHistory.board[i, j] + " ";
}
}
}
tablero.text += "\n";
}
if (boardHistory.vectorSolucion != null)
{
for (int i = 0; i < boardHistory.vectorSolucion.Count; i++)
{
vectorSolucionText.text += boardHistory.vectorSolucion[i] + " ";
}
}
}
private void CreateThrustGraph(DataHistory data)
{
data.Clear();
float scale = 1000.0f / (data.MaxLength - 1);
for (float x = 0; x <= 1000.0f; x += scale)
{
data.UpdateValue(InputManager.ThrustMax * InputManager.MapThrust(x / 1000.0f));
}
}
private void CreateInputGraph(DataHistory data, float exp)
{
data.Clear();
float scale = 1000.0f / (data.MaxLength - 1);
for (float x = -500; x <= 500.0f; x += scale)
{
data.UpdateValue(500 * InputManager.MapInputOneToOne(x / 500.0f, 0.5, exp));
}
}
//Este método pintará el siguiente estado del laberinto y esperara un numero de segundos.
IEnumerator waitForNextText(DataHistory laberinto, bool lastMove, DataHistory laberintoAnterior)
{
faseDePintado(laberinto, fase, lastMove, laberintoAnterior);
yield return(new WaitForSeconds(speedNextMove.value));
var results = menu.waitForNextText(lastMove, fase, nextText, nextStep, laberinto, problem);
nextStep = results.Item1;
nextText = results.Item2;
fase = results.Item3;
}
//Este método pintará el siguiente estado del tablero y esperara un numero de segundos.
IEnumerator waitForNextText(DataHistory boardHistory, bool lastMove)
{
faseDePintado(boardHistory, fase, lastMove);
yield return(new WaitForSeconds(speedNextMove.value));
var results = menu.waitForNextText(lastMove, fase, nextText, nextStep, boardHistory, problem);
nextStep = results.Item1;
nextText = results.Item2;
fase = results.Item3;
}
void Start()
{
//Actualizamos el texto compartido
kActualText.text = "K actual:";
//Inicializacion de variables
tamaño = 12;
laberintoHistory = new List <DataHistory>();
textos = new List <List <TextMeshProUGUI> >();
textosSinPintar = new List <List <string> >();
menu = new SharedCode();
//Inicializacion de laberintos y textos
int[,] lab = inicializarLaberinto();
int[,] labVisualizer = inicializarLaberinto();
inicializarTextos();
int paso = 1;
lab[Xini, Yini] = paso;
labVisualizer[Xini, Yini] = paso;
int[,] aux = new int[tamaño, tamaño];
for (int u = 0; u < tamaño; u++)
{
for (int j = 0; j < tamaño; j++)
{
aux[u, j] = lab[u, j];
}
}
//Laberinto inicial.
laberintoBase = new DataHistory(aux, Xini, Yini, 1, false, true);
//Solucionamos el problema
resolverLaberintoVA(lab, labVisualizer, Xini, Yini, paso + 1);
piezasTablero = new GameObject[tamaño, tamaño];
//Guardamos la referencia visual de cada una de las piezas del laberinto en piezasTablero, para poder acceder a ellas.
int indiceX = 0;
int indiceY = 0;
int i = 0;
for (i = 0; i < tamaño * tamaño; i++)
{
if (indiceY >= tamaño)
{
indiceX += 1;
indiceY = 0;
}
piezasTablero[indiceX, indiceY] = objetoTablero.transform.GetChild(i).gameObject;
indiceY += 1;
}
pintarEstadoTablero(laberintoHistory[0].board);
}
//Pinta el primer paso del tablero en cada llamada recursiva indicando en que casilla estamos.
public void printBoardFirstStep(DataHistory boardHistory)
{
tablero.text = "Tab\n";
vectorSolucionText.text = "";
for (int i = 0; i < tamaño; i++)
{
reinas[i].GetComponent <Image>().color = Color.white;
if (i > boardHistory.fil)
{
reinas[i].transform.position = new Vector3(posicionXInicial, reinas[i].transform.position.y, reinas[i].transform.position.z);
}
for (int j = 0; j < tamaño; j++)
{
if (boardHistory.vectorSolucion != null && i == boardHistory.fil && j == boardHistory.col)
{
//Obtenemos la posicion a la que se tiene que mover la reina.
targetPosition.transform.position = piezasTablero[i, j].transform.position;
moverReina = true;
reinas[i].GetComponent <Image>().color = Color.cyan;
piezasTablero[i, j].GetComponent <Image>().color = Color.white;
tablero.text += "<color=cyan>" + boardHistory.board[i, j] + "</color> ";
}
else
{
piezasTablero[i, j].GetComponent <Image>().color = Color.white;
tablero.text += boardHistory.board[i, j] + " ";
}
}
tablero.text += "\n";
}
if (boardHistory.vectorSolucion != null)
{
for (int i = 0; i < boardHistory.vectorSolucion.Count; i++)
{
vectorSolucionText.text += boardHistory.vectorSolucion[i] + " ";
}
}
colText.color = Color.white;
diag1Text.color = Color.white;
diag2Text.color = Color.white;
}
//Este método pintará la fase actual de la ejecucion, además de elegir el camino en caso de encontrarnos en un if o else, en base a los valores guardados en nuestro boardHistory, el cual guarda todos los valores de cada una de las fases del tablero.
public void faseDePintado(DataHistory boardHistory, int fase, bool lastMove)
{
esSolActualText.text = "EsSol actual: " + boardHistory.esSol;
if (boardHistory.esSol)
{
for (int j = 0; j < boardHistory.vectorSolucion.Count - 1; j++)
{
llamadasRecursivas[j].gameObject.SetActive(false);
}
pieLlamada[0].text = "" + 1;
}
int camino = 0;
switch (fase)
{
case 0:
//Pintamos el primer paso del tablero
printBoardFirstStep(boardHistory);
break;
case 2:
//Si es el ultimo tablero, es decir la solucion, finalizará la ejecucion, sino seguira con ella, este se trata del primer if del codigo.
if (lastMove)
{
camino = 0;
}
else
{
camino = 1;
}
break;
case 3:
//Continuacion del caso anterior
if (lastMove)
{
finished = true;
camino = 0;
}
else
{
camino = 1;
}
break;
case 5:
printBoardFirstStep(boardHistory);
break;
case 6:
//Desactivamos el esFactible para que no sea visible si es un paso atras.
if (backStep)
{
defEsFactibleFunc.gameObject.SetActive(false);
}
break;
case 7:
//Activamos el esFactible para que no sea visible si es un paso adelante.
printBoardFirstStep(boardHistory);
defEsFactibleFunc.gameObject.SetActive(true);
break;
case 8:
//Pintamos la columna del tablero, de verde en caso de ser factible y de rojo en caso de no serlo.
printBoardCol(boardHistory);
break;
case 9:
//Pintamos la diagonal 1 del tablero, de verde en caso de ser factible y de rojo en caso de no serlo.
printBoardDiag1(boardHistory);
break;
case 10:
//Pintamos la diagonal 2 del tablero, de verde en caso de ser factible y de rojo en caso de no serlo.
printBoardDiag2(boardHistory);
break;
case 11:
//Volvemos a pintar el tablero como en el primer paso para quitar los colores.
printBoardFirstStep(boardHistory);
if (backStep)
{
defEsFactibleFunc.gameObject.SetActive(true);
}
break;
case 12:
defEsFactibleFunc.gameObject.SetActive(false);
//Aqui nos encontramos ante el segundo if del problema en el cual tambien tendremos que elegir entre los dos caminos.
if (boardHistory.colOk && boardHistory.diag1Ok && boardHistory.diag2Ok)
{
camino = 0;
}
else
{
camino = 1;
}
break;
}
menu.pila(fase, camino, i, backStep, textosSinPintar, boardHistory, problem);
}
//Añade el texto al que hemos avanzado a la pila con su correspondiente fase, además de marcar el texto en el que estamos coloreandolo y quitar el color a todos los demás
public void pila(int fase, int camino, int iteracion, bool backStep, List <List <string> > textosSinPintar, DataHistory board, int problem)
{
//Limpiamos el color de todos los textos
for (int i = 0; i < piscinaTextos.Count; i++)
{
for (int j = 0; j < piscinaTextos[i].Count; j++)
{
piscinaTextos[i][j].text = piscinaTextosOriginal[i][j];
piscinaTextos[i][j].color = Color.white;
}
}
//Actualizamos el texto por pantalla y lo coloreamos de azul
piscinaTextos[fase][camino].text = textosSinPintar[fase][camino];
piscinaTextos[fase][camino].color = Color.cyan;
//Dependiento del problema en el que estemos, habrá unas excepciones para pintar u otras.
switch (problem)
{
case 1:
if (board.colOk && fase == 8)
{
piscinaTextos[fase][camino].color = Color.green;
}
else if (!board.colOk && fase == 8)
{
piscinaTextos[fase][camino].color = Color.red;
}
if (board.diag1Ok && fase == 9)
{
piscinaTextos[fase][camino].color = Color.green;
}
else if (!board.diag1Ok && fase == 9)
{
piscinaTextos[fase][camino].color = Color.red;
}
if (board.diag2Ok && fase == 10)
{
piscinaTextos[fase][camino].color = Color.green;
}
else if (!board.diag2Ok && fase == 10)
{
piscinaTextos[fase][camino].color = Color.red;
}
break;
case 2:
if (board.filOk && fase == 13)
{
piscinaTextos[fase][camino].color = Color.green;
}
else if (!board.filOk && fase == 13)
{
piscinaTextos[fase][camino].color = Color.red;
}
if (board.colOk && fase == 14)
{
piscinaTextos[fase][camino].color = Color.green;
}
else if (!board.colOk && fase == 14)
{
piscinaTextos[fase][camino].color = Color.red;
}
if (board.cuadroOk && fase == 19)
{
piscinaTextos[fase][camino].color = Color.green;
}
else if (!board.cuadroOk && fase == 19)
{
piscinaTextos[fase][camino].color = Color.red;
}
break;
case 3:
if (board.esFactible && fase == 9)
{
piscinaTextos[fase][camino].color = Color.green;
}
else if (!board.esFactible && fase == 9)
{
piscinaTextos[fase][camino].color = Color.red;
}
break;
}
//Solo se añaden textos a la pila cuando se dan pasos hacia delante.
if (backStep == false)
{
pilaEjecucion[iteracion].fases.Add(fase);
pilaEjecucion[iteracion].pilaPintado.Add(piscinaTextos[fase][camino]);
}
}
//Mediante este metodo se avanzaa la fase de pintado, y devuelve cual es el siguiente paso.Bien sea avanzar en la ejecucion de la funcion o realizar una llamada recursiva.
public Tuple <bool, bool, int> waitForNextText(bool lastMove, int fase, bool nextText, bool nextStep, DataHistory board, int problem)
{
//En cada problema la llamada recursiva se hace en una fase del pintado diferente, por tanto hay un caso para cada problema.
if (!(lastMove && fase == 3))
{
switch (problem)
{
case 1:
if (!(board.colOk && board.diag1Ok && board.diag2Ok) && fase == 12)
{
fase = 5;
nextStep = true;
}
else if (fase == 13)
{
fase = 0;
nextStep = true;
}
break;
case 2:
if (board.numeroBase && fase == 8)
{
fase = 0;
nextStep = true;
}
else if (!(board.colOk && board.filOk && board.cuadroOk) && fase == 21)
{
fase = 10;
nextStep = true;
}
else if (fase == 22)
{
fase = 0;
nextStep = true;
}
break;
case 3:
if (!board.esFactible && fase == 10)
{
fase = 6;
nextStep = true;
}
else if (fase == 11)
{
fase = 0;
nextStep = true;
}
break;
}
if (!nextStep)
{
nextText = true;
}
}
//Esto devolvera si bien hay que hacer una llamada recursiva, es decir nextStep=true, o bien simplemente hay que avanzar el texto de la llamada en la que estamos.
return(Tuple.Create(nextStep, nextText, fase));
}
//Este método pintará la fase actual de la ejecucion, además de elegir el camino en caso de encontrarnos en un if o else, en base a los valores guardados en nuestro laberintoHistory, el cual guarda todos los valores de cada una de las fases del laberinto.
public void faseDePintado(DataHistory laberintoHistory, int fase, bool lastMove, DataHistory laberintoAnterior = null)
{
//Actualizamos los textos mostrados por pantalla
esSolActualText.text = "EsSol actual: " + laberintoHistory.esSol;
kActualText.text = "K actual: " + laberintoHistory.k;
int camino = 0;
switch (fase)
{
case 0:
inicial = laberintoAnterior;
printLaberintoFirstStep(inicial, inicial);
//Actualizamos los textos de la fila y la columna actual
filActualText.text = "Fil actual: " + (inicial.fil + 1);
colActualText.text = "Col actual: " + (inicial.col + 1);
camino = 0;
break;
case 2:
//Si es el ultimo tablero, es decir la solucion, finalizará la ejecucion, sino seguira con ella, este se trata del primer if del codigo.
if (lastMove)
{
camino = 0;
}
else
{
camino = 1;
}
break;
case 3:
//Continuacion del caso anterior
if (lastMove)
{
camino = 1;
}
else
{
camino = 0;
}
break;
case 4:
if (backStep)
{
inicial = laberintoAnterior;
}
printLaberintoFirstStep(inicial, inicial);
//Actualizamos los textos de la fila y la columna actual
filActualText.text = "Fil actual: " + (inicial.fil + 1);
colActualText.text = "Col actual: " + (inicial.col + 1);
camino = 0;
break;
case 6:
//Actualizamos los textos de la fila y la columna actual
filActualText.text = "Fil actual: " + (laberintoHistory.fil + 1);
colActualText.text = "Col actual: " + (laberintoHistory.col + 1);
//Pintamos el primer paso del laberinto
printLaberintoFirstStep(laberintoHistory, inicial);
camino = 0;
break;
case 7:
//Dejamos de mostrar el esFactible si el paso es de retroceso
if (backStep)
{
esFactibleFunction.gameObject.SetActive(false);
}
camino = 0;
break;
case 8:
printLaberintoFirstStep(laberintoHistory, inicial);
//Mostramos el esFactible si el paso es de retroceso
if (!backStep)
{
esFactibleFunction.gameObject.SetActive(true);
}
camino = 0;
break;
case 9:
//Pintamos la casilla del laberinto en base al esfactible de la casilla
printLaberintoColorText(laberintoHistory);
if (backStep)
{
esFactibleFunction.gameObject.SetActive(true);
}
camino = 0;
break;
case 10:
if (!backStep)
{
esFactibleFunction.gameObject.SetActive(false);
}
//Segundo if de la ejecucion si es factible dicho movimiento, entonces pasaremos a la llamada recursiva, sino continuaremos con la ejecucion normal
if (laberintoHistory.esFactible)
{
printLaberintoFirstStep(laberintoHistory, inicial);
camino = 0;
}
else
{
filActualText.text = "Fil actual: " + (inicial.fil + 1);
colActualText.text = "Col actual: " + (inicial.col + 1);
printLaberintoFirstStep(laberintoHistory, inicial);
camino = 1;
}
break;
}
menu.pila(fase, camino, i, backStep, textosSinPintar, laberintoHistory, problem);
}
public Graph()
{
InitializeComponent();
History = new DataHistory(Width);
}
//Codigo resolverLaberinto
public Tuple <int[, ], bool> resolverLaberintoVA(int[,] laberinto, int[,] labVisualizer, int f, int c, int k)
{
bool esSol;
if (f == tamaño - 2 && c == tamaño - 2)
{
esSol = true;
int[,] aux = new int[tamaño, tamaño];
for (int i = 0; i < tamaño; i++)
{
for (int j = 0; j < tamaño; j++)
{
aux[i, j] = labVisualizer[i, j];
}
}
data = new DataHistory(aux, tamaño - 2, tamaño - 2, k, esSol, true, i);
//Guardamos el ultimo tablero y lo añadimos a la lista.
laberintoHistory.Add(data);
}
else
{
esSol = false;
int[][,] mov = new int[][, ] {
new int[, ] {
{ 1, 0 }
}, new int[, ] {
{ 0, 1 }
}, new int[, ] {
{ -1, 0 }
}, new int[, ] {
{ 0, -1 }
}
};
int i = 0;
while (!esSol && i < mov.Length)
{
bool factible = esFactible(laberinto, f + mov[i][0, 0], c + mov[i][0, 1]);
if (factible)
{
labVisualizer[f + mov[i][0, 0], c + mov[i][0, 1]] = k;
}
int[,] aux = new int[tamaño, tamaño];
for (int u = 0; u < tamaño; u++)
{
for (int j = 0; j < tamaño; j++)
{
aux[u, j] = labVisualizer[u, j];
}
}
data = new DataHistory(aux, f + mov[i][0, 0], c + mov[i][0, 1], k, esSol, factible, i);
//Añadimos cada uno de los tableros a la lista, con su correspondientes variables.
laberintoHistory.Add(data);
if (factible)
{
laberinto[f + mov[i][0, 0], c + mov[i][0, 1]] = k;
var results = resolverLaberintoVA(laberinto, labVisualizer, f + mov[i][0, 0], c + mov[i][0, 1], k + 1);
laberinto = results.Item1;
esSol = results.Item2;
if (!esSol)
{
laberinto[f + mov[i][0, 0], c + mov[i][0, 1]] = 0;
labVisualizer[f + mov[i][0, 0], c + mov[i][0, 1]] = 0;
}
}
i += 1;
}
}
return(Tuple.Create(laberinto, esSol));
}
//Pinta el laberinto, marcando la casilla que estamos testeando para ver si nos podemos mover a ella o no, si es factible moverse a ella la coloreara de verde, lo hara de rojo si no lo es.
public void printLaberintoColorText(DataHistory laberintoActual)
{
laberintoText.text = "";
for (int i = 0; i < tamaño; i++)
{
laberintoText.text += "[";
for (int j = 0; j < tamaño; j++)
{
if (laberintoActual.fil == i && laberintoActual.col == j)
{
if (laberintoActual.esFactible)
{
//Pinta lo visual
piezasTablero[i, j].GetComponent <Image>().color = Color.green;
//Pinta la matriz
if (laberintoActual.board[i, j] != -1 && laberintoActual.board[i, j] < 10)
{
if (j != 11)
{
laberintoText.text += " <color=green>" + laberintoActual.board[i, j] + "</color>, ";
}
else
{
laberintoText.text += " <color=green>" + laberintoActual.board[i, j] + "</color>";
}
}
else
{
if (j != 11)
{
laberintoText.text += "<color=green>" + laberintoActual.board[i, j] + "</color>, ";
}
else
{
laberintoText.text += "<color=green>" + laberintoActual.board[i, j] + "</color>";
}
}
}
else
{
//Pinta lo visual
piezasTablero[i, j].GetComponent <Image>().color = Color.red;
//Pinta la matriz
if (laberintoActual.board[i, j] != -1 && laberintoActual.board[i, j] < 10)
{
if (j != 11)
{
laberintoText.text += " <color=red>" + laberintoActual.board[i, j] + "</color>, ";
}
else
{
laberintoText.text += " <color=red>" + laberintoActual.board[i, j] + "</color>";
}
}
else
{
if (j != 11)
{
laberintoText.text += "<color=red>" + laberintoActual.board[i, j] + "</color>, ";
}
else
{
laberintoText.text += "<color=red>" + laberintoActual.board[i, j] + "</color>";
}
}
}
}
else
{
Color color = piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().color;
//Pinta lo visual
if (laberintoActual.board[i, j] == -1)
{
color.a = 0f;
piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().color = color;
piezasTablero[i, j].GetComponent <Image>().color = Color.black;
}
else if (laberintoActual.board[i, j] == 0)
{
color.a = 0f;
piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().color = color;
piezasTablero[i, j].GetComponent <Image>().color = Color.white;
}
else
{
piezasTablero[i, j].GetComponent <Image>().color = Color.grey;
}
//Pinta la matriz
if (laberintoActual.board[i, j] != -1 && laberintoActual.board[i, j] < 10)
{
if (j != 11)
{
laberintoText.text += " " + laberintoActual.board[i, j] + ", ";
}
else
{
laberintoText.text += " " + laberintoActual.board[i, j] + "";
}
}
else
{
if (j != 11)
{
laberintoText.text += laberintoActual.board[i, j] + ", ";
}
else
{
laberintoText.text += laberintoActual.board[i, j] + "";
}
}
}
}
laberintoText.text += "]\n";
}
}
/*
* public void printInitialLaberinto(DataHistory laberintoActual)
* {
* laberintoText.text = "";
* for (int i = 0; i < tamaño; i++)
* {
* laberintoText.text += "[";
* for (int j = 0; j < tamaño; j++)
* {
* if (laberintoActual.fil == i && laberintoActual.col == j)
* {
* piezasTablero[i, j].GetComponent<Image>().color = Color.cyan;
* if (laberintoActual.board[i, j] != -1 && laberintoActual.board[i, j] < 10)
* {
* if (j != 11)
* {
* laberintoText.text += " <color=cyan>" + laberintoActual.board[i, j] + "</color>, ";
* }
* else
* {
* laberintoText.text += " <color=cyan>" + laberintoActual.board[i, j] + "</color>";
* }
* }
* else
* {
* if (j != 11)
* {
* laberintoText.text += "<color=cyan>" + laberintoActual.board[i, j] + "</color>, ";
* }
* else
* {
* laberintoText.text += "<color=cyan>" + laberintoActual.board[i, j] + "</color>";
* }
* }
* }
* else {
* if (laberintoActual.board[i, j] == -1)
* {
* piezasTablero[i, j].GetComponent<Image>().color = Color.black;
* }else if (laberintoActual.board[i, j] == 0)
* {
* piezasTablero[i, j].GetComponent<Image>().color = Color.white;
* }
* else
* {
* piezasTablero[i, j].GetComponent<Image>().color = Color.grey;
* }
* if (laberintoActual.board[i, j] != -1 && laberintoActual.board[i, j] < 10)
* {
* if (j != 11)
* {
* laberintoText.text += " " + laberintoActual.board[i, j] + ", ";
* }
* else
* {
* laberintoText.text += " " + laberintoActual.board[i, j] + "";
* }
* }
* else
* {
* if (j != 11)
* {
* laberintoText.text += laberintoActual.board[i, j] + ", ";
* }
* else
* {
* laberintoText.text += laberintoActual.board[i, j] + "";
* }
* }
* }
*
* }
* laberintoText.text += "]\n";
* }
* }*/
//Pinta el primer paso del laberinto en cada llamada recursiva indicando en que casilla estamos.
public void printLaberintoFirstStep(DataHistory laberintoActual, DataHistory laberintoAnterior)
{
laberintoText.text = "";
for (int i = 0; i < tamaño; i++)
{
laberintoText.text += "[";
for (int j = 0; j < tamaño; j++)
{
if (laberintoActual.fil == i && laberintoActual.col == j)
{
//Pinta la parte visual
piezasTablero[i, j].GetComponent <Image>().color = Color.cyan;
//Pinta la matriz
if (laberintoActual.board[i, j] != -1 && laberintoActual.board[i, j] < 10)
{
if (j != 11)
{
laberintoText.text += " <color=cyan>" + laberintoActual.board[i, j] + "</color>, ";
}
else
{
laberintoText.text += " <color=cyan>" + laberintoActual.board[i, j] + "</color>";
}
}
else
{
if (j != 11)
{
laberintoText.text += "<color=cyan>" + laberintoActual.board[i, j] + "</color>, ";
}
else
{
laberintoText.text += "<color=cyan>" + laberintoActual.board[i, j] + "</color>";
}
}
}
else
{
Color color = piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().color;
//Pinta la parte visual
if (laberintoActual.board[i, j] == -1)
{
color.a = 0f;
piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().color = color;
piezasTablero[i, j].GetComponent <Image>().color = Color.black;
}
else if (laberintoActual.board[i, j] == 0)
{
color.a = 0f;
piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().color = color;
piezasTablero[i, j].GetComponent <Image>().color = Color.white;
}
else
{
//Dibujamos el camino con flechas
int[][,] mov = new int[][, ] {
new int[, ] {
{ 1, 0 }
}, new int[, ] {
{ 0, 1 }
}, new int[, ] {
{ -1, 0 }
}, new int[, ] {
{ 0, -1 }
}
};
if ((laberintoActual.esFactible && (i != 1 || j != 1)) || (backStep && (i != 1 || j != 1)) && (i != laberintoActual.fil || j != laberintoActual.col))
{
if (laberintoActual.board[i, j] == laberintoActual.board[(i + mov[0][0, 0]), (j + mov[0][0, 1])] - 1)
{
piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().sprite = Resources.Load <Sprite>("flecha_down");
}
if (laberintoActual.board[i, j] == laberintoActual.board[(i + mov[1][0, 0]), (j + mov[1][0, 1])] - 1)
{
piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().sprite = Resources.Load <Sprite>("flecha_right");
}
if (laberintoActual.board[i, j] == laberintoActual.board[(i + mov[2][0, 0]), (j + mov[2][0, 1])] - 1)
{
piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().sprite = Resources.Load <Sprite>("flecha_up");
}
if (laberintoActual.board[i, j] == laberintoActual.board[(i + mov[3][0, 0]), (j + mov[3][0, 1])] - 1)
{
piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().sprite = Resources.Load <Sprite>("flecha_left");
}
color.a = 1f;
piezasTablero[i, j].transform.GetChild(0).gameObject.GetComponent <Image>().color = color;
}
piezasTablero[i, j].GetComponent <Image>().color = Color.grey;
}
//Pinta la matriz
if (laberintoActual.board[i, j] != -1 && laberintoActual.board[i, j] < 10)
{
if (j != 11)
{
laberintoText.text += " " + laberintoActual.board[i, j] + ", ";
}
else
{
laberintoText.text += " " + laberintoActual.board[i, j] + "";
}
}
else
{
if (j != 11)
{
laberintoText.text += laberintoActual.board[i, j] + ", ";
}
else
{
laberintoText.text += laberintoActual.board[i, j] + "";
}
}
}
}
laberintoText.text += "]\n";
}
}
