Index: /trunk/src/lib/coord/p_node.cc
===================================================================
--- /trunk/src/lib/coord/p_node.cc	(revision 6958)
+++ /trunk/src/lib/coord/p_node.cc	(revision 6959)
@@ -1253,5 +1253,5 @@
   SYNCHELP_WRITE_BEGIN();
 
-  if ( this->getHostID()!=this->getOwner() )
+  if ( this->getHostID()!=0 && this->getHostID()!=this->getOwner() )
   {
     return SYNCHELP_WRITE_N;
@@ -1259,7 +1259,7 @@
 
   byte flags = 0;
-  if ( fabs( coorx - relCoordinate.x ) > __OFFSET_POS ||
-       fabs( coory - relCoordinate.y ) > __OFFSET_POS ||
-       fabs( coorz - relCoordinate.z ) > __OFFSET_POS )
+  if ( fabs( coorx - relCoordinate.x ) > __OFFSET_POS*0.05*this->velocity.len() ||
+       fabs( coory - relCoordinate.y ) > __OFFSET_POS*0.05*this->velocity.len() ||
+       fabs( coorz - relCoordinate.z ) > __OFFSET_POS*0.05*this->velocity.len() )
     flags |= __FLAG_COOR;
 
@@ -1272,10 +1272,10 @@
 
   SYNCHELP_WRITE_BYTE( flags, NWT_PN_FLAGS );
-  //PRINTF(0)("FLAGS = %d\n", flags);
+  PRINTF(0)("FLAGS = %d\n", flags);
 
   if ( flags & __FLAG_COOR )
   {
 
-    //PRINTF(0)("SEND COOR: %f %f %f\n", this->relCoordinate.x, this->relCoordinate.y, this->relCoordinate.z);
+    PRINTF(0)("SEND COOR: %f %f %f\n", this->relCoordinate.x, this->relCoordinate.y, this->relCoordinate.z);
 
     SYNCHELP_WRITE_FLOAT( this->relCoordinate.x, NWT_PN_SCOORX );
@@ -1291,5 +1291,5 @@
   {
 
-    //PRINTF(0)("SEND QUAT: %f %f %f %f\n", this->absDirection.w, this->absDirection.v.x, this->absDirection.v.y, this->absDirection.v.z);
+    PRINTF(0)("SEND QUAT: %f %f %f %f\n", this->absDirection.w, this->absDirection.v.x, this->absDirection.v.y, this->absDirection.v.z);
 
     SYNCHELP_WRITE_FLOAT( this->absDirection.w, NWT_PN_SROTV );
@@ -1309,7 +1309,7 @@
 bool PNode::needsReadSync( )
 {
-  if ( fabs( coorx - relCoordinate.x ) > __OFFSET_POS ||
-       fabs( coory - relCoordinate.y ) > __OFFSET_POS ||
-       fabs( coorz - relCoordinate.z ) > __OFFSET_POS )
+  if ( fabs( coorx - relCoordinate.x ) > __OFFSET_POS*0.05*this->velocity.len() ||
+       fabs( coory - relCoordinate.y ) > __OFFSET_POS*0.05*this->velocity.len() ||
+       fabs( coorz - relCoordinate.z ) > __OFFSET_POS*0.05*this->velocity.len() )
     return true;
 
Index: /trunk/src/lib/network/converter.cc
===================================================================
--- /trunk/src/lib/network/converter.cc	(revision 6958)
+++ /trunk/src/lib/network/converter.cc	(revision 6959)
@@ -90,5 +90,5 @@
  * @return: The number of written bytes
  */
-int Converter::intToByteArray(int x, byte* a, int length)
+int Converter::_intToByteArray(int x, byte* a, int length)
 {
   if (length < INTSIZE)
@@ -127,5 +127,5 @@
  * @return: The number of read bytes
  */
-int Converter::byteArrayToInt(const byte* a, int* x)
+int Converter::_byteArrayToInt(const byte* a, int* x)
 {
   int mult = 1;
@@ -146,4 +146,21 @@
     *x += a[INTSIZE - 1] * mult;
 
+  return INTSIZE;
+}
+
+int Converter::byteArrayToInt(const byte* a, int* x)
+{
+  memcpy( x, a, INTSIZE );
+  return INTSIZE;
+}
+
+int Converter::intToByteArray(int x, byte* a, int length)
+{
+  if ( length< INTSIZE )
+  {
+    PRINTF(1)("Byte Array to small\n");
+    return 0;
+  }
+  memcpy(a, &x, INTSIZE);
   return INTSIZE;
 }
Index: /trunk/src/lib/network/converter.h
===================================================================
--- /trunk/src/lib/network/converter.h	(revision 6958)
+++ /trunk/src/lib/network/converter.h	(revision 6959)
@@ -30,4 +30,7 @@
     static int intToByteArray(int x, byte* a, int length);
     static int byteArrayToInt(const byte* a, int* x);
+    
+    static int _intToByteArray(int x, byte* a, int length);
+    static int _byteArrayToInt(const byte* a, int* x);
 
     static int stringToByteArray(const char* s, byte* a, int length, int maxLength);
Index: /trunk/src/lib/network/network_game_manager.cc
===================================================================
--- /trunk/src/lib/network/network_game_manager.cc	(revision 6958)
+++ /trunk/src/lib/network/network_game_manager.cc	(revision 6959)
@@ -29,6 +29,7 @@
 #include "world_entity.h"
 #include "playable.h"
+#include "space_ships/space_ship.h"
 #include "player.h"
-#include "network_manager.h"
+#include "shared_network_data.h"
 
 #include "class_list.h"
@@ -541,5 +542,5 @@
     if ( b->isA(CL_WORLD_ENTITY) && !b->isA(CL_PLAYABLE) )
     {
-      if ( NetworkManager::getInstance()->getHostID()!=0 )
+      if ( SharedNetworkData::getInstance()->getHostID()!=0 )
       {
         static Vector pos = Vector(1000.0, 1000.0, 1000.0);
@@ -550,4 +551,20 @@
       }
     }
+    ///HACK this is only for network multiplayer games.
+    if( b->isA(CL_SPACE_SHIP))
+    {
+      SpaceShip* ss = dynamic_cast<SpaceShip*>(b);
+      if( owner%2 == 0)
+      {
+
+        ss->loadModel("models/ships/reap_#.obj");
+        ss->toList(OM_GROUP_00);
+      }
+      else
+      {
+        ss->loadModel( "models/ships/fighter.obj" );
+        ss->toList(OM_GROUP_01);
+      }
+    }
 
     return b;
@@ -576,4 +593,5 @@
     {
       assert((*it)->isA(CL_WORLD_ENTITY));
+      dynamic_cast<WorldEntity*>(*it)->leaveWorld();
       dynamic_cast<WorldEntity*>(*it)->toList(OM_DEAD);
       break;
@@ -895,4 +913,5 @@
   i += Converter::byteArrayToInt( &data[i], &uniqueID );
 
+  PRINTF(0)("handleRequestSync %d %d\n", uniqueID, sender);
   doRequestSync( uniqueID, sender );
 
@@ -980,4 +999,5 @@
 void NetworkGameManager::executeRequestSync( int uniqueID, int user )
 {
+  PRINTF(0)("executeRequestSync %d %d\n", uniqueID, user);
   if ( user >= outBuffer.size() )
     resizeBufferVector( user );
Index: /trunk/src/lib/network/network_socket.cc
===================================================================
--- /trunk/src/lib/network/network_socket.cc	(revision 6958)
+++ /trunk/src/lib/network/network_socket.cc	(revision 6959)
@@ -172,5 +172,8 @@
 
   if (!tcpSocket || data==NULL || nbytes<=0)
-    return 0;
+  {
+    assert(_OUTGOING_BUFFER_SIZE - outgoingBufferLength > 0);
+    return 0;
+  }
 
   SDL_mutexP(outgoingBufferMutex);
@@ -324,5 +327,13 @@
 
 
+#ifdef DONTEXITTHREADS
+  while ( true )
+  {
+    SDL_Delay(1000);
+  }
+#endif
+  
   PRINTF(0)("QUIT READ THREAD\n");
+  
   return 0;
 }
@@ -392,7 +403,15 @@
   }
 
+#ifdef DONTEXITTHREADS
+  while ( true )
+  {
+  SDL_Delay(1000);
+  }
+#endif
 
   PRINTF(0)("QUIT WRITE THREAD\n");
+
   return 0;
+  
 }
 
@@ -426,4 +445,5 @@
   {
     PRINTF(1)("Buffersize is too small (%d) for packet (%d)\n", maxLength, blen);
+    assert(false);
     return 0;
   }
Index: /trunk/src/lib/network/network_socket.h
===================================================================
--- /trunk/src/lib/network/network_socket.h	(revision 6958)
+++ /trunk/src/lib/network/network_socket.h	(revision 6959)
@@ -8,8 +8,11 @@
 #define _NETWORK_SOCKET
 
+//HACK else gdb will not work on server
+#define DONTEXITTHREADS
+
 //if you want to use outgoing buffer define _USE_OUTGOING_BUFFER
 #define _USE_OUTGOING_BUFFER
 
-#define _INCOMING_BUFFER_SIZE 10240
+#define _INCOMING_BUFFER_SIZE 2024000
 #define _OUTGOING_BUFFER_SIZE 2024000
 #define _LOCAL_BUFFER_SIZE 1024
Index: /trunk/src/lib/network/network_stream.cc
===================================================================
--- /trunk/src/lib/network/network_stream.cc	(revision 6958)
+++ /trunk/src/lib/network/network_stream.cc	(revision 6959)
@@ -26,6 +26,6 @@
 #include "connection_monitor.h"
 #include "synchronizeable.h"
-#include "network_manager.h"
 #include "network_game_manager.h"
+#include "shared_network_data.h"
 
 #include "debug.h"
@@ -195,5 +195,5 @@
           {
             SharedNetworkData::getInstance()->setHostID( handshakes[i]->getHostId() );
-            myHostId = NetworkManager::getInstance()->getHostID();
+            myHostId = SharedNetworkData::getInstance()->getHostID();
 
             this->networkGameManager = NetworkGameManager::getInstance();
@@ -231,12 +231,24 @@
   int reciever;
   Header header;
+  int counter;
+
   for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
   {
+    counter = 0;
+
     if ( (*it)!=NULL && (*it)->beSynchronized() /*&& (*it)->getOwner() == myHostId*/ )
     {
       do {
+        counter++;
+
+        //check for endless loop
+        if ( counter > 50 )
+        {
+          PRINTF(1)("there seems to be an error in readBytes of %s\n", (*it)->getClassName());
+          assert(false);
+        }
+
         reciever = 0;
         dataLength = (*it)->readBytes(downBuffer, DATA_STREAM_BUFFER_SIZE, &reciever);
-
 
         if ( dataLength<=0 ){
@@ -267,7 +279,7 @@
             for ( int i = 0; i<networkSockets.size(); i++)
             {
-              if ( i!=-reciever && networkSockets[i] != NULL )
+              if ( i!=abs(reciever) && networkSockets[i] != NULL )
               {
-                PRINTF(5)("write %d bytes to socket %d\n", dataLength, i);
+                PRINTF(0)("write %d bytes to socket %d uniqueid %d reciever %d\n", dataLength, i, (*it)->getUniqueID(), reciever);
                 networkSockets[i]->writePacket(downBuffer, dataLength);
               }
Index: /trunk/src/lib/network/synchronizeable.h
===================================================================
--- /trunk/src/lib/network/synchronizeable.h	(revision 6958)
+++ /trunk/src/lib/network/synchronizeable.h	(revision 6959)
@@ -34,10 +34,14 @@
   NWT_SS_VELZ,
   NWT_SS_PL_SYNC,
-  
+  NWT_SS_CO_N,
+  NWT_SS_CO_CLID,
+
   NWT_HS_HOST_ID,
   NWT_HS_NGM_ID,
-  
+
+  NWT_PL_B,
   NWT_PL_FLAGS,
-  
+  NWT_PL_SCORE,
+
   NWT_PN_BO_WRITESTATE,
   NWT_PN_PARENTMODE,
@@ -49,5 +53,5 @@
   NWT_PN_ROTZ,
   NWT_PN_ROTV,
-  
+
   NWT_PN_FLAGS,
   NWT_PN_SCOORX,
@@ -58,27 +62,27 @@
   NWT_PN_SROTZ,
   NWT_PN_SROTV,
-  
+
   NWT_BO_NAME,
-  
+
   NWT_WE_PN_WRITESTATE,
   NWT_WE_PN_MODELFILENAME,
   NWT_WE_PN_SCALING,
-  
+
   NWT_GT_WE_STATE,
-  
+
   NWT_SB_WE_STATE,
   NWT_SB_SIZE,
   NWT_SB_TEXTURENAME,
-  
+
   NWT_TER_WE_STATE,
-  
+
   NWT_PU_WE_STATE,
-  
+
   NWT_TPU_WE_STATE,
-  
+
   NWT_LPU_WE_STATE,
-  
+
   NWT_WPU_WE_STATE,
-  
+
   NWT_PPU_WE_STATE,
   NWT_PPU_TYPE,
@@ -133,5 +137,5 @@
  *  delete[] textureName;
  *  textureName = NULL;
- *  SYNCHELP_READ_STRINGM( texturename );      //this will call new char[strlen()+1] 
+ *  SYNCHELP_READ_STRINGM( texturename );      //this will call new char[strlen()+1]
  *
  * Example 2:
@@ -142,5 +146,5 @@
  *
  */
- 
+
 #define SYNCHELP_WRITE_DEBUG(n) {\
   __synchelp_write_n = Converter::intToByteArray( n, data+__synchelp_write_i, maxLength-__synchelp_write_i ); \
Index: /trunk/src/world_entities/planet.h
===================================================================
--- /trunk/src/world_entities/planet.h	(revision 6958)
+++ /trunk/src/world_entities/planet.h	(revision 6959)
@@ -22,5 +22,5 @@
   virtual ~Planet();
 
-  void loadParams(const TiXmlElement* root);
+  virtual void loadParams(const TiXmlElement* root);
 
   void setSize(float size);
Index: /trunk/src/world_entities/playable.cc
===================================================================
--- /trunk/src/world_entities/playable.cc	(revision 6958)
+++ /trunk/src/world_entities/playable.cc	(revision 6959)
@@ -28,4 +28,8 @@
 
 
+#include "dot_emitter.h"
+#include "sprite_particles.h"
+
+
 Playable::Playable()
 {
@@ -43,4 +47,24 @@
 
   this->setSynchronized(true);
+
+  this->score = 0;
+  this->oldScore = 0;
+
+
+  this->emitter = new DotEmitter(100, 5, M_2_PI);
+  this->emitter->setParent(this);
+  this->emitter->setSpread(M_PI, M_PI);
+  this->emitter->setEmissionRate(300.0);
+  this->emitter->setEmissionVelocity(50.0);
+
+  this->explosionParticles = new SpriteParticles(1000);
+  this->explosionParticles->setName("LaserExplosionParticles");
+  this->explosionParticles->setLifeSpan(.5, .3);
+  this->explosionParticles->setRadius(0.0, 10.0);
+  this->explosionParticles->setRadius(.5, 6.0);
+  this->explosionParticles->setRadius(1.0, 3.0);
+  this->explosionParticles->setColor(0.0, 1,1,0,.9);
+  this->explosionParticles->setColor(0.5, .8,.8,0,.5);
+  this->explosionParticles->setColor(1.0, .8,.8,.7,.0);
 }
 
@@ -101,10 +125,16 @@
 void Playable::collidesWith(WorldEntity* entity, const Vector& location)
 {
-  if (entity->isA(CL_PROJECTILE))
+  if (entity->isA(CL_PROJECTILE) && !State::isOnline() )
     this->decreaseHealth(entity->getHealth());
 
   // EXTREME HACK
   if (this->getHealth() == 0.0f)
-    this->deactivateNode();
+  {
+    //this->deactivateNode();
+    this->emitter->setSystem(explosionParticles);
+    this->setAbsCoor(0, 0, 0);
+    //this->setAbsDir(Vector(1,0,0), 0);
+    this->emitter->setSystem(NULL);
+  }
 }
 
@@ -248,4 +278,7 @@
 }
 
+#define DATA_FLAGS    1
+#define DATA_SCORE    2
+
 #define FLAGS_bFire   1
 
@@ -281,4 +314,7 @@
 bool Playable::needsReadSync( )
 {
+  //if ( score != oldScore )
+  //  return true;
+
   byte flags = 0;
 
Index: /trunk/src/world_entities/playable.h
===================================================================
--- /trunk/src/world_entities/playable.h	(revision 6958)
+++ /trunk/src/world_entities/playable.h	(revision 6959)
@@ -15,6 +15,7 @@
 
 class Weapon;
-
+class DotEmitter;
 class Player;
+class SpriteParticles;
 
 //! Basic controllable WorldEntity
@@ -58,4 +59,7 @@
     int       readSync(byte* data, int maxLength );
     bool      needsReadSync();
+    
+    inline void setScore( int score ) { this->score = score; }
+    inline int  getScore() { return this->score; }
 
   protected:
@@ -73,5 +77,11 @@
     bool                  bFire;              //!< If the Ship is firing.
     int                   oldFlags;           //!< Used for synchronisation
+    
+    int                   score;
+    int                   oldScore;
 
+    //HACK: explosion emitter
+    DotEmitter*           emitter;
+    SpriteParticles*      explosionParticles;
 };
 
Index: /trunk/src/world_entities/space_ships/space_ship.cc
===================================================================
--- /trunk/src/world_entities/space_ships/space_ship.cc	(revision 6958)
+++ /trunk/src/world_entities/space_ships/space_ship.cc	(revision 6959)
@@ -96,5 +96,15 @@
   {
     //this->loadModel("models/ships/reap_#.obj");
-    this->loadModel( "models/ships/fighter.obj" );
+    ///HACK this is only for network multiplayer games.
+    if( this->getOwner()%2 == 0)
+    {
+      this->loadModel("models/ships/reap_#.obj");
+      this->toList(OM_GROUP_00);
+    }
+    else
+    {
+      this->loadModel( "models/ships/fighter.obj" );
+      this->toList(OM_GROUP_01);
+    }
   }
 
@@ -275,9 +285,20 @@
 {
   Playable::collidesWith(entity, location);
+
+
   if (entity->isA(CL_TURRET_POWER_UP) && entity != ref)
   {
     this->ADDWEAPON();
     ref = entity;
-    }
+  }
+
+  if( entity->isA(CL_PROJECTILE) && entity != ref)
+  {
+    if ( isServer() )
+    {
+      networkCollisionList.push_back( entity->getHealth() );
+      doCollideNetwork( entity->getHealth() );
+    }
+  }
 //  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassName(), entity->getClassName(), location.x, location.y, location.z);
 }
@@ -320,5 +341,7 @@
 
   // spaceship controlled movement
-  this->calculateVelocity(time);
+  if (this->getOwner() == this->getHostID())
+    this->calculateVelocity(time);
+
 
   Vector move = velocity*time;
@@ -450,5 +473,5 @@
   }
 
-  velocity += accel;
+  velocity += accel*time*10;
   //rot.normalize();
   //this->setRelDirSoft(Quaternion(rotVal, rot), 5);
@@ -526,4 +549,5 @@
 #define DATA_velocity    5
 #define DATA_playables   6
+#define DATA_collision   7
 
 int SpaceShip::writeBytes( const byte * data, int length, int sender )
@@ -561,5 +585,5 @@
         bRollL = (flags & MASK_bRollL) != 0;
         bRollR = (flags & MASK_bRollR) != 0;
-        
+
       }
       else
@@ -603,11 +627,11 @@
         SYNCHELP_READ_FLOAT( velocity.y, NWT_SS_VELY );
         SYNCHELP_READ_FLOAT( velocity.z, NWT_SS_VELZ );
-      }      
+      }
       else
         assert(false);
-      
+
       continue;
     }
-    
+
     if ( b == DATA_playables )
     {
@@ -619,4 +643,17 @@
         assert(false);
     }
+
+    if ( b == DATA_collision )
+    {
+      int n;
+      float energy;
+      SYNCHELP_READ_INT( n, NWT_SS_CO_N );
+
+      for ( int i = 0; i<n; i++ )
+      {
+        SYNCHELP_READ_FLOAT( energy, NWT_SS_CO_CLID );
+        doCollideNetwork( energy );
+      }
+    }
   }
 
@@ -651,11 +688,14 @@
   }
 
-  *reciever = -this->getOwner();
+  *reciever = 0 - this->getOwner();
+  //TODO: implement with SYNCHELP_WRITE_SENT()
   bool sentSomething = false;
 
-  if ( ( this->getHostID()==0 || this->getOwner() == this->getHostID() ) && PNode::needsReadSync() )
-  {
+  if ( PNode::needsReadSync() && ( this->getHostID()==0 || this->getOwner() == this->getHostID() ) )
+  {
+    PRINTF(0)("sending PNode::readSync\n");
     SYNCHELP_WRITE_BYTE( DATA_sync, NWT_SS_B );
     SYNCHELP_WRITE_FKT( PNode::readSync, NWT_SS_PN_SYNC );
+    sentSomething = true;
   }
 
@@ -683,4 +723,5 @@
     {
       oldMask = mask;
+      PRINTF(0)("sending mask\n");
       sentSomething = true;
       SYNCHELP_WRITE_BYTE( DATA_flags, NWT_SS_B );
@@ -705,19 +746,23 @@
     }
 #define __OFFSET_VEL 0.05
-    if ( fabs( oldVelocity.x - velocity.x ) > __OFFSET_VEL*velocity.x ||
-         fabs( oldVelocity.y - velocity.y ) > __OFFSET_VEL*velocity.y ||
-         fabs( oldVelocity.z - velocity.z ) > __OFFSET_VEL*velocity.z )
-    {
-      oldVelocity = velocity;
-      //PRINTF(0)("SENDING velocity\n");
-      //SYNCHELP_WRITE_BYTE( DATA_velocity, NWT_SS_B );
-      //SYNCHELP_WRITE_FLOAT( velocity.x, NWT_SS_VELX );
-      //SYNCHELP_WRITE_FLOAT( velocity.y, NWT_SS_VELY );
-      //SYNCHELP_WRITE_FLOAT( velocity.z, NWT_SS_VELZ );
-    }
-    
+    if ( fabs( oldVelocity.x - velocity.x ) > __OFFSET_VEL*fabs(oldVelocity.x)+0.1 ||
+         fabs( oldVelocity.y - velocity.y ) > __OFFSET_VEL*fabs(oldVelocity.y)+0.1 ||
+         fabs( oldVelocity.z - velocity.z ) > __OFFSET_VEL*fabs(oldVelocity.z)+0.1 )
+    {
+      oldVelocity.x = velocity.x;
+      oldVelocity.y = velocity.y;
+      oldVelocity.z = velocity.z;
+      PRINTF(0)("SENDING velocity\n");
+      sentSomething = true;
+      SYNCHELP_WRITE_BYTE( DATA_velocity, NWT_SS_B );
+      SYNCHELP_WRITE_FLOAT( velocity.x, NWT_SS_VELX );
+      SYNCHELP_WRITE_FLOAT( velocity.y, NWT_SS_VELY );
+      SYNCHELP_WRITE_FLOAT( velocity.z, NWT_SS_VELZ );
+    }
+
     if ( Playable::needsReadSync() )
     {
       sentSomething = true;
+      PRINTF(0)("SYNCHELP_WRITE_FKT( Playable::readSync, NWT_SS_PL_SYNC )\n");
       SYNCHELP_WRITE_BYTE( DATA_playables, NWT_SS_B );
       SYNCHELP_WRITE_FKT( Playable::readSync, NWT_SS_PL_SYNC );
@@ -725,10 +770,32 @@
 
   }
-  
+
   if ( !sentSomething )
-    reciever = 0;
+  {
+    *reciever = 0;
+
+    if ( networkCollisionList.size()>0 )
+    {
+      SYNCHELP_WRITE_BYTE( DATA_collision, NWT_SS_B );
+
+      SYNCHELP_WRITE_INT( networkCollisionList.size(), NWT_SS_CO_N );
+
+      for ( std::list<float>::iterator it = networkCollisionList.begin(); it!=networkCollisionList.end(); it++ )
+      {
+        SYNCHELP_WRITE_FLOAT( *it, NWT_SS_CO_CLID );
+      }
+
+      networkCollisionList.clear();
+    }
+  }
 
   return SYNCHELP_WRITE_N;
 }
 
-
+void SpaceShip::doCollideNetwork( float energy )
+{
+  this->decreaseHealth( energy );
+}
+
+
+
Index: /trunk/src/world_entities/space_ships/space_ship.h
===================================================================
--- /trunk/src/world_entities/space_ships/space_ship.h	(revision 6958)
+++ /trunk/src/world_entities/space_ships/space_ship.h	(revision 6959)
@@ -47,4 +47,6 @@
     void calculateVelocity(float time);
 
+    void doCollideNetwork( float energy );
+
     // !! temporary !!
     void ADDWEAPON();
@@ -84,4 +86,6 @@
     ParticleEmitter*      burstEmitter;
     ParticleSystem*       burstSystem;
+
+    std::list<float>        networkCollisionList;
 };
 
Index: /trunk/src/world_entities/world_entity.cc
===================================================================
--- /trunk/src/world_entities/world_entity.cc	(revision 6958)
+++ /trunk/src/world_entities/world_entity.cc	(revision 6959)
@@ -280,12 +280,7 @@
 
 /**
- *  this method is called by the world if the WorldEntity leaves valid gamespace
- *
- * For free entities this means it left the Track boundaries. With bound entities it means its Location adresses a
- * place that is not in the world anymore. In both cases you might have to take extreme measures (a.k.a. call destroy).
- *
- * NOT YET IMPLEMENTED
- */
-void WorldEntity::leftWorld ()
+ *  this method is called by the world if the WorldEntity leaves the game
+ */
+void WorldEntity::leaveWorld ()
 {}
 
Index: /trunk/src/world_entities/world_entity.h
===================================================================
--- /trunk/src/world_entities/world_entity.h	(revision 6958)
+++ /trunk/src/world_entities/world_entity.h	(revision 6959)
@@ -54,5 +54,5 @@
 
   virtual void postSpawn ();
-  virtual void leftWorld ();
+  virtual void leaveWorld ();
 
   virtual void tick (float time);
