def test_creation_labyrinthe_depuis_chaine(self): """ Vérification de la création d'un labyrinthe depuis une chaîne => vérification des méthodes de classe suivantes : - creation_derniere_carte - formatage_derniere_carte """ # Vérification de creation_derniere_carte # Plus besoin de vérifier facile & prison i = 1 # On prend la deuxième carte facile (nombre maximum de joueur = 2) carte = choix_carte([self.liste_carte_facile[i]], self.chemin_carte_facile) print("La chaîne testée est :\n" + carte + "\n") numero_client = 1 # Initialisation du numero_client labyrinthe = Labyrinthe(numero_client) # Traitement du cas où l'on n'a plus de vide pour créer le robot! if numero_client <= labyrinthe.nombre_joueur_maximum(carte): liste_1, indice_X_1 = labyrinthe.creation_derniere_carte(carte) carte_1 = labyrinthe.formatage_derniere_carte(liste_1) print("Le labyrinthe du client " + str(numero_client) + " est :\n" + carte_1 + "\n") self.assertNotEqual(carte, carte_1) self.assertEqual(numero_client, labyrinthe.nb_robot) self.assertEqual(liste_1[indice_X_1], self.robot) self.assertNotIn(self.robot_adverse, carte_1) # Vérification que la différence entre carte et carte_1 est le robot ajouté carte_1_transforme = carte_1.replace(self.robot, self.vide) self.assertEqual(carte, carte_1_transforme) else: with self.assertRaises(IndexError): labyrinthe.creation_derniere_carte(carte) numero_client = 2 carte_2 = carte_1 labyrinthe = Labyrinthe(numero_client) # Traitement du cas où l'on n'a plus de vide pour créer le robot! if numero_client <= labyrinthe.nombre_joueur_maximum(carte): liste_2, indice_X_2 = labyrinthe.creation_derniere_carte(carte_2) carte_2 = labyrinthe.formatage_derniere_carte(liste_2) print("Le labyrinthe du client " + str(numero_client) + " est :\n" + carte_2 + "\n") self.assertNotEqual(carte_1, carte_2) self.assertEqual(numero_client, labyrinthe.nb_robot) self.assertEqual(liste_2[indice_X_2], self.robot) self.assertIn(self.robot_adverse, carte_2) # Vérification que la différence entre carte_1 et carte_2 est le robot ajouté carte_2_transforme = carte_2.replace(self.robot, self.vide) carte_2_transforme = carte_2_transforme.replace( self.robot_adverse, self.robot) self.assertEqual(carte_1, carte_2_transforme) else: with self.assertRaises(IndexError): labyrinthe.creation_derniere_carte(carte_2) numero_client = 3 carte_3 = carte_2 labyrinthe = Labyrinthe(numero_client) # Traitement du cas où l'on n'a plus de vide pour créer le robot! if numero_client <= labyrinthe.nombre_joueur_maximum(carte): liste_3, indice_X_3 = labyrinthe.creation_derniere_carte(carte_3) carte_3 = labyrinthe.formatage_derniere_carte(liste_3) print("Le labyrinthe du client " + str(numero_client) + " est :\n" + carte_3 + "\n") self.assertNotEqual(carte_2, carte_3) self.assertEqual(numero_client, labyrinthe.nb_robot) self.assertEqual(liste_3[indice_X_3], self.robot) self.assertIn(self.robot_adverse, carte_3) # Vérification que la différence entre carte_2 et carte_3 est le robot ajouté carte_3_transforme = carte_3.replace(self.robot, self.vide) carte_2_transforme = carte_2.replace(self.robot, self.robot_adverse) self.assertEqual(carte_2_transforme, carte_3_transforme) else: with self.assertRaises(IndexError): labyrinthe.creation_derniere_carte(carte_3)
def test_fonctionnalites_jeu_multi_joueurs(self): """ Vérification des fonctionnalités du jeu multi-joueurs """ # Plus besoin de vérifier la création du labyrinthe à partir d'une chaîne # Création de 3 labyrinthes avec 3 joueurs connectés # Initialisation des éléments des labyrinthe pour le jeu multi-joueurs : carte_clients = {} robot_clients = {} liste_clients = {} mouvt_clients = {} pcrea_clients = {} mcrea_clients = {} i = -1 # On prend la première carte prison (nombre maximum de joueur important!) carte = choix_carte([self.liste_carte_prison[i]], self.chemin_carte_prison) print("La carte (prison) de ce test est :\n" + carte + "\n") # Connexion du client 1 connexion_avec_serveur_1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.assertIsNotNone(connexion_avec_serveur_1) connexion_avec_serveur_1.connect(("localhost", self.port)) numero_client = 1 # Initialisation du numero_client labyrinthe = Labyrinthe(numero_client) liste_1, indice_X_1 = labyrinthe.creation_derniere_carte(carte) carte_1 = labyrinthe.formatage_derniere_carte(liste_1) carte_clients[1] = carte_1 # Partie des nouveaux clients liste_clients[1] = liste_1 # Liste du jeu des nouveaux clients robot_clients[1] = indice_X_1 # Indice du Robot des nouveaux clients mouvt_clients[ 1] = " " # Symbole où se trouve le robot (une porte ou un vide) pcrea_clients[1] = -1 # Indice d'une porte créée mcrea_clients[1] = -1 # Indice d'un mur créé # Connexion du client 2 connexion_avec_serveur_2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.assertIsNotNone(connexion_avec_serveur_2) connexion_avec_serveur_2.connect(("localhost", self.port)) numero_client = 2 carte_2 = carte_1 labyrinthe = Labyrinthe(numero_client) liste_2, indice_X_2 = labyrinthe.creation_derniere_carte(carte_2) carte_2 = labyrinthe.formatage_derniere_carte(liste_2) # Ajout du robot du client 2 dans carte_1 liste_clients[1][indice_X_2] = labyrinthe.ajout_robot_adverse( liste_clients[1][indice_X_2]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) carte_1 = carte_clients[1] carte_clients[2] = carte_2 # Partie des nouveaux clients liste_clients[2] = liste_2 # Liste du jeu des nouveaux clients robot_clients[2] = indice_X_2 # Indice du Robot des nouveaux clients mouvt_clients[ 2] = " " # Symbole où se trouve le robot (une porte ou un vide) pcrea_clients[2] = -1 # Indice d'une porte créée mcrea_clients[2] = -1 # Indice d'un mur créé # Connexion du client 3 connexion_avec_serveur_3 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.assertIsNotNone(connexion_avec_serveur_3) connexion_avec_serveur_3.connect(("localhost", self.port)) numero_client = 3 carte_3 = carte_2 labyrinthe = Labyrinthe(numero_client) liste_3, indice_X_3 = labyrinthe.creation_derniere_carte(carte_3) carte_3 = labyrinthe.formatage_derniere_carte(liste_3) # Ajout du robot du client 3 dans carte_1 et carte_2 liste_clients[1][indice_X_3] = labyrinthe.ajout_robot_adverse( liste_clients[1][indice_X_3]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) liste_clients[2][indice_X_3] = labyrinthe.ajout_robot_adverse( liste_clients[2][indice_X_3]) carte_clients[2] = labyrinthe.formatage_derniere_carte( liste_clients[2]) # Réinitialisation de carte 1 & 2 carte_1 = carte_clients[1] carte_2 = carte_clients[2] print("Carte 1 (du client 1) :\n" + carte_1 + "\n") print("Carte 2 (du client 2) :\n" + carte_2 + "\n") print("Carte 3 (du client 3) :\n" + carte_3 + "\n") carte_clients[3] = carte_3 # Partie des nouveaux clients liste_clients[3] = liste_3 # Liste du jeu des nouveaux clients robot_clients[3] = indice_X_3 # Indice du Robot des nouveaux clients mouvt_clients[ 3] = " " # Symbole où se trouve le robot (une porte ou un vide) pcrea_clients[3] = -1 # Indice d'une porte créée mcrea_clients[3] = -1 # Indice d'un mur créé # Début des tests sur commandes # Tests simples d'abord print("Début des tests sur quelques commandes simples!") # Test des commandes de jeu sur le 1er joueur connecté # NB : les 3 premiers tests ne sont pas exploités par la suite # C'est pour cela que l'on prend une copie de liste_clients[1] coup = "o1" liste, robot, mouvt, pcrea, mcrea, msg, proxy_dep \ = labyrinthe.modifier_carte(coup, list(liste_clients[1]), robot_clients[1], mouvt_clients[1]) carte = labyrinthe.formatage_derniere_carte(liste) self.assertEqual(pcrea, -1) self.assertEqual(mcrea, -1) if "Aïe" in msg: self.assertEqual(carte_1, carte) elif "impossible" in msg: self.assertEqual(carte_1, carte) else: self.assertNotEqual(carte_1, carte) print("Carte 1 suite coup " + coup + " :\n" + carte + "\n") coup = "e1" liste, robot, mouvt, pcrea, mcrea, msg, proxy_dep \ = labyrinthe.modifier_carte(coup, list(liste_clients[1]), robot_clients[1], mouvt_clients[1]) carte = labyrinthe.formatage_derniere_carte(liste) self.assertEqual(pcrea, -1) self.assertEqual(mcrea, -1) if "Aïe" in msg: self.assertEqual(carte_1, carte) elif "impossible" in msg: self.assertEqual(carte_1, carte) else: self.assertNotEqual(carte_1, carte) print("Carte 1 suite coup " + coup + " :\n" + carte + "\n") coup = "s1" liste, robot, mouvt, pcrea, mcrea, msg, proxy_dep \ = labyrinthe.modifier_carte(coup, list(liste_clients[1]), robot_clients[1], mouvt_clients[1]) carte = labyrinthe.formatage_derniere_carte(liste) self.assertEqual(pcrea, -1) self.assertEqual(mcrea, -1) if "Aïe" in msg: self.assertEqual(carte_1, carte) elif "impossible" in msg: self.assertEqual(carte_1, carte) else: self.assertNotEqual(carte_1, carte) print("Carte 1 suite coup " + coup + " :\n" + carte + "\n") coup = "n1" # Réinitialisation de la place qu'occupait le robot du client 1 chez le 2 & 3 liste_clients[2][robot_clients[1]] = mouvt_clients[1] liste_clients[3][robot_clients[1]] = mouvt_clients[1] # Modification de la carte du client 1 indice_X_1 = robot_clients[1] liste_clients[1], robot_clients[1], mouvt_clients[1], pcrea_clients[1], mcrea_clients[1], msg, proxy_dep \ = labyrinthe.modifier_carte(coup, liste_clients[1], robot_clients[1], mouvt_clients[1]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) self.assertEqual(pcrea_clients[1], -1) self.assertEqual(mcrea_clients[1], -1) print("Carte 1 suite coup " + coup + " :\n" + carte_clients[1] + "\n") # Tests if "Aïe" in msg: self.assertEqual(carte_1, carte_clients[1]) elif "impossible" in msg: self.assertEqual(carte_1, carte_clients[1]) else: self.assertNotEqual(carte_1, carte_clients[1]) self.assertNotEqual(robot_clients[1], indice_X_1) self.assertEqual(liste_clients[1][robot_clients[1]], self.robot) # Réinitialisation de carte_1 carte_1 = carte_clients[1] # Ajout du déplacement du robot du client 1 dans les cartes des clients 2 & 3 liste_clients[2][robot_clients[1]] = labyrinthe.ajout_robot_adverse( liste_clients[2][robot_clients[1]]) carte_clients[2] = labyrinthe.formatage_derniere_carte( liste_clients[2]) liste_clients[3][robot_clients[1]] = labyrinthe.ajout_robot_adverse( liste_clients[3][robot_clients[1]]) carte_clients[3] = labyrinthe.formatage_derniere_carte( liste_clients[3]) print("Carte 2 suite coup " + coup + " :\n" + carte_clients[2] + "\n") print("Carte 3 suite coup " + coup + " :\n" + carte_clients[3] + "\n") # Tests if "Aïe" in msg: self.assertEqual(carte_2, carte_clients[2]) self.assertEqual(carte_3, carte_clients[3]) elif "impossible" in msg: self.assertEqual(carte_2, carte_clients[2]) self.assertEqual(carte_3, carte_clients[3]) else: self.assertNotEqual(carte_2, carte_clients[2]) self.assertNotEqual(carte_3, carte_clients[3]) self.assertEqual(liste_clients[2][robot_clients[1]], self.robot_adverse) self.assertEqual(liste_clients[3][robot_clients[1]], self.robot_adverse) # Réinitialisation de carte_2 & carte_3 carte_2 = carte_clients[2] carte_3 = carte_clients[3] # Test de la commande "porte" sur client 2 : # Idem 3 premiers tests non exploités par la suite! coup = "po" indice_X_2 = robot_clients[2] liste, robot, mouvt, pcrea, mcrea, msg, proxy_dep \ = labyrinthe.modifier_carte(coup, list(liste_clients[2]), robot_clients[2], mouvt_clients[2]) carte = labyrinthe.formatage_derniere_carte(liste) print("Carte 2 suite coup " + coup + " :\n" + carte + "\n") # Tests if "impossible" in msg: self.assertEqual(robot, indice_X_2) self.assertEqual(pcrea, -1) self.assertEqual(carte_2, carte) elif "empêche" in msg: self.assertEqual(robot, indice_X_2) self.assertEqual(pcrea, -1) self.assertEqual(carte_2, carte) elif "créé" in msg: self.assertEqual(robot, indice_X_2) self.assertNotEqual(pcrea, -1) self.assertEqual(liste[pcrea], self.porte) self.assertNotEqual(carte_2, carte) coup = "pe" indice_X_2 = robot_clients[2] liste, robot, mouvt, pcrea, mcrea, msg, proxy_dep \ = labyrinthe.modifier_carte(coup, list(liste_clients[2]), robot_clients[2], mouvt_clients[2]) carte = labyrinthe.formatage_derniere_carte(liste) print("Carte 2 suite coup " + coup + " :\n" + carte + "\n") # Tests if "impossible" in msg: self.assertEqual(robot, indice_X_2) self.assertEqual(pcrea, -1) self.assertEqual(carte_2, carte) elif "empêche" in msg: self.assertEqual(robot, indice_X_2) self.assertEqual(pcrea, -1) self.assertEqual(carte_2, carte) elif "créé" in msg: self.assertEqual(robot, indice_X_2) self.assertNotEqual(pcrea, -1) self.assertEqual(liste[pcrea], self.porte) self.assertNotEqual(carte_2, carte) coup = "ps" indice_X_2 = robot_clients[2] liste, robot, mouvt, pcrea, mcrea, msg, proxy_dep \ = labyrinthe.modifier_carte(coup, list(liste_clients[2]), robot_clients[2], mouvt_clients[2]) carte = labyrinthe.formatage_derniere_carte(liste) print("Carte 2 suite coup " + coup + " :\n" + carte + "\n") # Tests if "impossible" in msg: self.assertEqual(robot, indice_X_2) self.assertEqual(pcrea, -1) self.assertEqual(carte_2, carte) elif "empêche" in msg: self.assertEqual(robot, indice_X_2) self.assertEqual(pcrea, -1) self.assertEqual(carte_2, carte) elif "créé" in msg: self.assertEqual(robot, indice_X_2) self.assertNotEqual(pcrea, -1) self.assertEqual(liste[pcrea], self.porte) self.assertNotEqual(carte_2, carte) coup = "pn" indice_X_2 = robot_clients[2] liste_clients[2], robot_clients[2], mouvt_clients[2], pcrea_clients[2], mcrea_clients[2], msg, proxy_dep \ = labyrinthe.modifier_carte(coup, liste_clients[2], robot_clients[2], mouvt_clients[2]) carte_clients[2] = labyrinthe.formatage_derniere_carte( liste_clients[2]) print("Carte 2 suite coup " + coup + " :\n" + carte_clients[2] + "\n") # Tests if "impossible" in msg: self.assertEqual(robot_clients[2], indice_X_2) self.assertEqual(pcrea_clients[2], -1) self.assertEqual(carte_2, carte_clients[2]) elif "empêche" in msg: self.assertEqual(robot_clients[2], indice_X_2) self.assertEqual(pcrea_clients[2], -1) self.assertEqual(carte_2, carte_clients[2]) elif "créé" in msg: self.assertEqual(robot_clients[2], indice_X_2) self.assertNotEqual(pcrea_clients[2], -1) self.assertEqual(liste_clients[2][pcrea_clients[2]], self.porte) self.assertNotEqual(carte_2, carte_clients[2]) # Réinitialisation de carte_2 carte_2 = carte_clients[2] # On ajoute la porte aux clients 1 & 3 if pcrea_clients[2] != -1: liste_clients[1][pcrea_clients[2]] = labyrinthe.ajout_porte( liste_clients[1][pcrea_clients[2]]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) liste_clients[3][pcrea_clients[2]] = labyrinthe.ajout_porte( liste_clients[3][pcrea_clients[2]]) carte_clients[3] = labyrinthe.formatage_derniere_carte( liste_clients[3]) print("Carte 1 suite coup " + coup + " :\n" + carte_clients[1] + "\n") print("Carte 3 suite coup " + coup + " :\n" + carte_clients[3] + "\n") # Tests if "impossible" in msg: self.assertEqual(carte_1, carte_clients[1]) self.assertEqual(carte_3, carte_clients[3]) elif "empêche" in msg: self.assertEqual(carte_1, carte_clients[1]) self.assertEqual(carte_3, carte_clients[3]) elif "créé" in msg: self.assertNotEqual(carte_1, carte_clients[1]) self.assertNotEqual(carte_3, carte_clients[3]) self.assertEqual(liste_clients[1][pcrea_clients[2]], self.porte) self.assertEqual(liste_clients[3][pcrea_clients[2]], self.porte) # Réinitialisation de carte_1 et carte_3 carte_1 = carte_clients[1] carte_3 = carte_clients[3] # Réinitialisation de pcrea pcrea_clients[2] = -1 # Effet mirroir pour client 3 sur mur... # Idem 3 premiers tests non exploités par la suite! coup = "mo" indice_X_3 = robot_clients[3] liste, robot, mouvt, pcrea, mcrea, msg, proxy_dep \ = labyrinthe.modifier_carte(coup, list(liste_clients[3]), robot_clients[3], mouvt_clients[3]) carte = labyrinthe.formatage_derniere_carte(liste) print("Carte 3 suite coup " + coup + " :\n" + carte + "\n") # Tests if "impossible" in msg: self.assertEqual(robot, indice_X_3) self.assertEqual(mcrea, -1) self.assertEqual(carte_3, carte) elif "empêche" in msg: self.assertEqual(robot, indice_X_3) self.assertEqual(mcrea, -1) self.assertEqual(carte_3, carte) elif "créé" in msg: self.assertEqual(robot, indice_X_3) self.assertNotEqual(mcrea, -1) self.assertEqual(liste[mcrea], self.mur) self.assertNotEqual(carte_3, carte) coup = "me" indice_X_3 = robot_clients[3] liste, robot, mouvt, pcrea, mcrea, msg, proxy_dep \ = labyrinthe.modifier_carte(coup, list(liste_clients[3]), robot_clients[3], mouvt_clients[3]) carte = labyrinthe.formatage_derniere_carte(liste) print("Carte 3 suite coup " + coup + " :\n" + carte + "\n") # Tests if "impossible" in msg: self.assertEqual(robot, indice_X_3) self.assertEqual(mcrea, -1) self.assertEqual(carte_3, carte) elif "empêche" in msg: self.assertEqual(robot, indice_X_3) self.assertEqual(mcrea, -1) self.assertEqual(carte_3, carte) elif "créé" in msg: self.assertEqual(robot, indice_X_3) self.assertNotEqual(mcrea, -1) self.assertEqual(liste[mcrea], self.mur) self.assertNotEqual(carte_3, carte) coup = "ms" indice_X_3 = robot_clients[3] liste, robot, mouvt, pcrea, mcrea, msg, proxy_dep \ = labyrinthe.modifier_carte(coup, list(liste_clients[3]), robot_clients[3], mouvt_clients[3]) carte = labyrinthe.formatage_derniere_carte(liste) print("Carte 3 suite coup " + coup + " :\n" + carte + "\n") # Tests if "impossible" in msg: self.assertEqual(robot, indice_X_3) self.assertEqual(mcrea, -1) self.assertEqual(carte_3, carte) elif "empêche" in msg: self.assertEqual(robot, indice_X_3) self.assertEqual(mcrea, -1) self.assertEqual(carte_3, carte) elif "créé" in msg: self.assertEqual(robot, indice_X_3) self.assertNotEqual(mcrea, -1) self.assertEqual(liste[mcrea], self.mur) self.assertNotEqual(carte_3, carte) coup = "mn" indice_X_3 = robot_clients[3] liste_clients[3], robot_clients[3], mouvt_clients[3], pcrea_clients[3], mcrea_clients[3], msg, proxy_dep \ = labyrinthe.modifier_carte(coup, liste_clients[3], robot_clients[3], mouvt_clients[3]) carte_clients[3] = labyrinthe.formatage_derniere_carte( liste_clients[3]) print("Carte 3 suite coup " + coup + " :\n" + carte_clients[3] + "\n") # Tests if "impossible" in msg: self.assertEqual(robot_clients[3], indice_X_3) self.assertEqual(mcrea_clients[3], -1) self.assertEqual(carte_3, carte_clients[3]) elif "empêche" in msg: self.assertEqual(robot_clients[3], indice_X_3) self.assertEqual(mcrea_clients[3], -1) self.assertEqual(carte_3, carte_clients[3]) elif "créé" in msg: self.assertEqual(robot_clients[3], indice_X_3) self.assertNotEqual(mcrea_clients[3], -1) self.assertEqual(liste_clients[3][mcrea_clients[3]], self.mur) self.assertNotEqual(carte_3, carte_clients[3]) # Réinitialisation de carte_3 carte_3 = carte_clients[3] # On ajoute le mur aux clients 1 & 2 if mcrea_clients[3] != -1: liste_clients[1][mcrea_clients[3]] = labyrinthe.ajout_mur( liste_clients[1][mcrea_clients[3]]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) liste_clients[2][mcrea_clients[3]] = labyrinthe.ajout_mur( liste_clients[2][mcrea_clients[3]]) carte_clients[2] = labyrinthe.formatage_derniere_carte( liste_clients[2]) print("Carte 1 suite coup " + coup + " :\n" + carte_clients[1] + "\n") print("Carte 2 suite coup " + coup + " :\n" + carte_clients[2] + "\n") # Tests if "impossible" in msg: self.assertEqual(carte_1, carte_clients[1]) self.assertEqual(carte_2, carte_clients[2]) elif "empêche" in msg: self.assertEqual(carte_1, carte_clients[1]) self.assertEqual(carte_2, carte_clients[2]) elif "créé" in msg: self.assertNotEqual(carte_1, carte_clients[1]) self.assertNotEqual(carte_2, carte_clients[2]) self.assertEqual(liste_clients[1][mcrea_clients[3]], self.mur) self.assertEqual(liste_clients[2][mcrea_clients[3]], self.mur) carte_1 = carte_clients[1] carte_2 = carte_clients[2] # Réinitialisation de mcrea mcrea_clients[3] = -1 # On fait une boucle et le programme tire au hasard des commandes de jeu # On crée les commandes de coup que l'on place dans liste_commandes # Le nombre de commandes de déplacement dépendent de la taille de liste_1 liste_commandes = [ "o", "e", "s", "n", "po", "pe", "ps", "pn", "mo", "me", "ms", "mn" ] i = 1 while i < len(liste_1): liste_commandes.append( random.choice(liste_commandes) ) # Pour avoir plus de commandes avec porte et mur liste_commandes.append(random.choice(liste_commandes)) # Idem liste_commandes.append("o" + str(i)) liste_commandes.append("e" + str(i)) liste_commandes.append("s" + str(i)) liste_commandes.append("n" + str(i)) i += 1 # On fixe le nombre de tirage aléatoire de la boucle (dépend de liste_1) nombre_tirage = len( liste_1) * 10 # on multiplie par 10 la taille de liste_1 # On lance la boucle print("Lancement du test sur commandes aléatoires!\n") numero_tirage = 1 while numero_tirage < nombre_tirage: coup = random.choice(liste_commandes) # On commence par le coup du client 1 # Réinitialisation de la place qu'occupait le robot du client 1 chez le 2 & 3 liste_clients[2][robot_clients[1]] = mouvt_clients[1] liste_clients[3][robot_clients[1]] = mouvt_clients[1] indice_X_1 = robot_clients[1] liste_clients[1], robot_clients[1], mouvt_clients[1], pcrea_clients[1], mcrea_clients[1], msg, proxy_dep \ = labyrinthe.modifier_carte(coup, liste_clients[1], robot_clients[1], mouvt_clients[1]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) # Tests # Cas où l'on sort du jeu tout de suite if "impossible" in msg and proxy_dep == 1: self.assertEqual(carte_1, carte_clients[1]) # Autre cas impossible où pas de porte ni de mur à créer elif "impossible" in msg and ("p" in coup or "m" in coup): self.assertEqual(carte_1, carte_clients[1]) self.assertEqual(mcrea_clients[1], -1) self.assertEqual(pcrea_clients[1], -1) # Cas où l'on entre dans un mur ou un robot tout de suite elif "Aïe" in msg and proxy_dep == 1: self.assertEqual(carte_1, carte_clients[1]) # Cas où un robot empêche de créer une porte ou un mur elif "empêche" in msg: self.assertEqual(robot_clients[1], indice_X_1) self.assertEqual(mcrea_clients[1], -1) self.assertEqual(pcrea_clients[1], -1) self.assertEqual(carte_1, carte_clients[1]) # Cas où l'on crée une porte ou un mur elif "créé" in msg: self.assertEqual(robot_clients[1], indice_X_1) self.assertNotEqual(carte_1, carte_clients[1]) if "m" in coup: self.assertNotEqual(mcrea_clients[1], -1) self.assertEqual(liste_clients[1][mcrea_clients[1]], self.mur) else: self.assertNotEqual(pcrea_clients[1], -1) self.assertEqual(liste_clients[1][pcrea_clients[1]], self.porte) # Tous les autres cas avec déplacement donc! else: self.assertNotEqual(carte_1, carte_clients[1]) self.assertNotEqual(robot_clients[1], indice_X_1) self.assertEqual(liste_clients[1][robot_clients[1]], self.robot) # Réinitialisation de carte_1 carte_1 = carte_clients[1] # Réinitialisation de pcrea et mcrea pcrea_clients[1] = -1 mcrea_clients[1] = -1 # Ajout du déplacement du robot du client 1 dans les cartes des clients 2 & 3 liste_clients[2][ robot_clients[1]] = labyrinthe.ajout_robot_adverse( liste_clients[2][robot_clients[1]]) carte_clients[2] = labyrinthe.formatage_derniere_carte( liste_clients[2]) liste_clients[3][ robot_clients[1]] = labyrinthe.ajout_robot_adverse( liste_clients[3][robot_clients[1]]) carte_clients[3] = labyrinthe.formatage_derniere_carte( liste_clients[3]) # Réinitialisation de carte_2 & carte_3 carte_2 = carte_clients[2] carte_3 = carte_clients[3] # On incrémente numero_tirage numero_tirage += 1 coup = random.choice(liste_commandes) # On joue avec le client 2 # Réinitialisation de la place qu'occupait le robot du client 2 chez le 1 & 3 liste_clients[1][robot_clients[2]] = mouvt_clients[2] liste_clients[3][robot_clients[2]] = mouvt_clients[2] indice_X_2 = robot_clients[2] liste_clients[2], robot_clients[2], mouvt_clients[2], pcrea_clients[2], mcrea_clients[2], msg, proxy_dep \ = labyrinthe.modifier_carte(coup, liste_clients[2], robot_clients[2], mouvt_clients[2]) carte_clients[2] = labyrinthe.formatage_derniere_carte( liste_clients[2]) # Cas où l'on sort du jeu tout de suite if "impossible" in msg and proxy_dep == 1: self.assertEqual(carte_2, carte_clients[2]) # Autre cas impossible où pas de porte ni de mur à créer elif "impossible" in msg and ("p" in coup or "m" in coup): self.assertEqual(carte_2, carte_clients[2]) self.assertEqual(mcrea_clients[2], -1) self.assertEqual(pcrea_clients[2], -1) # Cas où l'on entre dans un mur ou un robot tout de suite elif "Aïe" in msg and proxy_dep == 1: self.assertEqual(carte_2, carte_clients[2]) # Cas où un robot empêche de créer une porte ou un mur elif "empêche" in msg: self.assertEqual(robot_clients[2], indice_X_2) self.assertEqual(mcrea_clients[2], -1) self.assertEqual(pcrea_clients[2], -1) self.assertEqual(carte_2, carte_clients[2]) # Cas où l'on crée une porte ou un mur elif "créé" in msg: self.assertEqual(robot_clients[2], indice_X_2) self.assertNotEqual(carte_2, carte_clients[2]) if "m" in coup: self.assertNotEqual(mcrea_clients[2], -1) self.assertEqual(liste_clients[2][mcrea_clients[2]], self.mur) else: self.assertNotEqual(pcrea_clients[2], -1) self.assertEqual(liste_clients[2][pcrea_clients[2]], self.porte) # Tous les autres cas avec déplacement donc! else: self.assertNotEqual(carte_2, carte_clients[2]) self.assertNotEqual(robot_clients[2], indice_X_2) self.assertEqual(liste_clients[2][robot_clients[2]], self.robot) # Réinitialisation de carte_2 carte_2 = carte_clients[2] # Réinitialisation de pcrea et mcrea pcrea_clients[2] = -1 mcrea_clients[2] = -1 # Ajout du déplacement du robot du client 2 dans les cartes des clients 1 & 3 liste_clients[1][ robot_clients[2]] = labyrinthe.ajout_robot_adverse( liste_clients[1][robot_clients[2]]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) liste_clients[3][ robot_clients[2]] = labyrinthe.ajout_robot_adverse( liste_clients[3][robot_clients[2]]) carte_clients[3] = labyrinthe.formatage_derniere_carte( liste_clients[3]) # Réinitialisation de carte_1 & carte_3 carte_1 = carte_clients[1] carte_3 = carte_clients[3] # On incrémente numero_tirage numero_tirage += 1 coup = random.choice(liste_commandes) # On joue avec le client 3 # Réinitialisation de la place qu'occupait le robot du client 3 chez le 1 & 2 liste_clients[1][robot_clients[3]] = mouvt_clients[3] liste_clients[2][robot_clients[3]] = mouvt_clients[3] indice_X_3 = robot_clients[3] liste_clients[3], robot_clients[3], mouvt_clients[3], pcrea_clients[3], mcrea_clients[3], msg, proxy_dep \ = labyrinthe.modifier_carte(coup, liste_clients[3], robot_clients[3], mouvt_clients[3]) carte_clients[3] = labyrinthe.formatage_derniere_carte( liste_clients[3]) # Cas où l'on sort du jeu tout de suite if "impossible" in msg and proxy_dep == 1: self.assertEqual(carte_3, carte_clients[3]) # Autre cas impossible où pas de porte ni de mur à créer elif "impossible" in msg and ("p" in coup or "m" in coup): self.assertEqual(carte_3, carte_clients[3]) self.assertEqual(mcrea_clients[3], -1) self.assertEqual(pcrea_clients[3], -1) # Cas où l'on entre dans un mur ou un robot tout de suite elif "Aïe" in msg and proxy_dep == 1: self.assertEqual(carte_3, carte_clients[3]) # Cas où un robot empêche de créer une porte ou un mur elif "empêche" in msg: self.assertEqual(robot_clients[3], indice_X_3) self.assertEqual(mcrea_clients[3], -1) self.assertEqual(pcrea_clients[3], -1) self.assertEqual(carte_3, carte_clients[3]) # Cas où l'on crée une porte ou un mur elif "créé" in msg: self.assertEqual(robot_clients[3], indice_X_3) self.assertNotEqual(carte_3, carte_clients[3]) if "m" in coup: self.assertNotEqual(mcrea_clients[3], -1) self.assertEqual(liste_clients[3][mcrea_clients[3]], self.mur) else: self.assertNotEqual(pcrea_clients[3], -1) self.assertEqual(liste_clients[3][pcrea_clients[3]], self.porte) # Tous les autres cas avec déplacement donc! else: self.assertNotEqual(carte_3, carte_clients[3]) self.assertNotEqual(robot_clients[3], indice_X_3) self.assertEqual(liste_clients[3][robot_clients[3]], self.robot) # Réinitialisation de carte_3 carte_3 = carte_clients[3] # Réinitialisation de pcrea et mcrea pcrea_clients[3] = -1 mcrea_clients[3] = -1 # Ajout du déplacement du robot du client 3 dans les cartes des clients 1 & 2 liste_clients[1][ robot_clients[3]] = labyrinthe.ajout_robot_adverse( liste_clients[1][robot_clients[3]]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) liste_clients[2][ robot_clients[3]] = labyrinthe.ajout_robot_adverse( liste_clients[2][robot_clients[3]]) carte_clients[2] = labyrinthe.formatage_derniere_carte( liste_clients[2]) # Réinitialisation de carte_1 & carte_2 carte_1 = carte_clients[1] carte_2 = carte_clients[2] # On incrémente numero_tirage numero_tirage += 1 print("Test réussi sur " + str(nombre_tirage) + " coups!\n") print("La dernière partie du client 1 est \n" + carte_1 + "\n") print("La dernière partie du client 2 est \n" + carte_2 + "\n") print("La dernière partie du client 3 est \n" + carte_3 + "\n") print( "Pour rappel : la partie n'a pas été arrêtée en cas de victoire d'un des 3 clients!\n" ) print("Test de la victoire :") # Je teste la victoire! # On lance la même boucle sans limite en nombre de tirage # La boucle devra s'arrêter si un des clients trouve la sortie # Cas où un des robots est déjà sur la sortie if mouvt_clients[1] == self.sortie: self.assertEqual(labyrinthe.victoire(mouvt_clients[1]), True) elif mouvt_clients[2] == self.sortie: self.assertEqual(labyrinthe.victoire(mouvt_clients[2]), True) elif mouvt_clients[3] == self.sortie: self.assertEqual(labyrinthe.victoire(mouvt_clients[3]), True) else: # Réinitialisation du numéro de tirage numero_tirage = 1 sortie_en_recherche = True while sortie_en_recherche: coup = random.choice(liste_commandes) # On commence par le coup du client 1 # Réinitialisation de la place qu'occupait le robot du client 1 chez le 2 & 3 liste_clients[2][robot_clients[1]] = mouvt_clients[1] liste_clients[3][robot_clients[1]] = mouvt_clients[1] indice_X_1 = robot_clients[1] liste_clients[1], robot_clients[1], mouvt_clients[1], pcrea_clients[1], mcrea_clients[1], msg, proxy_dep \ = labyrinthe.modifier_carte(coup, liste_clients[1], robot_clients[1], mouvt_clients[1]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) # Tests si sortie if "atteinte" in msg: self.assertEqual(mouvt_clients[1], self.sortie) self.assertNotEqual(carte_1, carte_clients[1]) self.assertEqual(labyrinthe.victoire(mouvt_clients[1]), True) elif "atteinte" in msg: self.assertNotEqual(labyrinthe.victoire(mouvt_clients[1]), True) # Réinitialisation de carte_1 carte_1 = carte_clients[1] # Réinitialisation de pcrea et mcrea pcrea_clients[1] = -1 mcrea_clients[1] = -1 # Ajout du déplacement du robot du client 1 dans les cartes des clients 2 & 3 liste_clients[2][ robot_clients[1]] = labyrinthe.ajout_robot_adverse( liste_clients[2][robot_clients[1]]) carte_clients[2] = labyrinthe.formatage_derniere_carte( liste_clients[2]) liste_clients[3][ robot_clients[1]] = labyrinthe.ajout_robot_adverse( liste_clients[3][robot_clients[1]]) carte_clients[3] = labyrinthe.formatage_derniere_carte( liste_clients[3]) # Réinitialisation de carte_2 & carte_3 carte_2 = carte_clients[2] carte_3 = carte_clients[3] if "atteinte" in msg: break # On incrémente numero_tirage numero_tirage += 1 coup = random.choice(liste_commandes) # On joue avec le client 2 # Réinitialisation de la place qu'occupait le robot du client 2 chez le 1 & 3 liste_clients[1][robot_clients[2]] = mouvt_clients[2] liste_clients[3][robot_clients[2]] = mouvt_clients[2] indice_X_2 = robot_clients[2] liste_clients[2], robot_clients[2], mouvt_clients[2], pcrea_clients[2], mcrea_clients[2], msg, proxy_dep \ = labyrinthe.modifier_carte(coup, liste_clients[2], robot_clients[2], mouvt_clients[2]) carte_clients[2] = labyrinthe.formatage_derniere_carte( liste_clients[2]) # Tests si sortie # Cas où l'on sort du jeu tout de suite if "atteinte" in msg: self.assertEqual(mouvt_clients[2], self.sortie) self.assertNotEqual(carte_1, carte_clients[2]) self.assertEqual(labyrinthe.victoire(mouvt_clients[2]), True) else: self.assertNotEqual(labyrinthe.victoire(mouvt_clients[2]), True) # Réinitialisation de carte_2 carte_2 = carte_clients[2] # Réinitialisation de pcrea et mcrea pcrea_clients[2] = -1 mcrea_clients[2] = -1 # Ajout du déplacement du robot du client 2 dans les cartes des clients 1 & 3 liste_clients[1][ robot_clients[2]] = labyrinthe.ajout_robot_adverse( liste_clients[1][robot_clients[2]]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) liste_clients[3][ robot_clients[2]] = labyrinthe.ajout_robot_adverse( liste_clients[3][robot_clients[2]]) carte_clients[3] = labyrinthe.formatage_derniere_carte( liste_clients[3]) # Réinitialisation de carte_1 & carte_3 carte_1 = carte_clients[1] carte_3 = carte_clients[3] if "atteinte" in msg: break # On incrémente numero_tirage numero_tirage += 1 coup = random.choice(liste_commandes) # On joue avec le client 3 # Réinitialisation de la place qu'occupait le robot du client 3 chez le 1 & 2 liste_clients[1][robot_clients[3]] = mouvt_clients[3] liste_clients[2][robot_clients[3]] = mouvt_clients[3] indice_X_3 = robot_clients[3] liste_clients[3], robot_clients[3], mouvt_clients[3], pcrea_clients[3], mcrea_clients[3], msg, proxy_dep \ = labyrinthe.modifier_carte(coup, liste_clients[3], robot_clients[3], mouvt_clients[3]) carte_clients[3] = labyrinthe.formatage_derniere_carte( liste_clients[3]) # Tests si sortie # Cas où l'on sort du jeu tout de suite if "atteinte" in msg: self.assertEqual(mouvt_clients[3], self.sortie) self.assertNotEqual(carte_1, carte_clients[3]) self.assertEqual(labyrinthe.victoire(mouvt_clients[3]), True) else: self.assertNotEqual(labyrinthe.victoire(mouvt_clients[3]), True) # Réinitialisation de carte_3 carte_3 = carte_clients[3] # Réinitialisation de pcrea et mcrea pcrea_clients[3] = -1 mcrea_clients[3] = -1 # Ajout du déplacement du robot du client 3 dans les cartes des clients 1 & 2 liste_clients[1][ robot_clients[3]] = labyrinthe.ajout_robot_adverse( liste_clients[1][robot_clients[3]]) carte_clients[1] = labyrinthe.formatage_derniere_carte( liste_clients[1]) liste_clients[2][ robot_clients[3]] = labyrinthe.ajout_robot_adverse( liste_clients[2][robot_clients[3]]) carte_clients[2] = labyrinthe.formatage_derniere_carte( liste_clients[2]) # Réinitialisation de carte_1 & carte_2 carte_1 = carte_clients[1] carte_2 = carte_clients[2] if "atteinte" in msg: break # On incrémente numero_tirage numero_tirage += 1 print("Sortie atteinte après " + str(numero_tirage) + " coups!\n") print("La dernière partie du client 1 est \n" + carte_1 + "\n") print("La dernière partie du client 2 est \n" + carte_2 + "\n") print("La dernière partie du client 3 est \n" + carte_3 + "\n") # Fermeture des connexions connexion_avec_serveur_1.close() connexion_avec_serveur_2.close() connexion_avec_serveur_3.close()