def gestionClicGauche(clic):
#Utilise l'objet évènement qui contient un clic, retourne l'objet de la barre d'édition séléctionné ou les coordonnées d'une case ou None
x = tk.clic_x(clic)
y = tk.clic_y(clic)
if x < largeurFenetre - largeurEditeur: # le clic est sur la carte
return y // largeurCase, x // largeurCase
else: # le clic est sur la fenêtre d'édition
# la position par défaut des objets avant d'appliqué le coefficient
objet_x = largeurFenetre - largeurEditeur + largeurCase // 2
objet_y = largeurCase * 1.5
# détection de quel objet est touché par le clic
if toucher(x, y, objet_x, objet_y, 0):
return "mur"
elif toucher(x, y, objet_x, objet_y, 1):
return "cible"
elif toucher(x, y, objet_x, objet_y, 2):
return "joueur"
elif toucher(x, y, objet_x, objet_y, 3):
return "porte"
elif toucher(x, y, objet_x, objet_y, 4):
return "clef"
elif toucher(x, y, objet_x, objet_y, 5):
return "boite"
else:
return "vide"
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 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 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 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():
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