Game AI Resources: Toolkits & SDKs

• AI.Implant -- Once known as ACE, this toolkit developed by Biographic Technologies out of Canada was originally released in March, 2001 and then upgraded (and renamed) just prior to the GDC in March, 2002. AI.Implant is basically an AI Software Development Kit (SDK) that bills itself as 'the world's first real-time 3D Artificial Intelligence (AI) SDK'. The product is basically a middleware (software library) that allows game developers to quickly and effectively add advanced artificial intelligence (AI) technology to their games in order to make smarter characters. This "Brain In A Box" solution integrates very well into PC, X-Box, and PS2 games (a Linux version is under development as of this writing)
  
  The SDK really works best with as a plug-in used with Maya (the 3D rendering tool), though that's not necessary since there's also a straightforward library for the programmers to use. As a plug-in it provides animators a quick way to animate large number of characters within Maya. "The fact that we were able to rapidly and seamlessly integrate our real-time AI technology into such an advanced 3D application like Maya is a fantastic proof of the openness of our SDK. Moreover, since our SDK is designed to integrate into advanced game engines, we provide tools for everyone in the game creation pipeline from artist to level builder to programmer," according to Dr. Kruszewski.
  
  AI.Implant was recently upgraded to version 1.1 and now includes some interesting new features, including more intelligent path-finding, "surface hugging" technology so agents can move along any arbitrary surface rather than just terrain, updated plug-in support for 3DS-Max users, and a "periodic solver control" which lets programmers and artists control how often their characters are "called" to do their thinking (thus allowing more control over the game's AI cycle than before). Future versions plan to add 3D path-finding technologies, finite-state machines, and learning systems (ala Black & White).
  
  Well worth a look, and definitely a mature system now that the 1.1 SDK has hit the market.

• Braniac -- An interestly named toolkit from the Twilight Minds design group, the Braniac Behavior Engine (BBE) is an open source AI "engine" that promises to provide "real-life behavior".
  
  BBE has an interesting feature set, allowing for what appears to be a goal-based hierarchy using scripts and simple Finite State Machines. Of particular interest to me is that it has a new approach to verbal conversations that gives it a functionality rather akin to those found in many of the more sophisticated MUD 'bots....very interesting indeed.
  
  There's quite a bit of online documention, downloads of the source code, and a nice user forum for support. I don't know much about this at the moment but I do plan to explore it in greater detail.
  
  Worth a look particularly if you want your RPG characters to have a bit more "depth" than one finds in many of today's games!

• DirectIA -- Built by Mathematiques Appliquees, a French-based company, DirectIA an interesting SDK. The initials stand for Direct Intelligent Adaptation) and it's really a pretty ambitious undertaking. I first saw it at the 1999 GDC and spoke extensively with its creators. DirectIA is, essentially, an SDK which allows developers to build autonomous agents (or groups of agents) that have the capacity to learn, anticipate, and select their actions. Agents controlled by this SDK can reportedly adapt to their environments and learn in realtime. A variety of modules come with the SDK supporting such things as Reactive Behaviors, Perception, and Motivations. Of course, you can add your own custom-rolled bits of code.
  
  At first glance I had thought that DirectIA supported agents built with rules-based approaches or Finite/Fuzzy State Machines, but after some correspondence with the DirectIA folks I see that I was in error. DirectIA instead uses a biological approach of sorts, using a proprietary technology developed by Mathematiques Appliquees themselves. To quote:

     "DirectIA...uses both biological and cognitive modeling. These 
      two models define the current state of the agent in real time. 
      Analogous to the discrete state used in finite state machine, the 
      dynamical state used in DirectIA SDK generates the behavior of the 
      agent, but in a more realistic and non deterministic manner. To 
      summarize, one could compare the behavioral system of DirectIA SDK 
      with an "infinite state machine".
  

  The DirectIA package also provides an English-like scripting language for use by the developer in building his own AIs, through which he can access many of the SDK's internal methods. This language uses production rules that differ from somewhat from traditional AI rules in that they are not used to directly create the behavior of an agent; rather, they are define the influence of external or internal factors in the evolution of the agent's internal dynamic state. These rules can be activated at each time step and can influence behavior at any point. Effects are carried over from time step to time step so that one rule can have a large influence on the resulting behavior in one context and a smaller in another context.
  
  Of particular note (to me, anyway) are the learning capabilitiess built into the package. Through the DirectIA scripting language it is possible to build agents to do various things:
  • To build agents that learn from their successes and failures;
  • To build a player artifact that first learns by imitation, and then reproduces the player’s behavior;
  • To build an AI that can build a model of the players tactics and strategies, and then use this model to anticipate them, choose its own strategy accordingly, etc.
  
  Oddly enough, no pathfinding capabilities are provided. The kit does come with a suite of debugging and tuning tools to help you build the perfect game AI.
  
  Definitely an interesting toolkit. In its earlier incarnation I felt that if you already knew enough to know you needed it, then you probably didn't need it, but with the newer releasses that's faded away. Very much a good toolkit with a lot of potential.

• GALib -- The kind folks at MIT (who have an excellent AI research program, I might add) have placed a nice little set of C++ classes implementing all of the standard genetic algorithm stuff. Free for non-profit use but requiring permission if you plan to use it in a game, GALib is still an excellent code example that runs across a variety of platforms. The page also has a robust set of links to other sites with GA information.

• KDCalc -- At one of the 2003 GDCi AI roundtables, Neil Kirby asked developers what was the most used middleware (i.e., toolkits) that they used in building their AIs. After a bit of uncomfortable silence, one guy piped up and said, "Microsoft Notepad" and then quickly added "...or Excel.".
  
  Well, the guys who make KDCalc have just the thing for that kind of developer.
  
  KDCalc is basically a tool for Excel that lets you build AIs of various kinds and give them a whirl. Plugins and templates let you experiment with fuzzy logic, NNs, or your basic rules based system while keeping the AI in a sort of "black box". When you're all done and have something you like, you can embed the AI in a web page, put it on a server (great for those online games), or stick the whole thing into a code module accessed via a (provided) API.
  
  I haven't played with the tool much but it is kind of neat. As of this writing there's both a Java and a .Net version available, and the developers have several demonstrations available that mostly focus on agent learning.
  
  This could be useful if you really do use Excel extensively in the development and tuning of your AI, or if you want a quick-and-easy interface to the AI for your online game masters to get to.

• Logic Programming Associates -- These folks offer a series of AI programming tools that I'd somehow missed completely for years.
  
  Providing a package of tools, LPA is now striving to make their toolkit more attractive to the game development community. They have a variety of utilities that programmers might find useful:

  • Flex uses an English-like interface to support forward/backward chaining AI structures.
  • Agent lets developers built agent-based systems useing a database- interfacing language named KQML.
  • Flint is perhaps the most useful tool to the gaem developer, providing a fuzzy logic editor that's fully graphical and interactive.
  LPA has a variety of other tools as well, and they're constantly adding new features. Prices range from a few hundred to several thousand dollars depending on the application and what features you want in the toolkit. For more information, hit their website (above).

• Spark! -- is a cool product from an interesting company named LouderThanABomb! that I first ran into at the 1999 GDC. Their stated purpose is to "Put the 'AI' in Entertainment Software", and from what I've seen they mean it. Their first tool towards that end is called Spark! (obviously these guys like exclamation points).
  
  Spark! is realtime fuzzy logic editor, designed to let developers integrate such AIs into their games and applications. Using its Windows-based GUI, developers are able to lay out the interconnections and parameters of their AIs in realtime, then integrate it into their application through either a C library or ActiveX/COM. Developers can then tweak their constructions and see the results in their applications immediately without the need to recompile.
  
  There's a mailing list on the site to which interested parties can subscribe to get updates on Spark!'s development, and a beta-test signup page if you'd like to get a chance to play with it before it hits the market. As of this posting the LouderThanABomb! folks haven't set a price yet; as soon as they do I'll update this information accordingly.
  
  If you're using it, or considering using it, please let me know how it's working out for you.

• Memetic -- Billing itself as "behavorial tools for persistant world game developers", the Memetic Artificial Intelligence Toolkit (MAI) is a fairly powerful API with a good base of documentation and such. The toolkit is written entirely in NWScript, Bioware's scriping language that drives their Neverwinter Nights series of games. As such the original idea was to provide better AI for aspiring dungeonmasters using that game to build adventures.
  
  The toolkit isn't limited to that however. MAI is a modular, priority-based system for each NPC with preemption, suspension, and resumption of various actions and states as required. A communications system is in place, and there are libraries of behaviors already provided as part of the toolkit. The code supports C++ style inheritance and various types of learning.
  
  MAI has an excellent documentation base and some well populated forums with a fairly activie community. While MAI is focused heavily on Neverwinter Nights there's a lot to learn from its construction and the discussions that are ongoing.
  
  An excellent package.

• NightFall -- Built by Altor Systems NightFall is an AI engine that I really don't know much about. Pointed out to me by a fan of these pages, the NightFall engine is interesting from an AI perspective is that it ships with a variety of tools to help developers with their world-building, including an AI editor and library.
  
  There's not a ton of info about the AI tools on the site, but it does list enough features to make it of potential interest:
  
  

  • Flexible physics model that allows objects to be stacked, lifted, carried.
  • Clicking on objects can link to 2D sequences of images and movies by simple text scripts, or to almost any form of AI, physics, and animation by means of C code.
  • High level C routines for AI functions - route finding, sensing other objects nearby, creating other objects, moving around.
  • Editors are provided to allow you to specify behaviors, customize the AI, etc.
  
  That's all I know about this one...has anybody out there used it who might want to share the experience?
• PathEngine -- Here's something unique...a middleware pathfinding library.
  
  PathEngine is a pretty neat toolkit that's still in the polishing phase as of this writing. It offers a variety of fast and efficient pathfinding libraries for the game developer together with a tightly-coupled collision model (a good combination, IMO--Ferretman). It provides for geometric pathfinding queries and handles dynamically placed (i.e., moving) obstacles just fine.
  
  There's a lot more but I must say the thing looks quite robust. The code itself comes in the form of a .DLL and there's all kinds of documentation and such on the web site. Well worth checking out!
• RenderWare AI -- A neat package that burst on the scene in the December, 2002 issue of Game Developer magazine, RWAI (it's fully name is "Renderware AI Powered by Kynogon", so you can see why I shortened it for this) is impressive in what it provides--and kinda fun to use. Better yet you don't actually need Renderware to use it (though it perhaps offers more flexibility in conjunction with that package).
  
  Renderware has long been known as an excellent 3D tool (in fact we used it for much of our work on Behind Enemy Lines for Sega). Now they've expanded their toolkit with a new AI middleware package in an attempt to bring the same level of performance and integration to the AI field. (There are definitely some strong resemblances between this product and the AI.Implant package, but I'm told by the developers that's pure coincidence.)
  
  RWAI takes a somewhat similar approach to that offered by AI.Implant in that it provides a suite of what they call "layered solutions" for building one's AI:
  
  
  • The "foundation" layer - Architecture. Provides core classes for C/C++ implemetation, basic time-slicing and queing, agent creation and deletion, etc.
  • The "management" layer - Services. Provides a variety of "have I?" or "how do I?" functions such as 3D pathfinding, field of view and "Can I see?" functions, dynamic object avoidance, etc.
  • The "actions" layer - Agents. Provides a basic agent framework upon which the other components are built.
  • The "thinking" layer - Brains. Provides the "thinking process" for each agent given inputs received from the services layer. Most of the user-provided stuff is probably located here (though you can add your own code pretty much at any level).
  
  Each of these layers has some pre-defined capabilties already available so that in theory you can quickly "roll your own" AI for a variety of purposes, and there are some fun example programs to demonstrate this on the site. RWAI notes in its white paper that most developers will probably be more comfortable adding their own routines for things like line-of-sight checks since those can be optimized for the game engine in question. The engine also supports scripts at the Brains level using an editor/compiler that's relatively intuitive (it's much like many of the Quake interfaces).
  
  The API does provide some other intriguing behaviors that are a bit unusual, such as specifying you want an agent to hide during movement (useful) and fish-tailing (useful for racing games). There's an excellent GUI for editing the AI's parameters in real time (rather like the one in AI.Implant that's pretty straightforward and expandable as you enhance your AI. The API will no doubt expand its capabilities over time as new features are added and users of the product work with the developers.
  
  Well worthy of your consideration, especially if your project is already using Renderware for its 3D or physics packages.

posted on 2007-11-21 17:17 楊粼波 閱讀(525) 評論(0)  編輯 收藏 引用