### Animation de Saut

Pour le saut, nous aurons deux animations : Comme le joueur va sauter puis tomber, nous devons créer deux animations pour cela. La transition entre elles sera basée sur la "vitesse y" du joueur ; si y est positif, il saute, et si y est négatif, il tombe. Nous pouvons obtenir la vitesse y à partir du composant Rigidbody2D attaché au joueur.

```csharp
animator.SetFloat("JumpingForce", rb.velocity.y);
```
Ce code assigne la valeur pour le paramètre de transition entre le saut et la chute.

### Explication du Code

```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
}
```

Cette ligne vérifie si la touche Espace est enfoncée (`Input.GetKeyDown(KeyCode.Space)`), si le joueur est au sol (`isGrounded`), et si le joueur n'est pas en train d'attaquer (`animator.GetBool("isAttacking") == false`). Si toutes les conditions sont remplies, le bloc de code suivant s'exécutera.

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

Cette ligne ajoute une force vers le haut au composant Rigidbody (`rb`) attaché au joueur, simulant un saut. La force appliquée est dans la direction ascendante (`Vector2.up`) avec une magnitude définie par `jumpForce`, et elle est appliquée de manière impulsive (`ForceMode2D.Impulse`).


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

Cette ligne définit un paramètre booléen **"isJumping"** dans le composant Animator à true, déclenchant l'animation de saut.


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

Cette ligne vérifie si le joueur est actuellement en train de sauter (`animator.GetBool("isJumping") == true`), si la vitesse verticale du joueur est négative (`rb.velocity.y < 0`), et si le joueur est au sol (`isGrounded`). Si toutes les conditions sont remplies, le bloc de code suivant s'exécutera.


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

Cette ligne définit le paramètre booléen **"isJumping"** dans le composant Animator à false, indiquant que le joueur a terminé de sauter et de tomber et changera son animation en mode veille.

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

Cette ligne projette un rayon vers le bas à partir de la position des pieds du joueur (`playerFeet.position`) pour détecter si le joueur est au sol. Elle renvoie vrai si le rayon intersecte un quelconque colliseur dans la couche de sol dans une distance de 0,1 unité, mettant à jour la variable `isGrounded` en conséquence.

Que représente un `raycast` dans Unity ?

Préparez-vous à créer un jeu de combat impressionnant avec des animations cool et une grande bataille contre un boss ! 
Apprenez le système d'animation de Unity pour créer des mouvements fluides et des attaques puissantes.
Plongez dans l'IA ennemie, en façonnant leurs comportements allant du suivi aux états de rage. Améliorez votre jeu avec des éléments d'interface utilisateur simples, des effets cool et des sons. Enfin, partagez votre jeu avec d'autres pour qu'ils puissent y jouer.

Dans ce chapitre, nous allons tout apprendre sur les animations, comment synchroniser les animations avec le mouvement, et comment passer en douceur d'une animation à l'autre.


Nous allons créer un comportement complet pour le joueur et l'animer. Le joueur pourra se déplacer, sauter et attaquer en utilisant différentes techniques, telles que le Rigidbody2D pour le mouvement et les déclencheurs pour les attaques et les interactions.

Nous allons créer l'IA du Boss et définir son comportement en fonction de la proximité du joueur. Lorsque le joueur est à une longue distance, le Boss enverra soit un projectile, soit se déplacera vers le joueur. Si le joueur est à proximité, le Boss attaquera avec son arme. De plus, lorsque la santé du Boss tombe en dessous de 40%, il entrera dans un état de rage et déclenchera des attaques différentes et plus agressives.

Nous allons apporter des améliorations majeures au jeu, notamment en ajoutant des particules et des effets pour améliorer l'ambiance générale. De plus, nous créerons des éléments d'interface utilisateur tels que le menu principal et la barre de santé, et nous assurerons qu'ils sont contrôlables. Enfin, nous exporterons le jeu et le testerons.

Nous allons revisiter le jeu que nous avons créé dans le cours Unity précédent (Flappy Bird) et l'améliorer. Nous ajouterons une génération aléatoire, synchroniserons le mouvement de l'arrière-plan avec le joueur, et déplacerons dynamiquement les obstacles, créant ainsi une expérience de jeu sans fin.


Jeu de Combat dans Unity

Terminer l'Animation du Joueur

Animation de Saut

Explication du Code