Programmation Java – Mouvements d’échecs (base, pas d’IA)

Lors de la conception d’un logiciel, je trouve utile de réfléchir à la manière dont j’utiliserais une méthode, puis de rédiger la signature de la méthode (et si vous effectuez un test basé sur le développement, le test unitaire), et réfléchissez seulement ensuite à la manière de la mettre en œuvre.

En faisant cela ici, je trouve que l’exigence

Ensuite, quand un joueur clique sur une pièce, les carrés disponibles comme destination après le déplacement sont délimités par une couleur.

est impossible à satisfaire avec une méthode comme

 void move(Square destination); 

car il n’existe aucun moyen de déterminer les mouvements possibles sans les effectuer réellement. Pour mettre en évidence les carrés, il serait probablement préférable si nous avions une méthode comme

 Collection getPossibleMoves(); 

et alors nous pourrions mettre en œuvre

 void move(Square destination) { if (!getPossibleMoves().contains(destination) { throw new IllegalMoveException(); } this.location.occupyingPiece = null; this.location = destination; this.location.occupyingPiece = this; } 

comme pour l’implémentation de getPossibleMoves:

 class Pawn extends Piece { @Override Collection getPossibleMoves() { List possibleMoves = new ArrayList(); int dy = color == Color.white ? 1 : -1; Square ahead = location.neighbour(0, dy); if (ahead.occupyingPiece == null) { possibleMoves.add(ahead); } Square aheadLeft = location.neighbour(-1, dy); if (aheadLeft != null && aheadLeft.occupyingPiece != null && aheadLeft.occupyingPiece.color != color) { possibleMoves.add(aheadLeft); } Square aheadRight = location.neighbour(1, dy); if (aheadRight != null && aheadRight.occupyingPiece != null && aheadRight.occupyingPiece.color != color) { possibleMoves.add(aheadRight); } return possibleMoves; } } 

Modifier :

 class Knight extends Piece { @Override Collection getPossibleMoves() { List possibleMoves = new ArrayList(); int[][] offsets = { {-2, 1}, {-1, 2}, {1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2}, {-2, -1} }; for (int[] o : offsets) { Square candidate = location.neighbour(o[0], o[1]); if (candidate != null && (candidate.occupyingPiece == null || candidate.occupyingPiece.color != color)) { possibleMoves.add(candidate); } } return possibleMoves; } } 

Comme vous le décrivez, plus qu’une méthode movePiece, vous avez besoin d’une méthode getPossibleMoves qui vous donne tous les endroits où vous pouvez vous déplacer. Alternativement ou en complément, une méthode moveAllowed pour une pièce vous indique s’il est autorisé de déplacer une pièce vers cet emplacement donné.

Au lieu d’utiliser des coordonnées brutes (x, y), vous pouvez créer une classe pour définir un Location dans le tableau. Cela pourrait vous fournir des méthodes pour traduire un lieu en “coordonnées d’échecs” telles qu’utilisées dans la littérature sur les échecs. Un emplacement serait construit en tant que new Location(x, y) .

De plus, je préférerais une classe Board qui représente la carte de cellules 8×8 et constitue le conteneur pour les pièces. Elle peut avoir une logique plus riche qu’un simple tableau (par exemple, elle pourrait vous donner un pathClear(from, to) qui vous indique s’il existe Aucune pièce ne bloque-t-elle votre passage d’un lieu à un autre), etc.

Je ferais une méthode abstraite isValidMove (Board boardState, int square), qui serait surchargée dans chaque pièce et appelée pour mettre en évidence les mouvements valides (à chaque itération du dessin). Cette même méthode serait appelée dans movePiece (int square) pour vérifiez si le mouvement est valide et effectuez le mouvement s’il en est ainsi. En fait, la méthode movePiece appartiendrait au Conseil lui-même (et appellerait Piece.isValidMove (…) pour vérifier.)

IsValidMove de Pawn ressemblerait à quelque chose du genre (notez que c’est du pseudo-code):

 if ( boardState.getSquare(square).isFree() && square == this.square+ONE_FILE) return true; else return false; 

Je créerais une méthode appelée getValidMoves () qui renvoie la liste de tous les mouvements possibles pour une pièce donnée. Ainsi, vous n’aurez pas à parcourir tout le tableau pour trouver les carrés à mettre en évidence. Je rendrais également la classe de base abstraite afin que des méthodes telles que celle-ci n’aient pas besoin d’une implémentation de base.

Je termine juste mon propre jeu d’échecs. Voici quelques conseils / points que je souhaite partager avec vous.

N’oubliez pas que Java est un langage orienté object, divise le jeu en objects logiques et interagit avec des méthodes.

Gardez les méthodes aussi simples que possible (comme toujours). Rendre le code lisible par l’homme. Parfois! 8 méthodes différentes pour vérifier les pièces (King) Les mouvements disponibles sont plus lisibles que certaines phrases cryptées essayant de faire tout ce travail de calcul.

Si vous vouliez appliquer le modèle MVC, vous voudrez peut-être considérer que votre interface graphique est également votre contrôleur qui contient une référence à votre carte actuelle.

Piece.java protected Liste autoriséeSquares; public abstract void calculeAllowedSquares (ChessBoard chessBoard); déplacement public vide (ChessBoard chessBoard, Square de Square, Square en Square)

Dans la classe King, vous devrez peut-être remplacer la méthode move. Par exemple, dans le mouvement de castling, vous devez déplacer la tour en même temps.

• Vous aurez également besoin de savoir d’où vous vous déplacez (règle de vérification pour le déplacement passant) et vous devrez probablement effacer le “fromSquare” de votre déplacement puisque vous utilisez le tableau [] [].

Le concept de jeu d’échecs comporte deux grands problèmes: 1. Comment éliminer les mouvements qui exposent votre propre roi à vérifier. Parfois, les pièces ne peuvent pas bouger du tout. 2. Comment permettre à une pièce de bouger uniquement pour protéger votre roi en cas de contrôle. Cela signifie que si évêque for.ex menace votre roi et que vous pouvez déplacer un élément pour bloquer cette menace, mais nulle part ailleurs.

Et enfin, je vous conseille de créer votre interface graphique en même temps que votre logique. C’est une grande aide lorsque vous cliquez sur votre pièce (ou le carré où se trouve la pièce) et vous pouvez immédiatement voir à l’écran quels sont les carrés disponibles. Cela vous évite des heures et des heures de débogage.

tu dois ralentir!

Tout d’abord, vous devez créer une classe pour chaque élément et append les mouvements possibles pour chacun d’entre eux, ainsi que mettre en œuvre une méthode de vérification des mouvements possibles pendant le jeu, puis utiliser l’interface graphique Netbeans, append des JLabels et modifier leur couleur en blanc et noir. une bonne vue de l’ensemble du processus.

commencez simplement, n’hésitez pas à supprimer les anciens codes et à les changer avec de nouveaux codes plus performants. c’est comme ça que ça marche mec.

bonne chance.