def activate(self, act=True): '''Active l'interface, sinon toutes ses interactions sont inactives. Cela facilite la gestion de changements de modes dans le programme. ''' if not self._open: raise Sudoku_Error("GUI was closed - now unusable") if act in (True, False): self._active = act else: raise Sudoku_Error("Wrong GUI activation value. "\ "Must be True or False.") return
def _next_techloc(self): '''Prépare la technique locale suivante quand celle en cours a retourné "end". Enchaîne les techniques row/col/sqr. ''' TEST.display("techlplcplace", 3, "TechLastPlcPlace - dans _next_techloc()") assert self._initOk assert self._encours mem = self._mem #se rappeler le type de bloc rcs = mem.recall("techlplcplace_rcs", self) if rcs == "row": TEST.display("techlplcplace", 2, "Fin de la technique sur le rang. "\ "Passage à la technique sur la colonne.") icol = mem.recall("techlplcplace_icol", self) try: tech = TechLastPlcCol(mem, (icol,)) except: ui.DisplayError("Erreur", "Impossible de lancer une technique de"+ "résolution TechLastPlcCol.") raise Sudoku_Error("TechLastPlcPlace - erreur instanciation tech col") mem.memorize("techlplcplace_techloc", tech, self) mem.memorize("techlplcplace_rcs", "col", self) r = ("continue", None) elif rcs == "col": TEST.display("techlplcplace", 2, "Fin de la technique sur la colonne. "\ "Passage à la technique sur le carré.") #transformation de coordonnées irow = mem.recall("techlplcplace_irow", self) icol = mem.recall("techlplcplace_icol", self) #### NOTE ## Code horrible mais beaucoup de changements pour corriger cela ru = rules.SudoRules() isqr = ru.coordToSQ(irow, icol)[0] #### try: tech = TechLastPlcSqr(mem, (isqr,)) except: ui.DisplayError("Erreur", "Impossible de lancer une technique de"+ "résolution TechLastPlcSqr.") raise Sudoku_Error("TechLastPlcPlace - erreur instanciation tech sqr") mem.memorize("techlplcplace_techloc", tech, self) mem.memorize("techlplcplace_rcs", "sqr", self) r = ("continue", None) elif rcs == "sqr": TEST.display("techlplcplace", 2, "Fin de la technique sur le carré. "\ "La technique LastPlc sur une case est terminée.") r = self._finish_apply() else: #ne devrait jamais arriver raise Sudoku_Error("TechLastPlcPlace : erreur type de technique.") return r
def _applyAI(self, action, actionDetails): '''Application d'une action directe demandée par ThinkAI, en dehors du contexte d'une technique structurée. ''' TEST = self.env.TEST TEST.display("thinking", 3, "Thinking : fontion _applyAI()") assert self._initOk if action == "observe": pattern = actionDetails[0] nextAction = ("observe", pattern) elif action == "place": placement = actionDetails[0] nextAction = ("place", placement) elif action == "continue": nextAction = ("continue", None) ## #la précédente action était aussi faite par ThinkAI ## lastAction = mem.recall("thinking_lastaction", self) ## #cas particulier : ThinkAI a fait une observation juste avant ## if lastAction == "observe": ## found = mem.recallObs() ## nextAction = self._thinkAI.obsFound(found) ## else: ## nextAction = ("continue", None) else: #ne devrait jamais arriver raise Sudoku_Error("erreur retour de ThinkAI.suggestAction()") #ok _applyAI() se termine bien TEST.display("thinking", 3, "Thinking : AI retourne : {0}" \ .format(nextAction)) return nextAction
def _solve_suite3(self): '''Résolution pour un rang (Row) - Retour de placement Vérifier que la placement a été correct et terminer la technique avec succès.''' TEST.display("techlplcrow", 3, "TechLastPlcRow - dans _solve_suite3()") assert self._initOk mem = self._mem #à quel rang en est-on ? irow = mem.recall("techlplcrow_irow", self) #vérifier que le placement a été bien réalisé. Sinon c'est une erreur #de mémoire, d'algorithme ou de cohérence de la grille. try: plcOk = mem.recall("techlplcrow_placeok", self) assert plcOk is True except: raise Sudoku_Error ("Résultat de placement invalide "\ "dans TechLastPlcRow._solve_suite3()") #Mise à jour comptages. nbplcrow = mem.increment("techlplcrow_nbplcrow", 1, self) TEST.display("techlplcrow", 3, "_solve_suite3() - "\ "Rang n° {0} : retour de placement correct.".format(irow)\ + "\nNombre de placements : {0}".format(nbplcrow)) #Etat d'avancement - fin de la technique sur ce rang mem.memorize("techlplcrow_steprow", 4, self) r = self._solve_fin("succeed") return r
def __init__(self, mem, args): '''Initialise l'instance pour appliquer la technique au rang de carrés indiqué en utilisant la mémoire du joueur 'mem'. ''' TEST.display("techchrcrow", 3, "TechChRCrow - Dans __init__()") #arguments de l'instanciation - vérifier leur validité try: chiffre = args[0] assert isinstance(chiffre, int) and 1 <= chiffre <= 9 irow = args[1] assert isinstance(irow, int) and 1 <= irow <= 9 except: raise Sudoku_Error("TechChRCgrid instanciée avec des arguments "\ "invalides : {0}".format(args)) TEST.display("techchrcrow", 3, \ "Nouvelle instance de la technique TechChRCrow "\ "appliquée au rang {0} pour le chiffre {1}" .format(irow, chiffre)) self._mem = mem self._chiffre = chiffre self._irow = irow mem.memorize("techchrcrow_chiffre", chiffre, self) mem.memorize("techchrcrow_irow", irow, self) #déterminer le rang de carrés. on utilise le premier rang = 1,4,7 isqrow = 1 + 3*( (irow-1)//3 ) TEST.display("techchrcrow", 3, "Le rang {0} correspond ".format(irow)\ + "au rang de carrés {0}".format(isqrow)) mem.memorize("techchrcrow_isqrow", isqrow, self) self._clear_tech_mem() self._finished = False #uniquement pour éviter une erreur de code self._initOk = True return
def UImode(mode=None): '''Fixe le nouveau mode d'interface utilisateur. S'il n'y a pas d'argument, retourne simplement le mode actif. Si le mode est GUI, affiche optionnellement le contenu actuel de la grille indiquée. ''' global __gui global __uimode if mode is None: return __uimode #elif mode == GUI: elif GUI in mode: #créer l'interface graphique si ça n'est pas déjà fait if openGUI(): __gui.activate() ## if restoreGrid==True: ## __gui._grid.displayAllGrid(aGrid) #elif mode == STD: elif STD in mode: if GUIactive(): __gui.activate(False) else: raise Sudoku_Error("Valeur de mode UI incorrecte") __uimode = mode return
def __init__(self, mem, args=None): '''Initialise l'instance en utilisant la mémoire du joueur 'mem'. Le paramètre 'args' contient le chiffre pour lequel appliquer la technique. ''' TEST.display("techchrcgrid", 3, "TechChRCgrid - Dans __init__()") #chiffre pour lequel appliquer la technique, vérifier la validité. try: chiffre = args[0] assert isinstance(chiffre, int) and 1 <= chiffre <= 9 except: raise Sudoku_Error("TechChRCgrid instanciée avec des arguments "\ "invalides : {0}".format(args)) TEST.display("techchrcgrid", 2, \ "\nNouvelle instance de la technique TechChRCgrid "\ "pour le chiffre {0}".format(chiffre)) self._chiffre = chiffre self._mem = mem #Initialiser les données en mémoire de la résolution mem.memorize("techchrcgrid_chiffre", chiffre, self) self._clear_tech_mem() #init contrôle d'exécution (en_cours, finished etc.) self._init_tech() self._initOk = True TEST.display("techchrcgrid", 3, "TechChRCgrid - L'initialisation de "\ "l'instance est terminée.") return
def __init__(self, mem, args): '''Initialise l'instance pour appliquer la technique à la colonne de carrés indiquée en utilisant la mémoire du joueur 'mem'. ''' TEST.display("techchrccol", 3, "TechChRCcol - Dans __init__()") #arguments de l'instanciation - vérifier leur validité try: chiffre = args[0] assert isinstance(chiffre, int) and 1 <= chiffre <= 9 icol = args[1] assert isinstance(icol, int) and 1 <= icol <= 9 except: raise Sudoku_Error("TechChRCcol instanciée avec des arguments "\ "invalides : {0}".format(args)) TEST.display("techchrccol", 2, \ "Nouvelle instance de la technique TechChRCcol "\ "appliquée à la colonne {0} pour le chiffre {1}" .format(icol, chiffre)) self._mem = mem self._chiffre = chiffre self._icol = icol mem.memorize("techchrccol_chiffre", chiffre, self) mem.memorize("techchrccol_icol", icol, self) #déterminer la colonne de carrés. on utilise la première colonne = 1,2,3 isqcol = 1 + (icol - 1) // 3 TEST.display("techchrccol", 3, "La colonne {0} correspond ".format(icol)\ + "à la colonne de carrés {0}".format(isqcol)) mem.memorize("techchrccol_isqcol", isqcol, self) self._clear_tech_mem() self._finished = False #uniquement pour éviter une erreur de code self._initOk = True #n'est plus utilisé si disparition de init() return
def _finish_apply(self): '''Termine l'application de cette technique globale après que toutes les techniques locales ont été exécutées et retourne le résultat global. ''' TEST.display("techchrcgrid", 3, "TechChRCgrid - dans _finish_apply()") assert self._initOk assert self._encours #nombre de placements faits totplc = self._mem.recall("techchrcgrid_nbplctot", self) TEST.display("techchrcgrid", 1, "Technique TechChRCgrid : {0} " \ "placements fait(s).".format(totplc)) self._finished = True self._encours = False #fait la réponse qui correspond au résultat des placements if totplc == 0: endDetails = ("noplace", 0) elif totplc > 0: endDetails = ("succeed", totplc) else: r = ("end", ("fail", "Erreur d'exécution de la technique TechChRCgrid")) raise Sudoku_Error("TechChRCgrid._finish_apply() : valeur de "\ "totplc invalide.") #retourner "end" avec les détails return ("end", endDetails)
def _techPilePop(self): try: self._techpile.pop() except IndexError: raise Sudoku_Error("SudoAI : erreur de dépilement de la pile "\ "des techniques en cours.") self._level -= 1
def __init__(self, mem, args=None): '''Initialise l'instance en utilisant la mémoire du joueur 'mem'. Le paramètre 'args' contient les coordonnées de la case sur laquelle appliquer la technique. ''' TEST.display("techlplcplace", 3, "TechLastPlcPlace - Dans __init__()") #vérifier la validité de l'argument 'args' try: irow = args[0] assert isinstance(irow, int) and 1 <= irow <= 9 icol = args[1] assert isinstance(icol, int) and 1 <= icol <= 9 except: raise Sudoku_Error("TechLastPlcPlace instanciée avec des arguments "\ "invalides : {0}".format(args)) TEST.display("techlplcplace", 2, \ "Nouvelle instance de la technique TechLastPlcPlace "\ "appliquée à la case {0}.".format(args)) self._mem = mem self._irow = irow mem.memorize("techlplcplace_irow", irow, self) self._icol = icol mem.memorize("techlplcplace_icol", icol, self) #Initialisation des données en mémoire du joueur self._clear_tech_mem() #autres variables de contrôle d'exécution de la technique self._finished = False #uniquement pour éviter une erreur de code self._resume = False #indique appel de resume() au lieu de apply() self._initOk = True #n'est plus utilisé si disparition de init() self._encours = False return
def _start_apply(self): '''Début de la résolution. La première technique locale à appliquer va être sur le premier carré rang de carrés ''' TEST.display("techchrcgrid", 3, "TechChRCgrid - dans _start_apply()") assert self._initOk mem = self._mem chiffre = mem.recall("techchrcgrid_chiffre", self) #Instancier la technique de résolution locale pour le premier rang #de carrés try: techloc = TechChRCrow(mem, (chiffre, 1)) TEST.display("techchrgrid", 3, "TechChRCgrid - retour à "\ "_start_apply()") except: ui.DisplayError( "Erreur", "Impossible de lancer une technique de" + "résolution TechChRCrow.") raise Sudoku_Error("TechChRCgrid - erreur instanciation tech sqr") #mémorise les données pour la suite de la technique mem.memorize("techchrcgrid_rcs", "row", self) mem.memorize("techchrcgrid_isqrow", 1, self) mem.memorize("techchrcgrid_techclass", TechChRCrow, self) mem.memorize("techchrcgrid_techloc", techloc, self) mem.memorize("techchrcgrid_techlocname", "TechChRCrow", self) mem.memorize("techchrcgrid_encours", True, self) self._encours = True #appliquer la technique locale r = self._apply_techloc() TEST.display("techchrgrid", 3, "TechChRCgrid - retour à _start_apply()") return r
def _solve_suite5(self): '''Résolution pour un rang (Row) - Retour de placement. Vérifier que le placement a été correct et terminer la technique avec succès. ''' TEST.display("techchrcrow", 3, "TechChRCrow - dans _solve_suite5()") assert self._initOk mem = self._mem #se rappeler les infos en mémoire de l'étape précédente chiffre = mem.recall("techchrcrow_chiffre", self) placement = mem.recall("techchrcrow_placement", self) nbplc = mem.recall("techchrcrow_nbplcrow", self) #vérifier que le placement a été bien réalisé. Sinon c'est une erreur #de mémoire, d'algorithme ou de cohérence de la grille. plcValid = mem.recall("techchrcrow_placeok", self) if plcValid is not True: raise Sudoku_Error ("Erreur de placement dans TechChRCrow"\ "._solve_suite5(), le placement a échoué.") #incrémenter le compteur de placement puis passer à la fin mem.increment("techchrcrow_nbplcrow", 1, self) (row, col) = (placement[0], placement[1]) TEST.display("techchrcrow", 3, "_solve_suite5() - Le placement "\ "de {0} en {1} est validé.".format(chiffre, (row, col))) #fin de la technique avec succès r = self._solve_fin("succeed") return r
def apply(self): '''Méthode d'application de cette technique. Elle est appelée répétitivement pour faire progresser la technique étape par étape. ''' TEST.display("techlplcplace", 3, "TechLastPlcPlace - Dans apply()") assert self._initOk #si la technique est terminée, sortir tout de suite if self._finished is True: return ("end", ("finished", None)) mem = self._mem #selon qu'une résolution est déjà en cours ou pas if mem.recall("techlplcplace_encours", self) is False: #pas de résolution en cours : débuter la technique TEST.display("techlplcplace", 1, \ "Technique de résolution \"Dernier placement sur "+ "une case\"") try: r = self._start_apply() except: #la méthode ne s'exécute pas correctement #abandonner l'exécution de la technique mem.memorize("techlplcplace_encours", None, self) TEST.display("techlplcplace", 0, \ "ERREUR FATALE : échec de la méthode de résolution." "\nLa technique 'Dernier placement' est annulée.") r = ("fail", "Erreur dans le module 'techlplcp'\n"\ "Dans apply() exception retour de _start_apply()\n") raise Sudoku_Error("TechLastPlcPlace - Erreur dans apply()") else: #déjà une résolution en cours, la continuer TEST.display("techlplcplace", 2, "LastPlcPlace suite de la résolution") #methode = self._apply_techloc try: r = self._apply_techloc() except: #la méthode ne s'exécute pas correctement #abandonner l'exécution de la technique mem.memorize("techlplcplace_encours", None, self) TEST.display("techlplcplace", 0, \ "ERREUR FATALE : échec de la méthode de résolution." "\nLa technique 'Dernier placement' est annulée.") r = ("fail", "Erreur dans le module 'techlplcp'\n"\ "Dans apply() exception retour de _start_apply()\n") raise Sudoku_Error("TechLastPlcPlace - Erreur dans apply()") return r
def _solve_suite1(self): '''Résolution pour un rang (Row) - Retour 1ère observation. S'il y a un bon résultat d'observation, demande la 2ème observation : quel est le chiffre manquant sur ce rang. ''' TEST.display("techlplcrow", 3, "TechLastPlcRow - dans _solve_suite1()") assert self._initOk mem = self._mem #à quel rang en est-on ? irow = mem.recall("techlplcrow_irow", self) TEST.display("techlplcrow", 3, "_solve_suite1() - rang n° {0} : "\ "retour 1ère observation".format(irow)) #résultat de l'observation : recherche des cases vides du rang #gérer les cas de retour d'observation invalide try: found = mem.recall("techlplcrow_obsfound", self) assert found is not None (nb, listPlc) = found assert isinstance(nb, int) and 0 <= nb <= 9 #on ne va pas tout vérifier non plus, ne pas exagérer. except: #quelle que soit l'erreur la technique doit être interrompue. raise Sudoku_Error("Retour d'observation invalide. " + "Technique de résolution abandonnée.") #cas où il y a une seule case vide dans le rang if nb == 1: TEST.display("techlplcrow", 3, "_solve_suite1() - "\ "Rang {0} : il y a une case vide, ".format(irow)\ +"la technique passe à l'étape suivante.") #mémoriser l'emplacement trouvé. C'est un indice de colonne mem.memorize("techlplcrow_coordcol", listPlc[0], self) #Passer à la 2ème étape : quel est le chiffre manquant ? obsPattern = (gridview.OBS_ROW_MISSING, (irow, )) #mémoriser ce qui a été demandé, pour l'itération suivante mem.memorize("techlplcrow_obspattern", obsPattern, self) #memoriser l'avancement et l'opération suivante mem.memorize("techlplcrow_action_suivante", self._solve_suite2, self) mem.memorize("techlplcrow_nom_action", "suite 2", self) mem.memorize("techlplcrow_steprow", 2, self) #réinitialiser l'indicateur de résultat d'observation mem.memorize("techlplcrow_obsfound", None, self) #retourner en indiquant la demande d'observation r = ("observe", obsPattern) #cas où il n'y a aucune case vide elif nb == 0: #la technique est terminée sans rien à faire TEST.display("techlplcrow", 3, "_solve_suite1() - "\ "Rang {0} : aucune case vide, c'est terminé"\ .format(irow)) r = self._solve_fin("noplace") else: #nb>1 => plusieurs cases vides : #dans cette version on ne le gère pas (plus compliqué) TEST.display("techlplcrow", 3, "_solve_suite1() - "\ "Rang {0} : {1} cases vide. On ne traite pas ce cas"\ .format(irow, nb) + "dans la technique LastPlcRow.") r = self._solve_fin("quit") return r
def crit(self, critName): '''Retourne l'instance de critère indiqué par son nom, ou déclenche une exception s'il n'y a pas de critère de ce nom. ''' cr = self._crits.get(critName, False) if cr is False: #erreur, pas de critère de ce nom raise Sudoku_Error("Pas de critère nommée {0}".format(critName)) return cr
def rule(self, ruleName): '''Retourne l'instance de règle indiquée par son nom, ou déclenche une exception s'il n'y a pas de règle de ce nom. ''' r = self._rules.get(ruleName, False) if r is False: #erreur, pas de règle de ce nom raise Sudoku_Error("Pas de règle nommée {0}".format(ruleName)) return r
def _discardAll(self): '''Arrêt de toutes les techniques en cours et retour au niveau 0. La pile d'imbrication est alors vide. ''' TEST = self.env.TEST TEST.display("thinkai", 3, "ThinkAI : dans _discardAll()") TEST.display("thinkai", 3, "METHODE A ECRIRE") assert self._initOk raise Sudoku_Error("_discardAll() n'existe pas encore.")
def critEval(self, critName): '''Retourne la valeur du critère indiqué par son nom. Au besoin fait l'évaluation de ce critère. Retourne False s'il n'y a pas de critère du nom indiqué. Propage une éventuelle exception. ''' cr = self._crits.get(critName, False) if cr is False: #inconnu dans le dictionnaire raise Sudoku_Error("Pas de critère nommée {0}".format(critName)) return cr.eval()
def _newTechInst(self, techClass, techArgs=None): '''Crée une nouvelle instance de la technique indiquée et l'initialise. ''' TEST = self.env.TEST TEST.display("thinkai", 3, "ThinkAI - dans _newTechInst()") TEST.display("thinkai", 3, "ThinkAI - Création d'une instance de la "\ "classe {0}".format(techClass.techClassName())) assert self._initOk #### ATTENTION à faire une meilleure gestion d'erreur ici try: tech = techClass(self._mem, techArgs) except: raise Sudoku_Error("SudoThinkAI._newTechInst() : "\ "Erreur instanciation de tech de résolution.") if tech is None: raise Sudoku_Error("SudoThinkAI._newTechInst() : "\ "Erreur instanciation de tech de résolution.") return tech
def _abortAllTechs(self): '''Lancement d'une nouvelle technique et insertion dans la pile de techniques en cours. ''' TEST = self.env.TEST TEST.display("thinkai", 3, "ThinkAI : dans _abortAllTechs()") TEST.display("thinkai", 3, "METHODE A ECRIRE") assert self._initOk raise Sudoku_Error("_abortAllTechs() n'existe pas encore.")
def _col_suite1(self): '''Résolution pour une colonne - Retour 1ère observation. S'il y a un bon résultat d'observation, demande la 2ème observation : quel est le chiffre manquant sur cette colonne. ''' TEST.display("techlplccol", 3, "TechLastPlcCol - dans _col_suite1()") assert self._initOk mem = self._mem #à quelle colonne en est-on ? icol = mem.recall("techlplccol_icol", self) TEST.display("techlplccol", 3, \ "colonne n° {0} : retour 1ère observation".format(icol)) #résultat de l'observation : recherche des cases vides de la colonne #Attention : gérer les cas de retour d'observation invalide try: found = mem.recall("techlplccol_obsfound", self) assert found is not None (nb, listPlc) = found assert isinstance(nb, int) and 0 <= nb <= 9 #on ne va pas tout vérifier non plus, ne pas exagérer. except: #quelle que soit l'erreur La technique doit être interrompue raise Sudoku_Error("Retour d'observation invalide. " + "Technique de résolution abandonnée.") #cas où il y a une seule case vide dans la colonne => continuer if nb == 1: TEST.display("techlplccol", 3, "_col_suite1() - "\ "Colonne {0} : il y a une case vide, ".format(icol)\ +"la technique passe à l'étape suivante.") #mémoriser l'emplacement trouvé. C'est un indice de rang mem.memorize("techlplccol_coordrow", listPlc[0], self) #2ème étape : il manque un seul chiffre, lequel est-ce ? obsPattern = (gridview.OBS_COL_MISSING, (icol,) ) #mémoriser ce qui a été demandé, pour l'itération suivante mem.memorize("techlplccol_obspattern", obsPattern, self) #memoriser l'avancement et l'opération suivante mem.memorize("techlplccol_action_suivante", self._col_suite2, self) mem.memorize("techlplccol_stepcol", 2, self) #réinitialiser l'indicateur de résultat d'observation mem.memorize("techlplccol_obsfound", None, self) #retourner en indiquant la demande d'observation r = ("observe", obsPattern) elif nb == 0: #aucune case vide #la technique est terminée sans rien à faire r = self._solve_fin("noplace") TEST.display("techlplccol", 3, \ "Colonne {0} : aucune case vide, c'est terminé" \ .format(icol)) else: #nb>1 => plusieurs cases vides : #dans cette version on ne le gère pas (plus compliqué) r = self._solve_fin("quit") TEST.display("techlplccol", 3, \ "Colonne {0} : {1} cases vide. On ne traite pas ce cas" \ .format(icol, nb) + "dans la technique LastPlcCol.") return r
def ruleEval(self, ruleName): '''Retourne la valeur de la règle indiquée par son nom. Au besoin fait l'évaluation de la règle. Déclenche une exception s'il n'y a pas de règle de ce nom et propage une exception d'évaluation de la règle. ''' r = self._rules.get(ruleName, False) if r is False: #erreur, nom de règle inconnu raise Sudoku_Error("Pas de règle nommée {0}".format(ruleName)) return r.eval()
def sudoPause(continuer=False, texte=None): '''Interrompt l'exécution jusqu'à une confirmation de l'utilisateur. (utilise la console stdin) ''' if texte is None: texte = "Tapez ENTREE pour continuer..." try: s = input(texte) return (True) except EOFError: if continuer: return (None) else: raise Sudoku_Error("Exécution interrompue volontairement.") except KeyboardInterrupt: if continuer: return (False) else: raise Sudoku_Error("Exécution interrompue volontairement.")
def rule(self, ruleName): '''Retourne l'instance de règle indiquée par son nom, ou déclenche une exception s'il n'y a pas de règle de ce nom. ''' TEST = self.env.TEST TEST.display("ai", 3, "SudoAI - dans AIruleSet.rule()") r = self._rules.get(ruleName, False) if r is False: #erreur, pas de règle de ce nom raise Sudoku_Error("Pas de règle nommée {0}".format(ruleName)) return r
def crit(self, critName): '''Retourne l'instance de critère indiqué par son nom, ou déclenche une exception s'il n'y a pas de critère de ce nom. ''' TEST = self.env.TEST TEST.display("ai", 3, "SudoAI - dans SudoAIcritSet.crit()") cr = self._crits.get(critName, False) if cr is False: #erreur, pas de critère de ce nom raise Sudoku_Error("Pas de critère nommée {0}".format(critName)) return cr
def displayText(self, text=None): '''Affiche du texte si l'interface est active, sinon ne fait rien.''' if not self._open: raise Sudoku_Error("GUI was closed - now unusable") if self._active: if text is None: self._disp.insert("end", "\n") else: self._disp.insert("end", text) return
def _apply_techloc(self): '''Transmet l'exécution à la technique locale en cours d'application. La technique locale sera appelée avec sa méthode apply() ou resume() suivant l'appel qui a été utilisé pour la technique globale. ''' TEST.display("techchrcgridall", 3, "TechChRCgridAll - dans "\ "_apply_techloc()") assert self._initOk assert self._encours mem = self._mem #applique la technique locale en cours techloc = mem.recall("techchrcgridall_techloc", self) techlocName = mem.recall("techchrcgridall_techlocname", self) try: if self._resume is True: TEST.display("techchrcgridall", 3, "appel de resume() de la technique "\ "locale {0}".format(techlocName)) TEST.display("techchrcgridall", 3, "appel de {0}".format(techloc.resume)) r = techloc.resume() TEST.display("techchrgridall", 3, "TechChRCgridAll - retour à "\ "_apply_techloc()") else: TEST.display("techchrcgridall", 3, "appel de apply() de la technique "\ "locale {0}".format(techlocName)) TEST.display("techchrcgridall", 3, "appel de {0}".format(techloc.apply)) r = techloc.apply() TEST.display("techchrgridall", 3, "TechChRCgridAll - retour à "\ "_apply_techloc()") #en plus d'une exception de apply() ou resume(), gérer un retour #invalide if not r[0] in ("continue", "observe", "place", "end", "fail"): raise Sudoku_Error() except: #Erreur dans l'application de la technique locale failTxt = "TechChRCgridAll - FAIL dans _apply_techloc()\n"\ "Impossible d'appliquer la technique {0}. La technique "\ "de résolution TechChRCgridAll est abandonnée."\ .format(techlocName) TEST.raiseArgs("techchrcgrid", 1, Sudoku_Error, failTxt) self._encours = False self._finished = True return ("end", ("fail", "Erreur d'exécution de la technique "\ "TechChRCgridAll.")) #si la technique locale est terminée, gérer sa fin et l'exploitation #des données de fin et éventuellement le passage à la technique locale #suivante. if r[0] == "end": TEST.display("techchrcgridall", 3, "TechChRCgridAll : la technique "\ "{0} a retourné \"end\".".format(techlocName)) endDetails = r[1] r = self._techloc_end(endDetails) #ok return r
def critEval(self, critName): '''Retourne la valeur du critère indiqué par son nom. Au besoin fait l'évaluation de ce critère. Retourne False s'il n'y a pas de critère du nom indiqué. Propage une éventuelle exception. ''' TEST = self.env.TEST TEST.display("aicrit", 3, "SudoAIcritSet - Dans critEval() - "\ "Evaluation du critère \"{0}\"".format(critName)) cr = self._crits.get(critName, False) if cr is False: #inconnu dans le dictionnaire raise Sudoku_Error("Pas de critère nommée {0}".format(critName)) return cr.eval()
def makeGameRessources(self, grid): '''Crée un ensemble de ses ressources cognitives de résolution : mémoire, réflexion et interaction avec une grille. Retourne ces objets dans une liste. ''' TEST = self.env.TEST TEST.display("player", 3, "SudoPlayer - dans _initGame()") TEST.display("player", 2, "Préparation du joueur pour la partie...") assert self._initOk assert isinstance(grid, SudoGrid) #préparation de la mémoire du joueur pour la partie try: mem = SudoMemory(self._memProfile, env=self.env) except: ui.displayError("Erreur", "Impossible de créer la mémoire de jeu.") #self._mem = None raise Sudoku_Error("new SudoMemory fail in SudoPlayer.initGame()") #préparation de la pensée du joueur pour la partie try: think = SudoThinking(mem, self._thinkProfile, env=self.env) except: ui.displayError("Erreur", "Impossible de créer la pensée.") #self._think = None raise Sudoku_Error( "new SudoThinking fail in SudoPlayer.initGame()") #création de la vue sur la grille try: view = SudoGridView(grid, env=self.env) except: ui.displayError("Erreur", "Impossible de créer la vue sur la grille.") #self._view = None raise Sudoku_Error( "new SudoGridView fail in SudoPlayer.initGame()") #ok return (mem, think, view)