Python statemachine.StateMachine类代码示例

def main():
    #This makes it so if you hit CTRL+C curses doesn't eat the terminal alive!
    signal.signal(signal.SIGINT, signal_handler)
    
    #Setup curses
    stdscr = curses.initscr()
    curses.noecho()
    curses.cbreak()
    curses.curs_set(0)
    
    #Create the State Machine instance
    s = StateMachine()
    
    win = curses.newwin(20, 40, 2, 2)
    win.addstr(1, 7, "CODE:\n")
    win.addstr(18, 7, "Press q or CTRL-c to quit.")
    win.border()
    win.refresh()
    
    #This while loop keeps checking the input you type on the keyboard
    while True:
        #Get a single keypress and turn it into a string
        win.border()
        c = chr(win.getch())
        win.addstr(13, 7, "Correct PIN: "+" ".join(s.correct_code))
    
        #if you press q, terminate the program
        if c == 'q':
            break
    
        if c.isalnum():
            win.addstr(10, 7, "Prev PIN: "+" ".join(s.cur_code))
    
            old_state = s.state
            s.do_event(StateMachine.E_KEYPRESS, c)
            new_state = s.state
    
            #Write out some debug data
            win.addstr(15, 7, "OLD STATE: %s        "%s.STATE_NAMES[old_state])
            win.addstr(16, 7, "NEW STATE: %s        "%s.STATE_NAMES[new_state])
            win.addstr(18, 7, "Press q or CTRL-c to quit.")
    
            if s.state == StateMachine.IDLE:
                win.erase()
                win.addstr(1, 7, "CODE:  ")

            win.addstr(2, 7, '* '*len(s.cur_code))
    
            if s.state == StateMachine.CODEOK:
                win.addstr(1, 7, "SUCCESS")
    
            elif s.state == StateMachine.CODEBAD:
                win.addstr(1, 7, "NO!    ")
    
            win.addstr(11, 7, "Curr PIN: "+" ".join(s.cur_code))
    
            #Curses only draws changes to the screen when you ask nicely.
            win.refresh()
    
    cleanup_curses()

    def test_stateMachine_initialState(self):
        """Test State Machine Initial set up."""
        machine                                     = StateMachine(State1)

        self.assertTrue(machine.inState(State1))
        self.assertFalse(State1 in machine.state.movesTo)
        self.assertTrue(State2 in machine.state.movesTo)

class Miner(BaseGameEntity):

    def __init__(self, name):
        self.name = name
        self.location = None
        self.gold = 0
        self.fatigue = 0
        self.thirsty = 0
        self.fsm = StateMachine(self)
        self.fsm.set_current_state(states.GoHomeAndSleepTilRested())

        self.pocket_limit = 10
        self.thirsty_limit = 10
        self.fatigue_limit = 10

    def __repr__(self):
        return '<Miner {0}>'.format(self.name)

    def change_location(self, location):
        self.location = location

    def is_pocket_full(self):
        return self.gold >= self.pocket_limit

    def add_gold_carried(self, n):
        self.gold += n

    def increase_fatigue(self):
        self.fatigue += 1
        self.thirsty += 1

    def is_thirsty(self):
        return self.thirsty >= self.thirsty_limit

    def __init__(self, _id=None, level=None, room=None,
                 speed=50, chance_to_hit=0.5, weapon_damage=5, healing=0, max_health=100,
                 health=100, ammo=0, morale=100):
        self._id = _id if _id else str(uuid.uuid4())
        self.level = level
        self.room = room

        self.speed = speed
        self.chance_to_hit = chance_to_hit
        self.weapon_damage = weapon_damage  # Note: should depend on equipment
        self.fight_cooldown = 1.0
        self.healing = healing

        self.health = health
        self.ammo = ammo
        self.morale = morale

        self._path = deque()  # the current path the entity is on
        self._vision = set()  # the rooms currently visible to the entity

        self._timeout = 0

        self._fight_timeout = 0

        def log_state_change(a, b):
            self.log("%s -> %s" % (a, b))
        StateMachine.__init__(self, ["IDLE", "MOVING", "FIGHTING", "DEAD"],
                              on_state_change=log_state_change)

 def test_stateMachine_transitions_byAssignment(self):
     """Test State Transations from State 1 to State2."""
     machine                                     = StateMachine(State1)
     self.assertRaises(StateError,               machine.goto, State1)
     self.assertTrue(machine.inState(State1))
     machine.state = State2
     self.assertEqual(machine.message,           'Entered State 2')
     self.assertTrue(machine.inState(State2))

    def reset(self):
        """ UpdateStateMachin override.

        """
        StateMachine.reset(self)
        if len(self.ctx.orphaned) > 0:
            print "BUG?: Abandoning orphaned requests."
            self.ctx.orphaned.clear()
        self.ctx = ArchiveUpdateContext(self, self.ctx.ui_)

def test_weak_wildcard():
    machine = StateMachine({
        'initial'    : 'a',
        'transitions': [
            # A can only go to b on a 1
            { 'from': 'a', 'on': [1], 'to': 'b'},
            # Always stay on b without erroring
            { 'from': 'a', 'on': [ ] }
        ]
    })
    machine.step(1)
    assert(machine._current == 'b')

    def reset(self):
        """ StateMachine override. """
        StateMachine.reset(self)

        ctx = UpdateContext(self)
        ctx.repo = self.ctx.repo
        ctx.ui_ = self.ctx.ui_
        ctx.bundle_cache = self.ctx.bundle_cache
        if len(self.ctx.orphaned) > 0:
            print "BUG?: Abandoning orphaned requests."
            self.ctx.orphaned.clear()

        self.ctx = ctx

class AnimatedGameEntity(GameEntity):
    def __init__(self, startCoordinates, name=''):
        GameEntity.__init__(self, startCoordinates, name)
        self.frameNumber = 1
        self.imageFrame = 0
        self.frameTime = 0.
        self.animationSpeed = 0.5 + randint(-3, 3) / 10.0
        self.frameWidth = 0
        self.speed = 0
        self.width = self.height = 0
        self.brain = StateMachine()
        self.actionQueue = []
        
    def set_image(self, image, frameNumber=1):
        self.image = image
        self.frameNumber = frameNumber
        self.frameWidth = self.image.get_width() / self.frameNumber
        self.width, self.height = self.image.get_size()
        
    def render(self, surface, offset):
        surface.blit(self.image, 
                     (self.location.x - offset[0], self.location.y - offset[1]), 
                     (self.frameWidth * self.imageFrame, 0, self.frameWidth, self.height))
    
    def adjustPosition(self, dimension):
        self.location.x = min(self.location.x, dimension[0] - 20)
        self.location.x = max(self.location.x, 10)
        self.location.y = min(self.location.y, dimension[1] - 20)
        self.location.y = max(self.location.y, 10)
    
    def handleAction(self, action):
        raise NotImplementedError, 'Entity %s cannot handle Action %s' % (self.name, action)
    
    def process(self, time_passed):
        self.frameTime += time_passed
        if self.frameTime > self.animationSpeed:
            self.frameTime = 0.
            self.imageFrame = (self.imageFrame + 1) % self.frameNumber

        if self.speed > 0. and self.location != self.destination:
            vec_to_destination = self.destination - self.location
            distance_to_destination = vec_to_destination.get_magnitude()
            heading = vec_to_destination.get_normalized()
            travel_distance = min(distance_to_destination, time_passed * self.speed)
            self.location += heading * travel_distance
        
        if self.actionQueue:
            action = self.actionQueue.pop()
            self.handleAction(action)
        else:
            self.brain.think()

    def __init__(self):
        # These attributes are set by the parse method
        self.doc = None
        self.para = None
        self.current_string = None
        self.flow = None

        self.stateMachine = StateMachine()
        self.stateMachine.add_state("PARA", self._para)
        self.stateMachine.add_state("ESCAPE", self._escape)
        self.stateMachine.add_state("END", None, end_state=1)
        self.stateMachine.add_state("ANNOTATION-START", self._annotation_start)
        self.stateMachine.add_state("CITATION-START", self._citation_start)
        self.stateMachine.add_state("BOLD-START", self._bold_start)
        self.stateMachine.add_state("ITALIC-START", self._italic_start)
        self.stateMachine.add_state("CODE-START", self._code_start)
        self.stateMachine.add_state("QUOTES-START", self._quotes_start)
        self.stateMachine.add_state("INLINE-INSERT", self._inline_insert)
        self.stateMachine.add_state("CHARACTER-ENTITY", self._character_entity)
        self.stateMachine.set_start("PARA")
        self.patterns = {
            'escape': re.compile(r'\\', re.U),
            'escaped-chars': re.compile(r'[\\\(\{\}\[\]_\*,\.\*`"&]', re.U),
            'annotation': re.compile(
                r'(?<!\\)\{(?P<text>.*?)(?<!\\)\}(\(\s*(?P<type>\S*?\s*[^\\"\']?)(["\'](?P<specifically>.*?)["\'])??\s*(\((?P<namespace>\w+)\))?\s*(~(?P<language>[\w-]+))?\))?', re.U),
            'bold': re.compile(r'\*(?P<text>((?<=\\)\*|[^\*])*)(?<!\\)\*', re.U),
            'italic': re.compile(r'_(?P<text>((?<=\\)_|[^_])*)(?<!\\)_', re.U),
            'code': re.compile(r'`(?P<text>(``|[^`])*)`', re.U),
            'quotes': re.compile(r'"(?P<text>((?<=\\)"|[^"])*)(?<!\\)"', re.U),
            'inline-insert': re.compile(r'>\((?P<attributes>.*?)\)', re.U),
            'character-entity': re.compile(r'&(\#[0-9]+|#[xX][0-9a-fA-F]+|[\w]+);'),
            'citation': re.compile(r'(\[\s*\*(?P<id>\S+)(\s+(?P<id_extra>.+?))?\])|(\[\s*\#(?P<name_name>\S+)(\s+(?P<extra>.+?))?\])|(\[\s*(?P<citation>.*?)\])', re.U)
        }

    def __init__(self):
        self.screen = pygame.display.get_surface()
        self.gamestate = StateMachine()
        self.data = None
        self.video = Video()
        self.audio = Audio(self)

        self.running = False
        self.all_maps_loaded = False
        self.force_bg_music = False

        self.clock = pygame.time.Clock()
        self.playtime = 0.0
        self.dt = 0.0
        self.key_timer = 0.0
        self.state_timer = 0.0

        self.debugfont = pygame.font.SysFont(DEBUGFONT, DEBUGFONTSIZE)
        self.key_input = None
        self.mouse_input = None

        self.show_debug = False
        self.debug_mode = True
        self.fps = FPS

        threading.Thread(target=self.load_all_maps).start()

    def __init__(self):
        # These attributes are set by the parse method
        self.doc = None
        self.para = None
        self.current_string = None
        self.flow = None

        self.stateMachine = StateMachine()
        self.stateMachine.add_state("PARA", self._para)
        self.stateMachine.add_state("ESCAPE", self._escape)
        self.stateMachine.add_state("END", None, end_state=1)
        self.stateMachine.add_state("ANNOTATION-START", self._annotation_start)
        self.stateMachine.add_state("CITATION-START", self._citation_start)
        self.stateMachine.add_state("BOLD-START", self._bold_start)
        self.stateMachine.add_state("ITALIC-START", self._italic_start)
        self.stateMachine.add_state("MONO-START", self._mono_start)
        self.stateMachine.add_state("QUOTES-START", self._quotes_start)
        self.stateMachine.add_state("INLINE-INSERT", self._inline_insert)
        self.stateMachine.set_start("PARA")
        self.patterns = {
            "escape": re.compile(r"\\"),
            "escaped-chars": re.compile(r"[\\\(\{\}\[\]_\*,`]"),
            "annotation": re.compile(
                r'(?<!\\)\{(?P<text>.*?)(?<!\\)\}(\(\s*(?P<type>\S*?\s*[^\\"\']?)(["\'](?P<specifically>.*?)["\'])??\s*(\((?P<namespace>\w+)\))?\))?'
            ),
            "bold": re.compile(r"\*(?P<text>\S.+?\S)\*"),
            "italic": re.compile(r"_(?P<text>\S.*?\S)_"),
            "mono": re.compile(r"`(?P<text>\S.*?\S)`"),
            "quotes": re.compile(r'"(?P<text>\S.*?\S)"'),
            "inline-insert": re.compile(r">>\((?P<attributes>.*?)\)"),
            "citation": re.compile(
                r"(\[\s*\*(?P<id>\S+)(\s+(?P<id_extra>.+?))?\])|(\[\s*\#(?P<name_name>\S+)(\s+(?P<extra>.+?))?\])|(\[\s*(?P<citation>.*?)\])"
            ),
        }

    def __init__(self):

        self.stateMachine = StateMachine()
        self.stateMachine.add_state("NEW", self._new_file)
        self.stateMachine.add_state("SAM", self._sam)
        self.stateMachine.add_state("BLOCK", self._block)
        self.stateMachine.add_state("CODEBLOCK-START", self._codeblock_start)
        self.stateMachine.add_state("CODEBLOCK", self._codeblock)
        self.stateMachine.add_state("PARAGRAPH-START", self._paragraph_start)
        self.stateMachine.add_state("PARAGRAPH", self._paragraph)
        self.stateMachine.add_state("RECORD-START", self._record_start)
        self.stateMachine.add_state("RECORD", self._record)
        self.stateMachine.add_state("LIST-ITEM", self._list_item)
        self.stateMachine.add_state("NUM-LIST-ITEM", self._num_list_item)
        self.stateMachine.add_state("BLOCK-INSERT", self._block_insert)
        self.stateMachine.add_state("END", None, end_state=1)
        self.stateMachine.set_start("NEW")
        self.current_paragraph = None
        self.doc = DocStructure()
        self.source = None
        self.patterns = {
            'comment': re.compile(r'\s*#.*'),
            'block-start': re.compile(r'(\s*)([a-zA-Z0-9-_]+):(?:\((.*?)\))?(.*)'),
            'codeblock-start': re.compile(r'(\s*)```(.*)'),
            'codeblock-end': re.compile(r'(\s*)```\s*$'),
            'paragraph-start': re.compile(r'\w*'),
            'blank-line': re.compile(r'^\s*$'),
            'record-start': re.compile(r'\s*[a-zA-Z0-9-_]+::(.*)'),
            'list-item': re.compile(r'(\s*)(\*\s+)(.*)'),
            'num-list-item': re.compile(r'(\s*)([0-9]+\.\s+)(.*)'),
            'block-insert': re.compile(r'(\s*)>>\(.*?\)\w*')
        }

	def __init__(self,argv):
		#self.argv=argv
		self.params={'-h':'localhost','-d':'','-s':'','-u':'SYSDBA','-p':'masterkey'}
		self.ch='UTF8'
		self.ch=self.detect_codecs()
		self.mydb=None
		self.cmd=None
		self.sm = StateMachine()
		self.create_state(self.sm)
		self.parse_cmd(argv)

 def __init__(self, startCoordinates, name=''):
     GameEntity.__init__(self, startCoordinates, name)
     self.frameNumber = 1
     self.imageFrame = 0
     self.frameTime = 0.
     self.animationSpeed = 0.5 + randint(-3, 3) / 10.0
     self.frameWidth = 0
     self.speed = 0
     self.width = self.height = 0
     self.brain = StateMachine()
     self.actionQueue = []