Unidad: conociendo los Objetos Scriptables

En este tutorial, aprenderá a crear y usar Objetos de secuencias de comandos en Unity. Los Objetos programables pueden ayudarlo a mejorar su flujo de trabajo, reducir la huella de memoria e incluso permitirle dividir la arquitectura del código.

De acuerdo con la documentación de Unity , ScriptableObject es un código de clase que le permite crear Objetos Scriptable en el juego para almacenar grandes cantidades de datos compartidos que son independientes de las instancias de script.

Hay muchas razones para usar Objetos de secuencias de comandos en Unity. Pueden reducir la cantidad de memoria utilizada para cada prefabricado adicional, porque el Objeto Scriptable esencialmente sigue el patrón de diseño Flyweight .

Otra ventaja de Scriptable Objects, que será el tema principal de este tutorial, es su uso para la transferencia de datos conveniente. Consideraremos esta propiedad como un ejemplo de creación de una tienda de comercio de espadas, que mostrará los parámetros, precios y descripciones de varias espadas.

Nota: este tutorial asume que está familiarizado con el editor de Unity. Debe comprender cómo editar código en un editor de código y tener conocimientos básicos de C #. Si necesita mejorar sus habilidades de Unity, consulte otros tutoriales de Unity .

Llegar al trabajo

Comencemos descargando los materiales que necesitamos.

Descomprima el archivo descargado en un lugar conveniente para usted y abra el proyecto Tutorial Object Starter-Starter en Unity.

Debería ver la siguiente carpeta creada como parte de la adquisición del proyecto:

• _Configuración : para el tutorial esta carpeta no es necesaria.
• Escenas : contiene una escena de Sword Merchant que cubriremos a lo largo del tutorial. Abre esta escena.
• Guiones : hasta ahora solo hay un guión, pero durante el tutorial crearemos nuevos.
• Iconos de espada : contiene imágenes fijas de espadas individuales.
• Prefabricados de espada : Contiene los prefabricados de todas las espadas en la escena del comerciante de espadas.

Crear un objeto programable

Para comenzar, ve a la escena del comerciante de espadas . Debería verse así:

Preparando Objeto Scriptable

¡Es hora de crear el primer objeto programable!

En la carpeta Scripts , cree un nuevo script llamado SwordData . Esta clase se utilizará como contenedor para todos los datos de espada que se muestran en la tienda del comerciante de espadas.

Dentro de esta clase, comience por heredar de ScriptableObject lugar de MonoBehaviour :

 public class SwordData : ScriptableObject { } 

Esta acción le dice a Unity que todavía queremos usar las características y métodos de Unity, al igual que MonoBehaviour normal, pero ya no necesitamos adjuntar este script a GameObject. En cambio, se procesará como cualquier activo normal, que se puede crear de la misma manera que se crea una prefabricada, una escena o un material.

Rellene el script con campos serializados, que contendrán todos los datos correspondientes a la información que se muestra en la interfaz de usuario de Sword Merchant.

 public class SwordData : ScriptableObject { [SerializeField] private string swordName; [SerializeField] private string description; [SerializeField] private Sprite icon; [SerializeField] private int goldCost; [SerializeField] private int attackDamage; } 

• swordName : string , en la que se almacenará el nombre de la espada.
• description : string , en la que se almacenará la descripción de la espada.
• icono : el sprite que contendrá el icono de la espada.
• goldCost : int para almacenar el valor de la espada en oro.
• attackDamage : int para almacenar el daño al atacar con una espada.

Nota: SerializeField

En Unity, el atributo SerializeField le permite tener variables de script privadas disponibles en el Inspector. Le permitirá establecer valores en el editor sin proporcionar acceso a la variable desde otros scripts.

Cada espada requerirá su propia implementación única de Scriptable Object SwordData . Pero antes de que podamos crear estas implementaciones, necesitamos agregar un objeto programable al menú de activos.

Agregue nuestro Objeto de secuencias de comandos al Menú de activos agregando el siguiente atributo a la clase SwordData :

 [CreateAssetMenu(fileName = "New SwordData", menuName = "Sword Data", order = 51)] public class SwordData : ScriptableObject 

• fileName : nombre predeterminado al crear el activo.
• menuName : nombre del activo que se muestra en el menú de activos.
• orden : colocación de activos en el menú de activos. Unity divide los activos en subgrupos con un factor de 50. Es decir, un valor de 51 coloca el nuevo activo en el segundo grupo del menú de activos.

Si todo se hace correctamente, puede ir a Activos >> Crear y ver el nuevo activo de Datos de espada en el menú. Debe ubicarse en el segundo grupo bajo el activo Carpeta:


También puede hacer clic con el botón derecho en la ventana Proyecto y también ver el nuevo activo de Datos de espada:

Agregar datos

Organizaremos el proyecto creando una carpeta llamada Objetos programables en la carpeta Scripts, y dentro de esta carpeta otra carpeta llamada Datos de espada .

Dentro de la carpeta de datos de espada recién creada, cree nuestro primer activo de datos de espada.

El nuevo activo de Sword Data aún debe tener el nombre de archivo predeterminado previamente especificado FileName . Seleccione un activo y duplíquelo seis veces ( Ctrl / Cmd + D ) para crear siete activos de datos de espada, uno para cada una de las espadas. Ahora cambie el nombre de cada activo de acuerdo con los prefabricados:


Haga clic en el primer activo de Datos de espada en la carpeta Datos de espada y mire la ventana del Inspector :


Aquí vemos un activo en el que se almacenará información sobre una espada en particular. Completa la información de cada espada. Intenta darles una descripción única, valor en oro y daños durante un ataque. En el campo Icon Sprite, usa los sprites correspondientes ubicados en la carpeta Sword Icons :


Felicidades Creó un objeto programable y configuró varios activos con este objeto programable.

Usando Objeto Scriptable

Ahora comenzaremos a obtener datos de estos Objetos programables.

Primero, necesitamos agregar algunos métodos getter públicos para que otros scripts puedan acceder a campos privados dentro del Objeto Scriptable. Abra SwordData.cs y agregue lo siguiente en los campos agregados anteriormente:

  public string SwordName { get { return swordName; } } public string Description { get { return description; } } public Sprite Icon { get { return icon; } } public int GoldCost { get { return goldCost; } } public int AttackDamage { get { return attackDamage; } } 

Abra Sword.cs y agregue el siguiente código:

  [SerializeField] private SwordData swordData; // 1 private void OnMouseDown() // 2 { Debug.Log(swordData.name); // 3 Debug.Log(swordData.Description); // 3 Debug.Log(swordData.Icon.name); // 3 Debug.Log(swordData.GoldCost); // 3 Debug.Log(swordData.AttackDamage); // 3 } 

Esto es lo que agregamos con este código:

1. El contenedor de datos para los datos de esta espada.
2. OnMouseDown es una función incorporada de MonoBehaviour que se llama cuando el usuario presiona el botón izquierdo del mouse.
3. Ejemplos de cómo obtener datos de nuestro activo Objeto programable

Regrese a Unity y vaya a la ventana Jerarquía . Seleccione el objeto de juego 1_Longsword en el prefab espada. Agregue el activo de datos 1_Longsword apropiado a la variable Datos de espada del script Sword.cs en la ventana del Inspector:


Haga clic en Reproducir ( Ctrl / Cmd + P ) en el editor de Unity y luego haga clic en la espada más a la izquierda:


La consola debe mostrar información similar a los datos transferidos desde el activo Sword Data.

Los objetos programables facilitan la sustitución de estos datos. Intente insertar diferentes Objetos con guión de datos de espada en el campo Datos de espada de la espada.

Objetos de secuencias de comandos Eventable

Entonces, creamos un Objeto Scriptable, y viste cómo puedes acceder a sus datos dentro del juego. ¡Pero aún necesitamos integrar Sword Data con la interfaz de usuario!

Puede usar el patrón Singleton rápido y sucio para esto. Sin embargo, ahora tenemos otras posibilidades ...

... a saber, objetos con secuencias de comandos! Los utilizaremos para crear código limpio y bien dividido.

En esta sección, aprenderá cómo crear eventos de juego usando la clase UnityEvent .

Eventos de juegos y oyentes

En la carpeta Scripts, cree dos scripts: GameEvent.cs y GameEventListener.cs . Dependen unos de otros, por lo que para deshacerse de los errores, debe crear ambos.

 using System.Collections.Generic; using UnityEngine; [CreateAssetMenu(fileName = "New Game Event", menuName = "Game Event", order = 52)] // 1 public class GameEvent : ScriptableObject // 2 { private List<GameEventListener> listeners = new List<GameEventListener>(); // 3 public void Raise() // 4 { for (int i = listeners.Count - 1; i >= 0; i--) // 5 { listeners[i].OnEventRaised(); // 6 } } public void RegisterListener(GameEventListener listener) // 7 { listeners.Add(listener); } public void UnregisterListener(GameEventListener listener) // 8 { listeners.Remove(listener); } } 

Esto es lo que hace el código anterior:

1. Agrega un GameEvent como un activo al menú de activos.
2. GameEvent es un objeto programable, por lo que debe heredar de ScriptableObject.
3. Lista de GameEventListeners que se suscribirán a GameEvent.
4. Método para llamar a todos los suscriptores de GameEvent.
5. El último GameEventListener firmado será el primero llamado (último en llegar, primero en salir).
6. Llama a cada GameEventListeners de UnityEvent.
7. Un método que permite a GameEventListeners suscribirse a este GameEvent.
8. Un método que permite a GameEventListeners darse de baja de este GameEvent.

 using UnityEngine; using UnityEngine.Events; // 1 public class GameEventListener : MonoBehaviour { [SerializeField] private GameEvent gameEvent; // 2 [SerializeField] private UnityEvent response; // 3 private void OnEnable() // 4 { gameEvent.RegisterListener(this); } private void OnDisable() // 5 { gameEvent.UnregisterListener(this); } public void OnEventRaised() // 6 { response.Invoke(); } } 

En el código que se muestra arriba, el proyecto continúa desarrollándose:

1. Requisito para usar la clase UnityEvent.
2. El GameEvent al que se suscribirá este GameEventListener.
3. La respuesta de UnityEvent que se generará cuando el evento GameEvent lanza este GameEventListener.
4. Enlace de un GameEvent a un GameEventListener cuando este GameObject está habilitado.
5. Enlace de un GameEvent desde un GameEventListener cuando este GameObject está deshabilitado.
6. Se invoca cuando se genera un GameEvent que hace que GameEventListener llame al evento UnityEvent.

¿Es dificil? ¡Nada, lo descubrirás con el tiempo!

Entrenamiento de editor

Regrese al editor de Unity y cree una nueva carpeta de Game Events en Scripts >> ScriptableObjects. Luego crea siete eventos de juego desde el menú de activos, como lo hicimos para cada activo de Sword Data. Colóquelos en la nueva carpeta Game Events.


Reemplace el código dentro del script Sword.cs con las siguientes líneas:

  [SerializeField] private GameEvent OnSwordSelected; // 1 private void OnMouseDown() { OnSwordSelected.Raise(); // 2 } 

Este código agrega dos posibilidades a la tienda del comerciante de espadas:

1. Generación de evento de juego al elegir una espada.
2. Generación de eventos cuando haces clic en la espada.

Guarda el guión. Ahora, en cada Objeto de juego de la Jerarquía de la espada, conecta el evento OnSwordSelected correspondiente.


Cada espada ahora tiene un enlace al evento que se activa cuando se hace clic en la espada.

Integración UI

Ahora debe hacer que la interfaz de usuario funcione. Nuestro objetivo es mostrar los datos de espada correspondientes al hacer clic en cada espada.

UI Links

Antes de actualizar la IU, debe obtener un enlace a cada elemento de la IU. Comencemos creando un nuevo script llamado SwordMerchant.cs y agregando el siguiente código a este nuevo script:

 using UnityEngine; using UnityEngine.UI; public class SwordMerchant : MonoBehaviour { [SerializeField] private Text swordName; // 1 [SerializeField] private Text description; // 2 [SerializeField] private Image icon; // 3 [SerializeField] private Text goldCost; // 4 [SerializeField] private Text attackDamage; // 5 } 

Usando este código, agregamos lo siguiente:

1. Una referencia al componente de texto del objeto de juego NameText .
2. Enlace al componente de texto del objeto de juego DescriptionText .
3. Enlace al componente Imagen del objeto de juego Sword_Icon .
4. Enlace al componente de texto del objeto de juego GoldText .
5. Un enlace al componente de texto del objeto de juego AttackText .

Los objetos del juego anteriores se encuentran en el SwordMerchantCanvas >> SwordMerchantPanel de la ventana Jerarquía. Agregue el script a GameObject SwordMerchantCanvas y luego configure todos los enlaces:

Oyentes y respuestas de UI

Todas las espadas tienen un evento al que la UI puede suscribirse usando el script GameEventListener . Agregue un GameEventListener para cada evento OnSwordSelected a GameObject SwordMerchantCanvas :


Como puede ver, nuestro Game Event Listener tiene dos campos: el evento del evento del juego que escucha y la respuesta que se genera cuando se genera el evento del juego.

En nuestro caso, la respuesta será actualizada por la interfaz de usuario. Agregue el siguiente método al script SwordMerchant.cs :

  public void UpdateDisplayUI(SwordData swordData) { swordName.text = swordData.SwordName; description.text = swordData.Description; icon.sprite = swordData.Icon; goldCost.text = swordData.GoldCost.ToString(); attackDamage.text = swordData.AttackDamage.ToString(); } 

Este método recibe un activo de Datos de espada y luego actualiza cada campo de la IU con el valor del campo de Datos de espada correspondiente. Tenga en cuenta que GoldCost y AttackDamage devuelven un int , por lo que debe convertirlo en una cadena de texto.

Usando nuestro nuevo método, podemos agregar una respuesta a cada GameEventListener .

Para cada respuesta que agregue, necesita un enlace a nuestro objeto de juego SwordMerchantCanvas como el valor del campo Ninguno (Objeto) . Después de eso, seleccione SwordMerchant.UpdateDisplayUI en el menú desplegable a la derecha de la lista desplegable Solo tiempo de ejecución .

Tenga cuidado y use el activo correcto de Sword Data para cada evento OnSwordSelected .


Ahora podemos comenzar el juego, hacer clic en la espada y ver que la interfaz de usuario se actualiza en consecuencia.


Como usamos Game Events, puedes simplemente SwordMerchantCanvas , y todo seguirá funcionando, solo sin una interfaz de usuario. Esto significa que los prefabricados de espada están separados de los SwordMerchantCanvas .

¿A dónde ir después?

Si se perdió algo durante la historia, puede descargar el proyecto terminado , que se encuentra en los materiales del tutorial.

Si quieres seguir adelante, intenta hacer que cada espada reproduzca su propio sonido. Intente expandir los datos de la espada de objetos programables y escuche los eventos OnSwordSelected .

¿Quieres aprender más sobre Unity? Echa un vistazo a nuestra serie de videos de Unity o lee los tutoriales de Unity .