Mastermind (par julie et hcd)
Description
PRESENTATION
Au lancement du jeu, le bouton < Mise en place du jeu !> fait apparaître:
- la zone des couleurs choisies pour la partie
- la zone de jeu dans laquelle le chercheur inscrira ses propositions (de haut en bas)
- la zone de réponse où sera indiqué le nombre de couleurs bien et/ou mal placées de la proposition
- la zone de la solution pour visualiser la combinaison choisie par l'ordinateur
En haut du plan de jeu apparaissent:
- une commande permettant d'accéder à tout moment à la <Règle du jeu>
- une commande pour <quitter le jeu !>
Ce travail a été réalisé en 2006 par Julie avec ma collaboration.
Je le publie aujourd'hui, pensant qu'il intéresserait les débutants en PYTHON.
Au lancement du jeu, le bouton < Mise en place du jeu !> fait apparaître:
- la zone des couleurs choisies pour la partie
- la zone de jeu dans laquelle le chercheur inscrira ses propositions (de haut en bas)
- la zone de réponse où sera indiqué le nombre de couleurs bien et/ou mal placées de la proposition
- la zone de la solution pour visualiser la combinaison choisie par l'ordinateur
En haut du plan de jeu apparaissent:
- une commande permettant d'accéder à tout moment à la <Règle du jeu>
- une commande pour <quitter le jeu !>
Source / Exemple :
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
# Python version 2.5a1
# Tk version 8.4
# IDLE version 1.2a1
#########################################################################################################################################################################
from Tkinter import*
from math import *
from random import randrange
from tkMessageBox import askokcancel
k=1.0 #échelle des zones (mini=0.5 ; maxi=1.1) : ce paramètre est modifiable
################################################### PRESENTATION DU SCRIPT ###########################################################################################
# Le code met en oeuvre le concept de LISTE pour la gestion des couleurs (et des chiffres associés), des zones de jeu, de réponse et de solution.
# Pour alléger le code, ces listes sont définies de façon contractée; par exemple, pour la création des cercles gris de la zone de jeu :
# < xCC,yCC=[225*k+50*k*i for i in range(0,taille_combinaison)],[125*k+50*k*j for j in range(0,max_propositions)] >
# < CC=[can.create_oval(xCC[i]-r,yCC[j]-r,xCC[i]+r,yCC[j]+r,width=2,fill="grey")for j in range(0,max_propositions)for i in range(0,taille_combinaison)]
# La sélection d'une couleur pour créer une proposition dans la zone de jeu utilise le clic gauche de la souris, avec les fonctions:
# <def mouseDown( event)> : "Opérations à effectuer quand le bouton gauche de la souris est enfoncé"
# <def mouseUp( event)> : "Opérations à effectuer quand le bouton gauche de la souris est relâché"
# Le réglage des paramètres du jeu, fait appel au widget <Scale>, par exemple:
# <RAmin,RAmax,RAdef=5,10,8>
# <RA=Scale(can2,length=215,orient=HORIZONTAL,sliderlength=15,label='nombre de couleurs (entre 5 et 10)',from_=RAmin,to=RAmax,troughcolor='white',command=nb_couleurs)>
# <RA.set(RAdef)>
# <RA.pack(padx=5,pady=2,side=BOTTOM,anchor=SW)>
# Les commandes font appel au widget <Button>, avec les méthodes d'"activation" (par exemple:<MeP.configure(state=NORMAL)>) et de "désactivation" (par exemple:<MeP.configure(state=DISABLED)>)
# Les deux commandes <Règle du jeu> et <Quitter> sont traitées différemment, dans la barre de menu de la fenêtre principale.
# Pour pouvoir montrer ou cacher la solution (cad la combinaison choisie par l'ordinateur) deux <Radiobutton> sont incorporés au code.
##########################################################################################################################################################################
def mise_en_place():
"mise en place du jeu"
global C,CC,CCC,S,RR,couleurs,flag,chiffres,prop,propo
global xC,yC,xCC,yCC,xRR,yRR,xS,yS
flag=0 #indicateur : la fonction <clic> de la souris n'est pas activée
RaZ.configure(state=DISABLED) #activation du bouton "Remise à Zéro !"
MeP.configure(state=DISABLED) #désactivation du bouton "Mise en Place !"
prop=[0]*taille_combinaison #création d'une liste pour recueillir la couleur choisie pour chaque case de la proposition
propo=[0]*taille_combinaison #création d'une liste pour recueillir les couleurs de la proposition dans la zone de jeu
can.delete(ALL)
can.create_text(30*k,80*k,text='couleurs',fill="white")
can.create_text(300*k,80*k,text='zone de jeu',fill="white")
can.create_text(600*k,80*k,text='zone de réponse',fill="white")
can.create_text(300*k,690*k,text='solution',fill="white")
#afficher la zone des couleurs
can.create_rectangle(0,100*k,50*k,150*k+50*k*(nb_couleurs-1),width=2,fill="white") #création du rectangle blanc de la zone des couleurs
#afficher les couleurs
couleurs=["brown","red","green","blue","orange","purple","yellow","pink","white","cyan"] #création d'une liste de 10 couleurs
chiffres=[0]*len(couleurs) #création d'une liste de chiffres de <len(couleurs> éléments
for i in range(0,len(couleurs)):chiffres[i]=couleurs.index(couleurs[i])+1 #création d'une liste affectant un chiffre à chaque couleur
xC,yC=25*k,[125*k+50*k*i for i in range(0,nb_couleurs)] #coordonnées des centres des cercles
C=[can.create_oval(xC-r,yC[i]-r,xC+r,yC[i]+r,width=2,fill=couleurs[i])for i in range(0,nb_couleurs)] #création des cercles de la zone des couleurs
#afficher la zone de jeu
can.create_rectangle(200*k,100*k,250*k+50*k*(taille_combinaison-1),150*k+50*k*(max_propositions-1),width=2,fill="white") #création du rectangle blanc de la zone de jeu
xCC,yCC=[225*k+50*k*i for i in range(0,taille_combinaison)],[125*k+50*k*j for j in range(0,max_propositions)] #coordonnées des centres des cercles gris de la zone de jeu
CC=[can.create_oval(xCC[i]-r,yCC[j]-r,xCC[i]+r,yCC[j]+r,width=2,fill="grey")for j in range(0,max_propositions)for i in range(0,taille_combinaison)] #création des cercles
CCC=[can.create_polygon(120*k,yCC[j]-r/8,180*k,yCC[j]-r/8,180*k,yCC[j]-r/2,190*k,yCC[j],180*k,yCC[j]+r/2,180*k,yCC[j]+r/8,120*k,yCC[j]+r/8,width=0,fill="dark green")for j in range(0,max_propositions)] #création des flèches indiquant la ligne de la proposition à faire
can.itemconfig(CCC[0],fill="white") #coloration en blanc de la flèche de la première ligne
#afficher la zone de réponse
can.create_rectangle(550*k,100*k,575*k+20*k*(taille_combinaison-1),150*k+50*k*(max_propositions-1),width=2,fill="white") #création du rectangle blanc de la zone de réponse
xRR,yRR=[560*k+20*k*i for i in range(0,taille_combinaison)],[125*k+50*k*j for j in range(0,max_propositions)] #coordonnées des coins des traits gris de la zone de réponse
RR=[can.create_rectangle(xRR[i],yRR[j]-r,xRR[i]+5,yRR[j]+r,width=1,fill="grey",outline="black")for j in range(0,max_propositions)for i in range(0,taille_combinaison)] #création des traits
#définition de la zone de la solution
can.create_rectangle(200*k,625*k,250*k+50*k*(taille_combinaison-1),675*k,width=2,fill="white") #création du rectangle blanc de la zone de la solution
xS,yS=[225*k+50*k*i for i in range(0,taille_combinaison)],650*k #coordonnées des centres des cercles gris de la zone de la solution
S=[can.create_oval(xS[i]-r,yS-r,xS[i]+r,yS+r,width=2,fill="grey")for i in range(0,taille_combinaison)] #création des cercles
information.config(text=texte2) #message d'information
jouer()
#_________________________________________________________________________________________________________________________________________________________________________
#paramétrage du jeu
def nb_couleurs(a):
"récupération de la valeur (a) choisie sur l'échelle"
global nb_couleurs
nb_couleurs=int(a) #affectation à la variable <nb_couleurs>
def taille_de_combinaison(a):
"récupération de la valeur (a) choisie sur l'échelle"
global taille_combinaison
taille_combinaison=int(a) #affectation à la variable <taille_combinaison>
def nombre_maximum_de_propositions(a):
"récupération de la valeur (a) choisie sur l'échelle"
global max_propositions
max_propositions=int(a) #affectation à la variable <max_propositions>
def nombre_total_de_parties(a):
"récupération de la valeur (a) choisie sur l'échelle"
global total_parties
total_parties=int(a) #affectation à la variable <total_parties>
#_________________________________________________________________________________________________________________________________________________________________________
def jouer():
"fonction pour lancer une nouvelle partie"
global NP,NBien_Place, NMal_Place,CNP
NBien_Place,NMal_Place=0,0 #initialiser quelques variables
NP=NP+1 #incrémenter le nombre de parties quand on fait une nouvelle partie
while NP in range (1,total_parties+1):
combinaison() #l'ordinateur choisit la combinaison
break
#__________________________________________________________________________________________________________________________________________________________________________
def combinaison():
"fonction qui incite l'ordinateur a entrer la combinaison"
global combin
combin=[randrange(1,nb_couleurs) for i in range(0,taille_combinaison)] #l'ordinateur choisit aléatoirement <taille_combinaison> chiffres parmi les entiers compris entre 1 et <nb_couleurs> ("grey" est exclus)
#_________________________________________________________________________________________________________________________________________________________________________
def mouseDown( event):
"Opérations à effectuer quand le bouton gauche de la souris est enfoncé"
global selObject,X,Y,couleur,choix_couleur_effectue,flag,chiffre,prop,propo
can.currObject=None # aucun objet sélectionné
X,Y=event.x,event.y # coordonnées du clic
flag=1 #la fonction <clic> de la souris est activée
#choix d'une couleur dans la zone des couleurs
xC,yC=25*k,[125*k+50*k*i for i in range(0,nb_couleurs)]
D=[hypot(X-xC,Y-yC[i]) for i in range(0,nb_couleurs)] # liste des distances entre le clic et les centres des cercles C[i] de la zone des couleurs
for i in range(0,nb_couleurs): #pour chaque chiffre (cad chaque couleur) sélectionné...
if D[i]<r: #si la distance entre le clic et le centre du cercle C[i] est inférieure au rayon du cercle (le clic est à l'intérieur de C[i])...
selObject=C[i] # sélection de C[i]...
couleur=couleurs[i] # la couleur choisie est celle du cercle C[i]...
chiffre=chiffres[i] #le chiffre choisi est celui correspondant à la couleur choisie...
can.itemconfig(selObject,width=4) # le contour du cercle sélectionné double d'épaisseur...
choix_couleur_effectue=True #le choix a été effectué...
#affichage de la couleur choisie dans la zone de jeu
xCC,yCC=[225*k+50*k*i for i in range(0,taille_combinaison)],[125*k+50*k*j for j in range(0,max_propositions)]
RC=[hypot(X-xCC[i],Y-yCC[j])for j in range(0,max_propositions)for i in range(0,taille_combinaison)]# liste des distances entre le clic et les centres des cercles CC[i,j] de la zone de jeu
for j in range(0,max_propositions): #pour chaque proposition faite dans la zone de jeu...
for i in range(0,taille_combinaison): #pour chaque chiffre de la proposition...
if RC[i+taille_combinaison*j]<15: #si la distance entre le clic et le centre du cercle CC[i] est inférieure au rayon du cercle (le clic est à l'intérieur de CC[i,j])...
selObject=CC[i+taille_combinaison*j] # sélection de CC[i,j]...
if choix_couleur_effectue==False : #si le choix n'a pas été effectué...
selObject=None #aucune sélection possible...
if choix_couleur_effectue==True : #si le choix a été effectué...
can.itemconfig(selObject,fill=couleur,width=4) #C[i,j] prend la couleur choisie et son contour double d'épaisseur...
propo[i]=chiffre #le chiffre correspondant à la couleur choisie est placé dans la liste <propo>...
p=propo.count(0) # le compteur <p> détermine le nombre de cases non remplies
if p==0:
prop=propo #la liste <prop> récupère la proposition complète
can.itemconfig(CCC[j],fill="dark green") #effacement de l'indicateur de ligne
if j<max_propositions-1: can.itemconfig(CCC[j+1],fill="white") #coloration en blanc de la flèche indicant la ligne suivante
proposition()
#_________________________________________________________________________________________________________________________________________________________________________
def proposition():
"fonction pour faire une proposition"
global CNP
CNP=CNP+1 # on incrémente CNP de 1
direBienMalPlaces() #dire au chercheur ce qu'il en est de sa proposition
#_________________________________________________________________________________________________________________________________________________________________________
def direBienMalPlaces():
"fonction qui donne les résultats "
global Bien_Place,Mal_Place,NBien_Place, NMal_Place,NP,CNP,C1,C2,s
while NP in range(1,total_parties+1):
for i in range(1,nb_couleurs+1): #on va tester chaque chiffre <i> (couleur) de la proposition
Bien_Place,Mal_Place=0,0 #réinitialiser les variables <Bien_Place> et <Mal_Place>
#compter le nombre de chiffres (couleurs) bien placés
for j in range(0,taille_combinaison):
if prop[j]==i and combin[j]==i: #si le chiffre <i> de <prop> est le même que celui de <combin> ...
Bien_Place=Bien_Place+1 # on incrémente <Bien_Place> de 1 ...
NBien_Place=NBien_Place+Bien_Place #et on incrémente <NBien_Place> de <Bien_Place>
#compter le nombre de chiffres (couleurs) mal placés
if combin.count(i)>=prop.count(i): #on compare le nombre de <i> de <combin> au nombre de <i> de <prop>
Mal_Place=prop.count(i)-Bien_Place
else:
Mal_Place=combin.count(i)-Bien_Place
NMal_Place=NMal_Place+Mal_Place #on incrémente <NMal_Place> de <Mal_Place>
for k in range(0,NBien_Place):can.itemconfig(RR[k+taille_combinaison*(CNP-1)],fill="green") #la zone de réponse indique en vert le nombre de couleurs trouvées bien placées
for k in range(0,NMal_Place):can.itemconfig(RR[k+NBien_Place+taille_combinaison*(CNP-1)],fill="orange") #la zone de réponse indique en orange le nombre de couleurs trouvées mal placées
for k in range(0,taille_combinaison-NBien_Place-NMal_Place):can.itemconfig(RR[k+NBien_Place+NMal_Place+taille_combinaison*(CNP-1)],fill="red") #la zone de réponse indique en rouge le nombre de couleurs non trouvées
#résultat et préparation du coup suivant
if NBien_Place==taille_combinaison: #si le joueur trouve la combinaison
information.config(text=texte3)
RaZ.configure(state=NORMAL) #activation du bouton "Remise à Zéro !"
can.itemconfig(CCC[CNP],fill="dark green") #effacement de la flèche blanche
C1[0]=C1[0]+1
C1[1]=C1[1]+0
s=s+CNP
CNP=0 #on remet à zéro
RPG.config(text='%s'%C1[0])
RPP.config(text='%s'%C1[1])
if C1[0]+C1[1]==total_parties: #annoncer le gagnant
if C1[0]>C1[1]:
information.config(text=texte6)
RaZ.configure(state=DISABLED) #désactivation du bouton "Lancer une nouvelle partie !"
RJR.configure(state=NORMAL) #activation du bouton "Lancer une nouvelle manche !"
else:
information.config(text=texte7)
RaZ.configure(state=DISABLED) #désactivation du bouton "Lancer une nouvelle partie !"
RJR.configure(state=NORMAL) #activation du bouton "Lancer une nouvelle manche !"
C2=float(s/(C1[0]+C1[1]))
for j in range(0,taille_combinaison): prop[j]=0
NBien_Place,NMal_Place=0,0
break
else: #si le joueur ne trouve pas la combinaison
information.config(text=texte4)
for j in range(0,taille_combinaison): prop[j]=0
NBien_Place,NMal_Place=0,0 #remise à zéro
if CNP==max_propositions:
C1[1]=C1[1]+1
C1[0]=C1[0]+0
information.config(text=texte5)
RPG.config(text='%s'%C1[0])
RPP.config(text='%s'%C1[1])
RaZ.configure(state=NORMAL) #activation du bouton "Lancer une nouvelle partie !"
s=s+CNP
NBien_Place,NMal_Place=0,0 #remise à zéro
CNP=0 #remise à zéro
if C1[0]+C1[1]==total_parties: #annoncer le gagnant
if C1[0]>C1[1]:
information.config(text=texte6)
RaZ.configure(state=DISABLED) #désactivation du bouton "Remise à Zéro !"
RJR.configure(state=NORMAL) #activation du bouton "Lancer une nouvelle partie !"
else:
information.config(text=texte7)
RaZ.configure(state=DISABLED) #désactivation du bouton "Remise à Zéro !"
RJR.configure(state=NORMAL) #activation du bouton "Lancer une nouvelle partie !"
C2=float(s/(C1[0]+C1[1]))
break
#_________________________________________________________________________________________________________________________________________________________________________
def mouseUp( event):
"Opérations à effectuer quand le bouton gauche de la souris est relâché"
global selObject,flag
if flag==1: #si la fonction <clic> de la souris est activée...
can.itemconfig(selObject,width=2) # le contour de l'objet sélectionné revient à son épaisseur initiale
if flag==0: #si la fonction <clic> de la souris n'est pas activée...
selObject=None # aucun objet sélectionné
#_________________________________________________________________________________________________________________________________________________________________________
def quitter():
" façon classique de quitter l'application "
ans=askokcancel('MASTERMIND',"Voulez-vous réellement quitter ?")
if ans:root.quit()
#_________________________________________________________________________________________________________________________________________________________________________
def rejouer():
"lancer une nouvelle manche"
global RA,RB,RC,RD,FF,CNP,NP,s
RJR.configure(state=DISABLED) #désactivation du bouton "Rejouer !"
RaZ.configure(state=DISABLED) #désactivation du bouton "Remise à Zéro !"
MeP.configure(state=NORMAL) #activation du bouton "Mise en Place !"
information.config(text=texte1)
s=0 #remise à zéro
CNP,NP=0,0 #remise à zéro
C1[0],C1[1],C2=0,0,0 #remise à zéro
RPG.config(text='%s'%C1[0]);RPP.config(text='%s'%C1[1])
choix_couleur_effectue=False #le choix d'une couleur n'est pas encore effectué
can.delete(ALL) #effacement de toutes les zones
RA.set(RAdef);RB.set(RBdef);RC.set(RCdef);RD.set(RDdef) #affectation des valeurs par défaut aux échelles de réglage des paramètres du jeu
choix_montrer_cacher.set(niveau[0])
#_________________________________________________________________________________________________________________________________________________________________________
def remiseAZero():
"remettre tout a zéro et nouvelle partie"
global CNP
RaZ.configure(state=DISABLED) #désactivation du bouton "Lancer une nouvelle partie !"
MeP.configure(state=DISABLED) #désactivation du bouton "Mise en Place !"
information.config(text=texte2)
CNP=0
for j in range(0,max_propositions):
for i in range(0,taille_combinaison):
can.itemconfig(CC[i+taille_combinaison*j],fill="grey") #retour à la couleur grise pour tous les cercles de la zone de jeu
can.itemconfig(RR[i+taille_combinaison*j],fill="grey") #retour à la couleur grise pour tous les traits de la zone de réponse
for i in range(0,taille_combinaison):
can.itemconfig(S[i],fill="grey") #retour à la couleur grise pour tous les cercles de la zone de solution
choix_couleur_effectue=False #le choix d'une couleur n'est pas encore effectué
choix_montrer_cacher.set(niveau[0])
jouer()
#_________________________________________________________________________________________________________________________________________________________________________
def presentation():
"Fenêtre-message contenant la description sommaire du principe du jeu"
msg =Toplevel()
Message(msg, bg ="dark green", fg ="white", width =810,font ="Arial 10",
text =''' PRESENTATION\n
Au lancement du jeu, le bouton < Mise en place du jeu !> fait apparaître:
- la zone des couleurs choisies pour la partie
- la zone de jeu dans laquelle le chercheur inscrira ses propositions (de haut en bas)
- la zone de réponse où sera indiqué le nombre de couleurs bien et/ou mal placées de la proposition
- la zone de la solution pour visualiser la combinaison choisie par l'ordinateur\n
En haut du plan de jeu apparaissent:
- une commande permettant d'accéder à tout moment à la <Règle du jeu>
- une commande pour <quitter le jeu !>\n
A la droite du plan de jeu apparaissent :
- une fenêtre jaune donnant les consignes de jeu, en fonction des résultats obtenus
- une fenêtre rose indiquant le nombre de parties gagnées/perdues\n\n''').pack(padx =10, pady =10)
#_________________________________________________________________________________________________________________________________________________________________________
def processus():
"Fenêtre-message contenant la description du processus de jeu"
msg =Toplevel()
Message(msg, bg ="dark green", fg ="white", width =500,font ="Arial 10",
text='''PROCESSUS à suivre\n
(suivre les instructions apparaissant dans la fenêtre d'information)\n
1. Choisir les paramètres du jeu :
- nombre de couleurs (entre 5 et 10)
- taille de combinaison (entre 4 et 6)
- nombre maximum de propositions (entre 6 et 10)
- nombre maximum de parties par manche (entre 1 et 10)\n
2. Cliquer sur le bouton < Mise en place du jeu ! > :
- l'ordinateur choisit une combinaison
- celle-ci peut apparaitre dans la zone de la solution\n
3. Faire une proposition sur la première ligne du jeu :
- le nombre de couleurs bien et/ou mal placées apparaît en vert/orange
- le nombre de couleurs non trouvées apparaît en rouge\n
4. Continuer ainsi sur les lignes suivantes du jeu
tant que le nombre maximum permis de propositions n'est pas atteint\n
5. Quand la partie est "gagnée" ou "perdue", cliquer sur <Nouvelle partie !>\n
6. Quand le nombre maximum de parties est atteint, cliquer sur <Lancer une nouvelle manche !>\n
7. Cliquer sur < Quitter le jeu !> pour abandonner la partie\n''').pack(padx =10, pady =10)
#_________________________________________________________________________________________________________________________________________________________________________
def aPropos():
"Fenêtre-message indiquant les versions utilisées"
msg =Toplevel()
Message(msg, width =200, aspect =100, justify =CENTER,
text ='''MASTERMIND
Julie en collaboration avec HCD, Avril 2006
Python version 2.5.a1
Tk version 8.4''').pack(padx =10, pady =10)
#_________________________________________________________________________________________________________________________________________________________________________
def makemenu(win):
"barre de menu"
top=Menu(win)
win.config(menu=top)
R=Menu(top)
top.add_cascade(label='Règle du jeu',menu=R,underline=0)
R.add_command(label='Présentation',command=presentation,underline=0)
R.add_command(label='Processus',command=processus,underline=0)
R.add_command(label='A propos',command=aPropos,underline=0)
Q=Menu(top)
top.add_cascade(label='Quitter !',menu=Q,underline=0)
Q.add_command(label='Quitter le jeu !!',command=quitter,underline=0)
#_________________________________________________________________________________________________________________________________________________________________________
def montrer_cacher():
" montrer ou cacher la solution"
global S,N
if activation_cases==1:
N=choix_montrer_cacher.get()# entrée du n° de choix (de 1 à 2)
if N==1:
for i in range(0,taille_combinaison):
can.itemconfig(S[i],fill="grey") #masquer : affectation de la couleur grise à toutes les cases de la solution
choix_montrer_cacher.set(niveau[0])
if N==2:
for i in range(0,taille_combinaison):
can.itemconfig(S[i],fill=couleurs[ combin[i]-1]) #montrer : affectation des couleurs correspondant aux chiffres de la combinaison
choix_montrer_cacher.set(niveau[1])
#_________________________________________________________________________________________________________________________________________________________________________
def stop_it():
"arrêt de l'animation des 3 boules"
global flag1
flag1 =0
def start_it():
"démarrage de l'animation des 3 boules"
global flag1
global oval1,oval2,oval3
if flag1 ==0:
flag1 =1
oval1 = can.create_oval(x1, y1, x1+3*r, y1+3*r, width=1, fill='white')
oval2 = can.create_oval(x2, y2, x2+3*r, y2+3*r, width=1, fill='red')
oval3 = can.create_oval(x3, y3, x3+3*r, y3+3*r, width=1, fill='blue')
move()
#_________________________________________________________________________________________________________________________________________________________________________
def stop():
""
global flag2
flag2=0
can.delete(ALL) # effacement du contenu de la fenêtre
######## Programme principal #############################################################################################################################################
root=Tk()
root.title('>>>>>>> MASTERMIND <<<<<<<')
makemenu(root)
# données initiales des trois boules animées
flag1=0 # compteur
a1,a2,a3=pi/4-pi/37,-pi/4,pi/3 # angle avec l'axe des x
x1,y1,x2,y2,x3,y3=100,100,500,450,600,700 # coordonnées en x et y
dv1,dv2,dv3=15,10,5 # module du vecteur vitesse
# coordonnées des vecteurs vitesse
dx1,dy1=dv1*cos(a1),dv1*sin(a1)
dx2,dy2=dv2*cos(a2),dv2*sin(a2)
dx3,dy3=dv3*cos(a3),dv3*sin(a3)
p,n=1,0.99 # pas de calcul(p),cefficient de réduction de la vitesse (n)
q=22.5
ov12,ov23,ov31=0,0,0
#initialisation des variables du MASTERMIND
flag=0
choix_couleur_effectue=False
r=15*k #rayon des cercles
CNP=0 #current_nb_partie
Bien_Place,Mal_Place=0,0
NBien_Place,NMal_Place=0,0
C1=[0,0]
C2=0 #compteur du nombre moyen de propositions par partie
NP=0 #nombre de parties
s=0
activation_cases=1
#mise en place du canevas de la zone de jeu
can=Canvas(root,height=810,width=1200, bg='dark green')
can.grid(row=1,column=0)
# mise en place du canevas 2 comprenant la zone de texte, la zone des paramètres réglables et la zone des boutons de commande
can2=Canvas(root,height=810,width=200, bg='brown')
can2.grid(row=1,column=1)
selObject=can2
# commandes à partir de la souris
root.bind("<Button-1>", mouseDown) # commandes avec le clic gauche de la souris, lorsqu'il est enfoncé
root.bind("<Button1-ButtonRelease>", mouseUp) # commandes avec le clic gauche de la souris, lorsqu'il est relâché
#définition des boutons de commande
RaZ=Button(can2,text='Nouvelle partie !',height=1,width=35,relief=GROOVE,bg="light blue",command=remiseAZero)
RaZ.pack(padx=5,pady=2,side =BOTTOM,anchor=SW)
RaZ.configure(state=DISABLED)
RJR=Button(can2,text='Lancer une nouvelle manche !',height=1,width=35,relief=GROOVE,bg="light blue",command=rejouer)
RJR.pack(padx=5,pady=2,side =BOTTOM,anchor=SW)
RJR.configure(state=DISABLED)
MeP=Button(can2,text='Mise en place du jeu !',height=1,width=35,relief=GROOVE,bg="light blue",command=mise_en_place)
MeP.pack(padx=5,pady=2,side =BOTTOM,anchor=SW)
MeP.configure(state=NORMAL)
#définition des échelles de réglage des paramètres du jeu
RDmin,RDmax,RDdef=1,10,5
RCmin,RCmax,RCdef=6,10,8
RBmin,RBmax,RBdef=4,6,5
RAmin,RAmax,RAdef=5,10,8
RD=Scale(can2,length=215,orient=HORIZONTAL,sliderlength=15,label='nombre de parties (entre 1 et 10)', from_ =RDmin, to =RDmax, troughcolor ='white',command =nombre_total_de_parties)
RD.set(RDdef)
RD.pack(padx=5,pady=2,side =BOTTOM,anchor=SW)
RC=Scale(can2,length=215,orient=HORIZONTAL,sliderlength=15,label='maximum de propositions (entre 6 et 10)', from_ =RCmin, to =RCmax, troughcolor ='white',command =nombre_maximum_de_propositions)
RC.set(RCdef)
RC.pack(padx=5,pady=2,side =BOTTOM,anchor=SW)
RB=Scale(can2,length=215,orient=HORIZONTAL,sliderlength=15,label='taille de combinaison (entre 4 et 6)', from_ =RBmin, to =RBmax, troughcolor ='white',command =taille_de_combinaison)
RB.set(RBdef)
RB.pack(padx=5,pady=2,side =BOTTOM,anchor=SW)
RA=Scale(can2,length=215,orient=HORIZONTAL,sliderlength=15,label='nombre de couleurs (entre 5 et 10)', from_ =RAmin, to =RAmax, troughcolor ='white',command =nb_couleurs)
RA.set(RAdef)
RA.pack(padx=5,pady=2,side =BOTTOM,anchor=SW)
#affichage des résultats
RPP=Label(can2,text='0',fg='white',bg='brown')
RPP.pack(side=BOTTOM,anchor=S)
RPG=Label(can2,text='0',fg='white',bg='brown')
RPG.pack(side=BOTTOM,anchor=S)
texte9="Parties gagnées\nParties perdues"
information1=Label(can2,text=texte9,height=3,width=36,bg="pink",fg="blue",command=None)
information1.pack(padx=5,pady=2,side=BOTTOM,anchor=SW)
#fenêtre d'information (sur fond jaune)
texte1='Jouons au MASTERMIND ! ( par Julie et HCD)\n\nCommencer par choisir les paramètres du jeu.\nEnsuite :\n Appuyer sur le bouton <Mise en place du jeu!>\npour lancer une nouvelle manche\n\n(la manche se joue en plusieurs parties)'
texte2="L'ordinateur a choisi une combinaison\nFaire une proposition\n(sur la première ligne)"
texte3="Bravo : partie gagnée !\nAppuyer sur <Nouvelle partie !>\npour relancer une partie"
texte4="La combinaison ne convient pas !\nFaire une nouvelle proposition\n(sur la ligne suivante)"
texte5="Vous avez perdu cette partie !\nAppuyer sur <Nouvelle partie !>\npour relancer une partie"
texte6="Vous avez gagné cette manche !\nAppuyer sur <Lancer une nouvelle manche !>\npour lancer une nouvelle manche\nou sur <Quitter !> pour arrêter le jeu"
texte7="L'ordinateur a gagné cette manche !\nAppuyer sur <Lancer une nouvelle manche !>\npour relancer une nouvelle manche\nou sur <Quitter !> pour arrêter le jeu"
information=Label(can2,text=texte1,height=21,width=36,bg="yellow",fg="dark blue",command=None)
information.pack(padx=5,pady=5,side=BOTTOM,anchor=SW)
# montrer ou cacher la combinaison
Label(can2,text='''Cacher ou montrer la solution''',fg='white',bg='brown').pack(padx=5,pady=1,side=BOTTOM)
niveau=["1","2"]
choix_montrer_cacher=IntVar()
choix_montrer_cacher.set(niveau[0])
for i in range(0,2):
rad=Radiobutton(can2,variable=choix_montrer_cacher,value=niveau[i],command=montrer_cacher)
rad.pack(padx=20,ipadx=20,pady=5,side=LEFT)
#_________________________________________________________________________________________________________________________________________________________________________
root.config(bg="brown")
root.mainloop()# démarrage du réceptionnaire d'évènements (boucle principale)
root.destroy()
#_________________________________________________________________________________________________________________________________________________________________________
Conclusion :
Ce travail a été réalisé en 2006 par Julie avec ma collaboration.
Je le publie aujourd'hui, pensant qu'il intéresserait les débutants en PYTHON.
Codes Sources
A voir également
- Mastermind (par julie et hcd)
- Mastermind dessin animé ✓ - Forum C
- Mastermind python - Forum Python
- Mastermind - Forum Python
- Jeu mastermind - Forum Python
- Help, faire un mastermind en python et en tkinter avant le 24 !!! ✓ - Forum Python
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.