Learning Game AI Programming with Lua电子书

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 additional navigation meshes

Summary

6. Decision Making

Creating userdata

Agent actions

Adding data members

Initializing an action

Updating an action

Action cleanup

Action member functions

Creating actions

The idle action

The die action

The reload action

The shoot action

The random move action

The move action

The flee action

The pursue action

Evaluators

Creating evaluators

Constant evaluators

Has ammo evaluator

Has critical health evaluator

Has enemy evaluator

Has move position evaluator

Is alive evaluator

Can shoot enemy evaluator

50/50 chance evaluator

Decision structures

Decision trees

Branches

Decision leaves

Branch evaluation

Building a decision tree

Creating branches

Creating a decision tree agent

Strengths of decision trees

Pitfalls of decision trees

Finite state machines

States

Transitions

Finite state machine structure

Helper functions

Adding states and transitions

Updating the finite state machine

Adding instance functions

Building a finite state machine

The idle state

The movement state

The random movement state

The shoot state

The flee state

The die state

The pursue state

The reload state

Creating a finite state machine agent

Strengths of finite state machines

Pitfalls of finite state machines

Behavior trees

The behavior tree node

Helper functions

Updating the behavior tree node

Actions

Conditions

Selectors

Sequences

Creating a behavior tree object

Behavior tree helper functions

Selector evaluation

Sequence evaluation

Node evaluation

Continue behavior tree evaluation

The behavior tree update loop

Updating the behavior tree

Building a behavior tree

The death behavior

The flee behavior

Combat behaviors

The reload behavior

The shoot behavior

The pursue behavior

The move behavior

The random move behavior

The idle behavior

Creating a behavior tree agent

Strengths of behavior trees

Pitfalls of behavior trees

Summary

7. Knowledge Representation

Knowledge sources

Creating a knowledge source

Knowledge source evaluation

Blackboards

Creating a blackboard

Adding and removing knowledge sources

Evaluating knowledge sources

Setting and retrieving blackboard attributes

Blackboard member functions

Creating soldier knowledge sources

Enemy selection

Flee position selection

Constructing a soldier blackboard

Updating decision evaluators

Updating behavior actions

The die action

The flee action

The idle action

The move action

The pursue action

The reload action

The shoot action

Summary

8. Perception

Events

Attributes

Sending events

Receiving events

Managing events

Assigning agent teams

Handling agent communications

Event types

Creating agent senses

Initializing senses

Updating senses

Agent visibility

Detecting other visible agents

Agent sighting events

New enemy sighted event

New dead enemy body sighted event

New dead teammate body sighted event

Handling new agent sightings

Intermittent agent sightings

Throttling agent visibility updates

Creating event handlers

Adding event handlers

Agent auditory senses

Auditory events

The BulletShot event

The BulletImpact event

Handling auditory events

Decaying blackboard events

Decaying auditory events

Team communications

The EnemySelection event

The PositionUpdate event

The RetreatPosition event

Updating agent behaviors

Enemy selection

Scoring dangerous positions

Score danger from bullet impacts

Score danger from bullet shots

Score danger from enemies

Score danger from dead bodies

Calculating the best flee position

Summary

9. Tactics

Influence maps

The cell height

The cell width

Constructing an influence map

Configuration

Voxelizing a navigation mesh

Drawing influence maps

Accessing influences

Setting influences

Getting influences

Clearing influences

Spreading influences

Cell inertia

Cell falloff

Influence map layers

Updating the influence map

Soldier tactics

Initializing and updating tactics

Scoring team influences

Initializing team influences

Updating team influences

Configuring team influences

Scoring dangerous areas

Tapping into agent events

Adding event handlers

Initializing dangerous influences

Updating dangerous influences

Configuring team influences

Summary

Index