def dessine(fenetre, pile):
for i in range(len(pile)):
# coordonnées du coin inférieur gauche de la planchette
x0 = Fenetre.largeur(fenetre) / 2 + VuePlanchette.pixels(
Empilement.centreGeometrique(pile[i]) -
Planchette.longueur(pile[i][0]) / 2)
y0 = Fenetre.hauteur(fenetre) - 40 - VuePlanchette.pixels(
(i + 1) * Planchette.Epaisseur)
if i % 2 == 0:
couleur = VuePioche.Couleur1
else:
couleur = VuePioche.Couleur2
VuePlanchette.dessine(fenetre, Empilement.planchette(pile[i]), x0, y0,
couleur)
# coordonnées du centre de la croix
x_croix = Fenetre.largeur(fenetre) / 2 + VuePlanchette.pixels(
Empilement.centreGravite(pile[i]))
y_croix = Fenetre.hauteur(fenetre) - 40 - VuePlanchette.pixels(
(i + 0.5) * Planchette.Epaisseur)
if Empilement.desequilibre(pile[i]) == True:
dessine_croix(fenetre, '#FF3200', x_croix, y_croix)
else:
dessine_croix(fenetre, 'dark green', x_croix, y_croix)
def askRejouer(jeu, message):
if Fenetre.rejouer(fenetre(jeu), message) == "yes":
Fenetre.quitte(fenetre(jeu))
jeu = cree()
joue(jeu)
else:
Fenetre.quitte(fenetre(jeu))
def choisisDecalage(jeu, planchetteAPoser):
titre = getName(jeu, indiceJoueur(jeu))
txt = getName(jeu, indiceJoueur(jeu)) + " choisit ton decalage"
decalage = Fenetre.saisisEntier(fenetre(jeu), txt, titre)
while decalage is None:
decalage = Fenetre.saisisEntier(fenetre(jeu), txt, titre)
if decalage is not None:
return decalage
def selectionnePlanchette(jeu):
titre = getName(jeu, indiceJoueur(jeu))
txt = getName(jeu, indiceJoueur(jeu)) + " selectionne ta planchette"
selection = Fenetre.saisisTexte(fenetre(jeu), txt, titre)
while selection is None or Pioche.contient(piocheJoueur(jeu),
selection) is False:
selection = Fenetre.saisisTexte(fenetre(jeu), txt, titre)
if selection is not None:
return selection
def dessine(fenetre, planchette, x0, y0, couleur):
"""
Dessine une planchette dans une fenetre Tkinter, en fonction des coordonnées
choisies.
:param fenetre: La fenêtre dans laquelle travailler.
:param planchette: La planchette à dessiner.
:param x0: La coordonnée x0 (en haut à gauche).
:param y0: La coordonnée y0 (en bas à gauche).
:param couleur: La couleur à donner.
:type fenetre: Tkinter Windows
:type planchette: Planchette
:type x0: Entier
:type y0: Entier
:type couleur: String
:return: Dessine dans une fenetre (retourne rien).
:rtype: void
"""
longueur = pixels(Planchette.longueur(planchette))
hauteur = pixels(Planchette.Epaisseur)
marge = pixels(Planchette.marge(planchette))
#Marge
Fenetre.toile(fenetre).create_rectangle(x0,
y0,
x0 + longueur,
y0 + hauteur,
fill=CouleurFond)
#Par dessus on met le "coeur" de la planchette.
Fenetre.toile(fenetre).create_rectangle(x0 + marge,
y0,
x0 + (longueur - marge),
y0 + hauteur,
fill=couleur)
#On crée le polygone du dessus
Fenetre.toile(fenetre).create_polygon((x0, y0), (x0 + longueur, y0),
(x0 + longueur + 8, y0 - 8),
(x0 + 8, y0 - 8),
fill=CouleurFond,
outline="black")
Fenetre.toile(fenetre).create_polygon(
(x0 + marge, y0), (x0 + longueur - marge, y0),
(x0 + longueur + 8 - marge, y0 - 8), (x0 + 8 + marge, y0 - 8),
fill=couleur,
outline="black")
Fenetre.toile(fenetre).create_polygon(
(x0 + longueur, y0 + Facteur), (x0 + longueur + 8, y0 + Facteur - 8),
(x0 + longueur + 8, y0 - 8), (x0 + longueur, y0),
fill=CouleurFond,
outline="black")
def dessine_croix(fenetre, color, x, y):
Fenetre.toile(fenetre).create_line(x - VuePlanchette.pixels(0.3),
y - VuePlanchette.pixels(0.3),
x + VuePlanchette.pixels(0.3),
y + VuePlanchette.pixels(0.3),
fill=color,
width=2)
Fenetre.toile(fenetre).create_line(x - VuePlanchette.pixels(0.3),
y + VuePlanchette.pixels(0.3),
x + VuePlanchette.pixels(0.3),
y - VuePlanchette.pixels(0.3),
fill=color,
width=2)
def joue(jeu, is_replay=False, is_save=False):
majVues(jeu)
if is_replay:
print("Hello")
replay(jeu)
elif is_save:
activite(jeu, debutPartie=False
) #Si c'est une sauvegarde on est plus au début de la partie.
else:
print("youhou")
#Si on joue, on supprime le dernier replay pour repartir sur un fichier vide.
if os.path.exists("replay.txt"):
os.remove("replay.txt")
activite(jeu)
Fenetre.bouclePrincipale(fenetre(jeu))
def majVues(jeu):
"""
Met à jour la vue.
"""
#D'abord on efface les graphiques.
Fenetre.effaceGraphiques(fenetre(jeu))
#Puis on dessine la pile (initialement vide)
VuePile.dessine(fenetre(jeu), pile(jeu))
#Puis pour chaque joueur, on affiche la pioche.
for iteration, joueur in enumerate(joueurs(jeu)):
if (iteration == 0): #Le premier joueur à gauche, l'autre à droite.
gauche = True
else:
gauche = False
VuePioche.dessine(fenetre(jeu), Joueur.pioche(joueur), gauche)
def cree():
return {
"fenetre": Fenetre.cree(1000, 600),
"pile": Pile.cree(),
"0": Joueur.cree(0),
"1": Joueur.cree(1),
"courant": 0,
"name": ["", ""]
}
def dessine(fenetre, pioche, gauche):
# La largeur de la fenetre nous sera utile.
largeur_fenetre = Fenetre.largeur(fenetre)
hauteur_fenetre = Fenetre.hauteur(fenetre)
y0 = hauteur_fenetre - len(pioche) * 20
if gauche:
Fenetre.toile(fenetre).create_text(100,
300,
text="Joueur 1",
font=("Purisa", 16))
else:
Fenetre.toile(fenetre).create_text(880,
300,
text="Joueur 2",
font=("Purisa", 16))
for iteration, exemplaires in enumerate(pioche):
planchette = Exemplaires.planchette(exemplaires)
if gauche: #Si on est à gauche
x0 = 20
Fenetre.toile(fenetre).create_text(
x0, y0, text=Exemplaires.versChaine(exemplaires), anchor='w')
VuePlanchette.dessine(fenetre,
planchette,
x0 + 40,
y0,
couleur=Couleur1)
else: #Sinon on est à droite
longueur_planchette = VuePlanchette.pixels(
Planchette.longueur(planchette))
x0 = largeur_fenetre - 40 - longueur_planchette
Fenetre.toile(fenetre).create_text(
x0 + longueur_planchette,
y0,
text=Exemplaires.versChaine(exemplaires),
anchor='e')
VuePlanchette.dessine(fenetre,
planchette,
x0 - 40,
y0,
couleur=Couleur2)
y0 += 20
def loadGame():
with open("data.json", "r") as read_file:
data = json.load(read_file)
if data == "":
texte = "pas de partie a chargé"
jeu = Jeuselectionsouris.cree()
else:
jeu = data
jeu["fenetre"] = Fenetre.cree(1000, 600)
Jeuselectionsouris.joue(jeu)
def dessine(fenetre, planchette, x0, y0, color="blue"):
"""
"""
eppaisseur = pixels(Planchette.Epaisseur)
marge = pixels(Planchette.marge(planchette))
longueur = pixels(Planchette.longueur(planchette)) - 2 * marge
Fenetre.toile(fenetre).create_rectangle(x0,
y0,
x0 + marge,
y0 + eppaisseur,
fill="grey")
Fenetre.toile(fenetre).create_rectangle(x0 + marge,
y0,
x0 + marge + longueur,
y0 + eppaisseur,
fill=color,
tag=Planchette.numero(planchette))
Fenetre.toile(fenetre).create_rectangle(x0 + marge + longueur,
y0,
x0 + marge + longueur + marge,
y0 + eppaisseur,
fill="grey")
def dessine(fenetre, pile):
y0 = Planchette.Epaisseur
for empilement in pile:
x0 = Empilement.centreGeometrique(
empilement) - Empilement.planchette(empilement)[0]/2
planchette = Empilement.planchette(empilement)
x = VuePlanchette.pixels(x0) + Fenetre.largeur(fenetre)/2
y = Fenetre.hauteur(fenetre) - VuePlanchette.pixels(y0) - 40
VuePlanchette.dessine(fenetre, planchette, x, y,
Empilement.color(empilement))
x1 = VuePlanchette.pixels(Empilement.centreGravite(
empilement)) + Fenetre.largeur(fenetre)/2
y1 = y + VuePlanchette.pixels(Planchette.Epaisseur / 2)
if Empilement.desequilibre(empilement):
color = "red"
else:
color = "green"
Fenetre.toile(fenetre).create_line(
x1-5, y1-5, x1+5, y1+5, width=3, fill=color)
Fenetre.toile(fenetre).create_line(
x1+5, y1-5, x1-5, y1+5, width=3, fill=color)
y0 += Planchette.Epaisseur
def cree():
return (Fenetre.cree(1000,
600), Pile.cree(), [Joueur.cree(1),
Joueur.cree(2)], {
'indiceJoueur': 0
})
def replay(jeu, iteration=0):
"""
Fonction qui s'occupe d'afficher le replay d'une partie.
Cette fonction lit le fichier replay.txt s'il existe. Les données sont stockées sous la
forme: indiceJoueur;planchette;decalage
indiceJoueur est un entier, planchette est de la forme longueur,marge
et decalage est un entier.
Entre chaque lecture de ligne, donc chaque tour on met un petit timer de 2 secondes.
Aucun retour, juste de l'affichage.
Pour l'affichage, on utilise la fonction tkinter.after, équivalent de time.sleep.
time.sleep ne fonctionne pas avec Tkinter : l'affichage ne se faisait qu'à la toute fin.
Pause de 2 secondes entre chaque tour.
:param jeu: Tuple fourni par Jeu.cree()
:type jeu: tuple
:return: Nothing
:rtype: Nothing
"""
#On regarde si le fichier replay.txt existe avec un try/catch simple.
try:
file = open("replay.txt")
except IOError:
print("Fichier de replay introuvable.")
VueJeu.affichageMessage(Fenetre.toile(fenetre(jeu)),
"Fichier introuvable.\nRééssayez")
else:
with file:
contenu = file.read().split(";") #On split les données par ";"
#Compréhension de listes parce que c'est joli et qu'on l'a fait nulle part dans le projet. Et on prend le 1er élément.
tour = [
contenu[i:i + 3] if len(contenu[i:i + 3]) == 3 else None
for i in range(iteration, iteration + 3, 3)
][0]
if tour != None:
joueurCourant = int(tour[0])
piocheJoueur = Joueur.pioche(
joueurs(jeu)[joueurCourant]) #On récupère sa pioche
planchette_brute = tour[1].split(",")
longueur, marge = int(planchette_brute[0]), int(
planchette_brute[1])
planchette = Planchette.cree(longueur, marge)
decalage = int(tour[2])
Pioche.retire(piocheJoueur, Planchette.numero(planchette))
Pile.empileEtCalcule(pile(jeu), planchette, decalage)
majVues(jeu)
# Documentation : http://tkinter.fdex.eu/doc/uwm.html#after
Fenetre.tk(fenetre(jeu)).after(1000, replay, jeu,
iteration + 3)
#Une aide pour mieux comprendre la partie : qui joue ?
#On le place après le after sinon le message est supprimé avant même que nous l'ayons vu.
VueJeu.affichageMessage(
Fenetre.toile(fenetre(jeu)),
"Tour : " + Joueur.nom(joueurs(jeu)[joueurCourant]), 120,
50, 24)
else:
# On remet à zéro comme ça ça efface le texte mis auparavant.
Fenetre.effaceGraphiques(fenetre(jeu))
majVues(jeu)
#Et on affiche.
VueJeu.affichageMessage(Fenetre.toile(fenetre(jeu)),
"PARTIE TERMINEE")
dernier_joueur = int(contenu[-4])
VueJeu.affichageMessage(
Fenetre.toile(fenetre(jeu)),
Joueur.nom(joueurs(jeu)[dernier_joueur]) + " perd !", 500,
300)
from Mobile import * from Noeud import * from Arbre import * from Fenetre import * from tkinter import * Fen = Fenetre() Fen.mainloop()
def activite(jeu, debutPartie=True):
"""
Applique le diagramme d'activité de la Notice de l'Etape 5.
:param jeu: Le Jeu.
:type jeu: Tuple.
"""
nombrePlanchettes = Pioche.nombrePlanchettes(
Joueur.pioche(joueurCourant(jeu)))
desequilibre = False
partieFinie = False
while nombrePlanchettes != 0 and desequilibre == False and partieFinie != True:
VueJeu.affichageMessage(Fenetre.toile(fenetre(jeu)),
"Tour : " + Joueur.nom(joueurCourant(jeu)),
120, 50, 24)
planchette = selectionnePlanchette(jeu)
if planchette == None:
partieFinie = True
else:
#### REPLAY ####
saveReplay(indiceJoueur(jeu)) #Toujours l'indice du joueur en 1er
saveReplay(
str(Planchette.longueur(planchette)) + "," +
str(Planchette.marge(planchette))
) #Puis on sauvegarde la planchette dans un format prédéfini.
#### JEU COURANT ####
pioche = Joueur.pioche(joueurCourant(jeu))
Pioche.retire(pioche, Planchette.numero(
planchette)) #On retire la planchette de la pioche.
if debutPartie: #Si c'est le début de partie
Pile.empileEtCalcule(pile(jeu), planchette, 0)
saveReplay(0) #On met le décalage à 0.
majVues(jeu)
passeJoueurSuivant(jeu)
debutPartie = False
else: #Si ce n'est pas le début de partie
passeJoueurSuivant(jeu)
decalage = choisisDecalage(jeu, planchette)
saveReplay(decalage)
if decalage == None:
partieFinie = True
else:
Pile.empileEtCalcule(pile(jeu), planchette, decalage)
for empilement in pile(jeu):
if Empilement.desequilibre(empilement):
desequilibre = True
nombrePlanchettes = Pioche.nombrePlanchettes(
Joueur.pioche(joueurCourant(jeu)))
majVues(jeu)
if desequilibre: #S'il y a un déséquilibre
Dialogue.afficheMessage(
"{joueur} gagne !".format(joueur=Joueur.nom(joueurCourant(jeu))))
else: #S'il n'y en a pas.
if Pioche.nombrePlanchettes(Joueur.pioche(joueurCourant(jeu))) == 0:
Dialogue.afficheMessage("Egalité de la partie")
else:
save = Dialogue.yesNoMessage(
"La partie est terminée ! Voulez-vous sauvegarder ?")
#SAUVEGARDE
if save:
sauvegarde_jeu = (pile(jeu), joueurs(jeu), {
'indiceJoueur': indiceJoueur(jeu)
})
pickle.dump(sauvegarde_jeu, open("save.txt", "wb"))
#Rejouer une partie ?
rejouer = Dialogue.yesNoMessage("Voulez-vous recommencer une partie ?")
Fenetre.quitte(fenetre(jeu)) #On supprime dans tous les cas la fenêtre
if rejouer:
joue(cree(
)) #On recrée les données puis on nettoie et on peut joueur à nouveau.
def joue(jeu):
majVues(jeu)
Fenetre.quandOuverte(fenetre(jeu), activite, jeu)
Fenetre.affiche(fenetre(jeu))
def setName(jeu):
jeu["name"][0] = Fenetre.saisisTexte(fenetre(jeu), "Nom Joueur 0: ")
jeu["name"][1] = Fenetre.saisisTexte(fenetre(jeu), "Nom Joueur 1: ")
def partieNormale(event, fenetre=None):
if fenetre != None:
Fenetre.quitte(fenetre)
jeu = Jeu.cree()
Jeu.joue(jeu)
# -*- coding: utf8 -*-
import sys
sys.path.append("core/")
sys.path.append("fonction/")
sys.path.append("classe/")
from Initialisation import *
from Fenetre import *
connexion = start()
fenetre = Fenetre('Ajout d\'une voiture', connexion, None)
# Connexion de l'utilisateur
fenetre.AfficherFenetre()
while fenetre.GetResultatButton().GetConnexion() == None:
fenetre = Fenetre('ErreurConnexion', connexion, None)
fenetre.AfficherFenetre()
# Boucle
boucle = 1
while boucle:
ResultatPrecedent = fenetre.GetDicoResult()
fenetre = Fenetre(fenetre.GetNextFenetre(), connexion, ResultatPrecedent)
fenetre.AfficherFenetre()
from Mobile import * from Noeud import * from Arbre import * from Fenetre import * from tkinter import * Fen = Fenetre() Fen.mainloop()
import Fenetre
import Planchette
import VuePlanchette
p = Planchette.cree(12, 4)
ep = VuePlanchette.pixels(Planchette.Epaisseur)
r = range(ep, 10*ep, ep)
for test in range(1, 4):
# test 1 : les 10 planchettes sont affichées
f = Fenetre.cree(1000, 600)
for xy in r:
# test 2 : seule la dernière planchette est affichée
if (test == 2):
Fenetre.effaceGraphiques(f)
VuePlanchette.dessine(f, p, xy, xy)
# test 3 : aucune planchette n'est affichée
if (test == 3):
Fenetre.effaceGraphiques(f)
Fenetre.affiche(f)
def partieSauvegarde(event, fenetre):
Fenetre.quitte(fenetre)
sauvegarde = pickle.load(open("save.txt", "rb"))
jeu = (Fenetre.cree(1000,
600), sauvegarde[0], sauvegarde[1], sauvegarde[2])
Jeu.joue(jeu, is_save=True)
def majVues(jeu):
""" Met a jour les element du canvas """
Fenetre.effaceGraphiques(fenetre(jeu))
VuePile.dessine(fenetre(jeu), pile(jeu))
VuePioche.dessine(fenetre(jeu), Joueur.pioche(jeu["0"]), True, "blue")
VuePioche.dessine(fenetre(jeu), Joueur.pioche(jeu["1"]), False, "red")
def partieReplay(event, fenetre):
Fenetre.quitte(fenetre)
jeu = Jeu.cree()
Jeu.joue(jeu, is_replay=True)
def AjoutFenetre(stringFenetre):
fichier = open("Test.py",'r')
contenu_fichier = fichier.read().decode('utf8')
fichier.close()
contenu_fichier_modifie = contenu_fichier + "\n\n" + stringFenetre
fichier = open("Test.py","w")
fichier.write(contenu_fichier_modifie.encode('utf8'))
fichier.close()
connexion = start()
fenetre = Fenetre('GestionDeFenetre',connexion,None)
fenetre.AfficherFenetre()
# Boucle
boucle = 1
while boucle:
if fenetre.GetTitre() == "FenetreCreationDeFenetre":
resultat = fenetre.GetDicoResult()
resultat_forme = resultat["listResultEntry"]
titre_fenetre = resultat_forme[0].get()
# Suppression des espaces
titre_fenetre = titre_fenetre.replace(" ","")
description_fenetre = resultat_forme[1].get()
''' Created on 1 fevr. 2019 @author: Denis ''' from Fenetre import * from Robot import * from Controlleur import * import time from Obstacle import * #on creer la fenetre ma_fenetre=Fenetre(900,900) #a ne pas changer, ou alors reflechir a comment creer des constantes inter-fichiers #on creer les robots mon_robot=Robot(400,400, [1,-1] ) #ne pas mettre 0,0 en direction initiale ou les fonctions tourner ne marcheront pas mon_robot2= Robot(320,420, [0,1] ) #on creer leur controlleur controlleur = Controlleur(mon_robot) controlleur2 = Controlleur(mon_robot2) #une premiere mise a jour avec la direction initiale controlleur.update_coords_dir() controlleur2.update_coords_dir() #on dessine les robot triangle = ma_fenetre.fenetre.create_polygon(mon_robot.A,mon_robot.B,mon_robot.C) triangle2= ma_fenetre.fenetre.create_polygon(mon_robot2.A,mon_robot2.B,mon_robot2.C, fill='blue')
Jeuselectionsouris.joue(jeu)
def loadGame():
with open("data.json", "r") as read_file:
data = json.load(read_file)
if data == "":
texte = "pas de partie a chargé"
jeu = Jeuselectionsouris.cree()
else:
jeu = data
jeu["fenetre"] = Fenetre.cree(1000, 600)
Jeuselectionsouris.joue(jeu)
welcomePage = Fenetre.cree(300, 100)
canvas = Fenetre.toile(welcomePage)
text = Label(canvas, text="PYTATRA")
text.pack()
boutons1 = Button(
canvas,
text="Nouvelle partie",
command=lambda: [Fenetre.tk(welcomePage).destroy(),
newGame()])
boutons1.pack()
boutons2 = Button(
canvas,
text="Charger partie",
command=lambda: [Fenetre.tk(welcomePage).destroy(),
loadGame()])
boutons2.pack()
import os
from Classes import *
from Fenetre import *
import string
# os.system("cls")
app = Fenetre()
app.mainloop()
Fenetre.quitte(fenetre)
jeu = Jeu.cree()
Jeu.joue(jeu, is_replay=True)
def partieSauvegarde(event, fenetre):
Fenetre.quitte(fenetre)
sauvegarde = pickle.load(open("save.txt", "rb"))
jeu = (Fenetre.cree(1000,
600), sauvegarde[0], sauvegarde[1], sauvegarde[2])
Jeu.joue(jeu, is_save=True)
if path.exists('save.txt') or path.exists(
'replay.txt'): #On regarde s'il existe une sauvegarde ou un replay
fenetre = Fenetre.cree(300, 300)
normale = Button(Fenetre.toile(fenetre), text="Nouvelle partie")
normale.bind("<Button-1>", lambda event: partieNormale(event, fenetre))
save = Button(Fenetre.toile(fenetre), text="Charger dernière sauvegarde")
save.bind("<Button-1>", lambda event: partieSauvegarde(event, fenetre))
normale.pack()
save.pack()
if path.exists("replay.txt"):
replay = Button(Fenetre.toile(fenetre), text="Replay dernière partie")
replay.bind("<Button-1>", lambda event: partieReplay(event, fenetre))
replay.pack()