Imprimer tout le livreImprimer tout le livre

Zelda Nes en python (défi final)

Site: Le labo numérique de M. MIGNOTTE – Cours, projets et ressources pour les élèves de seconde SNT et STI2D
Cours: Chapitre 6 : Python
Livre: Zelda Nes en python (défi final)
Imprimé par: Visiteur anonyme
Date: samedi 14 mars 2026, 07:00

Table des matières

1. Introduction

Vous allez réaliser un jeu zelda en python.

Voici l'arborescence du projet :

  • zelda_python
    • Audio
    • Code
    • Graphics
    • Map

2. Main.py

Le premier fichier a réaliser dans le dossier "code".

Ce code Python utilise la bibliothèque Pygame.

 Voici une explication de chaque partie du code vous avez à les reprendre et les compléter :

Imports :

python
import pygame, sys from Settings import * from Level import Level import os
  • pygame est une bibliothèque populaire pour le développement de jeux en Python.
  • sys est utilisé pour accéder à certaines fonctionnalités spécifiques du système.
  • Settings et Level sont des modules définis ailleurs dans le projet.

Changement du répertoire de travail :

python
os.chdir(os.path.dirname(os.path.abspath(__file__)))
      • Cette ligne change le répertoire de travail actuel pour le répertoire du script en cours d'exécution. Cela est généralement fait pour faciliter l'importation de fichiers, en particulier des images ou d'autres ressources.

Classe Game :

python
class Game: def __init__(self): # Initialisation générale pygame.init() self.screen = pygame.display.set_mode((WIDTH, HEIGTH)) pygame.display.set_caption("Zelda with Python") pygame_icon = pygame.image.load("../Graphics/Test/Player.png") pygame.display.set_icon(pygame_icon) self.clock = pygame.time.Clock() self.level = Level() # Musique main_sound = pygame.mixer.Sound("../Audio/Main.ogg") main_sound.set_volume(0.5) main_sound.play(loops=-1)
      • __init__ est le constructeur de la classe Game.
      • Il initialise Pygame, configure la fenêtre du jeu, charge une icône, crée une horloge pour gérer le temps du jeu, et instancie un objet de la classe Level.
      • Il charge également un fichier audio (Main.ogg) et le joue en boucle.

Méthode run :

python
def run(self): while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_m: self.level.toggle_menu() self.screen.fill(WATER_COLOR) self.level.run() pygame.display.update() self.clock.tick(FPS)
      • Cette méthode gère la boucle principale du jeu.
      • Elle vérifie les événements Pygame, tels que la fermeture de la fenêtre ou l'appui sur la touche 'm' pour activer/désactiver le menu.
      • Elle remplit l'écran avec une couleur d'eau définie (WATER_COLOR), exécute la logique du niveau, met à jour l'affichage, puis attend un certain temps pour maintenir un taux de rafraîchissement constant (FPS).

Point d'entrée du programme :

python
if __name__ == "__main__": game = Game() game.run()
    • Le programme principal instancie la classe Game et exécute sa méthode run lorsque le script est exécuté.

3. Settings.py

Ce code définit des paramètres et des données utilisés dans le jeu. Voici une explication détaillée du code :

  1. Imports :

    python
import os

os: Utilisé pour effectuer des opérations liées au système d'exploitation, notamment le changement du répertoire de travail.

  • Changement du répertoire de travail :

    python
os.chdir(os.path.dirname(os.path.abspath(__file__)))

Comme dans les exemples précédents, cela change le répertoire de travail actuel pour le répertoire du script en cours d'exécution.

  • Paramètres du jeu :

    python
# Game setup WIDTH = 1280 HEIGHT = 720 FPS = 60 TILESIZE = 64 HITBOX_OFFSET = { "player": -26, "object": -40, "grass": -10, "invisible": 0 }
    • WIDTH et HEIGHT définissent la largeur et la hauteur de la fenêtre du jeu.
    • FPS définit le nombre d'images par seconde du jeu.
    • TILESIZE définit la taille d'une tuile dans le jeu.
    • HITBOX_OFFSET est un dictionnaire définissant des décalages pour différentes types d'objets.

  • Paramètres de l'interface utilisateur (UI) :

    python
# UI BAR_HEIGHT = 20 HEALTH_BAR_WIDTH = 200 ENERGY_BAR_WIDTH = 140 ITEM_BOX_SIZE = 80 UI_FONT = "../Graphics/Font/Joystix.ttf" UI_FONT_SIZE = 18

Différents paramètres liés à l'interface utilisateur tels que la hauteur des barres, la taille des boîtes d'objets, la police utilisée, etc.

  • Couleurs générales :

    python
# General Colors WATER_COLOR = "#71ddee" UI_BG_COLOR = "#222222" UI_BORDER_COLOR = "#111111" TEXT_COLOR = "#EEEEEE"

Définition de certaines couleurs utilisées dans le jeu.

  • Couleurs spécifiques à l'interface utilisateur :

    python
# UI Colors HEALTH_COLOR = "Red" ENERGY_COLOR = "Blue" UI_BORDER_COLOR_ACTIVE = "Gold"

Définition de couleurs spécifiques pour les barres de santé et d'énergie, ainsi que pour la bordure active.

  • Paramètres du menu d'amélioration :

    python
# Upgrade Menu TEXT_COLOR_SELECTED = "#111111" BAR_COLOR = "#EEEEEE" BAR_COLOR_SELECTED = "#111111" UPGRADE_BG_COLOR_SELECTED = "#EEEEEE"

Paramètres de couleurs pour le menu d'amélioration.

  • Données des armes :

    python
# Weapons weapon_data = { "sword": {"cooldown": 100, "damage": 15, "graphic": "../Graphics/Weapons/Sword/Full.png"}, "lance": {"cooldown": 400, "damage": 30, "graphic": "../Graphics/Weapons/Lance/Full.png"}, "axe": {"cooldown": 300, "damage": 20, "graphic": "../Graphics/Weapons/Axe/Full.png"}, "rapier": {"cooldown": 50, "damage": 8, "graphic": "../Graphics/Weapons/Rapier/Full.png"}, "sai": {"cooldown": 80, "damage": 10, "graphic": "../Graphics/Weapons/Sai/Full.png"} }
    • Une collection de données pour différentes armes, spécifiant des informations telles que le temps de recharge, les dégâts, et l'image graphique associée.

  • Données de la magie :

    python
# Magic magic_data = { "flame": {"strength": 5, "cost": 20, "graphic": "../Graphics/Particles/Flame/Fire.png"}, "heal": {"strength": 20, "cost": 10, "graphic": "../Graphics/Particles/Heal/Heal.png"} }
    • Une collection de données pour différents types de magie, spécifiant des informations telles que la force, le coût, et l'image graphique associée.

  1. Données des ennemis :

python
# Enemies monster_data = { "squid": {"health": 100, "exp": 180, "damage": 20, "attack_type": "slash", "attack_sound": "../Audio/Attack/Slash.wav", "speed": 3, "resistance": 3, "attack_radius": 80, "notice_radius": 360}, "raccoon": {"health": 300, "exp": 300, "damage": 40, "attack_type": "claw", "attack_sound": "../Audio/Attack/Claw.wav", "speed": 2, "resistance": 3, "attack_radius": 120, "notice_radius": 400}, "spirit": {"health": 100, "exp": 200, "damage": 8, "attack_type": "thunder", "attack_sound": "../Audio/Attack/Fireball.wav", "speed": 4, "resistance": 3, "attack_radius": 60, "notice_radius": 350}, "bamboo": {"health": 70, "exp": 150, "damage": 6, "attack_type": "leaf_attack", "attack_sound": "../Audio/Attack/Slash.wav", "speed": 3, "resistance": 3, "attack_radius": 50, "notice_radius": 300} }
  • Une collection de données pour différents types d'ennemis, spécifiant des informations telles que la santé, l'expérience, les dégâts, etc.

Ces paramètres et données sont utilisés dans le jeu pour définir des caractéristiques telles que la taille de la fenêtre, les couleurs, les propriétés des objets, les informations sur les armes, la magie et les ennemis.

4. Level.py

Ce code définit la classe Level, qui représente le niveau ou la scène du jeu. Voici une explication détaillée du code :

Imports :

python
import pygame from Settings import * from Tile import Tile from Player import Player from Debug import debug from Support import * from random import choice, randint from Weapon import Weapon from UI import UI from Enemy import Enemy from Particles import AnimationPlayer from Magic import MagicPlayer from Upgrade import Upgrade import os
      • Importe les modules nécessaires pour la création du niveau, y compris les classes de tuiles, de joueur, d'armes, d'ennemis, de particules, etc.

Changement du répertoire de travail :

python
os.chdir(os.path.dirname(os.path.abspath(__file__)))
      • Change le répertoire de travail actuel pour le répertoire du script en cours d'exécution.

Classe Level :

python
class Level: def __init__(self): # ... (voir explications ci-dessous) def create_map(self): # ... (voir explications ci-dessous) def create_attack(self): # ... (voir explications ci-dessous) def create_magic(self, style, strength, cost): # ... (voir explications ci-dessous) def destroy_attack(self): # ... (voir explications ci-dessous) def player_attack_logic(self): # ... (voir explications ci-dessous) def damage_player(self, amount, attack_type): # ... (voir explications ci-dessous) def trigger_death_particles(self, pos, particle_type): # ... (voir explications ci-dessous) def add_exp(self, amount): # ... (voir explications ci-dessous) def toggle_menu(self): # ... (voir explications ci-dessous) def run(self): # ... (voir explications ci-dessous)

Initialisation de la classe Level :

python
def __init__(self): # Get the display surface self.display_surface = pygame.display.get_surface() self.game_paused = False # Sprite Group Setup self.visible_sprites = YSortCameraGroup() self.obstacle_sprites = pygame.sprite.Group() # Attack Sprites self.current_attack = None self.attack_sprites = pygame.sprite.Group() self.attackable_sprites = pygame.sprite.Group() # Sprite Setup self.create_map() # User Interface self.ui = UI() self.upgrade = Upgrade(self.player) # Particles self.animation_player = AnimationPlayer() self.magic_player = MagicPlayer(self.animation_player)
      • Initialise la classe Level avec des attributs tels que display_surface, des groupes de sprites, des objets pour la gestion des attaques, de l'interface utilisateur, des particules, etc.

Création de la carte (méthode create_map) :

python
def create_map(self): # ... (voir explications ci-dessous)
      • Cette méthode crée la carte du niveau en chargeant différentes dispositions (layouts) à partir de fichiers CSV. Elle crée des tuiles, des objets, des entités (joueur et ennemis) en fonction de ces dispositions.

Création d'une attaque (méthode create_attack) :

python
def create_attack(self): # ... (voir explications ci-dessous)
      • Cette méthode crée une nouvelle instance d'attaque (Weapon) pour le joueur.

Création de la magie (méthode create_magic) :

python
def create_magic(self, style, strength, cost): # ... (voir explications ci-dessous)
      • Cette méthode crée de la magie pour le joueur en fonction du style spécifié.

Destruction de l'attaque actuelle (méthode destroy_attack) :

python
def destroy_attack(self): # ... (voir explications ci-dessous)
      • Cette méthode détruit l'attaque actuelle du joueur.

Logique d'attaque du joueur (méthode player_attack_logic) :

python
def player_attack_logic(self): # ... (voir explications ci-dessous)
      • Cette méthode gère la logique d'attaque du joueur, détectant les collisions avec des sprites attaquables et infligeant des dégâts.

Dommage au joueur (méthode damage_player) :

python
def damage_player(self, amount, attack_type): # ... (voir explications ci-dessous)
      • Cette méthode gère les dégâts infligés au joueur.

Déclenchement de particules de mort (méthode trigger_death_particles) :

python
def trigger_death_particles(self, pos, particle_type): # ... (voir explications ci-dessous)
      • Cette méthode déclenche la création de particules lorsqu'un ennemi meurt.

Ajout d'expérience (méthode add_exp) :

python
def add_exp(self, amount): # ... (voir explications ci-dessous)
      • Cette méthode ajoute de l'expérience au joueur.

Basculement du menu (méthode toggle_menu) :

python
def toggle_menu(self): # ... (voir explications ci-dessous)
      • Cette méthode bascule l'état du menu (en pause ou en cours d'exécution).

Exécution du niveau (méthode run) :

python
def run(self): # ... (voir explications ci-dessous)
    • Cette méthode exécute le niveau, met à jour les sprites visibles, gère la logique d'attaque du joueur et affiche l'interface utilisateur ou le menu d'amélioration en fonction de l'état du jeu.

5. UI.py

Ce code définit une classe UI qui gère l'interface utilisateur du jeu. Voici une explication détaillée du code :

  1. Imports :

    python
  • import pygame from Settings import * import os
    • pygame est la bibliothèque de jeu utilisée.
    • Settings est un module défini ailleurs dans le projet, contenant des constantes et des configurations.

  • Changement du répertoire de travail :

    python
  • os.chdir(os.path.dirname(os.path.abspath(__file__)))
    • Comme dans le code précédent, cela change le répertoire de travail actuel pour le répertoire du script en cours d'exécution.

  • Classe UI :

    python
  • class UI: def __init__(self): # Initialisation générale self.display_surface = pygame.display.get_surface() self.font = pygame.font.Font(UI_FONT, UI_FONT_SIZE) # Configuration des barres self.health_bar_rect = pygame.Rect(10, 10, HEALTH_BAR_WIDTH, BAR_HEIGHT) self.energy_bar_rect = pygame.Rect(10, 34, ENERGY_BAR_WIDTH, BAR_HEIGHT) # Conversion du dictionnaire des armes self.weapon_graphics = [] for weapon in weapon_data.values(): path = weapon["graphic"] weapon_image = pygame.image.load(path).convert_alpha() self.weapon_graphics.append(weapon_image) # Conversion du dictionnaire des magies self.magic_graphics = [] for magic in magic_data.values(): magic_image = pygame.image.load(magic["graphic"]).convert_alpha() self.magic_graphics.append(magic_image)
    • Le constructeur initialise l'interface utilisateur avec des éléments tels que la surface d'affichage, la police, les rectangles des barres de santé et d'énergie, et les images des armes et des magies.

  • Méthodes de la classe UI :

    • show_bar(self, current, max_amount, bg_rect, color): Affiche une barre avec la couleur spécifiée.
    • show_exp(self, exp): Affiche le niveau d'expérience du joueur.
    • selection_box(self, left, top, has_switched): Affiche une boîte de sélection avec ou sans bordure active, en fonction de la valeur de has_switched.
    • weapon_overlay(self, weapon_index, has_switched): Affiche l'arme actuelle du joueur avec une boîte de sélection.
    • magic_overlay(self, magic_index, has_switched): Affiche la magie actuelle du joueur avec une boîte de sélection.
    • display(self, player): Affiche l'ensemble de l'interface utilisateur, y compris les barres de santé et d'énergie, l'expérience du joueur, l'arme et la magie actuelles.

  • Utilisation de la classe UI :

    python
  1. def display(self, player): self.show_bar(player.health, player.stats["health"], self.health_bar_rect, HEALTH_COLOR) self.show_bar(player.energy, player.stats["energy"], self.energy_bar_rect, ENERGY_COLOR) self.show_exp(player.exp) self.weapon_overlay(player.weapon_index, not player.can_switch_weapon) self.magic_overlay(player.magic_index, not player.can_switch_magic)
    • Cette méthode est probablement appelée ailleurs dans le code du jeu pour afficher l'interface utilisateur en fonction de l'état actuel du joueur.

En résumé, la classe UI gère l'affichage des éléments de l'interface utilisateur du jeu, tels que les barres de santé et d'énergie, l'expérience, les armes et les magies.

6. Debug.py

Ce code définit une fonction de débogage pour afficher des informations à l'écran dans un jeu Pygame. Voici une explication détaillée du code :

  1. Imports :

    python
  • import pygame import os
    • pygame est la bibliothèque de jeu utilisée.
    • os est utilisé pour effectuer des opérations liées au système d'exploitation, notamment le changement du répertoire de travail.

  • Changement du répertoire de travail :

    python
  • os.chdir(os.path.dirname(os.path.abspath(__file__)))
    • Comme dans les exemples précédents, cela change le répertoire de travail actuel pour le répertoire du script en cours d'exécution.

  • Initialisation de Pygame et création d'une police :

    python
  • pygame.init() font = pygame.font.Font(None, 30)
    • pygame.init() initialise la bibliothèque Pygame.
    • pygame.font.Font(None, 30) crée un objet police Pygame avec une taille de police de 30 pixels. La police est utilisée pour rendre le texte lors du débogage.

  • Fonction de débogage (debug) :

    python
  1. def debug(info, y=10, x=10): display_surface = pygame.display.get_surface() debug_surf = font.render(str(info), True, "White") debug_rect = debug_surf.get_rect(topleft=(x, y)) pygame.draw.rect(display_surface, "Black", debug_rect) display_surface.blit(debug_surf, debug_rect)
    • La fonction debug prend trois paramètres :
      • info: L'information à afficher (peut être n'importe quel type, car elle est convertie en chaîne avec str(info)).
      • y: La position verticale du coin supérieur gauche du texte (par défaut à 10 pixels depuis le haut de la fenêtre).
      • x: La position horizontale du coin supérieur gauche du texte (par défaut à 10 pixels depuis la gauche de la fenêtre).
    • La fonction utilise la surface d'affichage actuelle de Pygame (pygame.display.get_surface()).
    • Elle crée une surface de texte (debug_surf) à partir de l'information fournie, avec une couleur blanche.
    • Un rectangle (debug_rect) est créé pour délimiter la zone où le texte sera affiché, avec la position spécifiée par les paramètres x et y.
    • Ce rectangle est rempli avec une couleur noire ("Black") à l'aide de pygame.draw.rect().
    • Enfin, la surface de texte est blittée (copiée) sur la surface d'affichage à la position définie par le rectangle.

Cette fonction est utile pour afficher des informations de débogage à l'écran pendant le développement du jeu. Elle peut être appelée à différents endroits du code pour afficher des variables, des états ou d'autres informations importantes.

7. Enemy.py

Ce code définit une classe Enemy qui représente les ennemis dans le jeu. Voici une explication détaillée du code :

Imports :

python
import pygame from Settings import * from Entity import Entity from Support import * import os
    • pygame est la bibliothèque de jeu utilisée.
    • Settings, Entity, et Support sont des modules définis ailleurs dans le projet.

  • Changement du répertoire de travail :

    python
os.chdir(os.path.dirname(os.path.abspath(__file__)))
    • Comme dans les exemples précédents, cela change le répertoire de travail actuel pour le répertoire du script en cours d'exécution.

  • Classe Enemy héritant de Entity :

    python
class Enemy(Entity): def __init__(self, monster_name, pos, groups, obstacle_sprites, damage_player, trigger_death_particles, add_exp): # Initialisation générale super().__init__(groups) self.sprite_type = "enemy" # Configuration graphique self.import_graphics(monster_name) self.status = "idle" self.image = self.animations[self.status][self.frame_index] # Mouvement self.rect = self.image.get_rect(topleft=pos) self.hitbox = self.rect.inflate(0, -10) self.obstacle_sprites = obstacle_sprites # Statistiques self.monster_name = monster_name monster_info = monster_data[self.monster_name] # (D'autres initialisations de statistiques sont également présentes) # Interaction avec le joueur self.can_attack = True self.attack_time = None # (D'autres initialisations liées au combat) # Timer d'invincibilité self.vulnerable = True self.hit_time = None # (D'autres initialisations liées à l'invincibilité) # Sons self.death_sound = pygame.mixer.Sound("../Audio/Death.wav") self.hit_sound = pygame.mixer.Sound("../Audio/Hit.wav") self.attack_sound = pygame.mixer.Sound(monster_info["attack_sound"]) # (D'autres initialisations de sons)
    • La classe Enemy hérite de la classe Entity (qui pourrait être une classe de base pour d'autres types d'entités dans le jeu).
    • Le constructeur initialise diverses propriétés liées aux graphismes, au mouvement, aux statistiques, à l'interaction avec le joueur, aux timers, et aux sons.

Méthodes spécifiques à Enemy :

    • import_graphics(self, name): Importe les animations de l'ennemi à partir d'un répertoire spécifié.
    • get_player_distance_direction(self, player): Calcule la distance et la direction entre l'ennemi et le joueur.
    • get_status(self, player): Détermine l'état actuel de l'ennemi en fonction de la distance par rapport au joueur.
    • actions(self, player): Définit les actions à effectuer en fonction de l'état de l'ennemi.
    • animate(self): Anime l'ennemi en fonction de son état actuel.
    • cooldowns(self): Gère les temps de recharge pour les attaques et l'invincibilité.
    • get_damage(self, player, attack_type): Inflige des dégâts à l'ennemi en fonction du type d'attaque.
    • check_death(self): Vérifie si l'ennemi est mort et effectue des actions en conséquence.
    • hit_reaction(self): Gère la réaction de l'ennemi lorsqu'il est touché.
    • update(self): Met à jour l'état de l'ennemi (mouvement, animation, cooldowns, etc.).
    • enemy_update(self, player): Met à jour l'état spécifique à l'ennemi en fonction du joueur.

La classe Enemy encapsule la logique liée aux ennemis du jeu, notamment leur apparence, leur mouvement, leurs statistiques, leurs interactions avec le joueur, etc. Elle utilise également des fichiers audio pour les sons associés aux actions de l'ennemi.

8. Entity.py

Ce code définit la classe Entity, qui est une classe de base pour les entités du jeu. Voici une explication ligne par ligne :

Imports :

python
from cmath import rect import pygame from math import sin import os
      • Importe les modules nécessaires, y compris la bibliothèque Pygame pour la création de jeux.

Changement du répertoire de travail :

python
os.chdir(os.path.dirname(os.path.abspath(__file__)))
      • Change le répertoire de travail actuel pour le répertoire du script en cours d'exécution.

Classe Entity :

python
class Entity(pygame.sprite.Sprite): def __init__(self, groups): # ... (voir explications ci-dessous) def move(self, speed): # ... (voir explications ci-dessous) def collision(self, direction): # ... (voir explications ci-dessous) def wave_value(self): # ... (voir explications ci-dessous)

Initialisation de la classe Entity :

python
def __init__(self, groups): super().__init__(groups) self.frame_index = 0 self.animation_speed = 0.15 self.direction = pygame.math.Vector2()
      • Initialise la classe Entity avec des attributs tels que l'index du frame, la vitesse d'animation et la direction de l'entité.

Méthode move :

python
def move(self, speed): if self.direction.magnitude() != 0: self.direction = self.direction.normalize() self.hitbox.x += self.direction.x * speed self.collision("Horizontal") self.hitbox.y += self.direction.y * speed self.collision("Vertical") self.rect.center = self.hitbox.center
      • Cette méthode permet à l'entité de se déplacer en fonction de sa direction et de la vitesse donnée. Elle vérifie également les collisions horizontales et verticales avec d'autres sprites.

Méthode collision :

python
def collision(self, direction): if direction == "Horizontal": # ... (voir explications ci-dessous) if direction == "Vertical": # ... (voir explications ci-dessous)
      • Cette méthode gère les collisions de l'entité avec les sprites environnants, ajustant sa position en fonction de la direction de déplacement.

Méthode wave_value :

python
def wave_value(self): value = sin(pygame.time.get_ticks()) if value >= 0: return 255 else: return 0
    • Cette méthode renvoie une valeur basée sur une onde sinusoïdale, qui peut être utilisée pour des effets visuels comme le clignotement ou la variation de l'opacité.

9. Magic.py

Ce code définit la classe MagicPlayer, qui gère les sorts du joueur. Voici une explication ligne par ligne :

Importation de modules :

python
import pygame from Settings import * from random import randint import os
      • Importe les modules nécessaires, y compris Pygame pour la création de jeux.

Changement du répertoire de travail :

python
os.chdir(os.path.dirname(os.path.abspath(__file__)))
      • Change le répertoire de travail actuel pour le répertoire du script en cours d'exécution.

Classe MagicPlayer :

python
class MagicPlayer: def __init__(self, animation_player): # ... (voir explications ci-dessous) def heal(self, player, strength, cost, groups): # ... (voir explications ci-dessous) def flame(self, player, cost, groups): # ... (voir explications ci-dessous)

Initialisation de la classe MagicPlayer :

python
def __init__(self, animation_player): self.animation_player = animation_player self.sounds = { "heal": pygame.mixer.Sound("../Audio/Heal.wav"), "flame": pygame.mixer.Sound("../Audio/Fire.wav") }
      • Initialise la classe MagicPlayer avec un lecteur d'animations et des effets sonores pour les sorts.

Méthode heal :

python
def heal(self, player, strength, cost, groups): if player.energy >= cost: # ... (voir explications ci-dessous)
      • Cette méthode permet au joueur de lancer un sort de guérison s'il a suffisamment d'énergie. Elle restaure la santé du joueur, réduit son énergie et crée des particules d'effet visuel.

Méthode flame :

python
def flame(self, player, cost, groups): if player.energy >= cost: # ... (voir explications ci-dessous)
    • Cette méthode permet au joueur de lancer un sort de flamme s'il a suffisamment d'énergie. Elle réduit l'énergie du joueur et crée des particules de flamme qui se propagent dans la direction du joueur.

10. Particles.py

Ce code définit la classe AnimationPlayer et la classe ParticleEffect, qui gèrent les animations des particules dans le jeu. Voici une explication ligne par ligne :

Importation de modules et de fonctions :

python
import pygame from Support import import_folder from random import choice import os
    • Importe les modules nécessaires, y compris Pygame pour la création de jeux, et les fonctions d'assistance.

  • Changement du répertoire de travail :

    python
os.chdir(os.path.dirname(os.path.abspath(__file__)))
    • Change le répertoire de travail actuel pour le répertoire du script en cours d'exécution.

  • Classe AnimationPlayer :

    python
class AnimationPlayer: def __init__(self): # ... (voir explications ci-dessous) def reflect_images(self, frames): # ... (voir explications ci-dessous) def create_grass_particles(self, pos, groups): # ... (voir explications ci-dessous) def create_particles(self, animation_type, pos, groups): # ... (voir explications ci-dessous)

  • Initialisation de la classe AnimationPlayer :

    python
def __init__(self): self.frames = { # ... (voir explications ci-dessous) }
    • Initialise la classe AnimationPlayer avec un dictionnaire contenant différents types d'animations pour les particules.

  • Méthode reflect_images :

    python
def reflect_images(self, frames): new_frames = [] for frame in frames: flipped_frame = pygame.transform.flip(frame, True, False) new_frames.append(flipped_frame) return new_frames
    • Cette méthode retourne une liste de frames d'animation reflétées horizontalement.

  • Méthode create_grass_particles :

    python
def create_grass_particles(self, pos, groups): animation_frames = choice(self.frames["leaf"]) ParticleEffect(pos, animation_frames, groups)
    • Cette méthode crée des particules d'herbe en choisissant aléatoirement parmi les animations de feuilles.

  • Méthode create_particles :

    python
def create_particles(self, animation_type, pos, groups): animation_frames = self.frames[animation_type] ParticleEffect(pos, animation_frames, groups)
    • Cette méthode crée des particules en fonction du type d'animation spécifié et de la position donnée.

  • Classe ParticleEffect :

    python
class ParticleEffect(pygame.sprite.Sprite): def __init__(self, pos, animation_frames, groups): # ... (voir explications ci-dessous) def animate(self): # ... (voir explications ci-dessous) def update(self): # ... (voir explications ci-dessous)

  • Initialisation de la classe ParticleEffect :

    python
def __init__(self, pos, animation_frames, groups): super().__init__(groups) self.sprite_type = "magic" self.frame_index = 0 self.animation_speed = 0.15 self.frames = animation_frames self.image = self.frames[self.frame_index] self.rect = self.image.get_rect(center = pos)
    • Initialise la classe ParticleEffect avec différentes propriétés pour gérer l'animation des particules.

Méthode animate :

python
def animate(self): self.frame_index += self.animation_speed if self.frame_index >= len(self.frames): self.kill() else: self.image = self.frames[int(self.frame_index)]
  • Cette méthode anime les particules en changeant les images à un certain rythme. Si l'animation est terminée, la particule est supprimée.

Méthode update :

python
def update(self): self.animate()
  • Cette méthode met à jour l'animation des particules lorsqu'elle est appelée dans la boucle principale du jeu.

11. Player.py

Ce code définit la classe Player, qui représente le personnage contrôlé par le joueur dans le jeu. Voici une explication ligne par ligne :

Importation de modules et de fonctions :

python
import pygame from Support import import_folder from Settings import * import os, sys
    • Importe les modules nécessaires pour le jeu, y compris Pygame pour la création de jeux, et les fonctions d'assistance.

Changement du répertoire de travail :

python
os.chdir(os.path.dirname(os.path.abspath(__file__)))
    • Change le répertoire de travail actuel pour le répertoire du script en cours d'exécution.

Définition de la classe Player :

python
class Player(Entity): def __init__(self, pos, groups, obstacle_sprites, create_attack, destroy_attack, create_magic): # ... (voir explications ci-dessous) def import_player_assets(self): # ... (voir explications ci-dessous) def input(self): # ... (voir explications ci-dessous) def get_status(self): # ... (voir explications ci-dessous) def cooldowns(self): # ... (voir explications ci-dessous) def animate(self): # ... (voir explications ci-dessous) def get_full_weapon_damage(self): # ... (voir explications ci-dessous) def get_full_magic_damage(self): # ... (voir explications ci-dessous) def get_value_by_index(self, index): # ... (voir explications ci-dessous) def player_death(self): # ... (voir explications ci-dessous) def get_cost_by_index(self, index): # ... (voir explications ci-dessous) def energy_recovery(self): # ... (voir explications ci-dessous) def update(self): # ... (voir explications ci-dessous)

Initialisation de la classe Player :

python
def __init__(self, pos, groups, obstacle_sprites, create_attack, destroy_attack, create_magic): super().__init__(groups) # ... (voir explications ci-dessous)
    • Initialise la classe Player avec différentes propriétés, y compris l'image, la position, les attributs de mouvement, les statistiques du personnage, etc.

Méthode import_player_assets :

python
def import_player_assets(self): character_path = "../Graphics/Player/" self.animations = { "up": [], "down": [], "left": [], "right": [], "right_idle": [], "left_idle": [], "up_idle": [], "down_idle":[], "right_attack": [], "left_attack": [], "up_attack": [], "down_attack": [] } for animation in self.animations.keys(): full_path = character_path + animation self.animations[animation] = import_folder(full_path)
    • Importe les animations du joueur à partir des dossiers correspondants.

Méthode input :

python
def input(self): # ... (voir explications ci-dessous)
    • Gère les entrées du joueur, y compris les mouvements, les attaques et les changements d'arme/magie.

Méthode get_status :

python
def get_status(self): # ... (voir explications ci-dessous)
    • Détermine le statut actuel du joueur en fonction de ses actions, comme les mouvements ou les attaques.

Méthode cooldowns :

python
def cooldowns(self): # ... (voir explications ci-dessous)
    • Gère les temps de recharge des attaques, des changements d'arme/magie et de l'invulnérabilité après avoir été touché.

Méthode animate :

python
def animate(self): # ... (voir explications ci-dessous)
    • Anime le joueur en changeant les images en fonction de son statut et de ses actions.

Méthodes get_full_weapon_damage et get_full_magic_damage :

python
def get_full_weapon_damage(self): # ... (voir explications ci-dessous) def get_full_magic_damage(self): # ... (voir explications ci-dessous)
    • Calcule les dégâts totaux du joueur en combinant les dégâts de base et ceux de l'arme ou de la magie utilisée.

Méthode get_value_by_index :

python
def get_value_by_index(self, index): # ... (voir explications ci-dessous)
    • Renvoie la valeur d'une statistique du joueur en fonction de son index.

Méthode player_death :

python
def player_death(self): # ... (voir explications ci-dessous)
    • Vérifie si le joueur est mort et quitte le jeu si c'est le cas.

Méthode get_cost_by_index :

python
def get_cost_by_index(self, index): # ... (voir explications ci-dessous)
    • Renvoie le coût d'une amélioration en fonction de son index.

Méthode energy_recovery :

python
def energy_recovery(self): # ... (voir explications ci-dessous)

12. Support.py

Ce code fournit deux fonctions utiles :

import_csv_layout : Cette fonction prend en entrée le chemin d'un fichier CSV et renvoie son contenu sous forme de liste de listes. Chaque élément de la liste représente une ligne du fichier CSV, et chaque ligne est elle-même une liste contenant les valeurs séparées par des virgules.

    • path: Chemin du fichier CSV à importer.

import_folder : Cette fonction prend en entrée le chemin d'un dossier contenant des images et renvoie une liste de surfaces Pygame correspondant à ces images.

    • path: Chemin du dossier contenant les images à importer.

Ces fonctions sont utiles pour importer des données externes dans le jeu, telles que des cartes de niveau (fournies sous forme de fichiers CSV) ou des images utilisées pour les graphiques.

 

13. Tile.py

Ce code définit une classe Tile qui hérite de pygame.sprite.Sprite. Cette classe est utilisée pour représenter les tuiles dans un jeu, comme celles qui composent un niveau ou une carte.

Méthodes de la classe Tile :

  • __init__(self, pos, groups, sprite_type, surface) :
    • pos : La position de la tuile sur l'écran.
    • groups : Les groupes de sprites auxquels la tuile appartient.
    • sprite_type : Le type de la tuile, par exemple "object", "grass", etc.
    • surface : La surface de la tuile, qui peut être une surface pygame personnalisée ou une surface vide par défaut.

Dans le constructeur :

  • La méthode __init__ initialise les attributs de la tuile, y compris son image, sa position et sa hitbox (zone de collision).
  • La hitbox est définie en fonction du type de sprite pour gérer correctement les collisions avec d'autres sprites.
  • La position de la tuile est déterminée en fonction de son type pour ajuster sa position en conséquence.

Cette classe est utilisée pour créer et gérer les tuiles du jeu, en leur attribuant un type spécifique et en définissant leurs caractéristiques de collision.

14. Upgrade.py

Ce code définit une classe Upgrade et une classe Item utilisées pour afficher et gérer le système d'amélioration dans un jeu. Voici une explication des principales parties du code :

Classe Upgrade :

  • __init__(self, player) : Initialise les attributs de la classe Upgrade.
    • display_surface : Surface d'affichage.
    • player : Instance du joueur.
    • attribute_nr : Nombre d'attributs à améliorer (santé, énergie, attaque, magie, vitesse).
    • attribute_names : Noms des attributs.
    • max_values : Valeurs maximales des attributs.
    • font : Police d'écriture pour l'affichage.
    • height, width : Hauteur et largeur des éléments d'amélioration.
    • item_list : Liste des éléments à améliorer.
    • selection_index : Index de l'élément sélectionné.
    • selection_time : Temps de la dernière sélection.
    • can_move : Indique si le joueur peut bouger la sélection.

Méthodes de la classe Upgrade :

  • input(self) : Gère les entrées du joueur pour la sélection des améliorations.
  • selection_cooldown(self) : Gère le délai de sélection entre deux mouvements.
  • create_items(self) : Crée les éléments à améliorer.
  • display(self) : Affiche les éléments d'amélioration à l'écran.

Classe Item :

  • __init__(self, l, t, w, h, index, font) : Initialise les attributs de la classe Item.
    • rect : Rectangle représentant la position et les dimensions de l'élément.
    • index : Index de l'élément.
    • font : Police d'écriture pour l'affichage.

Méthodes de la classe Item :

  • display_names(self, surface, name, cost, selected) : Affiche le nom et le coût de l'élément.
  • display_bar(self, surface, value, max_value, selected) : Affiche la barre de progression de l'élément.
  • trigger(self, player) : Gère l'amélioration de l'attribut sélectionné.
  • display(self, surface, selection_num, name, value, max_value, cost) : Affiche l'élément à l'écran en fonction de sa sélection.

15. Weapon.py

Ce code définit une classe Weapon utilisée pour gérer l'affichage et la position des armes du joueur dans un jeu. Voici une explication des principales parties du code :

Classe Weapon :

  • __init__(self, player, groups) : Initialise les attributs de la classe Weapon.
    • player : Instance du joueur auquel l'arme est associée.
    • groups : Groupes de sprites auxquels l'arme appartient.
    • sprite_type : Type de sprite (ici, "weapon").
    • direction : Direction actuelle du joueur.
    • Graphics :
      • Charge l'image de l'arme en fonction du type d'arme et de la direction du joueur.
    • Placement :
      • Place l'arme à une position spécifique par rapport au joueur en fonction de sa direction.
      • Si le joueur regarde vers la droite, l'arme est placée à sa droite.
      • Si le joueur regarde vers la gauche, l'arme est placée à sa gauche.
      • Si le joueur regarde vers le bas, l'arme est placée en dessous de lui.
      • Si le joueur regarde vers le haut, l'arme est placée au-dessus de lui.

Cette classe est utilisée pour créer et positionner les armes du joueur en fonction de sa direction. Elle est destinée à être utilisée dans un jeu où le joueur peut porter différentes armes et où leur position sur l'écran est relative à la position du joueur.