Jeu memory en java

**baffreux** · 21/10/2013, 11h47

Bonjour à tous,
je suis actuellement en train de suivre un projet ou l'objectif est de creer un jeu simple en java, ici un memory, qui affiche 3 forme aleatoire qui apparaissent puis disparaisse a la suite l'utilisateur doit ensuite retrouver la suite proposé

Donc j'ai créer une partie de code qui me permet de creer des formes aleatoire et j'aimerais savoir s'il y a possibilité de dessiner les formes dans un tableau. Le tableau serait pour pouvoir comparer ce que l'utilisateur rentre et savoir s'il a reussit le jeux. Mais je ne sais pas comment inclure ces formes dans mon tableau.

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
 
package jeremyravel;
 
import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Polygon;
import java.util.ArrayList;
 
public class test extends Applet {
 
 
	public void paint (Graphics g) {
		int a = (int) (Math.random() * 3 + 1 );
 
		switch (a) {
	    case 1:  
	    	drawRect(g);
	             break;
	    case 2: drawCircle(g);
	             break;
	    case 3:  drawPolygone(g);
	             break;
 
 
		}
 
	}
 
 
	public void drawRect(Graphics g)
	{
 
		int x= 0 ;  
		int y = 39;
 
	      // Dessiner un rectangle plein (4 point) et de dimensions (22,90).
	         Polygon rectangle = new Polygon();
	         rectangle.addPoint(x +396, y+=51);   // point haut gauche: x = 148, y = 90
	         rectangle.addPoint(x +496, y);           // point haut droite: x = 170, y = 90
	         rectangle.addPoint(x +496, y+=60);   // point bas droite: x = 170, y = 150
	         rectangle.addPoint(x +396, y);           // point bas gauche: x = 148, y = 150
	         g.setColor(Color.blue);                      // fond du rectangle
	         g.fillPolygon(rectangle);                     // remplissage
	         g.drawPolygon(rectangle);                // affichage
 
	}
 
	public void drawPolygone(Graphics g)
	{
	     int y = 39;
	     int x = 0 ;
 
	      // Dessiner un triangle plein (3points)
	         Polygon triangle = new Polygon();
	         triangle.addPoint(x +446, y+=51);      // point haut: x = 446, y = 90
	         triangle.addPoint(x +496, y+=60);  // point bas droite: x = 496, y = 150
	         triangle.addPoint(x +396, y);      // point bas gauche: x = 396, y = 150
	         g.setColor(Color.RED);     // fond du triangle
	         g.fillPolygon(triangle);      // remplissage
	         g.drawPolygon(triangle);      // affichage
 
	}
 
	public void drawCircle(Graphics g)
	{
 
		 int  x = 0;
	      int y = 39;
 
	      // Dessiner un ovale plein .
	      // dans ce cas l'ovale est un cercle (dim. 50X50)
	         g.setColor(Color.GREEN);           // couleur de remplissage (fond)
	         g.fillOval(x +450, y+=61, 50, 50); // remplissage (fill)
	         g.drawOval(x +450, y, 50, 50);     // affichage, dessiner (draw)	
	}
 
 
 
public static void main(String[] args)
{
	new test();
}
 
 
}

**joel.drigo** · 21/10/2013, 12h46

Salut,

tu n'a pas besoin de mettre tes formes dans un tableau, mais seulement un moyen de les identifier.

le plus simple dans ton cas, c'est d'utiliser le nombre que tu tires aléatoirement pour déterminer quelle forme dessiner : il suffit de stocker les différents nombres tirés lors d'une séquence (dans un tableau par exemple, si tu tire toujours 3 formes à chaque fois).

Quand tu proposes les séquences à reconnaître, ces séquences présentées correspondent elle aussi à des tableau de nombres

Ensuite, tu peux comparer les différentes valeurs du tableau correspondant à la séquence cliquée par l'utilisateur et le comparer aux valeurs du tableau stockant les numéros de formes sélectionnées aléatoire au début...

**baffreux** · 21/10/2013, 13h28

Merci de ta réponse,

alors j'ai essayer d'ameliorer mon code en suivant ta solution

Code :

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

1
2
 
String tab[];

Donc je creer un tableau
Puis pour chaque methode

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
	public void drawRect(Graphics g)
	{
 
		int x= 0 ;  
		int y = 39;
 
	      // Dessiner un rectangle plein (4 point) et de dimensions (22,90).
	         Polygon rectangle = new Polygon();
	         rectangle.addPoint(x +396, y+=51);   // point haut gauche: x = 148, y = 90
	         rectangle.addPoint(x +496, y);           // point haut droite: x = 170, y = 90
	         rectangle.addPoint(x +496, y+=60);   // point bas droite: x = 170, y = 150
	         rectangle.addPoint(x +396, y);           // point bas gauche: x = 148, y = 150
	         g.setColor(Color.blue);                      // fond du rectangle
	         g.fillPolygon(rectangle);                     // remplissage
	         g.drawPolygon(rectangle);                // affichage
	         tab[0] = "rectangle" ;
 
	}

Le probleme c'est qu'il me sort une erreur du type

Exception in thread "AWT-EventQueue-1" java.lang.ArrayIndexOutOfBoundsException: 0
at jeremyravel.test.drawRect(test.java:62)
at jeremyravel.test.paint(test.java:21)

Donc je dois faire une erreur, car il ne veut pas rentrer la valeur dans mon tableau.
Et sinon j'ai une autre question penses tu qu'il soit possible de faire apparaitre une forme genre 5s puis qu'ensuite elle disparaisse ?

**joel.drigo** · 21/10/2013, 14h26

Il suffit pas de déclarer un tableau par

Code :

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

String tab[];

Il faut aussi le créer par :

Code :

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

 tab = new String[ un nombre d'élément ];

Mais je pensais pas à un tableau de String :
Là tu as cette méthode :

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
public void paint (Graphics g) {
		int a = (int) (Math.random() * 3 + 1 );
 
		switch (a) {
	    case 1:  
	    	drawRect(g);
	             break;
	    case 2: drawCircle(g);
	             break;
	    case 3:  drawPolygone(g);
	             break;
 
 
		}
 
	}

donc tu as bien une équivalence 1 = rectangle, 2 = cercle, 3 = polygone
(il y plusieurs manières de gérer ça "proprement" en java ( enumération, classes dédiées) mais je pensais à une méthode plus basic pour toi :

Code :

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

1
2
3
4
5
6
7
public int[] creerSequence(int nombreDeFormes) {
    int[] formes = new int[nombreDeFormes]; // on créé un tableau de la taille nombreDeFormes
    for(int i=0; i<formes.length; i++) { // on remplit ce tableau...
         formes[i]=(int) (Math.random() * 3 + 1 ); //...avec des numéros de formes, tirés au hasard
    }
    return formes;
}

Si tu veux que chaque forme n'apparaisse qu'une fois dans une séquence :

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
public int[] creerSequence(int nombreDeFormes) {
    int[] formes = new int[nombreDeFormes];
    for(int i=0; i<formes.length; i++) {
         boolean formeChoisie=false;
         do {
            forme[i] = (int) (Math.random() * 3 + 1 );
            formeChoisie=true; // on suppose que cette forme est ok
            for(int j=0; j<i; j++ ) {
                if ( formes[j]==forme[i] ) {
                   formeChoisie=false; // forme déjà choisie
                   break; // va la peine de continuer à cherche, on sait déjà qu'on va devoir rechoisir
                }
            }
         } while(!formeChoisie); // on boucle tant qu'on a pas choisie une forme
    }
    return formes;
}

et qui s'appellera comme ça :

Code :

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

sequenceChoisie = creerSequence(3);

pour trois formes...et ou sequenceChosie est un tableau de int (int[])

Tu peux utiliser la même méthode pour créer la séquence à afficher au début, en affichant chaque forme l'une après l'autre (ce que ne fait pas vraiment le programme que tu as fait au début qui va afficher une forme différente chaque fois le composant va se redessiner) et également pour les séquences à présenter au joueur à la fin (dont l'une sera la séquence tirée au hasard au début).

Pour faire défiler les formes, il faut que tu fasses un système qui incrémente un index, pour afficher successivement les différentes formes : sequence[0], puis sequence[1], puis sequence[2].

Il te faut donc un index de forme courante, un int dans ta classe d'affichage, et que tu utiliseras dans ta méthode paint à la place de ton a tiré au hasard.
private int indexFormeCourante=-1;

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
public void paint (Graphics g) {
 
        // il faudra penser à effacer le dessin précédent, sinon les formes vont se superposer...
 
                if ( sequenceChoisie!=null && indexFormeCourante>=0 && indexFormeCourante<sequenceChoisie.length ) {
		int a = sequenceChoisie[indexFormeCourante];
 
		switch (a) {
	    case 1:  
	    	drawRect(g);
	             break;
	    case 2: drawCircle(g);
	             break;
	    case 3:  drawPolygone(g);
	             break;
 
 
		}
}
 
	}

Pour faire défiler les formes, il faut incrémenter index jusqu'à à la taille de sequenceChoisie[].
Pour ça, il te faut soit utiliser un Thread, soit un Timer, pour afficher chaque forme un certain temps, à moins que tu veuilles que la forme change sur pression d'une touche au clavier... mais si j'ai bien compris tu veux que les formes s'affiche pendant un temps limité :

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
public void lancerJeu() {
    sequenceChoisie  = creerSequence(3);
    new Thread() {
       public void run() {
 
             for(int i=0; i<sequenceChoisie.length; i++ ) {
                   indexFormeCourante=i;
                   repaint();
                  try {
 sleep(500);  // on affiche la forme pendant 1/2 secondes (500 ms)
} 
catch(InterruptedException e) { 
break; 
};
             }
indexFormeCourante=-1;
 
       }
    }.start();
}

**baffreux** · 21/10/2013, 15h13

Merci de m'accorder autant d'aide,
bon j'ai quelques questions

Ensuite ta methode new game, si j'ai bien compris je dois l'appeler dans le main c'est ca ?

**joel.drigo** · 21/10/2013, 15h19

Envoyé par baffreux

Merci de m'accorder autant d'aide,
bon j'ai quelques problèmes :

Code :

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

sequenceChoisie =  creerSequence(3); // Une erreur de type Return type for the method is missing

Donc j'ai cette première erreur qui m'empeche d'avancer =/
Ensuite ta methode new game, si j'ai bien compris je dois l'appeler dans le main c'est ca ?

j'ai mis quelques bribes de codes, à toi de t'en inspirer, de les assembler, de déclarer les variables aux bons endroits etc... désolé, je ne peux pas passer plus de temps pour plus de détail et d'explication, pour le moment...

**joel.drigo** · 21/10/2013, 19h41

Donc, maintenant que j'ai un peu de temps, revenons à nos moutons

On va reprendre à zéro histoire de :

- si j'ai bien compris (tu me dis si je me trompe) :
tu veux faire une applet avec un petit jeu qui se déroule en 2 phases
la première phase consiste à afficher des formes successivement un court laps de temps,
la seconde phase consiste à afficher des séquences de différentes formes, l'utilisateur devant choisir celle qu'il pense être celle qu'il a vu dans la première phase

Moi déjà, je séparerais l'affichage des deux phases dans 2 composants différents, des JPanel pour faire simple.

Le déroulement du jeu (ou d'une partie, parce que ce serait bien qu'il puisse jouer plusieurs fois) se déroulerait ainsi :

- on commence par un écran avec genre un bouton "Démarrer"
- après avoir cliquer sur "Démarrer",
- on tire une séquence de forme à afficher au hasard (qu'on mémorise dans la classe principale, donc ta classe applet)
- on "affiche" le panel de la phase 1, ce panel en fait ne fait qu'afficher une forme ou pas de forme
- on lance le thread, qui va afficher successivement les différentes formes puis à la fin, va remplacer le panel de la phase 1, par celui de la phase 2
ce panel de la phase 2 : affichera plusieurs séquence, en permettant à l'utilisateur de cliquer dessus (il a un temps limite ou pas là pour cliquer dessus ?)

je t'avais suggéré de mettre le tableau sequenceChoisie dans le composant de la phase 1 : on va faire plus simple : on va mettre que l'index de la forme à afficher

donc le panel :

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
 public class PanelPhase1 extends JPanel {
private int forme = -1;
 
public void setForme(int forme) {
this.forme=forme;
}
 
public void paint (Graphics g) {
 
     // on efface le fond
     Dimension size = getSize();
     g.setColor(getBackground());
     g.fillRectangle(0,0,size.getWidth(),size.getHeight());
 
		switch (forme) {
	    case 1:  
	    	drawRect(g);
	             break;
	    case 2: drawCircle(g);
	             break;
	    case 3:  drawPolygone(g);
	             break;
 
 
		}
 
	}

Dans ta classe principale, tu crées ce panel en tant que variable de classe

Code :

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

private PanelPhase1 panel1 = new PanelPhase1();

pour gérer le dessin de l'applet, comme on a différent panel à afficher successivement, on à 2 solutions :

- soit on utilise un BorderLayout et on remplace à chaque fois le composant situé au centre par le nouveau qu'on veut afficher
- soit on utilise un CardLayout, qui permet de mettre tous les composants les uns au dessus des autres, et d'en sélectionner un à afficher à la fois parmi

disons que pour faire simple, utilisons un borderlayout : à la création de l'applet, il suffit de faire :

Code :

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

setLayout(new BorderLayout());

et dans cette classe applet du met une méthode qui permet de lancer le jeu

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
public void lancerJeu() {
    sequenceChoisie  = creerSequence(3);
    new Thread() {
       public void run() {
 
             // donc là on affiche le panel de la phase 1 :
             add(panelPhase1, BorderLayout.CENTER);
 
             for(int i=0; i<sequenceChoisie.length; i++ ) {
                   panelPhase1.setForme(sequenceChoisie[i]);
                   repaint();
                  try {
 sleep(3000);  // on affiche la forme pendant 3 secondes (1/2 c'était un peu furieux ;))
} 
catch(InterruptedException e) { 
break; 
};
             }
panelPhase1.setForme(-1); 
 
add(panelPhase2, BorderLayout.CENTER); // puis on met le panel de la phase 2 à la place de celui de la phase 1
 
       }
    }.start();
}

pour le panel de la phase 2, il faut en fait afficher plusieurs séquences dont au moins la séquence tirée au hasard, mettons une par ligne, ce qui donne en gros une grille

il faut donc avoir une fonction de dessin de formes qui permettent de dessiner à différents endroits

donc reprenons ta méthode de dessin :

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
public void drawRect(Graphics g)
	{
 
		int x= 0 ;  
		int y = 39;
 
	      // Dessiner un rectangle plein (4 point) et de dimensions (22,90).
	         Polygon rectangle = new Polygon();
	         rectangle.addPoint(x +396, y+=51);   // point haut gauche: x = 148, y = 90
	         rectangle.addPoint(x +496, y);           // point haut droite: x = 170, y = 90
	         rectangle.addPoint(x +496, y+=60);   // point bas droite: x = 170, y = 150
	         rectangle.addPoint(x +396, y);           // point bas gauche: x = 148, y = 150
	         g.setColor(Color.blue);                      // fond du rectangle
	         g.fillPolygon(rectangle);                     // remplissage
	         g.drawPolygon(rectangle);                // affichage
	         tab[0] = "rectangle" ;
 
	}

y'a plein de chose à dire dessus :
1) pour dessiner un rectangle inutile de se compliquer la vie avec un polygone : il y a une méthode pour dessiner un rectangle
2) les trucs du genre y+=60 en paramètre ne servent qu'à compliquer la lecture : tu peux tout aussi bien les mettre à part
3) inutile de remplir, puis de dessiner le cadre dans la même couleur : le fill suffit
4) le x et y on va les mettres en arguments de la méthodes ce qui va permettre de l'appeler avec un x et y différents et donc de dessiner le rectangle à différents endroits (donc de faire une grille)
5) pour les dimensions, il faudrait établir une référence qui permettre d'avoir une grille entière, et pas coupée : donc prendre les dimensions que tu comptes donner à ton applet, diviser ce rectangle en case, et établir que la taille des cases constitue une taille de référence,
les formes devront être affichée un tout petit plus petite que cette taille pour ne pas se toucher, ce qui serait mieux esthétiquement parlant, genre on se prend une marge de 5 pixels :
- à moins que ton applet puisse prendre une taille variable, auquel cas, il faudrait calculer la taille max d'une forme dynamiquement, on peut utiliser des constantes pour commencer au moins.
donc

Code :

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

1
2
private static final int LARGEUR_CASE = 90;
private static final int HAUTEUR_CASE = 50;

par exemple, au lieu de mettre des coordonnées directement dans le code de dessin : à chaque fois qu'on veut changer cette taille on est obligé de la modifier à plein d'endroit...

dessiner un rectangle devriendrait, qu'on mettrait par exemple dans une classe Util à part

Code :

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

1
2
3
4
5
6
7
8
public static void drawRect(Graphics g, int x, y) {
     g.setColor(Color.BLUE);
 
     int largeur = LARGEUR_CASE - MARGE * 2;
     int hauteur = HAUTEUR_CASE - MARGE * 2;
 
 g.fillRect(x + (LARGEUR_CASE - largeur) /2, y+ (HAUTEUR_CASE - hauteur) /2 , largeur, hauteur) ;   // on centre le rectangle
}

le code dans PanelPhase1 devriendrait :

Code :

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

1
2
3
4
5
6
7
public void drawRect(Graphics g)
	{
 
 
	      Util.drawRect(g, 0, 39);
 
	}

et on pourrait réutiliser Util.drawRect() pour dessiner des rectangles à différents endroits dans PanelPhase2...

je te laisse méditer ça pour l'instance...mais tu as déjà plusieurs pistes pour avancer

**baffreux** · 21/10/2013, 22h30

Merci, je vais reflechir la dessus

Jeu memory en java

Applets Java

Discussions similaires

Partager

Partager