Aide Java Jeu Echecs

Version imprimable

Bonjour,
Je suis nouvelle ici car en formation depuis octobre pour une reconversion, j'ai donc commencé les cours de Java. Pour valider ce semestre, nous devons réaliser un jeu d'échecs.
Les premières consignes sont :
1. Créer une classe principale Echecs dans laquelle vous devez initialiser un tableau à 2 dimensions (8 x 8 ) nommé Echiquier . Ce tableau représente les cases de l’ échiquier : à un instant t , une case est soit libre , soit occupé par une pièce . Chaque pièce sera référencée par un code sur 2 constitué du type de la pièce (T=Tour , F=Fou , P=Pion, Q=Reine, K=Roi, C=Cavalier ) + le code joueur (B pour les blancs, N pour les noirs)
2. Créer et implémenter une méthode initialiser qui ,étant donné l’échiquier, positionne les pièces selon la disposition conventionnelle des pièces des blancs et des noirs en début de partie , et retourne l’échiquier ainsi initialisé .
3. Créer et implémenter une méthode afficher qui , étant donné l’échiquier, affiche à la console l’échiquier avec les pièces de la manière la plus lisible possible .
4.Testez les méthodes afficher et initialiser dans la méthode principale de la classe Echecs .

Le code que j'ai créée :
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 38 39 40 41 42 43 44 45 46 47 package echecs; import java.util.*; public class Echecs { public static void main (String [] arg) { String Echiquier[][]; Echiquier = new String [8][8]; initialiser(Echiquier); afficher(Echiquier); } // fin main public static void initialiser (String[][] tableau) { String [][] echiquier = { {"TN","CN","FN","KN","QN","FN","CN","TN"}, {"PN", "PN", "PN","PN", "PN", "PN", "PN", "PN"}, {" " , " " , " " , " " , " " ," " , " " , " " }, {" " , " " , " " , " " , " " ," " , " " , " " }, {" " , " " , " " , " " , " " ," " , " " , " " }, {" " , " " , " " , " " , " " ," " , " " , " " }, {"PB", "PB", "PB", "PB", "PB", "PB", "PB", "PB"}, {"TB","CB","FB","KB","QB","FB","CB","TB"} }; } // fin méthode position initiale des pièces public static void afficher (String[][] tableau) { for (int i=0; i<tableau.length ; i++) { for (int j=0;j<tableau[i].length; j++) { System.out.print(tableau[i][j]+" , "); } System.out.println(" "); } } // fin méthode afficher } // fin class echecs
Malheureusement, je ne parviens pas à "remplacer" le tableau vide du main par celui de la méthode initialiser, je suppose qu'il faut utiliser "new" mais je ne connais pas la syntaxe pour les String. Pourriez-vous m'aider s'il vous plait ?
Je vous remercie.
(Si le sujet pouvait rester ouvert un peu parce que je sens que j'aurais de nouveau besoin d'aide pour le reste du projet...)
Merci beaucoup

02/01/2024, 13h53
yildiz-online

Bonjour quelques remarques generales avant de commencer:

1)Il est souvent bon de preferer les imports complets plutot que d'utiliser import package.* pour eviter les risques de collision sur plusieurs classes avec le meme nom aparaissant dans des packages differents.
2)Les conventions de nommage standard java sont pour les variable le camel case debutant par une minuscule, mieux vaut s'en tenir aux standard pour eviter de pendre de mauvaises habitudes. (https://www.oracle.com/java/technolo...nventions.html)

Pour le probleme en lui meme, il ne faut pas recreer un nouveau tableau mais modifier son contenu a l'indice voulu, donc echiquer[0][0] = "TN", echiquer[0][1]="CN" etc...
Mais il serait preferable de creer l'echiquier et l'initialiser dans la fonction elle meme plutot que de le promener pour eviter les effets de bords possible, en utilisant cette signature de fonction: private static String[][] initialiser();

Ce cours est tres bien pour debuter: https://www.jmdoudoux.fr/java/dej/chap-syntaxe.htm
02/01/2024, 15h18
Aline64

Je te remercie pour ces informations.

Citation:

Envoyé par yildiz-online

1) Il est souvent bon de préférer les imports complets plutôt que d'utiliser import package.* pour éviter les risques de collision sur plusieurs classes avec le même nom apparaissant dans des packages différents.

C'est noté, merci pour l'information

Citation:

Envoyé par yildiz-online

2)Les conventions de nommage standard java sont pour les variable le camel case débutant par une minuscule, mieux vaut s'en tenir aux standard pour éviter de pendre de mauvaises habitudes.

Comme expliqué, je suis les consignes données à savoir "initialiser l'échiquier à 2 dimensions (8 x 8 ) nommé Echiquier." avec une majuscule...

Citation:

Envoyé par yildiz-online

Pour le problème en lui même, il ne faut pas recréer un nouveau tableau mais modifier son contenu a l'indice voulu, donc echiquer[0][0] = "TN", echiquer[0][1]="CN" etc...
Mais il serait préférable de créer l’échiquier et l'initialiser dans la fonction elle même plutôt que de le promener pour éviter les effets de bords possible, en utilisant cette signature de fonction: private static String[][] initialiser();

Tu suggères de ne pas créer l'échiquier dans le Main ? pardon pour les questions, je suis vraiment débutante.

Merci pour le lien, je vais regarder ça attentivement.
02/01/2024, 16h18
PhilippeGibault
Bonjour,

Quand on a un problème compliqué, comme c'est un peu le cas ici, il faut le découper en plusieurs sous problèmes simple et compréhensible.
C'est le principe du rasoir d'Ockham.

https://fr.wikipedia.org/wiki/Rasoir_d%27Ockham

Voici un début possible (largement améliorable).

Pour commencer, je n'ai pas n'importe quoi comme pièce.
Je devrais donc lister les pièces.
L'enum est parfait:
https://www.baeldung.com/a-guide-to-java-enums

Soit:
Code:

1 2 3 4 public enum TypePiece{ ROI,DAME,TOUR,CAVALIER,FOU,PION }
On a selon le même principe deux couleur:
Code:

1 2 3 4 public enum Couleur{ BLANC,NOIR }
On peut donc définir la pièce, par record dans les nouvelles versions de Java:
https://www.jmdoudoux.fr/java/dej/chap-records.htm
https://www.baeldung.com/java-record-keyword
Code:

1 2 public record Piece(TypePiece type, Couleur couleur) {}
De fait on peut passer à l'échiquier (problème suivant).

La version la plus simple (voir simpliste) est un tableau 8*8 qui donne l'état de l'échiquier:
Code:

1 2 Optional<Piece>[][]
Notez l'utilisation d'un Optional, car il se peut qu'il n'y ait pas de pièce sur une case.
https://www.baeldung.com/java-optional

Du coup, comme l'a expliqué @yildiz-online, le déplacement d'une pièce est l'échange de deux position du tableau (et la prise étant le remplacement pas Optional.empty()).

Si on doit dessiner l'échiquier, c'est un autre problème, et on se basera sur le tableau réel.

On peut aussi complexifier la modélisation de l'échiquier (couleur de la case, coordonnées...) mais j'ai préféré resté simpliste.
02/01/2024, 16h41
Aline64

Merci pour toutes ces informations.
Je pensais que mettre les consignes aiderait à comprendre ce qu'il m'est demandé de faire.
Vos réponses sont très complètes, vont bien au-delà de ce que je sais faire, et ce qui est demandé, il me semble. Par exemple, je ne connais pas du tout la fonction enum, qui viendra peut être après dans le cours et répondra aux autres consignes.

Bon, il faut effectivement peut-être aller plus loin.

Pour rappel, un échiquier, ça ressemble à ça:
https://fr.wikipedia.org/wiki/%C3%89chiquier

Un échiquier, ça a des cases, que pour la suite, on va contractualiser:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public interface Case(){
 
  Optional<Piece> getPiece();
 
  void deplacePiece(Optional<Piece> nouvellePiece);
 
  void retirePiece();
 
  String abscisse();
 
  Integer ordonnee();
 
  Couleur couleur();
}

Il s'agit de ce que verra l'utilisateur. Un utilisateur sait ce que ça fait, mais il ne doit surtout pas savoir comment ça fonctionne. Il ne voit que un contrat, soit, en langage UML, ce que l'on appelle une interface.

On va donc donner une implémentation:

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
38
39
40
41
42
43
44
45
46
47
 
public class CaseImpl() implements Case{
 
  private final String abscisse;
  private final Integer ordonnee;
  private final Couleur couleur;
 
  private Optional<Piece> pieceSurCase;
 
 
  public CaseImpl(Optional<Piece> pieceSurCase,String abscisse,Integer ordonnee,Couleur couleur){
    this.pieceSurCase = pieceSurCase;
    this.abscisse = abscisse;
    this.ordonnee = ordonnee;
    this.couleur = couleur;
  }
 
  @Override
  public Optional<Piece> getPiece(){
    return pieceSurCase;
  }
 
  @Override
  public void deplacePiece(Optional<Piece> nouvellePiece){
    pieceSurCase = nouvellePiece;
  }
 
  @Override
  public void retirePiece(){
   pieceSurCase = Optional.empty();
  }
 
  @Override
  public String abscisse(){
    return abscisse;
  }
 
  @Override
  public Integer ordonnee(){
    return ordonnee;
  }
 
 @Override
 public Couleur couleur(){
   return couleur;
 }
}

On peut donc contractualiser l'échiquier.

Code:

1
2
3
4
5
6
 
public interface Echiquier{
  void initialise();
 
  List<Case> afficher();
}

Notez que j'ai décidé contrairement sans doute à l'énoncé de lister les cases. Pour le voir en ayant une compréhension humaine, il faut en plus surcharger toString (correctement surchargé pour un record, à redéfinir pour une classe):
https://www.baeldung.com/java-tostring

Soit (là, ça devient chiant, lourd et fastidieux):

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
 
public class EchiquierImpl implements Echiquier{
  private final List<Case> cases;
 
  public Echiquier(){
    cases = new ArrayList<>();
  }
 
  @Override
  public void initialise(){
   //Ici code chiant
   cases.clear()//On néinitialise
 
   //Ligne 1(Blanc)
   cases.add(new Case(new Piece(TypePiece.TOUR,Couleur.BLANC),"a",1,Couleur.NOIR));
   cases.add(new Case(new Piece(TypePiece.CAVALIER,Couleur.BLANC),"b",1,Couleur.BLANC));
   cases.add(new Case(new Piece(TypePiece.FOU,Couleur.BLANC),"c",1,Couleur.NOIR)); 
   //Compléter suite ligne 1
 
   //Ligne 2(Blanc)
   cases.add(new Case(new Piece(TypePiece.PION,Couleur.BLANC),"a",2,Couleur.BLANC));
   cases.add(new Case(new Piece(TypePiece.PION,Couleur.BLANC),"b",2,Couleur.NOIR));
   //Compléter suite ligne 2
 
   //Ligne 3
   cases.add(new Case(Optional.empty(),"a",1,Couleur.NOIR));
   cases.add(new Case(Optional.empty(),"b",1,Couleur.BLANC));
   //Faire la suite
  }
 
  @Override
  public List<Case> afficher(){
    return cases;
  }
}

03/01/2024, 10h07
yildiz-online

Oui je suggere de ne pas creer (le terme est instancier quand on utilise un new) le tableau dans la fonction main, mais bien dans la fonction initialiser, ceci pour plusieurs raisons:

1) le main devrait etre aussi simple que possible et ne contenir que les appels vers les fonctions metiers, afin de preserver la lisibilite du code
2) les new sont un facteur bloquant en java(que ce soit au niveau du code ou semantique), tu le verra lorsque le paradigme oriente objet sera aborde, mais vu qu'ils sont lies aux constructeurs de classes, il posent vite des limitation qui sont levee en delegant la creation vers des fonctions dediees, bien que dans ce cas, l'interet soit limite vu que c'est un simple tableau, mais si ton code evolue vers de l'objet tu auras un meilleure base de travail.
3) et surtout passer des objets mutable (dont l'etat interne peut etre modifie, c'est le cas des tableaux) en parametre d'une fonction est un risque eleve d'effet de bord, qui augmente en fonction de la complexite et du nombre de fonctions, il est des lors souvent preferable de soit passer un objet non modifiable et de creer un nouvelle version modifiee dans la fonction pour ensuite la retourner, ca evite les mauvaises surprise lorsque plusieurs processus travaillent "en meme temps" sur un objet commun, ou tout simplement si l'objet n'etait pas sense etre modifie, c'est donc une bonne habitude a prendre.

Il y a dans cet exercice de nombreuses entorses a la programmation (ce qui a suscite la reaction de Phillipe je suppose), ce qui est normal dans un but didactique afin d'apprendre les bases, mais faire l'impasse sur les conventions de nommage n'apporte rien en terme d'apprentissage, au contraire, tu pourrais remonter cette info vers ton professeur (avec la reference vers le site d'Oracle), pas besoin de le confronter, juste remonter l'info et voir ce qu'il en dit.
03/01/2024, 12h25
Aline64

Merci beaucoup pour vos différentes solutions et votre aide. J'y vois plus clair et je vais continuer à travailler sur ce projet.

Citation:

Envoyé par Aline64

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
 
public class Echecs {
 
	public static void main (String [] arg) {
	String Echiquier[][];
	Echiquier = new String [8][8];
 
 
	initialiser(Echiquier);
	afficher(Echiquier);
 
 
	} // fin main
 
	public static void initialiser (String[][] tableau)
	{
		String [][] echiquier = {
				{"TN","CN","FN","KN","QN","FN","CN","TN"},
				{"PN", "PN", "PN","PN", "PN", "PN", "PN", "PN"},
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{"PB", "PB", "PB", "PB", "PB", "PB", "PB", "PB"},
				{"TB","CB","FB","KB","QB","FB","CB","TB"}
		};
 
	} // fin méthode position initiale des pièces

Tu mets en paramètre ton tableau de String dans la méthode initialiser en paramètre.
Mais dans l'implémentation de la méthode, tu n'y touche pas et en crée un autre.
Donc en effet, ton échiquier ne change pas

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void initialiser (String[][] tableau)
	{
		String [][] echiquier = {
				{"TN","CN","FN","KN","QN","FN","CN","TN"},
				{"PN", "PN", "PN","PN", "PN", "PN", "PN", "PN"},
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{" " , " " , " " , " " , " " ," " , " " , " " },
				{"PB", "PB", "PB", "PB", "PB", "PB", "PB", "PB"},
				{"TB","CB","FB","KB","QB","FB","CB","TB"}
		};
 
	} // fin méthode position initiale des pièces

tableau est passé en paramètres, mais tu n'y touche a aucun moment dans la méthode.
Donc soit tu enlève le paramètre, vu qu'il ne sert à rien en l'état.
Soit tu change echiquier par tableau.