def main():
""" Fonction principale du programme """
#---------- Initialisation ----------
numeroDeMap = "Edited" # le numéro de la map à lire (changeable)
carte, inventaire = initialisationMap(numeroDeMap)
carte_debut = [list(l) for l in carte]
largeurFenetre, hauteurFenetre, largeurInventaire = generationFenetre(
carte)
infoMap = [
largeurFenetre, hauteurFenetre, largeurInventaire
] #Stockage des infos dans une liste pour limiter le nombre de paramètres envoyés aux fonctions
tk.cree_fenetre(largeurFenetre, hauteurFenetre)
#-------- Fin initialisation --------
# -- boucle de jeu
while True:
affichage(largeurFenetre, hauteurFenetre, largeurInventaire,
inventaire, carte)
# conditions de sortie
if partieGagnee(carte):
dessinerVictoire(largeurFenetre, hauteurFenetre)
tk.attente_clic()
break
#Gestion des touches
typeEvent = attenteMouvement(carte, infoMap)
if typeEvent == "r": #commande pour revenir à la précédante sauvegarde
carte, inventaire = recharger()
continue
elif typeEvent == "s": #commande de sauvegarde
ecritureFichierSauvegarde(carte, inventaire)
continue
elif typeEvent == "b": #commande de reset
carte = [list(l) for l in carte_debut]
inventaire["nbClefs"], inventaire["nbCoups"] = 0, 0
continue
#Touches pour quitter le jeu
elif typeEvent == "Quitte" or typeEvent == "Escape":
break
carte = typeMouvement(
typeEvent, carte, infoMap,
inventaire) #Modifications de la carte par rapport à la touche
tk.ferme_fenetre()
tk.cercle(x + cstCentrage, y + cstCentrage, rayon, "red", "#ff5050", 2)
tk.cercle(x + cstCentrage, y + cstCentrage, rayon / 1.2, "red", "#ff5050",
2)
def dessinerVictoire(largeurFenetre, hauteurFenetre):
tk.texte(largeurFenetre // 4,
hauteurFenetre // 3,
"Victory !",
'black',
police="Times New Roman",
taille=60)
if __name__ == '__main__':
""" Ce programme sert à tester les différentes fonctions de dessin """
tk.cree_fenetre(300, 300)
dessinerQuadrillage(300, 300, 100,
[['.', '.', '.'], ['.', '.', '.'], ['.', '.', '.']])
dessinerMur(0, 0, 100)
dessinerClef(100, 0, 100)
dessinerCible(0, 100, 100)
dessinerBoite(100, 100, 100)
dessinerJoueur(0, 200, 100)
dessinerPorte(100, 200, 100)
tk.attente_clic()
tk.ferme_fenetre()
def init_game():
"""
Charge la fenetre.
"""
utk.cree_fenetre(win_size[0], win_size[1])
def start(self):
upemtk.cree_fenetre(self.size, self.size)
self.get_images() # TODO : FIND A BETTER WAY TO INIT THIS IMAGES
def main():
""" Fonction principale """
#### Définition des constantes et initialisation des variables ###########
# info sur le contenu des cellules
matriceTerrain, matriceTuiles, mursVer, mursHor = creerMatriceTerrain()
tuilesRestantes = [i for i in range(2, 10)]
infoPion = dict() # info sur la position des pion
initPions(1, (24, 24), infoPion)
initPions(2, (25, 25), infoPion)
initPions(3, (25, 24), infoPion)
initPions(4, (24, 25), infoPion)
dicEsc = {(25, 26): (26, 25), (26, 25): (25, 26)}
dicTuile2 = defDicTuile2()
dicTuile7 = defDicTuile7()
#initialisé à 0 (inactif), passe à 1 si actif
#on utilise une liste car objet mutable (dégueux mais pratique)
modeVortex = [0]
#roulement entre 0 (aucun portail selectionné) et les autres portails accessibles
vortexActif = [0]
tuilesPosees = [0, 1]
modeTelekinesie = [0]
telekinesieIndexTuileActive = [0]
telekinesiesRestantes = [2]
dicVortex = {1: [(23, 26)], 2: [(24, 26)], 3: [(26, 23)], 4: [(25, 23)]}
sortieActive = False
partiePerdue = False
partieGagnee = False
dureeTotalePartieInitiale = 180 # En secondes
tempsRestant = dureeTotalePartieInitiale
modifTemps = [0]
listeGagnants = []
debugActif = -1 # -1 -> vdésactivé ; 1 -> activé
vitesse = 1 / 500 # Vitesse du mode debug
#### Ouverture de la fenêtre #############################################
tk.cree_fenetre(1900, 1000)
#### Demander au joueur ce qu'il faut faire ##############################
chargerSave = UIecranTitre()
#### Choix du nombre de joueur ###########################################
touchesDeBase = defTouchesDeBase()
if not chargerSave:
nb_joueurs = UIchoixNbrJoueur()
touchesTotales = attributionDesTouches(nb_joueurs, touchesDeBase)
touchesPartieParJoueur = touchesTotales[0]
touchesPartie = touchesTotales[1]
else:
matriceTerrain, infoPion, nb_joueurs, sortieActive, tempsRestant, touchesPartie, touchesPartieParJoueur, listeGagnants, matriceTuiles, mursVer, mursHor, tuilesPosees, dicVortex, dicEsc, telekinesiesRestantes = chargerPartie(
)
for tuile in tuilesPosees:
if tuile in tuilesRestantes:
tuilesRestantes.remove(tuile)
pionActif = dict()
for i in range(1, nb_joueurs + 1):
pionActif[i] = 1
#### Entrée dans le jeu ##################################################
heureDebut = time()
dureeTotalePartie = tempsRestant
while True: # Boucle Principale
tempsPause = gestionEntreeClavier(
matriceTerrain, mursVer, mursHor, infoPion, pionActif,
sortieActive, debugActif, vitesse, listeGagnants, dicVortex,
dicEsc, dicTuile2, dicTuile7, modeVortex, vortexActif,
touchesPartie, touchesPartieParJoueur, nb_joueurs, touchesDeBase,
tempsRestant, matriceTuiles, tuilesRestantes, tuilesPosees,
telekinesieIndexTuileActive, modeTelekinesie,
telekinesiesRestantes)
heureDebut = heureDebut + tempsPause
if not sortieActive: # Si les sorties ne sont pas activées on regarde si on peut les activer
sortieActive = pionSurObjet(matriceTuiles, matriceTerrain,
infoPion)
# Mise à jour de l'image, gestion de la victoire/défaite
tk.efface_tout()
partiePerdue, tempsRestant = afficherPlateau(
matriceTerrain, mursHor, mursVer, infoPion, listeGagnants,
pionActif, debugActif, sortieActive, heureDebut, dureeTotalePartie,
modifTemps, vortexActif, dicVortex, touchesPartie,
touchesPartieParJoueur, matriceTuiles, modeTelekinesie,
tuilesPosees, telekinesieIndexTuileActive, telekinesiesRestantes)
partieGagnee = verifVictoire(listeGagnants)
if partieGagnee or partiePerdue:
break
# Affichage des messages de victoire/défaite
finPartie(partieGagnee, partiePerdue)
tk.attente_clic_ou_touche()
tk.ferme_fenetre()
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()