Hébergeur de fichiers indépendant

les premiers pas d une souris intelligente.py

À propos

Type de fichier
Fichier PY de 26 Ko (text/x-python)
Confidentialité
Fichier public, envoyé le 27 février 2016 à 14:57, depuis l'adresse IP 88.160.x.x (France)
Sécurité
Ne contient aucun Virus ou Malware connus - Dernière vérification: 2 jours
Statistiques
La présente page de téléchargement a été vue 264 fois depuis l'envoi du fichier
Page de téléchargement

Aperçu du fichier


# ------------------------      Importation        ------------------------ #

from time import *
from tkinter import *
from random import *

# ------------------------      Déclaration        ------------------------ #

x = 20              # Indique la position x initiale du premier carré
y = 20              # Indique la position y initiale du premier carré
r = 10              # Le rayon des carrés (éviter de le modifier)
Nmbrx = 30          # Définit en nombre de carré la Largeur de la box
Nmbry = 20          # Définit en nombre de carré la Hauteur de la box
xSave = 20          # Indique la position x initiale du Sauveteur
ySave = 20          # Indique la position y initiale du sauveteur
IDSauveteur = ""    # C'est une chaîne de caractère qui va recevoir la valeur de l'ID du sauveteur
xPoint = xSave      # La position du pointeur en x
yPoint = ySave      # La position du pointeur en y
deplacement = []    # Créer une liste qui enregistrera tous les déplacements éfféctués par la souris
num = 0             # un compteur afin de se retrouver dans la liste il fonctionne de pair avec "ineg"
ineg = 0            # ---
RETURN = 0          # Cette variable est un interrupteur, elle nous permettra de savoir quand le sauveteur devra faire marche arrière.
ISSUE = 1           # Quand cette variable sera égale à 0 il n'y aura plus d'issus.
CREATE = FALSE      # Cet interrupteur permet d'activé le placement de "way"
PUTFINISH = FALSE   # Cet interrupteur permet d'activé le placement de "finish"
FINISH = FALSE      # Cet interrupteur permet de savoir si le sauveteur a trouvé la case finale.



# ------------------------      Fonctions        ------------------------ #
# ----------------------------------------------- #
"""Cette fonction va permettre de générer tous les murs et de placer le sauveteur à son emplacement initial."""
def Generer():
    
    """ Va Génerer la salle """
    global x , y , Largeur , Hauteur, item, r, IDSauveteur,xSave,ySave, FINISH, ISSUE, num, ineg, deplacement
    num = 0
    ineg = 0
    deplacement = [6]
    print ("GRZDAZEZZZADZ:" , deplacement)
    FINISH = 0
    ISSUE = 1
    Canevas.delete(ALL)
    xSave = 20 # Indique la position x initiale du Sauveteur
    ySave = 20 # Indique la position y initiale du sauveteur
    #Cette conndition permet de remplir le tableau
    while x <= Largeur-2 * r and y<= Hauteur-2 * r:
        # Va crer un rectangle au niveau du curseur.
        item = Canevas.create_rectangle(x-r, y-r, x+r, y+r, outline='black', fill= "#00DD00" )
        if (x < Largeur - 2 * r):       # Fait les retours à la ligne si nécessaires
            x = x + 2 * r
            y = y
        
        else:
            x = 2 * r
            y = y + 2 * r        
    print("Création de",item,"rectangles")
    x = 2 * r
    y = 2 * r
    Canevas.addtag_all ("wall")
    """------------------------Placer Le sauveteur-----------------------------"""
    #Formation
    """ Va placer le sauveteur"""
    
    Canevas.create_rectangle(xSave-r, ySave-r, xSave+r, ySave+r, outline='black', fill= "#FF0000" ) # Va placer le rectangle par rapport aux positions initiales
    IDSauveteur = Canevas.find_closest (xSave,ySave , halo = None, start = None)                    # Va récupérer L'id du sauveteur.
    
    IDSauveteur = str(IDSauveteur)[1:len(str(IDSauveteur))-2]                                       # Permet de retourner l'ID du sauveteur sans les parenthèse et sans la virgule 
    print (IDSauveteur)
    Canevas.addtag_withtag ("sauveteur", IDSauveteur)

# ----------------------------------------------- #
"""Cette fonction va renvoyé les TAGS des cases ,haut, droite, bas et gauche, du sauveteur"""
def Check():
    global IDSauveteur , xSave, ySave,r, TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft

    CaseTop = Canevas.find_closest (xSave, ySave - 2 * r, halo = None, start = None) 
    CaseTop = str(CaseTop)[1:len(str(CaseTop))-2]
    TAGCaseTop = Canevas.gettags (CaseTop)
    print ("Le Tag de la caseTOP est :" , TAGCaseTop)

    CaseBot = Canevas.find_closest (xSave, ySave + 2*r , halo = None, start = None) 
    CaseBot = str(CaseBot)[1:len(str(CaseBot))-2]
    TAGCaseBot = Canevas.gettags (CaseBot)
    print ("Le Tag de la caseBOT est :" , TAGCaseBot)

    CaseRight = Canevas.find_closest (xSave + 2 * r, ySave, halo = None, start = None) 
    CaseRight = str(CaseRight)[1:len(str(CaseRight))-2]
    TAGCaseRight = Canevas.gettags (CaseRight)
    print ("Le Tag de la caseRIGHT est :" , TAGCaseRight)

    CaseLeft = Canevas.find_closest (xSave- 2 * r, ySave , halo = None, start = None) 
    CaseLeft = str(CaseLeft)[1:len(str(CaseLeft))-2]
    TAGCaseLeft = Canevas.gettags (CaseLeft)
    print ("Le Tag de la caseLEFT est :" , TAGCaseLeft)
    return TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft

# ----------------------------------------------- #
"""Cette fonction va renvoyé les TAGS des cases ,haut, droite, bas et gauche, du chien (pour tenter de créer une carte aléatoire)"""
def CheckChien():
    global IDChien , x, y,r, TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft

    CaseTop = Canevas.find_closest (x, y - 2 * r, halo = None, start = None) 
    CaseTop = str(CaseTop)[1:len(str(CaseTop))-2]
    TAGCaseTop = Canevas.gettags (CaseTop)
    print ("Le Tag de la caseTOP est :" , TAGCaseTop)

    CaseBot = Canevas.find_closest (x, y + 2 * r, halo = None, start = None) 
    CaseBot = str(CaseBot)[1:len(str(CaseBot))-2]
    TAGCaseBot = Canevas.gettags (CaseBot)
    print ("Le Tag de la caseBOT est :" , TAGCaseBot)

    CaseRight = Canevas.find_closest (x + 2 * r, y, halo = None, start = None) 
    CaseRight = str(CaseRight)[1:len(str(CaseRight))-2]
    TAGCaseRight = Canevas.gettags (CaseRight)
    print ("Le Tag de la caseRIGHT est :" , TAGCaseRight)

    CaseLeft = Canevas.find_closest (x- 2 * r, y , halo = None, start = None) 
    CaseLeft = str(CaseLeft)[1:len(str(CaseLeft))-2]
    TAGCaseLeft = Canevas.gettags (CaseLeft)
    print ("Le Tag de la caseLEFT est :" , TAGCaseLeft)
    
    return TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft

# ----------------------------------------------- #
"""Cette fonction ne fait que vérifier si la case finale, la sortie est adjacente au sauveteur."""
def CheckFinish():
    
    global IDSauveteur , xSave, ySave,r, TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft, FINISH
    
    if str(TAGCaseTop) == "('finish',)":
        ySave = ySave - 2*r
        Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
        Canevas.addtag_closest ("Vu", xSave, ySave + 2*r )              # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu. 
        FINISH = 1
        
    if str(TAGCaseRight) == "('finish',)":
        xSave = xSave + 2*r
        Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
        Canevas.addtag_closest ("Vu", xSave - 2*r , ySave)              # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu. 
        FINISH = 1
        
    if str(TAGCaseBot) == "('finish',)":
        ySave = ySave + 2*r
        Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
        Canevas.addtag_closest ("Vu", xSave, ySave - 2*r )              # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu. 
        FINISH = 1
        
    if str(TAGCaseLeft) == "('finish',)" :
        xSave = xSave - 2*r
        Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
        Canevas.addtag_closest ("Vu", xSave + 2*r , ySave )             # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu. 
        FINISH = 1

# ----------------------------------------------- #
"""Cette fonction permettra au sauveteur de se déplacer de manière aléatoire, sur les différents choix de chemin qui s'ofrent à lui."""     
def MvmtFree():
    global TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft, ySave, xSave, RETURN, deplacement, ineg, num
    
    liste = []
    i = 0
    bouger = 0
    if str(TAGCaseTop) == "('way',)":
        print("Top libre")
        liste.append (1)
        i += 1
    if str(TAGCaseRight) == "('way',)":
        print("Right libre")
        liste.append (2)
        i += 1
    if str(TAGCaseBot) == "('way',)":
        print("Bot libre")
        liste.append (3)
        i += 1
    if str(TAGCaseLeft) == "('way',)" or str(TAGCaseLeft) == "('finish',)":
        print("Left libre")
        liste.append (4)
        i += 1
    if i != 0 :
        ineg = 0
        bouger = choice(liste)
    print (bouger)
    
    if i == 2:                      #Quand le sauveteur aura le choix entre 2 directions différentes va ajouter le nombre 6 dans la liste de déplacements
        deplacement.append(6)
    if i == 3:                      #Quand le sauveteur aura le choix entre 3 directions différentes va ajouter le nombre 7 dans la liste de déplacements
        deplacement.append(7)
        
    if bouger == 1:
        ySave = ySave - 2*r
        Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
        Canevas.addtag_closest ("Vu", xSave, ySave + 2*r )              # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu. 
        deplacement.append (1)                                          # Ajoute le déplacement haut (1) à l'historique des déplacements
        num += 1 
    elif bouger == 2:
        xSave = xSave + 2*r
        Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
        Canevas.addtag_closest ("Vu", xSave - 2*r , ySave)              # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu. 
        deplacement.append (2)                                          # Ajoute le déplacement droite (2) à l'historique des déplacements
        num += 1 
    elif bouger == 3:
        ySave = ySave + 2*r
        Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
        Canevas.addtag_closest ("Vu", xSave, ySave - 2*r )              # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu. 
        deplacement.append (3)                                          # Ajoute le déplacement bas (3) à l'historique des déplacements
        num += 1 
    elif bouger == 4:
        xSave = xSave - 2*r
        Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
        Canevas.addtag_closest ("Vu", xSave + 2*r , ySave )             # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est vu. 
        deplacement.append (4)                                          # Ajoute le déplacement gauche (4) à l'historique des déplacements
        num += 1 
    else:
        print ("Marche arrière")
        RETURN = 1

# ----------------------------------------------- #
"""Cette fonction permettra au sauveteur de retourner en arrière jusqu'à son dernier choix."""
def Return():
    global ySave, xSave, RETURN, ISSUE, deplacement, num, ineg
    marchearr = []  # Cette liste va stocker les déplacements en marche arrière nécessaires pour retourner à l'ancien choix.
    bouger = 0      # Cette variable va indiquer la direction à suivre, (coordonées sont inversés par rapport à la fonction MvmtFree car le sauveteur devra faire les mouvements contraires de ceux déjà éxécutés).
    compteur = 0
    i = len (deplacement)-1
    if len(deplacement) > 0 :
        print (i)
        print (deplacement[i])
        while str(deplacement[i])!= "6" and str(deplacement[i]) != "7":
            
            print ("i:" , i)
            print ("Taille:" , len(deplacement))
            print ("Deplacement:" , deplacement)
            print (deplacement[i])
            
            marchearr.append (deplacement[i])
            print ("marche arrière:" , marchearr)
            i -= 1
        if deplacement[i]== 6 and RETURN == 1:
            deplacement = deplacement [:i]      # Cette ligne supprime tous les déplacements depuis l'ancien choix
            print (deplacement)
            print ("6 -> 0")
            RETURN = 0
        elif deplacement[i]== 7 and RETURN == 1:
            deplacement = deplacement [:i]      # Cette ligne supprime tous les déplacements depuis l'ancien choix
            deplacement.append (6)
            print (deplacement)
            print ("7 -> 6")
            RETURN = 0
    
        while len(marchearr) > compteur:
            print (len(marchearr))
            bouger = marchearr [compteur]                          # Va assigné à la variable bouger la valeur des déplacements précédents.
            print (bouger)
            if bouger == 1:
                ySave = ySave + 2*r
                Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
                Canevas.addtag_closest ("Block", xSave, ySave - 2*r )           # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est le mauvais. 
                                                      # Ajoute le déplacement bas (3) à l'historique des déplacements
                
            elif bouger == 2:
                xSave = xSave - 2*r
                Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
                Canevas.addtag_closest ("Block", xSave + 2*r , ySave )          # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est le mauvais. 
                                                         # Ajoute le déplacement gauche (4) à l'historique des déplacements
                
            elif bouger == 3:
                ySave = ySave - 2*r
                Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
                Canevas.addtag_closest ("Block", xSave, ySave + 2*r )           # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est le mauvais. 
                                                         # Ajoute le déplacement haut (1) à l'historique des déplacements
                
            elif bouger == 4:
                xSave = xSave + 2*r
                Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
                Canevas.addtag_closest ("Block", xSave - 2*r , ySave)           # Va mettre une marque à son dernier emplacement de manière à indiquer que ce chemin est le mauvais. 
                                                   # Ajoute le déplacement droite (2) à l'historique des déplacements
            sleep (0.5)
            Canevas.itemconfigure ("Block", outline= "#000000", fill= "#FF9933"  )
            cadre.update()
            compteur += 1
            
    else:
        ISSUE = 0   # Va indiquer qu'il n'y a plus d'issus
        print ("Votre petite souris est bloqué ici !")
    
    print (ineg)
    print (num)
    ineg += 1
    num += 1
# ----------------------------------------------- #
"""Cette fonction permettra De gérer les différentes fonctions liés aux déplacements avec toutes les conditions nécéssaires."""    
def Bouger():
    global TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft, ySave, xSave, RETURN, ISSUE, FINISH, ISSUE, ineg, num
    while FINISH == 0 and ISSUE == 1:
        Check ()
        CheckFinish()
        print (RETURN)
        print (FINISH)
        if  FINISH == 1 and ISSUE == 1:         # Cette condition va vérifier si nous avons trouvé la fin du labyrinthe.
            print ("Votre petite souris a trouvé la sortie.")
        elif FINISH == 0 and ISSUE == 1:        # Cette condition va vérifier que nous n'avons pas trouvé trouvé la fin et si nous ne sommes pas au point où il n'y a plus d'issus.
            if RETURN == 0:
                MvmtFree ()
            if RETURN == 1:
                Return ()
        Canevas.dtag ("Vu", "way")
        Canevas.dtag ("Block", "Vu")
        Canevas.dtag ("Block","way")
        Canevas.dtag ("wall","Vu")
        Canevas.itemconfigure ("Vu", outline= "#000000", fill= "#0000CC"  )
        Canevas.itemconfigure ("Block", outline= "#000000", fill= "#FF9933"  )
        cadre.update()
        sleep (0.5)
        
    if ISSUE == 0 :                             # Cette condition s'effectuera si aucune issue n'a était trouvé au labyrinthe.
        print ("Ce labyrinthe est sans issus. Votre souris risque de décéder.")
        

# ----------------------------------------------- #
"""Cette fonction va générer la map automatiquement, en créant un pointeur qui créera la map.(en cours de création.)"""

def Auto():
    global TAGCaseTop, TAGCaseBot, TAGCaseRight, TAGCaseLeft, y, x, RETURN
    
    
    Canevas.create_rectangle(x-r, y-r, x+r, y+r, outline='black', fill= "#FFFF99" )     # Va placer le rectangle par rapport aux positions initiales
    IDChien = Canevas.find_closest (x,y , halo = None, start = None)                    # Va récupérer L'id du chien.
    IDChien = str(IDChien)[1:len(str(IDChien))-2]                                       # Permet de retourner l'ID du chien sans les parenthèse et sans la virgule 
    print (IDChien)
    Canevas.addtag_withtag ("chien", IDChien)
    b = 0
    while b != 200:
        CheckChien ()
        liste = []
        i = 0
        bouger = 0
        if str(TAGCaseTop) == "('wall',)" :
            print("Top libre")
            liste.append (1)
            i += 1
        if str(TAGCaseRight) == "('wall',)" :
            print("Right libre")
            liste.append (2)
            i += 1
        if str(TAGCaseBot) == "('wall',)" :
            print("Bot libre")
            liste.append (3)
            i += 1
        if str(TAGCaseLeft) == "('wall',)" :
            print("Left libre")
            liste.append (4)
            i += 1
        if i != 0 :
            bouger = choice(liste)
        print (bouger)
        
        if bouger == 1:
            y = y - 2*r
            Canevas.coords(IDChien, x-r, y-r, x+r, y+r)             # Repositionne Le chien avec les nouvelles coordonées
            Canevas.addtag_closest ("way", x, y + 2*r )
        elif bouger == 2:
            x = x + 2*r
            Canevas.coords(IDChien, x-r, y-r, x+r, y+r) 
            Canevas.addtag_closest ("way", x - 2*r , y)
        elif bouger == 3:
            y = y + 2*r
            Canevas.coords(IDChien, x-r, y-r, x+r, y+r) 
            Canevas.addtag_closest ("way", x ,y - 2*r )
        elif bouger == 4:
            x = x - 2*r
            Canevas.coords(IDChien, x-r, y-r, x+r, y+r) 
            Canevas.addtag_closest ("way", x + 2*r , y )
        b += 1
        Canevas.dtag ("way", "wall")
        Canevas.itemconfigure ("way", outline= None, fill= "#999999"  )
        
# ----------------------------------------------- #
"""Cette fonction va permettre de déplacer le sauveteur (à l'aide du clavier) avant de le lancer dans le labyrinthe"""
def clavier(event):
    
    global coords , IDSauveteur, xSave, ySave
    touche = event.keysym                                           #La variable touche récupère la valeur de la touche entrée
    
    """Les quatres diffférents déplacements possibles"""
    
    if touche == "Up" and ySave - 2*r > 0:                          # Si l'utilisateur appuie sur la touche haut, le sauveteur se déplacera vers le haut d'une case. Tant qu'il ne sort pas du cadre. 
        ySave = ySave - 2*r
        
    elif touche == "Down" and ySave + 2*r < Hauteur:                # Si l'utilisateur appuie sur la touche bas, le sauveteur se déplacera vers le bas d'une case.  
        ySave = ySave + 2*r
        
    elif touche == "Right" and xSave + 2*r < Largeur:               # Si l'utilisateur appuie sur la touche droite, le sauveteur se déplacera vers la droite d'une case. 
        xSave = xSave + 2*r
        
    elif touche == "Left" and xSave - 2*r > 0:                      # Si l'utilisateur appuie sur la touche gauche, le sauveteur se déplacera vers la gauche d'une case.
        xSave = xSave -2*r
        
    Canevas.coords(IDSauveteur, xSave-r, ySave-r, xSave+r, ySave+r) # Repositionne Le sauveteur avec les nouvelles coordonées
    
    if touche == "Escape":                                          # Pour quitter le programme
        cadre.destroy()


        
# -----------"""Fonctions souris"""----------- #
# ----------------------------------------------- #
"""Cette fonction permet d'activé l'interrupteur nous permettant de placé des chemin"""
def Create():
    global CREATE, PUTFINISH
    CREATE = TRUE
    PUTFINISH = FALSE

# ----------------------------------------------- #
"""Cette fonction permet d'activé l'interrupteur nous permettant de placé une ligne d'arrivée"""
def PutFinish():
    global CREATE, PUTFINISH
    CREATE = FALSE
    PUTFINISH = TRUE
# ----------------------------------------------- #
"""Cette fonction va permettre placer certains points, les chemins ou le point final."""
def Clic(event):
    global r, sauveteur, IDSauveteur, CREATE, PUTFINISH
    
    # Va chercher les valeurs des coordonées de la souris X et Y
    X = event.x
    Y = event.y
    
    if PUTFINISH == TRUE:
        # Va donner au carre le plus proche des coordonées de la souris le TAG "finish"
        Canevas.addtag_withtag('wall',  'finish')
        Canevas.dtag ("wall", "finish")
        Canevas.itemconfigure ("wall", outline= "#000000", fill= "#00DD00"  )
        Canevas.addtag_closest ("finish", X, Y)
        
    if CREATE == TRUE:
        # Va donner au carre le plus proche des coordonées de la souris le TAG "way"
        Canevas.addtag_closest ("way", X, Y)
 
    """CLEAN"""
    # Ce bloc permet d'éviter que les objet aient différents TAG
    Canevas.dtag ("way", "wall")
    Canevas.dtag ("sauveteur", "way")
    Canevas.dtag ("sauveteur", "finish")
    Canevas.dtag ("finish", "way")
    Canevas.dtag ("finish", "wall")
    Canevas.itemconfigure ("sauveteur", outline= "#000000", fill= None  )
    Canevas.itemconfigure ("finish", outline= "#000000", fill= "#FFFF00"  )
    Canevas.itemconfigure ("wall", outline= "#000000", fill= "#00DD00"  )
    Canevas.itemconfigure ("way", outline= None, fill= "#999999"  )


    
    
# -----------"""Fonctions utilitaires"""----------- #

# ----------------------------------------------- #
"""Cette fonctione permet de nettoyer la zone graphique"""     
def Effacer():
    Canevas.delete(ALL)

# ----------------------------------------------- #
"""Cette fonctione permet de fermer la fenetre."""
def Quitter(event):
    cadre.destroy()
    
# ----------------------------------------------- #
"""Cette fonctione permet d'empecher le sauveteur de se déplacer en cas de problème."""
def Interrupt():
    global FINISH
    FINISH = 1

# ------------------------      Partie graphique        ------------------------ #

# Création de la fenêtre principale (main window)
cadre = Tk()

cadre.title('La souricière')

# Création d'un widget Canevas (zone graphique)
Largeur = r * 2 * Nmbrx
Hauteur = r * 2 * Nmbry
Canevas = Canvas(cadre, width = Largeur, height =Hauteur, bg ='white')
Canevas.pack(padx =5, pady =5)


# Création d'un widget Button (bouton Go)
BoutonGo = Button(cadre, text ='Go', command = Generer)
BoutonGo.pack(side = LEFT, padx = 5, pady = 5)

# Création d'un widget Auto (bouton Auto)
BoutonAuto = Button(cadre, text ='Auto', command = Auto)
BoutonAuto.pack(side = LEFT, padx = 5, pady = 5)

# Création d'un widget Auto (bouton Create)
BoutonGo = Button(cadre, text ='Create', command = Create)
BoutonGo.pack(side = LEFT, padx = 5, pady = 5)

# Création d'un widget Auto (bouton PutFinish)
BoutonGo = Button(cadre, text ='PutFinish', command = PutFinish)
BoutonGo.pack(side = LEFT, padx = 5, pady = 5)

# Création d'un widget Button (bouton Effacer)
BoutonEffacer = Button(cadre, text ='Effacer', command = Effacer)
BoutonEffacer.pack(side = LEFT, padx = 5, pady = 5)

# Création d'un widget Button (bouton Check)
BoutonCheck = Button(cadre, text ='Check', command = Check)
BoutonCheck.pack(side = LEFT, padx = 5, pady = 5)

# Création d'un widget Button (bouton Bouger)
BoutonBouger = Button(cadre, text ='Bouger', command = Bouger)
BoutonBouger.pack(side = LEFT, padx = 5, pady = 5)

# Création d'un widget Button (bouton Interrupt)
BoutonInterrupt = Button(cadre, text ='Interrupt', command = Interrupt)
BoutonInterrupt.pack(side = LEFT, padx = 5, pady = 5)

# Création d'un widget Button (bouton Quitter)
BoutonQuitter = Button(cadre, text ='Quitter', command = cadre.destroy)
BoutonQuitter.pack(side = LEFT, padx = 5, pady = 5)

Canevas.focus_set()                 # Permet de réinitialisé le focus, il est conseillé d'en placer un pour éviter certains bugs.
Canevas.bind('<Button-1>',Clic)     # évévement clic gauche (press)
Canevas.bind('<B1-Motion>',Clic)    # évévement clic gauche (enfoncé)
Canevas.bind("<Key>", clavier)      # Récupère la touche entrée


cadre.mainloop()



Partager le fichier

Télécharger les-premiers-pas-d-une-souris-intelligente.py

Télécharger le fichier (26 Ko)