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