AiGameDev.com Premium for Members

Crowds and Pedestrians without Bumper-Car Syndrome

Wed, 25 Aug 2010 07:19:00 +0000

While animation and navigation technology has matured significantly over the years, combining the two together remains quite a challenge! Games like HEAVY RAIN include scenes with few pedestrians that must avoid each other (e.g. on a sidewalk), as well as huge groups that form the illusion of a crowd (e.g. in the station). What techniques are used to implement such situations, and how can the results be improved?

In this all-star panel from the Paris Game AI Conference 2010, you'll hear different perspectives on the problem, from the programming team at Quantic Dream (Bertrand Faure, Jean-Charles Perrier) to leading researchers on procedural animation (Ken Perlin), and one the best independent AI developers (Mikko Mononen)! With their combined wisdom you'll hear solutions to the crowd problem compared to smaller groups of agents, and the best way to integrate it with character animation.

Psychology Profiling in SILENT HILL: SHATTERED MEMORIES with Gwaredd Mountain

Mon, 09 Aug 2010 10:06:00 +0000

The most recent game in the survival horror series, SILENT HILL: SHATTERED MEMORIES recently became famous by psychologically profiling its players. The game received acclaim from the press and players alike, in particular for getting into people's head — and adding replayability to the game. But what combination of tricks and techniques were used to pull this off?

In this presentation from the Paris Game AI Conference 2010, you'll hear Gwaredd Mountain (technical director at Climax) explain the player modelling used by the game to infer which of the Big Five personality profile is dominant in each player. He also explains what data drives the psychological profiling and how it affects the content in the game to deliver a customized experience to the player. He'll also share some insights on its integration within the game's design.

Building the BATTLEFIELD AI Experience with Mikael Hedberg

Wed, 28 Jul 2010 13:28:00 +0000

BATTLEFIELD: BAD COMPANY 2 is most recent FPS from EA's acclaimed DICE studio. The game certainly has its fair share of AI challenges — including many BATTLEFIELD-specific problems such as finding cover in highly dynamic environments and driving physically realistic vehicles. How did a AAA studio known for its multiplayer games set out to build the AI a story-driven game in BAD COMPANY 1, and how did it evolve for the sequel?

In this keynote from the Paris Game AI Conference 2010, Lead AI Programmer Mikael Hedberg shares some insights into AI for the BAD COMPANY series, in particular the changes the team made for the most recent iteration and how it affected the overall experience. You'll also hear how the Frostbite AI evolved from its original use in multiplayer bots, and how the results differ from many other game's AI.

Rule-Based Systems and Declarative Representations with Richard Evans

Wed, 26 May 2010 13:06:00 +0000

The typical decision-making systems used in games these days have many inter-dependencies; even with HFSM or behavior trees it's hard to extend the AI without having to consider the whole set of decisions. Rule-based systems provide a more modular approach to certain problems, which can help build more scalable AI using formal logic.

In this masterclass with Richard Evans, Lead Simulation Engineer at Maxis and Head of AI on THE SIMS 3 who was also Lead AI Programmer on BLACK & WHITE, you'll hear about using rule-based systems in practice. Richard will discuss the application of rule-based systems, logic programming and deontic logic in games — using examples from prototypes and previous games — and how they can help you in your game.

Debug Rendering and Visualization Frameworks for AI & Gameplay

Sat, 15 May 2010 11:48:00 +0000

Fixing bugs remains one of the most time consuming tasks for game developers, and no matter how careful you are with architectural choices or automated testing, problems will creep in at the worst possible time! In terms of AI, decision making processes are often quite complex, and as such, debugging AI often requires significant help from debug visualization.

This masterclass looks into the kind of rendering frameworks you need to build to support debug visualization, and the different ways this can be done in practice. You'll also hear guidelines about what to support upfront and what to expect during production.

High-Performance and Memory-Efficient Pathfinding in DRAGON AGE with Nathan Sturtevant

Thu, 06 May 2010 13:48:00 +0000

Role-playing games often exhibit challenging worlds for the AI to deal with, and BioWare's recently released DRAGON AGE: ORIGINS is no exception. It features large worlds with multiple co-operative NPCs, player avatars that can be automatically controlled at the click of a mouse, plus dynamic area effects and unpredictable dynamic obstacles. How are pathfinding and navigation systems built to deal with all these requirements?

In this interview with Nathan Sturtevant, contractor at BioWare and Associate Professor at the University of Alberta, you'll learn about the pathfinding of DRAGON AGE: ORIGINS in all its details. In particular Nathan will explain the process of rewriting the existing system, the functioning of the navigation system as well as the low-level details about optimization and implementation. You'll also see how a mere three bits in the low-level representation enabled entire game features!

Programming Utility Systems for Single Decisions in Practice

Mon, 26 Apr 2010 13:19:00 +0000

AI programmers have been applying variations of utility systems for decades, and in many cases the problems are so simple it's not worth thinking twice about! However, it's extremely useful to spot utility-based decisions patterns in your code so you can use common techniques when trying to extend your AI — or simply prevent problems later on in the project.

In this masterclass, you'll learn about the code behind utility systems; what do they start out like, how do they evolve over time, and what happens when you try to extend them? You'll see how you can apply a simple code framework as appropriate to help support single-decisions in your game.

Sandbox Release #14: Stalker Behavior, Cover Finding, Blackboard, FHPA*, Utility Kit

Thu, 22 Apr 2010 22:47:00 +0000

The fourteenth release of the AI Sandbox includes a wide variety of improvements, ranging from a new fast implementation of HPA* pathfinding (also known as FHPA*) which deals with dynamic worlds better, a new Decision Kit for making utility-based choices, a cover reasoning & selection demo applied to creating a Stalker behavior, as well as major improvements in the behavior code by using a blackboard architecture.

Credits: Radu Cristea, Nick Samarin, Richard Fredriksson

Historical Battlefield AI in DARKEST OF DAYS with Jeff Russell

Tue, 20 Apr 2010 10:15:00 +0000

The concept behind DARKEST OF DAYS that captured the imagination of gamers was the ability to travel into the past and visit major battlefields, for example Ancient Rome, to the Civil War, or World War I. This obviously presented many challenges for the AI, in particular scaling up to huge battlefields and making sure large numbers of soldiers were fun for the player to interact with.

In this (text) interview with Jeff Russell, Lead Engineer at 8 Monkey Lab, you'll hear about the three major rewrites that the AI underwent to be able to cope with the requirements. Learn how Jeff and his team managed to optimize the pathfinding and the sensory system to reach adequate performance levels for hundreds of soldiers. You'll also hear about the balancing of the game where the player is one soldier in a large group, and many more AI design insights.

Building AI that Rocks: A BRÜTAL LEGEND Post-Mortem with Tara Teich

Thu, 01 Apr 2010 10:06:00 +0000

Tim Schafer's most recent masterpiece, BRÜTAL LEGEND, presented many challenges to the Double Fine team. Not only did the story include a rich cast of characters and a variety of units to play with, but the gameplay also combines brawling, driving, and strategy... Combined with a modest team size, this proved to be a great undertaking from a technical perspective.

In this 1h post-mortem style interview with Tara Teich, Senior Programmer at Double Fine, you'll find out how the AI team resolved these problems. In particular, Tara explains how a component-based approach allowed them easy implementation of a wide variety of characters, how an automated testing tool called RoBert checks many of the game's features automatically, and how the implementation of the AI Avatar as the RTS opponent was approached.

The SIMS 3's Techniques for Unique Characters and Living Neighborhoods in Real-Time

Sun, 28 Mar 2010 19:32:00 +0000

The third installment of THE SIMS redefined the franchise by going beyond a single home and creating an entire living neighborhood. The designers on the game were also keen to emphasize each Sim as a "unique snowflake" with their own traits and personality. The benefits — emergent drama and better story progression — obviously create a huge challenge for the engine...

Richard Evans, Lead AI Programmer at Electronic Arts on the project, gave presentations at both AIIDE and GDC about the AI technology that makes all of this possible at real-time rates on modern PCs. The rest of this article contains highlights and insights from his presentations, as well as an analysis of the changes necessary for this installment.

Balancing Diplomacy and Warfare in SINS OF A SOLAR EMPIRE's AI with Blair Fraser

Sat, 27 Mar 2010 12:54:00 +0000

Since it's release in 2008, SINS OF A SOLAR EMPIRE has captured the hearts of the gaming community and created an army of fans for its unapologetic approach to space battles; everything is always simulated, which brings the game to life with activity in a consistent and detailed way. In fact, SOSE won the AiGameDev.com award for Best AI in an Independent Game that same year.

In this 1h30 interview with Blair Fraser, one of the masterminds behind the game and its AI, you'll hear about the implementation details that allowed Ironclad to simulate the whole universe on minimum hardware requirements. You'll also learn about how the game combines utility-based decision making along with an objective-based system that plans through the technology tree to achieve its goals. You'll also discover the challenges of building a diplomatic yet Machiavellian AI opponent in the most recent expansion!

Finite State Machines, Hierarchical Graphs and Beyond...

Mon, 22 Mar 2010 19:22:00 +0000

Finite state machines (FSM) are used very often in games, more so than any other approach. But is the graph representation more useful than the control technique itself? How can we leverage that without the usual disadvantages?

This tutorial looks into the use of finite state machines for AI and animation, and how they are typically extended with hierarchies. You'll then learn about the potential pitfalls of using a FSM for character AI and how to work around them by leveraging only the advantages of a hierarchical graph.

Hierarchical Pathfinding Tips & Tricks with Alexander Kring

Sat, 06 Mar 2010 21:50:00 +0000

Understanding the theory of A* or hierarchical search is only half of the battle. How do you build a good navigation system around that? What do you need to watch out for to make sure the pathfinding behavior remains robust? Which are the biggest obstacles to performance and multi-threading?

Using examples from COUNTER STRIKE: SOURCE, COMPANY OF HEROES, F.E.A.R., UNCHARTED, and LEFT 4 DEAD, this masterclass digs into the little practical details of hierarchical pathfinding. In particular, you'll learn about setting up a consistent hierarchy, performance trade-offs for the shape of areas, how to structure a navigation system, and supporting incremental searches — among many other things...

Code Coverage for QA: A Practical Approach to Testing AI in Games with Matthew Jack

Mon, 01 Mar 2010 22:00:00 +0000

As AI systems have become increasingly complex thanks to better techniques and tools, quality assurance has also had to improve accordingly. Testers have always relied on their intuitions, hard work, communication, their gaming skills and some luck to find bugs, but over the past few years better tools have been falling into place to help this process. This year will mark another step in QA for Game AI, thanks to a clever technique that Matthew Jack applied on Crysis.

In this masterclass with you'll discover a new semi-automated tool to help testers isolate features and problems when playing games, which stands to significantly improve the way you test AI without too much time investment. Matthew will also provide a quick overview of other testing procedures that are commonly used in the games industry and discuss their effectiveness. Finally, you'll hear the story of how this was used at Crytek, and how Matthew recently applied it to Alien Arena, the open-source FPS.

Sandbox Release #13: Stealth Mini-Game

Sat, 20 Feb 2010 13:16:00 +0000

This is the thirteenth release of the Sandbox and it features a small stealth game that was mostly built during the Game Jam / AI Marmelade, as well as underlying changes to the pathfinding grid representation, and the inclusion of a reasoning layer to manage the sensory queries.

Credits: Radu Cristea, Nick Samarin, Richard Fredriksson

Understanding Decision Boundaries: How to Preempt Bugs and Increase the Realism of Behaviors

Thu, 18 Feb 2010 15:34:00 +0000

Building an AI that doesn't oscillate or ignore important events can be quite a challenge in practice. However, looking the AI from a different perspective can often offer some new design insights on such problems, for example by considering points in-between behaviors. Watch this design masterclass about decision boundaries and find out why it was called "mind-opening" by multiple attendees!

In this 1h presentation, you'll learn about the concept and applications of decision boundaries using scenarios from Ubisoft's FAR CRY 2. You'll see how thinking in terms of these boundaries between behaviors can help you reduce bugs like oscillating between two states or simply ignoring environment changes. Finally, you'll understand how to avoid robotic looking actions and better convey gameplay information to the player.

Blackboard Architectures and Knowledge Representation with Damian Isla

Thu, 04 Feb 2010 11:42:00 +0000

Blackboards have increasingly become a key part of almost every game's AI architecture. They help maximize computation time while reducing spikes, as well as helping decouple the behavior from the acquisition of information. However, getting this part of the system right involves finding a good knowledge representation...

Find out exactly how in this 1h masterclass with Damian Isla, Lead AI Programmer on HALO 2 and 3. He'll explain the key motivations for using a blackboard, what role they play in the overall system, how to approach the development process, and what kinds of considerations you need to make while designing your KR.

Behaviors By Example: Patrolling and Hiding in Cover

Wed, 27 Jan 2010 18:09:00 +0000

Building behaviors for a game or simulation is an incremental process involving both the building blocks at the C++ level, and the way they are combined to create the AI. A key part of this process is reviewing and improving the code and the behaviors — and figuring out what the next iteration should be.

This tutorial looks into the behaviors inside the recent release of the Sandbox, in particular the patrol sequence of the red bots and the seeking cover and hiding behaviors of the yellow bots. Both of these are implemented using a behavior tree, and you'll see how these were built and how they can be improved.

SHPA: Improving Hierarchical Pathfinding Performance by Maintaining A Static Hierarchy with HPA

Thu, 21 Jan 2010 13:55:00 +0000

NOTE: This article was written by Alexander Kring (awkring at gmail dot com), Gameplay Programmer at Nihilistic Software and previously AI Engineer at Electronic Arts. The algorithm described was reimplemented by Nick Samarin in the AI Sandbox, under the guidance of Alex J. Champandard — who also suggested improvements to the algorithm.

In 2004, Botea, Muller, and Schaeffer published the HPA* algorithm (Hierarchical Path-Finding A*), which arguably describes the most popular hierarchical path-finding implementation in the video games industry. One of the most pressing concerns for HPA* is the complexity involved in modifying the graph hierarchy, which is required for connecting arbitrary start and goal nodes. Maintaining a dynamic hierarchy slows performance, and complicates programming and debugging. This paper explains the problems with modifying the graph hierarchy, and then shows how the SHPA* algorithm alleviates these problems by maintaining a static hierarchy. Compared to HPA*, SHPA* is shown to be up to nine times faster in the best case, and about twice as fast for many common cases, while finding paths that are within 4% optimality of HPA*.

This article was written by Alexander Kring, Gameplay Programmer at Nihilistic Software and previously AI Engineer at Electronic Arts. The algorithm described was reimplemented by Nick Samarin in the AI Sandbox, under the guidance of Alex J. Champandard — who also suggested improvements to the algorithm.

Climbing and Sneaking Behind UNCHARTED 2: AMONG THIEVES's AI with Christian Gyrling

Fri, 15 Jan 2010 17:52:00 +0000

Naughty Dog's second game of this console generation, UNCHARTED 2: AMONG THIEVES, received critical acclaim for perfectly blending story telling, high-quality animation and of course gameplay. The game's AI not only allowed the creation of believable buddies that accompany the player (as Nathan Drake) throughout the game, but also supported the variety of enemies in both single player and co-operative modes.

In this 1h30 interview with Christian Gyrling, you'll hear how the new features were implemented, from the implementation of movement via traversal packs, to support for stealth gameplay. You'll also find out all the little details that went into creating the AI for these characters, including the character layering, the integrated pathfinding and obstacle avoidance on the PS3's SPUs, the navigation meshes, the blend tree's functioning, the flat & dynamic structure of the behavior tree, and more...

Decentralized, Emergent and Fuzzy Intelligence: 30,000 Units in AI WAR

Tue, 15 Dec 2009 23:06:00 +0000

As an independently developed game free of typical AAA constraints, AI WAR chose to innovate with its artificial intelligence. The simulation maintains over 30,000 active ships at later stages in the campaign, including player controlled and enemy ships. The game also populates the universe procedurally in multiple ways to create replayable experiences, combining design elements of real-time strategy with tower defense.

In this almost 2h long interview with Chris Park, Lead Developer of the game, you'll discover how he used concepts from database technology to implement such large scale battles. You'll also discover many of the gameplay insights from modern RTS games that lead to the design of the game's AI. Finally, you'll understand how all the AI units coordinate emergently despite having no central control.

Non-Player Characters: From Animation to Behavior A Panel Discussion

Thu, 10 Dec 2009 18:23:00 +0000

The single biggest challenge that AI programmers face is expressing behaviors... via animations. Character animation is at the same time the best tool for portraying intentions, but it's also the most expensive and time consuming process. As we strive towards better characters, animation is the primary battleground.

This panel from the Paris Game AI Conference '09 brought together professional animators, designers, and programmers to discuss the issue. Which techniques can you use to improve character animation in practice? How should you work within a team to create better looking animations? What's the next step for the games industry?

Panelists: Christiaan Moleman (moderator), Phil Carlisle, Xavier Dolci, Julien Hamaide

Sandbox Release #12: Multi-Threaded Job Queue, Sensory System, Path-Following & Visualization

Wed, 09 Dec 2009 00:24:00 +0000

This is the twelfth release of the Sandbox and our first double release! This includes all changes from version eleven, which was not released due to a pending rework of the engine to support multi-threading. The sensory system has been rebuilt to support asynchronous requests managed centrally, which are parallelized using the job queue. The Navigation and Locomotion components have been reworked, and support path following based on the hierarchical search. The HPA* implementation has also been optimized using a technique known as FHPA*, as well as the multi-threaded job queue. There's also support for debug visualization API, as well as a new user interface implementation.

Credits: Radu Cristea, Nick Samarin, Piotr Trochim, Jeremy Tryba, Matt Fair

DEMIGOD's AI from Role-Playing to Real-Time Strategy with Dru Staltman

Thu, 26 Nov 2009 10:01:00 +0000

The AI in DEMIGOD has arguably one of the most innovative designs of the decade, let alone this year. It uses a hybrid combination of a search algorithm used as way to find optimal actions, allowing the computer-controlled Heroes to both behave strategically and figure out how to level up in the game! Read this in-depth article for details of how the final system works.

In this 1h30 interview with Dru Staltman, Lead Gameplay Engineer on DEMIGOD, you'll hear stories from behind the scenes of how the AI was developed. Find out how Dru had to effectively build the AI for multiple games as the design changed radically during the development, and how his three layer architecture coped with the changes. You'll also hear practical tips for how to deal with tuning and testing systems based on fuzzy weights, and what do do if Lua's performance becomes a problem.

Hard Work, Networking and a Bit of Luck: A Tortuous Journey into the Games Industry

Thu, 19 Nov 2009 12:38:00 +0000

Working in the games industry as an AI Programmer is undoubtedly the coolest job on the planet — based on completely objective and unbiased judgment from the AiGameDev.com editorial team. However, getting the position you want in the right company can be quite a daunting process!

In this interview with Jad Nohra (the latest AI recruit at Guerrilla Games), you'll find out how he did it. Jad shares his programming background including his independent games, how he approached industry and his most recent work on the AI Sandbox. This is followed by an open Q&A session with Jad and Alex Champandard (AiGameDev.com, ex-Rockstar) about the process of getting into industry, portfolio, interviews & contacts, required background, etc.

Designing and Prototyping an Independent Game with Borut Pfeifer

Mon, 16 Nov 2009 18:52:00 +0000

How do you turn an idea for a game into something that's fun to play? What do you do when those ideas rely heavily on AI? How do you balance the apparent complexity that AI brings to a simulation with the desire to keep gameplay simple? Find out in this interview with veteran game developer, Borut Pfeifer, formerly a Lead AI Programmer at Electronic Arts LA, currently working on an independent game.

Borut's current project is called The Unconcerned, taking place during the riots in Iran. You play the role of two parents that have lost their child in the crowd. Learn how Borut is approaching the design and in which way he's prototyping the ideas in practice. You'll also see what kind of things he's considering for the AI.

The Art of Multi-Threading Panel: From Implementation Strategies to Cross Platform Development

Sun, 08 Nov 2009 09:05:00 +0000

Successfully implementing a multi-threaded system for a game requires a good understanding of the theory. But there are also many "tricks of the trade" that experienced developers use in practice. This is particularly the case for AI since it interacts with many other sub-systems...

In this panel from the Paris Game AI Conference '09, you'll learn about the practical sides of parallel programming. What can you do to build a cross platform system? How does parallelization fit with modular code? Where's a good place to get started when scaling up to multiple threads?

Participants: Julien Hamaide (Fishing Cactus), Markus Mohr (Crytek GmbH), Björn Knafla (University of Kassel).

Race Script: An Alternative to Rubber Banding by Eduardo Jiménez

Fri, 30 Oct 2009 17:45:00 +0000

As games become more ubiquitous, two of the most important design challenges we face as developers are difficulty adaptation and experience management. Pure, a dirt racing title from Disney Interactive, received critical acclaim by addressing both of these issues.

In this presentation from the Paris Game AI Conference 2009, you'll hear from Eduardo Jiménez about how Black Rock designed their own "race script" solution as an alternative to rubber banding that increases the amount of interactions between the riders. You'll also see how this avoids the visible effects of speed-adjustment, and finally you'll discover how this was implemented in practice, both with videos from the game and a prototype mini-game.

A Programmer's Guide to Building a Low-Level Sensory System

Sun, 25 Oct 2009 14:54:00 +0000

AI is only as good as the information it gets; if garbage goes in, garbage comes out. Unfortunately, acquiring good information about the physical world around an actor is not a trivial task, and calculating things like collisions and line of sight queries can take a fair bit of processing power. Providing such an interface between the low-level collision representation is typically the role of a sensory system.

In this 1h30 masterclass, you'll discover the big picture that a programmer needs to know about sensory systems — using examples from Thief: Deadly Shadows. In particular, what information do they provide for the AI to reason with, and how do they create an interface between the AI and other systems? Then, focusing on the low-level, you'll find out what it takes to build a good sensory system that can scale up and down depending on the computation power available on your target platform, and most importantly how it can manage sensory queries efficiently.

Planning Multi-Unit Maneuvers Using HTN and A* with William van der Sterren

Thu, 15 Oct 2009 12:16:00 +0000

As military-style games become bigger in scope and more realistic in their simulations, there's an increasing need for using AI to help generate mission scripts automatically under the supervision of designers. Furthermore, online services can be used to extend the lifespan of games by providing procedural missions for players on either standard maps or user-generated content.

In this presentation from the Paris Game AI Conference 2009, William van der Sterren presents his most recent project involving HTN planners based on A*. You'll discover how his web-server based implementation can plan intricate coordination for missions in Armed Assault (a.k.a. ArmA 1). You'll also learn the challenges of applying HTN and A* to making sure units behave in a sensible & tactical manner. You'll also find out what it takes to make military units of many different type coordinate together to achieve objectives.

Dynamic Decisions: Building an AI that Can Change Its Mind

Sun, 11 Oct 2009 11:38:00 +0000

Your archers are engaging enemy cavalry from a distance using their ranged attack. The opposing forces harass you, the archers get a bit too complacent and move away from the protection of your infantry. Seeing the opportunity, the enemy cavalry charges suddenly! How do you make sure your archers or crossbowmen switch to their hand weapon to try to limit the damage?

Such problems come up very frequently in game AI. What do you need to do to make sure the AI can deal with changing its mind, for instance to switch between an attack that makes sense in one situation (e.g. ranged attack) vs. another attack mode that needs to be used otherwise (e.g. close combat)? How should you structure your behaviors to support such situations? This masterclass using examples from the indie game Mount & Blade to explain the solutions.

11 Secrets about Left 4 Dead's AI Director and its Procedural Zombie Population

Wed, 07 Oct 2009 14:08:00 +0000

As more games strive for replayability and unique experiences, AI becomes increasingly important to help synthesize the gameplay and adapt to what the players are doing. This can help significantly increase the lifespan of single player games or story-based games, even if they are mostly linear like Left 4 Dead. With large open sandbox worlds, technologies like the AI Director become even more important to help make the experience a little less mediocre during the worst moments, since emergence is rarely good enough on its own!

This in-depth feature article looks into Left 4 Dead's procedural gameplay systems and the famous AI Director that helped Valve solve such problems, and secure the "Best Game AI of the Year" in the AiGameDev.com 2008 Awards. You'll learn how the zombie population is generated using a layered approach that's similar to Perlin noise, and how the results are adapted to what the players are doing. Dig into the a simple four-state system monitors and controls the whole experience, and discover what tricks Valve used to balance and tune the results.

Advice and Tales from the Trenches: Being an AI Programmer in Industry

Wed, 30 Sep 2009 22:29:00 +0000

Both the importance of AI and working conditions have changed quite dramatically over the past few years. What's it like to work as an AI programmer in big companies? How is being part of a small independent studio different? What should you expect from an average day of work?

In this 45 minute panel, you'll hear war stories from industry veterans about their time in industry, and learn about the current responsibilities of an AI programmer. You'll also find out what studios are looking for in developers, and how best to build yourself into the role of an AI programmer.

Participants: Phil Carlisle (British Indie), Eduardo Jimenez (Black Rock Studio), Mieszko Zielinski (People Can Fly)

Building a Scalable Navigation System for Pathfinding and Decision Making

Wed, 23 Sep 2009 22:02:00 +0000

Building a pathfinder based on A* is the easy part! What do you need to keep in mind when building the navigation system around it? Which queries should it support and how are they used? How do you make it robust and capable of scaling up to support large numbers of agents, and work well on lower grade hardware?

In this 1h20 masterclass, you'll find out exactly what role a navigation system fills, and how it interfaces with the rest of the game's architecture. You'll also understand why pathfinding is increasingly important for decision making, and what to do about it. Finally, you'll learn some tricks for dealing with large numbers of navigation queries in an efficient way, using examples situations from Unreal Tournament 3.

Sandbox Release #10: Patrol & Flee Behavior Demos, Navigation System

Tue, 22 Sep 2009 00:57:00 +0000

This is the tenth release of the Sandbox, and based on monthly progress, it's arguably the most impressive so far! The Hide & Seek demo from the previous release has been extended to use the behavior tree library; one guard patrols around while multiple other bots run away and find cover. The behavior library some big usability improvements also, so it's now easier for you to experiment with BTs and dig into the code. The running demo is now integrated with the hierarchical pathfinder, and there's a centralized navigation system that handles time-sliced pathfinding queries. Finally, the codebase has been ported to work under GCC/Linux, along with a cross-platform build system.

Credits: Jeremy Tryba, Nick Samarin, Piotr Trochim, Radu Cristea

Goal-Based Action Optimization and the Hybrid Hero AI in DEMIGOD

Wed, 09 Sep 2009 23:08:00 +0000

Demigod is an innovative hybrid between RPG and RTS games, challenging the player to control and manage a Hero-like unit to accomplish a variety of missions (e.g. Dominate, Conquest, Fortress) in a set of predefined maps. It's built mostly as a multi-player experience, but includes an offline Skirmish mode for both quick games and tournaments against the AI. Since the implementation is based on a goal-oriented action planner, I've been keen to play the game and dig into the Lua code for the last week.

I was expecting to find a textbook application of the goal-oriented action planner (GOAP) from F.E.A.R. pioneered by Jeff Orkin. On the surface that seems to be the case, as the architecture and many of the high-level concepts are similar. However, under the hood, almost everything is done differently — to the extent that it's more similar to other game AI approaches than goal-oriented planning. And indeed, due to the RPG nature of the game, the long term progress of the AI Demigods, and the dynamic yet tactical gameplay, the problem required a very different solution.

In this in-depth feature, you'll learn how the AI used for the Demigods was architected and implemented (a.k.a. Hero GOAP). You'll find out why the name "goal-based action optimization" fits better than calling it a traditional STRIPS-like planner implementation, and what was necessary to make such a system work on such a large search space with a wide range of choices available.

NOTE: This first article covers only Demigod's Hero AI — which is the lowest-level and most complex layer of the whole system. The next article will show how everything fits into a three-layer architecture with multiple planners that include a squad AI and strategic reasoning.

Parallelization of Game AI: The Theory of Multi-threading Explained by Björn Knafla

Wed, 09 Sep 2009 13:00:00 +0000

The question of multi-threading has been relatively straightforward for AI so far: most games keep all the logic on the main thread, and if necessary offload pathfinding to a separate thread. However, there are huge opportunities for programmers who understand the theory of parallelism and design their architectures accordingly.

In this presentation, Björn provides an overview of the underlying concepts you need to know about for parallelizing game AI. He'll also talk you through the most common techniques that used for parallelizing AI code in the games industry today.

From Squad Tactics to Real-time Strategy: High-Level Multiplayer Bot AI in Killzone 2

Mon, 31 Aug 2009 19:30:00 +0000

Thanks to improvements in PC & console hardware, there's now an opportunity for game developers to leverage AI technology from different genres. In studios that reuse their AI codebase from one generation to another, or those with large enough AI teams, it's now possible for a single title to bridge the gap between first-person shooters (FPS) and real-time strategy (RTS) technology — and Killzone 2 is a perfect example.

This is part 2 of the presentation about Killzone 2's multiplayer bots from the Paris Game AI Conference 2009. You'll see how the high-level strategy was implemented for multiple game modes including Search and Retrieve, Assassination, Capture and Hold, and Search and Destroy. You'll also learn how terrain areas can be created automatically using an area clustering algorithm, and form the basis of the tactical pathfinding used by squads and the high-level strategic reasoning.

The Team: Alex J. Champandard (Main Presenter), Remco Straatman (Summary and Q&A), Tim Verweij (Off Screen)

The AI in Killzone 2's Bots: Architecture and HTN Planning with Remco Straatman

Sun, 23 Aug 2009 16:58:00 +0000

Killzone 2 was one of the most anticipated titles of early 2009. While the quality of the graphics is immediately obvious, the game also received acclaim for its dynamic and adaptive AI. This is most obvious in multiplayer mode, featuring both online and offline bots that battle in a mission-based game environment.

In this presentation from the Paris Game AI Conference 2009, you'll learn about the architecture behind the AI for the Killzone series that has evolved over the years. You'll also discover exclusive details about the hierarchical task network (HTN) planner that was entirely written for the next-gen experience in Killzone 2.

AI for Dynamic Large-Scale Open Worlds in [PROTOTYPE] with Sergio Garces

Sat, 15 Aug 2009 10:49:00 +0000

In this 1h15 interview, you'll find out about the tricks used to populate streets of New York with hundreds of pedestrians in [PROTOTYPE]'s large-scale city. Discover how the AI was designed and implemented to support open-world three way battles between the Player, the Infected and the Military. You'll also learn about the different components in the game's AI, such as the behavior tree, the pathfinder, the sensory and tactical reasoning systems, as well as the animation and close combat system. How did Radical Entertainment manage to fit all this onto a modern console?

Sandbox Release #9: Hide & Seek, Line of Sight and Game Architecture

Sun, 09 Aug 2009 18:04:00 +0000

This ninth release of the Sandbox introduces a new mini-game demo, where the bots use boxes to hide from the moving cursor. To do this, the AI queries the underlying collision representation for ray tests, to determine if a cover location is hidden or not. Finally, this version of the code introduces new game code concepts to help simplify the application code; for instance, central systems are used to manage the components, such as NavigationSystem, LocomotionSystem, etc. Also, the loose components of the MVC are tied together in a more explicit way using something similar to a domain-specific language within C++.

A Practical Introduction to Reinforcement Learning for Games

Mon, 03 Aug 2009 12:14:00 +0000

Find out why reinforcement learning (RL) is an up-and-coming technology, and the ideal complement for many classical game AI techniques. In this masterclass, you'll learn how RL was applied in commercial games to enhance the gameplay. The second part will also cover how this type of machine learning is well suited for content creation to simplify the authoring of behaviors. Finally, in the last part you'll hear the trick to applying RL at runtime for online adaptation while the game is underway.

Squad AI and Group Behaviors: A Panel Discussion

Sun, 26 Jul 2009 19:38:00 +0000

In this panel from the Paris Game AI Conference 2009, veteran AI developers talked about their experiences with games such as End War and Crysis, share thoughts and tips about the development process of group behaviors, and talk about design and implementation ideas for the future. Topics included the use of war maps as a design tool, the benefits and approaches to cheating (or not) with sensory information, and the importance of hand signals and vocalizations...

Participants: Florent Dotto (Ubisoft), Mikko Mononen (Recoil Games), Ricardo Pillosu (Crytek), Mieszko Zielinski (People Can Fly)

Coordinating Agents using Behavior Trees with Ricardo Pillosu

Wed, 22 Jul 2009 15:01:00 +0000

As behavior trees become the implementation of choice for individual game characters, game developers are increasingly turning towards them to coordinate multiple agents. Ricardo Pillosu's talk at the Paris Game AI Conference 2009 focused on his recent experience applying the behavior tree paradigm on top of the CryEngine 2's existing AI system, and in particular to coordinating multiple AI agents simulate group tactics.

Emotions in Game Characters with Phil Carlisle

Fri, 17 Jul 2009 12:03:00 +0000

While AI technology is getting better, game characters still often lack an emotional dimension. In this presentation from the Paris Game AI Conference 2009, Phil Carlisle provides overview of recent progress adding character and emotion to in game NPCs, as well as a review recent research in the field for developers who are curious about emotional reactions for game characters. He also discussed this from a practical perspective using his work as the basis, outlining the techniques that are ready to be applied.

Learning and Generating Social Behavior from Gameplay with Jeff Orkin

Wed, 08 Jul 2009 11:47:00 +0000

Machine learning has made a lot of progress to recognize patterns in gameplay, as well as assist designers in improving the game's experience. But how can it be applied to learning social interactions from human gameplay recordings? In this hour long interview with Jeff Orkin (famous for his work on F.E.A.R.'s AI), find out about his research on The Restaurant Game and his recent white paper that describes how social behaviors can be generated by mining the content of a collective experience.

The AI in Dark Sector and the Evolution Engine with Daniel Brewer

Wed, 01 Jul 2009 15:48:00 +0000

In this 1h45 interview, you'll find out how the AI in Dark Sector was designed and implemented — including anecdotes, iterations and tips from the development. In particular, this session will focus on three of the NPCs that Daniel Brewer worked on. You'll learn how all the technology came together with the gameplay to create the Mauler (close combat enemy with a shield), the Chroma (stealthy ranged-weapon enemy) and the Helicopter (mini-boss). Other topics include dynamic difficulty adjustment, aiming skills for a cinematic feel, and funny bugs!

AI Blueprints for Action & Combat Behavior Trees

Wed, 27 May 2009 21:09:00 +0000

This masterclass ties together all the sessions on design patterns to show you how to build a complete behavior tree for enemy NPCs in action / combat games. You'll learn how to assemble a set of relaxed, suspicious and alert behaviors into three subtrees. At each stage, you'll find out what kinds of decisions should be made, how the tree should be structured, and what you need to do to make sure the whole behavior is responsive to changes in the environment.

Sandbox Release #8: Collision Detection, Running/Racing Demo

Sat, 23 May 2009 12:17:00 +0000

The eighth release of the Sandbox brings a host of new technology and systems together, including components within the AI actors, whole modules of the MVC framework and even additional external libraries. The result is a mini-simulation that includes a race on-foot between multiple characters, each avoiding boxes and locomoting between markers in the world. This ties together game logic, simple character AI and the motion planning based on the terrain representation.

Behavior Tree Design Patterns: Goal-Orientation

Wed, 20 May 2009 11:45:00 +0000

Continuing the series of masterclasses about behavior tree design, learn how to build modular building blocks for plugging into a more complex tree, at what level you should model behaviors, and the important things to consider when building a goal-directed AI using a behavior tree. Find out what's a good granularity to help your designers interact with purposeful behaviors, and where you can start programming to reduce the lines of code required.

A Venture into A-Life and Virtual Ecosystems with Andy Schatz

Sun, 10 May 2009 22:55:00 +0000

In this interview with independent developer Andy Schatz, you'll learn about the A-Life behind his series of games including Venture Africa and Venture Arctic, and the upcoming Venture Dinosauria. Find out how the game's AI was designed, how the creature behaviors were balanced, and how the predator / prey simulation was inspired by the behavior in nature. Andy also talks about opportunities for independent developers looking into A-Life games.

AI and Designers: Mind the Gap

Sat, 02 May 2009 19:26:00 +0000

The AI Summit earlier this year featured a discussion panel about the tensions between design and programming — and particularly AI. Since AI is such an integral part of gameplay, innovation on the technical front must be matched in equal measures in design and methodology. This session looked into prototyping workflows, methodology and interaction, as well as tips and tricks from experienced designers and coders.

Participants: Alex Hutchinson, Soren Johnson (moderator), Joshua Mosqueira, Adam Russell, and Tara Teich.

Behavior Tree Design Patterns: Prioritization

Wed, 29 Apr 2009 23:55:00 +0000

This masterclass digs into the concept of prioritizing behaviors to help select which to activate or deactivate at any point in time. You'll learn about the three major ways of prioritizing behaviors, both statically at development time and at runtime, and list both their advantages and disadvantages. Also find out how to combine all these forms of prioritization into one tree as necessary.

GDC '09 AI Debriefing: Trends and Take-Away

Mon, 27 Apr 2009 18:07:00 +0000

This year's GDC, through the AI Summit and multiple lectures on game design, emphasized many new trends that have been sweeping through the field of Game AI recently. In this informal discussion, Phil Carlisle and Alex Champandard talk about the key trends from the conference from both a design and technical perspective. They also discuss open points and things to take-away as homework for next year!

Applying Behavioral Mathematics to Left 4 Dead with Dave Mark

Wed, 15 Apr 2009 01:40:54 +0000

How can you go beyond boolean decisions to improve the AI in your NPCs? This session with Dave Mark looks into the bots in Left 4 Dead, and finds ways they can be improved using concepts like decision theory and fuzzy logic. Learn how to select better targets by taking into account many factors without spending too much processing power, find out how utility-based models and drives can replace a FSM, and see what a fuzzy trigger could do for your game.

[Bonus] Procedural 3D Model of Future Manhattan by CityEngine

Fri, 10 Apr 2009 22:11:33 +0000

Large worlds are generally a challenge for game AI, since it requires lots of forethought to handle efficiently. Procedural technology brings these kinds of challenges right to our doorstep. To help you prepare for these challenges, AiGameDev.com teamed up with Procedural.com, the company behind CityEngine, to provide you some large models of future Manhattan — based on current maps but with lower water levels.

The Recast Navigation & Construction Library by Mikko Mononen

Sat, 04 Apr 2009 14:29:57 +0000

Last month in his popular masterclass about creating navigation meshes by voxelization, Mikko Mononen announced that he'd be releasing his project to the public in the future. The project is now called Recast and the first version is ready, plus Mikko has made it available exclusively to Premium Members of AiGameDev.com. The license allows any usage (including commercial) but above all, be sure to send in your feedback as he intends to improve the library further.

Dynamic Locomotion by Example with Alex Champandard

Mon, 30 Mar 2009 22:08:31 +0000

Follow step by step as this masterclass builds up a locomotion system from the ground up, starting from a solution that's simple to implement and low-level of detail then moving into higher quality systems that leverage animation data more and more. Learn about concepts like animation-driven motion, transitions, parametric animations, step-based models, reactive controllers and planning.

Beyond A*: Speeding Up Pathfinding Through Hierarchical Abstraction with Daniel Harabor

Thu, 19 Mar 2009 15:18:43 +0000

What's the next step for pathfinding after the traditional A* algorithm? Find out how to improve the performance of search using a hierarchical representation combined with pathfinding on multiple layers — known as the HPA* algorithm. This masterclass will also show you how to deal with many different unit sizes and capabilities, while at the same time preserving the same speed-up provided by the hierarchy. Finally, you'll see different ways to break away from the 2D grid and instead support continuous space, using a technique known as probabilistic roadmaps.

Sandbox Architecture, Discussion and Recent Features

Sun, 15 Mar 2009 14:19:30 +0000

Find out about the latest progress in the sandbox, such as the step-based motion graph, the HPA* search and our clustering prototypes that build on top of the new sample framework. Also learn about the underlying architecture of the system, based on MVC but that's growing in its own unique way. The discussion also goes into component system, blend trees and future work.

Sandbox Release #7: Motion Model, Step-Based Planning & Sample Framework

Wed, 11 Mar 2009 20:48:06 +0000

For the seventh release of The AI Sandbox, we've applied the motion synthesis code to generate locomotion animations which can be directed towards points in space. This based on a motion graph which is built out of individual steps; this is the motion model. The A* algorithm is applied onto this to generate a sequence of motions which are carefully aligned and blended together. This release also contains improvements to the previous samples for clustering and HPA* — which you can now experiment with interactively.

Clearance-based Pathfinding and Hierarchical Annotated A* Search

Thu, 05 Mar 2009 13:34:57 +0000

In this tutorial written by Daniel Harabor, you'll find out how to deal with different sized units when pathfinding on a grid, for example in a typical real-time strategy (RTS) game with tanks and foot soldiers. Learn how you can deal with this problem elegantly by using the concept of clearance at each point in the map. Daniel also presents his HAA* algorithm, which helps deal with clearance in a hierarchical manner such that the search remains both efficient and accurate.

Navigation Mesh Generation via Voxelization and Watershed Partitioning with Mikko Mononen

Tue, 03 Mar 2009 14:37:50 +0000

Learn how to turn a complex poly soup of triangles representing your game world into a simple but accurate mesh representation that you can use for navigation. The topcis include voxelizing the polygons efficiently, ways to partition the voxels into areas, then turning these areas into triangle or convex polygons. Mikko demonstrates some real-world examples of his algorithm at work, and discuss possible improvements and extensions.

A Homegrown Abstract State Machine for Sports AI with Brian Schwab

Tue, 24 Feb 2009 13:35:02 +0000

Discover how the AI for Sony's basketball franchise was built with Lead AI Developer Brian Schwab. You'll learn about how the ASM concept was adapted and customized into a situation NBA '09. Find out how these ideas compare to behavior trees, what the editor looks like, and how Brian's situation system helped implement complex multi-agent behaviors that are 100x more detailed than 5 years ago...

High-Level Animation and Motion Planning

Fri, 20 Feb 2009 01:59:33 +0000

Building on top of the animation system and motion assets described in previous sessions, this masterclass focuses on locomotion and character animation logic. In particular, you'll learn about the major challenges of creating high-level animation logic and why HFSM are currently the most common approach. A solution based on behavior trees is also presented, showing how you can create goal-driven animation behaviors. Finally, you'll hear about the main approaches to locomotion planning.

Advanced Potential Fields in Practice with Johan Hagelbäck

Wed, 11 Feb 2009 00:49:44 +0000

Discover advanced tricks using potential fields in this masterclass with Johan Hagelbäck. In particular, this session discusses the process of accelerating high-level pathfinding using reactive lookups, as well as improving low-level navigation in dynamic environments (e.g. crowds) using a similar approach. These potential fields are also applied to tactical maneuvers such as attacking from a distance, flanking, or avoiding fields of fire. Finally, the strategic component of potential fields is discussed too, including multiple objectives and state-based potential fields.

Sandbox Release #6: A* Search, Hierarchical Representation, and HPA*

Sun, 08 Feb 2009 21:43:06 +0000

In this release of the AiGameDev.com's sandbox, we've focused on pathfinding algorithms, most importantly making it easy to demonstrate the process and visualize the results easily. In particular, an abstract A* search was added and applied to a 2D waypoint grid. We also implemented a customized version of HPA* that re-uses the area generation algorithm. This clustering algorithm is now easier to customize, and you can experiment with custom heuristics.

Modern Pathfinding Techniques

Wed, 04 Feb 2009 00:03:54 +0000

This full report looks into the topic of pathfinding, focusing on challenges found in modern games. While the low-level algorithms like A* are well understood in theory, there's a huge gap before reaching an implementation of a system capable of robust path-planning and path-following in practice. In particular, problems like dealing with large worlds, moving realistically within dynamic crowds, pathfinding while taking into account animations, coping with the quirks of physics simulations, and providing efficient answers to spatial queries — among others.
Contributors: Julien Hamaide, David Miles, Per-Magnus Olsson.

Introversion’s AI: From Darwinia to Multiwinia with Chris Delay

Sun, 01 Feb 2009 02:39:56 +0000

Learn about the design tricks that help bring the Darwinians to life in this 1h20 interview with Chris Delay, Lead Designer and Director at Introversion — the developer of Darwinia and Multiwinia. Chris goes into details about how instinctive behaviors work and they way they brought the Darwinians to life. He also talks about implementation of the behaviors, key challenges, performance and optimization to get 2,000 entities battling in Multiwinia. The high-level strategy of the opponent AI is also explained in detail.

Crafting Animations for a Locomotion System

Sun, 25 Jan 2009 00:53:34 +0000

In this session, Alex Champandard explains how to apply animation technology to create a locomotion system that can move characters around in space. In particular, you'll find out how to create the typical idle, walking, running, jogging and sprinting motions from action games. The process will be discussed from the perspective asset design and technological constraints too. You'll learn about whether looping / aligned / synchronized animations are useful, whether they can be blended, and how to make smooth transitions.

(Almost) Everything You Wanted to Know about Game AI [Bonus, Part 2]

Fri, 16 Jan 2009 21:38:13 +0000

In this 2h bonus session, Alex Champandard talks about a variety of topics ranging from level scripting with triggers and event handlers, gameplay-friendly level design workflows, machine learning and case-based reasoning, embodiment and player-centric design, procedural narrative and story models, physics-based animation systems and more!

Near-Optimal Character Locomotion with Adrien Treuille

Wed, 07 Jan 2009 12:01:47 +0000

Over the past few years, research in character animation has made huge progress — particularly in example-based motion synthesis, a technique that uses captured animations to generate new streams of motion. In particular, a recent paper entitled "Near-optimal Character Animation with Continuous Control" from the University of Washington at Siggraph 2007 is at the cutting edge of locomotion technology. This paper shows how to continuously cross-blend between two motions to obtain near optimal locomotion.

Sandbox Release #5: Behavior Tree Implementation and Core Framework

Sun, 04 Jan 2009 18:27:50 +0000

The fifth release of AiGameDev.com's sandbox, building towards an "industrial strength prototyping environment," focuses primarily on behavior trees. You'll find the code for implementing hierarchical logic using sequences, various forms of selectors, parallels and decorators/filters. The underlying implementation is based on a task scheduler, which allows the tree to be updated efficiently and reliably over multiple frames in an event-driven fashion.

[Bonus] Modeling Non-Linear Stories with Fabio Zambetta

Mon, 29 Dec 2008 19:45:04 +0000

In this session, Fabio Zambetta discusses the process of applying hybrid control policies (HCB) that combine fuzzy logic and discrete logic to story generation. In particular, he explains how to create the AI of high-level factions that can decide when and why to behave towards each other. The masterclass looks at strategies for controlling the outcome of such simulations, and uses a few examples to illustrate how this can be done in practice.

Helios in Metroid Prime 3 with Paul Tozour

Sat, 20 Dec 2008 18:09:43 +0000

In this interview, Paul Tozour discusses his work on the AI of Metroid Prime 3, most notably the boss called Helios. He discusses the swarms in the game as the inspiration for Helios, and the various stages of the prototype. Paul also discusses the various levels of intelligence that goes into this multi-agent system, including the various forms of Helios: creature, shapes, swarm, multiple swarms, and particles system. You'll also learn about the various obstacles encountered, such as performance in collision or avoidance, and how they were resolved in practice.

S.T.A.L.K.E.R. Clear Sky with Dmitriy Iassenev

Sat, 13 Dec 2008 19:34:46 +0000

In this interview, Dmitriy Iassenev talks about the A-Life and the NPC AI behind the Clear Sky prequel to the original S.T.A.L.K.E.R. Dmitriy discusses how they managed to deal with many more Stalker NPCs in the world, how the level-of-detail system works, ways for the designers to control the outcome of the A-Life simulation, and insights into the tuning process. On the individual AI level, Dmitriy discusses navigation withing a large world, how dynamic obstacle avoidance works, and the process of generating cover locations. Dmitriy also shares his insights into the development process.

Low-Level Animation Technology

Mon, 08 Dec 2008 18:40:15 +0000

In this 2h masterclass, Alex Champandard talks about the implementation details of animation systems that are commonly used in the games industry. In particular, you'll learn about the representation of motion data as animated tracks of quaternion rotations, how skeletons are represented and how they relate to point clouds. Also, this session goes into details about how blend-trees are implemented and how they can be implemented efficiently by using separate processors.

Sandbox Release #4: Terrain Representation and Area Clustering

Fri, 05 Dec 2008 18:18:09 +0000

The fourth release of AiGameDev.com's "industrial strength prototyping environment" — a.k.a. AI sandbox — focuses on terrain representation and area clustering. You'll find a terrain graph class to manage and maintain connections between nodes in the terrain efficiently, whether these are 2D cells, 3D waypoints or even areas. This allows a hierarchical representation that is the basis of the area clustering algorithm that groups up areas together, to be used for terrain analysis or navigation.

Production & Methodology

Wed, 03 Dec 2008 00:04:13 +0000

This full report looks into the topics of production and methodology, specifically focusing on how the the AI can be improved in the process. You'll learn about finding the balance between design documents and prototypes, finding a balance between production goals and making the AI fun, how to structure the production phase and what to expect in the process, what to pay attention to best set-up a tools pipeline and take care of the content creators, when and how to incorporate playtesting feedback, and how to use QA teams to make sure the AI is the best it can be.

Automated Unit and Functional Testing

Sat, 29 Nov 2008 14:14:23 +0000

In this 2h masterclass, Alex Champandard talks about automated testing with both unit and functional tests. You'll learn about the motivations behind using automated tests, and hear about experiences of using them in practice. The presentation covers all the details from creating a test framework yourself to wrapping or modifying an existing one, how to write both kinds of tests and what workflow to use. Examples are also discussed throughout the presentation, such as testing for animation systems or behavior trees.

Building a Near-Perfect Animation System with Lucas Kovar

Mon, 24 Nov 2008 21:32:59 +0000

In this 2h masterclass, Lucas Kovar and Alex Champandard discuss the process of creating a next-generation animation system that's flexible and extensible. The underlying representation is a graph of parametric motions, which are typically created using blending-based approaches, and built using robust tools under the supervision of animators and programmers. The runtime playback section of the talk covers blend trees, transitions between states, locomotion and motion planning. To wrap up, the discussion covers how procedural and physical approaches integrate with such a system.

Testing & Debugging with John Abercrombie and Phil Carlisle

Tue, 18 Nov 2008 17:27:01 +0000

In this 2h audio panel, John Abercrombie (Lead AI on Bioshock), resident expert Phil Carlisle and Alex Champandard go through the whole production pipeline step by step and identify opportunities for improving the quality and reliability of the AI. In particular, the participants discuss design documents and requirements, asserts and logging, automated testing, runtime controls and visualizations that help identify problems, and a build pipeline that helps reduce issues and empowers the quality assurance team — among others.

Sandbox Release #3: Motion Synthesis Library

Thu, 13 Nov 2008 20:53:28 +0000

The third release of AiGameDev.com's "industrial strength prototyping environment" — a.k.a. AI sandbox — takes a major step towards better animation quality in general. It includes a library for motion synthesis based on motion graphs, improved low-level playback thanks to cascaded blend tree that can deal with n-way blends using a continuous interpolation strategy. The library is also used to automatically process animation clips to find transitions between the best frames, and will serve as a basis for future tools based on this functionality.

Automatically Computing Motion Transitions with Posture Alignment

Wed, 12 Nov 2008 02:57:53 +0000

This article looks into the process of automating the process of annotating the animations with appropriate transition points, and working out which postures are suitable for blending. This is done based on the work of Mike Gleicher and Lucas Kovar on Motion Graphs. By calculating similarity between postures using the techniques described here, many aspects of manual animation editing can be automated and the quality of the resulting motion improves visibly.

(Almost) Everything You Wanted to Know about Game AI [Bonus, Part 1]

Mon, 10 Nov 2008 15:20:36 +0000

In this 2h30 bonus session, Alex J. Champandard talks about a variety of topics ranging from AI / Animation interface, designing a layered goal-oriented architecture and the format of the orders, building systems to deal with these orders, how to integrate scripts with AI, general and AI middleware, how to build a behavior tree for group communication, implementing sports AI based on the concept of plays, finding paths from cover to cover with good combat positions, and more!

Model View Controller Pattern for Game Architectures

Tue, 04 Nov 2008 01:33:45 +0000

In this masterclass, Alex J. Champandard talks about the MVC pattern as applied to game engine architectures. Topics covered include the design of an API for the model that supports both push/pull paradigms and when to use them, creating an efficient underlying world model and abstracting it out, how to organize different controllers like physics and AI, what role the rendering plays and how to deal with interpolation and synchronization.

Goal-Oriented Action Planning

Fri, 31 Oct 2008 16:14:20 +0000

This full report looks into the process of applying goal-oriented action planning (a.k.a. GOAP) to real-time games. This report covers many aspects of the technology, including production decisions, how to approach prototypes, dealing with designers and level scripting, low-level animation integration, and more. From the implementation point of view, you'll learn about optimization, implementation tips and debugging tools. In particular, this report focuses on STRIPS, currently the most popular implementation of GOAP in the games industry, based on the A* search algorithm. Extensions such as layers of planners, and Hierarchical Task Network planners are also discussed.

Contributors: Dmitriy Iassenev, Bill Merrill, Jeff Orkin, Borut Pfeifer

Sandbox Release #2: Automated Testing & Continuous Animation Playback

Mon, 27 Oct 2008 20:55:53 +0000

The second release of the sandbox extends the previous release in a few important areas, including animation playback and blending, an automated test framework, as well as support for OpenGL rendering. Multiple little fixes and improvements were made to the underlying MVC architecture also, as well as the project settings and compilation options for more reliable and efficient builds.

Dawn of War II and Real-time Strategy AI with Chris Jurney

Mon, 27 Oct 2008 01:16:59 +0000

In this interview, Chris Jurney talks about the AI in Company of Heroes, which was extended for Dawn of War II. He discusses topics such as path-finding in dynamic environments, dealing with destruction, his thoughts on solving path-finding generally, squad movement and strategy, high-level RTS AI and developing AI for PC games.

Low-Level Animation Playback and Motion Blending

Sat, 25 Oct 2008 15:49:15 +0000

This in-depth article looks into the process of creating the foundation of a motion-capture driven animation system. In particular, it covers the details of annotating walking / running cycles, how to interpret and model the motion of the skeleton root, playing back animations in space, as well as lining them up so they can be concatenated and blended correctly.

Automated Terrain Analysis with William van der Sterren

Sat, 18 Oct 2008 19:51:23 +0000

In this masterclass, William van der Sterren goes over the whole process of acquiring annotations for a level automatically, from finding a set of waypoints that describe the level by filtering out low quality waypoints and keeping the best, to connecting them together for tactical path-finding, as well as movement annotations. A whole section of the talk is also focused on area clustering, or the process of creating a an extra layer in the navigation hierarchy to support things like squad behaviors and reasoning for groups of soldiers.

Running Motion Capture Animations

Sat, 04 Oct 2008 23:47:06 +0000

These animations are taken from a few different motion capture sessions labeled "Action / Adventure." The data includes running forward, turning left & right slightly, as well as more sudden turns and even dodge-like side steps. The clips include lead-in and lead-out time from the important cycles.

Sandbox Release #1: Procedural Block World

Fri, 03 Oct 2008 11:39:04 +0000

The first release is a fully functioning version of the sandbox, including full assets and code, that tackles the major technical obstacles. For instance, it demonstrates a procedural block world generated quickly and efficiently, which can be loaded in a few seconds. The graphics can also be disabled and the simulation run from the console entirely at a much faster speed. Characters can also be animated as skeletons with a set of motion capture clips, and displayed optionally in the 3D view.

Behavior Tree Implementation Techniques with Phil Carlisle

Sat, 27 Sep 2008 12:13:58 +0000

In this 2h30 session, Phil Carlisle and Alex Champandard discuss the programming details behind behavior trees, and hierarchical logic in general. Two major approaches are covered: the first implementation relies on modular behaviors that get updated regularly in a polling fashion. Here, all the control flow and memory management is distributed. The second approach is rather more centralized with a scheduler responsible for executing behaviors, and a blackboard that stores the task memories. The relative merits of each solution is discussed and analyzed.

Game AI Design Pitfalls for Action Shooters with Mikko Mononen

Fri, 26 Sep 2008 22:00:22 +0000

In this session, Mikko Mononen discusses his experiences and presents 5+1 pitfalls that developers fall into when designing game AI for shooter games. The talk discusses avoiding complex solutions when possible, not necessarily simulating characters and their brains accurately, striving towards believable behaviors rather than realistic ones, embracing special cases rather than mimicking the elegance of physics simulations, not constraining design to the capabilities of a path-finder, and taking into account player expectations during design.

Terrain Analysis & Reasoning

Wed, 24 Sep 2008 17:23:37 +0000

This report looks into the process of creating useful annotations for terrains, whether manually by designers (and provides tips for helping the process go smoothly) or automatically using algorithms (with advice for how to approach the problem). In the second part, terrain representation is discussed in terms of finding the balance between a generic solution that supports a variety of reasoning tasks and special-case data-structures. Finally, reasoning with the terrain representation is discussed for individuals as well as groups.

Contributors: Kevin Dill, Sergio Garces, William van der Sterren, Paul Tozour.

[Bonus] Next-Gen Animation for Games and AI with Mike Gleicher

Tue, 23 Sep 2008 12:24:27 +0000

In this talk, leading animation researcher Michael Gleicher takes a tour of the field of motion synthesis, locomotion and character animation. In particular, Mike discusses ways to improve I.K. using local warping around the constraint frame, implementing a skeleton based on point clouds that allow for a little stretching to overcome I.K. problems, interfacing between AI / Animation interfaces by taking into account steps and natural paths while planning, and finally using path-editing to avoid the expense of motion clips and blending where possible.