0faa50e7 a049 44ff 98a8 c480b0416f15



Not specified


Supported Platforms:
Windows, Linux, Xbox360, PS3

Languages Written In:

Not reviewed yet

00000000000000000000000000000000 TechSchuey

xaitControl gives game developers graphical tools to model advanced AI character behaviors with a probabalistic, hierarchical finite state machine. It also includes a graphical, real-time debugger.

Rapid Production of State Machines

  • Graphical UI for state machines. The modeling of state machines is done entirely in a graphical tool.
  • Graphical Debugging of running Finite State Machines. To debug the modeled logic you do not need any programmer or source code of the game.
  • Easy integration into existing environments. Minimal effort is required to integrate the module into your application. The coexistence with existing scripting environments (LUA, Phyton, etc.) is not a problem and existing script code can be used by the xaitControl module.
  • Possibility to model non AI Logic. Any logic in your application that is appropriate to model with finite state machines can be modeled with xaitControl (e.g. GUI elements).
  • Fallback function. Register the fallback function with the xaitControl library in the beginng of your project and just get going. Forget about registering all functions used in the xaitControl Creator for rapid prototyping.
  • Parameters for Events: With xaitControl, the runtime libraries, the xaitControl Creator and the graphical debugger can handle parametrisable events for even better control of the AI action.
  • Fallback function The fallback function makes it easier to create and prototype a xaitControl project independent from code. Just register the fallback function once and forget about registering all xaitControl Creator functions for prototyping.

Efficient Character Modeling

  • High reuse due to hierarchical modeling. The usage of hierarchical state machines allows an efficient reuse of modeled behaviors that are parameterizable by their variables.
  • Transition probabilities that allow a certain non-deterministic behavior of the modeled logic.
  • Different transitions types. xaitControl extends the common state machine model with transitions that allow for more efficient and easier state machines.
  • Low memory footprint. Concrete instances of state machines only store the instance specific data. All other data is shared.
  • Scenegraph Shortcuts New shortcuts for inserting states and transitions speed up the already fast modelling process. Creating state machines is intuitive, fast and as easy as a click.
  • Support for Multiple Data Sets: Support for multiple data sets means that you have different name spaces for registering functions, events, and variables within the environment window. The environment window displays all definitions within multiple tabs.
  • Integrated Movement and Behavior: A MoveProject template and template dataset in xaitControl eases communication with the movement core of xaitMap. These templates provide you with a fully configured function registration that understands all functions, events and variables needed to control movement entities.


  • Graphical debugging of Finite State Machines. To debug the modeled logic you do not need any programmer or source code of the game. The debugger gives you full control over the instances of the finite state machine.
  • Remote debugger. Debug your state machines on every platform over a remote connection.
  • Full variable access. Every variable of a state machine can be watched and changed by the debugger at runtime.
  • Breakpoints allow an efficient debugging of the state machines by stopping the game. Even setting breakpoints for state machines that do not yet exist is possible. The debugger features additional breakpoints for the preconditions and postcommands of transitions.
  • Restart of state machines allows you to reset a certain part of the control logic during runtime.
  • Transition blocking allows the force of a certain control flow.
  • History trail. Allows checking graphically the recent control flow of each state machine instance and the changes of the variables. Features a filter function.

xaitControl Library Features

  • C++ library that will be linked against your game runtime.
  • Full access to static data. It is possible to access all important information at runtime from the source code like all known state machines, used variables and functions (including the entire signature). This allows for example the dynamic registration of callback functions that are defined in another data driven system (scripting languages, etc.).
  • Full access to dynamic data. The application is able to get and set all variables from the state machines, get the stack of the state machine, etc.
  • Parameters for Events. Events support arbitrary parameters and give you more flexibility when conrolling the action of your AI entities.
  • Built-In Function for FSM Instance ID. Library and Creator feature a built-in function that allows easier identification and handling of FSMs during runtime.
  • Thread safety. The creation and usage of the state machine instances is completely thread-safe. The debugger works also in threaded environments, allowing you to block the main thread execution if a state machine has been blocked by a breakpoint.
  • Integration in asynchronous environments. The library supports suspending of individual fsm executions. This allows you to implement asynchronous getter functions that suspends the state machine and resumes when the result is available. Incoming events while suspending are queued separately to emulate a zero execution time of the asynchronous access.
  • Custom memory allocator. The library can be initialized to use any custom memory allocator. The library itself uses no direct calls to C++ memory heap. You can provide your own memory allocation scheme or use one of your favorite game engines.
  • Custom random generator. Allows the usage of custom random generators with certain constraints. Configuration files from various data sources. The configuration files can be loaded directly from memory blocks or user provided streams.
  • For faster startup implementations there is also a file based implementation.
  • Data serialization from/to various data sources. The runtime data can be serialized directly from/to memory blocks or user provided streams. For faster startup implementations there is also a file based serialization stream.
  • Wide platform and compiler support
    • Win32/64 using VC2005,VC2008,VC2010 (static and dynamic library)
    • Linux32/64 using GCC4.1,GCC4.4 (static and dynamic library)
    • Recent Xbox360 SDK (static library)
    • Recent PS3 SDK, GCC and SN Compiler (static library)
  • Full Documentation. The SDK comes with documentation for the API and high level concepts or the library. There are also source code examples for using the library in different scenarios.

xaitControl Creator Features

  • Multi-level graphical representation of state machines. Depending on the zoom level, the graphical representation hides details to allow an efficient workflow.
  • Grouping of state machines. FSMSets allow the definition of a shared runtime environment for different state machines. An environment is defined by available callback functions and variables. All state machines in a set are potential sub-state machines for each other. FSMs and FSM-Sets can also be organized into folders of arbitrary depth in the project tree. This increases the possibilties of structuring your Control projects in a logical and convenient manner.
  • Parameters for Events. Events support arbitrary parameters and give you more flexibility when conrolling the action of your AI entities.
  • Built-In Function for FSM Instance ID. Library and Creator feature a built-in function that allows easier identification and handling of FSMs during runtime.
  • Different kinds of transitions. xaitControl provides a variety of different transitions types to simplify the modeling process.
  • Different trigger types
    • Event transitions. Triggered by application events.
    • Direct transitions. Triggered by an implicit enter state event. Can be used to model a control flow.
    • Time-based transitions. Delayed evaluation of direct transitions.
  • Different source types
    • Normal transitions. From one state to another.
    • Global transitions. Transitions without source state. Typically used for exception handling.
  • Simple language to define pre and postconditions of transitions with full access on callback functions and instance memory.
  • Customizable GUI layout. The GUI of the tool can be changed to fit your needs by using the flexible window management. Mouse, color and grid settings can be individually customized.
  • Multi-user environment. The project structure has been set up for use in multi-user environments. There are per user settings which can influence target paths of path data. The file structure is suitable for file base version control systems, so there is no big monolithic xml file which is hard to merge in a case of conflicts.
  • Document view allows you to navigate through the last visited state machines within the Creator.

Fully Integrated Graphical Debugger

  • Full access on runtime data
    • Existing state machine instances.
    • Variables. Watch and change variables in the memory of the instance.
    • Events Queue. Remove or Add events from the current event queue.
    • Resetting of instances
  • Debugging of non-existing instances. The debugger allows the addressing of an instance by name to debug instances on creation time without human influences.
  • Different kinds of breakpoints.
    • At different locations ‘Enter state’ and ‘Leave state’
    • Different kinds ‘Normal breakpoint’ and ‘Condition breakpoint’ with simple Boolean conditions
  • Blocking of transitions which allows an explicit control flow.
  • History trail. Graphical representation of the program flow with all information about changed variables. This can be used to evaluate why a certain state changed happened and what goes wrong.
  • Supports all library platforms
    • PC (Windows / Linux): TCP/IP
    • XBOX360: TCP/IP
    • PS3: TCP/IP
    • Wii: USB


License Name Price in $US Source Code Included?
GPL Unspecified No

This tool hasn't been reviewed yet. Be the first!

Write a Review

Suggest Edits

Last edited Jan 22, 2012 at 07:35