Giving precedence to a transition when two transitions are feasible

[ACE07-Sev]

Greetings there,

Hope all are well. I was wondering if I could give priority to a transition when you can technically do two transitions at the same time (both being valid). I made a FSM for a soldier that would shoot, and when a target is in shooting range, and the magazine is empty, it needs to prioritize transitioning to reload than to shooting again.

I apologize if the question is silly. I am quite new to this wonderful package.

from statemachine import StateMachine, State


class Soldier(StateMachine):
    idle = State('Idle', initial=True)
    shooting = State('Shooting')
    melee = State('Melee')
    reloading = State('Reloading')

    cycle = (
        idle.to(shooting, cond="in_shooting_range") | idle.to(melee, cond="in_melee_range") |

        shooting.to(idle, cond="enemy_dead") | shooting.to(reloading, cond="mag_empty") |
        shooting.to(shooting, cond="in_shooting_range") | shooting.to(melee, cond="in_melee_range") |

        melee.to(idle, cond="enemy_dead") | melee.to(shooting, cond="in_shooting_range") |
        melee.to(melee, cond="in_melee_range") |

        reloading.to(idle) | reloading.to(melee, cond="in_melee_range")
    )

    def __init__(self) -> None:

        self.mag_size = 5
        self.current_mag = self.mag_size

        super().__init__()

    async def after_transition(
            self,
            event: str,
            source: State,
            target: State
        ) -> None:

        if source == self.reloading:
            print("Reloading...")
            self.current_mag = self.mag_size

    async def in_shooting_range(
            self,
            enemy_distance: int
        ) -> bool:

        print(f"Current mag: {self.current_mag}")

        if self.current_mag <= 0:
            return False

        in_range = enemy_distance < 500 and enemy_distance > 100

        if in_range:
            print("Pow")
            self.current_mag -= 1

        return in_range

    async def in_melee_range(
            self,
            enemy_distance: int
        ) -> bool:

        in_range = enemy_distance < 100

        if in_range:
            print("Slash")

        return in_range

    async def enemy_dead(
            self,
            enemy_health: int
        ) -> bool:

        is_dead = enemy_health <= 0

        if is_dead:
            print("Enemy is dead")

        return is_dead

    async def mag_empty(self) -> bool:

        is_empty = self.current_mag == 0

        if is_empty:
            print("Im out of ammo")

        return is_empty

[ACE07-Sev]

For now, I used unless in a cascading manner to emulate precedence given the random order which the transition rules are evaluated.

[fgmacedo]

Hi @ACE07-Sev , how are you?

Transitions are evaluated in the order they are declared. The first transition that matches the triggered event and whose conditions all return True will be taken. This means only one transition is executed per event, even if multiple transitions could match.

See conditions.

This feature allows for multiple transitions on the same Event, with each Transition checked in the order they are declared. A condition acts like a predicate (a function that evaluates to true/false) and is checked when a StateMachine handles an Event with a transition from the current state bound to this event. The first transition that meets the conditions (if any) is executed. If none of the transitions meet the conditions, the state machine either raises an exception or does nothing (see the allow_event_without_transition parameter of StateMachine).

[ACE07-Sev]

cycle = (
        idle.to(melee, cond="can_melee") |
        idle.to(reloading, cond="mag_empty", unless="can_melee") |
        idle.to(shooting, cond="can_shoot", unless=["can_melee", "mag_empty"]) |
        idle.to(walking, cond="can_patrol", unless=["can_melee", "mag_empty", "can_shoot"]) |
        idle.to(idle, unless=["can_melee", "mag_empty", "can_shoot", "can_patrol"]) |

        walking.to(melee, cond="can_melee") |
        walking.to(reloading, cond="mag_empty", unless=["can_melee"]) |
        walking.to(shooting, cond="can_shoot", unless=["can_melee", "mag_empty"]) |
        walking.to(idle, cond="can_take_a_break", unless=["can_melee", "mag_empty", "can_shoot"]) |
        walking.to(walking, cond="can_patrol", unless=["can_melee", "mag_empty", "can_shoot", "can_take_a_break"]) |

        shooting.to(melee, cond="can_melee") |
        shooting.to(reloading, cond="mag_empty", unless="can_melee") |
        shooting.to(shooting, cond="can_shoot", unless=["can_melee", "mag_empty"]) |
        shooting.to(idle, unless=["can_melee", "mag_empty", "can_shoot"]) |

        melee.to(melee, cond="can_melee") |
        melee.to(reloading, cond=["mag_empty", "can_shoot"], unless="can_melee") |
        melee.to(shooting, cond="can_shoot", unless=["can_melee", "mag_empty"]) |
        melee.to(idle, unless=["can_melee", "can_shoot"]) |

        reloading.to(melee, cond="can_melee") |
        reloading.to(reloading, cond="mag_empty", unless="can_melee") |
        reloading.to(shooting, cond="can_shoot", unless=["mag_empty"]) |
        reloading.to(idle, unless=["can_melee", "can_shoot"])
    )

I did like so. Is this the wrong way?

[ACE07-Sev]

I think I see my mistake. The paranthesis makes it a set.