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

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

Cacher/Afficher le codeSélectionnez

package support_travail_exercice_1;

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;

import javax.swing.BoxLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.WindowConstants;

/**
 * Cette classe dessine une table de ping-pong verte
 * et affiche les coordonnees du point où l'utilisateur
 * a clique.
 */
public class TableVertePingPong
extends JPanel
implements ConstantesDuJeu {
    JLabel label;
    public Point point = new Point(0,0);
    public int raquetteOrdinateur_X = 15;
    private int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
    Dimension taillePreferee = new
            Dimension(LARGEUR_TABLE, HAUTEUR_TABLE);
    // Cette methode affecte sa taille au cadre.
    // Elle est appelee par Java.
    public Dimension getPreferredSize() {
        return taillePreferee;
    }
    // Constructeur.
    TableVertePingPong() {
        MoteurJeuPingPong moteurJeu =
                new MoteurJeuPingPong(this);
        // Reçoit les clics pour l'affichage de leurs coordonnees
        addMouseListener(moteurJeu);
        // Reçoit les mouvements de la souris pour
        // le deplacement des raquettes
        addMouseMotionListener(moteurJeu);
    }
    // Ajoute à une fenetre un panneau contenant cette table et
    // un JLabel
    void ajouteAuCadre(Container conteneur) {
        conteneur.setLayout(new BoxLayout(conteneur,
                BoxLayout.Y_AXIS));
        conteneur.add(this);
        label = new JLabel("Coordonnees...");
        conteneur.add(label);
    }
    // Repeint la fenetre. Cette methode est appelee par Java
    // quand il est necessaire de rafraîchir l'ecran ou quand
    // la methode repaint() est appelee par le
    // MoteurJeuPingPong.
    public void paintComponent(Graphics contexteGraphique) {
        super.paintComponent(contexteGraphique);
        // Dessine la table verte
        contexteGraphique.setColor(Color.GREEN);
        contexteGraphique.fillRect(
                0, 0, LARGEUR_TABLE, HAUTEUR_TABLE);
        // Dessine la raquette droite
        contexteGraphique.setColor(Color.yellow);
        contexteGraphique.fillRect(RAQUETTE_ENFANT_X_DEPART,
                raquetteEnfant_Y, 5, 30);
        // Dessine la raquette gauche
        contexteGraphique.setColor(Color.blue);
        contexteGraphique.fillRect(
                raquetteOrdinateur_X, 100, 5, 30);
        // Dessine la balle
        contexteGraphique.setColor(Color.red);
        contexteGraphique.fillOval(25, 110, 10, 10);
        // Dessine les lignes
        contexteGraphique.setColor(Color.white);
        contexteGraphique.drawRect(10, 10, 300, 200);
        contexteGraphique.drawLine(160, 10, 160, 210);

        // Affiche un point sous forme de rectangle de 2x2 pixels
        if (point != null) {
            label.setText("Coordonnees (x, y) : " +
                    point.x + ", " + point.y);
            contexteGraphique.fillRect(point.x, point.y, 2, 2);
        }
    }
    // Affecte sa position courante à la raquette de l'enfant
    public void positionnerRaquetteEnfant_Y(int y) {
        this.raquetteEnfant_Y = y;
    }
    // Retourne la position courante de la raquette de l'enfant
    public int coordonneeRaquetteEnfant_Y() {
        return raquetteEnfant_Y;
    }
    public static void main(String[] args) {
        // Cree une instance du cadre
        JFrame monCadre = new JFrame("Table verte de ping-pong");
        // Permet la fermeture de la fenetre par clic sur la
        // petite croix dans le coin.
        monCadre.setDefaultCloseOperation(
                WindowConstants.EXIT_ON_CLOSE);
        TableVertePingPong table = new TableVertePingPong();
        table.ajouteAuCadre(monCadre.getContentPane());
        // Affecte sa taille au cadre et le rend visible.
        monCadre.pack();
        monCadre.setVisible(true);
    }
}

ConstantesDuJeu

Cacher/Afficher le codeSélectionnez

package support_travail_exercice_1;

public interface ConstantesDuJeu {
    public final int LARGEUR_TABLE = 320;
    public final int HAUTEUR_TABLE = 220;
    public final int RAQUETTE_ENFANT_Y_DEPART = 100;
    public final int RAQUETTE_ENFANT_X_DEPART = 300;
    public final int HAUT_TABLE = 12;
    public final int BAS_TABLE = 180;
    public final int INCREMENT_RAQUETTE = 4;
}

MoteurJeuPingPong

Cacher/Afficher le codeSélectionnez

package support_travail_exercice_1;

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;

public class MoteurJeuPingPong implements
MouseListener, MouseMotionListener, ConstantesDuJeu {
    TableVertePingPong table;
    public int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
    // Constructeur. Stocke une reference a la table.
    public MoteurJeuPingPong(TableVertePingPong tableVerte) {
        table = tableVerte;
    }
    // Methodes requises par l'interface MouseListener.
    public void mousePressed(MouseEvent evenement) {
        // Recupere les coordonnees X et Y du pointeur de la
        // souris et les affecte au "point blanc" sur la table.
        table.point.x = evenement.getX();
        table.point.y = evenement.getY();
        // La methode repaint appelle en interne la methode
        // paintComponent() de la table qui rafraîchit la
        // fenetre.
        table.repaint();
    }
    public void mouseReleased(MouseEvent evenement) {}
    public void mouseEntered(MouseEvent evenement) {}
    public void mouseExited(MouseEvent evenement) {}
    public void mouseClicked(MouseEvent evenement) {}
    // Methodes requises par l'interface MouseMotionListener.
    public void mouseDragged(MouseEvent evenement) {}
    public void mouseMoved(MouseEvent evenement) {
        int souris_Y = evenement.getY();
        // Si la souris est au-dessus de la raquette de l'enfant
        // et que la raquette n'a pas depasse la limite
        // superieure de la table, la deplace vers le haut ;
        // sinon, la deplace vers le bas.
        if (souris_Y < raquetteEnfant_Y
                && raquetteEnfant_Y > HAUT_TABLE) {
            raquetteEnfant_Y -= INCREMENT_RAQUETTE;
        } else if (raquetteEnfant_Y < BAS_TABLE) {
            raquetteEnfant_Y += INCREMENT_RAQUETTE;
        }
        // Affecte la nouvelle position de la raquette dans la
        // classe table
        table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
        table.repaint();
    }
}

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

Cacher/Afficher le codeSélectionnez

package exercice1;

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;

import javax.swing.BoxLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.WindowConstants;

/**
 * Cette classe dessine une table de ping-pong verte
 * et affiche les coordonnees du point où l'utilisateur
 * a clique.
 */
public class TableVertePingPong
extends JPanel
implements ConstantesDuJeu {
    JLabel label;
    private Point point = new Point(0,0);
    public int raquetteOrdinateur_X = 15;
    private int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
    Dimension taillePreferee = new
            Dimension(LARGEUR_TABLE, HAUTEUR_TABLE);
    // Cette methode affecte sa taille au cadre.
    // Elle est appelee par Java.
    public Dimension getPreferredSize() {
        return taillePreferee;
    }
    // Constructeur.
    TableVertePingPong() {
        MoteurJeuPingPong moteurJeu =
                new MoteurJeuPingPong(this);
        // Reçoit les clics pour l'affichage de leurs coordonnees
        addMouseListener(moteurJeu);
        // Reçoit les mouvements de la souris pour
        // le deplacement des raquettes
        addMouseMotionListener(moteurJeu);
    }
    // Ajoute à une fenetre un panneau contenant cette table et
    // un JLabel
    void ajouteAuCadre(Container conteneur) {
        conteneur.setLayout(new BoxLayout(conteneur,
                BoxLayout.Y_AXIS));
        conteneur.add(this);
        label = new JLabel("Coordonnees...");
        conteneur.add(label);
    }
    // Repeint la fenetre. Cette methode est appelee par Java
    // quand il est necessaire de rafraîchir l'ecran ou quand
    // la methode repaint() est appelee par le
    // MoteurJeuPingPong.
    public void paintComponent(Graphics contexteGraphique) {
        super.paintComponent(contexteGraphique);
        // Dessine la table verte
        contexteGraphique.setColor(Color.GREEN);
        contexteGraphique.fillRect(
                0, 0, LARGEUR_TABLE, HAUTEUR_TABLE);
        // Dessine la raquette droite
        contexteGraphique.setColor(Color.yellow);
        contexteGraphique.fillRect(RAQUETTE_ENFANT_X_DEPART,
                raquetteEnfant_Y, 5, 30);
        // Dessine la raquette gauche
        contexteGraphique.setColor(Color.blue);
        contexteGraphique.fillRect(
                raquetteOrdinateur_X, 100, 5, 30);
        // Dessine la balle
        contexteGraphique.setColor(Color.red);
        contexteGraphique.fillOval(25, 110, 10, 10);
        // Dessine les lignes
        contexteGraphique.setColor(Color.white);
        contexteGraphique.drawRect(10, 10, 300, 200);
        contexteGraphique.drawLine(160, 10, 160, 210);

        // Affiche un point sous forme de rectangle de 2x2 pixels
        if (point != null) {
            label.setText("Coordonnees (x, y) : " +
                    point.x + ", " + point.y);
            contexteGraphique.fillRect(point.x, point.y, 2, 2);
        }
    }
    // Affecte sa position courante à la raquette de l'enfant
    public void positionnerRaquetteEnfant_Y(int y) {
        this.raquetteEnfant_Y = y;
    }
    // Retourne la position courante de la raquette de l'enfant
    public int coordonneeRaquetteEnfant_Y() {
        return raquetteEnfant_Y;
    }
    public void affecteCoordonneesPoint(int x, int y){
        point = new Point(x, y);
    }
    public static void main(String[] args) {
        // Cree une instance du cadre
        JFrame monCadre = new JFrame("Table verte de ping-pong");
        // Permet la fermeture de la fenetre par clic sur la
        // petite croix dans le coin.
        monCadre.setDefaultCloseOperation(
                WindowConstants.EXIT_ON_CLOSE);
        TableVertePingPong table = new TableVertePingPong();
        table.ajouteAuCadre(monCadre.getContentPane());
        // Affecte sa taille au cadre et le rend visible.
        monCadre.pack();
        monCadre.setVisible(true);
    }
}

MoteurJeuPingPong

Cacher/Afficher le codeSélectionnez

package exercice1;

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;

public class MoteurJeuPingPong implements
MouseListener, MouseMotionListener, ConstantesDuJeu {
    TableVertePingPong table;
    public int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
    // Constructeur. Stocke une reference a la table.
    public MoteurJeuPingPong(TableVertePingPong tableVerte) {
        table = tableVerte;
    }
    // Methodes requises par l'interface MouseListener.
    public void mousePressed(MouseEvent evenement) {
        // Recupere les coordonnees X et Y du pointeur de la
        // souris et les affecte au "point blanc" sur la table.
        table.affecteCoordonneesPoint(evenement.getX(), evenement.getY());
        // La methode repaint appelle en interne la methode
        // paintComponent() de la table qui rafraîchit la
        // fenetre.
        table.repaint();
    }
    public void mouseReleased(MouseEvent evenement) {}
    public void mouseEntered(MouseEvent evenement) {}
    public void mouseExited(MouseEvent evenement) {}
    public void mouseClicked(MouseEvent evenement) {}
    // Methodes requises par l'interface MouseMotionListener.
    public void mouseDragged(MouseEvent evenement) {}
    public void mouseMoved(MouseEvent evenement) {
        int souris_Y = evenement.getY();
        // Si la souris est au-dessus de la raquette de l'enfant
        // et que la raquette n'a pas depasse la limite
        // superieure de la table, la deplace vers le haut ;
        // sinon, la deplace vers le bas.
        if (souris_Y < raquetteEnfant_Y
                && raquetteEnfant_Y > HAUT_TABLE) {
            raquetteEnfant_Y -= INCREMENT_RAQUETTE;
        } else if (raquetteEnfant_Y < BAS_TABLE) {
            raquetteEnfant_Y += INCREMENT_RAQUETTE;
        }
        // Affecte la nouvelle position de la raquette dans la
        // classe table
        table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
        table.repaint();
    }
}

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

Cacher/Afficher le codeSélectionnez

package support_travail_exercice_2;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.BoxLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.WindowConstants;
/**
 * Cette classe dessine la table de ping-pong, la balle et
 * les raquettes et affiche le score
 */
public class TableVertePingPong extends JPanel
implements ConstantesDuJeu {
    private JLabel label;
    private int raquetteOrdinateur_Y =
            RAQUETTE_ORDINATEUR_Y_DEPART;
    private int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
    private int balle_X = BALLE_X_DEPART;
    private int balle_Y = BALLE_Y_DEPART;
    Dimension taillePreferee = new
            Dimension(LARGEUR_TABLE, HAUTEUR_TABLE);
    // Cette methode affecte sa taille au cadre.
    // Elle est appelee par Java.
    public Dimension getPreferredSize() {
        return taillePreferee;
    }
    // Constructeur. Cree un recepteur d'evenements souris.
    TableVertePingPong() {
        MoteurJeuPingPong moteurJeu =
                new MoteurJeuPingPong(this);
        // Reçoit les mouvements de la souris pour deplacer la
        // raquette.
        addMouseMotionListener(moteurJeu);
        // Reçoit les evenements clavier.
        addKeyListener(moteurJeu);
    }
    //Ajoute a un cadre la table et un JLabel
    void ajouteAuCadre(Container conteneur) {
        conteneur.setLayout(new BoxLayout(conteneur,
                BoxLayout.Y_AXIS));
        conteneur.add(this);
        label = new JLabel(
                "Taper N pour une nouvelle partie, S pour servir" +
                " ou Q pour quitter");
        conteneur.add(label);
    }
    //Repeint la fenetre. Cette methode est appelee par Java
    //quand il est necessaire de rafraîchir l'ecran ou quand
    //la methode repaint() est appelee.
    public void paintComponent(Graphics contexteGraphique) {
        super.paintComponent(contexteGraphique);
        //Dessine la table verte
        contexteGraphique.setColor(Color.GREEN);
        contexteGraphique.fillRect(
                0, 0, LARGEUR_TABLE, HAUTEUR_TABLE);
        //Dessine la raquette droite
        contexteGraphique.setColor(Color.yellow);
        contexteGraphique.fillRect(
                RAQUETTE_ENFANT_X,
                raquetteEnfant_Y,
                LARGEUR_RAQUETTE, LONGUEUR_RAQUETTE);
        //Dessine la raquette gauche
        contexteGraphique.setColor(Color.blue);
        contexteGraphique.fillRect(RAQUETTE_ORDINATEUR_X,
                raquetteOrdinateur_Y,
                LARGEUR_RAQUETTE, LONGUEUR_RAQUETTE);
        //Dessine la balle
        contexteGraphique.setColor(Color.red);
        contexteGraphique.fillOval(balle_X, balle_Y, 10, 10);
        //Dessine les lignes blanches
        contexteGraphique.setColor(Color.white);
        contexteGraphique.drawRect(10, 10, 300, 200);
        contexteGraphique.drawLine(160, 10, 160, 210);
        //Donne le focus a la table, afin que le recepteur de
        //touches envoie les commandes a la table
        requestFocus();
    }
    //Affecte sa position courante a la raquette de l'enfant
    public void positionnerRaquetteEnfant_Y(int y) {
        this.raquetteEnfant_Y = y;
        repaint();
    }
    //Retourne la position courante de la raquette de l'enfant
    public int coordonneeRaquetteEnfant_Y() {
        return raquetteEnfant_Y;
    }
    //Affecte sa position courante a la raquette de
    //l'ordinateur
    public void positionnerRaquetteOrdinateur_Y(int y) {
        this.raquetteOrdinateur_Y = y;
        repaint();
    }
    //Affecte le texte du message du jeu
    public void affecterTexteMessage(String texte) {
        label.setText(texte);
        repaint();
    }
    //Positionne la balle
    public void positionnerBalle(int x, int y) {
        balle_X = x;
        balle_Y = y;
        repaint();
    }
    public static void main(String[] args) {
        //Cree une instance du cadre
        JFrame monCadre = new JFrame("Table verte de ping-pong");
        //Permet la fermeture de la fenetre par clic sur la
        //petite croix dans le coin.
        monCadre.setDefaultCloseOperation(
                WindowConstants.EXIT_ON_CLOSE);
        TableVertePingPong table = new TableVertePingPong();
        table.ajouteAuCadre(monCadre.getContentPane());
        //Affecte sa taille au cadre et le rend visible.
        monCadre.setBounds(0, 0, LARGEUR_TABLE + 5,
                HAUTEUR_TABLE + 40);
        monCadre.setVisible(true);
    }
}

MoteurJeuPingPong

Cacher/Afficher le codeSélectionnez

package support_travail_exercice_2;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
/**
 * Cette classe est un recepteur de souris et de clavier.
 * Elle calcule les deplacements de la balle et des raquettes
 * et change leurs coordonnees.
 */
public class MoteurJeuPingPong implements Runnable,
MouseMotionListener, KeyListener, ConstantesDuJeu {
    private TableVertePingPong table; // Reference à la table.
    private int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
    private int raquetteOrdinateur_Y =
            RAQUETTE_ORDINATEUR_Y_DEPART;
    private int scoreEnfant;
    private int scoreOrdinateur;
    private int balle_X; // position X de la balle
    private int balle_Y; // position Y de la balle
    private boolean deplacementGauche = true;
    private boolean balleServie = false;
    //Valeur en pixels du deplacement vertical de la balle.
    private int deplacementVertical;
    // Constructeur. Stocke une reference à la table.
    public MoteurJeuPingPong(TableVertePingPong tableVerte) {
        table = tableVerte;
        Thread travailleur = new Thread(this);
        travailleur.start();
    }
    // Methodes requises par l'interface MouseMotionListener
    // (certaines sont vides, mais doivent etre incluses dans
    // la classe de toute façon).
    public void mouseDragged(MouseEvent evenement) {
    }
    public void mouseMoved(MouseEvent evenement) {
        int souris_Y = evenement.getY();
        //        Si la souris est au-dessus de la raquette de l'enfant
        //        et que la raquette n'a pas depasse le haut de la
        //        table, la deplace vers le haut ;
        //        sinon, la deplace vers le bas.
        if (souris_Y < raquetteEnfant_Y &&
                raquetteEnfant_Y > HAUT_TABLE) {
            raquetteEnfant_Y -= INCREMENT_RAQUETTE;
        } else if (raquetteEnfant_Y < BAS_TABLE) {
            raquetteEnfant_Y += INCREMENT_RAQUETTE;
        }
        // Affecte la nouvelle position de la raquette
        table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
    }
    // Methodes requises par l'interface KeyListener.
    public void keyPressed(KeyEvent evenement) {
        char touche = evenement.getKeyChar();
        if ('n' == touche || 'N' == touche) {
            demarrerNouvellePartie();
        } else if ('q' == touche || 'Q' == touche) {
            terminerJeu();
        } else if ('s' == touche || 'S' == touche) {
            serviceEnfant();
        }
    }
    public void keyReleased(KeyEvent evenement) {}
    public void keyTyped(KeyEvent evenement) {}
    // Demarre une nouvelle partie.
    public void demarrerNouvellePartie() {
        scoreOrdinateur = 0;
        scoreEnfant = 0;
        table.affecterTexteMessage("Scores - Ordinateur : 0"
                + "Enfant : 0");
        serviceEnfant();
    }
    // Termine le jeu.
    public void terminerJeu(){
        System.exit(0);
    }
    //La methode run() est requise par l'interface Runnable.
    public void run() {
        boolean rebondPossible = false;
        while (true) {
            if (balleServie) { // Si la balle est en mouvement
                //Etape 1. La balle se deplace-t-elle vers la
                //gauche ?
                if (deplacementGauche && balle_X > BALLE_X_MIN) {
                    rebondPossible = (balle_Y >= raquetteOrdinateur_Y
                            && balle_Y < (raquetteOrdinateur_Y +
                                    LONGUEUR_RAQUETTE) ? true : false);
                    balle_X -= INCREMENT_BALLE;
                    //Ajoute un deplacement vertical à chaque
                    //mouvement horizontal de la balle.
                    balle_Y -= deplacementVertical;
                    table.positionnerBalle(balle_X, balle_Y);
                    //La balle peut-elle rebondir ?
                    if (balle_X <= RAQUETTE_ORDINATEUR_X
                            && rebondPossible) {
                        deplacementGauche = false;
                    }
                }
                //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;
                    }
                }
                //Etape 3. Deplace la raquette de l'ordinateur vers le
                // haut ou vers le bas pour bloquer la balle.
                if (raquetteOrdinateur_Y < balle_Y
                        && raquetteOrdinateur_Y < BAS_TABLE) {
                    raquetteOrdinateur_Y += INCREMENT_RAQUETTE;
                } else if (raquetteOrdinateur_Y > HAUT_TABLE) {
                    raquetteOrdinateur_Y -= INCREMENT_RAQUETTE;
                }
                table.positionnerRaquetteOrdinateur_Y(
                        raquetteOrdinateur_Y);
                // Etape 4. Sommeiller un peu
                try {
                    Thread.sleep(DUREE_SOMMEIL);
                } catch (InterruptedException exception) {
                    exception.printStackTrace();
                }
                // Etape 5. Mettre le score à jour si la balle est
                // dans la surface verte mais ne bouge plus.
                if (balleSurLaTable()) {
                    if (balle_X > BALLE_X_MAX ) {
                        scoreOrdinateur++;
                        afficherScore();
                    } else if (balle_X < BALLE_X_MIN) {
                        scoreEnfant++;
                        afficherScore();
                    }
                }
            } // Fin du if balleServie
        } // Fin du while
    }// Fin de run()
    // Sert depuis la position courante de la raquette
    // de l'enfant.
    private void serviceEnfant() {
        balleServie = true;
        balle_X = RAQUETTE_ENFANT_X - 1;
        balle_Y = raquetteEnfant_Y;
        if (balle_Y > HAUTEUR_TABLE / 2) {
            deplacementVertical = -1;
        } else {
            deplacementVertical = 1;
        }
        table.positionnerBalle(balle_X, balle_Y);
        table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
    }
    private void afficherScore() {
        balleServie = false;
        if (scoreOrdinateur == SCORE_GAGNANT) {
            table.affecterTexteMessage("L'ordinateur a gagne ! " +
                    scoreOrdinateur +
                    " : " + scoreEnfant);
        } else if (scoreEnfant == SCORE_GAGNANT) {
            table.affecterTexteMessage ("Tu as gagne ! "+
                    scoreEnfant +
                    " : " + scoreOrdinateur);
        } else {
            table.affecterTexteMessage ("Ordinateur : "+
                    scoreOrdinateur +
                    " Enfant: " + scoreEnfant);
        }
    }
    // Verifie que la balle n'a pas depasse la limite
    // inferieure ou superieure de la table.
    private boolean balleSurLaTable() {
        if (balle_Y >= BALLE_Y_MIN && balle_Y <= BALLE_Y_MAX) {
            return true;
        } else {
            return false;
        }
    }

}

ConstantesDuJeu

Cacher/Afficher le codeSélectionnez

package support_travail_exercice_2;
/**
 * Cette interface contient toutes les définitions des
 * variables invariantes utilisées dans le jeu.
 */
public interface ConstantesDuJeu {
    // Taille de la table de ping-pong
    public final int LARGEUR_TABLE = 320;
    public final int HAUTEUR_TABLE = 220;
    public final int HAUT_TABLE = 12;
    public final int BAS_TABLE = 180;
    // Incrément du mouvement de la balle en pixels
    public final int INCREMENT_BALLE = 4;
    // Coordonnées maximum et minimum permises pour la balle
    public final int BALLE_X_MIN = 1 + INCREMENT_BALLE;
    public final int BALLE_Y_MIN = 1 + INCREMENT_BALLE;
    public final int BALLE_X_MAX =
            LARGEUR_TABLE - INCREMENT_BALLE;
    public final int BALLE_Y_MAX =
            HAUTEUR_TABLE - INCREMENT_BALLE;
    // Position de départ de la balle
    public final int BALLE_X_DEPART = LARGEUR_TABLE / 2;
    public final int BALLE_Y_DEPART = HAUTEUR_TABLE / 2;
    // Taille, positions et incrément des raquettes
    public final int RAQUETTE_ENFANT_X = 300;
    public final int RAQUETTE_ENFANT_Y_DEPART = 100;
    public final int RAQUETTE_ORDINATEUR_X = 15;
    public final int RAQUETTE_ORDINATEUR_Y_DEPART = 100;
    public final int INCREMENT_RAQUETTE = 2;
    public final int LONGUEUR_RAQUETTE = 30;
    public final int LARGEUR_RAQUETTE = 5;
    public final int SCORE_GAGNANT = 21;
    // Ralentit mes ordinateurs rapides ;
    // modifier la valeur si nécessaire.
    public final int DUREE_SOMMEIL = 10; // En millisecondes.
}

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é

Cacher/Afficher le codeSélectionnez

package exercice2;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
/**
 * Cette classe est un recepteur de souris et de clavier.
 * Elle calcule les deplacements de la balle et des raquettes
 * et change leurs coordonnees.
 */
public class MoteurJeuPingPong implements Runnable,
MouseMotionListener, KeyListener, ConstantesDuJeu {
    private TableVertePingPong table; // Reference a la table.
    private int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
    private int raquetteOrdinateur_Y =
            RAQUETTE_ORDINATEUR_Y_DEPART;
    private int scoreEnfant;
    private int scoreOrdinateur;
    private int balle_X; // position X de la balle
    private int balle_Y; // position Y de la balle
    private boolean deplacementGauche = true;
    private boolean balleServie = false;
    //Valeur en pixels du deplacement vertical de la balle.
    private int deplacementVertical;
    // Constructeur. Stocke une reference a la table.
    public MoteurJeuPingPong(TableVertePingPong tableVerte) {
        table = tableVerte;
        Thread travailleur = new Thread(this);
        travailleur.start();
    }
    // Methodes requises par l'interface MouseMotionListener
    // (certaines sont vides, mais doivent etre incluses dans
    // la classe de toute façon).
    public void mouseDragged(MouseEvent evenement) {
    }

    public void mouseMoved(MouseEvent evenement) {
        int souris_Y = evenement.getY();
        // Si la souris est au-dessus de la raquette de l'enfant
        // et que la raquette n'a pas depasse le haut de la
        // table, la deplace vers le haut ;
        // sinon, la deplace vers le bas.
        if (souris_Y < raquetteEnfant_Y &&
                raquetteEnfant_Y > HAUT_TABLE) {
            raquetteEnfant_Y -= INCREMENT_RAQUETTE;
        } else if (raquetteEnfant_Y < BAS_TABLE) {
            raquetteEnfant_Y += INCREMENT_RAQUETTE;
        }
        // Affecte la nouvelle position de la raquette
        table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
    }
    // Methodes requises par l'interface KeyListener.
    public void keyPressed(KeyEvent evenement) {
        char touche = evenement.getKeyChar();
        if ('n' == touche || 'N' == touche) {
            demarrerNouvellePartie();
        } else if ('q' == touche || 'Q' == touche) {
            terminerJeu();
        } else if ('s' == touche || 'S' == touche) {
            if (scoreEnfant < SCORE_GAGNANT && scoreOrdinateur < SCORE_GAGNANT){
                serviceEnfant();
            }
        }
    }
    public void keyReleased(KeyEvent evenement) {}
    public void keyTyped(KeyEvent evenement) {}
    // Demarre une nouvelle partie.
    public void demarrerNouvellePartie() {
        scoreOrdinateur = 0;
        scoreEnfant = 0;
        table.affecterTexteMessage("Scores - Ordinateur : 0"
                + " Enfant : 0");
        serviceEnfant();
    }
    // Termine le jeu.
    public void terminerJeu(){
        System.exit(0);
    }

    // La methode run() est requise par l'interface Runnable.
    public void run() {
        boolean rebondPossible = false;
        while (true) {
            // Etape 4. Sommeiller un peu
            try {
                Thread.sleep(DUREE_SOMMEIL);
            } catch (InterruptedException exception) {
                exception.printStackTrace();
            }
            if (balleServie) { // Si la balle est en mouvement
                // Etape 1. La balle se deplace-t-elle vers la
                // gauche ?
                if (deplacementGauche && balle_X > BALLE_X_MIN) {
                    rebondPossible = (balle_Y >= raquetteOrdinateur_Y
                            && balle_Y < (raquetteOrdinateur_Y +
                                    LONGUEUR_RAQUETTE) ? true : false);
                    balle_X -= INCREMENT_BALLE;
                    // Ajoute un deplacement vertical a chaque
                    // mouvement horizontal de la balle.
                    balle_Y -= deplacementVertical;
                    table.positionnerBalle(balle_X, balle_Y);
                    // La balle peut-elle rebondir ?
                    if (balle_X <= RAQUETTE_ORDINATEUR_X
                            && rebondPossible) {
                        deplacementGauche = false;
                    }
                }
                // 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;
                    }
                }
                // Etape 3. Deplace la raquette de l'ordinateur vers le
                //     haut ou vers le bas pour bloquer la balle.

                if (raquetteOrdinateur_Y < balle_Y
                        && raquetteOrdinateur_Y < BAS_TABLE) {
                    raquetteOrdinateur_Y += INCREMENT_RAQUETTE;
                } else if (raquetteOrdinateur_Y > HAUT_TABLE) {
                    raquetteOrdinateur_Y -= INCREMENT_RAQUETTE;
                }
                table.positionnerRaquetteOrdinateur_Y(
                        raquetteOrdinateur_Y);
                
                // Etape 5. Mettre le score a jour si la balle est
                // dans la surface verte mais ne bouge plus.
                if (balleSurLaTable()) {
                    if (balle_X > BALLE_X_MAX ) {
                        scoreOrdinateur++;
                        afficherScore();
                    } else if (balle_X < BALLE_X_MIN) {
                        scoreEnfant++;
                        afficherScore();
                    }
                }
            } // Fin du if balleServie
        } // Fin du while
    }// Fin de run()
    // Sert depuis la position courante de la raquette
    // de l'enfant.
    private void serviceEnfant() {
        balleServie = true;
        balle_X = RAQUETTE_ENFANT_X - 1;
        balle_Y = raquetteEnfant_Y;
        if (balle_Y > HAUTEUR_TABLE / 2) {
            deplacementVertical = -1;
        } else {
            deplacementVertical = 1;
        }
        table.positionnerBalle(balle_X, balle_Y);
        table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
    }

    private void afficherScore() {
        balleServie = false;
        if (scoreOrdinateur == SCORE_GAGNANT) {
            table.affecterTexteMessage("L'ordinateur a gagne ! " +
                    scoreOrdinateur +
                    " : " + scoreEnfant);
        } else if (scoreEnfant == SCORE_GAGNANT) {
            table.affecterTexteMessage ("Tu as gagne ! "+
                    scoreEnfant +
                    " : " + scoreOrdinateur);
        } else {
            table.affecterTexteMessage ("Ordinateur : "+
                    scoreOrdinateur +
                    " Enfant : " + scoreEnfant);
        }
    }
    // Verifie que la balle n'a pas depasse la limite
    // inferieure ou superieure de la table.
    private boolean balleSurLaTable() {
        if (balle_Y >= BALLE_Y_MIN && balle_Y <= BALLE_Y_MAX) {
            return true;
        } else {
            return false;
        }

    }
}

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

Cacher/Afficher le codeSélectionnez

package ex_malins_1;
/**
 * Cette interface contient toutes les definitions des
 * variables invariantes utilisees dans le jeu.
 */
public interface ConstantesDuJeu {
    // Taille de la table de ping-pong
    public final int LARGEUR_TABLE = 320;
    public final int HAUTEUR_TABLE = 260;
    public final int HAUT_TABLE = 12;
    public final int BAS_TABLE = 180;
    // Increment du mouvement de la balle en pixels
    public final int INCREMENT_BALLE = 4;
    // Coordonnees maximum et minimum permises pour la balle
    public final int BALLE_X_MIN = 1 + INCREMENT_BALLE;
    public final int BALLE_Y_MIN = 1 + INCREMENT_BALLE;
    public final int BALLE_X_MAX =
            LARGEUR_TABLE - INCREMENT_BALLE;
    public final int BALLE_Y_MAX =
            HAUTEUR_TABLE - INCREMENT_BALLE;
    // Position de depart de la balle
    public final int BALLE_X_DEPART = LARGEUR_TABLE / 2;
    public final int BALLE_Y_DEPART = HAUTEUR_TABLE / 2;
    // Taille, positions et increment des raquettes
    public final int RAQUETTE_ENFANT_X = 300;
    public final int RAQUETTE_ENFANT_Y_DEPART = 100;
    public final int RAQUETTE_ORDINATEUR_X = 15;
    public final int RAQUETTE_ORDINATEUR_Y_DEPART = 100;
    public final int INCREMENT_RAQUETTE = 2;
    public final int LONGUEUR_RAQUETTE = 30;
    public final int LARGEUR_RAQUETTE = 5;
    public final int SCORE_GAGNANT = 21;
    // Ralentit mes ordinateurs rapides ;
    // modifier la valeur si necessaire.
    public final int DUREE_SOMMEIL = 10; // En millisecondes.
    // Valeurs minimale et maximale pour le niveau
    public final int NIVEAU_MIN = 1;
    public final int NIVEAU_MAX = 10;
}

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

Cacher/Afficher le codeSélectionnez

package ex_malins_1;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import javax.swing.BoxLayout;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.WindowConstants;
/**
 * Cette classe dessine la table de ping-pong, la balle et
 * les raquettes et affiche le score
 */
public class TableVertePingPong extends JPanel
implements ConstantesDuJeu, ItemListener {
    private MoteurJeuPingPong moteurJeu;
    private JLabel label;
    private int raquetteOrdinateur_Y =
            RAQUETTE_ORDINATEUR_Y_DEPART;
    private int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
    private int balle_X = BALLE_X_DEPART;
    private int balle_Y = BALLE_Y_DEPART;
    Dimension taillePreferee = new
            Dimension(LARGEUR_TABLE, HAUTEUR_TABLE);
    // Cette methode affecte sa taille au cadre.
    // Elle est appelee par Java.
    public Dimension getPreferredSize() {
        return taillePreferee;
    }
    // Constructeur. Cree un recepteur d'evenements souris.
    TableVertePingPong() {
        moteurJeu =
                new MoteurJeuPingPong(this);
        // Reçoit les mouvements de la souris pour deplacer la
        // raquette.
        addMouseMotionListener(moteurJeu);
        // Reçoit les evenements clavier.
        addKeyListener(moteurJeu);
    }
    // Ajoute a un cadre la table, un JLabel,
    // et un ensemble JLabel + JComboBox
    void ajouteAuCadre(Container conteneur) {
        conteneur.setLayout(new BoxLayout(conteneur,
                BoxLayout.Y_AXIS));
        conteneur.add(this);
        label = new JLabel(
                "Taper N pour une nouvelle partie, S pour servir" +
                " ou Q pour quitter");
        conteneur.add(label);
        
        JPanel panneauChoixNiveau = new JPanel();
        panneauChoixNiveau.setLayout(new FlowLayout());
        panneauChoixNiveau.add(new JLabel("Niveau"));
        JComboBox controleNiveaux = new JComboBox();
        int i;
        for(i = NIVEAU_MIN; i <= NIVEAU_MAX; i++){
            controleNiveaux.addItem(String.valueOf(i));
        }
        controleNiveaux.addItemListener(this);
        panneauChoixNiveau.add(controleNiveaux);
        conteneur.add(panneauChoixNiveau);
    }
    // Repeint la fenetre. Cette methode est appelee par Java
    // quand il est necessaire de rafraîchir l'ecran ou quand
    // la methode repaint() est appelee.
    public void paintComponent(Graphics contexteGraphique) {
        super.paintComponent(contexteGraphique);
        // Dessine la table verte
        contexteGraphique.setColor(Color.GREEN);
        contexteGraphique.fillRect(
                0, 0, LARGEUR_TABLE, HAUTEUR_TABLE);
        // Dessine la raquette droite
        contexteGraphique.setColor(Color.yellow);
        contexteGraphique.fillRect(
                RAQUETTE_ENFANT_X,
                raquetteEnfant_Y,
                LARGEUR_RAQUETTE, LONGUEUR_RAQUETTE);
        // Dessine la raquette gauche
        contexteGraphique.setColor(Color.blue);
        contexteGraphique.fillRect(RAQUETTE_ORDINATEUR_X,
                raquetteOrdinateur_Y,
                LARGEUR_RAQUETTE, LONGUEUR_RAQUETTE);
        // Dessine la balle
        contexteGraphique.setColor(Color.red);
        contexteGraphique.fillOval(balle_X, balle_Y, 10, 10);
        // Dessine les lignes blanches
        contexteGraphique.setColor(Color.white);
        contexteGraphique.drawRect(10, 10, 300, 200);
        contexteGraphique.drawLine(160, 10, 160, 210);
        // Donne le focus a la table, afin que le recepteur de
        // touches envoie les commandes a la table
        requestFocus();
    }
    // Affecte sa position courante a la raquette de l'enfant
    public void positionnerRaquetteEnfant_Y(int y) {
        this.raquetteEnfant_Y = y;
        repaint();
    }
    // Retourne la position courante de la raquette de l'enfant
    public int coordonneeRaquetteEnfant_Y() {
        return raquetteEnfant_Y;
    }
    // Affecte sa position courante a la raquette de
    // l'ordinateur
    public void positionnerRaquetteOrdinateur_Y(int y) {
        this.raquetteOrdinateur_Y = y;
        repaint();
    }
    // Affecte le texte du message du jeu
    public void affecterTexteMessage(String texte) {
        label.setText(texte);
        repaint();
    }
    // Positionne la balle
    public void positionnerBalle(int x, int y) {
        balle_X = x;
        balle_Y = y;
        repaint();
    }
    public static void main(String[] args) {
        // Cree une instance du cadre
        JFrame monCadre = new JFrame("Table verte de ping-pong");
        // Permet la fermeture de la fenetre par clic sur la
        // petite croix dans le coin.
        monCadre.setDefaultCloseOperation(
                WindowConstants.EXIT_ON_CLOSE);
        TableVertePingPong table = new TableVertePingPong();
        table.ajouteAuCadre(monCadre.getContentPane());
        // Affecte sa taille au cadre et le rend visible.
        monCadre.setBounds(0, 0, LARGEUR_TABLE + 5,
                HAUTEUR_TABLE + 40);
        monCadre.setVisible(true);
    }
    public void itemStateChanged(ItemEvent event) {
        if (event.getStateChange() == ItemEvent.SELECTED) {
            String niveauChoisi = (String) event.getItem();
            moteurJeu.fixerNiveauDeJeu(Integer.valueOf(niveauChoisi));
        }
    }
}

Voici la nouvelle version de MoteurJeuPingPong.java :

MoteurJeuPingPong

Cacher/Afficher le codeSélectionnez

package ex_malins_1;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
/**
 * Cette classe est un recepteur de souris et de clavier.
 * Elle calcule les deplacements de la balle et des raquettes
 * et change leurs coordonnees.
 */
public class MoteurJeuPingPong implements Runnable,
MouseMotionListener, KeyListener, ConstantesDuJeu {
    private TableVertePingPong table; // Reference a la table.
    private int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
    private int raquetteOrdinateur_Y =
            RAQUETTE_ORDINATEUR_Y_DEPART;
    private int scoreEnfant;
    private int scoreOrdinateur;
    private int balle_X; // position X de la balle
    private int balle_Y; // position Y de la balle
    private boolean deplacementGauche = true;
    private boolean balleServie = false;
    //Valeur en pixels du deplacement vertical de la balle.
    private int deplacementVertical;
    // Niveau de jeu : vaudra entre 1 et 10
    private int niveauDeJeu = 10;
    // Constructeur. Stocke une reference a la table.
    public MoteurJeuPingPong(TableVertePingPong tableVerte) {
        table = tableVerte;
        Thread travailleur = new Thread(this);
        travailleur.start();
    }
    // Methodes requises par l'interface MouseMotionListener
    // (certaines sont vides, mais doivent etre incluses dans
    // la classe de toute façon).
    public void mouseDragged(MouseEvent evenement) {
    }

    public void mouseMoved(MouseEvent evenement) {
        int souris_Y = evenement.getY();
        // Si la souris est au-dessus de la raquette de l'enfant
        // et que la raquette n'a pas depasse le haut de la
        // table, la deplace vers le haut ;
        // sinon, la deplace vers le bas.
        if (souris_Y < raquetteEnfant_Y &&
                raquetteEnfant_Y > HAUT_TABLE) {
            raquetteEnfant_Y -= INCREMENT_RAQUETTE + 20 - 2*niveauDeJeu;
        } else if (raquetteEnfant_Y < BAS_TABLE) {
            raquetteEnfant_Y += INCREMENT_RAQUETTE + 20 - 2*niveauDeJeu;
        }
        // Affecte la nouvelle position de la raquette
        table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
    }
    // Methodes requises par l'interface KeyListener.
    public void keyPressed(KeyEvent evenement) {
        char touche = evenement.getKeyChar();
        if ('n' == touche || 'N' == touche) {
            demarrerNouvellePartie();
        } else if ('q' == touche || 'Q' == touche) {
            terminerJeu();
        } else if ('s' == touche || 'S' == touche) {
            if (scoreEnfant < SCORE_GAGNANT && scoreOrdinateur < SCORE_GAGNANT){
                serviceEnfant();
            }
        }
    }
    public void keyReleased(KeyEvent evenement) {}
    public void keyTyped(KeyEvent evenement) {}
    // Demarre une nouvelle partie.
    public void demarrerNouvellePartie() {
        scoreOrdinateur = 0;
        scoreEnfant = 0;
        table.affecterTexteMessage("Scores - Ordinateur : 0"
                + " Enfant : 0");
        serviceEnfant();
    }
    // Termine le jeu.
    public void terminerJeu(){
        System.exit(0);
    }

    // La methode run() est requise par l'interface Runnable.
    public void run() {
        boolean rebondPossible = false;
        while (true) {
            // Etape 4. Sommeiller un peu
            try {
                Thread.sleep(DUREE_SOMMEIL);
            } catch (InterruptedException exception) {
                exception.printStackTrace();
            }
            if (balleServie) { // Si la balle est en mouvement
                // Etape 1. La balle se deplace-t-elle vers la
                // gauche ?
                if (deplacementGauche && balle_X > BALLE_X_MIN) {
                    rebondPossible = (balle_Y >= raquetteOrdinateur_Y
                            && balle_Y < (raquetteOrdinateur_Y +
                                    LONGUEUR_RAQUETTE) ? true : false);
                    balle_X -= INCREMENT_BALLE;
                    // Ajoute un deplacement vertical a chaque
                    // mouvement horizontal de la balle.
                    balle_Y -= deplacementVertical;
                    table.positionnerBalle(balle_X, balle_Y);
                    // La balle peut-elle rebondir ?
                    if (balle_X <= RAQUETTE_ORDINATEUR_X
                            && rebondPossible) {
                        deplacementGauche = false;
                    }
                }
                // 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;
                    }
                }
                // Etape 3. Deplace la raquette de l'ordinateur vers le
                //     haut ou vers le bas pour bloquer la balle.

                if (raquetteOrdinateur_Y < balle_Y
                        && raquetteOrdinateur_Y < BAS_TABLE) {
                    raquetteOrdinateur_Y += INCREMENT_RAQUETTE;
                } else if (raquetteOrdinateur_Y > HAUT_TABLE) {
                    raquetteOrdinateur_Y -= INCREMENT_RAQUETTE;
                }
                table.positionnerRaquetteOrdinateur_Y(
                        raquetteOrdinateur_Y);
                // Etape 5. Mettre le score a jour si la balle est
                // dans la surface verte mais ne bouge plus.
                if (balleSurLaTable()) {
                    if (balle_X > BALLE_X_MAX ) {
                        scoreOrdinateur++;
                        afficherScore();
                    } else if (balle_X < BALLE_X_MIN) {
                        scoreEnfant++;
                        afficherScore();
                    }
                }
            } // Fin du if balleServie
        } // Fin du while
    }// Fin de run()
    
    public void fixerNiveauDeJeu(int niveauDeJeu){
        /*
         * On s'assure que le niveau de jeu
         * reste compris entre 1 et 10
         */
        niveauDeJeu = niveauDeJeu < 1 ? 1 : niveauDeJeu;
        niveauDeJeu = niveauDeJeu > 10 ? 10 : niveauDeJeu;
        
        /*
         * Ici, on doit utiliser le
         * mot clé this pour distinguer la variable locale
         * et la variable de classe.
         */
        this.niveauDeJeu = niveauDeJeu;
    }
    
    
    // Sert depuis la position courante de la raquette
    // de l'enfant.
    private void serviceEnfant() {
        balleServie = true;
        balle_X = RAQUETTE_ENFANT_X - 1;
        balle_Y = raquetteEnfant_Y;
        if (balle_Y > HAUTEUR_TABLE / 2) {
            deplacementVertical = -1;
        } else {
            deplacementVertical = 1;
        }
        table.positionnerBalle(balle_X, balle_Y);
        table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
    }

    private void afficherScore() {
        balleServie = false;
        if (scoreOrdinateur == SCORE_GAGNANT) {
            table.affecterTexteMessage("L'ordinateur a gagne ! " +
                    scoreOrdinateur +
                    " : " + scoreEnfant);
        } else if (scoreEnfant == SCORE_GAGNANT) {
            table.affecterTexteMessage ("Tu as gagne ! "+
                    scoreEnfant +
                    " : " + scoreOrdinateur);
        } else {
            table.affecterTexteMessage ("Ordinateur : "+
                    scoreOrdinateur +
                    " Enfant : " + scoreEnfant);
        }
    }
    // Verifie que la balle n'a pas depasse la limite
    // inferieure ou superieure de la table.
    private boolean balleSurLaTable() {
        if (balle_Y >= BALLE_Y_MIN && balle_Y <= BALLE_Y_MAX) {
            return true;
        } else {
            return false;
        }

    }
}

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

Cacher/Afficher le codeSélectionnez

package ex_malins_2;
/**
 * Cette interface contient toutes les definitions des
 * variables invariantes utilisees dans le jeu.
 */
public interface ConstantesDuJeu {
    // Taille de la table de ping-pong
    public final int LARGEUR_TABLE = 320;
    public final int HAUTEUR_TABLE = 260;
    public final int HAUT_TABLE = 12;
    public final int BAS_TABLE = 180;
    public final int MILIEU_HAUTEUR_TABLE = (BAS_TABLE - HAUT_TABLE) / 2;
    // Increment du mouvement de la balle en pixels
    public final int INCREMENT_BALLE = 4;
    // Coordonnees maximum et minimum permises pour la balle
    public final int BALLE_X_MIN = 1 + INCREMENT_BALLE;
    public final int BALLE_Y_MIN = 1 + INCREMENT_BALLE;
    public final int BALLE_X_MAX =
            LARGEUR_TABLE - INCREMENT_BALLE;
    public final int BALLE_Y_MAX =
            HAUTEUR_TABLE - INCREMENT_BALLE;
    // Position de depart de la balle
    public final int BALLE_X_DEPART = LARGEUR_TABLE / 2;
    public final int BALLE_Y_DEPART = HAUTEUR_TABLE / 2;
    // Taille, positions et increment des raquettes
    public final int RAQUETTE_ENFANT_X = 300;
    public final int RAQUETTE_ENFANT_Y_DEPART = 100;
    public final int RAQUETTE_ORDINATEUR_X = 15;
    public final int RAQUETTE_ORDINATEUR_Y_DEPART = 100;
    public final int INCREMENT_RAQUETTE = 2;
    public final int LONGUEUR_RAQUETTE = 30;
    public final int LARGEUR_RAQUETTE = 5;
    public final int SCORE_GAGNANT = 21;
    // Ralentit mes ordinateurs rapides ;
    // modifier la valeur si necessaire.
    public final int DUREE_SOMMEIL = 10; // En millisecondes.
    // Valeurs minimale et maximale pour le niveau
    public final int NIVEAU_MIN = 1;
    public final int NIVEAU_MAX = 10;
}

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

Cacher/Afficher le codeSélectionnez

package ex_malins_2;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
/**
 * Cette classe est un recepteur de souris et de clavier.
 * Elle calcule les deplacements de la balle et des raquettes
 * et change leurs coordonnees.
 */
public class MoteurJeuPingPong implements Runnable,
MouseMotionListener, KeyListener, ConstantesDuJeu {
    private TableVertePingPong table; // Reference a la table.
    private int raquetteEnfant_Y = RAQUETTE_ENFANT_Y_DEPART;
    private int raquetteOrdinateur_Y =
            RAQUETTE_ORDINATEUR_Y_DEPART;
    private int scoreEnfant;
    private int scoreOrdinateur;
    private int balle_X; // position X de la balle
    private int balle_Y; // position Y de la balle
    private boolean deplacementGauche = true;
    private boolean balleServie = false;
    //Valeur en pixels du deplacement vertical de la balle.
    private int deplacementVertical;
    // Niveau de jeu : vaudra entre 1 et 10
    private int niveauDeJeu = 10;
    // Constructeur. Stocke une reference a la table.
    public MoteurJeuPingPong(TableVertePingPong tableVerte) {
        table = tableVerte;
        Thread travailleur = new Thread(this);
        travailleur.start();
    }
    // Methodes requises par l'interface MouseMotionListener
    // (certaines sont vides, mais doivent etre incluses dans
    // la classe de toute façon).
    public void mouseDragged(MouseEvent evenement) {
    }

    public void mouseMoved(MouseEvent evenement) {
        int souris_Y = evenement.getY();
        // Si la souris est au-dessus de la raquette de l'enfant
        // et que la raquette n'a pas depasse le haut de la
        // table, la deplace vers le haut ;
        // sinon, la deplace vers le bas.
        if (souris_Y < raquetteEnfant_Y &&
                raquetteEnfant_Y > HAUT_TABLE) {
            raquetteEnfant_Y -= INCREMENT_RAQUETTE + 20 - 2*niveauDeJeu;
        } else if (raquetteEnfant_Y < BAS_TABLE) {
            raquetteEnfant_Y += INCREMENT_RAQUETTE + 20 - 2*niveauDeJeu;
        }
        // Affecte la nouvelle position de la raquette
        table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
    }
    // Methodes requises par l'interface KeyListener.
    public void keyPressed(KeyEvent evenement) {
        char touche = evenement.getKeyChar();
        if ('n' == touche || 'N' == touche) {
            demarrerNouvellePartie();
        } else if ('q' == touche || 'Q' == touche) {
            terminerJeu();
        } else if ('s' == touche || 'S' == touche) {
            if (scoreEnfant < SCORE_GAGNANT && scoreOrdinateur < SCORE_GAGNANT){
                serviceEnfant();
            }
        }
    }
    public void keyReleased(KeyEvent evenement) {}
    public void keyTyped(KeyEvent evenement) {}
    // Demarre une nouvelle partie.
    public void demarrerNouvellePartie() {
        scoreOrdinateur = 0;
        scoreEnfant = 0;
        table.affecterTexteMessage("Scores - Ordinateur : 0"
                + " Enfant : 0");
        serviceEnfant();
    }
    // Termine le jeu.
    public void terminerJeu(){
        System.exit(0);
    }

    // La methode run() est requise par l'interface Runnable.
    public void run() {
        boolean rebondPossible = false;
        while (true) {
            // Etape 4. Sommeiller un peu
            try {
                Thread.sleep(DUREE_SOMMEIL);
            } catch (InterruptedException exception) {
                exception.printStackTrace();
            }
            if (balleServie) { // Si la balle est en mouvement
                // Etape 1. La balle se deplace-t-elle vers la
                // gauche ?
                if (deplacementGauche && balle_X > BALLE_X_MIN) {
                    rebondPossible = (balle_Y >= raquetteOrdinateur_Y
                            && balle_Y < (raquetteOrdinateur_Y +
                                    LONGUEUR_RAQUETTE) ? true : false);
                    balle_X -= INCREMENT_BALLE;
                    // Ajoute un deplacement vertical a chaque
                    // mouvement horizontal de la balle.
                    balle_Y -= deplacementVertical;
                    table.positionnerBalle(balle_X, balle_Y);
                    // La balle peut-elle rebondir ?
                    if (balle_X <= RAQUETTE_ORDINATEUR_X
                            && rebondPossible) {
                        deplacementGauche = false;
                    }
                }
                // 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;
                    }
                }
                // Etape 3. Deplace la raquette de l'ordinateur vers le
                //     haut ou vers le bas pour bloquer la balle.

                if (raquetteOrdinateur_Y < balle_Y
                        && raquetteOrdinateur_Y < BAS_TABLE) {
                    raquetteOrdinateur_Y += INCREMENT_RAQUETTE;
                } else if (raquetteOrdinateur_Y > HAUT_TABLE) {
                    raquetteOrdinateur_Y -= INCREMENT_RAQUETTE;
                }
                table.positionnerRaquetteOrdinateur_Y(
                        raquetteOrdinateur_Y);
                // Etape 5. Mettre le score a jour si la balle est
                // dans la surface verte mais ne bouge plus.
                if (balleSurLaTable()) {
                    if (balle_X > BALLE_X_MAX ) {
                        scoreOrdinateur++;
                        afficherScore();
                    } else if (balle_X < BALLE_X_MIN) {
                        scoreEnfant++;
                        afficherScore();
                    }
                }
            } // Fin du if balleServie
        } // Fin du while
    }// Fin de run()
    
    public void fixerNiveauDeJeu(int niveauDeJeu){
        /*
         * On s'assure que le niveau de jeu
         * reste compris entre 1 et 10
         */
        niveauDeJeu = niveauDeJeu < 1 ? 1 : niveauDeJeu;
        niveauDeJeu = niveauDeJeu > 10 ? 10 : niveauDeJeu;
        
        /*
         * Ici, on doit utiliser le
         * mot clé this pour distinguer la variable locale
         * et la variable de classe.
         */
        this.niveauDeJeu = niveauDeJeu;
    }
    
    
    // Sert depuis la position courante de la raquette
    // de l'enfant.
    private void serviceEnfant() {
        balleServie = true;
        balle_X = RAQUETTE_ENFANT_X - 1;
        balle_Y = raquetteEnfant_Y;
        if (raquetteEnfant_Y > HAUTEUR_TABLE / 2) {
            deplacementVertical = +1;
        } else {
            deplacementVertical = -1;
        }
        table.positionnerBalle(balle_X, balle_Y);
        table.positionnerRaquetteEnfant_Y(raquetteEnfant_Y);
    }

    private void afficherScore() {
        balleServie = false;
        if (scoreOrdinateur == SCORE_GAGNANT) {
            table.affecterTexteMessage("L'ordinateur a gagne ! " +
                    scoreOrdinateur +
                    " : " + scoreEnfant);
        } else if (scoreEnfant == SCORE_GAGNANT) {
            table.affecterTexteMessage ("Tu as gagne ! "+
                    scoreEnfant +
                    " : " + scoreOrdinateur);
        } else {
            table.affecterTexteMessage ("Ordinateur : "+
                    scoreOrdinateur +
                    " Enfant : " + scoreEnfant);
        }
    }
    // Verifie que la balle n'a pas depasse la limite
    // inferieure ou superieure de la table.
    private boolean balleSurLaTable() {
        if (balle_Y >= BALLE_Y_MIN && balle_Y <= BALLE_Y_MAX) {
            return true;
        } else {
            return false;
        }

    }
}

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.

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.