Ajout d'effets spéciaux aux jeux Pygame: systèmes de particules et améliorations visuelles

Pygame est une bibliothèque populaire pour développer des jeux en Python. Lors de la création de jeux, l'ajout d'effets spéciaux peut grandement améliorer l'attrait visuel et l'expérience globale des joueurs.

Les systèmes de particules sont une technique puissante pour créer des effets dynamiques et visuellement intéressants tels que des nuages ​​de poussière, des explosions, du brouillard, etc.

Créer un jeu simple

Avant de plonger dans les systèmes de particules et les améliorations visuelles, commencez par créer un jeu simple à l'aide de Pygame. Créer un nouveau fichier nommé jeu-simple.py et commencez par importer les bibliothèques nécessaires et initialisez Pygame. Configurez la fenêtre de jeu avec une largeur et une hauteur spécifiées.

Le code utilisé dans cet article est disponible dans ce Référentiel GitHub et est libre d'utilisation sous la licence MIT.

À l'intérieur de la boucle de jeu principale, gérez les événements utilisateur et mettez à jour la position du joueur en fonction des pressions sur les touches. Dessiner un rectangle pour l'objet joueur en utilisant pygame.draw.rect().

Enfin, mettez à jour la fenêtre du jeu en utilisant pygame.display.flip() et quitter le jeu lorsque le joueur quitte la boucle. Ce jeu simple servira de base pour ajouter des effets spéciaux à l'aide de systèmes de particules.

Vous devriez voir un carré blanc représentant le joueur que vous pouvez déplacer à gauche et à droite :

Création de divers types de particules

Maintenant que vous avez configuré votre jeu simple, vous pouvez ajouter différents systèmes de particules. Créez des classes de particules pour chaque effet et une classe de système de particules pour gérer et mettre à jour les particules.

Effet de particules lorsque le joueur se déplace

Le premier effet de particules sera une traînée de particules de poussière émises par le dos du joueur lorsque celui-ci commencera à déplacer à l'aide de la souris ou du clavier. De plus, la direction des particules de poussière changera lorsque le joueur changera de direction.

Définir un Particule classe qui représente une particule individuelle. Chaque particule a une position initiale (X et y), une vitesse aléatoire (dx et mourir), et une durée de vie qui détermine la durée d'existence de la particule.

Définissez également un Système de particules classe qui gère une collection de particules. Vous pouvez ajouter une nouvelle particule au système en utilisant le add_particle() méthode. Le mise à jour() met à jour toutes les particules du système et supprime les particules qui ont atteint la fin de leur durée de vie.

# Classe de particules
classeParticule:
définitivement__init__(soi, x, y):
 soi.x = x
 soi.y = y
 self.dx = random.uniform(-1, 1)
 self.dy = random.uniform(-1, 1)
 self.lifetime = 60
définitivementmise à jour(soi):
 soi.x += soi.dx
 soi.y += soi.dy
 self.lifetime -= 1
définitivementdessiner(soi, fenêtre):
 couleur = (200, 200, 200)
 position = (int (soi.x), int (soi.y))
 pygame.draw.circle (fenêtre, couleur, position, 2)
# Classe de système de particules
classeSystème de particules:
définitivement__init__(soi):
 self.particules = []
définitivementadd_particle(soi, x, y):
 self.particles.append (particule (x, y))
définitivementmise à jour(soi):
pour particule dans self.particules :
 particule.update()
si particule.lifetime <= 0:
 self.particles.remove (particule)
définitivementdessiner(soi, fenêtre):
pour particule dans self.particules :
 particule.draw (fenêtre)

Pour intégrer le système de particules dans votre jeu, vous devez apporter quelques modifications à la boucle principale du jeu. Créer un nouveau fichier nommé mouvement-particules.py et ajoutez le code avec les mises à jour ci-dessous :

# Créer un système de particules
système_de_particules = ParticleSystem()
# Boucle de jeu principale
courir = Vrai
horloge = pygame.heure. Horloge()
alors que en cours d'exécution:
 dt = horloge.tick(60) / 1000.0
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 courir = FAUX
 particule_y = player_y + player_height // 2
 particule_x = player_x + player_width
 clés = pygame.key.get_pressed()
 limite = player_x < window_width - player_width
si clés[pygame. K_LEFT] et joueur_x > 0:
 joueur_x -= 5
 particule_system.add_particle (particule_x, particule_y)
si clés[pygame. K_RIGHT] et frontière:
 joueur_x += 5
 particule_system.add_particle (joueur_x, particule_y)
 système_de_particules.update()
 window.fill (NOIR)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (fenêtre, BLANC, player_pos)
 particule_system.draw (fenêtre)
 pygame.display.flip()
# Quitter le jeu
pygame.quit()

Lorsque vous déplacez l'objet joueur maintenant, vous devriez voir des particules accentuant le mouvement :

Effet de souffle

Le prochain effet de particules sera un effet de souffle qui se produit lorsque le joueur tire une balle. L'effet de souffle consistera en des particules de couleur rouge émises depuis la position de la balle.

Définir un Particule classe similaire à la précédente, mais cette fois inclut une couleur paramètre pour représenter la couleur de la particule.

Aussi, mettez à jour le Système de particules classe pour gérer le nouveau type de particule. Le add_particle() la méthode prend maintenant un temps supplémentaire couleur paramètre et crée des particules avec la couleur spécifiée.

# Classe de particules
classeParticule:
définitivement__init__(soi, x, y, couleur):
 soi.x = x
 soi.y = y
 self.dx = random.uniform(-2, 2)
 self.dy = random.uniform(-2, 2)
 self.lifetime = 30
 self.color = couleur
définitivementmise à jour(soi):
 soi.x += soi.dx
 soi.y += soi.dy
 self.lifetime -= 1
définitivementdessiner(soi, fenêtre):
 position = (int (soi.x), int (soi.y))
 pygame.draw.circle (fenêtre, self.color, position, 3)
# Classe de système de particules
classeSystème de particules:
définitivement__init__(soi):
 self.particules = []
définitivementadd_particle(soi, x, y, couleur):
 self.particles.append (particule (x, y, couleur)
définitivementmise à jour(soi):
pour particule dans self.particules :
 particule.update()
si particule.lifetime <= 0:
 self.particles.remove (particule)
définitivementdessiner(soi, fenêtre):
pour particule dans self.particules :
 particule.draw (fenêtre)

Pour intégrer l'effet de souffle dans votre jeu, vous devez apporter quelques modifications à la boucle de jeu principale. Créer un nouveau nom de fichier shoot-particle.py et ajoutez le code avec les mises à jour ci-dessous :

# Créer un système de particules
système_de_particules = ParticleSystem()
# Boucle de jeu principale
courir = Vrai
horloge = pygame.heure. Horloge()
alors que en cours d'exécution:
 dt = horloge.tick(60) / 1000.0
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 courir = FAUX
 clés = pygame.key.get_pressed()
 limite = player_x < window_width - player_width
si clés[pygame. K_LEFT] et joueur_x > 0:
 joueur_x -= 5
si clés[pygame. K_RIGHT] et frontière:
 joueur_x += 5
si clés[pygame. K_ESPACE] :
 bullet_x = player_x + player_width // 2
 bullet_y = joueur_y
 particule_system.add_particle (bullet_x, bullet_y, ROUGE)
 système_de_particules.update()
 window.fill (NOIR)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (fenêtre, BLANC, player_pos)
 particule_system.draw (fenêtre)
 pygame.display.flip()
# Quitter le jeu
pygame.quit()

Voici la sortie :

Lorsque la barre d'espace ( pygame. K_ESPACE) est enfoncé, ajoutez une particule au système de particules à la position de la balle. Cela crée l'effet de souffle avec des particules rouges.

Effet de poussière

La dernière amélioration visuelle que vous pouvez implémenter est un effet de fond poussiéreux. L'effet de poussière consistera en de petites particules grises se déplaçant selon un motif circulaire, créant un arrière-plan dynamique et poussiéreux.

Mettre à jour le Particule classe pour inclure une angle et vitesse pour chaque particule. L'angle détermine la direction du mouvement et la vitesse contrôle la vitesse à laquelle les particules se déplacent dans leur motif circulaire. Modifier le mise à jour() méthode pour mettre à jour la position de chaque particule en fonction de son angle et de sa vitesse.

Aussi, mettez à jour le Système de particules classe pour gérer le nouveau comportement des particules. Les particules se déplacent maintenant selon un motif circulaire dans la fenêtre de jeu.

# Classe de particules
classeParticule:
définitivement__init__(soi, x, y, rayon):
 soi.x = x
 soi.y = y
 self.radius = rayon
 self.angle = random.uniform(0, 2 * math.pi)
 self.speed = random.uniform(0.5, 1.5)
définitivementmise à jour(soi):
 self.angle += 0.02
 self.x += math.cos (self.angle) * self.speed
 self.y += math.sin (self.angle) * self.speed
si soi.x < 0:
 self.x = window_width
elif self.x > window_width :
 soi.x = 0
si soi.y < 0:
 self.y = window_height
elif self.y > window_height :
 soi.y = 0
définitivementdessiner(soi, fenêtre):
 couleur = (128, 128, 128)
 pos = (int (soi.x), int (soi.y))
 rayon = int (self.radius)
 pygame.draw.circle (fenêtre, couleur, position, rayon)
# Classe de système de particules
classeSystème de particules:
définitivement__init__(soi):
 self.particules = []
définitivementadd_particle(soi, x, y, rayon):
 self.particles.append (particule (x, y, rayon))
définitivementmise à jour(soi):
pour particule dans self.particules :
 particule.update()
définitivementdessiner(soi, fenêtre):
pour particule dans self.particules :
 particule.draw (fenêtre)

Pour intégrer l'effet de poussière dans votre jeu, vous devez apporter quelques modifications à la boucle principale du jeu. Créer un nouveau fichier nommé poussière-particule.py et ajoutez le code avec les mises à jour ci-dessous :

# Créer un système de particules pour l'effet de poussière
système_de_particules = ParticleSystem()
# Boucle de jeu principale
courir = Vrai
horloge = pygame.heure. Horloge()
alors que en cours d'exécution:
 dt = horloge.tick(60) / 1000.0
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 courir = FAUX
 particule_x = random.randint(0, largeur_fenêtre)
 particule_y = random.randint(0, hauteur_fenêtre)
 particule_system.add_particle (particule_x, particule_y, 1)
 système_de_particules.update()
 fenêtre.fill((0, 0, 0))
 particule_system.draw (fenêtre)
 pygame.display.flip()
# Quitter le jeu
pygame.quit()

Ajoutez des particules au hasard dans la fenêtre de jeu en utilisant le random.randint() fonction. Chaque particule a un rayon initial de 1. Mettez à jour et dessinez le système de particules sur la fenêtre du jeu, créant un effet de fond dynamique et poussiéreux.

Vous devriez voir de nombreuses particules à l'écran, se déplaçant de manière aléatoire mais fluide :

Meilleures pratiques pour les effets spéciaux

Lorsque vous ajoutez des effets spéciaux à votre jeu Pygame, tenez compte des bonnes pratiques suivantes :

Optimisation des performances

Les systèmes de particules peuvent impliquer un grand nombre de particules, ce qui peut avoir un impact sur les performances du jeu. Mettre en œuvre des techniques telles que le partitionnement spatial (par exemple, Quadtree) pour optimiser les mises à jour et le dessin des particules.

Recyclage des particules

Au lieu de créer et de détruire des particules dans chaque image, envisagez de réutiliser des particules en réinitialisant leurs propriétés lorsqu'elles atteignent la fin de leur durée de vie. Cela permet de minimiser l'allocation et la désallocation de mémoire.

Mise en commun des particules

Maintenez un pool de particules pré-allouées pour éviter les frais généraux liés à la création de nouvelles instances pendant l'exécution. Cela peut améliorer les performances et réduire la fragmentation de la mémoire.

Limiter le nombre de particules

Pour éviter que les systèmes de particules ne submergent l'écran de jeu, fixez des limites au nombre maximum de particules et supprimez les particules lorsqu'elles atteignent cette limite. Cela garantit que les effets restent visuellement attrayants sans gêner le gameplay.

Cohérence visuelle

Maintenez un style visuel cohérent tout au long de votre jeu, y compris les effets de particules. Assurez-vous que les couleurs, les tailles et les mouvements des particules sont cohérents avec le thème général et le style artistique.

Effets sonores

Ajouter des effets sonores pour compléter vos effets de particules. Par exemple, jouez des sons d'explosion lorsqu'un effet de souffle se produit ou des sons ambiants lorsque des effets de brouillard ou de poussière sont actifs.

Rendez les jeux plus amusants avec des effets spéciaux

L'ajout d'effets spéciaux, tels que des systèmes de particules, à vos jeux Pygame peut grandement améliorer l'expérience du joueur et rendre vos jeux plus attrayants et amusants pour les joueurs. En implémentant des effets de particules tels que des traînées, des explosions, du brouillard et de la poussière, vous pouvez créer des environnements visuellement époustouflants et dynamiques.

N'oubliez pas de prendre en compte l'optimisation des performances, le recyclage des particules et la cohérence visuelle tout en incorporant des effets spéciaux dans vos jeux. Avec créativité et expérimentation, vous pouvez faire passer vos jeux Pygame au niveau supérieur et captiver les joueurs avec des expériences immersives et passionnantes.