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
