CUHP: Simple C# Task Planner for Unity3D

Artificial intelligence is a growing field, especially in the games industry. The need for realistic and intelligent behavior in games is increasing. In my previous post I presented a new planner written in C#, a so-called hierarchical task network (HTN) planner. I know of several (scientific) examples where HTN-planners are used in real-time strategy games (e.g. Total Annihilation, Warcraft) or first-person shooters (e.g. Killzone 2, Arma, Unreal Tournament). I now show how my planner can be used in video games, or more specifically, video games made with Unity3D.

In the next section I talk about how my HTN-planner works with Unity3D, after that I show an example, and finally, I talk about what direction I have in mind for the future of my HTN-planner.

The C# Unity3D HTN-Planner

I present you, the C# Unity3D HTN-planner (CUHP), a hierarchical task network (HTN) planner written in C# for use in Unity3D. The planner is downloadable as a Unity asset-file and as a Unity3D project. If you want to know how HTN-planners work, I would suggest you read my previous blog post first.

The HTN-planner takes as input a planning problem and a planning domain. The planning problem contains a knowledge representation of the current state of the world and one or more goal tasks. The planning domain contains HTN-operators and methods which represent actions an agent or an NPC can take in the world.

An interface with the HTN-planner is needed to use the CUHP-system in a game environment. It can be really simple, and can be part of another script if desired. The following code is an example of such a planner interface:
private HTNPlanner planner = new HTNPlanner(typeof(Domain), new Domain().GetMethodsDict(), typeof(Domain));

private List<string> GetPlan ()
    if (GetComponent<WorldModelManager>())
        State initialState = GetComponent<WorldModelManager>().GetWorldStateCopy();
        List<List<string>> goalTasks = new List<List<string>>();
        goalTasks.Add(new List<string>(new string[1] { "SolveProblem" }));

        return planner.SolvePlanningProblem(initialState, goalTasks);
    return null;

First a new HTN-planner is declared and the planning domain is given as parameters. Here, a method called "GetPlan" is made to provide a way to use the HTN-planner. It can be customized to fit specific needs. The method gets the initial state from another script (WorldModelManager) and creates a new goal task called "SolveProblem". Finally, it calls the "SolvePlanningProblem"-method of the HTN-planner, providing the initial world state and goal tasks as parameters, and then returns the plan found by the planner. The next section shows an example in which a plan is actually executed.

The Cleaning Robot Example

I made two simple examples in Unity3D, a swap object example and a cleaning robot example. The latter is the most interesting, it is a virtual environment consisting of several linked rooms which together form a building. A cleaning robot resides in this building and it can be commanded to clean dirty rooms. The user can simply click on a room to make it dirty (or clean), and by doing this, a planning problem is created. Then, when any number of rooms are made dirty, the planner can be started (with a button) to solve the planning problem and produce a plan for the cleaning robot to execute. When a feasible plan is found, the robot will execute it and clean all dirty rooms in the building.

The following picture shows the virtual environment of the cleaning robot example:

The world is abstract and basic because the focus is on planning. The tiles represent rooms, the sphere represents the cleaning robot. When the user clicks on the "Clean"-button, the HTN-planner seeks a plan and sends it to the robot for execution. The robot converts a plan of actions into an action queue and executes the actions one-by-one. If the robot is still busy and receives a new plan, it clears its action queue and fills it with new actions, but it always finishes its current action. This simple example can be easily extended into a more complex game situation.

As mentioned in my previous blog post, the HTN-planner is not perfect at backtracking yet. The user can create some planning problems in the cleaning robot example for which no feasible plan can be found. This should not be too hard to fix and I might do that soon.

Future Work

I have a few ideas in mind about the future of this CUHP-system:
  • HTN planning for strategy games. I want to make a more advanced game example to show the power of my HTN-planner, for example, I want to apply it to a real-time strategy game.
  • Extending the Unity3D Editor. I want to extend the Unity Editor GUI for easy integration of the planner with a game, and to provide a more efficient way of designing artificial intelligence when making a game.
  • Unity Asset Store. I am considering making the planner available in the Unity Asset Store.

I plan to work on these points in the future, and will write about it when I made progress.

You are encouraged to use the CUHP-system, and expand and improve on it, as long as you share alike under the same (or a similar) open-source license.


  1. Awesome article! I think this planner will be of great help in many Unity games!

    However a few tips regarding implementation in Unity:
    - Using GetComponent makes the script search through all of the components of its game object, which can be CPU heavy if done on runtime.
    - Reflection does not work in Unity's Webplayer.

  2. Thank you! Yes I hope it will.

    Oh well the GetComponent is just part of a simple example, you can change it in any way you like.
    Can you provide me with more information as to why C# reflection does not work in Unity's webplayer? I never heard about that before.

  3. http://docs.unity3d.com/Documentation/Manual/SecuritySandbox.html

  4. It's a great post. Thanks a lot for sharing!

  5. Excellent post, I'm combining this stuff with Behavior trees just to play a little.

    Btw, how do you plan to add functionality like send the planner a message that you plan now is invalid?

    1. Thanks. Oh that's interesting, I would love to see how that turns out.

      Well, you could make your own replanning-methods in the planner and then tell the planner to replan. You are entirely free on how you define your methods. Maybe you could even make repair-methods that fix the problem when something goes wrong. Just make sure you update the initial planning state and the goal tasks (planning problem). A goal task could then be something like replan or repair.

      I have no specific plan yet of adding such functionality myself, but maybe I'll try to develop a generic approach to it later.

  6. Hi!!, I think this is a very good iniciative, but I wonder, do you know of any C++ port?, I'm currently working in an university project but I'm using GNU/Linux and my project is in C++.

    1. Hello Marcos! I know for a fact that Guerrilla Games uses a C++ HTN-planner for the AI in the Killzone games, even though it's not publicly available, maybe they might still be able to help you out in some way if you contact them? Furthermore, I think Pegase+ Program Supervision Engine contains a C++ HTN-planner, but I'm not really sure about that as I have not looked into it (yet).. You might also be able to write a simple HTN-planner in C++ yourself, it should not be too hard I'd imagine. You could try to copy the functionality of my C# HTN-planner or Dana Nau's Pyhop implementation into your own C++ HTN-planner, or you could read (for example) the book Automated Planning by Ghallab, Nau and Traverso to understand the concept of HTN-planning more and to understand how you could program one yourself. As a final point, you could also try to connect your project with another HTN-planner through (for example) a socket connection. There are several existing HTN-planners that work on Linux.