Shooter avancé

Sur cette page tu trouveras le détail des fonctionnalités suivantes :

Crée une Frame d’invincibilité

pré-requis : un jeu où on prend des dégâts (compatible plateformer & shooter), un sprite pour le joueur

Le concept : quand le sprite du joueur enregistre des dégâts, il clignote quelques instants et pendant ce laps de temps il ne peut pas subir de nouveaux dégâts. 

Ajout du comportement Clignotement au sprite du joueur.

Dans la feuille d’événements :

Tu vas ajouter une nouvelle action dans les évènements où le sprite du joueur entre en collision avec un projectile ennemi, afin de faire clignoter le sprite une seconde.

Pour que le joueur soit invincible quand il vient d’être touché, ajoute une nouvelle condition sur ces mêmes événements : le sprite du joueur clignote.

Puis inverse cette condition (clic droit sur la condition > inverser (ou appuie sur i en sélectionnant la condition))

Ainsi, il faut que le vaisseau ne soit pas en train de clignoter pour prendre des dégâts.

Mets en place un système de Power Up ★★

pré-requis : un sprite pour chaque power up

Le concept : le joueur va débloquer différents pouvoirs en ramassant des objets dans le niveau. 

Dans la feuille d’événements :

Commence par créer une variable de type chaîne de caractères. Mets comme valeur initiale “aucun”. Tu vas utiliser cette variable pour savoir quel pouvoir est actif.

Lorsque le sprite du joueur entre en collision avec un Power Up celui-ci est détruit et notre variable change pour contenir le nom de notre pouvoir. À chaque fois que ton joueur débloque un nouveau pouvoir, tu peux choisir comment l’appeler dans ta variable. Fais attention à utiliser la même orthographe quand tu veux vérifier si le joueur a ce pouvoir actif.

Attention :  Selon les pouvoirs, il faudra penser à remettre notre variable sur “aucun” pouvoir, une fois le temps d’activation du pouvoir écoulé. Tu peux aussi mettre un événement pour qu’au démarrage de la scène la variable de pouvoir soit sur “aucun”

Crée une Jauge de durabilité d’un pouvoir

pré-requis : avoir des pouvoirs, utiliser le système de power up, un sprite pour ta future jauge, une variable globale de durabilité des pouvoirs

Le concept : Afficher une barre de durabilité pour indiquer au joueur s’il peuvent encore utiliser un pouvoir. 

Donne le comportement ancre à ton sprite de jauge. 

Dans l’éditeur de sprite, modifie le point d’image d’origine pour le mettre tout à gauche ou tout à droite. (le point d’origine va conditionner dans quel sens ton sprite va s’étendre. Il ira dans la direction opposée. Exemple : s’il est à gauche, la jauge s’étendra vers la droite). 

Pour cela tu peux faire clic droit sur ton origine, puis assigner rapidement et choisir le côté qui te convient le mieux.

Dans la feuille d’événements :

Crée une variable globale de Durabilité des pouvoirs. Tu peux la mettre à 0 par défaut.

Pour que l’affichage de la durabilité soit tout le temps actualisé, tu vas créer un événement dont la condition sera dans général, à chaque tick. 

Puis dans l’action de cet événement, tu vas définir la largeur de ton sprite et indiquer comme taille le nom de ta variable de durabilité.

Comme cette variable peut contenir un petit nombre, tu vas multiplier cette valeur pour que ta jauge soit grande.

Maintenant que ta jauge est prête, il faut modifier tes événements de pouvoir.

Pense à faire en sorte que lorsque le joueur débloque un pouvoir qui a une durabilité, tu ajoutes une action qui définit la variable de durabilité

Tu peux aussi, par exemple, faire en sorte que la durabilité d’un pouvoir diminue à chaque seconde.

Tu peux aussi faire en sorte que lorsque la jauge de durabilité atteint 0, un pouvoir s’arrête. Dans ce cas, il faut bien penser aussi à remettre ta variable de type de pouvoir à “aucun”.

Dans certains cas, pour diminuer ta jauge de durabilité, tu vas devoir vérifier si ton joueur est en train d’utiliser un pouvoir. Tu devras alors créer ou modifier un événement pour vérifier deux conditions. D’abord regarder si ta variable gobale de pouvoir est = au “nom du pouvoir”, puis faire en sorte que toutes les 1 secondes, ta variable de durabilité diminue.

Crée un Dash

pré-requis ( cette version est pour le shooter ) : avoir une jauge de durabilité, avoir un système de power up, l’ajout de la souris ou du clavier pour activer le dash (au choix)

Le concept : tu vas permettre au joueur de débloquer une petite accélération temporaire qu’il pourra activer / désactiver. 

Comme c’est un power up temporaire, réfère-toi aux explications de création des power-ups.
Commence aussi par créer ton système de durabilité avant de faire ton dash. 

Dans la feuille d’événements :

L’obtention du dash  ressemble à ceci :

Activation du Dash : choisis de quelle façon tes joueurs vont activer lseur dash. Dans cet exemple, ce sera quand ils appuient sur le clic droit.
Quand le joueur active le dash, il redéfinit la vitesse maximale du comportement “déplacer vers” de ton sprite. Mets un chiffre plus élevé que sa vitesse normale (tu peux la trouver dans les propriétés de ton sprite)
Tu vas également vérifier que la durabilité du dash n’est pas épuisée. Pour cela ajoute une condition et, dans System, compare ta variable de durabilité pour vérifier qu’elle est supérieure à 0.

Limitation du Dash : il ne faut pas que le sprite du joueur soit ultra rapide quand on n’active pas le dash.

Tu vas donc remettre la vitesse normale (ici 400) quand le joueur n’appuie pas sur le bouton d’activation. Pour cela tu vas créer une condition d’activation du dash que tu vas ensuite inverser, en faisant clic droit => inverser après avoir créé la condition.

Diminuer la durabilité : il faut maintenant faire en sorte que la durabilité diminue quand on utilise le pouvoir. Pour cela crée un nouvel événement dans lequel tu auras 3 conditions :

    • le joueur est en train d’activer le dash,
    • la durabilité est supérieure à 0
    • dans System l’instruction “toutes les X secondes”  permet de diminuer la jauge régulièrement. 

En action, tu vas simplement soustraire des points à ta variable de durabilité.

Mettre fin au Dash : quand le joueur n’a plus de durabilité, il retrouve sa vitesse normale indépendamment du bouton sur lequel il pourrait appuyer.

Crée un ennemi capable de se déplacer

pré-requis : création d’un sprite pour l’ennemi, un sprite de projectile pour l’ennemi (ou réutiliser un projectile d’un autre ennemi)

Ajoute les comportements ligne de mire, tourelle et déplacer vers à ton ennemi.

Ajoute le comportement projectile aux munitions de l’ennemi. 

Dans la feuille d’événements :

Ajoute le vaisseau du joueur en tant que cible de la tourelle (comme pour les ennemis simples du shooter)

Code aussi le déclenchement du tir comme pour les ennemis simple

Ajoute des Points de Vie à ton ennemi avec une variable d’instance ;  tu vas aussi re-coder les collisions avec les munitions du joueur et la perte de ses points de vie.

Donne du mouvement ! Pour cela il faut d’abord que ton ennemi voit le sprite du joueur à l’aide de son comportement Ligne de Mire avant de le suivre grâce à son déplacement vers un objet (le vaisseau)

Enfin, tu peux faire quelques réglages des comportements de l’ennemi : regarde la portée dans la Ligne de mire & dans la Tourelle. Il vaut mieux avoir une plus grande portée pour la ligne de mire que pour la tourelle. Cela permettra à l’ennemi de commencer à bouger un peu avant de tirer (mais ça se teste selon les projets )

Fais apparaître des Ennemis régulièrement

Pré-requis : un sprite pour le spwaner (peut être moche), création d’un sprite pour l’ennemi

Le concept : Tu vas poser à différents endroits de ta scène des points d’apparition depuis lesquels de nouveaux ennemis vont apparaître régulièrement.

Le sprite des spawners peut être rendu invisible quand tu auras fini et testé ton code. Mais pour le moment, je te conseille de remplir ton sprite avec le pot de peinture dans une couleur très vive pour bien les voir. 

Donne le comportement “Cherche Chemin” et Tourelle (optionnel) à ton ennemi. 

Dans la feuille d’événements :

Tes sprites de spawner vont créer des ennemis toutes les X secondes. 

Pour cela, ajoute un événement dont la condition est dans système => toutes les X secondes, et l’action va être que ton spawner fait apparaitre un ennemi. 

Ensuite, tu vas gérer la façon dont les ennemis trouvent leur chemin vers le joueur.  

Pour commencer, on veut que nos ennemis calculent leur chemin à chaque seconde. Donc tu vas créer un événement dont la condition sera “Toutes les 1 secondes”.

Maintenant, il faut que l’ennemi trouve son chemin. 

Tu vas utiliser les expressions pour que l’ennemi trouve son chemin vers la position en X et Y du sprite de ton joueur. Le comportement Cherche Chemin permet au sprite de suivre la route qu’il a trouvée (pas besoin du comportement “Déplacer vers »). 

Les actions de cet événement seront liées à l’ennemi qui va “Trouver Chemin”, et tu pourras alors lui indiquer “nom_du_sprite_joueur.X” et “nom_du_sprite_joueur.Y” comme coordonnées à atteindre.

Enfin, ajoute une dernière action pour que ton ennemi puisse “se déplacer le long du chemin”

Quand tu auras vérifié que tes ennemis fonctionnent bien, tu pourras rendre tes spawners invisibles. Pour cela tu peux simplement aller dans les propriétés du sprite et décocher “visible initialement ».

Crée un bouclier qui arrête les projectiles

pré-requis : avoir un jeu avec des projectiles, peut-être utilisé avec les power up, peut être utilisé avec une jauge de durabilité, un sprite de bouclier (si tu veux un bouclier qui s’use prépare quelques frames d’usure de ton bouclier dans ton sprite). 

Le concept : Le joueur peut activer ou débloquer un bouclier qui se fixe sur lui et le protège des projectiles ennemis.

Donne le comportement : épingle à ton bouclier.

Si tu n’as pas de système de jauge de durabilité, crée une variable d’instance pour ton bouclier. 

Si tu as une jauge de durabilité, tu utiliseras ta variable globale correspondante à la place d’une variable d’instance. 

Dans la feuille d’événements : 

Crée un événement pour débloquer le bouclier (voir ajout de power up).

Si tu n’utilises pas de power up, tu peux choisir que le bouclier apparaisse quand on appuie sur une touche ou qu’on fait un clic particulier. 

Tu auras ainsi une condition de type “lors de la collision avec le power up” ou alors “lorsqu’on fait un clic droit”.

Faire apparaître le bouclier. Dans le même événement, tu vas maintenant ajouter des actions liées à la création du bouclier. Le sprite de ton joueur va faire apparaître le sprite du bouclier, puis, le bouclier va s’épingler à un objet (le sprite du joueur).

Si tu utilises un système de durabilité, pense aussi à définir ta variable de durabilité dans System, tu auras quelque chose de similaire à ceci :

Ensuite quand le bouclier entre en collision avec un projectile ennemi, ce dernier est détruit et notre bouclier perd en durabilité

/!\  si tu as un système de durabilité c’est dans système que tu trouveras ta variable. Si tu n’as pas de système de durabilité, tu vas trouver les actions liées à ta variable d’instance dans le sprite du bouclier. 

Bonus : avoir une usure du bouclier visible. 

En ajoutant une ou deux frames dans l’animation de notre bouclier, on peut montrer qu’il s’use. 

/!\ pense à mettre la vitesse de l’animation à 0

Compare l’état de ta variable de durabilité et change de frame en fonction

Quand le bouclier n’a plus de durabilité il est détruit

Crée un bouclier qui gèle les ennemis

pré-requis : avoir des ennemis qui se déplacent, avoir un jeu avec des projectiles, peut être utilisé avec les power up, peut être utilisé avec une jauge de durabilité,  un sprite de bouclier, si tu veux un bouclier qui s’use prépare quelques frames d’usure de ton bouclier dans ton sprite. 

Le concept : Quand ce bouclier touche un ennemi capable de se déplacer, il lui retire cette capacité temporairement. 

Si tu n’as pas de système de jauge de durabilité, crée une variable d’instance pour ton bouclier. 

Si tu as une jauge de durabilité, tu utiliseras ta variable globale correspondante à la place d’une variable d’instance. 

Tu vas avoir besoin d’ajouter une variable d’instance sur tes ennemis qui bougent. On l’appelle “temps de freeze”, dans mon exemple. C’est grâce à cette variable qu’on va pouvoir maintenir nos ennemis immobiles quelques secondes. 

Dans la feuille d’événements : 

Crée un événement pour débloquer le bouclier (voir ajout de power up)

Si tu n’utilises pas de power up, tu peux choisir que le bouclier apparaisse quand on appuie sur une touche ou qu’on fait un clic particulier. 

Tu auras ainsi une condition de type “lors de la collision avec le power up” ou alors “lorsqu’on fait un clic droit”.

Faire apparaître le bouclier : dans le même événement, tu vas maintenant ajouter des actions liées à la création du bouclier. Le sprite de ton joueur va faire apparaître le sprite du bouclier, puis, le bouclier va s’épingler à un objet (le sprite du joueur).

Si tu utilises un système de durabilité pense aussi  à définir ta variable de durabilité dans système.

Tu auras quelque chose de similaire à ceci :

Geler les ennemis : tu vas créer un événement dont la condition est  » lorsqu’un ennemi est en train de chevaucher le bouclier « . En action, tu vas définir la variable d’instance de “temps de freeze”. Cela va servir à définir combien de temps notre ennemi restera gelé. 

Ensuite, tu vas créer un nouvel événement dans lequel, toutes les secondes on soustrait 1 à la variable de freeze à tous les ennemis qui ont une variable de temps de freeze supérieure à 0.
note : les ennemis qui ont une variable de temps de freeze supérieure à 0 sont en fait ceux qui ont été en contact avec le bouclier.

Modifie le reste du code. Pour que le freeze fonctionne, il faut s’assurer que seuls les ennemis qui ont une variable de freeze à 0 ont le droit de bouger. Tu vas devoir retrouver les événements où tu as créé les déplacements de tes ennemis et y ajouter une condition pour vérifier que leur variable est supérieure à 0.

Fais des tirs en cône

pré-requis : peut être utilisé avec les power up, peut être utilisé avec une jauge de durabilité,  un sprite pour ton projectile ou une frame alternative d’un projectile. 

Le concept : Au moment du tir, le joueur ou l’ennemi va faire apparaître plusieurs balles qui vont partir en cône. 

Tu peux paramétrer des tirs en cône pour le joueur ou les ennemis. 

Donne le comportement projectile à ton sprite. 

Dans la feuille d’événements : 

Si ton tir en cône se débloque avec un power up regarde les explications sur les power up. 

Pour paramétrer le tir en cône tu vas faire en sorte qu’au moment du tir, le sprite qui tire fasse apparaître plusieurs projectiles en même temps qui vont partir dans plusieurs directions.
Pour cela, dans l’action de ton événement,  tu vas définir l’angle du projectile et utiliser une expression pour indiquer le nom du sprite depuis lequel il part (par exemple le vaisseau) et préciser que l’on se base sur l’angle de ce dernier. Ce qui donnera quelque chose comme ceci : Vaisseau.Angle
On va donner des angles différents à chaque projectile. On peut donc avoir :

Vaisseau.Angle+15 /Vaisseau.Angle+0 /Vaisseau.Angle-15

Si ton tir en cône est un pouvoir pense aussi à ajouter une condition pour vérifier que le joueur a débloqué ce pouvoir.
Si ton pouvoir a une durabilité, pense à soustraire des points à ta variable de durabilité à chaque tir.

Fais des tests pour voir si tu veux plus de projectiles, ou si tu veux les faire partir dans des angles plus éloignés. 

/!\ Si le joueur a un autre type de tir, pense à bien ajouter une condition dans les évènements des autres tir pour comparer la variable de pouvoir. Sur le tir de base vérifies que ta variable est sur “aucun” pouvoir.

Crée un tir automatiquement

pré-requis : version shooter, peut être utilisé avec les power up, peut être utilisé avec une jauge de durabilité,  un sprite pour ton projectile ou une frame alternative d’un projectile. 

Le concept : permettre au joueur de tirer automatiquement.

Ajoute le comportement tourelle au sprite du joueur. 

Dans les paramètres de ton sprite, désactive l’option “tourner” de la tourelle car elle va entrer en conflit avec le fait que le sprite tourne en suivant la souris.

Si tu ne veux pas que ton vaisseau ait son tir automatique en permanence, dans les paramètres du comportement décoche le fait qu’il soit actif par défaut. Si tu veux que son tir soit actif tout le temps passe cette étape.

Dans les évènements 

Débloquer le tir : si le tir automatique est un power up dans ton jeu, regarde d’abord comment créer des power up. 

Définir les cibles de la tourelle : crée un événement pour ajouter un objet en tant que cible de ton comportement tourelle. Cet événement aura pour condition “au démarrage de la scène”, sauf si tu utilises un power up. Dans ce cas, tu peux ajouter un objet en tant que cible au moment où le joueur acquiert ce pouvoir. 

Note : si tu as plusieurs ennemis il te faudra une action pour chaque cible.

Gérer le tir : ajoute un nouvel événement pour qu’au moment du tir le sprite du joueur fasse apparaître sa munition. 

Ajoute une seconde action dans cet événement, pour définir l’angle de ta munition.
Afin que la munition parte dans la direction où ton sprite regarde, tu vas utiliser une expression. Dans “trouver des expressions” choisis le sprite de ton joueur, puis choisis Angle. Tu obtiendras “NomDuSpriteJoueur.Angle”

Génère des obstacles solides dans un jeu dirigé à la souris

pré-requis : jeu dirigé à la souris, un ou des sprites pour tes obstacles solides. 

Le concept : Utiliser un comportement qui reconnait les solides pour avoir des obstacles dans son jeu, sans avoir à programmer tout un système de collision. 

Ajoute le comportement solide sur tes obstacles.

Puis ajoute le comportement 8 directions sur le sprite du joueur. 

Attention ! Le comportement 8 directions est capable de détecter les collisions avec les objets “solides”. C’est uniquement pour cela qu’on va l’ajouter à notre sprite. Cependant, on ne veut pas utiliser ses autres propriétés. Dans les propriétés du comportement, tu vas désactiver la case “Contrôles par défaut”.

Si tu as des ennemis qui se déplacent et que tu veux aussi que les obstacles solides les arrêtent, tu vas devoir regarder aussi les propriétés de leur comportement. Fais attention à sélectionner ton ennemi dans la fenêtre de ton projet (à droite de base) pour que tes changements affectent TOUS les ennemis et non un seul que tu aurais sélectionné dans ta scène. 

Vérifie que leur ligne de mire reconnaît les obstacles solides

Vérifie que le comportement Déplacer Vers est actif pour “s’arrêter sur les solides”

Note : tu pourrais aussi décider d’activer l’option s’arrêter sur les solides du comportement “déplacer vers” de ton joueur. Cependant, il arrive parfois que les collisions avec les solides laissent ton joueur un peu “collé” contre les obstacles. En utilisant la méthode du 8 directions ce problème disparaît. Tu pourrais aussi décider de donner le comportement 8 direction à tous tes ennemis en le paramétrant comme celui du joueur. 

Crée des satellites sur orbite

pré-requis : jeu dirigé à la souris,  compatible avec power up,  un sprite pour nos satellites, il faudra créer un sprite pour nos satellites

Le concept : le joueur est entouré par un ou des petits satellites

Ajoute le comportement orbite à ton satellite

Attention, sélectionne le sprite dans le dossier du projet à droite pour que toutes les instances du sprite possède cette variable.

Dans les évènements 

Si power up voir explication power up.

Activation. quand les satellites s’activent (voir powerup ou mettre “au démarrage de la scène), ajoute une action pour que le sprite de ton joueur crée un satellite

Définir les paramètres du satellite. Tu vas devoir créer chaque petit satellite les uns après les autres. Tu peux en profiter pour leur donner des paramètres un peu différents.

Ajoute une nouvelle action dans l’événement où tu fais apparaître les satellites, dans taille et position, choisi “définir la taille” pour paramétrer la taille du satellite. 

Ajoute ensuite une action liée au comportement orbite pour “définir la cible”. Tu vas y mettre les expressions de la position en X et Y du sprite de ton joueur. Tu auras quelque chose comme “MonSprite.X” et “MonSprite.Y”

Ajoute une nouvelle action, toujours liée au comportement orbite, pour définir le rayon. Si tu mets le même nombre en rayon primaire et rayon secondaire, ton satellite aura une orbite en cercle parfait. Si tu mets des nombres différents il suivra une trajectoire plus ovale. 

Enfin, ajoute une dernière action pour définir les paramètres de ton satellite. Toujours en lien avec le comportement orbite, tu vas définir la vitesse.

Teste tes satellites pour affiner leur réglages.

Définit la valeur de la variable d’instance de point de vie du satellite à 1.

Ajoute une action de système pour attendre quelques instants entre la création de chaque satellite. Tu peux mettre une attente de 0.2 ou 0.5  secondes. Cette attente permet simplement à tes différents satellites de ne pas se superposer quand tu les crée. 

Répète les opérations 2 et 3 autant de fois que tu veux avoir de petits satellites. Tu peux changer les paramètres de l’étape 2 pour avoir des satellites de taille ou d’orbite différents par exemple.

Avoir des satellites qui suivent le joueur. Pour que les satellites suivent le sprite du joueur qui est mouvement, tu vas créer un nouvel événement. À chaque tick (dans système), le satellite va définir sa cible avec la position en X et en Y du sprite du joueur (comme à l’étape 2)

Ajoute un événement par ennemi pour faire en sorte que lorsque le satellite entre en collision avec un ennemi, l’ennemi perd un point de vie, et le satellite perd un point de vie.

Ajoute un dernier événement pour comparer la variable d’instance de ton satellite et vérifier quand les points de vie arrivent à 0. En conséquence, le satellite est détruit. 

Bonus : crée des satellites qui tirent ! ★

pré-requis : jeu dirigé à la souris,  compatible avec power up, un sprite de munition. 

Le concept : les satellites qui entourent le joueur sont capables de tirer automatiquement sur des ennemis !

Ajoute le comportement tourelle à tes satellites. 

Dans les évènements 

Au moment de la création de tes satellites ajoute des actions liées au comportement tourelle afin d’ajouter un objet en tant que cible. Répète cette action autant de fois que tu as de type d’ennemi que le satellite va devoir viser. 

Puis définit la portée du comportement tourelle de ton satellite pour t’assurer qu’il va repérer les ennemis de loin !

Enfin ajoute un événement pour qu’au moment du tir de la tourelle, ton satellite crée son projectile. 

Puis, définis l’angle du projectile. Utilise les expressions pour que le projectile adopte l’angle de ton satellite comme ceci : “Satellite.Angle”

Crée un tir qui gèle

pré-requis : avoir des ennemis qui se déplacent,  compatible avec power up, compatible avec jauge de durabilité, il faudra créer un sprite de projectile qui gèle, et en bonus tu peux créer une frame ou une animation pour les ennemis gelé

Le concept : Un projectile spécial qui arrête les déplacements des ennemis.

Donne le comportement projectile à ta munition spéciale. 

Si tu as fais un bouclier qui gèle tu peux passer l’étape suivante :

Tu vas avoir besoin d’ajouter une variable d’instance de type nombre sur tes ennemis qui bougent. Je l’ai appelé “temps de freeze”, dans mon exemple. C’est grâce à cette variable qu’on va pouvoir maintenir nos ennemis immobiles quelques secondes. 

Dans les évènements 

Crée un événement pour débloquer le tir qui gèle (voir ajout de power up)

Si tu utilises un système de durabilité, pense à remonter la variable globale qui correspond. 

Le tir. Ajoute un événement pour déclencher le tir de ton projectile. 

Si tu n’utilises pas de power up vérifie simplement que tu n’utilises pas la même touche que pour ton tir classique (par exemple utilise lors d’un clic sur le bouton droit). 

Si tu utilises un power up, ajoute une seconde condition, pour vérifier que ton joueur a sa variable de pouvoir sur le “tir gelé”, par exemple.

Ajoute en action le fait que le sprite du joueur fasse apparaître un objet : le projectile.

Geler les ennemis ! Tu vas créer un événement dont la condition est lorsqu’un ennemi est en collision avec le projectile. En action, tu vas définir la variable d’instance de “temps de freeze”. Cela va servir à définir combien de temps notre ennemi restera gelé.  Ajoute une action pour détruire le projectile.

/!\ Si tu as déjà créer le bouclier qui gèle les ennemis, saute cette étape :

Ensuite, tu vas créer un nouvel événement dans lequel, toutes les secondes on soustrait 1 à la variable de freeze à tous les ennemis qui ont une variable de temps de freeze supérieur à 0.
note : les ennemis qui ont une variable de temps de freeze supérieure à 0 sont en fait ceux qui ont été en contact avec le bouclier.

/!\ Si tu as déjà créer le bouclier qui gèle les ennemis, saute cette étape :

Modifier le reste du code. Pour que le freeze fonctionne, il faut s’assurer que seuls les ennemis qui ont une variable de freeze à 0 ont le droit de bouger. Tu vas devoir retrouver les événements où tu as créé les déplacements de tes ennemis et y ajouter une condition pour vérifier que leur variable est supérieure à 0.

Retour en haut