Build Powerful and Scalable Inventories in Godot

February 11, 2025

Introduction: The Inventory Problem

Every RPG developer knows the struggle – you’re building your game, and suddenly you feel like the player should be able to pick up and store 69 beers. How do you create a system that’s both flexible enough to handle various item types and efficient enough to scale with your game’s complexity? In my journey developing a 2D RPG in Godot, I faced these exact challenges. The inventory system needed to handle consumables, key items, and equipment, all while maintaining clean code architecture and providing a smooth player experience. Let me walk you through my solution.

The What: Understanding the Core Components

Before diving into the code, it’s essential to understand the core components of an inventory system. At its heart, an inventory system needs to:

Store items with unique properties (e.g., consumables, weapons, key items).
Track item quantities and manage item interactions (e.g., use, drop).
Integrate with other game systems like quests and player stats.

To achieve this, we’ll break down the system into three main parts: the Item Database, the Inventory Manager, and the UI Layer.

graph TD
    A[<b>Item Database</b>] 
    F[<b>Inventory Manager</b>] -->|Manages| G[<b>Player Inventory</b>]
    F -->|Uses| A

The How: Implementing the Inventory System

1. The Item Database

The Item Database is the backbone of our inventory system. It stores all the items available in the game, along with their properties. In Godot, we can use a Resource to define our item database:

extends Resource
class_name ItemDatabase

@export var items: Array[PackedScene]
var itemInstances = []

func getItemByName(itemName: String):
    for instance in itemInstances:
        if instance.stats.itemName == itemName:
            return instance
    return null

Each item is defined as a PackedScene, allowing us to instantiate items dynamically. This approach makes it easy to add new items without modifying the core system.

2. The Inventory Manager

The Inventory Manager handles the logic for adding, removing, and interacting with items. It also communicates with the UI to update the player’s inventory display. Here’s a simplified version of the Inventory Manager:

extends Node

var itemDb: ItemDatabase
var itemInstances = []

func _ready():
    itemDb = preload("res://resources/libraries/items/ItemDatabase.tres")
    initItems()

func initItems():
    for item in itemDb.items:
        var instance = item.instantiate()
        add_child(instance)
        itemInstances.append(instance)

func getNewItemInstance(itemName: String):
    for instance in itemInstances:
        if instance.stats and instance.stats.itemName == itemName:
            return instance
    return null

This manager ensures that items are properly instantiated and accessible throughout the game. Furthermore, this is the place where you want to keep track of which items are in the inventory currently etc.

3. The UI Layer

The UI Layer is responsible for displaying the inventory to the player. It should be flexible enough to handle different item types (e.g., consumables, weapons) and provide intuitive interactions. Here’s a snippet of how we can structure the UI:

extends HBoxContainer

func _on_tab_clicked(tab):
    buildFilteredItemList(get_tab_control(tab).filterForItemType)

func buildFilteredItemList(itemTypeId):
    var menuButtonContainer
    match itemTypeId:
        0: menuButtonContainer = $Consumables/PanelContainer/ScrollContainer/VBoxContainer 
        1: menuButtonContainer = $Weapons/PanelContainer/ScrollContainer/VBoxContainer
        2: menuButtonContainer = $"Key Items"/PanelContainer/ScrollContainer/VBoxContainer
        99: menuButtonContainer = $"All Items"/PanelContainer/ScrollContainer/VBoxContainer

    for item in itemMap:
        if ((item.stats.itemType == itemTypeId) or (itemTypeId == 99)): 
            var btn = itemMap.get(item).get("menuButton")
            btn.get_parent().remove_child(btn)
            menuButtonContainer.add_child(btn)

This code ensures that the UI dynamically updates based on the selected item type, providing a seamless experience for the player. In my case, the UI Layer is a Control Node while the Inventory Manager is a script attached to the Control Node.

4. Making it useful

From here, I took it further and integrated the inventory system with my other systems. The flowchart below visualizes the complete architecture with the extended functionality. The Item Database serves as the central repository feeding item definitions into the Inventory Manager, which handles real-time inventory operations including quantity tracking and interaction processing. The UI Layer not only displays inventory states but actively manages player input through event-driven design – notice how consuming an item triggers an update loop between the manager and UI. This bidirectional flow enables instant feedback while maintaining separation of concerns between data management and presentation layers.

graph TD
    A[<b>Item Database</b>] -->|Stores| B[Item Definitions]
    F[<b>Inventory Manager</b>] -->|Manages| G[<b>Player Inventory</b>]
    G -->|Tracks| H[Item Quantities]
    G -->|Handles| I["Item Interactions(e.g. consuming item)"]
    F -->|Uses| A
    J[UI Layer] -->|Displays| G
    J -->|Handles| K[Player Input]
    K -->|Triggers| I
    I -->|Updates| G
    G -->|Updates| J

Conclusion: The Future of Your Inventory System

Remember, the best inventory system is one that feels intuitive to the player while being easy for you to maintain. So, start small, iterate often, and don’t be afraid to refactor as your needs change. I didn’t come up with the system shown in the diagram above in one iteration either.

“The art of simplicity is a puzzle of complexity.” – Douglas Horton

In the next blog post, we’ll dive into integrating this inventory system with quests and player stats. Consider subscribing to my Newsletter if you don’t want to miss it!

In

concepts, systems