MASTERMIND (PAR JULIE ET HCD)

#! /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() 
#_________________________________________________________________________________________________________________________________________________________________________