robotengine.state_machine

state_machine 是 robotengine 控制 owner 复杂状态的节点。

需要在 owner 中实现以下函数:

# 状态机每帧更新
def tick(self, state, delta):
    pass

# 状态机切换的条件
def get_next_state(self, state):
    pass

# 状态机切换时的回调
def transition_state(self, from, to):
    pass

实现良好的状态机需要注意防止产生状态切换的死循环

 1"""
 2
 3state_machine 是 robotengine 控制 owner 复杂状态的节点。
 4
 5需要在 owner 中实现以下函数:
 6
 7    # 状态机每帧更新
 8    def tick(self, state, delta):
 9        pass
10
11    # 状态机切换的条件
12    def get_next_state(self, state):
13        pass
14    
15    # 状态机切换时的回调
16    def transition_state(self, from, to):
17        pass
18    
19实现良好的状态机需要注意防止产生状态切换的死循环
20
21"""
22
23from robotengine.node import Node
24import time
25from robotengine.tools import error
26
27class StateMachine(Node):
28    """ 状态机节点 """
29    KEEP_CURRENT = -1
30    """ 维持当前状态的状态码 """
31
32    def __init__(self, initial_state, name="StateMachine"):
33        """ 
34        初始化状态机, 需要传递初始状态,通常是枚举类型 
35        
36            :param initial_state: 初始状态
37            :param name: 节点名称
38        """
39        super().__init__(name)
40        self.state_time = 0.0
41        """ 当前状态持续的时间 """
42        self.current_state = initial_state
43        """ 状态机的当前状态 """
44        self._first = True
45         
46    def _process(self, delta: float) -> None:
47        start_transition_time = time.time()
48        while True:
49            if self._first:
50                self._first = False
51                self.owner.transition_state(None, self.current_state)
52
53            next = self.owner.get_next_state(self.current_state)
54            if next == StateMachine.KEEP_CURRENT:
55                break
56            self.owner.transition_state(self.current_state, next)
57            self.current_state = next
58            self.state_time = 0.0
59
60            if time.time() - start_transition_time > 1.0:
61                error(f"{self.owner.name} state_machine {self.current_state} transition timeout")
62
63        self.owner.tick(self.current_state, delta)
64        self.state_time += delta
class StateMachine(robotengine.node.Node):
28class StateMachine(Node):
29    """ 状态机节点 """
30    KEEP_CURRENT = -1
31    """ 维持当前状态的状态码 """
32
33    def __init__(self, initial_state, name="StateMachine"):
34        """ 
35        初始化状态机, 需要传递初始状态,通常是枚举类型 
36        
37            :param initial_state: 初始状态
38            :param name: 节点名称
39        """
40        super().__init__(name)
41        self.state_time = 0.0
42        """ 当前状态持续的时间 """
43        self.current_state = initial_state
44        """ 状态机的当前状态 """
45        self._first = True
46         
47    def _process(self, delta: float) -> None:
48        start_transition_time = time.time()
49        while True:
50            if self._first:
51                self._first = False
52                self.owner.transition_state(None, self.current_state)
53
54            next = self.owner.get_next_state(self.current_state)
55            if next == StateMachine.KEEP_CURRENT:
56                break
57            self.owner.transition_state(self.current_state, next)
58            self.current_state = next
59            self.state_time = 0.0
60
61            if time.time() - start_transition_time > 1.0:
62                error(f"{self.owner.name} state_machine {self.current_state} transition timeout")
63
64        self.owner.tick(self.current_state, delta)
65        self.state_time += delta

状态机节点

StateMachine(initial_state, name='StateMachine')
33    def __init__(self, initial_state, name="StateMachine"):
34        """ 
35        初始化状态机, 需要传递初始状态,通常是枚举类型 
36        
37            :param initial_state: 初始状态
38            :param name: 节点名称
39        """
40        super().__init__(name)
41        self.state_time = 0.0
42        """ 当前状态持续的时间 """
43        self.current_state = initial_state
44        """ 状态机的当前状态 """
45        self._first = True

初始化状态机, 需要传递初始状态,通常是枚举类型

:param initial_state: 初始状态
:param name: 节点名称
KEEP_CURRENT = -1

维持当前状态的状态码

state_time

当前状态持续的时间

current_state

状态机的当前状态