### Sprunganimation

Für den Sprung werden wir zwei Animationen haben: Da der Spieler springen und dann fallen wird, müssen wir dafür zwei Animationen erstellen. Der Übergang zwischen ihnen basiert auf der "y-Geschwindigkeit" des Spielers; wenn y positiv ist, springt er, und wenn y negativ ist, fällt er. Wir können die y-Geschwindigkeit aus der Rigidbody2D-Komponente erhalten, die am Spieler angebracht ist.

```csharp
animator.SetFloat("JumpingForce", rb.velocity.y);
```
Dieser Code weist den Wert für den Übergangsparameter zwischen dem Sprung und dem Fall zu.

### Code-Erklärung

```csharp
if (Input.GetKeyDown(KeyCode.Space) && isGrounded && animator.GetBool("isAttacking") == false)
{
    rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
    animator.SetBool("isJumping", true);
}

if (animator.GetBool("isJumping") == true && rb.velocity.y < 0 && isGrounded)
{
    animator.SetBool("isJumping", false);
}

animator.SetFloat("JumpingForce", rb.velocity.y);

isGrounded = Physics2D.Raycast(playerFeet.position, Vector2.down, 0.1f, groundLayer);
```

```csharp
if (Input.GetKeyDown(KeyCode.Space) && isGrounded && animator.GetBool("isAttacking") == false)
{
    // Code to execute when the conditions are met
}
```

Diese Zeile überprüft, ob die Leertaste gedrückt wird (`Input.GetKeyDown(KeyCode.Space)`), der Spieler am Boden ist (`isGrounded`) und der Spieler nicht gerade angreift (`animator.GetBool("isAttacking") == false`). Wenn alle Bedingungen erfüllt sind, wird der folgende Codeblock ausgeführt.

```csharp
rb.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);
```

Diese Zeile fügt der Rigidbody-Komponente (`rb`), die dem Spieler zugeordnet ist, eine Aufwärtskraft hinzu, um einen Sprung zu simulieren. Die angewandte Kraft ist in der Aufwärtsrichtung (`Vector2.up`) mit der durch `jumpForce` definierten Größe und wird impulsiv angewendet (`ForceMode2D.Impulse`).


```csharp
animator.SetBool("isJumping", true);
```

Diese Zeile setzt einen booleschen Parameter **"isJumping"** im Animator-Komponente auf true, wodurch die Sprunganimation ausgelöst wird.


```csharp
if (animator.GetBool("isJumping") == true && rb.velocity.y < 0 && isGrounded)
{
    // Code to execute when the conditions are met
}
```

Diese Zeile überprüft, ob der Spieler derzeit springt (`animator.GetBool("isJumping") == true`), die vertikale Geschwindigkeit des Spielers negativ ist (`rb.velocity.y < 0`) und der Spieler auf dem Boden ist (`isGrounded`). Wenn alle Bedingungen erfüllt sind, wird der folgende Codeblock ausgeführt.


```csharp
animator.SetBool("isJumping", false);
```

Diese Zeile setzt den booleschen Parameter **"isJumping"** im Animator-Komponente auf false, was anzeigt, dass der Spieler das Springen und Fallen beendet hat und seine Animation zu Idle wechselt.

```csharp
isGrounded = Physics2D.Raycast(playerFeet.position, Vector2.down, 0.1f, groundLayer);
```

Diese Zeile wirft einen Strahl von der Position der Füße des Spielers (`playerFeet.position`) nach unten, um zu erkennen, ob der Spieler auf dem Boden steht. Sie gibt true zurück, wenn der Strahl innerhalb einer Entfernung von 0,1 Einheiten mit einem Collider in der Bodenschicht kollidiert und aktualisiert entsprechend die Variable (`isGrounded`).

Bereite dich darauf vor, ein großartiges Kampfspiel mit coolen Animationen und einem großen Bosskampf zu erstellen! 
Lerne das Animationssystem von Unity, um flüssige Spielerbewegungen und kraftvolle Angriffe zu erstellen.
Tauche in die feindliche KI ein und forme ihr Verhalten von Verfolgung bis zu Wutzuständen. Verbessere dein Spiel mit einfachen UI-Elementen, coolen Effekten und Sounds. Teile schließlich dein Spiel mit anderen, damit sie es spielen können.

In diesem Kapitel werden wir alles über Animationen lernen, wie man Animationen mit Bewegungen synchronisiert und wie man sanft zwischen Animationen wechselt.


Wir werden ein vollständiges Verhalten für den Spieler erstellen und es animieren. Der Spieler wird in der Lage sein, sich zu bewegen, zu springen und mit verschiedenen Techniken anzugreifen, wie zum Beispiel dem Rigidbody2D für Bewegungen und Triggern für Angriffe und Interaktionen.

Wir werden die Boss-KI erstellen und ihr Verhalten basierend auf der Nähe des Spielers definieren. Wenn der Spieler weit entfernt ist, wird der Boss entweder ein Projektil senden oder sich auf den Spieler zubewegen. Befindet sich der Spieler in der Nähe, wird der Boss mit seiner Waffe angreifen. Zusätzlich, wenn die Gesundheit des Bosses unter 40% fällt, wird er in einen Wutzustand versetzen und verschiedene, aggressivere Angriffe entfesseln.

Wir werden wesentliche Verbesserungen am Spiel vornehmen, einschließlich der Hinzufügung von Partikeln und Effekten, um das Gesamtgefühl zu verbessern. Zusätzlich erstellen wir UI-Elemente wie das Hauptmenü und die Gesundheitsleiste und stellen sicher, dass sie steuerbar sind. Schließlich exportieren wir das Spiel und testen es.

Wir werden das Spiel, das wir im vorherigen Unity-Kurs (Flappy Bird) erstellt haben, erneut besuchen und verbessern. Wir werden eine zufällige Generierung hinzufügen, die Hintergrundbewegung mit dem Spieler synchronisieren und Hindernisse dynamisch bewegen, um ein endloses Spielerlebnis zu schaffen.


Kampfspiel in Unity

Spieleranimation Abschließen

Sprunganimation

Code-Erklärung