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"; } }