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

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 ?>