Discussion :

[Autofire]

Bonjour,

J'ai décidé de faire un morpion en java pour m'exercer. ( je commence par un truc simple pour ensuite faire des plus gros projets )
Je voudrais créer un code propre conceptuellement.

Je suis parvenu à faire fonctionner mon morpion et je voudrais votre avis.

Voila ce que j'ai fais ( ou que j'ai voulu faire car je ne sais pas si ma conception est correcte) :

- 1 classe = 1 service
- Séparation du modèle et de la vue (pattern MVC)
- Utilisation du pattern observer
- Je ne comprends pas à quoi sert le paramètre du notifyObservers dans l'objet observable donc j'ai mis un truc au pif (le plateau).
- Je voudrais savoir si vous auriez fait comme cela pour faire un morpion ?

Merci d'avance

Diagramme de classes :



La classe LancerJeu contient le main()

La classe AfficherPlateau est la vue, c'est un JFrame qui a un gridLayout(3,3)

La classe Plateau contient les données, accès aux cases et aux joueurs

La classe Case est un héritage de JButton à laquelle j'ai ajouté des coordonnées

La classe PlacerCase sert à placer soit une croix soit un rond selon le joueur actuel

La classe VerifierVictoire vérifie si un joueur a gagné et arrête le jeu si c'est le cas

Code de LancerJeu :

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 class LancerJeu {
 
	AfficherPlateau afficherPlateau;
	Plateau plateau;
 
	public LancerJeu(){
		plateau = new Plateau();
		afficherPlateau = new AfficherPlateau(plateau);
	}
 
	public static void main (String args []){
		LancerJeu lancerJeu = new LancerJeu();		
	}
 
 
}

Code de AfficherPlateau :

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
 
 
import java.awt.GridLayout; 
import javax.swing.JButton;
import javax.swing.JFrame;
import java.util.Observer;
import java.util.Observable;
 
public class AfficherPlateau extends JFrame implements Observer{
 
	Plateau plateau;
 
	public AfficherPlateau(Plateau plateau){
		this.plateau = plateau;
		afficher();
		init(plateau.placerCase);	
	}
 
	public void afficher(){
		this.setTitle("Morpion");
		this.setSize(500, 500);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setLocationRelativeTo(null);
		this.setLayout(new GridLayout(3, 3));
		for(int i=0; i < plateau.listeCases.size(); i++){
			this.getContentPane().add(plateau.listeCases.get(i));
		}
		this.setVisible(true);
 
	}
 
	public void init(PlacerCase signal) {
		signal.addObserver(this);
  }
 
	public void update(Observable observable, Object test) {
		revalidate();
		repaint();
  }
 
 
}

Code de plateau :

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
 
 
import java.util.ArrayList;
 
public class Plateau  {
 
	public ArrayList<Case> listeCases;
	public String joueur1;
	public String joueur2;
	public String joueurCourant;
	public PlacerCase placerCase;
	public VerifierVictoire verifierVictoire;
 
	public Plateau(){
		listeCases = new ArrayList<Case>();
		joueur1 = "toto";
		joueur2 = "titi";
		joueurCourant = joueur1;
		placerCase = new PlacerCase(this);	
		creerCases();
		VerifierVictoire verifierVictoire = new VerifierVictoire(this);
	}
 
	void creerCases(){
		for (int x = 0; x < 3; x ++){
			for(int y = 0; y < 3; y++){
				Case case1 = new Case(x,y);
				case1.addActionListener(placerCase);
				listeCases.add(case1);
			}
		}
	}
 
 
}

Code de case :

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
 
 
import javax.swing.JButton;
 
public class Case extends JButton {
 
	public int x;
	public int y;
 
	public Case(int x, int y){
		super("");
		this.x = x;
		this.y = y;
	}
 
	public void setText(String texte){
		super.setText(texte);
	}
 
}

Code de placerCase :

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
 
 
import java.awt.event.*;
import java.util.Observable;
 
public class PlacerCase extends Observable implements ActionListener {
	Plateau plateau;
 
	public PlacerCase(Plateau plateau){
		this.plateau = plateau; 
	}
 
	public void actionPerformed(ActionEvent e){
		if(plateau.joueurCourant == plateau.joueur1){
			((Case)e.getSource()).setText("X");
			plateau.joueurCourant = plateau.joueur2;
		}
		else {
			((Case)e.getSource()).setText("O");
			plateau.joueurCourant = plateau.joueur1;
		}
		setChanged();
		notifyObservers(this.plateau);
 
	}
}

Code de verifierVictoire :

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
 
 
import java.util.Observer;
import java.util.Observable;
 
public class VerifierVictoire implements Observer{
 
	Plateau plateau;
 
	public VerifierVictoire(Plateau plateau){
		this.plateau = plateau;
		init(plateau.placerCase);
		verifier();
	}
 
	public void verifier(){
		// arrête le jeu si les conditions de victoire sont remplis
		System.out.println("verification");
	}
 
	public void init(PlacerCase signal) {
		signal.addObserver(this);
  }
 
	public void update(Observable observable, Object test) {
		verifier();
  }
 
}

[francky74]

Bonjour,

Je n'ai pas encore tout regardé mais de prime abord, je trouve que la classe PlacerCase est mal nommée puisqu'on dirait le nom d'une méthode.
J'aurais plutôt créé une classe Case qui contient une méthode placerCase(positionX, positionY)

Ne penses-tu pas (ou ne pensez-vous pas ... pour les autres développeurs chevronnés) qu'il faudrait une classe Joueur ?
L'avantage d'une classe Joueur, c'est que tu peux avoir plus de joueurs et ainsi créer un tournoi géniaaaaal ! Dans ton code tu ne peux avoir que deux joueurs ... ce qui est déjà bien pour jouer au morpion

Au lieu de la classe verifiervictoire, j'aurais plutôt créé une classe Score qui contient une méthode verifierVictoire() !
Cette classe peut alors contenir des méthodes telles que :
addScore(int nbrePoints) //méthode qui prend un nombre de points en paramètre et qui augmente le score du nombre de points.
substractScore(nbrePoints) //méthode qui prend un nombre de points en paramètre et qui diminue le score du nombre de points.



Bon courage !

[kevin254kl]

Bonjour,

Pourquoi ne pas intégrer une IA avec un algorithme Alpha Beta ?

[Autofire]

Bonjour,

Je n'ai pas encore tout regardé mais de prime abord, je trouve que la classe PlacerCase est mal nommée puisqu'on dirait le nom d'une méthode.
J'aurais plutôt créé une classe Case qui contient une méthode placerCase(positionX, positionY)

Ne penses-tu pas (ou ne pensez-vous pas ... pour les autres développeurs chevronnés) qu'il faudrait une classe Joueur ?
L'avantage d'une classe Joueur, c'est que tu peux avoir plus de joueurs et ainsi créer un tournoi géniaaaaal ! Dans ton code tu ne peux avoir que deux joueurs ... ce qui est déjà bien pour jouer au morpion

Au lieu de la classe verifiervictoire, j'aurais plutôt créé une classe Score qui contient une méthode verifierVictoire() !
Cette classe peut alors contenir des méthodes telles que :
addScore(int nbrePoints) //méthode qui prend un nombre de points en paramètre et qui augmente le score du nombre de points.
substractScore(nbrePoints) //méthode qui prend une nombr de points en paramètre et qui diminue le score du nombre de points.



Bon courage !

Bonsoir, merci d'avoir répondu

En fait pour placer la "case" (une croix ou un rond), je n'ai pas besoin des coordonnées en x,y. Le joueur clique sur une case, il y a un listener qui appelle une action qui modifie le texte dans le JButton via la méthode setText et le JFrame se remet à jour pour avoir le nouvel affichage.

Pour la classe Joueur, effectivement elle serait utile pour un tournoi. Il faudrait aussi une base de données pour sauvegarder les informations du tournoi.

kevin254kl > C'est une bonne idée, je viens de voir qu'il est expliqué sur wikipédia

[kolodz]

Bonjour,

Personnellement, je n'aime pas la conception que tu présentes. Il n'y a pas de séparation entre les différents aspects de ton programme (modèle, vue, contrôleur). Pire, tu bases l'ensemble de ton développement sur une implémentation spécifique.

Ton "modèle métier" devrait être jouable sans ton interface graphique.

Dans un premier temps, il serait possible de de découpler l'IHM du modèle métier en ajoutant la notion de "grille". Ainsi, un plateau de jeu (composant graphique) afficherait la grille de jeu (composante métier).

Logiquement, la grille de jeu devrait avoir les actions jouer(x,y) qui potentiellement retournent une exception ou un boolean pour indiquer que le coup n'est pas possible. Cette même grille devrait pouvoir avoir une méthode getStatus(), qui retourne la valeur d'un enum Status avec les valeurs (en cours, victoire_joueur_1, victoire_joueur_2,match_nul).
L'idée étant d'avoir un vrai objet métier, avec du comportement.

Si tu fais de la programmation objet et qu'aucun de tes objets métiers n'a pas à la fois des attributs et du comportement, alors, tu ne fais pas de la programmation objet.

Cordialement,
Patrick Kolodziejczyk.

[francky74]

Bonsoir,

Voici une classe joueur que tu pourrais utiliser et apporter des modifs :

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
package modele;
 
public class Joueur {
	//ATTRIBUTS
	private static String prenom;
	private static byte nbreJoueurs;
 
	//CONSTRUCTEUR
	public Joueur(String prenom) {
		setPrenom(prenom);
		setNbreJoueurs((byte) (getNbreJoueurs() + 1));
	}
 
	//GETTERS & SETTERS
	public static String getPrenom() {
		return prenom;
	}
 
	public static void setPrenom(String prenom) {
		Joueur.prenom = prenom;
	}
 
	public static byte getNbreJoueurs() {
		return nbreJoueurs;
	}
 
	public static void setNbreJoueurs(byte nbreJoueurs) {
		Joueur.nbreJoueurs = nbreJoueurs;
	}
}

et voici une classe Score qui pourrait aussi être utilisée:

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
package modele;
 
public class Score {
 
	//ATTRIBUTS
	private static byte idJoueur;
	private static int lettresTrouvees;
	private static int motsTrouves;
	private static int totalScore;
 
	//CONSTANTES
	private static final int initialScore = 0;
 
	//CONSTRUTEURS
	public Score (byte idJoueur) {
		setIdJoueur(idJoueur);
	}
 
	//METHODES
	public void addToScore(int points) {
		setTotalScore(getTotalScore() + points);		
	}
 
	public void substractFromScore(int points) {
		setTotalScore(getTotalScore() - points);
	}
 
	public void resetScore () {
		setTotalScore(initialScore);
	}
 
	//GETTERS & SETTERS
	public static byte getIdJoueur() {
		return idJoueur;
	}
 
	public static void setIdJoueur(byte idjoueur) {
		Score.idJoueur = idJoueur;
	}
 
	public static int getLettresTrouvees() {
		return lettresTrouvees;
	}
 
	public static void setLettresTrouvees(int lettresTrouvees) {
		Score.lettresTrouvees = lettresTrouvees;
	}
 
	public static int getMotsTrouves() {
		return motsTrouves;
	}
 
	public static void setMotsTrouves(int motsTrouves) {
		Score.motsTrouves = motsTrouves;
	}
 
	public static int getTotalScore() {
		return totalScore;
	}
 
	public static void setTotalScore(int totalScore) {
		Score.totalScore = totalScore;
	}
}

tu peux sauvegarder les infos sous forme de fichier xml ou txt !

[Autofire]

D'accord merci à vous deux je vais regarder ça

[joel.drigo]

Salut,

Voici une classe joueur que tu pourrais utiliser et apporter des modifs :

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
package modele;
 
public class Joueur {
	//ATTRIBUTS
	private static String prenom;
	private static byte nbreJoueurs;
 
	//CONSTRUCTEUR
	public Joueur(String prenom) {
		setPrenom(prenom);
		setNbreJoueurs((byte) (getNbreJoueurs() + 1));
	}
 
	//GETTERS & SETTERS
	public static String getPrenom() {
		return prenom;
	}
 
	public static void setPrenom(String prenom) {
		Joueur.prenom = prenom;
	}
 
	public static byte getNbreJoueurs() {
		return nbreJoueurs;
	}
 
	public static void setNbreJoueurs(byte nbreJoueurs) {
		Joueur.nbreJoueurs = nbreJoueurs;
	}
}

Comment avoir plusieurs joueurs de prénoms différents, avec un prénom statique ?

Même question au sujet du Score.