Intelligence artificielle dans un jeu

**Azumii** · 12/03/2015, 23h22

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 :

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

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.

**joel.drigo** · 13/03/2015, 00h19

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 :

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

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 pseudocode :

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
 
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();
    }
 
}

**Azumii** · 13/03/2015, 11h04

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 :

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
 
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 :

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

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 [..]

**joel.drigo** · 13/03/2015, 11h53

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 :

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

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 :

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

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 :

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
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.

**Azumii** · 13/03/2015, 12h56

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 :

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
 
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 :

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
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.. ?

**joel.drigo** · 13/03/2015, 13h48

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 :

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
 
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());       
            }
 
		});
}

Intelligence artificielle dans un jeu

Interfaces Graphiques en Java

Vue hybride

Discussions similaires

Partager

Partager