La boucle de jeu¶
Vous avez maintenant :
- un joueur
- des ennemis
- des armes
- des sorts
Il est temps de tout assembler pour former un vrai roguelike.
Dans cette page, on va voir :
- comment s’enchaînent les combats
- comment fonctionnent les bonus entre les combats
- et à quoi ressemble la boucle de jeu finale
Et vous allez remarquer une chose importante :
La boucle de jeu est volontairement simple.
Toute la complexité est dans les objets.
Le principe du roguelike¶
Le déroulement général d’une partie est le suivant :
- Le joueur affronte un ennemi
- S’il gagne, il obtient une récompense
- Il choisit un bonus parmi plusieurs options (ou aucun)
- Il affronte un nouvel ennemi
- La partie se termine quand le joueur meurt
En pseudo-code, ça donne :
tant que le joueur est vivant :
créer un ennemi
lancer un combat
proposer un bonus
C’est tout.
Isoler un combat dans une fonction¶
Pour garder un code lisible, on va isoler un combat complet dans une fonction.
Cette fonction :
- gère les tours
- demande les actions au joueur
- fait jouer l’ennemi
- s’arrête quand l’un des deux meurt
Cette fonction ne connaît :
- ni les bonus
- ni le nombre d’étages
- ni la structure globale du roguelike
Elle s’occupe uniquement du combat.
Générer un ennemi¶
Pour l’instant, on peut rester simple :
def generate_enemy(player):
return Zombie(player)
Plus tard, vous pourrez facilement :
- ajouter plusieurs types d’ennemis
- augmenter leur difficulté
- tirer un ennemi au hasard
Sans modifier la boucle de jeu.
Les bonus : le cœur du roguelike¶
Ce qui fait vraiment un roguelike, ce ne sont pas seulement les combats, mais les choix entre les combats.
Après chaque victoire, le joueur :
- se voit proposer 2 bonus aléatoires
- peut en choisir un seul
- ou décider de ne rien prendre
Chaque bonus est un objet, avec sa propre classe et son propre comportement.
La classe Bonus¶
Tous les bonus héritent d’une même classe de base :
class Bonus:
def __init__(self, name, description):
self.name = name
self.description = description
def apply(self, player, ui):
pass
def option_text(self):
return f"{self.name} - {self.description}"
Un bonus sait :
- comment il s’appelle
- ce qu’il fait
- comment s’appliquer au joueur
Exemples de bonus possibles¶
Par exemple :
- récupérer 30 % des PV max
- récupérer 50 % du mana
- gagner +1 ATK de base
- gagner +5 PV max
- changer d’arme
Chaque bonus est une classe différente, et ajoute son effet au joueur quand il est choisi.
Proposer des bonus au joueur¶
On peut isoler la phase de récompense dans une fonction dédiée.
Encore une fois :
- la boucle de jeu ne sait pas quel bonus existe
- elle sait juste quand proposer un bonus
La boucle de jeu complète¶
En combinant :
- les combats
- la génération d’ennemis
- la phase de bonus
on obtient la boucle roguelike finale.
Pourquoi cette architecture est propre¶
- la boucle de jeu est courte et lisible
-
chaque partie du jeu est isolée :
-
combat
- bonus
- génération
- ajouter du contenu ne casse rien
- la POO sert réellement à structurer le système
Si la boucle devenait compliquée, ce serait le signe que les objets sont mal conçus.
Conclusion¶
Avec cette boucle de jeu, vous avez construit :
- un vrai roguelike
- un système extensible
- une architecture claire
- un projet bien structuré en POO
Ce n’est pas juste un exercice : c’est un vrai projet, que vous pouvez continuer à faire évoluer.
Et maintenant, le plus important : essayez d’ajouter vos propres bonus, vos propres ennemis, et vos propres règles.