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

Die Klasse Projectile ist für die Verwaltung des Verhaltens von Projektilen verantwortlich, die der Gegner auf den Spieler abfeuern kann. Diese Klasse übernimmt das Festlegen der Richtung und Geschwindigkeit des Projektils, die Aktualisierung seiner Bewegung sowie die Behandlung von Kollisionen.

Setup-Methode

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

Zweck: Diese Methode legt den Anfangszustand des Projektils fest.

Parameter: Nimmt einen Parameter Vector2 direction entgegen, um die Richtung festzulegen, in die das Projektil fliegen wird.

Aktionen: Legt die Richtung des Projektils fest, ruft die an das Projektil angehängte Komponente Rigidbody2D ab, dreht das Projektil in die Flugrichtung und plant die Zerstörung des Projektils nach 6 Sekunden, um ein unbegrenztes Bestehen zu verhindern.

Update-Methode

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

Zweck: Diese Methode aktualisiert die Bewegung des Projektils.

Vorgänge: Setzt die Geschwindigkeit des Rigidbody2D, um das Projektil in die angegebene Richtung mit der angegebenen Geschwindigkeit zu bewegen.

OnTriggerEnter2D-Methode

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

Zweck: Diese Methode verarbeitet Kollisionen mit anderen Objekten.

Parameter: Nimmt einen Collider2D collision-Parameter entgegen, um Kollisionen zu erkennen.

Vorgänge: Gibt den Namen des Objekts aus, mit dem das Projektil kollidiert ist, prüft, ob das Projektil mit einem Objekt mit dem Tag "Player" kollidiert ist, und ob das Objekt eine Komponente besitzt, die das IGetAttacked-Interface implementiert. In diesem Fall wird die Methode GetAttacked auf dieser Komponente aufgerufen, um Schaden zu verursachen. Abschließend wird das Projektil nach dem Treffer zerstört.

Warum wir es so umgesetzt haben

Modular und wiederverwendbar: Die Projectile-Klasse ist modular und wiederverwendbar gestaltet, sodass sie für beliebige Projektiltypen des Gegners eingesetzt werden kann. Durch das Setzen von Richtung und Geschwindigkeit können verschiedene Projektile mit unterschiedlichen Verhaltensweisen erstellt werden.

Effiziente Bewegungssteuerung: Die Verwendung der Rigidbody2D-Komponente für die Bewegung stellt sicher, dass sich das Projektil gemäß dem Physiksystem von Unity verhält und eine flüssige sowie realistische Bewegung aufweist.

Kollisions- und Schadensbehandlung: Die Methode OnTriggerEnter2D sorgt dafür, dass das Projektil Kollisionen mit dem Spieler erkennt und den Schaden korrekt anwendet, wodurch die Interaktion zwischen Projektil und Spieler effektiv gestaltet wird.

SendProjectileState Klasse

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

Die Klasse SendProjectileState ist ein spezifischer Zustand, der das Verhalten des Gegners beim Abschuss eines Projektils steuert. Diese Klasse erbt von der Klasse State und enthält Methoden zum Starten, Beenden und Auslösen der Projektilangriffsaktion.

Konstruktor

Der Konstruktor initialisiert die SendProjectileState mit einem Animator für Animationen und einer Aktion zum Senden des Projektils. Diese Werte werden den entsprechenden Member-Variablen zugewiesen.

StartState-Methode

Diese Methode setzt isStateFinished auf false und startet die Projektil-Animation, indem der boolesche Parameter "projectil" im Animator auf true gesetzt wird.

StartAction-Methode

Diese Methode ruft sendProjectileFunc auf, welche die für das Senden des Projektils definierte Aktion ausführt. Diese Methode wird typischerweise von einem Animator-Event aufgerufen, um den Abschuss des Projektils mit der Animation zu synchronisieren.

EndState-Methode

Diese Methode stoppt die Projektil-Animation, indem der boolesche Parameter "projectil" im Animator auf false gesetzt wird.

Warum wir es so gemacht haben

Modular und wiederverwendbar: Die Klasse SendProjectileState ist modular aufgebaut und ermöglicht durch die Verwendung von System.Action eine flexible Integration verschiedener Verhaltensweisen zum Abschießen von Projektilen.

Animationseinbindung: Durch die Nutzung von Animator-Parametern stellt der Zustand sicher, dass das Abschießen des Projektils mit der entsprechenden Animation synchronisiert ist und so ein flüssiges und realistisches Erlebnis bietet.

Funktion zum Abschießen von Projektilen

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

Die Methode SendProjectile ist dafür verantwortlich, ein Projektil zu erzeugen und auf den Spieler abzufeuern. Diese Methode berechnet die Richtung vom Gegner zum Spieler, instanziiert das Projektil und richtet es so aus, dass es sich in die berechnete Richtung bewegt.

Methodendefinition und Komponenten

Methodendefinition: void SendProjectile(): Diese Methode gibt keinen Wert zurück und ist dafür vorgesehen, den Abschuss des Projektils zu steuern.

Komponenten: Vector2 direction = (player.position - transform.position).normalized; Diese Zeile berechnet die Richtung vom Gegner zum Spieler, indem die Position des Gegners von der Position des Spielers subtrahiert wird. Der Teil .normalized stellt sicher, dass der Richtungsvektor die Länge 1 hat, also ein Einheitsvektor ist, der nur die Richtung angibt.

Instantiate(projectile, projectileSendingPosition.position, Quaternion.identity).Setup(direction); Diese Zeile erzeugt eine neue Instanz des Projektils an der angegebenen Position (projectileSendingPosition.position) ohne Rotation (Quaternion.identity). Die Methode Setup wird am instanziierten Projektil aufgerufen, um dessen Richtung festzulegen.

Verknüpfung mit dem Unity Animator

Die Funktion StartAction wird mithilfe von Animator-Events aufgerufen. Dadurch kann genau der Frame innerhalb der Animation des Gegners festgelegt werden, in dem das Projektil abgeschossen werden soll. Da die Animation aus vielen Frames besteht, ist es wichtig, den exakten Zeitpunkt für diese Aktion zu bestimmen.