Scriptable Objects en Unity: guía práctica para proyectos indie (con ejemplo real)

Luis Jaquez

Introducción

Si estás construyendo un juego indie en Unity, tarde o temprano te toparás con el mismo problema: empiezas con variables simples en scripts y, cuando el proyecto crece, los valores se duplican, se desincronizan o se vuelven difíciles de ajustar sin romper cosas.
Aquí es donde Scriptable Objects brillan: te permiten centralizar datos, reutilizarlos y mantener tu proyecto más ordenado sin depender de escenas específicas.

En esta guía vas a aprender:

  • Qué son y cuándo usarlos (sin teoría excesiva)

  • Un caso de uso real para un juego indie

  • Cómo implementarlos paso a paso en C#

  • Buenas prácticas y errores comunes

1) Qué son los Scriptable Objects

Un Scriptable Object es un tipo de asset que vive en tu proyecto (como una textura o un prefab), pero su propósito es almacenar datos y configuración. La diferencia clave es que no dependen de una escena, no “viven” dentro de un GameObject y se pueden reutilizar en muchos lugares.

Úsalos cuando:

  • Necesitas datos compartidos entre escenas (por ejemplo, ítems, stats, armas, enemigos)

  • Quieres ajustar valores sin tocar prefabs en 30 escenas

  • Buscas separar “datos” de “comportamiento” (muy útil para escalar un indie)

2) Caso de uso indie

Imagina un juego indie con:

  • Ítems coleccionables

  • Armas con daño, cooldown y rareza

  • Enemigos con vida, velocidad y loot

En lugar de tener esos valores dispersos en scripts, los guardas en Scriptable Objects. Así puedes:

  • Crear un nuevo ítem sin programar más

  • Balancear el juego cambiando assets

  • Reutilizar la misma data en UI, gameplay y spawning

3) Implementación paso a paso (C#)

Paso A: Crear el Scriptable Object

Crea un archivo llamado: ItemData.cs

using UnityEngine;

public enum ItemRarity
{
    Common,
    Rare,
    Epic
}

[CreateAssetMenu(fileName = "NewItemData", menuName = "CodeAndPlay/Items/Item Data")]
public class ItemData : ScriptableObject
{
    [Header("Basic Info")]
    public string itemName;
    [TextArea] public string description;
    public Sprite icon;

    [Header("Gameplay")]
    public ItemRarity rarity = ItemRarity.Common;
    public int price = 10;

    [Header("Optional Stats")]
    public int power = 1;
}

Qué logras aquí:

  • Un asset reutilizable con data de ítems

  • Un menú de creación limpio dentro de Unity: CodeAndPlay/Items/Item Data

Paso B: Consumir la data desde un componente

Crea: ItemPickup.cs

using UnityEngine;

public class ItemPickup : MonoBehaviour
{
    [SerializeField] private ItemData itemData;

    public void Pickup()
    {
        if (itemData == null)
        {
            Debug.LogWarning("No ItemData assigned.");
            return;
        }

        Debug.Log($"Picked up: {itemData.itemName} ({itemData.rarity})");
        // Aquí llamarías a tu inventario: Inventory.Add(itemData);
        Destroy(gameObject);
    }
}

Beneficio inmediato: el comportamiento del pickup es estable; lo que cambia es el asset ItemData.

Paso C: Crear assets en Unity (sin programar más)

En Unity:

  1. Click derecho en Project window

  2. Create → CodeAndPlay → Items → Item Data

  3. Crea varios ítems: “Poción”, “Llave”, “Espada”, etc.

  4. Asigna el ItemData a diferentes pickups en escenas distintas

4) Buenas prácticas

4.1 Nombra y organiza tus assets

  • Carpeta: Assets/_Game/Data/Items/

  • Nombres claros: Item_Potion_Common, Item_Key_Rare

4.2 No metas lógica compleja en el Scriptable Object al inicio

Mantenlo como “data” para evitar dependencias raras. Si agregas lógica, que sea pequeña y bien controlada.

4.3 Evita modificar Scriptable Objects en runtime (sin intención)

Un error común: cambias valores en juego y luego se quedan guardados en el asset (editor). Si necesitas estado por partida, usa:

  • Clonar datos

  • O un sistema de “runtime instance”

5) Errores comunes y cómo evitarlos

Error 1: usar Scriptable Objects como si fueran “save data”

  • No son un sistema de guardado por sí solos.

  • Para guardado, usa JSON, PlayerPrefs o un sistema de Save/Load.

Error 2: referencias circulares

  • Si un Scriptable Object referencia a otro y ese a otro, puedes crear dependencias difíciles de debuggear. Mantén relaciones simples.

Error 3: mezclar “data” con “escena”

  • No dependas de objetos de escena dentro del Scriptable Object.

6) Mini mejora (opcional): mostrar la data en UI

El siguiente paso natural es usar ItemData para poblar UI:

  • Icon

  • Nombre

  • Rareza con color

  • Descripción

Esto se integra perfecto con un sistema de inventario o con un tooltip.

Los Scriptable Objects son una de las herramientas más potentes (y subutilizadas) en Unity para proyectos indie. Te permiten mantener tu juego más modular, balanceable y escalable sin complejidad innecesaria.

En el próximo artículo construiremos un inventario simple que almacene ItemData y lo muestre en UI de manera limpia.

Por último, si este tutorial te ayudó, compártelo en tus redes, revisa la categoría Unity en CodeAndPlay para más guías prácticas enfocadas en desarrollo indie.

You should also read: