The Paris Game AI Conference 2009 took place earlier this month on June 10th and 11th, co-organised by AiGameDev.com and the CNAM where it was held. In total, almost 200 people from Europe and beyond attended this two day standalone event — with around 170 attendees per session on average. The event was based on last year's innovative workshop that we held for the first time after another conference in Paris, although this year was an complete upgrade in every way: the presenters, content and location were better in all aspects!

The whole event was made possible thanks to Stephane Natkin, director of the CEDRIC research lab, and Axel Buendia, CEO of the middleware company Spir.Ops. The rest of the organisational committee was pretty much only myself (Alex Champandard) and Petra (Mrs AiGameDev.com) — which explains the last few quiet weeks as we recover from the hectic months of organisation...

In the following post, you'll find the original slides for the presentations, my personal takeaway and executive summary from each session, and some references as appropriate. The recordings will take time to prepare edit, but all audio and video will be published over the next four months in the AiGameDev.com Premium area. (Sign-up here if you'd like to see this again next year!)

The coffee breaks on Wednesday were sponsored by Havok. We'd like to thank Havok for their continuing support of AiGameDev.com. Their company has offices in Dublin and San Francisco, and recently released their Havok AI™ solution to complement the existing packages like Havok Behavior™. For details, don't hesitate to contact them!

Photo 1: View from the audience in the amphi-theater during the HTN and Planning panel.

Table of Content

On this page, you'll find the coverage of the following sessions:

1. State of the Industry

2. Emotions in Game Characters

3. Coordinating Agents with Behavior Trees

4. Squad Behaviors Discussion

5. The AI for Killzone 2's Multiplayer Bots

6. Multithreading AI

7. The Art of Multithreading

That was day one, and day two follows:

8. Advice and Tales from the Trenches

9. Coordinating Unit Maneuvers Using HTN and A*

10. HTN and Planning in Games Discussion

11. Interactive Narrative Generation and Story Telling

12. Discussion about Emergent Stories in Games

13. The Racing AI in Pure

14. Game Characters from Animation to AI

15. Building Navigation Meshes by Voxelization

Other Coverage

There were many active bloggers and game development enthusiasts in the crowd who took notes during the event. You can find them here:

• Stefan Maton's Feature on GameDev.net,

• Andrew Armstrong's Coverage on his own site,

• Gonçalo Lopes' Notes in our forums.

Also, special thanks to everyone who helped during the day, and Phil Carlisle for his invaluable support and contribution to the event.

State of the Industry

The conference started out with an informal ~30 minute session where I introduced all the speakers, and asked them about the current challenges of AI in the games industry. This session certainly felt experimental, but contributed heavily to the friendly atmosphere that persisted throughout the event — and many attendees appreciated that compared to other conferences.

Photo 2: Alex Champandard.

The basic takeaway from this session was a theme that was left open at the end of the AI Summit. At the end, a veteran programmer called Brian (who worked on Starcraft's pathfinding system at Blizzard) asked a question along these lines:

“If you had to sum up the last ten years in game AI in one sentence, what would you say?”

Obviously, it's a hard question and the answers that were given at the time weren't particularly conclusive. Brian mentioned this at our AiGameDev.com Launch Party that evening, and I gave him the following answer — which he seemed much happier with:

“We've mastered the technology to the point where the major problems we have now are primarily in production and design.”

Of course, this doesn't mean there's no innovation to be done in technology, but multiple sessions emphasized the importance of design and its interplay with the technology.

Emotions in Game Characters

People: Phil Carlisle

Description

Phil presented an 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’ll also discussed this from a practical perspective using his work as the basis, outlining the techniques that are ready to be applied.

Photo 3: Phil Carlisle during Q&A.

Takeaway

Phil got much more time to share his ideas than the last time I heard him speak, and he's made visible progress since then. Though he could have gone on for another 45 minutes!

• There are various emotional models, but they all boil down to a set of floats!

• The usual sense / think / act routine needs to be rethought for including emotions.

• There's a big architectural diagram that most researchers use to implement their emotional systems.

• Phil's behavior tree approach uses a blackboard, very similarly to the Killzone 2 AI presented later.

Slides

Emotions in Game Characters
Phil Carlisle
Download PDF or PPT

References

Coordinating Agents with Behavior Trees

People: Ricardo Pillosu

Description

Recently, the concept of Behaviour Trees has been gaining traction and was used in games like Spore or Halo 3. Crytek has adopted and developed this technology to also coordinate different agents in complex situations. After a introduction to Crytek's perspective on Behaviour Trees, Ricardo provided examples on how this concept can be used to simulate group tactics.

Photo 4: Ricardo Pillosu interacting with the audience.

Slides

Coordinating Agents with Behavior Trees
Ricardo Pillosu
Download PDF or PPT

Takeaway

It was fascinating hearing about Ricardo's behavior tree innovations in contrast to last year's Paris '08 Workshop, when Ricardo wasn't yet fully convinced about BTs. But as a testimony to Crytek's team, and the power of behavior trees, this year he talked about extensions of their implementation.

As for key points I took away from this:

• Ricardo's approach deals mainly with coordination via timing, enabling and disabling branches on demand.

• Building more complex squad maneuvers with this approach would require distributing additional information to behaviors using a similar centralized manager.

Ricardo also mentioned simplicity as an explicit goal, though in my mind the complexity is in the problem itself and not the solution. So, there are different ways to achieve this in practice: either hide the complexity from the designer and let programmers do the work, provide a limited set of parameters and sliders to control the behaviors, or use smaller building blocks and combine them as necessary. All of these tricks are generally useful, but my favorite is the third as it results in more modular code — even though that's not what I'd always expose to designers.

References

Behavior Trees for Next-Gen AI
Alex J. Champandard
GDC Lyon 2007
Watch Online (free registration required)

Squad Behaviors Discussion

People: Florent Dotto, Mieszko Zielinski, Mikko Mononen, Ricard Pillosu

Description

This Q&A session follows Ricardo's talk; it features a panel discussion with Mieszko and Mikko, talking about squad behaviors in general. What are the biggest challenges and key points that we need to address going forwards? How can we improve the behaviors and make them easier to author?

Photo 5: Florent Dotto, Mieszko Zielinski, Mikko Mononen

Photo 6: (Mikko Mononen), Ricard Pillosu

Takeaway

Since I moderated this panel, many of the questions were very relevant to me :-) So I got a lot out of this session, in particular:

• Intuitive Control — Mikko mentioned an idea he had of using war maps, like sketches drawn in the sand indicating how a battle should take place. Obviously this would be a great interface for players to interact with squads, though the bulk of the work would be in the pattern recognition and not the group logic!

• Cheating — Mieszko pointed out that it's relatively simple to make a squad behavior that doesn't cheat, simply sharing information from individual members. I suggested that having "embodied" individuals that don't cheat is possibly enough, then you can have the squad give out orders knowing how to maximize player satisfaction and using more information if necessary.

• Top-Down — There are two choices for building group behaviors: implicit coordination based no shared information (bottom-up), and explicit ordering (top-down). Mikko mentioned he preferred the top-down approach.

• Obvious Behaviors — Everyone emphasized the need to for making the group behaviors over the top, including audio queues and gestures. These can even work on their own without group behaviors as in F.E.A.R. In Crysis, a lot of time was spent making sure the person making gestures was visible on screen!

One fascinating topic we didn't have time to address, is building a mixed squad with NPCs and human players together. The challenges here are two-fold, trying to understand what the player is doing and adapting to that, as well as behaving in a combat situation context sensitively.

The AI for Killzone 2's Multiplayer Bots

People: Alex J. Champandard, (Tim Verveij), Remco Straatman

Description

This talk will discuss the implementation of bots in Killzone 2’s online and offline multi-player component. We will discuss the overall hierarchical AI framework, the way individual bot behaviors such as badge usage are implemented using our HTN planner, how individual behaviors mix with the overall objectives in multiplayer modes and how we use data acquired at run-time to influence the tactical decisions.

Photo 7: Remco Straatman, Alex Champandard

Slides

Killzone 2 Multiplayer Bots
Remco Straatman, Tim Verveij, Alex Champandard
Download PDF or PPT

Takeaway

I worked on this project and gave this talk, so my key points made it into the presentation and slides. However, a few are worth emphasizing:

• HTN Planning — This conference will mark the advent of Hierarchical Task Networks. It's becoming increasingly hard to make a case for non-hierarchical STRIPS-like goal-oriented planners.

• FPS & RTS AI — The question of using techniques from RTS games in FPS games came up during multiple GDC panels this year. The multiplayer bots in Killzone 2 made a big stride in this direction!

• Incremental Evolution — Remco mentioned that the team has been working on the AI codebase over numerous years and multiple projects. I think this is very much obvious in the game.

References

HTN Planning: Complexity and Expressivity
K. Erol, J. Hendler, and Dana S. Nau.
Download PS

SHOP: Simple Hierarchical Ordered Planner
D. Nau, Y. Cao, A. Lotem, and H. Muñoz-Avila.
View Online

Multithreading AI

People: Bjoern Knafla

Description

Bjoern will provide an overview of the concepts and techniques that are the most commonly used for parallelizing code in the games industry, and present some of his own results applying multi-threading to a large crowd simulation.

Photo 8: Bjoern Knafla

Takeaway

I'll combine these notes with the following panel too. Here were my notes:

• Design for Memory — When paralellizing code, if you don't think about your memory accesses your game may end up being even slower!

• Rethinking OO — Object oriented design doesn't map directly to nice multi-threaded code. You'll almost be better off thinking at the plain C level!

• Clean Code — There are many patterns that will help you parallelize code, but having a nice codebase that doesn't involve a large Entity.h file is a good thing!

• Incremental — Don't try to do everything upfront, take your current code and move it to separate threads one piece at a time.

Slides

Parallelization of Game AI
Bjoern Knafla
Download PDF

The Art of Multithreading

People: Julien Hamaide, Markus Mohr, Bjoern Knafla

Description

Bjoern's presentation will be followed by a panel discussion with Julien and Markus that looks into some of the more practical aspects of game AI multithreading. Desining and architecture for concurrency can be a bit of an art, so be prepared for more subjective and possibly controversial opinions!

Photo 9: (Alex Champandard), Markus Mohr, Bjoern Knafla, Julien Hamaide

Photo 10: Bjoern Knafla, Julien Hamaide

Advice and Tales from the Trenches

People: Eduardo Jimenez, Phil Carlisle, Mieszko Zielinski

Description

In this interactive discussion panel, these veteran game developers will tell the story about how they got started, share some of their experiences from working in industry, and give advice to developers who are looking to get into the industry as AI Programmers.

Photo 11: Phil Carlisle, Eduardo Jimenez, Mieszko Zielinski

Takeaway

There were some interesting stories and perspective shared, but I'll save those for a separate blog post. Here's some advice for people trying to get into industry:

• Generalize — Even though you're likely to join large teams and work on specific problems, having general knowledge in game development and mastery of C++ will help you being able to solve anything that's thrown at you.

• Go Indie! — Everyone emphasized that the best thing you can do for your career is to build a game yourself. Phil also expressed surprise that so few students are becoming independent developers.

• Be Lucky? — This one I found rather funny. Everyone on the panel, myself included, mentioned that they'd first got into the industry with a bit of luck... So make sure you're in the right places at the right time!

Multi-Unit Planning with HTN and A*

People: William van der Sterren

Description

William's presentation will discuss the application of HTN and A* to help plan and coordinate groups of units. In the context of a turn-based strategy game, he’ll show how a planner can be used offline to create stimulating new scenarios for current games without the need for manual scripting.

Photo 12: William van der Sterren

Takeaway

This session was enlightening, for multiple reasons:

• Mission Design — Using AI to automatically help design missions is a hot topic in the game development community, particularly since Left 4 Dead. It can add lots of depth and replayability to the same game content.

• Web Services — Having the AI as a separate web-service I think is an idea that has potential, similarly to MMO clusters. I'm amazed Ruby's performance was good enough for this!

• A* Heuristic Magic — There's no getting away from the fact that A* based solutions rely heavily on black magic. This is the case also to get good performance, as with any STRIPS-like solution.

Slides

Multi-Unit Planning with HTN and A*
William van der Sterren
Download PDF

HTN and Planning in Games Discussion

People: Remco Straatman, William van der Sterren

Description

The Q&A session following William's talk will include an informal discussion including Remco about the benefits and risks of using HTN in games, provide advice for developers keen to look into this approach, and look forward for where to move next.

Photo 13: (Alex Champandard), Remco Straatman, William van der Sterren

Takeaway

The topic of HTN Planners was one of the biggest ideas to come out of the Paris Game AI Conference '09. They combine many aspects of behavior trees along with the benefits of planning to reduce the authoring burden. You'll be hearing more about these in the future.

It was also interesting to hear Remco's perspective on the performance challenges of getting the HTN Planner to run in realtime on the PS3, including using a depth-first "ordered" search.

Interactive Narrative Generation and Story Telling

People: Daniel Kudenko

Description

Daniel will be providing an overview over approaches to Interactive Drama, highlighting and summarizing the state of academic research on the subject, present an overview of selected systems, and point to potential avenues in industry collaboration to help you figure out where to start looking.

Photo 14: Daniel Kudenko

Slides

Approaches to Interactive Drama
Daniel Kudenko
Download PDF

Discussion about Emergent Stories in Games

People: Axel Buendia, Vincent Corruble, Daniel Kudenko

Description

Researchers in the field of procedural storytelling will answer questions from developers, and explain how academia would tackle many of the narrative challenges faced by modern games. Axel will act as the industry connection using examples from games like Far Cry 2, GTA 4 and S.T.A.L.K.E.R.

Photo 15: Daniel Kudenko, Vincent Corruble

Takeaway

For this session, my biggest takeaway came from a comment in the audience. It's the idea of using a dual AI representation, which includes character and an actor. One of them is responsible for making sure the story elements are chosen according to a pre-defined personality, and the other is responsible for assuring a certain basic level of human responsiveness.

The Racing AI in Pure

People: Eduardo Jimenez

Description

Eduardo will explain how the AI for riders is designed to prevent the feeling of rubber band AI that’s symptomatic of many racing games, and will present the solution to the problem applied in Pure which falls into the increasingly popular category of “experience management” for games.

Photo 16: Eduardo Jimenez

Slides

Race Script: An Alternative to Rubber Band AI
Eduardo Jimenez
Download PDF or PPT

Takeaway

I very much enjoyed Eduardo's presentation, as it shows the importance of design in the whole process of creating critically acclaimed AI. It also falls into the domain of experience management, which is the area to be involved in at the moment! Some notes:

• Groups — Eduardo made it clear from the start that having the AI form groups with the player was a design goal, and this made the game much more fun.

• Skills — Many games actually include the idea of "AI skills" and Eduardo explained how the idea of game balancing could be done in other genres with a similar approach.

• Player-Driven Design — The idea of combining a player-centric approach with mostly autonomous AI is something that every game developer needs to address.

Game Characters from Animation to AI

Description

This panel brings together an artist/animators, and animation programmers/designers to discuss the challenges of next-gen animation. How can we improve our current animation workflows to get around the usual motion capture problems? How can we improve the quality of characters without having gigabytes of motion capture?

Photo 16: (Christiaan Moleman), Xavier Dolci, Phil Carlisle, Julien Hamaide

Photo 17: Christiaan Moleman

Slides

AI Characters from Animation to Behaviour
Christiaan Moleman
Download PDF or PPT

Takeaway

This session was setup based on the increasing need to know and understand character animation to build good AI. AI is also the best ally that animators have for improving animation quality. I'm a part-time animation geek, so I got a lot out of this session:

• Gaze & Head Tracking — While most AAA games already use some form of eye and head movement, there's still a fair amount to be done in this area. In particular relating to the following...

• Animation Timing — One thing that Christiaan emphasized is that animation is really all about timing. Things like the muppets and the fraggles are more expressive than game characters because they have timing.

• Design above Technology — A recurring theme was that we have already lots of technology that can help us build more expressive characters. The question is more about finding situations and cases where this pays off.

• Multi-Disciplinary Teams — Based on the panelists' experience, having AI and animation programmers work alongside animators helps a lot, and integrating everyone into a "Character Team" made a big difference.

Building Navigation Meshes by Voxelization

People: Mikko Mononen

Description

Mikko will talk about an open source R&D project of his called Recast. The project is based on the idea of converting polygon soups into navigation meshes that can be used for pathfinding in space. He’ll present his approach step by step and discuss the benefits of this approach compared to other techniques.

Photo 18: Mikko Mononen

Takeaway

I've seen Mikko's work and masterclasses in the past already, so my takeaways were mostly not technical, instead:

• Bouncy Lines — In the latest version of Mikko's library, he uses arcs as connections between nodes to better visualize the links between areas.

• Visualization — It struck me during the presentation how important debug visualizations are, and how useful they can be for explaining concepts.

Conclusion

Seeing nearly 200 people passionate about game AI come together during these two days was incredible, and certainly one of the most rewarding moments of my professional career. A very large number of programmers from game studios around Europe attended including Ubisoft, Guerrilla Games, Arkane, Recoil Games, People Can Fly, Crytek and more. On top of that, a majority of game AI middleware developers were in the audience, including Wednesday's coffee break sponsors Havok and of course Spir.Ops — with only one notable absence from Germany.

What's particularly amazing is that everyone came especially to hear about artificial intelligence in computer games, and not just because this event was an appendix to another bigger conference which they happened to attend. (This was the case last year for our Paris Game AI Workshop '08.) On top of that, we were extremely lucky and thankful for the world-class lineup of speakers, who came not to get a pass to a conference but because they feel genuinely passionate about their topic. This passion and friendly atmosphere was apparently one of the most unique things about this event for attendees.

To be honest, this event was a lot of work to prepare and organize — more so than Petra & I expected. But based on all the feedback, it's been incredibly valuable for both the European community and for game developers outside of the U.S. looking for a more a more accessible industry-oriented conference on game AI. We have pages full of things to improve, and the event will definitely return next year. Some major things will change, but this event will be back next year!

If you found any of this interesting, you can get the full edited recordings over the next few months as part of AiGameDev.com Premium. Of course, you get all the other benefits of our members-only content too! Sign-up here.

Photo 19: View of the audience in the CNAM amphi-theater.

Comments and Feedback

“Congrats once again on pulling the conference off: it was by far the most inspiring work-related event I've ever been to. I hope it will become a regular event.”
— Remco Straatman, Lead AI Programmer, Guerrilla Games.

“What a great event. Focused, consistently high quality material, inspiring presentations. Well done to everyone involved!”
— Thomas Young, Founder, PathEngine.

“This conference was a real deal — cutting edge presentations and experienced speakers. My take away list from this one is impressive! I feel this event can really push Game AI forward!”
— Mieszko Zielinski, AI Programmer, People Can Fly.

“I really hope this will become a regular event! I will definitely try to attend next year again. It was really inspiring and useful to see implementations of planners and BT's for example. Emotions in characters was a real eye-opener for me. We will start and try to implement some of these things in our game as fast as we can. Thank you!”
— Joakim Wahlström, Gamplay-Programmer, Fatshark, Sweden.

“Awesome conferences, where professionals are sharing their knowledge, and their passion. It's quickly going to be the reference in the AI community.”
— Xavier Dolci, Lead AI Programmer, Ubisoft Montpellier.

“Very interesting conferences, covering a wide array of subjects (wide enough to be sure that everyone learned something during these two days). I'd definitely want to be there for a second edition...”
— David Steinberg, Senior AI/Gameplay Engineer, Darkworks.

“Great talks, real experts and real solutions for real issues in game AI. Very very interesting.”
— Guillaume Chatelet, Lead Programmer, Mikros Image.

“The very down-to-earth, pragmatic approach of the presentations and panels succeeded in making all the various topics much more approachable. In the end of the day, we all want to apply good ideas to our own games in practice, and I think I can do just that with virtually any of the communications presented at the Paris Game AI Conference '09.”
— Gonçalo Lopes, Software Engineer, YDreams.

“The conference gave me a comprehensive insight into new approaches and solutions for problems I also have been dealing with. Going there will definitely reflect in our project and daily work. This is an event you don't want to miss.”
— Daniel Kollmann, AI Programmer, YAGER Development.

“This conference was very useful, with a lot of subjects being directly applicable in professional projects. Making it also a free conference is also something really nice, as everyone can intend it, whether there student, or belong to a small or big company. Sharing knowledge between everyone is the best step to advance quickly and make better games!”
— David Partouche, AI Programmer, Eden Games

“A very interesting and inspiring event. I've learn a lot and met great people i'm eager to work with in the future!”
— Clodéric Mars, R&D Software Engineer, Golaem

“It was two days packed with diverse and interesting topics. Not only that it was also a great place to meet intersting people from the Game AI-Field. Thanks Alex, I will definitely attend the conference next year!”
— Denis Schluchter, AI Programmer, YAGER Development

The game AI & navigation middleware industry is moving very fast these days; even we're struggling to keep up! Today, PathEngine released its latest SDK and here at AiGameDev.com we've been sinking our teeth into it to check out the latest developments. In this article, you'll find a behind the scenes description of what's inside the release and how the features are implemented. On top of that, you can find the demo binary and the source code for samples within the "testbed" release available from their download page.

The key features of this release, discussed in this page, are the collapsible formations (including a video), support for both automatically generating navigation meshes based on BSP-geometry processing or voxelization (with a comparison), and finally support for run-time off mesh connections to allow agents to jump between arbitrary points in the world.

NOTE: Thanks to Thomas Young for giving us access to a pre-release build of the latest SDK, and for letting us post some exclusive details about the technology. PathEngine is a sponsor of AiGameDev.com.

Collapsible Formations

This release of PathEngine comes with an advanced sample that shows how formations can be handled. This behavior is not built into the library at the low-level so you can change the way the formations behave via game code. As it is now, each sub-formation always collapses to go through narrow gaps and doesn't considers taking detours to gain some more clearance. As Thomas Young points out, in some situations this would look more natural.

A recording of the demo is available as a video just below. (Click here to view it.) You can also find the majority of the source code for this sample (excluding the library code) in the testbed release available on the PathEngine site.

Audio & Video Screencast

NOTE: The video above is in 720p High Definition. Click on maximize to watch it full screen.

Technical Details

The default behavior in this demo is designed to have a very low update cost per individual agent, a minimal number of long distance pathfinding requests, using pathfinding based on the size of a single agent, and allowing the group to adapt to obstructions. Here's how it works in practice:

1. A path is planned according to the size of the maximum size of an individual unit in the formation, rather than the formation size.

2. The corridor around the path is used to calculate the ideal formation width, and positions available.

3. Sub-formations are created based on the distance between entities, so occasionally groups split up to move around obstacles.

4. Only one long distance pathfinding request is used per sub-formation, which reduces the cost of searching for paths.

5. While following the path, there's a piece of code responsible for organising movement orders within sub-formations using local queries only.

Thomas Young points out another few interesting details about this demo:

“Local, short distance pathfinding requests are currently used to move to start positions, but in most cases these are not actually required, and will early out on a line collision test direct to goal.

This is a good example, I guess, of the extreme usefulness of a paired pathfinding/collision setup, and it should be straightforward to apply this kind of approach to any situation where paired collision and pathfinding queries are available! ”

Voxel & BSP Processing

Voxel-based approaches to processing polygon soup have been gaining traction lately. However, compared to solutions based on processing polygonal geometry, the decision of which to use is not so clearcut. PathEngine's latest release includes both, so I took a few comparison screenshots to visualize the differences in practice.

In the followings images, you'll see the following from left to right:

• Blue — The original input geometry with polygon outlines.

• Grey — Walkable surface extracted with voxel processing.

• Green — Same walkable area extracted using BSP processing.

Here are the screenshots. (Click to enlarge.)

Screenshot 1: A fence example, showing the aliasing introduced by voxel solutions compared to perfect geometric processing.

Screenshot 2: Example scene with few differences. The voxel floor on the bridge is not as accurate.

I asked Thomas Young (developer of PathEngine) about the distinction between the two. Generally speaking, where do polygon-based approaches shine over voxel based approaches, and how would you decide which to use? Here's what he replied:

“The main point here is that BSP 3D processing has no aliasing. With voxel based approaches, if you have something like a doorway, the actual mesh width at this doorway can vary by a factor on the order of the voxel size being used, and so this is then something that needs to be taken into account if you want to guarantee passability for pathfinding agents — either by reducing the agent shape used for pathfinding, or by modelling all your doorways a certain amount larger than the actual physical agent size!

And then, apart from issues at obstruction boundaries, the BSP 3D processing also provides a much more exact ground representation. Being able to quickly get hold of Z values for agent rendering position is nice, but is something that can potentially be handled by other engine components if required. More importantly, perhaps, is the ability to convert things like content position markers to pathfinding configuration space, absolutely robustly. when you have large numbers of positions to work with, and don't want these to sometimes be assigned to the wrong piece of pathfinding ground then the quality of ground representation can become an important issue.

(Remember that with PathEngine we don't search directly through the ground meshes polys, so while representing ground mesh surfaces more exactly does mean larger ground mesh size, this does not then directly affect pathfinding performance.)

On the other hand, the extra precision comes at a cost, and having really fast processing times, without needing to do stuff like simplifying geometry or marking stuff up as solid objects, can just be that much more convenient. The great thing is that both content processing methods operate on exactly the same source data representation, and spit out exactly the same run-time mesh format, and so it is possible to switch between approaches without making any changes either to the input content data, or to run-time pathfinding code.”

If you have a commercial project, you can request an evaluation for the content processing system on their site by filling in a simple form.

Runtime Off-Mesh Connections

In practice, games with complex navigation will often need runtime changes to the underlying navigation graph. For instance, jumping down from or onto a moving platform can only be done when the platform is accessible from the nearby ledge.

PathEngine already supports these kinds of free form connections, but they were extended for this release:

“This feature is based on essentially the same idea as the off-mesh connections in previous releases, but with the difference that connections can now be completely specified at run-time if desired.”

• Feature Overview: Off-Mesh Connections

• Working with Off-Mesh Connections in the SDK

Summary

If you're interested in these demos and the sample code, you can download and access the SDK in the public testbed release available from the PathEngine download page. This also gives you access to most of the collapsible formations source, as well as a binary for you to experiment with.

Congratulations to the PathEngine team on this latest release!

One approach to machine learning that's getting more attention these days is learning by example (also known as imitation). Not only are there more academic papers on the subject, but parts of industry and middleware companies are also turning towards this kind of ML for answers. Will Wright recently said that the "Holy Grail is crowd-sourcing the algorithms, AI, and procedures in the game" and Jeff Orkin retired from the comfort of his AI job at Monolith to research data-mining gameplay sessions.

Imitation learning is appealing because it puts more control into the hands of the designers, by considering them as trainers who provide example behaviors for a system to learn from. Compared with other solutions, the AI can make fewer assumptions about the kind of results desired, so because there's less room for error it seems to be a good fit for the games industry.

Going beyond academic prototypes, there aren't many developers applying these ideas into commercial games — with the notable exception of TruSoft, makers of behavior capture middleware (and sponsors of AiGameDev.com). What follows in the article below are video highlights from their Artificial Contender solution (see this page for more), and two blog posts that I previously wrote about the system, along with my most recent thoughts.

NOTE: This weekend we'll be running an public session about behavior capture with Iskander Umarov, Technical Director on Artificial Contender (a behavior capture middleware), going over the general principles of learning by example, comparing the different solutions available as well as related technology, and discussing how it can be applied to a variety of games ranging from sports to combat training.

The online presentation this weekend and this article are technically sponsored by TruSoft. However, the open session will cover the behavior capture technology and its applications in general. I have to admit I spent 1h43 talking to Iskander in the pre-interview not only because it's a fascinating topic, but because he's willing to answer all questions on the subject!

Artificial Contender and Behavior Capture

This section was originally published via my personal blog on July 11th, 2006. I've made some minor edits since then, added inline comments also, and TruSoft let me repost some of the videos (see them on the site).

The world cup is over (with a somewhat disappointing ending), but I want to talk about some interesting football-related technology before everyone moves on. I just received news of a new AI SDK for games called Artificial Contender, developed by TruSoft. This middleware allows game developers to add behaviour capture into their games, and has been applied successfully in the making of Sony's This Is Football 2005.

Screenshot 1: This Is Football 2005.

There are a few demos on the site, including videos of gameplay, tools, and a promotional white paper — but you have to register for them. If you watch the videos, you'll see a rather familiar English football team conceding a few goals, and trying to make up for it by hoofing the ball forward. Except in this case, it's entirely the desired behaviour! The designer used such long passes during training, whereas the Brazilians use shorter passes and dodging runs. Anyway, TruSoft don't give away too many interesting details on the site (as you may expect since they're selling a product), but enough to get a good overview of the product. The system is based on a combination of technology: a directed graph that models the behaviour policy, and a tree-like data-structure and index the captured behaviour samples. Informamlly, the graph stores the samples and the tree provides abstractions for situations.

At the base, there's a training mode that allows the designer to record a series of situation → action pairs. All the behaviour recordings are combined into a "directed semantic graph" (obviously, nodes are situations and edges are actions). To compare this with motion capture solutions, individual training runs made by the designers correspond to single mocap clips, and the semantic graph is analogous to a move-tree or motion-graph, built by combining similar animation poses into a single node.

Screenshot 2: Situation Graph structure used by Artificial Contender.
View Original (TruSoft.com)

To help the system create general graphs from individual trials, there's a database back-end that stores the training samples and allows them to be queried, e.g. find situations similar to this. The graph is created on the fly within the game, and a database — in the traditional sense — is only used to fine tune the system's performance. I presume the data-structure is similar to R-Trees with a hierarchical index, which they call generalization trees. An important feature that R-Trees provide is they work in n-space, assuming it's possible to obtain a measure of similarity of two situations. The tree can thereby group similar situations under nearby leaf nodes. This makes it possible to build the semantic graph like the motion graphs are built: by merging similar situations together into one node (though with motion capture, this is much easier to accomplish).

Screenshot 3 The AC Viewer, View Original (TruSoft.com)

In practice, it seems the following steps are involved to integrate Artificial Contender into a game:

1. Model all possible sensors (inputs) and actuators (output) of the AI by using an API provided by the SDK.

2. Manually create a hierarchical model of the possible game situations, which allows the algorithm to create zoom levels for the data using generalisation trees.

3. Integrate the AC library into the game engine, and make its functionality accessible to the designers from within the game.

4. Get the designers to play the game in a particular style, and then train the AC on the sampled data.

5. Last but not least, work out a sensible QA plan for testing the resulting behaviours, and apply it until the results are satisfactory!

Overall, this seems like a solid combination of technology, delivered in a well thought-out package. One part that stands out is the use of reinforcement learning, which is mentioned a few times in the white paper. The idea is that NPCs get positive reinforcement for achieving goals, and in the future choose a course of action that increases the likelihood of reinforcement. Intuitively, this seems like an opposite solution to behaviour capture, which does not give NPCs much autonomy in deciding what to do but instead "plays back" a similar training sample. Apparently, the use of RL is optional in the AC product; it helps fine tune the behaviour policy and can provide goal-directed behaviour. This combination of RL with the unsupervised learning algorithm described above allows AC to get around some typical problems with behaviour capture.

NOTE: I was originally skeptical of the reinforcement learning when I wrote this, here's a sentence I removed: "On top of that, RL in itself is an exotic choice for game AI middleware, as most implementations are often not very transparent to designers, and in my experience not as reliable as goal-oriented action planners — among other possibilities." Both my opinion on the subject and the state of the industry has changed; RL is turning out to be a very pragmatic choice to get around the challenges of manually tweaking variables, and it scales better where planners have since been shown to struggle.

From a production point of view, from the features mentioned on the Artificial Contender site, I think one is particularly valuable right now in the games industry today: designers are involved directly without having to tweak scripts, and early on in development. I don't believe such middleware will save a substantial amount of time in development, but it'll mean that time is spent (better) elsewhere — notably integrating, prototyping with- and testing Artificial Contender.

It'll be interesting to watch this product in the future; I'm curious if they'll just get bought out by a large publisher of sports franchises, or if they'll manage to find a way into the mainstream market and apply their solution successfully to other games. I expect TruSoft's consulting services will be an important part of making that happen; it'll take a lot of on-site experience with AI systems in general, and this product in particular to get something good out of it. I think those are the necessary conditions for designers to start tackling much harder problems.

Interview with Iskander Umarov

This section was published about a month after the text above on August 8th, 2006, also via my personal blog. The video is also a new addition though, showing Artificial Contender's tools and underlying representation.

NOTE: Everything you see here is available as part of AiGameDev.com Premium. You can sign-up right here, and there are bonuses for signing up this week — whether you're an individual or a studio.

First, I'd like to extend a warm welcome to new readers who just discovered the site via recent features and subscribed to the feed. (You did find the RSS didn't you? :) There are even more cool articles already lined up for the next few days as we go into launch week...

Unless you've been stuck in the same finite state for the last month, you probably know we're re-opening the AiGameDev.com Premium for new Members in about 12h. You've also no doubt noticed all the extra content on the site since we relaunched — possibly even wondering who put those red crowns everywhere, and what's hidden behind those pages.

Here's the answer, watch the video below and find out everything now. It's the smartest move!

AiGameDev.com Premium Membership is...

1. Designed to help you apply artifical intelligence to improve your games (for strategy, behavior or tools) as well as build more believable characters (human or not).

2. A multimedia experience combining video & audio, illustrated reports, interactive sessions with whiteboards plus high-quality recordings, as well as source code samples.

3. An hybrid online program between training and consulting, to bring you up to speed in fields you're not familiar with and help you push the limits in other areas.

Sneak Peak Behind the Scenes!

Going Live on May 6th, 2009

I'll start with the most important information first. The exact time for the re-opening is 11:00 Pacific, 14:00 East Coast, and 18:00 Central European time. You can watch the countdown on the launch page. When the countdown hits zero, refresh the page and you'll see two buttons for signing up: one for Individuals (non-commercial) and the other for Studios (companies only).

When you sign-up in 12h, you'll basically get 3+1 months of membership (automatically recurring) as well as access to all the existing sessions. In summary, here's what you get:

• Previous Sessions — Over the last 8 months of running AiGameDev.com Premium we've collected over 45 full-length features like masterclasses, interviews, articles and tutorials. All this library will become available to you instantly as soon as you register as a Premium Member.

• Next Three Months — On Sunday May 10th, there's a public masterclass about Behavior Trees for Action & Combat AI (subscribe to the thread to be notified in advance). In June, we'll be running the Paris Game AI Conference '09 and releasing the videos online in the Premium Area incrementally.

• The AI Sandbox — This is the codebase we use to write samples and demos illustrating key points. For example, see our demo of HPA* pathfinding on a Counter Strike map, and our animation planning on a Motion Graph prototype.

Bonuses & Fast Movers

For the whole week of the relaunch, if you sign-up to AiGameDev.com Premium you'll receive the following bonuses:

• Recast Navigation Library by Mikko Mononen — This library is a R&D project that transforms arbitrary polygon soups into navigation meshes, and provides hierarchical pathfinding over the whole representation. The code is written in low-level C++ and designed to be integrated into games as a navigation solution.

• Future City Model from Procedural.com — The CityEngine team modeled a detailed version of Manhattan in 2259 inspired by the Fifth Element. You can get your hands on the 3D models to experiment with large scale pathfinding and writing the AI simulation for city environments... Challenge extended!

For the Individual (Non-Commercial) packages, you can earn the following FAST MOVER BONUSES if you join quickly:

1. First 50 People — If you sign-up for the Premium Membership within the first fifty people when we go live, you'll get 20 minutes consulting time with Alex J. Champandard, contractor on Killzone 2's Bots and previously Senior AI Programmer at Rockstar Games.

2. First 24 Hours — Anyone that registers within the first day of going live will receive a PDF report with 150+ tips collected from Indie and AAA games, both in the design and programming departments.

If you apply for the Studio (Commercial) packages, these fast mover bonuses are available for the whole 7 days after the launch.

Frequently Asked Questions

Question: What's the difference between "Members" and "Insiders"?

Answer: If you're already registered on the site (free) and have access to some of our content for no-cost, then you're what we call an Insider. This will not change! What's happening this week is access to our best material for paying members, which you can easily upgrade to if you have a credit card nearby!

Question: Do you support alternative forms of payment than Visa and Mastercard?

Answer: For the individual membership you have the choice between Visa and Mastercard only. If you sign-up for the commercial memberships (Silver and above) then you can arrange other forms of payment if necessary. Contact us directly by email at <members at AiGameDev.com>, for instance for payment via Bank Transfers.

Question: I'd like to subscribe for a whole year; is there a yearly payment option?

Answer: No, we currently provide only quarterly packages. Those of you that mentioned you'd like to support the site, then don't hesitate to select a more comprehensive package! (There are some for independent developers and studios.)

Question: Will the monthly price go up if I don't sign up now?

Answer: The offer above is available for this week only. Also, depending on how much work the launch is we might close the site for individual members again. It's a lot of work to take on individuals and re-open the site, and in the past we've stopped taking new members to focus instead on creating top quality content.

We won't be doing any kind of bonuses or promotion before Autumn later this year, and by then we'll have restructured the offer to split up access to our existing library content and future sessions separately. If you want full access at this price, now's your best chance.

So, what are you waiting for, go and check it out now!

This article was originally published as part of AiGameDev.com Premium (re-opening on May 6th) and written by Daniel Harabor, Ph.D. researcher at the NICTA and The Australian National University, specializing in pathfinding and game AI. You can contact him by email at <daniel.harabor at nicta.com.au>

Real-time strategy (RTS) games often feature a wide number unit types for the player to control. One of my favourite titles from the past, Westwood’s seminal Red Alert, had many classes of differently sized units: small infantry soldiers, medium-sized Jeeps and large tanks. In Red Alert 3, the most recent incarnation of the series, the diversity is increased even further by the introduction of units with terrain-specific movement capabilities (Figure 1). From a pathfinding perspective this introduces an interesting question: how can we efficiently search for valid routes for variable-sized agents in rich environments with many types of terrain?

This was the topic of a recent paper [1] I co-wrote with Adi Botea and which I presented at CIG’08. In the talk I outlined Hierarchical Annotated A* (HAA*), a path planner which is able to efficiently address this problem by first analysing the terrain of a game map and then building a much smaller approximate representation that captures the essential topographical features of the original. HAA* works by using a distance-to-obstacle metric to calculate the amount of clearance (or free space) at each tile in a grid environment. This simple method is the basis for a hierarchical clearance-based pathfinding approach that is able to answer queries for many different types of units with distinct sizes and terrain traversal capabilities. HAA* is shown to be an order of magnitude faster than low-level A* search, produces near-optimal solutions and requires little memory overhead in practice.

Figure 1: EA’s Red Alert 3 features a wide variety of land-based, aquatic and amphibious units. Each class has distinctive shape and size characteristics.

In this article I want to outline the two major aspects of HAA*. First, I’ll discuss how one can analyse a grid map to automatically extract clearance-related topographical information. Second, I’ll explain how HAA* is able to use this information to build space-efficient abstractions that allow a range of agents with different sizes and terrain traversal capabilities to very quickly find a high quality path through a static multi-terrain environment.

Clearance Values and the Brushfire Algorithm

Simply put, a clearance value is a distance-to-obstacle metric which is concerned with the amount of traversable space at a discrete point in the environment. Clearance values are useful because they allow us to quickly determine which areas of a map are traversable by an agent of some arbitrary size. The idea of measuring distances to obstacles in pathfinding applications is not a new one. The Brushfire algorithm [2] for instance is particularly well known to robotics researchers (though for different reasons than those motivating this article). This simple method, which is applicable to grid worlds, proceeds as so:

First, to each traversable tile immediately adjacent to a static obstacle in the environment (for example, a large rock or along the perimeter of a building) assign a value of 1. Next, each traversable neighbour of an assigned tile is itself assigned a value of 2 (unless a smaller value has already been assigned). The process continues in this fashion until all tiles have been considered; Figure 2 highlights this idea; here white tiles are traversable and black tiles represent obstacles (NB: The original algorithm actually assigns tiles adjacent to obstacles a value of 2; I use 1 here because it makes more sense for our purposes).

Figure 2: A small toy map annotated with values computed by the Brushfire algorithm. Black tiles are not traversable.

Figure 3: A 1×1 agent finds a path to the goal. All traversable tiles are included in the search space.

Figure 4: A 2×2 agent finds a path to the goal. Only tiles with clearance > 1 are considered.

Figure 5: A 2×2 agent fails to find a path due to incorrect clearance values near the goal. Notice that the highlighted tiles are infact traversable by this agent.

Brushfire makes use of a minimum obstacle distance metric to compute clearances which works reasonably well in many situations. If we assume our agents (I use the term agent and unit interchangeably) are surrounded by a square bounding box we can immediately use the computed values to identify traversable locations from non-traversable ones by comparing the size of an agent with the corresponding clearance of particular tile. Figure 3 shows the search space for an agent of size 1×1; in this case, any tile with clearance equal to at least 1 is traversable. Similarly, in Figure 4 the search space is shown for an agent of size 2×2. Notice that the bigger agent can occupy much fewer locations on the map; only tiles with clearance values at least equal to 2. Because this approach is so simple it has seen widespread use, even in video games. At GDC 2007 Chris Jurney (from Relic Entertainment) described a pathfinding system [3] for dealing with variable-sized agents in Company of Heroes — which happens to make use of a variant of the Brushfire algorithm (NB: this work actually takes a similar approach to HAA* but a direct comparison is difficult because the method is not outlined in great detail; nevertheless, it’s quite a nice presentation.).

Unfortunately, clearances computed using minimum obstacle distance do not accurately represent the amount of traversable space at each tile. Consider the example in Figure 5; Here our 2×2 agent incorrectly fails to find a path because all tiles in the bottleneck region are assigned clearance values less than 2. To overcome this limitation we will focus on an alternative obstacle-distance metric: true clearance.

The True Clearance Metric

The process of measuring true clearance for a given map tile is very straightforward: Surround each tile with a clearance square (bounding box really) of size 1×1. If the tile is traversable, assign it an inital clearance of 1. Next, expand the square symmetrically down and to the right, incrementing the clearance value each time, until no further expansions are possible. An expansion is successful only if all tiles within the square are traversable. If the clearance square intersects with an obstacle or with the edge of the map the expansion fails and the algorithm selects another tile to process. The algorithm terminates when all tiles on the map have been considered. Figure 6 highlights the process and Figure 7 shows the result on our running example.

Figure 6: After selecting a tile (a) the square is expanded twice (b, c) before intersecting an obstacle (d).

Figure 7: The toymap from Figure 2, annotated with true clearance values.

Notice that by using true clearance the example from Figure 5 now succeeds in finding a solution. Infact, one can prove that using the true clearance metric it is always possible to find a solution for any agent size if a valid path exists to begin with (i.e. the method is complete; see [1] for details).

Dealing With Multiple Terrain Types

Until now the discussion has been limited to a single type of traversable terrain (white tiles). As it turns out however, it is relatively easy to apply any clearance metric to maps involving arbitrarily many terrain types. Given a map with n terrain types we begin by first identifying the set of possible terrain traversal capabilities an agent may possess. A capability is simply a disjunction of terrains used to specify where each agent can traverse. So, on a map with 2 terrains such as {Ground, Water} the corresponding list of all possible capabilities is given by a set of sets; in this case {{Ground}, {Water}, {Ground, Water}}. Note that, for simplicity, I assume the traveling speed across all terrains is constant (but this constraint is easily lifted).

Next, we calculate and assign a clearance value to each tile for every capability. Figures 8-10 show the corresponding clearance values for each capability on our toy map; notice that we’ve converted some of the black (obstacle) tiles to blue to represent the Water terrain type (which some agents can traverse).

Figure 8: True clearance annotations for the {Ground} capability (only white tiles are traversable).

Figure 9: True clearance annotations for the {Water} capability (only blue tiles are traversable).

Figure 10: True clearance annotations for the {Ground, Water} capability (both white and blue tiles are traversable).

Theoretically this means that, at most, each tile will store 2^n-1 clearance value annotations (here n corresponds to the number of terrains; see [1] for details). I suspect this overhead can probably be improved with clever use of compression optimisations though I did not attempt more than a naive implementation. Alternatively, if memory is very limited (as is the case with many robot-related applications) one can simply compute true clearance on demand for each tile, thus trading off a little processing speed for more space.

Annotated A*

In order to actually find a path for an agent with arbitrary size and capability we can use the venerable A* algorithm [4] albeit with some minor modifications. First, we must pass two extra parameters to A*’s search function: the agent’s size and capability. Next, we augment the search function slightly so that before a tile is added to A*’s open list we first verify that it is infact traversable for the given size and capability; everything else remains the same. A tile is traversable only if its terrain type appears in the set of terrains that comprise the agent’s capability and if the corresponding clearance value is at least equal to the size of the agent. To illustrate these ideas I’ve put together a simplified pseudocode implementation of the algorithm, Annotated A*:

Function: getPath
Parameters: start, goal, size, capability push start onto open list.
for each node on the open list if current node is the goal, return path. else, for each neighbour of the newly opened node if neighbour is on the closed list, skip it else, if neighbour is already on the open list, update weights else, if clearance(neighbour, capability) > size, push neighbour on the open list else, skip neighbour push current node on closed list if openlist is null, return failure

If you’re interested in playing with a working implementation of Annotated A* you can check out the source code I wrote to evaluate it. It’s written in C++ and based on the University of Alberta’s freely available pathfinding library, Hierarchical Open Graph (or HOG). HOG compiles on most platforms; I’ve personally tested it on both OSX and Linux and I’m told it works on Windows too. The classes of most interest are probably AnnotatedMapAbstraction, which deals with computing true clearance values for a map, and AnnotatedAStar which is the reference implementation of the search algorithm described here.

Hierarchical Abstraction

Having described a simple clearance-based pathfinding system we can now turn our attention to speeding it up through the use of hierarchical abstraction. The main problem here is that a multi-terrain map annotated with clearance values contains lots of topographical information but abstraction methods can only hope to approximate the original. Thus, the goal is to build an abstraction which is representationally complete i.e. if a path between two points can be found on the original annotated map, we should be able to also find it using only the abstract map. To achieve this we’re going to attack the problem in 3 steps:

1. First, we divide our annotated map into a set of adjacent Clusters connected by Entrances. We will show that the resultant graph produced by this process is infact representationally complete but contains redundant and duplicated information.

2. Second, we compact the graph produced in the previous step using dominance techniques which identify and prune unnecessary nodes and edges. The resultant abstraction is shown to contain a minimal set of nodes and edges yet still retains the representational completeness properties of the original map.

3. Third, we describe the Hierarchical Annotated A* algorithm (HAA*) which we use to efficiently answer queries for a wide variety of agents with different sizes and terrain traversal capabilities. HAA* is shown to produce very high quality (i.e. near optimal) paths with comparatively little search effort vs. Annotated A*.

Clusters and Entrances

In order to create an an abstract representation of an annotated map we follow Botea et al [5] and divide the environment into a series of discrete square-sized areas called clusters. Figure 11 shows the result of this step on our running example using clusters of size 5×5.

Figure 11. The map is divided into four 5×5 clusters.

Figure 12. (a) Three entrances are identified between clusters C1 and C3, one for each possible capability. (b) Each transition point (denoted by a strong dark line) maximises clearance for a particular capability.

Next, we identify entrances between each pair of adjacent clusters. An entrance is defined as an obstacle-free area of maximal size that exists along the border between two clusters (Figure 12a). Each entrance has associated with it a transition point which reflects the fact that an agent can traverse from one cluster to the other. To this end we select from each entrance a pair of adjacent tiles, one from each cluster, which maximise clearance (Figure 12b). Each transition point is represented in the abstract graph by two nodes connected with a single inter-edge of weight 1.0. The inter-edge is also annotated with the corresponding capability and clearance value that reflect the traversability requirements of the transition point.

Figure 13. A complete initial abstraction.

Finally, we complete the abstraction by finding all possible ways to traverse each cluster. We achieve this by running Annotated A* (AA*) between each pair of abstract nodes inside a cluster; one search for each combination of possible agent sizes and capabilities. Every time AA* successfully finds a path we add a new intra-edge between the start and goal nodes. The weight of the edge is equal to the length of the path and we further annotate it with the size and capability parameters used by AA* to reflect the traversability requirements of the path. This approach is highly effective at capturing all pertinent topographical details of the original map. Infact, it is easy to see that the resultant graph (which is termed an initial abstraction) is representationally complete since we’ve identified all possible transitions between each pair of adjacent clusters and all possible ways to traverse each cluster (Figure 13).

Compacting the abstract graph

An interesting observation made during the abstraction-building process was that on many maps the same path was often returned by AA* when searching between the same pair of points with different sizes and capability parameters. This indicates that our abstract graph actually contains unnecessary or duplicated information (and is also needlessly large as a result). To solve this problem we’re going to apply two edge dominance approaches to prune unnecessary nodes an edges. I want to avoid describing these ideas formally (the details are in [1]) and instead focus on the intuition behind each one.

The first, termed strong dominance, states that if two edges, both of identical length, connect the same pair of nodes and both are traversable by the same capability then we need only retain the one with the largest clearance. Figure 14 illustrates this idea. It is easy to see that using this approach preserves representational completeness; any agent able to traverse the edge with smaller clearance is also able to traverse the one with larger clearance. The resultant graph is termed a high-quality abstraction because we discard only duplicate information fromt the graph.

Figure 14: (a) Part of the initial abstraction for cluster C1. (b) Strong dominance removes edges E5 (dominated by E3) and E6 (dominated by E4).

Figure 15. (a) A graph with two inter-edges, E2 and E5. An agent traveling from "u" to "x" via E2 must both swim and walk whereas traveling via E5 only requires walking. (b) The dominated inter-edge, E2, and its endpoints, are removed.

The second approach, termed weak dominance, is focused on minimising the number of transitions between clusters. To achieve this the algorithm analyses pairs of inter-edges that connect the same two clusters and attempts to prove that if one is removed the representational completeness of the graph is maintained. The effect is that only transitions which are traversable by the largest number of agents are retained. This is similar to the way motorists frequently prefer to travel between locations via freeways, which are traversable by many kinds of vehicles, instead of opting for more direct offroad travel. Figure 15 illustrates this idea; again, it is easy to see that the application of weak dominance also preserves representational completeness. The resultant graph is termed a low-quality abstraction, to reflect the fact that some connectivity information is lost in the process (Figure 16).

Figure 16: The abstract graph after weak dominance is applied. Note that the graph is almost half the size compared to Figure 13.

Choosing which dominance technique to use will depend on the exact requirements of the target application. Empirical results have shown that in both cases the amount of memory required to store the abstract graph can be a small fraction of that required by the original map. (though the exact number depends on a range of factors which are discussed in [1]). Comparatively speaking, low quality abstractions can be more than 50% smaller than their high quality counterparts but there is a small tradeoff. In particular, high quality abstractions produce, on average, paths with lengths 3-5% longer than optimal while low quality abstractions are in the 6-10% range.

Hierarchical Annotated A*

The process of finding a path using an abstract graph is a straightforward one that will be familiar to anyone who has come across the HPA* algorithm [5]:

1. Insert two temporary nodes into the abstract graph to represent the start and goal locations. Connect these nodes to the rest of the graph by attempting to find a path to from the start/goal positions to every transition point in the local cluster.

2. Using A*, find a shortest path from the start to the goal in the abstract graph. At the end of the search, remove the two temporary nodes.

As with other hierarchical planners, HAA* is shown to be very fast. I analysed its performance on a large set of problems (over 140K) using both small and large maps from Bioware’s popular RPG Baldur’s Gate. Since there are no similar pathfinding algorithms to measure against, it was contrasted with Annotated A*. In short, HAA* is an order of magnitude faster and, even with my naive, non-optimised implementation, it was able to find solutions to most problems in ~6ms on average (tested on my Core2 Duo 2.16GHz MacBook, running OSX 10.5.2 with 2GB of memory).

If you’d like to play with a working implementation of HAA*, you can download the source code I wrote to evaluate the algorithm. The classes most relevant to the preceeding few sections are probably AnnotatedCluster and AnnotatedClusterAbstraction which together are responsible for generating the abstract graph. Meanwhile, AnnotatedHierarchicalAStar provides a reference implementation of the HAA* algorithm.

Concluding Remarks

So that about wraps things up. I hope this article will serve to highlight the usefulness of clearance-based pathfinding methods for efficiently dealing with the large diversity of both units and environments so often seen in modern video games. For more information on HAA* I suggest taking a look at the original paper [1] and associated presentation slides, both of which contain more indepth discussion of the ideas presented here.

Alternatively, if you have specific questions or comments regarding anything described in this article, please feel free to contact me.

References

Hierarchical Path Planning for Multi-size Agents in Heterogeneous Environments
D. Harabor and A. Botea
IEEE Symposium on Computational Intelligence and Games (2008)
[1] Download (PDF) (Presentation)

Principles of Robot Motion, pp. 86-88
MIT Press (2004)
(google books entry)
[2] H. Choset, K. M. Lynch, S. Hutchinson, G. Kantor, W. Burgard, L. E. Kavraki and S. Thrun

Dealing with Destruction: AI From the Trenches of Company of Heroes
Game Developers Conference (2007)
(slides and videos) (audio purchase)
[3] C. Jurney and S. Hubick

Near Optimal Hierarchical Path-Finding
A. Botea, M. Müller, J. Schaeffer Journal of Game Development (2004) Volume 1, Issue 1, 7-28
Download PDF

Here's a list of the eighteen best, quirkiest, and most informative artificial intelligence bugs available on YouTube we've collected over the past 12 months. In the spirit of AiGameDev.com, you'll find a bunch of tips & tricks to help fix these problems when/if you see them in your own game.

First, a disclaimer. While certainly fun, this is also a difficult feature for me to write; the draft has been waiting to be finished up and published for over 6 months. There are already many video collections of AI bugs on also-ran Game News sites, but the difference here is that I've personally met or worked online with most of the developers behind these games — and many of them read this blog (RSS). I'm hoping the controversial aspect of this article is overshadowed by the useful analysis and the importance of the topic.

The fact is, if you look beyond the sensationalist headline, social media websites are dramatically changing the way games are received by gamers and the community at large. And AI in games is no exception here... In fact, there seems to be increasingly more pressure and scrutiny on the behavior of game characters. Luckily, this new area of social media means there's also lots to learn from!

#1
AI Can't See Until Seen

Game: Half-Life 2, 2004.

Symptom

A player is carrying a barrel in front of his eyes such that it hides all enemy NPCs in the scene. This in turn causes the enemies to not attack until the player drops the barrel!

Cause

Explaining this bug requires a little context. As documented by Tom Leonard (now working at Valve), the sensory system in Half-Life is built to help prevent player frustration, so that soldiers and enemies in the game do not attack the player until the player has noticed them.

In this case, you can use that to your advantage by carrying a barrel, but you could also demonstrate this bug by walking backwards into a room full of enemies!

Cure

Since this special case in the sensory system was introduced artificially for gameplay reasons, fixing it also needs to be a game design issue. There are multiple quick fixes:

• Add an extra condition to the "ignore player" statement in the sensory system, for example only when the player is under attack or recently received damage.

• Remove the "ignore player" statement with a time out mechanism that kicks in after a few seconds. This can provide realistic AI reaction & decision times while at the same time giving the player some leeway.

Going beyond these quick fixes requires a more general "experience manager" that can determine which NPCs should acquire the player as a target based on the current challenge to the player.

Building an AI Sensory System: Examining The Design of Thief: The Dark Project
Tom Leonard, GDC 2003.
View Online

#2
Your Last Known Position Is...

Game: Hitman: Blood Money, 2006.

Symptom

An doctor-like NPC was chasing the player who recently escaped from some hospital facility, but does not notice the player changing clothes in front of him. The doctor then abandons the chase, is threatened by the player (now in Hitman clothes) and goes to notify a guard NPC about the last known position of the escaped prisoner. In the process, the doctor NPC runs past the player himself shouting "Run for your life."

Extra: Guards do not react to the player's escape until notified by the hospital staff.

Cause

All NPCs in the game have a sensory system which allows them to react appropriately when the player is dressed differently. This allows gameplay features like changing clothes to hide from guards and doctors. However, there's a loophole in this system that's not handled when the player is visible when the clothes are changed.

Extra: The same sensory system means that not all guards are instantly aware of the escape until told, but in this cause the guards do not take into account the player's obvious actions.

Cure

The problem is caused by adding a sensory system, which is very useful. However, corner cases pop up due to the additional complexity. These can be fixed with the following steps:

• To hide these problems and generally improve the AI, each guard could be built with a default behavior that activates when the player does something suspicious — regardless of his clothes. For example, reacting to the player running or nearby.

• An extra flag is necessary somewhere in the sensory system to indicate if the player changed his clothes while visible. If that's the case, this flag would help override the current perceived clothes, and keep the same behavior active.

• This flag can be set globally once for the player or, in the spirit of this game, it would be set for each NPC. This would allow the doctors to communicate to guards about the player's false disguise.

#3
NO SWIMMING

Game: Grand Theft Auto San Andreas, 2004.

Symptom

NPC cops follow the player into the water, but they can't swim and immediately drown.

Cause

This kind of situation is one of many special cases that can arise in open worlds, particularly when the NPCs do not have the same abilities as the player. In particular, this bug was caused by the cops either not knowing about the water, or not knowing that they needed a special ability to enter the water. Instead, the cops AI was reactively moving towards the player's position.

Cure

This was fixed in subsequent releases, presumably by:

• Adding more information into the navigation graph about the type of environment, in this case annotating volumes as water.

• Making the cops' pathfinding aware of the water and avoiding it at all cost. The AI would stop before the ledge leading into the water.

#4
When Priorities Go Wrong!

Game: Crysis, 2007.

Symptom

NPC investigates a burning barrel that was thrown by the player and landed nearby. The barrel subsequently explodes while the NPC is nearby looking at it.

Cause

The NPC's investigate behavior is activated when an unexpected sound is emitted by the landing barrel, but the fact that the barrel is burning is not taken into account.

Cure

There are two possible fixes, in order of preference:

1. Have the FreeFromDanger behavior work for burning barrels, and make sure its activation is checked periodically. (Subsumption)

2. Add a special-case precondition to the investigate behavior that checks if the source object type is not dangerous. (Inhibition)

#5
What Sound Does a Knife Make?

Game: S.T.A.L.K.E.R., 2007.

Symptom

A player using a knife can completely take over an enemy base without any of the AI soldiers firing a shot back at the player.

Cause

There are two things that cause this bug:

1. The fact that the Knife seems to be treated as a separate case by the sensory system, so it doesn't trigger the usual reaction that you get from a weapon.

2. The fact that S.T.A.L.K.E.R. supports neutral factions, the player is by default treated as a neutral entity and this status is not updated because of point 1).

Cure

The solution to this problem is to first fix the sensory system and its effect on the behavior, so that knife kills are taken into account as other weapons. This can be done by using one common Event type, or alternatively taking into account a death sound.

The second thing to fix would be to make the Stalkers a little more suspicious of the player when entering their base, especially when armed. Also, Stalkers could be given a sixth-sense suspicious behavior (rather than the normal patrol / idle) when multiple nearby soldiers are killed.

#6
Standing Still *Is* A Strategy

Game: FIFA 08, 2007.

Symptom

An individual AI player on the opposite team remains completely immobile in the middle of the pitch, only playing the occasional idle animation. He remains still even if a human player runs up to the AI individual, puts the ball in his feet, or bounces the ball off him.

Cause

Such general bugs are hard to identify without looking at the code itself. Even with the code handy, explaining why an NPC is not doing what he's supposed to do generally is much harder than narrowing down a more specific issue. In this case, it could be any of the following:

• This player no longer has its AI updated because of a game logic bug, and is simply "going through the motions" in a brain dead manner.
• The individual player has found a "terminal" state in the behavior which offers no way out. This is a problem in the logic that's relatively simple to fix once identified.

Cure

The AI works for the rest of the team as well as for other games, so this seems to be a very special case. Specific enough that EA shipped the game with it. Once isolated, tracking down the source would be relatively easy by using a logging mechanism to identify this particular problem (if your designer comes up to you with this issue). However, to catch such problems generally you could consider gathering simple statistics for each player, such as distanced moved, passes sent and received, etc. and watch out for anomalies.

#7
The Shortest Path is a Straight Line

Game: Armed Assault, 2007.

Symptom

At the edge of the map near the water, a squad ordered to move to a point on the other side of the bank decides to move through the water. The individual AI soldiers swim around and eventually reach the shore, from where they can move to the target point. In the video, the player reached that point in 1/3rd of the time.

Cause

This bug may be caused by two things:

• The navigation representation does not model the water. This is possible if the world is assumed to be a 2D terrain with sparse obstacles.
• The pathfinder used by squads does not deal with concave areas like near the edge of the map, also caused by similar 2D terrain assumptions.

Cure

The easiest way to fix this is to smooth the coastline of each map such that there are only convex land masses. Alternatively, the squad pathfinder can be run through a representation that takes into account the water at an increased cost, such that it is avoided by default.

#8
I'm Invisible: Go Around Me

Game: Company of Heroes, 2006.

Symptom

An invisible sniper controlled by the player causes the tank to stop and pathfind around him everytime he moves. Yet the tank and the enemies are not aware of the sniper and therefore don't engage him.

Cause

The cause of this problem is a mismatch between the game logic and high-level behaviors ignoring the sniper, yet the pathfinding is continuously trying to find a way around a hidden sniper.

Cure

There are two ways to fix this, one involved less design and the other more technology:

• Remove the sniper cloaking feature! The tanks would attack the sniper rather than try to pathfind around it.

• When the sniper cloaks, remove it as an obstacle for enemy units in the pathfinder.

#9
Moonwalking Is Fun

Game: Prince of Persia: Rival Swords (PSP), 2006.

Symptom

NPC guards are seen on two instances walking into posts and closed doors repeatedly, while the animation keeps on walking.

Extra: Enemy is passive until attacked the first time.

Cause

There are two bugs that cause the behaviors to look like this in the end:

1. The navigation representation isn't accurate enough, either taking into account the characters width near pillars or not updating dynamically when doors close.

2. The path following isn't capable of noticing lack of progress, and simply keeps on going despite collision problems.

Cure

Fixes to either of the two problem areas would solve this, but such navigation problems often take much longer to fix than the usual behavioral bugs. In this case, you'd need to build a more conservative navigation representation (e.g. retracting the edges of your navmesh a bit further to prevent physics problems) or if the system is using waypoints then reducing their effective radius. The second improvement could be to use a simple form of dead reckoning to track the change in movement, and consider planning a new path if the velocity reaches zero over the course of a few seconds.

#10
Who's Your Enemy?

Game: Oblivion, 2006.

Symptom

An enemy NPC was unresponsive until attacked. The NPC responds to the player once hit with the sword, but decides to target another NPC before dealing with the player. In the end, the NPC ends up running off to his original target.

Extra: NPC moonwalking into a wall as in the previous issue.

Cause

The pathfinding issue and lack of responsiveness is the same diagnostic as bug #10. However, the prioritization issue (which seems to be a problem) is caused by the AI only taking into account the most recent attacker, and ignoring the players original attack.

Cure

The main way to fix this involves biasing the NPCs a little more towards the player. Having an in-game simulation is a nice feature to have, but this is a game so the NPCs should take the player's actions into account a little more. For instance:

• Have NPCs ignore other attacks if the player is the current target.

• Maintain a queue of multiple active targets, and make sure to engage the player before moving on.

Which of these you decide to apply as a fix depends on your design, and how "player focused" the AI should be. Even if the NPCs don't engage the player, they should at least acknowledge this.

#11
Where's the Pitch Control on this Mounted Gun?

Game: Crysis, 2007.

Symptom

The enemy NPC in control of the mounted gun just fires repeatedly in the direction of the player, despite not being able to hit him. There's a dead spot right near the vehicle where the NPC cannot aim the mounted gun, yet still the AI soldier keeps shooting regardless.

Cause

The problem is that the behavior of the enemy on a mounted gun remains the same in all cases while the player is in front, even though the player may not be targeted. When the NPC receives damage, however, he dismounts from the gun as expected.

Cure

This is another special case that is amplified by YouTube and the fact that this is a sandbox game. The multiple fixes are relatively simple:

• Use a simple line-of-sight (LOS) or cone-of-fire (COF) check to determine if the player can be targeted.

• Add a minimum radius to the mounted gun behavior such that the NPC dismounts if the player comes too close.

• Tell the NPC to dismount if he hasn't done any damage to the player for a certain period of time.

#12
Drowning on Land

Game: Halo, 2001.

Symptom

A grunt is stuck "swimming" on the floor. The grunt does not respond to player shots, but only to explosions.

Cause

This could be due to the fact he's stuck in geometry and playing a falling animation. The reason for being stuck in the first place may be due to collision and/or explosion pushing the grunt into problematic geometry.

Cure

This particular bug is a difficult one to fix within the physics simulation, like many other physics/collision related issues. The fact that this bug was also apparently reproduced in subsequent versions of Halo also indicates this is a tough problem.

A behavioral fix could be to detect that a grunt is partly stuck in this state, and run a query on the navigation system to find a nearby position that's not occupied, then slowly interpolating the grunt towards this position.

#13
Are You Receiving My Bullets?

Game: Call of Duty 4, 2007.

Symptom

Allied and enemy NPCs keep shooting each other from a meter away, and keep missing because of a nearby tree. Bullets of one of the NPCs are actually hitting the tree, but the bullets of the other seem to disappear.

Extra: Both AI soldiers are also unresponsive to player movement.

Cause

Four little factors (that wouldn't be too much of a problem elsewhere) combine to cause this particular issue:

1. The "attack enemy" behavior continues to execute at top priority until the target is dead, regardless of what the player is doing or how successful the behavior is.

2. The line-of-sight (LOS) check used to determine if an NPC can shoot another does not trace the bullet exactly. (This is usually the case in modern games.)

3. There's not enough variation in the shooting behavior to break the deadlock.

4. No feedback is provided to the NPC when his bullets hit a tree rather than the intended target.

Cure

Fixing any of the following problems would resolve the issue:

• Decrease the value of the "attack enemy" behavior over time as it fails to achieve its goal, or let it time out such that another behavior is chosen.

• Introduce more randomness into the shooting behavior as the NPC keeps aiming for the same target. Modeling this kind of frustration as part of the aiming skill would help.

• Have the NPC monitor the health of the enemy and inflicted damage to check that the current behavior is actually achieving its intended purpose.

• At regular stages before / during the shoot out, fire a tracer bullet to check if the target can currently be hit from the exact position of the gun.

The way I would resolve this problem is to have fixed duration actions for attacking the enemy, then select many of these in succession to guarantee diversity in the combat and also prevent single problems.

#14
What Just Happened There?

Game: Oblivion, 2006.

Symptom

The player fires an arrow in an NPC's living room. The NPC then accuses the player of stealing from him.

Cause

The typical causes for an inappropriate behavior in response to an event / stimulus are either:

• An error in the conditional logic to activate a behavior.

• There is no behavior for this event, and a default is used.

Cure

In this case, it's doubtful that the reaction "You're stealing from me!" is used as a default, so I'd assume that the problem is with the activation logic for this behavior. It might be a simple scripting or copy/paste error, but otherwise having a clear event/situation for "Player picked up an object that doesn't belong to him." would help activate the stealing response.

Also, you could remedy this situation by having the AI check the reaction "What exactly are you doing?" when specific situations like these are found.

#15
Do the Oscillation Dance

Game: Gears of War, 2006.

Symptom

The enemy NPC is dancing on the spot, oscillating back and forth between two positions. The NPC is also unresponsive to the player's nearby presence.

Cause

There are a few instances of the same bug on YouTube also, and this seems to be caused by the navigation system changing its mind too often. The pathfinder is run from one position, calculating a path one way. Then as the path is followed, the path is recalculated causing a different route to be taken.

The actual cause of this oscillation could be due to the way the costs are setup in the environment, which lead to a local "minima" where the bot oscillates. But an alternate explanation is that the bot hits a trigger box / radius when moving in one direction, which causes one behavior to engage. Then when the trigger is exited, the original behavior resumes.

Cure

Assuming it's a special pathfinding situation where there are multiple paths to the bot's target, the easy way to reduce the problem is to add a "cool down" factor for changing destinations less often. There's typically no need to decide on a new path on a regular basis, simply monitoring the current path for problems would be enough.

If the problem is due to local triggers engaging two competing behaviors, a similar time buffer can be used to reduce oscillation between the two choices.

#16
Driver, Where Are You Talking Me?

Game: Halo 3, 2007.

Symptom

An NPC driving in a Warthog keeps bumping into a force field while trying to drive around. However, when the player gets out of the vehicle, the driving / bumping bug stops.

Cause

The force field does not seem to be taken into account by the vehicle pathfinding. The AI doesn't realize it needs to move backwards in this case to get out of trouble.

Cure

There are two ways this could be fixed:

1. Have the pathfinder take into account force fields dynamically when doing searches for vehicles.

2. Detect that path-following fails (using progress measurements) and temporarily disable links in the navigation representation, to prevent problems of unexpected dynamic objects.

#17
I Speak with Dead People

Game: Crysis, 2007.

Symptom

Two NPCs are in a scripted dialog with each other. The player takes out one of them using a sniper riffle, and the other NPC keeps on chatting away as if nothing had happened.

Cause

The root of this bug is the interplay between scripted situations that involve multiple characters, and the dynamic gameplay behavior that's required to interact with the player. In this case, since the shot of the sniper riffle was possibly not heard by the NPCs, the trigger failed to interrupt the scripted dialog since it didn't take into account the nearby death of an ally — very much like bug #5.

Cure

The solution involves a similar fix as #5, making sure the sensory system takes into account "entity dead" events as sounds, for example. Alternatively, NPCs near the hit point of a bullet should be informed of the presence of the player, or possibly even informed of the player's position (after the second shot). Above all, your group behavior scripts must be written to be interruptible by the player at every stage — especially if you're working on an open game.

#18
Do Not Open that Box!

Game: Bioshock, 2007.

Symptom

When a particular box is searched, an enemy is spawned everytime on demand at a similar location. Even if the player is looking at all the access points for that location.

Cause

Although the game seems to spawn NPCs out of sight of the player, the problem is the script that spawns the enemy NPCs doesn't take into account how often he performs an action.

This isn't technically an AI issue, it's more of a scripting problem. But, as often with these bugs, it's attributed to AI programmers!

Cure

There's a scripting fix and a technical fix that can alleviate this problem:

• Add a counter to the script trigger to prevent it from firing more than once.

• Beyond checking the line-of-sight from the player to the spawn point, check if the player is looking directly at all the access points of the spawn location.

Summary & Take Away

Generally speaking, there are a few things you should know about game AI bugs:

1. On their own, most bugs don't take long to fix technically speaking; most ones in this list would possibly take between an hour and a few days to isolate and fix.

2. Most bugs quickly become a design decision, as fixing bugs may affect other behaviors or the gameplay itself. Towards the end of a project, the AI is often frozen for this reason.

3. AI bugs are rarely ever show stoppers, and the reason they are not fixed is due to scheduling and production reasons.

As an AI developer, this can be a little frustrating at times — particularly when the reviews come in. However, the fact that a game contains AI bugs reflects on a large part of the team, particularly at the production level. It's possibly one explanation for many AI programmers eventually becoming Lead Programmer, as it's one of the best ways to make sure everything comes together to make sure the behaviors work and the gameplay is fun!

In the meantime, if you're making your own game, this list of bugs also has its lessons to teach:

• Spend time playtesting so that you can find out your player's expectations, and cater to those. This is a numbers game.

• Consider spending some time tuning your AI for NPC watchers that try to find loopholes in the behaviors and post bugs on YouTube!

If you're reading this then no doubt you've noticed the brand new version of the site already. We've been online for a few days and let me tell you, it's been quite a ride! Thanks so much for your feedback, encouragement, and kind words — but also of course your bug reports and suggestions. Rest assured we're working on them.

Over the last two years, AiGameDev.com has grown very organically: first as a blog, then as a forum, and finally into the premium area. The site has certainly been needing renovations, so we took the time to completely rebuild the backend and create a new design — and this time we got professional help.

New and Noteworthy

The big theme for the redesign was to help explain the site better, and in particular emphasize the incredible community behind the site and also the amazing content we've been creating over the past 2+ years. Now it should be more obvious from first glance we're not just a game development blog or an also-ran news site!

In particular, we made it much easier to browse around on the site and see what's going on at a glance:

• Front Page — A lot of time and effort went into the root page of the whole site, in particular from a content and navigation perspective. It helps bring together everything together from different sections on the site and highlight what's important.
• Media Section — To help emphasize the depth and variety of the content, we also added a section that catalogs all the forms of Media listed on the site. We'll be annotating the few hundred existing articles so this section will grow incrementally.
• Integrated Search — You can also access all the content on the site via the search button, so everything is at your finger tips.
• Site Accessibility — We also smoothed out the process of helping you log-in to the site by adding it to the top menu, and it's also much clearer how you can sign-up to the site.
• Access Levels — The different user levels on the site are now much clearer: articles for regular visitors have no icons, those for Insiders (free sign-up) have a yellow star, and the Premium Member articles have a red crown.

Coming Shortly

We decided to focus the relaunch of the site on the key features, as I listed above. In the process, we pushed back some additional features that are ready — but will come online shortly:

• Topics — Based on popular demand, we'll be including topic specific sections on the site using category-like, for example navigation, character animation, or strategy. These will help you find relevant articles if you have a problem to solve!
• Events — As part of the Premium Membership we run a couple live sessions every month, either interviews or masterclasses. We also run public sessions now and then for everyone to join. To make it easier to keep track of what's going on, these will be available on the front page and in the sidebar.
• Papers & Code — In the Media section, as we annotate the existing and new articles, we'll include new subsections that reference all the white papers and source code & libraries available on the site.
• News — We've maintained a separate news blog for over a year now, but we'll migrate this to the front page of the site. This will encourage us to write smaller articles about current events so we can stay on top of the important news without having to wait for the weekly roundup!
• RSS Feed — We spent a lot of time customizing the RSS feed on the old site so it looks as good as you see it. We're obviously very proud of this, and it's one of the many reasons why almost everyone uses it to read the main blog! The new site's feed isn't included yet, but it will be shortly once it looks as good!

Known Issues

Also, there are a few things that don't behave quite fully as designed yet. These will be fixed shortly:

• Categories — Some of the categories of the public articles couldn't be imported, so all articles don't show up yet when you click on the sidebar links. We'll be re-tagging some articles manually and remapping the previous categories automatically where possible.

• Redirects — Occasional links in the new site are not redirected to the right place yet, and some old links for the categories are not remapped correctly yet. If you find an old link that doesn't work or redirect correctly let us know!

• Login — When logging in, you're currently always redirected to the front page. Also, the forums seem to remember you from a previous session when the main site doesn't always...

Lessons Learned...

Now, for those of you that followed the relaunch via our front page or Twitter, you probably realize there were a few glitches. Once the site was up and running, there were some performance issues and we had to optimize and upgrade to a new server — which took longer than expected. The site was under maintenance for about 36h.

Of course this wasn't planned and I apologize for those of you that tried to access the site. But in retrospect, lots of great things came of this:

1. I was amazed by the personal emails, instant messages, and Twitter comments from everyone who sent us support while the upgrade was underway. Thanks for those, they mean a lot!

2. Traffic actually increased significantly the day *before* the launch, obviously from people trying to get their fix from the forums or keen to see the new site!

3. We setup the official AiGameDev.com #gameai IRC channel on irc.freenode.net, and that has been fascinating so far! We've hit 10 people already, and it's a friendly atmosphere.

Anyway, the new site marks a new phase for AiGameDev.com. Over the next week, we'll be pumping out loads of cool features we had planned for the relaunch. We'll also be sharing more details about what we do as a startup, and what you can expect in the near future. Finally, we'll also be re-opening our Premium Members area in a bit more than a week, so if you want to be notified and get some exclusive previews feel free to sign up right here.