Objectif Pédagogique: Se familiariser avec Pygame et les techniques d'intelligence artificielle comportementale appliquées aux jeux vidéo
J'ai développé ce projet pour des apprentis. Ce projet a pour objectif d'aider les apprentis à maîtriser progressivement Pygame, depuis les bases jusqu'à la création d'un jeu complet intégrant des agents IA adaptatifs.
- Configurer un environnement de développement Pygame et comprendre la game loop
- Manipuler sprites, surfaces, rectangles, collisions et événements clavier/souris
- Construire une architecture de jeu orientée objet professionnelle (Game States, Entity System)
- Implémenter des effets visuels avancés : particules, explosions, scrolling
- Générer des effets sonores procéduraux avec numpy + pygame
- Intégrer des comportements d'IA : FSM, A*, Boids, difficulté adaptative
Introduction aux concepts fondamentaux de Pygame et de la programmation de jeux.
Concepts clés:
- Game loop (60 FPS)
- Gestion des événements (clavier, souris, fermeture fenêtre)
- Rendering et delta time
- Sprites et collisions
Voici une démonstration de l'application : l'écran de démarrage, les vagues, la scène du boss et l'écran de victoire.
Développement d'un space shooter 2D professionnel avec architecture modulaire.
nebula_strike/
├── main.py # Point d'entrée + game loop principale
├── settings.py # Toutes les constantes
├── entities/
│ ├── player.py # Classe Player (vaisseau joueur)
│ ├── enemy.py # Ennemis (Drone, Destroyer, Carrier)
│ ├── boss.py # Boss avec machine à états
│ ├── bullet.py # Projectiles
│ └── powerup.py # Power-ups (bouclier, tir triple, bombe EMP)
├── systems/
│ ├── particles.py # Système de particules (explosions, trainées)
│ ├── sound_manager.py # Sons procéduraux générés
│ ├── hud.py # HUD (santé, score, vague, énergie)
│ ├── wave_manager.py # Gestionnaire de vagues ennemies
│ ├── pathfinding.py # A* pathfinding (Partie 3)
│ ├── boids.py # Essaim Boids (Partie 3)
│ └── adaptive_difficulty.py # Difficulté adaptative (Partie 3)
├── utils/
│ └── helpers.py # Fonctions utilitaires
└── .gitignore
| Fonctionnalité | Description |
|---|---|
| Système de vagues | 5 vagues progessives + Boss spécial |
| 3 types d'ennemis | Drone (rapide), Destroyer (canon), Carrier (porte-drone) |
| Boss multi-phase | 4 phases avec patterns d'attaque différents |
| Système de particules | Explosions, trainées, onde EMP |
| Power-ups | Bouclier régénérant, tir triple, bombe EMP |
| Effets sonores | Générés procéduralement (numpy + pygame) |
| HUD complet | Santé, bouclier, score, vague, barre boss |
Intégration de 4 techniques d'IA pour créer des comportements ennemis intelligents et adaptatifs.
Machine à états avec 5 phases : PATROL, CHASE, ATTACK, EVADE, RETREAT
PATROL (patrouille)
↓
CHASE (poursuite si détecté)
├→ ATTACK (attaque rapprochée)
├→ EVADE (esquive balle)
└→ RETREAT (recul si HP < 40%)
Priorités de transition:
- Éviter les balles proches (distance < 100px)
- Retraite si HP < 40%
- Attaque si proche du joueur (distance < 170px)
- Poursuite si détecté (distance < 280px)
Algorithme de pathfinding sur grille discrète pour naviguer autour d'obstacles.
- Grille: 40px par cellule (22x17 cellules pour 900x700)
- Heuristique: Distance euclidienne
- Mouvements: 8-directionnels (cardinaux + diagonaux)
- Mise à jour: Recalcul du chemin toutes les 0.8s
Modèle de Craig Reynolds (1986) avec 3 règles simples:
| Règle | Effet | Poids |
|---|---|---|
| Séparation | Éviter les voisins proches | 1.8 |
| Alignement | Suivre la direction moyenne | 1.0 |
| Cohésion | Rester groupé | 1.0 |
| Poursuite joueur | Chercher le joueur | 1.5 |
Vitesse = max(MAX_SPEED, séparation + alignement + cohésion + poursuite)
Surveille les performances du joueur et ajuste les paramètres du jeu en temps réel.
Métriques de performance:
- Précision de tir (accuracy) : 40%
- Kills par minute (kpm) : 30%
- Ratio de survie (deaths) : 30%
Score de difficulté: [0.0 (très facile) → 2.0 (très difficile)] | Cible = 1.0
Multiplicateurs adaptatifs:
- Vitesse ennemis :
0.7x → 1.5x - Taux spawn :
0.6x → 1.3x - HP ennemis :
0.8x → 1.4x - Taux power-ups :
5% → 25%
- Python 3.11+
- pip (gestionnaire de paquets)
- Cloner le repository:
git clone https://github.com/yourusername/nebula-strike.git
cd nebula-strike- Créer un environnement virtuel (recommandé):
python -m venv venv- Activer l'environnement virtuel:
Windows (PowerShell):
.\venv\Scripts\Activate.ps1Windows (CMD):
venv\Scripts\activate.batLinux/Mac:
source venv/bin/activate- Installer les dépendances:
pip install pygame==2.6.0 numpy- Lancer le jeu:
cd nebula_strike
python main.py| Action | Clavier |
|---|---|
| Mouvement | ↑ ↓ ← → ou W A S D |
| Tir | SPACE |
| Pause | P |
| Bombe EMP | B |
| Menu | ENTRÉE pour démarrer |
| Rejouer | R après Game Over |
| Quitter | ESC |
Tous les paramètres du jeu sont centralisés dans settings.py:
# Fenêtre
WIDTH, HEIGHT = 900, 700
FPS = 60
# Couleurs
C_BG = (4, 4, 20) # Fond bleu nuit
C_PLAYER = (0, 200, 255) # Cyan
C_BULLET_P = (255, 255, 100) # Jaune
C_DRONE = (200, 50, 50) # Rouge sombre
C_DESTROYER = (255, 140, 0) # Orange
C_CARRIER = (180, 0, 220) # Violet
C_BOSS = (255, 50, 150) # Rose
# Gameplay
PLAYER_HP = 100
PLAYER_SPEED = 5.5
SHIELD_MAX = 100
SHIELD_REGEN = 0.15
# Ennemis
DRONE_HP, DRONE_SPD = 20, 2.5
DESTROYER_HP, DESTROYER_SPD = 60, 1.5
CARRIER_HP, CARRIER_SPD = 120, 0.8
BOSS_HP = 1000
# Scoring
SCORE_DRONE = 100
SCORE_DESTROYER = 300
SCORE_CARRIER = 500
SCORE_BOSS = 5000Architecture basée sur les entités (Pygame Sprite Groups) pour gestion efficace de milliers d'objets.
Utilisée pour les états du jeu (MENU, PLAYING, PAUSED, GAME_OVER, VICTORY) et les comportements IA.
Pool d'objets légers pour explosions, trainées et effets visuels sans surcharge mémoire.
Génération procédurale de sons avec numpy (laser, explosion, power-up, transitions boss).
| Vague | Contenu | Difficulté | Boss |
|---|---|---|---|
| 1-2 | Drones progressifs | Facile | Non |
| 3-4 | Drones + Destroyers | Moyen | Non |
| 5 | Essaim Boids + Elite | Difficile | Non |
| 6+ | Vague adaptée | Dynamique | OUI |
- Game loop fonctionnelle à 60 FPS
- Mouvements du vaisseau fluides (delta time)
- Affichage des étoiles avec parallaxe
- État MENU → PLAYING → GAME_OVER
- 3 types d'ennemis avec comportements distincts
- Système de particules colorées
- Boss avec 3 phases (PHASE1, PHASE2, PHASE3)
- Collisions joueur/ennemis/balles
- HUD affichant tous les infos
- Sons procéduraux jouant aux moments clés
- FSM de l'Elite affichant transitions console
- A* calculant chemins contournant astéroïdes
- Essaim Boids montrant séparation/alignement/cohésion
- Mode debug (F1) affichant métriques difficulté
- WaveManager adaptant contenu selon performance
| Type | Couleur | Cas d'usage |
|---|---|---|
| Explosion | RGB selon ennemi | Mort d'ennemi |
| Trainée | Cyan (0, 150, 255) | Propulsion joueur |
| Onde EMP | Cyan fluo (0, 255, 200) | Bombe EMP |
| Éclairs Boss | Rouge (255, 50, 50) | Rage du boss (Phase 3) |
MAX_PARTICLES = 500 # Limite totale
spawn_explosion(x, y, color, count=40, speed=4)
spawn_trail(x, y, color=(0,150,255))
spawn_emp(x, y, radius=120)| Son | Technique | Paramètres |
|---|---|---|
| Laser | Onde carrée + sweep freq | 880Hz → 200Hz, 0.08s |
| Explosion | Bruit blanc + enveloppe | 0.4s, attaque rapide |
| Power-up | Arpège (Do-Mi-Sol-Do) | 4 notes ascendantes |
| Boss Phase | Sinusoïde montante | 200Hz → 1000Hz |
- Système de sauvegarde du meilleur score (JSON)
- Éditeur de niveaux graphique
- Support multijoueur local (2 joueurs)
- Boss IA avec Q-Learning (apprentissage par renforcement)
- Génération procédurale de niveaux (Perlin noise)
- Port WebAssembly avec Pygbag (navigateur)
- Réseau de neurones PyTorch pour clonage comportemental
- FSM: Game Programming Patterns - State
- A:* Red Blob Games A* Pathfinding
- Boids: Craig Reynolds - Boids Simulation
Un rapport complet (2-3 pages) est attendu couvrant:
- Analyse comparative des 4 techniques IA
- Résultats mesurés du système adaptatif (graphe)
- Critique du modèle Boids et améliorations
- Proposition d'extension : Boss IA avec Q-Learning
Projet pédagogique ENSAM — 4ème année IATD
Département Mathématiques et Informatique
Durée estimée: 8-10 heures (3-4 séances)
Langage: Python 3.11+ / Pygame 2.x
Prérequis: Python OOP, algorithmes de base, notions d'IA
Ce projet est fourni à titre pédagogique sous licence MIT. Consultez LICENSE pour détails.
- Le jeu s'exécute sans erreurs à 60 FPS
- Tous les contrôles fonctionnent
- Les 4 techniques IA sont visibles et fonctionnelles
- Le rapport pédagogique est complet et réfléchi
- (Bonus) Implémentation d'une extension proposée
Pour toute question, consultez:
- La documentation Pygame officielle
- Les commentaires détaillés dans le code source
- Le rapport pédagogique inclus
Bon développement!
Made by AMLLAL Amine
