Probleme de collision sur PacMan [Résolu]

djbenji81100 66 Messages postés vendredi 9 septembre 2011Date d'inscription 4 juin 2012 Dernière intervention - 15 avril 2012 à 12:01 - Dernière réponse : cormandyr 600 Messages postés samedi 20 mai 2006Date d'inscription 8 juillet 2016 Dernière intervention
- 19 avril 2012 à 11:23
Bonjour ,

c'est la premiere application en java que je fait et je me heurte a quelques problemes .

voila j'ai fait une matrice pour dessiné mon labyrinthe + la nourriture ( en objet ) que le petit pac man doit manger .


voila la declaration :
public class Labyrinthe1 {
private boolean actif; 
private CaseGrille maCase;

CaseGrille[][] TabCase = new CaseGrille[45][45];              //22
                   //0,1,2,3,4,5,6,7,8,9;0,1,2,3,4,5,6,7,8,9;0,1,2,3,4,5,6,7,8,9;0,1,2,3,4,5,6,7,8,9;0,1,2,3,4
private int[] laby ={1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
             1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
             1,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,1,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,1,
             1,0,2,0,0,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,2,0,1,0,2,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,0,0,2,0,1,
             1,0,2,0,1,1,1,0,2,0,1,1,1,1,1,0,2,0,1,0,2,0,1,0,2,0,1,0,2,0,1,1,1,1,1,0,2,0,1,1,1,0,2,0,1,
             1,0,2,0,1,1,1,0,2,0,1,1,1,1,1,0,2,0,1,0,2,0,1,0,2,0,1,0,2,0,1,1,1,1,1,0,2,0,1,1,1,0,2,0,1,
             1,0,2,0,0,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,2,0,0,0,2,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,0,0,2,0,1,
             1,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,1,
             1,0,2,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,2,0,1,
             	 1,0,2,0,1,1,1,1,1,1,1,1,0,2,0,1,1,0,2,0,1,1,1,1,1,0,2,0,1,1,0,2,0,1,1,1,1,1,1,1,1,0,2,0,1,
             1,0,2,0,1,1,1,1,1,1,1,1,0,2,0,1,1,0,2,0,1,1,1,1,1,0,2,0,1,1,0,2,0,1,1,1,1,1,1,1,1,0,2,0,1,
             1,0,2,0,0,0,0,0,0,0,1,1,0,2,0,1,1,0,2,0,0,0,0,0,0,0,2,0,1,1,0,2,0,1,1,0,0,0,0,0,0,0,2,0,1,
             1,0,2,2,2,2,2,2,2,0,1,1,0,2,0,1,1,0,2,2,2,2,2,2,2,2,2,0,1,1,0,2,0,1,1,0,2,2,2,2,2,2,2,0,1,
             1,0,2,0,0,0,0,0,2,0,1,1,0,2,0,1,1,0,0,0,0,0,2,0,0,0,0,0,1,1,0,2,0,1,1,0,2,0,0,0,0,0,2,0,1,
             1,0,2,0,1,1,1,0,2,0,1,1,0,2,0,1,1,1,1,1,1,0,2,0,1,1,1,1,1,1,0,2,0,1,1,0,2,0,1,1,1,0,2,0,1,
             1,0,2,0,1,1,1,0,2,0,1,1,0,2,0,1,1,0,0,0,0,0,2,0,0,0,0,0,1,1,0,2,0,1,1,0,2,0,1,1,1,0,2,0,1,
             1,0,2,0,1,1,1,0,2,0,1,1,0,2,0,1,1,0,2,2,2,2,2,2,2,2,2,0,1,1,0,2,0,1,1,0,2,0,1,1,1,0,2,0,1,
             1,0,2,0,1,1,1,0,2,0,1,1,0,2,0,1,1,0,2,0,0,0,0,0,0,0,2,0,1,1,0,2,0,1,1,0,2,0,1,1,1,0,2,0,1,
             1,0,2,0,0,0,0,0,2,0,0,0,0,2,0,1,1,0,2,0,1,1,1,1,1,0,2,0,1,1,0,2,0,0,0,0,2,0,0,0,0,0,2,0,1,
             1,0,2,2,2,2,2,2,2,2,2,2,2,2,0,1,1,0,2,0,1,0,0,0,1,0,2,0,1,1,0,2,2,2,2,2,2,2,2,2,2,2,2,0,1,
             1,0,0,0,0,0,0,0,2,0,0,0,0,2,0,1,1,0,2,0,1,0,0,0,1,0,2,0,1,1,0,2,0,0,0,0,2,0,0,0,0,0,0,0,1,
             1,1,1,1,1,1,1,0,2,0,1,1,0,2,0,1,1,0,2,0,1,1,1,1,1,0,2,0,1,1,0,2,0,1,1,0,2,0,1,1,1,1,1,1,1,
             1,1,1,1,1,1,1,0,2,0,1,1,0,2,0,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,0,2,0,1,1,0,2,0,1,1,1,1,1,1,1,
             1,1,1,1,1,1,1,0,2,0,1,1,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,1,1,0,2,0,1,1,1,1,1,1,1,
             1,0,0,0,0,0,0,0,2,0,1,1,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,1,1,0,2,0,0,0,0,0,0,0,1,
             1,0,2,2,2,2,2,2,2,0,1,1,0,2,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,2,0,1,1,0,2,2,2,2,2,2,2,0,1,
             1,0,2,0,0,0,0,0,2,0,1,1,0,2,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,2,0,1,1,0,2,0,0,0,0,0,2,0,1,
             1,0,2,0,1,1,1,0,2,0,0,0,0,2,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,2,0,0,0,0,2,0,1,1,1,0,2,0,1,
             1,0,2,0,1,1,1,0,2,2,2,2,2,2,2,2,2,2,2,0,1,1,1,1,1,0,2,2,2,2,2,2,2,2,2,2,2,0,1,1,1,0,2,0,1,
               	 1,0,2,0,0,0,1,0,2,0,0,0,0,0,0,0,0,0,2,0,1,1,1,1,1,0,2,0,0,0,0,0,0,0,0,0,2,0,1,0,0,0,2,0,1,
             1,0,2,2,2,0,1,0,2,0,1,1,1,1,1,1,1,0,2,0,1,1,1,1,1,0,2,0,1,1,1,1,1,1,1,0,2,0,1,0,2,2,2,0,1,
             1,0,0,0,2,0,1,0,2,0,1,1,1,1,1,1,1,0,2,0,1,1,1,1,1,0,2,0,1,1,1,1,1,1,1,0,2,0,1,0,2,0,0,0,1,
             1,1,1,0,2,0,1,0,2,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,2,0,1,0,2,0,1,1,1,
             1,1,1,0,2,0,1,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,1,0,2,0,1,1,1,
             1,1,1,0,2,0,1,0,2,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,2,0,1,0,2,0,1,1,1,
             1,1,1,0,2,0,1,0,2,0,1,1,0,2,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,2,0,1,1,0,2,0,1,0,2,0,1,1,1,
             1,1,1,0,2,0,1,0,2,0,1,1,0,2,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,2,0,1,1,0,2,0,1,0,2,0,1,1,1,
             1,0,0,0,2,0,0,0,2,0,1,1,0,2,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,2,0,1,1,0,2,0,0,0,2,0,0,0,1,
             1,0,2,2,2,2,2,2,2,0,1,1,0,2,2,2,2,2,2,0,1,1,1,1,1,0,2,2,2,2,2,2,0,1,1,0,2,2,2,2,2,2,2,0,1,
             1,0,2,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,2,0,1,1,1,1,1,0,2,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,2,0,1,
            	 1,0,2,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,2,0,1,1,1,1,1,0,2,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,2,0,1,
             1,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,1,
             1,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,1,
             1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
             1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
             1,1,1,1,1,1,2,1,1,1,1,1,1,1,0,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 };



public Labyrinthe1(){

// creation de la matrice

int i, j,k;
k=0;
for (i=0; i<=44; i++){
for(j=0; j<=44; j++){

//this.maCase = new CaseGrille(i,j);

if (laby[k] == 0){
TabCase[i][j] = new CaseVide(i,j);
}
else if (laby[k] == 1){
TabCase[i][j] = new Mur(i,j);

}
else if (laby[k] == 2){
TabCase[i][j] = new Nourriture1(i,j);

}
k++;
}
}

}



Pour faire simple je parcours mon tableau "laby" et j'affecte un mur , une case vide ou de la nourriture en fonction du nombre ce trouvant dans le tableau .
jusque la pas de probleme ^^

Affin de pouvoir faire le controle de collision ( lorque le perso butte sur un mur ) j'ai fait comme ceci :

dans une classe ModeleDuJeu , je dissocie le calcul de l'affichage et je fait un controle de la prochaine case où doit ce trouver le perso . si c'est un mur je mets la direction a nul pour qu'il butte . voila le code :


	
// le calcul du jeu
    public void calcul(){
    	
    	this.lelabyrinthe.calcul();
    	//this.lanourriture.calcul();
    	
int laPosX, laPosY ;
laPosX = (this.leperso.getPosX() / Constantes.CASE_EN_PIXELS) ;
laPosY = (this.leperso.getPosY() / Constantes.CASE_EN_PIXELS) ;
//laDirect = Direction.VERS_LE_BAS;

if (this.lelabyrinthe.getbool(laPosX, laPosY, laDirect) == true){

this.laDirect = null;

}
else {
    	
    	this.leperso.calcul();
}
    	
    	
    	
    }
    


la methode getbool ( ce trouvant dans Labyrinthe1 ) :

public boolean getbool(int posX, int posY, Direction laDirect){
  
  int index; 
  boolean actif;
  index = 0;
  actif = true;
  
  
 if (laDirect == Direction.VERS_LE_HAUT){
  index = (((posY-1) * 45) + (posX) );
 }
 else if (laDirect == Direction.VERS_LE_BAS){
 index = ((posY  * 45) + (posX ));
 }
 else if (laDirect == Direction.VERS_LA_GAUCHE){
 index = (((posY - 1) * 45) + (posX-1) );
 }
 else if (laDirect == Direction.VERS_LA_DROITE){
 index = ((posY * 45) + (posX+1) );
 }
 
  if (laby[index] == 1){
  actif = true;
  }
  else if (laby[index] == 0){
  actif = false;
  }
  else if (laby[index] == 2){
  actif = false;
  }
    	 return actif;
     }
 



Donc en gros lors du controle de la prochaine case je verifie l'etat de la case ( mur , nourriture ou case vide ) et je renvoie un booleen ( si mur alors bool devient vrai )

Voila moin probleme :

Mon perso butte bien ! mais pas au bon endroit ^^ . voila l'imprime ecran ici

Donc il butte une fois arriver sur la case ...

Quelqu'un peu il me dire s'il as une idée qui pourrais expliquer le pourquoi du comment ?? =D

Merci d'avance
Afficher la suite 

Votre réponse

16 réponses

Meilleure réponse
cormandyr 600 Messages postés samedi 20 mai 2006Date d'inscription 8 juillet 2016 Dernière intervention - 17 avril 2012 à 10:56
3
Merci
Et donc de ce code ci:
public boolean getbool(int posX, int posY, Direction laDirect){
  
    int index; 
    boolean actif;
    index = 0;
    actif = true;		  
  
    if (laDirect == Direction.VERS_LE_HAUT){
index = (((posY-1) * 45) + (posX) );
    } else if (laDirect == Direction.VERS_LE_BAS){
index = ((posY  * 45) + (posX ));
    } else if (laDirect == Direction.VERS_LA_GAUCHE){
index = (((posY - 1) * 45) + (posX-1) );
    } else if (laDirect == Direction.VERS_LA_DROITE){
index = ((posY * 45) + (posX+1) );
    }
 
    if (laby[index] == 1){
actif = true;
    } else if (laby[index] == 0){
actif = false;
    } else if (laby[index] == 2){
        actif = false;
    }
    return actif;
}

qui est mieux comme ceci :
public boolean getbool(int posX, int posY, Direction laDirect){
  
    int index; 
    boolean actif;
    index = 0;	  
  
    switch(laDirect){
case Direction.VERS_LE_HAUT:
    index = (((posY-1) * 45) + (posX) );
    break;
        case Direction.VERS_LE_BAS:
    index = ((posY  * 45) + (posX ));
    break;
        case Direction.VERS_LA_GAUCHE:
    index = (((posY - 1) * 45) + (posX-1) );
    break;
        case Direction.VERS_LA_DROITE:
    index = ((posY * 45) + (posX+1) );
    break;
    }

    return laby[index] == 1;
}


Petite question, il le fait pour toute les directions ou le problème ne se pose que quand tu change de direction pour aller vers la gauche?

Merci cormandyr 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 102 internautes ce mois-ci

Commenter la réponse de cormandyr
Meilleure réponse
cormandyr 600 Messages postés samedi 20 mai 2006Date d'inscription 8 juillet 2016 Dernière intervention - 17 avril 2012 à 13:21
3
Merci
je réfléchis pour le problème pricipale...

pour la question facile, return laby[index] == 1;
cela retourne un boolean ^^
si tu préfères : return (laby[index] == 1);
en traduit : renvoie ( est-ce que laby[index] est égal à 1? )

Merci cormandyr 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 102 internautes ce mois-ci

Commenter la réponse de cormandyr
Meilleure réponse
cormandyr 600 Messages postés samedi 20 mai 2006Date d'inscription 8 juillet 2016 Dernière intervention - 18 avril 2012 à 08:08
3
Merci
- Vaut t'il mieu que je m'y prenne autrement ? ( sachant que j'aimerais que mon pacman commence a bouger que lorque j'appuis sur une touche , actuellement il bouge automatiquement vers la gauche dès le lancer du jeu )

comme ça je ne crois pas... ça me semble correct...

- Si oui comment ? ^^

Ben tu met la direction à null. et tu change un peu le code:
 public void calcul(){    	
    	this.lelabyrinthe.calcul();
    	//this.lanourriture.calcul();
    
int laPosX, laPosY ;
laPosX = (this.leperso.getPosX() / Constantes.CASE_EN_PIXELS) ;
laPosY = (this.leperso.getPosY() / Constantes.CASE_EN_PIXELS) ;
laDirect = this.leperso.laDirection();	
if (laDirect != null){
if (this.lelabyrinthe.getbool(laPosX, laPosY, laDirect) == true){
this.laDirect = null;		
} else {
    			this.leperso.calcul();
}
}
    }

- Lorsque le pacman arrive sur un mur ma direction passe a null donc le mouvement s'arrete ( forcement ) comment faut'il que je m'y prenne pour le faire repartir dans une autre direction ? ( ccar actuellement il ne bouge plus je suis obligé de relancer le jeu )

Tu lui donne la direction opposée par exemple... non?

Merci cormandyr 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 102 internautes ce mois-ci

Commenter la réponse de cormandyr
cormandyr 600 Messages postés samedi 20 mai 2006Date d'inscription 8 juillet 2016 Dernière intervention - 16 avril 2012 à 09:11
0
Merci
Salut,

Es-tu sur que ce code :
int laPosX, laPosY ;
laPosX = (this.leperso.getPosX() / Constantes.CASE_EN_PIXELS) ;
laPosY = (this.leperso.getPosY() / Constantes.CASE_EN_PIXELS) ;
//laDirect = Direction.VERS_LE_BAS;

if (this.lelabyrinthe.getbool(laPosX, laPosY, laDirect) == true){
this.laDirect = null;			
} else {  	
    	this.leperso.calcul();
}

ne calcule/teste pas sur la position actuelle et non sur la prochaine position?
Commenter la réponse de cormandyr
djbenji81100 66 Messages postés vendredi 9 septembre 2011Date d'inscription 4 juin 2012 Dernière intervention - 16 avril 2012 à 09:36
0
Merci
Bonjour,

je ne sais pas !

la condition fait appels a ceci :

public boolean getbool(int posX, int posY, Direction laDirect){
  
  int index; 
  boolean actif;
  index = 0;
  actif = true;
  
  
 if (laDirect == Direction.VERS_LE_HAUT){
  index = (((posY-1) * 45) + (posX) );
 }
 else if (laDirect == Direction.VERS_LE_BAS){
 index = ((posY  * 45) + (posX ));
 }
 else if (laDirect == Direction.VERS_LA_GAUCHE){
 index = (((posY - 1) * 45) + (posX-1) );
 }
 else if (laDirect == Direction.VERS_LA_DROITE){
 index = ((posY * 45) + (posX+1) );
 }
 
  if (laby[index] == 1){
  actif = true;
  }
  else if (laby[index] == 0){
  actif = false;
  }
  else if (laby[index] == 2){
  actif = false;
  }
    	 return actif;
     }
 



en fonction de la direction actuelle il regarde la posiont soit ( x + 1 si je vais a droite ) , soit ( x - 1 ) si je vais a gauche ) , soit ( y + 1 si je vais en bas ) , soit ( y - 1 si je vais en haut ) .

donc il regarde bien la future position en fonction de la direction et si elle n'est pas bonne je lui donne le privilege d'avancer ou pas .
Commenter la réponse de djbenji81100
cormandyr 600 Messages postés samedi 20 mai 2006Date d'inscription 8 juillet 2016 Dernière intervention - 16 avril 2012 à 10:48
0
Merci
Ajoute des sorties console pour le savoir alors ^^
Vérifie que l'index retourné par tes calculs pointe bien sur la bonne cellule de ton tableau...

Une fois cette piste écartée on regardera pour une autre possibilité de réponse ^^
Commenter la réponse de cormandyr
djbenji81100 66 Messages postés vendredi 9 septembre 2011Date d'inscription 4 juin 2012 Dernière intervention - 16 avril 2012 à 11:02
0
Merci
Je fais ça dés que possible et je reviens
Merci
Commenter la réponse de djbenji81100
djbenji81100 66 Messages postés vendredi 9 septembre 2011Date d'inscription 4 juin 2012 Dernière intervention - 17 avril 2012 à 10:28
0
Merci
Bonjour ,
dsl du retard ( petit imprevu ... ) bon en effectuant les tests j'ai trouvé l'erreur . Enfin , du moins ce qui la produits



int laPosX, laPosY ;
laPosX = (this.leperso.getPosX() / Constantes.CASE_EN_PIXELS) ;
laPosY = (this.leperso.getPosY() / Constantes.CASE_EN_PIXELS) ;
//laDirect = Direction.VERS_LE_BAS;

if (this.lelabyrinthe.getbool(laPosX, laPosY, laDirect) == true){
this.laDirect = null;			
} else {  	
    	this.leperso.calcul();
}


Justement lorsque je mets le jeu en route je suis obligé d'enlever les "//" du commentaire pour lui donner une direction sinon le pacman ne ce deplace pas .

Lorque je mets

laDirect = Direction.VERS_LA_GAUCHE;


et que me dirige vers un mur ce trouvant a la gauche du perso il butte correctement . Mais si je lui fait changer de direction en plein jeu , il plante .

De meme pour toute les direction si je mets :

laDirect = Direction.VERS_LA_DROITE;

et que je me deplace ensuite vers la gauche il me fait la meme erreur .
donc je pense que le probleme vient d'ici .
Commenter la réponse de djbenji81100
djbenji81100 66 Messages postés vendredi 9 septembre 2011Date d'inscription 4 juin 2012 Dernière intervention - 17 avril 2012 à 13:00
0
Merci
Merci de la reponse plus que rapide =D

Alors , le probleme ce pose pour toutes les directions .

comme expliqué , lorque je mets

laDirect = Direction.VERS_LA_GAUCHE;


la collision ( et ce sur n'importe qu'elle mur du labyrinthe ) ce fait correctement du moment que le perso percute un mur ce trouvant sur la gauche . Si le mur ce trouve sur sa droite ( alors que dans le code j'ai "laDirect = Direction.VERS_LA_GAUCHE" ) la collision pose quelque probleme .

ce cas est valable pour les quatres directions : si laDirect = Direction.VERS_LA_DROITE alors le perso percute correctement les murs si le mur ce trouve sur la droite .


Par contre je ne comprends pas vraiment le code que tu vien de me donner puisque le but de la methode été de revoyer un booleen . Et la le code retourne " return laby[index] == 1;"

Pourquoi ce "return" ?
Commenter la réponse de djbenji81100
djbenji81100 66 Messages postés vendredi 9 septembre 2011Date d'inscription 4 juin 2012 Dernière intervention - 17 avril 2012 à 13:37
0
Merci
ok ok . Etant debutant dans ce language ( c'est ma premiere appli en java et en objet ) je ne sait pas tout ! ^^ . je pense peu etre ( je dis bien peu etre ) avoir une idée a la place de :

laDirect = Direction.VERS_LA_DROITE;


Mettre l'appel d'une methode recuperant la direction actuelle . je ne peu pas le faire de suite je suis actuellement en pleine redaction d'une note de synthese . Je le fait avant ce soir dans tous les cas pour voir si ça fonctionne, ou pas ^^
Commenter la réponse de djbenji81100
cormandyr 600 Messages postés samedi 20 mai 2006Date d'inscription 8 juillet 2016 Dernière intervention - 17 avril 2012 à 13:51
0
Merci
comme ça, je te dirais de l'ajouter en variable de ton perso...
Commenter la réponse de cormandyr
djbenji81100 66 Messages postés vendredi 9 septembre 2011Date d'inscription 4 juin 2012 Dernière intervention - 17 avril 2012 à 19:11
0
Merci
What ???
Commenter la réponse de djbenji81100
djbenji81100 66 Messages postés vendredi 9 septembre 2011Date d'inscription 4 juin 2012 Dernière intervention - 17 avril 2012 à 19:23
0
Merci
Bon je revien avec une bonne nouvelle !! Mais avec des questions en plus ^^'

j'ai réussi a gérer le probleme de collision ( en fonction de la direction )

j'ai fait comme ceci :




  public void calcul(){
    	
    	this.lelabyrinthe.calcul();
    	//this.lanourriture.calcul();
    	
int laPosX, laPosY ;
laPosX = (this.leperso.getPosX() / Constantes.CASE_EN_PIXELS) ;
laPosY = (this.leperso.getPosY() / Constantes.CASE_EN_PIXELS) ;
laDirect = this.leperso.laDirection();

if (laDirect == null){
laDirect = Direction.VERS_LA_GAUCHE;
}

if (this.lelabyrinthe.getbool(laPosX, laPosY, laDirect) == true){

this.laDirect = null;

}
else {
    	
    	this.leperso.calcul();
}
    	
    	
    	
    }


avec "laDirect = this.leperso.laDirection();" je recupère la direction dans ma classe personnage grace a une methode me retournant la diection .

Mes questions sont les suivantes :

- Vaut t'il mieu que je m'y prenne autrement ? ( sachant que j'aimerais que mon pacman commence a bouger que lorque j'appuis sur une touche , actuellement il bouge automatiquement vers la gauche dès le lancer du jeu )

- Si oui comment ? ^^

Une autre petite question ( et c'est la derniere !! ouf ! )

- Lorsque le pacman arrive sur un mur ma direction passe a null donc le mouvement s'arrete ( forcement ) comment faut'il que je m'y prenne pour le faire repartir dans une autre direction ? ( ccar actuellement il ne bouge plus je suis obligé de relancer le jeu )


Merci =D
Commenter la réponse de djbenji81100
djbenji81100 66 Messages postés vendredi 9 septembre 2011Date d'inscription 4 juin 2012 Dernière intervention - 18 avril 2012 à 11:39
0
Merci
Bonjour ,

je viens de modifier le code avec la partie que tu viens de me donner et le pac man ne repond pas du tout ^^

.Je me demande si ce n'est pas a cause de la gestion des touches . je regarde ça et je reviens au nouvelles .
Commenter la réponse de djbenji81100
djbenji81100 66 Messages postés vendredi 9 septembre 2011Date d'inscription 4 juin 2012 Dernière intervention - 19 avril 2012 à 11:22
0
Merci
Bonjour , je n'arrive toujours pas a regler ce probleme .

C'est pas grave je verrais avec un de mes profs directement .

En tous cas je te remercie de l'aide que tu m'as apporté , ça ma bien rendu service !!

encore merci et bonne continuation .
Commenter la réponse de djbenji81100
cormandyr 600 Messages postés samedi 20 mai 2006Date d'inscription 8 juillet 2016 Dernière intervention - 19 avril 2012 à 11:23
0
Merci
Pas de soucis,

C'est le but de ce site...
Commenter la réponse de cormandyr

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.