State:

public abstract class State
{
    public abstract void StartState();
    public virtual void UpdateState()
    {
    }
    public abstract void EndState();
}

Métodos Abstratos:

public abstract void StartState(); public abstract void EndState(); são métodos abstratos. Um método abstrato não possui corpo (implementação) aqui e deve ser implementado por qualquer classe não abstrata que herde desta classe State.

Método Virtual:

public virtual void UpdateState() {} é um método virtual. Um método virtual possui uma implementação (neste caso, um corpo vazio {}), mas pode ser sobrescrito por classes derivadas caso necessitem de um comportamento diferente.

Como Funciona para Nosso Inimigo

Herança de Estado:

A classe State será herdada por outros estados específicos. Por exemplo, podemos ter classes como IdleState, AttackState e PatrolState que herdam de State. Cada um desses estados implementará suas próprias versões de StartState(), UpdateState() e EndState().

Comportamento do Inimigo:

O comportamento do inimigo é gerenciado por meio de estados, com StartState() inicializando o estado, UpdateState() atualizando o comportamento durante o estado e EndState() realizando a limpeza após o término do estado.

Uso de Classe Abstrata: Tornar State uma classe abstrata garante que todos os estados específicos implementem os métodos necessários, organizando o comportamento do inimigo e simplificando o gerenciamento de estados sem alterar o script do inimigo.

Gerenciador de Estados:

public class StateManager
{
    State currentState;

    public StateManager(State startingState)
    {
        currentState = startingState;
        currentState.StartState();
    }

    public void ChangeState(State newState)
    {
        currentState.EndState();
        currentState = newState;
        currentState.StartState();
    }

    public void UpdateStates()
    {
        currentState.UpdateState();
    }
}

Explicação

O construtor public StateManager(State startingState) inicializa o StateManager com um estado inicial. Ele define currentState como startingState e chama currentState.StartState() para inicializá-lo.

O método ChangeState, public void ChangeState(State newState), altera o estado do inimigo. Ele chama currentState.EndState() para finalizar o estado atual, define currentState para o novo estado e, em seguida, chama currentState.StartState() para inicializar o novo estado.

O método UpdateStates, public void UpdateStates(), atualiza o estado atual chamando currentState.UpdateState() para executar as ações associadas a esse estado.

Funcionamento para o Nosso Inimigo

Ao criar um StateManager para o inimigo, o construtor inicializa o estado inicial. Quando o inimigo precisa mudar de comportamento, o método ChangeState é chamado, finalizando o estado atual com EndState(), definindo o novo estado e inicializando-o com StartState(). Durante o jogo, o método UpdateStates é chamado repetidamente para executar as ações do estado atual por meio de UpdateState().

Exemplo de Fluxo de Trabalho:

O inimigo começa em um IdleState, com o StateManager criado e IdleState.StartState() chamado para configurar o comportamento de inatividade. Quando o inimigo detecta o jogador, ChangeState(new AttackState()) é chamado, finalizando o comportamento de inatividade com IdleState.EndState(). O estado atual é então definido como AttackState, e AttackState.StartState() inicia o comportamento de ataque. A cada frame, UpdateStates() é chamado e, se o estado atual for AttackState, AttackState.UpdateState() gerencia as ações de ataque.

Utilizando a classe StateManager, é possível gerenciar e alternar facilmente entre diferentes comportamentos do inimigo de forma organizada.

Estado de Inatividade

public class IdleState : State
{
    Animator animator;

    public IdleState(Animator animator)
    {
        this.animator = animator;
    }

    public override void StartState()
    {
        animator.SetBool("idle", true);
    }

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

Explicação

O construtor public IdleState(Animator animator) recebe um objeto Animator como parâmetro e o atribui à variável animator da classe. O método StartState, public override void StartState(), define o parâmetro booleano "idle" no animator como verdadeiro, acionando a animação de inatividade. O método EndState, public override void EndState(), define o parâmetro "idle" como falso, interrompendo a animação de inatividade.

Funcionamento para o Nosso Inimigo

Quando o inimigo entra no IdleState, o método StartState() define o parâmetro "idle" no animator como verdadeiro, iniciando a animação de inatividade e fazendo o inimigo parecer parado. Quando o inimigo sai do IdleState, o método EndState() define o parâmetro "idle" como falso, interrompendo a animação de inatividade e preparando o inimigo para transitar para outro estado, como movimentação ou ataque.

Exemplo de Fluxo de Trabalho

O StateManager define o estado do inimigo como IdleState, chamando IdleState.StartState() para definir o parâmetro "idle" do animator como verdadeiro, iniciando a animação de idle. Ao mudar o comportamento do inimigo, o StateManager chama IdleState.EndState(), definindo o parâmetro "idle" como falso e parando a animação de idle. Em seguida, o StateManager faz a transição do inimigo para um novo estado, como AttackState ou PatrolState.

Ao utilizar a classe IdleState, garantimos que nosso inimigo possa entrar e sair do comportamento de idle de forma suave, tornando-o mais dinâmico e realista. Essa estrutura também facilita a adição ou modificação do comportamento de idle do inimigo sem afetar outras partes do código do inimigo.