def display_all_level(): """ Réaffiche tous les éléments à la fenêtre. """ global has_stole utk.efface_tout() utk.rectangle(level_pos[0] - 20, level_pos[1] - 20, level_pos[0] + level_px[0] + 20, level_pos[1] + level_px[1] + 20, couleur="black", remplissage="black", epaisseur=0, tag="background") display_cases() display_between_cases() for i in range(len(lvl.pion_pos)): display_pion(i) display_selected_game() if lvl.player_using_vortex != -1: display_selected_target(lvl.selected_vortex) if lvl.player_using_spell != -1: display_selected_target(lvl.selected_spell_target) if len(lvl.move_pion) > 0: display_selected_target_confirmed(lvl.pion_pos[lvl.move_pion[0]]) display_escalators() if lvl.discussing: display_discuss(x=10, y=130) utk.mise_a_jour()
def setBackground(color): """ Modifie la couleur d'arrière plan. :param string color: Couleur d'arrière plan """ efface_tout() rectangle(0, 0, WIDTH_WINDOW, HEIGHT_WINDOW, color, color, 1) reDraw()
def draw_laby(self, labyrinth, entities): upemtk.efface_tout() upemtk.rectangle(0, 0, self.size, self.size, couleur='', remplissage='white') self.draw_extern_wall() self.draw_wall(labyrinth) for entity in entities: self.draw_entity(entity) if self.show_chance: self.draw_chance() self.show_chance = False upemtk.mise_a_jour()
def win(nbdiamand, diamand, tempsrestant, cartes, score, nommap): """ Regarde si l'utilisateur gagne si oui, met l'image de victoire et retourne True :param int nb_diamand: nombre de diamant deja recupere en jeu :param int diamand: nombre de diamant requis avant de pouvoir gagner :param int tempsrestant: temps restant de la partie en cours :param cartes: :param str score: score de la partie :param str nommap: nom de la map en cours de jeu :return: bool """ MS = 0 if (var["pos_x"] == var["pos_sortie_x"] and var["pos_y"] == var["pos_sortie_y"] and nbdiamand >= diamand): suivant = 0 upemtk.efface_tout() while suivant == 0: suivant, score = esthetique.menu_score(nbdiamand, tempsrestant, suivant, score) upemtk.efface_tout() esthetique.fond("cyan") upemtk.texte( var["dimension_fenetre"] // 2, var["dimension_fenetre"] // 3, "Victoire !", couleur="black", ancrage="center", taille=75, ) esthetique.personnage_victorieux() esthetique.coffre() esthetique.affiche_score_victoire(score) if MS == 0: test_meilleurscore(nommap, score) MS = 1 if cartes == 6: del var["carte"] return True return False
def UIchoixNbrJoueur(): """ Renvoie le nombre de joueur selectionné par l'utilisateur """ # Affichage de base tk.efface_tout() tk.texte(600, 100, "Selectionnez le nombre de joueur avec ↑, ↓ et Entrée", ancrage = 'center' ) tk.rectangle(200, 200, 450, 350, couleur = 'black', remplissage = '#b9b9b9', epaisseur = 3) tk.texte(325, 280, "1", ancrage = 'center', taille = 30) tk.rectangle(200, 400, 450, 550, couleur = 'black', remplissage = '#b9b9b9', epaisseur = 3) tk.texte(325, 480, "2", ancrage = 'center', taille = 30) tk.rectangle(200, 600, 450, 750, couleur = 'black', remplissage = '#b9b9b9', epaisseur = 3) tk.texte(325, 680, "3", ancrage = 'center', taille = 30) # Selecteur choix = 1 entreeClavier = None while entreeClavier != 'Return': tk.efface('selecteur') if choix == 1: tk.rectangle(190, 190, 460, 360, couleur = '#565656', remplissage = '', epaisseur = 4, tag = 'selecteur') elif choix == 2: tk.rectangle(190, 390, 460, 560, couleur = '#565656', remplissage = '', epaisseur = 4, tag = 'selecteur') elif choix == 3: tk.rectangle(190, 590, 460, 760, couleur = '#565656', remplissage = '', epaisseur = 4, tag = 'selecteur') entreeClavier = tk.attente_touche() if entreeClavier == 'Up': choix = choix-1 if choix > 1 else choix if entreeClavier == 'Down': choix = choix+1 if choix < 3 else choix return choix entree = None while entree != 'Escape': entree = tk.attente_touche() return
def loose(carte, tempsrestant): """ test si joueur s'est pris une pierre si oui met l'image de défaite et retourne True :param list carte: liste 2D contenant le jeu :param int tempsrestant: temps restant de la partie en cours :return: bool """ if carte[var["pos_y"] - 1][var["pos_x"]] in ["K", "C" ] or tempsrestant <= 0: upemtk.efface_tout() esthetique.fond("black") esthetique.personnage_defaitiste() upemtk.texte( var["dimension_fenetre"] // 2, var["dimension_fenetre"] // 4, "DÉFAITE !", couleur="red", ancrage="center", taille=75, ) return True return False
def clear(): """ Efface toute l'image. """ efface_tout()
def test_map(carte_, tempstotal, diamand): carte = ajout_mur_autour(carte_) var["w_map"] = len(carte[0]) var["h_map"] = len(carte) var["taille_case"] = int( var["dimension_fenetre"] / max([var["w_map"], var["h_map"]]) ) # fait en sorte que la map reste sur l'ecran for j in range(len(carte)): for i in range(len(carte[0])): if carte[j][i] == "R": var["pos_x"] = i var["pos_y"] = j elif carte[j][i] == "E": var["pos_sortie_x"] = i var["pos_sortie_y"] = j score = "00000000" tempslumiere = 150 nbdiamand = 0 debug = -1 chemin_prevu = False debut = time() temps_pierre = time() while True: if time() - debut >= tempstotal: fonction.my_input("Temps écoulé", "str") return False upemtk.efface_tout() if time() - temps_pierre > 0.3: # fait tomber pierre toute les ~ 0.3 sec fonction.tomber_de_pierre_ou_diamand(carte) fonction.test_pierre_ou_diamand_eboulement(carte) fonction.tomber_pierre_laterale(carte) temps_pierre = time() if ( time() - temps_pierre > 0.15 ): # transforme des pierre qui peuvent tomber en des pierres qui vont tomber fonction.test_si_pierre_va_tomber(carte) affiche_map(carte, nbdiamand=nbdiamand, diamand=diamand) ev = upemtk.donne_evenement() type_ev = upemtk.type_evenement(ev) if fonction.test_pousser_pierre(carte, ev): fonction.pousser_pierre(carte, upemtk.touche(ev)) if type_ev == "Quitte": # Peut quitter avec la croix return -1 elif type_ev == "Touche": t = upemtk.touche(ev).lower() if ( t == var["menu"] ): return False elif t == var["debug"]: debug *= -1 elif t == var["pf"]: trouve = fonction.recherche_parcours(carte, diamand - nbdiamand) if trouve: print("CHEMIN TROUVE") var["pathfinding"] = True else: print("PAS DE CHEMIN") var["pathfinding"] = False if debug == 1: nbdiamand, debug, tempstotal, score, tempslumiere = fonction.debug( carte, nbdiamand, debug, tempstotal, score, tempslumiere ) elif var["pathfinding"]: if len(var["chemin"]): ( nbdiamand, tempstotal, score, tempslumiere, chemin_prevu, ) = fonction.pathfinding( carte, nbdiamand, diamand, tempstotal, score, tempslumiere, var["chemin"].pop(0), ) if not chemin_prevu or not len(var["chemin"]): trouve = fonction.recherche_parcours(carte, diamand - nbdiamand) if trouve: print("CHEMIN TROUVE") var["pathfinding"] = True else: print("PAS DE CHEMIN") var["pathfinding"] = False else: nbdiamand, tempstotal, score, tempslumiere = fonction.deplacer_perso( carte, nbdiamand, ev, diamand, tempstotal, score, tempslumiere ) if var["porte"] == 1: fonction.enleve_porte(carte, ev, nbdiamand, diamand) upemtk.mise_a_jour() if ( var["pos_x"] == var["pos_sortie_x"] and var["pos_y"] == var["pos_sortie_y"] and nbdiamand >= diamand ): return True
def main(): tools = ["G", "P", "W", "D", "R", "E", "L", "F", "K", "C"] # block disponible dans la barre d'outil esthetique.fond("black") var["w_map"] = fonction.my_input("Nombre de colonnes:", "int") var["h_map"] = fonction.my_input("Nombre de lignes:", "int") var["taille_case"] = int( var["dimension_fenetre"] / max([var["w_map"], var["h_map"]]) ) # fait en sorte que la map reste sur l'ecran carte = [["." for i in range(var["w_map"])] for i in range(var["h_map"])] element = "." while True: upemtk.efface_tout() affiche_map(carte) affiche_tools(tools) quitter = fonction.encadrement( "Quitter", var["dimension_fenetre"] * 2 / 3, 2, "White", "white", 15, 1, 1, "Impact", ) sauvegarder = fonction.encadrement( "Sauvegarder", var["dimension_fenetre"] / 3, 2, "White", "white", 15, 1, 1, "Impact", ) upemtk.mise_a_jour() ev = upemtk.donne_evenement() type_ev = upemtk.type_evenement(ev) if type_ev == "Quitte": return -1 if type_ev == "ClicGauche": x_, y_ = (upemtk.clic_x(ev), upemtk.clic_y(ev)) if fonction.test_clic((x_, y_), quitter): return 0 if fonction.test_clic((x_, y_), sauvegarder): save(carte) else: x = x_ // var["taille_case"] y = y_ // var["taille_case"] if x < var["w_map"] and y < var["h_map"]: carte[y][x] = element elif y_ // var["bandeau"] == 6: element = tools[int(x_ // (var["bandeau"] * 6/len(tools)))] elif type_ev == "Touche": t = upemtk.touche(ev) if t.upper() in fonction.dico: element = t.upper() elif t.lower() == "s": save(carte) elif t.lower() == "t": # touche pour les test if not test_1_entree_1_sortie(carte): test_map(carte, 150, 0) # remet les bonnes tailles var["w_map"] = len(carte[0]) var["h_map"] = len(carte) var["taille_case"] = int( var["dimension_fenetre"] / max([var["w_map"], var["h_map"]]) ) # fait en sorte que la map reste sur l'ecran var["porte"] = 1 elif t == "Escape": break elif type_ev == "ClicDroit": if upemtk.clic_y(ev) // var["taille_case"] < len(carte): carte[upemtk.clic_y(ev) // var["taille_case"]][ upemtk.clic_x(ev) // var["taille_case"] ] = "." return 0
def affichage(largeurFenetre, hauteurFenetre, largeurInventaire, inventaire, carte): """ affichage de la fenêtre, la fonction affiche tout les éléments possibles """ tk.efface_tout() #On met à jour la fenêtre et on affiche chaque élément largeurCase = largeurDeCase(largeurFenetre, hauteurFenetre, carte) #On parcourt la liste 2D (des sous listes dans une liste) dessinerQuadrillage( largeurFenetre, hauteurFenetre, largeurCase, carte) # on peut retirer cette ligne pour que ça soit plus jolie for i in range(len(carte)): #i les lignes for j in range(len(carte[i])): #j les colonnes if carte[i][j] == ".": #Case vide pass elif carte[i][j] == "W": #Wall dessinerMur(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "T": #Target dessinerCible(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "S": #Start dessinerJoueur(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "D": #Door dessinerPorte(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "K": #Key dessinerClef(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "B": #Box dessinerBoite(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "TB": #Box On a target dessinerCible(j * largeurCase, i * largeurCase, largeurCase) dessinerBoite(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "TJ": #Joueur On a target dessinerCible(j * largeurCase, i * largeurCase, largeurCase) dessinerJoueur(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "J": #Joueur dessinerJoueur(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "KB": #Box On a key dessinerBoite(j * largeurCase, i * largeurCase, largeurCase, "green") n = largeurFenetre - largeurInventaire dessinerInventaire(n, 0, largeurInventaire, hauteurFenetre) dessinerClef(n, 0, largeurCase * 2) #largeurCase/1.5 ou largeurCase/15 est là pour centrer le texte tk.texte(n + largeurCase / 1.5, largeurCase * 2, inventaire["nbClefs"], "white") tk.texte(n + largeurCase / 1.5, largeurCase * 4, inventaire["nbCoups"], "white") n = largeurFenetre - largeurInventaire + largeurCase / 15 tk.texte(n, largeurCase * 6.5, "Echap: Quitter", "white", "nw", "Purisa", 9) #bouton quitter tk.texte(n, largeurCase * 7, "E: Tirer", "white", "nw", "Purisa", 9) #bouton pour tirer tk.texte(n, largeurCase * 7.5, "R: Recharger", "white", "nw", "Purisa", 9) #bouton reset tk.texte(n, largeurCase * 8, "S: Sauvegarde", "white", "nw", "Purisa", 9) #bouton save tk.texte(n, largeurCase * 8.5, "B: Recommencer", "white", "nw", "Purisa", 9) #bouton save tk.mise_a_jour()
def main(): """ Fonction principale """ #### Définition des constantes et initialisation des variables ########### # info sur le contenu des cellules matriceTerrain, matriceTuiles, mursVer, mursHor = creerMatriceTerrain() tuilesRestantes = [i for i in range(2, 10)] infoPion = dict() # info sur la position des pion initPions(1, (24, 24), infoPion) initPions(2, (25, 25), infoPion) initPions(3, (25, 24), infoPion) initPions(4, (24, 25), infoPion) dicEsc = {(25, 26): (26, 25), (26, 25): (25, 26)} dicTuile2 = defDicTuile2() dicTuile7 = defDicTuile7() #initialisé à 0 (inactif), passe à 1 si actif #on utilise une liste car objet mutable (dégueux mais pratique) modeVortex = [0] #roulement entre 0 (aucun portail selectionné) et les autres portails accessibles vortexActif = [0] tuilesPosees = [0, 1] modeTelekinesie = [0] telekinesieIndexTuileActive = [0] telekinesiesRestantes = [2] dicVortex = {1: [(23, 26)], 2: [(24, 26)], 3: [(26, 23)], 4: [(25, 23)]} sortieActive = False partiePerdue = False partieGagnee = False dureeTotalePartieInitiale = 180 # En secondes tempsRestant = dureeTotalePartieInitiale modifTemps = [0] listeGagnants = [] debugActif = -1 # -1 -> vdésactivé ; 1 -> activé vitesse = 1 / 500 # Vitesse du mode debug #### Ouverture de la fenêtre ############################################# tk.cree_fenetre(1900, 1000) #### Demander au joueur ce qu'il faut faire ############################## chargerSave = UIecranTitre() #### Choix du nombre de joueur ########################################### touchesDeBase = defTouchesDeBase() if not chargerSave: nb_joueurs = UIchoixNbrJoueur() touchesTotales = attributionDesTouches(nb_joueurs, touchesDeBase) touchesPartieParJoueur = touchesTotales[0] touchesPartie = touchesTotales[1] else: matriceTerrain, infoPion, nb_joueurs, sortieActive, tempsRestant, touchesPartie, touchesPartieParJoueur, listeGagnants, matriceTuiles, mursVer, mursHor, tuilesPosees, dicVortex, dicEsc, telekinesiesRestantes = chargerPartie( ) for tuile in tuilesPosees: if tuile in tuilesRestantes: tuilesRestantes.remove(tuile) pionActif = dict() for i in range(1, nb_joueurs + 1): pionActif[i] = 1 #### Entrée dans le jeu ################################################## heureDebut = time() dureeTotalePartie = tempsRestant while True: # Boucle Principale tempsPause = gestionEntreeClavier( matriceTerrain, mursVer, mursHor, infoPion, pionActif, sortieActive, debugActif, vitesse, listeGagnants, dicVortex, dicEsc, dicTuile2, dicTuile7, modeVortex, vortexActif, touchesPartie, touchesPartieParJoueur, nb_joueurs, touchesDeBase, tempsRestant, matriceTuiles, tuilesRestantes, tuilesPosees, telekinesieIndexTuileActive, modeTelekinesie, telekinesiesRestantes) heureDebut = heureDebut + tempsPause if not sortieActive: # Si les sorties ne sont pas activées on regarde si on peut les activer sortieActive = pionSurObjet(matriceTuiles, matriceTerrain, infoPion) # Mise à jour de l'image, gestion de la victoire/défaite tk.efface_tout() partiePerdue, tempsRestant = afficherPlateau( matriceTerrain, mursHor, mursVer, infoPion, listeGagnants, pionActif, debugActif, sortieActive, heureDebut, dureeTotalePartie, modifTemps, vortexActif, dicVortex, touchesPartie, touchesPartieParJoueur, matriceTuiles, modeTelekinesie, tuilesPosees, telekinesieIndexTuileActive, telekinesiesRestantes) partieGagnee = verifVictoire(listeGagnants) if partieGagnee or partiePerdue: break # Affichage des messages de victoire/défaite finPartie(partieGagnee, partiePerdue) tk.attente_clic_ou_touche() tk.ferme_fenetre()
def affichageEditeur(carte, selection, message): """ affichage de la fenêtre, la fonction affiche tout les éléments possibles """ tk.efface_tout() #On parcourt la liste 2D (des sous listes dans une liste) dessinerQuadrillage(largeurEditeur // 2 + largeurFenetre, hauteurFenetre, largeurCase, carte) for i in range(len(carte)): #i les lignes for j in range(len(carte[i])): #j les colonnes if carte[i][j] == ".": #Case vide pass elif carte[i][j] == "W": #Wall dessinerMur(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "T": #Target dessinerCible(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "S": #Start dessinerJoueur(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "D": #Door dessinerPorte(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "K": #Key dessinerClef(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "B": #Box dessinerBoite(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "TB": #Box On a target dessinerCible(j * largeurCase, i * largeurCase, largeurCase) dessinerBoite(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "TJ": #Player On a target dessinerCible(j * largeurCase, i * largeurCase, largeurCase) dessinerJoueur(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "J": #Player dessinerJoueur(j * largeurCase, i * largeurCase, largeurCase) elif carte[i][j] == "KB": #Box On a key dessinerBoite(j * largeurCase, i * largeurCase, largeurCase, "green") #------- la fenêtre d'édition tk.rectangle(largeurFenetre - largeurEditeur, 0, largeurFenetre, hauteurFenetre, 'black', 'black') # la position de base des objets avant d'appliquer un coefficient x = largeurFenetre - largeurEditeur + largeurCase // 2 # la position de base des objets de l'éditeur y = largeurCase * 1.5 # le texte tk.texte(0, 0, "Echap pour quitter", "black") tk.texte(0, 40, "S pour sauvegarder", "black") tk.texte(0, 80, "R pour tout effacer", "black") #le message s'il y en a un if message[1] > 0: taille = 42 #longueur texte est là pour centrer le texte tk.texte(( (largeurFenetre - largeurEditeur) - tk.longueur_texte(message[0]) * (taille / 24)) // 2, hauteurFenetre // 2, message[0], "#e82020", taille=taille) # Les objets selectionnables dessinerMur(x, y * 0, y) dessinerCible(x, y * 1, y) dessinerJoueur(x, y * 2, y) dessinerPorte(x, y * 3, y) dessinerClef(x, y * 4, y) dessinerBoite(x, y * 5, y) dessinerCroix(x, y * 6, y, "white") # les cadres verts de sélections if selection == "mur": tk.rectangle(x, y * 0, x + y, y + y * 0, 'green', '', 7) elif selection == "cible": tk.rectangle(x, y * 1, x + y, y + y * 1, 'green', '', 7) elif selection == "joueur": tk.rectangle(x, y * 2, x + y, y + y * 2, 'green', '', 7) elif selection == "porte": tk.rectangle(x, y * 3, x + y, y + y * 3, 'green', '', 7) elif selection == "clef": tk.rectangle(x, y * 4, x + y, y + y * 4, 'green', '', 7) elif selection == "clef": tk.rectangle(x, y * 4, x + y, y + y * 4, 'green', '', 7) elif selection == "boite": tk.rectangle(x, y * 5, x + y, y + y * 5, 'green', '', 7) elif selection == "vide": tk.rectangle(x, y * 6, x + y, y + y * 6, 'green', '', 7) tk.mise_a_jour()
def main(): historique = {} zone_edit = ( var["dimension_fenetre"], var["dimension_fenetre"], ) coordonnee_souris_x = coordonnee_souris_y = 0 liste_clic = [] forme_active = "" boutons = { "C": ("cercle", 50, 655, "green", "black", 20, 1, 2, "Impact"), "R": ("rectangle", 75, 610, "green", "black", 20, 1, 2, "Impact"), "P": ("polygone", 152, 655, "green", "black", 20, 1, 2, "Impact"), "Y": ("cle", 160, 610, "#ff0080", "black", 20, 1, 2, "Impact"), "T": ("torche", 257, 655, "#ff0080", "black", 20, 1, 2, "Impact"), "suppr (backspace)": ( "supprimer (dernier)", 302, 610, "red", "black", 20, 1, 2, "Impact", ), "suppr (enter)": ( "supprimer (nom)", 402, 655, "red", "black", 20, 1, 2, "Impact", ), "sauvegarder": ("sauvegarder", 500, 610, "black", "black", 20, 1, 2, "Impact"), "quitter": ("quitter", 548, 655, "black", "black", 20, 1, 2, "Impact"), } while True: ev = upemtk.donne_evenement() type_ev = upemtk.type_evenement(ev) if type_ev == "Quitte": return -1 if type_ev == "Touche": t = upemtk.touche(ev) t_upper = t.upper() if (t_upper in forme_possible and not forme_active and t_upper not in {"T", "Y"}): forme_active = t_upper elif (t_upper in {"T", "Y"} and not forme_active and not any(map(lambda x: t_upper in x, historique.values()))): forme_active = t_upper elif t == "BackSpace": if len(historique): del historique[len(historique)] affiche_historique(historique) elif t == "Return": nom_forme_a_suppr = fonction.my_input( "nom de la forme\n a supprimer", "str") for cle, valeur in historique.items(): if valeur and valeur[0] == nom_forme_a_suppr: historique[cle] = [] affiche_historique(historique) break elif t == "Escape": return 0 elif t_upper == "S": res = verif_1_cle_1_torche(historique) if res: fonction.my_input(res, "str") else: sauvegarde_historique(historique) return 0 elif type_ev == "Deplacement": coordonnee_souris_x = upemtk.clic_x(ev) coordonnee_souris_y = upemtk.clic_y(ev) if type_ev == "ClicGauche": x, y = upemtk.clic_x(ev), upemtk.clic_y(ev) if (forme_active != "" and (len(liste_clic) < forme_possible[forme_active][3]) and (x <= zone_edit[0] and y <= zone_edit[1])): liste_clic.append((x, y)) elif (type_ev == "ClicDroit" and forme_active != "" and len(liste_clic) >= forme_possible[forme_active][2]): forme_possible[forme_active][0]( historique, liste_clic ) # cree la forme dans l'historique a partir des clics forme_active = "" del liste_clic[:] affiche_historique(historique, len(historique)) upemtk.efface_tout() upemtk.rectangle( 0, 0, zone_edit[0], zone_edit[1], remplissage="black", ) # affiche les formes dans l'historique for elem in historique.values(): if elem: forme_possible[elem[1]][1](*elem[2:]) # affiche une croix sur les clics afin de conserver visuellement leur position for elem in liste_clic: affiche_croix(*elem, 5) # efface les traits sortant de la zone d'edit upemtk.rectangle( zone_edit[0], 0, var["dimension_fenetre"], var["dimension_fenetre"] - var["dimension_fenetre"] // 6, couleur="white", remplissage="white", ) upemtk.rectangle( 0, zone_edit[1], var["dimension_fenetre"], var["dimension_fenetre"] + var["bandeau"], couleur="white", remplissage="white", ) for cle, elem in boutons.items(): pos = fonction.encadrement(*boutons[cle]) if type_ev == "ClicGauche" and fonction.test_clic( (coordonnee_souris_x, coordonnee_souris_y), pos): if cle in forme_possible and cle not in {"T", "Y"}: del liste_clic[:] forme_active = cle elif cle in forme_possible and not any( map(lambda x: cle in x, historique.values())): del liste_clic[:] forme_active = cle elif cle == "sauvegarder": res = verif_1_cle_1_torche(historique) if res: fonction.my_input(res, "str") else: sauvegarde_historique(historique) return 0 elif cle == "quitter": return 0 elif cle == "suppr (backspace)": if len(historique): del historique[len(historique)] affiche_historique(historique) elif cle == "suppr (enter)": nom_forme_a_suppr = fonction.my_input( "nom de la forme\n a supprimer", "str") for cle, valeur in historique.items(): if valeur and valeur[0] == nom_forme_a_suppr: historique[cle] = [] affiche_historique(historique) break # affiche la croix sur le curseur pour plus de precision du clic affiche_croix(coordonnee_souris_x, coordonnee_souris_y, 20) upemtk.mise_a_jour() # fait de la place dans les evenements car le surplus d'evenemement est très présent et casse tout # la lignes peut etre supprimé afin de bien apprécier le spectacle puis venir la remettre dans les secondes qui suivent ;) del upemtk.__canevas.eventQueue[:-5] return 0