def load(self):
reponse = messagebox.askquestion(
"C'est une bonne partie...courage",
"Si vous chargez une nouvelle partie, vous "
"risquez de perdre la partie courante?\nCliquez sur "
"'Oui' pour sauvegarder la partie courante ou sur 'Non' pour "
"continuer.".format(self.partie.joueur_actif))
if reponse == "yes": # on affiche une fenetre pour demander si vraiment on veut quitter la partie en cours
self.save()
fichier_source = filedialog.askopenfilename(
title='Choisissez le fichier où est sauvegardé vôtre '
'partie',
defaultextension='.txt',
filetypes=[('text seulement', '.txt')])
if fichier_source:
load = open(fichier_source,
'r') # le même fonctionnement que pour sel.save()
dicos_chaine = load.readlines()
caracteres_pieces_r = {
'PB': Pion('blanc'),
'PN': Pion('noir'),
'TB': Tour('blanc'),
'TN': Tour('noir'),
'CB': Cavalier('blanc'),
'CN': Cavalier('noir'),
'FB': Fou('blanc'),
'FN': Fou('noir'),
'RB': Roi('blanc'),
'RN': Roi('noir'),
'DB': Dame('blanc'),
'DN': Dame('noir')
}
pos = ''
piece = None
piece_class = ''
self.canvas_echiquier.echiquier.dictionnaire_pieces = {}
for l in range(len(dicos_chaine) - 1):
pos = dicos_chaine[l][0:2]
piece = dicos_chaine[l][2:4]
for p in caracteres_pieces_r:
if piece == p:
piece_class = caracteres_pieces_r[p]
self.canvas_echiquier.echiquier.dictionnaire_pieces[
pos] = piece_class
self.partie.joueur_actif = dicos_chaine[-1]
load.close()
self.canvas_echiquier.delete('piece')
self.canvas_echiquier.dessiner_pieces()
self.messages['foreground'] = 'black'
self.messages['text'] = 'La partie à été chargé avec succès'
self.messages['text'] = "c'est parti"
self.mon_label_info['text'] = "C'est au tour du joueur {}".format(
self.partie.joueur_actif)
self.mon_label_info['text'] = "C'est au tour du joueur blanc"
self.prises_blanc['text'] = "Prises du\njoueur blanc"
self.prises_noir['text'] = "Prises du\njoueur noir"
self.depla_blanc['text'] = "Liste des déplacements\njoueur blanc"
self.depla_noir['text'] = "Liste des déplacements\njoueur noir"
def initialiser_echiquier_depart(self):
"""Initialise l'échiquier à son contenu initial. Pour faire vos tests pendant le développement,
nous vous suggérons de vous fabriquer un échiquier plus simple, en modifiant l'attribut
dictionnaire_pieces de votre instance d'Echiquier.
"""
# Initialisation d'une liste vide de Liste des Échiquiers qui servira a revenir en arrière avec la fonction
# d'Annulation du dernier mouvement
self.listeDesEchiquiers = []
self.dictionnaire_pieces = {
'a1': Tour('blanc'),
'b1': Cavalier('blanc'),
'c1': Fou('blanc'),
'd1': Dame('blanc'),
'e1': Roi('blanc'),
'f1': Fou('blanc'),
'g1': Cavalier('blanc'),
'h1': Tour('blanc'),
'a2': Pion('blanc'),
'b2': Pion('blanc'),
'c2': Pion('blanc'),
'd2': Pion('blanc'),
'e2': Pion('blanc'),
'f2': Pion('blanc'),
'g2': Pion('blanc'),
'h2': Pion('blanc'),
'a7': Pion('noir'),
'b7': Pion('noir'),
'c7': Pion('noir'),
'd7': Pion('noir'),
'e7': Pion('noir'),
'f7': Pion('noir'),
'g7': Pion('noir'),
'h7': Pion('noir'),
'a8': Tour('noir'),
'b8': Cavalier('noir'),
'c8': Fou('noir'),
'd8': Dame('noir'),
'e8': Roi('noir'),
'f8': Fou('noir'),
'g8': Cavalier('noir'),
'h8': Tour('noir'),
}
# Création d'une premiere liste des échiquiers pour générer un historique dès le départ
self.listeDesEchiquiers.append(dict(self.dictionnaire_pieces))
# Création d'un Sets de pièces blanches et noirs pour calculer la différence avec les pièces restantes
self.setBlanc = set()
self.setNoir = set()
for i in self.listeDesEchiquiers[0].values():
if i.est_blanc():
self.setBlanc.add(i)
else:
self.setNoir.add(i)
def promotion_pion(self, position_cible):
piece = self.recuperer_piece_a_position(position_cible)
if isinstance(piece, Pion):
if piece.est_blanc():
if position_cible in [
'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8'
]:
self.dictionnaire_pieces[position_cible] = Dame('blanc')
if piece.est_noir():
if position_cible in [
'a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1'
]:
self.dictionnaire_pieces[position_cible] = Dame('noir')
def save(
self
): # on ouvre une fenetre de dialogue pour le (path) de sauvegarde, (seulement .txt et prédefini),
# et aussi un demande un nom de fichier
destination = filedialog.asksaveasfilename(
title='Choisissez un répertoire où sauvegarder votre '
'partie',
defaultextension='.txt',
filetypes=[('text seulement', '.txt')])
if destination:
sauvegarde = open(destination, "w")
for e in self.canvas_echiquier.echiquier.dictionnaire_pieces:
sauvegarde.write(e) # on y écrit chaque position pleine.
piece = self.canvas_echiquier.echiquier.dictionnaire_pieces[e]
caracteres_pieces_w = {
Pion('blanc'): 'PB',
Pion('noir'): 'PN',
Tour('blanc'): 'TB',
Tour('noir'): 'TN',
Cavalier('blanc'): 'CB',
Cavalier('noir'): 'CN',
Fou('blanc'): 'FB',
Fou('noir'): 'FN',
Roi('blanc'): 'RB',
Roi('noir'): 'RN',
Dame('blanc'): 'DB',
Dame('noir'): 'DN'
}
for p in caracteres_pieces_w: # pour chque position on compare le type
if type(p) == type(
piece
) and p.couleur == piece.couleur: # de piece qu'elle contient avec le dict
sauvegarde.write(
caracteres_pieces_w[p]
) # defini au dessus puis on ecrit le caract
sauvegarde.write('\n') # correspondant, puis on saute la ligne
sauvegarde.write(self.partie.joueur_actif
) # apres avoir parcouru toutes les piece
sauvegarde.close() # on ecrit le nom du joueur actif
self.messages['foreground'] = 'black'
self.messages[
'text'] = 'La partie à été enregistré avec success' # enfin on affiche un message que tout c'est bien passé
def initialiser_echiquier_depart(self):
"""Initialise l'échiquier à son contenu initial. Pour faire vos tests pendant le développement,
nous vous suggérons de vous fabriquer un échiquier plus simple, en modifiant l'attribut
dictionnaire_pieces de votre instance d'Echiquier.
"""
self.dictionnaire_pieces = {
'a1': Tour('blanc'),
'b1': Cavalier('blanc'),
'c1': Fou('blanc'),
'd1': Dame('blanc'),
'e1': Roi('blanc'),
'f1': Fou('blanc'),
'g1': Cavalier('blanc'),
'h1': Tour('blanc'),
'a2': Pion('blanc'),
'b2': Pion('blanc'),
'c2': Pion('blanc'),
'd2': Pion('blanc'),
'e2': Pion('blanc'),
'f2': Pion('blanc'),
'g2': Pion('blanc'),
'h2': Pion('blanc'),
'a7': Pion('noir'),
'b7': Pion('noir'),
'c7': Pion('noir'),
'd7': Pion('noir'),
'e7': Pion('noir'),
'f7': Pion('noir'),
'g7': Pion('noir'),
'h7': Pion('noir'),
'a8': Tour('noir'),
'b8': Cavalier('noir'),
'c8': Fou('noir'),
'd8': Dame('noir'),
'e8': Roi('noir'),
'f8': Fou('noir'),
'g8': Cavalier('noir'),
'h8': Tour('noir'),
}
def dessiner_pieces(self):
# Caractères unicode représentant les pièces. Vous avez besoin de la police d'écriture DejaVu.
self.caracteres_pieces = {
Pion('blanc'): '\u2659',
Pion('noir'): '\u265f',
Tour('blanc'): '\u2656',
Tour('noir'): '\u265c',
Cavalier('blanc'): '\u2658',
Cavalier('noir'): '\u265e',
Fou('blanc'): '\u2657',
Fou('noir'): '\u265d',
Roi('blanc'): '\u2654',
Roi('noir'): '\u265a',
Dame('blanc'): '\u2655',
Dame('noir'): '\u265b'
}
# Pour tout paire position, pièce:
for position in self.echiquier.dictionnaire_pieces:
# On dessine la pièce dans le canvas, au centre de la case. On utilise l'attribut "tags" pour être en
# mesure de récupérer les éléments dans le canvas.
coordonnee_y = (
self.n_lignes - self.chiffres_rangees.index(position[1]) -
1) * self.n_pixels_par_case + self.n_pixels_par_case // 2
coordonnee_x = self.lettres_colonnes.index(position[
0]) * self.n_pixels_par_case + self.n_pixels_par_case // 2
piece = self.echiquier.dictionnaire_pieces[position]
uni = ""
for e in list(self.caracteres_pieces.keys()):
if type(e) == type(piece) and e.couleur == piece.couleur:
uni = self.caracteres_pieces[e]
break
self.create_text(coordonnee_x,
coordonnee_y,
text=uni,
font=('Deja Vu', self.n_pixels_par_case // 2),
tags='piece')
def __init__(self, master, couleur, **kwargs):
# Le widget est une fenêtre qui sera esclave d'un échiquier
tk.Toplevel.__init__(self, master)
self.master = master
self.master.passer_en_mode_attente()
self.transient(self.master)
self.code_piece_choisie = tk.StringVar()
self.couleur = tk.StringVar()
self.couleur.set(couleur)
# Frames contenant les widgets esclaves, pour la mise en page
self.frameMessage = tk.Frame(self)
self.frameBouton = tk.Frame(self)
self.frameChoix = tk.Frame(self)
# Les boutons et leurs handlers
self.boutonDame = BoutonPiece(self.frameBouton, Dame(couleur))
self.boutonDame.configure(command=lambda: self.decider("D"))
self.boutonTour = BoutonPiece(self.frameBouton, Tour(couleur))
self.boutonTour.configure(command=lambda: self.decider("T"))
self.boutonFou = BoutonPiece(self.frameBouton, Fou(couleur))
self.boutonFou.configure(command=lambda: self.decider("F"))
self.boutonCavalier = BoutonPiece(self.frameBouton, Cavalier(couleur))
self.boutonCavalier.configure(command=lambda: self.decider("C"))
self.bouton_ok = tk.Button(self.frameChoix,
text="Choisir",
font=("default", 25, "normal"),
state=tk.DISABLED,
command=self.disparaitre)
self.messagePromotion = tk.Label(
self.frameMessage,
text="Vous devez choisir une pièce pour promouvoir le pion",
font=("default", 25, "normal"))
self.boutons = {
"D": self.boutonDame,
"T": self.boutonTour,
"F": self.boutonFou,
"C": self.boutonCavalier
}
# Assemblage de la fenêtre
self.messagePromotion.pack()
self.boutonDame.pack(side=tk.LEFT, padx=20)
self.boutonTour.pack(side=tk.LEFT, padx=20)
self.boutonFou.pack(side=tk.LEFT, padx=20)
self.boutonCavalier.pack(side=tk.LEFT, padx=20)
self.bouton_ok.pack(padx=20)
self.frameMessage.pack(side=tk.TOP, padx=20, pady=20)
self.frameBouton.pack(side=tk.BOTTOM, padx=20, pady=20)
self.frameChoix.pack(side=tk.BOTTOM, padx=20, pady=20)
# On ne veut pas que le joueur puisse cliquer sur l'échiquier quand la fenêtre est affichée
self.focus_set()
self.grab_set()
def deposer(self, event):
toutes_les_position = [
'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'b1', 'b2', 'b3',
'b4', 'b5', 'b6', 'b7', 'b8', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6',
'c7', 'c8', 'd1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'e1',
'e2', 'e3', 'e4', 'e5', 'e6', 'e7', 'e8', 'f1', 'f2', 'f3', 'f4',
'f5', 'f6', 'f7', 'f8', 'g1', 'g2', 'g3', 'g4', 'g5', 'g6', 'g7',
'g8', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'h7', 'h8'
]
# On trouve le numéro de ligne/colonne en divisant les positions en y/x par le nombre de pixels par case.
ligne = event.y // self.canvas_echiquier.n_pixels_par_case
colonne = event.x // self.canvas_echiquier.n_pixels_par_case
global position_cible
position_cible = "{}{}".format(
self.canvas_echiquier.partie.echiquier.lettres_colonnes[colonne],
int(self.canvas_echiquier.partie.echiquier.chiffres_rangees[
self.canvas_echiquier.n_lignes - ligne - 1]))
if self.partie.echiquier.deplacement_est_valide(
self.position_selectionnee, position_cible) == True:
self.sauvegarder("Revenir")
try:
var = 1
if self.partie.echiquier.couleur_piece_a_position(
self.position_selectionnee) == self.partie.joueur_actif:
if self.partie.echiquier.deplacer(self.position_selectionnee,
position_cible) == True:
self.partie.echiquier.deplacer(self.position_selectionnee,
position_cible)
var = 0
if isinstance(
self.partie.echiquier.recuperer_piece_a_position(
position_cible), Pion) == True:
if self.partie.echiquier.couleur_piece_a_position(
position_cible) == 'blanc':
if position_cible[1] == '8':
self.partie.echiquier.dictionnaire_pieces[
position_cible] = Dame('blanc')
self.canvas_echiquier.dessiner_cases()
self.canvas_echiquier.dessiner_pieces()
elif self.partie.echiquier.couleur_piece_a_position(
position_cible) == 'noir':
if position_cible[1] == '1':
self.partie.echiquier.dictionnaire_pieces[
position_cible] = Dame('noir')
self.canvas_echiquier.dessiner_cases()
self.canvas_echiquier.dessiner_pieces()
self.canvas_echiquier.dessiner_cases()
self.canvas_echiquier.dessiner_pieces()
self.partie.partie_terminee()
for i in toutes_les_position:
if self.partie.echiquier.deplacement_est_valide(
position_cible, i) and isinstance(
self.partie.echiquier.
recuperer_piece_a_position(i),
Roi) == True:
self.partie.joueur_suivant()
self.messages['foreground'] = 'red'
self.messages[
'text'] = 'Le Roi ' + self.partie.joueur_actif + ' est en échec'
self.partie.joueur_suivant()
self.canvas_echiquier.dessiner_cases()
self.canvas_echiquier.dessiner_pieces()
if isinstance(
self.partie.echiquier.
recuperer_piece_a_position(i),
Pion) == True or isinstance(
self.partie.echiquier.
recuperer_piece_a_position(i),
Tour) == True or isinstance(
self.partie.echiquier.
recuperer_piece_a_position(i),
Fou) == True or isinstance(
self.partie.echiquier.
recuperer_piece_a_position(i),
Cavalier) == True or isinstance(
self.partie.echiquier.
recuperer_piece_a_position(i),
Dame) == True:
var = 1
self.partie.joueur_suivant()
self.label_temporaire[
'text'] = "C'est le tour au joueur " + self.partie.joueur_actif
else:
raise self.DeplacementInvalide
except self.DeplacementInvalide:
self.messages['foreground'] = 'red'
self.messages['text'] = 'Erreur: Deplacement invalide'
self.canvas_echiquier.dessiner_cases()
self.canvas_echiquier.dessiner_pieces()
if self.partie.partie_terminee() == True:
for i in toutes_les_position:
if isinstance(
self.partie.echiquier.recuperer_piece_a_position(i),
Roi) == True:
couleur = self.partie.echiquier.couleur_piece_a_position(i)
self.messages['foreground'] = 'red'
self.messages['text'] = 'La partie est terminer.'
self.label_temporaire['text'] = 'Félicitation joueur ' + couleur
if var == 0:
self.label_temporaire['text'] = 'Partie nulle de type pat'
var2 = 1
self.canvas_echiquier.dessiner_cases()
self.canvas_echiquier.dessiner_pieces()
self.canvas_echiquier.dessiner_cases()
self.canvas_echiquier.dessiner_pieces()
def deplacer(self, position_source, position_cible):
"""
Permet de d'appeler le mouvement à la méthode déplacer du module Échiquier.
Permet aussi de recalculer les pièces mangées qui sert dans le visuel du jeux.
En même temps, sert à écrire ce qui sera communiquer au joueur sur la liste des déplacements
dans le Listbox du jeux.
Args:
position_source (str): Position de source de la pièce
position_cible (str): Position cible de la pièce
"""
piece = self.echiquier.recuperer_piece_a_position(position_source)
#Pour le roque
if self.echiquier.deplacement_est_valide(position_source,
position_cible):
self.hist.append(piece)
self.echiquier.deplacer(position_source, position_cible)
self.joueur_suivant()
self.dernierDeplacement = [
"(" + piece.couleur + ")" + position_source + "->" + position_cible
]
self.listeDeplacements.append(self.dernierDeplacement)
echiquierCopy = dict(self.echiquier.dictionnaire_pieces)
self.echiquier.listeDesEchiquiers.append(echiquierCopy)
self.dictionnaire_pieces_initial = {
'a1': Tour('blanc'),
'b1': Cavalier('blanc'),
'c1': Fou('blanc'),
'd1': Dame('blanc'),
'e1': Roi('blanc'),
'f1': Fou('blanc'),
'g1': Cavalier('blanc'),
'h1': Tour('blanc'),
'a2': Pion('blanc'),
'b2': Pion('blanc'),
'c2': Pion('blanc'),
'd2': Pion('blanc'),
'e2': Pion('blanc'),
'f2': Pion('blanc'),
'g2': Pion('blanc'),
'h2': Pion('blanc'),
'a7': Pion('noir'),
'b7': Pion('noir'),
'c7': Pion('noir'),
'd7': Pion('noir'),
'e7': Pion('noir'),
'f7': Pion('noir'),
'g7': Pion('noir'),
'h7': Pion('noir'),
'a8': Tour('noir'),
'b8': Cavalier('noir'),
'c8': Fou('noir'),
'd8': Dame('noir'),
'e8': Roi('noir'),
'f8': Fou('noir'),
'g8': Cavalier('noir'),
'h8': Tour('noir'),
}
self.setBlanc = set()
self.setNoir = set()
for i in self.dictionnaire_pieces_initial.values():
if i.est_blanc():
self.setBlanc.add(i)
else:
self.setNoir.add(i)
self.resteBlanc = set()
self.resteNoir = set()
for i in self.echiquier.dictionnaire_pieces.values():
if i.est_blanc():
self.resteBlanc.add(i)
else:
self.resteNoir.add(i)
self.gapBlanc = list(self.echiquier.setBlanc - self.resteBlanc)
self.gapNoir = list(self.echiquier.setNoir - self.resteNoir)