Rapport final - Julien Stephen Bergé

2012
Rapport final
La Guerre d’ESIL
Projet - Programmation Orientée Objet
Jeu de Stratégie réalisé en JAVA par deux étudiants de l’ESIL
Encadré par M. Sébastien Mavromatis
Julien Bergé – Jimmy Chauveau
2/13/2012
SOMMAIRE
I.
Préambule ................................................................................................................................................................. 3
II.
Règle du Jeu .............................................................................................................................................................. 3
III.
Déroulement d’une partie ........................................................................................................................................ 5
IV.
Les différents fichiers ................................................................................................................................................ 9
1.
Carte.java ................................................................................................................................................................ 10
2.
Joueur.java .............................................................................................................................................................. 11
3.
Animal.java ............................................................................................................................................................. 12
4.
Combat.java ............................................................................................................................................................ 12
5.
L’interface graphique .............................................................................................................................................. 12
6.
Jeu.java ................................................................................................................................................................... 13
V.
Difficultés rencontrées ............................................................................................................................................ 13
VI.
Conclusion .............................................................................................................................................................. 13
2
Préambule | Julien Bergé – Jimmy Chauveau
Projet P.O.O
I.
[RAPPORT FINAL]
PREAMBULE
Dans le cadre de nos études, les enseignants nous ont demandé de réaliser un projet de Programmation Orientée Objet afin de
mettre en pratique nos compétences. Le fil conducteur de notre sujet était le jeu de la vie, mais il nous a été permis d’interpréter et
d’extrapoler comme on le souhaitait du moment qu’il existait une vraie interaction entre les objets dans notre programmation.
Nous avons arbitrairement choisi de programmer en JAVA. En effet, nous avons eu l’occasion de tester plusieurs langages de
programmation objet, le JAVA nous parait plus intuitif et adapté à notre but.
De plus, nous comptons utiliser le logiciel Eclipse pour programmer, ce logiciel étant celui sur lequel nous avons appris le JAVA.
Pendant la réalisation du jeu, Julien étant plus à l’aise dans la programmation s’est occupé de la structure du projet, de
l’implémentation des fonctions de déplacements et de la romance du jeu. Jimmy s’est occupé de la réalisation des fonctions
concernant la matrice, de l’affichage de la carte et des schémas UML. Cependant, bien qu’il semble difficile de réaliser un projet de
la sorte à plusieurs, nous avons facilement mis nos avancements en commun.
Tout d’abord, grâce à l’utilisation de « Dropbox » qui nous a permis de mettre à jour des fonctions dès que l’un de nous deux avait
travaillé sur le projet. De plus, nous nous sommes plutôt bien réparti les tâches et avons facilement utilisé des fonctions que l’autre
avait faites, le code reste à ce jour aussi clair.
II.
REGLE DU JEU
Sur une carte en deux dimensions, deux iles seront représentées. L’indien sur l’Amérique et l’Européen sur l’Europe, le but du
joueur sera de récolter les ressources nécessaires (bois, nourriture, or, pierre) afin de créer un bateau et d’atteindre l’ile adverse. Le
joueur devra aussi se nourrir en mangeant des animaux et éviter de se faire attaquer par d’autres.
3
Préambule | Julien Bergé – Jimmy Chauveau
Les touches violettes permettent de se déplacer sur la carte. Ensuite il faut se trouver sur le bloc ressource pour pouvoir la récolter :
 La touche o, en jaune, permet de récolter de l’or
 La touche p, en gris, permet de récolter de la pierre
 La touche b, en vert, permet de récolter du bois
Il faut obtenir 100 unités de chaque ressource pour pouvoir créer son bateau.
Cependant, le joueur perd un point de vie à chaque tour, il lui est donc nécessaire de manger en appuyant sur la touche m, en rouge.
Pour pouvoir avoir de la nourriture, il faut tuer des animaux :
 Une dinde, qui bouge tous les 5 tours, meurt en une seule fois et rapporte 20 de nourriture
 Un sanglier qui bouge tous les 2 tours, meurt en 2 fois et rapporte 50 de nourriture.
Le lion est le seul animal qui ne rapporte pas de nourriture, qui bouge à chaque tour et qui n’est donc là que pour nuire à l’homme.
Une fois les ressources nécessaires à la création du bateau le joueur devra se diriger vers l’océan, là il se transformera
systématiquement en mode bateau. Son but sera de rejoindre l’autre ile sans mourir, pour cela il devra être certain d’avoir mangé
assez de nourriture avant de partir, car il est impossible de manger une fois en mer et comme en mode normal le joueur perdra un
point de vie à chaque tour plus un nombre aléatoire compris entre 1 et 10 de points de vie lorsqu’il passera sur un bloc d’eau
dangereuse.
Le joueur ayant atteint l’ile adverse en premier aura gagné !
4
Déroulement d’une partie | Julien Bergé – Jimmy Chauveau
Projet P.O.O
III.
[RAPPORT FINAL]
DEROULEMENT D’UNE PARTIE
En commençant une partie, nous avons une carte comme celle-ci :
Carte principale
Nous avons ainsi la terre représentant l’Amérique à gauche et celle de l’Europe à droite. L’indien est le personnage situé au milieu de
la terre de gauche et l’Européen le personnage au milieu de celle droite. Nous pouvons aussi voir les animaux, comme prévu dans le
cahier des charges, il y en a plus en Amérique qu’en Europe.
Les ressources sont éparpillées dans tout le territoire équitablement, le joueur pourra donc récupérer la ressource en se
positionnant dessus et en choisissant de l’exploiter.
Aussi, il est possible de voir au milieu de l’eau des zones qui possèdent des « vagues », ce sont les eaux dangereuses, elles peuvent
faire perdre entre 1 et 10 de vie au joueur.
5
Déroulement d’une partie | Julien Bergé – Jimmy Chauveau
Nous voyons ici le menu se situant à droite de la carte :
Menu de jeu
Ce menu indique à qui est le tour, les ressources du joueur, les options de la case (manger) et ses déplacements possibles. Il suffit
ainsi de saisir le caractère voulu afin de jouer.
Aussi, les choix proposés sont en accord avec le terrain.
Exemple de déplacement restreint
Pour récupérer des ressources, le joueur doit se placer dessus et saisir la touche correspondante :
Saisie d’une ressource de bois
On a le menu suivant :
6
Déroulement d’une partie | Julien Bergé – Jimmy Chauveau
Après avoir pris la ressource :
Projet P.O.O
[RAPPORT FINAL]
Ainsi, le joueur verra donc sa ressource en bois augmenter. Il en est de même pour l’or et la pierre.
Voici maintenant comment fonctionnent les animaux :
Attaque d’un animal
L’indien a été attaqué par un Lion, nous avons après son attaque :
Pour ce qui est de la récolte de nourriture :
Récolte de nourriture
Ici, nous voyons que l’indien a tué l’animal “Dinde” et a ainsi récupéré 20 de ressources de nourriture. Il pourra ainsi récupérer de la
vie en saisissant la touche correspondante au prochain tour s’il le veut.
Le jeu étant assez long, il faut que le joueur mange et chasse afin de rester en vie. Dans le cas contraire, le jeu termine lorsque l’un
des joueurs meurt de faim :
Mort d’un des joueurs
Un joueur peut aussi bien évidemment mourir à cause d’un animal (Sanglier ou Lion).
7
Déroulement d’une partie | Julien Bergé – Jimmy Chauveau
Lorsque le joueur a récolté les ressources nécessaires, il obtient le message suivant :
Assez de ressources pour créer un bateau
Ensuite, il pourra se diriger vers la cote la plus proche et crée le bateau :
Création d’un bateau
En traversant l’océan, il pourra passer dans les eaux dangereuses et ainsi perdre de la vie.
Traverse des eaux dangereuses
La partie s’arrête lorsque l’un des joueurs a traversé l’océan et a atteint le continent adverse.
Voici un exemple :
Partie terminée par conquête
8
Les différents fichiers | Julien Bergé – Jimmy Chauveau
Projet P.O.O
IV.
[RAPPORT FINAL]
LES DIFFERENTS FICHIERS
Voici le schéma UML simplifié de notre projet.
Dans cette partie nous allons voir comment les différents fichiers sont liés les uns avec les autres.
9
Les différents fichiers | Julien Bergé – Jimmy Chauveau
1. CARTE.JAVA
Ce fichier est le plus important de notre programme : il permet dans un premier temps la création de la carte via la lecture du
fichier précédent (grâce aux fichiers Lirecarte.java et carte1.txt). Carte1.txt permet la création de la carte ; nous y trouvons une suite
de 1200 caractères sur 30 lignes, chaque caractère représentant un bloc de la carte :
 ¨ : un bloc d’herbe
 . : un bloc de sable
 - : un bloc d’eau calme
 ~ : un bloc d’eau dangereuse
 T : un bloc de forêt
 : un bloc d’or
 ^ : un bloc de pierre
Voici celui de notre projet :
Dans le projet actuel, nous avons une seule carte. Pour rendre le jeu bien plus intéressant, un set d’une dizaine de cartes aurait été
nécessaire, mais étant une activité relativement fastidieuse, nous avons concentré notre temps sur le test d’une seule carte
complète.
10
Les différents fichiers | Julien Bergé – Jimmy Chauveau
Projet P.O.O
[RAPPORT FINAL]
À la lecture de ce String, chaque caractère sera transformé en un objet de type bloc (le diagramme suivant nous montre les
différentes classes « bloc » qui existent et leurs héritages respectifs)
Ensuite Carte.java possède deux méthodes qui ont pour but de convertir la position (x, y) de notre joueur sur la matrice représentée
par notre carte en un rang (nombre compris en 1 et 1200 qui indique la position dans la String de notre carte1.txt) et inversement.
Enfin ce fichier permet le déplacement des joueurs grâce à plusieurs fonctions qui servent à :
Vérifier quelles sont les possibilités de jeu que le joueur a (ses déplacements ou ses actions)
 Demander au joueur ce qu’il souhaite faire
 Prendre en compte le choix du joueur
 Exécuter l’action choisie
2. JOUEUR.JAVA
11
Les différents fichiers | Julien Bergé – Jimmy Chauveau
Comme le montre le diagramme UML précédent, deux classes héritent de ce fichier : Indien (Indien.java) et Européen
(Européen.java). Ces dernières étant similaires, nous ne les distinguerons pas dans les explications à suivre.
Dans ces classes, nous retrouvons tout ce qui est nécessaire aux personnages pour pouvoir évoluer librement dans le jeu :
 Afficher les différentes informations du personnage (son nom, sa vie, ses ressources…)
 Savoir s’il se trouve sur un bloc de ressources
 Exploiter cette dernière si tel est le cas
 Pouvoir manger
 Vérifier si son nombre de ressources est suffisant pour créer un bateau
 Passer en mode bateau (si le point précédent est respecté et que le personnage se trouve au bon endroit)
 Vérifier si le joueur est mort ou s’il a gagné la partie
3. ANIMAL.JAVA
Voici le schéma UML de la classe Animal
Cette classe permet tout simplement le déplacement aléatoire des animaux sur la carte, les trois classes filles servent seulement
pour surcharger les attributs de différemment.
4. COMBAT.JAVA
Cette classe gère les combats lorsqu’un joueur et un animal se retrouvent sur la même case. Selon l’animal elle enlève un
nombre de points de vie plus ou moins important à ce dernier et au joueur et en cas de mort de l’animal, donne une quantité de
nourriture définie pour chaque type d’animal.
5. L’INTERFACE GRAPHIQUE
Elle se compose de deux panneaux :
 Le premier est celui de la carte (CartePanneau.java): Chaque bloc, joueur et animal a une image .png qui lui est associé. La
lecture de carte1.txt permet d’afficher l’image correspondant au caractère lu.
 Le deuxième panneau est celui des informations (MenuPanneau.java) : Nous y trouvons toutes les informations sur le
joueur, ses possibilités de déplacement, les actions qu’il peut faire, mais c’est aussi ci qu’il est averti qu’il peut passer en
mode bateau. Nous avons utilisé du HTML dans notre code pour une mise en page plus simple.
12
Les différents fichiers | Julien Bergé – Jimmy Chauveau
Projet P.O.O
[RAPPORT FINAL]
6. JEU.JAVA
Ce fichier correspond au main de notre programme. À son lancement :
 Il crée les différentes instances du jeu : la carte, les joueurs, le combat, l’interface…
 Il permet l’écoute d’une musique de fond (grâce au fichier Son.java)
 Il fait passer les joueurs du mode humain au mode bateau
 Il gère la résurrection des animaux
V.
DIFFICULTES RENCONTREES
Nous avons eu certains problèmes pendant le développement du projet. Malgré le fait que nous ayons réfléchi à la structure du
programme avant de commencer l’implémentation, nous avons rencontré certaines incohérences. Cela nous a permis de revoir
notre structure et de l’améliorer, mais aussi de nous simplifier la tâche. Le projet étant assez complexe et long à implémenter, il était
important de créer des classes et des fonctions simples à utiliser, à réutiliser voire à améliorer.
C’est pour cela que nous nous sommes forcés à mettre des commentaires dans chaque fonction de chaque classe.
De plus, nous étions partis dans l’optique de générer la carte sous forme d’une matrice, ce qui semblait pour nous la meilleure
solution. La majorité de nos problèmes concernait la matrice, la position des personnages, des animaux, des blocs et des ressources.
Nous sommes tout de même satisfaits de notre carte formée de blocs étant donné que nous avons gardé la même structure de celle
de notre conception.
Aussi, bien que non obligatoires, nous avons passé beaucoup de temps sur le passage du choix de l’utilisateur au terminal à celui du
choix au clavier. La fonction principale du déplacement était basée sur une saisie de l’utilisateur, il a fallu changer beaucoup de
choses pour l’adapter au clavier. Nous avions donc deux versions du jeu, une au clavier et une au terminal, mais étant donné que
nous avons réussi à rendre celle du clavier vraiment jouable, nous avons continué sur cette version et avons corrigé les derniers bugs
sur celle-ci.
VI.
CONCLUSION
Nous sommes satisfaits d’avoir pu mener à bien ce projet malgré les difficultés rencontrées. Il nous a permis d’améliorer nos
compétences du point de vue de la programmation objet. Nous nous sommes grandement améliorés tout au long du projet en
découvrant petit à petit des astuces. Nous avons respecté notre cahier des charges et réussi à mettre en place une interface
graphique qui nous permet une meilleure prise en main de notre jeu. Le fait de réviser le cahier des charges et le cahier de
conceptions nous a apporté une bonne expérience.
Le fait de pouvoir choisir librement un sujet qui nous faisait plaisir sans trop de contraintes nous a permis de vraiment nous investir.
Nous sommes satisfaits d’être arrivés à un résultat dont nous sommes relativement fiers.
Bien entendu, nous avons passé la majorité de notre temps à réaliser les exigences fonctionnelles, nous aurions pu ajouter de petits
plus à notre jeu afin de le rendre encore plus intéressant. Toutes les fonctions principales et nécessaires étant implémentées, il est
maintenant très simple de rajouter ces petits plus.
13
Difficultés rencontrées | Julien Bergé – Jimmy Chauveau