Atelier Jeux de dés en Java (BTS SIO)

Atelier Jeux de dés (en 4 parties)
Public :
BTS SIO
Contexte :
DAIGL prog - Java
Durée prévue :
4*2 h
Auteur :
P. Erny
Objectifs :
Manipuler et concevoir des classes, des méthodes, des constructeurs
Créez un nouveau projet AtelierJeuDeDes
1e PARTIE – LA CLASSE DE AVEC SES CONSTRUCTEURS ET SES METHODES
1. - Créez une classe De avec les propriétés num (n° du dé), nbFaces (nombre de faces) et valeur.
- Encapsulez-les et créez les accesseurs getNbFaces(), getValeur(), getNum().
- Créez un constructeur sans paramètre qui initialise par défaut le nombre de faces à 6 et la valeur
du dé à 0.
- Créez un autre constructeur avec un paramètre permettant d'initialiser le n° du dé.
- Écrivez une méthode lancer() qui simule un lancer du dé en tenant compte du nombre de faces.
Demandez-vous s'il est préférable d'utiliser une fonction ou une procédure.
- Écrivez une méthode toString() qui retourne le n° et la valeur du dé selon le format "dé n : valeur".
- Écrivez une classe Test qui crée puis lance 3 dés et affiche leur valeur.
- Ecrivez une méthode piper() pour la classe De qui truquera le dé en lui faisant sortir uniquement
des 4, 2 ou 1. Un attribut estPipe dira s'il est pipé ou non.
- Testez à nouveau avec des dés pipés.
2. Prenez un peu de temps pour répondre aux questions suivantes (si possible sans consulter de
cours) :
- Quelle est la différence entre une classe, un objet, une instance ?
- Quelle est la différence entre variable d'instance et variable locale ?
- A quoi sert la méthode main(), peut-il en exister plusieurs dans un projet ?
- Comment s'appelle le fait d'écrire dans une classe deux méthodes portant le même nom ?
Annexe – Comment générer des nombres aléatoires ? (rappel du cours)
En java, il y a 2 manières d'obtenir un nombre aléatoire, voici la 1ère :
– dans la classe Math, utiliser la méthode random, par exemple :
int n = Math.random(); // retourne un réel compris entre 0 (inclus) et 1 (exclus)
int n = (int)(Math.random() * 8); // retourne un entier de 0 à 7
– voici la seconde :
import java.util.Random;
…
Random r = new Random(); // on crée un objet de type Random
int n = r.nextInt(9) ; // on utilise la méthode nextInt de l'objet r en lui passant
// un paramètre p
// nextInt() retourne un entier de 0 à p-1 (p exclus)e

2e PARTIE – LE JEU DU SIMULATEUR
Dix amis décident de se défier aux dés. Ils choisissent de lancer chacun 20 fois un dé marqué à 6 faces.
Comme la partie risque de durer longtemps avec un vrai dé, ils vous proposent d'écrire le programme en
java qui va réaliser une simulation.
Vous implanterez les 20 lancers des 10 joueurs dans un tableau à 2 dimensions :
N° du lancer
0
1
2
3
4
5
6
...
.17
18
19
X
X
X
X
X
X
X
X
X
X
X
Joueur 1
2
...
9
10
Nota : vous n'utiliserez pas la ligne 0 afin que le joueur n° 1 soit à l'indice 1.
1. Créez une classe Simulateur comprenant le tableau t d'entiers ainsi qu'un objet de la classe De. Un
constructeur sans paramètre sera chargé d'initialiser toutes les cases à 0.
2. Écrivez une méthode remplir() qui remplira le tableau automatiquement. Le travail de lancer le dé est
délégué à la classe De.
3. Écrivez une méthode afficheLancersJoueur(int numJoueur) qui affiche les 20 lancers obtenus par le
joueur dont le n° est transmis en paramètre :
Joueur 09 : 4 1 6 … 1
4. Ecrire une classe TestSimulateur avec une méthode main pour tester les méthodes précédentes, par
exemple pour afficher les lancers des 10 joueurs :
…
Simulateur s1 = new Simulateur(); // le constructeur est appelé
s1.remplir();
for(int i = 1 ; i < 11 ; i++) {
s1.afficheLancersJoueur(i);
}
5. Dans Simulateur, écrire une méthode totalJoueur(int numJoueur) : int, qui retourne le total des
lancers obtenus par un joueur. Testez, puis afficher les résultats selon l'écran suivant (c'est un
exemple) :
Total joueur n° 1 : 3520
Total joueur n° 2 : 3408
...
Total joueur n° 10 : 3527
6. Complétez votre projet (une méthode à créer) pour obtenir le nombre de six réalisés par joueur :
Total joueur n° 1 : 3520 (dont 412 six)
Total joueur n° 2 : 3408 (dont 319 six)
...
Total joueur n° 10 : 3527 (dont 147 six)
7. Si ce n'est déjà fait, comment modifier la classe Simulateur pour qu'il soit possible de choisir le
nombre de joueurs et de lancers lors de l'instanciation (création) d'un Simulateur ?

3e PARTIE – LE JEU DU 421
Créer une classe Jeu421 qui simulera approximativement le fameux jeu du 421.
Principe : on lance simultanément 3 dés puis on choisit un dé à relancer jusqu'à ce qu'on obtienne la
combinaison 4, 2, 1 dans un ordre quelconque.
Ex. de déroulement :
dé 1 : 4
dé 2 : 6
dé 3 : 1
Quel dé relancer ? 2
dé 1 : 4
dé 2 : 3
dé 3 : 1
Quel dé relancer ? 2
dé 1 : 4
dé 2 : 2
dé 3 : 1
Gagné en 3 coups
Une méthode jouer() sera chargée de simuler une partie. Tester.
Modifier la méthode jouer() en utilisant des dés à 4 faces. Tester.
4e PARTIE – LE DE-A-DEVINER
Le principe du Dé-à-deviner est très simple : l'ordinateur lance (sans l'afficher) un dé à 100 faces (donc
valeur comprise entre 1 et 100) et le joueur doit deviner sa valeur dans le moins de coups possibles.
Si la valeur donnée par l'utilisateur est supérieure au dé l'ordi répond "C'est moins", si elle est inférieure
il répond "C'est plus" et s'il donne la bonne valeur l'ordi répond "Trouvé en n essais".
Imaginez puis créez les classes et méthodes nécessaires pour réaliser cet exercice.