tablier

Bonsoir,

Supposons que nous ayant une TableDeJeu contenant de PionPosee. Un objet PionPosee est une objet de la classe PionPosee, qui correspond à un pion sur une casse.
Supposons qu'un objet PionPosee dispose d'une position (x,y) et d'une couleur

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
public classe PionPosee{
public class PionPosee {
	private int x, y;
	private boolean couleurRouge;
 
	public int getX() {
		return x;
	}
 
	public void setX(int x) {
		this.x = x;
	}
 
	public int getY() {
		return y;
	}
 
	public void setY(int y) {
		this.y = y;
	}
	public boolean isCouleurRouge() {
		return couleur;
	}
 
	public void setCouleurRouge(boolean couleurRouge) {
		this.couleurRouge = couleurRouge;
	}
}
}

Un objet TableDeJeu est un objet de la classe TableDeJeu, qui dispose d'une longueur, d'une largeur et d'une liste de PionPosee :

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
import java.util.List;
import java.util.ArrayList;
 
public class TableDeJeu {
	private int longeur, largeur;
	private List<PionPosee> listePionPosee = new ArrayList<PionPosee>();
 
	public int getLargeur() {
		return largeur;
	}
 
	public void setLargeur(int largeur) {
		this.largeur = largeur;
	}
 
	public int getLongeur() {
		return longeur;
	}
 
	public void setLongeur(int longeur) {
		this.longeur = longeur;
	}
 
	public List<PionPosee> getListePionPosee() {
		return listePionPosee;
	}
 
	public void setListePionPosee(List<PionPosee> listePionPosee) {
		this.listePionPosee = listePionPosee;
	}
}

Pour jouer, il nous une TableDeJeu :

Code:

1
2
3
4
	public TableDeJeu(int longeur, int largeur) {
		this.longeur = longeur;
		this.largeur = largeur;
	}

Code:

TableDeJeu maTableDeJeu = new TableDeJeu (7,7);

Lorsqu'un joueur va poser vouloir poser un pion, il va falloir savoir si il y a déjà un pion à la case demandé :

Code:

1
2
3
4
5
6
7
8
public boolean isOccuped(int x, int y) {
		for (PionPosee pion : this.getListePionPosee()) {
			if(pion.getX()== x && pion.getY() ==y){
				return true;
			}
		}
		return false;
	}

Si la case n'est pas occupé on ajouter à la TableDeJeu un nouveau pion à l'endroit voulu :

Code:

1
2
3
4
5
PionPosee pionAPoser = new PionPosee();
pionAPoser.setX(x);
pionAPoser.setY(y);
pionAPoser.setCouleurRouge(isCouleurRouge);
maTableDeJeu.getListePionPosee().add(pionAPoser);

Il nous reste à savoir si l'un des joueurs à gagner :
Pour cela il y a un certains nombre de petite méthode a crée voici l'ossature que je propose :

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
	public abstract List<PionPosee> getNextToHim (PionPosee pion, List<PionPosee> liste);
	public abstract List<PionPosee> getPionDeCouleurRouge (List<PionPosee> liste);
	public abstract List<PionPosee> getPionDeCouleurNonRouge (List<PionPosee> liste);
	public abstract boolean isPionCoteGauche(List<PionPosee> liste);
	public abstract boolean isPionCoteDroit(List<PionPosee> liste);
	public abstract boolean isPionCoteHaut(List<PionPosee> liste);
	public abstract boolean isPionCoteBas(List<PionPosee> liste);
 
	public  boolean couleurRougeGagnant(){
		List<PionPosee> listPionRouge = this.getPionDeCouleurRouge(this.getListePionPosee());
		if(listPionRouge.size()==0){
			return false;
		}
		for (PionPosee pionPosee : listPionRouge) {
			ArrayList<PionPosee> amaDePion = new ArrayList<PionPosee>();
			this.addPionNextToHim(pionPosee, listPionRouge, amaDePion);
			if(this.isPionCoteHaut(amaDePion) && this.isPionCoteBas(amaDePion)){
				return true;
			}
		}
		return false;
 
	}
 
	public void addPionNextToHim(PionPosee pion, List<PionPosee> liste, List<PionPosee> ama){
		List<PionPosee> nextTo = this.getNextToHim(pion, liste);
		for (PionPosee pionPosee : nextTo) {
			if(!ama.contains(pionPosee)){
				ama.add(pionPosee);
				this.addPionNextToHim(pionPosee, liste, ama);
			}
		}
	}
 
 
 
	public abstract boolean couleurNonRougeGagnant();

L'idée étant d’identifiée des paquets de pions, puis de vérifier si pour un paquet donnée on touche les deux bords attendu.
Pour crée les paquets de pion, le principe suggérer est la propagation via une récursion.
Pour faire simple, chaque pion ajouter au paquet va ajouter les pions à côté de lui si il ne font pas déjà partie du paquet.
Récursion, car la méthode addPionNextToHim s'appelle elle-même.

Cordialement,
Patrick Kolodziejczyk.