def __init__(self, width, height): tk.Frame.__init__(self, bg='black') self.grid() self.agrandir = 40 self.width = width * self.agrandir self.height = height * self.agrandir self.taille_case = int(self.width / width) self.canvas = tk.Canvas(self, width=self.width, height=self.height) self.canvas.grid() L = Labyrinthe(width, height) p_initiale = position_initiale(L) print("La position initiale se situe: {}".format(p_initiale)) solution = cherche_sortie(L, p_initiale) print(solution) print(chemin) L.afficher_laby() #if chemin: #L.afficher_chemin(chemin) self.dessiner_laby(L) self.dessiner_entree(p_initiale) self.dessiner_sortie(L) if solution: print('dessiner chemin') self.dessiner_chemin(L, chemin)
def creer_labyrinthe_depuis_chaine(self,chaine): """ Parcours de la chaine de caractère du fichier et ajout de chaque éléméent dans un dictionnaire dont la clé est un tuple. """ grille={} i=1 taille_ligne = 0 j=1 for char in chaine: if char == '\n' : j +=1 # On lève une exeption si la carte n'a pas le mm nombre de caractère par ligne if taille_ligne is not 0 and taille_ligne is not i: raise Exception("Il semblerait que la carte ne soit pas cohérente la ligne {0} a {1} caractère(s) alors que la ligne {2} à \ {} caractère(s). Merci de faire en sorte que toutes les lignes est le même nombre de caractère") taille_ligne = i i = 1 if char != '\r' and char != '\n': # On enregistre la position initial du joueur if char == 'X': position_robot = [i,j] char=' ' # On enregistre la position de la sortie if char == 'U': position_sortie = [i,j] grille[i,j]=char i += 1 # On créé un objet Labyrinthe return Labyrinthe( taille_ligne -1, j, position_robot,position_sortie,grille)
def test_deplacer_robot(self): """ Teste le déplacement d'un robot """ labyrinthe = Labyrinthe(self.obstacles) # on ajoute un robot à côté de la sortie labyrinthe.ajouter_robot_xy(self.num_robot, self.x, self.y) # on tente un déplacement vers un obstacle labyrinthe.deplacer_robot(self.num_robot, "o") # on vérifie que le robot n'a pas bougé robot = labyrinthe.robot[self.num_robot] self.assertTupleEqual((robot.x, robot.y), (self.x, self.y)) self.assertIsInstance(labyrinthe.grille[self.x, self.y], Robot) # on déplace le robot vers une porte et on vérifie que ça passe labyrinthe.deplacer_robot(self.num_robot, "s") self.assertTupleEqual((robot.x, robot.y), (self.x, self.y + 1)) self.assertIsInstance(labyrinthe.grille[self.x, self.y + 1], Robot) # on vérifie aussi que la porte est enregistrée dans les points invisibles self.assertIsInstance(labyrinthe.invisibles[0], Porte) # et si on sort de la porte, elle réapparait dans la grille labyrinthe.deplacer_robot(self.num_robot, "n") self.assertTupleEqual((robot.x, robot.y), (self.x, self.y)) self.assertIsInstance(labyrinthe.grille[self.x, self.y], Robot) self.assertIsInstance(labyrinthe.grille[self.x, self.y + 1], Porte) # on déplace vers la sortie et on vérifie que la partie est gagnée self.assertFalse(labyrinthe.gagnee) labyrinthe.deplacer_robot(self.num_robot, "e") self.assertTupleEqual((robot.x, robot.y), (self.x + 1, self.y)) self.assertIsInstance(labyrinthe.grille[self.x + 1, self.y], Robot) self.assertTrue(labyrinthe.gagnee)
def affichage_list_carte(cartes=[]): """ Fonction d'affichage de carte. Elle affiche toutes les cartes présente dans le dossier 'cartes' ainsi que les partie qui sont engegistrée """ # On charge les cartes existantes # qui sont présentent dans le dossier 'cartes' for nom_fichier in os.listdir("cartes"): if nom_fichier.endswith(".txt"): chemin = os.path.join("cartes", nom_fichier) nom_carte = nom_fichier[:-4].lower() with open(chemin, "r") as fichier: contenu = fichier.read() # Création d'une carte, à compléter lab = Labyrinthe(nom_carte, contenu) # Ajout de la carte dans la liste de carte cartes.append(lab) nombre_total_carte = 0 # On affiche les cartes existantes print("\t\tLabyrinthes existants :\n") for i, carte in enumerate(cartes): print("\t\t\t{} -> {}".format(i + 1, carte.nom)) nombre_total_carte += 1 nombre_carte_base = len(cartes) i = int(nombre_carte_base) # Si il y a une partie sauvegardée, on l'affiche print("\n\n\t\tParties sauvegardées :\n") for nom_fichier in os.listdir("cartes" + os.path.sep + "sauvegardes"): if nom_fichier.endswith(".txt"): chemin = os.path.join("cartes", "sauvegardes", nom_fichier) nom_carte = nom_fichier[:-4].lower() with open(chemin, "r") as fichier: contenu = fichier.read() print("\t\t\t{} -> {}".format(i + 1, nom_carte)) i += 1 # Création d'une carte, à compléter lab = Labyrinthe(nom_carte, contenu) # Ajout de la carte dans la liste de carte cartes.append(lab) return nombre_carte_base
def test_murer_porte(self): """ Teste le murage d'une porte : transformation d'une porte en mur """ labyrinthe = Labyrinthe(self.obstacles) # on ajoute un robot à côté d'une porte labyrinthe.ajouter_robot_xy(self.num_robot, self.x, self.y) self.assertIsInstance(labyrinthe.grille[self.x, self.y + 1], Porte) labyrinthe.murer_porte(self.num_robot, "s") self.assertIsInstance(labyrinthe.grille[self.x, self.y + 1], Mur)
def test_percer_porte(self): """ Teste la transformation d'un mur en porte """ labyrinthe = Labyrinthe(self.obstacles) # on ajoute un robot à côté d'un mur labyrinthe.ajouter_robot_xy(self.num_robot, self.x, self.y) self.assertIsInstance(labyrinthe.grille[self.x - 1, self.y], Mur) labyrinthe.percer_porte(self.num_robot, "o") self.assertIsInstance(labyrinthe.grille[self.x, self.y + 1], Porte)
def creer_labyrinthe_depuis_chaine(self, chaine): """ creer un nouvel objet labyrinthe à partir de la chaine """ grille = chaine.split("\n") # on va créer le robot : nouveau_labyrinthe = Labyrinthe(grille) # à completer avec en attribut le robot return nouveau_labyrinthe # pour éviter que le nouveau labyrinthe ne se retrouve à la poubelle.
def __init__(self, nom, chaine): """" Fonction d'initialisation - nom : nom de la carte - labyrinthe : labyrinthe de jeu """ self.nom = nom self.labyrinthe = Labyrinthe() self.labyrinthe.creer_labyrinthe_depuis_chaine(chaine)
def main(): """ methode d'execution du jeu """ # on affiche la liste des cartes disponibles liste_des_cartes = functions.liste_cartes() + functions.liste_sauvegardes() functions.afficher_liste(liste_des_cartes) # selection d'une carte, un retour "None" indique une mauvaise saisie while True: choix = functions.choix_carte( input('''Indiquez le numéro de la carte choisie. Attention, si vous choisissez une nouvelle partie, la sauvegarde associée à la carte concernée sera remplacée. \n'''), liste_des_cartes) if choix is not None: break # la carte est choisie, on peut générer un Labyrinthe laby = Labyrinthe(choix) # on affiche le tracé du labyrinthe print(laby.carte) # on lance la boucle du jeu while True: deplacements = input("""Dans quelle direction voulez vous aller? "E" pour aller vers l'est, "N" pour aller vers le nord "S" pour aller vers le sud, "O" pour aller vers l'ouest Suivi d'un nombre (optionnel) pour le nombre de cases à parcourir "Q" pour sauvegarder et quitter """) # on vérifie que les données entrées par l'utilisateur sont valides instructions = functions.instructions_valide(deplacements) if instructions is not None: if instructions == "quitter": laby.sauvegarder_partie() break if instructions == "lettre non valide": print("La lettre entrée n'est pas valide \n") continue if instructions == "non valide": print("Les données entrées ne sont pas valides \n") continue else: # on vérifie si la partie est toujours active partie_en_cours = laby.effectuer_deplacements(instructions) if not partie_en_cours: # en cas de sortie trouvée, on supprime la sauvegarde laby.supprimer_partie() print("Partie terminée, sauvegarde supprimée") break # On met en pause le système (Windows) os.system("pause")
def test_move(self): """ test le mouvement d'un robot """ jeux = Labyrinthe(self.carte) jeux.ajouter_robot("X", "joueur", "thread_name") resultat_attendue = list(range(0, 3)) for x in range(1, 100): step_x = random.randint(-1, 1) for y in range(1, 100): step_y = random.randint(-1, 1) ret = jeux.move(step_x, step_y, "joueur") self.assertIn(ret, resultat_attendue)
def creer_labyrinthe_depuis_chaine(chaine): position_du_robot = (0, 0) lab = Labyrinthe() lignes = chaine.split("\n") for i, ligne in enumerate(lignes): for j, c in enumerate(ligne): if c == lab.get_robot(): case = Case(nature=" ", robot=True) position_du_robot = (i, j) else: case = Case(nature=c, robot=False) lab.insert_une_case((i, j), case)
class TestLabyrinthe: """Test du module labyrinthe""" carte_longueur, carte_test = (carte("cartes", "test")) lab = Labyrinthe(carte_longueur, carte_test) def test_labyrinthe(self): """test de la bonne creation du labyrinthe""" assert self.carte_longueur == 6 assert self.lab.cases[(0, 0)].valeur == "o" assert self.lab.cases[(1, 1)].valeur == " " assert self.lab.cases[(2, 2)].valeur == " " assert self.lab.cases[(3, 3)].valeur == " " assert self.lab.cases[(4, 4)].valeur == "o" def test_placement(self): """test de la methode de placement""" self.lab.placement(1) assert self.lab.cases[self.lab.joueurs[0]].valeur == "x"
def creer_labyrinthe_depuis_chaine(chaine): """Cette fonction crée un objet de type labyrinthe et ajoute les eléments principales à partir de chaine""" obstacles = [] portes = [] joueurs = [] vides = [] i = 0 x = 0 y = 0 while i < len(chaine): coord = (x, y) if chaine[i] == "O": # Obstacles obstacles.append(coord) x += 1 elif chaine[i] == "X": # Robot robot = coord x += 1 elif chaine[i] == ".": portes.append(coord) x += 1 elif chaine[i] == "U": # Sortie sortie = coord x += 1 elif chaine[i] == "\n": # Saut de ligne longueur = x y += 1 x = 0 else: # Space x += 1 if coord != (10, 10): vides.append(coord) i += 1 hauteur = y + 1 obstacles.sort() portes.sort() vides.sort() labyrinthe = Labyrinthe(robot, obstacles, portes, sortie, longueur, hauteur, joueurs, vides) return labyrinthe
def init_carte(): """ Fonction d'affichage de carte. Elle affiche toutes les cartes présente dans le dossier 'cartes' """ cartes = [] input_ok = False """ On charge les cartes existantes qui sont présentent dans le dossier 'cartes' """ for nom_fichier in os.listdir("cartes"): if nom_fichier.endswith(".txt"): chemin = os.path.join("cartes", nom_fichier) nom_carte = nom_fichier[:-4].lower() with open(chemin, "r") as fichier: contenu = fichier.read() """ Création d'une carte, à compléter """ lab = Labyrinthe(nom_carte, contenu) """ Ajout de la carte dans la liste de carte """ cartes.append(lab) print('Liste des cartes disponibles : \n') for i, carte in enumerate(cartes): print("\t\t\t{} -> {}".format(i + 1, carte.nom)) choix = input("Faites votre choix \n") """ On fait la vérificationd de la saisie """ while not input_ok: try: choix = int(choix) min = 1 max = len(cartes) assert choix in range(min, max + 1) input_ok = True except ValueError: print('Vous n\'avez pas choisi un nombre') choix = input('Faites votre choix ') except AssertionError: print('Vous n\'avez pas choisi une carte disponible') choix = input('Faites votre choix ') """ attend les joueurs """ print("En attente de joueurs ...") return cartes[choix - 1]
def creer_labyrinthe_depuis_chaine(self, chaine): """ cette methode permet de creer un labyrinthe a partir d'une chaine. Pour se faire, nous allons creer une grille dont le coin haut/gauche le point (0,0) que nous parcourerons element par element, ligne par ligne""" split_chaine = chaine.strip("\n").split("\n") robot = None carte = {} for i,morceau in enumerate(split_chaine): for j,elem in enumerate(morceau): if elem == 'X': robot = (i,j) carte[(i,j)] = elem j+=1 i+=1 size = (len(split_chaine), len(split_chaine[0])) return Labyrinthe(robot, carte, size)
def select_level(url_map="./map/"): """ Affiche la liste des niveaux dispo et propose a l'utilisateur de choisir son level Verifie la validité de l'input :param url_map: url du dossier avec les maps (par defaut c'est un dossier map au meme niveau) :return: l'instance de labyrinthe choisie par l'utilisateur """ print("Selectionnez le level :\n") try: list_level = [ f for f in os.listdir(url_map) if os.path.isfile(os.path.join(url_map, f)) ] except FileNotFoundError: print("Dossier non trouvé. Fermeture") sys.exit(0) if len(list_level) == 0: print("Aucun niveau trouvé. Fermeture") sys.exit(0) for index, level in enumerate(list_level): print("[{}] : {}".format(index, level[:-4])) choix = input("Quel level souhaitez vous faire ?") while not is_valid(choix, type_="int", choix=list(range(len(list_level)))): choix = input("Mauvaise entrée! Quel level souhaitez vous faire ?") choix = int(choix) file_url = os.path.join(url_map, list_level[choix]) niveau = [] with open(file_url, "r") as f: for line in f.read().splitlines(): niveau.append(list(line)) niveau = Labyrinthe(niveau, list_level[choix]) save(niveau) return niveau
def main(): """ Voici le début do mon programe pour jouer au labyrintheS""" # On charge les cartes existantes clear() cartes = [] for nom_fichier in os.listdir("cartes"): if nom_fichier.endswith(".txt"): chemin = os.path.join("cartes", nom_fichier) nom_carte = nom_fichier[:-3].lower() #charger la carte venant d'un fichier cartes.append(Carte.carte_from_file(chemin, nom_carte)) # On affiche les cartes existantes print("Labyrinthes existants :") for i, carte in enumerate(cartes): print(" {} - {}".format(i + 1, carte.nom)) #on Choisi la carte while True: resultat = input( "Entrez un numéro de labyrinthe pour commencer à jouer : ") if resultat.isdigit() == True: if int(resultat) > 0 and int(resultat) <= len(cartes): break clear() #charge la carte séléctionné carte = cartes[(int(resultat) - 1)] jeux = Labyrinthe(carte) #si une partie encours/ a été sauvé chemin = os.path.join("cartes", (carte.nom + "pre")) if os.path.exists(chemin): key = "" exp = r"^[O]|[N]$" reg = re.compile(exp) while reg.search(key) is None: key = (input("Voulez continer la partie précédente(O/N)") ).upper() or 'O' if key == 'O': clear() jeux = jeux.restaurer_labyrinthe() #Début du jeux jeux.start()
def __init__(self, nom, fichier): self.nom = nom self.labyrinthe = Labyrinthe(fichier)
#Demander à l'utilisateur de chosir la carte: num_carte = int( input("Entrez un numéro de labyrinthe pour\ commencer à jouer :")) Carte.compteur = 1 # J'indique qu'une carte est en cours / en fin de game c=0 #Instanciation de classe Carte nom_carte = liste_de_cartes[num_carte - 1] + 'txt' path_carte = os.path.join("cartes", nom_carte) carte = Carte(liste_de_cartes[num_carte - 1], path_carte) #Instanciation de la classe Labyrinthe ##Transfère de de la carte en coordonnée. structure = carte.recup_strutcure() # on creer une str avec le fichier labi = Labyrinthe(structure) #PLACE AU JOUEUR: print(structure) robot = {"N": move_N, "S": move_S, "E": move_E, "W": move_W, "Q": save_quit} continuer = 'o' while continuer != 'n': move_player = input("Taper une direction (N,S,E,W,Q) : ").upper() coord = check_answer(move_player) # une liste if coord == None: print("Erreur de saisi") continue # a virer car sinon on est dans le else else: if coord[0] == 'N' or coord[0] == 'S':
def __init__(self, nom, chaine): self.nom = nom self.labyrinthe = Labyrinthe(chaine, ['O']) self.robot = self.setRobotPosition()
def __init__(self, infopartie, lienreseau, monpseudo, mode, taille): """Initialise tous les paramètres pour le bon démarrage du jeu""" self.lienreseau = lienreseau # conservation du lien avec le serveur self.carte = infopartie['params'][0] self.vitesse = infopartie['params'][1] self.tempsbonus = infopartie['params'][2] self.nombremonstres = infopartie['params'][3] self.tortues = infopartie['tortues'] self.monpseudo = monpseudo self.mode = mode self.taille = taille self.info = None # initialisation des chronomètres self.netchrono = Chrono() # empêche l'envoi trop rapide de paquets self.joueurchrono = Chrono() # pour les mouvements self.pilulechrono = Chrono() # pour le temps bonus # initialisation de la fenêtre de jeu self.window = tk.Tk() self.window.title('Turtle-Men') # mise en forme des scores self.scores = OrderedDict() # dictionnaire ordonné des scores self.scores[monpseudo] = [0] # score du joueur en premier rang = 0 for joueurs in infopartie['tortues']: self.scores[joueurs] = [0] self.scores[joueurs].append( tk.StringVar(value='{:<10}:{:>10}'.format( joueurs, self.scores[joueurs][0]))) for index in range(len(self.scores)): tk.Label(self.window, textvariable=list(self.scores.items())[index][1][1]).grid( row=index, column=0) rang += 1 ## ajouter des trucs de fenêtre içi ## #détermine les dimensions de la carte largeurcarte = max(len(i) for i in self.carte) hauteurcarte = len(self.carte) # taille de la fenêtre self.canvas = tk.Canvas(self.window, width=self.taille * largeurcarte, height=self.taille * hauteurcarte) self.canvas.grid(row=0, column=1, rowspan=rang) self.fen = turtle.TurtleScreen(self.canvas) # "dessiner" içi self.labyrinthe = Labyrinthe(self.fen, self.carte, self.taille) # initialisation des monstres self.monstres = dict() posmonstres = self.labyrinthe.posDebut('M') if self.nombremonstres > 0: self.monstres['Blinky'] = [ posmonstres, 'nord', True, False, Monstre(self.fen, 'red', 'B', self.taille) ] if self.nombremonstres > 1: self.monstres['Pinky'] = [ posmonstres, 'nord', True, False, Monstre(self.fen, 'pink', 'P', self.taille) ] if self.nombremonstres > 2: self.monstres['Inky'] = [ posmonstres, 'nord', True, False, Monstre(self.fen, 'cyan', 'I', self.taille) ] if self.nombremonstres > 3: self.monstres['Clyde'] = [ posmonstres, 'nord', True, False, Monstre(self.fen, 'orange', 'C', self.taille) ] # initialisation des autres joueurs posjoueurs = self.labyrinthe.posDebut('T') for nom in self.tortues: if nom != self.monpseudo: self.tortues[nom].append( TMen(self.fen, 'red', nom, self.taille)) # instances self.tortues[nom][0] = posjoueurs[:] # initialisation du joueur principal if self.mode == 'manuel': self.joueur = JoueurHumain(self.fen, 'yellow', self.monpseudo, self.taille) self.fen.onkeypress(self.joueur.toucheLeft, 'Left') self.fen.onkeypress(self.joueur.toucheRight, 'Right') self.fen.onkeypress(self.joueur.toucheUp, 'Up') self.fen.onkeypress(self.joueur.toucheDown, 'Down') self.fen.listen() else: self.joueur = JoueurIA(self.fen, "yellow", self.monpseudo, self.taille, self.monstres) self.joueur.pos = posjoueurs[:] self.joueur.pos = posjoueurs[:] self.joueurchrono.reset() # démarrage du chrono joueur self.mvtprec = 'est' # pour les virages self.joueur.pencolor('white') self.fen.ontimer(self.go, 1) # démarrage de la boucle principale self.fen.mainloop()
def main(): """Debut du serveur """ # Initialisation du serveur - Mise en place du socket : my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: my_socket.bind((HOST, PORT)) except socket.error: print("La liaison du socket à l'adresse choisie a échoué.") sys.exit() print("Serveur prêt, en attente de requêtes ...") my_socket.listen(5) #choisir la carte. # On charge les cartes existantes CLEAR() cartes = [] for nom_fichier in os.listdir("cartes"): if nom_fichier.endswith(".txt"): chemin = os.path.join("cartes", nom_fichier) nom_carte = nom_fichier[:-3].lower() #charger la carte venant d'un fichier cartes.append(Carte.carte_from_file(chemin, nom_carte)) # On affiche les cartes existantes print("Labyrinthes existants :") for i, carte in enumerate(cartes): print(" {} - {}".format(i + 1, carte.nom)) #on Choisi la carte while True: resultat = input( "Entrez un numéro de labyrinthe pour commencer à jouer : ") if resultat.isdigit(): if int(resultat) > 0 and int(resultat) <= len(cartes): break CLEAR() #charge la carte séléctionné carte = cartes[(int(resultat) - 1)] carte.clean_robot() jeux = Labyrinthe(carte) #si une partie encours/ a été sauvé chemin = os.path.join("cartes", (carte.nom + "pre")) if os.path.exists(chemin): key = "" exp = r"^[O]|[N]$" reg = re.compile(exp) while reg.search(key) is None: key = (input("Voulez continer la partie précédente(O/N)") ).upper() or 'O' if key == 'O': CLEAR() jeux = jeux.restaurer_labyrinthe() #Début du jeux # Attente et prise en charge des connexions demandées par les clients : print( "" " __ \n" + "/ _\ ___ _ __ __ __ ___ _ _ _ __ /\ /\ _ __ \n" + "\ \ / _ \| '__|\ \ / // _ \| | | || '__| / / \ \| '_ \ \n" + "_\ \| __/| | \ V /| __/| |_| || | \ \_/ /| |_) | \n" + "\__/ \___||_| \_/ \___| \__,_||_| \___/ | .__/ \n" + "_ \n" + " On attend les clients.\n") while 1: #attendre de la connexion connexion, adresse = my_socket.accept() if jeux.partie_commencee == True: #message que la partie est commencé est que personne ne peux se rajouter msg = 'Sorry, partie est commencée FIN ' connexion.send(msg.encode("Utf8")) continue #choix du symbole du symbole du robot #jeux.ajouter_robot("P") th_client = ThreadClient(connexion, jeux) thread_name = th_client.getName() # identifiant du thread flag_created = False nombre_de_robot = 1 if bool(jeux.robots.robots): for item in list(jeux.robots.robots): print('************* robot ****************') robot = jeux.robots.get_robot_name(item) print('nom du robot {}'.format(robot.name)) print('symbole du robot {}'.format(robot.symbole)) print('thread du robot {}'.format(robot.thread_name_r)) #test si toujours valide connexion or robot if CONN_CLIENT[robot.thread_name_r].fileno() < 0: jeux.enlever_robot(item) jeux.ajouter_robot(robot.symbole, item, thread_name) flag_created = True break nombre_de_robot += 1 #si pas de place on fait un nouveau robot if not flag_created: joueur = "joueur" + str(nombre_de_robot) #identifier le jouer jeux.ajouter_robot("x", joueur, thread_name) else: #si on a pas de collection de robot on rajoute joueur = "joueur" + str(nombre_de_robot) jeux.ajouter_robot("x", joueur, thread_name) # Créer un nouvel objet thread pour gérer la connexion : th_client.joueur = joueur th_client.start() # Mémoriser la connexion dans le dictionnaire : CONN_CLIENT[thread_name] = connexion print("Client %s connecté, adresse IP %s, port %s." %\ (thread_name, adresse[0], adresse[1])) # Dialogue avec le client : msg = "Bienveun joueur {} avec symbole {} \n Vous êtes connecté au serveur. \nAppuyé sur C pour commencer\n".format( joueur, jeux.robots.get_robot_name(joueur).symbole) connexion.send(msg.encode("Utf8"))
def __init__(self, nom, chaine): """Constructeur des cartes de jeu""" self.nom = nom self.labyrinthe = Labyrinthe(chaine)
from labyrinthe import Labyrinthe from time import sleep from os import system # initialisation des variables globales lab1 = Labyrinthe([ "##########", "# #", "# ##### #", "# # ####", "# # # ", "# # ######", "# # #", "# ###### #", "# #", "##########" ]) continuer = True depart = [2, 8] arrivee = [4, 9] coord = list(depart) labVisible = Labyrinthe.creation_lab.__get__(lab1) def deplacement(lab, direction, coord, labVisible): gauche = "q" droite = "d" haut = "z" bas = "s" if direction == gauche and coord[1] > 0: # GAUCHE coord[1] = coord[1] - 1 elif direction == droite and coord[1] < lab.taille - 1: # DROITE coord[1] = coord[1] + 1 elif direction == haut and coord[0] > 0: # HAUT coord[0] = coord[0] - 1 elif direction == bas and coord[0] < lab.taille - 1: # BAS coord[0] = coord[0] + 1 else:
# coding: utf-8 from server import * from labyrinthe import Labyrinthe labyrinthe = Labyrinthe() tcpsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) tcpsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) tcpsock.bind(("", 1111)) while True: tcpsock.listen(10) (clientsocket, (ip, port)) = tcpsock.accept() newthread = ClientThread(ip, port, clientsocket, labyrinthe) newthread.start()
def main(): pygame.init() """Pygame initialization""" # Window setting win = pygame.display.set_mode((450, 480)) # Hero display char = pygame.image.load(IMAGE_MACGYVER).convert() winner = pygame.image.load(IMAGE_WIN).convert() lose = pygame.image.load(IMAGE_LOSE).convert() pygame.display.set_caption("ACCUEIL") pygame.display.flip() # Maze display labyrinthe = Labyrinthe("labyrinthe.txt") """ Display Hero and special objetcs """ perso = Macgayver(labyrinthe) ether = SpecialObjects(labyrinthe, IMAGE_ETHER) tube = SpecialObjects(labyrinthe, IMAGE_TUBE) needle = SpecialObjects(labyrinthe, IMAGE_NEEDLE) pygame.display.flip() game = 1 while game: continuer = 1 """ Game loop """ while continuer: pygame.time.Clock().tick(30) for event in pygame.event.get(): if (event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE): continuer = 0 game = 0 pygame.quit() exit() """ Display of the maze """ labyrinthe.show(win) ether.show_special(win) tube.show_special(win) needle.show_special(win) win.blit(char, (perso.x, perso.y)) pygame.display.flip() """Move fuctions in pygame with keyboard actions """ if event.type == QUIT: continuer = 0 elif event.type == KEYDOWN: if event.key == K_ESCAPE: continuer = 0 elif event.key == K_DOWN: perso.move("down") elif event.key == K_UP: perso.move("up") elif event.key == K_RIGHT: perso.move("right") elif event.key == K_LEFT: perso.move("left") print(perso.compteur) """Death of the Hero Event""" if (labyrinthe.structure[perso.case_y][perso.case_x] == "a" and perso.compteur < 3): win.blit(lose, (150, 200)) pygame.display.flip() continuer = 0 """ Win the game """ sound3 = pygame.mixer.Sound(SOUND_WIN) if (labyrinthe.structure[perso.case_y][perso.case_x] == "a" and perso.compteur == 3): sound3.play() win.blit(winner, (150, 200)) pygame.display.flip() continuer = 0
except ValueError: #La valeur n'est sans doute pas numérique print("Votre saisie est incorrecte ... Fin du programme") exit(1) if choix <1 or choix > i+1: print("Labyrinthe inexistant (pas dans la liste proposée) !!!") exit(1) #2. On affiche le labyrinthe et on enregistre la position du robot #S'il s'agit de la partie sauvegardée, on continue le jeu avec les données qui étaient enregistrée if bool(save) and choix==i+1 : jeu=save["labyrinthe"] else: robot=cartes[choix-1].posRobot() jeu=Labyrinthe(robot,cartes[choix-1].labyrinthe) save["nom"]=cartes[choix-1].nom save["dimension"]=cartes[choix-1].dim() save["labyrinthe"]=jeu save["nbCoups"]=0 jeu.afficher() #3. On boucle tant que le robot n'est pas sorti du labyrinthe finJeu=False #pour comptabiliser le nbr de coups (pourrait être utile si on voulait enregistrer des scores nbCoups=save["nbCoups"] while finJeu == False : saisieJoueur = input("Entrez le mouvement de votre robot : ") if checkMouvt(saisieJoueur) == False: #saisie incorrecte continue
## TELECHARGEMENT DES CARTES ######################################################################################### ##### A REMPLIR A LA MAIN nombre_cartes = 3 liste_labyrinthe = ["facile", "prison", "hyperloop"] ##### RECUPERATION DU CHEMIN dict_labyrinthe = {} # dict() -- dictionnaire des labyrinthes de la bibliothèque, la cle est le numero du labyrinthe dir_path = os.path.dirname(os.path.realpath(__file__)) ##### TELECHARGEMENT for i, elt in enumerate(liste_labyrinthe): path = dir_path + "/cartes/{}.txt".format(liste_labyrinthe[i]) i += 1 mon_labyrinthe_1 = Labyrinthe() mon_labyrinthe_1.telecharger(path, str(i)) dict_labyrinthe[str(i)] = mon_labyrinthe_1 ######################################################################################### ## ALGORITHME DE JEU ######################################################################################### ##### INITIALISATION continuer_jouer = bool() # bool -- vaut True tant que le joueur souhaite jouer partie = bool() # bool -- vaut True tant que le robot n'est pas sorti du labyrinthe continuer_jouer = True # bool() -- Vaut True tant que le Master est connecté clients_connectes = [] # list() -- Liste des sockets des clients connectés ##### GESTION DE LA CONNECTION # Contruction du socket
def __init__(self, nom, chaine): self.nom = nom self.labyrinthe = Labyrinthe(chaine)
def test_creer_labyrinthe(self): labyrinthe = Labyrinthe(self.obstacles) labyrinthe.afficher() for element in labyrinthe.grille.values(): self.assertIn(element, self.obstacles)