Intelligence artificielle dans un jeu

Version imprimable

12/03/2015, 23h22
Azumii

Intelligence artificielle dans un jeu
Bonsoir,
Je crée en ce moment , pour mon cours, un morpion avec interface graphique. Tout fonctionnait bien jusqu'à ce qu'on me demande d'y inclure une IA. L'ayant déjà fait auparavant pour un jeu, en version console, je me suis dit que ce ne serait pas très compliqué : créer deux nouvelles classes: Humain et Ordinateur qui héritent de la classe Joueur; puis redéfinir pour chaque classe la méthode jouerCoup(). Cependant, je ne sais pas comment le faire en version graphique. En effet, en version graphique c'est ma classe CaseGraphique qui déclenche la méthode jouerCoup() (qui se trouve dans ma classe MorpionGraphique ) grâce à ActionListener (dès que l'utilisateur clic sur une case). Le problème est que, quand c'est au tour de l'ordinateur de jouer il n'y a pas d'interaction avec la souris, et donc la méthode jouerCoup() n'est pas déclenchée. Auriez-vous des idées?

De plus , j'ai un deuxième problème: ce bout de code fait parfois buger mon jeu (qui ne répond plus du tout )
Code:

1 2 3 4 5 6 7 boolean probleme=false; do { try{ maMethode(); }catch(CoupInvalideException e) { probleme=true; } }while(probleme);
Si je ne me trompe pas, le problème vient de la boucle do..while. Sauriez-vous pourquoi?

Merci pour votre aide.

Salut,

Premièrement, pour ta boucle : en cas d'exception, probleme devient true, donc ça recommence. Mais il y a rien qui fait revenir probleme à false : donc il reste à true, et, donc, même s'il n'y a plus d'exception, ça continue de boucler indéfiniment.
Code:

1 2 3 4 5 6 7 boolean probleme=false; do { probleme = false; // toujours remettre à false avant de recommencer try{ maMethode(); }catch(CoupInvalideException e) { probleme=true; } }while(probleme);
Mais de toute manière, c'est toujours une mauvaise idée de faire un algorithme fondé sur des exceptions : il vaut mieux avoir un état qui dit qu'on a trouvé un coup valide. Les exceptions c'est fait pour traiter les erreurs, pas la recherche d'un coup "valide".

Sinon, pour le procédé de jeu alternant un coup par interaction graphique, puis un coup de l'ordinateur, le principe de base est d'avoir : une méthode qui fait jouer l'ordinateur (mettons qu'elle s'appelle ordinateurJoue()), et une pour faire jouer l'utilisateur (mettons qu'elle s'appelle joueurJoue()).

Le principe algorithmique est :
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 33 34 35 démarrer partie () { si ( ordinateur commence à jouer ) { ordinateurJoue(); } } ordinateurJoue() { bloquer l'ui (bloquer les interactions de l'utilsateur = par exemple, setEnabled(false) - enfin seulement celles qui servent à jouer, bien sûr faire tourner l'ia et appliquer le résultat si ( ordinateur gagne ) { arrêter partie et afficher résultat } sinon { débloquer l'ui } } joueurJoue() { faire l'action correspondant au choix du joueur si ( le joeur a gagné ) { arrêter partie et afficher résultat } sinon { ordinateurJoue(); } } actionListener() { actionPerformed() { joueurJoue(); } }

Merci joel.drigo, l'erreur était vraiment bête. En fait, j'ai réussi à mettre en place mon IA, mais d'une manière pas très "propre".. J'ai fait en sorte que l'utilisateur qui commence la partie, soit toujours un humain. Ainsi, dès qu'il clique sur une case, la méthode jouerPartie() se déclenche:
Classe MorpionGraphique

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
33
34
35
36
37
38
39
 
public void jouerPartie(int caseId){
		 if(partieEnCours){
				 try{
					 	getJoueurCourant().placerCoup(plateau.getCases(caseId)); // placerCoup vérifie si la case est vide, et si oui place le coup
                                        	changerJoueurCourant();
                                        	fenetre.setWarning("A "+joueurCourant+" de jouer");
                     	               }catch(CoupInvalideException e){
					 	fenetre.setWarning("Attention case invalide. "+joueurCourant+" essaie encore !");
 
				 }
				 siFinPartie();// vérifie si : le joueur a gagné ou si le plateau est plein
 
				 iaToPlay();
 
		 }
		 siFinPartie();
 
	}
 
public void iaToPlay() {
 
		 if (partieEnCours){
			 if(!getJoueurCourant().getEstHumain()){ // si le joueur courant est un ordinateur
					boolean problem=false;
					do {
						try{
						problem=false;
						 getJoueurCourant().placerCoup(plateau.getCases(getIndexCase())); // pour le moment la méthode getIndexCase() renvoie un nombre aléatoire grâce à random
 
					 }catch(CoupInvalideException e){
						 	problem=true;
					 }
				 }while(problem);
					changerJoueurCourant();
					fenetre.setWarning("A "+joueurCourant+" de jouer");
			 }
		 }
	 }

Le problème de cette méthode est que c'est l'action de l'utilisateur humain, quand il clique sur une case qui déclenche l'action de l'ordinateur..
Ta méthode me semble donc beaucoup mieux. Mais comme je l'ai précisé , j'ai un problème de classe.
Class CaseGraphique :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
JButton caseGraphique;
public CaseMorpionGraphique(int ident, MorpionGraphique m){
// Ici les paramètres du JButton
caseGraphique.addActionListener(new ActionListener(){
 
            public void actionPerformed(ActionEvent e){                   
                    morpionG.jouerPartie(getId());       
            }
 
		});
}

Or, si j'ai bien compris il faudrait que le ActionListener soit dans ma classe MorpionGraphique (voir code ci-dessus)et non dans le constructeur de CaseGraphique. Mais alors je ne vois pas du tout , en étant en dehors de la classe CaseGraphique, comment lui dire que dès qu'on clique sur une case alors [..]

Dans ton cas particulier, j'ai l'impression qu'il suffit de passer morpiong au constructeur ou que m porte la méthode jouerPartie, mais ce n'est pas très clair dans ce code :
Code:

1 2 3 4 5 6 7 8 9 10 11 JButton caseGraphique; public CaseMorpionGraphique(int ident, MorpionGraphique m){ // Ici les paramètres du JButton caseGraphique.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){ morpionG.jouerPartie(getId()); } }); }
qu'est-ce que morpiongG ?
qu'est ce que MorpiongGraphique (une sorte de classe étendant JPanel, c'est ça ?)
où est créé le JButton ?

Sinon, il faudrait prendre le problème de la modélisation dans l'autre sens (je veux dire ne pas se poser de question du genre "dans quelle classe je mets mon écouteur pour qu'il ait accès à telle ou telle classe"). Il faut séparer les fonctions, et les rendre les moins dépendantes possibles les unes des autres, en concentrant les dépendances dans quelques classes chargées de faire le lien entre les autres.

Classiquement, on utilise le modèle MVC (Modèle, vue, contrôleur) :

le modèle c'est les informations qu'on manipule (qui seront affichées, ou saisies, ou annexes - par exemple, la grille avec des ronds et et des croix, l'information qui dit que le joueur joue ou l'ordinateur joue, l'information qui dit qui a gagné, etc...)
la vue c'est l'affichage et les composants d'interaction (ce qui est cliquable par exemple) : elle affiche des informations du modèle.
le contrôleur c'est celui qui fait le lien entre vue et modèle en ce qui concerne les interactions :

il met à jour le modèle en fonction des saisies dans la vue (lorsque le joueur joue)
il met à jour la vue lorsqu'il ne s'agit pas d'affichage directe d'information (comme par exemple : bloquer l'ui quand l'IA joue)
il discute avec l'IA pour mettre à jour

L'implémentation la plus simple est une classe pour chaque : une pour le modèle, une pour la vue, une pour le contrôleur. Pour interagir avec le modèle, le contrôleur doit connaitre le modèle : donc avec une référence dessus : donc on passe l'instance de modèle au constructeur du contrôleur.
Il est assez classique la classe pour le contrôleur soit une classe interne de la vue pour que la classe du contrôleur puisse avoir accès à tous les composants graphiques de la vue (des variables membres privées de la vue) : ça évite d'exposer les composants graphiques en variables membres publiques ou à faire plein d'accesseur. Le contrôleur est en quelque sorte la combinaison des tous les listeners de tous les composants de la vue. Dans ton cas, comme il doit intérargir avec l'IA qui devrait être une classe à part, éventuellement intégré dans une classe chargée de traiter le jeu lui-même (appelons là GameEngine) : donc on doit aussi le passer au constructeur du contrôleur. Comme le contrôleur est une classe interne de la vue, on passera tous les paramètres du constructeur du contrôleur au constructeur de la vue pour qu'elle puisse instancier le contrôleur.

Exemple résumé :
Code:

1 2 3 4 5 6 7 public class Model { // des variables qui représente les informations qu'on a besoin de manipuler, afficher, etc. // les méthodes qui permettent de modifier ces variables ou de les lire }
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 33 34 public class Vue [ public Vue(Model model, GameEngine engine) { // on créé les composants graphiques square = new ... // une case du jeu // controleur = new Controleur(model, engine); } private class Controleur { public Controleur(Model model, GameEngine engine) { le contrôleur créé et enregistre les écouteurs nécessaire... square.addActionListener( new ActionListener() { engine.joueurJoue... jeuOrdinateur = engine.ordinateurJoue... rafraichir vue... } ); } } }
Pour gérer la mise à jour de la vue par rapport aux modifications du modèle, un modèle évènementiel est plus pratique, mais si ça te semble trop complexe à mettre en place, il est nécessaire que toutes les modifications du modèle soient faites par le contrôleur qui s'occupera de rafraîchir la vue : le moteur d'IA ne doit donc surtout pas modifier le modèle directement dans ce cas, ou du moins s'il le fait, le contrôleur doit en être informé. On peut faire ça par exemple par retour d'appel de GameEngine par le contrôleur, ou tout simplement, à la bourrin, estimer qu'à chaque retour d'appel de l'IA, on raffraichit toute la vue (c'est plus simple, mais on peut faire beaucoup de rafraîchissement pour rien, ce qui peut dans le cas général être pénalisant pour les performances - dans le cas d'un morpion, c'est négligeable à priori). On évitera que le moteur de jeu, et donc l'IA, aient des références sur le contrôleur pour le rendre indépendant de l'IHM.

En fait, j'ai deux packages:
* jeu2joueurs : avec comme classe Joueur, Case, et Partie.
* morpion qui hérite de jeu2joueurs et qui possède pour la version console :

JoueurMorpion extends Joueur;
CaseMorpion extends Case;
PlateauMorpion;
Morpion extends Partie : initialise la partie, les joueurs, possède la fonction qui permet de savoir quand la partie est finie etc;
MorpionConsole extends Morpion : contient la fonction principale qui interagit notamment avec l'utilisateur;

Pour la version console;

JoueurPanel extends JPanel : permet de créer une fiche récapitulatif pour chaque jouer (nom, score , et notamment le choix : humain/ordi );
JoueurMorpionGraphique extends JoueurMorpion : attribue à chaque joueur une couleur;
CaseMorpionGraphique extends CaseMorpion : crée pour chaque case un boutton
PlateauMorpionGraphique extends PlateauMorpion;
MorpionFenetre extend JFrame: crée la fenetre de jeu;
MorpionGraphique extends Morpion : crée les 2 JoueurMorpionGraphique, crée le plateau de jeu, crée la fenetre, contient la fonction principale jouerPartie() et la fonction newPartie() qui permet de recommencer une partie.

Pour répondre à tes questions :

morpionG est une instance de MorpionGraphique (voir explication ci-dessus)
Le JButton est créé dans la classe CaseMorpionGraphique

Class CaseMorpionGraphique:

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
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
 
package morpion;
 
import jeu2joueurs.Joueur;
 
public class CaseMorpionGraphique extends CaseMorpion{
 
	JButton caseGraphique;
	private MorpionGraphique morpionG;
 
	public CaseMorpionGraphique() {
 
	}
 
	public CaseMorpionGraphique(int ident, MorpionGraphique m){
		super(ident);
		// On instancie un bouton contenant le numéro de la case
		// Grâce à la méthode String.valueOf qui converti un int en string
		caseGraphique = new JButton(String.valueOf(getId()+1));
 
		// Propriétés graphique du bouton
		caseGraphique.setBorder(new LineBorder(Color.BLACK,1));
		caseGraphique.setBackground(Color.WHITE);
		caseGraphique.setMinimumSize(new Dimension(20,20));
		caseGraphique.setPreferredSize(new Dimension(30,30));
		caseGraphique.setVisible(true);
 
		morpionG=m;
		// Interception des actions de l'utilisateur grâce au clic de la souris
		 caseGraphique.addActionListener(new ActionListener(){
 
            public void actionPerformed(ActionEvent e){                   
                    morpionG.jouerPartie(getId());       
            }
 
		});
	} 
 
	public JButton getButton() {
		return caseGraphique;
	}
 
	public JoueurMorpionGraphique getJoueur(){
        return (JoueurMorpionGraphique)super.getJoueur();
} 
 
	public void setColor(){
		caseGraphique.setBackground(getJoueur().getCouleur());
 
	}
 
	public void restart() {
		super.restart();
		caseGraphique.setBackground(Color.WHITE);
	}
 
	public void setEstLibre(boolean libre, Joueur j){
		super.setEstLibre(libre, j);
		if (estLibre()) {
			caseGraphique.setBackground(Color.WHITE);
		}
		else {
			setColor();
		}
 
	}
}

MorpionGraphique:

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
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
package morpion;
import jeu2joueurs.*;
 
public class MorpionGraphique extends Morpion {
 
 
	MorpionFenetre fenetre;
	boolean partieEnCours=true;
	boolean caseChoisie;
	int indexCase;
	CaseMorpionGraphique uneCase;
 
 
	public MorpionGraphique(){
	       super();
 
	       joueurs[0] = new JoueurMorpionGraphique(0, Color.RED, false);
	       joueurs[1] = new JoueurMorpionGraphique(1, Color.BLUE, true);
	       joueurCourant=new JoueurMorpionGraphique();
 
	       initJoueurs();
	       plateau=new PlateauMorpionGraphique(this);
	       fenetre=new MorpionFenetre(this);	
 
	}
 
	// Fonction permettant au joueur courant de jouer un coup
	public void jouerPartie(int caseId){
		 if(partieEnCours){
				 try{
					 	getJoueurCourant().placerCoup(plateau.getCases(caseId));
                     	changerJoueurCourant();
                     	fenetre.setWarning("A "+joueurCourant+" de jouer");
 
				 }catch(CoupInvalideException e){
					 	fenetre.setWarning("Attention case invalide. "+joueurCourant+" essaie encore !");
 
				 }
				 siFinPartie();
				 iaToPlay();
 
		 }
		 siFinPartie();
 
	}
 
	 public PlateauMorpionGraphique getPlateau(){
         return (PlateauMorpionGraphique) plateau;
     }
 
	 public JoueurMorpionGraphique getJoueur(int id){
	       return (JoueurMorpionGraphique)joueurs[id];
	 }
 
	 public void iaToPlay() {
 
		 if (partieEnCours){
			 if(!getJoueurCourant().getEstHumain()){
					boolean problem=false;
					do {
						try{
						problem=false;
						 getJoueurCourant().placerCoup(plateau.getCases(getIndexCase()));
 
					 }catch(CoupInvalideException e){
						 	//fenetre.setWarning("Attention case invalide. "+joueurCourant+" essaie encore !");
					 		problem=true;
					 }
				 }while(problem);
					changerJoueurCourant();
					fenetre.setWarning("A "+joueurCourant+" de jouer");
			 }
		 }
	 }
 
	 // Fonction permettant de recommencer une partie
	 public void restart() {
		 getJoueur(0).restart();
         getJoueur(1).restart();
         getPlateau().restart();
         caseChoisie=false;
         partieEnCours=true;
         newPartie();
	 }
 
	 public void siFinPartie() {
		 if(finPartie()){
			 changerJoueurCourant();
			 if (matchNul()){
				 fenetre.setWarning("Match nul");
				 partieEnCours=false;
			 }
			 else {
				 getJoueurCourant().setScore();
				 fenetre.setWarning(joueurCourant+ " a gagné! Bravo!");
				 partieEnCours=false;
			 }
 
		 }
	 }
 
	 // Fonction permettant de changer de joueur
	 public void changerJoueurCourant() {
		 super.changerJoueurCourant();
         setCaseEstChoisie(false);
	 }
 
	 public JoueurMorpionGraphique getJoueurCourant(){
         return (JoueurMorpionGraphique)joueurCourant;
	 }
 
	 public JoueurMorpionGraphique getJoueur1(){
         return (JoueurMorpionGraphique)joueurs[1];
	 }
 
	 public boolean caseEstChoisie() {
		 return caseChoisie;
	 }
 
	 public void setCaseEstChoisie(boolean c) {
		 caseChoisie=c;
	 }
 
	 // Fonction permettant de savoir si les joueurs ont fait match nul
	 public boolean matchNul() {
		 boolean resultat=false;
		 if (getJoueur(0).getCasesPossedees().size()+getJoueur(1).getCasesPossedees().size()==9 && joueurGagnant==null) {
			 resultat=true;
		 }
		 return resultat;
	 }
 
	 public int getIndexCase() {
			return indexCase= (int)(Math.random()*9);
 
		}
 
 
}

Il est vrai que j'ai déjà entendu parler du modèle MVC et qu'il s'agit certainement de la meilleure solution, mais si je comprends bien il va remplacer toutes mes classes : CaseMorpionGraphique, PlateauMorpionGraphique, JoueurMorpionGraphique etc.. ?

Je ne comprends donc pas où est ton problème. Tu as déjà l'actionListener enregistré sur le bouton et qui manipule la méthode qu'il doit en l'appelant sur l'instance de MorpionGraphique (ton GameEngine spécialisé version graphique) qui est passé en paramètre du constructeur...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 JButton caseGraphique; public CaseMorpionGraphique(int ident, final MorpionGraphique morpionG){ ... caseGraphique = new JButton(...); ... morpionG.getPlateau().add ( getId(), caseGraphique ) // ou un truc comme ça // Ici les paramètres du JButton caseGraphique.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){ morpionG.jouerPartie(getId()); } }); }

En effet, je n'ai plus de problèmes.. J'avais mal compris vos explications, mais après les avoir relus j'ai compris où ça coinçait . J'obtiens donc:
Classe MorpionGraphique: (GameEngine)

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
[..]
	public void start() {
		if(!getJoueurCourant().getEstHumain()) {
			iaToPlay();
		}
		else humainPeutJouer=true;
	}
 
	// Fonction permettant au joueur courant de jouer un coup
	public void jouerPartie(int caseId){
		 if(partieEnCours& humainPeutJouer){
				 try{
					 	getJoueurCourant().placerCoup(plateau.getCases(caseId));
                     	changerJoueurCourant();
                     	fenetre.setWarning("A "+joueurCourant+" de jouer");
 
				 }catch(CoupInvalideException e){
					 	fenetre.setWarning("Attention case invalide. "+joueurCourant+" essaie encore !");
 
				 }
				 siFinPartie();
				 iaToPlay();
 
		 }
		 siFinPartie();
 
	}
 
public void iaToPlay() {
 
		 if (partieEnCours){
			 if(!getJoueurCourant().getEstHumain()){
					boolean problem=false;
					do {
						try{
						problem=false;
						 getJoueurCourant().placerCoup(plateau.getCases(getIndexCase()));
 
					 }catch(CoupInvalideException e){
						 	//fenetre.setWarning("Attention case invalide. "+joueurCourant+" essaie encore !");
					 		problem=true;
					 }
				 }while(problem);
					changerJoueurCourant();
					fenetre.setWarning("A "+joueurCourant+" de jouer");
					humainPeutJouer=true;
			 }
		 }
	 }

Une dernière petite question, j'ai créé une classe JoueurPanel extends JPanel, qui créé une fiche de renseignement sur le joueur. C'est dans cette classe, grâce à deux JCheckBox que le joueur choisit l'identité des joueurs: humain ou ordinateur.

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
33
34
35
36
 
private JCheckBox ia= new JCheckBox("Ordinateur");
private JCheckBox human = new JCheckBox("Humain");
private JoueurMorpionGraphique unJoueur;
 
	 public JoueurPanel(JoueurMorpionGraphique j){
[..]
unJoueur=j; 
 JPanel humanOrIa = new JPanel();
	     humanOrIa.add(ia);
	     humanOrIa.add(human);
	     humanOrIa.setPreferredSize(new Dimension(100,20));
	     this.add(humanOrIa, BorderLayout.CENTER);
	     setVisible(true);
 
	        // Clic de la souris
	        ia.addActionListener(new ActionListener(){
	                public void actionPerformed(ActionEvent e){
 
	                        ia.setVisible(false);
	                        human.setVisible(false);
	                        unJoueur.setEstHumain(false); // Si la case ia est cochée le joueur est un ordinateur
	                }
	        });
 
	        human.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e){
                        ia.setVisible(false);
                        human.setVisible(false);
                        unJoueur.setEstHumain(true); // Si la case humain est cochée le joueur est un humain
 
                }
        }); 
 
 
	 }

J'aimerais m'assurer que le choix des joueurs : humain ou ordinateur ait été fait avant de commencer la partie ( sinon le joueur 1 est un ordinateur par défaut, et joue dès que la fenetre s'affiche, car j'ai du mettre le boolean estHumain par défaut à false, sinon j'avais une erreur "NullPointerException".. ). Comment faire?

13/03/2015, 14h40
joel.drigo

Je ne comprends pas : la fiche de renseignement s'affiche dans la fenêtre principale, la même où on joue, c'est ça ?

Ce serait plus simple de faire 2 fenêtres consécutives (un dialogue pour la saisie des renseignements qui s'affiche avant la fenêtre principale) : sinon, avoir 2 panels dans un CardLayout (le premier est la fiche et quand elle est validée, le plateau passe en premier plan). Par contre, pourquoi "la partie commence quand la fenêtre s'affiche" : ça devrait être plutôt "la fenêtre s'affiche quand la partie commence". Et la partie commence quand les paramètres sont saisis (joueur ou ia commence).

Oui c'est celà, ma fenetre affiche (de gauche à droite) un rectangle avec le nom, le score, et le choix IA/Humain du Joueur1, ensuite le plateau de jeu, puis un rectangle avec le nom, le score et le choix IA/Humain du Joueur2.
J'ai essayé de créer deux fenêtres mais impossible de basculer d'une à l'autre, et je ne comprends pas pourquoi..
En fait, le "rectangle avec les informations des joueurs" est une instance de JoueurPanel extends JPanel:

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
33
34
35
36
37
38
39
40
 
 protected JoueurMorpionGraphique unJoueur;
	 private JLabel nom; 
	 private  JTextField nomToString;
 
	 private JLabel scoreToString=new JLabel("0", JLabel.CENTER);
	 private JCheckBox ia= new JCheckBox("Ordinateur");
	 private JCheckBox human = new JCheckBox("Humain");
 
 
	 public JoueurPanel(JoueurMorpionGraphique j){
 
	     unJoueur=j; 
	     unJoueur.setJoueurPanel(this);
	     nom=new JLabel( unJoueur.toString(), JLabel.CENTER);
	     setBackground(unJoueur.getCouleur());
	     this.setLayout(new BorderLayout());
	     this.add(nom, BorderLayout.NORTH);
	     this.add(scoreToString, BorderLayout.SOUTH);
	     JPanel humanOrIa = new JPanel();
	     humanOrIa.add(ia);
	     humanOrIa.add(human);
	     humanOrIa.setPreferredSize(new Dimension(100,20));
            this.add(humanOrIa, BorderLayout.CENTER);
 
     // Clic de la souris
	       ia.addActionListener(new ActionListener(){
	               public void actionPerformed(ActionEvent e){
	                       unJoueur.setEstHumain(2);   // estHumain=2 quand c'est un ordinateur
	               }
	       });
 
	       human.addActionListener(new ActionListener(){ 
	           public void actionPerformed(ActionEvent e){
	                   unJoueur.setEstHumain(1);    // estHumain=1 quand c'est un humain
 
	           }
	   });
 
	 }

Ensuite j'ai une classe JoueurMorpionGraphique :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
	private Color couleur;
	JoueurPanel joueurPanel;
	private int estHumain=0;  // J'initialise estHumain à 0 
	public JoueurMorpionGraphique(){
        super();
	}
 
	public JoueurMorpionGraphique(int i,Color c){
        super(i);
        couleur=c;
        joueurPanel = new JoueurPanel(this);       
	}
// setters et getters

Puis j'ai ma classe FenetreJeu extends JFrame , qui crée donc deux JoueurPanel et affiche le plateau.

J'ai donc créer une nouvelle fenêtre : FenetreAccueil , avec seulement les deux JoueurPanel ( sans le plateau de jeu) et la condition que j'essaie d'utiliser dans mon GameEngine pour passer d'une fenetre à l'autre est :

Code:

1
2
3
4
5
 fenetreAccueil = new FenetreAccueil(this);
 if ((joueur1.getEstHumain() != 0) && (joueur2.getEstHumain =!0)) {
fenetreAccueil.setVisible(false); 
fenetreJeu = new FenetreJeu(this).
}

Mais ça ne fonctionne pas, et je n'arrive pas à trouver d'où vient l'erreur.

En y réfléchissant, je pense que l'erreur vient bien de ma condition , et pas du ActionListener sur le JCkeckBox ( que j'ai finalement modifié en JRadioButton) .
Rappel:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public MorpionGraphique(){ super(); joueurs[0] = new JoueurMorpionGraphique(0, Color.RED); joueurs[1] = new JoueurMorpionGraphique(1, Color.BLUE); joueurCourant=new JoueurMorpionGraphique(); getJoueur0().setEstHumain(1); initJoueurs(); plateau=new PlateauMorpionGraphique(this); fenetreAccueil=new FenetreAccueil(this); if ((getJoueur1().getEstHumain()!=0)||(getJoueur2().getEstHumain()!=0)) { fenetreAccueil.setVisible(false); fenetreJeu=new FenetreJeu(this); } }
Etant donné qu'au début tous les "EstHumain" sont initialisés à 0, on ne rentre pas dans la boucle if; il faut attendre que l'utilisateur est choisie une option pour que la valeur des estHumain soit modifiée. Peut être faudrait il ajouter une boucle do..while .. Je vais encore y réfléchir.

13/03/2015, 19h36
Azumii
C'est bon tout fonctionne! C'était tout bête, dès que l'utilisateur clique sur une case, j'appelle la fonction start():
Code:

1 2 3 4 5 public void start() { fenetreAccueil.setVisible(false); fenetreJeu.setVisible(true); // et puis le jeu peu commencer
Merci joel.drigo pour tout.