{"id":37038988,"url":"https://github.com/caesuric/mountain-goap","last_synced_at":"2026-01-14T04:37:49.730Z","repository":{"id":60639690,"uuid":"544418486","full_name":"caesuric/mountain-goap","owner":"caesuric","description":"A GOAP (Goal Oriented Action Planning) AI library, written in C#.","archived":false,"fork":false,"pushed_at":"2025-03-18T11:16:55.000Z","size":327,"stargazers_count":111,"open_issues_count":8,"forks_count":10,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-09-01T10:23:17.506Z","etag":null,"topics":["ai","csharp","game","gamedev","games","goap"],"latest_commit_sha":null,"homepage":"","language":"C#","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/caesuric.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE.txt","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null}},"created_at":"2022-10-02T12:33:24.000Z","updated_at":"2025-08-14T09:39:17.000Z","dependencies_parsed_at":"2023-12-18T12:42:09.504Z","dependency_job_id":null,"html_url":"https://github.com/caesuric/mountain-goap","commit_stats":{"total_commits":93,"total_committers":1,"mean_commits":93.0,"dds":0.0,"last_synced_commit":"fcde1fce2260caa1773f2211d28805478595457a"},"previous_names":[],"tags_count":35,"template":false,"template_full_name":null,"purl":"pkg:github/caesuric/mountain-goap","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/caesuric%2Fmountain-goap","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/caesuric%2Fmountain-goap/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/caesuric%2Fmountain-goap/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/caesuric%2Fmountain-goap/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/caesuric","download_url":"https://codeload.github.com/caesuric/mountain-goap/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/caesuric%2Fmountain-goap/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28409616,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-14T01:52:23.358Z","status":"online","status_checked_at":"2026-01-14T02:00:06.678Z","response_time":107,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai","csharp","game","gamedev","games","goap"],"created_at":"2026-01-14T04:37:49.185Z","updated_at":"2026-01-14T04:37:49.722Z","avatar_url":"https://github.com/caesuric.png","language":"C#","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003cimg src=\"https://github.com/caesuric/mountain-goap/raw/main/logo.png\" alt=\"Mountain GOAP logo\" title=\"Mountain GOAP\" align=\"right\" height=\"180\" /\u003e\n\n# Mountain GOAP\n\nGeneric C# GOAP (Goal Oriented Action Planning) library for creating AI agents to be used in games. GOAP is a type of an AI system for games popularized by [the F.E.A.R. AI paper](https://alumni.media.mit.edu/~jorkin/gdc2006_orkin_jeff_fear.pdf). GOAP agents use A\\* pathfinding to plan paths through a series of sequential actions, creating action sequences that allow the agent to achieve its goals.\n\nMountain GOAP favors composition over inheritance, allowing you to create agents from a series of callbacks. In addition, Mountain GOAP's agents support multiple weighted goals and will attempt to find the greatest utility among a series of goals.\n\n1. [Quickstart](#quickstart)\n    1. [Using distributable](#using-distributable)\n    2. [Using distributable in Unity](#using-distributable-in-unity)\n    3. [Using NuGet package](#using-nuget-package)\n    4. [Using as a Unity package](#using-as-a-unity-package)\n    5. [Using the code directly](#using-the-code-directly)\n    6. [Using the library after installation](#using-the-library-after-installation)\n2. [Concepts \u0026 API](#concepts--api)\n    1. [Agents](#agents)\n        1. [Agent state](#agent-state)\n    2. [Goals](#goals)\n        1. [Extreme Goals](#extreme-goals)\n        2. [Comparative Goals](#comparative-goals)\n    3. [Actions](#actions)\n        1. [Comparative Preconditions](#comparative-preconditions)\n        2. [Arithmetic Postconditions](#arithmetic-postconditions)\n        3. [Parameter Postconditions](#parameter-postconditions)\n    4. [Sensors](#sensors)\n    5. [Permutation selectors](#permutation-selectors)\n    6. [Cost callbacks](#cost-callbacks)\n    7. [State mutators](#state-mutators)\n    8. [State checkers](#state-checkers)\n    9. [Full API Docs](#full-api-docs)\n3. [Events](#events)\n    1. [Agent events](#agent-events)\n    2. [Action events](#action-events)\n    3. [Sensor events](#sensor-events)\n4. [Logger](#logger)\n5. [Examples](#examples)\n6. [Project structure](#project-structure)\n7. [Roadmap](#roadmap)\n8. [Other open source GOAP projects](#other-open-source-goap-projects)\n9. [License Acknowledgements](#license-acknowledgements)\n\n## Quickstart\n\n### Using distributable\n\nDownload the [release](https://github.com/caesuric/mountain-goap/releases), unzip, and include the DLL in your project. In Visual Studio, you can do this by right-clicking on \"Dependencies\" in the Solution Explorer, then clicking \"Add COM Reference,\" clicking \"Browse,\" and browsing to the DLL.\n\n### Using distributable in Unity\n\nDownload the [release](https://github.com/caesuric/mountain-goap/releases), unzip to a folder, and drag the folder into your Unity project.\n\n### Using NuGet package\n\nIf you are not using Unity, you can download and use MountainGoap as a NuGet package.\n\nRight click your package and click \"Manage NuGet Packages,\" then search for \"MountainGoap\" and install the package.\n\n### Using as a Unity package\n\nIn the works.\n\n### Using the code directly\n\nClone the repo and copy the code in the MountainGoap folder to your repo.\n\n### Using the library after installation\n\nNo matter which method of installation you use, you can access MountainGoap by using the `MountainGoap` namespace as a prefix to the library classes, or by including the following line in your code:\n\n```csharp\nusing MountainGoap;\n```\n\n## Concepts \u0026 API\n\n### Agents\n\n**Agents** are indivdual entities that act within your game or simulated world. The simplest example of instantiating an agent is this:\n`Agent agent = new Agent();`\n\nIn practice, you will want to pass the agent constructor various things it needs to make a functional agent. Read on to understand what kinds of objects you should pass your agents.\n\nWhen you want your agent to act, just call the following:\n`agent.Step();`\n\nWhat kind of timeframe is represented by a \"step\" will vary based on your engine. In a turn based game, a step might be one turn. In a realtime engine like Unity, you might call `agent.Step()` on every `Update()` cycle. In a turn-based game you will probably want to call `agent.Step()` on every turn. In the case of turn-based games, you can force at least one action to be taken per turn by calling `agent.Step(mode: StepMode.OneAction)`. If you want the entire action sequence to be completed in one turn, you can call `agent.Step(mode: StepMode.AllActions)`.\n\nFor additional granularity, you can also call the functions `agent.Plan()`, `agent.ClearPlan()`, `agent.PlanAsync()`, and `agent.ExecutePlan()`. See the full API docs for additional details.\n\n#### Agent state\n\nThe agent stores a dictionary of objects called its **state**. This state can include anything, but simple values work best with [goals](#goals) and [actions](#actions). If you need to reference complex game state, however, this is not a problem -- [sensors](#sensors), covered below, can be used to translate complex values like map states into simpler ones, like booleans. More on that below.\n\nState can be passed into the agent constructor, like so:\n\n```csharp\nAgent agent = new Agent(\n    state: new Dictionary\u003cstring, object\u003e {\n        { \"nearOtherAgent\", false },\n        { \"otherAgents\", new List\u003cAgent\u003e() }\n    }\n);\n```\n\n### Goals\n\n**Goals** dictate the state values that the agent is trying to achieve. Goals have relatively simple constructors, taking just a dictionary of keys and values the agent wants to see in its state and a weight that indicates how important the goal is. The higher the weight, the more important the goal.\n\nGoals can be passed into the agent constructor, like so:\n\n```csharp\nGoal goal = new Goal(\n    desiredState: new Dictionary\u003cstring, object\u003e {\n        { \"nearOtherAgent\", true }\n    },\n    weight: 2f\n);\nAgent agent = new Agent(\n    goals: new List\u003cGoal\u003e {\n        goal\n    }\n);\n```\n\n#### Extreme Goals\n\n**Extreme goals** attempt to maximize or minimize a numeric state value. They take similar parameters to normal goals, but the values in the dictionary must be booleans. If the boolean is true, the goal will attempt to maximize the value. If the boolean is false, the goal will attempt to minimize the value. The state value must be a numeric type for this to work correctly.\n\nExample that will try to maximize the agent's health:\n\n```csharp\nExtremeGoal goal = new ExtremeGoal(\n    desiredState: new Dictionary\u003cstring, object\u003e {\n        { \"health\", true }\n    },\n    weight: 2f\n);\n```\n\n#### Comparative Goals\n\n**Comparative goals** attempt to make a numeric state value compare in a certain way to a base value. They take similar parameters to normal goals, but the values in the dictionary must be ComparisonValuePair objects. The ComparisonValuePair object specifies a value to use for comparison and a comparison operator to use. The state value must be a numeric type and the same type as the comparison value for this to work correctly.\n\nExample that will try to make the agent's health greater than 50:\n\n```csharp\nComparativeGoal goal = new ComparativeGoal(\n    desiredState: new Dictionary\u003cstring, object\u003e {\n        { \"health\", new ComparisonValuePair {\n            Value = 50,\n            Operator = ComparisonOperator.GreaterThan\n         } }\n    },\n    weight: 2f\n);\n```\n\n### Actions\n\n**Actions** dictate arbitrary code the agent can execute to affect the world and achieve its goals. Each action, when it runs, will execute the code passed to it, which is called the action **executor**. Actions can also have **preconditions**, state values required before the agent is allowed to execute the action, and **postconditions**, which are values the state is expected to hold if the action is successful. Finally, each action has a **cost**, which is used in calculating the best plan for the agent.\n\nActions return an `ExecutionStatus` enum to say if they succeeded or not. If they succeed, the postconditions will automatically be set to the values passed to the action constructor. If the `ExecutionStatus` returned is `ExecutionStatus.Executing`, the action will be considered in progress, and the executor will be called again on the next Step command.\n\nActions can be passed into the agent constructor, like so:\n\n```csharp\nAction giveHugAction = new Action(\n    executor: (Agent agent, Action action) =\u003e {\n        Console.WriteLine(\"hugged someone\");\n        return ExecutionStatus.Succeeded;\n    },\n    preconditions: new Dictionary\u003cstring, object\u003e {\n        { \"nearOtherAgent\", true }\n    },\n    postconditions: new Dictionary\u003cstring, object\u003e {\n        { \"wasHugged\", true }\n    },\n    cost: 0.5f\n);\nAgent agent = new Agent(\n    actions: new List\u003cAction\u003e {\n        giveHugAction\n    }\n);\n```\n\n#### Comparative Preconditions\n\n**Comparative preconditions** are preconditions that are calculated by comparing a state value to a target value. They take similar parameters to normal preconditions, but the values in the dictionary must be ComparisonValuePair objects.\n\nExample where energy must be greater than zero to walk:\n\n```csharp\nAction walk = new Action(\n    executor: (Agent agent, Action action) =\u003e {\n        Console.WriteLine(\"I'm walkin' here!\");\n        return ExecutionStatus.Succeeded;\n    },\n    comparativePreconditions: new() {\n        { \"energy\", new() { Operator = ComparisonOperator.GreaterThan, Value = 0 } }\n    },\n);\n```\n\n#### Arithmetic Postconditions\n\n**Arithmetic postconditions** are postconditions that are calculated by performing arithmetic on other state values. They take similar parameters to normal postconditions, but the values in the dictionary are added to the existing state value instead of replacing it. Note that the state value and the postcondition value must be of the same numeric type for this to work correctly.\n\nExample that will add 10 to the agent's health as a postcondition:\n\n```csharp\nAction heal = new Action(\n    executor: (Agent agent, Action action) =\u003e {\n        Console.WriteLine(\"healed for 10 hp\");\n        return ExecutionStatus.Succeeded;\n    },\n    arithmeticPostconditions: new Dictionary\u003cstring, object\u003e {\n        { \"health\", 10 }\n    },\n    cost: 0.5f\n);\n```\n\nNote that [normal Goals](#goals) use simple equality checks and cannot tell that a value is closer or further away from the goal value. If you want to use an arithmetic postcondition and have the library detect that you are moving closer to your goal, use [Comparative Goals](#comparative-goals) or [Extreme Goals](#extreme-goals). Both of these types of numerically based goals will calculate distance from a numeric goal value properly.\n\n#### Parameter Postconditions\n\n**Parameter postconditions** are postconditions that copy one of the parameters passed to the action into the agent state. The structure uses a dictionary of string keys and string values, where the keys are the keys to the parameter value being copied and the values are the state key into which you are copying the value.\n\nExample that will copy the \"target\" parameter into the \"target\" state value:\n\n```csharp\nvar targets = new List\u003cstring\u003e { \"target1\", \"target2\" }\nAction setTarget = new Action(\n    executor: (Agent agent, Action action) =\u003e {\n        Console.WriteLine(\"set target\");\n        return ExecutionStatus.Succeeded;\n    },\n    permutationSelectors: new() {\n        { \"target\", PermutationSelectorGenerators.SelectFromCollection(targets) }\n    },\n    parameterPostconditions: new Dictionary\u003cstring, string\u003e {\n        { \"target\", \"target\" }\n    },\n    cost: 0.5f\n);\n```\n\nThis example will create permutations of the action that either target `\"target1\"` or `\"target2\"`, and will copy the selected target into the `\"target\"` state value. See [permutation selectors](#permutation-selectors) for more information on permutation selectors.\n\n### Sensors\n\n**Sensors** allow an agent to distill information into their state, often derived from other state values. Sensors execute on every `Step()` call, and use a **sensor handler** to execute code. Sensors can be passed into the agent constructor, like so:\n\n```csharp\nSensor agentProximitySensor = new Sensor(\n    (Agent agent) =\u003e {\n        if (AgentNearOtherAgent(agent)) agent.State[\"nearOtherAgent\"] = true;\n        else agent.State[\"nearOtherAgent\"] = false;\n    }\n);\nAgent agent = new Agent(\n    sensors: new List\u003cSensor\u003e {\n        agentProximitySensor\n    }\n);\n```\n\n### Permutation Selectors\n\nFinally, actions can be constructed with **permutation selectors**, which will instantiate multiple copies of the action with different parameters for purposes such as target selection. The library comes with some default permutation selector generators, or you can write your own as callbacks. For instance, if you want an action to be evaluated separately with each member of a list as a potential parameter, you would construct the action as so:\n\n```csharp\nAction myAction = new Action(\n    permutationSelectors: new Dictionary\u003cstring, PermutationSelectorCallback\u003e {\n        { \"target1\", PermutationSelectorGenerators.SelectFromCollectionInState\u003cAgent\u003e(\"otherAgents\") },\n        { \"target2\", PermutationSelectorGenerators.SelectFromCollectionInState\u003cAgent\u003e(\"otherAgents\") }\n    },\n    executor: (Agent agent, Action action) =\u003e {\n        Console.WriteLine(action.GetParameter(\"target1\").ToString());\n        Console.WriteLine(action.GetParameter(\"target2\").ToString());\n    }\n);\n```\n\nThe code above will create an action that when evaluated for execution in an agent plan will be considered once for every pair combination of elements in the \"otherAgents\" collection of the agent state, one for `target1`, and one for `target2`. In order to take advantage of this feature, you can also calculate variable costs based on action parameters using the `costCallback` argument in the `Action` constructor. See [cost callbacks](#cost-callbacks) for more information.\n\n### Cost Callbacks\n\n**Cost callbacks** allow you to calculate the cost of an action based on its parameters. This is useful for actions that have variable costs based on the parameters passed to them. For instance, if you have an action that moves the agent to a target, you might want to calculate the cost of the action based on the distance to the target. You can do this by passing a cost callback to the action constructor:\n\n```csharp\nAction moveToTarget = new Action(\n    executor: (Agent agent, Action action) =\u003e {\n        Console.WriteLine(\"moved to target\");\n        return ExecutionStatus.Succeeded;\n    },\n    costCallback: (action, state) =\u003e {\n        if (action.GetParameter(\"target\") is Agent target) {\n            var distance = GetDistance(this, target);\n            return distance;\n        }\n        else return float.MaxValue;\n    }\n);\n```\n\n### State Mutators\n\n**State mutators** allow you to mutate the agent state during execution or evaluation of an action. This is useful for actions that have more complex side effects on agent state. For instance, if you have an action that moves the agent to a target, you might want to mutate the agent state to reflect the new position of the agent. You can do this by passing a state mutator to the action constructor:\n\n```csharp\nAction moveToTarget = newAction(\n    executor: (Agent agent, Action action) =\u003e {\n        Console.WriteLine(\"moved to target\");\n        return ExecutionStatus.Succeeded;\n    },\n    stateMutator: (action, state) =\u003e {\n        if (action.GetParameter(\"target\") is Agent target) {\n            state[\"position\"] = target.State[\"position\"];\n        }\n    }\n)\n```\n\n### State Checkers\n\n**State checkers** allow you to check agent state programmatically during execution or evaluation of an action. This is useful for actions that have more complex preconditions than simple equality checks or arithmetic comparisons. For instance, if you have an action that moves the agent to a target, you might want to check that the target is in range. You can do this by passing a state checker to the action constructor:\n\n```csharp\nAction moveToTarget = new Action(\n    executor: (Agent agent, Action action) =\u003e {\n        Console.WriteLine(\"moved to target\");\n        return ExecutionStatus.Succeeded;\n    },\n    stateChecker: (action, state) =\u003e {\n        if (action.GetParameter(\"target\") is Agent target) {\n            var distance = GetDistance(this, target);\n            if (distance \u003e 10) return false;\n            else return true;\n        }\n        return false;\n    }\n);\n```\n\n### Full API Docs\n\nFull API docs are available [here](./api-docs/index.md).\n\n## Events\n\nMountain GOAP features a simple event system that allows you to subscribe to events that occur during the agent's planning and execution process.\n\n### Agent events\n\nThe following events are available on agents:\n\n-   OnAgentActionSequenceCompleted: Called when the agent has finished executing its plan.\n    -   Example usage: `Agent.OnAgentActionSequenceCompleted += (Agent agent) =\u003e { Console.WriteLine(\"Agent finished executing its plan.\"); };`\n-   OnAgentStep: Called when the agent executes a step of work.\n    -   Example usage: `Agent.OnAgentStep += (Agent agent) =\u003e { Console.WriteLine(\"Agent is working.\"); };`\n-   OnPlanningStarted: Called when the agent begins planning.\n    -   Example usage: `Agent.OnPlanningStarted += (Agent agent) =\u003e { Console.WriteLine(\"Agent started planning.\"); };`\n-   OnPlanningFinished: Called when the agent finishes planning.\n    -   Example usage: `Agent.OnPlanningFinished += (Agent agent, Goal? goal, float utility) =\u003e { Console.WriteLine(\"Agent finished planning.\"); };`\n-   OnPlanningFinishedForSingleGoal: Called when the agent finishes planning for a single goal.\n    -   Example usage: `Agent.OnPlanningFinishedForSingleGoal += (Agent agent, Goal goal, float utility) =\u003e { Console.WriteLine(\"Agent finished planning for a single goal.\"); };`\n-   OnPlanUpdated: Called when the agent generates a viable action sequence.\n    -   Example usage: `Agent.OnPlanUpdated += (Agent agent, List\u003cAction\u003e actionList) =\u003e { Console.WriteLine(\"Agent generated a viable action sequence.\"); };`\n-   OnEvaluatedActionNode: Extremely low level debugging tool, called whenever the agent evaluates a potentially viable node in the action graph. The second parameter is a dictionary of all nodes that have been evaluated so far, with the keys as the most recent nodes and the values as the nodes that preceded them. You can use this to reconstruct the chain of actions that led to this point.\n    -   Example usage: `Agent.OnEvaluatedActionNode(ActionNode node, Dictionary\u003cActionNode, ActionNode\u003e nodes) =\u003e { Console.WriteLine(\"Agent evaluated a node.\")}`\n\n### Action events\n\nThe following events are available on actions:\n\n-   OnBeginExecuteAction: Called when the agent begins executing an action.\n    -   Example usage: `Action.OnBeginExecuteAction += (Agent agent, Action action, Dictionary\u003cstring, object\u003e parameters) =\u003e { Console.WriteLine(\"Agent started executing an action.\"); };`\n-   OnFinishExecuteAction: Called when the agent finishes executing an action.\n    -   Example usage: `Action.OnFinishExecuteAction += (Agent agent, Action action, ExecutionStatus status, Dictionary\u003cstring, object\u003e parameters) =\u003e { Console.WriteLine(\"Agent finished executing an action.\"); };`\n\n### Sensor events\n\nThe following events are available on sensors:\n\n-   OnSensorRun: Called when the agent runs a sensor.\n    -   Example usage: `Sensor.OnSensorRun += (Agent agent, Sensor sensor) =\u003e { Console.WriteLine(\"Agent ran a sensor.\"); };`\n\n## Logger\n\nMountain GOAP contains a default logger implementation that can be used to examine agent behavior. After including the MountainGoapLogger code, you can enable the logger using the following code:\n\n```csharp\n_ = new MountainGoapLogger.DefaultLogger(\n    logToConsole: true,\n    loggingFile: \"agents.log\"\n);\n```\n\n## Examples\n\n[Examples documentation](./Examples/examples.md).\n\n1. [Happiness Maximizer Example](./Examples/HappinessIncrementer.cs)\n2. [RPG Example](./Examples//RpgExample/RpgExample.cs)\n\n## Project Structure\n\n| File or folder                                                    | Description                                                                               |\n| ----------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |\n| `/Examples/`                                                      | Examples of how to use the library                                                        |\n| `/Examples/RpgExample/`                                           | RPG grid-based example.                                                                   |\n| `/Examples/RpgExample/RpgCharacterFactory.cs`                     | Static methods for creating character agents.                                             |\n| `/Examples/RpgExample/RpgExample.cs`                              | Main RPG example entrypoint.                                                              |\n| `/Examples/RpgExample/RpgMonsterFactory.cs`                       | Static methods for creating enemy agents derived from the base character agent.           |\n| `/Examples/RpgExample/Utils.cs`                                   | RPG example utility functions.                                                            |\n| `/Examples/examples.md`                                           | Examples documentation.                                                                   |\n| `/Examples/HappinessIncrementer.cs`                               | Happiness incrementer example.                                                            |\n| `/Examples/Program.cs`                                            | Examples entrypoint.                                                                      |\n| `/MountainGoap/`                                                  | The main library folder                                                                   |\n| `/MountainGoap/CallbackDelegates/`                                | Function signatures for callbacks.                                                        |\n| `/MountainGoap/CallbackDelegates/ExecutorCallback.cs`             | Function signature for a callback that executes an action.                                |\n| `/MountainGoap/CallbackDelegates/PermutationSelectorCallbacks.cs` | Function signature for a callback that selects a list of options for an action parameter. |\n| `/MountainGoap/CallbackDelegates/SensorRunCallback.cs`            | Function signature for a callback that runs a sensor.                                     |\n| `/MountainGoap/Internals/`                                        | Internal classes that external applications using the library will not need directly.     |\n| `/MountainGoap/Internals/ActionAStar.cs`                          | Class that calculates AStar for an action graph.                                          |\n| `/MountainGoap/Internals/ActionGraph.cs`                          | Class that represents an action graph.                                                    |\n| `/MountainGoap/Internals/ActionNode.cs`                           | Class that represents a node in an action graph.                                          |\n| `/MountainGoap/Internals/CopyDictionaryExtensionMethod.cs`        | Convenience extension method for copying a dictionary.                                    |\n| `/MountainGoap/Internals/Planner.cs`                              | Planning class used by agents.                                                            |\n| `/MountainGoap/Action.cs`                                         | An action that can be made available to agents.                                           |\n| `/MountainGoap/Agent.cs`                                          | An agent that can figure out plans to execute.                                            |\n| `/MountainGoap/BaseGoal.cs`                                       | A base class for all goal types.                                                          |\n| `/MountainGoap/ComparativeGoal.cs`                                | A goal that compares a value to a pre-existing value                                      |\n| `/MountainGoap/ComparisonOperator.cs`                             | An enum defining the comparison operators that can be used with ComparativeGoal.          |\n| `/MountainGoap/ComparisonValuePair.cs`                            | A class that represents a comparison value pair.                                          |\n| `/MountainGoap/ExecutionStatus.cs`                                | An enum defining the execution status of an action.                                       |\n| `/MountainGoap/ExtremeGoal.cs`                                    | A goal that attempts to minimize or maximize a state value.                               |\n| `/MountainGoap/Goal.cs`                                           | A goal that agents can attempt to accomplish.                                             |\n| `/MountainGoap/PermutationSelectorGenerators.cs`                  | Generators for lambda functions that return a list of options for an action parameter.    |\n| `/MountainGoap/Sensor.cs`                                         | A sensor that generates data for use by an agent.                                         |\n| `/MountainGoapLogging/DefaultLogger.cs`                           | Example logger implementation that can be used to inspect agent behavior.                 |\n\n## Roadmap\n\n-   Tests\n-   Examples - general and Unity\n\n## Other open source GOAP projects\n\n-   [ReGoap](https://github.com/luxkun/ReGoap) - C# GOAP library with more direct Unity support, providing Unity Components that can be attached to GameObjects.\n\n## License Acknowledgements\n\nProject is MIT licensed, and the main license file can be found [here](./LICENSE.txt).\n\n### Priority Queue Implementation\n\nThe MIT License (MIT)\n\nCopyright (c) 2013 Daniel \"BlueRaja\" Pflughoeft\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcaesuric%2Fmountain-goap","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcaesuric%2Fmountain-goap","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcaesuric%2Fmountain-goap/lists"}