def newGrid():
vals = readGridFile()
grid.fillByRowLines(vals)
gridInit.copyFrom(grid)
ui.display("Grille test choisie : grid = ")
grid.show()
ui.displayGridAll(grid)
def loopStep(tech):
'''Exécute une itération de la boucle de pensée ROMA avec l'instance
de TechChRCgridAll indiquée en argument.
'''
if view.isCompleted():
ui.display("loopTech - Grille terminée, c'est gagné !")
return "win"
r = tech.apply(mem)
action = r[0]
TEST.display("loop", 2,
"loopStep - Résultat de tech.apply() : {0}".format(r))
status = tech.status(mem)
TEST.display("loop", 3,
"loopStep - statut d'avancement de tech: {0}".format(status))
if action == "observe":
pattern = r[1]
found = view.lookup(pattern)
mem.memorizeObs(found, tech)
TEST.display("loop", 2,
"loopStep - Résultat de view.lookup() : {0}".format(found))
tech.obsFound(mem, found)
elif action == "place":
placement = r[1]
(row, col, val) = placement
TEST.display("loop", 1, "loopStep - Placement de {0} en ({1}, {2})"\
.format(val, row, col))
valid = view.place(placement)
TEST.display("loop", 2,
"loopStep - Résultat de view.place() : {0}".format(r))
tech.placeOk(mem, valid)
ui.displayGridPlace(grid, row, col)
TEST.display("loop", 2,
"loopStep - Action exécutée par la tech : {0}".format(action))
return action
def show(self):
'''Affiche le contenu de s'ensemble de règles.'''
TEST.display("ai", 3, "SudoAI - dans AIruleSet.show()")
ui.display("Le système contient {0} règles. Valeurs :" \
.format(self.nb))
self.disp()
return
def display(self, key, level, txt):
'''Affiche le texte si la clé est dans le dict et si son niveau
est >= à celui demandé.
Par exception, le texte n'est pas affiché si le niveau demandé
est 0 (zéro) même si le niveau de la clé est 0.
Le texte est affichée dans l'interface STD ou GUI suivant le mode actif.
'''
#ne fait rien en mode 'quiet'
if self._beQuiet is True:
return None
keylev = self._tstdict.get(str(key), None) #None si clé absente
if keylev != None and keylev >= level:
if self._modeUI == MODE_GUI \
or (self._modeUI in (MODE_SELECT, MODE_BOTH) \
and level <= self._modeUIlevel):
ui.display(txt) #dans l'interface active STD ou GUI
if self._modeUI == MODE_STD \
or (self._modeUI == MODE_SELECT and level > self._modeUIlevel) \
or self._modeUI == MODE_BOTH:
ui.displaySTD(txt) #dans la console STD
#s'il y a un affichage graphique, mettre à jour la fenêtre
if self._modeUI in (MODE_GUI, MODE_BOTH):
ui.updateGUI()
pass
return
def loopTechOld(tech, grid, mem, obs):
if grid.isCompleted():
ui.display("Grille terminée")
return
TEST.display("loop", 2, "Début de boucle")
r = tech.apply(mem)
action = r[0]
TEST.display("loop", 2, "Résultat de tech.solve() : {0}".format(r))
TEST.display("loop", 2,
"statut d'avancement de tech: {0}".format(tech.status(mem)))
if action == "observe":
pattern = r[1]
found = obs.lookup(grid, pattern)
TEST.display("loop", 1, "Résultat de obs.lookup() : {0}".format(found))
mem.memorizeObs(found, tech)
elif action == "place":
placement = r[1]
(row, col, chiffre) = placement
r = grid.placeRC(row, col, chiffre, True)
TEST.display("loop", 1, "Résultat de grid.place() : {0}".format(r))
elif action == "continue":
pass
else:
TEST.display("loop", 2,
"action retournée par solve() : {0}".format(action))
return
def reset(grid, think, view):
gr.fillByRowLines(vals)
# grid.copyFrom(gridInit)
mem = SudoMemory()
view = SudoGridView(grid)
think = SudoThinking(mem, view)
## think.init(mem)
ui.display("Le test est réinitialisé")
def testDispKeys(self):
'''Affiche en liste les clés du système de test de code.'''
keys = self._test.keys #dictionnaire des clés
if len(keys) == 0:
ui.display("Aucune clé dans TEST.")
else:
for testkey in keys:
ui.display("\"{0}\" : {1}".format(testkey, keys[testkey]))
return
def testNewGrid():
vals = testReadGridFileNum()
grid = gr.SudoGrid()
grid.fillByRowLines(vals)
ui.display("Grille test choisie : grid = ")
grid.show()
#testShowGrid(grid)
## ui.displayGridClear()
## ui.displayGridAll(grid)
return grid
def newPlayer(self, name=None):
'''Crée pour l'application un nouveau joueur avec le nom indiqué.
Cela oblige à annuler toute résolution de grille en cours. S'il y a
une grille chargée, elle est réinitialisée.
'''
TEST.display("app", 3, "SudoApp - dans newPlayer()")
if name is None:
name = self._defaultPlayerName
self._player = SudoPlayer(name)
if self._playing is True:
ui.display("Nouveau joueur", "La partie en cours est annulée.")
#self.abortGame() #abandonner sans perdre les stats
self.resetPlayingGrid()
return self._player
def newPlayer(self, name=None):
'''Crée pour l'application un nouveau joueur avec le nom indiqué.
Cela oblige à annuler toute résolution de grille en cours. S'il y a
une grille chargée, elle est réinitialisée.
Transfert l'objet d'environnement à la classe SudoPlayer.
'''
TEST = self.env.TEST
TEST.display("simpleapp", 3, "SudoSimpleApp - dans newPlayer()")
if name is None:
name = self._defaultPlayerName
#créer l'objet player et lui transmettre l'environnement
self._player = SudoPlayer(name, env=self._env)
if self._playing is True:
ui.display("Nouveau joueur", "La partie en cours est annulée.")
#self.abortGame() #abandonner sans perdre les stats
self.resetPlayingGrid()
return self._player
def loopTech(tech, pause=False):
'''Cette fonction applique répétitivement la technique 'LastPlc' sur la
grille 'grid' jusqu'à un certain état d'avancement. Par exemple faire tous
les carrés, ou tous les carrés et rangs, etc.
'''
TEST.display("loop", 1,
"Boucle de résolution de TechLastPlc sur tous les carrés")
tech.reset(mem)
grid = gr
iter = 0
while True:
if grid.isCompleted():
print("\nGrille terminée.")
return
status = loopStep(tech)
#contrôler fin du while
iter += 1
if iter > 100:
TEST.display("loop", 0,
"Plus de 100 itérations de boucle !!! Stop.")
break
# if status[0] not in ("sqr", "row", "col"):
if status[0] not in ("sqr", "row"):
TEST.display(
"loop", 1,
"Boucle : les carrés, rangs et colonnes sont terminés.")
break
if pause:
r = ui.sudoPause(True)
if r:
ui.display("")
else: #Ctrl-C ou Ctrl-D
ui.display("Interruption clavier")
break
continue
# tech.abort(mem)
return
def readGridFile():
ui.display("Choisir un fichier de test")
fich = ui.sudoNumTestFich()
if not fich:
ui.display("Abandon")
exit()
ui.display("Fichier choisi : {0}\n".format(fich))
vals = ui.sudoFichReadLines(fich)
return vals
def show(self):
'''Affiche toutes les valeurs du système de décision AI.'''
ui.display("Le système contient {0} données, {1} critères et " \
"{2} règles.\nValeurs des données :" \
.format(self.data.nb, self.crits.nb, self.rules.nb))
self.data.disp()
ui.display("Valeurs des critères :")
self.crits.disp()
ui.display("Valeurs des règles :")
self.rules.disp()
return
def loopTech(tech, pause=False):
'''Applique itérativement la technique indiquée en bouclant loopStep()
jusqu'à ce que la technique retourne 'end' pour indiquer sa fin. Permet
de demander une pause clavier à chaque boucle.
'''
TEST.display("loop", 1,
"Boucle de résolution de TechChRCgridAll sur la grille "\
"entière et pour tous les chiffres.")
global grid
iter = 0
while True:
TEST.display("loop", 2, "\nloopTech - Début de boucle")
if view.isCompleted():
ui.display("loopTech - Grille terminée, c'est gagné !")
return
action = loopStep(tech)
#éviter une boucle infinie
iter +=1
if iter > 200:
ui.displaySTD("loopTech - STOP, plus de 100 itérations de boucle !!!")
break
#fin de la technique
if action == "end":
break
#si une pause de boucle est demandée
if pause:
r = ui.sudoPause(True)
if r:
ui.displaySTD("")
else: #Ctrl-C ou Ctrl-D
ui.display("Interruption clavier")
break
continue
if view.isCompleted():
ui.display("loopTech - Grille terminée, c'est gagné !")
return
ui.displayGridAll(grid)
def level(lev):
TEST.levelAll(lev)
if __name__ == "__main__":
import sudogrid
#TEST
import sudotestall
testlevel = 3
TEST.levelAll(testlevel)
ui.display("Tous les niveaux de test sont à {0}".format(testlevel))
#mode GUI
ui.UImode(ui.GUI)
TEST.displayUImode(MODE_BOTH, 1)
#Grille
TEST.display("main", 1, "\nCréation de la grille")
grid = sudogrid.SudoGrid()
gridInit = sudogrid.SudoGrid()
newGrid()
ui.display("\nTest du module techlplcr")
ui.display("Test de la technique de résolution LastPlcRow")
ui.display("------------------------------------------\n")
david = None
def go():
global david
resetGrid()
david.solve(grid, params)
return
def resetGrid():
global grid
testShowGrid(grid)
return
#Initialisation des tests
TEST.level("main", 1)
ui.display("\nTest du module sudoplayer")
ui.display("----------------------------\n")
newGrid()
TEST.display("main", 1, "\nCréation et initialisation du joueur")
TEST.display("main", 1, "Création du joueur : 'david'")
david = pl.SudoPlayer("David")
#Niveaux de commentaires pour la partie
TEST.level("thinkai", 1)
# TEST.level("player", 3)
# TEST.level("game", 3)
#Paramètres de la partie
params = None
#Jeu
TEST.display("main", 1, "Prêt à jouer.\n")
print("\n...>>> david.solve(grid) \nou >>> go()")
def printAll(self):
"""Ecrit la totalité du contenu de la mémoire"""
assert self._initOk
for i in self._mem:
ui.display("{0} : {1}".format(i, self._mem[i][0]))
return
return "instance de {0}".format(self.techName())
def __str__(self):
return "Technique de résolution 'Chiffre/rang-colonne' sur toute la "\
"grille pour le chiffre {0}".format(self._chiffre)
##TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST
##TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST
if __name__ == "__main__":
import sudotestall
testlevel = 3
TEST.levelAll(testlevel)
ui.display("Tous les niveaux de test sont à {0}".format(testlevel))
#mode GUI
ui.UImode(ui.GUI)
TEST.displayUImode(MODE_BOTH, 2)
import sudogrid
from sudogridview import SudoGridView
ui.display("\nTest du module techrcg.py")
ui.display("Technique de résolution TechChRCgrid")
ui.display("------------------------------------\n")
list9 = [2, 5, 0, 6, 8, 0, 0, 3, 4]
ui.display("Choisir un fichier de test")
fich = ui.sudoNumTestFich()
if not fich:
def instName(self):
return "instance de {0}".format(self.techName())
def __str__(self):
return "Technique de résolution 'Dernier placement' sur une colonne"
##TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST
##TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST
if __name__ == "__main__":
import sudotestall
testlevel = 3
TEST.levelAll(testlevel)
ui.display("Tous les niveaux de test sont à {0}".format(testlevel))
import sudogrid
# from sudoobserver import SudoObserver
ui.display("\nTest du module techlplcr")
ui.display("Test de la technique de résolution LastPlcCol")
ui.display("------------------------------------------\n")
list9 = [2,5,0,6,8,0,0,3,4]
ui.display("Choisir un fichier de test")
fich = ui.sudoNumTestFich()
if not fich:
ui.display("Abandon")
exit()
ui.display("Fichier choisi : {0}\n".format(fich))
vals = ui.sudoFichReadLines(fich)
def disp(self):
'''Liste la valeur actuelle de toutes les règles.'''
for r in self._rules.values():
ui.display("{0} = {1}".format(r.name, r.val))
return
def show(self):
'''Liste la valeur actuelle de tous les critères.'''
ui.display("Evaluation des critères : ")
for cr in self._crits.values():
ui.display("{0} : {1}".format(cr.name, cr.val))
return
def disp(self):
'''Liste la valeur actuelle de tous les critères.'''
for cr in self._crits.values():
ui.display("{0} = {1}".format(cr.name, cr.val))
return
def show(self):
'''Liste la valeur actuelle de tous les critères.'''
ui.display("Le système contient {0} critères. Valeurs :" \
.format(self.nb))
self.disp()
return
def show(self):
ui.display("Le système contient {0} données. Valeurs :" \
.format(self.nb))
self.disp()
return
def disp(self):
for item in self.keys():
ui.display("{0} = {1}".format(item, self[item]))
return
def show(self):
'''Liste la valeur actuelle de toutes les règles.'''
ui.display("Evaluation des règles : ")
for r in self._rules.values():
ui.display("{0} : {1}".format(r.name, r.val))
return
view = SudoGridView(grid)
#view = SudoGridView(grid, env=self._env)
game = SudoGame(mem, think, view)
return
def go():
global game
game.play(params)
return
#Initialisation des tests et de la partie
TEST.level("main", 1)
TEST.display("main", 1, "\nTest du module sudogame")
TEST.display("main", 1, "----------------------------\n")
newGrid()
ui.display("Création et initialisation de la partie")
newGame()
#Niveaux de commentaires pour la partie
TEST.level("thinkai", 1)
#Paramètres de la partie
params = None
#jeu
TEST.display("main", 1, "Prêt à jouer.")
print("\n...>>> game.play(params) \nou >>> go()")
#ui.sudoPause()
#go()
## #TEST
## import sudotestall
return None
else:
return lastTech.techName()
##TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST
##TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST
if __name__ == "__main__":
env = sudoenv.SudoEnv("TEST THINKAI")
TEST = env.TEST
TEST.levelAll(0)
#lancement de l'AI
ui.display("\nSIMULATION : Lancement de l'AI")
mem = SudoMemory(env=env)
TEST.level("memory", 0)
tai = SudoThinkAI(mem, env=env)
TEST.test("thinkai", 3)
TEST.test("ai", 3)
#affichage des données initiales
ui.display("\nSIMULATION : Données initiales :")
tai._aiData.disp()
#simulation : premier appel par Thinking
ui.display("\nSIMULATION : Premier appel par Thinking")
TEST.pause("thinkai", 1)
da = tai.decideAction()
def _dispDataSet(self):
'''Affiche la valeur des données d'avancement de la résolution.'''
TEST = self.env.TEST
TEST.display("thinkai", 3, "ThinkAI - dans _dispDataSet()")
ui.display("self._begin = {0}".format(self._begin))
ui.display("self._techNiv = {0}".format(self._techNiv))
ui.display("self._techNivMax = {0}".format(self._techNivMax))
ui.display("self._inTech = {0}".format(self._inTech))
ui.display("self._opport = {0}".format(self._opport))
ui.display("self._tech = {0}".format(self._tech))
ui.display("self._lastTech = {0}".format(self._lastTech))
ui.display("self._lastAction = {0}".format(self._lastAction))
ui.display("self._lastTechAction = {0}".format(self._lastTechAction))
ui.display("self._lastAIaction = {0}".format(self._lastAIaction))
return
grid = None
mem = None
think = None
view = None
testlevel = 3
TEST.levelAll(testlevel)
print("Tous les niveaux de test sont à {0}".format(testlevel))
print("\nTest du module sudothinking")
print("----------------------------\n")
print("\nCréation de la grille")
gr = sudogrid.SudoGrid()
bl = sudogrid.SudoBloc()
list9 = [2, 5, 0, 6, 8, 0, 0, 3, 4]
import sudoui
ui.display("Choisir un fichier de test")
fich = sudoui.sudoNumTestFich()
if not fich:
ui.display("Abandon")
exit()
print("Fichier choisi : {0}\n".format(fich))
vals = sudoui.sudoFichReadLines(fich)
print("Variable SudoBloc : bl")
bl = sudogrid.SudoBloc()
print("Variables SudoGrid : gr et grid")
gr = sudogrid.SudoGrid()
gr.fillByRowLines(vals)
grid = gr
gridInit = grid.copy()
print("Grille test choisie : grid = ")
gr.show()
