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        super().__init__(name)
35        self.state_time = 0.0
36        """ 当前状态持续的时间 """
37        self.current_state = initial_state
38        """ 状态机的当前状态 """
39        self._first = True
40         
41    def _process(self, delta: float) -> None:
42        start_transition_time = time.time()
43        while True:
44            if self._first:
45                self._first = False
46                self.owner.transition_state(None, self.current_state)
47
48            next = self.owner.get_next_state(self.current_state)
49            if next == StateMachine.KEEP_CURRENT:
50                break
51            self.owner.transition_state(self.current_state, next)
52            self.current_state = next
53            self.state_time = 0.0
54
55            if time.time() - start_transition_time > 1.0:
56                error(f"{self.owner.name} state_machine {self.current_state} transition timeout")
57
58        self.owner.tick(self.current_state, delta)
59        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        super().__init__(name)
36        self.state_time = 0.0
37        """ 当前状态持续的时间 """
38        self.current_state = initial_state
39        """ 状态机的当前状态 """
40        self._first = True
41         
42    def _process(self, delta: float) -> None:
43        start_transition_time = time.time()
44        while True:
45            if self._first:
46                self._first = False
47                self.owner.transition_state(None, self.current_state)
48
49            next = self.owner.get_next_state(self.current_state)
50            if next == StateMachine.KEEP_CURRENT:
51                break
52            self.owner.transition_state(self.current_state, next)
53            self.current_state = next
54            self.state_time = 0.0
55
56            if time.time() - start_transition_time > 1.0:
57                error(f"{self.owner.name} state_machine {self.current_state} transition timeout")
58
59        self.owner.tick(self.current_state, delta)
60        self.state_time += delta

状态机节点

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

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

KEEP_CURRENT = -1

维持当前状态的状态码

state_time

当前状态持续的时间

current_state

状态机的当前状态