Index: branches/network/src/Makefile.am
===================================================================
--- branches/network/src/Makefile.am	(revision 6389)
+++ branches/network/src/Makefile.am	(revision 6402)
@@ -48,5 +48,7 @@
                   story_entities/story_entity.cc \
                   story_entities/campaign.cc \
+                  story_entities/campaign_data.cc \
                   story_entities/game_world.cc \
+                  story_entities/game_world_data.cc \
                   story_entities/single_player_world.cc \
                   story_entities/multi_player_world.cc \
@@ -97,5 +99,7 @@
                  story_entities/story_def.h \
                  story_entities/campaign.h \
+                 story_entities/campaign_data.h \
                  story_entities/game_world.h \
+                 story_entities/game_world_data.h \
                  story_entities/single_player_world.h \
                  story_entities/multi_player_world.h \
Index: branches/network/src/defs/class_id.h
===================================================================
--- branches/network/src/defs/class_id.h	(revision 6389)
+++ branches/network/src/defs/class_id.h	(revision 6402)
@@ -149,6 +149,9 @@
   CL_CAMPAIGN_DATA              =    0x00000102,
   CL_GAME_WORLD                 =    0x00000103,
-  CL_SINGLE_PLAYER_WORLD        =    0x00000104,
-  CL_MULTI_PLAYER_WORLD         =    0x00000105,
+  CL_GAME_WORLD_DATA            =    0x00000104,
+  CL_SINGLE_PLAYER_WORLD        =    0x00000105,
+  CL_SINGLE_PLAYER_WORLD_DATA   =    0x00000106,
+  CL_MULTI_PLAYER_WORLD         =    0x00000107,
+  CL_MULTI_PLAYER_WORLD_DATA    =    0x00000108,
 
   // WorldEntities (range from 0x00000200 to 0x000004ff)
Index: branches/network/src/lib/coord/p_node.cc
===================================================================
--- branches/network/src/lib/coord/p_node.cc	(revision 6389)
+++ branches/network/src/lib/coord/p_node.cc	(revision 6402)
@@ -152,4 +152,18 @@
   }
 }
+
+
+/**
+ *  init the pnode to a well definied state
+ *
+ * this function actualy only updates the PNode tree
+ */
+void PNode::init()
+{
+  /* just update all aboslute positions via timestep 0.001ms */
+  this->updateNode(0.001f);
+  this->updateNode(0.001f);
+}
+
 
 /**
Index: branches/network/src/lib/coord/p_node.h
===================================================================
--- branches/network/src/lib/coord/p_node.h	(revision 6389)
+++ branches/network/src/lib/coord/p_node.h	(revision 6402)
@@ -78,4 +78,6 @@
 
   void loadParams(const TiXmlElement* root);
+
+  void init();
 
   // ACTIVATION //
Index: branches/network/src/story_entities/campaign.cc
===================================================================
--- branches/network/src/story_entities/campaign.cc	(revision 6389)
+++ branches/network/src/story_entities/campaign.cc	(revision 6402)
@@ -21,4 +21,5 @@
 #include "load_param.h"
 
+#include "campaign_data.h"
 
 using namespace std;
@@ -63,5 +64,4 @@
 
   PRINTF(4)("Loaded Campaign specific stuff\n");
-
 }
 
@@ -147,123 +147,2 @@
 
 
-
-/* ==========================================================================================================
-   CampaignData
-   ==========================================================================================================
-*/
-
-/**
- * constructor for CampaignData
- */
-CampaignData::CampaignData(const TiXmlElement* root)
-{
-  this->setClassID(CL_CAMPAIGN_DATA, "CampaignData");
-  this->currentEntity = NULL;
-
-  this->loadParams(root);
-}
-
-
-/**
- * destructor for CampaignData
- */
-CampaignData::~CampaignData()
-{
-  PRINTF(0)("Deleting CampaignData\n");
-  while( !this->storyEntities.empty())
-  {
-    StoryEntity* bo = this->storyEntities.back();
-    this->storyEntities.pop_back();
-    PRINTF(0)("CampaignData is been deleted: nr %i\n", bo->getStoryID());
-    delete bo;
-  }
-}
-
-
-
-/**
- *  loads the Parameters of a Campaign
- * @param root: The XML-element to load from
- */
-void CampaignData::loadParams(const TiXmlElement* root)
-{
-  LoadParamXML(root, "WorldList", this, CampaignData, loadParamsWorldList)
-      .describe("A List of Worlds to be loaded in this Campaign");
-
-}
-
-
-/**
- *  loads a WorldList
- * @param root: the XML-element to load from
- */
-void CampaignData::loadParamsWorldList(const TiXmlElement* root)
-{
-  if( root == NULL)
-    return;
-
-  LOAD_PARAM_START_CYCLE(root, element);
-  {
-    StoryEntity* created = (StoryEntity*) Factory::fabricate(element);
-    if( created != NULL)
-      this->addStoryEntity(created);
-  }
-  LOAD_PARAM_END_CYCLE(element);
-}
-
-
-/**
- *  add the StoryEntity to the campaign data tank
- * @param se the StoryEntity to add
- */
-void CampaignData::addStoryEntity(StoryEntity* se)
-{
-  this->storyEntities.push_back(se);
-}
-
-
-/**
- *  switch to the next level in the list and return it
- */
-StoryEntity* CampaignData::getFirstLevel()
-{
-  int                            nextStoryID;
-  int                            storyID;
-  list<StoryEntity*>::iterator   it;
-
-  nextStoryID = 0;
-  this->currentEntity = NULL;
-  for( it = this->storyEntities.begin(); it != this->storyEntities.end(); it++)
-  {
-    storyID = (*it)->getStoryID();
-    if( storyID == nextStoryID)
-      this->currentEntity = (*it);
-  }
-  return this->currentEntity;
-}
-
-
-/**
- *  switch to the next level in the list and return it
- */
-StoryEntity* CampaignData::getNextLevel()
-{
-  int                            nextStoryID;
-  int                            storyID;
-  list<StoryEntity*>::iterator   it;
-
-  nextStoryID = this->currentEntity->getNextStoryID();
-  this->currentEntity = NULL;
-  for( it = this->storyEntities.begin(); it != this->storyEntities.end(); it++)
-  {
-    storyID = (*it)->getStoryID();
-    if( storyID == nextStoryID)
-      this->currentEntity = (*it);
-  }
-  return this->currentEntity;
-}
-
-
-
-
-
Index: branches/network/src/story_entities/campaign.h
===================================================================
--- branches/network/src/story_entities/campaign.h	(revision 6389)
+++ branches/network/src/story_entities/campaign.h	(revision 6402)
@@ -9,5 +9,4 @@
 
 #include "story_entity.h"
-#include <list>
 
 
@@ -40,30 +39,3 @@
 };
 
-
-
-//! A class that contains the data of the Campaign object
-class CampaignData : public BaseObject
-{
-
-  public:
-    CampaignData(const TiXmlElement* root);
-    virtual ~CampaignData();
-
-    void loadParams(const TiXmlElement* root);
-
-    void addStoryEntity(StoryEntity* se);
-
-    StoryEntity* getFirstLevel();
-    StoryEntity* getNextLevel();
-
-
-  private:
-    void loadParamsWorldList(const TiXmlElement* root);
-
-
-  private:
-    StoryEntity*                  currentEntity;                //!< reference to the currently used StoryEntity
-    std::list<StoryEntity*>       storyEntities;                //!< list of story entities
-};
-
 #endif /* _CAMPAIGN_H */
Index: branches/network/src/story_entities/campaign_data.cc
===================================================================
--- branches/network/src/story_entities/campaign_data.cc	(revision 6402)
+++ branches/network/src/story_entities/campaign_data.cc	(revision 6402)
@@ -0,0 +1,141 @@
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Patrick Boenzli
+*/
+
+
+#include "campaign_data.h"
+
+#include "factory.h"
+#include "load_param.h"
+
+#include "story_entity.h"
+
+
+using namespace std;
+
+
+/**
+ * constructor for CampaignData
+ */
+CampaignData::CampaignData(const TiXmlElement* root)
+{
+  this->setClassID(CL_CAMPAIGN_DATA, "CampaignData");
+
+  this->currentEntity = NULL;
+  this->loadParams(root);
+}
+
+
+/**
+ * destructor for CampaignData
+ */
+CampaignData::~CampaignData()
+{
+  PRINTF(3)("Deleting CampaignData\n");
+  while( !this->storyEntities.empty())
+  {
+    StoryEntity* bo = this->storyEntities.back();
+    this->storyEntities.pop_back();
+    PRINTF(3)("CampaignData is been deleted: nr %i\n", bo->getStoryID());
+    delete bo;
+  }
+}
+
+
+
+/**
+ *  loads the Parameters of a Campaign
+ * @param root: The XML-element to load from
+ */
+void CampaignData::loadParams(const TiXmlElement* root)
+{
+  LoadParamXML(root, "WorldList", this, CampaignData, loadParamsWorldList)
+      .describe("A List of Worlds to be loaded in this Campaign");
+
+}
+
+
+/**
+ *  loads a WorldList
+ * @param root: the XML-element to load from
+ */
+void CampaignData::loadParamsWorldList(const TiXmlElement* root)
+{
+  if( root == NULL)
+    return;
+
+  LOAD_PARAM_START_CYCLE(root, element);
+  {
+    StoryEntity* created = (StoryEntity*) Factory::fabricate(element);
+    if( created != NULL)
+      this->addStoryEntity(created);
+  }
+  LOAD_PARAM_END_CYCLE(element);
+}
+
+
+/**
+ *  add the StoryEntity to the campaign data tank
+ * @param se the StoryEntity to add
+ */
+void CampaignData::addStoryEntity(StoryEntity* se)
+{
+  this->storyEntities.push_back(se);
+}
+
+
+/**
+ *  switch to the next level in the list and return it
+ */
+StoryEntity* CampaignData::getFirstLevel()
+{
+  int                            nextStoryID;
+  int                            storyID;
+  list<StoryEntity*>::iterator   it;
+
+  nextStoryID = 0;
+  this->currentEntity = NULL;
+  for( it = this->storyEntities.begin(); it != this->storyEntities.end(); it++)
+  {
+    storyID = (*it)->getStoryID();
+    if( storyID == nextStoryID)
+      this->currentEntity = (*it);
+  }
+  return this->currentEntity;
+}
+
+
+/**
+ *  switch to the next level in the list and return it
+ */
+StoryEntity* CampaignData::getNextLevel()
+{
+  int                            nextStoryID;
+  int                            storyID;
+  list<StoryEntity*>::iterator   it;
+
+  nextStoryID = this->currentEntity->getNextStoryID();
+  this->currentEntity = NULL;
+  for( it = this->storyEntities.begin(); it != this->storyEntities.end(); it++)
+  {
+    storyID = (*it)->getStoryID();
+    if( storyID == nextStoryID)
+      this->currentEntity = (*it);
+  }
+  return this->currentEntity;
+}
+
+
+
+
+
Index: branches/network/src/story_entities/campaign_data.h
===================================================================
--- branches/network/src/story_entities/campaign_data.h	(revision 6402)
+++ branches/network/src/story_entities/campaign_data.h	(revision 6402)
@@ -0,0 +1,42 @@
+/*!
+ * @file campaign_data.h
+ * definition of the campaign data tank
+ */
+
+#ifndef _CAMPAIGN_DATA_H
+#define _CAMPAIGN_DATA_H
+
+
+#include "base_object.h"
+#include <list>
+
+class StoryEntity;
+
+//! A class that contains the data of the Campaign object
+class CampaignData : public BaseObject
+{
+
+  public:
+    CampaignData(const TiXmlElement* root);
+    virtual ~CampaignData();
+
+    void loadParams(const TiXmlElement* root);
+
+    void addStoryEntity(StoryEntity* se);
+
+    StoryEntity* getFirstLevel();
+    StoryEntity* getNextLevel();
+
+
+  private:
+    void loadParamsWorldList(const TiXmlElement* root);
+
+
+  private:
+    StoryEntity*                  currentEntity;                //!< reference to the currently used StoryEntity
+    std::list<StoryEntity*>       storyEntities;                //!< list of story entities
+};
+
+
+#endif /* _CAMPAIGN_DATA_H */
+
Index: branches/network/src/story_entities/game_world.cc
===================================================================
--- branches/network/src/story_entities/game_world.cc	(revision 6389)
+++ branches/network/src/story_entities/game_world.cc	(revision 6402)
@@ -18,4 +18,5 @@
 
 #include "game_world.h"
+#include "game_world_data.h"
 
 #include "shell_command.h"
@@ -82,5 +83,5 @@
 
 GameWorld::GameWorld(const TiXmlElement* root)
-  : StoryEntity()
+    : StoryEntity()
 {
   this->setClassID(CL_GAME_WORLD, "GameWorld");
@@ -89,5 +90,4 @@
   this->gameTime = 0.0f;
   this->setSpeed(1.0f);
-  this->music = NULL;
   this->shell = NULL;
 
@@ -110,4 +110,6 @@
   if( this->gameWorldData)
     delete this->gameWorldData;
+
+  PRINTF(0)("Deleted GameWorld\n");
 }
 
@@ -123,5 +125,5 @@
 
   LoadParam(root, "path", this, GameWorld, setPath)
-    .describe("The Filename of this GameWorld (relative from the data-dir)");
+  .describe("The Filename of this GameWorld (relative from the data-dir)");
 
   PRINTF(4)("Loaded GameWorld specific stuff\n");
@@ -137,23 +139,9 @@
 ErrorMessage GameWorld::init()
 {
-  State::setObjectManager(&this->objectManager);
   this->cycle = 0;
-
   /* init the world interface */
   this->shell = new Shell();
 
-  LightManager::getInstance();
-  PNode::getNullParent();
-
-  AnimationPlayer::getInstance(); // initializes the animationPlayer
-  ParticleEngine::getInstance();
-  PhysicsEngine::getInstance();
-
-  this->gameWorldData->localCamera = new Camera();
-  this->gameWorldData->localCamera->setName ("GameWorld-Camera");
-
-  State::setCamera(this->gameWorldData->localCamera, this->gameWorldData->localCamera->getTarget());
-
-  GraphicsEngine::getInstance()->displayFPS(true);
+  this->gameWorldData->init();
 }
 
@@ -171,90 +159,31 @@
 
   if( getPath() == NULL)
-    {
-      PRINTF(1)("GameWorld has no path specified for loading");
-      return (ErrorMessage){213,"Path not specified","GameWorld::load()"};
-    }
+  {
+    PRINTF(1)("GameWorld has no path specified for loading");
+    return (ErrorMessage){213,"Path not specified","GameWorld::load()"};
+  }
 
   TiXmlDocument* XMLDoc = new TiXmlDocument( getPath());
-  // load the campaign document
+  // load the xml world file for further loading
   if( !XMLDoc->LoadFile())
   {
-    // report an error
     PRINTF(1)("loading XML File: %s @ %s:l%d:c%d\n", XMLDoc->ErrorDesc(), this->getPath(), XMLDoc->ErrorRow(), XMLDoc->ErrorCol());
     delete XMLDoc;
     return (ErrorMessage){213,"XML File parsing error","GameWorld::load()"};
   }
-
   // check basic validity
   TiXmlElement* root = XMLDoc->RootElement();
   assert( root != NULL);
-
   if( root == NULL || root->Value() == NULL || strcmp( root->Value(), "WorldDataFile"))
-    {
-      // report an error
-      PRINTF(1)("Specified XML File is not an orxonox world data file (WorldDataFile element missing)\n");
-      delete XMLDoc;
-      return (ErrorMessage){213,"Path not a WorldDataFile","GameWorld::load()"};
-    }
-
-  // load the parameters
-  // name
-  const char* string = grabParameter( root, "name");
-  if( string == NULL)
-    {
-      PRINTF(2)("GameWorld is missing a proper 'name'\n");
-      this->setName("Unknown");
-    }
-  else
-    {
-      this->setName(string);
-    }
-
-
-
-    this->gameWorldData->loadGUI(root);
-
-
-    this->gameWorldData->loadWorldEntities(root);
-
-    //////////////////////////////
-    // LOADING ADDITIONAL STUFF //
-    //////////////////////////////
-
-    LoadParamXML(root, "LightManager", LightManager::getInstance(), LightManager, loadParams);
-
-   LoadParamXML(root, "ParticleEngine", ParticleEngine::getInstance(), ParticleEngine, loadParams);
-//   LoadParamXML(root, "PhysicsEngine", PhysicsEngine::getInstance(), PhysicsEngine, loadParams);
-
-  // free the XML data
+  {
+    // report an error
+    PRINTF(1)("Specified XML File is not an orxonox world data file (WorldDataFile element missing)\n");
+    delete XMLDoc;
+    return (ErrorMessage){213,"Path not a WorldDataFile","GameWorld::load()"};
+  }
+  /* the whole loading process for the GameWorld */
+  this->gameWorldData->loadData(root);
 
   delete XMLDoc;
-  /* GENERIC LOADING PROCESS FINISHED */
-
-
-
-
-
-//   //localCamera->setParent(TrackNode::getInstance());
-//  tn->addChild(this->localCamera);
-  this->gameWorldData->localCamera->setClipRegion(1, 10000.0);
-//  localCamera->lookAt(playable);
-//  this->localPlayer->setParentMode(PNODE_ALL);
-  if (this->gameWorldData->sky != NULL)
-  {
-    this->gameWorldData->localCamera->addChild(this->gameWorldData->sky);
-  }
-  SoundEngine::getInstance()->setListener(this->gameWorldData->localCamera);
-
-  /* some static stuff*/
-
-  this->music = NULL;
-  //(OggPlayer*)ResourceManager::getInstance()->load("sound/00-luke_grey_-_hypermode.ogg", OGG, RP_LEVEL);
-  //music->playback();
-
-  /* update the object position before game start - so there are no wrong coordinates used in the first processing */
-  PNode::getNullParent()->updateNode (0.001f);
-  PNode::getNullParent()->updateNode (0.001f);
-
   this->releaseLoadScreen();
 }
@@ -269,30 +198,5 @@
   PRINTF(3)("GameWorld::~GameWorld() - unloading the current GameWorld\n");
 
-  // delete all the initialized Engines.
-  FastFactory::flushAll(true);
-  delete LightManager::getInstance();
-  delete ParticleEngine::getInstance();
-  delete AnimationPlayer::getInstance();
-  delete PhysicsEngine::getInstance();
-
-  // external engines initialized by the orxonox-class get deleted
-  SoundEngine::getInstance()->flushAllBuffers();
-  SoundEngine::getInstance()->flushAllSources();
-
-  if (State::getObjectManager() == &this->objectManager)
-    State::setObjectManager(NULL);
-  // erease everything that is left.
-  delete PNode::getNullParent();
-
-  //secondary cleanup of PNodes;
-  const std::list<BaseObject*>* nodeList = ClassList::getList(CL_PARENT_NODE);
-  if (nodeList != NULL)
-    while (!nodeList->empty())
-      delete nodeList->front();
-
-  Shader::suspendShader();
-
-  // unload the resources !!
-  ResourceManager::getInstance()->unloadAllByPriority(RP_LEVEL);
+  this->gameWorldData->unloadData();
 }
 
@@ -309,9 +213,8 @@
 }
 
+
 /**
  *  stops the world.
-
-   This happens, when the player decides to end the Level.
-*/
+ */
 bool GameWorld::stop()
 {
@@ -320,11 +223,13 @@
 }
 
-/**
- *  pauses the Game
-*/
+
+/**
+ *  pauses the game
+ */
 bool GameWorld::pause()
 {
   this->isPaused = true;
 }
+
 
 /**
@@ -338,26 +243,36 @@
 
 /**
- *  shows the loading screen
-*/
-void GameWorld::displayLoadScreen ()
-{
-  PRINTF(3)("GameWorld::displayLoadScreen - start\n");
-  this->gameWorldData->glmis = new GLMenuImageScreen();
-  this->gameWorldData->glmis->setMaximum(8);
-  PRINTF(3)("GameWorld::displayLoadScreen - end\n");
-}
-
-
-/**
- * @brief removes the loadscreen, and changes over to the game
- *
- * @todo take out the delay
-*/
-void GameWorld::releaseLoadScreen ()
-{
-  PRINTF(3)("GameWorld::releaseLoadScreen - start\n");
-  this->gameWorldData->glmis->setValue(this->gameWorldData->glmis->getMaximum());
-  PRINTF(3)("GameWorld::releaseLoadScreen - end\n");
-  delete this->gameWorldData->glmis;
+ *  main loop of the world: executing all world relevant function
+ *
+ * in this loop we synchronize (if networked), handle input events, give the heart-beat to
+ * all other member-entities of the world (tick to player, enemies etc.), checking for
+ * collisions drawing everything to the screen.
+ */
+void GameWorld::run()
+{
+  this->lastFrame = SDL_GetTicks ();
+  PRINTF(3)("GameWorld::mainLoop() - Entering main loop\n");
+
+  while( this->isRunning) /* @todo implement pause */
+  {
+    ++this->cycle;
+    /* process intput */
+    this->handleInput ();
+    if( !this->isRunning)
+      break;
+
+    /* network synchronisation */
+    this->synchronize ();
+    /* process time */
+    this->tick ();
+    /* process collision */
+    this->collide ();
+    /* update the state */
+    this->update ();
+    /* draw everything */
+    this->display ();
+  }
+
+  PRINTF(3)("GameWorld::mainLoop() - Exiting the main loop\n");
 }
 
@@ -367,9 +282,5 @@
 */
 void GameWorld::synchronize ()
-{
-  // Get remote input
-  // Update synchronizables
-/*  NetworkManager::getInstance()->synchronize();*/
-}
+{}
 
 
@@ -383,8 +294,12 @@
 {
   EventHandler::getInstance()->process();
-
-  // remoteinput
-}
-
+}
+
+
+/**
+ *  ticks a WorldEntity list
+ * @param entityList list of the WorldEntities
+ * @param dt time passed since last frame
+ */
 void GameWorld::tick(std::list<WorldEntity*> entityList, float dt)
 {
@@ -397,63 +312,43 @@
 /**
  *  advance the timeline
-
-   this calculates the time used to process one frame (with all input handling, drawing, etc)
-   the time is mesured in ms and passed to all world-entities and other classes that need
-   a heart-beat.
-*/
+ *
+ * this calculates the time used to process one frame (with all input handling, drawing, etc)
+ * the time is mesured in ms and passed to all world-entities and other classes that need
+ * a heart-beat.
+ */
 void GameWorld::tick ()
 {
   Uint32 currentFrame = SDL_GetTicks();
+
   if( !this->isPaused)
+  {
+    this->dt = currentFrame - this->lastFrame;
+
+    /* limit the the frame rate to 100 frames per second (fps) */
+    if( this->dt < 10)
     {
-      this->dt = currentFrame - this->lastFrame;
-
-      if( this->dt > 10)
-        {
-          float fps = 1000/dt;
-
-          // temporary, only for showing how fast the text-engine is
-          char tmpChar[20];
-          sprintf(tmpChar, "fps: %4.0f", fps);
-        }
-      else
-        {
-          /* the frame-rate is limited to 100 frames per second, all other things are for
-             nothing.
-          */
-          PRINTF(3)("fps = 1000 - frame rate is adjusted\n");
-          SDL_Delay(10-dt);
-          this->dt = 10;
-        }
-
-      this->dtS = (float)this->dt / 1000.0 * this->speed;
-      this->gameTime += this->dtS;
-
-      this->tick(this->objectManager.getObjectList(OM_DEAD_TICK), this->dtS);
-      this->tick(this->objectManager.getObjectList(OM_COMMON), this->dtS);
-      this->tick(this->objectManager.getObjectList(OM_GROUP_00), this->dtS);
-      this->tick(this->objectManager.getObjectList(OM_GROUP_01), this->dtS);
-      this->tick(this->objectManager.getObjectList(OM_GROUP_01_PROJ), this->dtS);
-
-      /* update tick the rest */
-      this->gameWorldData->localCamera->tick(this->dtS);
-      // tick the engines
-      AnimationPlayer::getInstance()->tick(this->dtS);
-//      if (this->cycle > 5)
-        PhysicsEngine::getInstance()->tick(this->dtS);
-
-      ParticleEngine::getInstance()->tick(this->dtS);
-
-
-      /** actualy the Graphics Engine should tick the world not the other way around...
-         but since we like the things not too complicated we got it this way around
-         until there is need or time to do it the other way around.
-         @todo: GraphicsEngine ticks world: separation of processes and data...
-
-        bensch: in my opinion the GraphicsEngine could draw the world, but not tick it,
-         beceause graphics have nothing(or at least not much) to do with Motion.
-      */
-      GraphicsEngine::getInstance()->tick(this->dtS);
+      /* the frame-rate is limited to 100 frames per second, all other things are for nothing. */
+      PRINTF(0)("fps = 1000 - frame rate is adjusted\n");
+      SDL_Delay(10 - dt);
+      this->dt = 10;
     }
+
+    this->dtS = (float)this->dt / 1000.0f * this->speed;
+    this->gameTime += this->dtS;
+
+    this->tick(this->gameWorldData->objectManager->getObjectList(OM_DEAD_TICK), this->dtS);
+    this->tick(this->gameWorldData->objectManager->getObjectList(OM_COMMON), this->dtS);
+    this->tick(this->gameWorldData->objectManager->getObjectList(OM_GROUP_00), this->dtS);
+    this->tick(this->gameWorldData->objectManager->getObjectList(OM_GROUP_01), this->dtS);
+    this->tick(this->gameWorldData->objectManager->getObjectList(OM_GROUP_01_PROJ), this->dtS);
+
+    /* update tick the rest */
+    this->gameWorldData->localCamera->tick(this->dtS);
+    AnimationPlayer::getInstance()->tick(this->dtS);
+    ParticleEngine::getInstance()->tick(this->dtS);
+    PhysicsEngine::getInstance()->tick(this->dtS);
+
+    GraphicsEngine::getInstance()->tick(this->dtS);
+  }
   this->lastFrame = currentFrame;
 }
@@ -462,8 +357,8 @@
 /**
  *  this function gives the world a consistant state
-
-   after ticking (updating the world state) this will give a constistant
-   state to the whole system.
-*/
+ *
+ * after ticking (updating the world state) this will give a constistant
+ * state to the whole system.
+ */
 void GameWorld::update()
 {
@@ -475,17 +370,20 @@
 
 
+/**
+ * kicks the CDEngine to detect the collisions between the object groups in the world
+ */
 void GameWorld::collide()
 {
-  CDEngine::getInstance()->checkCollisions(this->objectManager.getObjectList(OM_GROUP_00),
-                                            this->objectManager.getObjectList(OM_GROUP_01_PROJ));
-  CDEngine::getInstance()->checkCollisions(this->objectManager.getObjectList(OM_GROUP_01),
-                                            this->objectManager.getObjectList(OM_COMMON));
+  CDEngine::getInstance()->checkCollisions(this->gameWorldData->objectManager->getObjectList(OM_GROUP_00),
+      this->gameWorldData->objectManager->getObjectList(OM_GROUP_01_PROJ));
+  CDEngine::getInstance()->checkCollisions(this->gameWorldData->objectManager->getObjectList(OM_GROUP_01),
+      this->gameWorldData->objectManager->getObjectList(OM_COMMON));
 }
 
 /**
  *  render the current frame
-
-   clear all buffers and draw the world
-*/
+ *
+ * clear all buffers and draw the world
+ */
 void GameWorld::display ()
 {
@@ -496,10 +394,6 @@
   // draw world
   this->draw();
-  // draw HUD
-  /** @todo draw HUD */
   // flip buffers
   GraphicsEngine::swapBuffers();
-  //SDL_Surface* screen = Orxonox::getInstance()->getScreen ();
-  //SDL_Flip (screen);
 }
 
@@ -511,4 +405,21 @@
 {
   GraphicsEngine* engine = GraphicsEngine::getInstance();
+
+   /* to draw the bounding boxes of the objects at level 2 for debug purp */
+  if( unlikely( this->showBV))
+  {
+    CDEngine* engine = CDEngine::getInstance();
+    engine->drawBV(State::getObjectManager()->getObjectList(OM_ENVIRON_NOTICK));
+    engine->drawBV(State::getObjectManager()->getObjectList(OM_ENVIRON));
+    engine->drawBV(State::getObjectManager()->getObjectList(OM_COMMON));
+    engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_00));
+    engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_01));
+    engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_01_PROJ));
+  }
+  /* debug draw the PNodes */
+  if( unlikely(this->showPNodes))
+    PNode::getNullParent()->debugDraw(0);
+
+  /* draw all WorldEntiy groups */
   engine->draw(State::getObjectManager()->getObjectList(OM_ENVIRON_NOTICK));
   engine->draw(State::getObjectManager()->getObjectList(OM_ENVIRON));
@@ -517,77 +428,11 @@
   engine->draw(State::getObjectManager()->getObjectList(OM_GROUP_01));
   engine->draw(State::getObjectManager()->getObjectList(OM_GROUP_01_PROJ));
-
-   if( unlikely( this->showBV))  // to draw the bounding boxes of the objects at level 2 for debug purp
-   {
-     CDEngine* engine = CDEngine::getInstance();
-     engine->drawBV(State::getObjectManager()->getObjectList(OM_ENVIRON_NOTICK));
-     engine->drawBV(State::getObjectManager()->getObjectList(OM_ENVIRON));
-     engine->drawBV(State::getObjectManager()->getObjectList(OM_COMMON));
-     engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_00));
-     engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_01));
-     engine->drawBV(State::getObjectManager()->getObjectList(OM_GROUP_01_PROJ));
-   }
-
-//   {
-//     if( entity->isVisible() ) entity->draw();
-  //FIXME
-//     entity = iterator->nextElement();
-//   }
-
+  /* draws the particles */
   ParticleEngine::getInstance()->draw();
 
-  if (unlikely(this->showPNodes))
-    PNode::getNullParent()->debugDraw(0);
-
+  /* final draw command */
   engine->draw();
-  //TextEngine::getInstance()->draw();
-}
-
-
-/**
- * \brief main loop of the world: executing all world relevant function
- *
- * in this loop we synchronize (if networked), handle input events, give the heart-beat to
- * all other member-entities of the world (tick to player, enemies etc.), checking for
- * collisions drawing everything to the screen.
- */
-void GameWorld::run()
-{
-  this->lastFrame = SDL_GetTicks ();
-  PRINTF(3)("GameWorld::mainLoop() - Entering main loop\n");
-
-  while( this->isRunning) /* @todo implement pause */
-  {
-    ++this->cycle;
-      // Network
-    this->synchronize ();
-      // Process input
-    this->handleInput ();
-    if( !this->isRunning)
-      break;
-      // Process time
-    this->tick ();
-      // Process collision
-    this->collide ();
-      // Update the state
-    this->update ();
-      // Draw
-    this->display ();
-  }
-
-  PRINTF(3)("GameWorld::mainLoop() - Exiting the main loop\n");
-}
-
-
-
-/**
- *  add and spawn a new entity to this world
- * @param entity to be added
-*/
-// void GameWorld::spawn(WorldEntity* entity)
-// {
-// //   this->entities->add (entity);
-//   entity->postSpawn ();
-// }
+}
+
 
 /**
@@ -605,121 +450,31 @@
   }
   else
-    {
-      this->path = new char[strlen(ResourceManager::getInstance()->getDataDir()) + strlen(name) +1];
-      sprintf(this->path, "%s%s", ResourceManager::getInstance()->getDataDir(), name);
-    }
-}
-
-
-
-
-
-
-
-GameWorldData::GameWorldData()
-{
-  this->localPlayer = NULL;
-  this->localCamera = NULL;
-
-  this->glmis = NULL;
-
-  this->localCamera = NULL;
-  this->localPlayer = NULL;
-  this->sky = NULL;
-  this->terrain = NULL;
-
-}
-
-
-GameWorldData::~GameWorldData()
-{
-  if( this->localPlayer)
-    delete this->localPlayer;
-}
-
-
-
-ErrorMessage GameWorldData::loadData(TiXmlElement* root)
-{}
-
-
-
-
-ErrorMessage GameWorldData::loadGUI(TiXmlElement* root)
-{
-  ////////////////
-  // LOADSCREEN //
-  ////////////////
-  TiXmlElement* element = root->FirstChildElement("LoadScreen");
-  if( element == NULL)
-  {
-    PRINTF(2)("no LoadScreen specified, loading default\n");
-
-    glmis->setBackgroundImage("pictures/load_screen.jpg");
-    this->glmis->setMaximum(8);
-    this->glmis->draw();
-  }
-  else
-  {
-    this->glmis->loadParams(element);
-    this->glmis->draw();
-  }
-  this->glmis->draw();
-
-}
-
-
-ErrorMessage GameWorldData::loadWorldEntities(TiXmlElement* root)
-{
-  ////////////////////////
-  // find WorldEntities //
-  ////////////////////////
-
-  TiXmlElement* element = root->FirstChildElement("WorldEntities");
-
-  if( element == NULL)
-  {
-    PRINTF(1)("GameWorld is missing 'WorldEntities'\n");
-  }
-  else
-  {
-    element = element->FirstChildElement();
-      // load Players/Objects/Whatever
-    PRINTF(4)("Loading WorldEntities\n");
-    while( element != NULL)
-    {
-      BaseObject* created = Factory::fabricate(element);
-      if( created != NULL )
-        printf("Created a %s: %s\n", created->getClassName(), created->getName());
-
-
-          //todo do this more elegant
-      if( element->Value() != NULL && !strcmp( element->Value(), "SkyBox"))
-        this->sky = dynamic_cast<WorldEntity*>(created);
-      if( element->Value() != NULL && !strcmp( element->Value(), "Terrain"))
-      {
-        this->terrain = dynamic_cast<Terrain*>(created);
-        CDEngine::getInstance()->setTerrain(terrain);
-      }
-      element = element->NextSiblingElement();
-      this->glmis->step(); //! @todo temporary
-    }
-    PRINTF(4)("Done loading WorldEntities\n");
-  }
-
-    // Create a Player
-  this->localPlayer = new Player();
-
-  Playable* playable;
-  const list<BaseObject*>* playableList = ClassList::getList(CL_PLAYABLE);
-  if (playableList != NULL)
-  {
-    playable = dynamic_cast<Playable*>(playableList->front());
-    this->localPlayer->setControllable(playable);
-  }
-}
-
-
-ErrorMessage GameWorldData::loadScene(TiXmlElement* root)
-{}
-
+  {
+    this->path = new char[strlen(ResourceManager::getInstance()->getDataDir()) + strlen(name) +1];
+    sprintf(this->path, "%s%s", ResourceManager::getInstance()->getDataDir(), name);
+  }
+}
+
+
+/**
+ *  shows the loading screen
+ */
+void GameWorld::displayLoadScreen ()
+{
+  PRINTF(3)("GameWorld::displayLoadScreen - start\n");
+  this->gameWorldData->glmis = new GLMenuImageScreen();
+  this->gameWorldData->glmis->setMaximum(8);
+  PRINTF(3)("GameWorld::displayLoadScreen - end\n");
+}
+
+
+/**
+ *  removes the loadscreen, and changes over to the game
+ */
+void GameWorld::releaseLoadScreen ()
+{
+  PRINTF(3)("GameWorld::releaseLoadScreen - start\n");
+  this->gameWorldData->glmis->setValue(this->gameWorldData->glmis->getMaximum());
+  PRINTF(3)("GameWorld::releaseLoadScreen - end\n");
+}
+
Index: branches/network/src/story_entities/game_world.h
===================================================================
--- branches/network/src/story_entities/game_world.h	(revision 6389)
+++ branches/network/src/story_entities/game_world.h	(revision 6402)
@@ -7,18 +7,13 @@
 #define _GAME_WORLD_H
 
-#include "sdlincl.h"
+
 #include "story_entity.h"
-#include "object_manager.h"
 
+
+class TiXmlElement;
+class Shell;
 class WorldEntity;
-class Camera;
-class Player;
-class GLMenuImageScreen;
-class Terrain;
-class TiXmlElement;
+class GameWorldData;
 
-class Shell;
-class OggPlayer;
-class GameWorldData;
 
 //! The game world
@@ -86,43 +81,13 @@
 
     /* world timing */
-    Uint32              lastFrame;                   //!< last time of frame
-    Uint32              cycle;                       //!< The cycle we are in (starts with 0 and rises with every frame)
-    Uint32              dt;                          //!< time needed to calculate this frame (in milliSeconds)
-    float               dtS;                         //!< The time needed for caluculations in seconds
-    float               speed;                       //!< how fast the game flows
-    double              gameTime;                    //!< this is where the game time is saved
-
-    /* external modules interfaces */
-    ObjectManager objectManager;                     //!< The ObjectManager of this GameWorld.
+    Uint32              lastFrame;                    //!< last time of frame
+    Uint32              cycle;                        //!< The cycle we are in (starts with 0 and rises with every frame)
+    Uint32              dt;                           //!< time needed to calculate this frame (in milliSeconds)
+    float               dtS;                          //!< The time needed for caluculations in seconds
+    float               speed;                        //!< how fast the game flows
+    double              gameTime;                     //!< this is where the game time is saved
 
     /* external modules interfaces */
     Shell*              shell;
-    OggPlayer*          music;
-
-    /* important entities */
-};
-
-
-class GameWorldData : public BaseObject
-{
-
-  public:
-    GameWorldData();
-    ~GameWorldData();
-    /* world loading functions */
-    virtual ErrorMessage loadData(TiXmlElement* root);
-
-    virtual ErrorMessage loadGUI(TiXmlElement* root);
-    virtual ErrorMessage loadWorldEntities(TiXmlElement* root);
-    virtual ErrorMessage loadScene(TiXmlElement* root);
-
-  public:
-    GLMenuImageScreen*  glmis;                        //!< The Level-Loader Display
-
-    Camera*             localCamera;                 //!< The current Camera
-    Player*             localPlayer;                 //!< The Player, you fly through the level.
-    WorldEntity*        sky;                         //!< The Environmental Heaven of orxonox @todo insert this to environment insted
-    Terrain*            terrain;                     //!< The Terrain of the GameWorld.
-
 };
 
Index: branches/network/src/story_entities/game_world_data.cc
===================================================================
--- branches/network/src/story_entities/game_world_data.cc	(revision 6402)
+++ branches/network/src/story_entities/game_world_data.cc	(revision 6402)
@@ -0,0 +1,315 @@
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Patrick Boenzli
+*/
+
+
+#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD
+
+#include "game_world_data.h"
+
+#include "resource_manager.h"
+#include "state.h"
+#include "class_list.h"
+#include "substring.h"
+
+#include "game_loader.h"
+
+#include "p_node.h"
+#include "world_entity.h"
+#include "player.h"
+#include "camera.h"
+#include "environment.h"
+#include "terrain.h"
+#include "test_entity.h"
+#include "terrain.h"
+#include "md2Model.h"
+#include "weapons/projectile.h"
+#include "npcs/npc_test1.h"
+#include "playable.h"
+
+#include "light.h"
+
+#include "factory.h"
+#include "fast_factory.h"
+#include "load_param.h"
+
+#include "particle_engine.h"
+#include "graphics_engine.h"
+#include "event_handler.h"
+#include "sound_engine.h"
+#include "cd_engine.h"
+#include "network_manager.h"
+#include "physics_engine.h"
+#include "fields.h"
+
+#include "glmenu_imagescreen.h"
+
+#include "animation_player.h"
+#include "animation3d.h"
+
+#include "ogg_player.h"
+#include "shader.h"
+
+
+
+using namespace std;
+
+
+/**
+ * constructor of the GameWorldData
+ */
+GameWorldData::GameWorldData()
+{
+  this->setClassID(CL_GAME_WORLD_DATA, "GameWorldData");
+
+  this->localPlayer = NULL;
+  this->localCamera = NULL;
+
+  this->glmis = NULL;
+
+  this->localCamera = NULL;
+  this->localPlayer = NULL;
+  this->sky = NULL;
+  this->terrain = NULL;
+
+  this->music = NULL;
+  this->objectManager = NULL;
+}
+
+
+/**
+ * destructor for the GameWorldData
+ */
+GameWorldData::~GameWorldData()
+{
+}
+
+
+
+/**
+ *  initialize the GameWorldData
+ */
+ErrorMessage GameWorldData::init()
+{
+  this->objectManager = new ObjectManager();
+  State::setObjectManager(this->objectManager);
+
+  PNode::getNullParent();
+  this->localCamera = new Camera();
+  this->localCamera->setName ("GameWorld-Camera");
+  State::setCamera(this->localCamera, this->localCamera->getTarget());
+
+  LightManager::getInstance();
+
+  GraphicsEngine::getInstance()->displayFPS(true);
+
+  /* initialize some graphics engines and graphical elements */
+  AnimationPlayer::getInstance();
+  ParticleEngine::getInstance();
+  PhysicsEngine::getInstance();
+}
+
+
+/**
+ *  loads the data from the xml file
+ * @param root reference to the xml root element
+ */
+ErrorMessage GameWorldData::loadData(TiXmlElement* root)
+{
+  // load the parameters
+  // name
+  const char* string = grabParameter( root, "name");
+  if( string == NULL)
+  {
+    PRINTF(2)("GameWorld is missing a proper 'name'\n");
+    this->setName("Unknown");
+  }
+  else
+    this->setName(string);
+
+  this->loadGUI(root);
+  this->loadWorldEntities(root);
+  this->loadScene(root);
+}
+
+
+/**
+ *  unloads the data from the xml file
+ */
+ErrorMessage GameWorldData::unloadData()
+{
+  this->unloadGUI();
+  this->unloadWorldEntities();
+  this->unloadScene();
+}
+
+
+/**
+ *  loads the GUI data
+ * @param root reference to the xml root element
+ */
+ErrorMessage GameWorldData::loadGUI(TiXmlElement* root)
+{
+  TiXmlElement* element = root->FirstChildElement("LoadScreen");
+  if( element == NULL)
+  {
+    PRINTF(2)("no LoadScreen specified, loading default\n");
+
+    glmis->setBackgroundImage("pictures/load_screen.jpg");
+    this->glmis->setMaximum(8);
+//     this->glmis->draw();
+  }
+  else
+  {
+    this->glmis->loadParams(element);
+//     this->glmis->draw();
+  }
+  this->glmis->draw();
+}
+
+
+/**
+ *  loads the GUI data
+ */
+ErrorMessage GameWorldData::unloadGUI()
+{
+  delete this->glmis;
+}
+
+
+/**
+ *  loads the world entities from the xml file
+ * @param root reference to the xml root parameter
+ */
+ErrorMessage GameWorldData::loadWorldEntities(TiXmlElement* root)
+{
+  TiXmlElement* element = root->FirstChildElement("WorldEntities");
+
+  if( element == NULL)
+  {
+    PRINTF(1)("GameWorld is missing 'WorldEntities'\n");
+  }
+  else
+  {
+    element = element->FirstChildElement();
+    // load Players/Objects/Whatever
+    PRINTF(4)("Loading WorldEntities\n");
+    while( element != NULL)
+    {
+      BaseObject* created = Factory::fabricate(element);
+      if( created != NULL )
+        printf("Created a %s: %s\n", created->getClassName(), created->getName());
+
+      //todo do this more elegant
+      if( element->Value() != NULL && !strcmp( element->Value(), "SkyBox"))
+        this->sky = dynamic_cast<WorldEntity*>(created);
+      if( element->Value() != NULL && !strcmp( element->Value(), "Terrain"))
+      {
+        this->terrain = dynamic_cast<Terrain*>(created);
+        CDEngine::getInstance()->setTerrain(terrain);
+      }
+      element = element->NextSiblingElement();
+      this->glmis->step(); //! @todo temporary
+    }
+    PRINTF(4)("Done loading WorldEntities\n");
+  }
+
+  // Create a Player
+  this->localPlayer = new Player();
+
+  Playable* playable;
+  const list<BaseObject*>* playableList = ClassList::getList(CL_PLAYABLE);
+  if (playableList != NULL)
+  {
+    playable = dynamic_cast<Playable*>(playableList->front());
+    this->localPlayer->setControllable(playable);
+  }
+
+  /* init the pnode tree */
+  PNode::getNullParent()->init();
+}
+
+
+/**
+ *  unloads the world entities from the xml file
+ */
+ErrorMessage GameWorldData::unloadWorldEntities()
+{
+  FastFactory::flushAll(true);
+
+  // erease everything that is left.
+  delete PNode::getNullParent();
+
+  //secondary cleanup of PNodes;
+  const std::list<BaseObject*>* nodeList = ClassList::getList(CL_PARENT_NODE);
+  if (nodeList != NULL)
+    while (!nodeList->empty())
+      delete nodeList->front();
+
+  /* remove the player object */
+  if( this->localPlayer)
+    delete this->localPlayer;
+
+  // unload the resources !!
+  ResourceManager::getInstance()->unloadAllByPriority(RP_LEVEL);
+
+  if (State::getObjectManager() == this->objectManager)
+  {
+    State::setObjectManager(NULL);
+    delete this->objectManager;
+  }
+}
+
+
+/**
+ *  loads the scene data
+ * @param root reference to the xml root element
+ */
+ErrorMessage GameWorldData::loadScene(TiXmlElement* root)
+{
+  LoadParamXML(root, "LightManager", LightManager::getInstance(), LightManager, loadParams);
+
+  LoadParamXML(root, "ParticleEngine", ParticleEngine::getInstance(), ParticleEngine, loadParams);
+  //LoadParamXML(root, "PhysicsEngine", PhysicsEngine::getInstance(), PhysicsEngine, loadParams);
+
+  this->localCamera->setClipRegion(1, 10000.0);
+  if( this->sky != NULL)
+    this->localCamera->addChild(this->sky);
+
+  /* sound loading */
+  this->music = NULL;
+  //(OggPlayer*)ResourceManager::getInstance()->load("sound/00-luke_grey_-_hypermode.ogg", OGG, RP_LEVEL);
+  //music->playback();
+  SoundEngine::getInstance()->setListener(this->localCamera);
+}
+
+
+/**
+ *  unloads the scene data
+ */
+ErrorMessage GameWorldData::unloadScene()
+{
+  /* delete some garphics and scene eingines */
+  delete LightManager::getInstance();
+  delete ParticleEngine::getInstance();
+  delete AnimationPlayer::getInstance();
+  delete PhysicsEngine::getInstance();
+
+  /* stop the sound eninge */
+  SoundEngine::getInstance()->flushAllBuffers();
+  SoundEngine::getInstance()->flushAllSources();
+
+  /* unload the shaders */
+  Shader::suspendShader();
+}
+
Index: branches/network/src/story_entities/game_world_data.h
===================================================================
--- branches/network/src/story_entities/game_world_data.h	(revision 6402)
+++ branches/network/src/story_entities/game_world_data.h	(revision 6402)
@@ -0,0 +1,66 @@
+/*!
+ * @file game_world_data.h
+ *  container for all game world data
+ */
+
+#ifndef _GAME_WORLD_DATA_H
+#define _GAME_WORLD_DATA_H
+
+#include "sdlincl.h"
+#include "base_object.h"
+#include "error.h"
+
+
+class Camera;
+class Player;
+class Terrain;
+class WorldEntity;
+class ObjectManager;
+
+class GLMenuImageScreen;
+
+class TiXmlElement;
+class OggPlayer;
+
+
+//! The game world data
+/**
+ * this class is a containter for the data of the GameWorld. It just loads and unloads it
+ * the game start/stop process is not contained here and can be found in the GameWorld class.
+ */
+class GameWorldData : public BaseObject
+{
+
+  public:
+    GameWorldData();
+    virtual ~GameWorldData();
+
+    virtual ErrorMessage init();
+    virtual ErrorMessage loadData(TiXmlElement* root);
+    virtual ErrorMessage unloadData();
+
+
+  private:
+    virtual ErrorMessage loadGUI(TiXmlElement* root);
+    virtual ErrorMessage loadWorldEntities(TiXmlElement* root);
+    virtual ErrorMessage loadScene(TiXmlElement* root);
+
+    virtual ErrorMessage unloadGUI();
+    virtual ErrorMessage unloadWorldEntities();
+    virtual ErrorMessage unloadScene();
+
+
+  public:
+    GLMenuImageScreen*  glmis;                       //!< The Level-Loader Display
+
+    Camera*             localCamera;                 //!< The current camera
+    Player*             localPlayer;                 //!< The player, you fly through the level.
+    WorldEntity*        sky;                         //!< The environmental sky of orxonox
+    Terrain*            terrain;                     //!< The terrain - ground
+
+    OggPlayer*          music;                       //!< Reference to the SoundEngine's music player (OggPlayer)
+    ObjectManager*      objectManager;               //!< Reference to the objects manager
+};
+
+#endif /* _GAME_WORLD_DATA_H */
+
Index: branches/network/src/story_entities/multi_player_world.cc
===================================================================
--- branches/network/src/story_entities/multi_player_world.cc	(revision 6389)
+++ branches/network/src/story_entities/multi_player_world.cc	(revision 6402)
@@ -51,5 +51,6 @@
   : GameWorld(root)
 {
-  this->constuctorInit("", -1);
+  this->setClassID(CL_MULTI_PLAYER_WORLD, "MultiPlayerWorld");
+
   this->path = NULL;
 
@@ -83,10 +84,6 @@
 void MultiPlayerWorld::constuctorInit(const char* name, int worldID)
 {
-  this->setClassID(CL_MULTI_PLAYER_WORLD, "MultiPlayerWorld");
-  this->setName(name);
-
   this->gameTime = 0.0f;
   this->setSpeed(1.0);
-  this->music = NULL;
   this->shell = NULL;
 
Index: branches/network/src/story_entities/single_player_world.cc
===================================================================
--- branches/network/src/story_entities/single_player_world.cc	(revision 6389)
+++ branches/network/src/story_entities/single_player_world.cc	(revision 6402)
@@ -38,5 +38,5 @@
   : GameWorld(root)
 {
-  this->setClassID(CL_SINGLE_PLAYER_WORLD, "SinglePlayerSinglePlayerWorld");
+  this->setClassID(CL_SINGLE_PLAYER_WORLD, "SinglePlayerWorld");
   this->setName("SinglePlayerWorld uninitialized");
 
