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 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 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 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
