def __init__(self):
"""Constructeur de la classe FenetrePartie. On initialise une partie en utilisant la classe Partie du TP3 et
on dispose les «widgets» dans la fenêtre.
"""
# Appel du constructeur de la classe de base (Tk)
super().__init__()
# La partie
self.partie = Partie()
# Création du canvas damier.
self.canvas_damier = CanvasDamier(self, self.partie.damier, 60)
self.canvas_damier.grid(sticky=NSEW)
self.canvas_damier.bind('<Button-1>', self.selectionner)
# Ajout d'une étiquette d'information.
self.messages = Label(self)
self.messages.grid()
# Nom de la fenêtre («title» est une méthode de la classe de base «Tk»)
self.title("Jeu de dames")
# Truc pour le redimensionnement automatique des éléments de la fenêtre.
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
self.messages['text'] = 'Bonjour'
def start(self):
pygame.display.flip()
menu = Menu(self.fenetre)
askToExit = False
while not askToExit:
for event in pygame.event.get():
if event.type == QUIT:
askToExit = True
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
askToExit = True
choix = menu.loop()
if choix <=0:
askToExit = True
if choix == 4:
regle = Regle(self.fenetre)
regle = regle.loop()
if regle <=0:
askToExit = True
if choix == 1:
niveau = Niveau(1)
joueurs = [Joueur(1),Joueur(1)]
partie = Partie(self.fenetre,niveau,joueurs)
askToExit = partie.start()
Joueur.i = 1
async def creerPartie(self,sid,data):
idJoueur = self.getJoueur(sid)
j = self.Joueurs[idJoueur]
partie = Partie("partie"+str(idJoueur), idJoueur, self.sio,self.fps,j)
self.Parties.append(partie)
await self.sio.emit('acces_partie', "success", room=sid)
j.etape=2
pass
partie.ready = True
def next_game(self):
"""
Permet de continuer une partie qui est terminée sans la redémarrer
:return: aucun paramètre
"""
self.partie = Partie(self.list_obj_joueur, self)
for i in self.de_buttom:
i.config(state="normal")
self.blancer.config(state="normal")
self.tour.config(state="disabled")
self.partie.jouer_partie()
self.tour.config(state="normal")
self.blancer.config(state="disabled")
for i in self.de_buttom:
i.config(state="disabled")
def charger_partie(self):
"""
Crée ou restaure une partie à partir de la fenêtre de départ, là où les joueurs doivent inscrire leurs paramètres.
:return:une fenêtre permettant au joueur de restaurer la partie déjà commencée
"""
self.master.partie = Partie(interface=self.master, joueurs=[])
self.master.partie.restaure()
self.master.partie.restore = True
self.grab_release()
self.master.focus_set()
self.destroy()
self.master.blancer.config(state="normal")
self.master.tour.config(state="disabled")
self.master.partie.jouer_partie()
self.master.tour.config(state="normal")
self.master.blancer.config(state="disable")
def nouvelle_parti(self):
"""Fonction qui démarre la partie et ferme la fenêtre.
"""
if self.nom_joueur1 == "" or self.nom_joueur2.get() == "":
w = Message(self,
text="SVP veuillez ajouter le nom des joueurs 1 et 2",
width=300)
w.grid(row=6, column=1, columnspan=6)
else:
list_joueur = []
est_joker = self.joker_d_as.get()
for i in range(0, len(self.master.de_buttom)):
self.master.de_buttom[i].config(state="normal")
self.master.list_obj_joueur = []
if (self.nom_joueur3.get() == ""):
self.master.frame_player3.destroy()
list_joueur.append(self.nom_joueur1.get())
list_joueur.append(self.nom_joueur2.get())
else:
list_joueur.append(self.nom_joueur1.get())
list_joueur.append(self.nom_joueur2.get())
list_joueur.append(self.nom_joueur3.get())
for i in list_joueur:
joueur = Joueur(i, self.master, est_joker)
self.master.list_obj_joueur.append(joueur)
self.master.partie = Partie(self.master.list_obj_joueur,
self.master)
self.grab_release()
self.master.focus_set()
self.destroy()
self.master.blancer.config(state="normal")
self.master.tour.config(state="disabled")
self.master.partie.jouer_partie()
self.master.tour.config(state="normal")
self.master.blancer.config(state="disabled")
for i in self.master.de_buttom:
i.config(state="disabled")
from partie import Partie
from plateau import Plateau
from constants import CASE_MUR,CASE_PORTE_OUVERTE,CASE_PORTE_FERMEE,CASE_SORTIE,CASE_VIDE,NB_PTS_DE_VIE_INIT,HOTE,PORT
listeJoueurs=[]
serveur_lance = True
clients_connectes = []
clients_a_lire = []
nbCoups=1
# Si la version Python utilisee est inferieure a 3, on sort (necessaire pour certaines fonctions)
gestionVersionPython()
nbJoueurs=nbJoueursAttendu() # On regarde dans parametres le nombre de joueurs attendus, on sort si probleme
# Creation du plateau de jeu
lePlateau=Plateau([],Partie(""))
lePlateau.chargerPlateau()
# Boucle sur le menu principal
sortieMenu=False
while sortieMenu==False :
print("Menu du jeu : ")
print(" J - Lancer le jeu avec les " + str(nbJoueurs) + " joueur(s) attendu(s)")
print(" V - Voir les cartes existantes")
print(" E - Editer les cartes")
print(" Q - Quitter le jeu")
choixMenuPrincipal = input("Entrez votre choix : ")
if choixMenuPrincipal=="J" or choixMenuPrincipal=="V" or choixMenuPrincipal=="E" or choixMenuPrincipal=="Q" or choixMenuPrincipal=="j" or choixMenuPrincipal=="v" or choixMenuPrincipal=="e" or choixMenuPrincipal=="q" :
if choixMenuPrincipal=="Q" or choixMenuPrincipal=="q" :
from joueur import Joueur
if __name__ == "__main__":
print("Bienvenue au Poker d'As!")
max_joueurs = 3
min_joueurs = 1
nb_joueurs = 0
while nb_joueurs < min_joueurs or nb_joueurs > max_joueurs:
nb_joueurs = int(input("Combien êtes-vous de joueurs? "))
joueurs = []
for i in range(0, nb_joueurs):
nom = input("Entrez le nom du joueur {:d} ".format(i + 1))
joueurs.append(Joueur(nom))
continuer = True
while continuer:
partie = Partie(joueurs)
partie.jouer_partie()
refaire_partie = ""
while not ("oui" in refaire_partie or "non" in refaire_partie):
refaire_partie = input(
"Voulez-vous refaire une partie? (oui/non) ").lower()
continuer = "oui" in refaire_partie
for joueur in joueurs:
print("{} a gagné {:d} parties, soit {:.0f}%.".format(joueur,
joueur.nb_victoires,
joueur.nb_victoires / joueur.nb_parties_jouees * 100))
if partie == False or nouvelle_partie == True:
# On charge les cartes existantes
cartes = carteHelper.chargementCartes()
# On affiche les cartes existantes
afficheLabyrinthes(cartes)
# l'utilisateur choisi une carte et commence la partie
choix_carte = carteHelper.choixCartes(cartes)
# Rappel des commandes
interactionHelper.rappelDesCommandes()
print("\n \n Commençons la partie ! \n \n")
labyrinthe = cartes[choix_carte - 1].labyrinthe
partie = Partie(joueur_name, cartes[choix_carte - 1].nom,
labyrinthe.position_robot)
else:
# On reprends la partie
carte = carteHelper.chargementCarte(partie.carte_name)
# On charge le labyrinthe ainsi que la position du joueur sauvegardé
print("\n \n Reprenons la partie ! \n \n")
labyrinthe = carte.labyrinthe
labyrinthe.position_robot = partie.position_robot
labyrinthe.display()
# Jouer le jeux
play(partie)
print("\n\n A bientôt !! ")
import os def takeSecond(elem): return elem[1] if __name__ == '__main__': t=Trie() f = open(os.path.dirname(os.path.realpath(__file__)) + "/francais.dic", "r") ff = open(os.path.dirname(os.path.realpath(__file__)) + "/FR_Sorted.dic","w") lines = f.readlines() for mot in lines: mot2 = ''.join(sorted(mot)) t.add(mot2.strip()).append(mot.strip()) partie = Partie(True) tour=0 mylist=[''] while mylist!=[] or partie.pioche != [] : partie.joueur.afficherChevalet() sys.stdout.flush() listA=[] listB=[] mylist=[] if tour!=0: ############COLONNE for i in range(15):
class FenetrePartie(Tk):
"""Interface graphique de la partie de dames.
Attributes:
partie (Partie): Le gestionnaire de la partie de dame
canvas_damier (CanvasDamier): Le «widget» gérant l'affichage du damier à l'écran
messages (Label): Un «widget» affichant des messages textes à l'utilisateur du programme
TODO: AJOUTER VOS PROPRES ATTRIBUTS ICI!
"""
def __init__(self):
"""Constructeur de la classe FenetrePartie. On initialise une partie en utilisant la classe Partie du TP3 et
on dispose les «widgets» dans la fenêtre.
"""
# Appel du constructeur de la classe de base (Tk)
super().__init__()
# La partie
self.partie = Partie()
# Création du canvas damier.
self.canvas_damier = CanvasDamier(self, self.partie.damier, 60)
self.canvas_damier.grid(sticky=NSEW)
self.canvas_damier.bind('<Button-1>', self.selectionner)
# Ajout d'une étiquette d'information.
self.messages = Label(self)
self.messages.grid()
# Nom de la fenêtre («title» est une méthode de la classe de base «Tk»)
self.title("Jeu de dames")
# Truc pour le redimensionnement automatique des éléments de la fenêtre.
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
self.messages['text'] = 'Bonjour'
def selectionner(self, event):
"""Méthode qui gère le clic de souris sur le damier.
Args:
event (tkinter.Event): Objet décrivant l'évènement qui a causé l'appel de la méthode.
"""
# 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_damier.n_pixels_par_case
colonne = event.x // self.canvas_damier.n_pixels_par_case
position = Position(ligne, colonne)
# On récupère l'information sur la pièce à l'endroit choisi.
piece = self.partie.damier.recuperer_piece_a_position(position)
if piece is None:
self.messages['foreground'] = 'red'
self.messages['text'] = 'Erreur: Aucune pièce à cet endroit.'
else:
self.messages['foreground'] = 'black'
self.messages[
'text'] = 'Pièce sélectionnée à la position {}.'.format(
position)
# TODO: À continuer....
#Creation du menu
menu = Menu(self)
self.config(menu=menu)
def doNothing():
self.messages['text'] = 'Nouvelle partie commence'
def quitter():
self.quit
#Fonctions optionelles
subMenu = Menu(menu)
subMenuOptions = Menu(menu)
#Fonctions optionelles
#1. Option de lire les règlements du jeu
def lireInstructions():
instruction = Tk()
instruction.title("Instructions")
#Ecrire les instructions sur l'interface
# Un Frame est utiliser pour mieux organiser la page
instruction_1 = "-> Le joueur avec les pièces blanches commence en premier"
instruction_2 = "-> Une pièce de départ est appelée unpion, et peut se déplacer en diagonalevers l’avant " \
"\n(vers le haut pour les blancs, vers le bas pour les noirs)."
instruction_3 = "-> Une case doit être libre pourpouvoir s’y déplacer "
instruction_4 = "-> Lorsqu’un pion atteint le côté opposé du plateau, il devient une dame."
instruction_5 = "-> Une dame a la particularité qu’elle peut aussi se déplacer vers l’arrière (toujours en diagonale)"
instruction_6 ="-> Une prise est l’action de «manger» une pièce adverse. Elle est effectuée en sautant par-dessus " \
"\nla pièce adverse, toujours en diagonale,vers l’avant ou l’arrière. "
instruction_7 = "-> On nepeut sauter par-dessus qu’une pièce adverse à la fois : il faut donc que la case d’arrivéesoit libre"
instruction_8 = "-> Après une prise, le joueur courant peut effectuer une (ou plusieurs) prise(s) supplé-mentaire(s) " \
"\nen utilisant la même pièce"
instruction_9 = "-> Lors du tour d’un joueur, si celui-ci peut prendre une pièce ennemie, " \
"\nil doit absolumentle faire (on ne peut pas déplacer une pièce s’il était possible d’effectuer une prise)"
instruction_10 = "-> On déduit des deux dernières règles que lorsqu’un joueur commence son tour et prendune pièce adverse, " \
"\ns’il peut continuer son tour en continuant de prendre des pièces adverses avec la même pièce, il doit le faire\n"
instruction_message = instruction_1 + "\n\n" + instruction_2 + "\n\n" \
+ instruction_3 + "\n\n" + instruction_4 + "\n\n" + instruction_5 \
+ "\n\n" + instruction_6 + "\n\n" + instruction_7 +"\n\n" + instruction_8 \
+ "\n\n" + instruction_9 + "\n\n" +instruction_10
frame = Frame(instruction)
frame.pack()
label_instruction = Label(frame,
text=instruction_message,
justify=LEFT)
label_instruction.pack(side="left")
instruction.mainloop()
menu.add_cascade(label="Fichier", menu=subMenu)
subMenu.add_command(label="Nouvelle partie", command=doNothing)
def sauvegarder():
filedialog.asksaveasfilename()
subMenu.add_separator()
subMenu.add_command(label="Sauvegarder", command=sauvegarder)
subMenu.add_separator()
subMenu.add_command(label="Quitter", command=quitter)
menu.add_cascade(label="Options", menu=subMenuOptions)
# Permettre de changer le thème (couleurs)
def changerCouleur():
color = colorchooser.askcolor()
color_name = color[1]
self.configure(background=color_name)
subMenuOptions.add_command(label="Couleur", command=changerCouleur)
menu.add_command(label="Instructions", command=lireInstructions)
def piece_peuvent_se_deplacer_sur_damier(self):
self.partie.tour().grid(CanvasDamier)
# TODO: À continuer....
print(self.partie.damier)
print(self.liste_position)
print(self.partie.demander_positions_deplacement())
self.canvas_damier.actualiser()
import pygricola.util as util
from partie import Partie
listeReponse = [] #/pour prédefinir les premières reponses tapes au clavier
#permet de jouer les premier coup automatiquemetn
nJoueurs = 3
p = Partie()
p.initialiser(nJoueurs, listeReponse)
p.demarragePartie()
p.demarrageTour()
while (True):
while (True):
encore = True
while (encore):
print(p.messagesPrincipaux[-1])
p.affichageJoueur()
sujet = p.joueurQuiJoue(
) #le sujet est l'objet à qui on demande possibilite
#au debut c'est joueur, après ça peut être un carte,...
casesJouablesStr = sujet.possibilites()
p.phraseChoixPossibles = "QUE VOULEZ VOUS FAIRE?"
choix = util.printPossibilities(p,
p.phraseChoixPossibles,
p.choixPossibles,
annulable=False)
(choixPossibles, sujet, encore,
message) = p.jouerUid(p.choixPossibles[choix].uid)
# (choixPossibles,sujet,encore,message)=p.choixPossibles[choix].jouer()
def __init__(self, adresseServeur, traiteRequete):
HTTPServer.__init__(self, adresseServeur, traiteRequete)
self.partie = Partie()
self.mustStop = False
class FenetrePartie(Tk):
"""Interface graphique de la partie de dames.
Attributes:
partie (Partie): Le gestionnaire de la partie de dame
canvas_damier (CanvasDamier): Le «widget» gérant l'affichage du damier à l'écran
messages (Label): Un «widget» affichant des messages textes à l'utilisateur du programme
"""
def __init__(self):
"""Constructeur de la classe FenetrePartie. On initialise une partie en utilisant la classe Partie du TP3 et
on dispose les «widgets» dans la fenêtre.
"""
# Appel du constructeur de la classe de base (Tk)
super().__init__()
# La partie
self.partie = Partie()
# Création du canvas damier.
self.canvas_damier = CanvasDamier(self, self.partie.damier, 60)
self.canvas_damier.grid(sticky=NSEW)
self.canvas_damier.bind('<Button-1>', self.selectionner)
# self.canvas_damier.bind('<B1-Button_release>', self.enregistrer_position_cible)
self.canvas_damier.couleur_foncee = '#426D8F' # Bleu
self.canvas_damier.couleur_pale = 'light cyan'
# Ajout d'une étiquette d'information.
self.messages1 = Label(self) # Affichage des messages
self.messages1.grid()
self.messages1['foreground'] = 'blue'
self.messages1['background'] = 'mint cream'
self.messages1['text'] = 'Quelle pièce désirez-vous déplacer?'
self.colonne_damier_reel = "abcdefgh"
# Ajout des boutons : A permettant d'obtenir l'aide et B de quitter et d'enregistrer.
self.bouton1_A = Button(self,
text='Aide',
bg='SlateGray1',
command=self.aide)
self.bouton1_B = Button(self,
text='Quitter',
bg='SlateGray1',
command=self.quitter_damier)
self.bouton1_C = Button(self,
text='Partie sauvegardée',
bg='SlateGray1',
command=self.partie_sauvegardee)
self.bouton1_D = Button(self,
text="Couleurs du damier",
bg='SlateGray1',
command=self.couleur_damier)
self.bouton1_A['foreground'] = 'midnight blue'
self.bouton1_B['foreground'] = 'midnight blue'
self.bouton1_C['foreground'] = 'midnight blue'
self.bouton1_D['foreground'] = 'midnight blue'
self.bouton1_A.grid(row=2, column=0, pady=5, sticky=W)
self.bouton1_B.grid(row=1, column=1, padx=25, pady=5)
self.bouton1_C.grid(row=2, column=1, pady=5, sticky=E)
self.bouton1_D.grid(row=2, column=0, pady=5, sticky=S)
# Liste des mouvements
self.messages1_B = Label(self)
self.messages1_B.grid(row=0, column=1, sticky=N)
self.messages1_B['foreground'] = 'black'
self.messages1_B['background'] = 'white'
self.messages1_B['text'] = "Blanc Noir\n───────\n"
self.numero_deplacement = 1
# Initialisation des attributs
self.doit_prendre = False
self.position_source_selectionnee = None
self.position_source_forcee = None
# Nom de la fenêtre
self.titre_joueur = self.partie.couleur_joueur_courant + " joue!"
self.title("Jeu de dames. Le joueur " + self.titre_joueur)
self['background'] = 'mint cream'
# Truc pour le redimensionnement automatique des éléments de la fenêtre.
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
def selectionner(self, event):
"""Méthode qui gère le clic de souris sur le damier. La méthode appelle les méthodes vérifiant la validité
des sélections source et cible.
Tant qu'une cible valide n'est pas sélectionnée, la position source peut être modifiée.
Args:
event (tkinter.Event): Objet décrivant l'évènement qui a causé l'appel de la méthode.
"""
try: # Permet d'affecter le premier clic à la position source et le second à la cible.
if self.flg == 0: # Génère l'erreur qui affecte le premier clic.
ligne = event.y // self.canvas_damier.n_pixels_par_case
colonne = event.x // self.canvas_damier.n_pixels_par_case # On trouve le numéro de ligne/colonne en
# divisant les positions en y/x par le nombre de pixels par case.
self.position_cible = Position(ligne, colonne)
self.messages1['foreground'] = 'black'
position_source_damier_reel =self.colonne_damier_reel[self.position.colonne]\
+ str(8 - self.position.ligne)
position_cible_damier_reel = self.colonne_damier_reel[self.position_cible.colonne]\
+ str(8 - self.position_cible.ligne)
self.messages1['text'] = 'Pièce à la position {} déplacée à {}.'\
.format(position_source_damier_reel, position_cible_damier_reel)
if not self.valider_et_enregistrer_position_cible()[0]:
self.messages1['foreground'] = 'red'
self.messages1[
'text'] = self.valider_et_enregistrer_position_cible(
)[1]
raise ValueError
retour_apres_deplacement = self.partie.damier.deplacer(
self.position, self.position_cible)
# ok, prise ou erreur
if self.partie.couleur_joueur_courant == "blanc":
self.messages1_B['text'] = self.messages1_B['text'] + str(self.numero_deplacement) + "- "\
+ str(position_source_damier_reel) + " " + str(position_cible_damier_reel) + " "
self.numero_deplacement += 1
#if retour_apres_deplacement == "prise":
# self.messages1_B['text'] = self.messages1_B['text'] + "\n"
else:
#if retour_apres_deplacement == "prise":
# self.messages1_B['text'] = self.messages1_B['text'] + " "
self.messages1_B['text'] = self.messages1_B['text'] + str(position_source_damier_reel) + " " \
+ str(position_cible_damier_reel) + "\n"
if retour_apres_deplacement == "ok":
pass
elif retour_apres_deplacement == "prise":
if self.partie.damier.piece_peut_faire_une_prise(
self.position_cible):
self.position_source_forcee = self.position_cible
self.doit_prendre = True
if self.partie.couleur_joueur_courant == 'noir':
self.messages1_B['text'] = self.messages1_B[
'text'] + " "
else:
self.messages1_B['text'] = self.messages1_B[
'text'] + " \n"
else:
self.doit_prendre = False
self.position_source_selectionnee = None
self.position_source_forcee = None
else:
self.messages1['foreground'] = 'red'
self.messages1['text'] = "Il y a erreur dans le code!"
if self.doit_prendre == False:
if self.partie.couleur_joueur_courant == "blanc":
self.partie.couleur_joueur_courant = "noir"
else:
self.partie.couleur_joueur_courant = "blanc"
self.titre_joueur = self.partie.couleur_joueur_courant + " joue!"
self.title("Jeu de dames. Le joueur " + self.titre_joueur)
else:
self.titre_joueur = self.partie.couleur_joueur_courant + " joue et doit faire une prise!"
self.title("Jeu de dames. Le joueur " + self.titre_joueur)
del self.flg # Libère le drapeau pour le tour suivant
except: # Permet de valider la position source et déterminer si une prise doit être faite.
ligne = event.y // self.canvas_damier.n_pixels_par_case
colonne = event.x // self.canvas_damier.n_pixels_par_case
self.position = Position(ligne, colonne)
position_source_damier_reel = self.colonne_damier_reel[
self.position.colonne] + str(8 - self.position.ligne)
if self.valider_prise_obligee()[0]:
self.title("Jeu de dames. Le joueur " +
self.valider_prise_obligee()[1])
if self.partie.damier.piece_peut_faire_une_prise(
self.position):
self.messages1['foreground'] = 'black'
self.messages1['text'] = 'La pièce sélectionnée en position ' \
+ position_source_damier_reel + ' peut faire une prise.'
else:
self.messages1['foreground'] = 'red'
self.messages1[
'text'] = 'Sélectionnez une pièce qui peut faire une prise.'
else:
self.titre_joueur = self.partie.couleur_joueur_courant + " joue!"
self.title("Jeu de dames. Le joueur " + self.titre_joueur)
if self.partie.position_source_valide(self.position)[0]:
if self.valider_et_enregistrer_position_source()[0]:
self.messages1['foreground'] = 'black'
self.messages1[
'text'] = self.valider_et_enregistrer_position_source(
)[1]
self.flg = 0 # Valide la position source et autorise la sélection de la cible
else:
self.messages1['foreground'] = 'red'
self.messages1[
'text'] = self.valider_et_enregistrer_position_source(
)[1]
else:
self.messages1['foreground'] = 'red'
self.messages1['text'] = self.partie.position_source_valide(
self.position)[1]
self.canvas_damier.actualiser()
# Fin de partie
if self.partie.damier.piece_de_couleur_peut_se_deplacer(self.partie.couleur_joueur_courant) or \
self.partie.damier.piece_de_couleur_peut_faire_une_prise(self.partie.couleur_joueur_courant):
pass
else:
self.title("Jeu de dames. La partie est terminée!")
self.messages1['foreground'] = 'orange'
if self.partie.couleur_joueur_courant == "blanc":
self.partie.couleur_joueur_courant = "noir"
else:
self.partie.couleur_joueur_courant = "blanc"
self.messages1[
'text'] = "Le joueur " + self.partie.couleur_joueur_courant + " a gagné!"
def valider_prise_obligee(self):
"""
Détermine si le joueur actif doit ou non faire une prise. Rend la prise obligatoire dans le choix
de la position source.
return:
[0] : True ou False
[1] : Message à afficher si le joueur doit faire une prise.
"""
if self.partie.damier.piece_de_couleur_peut_faire_une_prise(
self.partie.couleur_joueur_courant):
self.doit_prendre = True
if self.position_source_forcee is None: # C'est une première prise
self.titre_joueur = self.partie.couleur_joueur_courant + " joue et doit faire une prise!"
else: # Indique une prise successive
position_source_damier_reel = self.colonne_damier_reel[
self.position_source_forcee.colonne] + str(
8 - self.position_source_forcee.ligne)
self.titre_joueur = self.partie.couleur_joueur_courant + " joue. La pièce en position "\
+ position_source_damier_reel + " doit faire une prise!"
return [True, self.titre_joueur]
else:
return [False, ""]
def valider_et_enregistrer_position_source(self):
"""
S'assure que la position source doit faire une prise, si c'est le cas, sinon que la pièce choisie est de la
couleur du joueur et qu'elle peut se déplacer.
return:
[0] : True ou False
[1] : Message à afficher si la source n'est pas valide.
"""
position_source_damier_reel = self.colonne_damier_reel[
self.position.colonne] + str(8 - self.position.ligne)
if self.doit_prendre == True:
if self.position_source_forcee is None:
texte_messages1 = "Vous devez prendre. Assurez-vous que la pièce sélectionnée, en position " \
+ position_source_damier_reel + " peut prendre."
return [True, texte_messages1]
else:
if self.position_source_forcee == self.position:
self.messages1['foreground'] = 'red'
texte_messages1 = "Vous devez prendre à nouveau. La pièce en position "\
+ position_source_damier_reel + " a été sélectionnée."
return [True, texte_messages1]
else:
texte_messages1 = "Vous devez prendre à nouveau. La pièce choisie ne peut pas être sélectionnée."
return [False, texte_messages1]
elif self.partie.damier.piece_peut_se_deplacer(self.position):
self.messages1['foreground'] = 'black'
texte_messages1 = 'La pièce en position ' + position_source_damier_reel \
+ ' a été sélectionnée. Cliquez sur la cible désirée. '
return [True, texte_messages1]
else:
texte_messages1 = "La pièce que vous avez sélectionnée ne peut pas se déplacer. Veuillez " \
"faire un autre choix. "
return [False, texte_messages1]
def valider_et_enregistrer_position_cible(self):
"""
S'assure que la pièce choisie comme position source peut se déplacer à la position cible, soit en faisant
une prise ou en se déplaçant.
return:
[0] : True, si la position cible est valide, sinon False
[1] : Message à afficher si la cible n'est pas valide.
"""
if self.doit_prendre == True:
if self.partie.damier.piece_peut_sauter_vers(
self.position, self.position_cible,
self.partie.couleur_joueur_courant):
return [True, ""]
else:
texte_messages1 = "La pièce choisie doit prendre une pièce adverse. La cible choisie doit être modifiée."
return [False, texte_messages1]
elif self.partie.damier.piece_peut_se_deplacer_vers(
self.position, self.position_cible):
return [True, ""]
else:
texte_messages1 = "La pièce choisie ne peut pas être déplacée vers cette case."
return [False, texte_messages1]
def aide(self):
"""
Fait apparaître une fenêtre contextuelle présentant, sous la forme d'un texte, l'aide à l'utilisation
du programme damier ainsi que les règlements applicables.
Le bouton "Quitter" permet de fermer la fenêtre et de retourner au damier.
"""
self.fenetre_2 = Tk()
self.fenetre_2.title("Aide et règlements")
texte_aide0 = Message(self.fenetre_2)
texte_aide0['foreground'] = 'brown'
texte_aide1 = Message(self.fenetre_2, width=492)
texte_aide1['foreground'] = 'blue'
texte_aide2 = Message(self.fenetre_2)
texte_aide2['foreground'] = 'brown'
texte_aide3 = Message(self.fenetre_2)
texte_aide3['foreground'] = 'blue'
Extrait_aide = open("Aide_reglements.txt", 'r', encoding="utf-8")
texte_extrait = Extrait_aide.readlines()
texte_aide0['text'] = texte_extrait[0]
texte_aide1['text'] = texte_extrait[1]
for i in range(2, 5):
texte_aide1['text'] = texte_aide1['text'] + texte_extrait[i]
texte_aide2['text'] = texte_extrait[5]
texte_aide3['text'] = texte_extrait[6]
for i in range(7, len(texte_extrait)):
texte_aide3['text'] = texte_aide3['text'] + texte_extrait[i]
Extrait_aide.close()
texte_aide0.grid()
texte_aide1.grid(sticky=W)
texte_aide2.grid()
texte_aide3.grid(sticky=W)
bouton2_A = Button(self.fenetre_2,
text='Quitter',
command=self.fenetre_aide_quit)
bouton2_A.grid()
self.fenetre_2.tkraise() # mainloop()
def fenetre_aide_quit(self):
"""
Méthode appelée par le bouton "Quitter" de la fenêtre "Aide et règlements".
Permet de fermer la fenêtre en permettant aux joueurs de retourner au jeu déjà commencé.
"""
self.fenetre_2.withdraw()
def quitter_damier(self):
"""
Méthode appelée par le bouton "Quitter" de la fenêtre principale du damier.
Permet
1. de fermer la fenêtre avec ou sans sauvegarde de la partie en cours;
2.aux joueurs de retourner au jeu déjà commencé;
3. d'ouvrir une nouvelle partie sans fermer la partie en cours.
Boutons activés :
A. Quitter et sauvegarder
B. Quitter sans sauvegarder
C. Nouvelle partie
D. Annuler et revenir à la partie
"""
self.fenetre_3 = Tk()
self.fenetre_3.geometry("460x230")
self.fenetre_3.title("Pourquoi quitter?")
# texte_3_A = Message(self.fenetre_3)
texte_3_A = Label(self.fenetre_3)
texte_3_B = Label(self.fenetre_3)
texte_3_C = Label(self.fenetre_3)
texte_3_D = Label(self.fenetre_3)
texte_3_A[
'text'] = "1- Si vous ouvrez une nouvelle partie, la partie non terminée que vous venez de quitter"
texte_3_B[
'text'] = "sera encore accessible et il sera possible de jouer deux parties à la fois!\n "
texte_3_C[
'text'] = "2- En annulant, vous retournez à la partie déjà ouverte.\n "
texte_3_D[
'text'] = "3- Si vous quittez sans sauvegarder, toutes les parties seront fermées."
texte_3_A.grid(sticky=W)
texte_3_B.grid(sticky=W)
texte_3_C.grid(sticky=W)
texte_3_D.grid(sticky=W)
bouton3_A = Button(self.fenetre_3,
text='Quitter et sauvegarder',
command=self.sauvegarde_partie)
bouton3_B = Button(self.fenetre_3,
text='Quitter sans sauvegarder',
command=self.quit)
bouton3_C = Button(self.fenetre_3,
text='Nouvelle partie',
command=self.nouvelle_partie)
bouton3_D = Button(self.fenetre_3,
text='Annuler',
command=self.fenetre_quit_annulee)
bouton3_A.grid(row=4, column=0, pady=10, sticky=W)
bouton3_B.grid(row=4, column=0, pady=10, sticky=E)
bouton3_C.grid(row=5, column=0, sticky=W)
bouton3_D.grid(row=5, column=0, sticky=E)
self.fenetre_3.tkraise()
def sauvegarde_partie(self):
"""
Méthode appelée par le bouton "Quitter et sauvegarder" de la fenêtre "Quitter".
Permet de sauvegarder la partie au point où elle était rendue.
"""
self.fenetre_4 = Tk()
self.fenetre_4.geometry("500x130")
self.fenetre_4.title("Fichier de sauvegarde")
# Sauvegarde de plusieurs parties à la même date
# Le nom des fichiers contient la date de la sauvegarde
n_fich = 1
while os.path.isfile("Sauvegarde-" + str(date.today()) + "(" +
str(n_fich) + ").txt"):
n_fich += 1
nom_fichier_sauvegarde = "Sauvegarde-" + str(
date.today()) + "(" + str(n_fich) + ").txt"
fichier_partie = open(nom_fichier_sauvegarde, "wb")
dump([self.partie.couleur_joueur_courant, self.partie.damier.cases],
fichier_partie)
fichier_partie.close()
texte_4_A = Label(self.fenetre_4)
texte_4_B = Label(self.fenetre_4)
texte_4_C = Label(self.fenetre_4)
texte_4_D = Label(self.fenetre_4)
texte_4_A['foreground'] = 'blue'
texte_4_B['foreground'] = 'green'
texte_4_C['foreground'] = 'blue'
texte_4_A[
'text'] = "La partie que vous quittez a été sauvegardée dans le fichier : "
texte_4_B['text'] = nom_fichier_sauvegarde # + "!"
texte_4_C['text'] = "!"
texte_4_A.grid(row=0, column=0)
texte_4_B.grid(row=0, column=1)
texte_4_C.grid(row=0, column=2)
texte_4_D.grid(row=1, column=0)
bouton4_A = Button(self.fenetre_4,
text='Quitter le jeu',
command=self.quit)
bouton4_B = Button(self.fenetre_4,
text='Retour au jeu',
command=self.retour_jeu)
bouton4_A.grid(row=2, column=0, sticky=SW)
bouton4_B.grid(row=2, column=0, sticky=SE)
self.fenetre_4.tkraise()
def nouvelle_partie(self):
"""
Méthode appelée par le bouton "Nouvelle partie" de la fenêtre "Quitter".
Ouvre une autre fenêtre de jeu sans fermer le damier déjà commencé,
permettant aux joueurs de jouer plusieurs parties simultanées.
"""
self.fenetre_3.withdraw()
fenetre = FenetrePartie()
fenetre.mainloop()
def partie_sauvegardee(self):
"""
Méthode appelée par le bouton "Partie sauvegardée" de la fenêtre principale.
Permet d'ouvrir une partie non complétée au point où elle avait été arrêtée.
"""
self.fenetre_5 = Tk()
self.fenetre_5.geometry("400x230") # Ajuster
self.fenetre_5.title("Fichiers sauvegardés")
texte_5_A = Label(self.fenetre_5)
bouton5_A = Button(self.fenetre_5,
text='Annuler',
command=self.ouverture_fich_annulee)
self.liste_fich = Listbox(self.fenetre_5,
width=27,
height=10,
selectmode=SINGLE)
fich_insere = 0
for nom_fich in os.listdir():
if nom_fich[0:10] == "Sauvegarde":
self.liste_fich.insert(END, nom_fich)
fich_insere += 1
if fich_insere != 0:
texte_5_A['foreground'] = 'purple'
texte_5_A[
'text'] = "Liste des fichiers de sauvegarde dans le répertoire du projet :"
self.liste_fich.grid(row=2, column=0)
self.liste_fich.bind('<Double-Button-1>',
lambda event: self.ouvrir_sauvegarde())
else:
texte_5_A['foreground'] = 'red'
texte_5_A[
'text'] = "Il n'y a pas de fichiers de sauvegarde dans le répertoire du projet."
texte_5_A.grid(row=0, column=0) # Ajuster
bouton5_A.grid(row=2, column=1, sticky=N)
self.fenetre_5.tkraise()
def ouvrir_sauvegarde(self):
self.index_fich_select = self.liste_fich.curselection()[0]
nom_fichier = open(self.liste_fich.get(self.index_fich_select), "rb")
list_dic = load(nom_fichier)
self.partie.couleur_joueur_courant = list_dic[0]
self.partie.damier.cases = list_dic[1]
# self.damier_ouvert = literal_eval(damier_cases)
nom_fichier.close()
self.fenetre_5.withdraw()
self.titre_joueur = self.partie.couleur_joueur_courant + " joue!"
self.title("Jeu de dames. Le joueur " + self.titre_joueur)
self.canvas_damier.actualiser()
self.mainloop()
def fenetre_quit_annulee(self):
"""
Méthode appelée par le bouton "Annuler" de la fenêtre "Quitter".
Permet de fermer la fenêtre en permettant aux joueurs de retourner au jeu déjà commencé.
"""
self.fenetre_3.withdraw()
def retour_jeu(self):
"""
Méthode appelée par le bouton "Retour au jeu" de la fenêtre "Quitter et sauvegarder".
Ferme la fenêtre confirmant le nom du fichier de sauvegarde sans fermer ni le damier déjà commencé
ni la fenêtre contextuelle, permettant aux joueurs de retourner à la partie en cours.
"""
self.fenetre_3.withdraw()
self.fenetre_4.withdraw()
def couleur_damier(self):
#TODO
"""
Méthode appelée par le bouton "Couleurs du damier" de la fenêtre principale du damier.
Permet de choisir les couleurs du damier;
Boutons activés :
A. Bleu
B. Mauve
C. Marron
D. Rouge
E. Vert
"""
self.fenetre_6 = Tk()
self.fenetre_6.geometry("460x230")
self.fenetre_6.title("Couleurs du damier!")
self.var_b = IntVar()
r_bouton6_A = Radiobutton(self.fenetre_6,
text='Bleu',
variable=self.var_b,
value=1,
command=self.selection_couleur_bleue)
r_bouton6_B = Radiobutton(self.fenetre_6,
text='Mauve',
variable=self.var_b,
value=2,
command=self.selection_couleur_mauve)
r_bouton6_C = Radiobutton(self.fenetre_6,
text='Marron',
variable=self.var_b,
value=3,
command=self.selection_couleur_marron)
r_bouton6_D = Radiobutton(self.fenetre_6,
text='Rouge',
variable=self.var_b,
value=4,
command=self.selection_couleur_rouge)
r_bouton6_E = Radiobutton(self.fenetre_6,
text='Vert',
variable=self.var_b,
value=5,
command=self.selection_couleur_verte)
texte_6_A = Label(self.fenetre_6)
texte_6_A[
'text'] = "Choisir la couleur du damier que vous désirez afficher."
texte_6_A.grid(row=0, sticky=N)
r_bouton6_A.grid(sticky=W) # row=2)
r_bouton6_B.grid(sticky=W)
r_bouton6_C.grid(sticky=W)
r_bouton6_D.grid(sticky=W)
r_bouton6_E.grid(sticky=W)
bouton6_A = Button(self.fenetre_6,
text='Annuler',
command=self.fenetre_6.withdraw)
bouton6_A.grid()
self.fenetre_6.tkraise()
def selection_couleur_bleue(self):
"""
Modification de la couleur du damier.
Ferme la fenêtre contextuelle dès que la sélection est faite et retourne au damier.
"""
self.canvas_damier.couleur_foncee = '#426D8F' # Bleu
self.canvas_damier.couleur_pale = 'light cyan'
self.fenetre_6.withdraw()
self.canvas_damier.actualiser()
def selection_couleur_mauve(self):
"""
Modification de la couleur du damier.
Ferme la fenêtre contextuelle dès que la sélection est faite et retourne au damier.
"""
self.canvas_damier.couleur_foncee = 'maroon4' # Mauve
self.canvas_damier.couleur_pale = 'thistle1'
self.fenetre_6.withdraw()
self.canvas_damier.actualiser()
def selection_couleur_marron(self):
"""
Modification de la couleur du damier.
Ferme la fenêtre contextuelle dès que la sélection est faite et retourne au damier.
"""
self.canvas_damier.couleur_foncee = 'Firebrick4' # Marron
self.canvas_damier.couleur_pale = 'Wheat1'
self.fenetre_6.withdraw()
self.canvas_damier.actualiser()
def selection_couleur_rouge(self):
"""
Modification de la couleur du damier.
Ferme la fenêtre contextuelle dès que la sélection est faite et retourne au damier.
"""
self.canvas_damier.couleur_foncee = 'red4' # Rouge
self.canvas_damier.couleur_pale = 'LightPink1'
self.fenetre_6.withdraw()
self.canvas_damier.actualiser()
def selection_couleur_verte(self):
"""
Modification de la couleur du damier.
Ferme la fenêtre contextuelle dès que la sélection est faite et retourne au damier.
"""
self.canvas_damier.couleur_foncee = 'chartreuse4' # Vert
self.canvas_damier.couleur_pale = 'light cyan'
self.fenetre_6.withdraw()
self.canvas_damier.actualiser()
def ouverture_fich_annulee(self):
"""
Méthode appelée par le bouton "Annuler" de la fenêtre "Quitter".
Permet de fermer la fenêtre en permettant aux joueurs de retourner au jeu déjà commencé.
"""
self.fenetre_5.withdraw()
class FenetrePartie(Tk):
"""
Interface graphique de la partie de dames.
Attributes:
partie (Partie): Le gestionnaire de la partie de dame.
canvas_damier (CanvasDamier): Le «widget» gérant l'affichage du damier à l'écran.
messages (Label): Un «widget» affichant des messages textes à l'utilisateur du programme.
couleur_joueur (Label): Un «widget» affichant la couleur du joueur courant.
bool_piece_selectionnee (bool): Un booleen dont la valeur est True si une pièce est sélectionnée par le joueur.
piece_selectionnee (Piece): La pièce sélectionnée par le joueur.
position_selectionnee (Position): La position de la pièce sélectionnée par le joueur.
position_cible_graphique (Position): La position cible valide sélectionnée par le joueur.
texte_deplacements (str): Le texte enregistrant les déplacements effectuées par les joueurs.
cadre_bouton (Frame): Un cadre servant à positionner les boutons.
bouton_nouvelle_partie (Button): Un bouton pour initialiser une nouvelle partie.
bouton_Quitter (Button): Un bouton pour quitter la fenêtre de partie.
bouton_reglements (Button): Un bouton pour afficher les règlements dans une nouvelle fenêtre.
bouton_deplacements (Button): Un bouton pour afficher l'historique des déplacements de la partie dans une
nouvelle fenêtre.
bouton_sauvegarder (Button): Un bouton pour sauvegarder la partie dans un fichier .txt.
bouton_charger (Button): Un bouton pour charger la précédente sauvegarde.
bouton_triche (Button): Un bouton pour ouvrir les options de triches dans une nouvelle fenêtre.
fenetre_alarme (Tk): Une fenêtre affichant un message d'alarme au joueur.
"""
def __init__(self):
"""
Constructeur de la classe FenetrePartie. On initialise une partie en utilisant la classe Partie du TP3 et
on dispose les «widgets» dans la fenêtre.
"""
# Appel du constructeur de la classe de base (Tk):
super().__init__()
# La partie:
self.partie = Partie()
# Création du canvas damier:
self.canvas_damier = CanvasDamier(self, self.partie.damier, 60)
self.canvas_damier.grid(sticky=NSEW)
self.canvas_damier.bind('<Button-1>', self.selectionner)
# Ajout d'une étiquette d'information:
self.messages = Label(self)
self.messages.grid()
# Ajout d'une étiquette de couleur du tour du joueur:
self.couleur_joueur = Label(self)
self.couleur_joueur.grid()
self.couleur_joueur['text'] = 'Tour du joueur {}'.format('blanc')
# Nom de la fenêtre («title» est une méthode de la classe de base «Tk»):
self.title("Jeu de dames")
# Truc pour le redimensionnement automatique des éléments de la fenêtre:
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
# Ajout de variables se rappelant si une pièce est sélectionnée:
self.bool_piece_selectionnee = False
self.piece_selectionnee = None
self.position_selectionnee = None
# Ajout d'uhe variable gérant le déplacement:
self.position_cible_graphique = None
# Ajout d'une chaîne de caractère enregistrant les déplacements effectués:
self.texte_deplacements = 'Liste des déplacements, du plus récent au plus ancien: \n'
# Ajout du cadre des boutons:
self.cadre_bouton = Frame(self)
self.cadre_bouton.grid(padx=10, pady=10)
# Création du bouton 'Nouvelle partie':
self.bouton_nouvelle_partie = Button(self.cadre_bouton,
text="Nouvelle partie",
command=self.nouvelle_partie,
padx=10,
pady=10)
self.bouton_nouvelle_partie.grid(padx=10, pady=10, column=0, row=0)
# Création du bouton 'quitter':
self.bouton_Quitter = Button(self.cadre_bouton,
text="Quitter",
command=self.destroy,
padx=10,
pady=10)
self.bouton_Quitter.grid(padx=10, pady=10, column=1, row=0)
# Création du bourron 'Règlements':
self.bouton_reglements = Button(self.cadre_bouton,
text="Règlements",
command=ouvrir_reglements,
padx=10,
pady=10)
self.bouton_reglements.grid(padx=10, pady=10, column=2, row=0)
# Création du bouton 'Déplacement':
self.bouton_deplacements = Button(self.cadre_bouton,
text='Déplacements',
command=self.afficher_deplacements,
padx=10,
pady=10)
self.bouton_deplacements.grid(padx=10, pady=10, column=3, row=0)
# Création du bouton 'Sauvegarder':
self.bouton_sauvegarder = Button(self.cadre_bouton,
text='Sauvegarder',
command=self.sauvegarder_partie,
padx=10,
pady=10)
self.bouton_sauvegarder.grid(padx=10, pady=10, column=0, row=1)
# Création du bouton 'Charger':
self.bouton_charger = Button(self.cadre_bouton,
text='Charger',
command=self.charger_partie,
padx=10,
pady=10)
self.bouton_charger.grid(padx=10, pady=10, column=1, row=1)
# Création du bouton 'Tricher':
self.bouton_triche = Button(self.cadre_bouton,
text="Tricher",
command=self.ouvrir_triches,
padx=10,
pady=10)
self.bouton_triche.grid(padx=10, pady=10, column=2, row=1)
# Initialisation de la variable 'fenetre_alarme':
self.fenetre_alarme = None
def nouvelle_partie(self):
"""
Fonction supprimant la fenêtre de partie courante et relançant une nouvelle partie.
"""
self.destroy()
Fenetredimension()
def afficher_deplacements(self):
"""
Fonction créant une nouvelle fenêtre contenant un texte affichant l'historique des déplacements des joueurs.
L'enregistrement des déplacements est géré par la fonction selectionner.
"""
fenetre_deplacements = Tk() # Création de la nouvelle fenêtre.
# Création de l'étiquette ayant les déplacements comme texte:
texte_d = Label(fenetre_deplacements,
text=self.texte_deplacements,
anchor='e',
padx=10,
pady=10)
texte_d.grid()
fenetre_deplacements.mainloop()
def fonction_de_sauvegarde(self):
"""
Fonction écrasant la sauvegarde précédente et sauvegardant la partie actuelle.
"""
# Vérification de l'existence du fichier 'sauvegarde':
if existe('sauvegarde.txt'):
remove('sauvegarde.txt')
# Création de la sauvegarde:
fichier = open('sauvegarde.txt', 'w')
print(self.partie.damier.cases, file=fichier)
fichier.close()
# Fermeture de la fenêtre d'alarme générée par la fonction self.sauvegarder_partie:
self.fenetre_alarme.destroy()
def sauvegarder_partie(self):
"""
Fonction générant une fenêtre d'alarme demandant à l'utilisateur s'il veut bien sauvegarder.
"""
# Génération de la nouvelle fenêtre d'alarme:
self.fenetre_alarme = Tk()
# Ajout d'une étiquette contenant le texte voulue:
texte_alarme = Label(
self.fenetre_alarme,
text=
'Si vous sauvegarder maintenant, la sauvegarde précédente sera écrasée. '
'\n Voulez-vous continuer?',
padx=10,
pady=10)
texte_alarme.grid(row=0, column=1, padx=10, pady=10)
# Création du bouton 'oui':
bouton_oui = Button(self.fenetre_alarme,
text='Oui',
command=self.fonction_de_sauvegarde,
padx=10,
pady=10)
bouton_oui.grid(row=1, column=0, padx=10, pady=10)
# Création du bouton 'non':
bouton_non = Button(self.fenetre_alarme,
text='Non',
command=self.fenetre_alarme.destroy,
padx=10,
pady=10)
bouton_non.grid(row=1, column=2, padx=10, pady=10)
def charger_partie(self):
"""
Fonction chargeant une partie précédemment sauvegardée. Génère une fenêtre d'alarme en cas d'absence
de sauvegarde.
"""
if existe('sauvegarde.txt'
): # Vérification de l'exitence de la sauvegarde.
# Récupération des données enregistrées dans le fichier .txt:
unfichier = open('sauvegarde.txt', 'r')
dicostr = unfichier.readline()
unfichier.close()
# Gestion de la sauvegarde du dictionnaire:
# initialisation des variables nécessaires:
dico = {} # Le dictionnaire récupéré.
clef = '' # La clé de dictionnaire récupérée sous format str.
clef_p = '' # La clé de dictionnaire récupérée sous format Position.
# Parcours des éléments de la chaîne de caratères contenue dans le fichier .txt:
for i in dicostr:
if i == '{' or i == '}' or i == ' ' or i == ',': # Les caractères à ignorer.
pass
elif i == 'o' or i == 'O' or i == 'x' or i == 'X': # Les caratères représentant les types de pièces.
# Gestion des valeurs du dictionnaire:
if i == 'o':
dico[clef_p] = Piece(
"blanc", "pion"
) # Ajout de l'élément clé-valeur au dictionnaire 'dico'.
# Réinitialisation des variables:
clef_p = ''
clef = ''
# Les mêmes étapes sont répétés pour les autres types de pièces:
if i == 'O':
dico[clef_p] = Piece("blanc", "dame")
clef_p = ''
clef = ''
if i == 'x':
dico[clef_p] = Piece("noir", "pion")
clef_p = ''
clef = ''
if i == 'X':
dico[clef_p] = Piece("noir", "dame")
clef_p = ''
clef = ''
# Gestion des clefs du dictionnaire 'dico':
elif i == ':': # Passage d'une clef à une valeur dans la variable dico_str:
tuple1 = '' # Initialisation de la chaîne de caractère 'tuple1'
for j in clef: # Parcours des caractères de la chaîne de caractère 'clef'.
# Si le caractère peut être un entier, il est ajouter à tuple1:
try:
int(j)
tuple1 += j
except ValueError:
pass
# La variable 'clef_p' reçoit la bonne valeur:
clef_p = Position(int(tuple1[0]), int(tuple1[1]))
# Réinitialisation des variables:
clef = ''
# Dans les autres cas, 'clef' continie de stocker les caratères:
else:
clef += i
# Le dictionnaire définissant la partie est mis à jour par la sauvegarde:
self.partie.damier.cases = dico
# Si la sauvegarde n'existe pas, l'utilisateur en est informé:
else:
fenetre_alerte = Tk() # Création d'une nouvelle fenêtre.
texte = Label(fenetre_alerte,
text='Aucune sauvegarde n\'est disponible',
anchor='e')
texte.grid(padx=10, pady=10)
# Création du bouton pour quitter la fenêtre:
bouton_quitter = Button(fenetre_alerte,
text="Ok",
command=fenetre_alerte.destroy,
padx=10,
pady=10)
bouton_quitter.grid(padx=10, pady=10)
fenetre_alerte.mainloop()
def ouvrir_triches(self):
"""
Fonction ouvrant une nouvelle fenêtre exposant les options de triches.
"""
# Création d'une nouvelle fenêtre:
fenetre_triche = Tk()
# Création du bouton permettant de transformer toutes les pièces en dames:
bouton_dame_tous = Button(
fenetre_triche,
text='Toutes les pièces \n deviennent des dames',
command=self.pion_en_dames_tous,
padx=10,
pady=10)
bouton_dame_tous.grid(column=0, row=0, padx=10, pady=10)
# Création du bouton permettant de transformer les pièces blanches en dames:
bouton_dame_blanc = Button(
fenetre_triche,
text='Les pièces blanches \n deviennent des dames',
command=self.pion_en_dames_blanc,
padx=10,
pady=10)
bouton_dame_blanc.grid(column=1, row=0, padx=10, pady=10)
# Création du bouton permettant de transformer les pièces noires en dames:
bouton_dame_noir = Button(
fenetre_triche,
text='Les pièces noires \n deviennent des dames.',
command=self.pion_en_dames_noir,
padx=10,
pady=10)
bouton_dame_noir.grid(column=2, row=0, padx=10, pady=10)
# Création du bouton permettant de quitter la fenêtre:
bouton_quitter = Button(fenetre_triche,
text='Terminer',
command=fenetre_triche.destroy,
padx=10,
pady=10)
bouton_quitter.grid(column=1, row=1, padx=10, pady=10)
fenetre_triche.mainloop()
def pion_en_dames_noir(self):
"""
Fonction transformant les pièces noires en dames.
"""
# Boucle sur le dictionnaire définissant la partie:
for position in self.partie.damier.cases:
piece = self.partie.damier.recuperer_piece_a_position(position)
# Promotion de la pièce si celle-ci est noire:
if piece.couleur == 'noir':
piece.promouvoir()
# Actualisation du damier:
self.canvas_damier.actualiser()
def pion_en_dames_tous(self):
"""
Fonction transformant toutes les pièces en dames.
"""
# Boucle sur le dictionnaire définissant la partie:
for position in self.partie.damier.cases:
piece = self.partie.damier.recuperer_piece_a_position(position)
# Promotion de la pièce:
piece.promouvoir()
# Actualisation du damier:
self.canvas_damier.actualiser()
def pion_en_dames_blanc(self):
"""
Fonction transformant les pièces noires en dames.
"""
# Boucle sur le dictionnaire définissant la partie:
for position in self.partie.damier.cases:
piece = self.partie.damier.recuperer_piece_a_position(position)
# Promotion de la pièce si celle-ci est blanche:
if piece.couleur == 'blanc':
piece.promouvoir()
# Actualisation du damier:
self.canvas_damier.actualiser()
def selectionner(self, event):
"""Méthode qui gère le clic de souris sur le damier, exécute la gestion des tours et retourne un message
pertinent en cas de victoire.
Args:
event (tkinter.Event): Objet décrivant l'évènement qui a causé l'appel de la méthode.
"""
# Gestion du clic de position cible:
if self.bool_piece_selectionnee:
# On trouve le numéro de ligne/colonne en divisant les positions en y/x par le nombre de pixels par case.
ligne_deplacement = event.y // self.canvas_damier.n_pixels_par_case
colonne_deplacement = event.x // self.canvas_damier.n_pixels_par_case
# Vérification de la validité de la position cible désignée:
if self.partie.position_cible_valide(
Position(ligne_deplacement, colonne_deplacement))[0]:
# Si la position cible est valide, elle est attribuée à la variable 'self.position_cible_graphique:
self.position_cible_graphique = Position(
ligne_deplacement, colonne_deplacement)
else: # Affichage d'un message d'erreur pertinent en cas de position non valide:
self.messages['foreground'] = 'red'
self.messages['text'] = \
self.partie.position_cible_valide(Position(ligne_deplacement, colonne_deplacement))[1]
# Attribution des positions sélectionnées par clic à la variable pertinente de la classe partie:
self.partie.couple_de_position = self.position_selectionnee, self.position_cible_graphique
# Mise à jour du texte des déplacements:
self.texte_deplacements += 'Déplacement du joueur {}, de {} vers {}. \n'.format(
str(self.partie.couleur_joueur_courant),
str(self.position_selectionnee),
str(self.position_cible_graphique))
# Exécution d'un tour:
self.partie.tour()
# On affiche le damier mis a jour.
self.canvas_damier.actualiser()
# Mise à jour de l'affichage du joueur courant:
couleur = str(self.partie.couleur_joueur_courant)
self.couleur_joueur['text'] = 'Tour du joueur {}'.format(couleur)
# Réinitialisation des attributs
self.bool_piece_selectionnee = False
self.piece_selectionnee = None
self.position_selectionnee = None
self.partie.position_source_selectionnee = None
# Gestion des messages de victoire:
if not self.partie.damier.piece_de_couleur_peut_se_deplacer(self.partie.couleur_joueur_courant) and \
not self.partie.damier.piece_de_couleur_peut_faire_une_prise(self.partie.couleur_joueur_courant):
if self.partie.couleur_joueur_courant == 'noir':
self.messages['foreground'] = 'blue'
self.messages[
'text'] = 'Victoire du joueur blanc! Félicitations!'
return # Arrêt de la méthode
if self.partie.couleur_joueur_courant == 'blanc':
self.messages['foreground'] = 'blue'
self.messages[
'text'] = 'Victoire du joueur noir! Félicitations!'
return # Arrêt de la méthode
# Fin de l'exécution de la méthode:
return
# Gestion du clic de position source:
if not self.bool_piece_selectionnee:
# 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_damier.n_pixels_par_case
colonne = event.x // self.canvas_damier.n_pixels_par_case
# Validation de la position source sélectionnée
if self.partie.position_source_valide(Position(ligne, colonne))[0]:
# Si le joueur peut faire une prise, il y est obligé.
# Vérification si le joueur peut faire une prise:
if self.partie.damier.piece_de_couleur_peut_faire_une_prise(
self.partie.couleur_joueur_courant):
# Vérification si la pièce sélectionnée peut faire une prise:
if self.partie.damier.piece_peut_faire_une_prise(
Position(ligne, colonne)):
# Vérification si le joueur à déjà pris une pièce et doit continuer à prendre avec celle-ci:
if self.partie.position_source_forcee is not None \
and self.partie.position_source_forcee == Position(ligne, colonne):
# Si toutes les conditions sont réunies, les variables spnt mises à jour:
self.position_selectionnee = Position(
ligne, colonne)
self.partie.position_source_selectionnee = self.position_selectionnee
# Si le joueur n'est pas contraint par une position source forcée:
elif self.partie.position_source_forcee is None:
self.position_selectionnee = Position(
ligne, colonne)
self.partie.position_source_selectionnee = self.position_selectionnee
# Affichage d'un message d'erreur pertinent en cas d'erreur et arrêt de la méthode:
else:
self.messages['foreground'] = 'red'
self.messages['text'] = 'Erreur: Vous devez sélectionner la piece {}' \
.format(str(self.partie.position_source_forcee))
return # Arrêt de la méthode
# Affichage d'un message d'erreur pertinent en cas d'erreur:
else:
self.messages['foreground'] = 'red'
self.messages[
'text'] = 'Erreur: Vous devez sélectionner une pièce pouvant faire une prise.'
# Si le joueur n'est pas contraint dans son choix de position source:
else:
self.position_selectionnee = Position(ligne, colonne)
self.partie.position_source_selectionnee = self.position_selectionnee
# On récupère l'information sur la pièce à l'endroit choisi.
self.piece_selectionnee = self.partie.damier.recuperer_piece_a_position(
self.position_selectionnee)
# Affichage d'un message pertinent si le joueur à sélectionner une pièce source valide:
if self.piece_selectionnee is not None:
self.messages['foreground'] = 'black'
self.messages[
'text'] = 'Pièce sélectionnée à la position {}.'.format(
self.position_selectionnee)
self.bool_piece_selectionnee = True
# Affichage d'un message d'erreur si la position source n'est pas valide et arrêt de la méthode:
else:
self.messages['foreground'] = 'red'
self.messages['text'] = self.partie.position_source_valide(
Position(ligne, colonne))[1]
return # Arrêt de la méthode
# On affiche le damier mis a jour.
self.canvas_damier.actualiser()
import socket
import select
from partie import Partie
hote = ""
port = 12800
connexion_principale = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connexion_principale.bind((hote, port))
connexion_principale.listen(5)
print("Le serveur écoute à présent sur le port {}".format(port))
# Choix de la carte
jeu = Partie()
jeu.choisir_carte()
jeu.lire_carte()
carte_vide = jeu.carte.obtenir_carte()
# Gestion de la connexion des clients
serveur_lance = True
clients_connectes = []
while serveur_lance:
# On va vérifier que de nouveaux clients ne demandent pas à se connecter
# Pour cela, on écoute la connexion_principale en lecture
# On attend maximum 50ms
connexions_demandees, wlist, xlist = select.select([connexion_principale],
[], [], 0.05)
for connexion in connexions_demandees:
def __init__(self):
"""Constructeur de la classe FenetrePartie. On initialise une partie en utilisant la classe Partie du TP3 et
on dispose les «widgets» dans la fenêtre.
"""
# Appel du constructeur de la classe de base (Tk)
super().__init__()
# La partie
self.partie = Partie()
# Création du canvas damier.
self.canvas_damier = CanvasDamier(self, self.partie.damier, 60)
self.canvas_damier.grid(sticky=NSEW)
self.canvas_damier.bind('<Button-1>', self.selectionner)
# self.canvas_damier.bind('<B1-Button_release>', self.enregistrer_position_cible)
self.canvas_damier.couleur_foncee = '#426D8F' # Bleu
self.canvas_damier.couleur_pale = 'light cyan'
# Ajout d'une étiquette d'information.
self.messages1 = Label(self) # Affichage des messages
self.messages1.grid()
self.messages1['foreground'] = 'blue'
self.messages1['background'] = 'mint cream'
self.messages1['text'] = 'Quelle pièce désirez-vous déplacer?'
self.colonne_damier_reel = "abcdefgh"
# Ajout des boutons : A permettant d'obtenir l'aide et B de quitter et d'enregistrer.
self.bouton1_A = Button(self,
text='Aide',
bg='SlateGray1',
command=self.aide)
self.bouton1_B = Button(self,
text='Quitter',
bg='SlateGray1',
command=self.quitter_damier)
self.bouton1_C = Button(self,
text='Partie sauvegardée',
bg='SlateGray1',
command=self.partie_sauvegardee)
self.bouton1_D = Button(self,
text="Couleurs du damier",
bg='SlateGray1',
command=self.couleur_damier)
self.bouton1_A['foreground'] = 'midnight blue'
self.bouton1_B['foreground'] = 'midnight blue'
self.bouton1_C['foreground'] = 'midnight blue'
self.bouton1_D['foreground'] = 'midnight blue'
self.bouton1_A.grid(row=2, column=0, pady=5, sticky=W)
self.bouton1_B.grid(row=1, column=1, padx=25, pady=5)
self.bouton1_C.grid(row=2, column=1, pady=5, sticky=E)
self.bouton1_D.grid(row=2, column=0, pady=5, sticky=S)
# Liste des mouvements
self.messages1_B = Label(self)
self.messages1_B.grid(row=0, column=1, sticky=N)
self.messages1_B['foreground'] = 'black'
self.messages1_B['background'] = 'white'
self.messages1_B['text'] = "Blanc Noir\n───────\n"
self.numero_deplacement = 1
# Initialisation des attributs
self.doit_prendre = False
self.position_source_selectionnee = None
self.position_source_forcee = None
# Nom de la fenêtre
self.titre_joueur = self.partie.couleur_joueur_courant + " joue!"
self.title("Jeu de dames. Le joueur " + self.titre_joueur)
self['background'] = 'mint cream'
# Truc pour le redimensionnement automatique des éléments de la fenêtre.
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
class mon_interface(Tk):
def __init__(self):
super().__init__()
self.wait = BooleanVar()
self.wait.set(False)
self.relance_de = []
self.title("Poker d'As")
self.frame_player1 = LabelFrame(self,
text="Player 1",
padx=20,
pady=20)
self.frame_player1.grid(row=1, column=1)
self.player1 = Label(
self.frame_player1,
text=
"Combinaison:\nLancés_restants:\nRésultat:\nPourcentage de parties gagnées:\nParties jouées:",
justify="left")
self.player1.grid()
self.frame_player2 = LabelFrame(self,
text="Player 2",
padx=20,
pady=20)
self.frame_player2.grid(row=2, column=1)
self.player2 = Label(
self.frame_player2,
text=
"Combinaison:\nLancés_restants:\nRésultat:\nPourcentage de parties gagnées:\nParties jouées:",
justify="left")
self.player2.grid()
self.frame_player3 = LabelFrame(self,
text="Player 3",
padx=20,
pady=20)
self.frame_player3.grid(row=3, column=1)
self.player3 = Label(
self.frame_player3,
text=
"Combinaison:\nLancés_restants:\nRésultat:\nPourcentage de parties gagnées:\nParties jouées:",
justify="left")
self.player3.grid()
self.joueur_interface = [(self.frame_player1, self.player1),
(self.frame_player2, self.player2),
(self.frame_player3, self.player3)]
self.tour_a = Label(self, text="C'est au tour de ", justify="center")
self.tour_a.grid(row=1, column=2, columnspan=5)
self.lance_a_faire = Label(self, text="Tour: 0/0", justify="center")
self.lance_a_faire.grid(row=1, column=7, columnspan=4)
frame1 = Frame(self, borderwidth=2, relief=GROOVE).grid(row=2,
column=2)
self.de_1 = Button(frame1,
text="0",
width=3,
height=2,
command=lambda: self.buttom_action(0),
padx=5,
pady=5)
self.de_1.grid(row=2, column=3)
self.de_2 = Button(frame1,
text="1",
width=3,
height=2,
command=lambda: self.buttom_action(1),
padx=5,
pady=5)
self.de_2.grid(row=2, column=4)
self.de_3 = Button(frame1,
text="2",
width=3,
height=2,
command=lambda: self.buttom_action(2),
padx=5,
pady=5)
self.de_3.grid(row=2, column=5)
self.de_4 = Button(frame1,
text="3",
width=3,
height=2,
command=lambda: self.buttom_action(3),
padx=5,
pady=5)
self.de_4.grid(row=2, column=6)
self.de_5 = Button(frame1,
text="4",
width=3,
height=2,
command=lambda: self.buttom_action(4),
padx=5,
pady=5)
self.de_5.grid(row=2, column=7)
self.de_buttom = [
self.de_1, self.de_2, self.de_3, self.de_4, self.de_5
]
Button(self, text="Nouvelle Partie",
command=self.nouvelle_partie).grid(row=4,
column=6,
columnspan=4)
self.blancer = Button(self,
command=self.relance,
text="Garder/Lancer dés")
self.blancer.grid(row=3, column=2, columnspan=3)
self.tour = Button(self, text="Tour suivant", command=self.next_game)
self.tour.grid(row=4, column=2, columnspan=3)
self.sauvegarde = Button(self,
text="Sauvegarde",
command=self.fonction_sauvegarde)
self.sauvegarde.grid(row=3, column=6, columnspan=4)
self.menu = menu(self)
def next_game(self):
"""
Permet de continuer une partie qui est terminée sans la redémarrer
:return: aucun paramètre
"""
self.partie = Partie(self.list_obj_joueur, self)
for i in self.de_buttom:
i.config(state="normal")
self.blancer.config(state="normal")
self.tour.config(state="disabled")
self.partie.jouer_partie()
self.tour.config(state="normal")
self.blancer.config(state="disabled")
for i in self.de_buttom:
i.config(state="disabled")
def fonction_sauvegarde(self):
"""
Permet au bouton Sauvegarder d'accéder à la méthode de sauvegarde
:return: aucun paramètre
"""
self.partie.sauvegarde()
def relance(self):
"""
Permet au joueur de relancer les dés choisis par celui-ci, afin de changer son type de combinaison
:return: aucun paramètre
"""
self.wait.set(False)
self.update()
def nouvelle_partie(self):
"""
Permet de changer les paramètres de la nouvelle partie et de la commencer ou terminer.
:return: aucun paramètre
"""
self.menu = menu(self)
def buttom_action(self, index):
"""
Permet d'afficher et de sélectionner les dés à partir des dés sélectionnés
:param index: la position du bouton activé
:return: aucun paramètre
"""
if index in self.relance_de:
#print(index)
#print(self.partie.joueur_actif.combinaison.des[index])
self.de_buttom[index].config(
text=self.partie.joueur_actif.combinaison.des[index])
self.relance_de.remove(index)
else:
self.de_buttom[index].config(text="")
self.relance_de.append(index)
Le fichier python à exécuter avec python pour lancer le jeu
"""
import os
from partie import Partie
if __name__ == "__main__":
print(
"Bienvenue à roboc.\n"
+ "1. Nouvelle partie\n"
+ "2. Continuer une partie existante"
)
while True:
choix = int(input("Votre choix:"))
jeu = Partie()
if choix == 1:
print("\nNouvelle partie")
jeu.choisir_carte()
jeu.lire_carte()
jeu.lancer_partie()
break
elif choix == 2:
print("\nContinuer une partie existante")
if os.path.exists("save"):
jeu.charger_sauvegarde()
jeu.lancer_partie()
break
else:
print("Il n'y'a aucune partie sauvegardée.")
else:
from partie import Partie game = Partie() game.startGame()
def __init__(self):
"""
Constructeur de la classe FenetrePartie. On initialise une partie en utilisant la classe Partie du TP3 et
on dispose les «widgets» dans la fenêtre.
"""
# Appel du constructeur de la classe de base (Tk):
super().__init__()
# La partie:
self.partie = Partie()
# Création du canvas damier:
self.canvas_damier = CanvasDamier(self, self.partie.damier, 60)
self.canvas_damier.grid(sticky=NSEW)
self.canvas_damier.bind('<Button-1>', self.selectionner)
# Ajout d'une étiquette d'information:
self.messages = Label(self)
self.messages.grid()
# Ajout d'une étiquette de couleur du tour du joueur:
self.couleur_joueur = Label(self)
self.couleur_joueur.grid()
self.couleur_joueur['text'] = 'Tour du joueur {}'.format('blanc')
# Nom de la fenêtre («title» est une méthode de la classe de base «Tk»):
self.title("Jeu de dames")
# Truc pour le redimensionnement automatique des éléments de la fenêtre:
self.grid_columnconfigure(0, weight=1)
self.grid_rowconfigure(0, weight=1)
# Ajout de variables se rappelant si une pièce est sélectionnée:
self.bool_piece_selectionnee = False
self.piece_selectionnee = None
self.position_selectionnee = None
# Ajout d'uhe variable gérant le déplacement:
self.position_cible_graphique = None
# Ajout d'une chaîne de caractère enregistrant les déplacements effectués:
self.texte_deplacements = 'Liste des déplacements, du plus récent au plus ancien: \n'
# Ajout du cadre des boutons:
self.cadre_bouton = Frame(self)
self.cadre_bouton.grid(padx=10, pady=10)
# Création du bouton 'Nouvelle partie':
self.bouton_nouvelle_partie = Button(self.cadre_bouton,
text="Nouvelle partie",
command=self.nouvelle_partie,
padx=10,
pady=10)
self.bouton_nouvelle_partie.grid(padx=10, pady=10, column=0, row=0)
# Création du bouton 'quitter':
self.bouton_Quitter = Button(self.cadre_bouton,
text="Quitter",
command=self.destroy,
padx=10,
pady=10)
self.bouton_Quitter.grid(padx=10, pady=10, column=1, row=0)
# Création du bourron 'Règlements':
self.bouton_reglements = Button(self.cadre_bouton,
text="Règlements",
command=ouvrir_reglements,
padx=10,
pady=10)
self.bouton_reglements.grid(padx=10, pady=10, column=2, row=0)
# Création du bouton 'Déplacement':
self.bouton_deplacements = Button(self.cadre_bouton,
text='Déplacements',
command=self.afficher_deplacements,
padx=10,
pady=10)
self.bouton_deplacements.grid(padx=10, pady=10, column=3, row=0)
# Création du bouton 'Sauvegarder':
self.bouton_sauvegarder = Button(self.cadre_bouton,
text='Sauvegarder',
command=self.sauvegarder_partie,
padx=10,
pady=10)
self.bouton_sauvegarder.grid(padx=10, pady=10, column=0, row=1)
# Création du bouton 'Charger':
self.bouton_charger = Button(self.cadre_bouton,
text='Charger',
command=self.charger_partie,
padx=10,
pady=10)
self.bouton_charger.grid(padx=10, pady=10, column=1, row=1)
# Création du bouton 'Tricher':
self.bouton_triche = Button(self.cadre_bouton,
text="Tricher",
command=self.ouvrir_triches,
padx=10,
pady=10)
self.bouton_triche.grid(padx=10, pady=10, column=2, row=1)
# Initialisation de la variable 'fenetre_alarme':
self.fenetre_alarme = None
