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

FriFy -  
Phil_1857 Messages postés 1956 Statut Membre -
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.
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()


Quelqu'un pourrait m'aider ?>
A voir également:

7 réponses

Réponse 1 / 7
mamiemando Messages postés 34193 Date d'inscription   Statut Modérateur Dernière intervention   7 892
 
Bonjour,

Plusieurs choses :
  • N'ayant pas de lien vers tes fichiers images, on ne peut pas reproduire exactement ton cas. Si ton exemple n'est pas facilement reproductible, difficile de t'aider. Il faut soit partager un exemple minimal, soit partager tes images.
  • Au delà de ton problème, la boucle principale est incorrecte : tu utilises 
    jeu.boucle_principale()
    qui tourne en boucle. Ce n'est pas ce qu'il faut faire, je m'explique. 
    tkinter
    fournit une méthode (
    mainloop
    ) qui a l'image de ta fonction "tourne en boucle" en attente d'événements, mais contrairement à ta fonction, elle fonctionne de manière asynchrone, ce qui évite de solliciter en permanence ton CPU.
  • As-tu essayé pour mettre ta fenêtre en plein écran ce tutoriel ?


Bonne chance
0
Réponse 2 / 7
Phil_1857 Messages postés 1956 Statut Membre 168
 
Bonjour,

C'est le même problème que celui du 16 mars :
"Bug Tkinter déplacement de bouton après mise en plein écran"
non ?
0
Réponse 3 / 7
FriFy
 
Pour mamiemando :
1) Je ne peux pas mettre d'image car seuls les membres le peuvent.
2) Merci pour l'info.
3) N'est-ce pas la méthode que j'utilise ?

Pour Phil :
Oui, mais je l'ai reposté car je n'avais pas eu de réponse.
0
Réponse 4 / 7
mamiemando Messages postés 34193 Date d'inscription   Statut Modérateur Dernière intervention   7 892
 
Bonjour FriFry

1) Partage ton code sur un site genre github et donne-nous le lien. Si tu ne sais pas utiliser git, tu peux faire plus simple et uploader une archive sur un site style https://www.cjoint.com/
2-3) Non puis que tu n'utilises pas la méthode 
mainloop
.

Bonne chance
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 7
Phil_1857 Messages postés 1956 Statut Membre 168
 
Bonjour,

Oui, en fait, à la ligne 429, au lieu de: 

jeu.boucle_principale()


il faudrait: 

jeu.tk.mainloop()
0
Réponse 6 / 7
FriFy
 
Voilà le lien du fichier sur drive :
https://drive.google.com/drive/folders/13wkBSapWI1DXLN3gwMTU85i498rbPqcA?usp=sharing
0
Réponse 7 / 7
Phil_1857 Messages postés 1956 Statut Membre 168
 
Bonjour,

Tu devrais quand même remplacer la ligne : 

jeu.boucle_principale()


par : 

jeu.tk.mainloop()
0

Discussions similaires

Iptv beug
leogauthier15 -
bazfile -

1 réponse
Où est la touche SHIFT sur mon clavier d'ordi ?
joe! -
fernando-_ytb -

18 réponses
Bouton ON OFF, O ou I ?
Stargirlfr -
kaparzo23 -

12 réponses