Lemmings by night

Logo

• Encadrants: Eric GASCARD (tuteur), Michael PERIN
• Elèves RICM3: Paul LABAT (Chef de projet), Robin EUDES, Rodolphe FREBY, Pierre-Henri GINOUX, Adji-Ndèye-Ndaté SAMBE

• File:LemmingByNight-Flyer.pdf
• File:LemmingByNight-Poster.pdf
• File:LemmingByNight-ScreenCast.wav
• File:LemmingByNight-Presentation.pdf
• [Dépôt des sources]

Description (Contrat)

Lemmings est un jeu paru dans les années 1990. L’objectif est d’amener de charmants petits bonshommes en robe bleue avec des cheveux verts vers la sortie. Cependant, ces nobles créatures ne peuvent effectuer que des actions très basiques. Mais elles peuvent également se spécialiser, pour creuser un tunnel dans un mur, ou pour escalader celui-ci. Le but du jeu est de trouver la meilleure combinaison possible pour permettre au plus grand nombre d’atteindre l’arrivée sans encombre, et d’avoir un nombre de lemmings sauvés supérieur ou égal au nombre de lemmings requis pour gagner le niveau ! Cependant, la nuit rôde... vous pouvez perdre de vue le décor, ou même vos lemmings...

L’application vous propose une interface graphique avec une carte, dans laquelle se déplacent vos lemmings. Vous avez à votre disposition une palette d’actions que vous pouvez affecter à vos lemmings afin de résoudre le puzzle et d’atteindre la sortie ! Au travers de boutons, vous pouvez également mettre le jeu en pause, accéder au menu ou même quitter le jeu. Chaque carte est unique, et il n’existe pas forcément une seule combinaison de Lemmings afin de réussir le niveau. Personnalisez à volonté votre configuration afin de vous amuser à chaque fois !

Voici le contrat de base qui nous a été fixé :

  . Jeu classique 
  . Map décrite en XML avec texture
  . Défilement de la nuit
  . Chargement d'un lemmings utilisateur
  . Lemmings contrôlable 
  . Bruitage
  . Notification d'un XML invalide

En bonus :

  . Pop-up au dessus du lemming sélectionné
  . Portails de téléportation

En extension :

  . Chargement du XML par gui
  . Sauvegarde

Manuel Utilisateur

1. Fonctionnalités du logiciel

Lemmings : Night is Coming vous permet de configurer un grand nombre d’objets pour votre jeu :

● Ajoutez l’automate de votre choix, pour avoir un type de lemmings supplémentaire et personnalisable.

● Personnalisez vous-même les automates de base.

● Spécifiez le nombre de lemmings que vous désirez avoir pendant le jeu.

● Spécifiez le nombre d’actions bonus supplémentaires

● Créez votre propre monde en personnalisant la carte.

2. Installation

Pour jouer au jeu Lemmings : Night is Coming, vous devez avoir un interpréteur Ocaml ainsi qu’une machine virtuelle Java en version 1.7. Il vous faut ensuite désarchiver le fichier Lemmings_NIC.tar.gz puis suivre les instructions suivantes :

Étape 1 : édition du fichier de configuration

D’abord, il faut saisir tous les paramètres du jeu. Pour cela, il faut éditer le fichier ParserXML.ml, tout en consultant le fichier types.ml où ont été définis tous les types de façon explicite pour vous guider.

Un fichier Ocaml de base est fourni. Vous pouvez soit éditer ce fichier de configuration soit éditer le fichier XML généré par l’exécution du fichier Ocaml.

- Syntaxe du langage

Il y a des procédures à respecter. Seules les actions définies ci-dessous sont prises en compte :

● marcher

● tourner

● tomber

● monter

● mourir

● atterrir

● grimper

● bloquer

● retourner

● creuserH

● creuserV

● creuserD

● construire

Il en est de même pour les conditions que sont :

● isEau

● isVide

● isMortel

● isSol

● isObstacle

● isBloqueur

● hautMap

● isCorniche

● isEscalier

● isEsca

● isCreusableH

● finH

● finV

● isCreusableV

● finD

● isCreusableD

● finE

En cas de non-respect de ces primitives (conditions et actions), lors du lancement du jeu, non seulement le fichier XML ne sera pas exécuté mais une fenêtre d’erreur s’affichera pour indiquer l’emplacement de l’erreur que vous serez amené à rectifier.

En ce qui concerne le sens des blocs, vous avez 2 possibilités : horizontal et vertical. De même, on a 9 types de blocs:

● 1 = vide

● 2 = earth

● 3 = water

● 4 = escalier

● 6 = nondestructible

● 7 = creusable

● 8 = le spawn

● 9 = la sortie

Il faudra faire aussi attention à ce que les noms des boutons définis correspondent aux noms des comportements de l’automate. Vous pouvez aussi donner le nom d’utilisations de vos boutons.

Dans le jeu, vous disposez de 9 automates qui définissent les comportements des lemmings dont 8 déjà initialisés. Vous avez alors la possibilité de rajouter un seul et un seul nouvel automate, et pas plus. Si cette contrainte n’est pas respectée, un message d’erreur sera généré lors du lancement du jeu. Il faut cependant souligner qu’un ordre de priorité a été établi dans la déclaration des automates. Si vous voulez rajouter votre nouvel automate, il faut veiller à le déclarer à la suite de ceux déjà définis.

Pour les autres paramètres, vous pouvez les définir comme bon vous semble, vous êtes le maître du jeu.

- Exemple de fichier de configuration

Comme évoqué, les paramètres que vous allez définir doivent être en accord avec les types prédéfinis et les contraintes évoquée.

Voici un exemple de fichier de configuration :

let contexte = (50, 10, 5);;
(***********************  automate bloqueur ********************)
let transition1 = ("BLOQUE", "BLOQUE", "bloquer",["isSol"]);;
let transition2 = ("BLOQUE", "RETOUR", "retourner",["isVide"]);;
let automate = ("1",[trans1; trans2]);;
let comportement = ("bloqueur",[automate]);;
(*************** génération de la sortie et de deux spawns ***********)
let bloc1 = (9, 45, 126, "vertical", 4);;
let bloc2 = (8, 1 , 2, "vertical", 5);;
let bloc3 = (8, 5, 125, "vertical", 5);;
let liste_blocs =[bloc1;  bloc2;  bloc3] ;;
(********************** définition boutons  **********************)
let bouton1 = ( "parapluie", 10);;
let bouton2 = ("grimpeur", 10);;
let liste_boutons = [bouton1; bouton2] ;;
let jeu = (contexte, [comportement], liste_blocs, liste_boutons);;

Étape 2 : exécution de l’exécutable

Pour les utilisateurs de système Unix, se placer dans le dossier contenant le jeu, puis exécuter le fichier launcher.sh dans un terminal. Vous pouvez créer un fichier personnalisé qui pourra être chargé lors de l’exécution du jeu.

Concernant les utilisateurs de Windows, le fichier launcher.bat permet de faire les mêmes actions que décrites précédemment.

3. Utilisation du logiciel

3.1 Commandes

Voici la liste des raccourcis qui sont utilisables pendant le jeu. Ils permettent de sélectionner le bouton correspondant ou d’effectuer une action spécifique.

3.2 Menu

Lorsque le jeu est lancé, le menu apparait. Il permet de choisir différents sous-menus dont le menu « play ».

Lorsque l’on sélectionne le bouton « play », un sélecteur de fichier apparait. Il permet de choisir le fichier XML à charger. Ainsi, les modifications appliquées soit au fichier ParserXML.ml soit celles appliquées directement au fichier XML seront prises en compte lors de l’exécution du jeu.

Si vous sélectionnez Annuler au lieu de Ouvrir le fichier de base nommé FichierXML.xml qui se situe à la racine du dossier du jeu sera chargé.

3.3 Fenêtre de jeu

3.3.1 Menu

Il est composé de 5 boutons :

Menu : Permet de retourner au menu principal.

Reset : Permet de réinitialiser le jeu en cours de partie.

Pause : Met le jeu en pause.

Reprendre : Permet de sortir du mode pause.

Quitter : Quitter le logiciel.

3.3.2 Barre d'information

Cette barre située en haut de la fenêtre de jeu contient les informations relatives au jeu. On y retrouve le temps de jeu (limité à 5 minutes), le nombre de lemmings vivants et morts, ainsi que les objectifs à atteindre et l’état d’avancement du joueur dans le niveau.

Les boutons à droite de cette barre d’information permettent de changer la vitesse de jeu, un compteur est là pour connaître la vitesse actuelle.

3.3.3 Boutons de changement d'état

Cette barre contient l'ensemble des boutons qui permettent de changer les états des lemmings. Chaque bouton est représenté de la façon suivante :

Le chiffre en haut indique le nombre restant d'utilisation du bouton. L'image à l'intérieur de ce bouton indique le type d'action associée. Dans le cas ci-dessus, il reste dix utilisations du bouton « bombe ». Dans le cas où il n'y a pas d'image correspondant à une action, un texte remplace l'image.

Voici la liste des boutons accessibles :

Manuel Développeur

Introduction

Le présent manuel donne toutes les instructions nécessaires pour la compréhension du logiciel Lemmings : Night is coming. Ce logiciel a pour objectif de simuler des lemmings grâce à des automates, afin de produire un jeu. Ceci est effectué par une saisie des données de l’utilisateur dans un fichier OCAML de manière à définir tous les paramètres qui seront nécessaires au jeu. Leur évolution sera faite par la suite par un programme codé en Java, et visualisé à l’aide d’une interface graphique.

Partie 1

I. Structure du fichier Ocaml

Le fichier OCAML est rempli par l’utilisateur. Cependant, il doit veiller à respecter la définition des types tels qu’ils ont été définis ainsi que la grammaire du langage. Le non-respect de ces procédures entrainera une erreur d’exécution lors de la génération du fichier XML.

Ci-dessous, la définition des types :

(*********************************** Contexte  ***********************************************)
type objectif = int;;
type nombreLemmings = int;;
type tempsMax = int;;
type contexte = objectif * nombreLemmings *  tempsMax ;;
(************************************* Automate ********************************************)          
type  nature = string ;;
type numero = string ;;
type etat = string ;;
type action  = string ;;
type condition = string ;;
type transition = etat * etat * action * condition list ;;
type automate = numero * transition list;;
type comportement = nature * automate list ;;
(**************************************************** Map ************************************************)
type type = int;;
type coordonneesX = int;;
type coordonneesY = int;;
type sens = string ;;
type taille = int;;
type Bloc = type * coordonneesX *  coordonnesY * sens * taille ;;
type map = Bloc list ;;
(************************************************** Boutons *********************************************)
type nom = string ;;
type nombreCoups = int ;;
type bouton = nom * nombreCoups ;;
type liste_boutons = bouton list;;
(****************************************************** jeu ************************************************)
type jeu = contexte * comportement list *  map * liste_boutons ;;

Édition du fichier XML

La fonction ecriretout permet la génération du fichier XML. Cette fonction écrit dans le fichier XML toutes les informations saisies au préalable par l’utilisateur tout en respectant les types. Ni un parser, ni une redéfinition des types sous forme de token n’est nécessaire.

Néanmoins, deux instructions sont requises pour la génération du fichier XML :

— open string ;;

On fait appel au module String qui nous fournit l’ensemble des fonctions nécessaires pour la manipulation de chaines de caractères. Parmi-elles, nous avons la fonction length qui permet de calculer la taille d’une chaine de caractère donnée en entrée par l’utilisateur.

— let sortie = open_out "Fichier.xml";;

Cette ligne indique le fichier XML à créer ou à écraser s’il existe déjà.

La fonction ecriretout regroupe les fonctions suivantes :

ecrirejeu : permet de spécifier l’objectif du jeu, le nombre de lemmings ainsi que la durée du jeu

ecriretoutComportement : décrit la liste des comportements des lemmings

ecriremap : affiche l’ensemble des blocs de la map

ecriretoutBouton : affiche les boutons de l’interface graphique

Ces fonctions utilisent elles-mêmes des fonctions intermédiaires qui sont adaptées à d’éventuelles modifications (par exemple ajout de nouveaux attributs).

Voici un exemple de fichier XML généré :

Dans le cas contraire, un message d’erreur est généré pour indiquer le bon type à utiliser.

Partie 2

I. Structure du logiciel

L’architecture du logiciel repose sur le modèle MVC (Modèle-Vue-Contrôleur). Elle est découpée de la façon suivante :

Le modèle assure la gestion des événements et le fonctionnement des automates.

Le contrôleur déclenche les événements et informe des changements au modèle.

La vue gère l’affichage du monde.

II. Organisation du code Java

Le code est découpé en plusieurs paquets. Parmi eux se trouvent :

II.1 jus.ricm.contexte

Ce package comprend la classe Contexte. Cette classe contient l’ensemble des variables qui sont nécessaires au fonctionnement du programme et qui doivent être uniques. De plus, celles-ci sont accessibles depuis n’importe quelle classe. Grâce au contenu de cette classe, nous pouvons exécuter le jeu, le mettre en pause, etc. La classe Contexte comprend également une méthode qui permet de réinitialiser le contexte, qui peut être par exemple utile lorsque l’on veut faire une nouvelle partie.

II.2 jus.ricm.lemmings

Il contient la classe Lemmings. Cette classe représente tous les petits lemmings qui se déplaceront dans la fenêtre de jeu. Elle regroupe aussi tous les attributs permettant de représenter un lemming : sa position dans l’espace, son automate courant, son état courant dans l’automate. Les conditions particulières qui s’appliquent sur lui, et son état dans le jeu (vivant, mort ou arrivé à la sortie). Elle contient également les méthodes permettant de définir les événements qui s’appliquent à un lemming, et ainsi d’envoyer ces données dans l’automate, afin de trouver son état futur, et l’action qu’il doit effectuer.

II.3 jus.ricm.automate

Contiens les classes Automate et AutomateSuivantCondition. La première permet de représenter un automate. Elle contient des méthodes pour créer un automate, l’afficher et pour effectuer une transition d’un état vers un autre. La seconde permet de représenter une transition au travers d’un couple liant un état d’arrivée, une liste de conditions pour atteindre le-dît état d’arrivée, et l’action associée à ce changement d’état.

II.4 jus.ricm.gestionBouton

Ce package contient l’ensemble des écouteurs de bouton. Ils permettent d’assigner une action particulière à chaque type de bouton. De cette façon, il suffit de modifier une classe pour modifier le comportement d’un ensemble de boutons qui utilisent ce type d’écouteur.

II.5 jus.ricm.graphique

Dans ce package sont présentes les classes gérant l’affichage du jeu. Une classe Bloc permet de définir ce qu’est un bloc et tous les attributs qui seront nécessaires aux lemmings pour se déplacer ; une classe Map qui définit les méthodes permettant de se déplacer dans une matrice de bloc et de la modifier de façon rapide. Il y a également trois classes principales. Les classes Menu, FenetreJeu et FenetrePrincipale définissent les fenêtres du logiciel qui seront vues par l’utilisateur. Il existe également deux classes qui permettent de définir le sélecteur de fichier XML qui est lancé juste avant le démarrage de la partie. Enfin, la classe Map_canvas définit les méthodes d’affichages du décor, des lemmings, ainsi que les animations diverses et la méthode faisant apparaitre les lemmings à intervalle régulier.

II.6 jus.ricm.interpreteur

Il gère le fichier XML donné en entrée. Dans ce package, la classe ParserXML contient une méthode qui permet de parcourir l’ensemble du fichier XML afin de récupérer tous ses nœuds et attributs. Tous les objets concernant le contexte (l’objectif que l’utilisateur doit atteindre, le nombre de lemmings dans le jeu et la durée du jeu), les automates des lemmings, la map et les boutons y sont créés et initialisés.

II.7 jus.ricm.ordonnanceur

Dans ce package se trouve une unique classe. Elle définit le thread principal qui constitue le moteur de jeu. Elle contient également les méthodes qui permettent de savoir si le jeu est fini (en fonction du temps, du nombre de lemmings encore en vie et l’objectif que l’utilisateur doit atteindre). La méthode effectuant le traitement des lemmings est présente dans cette classe. Elle demande à chaque lemming d’interagir et de se déplacer dans son environnement, au moyen des méthodes définies dans la classe Lemmings.

II.8 jus.ricm.sound

Ce package contient la classe sound. Elle implémente Runnable et cloneable. La majorité des initialisations et des chargements sont effectués dans le constructeur. On charge un buffer dans le constructeur, ce qui permet par la suite de ne pas avoir à recharger le fichier son. On instancie donc dans le contexte un objet son en static, qui sera par la suite cloné à chaque utilisation. Ensuite, on lance un thread qui exécute le son demandé. Ce système nous permet de parcourir en une seule fois les fichiers audio pour une optimisation maximale du temps d’exécution.

III. Principe de fonctionnement du simulateur

Une fois le chargement du fichier XML fait, la carte ainsi que les boutons sont initialisés. Ensuite, le simulateur traite à chaque cycle 5 étapes :

— Mise à jour de l’affichage :

— Mise à jour du temps

— Mise à jour des informations concernant le jeu, telle que le nombre de lemmings en vie, le temps de jeu. — Traitement de chaque lemming un à un :

— Analyse de leur environnement proche afin de déterminer une liste de conditions liées aux lemmings

— Recherche de la transition dans l’automate adaptée en comparant la liste de condition représentant l’environnement du lemming avec la liste de condition nécessaire pour une transition.

— Application de l’action associée à la transition trouvée, avec la mise à jour des attributs des lemmings si nécessaire.

— Vérification des conditions de victoire.

La classe Ordonnanceur possède une méthode gameLoop() permettant de mettre à jour l’affichage, de parcourir les lemmings, d’appeler la méthode effectuant les transitions et les actions liées aux automates en fonction des conditions.

La classe Lemmings quant à elle possède une méthode transition qui est appelée dans l’Ordonnanceur. Celle-ci analyse totalement l’environnement autour du lemming (vérification de la présence du sol, du vide, d’un mur…) et crée ainsi une liste de condition représentant de manière symbolique cet environnement. Par la suite, la méthode transition va chercher l’état suivant dans l’automate en fonction de l’environnement entourant le lemming et d’une liste de conditions nécessaires au changement d’état, ainsi que l’action associée. Enfin, la méthode effectue l’action en mettant à jour les attributs du lemming qui auraient pu être modifiés par l’action.

Ci-dessous, un exemple de quelques une des méthodes de tests de l’environnement du lemming, ainsi que quelques une des méthodes pour la résolution des actions :

La classe Automate quant à elle possède une méthode permettant de trouver la transition adaptée pour un lemming. Elle prend en paramètre une liste de condition (celle du lemming) et renvoie un objet EtatSuivantCondition, qui est un couple comprenant une liste de String représentant les conditions pour atteindre un état, un String pour le nom de l’état d’arrivée, et un String pour l’action.

Cette classe comprend également une méthode capable de renvoyer un entier représentant l’indice de l’état dans l’automate passé en paramètre :