Voltar para o Blog
Quest Log

Como Fazer um Jogo Tipo The Sims (Simulador de Vida)

Personagem em uma casa vista de cima, com barras de necessidades (fome, sono, social, higiene) na tela e móveis que o personagem pode usar

Como fazer um jogo tipo The Sims no Godot 4: necessidades que decaem, IA que escolhe ações, interação com objetos e navegação com NavigationAgent.

Ferramenta:Godot

Quando alguém me pergunta como fazer um jogo tipo The Sims, a primeira coisa que eu explico é que o gênero parece sobre casas e móveis, mas no fundo é sobre números que descem. Um simulador de vida, o chamado life sim, é uma máquina de necessidades: o personagem tem fome, sono, vontade de socializar e higiene, e esses valores caem com o passar do tempo. O jogo inteiro gira em torno de suprir essas necessidades antes que elas cheguem ao fundo. A casa, os objetos e a animação bonita são a embalagem. O motor é a tabela de stats decaindo.

Neste tutorial eu desmonto esse motor nos sistemas que o sustentam e mostro código real em GDScript tipado no Godot 4: necessidades que decaem com o tempo, um personagem controlado por IA que decide sozinho o que fazer, objetos de cenário que satisfazem cada necessidade, navegação até esses objetos com NavigationAgent e um relógio de jogo que faz o mundo andar. A meta não é clonar The Sims inteiro, o que é um projeto de anos e de um time grande. É te dar o núcleo funcional de um life sim, a fatia que você consegue terminar e que já é gostosa de observar.

Como fazer um jogo tipo The Sims: comece pelas necessidades

Tudo começa aqui. Cada necessidade é um valor entre 0 e 100 que decai a um ritmo próprio. Fome cai mais rápido que higiene, sono cai devagar durante o dia. A escolha de arquitetura que eu recomendo é guardar essas necessidades num nó dedicado, separado do personagem, pra que a lógica de decaimento viva em um lugar só.

class_name Necessidades
extends Node

signal necessidade_critica(tipo: String)

var valores: Dictionary = {
    "fome": 80.0,
    "sono": 80.0,
    "social": 80.0,
    "higiene": 80.0,
}

var taxas: Dictionary = {
    "fome": 2.0,
    "sono": 1.0,
    "social": 1.5,
    "higiene": 0.8,
}

func decair(delta: float) -> void:
    for tipo in valores:
        var taxa: float = taxas[tipo]
        valores[tipo] = clampf(valores[tipo] - taxa * delta, 0.0, 100.0)
        if valores[tipo] <= 20.0:
            necessidade_critica.emit(tipo)

func suprir(tipo: String, quantidade: float) -> void:
    if valores.has(tipo):
        valores[tipo] = clampf(valores[tipo] + quantidade, 0.0, 100.0)

func mais_urgente() -> String:
    var menor_tipo: String = ""
    var menor_valor: float = 101.0
    for tipo in valores:
        if valores[tipo] < menor_valor:
            menor_valor = valores[tipo]
            menor_tipo = tipo
    return menor_tipo

Repare em três decisões. A primeira: o decaimento usa delta, então ele é independente da taxa de frames. A segunda: mais_urgente devolve a necessidade mais baixa, e é ela que a IA vai perseguir. A terceira: o sinal necessidade_critica deixa a interface, o som ou qualquer outro sistema reagir quando uma barra fica perigosa, sem que este nó precise conhecer nenhum deles. Esse Necessidades é um filho do personagem, e é a única fonte de verdade sobre o estado interno dele.

Objetos do cenário: cada móvel supre uma necessidade

No life sim, o mundo não é decoração passiva. A cama repõe sono, a geladeira repõe fome, o chuveiro repõe higiene, o telefone ou outro personagem repõe social. A forma limpa de modelar isso no Godot é fazer cada objeto interativo declarar qual necessidade ele atende e com que intensidade. Um Area2D com um script enxuto resolve.

class_name ObjetoInterativo
extends Area2D

@export var necessidade_alvo: String = "fome"
@export var ganho_por_segundo: float = 15.0
@export var ponto_de_uso: Marker2D

var em_uso: bool = false

func posicao_de_uso() -> Vector2:
    if ponto_de_uso:
        return ponto_de_uso.global_position
    return global_position

func usar(necessidades: Necessidades, delta: float) -> void:
    em_uso = true
    necessidades.suprir(necessidade_alvo, ganho_por_segundo * delta)

func liberar() -> void:
    em_uso = false

A geladeira é uma instância desse objeto com necessidade_alvo igual a "fome". A cama é outra, com "sono". Criar um objeto novo não exige código novo, só um nó configurado no inspetor, exatamente como acontece num jogo de fazenda, onde cada cultivo é um dado e não uma classe. O ponto_de_uso é um detalhe que importa: o personagem não para em cima da geladeira, ele para na frente dela. Esse Marker2D marca onde o personagem deve ficar pra usar o objeto, e é pra lá que a navegação vai mirar.

Pra IA encontrar os objetos, eu os mantenho num grupo. No _ready de cada ObjetoInterativo, uma linha basta: add_to_group("objetos_interativos"). Assim o personagem pergunta ao mundo quais objetos existem sem guardar referências fixas.

Curso de Godot
Quer fazer seu primeiro jogo na Godot?

No curso de Godot da CursoGame.Dev você vai do zero ao primeiro jogo, com um desafio prático em cada level e suporte individual no WhatsApp quando travar.

Conhecer o curso de Godot
Suporte no WhatsAppAcesso vitalícioGarantia de 7 dias

A IA que escolhe: utilidade simples, não magia

Esta é a parte que assusta quem está começando, e é mais simples do que parece. O personagem não precisa de uma árvore de comportamento gigante nem de machine learning. Ele precisa de um ciclo de decisão: descobrir a necessidade mais urgente, encontrar o objeto que a supre e ir até ele. The Sims faz uma versão sofisticada disso, pontuando cada objeto por quanto ele melhora o humor geral, mas a espinha é a mesma.

func escolher_objeto() -> ObjetoInterativo:
    var tipo: String = necessidades.mais_urgente()
    var candidatos: Array = get_tree().get_nodes_in_group("objetos_interativos")
    var melhor: ObjetoInterativo = null
    var menor_distancia: float = INF
    for obj in candidatos:
        var objeto: ObjetoInterativo = obj as ObjetoInterativo
        if objeto == null or objeto.em_uso:
            continue
        if objeto.necessidade_alvo != tipo:
            continue
        var d: float = global_position.distance_to(objeto.global_position)
        if d < menor_distancia:
            menor_distancia = d
            melhor = objeto
    return melhor

A lógica é direta: pegue a necessidade mais baixa, filtre os objetos que atendem a ela e que não estão ocupados, e escolha o mais perto. Num jogo maior, você trocaria "o mais perto" por uma pontuação que combina distância, ganho e urgência, e pode até deixar uma necessidade empurrar a decisão com mais peso quando ela fica crítica. Mas comece pelo mais perto. É legível, é previsível e já produz um personagem que parece ter vontade própria quando você o vê largar a geladeira e caminhar até a cama porque o sono passou a ser o problema mais grave.

Escolhido o objeto, o personagem precisa andar até ele, desviando de paredes e móveis. Aqui eu insisto para você não escrever o algoritmo de busca de caminho na mão. O Godot já traz pathfinding pronto. Você cria uma NavigationRegion2D, desenha o polígono da área onde dá pra andar (o chão da casa, menos as paredes), e adiciona um NavigationAgent2D como filho do personagem. O agente calcula a rota; você só pede o próximo ponto e se move na direção dele.

class_name Personagem
extends CharacterBody2D

@export var velocidade: float = 90.0

@onready var necessidades: Necessidades = $Necessidades
@onready var agente: NavigationAgent2D = $NavigationAgent2D

var alvo_atual: ObjetoInterativo = null

func ir_ate(objeto: ObjetoInterativo) -> void:
    alvo_atual = objeto
    agente.target_position = objeto.posicao_de_uso()

func _physics_process(_delta: float) -> void:
    if alvo_atual == null:
        return
    if agente.is_navigation_finished():
        velocity = Vector2.ZERO
        return
    var proximo: Vector2 = agente.get_next_path_position()
    var direcao: Vector2 = global_position.direction_to(proximo)
    velocity = direcao * velocidade
    move_and_slide()

O fluxo é o seguinte. ir_ate define o destino do agente como o ponto de uso do objeto, não o centro dele. A cada passo da física, o personagem pergunta ao agente qual é o próximo ponto do caminho (get_next_path_position), aponta a velocidade pra lá e desliza. Quando is_navigation_finished vira verdadeiro, ele chegou, para, e aí começa a usar o objeto. Vale notar que NavigationAgent3D tem a mesma API: se você for pra três dimensões depois, target_position passa a ser um Vector3 e o resto do raciocínio não muda. Essa simetria entre 2D e 3D é um dos pontos onde o Godot facilita a vida, e é parte do que eu discuto na comparação completa entre Godot e Unity.

O relógio do jogo: o tempo que faz tudo andar

Um life sim precisa de tempo, e o tempo tem duas camadas. Existe o tempo contínuo, que faz as necessidades decaírem a cada segundo, e existe o tempo de jogo, as horas e os dias que dão ritmo à vida do personagem (acordar, trabalhar, dormir). O decaimento já está resolvido pelo delta. Falta o relógio que converte segundos reais em horas de jogo, normalmente numa escala acelerada, onde um minuto real vale uma hora na ficção.

extends Node

signal hora_mudou(hora: int)

@export var minutos_por_hora: float = 1.0

var hora: int = 8
var _acumulado: float = 0.0

func _process(delta: float) -> void:
    _acumulado += delta
    var segundos_por_hora: float = minutos_por_hora * 60.0
    if _acumulado >= segundos_por_hora:
        _acumulado -= segundos_por_hora
        hora = (hora + 1) % 24
        hora_mudou.emit(hora)

Esse relógio vive num autoload, registrado nas configurações do projeto. Ele não conhece o personagem nem os objetos: só conta horas e anuncia a virada pelo sinal hora_mudou. Quem quiser reagir, se conecta. Isso é o que te permite, mais tarde, fazer o personagem ter uma rotina: às 22 horas o sono passa a cair mais rápido, às 7 a fome dispara. Cada regra dessas é uma conexão ao sinal, sem tocar na lógica do relógio. E aqui mora a diferença entre um life sim e um dating sim: o primeiro é movido por essa simulação de tempo e necessidades correndo em paralelo, enquanto o segundo gira em torno de diálogo e escolhas pontuais. São primos, mas o coração de cada um é outro.

Juntando tudo: o laço de vida

Com as cinco peças no lugar, o comportamento emerge do encaixe delas. No _process do personagem, o decaimento roda sempre. Quando o personagem está sem alvo, ele escolhe um novo objeto. Quando chega ao objeto, usa até a necessidade subir o bastante, libera e volta a decidir.

func _process(delta: float) -> void:
    necessidades.decair(delta)
    if alvo_atual == null:
        var escolhido: ObjetoInterativo = escolher_objeto()
        if escolhido:
            ir_ate(escolhido)
    elif agente.is_navigation_finished():
        alvo_atual.usar(necessidades, delta)
        if necessidades.valores[alvo_atual.necessidade_alvo] >= 85.0:
            alvo_atual.liberar()
            alvo_atual = null

Esse é o jogo inteiro em miniatura. O personagem acorda com fome, encontra a geladeira, caminha até ela, come até saciar, e nesse meio tempo o sono já caiu, então ele parte pra cama. Você não programou "ele come e depois dorme" em lugar nenhum. Esse encadeamento nasce da interação entre necessidades que decaem e uma IA que persegue a mais urgente. Essa é a sensação que define o gênero: um personagem que parece viver sozinho.

O que cortar e por onde crescer

Sendo honesto sobre o escopo: o que está neste tutorial é o núcleo, não o jogo pronto. The Sims completo tem construção de casa móvel por móvel, múltiplos personagens com relacionamentos e memória, carreiras, aspirações, idades que avançam e centenas de objetos únicos. Cada um desses é um sistema inteiro, e empilhá-los todos de uma vez é a forma mais confiável de nunca terminar. No primeiro projeto, corte sem culpa: um personagem só, uma casa fixa, sem construção, sem relacionamento, sem carreira.

O caminho de crescimento, quando o núcleo estiver de pé e divertido de observar, segue a direção da simulação. Adicione mais necessidades (diversão, bexiga, conforto) e o personagem fica mais rico sem código novo de estrutura, só mais linhas no dicionário. Melhore a IA trocando "o mais perto" por uma pontuação que pesa urgência e ganho. Dê horários às necessidades usando o relógio. Cada uma dessas camadas aprofunda o que já existe em vez de abrir uma frente nova.

Aqui no CursoGame.Dev a insistência é sempre a mesma: jogo se aprende fazendo, e um fazendo pequeno que funciona vale mais que um grande que trava no meio. Abra o Godot, crie o nó Necessidades, bote uma geladeira e uma cama na cena e deixe um personagem se virar sozinho entre as duas. Quando você se pegar olhando pra tela torcendo pra ele comer antes de passar fome, você entendeu o gênero. O resto é expansão em cima dessa semente.

Perguntas frequentes

Dá pra fazer um jogo tipo The Sims sozinho?

Dá, desde que você corte o escopo com honestidade. The Sims completo tem construção de casa, árvore genealógica, carreiras, aspirações e uma quantidade enorme de objetos, e foi feito por um time grande ao longo de anos. Um protótipo com um personagem, quatro necessidades que decaem e meia dúzia de objetos que as suprem é perfeitamente viável pra um dev solo em algumas semanas. Comece por esse núcleo e só cresça depois que ele estiver divertido de observar.

The Sims é 2D ou 3D? Qual eu uso no Godot?

The Sims original era isométrico com personagens 3D, mas o gênero funciona em qualquer uma das duas dimensões. Pra um primeiro projeto, 2D top-down é mais rápido de montar: menos arte, menos câmera, menos navegação pra depurar. A lógica de necessidades, IA e interação é idêntica nos dois casos. O Godot oferece NavigationAgent2D e NavigationAgent3D com a mesma API, então você escolhe a dimensão pelo custo de produção, não pela mecânica.

Como o personagem decide sozinho o que fazer?

Com uma IA simples de pontuação. A cada decisão, o personagem olha as necessidades mais baixas, procura um objeto que supra aquela necessidade e caminha até ele. Não precisa de rede neural nem de árvore de comportamento complexa: um laço que escolhe a necessidade mais urgente e o objeto mais adequado já produz um personagem que parece ter vontade própria. The Sims usa uma versão mais elaborada dessa mesma ideia, baseada em utilidade.

Preciso de pathfinding pra fazer um simulador de vida?

Precisa, porque o personagem anda até os objetos e a casa tem paredes e móveis no caminho. O Godot resolve isso com NavigationRegion e NavigationAgent de forma nativa, sem você escrever o algoritmo de A estrela na mão. Você desenha a área navegável, adiciona um NavigationAgent ao personagem e pede pra ele ir até a posição do objeto. O motor calcula a rota e devolve o próximo ponto do caminho.

Quanto tempo leva pra fazer um jogo tipo The Sims?

O protótipo do núcleo, com necessidades, IA e interação com objetos, sai em algumas semanas de trabalho consistente. O jogo completo é outra conversa: construção de casa, múltiplos personagens com relacionamentos, carreiras e centenas de objetos somam anos. O caminho sensato é fechar a fatia pequena primeiro, ver se observar um personagem se virar sozinho já prende a atenção, e só então decidir quais camadas valem o investimento.