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()
