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()