Example #1
0
 def playOneMatch(self):
     listeTrouvees = ListeMots()
     self.affichageTableRuzzle()
     temps = float(
         input("\nSaisir le temps de duree de votre defi (en secondes)!\ntemps = "))
     timer = Timer(temps, self.gererFinMatch, [listeTrouvees])
     timer.start()
     print("Saisir les mots que vous trouvez dans la grille!...\n")
     while True:
         if self.matchEnded == True:
             sys.exit()
         mot = input("mot -> ")
         if self.listeMotsDansGrille.estDans(mot):
             listeTrouvees.insert(mot)
Example #2
0
 def playOneMatch(self):
     listeTrouvees = ListeMots()
     self.affichageTableRuzzle()
     temps = float(
         input(
             "\nSaisir le temps de duree de votre defi (en secondes)!\ntemps = "
         ))
     timer = Timer(temps, self.gererFinMatch, [listeTrouvees])
     timer.start()
     print("Saisir les mots que vous trouvez dans la grille!...\n")
     while True:
         if self.matchEnded == True:
             sys.exit()
         mot = input("mot -> ")
         if self.listeMotsDansGrille.estDans(mot):
             listeTrouvees.insert(mot)
Example #3
0
 def __init__(self, ipServerAddress, tcpServerPort, ruzzleGraph):
     self.ipServerAddress = ipServerAddress
     self.tcpServerPort = tcpServerPort
     self.BUFFER_SIZE = 2024
     self.listeTrouvees = ListeMots()
     self.ruzzleGraph = ruzzleGraph
     # starting server
     self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self.s.bind((self.ipServerAddress, self.tcpServerPort))
     self.s.listen(1)
Example #4
0
 def waitForOpponent(self):
     print("En attente d' adversaire ... ")
     self.conn, self.addr = self.s.accept()
     print("Adversaire Trouve'! ---> ", self.addr, "\n")
     listeMotsAdversaire = ListeMots()
     listeTrouvees = ListeMots()
     received = str(self.receiveFromClient())
     # reponse au defi
     self.answerClient("CHALLENGE_ACCEPTED")
     # debut match en locale
     if received.startswith("TIME_"):
         self.ruzzleGraph.playChallenge(int(received[5:len(received)]))  # extraction du temps(%) de la str TIME_%
         # envoie resultats au client
         self.answerClient("RESULTS_" + self.ruzzleGraph.listeTrouvees.compressToSend())
         resultsClient = self.receiveFromClient()
         if resultsClient.startswith("RESULTS_"):
             resultsClient = resultsClient[8:len(resultsClient)]
             listeMotsAdversaire = ListeMots()
             listeMotsAdversaire.decompress(resultsClient)
             self.resultatMatch(self.ruzzleGraph.listeTrouvees, listeMotsAdversaire)
Example #5
0
 def sendChallenge(self, challengeTime):
     # on envoie une requete de defi au serveur
     self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     serverHostName = socket.gethostbyaddr(self.tcpServerAddress)
     serverHostName = serverHostName[0]
     self.client_socket.connect((serverHostName, self.tcpServerPort))
     # envoie du defi au serveur
     print("Connexion au Serveur en cours ...\n")
     self.sendToServeur("TIME_" + str(challengeTime))
     # elaboration reponse
     reponseDuServeur = self.receiveFromServeur()
     if reponseDuServeur == "CHALLENGE_ACCEPTED":
         self.ruzzleGraph.playChallenge(challengeTime)
         # envoie resultats...
         self.sendToServeur("RESULTS_" + self.ruzzleGraph.listeTrouvees.compressToSend())
         # reception resultats
         reponse = self.receiveFromServeur()
         if reponse.startswith("RESULTS_") == True:
             reponse = reponse[8:len(reponse)]
             listeMotsAdversaire = ListeMots()
             listeMotsAdversaire.decompress(reponse)
             self.resultatMatch(self.ruzzleGraph.listeTrouvees, listeMotsAdversaire)
Example #6
0
 def sendChallenge(self, challengeTime):
     # on envoie une requete de defi au serveur
     self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     serverHostName = socket.gethostbyaddr(self.tcpServerAddress)
     serverHostName = serverHostName[0]
     self.client_socket.connect((serverHostName, self.tcpServerPort))
     # envoie du defi au serveur
     print("Connexion au Serveur en cours ...\n")
     self.sendToServeur("TIME_" + str(challengeTime))
     # elaboration reponse
     reponseDuServeur = self.receiveFromServeur()
     if reponseDuServeur == "CHALLENGE_ACCEPTED":
         self.ruzzleGraph.playChallenge(challengeTime)
         # envoie resultats...
         self.sendToServeur("RESULTS_" +
                            self.ruzzleGraph.listeTrouvees.compressToSend())
         # reception resultats
         reponse = self.receiveFromServeur()
         if reponse.startswith("RESULTS_") == True:
             reponse = reponse[8:len(reponse)]
             listeMotsAdversaire = ListeMots()
             listeMotsAdversaire.decompress(reponse)
             self.resultatMatch(self.ruzzleGraph.listeTrouvees,
                                listeMotsAdversaire)
Example #7
0
 def waitForOpponent(self):
     print("En attente d' adversaire ... ")
     self.conn, self.addr = self.s.accept()
     print("Adversaire Trouve'! ---> ", self.addr, "\n")
     listeMotsAdversaire = ListeMots()
     listeTrouvees = ListeMots()
     received = str(self.receiveFromClient())
     # reponse au defi
     self.answerClient("CHALLENGE_ACCEPTED")
     # debut match en locale
     if received.startswith("TIME_"):
         self.ruzzleGraph.playChallenge(
             int(received[5:len(received)]
                 ))  # extraction du temps(%) de la str TIME_%
         # envoie resultats au client
         self.answerClient("RESULTS_" +
                           self.ruzzleGraph.listeTrouvees.compressToSend())
         resultsClient = self.receiveFromClient()
         if resultsClient.startswith("RESULTS_"):
             resultsClient = resultsClient[8:len(resultsClient)]
             listeMotsAdversaire = ListeMots()
             listeMotsAdversaire.decompress(resultsClient)
             self.resultatMatch(self.ruzzleGraph.listeTrouvees,
                                listeMotsAdversaire)
Example #8
0
class RuzzleGraph:

    def __init__(self, vertexList, dictionnaire):
        self.matchEnded = False
        self.vertexList = vertexList
        self.dictionnaire = dictionnaire
        self.listeMotsDansGrille = ListeMots()
        self.listeTrouvees = ListeMots()

    # methodes de construction et affichage
    def ajouteVertex(self, vertex):
        self.vertexList.append(vertex)

    def printSimpleGraph(self):
        for v in self.vertexList:
            print(v.value, " --> ", end='')
            for adj in v.listeAdjacences:
                print(adj.value, end='')
            print("")

    def affichageTableRuzzle(self):
        # print ligne 0
        print("  ", end='')
        for i in range(0, 5):
            if i % 2 == 0:
                print("/" + self.vertexList[i].value + "\\", end='')
            else:
                print(self.vertexList[i].value, end='')
        print("")
        # print ligne 1
        for i in range(5, 12):
            if i % 2 != 0:
                print("/" + self.vertexList[i].value + "\\", end='')
            else:
                print(self.vertexList[i].value, end='')
        print("")
        # print ligne 2
        for i in range(12, 19):
            if i % 2 == 0:
                print("\\" + self.vertexList[i].value + "/", end='')
            else:
                print(self.vertexList[i].value, end='')
        print("")
        # print ligne 3
        print("  ", end='')
        for i in range(19, 24):
            if i % 2 != 0:
                print("\\" + self.vertexList[i].value + "/", end='')
            else:
                print(self.vertexList[i].value, end='')
        print("")

    """Verification presence du mot dans la grille Ruzzle (pour methode 2)"""

    def motEstDansGraphe(self, mot):
        for vertex in self.vertexList:
            if vertex.value == mot[0] or vertex.value == '*':
                if self.motEstDansGrapheN(mot, vertex, "", None) is True:
                    return True

        return False

    def motEstDansGrapheN(self, mot, n, chainePartielle, listeDejaVisite):
        i = len(chainePartielle)

        if chainePartielle == mot:
            return True

        if i >= len(mot):
            return False

        # initialisation listeDejaVisite
        if i == 0:
            if mot[0] == n.value:
                listeDejaVisite = [n]
                return self.motEstDansGrapheN(mot, n, str(n.value), listeDejaVisite)
            elif n.value == '*':
                listeDejaVisite = [n]
                for car in range(97, 123):
                    result = self.motEstDansGrapheN(mot, n, str(chr(car)), listeDejaVisite)
                    if result is True:
                        return True
                    else:
                        continue
            else:
                return False

        else:  # cas i != 0, on a deja trouve le premier caractere du mot
            bonVoisin = False
            for vertex in n.listeAdjacences:
                if vertex.value == mot[i] and vertex not in listeDejaVisite:
                    bonVoisin = True
                    nouvelleDejaVisite = [el for el in listeDejaVisite]
                    nouvelleDejaVisite.append(vertex)

                    # on verifie la presence du caractere suivant dans le graphe
                    result = self.motEstDansGrapheN(mot, vertex, str(chainePartielle) + str(vertex.value), nouvelleDejaVisite)
                    if result is True:
                        return True
                    else:
                        continue
                elif vertex.value == '*' and vertex not in listeDejaVisite:
                    nouvelleDejaVisite = [el for el in listeDejaVisite]
                    nouvelleDejaVisite.append(vertex)
                    for car in range(97, 123):
                        result = self.motEstDansGrapheN(mot, vertex, str(chainePartielle) + str(chr(car)), nouvelleDejaVisite)
                        if result is True:
                            return True

            if bonVoisin == False:
                return False

    """Solution Ruzzle via Dictionnaire Python (DFS sur le graphe + verification presence mot non distribuee')"""

    def DFSPy(self, parcourDictionnaire):
        self.dictionnairePy = ArbreLex(parcourDictionnaire)
        for v in self.vertexList:
            if v.value == '*':
                for i in range(97, 123):
                    if self.dictionnairePy.estDans(str(chr(i))) == 1:
                        self.DFSVisitPy(v, str(chr(i)), None)

            if self.dictionnairePy.estDans(v.value) == 1:
                self.DFSVisitPy(v, str(v.value), None)

    def DFSVisitPy(self, vertex, chainePartielle, listeDejaVisite):
        # cas 0, on ajoute la premiere lettre du mot a la liste dejaVisite
        if listeDejaVisite == None:
            listeDejaVisite = [vertex]
        # on passe au prefix successif en ajoutant un voisin si le prefix
        # chainePartielle+voisin existe dans le dictio
        for v in vertex.listeAdjacences:
            # on s'assure de ne pas passer deux fois sur la meme lettre
            if v not in listeDejaVisite:
                resultatRecherche = 0
                if v.value == '*':
                    for i in range(97, 123):
                        resultatRecherche = self.dictionnairePy.estDans(
                            chainePartielle + str(chr(i)))
                        if resultatRecherche == 0:
                            continue
                        elif resultatRecherche == 1:
                            nouvelleDejaVisite = list()
                            nouvelleDejaVisite = [i for i in listeDejaVisite]
                            nouvelleDejaVisite.append(v)
                            self.DFSVisitPy(
                                v, chainePartielle + str(chr(i)), nouvelleDejaVisite)
                        elif resultatRecherche == 2:
                            nouvelleDejaVisite = [i for i in listeDejaVisite]
                            nouvelleDejaVisite.append(v)
                            # on a trouve un mot
                            self.listeMotsDansGrille.insert(
                                chainePartielle + str(chr(i)))
                            self.DFSVisitPy(
                                v, chainePartielle + str(chr(i)), nouvelleDejaVisite)
                        elif resultatRecherche == 3:
                            # on a trouve un mot
                            self.listeMotsDansGrille.insert(
                                chainePartielle + str(chr(i)))

                else:
                    resultatRecherche = self.dictionnairePy.estDans(chainePartielle + str(v.value))

                    if resultatRecherche == 0:
                        continue
                    elif resultatRecherche == 1:
                        nouvelleDejaVisite = list()
                        nouvelleDejaVisite = [i for i in listeDejaVisite]
                        nouvelleDejaVisite.append(v)
                        self.DFSVisitPy(v, chainePartielle + str(v.value), nouvelleDejaVisite)
                    elif resultatRecherche == 2:
                        nouvelleDejaVisite = [i for i in listeDejaVisite]
                        nouvelleDejaVisite.append(v)
                        # on a trouve un mot
                        self.listeMotsDansGrille.insert(chainePartielle + str(v.value))
                        self.DFSVisitPy(v, chainePartielle + str(v.value), nouvelleDejaVisite)
                    elif resultatRecherche == 3:
                        # on a trouve un mot
                        self.listeMotsDansGrille.insert(chainePartielle + str(v.value))

    """Solution Ruzzle via ServeurC (DFS sur le graphe + verification presence mot distribuee')"""

    def DFS(self):
        for v in self.vertexList:
            if v.value == '*':
                for i in range(97, 123):
                    self.DFSVisit(v, str(chr(i)), None)
            elif self.dictionnaire.estDans(v.value) == 1:
                self.DFSVisit(v, str(v.value), None)

    """
    Renvoie:
    0 -> pas dans l'arbre
    1 -> mot est prefixe
    2 -> mot est prefixe et mot
    3 -> est mot mais pas prefixe
    """

    def DFSVisit(self, vertex, chainePartielle, listeDejaVisite):
        # cas 0, on ajoute la premiere lettre du mot a la liste dejaVisite
        if listeDejaVisite == None:
            listeDejaVisite = [vertex]
        # on passe au prefix successif en ajoutant un voisin si le prefix
        # chainePartielle+voisin existe dans le dictio
        for v in vertex.listeAdjacences:
            # on s'assure de ne pas passer deux fois sur la meme lettre
            if v not in listeDejaVisite:
                resultatRecherche = 0
                if v.value == '*':
                    for i in range(97, 123):
                        resultatRecherche = self.dictionnaire.estDans(
                            chainePartielle + str(chr(i)))
                        if resultatRecherche == 0:
                            continue
                        elif resultatRecherche == 1:
                            nouvelleDejaVisite = list()
                            nouvelleDejaVisite = [i for i in listeDejaVisite]
                            nouvelleDejaVisite.append(v)
                            self.DFSVisit(
                                v, chainePartielle + str(chr(i)), nouvelleDejaVisite)
                        elif resultatRecherche == 2:
                            nouvelleDejaVisite = [i for i in listeDejaVisite]
                            nouvelleDejaVisite.append(v)
                            # on a trouve un mot
                            self.listeMotsDansGrille.insert(
                                chainePartielle + str(chr(i)))
                            self.DFSVisit(
                                v, chainePartielle + str(chr(i)), nouvelleDejaVisite)
                        elif resultatRecherche == 3:
                            # on a trouve un mot
                            self.listeMotsDansGrille.insert(
                                chainePartielle + str(chr(i)))
                else:
                    resultatRecherche = self.dictionnaire.estDans(
                        chainePartielle + v.value)
                    if resultatRecherche == 0:
                        continue
                    elif resultatRecherche == 1:
                        nouvelleDejaVisite = list()
                        nouvelleDejaVisite = [i for i in listeDejaVisite]
                        nouvelleDejaVisite.append(v)
                        self.DFSVisit(
                            v, chainePartielle + str(v.value), nouvelleDejaVisite)
                    elif resultatRecherche == 2:
                        nouvelleDejaVisite = [i for i in listeDejaVisite]
                        nouvelleDejaVisite.append(v)
                        # on a trouve un mot
                        self.listeMotsDansGrille.insert(
                            chainePartielle + str(v.value))
                        self.DFSVisit(
                            v, chainePartielle + str(v.value), nouvelleDejaVisite)
                    elif resultatRecherche == 3:
                        # on a trouve un mot
                        self.listeMotsDansGrille.insert(
                            chainePartielle + str(v.value))

    # methodes de gestion du Jeu en mode Multiplayer
    def gererFinMatch(self, listeTrouvees):
        print("Time's UP!!!")
        if listeTrouvees.len() > 0:
            print("Score --> ", listeTrouvees.len())
            print("Mots Trouvees...")
            listeTrouvees.printDecroissant()
            print("Fin PARTIE!")
            self.matchEnded = True
        else:
            print("Aucun Mot a ete' trouve'!!!!\nScore --> 0")
            print("Fin PARTIE!")
            self.matchEnded = True

    def playOneMatch(self):
        listeTrouvees = ListeMots()
        self.affichageTableRuzzle()
        temps = float(
            input("\nSaisir le temps de duree de votre defi (en secondes)!\ntemps = "))
        timer = Timer(temps, self.gererFinMatch, [listeTrouvees])
        timer.start()
        print("Saisir les mots que vous trouvez dans la grille!...\n")
        while True:
            if self.matchEnded == True:
                sys.exit()
            mot = input("mot -> ")
            if self.listeMotsDansGrille.estDans(mot):
                listeTrouvees.insert(mot)

    def playChallenge(self, challengeTime):
        self.affichageTableRuzzle()
        start_time = time.time()
        while True:
            current_time = time.time() - start_time
            if current_time > float(challengeTime):
                print("\n***********************")
                print("Mots Trouves --> ", self.listeTrouvees.len())
                print("***********************")
                self.listeTrouvees.printDecroissant()
                print("***********************")
                return
            mot = input("mot -> ")
            if self.listeMotsDansGrille.estDans(mot):
                self.listeTrouvees.insert(mot)

    # methodes de Resolution automatique du Ruzzle
    """resolution ruzzle via C-ServerTree"""

    def generationM1(self, bool_print):
        start_time = time.time()
        self.DFS()
        end_time = time.time()

        print("Execution Time -> ", end_time - start_time)
        print("Mots Trouves: " + str(self.listeMotsDansGrille.len()) + "\n")
        if bool_print is True:
            self.listeMotsDansGrille.printDecroissant()

    """resolution ruzzle via Py-ServerTree"""

    def generationM1b(self, parcourDictionnaire, bool_print):
        start_time = time.time()
        self.DFSPy(parcourDictionnaire)
        end_time = time.time()

        print("Execution Time -> ", end_time - start_time)
        print("Mots Trouves: " + str(self.listeMotsDansGrille.len()) + "\n")
        if bool_print is True:
            self.listeMotsDansGrille.printDecroissant()

    """resolution ruzzle via methode 2 (on verifie la presence de chaque mot du Dictionnaire dans la grille)"""

    def generationM2(self, ruzzleGraph, parcourDictionnaire, bool_print):
        dictionnaire = ArbreLex(parcourDictionnaire)
        start_time = time.time()
        listeMotsDansGrille = dictionnaire.generePossiblesMots(ruzzleGraph)
        end_time = time.time()

        print("Execution Time -> ", end_time - start_time)
        print("Mots Trouves: " + str(listeMotsDansGrille.len()) + "\n")
        if bool_print is True:
            listeMotsDansGrille.printDecroissant()
Example #9
0
 def __init__(self, vertexList, dictionnaire):
     self.matchEnded = False
     self.vertexList = vertexList
     self.dictionnaire = dictionnaire
     self.listeMotsDansGrille = ListeMots()
     self.listeTrouvees = ListeMots()
Example #10
0
 def __init__(self, parcoursDict):
     self.noeudRoot = Noeud("", None, None)
     self.chargeDictionnaire(parcoursDict)
     self.listeMotsDansGrille = ListeMots()
Example #11
0
class ArbreLex:

    def __init__(self, parcoursDict):
        self.noeudRoot = Noeud("", None, None)
        self.chargeDictionnaire(parcoursDict)
        self.listeMotsDansGrille = ListeMots()

    def generePossiblesMots(self, graph):
        self.parcourReturnArbre("", self.noeudRoot, graph)
        return self.listeMotsDansGrille

    """Methodes Construction de l'arbre"""

    def ajouteFils(self, lettre, noeud):
        n = Noeud(lettre, None, None)
        if noeud.fils is None:
            noeud.fils = n
            return noeud.fils
        else:
            ptr = noeud.fils
            while(ptr.frere is not None):
                ptr = ptr.frere
            ptr.frere = n
            return ptr.frere

    def estDans(self, mot):
        ptr = self.noeudRoot
        for i in range(0, len(mot)):
            #print(mot[i])
            #if mot[i] == 's':
            #    print(self.printFils(ptr))
            ptr = self.estFilsDe(mot[i], ptr)
            if ptr is None:
                return 0
        ptr = self.estFilsDe('-', ptr)
        if ptr is None:
            return 1
        else:
            ptr = ptr.frere
            if ptr is None:
                return 3
            else:
                return 2

    def estFilsDe(self, lettre, noeud):
        if noeud.fils is None:
            return None
        if noeud.fils.car == lettre:
            return noeud.fils
        else:
            ptr = noeud.fils
            while ptr.frere is not None:
                if ptr.frere.car == lettre:
                    return ptr.frere
                ptr = ptr.frere
            return None

    def ajouteMot(self, mot):
        ptr = self.noeudRoot
        ptr2 = ptr
        for i in range(0, len(mot)):
            ptr = self.estFilsDe(mot[i], ptr)
            if ptr is not None:
                ptr2 = ptr
                continue
            else:
                for j in range(i, len(mot)):
                    ptr2 = self.ajouteFils(mot[j], ptr2)
                ptr2 = self.ajouteFils('-', ptr2)
                return True

    def chargeDictionnaire(self, parcour):

        fichier = open(parcour, 'r')
        for ligne in fichier.readlines():
            self.ajouteMot(ligne[0:len(ligne) - 1])

    """Fonctions de recherche"""

    def rechercheMot(self, mot):
        ptr = self.noeudRoot
        for car in mot:
            ptr = self.estFilsDe(car, ptr)
            if ptr is not None:
                continue
            else:
                return False
        if self.estFilsDe('-', ptr):
            return True
        else:
            return False

    """Imprime tous les mots contenus dans l'arbre lexicographique a l'ecran"""

    def parcourPrintArbre(self, mot, n):
        ptr = n.fils
        while ptr is not None:
            if ptr.car == '-':
                print(mot)
                ptr = ptr.frere
                continue
            self.parcourPrintArbre(mot + ptr.car, ptr)
            ptr = ptr.frere

    def parcourReturnArbre(self, mot, n, graph):
        ptr = n.fils
        while ptr is not None:
            if ptr.car == '-':
                if graph.motEstDansGraphe(mot) is True:
                    self.listeMotsDansGrille.insert(mot)
                ptr = ptr.frere
                continue
            self.parcourReturnArbre(mot + ptr.car, ptr, graph)
            ptr = ptr.frere
Example #12
0
def main():
    # initialisation variables
    langue = ""
    parcourDictionnaire = ""
    for par in sys.argv:
        if par == "en":
            langue = "en"
            parcourDictionnaire = "./ressources/dictEn"
        if par == "fr":
            langue = "fr"
            parcourDictionnaire = "./ressources/dictFr"

    # creation de la grille de jeu
    ruzzle = RuzzleMatrix(langue)
    grafoRuzzle = RuzzleGraph(ruzzle.vertexMatrixToGraph(), None)

    # methode 1 (ArbreLexServeur C)
    if sys.argv[1] == "-m1":
        grafoRuzzle.affichageTableRuzzle()
        print("\n\n")

        grafoRuzzle.dictionnaire = ClientDictionnaire(int(sys.argv[2]))
        grafoRuzzle.generationM1(True)

    # methode 1b (ArbreLex en Python)
    elif sys.argv[1] == "-m1b":
        grafoRuzzle.affichageTableRuzzle()
        print("\n\n")
        grafoRuzzle.generationM1b(parcourDictionnaire, True)

    # methode 2 (ArbreLex en Python)
    elif sys.argv[1] == "-m2":
        grafoRuzzle.affichageTableRuzzle()
        print("\n\n")
        grafoRuzzle.generationM2(grafoRuzzle, parcourDictionnaire, True)

    # Statistiques - Comparation de performances m1 - m1b - m2
    elif sys.argv[1] == "-s":
        grafoRuzzle.dictionnaire = ClientDictionnaire(int(sys.argv[2]))
        grafoRuzzle.affichageTableRuzzle()

        print("Methode 1 (ArbreLexServeur C) --> ")
        grafoRuzzle.generationM1(False)
        grafoRuzzle.listeMotsDansGrille = ListeMots()

        print("Methode 1b (ArbreLex Python) --> ")
        grafoRuzzle.generationM1b(parcourDictionnaire, False)
        grafoRuzzle.listeMotsDansGrille = ListeMots()

        print("\nMethode 2 (Py - Parcours Diction) --> ")
        grafoRuzzle.generationM2(grafoRuzzle, parcourDictionnaire, False)

    # Multiplayer Mode - Server Side
    elif sys.argv[1] == "-server":
        print("Generation Liste Mots A Trouver...")
        grafoRuzzle.generationM2(grafoRuzzle, parcourDictionnaire, False)
        print("\nEn attente de connexion pour une defi!")
        serverGame = ServerGame('localhost', int(sys.argv[2]), grafoRuzzle)
        serverGame.waitForOpponent()

    # Multiplayer Mode - Client Side
    elif sys.argv[1] == "-client":
        print("Generation Liste Mots A Trouver...")
        grafoRuzzle.generationM2(grafoRuzzle, parcourDictionnaire, False)
        clientGame = ClientGame(sys.argv[2], int(sys.argv[3]), grafoRuzzle)
        temps = int(input("saisir temps du defi : "))
        clientGame.sendChallenge(temps)

    # mode Single Player
    else:
        dictionnaire = ArbreLex(parcourDictionnaire)
        dictionnaire.chargeDictionnaire(parcourDictionnaire)
        dictionnaire.generePossiblesMots(grafoRuzzle)
        grafoRuzzle.playOneMatch()
Example #13
0
 def __init__(self, parcoursDict):
     self.noeudRoot = Noeud("", None, None)
     self.chargeDictionnaire(parcoursDict)
     self.listeMotsDansGrille = ListeMots()
Example #14
0
class ArbreLex:
    def __init__(self, parcoursDict):
        self.noeudRoot = Noeud("", None, None)
        self.chargeDictionnaire(parcoursDict)
        self.listeMotsDansGrille = ListeMots()

    def generePossiblesMots(self, graph):
        self.parcourReturnArbre("", self.noeudRoot, graph)
        return self.listeMotsDansGrille

    """Methodes Construction de l'arbre"""

    def ajouteFils(self, lettre, noeud):
        n = Noeud(lettre, None, None)
        if noeud.fils is None:
            noeud.fils = n
            return noeud.fils
        else:
            ptr = noeud.fils
            while (ptr.frere is not None):
                ptr = ptr.frere
            ptr.frere = n
            return ptr.frere

    def estDans(self, mot):
        ptr = self.noeudRoot
        for i in range(0, len(mot)):
            #print(mot[i])
            #if mot[i] == 's':
            #    print(self.printFils(ptr))
            ptr = self.estFilsDe(mot[i], ptr)
            if ptr is None:
                return 0
        ptr = self.estFilsDe('-', ptr)
        if ptr is None:
            return 1
        else:
            ptr = ptr.frere
            if ptr is None:
                return 3
            else:
                return 2

    def estFilsDe(self, lettre, noeud):
        if noeud.fils is None:
            return None
        if noeud.fils.car == lettre:
            return noeud.fils
        else:
            ptr = noeud.fils
            while ptr.frere is not None:
                if ptr.frere.car == lettre:
                    return ptr.frere
                ptr = ptr.frere
            return None

    def ajouteMot(self, mot):
        ptr = self.noeudRoot
        ptr2 = ptr
        for i in range(0, len(mot)):
            ptr = self.estFilsDe(mot[i], ptr)
            if ptr is not None:
                ptr2 = ptr
                continue
            else:
                for j in range(i, len(mot)):
                    ptr2 = self.ajouteFils(mot[j], ptr2)
                ptr2 = self.ajouteFils('-', ptr2)
                return True

    def chargeDictionnaire(self, parcour):

        fichier = open(parcour, 'r')
        for ligne in fichier.readlines():
            self.ajouteMot(ligne[0:len(ligne) - 1])

    """Fonctions de recherche"""

    def rechercheMot(self, mot):
        ptr = self.noeudRoot
        for car in mot:
            ptr = self.estFilsDe(car, ptr)
            if ptr is not None:
                continue
            else:
                return False
        if self.estFilsDe('-', ptr):
            return True
        else:
            return False

    """Imprime tous les mots contenus dans l'arbre lexicographique a l'ecran"""

    def parcourPrintArbre(self, mot, n):
        ptr = n.fils
        while ptr is not None:
            if ptr.car == '-':
                print(mot)
                ptr = ptr.frere
                continue
            self.parcourPrintArbre(mot + ptr.car, ptr)
            ptr = ptr.frere

    def parcourReturnArbre(self, mot, n, graph):
        ptr = n.fils
        while ptr is not None:
            if ptr.car == '-':
                if graph.motEstDansGraphe(mot) is True:
                    self.listeMotsDansGrille.insert(mot)
                ptr = ptr.frere
                continue
            self.parcourReturnArbre(mot + ptr.car, ptr, graph)
            ptr = ptr.frere
Example #15
0
class RuzzleGraph:
    def __init__(self, vertexList, dictionnaire):
        self.matchEnded = False
        self.vertexList = vertexList
        self.dictionnaire = dictionnaire
        self.listeMotsDansGrille = ListeMots()
        self.listeTrouvees = ListeMots()

    # methodes de construction et affichage
    def ajouteVertex(self, vertex):
        self.vertexList.append(vertex)

    def printSimpleGraph(self):
        for v in self.vertexList:
            print(v.value, " --> ", end='')
            for adj in v.listeAdjacences:
                print(adj.value, end='')
            print("")

    def affichageTableRuzzle(self):
        # print ligne 0
        print("  ", end='')
        for i in range(0, 5):
            if i % 2 == 0:
                print("/" + self.vertexList[i].value + "\\", end='')
            else:
                print(self.vertexList[i].value, end='')
        print("")
        # print ligne 1
        for i in range(5, 12):
            if i % 2 != 0:
                print("/" + self.vertexList[i].value + "\\", end='')
            else:
                print(self.vertexList[i].value, end='')
        print("")
        # print ligne 2
        for i in range(12, 19):
            if i % 2 == 0:
                print("\\" + self.vertexList[i].value + "/", end='')
            else:
                print(self.vertexList[i].value, end='')
        print("")
        # print ligne 3
        print("  ", end='')
        for i in range(19, 24):
            if i % 2 != 0:
                print("\\" + self.vertexList[i].value + "/", end='')
            else:
                print(self.vertexList[i].value, end='')
        print("")

    """Verification presence du mot dans la grille Ruzzle (pour methode 2)"""

    def motEstDansGraphe(self, mot):
        for vertex in self.vertexList:
            if vertex.value == mot[0] or vertex.value == '*':
                if self.motEstDansGrapheN(mot, vertex, "", None) is True:
                    return True

        return False

    def motEstDansGrapheN(self, mot, n, chainePartielle, listeDejaVisite):
        i = len(chainePartielle)

        if chainePartielle == mot:
            return True

        if i >= len(mot):
            return False

        # initialisation listeDejaVisite
        if i == 0:
            if mot[0] == n.value:
                listeDejaVisite = [n]
                return self.motEstDansGrapheN(mot, n, str(n.value),
                                              listeDejaVisite)
            elif n.value == '*':
                listeDejaVisite = [n]
                for car in range(97, 123):
                    result = self.motEstDansGrapheN(mot, n, str(chr(car)),
                                                    listeDejaVisite)
                    if result is True:
                        return True
                    else:
                        continue
            else:
                return False

        else:  # cas i != 0, on a deja trouve le premier caractere du mot
            bonVoisin = False
            for vertex in n.listeAdjacences:
                if vertex.value == mot[i] and vertex not in listeDejaVisite:
                    bonVoisin = True
                    nouvelleDejaVisite = [el for el in listeDejaVisite]
                    nouvelleDejaVisite.append(vertex)

                    # on verifie la presence du caractere suivant dans le graphe
                    result = self.motEstDansGrapheN(
                        mot, vertex,
                        str(chainePartielle) + str(vertex.value),
                        nouvelleDejaVisite)
                    if result is True:
                        return True
                    else:
                        continue
                elif vertex.value == '*' and vertex not in listeDejaVisite:
                    nouvelleDejaVisite = [el for el in listeDejaVisite]
                    nouvelleDejaVisite.append(vertex)
                    for car in range(97, 123):
                        result = self.motEstDansGrapheN(
                            mot, vertex,
                            str(chainePartielle) + str(chr(car)),
                            nouvelleDejaVisite)
                        if result is True:
                            return True

            if bonVoisin == False:
                return False

    """Solution Ruzzle via Dictionnaire Python (DFS sur le graphe + verification presence mot non distribuee')"""

    def DFSPy(self, parcourDictionnaire):
        self.dictionnairePy = ArbreLex(parcourDictionnaire)
        for v in self.vertexList:
            if v.value == '*':
                for i in range(97, 123):
                    if self.dictionnairePy.estDans(str(chr(i))) == 1:
                        self.DFSVisitPy(v, str(chr(i)), None)

            if self.dictionnairePy.estDans(v.value) == 1:
                self.DFSVisitPy(v, str(v.value), None)

    def DFSVisitPy(self, vertex, chainePartielle, listeDejaVisite):
        # cas 0, on ajoute la premiere lettre du mot a la liste dejaVisite
        if listeDejaVisite == None:
            listeDejaVisite = [vertex]
        # on passe au prefix successif en ajoutant un voisin si le prefix
        # chainePartielle+voisin existe dans le dictio
        for v in vertex.listeAdjacences:
            # on s'assure de ne pas passer deux fois sur la meme lettre
            if v not in listeDejaVisite:
                resultatRecherche = 0
                if v.value == '*':
                    for i in range(97, 123):
                        resultatRecherche = self.dictionnairePy.estDans(
                            chainePartielle + str(chr(i)))
                        if resultatRecherche == 0:
                            continue
                        elif resultatRecherche == 1:
                            nouvelleDejaVisite = list()
                            nouvelleDejaVisite = [i for i in listeDejaVisite]
                            nouvelleDejaVisite.append(v)
                            self.DFSVisitPy(v, chainePartielle + str(chr(i)),
                                            nouvelleDejaVisite)
                        elif resultatRecherche == 2:
                            nouvelleDejaVisite = [i for i in listeDejaVisite]
                            nouvelleDejaVisite.append(v)
                            # on a trouve un mot
                            self.listeMotsDansGrille.insert(chainePartielle +
                                                            str(chr(i)))
                            self.DFSVisitPy(v, chainePartielle + str(chr(i)),
                                            nouvelleDejaVisite)
                        elif resultatRecherche == 3:
                            # on a trouve un mot
                            self.listeMotsDansGrille.insert(chainePartielle +
                                                            str(chr(i)))

                else:
                    resultatRecherche = self.dictionnairePy.estDans(
                        chainePartielle + str(v.value))

                    if resultatRecherche == 0:
                        continue
                    elif resultatRecherche == 1:
                        nouvelleDejaVisite = list()
                        nouvelleDejaVisite = [i for i in listeDejaVisite]
                        nouvelleDejaVisite.append(v)
                        self.DFSVisitPy(v, chainePartielle + str(v.value),
                                        nouvelleDejaVisite)
                    elif resultatRecherche == 2:
                        nouvelleDejaVisite = [i for i in listeDejaVisite]
                        nouvelleDejaVisite.append(v)
                        # on a trouve un mot
                        self.listeMotsDansGrille.insert(chainePartielle +
                                                        str(v.value))
                        self.DFSVisitPy(v, chainePartielle + str(v.value),
                                        nouvelleDejaVisite)
                    elif resultatRecherche == 3:
                        # on a trouve un mot
                        self.listeMotsDansGrille.insert(chainePartielle +
                                                        str(v.value))

    """Solution Ruzzle via ServeurC (DFS sur le graphe + verification presence mot distribuee')"""

    def DFS(self):
        for v in self.vertexList:
            if v.value == '*':
                for i in range(97, 123):
                    self.DFSVisit(v, str(chr(i)), None)
            elif self.dictionnaire.estDans(v.value) == 1:
                self.DFSVisit(v, str(v.value), None)

    """
    Renvoie:
    0 -> pas dans l'arbre
    1 -> mot est prefixe
    2 -> mot est prefixe et mot
    3 -> est mot mais pas prefixe
    """

    def DFSVisit(self, vertex, chainePartielle, listeDejaVisite):
        # cas 0, on ajoute la premiere lettre du mot a la liste dejaVisite
        if listeDejaVisite == None:
            listeDejaVisite = [vertex]
        # on passe au prefix successif en ajoutant un voisin si le prefix
        # chainePartielle+voisin existe dans le dictio
        for v in vertex.listeAdjacences:
            # on s'assure de ne pas passer deux fois sur la meme lettre
            if v not in listeDejaVisite:
                resultatRecherche = 0
                if v.value == '*':
                    for i in range(97, 123):
                        resultatRecherche = self.dictionnaire.estDans(
                            chainePartielle + str(chr(i)))
                        if resultatRecherche == 0:
                            continue
                        elif resultatRecherche == 1:
                            nouvelleDejaVisite = list()
                            nouvelleDejaVisite = [i for i in listeDejaVisite]
                            nouvelleDejaVisite.append(v)
                            self.DFSVisit(v, chainePartielle + str(chr(i)),
                                          nouvelleDejaVisite)
                        elif resultatRecherche == 2:
                            nouvelleDejaVisite = [i for i in listeDejaVisite]
                            nouvelleDejaVisite.append(v)
                            # on a trouve un mot
                            self.listeMotsDansGrille.insert(chainePartielle +
                                                            str(chr(i)))
                            self.DFSVisit(v, chainePartielle + str(chr(i)),
                                          nouvelleDejaVisite)
                        elif resultatRecherche == 3:
                            # on a trouve un mot
                            self.listeMotsDansGrille.insert(chainePartielle +
                                                            str(chr(i)))
                else:
                    resultatRecherche = self.dictionnaire.estDans(
                        chainePartielle + v.value)
                    if resultatRecherche == 0:
                        continue
                    elif resultatRecherche == 1:
                        nouvelleDejaVisite = list()
                        nouvelleDejaVisite = [i for i in listeDejaVisite]
                        nouvelleDejaVisite.append(v)
                        self.DFSVisit(v, chainePartielle + str(v.value),
                                      nouvelleDejaVisite)
                    elif resultatRecherche == 2:
                        nouvelleDejaVisite = [i for i in listeDejaVisite]
                        nouvelleDejaVisite.append(v)
                        # on a trouve un mot
                        self.listeMotsDansGrille.insert(chainePartielle +
                                                        str(v.value))
                        self.DFSVisit(v, chainePartielle + str(v.value),
                                      nouvelleDejaVisite)
                    elif resultatRecherche == 3:
                        # on a trouve un mot
                        self.listeMotsDansGrille.insert(chainePartielle +
                                                        str(v.value))

    # methodes de gestion du Jeu en mode Multiplayer
    def gererFinMatch(self, listeTrouvees):
        print("Time's UP!!!")
        if listeTrouvees.len() > 0:
            print("Score --> ", listeTrouvees.len())
            print("Mots Trouvees...")
            listeTrouvees.printDecroissant()
            print("Fin PARTIE!")
            self.matchEnded = True
        else:
            print("Aucun Mot a ete' trouve'!!!!\nScore --> 0")
            print("Fin PARTIE!")
            self.matchEnded = True

    def playOneMatch(self):
        listeTrouvees = ListeMots()
        self.affichageTableRuzzle()
        temps = float(
            input(
                "\nSaisir le temps de duree de votre defi (en secondes)!\ntemps = "
            ))
        timer = Timer(temps, self.gererFinMatch, [listeTrouvees])
        timer.start()
        print("Saisir les mots que vous trouvez dans la grille!...\n")
        while True:
            if self.matchEnded == True:
                sys.exit()
            mot = input("mot -> ")
            if self.listeMotsDansGrille.estDans(mot):
                listeTrouvees.insert(mot)

    def playChallenge(self, challengeTime):
        self.affichageTableRuzzle()
        start_time = time.time()
        while True:
            current_time = time.time() - start_time
            if current_time > float(challengeTime):
                print("\n***********************")
                print("Mots Trouves --> ", self.listeTrouvees.len())
                print("***********************")
                self.listeTrouvees.printDecroissant()
                print("***********************")
                return
            mot = input("mot -> ")
            if self.listeMotsDansGrille.estDans(mot):
                self.listeTrouvees.insert(mot)

    # methodes de Resolution automatique du Ruzzle
    """resolution ruzzle via C-ServerTree"""

    def generationM1(self, bool_print):
        start_time = time.time()
        self.DFS()
        end_time = time.time()

        print("Execution Time -> ", end_time - start_time)
        print("Mots Trouves: " + str(self.listeMotsDansGrille.len()) + "\n")
        if bool_print is True:
            self.listeMotsDansGrille.printDecroissant()

    """resolution ruzzle via Py-ServerTree"""

    def generationM1b(self, parcourDictionnaire, bool_print):
        start_time = time.time()
        self.DFSPy(parcourDictionnaire)
        end_time = time.time()

        print("Execution Time -> ", end_time - start_time)
        print("Mots Trouves: " + str(self.listeMotsDansGrille.len()) + "\n")
        if bool_print is True:
            self.listeMotsDansGrille.printDecroissant()

    """resolution ruzzle via methode 2 (on verifie la presence de chaque mot du Dictionnaire dans la grille)"""

    def generationM2(self, ruzzleGraph, parcourDictionnaire, bool_print):
        dictionnaire = ArbreLex(parcourDictionnaire)
        start_time = time.time()
        listeMotsDansGrille = dictionnaire.generePossiblesMots(ruzzleGraph)
        end_time = time.time()

        print("Execution Time -> ", end_time - start_time)
        print("Mots Trouves: " + str(listeMotsDansGrille.len()) + "\n")
        if bool_print is True:
            listeMotsDansGrille.printDecroissant()
Example #16
0
 def __init__(self, vertexList, dictionnaire):
     self.matchEnded = False
     self.vertexList = vertexList
     self.dictionnaire = dictionnaire
     self.listeMotsDansGrille = ListeMots()
     self.listeTrouvees = ListeMots()