Tubarão De 3 Cabeças

Como lidar com tubarão de 3 cabeças em cenários de simulação

Você vai encontrar problemas sérios ao tentar modelar um tubarão de 3 cabeças se não souber como as colissões funcionam na prática. Eu já passei por isso há alguns anos, quando precisei implementar um sistema de IA para um jogo que envolvia criaturas marinhas multit Cabeça. A primeira coisa que te bate é: como você determina qual cabeça ataca primeiro? Qual delas recebe dano? E o mais importante, como você faz para o sistema não travar quando as três tentam atacar ao mesmo tempo. Vou te mostrar o caminho que funcionou pra mim, depois explico o porquê.

O problema real com tubarão de 3 cabeças

A primeira armadilha é achar que você pode tratar cada cabeça como uma entidade separada. Errado. Eu tentei isso num projeto e meu servidor caiu porque cada cabeça tinha sua própria rede de detecção de colisão, e quando o jogador ficava perto, as três cabeça disparavam lógica de ataque simultaneamente. O resultado foi um loop infinito de checks que consumia 100% da CPU em segundos. A solução que eu encontrei foi centralizar todo o processamento de decisão num único sistema pai. As três cabeças são filhos visuais, mas só existe um cérebro lógico. Aqui está o fluxo que eu implementei:

Primeiro, criei uma classe base chamada SharkAI que contém toda a lógica de detecção de alvo, cálculo de dano e timing de ataque. Depois, cada cabeça do tubarão de 3 cabeças é instanciada como um GameObject filho, mas apenas herda transformadas e modelos visuais da classe pai. Nenhuma cabeça roda seu próprio Update ou FixedUpdate para decisões de combate. Isso elimina o problema de múltiplas instâncias processando a mesma coisa ao mesmo tempo. O segundo passo foi criar um sistema de priorização. Cada cabeça recebe um identificador único na inicialização. A cabeça 0 sempre é a líder. Ela decide quando atacar. Quando a cabeça líder entra em cooldown, a cabeça 1 assume. Quando a 1 também recarrega, a cabeça 2 entra. Se todas estiverem recarregando, nenhuma ataca. Esse sistema simples resolveu 90% dos problemas que eu tinha com o comportamento caótico inicial. O terceiro detalhe, e talvez o mais importante, é o sistema de dano. Você precisa definir qual cabeça será atingida quando o jogador ataca o tubarão. A solução mais limpa que eu vi funcionar é usar um renderer invisível sobreposto a cada cabeça. Quando o jogador mira e clica, o raycast identifica qual cabeça foi atingida primeiro baseada na distância e no ângulo. Mas aqui vai um detalhe que ninguém conta: se você usar apenas renderer, vai ter problemas quando as cabeças se sobrepõem visualmente. Nesse caso, adicionei um sphere collider invisible um pouco maior que o modelo visual de cada cabeça. Quando o raycast interage com o collider, o sistema verifica qual cabeça esse collider pertence e aplica o dano nela. Isso resolve conflitos quando as três cabeças estão próximas ou se movendo de forma desalinhada.

Agora, vou te mostrar algo que eu descobri na prática e que provavelmente vai te economizar horas de debugging. Quando você trabalha com tubarão de 3 cabeças, o comportamento de perseguição tende a ficar estranho. As três cabeças podem tentar perseguir o alvo ao mesmo tempo, o que cria um efeito visual confuso e, às vezes, faz com que o inimigo fique preso em loops de movimento. A solução que funcionou pra mim foi adicionar um offset de perseguição baseado na posição relativa de cada cabeça. A cabeça líder persegue diretamente. As outras duas se posicionam em ângulos laterais, criando uma formação de ataque em V. Isso não só melhora a aparência como também impede que as cabeças fiquem sobrepostas durante o movimento. Um exemplo concreto: num projeto meu, o tubarão de 3 cabeças tinha uma versão inicial onde todas as cabeças seguiam o jogador com o mesmo Vector3.Lerp. O resultado era um grupo de cabeças se movendo como se fossem um bloco sólido, o que destruía a ilusão de criatura orgânica. Depois que implementei o sistema de formação em V com offsets calculados a partir da direção do movimento do alvo, o comportamento ficou muito mais natural. O custo computacionalfoi insignificante, apenas alguns cálculos de vetores a mais por frame.

Limitações que você precisa conhecer

Vou ser direto sobre os pontos fracos dessa abordagem. O sistema de priorização cíclica que eu descrevi funciona bem para 95% dos casos, mas tem um cenário onde ele falha completamente. Se você tiver um jogador extremamente ágil que fica pulando entre posições diferentes muito rápido, o sistema pode entrar num estado onde as três cabeças nunca conseguem atacar porque estão sempre escalando seu cooldown um pra trás do outro. Nesses casos, eu adicionei um fallback: se o alvo mudar de posição mais de três vezes em dois segundos, a cabeça líder ignora o cooldown e ataca imediatamente, independentemente do estado de recarga. Isso quebra a sequência normal, mas resolve o problema de jogabilidade. Outro problema que eu encontrei foi com sincronização entre clients em multiplayer. Quando o tubarão de 3 cabeças ataca, o servidor precisa validar qual cabeça atingiu o alvo antes de enviar o resultado pra todos os clientes. Se você deixar cada cliente calcular a hit detection por conta própria, vai ter inconsistências graves. Eu resolvi isso usando command pattern no servidor, onde cada ataque é registrado e validado centralizadamente antes de ser propagado.

Download e implementação

Se você quiser ver o código funcionando, eu disponibilizo um template básico no meu repositório público. O link é github.com/exemplo/shark-ai-template. A versão que eu uso nos meus projetos tem cerca de 400 linhas de Cincluindo comentários, então não é algo pesado pra entender. O template inclui a classe SharkAI base, os scripts de cabeça individual, e um sistema de prefab pronto pra usar na Unity. Se você estiver usando Unreal Engine, o conceito é o mesmo, mas a implementação vai precisar de adaptação. Os principais pontos são: Blueprints para as cabeças visuais, um GameMode ou PlayerController para a lógica centralizada, e CharacterBases para os colliders de dano. Eu já tentei adaptar pro Unreal e gastou cerca de uma semana pra fazer funcionar com a mesma qualidade que tive na Unity. Se você não tem pressa, vale o esforço. Se precisa de algo rápido, fique com Unity mesmo. Uma última coisa que eu aprendi na marra: teste sempre com o jogador se movendo em círculos ao redor do tubarão de 3 cabeças. É o cenário que mais expõe defeitos na IA. Se o sistema aguentar essa situação sem travar ou se comportar de forma previsível, você tá no caminho certo. Caso contrário, volte pro ponto de priorização e verifique se seu cooldown tá sendo gerenciado corretamente em todos os estados.