Como Fazer um Jogo de Horror Tipo Forsaken no Roblox

O horror é um dos gêneros que mais crescem no Roblox, e o Forsaken ajudou a firmar a fórmula do caçador contra sobreviventes: um mapa escuro, um monstro perseguindo, uma lanterna que ilumina pouco e a sensação constante de que alguém está logo atrás de você. A boa notícia é que o medo, no fundo, é feito de poucos ingredientes técnicos. Aprender como fazer um jogo de horror tipo Forsaken no Roblox é menos sobre código difícil e mais sobre atmosfera, timing e um susto bem colocado. Neste guia você vai montar o esqueleto de um horror no Roblox Studio: escuridão com névoa, uma lanterna que o jogador liga e desliga, um monstro que caça o sobrevivente mais próximo e o toque que elimina, tudo em Luau curto.

O que deixa o Forsaken assustador

Antes de abrir o editor, vale entender o que você está copiando. O susto num jogo assim não vem de gráfico caro, vem de três coisas. A primeira é a falta de informação: você não enxerga o mapa inteiro, só o cone da lanterna, então o perigo mora no escuro ao redor. A segunda é a ameaça com vontade própria: o monstro não fica parado, ele vai atrás de você, e isso cria pressão a cada segundo. A terceira é a consequência: encostar no monstro acaba com sua rodada, então cada passo errado custa caro.

Repare que nenhum desses três pilares exige arte de ponta. Exige controle de luz, um comportamento de perseguição e um evento de toque. É exatamente o que a gente vai escrever. Se o Studio ainda é novo para você e nomes como Explorer, Part e Script não dizem muito, pare um momento neste guia de como criar jogo no Roblox Studio e volte aqui com a interface na cabeça.

O medo é quase todo atmosfera

Comece pela luz, porque é o que mais rende com menos esforço. O Roblox tem um serviço chamado Lighting que controla a iluminação global do jogo. Insira um Script em ServerScriptService e escureça o mundo:

local Lighting = game:GetService("Lighting")

Lighting.ClockTime = 0
Lighting.Brightness = 1
Lighting.Ambient = Color3.fromRGB(15, 15, 20)
Lighting.OutdoorAmbient = Color3.fromRGB(15, 15, 20)
Lighting.FogColor = Color3.fromRGB(8, 8, 12)
Lighting.FogEnd = 70

local atmosfera = Instance.new("Atmosphere")
atmosfera.Density = 0.45
atmosfera.Parent = Lighting

O ClockTime = 0 coloca o jogo à meia-noite. Ambient e OutdoorAmbient controlam a luz de preenchimento, e deixá-los quase pretos faz as sombras engolirem os cantos. FogEnd = 70 faz tudo além de 70 studs sumir na névoa, então o jogador nunca vê o mapa inteiro. O objeto Atmosphere dá aquela espessura leitosa ao ar. Aperte Play e você já vai sentir a diferença: o mesmo cenário que parecia inofensivo de dia vira ameaçador.

Depois da luz, pense em som. Um ambiente com um grave baixo e constante, passos ecoando e silêncios bruscos faz metade do trabalho de assustar. Som é fora do escopo de código aqui, mas é a primeira coisa a adicionar quando o esqueleto estiver de pé. Um truque barato e eficaz: deixe um som de ambiente em volume baixo o tempo todo e um segundo som, mais agudo e repentino, que você dispara quando o monstro chega perto do jogador. O cérebro humano reage ao contraste, então é o silêncio antes do barulho que assusta, não o barulho sozinho.

A lanterna do sobrevivente

Se está tudo escuro, o jogador precisa de uma luz própria, limitada de propósito. A lanterna é uma luz presa na cabeça do personagem, e ligá-la ou desligá-la é uma ação de cada jogador, então o script é um LocalScript. Coloque-o em StarterPlayer dentro de StarterCharacterScripts, assim ele roda toda vez que um personagem nasce:

local UserInputService = game:GetService("UserInputService")
local personagem = script.Parent
local cabeca = personagem:WaitForChild("Head")

local lanterna = Instance.new("SpotLight")
lanterna.Range = 32
lanterna.Angle = 50
lanterna.Brightness = 3
lanterna.Enabled = true
lanterna.Parent = cabeca

UserInputService.InputBegan:Connect(function(input, processado)
    if processado then
        return
    end
    if input.KeyCode == Enum.KeyCode.F then
        lanterna.Enabled = not lanterna.Enabled
    end
end)

O SpotLight projeta um cone de luz na direção para onde a Part aponta, e preso na cabeça ele acompanha o olhar do jogador. O Range limita o alcance, e o Angle define a abertura do cone. No InputBegan, a checagem if processado then return end evita disparar quando o jogador está digitando no chat, e a tecla F alterna Enabled entre ligado e desligado. Poder apagar a própria luz para se esconder do monstro é uma decisão tensa, e tensão é o que você quer.

Construindo um mapa que prende o jogador

A luz escura só funciona se o cenário obrigar o jogador a se mover por ele. Um horror de corredor é mais fácil de assustar do que um campo aberto, porque você controla o que a pessoa vê e para onde ela pode fugir. Monte o mapa com Parts formando paredes, portas estreitas e becos sem saída, e ancore tudo (marque Anchored no Properties), senão o cenário desmonta no primeiro Play.

Pense no ritmo do espaço, não só no visual. Alterne trechos apertados, onde o monstro pode encurralar, com salas um pouco maiores que deem alívio momentâneo, aquele respiro curto antes do próximo susto. Esconda os objetivos nos cantos mais escuros, assim o jogador é forçado a entrar no perigo de propósito. E deixe pelo menos duas rotas entre pontos importantes: uma saída única vira frustração, duas saídas viram decisão sob pressão, que é exatamente a emoção que o gênero vende.

Evite exagerar na decoração antes do jogo funcionar. Um corredor cinza com boa iluminação e um monstro competente assusta mais do que um cenário lindo e vazio. Primeiro faça a caça funcionar, depois vista o mapa.

Como fazer um jogo de horror tipo Forsaken no Roblox: o monstro que caça

Chegou a alma do jogo. O monstro precisa de um corpo com Humanoid e um PrimaryPart definido (o jeito mais simples é usar um modelo de personagem do Roblox e marcar a HumanoidRootPart como PrimaryPart no Properties do modelo). Com o modelo na cena, insira um Script dentro dele:

local monstro = script.Parent
local humanoid = monstro:WaitForChild("Humanoid")
local Players = game:GetService("Players")

local function alvoMaisProximo()
    local maisPerto = nil
    local menorDist = math.huge
    for _, jogador in Players:GetPlayers() do
        local char = jogador.Character
        local raiz = char and char:FindFirstChild("HumanoidRootPart")
        if raiz then
            local dist = (raiz.Position - monstro.PrimaryPart.Position).Magnitude
            if dist < menorDist then
                menorDist = dist
                maisPerto = raiz
            end
        end
    end
    return maisPerto
end

while true do
    task.wait(0.4)
    local alvo = alvoMaisProximo()
    if alvo then
        humanoid:MoveTo(alvo.Position)
    end
end

A função alvoMaisProximo passa por todos os jogadores, mede a distância de cada um até o monstro com .Magnitude e guarda o mais perto. O laço roda quatro vezes por segundo, acha o alvo e manda o monstro andar até ele com humanoid:MoveTo. Simples, e já dá medo, porque ele nunca para de vir.

Uma honestidade importante: o MoveTo anda em linha reta e não desvia de parede. Num mapa aberto ou num teste isso basta. Quando você fechar o cenário com corredores, troque o MoveTo pelo PathfindingService, que calcula um caminho válido pelo mapa e devolve uma lista de pontos para o monstro seguir em sequência. É o passo natural de evolução, mas comece pelo simples para ver o jogo funcionando hoje.

O susto que elimina

Perseguir sem consequência não assusta. Falta o toque que acaba com a rodada do sobrevivente. Dá para usar o mesmo Script do monstro: logo depois do laço de perseguição, conecte o evento Touched no PrimaryPart dele. Como o while true nunca termina, coloque esta parte acima do laço, ainda no mesmo script:

monstro.PrimaryPart.Touched:Connect(function(parte)
    local jogador = Players:GetPlayerFromCharacter(parte.Parent)
    if jogador and jogador.Character then
        local alvoHumanoid = jogador.Character:FindFirstChildOfClass("Humanoid")
        if alvoHumanoid and alvoHumanoid.Health > 0 then
            alvoHumanoid.Health = 0
        end
    end
end)

Quando algo encosta no monstro, o GetPlayerFromCharacter confere se foi um jogador. Se foi, o script zera a vida do Humanoid dele, o que no Roblox significa morrer e reaparecer. Para um horror mais cru você pode mostrar uma tela de susto antes de eliminar, mas o esqueleto já está completo: escuridão, lanterna, caça e morte. Aperte Play e corra.

Rodadas e objetivo: o que transforma susto em jogo

Um monstro perseguindo é assustador por trinta segundos. Para virar jogo, falta um ciclo e uma meta. A estrutura clássica do gênero é uma rodada: começa, os sobreviventes precisam cumprir um objetivo antes de serem pegos, e no fim alguém vence. O objetivo mais fácil de programar é a coleta, por exemplo cinco itens espalhados pelo mapa que, ao serem tocados, somam num contador, e quando o contador chega ao total, uma porta de saída abre.

Esse esqueleto de rodada usa os mesmos fundamentos que você já viu aqui, eventos de toque, uma variável de progresso e uma condição de vitória, os mesmos pilares do jogo tipo Steal a Brainrot no Roblox, só que no horror eles servem para gerar tensão em vez de economia. Se você fez aquele projeto antes, vai reaproveitar quase tudo o que aprendeu de evento e condição.

Publique e assuste alguém

Teste apertando Play a cada mudança e acompanhe a janela Output (menu View), onde os erros aparecem. Quando o monstro estiver caçando e o susto estiver matando, publique em File, depois Publish to Roblox As, com nome e descrição próprios. O jogo começa privado e você abre ao público quando quiser, de graça.

Horror é um gênero que vive do boca a boca e de reações em vídeo, então ele tem chance real de crescer. Se o seu pegar, o Roblox permite vender passes e itens, e criadores que atingem os requisitos do programa DevEx convertem Robux em dinheiro real, assunto que a gente detalha em como ganhar Robux criando jogos no Roblox. Mas a ordem importa: primeiro faça um jogo que dê medo de verdade, o resto vem depois. Agora apague as luzes do seu mapa e solte o monstro.