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 Projet Java : Démineur Mathieu Fortin et Pierre Ruyssen 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é. Ifips Informatique 2 Page 2/11 Université Paris Sud XI Projet Java : Démineur Mathieu Fortin et Pierre Ruyssen 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 : Ifips Informatique 2 Page 3/11 Université Paris Sud XI Projet Java : Démineur Mathieu Fortin et Pierre Ruyssen 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. Ifips Informatique 2 Page 4/11 Université Paris Sud XI Projet Java : Démineur Mathieu Fortin et Pierre Ruyssen 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. Ifips Informatique 2 Page 5/11 Université Paris Sud XI Projet Java : Démineur Mathieu Fortin et Pierre Ruyssen 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. Ifips Informatique 2 Page 6/11 Université Paris Sud XI Projet Java : Démineur Mathieu Fortin et Pierre Ruyssen 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. Ifips Informatique 2 Page 7/11 Université Paris Sud XI Projet Java : Démineur Mathieu Fortin et Pierre Ruyssen 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. Ifips Informatique 2 Page 8/11 Université Paris Sud XI Projet Java : Démineur Mathieu Fortin et Pierre Ruyssen 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. Ifips Informatique 2 Page 9/11 Université Paris Sud XI Projet Java : Démineur Mathieu Fortin et Pierre Ruyssen 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. Ifips Informatique 2 Page 10/11 Université Paris Sud XI Projet Java : Démineur Mathieu Fortin et Pierre Ruyssen 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. Ifips Informatique 2 Page 11/11 Université Paris Sud XI