# 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 20 dégâts !
========================================
Tour 2
========================================
Sacha: Pikachu (60/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 NC
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International.