Discussion :

[Salydan]

Bonjour tout le monde.

Il y a quelques jours j'ai eu un projet a faire en Java. Le temps étant limité j'ai choisis de codé un snake.
Tout fonctionne correctement sauf un detail. Je veux ajouter des sons lorsque le serpent mange une pomme. Le soucis est que le serpent se stop durant l'execution du son.
Même si le son n'est pas long ceci est parfois pénible. J'ai donc voulu mettre en place un thread que je lance dans ma méthode "mange". La première fois tout se passe bien mais la seconde fois comme mon premier thread est deja en route une erreur apparait "java.lang.IllegalThreadStateException".
Voici le code de ma classe snake

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.util.LinkedList;
import java.applet.Applet;
import java.applet.AudioClip;
import java.net.URL;
 
public class Snake extends Thread{
 
      private LinkedList<Case> linkList;
      private Direction direction;
      private boolean Mort;
      private Direction nouvelleDirection;
      private int nbMange;
      private int compteurMouvement;
      private URL url = Snake.class.getResource("sons/bruit.wav");
      private Color couleurSerpent = Color.PINK;
      private AudioClip ac = Applet.newAudioClip(url);
 
      public Snake() {
            this.linkList = new LinkedList<Case>();
            this.linkList.add(new Case(14, 15));
            this.linkList.add(new Case(15, 15));
            this.linkList.add(new Case(16, 15));
            this.direction = Direction.VERS_LA_GAUCHE;
      }
 
      Thread thread = new Thread(new Runnable() {
          @Override
          public void run() {
            ac.play();
          }
      });
 
      public Color getCouleur(){
    	  return this.couleurSerpent;
      }
 
      public void setCouleur(Color couleur){
    	  this.couleurSerpent = couleur;
      }
 
      public void setDemandeClavier(Direction demande) {
          this.nouvelleDirection = demande;
      }
 
      private void tourner() {
          if (this.nouvelleDirection != null) { // une touche à été pressée
                // le serpent va vers le haut ou le bas
                if (this.direction == Direction.VERS_LE_HAUT
                            || this.direction == Direction.VERS_LE_BAS) {
                      if (this.nouvelleDirection == Direction.VERS_LA_DROITE) { // la touche droite
                                                                   // à été pressée
                            // le serpent tourne à droite
                            this.direction = Direction.VERS_LA_DROITE;
                      } else if (this.nouvelleDirection == Direction.VERS_LA_GAUCHE) { // la touche
                                                                          // gauche à
                                                                          // été pressée
                            // le serpent tourne à gauche
                            this.direction = Direction.VERS_LA_GAUCHE;
                      }
                } else { // le serpent va vers la droite ou la gauche
                      if (this.nouvelleDirection == Direction.VERS_LE_HAUT) { // la touche haut à
                                                                 // été pressée
                            // le serpent tourne vers le haut
                            this.direction = Direction.VERS_LE_HAUT;
                      } else if (this.nouvelleDirection == Direction.VERS_LE_BAS) { // la touche bas
                                                                       // à été pressée
                            // le serpent tourne vers le bas
                            this.direction = Direction.VERS_LE_BAS;
                      }
                }
                // nous avons tenu compte du clavier, nous le vidons afin de
                // forcer le joueur à rappuyer sur une touche pour demander
                // une autre direction
                this.nouvelleDirection = null;
          }
    }
 
      private void avance() {
          // ajoute en tête de liste la case sur laquelle
          // le serpent doit se déplacer
          this.linkList.addFirst(getNextcase());
          // supprime le dernier élément de la liste
          this.linkList.removeLast();
    }
 
      private Case getNextcase() {
          Case tete = this.linkList.getFirst();
          switch (this.direction) {
                case VERS_LE_HAUT:
                      return new Case(tete.getIndiceX(), tete.getIndiceY() - 1);
                case VERS_LA_DROITE:
                      return new Case(tete.getIndiceX() + 1, tete.getIndiceY());
                case VERS_LE_BAS:
                      return new Case(tete.getIndiceX(), tete.getIndiceY() + 1);
                case VERS_LA_GAUCHE:
                      return new Case(tete.getIndiceX() - 1, tete.getIndiceY());
          }
          return null;
    }
 
      private boolean peutAvancer() {
    	  Case nextCase = getNextcase();
          return nextCase.estValide() && !this.linkList.contains(nextCase);
    }
 
      public boolean estMort() {
          return this.Mort;
    }
 
      private boolean peutManger(Monstre grenouille) {
          return grenouille.equals(getNextcase());
    }
 
      private void mange() {
          // ajoute en tête de liste la case sur laquelle
          // le serpent doit se déplacer
          this.linkList.addFirst(getNextcase());
          // comptabiliser les grenouilles "mangées"
          this.nbMange++;
          thread.start();
    }
 
      public int getEatCount() {
          return this.nbMange;
    }
 
      private int getThresholdCounter(int niveau) {
          switch (niveau) {
                case 1:
                      return 20;
                case 2:
                      return 16;
                case 3:
                      return 14;
                case 4:
                      return 12;
                case 5:
                      return 10;
                case 6:
                      return 8;
                case 7:
                      return 6;
                case 8:
                      return 4;
                case 9:
                      return 3;
                default :
                      return 2;
          }
    }
 
      public void calcul(Monstre grenouille, int niveau) {
    	// incrémenter le compteur
          this.compteurMouvement++;
          // vérifier qu'il est temps d'animer le serpent
          if (this.compteurMouvement >= getThresholdCounter(niveau)) {
                // remettre le compteur à zéro 
                this.compteurMouvement = 0;
                // calcul du serpent
                tourner();
                if (peutManger(grenouille)) {
                      mange();
                      grenouille.nouvelleGrenouille();
                } else if (peutAvancer()) {
                      avance();
                } else {
                      // la partie est perdue car le serpent
                      // a atteint les limites du plateau de jeu
                      this.Mort = true;
                }
          }
      }
 
 
      public void affichage(Graphics g) {
    	  // activer l'anti-aliasing du dessin
          Graphics2D g2 = (Graphics2D) g;
          g.setColor(couleurSerpent);
          g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                              RenderingHints.VALUE_ANTIALIAS_ON);
            // dessin du serpent
    	  for (Case box : this.linkList) {
              g.fillOval(box.getX(), box.getY(), box.getLargeur(), box.getHauteur());
        }
      }
 
}

Auriez vous une idée ?
Je vous remercie pour votre aide

Cordialement

Simon

[hwoarang]

Une fois que le thread a terminé l'execution de sa methode run, il est consideré terminé. Tu ne peux donc pas appler plusieurs fois start sur le meme thread.
Tu as donc 2 solutions:
- Creer un thread a chaque fois que tu veux jouer un son (simple mais peu efficace)
- Mettre une boucle dans le thread qui joue le son et le reveiller quand tu veux qu'il joue avec des semaphores/wait/notify. Ca evite de creer trop de thread mais c'est plus compliqué à gerer (et ne pas oublier dans ce cas d'arreter correctement le thread).

[Salydan]

Merci de ta réponse. Je vais opter pour la seconde solution car dans le premier cas le nombre de thread peut devenir très vite important.
Je te tient au courant du résultat final.

[tchize_]

Pour la seconde option, j'utiliserais plutôt un ExecutorService, ça gère déjà correctement la synchronization et mon expérience m'a appris qu'en terme de multithread, le développeur ont souvent tendance à merder les edge cases de synchronisation.

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
ExecutorService executorService = Executors.newSingleThreadExecutor();
public class Son implements Callable<Void>{
    private AudioClip ac;
    public Son(URL url){
       ac = Applet.newAudioClip(url);
    }
    public Void call() throws Exception{
        ac.play();
        return null;
    }
}
//...
      private void mange() {
          // ajoute en tête de liste la case sur laquelle
          // le serpent doit se déplacer
          this.linkList.addFirst(getNextcase());
          // comptabiliser les grenouilles "mangées"
          this.nbMange++;
          executorService.submit(new Son(Snake.class.getResource("sons/bruit.wav")));
    }