Sistema de Clima e Chuva no Godot: Efeito de Chuva e Transição de Tempo

Um jogo 2D ganha muita vida quando o tempo muda. Neste guia você vai montar um sistema de clima simples no Godot 4, com chuva feita de partículas, o ambiente escurecendo quando fecha o tempo, som de chuva em loop e uma transição suave entre sol e chuva. Nada de mágica: são quatro peças conversando entre si, e a keyword aqui é justamente essa combinação de sistema de clima com chuva no Godot que dá clima (com o perdão do trocadilho) sem custar caro.

Antes de sair codando, vale entender a ideia. Um sistema de clima não é um efeito só, é um gerente que decide o estado atual (sol, chuva) e ajusta várias coisas ao mesmo tempo para aquele estado: quanta chuva cai, quão escuro está o ambiente e quão alto está o som. Quando você troca de estado, esse gerente não corta seco, ele interpola. É essa interpolação que separa um efeito de amador de um que parece profissional.

As quatro peças do sistema de clima

Vamos usar só nós reais do Godot 4, nada exótico:

• GPUParticles2D para as gotas de chuva. Ele roda na GPU e aguenta bastante partícula sem travar o jogo.
• CanvasModulate para escurecer a cena inteira de uma vez, aplicando uma cor por cima de tudo.
• AudioStreamPlayer para o som de chuva em loop, subindo e descendo de volume conforme a intensidade.
• Um script gerente (com Timer opcional) que junta os três e faz a transição entre estados.

A montagem é direta. Crie a chuva como uma cena separada e instancie ela no seu mundo, ou coloque tudo dentro de um nó Clima que fica na frente da câmera. O importante é que a chuva acompanhe a câmera, senão o jogador anda e sai da região onde chove.

Montando a chuva com GPUParticles2D

Adicione um GPUParticles2D e, no Process Material, use um ParticleProcessMaterial. Ponha uma textura pequena de gota (um retângulo fino e claro já resolve), gravidade apontando para baixo no eixo Y e uma direção inicial levemente inclinada para dar aquele efeito de chuva batendo de lado. Para cobrir a tela, aumente o emission_shape para uma caixa larga posicionada um pouco acima do topo visível.

O ponto de partida é deixar o emissor desligado e ligar por código quando o clima virar chuva. Aqui já entra código tipado de verdade. Se você nunca mexeu com esse nó, vale primeiro ler sobre usar partículas com GPUParticles no Godot, porque este post assume que você já tem a cena da chuva montada.

extends GPUParticles2D

# Controla a chuva ligando o emissor e ajustando quantas gotas caem.
@export var gotas_max: int = 300

func definir_intensidade(intensidade: float) -> void:
    # intensidade vai de 0.0 (sem chuva) a 1.0 (temporal).
    var quantidade: int = int(gotas_max * clampf(intensidade, 0.0, 1.0))
    amount = maxi(quantidade, 1)
    emitting = intensidade > 0.0

Repare no clampf para não estourar valores e no maxi(quantidade, 1), porque amount do GPUParticles2D não aceita zero. Quando a intensidade for zero, a gente desliga pelo emitting e deixa amount no mínimo, sem crash.

Escurecendo o ambiente com CanvasModulate

O CanvasModulate é o truque mais barato do Godot para mudar o astral de uma cena. Ele multiplica a cor de tudo que está no canvas por uma cor só. Branco puro (Color(1, 1, 1)) não muda nada. Um azul acinzentado escuro deixa a cena com cara de dia nublado sem apagar o jogo.

O segredo da transição é não trocar a cor num frame só. Use um Tween para caminhar da cor atual até a cor de chuva ao longo de um ou dois segundos. O olho do jogador percebe o tempo fechando, e não um flash.

Somando o som de chuva em loop

Coloque um AudioStreamPlayer com um arquivo de chuva marcado para tocar em loop nas propriedades de import do áudio. O detalhe que faz diferença: não ligue o som no volume cheio de uma vez. Comece o player tocando em volume baixíssimo (ou em -80 decibéis, praticamente mudo) e suba o volume junto com a intensidade da chuva. Quando o sol voltar, desça de novo. Tudo com Tween, pela mesma razão do CanvasModulate: cortes secos denunciam o efeito.

O gerente de clima

Agora a peça central. O gerente guarda o estado atual, expõe uma função para pedir mudança de clima e dispara as transições em todas as três peças ao mesmo tempo. Manter isso num script só evita que a chuva, o som e a cor fiquem dessincronizados.

extends Node2D

# Referências aos nós que o clima controla.
@onready var chuva: GPUParticles2D = $Chuva
@onready var modulacao: CanvasModulate = $CanvasModulate
@onready var som_chuva: AudioStreamPlayer = $SomChuva

const COR_SOL: Color = Color(1.0, 1.0, 1.0)
const COR_CHUVA: Color = Color(0.55, 0.6, 0.72)

var intensidade_atual: float = 0.0

func definir_clima(tipo: String, duracao: float = 1.5) -> void:
    var alvo: float = 0.0
    if tipo == "chuva":
        alvo = 1.0

    var cor_alvo: Color = COR_SOL.lerp(COR_CHUVA, alvo)
    var volume_alvo: float = -80.0
    if alvo > 0.0:
        volume_alvo = -6.0

    if not som_chuva.playing:
        som_chuva.play()

    var tween: Tween = create_tween()
    tween.set_parallel(true)
    tween.tween_method(_aplicar_intensidade, intensidade_atual, alvo, duracao)
    tween.tween_property(modulacao, "color", cor_alvo, duracao)
    tween.tween_property(som_chuva, "volume_db", volume_alvo, duracao)

func _aplicar_intensidade(valor: float) -> void:
    intensidade_atual = valor
    chuva.definir_intensidade(valor)

O que está acontecendo aqui, passo a passo:

• definir_clima recebe o tipo ("sol" ou "chuva") e quanto tempo a transição dura.
• Ele calcula o alvo de intensidade, a cor alvo do ambiente e o volume alvo do som.
• Um Tween em modo paralelo (set_parallel(true)) roda as três animações juntas.
• tween_method chama _aplicar_intensidade a cada passo, que repassa o valor para a chuva. Assim a quantidade de gotas cresce e diminui junto com a cor e o som.

Para testar, basta chamar definir_clima("chuva") num sinal de botão ou num Timer. Se você quiser que o tempo mude sozinho de vez em quando, adicione um Timer que dispara a cada tantos segundos e sorteia entre sol e chuva. Comece manual, veja se está bom, depois automatize.

Como isso conversa com o ciclo dia e noite

Aqui mora a única pegadinha real do sistema. Tanto o clima quanto um ciclo de dia e noite querem mexer no CanvasModulate. Se os dois escreverem direto na cor, um vai apagar o outro: você deixa a noite azul escura, aí começa a chover e o clima repinta tudo de cinza claro, estragando a noite.

A saída é ter um ponto só que decide a cor final. Em vez do gerente de clima escrever direto no CanvasModulate, tanto o ciclo de tempo quanto o clima entregam suas cores para uma função central, que combina as duas (por multiplicação ou por um lerp) e só então aplica no nó. Se você ainda vai construir a parte do horário, veja como montar um ciclo de dia e noite e já deixe essa combinação prevista desde o começo, porque encaixar depois dá mais trabalho.

Na prática, guarde duas cores separadas (a do horário e a do clima) e recalcule a cor final sempre que qualquer uma mudar. Isso mantém chuva de dia, chuva de noite e sol de tarde funcionando sem um pisotear o outro.

Desempenho: cuidado no mobile

Partícula é barata na GPU, mas não é de graça. No PC você provavelmente nem sente 500 gotas de chuva. No celular, a conversa muda. Alguns cuidados que valem a pena:

• Menos partículas. Ajuste o gotas_max para bem menos no mobile. Duzentas gotas caindo rápido dão sensação de chuva forte sem precisar de mil.
• Textura simples. Uma gota é um retângulo claro. Não gaste uma textura grande e detalhada em algo que aparece por milissegundos e some.
• Emissor do tamanho da tela, não do mundo. Emita chuva só na área visível pela câmera. Fazer chuva no mundo inteiro é jogar processamento fora.
• Meça no aparelho real. O editor no seu PC mente sobre desempenho de celular. Rode uma build no telefone e olhe os frames.

Um caminho comum é ter uma configuração de qualidade que troca gotas_max conforme a plataforma ou uma opção nas configurações do jogo. Assim quem tem um aparelho fraco não sofre e quem tem um bom aproveita a chuva caprichada.

Fechando o sistema

Recapitulando, o sistema de clima com chuva no Godot que montamos tem quatro partes conversando: o GPUParticles2D que faz as gotas, o CanvasModulate que fecha o tempo, o AudioStreamPlayer que dá o som e o gerente que interpola tudo com Tween na hora de mudar de estado. A partir daqui você pode adicionar mais estados (neblina, tempestade com raios usando um flash no CanvasModulate), acoplar ao ciclo dia e noite e afinar o desempenho por plataforma.

O bom desse tipo de sistema é que ele é modular. Cada peça é um nó comum do Godot, e o gerente é um script curto que você entende de ponta a ponta. Se você está decidindo em qual engine investir seu tempo para fazer jogos 2D com esse nível de controle sem pagar licença, dá para conferir se vale a pena aprender Godot antes de mergulhar. Depois é só chover no seu mapa e ver a cena ganhar vida.