Discussion :

[kahrah]

Bonjour,

J'ai un programme à réaliser dont voici l'énoncé :

• Il y a un tableau de 7 colonnes et 7 lignes.
• Chaque joueur est représenté par une couleur, par exemple Bleu et Rouge. Les joueurs possèdent des pions à leur couleur, qu’ils disposent tour à tour sur une case de leur choix et un par un. Le tablier se remplit ainsi progressivement.
• L’objectif du joueur Bleu est de relier le coté droit et le coté gauche, tandis que le joueur Rouge doit relier le coté en bas avec le coté en haut.
• Un joueur gagne quand la configuration des pions permet la création d’une ligne continue de sa couleur reliant un coté à l’autre.

Pour l'instant j'ai réussi à créer une fonction avec un tableau à deux dimensions et une boucle "for" mais ensuite, je n’arrive pas à trouver la méthode qu'il faut dans la boucle for.

Quelqu'un saurait-il m'indiquer comment procéder ?

Merci d'avance pour votre aide.

[kolodz]

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 :

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

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

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

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

Code :

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

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 :

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

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 :

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

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 :

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