En este Tutorial de Unity aprenderemos sobre los “Bucles” en programación, conoceremos y haremos ejercicios con los Bucles “for”, “foreach” y “while”.
Tutorial de Unity Nivel: Principiante.
8.1 Bucles.
En programación, podemos definir a los “Bucles” como sentencias que, a partir de una condición, se encargan de ejecutar un bloque de código repetidamente, hasta que dicha condición se cumpla (cumpliéndose la condición, se deja de ejecutar el bloque de código y se prosigue con otras instrucciones).
Los Bucles más utilizados son los llamados “for”, “foreach” y “while”.
8.2 Bucle “for”.
Este Bucle nos es de mucha utilidad en situaciones donde conocemos o tenemos idea del “número de veces” que nuestro bloque de código se necesita repetir. Durante su funcionamiento, el Bucle “for” no evalúa solo una “condición”, sino toda una “expresión” (dentro de la cual se encuentra la condición, misma que al volverse “false” hará que el Bucle se detenga).
La estructura del Bucle “for” es la siguiente:
for (“variable de control” ; “condición a evaluar” ; “iteración”) {
//Bloque de Código a Ejecutar
}
La “variable de control” es, una variable que “creamos e inicializamos” para usarla dentro del Bucle (por eso se le llama “de control”, porque nos ayuda a controlar lo que sucede). La manera más habitual de crear e inicializar la “variable de control” es:
int i = n;
Nota: Por convención se usa el Tipo de Dato “int” con nombre de variable “i” (aunque esto se puede modificar si la situación lo amerita). Y “n” significa que es necesario inicializar nuestra variable con un valor numérico.
La “condición a evaluar” es, la condición que necesitamos que se cumpla para que el Bucle se detenga. En esta condición, lo más recomendable es que nuestra “variable de control” esté involucrada. Además, hay que recordar que necesitamos que la “condición a evaluar” de como resultado ”false” para que el Bucle se detenga (en otras palabras, desde un inicio la “condición a evaluar” debe dar como resultado “true” para que el Bucle comience a ejecutar su bloque de código).
Un ejemplo de la “condición a evaluar” es:
i < m;
Nota: Para este ejemplo (“i” menor que “m”), “m” representa un valor numérico del mismo tipo que la variable “i”, y se requiere que este sea mayor que “n” (porque si inicializamos a nuestra variable “i” con un valor mayor que “m”, el Bucle no ejecutará su bloque de código).
La “iteración” es, una operación matemática con la finalidad de hacer que el valor de la “variable de control” cambie y con ello, volver la “condición a evaluar” “false”.
Continuando con el ejemplo anterior, la “iteración” se puede escribir como:
i++
Nota: Lo anterior significa que nuestra variable “i” toma su valor actual y lo incrementa en “1” cada vez que el Bucle “for” evalúa la expresión (algo muy parecido a tener “i = i + 1”). Con ello esperamos que el valor de “i” crezca y en algún momento supere al valor de “m”, para así detener la ejecución del Bucle.
Uniendo los ejemplos anteriores, tenemos un Bucle “for” de la siguiente manera:
for (int i = n ; i < m ; i++) {
//Bloque de Código a Ejecutar
}
Si usáramos valores numéricos para “n” y “m”, nuestro Bucle se vería así:
for (int i = 1 ; i < 4 ; i++) {
//Bloque de Código a Ejecutar
}
Nota: Con este ejemplo, nuestro “Bloque de Código” se ejecutaría tres veces, porque al inicio nuestra “variable de control” se crea y se inicializa como “i = 1”, después, al evaluar “i < 4” o mejor dicho “1 < 4” (“uno es menor a cuatro”) nos da como resultado “verdadero” (“true”), debido a esto se ejecuta el “Bloque de Código” (por primera vez), después, gracias a la “iteración” “i++” (que es muy similar a “i = i + 1”, en otras palabras “i = 1 + 1”), se cambia el valor de la “variable de control” a “i = 2”, se vuelve a evaluar la condición, como “2 < 4” es verdadero (“true”), se ejecuta nuevamente el “Bloque de Código” (por segunda vez), después, gracias a la “iteración” “i++” ( “i = 2 + 1”), se cambia el valor de la “variable de control” a “i = 3”, como “3 < 4” es verdadero (“true”), se ejecuta otra vez el “Bloque de Código” (por tercera vez), finalmente, gracias a la “iteración” “i++” ( “i = 3 + 1”), se cambia el valor de la “variable de control” a “i = 4”, como “4 < 4” (cuatro es menor que cuatro) es falso (“false”), ya no se ejecuta el “Bloque de Código” (y se continua con el Script).
El Bucle “for” puede tener un sinnúmero de aplicaciones, además es de gran utilidad cuando trabajamos con Arreglos de Datos Unidimensionales y Multidimensionales que utilizan un “Índice”, ya que podemos recorrer todos los valores de este, usando la “iteración” del Bucle.
Si quieres conocer más sobre el Bucle “for”, puedes visitar https://docs.microsoft.com/es-mx/dotnet/csharp/language-reference/keywords/for .
8.3 Bucle “foreach”.
Este Bucle se enfoca principalmente a trabajar con “Arreglos de Datos” (“Arrays”, “List”, “Dictionary”, etc.), ya que ejecuta nuestro bloque de código una vez por cada elemento del Arreglo. Durante su funcionamiento, el Bucle “foreach” no evalúa una “expresión” como el Bucle “for”, sino que lee la cantidad de elementos contenidos en el Arreglo que se le defina y ejecuta el bloque de código asignado una vez por cada elemento (cuando se alcanza el número total de elementos dentro del Arreglo, el Bucle “foreach” se detiene y se continúa con el resto del Script).
La estructura del Bucle “foreach” es la siguiente:
foreach (“variable de control” in “Arreglo de Datos”) {
//Bloque de Código a Ejecutar
}
En este caso la “variable de control” sólo se crea pero no se le asigna un valor inicial, ya que su función, es tomar los valores de cada elemento del Arreglo para poder usarlos en el bloque de código a ejecutar (por ello, la variable de control debe tener el mismo Tipo de Dato que el Arreglo).
Ejemplo:
Crear una Colección “List” con los nombres de tres colores para después mostrarlos como mensajes en la Consola de Unity.
List<string> nombresColores = new List<string> {“rojo”, “azul”, “amarillo"};
foreach (string colores in nombresColores){
Debug.Log(“Color: ” + colores );
}
Y como resultado, se nos mostrará:
“Color: rojo”
“Color: azul”
“Color: amarillo”
Nota: En cada iteración, la variable de control “colores” toma el valor de cada elemento del Arreglo “nombresColores”.
Si quieres conocer más sobre el Bucle “foreach”, puedes visitar https://docs.microsoft.com/es-mx/dotnet/csharp/language-reference/keywords/foreach-in .
8.4 Bucle “while”.
En este Bucle, dada una “condición a evaluar”, que inicialmente debe ser “verdadera” (“true”), ejecutará un bloque de código repetidamente hasta que dicha condición sea “falsa” (“false”).
La estructura del Bucle “while” es la siguiente:
while (“condición a evaluar”) {
//Bloque de Código a Ejecutar
}
Ejemplo:
int monedasOro = 14;
while ( monedasOro > 8 ) {
Debug.Log (“Tengo “ + monedasOro + “ monedas”);
monedasOro -= 2; //Que es lo mismo que “monedasOro = monedasOro -2”
}
Y como resultado, se nos mostrará:
“Tengo 14 monedas”
“Tengo 12 monedas”
“Tengo 10 monedas”
En este ejemplo podemos ver que, se nos muestra en la Consola de Unity el total de monedas que tenemos, y después gastamos dos de ellas. Este proceso (mostrar/gastar) se seguirá haciendo mientras el total de monedas sea mayor que ocho.
Si quieres conocer más sobre el Bucle “while”, puedes visitar https://docs.microsoft.com/es-mx/dotnet/csharp/language-reference/keywords/while .
8.5 Bucle “for” en Unity.
Ahora, vamos a aprender a usar el Bucle “for” en Unity. Para ello, es necesario crear un nuevo Script llamado “MyLoops”, después hay que añadir este Script como un nuevo Componente del objeto “GameObject” en nuestra escena de trabajo y eliminar cualquier otro Componente tipo “Script” que contenga.
Dentro de nuestro Script “MyLoops”, vamos a dar de alta lo siguiente:
//Creamos una variable que almacene la cantidad máxima de logros desbloqueados en el juego. public int maximoLogrosDesbloqueados;
Y nuestro Método “Start” debe quedar así:
void Start () { /* Vamos a mostrar un mensaje en la Consola de Unity simulando que se han desbloqueado cada uno del número total de logros en el juego */ for (int i = 0; i <= maximoLogrosDesbloqueados; i++) { Debug.Log("Has Desbloqueado: " + i + " logros de " + maximoLogrosDesbloqueados); } }
Nota: En la “condición a evaluar” hemos escrito “<=” (“menor o igual que”), lo que significa que se incluye el caso donde la “variable de control” alcanza el valor máximo estipulado (de lo contrario, si usuráramos solo “<” “menor que”, no se incluiría el caso donde se igualan los valores).
Guardamos nuestro código, y cambiamos a la ventana de Unity.
Dentro de Unity, en la ventana “Inspector”, buscamos el Componente “My Loops” (recuerda que, dentro de la ventana “Hierarchy”, el objeto “GameObject” debe estar seleccionado). Y en el campo “Maximo Logros Desbloqueados”, escribir el valor “4”.
Ejecutamos nuestra escena, y la Consola de Unity nos mostrará:
Nuestro código funciona correctamente, ya que muestra cada uno del total de logros que hemos estipulado (el Bucle “for” nos sirve para automatizar esta tarea y no tener que escribir cada mensaje por separado).
Vamos a realizar otro ejemplo, pero ahora usando un Array.
Para ello, dentro de nuestro Script “MyLoops”, vamos a dar de alta lo siguiente:
//Creamos un Array "Vector" que contenga la fuerza de ataque de cinco enemigos. float[] fuerzaAtaqueEnemigos = new float[5] {4.7f,7.77f, 9.8f, 11.1f, 14.7f};
Y modificamos nuestro Método “Start” para que quede así:
void Start () { /* Vamos a mostrar un mensaje en la Consola de Unity que indique la fuerza que tiene cada uno de nuestros enemigos */ for (int i = 0; i < fuerzaAtaqueEnemigos.Length; i++) { Debug.Log("El Enemigo n." + i + " tiene una fuerza de " + fuerzaAtaqueEnemigos[i]); } }
Nota: En este caso, la “varibale de control” “i”, nos servirá de “Índice” para mostrar cada uno de los valores contenidos en nuestro Array (por eso escribimos “fuerzaAtaqueEnemigos[i]”). Además, nuestro código está diseñado para funcionar con cualquier tamaño que tenga nuestro Array; y esto se debe a que en la “condición a evaluar” usamos “i < fuerzaAtaqueEnemigos.Length” en lugar de “i < 5”, así, si modificamos nuestro arreglo (le aumentamos la capacidad o se la disminuimos), ya no será necesario modificar el Bucle “for” (porque este usará el tamaño actual del Array y no un valor fijo).
Ahora, guardamos nuestro código, cambiamos a la ventana de Unity y ejecutamos nuestra escena.
Nuestro código funciona correctamente, ya que muestra cada uno de los elementos contenidos en nuestro Array.
8.6 Bucle “foreach” en Unity.
Ahora, vamos a aprender a usar el Bucle “foreach” en Unity. Para ello, volveremos a usar nuestro Script “MyLoops”.
Como se mencionó en los puntos anteriores, el Bucle “foreach” se usa principalmente con Arreglos de Datos; nosotros en el siguiente ejemplo lo usaremos con una Colección “List”.
Dentro de nuestro Script “MyLoops”, vamos a dar de alta lo siguiente:
//Creamos una Colección "List" que contenga nombres de frutas. public List<string> nombresFrutas;
Y nuestro Método “Start” debe quedar así:
void Start () { /* Vamos a mostrar un mensaje en la Consola de Unity que indique todos los nombres de las frutas contenidas en nuestra Colección */ foreach (string fruta in nombresFrutas) { Debug.Log("Nombre de la Fruta: " + fruta); } }
Guardamos nuestro código, y cambiamos a la ventana de Unity.
Dentro de Unity, en la ventana “Inspector”, buscamos el Componente “My Loops” (recuerda que, dentro de la ventana “Hierarchy”, el objeto “GameObject” debe estar seleccionado). Y en el campo “Nombres Frutas” escribimos:
Ejecutamos nuestra escena, y la Consola de Unity nos mostrará:
Nuestro código funciona correctamente, ya que muestra todo el contenido de nuestra Colección.
Vamos a realizar otro ejemplo, pero ahora usando una Colección “Dictionary”.
Para ello, dentro de nuestro Script “MyLoops”, vamos a dar de alta lo siguiente:
//Creamos una Colección "Dictionary" que contenga los nombres y precios de algunas armas. Dictionary<string, int> preciosArmas = new Dictionary<string, int>();
Y modificamos nuestro Método “Start” para que quede así:
void Start () { //Añadimos las armas y sus precios a nuestra Colección preciosArmas.Add("Palo", 10); preciosArmas.Add("Espada de Madera", 50); preciosArmas.Add("Hacha de Madera", 75); preciosArmas.Add("Espada de Metal", 100); preciosArmas.Add("Hacha de Metal", 125); preciosArmas.Add("Espada de Diamante", 4000); preciosArmas.Add("Hacha de Diamante", 4700); /* Vamos a mostrar un mensaje en la Consola de Unity que indique todos los nombres y los precios de las armas contenidas en nuestra Colección */ foreach (KeyValuePair<string, int> armas in preciosArmas){ Debug.Log("Arma: " + armas.Key + ", precio: " + armas.Value); } }
Nota: Cuando a nuestra “variable de control” “armas” le asignamos el Tipo de Dato “KeyValuePair<string, int>” (donde “<string, int>” son los mismos que le asignamos a “preciosArmas”), significa que estamos trabajando con una Colección “Dictionary” y que deseamos tomar cada uno de sus valores de “Key” y “Value” en cada iteración (esto con la finalidad de poder mostrarlos dentro del mensaje usando los Métodos “armas.Key” y “armas.Value”).
Ahora, guardamos nuestro código, cambiamos a la ventana de Unity y ejecutamos nuestra escena.
Nuestro código funciona correctamente, ya que muestra todo el contenido de nuestra Colección (tanto las “Claves” o “Key”, como los Valores de cada elemento).
8.7 Bucle “while” en Unity.
Ahora, vamos a aprender a usar el Bucle “while” en Unity. Para ello, volveremos a usar nuestro Script “MyLoops”.
Dentro de nuestro Script, vamos a dar de alta lo siguiente:
//Creamos una Variable para almacenar la cantidad de monedas que tenemos. int cantidadMonedas = 40;
Y nuestro Método “Start” debe quedar así:
void Start () { /* Vamos a mostrar un mensaje en la Consola de Unity indicando la cantidad de monedas que tenemos, después simularemos que hemos ganado diez monedas más. El mensaje se repetirá hasta que tengamos cien monedas en nuestro poder */ while ( cantidadMonedas < 100 ) { Debug.Log ("Tienes: " + cantidadMonedas + " monedas, necesitas tener 100 para continuar"); cantidadMonedas += 10; } }
Ahora, guardamos nuestro código, cambiamos a la ventana de Unity y ejecutamos nuestra escena.
Como podemos ver, nuestro Bucle “while” muestra la cantidad de monedas que tenemos, además realiza la adición de “10” monedas en cada iteración, y el Bucle deja de ejecutarse cuando alcanzamos el valor de “100” monedas.
Ejercicios.
Para reforzar lo aprendido, es necesario practicarlo, por ello intenta realizar los siguientes ejercicios:
- Usa el Script “MyLoops” que creaste en este tutorial.
- Crea un Array Unidimensional (Vector) que almacene “la cantidad de pasos” que caminas por día (de lunes a viernes), usa la ventana “Inspector” de Unity para escribir los valores del Array, y crea un código que muestre esta información en la Consola de Unity usando el Bucle “for”.
- Crea una Colección “List” donde puedas almacenar “los nombres” de tus mejores amigos y crea un código que muestre esta información en la Consola de Unity usando el Bucle “foreach”.
- Crea una Colección “Dictionary” donde puedas almacenar “los nombres” de tus videojuegos favoritos (usando una “Clave” numérica de tres dígitos para identificarlos) y crea un código que muestre esta información en la Consola de Unity usando el Bucle “foreach” (no es necesario mostrar las “Claves” en el mensaje, solo los Valores).
- Crea una variable llamada “contadorRegresivo” con valor inicial de “20”, usa el Bucle “while” para mostrar un mensaje de espera al jugador y restar un valor de “2” a “contadorRegresivo” en cada iteración. El mensaje debe mostrarse hasta que “contadorRegresivo” sea menor o igual a cero.
Este Tutorial de Unity sobre los Bucles “for”, “foreach” y “while” y su aplicación termina aquí. Acompáñanos en el siguiente tutorial donde aprenderemos más sobre el lenguaje de programación “C Sharp” (C#) en Unity.
Recuerda que, si quieres conocer más a fondo sobre el lenguaje de programación “C#” puedes visitar https://docs.microsoft.com/es-mx/dotnet/csharp/ ó bien, no dudes en contactarnos para cualquier duda o asesoría haciendo clic "Aquí"