Tutorial Godot 4: Como Criar um Sistema de Inventário (Parte 1)

Criar um sistema de inventário é um marco fundamental para quem deseja evoluir no desenvolvimento de jogos indie utilizando a Godot Engine 4. Se você está desenvolvendo um RPG, um jogo de sobrevivência ou aventura, saber gerenciar itens de forma profissional é essencial para o sucesso do seu projeto.

Neste guia prático, vamos programar a base lógica de um sistema de inventário modular, utilizando GDScript, garantindo que seu código seja limpo, organizado e fácil de escalar.

Por que o inventário é tão importante?

Um inventário bem planejado não é apenas uma lista de objetos: ele é parte da experiência do jogador. Ele permite:

Dar ao jogador sensação de progressão.
Implementar mecânicas de crafting, comércio e gerenciamento de recursos.
Organizar armas, poções e recursos coletados.

O que um sistema de inventário profissional precisa ter?

Antes de codificar, é vital entender a arquitetura do seu game design. Para não cometer erros comuns de iniciante — como misturar o código do inventário diretamente no script do jogador — precisamos de uma estrutura que responda:

Como gerenciar a lista de itens de forma otimizada?
Como organizar o código para evitar bugs (manutenibilidade)?
Como preparar a base para uma interface de usuário (UI)?

Uma boa prática é manter o inventário como um nó independente, que pode ser instanciado em diferentes personagens ou até mesmo em baús e lojas dentro do jogo. Isso evita duplicação de código e facilita a manutenção.

Organização do Projeto na Godot 4

Para manter seu projeto de jogo organizado, recomendo a seguinte hierarquia de pastas:

res://
├── Scenes/
├── Scripts/
├── Assets/
└── Inventory/

Programando a Base do Inventário com GDScript

Agora vamos criar o script Inventory.gd na pasta Scripts. Esse arquivo será o coração do nosso sistema de inventário, responsável por armazenar e manipular os itens do jogador.

extends Node

class_name Inventory

# Lista para armazenar nossos itens
var items = []

func add_item(item):
    items.append(item)
    print("Item adicionado: ", item)

func remove_item(item):
    items.erase(item)
    print("Item removido: ", item)

func has_item(item) -> bool:
    return item in items

func count_items() -> int:
    return items.size()

func clear_inventory():
    items.clear()
    print("Inventário limpo.")

Entendendo o Código Passo a Passo

extends Node: Diz à Godot que este script é baseado na classe Node. Isso significa que o inventário pode ser usado como um nó dentro da cena, podendo ser instanciado em qualquer personagem ou objeto do jogo.
class_name Inventory: Registra a classe com o nome Inventory. Assim, você pode criar novos inventários em outros scripts simplesmente chamando Inventory.new(), sem precisar usar load() ou preload().
var items = []: Cria um Array vazio que servirá como a lista de itens. Neste estágio inicial, cada item é apenas um texto (string), mas futuramente será substituído por objetos mais complexos chamados Resources, contendo atributos como nome, descrição, peso e ícone.
func add_item(item): Adiciona um novo item ao inventário usando append(). Também imprime no console uma mensagem para confirmar que o item foi adicionado.
func remove_item(item): Remove um item específico da lista usando erase(). Se o item não existir, nada acontece. Essa função também imprime no console para facilitar o debug.
func has_item(item) -> bool: Retorna true ou false dependendo se o item existe no inventário. Isso é útil para verificar se o jogador possui determinado recurso antes de usar.
func count_items() -> int: Retorna o número total de itens no inventário usando size(). Isso pode ser usado para limitar a quantidade máxima de itens ou mostrar ao jogador quantos objetos ele possui.
func clear_inventory(): Remove todos os itens da lista com clear(). Essa função pode ser usada em situações como reiniciar o jogo ou limpar o inventário após uma missão.

Por que essas funções são importantes?

Mesmo sendo simples, elas já oferecem uma base sólida para manipular o inventário. Com elas, você pode:

Adicionar novos itens coletados pelo jogador.
Remover itens usados ou descartados.
Verificar se o jogador possui um item antes de permitir uma ação (ex: abrir uma porta com chave).
Contar quantos itens existem para aplicar limites ou regras de jogo.
Limpar o inventário em eventos específicos.

Essas funções tornam o inventário flexível e fácil de expandir. Na próxima etapa, vamos conectar esse sistema ao personagem e testar na prática.

Testando sua Implementação

Agora que criamos a base do inventário, é hora de testar na prática. Essa etapa é essencial para garantir que o sistema esteja funcionando corretamente e que você entenda como integrá-lo ao seu personagem.

Criando a Cena do Jogador (Player.tscn)

Agora vamos montar a cena do jogador na Godot 4, passo a passo, para que você consiga testar o inventário dentro de um personagem controlável.

1. Criando a cena

No editor da Godot, clique em Outro Nó. Pesquise por CharacterBody2D, e click no icone dele para selecionar, logo em seguida em Criar. Esse será o nó principal que representa o jogador.

O CharacterBody2D já vem com funções próprias para movimentação, como move_and_slide(), o que facilita bastante.

2. Adicionando o Sprite2D

Em Cena, a esquerda da tela, clique em Adicionar Nó Filho, ou aperte Ctrl + A.
Pesquise e selecione Sprite2D e click em Criar.
No Inspector que ficar a direita da tela, click em Texture, carregue uma imagem (ou arraste uma imagem para dentro).

Esse sprite será a parte visual do jogador.

3. Adicionando a CollisionShape2D

Em Cena, click uma vez em CharacterBody2D. logo em seguida click novamente em Adicionar Nó Filho, ou aperte Ctrl + A.
Pesquise e selecione CollisionShape2D e click em Criar.
No Inspector que ficar a direita da tela, em Shape, click na seta para baixo (carregamento rapido) e escolha RectangleShape2D ou CircleShape2D.
Ajuste o tamanho da forma para cobrir o sprite.

Essa forma define a área de colisão do jogador, permitindo que ele interaja com o cenário.

4. Estrutura da cena

Player (CharacterBody2D)
├── Sprite2D
└── CollisionShape2D

5. Criando o script do jogador

Em Cena, selecione com um click o nó CharacterBody2D adicione um script chamado Player.gd. Esse script controlará o movimento e também instanciará o inventário.


extends CharacterBody2D

# Instanciando o inventário
var inventario = Inventory.new()

# Velocidade do jogador
var speed = 200

func _ready():
    # Testando o inventário
    inventario.add_item("Espada de Ferro")
    inventario.add_item("Poção de Cura")
    print("Inventário inicial: ", inventario.items)

func _physics_process(delta):
    var direction = Vector2.ZERO

    if Input.is_action_pressed("ui_right"):
        direction.x += 1
    if Input.is_action_pressed("ui_left"):
        direction.x -= 1
    if Input.is_action_pressed("ui_down"):
        direction.y += 1
    if Input.is_action_pressed("ui_up"):
        direction.y -= 1

    velocity = direction.normalized() * speed
    move_and_slide()

Aperte Ctrl + S, nomeie de Player, e salve na pasta Scenes.

6. Testando

Vamos testar o jogos de maneira simples, aperte no botão Play, que ficar na parte superior direita da tela, ou perte o botão F5, e clique em selecionar atual,

7. Rodando o Jogo

Quando você clica para rodar o projeto, a primeira coisa que aparece é apenas o personagem que colocamos na cena usando o Sprite2D (um tipo de objeto que serve para mostrar imagens na tela).

Se você apertar as setas do teclado, já vai perceber que o personagem consegue se mover — isso mostra que o controle básico está funcionando.

Agora, para testar se o inventário está funcionando, faça o seguinte:

Minimize a janela do jogo.
Olhe para a parte chamada Saída (Output) dentro do Godot 4.
Se tudo estiver certo, vão aparecer mensagens ali confirmando que o inventário foi ativado.

Mensagens de Saída


Item adicionado: Espada de Ferro
Item adicionado: Poção de Cura
Inventário inicial: ["Espada de Ferro", "Poção de Cura"]

8. Testando o Inventário em Tempo Real

Até aqui, nosso inventário foi testado apenas quando o jogo iniciou, dentro da função _ready(). Isso funciona, mas não é muito prático. Afinal, durante o jogo o jogador coleta, usa e descarta itens a qualquer momento.

Vamos deixar esse teste mais interessante permitindo adicionar e remover itens enquanto o jogo está rodando.

Passo 1 — Abra o script do jogador

No painel Cena, selecione o nó Player (CharacterBody2D) e abra o script Player.gd (ou play.gd, caso você tenha usado esse nome).

É o mesmo script que criamos anteriormente, onde já existem as funções _ready() e _physics_process().

Passo 2 — Adicione uma nova função

Role até o final do arquivo e, logo abaixo da função _physics_process(), cole o código abaixo.

Não substitua nenhum código existente. Apenas adicione esta nova função no final do script.

func _process(delta):

		 # Enter adiciona um item
	if Input.is_action_just_pressed("ui_accept"):
		inventario.add_item("Arco de Caça")
		print("Inventário atual: ", inventario.items)

    # Esc remove esse item
	if Input.is_action_just_pressed("ui_cancel"):
		inventario.remove_item("Arco de Caça")
		print("Inventário atual: ", inventario.items)

Passo 3 — Salve o projeto

Pressione Ctrl + S para salvar o script.

Passo 4 — Execute o jogo

Agora pressione F5 para iniciar o projeto.

Assim que o personagem aparecer na tela:

Pressione Enter para adicionar um Arco de Caça ao inventário.
Pressione Esc para remover esse item.

Depois de cada ação, minimize a janela do jogo e observe o painel Output da Godot. Você verá a lista do inventário sendo atualizada automaticamente.

O que essa função faz?

A função _process() é executada continuamente enquanto o jogo está rodando. Ela verifica, a cada quadro, se alguma tecla foi pressionada.

ui_accept corresponde à tecla Enter nas configurações padrão da Godot.
ui_cancel corresponde à tecla Esc.

Quando pressionamos Enter, chamamos a função add_item(), adicionando um novo item ao inventário.

Quando pressionamos Esc, chamamos remove_item(), removendo esse mesmo item.

Já a função print() serve apenas para mostrar o conteúdo atual do inventário no painel Output, facilitando nossos testes.

Pronto!

Neste ponto você já possui um inventário completamente funcional. Mesmo sem uma interface gráfica, já é possível adicionar, remover e verificar os itens durante a execução do jogo. Na próxima parte do tutorial vamos construir a interface visual (UI), mostrando cada item na tela como acontece em jogos profissionais.

Próximos Passos

Com essa base, você já consegue manipular itens no inventário. O próximo passo será conectar esse sistema a uma interface visual (UI), permitindo que o jogador veja os itens na tela em tempo real. Mas antes disso, é importante garantir que todas as funções básicas estejam funcionando corretamente.

Dica: sempre teste seu inventário em diferentes situações. Isso evita bugs futuros e garante que sua lógica esteja sólida antes de avançar para recursos mais complexos.

pesquisar