Discussion :

[kmtaz]

Bonjour,

Je réalise un jeu avec Java et j'utilise 2 threads, le threads principal pour afficher l'interface de jeu, et le second pour réaliser les traitements (calcul trajectoire balle, déplacement...)
Depuis que j'ai défini les traitements du second thread, le programme ralentie, plus particulièrement lorsque je navigue dans la barre de menu de mon interface et que les différents évènements associés doivent s'éxécuter. Je poste mon code pour voir si quelqu'un pourrait me dire où se trouve mon erreur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
 
    public Moteur_PingPong(Table_PingPong tablePingPong) {
 
        table = tablePingPong;
 
        /* création d'un thread qui va assurer le déroulement du jeu (trajectoire balle, ordi...) */
        Thread jeu = new Thread(this);
        jeu.start();
    }
 
    public void run() {
 
        boolean rebondBalle = false;
 
        while (true) {
 
            /* si la balle est en jeu (en mouvement) */
            if (balle_Service) {
 
                /* si celle-ci se déplace vers la gauche */
                if (deplacement_Gauche && balle_X > BALLE_X_MIN) {
 
                    rebondBalle = (balle_Y >= raquetteOrdi_Y && balle_Y < (raquetteOrdi_Y + LONGUEUR_RAQUETTE)
                            ? true : false);
 
                    /* mise à jour de la position de la balle sur la table */
                    balle_X = balle_X - INCR_BALLE;
                    balle_Y = balle_Y - deplacement_Vertical;
                    table.positionBalle(balle_X, balle_Y);
 
                    /* si la balle rebondie */
                    if (balle_X <= RAQUETTE_ORDI_X && rebondBalle) {
 
                        deplacement_Gauche = false;
                    }
                }
 
                /* si celle-ci se déplace vers la droite */
                if (!deplacement_Gauche && balle_X <= BALLE_X_MAX) {
 
                    rebondBalle = (balle_Y >= raquetteJoueur_Y && balle_Y < (raquetteJoueur_Y + LONGUEUR_RAQUETTE)
                            ? true : false);
 
                    /* mise à jour de la position de la balle sur la table */
                    balle_X = balle_X + INCR_BALLE;
                    table.positionBalle(balle_X, balle_Y);
 
                    /* si la balle rebondie */
                    if (balle_X >= RAQUETTE_X && rebondBalle) {
 
                        deplacement_Gauche = true;
                    }
                }
 
                /* déplacement de la raquette de l'ordinateur pour taper la balle */
                if (raquetteOrdi_Y < balle_Y && raquetteOrdi_Y < BAS_TABLE) {
 
                    /* déplacement vers le haut */
                    raquetteOrdi_Y = raquetteOrdi_Y + INCR_RAQUETTE;
                }
                else if (raquetteOrdi_Y > HAUT_TABLE) {
 
                    /* déplacement vers le bas */
                    raquetteOrdi_Y = raquetteOrdi_Y - INCR_RAQUETTE;
                }
 
                /* mise à jour de la position de la raquette de l'ordinateur */
                table.mouvementRaquetteOrdi(raquetteOrdi_Y);
 
 
                /* ralentissement du thread en cas d'ordinateur puissant où s'exécute le jeu */
                try {
 
                    Thread.sleep(RALENTIE_JEU);
                } catch (InterruptedException exception) {
 
                    exception.printStackTrace();
               }
 
                /* mise à jour du score lors d'un service */
                if (balleEnJeu()) {
 
                    if (balle_X > BALLE_X_MAX) {
 
                        score_Joueur++;
                        affichageScore();
                    }
                    else if (balle_X < BALLE_X_MIN) {
 
                        score_Ordi++;
                        affichageScore();
                    }
                }
            }
        }
    }

Ma classe Main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
/**
     * méthode pour initialiser tous les composants graphique de l'interface
     */
    private void initComposants(){
 
        barreMenu = new JMenuBar();
        fichier = new JMenu();
        nouvellePartie = new JMenuItem();
        quitter = new JMenuItem();
 
        this.setTitle("Jeu de ping-pong");
 
        fichier.setText("Fichier");
        fichier.setMnemonic('F');
        nouvellePartie.setText("Nouvelle Partie");
        quitter.setText("Quitter");
 
        /* raccourci clavier pour l'option "Quitter" (ctrl + n) */
        nouvellePartie.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, KeyEvent.CTRL_MASK));
 
        /* raccourci clavier pour l'option "Quitter" (ctrl + q) */
        quitter.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Q, KeyEvent.CTRL_MASK));
 
 
        /* écouteurs d'évènements sur les options du menu */
        nouvellePartie.addActionListener(this);
        quitter.addActionListener(this);
 
        /* ajout de l'option "Nouvelle Partie" et "Quitter" dans l'onglet "Fichier" */
        fichier.add(nouvellePartie);
        fichier.add(quitter);
 
 
        /* ajout de l'onglet "Fichier" dans la barre de menu de l'interface */
        barreMenu.add(fichier);
 
        /* ajout de la barre de menu à l'interface */
        this.setJMenuBar(barreMenu);
 
 
    }
 
 
    public Main () {
 
 
        initComposants();
 
 
        /* évènements lors de la fermeture de l'application par le croix en haut à droite */
        this.addWindowListener(new WindowAdapter() {
 
 
            /**
            * Méthode appelée lors de la fermeture de l'application
            */
            @Override
            public void windowClosing(WindowEvent e) {
 
                /* Demande de confirmation à l'utilisateur pour quitter l'application */
                infoQuit = new JOptionPane();
                @SuppressWarnings("static-access")
                int choix = infoQuit.showConfirmDialog(null, "Voulez-vous vraiment quitter le jeu ?", "Confirmation", JOptionPane.YES_NO_OPTION);
 
                if (choix == JOptionPane.YES_OPTION) {
 
                   System.exit(0);
                }
                else {
 
                    setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
                }
            }
 
        });
 
         Table_PingPong table = new Table_PingPong();
         table.ajoutInterface(this.getContentPane());
         moteur = new Moteur_PingPong(table);
 
 
        this.pack();
        this.setBounds(0, 0, LARGEUR_TABLE + 90 , HAUTEUR_TABLE + 80);
 
        /* Place au milieu de l'écran la fenêtre d'application */
        this.setLocationRelativeTo(null);
 
        this.setVisible(true);
    }

Merci

[merill]

Il s'agit d'un problème lié à l'implémentation du moteur de jeu.

Actuellement, ton pas de mise à jour n'est pas constant en temps mais en itération. Ton application sera trop rapide sur un gros pc et trop lent sur un petit. Tu doit faire la mise à jour des positions en fonction du temps qui est passé depuis la dernière mise à jour.

quelque chose comme cela

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
long temps_debut = System.getMilisecond();
long temps_fin = temps_debut;
while(true){
  long interval = temps_fin - temps_debut;
  temps_debut = temps_fin;
 
  //mises à jour en fonction de interval
 
  temps_fin = System.getMilisecond();
}

[tchize_]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
            /* si la balle est en jeu (en mouvement) */
            if (balle_Service) {

si balle_Service est à false, jamais tu n'entrera dans ton sleep et le Thread tournera en continu, mangeant le CPU à suivre une boucle vide

[kmtaz]

Bonjour,

Merci pour vos réponses.
Concernant balle_Service, je l'initialise bien a False, mais il sera toujours à true grâce à ma méthode permettant de lancer le jeu par un service.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
/**
     * Méthode permettant au joueur de servir en 1 er dans le jeu
     */
    private void serviceJeu() {
 
        balle_Service = true;
        balle_X = table.place_Raquette - 1;
        balle_Y = raquetteJoueur_Y;
 
        if (balle_Y > table.hauteur_Table / 2) {
 
            deplacement_Vertical = -1;
        }
        else {
 
            deplacement_Vertical = 1;
        }
 
        table.positionBalle(balle_X, balle_Y);
        table.mouvementRaquetteJoueur(raquetteJoueur_Y);
    }

Donc le sleep sera exécuté.

Je n'avais pas pensé à la mise à jour des positions en fonction du temps, je vais essayé merci.

[tchize_]

tout le temps où tu n'a pas encore mis à trus, c'est du temps où le thread mangera le CPU. Fait sortir le sleep du if, pour qu'il soit inconditionnel, au minimum. De plus, comme dans le cas où tu n'a appelé aucune méthode on ne change pas de contexte, il est important que le flag balle_service soit déclaré volatile, pour que la boucle ne cache pas sa valeur dans un registre.

[kmtaz]

Vos conseils ont améliorer l'exécution du jeu, maintenant en modifiant la variable RALENTIE_JEU je vois une réel différence de vitesse de jeu.

Merci