def display_timer(x, y):
"""
Affiche le timer. Ne le met pas à jour.
"""
utk.efface("timer")
if timer.timer_paused:
utk.image(x + 50, y + 50, "sprites/hourglass_freeze.gif", tag="timer")
else:
utk.image(x + 50, y + 50, "sprites/hourglass.gif", tag="timer")
if timer.timer > 0:
utk.texte(x + 50,
y + 110,
str(int(timer.timer) // 60) + ":" +
str(int(timer.timer % 60)),
couleur="black",
ancrage="center",
police="Purisa",
taille=28,
tag="timer")
else:
utk.texte(x + 50,
y + 110,
"0:0",
couleur="black",
ancrage="center",
police="Purisa",
taille=28,
tag="timer")
def dessinerVictoire(largeurFenetre, hauteurFenetre):
tk.texte(largeurFenetre // 4,
hauteurFenetre // 3,
"Victory !",
'black',
police="Times New Roman",
taille=60)
def display_command(x, y, size):
utk.texte(x,
y,
"""Déplacement : Z,Q,S,D
Sélection : B (pour changer), N (Pour verrouiller)
Mode Debug : F1""",
taille=size)
def render(text=None):
"""
Exécute toutes les actions liées à au rendu de l'interface, principalement la gestion des objets à dessiner puis supprimer de la pile d'affichage.
:param string text: texte affiché au dessus de toute l'interface en bas à gauche (utilisé pour le compteur d'images par seconde)
"""
for r in renderRoutines.values():
r[0](*r[1])
buffer = getToRenderObjects()
if buffer:
for l in buffer:
for ID in l:
if objects[ID]["tkObjects"]:
for t in objects[ID]["tkObjects"]:
efface(t)
if not objects[ID]["hidden"] or not objects[ID]["isChild"]:
drawObject(ID)
l.clear()
setToRenderObjects(buffer)
efface("fps")
if text:
texte(0,
HEIGHT_WINDOW,
str(text) + " fps",
"white",
ancrage="sw",
tag="fps")
def display_save_success():
utk.texte(win_size[0] / 2,
win_size[1] - 200,
"Sauvegarde terminé.",
couleur="green",
ancrage="center",
police="Purisa",
taille="16")
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 loose_screen(self):
upemtk.rectangle(0,
0,
self.size,
self.size,
couleur='',
remplissage='white')
upemtk.texte(self.size / 2,
self.size / 2,
"Loose",
couleur="red",
taille=40)
def victory_screen(self):
upemtk.rectangle(0,
0,
self.size,
self.size,
couleur='',
remplissage='white')
upemtk.texte(self.size / 2,
self.size / 2,
"Victory",
couleur="green",
taille=40)
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 display_discuss(x, y):
utk.image(win_size[0] / 2,
win_size[1] / 2,
"sprites/discuss.gif",
tag="discuss_icon")
utk.texte(x,
y,
"ENTREE pour \nreprendre...",
ancrage="nw",
taille=10,
tag="discuss_info")
display_frame()
def UIecranTitre():
""" Affiche l'écran titre, renvoie True si le joueur charge un ancienne partie, sinon False"""
tk.texte(800, 100, 'MagicMaze, par Théodore Garcher et Simon Eveillé', ancrage = 'center')
tk.rectangle(200, 200, 550, 350, couleur = 'black', remplissage = '#b9b9b9', epaisseur = 3)
tk.texte(375, 275, "Nouvelle Partie", ancrage = 'center')
tk.rectangle(200, 400, 550, 550, couleur = 'black', remplissage = '#b9b9b9', epaisseur = 3)
tk.texte(375, 475, "Charger une partie", ancrage = 'center')
tk.texte(800, 800, "Selectionnez le nombre de joueur avec ↑, ↓ et Entrée", ancrage = 'center' )
# Selecteur
choix = False
entreeClavier = None
while entreeClavier != 'Return':
tk.efface('selecteur')
if not choix :
tk.rectangle(190, 190, 560, 360, couleur = '#565656', remplissage = '', epaisseur = 4, tag = 'selecteur')
else :
tk.rectangle(190, 390, 560, 560, couleur = '#565656', remplissage = '', epaisseur = 4, tag = 'selecteur')
entreeClavier = tk.attente_touche()
if entreeClavier == 'Up':
choix = False
elif entreeClavier == 'Down':
choix = True
return choix
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 still_remaining_options(world: World) -> bool:
solver = NaiveSolver()
current_conf = world.to_configuration()
clue = solver.solve(world)
world.load_configuration(current_conf)
if not clue:
upemtk.texte(HEIGHT // 2,
WIDTH // 2,
"NO MORE OPTION, GAME LOST :(",
couleur="red",
ancrage="center",
taille=40)
upemtk.attend_clic_gauche()
return False
return True
def encadrement(msg, x, y, couleurTXT, couleurCadre, Taille, Epaisseur,
Espacement, polise):
"""
Ecrit et encadre un texte puis donne les coordonnées du cadre (pour clic)
:param str msg: message a encadrer
:param int x: coordonnee x du msg a positionner
:param int y: coordonnee y du msg a positionner
:param str couleurTXT: couleur du msg
:param str couleurCadre: couleur du cadre
:param int Taille: taille du msg
:param int Epaisseur: epaisseur du trait de lencadrement
:param int Espacement: epaissement entre le msg et l'encadrement
:param str polise: police du texte
:return: [x_point_haut_gauche, y_point_haut_gauche, x_point_bas_droit, y_point_bas_droit]
"""
upemtk.texte(10000000,
y,
msg,
couleur=couleurTXT,
police=polise,
taille=Taille)
upemtk.longueur_texte(msg)
x2 = x + upemtk.longueur_texte(msg) // 2 + Espacement
y2 = y + upemtk.hauteur_texte() + Espacement
upemtk.texte(
x - upemtk.longueur_texte(msg) // 2,
y,
msg,
couleur=couleurTXT,
police="Impact",
taille=Taille,
)
upemtk.rectangle(
x - Espacement - upemtk.longueur_texte(msg) // 2,
y - Espacement,
x2,
y2,
couleur=couleurCadre,
epaisseur=Epaisseur,
)
return [
x - upemtk.longueur_texte(msg) // 2 - Espacement, y - Espacement, x2,
y2
]
def display_menu_choice(menu_choice):
"""
Affiche les différents choix du menu.
"""
utk.efface("choice")
for i in range(len(menu_choice)):
choice = menu_choice[i]
if choice == "Nombre de joueur : ":
choice += str(lvl.nbr_of_player)
utk.texte(win_size[0] / 2,
120 + i * 40,
choice,
couleur="white",
ancrage="center",
police="Purisa",
taille="16",
tag="choice")
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 solver_game(lab_path: str, game_type: str, display: bool) -> None:
"""
Start a new game where one of the solver tries to solve the game, and then demonstrate its solution if it can
find one.
:param lab_path: path of the file to parse to create the world.
:param game_type: type of solver that the user wants to use (naive or minimal)
:param display: set to True, the user will visualize all the computations steps made by the solver to find a
solution.
:return: None
"""
if game_type == "naive":
solver = NaiveSolver()
elif game_type == "minimal":
solver = MinimalSolver()
else:
return usage()
world = create_world_from_file(lab_path)
initial_config = world.to_configuration()
view.create_window(world)
view.display(world)
if solver.solve(world, display):
print("Solution found (", len(solver.solution), "moves) !")
solver.display_solution()
world.load_configuration(initial_config)
upemtk.texte(HEIGHT // 2,
WIDTH // 2,
"CLICK TO SEE SOLUTION",
couleur='black',
ancrage='center',
taille=40,
tag="click_to_display")
upemtk.attend_clic_gauche()
upemtk.efface("click_to_display")
view.display(world)
solver.play_game(world)
display_result(world)
else:
print("No solution found...")
upemtk.ferme_fenetre()
def affiche_case(matrice):
'''permet de générer la map à l'aide de la matrice'''
efface_tout()
for i in range(len(matrice)):
for j in range(len(matrice[i])):
#On teste chaque élément pour créer des "classes" pour chaque élément
if matrice[i][j] == 'W':
image(longueur_case * j,
hauteur_case * i,
'Images/mur.png',
ancrage='nw')
if matrice[i][j] == 'J':
image(longueur_case * j,
hauteur_case * i,
'Images/diam_menu.png',
ancrage='nw')
elif matrice[i][j] == 'G':
image(longueur_case * j,
hauteur_case * i,
'Images/sol.png',
ancrage='nw')
elif matrice[i][j] == 'D':
image(longueur_case * j,
hauteur_case * i,
'Images/diamant.png',
ancrage='nw')
elif matrice[i][j] == 'B':
image(longueur_case * j,
hauteur_case * i,
'Images/rocher.png',
ancrage='nw')
elif matrice[i][j] == '.':
image(longueur_case * j,
hauteur_case * i,
'Images/vide.png',
ancrage='nw')
elif matrice[i][j] == 'R':
image(longueur_case * j,
hauteur_case * i,
'Images/perso.png',
ancrage='nw')
elif matrice[i][j] == 'E':
image(longueur_case * j,
hauteur_case * i,
'Images/arriveebloc.png',
ancrage='nw')
elif matrice[i][j] == 'M':
image(longueur_case * j,
hauteur_case * i,
'Images/menu.png',
ancrage='nw')
elif matrice[i][j] == 'F':
image(longueur_case * j,
hauteur_case * i,
'Images/arrivee.png',
ancrage='nw')
upemtk.texte(10, 10, ('Temps:', int(timer)), couleur='yellow')
upemtk.texte(10, 85, ('Score:', score), couleur='yellow')
upemtk.texte(longueur_fenetre - 200, 10, (compteur, 'x'), couleur='yellow')
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 drawText(ID):
"""
Dessine un texte à partir de l'objet donné.
:param string ID: ID de l'objet
"""
if objects[ID]["anchorx"] == "l":
anchor = "w"
elif objects[ID]["anchorx"] == "r":
anchor = "e"
else:
anchor = "center"
return (texte(objects[ID]["x"], objects[ID]["y"], objects[ID]["text"],
objects[ID]["textColor"], objects[ID]["textAnchor"],
objects[ID]["textFont"], objects[ID]["textSize"]), )
def display_result(world: World):
"""
Display a text on the window when the game is in a winning or loosing state.
:param: world : the world attached to the current window view.
"""
if world.game_won():
upemtk.texte(HEIGHT // 2,
WIDTH // 2,
"ARIANE WON",
couleur="blue",
ancrage="center",
taille=40)
upemtk.attend_clic_gauche()
return
if world.game_lost():
upemtk.texte(HEIGHT // 2,
WIDTH // 2,
"ARIANE LOST",
couleur="red",
ancrage="center",
taille=40)
upemtk.attend_clic_gauche()
return
def init_menu():
"""
Initialise le menu
"""
utk.rectangle(0,
0,
win_size[0],
win_size[1],
couleur="black",
remplissage="black",
epaisseur=1,
tag="background")
utk.texte(win_size[0] / 2,
60,
"Magic-Maze",
couleur="white",
ancrage="center",
police="Purisa",
taille="40",
tag="title")
display_menu(0, ())
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 drawButton(ID):
"""
Dessine un bouton à partir de l'objet donné.
:param string ID: ID de l'objet
"""
return (polygone([(objects[ID]["ax"] + x * objects[ID]["width"],
objects[ID]["ay"] + y * objects[ID]["height"])
for x, y in objects[ID]["polygonal"]],
objects[ID]["outlineColor"], objects[ID]["fill"],
objects[ID]["stroke"]) if objects[ID]["polygonal"] else
rectangle(objects[ID]["ax"], objects[ID]["ay"], objects[ID]["bx"],
objects[ID]["by"], objects[ID]["outlineColor"],
objects[ID]["fill"], objects[ID]["stroke"]),
texte(objects[ID]["ax"] + objects[ID]["width"] / 2,
objects[ID]["ay"] + objects[ID]["height"] / 2,
objects[ID]["text"], objects[ID]["textColor"], "center",
objects[ID]["textFont"], objects[ID]["textSize"]))
def drawTextField(ID):
"""
Dessine un champ de texte modifiable à partir de l'objet donné.
:param string ID: ID de l'objet
"""
# if objects[ID]["text"]:
# while longueur_texte(objects[ID]["text"][-i:])>objects[ID]["width"]:
# i+=1
return (rectangle(objects[ID]["ax"], objects[ID]["ay"], objects[ID]["bx"],
objects[ID]["by"], objects[ID]["outlineColor"],
objects[ID]["fill"], objects[ID]["stroke"]),
texte(objects[ID]["ax"],
(objects[ID]["ay"] +
(objects[ID]["by"] - objects[ID]["ay"]) / 2),
objects[ID]["text"][-objects[ID]["maxChar"]:],
objects[ID]["textColor"],
taille=objects[ID]["textSize"],
ancrage="w",
police=objects[ID]["textFont"]))
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 affichageTelekinesie(tuilesPosees, telekinesieIndexTuileActive, telekinesiesRestantes):
"""Affiche la tuile selectionnée durant la télékinésie"""
numTuile = str(tuilesPosees[telekinesieIndexTuileActive[0]])
if numTuile == '0':
numTuile = 'aucune'
tk.texte(900, 10, "Télékinésie de l'elfe activée\nTuile sélectionnée : " + numTuile + "\nActivations restantes : " + str(telekinesiesRestantes[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 draw_winnable():
upemtk.texte(0, 0, "Winnable", couleur='green', taille=30)
def draw_loosed():
upemtk.texte(0, 0, "Not winnable", couleur='red', taille=30)
