diff --git a/POO/TP/Corrige_TP_Pokemon.md b/POO/TP/Corrige_TP_Pokemon.md index afabca7..aa2de14 100644 --- a/POO/TP/Corrige_TP_Pokemon.md +++ b/POO/TP/Corrige_TP_Pokemon.md @@ -642,108 +642,6 @@ C'est une **composition** d'objets : un `Pokemon` possède une liste d'objets `C --- -## Partie 5 : Héritage (hors programme) - -### Exercice 8 : Sous-classes par type - -```python -class PokemonFeu(Pokemon): - def __init__(self, nom, niveau=1, pv_max=100, attaque=10): - super().__init__(nom, "Feu", niveau, pv_max, attaque) - - def attaquer(self, cible): - """ - Attaque avec ×2 dégâts si la cible est de type Plante. - """ - degats = self.attaque - if cible.type_pokemon == "Plante": - degats = degats * 2 - print("C'est super efficace !") - print(f"{self.nom} attaque {cible.nom} et inflige {degats} dégâts !") - cible.subir_degats(degats) - - -class PokemonEau(Pokemon): - def __init__(self, nom, niveau=1, pv_max=100, attaque=10): - super().__init__(nom, "Eau", niveau, pv_max, attaque) - - def attaquer(self, cible): - """ - Attaque avec ×2 dégâts si la cible est de type Feu. - """ - degats = self.attaque - if cible.type_pokemon == "Feu": - degats = degats * 2 - print("C'est super efficace !") - print(f"{self.nom} attaque {cible.nom} et inflige {degats} dégâts !") - cible.subir_degats(degats) - - -class PokemonPlante(Pokemon): - def __init__(self, nom, niveau=1, pv_max=100, attaque=10): - super().__init__(nom, "Plante", niveau, pv_max, attaque) - - def attaquer(self, cible): - """ - Attaque avec ×2 dégâts si la cible est de type Eau. - """ - degats = self.attaque - if cible.type_pokemon == "Eau": - degats = degats * 2 - print("C'est super efficace !") - print(f"{self.nom} attaque {cible.nom} et inflige {degats} dégâts !") - cible.subir_degats(degats) -``` - -**Explications :** - -- `super().__init__(...)` appelle le constructeur de `Pokemon` : les sous-classes n'ont pas à réécrire l'initialisation des attributs, elles fixent seulement le type. -- Chaque sous-classe **redéfinit** `attaquer`. Quand on écrit `salameche.attaquer(...)`, Python cherche d'abord la méthode dans `PokemonFeu`, et ne remonte à `Pokemon` que s'il ne la trouve pas. -- Les trois méthodes `attaquer` se ressemblent beaucoup : c'est justement la question de l'exercice 10. - ---- - -### Exercice 9 : isinstance() en pratique - -```python ->>> salameche = PokemonFeu("Salamèche", niveau=15, pv_max=70, attaque=12) ->>> isinstance(salameche, PokemonFeu) -True ->>> isinstance(salameche, Pokemon) -True -``` - -`salameche` est une instance des deux classes, car `PokemonFeu` **hérite** de `Pokemon` : un Pokémon Feu **est un** Pokémon. Il possède tous ses attributs et toutes ses méthodes (`est_ko`, `soigner`...). C'est pour cela qu'on peut le placer dans l'équipe d'un `Dresseur` sans rien changer à cette classe. - -```python -def compter_par_type(equipe): - """ - Compte les Pokémon de chaque type. - - :param equipe: (list) Liste de Pokémon - :return: (dict) Dictionnaire {type: nombre} - """ - compteur = {} - for pokemon in equipe: - if pokemon.type_pokemon in compteur: - compteur[pokemon.type_pokemon] += 1 - else: - compteur[pokemon.type_pokemon] = 1 - return compteur -``` - ---- - -### Exercice 10 : Refactoring - -Il n'y a pas de réponse unique. Éléments de discussion : - -- **Avec les sous-classes**, chaque type porte son propre comportement : c'est lisible, et l'on peut donner à un type des particularités qui ne se résument pas à des faiblesses. Mais le code d'`attaquer` est recopié trois fois, et ajouter un type oblige à écrire une nouvelle classe. -- **Avec le dictionnaire `FAIBLESSES`**, toutes les règles sont réunies au même endroit et ajouter une faiblesse se fait en une ligne, sans toucher au code. Il gère aussi naturellement un type faible contre plusieurs autres. -- Pour des **données** (qui bat qui), le dictionnaire est plus adapté. Les sous-classes sont intéressantes quand les types ont des **comportements** vraiment différents. On peut combiner les deux : des sous-classes qui consultent le dictionnaire. - ---- - Auteurs : Florian Mathieu, Enzo Frémeaux, Timothée Decoster Licence CC BY-SA diff --git a/POO/TP/TP_Pokemon.md b/POO/TP/TP_Pokemon.md deleted file mode 100644 index 9b263eb..0000000 --- a/POO/TP/TP_Pokemon.md +++ /dev/null @@ -1,543 +0,0 @@ -# TP : Pokémon Arena - Programmation Orientée Objet - -> **Thème** : Classes, attributs, méthodes, interactions entre objets - ---- - -## Contexte - -Depuis 1996, Pokémon est l'une des franchises les plus populaires au monde. En 2026, avec la sortie de Pokémon Legends: Z-A, la licence bat tous les records. - -Dans ce TP, vous allez créer un **simulateur de combat Pokémon** en utilisant la Programmation Orientée Objet. Vous modéliserez des Pokémon, des dresseurs et des combats. - ---- - -## Partie 1 : La classe Pokémon - -### Exercice 1 : Créer la classe de base - -Créez une classe `Pokemon` avec les caractéristiques suivantes : - -**Attributs :** -- `nom` : nom du Pokémon (str) -- `type_pokemon` : type élémentaire (str) - "Feu", "Eau", "Plante", "Electrik", etc. -- `niveau` : niveau du Pokémon (int, par défaut 1) -- `pv_max` : points de vie maximum (int, par défaut 100) -- `pv` : points de vie actuels (int, initialisé à `pv_max`) -- `attaque` : puissance d'attaque (int, par défaut 10) - -**Méthodes :** -- `__init__` : constructeur -- `__repr__` : affiche le Pokémon sous la forme `"Pikachu (Electrik) - Nv.25 - 80/100 PV"` - -```python -class Pokemon: - def __init__(self, nom, type_pokemon, niveau=1, pv_max=100, attaque=10): - """ - Constructeur de la classe Pokemon. - - :param nom: (str) Nom du Pokémon - :param type_pokemon: (str) Type élémentaire - :param niveau: (int) Niveau du Pokémon - :param pv_max: (int) Points de vie maximum - :param attaque: (int) Puissance d'attaque - """ - # À compléter - pass - - def __repr__(self): - """Représentation textuelle du Pokémon.""" - # À compléter - pass -``` - -**Tests :** -```python ->>> pikachu = Pokemon("Pikachu", "Electrik", niveau=25, pv_max=80, attaque=15) ->>> print(pikachu) -Pikachu (Electrik) - Nv.25 - 80/80 PV -``` - ---- - -### Exercice 2 : Méthodes de combat - -Ajoutez les méthodes suivantes à la classe `Pokemon` : - -```python -def est_ko(self): - """ - Vérifie si le Pokémon est KO. - - :return: (bool) True si PV <= 0, False sinon - """ - # À compléter - pass - -def subir_degats(self, degats): - """ - Inflige des dégâts au Pokémon. - Les PV ne peuvent pas descendre en dessous de 0. - - :param degats: (int) Nombre de dégâts subis - """ - # À compléter - pass - -def attaquer(self, cible): - """ - Attaque un autre Pokémon. - Affiche un message et inflige des dégâts à la cible. - - :param cible: (Pokemon) Pokémon ciblé par l'attaque - """ - # À compléter - pass - -def soigner(self, soin): - """ - Soigne le Pokémon. - Les PV ne peuvent pas dépasser pv_max. - - :param soin: (int) Nombre de PV récupérés - """ - # À compléter - pass -``` - -**Tests :** -```python ->>> pikachu = Pokemon("Pikachu", "Electrik", niveau=25, pv_max=80, attaque=15) ->>> salameche = Pokemon("Salamèche", "Feu", niveau=20, pv_max=70, attaque=12) ->>> pikachu.attaquer(salameche) -Pikachu attaque Salamèche et inflige 15 dégâts ! ->>> print(salameche) -Salamèche (Feu) - Nv.20 - 55/70 PV ->>> salameche.est_ko() -False -``` - ---- - -### Exercice 3 : Système de faiblesses (Bonus) - -En Pokémon, certains types sont plus efficaces contre d'autres : -- **Eau** bat **Feu** (×2 dégâts) -- **Feu** bat **Plante** (×2 dégâts) -- **Plante** bat **Eau** (×2 dégâts) -- **Electrik** bat **Eau** (×2 dégâts) - -Modifiez la méthode `attaquer` pour prendre en compte les faiblesses : - -```python -# Dictionnaire des faiblesses : type_attaquant -> liste des types faibles -FAIBLESSES = { - "Eau": ["Feu"], - "Feu": ["Plante"], - "Plante": ["Eau"], - "Electrik": ["Eau"] -} - -def attaquer(self, cible): - """ - Attaque un autre Pokémon avec prise en compte des faiblesses. - """ - degats = self.attaque - - # Vérifier si le type de la cible est faible contre notre type - if self.type_pokemon in FAIBLESSES: - if cible.type_pokemon in FAIBLESSES[self.type_pokemon]: - degats *= 2 - print(f"C'est super efficace !") - - print(f"{self.nom} attaque {cible.nom} et inflige {degats} dégâts !") - cible.subir_degats(degats) -``` - ---- - -## Partie 2 : La classe Dresseur - -### Exercice 4 : Créer la classe Dresseur - -Un dresseur possède une équipe de Pokémon (maximum 6). - -**Attributs :** -- `nom` : nom du dresseur (str) -- `equipe` : liste de Pokémon (list, vide par défaut) - -**Méthodes :** -- `__init__` : constructeur -- `ajouter_pokemon(pokemon)` : ajoute un Pokémon à l'équipe (max 6) -- `pokemon_disponibles()` : renvoie la liste des Pokémon non KO -- `premier_pokemon_dispo()` : renvoie le premier Pokémon non KO ou None -- `tous_ko()` : renvoie True si tous les Pokémon sont KO -- `__repr__` : affiche le dresseur et son équipe - -```python -class Dresseur: - def __init__(self, nom): - """ - Constructeur de la classe Dresseur. - - :param nom: (str) Nom du dresseur - """ - # À compléter - pass - - def ajouter_pokemon(self, pokemon): - """ - Ajoute un Pokémon à l'équipe si possible (max 6). - - :param pokemon: (Pokemon) Pokémon à ajouter - :return: (bool) True si ajouté, False sinon - """ - # À compléter - pass - - def pokemon_disponibles(self): - """ - Renvoie la liste des Pokémon non KO. - - :return: (list) Liste des Pokémon encore en état de combattre - """ - # À compléter - pass - - def premier_pokemon_dispo(self): - """ - Renvoie le premier Pokémon non KO. - - :return: (Pokemon/None) Premier Pokémon dispo ou None - """ - # À compléter - pass - - def tous_ko(self): - """ - Vérifie si tous les Pokémon sont KO. - - :return: (bool) True si tous KO, False sinon - """ - # À compléter - pass - - def __repr__(self): - """Représentation du dresseur.""" - # À compléter - pass -``` - -**Tests :** -```python ->>> sacha = Dresseur("Sacha") ->>> sacha.ajouter_pokemon(Pokemon("Pikachu", "Electrik", 25, 80, 15)) -True ->>> sacha.ajouter_pokemon(Pokemon("Dracaufeu", "Feu", 50, 150, 25)) -True ->>> print(sacha) -Dresseur Sacha - 2 Pokémon - - Pikachu (Electrik) - Nv.25 - 80/80 PV - - Dracaufeu (Feu) - Nv.50 - 150/150 PV ->>> sacha.tous_ko() -False -``` - ---- - -## Partie 3 : La classe Combat - -### Exercice 5 : Simulateur de combat - -Créez une classe `Combat` qui simule un affrontement entre deux dresseurs. - -**Attributs :** -- `dresseur1` : premier dresseur (Dresseur) -- `dresseur2` : second dresseur (Dresseur) -- `tour` : numéro du tour actuel (int) - -**Méthodes :** -- `__init__` : constructeur -- `lancer_combat()` : lance le combat jusqu'à ce qu'un dresseur n'ait plus de Pokémon -- `afficher_etat()` : affiche l'état actuel du combat - -```python -class Combat: - def __init__(self, dresseur1, dresseur2): - """ - Constructeur de la classe Combat. - - :param dresseur1: (Dresseur) Premier dresseur - :param dresseur2: (Dresseur) Second dresseur - """ - # À compléter - pass - - def afficher_etat(self): - """Affiche l'état actuel du combat.""" - print(f"\n{'='*40}") - print(f"Tour {self.tour}") - print(f"{'='*40}") - # Afficher les Pokémon actifs - # À compléter - pass - - def lancer_combat(self): - """ - Lance le combat tour par tour. - Chaque tour, les deux Pokémon actifs s'attaquent. - Quand un Pokémon est KO, le suivant prend sa place. - Le combat s'arrête quand un dresseur n'a plus de Pokémon. - """ - print(f"\n*** COMBAT : {self.dresseur1.nom} VS {self.dresseur2.nom} ***\n") - - while not self.dresseur1.tous_ko() and not self.dresseur2.tous_ko(): - self.tour += 1 - self.afficher_etat() - - # Récupérer les Pokémon actifs - poke1 = self.dresseur1.premier_pokemon_dispo() - poke2 = self.dresseur2.premier_pokemon_dispo() - - # Le Pokémon 1 attaque - # À compléter - - # Vérifier si Pokémon 2 est KO - # À compléter - - # Le Pokémon 2 attaque (s'il n'est pas KO) - # À compléter - - # Vérifier si Pokémon 1 est KO - # À compléter - - # Afficher le vainqueur - # À compléter - pass -``` - -**Exemple d'exécution :** -``` -*** COMBAT : Sacha VS Pierre *** - -======================================== -Tour 1 -======================================== -Sacha: Pikachu (80/80 PV) -Pierre: Onix (120/120 PV) - -Pikachu attaque Onix et inflige 15 dégâts ! -Onix attaque Pikachu et inflige 18 dégâts ! - -======================================== -Tour 2 -======================================== -Sacha: Pikachu (62/80 PV) -Pierre: Onix (105/120 PV) - -... - -Pikachu est KO ! -Sacha envoie Dracaufeu ! - -... - -Tous les Pokémon de Pierre sont KO ! -*** SACHA REMPORTE LE COMBAT ! *** -``` - ---- - -## Partie 4 : Améliorations - -### Exercice 6 : Centre Pokémon - -Créez une classe `CentrePokemon` qui permet de soigner une équipe : - -```python -class CentrePokemon: - def __init__(self, ville): - """ - :param ville: (str) Ville où se trouve le centre - """ - self.ville = ville - - def soigner_equipe(self, dresseur): - """ - Soigne tous les Pokémon d'un dresseur à 100% de leurs PV. - - :param dresseur: (Dresseur) Dresseur dont l'équipe doit être soignée - """ - # À compléter - pass -``` - ---- - -### Exercice 7 : Capacités spéciales (Pour aller plus loin) - -Créez une classe `Capacite` pour donner des attaques spéciales aux Pokémon : - -```python -class Capacite: - def __init__(self, nom, puissance, type_capacite, pp_max): - """ - :param nom: (str) Nom de la capacité - :param puissance: (int) Puissance de base - :param type_capacite: (str) Type de la capacité - :param pp_max: (int) Nombre d'utilisations max - """ - self.nom = nom - self.puissance = puissance - self.type_capacite = type_capacite - self.pp_max = pp_max - self.pp = pp_max -``` - -Modifiez la classe `Pokemon` pour qu'un Pokémon possède une liste de capacités (max 4) et puisse choisir son attaque. - ---- - -## Partie 5 : Héritage - Spécialiser les Pokémon - -> ⚠️ Cette section est hors programme NSI. -> -> **Prérequis** : avoir vu la section "Pour aller plus loin" du cours POO. - -Jusqu'ici, tous les Pokémon utilisent la même méthode `attaquer`. Mais en vrai, un Pokémon Feu n'attaque pas comme un Pokémon Eau. Plutôt que de gérer ça avec un dictionnaire de faiblesses dans `attaquer`, on peut utiliser l'**héritage** pour créer des sous-classes spécialisées. - ---- - -### Exercice 8 : Sous-classes par type - -Créez trois sous-classes qui héritent de `Pokemon` : - -- `PokemonFeu` : inflige ×2 dégâts aux Pokémon Plante -- `PokemonEau` : inflige ×2 dégâts aux Pokémon Feu -- `PokemonPlante` : inflige ×2 dégâts aux Pokémon Eau - -Chaque sous-classe doit : -1. Hériter de `Pokemon` via `class PokemonFeu(Pokemon):` -2. Appeler `super().__init__(...)` dans son constructeur en fixant `type_pokemon` automatiquement -3. Surcharger la méthode `attaquer` pour appliquer le bonus de dégâts - -```python -class PokemonFeu(Pokemon): - def __init__(self, nom, niveau=1, pv_max=100, attaque=10): - super().__init__(nom, "Feu", niveau, pv_max, attaque) - - def attaquer(self, cible): - """ - Attaque avec ×2 dégâts si la cible est de type Plante. - """ - # À compléter - pass - - -class PokemonEau(Pokemon): - def __init__(self, nom, niveau=1, pv_max=100, attaque=10): - super().__init__(nom, "Eau", niveau, pv_max, attaque) - - def attaquer(self, cible): - """ - Attaque avec ×2 dégâts si la cible est de type Feu. - """ - # À compléter - pass - - -class PokemonPlante(Pokemon): - def __init__(self, nom, niveau=1, pv_max=100, attaque=10): - super().__init__(nom, "Plante", niveau, pv_max, attaque) - - def attaquer(self, cible): - """ - Attaque avec ×2 dégâts si la cible est de type Eau. - """ - # À compléter - pass -``` - -**Tests :** -```python ->>> salameche = PokemonFeu("Salamèche", niveau=15, pv_max=70, attaque=12) ->>> bulbizarre = PokemonPlante("Bulbizarre", niveau=15, pv_max=75, attaque=10) ->>> salameche.attaquer(bulbizarre) -C'est super efficace ! -Salamèche attaque Bulbizarre et inflige 24 dégâts ! ->>> bulbizarre.attaquer(salameche) -Bulbizarre attaque Salamèche et inflige 10 dégâts ! -``` - ---- - -### Exercice 9 : isinstance() en pratique - -1. Vérifiez que `salameche` est à la fois une instance de `PokemonFeu` **et** de `Pokemon`. Expliquez pourquoi. -2. Écrivez une fonction `compter_par_type(equipe)` qui prend une liste de Pokémon et renvoie un dictionnaire `{type: nombre}`. - -```python ->>> equipe = [PokemonFeu("Dracaufeu"), PokemonEau("Tortank"), PokemonFeu("Sulfura"), PokemonPlante("Florizarre")] ->>> compter_par_type(equipe) -{'Feu': 2, 'Eau': 1, 'Plante': 1} -``` - ---- - -### Exercice 10 : Refactoring - -Relisez le dictionnaire `FAIBLESSES` de l'exercice 3. Maintenant que vous avez des sous-classes, ce dictionnaire est-il encore utile ? Quelle approche est plus lisible selon vous ? Discutez. - ---- - -## Résumé des classes - -| Classe | Hérite de | Attributs supplémentaires | Méthodes modifiées | -|--------|-----------|---------------------------|--------------------| -| `Pokemon` | - | nom, type, niveau, pv, attaque | attaquer(), subir_degats(), est_ko() | -| `PokemonFeu` | `Pokemon` | - | attaquer() | -| `PokemonEau` | `Pokemon` | - | attaquer() | -| `PokemonPlante` | `Pokemon` | - | attaquer() | -| `Dresseur` | - | nom, equipe | ajouter_pokemon(), tous_ko() | -| `Combat` | - | dresseur1, dresseur2, tour | lancer_combat() | -| `CentrePokemon` | - | ville | soigner_equipe() | - ---- - -## Code de test final - -```python -# Création des Pokémon -pikachu = Pokemon("Pikachu", "Electrik", 25, 80, 15) -dracaufeu = Pokemon("Dracaufeu", "Feu", 50, 150, 25) -tortank = Pokemon("Tortank", "Eau", 45, 140, 22) -onix = Pokemon("Onix", "Roche", 30, 120, 18) -racaillou = Pokemon("Racaillou", "Roche", 20, 80, 12) - -# Création des dresseurs -sacha = Dresseur("Sacha") -sacha.ajouter_pokemon(pikachu) -sacha.ajouter_pokemon(dracaufeu) -sacha.ajouter_pokemon(tortank) - -pierre = Dresseur("Pierre") -pierre.ajouter_pokemon(onix) -pierre.ajouter_pokemon(racaillou) - -# Lancement du combat -combat = Combat(sacha, pierre) -combat.lancer_combat() - -# Soins au Centre Pokémon -centre = CentrePokemon("Argenta") -centre.soigner_equipe(sacha) -print(sacha) -``` - ---- - -Auteurs : Florian Mathieu, Enzo Frémeaux, Timothée Decoster - -Licence CC BY-SA - -Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International.