public class AttackState : State
{
    string attackStateName; 
    bool isAttacking;
    Animator animator;
    Transform transform;
    float range;
    int damage;
    LayerMask playerLayer;

    public AttackState(Transform t, Animator animator, LayerMask playerLayer, string attackStateName, int damage, float range = 2.1f)
    {
        this.animator = animator;
        this.attackStateName = attackStateName;
        this.range = range;
        transform = t;
        this.damage = damage;
        this.playerLayer = playerLayer;
    }

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

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

    public override void UpdateState(float deltaTime)
    {
        Attack();
    }

    public override void StartAction()
    {
        isAttacking = true;
    }

    public override void FinishMovement()
    {
        isAttacking = false;
    }

    void Attack()
    {
        if (!isAttacking) return;
        RaycastHit2D rayCastHit = Physics2D.Raycast(transform.position, Vector2.right * transform.localScale.x, range, playerLayer);
        if (rayCastHit)
        {
            if (rayCastHit.transform.TryGetComponent(out IGetAttacked getAttacked))
            {
                getAttacked.GetAttacked(damage);
                isAttacking = false;
            }
        }
    }
}

Explicação da Classe AttackState

A classe AttackState é um estado específico que lida com o comportamento de ataque do inimigo. Esta classe herda da classe State e inclui métodos para iniciar, atualizar e finalizar o estado de ataque, bem como lidar com a ação de ataque.

Definição da Classe e Variáveis Membro

Definição da Classe:

public class AttackState : State; Esta classe herda da classe State, o que significa que deve implementar os métodos abstratos definidos em State.

Variáveis Membro:

string attackStateName; O nome do estado de ataque usado no animador. bool isAttacking; Um indicador para mostrar se o inimigo está atualmente atacando. Animator animator; Controla as animações. Transform transform; O transform do inimigo, usado para posicionamento e raycasting. float range; O alcance do ataque. int damage; O dano causado pelo ataque. LayerMask playerLayer; A máscara de camada usada para identificar o jogador.

Construtor

O construtor inicializa o AttackState com os componentes necessários: um Transform para posicionamento, um Animator para animações, uma máscara de camada para identificar o jogador, o nome do estado de ataque, o valor do dano e o alcance do ataque. Ele define esses valores para as variáveis membro correspondentes.

Método StartState

Este método define isStateFinished como false, aciona a animação de ataque definindo o parâmetro booleano apropriado no animador como true, e redefine o indicador isAttacking para false.

Método EndState

Este método interrompe a animação de ataque definindo o parâmetro booleano apropriado no animador como false.

Método UpdateState

Este método é chamado a cada frame e aciona o método Attack para realizar a ação de ataque.

Método StartAction

Este método define isAttacking como true, indicando que a ação de ataque foi iniciada.

Método FinishMovement

Este método define isAttacking como false, indicando que a ação de ataque foi encerrada.

Método Attack

Este método realiza a ação de ataque. Se isAttacking for true, ele lança um raio na direção em que o inimigo está voltado. Se o raio atingir um objeto na playerLayer, ele chama o método GetAttacked no objeto atingido, causando dano e encerrando a ação de ataque.

Por Que Fizemos Assim

• Controle Sobre o Comportamento de Ataque: A flag isAttacking permite um controle preciso sobre quando o ataque deve ocorrer, tornando o comportamento mais responsivo aos eventos do jogo;

• Execução Dinâmica de Ataque: Ao atualizar continuamente o estado de ataque do inimigo, o AttackState garante que o inimigo possa atacar o jogador de forma precisa e dinâmica;

• Integração de Animação: Usar parâmetros do animador garante que as animações do inimigo estejam corretamente sincronizadas com seus ataques, proporcionando uma experiência suave e realista.

Como Funciona no Contexto

Entrando no Estado de Ataque: Quando o inimigo entra no AttackState, o método StartState é chamado, acionando a animação de ataque e reiniciando a flag isAttacking.

Durante o Ataque: O método UpdateState é chamado a cada frame. Ele aciona o método Attack para verificar se um ataque deve ocorrer.

Iniciando o Ataque: O método StartAction define isAttacking como true, permitindo que o método Attack realize a ação de ataque.

Realizando o Ataque: O método Attack lança um raio para detectar o jogador e causa dano se o jogador for atingido.

Finalizando o Ataque: O método FinishMovement define isAttacking como false, interrompendo a ação de ataque.

Saindo do Estado de Ataque: Quando o inimigo sai do AttackState, o método EndState é chamado, interrompendo a animação de ataque. Estruturando o AttackState desta forma, garantimos que o inimigo possa realizar ataques responsivos e dinâmicos no jogador, com transições suaves entre animações e estados.

Transição Fechada:

closeTransition = new Transition(() =>
{
    return (ThresholdDistance >= Mathf.Abs(transform.position.x - player.position.x));
}, new StatePourcentage(attack2, 50f), new StatePourcentage(attack1, 50f));

stateManager.AddStateTransition(idle, closeTransition);
stateManager.AddStateTransition(idle, FarAwayTransition);
stateManager.AddStateTransition(dashState, toIdleTransition);
stateManager.AddStateTransition(dashState, finishRunning);
stateManager.AddStateTransition(runState, finishRunning);
stateManager.AddStateTransition(attack2, toIdleTransition);
stateManager.AddStateTransition(attack1, toIdleTransition);

closeTransition: Esta transição verifica se o jogador está dentro de uma certa distância horizontal (ThresholdDistance) do inimigo. Se a condição for atendida, ela transita aleatoriamente para attack1 ou attack2 com igual probabilidade (50% cada);

Exemplo de Código:

 ```csharp
 closeTransition = new Transition(() =>
 {
     return (ThresholdDistance >= Mathf.Abs(transform.position.x - player.position.x));
 }, new StatePourcentage(attack2, 50f), new StatePourcentage(attack1, 50f));
 ```

Adicionando closeTransition ao Estado Idle:

stateManager.AddStateTransition(idle, closeTransition); Esta linha adiciona o closeTransition ao estado idle, permitindo que a máquina de estados verifique essa condição quando o inimigo está no estado ocioso.

Por Que Fizemos Assim

O sistema de transição permite que o inimigo mude para um estado de ataque com base na proximidade do jogador, aumentando o engajamento. A abordagem probabilística para escolher entre diferentes ataques adiciona imprevisibilidade, aumentando o desafio e o interesse do jogo.

Como Funciona no Contexto

Estado Idle: Enquanto o inimigo está no estado idle, ele verifica constantemente se o jogador está dentro do ThresholdDistance usando o closeTransition. Se o jogador estiver perto o suficiente, o closeTransition é acionado, e o inimigo transita para attack1 ou attack2.

Estados de Ataque:

Uma vez em attack1 ou attack2, o inimigo realiza o ataque. Após o término do ataque, o toIdleTransition existente faz o inimigo voltar ao estado idle, pronto para verificar novamente a condição do closeTransition.

Ao adicionar este closeTransition, garantimos que o inimigo possa engajar o jogador de forma mais dinâmica e imprevisível quando o jogador estiver em uma faixa próxima. Isso melhora a jogabilidade tornando o comportamento do inimigo mais responsivo e envolvente.