IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Corrections des exercices du livre "Java pour les enfants, les parents et les grand-parents"


précédentsommairesuivant

X. Chapitre 11

X-A. Exercice 1 : affecter les coordonnées du point

X-A-1. Le support de travail

Pour cet exercice, nous avons besoin de la première version du jeu : c'est-à-dire celle qui nous est donnée avant la section sur les fils d'exécution (Thread). Comme vous avez sûrement modifié les codes originaux pour les adapter à la section fil d'exécution, je les reposte ici (j'ai remplacé les accents).

TableVertePingPong
TéléchargerCacher/Afficher le codeSélectionnez
ConstantesDuJeu
TéléchargerCacher/Afficher le codeSélectionnez
MoteurJeuPingPong
TéléchargerCacher/Afficher le codeSélectionnez

X-A-2. Une correction possible

Cet exercice ne présente pas de grande difficulté. Vous pourrez juste remarquer, dans la méthode mousePressed() de la classe MoteurJeuPingPong, l'appel à

 
Sélectionnez
table.affecteCoordonneesPoint(evenement.getX(), evenement.getY());

sans même stocker les valeurs de evenement.getX() et evenement.getY() : en effet, on n'aura pas besoin de les réutiliser.

Voici les versions modifiées de TableVertePingPong.java et MoteurJeuPingPong.java.

Créez un package pour placer les deux fichiers de l'exercice 1 donnés ci-dessous. Dans Eclipse, importez les deux fichiers dans le nouveau package (clic droit sur le package en question et Import->General->FileSystem pour choisir le dossier où ils se situent). Copiez alors le fichier ConstantesDuJeu du package support_travail_exercice_1 vers le nouveau package (il suffit de faire clic droit->copy sur le fichier en question puis clic droit->paste sur le nouveau package.) Vous disposerez alors d'une copie adaptée pour le nouveau package.

TableVertePingPong
TéléchargerCacher/Afficher le codeSélectionnez
MoteurJeuPingPong
TéléchargerCacher/Afficher le codeSélectionnez

X-B. Exercice 2 : résolution du bogue

X-B-1. Support de travail

Cette fois-ci on doit travailler sur la version finale du jeu. (Sachez que dans les versions corrigées des différentes classes, tous les caractères accentués auront été remplacés.)

Je vous repasse donc les fichiers de la version finale du jeu de ping-pong, tel qu'il a été défini à la fin du chapitre (sans les accents).

TableVertePingPong
TéléchargerCacher/Afficher le codeSélectionnez
MoteurJeuPingPong
TéléchargerCacher/Afficher le codeSélectionnez
ConstantesDuJeu
TéléchargerCacher/Afficher le codeSélectionnez

X-B-2. Correction possible

Cet exercice ne présente pas de difficulté particulière.

Une manière simple de procéder consiste à vérifier, au moment où l'utilisateur appuie sur la touche S (que ce soit en minuscule ou en majuscule), que les scores du joueur et de l'ordinateur sont inférieurs au score gagnant. Et l'on sait que c'est dans la méthode keyPressed de la classe MoteurJeuPingPong qu'est effectuée la gestion des touches.

Enfin par prudence on peut déplacer l'étape 4 de la méthode run(), celle qui consiste à faire sommeiller le Thread, juste en dehors de la condition if (balleServie). Donc juste au début de la boucle while(true). De cette manière, si le service n'a pas été effectué, on sera quand même en mesure de faire le Thread se reposer un peu et éviter qu'il ne bloque tout.

Voici donc la nouvelle version de MoteurJeuPingPong.java :

MoteurJeuPingPong amélioré
TéléchargerCacher/Afficher le codeSélectionnez

X-C. Exercice pour les petits malins 1 : vitesse de la raquette

On peut s'y prendre de plusieurs manières pour ajuster le niveau de jeu. Ici, nous nous contenterons d'ajuster la vitesse de déplacement de la raquette du joueur en fonction du niveau.

Pour cela, la formule suivante est utilisée :

 
Sélectionnez
incrémentRaquetteJoueur = INCREMENT_RAQUETTE + 20 ?  2*niveauJoueur

Si l'on prend la valeur 2 pour INCREMENT_RAQUETTE, on aura notamment les valeurs suivantes :

niveauJoueur incrementRaquetteJoueur
1 20
5 12
10 2

Ainsi, la vitesse sera la plus élevée pour le niveau 1 et la plus faible pour le niveau 10.

Dans le fichier ConstantesDeJeu, on élargit la hauteur du composant table verte, afin d'y ajouter un nouveau panneau pour le choix du niveau. Mais on y définit aussi les niveaux minimum et maximum.

ConstantesDuJeu
TéléchargerCacher/Afficher le codeSélectionnez

On peut ajouter une méthode publique fixerNiveauDeJeu() dans la classe MoteurDeJeu afin de permettre à la classe TableVertePingPong de le modifier.

Dans la classe TableVertePingPong, on va ajouter une JComboBox permettant de choisir le niveau. On implémente l'interface ItemListener dans la classe TableVertePingPong afin de réagir au choix d'un élément de la JComboBox. Elle se compose de la méthode unique itemStateChanged().

Vous remarquerez l'appel à

 
Sélectionnez
String.valueof(i);

où i est de type int. Ceci permet simplement de convertir un entier en chaîne de caractères. La méthode valueof est aussi surchargée pour accepter un boolean, un char...

Enfin, une précaution est prise, dans la méthode itemStateChanged(), pour vérifier que l'on réponde bien à un évènement de sélection et non de désélection : car quand on choisit un élément, l'écouteur de type ItemListener réagit deux fois consécutives. L'une pour la désélection de l'élément précédent et l'autre pour la sélection du nouvel élément. Ceci par le biais du code suivant :

 
Sélectionnez
if (event.getStateChange() == ItemEvent.SELECTED) {

où event est le paramètre de la méthode itemStateChanged().

Voici le code de la nouvelle version de TableVertePingPong.java :

TableVertePingPong
TéléchargerCacher/Afficher le codeSélectionnez

Voici la nouvelle version de MoteurJeuPingPong.java :

MoteurJeuPingPong
TéléchargerCacher/Afficher le codeSélectionnez

Une dernière remarque. J'ai utilisé l'opérateur ternaire pour affecter la variable niveauDeJeu :

 
Sélectionnez
niveauDeJeu = niveauDeJeu < 1 ? 1 : niveauDeJeu

Il vous a été expliqué dans le livre. Plus précisément, dans le code de la version finale du jeu de ping pong (Chapitre 11, section "Fin du jeu ping-pong"). Il est utilisé au début de la méthode run() de la classe MoteurJeuPingPong et l'auteur nous en explique le fonctionnement juste avant le code. Pour rappel cet opérateur permet "d'économiser" l'utilisation d'une structure if/else.

X-D. Exercice pour les petits malins 2 : direction du rebond de la balle

Pour résoudre cet exercice, il convient d'abord de se poser les questions suivantes :

  • où se situe le milieu de la table ?
  • où doit-on modifier le code afin de gérer le rebond ?

Pour répondre à la première question, nous allons déclarer une nouvelle constante : HAUTEUR_MILIEU_TABLE. Nous avons :

 
Sélectionnez
HAUTEUR_MILIEU_TABLE = (BAS_TABLE ? HAUT_TABLE) / 2

Voici donc la nouvelle version du fichier ConstantesDuJeu.java :

ConstantesDuJeu
TéléchargerCacher/Afficher le codeSélectionnez

Quant à la gestion du rebond sur la raquette enfant, il fallait regarder dans la méthode run() de la classe MoteurJeuPingPong.java, étape 2. Pourquoi l'étape 2 ? Tout simplement parce que c'est lorsque que la balle se déplace vers la droite qu'elle est susceptible de rebondir sur la raquette de l'enfant.

Section de code pertinente
Sélectionnez
                // Etape 2. La balle se deplace-t-elle vers la
                // droite ?
                if (!deplacementGauche && balle_X <= BALLE_X_MAX) {
                    rebondPossible = (balle_Y >= raquetteEnfant_Y &&
                            balle_Y < (raquetteEnfant_Y +
                                    LONGUEUR_RAQUETTE) ? true : false);
                    balle_X += INCREMENT_BALLE;
                    table.positionnerBalle(balle_X, balle_Y);
                    // La balle peut-elle rebondir ?
                    if (balle_X >= RAQUETTE_ENFANT_X &&
                            rebondPossible) {
                        deplacementGauche = true;
                    }
                }

Pour l'instant, le code se contente de renvoyer la balle dans la direction verticale qui a été donnée lors du service de l'enfant (cette variable n'est modifiée nulle part ailleurs que dans la méthode serviceEnfant()). Or, il faut que la direction change en fonction de la position de raquette_Y.

Nous allons donc ajouter un test if(), pour voir si la raquette de l'enfant se situe au-dessus du milieu de l'écran et modifier la direction verticale de la balle en conséquence.

 
Sélectionnez
                // Etape 2. La balle se deplace-t-elle vers la
                // droite ?
                if (!deplacementGauche && balle_X <= BALLE_X_MAX) {
                    rebondPossible = (balle_Y >= raquetteEnfant_Y &&
                            balle_Y < (raquetteEnfant_Y +
                                    LONGUEUR_RAQUETTE) ? true : false);
                    balle_X += INCREMENT_BALLE;
                    table.positionnerBalle(balle_X, balle_Y);
                    // La balle peut-elle rebondir ?
                    if (balle_X >= RAQUETTE_ENFANT_X &&
                            rebondPossible) {
                        if (raquetteEnfant_Y < MILIEU_HAUTEUR_TABLE){
                            deplacementVertical = -1;
                        }
                        else {
                            deplacementVertical = 1;
                        }
                        deplacementGauche = true;
                    }
                }

Voici donc le code complet de la nouvelle version de MoteurJeuPingPong.java :

MoteurJeuPingPong
TéléchargerCacher/Afficher le codeSélectionnez

Pour tester le package depuis Eclipse (clic droit sur son nœud → RunAs → JavaApplication), il vous faut copier la source TableVertePingPong du package de l'exercice 1 des petits malins (l'exercice précédent).

X-E. Synthèse

Les exercices de ce chapitre vous ont permis :

  • d'encapsuler une variable de classe et de modifier les autres classes en conséquence ;
  • de résoudre un bogue simple ;
  • d'ajuster le niveau de jeu ;
  • de résoudre un bogue moins évident.

précédentsommairesuivant

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2012 Laurent Bernabé. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.