{"id":77860,"date":"2018-03-29T20:30:50","date_gmt":"2018-03-29T20:30:50","guid":{"rendered":"https:\/\/www.red-gate.com\/simple-talk\/?p=77860"},"modified":"2021-07-29T19:44:15","modified_gmt":"2021-07-29T19:44:15","slug":"pathfinding-unity-c","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/development\/dotnet-development\/pathfinding-unity-c\/","title":{"rendered":"Pathfinding with Unity and C#"},"content":{"rendered":"

The series so far:<\/h4>\n
    \n
  1. Introduction to Game Development with Unity and C#<\/a><\/li>\n
  2. Using C# Functions in Your Animations<\/a><\/li>\n
  3. Procedural Generation with Unity and C#<\/a><\/li>\n
  4. Pathfinding with Unity and C#<\/a><\/li>\n
  5. Extending the Unity Editor with C#<\/a><\/li>\n
  6. Using Unity UI and C# to Create a Tic-Tac-Toe Game<\/a><\/li>\n<\/ol>\n\n

    When creating enemy AI (Artificial Intelligence) it is often important to specify paths for your enemies. Enemy pathfinding can be useful for all types of games, be it stealth games or even fast paced action games. This pathfinding is often done by using a navigation mesh, or \u2018navmesh,\u2019 to find their way around. A navmesh is a type of data structure that is applied to objects to aid in pathfinding through complicated spaces. Video games began to see navigation meshes used more frequently as early as 2000.<\/p>\n

    As with many things, Unity has a simple way to create a pathfinding system for your objects. This easy process will allow you to get your basic AI off the ground quickly and allow you to create a more complex AI from there. In this example you’ll be creating a navigation mesh that an object will use to make its way to several points that you place in the environment. You will craft an area that you can \u2018bake\u2019 a navigation mesh in to start, create an object, and give the object a script that it will use to travel to different waypoints. From there you will set up these waypoints and assign them to the object in order to create a path for your object to follow endlessly.<\/p>\n

    Setting Up<\/h2>\n

    First you will need to create a project. Open Unity and select New<\/em> in the top right corner of the window as shown in Figure 1.<\/p>\n

    <\/p>\n

    Figure 1: Creating a new project<\/p>\n

    Name this project Pathfinding<\/em> and make sure it’s a 3D project (it should be by default). Specify a file path for your project. Your project creation window should look similar to Figure 2. Click Create project<\/em> once the form is complete.<\/p>\n

    <\/p>\n

    Figure 2: Naming the project<\/p>\n

    Allow Unity a moment to create the project. Once it\u2019s finished, the first thing that you’ll need to do is create an area for the navmesh. Start by selecting the Create <\/em>menu in the Hierarchy <\/em>window then selecting 3D Object <\/em>and then Cube<\/em>. Figure 3 shows where to select the cube object for creation.<\/p>\n

    <\/p>\n

    Figure 3: Creating a new cube object<\/p>\n

    This first cube object will be the floor of this scene. Name the object Floor <\/em>and give it an X Scale <\/em>of 20 and a Z Scale <\/em>of 20. Figure 4 shows the final result of the Floor <\/em>object in the Inspector<\/em> window.<\/p>\n

    <\/p>\n

    Figure 4: Renaming object to Floor and setting its scale values<\/p>\n

    Creating the Scene<\/h2>\n

    Now you should make some obstacles for the object to navigate around. Your scene can be as simple or as complex as you like. Figure 5 shows an example scene that you can use.<\/p>\n

    <\/p>\n

    Figure 5: An example scene<\/p>\n

    If you want a better view of your scene when creating it, you can move the scene camera around by right-clicking in the Scene <\/em>window and moving the mouse. Zoom in and out of the Scene <\/em>window by scrolling your mouse wheel in the Scene <\/em>window until you see everything you want view.<\/p>\n

    To create some obstacles, go to the Create <\/em>menu once again and under 3D Object <\/em>select Cube<\/em>. Duplicate the cube as many times as you wish, then set a scale, rotation, and position for each cube using the Transform <\/em>component in the Inspector <\/em>window. Note: the cube objects will probably need to have a Y Position <\/em>value of about 0.25, this way the cubes won’t be below the floor. Also, it is recommended that the cubes should have a Y Scale <\/em>of at least 2. Your cube objects can be arranged in any way you like, but if you wish to replicate the scene in Figure 5 you may refer to Table 1 for the sizes and positions.<\/p>\n

    Table 1: The position and scale of all objects used in the example figures<\/p>\n\n\n\n\n\n\n\n\n
    \n

    Object<\/p>\n<\/td>\n

    		\n

    Position X<\/p>\n<\/td>\n

    		\n

    Position Y<\/p>\n<\/td>\n

    		\n

    Position Z<\/p>\n<\/td>\n

    		\n

    Scale X<\/p>\n<\/td>\n

    		\n

    Scale Y<\/p>\n<\/td>\n

    		\n

    Scale Z<\/p>\n<\/td>\n<\/tr>\n

    \n

    Cube<\/p>\n<\/td>\n

    		\n

    1.13<\/p>\n<\/td>\n

    		\n

    0.25<\/p>\n<\/td>\n

    		\n

    0<\/p>\n<\/td>\n

    		\n

    10<\/p>\n<\/td>\n

    		\n

    2<\/p>\n<\/td>\n

    		\n

    1<\/p>\n<\/td>\n<\/tr>\n

    \n

    Cube (1)<\/p>\n<\/td>\n

    		\n

    6.04<\/p>\n<\/td>\n

    		\n

    0.25<\/p>\n<\/td>\n

    		\n

    5.87<\/p>\n<\/td>\n

    		\n

    7<\/p>\n<\/td>\n

    		\n

    2<\/p>\n<\/td>\n

    		\n

    3<\/p>\n<\/td>\n<\/tr>\n

    \n

    Cube (2)<\/p>\n<\/td>\n

    		\n

    -3.73<\/p>\n<\/td>\n

    		\n

    0.25<\/p>\n<\/td>\n

    		\n

    -5.32<\/p>\n<\/td>\n

    		\n

    9<\/p>\n<\/td>\n

    		\n

    2<\/p>\n<\/td>\n

    		\n

    3<\/p>\n<\/td>\n<\/tr>\n

    \n

    Cube (3)<\/p>\n<\/td>\n

    		\n

    -3.73<\/p>\n<\/td>\n

    		\n

    0.25<\/p>\n<\/td>\n

    		\n

    4.64<\/p>\n<\/td>\n

    		\n

    7<\/p>\n<\/td>\n

    		\n

    2<\/p>\n<\/td>\n

    		\n

    4<\/p>\n<\/td>\n<\/tr>\n

    \n

    Cube (4)<\/p>\n<\/td>\n

    		\n

    6.05<\/p>\n<\/td>\n

    		\n

    0.25<\/p>\n<\/td>\n

    		\n

    -5.87<\/p>\n<\/td>\n

    		\n

    5<\/p>\n<\/td>\n

    		\n

    2<\/p>\n<\/td>\n

    		\n

    5<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    Once you’ve set up your cubes, go ahead and parent them to the Floor <\/em>object by selecting all your cube objects and dragging them onto the Floor<\/em> object in the Hierarchy<\/em>. Note: In the Inspector <\/em>window it will look like the positions and scales change after parenting them to the Floor<\/em> object. These values are their local position and local scale. You do not need to edit them.<\/p>\n

    If you wish, you may also create a material for the floor so that you can more easily tell the difference from the floor to the walls you have created. To create a material, right click in your Assets <\/em>window and select Create->Material <\/em>like in Figure 6.<\/p>\n

    <\/p>\n

    Figure 6: Creating a new material<\/p>\n

    After creating the material, give it the name Floor <\/em>as seen in Figure 7.<\/p>\n

    <\/p>\n

    Figure 7: Renaming the material to Floor<\/p>\n

    Now you just need to set a color other than white for it. With the Floor <\/em>material selected, head over to the Inspector <\/em>window and double-click the color picker near the top like in Figure 8.<\/p>\n

    <\/p>\n

    Figure 8: Opening the color picker<\/p>\n

    In this example, the color has been set to grey, but it can be whatever color you desire. Figure 9 shows the Unity color wheel and the RGB values used in this example.<\/p>\n

    <\/p>\n

    Figure 9: Example color for the Floor material<\/p>\n

    Finally, to set the Floor <\/em>material to the Floor <\/em>object, select the Floor <\/em>object from the Hierarchy <\/em>and under the Mesh Renderer <\/em>component select the Materials <\/em>option like in Figure 10.<\/p>\n

    <\/p>\n

    Figure 10: Opening the Materials menu<\/p>\n

    This will reveal some properties where you can change the material the object is using. Click and drag the Floor <\/em>material from the Assets <\/em>window into the Element 0<\/em> field in the Inspector <\/em>like in Figure 11. Once complete, your floor will have a grey color to it, making it easier to tell apart the floor from the walls.<\/p>\n

    <\/p>\n

    Figure 11: Applying the material to the Floor object<\/p>\n

    Now there needs to be an object that to navigate the area you have created. Once again, open the Create <\/em>menu at the top of the Hierarchy <\/em>and navigate to 3D Object->Cube <\/em>to create another cube object. Be sure to set its position values to X 0, Y 1, Z 1.5<\/em> in the Inspector <\/em>window. Note: you may need to adjust this depending on your scene layout. Give the cube the new name Object<\/em>. When finished, your Hierarchy <\/em>window should look similar to Figure 12.<\/p>\n

    <\/p>\n

    Figure 12: The current Hierarchy window<\/p>\n

    You can come back to this object in a moment, but before continuing you should go ahead and create the navmesh that will be used in your project. To do this you will need to navigate to Window->Navigation <\/em>to open the Navigation <\/em>window. Figure 13 shows where to find this.<\/p>\n

    <\/p>\n

    Figure 13: Opening the Navigation window<\/p>\n

    This should open the Navigation <\/em>window where the Inspector <\/em>window was earlier. By default, Object<\/em> should be selected in the Navigation <\/em>menu. Before continuing, make sure that the Floor <\/em>object is selected in the Hierarchy <\/em>window, else the process of creating the navmesh won’t work. Make sure All <\/em>is selected under Scene Filter <\/em>(once again, it should be by default) then check the Navigation Static<\/em> checkbox. If you see a message asking if you want to enable the Navigation Static flag for the child objects, click Yes, change children<\/em>. When finished the Navigation <\/em>window should look like the one in Figure 14.<\/p>\n

    <\/p>\n

    Figure 14: Setting properties for the navmesh<\/p>\n

    Next, select the Bake <\/em>option in the Navigation <\/em>window as seen in Figure 15.<\/p>\n

    <\/p>\n

    Figure 15: Opening the Bake menu<\/p>\n

    Once selected you will be greeted with the Bake <\/em>menu. This is where the navigation mesh will be created. You can set properties like the radius and height here to change how the navmesh will turn out once it is finished \u2018baking,\u2019 which is the process of creating the navigation mesh from Unity’s end. For this project, you may leave all properties at their default values. Before creating the navmesh, you will need to save your scene. Once your scene is saved, go ahead and select the Bake <\/em>option near the bottom of the Bake <\/em>menu as seen in Figure 16 to create the navmesh.<\/p>\n

    <\/p>\n

    Figure 16: Baking the navmesh into the scene<\/p>\n

    You may need to allow a moment for Unity to create the navigation mesh before continuing. After Unity completes the navmesh creation process, your scene window should look similar to Figure 17.<\/p>\n

    <\/p>\n

    Figure 17: Example navmesh<\/p>\n

    Switch back to the Inspector <\/em>window by clicking Inspector<\/em> near the top of the Navigation <\/em>window like in Figure 18.<\/p>\n

    <\/p>\n

    Figure 18: Switching to the Inspector window<\/p>\n

    Select Object<\/em> in the Hierarchy <\/em>to complete the setup. The last thing you need to do is give Object <\/em>a new component called Nav Mesh Agent<\/em>. To do this, click the Add Component <\/em>button in the Inspector <\/em>window. Figure 19 shows where this button is.<\/p>\n

    <\/p>\n

    Figure 19: Adding a new component<\/p>\n

    Using the search bar, search for Nav Mesh Agent<\/em>. Once found, click on the component like in Figure 20 to add it to the Object <\/em>object.<\/p>\n

    \"\"<\/p>\n

    Figure 20: Adding the Nav Mesh Agent component<\/p>\n

    The Nav Mesh Agent <\/em>component allows an object to navigate the scene using the navmesh you just created. There are several properties you can change such as how fast it goes, if it automatically brakes, or adjusting the obstacle avoidance radius. In this project you can leave all those alone if you wish, as the default settings will work perfectly with this project. Now the only step remaining before adding C# code is to create another new component for the object, this time a script component. Click the Add Component <\/em>button again and this time search for \u2018new script. Once found, select new script\u2019 to create a new script. Give it the name Pathfinding <\/em>and make sure the language is set to C Sharp<\/em>. Select Create and Add <\/em>to create the script and attach it to Object<\/em>. Figure 21 shows how the setup should look.<\/p>\n

    <\/p>\n

    Figure 21: Creating the Pathfinding script<\/p>\n

    With the new script created, it is now time to open Visual Studio and create the Pathfinding <\/em>script. Double click the Script <\/em>field under the Pathfinding<\/em> component like in Figure 22 to open Visual Studio and begin writing this object’s pathfinding code.<\/p>\n

    <\/p>\n

    Figure 22: Opening the script in Visual Studio<\/p>\n

    Creating the Code<\/h2>\n

    Before any code can be written a library will need to be added in Visual Studio. Just underneath the line using UnityEngine;<\/strong> enter the following line of code:<\/p>\n

    using UnityEngine.AI;<\/pre>\n
    This line will allow you to get the Nav Mesh Agent <\/em>component that you attached earlier to Object<\/em>. It will also give you the tools needed to have the object move between different points you’ll be setting up for it in a moment. Now, just underneath the line that says public class Pathfinding : MonoBehaviour <\/strong>enter the following code:<\/p>\n
    public Transform[] points;\r\n  private NavMeshAgent nav;\r\n  private int destPoint;<\/pre>\n
    First, you will be making a public array of Transforms simply called points<\/strong>. This array will store the locations of the different points that will be set up in the next section. The object this script is attached to will make its way to each point one by one until you end the game. It will navigate towards these points using the Nav Mesh Agent <\/em>component, and the code will store a reference of that component in the nav <\/em>variable. Finally, there’s the destPoint<\/strong> integer, which will be used to cycle through the different points laid out for Object<\/em>. At this point, your code should look similar to the code seen in Figure 23.<\/p>\n
    <\/p>\n
    Figure 23: Getting the UnityEngine.AI library and declaring all needed variables<\/p>\n
    Now, in the Start<\/strong> function, you’ll need to enter a single line of code that will allow you to get a reference to the Nav Mesh Agent <\/em>component at the very start of the game. Simply enter the following code into the Start <\/strong>function:<\/p>\n
    nav = GetComponent<NavMeshAgent>();<\/pre>\n
    Next, go to the Update <\/em>function. Before entering anything in this function, rename it to FixedUpdate<\/em><\/strong>. The difference between Update <\/em>and FixedUpdate<\/em><\/strong> is that Update <\/em>will run once every frame, whereas FixedUpdate<\/em><\/strong> is capable of running zero, one, or more times per frame. If, for example, your game is running at thirty frames per second, your FixedUpdate<\/em><\/strong> can make sure physics calculations are consistent and in synch with the global physics timestep of your game. Thus, it is recommended that any physics updates such as movement should be placed within the FixedUpdate<\/em><\/strong>. With that in mind, add the following code to the FixedUpdate<\/em><\/strong> function.<\/p>\n
    if (!nav.pathPending && nav.remainingDistance < 0.5f)\r\n  \tGoToNextPoint();<\/pre>\n
    Here you’re checking to see if the object has reached its destination or not. If it has not reached its destination (the next point in its list), then nothing happens. However, if it has reached its destination, it will call the GoToNextPoint<\/strong> method to find the next point to travel to. By now your Start<\/strong> and FixedUpdate<\/strong> functions should look like Figure 24.<\/p>\n
    <\/p>\n
    Figure 24: The Start and FixedUpdate functions<\/p>\n
    Finally, the GoToNextPoint<\/strong> method must be created. Underneath the FixedUpdate<\/strong>, <\/em>function enter the following code:<\/p>\n
    void GoToNextPoint()\r\n  {\r\n  \tif (points.Length == 0)\r\n  \t{\r\n  \t\treturn;\r\n  \t}\r\n  \tnav.destination = points[destPoint].position;\r\n  \tdestPoint = (destPoint + 1) % points.Length;\r\n  }<\/pre>\n
    As stated above, the GoToNextPoint<\/strong> method will find the next point for the object to travel to. However, if the points<\/strong> array has nothing in it, it will instead cancel the method execution. This can help prevent any accidental errors from not entering anything into the array. After checking the length of the points<\/strong> array, it will then go on to set Object’s <\/em>next destination and find the next point in the list to have ready for the next time this method is called.<\/p>\n
    Once this method has been written, this script will be complete. Figure 25 shows the completed code along with the code for the GoToNextPoint <\/strong>method. Save the script and return to the Unity editor.<\/p>\n
    <\/p>\n
    Figure 25: The completed Pathfinding script<\/p>\n
    Completing the Project<\/h2>\n
    To finish the Pathfinding <\/em>project, you simply need to create several points for the Object <\/em>to travel to. Once again, click the Create <\/em>button in the Hierarchy <\/em>and select 3D Object->Cube<\/em> to create a new cube object. Make sure its Y Position <\/em>value is set to 1 (X <\/em>and Z <\/em>can be any value, so long as it’s within the map you created) in the Inspector. A<\/em>lso disable the Box Collider <\/em>component by clicking the checkbox next to the name of the component. Set the X, Y, and Z scale to 0.25.<\/p>\n
    With your new Point <\/em>object in place, create a new material to help identify the points. Name this material Point <\/em>and give it whatever color you wish (the example will use green). Assign the Point <\/em>material to the Point <\/em>object like you did with the Floor <\/em>object and material. Finally, set the X, Y, <\/em>and Z <\/em>scale of 0.25. The properties of the Point object should look similar to Figure 26.<\/p>\n
    <\/p>\n
    Figure 26: The Point object properties<\/p>\n
    Next, create duplicates of the Point <\/em>object by selecting Point <\/em>in the Hierarchy <\/em>and pressing Ctrl+D<\/strong>. You can have as many Point <\/em>objects as you wish, but this example will have a total of five Point <\/em>objects. Once these objects are created, move each Point <\/em>object to a different position on the map. Figure 27 shows an example of what the map with points will look like. Remember that yours may not look exactly like the image, depending on how you choose to set up your scene.<\/p>\n
    <\/p>\n
    Figure 27: Points with new material and size<\/p>\n
    Now you’ll just need to set the Point <\/em>objects as the values of the Points <\/em>array created in your Pathfinding <\/em>script. Select Object <\/em>and lock the Inspector <\/em>window onto Object<\/em> so that you don’t accidentally change screens when selecting other objects. Figure 28 shows where to click to lock the window.<\/p>\n
    <\/p>\n
    Figure 28: Locking the Inspector window<\/p>\n
    Select all the Point <\/em>objects in the Hierarchy <\/em>and drag them into the Points <\/em>field in the Pathfinding <\/em>component like in Figure 29.<\/p>\n
    <\/p>\n
    Figure 29: Setting the values of the Points array<\/p>\n
    Finally, you should reorient the camera, so you can see what Object<\/em> is doing when you press the play button. Be sure to unlock the Inspector <\/em>window, then choose the Main Camera <\/em>object from the Hierarchy <\/em>and set the following values:<\/p>\n
      \n
    • Position X: 0<\/li>\n
    • Position Y: 20<\/li>\n
    • Position Z: 0<\/li>\n
    • Rotation X: 90<\/li>\n<\/ul>\n
      When finished, the Transform <\/em>component for your Main Camera <\/em>object should look like the one seen in Figure 30.<\/p>\n
      <\/p>\n
      Figure 30: Setting up the Main Camera rotation and position<\/p>\n
      Once you have finished setting up the Main Camera<\/em> object, press the play button at the top of the Unity editor and watch Object <\/em>move to the different points you set up for it. When you’re done watching, click the play button at the top again or press Ctrl+P<\/strong> to exit play mode. Rearrange the points to create a new path for your object and play the game again. Notice how it both consistently finds the fastest route and is smart enough to avoid the walls you created, regardless of your point layout. Figure 31 shows this project in action.<\/p>\n
      <\/p>\n
      Figure 31: The Pathfinding project in action.<\/p>\n
      Conclusion<\/h2>\n
      With the project completed you have learned how to create a navigation mesh in your scene and have an object look at that navmesh to figure out where it can and cannot go. Unity makes it easy to quickly create this navmesh as well as put together a simple pathfinding system for an object. You can apply this knowledge in virtually any type of game, be it a stealth game where you assign enemy patrol routes for the player to avoid or in a puzzle game where you can decide where certain parts of a puzzle move to. The Unity engine handles a lot of the heavy lifting for you, permitting you to put more time into making a fun game without getting bogged down in trying to create simple AI.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Unity makes it simple to create an object that follows a path. In this article, game programmer Lance Talbert shows how to use C# to control the object’s path.…<\/p>\n","protected":false},"author":317499,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[143538],"tags":[],"coauthors":[52549],"class_list":["post-77860","post","type-post","status-publish","format-standard","hentry","category-dotnet-development"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/77860","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/users\/317499"}],"replies":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/comments?post=77860"}],"version-history":[{"count":8,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/77860\/revisions"}],"predecessor-version":[{"id":78315,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/77860\/revisions\/78315"}],"wp:attachment":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/media?parent=77860"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/categories?post=77860"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/tags?post=77860"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/coauthors?post=77860"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}