[RANDOM] Des chiffres pas si aléatoires que ca...
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:
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:
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]
