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)