How to update Goal weight and desired state

[inezradulov]

I am running the examples with a scenario of updating the goals at runtime, and it seems once the agent is created with goals they can't be updated.

here is an example

 _ = new DefaultLogger(true);
        var goal = new ComparativeGoal(
                  name: "Travel 50 miles",
                  desiredState: new() {
                            {
                                "distanceTraveled", new() {
                                    Operator = ComparisonOperator.GreaterThanOrEquals,
                                    Value = 50
                                }
                            }
                  });

        var walkAction = new Action(
              name: "Walk",
              cost: 50,
              postconditions: new() {
                            { "distanceTraveled", 50 }
              },
              executor: TravelExecutor
          );
        var driveAction = new Action(
                      name: "Drive",
                      cost: 5,
                      preconditions: new() {
                            { "inCar", true }
                      },
                      postconditions: new() {
                            { "distanceTraveled", 50 }
                      },
                      executor: TravelExecutor
                  );

        var getInCarAction = new Action(
              name: "Get in Car",
              cost: 1,
              preconditions: new() {
                            { "inCar", false }
              },
              postconditions: new() {
                            { "inCar", true }
              },
              executor: GetInCarExecutor
          );


        var agent = new Agent(
          name: "Driving Agent",
          state: new() {
                    { "distanceTraveled", 0 },
                    { "inCar", false }
          }
          );
        agent.Goals.Add(goal);
        agent.Actions.Add(walkAction);
        agent.Actions.Add(driveAction);
        agent.Actions.Add(getInCarAction);

        agent.Step(StepMode.OneAction);
        agent.Step(StepMode.OneAction);
        agent.Step(StepMode.OneAction);


        var newGoal = new ComparativeGoal(
                  name: "Travel 60 miless",
                  desiredState: new() {
                            {
                                "distanceTraveled", new() {
                                    Operator = ComparisonOperator.GreaterThanOrEquals,
                                    Value = 60
                                }
                            }
                  });

        agent.Goals.Clear();
        agent.Goals.Add(newGoal);
        agent.Step(StepMode.OneAction);
        agent.Step(StepMode.OneAction);
        agent.Step(StepMode.OneAction);

It throws

 :0 @ void System.Runtime.CompilerServices.CastHelpers.StelemRef(System.Array , IntPtr , System.Object ): System.IndexOutOfRangeException: Index was outside the bounds of the array.
  <C++ Error>    System.IndexOutOfRangeException
  <C++ Source>   :0 @ void System.Runtime.CompilerServices.CastHelpers.StelemRef(System.Array , IntPtr , System.Object )
  <Stack Trace>  :0 @ void System.Runtime.CompilerServices.CastHelpers.StelemRef(System.Array , IntPtr , System.Object )
                 :0 @ MountainGoap.ActionAStar..ctor(MountainGoap.ActionGraph , MountainGoap.ActionNode , MountainGoap.BaseGoal , Single , Int32 )

[caesuric]

My apologies, I somehow missed this post entirely.

I cannot replicate your issue. When I use the same code as you pasted above, I don't run into that particular error. Are you perhaps modifying the goal list WHILE the planner is running? That might cause the issue you mention. If you really want to change the goal list while the planner is running, maybe try initializing a new list of goals, like:

agent.Goals = new() { newGoal };

That MIGHT not interrupt the current iteration through the goals, though I'm not sure as I haven't tried this before.

[inezradulov]

Hi, thank you for your response.
I have another question about Goal weight and how the planner selects the best goal.
For example:

        var goalOne = new ComparativeGoal(
                  name: "GoalOne",
                  desiredState: new() {
                            {
                                "goalOneState", new() {
                                    Operator = ComparisonOperator.Equals,
                                    Value = 1
                                }
                            }
                  }, weight: 1);
        var goalTwo = new ComparativeGoal(
                    name: "GoalTwo",
                    desiredState: new() {
                          {
                                  "goalTwoState", new() {
                                    Operator = ComparisonOperator.Equals,
                                    Value = 1
                             }
                    }
                    }, weight: 1);

        var actionOne = new Action(
              name: "goalOneState",
              cost: 1,
                   preconditions: new()  {
                      { "preconditionsOne", true }
                 },
              postconditions: new() {
                { "goalOneState", 1 },
                { "doneGoalOne", true },
              },
              executor: (Agent agent, Action action) =>
                      {
                          // always return Failed for demonstration
                          return ExecutionStatus.Failed;
                      }
          );
        var actionTwo = new Action(
                      name: "ActionTwo",
                      cost: 1,
                    preconditions: new()  {
                      { "preconditionsTwo", true }
                    },
                      postconditions: new() {
                            { "goalTwoState", 1 },
                             { "doneGoalTwo", true }
                      },
                      executor: (Agent agent, Action action) =>
                      {
                  
                          return ExecutionStatus.Succeeded;
                      }
          );

        var agent = new Agent(
          name: "A1",
          state: new() {
                    { "goalOneState", 0 },
                    { "goalTwoState", 0 },
                    { "preconditionsOne", true },
                    { "preconditionsTwo", true },
                    { "doneGoalOne", false },
                    { "doneGoalTwo", false },
              }
          );
        agent.Goals.Add(goalOne);
        agent.Goals.Add(goalTwo);
        agent.Actions.Add(actionOne);
        agent.Actions.Add(actionTwo);

        agent.Step(StepMode.OneAction);
        agent.Step(StepMode.OneAction);
        agent.Step(StepMode.OneAction);
        agent.Step(StepMode.OneAction);

in the above case, I would expect GoalTwo to be selected as the best goal and completed since GoalOne cannot be completed in this case.

But the way it works: is if the weights are the same, then the first one is always the best goal.
If you set up a higher weight on the GoalTwo then it will complete. I think the selection of the best goal will lead to a lock in the highest weighted goal even if it is not possible to execute, and actions can be in NotPossible Status and not fall back to the Goal that can be executed.

[caesuric]

That seems entirely possible based on things I've also observed. I have run into goal selection issues with impossible goals before but have been able to work around them. I am on vacation this week without much computer access but I will look into this when I get back, as it's something I need to solve long term.

[inezradulov]

Something like this https://gist.github.com/inezradulov/469bdc379465082ebbc48606c62ec5e4 to track the Agent's current goal, and if it's an impossible goal, replan
and the planner https://gist.github.com/inezradulov/d8a04aeeed6196edcd05e6b9b0be7f84

[caesuric]

Okay, there are some potential issues here. Mainly, I don't know if checking ExecutionStatus returned from the executor function is really a reliable way of determining whether a goal is impossible. Since the executor can return different things based on agent state and action parameters, just returning ExecutionStatus.Failed and expecting the action not to be evaluated isn't expected behavior. For purposes of goal selection and success, the postconditions and state mutator are what is checked.

For instance, if you add the following precondition to actionOne in your example:

{ "impossibleState", true }

and set a reasonable stepMaximum or costMaximum on the agent, GoalTwo will always be selected.

If you add that precondition to both actionOne and actionTwo, then it will correctly fail to find a goal:

I would suggest that if an Action ALWAYS fails, that should be reflected in its preconditions or stateChecker, which should tell the GOAP engine whether or not the action is even possible.

There is a bit of a flaw in the engine in that if you don't set a costMaximum or stepMaximum, the optimizer will spin out forever trying to execute actions over and over to see if they eventually solve the goal. This can be solved for now with the costMaximum or stepMaximum mentioned above. It would be ideal to add a check for all available actions' postconditions to see if it is possible to achieve the goal. However, this only works for simple use cases involving only postconditions -- once you introduce dynamic functions as stateMutators, this falls apart and, I believe, becomes something we cannot really check for. I may be missing something.

Do the above troubleshooting steps work for you (namely setting a costMaximum or stepMaximum and relying on preconditions and postconditions to determine what is possible), or is there a use case I am missing?