Como Criar um Sistema de Vida e Dano em Unity (O Guia Completo e Prático)

  • EM

O que é um jogo de ação sem a emoção do perigo? Ou um RPG sem a satisfação de derrotar um inimigo formidável? No coração de quase todos esses jogos, existe um sistema fundamental: o de vida e dano.

Construir essa mecânica pode parecer complexo no início, mas a lógica por trás dela é bastante direta.

Neste guia, vamos construir um sistema de vida e dano do zero. O resultado será um componente flexível que você poderá anexar a jogadores, inimigos e até a objetos destrutíveis no seu cenário. Vamos focar na criação de um script limpo e que pode ser facilmente expandido no futuro.

1. A Base: O Componente de Saúde (Saude.cs)

O primeiro passo é criar um script que será o único responsável por gerenciar a saúde de um objeto. Essa abordagem de separar responsabilidades é uma ótima prática de programação.

  1. Na sua pasta de Scripts, crie um novo script C# chamado Saude.
  2. Abra o script e adicione as seguintes variáveis:
using UnityEngine;

public class Saude : MonoBehaviour {

    public float vidaMaxima = 100f;
    private float vidaAtual;

    void Awake() {
        // Ao iniciar, a vida atual é igual à vida máxima.
        vidaAtual = vidaMaxima;
    }
}

O método Awake() é chamado assim que o objeto é carregado, antes mesmo do Start(). É o lugar perfeito para inicializar o estado do nosso componente, garantindo que todo objeto comece com a vida cheia.

2. Recebendo Dano: A Função LevarDano()

Agora, precisamos de uma forma de fazer este objeto perder vida. Para isso, criaremos uma função pública, que poderá ser chamada por outros scripts (como um projétil ou a espada de um inimigo).

Adicione o seguinte método dentro da sua classe Saude:

public void LevarDano(float quantidadeDano) {
    // Subtrai o dano da vida atual.
    vidaAtual -= quantidadeDano;

    // Garante que a vida não fique negativa.
    if (vidaAtual < 0) {
        vidaAtual = 0;
    }

    // Se a vida chegar a zero, chama a função de morte.
    if (vidaAtual == 0) {
        Morrer();
    }
}

Esta função é o ponto de entrada para todo o dano que o objeto receber. Ela subtrai a quantidade de dano recebida e, crucialmente, verifica se a vida chegou a zero para acionar a consequência.

3. A Consequência: A Função Morrer()

O que acontece quando a vida de um objeto acaba? A “morte” pode significar coisas diferentes para objetos diferentes. Para um inimigo, pode ser uma explosão e a destruição do seu GameObject. Para o jogador, pode ser o acionamento de uma tela de “Game Over”.

Vamos criar uma função simples para lidar com isso. Adicione este método privado ao script Saude:

private void Morrer() {

    // Ação a ser executada quando a vida chega a zero.
    Debug.Log("O objeto morreu!");
    
    // Destrói o GameObject ao qual este script está anexado.
    Destroy(gameObject);

}

Esta é a implementação mais básica. Sinta-se à vontade para customizá-la: você pode adicionar aqui sua lógica para tocar uma animação de morte, instanciar um efeito de partículas, dar pontos ao jogador, etc.

4. Aplicando o Dano: Um Exemplo Prático

Agora que nosso componente Saude está pronto, como o usamos? Vamos criar um exemplo simples: um projétil que causa dano ao colidir com algo.

  1. Crie um novo script chamado Projetil.
  2. Adicione o seguinte código a ele:
using UnityEngine;

public class Projetil : MonoBehaviour {

    public float dano = 25f;

    // Para jogos 2D, use OnCollisionEnter2D
    void OnCollisionEnter(Collision colisao) {

        // Tenta obter o componente 'Saude' do objeto com o qual colidiu.
        Saude saudeDoAlvo = colisao.gameObject.GetComponent<Saude>();

        // Verifica se o objeto com o qual colidimos tem, de fato, um script 'Saude'.
        if (saudeDoAlvo != null) {
            // Se tiver, chama a função pública para causar dano.
            saudeDoAlvo.LevarDano(dano);
        }

        // Destrói o projétil após a colisão.
        Destroy(gameObject);
    }

}

Agora, basta anexar o script Projetil a um Prefab de projétil, e o script Saude a qualquer objeto que possa receber dano (jogador, inimigos, caixas destrutíveis). O sistema funcionará automaticamente.

Extras e Próximos Passos

Com a base pronta, você pode expandir o sistema facilmente:

  • Cura: Crie uma função public void Curar(float quantidadeCura) no script Saude que aumenta a vidaAtual, garantindo que ela não ultrapasse a vidaMaxima.
  • Feedback Visual: Crie uma barra de vida na UI que reflita a porcentagem de vida atual (vidaAtual / vidaMaxima). Você também pode fazer o personagem piscar em vermelho por um instante ao levar dano.
  • Invencibilidade Temporária: Após levar dano, ative um estado de “invencível” por um ou dois segundos para evitar que o jogador morra instantaneamente ao ser cercado.

Conclusão

Com estes dois scripts, Saude.cs e Projetil.cs, você tem um sistema de vida e dano funcional, modular e reutilizável.

O conceito mais importante aqui é a separação de responsabilidades: o script Saude só se preocupa com a vida do objeto e suas consequências, enquanto outros scripts são responsáveis por acionar a função de dano. Essa organização torna seu projeto mais limpo, fácil de depurar e de expandir.

Implementar sistemas como este é um passo crucial na sua jornada de dev. Se você curtiu este guia prático, vai gostar ainda mais dos projetos que desenvolvemos em nosso canal no YouTube, a PERAI DEV. Inscreva-se e continue aprendendo com a gente!

Compartilhe !

Posts relacionados