Discussion :

[djsbens]

Bonjour!!!!

Voila je fais actuellement un pacman et j'ai un petit probleme avec mes fantômes.

En fait ils arrivent parfois a se superposer et à ne plus se lacher du coup si j'avais 4 fantomes au début et que 2 se rejoingnent j'en ai plus que 3.

Ceci vient du fait (je pense) que ma génération de direction n'est pas si aléatoire que ca!

Voici l'algorithme en gros :

J'ai un thread dans une classe fantome qui toutes les 40 ms va rafficher le fantome à l'emplacement voulu.

POur cela je fais appel à une méthode obtenir direction.

Cette méthode la voici :

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
public int obtenirDirection(int x,int y)
	{
		ArrayList tab = new ArrayList();
		int directionOppose = Direction.getDirectionOppose(this.directionActuelle);
 
		// test sur la direction de droite
		if ((!this.panel.getLabyrinthe().getCaseSuivante(x, y, Direction.DROITE).isMur()) && (directionOppose!=Direction.DROITE)) {
			tab.add(new Integer(Direction.DROITE));
		}
 
		// test sur la direction de gauche
		if ((!this.panel.getLabyrinthe().getCaseSuivante(x, y, Direction.GAUCHE).isMur())  && (directionOppose!=Direction.GAUCHE)) {
			tab.add(new Integer(Direction.GAUCHE));
		}
 
		// test sur la direction de haut
		if ((!this.panel.getLabyrinthe().getCaseSuivante(x, y, Direction.HAUT).isMur())  && (directionOppose!=Direction.HAUT)) {
			tab.add(new Integer(Direction.HAUT));
		}
 
		// test sur la direction de bas
		if ((!this.panel.getLabyrinthe().getCaseSuivante(x, y, Direction.BAS).isMur())  && (directionOppose!=Direction.BAS)) {
			tab.add(new Integer(Direction.BAS));
		}
 
		if(tab.size()==0)
		{
			tab.add(new Integer(directionOppose));
		}
 
		return Direction.getDirectionAleatoire(tab);
	}

En gros elle teste les directions possibles du fantomes. et appel une classe Direction dont voici le code :

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
import java.util.ArrayList;
import java.util.Random;
 
public class Direction {
 
	public static final int AUCUNE = -1;
	public static final int DROITE = 0;
	public static final int GAUCHE = 1;
	public static final int HAUT = 2;
	public static final int BAS = 3;
 
	public static int getDirectionAleatoire(ArrayList tab)
	{
		Random rand = new Random();
		int i = rand.nextInt(tab.size());
		return Integer.parseInt(tab.get(i).toString());
	}
 
	public static int getDirectionOppose(int direction)
	{
		int directionRetour=Direction.AUCUNE;
		switch(direction)
		{
			case Direction.DROITE : directionRetour=Direction.GAUCHE;break;
			case Direction.GAUCHE : directionRetour=Direction.DROITE;break;
			case Direction.HAUT : directionRetour=Direction.BAS;break;
			case Direction.BAS : directionRetour=Direction.HAUT;break;	
		}
		return directionRetour;
	}
}

Si je me résume : je dirais que le probleme vient du fait que l'obtention d'une direction aléatoire pour deux fantomes superposés donnera souvent la même réponse.

Il arrive que les fantomes se détachent mais c'est très rare.

Comment je pourrais améliorer ma génération aléatoire?

Merci de m'avoir lu jusque là et d'essayer de m'aider!

A++

Ben[/code]

[Satch]

A tout hasard. en rendant synchronized ta méthode getdirectionAleatoire ça donne quoi ?

[djsbens]

Je connaissais pas l'utilité de synchronised . Je viens de l'apprendre.

En tout cas ca ne résoud pas le problème. Les fantômes font le meme parcours encore.

[djsbens]

En fait pour me compléter je dirais que le problème vient du fait que la méthode getDirectionAléatoirre reçoit les mêmes ArrayList du fait que les fantomes sont superposés et donc le random renvoit une direction aléatoire mais la même pour deux tableaux identiques donnés.

C clair?

je crois pas lol!

[adiGuba]

Salut,


Ramdom utilise l'heure système pour initialiser sa graine. La graine te permet d'obtenir une suite de chiffre. Comme tu recrée un nouvel objet Random à chaque fois tu le réinitialises à chaque fois...

Or l'heure système a une précision de l'ordre de 20 ms environ. Donc si tu appelle plusieurs fois la méthode dans ces 20 ms tu as la même graine donc la même suite et donc le même nombre. Tu dois donc initiliser l'objet Random une fois pour toute :

Code :

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

1
2
3
4
5
6
7
   private static final Random RAND = new Random();
 
   public static int getDirectionAleatoire(ArrayList tab)
   {
      int i = RAND.nextInt(tab.size());
      return Integer.parseInt(tab.get(i).toString());
   }

Enfin tu n'es pas forcément obligé de synchronisé getDirectionAleatoire() si tout tes appels sont fait dans le même thread...

a++

[djsbens]

ah oué!!!!

Ca marche beaucoup mieux maintenant...!

Merci beaucoup pour lex explications , je me doutais bien qu'il y avait un truc dans le genre a faire . C cool

Merci encore

Ben