Learning Game AI Programming with Lua

David Young

• Publisher: Packt Publishing
• Year: 2014
• eBook ISBN: 9781783281336
• Edition: 1
• Topic: Computer Science
• Subtopic: Programming
• Index: Computer Science

Game AI can be easily broken up into a number of components such as decision making, animation handling, and tactics, but the balance and interaction between each system strikes a balance between good AI and bad AI.

Beginning with an introduction to the AI sandbox, each new aspect of game AI is introduced, implemented, and then expanded upon. Going forward, you will learn to utilize open source libraries such as Ogre3D, Bullet Physics, OpenSteer, Recast, Detour, and Lua to create an AI sandbox with an entire codebase available to expand and step through.

This is done through a step-by-step approach, from learning to move basic shapes to fully animating your soldiers. By the end of the book, your AI will be able to navigate, pathfind, manage animation playback, communicate, and perceive their environment.

Learning Game AI Programming with Lua

---

Table of Contents

Learning Game AI Programming with Lua

Credits

About the Author

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers, and more

Why subscribe?

Free access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

1. Getting Started with AI Sandbox

Introduction to AI sandbox

Understanding the sandbox

The project layout

The Premake build

Compiling the sandbox with Visual Studio 2008/2010/2012/2013

Open source libraries

Open source tools

Lua IDE – Decoda

Running AI sandbox inside Decoda

Setting up a new Decoda project

Debugging Lua scripts

Decoda Watch window

Decoda Call Stack window

The Decoda Virtual Machines window

Simultaneous Lua and C++ debugging

Visual Studio – Attach to Process

Decoda – Attach to Process

Decoda – Attach System Debugger

Associating Lua scripts from code with Decoda

The Lua virtual machine

The Lua stack

Lua primitives

Metatables

Metamethods

Userdata

C/C++ calling Lua functions

Lua calling C/C++ functions

Function binding

Creating custom userdata

Looking at the vector data type

The demo framework

Ogre

Object-Oriented Input System

SandboxApplication

Sandbox

Agent

Utility classes

Lua binding

Summary

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

Creating a floor

Adding a light

Adding a skybox

Adding meshes to the sandbox

Creating sandbox objects

Shooting blocks

Creating an agent Lua script

Creating a visual representation

Updating an agent position

Updating an agent orientation

Agent properties

Orientation

The forward axis

The left axis

The up axis

Location

Position

Size

Height

Radius

Physics

Mass

The max force

The max speed

Speed

Velocity

Knowledge

Target

Target radius

Path

Agents' movement

Mass

Speed

Velocity

Acceleration

Force

Agent-steering forces

Seeking

Applying steering forces to an agent

Clamping the horizontal speed of an agent

Creating a seeking agent

Pursuit

Fleeing

Evasion

Wandering

The target speed

Path following

Creating a path following agent

Avoidance

Collision avoidance

Obstacle avoidance

Avoiding blocks and agents

Group steering

Alignment

Cohesion

Separation

Creating a group of followers

Summing steering forces

Weighted sums

Priority-based forces

Summary

3. Character Animations

Skeletons and meshes

Mesh skeletons

Loading an animated mesh

Showing a skeleton

Attaching meshes to bones

Attaching a weapon to our soldier

Animation clips

Playing an animation on our soldier

Soldier animations

Crouching animations

Standing animations

Weapon animations

Soldier poses

Weapon poses

Manipulating animations

Enabling and disabling animations

Looping animations

The animation length

The animation time

Normalized time

Restarting an animation

Playing a non-looping animation

The animation rate

Animation blending

Animation weights

Blend window

Blend curves

Linear blending

Playing with blend weights

Animation state machine (ASM)

States

Transitions

Creating animation state machines

Creating helper functions

Adding states

Adding transitions

Adding external helper functions

Forcefully setting states

Requesting states

Updating the animation state machine

Handling state transitions and state requests

Updating running animations

Adding functions to animation state machine instances

Building a weapon animation state machine

Building a soldier animation state machine

Updating animation state machines

Playing with states

Summary

4. Mind Body Control

Creating a body

Creating a soldier

Attaching an animated mesh to an agent

Creating an obstacle course

Displaying the physics world

Adding callbacks to the animation state machine

Handling callbacks

Adding callbacks to the ASM

Updating the ASM to call callbacks

Getting our soldier to shoot

The bone position

The bone rotation

Creating particle effects

The particle direction

Object removal

The collision impact callback

Shooting a projectile

Handling projectile collision impacts

Shooting

Getting our soldier to run

Setting a path through the obstacle course

Running the obstacle course

Creating a brain

Approaches for mind body control

Direct animation control

The death state

The idle state

The falling state

The moving state

The shooting state

A simple, finite state machine

Initializing the agent

Agent FSM state handling

Indirect animation control

The animation controller

Commands

The command queue

Manipulating commands

The change stance command

The die command

The fall command

The idle command

The move command

The shoot command

Assigning member functions

Initializing the controller

Adding handlers for commands

Updating the controller

Running the obstacle course

Creating a direct control agent

Creating an indirect control agent

Indirect control agent initialization

Indirect control agent update

Indirect control agent control

Spawning an indirect control agent

Action latency

Summary

5. Navigation

Pathfinding

Creating a navigation mesh

Configuring navigation meshes

The walkable height

The walkable radius

The walkable climb height

The walkable slope angle

The minimum region area

Building the navigation mesh

Drawing the navigation mesh

Pathfinding on a navigation mesh

Path query

Query results

Random navigation points

The path information

Adding random pathfinding to our soldier

Updating agent paths

Drawing paths

Initializing the navmesh

Randomly running agents

Creating addition...

Table of contents

• Learning Game AI Programming with Lua