World.cpp

Go to the documentation of this file.

#include "World.h" 
#include "SpaceShip.h"
#include "GlobalParameters.h"
#include "Textures.h"
#include "Wrapper.h"
#include "Objects.h"
#include "FileAccess.h"
#include "MovingObject.h"
#include "Planet.h"
#include "Wrapper.h"
#include "SpaceShip.h"
#include "ForeignSpaceShip.h"
#include "Thargon.h"
#include "Pirate.h"
#include "Merchant.h"
#include "PoliceShip.h"
#include "GraphicsObject.h"
#include "PlayerObject.h"
#include "GameObject.h"
#include "Star.h"
#include "Planet.h"
#include "SpaceStation.h"

using namespace std;



void World::initialize() {
  // init the data structure
  GameObjects.clear();

  float lightspeed = 0.00815;

  // create player
  PlayerObject *player = new PlayerObject( 0, 0, 4100, 0 , 0);
  player->setView( Vector3( 0, 0, -1 ) );
  player->setMaxSpeed( lightspeed );
  player->setMinSpeed( -lightspeed*0.5 );
  player->setStep( lightspeed/20.0 * 0.2 );  // 0.2 is a calibration value ;) greater value increases speed faster
  player->setMoveSpeed( player->getMaxSpeed()*0.5 );

  GameObjects.push_back( player );

  list<GameObject*>::iterator it = GameObjects.begin();
  playerPosition = it;

  // create the star(s)
  Star *sun = new Star( 0, 0, 0, 1000, star );
  //sun->setLightColor( 0, 1, 0);
  sun->setAxis( 0, 1, 0 );
  sun->setSpeed( -0.006);
  sun->setRotateAngle( 0 );
  sun->setRotateSpeed( 0 );

  GameObjects.push_back( sun );
  starPosition = ++it;

  // get planets info
  vector<PlanetInfoGraphical> planets = *World::getWorld()->getSystemPlanets();

  // get a planet for placing coriolis station later  

  unsigned int coriolisPlanetNr = nrForCoriolis[wrapper->getCurrentSystem()];
  Planet * coriolisPlanet;

  // create planets
  PlanetInfoGraphical planet = planets[0];
  float scaleFactor = (4155.0*0.5) / (planet.distance); // this sets the distance of the first planet to 4155/2
  for( unsigned int i=0; i < planets.size(); i++ ) {    
    PlanetInfoGraphical planetInfo = planets[i];
    Planet *planet = new Planet( 0, 0, scaleFactor*planetInfo.distance, planetInfo.radius*10, planet1+i );
    planet->setAxis( 0, 1, 0 );
    planet->setColor( 0, 0, 0 );
    planet->setSpeed( planetInfo.spinningSpeed );
    // set rotate angle randomly, but in [-30,30] intervall
      // set corolis planet rotate angle randomly, but in [-15,15] intervall
    planet->setRotateAngle((rand()%61-30));
    //planet->setRotateAngle( 0 );
    planet->setRotateSpeed( 0 );
    GameObjects.push_back( planet );
    if (i == coriolisPlanetNr) 
        coriolisPlanet = planet;
    it++;
  }
  
  // set corolis planet rotate angle randomly, but in [-15,15] intervall
  // coriolisPlanet->setRotateAngle((rand()%31-15));
  coriolisPlanet->setRotateAngle(0);

  // create coriolis station
  SpaceStation *station = new SpaceStation( 1, Objects::getObjects()->getDisplayList( coriolis ) );
  // calculate random position in orbit
  float sx, sy, sz;
  sx = coriolisPlanet->getPos().x;
  sy = coriolisPlanet->getPos().y;
  sz =  coriolisPlanet->getPos().z;
  Vector3 a = Vector3( rand()%100, rand()%100, rand()%100);
  a.normalize();
  a = a * coriolisPlanet->getCollisionRadius()*2.0f;//4150 ); 
  station->setPos( sx+a.x, sy+a.y, sz+a.z );
  //station->setPos(sx,sy,sz);
  station->setSpeed( 0.006 );
  station->setAxis( a ); // Vector3( 0, 0, 1 ) );
  GameObjects.push_back( station );
  stationPosition = ++it;

  playerStartDistance = 1000;

  player->setPos(station->getPos().x,station->getPos().y,station->getPos().z+playerStartDistance);

  // create 5 up to 10 pirates
  unsigned int numOfPirates = rand()%6+5;
  //numOfPirates = 0;

  for (unsigned i = 0; i < numOfPirates; i++)
  {
      Pirate* ship;
      ship = World::getWorld()->createNewPirate( anaconda, 1, player, lightspeed*0.75 );

      // pirates are between player and station, but not at station (there is the police)
      int rangeStart = (int)((playerStartDistance) * 0.50); //-(int)playerStartDistance* 0.5;
      int rangeEnd = (int)((playerStartDistance) * 0.90);
      int range = rangeEnd-rangeStart;

      Vector3 offset;
      offset.x = (rand()%101)-50;
      offset.y = (rand()%101)-50;
      offset.z = (rand()%range)+rangeStart;

      Vector3 stationPos = station->getPos();

      ship->setPos (stationPos+offset);
  }

  // create thargoids; maximal 5, but less if there are already more than 5 pirates
  unsigned int maxNumberOfThargoids = max((int)0,(int)(11-numOfPirates));
  unsigned int numOfThargoids = rand()%(maxNumberOfThargoids+1);
  
  //numOfThargoids = 0;

  int thargoidPositionRangeStart = (int)((playerStartDistance) * 0.20);
  int thargoidPositionRangeEnd   = (int)((playerStartDistance) * 0.45);
  int thargoidPositionRange = thargoidPositionRangeEnd-thargoidPositionRangeStart;
  
  int thargoidPosition = rand()%thargoidPositionRange+thargoidPositionRangeStart;

  int thargoidRange = 100;

  for (unsigned i = 0; i < numOfThargoids; i++)
  {
      Thargon* ship;
      ship = World::getWorld()->createNewThargon( ball, 1, player, lightspeed/2 );

      // thargoids are all in a certain field      

      Vector3 offset;
      offset.x = (rand()%101)-50;
      offset.y = (rand()%101)-50;
      offset.z = (thargoidPosition+rand()%thargoidRange-thargoidRange/2);

      Vector3 stationPos = station->getPos();
      ship->setPos( stationPos + offset);

  }

  // create PoliceShips
  unsigned int numOfPoliceShips = 3 + rand()%3;

  int shipsPositionRangeStart = (int)((playerStartDistance) * 0.01);
  int shipsPositionRangeEnd   = (int)((playerStartDistance) * 0.15);
  int shipsPositionRange = shipsPositionRangeEnd-shipsPositionRangeStart;

  for (unsigned int i = 0; i < numOfPoliceShips; i++)
  {  
      std::vector<Vector3> pointList;
      Vector3 offset;

      Vector3 stationPos = station->getPos();

      unsigned int shipPosition= rand()%shipsPositionRange+shipsPositionRangeStart;

      for (unsigned int j = 0; j < 3; j++)
      {
          offset.x = (rand()%51)-25;
          offset.y = (rand()%51)-25;
          offset.z = shipPosition;
          pointList.push_back(offset+stationPos);
      }     

      PoliceShip* ship;
      ship = World::getWorld()->createNewPoliceShip( adder, 1, pointList,player, lightspeed*0.75 );
  }

  // create a merchant

  int shipPositionRangeStart = (int)((playerStartDistance) * 0.01);
  int shipPositionRangeEnd   = (int)((playerStartDistance) * 0.05);
  int shipPositionRange = shipsPositionRangeEnd-shipsPositionRangeStart;
  
  Vector3 offset;
  offset.x = (rand()%41)-20;
  offset.y = (rand()%41)-20;
  offset.z = rand()%shipsPositionRange+shipsPositionRangeStart;

  Merchant* ship;
  ship = World::getWorld()->createNewMerchant( thargoid, 1, coriolisPlanet, player->getPos()+offset);

  Vector3 stationPos = station->getPos();
  ship->setPos( stationPos + offset);
  Vector3 viewVector = player->getPos()+offset - stationPos + offset;
  viewVector.normalize();
  ship->setView( viewVector );
  ship->setSpeed( lightspeed/3 );
}


void World::deinitialize() {
  list<GameObject*>::iterator it = GameObjects.begin();
  while( it !=GameObjects.end() ) {
    PlayerObject * pl = dynamic_cast<PlayerObject*>(*it);
    Star * st = dynamic_cast<Star*>(*it);
    Planet * pln = dynamic_cast<Planet*>(*it);
    PoliceShip * pol = dynamic_cast<PoliceShip*>(*it);
    Pirate * pir = dynamic_cast<Pirate*>(*it);
    Thargon * tha = dynamic_cast<Thargon*>(*it);
    Merchant * mer = dynamic_cast<Merchant*>(*it);
    SpaceShip * sh = dynamic_cast<SpaceShip*>(*it);
    SpaceStation * sta = dynamic_cast<SpaceStation*>(*it);
    if( pl ) {
      delete pl;
      it++;
      continue;
    }
    if( st ) {
      delete st;
      it++;
      continue;
    }
    if( pln ) {
      delete pln;
      it++;
      continue;
    }
    if( pol ) {
      delete pol;
      it++;
      continue;
    }
    if( pir ) {
      delete pir;
      it++;
      continue;
    }
    if( tha ) {
      delete tha;
      it++;
      continue;
    }
    if( mer ) {
      delete mer;
      it++;
      continue;
    }
    if( sh ) {
      delete sh;
      it++;
      continue;
    }
    if( sta ) {
      delete sta;
      it++;
      continue;
    }
    MessageBox(0, "Unknown Type!", "World::deinitialize()", 0 );
    it++;
  }
  GameObjects.clear();
}


PlayerObject *World::getPlayer() {
  PlayerObject * pl = dynamic_cast<PlayerObject*>(*playerPosition);
  return pl;
}


Star *World::getStar() {
  Star * st = dynamic_cast<Star*>(*starPosition);
  return st;
}


vector<Planet*> * World::getPlanets() {
  vector<Planet*> * planets = new vector<Planet*>;

  if( starPosition == GameObjects.end() )
    return planets;

  list<GameObject*>::iterator it = starPosition;
  it++;

  Planet * pl;
  while( it != GameObjects.end() && (pl = dynamic_cast<Planet*>(*it++)) != 0 )
    planets->push_back( pl );

  return planets;
}


SpaceStation *World::getStation() {
  SpaceStation * st = dynamic_cast<SpaceStation*>(*stationPosition);
  return st;
}


vector<GraphicsObject*> *World::getGraphicObjects() {
  vector<GraphicsObject*> * retObjects = new vector<GraphicsObject*>;

  list<GameObject*>::iterator it = starPosition;

  GraphicsObject * obj;
  while( it!= GameObjects.end() && (obj = dynamic_cast<GraphicsObject*>(*it++)) != 0 )
    retObjects->push_back( obj );

  return retObjects;
}



vector<SpaceShip*> * World::getSpaceShips() {
  vector<SpaceShip*> * retObjects = new vector<SpaceShip*>;

  list<GameObject*>::iterator it = stationPosition;

  if (it==GameObjects.end()) return retObjects;

  it++;

  SpaceShip * obj;
  while( it!= GameObjects.end() && (obj = dynamic_cast<SpaceShip*>(*it++)) != 0 )
    retObjects->push_back( obj );

  return retObjects;
}


vector<ForeignSpaceShip*> * World::getForeignSpaceShips() {
  vector<ForeignSpaceShip*> * retObjects = new vector<ForeignSpaceShip*>;

  list<GameObject*>::iterator it = stationPosition;

  if (it==GameObjects.end()) return retObjects;

  it++;

  ForeignSpaceShip * obj;
  while( it!= GameObjects.end() && (obj = dynamic_cast<ForeignSpaceShip*>(*it++)) != 0 )
    retObjects->push_back( obj );

  return retObjects;
}

vector <PoliceShip*> * World::getPoliceShips() {
  vector<PoliceShip*> * retObjects = new vector<PoliceShip*>;

  list<GameObject*>::iterator it = stationPosition;

  if (it==GameObjects.end()) return retObjects;

  it++;

  PoliceShip * obj;
  while( it!= GameObjects.end() )
  {
    obj = dynamic_cast<PoliceShip*>(*it++);
    if ( obj != 0)
        retObjects->push_back( obj );
  }

  return retObjects;
}


SpaceShip * World::createNewSpaceShip( ObjectName objectType, float radius ) {
  SpaceShip *ship = new SpaceShip( radius, Objects::getObjects()->getDisplayList( objectType ) );
  ship->setView( FileAccess::getObjectView( objectType ) );
  GameObjects.push_back( ship );

  return ship;
}


Thargon * World::createNewThargon( ObjectName objectType, float radius, PlayerObject *player, float maxSpeed ) {
  Thargon *ship = new Thargon( radius, Objects::getObjects()->getDisplayList( objectType ), player, maxSpeed );
  ship->setView( FileAccess::getObjectView( objectType ) );

  GameObjects.push_back( ship );

  return ship;
}


Pirate* World::createNewPirate( ObjectName objectType, float radius, PlayerObject *player, float maxSpeed ) {
  Pirate *ship = new Pirate( radius, Objects::getObjects()->getDisplayList( objectType ), player, maxSpeed );
  ship->setView( FileAccess::getObjectView( objectType ) );

  GameObjects.push_back( ship );

  return ship;
}


Merchant * World::createNewMerchant( ObjectName objectType, float radius, Planet * planet, Vector3 aim ) {
  Merchant *ship = new Merchant( radius, Objects::getObjects()->getDisplayList( objectType ), planet, aim );
  ship->setView( FileAccess::getObjectView( objectType ) );

  GameObjects.push_back( ship );

  return ship;
}


PoliceShip * World::createNewPoliceShip( ObjectName objectType, float radius, std::vector<Vector3> point, PlayerObject * player, float maxSpeed ) {
  PoliceShip *ship = new PoliceShip( radius, Objects::getObjects()->getDisplayList( objectType ), point, player, maxSpeed );
  ship->setView( FileAccess::getObjectView( objectType ) );

 GameObjects.push_back( ship );

  return ship;
}


void World::deleteCrashedShips( void ) {
  list<GameObject*>::iterator iti = stationPosition;
  list<GameObject*>::iterator itj = stationPosition;

  if( itj == GameObjects.end() )
    return;
  //itj++;

  GraphicsObject* goi;
  GraphicsObject* goj;
  while( iti != GameObjects.end() ) {
    itj = iti;
    itj++;
    while( itj != GameObjects.end() ) {
      // check if iti and itj have a collision
      goi = dynamic_cast<GraphicsObject*>(*iti);
      goj = dynamic_cast<GraphicsObject*>(*itj);

      Vector3 distVector = goi->getPos() - goj->getPos();
      float dist = distVector.length();

      if( dist - goi->getCollisionRadius() - goj->getCollisionRadius() <= 0 ) {
        // collision occured
        list<GameObject*>::iterator pred = iti;
        pred--;
        // check for coriolis
        SpaceStation* st = getStation();
        if( *iti != st )
          GameObjects.erase( iti );
        else
          pred = iti;
        //if( *itj != st )  // this can't happen if the station is always in front of the other ships
        //  Objects::getObjects().erase( itj );
        //else
        //  pred = iti;
        // delete both objects if
          GameObjects.erase( itj );
        
        iti = pred;
        itj = pred;
        //if( itj != Objects::getObjects().end() )
          itj++;
      } else {
        itj++;
      }
    }
    iti++;
  }
}


void World::deleteDestroyedShips( void ) {
  list<GameObject*>::iterator it = stationPosition;

  if( it ==GameObjects.end() )
    return;
  it++;

  SpaceShip* go;
  while( it != GameObjects.end() ) {
    go = dynamic_cast<SpaceShip*>(*it);
    if( go->isDestroyed() ) {
      list<GameObject*>::iterator pred = it;
      pred--;
      GameObjects.erase( it );
      it = pred;
    }
    it++;
  }
}



World *World::m_world = 0;


World *World::getWorld ( void ) {
  if( m_world == 0 )
    m_world = new World;
  return m_world;
}


World::World() {

  wrapper = new Wrapper( &error1, &error2 );

  srand(351);
  for( unsigned int i=0; i < 256; i++ )
    systemPlanets[i] = getSystemPlanetsR();

  systemStars.reserve( 256 );
  for( unsigned int i=0; i < 256; i++ )
    systemStars.push_back( this->getStarTextureR() );

  m_playerStatus = new PlayerStatus();
  m_playerStatus->fuel = wrapper->getFuelAmount();

  for (int i = 0; i < 256; i++ )
  {
      vector<PlanetInfoGraphical> planets = *getSystemPlanets(i);     
      unsigned possiblePlanets = min((float)planets.size(),5.0f);
      unsigned coriolisPlanetNr = (rand()%possiblePlanets);
      nrForCoriolis[i] = coriolisPlanetNr;
  }

}


World::~World( void ) {
  // delete ship info
  // missing cuz ship-handling is not very well now

  delete m_playerStatus;

  systemStars.clear();

  for( unsigned int i=0; i < 256; i++ ) {
    systemPlanets[i]->clear();
    delete systemPlanets[i];
  }

  delete wrapper;
}



TextureName World::getPlanetTexture( unsigned __int8 number ) {
  switch( number ) {
case 0:
  return planet_ss_earth;
  break;
case 1:
  return planet_ss_jupiter;
  break;
case 2:
  return planet_ss_mars;
  break;
case 3:
  return planet_ss_mercury;
  break;
case 4:
  return planet_ss_moon;
  break;
case 5:
  return planet_ss_neptune;
  break;
case 6:
  return planet_ss_pluto;
  break;
case 7:
  return planet_ss_saturn;
  break;
case 8:
  return planet_ss_uranus;
  break;
case 9:
  return planet_ss_venus;
  break;
case 10:
  return planet_red;
  break;
case 11:
  return planet_01;
  break;
case 12:
  return planet_02;
  break;
case 13:
  return planet_03;
  break;
case 14:
  return planet_04;
  break;
case 15:
  return planet_05;
  break;
case 16:
  return planet_06;
  break;
case 17:
  return planet_07;
  break;
case 18:
  return planet_08;
  break;
case 19:
  return planet_09;
  break;
  }
  return planet_ss_earth; // should not happen
}


TextureName World::getPlanetTextureR( bool reset ) {
  static vector<TextureName> usedTextures;
  if( reset )
    usedTextures.clear();

  unsigned __int8 num;
  bool newTexture;
  do {
    newTexture = false;
    num = rand()%20;
    for( unsigned int i=0; i < usedTextures.size(); i++ )
      if( usedTextures[i] == getPlanetTexture( num ) )
        newTexture = true;
  } while ( newTexture );

  usedTextures.push_back( getPlanetTexture( num ) );
  return getPlanetTexture( num );
}


TextureName World::getStarTexture( unsigned __int8 number ) {
  switch( number ) {
case 0:
  return star_sun;
  break;
case 1:
  return star_001;
  break;
case 2:
  return star_002;
  break;
case 3:
  return star_003;
  break;
case 4:
  return star_004;
  break;
case 5:
  return star_005;
  break;
case 6:
  return star_006;
  break;
case 7:
  return star_010;
  break;
case 8:
  return star_011;
  break;
case 9:
  return star_012;
  break;
case 10:
  return star_013;
  break;
case 11:
  return star_014;
  break;
  }
  return star_sun; // should not happen
}


TextureName World::getStarTextureR( ) {
  unsigned __int8 num = rand()%11;
  return getStarTexture( num );
}


SystemInfo World::getSystemInfo() {
  return getSystemInfo( wrapper->getCurrentSystem() );
}


SystemInfo World::getSystemInfo( unsigned __int8 number ) {
  // TODO: size is not correct, number of planets shall be calculated and
  //graphical information can be submitted directly?
  SystemInfo sysinfo;

  System system = wrapper->getSystemInfo( number );

  sysinfo.name = system.name;
  sysinfo.pos.x = system.posx;
  sysinfo.pos.y = system.posy;
  sysinfo.size = 591352  * (4155.0 / 149600);
  sysinfo.government = system.government;
  sysinfo.description = system.description;
  sysinfo.population = system.population;
  sysinfo.productivity = system.productivity;
  sysinfo.radius = system.radius;
  sysinfo.techLevel = system.techLevel;
  sysinfo.economy = system.economy;
  sysinfo.systemNumber = system.systemnumber;
  return sysinfo;
}


string World::getSystemName( int number ) {
  return wrapper->getSystemInfo( number ).name;
}


vector<PlanetInfoGraphical>  * World::getSystemPlanets() {
  return systemPlanets[wrapper->getCurrentSystem()];
}


vector<PlanetInfoGraphical>  * World::getSystemPlanets( unsigned __int8 number ) {
  return systemPlanets[number];
}


vector<PlanetInfoGraphical>  * World::getSystemPlanetsR() {
  vector<PlanetInfoGraphical> *solarSystem = new vector<PlanetInfoGraphical>;

  int planetCount = (rand()%5 + 1) + (rand()%5 + 1); // minimal 2 and maximal 10 planets

  int maxDistance;
  int minPlanetPosition = 0;

  // create some factors. the planet which is furthest away from the sun should? have the distance 800000
  float c1 = (float)800000 / pow((float)2, (float) planetCount-1);
  float c2 = (pow((float)2, (float)(planetCount*0.75))  * c1) / pow((float)(planetCount*0.75), (float)2);
  float rotateSpeed = -1;
  bool reset = true; // used to reset the no-double-textures-filter in getPlanetTexturesR function

  for(int i = 0; i < planetCount; i++) {
    PlanetInfoGraphical planet;

    // dist1 and dist2 are two functions that should set the maximal possible distance for planet i.
    // dist1 increases polynomial and dist2 super polynomial. the constants c1 and c2 calculated above
    // should assure that the values of the functions are the same when i is equal to the half of the
    // planets. that means that the distances for the first half of the planet increase approximately
    // polynomial and the distances for the second half of planets increases approximately exponential.
    // because this values will set the maximal distance they are only hints as the distance is calculated
    // randomly and the minimal distance must only increase by 20000!
    int dist1 = c2*(i+1)*(i+1) + 20000;
    int dist2 = pow((float)2, (float)i)  * c1;
    maxDistance = max( dist1, dist2 );

    // only create random number if maximal position is greater than minimal position
    int planetDistance = maxDistance;
    if( minPlanetPosition != 0 && minPlanetPosition < maxDistance )
      planetDistance = getRandNumber( minPlanetPosition, maxDistance );
    planet.distance = planetDistance;

    // calculate rotate speed. the speed of the first planet should be fixed to 1.
    if(rotateSpeed < 0)
      rotateSpeed = 1  * planetDistance;
    planet.rotateSpeed =(rotateSpeed / planetDistance);

    // set up the other information
    planet.radius = 10;
    planet.rotateAngle = rand()%360;
    planet.spinningSpeed = -0.012;
    planet.texture = getPlanetTextureR( reset );
    reset = false;
    solarSystem->push_back( planet );

    // set the minimal position for the next planet. it is increased by 20000 in every step. if the planets
    // shouldn't be very near together, the length of stride should be increased. if the stride is big enough
    // the distance will increase continously.
    minPlanetPosition = planetDistance + 20000;
  }
  return solarSystem;
}

vector<SystemInfo> *World::getSystems( SystemLists systemList ) {
  // TODO: return all systems and reachable
  vector<SystemInfo> *systems;
  switch( systemList ) {
case allSystems:
  break;
case nearSystems:
  {
    // this creates a list in an square around the reachable systems!
    // find out maximal/minimal x and y positions
    vector<int> *localSystems = wrapper->getLocalSystems();
    Position maxPos, minPos; // positions are unsigned integers in textelite --> 0 is minimal
    maxPos.x = wrapper->getSystemInfo(localSystems->at(0)).posx;
    maxPos.y = wrapper->getSystemInfo(localSystems->at(0)).posy;
    minPos = maxPos;
    for(unsigned int i = 0; i < localSystems->size(); i++) {
      System reachableSystem = wrapper->getSystemInfo(localSystems->at(i));
      if( reachableSystem.posx < minPos.x )
        minPos.x = reachableSystem.posx;
      if( reachableSystem.posy < minPos.y )
        minPos.y = reachableSystem.posy;
      if( reachableSystem.posx > maxPos.x )
        maxPos.x = reachableSystem.posx;
      if( reachableSystem.posy > maxPos.y )
        maxPos.y = reachableSystem.posy;
    }
    localSystems->clear();
    delete localSystems;
    systems = getSystems( minPos.x, maxPos.x, minPos.y, maxPos.y );
  }
  break;
case maximalReachable:
  {
    systems = new vector<SystemInfo>;
    vector<int> *localSystems = wrapper->getLocalSystems();
    for(unsigned int i = 0; i < localSystems->size(); i++) {
      SystemInfo sysinfo;
      System wsystem = wrapper->getSystemInfo(localSystems->at(i));
      sysinfo.name = wsystem.name;
      sysinfo.pos.x = wsystem.posx;
      sysinfo.pos.y = wsystem.posy;
      sysinfo.size = i; // wtf is this?
      sysinfo.government = wsystem.government;
      sysinfo.description = wsystem.description;
      sysinfo.population = wsystem.population;
      sysinfo.productivity = wsystem.productivity;
      sysinfo.radius = wsystem.radius;
      sysinfo.techLevel = wsystem.techLevel;
      sysinfo.economy = wsystem.economy;
      sysinfo.systemNumber = wsystem.systemnumber;
      systems->push_back( sysinfo );
    }
    localSystems->clear();
    delete localSystems;
  }
  break;
case reachable:
  break;
  }

  return systems;
}

std::vector<SystemInfo> *World::getSystems( int left, int right, int bottom, int top ) {
  vector<SystemInfo> *systems = new vector<SystemInfo>;

  vector<int> *localSystems = wrapper->getSystemsInRectangle( left, right, bottom, top );

  for(unsigned int i = 0; i < localSystems->size(); i++) {
    SystemInfo sysinfo;
    System wsystem = wrapper->getSystemInfo(localSystems->at(i));
    sysinfo.name = wsystem.name;
    sysinfo.pos.x = wsystem.posx;
    sysinfo.pos.y = wsystem.posy;
    sysinfo.size = i; // wtf is this?
    sysinfo.government = wsystem.government;
    sysinfo.description = wsystem.description;
    sysinfo.population = wsystem.population;
    sysinfo.productivity = wsystem.productivity;
    sysinfo.radius = wsystem.radius;
    sysinfo.techLevel = wsystem.techLevel;
    sysinfo.economy = wsystem.economy;
    sysinfo.systemNumber = wsystem.systemnumber;
    systems->push_back( sysinfo );
  }
  localSystems->clear();
  delete localSystems;

  return systems;
}


TextureName World::getSystemStarTexture() {
  return this->systemStars.at( wrapper->getCurrentSystem() );
}


TextureName World::getSystemStarTexture( unsigned __int8 number ) {
  return systemStars.at( number );
}


bool World::isSystemReachable( int systemNumber ) {
  return wrapper->systemIsReachable( systemNumber );
}


bool World::isSystemLocal( int systemNumber ) {
  return wrapper->systemIsInLocalRange( systemNumber );
}


void World::performJump( int number ) {
  wrapper->performJump( number );
  m_playerStatus->fuel = wrapper->getFuelAmount();
  // new initialization for new level, textures are not loaded here, however
  deinitialize();
  initialize();
}




void World::buyFuel(float amount) {
  wrapper->buyFuel(amount);
  m_playerStatus->fuel = wrapper->getFuelAmount();
}

vector<Tradegood> * World::getAllTradegoodDescriptions() {
  return wrapper->getAllTradegoodDescriptions();
}

unsigned int World::getCargoBaySize() {
  return wrapper->getCargoBaySize();
}

float World::getCurrentCash() {
  return wrapper->getCurrentCash();
}

vector<int> * World::getCurrentCargo() {
  return wrapper->getCurrentCargo();
}

vector<MarketplaceItem> * World::getCurrentMarketplace() {
  return wrapper->getCurrentMarketplace();
}

unsigned int World::getFreeHoldspace() {
  return wrapper->getFreeHoldspace();
}

int World::getNumberOfTradegoods() {
  return wrapper->getNumberOfTradegoods();
}


Tradegood World::getTradegoodDescription(int number) {
  return wrapper->getTradegoodDescription(number);
}


string World::performPurchase(int number, int amount) {
  return wrapper->performPurchase(number,amount);
}


string World::performSale(int number, int amount) {
  return wrapper->performSale(number,amount);
}


float World::getFuelCost()
{
  return wrapper->getFuelCost();
}


float World::getFuelAmount()
{
  return wrapper->getFuelAmount();
}


float World::getMaxFuel()
{
  return wrapper->getMaxFuel();
}


bool World::tradegoodIsInTons(int number)
{
  return wrapper->tradegoodIsInTons(number);
}


PlayerStatus * World::getPlayerStatus( void ) {
  return m_playerStatus;
}

string World::getEconomyString( econTypes economy ) {
  switch( economy ) {
case AverageAgri:
  return "Average agricultural";
case AverageInd:
  return "Average industrial";
case MainlyAgri:
  return "Mainly agricultural";
case MainlyInd:
  return "Mainly industrial";
case PoorAgri:
  return "Poor agricultural";
case PoorInd:
  return "Poor industrial";
case RichAgri:
  return "Rich agricultural";
case RichInd:
  return "Rich industrial";
  }
  return "";// does not happen under normal circumstances
}

string World::getGovernmentString( govTypes government ) {
  switch(government) {
case Anarchy:
  return "Anarchy";
case Communist:
  return "Communism";
case Confederacy:
  return "Confederacy";
case CorporateState:
  return "Corporate State";
case Democracy:
  return "Democracy";
case Dictatorship:
  return "Dictatorship";
case Feudal:
  return "Feudalism";
case MultiGov:
  return "Multiple Governments";
  }
  return ""; // does not happen under normal circumstances
}


unsigned int World::getRandNumber( unsigned int min, unsigned int max ) {
  if( min > max )
    return 0;

  unsigned int returnVal;

  do {
    unsigned int upperBound = max - min;
    unsigned int factor = upperBound / 32767;
    if( factor == 0)
      factor = 1;
    unsigned int randomFactor = rand()%factor; // creates random number from 0 to factor
    unsigned int randomOffset = rand(); // create offset
    returnVal = (randomFactor  * 32767 + randomOffset) + min; // create value to upperBound and add min to get a value in range
  } while( returnVal > max );

  return returnVal;
}


void error1( string error ) {

}

void error2( string error ) {

}