1. Overview

2. Demo

3. Detailed Information

NeuroDriver 2 Enhanced Track Format is ready for a ride! (see preview clip & screenshots)

The track format of NeuroDriver has been greatly enhanced since the first version :

* The track file is now in XML format and is easier to edit (a track editor is also planned)

* More parameters (bias & tension) were added for controling the exact curvature of each track segment

* New track texture

* Auto-Generation of scenery objects around track - configurable in track XML file and very easy to use!

Objects (trees, houses, banners, things, etc.) can be placed automatically around the track margins during the track generation phase.

By adding a short entry to the track XML file you can control the following parameters:
- Object's 3D model (tree, car, jelly-fish, etc.)
- Start Waypoint (objects will be placed starting from this track waypoint)
- End Waypoint (where to stop placing objects)
- Step Size (place object every X waypoints)
- Distance (distance from track margins)
- Side (on which side of the track to place the objects - Left, Right or Both)

Several Auto-Generate entries can be added to the track XML file, each with its own parameters.
So it is very easy to populate the track area with hundreds of objects without having to actually
place each individual object by hand.

Here's a sample track XML file: sample_track.xml (comments & suggestions are welcome)

 

 

NeuroDriver 2 Announced - check out the early preview

NeuroDriver 2 builds on top of the NeuroDriver framework.

A simple graphics engine was developed which works with a scene graph of objects.
Most objects inherit from a Geometry class (e.g. GeomMesh, GeomStatic, etc. )
A transofrmation matrix is attached to each Geom when it is inserted into the graph.

To ensure optimal resource management, loading of resources (meshes, textures, fonts)
is handled by the Framework's resource system (ResourceSys).

All data files (tracks, car config files, etc.) are now in XML format (I use tinyXML for that)

Every object added to the world can interact with the physics engine (built on top of ODE)
This adds a whole new dimension to the simulation - vehicles can now collide with scenery objects.
This motivated me to modify the neural-network AI to work with proximity sensors,
The vehicle is surrounded by several sensors which measure the distance to the nearest obstacle,
The distances are then used as input to the neural-network which controls the vehicle.

The NeuroDriver framework is finally complete.

I've implemented the following sub-systems:

LogSys - provides file logging services. supports priorities, timestamp, variable argument list (printf style).

TimeSys - provides timing services with both a real-time clock and a simulation-time clock.

InputSys - provides user input services such as Keyboard input processing.

Graphics Sys - provides low-level rendering services through a RenderDevice interface.

Resource Sys - provides interfaces to resource managers (e.g. TextureManager)

Interface pointers to all of the above sub-systems are obtained through a singleton Systems object.
The NeuroDriver application is built on-top of these sub-systems.

I'm now working on adding new features to NeuroDriver for the next version.
First thing on the list is an improved graphics engine. then a new track system and improved AI.
I'll keep updating this log during development and post new screenshots when they become available.

I've completed implementing the Graphics sub-system.
It uses abstract interface classes so it can be implemented by any 3D API.
(Currently it only has a Direct3D8 implementation).
I removed all the D3D code from the main application so it only uses the Graphics system
interface - this makes it easier to port the application to a different API in the future.

I still need to implement the Resource system and the Input system and then I can finally
concentrate on adding new features to NeuroDriver and release a new version.

I've released the source code for my neural-network class including a sample application which
demonstrates how a neural network can be used in a Role Playing Game.
The sample application also comes with full source code.

Currently I'm re-structuring the NeuroDriver code and making it more organized and modular.
Afterwards, I will probably release the full source-code, so stay tuned.

I'm also working on a simple game framework for use with my current and future projects.
It is based on several articles from the Game Programming Gems books.
Eventually, NeuroDriver will be adopted to work with this framework.
Then I'll start adding features and improve both the visuals and AI.

The initial version of the project, as featured on flipcode IOTD 06-Nov-2002 used only
Three values as inputs for the neural-network:

This gave nice results but I could only train the driver to "hug the center-line" of the track.
I then changed the inputs and instead of feeding the network only the Heading Factor for the next waypoint,
I fed it the Heading Factors for the next 3 waypoints.
This gave the network a "sense" for the shape of the track in-front of it (on straight sections the
heading factors are similar and on turns they differ from each other).
This change greatly improved the driver's steering behavior.

The next problem I encountered was that the AI driver would flip-over during turns.
In theory, the Traction input value should have caused the driver to slow down when it was about
to lose traction (when Traction value starts decreasing from 1.0 towards 0.0 ).
But in practice, the AI driver only started slowing down when it was already inside a turn which most of
The times ended with the car flipping over.

What I did was replace the Traction input with a TurnFactor input.
The TurnFactor value is the the delta between HeadingFactors of several waypoints in front of the car.
This gives the AI driver "turn prediction" capability, similar to a human driver looking ahead and seeing a turn
coming up on the horizon.
With the addition of the TurnFactor input, I could finally train the driver to brake before turns.
When a turn is several waypoints ahead of the car, the TurnFactor value increases and the AI driver now
Slows down, enters the turn at a reasonable speed and does not flip-over.