Space Invaders - Pygame

Découvrez le jeu

Space Invaders est un jeu d'arcade créé en 1978 par Tomohiro Nishikado. Dans ce jeu captivant, le joueur prend le contrôle d'un canon laser placé en bas de l'écran et doit défendre la Terre contre des vagues incessantes d'extraterrestres.

Ces envahisseurs se déplacent latéralement et descendent progressivement, menaçant de plus en plus notre planète. Le joueur doit habilement détruire les ennemis en tirant des projectiles tout en esquivant leurs tirs. À mesure que le joueur élimine les extraterrestres, leur vitesse augmente, rendant le défi encore plus intense.

Le jeu se termine si les envahisseurs atteignent le bas de l'écran ou si le joueur perd toutes ses vies. Avec son gameplay addictif et son influence durable, Space Invaders a marqué l'histoire des jeux vidéo et reste une référence incontournable du genre.

Téléchargez le code source

Téléchargez le code

Faire tourner le jeu

Si vous souhaitez faire tourner ce jeu sur votre machine, voici plusieurs prérequis à respecter :

• Version de Python : Certaines versions de Python ne permettent pas de faire tourner le jeu ou entraînent des performances beaucoup plus faibles. Le jeu a été développé et testé sur Python 3.11.7
• Version de Pygame : Le jeu a été développé et testé sur la version 2.5.2 de PyGame, cependant il peut également fonctionner sur des versions plus récentes bien qu'elles n'aient pas été testées.
• Système d'exploitation : Les tests ont été effectués sous Windows 11, mais le jeu devrait fonctionner sur n'importe quel système d'exploitation tant qu'il prend en charge Python et les modules nécessaires.
• Chemin d'Accès aux ressources : Le programme va chercher des ressources situées dans un dossier 'assets'. Il est donc nécessaire de lancer le programme depuis le dossier dans lequel il se trouve, sinon une erreur de chemin d'accès peut se produire. Une erreur se produira si vous exécutez le programme sans extraire les fichiers de l'archive zip.

Si ces critères sont remplis, vous pouvez alors lancer le fichier space_invaders.py et commencer à jouer.

Principaux Changements

Nouveautés Générales

• Ajout d'un menu d'accueil permettant de choisir le mode de jeu et le monde de départ.
• Ajout d'un menu de pause accessible avec la touche Échap, offrant des options pour revenir au jeu, retourner au menu d'accueil ou quitter le jeu.
• Ajout d'un mode libre où le joueur affronte des ennemis sans fin et possède tous les pouvoirs des boss.
• Ajout de la possibilité pour le joueur de mourir et d'afficher un écran de mort.
• Ajout de barres de vie pour les boss, les ennemis et le joueur.
• Ajout d'un score affiché en haut à gauche de l'écran en mode libre.

Mode Campagne

• Ajout d'un mode campagne composé de 8 niveaux avec 7 ennemis différents et 7 pouvoirs.
  • Niveaux 1 à 6 : Les ennemis apparaissent successivement, suivis d'un boss. Une fois tous les ennemis détruits, le boss apparaît. Vaincre le boss permet d'accéder au niveau suivant.
  • Niveaux 7 : Pas d'ennemis, mais trois mini-boss avec deux pouvoirs chacun.
  • Niveau 8 : Pas d'ennemis non plus, mais un boss final possédant tous les pouvoirs du jeu plus un nouveau pouvoir unique qui arrête le rafraîchissement des images du jeu.
• Chaque boss a son propre pouvoir, que le joueur récupère au niveau suivant une fois le boss battu.
• Une transition entre chaque monde affiche les mondes déjà parcourus et présente le nouveau pouvoir obtenu dans une boîte de dialogue.
• Lorsque le boss du niveau 8 est battu, un générique de fin se lance avant de revenir au menu d'accueil.

Musique et Sons

• Ajout de musiques de fond différentes pour chaque affrontement avec les boss.
• Ajout de musiques de fond lors des affrontements avec les ennemis, sur le menu d'accueil, et pour le générique de fin

Graphismes et Effets

• Ajout de fonds différents pour chaque monde.
• Ajout d'une classe Effect pour afficher sur plusieurs frames une image, comme lors de la téléportation d'une entité.
• Ajout d'une sélection du monde dans lequel commencer via le menu d'accueil.

Droits d'Auteurs et Crédits

Pour la création de ma version revisitée de Space Invaders, j'ai utilisé diverses ressources pour enrichir l'expérience de jeu. Les images ont été générées à l'aide de l'intelligence artificielle Midjourney, offrant ainsi un visuel unique et moderne. Les effets sonores proviennent de Pixabay, une plateforme reconnue pour ses ressources audio libres de droits, tandis que les musiques qui accompagnent le jeu sont issues de Soundraw, un service qui permet de créer des morceaux personnalisés et originaux.

Je tiens à préciser que toute modification ou redistribution de mon projet doit impérativement mentionner mon nom dans les crédits pour le code source. Par ailleurs, la revente de ce jeu, sous quelque forme que ce soit, est strictement interdite. Mon objectif est de partager cette création avec la communauté Open Source, tout en respectant les contributions et efforts investis dans ce projet.

En respectant ces conditions, vous contribuez à valoriser le travail collaboratif et à préserver l'esprit de partage qui anime la communauté des développeurs. Merci de votre compréhension et de votre soutien.

Structures du projet

Dans cette section, je vais vous présenter la structure de mon projet Space Invaders revisité, en expliquant le fonctionnement du code et l'utilité des différentes classes et méthodes. Cette documentation vise à vous fournir une compréhension approfondie de l'architecture du jeu, facilitant ainsi toute modification ou contribution future.

Organisation du Code

Le projet est structuré principalement autour du fichier space_invaders.py, qui constitue le cœur de la boucle de jeu, et du module space, qui contient les classes et méthodes nécessaires pour le fonctionnement du jeu. Voici un aperçu des principaux composants et de leur rôle :

• space_invaders.py : Le fichier principal qui initialise le jeu, gère les événements et contrôle la boucle principale du jeu.
• space.py : Contient les classes et méthodes pour les différents éléments du jeu (par exemple, Joueur, Ennemi, Tir).

Détails des Classes et Méthodes

Fichier space_invaders.py

Le fichier space_invaders.py initialise le jeu, gère les événements et maintient la boucle principale. Voici une explication détaillée de son contenu et de son fonctionnement :

Initialisation

                
                import sys
                sys.dont_write_bytecode = True
                import pygame
                import space
                import sys
                
                

Ces lignes importent les modules nécessaires et empêchent la création de fichiers bytecode (.pyc).

Paramètres du jeu

                
                WIDTH = 800
                HEIGHT = 600
                FPS = 60
                
                

Définition des paramètres de la fenêtre de jeu.

Lancement des modules de pygame

                
                pygame.init()
                clock = pygame.time.Clock()
                
                

Initialisation de Pygame et création d'un objet clock pour gérer le temps.

Création de la fenêtre

                
                screen = pygame.display.set_mode((WIDTH, HEIGHT))
                pygame.display.set_caption("Space Invaders")
                
                

Création de la fenêtre de jeu avec les dimensions spécifiées et définition du titre.

Instantiation de la classe Jeu

                jeu = space.Jeu(screen, WIDTH, HEIGHT, FPS)
                

Création d'une instance de la classe Jeu définie dans space.py.

Boucle de jeu

                
                while True:
                    ...
                
                

La boucle principale du jeu gère les événements, met à jour l'état du jeu et rend les objets à l'écran. Voici quelques éléments clés de cette boucle :

Fond de la fenêtre

                    
                    if (jeu.scene not in ['transition', 'ending', 'free_death', 'campaign_death']) and (jeu.bg_stop is False):
                        jeu.screen.blit(jeu.background(), (0, 0))
                    
                

Affiche le fond de la fenêtre sauf dans certaines scènes spécifiques.

Gestion des événements

                    
                    for event in pygame.event.get():
                        if event.type == pygame.QUIT:
                            sys.exit()
                        elif event.type == pygame.KEYDOWN:
                            ...
                    
                

Gère les événements de fermeture de la fenêtre, les entrées clavier et souris.

Mise à jour de la scène

                
                if jeu.scene == 'home':
                    jeu.home()
                elif jeu.scene == 'levels':
                    jeu.levels()
                elif jeu.scene in ['campaign_menu', 'free_menu']:
                    jeu.ingame_menu()
                elif jeu.scene in ['campaign', 'free']:
                    ...
                elif jeu.scene == 'transition':
                    jeu.world_transition()
                elif jeu.scene == 'ending':
                    jeu.ending()
                elif jeu.scene in ['campaign_death', 'free_death']:
                    ...
                
                

Met à jour et affiche les différentes scènes du jeu en fonction de l'état actuel.

Rendu et mise à jour de l'écran

                pygame.display.update()
                clock.tick(FPS)
                

Met à jour l'affichage et contrôle le taux de rafraîchissement du jeu.

Fichier space.py

Le fichier space.py contient les classes et méthodes nécessaires pour les différents éléments du jeu. Voici un aperçu des classes principales et de leurs méthodes :

Classe Jeu

• __init__(self, screen, width, height, fps) : Initialise les paramètres du jeu, y compris l'écran, les dimensions et le taux de rafraîchissement.
• background(self) : Retourne l'image de fond à afficher.
• home(self) : Gère la scène d'accueil.
• levels(self) : Gère la scène de sélection des niveaux.
• ingame_menu(self) : Affiche le menu en cours de jeu.
• campaign(self, world=None) : Démarre une campagne, avec un niveau spécifique si indiqué.
• free(self) : Démarre le mode libre.
• world_campaign(self) : Gère le déroulement des niveaux de la campagne.
• world_free(self) : Gère le déroulement des niveaux du mode libre.
• world_transition(self) : Gère les transitions entre les niveaux.
• ending(self) : Gère la scène de fin de jeu.
• show_text(self, text, position, size, color=(255, 255, 255)) : Affiche du texte à l'écran.
• interface(self) : Gère l'affichage de l'interface utilisateur.

Classe Player

• __init__(self, x, y) : Initialise la position du joueur.
• deplacer(self) : Gère le déplacement du joueur.
• cooldown(self) : Gère le temps de recharge des pouvoirs du joueur.
• marquer(self) : Incrémente le score du joueur.

Classe Ennemi

• __init__(self, x, y, speed, type) : Initialise la position, la vitesse et le type de l'ennemi.
• avancer(self) : Gère le déplacement de l'ennemi.
• ability(self) : Active les capacités spéciales de l'ennemi.
• disparaitre(self) : Gère la disparition de l'ennemi lorsqu'il est détruit.

Classe Tir

• __init__(self, x, y, speed, direction) : Initialise la position, la vitesse et la direction du projectile.
• bouger(self) : Met à jour la position du projectile.
• toucher(self, target) : Vérifie si le projectile touche une cible.
• toucher_healer(self, pouvoir) : Vérifie si le projectile
• toucher_healer(self, pouvoir) : Vérifie si le projectile touche un ennemi de type guérisseur sans être bloqué par son pouvoir.

Classe Boss

• __init__(self, name, x, y, speed) : Initialise le nom, la position et la vitesse du boss.
• bouger(self) : Gère le déplacement du boss.
• tirer(self) : Gère les tirs du boss.
• ability(self) : Active les capacités spéciales du boss.

Classe Effect

• __init__(self, x, y, duration) : Initialise la position et la durée de l'effet.
• afficher(self) : Affiche l'effet à l'écran.