Unity Scriptable Object

¿Qué es un Scriptable Object?

Los Scriptable Object son un tipo de componente (script) que puede contener
datos y métodos, igual que un componente normal, pero no necesita existir en
la escena para poder ejecutar sus métodos o acceder a sus datos desde otros
componentes de la escena. Parece un poco raro ¿verdad?

Imagina que pudieses crear un script que no necesitase añadirse a un objeto

de la escena para poder usarlo. Que desde el fichero del script te saliesen una
cajas de texto para asignarle valor de sus atributos públicos y pudieses crear
copias con distintos valores para usar el que más necesitases, pues
básicamente esto sería la esencia de los Scriptable Objects.

¿Para qué se utilizan los ScriptableObject?

Son excelentes soluciones para:

 Almacenar datos inmutables, como en un sistema de diálogo, sonidos o

los parámetros generales del juego
 Evitar tener multitud de prefabs del mismo objeto con distintos
parámetros.

También tienen usos avanzados como la IA (Inteligencia Artificial).

Características

 No necesitan añadirse como componente a un objeto de la escena

 No tiene la mayoría de callbacks (devolución de llamadas) como por
ejemplo Update
 Puede ser serializado (en Unity esto se refiere a poder arrastrarlo a un
atributo público del inspector)
 Permite polimorfismo
 No se reinician con el cambio de escena, ya que no viven en ninguna
 Sus valores no se pueden modificar una vez esté compilado en el
ejecutable final
 Si se cambia alguno de sus valores durante mientras se está ejecutando
desde Unity, el cambio es permanente
 Ocupan muy poco espacio en disco
¿Cómo se crean?

Creamos una clase que será el modelo o plantilla para nuestro Scriptable
Object. Esta clase debe heredar de Scriptable Object. Para este ejemplo vamos
a hacer un sistema de diálogo sencillo en el que además del texto se mostrará
una imagen del personaje que está hablando.

using UnityEngine;

//Permite crear el Scriptable Object desde el menú

conextual "Create"

[CreateAssetMenu]

//La clase debe heredar de ScriptableObject

public class ScriptableObjectExample : ScriptableObject {

public string dialogText;

public Sprite characterSprite;

El atributo de clase “[CreateAssetMenu]” es necesario para poder crear los

Scriptable Object desde el menú contextual de Unity.
Al pulsar en esta opción nos creará el verdadero Scriptable Object. Podemos
crear tantos como queramos y asignarles distintos valores.

Ahora creamos un sencillo script de diálogo que reciba varios Scriptable Object
creados a partir de la clase anterior “ScriptableObjectExample”.

using UnityEngine;

using UnityEngine.UI;

public class SimpleDialogSystem : MonoBehaviour {

//Aquí se asignarán los Scriptable Object desde el

inspector

public ScriptableObjectExample[] dialogs;

//El cajón de texto donde se imprimirán los diálogos

public Text dialogTextBox;

//Un sprite en scena que se cambiará por el sprite del

personaje que esté hablando

public SpriteRenderer spritePosition;

//Contador para saber qué diálogo hay que mostrar tras

finalizar el actual

private int dialogCounter;

//Muestra el primer diálogo al arrancar

 private void Start()

ShowDialog(dialogs[dialogCounter]);

private void Update () {

//Se ejecuta al pulsar el botón izquierdo del ratón

if (Input.GetMouseButtonUp(0))

dialogCounter++;

//Muestra el diálogo y tras pulsar el ratón

sigue habiendo más

if (dialogCounter < dialogs.Length)

ShowDialog(dialogs[dialogCounter]);

//Si no hay más diálogos oculta el texto y el

sprite

else

dialogTextBox.gameObject.SetActive(false);

spritePosition.gameObject.SetActive(false);

}
 //Asigna los valores del diálogo actual a los objetos de
la escena

private void ShowDialog(ScriptableObjectExample

currentDialog)

spritePosition.sprite =
currentDialog.characterSprite;

dialogTextBox.text = currentDialog.dialogText;

Creamos un objeto en escena de tipo Text y otro con el componente

SpriteRenderer para asignarle el texto y el sprite de los Scriptable Object que
hemos creado. Añadimos la referencia de nuestros Scriptable Objects al nuevo
componente.

Ahora al pulsar en la pantalla se cambia el diálogo por lo que habíamos

definido en los Scriptable Object de forma fácil y con la información bien
ordenada, sin leer de un fichero o tener clases estáticas con los diálogos en
constantes.