jeudi 22 janvier 2015

Python: Jeu Qui-est-ce

La nouvelle version du jeu Qui-Est-ce est plus élaborée.
En effet une première version plus simple est publiée ici:
http://blerow.blogspot.fr/2014/12/python-jeu-qui-estce.html


Cette version plus élaborée calcule les questions posées par l'ordinateur qui joue contre le joueur.
Un coefficient de pertinence des questions optimise les questions.

De plus, les animaux sont masqués par des rectangles lorsqu'ils sont éliminés.

L'image du zoo est à déposer sur le répertoire où se trouve le code du programme.

voici le code (pour pyzo)

#---------------------------------------------------------------------------------------------
#                                             jeu QUI EST CE ?
#
# Blerow
#  ...
#  ..
#----------------------------------------------------------------------------------------------
# date: janvier 2015
#-----------------------------------------------------------------------------------------------
# objet
# réalisation du jeu de societe Qui est ce
# PYTHON sur PYZO
#---------------------------------------------------------------------------------------------

#import des bib
# tkinter pour l'interface graphique
# scipy pour utiliser array
from tkinter import *
from scipy import *
         
#----------------------------------------------------------------------------------------------


#liste des personnes
#--------------0----1-------2--------3-------4-------5------6-------7-------8
listeCouleur=( '','bleu','violet','jaune','orange','vert','noir','blanc','rouge')

listePrenom = ('Ane','Dauphin','Giraphe','Koala','Leopard','Marsupilami','Mouette','Paon','Phoque','Requin','Tortue','Zebre')
#définitions des données


#liste des personnes
#--------------0----1-------2--------3-------4-------5------6-------7-------8
listpersonnes = array([
[0,'Nom'    ,'Poils','NbYeux','Chapeau','Corne','Peau','nez'], 
[1,'Ane'    ,    2,      2,       1,      0,      2,    1 ],
[2,'Dauphin',    0,      2,       0,      0,      3,    0 ],
[3,'Giraphe',    0,      2,       0,      2,      4,    1 ],
[4,'Koala'  ,    0,      1,       0,      0,      1,    1 ],
[5,'Leopard',    0,      3,       0,      0,      5,    1 ],
[6,'Marsupilami',0,      4,       5,      0,      2,    1 ],
[7,'Mouette',    0,      4,       0,      0,      4,    1 ],
[8,'Paon'   ,    1,      2,       0,      0,      1,    1 ],
[9,'Phoque' ,    0,      1,       0,      0,      2,    1 ],
[10,'Requin',    0,      2,       1,      0,      5,    1 ],
[11,'Tortue',    0,      2,       0,      0,      3,    1 ],
[12,'Zebre' ,    0,      2,       0,      0,      4,    1 ],

]
)


#coordonnees
coordonnees= array ([
 [0 ,0 ],

 [15 ,10 ],
 [100,10 ],
 [185,10 ],
 [270,10 ],
 [355,10 ],
 [440,10 ],

 [15 ,135],
 [100,135],
 [185,135],
 [270,135],
 [355,135],
 [480,135],

 [15 ,260],
 [100,260],
 [185,260],
 [250,260],
 [355,260],
 [440,260],

 [15 ,385],
 [100,385],
 [185,385],
 [270,385],
 [355,385],
 [440,385]
]
)


listquestionspossibles = array([
[0,''     ,'poste dans listpersonne','opération','valeurdecomparaison' ], 
[1,'Poils absent' ,           2, '=',0 ],
[2,'Poils présent' ,          2, '>',0 ],
[3,'Poils de couleur bleue',  2, '=',1 ],
[4,'Poils de couleur violet', 2, '=',2 ],
[5,'Poils de couleur jaune',  2, '=',3 ],
[6,'Poils de couleur orange', 2, '=',4 ],
[7,'Poils de couleur verte',  2, '=',5 ],
[8,'Poils de couleur noire',  2, '=',6 ],
[9,'Poils de couleur blanche',2, '=',7 ],
[10,'nombre d o = 1 ',       3, '=',1 ],
[11,'nombre de y = 2',       3, '=',2 ],
[12,'nombre de y = 3',       3, '=',3 ],
[13,'nombre de y = 4',       3, '=',4 ],
[14,'chapeau absent' ,           4, '=',0 ],
[15,'chapeau présent' ,          4, '>',0 ],
[16,'chapeau de couleur bleue',  4, '=',1 ],
[17,'chapeau de couleur violet', 4, '=',2 ],
[18,'chapeau de couleur jaune',  4, '=',3],
[19,'chapeau de couleur orange', 4, '=',4 ],
[20,'chapeau de couleur verte',  4, '=',5 ],
[21,'chapeau de couleur noire',  4, '=',6 ],
[22,'chapeau de couleur blanche',4, '=',7 ],
[23,'corne absente' ,               5, '=',0 ],
[24,'corne présente' ,              5, '>',0 ],
[25,'peau de couleur bleue',            6, '=',1 ],
[26,'peau de couleur violet',           6, '=',2 ],
[27,'peau de couleur jaune',            6, '=',3 ],
[28,'peau de couleur orange',           6, '=',4 ],
[29,'peau de couleur verte',            6, '=',5 ],
[30,'peau de couleur noire',            6, '=',6 ],
[31,'peau de couleur blanche',          6, '=',7 ],
[32,'nez absent' ,                          7, '=',0 ],
[33,'nez présent' ,                         7, '>',0 ]
]
)

#----------------------------------------------------------------------------------------------
#fonctions
#----------------------------------------------------

def debut():
    print("appel def debut()")
    global etatPartie
    global listedepersonnagepourlareflexiondelordi
    message = " impossible, la partie n'est pas finie "
    if etatPartie == "fin":
        print (" le joueur cherche ")
        global quiestceki
        quiestceki=random.randint(1,24)
        print (quiestceki)
        print (listpersonnes[ quiestceki][1])

        print (" l'ordi cherche ")
        global ordichercheki
        ordichercheki=random.randint(1,24)
        print (ordichercheki)
        print (listpersonnes[ ordichercheki][1])
        listedepersonnagepourlareflexiondelordi=listpersonnes 
          
        etatPartie="encours"
        print ("etat de la partie " + etatPartie)
        message = "etat de la partie " + etatPartie
    strReponseOuiNon.set(message)
    message = "La partie commence "  
    strActionOrdi.set(message)

    print("fin def debut()")
   
def controleEtatPartie():
    print("appel def controleEtatPartie()")

    message =""
    if etatPartie == "fin":         
        message = "Au lieu de cliquer au hasard, tu devrais commencer la partie en cliquant sur Nouvelle Partie "  
    strActionOrdi.set(message)
    print("fin controleEtatPartie()")

   
def quitter():
    print("appel def quitter()")
    fenetre.destroy()
    print("fin quitter()") 

def masqueOrdi(i):
    print("appel def masqueOrdi()")
    x1= coordonnees[int(i)][0]
    y1= coordonnees[int(i)][1]
    espace_ordinateur.create_rectangle(x1,y1,x1 +largeurRectangle,y1 +hauteurRectangle,fill='red')     
    print("fin masqueOrdi()")
   
def masqueJoueur(i):
    print("appel def masqueJoueur()")
    x1= coordonnees[i][0]
    y1= coordonnees[i][1]
    espace_joueur.create_rectangle(x1,y1,x1 +largeurRectangle,y1 +hauteurRectangle,fill='blue')     
    print("fin masqueJoueur()")

     
def traiteOrdi():
    print("appel def traiteOrdi()")
    global perso
    global listedepersonnagepourlareflexiondelordi       
    perso = perso + 1
    message ='lordi refelechi .. et joue '
    strActionOrdi.set(message)
   
    print ("l'ordi reflechi pour choisir cette question ")
    maxMemoriseCi =0
    indiceMemoriseMaxCi=0
    
    for itemsQuestion in listquestionspossibles:
        if itemsQuestion[0]!= "0":
            print ("boucle sur toutes les questions ")
            itemQuestionCi=0
            indiceQuestionCi= itemsQuestion[0]
            itemQuestionFi=0
            itemQuestionVi=0 
            for itemsPersonnage in listedepersonnagepourlareflexiondelordi:
                if itemsPersonnage[0]!= "0":
                    #print ("boucle sur tous les personnages ")
                    #print ("boucle sur tous les personnages     indice de la question : ")
                    #print ( indiceQuestionCi)
                    #print ("boucle sur tous les personnages     indice du personnage : ")
                    #print (itemsPersonnage[0]) 
                    numcolonne = itemsQuestion[2]
                    #print ("numecolonne")
                    #print (numcolonne)
                    operande1=itemsPersonnage[int(numcolonne)]       
                    operande2=itemsQuestion[4]   
       
                    # analyse de la question
                    # les opérateurs possibles de la table des questions est =, >
                    # on traite les deux cas
                    #    cas 1) operateur =
                    if itemsQuestion[3]=='=':
                        #print ("   operateur = ")
                        if operande1==operande2:
                            itemQuestionVi=itemQuestionVi+1
                        else:
                            itemQuestionFi=itemQuestionFi+1   
                       
                    # cas 2) operateur >         
                    else:
                        #print ("   operateur > ")
                        if operande1>operande2:
                            itemQuestionVi=itemQuestionVi+1
                        else:
                            itemQuestionFi=itemQuestionFi+1
                    #print ("Vi/Fi")
                    #print (itemQuestionVi)
                    #print (itemQuestionFi)
            print ("fin boucle sur tous les personnages")
   
            # comparaison du score de la question avec le score memorise
            # si le score est meilleur on memorise la question
           
            itemQuestionCi=itemQuestionVi*itemQuestionFi
            print (" scrore question ")
            print (itemQuestionCi)
           
            if itemQuestionCi> maxMemoriseCi:
                maxMemoriseCi=itemQuestionCi
                indiceMemoriseMaxCi=indiceQuestionCi
                print ("meilleure question/score")
                print (indiceMemoriseMaxCi)
                print (maxMemoriseCi)
            
    print ("fin de boucle sur les question ")    
    print ("l odinateur choisit la question " + listquestionspossibles[int(indiceMemoriseMaxCi)][1])

    questionRetenue =listquestionspossibles[int(indiceMemoriseMaxCi)]
    # ordichercheki repond-il au critere de la question retenue ?
    print (listpersonnes[ ordichercheki][1])
    numcolonne = questionRetenue[2]
    operande1=listpersonnes[ ordichercheki][int(numcolonne)]       
    operande2=questionRetenue[4]
    reponse="Faux"    
    if questionRetenue[3]=='=':
        if operande1==operande2:
            print ("l animal mystere repond aux criteres de la question retenue")
            reponse="VRAI"           
    else: 
        if operande1>operande2:
            print ("l animal mystere repond aux criteres  de la question retenue")
            reponse="VRAI"
    print("lordi refelechi .. demande " + questionRetenue[1] + " la reponse est :" + reponse)
    message ="lordi refelechi .. demande " + questionRetenue[1] + " la reponse est :" + reponse
    strActionOrdi.set(message)
       
   
        
    # elimination des personnages de listedepersonnagepourlareflexiondelordi           
    for itemsPersonnage in listedepersonnagepourlareflexiondelordi:
        if itemsPersonnage[0]!= "0":
            print ("l ordi reflechi sur l animal " + itemsPersonnage[1])
            numcolonne = questionRetenue[2]
            operande1=itemsPersonnage[int(numcolonne)]       
            operande2=questionRetenue[4]
            if reponse == "VRAI":   
                if questionRetenue[3]=='=':
                    if operande1==operande2:
                        print ("l animal " + itemsPersonnage[1] + " repond aux criteres de la question retenue") 
                    else:
                        masqueOrdi(itemsPersonnage[0])
                        listedepersonnagepourlareflexiondelordi[int(itemsPersonnage[0])][0]=0                                 
                else: 
                    if operande1>operande2:
                        print ("l animal " + itemsPersonnage[1] + " repond aux criteres de la question retenue")
                    else:
                        masqueOrdi(itemsPersonnage[0])
                        listedepersonnagepourlareflexiondelordi[int(itemsPersonnage[0])][0]=0                                 
            else:
                if questionRetenue[3]=='=':
                    if operande1==operande2:
                        masqueOrdi(itemsPersonnage[0])
                        listedepersonnagepourlareflexiondelordi[int(itemsPersonnage[0])][0]=0                                 
                else: 
                    if operande1>operande2:
                        masqueOrdi(itemsPersonnage[0])
                        listedepersonnagepourlareflexiondelordi[int(itemsPersonnage[0])][0]=0                                 
   
   
    #verification de la victoire par l'ordinateur
    # si listedepersonnagepourlareflexiondelordi contient un seul animal alors l'ordi a gagne
    compteur=0
    for itemsPersonnage in listedepersonnagepourlareflexiondelordi:
        if itemsPersonnage[0]!= "0":
            compteur=compteur+1
    if compteur ==1:
        message ='lordi a gagne '
        strActionOrdi.set(message)
        etatPartie == "fin"       
    else:                                           
        message ='lordi refelechi .. et joue '
        strActionOrdi.set(message)
    print("fin traiteOrdi()")  
    
def clicdanslisteQuestion(argumentaupifpoureviteruneerreurdexecution):
    print("appel def clicdanslisteQuestion()")      
    global strQuestion
    strQuestion.set(comboChoixQuestion.get(comboChoixQuestion.curselection()))
    print (strQuestion.get())
    
    print("fin clicdanslisteQuestion()")  

def traiteJoueur():

    print("appel def traiteJoueur")      
    global strQuestion
    global etatPartie
    controleEtatPartie()
    if strQuestion.get()=='':
        reponse= 'Il faut choisir une question'       
        strReponseOuiNon.set(reponse)
    else:
        libelle= ""
        resultat="faux"
        operande1 = 0
        operande2 = 0
        operateur = '='
        indice = 0
        numcolonne = 0
        #recherche de la question dans listquestionspossibles en fonction de la selection de la combobox des questions
        #l'indice représente la question
        for items in listquestionspossibles:
            print ("evaluation " + strQuestion.get() + "<<>>"+ items[1]) 
            if strQuestion.get()==items[1]:
                indice = items[0]
                question = items


        print ("     indice de la question : " )
        print ( indice)
        print ("     question dans listquestionspossibles    " + question[1])
        print ("     operateur ||" + question[3] + '||')
        print (" colonne dans listpersonnes: => " + question[2] + " eme colonne")
        # gros probleme: Piege a la con
        # ValueError: field named 2 not found
        # python semble melanger les string et les int
        # on convertit en int et Python ne semble pas reconnaitre que c'est un int
        numcolonne = int(question[2])
     
        print ("      operande1= " + listpersonnes[quiestceki][int(numcolonne)] )
        operande1=listpersonnes[quiestceki][int(numcolonne)]       
   
        print ("      operande2= " + question[4] )
        operande2=question[4]   
   
        # analyse de la question
        # les opérateurs possibles de la table des questions est =, >
        # on traite les deux cas
        # cas 1) operateur =
        if question[3]=='=':
            print ("   operateur = ")
            if operande1==operande2:
                print ("   operateur = et reponse vaut VRAI")
                resultat="vrai"
        # cas 2) operateur >         
        if question[3]=='>':
            print ("   operateur > ")
            if operande1>operande2:
                print ("   operateur > et reponse vaut VRAI")
                resultat="vrai"

        strReponseOuiNon.set(resultat)
        print ("etatPartie "+etatPartie)    
        if etatPartie == "encours":
            traiteOrdi()
    print("fin traiteJoueur")      

                    
def clicdansliste(argumentaupifpoureviteruneerreurdexecution):
    print("appel def clicdansliste")      

    global strReponsePrenom
    strReponsePrenom.set(comboChoixPrenom.get(comboChoixPrenom.curselection()))
    print("fin clicdansliste")      


def elimine():
    global etatPartie
    controleEtatPartie()
    print("appel def elimine")      
    global perso
    if strReponsePrenom.get()=='':
        reponse= 'Il faut choisir un personnage'       
        strReponseOuiNon.set(reponse)
    else:
        i=0
        while i <= 24 :
            if listpersonnes[i][1]==strReponsePrenom.get():
                perso = i
            i = i+1
        masqueJoueur(perso)   
    print("fin elimine")      

def go():
    print("appel def go")
    global etatPartie      
    controleEtatPartie()
    print ('GO')
    if strReponsePrenom.get()=='':
        reponse= 'Il faut choisir un personnage'       
        strReponseOuiNon.set(reponse)
    else:
        print("1"+strReponsePrenom.get())
        print ("2"+listpersonnes[quiestceki][1])
        print ("3")
        print (quiestceki)
        reponse = 'NON'
        if listpersonnes[quiestceki][1]==strReponsePrenom.get():
            reponse= 'OUI BRAVO GAGNE!'
            etatPartie = "fin"       
        strReponseOuiNon.set(reponse)
    print("fin go")      
   
#----------------------------------------------------------------------------------------------------
# interface graphique
#----------------------------------------------------


fenetre=Tk()
strReponseOuiNon=StringVar()
strReponsePrenom=StringVar()
strQuestion=StringVar()
strActionOrdi=StringVar()
largeurRectangle = 80
hauteurRectangle = 110
x2=0
y2=0
i=0
quiestceki=0
ordichercheki=0
etatPartie="fin"
perso=0

#definition des cadres conteneurs
fenetre.title('Jeu : Qui est ce ?  ')
fenetre.grid_rowconfigure(0, weight=1)
fenetre.grid_columnconfigure(0, weight=1)

 ## Le canvas
cnv = Canvas(fenetre)
cnv.grid(row=0, column=0, sticky='nswe')

 ## Les scrollbars
hScroll = Scrollbar(fenetre, orient=HORIZONTAL, command=cnv.xview)
hScroll.grid(row=1, column=0, sticky='we')

vScroll = Scrollbar(fenetre, orient=VERTICAL, command=cnv.yview)
vScroll.grid(row=0, column=1, sticky='ns')

cnv.configure(xscrollcommand=hScroll.set, yscrollcommand=vScroll.set)
 ## Le Frame, dans le Canvas, mais sans pack ou grid
frm = Frame(cnv)

selection1=LabelFrame(frm)
selection1.configure(text= '',bd=2,relief='groove')
selection1.grid(row=1,column=1,padx=1,pady=1)


selection2=LabelFrame(frm)
selection2.configure(text='',bd=2,relief='groove')
selection2.grid(row=2,column=1,padx=10,pady=10,rowspan=2)
 




selection3=LabelFrame(frm)
selection3.configure(text='',bd=2,relief='groove')
selection3.grid(row=4,column=1,padx=10,pady=10,rowspan=2)
 

 

# positionnement des images
photo = PhotoImage(file ='zoo.png')
image=Label(selection1)
image.configure(text='')
image.grid(row=1,column=1,padx=1,pady=1)

espace_ordinateur = Canvas(selection1, width =550, height =450, bg='blue',bd=8,relief="ridge")
espace_ordinateur.grid(row=1 , column=0, padx =1, pady =1)
espace_ordinateur.create_image(280, 230, image =photo)


espace_joueur = Canvas(selection1, width =550, height =450, bg='red',bd=8,relief="ridge")
espace_joueur.grid(row=1 , column=2, padx =1, pady =1)
espace_joueur.create_image(280, 230, image =photo)


# positionnement des boutons et label et combobox
boutonNewGame=Button(selection2)
boutonNewGame.configure(text='Nouvelle Partie ', command=debut )
boutonNewGame.grid(row=1,column=1,padx=10,pady = 10)

comboChoixPrenom=Listbox(selection2, width =20)
for items in listePrenom:
    comboChoixPrenom.insert(END,items )
comboChoixPrenom.bind('<ButtonRelease-1>',clicdansliste)
comboChoixPrenom.grid(row=1,column=2,padx=10,pady = 10)


labelprenom=Entry(selection2)
labelprenom.configure(textvariable=strReponsePrenom)
labelprenom.grid(row=1,column=3,padx=10,pady =10)

boutonCouic=Button(selection2)
boutonCouic.configure(text='Couic', command=elimine )
boutonCouic.grid(row=1,column=4,padx=10,pady = 10)

boutonGO=Button(selection2)
boutonGO.configure(text='GO', command=go )
boutonGO.grid(row=1,column=5,padx=10,pady = 10)


comboChoixQuestion=Listbox(selection2,width =35)
for items in listquestionspossibles:
    comboChoixQuestion.insert(END,items[1] )

comboChoixQuestion.bind('<ButtonRelease-1>',clicdanslisteQuestion)
comboChoixQuestion.grid(row=1,column=6,padx=10,pady = 10)


boutonTraiteJoueur=Button(selection2)
boutonTraiteJoueur.configure(text='joueur', command=traiteJoueur )
boutonTraiteJoueur.grid(row=1,column=7,padx=10,pady = 10)

boutonQuitter=Button(selection2)
boutonQuitter.configure(text='QUITTER ', command=quitter )
boutonQuitter.grid(row=1,column=8,padx=10,pady = 10)



reponse=Label(selection3)
reponse.configure(textvariable=strReponseOuiNon,fg="red")
reponse.grid(row=1,column=2,padx=10,pady=10)

actionOrdi=Label(selection3)
actionOrdi.configure(textvariable=strActionOrdi,fg="green")
actionOrdi.grid(row=2,column=1,padx=10,pady=10)

 ## Pour etre sur que les dimensions sont calculées
frm.update()

 ## Création de la window dans le Canvas
cnv.create_window(0, 0, window=frm, anchor=NW)

 ## La scrollregion est la boite englobante pour tout ce qu'il y a dans le Canvas
cnv.configure(scrollregion=cnv.bbox(ALL))


fenetre.mainloop()
#----------------------------------------------------------------------------------------------------


1 commentaire: