Share
Dans cet article, nous allons commencer par les bases du système de particules GameMaker Studio et par des techniques et des implémentations avancées. Pensez-y comme à un cours intensif pour vous familiariser et vous familiariser avec l'une des fonctionnalités intégrées les plus puissantes de GameMaker Studio. La démo et le fichier de projet téléchargeable vous permettront de suivre l’article pour voir exactement en quoi consiste le système de particules..
Le système de particules GameMaker Studio est un moyen simple et peu coûteux de créer des effets flashy pour votre projet de jeu. Grâce à une combinaison de particules et d'émetteurs, vous pouvez rapidement créer des explosions impressionnantes, de la fumée, du sang, des éclats d'obus et d'innombrables autres effets. Des effets similaires peuvent être obtenus en utilisant des objets individuels, mais le coût en informatique du système à effets de particules intégré est beaucoup moins cher..
Pour utiliser le système de particules dans votre projet, vous devez comprendre le langage GML (GameMaker Language), mais une fois que vous vous êtes familiarisé avec le système de particules, il vous suffit de remplir les blancs et d'expérimenter..
Regardez la démo ci-dessous pour voir ce que nous pouvons réaliser:
Les systèmes de particules dans GameMaker Studio se composent de trois parties: le système lui-même, la particule et l'émetteur. Vous pouvez créer plusieurs systèmes, et chaque système peut contenir plusieurs particules et émetteurs. Pensez au système comme un conteneur, avec les particules et les émetteurs définis dans.
L'implémentation d'un effet de particules dans GameMaker Studio est un processus en quatre étapes..
Pour vous apprendre les bases du système de particules GameMaker Studio, nous allons commencer par créer cet effet de particule vert très simple..
La création du système de particules est aussi simple que de définir une variable. Nous créons un objet appelé obj_first_particle et placez le code suivant dans l'événement Create de l'objet:
FirstParticleSystem = part_system_create ();
Le système de particules adoptera la valeur de profondeur de l'objet dans lequel le système est défini, mais vous pouvez également définir la profondeur séparément avec GML:
part_system_depth (FirstParticleSystem, 0);
Rappelez-vous que les objets et les systèmes de particules avec une valeur de profondeur élevée sont d'abord affichés à l'écran. Avec une profondeur de 0, notre système de particules vert apparaîtra au-dessus des objets d'une profondeur supérieure à 0, et apparaîtra au-dessous des objets avec une profondeur inférieure à 0.
Les systèmes de particules sont attirés vers l'écran avec une position de base par rapport à (0,0). Si, pour une raison quelconque, vous souhaitez créer un décalage pour toutes les positions futures de ce système de particules, vous pouvez utiliser le code suivant pour créer une nouvelle position de base (où Indiana est le système de particules):
part_system_position (ind, x, y);
Avec une nouvelle position de base réglée sur (10,10), une particule créée à (25,25) sera plutôt attiré à (35,35). Il est rarement nécessaire de modifier la position de base d'un système de particules, mais cela peut s'avérer utile dans votre projet spécifique..
Maintenant que le système est configuré, il est temps de définir la particule que l'émetteur va créer. Les particules peuvent contenir un grand nombre de paramètres qui déterminent son apparence et son comportement. La première étape consiste à créer une variable pour la particule, et nous le faisons dans le Créer événement du obj_first_particle objet:
first_particle = part_type_create ();
Ensuite, nous commençons à définir les paramètres individuels de la particule. Puisque nous ne prévoyons pas de modifier cette particule pendant son exécution, nous pouvons placer tout de ce code dans le Créer événement du obj_first_particle objet.
part_type_shape détermine la forme de base de la particule. Il existe 14 formes de particules par défaut disponibles dans GameMaker Studio, et vous pouvez également définir vos propres formes. Nous allons couvrir cela dans la section avancée ci-dessous, mais pour l'instant commençons par un carré de base.
part_type_shape (first_particle, pt_shape_square);
Pour une liste complète des formes par défaut disponibles, consultez la documentation officielle de GameMaker..
Avec part_type_scale, nous pouvons définir les valeurs d'échelle de base X et Y de la forme de la particule. Puisque nous voulons une forme carrée parfaite, nous utilisons le code suivant:
part_type_scale (first_particle, 1,1);
part_type_size nous permet de modifier la taille de la particule à la création et dans le temps. Le format de ce code est part_type_size (ind, size_min, size_max, size_incr, size_wiggle).
Accentsconagua
Indiana est la variable de particule. taille_min et taille_max déterminer la plage de la taille de la particule lors de sa création. Si vous voulez une taille uniforme, entrez simplement la même valeur pour les valeurs min et max.. size_incr est une valeur qui permet à la particule de croître ou de se réduire avec le temps. Cette valeur détermine la vitesse de croissance. Si vous ne voulez pas que votre image-objet change de taille, vous pouvez utiliser une valeur de 0. size_wiggle est légèrement plus compliqué, nous allons donc couvrir cela dans la section techniques avancées ci-dessous.Voici le code de taille de particule utilisé dans notre effet de particule verte:
part_type_size (first_particle, 0.10,0.15, -. 001,0);
La particule sera créée avec une taille quelque part entre 0,10 et 0,15 pour créer de la variété, et le sprite va lentement diminuer à une vitesse de -0,001. Cette valeur de vitesse dépend en grande partie de la vitesse de votre pièce. Vous devrez donc probablement expérimenter ces valeurs pour obtenir les résultats souhaités. Nous n'utiliserons aucune taille, donc nous avons défini la valeur sur 0.
Les particules dans GameMaker Studio peuvent en réalité changer de couleur au fil du temps. Ceci est réalisé avec part_type_color2 et part_type_color3. Si vous ne voulez pas que votre image-objet change de couleur, vous pouvez simplement utiliser part_type_color1. Pour notre effet de particule verte, nous voulons qu’il commence avec une couleur jaune / vert vif, puis passe à une couleur verte unie. Nous utilisons donc part_type_color2:
part_type_color2 (first_particle, 8454143,65280);
Les deux couleurs que j'ai sélectionnées sont des valeurs numériques spécifiques que j'utilise régulièrement, mais si vous souhaitez utiliser des valeurs hexadécimales plus traditionnelles, vous pouvez utiliser le format. $ RRGGBB.
Les particules peuvent également devenir plus ou moins transparentes avec le temps. part_type_alpha2 et part_type_alpha3. Si vous voulez une valeur alpha cohérente, utilisez part_type_alpha1. Pour notre effet de particule verte, nous voulons que la particule soit complètement opaque et disparaisse progressivement de 25% à mesure qu'elle reste à l'écran. Nous avons donc besoin de deux valeurs alpha:
part_type_alpha2 (first_particle, 1,0,75);
Dans GameMaker, alpha est une valeur de 0 à 1. Un objet totalement invisible aura une valeur alpha de 0, tandis qu'un objet complètement opaque aura une valeur alpha de 1..
La vitesse des particules est déterminée comme la taille des particules. Les particules sont créées dans une plage de valeurs de vitesse et cette valeur peut augmenter ou diminuer. Le format de ce code est part_type_speed (ind, speed_min, speed_max, speed_incr, speed_wiggle), où Indiana est la variable de particule, speed_min et speed_max est la plage de vitesse, speed_incr est la vitesse à laquelle la vitesse de la particule change, et speed_wiggle est un paramètre que nous couvrirons plus tard.
Le code de vitesse pour notre particule verte est:
part_type_speed (first_particle, 0.1,0.5,0,0);
Notre particule commencera à se déplacer avec une valeur de vitesse quelque part entre 0,1 et 0.5. Cette vitesse restera constante, nous utilisons donc une valeur de 0, et nous n'utiliserons à nouveau pas la vitesse de manoeuvre, nous utilisons donc une valeur de 0.
Alors que le paramètre de vitesse d'une particule détermine sa vitesse de déplacement, le paramètre de direction détermine son déplacement. Le code de direction est au format suivant: part_type_direction (ind, dir_min, dir_max, dir_incr, dir_wiggle) et encore une fois, nous définissons la variable, la plage de départ, une valeur incrémentielle et une valeur tremblante. Pour l'effet de particule verte, nous voulons que notre particule commence à se déplacer dans n'importe quelle direction, et que cette direction reste constante:
part_type_direction (first_particle, 0,359,0,0);
La plage de 0 à 359 garantit que la particule a la possibilité de se déplacer dans n’importe quelle direction (angle compris entre 0 et 359 degrés). Si vous vouliez qu'une particule monte et seulement vous utiliseriez alors une plage de 90 à 90).
La gravité de notre effet de particules est ce qui le rend le plus intéressant. Alors que nos paramètres de vitesse et de direction sont définis pour créer une particule qui commence par se déplacer dans une direction à une vitesse constante, le paramètre de gravité intervient et la modifie avec le temps. Avec un format de part_type_gravity (ind, grav_amount, grav_direction), le paramètre de gravité est très simple:
part_type_gravity (first_particle, 0.02,90);
En appliquant une légère attraction gravitationnelle de 0,02 vers le haut (90 degrés), nous pouvons créer une particule qui semble flotter. Combinée à nos paramètres de taille et alpha, la particule se rétrécit et devient plus transparente au fil du temps, accompagnée par la portance gravitationnelle..
L’orientation de la forme des particules est également importante pour l’apparition de l’effet, nous utilisons donc part_type_orientation (ind, ang_min, ang_max, ang_incr, ang_wiggle, ang_relative) faire pivoter le carré dans le temps.
Indiana est la variable de particule. ang_min et ang_max déterminer la valeur de départ de la valeur de rotation de la forme.ang_incr est utilisé pour incrémenter ou décrémenter l'orientation de la forme dans le temps.ang_relative est une valeur booléenne pour déterminer si l'orientation doit être définie par rapport au mouvement de la particule (true) ou non (false). Nous voulons que notre particule verte tourne légèrement vers la gauche, nous utilisons donc le code suivant:
part_type_orientation (first_particle, 0,359,10,0, true);
L'un des paramètres les plus importants d'une particule est la durée de vie valeur. Cette valeur détermine la durée minimale et maximale d'affichage d'une particule à l'écran. Avec deux valeurs min et max identiques, toutes les particules de ce type existeront pendant le même temps. Nous voulons que nos particules vertes soient variées. Nous allons donc utiliser une plage de 100 à 150 pour la durée de vie:
part_type_life (first_particle, 100,150);
Le paramètre final pour les particules est un simple booléen permettant de déterminer si les particules doivent se mélanger avec un effet de mélange additif:
part_type_blend (first_particle, true);
La première étape pour définir un émetteur consiste à créer une variable. Nous définissons cet émetteur dans l'événement Create du obj_first_particle objet.
first_emitter = part_emitter_create (FirstParticleSystem);
Ensuite, nous définissons la région d'émetteur avec part_emitter_region (ps, ind, xmin, xmax, ymin, ymax, forme, distribution).
ps est le système de particules auquel appartient l'émetteur et Indiana est la variable émetteur.forme détermine la forme de la région d'émetteur (ps_shape_rectangle, ps_shape_ellipse, ps_shape_diamond, ps_shap_line). Distribution est une courbe de distribution (ps_dist_linear, ps_distr_gaussian, ps_distr_invgaussian).Nous verrons plus en détail les paramètres de forme et de répartition dans la section Techniques avancées. Pour le moment, nous allons utiliser les valeurs par défaut de la forme d’ellipse et de la distribution gaussienne:
part_emitter_region (FirstParticleSystem, premier_émetteur, x-20, x + 20, y-20, y + 20, ps_shape_ellipse, ps_distr_gaussian);
Ce code crée une région émettrice elliptique de 40 pixels de haut et 40 pixels de large, centrée sur les valeurs x et y du obj_first_particle objet. Les particules créées par l'émetteur apparaîtront dans cette région définie.
L'étape suivante consiste à déterminer l'un des deux types d'émetteur: Burst ou Stream. Un émetteur en rafale crée une quantité spécifiée d'une certaine particule chaque fois qu'elle est déclenchée. Un émetteur de flux crée une quantité spécifiée d'une particule donnée une fois par étape.
Nous allons examiner les émetteurs Burst les plus polyvalents dans la section sur les techniques avancées. Pour le moment, utilisons simplement l'émetteur Stream:
part_emitter_stream (FirstParticleSystem, first_emitter, first_particle, 1);
Nous plaçons ce code dans le Créer événement du obj_first_particle l’émetteur crée une particule à chaque étape dès que l’objet est créé. Avec une vitesse ambiante de 30, notre émetteur créera 30 particules par seconde; pour créer 60 particules par seconde, vous utiliseriez simplement une valeur de 2 au lieu de 1.
Et avec cela, notre simple effet de particule verte est complet! L'utilité de cet effet est limitée, mais il est important de commencer modestement avant de plonger dans les aspects les plus compliqués du système de particules GameMaker Studio. Une fois que vous avez compris les bases du système de particules, vous pouvez commencer à mettre en œuvre des systèmes de particules plus avancés..
Wiggle est un paramètre simple mais puissant qui peut changer radicalement l’aspect de vos particules. Le paramètre wiggle amène la particule à osciller entre les valeurs minimale et maximale pour la durée de vie de la particule. La valeur peut être comprise entre 0 et 20 et détermine la vitesse du wiggle.
L’exemple "Fire Bubble" de la démo intégrée utilise une valeur de glissement de 0,40 dans le part_type_size paramètre:
part_type_size (fire_bubble_part, 0.25,0.75, -0.01,0.40);
L'une des implémentations les plus courantes des systèmes de particules implique des particules émanant de derrière un objet en mouvement, tel qu'une traînée de fumée sur une fusée. Pour atteindre cet effet dans GameMaker Studio, un émetteur Burst doit être placé dans un objet. Étape un événement.
L'exemple inclus utilise le même système de particules vert qu'auparavant, mais avec un émetteur légèrement modifié. Au lieu de déclencher un émetteur de flux dans l'objet Créer événement, un émetteur Burst est placé dans l'objet Étape un événement. La position actuelle du curseur de la souris est comparée à la position précédente du curseur et, en cas de changement de la position du curseur, l’émetteur Burst est déclenché pour libérer cinq particules:
x = souris_x; y = mouse_y; part_emitter_region (MouseParticle, green_mouse_emitter, x, x, y, y, 0,0); si x! = old_x || old_y! = y part_emitter_burst (MouseParticle, green_mouse_emitter, green_mouse_particle, 5); old_x = x; old_y = y;
En utilisant différentes formes d’émetteur et courbes de distribution, vous pouvez créer des effets très différents. La distribution linéaire des courbes associée à un émetteur de particules en forme de ligne peut créer un effet de pluie convaincant.
part_emitter_region (RainParticle, rain_emitter, -100, room_width, y, y, ps_shape_line, ps_distr_linear);
La forme de l'émetteur est définie par une ligne commençant par 100 pixels à gauche de l'origine de la pièce et s'étendant jusqu'à la largeur de la pièce. Une courbe de distribution linéaire est utilisée pour répartir les particules de pluie de manière uniforme dans la région de l'émetteur. Il est également utile d'utiliser part_system_update faire avancer la particule de pluie plusieurs étapes dans la Créer un événement. Ce code donne l’impression que la pluie tombait avant le chargement de la pièce, même si le système de particules n’existait pas encore dans la mémoire..
repeat (room_speed * 3) part_system_update (RainParticle);
Les particules individuelles d'un système peuvent également engendrer d'autres particules sur Étape et Mort événements. L'exemple montre une particule d'étincelle pourpre qui engendre des particules de poussière plus petites lorsqu'elle se déplace vers la droite et engendre une particule de fumée à la fin de sa durée de vie:
part_type_step (spark_particle, 1, dust_particle); part_type_death (spark_particle, 5, smoke_particle);
En utilisant part_type_sprite (ind, sprite, animate, stretch, random), vous pouvez utiliser des sprites personnalisés à la place des types de particules GameMaker intégrés.
Indiana est la variable de particule.lutin est la variable sprite à utiliser.animer est un booléen pour déterminer si les sous-images doivent être animées.étendue est un booléen qui fait correspondre la longueur de l'animation à la durée de vie de la particule. au hasard est un booléen pour déterminer si la sous-image de départ doit être sélectionnée de manière aléatoire.part_type_sprite (heart_particle, spr_heart, false, false, false);
La chose la plus importante à retenir sur le système de particules GameMaker Studio est que vous devez supprimer manuellement les éléments de la mémoire lorsqu'ils ne sont pas utilisés. Contrairement aux objets de jeu standard, les systèmes de particules resteront en mémoire même si vous changez de salle. Le moyen le plus simple consiste à placer le code de gestion de la mémoire dans la salle en modifiant les événements de vos objets de jeu..
système_de_partage (ind): Efface tous les émetteurs et particules appartenant à un système de particules spécifique.système_de_partage (ind): Efface toutes les occurrences d'un type de particule spécifique.part_emitter_clear (ps, ind): Efface toutes les particules appartenant à un émetteur spécifique.part_emitter_destroy (ps, ind): Détruit un émetteur spécifique dans un système de particules spécifique.part_emitter_destroy_all (ps): Détruit tous les émetteurs d'un système de particules spécifique.part_type_destroy (ind): Détruit un type de particule spécifique.part_system_destroy (ind): Détruit tout un système de particules, y compris toutes les particules et les émetteurs contenus dans.Même avec un didacticiel aussi long, nous n'avons encore qu'effleuré les effets du système de particules GameMaker Studio. La clé de la maîtrise des particules réside dans la familiarité et l'expérimentation, alors lancez-vous et créez vos propres effets en utilisant les connaissances acquises. N'oubliez pas de consulter la documentation officielle de GameMaker pour afficher tous les systèmes de particules GML disponibles.!
