En el desarrollo de videojuegos con Unity, uno de los retos más comunes es crear un sistema de inventario que sea flexible, escalable y fácil de mantener. Muchos desarrolladores comienzan utilizando listas estáticas o referencias directas a objetos en escena, lo que rápidamente se convierte en un problema cuando el proyecto crece. Por suerte, ScriptableObjects ofrecen una forma eficiente y elegante de gestionar datos de inventario de manera dinámica, evitando dependencias complicadas y mejorando la organización del proyecto.

En este post, vamos a profundizar en cómo implementar un sistema de inventario dinámico en Unity usando ScriptableObjects, desde la creación de los objetos de datos hasta la integración con la interfaz de usuario y la gestión de eventos de juego. Aprenderás no solo a almacenar información de items, sino también a actualizar el inventario en tiempo real, crear efectos visuales y asegurar la escalabilidad del sistema.

¿Qué son los ScriptableObjects en Unity?

Antes de adentrarnos en la implementación, es importante entender qué son los ScriptableObjects. Se trata de un tipo de objeto que Unity permite crear como un asset independiente del resto de los objetos de la escena. Esto significa que:

• Puedes almacenar datos sin necesidad de asociarlos a un GameObject.

• Los datos persisten entre escenas y se pueden reutilizar fácilmente.

• Mejoran la organización del proyecto al centralizar la información.

En términos prácticos, un ScriptableObject es perfecto para definir items de inventario, configuraciones de enemigos, niveles de habilidades o cualquier otro dato que necesites gestionar de forma centralizada y editable desde el editor de Unity.

Ventajas de usar ScriptableObjects en sistemas de inventario

El uso de ScriptableObjects para crear inventarios trae múltiples ventajas frente a otras soluciones tradicionales:

1. Separación de datos y lógica: Almacenas la información de los items de forma independiente del código que gestiona el inventario.

2. Reutilización: Un mismo ScriptableObject puede ser referenciado por múltiples sistemas, evitando duplicar datos.

3. Persistencia entre escenas: Los datos pueden ser compartidos en diferentes escenas sin necesidad de pasar referencias manualmente.

4. Escalabilidad: Es fácil añadir nuevos items o categorías sin modificar la lógica del inventario.

5. Compatibilidad con el editor: Puedes crear, editar y organizar los items directamente desde Unity, con visualización clara y sin necesidad de scripts adicionales.

Estas ventajas hacen que los ScriptableObjects sean la opción preferida para diseñadores que buscan iterar rápidamente y desarrolladores que quieren mantener el código limpio y organizado.

Estructura básica de un sistema de inventario

Antes de codificar, debemos definir cómo vamos a estructurar el inventario. Un sistema de inventario dinámico generalmente incluye:

1. ItemData: un ScriptableObject que contiene la información de cada item (nombre, icono, descripción, cantidad máxima, etc.).

2. Inventory: un componente que gestiona la lista de items que el jugador posee en tiempo real.

3. UIInventory: un sistema de interfaz que muestra los items, sus iconos y cantidades en la pantalla.

4. EventSystem o ScriptableEvents: opcionalmente, podemos usar eventos para notificar a la UI cuando se agregan o eliminan items, manteniendo la lógica desacoplada.

Creando el ScriptableObject para los items

El primer paso es definir la clase base para los items del inventario:

using UnityEngine;

[CreateAssetMenu(fileName = "NewItem", menuName = "Inventory/Item")]
public class ItemData : ScriptableObject
{
    public string itemName;
    public Sprite icon;
    public int maxStack = 1;
    public string description;
}

Con este código, podrás crear nuevos items directamente desde el menú de Unity: Assets → Create → Inventory → Item. Cada ScriptableObject será un asset independiente que puedes rellenar con los datos del item: nombre, icono, descripción y cantidad máxima.

Creando la clase de inventario

A continuación, necesitamos una clase que gestione la lista de items que el jugador posee. Esta clase interactuará con los ScriptableObjects que hemos creado:

using System.Collections.Generic;
using UnityEngine;

public class Inventory : MonoBehaviour
{
    public List<ItemData> items = new List<ItemData>();

    public void AddItem(ItemData newItem)
    {
        if (!items.Contains(newItem))
        {
            items.Add(newItem);
        }
    }

    public void RemoveItem(ItemData item)
    {
        if (items.Contains(item))
        {
            items.Remove(item);
        }
    }

    public bool HasItem(ItemData item)
    {
        return items.Contains(item);
    }
}

Esta clase permite añadir, eliminar y comprobar la existencia de items de manera sencilla. Al trabajar con ScriptableObjects, no necesitamos duplicar información ni preocuparnos por referencias en la escena.

Integrando la interfaz de usuario

Para que el inventario sea útil, necesitas mostrar los items en pantalla. Una manera sencilla de hacerlo es mediante un panel de UI con Grid Layout y botones que representen cada item.

Ejemplo básico de UIInventory:

using UnityEngine;
using UnityEngine.UI;

public class UIInventory : MonoBehaviour
{
    public Inventory inventory;
    public GameObject slotPrefab;
    public Transform slotsParent;

    void Start()
    {
        UpdateUI();
    }

    public void UpdateUI()
    {
        foreach (Transform child in slotsParent)
        {
            Destroy(child.gameObject);
        }

        foreach (var item in inventory.items)
        {
            GameObject slot = Instantiate(slotPrefab, slotsParent);
            slot.GetComponent<Image>().sprite = item.icon;
            slot.GetComponentInChildren<Text>().text = item.itemName;
        }
    }
}

Cada vez que se añade o elimina un item, basta con llamar a UpdateUI() para refrescar la interfaz.

Mejorando la gestión de inventario

Para sistemas más complejos, puedes:

• Implementar stacking de items, utilizando la propiedad maxStack de cada ScriptableObject.

• Añadir un sistema de eventos para notificar automáticamente a la UI sin necesidad de refrescarla manualmente.

• Crear categorías de items usando herencia de ScriptableObjects (por ejemplo, armas, consumibles, armaduras).

• Guardar y cargar el inventario mediante serialización o PlayerPrefs, usando los nombres o IDs de los ScriptableObjects.

Ejemplo de stacking y eventos

Para implementar stacking y eventos, podemos usar una clase intermedia:

using System;
using System.Collections.Generic;
using UnityEngine;

[Serializable]
public class InventoryItem
{
    public ItemData item;
    public int quantity;
}

public class Inventory : MonoBehaviour
{
    public List<InventoryItem> items = new List<InventoryItem>();
    public Action OnInventoryChanged;

    public void AddItem(ItemData newItem, int amount = 1)
    {
        InventoryItem existing = items.Find(i => i.item == newItem);
        if (existing != null)
        {
            existing.quantity = Mathf.Min(existing.quantity + amount, newItem.maxStack);
        }
        else
        {
            items.Add(new InventoryItem { item = newItem, quantity = amount });
        }

        OnInventoryChanged?.Invoke();
    }
}

Con esto, cada vez que se modifica el inventario, la UI puede actualizarse automáticamente escuchando OnInventoryChanged.

Buenas prácticas con ScriptableObjects

1. No almacenar estado mutable en el ScriptableObject: Guarda solo datos estáticos del item (nombre, icono, descripción). El estado dinámico, como cantidad o durabilidad, debe ir en otra clase (InventoryItem).

2. Usar prefabs o referencias para efectos: Los efectos visuales, sonidos o animaciones no deben ir directamente en los ScriptableObjects, sino referenciados desde ellos.

3. Organizar en carpetas: Mantén todos los ScriptableObjects en una carpeta de assets para mejorar la mantenibilidad del proyecto.

4. Reutilizar ScriptableObjects: Evita duplicar assets. Un mismo item puede usarse en varias escenas o inventarios sin necesidad de crear otro asset.

Conclusión

Implementar un sistema de inventario dinámico en Unity utilizando ScriptableObjects permite separar datos de la lógica, mejorar la escalabilidad y mantener el proyecto organizado. Siguiendo las buenas prácticas mencionadas y estructurando correctamente tus clases, puedes crear un sistema robusto que se adapte a cualquier tipo de juego, desde RPG hasta shooters o simuladores.

En resumen, los pasos clave para un inventario eficiente son:

• Crear ScriptableObjects para definir los items de forma centralizada.

• Implementar una clase de inventario que gestione los items en tiempo real.

• Desarrollar una UI que refleje el inventario dinámicamente.

• Añadir sistemas de stacking y eventos para mejorar la interacción.

• Seguir buenas prácticas para mantener los ScriptableObjects limpios y reutilizables.

Con estos elementos, no solo tendrás un inventario funcional, sino que también conseguirás un flujo de trabajo más ágil, profesional y preparado para escalar a medida que tu proyecto crezca. Dominar los ScriptableObjects es una habilidad esencial para cualquier desarrollador de Unity que quiera crear juegos modernos y eficientes.

Aprende sobre Desarrollo de Videojuegos con la Ruta de Frogames Formación

Si te ha interesado lo que te hemos contado en este post, te encantará saber que puedes profundizar en este tema y en todas las habilidades relacionadas con Desarrollo de Videojuegos a través de la ruta de aprendizaje de Frogames Formación.

Esta ruta ha sido diseñada para quienes desean iniciarse desde cero y avanzar paso a paso hasta dominar las herramientas y técnicas que usan los profesionales del sector. Aprenderás de forma práctica y amena todo lo necesario para crear tus propios juegos, desde los fundamentos del diseño y la programación hasta la publicación en diferentes plataformas.

A lo largo del recorrido, explorarás áreas clave como Unity, Unreal Engine, modelado 3D, animación, narrativa interactiva y diseño de niveles, siempre con un enfoque práctico y orientado a resultados. Cada módulo está pensado para que puedas aplicar los conocimientos en proyectos reales, desarrollando un porfolio sólido y profesional.

Si quieres convertir tu pasión por los videojuegos en una carrera y aprender a diseñar, desarrollar y optimizar experiencias interactivas completas, la Ruta de Desarrollo de Videojuegos de Frogames Formación es justo lo que necesitas.

¡Da el primer paso hacia una profesión creativa, tecnológica y llena de oportunidades!

¡Nos vemos en clase!