Discussion :

[joel.drigo]

Non, il est plus logique de faire avance une tortue, donc une instance de Tortue. Que le maitre du jeu ait une méthode qui permette de passer de la couleur à la tortue et inversement, oui, ça serait utile.

Le Joueur a un attribut Couleur : il pourrait avoir un attribut Tortue à la place, et qui ne soit pas passer au constructeur, ce qui lui permettrait de choisir sa couleur plus tard qu'à la construction (donc avec setTortue(Tortue tortue) et Tortue getTortue(). Mais c'est un détail : admettons qu'il ait une propriété Couleur.

Pour que MaitreDuJeu retrouve la Tortue correspondante, on pourrait avoir :

Code :

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

1
2
3
4
5
6
7
8
public Tortue getTortue(Joueur joueur) {
    for(Tortue tortue : tortues) {
         if ( joueur.getCouleur()==tortue.getCouleur() ) {
              return tortue; // on a trouver la tortue de la couleur correspondante à celle du joueur
         }
    }
    throw new IllegalStateException("Problème");
}

On peut réaliser ça de manière plus simple en utilisant une EnumMap à la place d'une liste de tortues.

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
public class MaitreDuJeu {
 
     private final EnumMap<Couleur> tortues = new EnumMap<>(Couleur.class);
 
     public MaitreDuJeu() {
          initialiserTortues();
          /* ... * /
     }
 
     private void initialiserTortues() {
         for(Couleur couleur : couleurs.values()) { // values() donne la liste de toutes les valeurs de l'enum
            if ( couleur!=Couleur.NEUTRE ) { // on ne doit pas créer une tortue de couleur NEUTRE (on pourrait aussi mettre un attribut dans Couleur pour dire                 que la couleur n'est pas valable pour une tortue)
                 tortues.put( couleur,  new Tortue(couleur) ); // on ajoute une Tortue de la couleur contenue dans la variable couleur
            }
       }
 
    // Pour obtenir une tortue pour un joueur
     public Tortue getTortue(Joueur joueur) {
            return tortues.get(joueur.getCouleur());
     }
 
}

[rodolph141]

Merci beaucoup pour ton aide !
Donc maintenant le méthode deplacerTortue fonctionne pour déplacer UNE tortue :

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 static void deplacerTortue(ECouleur c,EAction e){
	Tortue t=Tortue.getTortue(c);
 
	switch(e){
	case Avancer:
		//do{
			cases.get(t.getPosition()).ajouterTortue(t);
			cases.get(t.getPosition()-1).supprimerTortue(t);
			t.setPosition(t.getPosition()+1);
		//}while(cases.get(t.getPosition()-2).it.hasNext());
		break;
	case Reculer:
		cases.get(t.getPosition()-2).ajouterTortue(t);
		cases.get(t.getPosition()-1).supprimerTortue(t);
		t.setPosition(t.getPosition()-1);
		break;
	case AvancerX2:
		cases.get(t.getPosition()+1).ajouterTortue(t);
		cases.get(t.getPosition()-1).supprimerTortue(t);
		t.setPosition(t.getPosition()+2);
		break;
	case DernièreCase:
		cases.get(t.getPosition()).ajouterTortue(t);
		cases.get(t.getPosition()-1).supprimerTortue(t);
		t.setPosition(t.getPosition()+1);
		break;
	case DernièreCaseX2:
		cases.get(t.getPosition()+1).ajouterTortue(t);
		cases.get(t.getPosition()-1).supprimerTortue(t);
		t.setPosition(t.getPosition()+2);
		break;
	}
 
}

Le problème c'est que quand on déplace une tortue, et qu'il y a d'autres tortues dessus on doit pouvoir toutes les déplacer.

J'ai donc penser à créer un itérateur sur la liste Tortues, et ainsi utiliser la méthode hasNext() pour déplacer toutes les tortues qui sont sur la tortue que l'on veut déplacer.

Sauf que c'est la première fois que j'utilise cette méthode et j'ai un peu de mal.

J'ai fais comme ceci pour la déclaration :

Code :

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

1
2
3
4
5
public class Case {
 
	private  List<Tortue> Tortues=new LinkedList<Tortue>();
	private int num;
	Iterator<Tortue> it = Tortues.iterator();

Merci encore pour ton aide précieuse

[joel.drigo]

Je n'ai pas les règles en tête : tu veux dire que quand on déplace une tortue, les tortues se trouvant placées au-dessus doivent être déplacées aussi ?

Si les tortues d'une case sont stockées dans une List, on peut utiliser une caractéristique de List pour ça. En partant du principe qu'on ordonne les tortues de la plus basse à la plus haute dans la liste. On peut trouver la tortue à déplacer dans la liste par List.indexOf(Tortue). Et récupérer les tortues au-dessus par liste.subList(fromIndex, toIndex), ou fromIndex est le résultat de liste.indexOf(tortue à déplacer) et toIndex est la la taille de la liste (qu'on obtient par List.size()). Ensuite, on peut effectivement utiliser un itérateur (Iterator), mais on est pas obligé d'en créer un explicitement : le fait d'itérer sur une List par un "for each" créer un Iterator implicitement.

Si tu crées un Iterator explicitement, il faudra le créer dans la méthode de déplacement, et non pas en tant que variable membre comme tu le montres dans ton code (De manière général, crée toujours tes variables au plus proche de là où tu vas les utiliser, avec la portée minimum).

Donc, en résumé, on pourrait écrire :

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
public class Case {
 
    private List<Tortue> tortues=new ArrayList<>(); // les tortues sur la case
 
    /* ... */
 
   public List<Tortue> getTortueEtCellesAuDessus(Tortue tortue) {
 
         int fromIndex = tortues.indexOf(tortue);
         if ( fromIndex==-1 ) {
              // la tortue n'est pas sur la case
              throw new IllegalStateException("La tortue n'est pas sur la case"); // en théorie on devrait pas appeler cette méthode si la tortue n'est pas sur la case (on peut faire une méthode par contre pour le tester : voir juste après)
         }
         return new ArrayList<>( tortues.subList(fromIndex, tortues.size()); // on créé une nouvelle liste, ce qui permet de faire ce qu'on veut avec sans conflit avec la liste interne à la case (on ne peut pas itérer sur une liste pendant qu'on la modifie)
 
   }
 
   public boolean estSurLaCase(Tortue tortue) {
          return tortues.contains(tortue);
   }
 
 
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void deplacerTortue(Tortue t,EAction e){
 
	switch(e){
	case Avancer:
                List<Tortue> tortuesADeplacer = cases.get(t.getPosition()).getTortuesAuDessus(t);
                for(Tortue tortue : tortuesADeplacer) { // créer implicitement un itérateur et itére dessus
		   cases.get(tortue.getPosition()).ajouterTortue(tortue);
		   cases.get(tortue.getPosition()-1).supprimerTortue(tortue);
 		   tortue.setPosition(tortue.getPosition()+1);
                }
		break;
	case Reculer:
 
	}

Si tu veux, pour exemple, le code que ça donnerait avec un itéreteur explicite, le voici :

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
public void deplacerTortue(Tortue t,EAction e){
 
	switch(e){
	case Avancer:
                List<Tortue> tortuesADeplacer = cases.get(t.getPosition()).getTortuesAuDessus(t);
                for(Iterator<Tortue> tortueIterator = tortuesADeplacer.iterator(); tortueIterator.hasNext(); ) { // créer implicitement un itérateur et itére dessus
                   Tortue tortue = tortueIterator.next();
		   cases.get(tortue.getPosition()).ajouterTortue(tortue);
		   cases.get(tortue.getPosition()-1).supprimerTortue(tortue);
 		   tortue.setPosition(tortue.getPosition()+1);
                }
		break;
	case Reculer:
 
	}

Par contre, je pense qu'il y a un problème dans ton code :

Code :

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

1
2
3
4
 
		   cases.get(tortue.getPosition()).ajouterTortue(tortue);
		   cases.get(tortue.getPosition()-1).supprimerTortue(tortue);
 		   tortue.setPosition(tortue.getPosition()+1);

En toute logique, on devrait changer la position avant de faire le déplacement :

Code :

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

1
2
3
4
 
 		   tortue.setPosition(tortue.getPosition()+1); // on change la position
		   cases.get(tortue.getPosition()).ajouterTortue(tortue); // on pose la tortue sur la case suivante
		   cases.get(tortue.getPosition()-1).supprimerTortue(tortue); // on supprime la tortue de la case précédente

Ou plus proprement :

Code :

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

1
2
3
4
5
6
 
int position = tortue.getPosition();
cases.get(position).supprimerTortue(tortue); // on supprimer la tortue de la case où elle se trouve
position++; // on change la position
tortue.setPosition(position); 
cases.get(position).ajouterTortue(tortue); // on pose la tortue sur la nouvelle case

On pourrait faire encore mieux, afin de réutiliser :

Code :

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

1
2
3
4
5
6
7
private void deplacerTortue(Tortue tortue, int deplacement) {
int position = tortue.getPosition();
cases.get(position).supprimerTortue(tortue); // on supprimer la tortue de la case où elle se trouve
position+=deplacement; // on change la position
tortue.setPosition(position);
cases.get(position).ajouterTortue(tortue); // on pose la tortue sur la nouvelle case 
}

(ceci évite partiellement les risques erreurs d'incohérence - voir ma note en fin de message).

Ce qui permettrait de faire :

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 void deplacerTortue(Tortue t,EAction e){
 
	switch(e){
	case Avancer:
               deplacerTortues(t, 1);
		break;
	case Reculer:
                deplacerTortues(t, -1);
		break;
	}
/**
  * Déplacer toutes les tortues au dessus de t y compris t, d'un nombre de cases spécifié par deplacement (peut-être négatif)
  */
private void deplacerTortues(Tortue t, int deplacerment) {
                List<Tortue> tortuesADeplacer = cases.get(t.getPosition()).getTortuesAuDessus(t);
                for(Tortue tortue : tortuesADeplacer) { // créer implicitement un itérateur et itére dessus
                   deplacerTortue(tortue, 1);
                }
}
/**
  * Déplacer la tortue spécifiée d'un nombre de cases spécifié par deplacement (peut-être négatif)
  */
private void deplacerTortue(Tortue tortue, int deplacement) {
    int position = tortue.getPosition();
    cases.get(position).supprimerTortue(tortue); // on supprimer la tortue de la case où elle se trouve
    position+=deplacement; // on change la position
    tortue.setPosition(position);
    cases.get(position).ajouterTortue(tortue); // on pose la tortue sur la nouvelle case 
}

A noter, que, le fait de gérer la position d'une part comme attribut de tortue, et d'autre part comme attribut de Case peut poser des problèmes de cohérence (cela favorise les erreurs) : il faudrait éviter ce genre de modèle en s'arrangeant pour que la position soit stocker dans un état unique. La position dans la liste de case pourrait être suffisante. Mais tu pourras voir ça quand ton programme fonctionne : il te suffit de bien faire attention pour le moment à modifier les 2 états toujours en même temps.

[asurion]

Bonjour,
Nous avons terminé le programme hier, merci beaucoup pour ton aide.
Il manque des fonctionnalités mais le principe est la :

https://mega.co.nz/#!ekV0BDLa!VPvGVn...qjeaDep8MBc58A


Encore Merci