Introducción
En esta entrada vemos algunos ejemplos de métodos en programación que retornan «void» (vacío), es decir que no producen datos de salida y además métodos que no requieren parámetros de entrada. Para ello analizaremos un proyecto en Unity que consiste en una escena que tiene un conjunto de luces rojas, verdes y azules, un Script permite controlar el sistema de luces, encender y apagar todas las luces, o encender y apagar luces por color. Esto se logra definiendo distintos métodos de programación en el interior del Script de control.
En el siguiente vídeo muestro cómo funciona este sistema de iluminación hecho en Unity
Descargar sistema de luces en Unity
En el siguiente enlace puedes descargar el paquete de Unity con los Assets que se utilizan en el vídeo.
Funcionamiento del sistema
Este sistema está implementado usando solamente métodos que no tienen parámetros de entrada ni producen datos de salida.
En la jerarquía de la escena, tenemos un GameObject llamado Master of Lights que tiene asignado el script del sistema (también llamado Master of Lights). Este GameObject tiene tres hijos, que a su vez son los contenedores de las luces de cada color.
Cómo apagar las luces en Unity
Para apagar las luces en Unity se podría desactivar el GameObject que tiene el componente Light asignado o cualquier GameObject jerarquía arriba, o directamente se puede inhabilitar el componente Light, por ejemplo desmarcando la casilla en el inspector. Esto último es lo que usé en mi sistema, solo que lo vamos a hacer a través de código.
Encontrar las referencias de los componentes Light
Para poder modificar los componentes Light desde el Script necesitamos tener las referencias de estos componentes Light y además necesitamos que estén separados por color. En el inspector del Script hay cuatro arrays de componentes Light, uno para asignar todas las luces y los otros tres tendrán las referencias separadas por color.
Al entrar en el modo juego se puede ver cómo las referencias se encuentran automáticamente en tiempo de ejecución. En este artículo vamos a partir de la base de que contamos con las referencias de los componentes, si quieres ver los métodos que se encargan de encontrar las referencias lo dejaré aquí en la tarjeta de la esquina, te recomiendo que veas la serie completa sobre encontrar referencias en Unity en donde muestro distintas técnicas y ejemplos de cómo encontrar GameObjects y componentes de la jerarquía desde un Script.
Análisis del Script de control de luces en Unity
Si entramos en el Script, en la primera parte vamos a ver las variables que aparecen en el inspector, lo que sigue de ahí en adelante son todos métodos que no tienen parámetros de entrada ni producen datos de salida.
La sintaxis de un método sin parámetros de entrada ni salida es la siguiente: primero se indica la visibilidad que puede ser pública, privada o protegida, con las palabras public, private y void respectivamente, si se omite la visibilidad el método es privado.
Luego sigue la palabra void que indica que este método no tendrá parámetros de salida, en este ejemplo todos los métodos van a devolver void.
Luego sigue el nombre del método que puede ser el nombre que queramos, es conveniente que el nombre sea lo más representativo posible de la función que cumple, ya que lo interesante de los métodos es que nos permiten abstraernos de lo que contienen en su interior, considerarlos como una caja negra que cumple una función y construir soluciones más complejas arriba de eso.
Luego del nombre del método, abrimos y cerramos paréntesis porque el método no recibe parámetros de entrada, luego abrimos y cerramos llaves y las instrucciones que formen parte del método estarán en el interior de estas llaves.
Llamadas a los métodos
Para hacer que se ejecute un método se usa su nombre, se abre y cierra paréntesis (en este caso porque el método no requiere parámetros de entrada) y se finaliza con con punto y coma.
Cuando el flujo del programa llegue a ese punto, saltará a la región del método, ejecutará sus instrucciones y al finalizar retornará al punto desde donde se produjo la llamada.
Entonces fíjense que ejemplos conocidos de este tipo de métodos son los métodos Start, Update y FixedUpdate, funciones que ejecutará Unity automáticamente en su ciclo de vida.
En el método Start se hace la llamada a dos métodos, uno que se encargará de encontrar las referencias de las luces y separarlas por colores. Luego otro método que se encarga de apagar todas las luces, esta es la razón por la que al darle Play, todas las luces comienzan apagadas.
En el método Update se hace la ejecución a un método en donde se leen las entradas de teclado y se ejecutan los métodos apropiados para encender y apagar las luces dependiendo de la tecla pulsada. Lo que se hace es leer las teclas del 1 al 8 y en cada caso se ejecuta un método distinto.
Además de poder llamar los métodos de acuerdo a las entradas de teclado, en este ejemplo también los llamamos desde los botones de la interfaz gráfica, lo que nos muestra cómo el mismo código se puede reutilizar y ejecutar de distintas maneras, si quisiéramos podríamos ejecutar los métodos cuando un objeto entra en contacto con un trigger, cuando el personaje muere, cuando se derrota a un enemigo, las posibilidades son infinitas.
Métodos que finalmente controlan el encendido de las luces
Los métodos que controlan el estado de las luces se han definido con visibilidad pública para que puedan ser llamados utilizando los botones de la interfaz gráfica.
En el interior del método para encender todas las luces por ejemplo, lo que se hace es un bucle foreach para cada componente Light dentro del array que contiene todas las luces y a cada componente se le modifica su parámetro enabled haciéndolo igual a verdadero, esto es equivalente a tildar la casilla de habilitación del componente Light en el inspector, el resultado es que ese GameObject comienza a emitir luz en la escena.
Los demás métodos son muy similares, solo cambia el array que recorremos y el valor que se le asigna al parámetro enabled.