maybe you might want to apply this to a actor in game?

I have tools to record armature animations to Fcurves too.

When multiple actions have the same pre-condition, the primary action has to precede the dependent actions. However, the current behavior seems to be that the primary action is placed arbitrarily in the plan step wherein some actions are placed ahead even if the pre-condition is not met.

In the following example, the expectation is that the action Action1 should be the first action in the plan because every other action has the precondition {"FIRST": True}. However, that is not the result.

from action import Action
from planner import Planner


class Action1(Action):
    effects = {"FIRST": True}
    preconditions = {}


class Action2(Action):
    effects = {"SECOND": True}
    preconditions = {"FIRST": True}


class Action3(Action):
    effects = {"THIRD": True}
    preconditions = {"FIRST": True, "SECOND": True}


class Action4(Action):
    effects = {"FOURTH": True}
    preconditions = {"FIRST": True, "THIRD": True}


if __name__ == "__main__":
    world_state = {"FIRST": False, "SECOND": False, "THIRD": False, "FOURTH": False}
    goal_state = {"FOURTH": True}
    print("Initial State:", world_state)
    print("Goal State:   ", goal_state)

    actions = [Action1(), Action2(), Action3(), Action4()]
    planner = Planner(world_state, actions)

    plan = planner.find_plan(goal_state)
    
    plan_str = 'PLAN:\n'
    for ix, step in enumerate(plan):
        plan_str += "....."*(ix+1) + str(step.action) + '\n'
    print(plan_str)

Output plan steps:

PLAN:
.....Action2
..........Action3
...............Action1
....................Action4

Action2 is the first action; Its pre-condition {"FIRST": True} is being ignored.

I just tested a simple setup with the newest changes. It seems that sometimes preconditions of actions are ignored. See the example below. You can switch the effects variable in the Place(Action) class to see the difference.

For some reason the planner skips Carry and directly selects Place if there is another state affected in the effects.

I will check further but didn't find the source of the problem yet.

from goap.action import Action
from goap.planner import RegressivePlanner

# see https://github.com/agoose77/GOAP

TOOL_STATE = "tool"
BLOCK_IN_PLACE_STATE = "block_in_place"
BLOCK_IN_STORAGE_STATE = "block_in_storage"


class Carry(Action):
    effects = {TOOL_STATE: True, BLOCK_IN_STORAGE_STATE: False}
    preconditions = {TOOL_STATE: False, BLOCK_IN_STORAGE_STATE: True}


class Place(Action):
    # effects={BLOCK_IN_PLACE_STATE: True}
    effects = {TOOL_STATE: False, BLOCK_IN_PLACE_STATE: True}
    preconditions = {TOOL_STATE: True, BLOCK_IN_PLACE_STATE: False}


if __name__ == "__main__":
    world_state = {TOOL_STATE: False, BLOCK_IN_PLACE_STATE: False, BLOCK_IN_STORAGE_STATE: True}
    goal_state = {BLOCK_IN_PLACE_STATE: True}
    print("Initial State:", world_state)
    print("Goal State:   ", goal_state)

    actions = [Carry(), Place()]
    planner = RegressivePlanner(actions)

    plan = planner.find_plan(world_state, goal_state)
    for p in plan:
        print(p)

Is there a way to define not only a singular value per state variable but a list of values as precondition for an action? As far as I can see the ellipsis and reference() function pass the goal value to the precondition without further checking.
If it is not yet implemented, i would like to request this feature, as i think this makes the planner more versatile (and also helps with my problem setting ;) )

btw. I tried something like this for the preconditions of an action but it gets stuck in an infinite loop:

effects = {TOOL_STATE: None, BLOCK_IN_PLACE_STATE: ...}
preconditions = {
        TOOL_STATE: reference(BLOCK_IN_PLACE_STATE) if reference(BLOCK_IN_PLACE_STATE) in CARRY_ABLE else ERROR_VAL,
        BLOCK_IN_PLACE_STATE: None}

When testing the newest changes i was encountering various typing issues throughout the project: "TypeError: 'type' object is not subscriptable"
I fixed this in my install by changing all typing occurrences of list and dict to their typing aliases List and Dict.