OpenSkyNet / News: Recent posts

Pathfinding libs now build on Android using the NDK

Most work in 2010 will probably involve major improvements to the finite state machine tool, as there is an immediate need for it in http://tactics3d.sourceforge.net/.

For pathfinding, I have implemented navmesh generation algorithms before, so perhaps it is time for a new open source implementation here.

OpenSkyNet - Moving towards a comprehensive artificial intelligence solution for game developers under the LGPL. The goals are to implement action selection solvers, robust steering behaviors (including pathfinding algorithms), and machine learning.

The motherboard and hard drive on my Win2K box both finally died after almost a decade of use. Now, I have an Ubuntu laptop. What this means for OpenSkyNet is that I will be focused on Linux development for the time being. The first release from my new setup contains the pathfinding API AND demo compiling on GCC without warnings. I will no longer distribute binaries of the demo until I get another Windows machine. The demo will eventually evolve into a future iteration of my other project at http://tactics3d.sourceforge.net/.
That project WILL distribute binaries for various platforms.

The big news with this release is that, like any good open source project, the code is now platform independent. I finally acquired a Linux box to test with - my PS3 running Debian.

The other updates are:

Transformable waypoint collections (WPCs) are now incorporated into the pathfinding algorithms. WPCs are inserted as subpaths when a pathfinding algorithm reaches a bin solely occupied by an obstacle with a corresponding WPC.... read more

The distribution of the pathfinding library has changed slightly. The API release will now only contain the code and docs. Removing the demo data from the API release saves significant download time on slow connections.

New changes in 0.41:
1) A custom hash table, optimized for speed, is used to store bin data rather than using large, multi-dimensional arrays. See the benchmark tests versus std::map and stdext::hash_map in the Utils project. Here's a graph: http://openskynet.sourceforge.net/img/HashBenchmarkTests.jpg
and some stats: http://openskynet.sourceforge.net/HashBenchmarkTests.csv... read more

Hold on tight. A code review is eminent. Possible changes include:

Refactoring the library for memory/speed improvements, easing future extensibility, and easing integration w/ the pathfinding library.

Refactoring the GUI designer for memory/speed improvements and easing future extensibility (this will probably include moving to .NET 2.0).

Adding a multitude of unit tests.

Getting the library's coding standards in line with the pathfinding library.... read more

New feature: Transformable waypoint collections (WPCs) - WPCs can be stored offline per obstacle in *.wpc.xml files, allowing quickly calculated avoidance of complex translating obstacles. See the README included with the library for more info.

Ogre, CEGUI, and tinyxml dependencies have been updated to their most recent versions.

The next release, 0.41, will focus on adding more documentation and unit tests.... read more

11/26/05 v0.36
Compiled and tested w/ GCC (MinGW build) and Code::Blocks IDE (http://www.codeblocks.org/). Code::Blocks workspace included. Also included MSVC++ 7.1 solution.

Finished TODOs related to collision detection callbacks.

Fixed camera bug (others still exist, though)

Removed drivers subdividing the world AABB when stuck in one bin for too long. Subdivisions do work, but the definition of when a driver is "stuck" needs reworking. ... read more

New major features in version 0.35:

1) Piecemeal pathfinding - multi-threading support was removed in version 0.3 due to lack of time to fully debug it. However, incremental pathdfinding provides many of the benefits of multi-threading without all the pain. It is a user-settable option to determine the number of seconds alloted for pathfinding each call.

2) Batch pathfinding calls - Multiple drivers are often pathfinding w/ the same subdivision of the grid at any given time. Huge performance savings can be had in both speed and memory by sharing occupied bin data.

- Added A* algorithm, diagonal movement, and spline curves
- Updated to Ogre rendering engine 1.0
- Added a GUI (using Crazy Eddie's GUI system)

PF API Version 0.1 is released. Please view the homepage for documentation info and screenshots.
Goals stated on 2004-07-23 16:29:
1) Allow using a breadth first search for finding paths - Done
2) Make integration with any collision detection and/or physics system easy -
The class used for simple obstacle detection and avoidance in this library is CD::Volume. This is a rudimentary class and should not require much work to allow other collision volume classes to directly replace, inherit from, or wrap it.
3) a) Allow pathfinding calls to run on their own threads - Done
b) Balance their implementation for efficiency and memory usage -
Done, no significant loss of framerate during pathfinding and very little RAM is used.
c) Balance their implementation for robustness (for usage in many types of games) and scalability (for handling large, complex paths) -
NOT done, paths can currently contain a maximum of 19 steps (directions) do to their storage in a 64-bit integer in the BFS queue. The manager class tries to be as game agnostic as possible and limits the interface while allowing for a diversity of pathfinding algorithms, so the robustness goal has been reached.
d) Allow for the easy inclusion of future features -
Unknown, no plugin ability exists and its necessity has not be determined. At the very least, the current design makes hardcoding new pathfinding algorithms (e.g. A*) easier.
4) Give the library the advantages of a black box approach, yet still allowing for benefits inherent in a tightly integrated AI engine. This means that while this library could be used on its own without difficulty, hooks will be added to this and other libraries on this site to allow them to function together fluidly (e.g. the finite state machine library will be aware of and can make calls to the pathfinding library with little to no coding necessary from the end developer) -
Not done. The black box goal has been reached in that this library depends on no 3rd party code and can be inserted into any game and manipulated through a simple, single interface. However, no integration with other libraries from OpenSkyNet has begun.

The next release will be the first iteration of a pathfinding library for guiding objects in 2D/3D space. This release will at first only allow using a breadth first search for finding paths, with other algorithms coming afterwards. Goals for this library include: 1) Making integration with any collision detection and/or physics system easy, 2) Allowing pathfinding calls to run on their own threads and balancing their implementation for efficiency, memory usage, robustness (for usage in many types of games), scalability (for handling large, complex paths), and the easy inclusion of future features, and 3) To give the library the advantages of a black box approach, yet still allowing for benefits inherent in a tightly integrated AI engine. This means that while this library could be used on its own without difficulty, hooks will be added to this and other libraries on this site to allow them to function together fluidly (e.g. the finite state machine library will be aware of and can make calls to the pathfinding library with little to no coding necessary from the end developer). I am shooting for the alpha to be completed by Sept 30th.

The first release date is April 15th, 2004

Items included:

A visual authoring tool for creating AI state machines based on premises and boolean logic, written in C#. It can export the state machines as C++ code. This code is not standalone. It uses an AI library (the API will also be released on the 15th) to wrap other game objects with an AI class and control their actions depending on an object's state. The in-game implementation of the states' transitional inputs is via an exception handling mechanism by objects in the game loop. Along with its current state, an object with an AI wrapper also contains a knowledge base that stores the premises that it receives. Thus, the state machines' inputs may come from premises that have spawned at any time in the object's life.