def SetGameEventFromTkEvent(ev, inGame): """ renvoie la direction de rockford :param tuple ev: Evenement donné par upemtk """ type_ev=type_evenement(ev) if type_ev=="Touche": t=touche(event["tk"]) if t in "Right": event["game"]="move" if inGame else "right" elif t in "Left": event["game"]="move" if inGame else "left" elif t in "Up": event["game"]="move" if inGame else "up" elif t in "Down": event["game"]="move" if inGame else "down" elif t=="r": event["game"]="reset" elif t=="d": event["game"]="debug" elif t=="q": event["game"]="quitter" elif t=="s": event["game"]="save" elif t=="l": event["game"]="load" elif t=="Escape": event["game"]="return" else: event["game"]=None else: event["game"]=None
def clearEventQueue(): """ Corrige le système de pile d'événements de upemtk. """ while type_evenement(donne_evenement()) != "RAS": #print("videur d'event entre à l'action") 1
def debugDeplacement(carte, infoMap, inventaire): #Fonction qui nous permet d'effectuer le déplacement aléatoire du joueur de manière automatique largeurFenetre, hauteurFenetre, largeurInventaire = infoMap[0], infoMap[ 1], infoMap[2] #Affectations pour plus de clarté while True: nb = randint( 1, 4 ) #Génération d'un entier entre 1 et 4 qui va engendrer un mouvement aléatoire du joueur if nb == 1: carte = mouvement(0, -1, carte, inventaire) #Gauche elif nb == 2: carte = mouvement(0, 1, carte, inventaire) #Droite elif nb == 3: carte = mouvement(-1, 0, carte, inventaire) #Haut elif nb == 4: carte = mouvement(1, 0, carte, inventaire) #Bas affichage(largeurFenetre, hauteurFenetre, largeurInventaire, inventaire, carte) #Afficher la carte à l'écran event = tk.donne_evenement() #Récupérer un évènement typeEvent = tk.type_evenement(event) #Récupérer son type if typeEvent == 'Touche': typeEvent = tk.touche(event) #Récupérer la touche if typeEvent == "d": #Si la touche est 0, fin de boucle break if partieGagnee(carte): break tk.mise_a_jour() #Mise à jour de l'évènement return carte
def updateCursor(ev, canvas, block=None, onPressed=False): """ Met à jour la position du curseur dans la matrice de l'éditeur de niveau. :param tuple ev: Evenement donné par upemtk :param string canvas: ID du canvas cible :param string block: type de bloc :param bool onPressed: condition vraie si le clic de la souris est resté enfoncé """ evType=type_evenement(ev) # print(ev) # print(ui.objects["editorCanvas"]["selected"]) if evType in ("Deplacement", "ClicGauche"): pos=[clic_x(ev), clic_y(ev)] multiSelection=ui.objects["editorCanvas"]["selected"] and len(ui.objects["editorCanvas"]["selected"])>1 squaresMap=ui.objects[canvas]["squaresMap"] if ui.objects[canvas]["ax"] < pos[0] < ui.objects[canvas]["bx"]-1 and ui.objects[canvas]["ay"] < pos[1] < ui.objects[canvas]["by"]-1: x=int((pos[0]-ui.objects[canvas]["ax"])/ui.objects[canvas]["cellSize"]) y=int((pos[1]-ui.objects[canvas]["ay"])/ui.objects[canvas]["cellSize"]) if block: # print("inSquare") if not onPressed: if multiSelection: writeMultipleBlocks(canvas, squaresMap, block) return else: ui.setObject(canvas, {"selected":[(x,y)]}) else: if ui.objects["editorCanvas"]["selected"]: ui.setObject(canvas, {"selected":list(set((*ui.objects["editorCanvas"]["selected"],(x,y))))}) # ui.setObject(canvas, {"selected":[*ui.objects["editorCanvas"]["selected"],(x,y)]}) # Bad memory usage else: ui.setObject(canvas, {"selected":[ui.objects["blockCanvas"]["selected"][0], (x,y)]}) if evType == "ClicGauche": if block: squaresMap[y][x]=block else: ui.setObject(canvas, {"selected":[(x,y),ui.objects["blockCanvas"]["selected"][1]]}) render.update(squaresMap, canvas) else: if block: # print("notinSquare") if multiSelection: writeMultipleBlocks(canvas, squaresMap, block) return # onPressed=False # return onPressed else: ui.setObject(canvas, {"selected":[ui.objects["blockCanvas"]["selected"][0], None]})
def test_pousser_pierre(carte, ev): """ test si une pierre peut etre poussé et return true or false selon le résultat :param list carte: liste 2D contenant le jeu :param upemtk.Event ev: evenement recupere par upemtk.donne_evenement() :return: bool """ type_ev = upemtk.type_evenement(ev) if type_ev == "Touche": t = upemtk.touche(ev) if (t == "Right" and carte[var["pos_y"]][var["pos_x"] + 1] == "P" and carte[var["pos_y"]][var["pos_x"] + 2] == "."): return True if (t == "Left" and carte[var["pos_y"]][var["pos_x"] - 1] == "P" and carte[var["pos_y"]][var["pos_x"] - 2] == "."): return True return False
def enleve_porte(carte, ev, nbdiamand, diamand): """ test si la porte a été ouverte :param list carte: liste 2D contenant le jeu :param upemtk.Event ev: evenement recupere par upemtk.donne_evenement() :param int nb_diamand: nombre de diamant deja recupere en jeu :param int diamand: nombre de diamant requis avant de pouvoir gagner """ type_ev = upemtk.type_evenement(ev) if type_ev == "Touche": t = upemtk.touche(ev) if t in _touche: if (carte[var["pos_y"] + _touche[t][1]][var["pos_x"] + _touche[t][0]] == carte[var["pos_sortie_y"]][var["pos_sortie_x"]] and nbdiamand >= diamand): var["porte"] = 0
def logic(ev): """ Exécute toutes les actions liées à la logique de l'interface, principalement la vérification des clics de la souris sur les boutons. :param tuple ev: Evenement de upemtk """ global focus, exclusiveLayer type_ev = type_evenement(ev) for r in logicRoutines.values(): r[0](*r[1]) if type_ev == "ClicGauche": pos = (clic_x(ev), clic_y(ev)) layers = set(range(len(renderQueue) - 1, 0, -1)) layers.add(0) if exclusiveLayer is None: for l in layers: for p in positions[l]: if checkClick(p, pos): return else: try: for p in positions[exclusiveLayer]: if checkClick(p, pos): return except KeyError as e: print("UI Warning: exclusive layer", e, "is non existent, defaulting to None") exclusiveLayer = None return focus = None elif focus is not None and type_ev == "Touche": if focus["type"] == "textField": key = touche(ev) if len(key) == 1 and key.isalnum(): setObject(focus["ID"], {"text": objects[focus["ID"]]["text"] + key}) #objects[focus["ID"]]["text"] += key elif key == "BackSpace": setObject(focus["ID"], {"text": objects[focus["ID"]]["text"][:-1]}) #objects[focus["ID"]]["text"] = objects[focus["ID"]]["text"][:-1] elif key == "space": setObject(focus["ID"], {"text": objects[focus["ID"]]["text"] + " "})
def attenteMouvement(carte, infoMap): """ Cette fonction s'éxécute sans fin dans l'attente d'une action du joueur (clic, clavier,quitter) Elle retourne le type de la touche """ while True: event = tk.donne_evenement() # objet event de tk typeEvent = tk.type_evenement(event) # type de l'event # Lorsque l'évènement est une touche, on regarde laquelle et on la renvoie if typeEvent == 'Touche': typeEvent = tk.touche(event) if typeEvent in { "Left", "Right", "Up", "Down", "d", "e", "r", "s", "b", "Escape" }: break # Lorsque l'évènement est un autre dans cette liste, pareil elif typeEvent in {"Quitte", "ClicGauche"}: break tk.mise_a_jour() #Mettre à jour les évènements return typeEvent
def deplacer_perso(carte, nbdiamand, ev, diamand, tempstotal, score, tempslumiere): """ Test si le perso peut se deplacer, si oui, deplace le perso sur la carte en fonction de la touche utilisé :param list carte: liste 2D contenant le jeu :param int nb_diamand: nombre de diamant deja recupere en jeu :param upemtk.Event ev: evenement recupere par upemtk.donne_evenement() :param int diamand: nombre de diamant requis avant de pouvoir gagner :param int tempstotal: temps restant de la partie :param str score: score de la partie :param int tempslumiere: restant de lumiere restant :return: nbdiamand, tempstotal, score, tempslumiere """ type_ev = upemtk.type_evenement(ev) if type_ev == "Touche": t = upemtk.touche(ev) if t in _touche: if test_deplacement(carte, t, "D"): deplace(carte, t) return ( nbdiamand + 1, int(tempstotal) + 10, (8 - len((str(int(score) + 350)))) * "0" + (str(int(score) + 350)), tempslumiere, ) if test_deplacement(carte, t, "L"): deplace(carte, t) return nbdiamand, tempstotal, score, tempslumiere + 10 elif test_deplacement(carte, t, {"G", ".", "F"}): deplace(carte, t) return nbdiamand, tempstotal, score, tempslumiere if (nbdiamand >= diamand and test_deplacement(carte, t, "E") and var["porte"] == 0): deplace(carte, t) return nbdiamand, tempstotal, score, tempslumiere return nbdiamand, tempstotal, score, tempslumiere
def _input(msg, reponse_defaut): """ meme fonction que input mais cette fois si s'affiche à l'écran et non sur la console :param str msg: message decrivant linput sur la fenetre :param str reponse_defaut: texte a afficher par defaut dans linput :return: saisie de lutilisateur au clavier (str) """ texte = reponse_defaut while True: ev = upemtk.donne_evenement() type_ev = upemtk.type_evenement(ev) if type_ev == "Touche": x = upemtk.touche(ev) if x == "Return": return texte elif x == "BackSpace": texte = texte[:-1] elif len(x) == 1 and len(texte) <= 18: texte += x elif x in dico_texte: texte += dico_texte[x] elif type_ev == "ClicGauche": return texte upemtk.efface("texte_input") upemtk.texte( var["dimension_fenetre"] // 2, var["dimension_fenetre"] // 2, texte, couleur="white", ancrage="center", tag="texte_input", ) upemtk.mise_a_jour()
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 editor(level=None): """ Lance et fait fonctionner l'éditeur de niveau. :param list level: Niveau à charger """ ui.reset() ui.setBackground("black") initEditorUI() blockMap=[ ["W", "G"], [".", "B"], ["D", "X"], ["R", "E"], ] editorWidth = 20 editorHeight = 12 if level: # squaresMap=[] level=IO.loadLevel(level=level) ui.setObject("timeLeftTextField", {"text": str(level[0][0])}) level=level[1:] ydiff=editorHeight-len(level) xdiff=editorWidth-len(level[0]) for y in range(len(level)): level[y].extend(["." for x in range(xdiff)]) level.extend([["." for y in range(editorWidth)] for y in range(ydiff)]) else: level=[["." for x in range(editorWidth)] for y in range(editorHeight)] render.update(level, "editorCanvas") render.update(blockMap, "blockCanvas") onPressed=False while not evenement.event["game"] == 'return': evenement.compute() ui.logic(evenement.event["tk"]) tkEvent=evenement.getTkEvent() # print(type(ui.objects["blockCanvas"]["selected"])) if ui.focus is None: if ui.exclusiveLayer is None: updateCursor(tkEvent, "editorCanvas", ui.objects["blockCanvas"]["squaresMap"][ui.objects["blockCanvas"]["selected"][0][1]][ui.objects["blockCanvas"]["selected"][0][0]], onPressed) updateCursor(tkEvent, "blockCanvas") # print(evenement.event["game"]) if evenement.event["game"] == "reset": render.update([["." for x in range(editorWidth)] for y in range(editorHeight)], "editorCanvas") # ui.render(game.getFps()) # continue elif evenement.event["game"] == "save": timer.factor = 0 if level: IO.save(ui.objects["editorCanvas"]["squaresMap"], level[1]) else: ui.newPrompt("Nom de la sauvegarde:", "Sauvegarder", success=lambda: IO.save(game.data, ui.objects["prompt_2"]["text"]), checker=IO.checkSaveName, anyway=lambda: timer.setFactor(1)) if type_evenement(tkEvent)=="Deplacement": if "|" in str(tkEvent): onPressed=True else: onPressed=False game.updateTime() ui.render(game.getFps()) mise_a_jour() ui.reset()
def menu_echap(temps, tempslumiere): """ affiche un menu si jamais l'utilisateur à appuyer sur echap et renvoie un des différents choix disponible (retry, continue, sauvegarder, quitter le jeu) :param int temps: temps du jeu en debut de menu afin de le conserver :param int tempslumiere: temps de lumiere restant :return: code de retour, duree de la partie, temps de lumiere """ d = time() while True: esthetique.fond("black") encadrement( "MENU", var["dimension_fenetre"] // 2, 30, "White", "black", 50, 1, 1, "Impact", ) continuer = encadrement( "CONTINUER", var["dimension_fenetre"] // 2, var["dimension_fenetre"] // 5, "White", "white", 36, 1, 5, "Impact", ) sauvegarder = encadrement( "SAUVEGARDER", var["dimension_fenetre"] // 2, 2 * var["dimension_fenetre"] // 5, "White", "white", 36, 1, 5, "Impact", ) recommencer = encadrement( "RECOMMENCER", var["dimension_fenetre"] // 2, 3 * var["dimension_fenetre"] // 5, "White", "white", 36, 1, 5, "Impact", ) quitter = encadrement( "RETOURNER AU MENU", var["dimension_fenetre"] // 2, 4 * var["dimension_fenetre"] // 5, "White", "white", 36, 1, 5, "Impact", ) upemtk.mise_a_jour() ev = upemtk.donne_evenement() type_ev = upemtk.type_evenement(ev) if type_ev == "Quitte": return -1, temps + time() - d, tempslumiere + time() - d if type_ev == "Touche": t = upemtk.touche(ev) if t == "Escape": return 5, temps + time() - d, tempslumiere + time() - d if type_ev == "ClicGauche": coords = [upemtk.clic_x(ev), upemtk.clic_y(ev)] if test_clic(coords, continuer): return 5, temps + time() - d, tempslumiere + time() - d if test_clic(coords, sauvegarder): return 6, temps + time() - d, tempslumiere + time() - d if test_clic(coords, recommencer): return 9, temps + time() - d, tempslumiere + time() - d if test_clic(coords, quitter): return 7, temps + time() - d, tempslumiere + time() - d
def main(): """ Fonction principale du programme """ global largeurFenetre, hauteurFenetre #Limiter les paramètres des fonctions #---------- Initialisation ---------- carte = initialiseCarte() largeurFenetre, hauteurFenetre = generationFenetreEditeur(carte) tk.cree_fenetre(largeurFenetre, hauteurFenetre) selection = (0, 0) # pour savoir quel objet l'utilisateur a selectionné nouvelleSelection = (0, 0) message = [ "", 0 ] # Un message à afficher à l'écran [0] contient le message et [1] contient un boolean d'affichage (0 ou 1) #-------- Fin initialisation -------- # ---- Boucle principale du jeu quitter = False while not (quitter): #Affichage affichageEditeur(carte, selection, message) #Afficher la carte à l'écran #Retirer le message après un clic if message[1] > 0: message[1] = 0 ############ Boucle de Gestion des évènements ############ while True: # Boucle de récupération des évènements ev = tk.donne_evenement() typeEv = tk.type_evenement(ev) if typeEv == "Quitte": # Quand quelqu'un clique sur la croix pour fermer la fenêtre quitter = True break #Sortir de la boucle d'attente elif typeEv == "ClicGauche": nouvelleSelection = gestionClicGauche(ev) break elif typeEv == "ClicDroit": break elif typeEv == "Touche": # ------------ gestion des touches ------------ touche = tk.touche(ev) if touche == "s": # On vérifie la carte, on affiche un message si nécessaire ou on la sauvegarde verification = verifierCarte(carte) if verification[0]: ecritureCarte(carte) message = ["La carte a été sauvegardée !", 1] else: message = verification[1] elif touche == "r": nouvelleSelection = "vide" # pour éviter qu'un nouveau truc se place carte = initialiseCarte() elif touche == "Escape": #touche pour sortir quitter = True break # -------- fin de gestion des touches ------- tk.mise_a_jour() #mise à jour des évènements ############ Fin de gestion des évènements ############ #------ Changements sur le jeu if nouvelleSelection not in { "mur", "cible", "joueur", "porte", "clef", "boite", "vide" }: i, j = nouvelleSelection # on place l'objet sélectionné sur la case carte[i][j] = transformeChaineVersCaractere(selection) else: # si un nouveau truc est sélectionné, on le change selection = nouvelleSelection #------- tk.ferme_fenetre()
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