def levelSelectionMenu():
"""
Fait fonctionner le menu de sélection d'un niveau enregistré.
"""
goInBlack()
levels = IO.getLevels("level")
levelSelected = 0
level = IO.loadLevel(level=levels[0])
game.initSelectionLevel(level)
moveRender(levels, levelSelected, IO.loadLevel)
while not evenement.event["game"] == 'return':
evenement.compute()
ui.logic(evenement.event["tk"])
if evenement.event["game"] == "right":
levelSelected = move(levelSelected, levels, 1, IO.loadLevel)
elif evenement.event["game"] == "left":
levelSelected = move(levelSelected, levels, -1, IO.loadLevel)
elif evenement.event["game"] == "play":
goInBlack()
game.play(levels[levelSelected], "s")
backInBlack(game.initSelectionLevel, [levels[levelSelected]])
moveRender(levels, levelSelected, IO.loadLevel)
elif evenement.event["game"] == "edit":
goInBlack()
editor.editor(levels[levelSelected])
backInBlack(game.initSelectionLevel, [levels[levelSelected]])
moveRender(levels, levelSelected, IO.loadLevel)
game.updateTime()
animation.update()
ui.render(game.getFps())
mise_a_jour()
backInBlack(game.initPlayMenu)
def levelSaveMenu():
"""
Fait fonctionner le menu de sélection d'une sauvegarde.
"""
goInBlack()
levels = IO.getLevels("save")
levelSelected = 0
level = IO.loadSave(levels[0])
game.initSaveLevel(level)
moveRender(levels, levelSelected, IO.loadSave)
while not evenement.event["game"] == 'return':
evenement.compute()
ui.logic(evenement.event["tk"])
if evenement.event["game"] == "right":
levelSelected = move(levelSelected, levels, 1, IO.loadSave)
elif evenement.event["game"] == "left":
levelSelected = move(levelSelected, levels, -1, IO.loadSave)
elif evenement.event["game"] == "play":
goInBlack()
game.play(levels[levelSelected], "l")
backInBlack(game.initSaveLevel, [levels[levelSelected]])
moveRender(levels, levelSelected, IO.loadSave)
game.updateTime()
animation.update()
ui.render(game.getFps())
mise_a_jour()
backInBlack(game.initPlayMenu)
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 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 afficherPlateau(matriceTerrain, mursHor, mursVer, infoPion ,listeGagnants, pionActif, debugActif, sortieActive, heureDebut, dureeTotalePartie, modifTemps, vortexActif, dicVortex, touchesPartie, touchesPartieParJoueur, matriceTuiles, modeTelekinesie, tuilesPosees, telekinesieIndexTuileActive, telekinesiesRestantes):
"""
Affiche le terrain en entier et l'interface.
Args:
matriceTerrain (list): matrice qui encode le terrain
infoPion (list): Infos de position des pions
listeGagnants (list): liste des pions ayant gagné
Returns:
None.
"""
#Calcul du temps restant
tempsRestant = dureeTotalePartie-time()+heureDebut + modifTemps[0]
tempsEcoule = dureeTotalePartie - tempsRestant
# Renversement du sablier si un pion se trouve sur une case sablier
if pionSurSablier(matriceTerrain, infoPion):
if tempsRestant > tempsEcoule:
modifTemps[0] += ((tempsRestant - tempsEcoule) * (-1))
else:
modifTemps[0] += (tempsEcoule - tempsRestant)
# Affichage de l'interface
tk.rectangle(0, 0, 1300, 1000, couleur = 'black', remplissage = 'grey')
if debugActif == 1:
tk.texte(180, 700, "Mode debug activé\nO: Changer la vitesse\nP: Quitter mode debug", taille = 28,couleur = 'red')
if sortieActive:
tk.texte(1320, 50, "Sortie activée ! Rendez vous à la sortie !", taille = 24, couleur = 'light green')
tk.texte(10, 10, "Backspace : Sauvegarder et quitter")
affichagePionsInterface(touchesPartieParJoueur)
affichageTouches(touchesPartieParJoueur)
affichagePionActif(pionActif)
# Affichage du terrain et des pions
# listeCoordonnee = [tuple([ligne, colonne]) for ligne in range(len(matriceTerrain)) for colonne in range(len(matriceTerrain[0]))]
# affichageCellulePlateau(listeCoordonnee, matriceTerrain)
# affichageMurs(mursHor, mursVer)
affichageTuiles(matriceTuiles)
for pion in range(1,8):
if pion not in listeGagnants:
if pion in infoPion.keys():
afficherPion(pion, infoPion, matriceTuiles)
if vortexActif != [0]:
affichageVortexActif(pionActif[touchesPartie['vortex'][1]], vortexActif, dicVortex, matriceTuiles)
if modeTelekinesie != [0]:
affichageTelekinesie(tuilesPosees, telekinesieIndexTuileActive, telekinesiesRestantes)
tk.mise_a_jour()
# Gestion défaite
if tempsRestant >= 0: # Partie en cours
# Affichage du temps restant
tk.efface('chronometre')
tk.texte(1320, 10, str(int(tempsRestant))+" secondes restantes", taille = 24, tag = 'chronometre')
return False, tempsRestant
else: # Partie terminée
return True, tempsRestant
def display_lose():
utk.texte(win_size[0] / 2,
win_size[1] / 2,
"Vous avez perdu...",
couleur="red",
ancrage="center",
police="Purisa",
taille=56)
utk.mise_a_jour()
def display_win():
"""
Affiche 'Vous avez gagné !'
"""
utk.texte(win_size[0] / 2,
win_size[1] / 2,
"Vous avez gagné !",
couleur="lime",
ancrage="center",
police="Purisa",
taille=56)
utk.mise_a_jour()
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 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 choicePlaystyleMenu():
"""
Fait fonctionner le menu de sélection du mode de jeu.
"""
while not evenement.event["game"] == 'return':
evenement.compute()
ui.logic(evenement.event["tk"])
# home:play:selection
if evenement.event["game"] == 'selection':
levelSelectionMenu()
# home:play:save
if evenement.event["game"] == 'save':
levelSaveMenu()
# home:play:random
if evenement.event["game"] == 'play':
goInBlack()
game.play(mode="r")
backInBlack(game.initPlayMenu)
game.updateTime()
ui.render(game.getFps())
mise_a_jour()
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 scoresMenu():
scores = IO.loadScore()
levels = [key for key in scores["s"]]
selected = 0
game.initScores(scores)
while not evenement.event["game"] == 'return':
evenement.compute()
ui.logic(evenement.event["tk"])
if evenement.event["game"] == "up":
selected += 1
for i in range(4):
ui.setObject(
"ltext" + str(i + 1), {
"text":
levels[(selected + i) % len(levels)] + " - " +
str(scores["s"][levels[(selected + i) %
len(levels)]][0]) + "\n\t" +
scores["s"][levels[(selected + i) % len(levels)]][1]
})
elif evenement.event["game"] == "down":
selected -= 1
for i in range(4):
ui.setObject(
"ltext" + str(i + 1), {
"text":
levels[(selected + i) % len(levels)] + " - " +
str(scores["s"][levels[(selected + i) %
len(levels)]][0]) + "\n\t" +
scores["s"][levels[(selected + i) % len(levels)]][1]
})
game.updateTime()
animation.update()
ui.render(game.getFps())
mise_a_jour()
game.initMenuUI()
while not evenement.event["game"] == 'return':
# ev=donne_evenement()
# if ev[0]!='RAS':
# print(ev)
evenement.compute()
ui.logic(evenement.event["tk"])
# home:play
if evenement.event["game"] == 'play':
goInBlack(game.initPlayMenu)
choicePlaystyleMenu()
backInBlack(game.initMenuUI)
# home:editor
elif evenement.event["game"] == 'editor':
goInBlack()
editor.editor()
backInBlack(game.initMenuUI)
elif evenement.event["game"] == 'score':
goInBlack()
scoresMenu()
backInBlack(game.initMenuUI)
game.updateTime()
animation.update() # /!\ render.updateAnimations before ui.render
ui.render(game.getFps())
mise_a_jour()
###############################################################################
###############################################################################
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 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 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 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 main():
# Initialisation
global in_menu, playing
debug_mode = False
all_input = ("a", "z", "q", "s", "w", "t", "g", "y", "h", "b", "colon",
"o", "l", "p", "m", "8", "5", "9", "6", "2", "Up", "Down",
"Left", "Right", "Return")
selection = 0
display.init_game()
display.init_menu()
while True:
input = utk.attente_touche_jusqua(100 - 100 * debug_mode)
# Gestion du menu
if lvl.menu_loop:
print("input :", input)
menu.main_menu(input)
timer.update_timer()
# Gestion en jeu
elif lvl.playing_loop:
##### Parti debug #####
if input == "F1":
debug_mode = not debug_mode
if debug_mode:
input = all_input[random.randint(0, len(all_input) - 1)]
##### Fin parti debug #####
print("input :", input)
if input is not None:
if lvl.discussing:
lvl.discussing = False
display.efface_discuss()
elif lvl.player_using_vortex != -1:
vortex_selection(input)
elif lvl.player_using_spell != -1:
spell_target_selection(input)
elif menu.paused == True:
menu.pause_menu(input)
else:
player_choose(input)
check_steal(input)
if input == "Escape":
print("affichage du menu pause")
menu.activate_pause_menu()
timer.update_timer()
check_steal()
refresh_display()
display.display_frame()
utk.mise_a_jour()
if check_exit() or check_timer() or (lvl.playing_loop and check_guard_catch()) \
or input == "F4" or (not lvl.menu_loop and not lvl.playing_loop):
break
end_game()
utk.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