7. Knowledge Representation | Learning game AI programming with Lua

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Learning game AI programming with Lua

By : David Young

4.3 (3)

Learning game AI programming with Lua

4.3 (3)

By: David Young

Overview of this book

If you are a game developer or a general programmer who wishes to focus on programming systems and techniques to build your game AI without creating low-level interfaces in a game engine, then this book is for you. Knowledge of C++ will come in handy to debug the entirety of the AI sandbox and expand on the features present within the book, but it is not required.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Getting Started with AI Sandbox

1. Getting Started with AI Sandbox

Introduction to AI sandbox

Summary

2. Creating and Moving Agents

2. Creating and Moving Agents

Creating a new sandbox project

Setting up the file structure

Extending the SandboxApplication class

Running your sandbox for the first time

Creating a new Decoda project

Configuring Decoda's run executable

Creating a sandbox Lua script

Shooting blocks

Creating an agent Lua script

Agent properties

Physics

Knowledge

Agents' movement

Agent-steering forces

Avoidance

Avoiding blocks and agents

Group steering

Creating a group of followers

Summing steering forces

Summary

3. Character Animations

3. Character Animations

Skeletons and meshes

Attaching meshes to bones

Animation clips

Soldier poses

Manipulating animations

Animation blending

Animation state machine (ASM)

Building a weapon animation state machine

Building a soldier animation state machine

Updating animation state machines

Playing with states

Summary

4. Mind Body Control

4. Mind Body Control

Creating a body

Adding callbacks to the animation state machine

Getting our soldier to shoot

Getting our soldier to run

Creating a brain

Direct animation control

A simple, finite state machine

Indirect animation control

Running the obstacle course

Action latency

Summary

5. Navigation

5. Navigation

Pathfinding

Creating a navigation mesh

Pathfinding on a navigation mesh

The path information

Adding random pathfinding to our soldier

Creating additional navigation meshes

Summary

6. Decision Making

6. Decision Making

Creating userdata

Agent actions

Creating actions

Evaluators

Creating evaluators

Decision structures

Decision trees

Building a decision tree

Creating a decision tree agent

Finite state machines

Building a finite state machine

Creating a finite state machine agent

Strengths of finite state machines

Pitfalls of finite state machines

Behavior trees

Actions

Conditions

Selectors

Sequences

Creating a behavior tree object

Building a behavior tree

Creating a behavior tree agent

Strengths of behavior trees

Pitfalls of behavior trees

Summary

7. Knowledge Representation

7. Knowledge Representation

Knowledge sources

Blackboards

Creating soldier knowledge sources

Constructing a soldier blackboard

Updating decision evaluators

Updating behavior actions

Summary

8. Perception

8. Perception

Events

Managing events

Creating agent senses

Agent visibility

Agent sighting events

Handling new agent sightings

Agent auditory senses

Auditory events

Handling auditory events

Decaying blackboard events

Decaying auditory events

Team communications

Updating agent behaviors

Summary

9. Tactics

9. Tactics

Influence maps

Constructing an influence map

Drawing influence maps

Accessing influences

Clearing influences

Spreading influences

Influence map layers

Updating the influence map

Soldier tactics

Scoring team influences

Scoring dangerous areas

Summary

Index

Index

Knowledge sources

For our current soldier agents, we have two main sources of knowledge: the userData structure and logic evaluators that calculate results on the fly. While both of these techniques work, they quickly become unscalable, as no central system controls the rate at which they're updated, modified, or accessed from.

We can encapsulate our knowledge sources that require complex calculations into a data structure of their own. Once we've abstracted these sources, we can regulate their update frequency, cache calculations, and centralize access.

Creating a knowledge source

Knowledge sources have a few main characteristics: cached evaluation of the resulting calculation, the confidence of the evaluation, and the update frequency.

The cached evaluation is merely the result of the evaluator function the KnowledgeSource instance stores internally. The confidence measure is a value between 0 and 1, which our knowledge data structure can use to determine the best piece of knowledge to be...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Learning game AI programming with Lua

Search

Your notes and bookmarks