Ultimate Grid Inventory

About Ultimate Grid Inventory – Unity Editor Tool & Plugin

Ultimate Grid Inventory Unity Asset Overview

In mid-to-complex Unity projects, building a grid-based inventory from scratch is often a deceptively time-consuming task. Managing dynamic spatial placement, multi-cell item occupancy, item rotation, auto-sorting, and context-menu interactions can quickly lead to monolithic codebases if not structured carefully from day one. The Ultimate Grid Inventory asset provides a well-architected framework designed to handle the heavy lifting of spatial inventory management for Unity developers.

Architecture-wise, the framework relies on a clean Model-View-Controller (MVC) approach coupled with an event-driven design pattern. Data storage for items is completely decoupled from the rendering layer. The backend grid mechanics operate on a 2D spatial array (Matrix), managing item footprints and bounds detection independently of the UI. Meanwhile, the view layer uses standard UGUI Layout Groups and canvas rendering components to translate data matrix states into smooth drag-and-drop visuals. In my experience testing this system on large inventory sets, this clean separation prevents performance hitches and makes custom network synchronization much more straightforward.

Core Technical Features & Highlights

Under the hood, the architecture is modular and highly extensible. Here is a breakdown of the core technical features that make this asset stand out:

Data-Driven Item System

Items are constructed using ScriptableObjects (`ItemDefinition`), keeping runtime instance footprints minimal. Each item defines its base metadata, grid dimensions (`width` x `height`), sprite icon, stack capacity, weight, and custom extension scripts for consumable or equipment behaviors.

Spatial Occupancy & Rotation Logic

The core grid spatial engine evaluates cell collisions using dynamic matrix bounding checks. When a player rotates an item during a drag operation, the system automatically recalculates the occupied matrix footprint using matrix transformation logic without leaking garbage collector allocations at runtime.

Performance & UI Architecture

• Zero-Allocation UI Dragging: Utilizes native UGUI event interfaces (`IBeginDragHandler`, `IDragHandler`, `IEndDragHandler`) combined with dynamic visual feedback loops that avoid constant runtime allocations.
• Object Pooling: Item slots and dynamic UI icons are instantiated and recycled through an internal UI pooling manager, minimizing overhead when opening large container views.
• Flexible Render Pipeline Support: Works out of the box with the Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and the Built-in Render Pipeline, as UI space interactions rely on standard Screen/World Space Canvas setups.

Ideal Use Cases & Game Genres

Honestly, grid inventory systems carry a specific style and mechanical weight. This template is particularly suited for genres where inventory space and item layout directly impact gameplay decisions:

• Tactical Survival Shooters: Perfect for Tarkov-style gear layouts where equipment size, backpacks, and tactical chest rigs mandate tight spatial inventory decisions.
• Action RPGs & Hack-and-Slash: Ideal for isometric loot games like Diablo, where weapons and armor occupy multi-cell slots (e.g., 2x3 for longswords, 1x1 for rings).
• Survival Horror Games: Excellent for Resident Evil style resource management setups, encouraging strategic item reorganization, combination, and ammo conservation.
• Space & Sci-Fi Simulators: Suitable for managing cargo bays, modular starship components, and hardpoint mounting systems.

Quick-Start Unity Setup & Integration Guide

Integrating the asset into an existing workflow is straightforward. Here is a practical quick-start setup path to get the inventory running in your scene:

Step 1: Inventory Controller Setup

Attach the GridInventoryController component to your UI Canvas or a dedicated player manager GameObject. Assign your inventory bounds (e.g., 8 columns by 6 rows) within the Inspector interface.

Step 2: ScriptableObject Asset Creation

Create your item definitions by navigating to Assets > Create > Inventory > Item Definition. Set the Width, Height, and inventory preview icon sprite for each item.

Step 3: Programmatic Item Insertion

Here is how you can programmatically add items into the player's inventory grid upon picking up loot or executing a console command:

using UnityEngine;
using UltimateGridInventory;

public class PlayerLootContainer : MonoBehaviour
{
    [SerializeField] private GridInventoryController _gridInventory;
    [SerializeField] private ItemDefinition _lootItem;

    public void CollectLoot()
    {
        if (_gridInventory == null || _lootItem == null) return;

        // Check if there is space available in the spatial matrix
        if (_gridInventory.InventoryModel.TryFindSpace(_lootItem, out Vector2Int gridPosition))
        {
            // Successfully insert the item into the calculated slot coordinate
            _gridInventory.AddItem(_lootItem, gridPosition);
            Debug.Log($"Placed {_lootItem.ItemName} at cell position: {gridPosition}");
        }
        else
        {
            Debug.LogWarning("Inventory grid is full! Spilling loot into world space.");
            DropLootInWorld();
        }
    }

    private void DropLootInWorld()
    {
        // Instantiation logic for dropping dynamic item prefab into 3D world space
    }
}

Pros & Cons Assessment

Pros

• Clean Code Architecture: Clear separation between backend grid data (`InventoryModel`) and dynamic UI visual elements (`GridInventoryUI`).
• Highly Performant: Grid checking algorithms run cleanly without dropping frames, even when managing large container sizes.
• Flexible Auto-Sorting: Built-in sorting logic handles automatic item organization based on size, item type, or rarity out of the box.
• Input System Ready: Easily binds with both Unity's Legacy Input Manager and the newer Input System Package.

Cons

• UGUI Centric: Built primarily around UGUI. Teams looking for native UI Toolkit support will need to refactor visual presentation scripts.
• Initial Learning Curve: Setting up complex nested containers (e.g., opening a backpack inside an inventory) requires understanding how the model handles secondary grid instances.

Developers Who Downloaded This Also Downloaded

Related Unity Tools Assets