def __init__(self) : self.action_verify = RuleTable(doc="""Handles verifying actions for being at least somewhat logical. Should not change world state.""") self.action_trybefore = RuleTable(doc="""Handles a last attempt to make the action work (one shouldn't work with this table directly).""") self.action_before = RuleTable(doc="""Checks an action to see if it is even possible (opening a door is logical, but it's not immediately possible to open a locked door)""") self.action_when = RuleTable(doc="""Carries out the action. Must not fail.""") self.action_report = RuleTable(doc="""Explains what happened with this action. Should not change world state.""") self.verify = make_rule_decorator(self.action_verify) self.trybefore = make_rule_decorator(self.action_trybefore) self.before = make_rule_decorator(self.action_before) self.when = make_rule_decorator(self.action_when) self.report = make_rule_decorator(self.action_report)
def __init__(self): self.action_verify = RuleTable( doc="""Handles verifying actions for being at least somewhat logical. Should not change world state.""") self.action_trybefore = RuleTable(doc="""Handles a last attempt to make the action work (one shouldn't work with this table directly).""") self.action_before = RuleTable(doc="""Checks an action to see if it is even possible (opening a door is logical, but it's not immediately possible to open a locked door)""") self.action_when = RuleTable( doc="""Carries out the action. Must not fail.""") self.action_report = RuleTable(doc="""Explains what happened with this action. Should not change world state.""") self.verify = make_rule_decorator(self.action_verify) self.trybefore = make_rule_decorator(self.action_trybefore) self.before = make_rule_decorator(self.action_before) self.when = make_rule_decorator(self.action_when) self.report = make_rule_decorator(self.action_report)
class ActionSystem(object) : def __init__(self) : self.action_verify = RuleTable(doc="""Handles verifying actions for being at least somewhat logical. Should not change world state.""") self.action_trybefore = RuleTable(doc="""Handles a last attempt to make the action work (one shouldn't work with this table directly).""") self.action_before = RuleTable(doc="""Checks an action to see if it is even possible (opening a door is logical, but it's not immediately possible to open a locked door)""") self.action_when = RuleTable(doc="""Carries out the action. Must not fail.""") self.action_report = RuleTable(doc="""Explains what happened with this action. Should not change world state.""") self.verify = make_rule_decorator(self.action_verify) self.trybefore = make_rule_decorator(self.action_trybefore) self.before = make_rule_decorator(self.action_before) self.when = make_rule_decorator(self.action_when) self.report = make_rule_decorator(self.action_report) def verify_action(self, action, ctxt) : """Returns either the best reason for doing the action, or, if there is a reason not to do it, the worst.""" reasons = self.action_verify.notify(action, {"ctxt" : ctxt}, {"world" : ctxt.world}) reasons = [r for r in reasons if r is not None] reasons.sort(key=lambda x : x.score) if len(reasons) == 0 : return LogicalOperation() else : if not reasons[0].is_acceptible() : return reasons[0] else : return reasons[-1] def run_action(self, action, ctxt, is_implied=False, write_action=False, silently=False) : """Runs an action by the following steps: * Verify - if the action is not reasonable, then the action fails * Trybefore - just tries to make the world in the right state for Before to succeed. * Before - checks if the action is possible. May throw DoInstead to redirect execution. * When - carries out the action. * Report - reports the action. Executes if the silently flag is False. is_implied, if true forces a description of the action to be printed. Also (should) prevent possibly dangerous actions from being carried out. write_action is a boolean or a string such as "(first %s)". If considered to be true, then describes action. silently, if true, prevents reporting the action.""" if (write_action or is_implied) : if write_action is True : write_action = "(%s)" ctxt.write(write_action % action.gerund_form(ctxt)) ctxt.write("[newline]") reasonable = self.verify_action(action, ctxt) if not reasonable.is_acceptible() : ctxt.write(reasonable.reason) raise AbortAction() self.action_trybefore.notify(action, {"ctxt" : ctxt}, {"world" : ctxt.world}) try : self.action_before.notify(action, {"ctxt" : ctxt}, {"world" : ctxt.world}) except DoInstead as ix : msg = False if ix.suppress_message or silently else "(%s instead)" self.run_action(ix.instead, ctxt, write_action=msg) return did_something = self.action_when.notify(action, {"ctxt" : ctxt}, {"world" : ctxt.world}) #if not did_something : # raise AbortAction("There was nothing to do.") # this doesn't seem to be the right thing to do. if not silently : self.action_report.notify(action, {"ctxt" : ctxt}, {"world" : ctxt.world}) def do_first(self, action, ctxt, silently=False) : """Runs an action with a "(first /doing something/)" message. If silently is True, then this message is not printed.""" self.run_action(action, ctxt=ctxt, is_implied=True, write_action="(first %s)", silently=silently) def copy(self) : """Returns a copy which behaves like the original, but for which modifications do not change the original.""" newat = ActionSystem() newat.action_verify = self.action_verify.copy() newat.action_trybefore = self.action_trybefore.copy() newat.action_before = self.action_before.copy() newat.action_when = self.action_when.copy() newat.action_report = self.action_report.copy() newat.verify = make_rule_decorator(newat.action_verify) newat.trybefore = make_rule_decorator(newat.action_trybefore) newat.before = make_rule_decorator(newat.action_before) newat.when = make_rule_decorator(newat.action_when) newat.report = make_rule_decorator(newat.action_report) return newat def make_documentation(self, escape, heading_level=1) : hls = str(heading_level) print "<h"+hls+">Event system</h"+hls+">" print "<p>This is the documentation for the event system.</p>" def _make_action_docs(heading_level, table, heading) : shls = str(heading_level+1) print "<h"+shls+">"+heading+"</h"+shls+">" table.make_documentation(escape, heading_level=heading_level+2) _make_action_docs(heading_level, self.action_verify, "action_verify") _make_action_docs(heading_level, self.action_trybefore, "action_trybefore") _make_action_docs(heading_level, self.action_before, "action_before") _make_action_docs(heading_level, self.action_when, "action_when") _make_action_docs(heading_level, self.action_report, "action_report")
class ActionSystem(object): def __init__(self): self.action_verify = RuleTable( doc="""Handles verifying actions for being at least somewhat logical. Should not change world state.""") self.action_trybefore = RuleTable(doc="""Handles a last attempt to make the action work (one shouldn't work with this table directly).""") self.action_before = RuleTable(doc="""Checks an action to see if it is even possible (opening a door is logical, but it's not immediately possible to open a locked door)""") self.action_when = RuleTable( doc="""Carries out the action. Must not fail.""") self.action_report = RuleTable(doc="""Explains what happened with this action. Should not change world state.""") self.verify = make_rule_decorator(self.action_verify) self.trybefore = make_rule_decorator(self.action_trybefore) self.before = make_rule_decorator(self.action_before) self.when = make_rule_decorator(self.action_when) self.report = make_rule_decorator(self.action_report) def verify_action(self, action, ctxt): """Returns either the best reason for doing the action, or, if there is a reason not to do it, the worst.""" reasons = self.action_verify.notify(action, {"ctxt": ctxt}, {"world": ctxt.world}) reasons = [r for r in reasons if r is not None] reasons.sort(key=lambda x: x.score) if len(reasons) == 0: return LogicalOperation() else: if not reasons[0].is_acceptible(): return reasons[0] else: return reasons[-1] def run_action(self, action, ctxt, is_implied=False, write_action=False, silently=False): """Runs an action by the following steps: * Verify - if the action is not reasonable, then the action fails * Trybefore - just tries to make the world in the right state for Before to succeed. * Before - checks if the action is possible. May throw DoInstead to redirect execution. * When - carries out the action. * Report - reports the action. Executes if the silently flag is False. is_implied, if true forces a description of the action to be printed. Also (should) prevent possibly dangerous actions from being carried out. write_action is a boolean or a string such as "(first %s)". If considered to be true, then describes action. silently, if true, prevents reporting the action.""" if (write_action or is_implied): if write_action is True: write_action = "(%s)" ctxt.write(write_action % action.gerund_form(ctxt)) ctxt.write("[newline]") reasonable = self.verify_action(action, ctxt) if not reasonable.is_acceptible(): ctxt.write(reasonable.reason) raise AbortAction() self.action_trybefore.notify(action, {"ctxt": ctxt}, {"world": ctxt.world}) try: self.action_before.notify(action, {"ctxt": ctxt}, {"world": ctxt.world}) except DoInstead as ix: msg = False if ix.suppress_message or silently else "(%s instead)" self.run_action(ix.instead, ctxt, write_action=msg) return did_something = self.action_when.notify(action, {"ctxt": ctxt}, {"world": ctxt.world}) #if not did_something : # raise AbortAction("There was nothing to do.") # this doesn't seem to be the right thing to do. if not silently: self.action_report.notify(action, {"ctxt": ctxt}, {"world": ctxt.world}) def do_first(self, action, ctxt, silently=False): """Runs an action with a "(first /doing something/)" message. If silently is True, then this message is not printed.""" self.run_action(action, ctxt=ctxt, is_implied=True, write_action="(first %s)", silently=silently) def copy(self): """Returns a copy which behaves like the original, but for which modifications do not change the original.""" newat = ActionSystem() newat.action_verify = self.action_verify.copy() newat.action_trybefore = self.action_trybefore.copy() newat.action_before = self.action_before.copy() newat.action_when = self.action_when.copy() newat.action_report = self.action_report.copy() newat.verify = make_rule_decorator(newat.action_verify) newat.trybefore = make_rule_decorator(newat.action_trybefore) newat.before = make_rule_decorator(newat.action_before) newat.when = make_rule_decorator(newat.action_when) newat.report = make_rule_decorator(newat.action_report) return newat def make_documentation(self, escape, heading_level=1): hls = str(heading_level) print "<h" + hls + ">Event system</h" + hls + ">" print "<p>This is the documentation for the event system.</p>" def _make_action_docs(heading_level, table, heading): shls = str(heading_level + 1) print "<h" + shls + ">" + heading + "</h" + shls + ">" table.make_documentation(escape, heading_level=heading_level + 2) _make_action_docs(heading_level, self.action_verify, "action_verify") _make_action_docs(heading_level, self.action_trybefore, "action_trybefore") _make_action_docs(heading_level, self.action_before, "action_before") _make_action_docs(heading_level, self.action_when, "action_when") _make_action_docs(heading_level, self.action_report, "action_report")