7.2 Arreglos de Datos Estáticos.

Este tipo de Arreglo de Datos se conoce como “Array”, y se caracteriza porque su tamaño es fijo; ya que una vez que este se define no se puede modificar.

Ejemplo:

Dar de alta un arreglo de datos tipo “string” que pueda almacenar “4” nombres de enemigos.

string[ ] nombresEnemigos = new string[4];

Nota: Para definir que nuestra Variable sea un “Array”, es necesario añadir los símbolos “corchetes” “[]” justo después de escribir el Tipo de Dato (en este ejemplo, al escribir “string[]”, estamos diciendo que nuestra Variable “nombresEnemigos” es un “Array” de datos tipo “string”). Al escribir “new string[4];”, estamos diciendo que nuestro Arreglo tendrá una “capacidad” para almacenar un máximo de “cuatro datos” (y no más).

Con el ejemplo anterior, hemos creado nuestro “contenedor” para “cuatro nombres de enemigos”; por ahora al contenedor no le hemos asignado la información que almacenará y tendríamos que hacerlo posteriormente.

Nota: Cuando creamos un “Array” y no le hemos asignado información alguna en su interior, este automáticamente se completa con valores “cero” (cuando el tipo de dato a contener es numérico), “false” (cuando el tipo de dato a contener es booleano), “ “” ” (cuando el tipo de dato a contener corresponde a una cadena de caracteres) o “null” (cuando el tipo de dato a contener corresponde a una Instancia de una Clase), y se mantendrá así, hasta que exista una línea de código que lo modifique.

Otra manera de dar de alta nuestro Arreglo, pero esta vez añadiendo los nombres deseados desde el inicio, sería:

string[ ] nombresEnemigos = new string[] {“pirata”, “ninja”, “ladrón”, “esqueleto”};

Nota: Al igual que con el primer ejemplo, hemos creado un Arreglo de Datos Tipo “string” con capacidad para “cuatro datos”; en este caso, “la capacidad y el contenido del Arreglo” están definidos por “los valores indicados y la cantidad de estos” dentro de los símbolos “llaves” “{}” (como escribimos “cuatro” nombres, nuestro Array será de tamaño “4”). Cabe mencionar que, los valores pueden ser modificados en cualquier momento, pero la cantidad ya no podrá ser mayor que lo definido inicialmente (podemos cambiar los nombres de los enemigos existentes, pero ya no podemos agregar más).

También es válido escribir:

string[ ] nombresEnemigos = new string[4] {“pirata”, “ninja”, “ladrón”, “esqueleto”};

Nota: Para este caso, estamos definiendo la capacidad del Array con “new string[4]”, y el contenido del Array con lo escrito dentro de los símbolos “llaves” “{}”.

Para darnos una idea de como es la estructura de nuestro “Array”, podemos usar la siguiente imagen:

Los números en color rojo representan la “posición” en la cual se encuentran ubicados los datos dentro del Array, a esta “posición” le llamamos “Índice”. Cuando se crea el Array, el orden en el cual se escriben los datos que este contendrá, será el mismo orden en el cual se ubicarán dentro del Array (como “pirata” es el primer dato que escribimos, “pirata” tendrá la primera posición dentro del Array, o sea el Índice “cero”).

Nota: El “Índice” siempre comienza desde “cero”. En nuestro caso, para un Array de tamaño “4”, el Índice va desde “0” hasta “3”. Y como regla general, para un Array de tamaño “n”, el Índice abarcará desde “cero” hasta “n-1”.

Para visualizar el uso del Índice en un Array, nos ayudaremos del siguiente ejemplo.

Ejemplo:

Dentro de nuestro Array “nombresEnemigos”, cambiar el nombre “ladrón” por “fantasma”.

nombresEnemigos[2] = “fantasma”;

Nota: Como se puede ver en el ejemplo anterior, para realizar alguna acción con un miembro específico de nuestro Array, es necesario incluir el “[Índice]” con la posición del dato a modificar justo después del nombre de la variable (por ello escribimos “nombresEnemigos[2]”, para tener acceso a la posición correspondiente al nombre “ladrón”).

Como puedes observar, en nuestro Array “nombresEnemigos”, los datos están almacenados en forma lineal (desde la posición “0” hasta la posición “3”). A este tipo de “estructura” se le denomina “Arreglo Unidimensional” o “Vector”.

Existen otros tipos de “estructuras” que corresponden a “Arreglos Multidimensionales”, en los cuales los datos se pueden almacenar en estructuras similares a “casillas” ubicadas por “coordenadas”.

Ejemplo:

Crear un Array “Multidimensional” tipo “string” con “3 Filas” y “2 Columnas” que nos sirva para almacenar los nombres de nuestros colores favoritos.

string[ , ] nombresColores = new string[3,2];

Nota: Con “string[ , ]” estamos definiendo que vamos a dar de alta un Array Multidimensional de “2 Dimensiones” (si quisiéramos uno de tres dimensiones, tendríamos que agregar otra coma y escribir “string[ , , ]”). Y con “new string[3,2];” estamos diciendo que este Array de dos dimensiones tendrá “3 Filas” y “2 Columnas”.

Si optamos por dar de alta este mismo Array, pero indicando su contenido, podríamos hacerlo de la siguiente forma:

string[ , ] nombresColores = new string[3,2] { {“verde” , ”azul”}, {“amarillo” , ”rojo”}, {“rosa” , ”púrpura”} };

Y su estructura sería muy similar a esto:

Y para poder modificar algún miembro de esta “Array Multidimensional”, debemos usar el Índice correspondiente.

Ejemplo:

Del Array “nombresColores”, modificar el color “rojo” por “negro”.

nombresColores[1,1] = “negro”;

En esta serie de Tutoriales nosotros trabajaremos con Arreglos Unidimensionales “Vectores”, así que por el momento no es necesario profundizar mucho en los otros tipos.

Si quieres conocer más a fondo sobre los Arreglos de Datos Estáticos en “C#”, puedes visitar https://docs.microsoft.com/es-mx/dotnet/csharp/programming-guide/arrays/ .

7.3 Arreglos de Datos Dinámicos.

También conocidos como “Colecciones”, estos Arreglos de Datos se caracterizan porque su tamaño no es fijo; ya que una vez que definimos o damos de alta una “Colección”, posteriormente se puede incrementar o reducir su tamaño (podemos agregar o quitar datos).

Las Colecciones son “Clases” que podemos utilizar para agrupar datos, y parte de los grandes beneficios que nos brindan se encuentran en los “Métodos” que estas contienen (Métodos para “Buscar”, “Ordenar” y “Manipular” la información contenida dentro de las Colecciones).

Las Colecciones que usaremos son “List” y “Dictionary”.

Colección “List”

El Arreglo de Datos Dinámicos (“Colección”) “List” tiene una estructura muy similar a la de un “Array” Unidimensional (“Vector”), ya que solo pueden contener datos del mimo tipo, tienen un Índice para ubicar a los miembros del arreglo y la manera de ordenarlos es lineal (unidimensional).

Ejemplo:

Crear una Colección tipo “List” de datos tipo “float” donde se puedan almacenar mis calificaciones de este parcial.

List<float> calificacionesParcial = new List<float> ();

Nota: Cuando usamos “List” no es necesario definir el tamaño de la Colección o asignar los datos que esta contendrá. Lo único que requerimos es definir el Tipo de Dato a usar (por eso escribimos “List<float>”) y después inicializarla (por eso escribimos “new List<float> ();”)

Si queremos comenzar a añadir datos a esta Colección, usamos el Método “Add”:

calificacionesParcial.Add(7.4f);

calificacionesParcial.Add(8.7f);

calificacionesParcial.Add(9.5f);

Nota: Con “Add()” añadiremos a nuestra Colección los valores contenidos en “()”. Entre más valores vayamos añadiendo, el tamaño de nuestra Colección se irá incrementando.

Si queremos añadir datos desde el momento en que creamos la Colección:

List<float> calificacionesParcial = new List<float> {7.4f, 8.7f, 9.5f};

Nota: En este caso, reemplazamos “new List<float> ();” por “new List<float> {7.4f, 8.7f, 9.5f};”.

Si queremos eliminar el valor “8.7f”, lo podemos hacer de dos maneras (usando los Métodos “Remove” y “RemoveAt”):

calificacionesParcial.Remove(8.7f);

Nota: Con “Remove()” eliminaremos el primer valor igual al contenido de “()”. Si tuviéramos “8.7f” repetido en otras posiciones, solo se borraría el primero de ellos. Cuando usamos “Remove()” el tamaño de nuestra Colección se “reduce” y los datos contenidos se “recorren en su posición” (no quedan espacios vacíos).

calificacionesParcial.RemoveAt(1);

Nota: Con “RemoveAt()” eliminaremos el dato ubicado en el valor del Índice escrito dentro de “()”. Cuando usamos “RemoveAt()” el tamaño de nuestra Colección se “reduce” y los datos contenidos se “recorren en su posición” (no quedan espacios vacíos).

Y si en lugar de querer eliminar el valor “8.7f” lo queremos cambiar por “8.5f”:

calificacionesParcial[1]=8.5f;

Nota: La modificación de datos en una Colección tipo “List” es igual que un Array; se debe usar el Índice para ubicar la posición del dato a cambiar.

“List” nos permite realizar muchas acciones sobre nuestra Colección, más adelante veremos cómo utilizar algunos otros Métodos pertenecientes a “List”.

Colección “Dictionary”

El Arreglo de Datos Dinámicos (“Colección”) “Dictionary” es muy similar en estructura a “List”, pero con la particularidad de que “Dictionary” no usa un Índice como tal, en su lugar usa “Claves Únicas” (“Key”) para hacer referencia a los elementos que contiene.

Ejemplo:

Crear una Colección tipo “Dictionary” de datos tipo “float” donde se puedan almacenar mis calificaciones de este parcial; las “Claves” para hacer referencia a cada calificación, deben ser Datos Tipo “string” que indiquen el nombre de la asignatura.

Dictionary<string, float> calificacionesParcial = new Dictionary<string, float> ();

Nota: Cuando usamos “Dictionary” no es necesario definir el tamaño de la Colección o asignar los datos que esta contendrá. Lo único que requerimos es definir el Tipo de Dato a usar para la “Clave” (“Key”) y el Tipo de Dato a usar para el Valor Almacenado (por eso escribimos “Dictionary<string, float>”) y después la inicializamos (por eso escribimos “new Dictionary<string, float> ();”)

Si queremos comenzar a añadir datos a esta Colección, usamos el Método “Add”:

calificacionesParcial.Add(“Física”,7.4f);

calificacionesParcial.Add(“Computación”,8.7f);

calificacionesParcial.Add(“Historia”,9.5f);

Nota: Con “Add()” añadiremos a nuestra Colección las Claves y los Valores contenidos en “()” siempre separados por “una coma” (“,”). Entre más valores vayamos añadiendo, el tamaño de nuestra Colección se irá incrementando. Sólo las Claves deben ser Únicas (no se pueden repetir, de lo contrario se generará un error).

Si queremos añadir datos desde el momento en que creamos la Colección, se hace de la siguiente manera:

Dictionary<string, float> calificacionesParcial = new Dictionary<string, float> { {“Física”,7.4f} , {“Computación”,8.7f} , {“Historia”,9.5f} };

Nota: En este caso, reemplazamos “new Dictionary<string, float> ();” por “new Dictionary<string, float> { {“Física”,7.4f} , {“Computación”,8.7f} , {“Historia”,9.5f} };”.

Si queremos eliminar el valor “8.7f” (“Computación”), lo podemos hacer usando el Método “Remove”

calificacionesParcial.Remove(“Computación”);

Nota: Como podemos ver, con “Remove()” usamos la “Clave” (“Key”) del Valor que queremos eliminar dentro de “()”. Con esto, nos encargamos de eliminar tanto al Valor como a su Clave. Cuando usamos “Remove()” el tamaño de nuestra Colección se “reduce” y los datos contenidos se “recorren en su posición” (no quedan espacios vacíos).

Si lo que queremos es modificar el Valor de “Computación” de “8.7f” a “8.5f”, lo hacemos de la siguiente forma:

calificacionesParcial[“Computación”]=8.5f;

Como pudimos ver, “Dictionary” trabaja de una manera muy similar a “List”, solo que con “Dictionary”, todas las referencias a los datos contenidos en nuestra Colección las realizamos usando la “Clave” (“Key”) y no el Valor o un Índice.

“Dictionary” nos permite realizar muchas acciones sobre nuestra Colección, más adelante veremos cómo utilizar algunos otros Métodos pertenecientes a “Dictionary”.

Si quieres saber más a fondo sobre las “Colecciones”, puedes visitar https://docs.microsoft.com/es-mx/dotnet/csharp/programming-guide/concepts/collections .

7.4 Arrays en Unity.

Ahora, vamos a aprender a usar “Arrays” en Unity. Para ello, es necesario crear un nuevo Script llamado “MyArrays”, 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 “MyArrays”, vamos a dar de alta lo siguiente:

float[] costoNaves = new float[3] {10.5f,15.8f,24.7f};
string[] nombresNaves = new string[3] {"Cometa", "Rayo", "Destructor"};

Y nuestro Método “Start” debe quedar así:

void Start () {
        Debug.Log("Los Precios de las Naves son: " + "\n" +
        nombresNaves[0] + ": " + costoNaves[0] + "   " +
        nombresNaves[1] + ": " + costoNaves[1] + "   " +
        nombresNaves[2] + ": " + costoNaves[2] );
    }

Nota: Cunado usamos "\n" dentro de un campo de texto, significa que existirá un salto de línea (todo lo que se escriba después de "\n" aparecerá en la siguiente línea de texto).

Ahora, guardamos nuestro código, cambiamos a la ventana de Unity y ejecutamos nuestra escena.

Podemos ver que hemos creado correctamente dos tipos de Arrays (uno tipo “float” y otro tipo “string”), y hemos usado sus Índices para mostrar el contenido de cada arreglo como mensaje en la Consola de Unity.

Ahora veamos como aprovechar la Interfaz de Edición de Unity para manipular nuestros Arrays. Para ello es necesario, modificar la forma en que dimos de alta los arreglos, quedando de la siguiente manera:

public float[] costoNaves;
public string[] nombresNaves;

No es necesario modificar nuestro Método “Start”. Guardamos nuestro código y cambiamos a Unity.

Con “GameObject” seleccionado (en la ventana “Hierarchy”), podemos ver que su componente “My Arrays” (en la ventana “Inspector”) nos muestra lo siguiente:

Podemos ver que los nombres de nuestros Arrays se encuentran ahí. Si hacemos clic sobre los pequeños triángulos grises a lado de “Costo Naves” y “Nombres Naves”, veremos como se despliegan otros campos:

El campo “Size”, nos indica el “tamaño” de nuestro Array, aquí nosotros podemos escribir el tamaño que deseamos para nuestro arreglo, y para ser consistentes con el código dentro del Método “Start” (y así evitar mensajes de error), vamos a escribir el número “3” en cada campo “Size”. Es necesario que después de escribir un número dentro de un campo oprimamos la tecla “Intro” o hagamos clic fuera del campo para que el valor sea procesado y se nos muestre lo siguiente:

Ahora, se nos muestran los campos “Element”, estos campos representan el “contenido” de cada Array, y están numerados a partir del número “cero” hasta el valor de “Size-1” (para este caso, van del “0 al 2”).

Dentro los campos “Element” podemos asignar los valores que deseemos siempre y cuando correspondan al Tipo de Dato con el que dimos de alta el Array en nuestro Script “MyArrays”.

Si ejecutamos nuestra escena, podemos ver el siguiente mensaje en la Consola de Unity.

Por último, vamos a modificar nuestro Método “Start” para que quede de la siguiente forma:

void Start () {
        //Cambiamos el valor de la tercera posición en el Array “costoNaves” (Índice = 2)
        costoNaves[2] = costoNaves[0] + costoNaves[1];
       //Desplegamos los valores de los dos Arrays
        Debug.Log("Los Precios de las Naves son: " + "\n" +
        nombresNaves[0] + ": " + costoNaves[0] + "   " +
        nombresNaves[1] + ": " + costoNaves[1] + "   " +
        nombresNaves[2] + ": " + costoNaves[2] );
        //Desplegamos el tamaño de los dos Arrays
        Debug.Log("El Tamaño del Array costoNaves es: " + costoNaves.Length);
        Debug.Log("El Tamaño del Array nombresNaves es: " + nombresNaves.Length);

    }

Los Arrays también cuentan con algunos Métodos que podemos utilizar y que nos serán de mucha utilidad, uno de ellos es “Length”, el cual nos devuelve el “tamaño” (“Size”) del Array en el cual lo usemos (por eso escribimos “costoNaves.Length” y “nombresNaves.Length”, para obtener el valor del tamaño de estos Arrays).

Ahora, guardamos nuestro código, cambiamos a la ventana de Unity y ejecutamos nuestra escena.

Como podemos observar, el valor de la tercera posición en nuestro Array “costoNaves” corresponde a la suma de las otras posiciones (costoNaves[2] = costoNaves[0] + costoNaves[1]), y sustituye a lo que hayamos puesto en el campo “Element 2” en la ventana “Inspector” (porque lo que pusimos son valores con los que se inicializa el Array, pero pueden ser modificados posteriormente por otras líneas de código).

Además, también se muestran los resultados de llamar al Método “Length” en cada uno de los Arrays que creamos (“costoNaves.Length” y “nombresNaves.Length”), indicándonos así el tamaño de cada uno de estos.

7.5 Colecciones en Unity.

Ahora, vamos a aprender a usar las Colecciones “List” y “Dictionary” en Unity. Para ello, es necesario crear un nuevo Script llamado “MyCollections”, 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.

Colección “List”.

Dentro de nuestro Script “MyCollections”, vamos a dar de alta lo siguiente:

//Supongamos que tenemos un juego de Carreras y necesitamos crear una Colección que contenga las Velocidades de los
//Oponentes contra los que vamos a competir.
List<float> velocidadesOponentes = new List<float>();

Y nuestro Método “Start” debe quedar de la siguiente manera:

void Start () {
        //Añadimos las Velocidades de Cada Oponente
        velocidadesOponentes.Add(4.7f);
        velocidadesOponentes.Add(5.5f);
        velocidadesOponentes.Add(7.4f);
        velocidadesOponentes.Add(9.8f);
        velocidadesOponentes.Add(11.1f);
        //Mostramos la Velocidad del Tercer Oponente (Índice = 2) y el Total de Oponentes
        Debug.Log("Velocidad del Tercer Oponente = " + velocidadesOponentes[2] + "\n" + 
        "Número de Oponentes = " + velocidadesOponentes.Count);
        //Decidimos que es mejor quitar al Oponente con la Velocidad = 5.5
        velocidadesOponentes.Remove(5.5f);
        //Como la Colección se modificó, volvemos a mostrar la Velocidad del Tercer Oponente (Índice = 2) y el Total de Oponentes
        Debug.Log("Velocidad del Tercer Oponente = " + velocidadesOponentes[2] + "\n" + 
        "Número de Oponentes = " + velocidadesOponentes.Count);
        //Ahora decidimos que es mejor que el Tercer Oponente sea Nuevo y con Velocidad = 6.6
        velocidadesOponentes.Insert(2, 6.6f);
        //Como la Colección se modificó, volvemos a mostrar la Velocidad del Tercer Oponente (Índice = 2) y el Total de Oponentes
        Debug.Log("Velocidad del Tercer Oponente = " + velocidadesOponentes[2] + "\n" + 
        "Número de Oponentes = " + velocidadesOponentes.Count);
    }

Como se puede observar en el código anterior, estamos haciendo uso de distinto Métodos pertenecientes a la Clase “List” para manipular nuestro arreglo:

• Método “Add”. El cual nos permite añadir nuevos datos a nuestra Colección (haciendo que el tamaño de nuestra Colección se incremente).
• Método “Count”. Nos muestra el tamaño de nuestra Colección (similar a “Length” en los Arrays).
• Método “Remove”. Nos permite eliminar un dato de nuestra Colección (haciendo que el tamaño de nuestra Colección se reduzca y las posiciones de datos que se encuentran después del dato removido se recorran).
• Método “Insert”. Nos permite añadir un dato nuevo en la posición (Índice) que elijamos (se escribe primero la posición, después una “coma” “,” y por último el valor deseado). Esto hace que el tamaño de nuestra Colección se incremente y las posiciones de los otros datos se muevan hacia adelante (solo los datos que se ubiquen después del dato añadido).

Ahora, guardamos nuestro código, cambiamos a la ventana de Unity y ejecutamos nuestra escena.

Nuestro código se ejecuta correctamente, ya que los valores y posiciones de los datos contenidos en la Colección se modifican de acuerdo con lo descrito en nuestro código.

La Colección “List” también puede ser modificada desde la Interfaz de Edición de Unity, para eso, es necesario cambiar la manera en que dimos de alta a nuestra Colección.

public List<float> velocidadesOponentes = new List<float>();

Guardamos nuestro Código y cambiamos a Unity.

Una vez en Unity, nos dirigimos al componente “My Collections” y podremos ver algo así:

Esto es muy similar a cuando trabajamos con Arrays; ahora, vamos a agregar la siguiente información:

Si ejecutamos nuestra escena, podremos ver los siguientes cambios:

Y la Consola de Unity nos mostrará:

Aunque nosotros hayamos dimensionado nuestra Colección para tener un tamaño igual a “3”, debido al contenido del Método “Start”, nuestra Colección se modificó para pasar de “tres” elementos a “ocho”, después a “siete” y por último a “ocho” (debido al uso de los Métodos propios de “List”).

Colección “Dictionary”.

Dentro de nuestro Script “MyCollections”, vamos a sustituir todo nuestro código de la siguiente forma:

//Supongamos que tenemos un juego de Carreras "Animales" y necesitamos crear una Colección que contenga las Velocidades
//y los Nombres de los Oponentes contra los que vamos a competir.
Dictionary<string, float> velocidadesOponentes = new Dictionary<string, float>();

Y nuestro Método “Start” debe quedar así:

void Start () {
        //Añadimos los Nombres "Clave" y Velocidades de Cada Oponente
        velocidadesOponentes.Add("Tortuga", 4.7f);
        velocidadesOponentes.Add("Oso", 5.5f);
        velocidadesOponentes.Add("Avestruz", 7.4f);
        velocidadesOponentes.Add("Liebre", 9.8f);
        velocidadesOponentes.Add("Guepardo", 11.1f);
        //Mostramos la Velocidad del Oponente "Oso" y el Total de Oponentes
        Debug.Log("Velocidad del Oponente Oso = " + velocidadesOponentes["Oso"] + "\n" + 
        "Número de Oponentes = " + velocidadesOponentes.Count);
        //Decidimos que es mejor quitar al Oponente "Tortuga"
        velocidadesOponentes.Remove("Tortuga");
        //Como la Colección se modificó, volvemos a mostrar la Velocidad del Oponente "Oso" y el Total de Oponentes
        Debug.Log("Velocidad del Oponente Oso = " + velocidadesOponentes["Oso"] + "\n" + 
        "Número de Oponentes = " + velocidadesOponentes.Count);
        //Ahora decidimos que es mejor añadir al Oponente "Perro" con Velocidad = 6.6
        velocidadesOponentes.Add("Perro", 6.6f);
        //Como la Colección se modificó, vamos a mostrar la Velocidad del nuevo Oponente "Perro" y el Total de Oponentes
        Debug.Log("Velocidad del Oponente Perro = " + velocidadesOponentes["Perro"] + "\n" + 
        "Número de Oponentes = " + velocidadesOponentes.Count);
        
    }

Guardamos nuestro código, cambiamos a la ventana de Unity y ejecutamos nuestra escena.

Nuestro código se ejecuta correctamente, y como se puede observar, el trabajar con una Colección “Dictionary” es muy sencillo (ya que puede ser más intuitivo usar “Claves” o “Keys” en lugar de números de Índice).

Nota: Por defecto, Unity no muestra en su ventana “Inspector” las Colecciones “Dictionary” cuando estas se crean como “Public” ().

Cada uno de los Arreglos de Datos que vimos en este Tutorial (“Arrays”, “List” y “Dictionary”) nos serán de gran utilidad cuando comencemos a desarrollar nuestros videojuegos. Más adelante en otros Tutoriales veremos más aplicaciones con mayor detalle.

Ejercicios.

Para reforzar lo aprendido, es necesario practicarlo, por ello intenta realizar los siguientes ejercicios:

1. Usa el Script “MyArrays” que creaste en este tutorial.
2. 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.
3. Usa el Script “MyCollections” que creaste en este tutorial.
4. 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.
5. 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.

Este Tutorial de Unity sobre los “Arreglos de Datos” (“Array”, “List” y “Dictionary”) 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í"

Siguiente Tutorial de Unity: "8. Bucles."