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é :