Tutorials

I have taken a break from the spherical terrain and virtual world project to work on something a little less complex. I am creating a relatively simple script-only resource for T3D that simply moves objects and players along a path. The resource uses the existing T3D path system, and can be used to create a looping path or a non looping path.

This resource could be used to create currents in rivers, to move cameras or scene decorations around a level, to guide a player towards the next objective, or to create animated effects within a game level.

I am also working on a proximity detection feature which will automatically engage the “force” when the player intersects the path. This is proving to be a lot more complex that I thought, since the path is not solid, and the distance between nodes in the path is not known, and could be large, so I can’t just use a radius search.

Instead, I need to use vector math. I create a vector from the closest node to the player to the two other nodes in both directions. I then normalise these vectors, and scale them by the distance from the player to the closest node. Adding these vectors to the closest node gives me the two points closest to the player on the imaginary lines between the path nodes. If the distance from the player to either of these two points is less than a certain value, the player is captured within the force field.
This concept seems to work, but the implementation is still a little buggy.

I will post the link to the resource once I have uploaded it.

I have decided to release my Computational Fluid Dynamics code as a free resource for users of the Torque 3D game engine.

My resource can be found here:

http://www.garagegames.com/community/blogs/view/22519

I have duplicated the text of the resource below.

This resource adds support for “metablobs” to T3D. This can allow for very realistic fluid simulations, much more so than can be achieved with particle effects.

Included are a realistic Water material, a Lava Material, A Tar material, and a Mud material. I have also included a ported version of the renderMonkey glitter shader.

Tutorial:

First, download the resource from here: (4.2MB’s, .RAR archive)
http://www.phoenixgamedevelopment.com/downloads/FluidDynamics.rar

Copy the “Fluid Dynamics” folder to:
“game/art/shapes/FluidDynamics”

Inside the archive is a folder called “SHADERS”. All files in this folder should be copied to:
game/shaders/common/
Drop the files directly in that folder, do not include the “SHADERS” directory itself.

There should also be a folder called “CODE”. All files in this directory should be added to:
“engine/source/T3D/examples/metaBlobs”
In your compiler, you will then need to add these files to the build.

In order to add MetaBlob based objects to the world using the editor, add the following line to:
“game/tools/worldeditor/scripts/editors/creator.ed.cs

Around line 100, under:
%this.registerMissionObject( “RenderShapeExample” );
add:
%this.registerMissionObject( “metaBlobExample” );

The resource folder also contains a sample mission file showing how to create a metablob object from code.

Finally, execute the file “fluiddynamics.cs” by adding the line:
exec(“art/shapes/FluidDynamics/fluiddynamics.cs”);
to:
“game/scripts/server/scriptExec.cs”

Any questions, comments, etc, can be directed to:
jackstone@phoenixgamedevelopment.com

I have prepared my Genetic Algorithm Example application for upload. I used the QT library to develop the application, but the executable should run on almost any Windows system, whether QT installed or not.

The executable is located HERE.

The source files are located HERE.

A code listing with comments follows, refer to my earlier post on this topic for more information. To build and execute this code, simple create a new QT gui application, and add the relevant files from the source directory.

gaentity.h:


#ifndef GAENTITY_H

#define GAENTITY_H

class GAEntity

{

public:

GAEntity(int maxnumber);

GAEntity();

int solution; //This is the first, and so far only, “chromasome” of the GA entity

int fitness;

};

#endif // GAENTITY_H

gaentity.cpp:



#include “gaentity.h”

GAEntity::GAEntity(int maxnumber)
{
solution = rand() % maxnumber + 1; //All GA entities are initialised with a random value from 1 to the max number.
fitness = 999; //lower fitness values are better, so initialise entity with an impossibly high value
}

GAEntity::GAEntity()
{
solution = rand() % 1000 + 1; // default constructor, assumes max value is 1000
fitness = 999;
}

Main Logic Function:



void MainWindow::runbtnpushed(){

srand ( time(NULL) ); //init time for random number function
QString s = “”;
//init variables from gui:
int targetnumber = ui->targetIN->value(); //The number that the AI is trying to guess
int maxgenerations = ui->maxgenerationsIN->value(); //The max number of generations that the algorithm will run for.
int populationsize = ui->popsizeIN->value(); //The number of entities to create in each generation, the more there are, the more chance they will solve the problem

int bestfitness = 999;

for(int i = 0; i < populationsize;i++){ GAEntity ent = GAEntity(ui->maxnumberIN->value()); //Create I entities and initialise to random value
ent.fitness = abs(targetnumber – ent.solution); //determine fitness (Simply subtract the solution from the targetnumber, and ignore the sign)
population.push_back(ent); //add to population vector
}
int count = 0;

//pick the best two candidates, mate them, produce new population
GAEntity parent1;
GAEntity parent2;

while(bestfitness > 0 && count < maxgenerations){
count++;

parent1.fitness = 999;
parent1.solution = 0;

//choose parents:
for(size_t i = 0; i < population.size();i++){ //lesser fitness is better

GAEntity ent = population[i];
//fitness:
int fitness = abs(targetnumber – abs(ent.solution));
//this code finds the two entities with the highest fitness. This would be an excellent place for improvement!
if(fitness < parent1.fitness){
parent2.fitness = parent1.fitness;
parent2.solution = parent1.solution;

parent1.fitness = ent.fitness;
parent1.solution = ent.solution;

}else if(fitness < parent2.fitness){ parent2.fitness = ent.fitness; parent2.solution = ent.solution; } } //mate parents: GAEntity child; child.solution = (parent1.solution + parent2.solution)/2; //This is the “seed” for the next generation //print data to gui s = “Generation: “; s.append(QString::number(count)); s.append(” Parent 1 Fitness: “); s.append(QString::number(abs(targetnumber – abs(parent1.solution)))); s.append(” Parent 2 Fitness: “); s.append(QString::number(abs(targetnumber – abs(parent2.solution)))); ui->textBrowser->append(s);

if(abs(targetnumber – abs(child.solution) == 0)){ //Solution has been found!
//qDebug() << “Solution found!” << child.solution << ” Generation: ” << count; ui->textBrowser->append(“”);
s = “Solution found! Solution: “;
s.append(QString::number(child.solution));
s.append(” Generation: “);
s.append(QString::number(count));
ui->textBrowser->append(s);
bestfitness = 0;
}

population.clear(); //delete old population
//mutate child and produce new population:
for(int i = 0; i < populationsize;i++){

GAEntity ent;

//Random Mutation:
float rnd1 = static_cast (rand()) / static_cast (RAND_MAX);
int rnd = rand() % 2 + 0;

if(rnd1 > 0.5 && child.solution-rnd >0)
ent.solution = child.solution-rnd;
else
ent.solution = child.solution+rnd;

//eval fitness here:
//ent.fitness = abs(targetnumber – ent.solution);
population.push_back(ent);

}
}

//print out all entities:
for(size_t i = 0; i < population.size();i++){
// qDebug() << “ID: ” << i << ” Solution: ” << population[i].solution << ” Fitness: ” << abs(targetnumber – population[i].solution);//population[i].fitness;
}

}