cahier des charges pacman

Ecole Supérieure d’Ingénieurs de Luminy
Département Informatique
Université de la Méditerranée
Luminy case 925
13 288 Marseille Cedex 09
Tél. 04 91 82 85 00
[email protected]
Cahier des charges
19 novembre 2007
ANDRE Julie
DUPRAT Boris
2ème année
Enseignants responsables :
DANIEL Marc
MAVROMATIS Sébastien
Cahier des charges
Sommaire
I – INTRODUCTION .............................................................. - 3 1 – Objet ................................................................................. - 3 2 – Contexte ........................................................................... - 3 3 – Terminologie ..................................................................... - 4 -
II – DESCRIPTION DU PRODUIT ........................................ - 5 1 – Caractéristiques ................................................................ - 5 2 – Interface ........................................................................... - 6 3 – Exigences non fonctionnelles ............................................ - 6 -
III – LIVRABLES .................................................................... - 7 IV – CONDITIONS DE REALISATION ................................. - 8 1 – Délai de réalisation ........................................................... - 8 2 – Contraintes de développement ........................................ - 8 3 – Suivi de la réalisation ........................................................ - 8 -
V – Annexes ......................................................................... - 9 Document de conception ....................................................... - 9 -
ANDRE Julie
DUPRAT Boris
Projet Pac-Man
2ème année
-2-
Cahier des charges
I – INTRODUCTION
L’objectif de notre projet est de réaliser un jeu de labyrinthe de type Pac-Man.
1 – Objet
Ce cahier des charges a pour but de présenter ce projet. Il inclut donc
une description détaillée, visant à définir les spécifications de base de notre
produit. Il définit également les objectifs à atteindre et permet d’évaluer la
charge de travail ainsi que le temps nécessaire à sa réalisation.
2 – Contexte
La réalisation de ce jeu s’inscrit dans le cadre du projet de
programmation orientée objet proposé aux étudiants de 2ème année de la filière
Informatique de l’ESIL. Ce projet, réalisé en binôme, a donc pour but de nous
familiariser avec ce type de programmation.
ANDRE Julie
DUPRAT Boris
Projet Pac-Man
2ème année
-3-
Cahier des charges
3 – Terminologie
Le vocabulaire utilisé tout au long de cette présentation peut contenir un
vocabulaire spécifique à l’univers du jeu Pac-Man, il est donc préférable
d’expliciter le sens de chacun de ces mots afin que tout soit parfaitement clair.
- Pac-Man : Pac-Man est le personnage emblématique du jeu. En forme
de rond jaune et doté d’une bouche, il est contrôlé par
l’utilisateur.
- Fantômes : Il y a quatre fantômes qui sont les ennemis du Pac-Man. Ils
ont pour but de le tuer.
- Pac-gomme : Une pac-gomme est une pastille jaune dont se nourrit le
Pac-Man. Il existe quatre pac-gommes spéciales qui
rendent les fantômes vulnérables durant une certaine
période.
- Bonus : Les bonus se matérialisent sous forme de fruits. Ils rapportent
des points supplémentaires au Pac-Man si celui-ci les mange.
ANDRE Julie
DUPRAT Boris
Projet Pac-Man
2ème année
-4-
Cahier des charges
II – DESCRIPTION DU PRODUIT
1 – Caractéristiques
Le Pac-Man, sorti en 1979, est un jeu d’arcade très célèbre. Cependant il
semble nécessaire d’en rappeler le principe de fonctionnement.
Le but du jeu est de faire ramasser au Pac-Man toutes les pac-gommes à
l’intérieur du labyrinthe, en évitant d’être touché par des fantômes. Le PacMan peut dévorer les fantômes pendant un temps limité après avoir ramassé
une des 4 pac-gomme spéciales. Le joueur dispose de 3 vies.
Il peut augmenter son score :
- en ramassant des pac-gommes (10 points pour une classique, 50 pour
une spéciale)
- en dévorant les fantômes (200 points pour le premier, le double pour
les suivants pour une même pac-gomme)
- en ramassant des bonus dont le nombre de points rapportés
augmente avec les niveaux.
Une fois toutes les pac-gommes ramassées, le joueur passe au niveau
suivant. Plus il avance dans les niveaux, plus les fantômes sont rapides afin
d’augmenter la difficulté.
Notre programme respectera au maximum les règles du jeu original.
Nous essaierons de rendre l’intelligence artificielle des fantômes la plus
évoluée possible, notamment en personnalisant le comportement de chaque
fantôme, si le temps nous le permet.
ANDRE Julie
DUPRAT Boris
Projet Pac-Man
2ème année
-5-
Cahier des charges
2 – Interface
Le jeu se lancera dans une fenêtre OpenGL. L’utilisateur accèdera
directement au menu qu’il pourra gérer avec la souris. Le joueur aura le choix
entre :
-
commencer une partie avec le labyrinthe par défaut
sélectionner un des labyrinthes alternatifs
consulter les meilleurs scores
afficher les règles du jeu
quitter l’application
Une fois la partie démarrée, le Pac-Man sera contrôlé à l’aide du Pad
directionnel du clavier.
L’utilisateur peut s’il le souhaite, créer ses propres labyrinthes en
modifiant un fichier texte contenant un modèle de référence.
3 – Exigences non fonctionnelles
Notre jeu sera exécuté sous Linux et sous Windows. Les librairies Glut et
OpenGL seront fournies.
Le programme étant relativement léger, les problèmes de performance
ne se posent pas. Nous essayerons simplement de rendre l’affichage le plus
fluide possible.
Notre jeu étant un projet dans le cadre de nos études, il sera gratuit et
libre de droits.
Les utilisateurs ayant la possibilité de créer leur propre labyrinthe en
modifiant le fichier texte de référence, il est nécessaire que la carte soit valide.
En effet, le Pac-Man doit pouvoir ramasser l’ensemble des pac-gommes. De
plus, l’utilisateur ne devra pas modifier le nom de ce fichier.
ANDRE Julie
DUPRAT Boris
Projet Pac-Man
2ème année
-6-
Cahier des charges
III – LIVRABLES
Une fois le projet achevé, les éléments suivants seront livrés à l’E.S.I.L. :
-
le présent cahier des charges
un exécutable du Pac-Man et son code source
un manuel d'utilisation du jeu
un site web de présentation du projet
un rapport du projet
ANDRE Julie
DUPRAT Boris
Projet Pac-Man
2ème année
-7-
Cahier des charges
IV – CONDITIONS DE REALISATION
1 – Délai de réalisation
Ce cahier des charges devra être rendu au plus tard le lundi 19 novembre
2007.
Notre projet devra être terminé pour le vendredi 21 décembre 2007 date
à laquelle l’ensemble des documents seront livrés. La soutenance aura lieu le
mercredi 19 décembre 2007.
2 – Contraintes de développement
Ce projet devra être développé en C++, il utilisera donc les techniques de
la programmation orientée objet. Concernant l’interface graphique, nous nous
servirons des librairies OpenGL.
Par souci de qualité, nous programmerons en suivant certaines règles
dans le but d’obtenir un code bien structuré et donc réutilisable et facile à
maintenir.
3 – Suivi de la réalisation
Nous communiquerons régulièrement à nos clients l’état d’avancement
de notre projet par l’intermédiaire de mails ou directement dans les locaux
durant les heures consacrées à ce projet.
Pour toute remarque ou suggestion, nous sommes joignables par mail aux
adresses suivantes :
[email protected]
[email protected]
ANDRE Julie
DUPRAT Boris
Projet Pac-Man
2ème année
-8-
Cahier des charges
V – Annexes
Document de conception
Pour ce projet, nous avons distingué deux « choses » :
- le labyrinthe
- les personnages
Nous avons décidé de représenter le labyrinthe par un tableau
bidimensionnel. Pour être visible de tous, cette donnée est globale. Cette
matrice contient des entiers représentant les différents éléments (murs, pacgommes classique et spéciales, bonus, Pac-Man et fantômes).
Les personnages du jeu, aussi bien le Pac-Man et les Fantômes, ont des
caractéristiques communes. Nous avons donc décidé de rassembler ces
données communes dans une classe Perso. Nous spécialisons les personnages
avec deux classes : Pac-Man et Fantôme (héritant donc de la classe Perso).
Perso
PacMan
ANDRE Julie
DUPRAT Boris
Fantome
Projet Pac-Man
2ème année
-9-
Cahier des charges
Nous pensons représenter ces données de la manière suivante :
class Perso
{
protected :
unsigned int _x, _y; // coordonnees
unsigned int _direction; // sens du mouvement
(1:haut, 2:bas, 3:gauche, 4:droite)
unsigned int _vitesse; // 0 : normal, 1 : rapide
unsigned int _img; // numero correspondant a un
fichier image
public :
// constructeurs
Perso (void); // par defaut
Perso (unsigned int x, unsigned int y, unsigned int
Direction, unsigned int Vitesse, unsigned int Img); // par
valeur
Perso (const Perso & P); // par recopie
// accesseurs
unsigned int GetX (void) const;
unsigned int GetY (void) const;
unsigned int GetDirection (void) const;
unsigned int GetVitesse (void) const;
unsigned int GetImg (void) const;
// modifieurs
void SetX (unsigned int x);
void SetY (unsigned int y);
void SetDirection (unsigned int Direction);
void SetVitesse (unsigned int Vitesse);
void SetImg (unsigned int Img);
// autres fonctions
virtual void Affiche (void) = 0; // affiche a la
console les informations du perso
virtual void Avance (void) = 0; // recupere la
direction et avance jusqu'au mur (le labyrinthe fait 19 par
22)
// destructeur
~Perso (void);
// surcharge d'operateurs
friend ostream & operator << (ostream & flux, const
Perso & P); // affiche a la console les informations du perso
}; // classe Perso
ANDRE Julie
DUPRAT Boris
Projet Pac-Man
2ème année
- 10 -
Cahier des charges
class PacMan : public Perso
{
private :
int _nbVies;
unsigned int _score;
public :
// constructeurs
PacMan (unsigned int Direction = 3, unsigned int
Vitesse = 0, unsigned int Img = 1, int NbVies = 2, unsigned
int Score = 0); // par defaut et par valeur
PacMan (const PacMan & P); // par recopie
// accesseurs
int GetNbVies (void) const;
unsigned int GetScore (void) const;
// modifieurs
void SetNbVies (int NbVies);
void SetScore (unsigned int Score);
// autres fonctions
void Affiche (void); // affiche a la console les
informations du perso
void Avance (void); // recupere la direction et
avance jusqu'au mur
// destructeur
~PacMan (void);
// surcharge d'operateurs
friend ostream & operator << (ostream & flux, const
PacMan & P); // affiche a la console les informations du perso
}; // classe PacMan
ANDRE Julie
DUPRAT Boris
Projet Pac-Man
2ème année
- 11 -
Cahier des charges
class Fantome : public Perso
{
private :
unsigned int _etat; // 0: vivant, 1 : vulnerable, 2 :
mort
public :
// constructeurs
Fantome (void); // par defaut
Fantome (unsigned int x, unsigned int y, unsigned int
Direction = 1, unsigned int Vitesse = 0, unsigned int Img =
20, unsigned int Etat = 0); // par valeur
Fantome (const Fantome & F); // par recopie
// accesseurs
unsigned int GetEtat (void) const;
// modifieurs
void SetEtat (unsigned int Etat);
// autres fonctions
void Affiche (void); // affiche a la console les
informations du perso
void Avance (void); // recupere la direction et
avance jusqu'au mur
void IA_Deplacer (void);
void Ressuciter (void); // si un fantome se fait
manger, le fantome reapparait au centre de la carte au bout
d'un certain temps
// destructeur
~Fantome (void);
// surcharge d'operateurs
friend ostream & operator << (ostream & flux, const
Fantome & F); // affiche a la console les informations du
perso
}; // classe Fantome
ANDRE Julie
DUPRAT Boris
Projet Pac-Man
2ème année
- 12 -