Bug Tkinter déplacement de bouton après mise en plein écran

Fermé
FriFy -  
mamiemando Messages postés 33228 Date d'inscription   Statut Modérateur Dernière intervention   -
Bonjour,

Je suis en train de créer un jeu de plateforme où je peux mettre la fenêtre Tkinter en plein écran. Le problème est que quand je fais cela, les boutons du menu se créent en décalé par rapport à leur place habituelle. J'ai remarqué qu'en réduisant la taille du canvas, le problème disparaît. Mais pour que ce soit le cas, il faut laisser une bordure blanche de taille importante en bas de la fenêtre quand elle est en plein écran.

Quelqu'un pourrait m'aider ?

2 réponses

  1. Phil_1857 Messages postés 1883 Date d'inscription   Statut Membre Dernière intervention   169
     
    Bonjour
    oui, si tu affiches ton code ici, en utilisant les balises:
    https://codes-sources.commentcamarche.net/faq/11288-les-balises-de-code
    0
    1. FriFy
       
      Voici mon code :
      # Le projet jeufiliforme.py est un jeu de plateau mettant en scène un personnage du nom de M. Filiforme,
      # qui a pour but de courir vers la sortie.
      
      
      # Importation des modules en global
      from tkinter import *
      import time
      import pickle
      
      
      # Boucle principale, mise en place de la fenêtre
      class Jeu:
          def __init__(self):
              self.tk = Tk()
              self.tk.title("M. Filiforme court vers la sortie")
              self.tk.resizable(0, 0)
              self.tk.wm_attributes("-topmost", 1, '-fullscreen', False)
              self.plein_ecran = False
              self.canvas = Canvas(self.tk, width=500, height=500, highlightthickness=0)
              self.canvas.bind_all("<Escape>", self.changer_plein_ecran)
              self.canvas.pack()
              self.tk.update()
              self.hauteur_canvas = 500
              self.largeur_canvas = 500
              self.ap = PhotoImage(file="arriere-plan1.gif")
      
              self.lutins = []
              self.enfonction = True
              self.centre = (self.largeur_canvas / 2, self.hauteur_canvas / 2)
              self.boutons = []
      
          def menu(self):
              larg = self.ap.width()
              haut = self.ap.height()
              for x in range(0, 20):
                  for y in range(0, 11):
                      self.canvas.create_image(x * larg, y * haut, image=self.ap, anchor='nw')
              Bouton("Jouer", self.lancer_partie, self.largeur_canvas / 4, self.hauteur_canvas / 2)
              Bouton("Editer un niveau", self.editer, self.largeur_canvas * 3/4, self.hauteur_canvas / 2)
      
          def editer(self):
              pass
      
          def lancer_partie(self):
              self.enfonction = True
              detruire_boutons()
              self.lutins.clear()
              plateforme1 = PlateFormeMobile(self, PhotoImage(file="plate-forme1.gif"), \
                                             0, 480, 100, 10, 70)
              plateforme2 = LutinPlateForme(self, PhotoImage(file="plate-forme1.gif"), \
                                            150, 440, 100, 10)
              plateforme3 = LutinPlateForme(self, PhotoImage(file="plate-forme1.gif"), \
                                            300, 400, 100, 10)
              plateforme4 = LutinPlateForme(self, PhotoImage(file="plate-forme1.gif"), \
                                            300, 160, 100, 10)
              plateforme5 = LutinPlateForme(self, PhotoImage(file="plate-forme2.gif"), \
                                            175, 350, 66, 10)
              plateforme6 = PlateFormeMobile(self, PhotoImage(file="plate-forme2.gif"), \
                                             50, 300, 66, 10, 60)
              plateforme7 = LutinPlateForme(self, PhotoImage(file="plate-forme2.gif"), \
                                            170, 120, 66, 10)
              plateforme8 = LutinPlateForme(self, PhotoImage(file="plate-forme2.gif"), \
                                            45, 60, 66, 10)
              plateforme9 = LutinPlateForme(self, PhotoImage(file="plate-forme3.gif"), \
                                            170, 250, 32, 10)
              plateforme10 = LutinPlateForme(self, PhotoImage(file="plate-forme3.gif"), \
                                             230, 200, 32, 10)
              self.lutins.append(plateforme1)
              self.lutins.append(plateforme2)
              self.lutins.append(plateforme3)
              self.lutins.append(plateforme4)
              self.lutins.append(plateforme5)
              self.lutins.append(plateforme6)
              self.lutins.append(plateforme7)
              self.lutins.append(plateforme8)
              self.lutins.append(plateforme9)
              self.lutins.append(plateforme10)
              porte = LutinPorte(jeu, PhotoImage(file="porte1.gif"), 45, 30, 40, 35)
              self.lutins.append(porte)
              self.porte = porte
              personnage = LutinPersonnage(jeu)
              self.lutins.append(personnage)
              self.personnage = personnage
      
          def partie_terminee(self):
              self.porte.ouvrir()
              self.tk.update()
              time.sleep(0.5)
              self.canvas.delete(self.personnage.image)
              self.tk.update()
              time.sleep(0.5)
              self.porte.fermer()
              self.tk.update()
              time.sleep(0.5)
              self.canvas.delete(ALL)
              self.canvas.create_text(self.centre, text='Tu as gagné !', fill='blue', font=('Helvetica', 30))
              self.canvas.update()
              time.sleep(1)
              self.menu()
      
          def changer_plein_ecran(self, evt):
              self.plein_ecran = not self.plein_ecran
              if self.plein_ecran:
                  self.canvas.config(width=1920, height=1080)
                  self.tk.update()
              else:
                  self.canvas.config(width=500, height=500)
                  self.tk.update()
              # for btn in range(0, len(self.boutons)-1):
              #     self.boutons[btn].bouton.place(x=self.boutons[btn].x - self.boutons[btn].centre_larg,\
              #                             y=self.boutons[btn].y - self.boutons[btn].centre_haut)
      
          def boucle_principale(self):
              while 1:
                  if self.enfonction:
                      for lutin in self.lutins:
                          lutin.deplacer()
                  self.tk.wm_attributes('-fullscreen', self.plein_ecran)
                  self.tk.update_idletasks()
                  self.tk.update()
                  time.sleep(0.01)
      
      
      # Définition des coordonnées
      class Coords:
          def __init__(self, x1=0, y1=0, x2=0, y2=0):
              self.x1 = x1
              self.y1 = y1
              self.x2 = x2
              self.y2 = y2
      
      
      # Les fonctions suivantes vérifient s'il y a des collisions entre les lutins
      def dans_x(co1, co2):
          if (co1.x1 > co2.x1 and co1.x1 < co2.x2) \
              or (co1.x2 > co2.x1 and co1.x2 < co2.x2) \
              or (co2.x1 > co1.x1 and co2.x1 < co1.x2) \
              or (co2.x2 > co1.x1 and co2.x2 < co1.x1):
              return True
          else:
              return False
      
      
      def dans_y(co1, co2):
          if (co1.y1 > co2.y1 and co1.y1 < co2.y2) \
                 or (co1.y2 > co2.y1 and co1.y2 < co2.y2) \
                 or (co2.y1 > co1.y1 and co2.y1 < co1.y2) \
                 or (co2.y2 > co1.y1 and co2.y2 < co1.y1):
              return True
          else:
              return False
      
      
      def collision_gauche(co1, co2):
          if dans_y(co1, co2):
              if co1.x1 <= co2.x2 and co1.x1 >= co2.x1:
                  return True
          return False
      
      
      def collision_droite(co1, co2):
          if dans_y(co1, co2):
              if co1.x2 >= co2.x1 and co1.x2 <= co2.x2:
                  return True
          return False
      
      
      def collision_haut(co1, co2):
          if dans_x(co1, co2):
              if co1.y1 <= co2.y2 and co1.y1 >= co2.y1:
                  return True
          return False
      
      
      def collision_bas(y, co1, co2):
          if dans_x(co1, co2):
              y_calc = co1.y2 + y
              if y_calc >= co2.y1 and y_calc <= co2.y2:
                  return True
          return False
      
      
      def detruire_boutons():
          for num in range(0, len(jeu.boutons)):
              print(jeu.boutons[num])
              jeu.boutons[num].destroy()
          jeu.boutons.clear()
      
      
      # La classe des lutins
      class Lutin:
          def __init__(self, jeu):
              self.jeu = jeu
              self.finjeu = False
              self.coordonnees = None
      
          def deplacer(self):
              pass
      
          def coords(self):
              return self.coordonnees
      
          def suivresouris(self):
              pass
      
      
      # La classe des plateformes
      class LutinPlateForme(Lutin):
          def __init__(self, jeu, image_photo, x, y, largeur, hauteur):
              Lutin.__init__(self, jeu)
              self.image_photo = image_photo
              self.image = jeu.canvas.create_image(x, y, image=self.image_photo, anchor='nw')
              self.coordonnees = Coords(x, y, x + largeur, y + hauteur)
      
      
      class PlateFormeMobile(LutinPlateForme):
          def __init__(self, jeu, image_photo, x, y, largeur, hauteur, amplitude):
              LutinPlateForme.__init__(self, jeu, image_photo, x, y, largeur, hauteur)
              self.i1 = 0
              self.i2 = 0
              self.amplitude = amplitude
              self.sens = 0
              self.vitesse = 2
      
          def deplacer(self):
              if self.i1 < self.amplitude:
                  self.jeu.canvas.move(self.image, self.vitesse, 0)
                  self.coordonnees.x1 += self.vitesse
                  self.coordonnees.x2 += self.vitesse
                  self.i1 = self.i1 + self.vitesse
                  self.sens = self.vitesse/3
              elif self.i2 < self.amplitude:
                  self.jeu.canvas.move(self.image, -self.vitesse, 0)
                  self.coordonnees.x1 -= self.vitesse
                  self.coordonnees.x2 -= self.vitesse
                  self.i2 = self.i2 + self.vitesse
                  self.sens = -self.vitesse/3
              else:
                  self.i1 = 0
                  self.i2 = 0
      
      
      # La classe de M. Filiforme
      class LutinPersonnage(Lutin):
          def __init__(self, jeu):
              Lutin.__init__(self, jeu)
              self.images_gauche = [
                  PhotoImage(file="fil-G1.gif"),
                  PhotoImage(file="fil-G2.gif"),
                  PhotoImage(file="fil-G3.gif")
              ]
              self.images_droite = [
                  PhotoImage(file="fil-D1.gif"),
                  PhotoImage(file="fil-D2.gif"),
                  PhotoImage(file="fil-D3.gif")
              ]
              self.image = jeu.canvas.create_image(200, 470, \
                      image=self.images_gauche[0], anchor='nw')
              self.x = -2
              self.y = 0
              self.image_courante = 0
              self.ajout_image_courante = 1
              self.compte_sauts = 0
              self.derniere_heure = time.time()
              self.coordonnees = Coords()
              self.sens = 0
              jeu.canvas.bind_all('<KeyPress-Left>', self.tourner_a_gauche)
              jeu.canvas.bind_all('<KeyPress-Right>', self.tourner_a_droite)
              jeu.canvas.bind_all('<space>', self.sauter)
      
          def tourner_a_gauche(self, evt):
              if self.y == 0:
                  self.x = -2
                  self.sens = -2
      
          def tourner_a_droite(self, evt):
              if self.y == 0:
                  self.x = 2
                  self.sens = 2
      
          def sauter(self, evt):
              if self.y == 0:
                  self.y = -4
                  self.compte_sauts = 0
      
          def animer(self):
              if self.x != 0 and self.y == 0:
                  if time.time() - self.derniere_heure > 0.1:
                      self.derniere_heure = time.time()
                      self.image_courante += self.ajout_image_courante
                      if self.image_courante >= 2:
                          self.ajout_image_courante = -1
                      if self.image_courante <= 0:
                          self.ajout_image_courante = 1
              if self.x < 0:
                  if self.y != 0:
                      self.jeu.canvas.itemconfig(self.image, \
                          image=self.images_gauche[2])
                  else:
                      self.jeu.canvas.itemconfig(self.image, \
                          image=self.images_gauche[self.image_courante])
              elif self.x > 0:
                  if self.y != 0:
                      self.jeu.canvas.itemconfig(self.image, \
                          image=self.images_droite[2])
                  else:
                      self.jeu.canvas.itemconfig(self.image, \
                          image=self.images_droite[self.image_courante])
      
          def coords(self):
              xy = self.jeu.canvas.coords(self.image)
              self.coordonnees.x1 = xy[0]
              self.coordonnees.y1 = xy[1]
              self.coordonnees.x2 = xy[0] + 27
              self.coordonnees.y2 = xy[1] + 30
              return self.coordonnees
      
          def deplacer(self):
              self.animer()
              if self.y < 0:
                  self.compte_sauts += 1
                  if self.compte_sauts > 20:
                      self.y = 4
              if self.y > 0:
                  self.compte_sauts -= 1
              co = self.coords()
              gauche = True
              droite = True
              haut = True
              bas = True
              tombe = True
              if self.y > 0 and co.y2 >= self.jeu.hauteur_canvas:
                  self.y = 0
                  bas = False
              elif self.y < 0 and co.y1 <= 0:
                  self.y = 0
                  haut = False
              if self.x > 0 and co.x2 >= self.jeu.largeur_canvas:
                  self.x = 0
                  droite = False
              elif self.x < 0 and co.x1 <= 0:
                  self.x = 0
                  gauche = False
              for lutin in self.jeu.lutins:
                  if lutin == self:
                      continue
                  co_lutin = lutin.coords()
                  if haut and self.y < 0 and collision_haut(co, co_lutin):
                      self.y = -self.y
                      haut = False
                  if bas and self.y > 0 and collision_bas(self.y, co, co_lutin):
                      self.y = co_lutin.y1 - co.y2
                      if self.y < 0:
                          self.y = 0
                      bas = False
                      haut = False
                  if bas and tombe and self.y == 0 \
                          and co.y2 < self.jeu.hauteur_canvas \
                          and collision_bas(1, co, co_lutin):
                      tombe = False
                  if gauche and self.x < 0 and collision_gauche(co, co_lutin):
                      self.x = 0
                      gauche = False
                      if lutin.finjeu:
                          self.jeu.enfonction = False
                          self.jeu.partie_terminee()
                  if droite and self.x > 0 and collision_droite(co, co_lutin):
                      self.x = 0
                      droite = False
                      if lutin.finjeu:
                          self.jeu.enfonction = False
                          self.jeu.partie_terminee()
                  if droite and gauche and lutin.__class__ == PlateFormeMobile:
                      if collision_bas(self.y, co, co_lutin):
                          if self.sens == 2:
                              self.x = lutin.sens + 2
                          elif self.sens == -2:
                              self.x = lutin.sens - 2
                          else:
                              self.x = lutin.sens
                      elif tombe and self.x != 0:
                          self.x = self.sens
              if tombe and bas and self.y == 0 \
                      and co.y2 < self.jeu.hauteur_canvas:
                  self.y = 4
              self.jeu.canvas.move(self.image, self.x, self.y)
      
      
      class LutinPorte(Lutin):
          def __init__(self, jeu, image_photo, x, y, largeur, hauteur,):
              Lutin.__init__(self, jeu)
              self.image_photo = image_photo
              self.image = jeu.canvas.create_image(x, y, \
                      image=self.image_photo, anchor='nw')
              self.coordonnees = Coords(x, y, x + (largeur / 2), y + hauteur)
              self.finjeu = True
      
          def ouvrir(self):
              self.image_photo = PhotoImage(file="porte2.gif")
              self.jeu.canvas.itemconfig(self.image, image=self.image_photo)
      
          def fermer(self):
              self.image_photo = PhotoImage(file="porte1.gif")
              self.jeu.canvas.itemconfig(self.image, image=self.image_photo)
      
      
      class Bouton:
          def __init__(self, texte, commande, x, y):
              self.x = x
              self.y = y
              self.largeur_canvas = jeu.largeur_canvas
              self.hauteur_canvas = jeu.hauteur_canvas
              self.bouton = Button(jeu.tk, text=texte, command=commande, font=("Helvetica", 15))
              jeu.boutons.append(self.bouton)
              self.bouton.pack()
              print(self.bouton)
              jeu.canvas.update()
              self.largeur = self.bouton.winfo_width()
              self.hauteur = self.bouton.winfo_height()
              print(self.largeur, self.hauteur)
              self.centre_larg = self.largeur / 2
              self.centre_haut = self.hauteur / 2
              self.bouton.place(x=self.x - self.centre_larg, y=self.y - self.centre_haut)
      
      
      # Création des objets de "Jeu"
      jeu = Jeu()
      jeu.menu()
      jeu.boucle_principale()
      0
  2. FriFy
     
    Voici mon code:
    # Le projet jeufiliforme.py est un jeu de plateau mettant en scène un personnage du nom de M. Filiforme,
    # qui a pour but de courir vers la sortie.
    
    
    # Importation des modules en global
    from tkinter import *
    import time
    import pickle
    
    
    # Boucle principale, mise en place de la fenêtre
    class Jeu:
        def __init__(self):
            self.tk = Tk()
            self.tk.title("M. Filiforme court vers la sortie")
            self.tk.resizable(0, 0)
            self.tk.wm_attributes("-topmost", 1, '-fullscreen', False)
            self.plein_ecran = False
            self.canvas = Canvas(self.tk, width=500, height=500, highlightthickness=0)
            self.canvas.bind_all("<Escape>", self.changer_plein_ecran)
            self.canvas.pack()
            self.tk.update()
            self.hauteur_canvas = 500
            self.largeur_canvas = 500
            self.ap = PhotoImage(file="arriere-plan1.gif")
    
            self.lutins = []
            self.enfonction = True
            self.centre = (self.largeur_canvas / 2, self.hauteur_canvas / 2)
            self.boutons = []
    
        def menu(self):
            larg = self.ap.width()
            haut = self.ap.height()
            for x in range(0, 20):
                for y in range(0, 11):
                    self.canvas.create_image(x * larg, y * haut, image=self.ap, anchor='nw')
            Bouton("Jouer", self.lancer_partie, self.largeur_canvas / 4, self.hauteur_canvas / 2)
            Bouton("Editer un niveau", self.editer, self.largeur_canvas * 3/4, self.hauteur_canvas / 2)
    
        def editer(self):
            pass
    
        def lancer_partie(self):
            self.enfonction = True
            detruire_boutons()
            self.lutins.clear()
            plateforme1 = PlateFormeMobile(self, PhotoImage(file="plate-forme1.gif"), \
                                           0, 480, 100, 10, 70)
            plateforme2 = LutinPlateForme(self, PhotoImage(file="plate-forme1.gif"), \
                                          150, 440, 100, 10)
            plateforme3 = LutinPlateForme(self, PhotoImage(file="plate-forme1.gif"), \
                                          300, 400, 100, 10)
            plateforme4 = LutinPlateForme(self, PhotoImage(file="plate-forme1.gif"), \
                                          300, 160, 100, 10)
            plateforme5 = LutinPlateForme(self, PhotoImage(file="plate-forme2.gif"), \
                                          175, 350, 66, 10)
            plateforme6 = PlateFormeMobile(self, PhotoImage(file="plate-forme2.gif"), \
                                           50, 300, 66, 10, 60)
            plateforme7 = LutinPlateForme(self, PhotoImage(file="plate-forme2.gif"), \
                                          170, 120, 66, 10)
            plateforme8 = LutinPlateForme(self, PhotoImage(file="plate-forme2.gif"), \
                                          45, 60, 66, 10)
            plateforme9 = LutinPlateForme(self, PhotoImage(file="plate-forme3.gif"), \
                                          170, 250, 32, 10)
            plateforme10 = LutinPlateForme(self, PhotoImage(file="plate-forme3.gif"), \
                                           230, 200, 32, 10)
            self.lutins.append(plateforme1)
            self.lutins.append(plateforme2)
            self.lutins.append(plateforme3)
            self.lutins.append(plateforme4)
            self.lutins.append(plateforme5)
            self.lutins.append(plateforme6)
            self.lutins.append(plateforme7)
            self.lutins.append(plateforme8)
            self.lutins.append(plateforme9)
            self.lutins.append(plateforme10)
            porte = LutinPorte(jeu, PhotoImage(file="porte1.gif"), 45, 30, 40, 35)
            self.lutins.append(porte)
            self.porte = porte
            personnage = LutinPersonnage(jeu)
            self.lutins.append(personnage)
            self.personnage = personnage
    
        def partie_terminee(self):
            self.porte.ouvrir()
            self.tk.update()
            time.sleep(0.5)
            self.canvas.delete(self.personnage.image)
            self.tk.update()
            time.sleep(0.5)
            self.porte.fermer()
            self.tk.update()
            time.sleep(0.5)
            self.canvas.delete(ALL)
            self.canvas.create_text(self.centre, text='Tu as gagné !', fill='blue', font=('Helvetica', 30))
            self.canvas.update()
            time.sleep(1)
            self.menu()
    
        def changer_plein_ecran(self, evt):
            self.plein_ecran = not self.plein_ecran
            if self.plein_ecran:
                self.canvas.config(width=1920, height=1080)
                self.tk.update()
            else:
                self.canvas.config(width=500, height=500)
                self.tk.update()
            # for btn in range(0, len(self.boutons)-1):
            #     self.boutons[btn].bouton.place(x=self.boutons[btn].x - self.boutons[btn].centre_larg,\
            #                             y=self.boutons[btn].y - self.boutons[btn].centre_haut)
    
        def boucle_principale(self):
            while 1:
                if self.enfonction:
                    for lutin in self.lutins:
                        lutin.deplacer()
                self.tk.wm_attributes('-fullscreen', self.plein_ecran)
                self.tk.update_idletasks()
                self.tk.update()
                time.sleep(0.01)
    
    
    # Définition des coordonnées
    class Coords:
        def __init__(self, x1=0, y1=0, x2=0, y2=0):
            self.x1 = x1
            self.y1 = y1
            self.x2 = x2
            self.y2 = y2
    
    
    # Les fonctions suivantes vérifient s'il y a des collisions entre les lutins
    def dans_x(co1, co2):
        if (co1.x1 > co2.x1 and co1.x1 < co2.x2) \
            or (co1.x2 > co2.x1 and co1.x2 < co2.x2) \
            or (co2.x1 > co1.x1 and co2.x1 < co1.x2) \
            or (co2.x2 > co1.x1 and co2.x2 < co1.x1):
            return True
        else:
            return False
    
    
    def dans_y(co1, co2):
        if (co1.y1 > co2.y1 and co1.y1 < co2.y2) \
               or (co1.y2 > co2.y1 and co1.y2 < co2.y2) \
               or (co2.y1 > co1.y1 and co2.y1 < co1.y2) \
               or (co2.y2 > co1.y1 and co2.y2 < co1.y1):
            return True
        else:
            return False
    
    
    def collision_gauche(co1, co2):
        if dans_y(co1, co2):
            if co1.x1 <= co2.x2 and co1.x1 >= co2.x1:
                return True
        return False
    
    
    def collision_droite(co1, co2):
        if dans_y(co1, co2):
            if co1.x2 >= co2.x1 and co1.x2 <= co2.x2:
                return True
        return False
    
    
    def collision_haut(co1, co2):
        if dans_x(co1, co2):
            if co1.y1 <= co2.y2 and co1.y1 >= co2.y1:
                return True
        return False
    
    
    def collision_bas(y, co1, co2):
        if dans_x(co1, co2):
            y_calc = co1.y2 + y
            if y_calc >= co2.y1 and y_calc <= co2.y2:
                return True
        return False
    
    
    def detruire_boutons():
        for num in range(0, len(jeu.boutons)):
            print(jeu.boutons[num])
            jeu.boutons[num].destroy()
        jeu.boutons.clear()
    
    
    # La classe des lutins
    class Lutin:
        def __init__(self, jeu):
            self.jeu = jeu
            self.finjeu = False
            self.coordonnees = None
    
        def deplacer(self):
            pass
    
        def coords(self):
            return self.coordonnees
    
        def suivresouris(self):
            pass
    
    
    # La classe des plateformes
    class LutinPlateForme(Lutin):
        def __init__(self, jeu, image_photo, x, y, largeur, hauteur):
            Lutin.__init__(self, jeu)
            self.image_photo = image_photo
            self.image = jeu.canvas.create_image(x, y, image=self.image_photo, anchor='nw')
            self.coordonnees = Coords(x, y, x + largeur, y + hauteur)
    
    
    class PlateFormeMobile(LutinPlateForme):
        def __init__(self, jeu, image_photo, x, y, largeur, hauteur, amplitude):
            LutinPlateForme.__init__(self, jeu, image_photo, x, y, largeur, hauteur)
            self.i1 = 0
            self.i2 = 0
            self.amplitude = amplitude
            self.sens = 0
            self.vitesse = 2
    
        def deplacer(self):
            if self.i1 < self.amplitude:
                self.jeu.canvas.move(self.image, self.vitesse, 0)
                self.coordonnees.x1 += self.vitesse
                self.coordonnees.x2 += self.vitesse
                self.i1 = self.i1 + self.vitesse
                self.sens = self.vitesse/3
            elif self.i2 < self.amplitude:
                self.jeu.canvas.move(self.image, -self.vitesse, 0)
                self.coordonnees.x1 -= self.vitesse
                self.coordonnees.x2 -= self.vitesse
                self.i2 = self.i2 + self.vitesse
                self.sens = -self.vitesse/3
            else:
                self.i1 = 0
                self.i2 = 0
    
    
    # La classe de M. Filiforme
    class LutinPersonnage(Lutin):
        def __init__(self, jeu):
            Lutin.__init__(self, jeu)
            self.images_gauche = [
                PhotoImage(file="fil-G1.gif"),
                PhotoImage(file="fil-G2.gif"),
                PhotoImage(file="fil-G3.gif")
            ]
            self.images_droite = [
                PhotoImage(file="fil-D1.gif"),
                PhotoImage(file="fil-D2.gif"),
                PhotoImage(file="fil-D3.gif")
            ]
            self.image = jeu.canvas.create_image(200, 470, \
                    image=self.images_gauche[0], anchor='nw')
            self.x = -2
            self.y = 0
            self.image_courante = 0
            self.ajout_image_courante = 1
            self.compte_sauts = 0
            self.derniere_heure = time.time()
            self.coordonnees = Coords()
            self.sens = 0
            jeu.canvas.bind_all('<KeyPress-Left>', self.tourner_a_gauche)
            jeu.canvas.bind_all('<KeyPress-Right>', self.tourner_a_droite)
            jeu.canvas.bind_all('<space>', self.sauter)
    
        def tourner_a_gauche(self, evt):
            if self.y == 0:
                self.x = -2
                self.sens = -2
    
        def tourner_a_droite(self, evt):
            if self.y == 0:
                self.x = 2
                self.sens = 2
    
        def sauter(self, evt):
            if self.y == 0:
                self.y = -4
                self.compte_sauts = 0
    
        def animer(self):
            if self.x != 0 and self.y == 0:
                if time.time() - self.derniere_heure > 0.1:
                    self.derniere_heure = time.time()
                    self.image_courante += self.ajout_image_courante
                    if self.image_courante >= 2:
                        self.ajout_image_courante = -1
                    if self.image_courante <= 0:
                        self.ajout_image_courante = 1
            if self.x < 0:
                if self.y != 0:
                    self.jeu.canvas.itemconfig(self.image, \
                        image=self.images_gauche[2])
                else:
                    self.jeu.canvas.itemconfig(self.image, \
                        image=self.images_gauche[self.image_courante])
            elif self.x > 0:
                if self.y != 0:
                    self.jeu.canvas.itemconfig(self.image, \
                        image=self.images_droite[2])
                else:
                    self.jeu.canvas.itemconfig(self.image, \
                        image=self.images_droite[self.image_courante])
    
        def coords(self):
            xy = self.jeu.canvas.coords(self.image)
            self.coordonnees.x1 = xy[0]
            self.coordonnees.y1 = xy[1]
            self.coordonnees.x2 = xy[0] + 27
            self.coordonnees.y2 = xy[1] + 30
            return self.coordonnees
    
        def deplacer(self):
            self.animer()
            if self.y < 0:
                self.compte_sauts += 1
                if self.compte_sauts > 20:
                    self.y = 4
            if self.y > 0:
                self.compte_sauts -= 1
            co = self.coords()
            gauche = True
            droite = True
            haut = True
            bas = True
            tombe = True
            if self.y > 0 and co.y2 >= self.jeu.hauteur_canvas:
                self.y = 0
                bas = False
            elif self.y < 0 and co.y1 <= 0:
                self.y = 0
                haut = False
            if self.x > 0 and co.x2 >= self.jeu.largeur_canvas:
                self.x = 0
                droite = False
            elif self.x < 0 and co.x1 <= 0:
                self.x = 0
                gauche = False
            for lutin in self.jeu.lutins:
                if lutin == self:
                    continue
                co_lutin = lutin.coords()
                if haut and self.y < 0 and collision_haut(co, co_lutin):
                    self.y = -self.y
                    haut = False
                if bas and self.y > 0 and collision_bas(self.y, co, co_lutin):
                    self.y = co_lutin.y1 - co.y2
                    if self.y < 0:
                        self.y = 0
                    bas = False
                    haut = False
                if bas and tombe and self.y == 0 \
                        and co.y2 < self.jeu.hauteur_canvas \
                        and collision_bas(1, co, co_lutin):
                    tombe = False
                if gauche and self.x < 0 and collision_gauche(co, co_lutin):
                    self.x = 0
                    gauche = False
                    if lutin.finjeu:
                        self.jeu.enfonction = False
                        self.jeu.partie_terminee()
                if droite and self.x > 0 and collision_droite(co, co_lutin):
                    self.x = 0
                    droite = False
                    if lutin.finjeu:
                        self.jeu.enfonction = False
                        self.jeu.partie_terminee()
                if droite and gauche and lutin.__class__ == PlateFormeMobile:
                    if collision_bas(self.y, co, co_lutin):
                        if self.sens == 2:
                            self.x = lutin.sens + 2
                        elif self.sens == -2:
                            self.x = lutin.sens - 2
                        else:
                            self.x = lutin.sens
                    elif tombe and self.x != 0:
                        self.x = self.sens
            if tombe and bas and self.y == 0 \
                    and co.y2 < self.jeu.hauteur_canvas:
                self.y = 4
            self.jeu.canvas.move(self.image, self.x, self.y)
    
    
    class LutinPorte(Lutin):
        def __init__(self, jeu, image_photo, x, y, largeur, hauteur,):
            Lutin.__init__(self, jeu)
            self.image_photo = image_photo
            self.image = jeu.canvas.create_image(x, y, \
                    image=self.image_photo, anchor='nw')
            self.coordonnees = Coords(x, y, x + (largeur / 2), y + hauteur)
            self.finjeu = True
    
        def ouvrir(self):
            self.image_photo = PhotoImage(file="porte2.gif")
            self.jeu.canvas.itemconfig(self.image, image=self.image_photo)
    
        def fermer(self):
            self.image_photo = PhotoImage(file="porte1.gif")
            self.jeu.canvas.itemconfig(self.image, image=self.image_photo)
    
    
    class Bouton:
        def __init__(self, texte, commande, x, y):
            self.x = x
            self.y = y
            self.largeur_canvas = jeu.largeur_canvas
            self.hauteur_canvas = jeu.hauteur_canvas
            self.bouton = Button(jeu.tk, text=texte, command=commande, font=("Helvetica", 15))
            jeu.boutons.append(self.bouton)
            self.bouton.pack()
            print(self.bouton)
            jeu.canvas.update()
            self.largeur = self.bouton.winfo_width()
            self.hauteur = self.bouton.winfo_height()
            print(self.largeur, self.hauteur)
            self.centre_larg = self.largeur / 2
            self.centre_haut = self.hauteur / 2
            self.bouton.place(x=self.x - self.centre_larg, y=self.y - self.centre_haut)
    
    
    # Création des objets de "Jeu"
    jeu = Jeu()
    jeu.menu()
    jeu.boucle_principale()
    0
    1. mamiemando Messages postés 33228 Date d'inscription   Statut Modérateur Dernière intervention   7 944
       
      Bonjour,

      Afin d'éviter que les discussions se croisent, merci de continuer dans le nouveau fil de discussion.
      0