Discussion :

[FoxStyle]

Bonjour et bonsoir à toutes et à tous!

Alors voilà, je suis un jeune étudiant en informatique et pour réussir cette année il me faut rendre un jeu qui tourne. Ce jeu c'est le Quatro, une sorte de Puissance 4. La différence est que les pions ne sont pas seulement soit blanc soit noir, ils sont aussi soit grands soit petits, soit carrés soit ronds et soit creusés soit pleins.

Je rencontre divers problèmes durant mon codage et je crois que j'ai trop de questions. Les poser à mes amis étudiants fut une solution au début mais je crois que je prenais beaucoup trop de leurs temps, ce qui fait que je viens vers vous, Ô aide indispensable à ma réussite

Par contre, je ne viens pas demander des réponses toutes faites, des éclaircissements seraient parfaits!
Je vous remercie d'avance!

Je vous explique où j'en suis :

J'ai tout d'abord comme demandé sur ma feuille d'instructions crée quatre énumérations : filling, shape, color & size. Ces quatre énumérations, je les ai regroupées dans un objet Piece.

Donc une piece a une couleur, une taille, est pleine ou vide et a une forme.
Exemple : Piece = WHITE, HOLLOW, TALL & ROUND

Maintenant je dois créer une liste d'objets de types pieces et y mettre les 16pieces de types différents.
Voici mon code :

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
package quarto;
import java.util.ArrayList;
/**
 *
 * @author dell portable
 */
public class Stock {
    private ArrayList pieces;
 
    public Stock() {
        ArrayList<Piece> pieces = new ArrayList<Piece>(16);
        this.pieces.add(new Piece(Filling.HOLLOW, Shape.ROUND, Size.SHORT, Color.WHITE));
this.pieces.add(new Piece(Filling.HOLLOW, Shape.ROUND, 
        Size.SHORT, Color.WHITE));
this.pieces.add(new Piece(Filling.HOLLOW, Shape.ROUND, 
        Size.SHORT, Color.BLACK));
this.pieces.add(new Piece(Filling.HOLLOW, Shape.ROUND, 
        Size.TALL, Color.WHITE));
this.pieces.add(new Piece(Filling.HOLLOW, Shape.ROUND, 
        Size.TALL, Color.BLACK));
this.pieces.add(new Piece(Filling.HOLLOW, Shape.SQUARE, 
        Size.SHORT, Color.WHITE));
this.pieces.add(new Piece(Filling.HOLLOW, Shape.SQUARE, 
        Size.SHORT, Color.BLACK));
this.pieces.add(new Piece(Filling.HOLLOW, Shape.SQUARE, 
        Size.TALL, Color.WHITE));
this.pieces.add(new Piece(Filling.HOLLOW, Shape.SQUARE, 
        Size.TALL, Color.BLACK));
this.pieces.add(new Piece(Filling.SOLID, Shape.ROUND, 
        Size.SHORT, Color.WHITE));
this.pieces.add(new Piece(Filling.SOLID, Shape.ROUND, 
        Size.SHORT, Color.BLACK));
this.pieces.add(new Piece(Filling.SOLID, Shape.ROUND, 
        Size.TALL, Color.WHITE));
this.pieces.add(new Piece(Filling.SOLID, Shape.ROUND, 
        Size.TALL, Color.BLACK));
this.pieces.add(new Piece(Filling.SOLID, Shape.SQUARE, 
        Size.SHORT, Color.WHITE));
this.pieces.add(new Piece(Filling.SOLID, Shape.SQUARE, 
        Size.SHORT, Color.BLACK));
this.pieces.add(new Piece(Filling.SOLID, Shape.SQUARE, 
        Size.TALL, Color.WHITE));
this.pieces.add(new Piece(Filling.SOLID, Shape.SQUARE, 
        Size.TALL, Color.BLACK));
    }

Dans un premier temps, je me disais que c'était bête de tout marquer de cette manière. Imaginons que je doive coder un jeu qui regroupe 20 manieres différentes de faire un quatro...
Je vois bien un arbre où :

Code :

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

1
2
3
4
5
6
7
8
9
   PIECE
                                                                                              /        \
                                                                                     HOLLOW       SOLID
                                                                                      /       \         /     \
                                                                           ROUND      SQUARE
                                                                              /    \
                                                                      TALL        SHORT
                                                                     /     \
                                                                WHITE   BLACK

Mais logiquement je vois pas trop où je peux gagner du temps à faire les choses ainsi.

Ensuite en seconde question, on me demande de redéfinir toString() pour qu'elle retourne un String qui renseigne sur les caractéristiques des pieces de la liste sous la forme d'une liste numérotée.
Exemple :

0 WHITE SHORT HOLLOW SQUARE
1 WHITE TALL SOLID SQUARE
2 WHITE SHORT SOLID SQUARE
etc...

Mon probléme c'est que je comprends pas trop la méthode toString(). Donc je crois que ce bout de code est bon, mais comment faire une implémentation?
Je pourrais faire un :
-Pour i de 0 a 15 faire
piece i + filling + shape + size + color
-fin pour

Code :

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

1
2
3
4
5
6
@Override
    public String toString() {
       for (int i = 0; i<=15; i++){
        return i + filling + shape + size + color;
}    
    }

Mais là je me dis que tout part en couilles xD Car je return 15fois ce qui est totalement n'importe quoi. Devrais-je faire une liste que je convertisse en String? ou un Tableau?

Merci d'avance et désolé pour mon niveau :/

[Arislas]

Je vais essayer de répondre au problème de ton toString() :


On te demande que ton toString(), retourne un chaine de caractère contenant toutes les infos de chaque pièce non ? Je pense que tu 2 as de façon simple de faire ça :

- Tu créer une String et tu ajoute à la suite chaque caractéristiques de chaque pièces dans ta boucle( en utilisant le += pour concaténer), et après tu renvoie en une seul fois ta String.
- Tu créer un toString() dans ta classe pour la pièce qui renvoie une string contenant toutes les caractéristique de ta pièce, puis dans ton autre classe tu fait un toString() , tu reprend l'idée de la première solution, de façon que tu n'ai plus qu'à concaténer ta grand String, avec chaque toString() de tes pièces, puis tu return la String. ( c'est de l'optimisation)


Je ne suis pas sur d'avoir été très clair, si tu as besoin d'autres infos demande ^^

[FoxStyle]

Merci Arislas pour ta réponse!

Mais comment récupérer les éléments d'une liste un à un? Je veux dire, System.out.println(maListe) va me sortir toute ma liste. Puis-je utiliser ma liste comme un tableau? System.out.println(maListe[0]) ?

Merci d'avance!

EDIT :

Qu'en penses-tu?

Code :

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

1
2
3
4
5
6
7
8
9
10
   @Override
    public String toString() {
        grand = null;
       for (int i = 0; i<pieces.size(); i++){
       String petit = ""+i + pieces.get(i); 
           grand = grand + "/n" + petit;
 
}   
       return grand;
    }

[Arislas]

J'avais pas vu , oui ton code est à peu près bon, tu peu utiliser un ArrayList comme un tableau vu que c'est une sorte de tableau, ton code devrait donc fonctionner

Par contre c'est toi qui à créer l'arrayList ? Parce que tu devrait plutôt stocker la string contenant ( TAILLE ....) dedans plutôt que les pièces en elle-mêmes.

Sinon , si la méthode get() te return une String contenant les infos de la pièce alors oui ton code marche. Il ne te reste plus qu'à println() ta variable grand.

[FoxStyle]

Oui c'est moi qui aie créé cette ArrayList. Je ne comprends pas pour ce que tu dis ensuite. Ce serait mieux de mettre pieces.get(i).filling et les autres plutôt que la piece en elle-même c'est ça?

Et la méthode get() me retourne un objet Piece je crois, mais de ce que j'ai lu, String quelquechose = converti tout en String si tu débuts avec ""

[Arislas]

Il serait mieux de remplir ta liste de String du genre ( TALL BLACK HOLLOW ...), comme ça il te suffit de les récupérer dans ton toString() avec pieces[i] .

[FoxStyle]

Je suis obligé de faire une liste de pieces :/

[Arislas]

Ok, dans la classe pièce tu as une fonction pour transformer ta pièce en String ?

[FoxStyle]

Oui j'ai fait un toString()

Voici le code :

Code :

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

1
2
3
4
@Override
    public String toString() {
        return Piece.filling + Piece.shape + Piece.size + Piece.color
    }

Le must serait de récupérer ce toString() pour le toString() de la liste... Mais je ne vois pas vraiment comment utiliser cette méthode dans l'autre.

Devrais je faire quarto.Piece.toString() ?

Merci d'avance

[Arislas]

Pour reprendre ton code :

Code :

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

1
2
3
4
5
6
7
8
9
10
@Override
    public String toString() {
        grand = null;
       for (int i = 0; i<pieces.size(); i++){
       String petit = ""+i + pieces[i].toString(); 
           grand += "/n" + petit;
 
}   
       return grand;
    }

[joel.drigo]

Salut,

La méthode toString() ne doit retourner que la description d'une pièce, celle pour laquelle elle est appelée. C'est quand on affiche la liste de pièces (pieces dans Stock) que la liste de pièces s'affiche.

Donc dans Piece :

Code :

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

1
2
3
 public String toString() {
    return filling + " " + shape + " " + size + " " + color;
}

et dans Stock, pour le cas général :

Code :

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

1
2
3
public String toString() {
    return pieces.toString();
}

Ou pour le cas demandé

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
public String toString() {
    StringBuilder stringBuilder = new StringBuilder();
    boolean first=true;
    int n=1;
    for(Piece piece : pieces) {
       if ( first ) {
          first = false;
       }
       else {
          stringBuilder.append( "\n" );
       }
       stringBuilder.append(n++);
       stringBuilder.append(" ");
       stringBuilder.append(piece);
    }
    return stringBuilder.toString();
}

Ou

Code :

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

1
2
3
4
5
public String toString() {
   AtomicInteger n = new AtomicInteger();
   return pieces.stream()
                .map(piece-> n.incrementAndGet() + " " + piece )
                .collect( Collectors.joining("\n") ) )}

[FoxStyle]

Salut la compagnie!

Merci Arislas! Je vais esseyer le code!

Merci Joel.Drigo, mais le problème c'est que je ne comprends vraiment pas ton code. Le mien n'était pas correct?
Sinon peux-tu m'en dire plus sur les codes donnés?

Merci d'avance!

[joel.drigo]

Qu'est-ce que tu ne comprends pas dans mon code ?

Je rappelle la question

Ensuite en seconde question, on me demande de redéfinir toString() pour qu'elle retourne un String qui renseigne sur les caractéristiques des pieces de la liste sous la forme d'une liste numérotée.

Donc, il s'agit manifestement de rédéfinir la méthode toString() de la classe Stock, puisque c'est elle qui a un attribut liste de pièces, variable appelée pieces dans ton code.

Donc on doit avoir dans la classe Stock, ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public class Stock {
 
        // ici le reste de ton code
 
        public String toString()  {
 
              // ici un return d'une String qui représente la liste des pièces, précédées de leur numéro, à raison d'une pièce par ligne
 
        }
 
}

Donc pour coder la méthode toString(), il faut faire une boucle sur la liste piece (et surtout pas utiliser des bornes en dur, de 1 à 15, parce que si on a pas 15 pèces dans la liste, ça plante).
On doit créer une chaîne qui est la concaténation de plusieurs lignes, chacune correspondant à une pièce : donc on doit faire de la concaténation de chaîne dans un boucle sur la liste de pièces. On utilise un StringBuilder, quand on fait de la concaténation de chaîne dans une boucle : la concaténation de 2 variables String (ou plus) utilise implicitement un StringBuilder, donc quand on le fait dans une boucle, on va créer pour chaque concaténation un StringBuilder, donc plusieurs à cause de plusieurs concaténaitons et de la boucle. Donc autant utiliser un seul explicitement : ça n'a pas une très grande importance quand on a que quelques itérations, mais c'est une habitude qu'il vaut mieux prendre : l'exécution en sera plus rapide.

Ensuite, comme on doit avoir chaque ligne, l'une en dessous de l'autre, il faut les séparer par des retour-chariots (\n), à la fin de chaque ligne. Pour gérer ça, il faudrait qu'on teste si on est à la fin de la liste, pour savoir qu'on ne doit pas mettre de \n à la fin de la ligne. C'est plus simple de considérer qu'on met les \n avant chaque ligne, sauf avant la première, car il est plus simple de tester la première.

Enfin, dans cette liste de pièces, chaque pièce est représenté par une chaîne, qui consiste à une concaténation des valeurs de ses attributs : on pourrait faire cette concaténation dans la boucle, mais autant redéfinir la méthode toString de la classe Piece, comme ça, non seulement on pourra afficher la liste des pièces, mais on pourra afficher une pièce toute seule.

Donc le code de la méthode toString() de la classe Stock est comme ça

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
public String toString() {
    StringBuilder stringBuilder = new StringBuilder(); // on utilise un StringBuilder
    boolean first=true; // on sait qu'on commence toujours par la première ligne (évidence)
    int n=1; // pour pouvoir afficher un numéro devant chaque ligne
    for(Piece piece : pieces) { // on parcourt la liste
       if ( first ) { // si on est sur la première ligne, alors on ne sera plus sur la première après
          first = false; // donc on ne sera plus sur la première après
       }
       else {
          stringBuilder.append( "\n" ); // si on est pas sur la première ligne, alors on commence par \n
       }
       stringBuilder.append(n++); // puis on met le numéro de ligne, et on l'incrémente, pour n vaille 1, puis 2, puis 3, puis 4, etc.
       stringBuilder.append(" "); // ensuite une espace
       stringBuilder.append(piece); // puis le toString() (implicitement appelé) qui correspond à la pièce de la ligne
    }
    return stringBuilder.toString(); // on récupère la String qui correspond à ce qu'on vient de concaténer et on la retourne à l'appelant
}

Et pour la classe Piece, on concatène simplement ses 4 attributs :

Code :

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

1
2
3
4
5
6
7
8
9
public class Piece {
 
    // ...
 
    public String toString() {
        return filling + " " + shape + " " + size + " " + color;
    }
 
}

Et ce qui suit, c'est un moyen plus simple de faire la méthode toString() de la classe Stock, en Java 8 :

Code :

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

1
2
3
4
5
public String toString() {
   AtomicInteger n = new AtomicInteger();
   return pieces.stream()
                .map(piece-> n.incrementAndGet() + " " + piece )
                .collect( Collectors.joining("\n") ) )}

[FoxStyle]

Okay cool un grand merci! Ca m'apprend plein de choses ce StringBuilder!

J'avais un code qui fonctionnait mais pas assez remodelable si la liste est plus grande... Mais il fonctionne! Je vais réécrire le tien pour encore mieux l'assimiler.
Je continue mon projet et reviens vers vous pour le prochains soucis, merci encore les gars!

[FoxStyle]

Salut les gars, encore un souci mais d'une plus grande envergure. Grâce à vous je commence à mieux me débrouiller, pleins de choses ont été faites de mon côté, mais là je vous avoue être devant un mur.

Alors voilà, il me faut créer un plateau de jeu où les pieces seront mises. Ces pieces seront affichées selon la premiere lettre de leurs quatre caractéristiques.
Exemple :
Piece = HOLLOW SQUARE SHORT WHITE, il sera affiché :

Code :

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

1
2
H S
S W

Le plateau de jeu doit être fait avec des caracteres du genre :

Code :

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

1
2
3
4
5
   1  2  3
    _  _ _ 
1 |_|_|_|
2 |_|_|_|
3 |_|_|_|

Donc voilà, j'ai décidé de m'y coltiner, mais je suis aujourd'hui devant un problème.
En effet, j'ai tout d'abord décider de faire la structure complète, et quand je faisais les tests pour afficher le tableau, il n'y avait aucun souci.
Ensuite, j'ai fait les tests pour voir si, quand je mets une piece dans une case, si ca fonctionnait, et là encore aucun souci. Sauf que dans ce cas là, j'avais mis une pièce dans chaque case où j'avais prévu de mettre une pièce. Un exemple parlera mieux.

Comme vous pouvez le voir, ca tournait. Par flemme et envie de voir un résultat, je n'avais prévu des emplacements de pieces que pour ces deux pieces. Mais quand j'ai décidé de mettre des emplacements de pieces, mais sans y mettre de pièces, ca bloquait.


Je vois tres bien pourquoi, mon ajout envoie un null que mon board ne peut pas gérer... Mais quel serait la solution? Pouvez-vous m'éclairer?

Merci d'avance!

[joel.drigo]

(Mets ton code entre balise [CODE] (bouton #), parce que là, avec les copies d'écran, ce n'est pas pratique.)

Sur le principe, il suffit de gérer les cases vides en les éléminant par un test et en concaténant des espaces à la place, tout simplement.

Code :

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

1
2
3
4
5
if ( board[i][j]==null ) { // si la case est vide
    // aficher espaces...
} else {
    // afficher la piece dans board[i][j]
}

[FoxStyle]

C'était l'idée mais le souci c'est que je peux pas convertir un String en un objet Piece car Board est un tableau de Pièces :/

Une idée?
Merci d'avance et encore pour ton aide

[joel.drigo]

C'était l'idée mais le souci c'est que je peux pas convertir un String en un objet Piece car Board est un tableau de Pièces :/

Pourquoi convertir un String en objet Piece : même si c'est dans un certain sens possible, je ne vois pas à quoi ça servirait.

Démo (j'ai simplifié Piece, mais c'est pour le principe) :

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
public class Demo {
 
   public static void main(String[] args) {
 
      Piece[][] pieces = generer(); // génération aléatoire pour l'exemple.
 
      StringBuilder sb = new StringBuilder(); // pour construire le tableau
      StringBuilder ligne1 = new StringBuilder(); // pour construire la première ligne de chaque rangée
      StringBuilder ligne2 = new StringBuilder(); // pour construire la seconde ligne de chaque rangée
      for(int i=0; i<pieces.length; i++) {		
         if ( i==0 ) { 
            ligneHorizontal(sb, pieces[i].length); // la première bordure en haut	
         }
         ligne1.append("|"); // bordure à gauche première ligne
         ligne2.append("|"); // bordure à gauche seconde ligne
         for(int j=0; j<pieces[i].length; j++) {
            if ( pieces[i][j]!=null ) { // on ne traite que les cases non null, pour éviter le NullPointerException
               char[] values = pieces[i][j].getValues(); // on récupère les propriétés à afficher
               Arrays.sort(values); // pour avoir les lettres dans l'ordre
               ligne1.append(values[0]); // premier caractère dans première ligne
	       ligne1.append(" "); // espace de séparation au milieu
               ligne1.append(values[1]); // deuxième caractère dans première ligne
               ligne1.append("|"); // bordure droite première ligne
               ligne2.append(values[2]); // troisième caractère dans seconde ligne
	       ligne2.append(" "); // espace de séparation au milieu
               ligne2.append(values[3]); // quatirèe caractère  dans seconde ligne
               ligne2.append("|"); // bordure droite seconde ligne
           }
           else {
	       // on remplit les cases vides avec des espaces
	       ligne1.append("   |"); // 3 espaces + bordure droite
	       ligne2.append("   |");
	   }
         }
         sb.append(ligne1); // on ajoute la première ligne au tableau
         sb.append("\n"); // passage à la ligne
         ligne1.setLength(0); // reset
         sb.append(ligne2); // on ajoute la seconde ligne au tableau
         sb.append("\n"); 
         ligne2.setLength(0); // reset
         ligneHorizontal(sb, pieces[i].length); // la bordure entre chaque ligne, plus la derniere en bas	
      }
 
      System.out.println(sb); // on affiche
 
   }
 
   private static void ligneHorizontal(StringBuilder sb, int length) {
      sb.append("+"); // correspond à l'intersection avec la bordure de gauche
      for(int j=0; j<length; j++) {
         sb.append("---+"); // 2 caractères de large pour chaque case; plus l'intersection avec la border de droite
      }
      sb.append("\n");
   }
 
   public static class Piece {
      private final char c1;
      private final char c2;
      private final char c3;
      private final char c4;
 
      public Piece(char c1, char c2, char c3, char c4) {
         this.c1=c1;
	 this.c2=c2;
	 this.c3=c3;
	 this.c4=c4;
      }
 
      public char[] getValues() {
        return new char[]{c1, c2, c3, c4};
      }
   }
 
   private static Piece[][] generer() {
       Random random=new Random();
       Piece[][] pieces = new Piece[random.nextInt(7)+3][random.nextInt(7)+3];
 
       int nb=random.nextInt((pieces.length+pieces[0].length)/2)+10;
 
       List<Character> lettres = new ArrayList<Character>();
       for(char c = 'A'; c<='Z'; c++) {
           lettres.add(c);
       }
       for(int i=0; i<nb; i++) {
           Collections.shuffle(lettres);
	   Piece piece = new Piece( lettres.get(0), lettres.get(1), lettres.get(2), lettres.get(3));
	   pieces[random.nextInt(pieces.length)][random.nextInt(pieces[0].length)]=piece;
       }
 
       return pieces;		
   }
 
}

[FoxStyle]

Wow merci je vais étudier ça