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.
--!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.