def __init__(self, parent, n_pixels_par_case):
# Nombre de lignes et de colonnes.
self.n_lignes = 8
self.n_colonnes = 8
# Création d'une partie d'échec dans le Canvas
self.partie = Partie()
# Noms des lignes et des colonnes.
self.chiffres_rangees = ['1', '2', '3', '4', '5', '6', '7', '8']
self.lettres_colonnes = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
# Nombre de pixels par case, variable.
self.n_pixels_par_case = n_pixels_par_case
# Appel du constructeur de la classe de base (Canvas).
# La largeur et la hauteur sont déterminés en fonction du nombre de cases.
super().__init__(parent,
width=self.n_lignes * n_pixels_par_case,
height=self.n_colonnes * self.n_pixels_par_case)
# On utilise le dictionnaire de pièces intégré dans l'échiquier
self.pieces = self.partie.echiquier.dictionnaire_pieces
# Couleur d'arrière plan de l'échiquier (Avec le blanc)
self.couleur_theme = 'grey'
# On fait en sorte que le redimensionnement du canvas redimensionne son contenu. Cet événement étant également
# généré lors de la création de la fenêtre, nous n'avons pas à dessiner les cases et les pièces dans le
# constructeur.
self.bind('<Configure>', self.redimensionner)
def __init__(self):
super().__init__()
self.protocol("WM_DELETE_WINDOW", self.fermeture)
# Nom de la fenêtre.
self.title("Échiquier")
#Initialisation d'une partie
self.partie = Partie()
# Truc pour le redimensionnement automatique des éléments de la fenêtre.
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
# Création du canvas échiquier.
self.canvas_echiquier = CanvasEchiquier(self, 60, self.partie)
self.canvas_echiquier.grid(sticky=NSEW)
# Ajout d'une étiquette d'information.
self.messages = Label(self)
self.messages.grid()
# Ajout d'une étiquette qui indique le joueur actif.
self.messages_joueur_actif = Label(self)
self.messages_joueur_actif['text'] = (
"C'est au joueur blanc de commencer! ")
self.messages_joueur_actif['foreground'] = 'blue'
self.messages_joueur_actif.grid()
# On lie un clic sur le CanvasEchiquier à une méthode.
self.canvas_echiquier.bind('<Button-1>', self.selectionner)
# Ajout d'un cadre pour regrouper les boutons
frame_boutons = Frame(self)
frame_boutons.grid(row=0, column=1)
#Bouton pour annuler le dernier mouvement.
bouton_dernier_mouvement = bouton_sauvegarder = Button(
frame_boutons,
text="Annuler le dernier mouvement",
command=self.charger_dernier_mouvement)
bouton_dernier_mouvement.grid()
#Ajout des boutons pour sauvegarder et charger une partie.
bouton_sauvegarder = Button(frame_boutons,
text="Sauvegarder la partie",
command=self.sauvegarder_partie)
bouton_charger = Button(frame_boutons,
text="Charger la partie",
command=self.charger_partie)
bouton_sauvegarder.grid()
bouton_charger.grid()
#Ajout d'un bouton pour commencer une nouvelle partie.
bouton_nouvelle_partie = Button(frame_boutons,
text="Nouvelle partie",
command=self.nouvelle_partie)
bouton_nouvelle_partie.grid()
def nouvelle_partie(self):
self.canvas_echiquier.partie = Partie()
self.partie = self.canvas_echiquier.partie
self.canvas_echiquier.rafraichir()
self.mise_a_jour_message_joueur_actif()
self.messages['text'] = ""
def __init__(self,
parent,
n_pixels_par_case,
store_filename='annulerdeplacement.txt'):
# Nombre de lignes et de colonnes.
self.n_lignes = 8
self.n_colonnes = 8
# Noms des lignes et des colonnes.
self.chiffres_rangees = ['1', '2', '3', '4', '5', '6', '7', '8']
self.lettres_colonnes = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
# Nombre de pixels par case, variable.
self.n_pixels_par_case = n_pixels_par_case
# Appel du constructeur de la classe de base (Canvas).
# La largeur et la hauteur sont déterminés en fonction du nombre de cases.
super().__init__(parent,
width=self.n_lignes * n_pixels_par_case,
height=self.n_colonnes * self.n_pixels_par_case)
# On fait en sorte que le redimensionnement du canvas redimensionne son contenu. Cet événement étant également
# généré lors de la création de la fenêtre, nous n'avons pas à dessiner les cases et les pièces dans le
# constructeur.
self.bind('<Configure>', self.redimensionner)
# Importation de Échequier et partie et Fenetre
self.echequier = Echiquier()
self.partie = Partie()
self.fenetre = Fenetre
# Dictionnaire contenant les pièces. Vous devinerez, si vous réutilisez cette classe dans votre TP4,
# qu'il fandra adapter ce code pour plutôt utiliser la classe Echiquier.
self.pieces = self.echequier.dictionnaire_pieces
# Les variables nécessaires pour la fonction déplacement
self.selectionner = 0
self.case_source = ""
self.case_cible = ""
# Déterminer le gagnant
self.gagnant_noir = False
self.gagnant_blanc = False
# Enregistrement des coups
self.texte = ""
# Fichier text annuler déplacement
self.store_filename = os.path.join(BASE_DIR, store_filename)
self.t = 0
def __init__(self,
store_filename='partie1.bin',
store_filename2='partie2.bin',
store_filename3="deplacements1.txt",
store_filename4='deplacements2.txt'):
super().__init__()
self.title("Échiquier")
# Background de la fenêtre.
self.config(bg="AntiqueWhite1")
# La position sélectionnée.
self.position_selectionnee = None
# Truc pour le redimensionnement automatique des éléments de la fenêtre.
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
# Création du canvas échiquier.
self.canvas_echiquier = CanvasEchiquier(self, 60)
self.canvas_echiquier.grid(sticky=NSEW)
# Ajout d'une étiquette d'information.
self.messages = Label(self)
self.messages.grid()
# Ajout d'un message box
self.message_alerte = messagebox
# On lie un clic sur le CanvasEchiquier à une méthode.
self.canvas_echiquier.bind('<Button-1>', self.canvas_echiquier.jouer)
# Les variables nécessaires pour la fonction déplacement
self.selectionner = 0
self.case_source = ""
self.case_cible = ""
self.echiquier = Echiquier()
# Frame unique pour les autres fonctions
self.cadre_fonctions = Frame(self, relief="groove")
self.cadre_fonctions.grid(row=0, column=1, padx=10, pady=10, sticky=S)
self.cadre_fonctions.config(bg="AntiqueWhite1")
self.cadre_fonctions_partie = Frame(self, relief="groove")
self.cadre_fonctions_partie.config(bg="AntiqueWhite1")
self.cadre_fonctions_partie.grid(row=0,
column=1,
padx=10,
pady=10,
sticky=N)
# On importe les fonctions de parties
self.partie = Partie()
# L'emplacement du file
self.store_filename = os.path.join(BASE_DIR, store_filename)
self.store_filename2 = os.path.join(BASE_DIR, store_filename2)
self.store_filename3 = os.path.join(BASE_DIR, store_filename3)
self.store_filename4 = os.path.join(BASE_DIR, store_filename4)
# Pour savoir nous sommes actuellement dans quel partie
self.partie_actuel = 0
# Label compteur
self.m = 2
self.s = 0
self.compteur = StringVar()
self.compteur.set(str(self.m) + ":" + str(self.s))
self.lbl_compteur1 = Label(self.cadre_fonctions_partie,
textvariable=self.compteur,
bd=4,
relief="groove",
height=2).grid(row=0,
column=0,
sticky=NSEW,
padx=10,
pady=10)
# Label joueur actif
self.joueur_actif = StringVar()
self.joueur_actif.set("C'est le tour du joueur {}.".format(
self.canvas_echiquier.partie.joueur_actif))
self.lbl_joueur_actif = Label(self.cadre_fonctions_partie,
textvariable=self.joueur_actif,
relief="groove",
bg="green",
height=2).grid(row=1,
column=0,
sticky=NSEW,
padx=10,
pady=10)
# Label Menu de partie
self.lbl_options_de_partie = Label(self.cadre_fonctions_partie, text="Menu", relief="sunken",
font="Arial 13 bold").grid \
(row=2, column=0, sticky=NSEW, padx=10, pady=10)
# Bouton Nouvelle Partie
self.btn_nouvelle_partie = Button(
self.cadre_fonctions_partie,
text="Nouvelle partie",
command=self.alerte_nouvelle_partie).grid(row=3,
column=0,
sticky=NSEW)
# Bouton Fin du tour
self.btn_fin_du_tour = Button(self.cadre_fonctions_partie,
bg="yellow",
text="Fin du tour",
relief="groove",
height=2,
command=self.fin_du_tour).grid(
row=2,
column=0,
sticky=NSEW,
padx=10,
pady=10)
# Bouton Sauvegarder
self.btn_Sauvegarder = Button(
self.cadre_fonctions_partie,
text="Sauvegarder la partie",
command=self.alerte_sauvegarder_partie).grid(row=4,
column=0,
sticky=NSEW)
# Bouton Charger
self.btn_Charger = Button(self.cadre_fonctions_partie,
text="Charger une partie",
command=self.alerte_charger_partie).grid(
row=5, column=0, sticky=NSEW)
# Boutton Quitter
self.btn_quitter = Button(self.cadre_fonctions_partie,
text="Quitter",
command=self.quit).grid(row=6,
column=0,
sticky=NSEW)
# Label options de partie
self.lbl_options_de_partie = Label(self.cadre_fonctions, text="Options", relief="sunken",
font="Arial 13 bold").grid \
(row=1, column=0, sticky=NSEW, padx=10, pady=10)
# Boutton revoir la partie
self.btn_revoir_partie = Button(
self.cadre_fonctions,
text="Revoir une partie",
command=self.alert_revoir_une_partie).grid(row=7,
column=0,
sticky=NSEW)
# Bouton annuler deplacement
self.btn_console = Button(self.cadre_fonctions,
text="Annuler le dernier mouvement",
command=self.annuler_deplacement).grid(
row=8, column=0, sticky=NSEW)
# Bouton pour afficher les déplacements effectués
self.btn_console = Button(
self.cadre_fonctions,
text="Afficher les déplacements effectués",
command=self.afficher_liste_deplacements).grid(row=9,
column=0,
sticky=NSEW)
# Bouton pour lire les règlements du jeux
self.btn_reglement = Button(
self.cadre_fonctions,
text="Voir les règlements du jeux en ligne",
command=self.openweb).grid(row=10, column=0, sticky=NSEW)
# Bouton changer thème:
self.btn_changer_theme = Button(self.cadre_fonctions,
text="Changer le thème",
command=self.changer_theme).grid(
row=11, column=0, sticky=NSEW)
# -*- coding: utf-8 -*-
"""Module principal du package pychecs2. C'est ce module que nous allons exécuter pour démarrer votre jeu.
Importez les modules nécessaires et démarrez votre programme à partir d'ici. Le code fourni n'est qu'à titre d'exemple.
"""
from pychecs2.echecs.partie import Partie
from pychecs2.interface.exemple import Fenetre
if __name__ == '__main__':
# Création d'une instance de Partie.
p = Partie()
# Affichage de l'échiquier dans cette partie.
# print(p.echiquier)
# Création et affichage d'une fenêtre (aucun lien avec la partie ci-haut).
Fenetre().mainloop()
#test push
def __init__(self):
super().__init__()
# Nom de la fenêtre.
self.title("Chess")
# quelques attributs à utiliser plustard
self.position_source = None
self.option_indice = 0
self.protocol(
'WM_DELETE_WINDOW', self.demander
) # cette instruction fait appel a une fonction si le joueur
# click sur le bouton fermé de la fenetre tk
# Création du canvas échiquier.
self.canvas_echiquier = CanvasEchiquier(self, 50)
self.canvas_echiquier.grid(padx=0,
pady=0,
sticky=NSEW,
row=0,
column=0,
rowspan=2)
# Redimensionnement automatique du canvas.
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
# Label pour les infos sur la partie, voir les paramètres 'text=...' pour avoir plus de détails sur chaque sous-fram
self.frame_infos = LabelFrame(self,
borderwidth=3,
relief=RIDGE,
text="Information sur la partie")
self.frame_infos.grid(row=0, column=1, sticky=N)
self.mon_label_info = Label(self.frame_infos,
font=("DejaVu Sans", 16),
text="C'est au tour du joueur blanc")
self.mon_label_info.grid(columnspan=4)
self.prises_blanc = Label(self.frame_infos,
borderwidth=2,
relief=RIDGE,
font=("DejaVu Sans", 8),
text="Prises du\njoueur blanc")
self.prises_blanc.grid(row=1, column=0, sticky=N + W)
self.prises_noir = Label(self.frame_infos,
borderwidth=2,
relief=RIDGE,
font=("DejaVu Sans", 8),
text="Prises du\njoueur noir")
self.prises_noir.grid(row=1, column=1, sticky=N + E)
self.depla_blanc = Label(self.frame_infos,
borderwidth=2,
relief=RIDGE,
font=("DejaVu Sans", 8),
text="Liste des déplacements\njoueur blanc")
self.depla_blanc.grid(row=1, column=2, sticky=N + W)
self.depla_noir = Label(self.frame_infos,
borderwidth=2,
relief=RIDGE,
font=("DejaVu Sans", 8),
text="Liste des déplacements\njoueur noir")
self.depla_noir.grid(row=1, column=3, sticky=N + E)
# Label pour le menu (contenant des bouton) de la partie, voir les paramètres 'text=...' pour avoir plus de
# détails sur cache bouton: chaque bouton envoi vers une fonction voir les paramètres 'command=...'
self.frame_menu = LabelFrame(self,
borderwidth=3,
relief=RIDGE,
text="Menu de la partie")
self.frame_menu.grid(row=1, column=1, sticky=NSEW, padx=10, pady=0)
self.nouvelle = Button(self.frame_menu,
text="Nouvelle partie",
command=self.nouvelle_partie)
self.nouvelle.grid(sticky=NSEW, row=0, column=0)
self.sauv = Button(self.frame_menu,
text="Sauvegarder la partie",
command=self.save)
self.sauv.grid(sticky=NSEW, row=1, column=0)
self.load = Button(self.frame_menu,
text="Charger une partie",
command=self.load)
self.load.grid(sticky=NSEW, row=2, column=0)
self.infos = Button(self.frame_menu,
text="Informations sur le jeu",
command=self.infos_et_règles)
self.infos.grid(sticky=NSEW, row=3, column=0)
self.annul = Button(self.frame_menu,
text="Annuler le dernier déplacement",
command=self.annuler)
self.annul.grid(sticky=NSEW, row=4, column=0)
self.o = Button(self.frame_menu,
text="Passez la main à l'ordi",
command=self.ordi)
self.o.grid(sticky=N + E + W, row=0, column=1)
self.o_h_a = Checkbutton(
self.frame_menu,
text="Activer cette case puis faites un\nclick droit sur la piece "
"voulu\npour voir les possibilitées\nqui s'offrent à "
"vous",
command=self.activer_indice)
self.o_h_a.grid(sticky=NSEW, row=1, column=1, rowspan=3)
self.partie = Partie(self.canvas_echiquier.echiquier)
# Ajout d'une étiquette d'information.
self.messages = Label(self, font=("DejaVu Sans", 16))
self.messages.grid(row=2, columnspan=2)
# On lie un clic sur le CanvasEchiquier à une méthode.
self.canvas_echiquier.bind('<Button-3>', self.option_hint)
self.canvas_echiquier.bind('<Button-1>', self.selectionner_source)
self.canvas_echiquier.bind('<ButtonRelease-1>',
self.selectionner_cible)
def __init__(self):
super().__init__()
# Nom de la fenêtre.
self.title("Échiquier")
# Creation d'une nouvelle partie
self.partie = Partie()
self.sauvegarder("Revenir")
# La position sélectionnée.
self.position_selectionnee = None
# Truc pour le redimensionnement automatique des éléments de la fenêtre.
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
# Création du canvas échiquier.
self.canvas_echiquier = CanvasEchiquier(self, 60, self.partie)
self.canvas_echiquier.grid(sticky=NSEW)
# Frame bouton Sauvegare/NG/coup précédent
self.frame_sauvegarde = Frame(self)
self.frame_sauvegarde.grid(row=1)
# label invisible
self.label_invisible1 = Label(self.frame_sauvegarde)
self.label_invisible1.grid(row=0)
# Creation d'un bouton nouvelle partie
self.boutton_nouvelle_partie = Button(self.frame_sauvegarde,
text='Nouvelle Partie',
command=self.nouvelle_partie)
self.boutton_nouvelle_partie.grid()
# label invisible
self.label_invisible2 = Label(self.frame_sauvegarde)
self.label_invisible2.grid(row=1, column=2)
# Creation d'un bouton précédant
self.boutton_revenir = Button(self.frame_sauvegarde,
text='Coup précédant',
command=self.revenir)
self.boutton_revenir.grid(row=1, column=3)
# label invisible
self.label_invisible2 = Label(self.frame_sauvegarde)
self.label_invisible2.grid(row=1, column=4)
# Sauvegarder
self.boutton_sauvegarde = Button(self.frame_sauvegarde,
text='Sauvegarder',
command=self.faire_sauvegarder)
self.boutton_sauvegarde.grid(row=1, column=5)
# label invisible
self.label_invisible2 = Label(self.frame_sauvegarde)
self.label_invisible2.grid(row=1, column=6)
# Charger
self.bouton_charger = Button(self.frame_sauvegarde,
text=' Charger ',
command=self.faire_charger)
self.bouton_charger.grid(row=1, column=7)
# Frame joueur actif
self.frame_info = LabelFrame(self, text="Joueur actif")
self.frame_info.grid(row=0, column=1, sticky=NW)
self.label_temporaire = Label(self.frame_info,
text="C'est le tour au joueur " +
self.partie.joueur_actif,
background='snow')
self.label_temporaire.grid(row=0, sticky=N, column=0)
# label invisible
self.label_invisible = Label(self.frame_info)
self.label_invisible.grid(row=1, column=0, padx=100)
# label theme
self.label_theme = Label(self.frame_info, text="Thème:")
self.label_theme.grid(row=2, sticky=W)
# Changer de thème
self.valeur = StringVar()
self.boite_theme = ttk.Combobox(self.frame_info,
textvariable=self.valeur,
state="readonly")
self.boite_theme["values"] = [
"Classique", "Noel", "Saint-Valentin", "Doritos-MountainDew"
]
self.boite_theme.current(0)
self.boite_theme.grid(row=3)
self.boite_theme.bind("<<ComboboxSelected>>", self.changer_theme)
# label invisible
self.label_invisible = Label(self.frame_info)
self.label_invisible.grid(row=4, column=0)
# label invisible
self.label_invisible = Label(self.frame_info)
self.label_invisible.grid(row=5, column=0)
# label invisible
self.label_invisible = Label(self.frame_info)
self.label_invisible.grid(row=6, column=0)
# label invisible
self.label_invisible = Label(self.frame_info)
self.label_invisible.grid(row=7, column=0)
# label invisible
self.label_invisible = Label(self.frame_info)
self.label_invisible.grid(row=8, column=0)
# bouton Reglement
self.bouton_reglement = Button(self.frame_info,
text='Règlements',
command=self.montre_reglement)
self.bouton_reglement.grid(row=9, column=0)
# label invisible
self.label_invisible = Label(self.frame_info)
self.label_invisible.grid(row=10, column=0)
# bouton Troll
self.bouton_troll = Button(self.frame_info,
text='Ne pas cliquer :)',
background='red',
command=self.troll)
self.bouton_troll.grid(row=11, column=0)
# label invisible
self.label_invisible = Label(self.frame_info)
self.label_invisible.grid(row=12, column=0, pady=58)
# label note
self.label_note = Label(self.frame_info,
text='*Note:',
background='yellow')
self.label_note.grid(row=13, column=0, sticky=NW)
self.label_clic1 = Label(self.frame_info,
text='Clique gauche = Sélectionner pièce')
self.label_clic1.grid(row=14, column=0, sticky=NW)
self.label_clic2 = Label(self.frame_info,
text='Clique droit = Déposer pièce')
self.label_clic2.grid(row=15, column=0, sticky=NW)
# Ajout d'une étiquette d'information.
self.messages = Label(self)
self.messages.grid()
# On lie un clic sur le CanvasEchiquier à une méthode.
self.canvas_echiquier.bind('<Button-1>', self.selectionner)
self.canvas_echiquier.bind('<Button-3>', self.deposer)
def __init__(self):
super().__init__()
self.estTermine = False
self.estSauvegarde = False
self.listemovements = []
self.listepiecesnoirs = []
self.listepiecesblanches = []
self.chrono_actif = False
# On redéfinie ce qui se passe lors de la fermeture du fichier.
self.protocol("WM_DELETE_WINDOW", self.demandesauvegarde)
# Nom de la fenêtre.
self.title("Échiquier")
self.partie = Partie()
# La position sélectionnée.
self.position_selectionnee = None
# Truc pour le redimensionnement automatique des éléments de la fenêtre.
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
# Création du canvas échiquier.
self.canvas_echiquier = CanvasEchiquier(self, 60, self.partie)
self.canvas_echiquier.grid(row=0, column=0, sticky=NSEW)
# Création du menu
self.menubar = BarreMenu(self, self.canvas_echiquier)
self.config(menu=self.menubar)
# Ajout d'une étiquette d'information.
self.lblMessages = Label(self)
self.lblMessages.config(font=("Courier", 18))
self.lblMessages.grid()
self.lblMessagejoueuractif = Label(self)
self.lblMessagejoueuractif['text'] = 'Tour du joueur blanc'
self.lblMessagejoueuractif.config(font=("Courier", 18))
self.lblMessagejoueuractif.grid()
# Listes des pièces perdues par chaque joueurs
self.lblpiecesblanches = Label(self, anchor='w')
self.lblpiecesblanches.grid(row=4, column=0)
self.lblpiecesblanches.config(font=("Courier", 14))
self.lblpiecesblanches['text'] = 'Pièces noires perdues: '
self.lblpiecesnoires = Label(self, anchor='w')
self.lblpiecesnoires.config(font=("Courier", 14))
self.lblpiecesnoires.grid(row=4, column=1)
self.lblpiecesnoires['text'] = 'Pièces blanches perdues: '
# Création d'une zone de texte pour l'affichage des déplacements.
self.afficher_deplacement = False
self.txtListe = Text(self)
self.txtListe.grid(row=0, column=1, sticky=NSEW)
self.lblListe = Label(self)
self.lblListe['text'] = 'La liste des mouvements'
self.lblListe.grid(row=1, column=1, sticky=NSEW)
# On lie un clic sur le CanvasEchiquier à une méthode.
self.canvas_echiquier.bind('<Button-1>', self.selectionner)
# chrono
self.chrono = Label(text="")
self.chrono.grid(row=5, column=0, sticky=NSEW)
self.minute = 0
self.second = 0
self.color_chrono = "blue"
def __init__(self):
super().__init__()
# Nom de la fenêtre.
self.title("Échiquier")
self.partie = Partie()
#Bouton X (pour quitter)
self.protocol('WM_DELETE_WINDOW', self.message_quitter)
# Truc pour le redimensionnement automatique des éléments de la fenêtre.
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
# Création du canvas échiquier.
self.canvas_echiquier = CanvasEchiquier(self, 60, self.partie)
self.canvas_echiquier.grid(sticky=NSEW)
##########################################################
# #
# VISUEL #
# #
##########################################################
# Étiquette d'information et de sélection des pièces
self.messages = Label(self)
self.messages['foreground'] = 'black'
self.messages['text'] = "Bienvenue au super jeux d'échec!"
self.messages.grid(row=1, sticky='w')
# # Étiquette d'information sur le joueur courant
self.messages1 = Label(self)
self.messages1[
'text'] = "Au tour du joueur: " + self.partie.joueur_actif.upper()
self.messages1.grid(row=2, sticky='w')
self.messages1['foreground'] = 'blue'
# Création du frame a droite du canevas
self.monFramePrincipal = Frame(self)
self.monFramePrincipal.grid(row=0, column=1, sticky='n')
# FRAME a DROITE: Fenetre pour afficher la liste des déplacements effectués
self.mon_frame1 = LabelFrame(self.monFramePrincipal,
text="Les déplacements ",
borderwidth=2,
relief=RIDGE,
padx=5,
pady=5)
self.mon_frame1.grid(row=0, column=0, sticky='n')
self.yScroll = Scrollbar(self.mon_frame1, orient=VERTICAL)
self.yScroll.grid(row=0, column=1, sticky=N + S)
#small_font = font(size=5)
self.liste1 = Listbox(self.mon_frame1, yscrollcommand=self.yScroll.set)
self.liste1 = Listbox(self.mon_frame1)
self.liste1.grid(row=0, column=0)
self.yScroll['command'] = self.liste1.yview
# Creation d'un espace pour mettre les 2 fenetres de pièces mangées (un sous-Frame)
self.monSousFrame = Frame(self.monFramePrincipal)
self.monSousFrame.grid(row=1, column=0, sticky='n')
# FRAME a DROITE: Fenetre pour afficher les pieces blanches mangées
self.mon_frame2 = LabelFrame(self.monSousFrame,
text="Les blancs\nmangés ",
borderwidth=2,
relief=RIDGE,
padx=5,
pady=5,
width=7)
self.mon_frame2.grid(row=0, column=0, sticky='n')
self.yScroll = Scrollbar(self.mon_frame2, orient=VERTICAL)
self.yScroll.grid(row=0, column=1, sticky=N + S)
self.liste2 = Listbox(self.mon_frame2, yscrollcommand=self.yScroll.set)
self.liste2 = Listbox(self.mon_frame2, width=7)
self.liste2.grid(row=0, column=0)
self.yScroll['command'] = self.liste2.yview
# FRAME a DROITE: Fenetre pour afficher les pieces noires mangées
self.mon_frame2 = LabelFrame(self.monSousFrame,
text="Les noirs\nmangés ",
borderwidth=2,
relief=RIDGE,
padx=5,
pady=5,
width=7)
self.mon_frame2.grid(row=0, column=1, sticky='n')
self.yScroll = Scrollbar(self.mon_frame2, orient=VERTICAL)
self.yScroll.grid(row=0, column=1, sticky=N + S)
self.liste3 = Listbox(self.mon_frame2, yscrollcommand=self.yScroll.set)
self.liste3 = Listbox(self.mon_frame2, width=7)
self.liste3.grid(row=0, column=0)
self.yScroll['command'] = self.liste3.yview
# FRAME a DROITE: Bouton pour se connecter au site web des intrusctions d'echec
self.mon_frame3 = Frame(self.monFramePrincipal,
borderwidth=2,
relief=RIDGE,
padx=5,
pady=5)
self.mon_frame3.grid(row=2, column=0, sticky='n')
but1 = Button(self.mon_frame3,
text="Lien web pour accéder\naux règles du jeux!",
command=self.ouvrirURL).grid(row=0, column=0)
# Frame pour les options de jeux en bas de l'échiquier
self.mon_frame = LabelFrame(self,
text="Options de partie",
borderwidth=2,
relief=RIDGE,
padx=5,
pady=5)
self.mon_frame.grid(row=4, column=0, sticky='w')
bouton_sauver = Button(self.mon_frame,
text="Sauvegarder",
command=self.sauvergarder).grid(row=0, column=0)
bouton_charge = Button(self.mon_frame,
text="Charger",
command=self.message_charger).grid(row=0,
column=1)
bouton_demarrer = Button(self.mon_frame,
text="Redémarrage",
command=self.message_reinitialiser).grid(
row=0, column=2)
bouton_annuler = Button(self.mon_frame,
text="Annuler dernier mouvement",
command=self.annulerDernierMouvement).grid(
row=0, column=3)
# On lie un clic sur le CanvasEchiquier à une méthode.
self.canvas_echiquier.bind('<Button-1>', self.selectionner)
self.piece_a_deplacer = None
self.position_piece_a_deplacer = None
#Pour que x et y soient accessibles dans selectionner ET dans creer_carre_selection
self.x = 1
self.y = 1
