Introducing the  A* algorithm

Starting Work on a Pathfinding Algorithm

Selecting Random Starting and Ending Points in a Maze

Placing Markers for Visualising A*

Beginning to Search

Watching the A* in Action

Debugging and Tweaking A*

In this tutorial you will learn about the fundamental concepts used in the creation of Behaviour Trees.  You will also take this knowledge and apply it in Unity by building a simple simulation scenario where a behaviour tree is used to define action sequences of a thief stealing a diamond from a gallery.

The A* Algorithm

Welcome to the Course

2021.3

Introduction to Artificial Intelligence

Not So Scary Vector Mathematics

Cartesian Coordinates

2019.4

2019.3

2019.2

2019.1

Vectors

Calculating Distance

Dot Product

Cross Product

Virtual Pet Challenges

Time

Velocity

Introducing Acceleration

Calculating Trajectories

2020.2

2021.1

2020.3

2020.1

2018.4

2018.3

2018.2

2018.1

2017.4

2017.3

2017.2

2017.1

Waypoints

Following a Circuit&Tracker

Using A* with Waypoints Part 1

A Simple Graph API

Using A* with Waypoints Part 2

Commanding a Path

NavMesh Introduction

From Waypoints to Navigation Meshes

Setting up NavMeshes

Drop Height and Jump Distance

Defining Agent Types

Areas and Costs

Following a Player on a NavMesh

Introduction to Finite State Machines

Creating a State Class

Patrolling the Perimeter

Chasing the Player

Finite State Machine Challenge

Steering Behaviors

Steering: Seek and Flee

Steering: Pursuit

Steering: Evade

Wandering

Hiding from the Player

Adding Complex Behaviour

Steering Behaviour Challenge

Moving As One

Creating a City Crowd

Fleeing

Flocking

An Introduction to GOAP

Setting up a GOAP Environment

Preplanning the Agent Actions

The World States

Actions

Agents

The GOAP Planner

Executing a Simple Plan

Creating a Multi-step Plan

Adding Agents

Adding More Resources to the World

Implementing the Inventory System

Moving the Nurse

Adding Goal Challenge

Taking a Break

Introducing Behaviour Trees

Nodes

Tree Printing

Leaf and Action Nodes

NavMesh Movement

Sequences

Selectors

Extended Action Methods

Conditions

In the tutorial you will be introduced to the course content as well as given an overview of the field of AI and how AI in games fits into the domain.

Introduction

Examine how the cross product is derived and why it is essential for character rotation processes.

In this project, you will learn about the fundamental mathematics used in moving characters around in a game environment. You will follow along as geometry and trigonometry is used to develop methods that move and turn game characters.  With these techniques you'll put together an auto-navigating character that represents the basis of the simple artificial intelligence used in developing non-player characters.  In doing this you will discover the mathematics behind some of Unity's most used Vector and Angle manipulating methods. 

The Mathematics of AI

In this project, you will be introduced to some of the fundamental principles in the field of physics and how they are used to move objects around in the game environment. The relationships between time, velocity and acceleration will be investigated and then applied in the creation of an automated shooting tank that calculates the angle of it's turret based on parabolic mathematics and the position of an enemy.

The Physics of AI

In this project you will learn about the major role that the mathematical construct of graphs plays in developing many artificial intelligence techniques in games.  You will discover how graphs are visualised in a set of waypoints used for non-player character navigation.  In addition we will cover the algorithms used for searching through graphs and develop classes for the A* algorithm, one of the most prolific search methods used with graphs in games.

Waypoints & Graphs

In this tutorial students will learn how to set off mesh links that can connect different heights and gaps in the navmesh for agents to drop across.

In this project you will be introduced to navigation meshes and learn to use them in a game environment to move characters between goals.  You will develop AI algorithms that command characters to find the path between their current location and destination using the navigation mesh as the waypoint system.  The waypoint mecanics in the previous section will be reworked to use a navigation mesh rather than predefined straight lines between points.  This will make for more dynamic and intelligent appearing non-player characters.

Navigation Meshes

In this project you will learn about the design patter of "states" and use them to construct an AI behavioural algorithm called a Finite State Machine.  This tutorial will combine you knowledge of NavMeshes and Graphs.

Finite State Machines

Explore the differences between seek and pursuit behaviors and add a new movement method for an agent in code.

In this tutorial you design a custom evade behavior so an agent moves away from a target’s predicted position.

Discover one approach to create smooth, random wandering behavior for an agent moving through an environment.

Learn to script a hide behavior so an agent finds better hiding spots behind obstacles while reducing Update method calls.

Learn to combine multiple steering behaviors with simple geometric rules to create complex agent movement.

Challenge yourself to integrate wander behavior into complex AI so agents roam when their target is out of range.

In this project you will be working with NavMesh agents to recreate some very popular steering behaviours to create non-player characters that move around independently in a game environment and make choices about their movements based on the location and orientation of the player character.

Autonomously Moving Agents

Discover key principles of crowd behavior and observe simple simulations that illustrate how group dynamics emerge.

Build a crowded city scene by configuring a NavMesh and scripting animated humanoid agents along sidewalks.

Add a hazardous obstacle to a crowd simulation and script agents to flee for a set duration.

Apply flocking rules to program a school of fish, confine them to a tank, and add obstacles to the simulation.

In this project you will be working with a high number of agents to simulate crowd behaviour.  You will discover how patterns of movement can be formed from the simpliest of rules that mimic crowd behaviour in the real world.  By the end you will have created a crowded city street scene with humanoid characters walking along a pavement and avoiding each other as well as a simulation of a school of fish.

Crowd Simulation

Learn how Goal-Oriented Action Planning (GOAP) creates flexible AI by separating actions from goals.

Get introduced to the section’s starter file while you inspect the NavMesh configuration, agents, and upcoming simulation.

Analyze the scenario’s GOAP agents, their planning process, and available actions before implementing the system in code.

Begin implementing world state classes that store and update game environment data used for GOAP planning.

Build a base action class that defines preconditions, effects, durations, and locations for agent behaviors.

Build the core structure of a C# class that controls the behavior of a GOAP Agent.

Build the core GOAP Planner class to match actions with goals, preconditions, and effects using a recursive planning method.

Implement the agent’s LateUpdate method to control how a plan runs each frame.

Begin building multi-step action sequences that move an agent through its environment as part of a larger plan.

Practice building queues that store GameObjects as reusable resources for planning in your project.

Start managing multiple world resources by creating an inventory system that tracks agent ownership.

Build an agent action that checks inventory items to send the patient GameObject to the correct cubicle.

Learn one implementation for making the nurse character follow the patient to the cubicle based on the previous tutorial’s challenge.

Add a post-treatment goal that sends patients home and fix a navigation mesh bug in your Scene.

Finalize your GOAP simulation by creating a time-based trigger for a nurse agent and populating the scene with multiple nurses.

In this project you will learn about the Goal-Orientated Action Planning (GOAP) architecture used to create intelligent agents that can set goals and plan at achieving them.  Unlike Finite State Machines, actions and states are uncoupled, making for a very flexible system.  You will build a GOAP system from the ground up and implement it in a simple hospital simulation.

Goal Driven Behaviour

Study the structure of behavior trees and the key elements used to build them.

Write the initial class for a behavior tree system that will support most of the technique’s functionality.

Learn to write C# code that traverses a behaviour tree and prints its structure for inspection.

In this unit, you begin coding leaf nodes to drive behavior and move a NavMesh Agent character.

Create a reusable method to move an agent on a NavMesh and reduce repetitive navigation code.

Learn how to build the logic required to implement a sequence node in your project.

Learn step by step how to build a selector node and add it to your behavior tree.

Learn to connect NavMesh-driven navigation commands with a behavior tree to control in-game agents.

Learn to build a condition node that adds branching logic and extra functionality to a sequence.

In this project you will learn about the fundamental concepts used in the creation of Behaviour Trees. You will also take this knowledge and apply it in Unity by building a simple simulation scenario where a behaviour tree is used to define action sequences of a thief stealing a diamond from a gallery.

Behaviour Trees

Artificial Intelligence for Beginners 2021.3 Common Cartridge File

Below you can download a CSV outline and a Common Cartridge file for this course.


Open the CSV outline in spreadsheet software (Excel, Google Sheets) for a summary of all content in the course, with links to each tutorial, exercise, and quiz.


Use the Common Cartridge file to import the course content into your Learning Management System (such as Canvas, Moodle, Blackboard, etc.). See instructions from your LMS provider for importing Common Cartridge files.

In this course, Dr Penny de Byl reveals the most popular AI techniques used for creating believable game characters using her internationally acclaimed teaching style and knowledge from over 25 years researching and working with games, computer graphics and artificial intelligence. 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, hide, flee, patrol, shoot, race, crowd, plan and much more.

Artificial Intelligence for Beginners

c409670b-02da-5b09-a475-8c45534d56e8:6udFvAlfFjsjj7eis1ce8t

The A* Pathfinding Algorithm Part 6

In this unit students will finalise their A* code project and find the final path between the start and the end markers.

Watching the A* in Action

1. The A* Pathfinding Algorithm Part 6

Complete this Tutorial