Changeset 3238 in orxonox.OLD for orxonox/branches/sound/src/world.cc

Timestamp:

Dec 20, 2004, 2:42:54 AM (21 years ago)

Author:

bensch

Message:

orxonox/branches: updated branches: buerli, nico, sound. And moved bezierTrack to old.bezierTrack. Conflicts resolved in a usefull order.
Conflics mostly resolved in favor of trunk
merge.

File:

• orxonox/branches/sound/src/world.cc (modified) (27 diffs)

orxonox/branches/sound/src/world.cc

@@ -22 +22 @@
 #include "command_node.h"
 #include "camera.h"
+#include "environment.h"
 
 using namespace std;
@@ -35 +36 @@
   this->worldName = name;
   this->debugWorldNr = -1;
-  this->entities = new List<WorldEntity>();
+  this->entities = new tList<WorldEntity>();
 }
 
@@ -42 +43 @@
   this->debugWorldNr = worldID;
   this->worldName = NULL;
-  this->entities = new List<WorldEntity>();
+  this->entities = new tList<WorldEntity>();
 }
 
@@ -50 +51 @@
 World::~World ()
 {
-  Orxonox *orx = Orxonox::getInstance();
-  orx->get_localinput()->unbind (this->localPlayer);
+  printf("World::~World() - deleting current world\n");
+  CommandNode* cn = Orxonox::getInstance()->getLocalInput();
+  cn->unbind(this->localPlayer);
+  cn->reset();
+  this->localCamera->destroy();
+
+  WorldEntity* entity = entities->enumerate();  
+  while( entity != NULL ) 
+    { 
+      entity->destroy();
+      entity = entities->nextElement();
+    }
+  this->entities->destroy();
+
   delete this->entities;
   delete this->localCamera;
-}
-
-
-/** 
-    \brief initialize the world before use.
-*/
-Error World::init()
+  /* this->localPlayer hasn't to be deleted explicitly, it is 
+     contained in entities*/
+}
+
+
+ErrorMessage World::init()
 {
   this->bPause = false;
-}
-
-Error World::start()
-{
+  CommandNode* cn = Orxonox::getInstance()->getLocalInput();
+  cn->addToWorld(this);
+  cn->enable(true);
+}
+
+ErrorMessage World::start()
+{
+  printf("World::start() - starting current World: nr %i\n", this->debugWorldNr);
+  this->bQuitOrxonox = false;
+  this->bQuitCurrentGame = false;
   this->mainLoop();
 }
 
-Error World::stop()
-{
+ErrorMessage World::stop()
+{
+  printf("World::stop() - got stop signal\n");
   this->bQuitCurrentGame = true;
-  this->localCamera->setWorld(NULL);
-  this->~World();
-}
-
-Error World::pause()
+}
+
+ErrorMessage World::pause()
 {
   this->isPaused = true;
 }
 
-Error World::resume()
+ErrorMessage World::resume()
 {
   this->isPaused = false;
 }
 
+void World::destroy()
+{
+
+}
+
 void World::load()
 {
@@ -93 +115 @@
       switch(this->debugWorldNr)
         {
+          /*
+            this loads the hard-coded debug world. this only for simplicity and will be 
+            removed by a reald world-loader, which interprets a world-file.
+            if you want to add an own debug world, just add a case DEBUG_WORLD_[nr] and
+            make whatever you want...
+           */
         case DEBUG_WORLD_0:
           {
@@ -98 +126 @@
             this->pathnodes = new Vector[6];
             this->pathnodes[0] = Vector(0, 0, 0);
-            this->pathnodes[1] = Vector(-100, 40, 0);
-            this->pathnodes[2] = Vector(-100, 140, 0);
-            this->pathnodes[3] = Vector(0, 180, 0);
-            this->pathnodes[4] = Vector(100, 140, 0);
-            this->pathnodes[5] = Vector(100, 40, 0);
+            this->pathnodes[1] = Vector(1000, 0, 0);
+            //      this->pathnodes[2] = Vector(-100, 140, 0);
+            //      this->pathnodes[3] = Vector(0, 180, 0);
+            //      this->pathnodes[4] = Vector(100, 140, 0);
+            //      this->pathnodes[5] = Vector(100, 40, 0);
             
             // create the tracks
-            this->tracklen = 6;
-            this->track = new Track[6];
+            this->tracklen = 2;
+            this->track = new Track[2];
             for( int i = 0; i < this->tracklen; i++)
               {
                 this->track[i] = Track( i, (i+1)%this->tracklen, &this->pathnodes[i], &this->pathnodes[(i+1)%this->tracklen]);
               }
-            
+            // !\todo old track-system has to be removed
+
             // create a player
-            //WorldEntity* myPlayer = (WorldEntity*) this->spawn<Player>();
             WorldEntity* myPlayer = new Player();
             this->spawn(myPlayer);
@@ -120 +148 @@
             // bind input
             Orxonox *orx = Orxonox::getInstance();
-            orx->get_localinput()->bind (myPlayer);
+            orx->getLocalInput()->bind (myPlayer);
             
             // bind camera
             this->localCamera = new Camera(this);
             this->getCamera()->bind (myPlayer); 
+
+            Placement* plc = new Placement;
+            plc->r = Vector(100, 10, 10);
+            plc->w = Quaternion();
+            WorldEntity* env = new Environment();
+            this->spawn(env, plc);
+
             break;
           }
@@ -145 +180 @@
                 this->track[i] = Track( i, (i+1)%this->tracklen, &this->pathnodes[i], &this->pathnodes[(i+1)%this->tracklen]);
               }
-            
+
             // create a player
-            //WorldEntity* myPlayer = (WorldEntity*) this->spawn<Player>();
             WorldEntity* myPlayer = new Player();
             this->spawn(myPlayer);
-            this->localPlayer = myPlayer;
+            this->localPlayer = myPlayer;           
             
             // bind input
             Orxonox *orx = Orxonox::getInstance();
-            orx->get_localinput()->bind (myPlayer);
+            orx->getLocalInput()->bind (myPlayer);
             
             // bind camera
@@ -169 +203 @@
 
     }
+
+  // initialize debug coord system
+  objectList = glGenLists(1);
+  glNewList (objectList, GL_COMPILE);
+  glLoadIdentity();
+  glColor3f(1.0,0,0);
+  glBegin(GL_QUADS);
+
+  int sizeX = 100;
+  int sizeY = 80;
+  float length = 1000;
+  float width = 200;
+  float widthX = float (length /sizeX);
+  float widthY = float (width /sizeY);
+  
+  float height [sizeX][sizeY];
+  Vector normal_vectors[sizeX][sizeY];
+  
+  
+  for ( int i = 0; i<sizeX-1; i+=1)
+    for (int j = 0; j<sizeY-1;j+=1)
+      //height[i][j] = rand()/20046 + (j-25)*(j-25)/30;
+#ifdef __WIN32__
+      height[i][j]=(sin((float)j/3)*rand()*i/182400)*.5;
+#else
+      height[i][j]=(sin((float)j/3)*rand()*(long)i/6282450500.0)*.5;
+#endif
+
+  //Die Hügel ein wenig glätten
+  for (int h=1; h<2;h++)
+    for (int i=1;i<sizeX-2 ;i+=1 )
+      for(int j=1;j<sizeY-2;j+=1)
+        height[i][j]=(height[i+1][j]+height[i][j+1]+height[i-1][j]+height[i][j-1])/4;
+  
+  //Berechnung von normalen Vektoren
+
+  for(int i=1;i<sizeX-2;i+=1)
+    for(int j=1;j<sizeY-2 ;j+=1)
+      {
+        Vector v1 = Vector (widthX*(1),      widthY*(j)  ,      height[i][j]);
+        Vector v2 = Vector (widthX*(i-1),    widthY*(j)  ,      height[i-1][j]);
+        Vector v3 = Vector (widthX*(i),      widthY*(j+1),      height[i][j+1]);
+        Vector v4 = Vector (widthX*(i+1),    widthY*(j),        height[i+1][j]);
+        Vector v5 = Vector (widthX*(i),      widthY*(j-1),      height[i][j-1]);
+        
+        Vector c1 = v2 - v1;
+        Vector c2 = v3 - v1;
+        Vector c3=  v4 - v1;
+        Vector c4 = v5 - v1;
+        Vector zero = Vector (0,0,0);
+        normal_vectors[i][j]=c1.cross(v4-v2)+c2.cross(v1-v3)+c3.cross(v2-v4)+c4.cross(v3-v1);
+        normal_vectors[i][j].normalize();
+      }
+
+  int snowheight=3;
+  for ( int i = 0; i<sizeX; i+=1)
+    for (int j = 0; j<sizeY;j+=1)
+      {   
+        Vector v1 = Vector (widthX*(i),      widthY*(j)  -width/2,      height[i][j]-20 );
+        Vector v2 = Vector (widthX*(i+1),    widthY*(j)  -width/2,      height[i+1][j]-20);
+        Vector v3 = Vector (widthX*(i+1),    widthY*(j+1)-width/2,    height[i+1][j+1]-20);
+        Vector v4 = Vector (widthX*(i),      widthY*(j+1)-width/2,    height[i][j+1]-20);
+        float a[3];
+        if(height[i][j]<snowheight){
+          a[0]=0;
+          a[1]=1.0-height[i][j]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else{
+            a[0]=1.0;
+            a[1]=1.0;
+            a[2]=1.0;
+            glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+            
+        }
+        glNormal3f(normal_vectors[i][j].x, normal_vectors[i][j].y, normal_vectors[i][j].z);
+        glVertex3f(v1.x, v1.y, v1.z);
+        if(height[i+1][j]<snowheight){
+          a[0]=0;
+          a[1] =1.0-height[i+1][j]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else{
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+          
+        }
+        glNormal3f(normal_vectors[i+1][j].x, normal_vectors[i+1][j].y, normal_vectors[i+1][j].z);
+        glVertex3f(v2.x, v2.y, v2.z);
+        if(height[i+1][j+1]<snowheight){
+          a[0]=0;
+          a[1] =1.0-height[i+1][j+1]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else{
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+          
+          
+        }
+        glNormal3f(normal_vectors[i+1][j+1].x, normal_vectors[i+1][j+1].y, normal_vectors[i+1][j+1].z);
+        glVertex3f(v3.x, v3.y, v3.z);
+        if(height[i][j+1]<snowheight){
+          a[0]=0;
+          a[1] =1.0-height[i+1][j+1]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else{
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        glNormal3f(normal_vectors[i][j+1].x, normal_vectors[i][j+1].y, normal_vectors[i][j+1].z);
+        glVertex3f(v4.x, v4.y, v4.z);
+        
+      }
+  glEnd();
+  /*  
+  glBegin(GL_LINES);
+  for( float x = -128.0; x < 128.0; x += 25.0)
+    {
+      for( float y = -128.0; y < 128.0; y += 25.0)
+        {
+          glColor3f(1,0,0);
+          glVertex3f(x,y,-128.0);
+          glVertex3f(x,y,0.0);
+          glColor3f(0.5,0,0);
+          glVertex3f(x,y,0.0);
+          glVertex3f(x,y,128.0);
+        }
+    }
+  for( float y = -128.0; y < 128.0; y += 25.0)
+    {
+      for( float z = -128.0; z < 128.0; z += 25.0)
+        {
+          glColor3f(0,1,0);
+          glVertex3f(-128.0,y,z);
+          glVertex3f(0.0,y,z);
+          glColor3f(0,0.5,0);
+          glVertex3f(0.0,y,z);
+          glVertex3f(128.0,y,z);
+        }
+    }
+  for( float x = -128.0; x < 128.0; x += 25.0)
+    {
+      for( float z = -128.0; z < 128.0; z += 25.0)
+        {
+          glColor3f(0,0,1);
+          glVertex3f(x,-128.0,z);
+          glVertex3f(x,0.0,z);
+          glColor3f(0,0,0.5);
+          glVertex3f(x,0.0,z);
+          glVertex3f(x,128.0,z);
+        }
+      
+    }
+  */  
+  //draw track
+  glBegin(GL_LINES);
+  glColor3f(0,1,1);
+  for( int i = 0; i < tracklen; i++)
+    {
+      glVertex3f(pathnodes[i].x,pathnodes[i].y,pathnodes[i].z);
+      glVertex3f(pathnodes[(i+1)%tracklen].x,pathnodes[(i+1)%tracklen].y,pathnodes[(i+1)%tracklen].z);
+    }
+  glEnd();
+  glEndList();
 }
 
@@ -181 +391 @@
 void World::collide ()
 {
-  List<WorldEntity> *a, *b;
+  /*
+  List *a, *b;
   WorldEntity *aobj, *bobj;
-  
-  a = entities->get_next();
+   
+  a = entities;
   
   while( a != NULL)
     {
-      aobj = a->get_object();
+      aobj = a->nextElement();
       if( aobj->bCollide && aobj->collisioncluster != NULL)
         {
-          b = a->get_next();
+          b = a->nextElement();
           while( b != NULL )
             {
-              bobj = b->get_object();
+              bobj = b->nextElement();
               if( bobj->bCollide && bobj->collisioncluster != NULL )
                 {
@@ -206 +417 @@
                   }
                 }
-              b = b->get_next();
+              b = b->nextElement();
             }
         }
-      a = a->get_next();
-    }
+      a = a->enumerate();
+    }
+  */
 }
 
@@ -221 +433 @@
   
   // draw entities
-  List<WorldEntity> *l;
   WorldEntity* entity;
   
-  l = entities->get_next();  
-  while( l != NULL ) 
+  entity = this->entities->enumerate();
+  while( entity != NULL ) 
     { 
-      entity = l->get_object();
       if( entity->bDraw ) entity->draw();
-      l = l->get_next();
+      entity = this->entities->nextElement();
     }
   
   
   // draw debug coord system
-  glLoadIdentity();
-  
-
-  glBegin(GL_LINES);
-  
-  for( float x = -128.0; x < 128.0; x += 25.0)
-    {
-      for( float y = -128.0; y < 128.0; y += 25.0)
-        {
-          glColor3f(1,0,0);
-          glVertex3f(x,y,-128.0);
-          glVertex3f(x,y,0.0);
-          glColor3f(0.5,0,0);
-          glVertex3f(x,y,0.0);
-          glVertex3f(x,y,128.0);
-        }
-    }
-  for( float y = -128.0; y < 128.0; y += 25.0)
-    {
-      for( float z = -128.0; z < 128.0; z += 25.0)
-        {
-          glColor3f(0,1,0);
-          glVertex3f(-128.0,y,z);
-          glVertex3f(0.0,y,z);
-          glColor3f(0,0.5,0);
-          glVertex3f(0.0,y,z);
-          glVertex3f(128.0,y,z);
-        }
-    }
-  for( float x = -128.0; x < 128.0; x += 25.0)
-    {
-      for( float z = -128.0; z < 128.0; z += 25.0)
-        {
-          glColor3f(0,0,1);
-          glVertex3f(x,-128.0,z);
-          glVertex3f(x,0.0,z);
-          glColor3f(0,0,0.5);
-          glVertex3f(x,0.0,z);
-          glVertex3f(x,128.0,z);
-        }
-      
-    }
-  
-  //draw track
-  glColor3f(0,1,1);
-  for( int i = 0; i < tracklen; i++)
-    {
-      glVertex3f(pathnodes[i].x,pathnodes[i].y,pathnodes[i].z);
-      glVertex3f(pathnodes[(i+1)%tracklen].x,pathnodes[(i+1)%tracklen].y,pathnodes[(i+1)%tracklen].z);
-    }
-  glEnd();
+  glCallList (objectList);
+
+
 }
 
@@ -297 +459 @@
 void World::update ()
 {
-  List<WorldEntity> *l;
+  //List<WorldEntity> *l;
   WorldEntity* entity;
   Location* loc;
@@ -303 +465 @@
   Uint32 t;
   
-  l = entities->get_next();  
-  while( l != NULL ) 
+  //  l = entities->enumerate(); 
+  entity = this->entities->enumerate();
+  while( entity != NULL ) 
     { 
-      entity = l->get_object();
+
       
       if( !entity->isFree() )
         {
-          loc = entity->get_location();
-          plc = entity->get_placement();
+          loc = entity->getLocation();
+          plc = entity->getPlacement();
           t = loc->part;
           
@@ -318 +481 @@
             {
               printf("An entity is out of the game area\n");
-              entity->left_world ();
+              entity->leftWorld ();
             }
           else
             {
-              while( track[t].map_coords( loc, plc) )
+              while( track[t].mapCoords( loc, plc) )
                 {
-                  track[t].post_leave (entity);
+                  track[t].postLeave (entity);
                   if( loc->part >= tracklen )
                     {
                       printf("An entity has left the game area\n");
-                      entity->left_world ();
+                      entity->leftWorld ();
                       break;
                     }
-                  track[loc->part].post_enter (entity);
+                  track[loc->part].postEnter (entity);
                 }
             }
@@ -337 +500 @@
       else
         {
-          /* TO DO: implement check whether this particular free entity 
+          /* \todo: implement check whether this particular free entity 
              is out of the game area
-             TO DO: call function to notify the entity that it left 
+             \todo: call function to notify the entity that it left 
              the game area
           */
         }
       
-      l = l->get_next();
+      entity = entities->nextElement();
     }
   
@@ -353 +516 @@
     \param deltaT: the time passed since the last frame in milliseconds
 */
-void World::time_slice (Uint32 deltaT)
-{
-  List<WorldEntity> *l;
+void World::timeSlice (Uint32 deltaT)
+{
+  //List<WorldEntity> *l;
   WorldEntity* entity;
-  float seconds = deltaT;
-  
-  seconds /= 1000;
-  
-  l = entities->get_next();  
-  while( l != NULL) 
+  float seconds = deltaT / 1000.0;
+  
+  entity = entities->enumerate(); 
+  while( entity != NULL) 
     { 
-      entity = l->get_object();
       entity->tick (seconds);
-      l = l->get_next();
-    }
-  
-  for( int i = 0; i < tracklen; i++) track[i].tick (seconds);
+      entity = entities->nextElement();
+    }
+
+  //for( int i = 0; i < tracklen; i++) track[i].tick (seconds);
 }
 
@@ -387 +547 @@
    Camera Placement
 */
-void World::calc_camera_pos (Location* loc, Placement* plc)
-{
-  track[loc->part].map_camera (loc, plc);
+void World::calcCameraPos (Location* loc, Placement* plc)
+{
+  track[loc->part].mapCamera (loc, plc);
 }
 
@@ -403 +563 @@
 }
 
+
+
+/**
+   \brief function to put your own debug stuff into it. it can display informations about
+   the current class/procedure
+*/
 void World::debug()
 {
-  List<WorldEntity> *l;
+  //List<WorldEntity> *l;
   WorldEntity* entity;
   
   printf("counting all entities\n");
-  l = entities->get_next();  
-  while( l != NULL ) 
+  printf("World::debug() - enumerate()\n");
+  entity = entities->enumerate();  
+  while( entity != NULL ) 
     { 
-      entity = l->get_object();
       if( entity->bDraw ) printf("got an entity\n");
-      l = l->get_next();
-    }
-}
-
-
+      entity = entities->nextElement();
+    }
+}
+
+
+/*
+  \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 World::mainLoop()
 {
   this->lastFrame = SDL_GetTicks();
-  this->bQuitOrxonox = false;
-  this->bQuitCurrentGame = false;
-  printf("World|Entering main loop\n");
-  while(!this->bQuitOrxonox && !this->bQuitCurrentGame) /* pause pause pause ?!?!?*/
-    {
-      //debug routine
-      //debug();
+  printf("World::mainLoop() - Entering main loop\n");
+  while( !this->bQuitOrxonox && !this->bQuitCurrentGame) /* \todo implement pause */
+    {
       // Network
       synchronize();
       // Process input
-      handle_input();
+      handleInput();
+      if( this->bQuitCurrentGame || this->bQuitOrxonox)
+        {
+          printf("World::mainLoop() - leaving loop earlier...\n");
+          break;
+        }
       // Process time
-      time_slice();
+      timeSlice();
       // Process collision
       collision();
       // Draw
       display();
-    }
-  printf("World|Exiting the main loop\n");
+  
+      for(int i = 0; i < 10000000; i++) {}
+    }
+  printf("World::mainLoop() - Exiting the main loop\n");
 }
 
@@ -454 +630 @@
 /**
    \brief run all input processing
-*/
-void World::handle_input ()
+
+   the command node is the central input event dispatcher. the node uses the even-queue from
+   sdl and has its own event-passing-queue.
+*/
+void World::handleInput ()
 {
   // localinput
-  Orxonox::getInstance()->get_localinput()->process();
+  CommandNode* cn = Orxonox::getInstance()->getLocalInput();
+  cn->process();
   // remoteinput
 }
@@ -464 +644 @@
 /**
    \brief advance the timeline
-*/
-void World::time_slice ()
+
+   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 World::timeSlice ()
 {
   Uint32 currentFrame = SDL_GetTicks();
@@ -471 +655 @@
     {
       Uint32 dt = currentFrame - this->lastFrame;
-      /*
+      
       if(dt > 0)
         {
@@ -479 +663 @@
       else
         {
-          printf("fps = 1000\n");
-        }
-      */
-      this->time_slice (dt);
+          /* the frame-rate is limited to 100 frames per second, all other things are for
+             nothing.
+          */
+          printf("fps = 1000 - frame rate is adjusted\n");
+          SDL_Delay(10);
+          dt = 10;
+        }
+      this->timeSlice (dt);
       this->update ();
-      this->localCamera->time_slice (dt);
+      this->localCamera->timeSlice(dt);
     }
   this->lastFrame = currentFrame;
 }
 
+
 /**
    \brief compute collision detection
@@ -497 +686 @@
 }
 
-/**
-   \brief handle keyboard commands that are not meant for WorldEntities
-   \param cmd: the command to handle
-   \return true if the command was handled by the system or false if it may be passed to the WorldEntities
-*/
-bool World::system_command (Command* cmd)
-{
-  if( !strcmp( cmd->cmd, "quit"))
-    {
-      if( !cmd->bUp) this->bQuitOrxonox = true;
-      return true;
-    }
-  return false;
-}
-
-/**
-        \brief render the current frame
+
+/**
+   \brief render the current frame
+   
+   clear all buffers and draw the world
 */
 void World::display ()
@@ -528 +705 @@
 }
 
+/**
+   \brief give back active camera
+   
+   this passes back the actualy active camera
+   \todo ability to define more than one camera or camera-places
+*/
 Camera* World::getCamera()
 {
@@ -534 +717 @@
 
 
+/**
+   \brief add and spawn a new entity to this world
+   \param entity to be added
+*/
 void World::spawn(WorldEntity* entity)
 {
@@ -539 +726 @@
   Location* loc = NULL;
   WorldEntity* owner;
-  //T* entity = new T();
-  entities->add (entity, LIST_ADD_NEXT);
-  //if( loc == NULL)
-  //{
-      zeroloc.dist = 0;
-      zeroloc.part = 0;
-      zeroloc.pos = Vector();
-      zeroloc.rot = Quaternion();
-      loc = &zeroloc;
-      //}
+
+  entities->add (entity);
+  zeroloc.dist = 0;
+  zeroloc.part = 0;
+  zeroloc.pos = Vector();
+  zeroloc.rot = Quaternion();
+  loc = &zeroloc;
   entity->init (loc, owner);
   if (entity->bFree)
     {
-      this->track[loc->part].map_coords( loc, entity->get_placement());
-    }
-  entity->post_spawn ();
+      this->track[loc->part].mapCoords( loc, entity->getPlacement());
+    }
+  entity->postSpawn ();
+}
+
+
+/**
+   \brief add and spawn a new entity to this world
+   \param entity to be added
+   \param location where to add
+*/
+void World::spawn(WorldEntity* entity, Location* loc)
+{
+  Location zeroLoc;
+  WorldEntity* owner;
+  this->entities->add (entity);
+  if( loc == NULL)
+    {
+      zeroLoc.dist = 0;
+      zeroLoc.part = 0;
+      zeroLoc.pos = Vector();
+      zeroLoc.rot = Quaternion();
+      loc = &zeroLoc;
+    }
+  entity->init (loc, owner);
+  if (entity->bFree)
+    {
+      this->track[loc->part].mapCoords( loc, entity->getPlacement());
+    }
+  entity->postSpawn ();
   //return entity;
 }
+
+
+/**
+   \brief add and spawn a new entity to this world
+   \param entity to be added
+   \param place where to be added
+*/
+void World::spawn(WorldEntity* entity, Placement* plc)
+{
+  Placement zeroPlc;
+  WorldEntity* owner;
+  if( plc == NULL)
+    {
+      zeroPlc.r = Vector();
+      zeroPlc.w = Quaternion();
+      plc = &zeroPlc;
+    }
+  this->entities->add (entity);
+  entity->init (plc, owner);
+  entity->postSpawn ();
+  //return entity;
+}
+
+
+/*
+  \brief commands that the world must catch
+  \returns false if not used by the world
+*/
+bool World::command(Command* cmd)
+{
+  return false;
+}