Pong

Ce jeu est une réplique du jeu d'arcade Pong utilisant la bibliothèque Pyxel.

Utilisation

1. Installer Python (3.11+)
2. Créer et activer un environnement virutel (recommendé)

# Créer l'environnement virtuel
python -m venv venv

# Activer l'environnement (Linux/MacOS)
source ./venv/bin/activate

# Activer l'environnement (Windows)
.\venv\Scripts\activate.bat

3. Installer les dépendances

python -m pip install -r requirements.txt

4. Lancer le jeu

python main.py

Fonctionnalités

Il existe 2 types de partie : classique (2 joueurs) ou solo (1 joueur contre l'ordinateur)

Partie classique (2 joueurs)

• Chaque joueur contrôle une raquette avec le clavier (A et Q à gauche, P et M à droite).
• Avant de démarrer une partie, on peut tester les contrôles, cependant la position des raquettes est réinitialisée au début de la partie.
• Appuyer sur Entrée lance la partie.
• La balle part du milieu de la surface de jeu, à gauche ou à droite en alternant tous les 2 points (à chaque point à partir de 10-10).
• Elle rebondit sur les bords haut et bas de l'écran.
• Lorsqu'elle touche une raquette, elle rebondit et la direction dépend de son impact avec la raquette : si elle touche le haut de la raquette, elle part vers le haut et inversement.
• Lorsqu'elle manque la raquette, l'autre joueur marque un point et un nouvel échange commence immédiatement.
• Il y a une petite zone inaccessible en haut et en bas où l'on ne peut pas mettre la raquette, ainsi, si la balle y arrive le joueur ne peut pas la renvoyer et perd le point, le but est d'éviter des parties infinies.
• La vitesse de la balle augmente aléatoirement à chaque contact avec une raquette
• Le premier joueur à 11 points gagne, sauf s'il y a moins de 2 points d'écart, auquel cas la partie se poursuit jusqu'à ce qu'un joueur ait 2 points de plus que l'autre.

Partie solo (contre l'ordinateur)

• Les règles sont les mêmes que pour une partie classique.
• La raquette gauche est contrôlée automatiquement par l'ordinateur.
• Au lancement du jeu, un menu permet au joueur de choisir la diffuculté.

Les niveaux de difficultés sont :

Nom	Comportement
Nice	Prévoit la trajectoire de la balle et la renvoie sur la raquette du joueur si possible, le plus près possible sinon.
Easy	Essaie toujours d'avoir sa raquette en face de la balle.
Normal	Prévoit la trajectoire de la balle et se place de manière à la renvoyer, sans essayer de viser.
Hard	Comme le niveau précédent mais essaie de viser le plus loin possible de la raquette adverse.
Very Hard	Comme le niveau précédent mais, si possible, vise les zones inaccessibles en haut et en bas.

Menus

• On peut naviguer dans les différents menus en utilisant les touches Haut et Bas.
• On peut sélectionner une option avec la touche Entrée.
• En jeu, on peut accéder au menu pause avec la touche Entrée.

Enregistrement/chargement de partie

• Dans le menu pause, on peut enregistrer une partie en choisissant un emplacement (entre 1 et 5).
• Dans le menu principal, on peut charger une partie en choisissant son emplacement (entre 1 et 5).
• Les parties sont enregistrées au format JSON dans le dossier saves/.

Paramètres

• Un menu de paramètre permet de configurer certains comportements du jeu.
• On peut naviguer entre les options grâce aux touches Gauche et Droite.
• On peut modifier la valeur de l'option actuelle avec les touches Haut et Bas.
• On peut réinitialiser la valeur de l'option actuelle avec la touche R.
• On peut enregistrer les changements et quitter avec la touche Entrée.
• Certaines options proposent de tester les modifications, les raquettes sont alors contrôlables avec les mêmes touches qu'en jeu.

Les options sont :

Nom	Valeur par défaut	Unité	Description
Default ball speed	3,5	pixels/frame	Vitesse de la balle lors de la mise en jeu. En réalité, la vitesse est générée aléatoirement à partir de cette valeur.
Ball spawn random direction range	0,3	-	Lorsque la balle apparaît, sa direction est choisie aléatoirement dans cette plage de valeurs.
Paddle speed	3	pixels/frame	Vitesse des raquttes
Paddle length (height)	25	pixels	Taille (hauteur) de la raquette
Ball color	blanc	-	Couleur de la balle (blanc/orange)

La configuration du jeu est enregistrée au format JSON dans le fichier config.json. À l'ouverture du jeu, si le fichier existe il est chargé, sinon il est créé.

Implémentation

L'organisation des modules est la suivante :

• main.py: point d'entrée du programme et classe App (voir plus loin)
• game/: classes qui représentent les parties et les éléments du jeu
  • game.py : classe Game et sous-classes
  • ball.py: balle
  • paddle.py: raquette
  • ai.py: IAs (pour le mode solo)
• menu/: menus de l'application
  • menu.py: classe Menu (générique)
  • main.py: menu principal
  • pause.py: menu pause
  • save.py: menus d'enregistrement/chargement de partie
  • ai.py: menu permettant de choisir la difficulté de l'IA en mode solo
• config.py: classe Config, représentant la configuration du jeu
• settings.py: écran de paramètre
• consts.py: constantes du jeu
• screen.py: classe abstraite Screen et classe MessageScreen
• save.py: classe abstraite Savable et fonctions génériques pour le JSON
• util.py: fonctions diverses
• vec.py: classe Vec2, représentant un vecteur 2D (pour la physique de la balle)

Classes

Les classes les plus importantes sont :

• App (définie dans main.py)
  • Représente l'application, gère l'initalisation, le lancement et la fermeture de la fenêtre Pyxel.
  • Un attribut (screen) contient l'écran actuellement ouvert (ex : un menu ou une partie).
  • À chaque frame, l'écran actuel est mis à jour (méthode update()) puis affiché (méthode draw()).
  • Lorsqu'on démarre le programme, le menu principal est ouvert (c'est alors l'écran actuel de l'application). Celui-ci permet de lancer une partie ou d'ouvrir d'autres menus.
• Screen (définie dans screen.py)
  • Classe abstraite mère de tous les écrans.
• Menu (définie dans menu/menu.py)
  • Classe mère de tous les menus.
• Game (définie dans game/game.py)
  • Classe mère des classes représentant les parties : MultiGame (partie classique) et SoloGame (partie solo).
• AI (définie dans game/ai.py)
  • Classe mère de toutes les IAs, chaque niveau est représenté par une classe : EasyAI, NormalAI, HardAI, VeryHardAI et NiceAI