Fr

Second Edition
Unity 5 provides game and app developers with a variety
of tools to implement artificial intelligence. Leveraging
these tools via Unity's API or built-in features allows
limitless possibilities when it comes to creating your
game's worlds and characters.

What you will learn from this book

Understand the basic terminology and
concepts in game AI
Implement a basic finite state machine using
state machine behaviors in Unity 5

Who this book is written for

Create a basic behavior tree to drive a

character's actions
Make your characters more engaging
by implementing fuzzy logic concepts
in your AI's decision-making
Tie all the concepts together with examples
and guides
$ 49.99 US
31.99 UK

"Community
Experience
Distilled"

Prices do not include

local sales tax or VAT
where applicable

Visit www.PacktPub.com for books, eBooks,

code, downloads, and PacktLib.

Aung Sithu Kyaw

Thet Naing Swe

This book is intended for Unity developers with a basic

understanding of C# and the Unity editor. Whether you're
looking to build your first game or are looking to expand
your knowledge as a game programmer, you will find
plenty of exciting information and examples of game AI
in terms of concepts and implementation.

Implement an industry-standard pathfinding

system and a navigation mesh with the
Unity 5 NavMesh feature

Ray Barrera
Clifford Peters

Build believable and highly-efficient artificial

flocks and crowds

Create sensory systems for your AI with the

most commonly used techniques

Second Edition

This book helps you break down artificial intelligence

into simple concepts to give you a fundamental
understanding of the topic to build upon. Using a variety
of examples, the book then takes those concepts and
walks you through actual implementations designed to
highlight key concepts and features related to game AI
in Unity 5. Along the way, several tips and tricks are
included to make the development of your own AI easier
and more efficient.

Unity AI Game Programming

Unity AI Game
Programming

ee

Sa
m

pl

C o m m u n i t y

E x p e r i e n c e

D i s t i l l e d

Unity AI Game
Programming
Second Edition
Leverage the power of Unity 5 to create stunningly life-like
AI entities in your games!
Ray Barrera
Clifford Peters

Aung Sithu Kyaw

Thet Naing Swe

In this package, you will find:

The author biography

A preview chapter from the book, Chapter 1 'The Basics of AI in Games'
A synopsis of the books content
More information on Unity AI Game Programming Second Edition

About the Authors

Ray Barrera was a tinker in his childhood. From making mods and custom

maps in games such as StarCraft and Unreal Tournament to developing open

source role-playing games using RPG Maker, he always had a passion for game
development. The passion stayed with him, and after many years as a hobbyist,
he decided to take the plunge into professional development.
In the initial stages of his career, he was fortunate enough to work on educational and
research projects for major contractors in the defense industry, allowing him to blend
his love for games with his innate desire to teach and create interactive experiences.
Since then, he has straddled the line between entertainment and education. Unity
was the logical weapon of choice for him as it gave him the flexibility to create games
and applications and iterate quickly. From being an original member of the Los
Angeles Unity meetup to helping coordinate Unity workshops at local colleges and
high schools, he has been very active in the Unity community. You can follow him on
Twitter at @ray_barrera.

Aung Sithu Kyaw has been in the technical industry for over a decade. He is

passionate about graphics programming, creating video games, writing, and sharing
knowledge with others. He holds an MSc in digital media technology from the
Nanyang Technological University (NTU), Singapore. Over the last few years, he
has worked in various positions, including research programmer and senior game
programmer. Lastly, he worked as a research associate, which involved implementing
a sensor-based real-time movie system using Unreal Development Kit. In 2011, he
founded a tech start-up, which focuses on interactive media productions and backend
server-side technologies. He is currently based in Myanmar and working on his latest
company's product, a gamified social opinion network for Myanmar.
He can be followed on Twitter at @aungsithu and LinkedIn at http://linkedin.

com/in/aungsithu.

Clifford Peters is a programmer and a computer scientist. He was the

technical reviewer for Unity Game Development Essentials, Unity 3D Game

Development by Example Beginner's Guide, Unity 3 Game Development HOTSHOT,
Unity 3.x Game Development by Example Beginner's Guide, Unity iOS Game
Development Beginner's Guide, and Unity iOS Essentials, all by Packt Publishing.

Thet Naing Swe is the founder and CTO of Joy Dash Pte Ltd, based in Singapore.
He graduated from the University of Central Lancashire with a major in game
design and development and started his career as a game programmer at one of
the UK-based Nintendo DS game development studios. In 2010, he relocated to
Singapore and worked as a graphics programmer at the Nanyang Technological
University (NTU) on a cinematic research project.
At Joy Dash, he's responsible for interactive digital media consulting projects,
especially in education, casual games, and augmented reality projects using
Unity 3D as the main development tool. He can be reached via thetnswe@gmail.com.

Preface
In this book, we'll be exploring the world of artificial intelligence (AI) as it relates
to game development. No matter what kind of game you are developing, you will
surely find a myriad of uses for the content in this bookperhaps in ways that even
I could not imagine.
The goal of this book is not to make you an expert, as it would take many, many,
years and many more pages to do this, but to provide you with the knowledge and
tools to embark on your own AI journey. This book covers the essentials, and by the
end, you will have all that you need to implement AI in your own game, whether
you choose to expand upon the examples provided or take the knowledge and do
something new and exciting with it.
You will get the most out of this book and the examples provided by following along
and tinkering with the code and project files provided. Each chapter will provide a
conceptual background and some examples and will challenge readers to think of
ways in which they can use these concepts in their games.

What this book covers

Chapter 1, The Basics of AI in Games, aims to demystify some of the most basic
concepts of AI as it is a very vast and intimidating topic.
Chapter 2, Finite State Machines and You, covers one of the most widely used concepts
in AIthe finite state machine.
Chapter 3, Implementing Sensors, covers some of the most important ways for a game
AI agent to perceive the world around it. The realism of an AI agent is directly linked
to how it responds to its environment.

Preface

Chapter 4, Finding Your Way, covers the most widely used pattern in pathfinding for
game AI agents. The agents in games need to traverse the areas of the game levels
and maneuver around obstacles along the way.
Chapter 5, Flocks and Crowds, covers flocking and crowd simulation algorithms,
allowing you to handle the unison movements of the agents in your game rather
than having to figure out the logic for each agent.
Chapter 6, Behavior Trees, covers the process of implementing a custom behavior
tree as it is one of the most common ways to implement complex and compound
AI behaviors in games.
Chapter 7, Using Fuzzy Logic to Make Your AI Seem Alive, shows you how to
let the game AI agents make decisions based on various factors in a non-binary
way. Fuzzy logic mimics the way humans make decisions.
Chapter 8, How It All Comes Together, covers an example of how various systems come
together in a single-objective game template that can be easily expanded upon.

The Basics of AI in Games

Artificial Intelligence (AI), in general, is a vast, deep, and intimidating topic. The
uses for it are diverse, ranging from robotics, to statistics, to (more relevantly to us)
entertainment, and more specifically, video games. Our goal will be to demystify the
subject by breaking down the use of AI into relatable, applicable solutions, and to
provide accessible examples that illustrate the concepts in the ways that cut through
the noise and go straight for the core ideas.
This chapter will give you a little background on AI in academics, traditional
domains, and game-specific applications. Here are the topics we'll cover:

Exploring how the application and implementation of AI in games is

different from other domains

Looking at the special requirements for AI in games

Looking at the basic AI patterns used in games

This chapter will serve as a reference for later chapters, where we'll implement the
AI patterns in Unity.

Creating the illusion of life

Living organisms such as animals and humans have some sort of intelligence that
helps us in making a particular decision to perform something. Our brains respond
to stimuli, albeit through sound, touch, smell, or vision, and then convert that
data into information that we can process. On the other hand, computers are just
electronic devices that can accept binary data, perform logical and mathematical
operations at high speed, and output the results. So, AI is essentially the subject of
making computers appear to be able to think and decide like living organisms to
perform specific operations.

[1]

The Basics of AI in Games

AI and its many related studies are dense and vast, but it is really important to
understand the basics of AI being used in different domains before digging deeper
into the subject. AI is just a general term; its implementations and applications are
different for different purposes, solving different sets of problems.
Before we move on to game-specific techniques, we'll take a look at the following
research areas in AI applications that have advanced tremendously over the last
decade. Things that used to be considered science fiction are quickly becoming
science fact, such as autonomous robots. You need not look very far to find a great
example of AI advancesyour smart phone most likely has a digital assistant feature
that relies on some new AI-related technology. Here are some of the research fields
driving AI:

Computer vision: It is the ability to take visual input from sources such as
videos and cameras and analyze them to do particular operations such as
facial recognition, object recognition, and optical-character recognition.

Natural language processing (NLP): It is the ability that allows a machine

to read and understand the languages as we normally write and speak. The
problem is that the languages we use today are difficult for machines to
understand. There are many different ways to say the same thing, and the
same sentence can have different meanings according to the context. NLP is an
important step for machines since they need to understand the languages and
expressions we use, before they can process them and respond accordingly.
Fortunately, there's an enormous amount of data sets available on the Web that
can help researchers to do the automatic analysis of a language.

Common sense reasoning: This is a technique that our brains can easily
use to draw answers even from the domains we don't fully understand.
Common sense knowledge is a usual and common way for us to attempt
certain questions since our brains can mix and interplay between the context,
background knowledge, and language proficiency. But making machines
to apply such knowledge is very complex and still a major challenge
for researchers.

Machine learning: This may sound like something straight out of a science
fiction movie, and the reality is not too far off. Computer programs generally
consist of a static set of instructions, which take input and provide output.
Machine learning focuses on the science of writing algorithms and programs
that can learn from the data processed by said program.

[2]

Chapter 1

Leveling up your game with AI

AI in games dates back all the way to the earliest games, even as far back as Namco's
arcade hit Pac-Man. The AI was rudimentary at best, but even in Pac-Man, each of
the enemies, Blinky, Pinky, Inky, and Clyde had unique behaviors that challenged
the player in different ways. Learning those behaviors and reacting to them added a
huge amount of depth to the game that keeps players coming back, even after over
30 years since its release.
It's the job of a good game designer to make the game challenging enough to
be engaging, but not so difficult that a player can never win. To this end, AI is a
fantastic tool that can help abstract the patterns that entities in games follow to make
them seem more organic, alive, and real. Much like an animator through each frame
or an artist through his brush, a designer or programmer can breathe life into their
creations by a clever use of the AI techniques covered in this book.
The role of AI in games is to make it fun by providing challenging entities to
compete with and interesting non-player characters (NPCs) that behave realistically
inside the game world. The objective here is not to replicate the whole thought
process of humans or animals, but merely to sell the illusion of life and make NPCs
seem intelligent by reacting to the changing situations inside the game world in a
way that makes sense to the player.
Technology allows us to design and create intricate patterns and behaviors, but
we're not yet at the point where AI in games even begins to resemble true human
behavior. While smaller, more powerful chips, buckets of memory, and even
distributed computing have given programmers a much higher computational
ceiling to dedicate to AI, at the end of the day, resources are still shared between
other operations such as graphic rendering, physics simulation, audio processing,
animation, and others, all in real time. All these systems have to play nice with
each other to achieve a steady frame rate throughout the game. Like all the other
disciplines in game development, optimizing AI calculations remains a huge
challenge for the AI developers.

[3]

The Basics of AI in Games

Using AI in Unity
In this section, we'll walk through some of the AI techniques being used in different
types of games. We'll learn how to implement each of these features in Unity in the
upcoming chapters. Unity is a flexible engine that affords us a number of avenues to
implement AI patterns. Some are ready to go out of the box, so to speak, while we'll
have to build others from scratch. In this book, we'll focus on implementing the most
essential AI patterns within Unity so that you can get your game's AI entities up and
running quickly. Learning and implementing these techniques with this book will
serve as a fundamental first step into the vast world of AI.

Defining the agent

Before jumping into our first technique, we should be clear on a key term you'll see
used throughout the bookthe agent. An agent, as it relates to AI, is our artificially
intelligent entity. When we talk about our AI, we're not specifically referring to
a character, but an entity that displays complex behavior patterns, which we can
refer to as non-random or in other words, intelligent. This entity can be a character,
creature, vehicle, or anything else. The agent is the autonomous entity, executing the
patterns and behaviors we'll be covering. With that out of the way, let's jump in.

Finite State Machines

Finite State Machines (FSM) can be considered as one of the simplest AI models,
and they are commonly used in games. A state machine basically consists of a set
number of states that are connected in a graph by the transitions between them. A
game entity starts with an initial state and then looks out for the events and rules
that will trigger a transition to another state. A game entity can only be in exactly
one state at any given time.

[4]

Chapter 1

For example, let's take a look at an AI guard character in a typical shooting game. Its
states could be as simple as patrolling, chasing, and shooting:

There are basically four components in a simple FSM:

States: This component defines a set of distinct states that a game entity or an
NPC can choose from (patrol, chase, and shoot)

Transitions: This component defines relations between different states

Rules: This component is used to trigger a state transition (player on sight,

close enough to attack, and lost/killed player)

Events: This is the component that will trigger to check the rules (guard's
visible area, distance with the player, and so on)

FSMs are a commonly used go-to AI pattern in game development because they
are relatively easy to implement, visualize, and understand. Using simple if/else
statements or switch statements, we can easily implement an FSM. It can get messy
as we start to have more states and more transitions. We'll look at how to manage a
simple FSM more in depth in Chapter 2, Finite State Machines and You.

[5]

The Basics of AI in Games

Seeing the world through our agent's

eyes
In order to make our AI convincing, our agent needs to be able to respond to events
around him, the environment, the player, and even other agents. Much like real-living
organisms, our agent can rely on sight, sound, and other "physical" stimuli. However,
we have the advantage of being able to access much more data within our game than a
real organism can from their surroundings, such as the player's location, regardless of
whether or not they are in the vicinity, their inventory, the location of items around the
world, and any variable you chose to expose to that agent in your code.
In the following image, our agent's field of vision is represented by the cone in front
of it, and its hearing range is represented by the grey circle surrounding it:

[6]

Chapter 1

Vision, sound, and other senses can be thought of, at their most essential level, as
data. Vision is just light particles, sound is just vibrations, and so on. While we don't
need to replicate the complexity of a constant stream of light particles bouncing
around and entering our agent's eyes, we can still model the data in a way that
produces similar results.
As you might imagine, we can similarly model other sensory systems, and not just
the ones used for biological beings such as sight, sound, or smell, but even digital
and mechanical systems that can be used by enemy robots or towers, for example,
sonar and radar.

Path following and steering

Sometimes, we want our AI characters to roam around in the game world, following
a roughly-guided or thoroughly-defined path. For example, in a racing game, the AI
opponents need to navigate on the road. In an RTS game, your units need to be able
to get from wherever they are to the location you tell them to, navigating through the
terrain, and around each other.
To appear intelligent, our agents need to be able to determine where they are going,
and if they can reach that point, they should be able to route the most efficient path
and modify that path if an obstacle appears as they navigate. As you'll learn in
later chapters, even path following and steering can be represented via a finite state
machine. You will then see how these systems begin to tie in.
In this book, we will cover the primary methods of pathfinding and navigation,
starting with our own implementation of an A* Pathfinding system, followed by
an overview of Unity's built-in navigation mesh (NavMesh) feature.

[7]

The Basics of AI in Games

Using A* Pathfinding
There are many games where you can find monsters or enemies that follow the
player, or go to a particular point while avoiding obstacles. For example, let's take
a look at a typical RTS game. You can select a group of units and click on a location
where you want them to move or click on the enemy units to attack them. Your units
then need to find a way to reach the goal without colliding with the obstacles. The
enemy units also need to be able to do the same. Obstacles could be different for
different units. For example, an air force unit might be able to pass over a mountain,
while the ground or artillery units need to find a way around it. A* (pronounced "A
star") is a pathfinding algorithm, widely used in games because of its performance
and accuracy. Let's take a look at an example to see how it works. Let's say we want
our unit to move from point A to point B, but there's a wall in the way, and it can't go
straight towards the target. So, it needs to find a way to get to point B while avoiding
the wall. The following figure illustrates this scenario:

[8]

Chapter 1

In order to find the path from point A to point B, we need to know more about the
map such as the position of the obstacles. For this, we can split our whole map into
small tiles, representing the whole map in a grid format. The tiles can also be of other
shapes such as hexagons and triangles. Representing the whole map in a grid makes
the search area more simplified, and this is an important step in pathfinding. We can
now reference our map in a small 2D array.

Once our map is represented by a set of tiles, we can start searching for the best
path to reach the target by calculating the movement score of each tile adjacent to
the starting tile, which is a tile on the map not occupied by an obstacle, and then
choosing the tile with the lowest cost. We'll dive into the specifics of how we assign
scores and traverse the grid in Chapter 4, Finding Your Way, but this is the concept of
A* Pathfinding in a nutshell.

A* Pathfinding calculates the cost to move across the tiles

[9]

The Basics of AI in Games

A* is an important pattern to know when it comes to pathfinding, but Unity also

gives us a couple of features right out of the box such as automatic navigation mesh
generation and the NavMesh agent, which we'll explore in the next section and then
in more detail in Chapter 4, Finding Your Way. These features make implementing
pathfinding in your games a walk in the park (no pun intended). Whether you
choose to implement your own A* solution or simply go with Unity's built in
NavMesh feature, will depend on your project requirements. Each have their own
pros and cons, but ultimately, knowing both will allow you to make the best possible
choice. With that said, let's have a quick look at NavMesh.

Using navigation mesh

Now that we've taken a brief look at A*, let's look at some possible scenarios
where we might find NavMesh a fitting approach to calculate the grid. One thing
that you might notice is that using a simple grid in A* requires quite a number of
computations to get a path that is the shortest to the target and at the same time,
avoids the obstacles. So, to make it cheaper and easier for AI characters to find
a path, people came up with the idea of using waypoints as a guide to move AI
characters from the start point to the target point. Let's say we want to move our AI
character from point A to point B and we've set up three waypoints, as shown in the
following figure:

[ 10 ]

Chapter 1

All we have to do now is to pick up the nearest waypoint and then follow its
connected node leading to the target waypoint. Most of the games use waypoints for
pathfinding because they are simple and quite effective in using less computation
resources. However, they do have some issues. What if we want to update the
obstacles in our map? We'll also have to place waypoints for the updated map again,
as shown in the following figure:

Following each node to the target can mean that the AI character moves in a series of
straight lines from node to node. Look at the preceding figures; it's quite likely that
the AI character will collide with the wall where the path is close to the wall. If that
happens, our AI will keep trying to go through the wall to reach the next target, but
it won't be able to and will get stuck there. Even though we can smooth out the path
by transforming it to a spline and do some adjustments to avoid such obstacles, the
problem is that the waypoints don't give any information about the environment,
other than the spline is connected between the two nodes. What if our smoothed and
adjusted path passes the edge of a cliff or bridge? The new path might not be a safe
path anymore. So, for our AI entities to be able to effectively traverse the whole level,
we're going to need a tremendous number of waypoints, which will be really hard to
implement and manage.

[ 11 ]

The Basics of AI in Games

This is a situation where a NavMesh makes the most sense. NavMesh is another graph
structure that can be used to represent our world, similar to the way we did with our
square tile-based grid or waypoints graph, as shown in the following screenshot:

A navigation mesh uses convex polygons to represent the areas in the map that an
AI entity can travel to. The most important benefit of using a navigation mesh is
that it gives a lot more information about the environment than a waypoint system.
Now we can adjust our path safely because we know the safe region in which our
AI entities can travel. Another advantage of using a navigation mesh is that we can
use the same mesh for different types of AI entities. Different AI entities can have
different properties such as size, speed, and movement abilities. A set of waypoints
is tailored for humans; AI may not work nicely for flying creatures or AI-controlled
vehicles. These might need different sets of waypoints. Using a navigation mesh can
save a lot of time in such cases.
But generating a navigation mesh programmatically based on a scene can be
a somewhat complicated process. Fortunately, Unity 3.5 introduced a built-in
navigation mesh generator as a Pro-only feature, but is now included for free in
Unity 5 personal edition. Chapter 4, Finding Your Way, will look at some of the cool
ways we can use Unity's NavMesh feature in your games and explore the additions
and improvements that came with Unity 5.

[ 12 ]

Chapter 1

Flocking and crowd dynamics

Many living beings such as birds, fish, insects, and land animals perform certain
operations such as moving, hunting, and foraging in groups. They stay and hunt
in groups, because it makes them stronger and safer from predators than pursuing
goals individually. So, let's say you want a group of birds flocking, swarming around
in the sky; it'll cost too much time and effort for animators to design the movement
and animations of each bird. But if we apply some simple rules for each bird to
follow, we can achieve emergent intelligence of the whole group with complex,
global behavior.
Similarly, crowds of humans, be it on foot or vehicles, can be modeled by
representing the entire crowd as an entity rather than trying to model each
individual as its own agent. Each individual in the group only really needs to
know where the group is heading and what their nearest neighbor is up to in
order to function as part of the system.

Behavior trees
The behavior tree is another pattern used to represent and control the logic behind
AI agents. They have become popular for the applications in AAA games such as
Halo and Spore. Previously, we have briefly covered FSMs. They provide a very
simple, yet efficient way to define the possible behaviors of an agent, based on
the different states and transitions between them. However, FSMs are considered
difficult to scale as they can get unwieldy fairly quickly and require a fair amount of
manual setup. We need to add many states and hard-wire many transitions in order
to support all the scenarios, which we want our agent to consider. So, we need a
more scalable approach when dealing with large problems. This is where behavior
trees come in.
Behavior trees are a collection of nodes, organized in a hierarchical order, in which
nodes are connected to parents rather than states connected to each other, resembling
branches on a tree, hence the name.

[ 13 ]

The Basics of AI in Games

The basic elements of behavior trees are task nodes, where states are the main
elements for FSMs. There are a few different tasks such as Sequence, Selector, and
Parallel Decorator. It can be a bit daunting to track what they all do. The best way
to understand this is to look at an example. Let's break the following transitions and
states into tasks, as shown in the following figure:

Let's look at a Selector task for this behavior tree. Selector tasks are represented with
a circle and a question mark inside. The selector will evaluate each child in order,
from left to right. First, it'll choose to attack the player; if the Attack task returns
success, the Selector task is done and will go back to the parent node, if there is one.
If the Attack task fails, it'll try the Chase task. If the Chase task fails, it'll try the Patrol
task. The following figure shows the basic structure of this tree concept:

[ 14 ]

Chapter 1

Test is one of the tasks in the behavior trees. The following diagram shows the use of
Sequence tasks, denoted by a rectangle with an arrow inside it. The root selector may
choose the first Sequence action. This Sequence action's first task is to check whether
the player character is close enough to attack. If this task succeeds, it'll proceed
with the next task, which is to attack the player. If the Attack task also returns
successfully, the whole sequence will return as a success, and the selector is done
with this behavior, and will not continue with other Sequence tasks. If the proximity
check task fails, the Sequence action will not proceed to the Attack task, and will
return a failed status to the parent selector task. Then the selector will choose the
next task in the sequence, Lost or Killed Player? The following figure demonstrates
this sequence:

The other two common components are parallel tasks and decorators. A parallel
task will execute all of its child tasks at the same time, while the Sequence and
Selector tasks only execute their child tasks one by one. Decorator is another type
of task that has only one child. It can change the behavior of its own child's tasks
that includes whether to run its child's task or not, how many times it should run,
and so on. We'll study how to implement a basic behavior tree system in Unity in
Chapter 6, Behavior Trees.

[ 15 ]

The Basics of AI in Games

Thinking with fuzzy logic

Finally, we arrive at fuzzy logic. Put simply, fuzzy logic refers to approximating
outcomes as opposed to arriving at binary conclusions. We can use fuzzy logic and
reasoning to add yet another layer of authenticity to our AI.
Let's use a generic bad guy soldier in a first person shooter as our agent to illustrate
the basic concept. Whether we are using a finite state machine or a behavior tree, our
agent needs to make decisions. Should I move to state x, y, or z? Will this task return
true or false? Without fuzzy logic, we'd look at a binary value to determine the answer
to those questions, for example, can our soldier see the player? That's a yes/no binary
condition. However, if we abstract the decision making process further, we can make
our soldier behave in much more interesting ways. Once we've determined that our
soldier can see the player, the soldier can then "ask" itself whether it has enough ammo
to kill the player, or enough health to survive being shot at, or whether there are other
allies around it to assist in taking the player down. Suddenly, our AI becomes much
more interesting, unpredictable, and more believable.

Summary
Game AI and academic AI have different objectives. Academic AI researches try to
solve real-world problems and prove a theory without much limitation of resources.
Game AI focuses on building NPCs within limited resources that seems to be
intelligent to the player. The objective of AI in games is to provide a challenging
opponent that makes the game more fun to play.
We learned briefly about the different AI techniques that are widely used in
games such as FSMs, sensor and input systems, flocking and crowd behaviors,
path following and steering behaviors, AI path finding, navigation meshes,
behavior trees, and fuzzy logic.
In the following chapters, we'll look at fun and relevant ways in which you can apply
these concepts to make your game more fun. We'll start off right away in Chapter 2,
Finite State Machines and You, with our own implementation of an FSM, where we'll
dive into the concepts of agents, states, and how they are applied to games.

[ 16 ]

Get more information Unity AI Game Programming Second Edition

Where to buy this book

You can buy Unity AI Game Programming Second Edition from the
Packt Publishing website.
Alternatively, you can buy the book from Amazon, BN.com, Computer Manuals and most internet
book retailers.
Click here for ordering and shipping details.

www.PacktPub.com

Stay Connected: