Game Design & Combate 20 de outubro de 2026 • 7 min de leitura • Equipe de Combate • Dead Pilot Studios

Arquitetura de Sistemas de Combate e Hitboxes Responsivos no Roblox

Por que abandonamos eventos Touched em favor da Spatial Query API, como estruturamos frame data com startup, active e recovery e como validamos acertos no servidor.

CombateHitboxSpatial QueryNetcode

Os limites do evento Touched e a migração para Spatial Query API

Quem começa a desenvolver sistemas de combate corpo a corpo no Roblox costuma recorrer ao evento `BasePart.Touched` acoplado ao modelo da arma. Embora funcione em protótipos simples, essa abordagem falha rapidamente em jogos de ação rápida. Como o evento depende de interseções calculadas pelo passo de física padrão, movimentos velozes atravessam alvos sem disparo, personagens parados dentro da área podem não gerar novos eventos e disparos múltiplos em uma mesma varredura exigem controles manuais frágeis.

Nos projetos do Dead Pilot Studios, substituímos completamente detecção por colisão passiva pela Spatial Query API moderna do motor, especificamente `workspace:GetPartBoundsInBox`, `workspace:GetPartBoundsInRadius` e `workspace:Spherecast`. Essas consultas síncronas aceitam parâmetros explícitos por meio de `OverlapParams` e `RaycastParams`, filtrando apenas a pasta de personagens válidos e ignorando acessórios decorativos, partículas e geometria irrelevante do cenário.

Ao rodar a consulta espacial exatamente nos quadros ativos do golpe, obtemos precisão geométrica consistente independentemente da velocidade da animação. Além disso, o controle explícito da lista de alvos já atingidos dentro de um único ataque impede danos duplicados e garante que um corte horizontal atinja todos os oponentes dentro do arco com o mesmo comportamento determinístico.

Frame data claro: startup, active frames, recovery e cancelamento

Um combate memorável depende tanto da sensação de controle quanto da matemática subjacente. Em vez de disparar dano no milissegundo em que o jogador pressiona o botão, estruturamos todo ataque como uma pequena máquina de estados dividida em três fases bem definidas: startup (antecipação), active (janela em que a hitbox consulta acertos) e recovery (retorno à postura neutra).

A fase de startup comunica visualmente a intenção do ataque para o adversário, permitindo esquivas ou bloqueios conscientes. Durante os active frames, o sistema consulta a área frontal a cada passo de simulação e aplica o impacto apenas uma vez por alvo detectado. Já a fase de recovery cria compromisso tático: errar um golpe pesado deixa uma breve abertura punível, enquanto ataques leves permitem encadear combos ou cancelar a recuperação com uma esquiva.

Para manter código e animação sempre sincronizados, evitamos temporizadores soltos desconectados dos movimentos visuais. Em vez disso, utilizamos `AnimationTrack:GetMarkerReachedSignal` combinado com janelas de segurança no servidor. Assim, o som de impacto, o rastro da lâmina e a abertura da hitbox acontecem em uníssono com a pose exata da animação.

  • Startup curto (120 ms a 180 ms) para ataques rápidos que iniciam pressão e testam a guarda rival.
  • Active frames contínuos em arco frontal evitando áreas cegas muito próximas ao tronco do atacante.
  • Janelas explícitas de parry antes do impacto para recompensar leitura e reação precisa.
  • Hitstop sutil (35 ms a 60 ms) em acertos críticos apenas no nível visual e sonoro, sem travar a rede.

Validação server-authoritative sem sacrificar a fluidez do cliente

Um dilema clássico em jogos multiplayer é equilibrar segurança contra trapaças e sensação imediata de resposta. Confiar cegamente em pacotes enviados pelo cliente abre brechas óbvias de alcance infinito ou dano artificial; por outro lado, esperar a ida e volta completa no servidor antes de iniciar qualquer feedback visual faz o jogo parecer pesado e desconfortável.

Nossa arquitetura adota um modelo híbrido focado em autoridade do servidor com previsão responsiva no cliente. Ao clicar para atacar, o jogador vê imediatamente a animação local, ouve o efeito inicial e observa a resposta de movimento. Simultaneamente, um pedido compacto de início de ação chega ao servidor, que verifica cooldown, estado de atordoamento, energia disponível e coerência temporal antes de autorizar o ataque para os demais participantes.

Na detecção de acerto, o servidor compara a posição declarada no instante do golpe com uma tolerância calculada dinamicamente a partir do ping medido do jogador via `Player:GetNetworkPing()`, dentro de um limite máximo rígido. Se a distância estiver fora do cone plausível ou se a cadência violar o frame data registrado na tabela de configuração da arma, o pacote é descartado silenciosamente e registrado nos logs de diagnóstico.

Consulta espacial no servidor com filtragem de alvos únicos (luau)
--!strict
local Players = game:GetService("Players")

local HitboxService = {}

function HitboxService.queryBox(
	origin: CFrame,
	size: Vector3,
	attacker: Player,
	alreadyHit: { [Model]: boolean },
	params: OverlapParams
): { Model }
	local hits: { Model } = {}
	local parts = workspace:GetPartBoundsInBox(origin, size, params)

	for _, part in parts do
		local model = part:FindFirstAncestorOfClass("Model")
		if not model or alreadyHit[model] then
			continue
		end

		local humanoid = model:FindFirstChildOfClass("Humanoid")
		local targetPlayer = Players:GetPlayerFromCharacter(model)
		if humanoid and humanoid.Health > 0 and targetPlayer ~= attacker then
			alreadyHit[model] = true
			table.insert(hits, model)
		end
	end

	return hits
end

return HitboxService

Feedback tátil, áudio espacial e legibilidade em arenas cheias

Mesmo a hitbox matematicamente perfeita parece imprecisa se o jogador não compreender instantaneamente se acertou, errou ou foi bloqueado. Por isso, dedicamos a mesma atenção de engenharia ao feedback multissensorial do impacto: variação tonal no áudio entre acerto limpo e bloqueio metálico, faíscas direcionais alinhadas à normal do contato e leve recuo de câmera controlado sem causar desconforto.

Cada novo arquétipo de arma passa por sessões de teste com latência artificial injetada no ambiente de desenvolvimento, garantindo que o combate permaneça justo e legível tanto em conexões locais de 25 milissegundos quanto em partidas intercontinentais acima de 140 milissegundos.

Continue Lendo

Outros Devlogs Técnicos