La classe `Obstacle` gère les obstacles dans le jeu, en s'assurant qu'ils se repositionnent lorsqu'ils sortent de l'écran pour maintenir un gameplay continu.

## Méthodes

**Méthode Start**

```csharp
private void Start()
{
    lastObject = startingLastObject;
    player = FindAnyObjectByType<PlayerMVT>().transform;
}
```

**But** : Initialise le dernier obstacle et trouve le transform du joueur.


**Comment ça fonctionne** :
`lastObject = startingLastObject;` : Définit `lastObject` à l'obstacle initial spécifié dans l'Inspecteur ;
`player = FindAnyObjectByType<PlayerMVT>().transform;` : Trouve le transform du joueur en utilisant la méthode `FindAnyObjectByType`.

**Méthode OnBecameInvisible**

```csharp
private void OnBecameInvisible()
{
    if (player == null) return;
    if (transform.position.x >= player.position.x) return;
    if (transform == lastObject) return;

    Vector2 position = transform.position;
    float random = Random.Range(0, 100);

    if (random <= 50)
    {
        position.y = Random.Range(-2, 1);
    }
    else
    {
        position.y = Random.Range(15, 18);
    }

    position.x = lastObject.position.x + Random.Range(6f, 10f);
    transform.position = position;
    lastObject = transform;
}
```

**But** : Repositionne l'obstacle lorsqu'il sort de l'écran et remplit certaines conditions.

**Comment ça fonctionne** :
Le script s'assure que le joueur existe avant de continuer (`if (player == null) return;`), vérifie que l'obstacle est positionné derrière le joueur (`if (transform.position.x >= player.position.x) return;`), et empêche le repositionnement consécutif (`if (transform == lastObject) return;`). 

Il récupère la position actuelle de l'obstacle (`Vector2 position = transform.position;`), génère un nombre aléatoire (`float random = Random.Range(0, 100);`), et ajuste la position y de l'obstacle en fonction du nombre aléatoire. 

Ensuite, il met à jour la position x par rapport au dernier obstacle (`position.x = lastObject.position.x + Random.Range(6f, 10f);`), et met à jour `lastObject` pour faire référence à l'obstacle actuel (`lastObject = transform;`).

## Résumé

- **Initialisation** : Définit le dernier obstacle initial et trouve le joueur ;
- **Repositionnement** : Lorsqu'un obstacle sort de l'écran et répond à des conditions spécifiques, il est repositionné à une distance aléatoire devant le dernier obstacle avec une hauteur aléatoire ;
- **Conditions** : Assure que les obstacles ne sont repositionnés que s'ils sont derrière le joueur, et non le même obstacle de manière répétée.


Cette configuration permet un flux continu d'obstacles dans le jeu, maintenant le défi et la variété pour le joueur.

Qu'est-ce qui détermine la nouvelle position y de l'objet lorsqu'il devient invisible et est repositionné ?

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

Obstacles Générés Aléatoirement.

Méthodes

Résumé