Les tamagoshis

PAS DE MOTEUR DE RECHERCHE / PAS D'IA (MÊME DANS L'IDE) / PAS DE STACKOVERFLOW...


LA SEULE PAGE AUTORISÉE EST : https://docs.oracle.com/en/java/javase/21/docs/api

Au cours des prochaines séances, l'objectif est de réaliser un projet pour lequel vous appliquerez le plus possible les principes de développement que nous avons vu en cours, ainsi que les outils correspondants. En soi, le projet n'est pas très compliqué mais vous verrez qu'il est possible de le réaliser avec une qualité plus ou moins bonne. Ainsi, votre but sera de l'améliorer au fur et à mesure.

En programmation orientée objet, on dit que les méthodes d'une classe définissent le comportement de ses instances. Pour bien comprendre cette notion, on peut faire une analogie entre le comportement des instances et celui d'êtres vivants. Un tamagoshi va donc être un objet qui vit (perd de l'énergie) et qui doit être alimenté pour survivre (augmenter son énergie). Le but de ce projet est de réaliser un jeu qui consiste à faire interagir l'utilisateur dans le but de maintenir une colonie de tamagoshis en vie. Ceux-ci ayant des comportements divers et variés.

PARTIE 1 : Initialisation du projet : Gradle / IDE / GitLab

Exercice 1:

Pour commencer, vous allez créer un projet à l'aide de Gradle (COMME NOUS N'AVONS PAS ENCORE VU GRADLE, VOUS FEREZ AVEC PLUS TARD (exos 1 et 2)... sauf si vous connaissez), en ligne de commande, quelque part dans votre arborescence. Choisissez application pour le type du projet -> langage Java -> subprojects : no -> syntaxe groovy pour le DSL des fichiers de build, de préférence, -> Junit Jupiter pour les tests.

Exercice 2:

Importerez ce projet dans votre IDE favori et vérifierez que tout fonctionne, avec le squelette de base.

Exercice 3:

Créez maintenant dans GitLab un projet vide ayant pour nom Tamagoshis, préfixé par votre nom de famille, par exemple Dupont_Tamagoshis.

Exercice 4:

Dans le menu Plan de GitLab, créez une nouvelle milestone dont la description sera de réaliser la version 1.0 du jeu en mode texte.

Exercice 5:

Dans un premier temps, vous ne travaillerez jamais sur la branche main, qui sera considérée comme contenant une version stable du logiciel. Toutes vos modifications devront être faites sur une ou plusieurs branches alternatives. Vous pouvez par exemple créer une branche 'develop' qui vous servira de point de départ pour créer d'autres branches de type feature, que vous fusionnerez au fur et à mesure dans develop. Une fois que vous penserez que le résultat est bon, vous ferez une merge request sur main qui sera relue par quelqu'un d'autre (dans un prochain TP).

PARTIE 2 - Le jeu

Le principe du jeu est très simple : le joueur choisit le nombre de Tamagoshi avec lequel il veut jouer et leur donne un nom, puis la partie se déroule tour par tour sachant que le joueur peut effectuer une seule interaction d'un type avec un Tamagoshi. Par exemple, il pourra choisir de nourrir un Tamagoshi, puis jouer avec un autre ou le même.

À chaque tour, les Tamagoshis expriment leurs émotions en fonction de leurs variables d'état. Par exemple, un Tamagoshi qui possède peu d'énergie exprimera un besoin de manger lorsque son état sera affiché. Idem pour le besoin de jouer. Par ailleurs, à chaque fin de tour les variables d'état des Tamagoshis sont décrémentées en fonction du type du Tamagoshi. Par exemple, pour un Tamagoshi normal, on fera baisser toutes les valeurs d'un point tout en augmentant son âge de un point. Si une valeur passe à 0, le tamagoshi est retiré du jeu.

Le nombre de tamagoshis initial ainsi que leurs noms seront entrés par l'utilisateur à l'initialisation du jeu. Le nombre de tamagoshis correspond au niveau de difficulté du jeu. Le score obtenu à la fin du jeu correspond au pourcentage de la somme de l'âge des tamagoshis par rapport à la somme de leur durée de vie potentielle. Par exemple, pour 3 tamagoshis, le maximum possible est 3*10, 30. Si tous les tamagoshis finissent avec un âge de 10, le score est de 100 %.

Pour pimenter le jeu, l'idée est d'avoir plusieurs sortes de Tamagoshi qui évolueront de manière différente, sans que le joueur ne connaisse le type exact des Tamagoshis : il s'agit de les deviner pendant la partie. Par exemple, on peut imaginer un type de Tamagoshi qui serait un gros mangeur et dont l'énergie diminue très rapidement, ce qui ferait qu'il serait souvent en demande d'être nourri. De la même manière, on peut imaginer des Tamagoshis légendaires qui récupèrent l'intégralité de leurs points d'énergie dès qu'on les nourrit. De plus, lorsqu'on donne à manger à un tamagoshi, le nombre de points d'énergie gagné est tiré aléactoirement entre 1 et 3. Idem pour l'attibut de fun.

Le jeu s'arrête lorsque les tamagoshis sont tous morts ou arrivés à leur âge limite.

Voici un exemple d'exécution pour une version très basique du jeu :

Exercice 6:

Voici les caractéristiques communes à tous les Tamagoshis :
- un nom
- un générateur de nombres aléatoires partagé par toutes les instances.
- une constante représentant l'âge limite des tamagoshis, ayant pour valeur 10
- un âge (qui correspondra au numéro du tour de jeu)
- un compteur d'énergie initialisé aléatoirement entre les valeurs 3 et 5
- une variable correspondant au maximum d'énergie que le Tamagoshi peut avoir, initialisée aléatoirement entre 5 et 9.
- une variable correspondant au niveau d'alerte sur l'énergie, initialisée aléatoirement entre 3 et 5 : autrement dit à partir de quel niveau d'énergie le tamagoshi réclame à manger

Ces trois derniers attributs sont déclinés de la même manière pour le fun.

Exercice 7:

Réalisez un programme qui permet d'obtenir quelque chose de similaire à l'exemple d'exécution.

Vous êtes libres de l'organisation de vos classes et de vos packages. Vous devrez cependant respecter un certain nombre de prérequis dont voici la liste :
- Les classes/interfaces utilisées pour les tamagoshis doivent être dans un package différent de celles du jeu
- Toutes les méthodes publiques doivent être documentées
- Réfléchissez bien aux visibilités de vos méthodes
- Utilisez autant que possible les pratiques de développement dirigé par les tests
- Factorisez le plus possible votre code : éviter d'avoir des lignes de code qui se ressemblent trop. pour cela, n'hésitez pas à créer des méthodes auxiliaires.
- Veillez à ce que votre code soit le plus lisible possible : notamment car quand vous aurez terminé la version 1. 0, vous serez relus par l'un de vos camarades.


Pour le choix du code concernant la saisie clavier, lisez cette page : Difference Between Scanner and BufferedReader Class in Java. Vous verrez qu'il est préférable d'utiliser un BufferedReader pour notre use case.

PARTIE 3 - Vous avez fini ?

Exercice 8:

Lisez cette documentation : How to Write a Git Commit Message