Aller au contenu

Boss final : Rogue-like en POO

Dans cette partie, vous allez réaliser un projet que peut-être vous ne pensiez pas pouvoir faire : un petit rogue-like en Python.

Un vrai jeu, avec :

  • un personnage jouable
  • des ennemis
  • des tours de combat
  • et surtout : une structure en programmation orientée objet qui tient la route

On va donc y aller étape par étape, et dans cette première page on va juste construire la base du jeu : un joueur, un mob, et un combat simple.

Le but ici n’est pas encore d’avoir un rogue-like complet. Le but, c’est d’avoir une structure propre avec de l’héritage, qu’on va ensuite enrichir.

Créer la base : entités, joueur, mobs

L’idée principale de cette étape est la suivante :

  • Entity : une classe de base pour tout ce qui peut se battre
  • Player : une entité contrôlée par le joueur
  • Mob : une entité contrôlée par l’ordinateur
  • puis des classes concrètes :
  • Warrior (un type de joueur)
  • Zombie (un type de mob)

Là où ça devient intéressant, c’est que :

  • Warrior hérite de Player
  • Player hérite de Entity
  • Zombie hérite de Mob
  • Mob hérite de Entity

Donc au final :

  • un Warrior est une Entity
  • un Zombie est une Entity

Et ça, ça va nous permettre d’avoir un système super extensible ensuite.

La classe Entity

Créez une classe Entity qui possède :

  • des points de vie (pv)
  • une attaque (atk)
  • un booléen alive

Et deux méthodes :

  • get_damaged(deg) : enlève des PV, gère la mort et affiche ce qu’il se passe
  • attack(target) : attaque une autre entité

Le but, c’est de pouvoir écrire :

zombie.attack(player)
player.attack(zombie)

et que ça fonctionne.

La classe Player

Créez une classe Player qui hérite de Entity.

Cette classe représente une entité contrôlée par le joueur, donc elle possède :

  • une liste d’options (par exemple ["Attaquer", "Fuite"])
  • une méthode act(opt, target) qui exécute l’action choisie

Dans cette première version :

  • si l’option est "Attaquer", alors le joueur attaque la cible
  • l’option "Fuite" sera gérée dans la boucle principale

La classe Warrior

Créez une classe Warrior qui hérite de Player.

Ce guerrier est votre classe de personnage jouable de base. Par exemple :

  • 20 PV
  • 5 d’attaque

Faites en sorte qu’un Warrior s’affiche joliment (avec __str__) en affichant simplement "Guerrier".

La classe Mob

Créez une classe Mob qui hérite de Entity.

Un mob doit avoir une cible (le joueur) et être capable de jouer son tour. Donc :

  • le mob possède target
  • le mob possède une méthode play() qui attaque sa cible

La classe Zombie

Créez une classe Zombie qui hérite de Mob.

Par exemple :

  • 10 PV
  • 2 d’attaque

Et comme pour le guerrier, faites un __str__ pour afficher "Zombie".

Faire un combat simple

Une fois toutes ces classes créées, faites un programme qui :

  1. Crée un joueur Warrior
  2. Crée un ennemi Zombie qui cible le joueur
  3. Lance une boucle tant que les deux sont vivants

  4. À chaque tour :

  5. le joueur choisit une action dans la liste (attaquer ou fuite)

  6. si fuite : on sort de la boucle
  7. sinon : le joueur agit
  8. puis le zombie joue

Exemple d'exécution

Voici à quoi peut ressembler une exécution typique :

Guerrier doit se battre contre Zombie
Que voulez-vous faire ?
1: Attaquer
2: Fuite
Votre choix : 1
Guerrier attaque Zombie !
Zombie subit 5 dégats (5 PV restants) !
Zombie attaque Guerrier !
Guerrier subit 2 dégats (18 PV restants) !
Que voulez-vous faire ?
1: Attaquer
2: Fuite
Votre choix : 1
Guerrier attaque Zombie !
Zombie est mort !

Remarques importantes

  • Oui, ce jeu est encore très simple.
  • Oui, on pourrait le faire sans POO.

Mais l’objectif ici est de construire une base extensible : ensuite, on pourra rajouter facilement :

  • plusieurs classes de joueur
  • plusieurs mobs
  • des sorts
  • du mana
  • de l’XP
  • des niveaux
  • des bonus aléatoires

Et si la structure de base est bien faite maintenant, la suite sera beaucoup plus facile.

Dans la page suivante, on va rajouter un vrai système d’attaque plus intéressant : des armes équipables et des comportements différents selon la classe du personnage.