EsilSquadron (shoot`them`up)

Transcription

Département
informatique
RAPPORT FINAL
(DOCUMENT DE CONCEPTION)
Version 1.0
EsilSquadron
(shoot’them’up)
Projet de POO de deuxième année
Enseignants responsables et
clients :
Marc DANIEL
Sébastien MAVROMATIS
SIGNATURE*
SIGNATURE*
* Le présent document devra être signé à réception par l’un des clients, au moins.
Maîtres d’œuvres :
Sylvain LARGIER
Jonathan FAVIER
Promotion 2008
Mardi 26 décembre 2006
École Supérieure d’Ingénieurs de Luminy, département Informatique
Sommaire
I. Domaine d’application............................................................................................................ 3
1.1 Objectifs du système ........................................................................................................ 3
1.2 Interfaces utilisateurs, logiciels et matériels .................................................................... 3
1.2.1 Interface utilisateur.................................................................................................... 3
1.2.2 Interface logicielle..................................................................................................... 7
1.2.3 Interface matérielle.................................................................................................... 7
1.3 Contraintes générales de conception ................................................................................ 7
II. Documents de référence ........................................................................................................ 8
III. Conception générale............................................................................................................. 9
3.1 Langage utilisé ................................................................................................................. 9
3.2 Architecture générale ..................................................................................................... 11
3.2.1 Conception UML – Diagramme de classes............................................................. 11
3.2.2 Interfaces détaillées des modules ............................................................................ 12
3.3. Structure des fichiers et données globales..................................................................... 13
3.4. Stratégie de traitement des erreurs ................................................................................ 14
3.5. Justification du choix de l’architecture et des modules................................................. 14
IV. Conception détaillée des modules...................................................................................... 15
4.1 Module Objet.................................................................................................................. 15
4.1.1. Variables globales et macro-instructions ............................................................... 15
4.1.2. Classes.................................................................................................................... 16
4.1.3. Méthodes internes .................................................................................................. 18
4.1.4. Modules utilisés...................................................................................................... 18
4.1.5. Pseudo-code des algorithmes complexes ............................................................... 18
4.2 Module Jeu ..................................................................................................................... 20
4.2.2. Classes.................................................................................................................... 20
4.3 Module Utilitaires .......................................................................................................... 23
4.3.2. Classes.................................................................................................................... 25
4.4 Module Menus................................................................................................................ 29
4.4.2. Classes.................................................................................................................... 29
V. Tableau d’allocation des modules ....................................................................................... 32
VI. Spécifications techniques ................................................................................................... 32
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
Document de conception 1.0
2
I. Domaine d’application
1.1 Objectifs du système
L’objectif du projet est la conception d’un jeu de type shoot’em’up, un jeu de tirs en
2D. Le principe du jeu est simple : le joueur est un pilote de vaisseau spatial, qui doit survivre
aux multiples attaques lancées par différents vaisseaux spatiaux ennemis. Les vaisseaux
ennemis peuvent avoir leur propre comportement ; il s'agit donc de gérer les collisions entre le
vaisseau du joueur et ceux des ennemis, le décor, les missiles. Il est ensuite possible de gérer
le "scrolling 2D", et de nombreux autres détails tels que les explosions, l'environnement dans
lequel évolue le vaisseau,etc.
1.2 Interfaces utilisateurs, logiciels et
et matériels
1.2.1 Interface utilisateur
Les interfaces homme-machine (IHM) du projet EsilSquadron se divisent en 6 parties :
Menu Principal : interface de départ permettant d’accéder aux autres interfaces du jeu.
On y accède soit dès l’ouverture du programme, soit en revenant d’un autre menu
(touche Echap), soit lorsqu’on a perdu. Chacun des sous-menus proposés dans le
menu principal est accessible soit en cliquant dessus soit en le sélectionnant avec les
flèches directionnelles puis en appuyant sur la touche Entrée.
Illustration 1 : Menu principal
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
3
Menu Aide : interface accédée à partir du menu principal, permettant d’afficher des
informations sur le but du jeu et son fonctionnement.
Illustration 2 : Menu Aide
Menu Records : interface accédée à partir du menu principal et de l’interface de saisie
des scores, permettant d’afficher les dix meilleurs scores enregistrés dans le jeu (avec
pour chaque score le nom du joueur correspondant et le nombre de vaisseaux détruits).
Illustration 3 : Menu Records
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
4
Saisie du score: interface accédée à partir du moment où l’on termine le jeu,
permettant de saisir son nom pour qu’il soit enregistré dans les meilleurs scores du jeu.
Cette interface affiche également des statistiques sur la partie terminée (le nombre de
missiles envoyés, le nombre de bonus obtenus, les vaisseaux ennemis détruits).
Illustration 4: Saisie du score
Menu Configuration : interface accédée à partir du menu principal, permettant de
sélectionner le niveau de jeu (facile, normal ou expert) et le vaisseau du joueur
(XWing ou Faucon Millenium).
Illustration 5 : Menu Configuration
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
5
Ecran de jeu : interface accédée à partir du menu principal, permettant de jouer au jeu.
Illustration 6 : Ecran de jeu
Voici le diagramme d’état du projet qui permet de visualiser les transitions entre les
interfaces et les états du jeu:
Illustration 7 : diagramme d’état
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
6
1.2.2 Interface logicielle
Le projet est compilable sous système UNIX et Windows avec le compilateur GCC.
Nous avons donc veillé à ce que toutes les bibliothèques dynamiques, quand elles sont
utilisées, soit bien installées (l’utilisateur ne doit pas avoir à s’en occuper, tout les fichiers
nécessaires doivent être copiés lors de l’installation de l’application). Le cahier des charges
mentionnant une installation simplifiée de l’application, nous avons utilisé pour l’installation
sous Windows un dossier archivé (contenant un dossier qui rassemble un exécutable ainsi que
tous les fichiers nécessaires au bon fonctionnement du logiciel) et pour l’installation sous
Linux un makefile.
1.2.3 Interface matérielle
Le programme est opérationnel sur les machines compatibles PC. Une carte graphique
de base suffit pour une exécution correcte du logiciel. Le périphérique d’entrée standard est le
clavier, celui de sortie est un écran de type VGA. Les bibliothèques standards utilisent par
défaut ces paramètres.
ATTENTION : Le jeu est développé pour fonctionner correctement sur deux
types de résolutions d’écran : 1280*800 (ordinateur portable) et 1152*864 (ordinateur
fixe). Pour les autres résolutions, nous ne garantissons pas un affichage correct des
images.
1.3 Contraintes
Contraintes générales de conception
L’équipe de conception était composée de deux étudiants ingénieurs, Jonathan
FAVIER et Sylvain LARGIER, responsables de la réalisation complète du projet. En raison
des contraintes géographiques et temporelles, la réalisation de ce projet impliquait une
organisation rigoureuse et une répartition des tâches bien définie.
Il a été décidé par l’équipe de conception que le logiciel serait développé sur le
système d’exploitation Windows XP (en veillant cependant à faire périodiquement des tests
sur les systèmes UNIX ainsi que sur les machines dotées d’un système MAC) grâce à
l’environnement de développement gratuit Bloodshed Software® Dev C++ 4.9. Ce choix
s’explique par la facilité d’utilisation de librairies externes et par la possibilité de visualiser et
de modifier facilement le Makefile généré. Il est à noter que Bloodshed Software® Dev C++
4.9 utilise GCC pour compiler ses programmes. Nous avons veillé aussi à n’utiliser que des
bibliothèques d’entrée-sortie standard. Toutefois, nous avons vérifié périodiquement que le
projet reste compilable et exécutable sur les deux systèmes utilisés, Windows et Unix.
De plus, la conception du projet devait être modulaire. Ainsi, chaque grande
fonctionnalité du projet est implémentée dans un module différent (menu.h, vaisseau.h,
planete.h, etc.). Cela assure la clarté et la réutilisation du code. Le développement en équipe et
la répartition des tâches sont ainsi simplifiés. Le projet EsilSquadron a dû suivre une
architecture basée sur le modèle objet. La conception détaillée de ses modules a été menée et
illustrée grâce à des schémas sous la norme UML.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
7
Enfin, la date de présentation du projet est le jeudi 18 janvier 2007. A cette date, le
produit, la documentation complète ainsi que la page Web de présentation du projet
EsilSquadron doivent être terminés.
II. Documents de référence
- Documents relatifs aux cours de Génie Logiciel donné par William BOHER-COY à l’ESIL:
Initialisation au Génie Logiciel : Analyse des besoins
Initialisation au Génie Logiciel : Cycles de développement
Initialisation au Génie Logiciel : Conception
Formation/Action : Gestion de Projet (cours de 2ème année).
- Documents liés directement à la réalisation du jeu:
Sujet de POO, Marc DANIEL et Sébastien MAVROMATIS, 2006.
Cours de POO – C++, Marc DANIEL.
Cours d’OpenGL et de GLUT, Sébastien MAVROMATIS. Le manuel d’utilisation des
fonctions graphiques (le Red Book), ainsi qu’un manuel d’utilisation du système de
fenêtrage GLUT ont également été utilisés.
Tutorial sur la bibliothèque FMOD : http://tastalian.free.fr/cours.php?part=FMOD
Exemples de code sur Internet et projets divers des années précédentes pour
l’utilisation de la librairie SDL.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
8
III. Conception générale
3.1 Langage utilisé
utilisé
Le jeu est réalisé en C++, un langage particulièrement bien adapté à un projet
de programmation orientée objet. Le compilateur utilisé est GCC, gratuit, standard et
performant. Nous avons bien sûr établis des règles de codage pour tous les fichiers sources, de
manière à faciliter la lecture du code et à le simplifier. Les interfaces du jeu sont réalisées à
l’aide des bibliothèques SDL (pour l’aspect graphique) et FMOD(pour le son).
On utilise la bibliothèque SDL pour l’affichage du jeu à l’écran. Cette bibliothèque
gratuite est particulièrement pratique pour créer des applications multimédias en 2
dimensions. On la retrouve sous de nombreux systèmes d’exploitation (Mac OS X, Linux,
gamme Windows, FreeBSD, etc). Elle est simple, flexible et portable, et gère très facilement
l'affichage vidéo, les événements et la gestion des périphériques communs comme le clavier
et la souris.
La fonction SDL_BlitSurface prend en paramètres la surface source, l'adresse d'un SDL_Rect
permettant de ne sélectionner qu'une partie de la surface source à dessiner, la surface
destination et l'adresse d'un autre SDL_Rect qui indique la position à partir de laquelle copier
l'image source. Cette fonction permet ainsi d’afficher une surface sur une autre, c’est ce qu’on
appelle le blit.
SDL nous permet aussi d’utiliser le double buffering : cette technique consiste à avoir non pas
une, mais deux zones d'écran: l'une représente l'écran affiché actuellement et l'autre le
prochain écran en préparation. Dès que le nouvel écran est terminé, le pointeur de mémoire
vidéo est modifié pour pointer sur celui-ci, et lors du prochain balayage vidéo le nouvel écran
apparaît d'un coup. L'ancienne zone affichée devient alors la zone de travail dans laquelle est
préparé le prochain écran à afficher, sur lequel re-pointera le pointeur de mémoire vidéo
lorsqu'il sera terminé, et ainsi de suite.
Pour gérer les sons du jeu (musique dans les menus, dans le jeu, sons divers tels que
des sons d’explosions de vaisseaux, de tirs de missile, etc.), on utilise FMOD, une
bibliothèque gratuite de gestion du son (MP3, MID, WAV, etc.) et disponible pour de
nombreux langages. FMOD supporte également plusieurs plates-formes, telles que MAC OS
8/9/X, gamme Windows 32 et 64 bits, Linux 64 bits ou encore les nouvelles consoles de jeu
sur le marché.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
9
Pour gérer les animations 3D de fin de jeu, nous utilisons OpenGL qui est une
bibliothèque qui permet d’effectuer du rendu graphique (2D, 3D), ainsi que GLUT, qui est
une API gérant le système de fenêtrage et les interruptions utilisateurs (souris, clavier). Ces
deux bibliothèques sont portables et gratuites.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
10
3.2 Architecture générale
3.2.1 Conception UML – Diagramme de classes
Illustration 8 : diagramme de classes
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
11
3.2.2 Interfaces détaillées des modules
Le diagramme de classes présenté précédemment permet de comprendre les différents
modules qui ont été implémentés. Nous allons présenter ici le rôle des différents modules, les
sous-modules qu’ils utilisent ainsi que les structures de données et les fonctions qu’ils
comportent. Les fonctions susceptibles d’être utilisées dans d’autres modules sont précédés de
la macro PUBLIC. Les fonctions PRIVATE se limitent quant à elles à une utilisation interne.
Illustration 9 : Modules et sous-modules
1. Module Objet
Ce module permet de gérer les interactions entre les différents objets apparaissant dans
le jeu et correspond aux classes Vaisseau, Planète, Missile et Météorite (qu’on appellera
classes « Mères »), qui sont toutes des sous-classes de la classe Objet. Ce module correspond
à l’ensemble des fonctions implémentées dans le fichiers Vaisseau.h, Planete.h, Meteorite.h,
et Objet.h. Les objets peuvent être crées, affichés ou supprimés en cas de collision avec
d’autres objets d’un type particulier. Les classes Missile et Vaisseau contiennent aussi des
sous-classes (qu’on appellera classes « filles ») caractérisant chaque missile et chaque
vaisseau du jeu :
- Missile: TurboLaser,LanceMissile,CanonBlaster,CanonQuadriLaser,CanonIon,SuperLaser.
- Vaisseau: TieFighter,TieOppressor,StarDestroyer,DeathStar,VaisseauCommercial,Joueur.
Ces sous-classes contiennent des attributs supplémentaires en plus des attributs de leur classe
mère (exemple : _sonImpact pour DeathStar, _dommage pour VaisseauCommercial, etc.).
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
12
2. Module Jeu
Ce module permet de gérer l’ensemble des fonctionnalités du jeu. Il correspond à
l’ensemble des fonctions implémentées dans le fichier Jeu.h. On divise ce module en deux
sous-modules : le sous-module LancerJeu, qui lance toutes les fonctionnalités utilisées
dans le jeu, et le sous-module Vecteur. Les objets sont gérés grâce à des vecteurs
spécifiques à chaque type d’objets, qu’on peut regrouper dans ce second sous-module
(utilisation de la classe Vector de la STL). On a donc crées 4 fichiers :
"MeteoriteFonctions.h", "MissileFonctions.h", "PlaneteFonctions.h" et "VaisseauFonctions.h"
qui regroupe toutes les fonctions liés aux vecteurs spécifiques à chaque type d’objets.
Ainsi "MeteoriteFonctions.h" regroupe les fonctions liés au vecteur des Méteorites,
"MissileFonctions.h" les fonctions liés au vecteur des Missiles du joueur,
"PlaneteFonctions.h" les fonctions liés au vecteur des Bonus et "VaisseauFonctions.h" les
fonctions liés au vecteur des Missiles et des Vaisseaux Ennemis.
3. Module Utilitaires
Ce module rassemble les fonctions et les variables globales utilisées dans plusieurs
modules. Il correspond au fichier Utilitaires.h et permet entre autres de charger des sons, des
images, des textes, d’initialiser les variables globales, etc. Ces fonctions ne sont spécifiques à
aucune classe ni à aucun module en particulier, et peuvent donc être utilisé n’importe quand
dans le code.
4. Module Menus
Ce module rassemble les fonctions d’affichage des différents menus, la gestion des
évènements entre les menus (en fonction des entrées sorties clavier et souris) et l’initialisation
du jeu (lancement des fonctions d’initialisations des variables globales). Il correspond aux
fichiers Menu.h et Main.cpp.
3.3. Structure des fichiers et données globales
La structure des fichiers est normalisée et diffère selon qu’il s’agit d’un fichier d’entête ou un fichier contenant le corps des fonctions. Ainsi les fichiers *.h s’articulent autours
de ce modèle :
•
•
•
•
•
•
•
•
Nom du module / fichier,
Auteur(s), Date de création, Version, Synopsis,
Bugs répertoriés, TODO, Modifications réalisées,
Inclusions,
Définition de macros le cas échéant,
Définition de structures de données le cas échéant,
Squelettes des fonctions avec leur(s) entrée(s), leur sortie et leur description,
Définition des fonctions du module ne correspondant pas à une classe particulière.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
13
Voici le modèle d’organisation des fichiers *.cpp :
•
•
•
•
Nom du module / fichier,
Auteur(s), Date de création, Version, Synopsis,
Bugs répertoriés, TODO, Modifications réalisées,
Définitions des fonctions et méthodes de classes.
Nous avons structuré notre programme de telle sorte que les modules puissent utiliser
des variables globales afin d’interagir entre eux. Nous avons ainsi défini ces variables et de
nombreuses macros représentant des constantes dans le fichier Utilitaires.h, ceci dans le but
de rendre le code plus lisible et adaptable facilement pour tout ce qui concerne la gestion des
images.
3.4. Stratégie de traitement des erreurs
Afin de mieux localiser la provenance des erreurs et de limiter au maximum la
propagation de celles-ci, certaines fonctions et méthode classes dites « dangereuses » sont
contrôlées à l’aide de la fonction assert() (pour tester par exemple les invariants de
domaine ou pré-conditions).
3.5. Justification du choix de l’architecture et des modules
Les différents modules ont été conçus de manière évolutive. Nous avons choisi de
respecter une certaine hiérarchie permettant de nombreux ajouts de fonctionnalités en cas de
besoin : ajouts de nouveaux objets (nouveaux vaisseaux, nouvelles armes, etc.), changements
de configuration des ennemis (vitesse, cadence, nombres d’apparitions, points de vie,
dommages) ou du joueur, évolution différente des objets (déplacements différents), etc.
Chaque module a ainsi un rôle bien défini, de manière à faciliter l’implémentation de
nouvelles fonctionnalités. Nous avons également réparti nos fichiers de manière modulaire et
normalisée : tous les sons se trouvent dans le dossier /son, toutes les images dans le dossier
/images, tous les fichiers sources à la racine. De plus, chaque fichier source ou audio, chaque
image, chaque fonction, classe ou variable a été défini suivant une norme spécifique de
manière à faciliter la compréhension du code.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
14
IV. Conception détaillée des modules
4.1 Module Objet
4.1.1. Variables globales et macromacro-instructions
static int nbObjet : Compteur d’objets (incrémenté à chaque construction).
static int nbPlanete: Compteur de planètes (incrémenté à chaque construction).
static int nbMeteorite: Compteur de météorites (incrémenté à chaque
construction).
static int nbMissile : Compteur de missiles (incrémenté à chaque construction de
missile ; idem pour les missiles suivants).
static int nbCanonBlaster : Compteur de missiles CanonBlaster.
static int nbCanonQuadriLaser : Compteur de missiles CanonQuadriLaser.
static int nbCanonIon : Compteur de missiles CanonIon.
static int nbLanceMissile : Compteur de missiles LanceMissile.
static int nbTurboLaser : Compteur de missiles TurboLaser.
static int nbSuperLaser : Compteur de missiles SuperLaser.
int cptTpsSuperLaser=1 : Compteur permettant de gérer la fréquence de lancement
des missiles SuperLaser par la DeathStar.
static int nbVaisseau : Compteur de vaisseaux (incrémenté à chaque construction
de vaisseau ; idem pour les vaisseaux suivants).
static int nbTieFighter : Compteur de TieFighter.
static int nbTieOppressor : Compteur de TieOppressor.
static int nbStarDestroyer : Compteur de StarDestroyer.
static int nbVaisseauCommercial : Compteur de vaisseaux commerciaux.
int sensDeplacementDeathStarHorizontal : Permet d’alterner le sens de
déplacement horizontaux de la DeathStar (idem pour les vaisseaux suivants).
int sensDeplacementDeathStarVertical : Permet d’alterner le sens de
déplacement verticaux de la DeathStar (idem pour les vaisseaux suivants).
int sensDeplacementTieFighterHorizontal,
sensDeplacementTieOppressorHorizontal,
sensDeplacementStarDestroyerHorizontal: Variables utilisées pour
contenir les différences de sens de déplacement des vaisseaux entre 2 cycles de temps.
int tDeathStar, tTieFighter, tTieOppressor, tStarDestroyer :
Variables utilisées pour contenir les différences de déplacements des vaisseaux entre deux
cycles de temps.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
15
4.1.2. Classes
Le principe de l’héritage a été largement utilisé dans ce module. La classe d’origine, la
classe Objet, à un certain nombre d’attributs communs à tous les objets. Les classes mères
Vaisseau, Planète, Météorite et Missile héritent de cette classe d’origine. Elles ont chacune
des attributs propres (détaillés ci-dessous). Certaines des classes héritées de la classe Vaisseau
ont également des attributs propres, en fonction des besoins.
Liste des attributs des différentes classes du module Objet
Classe Objet :
_id (entier) : identifiant de l’objet ;
_typeObjet (entier) : utilisée pour distinguer certains objets au sien d’une même classe
_x, _y (entiers) : coordonnées de l’objet dans le plan ;
_image (chaîne) : contient le chemin relatif de l’image de l’objet ;
_xCoinHG, _yCoinHG (entiers) : coordonnées du coin Haut Gauche de l’objet ;
_xCoinHD, _yCoinHD (entiers) : coordonnées du coin Haut Droit de l’objet ;
_xCoinBG, _yCoinBG (entiers) : coordonnées du coin Bas Gauche de l’objet ;
_xCoinBD, _yCoinBD (entiers) : coordonnées du coin Bas Droit de l’objet.
Classe Vaisseau :
_libelle (chaîne) : libellé du vaisseau ;
_ptsDeVie (entier) : nombre de points de vie du vaisseau ;
_armeCourante (entier) : permet de connaître l’arme en cours d’utilisation du vaisseau
_nbArme (entier) : permet de connaître le nombre d’armes du vaisseau ;
_sonExplosion (chaîne) : contient le chemin relatif du son de l’explosion de l’objet ;
_sonImpact (chaîne) : contient le chemin relatif du son des impacts sur l’objet ;
_yPosMissile, _xPosMissile (entiers) : coordonnées du 1er missile par rapport à la
position du vaisseau (utilisée pour placer l’apparition du missile à un endroit donné).
Classe VaisseauCommercial :
_dommageMunition1 (entier) : contient la valeur du 1er malus en cas de contact entre
le vaisseau commercial et le vaisseau du joueur ;
_dommageMunition2 (entier) : contient la valeur du 2ème malus en cas de contact entre
le vaisseau commercial et le vaisseau du joueur ;
_dommageMunition3 (entier) : contient la valeur du 3ème malus en cas de contact
entre le vaisseau commercial et le vaisseau du joueur ;
Autres classes héritées de la classe vaisseau
Pour chacune de ces classes, le principe est le même, seul le nombre d’arme change.
_munitionArme1 : nombre de munitions de la 1ère arme disponibles pour le vaisseau ;
_munitionArme2 : nombre de munitions de la 2ème arme disponibles pour le vaisseau ;
etc.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
16
Classe Missile :
_dommage (entier) : contient le nombre de points de vie de dommage du missile ;
_vitesse (entier) : vitesse d’évolution du missile (à la verticale) ;
_cadence (entier) : cadence de tir autorisé du missile (limite le nombre de tir à la min.)
_sonMissile (chaîne) : contient le chemin relatif du son du lancement du missile.
Classe Météorite :
_sonExplosion (chaîne) : contient le chemin relatif du son de l’explosion de l’objet ;
_dommage (entier) : contient le nombre de points de vie de dommage de la météorite.
Classe Planète :
_libelle (chaîne) : nom de la planète;
_bonus (entier) : contient la valeur du gain obtenu en passant sur la planète ;
_sonBonus (chaîne) : contient le chemin relatif du son de gain du bonus.
Pour chaque classe mère du module Objet (classes Vaisseau, Météorite, Planète et
Missile), on retrouve les mêmes modèles de méthodes de classes :
Liste des méthodes des différentes classes du module Objet
Le constructeur et le destructeur
PUBLIC void Classe(Paramètres)
Ces paramètres correspondent aux attributs de la classe qui ne sont pas constants entre les
différentes instances de la classe.
Les accesseurs et les modifieurs
PUBLIC void setAttribut(typeAttribut Attribut)
PUBLIC typeAttribut getAttribut(void)
A chaque attribut de classe correspond un accesseur et un modifieur permettant d’utilisé
l’attribut en dehors du module (dans le module Jeu ou le module Menu par exemple).
Les fonctions d’usage
PUBLIC void deplace(void) //Permet de déplacer l’objet
Tous les objets, excepté le vaisseau du joueur, se déplacent toujours de bas en haut. Les
météorites, les planètes et les vaisseaux commerciaux se déplacent de manière linéaire, les
vaisseaux ennemis de manière aléatoire. Le Boss du jeu, la DeathStar, se déplace pendant un
certain temps aléatoirement de droite à gauche, puis ensuite aléatoirement de droite à gauche
et de haut en bas.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
17
4.1.3. Méthodes internes
PRIVATE bool verifierCollision(Objet obj)
Fonction permettant de comparer les positions de deux objets. Renvoie VRAI si les deux
objets sont en collision, FAUX sinon.
4.1.4. Modules utilisés
Aucun autre module n’est utilisé. On retrouve les classes, les variables globales et les
méthodes internes de ce module dans les fichiers Objet.h, Vaisseau.h, Meteorite.h, Planete.h
et Missile.h.
4.1.5. PseudoPseudo-code des algorithmes complexes
Fonction : verifierCollision ()
booléen verifierCollision(vaisseauJoueur){
Si le vaisseau joueur touche l'objet ennemi par le coin HautDroit du vaisseau Alors
Retourne VRAI;
SinonSi le vaisseau joueur touche l'objet ennemi par le coin BasDroit du vaisseau Alors
Retourne VRAI;
SinonSi le vaisseau joueur touche l'objet ennemi par le coin HautGauche du vaisseau Alors
Retourne VRAI;
SinonSi le vaisseau joueur touche l'objet ennemi par le coin BasGauche du vaisseau Alors
Retourne VRAI;
SinonSi le vaisseau est plus large que l'objet ennemi Alors
Si le vaisseau joueur touche l'objet ennemi par le haut Alors
Retourne VRAI;
Si le vaisseau joueur touche l'objet ennemi par le bas Alors
Retourne VRAI;
FinSi
Retourne FAUX;
}
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
18
Fonction : deplace ()
void deplace(){
//Méthode du TieFighter (principe identique pour les autres vaisseaux)
entier : x = getX();
entier : y = getY() ;
On déplace le vaisseau verticalement (on augmente y) ;
Si la différence la coordonnée x actuelle et le précédent nombre aléatoire est entre 0 et 50
On sauvegarde le nombre aléatoire du déplacement précédent ;
On prend un nombre aléatoire entre la limite à gauche (150) et à droite (930)
de l’écran de jeu ;
TantQue la différence entre ces deux nombres est comprise entre 0 et 50
On sauvegarde le nombre aléatoire du déplacement précédent ;
On prend un nombre aléatoire entre la limite à gauche (150) et à droite (930)
de l’écran de jeu ;
FinTantQue
Finsi
Si x est supérieur au nombre aléatoire Alors
On met le sens du déplacement du vaisseau vers la gauche ;
On déplace le vaisseau horizontalement (on diminue x) ;
Finsi
Si x est inférieur au nombre aléatoire Alors
On met le sens du déplacement du vaisseau vers la droite ;
On déplace le vaisseau horizontalement (on augmente x) ;
Finsi
On modifie les coordonnées _y et _y de l’objet ;
}
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
19
4.2 Module Jeu
instructions
Aucune.
4.2.2. Classes
Aucune.
3.A. Sous-module LancerJeu
Ce sous-module correspond à la fonction LancerJeu() qui lance toutes les fonctions
permettant de faire fonctionner le jeu (ces fonctions sont soit dans le module Menu, soit dans
le module Utilitaires, soit dans le sous-module Vecteur) :
Initialisations des variables globales, chargement du fond sonore et du décor
Chargement du joueur et affichage de son vaisseau
Scrolling du décor, affichage des barres de statistiques de jeu
Lancements des missiles du joueur, changement d’armes
Apparition, affichage et suppression des objets au cours du jeu
Gestion des évènements en fonction de l’état de la partie (Pause/Gagné/Perdu).
3.B. Sous-module Vecteur
A chaque fois qu’un objet est créé, il est inséré dans le vecteur, et dès qu’il est détruit
(parce qu’il a été détruit par le joueur ou qu’il est sorti du champ de l’écran), il est supprimé
du vecteur. Il existe plusieurs vecteurs: vectMissileEnnemi, vectVaisseauEnnemi,
vectPlanete, vectMeteorite, vectVaisseauCommercial et vectMissileJoueur.
A chaque cycle de temps, les éléments de chaque vecteur sont comparés avec le
vaisseau du joueur et la position de ses missiles. Si des objets rentrent en contact
(superposition des objets par rapport à l’axe d’affichage), un évènement est lancé en fonction
de la nature de l’objet (impact, explosion, perte de points, jouer un son, détruire un objet,
etc.). Ces évènements sont gérés dans la fonction verifierCollision() du module
Objet. Pour chaque vecteur, on retrouve les mêmes méthodes:
PUBLIC void supprimerObjet(typeObjet Objet)
Fonction qui supprime l’objet du vecteur correspondant puis le détruit.
PUBLIC void viderVectObjet (void)
Fonction qui vide la totalité du vecteur correspondant.
PUBLIC void creerObjet(Paramètres)
Fonction qui créé l’objet et l’insère dans le vecteur correspondant. Les paramètres dépendent
du type d’objet (la position de l’objet, sa catégorie, sa fréquence d’apparition, etc.).
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
20
PUBLIC void afficherObjet(typeObjet Objet)
Fonction qui affiche l’objet à l’écran, en fonction de la position de l’objet passé en paramètre.
Cette fonction lance également des évènements en fonction de cette position (impact et son,
explosion et son, suppression de l’objet, etc.).
PUBLIC void afficherVectObjet(typeObjet Objet)
Fonction qui affiche le contenu du vecteur correspondant.
Ces fonctions sont implémentées pour chaque vecteur dans un fichier différent :
- "MeteoriteFonctions.h" regroupe les fonctions liées au vecteur des Météorites ;
- "MissileFonctions.h" regroupe les fonctions liées au vecteur des Missiles du joueur ;
- "PlaneteFonctions.h" regroupe les fonctions liées au vecteur des Bonus ;
- "VaisseauFonctions.h" regroupe les fonctions liées au vecteur des Missiles et des Vaisseaux
Ennemis (dont les vaisseaux commerciaux).
Modules Utilitaires, Objet et Menus. On retrouve les variables globales et les
méthodes internes de ce module dans le fichier Jeu.h.
complexes
Pour chaque type d’objet(Vaisseau, Planète, Météorite ou Missile), le principe est le
même (seul l’affichage de l’objet en question diffère). Nous allons donc détailler les fonctions
d’une classe par défaut :
Fonction : supprimerTypeObjet ()
void supprimerTypeObjet(TypeObjet objet){
Pour chaque objet du vecteur vectTypeObjet faire
Si l’objet est identique à celui passé en paramètre Alors
On joue le son de l’explosion de l’objet ;
On le supprime du vecteur ;
On le détruit ;
FinSi
FinPour
}
Fonction : viderVectTypeObjet ()
void viderVectTypeObjet (){
Pour chaque objet du vecteur vectTypeObjet Faire
Si l’objet est situé plus bas que l’écran (il est sorti de l’écran) Alors
On le supprime du vecteur ;
On le détruit ;
FinSi
FinPour
}
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
21
Fonction : afficherVectTypeObjet ()
void afficherVectTypeObjet( vector<TypeObjet* > vecteur ){
Si le vecteur n’est pas vide Alors
Pour chaque objet du vecteur vectTypeObjet Faire
On le déplace en fonction de son type ;
On l’affiche ;
FinPour
Finsi
}
Fonction : afficherTypeObjet ()
void afficherTypeObjet(TypeObjet objet){
On modifie les coordonnées de la boite englobante de l’objet en fonction ;
//nouvelles coordonnées dans l’espace ;
Si l’objet n’est pas en collision avec le joueur Alors
On affiche l’objet ;
Sinon
Selon le type de l’objet Faire
Cas 1 : //Actions
Cas 2 : //Actions
Cas 3 : //Actions
Cas 4 : //Actions
FinSelon
On augmente le nombre d’objets détruits (ou obtenus pour les bonus)
On supprime l’objet ;
FinSi
}
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
22
4.3 Module Utilitaires
4.3.1. Variables
Variables globales et macromacro-instructions
TTF_Font *policeTitre, *policeMenu, *policeTexte, *ttfPolice,
*ttfPolice16, *ttfPolice18 : polices utilisées pour l’affichage des textes.
SDL_Color Blanc = {250, 250, 250}, Noir = {0,0,0},Rouge =
{250,0,0} : Variables utilisées pour la couleur des textes.
SDL_Rect rctPosition, rctPositionMissile, rctPositionJoueur,
rctExplosionMeteorit,rctExplosionXWing,rctExplosionFaucon,
rctExplosionTieFighter,rctExplosionTieOppressor,
rctExplosionStarDestroyer,rctExplosionDeathStar,
rctApparitionXWing,rctApparitionFalcon,rctImpactDeathStar,
rctApparitionSuperLaser,rctPositionSuperLaser,
rctMeteorite : Variables utilisées pour déclarer les positions des images.
SDL_Rect rctScroll_1, rctScroll_2: variables utilisées pour le scrolling.
SDL_Event event : variable utilisée pour gérer les évènements clavier et souris.
FSOUND_STREAM *musique : variable utilisée pour contenir le fond sonore en cours.
FSOUND_SAMPLE *sample : variable utilisée pour contenir le son en cours.
int resolutionX, resolutionY : variables contenant la résolution de l’écran.
SDL_Surface *ecran,*sfcImageFond,*sfcTurboLaser,
*sfcLanceMissile,*sfcCanonQuadriLaser, *sfcCanonBlaster,
*sfcSuperLaser, *sfcCanonIon,*sfcTurboLaserEnnemi,
*sfcLanceMissileEnnemi, *sfcSorooSub, *sfcYKL,*sfcFalcon,
*sfcStarDestroyer,*sfcTieFighter,*sfcTieOppressor,
*sfcDeathStar,*sfcXWing, *sfcPlaneteBleue,
*sfcPlaneteRouge, *sfcPlaneteOrange, *sfcPlaneteVerte,
*sfcPlaneteJaune, *sfcMeteorite, *sfcJeuMenuGris,
*sfcJeuMenuArmes,*sfcJeuMenuMunitions,*sfcJeuMenuIllimite,
*sfcJeuMenuArme1,*sfcJeuMenuArme2,*sfcJeuMenuArme3,
*sfcJeuMenuArme4,*sfcJeuMenuJoueur,*sfcJeuMenuPtsDeVie,
*sfcJeuMenuVaisseauxDetruits,*sfcJeuMenuNbTieFighter,
*sfcJeuMenuNbTieOppressor,*sfcJeuMenuNbStarDestroyer,
*sfcJeuMenuDeathStar,*sfcJeuMenuNiveauEnergie,
*sfcJeuMenuTurboLaser,*sfcJeuMenuLanceMissile,
*sfcJeuMenuCanonQuadriLaser,*sfcJeuMenuCanonBlaster,
*sfcApparitionXWing,*sfcApparitionFalcon,
*sfcApparitionSuperLaser,*sfcExplosionMeteorite,
*sfcExplosionTieFighter,*sfcExplosionTieOppressor,
*sfcExplosionStarDestroyer,*sfcExplosionDeathStar,
*sfcExplosionXWing,*sfcExplosionFalcon,
*sfcImpactDeathStar : variables utilisées pour contenir les images des objets
de l’écran de jeu (Missiles, Planètes, Vaisseaux, Météorite), des impacts et des explosions,
ainsi que les images des barres de menu (gauche-droite) de l’écran de jeu.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
23
vector
vector
vector
vector
vector
vector
vector
vector
vector
vector
vector
vector
vector
vector
<Vaisseau*> vctVaisseau : Vecteur des vaisseaux ennemis.
<Vaisseau*> ::iterator _ptrVaisseau : Itérateur correspondant.
<Missile*> vctMissileEnnemi: Vecteur des missiles ennemis.
<Missile*> ::iterator _ptrMissileEnnemi: Itérateur correspondant.
<Meteorite*> vctMeteorite: Vecteur des météorites.
<Meteorite*> iterator _ptrMeteorite;
<Missile*> vctMissile: Vecteur des missiles du joueur.
<Missile*>::iterator _ptrMissile: Itérateur correspondant.
<Planete*> vctBonus: Vecteur des planètes.
<Planete*>::iterator _ptrBonus: Itérateur correspondant.
<Vaisseau*> vctVCommercial: Vecteur des vaisseaux commerciaux.
<Vaisseau*>::iterator _ptrVCommercial: Itérateur correspondant.
<Record*>vctRecord: Vecteur des records/scores.
<Record*>::iterator _ptrRecord: Itérateur correspondant.
int itPlanete : Indice permettant d’alterner le type de planètes créé.
int itVCommercial: Indice permettant d’alterner le type de vaisseau commercial créé.
int itMissileDeathStar: Indice permettant d’alterner les missiles de la DeathStar.
int idStarDestroyer, idTieFighter, idTieOppressor,
idMeteorite, idCommerc : variables permettant de savoir si le vaisseau du
joueur a déjà touché un objet(vaisseau, météorite,..) avec cet identifiant.
int precNbArme, precMunition, precPtsDeVie,
precNbTieFighterDetruit, precNbTieOppressorDetruit,
precNbStarDestroyerDetruit,ptsDeVieDeathStar,
precPtsDeVieDeathStar : variables utilisées pour modifier seulement en cas
de besoin les textes des barres de menus de l’écran de jeu.
int explosionMeteorite, explosionXWing, explosionFalcon,
explosionTieFighter,explosionTieOppressor,
explosionStarDestroyer, explosionDeathStar,
impactDeathStar, apparitionJoueur, apparitionSuperLaser,
animationMeteorite : variables utilisées pour gérer l’affichage des
animations en bande (explosions, impacts et apparitions du vaisseau du joueur).
int malus1VaisseauCommercial,malus2VaisseauCommercial,
malus3VaisseauCommercial : variables utilisées pour les dommages causés
par les vaisseaux commerciaux.
int bonusTieFighterDetruit, bonusTieOppressorDetruit,
bonusStarDestroyerDetruit : variables utilisées pour contenir les gains en cas
de destruction de vaisseaux ennemis.
int nbMissileEnvoyeJoueur,nbTieFighterDetruit, nbBonusObtenus,
nbTieOppressorDetruit,nbStarDestroyerDetruit : variables
utilisées pour les statistiques des scores du joueur.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
24
int frequenceTirDeathStar, frequenceTieFighters,
frequenceTieOppressors, frequenceStarDestroyers: variables
utilisées pour gérer la fréquence d’apparition des objets en fonction du niveau de jeu.
VaisseauJoueur * joueur : variable contenant l’instance de joueur créé.
int
cycle,
sauv_cycle,sauv_cycle_pause,
cycleVictoire,
continuerApplication,
continuerScore,
pauseApplication,
gameover, scroll, menu, arretScroll, victoireJeu : variables
utilisées pour gérer les cycles de temps et les évènements correspondants.
int configVaisseauJoueur, configNiveauJeu : Configuration de jeu.
int canalAudio : Variable permettant de mémoriser le dernier canal audio utilisé.
char buffer[10]: Variable utilisée pour contenir le nom du joueur en cours de saisie.
4.3.2. Classes
Aucune.
Gestion des images et des textes
PRIVATE void afficherScrollingBG ()
Fonction qui permet d’afficher en arrière plan un fond étoilé défilant de haut en bas, simulant
le déplacement des objets dans l’espace.
PRIVATE void afficherTexte(char * texte, char * police,
int taille, SDL_color couleur, int x, int y)
Fonction qui permet d’afficher un texte à l’écran à une position (x,y).
PRIVATE void afficherImage(char * image, int x, int y)
Fonction qui permet d’afficher une image lambda à l’écran (image peut utilisée).
PRIVATE void afficherObjet(int typeObjet, int x, int y)
Fonction qui permet d’afficher les objets du jeu à l’écran à une position (x,y) en fonction du
type d’objet demandé.
Gestion des sons
PRIVATE void chargerSon(char * son, int canal)
Fonction permettant de lire le son spécifié en paramètre sur le canal donné.
PRIVATE int canal()
Fonction permettant de sélectionner un canal audio libre parmi les 32 canaux disponibles
pour la lecture d’un nouveau son.
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
25
Gestions des scores
Toutes les méthodes liées à la gestion des scores sont implémentés dans le fichier
"RecordFonctions.h" pour plus de clarté.
PUBLIC void afficherInterfaceSaisieScore()
Fonction permettant d’afficher l’interface de saisie du score du joueur.
PUBLIC void sauverRecords(char * nom)
Fonction permettant d’enregistrer les 10 meilleurs scores inclus dans le vecteur Records dans
le fichier Records.txt.
PUBLIC void chargerRecords(fstream & stream)
Fonction permettant de charger dans un vecteur des scores (le vecteur des Records)
l’ensemble des enregistrements lu dans le fichier Records.txt. Ce vecteur contient des objets
de type Record (classe du même nom).
PRIVATE void afficherNomJoueur()
Fonction permettant d’afficher le nom du joueur en cours de saisie dans l’interface
correspondante.
PRIVATE int calculerScore()
Fonction permettant de calculer le score du joueur en fonction de plusieurs variables globales.
PRIVATE void afficherVectRecords()
Fonction permettant d’afficher le vecteur et les textes de l’interface de saisie des scores.
PRIVATE void viderVectRecords()
Fonction permettant de vider le vecteur des scores.
Initialisations
PRIVATE void chargerJoueur(int x, int y)
Fonction permettant de créer un vaisseau joueur et d’initialiser ses attributs en fonction du
niveau de jeu choisi dans la configuration (facile / normale / expert).
PRIVATE void chargerMalus(void)
Fonction permettant d’initialiser les malus provoqués par le contact entre les vaisseaux
commerciaux et le joueur, en fonction du niveau de jeu choisi dans la configuration.
PRIVATE void chargerTextes()
Fonction permettant de charger les textes apparaissant dans les barres de menus du jeu (à
droite et à gauche de l’écran de jeu). Ceci permet d’éviter de surcharger la mémoire en les
rechargeant à chaque cycle de temps.
PRIVATE void chargerImages()
Fonction permettant de charger les images apparaissant dans l’écran de jeu. Ces images étant
réaffichées à chaque cycle de temps, on les charge dès le départ dans des variables globales
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
26
qui sont ensuite appelée à chaque utilisation. Ceci permet d’éviter de surcharger la mémoire
en les rechargeant à chaque cycle de temps.
PRIVATE void initVariablesGlobales()
Fonction permettant d’initialiser l’ensemble des variables globales (vecteurs, images SDL,
textes SDL, compteurs d’objets, etc.).
PRIVATE void libererEspaceMemoire()
Fonction permettant de libérer l’espace mémoire allouée pour les variables globales de type
SDL_Surface (les images) ou pour le fond sonore.
Modules Jeu (sous-module Vecteur), Objet et Menus. On retrouve les classes, les
variables globales et les méthodes de ce module dans les fichiers Utilitaires.h et Record.h.
4.3.5. PseudoPseudo-code
code des algorithmes complexes
Fonction : calculerScore()
int calculerScore(){
Retourne ((Nombre de StarDestroyers détruit * 10)+
(Nombre de TieOppressors détruit * 20)+ (Nombre de StarDestroyers détruit * 40)+
Nombre de points de vie du joueur - (Nombre de bonus obtenu*5));
}
Fonction : sauverRecords ()
void sauverRecords(char * nomJoueur) {
On ouvre le fichier Records.txt en écriture ;
On crée une instance de Record avec le nom passé en paramètre, les variables globales
actuelles et le score calculé à partir de ces dernières ;
Pour chaque objet du vecteur des scores vectRecords Faire
Si l’objet à un score inférieur au nouvel objet créé Alors
On insère dans le vecteur (avant l’objet comparé) le nouvel objet créé ;
On supprime le dernier objet du vecteur ;
On détruit l’objet en question ;
On sort de la boucle ;
Finsi
FinPour
Si le fichier Records.txt est ouvert Alors
Pour les 10 premiers objets du vecteur des scores vectRecords Faire
Sauver toutes les informations de l’objet dans le fichier ;
FinPour
Fermer le fichier ;
Finsi
}
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
27
Fonction : chargerRecords ()
void chargerRecords(fstream & stream) {
Si le fichier Records.txt peut s’ouvrir Alors
TantQue l’on n’est pas arrivé à la fin du fichier Faire
Récupérer les informations de la ligne du fichier en cours ;
Créé une instance de Record avec ces informations ;
Insérer le nouvel objet créé à la fin du vecteur des scores ;
FinTantQue
Finsi
}
Fonction : afficherScrollingBG ()
void afficherScrollingBG(){
Si le scrolling dépasse la limite du bas de l’écran (800) Alors
On le remet à 0 ;
Finsi
Si le scrolling est arrêté Alors
On sort de la fonction ;
Sinon
On redessine l’image de fond en décalant la coordonnée y du scrolling calculé et en
diminuant la hauteur du scrolling calculé (affichage de la partie haute de l’image) ;
On redessine l’image de fond en dessinant cette fois-ci la partie basse de l’image;
On augmente la variable de scrolling ;
Finsi
}
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
28
4.4 Module Menus
int choixMenu, choixSousMenu : Variables permettant de contenir le choix des
menus et d’autoriser en fonction de celui-ci certains évènements.
4.4.2. Classes
On peut inclure dans ce module la classe Record permettant d’enregistrer les scores
des joueurs. Cette classe contient un constructeur, un destructeur, des accesseurs, des
modifieurs et des attributs (le nom, le score, le nombre de TieFighters détruits – idem pour les
TieOppressors et les StarDestroyers).
PRIVATE void main()
Fonction permettant d’initialiser les paramètres d’affichage vidéo, de charger les images, les
textes et le fond sonore, et de lancer l’affichage du menu de départ.
PUBLIC void gestionMenu()
Fonction permettant de gérer l’affichage des menus en fonctions des évènements clavier ou
souris et de modifier les variables globales correspondantes. Les couleurs des textes ou les
images affichées sont modifiées en fonction du passage de la souris ou du choix d’un menu ou
d’une option de configuration.
PUBLIC void afficherMenuPrincipal()
Fonction permettant d’afficher les textes, les images et le fond d’écran du menu principal.
PUBLIC void afficherAide()
Fonction permettant d’afficher les textes, les images et le fond d’écran du menu Aide.
PUBLIC void afficherRecords()
Fonction permettant d’afficher les textes, les images et le fond d’écran du menu Records.
Cette fonction lance donc le chargement et l’affichage des scores contenus dans Records.txt.
PUBLIC void afficherConfiguration()
Fonction permettant d’afficher les textes, les images et le fond d’écran du menu
Configuration. Les images et les textes sont modifiés en fonction de la configuration choisie.
PUBLIC void afficherBarreGaucheJeu()
Fonction permettant d’afficher les textes et les images de la barre gauche de l’écran de jeu en
fonction des caractéristiques du joueur et de ses armes (fonction appelée à chaque cycle).
PUBLIC void afficherBarreDroiteJeu()
Fonction permettant d’afficher les textes et les images de la barre droite de l’écran de jeu en
fonction des caractéristiques des ennemis (fonction appelée à chaque cycle).
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
29
Module Utilitaires. On retrouve les variables globales et les méthodes internes de ce
module dans les fichiers Menu.h et Main.cpp.
Fonction : gestionMenu ()
void gestionMenu(){
TantQue l’application n’a pas été arrêtée par l’utilisateur Faire
On prend en compte les évènements (clavier et souris);
Selon l’évènement Faire
Cas ou l'utilisateur appuie sur le clavier :
//Attention : le clavier en SDL est considéré en configuration QWERTY :
//quand on appuie sur ‘a’, en réalité on appuie sur ‘q’
Selon la touche appuyée Faire
Cas ‘Q’ :
Si on est dans l’interface de saisie du score Alors on écrit ‘q’ sur l’écran ;
Sinon on quitte l’application ;
Finsi
Cas de la barre d’espace :
Cas des autres lettres :
On écrit la lettre à l’écran ;
Cas du BackSpace :
On supprime toutes les précédentes lettres saisies;
Cas de la flèche du bas:
Si on est dans le menu principal Alors
On sélectionne le menu en dessous du menu actuel sélectionné (si on est
sur le dernier, on repasse au premier) ;
On met son texte d’une couleur différente pour indiquer la sélection ;
On affiche les menus ;
Finsi
Cas de la flèche du haut :
On sélectionne le menu au-dessus du menu actuel sélectionné (si on est
sur le premier, on repasse au dernier) ;
On met son texte d’une couleur différente pour indiquer la sélection ;
On affiche les menus ;
Finsi
Cas de la touche Entrée:
Si le menu LancerJeu est sélectionné Alors on lance le jeu ;
Si le menu Aide est sélectionné Alors on affiche le menu Aide ;
Si le menu Records est sélectionné Alors on affiche le menu Records ;
Si le menu Configuration est sélectionné Alors on affiche le menu
Configuration ;
Si le menu Quitter est sélectionné Alors on quitte le jeu ;
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
30
Finsi
Si on est dans l’interface de saisie des scores Alors
On sauvegarde les scores ;
On les affiche ;
Finsi
Cas de la touche Echap :
Si on est dans l’interface de saisie des scores Alors
On change de fond sonore ;
On réinitialise toutes les variables globales ;
Finsi
On réaffiche le menu principal ;
FinSelon
Cas ou l'utilisateur passe au-dessus du titre d'un menu :
On affiche le menu principal ;
On affiche en noir le texte du menu sur lequel la souris passe ;
On affiche les autres textes en blanc ;
SinonSi on est dans le menu Configuration Alors
On affiche le menu de configuration ;
On affiche en noir le texte de l’option sur lequel la souris passe ;
On affiche les autres textes en blanc ;
On change l’image du vaisseau en fonction de l’option sélectionné (XWing ou
Faucon Millenium) ;
Finsi
Cas ou l'utilisateur clique sur le titre d'un menu avec le bouton gauche de la souris:
Si le menu cliqué est Quitter le jeu Alors
On quitte l’application ;
SinonSi le menu cliqué est Lancer Le Jeu Alors
On lance le jeu ;
Sinon
Si on a cliqué sur le menu Aide Alors on affiche le menu Aide ;
Si on a cliqué sur le menu Records Alors on affiche le menu Records ;
Si on a cliqué sur le menu Configuration Alors on affiche le menu
Configuration ;
Finsi
SinonSi on est dans le menu Configuration Alors
On change la configuration en fonction de l’option cliquée (Niveau de jeu ou
vaisseau du joueur) ;
On réaffiche le menu Configuration ;
Finsi
}
Jonathan FAVIER
Sylvain LARGIER
EsilSquadron
31
V. Tableau d’allocation des modules
Dans le cahier des charges, il avait été calculé qu’environ 100 heures de travail pour
chaque membre de l’équipe de conception, soit 200 heures en tout, étaient nécessaires à la
réalisation du projet (dont 45 heures pour l’étude du système, la réalisation de la
documentation et la définition des règles du jeu). Voici le tableau récapitulatif des 155 heures
restantes réparties en fonction des modules :
Module
Objet
Jeu
Utilitaires
Menus
Temps
30h
55h
40h
30h
VI. Spécifications techniques
Voici le tableau regroupant les principales spécifications techniques du produit :
Elément
Systèmes d’exploitation supportés
Taille de l’exécutable
Configuration matérielle minimale requise
Jonathan FAVIER
Sylvain LARGIER
Détail technique
Windows 2000 et versions supérieures, Linux
toutes versions.
Dépend des options du compilateur.
Classiquement inférieure à 1Mo environ.
Processeur 800 Mhz ou supérieur.
256 Mo mémoire vive.
10 Mo de libre sur le disque dur.
Clavier 105 touches.
Résolution d’écran:
-1280*800 (ordinateur portable)
-1152*864(ordinateur fixe).
EsilSquadron
32

EsilSquadron (shoot`them`up)

Transcription

Documents pareils

Menu du Dimanche

Passer la TI-84 Plus Silver Edition en mode fr

Configurer le menu de navigation

MENU « PROVENCE » Clafoutis d`aubergines à la mozzarella

Rencontre franco-allemande au Vaisseau

Restaurant Menu de la St

Exercice sur excel. Protection de cellule. Objectif : empêcher les

Grammes du menu Equilibre - Eldora > Le Twelve O`clock

Menu Novembre 2016

jambon broche - Mairie de Sainte-Croix-en