Como Fazer Jogo Stealth: Cone de Visão e Suspeita no Godot 4

Aprenda como fazer jogo stealth no Godot 4: cone de visão com Area2D e RayCast2D, medidor de suspeita, ruído ao correr e esconderijos em GDScript tipado.
Se você quer aprender como fazer jogo stealth, esqueça por enquanto inimigo esperto, iluminação dinâmica e sistema de câmera. Stealth é um jogo de informação: o jogador precisa ler o que cada inimigo vê e ouve, naquele exato momento, pra decidir se atravessa o corredor agora ou espera mais dois segundos. Em vinte e poucos anos fazendo e destrinchando jogos, eu resumo o gênero numa regra só: o estado do inimigo tem que estar sempre visível. Cone desenhado no chão, ícone de alerta na cabeça, som de suspeita. Quando o jogador é pego sem entender o porquê, ele não culpa a si mesmo, culpa o jogo. E fecha o jogo.
Neste tutorial eu monto o núcleo de um stealth 2D no Godot 4: cone de visão que o jogador enxerga na tela, raycast que respeita parede, medidor de suspeita que sobe aos poucos, três estados de inimigo, sistema de ruído pra quem corre e esconderijo pra quem erra. Tudo em GDScript com tipagem estática, em blocos que você pode colar no seu projeto.
Stealth funciona na cabeça do jogador
Antes do código, o princípio de design que sustenta tudo. Num jogo de ação, o desafio está nos dedos. Num jogo stealth, o desafio está no planejamento: observar a rotina do guarda, identificar a janela, executar. Isso só funciona se o jogo entrega informação honesta o tempo todo.
Mark of the Ninja é a aula definitiva disso: cada barulho vira um círculo visível, cada cone de visão está desenhado, cada estado de inimigo tem ícone. O jogador nunca adivinha, ele lê. Metal Gear faz o mesmo com o radar e a exclamação sonora. O que esses jogos entenderam é que esconder informação do jogador não cria tensão, cria frustração. A tensão vem de o jogador saber exatamente o risco que está correndo.
A segunda decisão de design importante: detecção gradual em vez de binária. Se pisar no cone significa game over instantâneo, cada erro pequeno custa a fase inteira e o jogo vira tentativa e erro decorado. Com um medidor de suspeita que sobe enquanto você está exposto, aparece a mecânica mais gostosa do gênero: ser visto de relance, ver o guarda desconfiar e sair andando na direção errada enquanto seu coração acelera.
Guarde essas duas regras: estado do inimigo sempre visível, detecção sempre gradual. Todo o código abaixo existe pra servir a elas.
O cone de visão 2D que todo jogo stealth precisa
A detecção visual tem dois passos, e separar os dois é o que faz o sistema funcionar:
- Candidato: uma
Area2DcomCollisionPolygon2Dem formato de cone detecta que o player entrou no campo de visão em potencial. - Confirmação: um raycast verifica se existe linha de visão direta. Parede no caminho, o inimigo não vê nada.
A estrutura de nodes do inimigo:
Inimigo (CharacterBody2D)
├── CollisionShape2D
├── Sprite2D
├── RayCast2D
└── ConeDeVisao (Area2D)
└── CollisionPolygon2D
O script do cone gera o polígono por código (assim alcance e ângulo viram números ajustáveis no Inspector) e desenha o mesmo polígono na tela com _draw(). Um polígono só, usado pra colisão e pra visual, nunca dessincroniza:
# cone_de_visao.gd
class_name ConeDeVisao
extends Area2D
@export var alcance: float = 220.0
@export var meio_angulo_graus: float = 35.0
var cor_atual: Color = Color(1.0, 1.0, 0.0, 0.25)
@onready var colisor: CollisionPolygon2D = $CollisionPolygon2D
func _ready() -> void:
colisor.polygon = gerar_cone()
func gerar_cone() -> PackedVector2Array:
var pontos: PackedVector2Array = PackedVector2Array([Vector2.ZERO])
for i: int in range(11):
var t: float = float(i) / 10.0
var angulo: float = deg_to_rad(lerpf(-meio_angulo_graus, meio_angulo_graus, t))
pontos.append(Vector2.RIGHT.rotated(angulo) * alcance)
return pontos
func _draw() -> void:
draw_colored_polygon(colisor.polygon, cor_atual)
func mudar_cor(nova: Color) -> void:
cor_atual = nova
queue_redraw()
O gerar_cone() cria um leque: o ponto zero é o olho do inimigo e os onze pontos seguintes desenham o arco. O _draw() pinta esse polígono com draw_colored_polygon(), e o mudar_cor() chama queue_redraw() pra atualizar a tela quando o estado do inimigo mudar. Amarelo transparente na patrulha, laranja quando suspeito, vermelho no alerta. É a primeira regra de design implementada em quinze linhas: o jogador olha pra tela e sabe o que cada inimigo está sentindo.
Como o cone é filho do inimigo, girar o inimigo gira o cone junto, colisão e desenho de uma vez.
Parede existe: confirmando a linha de visão
A Area2D sozinha tem um defeito fatal: ela detecta o player mesmo com uma parede inteira entre os dois. Todo tutorial que para no primeiro passo produz guarda com visão de raio X, e o jogador percebe na hora. A correção é o segundo passo, o raycast. Se você nunca usou, eu explico o node em detalhe no guia de RayCast2D no Godot; aqui vai direto o uso:
# inimigo.gd (parte 1: detecção)
extends CharacterBody2D
@onready var cone: ConeDeVisao = $ConeDeVisao
@onready var raio_visao: RayCast2D = $RayCast2D
var candidato: Player = null
func _on_cone_de_visao_body_entered(body: Node2D) -> void:
if body is Player:
candidato = body as Player
func _on_cone_de_visao_body_exited(body: Node2D) -> void:
if body == candidato:
candidato = null
func ve_o_player() -> bool:
if candidato == null:
return false
if candidato.escondido and estado != Estado.ALERTA:
return false
raio_visao.target_position = to_local(candidato.global_position)
raio_visao.force_raycast_update()
return raio_visao.get_collider() == candidato
Os sinais body_entered e body_exited da Area2D mantêm a referência do candidato. O ve_o_player() aponta o raycast pro player (target_position é local, por isso o to_local()), força a atualização com force_raycast_update() e pergunta o que o raio acertou primeiro. Se foi uma parede, retorna a parede e a função responde false. Configure a máscara de colisão do RayCast2D pra enxergar as camadas de parede e de player, e nada mais.
Duas notas: a checagem de escondido e o estado vêm das seções seguintes, deixa eles aí. E se você precisar de vários raios por frame (vários inimigos mirando pontos diferentes do corpo do player), o caminho é consultar o espaço físico direto com PhysicsDirectSpaceState2D.intersect_ray(), que dispensa o node. Pra um raio por inimigo, o RayCast2D é mais simples e resolve.
Patrulha, suspeito, alerta: os três estados
Detecção binária (viu, perdeu) produz inimigo histérico. O que a gente quer é uma escada de três degraus: patrulha (rotina normal), suspeito (viu algo de relance, vai até lá investigar) e alerta (confirmou, persegue). Quem sobe e desce essa escada é o medidor de suspeita, um float que acumula com delta enquanto o player está visível:
# inimigo.gd (parte 2: estados e suspeita)
enum Estado { PATRULHA, SUSPEITO, ALERTA }
const GANHO_SUSPEITA: float = 0.8
const PERDA_SUSPEITA: float = 0.4
const LIMIAR_SUSPEITO: float = 0.3
var estado: Estado = Estado.PATRULHA
var suspeita: float = 0.0
var ultima_posicao_vista: Vector2 = Vector2.ZERO
func _physics_process(delta: float) -> void:
if ve_o_player():
suspeita = minf(suspeita + GANHO_SUSPEITA * delta, 1.0)
ultima_posicao_vista = candidato.global_position
else:
suspeita = maxf(suspeita - PERDA_SUSPEITA * delta, 0.0)
match estado:
Estado.PATRULHA:
if suspeita >= LIMIAR_SUSPEITO:
mudar_estado(Estado.SUSPEITO)
Estado.SUSPEITO:
if suspeita >= 1.0:
mudar_estado(Estado.ALERTA)
elif suspeita <= 0.0:
mudar_estado(Estado.PATRULHA)
Estado.ALERTA:
if suspeita <= 0.0:
mudar_estado(Estado.SUSPEITO)
func mudar_estado(novo: Estado) -> void:
if novo == estado:
return
estado = novo
match estado:
Estado.PATRULHA:
cone.mudar_cor(Color(1.0, 1.0, 0.0, 0.25))
Estado.SUSPEITO:
cone.mudar_cor(Color(1.0, 0.6, 0.0, 0.35))
Estado.ALERTA:
cone.mudar_cor(Color(1.0, 0.2, 0.2, 0.4))
Repare nos números: a suspeita sobe duas vezes mais rápido do que desce. Com ganho de 0.8 por segundo, o player tem pouco mais de um segundo de exposição total antes do alerta, e sair do cone não zera nada na hora. Errou, a dívida fica. Esses três valores (GANHO_SUSPEITA, PERDA_SUSPEITA, LIMIAR_SUSPEITO) são o coração do balanceamento do seu stealth inteiro; exponha os três com @export e ajuste testando.
O mudar_estado() é o funil único de transição, e é ali que o feedback acontece: cor do cone, e depois som e ícone. Esse padrão de enum com match eu destrincho no artigo sobre state machine no Godot. E o comportamento dentro de cada estado (andar entre waypoints na patrulha, ir até ultima_posicao_vista quando suspeito, correr atrás do player no alerta) é exatamente o que eu construo passo a passo no tutorial de IA de inimigo que persegue e patrulha; os dois sistemas se encaixam sem adaptação.
Ruído: correr tem preço
Visão sozinha deixa o stealth raso, porque só existe um recurso pra administrar (a posição). Audição cria a segunda camada: agora atravessar uma sala rápido tem custo. A implementação mais simples que funciona é um evento de som com posição e raio:
# player.gd
class_name Player
extends CharacterBody2D
signal fez_barulho(posicao: Vector2, raio: float)
var escondido: bool = false
const VEL_ANDAR: float = 120.0
const VEL_CORRER: float = 220.0
const RAIO_BARULHO: float = 260.0
func _physics_process(_delta: float) -> void:
var direcao: Vector2 = Input.get_vector("esquerda", "direita", "cima", "baixo")
var correndo: bool = Input.is_action_pressed("correr")
velocity = direcao * (VEL_CORRER if correndo else VEL_ANDAR)
move_and_slide()
if correndo and direcao != Vector2.ZERO:
fez_barulho.emit(global_position, RAIO_BARULHO)
# inimigo.gd (parte 3: audição)
var ultima_posicao_ouvida: Vector2 = Vector2.ZERO
func _on_player_fez_barulho(posicao: Vector2, raio: float) -> void:
if global_position.distance_to(posicao) > raio:
return
ultima_posicao_ouvida = posicao
suspeita = maxf(suspeita, LIMIAR_SUSPEITO)
if estado == Estado.PATRULHA:
mudar_estado(Estado.SUSPEITO)
O player emite o sinal fez_barulho enquanto corre, e cada inimigo conectado compara a distância. Dentro do raio, ele guarda a posição ouvida, ganha suspeita suficiente pra cruzar o limiar e vai investigar o ponto. Detalhe importante: ele investiga onde o som nasceu, não onde o player está agora. Isso abre a jogada clássica do gênero, correr de propósito num canto pra atrair o guarda e passar pelo outro lado.
Em produção, ligue a emissão ao frame do passo na animação em vez de emitir todo tick de física, e desenhe um círculo que pulsa no chão quando o barulho acontece. De novo a primeira regra: se o jogo tem um sistema de som, o jogador precisa ver o som.
Esconderijo: a válvula de escape
Stealth sem esconderijo é corredor da morte. O armário do Outlast e a moita do Assassins Creed cumprem a mesma função de design: dar ao jogador um botão de reset da tensão. A implementação é uma Area2D cobrindo a zona segura:
# esconderijo.gd
extends Area2D
func _on_body_entered(body: Node2D) -> void:
if body is Player:
(body as Player).escondido = true
func _on_body_exited(body: Node2D) -> void:
if body is Player:
(body as Player).escondido = false
A flag escondido já está sendo checada lá no ve_o_player(), com uma exceção deliberada: estado != Estado.ALERTA. Traduzindo a regra: o esconderijo torna o player invisível pro guarda que não o viu entrar, mas o guarda que estava perseguindo e viu você pular na moita não esquece magicamente. Sem essa exceção, o esconderijo vira botão de vitória e mata a tensão do jogo; com ela, esconder-se é uma aposta que você precisa fazer antes de ser visto.
Distração: dar ao jogador uma ferramenta de manipulação
Até aqui o jogador só reage ao inimigo: espera a patrulha passar, corre quando o cone vira pro outro lado. O que eleva o stealth de bom pra viciante é dar uma ferramenta pra ele manipular o inimigo de propósito. A garrafa do Thief, a pedra do Dishonored, o apito do Last of Us: todos fazem a mesma coisa, criar um barulho controlado num lugar escolhido pra puxar o guarda pra longe do caminho.
O bonito é que a gente já construiu toda a mecânica de som na seção de ruído. Distração não é sistema novo, é reusar o sinal fez_barulho emitido por outro objeto que não o player. Um objeto arremessável que, ao bater no chão, emite o mesmo evento:
# pedra.gd
class_name Pedra
extends RigidBody2D
signal fez_barulho(posicao: Vector2, raio: float)
const RAIO_IMPACTO: float = 180.0
var ja_bateu: bool = false
func _on_body_entered(_body: Node) -> void:
if ja_bateu:
return
ja_bateu = true
fez_barulho.emit(global_position, RAIO_IMPACTO)
# some depois de avisar, pra nao poluir a fase
await get_tree().create_timer(0.2).timeout
queue_free()
Repare no ja_bateu: sem ele, uma pedra quicando emite barulho a cada toque e vira um alarme ambulante. A flag garante um único evento por arremesso, que é o comportamento que o jogador consegue prever. Do lado do inimigo, nada muda: ele já sabe reagir a fez_barulho. Basta conectar o sinal da pedra ao mesmo _on_player_fez_barulho que você escreveu antes, ou melhor, renomear o handler pra algo neutro como _ao_ouvir_barulho, já que a fonte agora pode ser o player ou um objeto.
No player, lançar é só instanciar a cena e dar um impulso na direção mirada:
@export var cena_pedra: PackedScene
func lancar_pedra(direcao: Vector2) -> void:
var pedra: Pedra = cena_pedra.instantiate() as Pedra
get_parent().add_child(pedra)
pedra.global_position = global_position
pedra.linear_velocity = direcao.normalized() * 420.0
for inimigo: Node in get_tree().get_nodes_in_group("inimigos"):
if inimigo.has_method("_ao_ouvir_barulho"):
pedra.fez_barulho.connect(inimigo._ao_ouvir_barulho)
Conectar todos os inimigos do grupo inimigos ao sinal da pedra na hora do arremesso mantém o acoplamento baixo: a pedra não sabe quem existe na fase, só grita, e quem estiver no grupo escuta. Esse costume de conversar por sinal e grupo em vez de referência direta é o que deixa o sistema de IA escalável conforme você adiciona tipos de inimigo, e é um dos pilares do tutorial de IA de inimigo que persegue e patrulha.
Uma decisão de design pra fechar: limite o recurso. Pedra infinita quebra o jogo, porque o jogador resolve tudo distraindo. Dê três pedras por fase, ou pedras espalhadas pra ele coletar, e de repente cada arremesso é uma escolha com peso. Escassez é o que transforma uma ferramenta em decisão.
Luz, sombra e distância: o mesmo cone, ganho diferente
Com o sistema montado até aqui, o player dentro do cone é detectado sempre na mesma velocidade, esteja ele colado no guarda ou lá na ponta do alcance, no claro ou no escuro. Isso deixa o stealth previsível demais. A variação mais barata e mais eficiente é mexer no ganho de suspeita, não no cone: quanto mais perto e mais iluminado, mais rápido o medidor enche.
No player, uma variável de visibilidade:
# player.gd (acréscimo)
var visibilidade: float = 1.0
Uma zona escura é só mais uma Area2D cobrindo o pedaço da fase sem luz:
# zona_escura.gd
extends Area2D
@export var visibilidade_na_sombra: float = 0.35
func _on_body_entered(body: Node2D) -> void:
if body is Player:
(body as Player).visibilidade = visibilidade_na_sombra
func _on_body_exited(body: Node2D) -> void:
if body is Player:
(body as Player).visibilidade = 1.0
E no inimigo, o ganho passa a ser calculado em vez de constante:
# inimigo.gd (parte 4: ganho variável)
func ganho_de_suspeita() -> float:
var distancia: float = global_position.distance_to(candidato.global_position)
var fator_distancia: float = clampf(1.0 - distancia / cone.alcance, 0.25, 1.0)
return GANHO_SUSPEITA * fator_distancia * candidato.visibilidade
No _physics_process, troque GANHO_SUSPEITA * delta por ganho_de_suspeita() * delta. O clampf com mínimo de 0.25 garante que a ponta do cone ainda detecta, só que devagar. Com esses números, o player na sombra e longe enche o medidor em mais de dez segundos, enquanto colado no guarda e no claro leva pouco mais de um. Agora a fase tem rotas: o caminho iluminado é curto e arriscado, o escuro é longo e seguro. Escolher entre os dois é exatamente o tipo de decisão que faz o gênero funcionar. E pela regra número um, sinalize a sombra na arte: escureça o chão de verdade, para o jogador saber onde está protegido.
Mostrando a suspeita na cabeça do guarda
A cor do cone mostra o estado, mas não mostra quanto falta para o alerta. Um arco que enche sobre a cabeça do inimigo resolve isso com poucas linhas. Crie um Node2D filho do inimigo, posicionado acima do sprite:
# indicador_suspeita.gd
extends Node2D
var valor: float = 0.0
func atualizar(novo: float) -> void:
if is_equal_approx(novo, valor):
return
valor = novo
queue_redraw()
func _draw() -> void:
if valor <= 0.0:
return
var inicio: float = -PI / 2.0
var fim: float = inicio + TAU * valor
draw_arc(Vector2.ZERO, 10.0, inicio, fim, 24, Color(1.0, 0.6, 0.0), 3.0)
No fim do _physics_process do inimigo, chame indicador.atualizar(suspeita). O is_equal_approx evita redesenhar a cada frame quando nada mudou. Um detalhe: como o indicador é filho do inimigo, ele gira junto quando o guarda vira. Se isso incomodar, ative top_level no indicador e atualize a posição dele manualmente, ou zere a rotação com global_rotation = 0.0 antes de desenhar.
Montando a primeira fase stealth, passo a passo
Código pronto não é jogo. A primeira fase é onde o sistema vira experiência, e um roteiro curto evita a fase que é só um corredor com três guardas:
- Uma sala, um guarda, uma rota. Comece com uma patrulha de vai e volta e uma saída do outro lado. O objetivo é o jogador aprender a ler o cone sem pressão.
- Adicione a sombra. Na segunda sala, coloque uma faixa escura que permite passar perto do guarda. O jogador descobre que a visibilidade muda o jogo.
- Adicione o ruído. Na terceira, um piso onde correr é tentador (a distância é longa) e um guarda perto o suficiente para ouvir. Ele aprende que pressa custa.
- Dê a ferramenta. Só depois de ensinar as regras, entregue a pedra de distração, com uma situação em que ela é a solução óbvia.
- Combine. A última sala mistura dois guardas, sombra e uma pedra. Aqui o jogador aplica o que aprendeu, e é aqui que ele se sente esperto.
Cada passo ensina uma regra por vez, do mesmo jeito que um bom tutorial integrado à fase faz em qualquer gênero. Teste cada sala isolada antes de juntar.
Erros comuns ao programar stealth
- Suspeita somada sem
delta. O medidor enche em velocidades diferentes conforme o FPS, e o jogo fica mais difícil em máquina rápida. Sempre multiplique pelodeltado frame. - Raycast batendo em área. Se o
RayCast2Dtemcollide_with_areasligado, ele acerta o próprio cone ou uma zona escura antes de chegar no player e o guarda fica cego. Deixe só corpos e as camadas de parede e player na máscara. - Ruído acumulando. Emitir
fez_barulhotodo tick de física enquanto corre empilha dezenas de eventos por segundo. Funciona, mas desperdiça processamento e dificulta adicionar feedback sonoro. Prefira emitir em intervalos ou no frame do passo. - Guarda que esquece rápido demais.
PERDA_SUSPEITAalta faz o inimigo voltar à patrulha segundos depois de quase te pegar, e a tensão some. Deixe a suspeita cair devagar e mantenha o guarda investigandoultima_posicao_vistapor um tempo. - Informação escondida. Cone sem desenho, barulho sem círculo, sombra sem diferença visual. Toda regra invisível vira frustração.
Feche o loop e teste a leitura
Recapitulando o sistema completo: o cone detecta o candidato, o raycast confirma respeitando parede, a suspeita acumula com o tempo de exposição, a escada de estados reage (e muda a cor do cone na tela), correr emite som que puxa inimigo pra investigar, e o esconderijo perdoa quem entrou sem ser visto.
O teste de qualidade não é técnico, é de leitura. Chame alguém que nunca viu o projeto, deixe jogar dois minutos e pergunte: você sabia por que foi pego? Se a resposta for sim ("eu corri perto dele", "encostei no cone vermelho"), seu stealth funciona, e agora é produção de conteúdo: fases, rotinas de patrulha variadas, talvez um medidor de suspeita visível sobre a cabeça do guarda. Se a resposta for não, o problema quase sempre é feedback faltando, não código errado. Volte na regra número um: o estado do inimigo tem que estar sempre visível.
Stealth é um dos gêneros mais generosos pra dev solo: arte simples funciona, não precisa de combate elaborado, e cada fase nova reusa os mesmos três scripts. O que você constrói uma vez, o jogo inteiro aproveita. E se quiser levar esses inimigos além do stealth, com pathfinding por navmesh, behavior tree e utility AI, o guia de IA para jogos no Godot cobre o resto do repertório.
Perguntas frequentes
Como fazer cone de visão no Godot?
Use uma Area2D com um CollisionPolygon2D em formato de cone pra detectar candidatos e um RayCast2D pra confirmar que nenhuma parede bloqueia a linha de visão. Desenhe o mesmo polígono com draw_colored_polygon() dentro do _draw() pra que o jogador enxergue o campo de visão do inimigo em tempo real.
Preciso de RayCast2D se a Area2D já detecta o player?
Precisa. A Area2D só informa que o player está dentro do formato do cone, mas não sabe se existe uma parede no caminho. O raycast confirma a linha de visão direta; sem ele, o inimigo enxerga através de obstáculos e o jogador se sente trapaceado.
Como fazer o inimigo ouvir o jogador?
Quando o player corre, emita um sinal com a posição e um raio de alcance do barulho. Cada inimigo compara a própria distância até essa posição: se estiver dentro do raio, guarda a última posição ouvida e entra no estado suspeito pra investigar o local.
Como funciona a detecção em jogos stealth?
Os bons jogos stealth usam detecção gradual em vez de binária: um medidor de suspeita sobe enquanto o jogador está no campo de visão e desce quando ele sai. Isso cria a janela de quase fui visto que define o gênero e dá ao jogador tempo de reagir ao próprio erro.
Stealth é um bom gênero pra iniciante?
Sim, desde que o escopo fique pequeno: um cone de visão, três estados de inimigo e meia dúzia de fases já formam um jogo completo. O gênero perdoa arte simples e dispensa combate elaborado, porque a tensão vem da informação, não da ação.
Como fazer luz e sombra afetarem a detecção no stealth?
Dê ao player uma variável de visibilidade entre 0 e 1 e use Area2D de zona escura para reduzi-la quando ele entra na sombra. No inimigo, multiplique o ganho de suspeita por essa visibilidade e por um fator de distância. O cone continua o mesmo, só a velocidade de detecção muda.


