def display_selected_ingame(x, y, select_value, list_choice, tag_name="default"): """ Affiche le pion sélectionné en jeu. """ utk.efface(tag_name) utk.image(x + 20, y + 10, "sprites/select_arrow_up.gif", tag=tag_name) utk.image(x + 20, y + len(list_choice) * 40 + 30, "sprites/select_arrow_down.gif", tag=tag_name) for i in range(len(list_choice)): utk.rectangle(x, y + i * 40 + 20, x + 40, y + (i + 1) * 40 + 20, couleur="black", remplissage="cyan" * (i == select_value), epaisseur=2, tag=tag_name) utk.image(x + 20, y + i * 40 + 40, "sprites/" + list_choice[i] + ".gif", tag=tag_name)
def dessinerMur(x, y, largeurCase): #Dessine le mur largeurBrique = largeurCase / 2 hauteurBrique = largeurCase / 4 X, Y = 0, 0 for i in range(4): for j in range(2): if i % 2 == 0: tk.rectangle(x + X, y + Y, x + largeurBrique + X, y + hauteurBrique + Y, "white", "brown") else: tk.rectangle(x + X + largeurBrique / 2, y + Y, x + largeurBrique * 1.5 + X, y + hauteurBrique + Y, "white", "brown") tk.rectangle(x + X, y + Y, x + X + largeurBrique / 2, y + hauteurBrique + Y, "white", "brown") tk.rectangle(x + largeurBrique * 1.5 + X, y + Y, x + 2 * largeurBrique, y + hauteurBrique + Y, "white", "brown") break X += largeurBrique X = 0 Y += hauteurBrique tk.rectangle(x, y, x + largeurCase, y + largeurCase, 'black', '') # Le contour de la case
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 affichageV2(carte, nbdiamand, diamand, taille, x_, y_, nbrcase): """ Affiche la carte dans le menu des map :param list carte: liste 2D contenant le jeu :param int nb_diamand: :param int diamand: :param int taille: taille des cases :param int x_: position de l'apercu de la map :param int y_ position de l'apercu de la map :param int nbrcase: nombre de case a afficher sur l'apercu """ esthetique.fond("black") for y in range(len(carte) - 1, -1, -1): # y = ligne for x in range(len(carte[y]) - 1, -1, -1): # x = colonne dico[carte[y][x]]( (x + (var["nb_cases"] // 2 - var["pos_x"])) + x_, (y + (var["nb_cases"] // 2 - var["pos_y"])) + y_, taille, nbdiamand, diamand, "goldenrod3", ) # centre le perso upemtk.rectangle( x_ * taille + nbrcase * taille + 2 * taille, y_ * taille, var["dimension_fenetre"], var["dimension_fenetre"] + 100, remplissage="black", ) upemtk.rectangle( x_ * taille, y_ * taille + nbrcase * taille + 2 * taille, var["dimension_fenetre"], var["dimension_fenetre"] + 100, remplissage="black", ) upemtk.rectangle( x_ * taille, y_ * taille, x_ * taille + 2 * taille, var["dimension_fenetre"] + 100, remplissage="black", ) upemtk.rectangle( x_ * taille, y_ * taille, var["dimension_fenetre"], y_ * taille + 3 * taille, remplissage="black", ) upemtk.rectangle( x_ * taille + 2 * taille, y_ * taille + 3 * taille, x_ * taille + nbrcase * taille + 2 * taille + 5, y_ * taille + nbrcase * taille + 2 * taille + 5, couleur="gold", epaisseur=10, )
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 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 dessinerBoite(x, y, largeurCase, couleurCroix="brown"): #Dessine un petit carré distanceAuBord = largeurCase / 4 tk.rectangle(x + distanceAuBord, y + distanceAuBord, x + largeurCase - distanceAuBord, y + largeurCase - distanceAuBord, "brown", "#ffa724", 2, tag="Carre-Boite") dessinerCroix(x + distanceAuBord, y + distanceAuBord, largeurCase - distanceAuBord * 2, couleurCroix, 2)
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 init_pause(): """ Initialise le menu de pause. """ utk.rectangle(200, 100, win_size[0] - 200, win_size[1] - 100, couleur="black", remplissage="grey", epaisseur=5, tag="background") display_pause(0, ("Reprendre", "Sauvegarder", "Quitter"))
def display_menu_selection(selected): """ Affiche la sélection du menu """ utk.efface("selection") utk.rectangle(win_size[0] / 2 - 150, selected * 40 + 105, win_size[0] / 2 + 150, selected * 40 + 135, couleur="grey", remplissage="grey", epaisseur=1, tag="selection")
def dessinerPorte(x, y, largeurCase): #Dessine une porte centreDuCercleX = x + largeurCase / 2 centreDuCercleY = y + largeurCase / 2.5 rayon = (largeurCase / 3) // 2 tk.rectangle(x, y, x + largeurCase, y + largeurCase, 'black', '#339933') # Le reste de la case tk.cercle(centreDuCercleX, centreDuCercleY, rayon, 'black', 'black', 2) #Le rond de la serrure largeurRectangle1 = rayon / 3 #la serrure tk.rectangle(centreDuCercleX - largeurRectangle1, centreDuCercleY - 10 + rayon, centreDuCercleX + largeurRectangle1, centreDuCercleY - 10 + rayon + largeurCase // 3, 'black', 'black')
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 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 affiche_map(carte, **kwargs): """ affiche la map en cours de creation :param list carte: liste 2D contenant le jeu """ if "nbdiamand" not in kwargs: kwargs["nbdiamand"], kwargs["diamand"] = 0, 0 esthetique.fond("white") upemtk.rectangle( 0, 0, var["w_map"] * var["taille_case"], var["h_map"] * var["taille_case"], remplissage="black", ) for j in range(var["h_map"]): for i in range(var["w_map"]): fonction.dico[carte[j][i]](i, j, var["taille_case"], kwargs["nbdiamand"], kwargs["diamand"], "goldenrod3")
def drawPanel(ID): """ Dessine un panneau à partir de l'objet donné. :param string ID: ID de l'objet """ returnValue = (rectangle(objects[ID]["ax"], objects[ID]["ay"], objects[ID]["bx"], objects[ID]["by"], objects[ID]["outlineColor"], objects[ID]["fill"], objects[ID]["stroke"]), ) for c in objects[ID]["childs"]: #Problem drawObject(c) return returnValue
def dessinerClef(x, y, largeurCase): #Dessine une clef rayon = largeurCase / 4 espacementX = largeurCase / 3 - rayon espacementY = largeurCase / 2 - rayon #Cercle: positionX_cercle = x + espacementX + rayon positionY_cercle = y + espacementY + rayon tk.cercle(positionX_cercle, positionY_cercle, rayon, "#339933", "#339933") #Rectangle principal hauteurRectangle = rayon / 2.8 tk.rectangle(positionX_cercle, positionY_cercle - hauteurRectangle, x + largeurCase - espacementX, positionY_cercle + hauteurRectangle, "#339933", "#339933") #Rectangles secondaires: PositionBDX_Rectangle2 = x + largeurCase - espacementX PositionBDY_Rectangle2 = y + largeurCase - espacementY - hauteurRectangle PositionHGX_Rectangle2 = PositionBDX_Rectangle2 - hauteurRectangle PositionHGY_Rectangle2 = y + espacementY + rayon + hauteurRectangle tk.rectangle(PositionHGX_Rectangle2, PositionHGY_Rectangle2, PositionBDX_Rectangle2, PositionBDY_Rectangle2, "#339933", "#339933") tk.rectangle(PositionHGX_Rectangle2 - 1.5 * espacementX, PositionHGY_Rectangle2, PositionBDX_Rectangle2 - 1.5 * espacementX, PositionBDY_Rectangle2, "#339933", "#339933")
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 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 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
def dessinerInventaire(x, y, largeur, hauteur): tk.rectangle(x, y, x + largeur, y + hauteur, 'black', 'black')
def drawCanvas(ID): """ Dessine un canevas à partir de l'objet donné. :param string ID: ID de l'objet """ if len(objects[ID]["squaresMap"]): if len(objects[ID]["squaresMap"] [0]) * objects[ID]["cellSize"] < objects[ID]["width"]: setObject( ID, { "width": len(objects[ID]["squaresMap"][0]) * objects[ID]["cellSize"] + 1 }) if (len(objects[ID]["squaresMap"]) ) * objects[ID]["cellSize"] < objects[ID]["height"]: setObject( ID, { "height": (len(objects[ID]["squaresMap"])) * objects[ID]["cellSize"] + 1 }) if len(objects[ID]["squaresMap"] [0]) * objects[ID]["cellSize"] > objects[ID]["width"]: setObject( ID, { "width": len(objects[ID]["squaresMap"][0]) * objects[ID]["cellSize"] + 1 }) if (len(objects[ID]["squaresMap"]) ) * objects[ID]["cellSize"] > objects[ID]["height"]: setObject( ID, { "height": (len(objects[ID]["squaresMap"])) * objects[ID]["cellSize"] + 1 }) # if len(objects[ID]["squaresMap"]): # if len(objects[ID]["squaresMap"][0])*CELL_SIZE < objects[ID]["width"]: # bx = objects[ID]["ax"] + len(objects[ID]["squaresMap"][0])*CELL_SIZE # setObject(ID, {"bx": bx}) # print("changed") # if (len(objects[ID]["squaresMap"])-1)*CELL_SIZE < objects[ID]["height"]: # by = objects[ID]["ay"] + (len(objects[ID]["squaresMap"])-1)*CELL_SIZE # setObject(ID, {"by": by}) # print("changed") identifierList = [ rectangle(objects[ID]["ax"], objects[ID]["ay"], objects[ID]["bx"], objects[ID]["by"], objects[ID]["outlineColor"], objects[ID]["fill"], objects[ID]["stroke"]) ] for y in range(len(objects[ID]["squaresMap"])): for x in range(len(objects[ID]["squaresMap"][y])): x1, y1 = toCanvasCoord(ID, x, y) identifierList.extend(renderCase[objects[ID]["squaresMap"][y][x]]( (x1 + 1, y1 + 1), objects[ID]["cellSize"] - 2)) if objects[ID]["selected"]: for p in objects[ID]["selected"]: if p: x, y = p[0], p[1] identifierList.append(renderCase["S"](toCanvasCoord(ID, x, y), objects[ID]["cellSize"], objects[ID]["fill"])) return tuple(identifierList)
def my_input(msg, type_retour, reponse_defaut=""): """ affichage de l'input :param str msg: message decrivant linput sur la fenetre :param str type_retour: ("int", "str") :param str reponse_defaut: texte a afficher par defaut dans linput :return: texte saisie par lutilisateur respectant le type voulu """ upemtk.rectangle( var["dimension_fenetre"] // 2 - 180, var["dimension_fenetre"] // 2 - 100, var["dimension_fenetre"] // 2 + 180, var["dimension_fenetre"] // 2 + 100, couleur="gray28", remplissage="gray", epaisseur=5, tag="cadre", ) while True: upemtk.texte( var["dimension_fenetre"] // 2, var["dimension_fenetre"] // 2 - 50, msg, couleur="white", ancrage="center", tag="msg", ) _var = _input(msg, reponse_defaut) if type_retour == "int": if _var.isdigit(): if int(_var) < 500 and int(_var) >= 0: upemtk.efface("msg") upemtk.efface("msg_erreur") upemtk.efface("texte_input") upemtk.efface("cadre") return int(_var) elif int(_var) == 0: upemtk.efface("msg_erreur") upemtk.texte( var["dimension_fenetre"] // 2, var["dimension_fenetre"] // 2 + 75, "Valeur trop petite", couleur="red", ancrage="center", police="impact", tag="msg_erreur", ) else: upemtk.efface("msg_erreur") upemtk.texte( var["dimension_fenetre"] // 2, var["dimension_fenetre"] // 2 + 75, "Valeur trop grande", couleur="red", ancrage="center", police="impact", tag="msg_erreur", ) else: upemtk.efface("msg_erreur") upemtk.texte( var["dimension_fenetre"] // 2, var["dimension_fenetre"] // 2 + 75, "Valeur entiere requis", couleur="red", ancrage="center", police="impact", tag="msg_erreur", ) else: upemtk.efface("msg") upemtk.efface("msg_erreur") upemtk.efface("texte_input") upemtk.efface("cadre") return _var
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 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()