def player_game(lab_path: str) -> None:
"""
Start a new game where the player controls Ariane. The world is loaded using the file whose path has been provided.
:param lab_path: path of the file to parse to create the world
:return: None
"""
canceled_last_move = False
world = create_world_from_file(lab_path)
world.save_game_state()
if world.load_save():
print("Save has been loaded!")
view.create_window(world)
view.display(world)
while True:
# If the player has no more chance of winning, the game is stopped
if not still_remaining_options(world):
break
ev = upemtk.attend_ev()
tev = upemtk.type_ev(ev)
if tev == 'Quitte':
break
if tev == 'Touche':
key = touche(ev)
if key == 'c':
if not canceled_last_move:
world.cancel_move(view)
canceled_last_move = True
continue
else:
canceled_last_move = False
if key == 's':
world.create_save()
direction = get_dir_from_string(key)
if not world.move_ariane(direction):
continue
world.move_thesee()
view.display(world)
if world.game_won():
display_result(world)
break
world.move_minos(view)
if world.game_lost():
display_result(world)
break
world.save_game_state()
upemtk.ferme_fenetre()
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()
def solver_game(lab_path: str, game_type: str, display: bool) -> None:
"""
Start a new game where one of the solver tries to solve the game, and then demonstrate its solution if it can
find one.
:param lab_path: path of the file to parse to create the world.
:param game_type: type of solver that the user wants to use (naive or minimal)
:param display: set to True, the user will visualize all the computations steps made by the solver to find a
solution.
:return: None
"""
if game_type == "naive":
solver = NaiveSolver()
elif game_type == "minimal":
solver = MinimalSolver()
else:
return usage()
world = create_world_from_file(lab_path)
initial_config = world.to_configuration()
view.create_window(world)
view.display(world)
if solver.solve(world, display):
print("Solution found (", len(solver.solution), "moves) !")
solver.display_solution()
world.load_configuration(initial_config)
upemtk.texte(HEIGHT // 2,
WIDTH // 2,
"CLICK TO SEE SOLUTION",
couleur='black',
ancrage='center',
taille=40,
tag="click_to_display")
upemtk.attend_clic_gauche()
upemtk.efface("click_to_display")
view.display(world)
solver.play_game(world)
display_result(world)
else:
print("No solution found...")
upemtk.ferme_fenetre()
def 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()
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 stop(self):
upemtk.ferme_fenetre()
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()