public class Projectile : MonoBehaviour
{
    [SerializeField] int damage;
    [SerializeField] float speed;
    Rigidbody2D rb;
    Vector2 direction;

    public void Setup(Vector2 direction)
    {
        this.direction = direction;
        rb = GetComponent<Rigidbody2D>();
        transform.right = direction;
        Destroy(gameObject, 6);
    }

    private void Update()
    {
        rb.velocity = direction * speed;
    }

    private void OnTriggerEnter2D(Collider2D collision)
    {
        Debug.Log(collision.gameObject.name);
        if (collision.tag == "Player")
        {
            if (collision.TryGetComponent(out IGetAttacked getAttacked))
            {
                getAttacked.GetAttacked(damage);
                Destroy(gameObject);
            }
        }
    }
}

A classe Projectile é responsável por gerenciar o comportamento dos projéteis que o inimigo pode lançar contra o jogador. Esta classe lida com a configuração da direção e velocidade do projétil, atualização do seu movimento e tratamento de colisões.

Método Setup

public void Setup(Vector2 direction)
{
    this.direction = direction;
    rb = GetComponent<Rigidbody2D>();
    transform.right = direction;
    Destroy(gameObject, 6);
}

Finalidade: Este método define o estado inicial do projétil.

Parâmetros: Recebe um parâmetro Vector2 direction para definir a direção que o projétil irá percorrer.

Ações: Define a direção do projétil, obtém o componente Rigidbody2D anexado ao projétil, rotaciona o projétil para apontar na direção em que irá se mover e agenda a destruição do projétil após 6 segundos para evitar que ele permaneça indefinidamente na cena.

Método Update

private void Update()
{
    rb.velocity = direction * speed;
}

Finalidade: Este método atualiza o movimento do projétil.

Ações: Define a velocidade do Rigidbody2D para mover o projétil na direção especificada com a velocidade definida.

Método OnTriggerEnter2D

private void OnTriggerEnter2D(Collider2D collision)
{
    Debug.Log(collision.gameObject.name);
    if (collision.tag == "Player")
    {
        if (collision.TryGetComponent(out IGetAttacked getAttacked))
        {
            getAttacked.GetAttacked(damage);
            Destroy(gameObject);
        }
    }
}

Finalidade: Este método lida com colisões com outros objetos.

Parâmetros: Recebe um parâmetro Collider2D collision para detectar colisões.

Ações: Registra o nome do objeto com o qual o projétil colidiu, verifica se o projétil colidiu com um objeto com a tag "Player" e, se o objeto possuir um componente que implementa a interface IGetAttacked, chama o método GetAttacked nesse componente para causar dano. Por fim, destrói o projétil após atingir o jogador.

Por Que Fizemos Desta Forma

Modular e Reutilizável: A classe Projectile foi projetada para ser modular e reutilizável para qualquer tipo de projétil que o inimigo possa usar. Ao definir a direção e a velocidade, é possível criar diversos projéteis com comportamentos diferentes.

Manipulação Eficiente de Movimento: Utilizar o componente Rigidbody2D para o movimento garante que o projétil se comporte de acordo com o sistema de física do Unity, proporcionando um movimento suave e realista.

Detecção de Colisão e Manipulação de Dano: O método OnTriggerEnter2D garante que o projétil possa detectar colisões com o jogador e aplicar dano de forma apropriada, tornando a interação entre o projétil e o jogador eficaz.

Classe SendProjectileState

public class SendProjectileState : State
{
    Animator animator;
    System.Action sendProjectileFunc;

    public SendProjectileState(Animator animator, System.Action sendProjectileFunc)
    {
        this.animator = animator;
        this.sendProjectileFunc = sendProjectileFunc;
    }

    public override void StartState()
    {
        isStateFinished = false;
        animator.SetBool("projectil", true);
    }

    public override void StartAction()
    {
        sendProjectileFunc();
    }

    public override void EndState()
    {
        animator.SetBool("projectil", false);
    }
}

A classe SendProjectileState é um estado específico que gerencia o comportamento do inimigo ao lançar um projétil. Esta classe herda da classe State e inclui métodos para iniciar, finalizar e executar a ação de ataque com projétil.

Construtor

O construtor inicializa o SendProjectileState com um Animator para animações e uma ação para lançar o projétil. Ele atribui esses valores às variáveis membro correspondentes.

Método StartState

Este método define isStateFinished como false e aciona a animação do projétil ao definir o parâmetro booleano "projectil" no animator como true.

Método StartAction

Este método chama sendProjectileFunc, que executa a ação definida para o envio do projétil. Este método normalmente é chamado por um evento do animator para sincronizar o lançamento do projétil com a animação.

Método EndState

Este método interrompe a animação do projétil ao definir o parâmetro booleano "projectil" no animator como false.

Por que Fizemos Desta Forma

Modular e Reutilizável: A classe SendProjectileState foi projetada para ser modular, permitindo a integração flexível de diferentes comportamentos de envio de projéteis por meio do uso de System.Action.

Integração com Animação: Ao utilizar parâmetros do animador, o estado garante que o lançamento do projétil esteja sincronizado com a animação correspondente, proporcionando uma experiência suave e realista.

Função de Envio de Projétil

void SendProjectile()
{
    Vector2 direction = (player.position - transform.position).normalized;
    Instantiate(projectile, projectileSendingPosition.position, Quaternion.identity).Setup(direction);
}

O método SendProjectile é responsável por criar e lançar um projétil em direção ao jogador. Este método calcula a direção do inimigo até o jogador, instancia o projétil e o configura para se mover na direção calculada.

Definição do Método e Componentes

Definição do Método: void SendProjectile(): Este método não retorna um valor e é projetado para lidar com o lançamento do projétil.

Componentes: Vector2 direction = (player.position - transform.position).normalized; Esta linha calcula a direção do inimigo até o jogador subtraindo a posição do inimigo da posição do jogador. A parte .normalized garante que o vetor de direção tenha comprimento 1, tornando-o um vetor unitário que indica apenas a direção.

Instantiate(projectile, projectileSendingPosition.position, Quaternion.identity).Setup(direction); Esta linha cria uma nova instância do projétil na posição especificada (projectileSendingPosition.position) sem rotação (Quaternion.identity). O método Setup é chamado no projétil instanciado para definir sua direção.

Vinculação com o Unity Animator

A função StartAction está sendo chamada utilizando eventos do animator. Isso permite especificar o quadro exato dentro da animação do inimigo no qual queremos que o projétil seja enviado. Como a animação consiste em vários quadros, é importante determinar o momento preciso para que essa ação ocorra.