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 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 __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)
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)
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)
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)
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)
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()
def __init__(self, vertexList, dictionnaire):
self.matchEnded = False
self.vertexList = vertexList
self.dictionnaire = dictionnaire
self.listeMotsDansGrille = ListeMots()
self.listeTrouvees = ListeMots()
def __init__(self, parcoursDict):
self.noeudRoot = Noeud("", None, None)
self.chargeDictionnaire(parcoursDict)
self.listeMotsDansGrille = ListeMots()
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
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()
def __init__(self, parcoursDict):
self.noeudRoot = Noeud("", None, None)
self.chargeDictionnaire(parcoursDict)
self.listeMotsDansGrille = ListeMots()
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
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()
def __init__(self, vertexList, dictionnaire):
self.matchEnded = False
self.vertexList = vertexList
self.dictionnaire = dictionnaire
self.listeMotsDansGrille = ListeMots()
self.listeTrouvees = ListeMots()