Projet Pacman I.OBJECTIF ET BESOIN
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Projet Pacman
I.OBJECTIF ET BESOIN
Notre projet est de créer un jeu de Pacman où le Pacman se déplace dans
le plateau, notamment entre les couloirs, sans traverser les murs; les
touches directionnelles permettent au client de contrôler le Pacman et le
but du jeu est de passer sur toutes pastilles du jeu, tout en évitant les
fantômes.
Il y a 2 super-pastilles à deux coins du plateau de jeu qui, une fois
mangée, donne au Pacman des supers pouvoirs (30 secondes environ) et
permet au Pacman de manger les fantômes.
La partie sera gagnée si le Pacman a mangé toutes les pastilles du jeu.
Le rôle des fantômes est de rendre plus difficile le jeu. Ceux ci ont deux
modes de fonctionnement :
• En état « normal », les fantômes se déplacent aléatoirement au
début du jeu et plus le niveau augmente et plus les fantômes
deviendront intelligents en suivant le Pacman. La collision du Pacman
et d’un Fantôme fait perdre la partie.
• En état « effrayé », les fantômes changent de couleurs, ralentissent
et se déplacent de manière à s'éloigner du Pacman.
Si le fantôme effrayé touche le Pacman, il retourne alors au centre
du plateau et revient à l'état « normal ».
II. FONCTIONNALITÉS / CONTRAINTES
• Gérer le déplacement du Pacman et des fantômes :
Ils ne doivent pas sortir du cadre du jeu, ils ne doivent pas rentrer
dans un mur : dans ce cas, les fantômes changent de direction
aléatoirement alors que le Pacman attend l’instruction de l’utilisateur.
• Gestion du déplacement du fantôme en fonction du niveau de jeu.
• Créer les super pastilles modifiant le rôle des fantômes et duPacman.
• Gestion du score : le Pacman modifie la couleur des cases sur lequel
il passe : une nouvelle case rapporte 1 point et une superpastille
rapporte 10 points.
III. DESCRIPTION DE L’AVANCEMENT
DU PROJET
1. Etape d’avancement du projet
• Durant la séance du 02/02/2015 : (Idrissa)
Création de la structure du plateau de jeu (Mur du jeu et couloir de
déplacement du Pacman).
• Durant les séances du 09-16/01/2015 : (Idrissa)
Eviter au Pacman de travers un mur.
• Durant les séances du 09-16/02/2015 : (Mamadou)
Gérer la modification des couleurs des cases en cas du passage du
pacman et le décompte des points.
• Durant la séance du 09/03/2015 : (Mamadou)
Mettre en place les super pastilles modifiant le rôle des fantômes et
du pacman.
• Durant les séances du 16/03/2015 au 11/05/2014 : (Idrissa)
Gestion du déplacement aléatoire des fantômes.
• Durant la séance du 18/05/2014 (Idrissa et Mamadou):
Affichage de la fin du jeu (gagné ou perdu).
2. Difficulté à mettre le travail en
commun
On a rencontré quelques difficulté à mettre notre code en commun avec
d’un côté les modifications à faire pour que le code de l’un marche
correctement chez l’autre et vice-versa (Emplacement, variables à
déclarer, etc...) ; et de l’autre, l’explication brève du code et de son rôle.
3. Développement ultérieur duprojet
• Le code peut être amélioré en dotant le fantôme d'une intelligence
artificielle.
• Actuellement, le jeu ne possède pas de niveaux de difficulté : il
faudrait le doter de plusieurs niveaux de jeu, c'est-à-dire qu'en
fonction du score du jeu, la difficulté du jeu augmentera.
On peut augmenter la difficulté du jeu en réduisant la durée des
cycles (augmentant la vitesse des pions), ralentir le Pacman, modifier
le plateau de jeu, augmenter le nombre de fantômes ...
4. Remarque
Nous n'avons pas réussi à implémenter entièrement le code qui gère la
collision Pacman-fantôme car dans la version présente, la collision n'est
valable que lorsque le Pacman et le fantôme arrive sur une même case
mais ne marche pas lorsqu'ils se croisent.
IV. IMPLANTATION EN JAVA
1. Variables :
a) palette
Cette variable est un tableau d'entiers contenant la totalité des couleurs
utilisées dans le jeu (murs, pastilles, pions, super_pastille...). Chaque
couleur est désignée par un nombre hexadécimal et repéré par son index
dans cette variable.
b) fondCouleur
Cette variable est un tableau à deux dimensions permettant de définir la
couleur des cases du plateau de jeu, une valeur de cette variable
correspond à l'index de la couleur utilisée pour la case.
2. Description des fonctions
c) Arrêt lors de la rencontre d’un mur
• ExplicationPour que le Pacman ne rentre pas dans un mur, on doit détecter si sa
prochaine position sera un mur. Si c’est le cas, il attribue aux vecteurs
vectX et vectY du Pacman la valeur 0 afin que le Pacman s’arrête avant le
mur et attende la prochaine action du joueur.
Nous utilisons deux variables x et y qui représenteront la prochaine
position du Pacman.
On vérifie ensuite que la prochaine case repérée par la position (x,y) est
un mur : c’est-a-dire possède une couleur d’index 1 (Couleur rouge).
• Algorithme
x=abscisse de la prochaine case ;
y=ordonne de la prochaine case ;
Si (l'index de la prochaine destination du pacman est rouge)
Alors :
vectX devient nul ;
vectY devient nul ;
Fin si
• Implémentation java
//récupère la valeur de la prochaine case que le pacman va
atteindre
int x = getX()+vectX;
int y = getY()+vectY;
//si la couleur de cette case est rouge, le pacman s’arrête et
attend les commandes du client
if (projet.fondCouleur[y][x] == 1){
vectX= 0;
vectY=0;
}
d) Déplacement du Fantôme
• Description
Cette fonction a pour objectif de permettre au fantôme de se déplacer de
manière aléatoire dans les couloirs du plateau de jeu. Les vecteurs des
fantômes subiront une modification pour qu'il se déplace aléatoirement
sans retour sur ses pas.
On utilise les deux variables vectChoixX et vectChoixY qui seront
affectées des valeurs de la position actuelle à laquelle on ajoute le vecteurvitesse (vectX,vectY) afin d’obtenir la prochaine position du Pacman.
Ces deux variables vont permettre de savoir le nombre de possibilités dont
le fantôme dispose afin de lui accorder un vecteur aléatoire grâce au
binaire (0,1,2,3) représentant respectivement les directions haut, droite,
bas, gauche. La fonction « math.random() » sera utilisée.
• Algorithme
mouvChoix : variable stockant les positions
mouvDeplacement :boolean permettant d'exécuter le choix aléatoire
les variables ancienvectX et ancienvectY stockent les anciennes vecteurs
du fantomes .
les variables vectchoixX et ancienvectchoixY stockent les vecteurs qui
seront affecte au fantômes une voix le choix aléatoire exécuter .
Tant que (mouvDeplacement est vrai){
mouvChoix choisi entre 0,1,2,3
si (mouvChoix = 0 et ancienvectX different de 0 et
ancienvectY est différent de 1) {
vectchoixX = 0;
vectchoixy = -1 ;
fin si
fin tant que
• Implémentation javaboolean selectDeplacement=false;
//le choix aleatoire est effectuer tant que mouvDeplacement
est vrai
while(!selectDeplacement){
// La variable mouvChoix va faire un choix aleatoire
entre les entiers 0,1,2,3
mouvChoix = Math.floor(Math.random()*4);
//Test la possibilite du deplacement vers le haut
if((mouvChoix == 0) && !((ancienVectX==0) &&
(ancienVectY==1))){
vectChoixX = 0;
vectChoixY = -1;
}
//si le fantome a deja un vecteur
if(!((vectChoixX==0) && (vectChoixY==0))){
//verifie si la prochaine position est un mur
if(projet.fondCouleur[getY()+vectChoixY][getX()
+vectChoixX] != 1){
//le fantome ne rentre pas dans le mur
selectDeplacement=true;
}
}
}
e) Score
• Description
La variable « score » permet de comptabiliser le nombre de cases sur
lequel passe le Pacman. Après le passage du pacman sur une case non
coloriée, la case sera coloriée.
La variable score est positionnée initialiser à 0 dans le fichier Pacman
Quand le Pacman passe sur une des 2 super pastilles le score augmente
de 10 points
Pour savoir si la case sera comptabilisée ou non, on utilise la fonction
« changePosition() » pour connaître le prochain déplacement du Pacman
si la case n’est pas coloriée le score augmente de 1…
si la case est déjà coloriée le score ne varie pas.
• AlgorithmeSi(la valeur de fondCouleur à l’index (posX ,posY) vaut 0 ) alors ;
On augmente le Score de 1;
Fin si
Si(la valeur de fondCouleur à l’index (posY,posX vaut 3)
Alors ;
On augmente le score de 10
On affecte une valeur de l’index de la couleur qui vaut 2
à la variable fondCouleur
On affecte la valeur 2 à l’index (posX,posY) de la variable
fondCouleur
Fin sinon
• Implémentation java
if(ProjetCase.fondCouleur[posY][posX]==0){
caseChangeCouleur(posX,posY,2 );
projet.score++;
}
f) Super pastille
• Description
L’objectif est de créer 2 super pastilles dans les extrémités du plateau.
Quand le Pacman passe sur une super pastille, les fantômes fuient le
Pacman car ils sont confrontés au danger d’être mangé par le Pacman. Ce
moment dure 20 cycles de jeu.
La variable « superCycle » qui à pour but de comptabiliser le nombre de
cycles
• Algorithme//Initialisation des variables
La variable.peur de type booléen prend valeur par défaut false
//Vérification du passage sur une super pastille
Si( le pacman passe sur une super pastille)
Alors ;
La variable peur de type boolean passe à true ;
fin sinon
//Gestion de la variable supercycle pour chaque cycle
Si( la variable peur de type booléen vaut true)
Alors ;
La variable superCyle augmente d’un
Fin si
si( la variable superCycle vaut 20)
alors ;
la variable peur de type booléen prend la valeur false
la variable superCycle est initialisée à 0
fin si
• Implémentation java
if(ProjetCase.fondCouleur[posY][posX]==3){
caseChangeCouleur(posX,posY,2 );
projet.score = projet.score+10;
projet.superPastille = true;
}
if(projet.superPastille == true){
projet.superCycle++;
}
if(projet.superCycle == 20){
projet.superPastille = false;
projet.superCycle=0;
}
g) Gain ou perte de la partie
• Description
Il s’agit de gérer la perte de la partie si le Pacman croise un Fantôme et
d’afficher le score, et de gérer le gain de la partie si le Pacman arrive a
manger toutes les pastilles du jeu c'est-à-dire a rendre toutes les cases
noires en vertes.• Algorithme
Pour (chaque pion fantôme [k])
Si (position du Pacman = La position du fantôme)
Alors
Si (Super Pastille est activée) alors :
Le fantôme meurt et vois sa position se réinitialiser
Sinon alors :
Afficher le Message Partie Perdu
Fin Si
Si (Score = 160) alors :
Afficher le message du gain de la partie.
Fin Si
• Implémentation java
for(int k=1;kAnnexe
Fichier “Pacman.java”
1 import j a v a x . swing . JOptionPane ;
2 import j a v a x . swing . JPanel ;
3 import j a v a x . swing .Box;
4 class Pacman extends ProjetCase {
5 public int score =0;
6 public boolean superPastille = false ;
7 public int superCycle =0;
8 public static void main ( String [ ] args ) {
9 // Definie les murs du fond
10 palette = new int [ ] {0 x00000000 , 0 x00FF0000 ,
11 0 x0000FF00 , 0x00FF00FF ,
12 0X00AAAAFF,0x00FFFF00};
13
14 fondCouleur = new int [ ] [ ] {{1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1} ,
15 {1 ,3 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,1} ,
16 {1 ,0 ,1 ,1 ,0 ,1 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,1 ,0 ,1 ,1 ,0 ,1} ,
17 {1 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,1} ,
18 {1 ,0 ,1 ,0 ,1 ,1 ,0 ,1 ,0 ,0 ,0 ,0 ,1 ,0 ,1 ,1 ,0 ,1 ,0 ,1} ,
19 {1 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,1} ,
20 {1 ,0 ,1 ,0 ,1 ,1 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,1 ,1 ,0 ,1 ,0 ,1} ,
21 {1 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,1} ,
22 {1 ,0 ,1 ,1 ,0 ,1 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,1 ,0 ,1 ,1 ,0 ,1} ,
23 {1 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 ,0 ,0 ,0 ,3 ,1} ,
24 {1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1}};
25
26 // plateau de jeu avec 20 collones et 11 lignes
27 new Pacman (11 ,20 ,25) ;
28 }
29
30 public Pacman ( int x , int y , int largeur ) {
31 super (x ,y , largeur ) ;
32 // permet un deplacement continu des pions du jeu
33 this . cycleContinue ( true ) ;
34 this . titreFenetre (" Pacman "+ score ) ;
35 }
36
37 @Override
38 public void declaration () {
39 // declares tous les pions du jeu
40 this . pions = new Pion [ 3 ] ;
41 // la vitesse de deplacement du jeu
42 this . c y c l e D e p l a ce men tS ec ond = 4;
43
44 // 1 er pion ou pion pacman
45 pions [ 0 ] = new PionPacman ( this ,1 ,5) ;
46 // 2 em pion ou pion fantome
47 pions [ 1 ] = new PionFantome ( this ,10 ,5) ;
48 // 3 em pion ou pion fantome
49 pions [ 2 ] = new PionFantome ( this ,9 ,5) ;
50 }
51
52 public void a c t i o n E s c a p e () {
53 this . cycleStop () ;
54 JOptionPane jop1 ;
55 jop1 = new JOptionPane () ;
56 jop1 . showMess ageDialog ( null , " appuyer s u r echap pour r e p r e n d r e " , null , ←-
JOptionPane .INFORMATION_MESSAGE) ;
57 this . cycleStart () ;
58 }
59 }
Fichier “PionFantome.java”
1 import j a v a x . swing . JOptionPane ;2
3 class PionFantome extends Pion {
4 Pacman projet ;
5 public PionFantome ( Pacman projet , int posX , int posY ) {
6 super ( projet , posX , posY ) ;
7 this . projet = projet ;
8 // donne la couleur d ’ index 5 aux fantomes
9 this . couleurChange (5) ;
10 }
11
12 public void meurt () {
13 // renitialise la position du fantome a la case (5 ,9)
14 changePosition (9 ,5) ;
15 }
16
17 @Override
18 public void cycleVecteur ( int X , int Y ) {
19 int ancienVectX , ancienVectY ;
20 int vectChoixX =0 , vectChoixY =0;
21
22 ancienVectX = vectX ;
23 ancienVectY = vectY ;
24
25 // le choix aleatoire du déplacement est initialisé à 0
26 double mouvChoix = 0;
27 // Initialise la variable de type booleen mouvDeplacement à true
28 boolean selec tDeplacement = false ;
29 // le choix aleatoire est effectuer tant que mouvDeplacement est vrai
30 while (! selectDe placement ) {
31 // La variable mouvChoix va faire un choix aleatoire entre les ←-
entiers 0 ,1 ,2 ,3
32 mouvChoix = Math . f l o o r ( Math .random () *4) ;
33
34 // Test la possibilite du deplacement vers le haut
35 if (( mouvChoix == 0) && !(( ancienVectX ==0) && ( ancienVectY ==1) ) ) {
36 vectChoixX = 0;
37 vectChoixY = -1;
38 }
39
40 // test la possibilite du deplacement vers la droite
41 if (( mouvChoix == 1) && !(( ancienVectX == -1) && ( ancienVectY ==0) ) ) ←-
{
42 vectChoixX = 1;
43 vectChoixY =0;
44 }
45
46 // test la possibilite du deplacememnt vers le bas
47 if (( mouvChoix == 2) && !(( ancienVectX ==0) && ( ancienVectY == -1) ) ) {
48 vectChoixX = 0;
49 vectChoixY =1;
50 }
51
52 // test la possibilite du deplacement vers le gauche
53 if (( mouvChoix == 3) && !(( ancienVectX ==1) && ( ancienVectY ==0) ) ) {
54 vectChoixX = -1;
55 vectChoixY =0;
56 }
57
58 // si le fantome a deja un vecteur
59 if (!(( vectChoixX ==0) && ( vectChoixY ==0) ) ) {
60 // verifie si la prochaine position est un mur
61 if ( projet . fondCouleur [ getY () + vectChoixY ] [ getX () + vectChoixX ] ←-
!= 1) {
62 // le fantome ne rentre pas dans le mur
63 selectDeplacement = true ;64 }
65 }
66 }
67 // affecte au variables les vecteurs du pions
68 vectX = vectChoixX ;
69 vectY = vectChoixY ;
70 }
71 }
Fichier “PionPacman.java”
1 import j a v a x . swing . JOptionPane ;
2
3 class PionPacman extends Pion {
4 Pacman projet ;
5
6 public PionPacman ( Pacman projet , int posX , int posY ) {
7 super ( projet , posX , posY ) ;
8 this . projet = projet ;
9 // Donne la couleur d ’ index 4 au pion pacman
10 this . couleurChange (4) ;
11 }
12
13 @Override
14 public void changePosition ( int posX , int posY ) {
15 putX( posX ) ;
16 putY( posY ) ;
17 // vpour chaque pion fantome
18 for ( int k =1; k50 caseC hangeC ouleur ( posX , posY ,2 ) ;
51 projet . score = projet . score +10;
52 projet . superPastille = true ;
53 projet . titreFenetre (" pacman "+ projet . score ) ;
54 }
55
56 if ( projet . superPastille == true ) {
57 // le nombre de cycle augmente quand en est en mode superPastille
58 projet . superCycle ++;
59 }
60
61 if ( projet . superCycle == 20) {
62 // apres 20 cycles le mode superPastille n ’ est plus active
63 projet . superPastille = false ;
64 projet . superCycle =0;
65 }
66
67 if ( projet . score ==126) {
68 // affiche le gain de la partie si le score est egale à 126
69 JOptionPane jop1 ;
70 jop1 = new JOptionPane () ;
71 jop1 . showMessageDialog ( null , " P a r t i e Gagnee " , null , JOptionPane .←-
WARNING_MESSAGE) ;
72 projet . cycleStop () ;
73 }
74 }
75
76 @Override
77 public void cycleVecteur ( int actionX , int actionY ) {
78 vectX = actionX ;
79 vectY = actionY ;
80
81 // recupere la valeur de la variable x et y de la prochaine case que ←-
le pacman va atteindre
82 int x = getX () + vectX ;
83 int y = getY () + vectY ;
84 // si la couleur de cette case est rouge , le pacman sarrete et attend ←-
les commande du client
85 if ( projet . fondCouleur [ y ] [ x ] == 1) {
86 vectX = 0;
87 vectY =0;
88 }
89 }
90 }Vous pouvez aussi lire
