Inventory 2 | Game Creator 2

About Inventory 2 | Game Creator 2 – Unity Editor Tool & Plugin

Inventory 2 | Game Creator 2 Unity Asset Overview

Honestly, building a production-ready inventory system from scratch in Unity is one of those developer tasks that sounds straightforward until you are deep in the weeds. Between handling stack limits, equipment slot validation, UI data-binding, persistence across scene loads, and crafting dependencies, custom inventory code can quickly morph into a tangled web of boilerplate logic. This is precisely where Inventory 2 for Game Creator 2 comes into play.

As an extension module specifically engineered for the Game Creator 2 (GC2) architecture, Inventory 2 adopts a modular, data-driven framework. Instead of tying item data directly to MonoBehaviour instances, the asset centers its architecture on Unity's ScriptableObject system. Abstract definitions for items, equipment types, crafting recipes, and bag behaviors exist cleanly in project assets, detached from scene execution. At runtime, the core Bag component manages dynamic instances, state modifications, and event broadcasts without creating unnecessary garbage collection overhead.

Core Technical Features & Highlights

In my experience shipping indie and AA titles on Unity, inventory modules often fail at two main friction points: UI synchronization and clean runtime serialization. Inventory 2 solves both issues natively within the GC2 visual scripting pipeline.

Data Architecture & ScriptableObjects

The system breaks inventory management into decoupled asset definitions:

• Item Assets: Defines unique identifiers, display names, localized descriptions, icons, stack thresholds, weight/volume properties, and dynamic attributes (e.g., weapon stats, durability).
• Bag Components: Component attached to entities (Player, NPCs, Chests) that maintains dynamic runtime inventory states, equipped gear, runtime capacity limits, and container restrictions.
• Equipment & Sockets: Modular equipment tracking that validates item types against designated slots (e.g., Primary Weapon, Headgear, Accessories) and dispatches events when gear state changes.
• Crafting & Recipe Systems: Built-in structural blueprints for combining base materials into outcome items with success probabilities, crafting time delays, and required tool conditions.

UI Framework & Event System

Instead of forcing you into a rigid UI layout, Inventory 2 provides template-driven UI components built to work with both standard Unity uGUI and modern UI Toolkit layouts. View components hook directly into runtime state changes via reactive event listeners. When an item is added, consumed, or moved, only the corresponding slot view repaints, preventing expensive full-grid redraws.

using UnityEngine;
using GameCreator.Runtime.Common;
using GameCreator.Runtime.Inventory;

public class CustomLootDrop : MonoBehaviour
{
    [SerializeField] private Item itemToGrant;
    [SerializeField] private int quantity = 1;

    public void GiveLootToPlayer(GameObject playerTarget)
    {
        // Extract the Bag component from the GC2 character target
        Bag bag = playerTarget.GetComponent<Bag>();
        
        if (bag != null && itemToGrant != null)
        {
            // Add item directly to player runtime inventory
            bag.Content.Add(this.itemToGrant, this.quantity);
            Debug.Log($"Successfully added {quantity}x {itemToGrant.Name} to player bag.");
        }
    }
}

Ideal Use Cases & Game Genres

While Inventory 2 is built to be flexible, its out-of-the-box features shine brightest in specific game genres built on the Game Creator 2 ecosystem:

• Action RPGs & Dungeon Crawlers: Requires deep stats, gear slots, sockets, consumables, durability loss, and loot tables.
• Survival & Crafting Titles: Benefits heavily from grid or weight-based inventory constraints, material aggregation, and multi-tier crafting blueprints.
• Open World Adventure Games: Ideal for managing quest items, key/lock mechanisms, vendor shops, and persistent chest containers spread across multiple scenes.
• Tactical Strategy / Turn-Based Titles: Allows rapid assignment of individual inventories to multiple controlled units simultaneously.

Quick-Start Unity Setup & Integration Guide

Integrating Inventory 2 into an existing Game Creator 2 project takes minutes if you follow this step-by-step developer workflow:

Step 1: System Verification & Package Import

Ensure your project is running Unity 2021.3 LTS or higher and has the core Game Creator 2 package fully installed. Import the Inventory 2 module via the Unity Package Manager. Ensure there are no compilation errors in your project before proceeding.

Step 2: Defining Item Assets

Navigate to your Project window, right-click, and choose Create > Game Creator > Inventory > Item. Name your newly created ScriptableObject (e.g., Item_HealthPotion). In the Inspector panel, configure its base parameters: Assign an icon sprite, specify standard stack quantities (e.g., 99), set item weight, and define dynamic Properties such as health restoration values.

Step 3: Attaching Bag Components to Characters

Select your Player GameObject in the scene hierarchy. Click Add Component and attach the Bag component. Here, configure container parameters such as maximum weight capacity, slot grid constraints, and allowed item categories.

Step 4: Linking UI Elements & Visual Scripting

Drag the standard UI Inventory prefab provided by the asset into your canvas. Ensure the UI container references your Player character's Bag component. Using Game Creator 2's Visual Scripting interface, create a new Trigger on keypress (e.g., pressing 'I') executing the Toggle Inventory Canvas Action.

using UnityEngine;
using GameCreator.Runtime.Inventory;

// Helper script demonstrating dynamic item queries
public class InventoryChecker : MonoBehaviour
{
    [SerializeField] private Bag playerBag;
    [SerializeField] private Item keycardItem;

    public bool HasRequiredKeycard()
    {
        if (playerBag == null || keycardItem == null) return false;

        // Query internal item count from bag content
        int currentAmount = playerBag.Content.Count(keycardItem);
        return currentAmount > 0;
    }
}

Pros & Cons Assessment

Here is the key takeaway: Inventory 2 saves hundreds of development hours, but it comes with clear architectural trade-offs depending on your project setup.

• Pros:
  • Deep native integration with Game Creator 2's visual triggers, actions, and conditions.
  • Clean architecture separating raw item definitions (ScriptableObjects) from runtime instances (Bags).
  • Out-of-the-box support for gear equipping, loot containers, crafting, and vendor/shop mechanics.
  • Saves and restores inventory state automatically using GC2's persistent Save System.
  • Extensible modular codebase allowing custom C# extensions for bespoke gameplay mechanics.
• Cons:
  • Hard dependency on the core Game Creator 2 framework—cannot be used standalone.
  • Default UI visual style requires significant styling work to match custom visual aesthetics.
  • Complex slot-based grid layouts (e.g., irregular Resident Evil-style multi-tile shapes) require custom extension logic.

Developers Who Downloaded This Also Downloaded

Related Unity Tools Assets