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 __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 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 Carte:
"""Objet de transition entre un fichier et un labyrinthe."""
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 __repr__(self):
""""
Fonction de representation de carte pour son affichage
"""
return "<Carte {}>".format(self.nom)
def get_name_for_saving(self):
""""
Récupération du nom de la carte pour sauvegarde
Retourne le nom du fichier en chaine de caractères
"""
# Checking if the game has already been saved
if (self.nom.endswith("_save") is True):
filename = self.nom + ".txt"
else:
filename = self.nom + "_save.txt"
return filename
def save(self):
""""
Fonction de sauvegarde de carte dans un fichier texte
Retourne :
- True si succes
- False si erreur
"""
path = "cartes/" + self.get_name_for_saving()
# ouverture sans test préalable
fh = open(path, "w")
try:
fh.write(self.labyrinthe.grilletodata())
# caractère de fin optionnel
fh.write("\n")
finally:
fh.close()
#fichier créé
return True
return False
def creer_labyrinthe_depuis_chaine(self, chaine):
#On extrait les coordonées du Robot et les differents obstacles
self.chaine = chaine
#Définition des Elements de la carte
largeur = chaine.find("\n")
obstacles ={}
positionRobot=chaine.find(roboc)
robot=self.CalculerCoordonees(positionRobot,largeur)
index=0
for caractere in chaine:
if caractere == murs:
pos = self.CalculerCoordonees(index,largeur)
#print("position:{} de type : {}".format(pos,"murs"))
obstacles[pos]=murs
elif caractere == roboc:
pos = self.CalculerCoordonees(index,largeur)
#print("position:{} de type : {}".format(pos,"roboc"))
obstacles[pos]=roboc
elif caractere == vide:
pos = self.CalculerCoordonees(index,largeur)
#print("position:{} de type : {}".format(pos,"roboc"))
obstacles[pos]=vide
elif caractere == porte:
pos = self.CalculerCoordonees(index,largeur)
#print("position:{} de type : {}".format(pos,"porte"))
obstacles[pos]=porte
elif caractere == sortie:
pos = self.CalculerCoordonees(index,largeur)
print("position:{} de type : {}".format(pos,"sortie"))
obstacles[pos]=sortie
elif caractere == Escalier:
pos = self.CalculerCoordonees(index,largeur)
#print("position:{} de type : {}".format(pos,"Escalier"))
obstacles[pos]=Escalier
elif caractere == retour:
pos = self.CalculerCoordonees(index,largeur)
#print("position:{} de type : {}".format(pos,"retour"))
obstacles[pos]=retour
index +=1
lab = Labyrinthe(robot, obstacles)
print("on avance de 1")
if lab.isObstacle("x0-y1"):
print("youpi")
else:
print("ouin")
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 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
class Carte:
"""Objet de transition entre un fichier et un labyrinthe."""
def __init__(self, nom, chaine):
self.nom = nom
self.labyrinthe = Labyrinthe(chaine)
def __repr__(self):
return "<Carte {}>".format(
self.nom) + "\n" + self.labyrinthe.__repr__()
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 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 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 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 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)
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 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 __init__(self, nom, chaine):
self.nom = nom
self.labyrinthe = Labyrinthe.creer_labyrinthe_depuis_chaine(chaine)
## 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
#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 test_creer_labyrinthe(self):
labyrinthe = Labyrinthe(self.obstacles)
labyrinthe.afficher()
for element in labyrinthe.grille.values():
self.assertIn(element, self.obstacles)
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()
class Jeu():
"""Constitue une partie du jeu"""
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 go(self):
"""Fonction qui remplit la boucle principale, ne doit pas bloquer"""
# mise à jour des données
if self.netchrono.get() > 0.020: # on peut communiquer
self.info = self.lienreseau.rapporter(self.joueur.getStatus())
self.netchrono.reset()
if self.info is not None:
# données des monstres
for monstre in self.info['monstres'].keys():
self.monstres[monstre][0] =\
self.info['monstres'][monstre][0]
self.monstres[monstre][1] =\
self.info['monstres'][monstre][1]
self.monstres[monstre][2] =\
self.info['monstres'][monstre][2]
self.monstres[monstre][3] =\
self.info['monstres'][monstre][3]
# données des tortues
for tortue in self.info['tortues'].keys():
if tortue != self.monpseudo:
self.tortues[tortue][0] =\
self.info['tortues'][tortue][0]
self.tortues[tortue][1] =\
self.info['tortues'][tortue][1]
self.tortues[tortue][2] =\
self.info['tortues'][tortue][2]
self.tortues[tortue][3] =\
self.info['tortues'][tortue][3]
# mise à jour des scores
if not self.info['gagnant']:
for joueur in self.info['scores'].keys():
self.scores[joueur][0] = self.info['scores'][joueur]
self.scores[joueur][1].set('{:<10}:{:>10}'.format(
joueur, self.scores[joueur][0]))
else:
for joueur in self.info['scores'].keys():
if joueur == self.info['gagnant']:
self.scores[joueur][1].set('{:<10}:{:>10}'.format(
joueur, 'gagnant'))
else:
self.scores[joueur][1].set('{:<10}:{:>10}'.format(
joueur, 'perdant'))
# mise à jour des monstres
for monstre in self.monstres.keys():
self.monstres[monstre][-1].deplacer(self.monstres[monstre][0])
self.monstres[monstre][-1].orienter(self.monstres[monstre][1])
# mise à jour des autres tortues
for joueur in self.tortues.keys():
if joueur != self.monpseudo:
self.tortues[joueur][-1].deplacer(self.tortues[joueur][0])
self.tortues[joueur][-1].orienter(self.tortues[joueur][1])
# mouvement du joueur
deltat = self.joueurchrono.get()
self.joueurchrono.reset()
case = tuple(math.floor(i) for i in self.joueur.pos)
diffcase = tuple(i - j for i, j in zip(case, self.joueur.pos))
normediffcase = (diffcase[0]**2 + diffcase[1]**2)**(0.5)
distance = self.vitesse * deltat
if not self.joueur.vie:
distance = 0
if self.mvtprec == 'est':
mvtactuel = (1, 0)
elif self.mvtprec == 'ouest':
mvtactuel = (-1, 0)
elif self.mvtprec == 'nord':
mvtactuel = (0, -1)
elif self.mvtprec == 'sud':
mvtactuel = (0, 1)
else:
mvtactuel = (0, 0)
if self.mode != 'manuel':
self.joueur.deterDirection()
self.joueur.posprec = self.joueur.pos
if self.joueur.bougervers == 'est':
mvtvoulu = (1, 0)
elif self.joueur.bougervers == 'ouest':
mvtvoulu = (-1, 0)
elif self.joueur.bougervers == 'nord':
mvtvoulu = (0, -1)
elif self.joueur.bougervers == 'sud':
mvtvoulu = (0, 1)
else:
mvtvoulu = (0, 0)
if mvtactuel == mvtvoulu: # même direction
pass
elif mvtactuel == tuple(-i for i in mvtvoulu): # direction inverse
self.mvtprec = self.joueur.bougervers
mvtactuel = mvtvoulu
else: # virage
produitscalaire = abs(
sum(i * j for i, j in zip(diffcase, mvtactuel)))
if produitscalaire <= distance and not\
self.labyrinthe.blocExiste(math.floor(self.joueur.pos[1] +
mvtvoulu[1]),
math.floor(self.joueur.pos[0] +
mvtvoulu[0])):
distance -= normediffcase # perte de distance partielle
self.mvtprec = self.joueur.bougervers
mvtactuel = mvtvoulu
else:
pass # on continue dans la même direction
posvoulue = (self.joueur.pos[0] + distance * mvtactuel[0],
self.joueur.pos[1] + distance * mvtactuel[1])
if not self.labyrinthe.blocExiste(
math.floor(posvoulue[1] + mvtactuel[1] / 2 + 0.5),
math.floor(posvoulue[0] + mvtactuel[0] / 2 + 0.5)):
self.joueur.pos = posvoulue
else:
if self.mvtprec == 'est':
posx = math.floor(posvoulue[0])
elif self.mvtprec == 'ouest':
posx = math.ceil(posvoulue[0])
else:
posx = posvoulue[0]
if self.mvtprec == 'nord':
posy = math.ceil(posvoulue[1])
elif self.mvtprec == 'sud':
posy = math.floor(posvoulue[1])
else:
posy = posvoulue[1]
self.joueur.pos = (posx, posy)
self.joueur.deplacer(self.joueur.pos)
self.joueur.orienter(self.mvtprec)
# gestion des nourritures
casesoccupe = list()
macase = tuple(math.floor(i + 0.5) for i in self.joueur.pos)
casesoccupe.append(macase)
for joueur in self.tortues.keys():
if joueur != self.monpseudo:
casesoccupe.append(
tuple(
math.floor(i + 0.5)
for i in self.tortues[joueur][-1].pos))
for posjoueur in casesoccupe:
if self.labyrinthe.bouffeExiste(posjoueur):
self.labyrinthe.detruireBouffe(posjoueur)
# gestion des pilules
for posjoueur in casesoccupe:
if self.labyrinthe.piluleExiste(posjoueur):
self.labyrinthe.detruirePilule(posjoueur)
if posjoueur == macase: # c'est nous, avec la pilule
self.joueur.energie = True
self.joueur.color('lightgreen')
self.pilulechrono.reset()
# autres tortues
for joueur in self.tortues.keys():
if joueur != self.monpseudo:
if self.tortues[joueur][3]:
self.tortues[joueur][-1].color('green')
else:
self.tortues[joueur][-1].color('red')
# collisions avec les monstres
caseoccupe = [] # on réinitialise
for monstre in self.monstres.keys():
posmonstre = self.monstres[monstre][-1].pos
if self.monstres[monstre][2]: # monstre en vie
caseoccupe.append(
tuple(
math.floor(i + 0.5)
for i in self.monstres[monstre][-1].pos))
for joueur in self.tortues.keys():
if joueur != self.monpseudo:
if not self.tortues[joueur][2]:
self.tortues[joueur][-1].hideturtle()
# si les monstres meurent
for monstre in self.monstres.keys():
if self.monstres[monstre][2]:
self.monstres[monstre][-1].showturtle()
else:
self.monstres[monstre][-1].hideturtle()
if macase in caseoccupe and not self.joueur.energie:
self.joueur.vie = False
self.joueur.hideturtle()
if self.pilulechrono.get() >= self.tempsbonus: # temps bonus dépassé
self.joueur.energie = False
self.joueur.color('yellow')
self.fen.update()
self.fen.ontimer(self.go, 0)
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 __init__(self, nom, chaine):
self.nom = nom
self.labyrinthe = Labyrinthe(chaine)
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
