Résumé du Fonctionnement du Jeu
Objectif du Jeu
Deux joueurs s'affrontent sur un plateau carré de taille \( n \times n \) (par défaut \( n = 8 \)).
Chaque joueur dispose de deux types de pièces : une reine et plusieurs tours.
- Reine :La reine peut se déplacer orthogonalement (horizontalement ou verticalement) ou
en diagonale vers une case vide, à condition que toutes les cases entre sa position de
départ et d'arrivée soient vides.
- Tour : La tour peut se déplacer orthogonalement vers une case vide, à condition que toutes
les cases entre sa position de départ et d'arrivée soient vides.
Règles de Déplacement et de Capture
1. Déplacement de la Reine :La reine se déplace orthogonalement ou en diagonale sans
obstacles.
2. Déplacement de la Tour :La tour se déplace orthogonalement sans obstacles.
3. Capture : Après qu'une tour ait été déplacée, si elle n'est ni sur la même ligne ni sur la
même colonne que la reine de son joueur, une capture est possible. La tour et la reine
forment deux sommets d'un rectangle virtuel. Si une ou deux tours adverses se trouvent sur
les autres sommets de ce rectangle, elles sont capturées.
Conditions de Victoire
Le jeu se termine dès qu'un joueur n'a plus que deux pièces ou moins (comptant la reine et
les tours). Le joueur restant avec plus de deux pièces remporte la partie.
Interprétation du Code
Classes et Méthodes Principales
1. Classe `Piece` :python
class Piece:
def __init__(self, couleur, type_piece, position):
[Link] = couleur
self.type_piece = type_piece
[Link] = position
En français :Cette classe représente une pièce sur le plateau avec sa couleur, son type
(reine ou tour) et sa position.
2. Classe `Player` :
`python
class Player:
def __init__(self, color):
[Link] = color
[Link] = None
[Link] = []
```
En français : Cette classe représente un joueur avec sa couleur, sa reine et ses tours.
3. Classe `Game` :
Méthode `__init__` :
python
def __init__(self, size=8):
[Link] = size
self.player1 = Player("blue")
self.player2 = Player("red")
self.current_player = self.player1
[Link] = [[None for _ in range(size)] for _ in range(size)]
self.selected_piece = None
self.initialize_game()
self.draw_board()
En français :Cette méthode initialise le jeu avec une taille de plateau par défaut de 8, crée
les joueurs, initialise le plateau et dessine le plateau.
Méthode `initialize_game` :
python
def initialize_game(self):
self.player1.initialize_pieces([Link])
self.player2.initialize_pieces([Link])
for piece in [Link] + [[Link]]:
self.place_piece(piece)
for piece in [Link] + [[Link]]:
self.place_piece(piece)
```
En français :Cette méthode initialise les pièces des deux joueurs et les place sur le
plateau.
Méthode `place_piece` :
python
def place_piece(self, piece):
row, col = [Link]
[Link][row][col] = piece
En français :Cette méthode place une pièce sur le plateau.
Méthode `draw_board` :
```python
def draw_board(self):
[Link] = [Link]()
[Link]("Game")
cell_size = 50
canvas_width = cell_size * [Link]
canvas_height = cell_size * [Link]
[Link] = [Link]([Link], width=canvas_width, height=canvas_height)
[Link]()
for row in range([Link]):
for col in range([Link]):
x1 = col * cell_size
y1 = row * cell_size
x2 = x1 + cell_size
y2 = y1 + cell_size
[Link].create_rectangle(x1, y1, x2, y2, fill="white", outline="black")
piece = [Link][row][col]
if piece:
color = [Link]
if piece.type_piece == "queen":
[Link].create_oval(x1 + 10, y1 + 10, x2 - 10, y2 - 10, fill=color,
outline="purple", width=5)
else:
[Link].create_oval(x1 + 10, y1 + 10, x2 - 10, y2 - 10, fill=color)
self.player_label = [Link]([Link], text=f"Player:
{self.current_player.[Link]()}", font=("Helvetica", 16), fg=self.current_player.color)
self.player_label.pack()
[Link]("<Button-1>", self.select_piece)
[Link]("<Button-3>", self.move_piece)
[Link]()
En français :Cette méthode crée la fenêtre du jeu, dessine le plateau et les pièces, et met
en place les événements de la souris pour sélectionner et déplacer les pièces.
Méthode `select_piece` :
python
def select_piece(self, event):
col = event.x // 50
row = event.y // 50
piece = [Link][row][col]
if piece and [Link] == self.current_player.color:
self.selected_piece = piece
self.highlight_piece(row, col)
En français : Cette méthode permet de sélectionner une pièce en cliquant dessus. Si la
pièce appartient au joueur actuel, elle est sélectionnée et mise en surbrillance.
Méthode `highlight_piece` :
python
def highlight_piece(self, row, col):
cell_size = 50
x1 = col * cell_size
y1 = row * cell_size
x2 = x1 + cell_size
y2 = y1 + cell_size
[Link].create_rectangle(x1, y1, x2, y2, outline="yellow", width=3)
```
En français : Cette méthode met en surbrillance la pièce sélectionnée en dessinant un
rectangle jaune autour d'elle.
Méthode `move_piece` :
python
def move_piece(self, event):
if not self.selected_piece:
return
new_col = event.x // 50
new_row = event.y // 50
old_row, old_col = self.selected_piece.position
if self.is_valid_move(self.selected_piece, (new_row, new_col)):
[Link][old_row][old_col] = None
self.selected_piece.position = (new_row, new_col)
[Link][new_row][new_col] = self.selected_piece
self.selected_piece = None
[Link]("all")
self.draw_board()
self.current_player = self.player2 if self.current_player == self.player1 else
self.player1
self.player_label.config(text=f"Player: {self.current_player.[Link]()}",
fg=self.current_player.color)
En français : Cette méthode permet de déplacer la pièce sélectionnée vers une nouvelle
position valide. Si le déplacement est valide, la pièce est déplacée, le plateau est mis à jour,
et le joueur suivant devient le joueur actuel.
Méthode `is_valid_move` :python
def is_valid_move(self, piece, new_position):
start_row, start_col = [Link]
end_row, end_col = new_position
if not (0 <= end_row < [Link] and 0 <= end_col < [Link]):
return False
if [Link][end_row][end_col] is not None:
return False
delta_row, delta_col = end_row - start_row, end_col - start_col
if piece.type_piece == "queen":
if abs(delta_row) == abs(delta_col) or delta_row == 0 or delta_col == 0:
return self.is_path_clear(start_row, start_col, end_row, end_col)
elif piece.type_piece == "tower":
if delta_row == 0 or delta_col == 0:
return self.is_path_clear(start_row, start_col, end_row, end_col)
return False
En français :Cette méthode vérifie si le déplacement d'une pièce est valide. Si la pièce est
une reine, elle doit se déplacer en ligne droite ou en diagonale sans obstacles. Si la pièce
est une tour, elle doit se déplacer en ligne droite sans obstacles.