Crafting a Robust Inventory System for Your Godot Roguelike

Posted by Gemma Ellison

July 21, 2025

It’s a familiar scene for any aspiring game developer: you’ve poured your heart into crafting a compelling world, populated it with intriguing characters, and established a satisfying gameplay loop. But wait! Your hero is bravely battling goblins without a rusty sword, or worse, lugging around twenty broadswords like some sort of medieval hoarder. A robust, functional, and dare I say, elegant inventory system is the unsung hero of countless RPGs and roguelikes. Let’s cut through the fluff and get our hands dirty, crafting a rock-solid inventory for your Godot roguelike.

Defining the Item Data Structure

Forget using flimsy variables scattered throughout your code. We need a centralized, easily accessible, and highly adaptable data structure. Dictionaries are your best friend here. They allow you to store various properties for each item in a key-value format.

Example:

var sword = {
    "name": "Rusty Sword",
    "description": "A slightly used, slightly dull sword.",
    "type": "weapon",
    "damage": 5,
    "weight": 2.5,
    "icon": preload("res://assets/icons/sword.png")
}

Don’t be afraid to add more data to your items! Critical hit chance, armor rating, special abilities – the possibilities are endless. The important part is keeping it organized within the dictionary.

The Inventory: An Array of Possibilities

Now that we have our item data structure down, we need a place to store them. An array is the natural choice for an inventory. It’s a simple ordered list that can hold any number of items (within reason, of course – memory is finite!).

var inventory = []

That’s it! A simple, empty inventory waiting to be filled with loot.

Item Management: Adding, Removing, and Equipping

This is where the rubber meets the road. We need functions to manipulate the inventory array. Let’s start with adding items:

func add_item(item):
    inventory.append(item)
    # Tell the UI to update! (More on this later)
    emit_signal("inventory_changed")

Removing items is equally straightforward:

func remove_item(item):
    if item in inventory:
        inventory.erase(item)
        emit_signal("inventory_changed")
    else:
        print("Item not found in inventory!")

Equipping items requires a bit more finesse. We’ll need to check the item type and potentially unequip any existing item in that slot.

var equipped = {
    "weapon": null,
    "armor": null
}

func equip_item(item):
    if item.type == "weapon":
        # Unequip existing weapon
        if equipped.weapon != null:
            unequip_item("weapon")
        equipped.weapon = item
        emit_signal("inventory_changed") #Or create an equipped_changed signal
    elif item.type == "armor":
        # Logic for equipping armor
        pass
    else:
        print("Cannot equip item of type: ", item.type)

func unequip_item(slot):
    if equipped[slot] != null:
        equipped[slot] = null
        emit_signal("inventory_changed")#Or create an equipped_changed signal

Pitfalls to Avoid:

Forgetting to check if an item exists before removing it. This can lead to errors and crashes.
Not updating the UI after inventory changes. This will leave the player confused and frustrated.
Hardcoding item types. Use constants or enums to make your code more maintainable.

UI Updates with Signals: The Key to Reactivity

Directly manipulating UI elements from your inventory logic is a recipe for spaghetti code. Signals provide a clean and efficient way to communicate changes to the UI.

In your inventory script, define a signal:

signal inventory_changed

Whenever you add or remove an item, emit this signal. Your UI code can then connect to this signal and update the display accordingly.

Example (in your UI script):

func _ready():
    inventory_script.connect("inventory_changed", _on_inventory_changed)

func _on_inventory_changed():
    # Update the UI to reflect the current inventory
    update_inventory_display() # Replace with your actual UI update logic

Example: Creating a UI Slot and Populating It

Let’s say you have a TextureRect node in your UI representing a single inventory slot. The update_inventory_display() function might look something like this:

func update_inventory_display():
    #Clear existing icons first

    for i in range(inventory_script.inventory.size()):
        var item = inventory_script.inventory[i]
        var slot = slot_container.get_child(i) # Assuming slots are children

        if slot != null and slot is TextureRect:
            slot.texture = item.icon

Challenges and Solutions:

Limited Inventory Size: Implement a maximum inventory size and prevent the player from picking up more items when the inventory is full. Display a message informing them of this.
Drag and Drop: Use Godot’s input event system to allow players to drag and drop items within the inventory and between the inventory and the game world.
Stacking Items: If you want to allow stacking of identical items, modify the add_item function to check if the item already exists in the inventory and increment its quantity instead of adding a new entry.

Why This Approach? Modularity and Expandability

This system is designed to be modular and expandable. By using dictionaries for item data and signals for UI updates, you can easily add new items, modify existing items, and create new UI elements without breaking your existing code. This is crucial for larger projects with complex inventory systems. This approach also gives you more freedom to add complex features such as crafting, item durability, or item identification later on without a full re-write of your inventory code.

Don’t get bogged down in overly complex solutions from the start. Begin with the fundamentals. A simple yet expandable system will give you more room to grow and adapt as you build your roguelike masterpiece!