Learning Game AI Programming With Lua by Young, David -- Read -- Imperial Library of Trantor

Index

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

← Prev
Back
Next →

← Prev
Back
Next →