Last updated 8/2022Course Language EnglishCourse Caption English [Auto], Portuguese [Auto], 1 moreCourse Length 30:10:37 to be exact 108637 seconds!Number of Lectures 185
This course includes:
30 hours hours of on-demand video
17 article
Full lifetime access
Access on mobile and TV
Certificate of completion
128 additional resources
Design and program NPCs with C# in Unity
Explain how AI is applied in computer games
Implement AI-related Unity Asset plugins into existing projects
Work with a variety of AI techniques for developing navigation and decision making abilities in NPCs
Do your non-player characters (NPCs) lack drive and ambition? Are they slow, stupid and constantly banging their heads against the wall? Then this course is for you. Join Penny as she explains, demonstrates and assists you in creating your very own NPCs in Unity with C#. All you need is a sound knowledge of Unity, C# and the ability to add two numbers together.This course uses Unity Version 2021.3 LTSIn this course, Penny reveals the most popular AI techniques used for creating believable character behaviour in games using her internationally acclaimed teaching style and knowledge from over 30 years working with games, graphics and having written two award winning books on games AI. Throughout, you will follow along with hands-on workshops designed to teach you about the fundamental AI techniques used in today's games. You'll join in as NPCs are programmed to chase, patrol, shoot, race, crowd and much more.Learn how to program and work with:vectorswaypointsnavmeshesthe A* algorithmcrowdsflocksanimated charactersvehiclesand industry standard techniques such as goal-oriented action learning and behaviour trees.Contents and OverviewThe course begins with a detailed examination of vector mathematics that sits at the very heart of programming the movement of NPCs. Following this, systems of waypoints will be used to move characters around in an environment before examining the Unity waypoint system for car racing with AI controlled cars. This leads into an investigation of graph theory and the A* algorithm before we apply these principles to developing navmeshes and developing NPCs who can find their way around a game environment. Before an aquarium is programmed complete with autonomous schooling fish, crowds of people will be examined from the recreation of sidewalk traffic, to groups of people fleeing from danger. Having examined the differing ways to move NPCs around in a game environment, their thinking abilities will be discussed with full explanations and more hands-on workshops using finite state machines and behaviour trees.The follow-along workshops included in the course come with starter Unity asset files and projects complete with solutions. Throughout, there are also quizzes and challenge exercises to reinforce your learning and guide you to express your newfound knowledge.At the completion of this course you will have gained a broad understanding of what AI is in games, how it works and how you can use it in your own projects. It will equip you with a toolset to examine any of the techniques presented in more depth to take your game environments to the next level.What students are saying about this course:This has been my favourite Udemy-Unity course so far. It took me from literally 0% knowledge of how game AI is achieved, and took me to a whole new level. Waypoints, pathfinding, state machines, etc etc etc are all covered in-depth and will reveal the magic (spoiler alert: it isn't magic) behind making your computer characters seem like they really have a mind of their own.Oh My God. I love her way of teaching things. I haven’t finished this course yet. But all i can say is that it is another brilliant course from her. Artificial intelligence by itself is a tricky thing to do. And before starting this course i never thought that i will understand anything in it. But i was wrong. With her style of teaching, you will learn how to move your characters in an ”intelligent“ way. This course is perfectly sliced and the pace is wonderful.Who this course is for:Anyone interested in learning how to program their own non-player characters (NPCs).Anyone interested in seeing how artificial intelligence is applied in computer games.
Course Content:
Sections are minimized for better readability, click the section title to view the course content
6 Lectures | 19:49
Welcome to the Course
02:37
This lecture introduces the course by outlining all the content that will be covered with a section by section breakdown.
Introduction to Artificial Intelligence
03:42
In this unit students will gain an understanding of the field of artificial intelligence and how it pertains to game development.
Join the H3D Student Community
01:26
H3D has a bustling online student community. Here's how to get involved.
FAQs
00:14
Important Reading on Common Issues students have and how to ask for help.
Not So Scary Vector Mathematics
06:55
In this lecture we will get an overview of vectors and why they are an important concept to have an understanding of before you launch into programming the movement of an NPC.
Vector Mathematics Basics Cheat Sheet
04:54
Test your vector mathematics knowledge
10 questions
11 Lectures | 01:45:25
The Cartesian plane
12:49
In this lecture students will learn about the Cartesian coordinate system and how points are defined in the space as well as 2D and 3D nature of a game environment.
Vectors Part 1
09:18
In this video students will begin an exploration of vectors and discover their importance in measuring game environment space as well as defining direction of movement of game characters.
Vectors Part 2
10:34
In this lecture students will learn how to normalise the movement of a game character by calculating a velocity to gradually move it from one location to another.
Vectors Part 3
10:49
In this lecture students will learn how to determine the size of a vector to determine when a character has reached its goal as well as have AI characters follow a player character.
Calculating Distance Part 1
11:04
In this lecture students will learn to use Pythagorus' theorem to calculate the distance between points in a game environment and the length of a vector.
Calculating Distance Part 2
09:46
In this lecture students will learn how to use Unity methods to calculate distance.
Calculating the Dot Product
11:44
In this lecture students will learn about the derivation of the dot product formulae and how it is used to calculate the angle between vectors for the purposes of rotating a game character.
Calculating the Angle Between Vectors
04:42
In this lecture students will be challenged to calculate the angle between vectors to turn a game character to face another.
Calculating the Cross Project
11:10
In this video students will learn about the derivation of the cross product and discover why it is important to include in processes involving the rotation of characters.
A Simple Autopilot Project
12:59
In this video students will be challenged to built an autopilot system to drive a character towards a goal and include turning in increments.
A Simple AI Pet Challenge Project
00:30
11 Lectures | 01:50:27
Time
11:39
In this lecture students will examine the differing game loops that Unity runs and investigate how it affects the timing of character movements.
Normalising Movement with Time
06:09
In this lecture students will learn how to smooth update values to give consistent rates of movement in game characters.
Velocity
09:49
In this lecture students will learn how to work with velocity to control the speed of a rigid body.
Predicting Future Locations of Game Objects Part 1
10:09
In this lecture students will learn how to use velocity vectors to predict where a moving game object will be in the future.
Predicting Future Locations of Game Objects Part 2
11:50
In this lecture students will complete the code that works with a quadratic equation to predict the hit location between a projectile and enemy.
Acceleration Part 1
08:07
In this unit students will be introduced to acceleration as a means of calculating the shell's velocity and also introduced gravity into the equation.
Acceleration Part 2
11:24
In this lecture students will add the shell to fire from the red tank and also program it to move under speed and acceleration.
Acceleration Part 3
10:12
In this lecture students will complete their exploration of projectiles by examining drag and gravity.
Trajectories Part 1
11:56
In this unit students will learn about the parabola formed by projectile motion and use physics calculations to start programming an automatic attacking tank.
Trajectories Part 2
09:36
In this lecture students will learn how to calculate the trajectory of an arc made by a moving physics object to determine a hit location.
Trajectories Part 3
09:36
In this lecture students will learn how to use the trajectory calculations to have a Unity Physics system operated bullet hit its mark as well as create a simple AI character that will shoot at and follow an enemy.
6 Lectures | 01:11:11
The A* Pathfinding Algorithm Part 1
14:58
In this lecture students will learn about the concepts behind the A* algorithm and take an in-depth look at its inner workings.
The A* Pathfinding Algorithm Part 2
06:33
In this lecture students will write some preliminary code to get their project ready for the dedicated AStar method.
The A* Pathfinding Algorithm Part 3
15:55
In this unit students will begin writing the A* algorithm by creating a start and goal location as well as marking them inside a maze.
The A* Pathfinding Algorithm Part 4
11:20
In this lecture students will complete most of the code focused on running the A* algorithms logic.
The A* Pathfinding Algorithm Part 5
09:56
In this lecture students will complete all but the last part of the code focused on running the A* algorithms logic.
The A* Pathfinding Algorithm Part 6
12:29
In this lecture students will finalise their A* Pathfinding code to search from a starting location to an ending location and then determine the path points between them.
11 Lectures | 01:48:17
Waypoints
09:03
In this unit students will learn about waypoints, how to place them on a map to form a circuit and how to program a vehicle to automatically navigate between them.
Slerping to the Direction of Travel
07:36
In this lecture students will learn how rotational speed and waypoint accuracy affect an AIs ability to traverse waypoints.
Following a Circuit
06:04
In this lecture students will create copies of many tanks with different driving attributes and explore the issues that using waypoints may incur.
Following a Tracker
12:26
In this lecture students will create a tracker object that will make its way around a circuit while the tanks follow.
Using A* with Waypoints Part 1
07:48
In this lecture students will learn how to setup waypoints on a map that can later be used with the A* algorithm for finding a path around an environment.
A Simple Graph API Part 1
11:00
In this lecture we will start writing a new set of classes to store a graph, with it's nodes and edges.
A Simple Graph API Part 2
14:57
In this lecture students will learn how to introduce the A* algorithm into the graph class.
A Simple Graph API Part 3
06:34
In this lecture students will complete writing the Graph class with the A* Algorithm code and be ready to continue working on the waypoint system.
Using A* with Waypoints Part 2
09:32
In this lecture students will learn how to add the waypoints and edges to the graph and begin programming the AI code for their NPC.
Traversing a Path
11:19
In this lecture students will implement a waypoint path following code for the tank NPC.
Giving Commands to Pathfind
11:58
In this lecture students will complete programming the waypoint navigation system by adding command buttons to the environment.
14 Lectures | 02:32:17
Setting up Wheel Physics
10:58
In this lecture students will learn how to apply a wheel collider and rigid body to a tyre.
Forces on Wheels
11:02
In this lecture students will learn about wheel spring dampening and create a script to apply torque to the wheel.
Constructing a Simple Car
11:49
In this lecture students will learn how to construct a car physics object by combining wheel colliders with meshes.
Turning the Steering Wheel
05:39
In this lecture students will learn how to turn the wheel collider so the front wheels can be used to determine a direction of travel.
Creating A Circuit with Waypoints
06:20
In this lecture students will learn how to setup a waypoint system to define a circuit for the AI car to drive around.
Automatically Driving a Circuit Part 1
13:52
In this lecture students will learn how to get a simple car NPC up and driving around waypoints using a steering mechanic.
Braking
13:14
In this lecture students will learn how to apply braking to slow a car as it approaches waypoints.
Driving Forces
10:14
In this lecture students will learn about the forces placed on tires when driving and create code to flip the cars over when they flip onto their roof.
Improved Driving Tactics
10:15
In this lecture students will learn how improve on the acceleration and braking based on the turning direction.
Adding a Progress Tracker
10:18
In this lecture students will learn how to add a progress tracker that can be used to guide the car around the track.
Adding Antiroll Stabilising
10:51
In this lecture students will learn how to add an antiroll bar onto the car to stabilising it from tipping over.
Reconfiguring for Car Setting Testing
11:55
In this lecture students will learn how they can reconfigure the AIController code to organise all the variable settings for their cars.
Avoiding Other Drivers
12:47
In this lecture students will learn to create code to assist cars in avoiding other cars on the road.
Improving Avoidance and Reversing
13:03
In this lecture students will learn how to improve the avoiding behaviours and add reversing to their cars.
6 Lectures | 53:45
Navigation Mesh Introduction
05:07
In this lecture students will learn about the principles and theory behind navigation meshes and how to construct one in Unity.
From Waypoints to Navigation Meshes
09:11
In this lecture students will learn how to convert a waypoint system to use the Navigation Mesh API that comes with Unity to achieve the same thing.
NavMesh Agents Part 1
11:29
In this lecture students will practice setting up a navigation mesh from scratch and program a simple AI agent.
NavMesh Agents Part 2
08:37
In this lecture students will learn some code optimisation techniques as well as program in the animations to synchronise with agent movement.
NavMesh Agents Part 3
10:14
In this lecture students will learn how to restrict agents from going into certain areas on a navmesh.
Following a Player on a NavMesh
09:07
In this lecture students will learn how to program AI navmesh characters to follow a player character in addition to using off mesh links to traverse gaps in the navmesh.
7 Lectures | 01:31:02
Finite State Machines
10:48
In this lecture students will setup an environment ready for creating a finite state machine.
Creating a State Class
12:54
In this lecture students will start coding for the environment and design a state class.
Patrolling
14:42
In this lecture students will write up the state code for Idle and Patrolling.
Building the AI Class
11:30
In this lecture students will create the code to control the AI and provide an interface to the states.
Chasing the Player Part 1
16:02
In this lecture students will begin developing code so the NPC can determine if it senses the player and then act on it.
Chasing the Player Part 2
16:23
In this lecture students will complete the AI code that will cause the NPC to chase and shoot at the player as well as lose interest if the player goes out of range.
FSM Challenge
08:43
In this lecture students will be challenged to add a new state into the NPCs behaviour to make it run away when it is threatened.
9 Lectures | 01:27:13
Seek and Flee
10:46
In this lecture students will follow along to implement simple seek and flee methods for a Nav Mesh agent.
Pursuit
11:52
In this lecture students will learn the difference between seeking and pursuit and be able to add predictive code to their agent to make assumptions about where the target will be in the future.
Evade
02:57
In this unit students will be challenged to create their own evade method which will see the agent move away from the predicted location of the target.
Wander
11:19
In this unit students will examine one method of producing a wandering behaviour that will have the agent freely walk around the environment with smooth randomness.
Hide Part 1
14:45
In this video students will take a look at the basics behind the hide behaviour. In it we will create a simple hide method that will have the agent hide behind the closest obstacle in the environment.
Hide Part 2
10:51
In this unit students complete the development of the hiding behaviour and work to calculate a more accurate hiding location and reduce the number of calls to the method in the update.
Hide Part 3
06:26
In this lecture students will learn how to implement code to stop the robber from moving if it can't see the cop.
Complex Behaviours
09:33
In this video students will learn how to combine a number of steering behaviours with simple geometric conditions to produce complex behaviours in agents.
Behaviour Challenge
08:44
In this video students will be challenged to integrate the wander behaviour into the complex behaviour to have the agents go into a wander when the target cop is out of range.
11 Lectures | 01:28:07
Moving As One
08:53
In this lecture students will learn about the dynamics of crowd behaviour and watch some simple simulations.
Creating a City Crowd Part 1
09:34
In this lecture students will set up a navmesh with numerous animated humanoid agents and begin programming a crowded street scene.
Creating a City Crowd Part 2
10:54
In this lecture students will finalise their work on creating a crowded city scape where humanoid agents walk from one end of a sidewalk to another.
Fleeing Part 1
08:18
In this lecture students will setup a project to drop an obstacle into the scene that the agents in the crowd will flee from.
Fleeing Part 2
12:37
In this lecture students will complete the fleeing simulation by adding code to the agents controller to calculate a flee direction.
Flocking Part 1
11:13
In this lecture students will learn how the flocking algorithm works and begin setting up a project to create a schooling fish simulation.
Flocking Part 2
10:41
In this lecture students will write a basic flocking algorithm to create a school of fish.
Flocking Part 3
08:56
In this lecture students will learn how to add a goal position to the flocking simulation.
Flocking Part 4
06:29
In this lecture students will learn how to keep the flocking fish within the confines of a bounding box so they can't swim off into infinity.
Crowd Challenge Project
00:13
Flock Challenge Project
00:18
17 Lectures | 03:09:09
An Introduction to GOAP
05:17
In this lecture students will learn about the architecture of a GOAP system.
Setting up a GOAP Environment
09:01
This lecture introduces the starter file that will be used for this section. Each part of the game project will be examined with respect to the nav mesh setup, the agents and the simulation about to be created.
Preplanning the agent's actions
08:07
Before jumping into the coding of a GOAP system, in lecture unit the agents involved in the scenario will be examined and their planning process and actions discussed.
The World States
12:51
In this lecture students will start building the world states classes that hold, set and manipulate the states of the game environment required for GOAP planning.
Actions
11:55
In this lecture students will create the base class for actions. It will be used later on to create all the actions an agent requires by specifying their preconditions, effects, durations and locations.
Agents
08:10
In this lecture students will create the basic structure of a class that will drive the GOAP Agent.
The GOAP Planner Part 1
14:22
In this lecture students will start working on the basic structure of the GOAP Planner class. It will be the workhorse of the project matching actions in a plan with goals, preconditions and effects.
The GOAP Planner Part 2
12:37
In this lecture students will complete writing the basic GOAP Planning class by adding in its all important recursive graph building method.
Executing a Simple Plan
19:55
In this lecture students will write the code that controls the execution of a plan and that's the contents of the agent's LateUpdate method.
Creating a Multistep Plan
11:20
In this lecture students will begin creating multiple actions that need to be strung together to create a longer plan that will have the agent moving around the environment.
Spawning Patients
10:43
In this lecture students will create a spawner for patients and place it outside the hospital.
Plans that Require Multiple Agents
12:40
In this lecture students will work to create a plan for the nurse that is triggered by a change in world states.
Matching Agents with Agents
06:39
In this lecture students will learn how to assign another game object to the target destination for the nurse so she can move to her patient.
Adding More Resources to the World
17:40
In this lecture students will work on creating an action that is dependent on items in the agent's inventory. With this we'll program the patient to go to the cubicle.
Implementing the Inventory System
13:55
In this lecture students will work on creating an action that is dependent on items in the agent's inventory. With this we'll program the patient to go to the cubicle.
Moving the Nurse
07:27
This lecture presents just one way to solve the challenge posed at the end of the previous one and that is how to get the nurse to follow the patient to the cubicle.
Adding a Goal Challenge
06:30
In this lecture students will add an extra goal to the patient to make them go home after they are treated and fix a pesky little bug in the navigation mesh system.
9 Lectures | 01:45:38
Introducing Behaviour Trees
04:46
In this lecture students will learn about the structure of behaviour trees and the fundamental elements that are used to construct them.
Nodes
11:56
In this lecture students will write the first class for the behaviour tree system that will underwrite the majority of the functionality for the technique.
Tree Printing
11:59
In this lecture students will learn how to write code to traverse a behaviour tree and print out the structure.
Leaf and Action Nodes
15:20
In this lecture students will work begin writing the code for leaf nodes and get their NavMeshAgent character moving.
NavMesh Movement
08:24
In this lecture students will create a helpful method to assist in moving an agent around on the navmesh and reduce repetitive code.
Sequences
15:03
In this lecture students will learn how to construct the logic to implement a sequence node.
Selectors
12:34
In this lecture students will learn how to create a selector node and insert it into the behaviour tree.
Extended Action Methods
12:20
In this lecture students will learn how to integrate game engine specifics such as navmesh commands with the behaviour tree.
Conditions
13:16
In this lecture students will learn how to create a condition node to add extra logic and functionality to a sequence.
2 Lectures | 02:09
Some Final Words from Penny
02:04
In this video Penny provides some final words about the course.
Where to now?
00:05
This link provides further information on the courses you can look at taking based on your interests and skill level.
8 Lectures | 58:22
This is the previous version of the course.
00:11
Please read this.
Vectors and Moving in a Straight Line
11:50
In this lecture we will take a quick look at the nature of vectors and then discuss through a practical application how they can be used to move a character forward at a constant speed.
Traveling to a Goal Location
12:21
Follow along in the lecture as we setup a goal location for the character to move towards. You will also be shown how to change the facing direction of a character such that it looks in the direction it is travelling.
Pushing the Character Forward
12:40
In this lecture we will examine a different approach to moving the character. This time instead of setting a vector to travel along we will turn the character towards a goal and then push the character in a forward direction.
Slerping
05:19
Instead of snapping a character around to face a goal in a single update you may want more smooth turning behaviour to occur that makes the movement appear more natural. In this lecture we will examine the slerp method for achieving this.
About Animation and Translation
06:38
In this lecture we will take a quick look at the difference between animation translation and translating with code. Eitherway is acceptable and it will depend on what you are trying to achieve with the look of your character as to which one is more appropriate.
Waypoints
09:10
In this lecture we will look at the simplest form of AI navigation: waypoints. Using the code we've developed thus far by giving the NPC an array of goals we can change its behaviour from chasing to patrolling.
Challenge
00:13
4 Lectures | 49:40
Unity's Waypoint System
12:38
If you import the Utilities from Unity's included assets you'll find code for setting up waypoints and navigating a circuit. In this lecture we will look at how to integrate these Unity asset's with our own code.
Car Racing with Waypoints
13:25
In this lecture we will examine how to create a simple car NPC that can accelerate and brake while following a circuit tracker.
Customising Car Behaviours
07:59
Continuing where we left the previous lecture we will add in another car and set about making the properties of the movement behaviour customisable.
Unity's Vehicle System
15:38
Inside Unity's Standard Assets you will find the setup for a Waypoint following AI car with many customisable properties. In this lecture we will explore this feature as well as discuss how to add your own custom model into the system.
5 Lectures | 39:37
Graph Theory and Pathfinding
08:31
Graph Theory underpins so many AI techniques and it certainly deserves some focussed attention. In this lecture we will examine the structure of graphs and several path searching algorithms will be discussed.
Pathfinding through Waypoints
19:31
In this lecture we will apply the A* algorithm to finding a path through a system of waypoints converted into a graph.
Pathfinding through Waypoints Part 2
10:17
In part 2 of this hands-on workshop to put together a waypoint graph traversal system using the A * algorithm we will add UI buttons to send location commands to the NPC.
Challenge
00:13
Waypoints in 2D
01:05
This short article will explain how the code for dealing with 3D waypoints can be modified for 2D environments.
10 Lectures | 01:29:55
NavMesh Basics
05:11
In this lecture we will modify the pathfinding exercise created thus far and introduce the concept of a NavMesh. This will reduce the amount of code we need to write as well as the time taken to setup a waypoint system manually.
From Waypoints to NavMesh
09:07
In this lecture we will turn the previous waypoint system with the tank into a navmesh based project.
NavMesh Agents Part 1
17:42
In this lecture we will start taking a closer look at the navmesh agent component and explore the various settings for the baked nav mesh agent that controls how the navmesh is generated.
NavMesh Agents Part 2
10:32
Agents can be assigned different areas of the NavMesh through which to travel. In this lecture we will look at how to set up different areas with different costs and associate the agents with them.
Following a Player on A NavMesh and Setting-Up Off Mesh Links
14:10
The test of a NavMesh is to try it out with a real character in a real situation. It's then you'll find glitches in the default settings and automatically generated paths. Without having to remodel the environment, off-mesh links can be generated to provide smooth paths were their aren't any. In this lecture we will make a character follow a first person player character around a map while tweaking the NavMesh to handle different situations when gaps and drops appear in the NavMesh.
Fixing Mixamo Textures
00:09
This video link describes how to fix textures on imported FBX files from Mixamo.
Animating on a NavMesh
13:36
In this lecture we will examine how the NavMesh agent code and be coordinated with character animation to provide smooth and believable movement of a character when pathfinding over a NavMesh.
Syncing Animation Speed with NavMesh Agent Speed
06:35
In this short lecture I will demonstrate how to sync the animation speed with the nav mesh agent speed.
Multiple NavMeshes for Different Agent Sizes
12:41
In order to include multiple navmeshes to cater for multiple different navmeshagent sizes we need to turn to some beta code that isn't currently included in Unity but available for download and inclusion. In this lecture we will walk through the setups of creating multiple navmeshes after a quick refresher on setting up humanoid animations with strafe sets.
Challenge
00:12
8 Lectures | 01:31:43
Seek and Flee
11:08
In this video students will follow along to implement simple seek and flee methods for a Nav Mesh agent.
Pursuit
12:34
In this video students will learn about the differences in dynamics between the seek and pursuit behaviours and add an new method for moving an agent into the code.
Evade
03:19
In this video students will be challenged to create their own evade method which will see the agent move away from the predicted location of the target.
Wander
11:30
In this video students will examine one method of producing a wandering behaviour that will have the agent freely walk around the environment with smooth randomness.
Hide Part 1
15:21
In this video students will take a look at the basics behind the hide behaviour. In it we will create a simple hide method that will have the agent hide behind the closest obstacle in the environment.
Hide Part 2
18:39
In this video students complete the development of the hiding behaviour and work to calculate a more accurate hiding location and reduce the number of calls to the method in the update.
Complex Behaviours
10:24
In this video students will learn how to combine a number of steering behaviours with simple geometric conditions to produce complex behaviours in agents.
Behaviour Challenge
08:48
In this video students will be challenged to integrate the wander behaviour into the complex behaviour to have the agents go into a wander when the target cop is out of range.
10 Lectures | 01:39:56
Crowd Simulation
07:59
There are many factors to included in a crowd simulation... or are there? Seemingly very complex movement behaviour can be generated for groups of characters with some very simple rules. This lecture will show you how.
Creating a City Crowd Part 1
12:55
In this series of lectures we will set up a city scene with a crowd walking along the sidewalk.
Creating a City Crowd Part 2
11:20
This lecture continues on from the last adjusting animation behaviours and speeds to vary from agent to agent as well as introduces the concept of a dynamic obstacle that can move around a navmesh and be avoided by the agents.
Fleeing
18:29
A behaviour seen in NPC movement is fleeing. This is a technique for steering a character away from danger. In this lecture we will look at the mathematics involved in the movement and apply it to the crowd simulation.
Flocking Part 1
20:00
Flocking is capable of producing incredible behaviour from three simple vector calculations. In this lecture you will learn how to apply this to the development of schooling fish.
Flocking Part 2
15:45
In this second part of the flocking workshop we will add extra behaviours to the fish by controlling the boundary of their swimming range.
Flocking Part 3
12:58
The third part of the flocking workshop will explore ways in which the fish can avoid obstacles in their environment through raycasting and vector calculations.
Challenge 1
00:14
Challenge 2
00:07
Challenge 3
00:08
6 Lectures | 56:37
Line of Sight
14:10
In this lecture we will develop an NPC that can detect the presence of a player and act accordingly. We will implement step-by-step this algorithm which is one of the simplest AI techniques used.
Finite State Machines Part 1
10:52
Finite State Machines are a staple AI method used in games as they elegantly segregate the states, behaviours and logic used by NPCs. In part one we will begin looking at how the Unity animation system can be used to create such a machine.
Finite State Machines Part 2
14:49
In this second part of the FSM workshop we will add a base NPC class to enable sharing of properties between behaviour scripts and then add in the functionality to move from patrol to chase and back again.
Finite State Machines Part 3
09:36
In the final FSM lecture, steping you through the setup for a FSM, we will complete the example by adding in bullet shooting functionality and states onto the NPC tank.
Converting the FSM to Work on a Navmesh
07:05
In this short lecture I'll show you how to convert the waypoint system used to move the tank around to have the same FSM work on a navmesh.
Challenge
00:05
8 Lectures | 01:17:30
Introduction to Behaviour Trees
03:54
In this lecture Behaviour Trees will be introduced. Well take a look at their structure and the theory of their execution.
Sequence Nodes Part 1
17:17
This lecture begins by taking you through the setup for our behaviour tree project before starting with a very simple sequencial behaviour tree as a demo.
Sequence Nodes Part 2
16:06
We continue our examination of sequences in this lecture by creating a longer set of actions and modifying different behaviour tree specific returns discover what makes sequences run and fail. Towards the end we will start creating a new behaviour tree for attacking and take a look at the wait leaf node.
Embedding Logic in Behaviour Trees
11:00
In this lecture we will take a look at the while decorator node that allows you to invert the value of an action and also perform logic tests in the tree at a higher level than leaf nodes.
Selector Nodes
05:15
This lecture will introduce the selector node. This type of node can be used when any (but only one) of the children nodes need to run.
More Logic for Complex Behaviours
08:20
In this lecture we will complete the full set of single behaviour trees that will define all behaviours of the agent by adding the abilities to flee from danger and die.
Putting Together a Complex Behaviour Tree
15:26
To finish our investigation into Behaviour Trees all the smaller trees made throughout this section will be combined to inform the total behaviour of the agent droid. A final version of the project is attached as a download.
Challenge
00:12
5 Lectures | 51:27
Introduction to GOAP
05:22
Goal-Orientated Action Planning is an AI technique that turns Finite State Machines on their head. It decouples goals from actions and provides for a very dynamic NPC behavioural system.
Getting Started with GOAP in Unity
14:48
In this lecture we will get started with GOAP by setting up a simple scene and adding an agent.
Adding Actions to GOAP
11:15
In this lecture the GOAP agent will be given its first set of actions.
Adding Multiple Plans to GOAP
06:51
To create more complex behaviours in an agent you can add multiple plans that it can execute when the world states are right. In this lecture we will do this by extending the baker behaviour.
Global States and Multiple Agents
13:11
Even more complexity can be added when multiple inventories and agents are introduced to the system. This lecture will take you through the addition of a world inventory as well as a new agent type.
1 Lectures | 11:16
Where To Now?
11:16
This link provides further information on the courses you can look at taking based on your interests and skill level.
4.74
(2233 course ratings)
1
22/2233
2
19/2233
3
132/2233
4
617/2233
5
1442/2233
JOIN OUR WHATSAPP GROUP TO GET LATEST COUPON AS SOON AS UPDATED
If you like to get inspired by great web projects, you should check out Made with Javascript. If you have a project that you wish to share with the world, feel free to submit your project on Made with Javascript Club website.
Free Online Tools And Converters for your use
URL Encoder
Input a string of text or a URL and encode the entered string
FAQ: Udemy Free course Most frequent questions and answers
Does Udemy offer Free Udemy coupons?
Yes, Udemy is the largest online education platform, with the broadest selection of video-on-demand courses and qualified instructors available to meet your needs. At theprogrammingbuddy.club we curate the latest udemy coupons, their expiry, and the number of uses left of these udemy coupons.
How to get free Udemy courses?
There are two ways to get free Udemy courses:
Go to udemy.com and search for your desired course category. Then select free from the filter options.
You can also get paid courses for free if you have a coupon. You can head to theprogrammingbuddy.club, where you can get a daily udemy paid course for free.
How to get Udemy Certificates for free?
Udemy offers certification on completion of each course. In order to receive a certificate of completion from Udemy, you need to complete your course 100%. There is a simple hack, you can open a video and jump on the timeline to complete a lecture.
To download the certificate from Udemy, you need to head over to your account on a desktop browser. Udemy certificates can't be accessed on the mobile app.
Do Udemy courses expire?
No, once you enroll, you will have lifetime access to the course. You can complete the course on your schedule.
Why are the Udemy instructors giving away free Udemy Coupons?
Every instructor has worked for hours on each of their courses. As new courses get launched, the instructors have no way to get their course in front of an audience to get some feedback. So, instructors share free coupons for their courses to get feedback from the students. We attheprogrammingbuddy.club work with these instructors to get their courses available to our buddies.
Is Udemy safe to use?
Yes, payments on Udemy are safe. It is no different than paying for other services on an application or website and inputting your payment information before receiving your goods. Just be sure to keep your account secure, do not share your udemy accounts.
Can Udemy courses get you a job?
Earning a skill is more valuable than earning a job these days. Skills are your most valuable asset. They can help you qualify for jobs you want and get promoted to more advanced positions within your organization. Unfortunately, it is difficult for many people to balance taking courses with work and family obligations. We have had many students, who have taken just Udemy courses, started a job as well as started freelancing with the skills they have learned.