Sujet Précédent Sujet Suivant

Probleme de collision sur PacMan

Résolu
djbenji81100 Messages postés 66 Date d'inscription vendredi 9 septembre 2011 Statut Membre Dernière intervention 4 juin 2012 - 15 avril 2012 à 12:01
cormandyr Messages postés 600 Date d'inscription samedi 20 mai 2006 Statut Membre Dernière intervention 8 juillet 2016 - 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

16 réponses

Réponse 1 / 16
cormandyr Messages postés 600 Date d'inscription samedi 20 mai 2006 Statut Membre Dernière intervention 8 juillet 2016 11
17 avril 2012 à 10:56
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?
3
Réponse 2 / 16
cormandyr Messages postés 600 Date d'inscription samedi 20 mai 2006 Statut Membre Dernière intervention 8 juillet 2016 11
17 avril 2012 à 13:21
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? )
3
Réponse 3 / 16
cormandyr Messages postés 600 Date d'inscription samedi 20 mai 2006 Statut Membre Dernière intervention 8 juillet 2016 11
18 avril 2012 à 08:08
- 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?
3
Réponse 4 / 16
cormandyr Messages postés 600 Date d'inscription samedi 20 mai 2006 Statut Membre Dernière intervention 8 juillet 2016 11
16 avril 2012 à 09:11
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?
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 16
djbenji81100 Messages postés 66 Date d'inscription vendredi 9 septembre 2011 Statut Membre Dernière intervention 4 juin 2012
16 avril 2012 à 09:36
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 .
0
Réponse 6 / 16
cormandyr Messages postés 600 Date d'inscription samedi 20 mai 2006 Statut Membre Dernière intervention 8 juillet 2016 11
16 avril 2012 à 10:48
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 ^^
0
Réponse 7 / 16
djbenji81100 Messages postés 66 Date d'inscription vendredi 9 septembre 2011 Statut Membre Dernière intervention 4 juin 2012
16 avril 2012 à 11:02
Je fais ça dés que possible et je reviens
Merci
0
Réponse 8 / 16
djbenji81100 Messages postés 66 Date d'inscription vendredi 9 septembre 2011 Statut Membre Dernière intervention 4 juin 2012
17 avril 2012 à 10:28
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 .
0
Réponse 9 / 16
djbenji81100 Messages postés 66 Date d'inscription vendredi 9 septembre 2011 Statut Membre Dernière intervention 4 juin 2012
17 avril 2012 à 13:00
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" ?
0
Réponse 10 / 16
djbenji81100 Messages postés 66 Date d'inscription vendredi 9 septembre 2011 Statut Membre Dernière intervention 4 juin 2012
17 avril 2012 à 13:37
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 ^^
0
Réponse 11 / 16
cormandyr Messages postés 600 Date d'inscription samedi 20 mai 2006 Statut Membre Dernière intervention 8 juillet 2016 11
17 avril 2012 à 13:51
comme ça, je te dirais de l'ajouter en variable de ton perso...
0
Réponse 12 / 16
djbenji81100 Messages postés 66 Date d'inscription vendredi 9 septembre 2011 Statut Membre Dernière intervention 4 juin 2012
17 avril 2012 à 19:11
What ???
0
Réponse 13 / 16
djbenji81100 Messages postés 66 Date d'inscription vendredi 9 septembre 2011 Statut Membre Dernière intervention 4 juin 2012
17 avril 2012 à 19:23
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
0
Réponse 14 / 16
djbenji81100 Messages postés 66 Date d'inscription vendredi 9 septembre 2011 Statut Membre Dernière intervention 4 juin 2012
18 avril 2012 à 11:39
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 .
0
Réponse 15 / 16
djbenji81100 Messages postés 66 Date d'inscription vendredi 9 septembre 2011 Statut Membre Dernière intervention 4 juin 2012
19 avril 2012 à 11:22
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 .
0
Réponse 16 / 16
cormandyr Messages postés 600 Date d'inscription samedi 20 mai 2006 Statut Membre Dernière intervention 8 juillet 2016 11
19 avril 2012 à 11:23
Pas de soucis,

C'est le but de ce site...
0

Discussions similaires

trier un iterator
lafolle24320 -
Twinuts -

9 réponses
la division en java
cs_aliomar -
KIRAIII -

3 réponses
la difference entre a++ et ++a
waluigii -
Twinuts -

2 réponses
Le Mapping en Java: Map(Key,Value)
cs_developppez -
icecube005 -

2 réponses
Problème de division réelle (et oui...)
playmo420 -
nomad56 -

4 réponses
Rejoignez-nous