Zustand:

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

Abstrakte Methoden:

public abstract void StartState(); public abstract void EndState(); sind abstrakte Methoden. Eine abstrakte Methode besitzt hier keinen Rumpf (keine Implementierung) und muss von jeder nicht-abstrakten Klasse, die von dieser State-Klasse erbt, implementiert werden.

Virtuelle Methode:

public virtual void UpdateState() {} ist eine virtuelle Methode. Eine virtuelle Methode besitzt eine Implementierung (in diesem Fall einen leeren Rumpf {}), kann jedoch von abgeleiteten Klassen überschrieben werden, falls ein anderes Verhalten benötigt wird.

Funktionsweise für unseren Gegner

Zustandsvererbung:

Die Klasse State wird von anderen spezifischen Zuständen geerbt. Beispielsweise könnten wir Klassen wie IdleState, AttackState und PatrolState haben, die von State erben. Jeder dieser Zustände implementiert eigene Versionen von StartState(), UpdateState() und EndState().

Verhalten des Gegners:

Das Verhalten des Gegners wird durch Zustände gesteuert. StartState() initialisiert den Zustand, UpdateState() aktualisiert das Verhalten während des Zustands und EndState() bereinigt nach dem Ende des Zustands.

Verwendung einer abstrakten Klasse: Die Definition von State als abstrakte Klasse stellt sicher, dass alle spezifischen Zustände die erforderlichen Methoden implementieren. Dies organisiert das Gegnerverhalten und vereinfacht das Zustandsmanagement, ohne das Gegner-Skript ändern zu müssen.

Zustandsmanager:

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();
    }
}

Erklärung

Der Konstruktor public StateManager(State startingState) initialisiert den StateManager mit einem Anfangszustand. Er setzt currentState auf startingState und ruft currentState.StartState() auf, um diesen zu initialisieren.

Die Methode ChangeState, public void ChangeState(State newState), ändert den Zustand des Gegners. Sie ruft currentState.EndState() auf, um den aktuellen Zustand zu bereinigen, setzt currentState auf den neuen Zustand und ruft anschließend currentState.StartState() auf, um den neuen Zustand zu initialisieren.

Die Methode UpdateStates, public void UpdateStates(), aktualisiert den aktuellen Zustand, indem sie currentState.UpdateState() aufruft, um die mit diesem Zustand verbundenen Aktionen auszuführen.

Funktionsweise für unseren Gegner

Wenn wir einen StateManager für unseren Gegner erstellen, initialisiert der Konstruktor den Anfangszustand. Wenn der Gegner sein Verhalten ändern muss, wird die Methode ChangeState aufgerufen, beendet den aktuellen Zustand mit EndState(), setzt den neuen Zustand und initialisiert ihn mit StartState(). Während des Spiels wird die Methode UpdateStates wiederholt aufgerufen, um die Aktionen des aktuellen Zustands über UpdateState() auszuführen.

Beispielhafter Ablauf:

Der Gegner startet in einem IdleState, wobei der StateManager erstellt und IdleState.StartState() aufgerufen wird, um das Leerlaufverhalten einzurichten. Wenn der Gegner den Spieler entdeckt, wird ChangeState(new AttackState()) aufgerufen, wodurch das Leerlaufverhalten mit IdleState.EndState() beendet wird. Der aktuelle Zustand wird dann auf AttackState gesetzt und AttackState.StartState() startet das Angriffsverhalten. In jedem Frame wird UpdateStates() aufgerufen und, falls der aktuelle Zustand AttackState ist, übernimmt AttackState.UpdateState() die Angriffsaktionen.

Mit der Klasse StateManager lassen sich die verschiedenen Verhaltensweisen unseres Gegners einfach und strukturiert verwalten und wechseln.

Idle-Zustand

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);
    }
}

Erklärung

Der Konstruktor public IdleState(Animator animator) nimmt ein Animator-Objekt als Parameter und weist es der animator-Variable der Klasse zu. Die Methode StartState, public override void StartState(), setzt den booleschen Parameter "idle" im Animator auf true und löst damit die Idle-Animation aus. Die Methode EndState, public override void EndState(), setzt den "idle"-Parameter auf false und beendet so die Idle-Animation.

Funktionsweise für unseren Gegner

Wenn der Gegner in den IdleState wechselt, setzt die Methode StartState() den "idle"-Parameter im Animator auf true, wodurch die Idle-Animation gestartet wird und der Gegner untätig erscheint. Verlässt der Gegner den IdleState, setzt die Methode EndState() den "idle"-Parameter auf false, wodurch die Idle-Animation gestoppt und der Gegner auf den Übergang in einen anderen Zustand wie Bewegung oder Angriff vorbereitet wird.

Beispiel-Workflow

Der StateManager setzt den Zustand des Gegners auf IdleState und ruft IdleState.StartState() auf, um den "idle"-Parameter des Animators auf true zu setzen und die Idle-Animation zu starten. Beim Wechsel des Verhaltens des Gegners ruft der StateManager IdleState.EndState() auf, wodurch der "idle"-Parameter auf false gesetzt und die Idle-Animation gestoppt wird. Anschließend wechselt der StateManager den Gegner in einen neuen Zustand, wie z. B. AttackState oder PatrolState.

Durch die Verwendung der IdleState-Klasse wird sichergestellt, dass unser Gegner das Idle-Verhalten reibungslos ein- und ausführen kann, was ihn dynamischer und realistischer macht. Diese Struktur erleichtert zudem das Hinzufügen oder Anpassen des Idle-Verhaltens des Gegners, ohne andere Teile des gegnerischen Codes zu beeinflussen.