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'
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 game = Partie() game.startGame()
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:
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))
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" :
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):
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 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
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 __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