Graphics :
import pygame from ChessPiece import * from Computer import
get_random_move, get_ai_move dark_block =
[Link]('assets/pictures/128px/square brown
dark_png_shadow_128px.png') light_block =
[Link]('assets/pictures/128px/square brown
light_png_shadow_128px.png') dark_block = [Link](dark_block,
(75, 75)) light_block = [Link](light_block, (75, 75)) whitePawn
= [Link]('assets/pictures/128px/w_pawn_png_shadow_128px.png')
whitePawn = [Link](whitePawn, (75, 75)) whiteRook =
[Link]('assets/pictures/128px/w_rook_png_shadow_128px.png')
whiteRook = [Link](whiteRook, (75, 75)) whiteBishop =
[Link]('assets/pictures/128px/w_bishop_png_shadow_128px.png')
whiteBishop = [Link](whiteBishop, (75, 75)) whiteKnight =
[Link]('assets/pictures/128px/w_knight_png_shadow_128px.png')
whiteKnight = [Link](whiteKnight, (75, 75)) whiteKing =
[Link]('assets/pictures/128px/w_king_png_shadow_128px.png')
whiteKing = [Link](whiteKing, (75, 75)) whiteQueen =
[Link]('assets/pictures/128px/w_queen_png_shadow_128px.png')
whiteQueen = [Link](whiteQueen, (75, 75)) blackPawn =
[Link]('assets/pictures/128px/b_pawn_png_shadow_128px.png')
blackPawn = [Link](blackPawn, (75, 75)) blackRook =
[Link]('assets/pictures/128px/b_rook_png_shadow_128px.png')
blackRook = [Link](blackRook, (75, 75)) blackBishop =
[Link]('assets/pictures/128px/b_bishop_png_shadow_128px.png')
blackBishop = [Link](blackBishop, (75, 75)) blackKnight =
[Link]('assets/pictures/128px/b_knight_png_shadow_128px.png')
blackKnight = [Link](blackKnight, (75, 75)) blackKing =
[Link]('assets/pictures/128px/b_king_png_shadow_128px.png')
blackKing = [Link](blackKing, (75, 75)) blackQueen =
[Link]('assets/pictures/128px/b_queen_png_shadow_128px.png')
blackQueen = [Link](blackQueen, (75, 75)) highlight_block =
[Link]('assets/pictures/128px/highlight_128px.png') highlight_block
= [Link](highlight_block, (75, 75)) screen = None
[Link]() font = [Link]('Comic Sans MS', 30)
Ce code utilise la bibliothèque Pygame pour créer une interface graphique pour un jeu d'échecs. Voici une
explication détaillée du code :
1. **Importation de modules et de classes nécessaires** :
- `import pygame` : Importe la bibliothèque Pygame pour la création d'applications graphiques.
- `from ChessPiece import *` : Importe les classes liées aux pièces d'échecs (comme `Pawn`, `Rook`, etc.).
- `from Computer import get_random_move, get_ai_move` : Importe les fonctions liées au mouvement de
l'ordinateur.
2. **Chargement des images des cases du plateau** :
- `dark_block` et `light_block` : Chargent les images des cases sombres et claires du plateau. Ces images sont
ensuite redimensionnées à une taille de 75x75 pixels.
3. **Chargement des images des pièces blanches** :
- Des images pour chaque type de pièce blanche (`whitePawn`, `whiteRook`, `whiteBishop`, `whiteKnight`,
`whiteKing`, `whiteQueen`) sont chargées et redimensionnées.
4. **Chargement des images des pièces noires** :
- Des images pour chaque type de pièce noire (`blackPawn`, `blackRook`, `blackBishop`, `blackKnight`,
`blackKing`, `blackQueen`) sont chargées et redimensionnées.
5. **Chargement de l'image pour la mise en surbrillance** :
- `highlight_block` : Charge une image représentant une mise en surbrillance de la case et la redimensionne.
6. **Initialisation de Pygame** :
- `screen = None` : Initialise la variable `screen` à `None` (elle sera utilisée plus tard pour représenter la
fenêtre de jeu).
- `[Link]()` : Initialise le module de police d'écriture de Pygame.
- `font = [Link]('Comic Sans MS', 30)` : Initialise une police d'écriture pour l'affichage du texte
avec Pygame.
Le code prépare essentiellement toutes les ressources graphiques nécessaires pour représenter le plateau
d'échecs et les pièces du jeu. Ces images redimensionnées seront utilisées ultérieurement pour afficher le
plateau de jeu, les pièces et d'autres éléments graphiques dans la fenêtre Pygame.
def initialize(): global screen [Link]() [Link].set_caption('Chess!') icon =
[Link]('assets/[Link]') [Link].set_icon(icon) screen =
[Link].set_mode((600, 650)) [Link]((0, 0, 0)) explique en details
La fonction `initialize` dans le code Pygame fournit les premières étapes pour lancer l'application du jeu
d'échecs. Voici une explication détaillée de cette fonction :
1. **`global screen`** : Déclare la variable `screen` comme globale afin qu'elle puisse être utilisée à l'extérieur
de la fonction. La variable `screen` représentera la fenêtre de jeu Pygame.
2. **`[Link]()`** : Initialise le module Pygame. Cette fonction doit être appelée avant toute autre fonction
Pygame.
3. **`[Link].set_caption('Chess!')`** : Définit le titre de la fenêtre du jeu comme "Chess!". Cela
apparaîtra dans la barre de titre de la fenêtre.
4. **`icon = [Link]('assets/[Link]')`** : Charge une image à utiliser comme icône de la fenêtre
du jeu. L'icône est souvent affichée dans le coin supérieur gauche de la fenêtre et dans la barre des tâches.
5. **`[Link].set_icon(icon)`** : Définit l'icône précédemment chargée comme icône de la fenêtre du
jeu.
6. **`screen = [Link].set_mode((600, 650))`** : Crée une fenêtre de jeu d'une taille de 600 pixels de
large sur 650 pixels de haut. La variable `screen` est mise à jour pour contenir cet objet de fenêtre.
7. **`[Link]((0, 0, 0))`** : Remplit la surface de la fenêtre avec une couleur noire. Cela sert à effacer tout
contenu précédent de la fenêtre. La couleur est spécifiée en utilisant un tuple RGB, où `(0, 0, 0)` représente le
noir (pas de couleur).
En résumé, la fonction `initialize` réalise les opérations initiales nécessaires pour préparer la fenêtre de jeu
Pygame, y compris l'initialisation du module Pygame, la définition du titre et de l'icône de la fenêtre, la création
de la fenêtre avec une taille spécifique, et le remplissage initial de la fenêtre avec une couleur de fond noire.
Une fois cette fonction exécutée, vous avez une fenêtre Pygame prête à être utilisée pour afficher le plateau de
jeu, les pièces, etc.
def draw_background(board): block_x = 0 for i in range(4): block_y = 0 for j in range(4):
[Link](light_block, (block_x, block_y)) [Link](dark_block, (block_x + 75, block_y))
[Link](light_block, (block_x + 75, block_y + 75)) [Link](dark_block, (block_x, block_y + 75))
block_y += 150 block_x += 150 step_x = 0 step_y = [Link].get_surface().get_size()[0] - 75 for i
in range(8): for j in range(8): if isinstance(board[i][j], ChessPiece): obj = globals()[f'{board[i][j].color}
{board[i][j].type}'] [Link](obj, (step_x, step_y)) step_x += 75 step_x = 0 step_y -= 75
[Link]()
La fonction `draw_background` est responsable de dessiner l'arrière-plan du plateau de jeu d'échecs et de
placer les pièces du jeu sur ce plateau. Voici une explication détaillée de cette fonction :
1. **Initialisation des variables** :
- `block_x = 0` : Initialise la position horizontale du premier bloc du plateau à 0.
- `block_y = 0` : Initialise la position verticale du premier bloc du plateau à 0.
2. **Boucle pour dessiner les cases du plateau** :
- La première boucle (`for i in range(4)`) parcourt les lignes du plateau, et la deuxième boucle (`for j in
range(4)`) parcourt les colonnes.
- À chaque itération, quatre cases sont dessinées (deux claires et deux sombres) en alternance, formant ainsi
une grille de 4x4.
3. **Placement des images des cases sur la fenêtre** :
- `[Link](light_block, (block_x, block_y))` : Place une case claire à la position actuelle (`block_x`, `block_y`)
sur la fenêtre.
- `[Link](dark_block, (block_x + 75, block_y))` : Place une case sombre décalée horizontalement de 75
pixels par rapport à la case précédente.
- `[Link](light_block, (block_x + 75, block_y + 75))` : Place une case claire décalée horizontalement et
verticalement de 75 pixels par rapport à la case précédente.
- `[Link](dark_block, (block_x, block_y + 75))` : Place une case sombre décalée verticalement de 75 pixels
par rapport à la case précédente.
4. **Mise à jour des positions pour la prochaine itération** :
- `block_y += 150` : Incrémente la position verticale pour la prochaine colonne de cases.
- `block_x += 150` : Incrémente la position horizontale pour la prochaine ligne de cases.
5. **Initialisation des variables pour le placement des pièces** :
- `step_x = 0` : Initialise la position horizontale pour le placement des pièces à 0.
- `step_y = [Link].get_surface().get_size()[0] - 75` : Initialise la position verticale pour le placement
des pièces à la hauteur de la fenêtre moins la taille d'une case (75 pixels).
6. **Boucle pour dessiner les pièces sur le plateau** :
- Deux boucles imbriquées (`for i in range(8)` et `for j in range(8)`) parcourent chaque case du plateau.
- Si la case contient une instance de la classe `ChessPiece`, l'image correspondante à cette pièce est récupérée
et placée sur la fenêtre.
7. **Mise à jour des positions pour la prochaine itération** :
- `step_x += 75` : Incrémente la position horizontale pour la prochaine colonne de pièces.
- `step_x = 0` : Réinitialise la position horizontale à 0 pour la prochaine ligne de pièces.
- `step_y -= 75` : Décrémente la position verticale pour passer à la ligne suivante.
8. **Mise à jour de l'affichage** :
- `[Link]()` : Met à jour l'affichage de la fenêtre pour refléter les changements effectués.
En résumé, cette fonction dessine l'arrière-plan du plateau d'échecs (cases claires et sombres) et place les
pièces du jeu à leurs positions initiales. La fonction utilise les images chargées précédemment (`light_block`,
`dark_block`, etc.) pour dessiner le plateau et les pièces.
def draw_text(text): s = [Link]((400, 50)) [Link]((0, 0, 0)) [Link](s, (100, 600)) text_surface =
[Link](text, False, (237, 237, 237)) if 'DRAW' in text: x = 260 else: x = 230 text_surface_restart =
[Link]('PRESS "SPACE" TO RESTART', False, (237, 237, 237)) [Link](text_surface, (x, 600))
[Link](text_surface_restart, (150, 620)) [Link]()
La fonction `draw_text` est responsable de l'affichage de messages textuels à l'écran dans le contexte du jeu
d'échecs. Voici une explication détaillée de cette fonction :
1. **Création d'une surface noire** :
- `s = [Link]((400, 50))` : Crée une surface noire de dimensions 400x50 pixels. Cette surface servira
de fond pour afficher le texte.
- `[Link]((0, 0, 0))` : Remplit la surface noire avec une couleur noire (0, 0, 0).
2. **Placement de la surface noire sur la fenêtre** :
- `[Link](s, (100, 600))` : Place la surface noire à la position (100, 600) sur la fenêtre. Cela crée un
rectangle noir en bas de la fenêtre pour afficher le texte.
3. **Rendu du texte principal** :
- `text_surface = [Link](text, False, (237, 237, 237))` : Utilise la police de caractères pour créer une
surface de texte avec la couleur spécifiée (237, 237, 237). La couleur est un blanc légèrement grisé.
- `if 'DRAW' in text: x = 260` : Si le texte contient le mot "DRAW", positionne le texte au centre de la fenêtre.
- Sinon, `x = 230` : Positionne le texte plus à gauche.
- `[Link](text_surface, (x, 600))` : Place la surface de texte à la position calculée sur la fenêtre.
4. **Rendu du texte de redémarrage** :
- `text_surface_restart = [Link]('PRESS "SPACE" TO RESTART', False, (237, 237, 237))` : Crée une surface
de texte indiquant au joueur de presser la barre d'espace pour redémarrer la partie.
- `[Link](text_surface_restart, (150, 620))` : Place cette surface de texte juste en dessous du texte
principal.
5. **Mise à jour de l'affichage** :
- `[Link]()` : Met à jour l'affichage de la fenêtre pour refléter les changements effectués.
En résumé, cette fonction crée une zone noire en bas de la fenêtre pour afficher du texte. Elle rend ensuite
deux surfaces de texte : l'une pour le texte principal et l'autre pour les instructions de redémarrage. Ces
surfaces de texte sont positionnées sur la fenêtre à des emplacements spécifiques, et l'affichage est mis à jour
pour montrer ces changements à l'utilisateur. L'utilisation de surfaces noires en tant que fond permet de
masquer tout texte précédent et assure une présentation claire du message actuel.
def start(board): global screen possible_piece_moves = [] running = True visible_moves = False
dimensions = [Link].get_surface().get_size() game_over = False piece = None if
board.game_mode == 1 and [Link]: get_ai_move(board) draw_background(board) while running: if
game_over: draw_text(game_over_txt) for event in [Link](): if [Link] == [Link]:
running = False if game_over and [Link] == [Link]: if [Link] == pygame.K_SPACE:
return True if [Link] == [Link] and not game_over: x = 7 -
[Link].get_pos()[1] // 75 y = [Link].get_pos()[0] // 75 if isinstance(board[x][y],
ChessPiece) and (board.get_player_color() == board[x][y].color or not [Link]) and (x, y) not in
possible_piece_moves: piece = board[x][y] moves = piece.filter_moves(piece.get_moves(board), board)
move_positions = [] possible_piece_moves = [] for move in moves:
move_positions.append((dimensions[0] - (8 - move[1]) * 75, dimensions[1] - move[0] * 75 - 125)) move_x
= 7 - move_positions[-1][1] // 75 move_y = move_positions[-1][0] // 75
possible_piece_moves.append((move_x, move_y)) if visible_moves: draw_background(board)
visible_moves = False for move in move_positions: visible_moves = True [Link](highlight_block,
(move[0], move[1])) [Link]() else: clicked_move = (x, y) try: if clicked_move in
possible_piece_moves: board.make_move(piece, x, y) possible_piece_moves.clear()
draw_background(board) if [Link]: get_ai_move(board) draw_background(board) if board.white_won():
game_over = True game_over_txt = 'WHITE WINS!' elif board.black_won(): game_over = True
game_over_txt = 'BLACK WINS!' elif [Link](): game_over = True game_over_txt = 'DRAW!' except
UnboundLocalError: pass
Cette fonction `start` gère l'interaction utilisateur et le déroulement du jeu dans l'interface graphique du jeu
d'échecs. Voici une explication détaillée de cette fonction :
1. **Initialisation des variables** :
- `global screen` : Déclare la variable `screen` comme globale, indiquant qu'elle fait référence à la fenêtre
Pygame.
- `possible_piece_moves = []` : Initialise une liste vide pour stocker les mouvements possibles de la pièce
sélectionnée.
- `running = True` : Initialise une variable de contrôle pour le fonctionnement continu du jeu.
- `visible_moves = False` : Initialise une variable pour suivre si les mouvements possibles de la pièce sont
actuellement visibles.
- `dimensions = [Link].get_surface().get_size()` : Récupère les dimensions de la fenêtre du jeu.
- `game_over = False` : Initialise une variable pour suivre si la partie est terminée.
- `piece = None` : Initialise une variable pour stocker la pièce sélectionnée.
2. **Vérification du mode de jeu et mouvement de l'IA initial (si nécessaire)** :
- Si le mode de jeu est contre l'IA (`board.game_mode == 1`) et l'IA est activée (`[Link]`), l'IA effectue son
premier mouvement en appelant `get_ai_move(board)` et le plateau est mis à jour avec
`draw_background(board)`.
3. **Boucle principale du jeu** (`while running:`) :
- Si la partie est terminée, affiche le texte de fin de partie en appelant `draw_text(game_over_txt)`.
- Gère les événements Pygame à l'intérieur de la boucle.
4. **Gestion de l'événement de fermeture de la fenêtre** :
- Si l'événement de fermeture de la fenêtre (`[Link]`) est détecté, met fin à la boucle (`running =
False`), ce qui arrête le jeu.
5. **Gestion de l'événement de pression de touche (si la partie est terminée)** :
- Si la partie est terminée et l'utilisateur appuie sur la barre d'espace (`[Link]` et `[Link] ==
pygame.K_SPACE`), renvoie `True` pour indiquer que le joueur veut redémarrer la partie.
6. **Gestion de l'événement de clic de souris** :
- Si la partie n'est pas terminée et l'utilisateur clique sur une case du plateau :
- Calcule les coordonnées `x` et `y` de la case cliquée.
- Vérifie si la case contient une pièce du joueur en cours et si ces mouvements ne sont pas déjà affichés.
- Si c'est le cas, stocke la pièce sélectionnée et ses mouvements possibles.
- Affiche les mouvements possibles en mettant à jour le fond du plateau.
- Si un mouvement valide est cliqué, effectue le mouvement et met à jour le fond du plateau.
- Vérifie si la partie est terminée, et si c'est le cas, affiche le texte approprié.
- Si la partie est en mode contre l'IA, l'IA effectue également son mouvement et le plateau est mis à jour.
7. **Gestion d'exceptions** :
- Capture l'exception `UnboundLocalError` qui pourrait survenir si aucune pièce n'est sélectionnée et qu'un
mouvement est effectué. Dans ce cas, la fonction ne fait rien.
En résumé, la fonction gère l'interaction utilisateur avec la fenêtre Pygame, détecte les clics de souris, effectue
les mouvements de pièces, vérifie si la partie est terminée, et gère les actions associées à la fin de la partie. Elle
prend en charge le mode de jeu contre l'IA et permet au joueur de redémarrer la partie après qu'elle soit
terminée.
