Projet_Java_

Transcription

Projet_Java_

Projet Java : Démineur
Le
Mathieu Fortin et Pierre Ruyssen
DoMineur
« Le Démineur réseau pour tout âge »
Le jeu est conçu en java et se décompose en deux parties, le démineur classique et la partie
réseau et communication entre les fenêtres des joueurs. Dans un premier temps nous présenterons
l'utilisation de ce démineur à travers la notice d'utilisation puis nous aborderons l'implémentation à
travers la notice technique.
I – Notice d'utilisation
Démarrage et arrêt du jeu ...................................................... 2
Enregistrement d'une partie ................................................... 2
Notations, symboles et fonctionnalités................................... 3
Partie en réseau....................................................................... 5
II – Notice technique
Diagramme UML simplifié ................................................... 6
Organisation générale ............................................................ 7
L'entête ................................................................................... 8
Options et sauvegardes ........................................................... 9
Réseau ................................................................................... 10
III – Conclusion
Ifips Informatique 2
Page 1/11
Université Paris Sud XI
Notice d'utilisation
Le DoMineur est la nouvelle génération du célèbre démineur, conçu sur une technologie
Java il est compatible avec la plupart des systèmes (Windows, Mac, Linux).
Les règles du jeu sont les mêmes que dans le démineur windows, toutes les cases doivent être
découvertes ou déminées pour gagner la partie. Sur les bases de ce jeu en mode non connecté,
s'ajoute la possibilité de jouer en réseau avec des amis connectés à internet.
Avec le DoMineur il est possible de jouer à plusieurs et de s'affronter sur une même partie. Le
temps est crucial dans le DoMineur, pour gagner vous devrez être le plus rapide à découvrir toutes
les mines.
Le Jeu démarre ...
Le Menu du Haut :
Options > permet de sélectionner le niveau de
difficulté de la parties
Rézo > permet de lancer une partie en réseau en
tant que serveur ou client
Aide > Information générale sur le jeu
Le Menu du Bas :
- A gauche :
Vous trouvez le nombre de mines restantes à
découvrir. Attention, ce compteur se base sur
le nombre de drapeaux que vous avez placé,
qu'ils soient bien placé ou non.
- Au milieu :
Le bouton pour démarrer une nouvelle partie.
- A droite :
Le chronomètre indiquant le temps depuis le
début de la partie. Le chronomètre se
déclenche automatiquement lors de votre
premier click de souris sur l'une des cases.
Le jeu s'arrête ... lorsque vous avez perdu ou remporté la partie.
Pour remporter la partie, il vous suffit, soit de placer un drapeau sur toutes les mines et uniquement
celles-ci, soit de découvrir toutes les cases non minées. S'il reste autant de cases minées qu'il reste
de cases non découvertes, vous gagnez la partie.
Pour perdre, il suffit de cliquer sur une case minée.
Enregistrement d'une partie :
Le DoMineur enregistre automatiquement votre partie lorsque vous quittez le jeu. Lorsque
vous le rouvrez, la partie est automatiquement chargée (et le chronomètre remis au temps auquel
vous avez quitté le jeu). Vous pouvez alors reprendre votre partie normalement. Le nombre
d'enregistrement par partie est bien sur illimité.
Page 2/11
Notation, symboles et fonctionnalités
Dans ce cas de figure la partie vient d'être
perdue, la mine sur laquelle vous êtes tombé est
entourée de rouge.
Les cases que vous auriez identifiées comme
minées alors qu'elles ne l'étaient portent l'image :
Dans ce cas de figure la partie est gagnée, les
mines entourées de vert sont celles que vous
avez correctement identifié.
La grille a été entièrement découverte, il n'a
donc pas été nécessaire d'identifier toutes les
mines : il reste deux cases non découverte sur la
grille, et deux mines non découvertes la partie
est donc gagnée. Les mines non découvertes sont
en blanc.
Les cases minées sur lesquelles vous avez placé
un point d'interrogation seront représentées à la
fin de la partie par l'icône :
Page 3/11
Il existe différents états pour une case, vous
pouvez placer un drapeau sur une case si vous
estimez qu'elle est minée avec un click droit ou
bien placer une interrogation en clickant de
nouveau sur le bouton droit.
L'état d'interrogation comme celui de drapeau
sur une case vous empêche de découvrir la case.
Faire un click avec le bouton du milieu sur une
case découverte, permet de changer l'état des
cases voisines. De les passer successivement du
drapeau, au point d'interrogation ou de revenir à
l'état normal.
Un click droit sur une case découverte permet de
placer une incertitude sur les cases voisines
« indéfinies ». Les cases sur lesquelles est placée
l'incertitude sont alors
affublées de l'icône :
Il est alors possible de déplacer la souris sans
lâcher le bouton droit, l'état d'incertitude suivra
les cases adjacentes à la case survolée.
Toujours en maintenant le click droit, cliquer
avec le bouton gauche de la souris pour
découvrir les cases sur lesquelles on a placé
l'incertitude. Tant que vous ne lâchez pas le click
gauche l'icône devient alors :
Lorsque vous lâchez le click
gauche, les cases affublées de l'icône précédente
sont alors découvertes, et si une mine était
présente sur l'une d'elle, vous perdez la partie.
Si lorsque vous avez pressé le bouton gauche,
vous décidez de ne pas découvrir les cases
rouges, il suffit de changer la souris de case sans
relâcher le bouton gauche.
Page 4/11
Le Réseau
Le DoMineur est composé d'une partie réseau, qui offre la possibilité de jouer à plusieurs sur une
grille identique.
Pour commencer une partie en réseau, cliquez
sur Rézo puis choisissez :
-Serveur si vous souhaitez héberger la partie
-Client si vous souhaitez rejoindre une partie
Une fois lancé, le serveur attendra qu'un client se
connecte.
Lorsque vous avez fini la partie, l'application
attendra le résultat de la personne contre qui
vous jouez pour vous proclamer vainqueur ... ou
perdant.
Page 5/11
Notice Technique :
Diagramme UML simplifié :
Ce diagramme a été volontairement très simplifié afin de faire ressortir les relations les plus
importantes. Une brève description des classes et de l'organisation générale de l'application suivent
ce schéma ; nous vous recommandons cependant de consulter la javadoc pour une description
détaillée de chaque classe.
Page 6/11
Organisation générale du projet :
Le code est organisé autour de deux classes principales : Grille et Case.
La classe Grille, héritière de la classe standard JPanel.
Elle est composée de plusieurs instances de cases et possède des attributs comme le nombre
de mines, la hauteur, la largeur... Elle permet de rassembler les cases dans un ensemble logique et
de manipuler celles-ci de manière plus globale. C'est la grille qui gère les cas de victoire ou défaite
d'une partie.
Attributs : Cette classe contient des attributs paramettrables dont les plus importants sont : la
hauteur et largeur de la grille, le nombre de mines présents sur la grille. Elle contient aussi des
attributs internes et propres à sa gestion tels le nombre de drapeaux posés ou le nombre de cases
indéfinies qui permettent de déclencher des événements (victoire par exemple). La grille contient
bien sur l'ensemble des cases, représenté sous la forme d'un tableau.
Constructeurs : Plusieurs constructeurs sont disponibles pour cette classe, et permettent de créer
une grille de façon personnalisée (en spécifiant la taille, le nombre de mines...), une grille par défaut
ou encore à partir d'une grille sauvegardée (utile pour le réseau ou les sauvegardes).
Accesseurs : La grille de jeu possède de nombreux accesseurs qui permettent : d'accéder à des
composants associées à la grille (Chrono, Historique...) ou à des attributs (hauteur, largeur, ...), voir
de (ré)initialiser complètement l'instance.
Les accesseurs sont construits de manière à éviter les effets de débordement et simplifier la gestion
de la grille. Par exemple, la grille reprend de nombreuses méthodes de la classe Case et est capable
de les appliquer à des groupes de case de manière globale et sécurisée (sans débordement des bornes
du tableau par exemple).
La classe Case, héritière de la classe standard Jbutton.
Elle permet de manipuler les cases de façon sécurisée et simplifiée.
Attributs : Informations concernant l'état de la case (si elle est minée, découverte...), du nombre de
mines présentes dans les cases adjacentes et de la position de la case dans la grille à laquelle elle
appartient.
Constructeurs : Cette classe ne comporte qu'un seul constructeur qui renseigne la case sur la grille
à laquelle elle appartient et sur sa place dans la grille.
Accesseurs : Les principaux accesseurs de la classe permettent de définir un état pour la case. Les
accesseurs gèrent les actions parallèles à effectuer comme la modification des compteurs de la
grille, le changement d'apparence de l'objet graphique...
Classe interne : La classe ActionCase, incluse dans Case se charge de récupérer les clicks de souris
et appelle les méthodes de Case appropriées. Différents cliks de souris sont gérés : le clicks gauche
et droits sont associées aux événements standards « découvrir » et « changer d'état » (drapeau,
interrogation, indéterminé). Une gestion avancée des clicks (MousseReleased, MouseExited,
MoussePressed) permet de gérer le mécanisme de découverture rapide des cases adjacentes à une
case (cf. notice d'utilisation).
Pour une description plus détaillée, nous vous recommandons de vous référer à la javadoc générée,
celle-ci étant très détaillée.
Ces deux classes principales permettent à elles seules d'avoir un jeu minimaliste. Cependant,
d'autres classes viennent les enrichir afin de proposer d'autres fonctionnalités.
Page 7/11
L'entête :
Nous avons créé la classe Haut qui représente l'entête du démineur (compteur de mines +
bouton d'initialisation + chronomètre). Cette classe qui a pour simple objectif de rassembler et mettre en
forme les composant précédemment cités a été nommée ainsi car à l'origine elle se situait au dessus de
la grille de jeu. Nous avons décidé de la mettre dessous la grille de jeu par soucis d'esthétique.
La classe Haut n'existant que par soucis de mise en page et de clarté, ses composants sont déclarés en
public et elle ne possède qu'un constructeur. La grille de jeu, à qui l'on indique l'entête lui appartenant,
accédera donc directement a ses composants.
La classe Label3D, héritière de la classe Canvas
Cette classe est un composant graphique utilisé par le chronomètre et le compteur de mines. Elle
permet de faire un affichage « pseudo 3D ».
Attributs : Divers attributs tels que le texte à afficher, les couleurs utilisées, la police.
Constructeur : Un constructeur spécifiant la taille du composant et le texte à afficher au début.
Accesseur : une seule méthode qui permet de redéfinir le texte à afficher.
La classe CptMines, héritière de la classe Jpanel
Compteur de mines, cette classe comprend une instance de la classe Label3D.
Attributs : le nombre de mines restantes à afficher (pas forcément vrai si le joueur s'est trompé en
plaçant ses drapeaux).
Constructeur : une seul constructeur, permettant de définir le nombre de mines restantes au début
de la partie.
Accesseur : deux accesseurs, qui permettent respectivement d'incrément ou de décrément le nombre
de mines restantes à afficher.
La classe Chrono, héritière de la classe Jpanel
Elle s'organise de la même manière que la classe CptMines à la différence prêt qu'elle intègre deux
instances des classes Label3D et Timer. Elle se sert de plus de la classe Temps.
Attributs : Le temps à afficher sous forme d'une chaîne de caractères.
Constructeur : Un seul constructeur, initialisant le temps à « 00:00 ».
Méthodes : Les méthodes de mise en marche, pause et arrêt et réinitialisation du chronomètre. Une
fois le chronomètre mis en marche, il se met à jour automatiquement grâce au timer qui utilise alors
la méthode maj().
La classe Timer, héritière de la classe Tread
Chaque instance de cette classe est associée à une instance de la classe Chrono. Une fois démarrée,
cette instance se chargera de mettre à jour le Chrono toutes les secondes.
Attributs : une instance de la classe Temps.
Constructeur : un seul constructeur, obligeant l'association à une instance de Chrono.
Méthodes : méthodes permettant la mise en marche et l'arrêt.
La classe Temps
Cette classe permet d'effectuer des opération sur un temps.
Attributs : heures, minutes, secondes du temps qu'elle représente.
Constructeurs : trois constructeurs qui permettent d'initialiser le temps selon différents formats ou
par défaut(0h0m0s).
Accesseurs : Des accesseurs qui permettent d'accéder uniquement à l'un des trois attributs, d'ajouter
une seconde, d'effectuer des comparaisons entre des temps ou encore de retourner le temps sous la
forme de chaînes de caractères formatées « mm:ss » par exemple.
La classe BoutonInitialise, héritière de la classe JButton
Classe servant uniquement à réinitialiser la grille et le chronomètre, elle possède une vue sur ses deux
composants.
Page 8/11
Organisation des options et des sauvegardes :
La gestion de la sauvegarde des options et du jeu s'effectue à l'aide de six classes.
La classe Options :
Cette classe contient juste les options du jeu et est surtout destinée à être sérializée pour
enregistrer ses options.
La classe Coordonnées :
Cette classe fait office de container, puisque ses deux seuls attributs (hauteur et largeur)
indiquant une position, sont déclarés public. Elle ne possède aucun accesseur.
La classe Coup :
Chaque instance de cette classe permet de décrire un coup.
Attributs : Un coup se distingue par les coordonnées de la case jouée, son état après le coup et le
temps auquel a été joué le coup.
Constructeur : Le seul constructeur de cette classe se contente juste de prendre une case et un
temps pour renseigner les attributs.
Accesseurs : Les accesseurs disponibles permettent d'obtenir la valeur des attributs sans pouvoir les
modifier.
La classe HistoriquePartie :
Cette classe décrit le déroulement d'une partie en rassemblant les coups joués.
Attributs : Les attributs sont le nombre de coups joués et un Vector de Coups contenant l'ensemble
des coups joués de la partie.
Constructeur : Un seul constructeur permettant d'initialiser les attributs.
Accesseur : Il est possible d'ajouter un coup à l'historique en utilisant la méthode ajoute(Coup).
Méthode : Pour appliquer l'historique d'une partie à une grille il suffit d'utiliser la méthode joue
(Grille).
La classe SauvegardeGrille :
Cette classe permet de sauvegarder une grille initiale en ne gardant que les informations
minimales et indispensables à la recréation de la grille.
Attributs : hauteur, largeur, nombre de mines et positions de celles-ci dans la grille sauvegardée.
Constructeur : Un seul constructeur qui prend une grille en paramètres.
Accesseurs : Différents accésseurs qui permettent d'accéder aux attributs en lecture seule.
Méthode : Une méthode qui retourne une grille crée grâce à l'enregistrement.
La classe Sauvegarde :
Cette classe permet de regrouper l'ensemble des informations à sauvegarder.
Attributs : Une instance des classes SauvegardeGrille, HistoriquePartie et Options. Elle contient en
plus la taille et la position de la fenêtre principale afin de recharger ces paramètres à la prochaine
exécution du programme.
Constructeur : Deux constructeurs: un qui initialise les attributs en prenant en paramètre une Grille
et l'autre qui n'initialise rien. Le premier sera appelé pour construire une sauvegarde de l'existant et
le second pour charger une sauvegarde.
Accesseurs : Différents accesseurs au attributs.
Méthodes :Une méthode save() qui permet d'enregistrer toutes les sauvegardes dans le fichier
« saveDemineur.ser », et une méthode load() qui permet de charger ce que contient le fichier
« saveDemineur.ser » dans l'instance de la classe.
Page 9/11
Organisation du réseau :
La gestion du jeu en réseau se fait grâce à deux classes principales.
La classe Server :
Cette classe va créer le socket serveur afin de permettre une connexion, et ensuite va lancer
un thread qui va attendre les connexions clients et leur envoyer une copie de la grille de jeu afin de
jouer la même partie sur les différents clients/serveur. Un thread d'écoute est également lancé à
chaque connexion client, afin de récupérer les informations provenant des clients, comme le temps
mis pour finir la grille.
Attributs : Un SocketServer et une Grille.
Constructeur : Un seul constructeur qui prend une Grille en paramètre.
Méthodes : Une méthode attendre_client qui permet d'attendre les connexions des clients avant de
diffuser les informations, plusieurs Broadcast qui permettent de diffuser des informations aux
clients.
La classe Client :
Cette classe créer un socket client et tente de se connecter à un serveur, et lance ensuite un
thread d'écoute afin de recevoir une copie de la grille de jeu. Le client envoie une fois sa partie
terminé son temps au serveur.
Attributs : Un Socket client et une Grille.
Constructeur : Un seul constructeur qui prend une Grille en paramètre.
Méthodes : Plusieurs Broadcast qui permettent de diffuser des informations au serveur.
En fin de partie les temps sont affichés dans une fenêtre JFrame de la classe MsgBox.
Page 10/11
Conclusion
Ce projet étant le premier que nous ayons à faire en java, et surtout le premier dans lequel
nous abordons les interfaces graphiques dans le code a été très enrichissant tant sur le plan du
langage lui même que sur le plan de la programmation objet. Java permet en effet de créer des
applications en restant très proche de l'analyse UML et donc un travail bien cloisonné. Couplé à
l'IDE Eclipse, nous avons profité de la puissance d'outils tels que JavaDoc et compris l'intérêt d'un
bon environnement de travail au niveau organisationnel.
Nous avons essayé de « programmer proprement » et même s'il reste toujours des
fonctionnalités à implémenter, nous avons fait en sorte que notre application soit facilement
maintenable et évolutive.
Page 11/11

Projet_Java_

Transcription

Documents pareils

jeu des dinosaures

kakuro

MAISON MIKIT

Construction/Destruction

JEU DE DÉS

Binero_ règles du jeu

Enonce - gardeux

Le Sudoku, art cérébral du programmeur

Collège Privé Cluny - Collège Saint Joseph de Cluny