Pathfinding in Unity
4.8 (271 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
2,846 students enrolled

Pathfinding in Unity

implementing A* search and graph search algorithms in Unity
Highest Rated
4.8 (271 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
2,846 students enrolled
Created by Wilmer Lin
Last updated 3/2020
English
English [Auto]
Current price: $27.99 Original price: $39.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 4.5 hours on-demand video
  • 3 articles
  • 30 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Understand the fundamentals of graph search algorithms
  • Implement your own basic version of A*
Course content
Expand all 36 lectures 04:27:33
+ Introduction
3 lectures 11:22

Welcome to Pathfinding in Unity!

Preview 01:22

Before you begin this course, please review the prerequisites.  This course is intended for Intermediate Unity developers with experience in C# scripting.

Preview 04:00

Here let's review the naming conventions that we use for the included Unity project.

Preview 06:00
+ Constructing a Maze
12 lectures 01:25:57

Let's review the basics of pathfinding.   Graphs are a set of interconnected nodes, which are joined by edges.  We will apply this data structure to a physical map, allowing us to solve for a path through a maze.

Preview 03:18

Each graph is made of nodes.  Let's define a class for our most basic object, the Node.

The Node class
06:00

In this lesson, we define a MapData class, designed to read the level data into the Graph.

The MapData class
05:29

We will create a Graph class to manage the various nodes which will comprise our level.

The Graph class
06:07

Our nodes will be connected by proximity.  In this lesson, we define a set of compass directions and establish how nodes and their neighbors are connected.

Neighbor Nodes
07:26

Let's use the MVC (Model View Controller) design pattern to create some new components.  We will make an interface class called the NodeView specifically designed for displaying a Node onscreen.

NodeView
08:25

Let's create another user interface class, the GraphView, for managing all of our NodeViews.

GraphView
08:54

In this lesson, we review creating level data as a Text Asset, allowing us to store our map as a simple set of ASCII characters on disk.

Text Mapdata Part 1
09:26

In this lesson, we create the MakeMap method in the MapData class, allowing us to read the 1's and 0's from our ASCII Text Asset.  Now we have a much easier means of generating our level maps!

Text MapData Part 2
08:56

We can use the Resources command to help organize our project folders.  Setting up the default Resources folder allows us to look for map data without needing to browse for files explicitly in the Inspector! 

Resources
04:42

If using a text editor to create your level map is too cumbersome, let's use our favorite image editor to create a level!  Using a one-pixel brush we can save our maze in a super small image file.  This is a super interactive way to create new levels!

Preview 09:59

We have a minor bug in our MapData class.  Let's examine how Script Execution Order can affect the behavior of our components and apply a simple fix.

Update: Script Execution Order
07:15
+ Pathfinding Algorithms
18 lectures 02:42:21
The Pathfinder class
10:12
Search Part 1
05:32
Search Part 2
06:22
Node Arrows
10:12
Path Nodes
09:16
Breadth First Search
11:59
Dijkstra's Algorithm
05:06
Node Distance
04:41
Dijkstra's Search
11:09
Priority Queue Part 1
06:59
Priority Queue Part 2
12:27
Priority Queue Part 3
11:34
Terrain Cost Part 1
12:52
Terrain Cost Part 2
14:01
Greedy Best-First Search
11:58

In this lesson, we tweak our Pathfinder search routine to implement A* search!

A* Search
12:35
Code Comments
00:01
+ Updates
2 lectures 07:29
Search Routine Updates
06:54
Refactored Project
00:35
+ Bonus
1 lecture 00:22
Credits and Acknowledgments
00:22
Requirements
  • Unity 3D version 2017 or above (personal FREE edition)
  • Mac or PC
  • OPTIONAL Photoshop or image-editing program to customize level data
Description

Description

This course is designed for intermediate users of Unity (see the Prerequisites for specific topics you should be familiar with before joining). 

Though Unity comes pre-packaged with an excellent pathfinding system, we explore beyond using a black box to calculate paths through your game levels.

Pathfinding and search algorithms are a core component of game development.  If you want to level up your skills, enroll today and dive into implementing your own version of A* search!

Through a carefully crafted set of lectures we learn search algorithms, starting with Breadth-First Search, diving in Dijkstra's algorithm and culminating with the industry-standard A* search for pathfinding.

All concepts are presented with easy-to-understand visuals! 

Some other bonus features of those course:

  • learn to use text files or texture maps to drive level data in Unity
  • learn how to implement a priority queue (binary heap) in C#
  • learn to structure a small project using the MVC(Model View Controller) design pattern



Who this course is for:
  • intermediate Unity developers with good working knowledge of C#
  • anyone who wants to implement graph search algorithms in Unity