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)