Como Fazer um Jogo de Fazenda: Sistemas, Código e Escopo Real

Sempre que alguém me pergunta como fazer um jogo de fazenda, eu começo com um aviso, não com uma resposta técnica: esse é um dos gêneros que mais enganam quem está começando. Na tela, um farming sim parece o projeto perfeito pra iniciante. Não tem física complicada, não tem inimigo com IA, não tem combate pra balancear. É plantar, esperar, colher e vender. O problema é que cada um desses verbos esconde um sistema, e os sistemas conversam entre si o tempo todo. Depois de mais de vinte anos nessa indústria, eu aprendi a respeitar o gênero exatamente por isso: fazenda é fácil de começar e difícil de terminar.

Neste guia eu desmonto o farming sim nos sistemas que o sustentam, mostro código real na Godot 4, com GDScript tipado, e fecho com a ordem de construção que eu seguiria se fosse começar um hoje. A meta não é te ensinar a fazer o próximo Stardew Valley. É te ensinar a terminar uma fazenda pequena que funciona, o que já coloca você na frente da maioria.

A armadilha do escopo: por que fazenda engana

Stardew Valley foi feito por uma pessoa, Eric Barone, ao longo de aproximadamente quatro anos. Esse fato é público e conhecido, e eu não trago ele aqui pra te inspirar. Trago pra calibrar a régua. Quatro anos de uma pessoa dedicada, programando, desenhando e compondo, é o custo real do jogo que provavelmente te trouxe até este texto. Seu primeiro farming sim não precisa custar isso, e não deve. Mas ele só vai custar menos se você entender de onde vem o custo.

O custo vem da interconexão. O ciclo de dia alimenta o crescimento das plantas. O crescimento alimenta a colheita. A colheita alimenta o inventário. O inventário alimenta a economia. A economia paga as ferramentas melhores, que mudam a interação com o grid, que muda o ritmo do dia. Nenhum sistema vive sozinho, então cada sistema novo não soma trabalho, multiplica. Quando entram estações, cada cultivo ganha calendário e cada tile ganha variação visual. Quando entram NPCs, cada dia ganha agenda, diálogo e presente favorito. É assim que um projeto de três meses vira um projeto de três anos sem que ninguém perceba a virada.

A saída não é desistir do gênero, é fatiar. Um farming sim mínimo, com o loop de plantar, esperar, colher e vender, é um projeto perfeitamente possível pra um dev solo em alguns meses. O que mata os projetos é tentar construir a fazenda, a mina, a pesca, o casamento e os festivais ao mesmo tempo.

Como fazer um jogo de fazenda: os sistemas núcleo

Todo farming sim, do mais simples ao mais ambicioso, se apoia nos mesmos blocos. Vamos a eles, na ordem em que eu os construiria.

O grid de plantio. A fazenda é um tabuleiro. Cada célula pode estar vazia, arada, plantada ou ocupada por algo permanente. No Godot, esse tabuleiro é o TileMap, e a operação mais importante do sistema inteiro é a conversão entre posição no mundo e célula do grid: local_to_map pra descobrir qual célula o jogador está mirando, map_to_local pra posicionar a planta no centro dela. Se você nunca trabalhou com esse nó, o guia de TileMap no Godot 4 cobre a base que este texto assume.

O ciclo de dia e as estações. O tempo de um farming sim não é contínuo, é discreto. O que importa não é o relógio correndo, é a fronteira entre um dia e outro, porque é nela que o mundo inteiro atualiza: plantas crescem, lojas repõem estoque, o dinheiro da caixa de venda entra na conta. Meu conselho é tratar o dia como a unidade atômica do jogo e deixar a parte visual pra depois. O ciclo de dia e noite no Godot resolve iluminação e transição na tela; a lógica que interessa aqui é o sinal que anuncia o novo dia, e eu mostro ela em código logo abaixo. Estações são um multiplicador em cima disso, e no primeiro jogo uma estação eterna resolve.

Crescimento por estágio. Planta de farming sim não cresce de forma contínua, cresce em degraus: semente, broto, planta jovem, planta madura. Cada estágio é uma textura e um número de dias. Essa decisão simplifica tudo. Salvar o jogo vira guardar dois inteiros por planta, e o crescimento vira uma comparação feita uma vez por dia, não uma simulação rodando a cada frame.

Ferramentas e interação. Enxada ara, regador molha, foice colhe. Por baixo, é um único sistema: a ferramenta selecionada define o que acontece quando o jogador interage com a célula na frente dele. Resista à tentação de criar uma hierarquia elaborada de classes por ferramenta no começo. Um match no identificador da ferramenta, dentro de uma única função de interação, sustenta o jogo por muito tempo.

Inventário e economia. A colheita precisa ir pra algum lugar, e esse lugar precisa ter valor. O inventário pode começar como um dicionário de item pra quantidade, e a economia pode começar como uma caixa de venda: o jogador deposita, dorme, acorda com dinheiro. Preço de semente menor que preço de venda, e essa diferença é o motor de progressão do jogo inteiro. Mais tarde, com a base de pé, um sistema de craft com receitas é a expansão natural: transformar colheita em produto de maior valor é o que dá profundidade à economia.

NPCs e relacionamentos. O sistema mais amado de Stardew Valley e o primeiro que eu corto em qualquer primeiro projeto. NPC com rotina é pathfinding com agenda. Diálogo é ferramenta de escrita com condições de estado. Afinidade é uma economia paralela de presentes. São três jogos dentro do jogo, e nenhum deles participa do loop de plantar e vender. Corte sem culpa. A fazenda funciona sem vizinhos.

O cultivo como Resource: dados longe da lógica

A primeira decisão de arquitetura que eu tomaria: cada tipo de cultivo é um Resource. Não um nó, não uma cena duplicada, não um dicionário solto num autoload. Um Resource com class_name aparece no inspetor da Godot, vira arquivo .tres no projeto, e permite criar a cenoura e o milho sem tocar em código.

class_name CropData
extends Resource

@export var nome: String = ""
@export var dias_por_estagio: int = 2
@export var total_estagios: int = 4
@export var texturas_estagios: Array[Texture2D] = []
@export var preco_semente: int = 10
@export var preco_venda: int = 25

Com esse script salvo, clique com o botão direito no painel FileSystem, crie um novo Resource do tipo CropData e preencha os campos no inspetor: quatro texturas, dois dias por estágio, os preços. Cada cultivo novo do jogo passa a custar minutos, não horas, e balancear a economia vira mexer em arquivos de dados, não em lógica.

O relógio do jogo e a plantação que escuta o dia

O tempo vive num autoload, registrado nas configurações do projeto com o nome Relogio. Ele é curto de propósito: a única responsabilidade dele é saber o dia atual e anunciar quando ele muda.

extends Node

signal dia_mudou(dia: int)

var dia_atual: int = 1

func avancar_dia() -> void:
    dia_atual += 1
    dia_mudou.emit(dia_atual)

O botão de dormir chama Relogio.avancar_dia() e mais nada. Quem precisa reagir ao novo dia se conecta ao sinal. Essa inversão importa: o relógio não conhece as plantas, as lojas nem a caixa de venda. Cada sistema novo se pluga no sinal sem que nenhuma linha existente mude.

A plantação é o outro lado dessa conversa. Cada planta no grid é uma instância deste nó, carregando o CropData do cultivo escolhido:

class_name Plantacao
extends Node2D

@export var dados: CropData

var estagio_atual: int = 0
var dias_no_estagio: int = 0

@onready var sprite: Sprite2D = $Sprite2D

func _ready() -> void:
    Relogio.dia_mudou.connect(_ao_mudar_dia)
    _atualizar_sprite()

func esta_madura() -> bool:
    return estagio_atual >= dados.total_estagios - 1

func _ao_mudar_dia(_dia: int) -> void:
    if esta_madura():
        return
    dias_no_estagio += 1
    if dias_no_estagio >= dados.dias_por_estagio:
        dias_no_estagio = 0
        estagio_atual += 1
        _atualizar_sprite()

func _atualizar_sprite() -> void:
    if estagio_atual < dados.texturas_estagios.size():
        sprite.texture = dados.texturas_estagios[estagio_atual]

Repare no que não existe aqui: nenhum _process, nenhum timer, nenhuma checagem por frame. A planta dorme até o sinal chegar, avança um contador e, quando o contador bate no valor do CropData, sobe de estágio e troca a textura. Cem plantas no grid custam praticamente zero por frame, porque todo o trabalho acontece uma vez por dia. E quando você adicionar rega, a mudança é uma guarda no início de _ao_mudar_dia: sem água, o dia não conta pro crescimento.

A vertical slice: um cultivo, um dia, uma caixa de venda

A ordem de construção que eu recomendo, passo a passo. Primeiro, o personagem andando num TileMap com colisão. Segundo, a interação com célula: mirar, apertar o botão, a célula muda de estado pra arada. Terceiro, plantar: com semente selecionada, interagir numa célula arada instancia uma Plantacao com o CropData da cenoura. Quarto, o dia: um botão de dormir que chama o Relogio e uma transição de tela preta. A planta cresce, e essa é a primeira vez que o jogo parece vivo. Quinto, colher: interagir com planta madura remove o nó e soma o item no inventário. Sexto, vender: uma caixa que aceita itens e vira dinheiro quando o dia muda. Sétimo, comprar semente nova com esse dinheiro.

Quando o passo sete fecha, o loop está completo e se sustenta sozinho: dinheiro vira semente, semente vira colheita, colheita vira dinheiro. Esse é o jogo. Tudo que um farming sim tem além disso é ornamento em volta desse ciclo, e a hora de decidir quais ornamentos entram é depois que o ciclo diverte, não antes. Se plantar uma cenoura e vender ela na caixa não tiver graça nenhuma, nenhuma quantidade de pesca, mina ou casamento vai consertar isso.

O que cortar no primeiro jogo

Minha lista de cortes pra um primeiro farming sim, na ordem em que as pessoas mais resistem a cortar: NPCs e romance, estações, clima, pesca, mineração, animais e festivais. Cada item dessa lista é um jogo inteiro disfarçado de feature. Pesca é um minigame com física e tabela de raridade. Animal é cultivo com movimento, apego e produção diária. Festival é cutscene com calendário. Nada disso cabe num primeiro projeto, e o mais importante: nada disso é necessário pra fazenda ser gostosa de jogar.

Se depois da vertical slice você quiser crescer, cresça na direção do loop: mais cultivos, que agora custam minutos por causa do Resource, rega, upgrades de ferramenta e craft. Cada um desses aprofunda o ciclo que já existe em vez de abrir uma frente nova de trabalho.

Fazenda é o gênero da paciência, no jogo e no desenvolvimento. Se você quer estruturar o aprendizado em vez de ir juntando tutoriais soltos, o melhor curso de Godot é o caminho que eu recomendo pra construir essa base com método. Aqui no CursoGame.Dev a gente insiste que jogo se aprende fazendo: abra a Godot, crie o CropData da sua primeira cenoura e faça um dia passar. A fazenda inteira cresce a partir dessa semente.