galaxy_gen.cpp File Reference

#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <string>
#include "macosx_math.h"
#include <math.h>
#include <time.h>
#include <assert.h>
#include "configxml.h"
#include "vs_globals.h"
#include "xml_support.h"
#include "gfxlib.h"
#include "galaxy_xml.h"
#include "galaxy_gen.h"
#include "vs_random.h"
#include <ctype.h>
#include "vsfilesystem.h"

Go to the source code of this file.

Classes
struct	StarSystemGent::Color
class	StarSystemGent::Vector
struct	StarSystemGent::GradColor
struct	StarSystemGent::PlanetInfo
struct	StarSystemGent::StarInfo

Namespaces
	StarSystemGent

Constant Groups
	StarSystemGent

Macros
#define	M_PI   3.1415926536

Functions
static void	seedrand (unsigned long seed)
static int	stringhash (const string &key)
static unsigned int	ssrand ()
static string	GetWrapXY (string cname, int &wrapx, int &wrapy)
string	getStarSystemName (const string &in)
float	StarSystemGent::mmax (float a, float b)
int	StarSystemGent::rnd (int lower, int upper)
string	StarSystemGent::getGenericName (vector< string > &s)
string	StarSystemGent::getRandName (vector< string > &s)
float	StarSystemGent::grand ()
static void	StarSystemGent::Tab ()
float	StarSystemGent::difffunc (float inputdiffuse)
void	StarSystemGent::WriteLight (unsigned int i)
void	StarSystemGent::ResetGlobalVariables ()
void	StarSystemGent::readColorGrads (vector< string > &entity, const char *file)
float	StarSystemGent::clamp01 (float a)
float	StarSystemGent::getcolor (float c, float var)
GradColor	StarSystemGent::whichGradColor (float r, unsigned int &j)
Color	StarSystemGent::StarColor (float radius, unsigned int &entityindex)
GFXColor	StarSystemGent::getStarColorFromRadius (float radius)
float	StarSystemGent::LengthOfYear (Vector r, Vector s)
void	StarSystemGent::CreateLight (unsigned int i)
Vector	StarSystemGent::generateCenter (float minradii, bool jumppoint)
float	StarSystemGent::makeRS (Vector &r, Vector &s, float minradii, bool jumppoint)
void	StarSystemGent::Updateradii (float orbitsize, float thisplanetradius)
Vector	StarSystemGent::generateAndUpdateRS (Vector &r, Vector &s, float thisplanetradius, bool jumppoint)
vector< string >	StarSystemGent::parseBigUnit (const string &input)
void	StarSystemGent::WriteUnit (const string &tag, const string &name, const string &filename, const Vector &r, const Vector &s, const Vector &center, const string &nebfile, const string &destination, bool faction, float thisloy=0)
string	StarSystemGent::getJumpTo (const string &s)
string	StarSystemGent::starin (const string &input)
string	StarSystemGent::GetNebFile (string &input)
string	StarSystemGent::AnalyzeType (string &input, string &nebfile, float &radius)
void	StarSystemGent::MakeSmallUnit ()
void	StarSystemGent::MakeJump (float radius, bool forceRS=false, Vector R=Vector(0, 0, 0), Vector S=Vector(0, 0, 0), Vector center=Vector(0, 0, 0), float thisloy=0)
void	StarSystemGent::MakeBigUnit (int callingentitytype, string name=string(), float orbitalradius=0)
void	StarSystemGent::MakeMoons (float callingradius, int callingentitytype)
void	StarSystemGent::MakeJumps (float callingradius, int callingentitytype, int numberofjumps)
void	StarSystemGent::MakePlanet (float radius, int entitytype, string texturename, string unitname, string technique, int texturenum, int numberofjumps, int numberofstarbases)
void	StarSystemGent::beginStar ()
void	StarSystemGent::endStar ()
void	StarSystemGent::CreateStar ()
void	StarSystemGent::CreateFirstStar ()
void	StarSystemGent::CreatePrimaries ()
void	StarSystemGent::CreateStarSystem ()
void	StarSystemGent::readentity (vector< string > &entity, const char *filename)
const char *	StarSystemGent::noslash (const char *in)
string	getStarSystemFileName (const string &input)
string	getStarSystemSector (const string &in)
void	readnames (vector< string > &entity, const char *filename)
void	readplanetentity (vector< StarInfo > &starinfos, string planetlist, unsigned int numstars)
static int	pushDown (int val)
static int	pushDownTowardsMean (int mean, int val)
static int	pushTowardsMean (int mean, int val)
void	generateStarSystem (SystemInfo &si)

Variables
static VSRandom	starsysrandom (time(NULL))
const char	StarSystemGent::nada [1] = ""
vector< Color >	StarSystemGent::lights
VSFile	StarSystemGent::f
int	StarSystemGent::xmllevel
const int	StarSystemGent::STAR = 0
const int	StarSystemGent::PLANET = 1
const int	StarSystemGent::MOON = 2
const int	StarSystemGent::JUMP = 3
vector< string >	StarSystemGent::starentities
vector< string >	StarSystemGent::jumps
vector< string >	StarSystemGent::gradtex
vector< string >	StarSystemGent::naturalphenomena
vector< string >	StarSystemGent::starbases
unsigned int	StarSystemGent::numstarbases
unsigned int	StarSystemGent::numnaturalphenomena
unsigned int	StarSystemGent::numstarentities
vector< string >	StarSystemGent::background
vector< string >	StarSystemGent::names
vector< string >	StarSystemGent::rings
const float	StarSystemGent::moonofmoonprob = .01
string	StarSystemGent::systemname
vector< float >	StarSystemGent::radii
const float	StarSystemGent::minspeed = .001
const float	StarSystemGent::maxspeed = 8
vector< float >	StarSystemGent::starradius
string	StarSystemGent::faction
vector< GradColor >	StarSystemGent::colorGradiant
float	StarSystemGent::compactness = 2
float	StarSystemGent::jumpcompactness = 2
vector< StarInfo >	StarSystemGent::stars
unsigned int	StarSystemGent::planetoffset
unsigned int	StarSystemGent::staroffset
unsigned int	StarSystemGent::moonlevel

Macro Definition Documentation

#define M_PI   3.1415926536

Definition at line 27 of file galaxy_gen.cpp.

Referenced by GamePlanet::AddCity(), GamePlanet::AddRing(), aim_assist(), Atmosphere::Atmosphere(), Unit::DamageRandSys(), anonymous_namespace{plane_display.cpp}::Degree2Radian(), Bolt::Draw(), DrawOneTargetBox(), GameCockpit::GameCockpit(), GFXCircle(), GFXPerspective(), Planet::InitPlanet(), SphereMesh::InitSphere(), StarSystemGent::LengthOfYear(), Audio::TemplateManager::loadSourceTemplate(), MinRotationFromDirections(), StarSystemGent::Vector::Pitch(), Radar::PlaneDisplay::PlaneDisplay(), StarSystemGent::Vector::Roll(), SetDirection(), Orders::FireAt::ShouldFire(), Audio::Test::testComplexScene(), and StarSystemGent::Vector::Yaw().

Function Documentation

void generateStarSystem

(

SystemInfo &

si)

Definition at line 1344 of file galaxy_gen.cpp.

References SystemInfo::asteroids, SystemInfo::asteroidslist, StarSystemGent::background, SystemInfo::backgrounds, SystemInfo::compactness, StarSystemGent::compactness, VSFileSystem::CreateDirectoryHome(), StarSystemGent::CreateStarSystem(), f, SystemInfo::faction, StarSystemGent::faction, SystemInfo::filename, VegaConfig::getVariable(), StarSystemGent::gradtex, i, int, StarSystemGent::jumpcompactness, SystemInfo::jumps, StarSystemGent::jumps, SystemInfo::name, SystemInfo::names, StarSystemGent::names, StarSystemGent::naturalphenomena, SystemInfo::nebulae, SystemInfo::nebulaelist, StarSystemGent::numnaturalphenomena, StarSystemGent::numstarbases, StarSystemGent::numstarentities, SystemInfo::numstars, SystemInfo::numun1, SystemInfo::numun2, VSFileSystem::Ok, XMLSupport::parse_float(), XMLSupport::parse_int(), SystemInfo::planetlist, pushTowardsMean(), StarSystemGent::readColorGrads(), StarSystemGent::readentity(), readnames(), readplanetentity(), StarSystemGent::ResetGlobalVariables(), SystemInfo::ringlist, StarSystemGent::rings, SystemInfo::sector, SystemInfo::seed, seedrand(), VSFileSystem::sharedsectors, SystemInfo::smallun, StarSystemGent::starbases, StarSystemGent::starradius, SystemInfo::stars, StarSystemGent::stars, stringhash(), SystemInfo::sunradius, VSFileSystem::SystemFile, StarSystemGent::systemname, VSFileSystem::universe_name, vs_config, and VSFileSystem::vs_fprintf().

Referenced by MakeStarSystem().

{
    ResetGlobalVariables();
    static float radiusscale = XMLSupport::parse_float( vs_config->getVariable( "galaxy", "StarRadiusScale", "1000" ) );
    si.sunradius *= radiusscale;
    systemname    = si.name;
    static float compactness_scale = XMLSupport::parse_float( vs_config->getVariable( "galaxy", "CompactnessScale", "1.5" ) );
    static float jump_compactness_scale =
        XMLSupport::parse_float( vs_config->getVariable( "galaxy", "JumpCompactnessScale", "1.5" ) );
    static int   meannaturalphenomena   = XMLSupport::parse_int( vs_config->getVariable( "galaxy", "MeanNaturalPhenomena", "1" ) );
    static int   meanbases = XMLSupport::parse_int( vs_config->getVariable( "galaxy", "MeanStarBases", "2" ) );
    compactness     = si.compactness*compactness_scale;
    jumpcompactness = si.compactness*jump_compactness_scale;
    if (si.seed)
        seedrand( si.seed );
    else
        seedrand( stringhash( si.sector+'/'+si.name ) );
    VSFileSystem::vs_fprintf( stderr, "star %d, natural %d, bases %d", si.numstars, si.numun1, si.numun2 );
    int nat = pushTowardsMean( meannaturalphenomena, si.numun1 );
    numnaturalphenomena = nat > si.numun1 ? si.numun1 : nat;
    numstarbases    = pushTowardsMean( meanbases, si.numun2 );
    static float smallUnitsMultiplier = XMLSupport::parse_float( vs_config->getVariable( "galaxy", "SmallUnitsMultiplier", "0" ) );
    numstarbases    = (int) (si.numun2*smallUnitsMultiplier);
    numstarentities = si.numstars;
    VSFileSystem::vs_fprintf( stderr, "star %d, natural %d, bases %d", numstarentities, numnaturalphenomena, numstarbases );
    starradius.push_back( si.sunradius );
    readColorGrads( gradtex, (si.stars).c_str() );

    readentity( starbases, (si.smallun).c_str() );
    readentity( background, (si.backgrounds).c_str() );
    if ( background.empty() )
        background.push_back( si.backgrounds );
    if (si.nebulae)
        readentity( naturalphenomena, (si.nebulaelist).c_str() );
    if (si.asteroids)
        readentity( naturalphenomena, (si.asteroidslist).c_str() );
    for (unsigned int i = 0; i < si.jumps.size(); i++)
        jumps.push_back( si.jumps[i] );
    faction = si.faction;

    readplanetentity( stars, si.planetlist, numstarentities );

    readentity( rings, (si.ringlist).c_str() );
    readnames( names, (si.names).c_str() );

    CreateDirectoryHome( VSFileSystem::sharedsectors+"/"+VSFileSystem::universe_name+"/"+si.sector );

    VSError err = f.OpenCreateWrite( si.filename, SystemFile );
    if (err <= Ok) {
        CreateStarSystem();
        f.Close();
    }
    ResetGlobalVariables();     //deallocate any unused memory in vectors.
}

string getStarSystemFileName

(

const string &

input)

Definition at line 1165 of file galaxy_gen.cpp.

{
    return input+string( ".system" );
}

string getStarSystemName

(

const string &

in)

Definition at line 1169 of file galaxy_gen.cpp.

References StarSystemGent::noslash().

Referenced by Universe::getAdjacentStarSystems(), StarSystem::getFileName(), Universe::getGalaxyProperty(), Universe::getGalaxyPropertyDefault(), StarSystemGent::MakeJump(), MakeStarSystem(), and GalaxyXML::SGalaxy::processSystem().

{
    return string( noslash( in.c_str() ) );
}

string getStarSystemSector

(

const string &

in)

Definition at line 1173 of file galaxy_gen.cpp.

{
    string::size_type sep = in.find( '/' );
    if (sep == string::npos)
        return string( "." );

    else
        return in.substr( 0, sep );
}

static string GetWrapXY ( string  cname, int &  wrapx, int &  wrapy  )

static

Definition at line 54 of file galaxy_gen.cpp.

Referenced by StarSystemGent::MakePlanet().

{
    string wrap = cname;
    wrapx = wrapy = 1;
    string::size_type pos = wrap.find( "wrapx" );
    if (pos != string::npos) {
        string Wrapx = wrap.substr( pos+5, wrap.length() );
        cname = cname.substr( 0, pos );
        sscanf( Wrapx.c_str(), "%d", &wrapx );
        pos   = Wrapx.find( "wrapy" );
        if (pos != string::npos) {
            string Wrapy = Wrapx.substr( pos+5, Wrapx.length() );
            sscanf( Wrapy.c_str(), "%d", &wrapy );
        }
    }
    return cname;
}

static int pushDown ( int  val)

static

Definition at line 1323 of file galaxy_gen.cpp.

References StarSystemGent::grand().

Referenced by pushDownTowardsMean().

{
    while ( grand() > (1/val) )
        val--;
    return val;
}

static int pushDownTowardsMean ( int  mean, int  val  )

static

Definition at line 1329 of file galaxy_gen.cpp.

References pushDown().

Referenced by pushTowardsMean().

{
    int delta = mean-1;
    return delta+pushDown( val-delta );
}

static int pushTowardsMean ( int  mean, int  val  )

static

Definition at line 1334 of file galaxy_gen.cpp.

References VegaConfig::getVariable(), XMLSupport::parse_bool(), pushDownTowardsMean(), and vs_config.

Referenced by generateStarSystem().

{
    static bool dopushingtomean = XMLSupport::parse_bool( vs_config->getVariable( "galaxy", "PushValuesToMean", "true" ) );
    if (!dopushingtomean)
        return val;
    if (val < mean)
        return -pushDownTowardsMean( -mean, -val );
    return pushDownTowardsMean( mean, val );
}

void readnames	(	vector< string > &	entity,
		const char *	filename
	)

warning... obvious vulnerability

Definition at line 1182 of file galaxy_gen.cpp.

References VSFileSystem::VSFile::Close(), VSFileSystem::VSFile::Eof(), f, i, input_buffer, VSFileSystem::Ok, VSFileSystem::VSFile::OpenReadOnly(), VSFileSystem::VSFile::ReadLine(), and VSFileSystem::UniverseFile.

Referenced by generateStarSystem().

{
    VSFile  f;
    VSError err = f.OpenReadOnly( filename, UniverseFile );
    if (err > Ok)
        return;
    char input_buffer[1000];
    while ( !f.Eof() ) {
        f.ReadLine( input_buffer, 999 );
        if (input_buffer[0] == '\0' || input_buffer[0] == '\n' || input_buffer[0] == '\r')
            continue;
        for (unsigned int i = 0; input_buffer[i] != '\0' && i < 999; i++) {
            if (input_buffer[i] == '\r')
                input_buffer[i] = '\0';
            if (input_buffer[i] == '\n') {
                input_buffer[i] = '\0';
                break;
            }
        }
        entity.push_back( input_buffer );
    }
    f.Close();
}

void readplanetentity	(	vector< StarInfo > &	starinfos,
		string	planetlist,
		unsigned int	numstars
	)

Definition at line 1207 of file galaxy_gen.cpp.

References _Universe, Universe::getGalaxy(), GalaxyXML::Galaxy::getPlanetNameFromInitial(), GalaxyXML::Galaxy::getPlanetVariable(), i, j, StarSystemGent::jumps, k, StarSystemGent::numstarbases, XMLSupport::parse_int(), rnd(), size, and VSFileSystem::vs_fprintf().

Referenced by generateStarSystem().

{
    if (numstars < 1) {
        numstars = 1;
        vs_fprintf( stderr, "No stars exist in this system!\n" );
    }
    string::size_type i, j;
    unsigned int u;
    starinfos.reserve( numstars );
    for (u = 0; u < numstars; ++u)
        starinfos.push_back( StarInfo() );
    u--;
    while (i = planetlist.find( ' ' ), 1) {
        if (i == 0) {
            planetlist = planetlist.substr( 1 );
            continue;
        }
        int nummoon = 0;
        for (j = 0; j < i && j < planetlist.size() && planetlist[j] == '*'; ++j)
            nummoon++;
        if (nummoon == 0)
            u++;
        if ( j == string::npos || j >= planetlist.size() ) break;
        starinfos[u%numstars].planets.push_back( PlanetInfo() );
        starinfos[u%numstars].planets.back().moonlevel = nummoon;
        {
            GalaxyXML::Galaxy *galaxy = _Universe->getGalaxy();
            
            static const string numtag("#num#");
            static const string empty;
            static const string::size_type numlen = numtag.length();
            string::size_type numpos;
            
            // Get planet name and texture
            string planetname  = galaxy->getPlanetNameFromInitial( planetlist.substr( j, i == string::npos ? string::npos : i-j ) );
            string texturename = galaxy->getPlanetVariable( planetname, "texture", "No texture supplied in <planets>!" );
            
            // Get unit name, deriving a default name from its texture
            string defunitname = texturename.substr(0, texturename.find_first_of('|'));
            if (defunitname.find_last_of('/') != string::npos)
                defunitname = defunitname.substr(defunitname.find_last_of('/')+1);
            defunitname = defunitname.substr(0, defunitname.find_last_of('.'));
            
            numpos=0;
            while ((numpos = defunitname.find(numtag, numpos)) != string::npos)
                defunitname.replace(numpos, numlen, empty);
            
            string unitname    = galaxy->getPlanetVariable( planetname, "unit", defunitname );
            
            // Get planet rendering technique
            string techniquename=galaxy->getPlanetVariable( planetname, "technique", "" );
            
            // Replace randomized number placeholder tags
            starinfos[u%numstars].planets.back().num =
                rnd( XMLSupport::parse_int( galaxy->getPlanetVariable( planetname, "texture_min", "0" ) ),
                     XMLSupport::parse_int( galaxy->getPlanetVariable( planetname, "texture_max", "0" ) ) );
            
            char num[32];
            if (starinfos[u%numstars].planets.back().num == 0)
                num[0] = 0;
            else
                snprintf(num, sizeof(num), "%d", starinfos[u%numstars].planets.back().num);
            
            numpos=0;
            while ((numpos = texturename.find(numtag, numpos)) != string::npos)
                texturename.replace(numpos, numlen, num);
            
            // Store info
            starinfos[u%numstars].planets.back().name = texturename;
            starinfos[u%numstars].planets.back().unitname = unitname;
            starinfos[u%numstars].planets.back().technique = techniquename;
        }
        starinfos[u%numstars].planets.back().numstarbases = 0;
        starinfos[u%numstars].planets.back().numjumps     = 0;
        if (i == string::npos) break;
        planetlist = planetlist.substr( i+1 );
    }
    unsigned int k;
    if ( starinfos.size() ) {
        bool size = 0;
        for (k = 0; k < starinfos.size(); ++k)
            if ( starinfos[k].planets.size() ) {
                size = true;
                break;
            }
        if (!size) {
            int oldjumps     = jumps.size();
            int oldstarbases = numstarbases;
            int newstuff;
            for (k = starinfos.size(); k > 0; --k) {
                newstuff      = oldjumps/k;
                starinfos[k-1].numjumps = newstuff;
                oldjumps     -= newstuff;
                newstuff      = oldstarbases/k;
                starinfos[k-1].numstarbases = newstuff;
                oldstarbases -= newstuff;
            }
        } else {
            for (k = 0; k < jumps.size(); ++k) {
                vector< PlanetInfo > *temp;                 //& doesn't like me so I use *.
                do
                    temp = &starinfos[rnd( 0, starinfos.size() )].planets;
                while ( !temp->size() );
                (*temp)[rnd( 0, temp->size() )].numjumps++;
            }
            for (k = 0; k < numstarbases; ++k) {
                vector< PlanetInfo > *temp;                 //& appears to still have dislike for me.
                do
                    temp = &starinfos[rnd( 0, starinfos.size() )].planets;
                while ( !temp->size() );
                (*temp)[rnd( 0, temp->size() )].numstarbases++;
            }
        }
    }
}

static void seedrand ( unsigned long  seed)

static

Definition at line 36 of file galaxy_gen.cpp.

References starsysrandom.

Referenced by generateStarSystem().

{
    starsysrandom = VSRandom( seed );
}

static unsigned int ssrand ( )

static

Definition at line 49 of file galaxy_gen.cpp.

References VSRandom::rand(), and starsysrandom.

Referenced by StarSystemGent::grand(), and StarSystemGent::rnd().

{
    return starsysrandom.rand();
}

static int stringhash ( const string &  key)

static

Definition at line 40 of file galaxy_gen.cpp.

References k, and start.

Referenced by generateStarSystem().

{
    unsigned int k = 0;
    string::const_iterator start = key.begin();
    for (; start != key.end(); start++)
        k += (k*128)+*start;
    return k;
}

Variable Documentation

VSRandom starsysrandom(time(NULL))

static

Referenced by seedrand(), and ssrand().