Salut !

Je me suis donner comme objectif de réussir à reprogrammer en python toutes les énigmes du jour du dernier jeu Layton.

Je suis à la 2eme et là j'ai un problème surement un peu bête.Pour ne pas m'embêter à coder les niveaux , je crée un éditeur(Pour démarrer l'éditeur il faut appuyer sur controle).

Voici le code en question :

#Enigme Layton n°2
from EnigmeAffichage import *
from tkinter import *
from math import *


class Enigme2():
    """Classe de Enigme2 :
       Pour gagner Encadrer le chiffre avec le bon chiffre de case.   
    """
    def __init__(self):
        "Création du niveaux"
        #Variables
        AffichageE.__init__(self,400,0,5,'#926D27','#DE9816',0,1)
        self.chiffreOk = 0
        self.CaseOqp = []                      #Cases qui seront prises.
        self.ListChiffre = []                  #Lettre qui aura dans le cadre
        self.levelMatrice = [2,0,2,0,0,        #Matrice qui sert à placer les chiffres
                             2,0,2,0,0,
                             2,0,2,0,0,
                             2,0,2,0,0,
                             2,0,2,0,5]
        self.codeCouleur = {2:"#77B5FE",       #Couleur associer au chiffre
                            3:"#F7230C",
                            4:"#57D53B",
                            5:"#708D23",
                            6:"#FEA347",
                            7:"#723E64",
                            8:"#800080",
                            9:"#DB1702"}
        #Placement des chiffres
        for i in range(len(self.levelMatrice)):
            if self.levelMatrice[i] :
              x , y = self.ListCase[i]
              self.Can.create_rectangle(x,y,x+self.NbCase,y+self.NbCase,outline ="#DE9816"
                                        ,fill= self.codeCouleur[self.levelMatrice[i]],width =3)
              self.ListChiffre.append(self.Can.create_text(x+self.NbCase/2,y+self.NbCase/2,
                                   text=self.levelMatrice[i],font=("default",50,"bold")))
        self.Can.bind("<Button-1>",self.PlaceCadre)
        self.fen.bind("<Control_L>",self.Editeur)
        self.fen.mainloop()

    def Editeur(self,event):
        EditeurEnigme2()     


    def PlaceCadre(self,event):
        "Création du cadre"
        #On verifie si on ne clique pas sur un cadre existant
        for i in self.CaseOqp :
            if i[0][0]<event.x<i[0][2] and  i[0][1]<event.y<i[0][3] :
                self.Can.delete(i[1])
                eff1 = self.CaseOqp.index(i)
                self.chiffreOk -= 1
                del self.CaseOqp[eff1]             
                return
        #On place le cadre en fonction de l'endroit du clic.
        for i in self.ListCase :
            if i[0]<event.x<i[0]+self.NbCase :
                if i[1]<event.y<i[1]+self.NbCase :
                    self.chk = 0
                    self.CadreOn = self.Can.create_rectangle(i[0],i[1],i[0]+self.NbCase,i[1]+self.NbCase,outline = "yellow",width = 3)
                    self.CoordOn = self.Can.coords(self.CadreOn)
                    self.Can.bind("<B1-Motion>",self.DelpCadre)
                    self.Can.bind("<ButtonRelease-1>",self.ChkCadre)
        
    def DelpCadre(self,event):
        "Cette fonction permet de modifier le cadre et de changer sa couleur en fonction des règles"
        #Modification du cadre
        if 0<event.x<self.taille and 0<event.y<self.taille :
            if event.x < self.CoordOn[0]:
                x1 = floor(event.x/self.NbCase) * self.NbCase
            else:
                x1 = self.CoordOn[0]
            if event.y <= self.CoordOn[1]:
                y1 = floor(event.y/self.NbCase) *  self.NbCase
            else:
                y1 = self.CoordOn[1]
            if event.x >= self.CoordOn[2]:
                x2 = ceil(event.x/self.NbCase) * self.NbCase 
            else:
                x2 = self.CoordOn[2]
            if event.y >= self.CoordOn[3]:
                y2 = ceil(event.y/self.NbCase) * self.NbCase 
            else:
                y2 = self.CoordOn[3]
        else :
            return
        #Verification du cadre
        C = 0
        self.chk = 0
        self.Coords = self.Can.coords(self.CadreOn)
        CParLigne = abs(self.Coords[0]-self.Coords[2])/ self.NbCase
        CParCollone = abs(self.Coords[1]-self.Coords[3])/ self.NbCase
        #On verifie si il y a plus d'un nombre dans le cadre
        for y in range(int(CParCollone)):
            for x in range(int(CParLigne)):
                x0 , y0 = self.Coords[0] , self.Coords[1]
                ind = self.ListCase.index([x0+x*self.NbCase,y0+y*self.NbCase])
                if self.levelMatrice[ind] :
                    C += 1
                    self.nbre = self.levelMatrice[ind]
                if C > 1:
                    break
            if C > 1:
                #Si oui on met le contour en rouge
                self.Can.itemconfig(self.CadreOn,outline ="red")
                break
        else :
            #Si non il est en jaune
            self.Can.itemconfig(self.CadreOn,outline ="Yellow")
            #On verifie si deux cadres ce surperposent 
            for i in self.CaseOqp:
                if i[0][0]<event.x<i[0][2] and i[0][1]<event.y<i[0][3] :
                    #Si oui on met le contour en rouge
                    self.Can.itemconfig(self.CadreOn,outline ="red")
                    self.chk , C = 0 , 0
            #On verifie si le chiffre correspond au mesure du cadre
            if C and abs(self.Coords[0] - self.Coords[2])*abs(self.Coords[1] - self.Coords[3])/self.NbCase**2 == self.nbre:
                #Si oui le contour est vert
                self.Can.itemconfig(self.CadreOn,outline ="green")
                self.chk = 1
        self.Can.coords(self.CadreOn,x1,y1,x2,y2)
        

    def ChkCadre(self,event):
        "Cette fonction permet de savoir si les mesures du cadres correspond à la valeur du chiffre"
        #Si la cadre correspond
        if self.chk :
            self.chk = 0             
            self.chiffreOk += 1
            Cadre = self.CadreOn
            self.CaseOqp.append([self.Coords,Cadre])
            #on remplie le cadre de la couleur du chiffre
            self.Can.itemconfig(self.CadreOn,fill =self.codeCouleur[self.nbre])
            for i in self.ListChiffre :
                #On remet le chiffre au premier plan
                self.Can.tag_raise(i)
        else :
            #Sinon on détruit le cadre
            self.Can.delete(self.CadreOn)
        self.Can.unbind("<B1-Motion>")
        self.Can.unbind("<ButtonRelease-1>")
        #Si tous les chiffres ont leurs cadres
        if self.chiffreOk == len(self.ListChiffre) :
            self.Text.set("Gagner")



class EditeurEnigme2(Enigme2):
    """docstring for EditeurEnigme2"""
    def __init__(self):
        AffichageE.__init__(self,400,0,5,'#926D27','#DE9816',0,1,1)
        #Variable
        self.chiffreOk = 0
        self.Perimetre = self.taille**2
        self.preListChiffre = []
        self.ListChiffre = []
        self.CaseOqp = []
        self.listPossibilite = [0,2,3,4,5,6,7,8,9]
        self.levelMatrice = [0]*self.div**2
        self.nombreCase = []
        self.codeCouleur = {2:"#77B5FE",
                            3:"#F7230C",
                            4:"#57D53B",
                            5:"#708D23",
                            6:"#FEA347",
                            7:"#723E64",
                            8:"#800080",
                            9:"#DB1702"}
        self.Grille["command"] = self.ModifGrille
        self.Grille["from_"] = 4
        self.menu.entryconfig("Reset",command =self.Reset)
        self.menu.entryconfig("Niveaux",command =self.Placer)
        self.menu.entryconfig("Verifier",command =self.VerifLevel)
        self.fen.mainloop()

    def Reset(self):
        "Cette fonction permet de revenir de réinitialiser l'éditeur"
        self.Can.delete(ALL)
        self.div = 5
        self.NbCase = self.taille/self.div
        self.levelMatrice = [0]*self.div**2
        self.ListCase = []
        for i in range(self.div+1):
            self.Can.create_line(i*self.NbCase+self.bord,0,i*self.NbCase+self.bord,self.taille+self.bord,fill =self.colQuad,width=3)
            self.Can.create_line(0,i*self.NbCase+self.bord,self.taille+self.bord,i*self.NbCase+self.bord,fill =self.colQuad,width=3)
        #Sauvegarde des cases
        for y in range(self.div):
            for x in range(self.div):
                self.ListCase.append([x*self.NbCase,
                                      y*self.NbCase])
        self.Grille.set(5)
        self.Grille["state"] = "normal"
        self.menu.entryconfig("Niveaux", state="normal")

    
        
    def ModifGrille(self,val):
        "Cette fonction permet de modifier le nombre de case"
        self.Can.delete(ALL)
        self.div = int(val)                         
        self.NbCase = self.taille/self.div
        self.preListChiffre = []
        self.levelMatrice = [0]*self.div**2
        self.ListCase = [] 
        for i in range(self.div+1):
            self.Can.create_line(i*self.NbCase+self.bord,0,i*self.NbCase+self.bord,self.taille+self.bord,fill =self.colQuad,width=3)
            self.Can.create_line(0,i*self.NbCase+self.bord,self.taille+self.bord,i*self.NbCase+self.bord,fill =self.colQuad,width=3)
        #Sauvegarde des cases
        for y in range(self.div):
            for x in range(self.div):
                self.ListCase.append([x*self.NbCase,
                                      y*self.NbCase])

    def Placer(self):
        self.Grille["state"] = "disabled"
        self.menu.entryconfig("Niveaux", state="disabled")
        self.menu.entryconfig("Verifier",state ="normal")
        self.Can.bind("<Button-1>",self.PlaceNombre)

    def PlaceNombre(self,event):
        "Cette fonction permet de changer le nombre afficher sur une case ou de l'enlever"
        # On cherche les coordonnées du clic
        for i in range(len(self.ListCase)) :
            if self.ListCase[i][0]<event.x<self.ListCase[i][0]+self.NbCase \
            and self.ListCase[i][1]<event.y<self.ListCase[i][1]+self.NbCase:
               X = self.ListCase[i][0]
               Y = self.ListCase[i][1]
               break
        # On chercher sa place dans la matrice du niveau
        indice = self.levelMatrice[i]                            #On regarde le nombre actuel sur la matrice à cette position                              
        index = self.listPossibilite.index(indice) + 1           #On prend le suivant
        if index == len(self.listPossibilite) :                  #Si on arrive à la fin des chiffres posssible on met index à 0               
            index = 0
        self.levelMatrice[i] = self.listPossibilite[index]
        if index :
            case = self.Can.create_rectangle(X,Y,X+self.NbCase,Y+self.NbCase,outline ="#DE9816"
                                   ,fill= self.codeCouleur[self.levelMatrice[i]],width =3)
            Lettre = self.Can.create_text(X+self.NbCase/2,Y+self.NbCase/2,
                                   text=self.levelMatrice[i],font=("default",50,"bold"))
        for n in self.preListChiffre :
            if n[2] == i :
                eff1 = self.preListChiffre.index(n)
                self.Can.delete(n[0])
                self.Can.delete(n[1])
                del self.preListChiffre[eff1]
                break
        if index :
            self.preListChiffre.append((case,Lettre,i))

    def VerifLevel(self):
        self.menu.entryconfig("Verifier", state="disabled")
        self.Can.unbind("<Button-1>")
        self.Can.bind("<Button-1>",self.PlaceCadre)
        for i in self.preListChiffre :
            self.ListChiffre.append(i[1])




        
        

if __name__== "__main__":
    a = Enigme2()

Desoler pour les commentaires , j'essaie de prendre l'habitude d'en faire donc ils peuvent ne pas être clair.

 l'autre code sert à faire l'interface du jeux de façon générale . j'en ai fait un classe car que pense que sur la constrution , les autres enigmes seront sûrement identiques.

Voici le code :

from tkinter import *

class AffichageE():
	"""Cette classe servira d'affichage à toutes les enigmes"""
	def __init__(self,taille,bord,div,colFond,colQuad,button=None,label=None,editeur =None):
		"affichage"
		#VARIABLE
		self.taille = taille                   #longueur et largueur du canvas
		self.bord = bord
		self.div = div                         #Nombre de case par ligne/colonne
		self.NbCase = self.taille/self.div     
		self.ListCase = []                     #Contiendra toutes les cases du quadrillage
		self.fen = Tk()
		self.colFond = colFond
		self.colQuad = colQuad
		self.Can = Canvas(self.fen,width= self.taille+1, height= self.taille+1,
                         background= self.colFond,highlightthickness= 0,bd =self.bord,relief =RIDGE)
		#Création du quadrillage
		for i in range(self.div+1):
			self.Can.create_line(i*self.NbCase+self.bord,0,i*self.NbCase+self.bord,self.taille+self.bord,fill =self.colQuad,width=3)
			self.Can.create_line(0,i*self.NbCase+self.bord,self.taille+self.bord,i*self.NbCase+self.bord,fill =self.colQuad,width=3)
		#Sauvegarde des cases
		for y in range(self.div):
			for x in range(self.div):
				self.ListCase.append([x*self.NbCase,
                                      y*self.NbCase])
		self.Can.grid(row =0,rowspan =5,column=0,columnspan=2)
		if button and label :
			self.Text = StringVar()
			self.Text.set('-------------')
			self.button = Button(self.fen,text = "Validez",height =3)
			self.label = Label(self.fen,bg ="#F7E269",textvariable =self.Text)
			self.button.grid(row =6,column=0 ,sticky = W+E)
			self.label.grid(row =6, column=1, sticky =W+E+N+S)
		elif button :
			self.button = Button(self.fen,text = "Validez",height =3)
			self.button.grid(row =6,column=0,columnspan =2,sticky = W+E)
		elif label :
			self.Text = StringVar()
			self.Text.set('--------------------------')
			self.label = Label(self.fen,height =3,bg ="#F7E269",fg ="#6C0277",textvariable =self.Text)
			self.label.grid(row =6, column=0,columnspan =2, sticky =W+E+N+S)
		if editeur :
			#Création des menus
			self.menu = Menu(self.fen)
			self.menu.add_command(label="Niveaux")
			self.menu.add_command(label="Verifier",state="disabled")
			self.menu.add_command(label="Ajouter",state="disabled")
			self.menu.add_command(label="Reset")
			self.fen.config(menu =self.menu)
			self.Grille = Scale(self.fen, length=350, orient=VERTICAL, sliderlength =25,
              from_=1, to=15, tickinterval =1,
              showvalue =0 )
			self.Grille.set(5)
			self.Grille.grid(row=0,rowspan=7,column=3)

Le problème étant que le label de l'éditeur n'affiche rien et je vois pas d'où viens le problème .

Donc si quelqu'un pourrait m'aider la-dessus.

-
Edité par chatoxchimix 22 mai 2018 à 8:29:54

Salut

Si je suis bien le cheminement du programme, j'ai :

ligne 266, construction de l'objet a
de la classe Enigme2() (ligne 7)

cette classe hérite d'AffichageE du
deuxième code, je ne vois pas écrit :
classEnigme2(AffichageE)

ligne 14, si j'ai bien compter, le
paramètre label a 1 comme argument
(tip : je pense que button et label
sont des booléens, mets plutôt True
à la place de 1, et False à la place de 0)

dans tes codes, button est 0 label
est 1, on va (il doit y avoir des
étapes avant) à la ligne 38 du
deuxième code qui est vraie (elif label:)

Ce que je ferai est de mettre des print, dans la condition ligne 38, puis dans le constructeur d'AffichageE, puis dans celui d'Enigme2.

AffichageE prend 8 paramètres, tu n'en as mis que 7 dans Enigme2, mais, avec les arguments à None, peut-être que ce que je te dis n'es pas utile.

-
Edité par Le Cobriste 128 22 mai 2018 à 19:24:36

merci pour ton aide j'ai vu d'où venait l'erreur . il fallait mettre :

Text = StringVar(fenêtre)
#au lieu de 
Text = StringVar()

J'avais mis AffichageE de base mais je l'ai enlever car je constatais aucun changement , sinon je pense le modifier en mettant les argument label , button et editeur en fonction de la classe AffichageE.

-
Edité par chatoxchimix 22 mai 2018 à 19:33:11