Lemmings

Lemmings est un jeu vidéo de réflexion développé par le studio écossais DMA Design (aujourd’hui Rockstar North) et édité par Psygnosis en 1991.

Le joueur doit guider des dizaines de lemmings, minuscules créatures écervelées, dans des niveaux alambiqués truffés de dangers mortels. Le jeu est fondé sur le mythe populaire selon lequel les lemmings, petits rongeurs bien réels des régions arctiques, se livreraient au suicide collectif en se jetant des falaises.

Cliquez ici pour jouer !

Dans ce jeu, les lemmings marchent dans une grotte représentée par une grille à deux dimensions dont chaque case est soit un mur soit un espace vide, un espace vide pouvant contenir au maximum un lemming à un instant donné. Les lemmings apparaissent les uns après les autres à une position de départ, et disparaissent lorsqu’ils atteignent une case de sortie.

Chaque lemming possède les propriétés suivantes :

  • Sa position, donnée par deux coordonnées, désignant la case dans laquelle il se trouve.
  • La direction dans laquelle il se déplace (gauche ou droite).

Les lemmings se déplacent à tour de rôle, toujours dans l’ordre correspondant à leur introduction dans le jeu, de la manière suivante :

  • si l’espace immédiatement en-dessous est libre, le lemming tombe d’une case ;
  • sinon, si l’espace immédiatement devant est libre (dans la direction du lemming concerné), le lemming avance d’une case ;
  • enfin, si aucune de ces deux conditions n’est vérifiée, le lemming se retourne.

 

On propose, pour réaliser un petit programme permettant de voir évoluer une colonie de lemmings, une structure avec une classe Lemmingpour les lemmings, une classe Casepour les cases de la grotte, et une classe principale Jeupour les données globales.

 

Définition des classes

Classe Jeu

La casse principale Jeu contient un attribut grille contenant un tableau de cases (instances de Case) à deux dimensions , et un attribut lemmings  contenant la liste des Lemmings actuellement en jeu.

Son constructeur initialise la grille, par exemple à partir d’une carte donnée par un fichier texte d’un format inspiré du suivant, où le caractère "#"représente un mur, "I"représente l’entrée et "O"la sortie :

#I###############
#               #
#####  ##########
#         #     #
#   #######     #
#               O
######  #########
     #  #
     ####

Cette classe fournit notamment (mais pas uniquement !) les méthodes suivantes :

  • afficher(self) affiche la carte avec les positions et directions de tous les lemmings en jeu ;
  • tour(self) fait « agir » chaque lemming une fois et affiche le nouvel état du jeu ;
    dans cette méthode, il faut « regarder » ce qui se trouve autour de chaque lemming (mur, trou, …) afin de le faire agir en conséquence …
  • demarrer(self) lance une boucle infinie attendant des commandes de l’utilisateur.
    Exemples de commandes : « + » pour ajouter un lemming, « q » pour quitter le jeu,….

 

Classe Lemming

Une classe Lemming avec des attributs entiers positifs let c indiquant la position (ligne et colonne) où se trouve le lemming dans la grille, et un attribut d indiquant sa direction, valant 1 si le lemming se dirige vers la droite et -1 si le lemming se dirige vers la gauche.

Cette classe fournit en outre les méthodes suivantes :

  • __str__ (self) renvoie '>' ou '<' selon la direction du lemming ;
  • avancer(self) déplace le lemming, dans la bonne direction, droite ou gauche (selon la direction dans laquelle il se trouve – changement de colonne) ;
  • retourner(self) retourne le lemming (changement de direction) ;
  • tomber(self) fait tomber le lemming (changement de ligne);

ATTENTION : le lemming ne regarde pas ou il va → ce n’est pas lui qui décide quoi faire s’il y a un mur en face, un autre lemming, un trou, … Tout ceci est géré par la méthode tour du jeu.

 

Classe Case

La classe Case contient un attribut terrain contenant le caractère représentant la caractéristique de la case (mur, vide, sortie, entrée … comme dans le fichier texte décrivant la grotte), et un attribut lemming contenant l’éventuel lemming présent dans cette case et None si la case est libre.

Cette classe fournit notamment les méthodes suivantes :

  • __str__ (self) renvoie le caractère à afficher pour représenter cette case ou son éventuel occupant ;
  • estLibre(self) renvoie True si la case est peut recevoir un lemming (elle n’est ni un mur, ni occupée par un lemming) ;
  • liberer(self) retire le lemming présent dans la case ;
  • occuper(self, lem) place le lemming lem sur la case ;

 

 

 

 

 

Déroulement du jeu

La méthode Jeu.demarrer lance une boucle infinie, dont une issue passe par l’appui sur la touche "q"(« quitter ») du clavier. Le rythme du jeu est donné par une constante de classe Jeu.PERIODE. Le calcul des positions des lemmings, suivi de l’affichage du jeu a lieu chaque Jeu.PERIODE secondes.

A chaque « tour », les lemmings font un mouvement (avancer, tomber ou se retourner), dans l’ordre de leur entrée dans le jeu. Lorsque l’un d’entre eux atteint la sortie, il quitte le jeu (on pourra par exemple à cette occasion incrémenter un attribut score du jeu)

Si l’utilisateur appui sur la touche « + », un nouveau lemming rentre dans le jeu.

 

Ressources possibles

Gestion des touches du clavier

On peut utiliser la classe GestionnaireEvenement qui utilise la bibliothèque keyboard, décrite sur cet article.

 

 

Gestion des tableaux

On peut stocker les tableaux de jeux dans un fichier .txt. Pour ouvrir et lire ce fichier, rien de tel que le module os et la structure with … as … .

 

Amélioration de l’affichage

Avec des caractères plus complets

█ pour les murs

…..

 

Avec des couleurs

Plusieurs méthodes :

class bcolors: 
    VIOLET = '\033[95m' 
    BLEU = '\033[94m' 
    CYAN = '\033[96m' 
    VERT = '\033[92m' 
    JAUNE = '\033[93m' 
    ROUGE = '\033[91m' 
    ENDC = '\033[0m' 
    BOLD = '\033[1m' 
    UNDERLINE = '\033[4m' 
    

print(f"Voici un {bcolors.ROUGE}texte{bcolors.ENDC} {bcolors.BOLD}avec{bcolors.ENDC} des {bcolors.BLEU}couleurs{bcolors.ENDC}")

Remarque : fonctionne avec certains terminaux seulement (pas avec l’IDLE de Python, ni avec Pyzo, mais avec VSCode)

Ou bien utiliser une bibliothèque, comme termcolor.

 

Avec des cases de plusieurs caractères

 

Implémenter une classe pour gérer l’interface utilisateur

 

Exemple en animation

 

Cette base peut ensuite évidemment être étendue avec des terrains plus variés, de nouvelles possibilités d’interaction pour le joueur, des objectifs en termes de nombre de lemmings sauvés, etc…

 

 

 

 

Source : https://www.editions-ellipses.fr/accueil/10445-20818-specialite-numerique-et-sciences-informatiques-lecons-avec-exercices-corriges-terminale-nouveaux-programmes-9782340038554.html#/1-format_disponible-broche

Vous aimerez aussi...

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *