Changeset 6695 in orxonox.OLD for trunk

Timestamp:

Jan 25, 2006, 2:39:53 PM (19 years ago)

Author:

patrick

Message:

merged the network branche to the trunk

Location:

trunk/src

Files:

• defs/class_id.h (modified) (1 diff)
• lib/coord/p_node.cc (modified) (8 diffs)
• lib/coord/p_node.h (modified) (1 diff)
• lib/graphics/importer/vertex_array_model.cc (modified) (3 diffs)
• lib/network/Makefile.am (modified) (2 diffs)
• lib/network/handshake.cc (modified) (2 diffs)
• lib/network/netdefs.h (modified) (2 diffs)
• lib/network/network_game_manager.cc (modified) (30 diffs)
• lib/network/network_game_manager.h (modified) (5 diffs)
• lib/network/network_manager.cc (modified) (6 diffs)
• lib/network/network_manager.h (modified) (3 diffs)
• lib/network/network_socket.cc (modified) (1 diff)
• lib/network/network_socket.h (modified) (1 diff)
• lib/network/network_stream.cc (modified) (10 diffs)
• lib/network/network_stream.h (modified) (3 diffs)
• lib/network/shared_network_data.cc (copied) (copied from branches/network/src/lib/network/shared_network_data.cc)
• lib/network/shared_network_data.h (copied) (copied from branches/network/src/lib/network/shared_network_data.h)
• lib/network/synchronizeable.cc (modified) (9 diffs)
• lib/network/synchronizeable.h (modified) (2 diffs)
• orxonox.cc (modified) (2 diffs)
• util/state.cc (modified) (1 diff)
• util/state.h (modified) (2 diffs)
• world_entities/environments/water.cc (modified) (2 diffs)
• world_entities/environments/water.h (modified) (1 diff)
• world_entities/movie_entity.cc (modified) (2 diffs)
• world_entities/planet.cc (modified) (4 diffs)
• world_entities/playable.cc (modified) (6 diffs)
• world_entities/power_ups/param_power_up.cc (modified) (1 diff)
• world_entities/power_ups/turret_power_up.cc (modified) (1 diff)
• world_entities/power_ups/weapon_power_up.cc (modified) (1 diff)
• world_entities/projectiles/laser.cc (modified) (1 diff)
• world_entities/skybox.cc (modified) (1 diff)
• world_entities/space_ships/space_ship.cc (modified) (3 diffs)
• world_entities/terrain.cc (modified) (1 diff)
• world_entities/weapons/targeting_turret.cc (modified) (1 diff)
• world_entities/weapons/weapon.cc (modified) (1 diff)
• world_entities/world_entity.cc (modified) (3 diffs)
• world_entities/world_entity.h (modified) (1 diff)

trunk/src/defs/class_id.h

@@ -147 +147 @@
   CL_GLGUI_MAIN_WIDGET          =    0x00000f41,
   CL_NETWORK_MANAGER            =    0x00000f50,
+  CL_SHARED_NETWORK_DATA        =    0x00000f51,
 
 

trunk/src/lib/coord/p_node.cc

@@ -42 +42 @@
  */
 PNode::PNode (PNode* parent, long nodeFlags)
+  : Synchronizeable(), BaseObject()
 {
   this->setClassID(CL_PARENT_NODE, "PNode");
@@ -487 +488 @@
       this->children.push_back(child);
     child->parentCoorChanged();
+
+//     if(this->getUniqueID() == NET_UID_UNASSIGNED)
+//     {
+//       PRINTF(1)("Adding to an UNASSIGNED PNode - looking for next assigned Node\n");
+//       PNode* node = this->seekNextAssignedPNode(this);
+//       if( node == NULL)
+//         PRINTF(1)("    Got NULL - Is this the NULLParent - uid %i\n", this->getUniqueID());
+//       else
+//         PRINTF(1)("    Found next assigned node: %i\n", node->getUniqueID());
+//     }
   }
   else
@@ -495 +506 @@
     child->parentCoorChanged();
   }
+}
+
+
+PNode* PNode::seekNextAssignedPNode(PNode* node) const
+{
+  PNode* tmpNode = node->parent;
+  printf("entering seek PNode loop for name: %s, uid: %i\n", node->getName(), node->getUniqueID());
+  if(tmpNode)
+    printf("  @node name: %s, uid: %d\n", tmpNode->getName(), tmpNode->getUniqueID());
+  while( tmpNode != NULL && tmpNode->getUniqueID() == NET_UID_UNASSIGNED)
+  {
+    printf("  @node name: %s, uid: %d\n", tmpNode->getName(), tmpNode->getUniqueID());
+    tmpNode = tmpNode->parent;
+  }
+  printf("leaving PNode loop\n\n");
+
+  return tmpNode;
 }
 
@@ -695 +723 @@
   {
     PNode::nullParent = new PNode(NULL, PNODE_PARENT_MODE_DEFAULT | PNODE_REPARENT_TO_NULL);
+    PNode::nullParent->setClassID(CL_NULL_PARENT, "NullParent");
     PNode::nullParent->setName("NullParent");
+    PNode::nullParent->setSynchronized(true);
   }
   return PNode::nullParent;
@@ -1049 +1079 @@
   SYNCHELP_READ_FKT( BaseObject::writeState );
 
-  char * parentName = NULL;
-  SYNCHELP_READ_STRINGM( parentName );
-
-  if ( strcmp(parentName, "")==0 )
-  {
-    setParent( (char*)NULL );
-  }
-  else
-  {
-    setParent( parentName );
-  }
-
-  delete[] parentName;
+//   char * parentName = NULL;
+//   SYNCHELP_READ_STRINGM( parentName );
+//
+//   if ( strcmp(parentName, "")==0 )
+//   {
+//     setParent( (char*)NULL );
+//   }
+//   else
+//   {
+//     setParent( parentName );
+//   }
+//
+//  delete[] parentName;
 
   int parentMode;
@@ -1081 +1111 @@
   this->setRelDir( Quaternion( Vector(f2, f3, f4), f1 ) );
 
-  int n;
-  char * childName;
-
-  PRINTF(0)("JKLO %d %d %d %d\n", data[__synchelp_read_i], data[__synchelp_read_i+1], data[__synchelp_read_i+2], data[__synchelp_read_i+3]);
-  SYNCHELP_READ_INT( n );
-  PRINTF(0)("read %s:n=%d\n", this->getName(), n);
-
-  for (int i = 0; i<n; i++)
-  {
-    SYNCHELP_READ_STRINGM( childName );
-    PRINTF(0)("RCVD CHILD = %s\n", childName);
-    addChild( childName );
-    delete childName;
-    childName = NULL;
-  }
+//   int n;
+//   char * childName;
+//
+//   PRINTF(0)("JKLO %d %d %d %d\n", data[__synchelp_read_i], data[__synchelp_read_i+1], data[__synchelp_read_i+2], data[__synchelp_read_i+3]);
+//   SYNCHELP_READ_INT( n );
+//   PRINTF(0)("read %s:n=%d\n", this->getName(), n);
+//
+//   for (int i = 0; i<n; i++)
+//   {
+//     SYNCHELP_READ_STRINGM( childName );
+//     PRINTF(0)("RCVD CHILD = %s\n", childName);
+//     addChild( childName );
+//     delete childName;
+//     childName = NULL;
+//   }
 
   return SYNCHELP_READ_N;
@@ -1112 +1142 @@
   SYNCHELP_WRITE_FKT( BaseObject::readState );
 
-  if ( this->parent )
-  {
-    SYNCHELP_WRITE_STRING( parent->getName() );
-  }
-  else
-  {
-    SYNCHELP_WRITE_STRING( "" );
-  }
+//   if ( this->parent )
+//   {
+//     SYNCHELP_WRITE_STRING( parent->getName() );
+//   }
+//   else
+//   {
+//     SYNCHELP_WRITE_STRING( "" );
+//   }
 
   SYNCHELP_WRITE_INT( this->parentMode );
@@ -1132 +1162 @@
   SYNCHELP_WRITE_FLOAT( this->relDirection.v.z );
 
-  int n = children.size();
-
-  //check if camera is in children
-  for (std::list<PNode*>::const_iterator it = children.begin(); it!=children.end(); it++)
-  {
-    if ( (*it)->isA(CL_CAMERA) )
-      n--;
-  }
-  PRINTF(0)("write %s:n=%d\n", this->getName(), n);
-  SYNCHELP_WRITE_INT( n );
-  PRINTF(0)("ASDF %d %d %d %d\n", data[__synchelp_write_i-4], data[__synchelp_write_i-3], data[__synchelp_write_i-2], data[__synchelp_write_i-1]);
-
-  for (std::list<PNode*>::const_iterator it = children.begin(); it!=children.end(); it++)
-  {
-    //dont add camera because there is only one camera attached to local player
-    if ( !(*it)->isA(CL_CAMERA) )
-    {
-      PRINTF(0)("SENDING CHILD: %s\n", (*it)->getName());
-      SYNCHELP_WRITE_STRING( (*it)->getName() );
-    }
-  }
+//   int n = children.size();
+//   //check if camera is in children
+//   for (std::list<PNode*>::const_iterator it = children.begin(); it!=children.end(); it++)
+//   {
+//     if ( (*it)->isA(CL_CAMERA) )
+//       n--;
+//   }
+//   PRINTF(0)("write %s:n=%d\n", this->getName(), n);
+//   SYNCHELP_WRITE_INT( n );
+//   PRINTF(0)("ASDF %d %d %d %d\n", data[__synchelp_write_i-4], data[__synchelp_write_i-3], data[__synchelp_write_i-2], data[__synchelp_write_i-1]);
+//
+//
+//   for (std::list<PNode*>::const_iterator it = children.begin(); it!=children.end(); it++)
+//   {
+//     //dont add camera because there is only one camera attached to local player
+//     if ( !(*it)->isA(CL_CAMERA) )
+//     {
+//       PRINTF(0)("SENDING CHILD: %s\n", (*it)->getName());
+//       SYNCHELP_WRITE_STRING( (*it)->getName() );
+//     }
+//   }
 
   return SYNCHELP_WRITE_N;

trunk/src/lib/coord/p_node.h

@@ -147 +147 @@
   void removeNode();
 
+  PNode* seekNextAssignedPNode(PNode* node) const;
+
   /** @param parent the new parent of this node */
   inline void setParent (PNode* parent) { parent->addChild(this); };

trunk/src/lib/graphics/importer/vertex_array_model.cc

@@ -305 +305 @@
     this->addColor(.125,.436,.246); ///FIXME
   }
+
   for (unsigned int loopNumber = 0; loopNumber <= loops; ++loopNumber)
   {
@@ -326 +327 @@
     }
   }
+
   for (unsigned int loopSegmentNumber = 0; loopSegmentNumber < segmentsPerLoop; ++loopSegmentNumber)
   {
@@ -331 +333 @@
     this->addIndice(segmentsPerLoop + loopSegmentNumber);
   }
+
   for (unsigned int loopNumber = 0; loopNumber < loops; ++loopNumber)
   {

trunk/src/lib/network/Makefile.am

@@ -6 +6 @@
 libORXnet_a_SOURCES = synchronizeable.cc \
                       network_manager.cc \
+                      shared_network_data.cc \
                       network_socket.cc \
                       connection_monitor.cc \
@@ -21 +22 @@
 noinst_HEADERS = synchronizeable.h \
                  network_manager.h \
+                 shared_network_data.h \
                  network_socket.h \
                  connection_monitor.h \

trunk/src/lib/network/handshake.cc

@@ -23 +23 @@
 
 Handshake::Handshake( bool server, int clientId, int networkGameManagerId )
+  : Synchronizeable()
 {
   /* set the class id for the base object */
@@ -34 +35 @@
   this->setOwner(0);
 
+  this->setSynchronized(true);
   PRINTF(5)("Handshake created clientId = %d\n", clientId);
 }

trunk/src/lib/network/netdefs.h

@@ -17 +17 @@
 
 
+#define MAX_CONNECTIONS 1000
+
+
 typedef unsigned char byte;
 
@@ -25 +28 @@
 } NodeType;
 
+
+typedef enum {
+  NET_UID_UNASSIGNED = -1,
+
+  NET_UID_NUMBER
+} UidType;
+
 #endif /* _NETWORK_MANAGER */

trunk/src/lib/network/network_game_manager.cc

@@ -46 +46 @@
  */
 NetworkGameManager::NetworkGameManager()
+  : Synchronizeable()
 {
   PRINTF(0)("START\n");
@@ -52 +53 @@
   this->setClassID(CL_NETWORK_GAME_MANAGER, "NetworkGameManager");
 
-  newUniqueID = MAX_CONNECTIONS + 2;
-
   hasRequestedWorld = false;
+  this->setSynchronized(true);
 }
 
@@ -80 +80 @@
     b = data[i++];
 
+    /**************** Commands only processed by servers ****************/
     if ( isServer() )
     {
-      if ( b == REQUEST_CREATE )
+      if ( b == NET_REQUEST_CREATE )
       {
         if ( !handleRequestCreate( i, data, length, sender ) )
@@ -88 +89 @@
         continue;
       }
-      if ( b == REQUEST_REMOVE )
+      else if ( b == NET_REQUEST_REMOVE )
       {
         if ( !handleRequestRemove( i, data, length, sender ) )
@@ -94 +95 @@
         continue;
       }
+      else if ( b == NET_REQUEST_PNODE_PATH )
+      {
+        if ( !handleRequestPNodePath( i, data, length, sender ) )
+          return i;
+        continue;
+      }
     }
     else
     {
-      if ( b == CREATE_ENTITY )
+      /**************** Commands only processed by clients ****************/
+      if ( b == NET_CREATE_ENTITY )
       {
         PRINTF(0)("CREATE_ENTITY\n");
@@ -104 +112 @@
         continue;
       }
-      if ( b == REMOVE_ENTITY )
+      else if ( b == NET_REMOVE_ENTITY )
       {
         if ( !handleRemoveEntity( i, data, length, sender ) )
@@ -110 +118 @@
         continue;
       }
-      if ( b == CREATE_ENTITY_LIST )
+      else if ( b == NET_CREATE_ENTITY_LIST )
       {
         if ( !handleCreateEntityList( i, data, length, sender ) )
@@ -116 +124 @@
         continue;
       }
-      if ( b == REMOVE_ENTITY_LIST )
+      else if ( b == NET_REMOVE_ENTITY_LIST )
       {
         if ( !handleRemoveEntityList( i, data, length, sender ) )
@@ -122 +130 @@
         continue;
       }
-      if ( b == YOU_ARE_ENTITY )
+      else if ( b == NET_YOU_ARE_ENTITY )
       {
         if ( !handleYouAreEntity( i, data, length, sender ) )
@@ -130 +138 @@
     }
 
-    if ( b == REQUEST_ENTITY_LIST )
+    /**************** Commands processed by servers and clients ****************/
+    if ( b == NET_REQUEST_ENTITY_LIST )
     {
       sendEntityList( sender );
       continue;
     }
-
-    if ( b == REQUEST_SYNC )
+    else if ( b == NET_REQUEST_SYNC )
     {
       if ( !handleRequestSync( i, data, length, sender ) )
@@ -143 +151 @@
     }
 
-    //if we get her something with data is wrong
+
+    PRINTF(1)("Network is asynchronous: couldn't decode the command sent by %i\n", sender);
+    PRINTF(1)("Probably this is because the network protocol has different \n");
+    PRINTF(1)("versions or there occured an error in the sending algorithm\n");
     PRINTF(1)("Data is not in the right format! i=%d\n", i);
     return i;
@@ -156 +167 @@
   {
     SYNCHELP_WRITE_BEGIN();
-    byte b = REQUEST_ENTITY_LIST;
+    byte b = NET_REQUEST_ENTITY_LIST;
     SYNCHELP_WRITE_BYTE( b );
     hasRequestedWorld = true;
@@ -200 +211 @@
 int NetworkGameManager::createEntity( ClassID classID, int owner )
 {
-  if ( this->isServer() )
-  {
-    if ( newUniqueID < 0 )
+  if ( this->isServer())
+  {
+    if ( SharedNetworkData::getInstance()->getNewUniqueID() < 0 )
     {
       PRINTF(1)("Cannot create entity! There are no more uniqueIDs left!\n");
       return -1;
     }
-
-    return this->executeCreateEntity( classID, newUniqueID++, owner );
+    return this->executeCreateEntity( classID, SharedNetworkData::getInstance()->getNewUniqueID(), owner );
   }
   else
@@ -227 +237 @@
   if ( this->isServer() )
   {
-    if ( newUniqueID < 0 )
+    if ( SharedNetworkData::getInstance()->getNewUniqueID() < 0 )
     {
       PRINTF(1)("Cannot create entity! There are no more uniqueIDs left!\n");
@@ -245 +255 @@
     {
       Synchronizeable * s = dynamic_cast<Synchronizeable*>(b);
-      s->setUniqueID( newUniqueID++ );
+      s->setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
       s->setOwner( 0 );
-      this->networkStream->connectSynchronizeable( *s );
+      // all entities created via this function are added automaticaly to the synchronizeable list
+      s->setSynchronized(true);
       return b;
     }
@@ -258 +269 @@
   }
   else
+
   {
     PRINTF(1)("This node is not a server and cannot create id %x\n", element->Value());
@@ -295 +307 @@
       continue;
 
-    if ( !writeToClientBuffer( outBuffer[i], (byte)REQUEST_CREATE ) )
+    if ( !writeToClientBuffer( outBuffer[i], (byte)NET_REQUEST_CREATE ) )
       return;
     if ( !writeToClientBuffer( outBuffer[i], (int)classID ) )
@@ -313 +325 @@
       continue;
 
-    if ( !writeToClientBuffer( outBuffer[i], (byte)REQUEST_REMOVE ) )
+    if ( !writeToClientBuffer( outBuffer[i], (byte)NET_REQUEST_REMOVE ) )
       return;
     if ( !writeToClientBuffer( outBuffer[i], uniqueID ) )
@@ -332 +344 @@
       continue;
 
-    if ( !writeToClientBuffer( outBuffer[i], (byte)CREATE_ENTITY ) )
+    if ( !writeToClientBuffer( outBuffer[i], (byte)NET_CREATE_ENTITY ) )
       return -1;
     if ( !writeToClientBuffer( outBuffer[i], (int)classID ) )
@@ -342 +354 @@
   }
 
+  PRINTF(0)("ExecuteCreateEntity: server side: classID: %x, uniqueID: %i, owner: %i\n", classID, uniqueID, owner);
   doCreateEntity( classID, uniqueID, owner );
 
@@ -359 +372 @@
       continue;
 
-    if ( !writeToClientBuffer( outBuffer[i], (byte)REMOVE_ENTITY ) )
+    if ( !writeToClientBuffer( outBuffer[i], (byte)NET_REMOVE_ENTITY ) )
       return;
     if ( !writeToClientBuffer( outBuffer[i], uniqueID ) )
@@ -394 +407 @@
   e = this->networkStream->getSyncEnd();
 
-  if ( !writeToClientBuffer( outBuffer[userID], (byte)CREATE_ENTITY_LIST ) )
+  // send the packet header
+  if ( !writeToClientBuffer( outBuffer[userID], (byte)NET_CREATE_ENTITY_LIST ) )
     return;
 
-  // -2 because you must not send network_game_manager and handshake
+  // send the number of entities: -2 because you must not send network_game_manager and handshake
   if ( !writeToClientBuffer( outBuffer[userID], networkStream->getSyncCount() ) )
     return;
@@ -403 +417 @@
   //PRINTF(0)("SendEntityList: n = %d\n", networkStream->getSyncCount()-2 );
 
-  int n = 0;
-
+  // first send the NullParent
+  if ( !writeToClientBuffer( outBuffer[userID], (int)PNode::getNullParent()->getLeafClassID()) )
+    return;
+  if ( !writeToClientBuffer( outBuffer[userID], (int)PNode::getNullParent()->getUniqueID()) )
+    return;
+  if ( !writeToClientBuffer( outBuffer[userID], (int)PNode::getNullParent()->getOwner()) )
+    return;
+
+  // now send the rest of the entities
   while ( it != e )
   {
-    PRINTF(5)("SENDING ENTITY %s id %d\n", (*it)->getClassName(), (*it)->getUniqueID() );
-    if ( !writeToClientBuffer( outBuffer[userID], (int)((*it)->getLeafClassID()) ) )
-      return;
-
-    if ( !writeToClientBuffer( outBuffer[userID], (int)((*it)->getUniqueID()) ) )
-      return;
-
-    if ( !writeToClientBuffer( outBuffer[userID], (int)((*it)->getOwner()) ) )
-      return;
-
+    if( (*it)->beSynchronized() && (*it) != PNode::getNullParent())
+    {
+      PRINTF(0)("SENDING ENTITY %s classid: %x, uniqueid %d\n", (*it)->getClassName(), (*it)->getLeafClassID(), (*it)->getUniqueID() );
+      if ( !writeToClientBuffer( outBuffer[userID], (int)((*it)->getLeafClassID()) ) )
+        return;
+
+      if ( !writeToClientBuffer( outBuffer[userID], (int)((*it)->getUniqueID()) ) )
+        return;
+
+      if ( !writeToClientBuffer( outBuffer[userID], (int)((*it)->getOwner()) ) )
+        return;
+    }
     it++;
   }
@@ -467 +490 @@
 BaseObject* NetworkGameManager::doCreateEntity( ClassID classID, int uniqueID, int owner )
 {
-  BaseObject * b = Factory::fabricate( classID );
+  PRINTF(0)("Creating Entity via Factory: classid: %x, uniqueID: %i, owner: %i\n", classID, uniqueID, owner);
+
+  BaseObject * b;
+  /* These are some small exeptions in creation: Not all objects can/should be created via Factory */
+  /* Exception 1: NullParent */
+  if( classID == CL_NULL_PARENT)
+  {
+    b = (BaseObject*)PNode::getNullParent();
+  }
+  else
+    b = Factory::fabricate( classID );
 
   if ( !b )
@@ -480 +513 @@
     s->setUniqueID( uniqueID );
     s->setOwner( owner );
-    this->networkStream->connectSynchronizeable( *s );
+    s->setSynchronized(true);
+    //this->networkStream->connectSynchronizeable( *s );
     if ( !isServer() )
       s->setIsOutOfSync( true );
@@ -646 +680 @@
   if ( userID != 0 )
   {
-    if ( !writeToClientBuffer( outBuffer[userID], (byte)YOU_ARE_ENTITY ) )
+    if ( !writeToClientBuffer( outBuffer[userID], (byte)NET_YOU_ARE_ENTITY ) )
       return;
 
@@ -714 +748 @@
   i += Converter::byteArrayToInt( &data[i], &owner );
 
+  PRINTF(0)("handleCreateEntity: client side: classID: %x, uniqueID: %i, owner: %i\n", classID, uniqueID, owner);
   doCreateEntity( (ClassID)classID, uniqueID, owner );
 
@@ -779 +814 @@
     {
       BaseObject* b = doCreateEntity( (ClassID)classID, uniqueID, owner );
-
-      /*if ( b != NULL )
-      {
-        if ( b->isA(CL_WORLD_ENTITY) )
-        {
-          int n = dynamic_cast<WorldEntity*>(b)->writeState( data, length, sender );
-
-          i += n;
-        }
-    }*/
     }
 
@@ -854 +879 @@
   return true;
 }
+
+
+/**
+ *  handles the network signal NET_REQUEST_PNODE_PATH
+ * @param i byte offset in the buffer
+ * @param data data array
+ * @param length length of the data arary
+ * @param sender the sender id
+ * @return true if process terminated sucessfully
+ */
+bool NetworkGameManager::handleRequestPNodePath(int& i, const byte* data, int length, int sender)
+{
+  if( INTSIZE > length-i )
+  {
+    PRINTF(1)("Cannot read n from buffer! Not enough data left!\n");
+    return false;
+  }
+  PRINTF(0)("HandleRequestPNodePath:  data[i..i+3] = %d %d %d %d\n", data[i], data[i+1], data[i+2], data[i+3]);
+
+  int uniqueID1, uniqueID2;
+  if( INTSIZE > length-i )
+  {
+    PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
+    return false;
+  }
+  i += Converter::byteArrayToInt( &data[i], &uniqueID1 );
+
+  if( INTSIZE > length-i )
+  {
+    PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
+    return false;
+  }
+  i += Converter::byteArrayToInt( &data[i], &uniqueID2 );
+
+
+  PRINTF(0)("HandleRequestPNodePath: got a request for path from uid %i to uid %i\n", uniqueID1, uniqueID2);
+
+  return true;
+}
+
 
 bool NetworkGameManager::writeToClientBuffer( clientBuffer & cb, byte b )
@@ -898 +963 @@
     resizeBufferVector( user );
 
-  if ( !writeToClientBuffer( outBuffer[user], (byte)REQUEST_SYNC ) )
+  if ( !writeToClientBuffer( outBuffer[user], (byte)NET_REQUEST_SYNC ) )
     return;
   if ( !writeToClientBuffer( outBuffer[user], uniqueID ) )

trunk/src/lib/network/network_game_manager.h

@@ -15 +15 @@
 
 class TiXmlElement;
+class PNode;
 
 /**
  * protocol definition
  *
- *  CREATE_ENTITY:       CLASS_ID, UNIQUE_ID, OWNER
- *  REMOVE_ENTITY:       UNIQUE_ID
+ *  CREATE_ENTITY:       >> CLASS_ID, UNIQUE_ID, OWNER
+ *  REMOVE_ENTITY:       >> UNIQUE_ID
  *
- *  CREATE_ENTITY_LIST:  NUMBER, [CLASS_ID, UNIQUE_ID, OWNER][0..NUMBER]
- *  REMOVE_ENTITY_LIST:  NUMBER, [UNIQUE_ID][0..NUMBER]
+ *  CREATE_ENTITY_LIST:  >> NUMBER, [CLASS_ID, UNIQUE_ID, OWNER][0..NUMBER]
+ *  REMOVE_ENTITY_LIST:  >> NUMBER, [UNIQUE_ID][0..NUMBER]
  *
- *  REQUEST_CREATE:      CLASS_ID
- *  REQUEST_REMOVE:      UNIQUE_ID
+ *  REQUEST_CREATE:      >> CLASS_ID
+ *                       << [Sync Info]
+ *  REQUEST_REMOVE:      >> UNIQUE_ID
+ *                       << [Sync Info]
  *
  *  //REQUEST_CREATE_LIST: NUMBER, [CLASS_ID][0..NUMBER]
@@ -32 +35 @@
  *
  *  REQUEST_ENTITY_LIST: //request the whole world :D
- *  REQUEST_SYNC:        UNIQUE_ID
+ *  REQUEST_SYNC:        >> UNIQUE_ID
+ *                       << [Sync Info]
  *  //REQUEST_SYNC_LIST:   NUMBER, [UNIQUE_ID][0..NUMBER]
  *
- *  YOU_ARE_ENTITY:      UNIQUE_ID
+ *  YOU_ARE_ENTITY:      >> UNIQUE_ID
  *
+ *  REQUEST_PNODE_PATH   >> UNIQUE_ID_START   UNIQUE_ID_STOP
+ *                       << UNIQUE_ID_1   UNIQUE_ID_2   UNIQUE_ID_3 ...   UNIQUE_ID_N
+ *
+ *  SEND_PNODE_PATH      >> UNIQUE_ID_START   UNIQUE_ID_STOP NUMBER [UNIQUE_ID][0..NUMBER]
  */
 
-typedef enum NetworkGameManagerProtocol{
-  CREATE_ENTITY = 0,
-  REMOVE_ENTITY,
-  CREATE_ENTITY_LIST,
-  REMOVE_ENTITY_LIST,
-  REQUEST_CREATE,
-  REQUEST_REMOVE,
-  REQUEST_SYNC,
-  YOU_ARE_ENTITY,
-  REQUEST_ENTITY_LIST
+typedef enum NetworkGameManagerProtocol {
+  NET_CREATE_ENTITY = 0,
+  NET_REMOVE_ENTITY,
+  NET_CREATE_ENTITY_LIST,
+  NET_REMOVE_ENTITY_LIST,
+  NET_REQUEST_CREATE,
+  NET_REQUEST_REMOVE,
+  NET_REQUEST_SYNC,
+  NET_YOU_ARE_ENTITY,
+  NET_REQUEST_ENTITY_LIST,
+  NET_REQUEST_PNODE_PATH,
+  NET_SEND_PNODE_PATH,
+
+  NET_NUMBER
 };
 
@@ -83 +95 @@
     void sendEntityList(int userID);
 
+
   private:
     NetworkGameManager();
 
+
+    /* some network signal handlers */
+    bool handleRequestCreate( int& i, const byte* data, int length, int sender );
+    bool handleRequestRemove( int& i, const byte* data, int length, int sender );
+    bool handleCreateEntity( int& i, const byte* data, int length, int sender );
+    bool handleRemoveEntity( int& i, const byte* data, int length, int sender );
+    bool handleCreateEntityList( int& i, const byte* data, int length, int sender );
+    bool handleRemoveEntityList( int& i, const byte* data, int length, int sender );
+    bool handleYouAreEntity( int& i, const byte* data, int length, int sender );
+    bool handleRequestSync( int& i, const byte* data, int length, int sender );
+    bool handleRequestPNodePath(int& i, const byte* data, int length, int sender);
+    bool handleSendPNodePath(int& i, const byte* data, int length, int sender);
+
+
+    /* some network handlers helper functions */
     void requestCreateEntity(ClassID classID);
     int executeCreateEntity(ClassID classID, int uniqueID = 0, int owner = 0);
+    BaseObject* doCreateEntity(ClassID classID, int uniqueID, int owner);
 
     void requestRemoveEntity(int uniqueID);
     void executeRemoveEntity(int uniqueID);
+    void doRemoveEntity(int uniqueID);
 
     void executeRequestSync( int uniqueID, int user );
+    void doRequestSync(int uniqueID, int userID);
 
-    BaseObject* doCreateEntity(ClassID classID, int uniqueID, int owner);
-    void doRemoveEntity(int uniqueID);
-    void doRequestSync(int uniqueID, int userID);
     void doYouAre( int uniqueID );
+
+    void requestPNodePath(const PNode* node1, const PNode* node2);
+    void executeRequestPNodePath(const PNode* node2, const PNode* node2);
+    void doRequestPNodePath(const PNode* node1, const PNode* node2);
 
     bool canCreateEntity(ClassID classID);
@@ -105 +137 @@
     void resizeBufferVector(int n);
 
-    inline bool writeToClientBuffer( clientBuffer &cb, byte*data, int length );
-    inline bool writeToClientBuffer( clientBuffer &cb, byte b );
-    inline bool writeToClientBuffer( clientBuffer &cb, int i );
-    inline bool readFromClientBuffer( clientBuffer &cb, byte*data, int length );
+    bool writeToClientBuffer( clientBuffer &cb, byte*data, int length );
+    bool writeToClientBuffer( clientBuffer &cb, byte b );
+    bool writeToClientBuffer( clientBuffer &cb, int i );
+    bool readFromClientBuffer( clientBuffer &cb, byte*data, int length );
 
-    //helper functions for writeBytes
-    inline bool handleRequestCreate( int& i, const byte* data, int length, int sender );
-    inline bool handleRequestRemove( int& i, const byte* data, int length, int sender );
-    inline bool handleCreateEntity( int& i, const byte* data, int length, int sender );
-    inline bool handleRemoveEntity( int& i, const byte* data, int length, int sender );
-    inline bool handleCreateEntityList( int& i, const byte* data, int length, int sender );
-    inline bool handleRemoveEntityList( int& i, const byte* data, int length, int sender );
-    inline bool handleYouAreEntity( int& i, const byte* data, int length, int sender );
-    inline bool handleRequestSync( int& i, const byte* data, int length, int sender );
 
   private:
@@ -124 +147 @@
     //clientBuffer                  allOutBuffer;
     static NetworkGameManager*    singletonRef;
-
-    int                           newUniqueID;
     bool                          hasRequestedWorld;
 };

trunk/src/lib/network/network_manager.cc

@@ -20 +20 @@
 #define DEBUG_MODULE_NETWORK
 
-
-#include "network_stream.h"
 #include "class_list.h"
-
 #include "debug.h"
-
+#include "shell_command.h"
 
 /* include your own header */
 #include "network_manager.h"
+#include "shared_network_data.h"
+#include "network_stream.h"
 
 
 /* using namespace std is default, this needs to be here */
 using namespace std;
+
+SHELL_COMMAND(debug, NetworkManager, debug);
 
 
@@ -49 +50 @@
   this->netStreamList = NULL;
   this->syncList = NULL;
-  this->tmpStream = NULL;
-
-  this->hostID = -1;
-  this->bGameServer = false;
+  this->defaultSyncStream = NULL;
+  this->sharedNetworkData = SharedNetworkData::getInstance();
 
   PRINTF(0)("NetworkManager created\n");
@@ -98 +97 @@
   }
 
-  this->tmpStream = new NetworkStream(ipAddress);
+  this->defaultSyncStream = new NetworkStream(ipAddress);
+  this->sharedNetworkData->setDefaultSyncStream(this->defaultSyncStream);
+  this->defaultSyncStream->startHandshake();
   return 1;
 }
@@ -109 +110 @@
 int NetworkManager::createServer(unsigned int port)
 {
-  this->hostID = 0;
-  this->bGameServer = true;
-  this->tmpStream = new NetworkStream(port);
-  this->bGameServer = true;
+  this->sharedNetworkData->setHostID(0);
+  this->sharedNetworkData->setGameServer(true);
+  this->defaultSyncStream = new NetworkStream(port);
+  this->sharedNetworkData->setDefaultSyncStream(this->defaultSyncStream);
+  this->defaultSyncStream->createNetworkGameManager();
+  PRINTF(0)("CREATE SERVER\n");
   SDL_Delay(20);
   return 1;
@@ -118 +121 @@
 
 
-/**
- *  creates a connection from one object to a host
- * @param address: the address of the destination host
- * @param synchronizeable: reference to the sync object
- */
-NetworkStream& NetworkManager::establishConnection(IPaddress& address, Synchronizeable& sync)
-{
-  /* creating a new network stream, it will register itself automaticaly to the class list */
-  this->tmpStream = new NetworkStream(address);
-  this->tmpStream->connectSynchronizeable(sync);
-}
-
-
-/**
- *  teardown a connection
- */
-void NetworkManager::shutdownConnection()
-{
-  PRINTF(0)("Shutdown connection\n");
-}
-
-
 void NetworkManager::connectSynchronizeable(Synchronizeable& sync)
 {
-  this->tmpStream->connectSynchronizeable(sync);
+  if( this->defaultSyncStream)
+    this->defaultSyncStream->connectSynchronizeable(sync);
 }
 
@@ -157 +139 @@
       if( static_cast<NetworkStream*>(*stream)->isActive())
         static_cast<NetworkStream*>(*stream)->processData();
-
   }
-
 }
 
+
+
 /**
- * Sets the hostID to a specific number
- * @param id: The new ID
+ * debug output
  */
-void NetworkManager::setHostID(int id)
+ void NetworkManager::debug()
 {
-    this->hostID = id;
+  PRINT(0)("=================Network::debug()=========\n");
+  this->defaultSyncStream->debug();
+  PRINT(0)("===========================================\n");
 }

trunk/src/lib/network/network_manager.h

@@ -6 +6 @@
 /* you will want to add such a a line at your header file also, since it will
    prevent c++ from including your code twice*/
-#ifndef _NETWORK_MANGER
+#ifndef _NETWORK_MANAGER
 #define _NETWORK_MANAGER
 
 /* include this file, it contains some default definitions */
 #include "netdefs.h"
+#include "shared_network_data.h"
 
 /* include base_object.h since all classes are derived from this one */
@@ -38 +39 @@
     int createServer(unsigned int port);
 
-    NetworkStream& establishConnection(IPaddress& address, Synchronizeable& sync);
-    void shutdownConnection();
-
-
-    void setHostID(int id);
     /** Returns the hostID @return The hostID of the object */
-    inline int getHostID() { return this->hostID; }
-    inline bool isGameServer() { return this->bGameServer; }
+    inline int getHostID() { return this->sharedNetworkData->getHostID(); }
+    inline bool isGameServer() { return this->sharedNetworkData->isGameServer(); }
 
 
     void connectSynchronizeable(Synchronizeable& sync);
     void synchronize();
+
+    void debug();
+
 
   private:
@@ -59 +58 @@
     const std::list<BaseObject*>*    syncList;                // list of synchronizeables
     static NetworkManager*           singletonRef;            //!< Pointer to the only instance of this Class
-    NetworkStream*                   tmpStream;               //!< FIXME: this is only for testing purposes
-    int                              hostID;                  //!< The Host-ID of the Manager
-    bool                             bGameServer;             //!< true if it is a server
+    NetworkStream*                   defaultSyncStream;       //!< FIXME: this is only for testing purposes
 
+    SharedNetworkData*               sharedNetworkData;       //!< reference to the shared data
 };
 

trunk/src/lib/network/network_socket.cc

@@ -97 +97 @@
 /**
  * Default destructor
+ * dont use this from outside: use destroy() instead!!
  */
 NetworkSocket::~NetworkSocket( )

trunk/src/lib/network/network_socket.h

@@ -81 +81 @@
   void init();
 
-  //dont make this public use destroy() instead
-  ~NetworkSocket();
-
 public:
 
   NetworkSocket();
+  ~NetworkSocket();
   NetworkSocket(IPaddress ip);
   NetworkSocket(TCPsocket sock);

trunk/src/lib/network/network_stream.cc

@@ -53 +53 @@
 }
 
+
 NetworkStream::NetworkStream(IPaddress& address)
 {
@@ -60 +61 @@
   this->networkProtocol = new NetworkProtocol();
   this->connectionMonitor = new ConnectionMonitor();
-
-  Handshake* hs = new Handshake(false);
-  hs->setUniqueID( 0 );
-  this->handshakes.push_back(hs);
-  this->connectSynchronizeable(*hs);
-  PRINTF(0)("NetworkStream: %s\n", hs->getName());
   this->maxConnections = 1;
 }
@@ -81 +76 @@
   this->handshakes.push_back( NULL );
   this->bActive = true;
-  this->networkGameManager = NetworkGameManager::getInstance();
-  // setUniqueID( maxCon+2 ) because we need one id for every handshake
-  // and one for handshake to reject client maxCon+1
-  this->networkGameManager->setUniqueID( this->maxConnections+2 );
-  this->connectSynchronizeable( *(this->networkGameManager) );
-
-  this->setMaxConnections( 10 );
 }
 
@@ -132 +120 @@
 
 
+void NetworkStream::createNetworkGameManager()
+{
+  this->networkGameManager = NetworkGameManager::getInstance();
+  // setUniqueID( maxCon+2 ) because we need one id for every handshake
+  // and one for handshake to reject client maxCon+1
+  this->networkGameManager->setUniqueID( this->maxConnections + 2 );
+  //this->connectSynchronizeable( *(this->networkGameManager) );
+  this->setMaxConnections( 10 );
+}
+
+
+void NetworkStream::startHandshake()
+{
+  Handshake* hs = new Handshake(false);
+  hs->setUniqueID( 0 );
+  this->handshakes.push_back(hs);
+  //this->connectSynchronizeable(*hs);
+  PRINTF(0)("NetworkStream: %s\n", hs->getName());
+}
+
+
 void NetworkStream::connectSynchronizeable(Synchronizeable& sync)
 {
@@ -140 +149 @@
     this->bActive = true;
 }
+
 
 void NetworkStream::disconnectSynchronizeable(Synchronizeable& sync)
@@ -184 +194 @@
           if ( type != NET_SERVER )
           {
-            NetworkManager::getInstance()->setHostID( handshakes[i]->getHostId() );
+            SharedNetworkData::getInstance()->setHostID( handshakes[i]->getHostId() );
             myHostId = NetworkManager::getInstance()->getHostID();
 
             this->networkGameManager = NetworkGameManager::getInstance();
             this->networkGameManager->setUniqueID( handshakes[i]->getNetworkGameManagerId() );
-            this->connectSynchronizeable( *(this->networkGameManager) );
+            //this->connectSynchronizeable( *(this->networkGameManager) );
           }
           else
@@ -216 +226 @@
   /* DOWNSTREAM */
 
+
+
   int dataLength;
   int reciever;
@@ -221 +233 @@
   for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
   {
-    if ( (*it)!=NULL /*&& (*it)->getOwner() == myHostId*/ )
+    if ( (*it)!=NULL && (*it)->beSynchronized() /*&& (*it)->getOwner() == myHostId*/ )
     {
       do {
@@ -357 +369 @@
     PRINTF(0)("New Client: %d\n", clientId);
 
-    this->connectSynchronizeable(*handshakes[clientId]);
+    //this->connectSynchronizeable(*handshakes[clientId]);
   }
 
@@ -416 +428 @@
 
 
+
+void NetworkStream::debug()
+{
+  if( this->isServer())
+    PRINT(0)(" Host ist Server with ID: %i\n", this->myHostId);
+  else
+    PRINT(0)(" Host ist Client with ID: %i\n", this->myHostId);
+
+  PRINT(0)(" Got %i connected Synchronizeables, showing active Syncs:\n", this->synchronizeables.size());
+  for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
+  {
+    if( (*it)->beSynchronized() == true)
+      PRINT(0)("  Synchronizeable of class: %s::%s, with unique ID: %i, Synchronize: %i\n", (*it)->getClassName(), (*it)->getName(),
+               (*it)->getUniqueID(), (*it)->beSynchronized());
+  }
+  PRINT(0)(" Maximal Connections: %i\n", this->maxConnections);
+
+}
+
+
+int NetworkStream::getSyncCount()
+{
+  int n = 0;
+  for (SynchronizeableList::iterator it = synchronizeables.begin(); it!=synchronizeables.end(); it++)
+    if( (*it)->beSynchronized() == true)
+      ++n;
+
+  //return synchronizeables.size();
+  return n;
+}
+
+
+
+
+
+

trunk/src/lib/network/network_stream.h

@@ -14 +14 @@
 #include "server_socket.h"
 #include "handshake.h"
-
-#define MAX_CONNECTIONS 1000
 
 class Synchronizeable;
@@ -40 +38 @@
     void init();
 
+    void createNetworkGameManager();
+    void startHandshake();
+
     void connectSynchronizeable(Synchronizeable& sync);
     void disconnectSynchronizeable(Synchronizeable& sync);
@@ -53 +54 @@
     inline SynchronizeableList::const_iterator getSyncBegin(){ return synchronizeables.begin(); }
     inline SynchronizeableList::const_iterator getSyncEnd(){ return synchronizeables.end(); }
-    inline int getSyncCount(){ return synchronizeables.size(); }
+    int getSyncCount();
 
     inline bool isUserIdActive( int userID ) { if (userID>=networkSockets.size()) return false; else return networkSockets[userID]!=NULL; }
 
+    void debug();
+
+
   private:
-    NetworkProtocol*       networkProtocol;
-    ConnectionMonitor*     connectionMonitor;
-    SynchronizeableList    synchronizeables;
-    NetworkSocketVector    networkSockets;
-    HandshakeVector        handshakes;
-    ServerSocket*          serverSocket;
-    int                    type;
-    Header                 packetHeader;
-    bool                   bActive;
-    std::list<int>         freeSocketSlots;
+    void updateConnectionList();
 
-    int                    myHostId;
-    int                    maxConnections;
 
-    NetworkGameManager*   networkGameManager;
+  private:
+    NetworkProtocol*           networkProtocol;
+    ConnectionMonitor*         connectionMonitor;
+    SynchronizeableList        synchronizeables;
+    NetworkSocketVector        networkSockets;
+    HandshakeVector            handshakes;
+    ServerSocket*              serverSocket;
+    int                        type;
+    Header                     packetHeader;
+    bool                       bActive;
+    std::list<int>             freeSocketSlots;
 
-    void updateConnectionList();
+    int                        myHostId;
+    int                        maxConnections;
+
+    NetworkGameManager*        networkGameManager;
 };
 #endif /* _NETWORK_STREAM */

trunk/src/lib/network/synchronizeable.cc

@@ -17 +17 @@
 #define DEBUG_MODULE_NETWORK
 
+#include "shared_network_data.h"
+#include "network_stream.h"
+#include "netdefs.h"
+
+#include "state.h"
+
+#include "assert.h"
+
 #include "synchronizeable.h"
-#include "netdefs.h"
-#include "network_manager.h"
-#include "network_stream.h"
+
 
 
@@ -29 +35 @@
 {
   this->setClassID(CL_SYNCHRONIZEABLE, "Synchronizeable");
-  owner = 0;
-  state = 0;
-  hostID = NetworkManager::getInstance()->getHostID();
+  this->owner = 0;
+  this->state = 0;
+  this->hostID = SharedNetworkData::getInstance()->getHostID();
   this->setIsServer(this->hostID == 0);
-  uniqueID = -1;
+  this->uniqueID = NET_UID_UNASSIGNED;
   this->networkStream = NULL;
   this->setRequestedSync( false );
   this->setIsOutOfSync( !(this->isServer()) );
+  this->bSynchronize = false;
+
+  if( State::isOnline())
+  {
+    NetworkStream* nd = SharedNetworkData::getInstance()->getDefaultSyncStream();
+    assert(nd != NULL);
+    nd->connectSynchronizeable(*this);
+    this->setUniqueID(SharedNetworkData::getInstance()->getNewUniqueID());
+  }
 }
 
@@ -50 +65 @@
 }
 
+
 /**
  *  write data to NetworkStream
@@ -57 +73 @@
   PRINTF(5)("Synchronizeable::writeBytes was called\n");
 }
+
 
 /**
@@ -87 +104 @@
 }
 
+
 /**
  * Sets the outofsync flag to a given value
@@ -100 +118 @@
 }
 
+
 /**
  * Determines if the server flag is set
@@ -108 +127 @@
   return (this->state & STATE_SERVER) >0;
 }
+
 
 /**
@@ -118 +138 @@
 }
 
+
 /**
  * Determines if the requestedSync flag is set
@@ -126 +147 @@
   return (this->state & STATE_REQUESTEDSYNC) >0;
 }
+
 
 /**

trunk/src/lib/network/synchronizeable.h

@@ -163 +163 @@
 
 class Synchronizeable : virtual public BaseObject
-  {
+{
+
   public:
     Synchronizeable();
-    ~Synchronizeable();
+    virtual ~Synchronizeable();
 
     virtual int       writeBytes(const byte* data, int length, int sender);
@@ -179 +180 @@
     bool isOutOfSync();
     bool requestedSync();
+
     inline void setUniqueID( int id ){ uniqueID = id; }
-    inline int  getUniqueID() const { return uniqueID; };
+    inline int  getUniqueID() const { return uniqueID; }
+    inline int getHostID() { return this->hostID; }
+
+    inline int getOwner(){ return owner; }
+    inline void setOwner(int owner){ this->owner = owner; }
+
+    /** @returns true if this Synchronizeable has to be synchronized over network */
+    inline bool beSynchronized() { return this->bSynchronize; }
+    /** @param bSynchronize sets the Synchronizeable to be sunchronized or not */
+    inline void setSynchronized(bool bSynchronize) { this->bSynchronize = bSynchronize; }
+
     inline void requestSync( int hostID ){ this->synchronizeRequests.push_back( hostID ); }
     inline int getRequestSync( void ){ if ( this->synchronizeRequests.size()>0 ){ int n = *(synchronizeRequests.begin()); synchronizeRequests.pop_front(); return n; } else { return -1; } };
-    inline int getHostID() { return this->hostID; }
-
-    inline int getOwner(){ return owner; }
-    inline void setOwner(int owner){ this->owner = owner; }
 
     inline void setNetworkStream(NetworkStream* stream) { this->networkStream = stream; }
+    inline NetworkStream* getNetworkStream() { return this->networkStream; }
+
+
+  protected:
+    NetworkStream*    networkStream;
+    int               state;
+
 
   private:
-
     int               uniqueID;
-
-
-
-    //static std::vector<Synchronizeable*> classList;
-    int owner;
-    int hostID;
-
-    std::list<int> synchronizeRequests;
-
-  protected:
-    NetworkStream* networkStream;
-    int state;
-
-  };
+    int               owner;
+    int               hostID;
+    bool              bSynchronize;
+
+    std::list<int>    synchronizeRequests;
+
+};
 #endif /* _SYNCHRONIZEABLE_H */

trunk/src/orxonox.cc

@@ -56 +56 @@
 
 #include "network_manager.h"
+
+#include "state.h"
 
 #include <string.h>
@@ -276 +278 @@
 
   if( this->serverName != NULL) // we are a client
+  {
+    State::setOnline(true);
     NetworkManager::getInstance()->establishConnection(this->serverName, port);
+  }
   else if( this->port > 0) {    // we are a server
+    State::setOnline(true);
     NetworkManager::getInstance()->createServer(port);
   }
-
   return 0;
 }

trunk/src/util/state.cc

@@ -41 +41 @@
 Player* State::player = NULL;
 
+bool State::bOnline = false;
 
 /**

trunk/src/util/state.h

@@ -73 +73 @@
 
 
+  ///////////////
+  /// NETWORK ///
+  ///////////////
+  /** sets the online stat (multiplayer network) @param bOnline is true if node is online */
+  static inline void setOnline(bool bOnline) { State::bOnline = bOnline; }
+  /** @returns true if this node is online (multiplayer network game) */
+  static bool isOnline() { return State::bOnline; }
+
 
  private:
@@ -87 +95 @@
   static unsigned int           resX;              //!< The X Resolution of the screen.
   static unsigned int           resY;              //!< The Y Resolution of the screen.
+
+  static bool                   bOnline;           //!< Is true if this node is in multiplayer mode (via network)
+
   };
 

trunk/src/world_entities/environments/water.cc

@@ -28 +28 @@
 #include "skybox.h"
 
+#include "network_game_manager.h"
 
 using namespace std;
@@ -238 +239 @@
   this->grid->rebuildNormals(this->height);
 }
+
+
+/**
+ * Writes data from network containing information about the state
+ * @param data pointer to data
+ * @param length length of data
+ * @param sender hostID of sender
+ */
+int Water::writeBytes( const byte * data, int length, int sender )
+{
+  setRequestedSync( false );
+  setIsOutOfSync( false );
+
+  SYNCHELP_READ_BEGIN();
+
+  SYNCHELP_READ_FKT( Water::writeState );
+
+  return SYNCHELP_READ_N;
+}
+
+
+/**
+ * data copied in data will bee sent to another host
+ * @param data pointer to data
+ * @param maxLength max length of data
+ * @return the number of bytes writen
+ */
+int Water::readBytes( byte * data, int maxLength, int * reciever )
+{
+  SYNCHELP_WRITE_BEGIN();
+
+  if ( isOutOfSync() && !requestedSync() && this->getHostID()!=this->getOwner() )
+  {
+    (NetworkGameManager::getInstance())->sync( this->getUniqueID(), this->getOwner() );
+    setRequestedSync( true );
+  }
+
+  int rec = this->getRequestSync();
+  if ( rec > 0 )
+  {
+    *reciever = rec;
+    SYNCHELP_WRITE_FKT( Water::readState );
+  }
+
+  *reciever = 0;
+  return SYNCHELP_WRITE_N;
+}
+
+
+
+/**
+ * data copied in data will bee sent to another host
+ * @param data pointer to data
+ * @param maxLength max length of data
+ * @return the number of bytes writen
+ */
+int Water::readState( byte * data, int maxLength )
+{
+  SYNCHELP_WRITE_BEGIN();
+
+  SYNCHELP_WRITE_FKT( WorldEntity::readState );
+
+  // sync the size
+  SYNCHELP_WRITE_FLOAT( this->sizeX );
+  SYNCHELP_WRITE_FLOAT( this->sizeY );
+
+  //sync resolution
+  SYNCHELP_WRITE_INT( this->resX );
+  SYNCHELP_WRITE_INT( this->resY );
+
+  //sync the height
+  SYNCHELP_WRITE_FLOAT( this->height );
+
+  return SYNCHELP_WRITE_N;
+}
+
+
+/**
+ * Writes data from network containing information about the state
+ * @param data pointer to data
+ * @param length length of data
+ * @param sender hostID of sender
+ */
+int Water::writeState( const byte * data, int length, int sender )
+{
+  SYNCHELP_READ_BEGIN();
+
+  SYNCHELP_READ_FKT( WorldEntity::writeState );
+
+  float f1, f2;
+  int i1, i2;
+
+  //read the size
+  SYNCHELP_READ_FLOAT( f1 );
+  SYNCHELP_READ_FLOAT( f2 );
+  this->sizeX = f1;
+  this->sizeY = f2;
+  PRINTF(0)("Setting Water to size: %f x %f\n", f1, f2);
+
+  //read the resolution
+  SYNCHELP_READ_INT( i1 );
+  SYNCHELP_READ_INT( i2 );
+  this->resX = i1;
+  this->resY = i2;
+  PRINTF(0)("Setting Water to resolution: %i x %i\n", i1, i2);
+
+  //read the height
+  SYNCHELP_READ_FLOAT( f1 );
+  this->height = f1;
+
+  this->rebuildGrid();
+
+  return SYNCHELP_READ_N;
+}
+
+

trunk/src/world_entities/environments/water.h

@@ -35 +35 @@
    void tick(float dt);
 
+   virtual int writeBytes(const byte* data, int length, int sender);
+   virtual int readBytes(byte* data, int maxLength, int * reciever);
+
+   int writeState( const byte * data, int length, int sender );
+   int readState( byte * data, int maxLength );
+
+
   private:
     Grid*           grid;            //!< The water-surface-model to render with

trunk/src/world_entities/movie_entity.cc

@@ -40 +40 @@
   this->toList(OM_COMMON);
 
-  this->loadParams(root);
+  if( root != NULL)
+    this->loadParams(root);
 
   counter = 0;
@@ -52 +53 @@
 MovieEntity::~MovieEntity ()
 {
-  delete this->media_container;
+  if( this->media_container)
+    delete this->media_container;
 }
 

trunk/src/world_entities/planet.cc

@@ -27 +27 @@
 #include "network_game_manager.h"
 #include "converter.h"
+#include "vertex_array_model.h"
+#include "primitive_model.h"
 
 using namespace std;
@@ -44 +46 @@
 
   this->material = new Material();
-  this->material->setIllum(10);
+  //this->material->setIllum(20);
+  //this->material->setAmbient(0.1, 0.1, 0.1);
+
+
+
+      //st float radius, const unsigned int loops, const unsigned int segmentsPerLoop
 
   this->loadParams(root);
+
+//   VertexArrayModel* model = new VertexArrayModel();
+//   model->spiralSphere(this->size, 10, 10);
+//   this->setModel(model);
+//   model->debug();
+//
+  PrimitiveModel* model = new PrimitiveModel(PRIM_SPHERE, this->size, 50);
+  this->setModel(model);
 }
 
@@ -98 +113 @@
 {
 
+
   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
+
+  glShadeModel(GL_SMOOTH);
 
   /* translate */
@@ -109 +127 @@
   this->material->select();
 
-
-  Vector c;
-  double r = this->size;
-  int n = 200;
-  int method = 1;
-  double theta1 = 0;
-  double theta2 = 2 * M_PI;
-  double phi1 = -M_PI/2.0;
-  double phi2 = M_PI/2.0;
-
-
-  int i,j;
-  double jdivn,j1divn,idivn,dosdivn,unodivn=1/(double)n,ndiv2=(double)n/2,t1,t2,t3,cost1,cost2,cte1,cte3;
-  cte3 = (theta2-theta1)/n;
-  cte1 = (phi2-phi1)/ndiv2;
-  dosdivn = 2*unodivn;
-  Vector e,p,e2,p2;
-
-
-  t2=phi1;
-  cost2=cos(phi1);
-  j1divn=0;
-  for (j=0;j<ndiv2;j++) {
-    t1 = t2;//t1 = phi1 + j * cte1;
-    t2 += cte1;//t2 = phi1 + (j + 1) * cte1;
-    t3 = theta1 - cte3;
-    cost1 = cost2;//cost1=cos(t1);
-    cost2 = cos(t2);
-    e.y = sin(t1);
-    e2.y = sin(t2);
-    p.y = c.y + r * e.y;
-    p2.y = c.y + r * e2.y;
-
-    if (method == 0)
-      glBegin(GL_QUAD_STRIP);
-    else
-      glBegin(GL_TRIANGLE_STRIP);
-
-    idivn=0;
-    jdivn=j1divn;
-    j1divn+=dosdivn;//=2*(j+1)/(double)n;
-    for (i=0;i<=n;i++) {
-       //t3 = theta1 + i * (theta2 - theta1) / n;
-      t3 += cte3;
-      e.x = cost1 * cos(t3);
-       //e.y = sin(t1);
-      e.z = cost1 * sin(t3);
-      p.x = c.x + r * e.x;
-       //p.y = c.y + r * e.y;
-      p.z = c.z + r * e.z;
-      glNormal3f(e.x,e.y,e.z);
-      glTexCoord2f(idivn,jdivn);
-      glVertex3f(p.x,p.y,p.z);
-
-
-      e2.x = cost2 * cos(t3);
-       //e.y = sin(t2);
-      e2.z = cost2 * sin(t3);
-      p2.x = c.x + r * e2.x;
-       //p.y = c.y + r * e.y;
-      p2.z = c.z + r * e2.z;
-      glNormal3f(e2.x,e2.y,e2.z);
-      glTexCoord2f(idivn,j1divn);
-      glVertex3f(p2.x,p2.y,p2.z);
-      idivn += unodivn;
-    }
-    glEnd();
-  }
+//   /WorldEntity::draw();
+  this->getModel(0)->draw();
+ // static_cast<VertexArrayModel*>(this->getModel(0))->debug();
 }
 

trunk/src/world_entities/playable.cc

@@ -36 +36 @@
   // the reference to the Current Player is NULL, because we dont have one at the beginning.
   this->currentPlayer = NULL;
-}
+
+  this->setSynchronized(true);
+}
+
+
 
 Playable::~Playable()
@@ -57 +61 @@
 }
 
+
 void Playable::removeWeapon(Weapon* weapon)
 {
@@ -63 +68 @@
     this->weaponConfigChanged();
 }
+
 
 void Playable::nextWeaponConfig()
@@ -70 +76 @@
 }
 
+
 void Playable::previousWeaponConfig()
 {
@@ -76 +83 @@
 }
 
+
 void Playable::weaponConfigChanged()
 {
@@ -81 +89 @@
     this->currentPlayer->weaponConfigChanged();
 }
+
 
 /**

trunk/src/world_entities/power_ups/param_power_up.cc

@@ -46 +46 @@
 {
   this->init();
-  this->loadParams(root);
+  if( root != NULL)
+    this->loadParams(root);
 }
 

trunk/src/world_entities/power_ups/turret_power_up.cc

@@ -36 +36 @@
   this->init();
 
-  this->loadParams(root);
+  if( root != NULL)
+    this->loadParams(root);
 }
 

trunk/src/world_entities/power_ups/weapon_power_up.cc

@@ -39 +39 @@
 {
   this->init();
-  this->loadParams(root);
+  if( root != NULL)
+    this->loadParams(root);
 }
 

trunk/src/world_entities/projectiles/laser.cc

@@ -30 +30 @@
 #include <cassert>
 
+#include "assert.h"
 
 

trunk/src/world_entities/skybox.cc

@@ -51 +51 @@
   this->preInit();
 
-  this->loadParams(root);
+  if( root != NULL)
+    this->loadParams(root);
 
   this->postInit();

trunk/src/world_entities/space_ships/space_ship.cc

@@ -97 +97 @@
   if (root != NULL)
     this->loadParams(root);
+  else
+  {
+    this->loadModel("models/ships/reap_#.obj");
+  }
+
+}
+
+
+/**
+ * initializes a Spaceship
+ */
+void SpaceShip::init()
+{
+//  this->setRelDir(Quaternion(M_PI, Vector(1,0,0)));
+  this->setClassID(CL_SPACE_SHIP, "SpaceShip");
+
+  PRINTF(4)("SPACESHIP INIT\n");
 
   //weapons:
@@ -112 +129 @@
 
   this->getWeaponManager()->changeWeaponConfig(1);
-}
-
-
-/**
- * initializes a Spaceship
- */
-void SpaceShip::init()
-{
-//  this->setRelDir(Quaternion(M_PI, Vector(1,0,0)));
-  this->setClassID(CL_SPACE_SHIP, "SpaceShip");
-
-  PRINTF(4)("SPACESHIP INIT\n");
 
   EventHandler::getInstance()->grabEvents(true);
@@ -206 +211 @@
   dynamic_cast<Element2D*>(this->getWeaponManager()->getFixedTarget())->setVisibility( false);
 }
+
 
 /**

trunk/src/world_entities/terrain.cc

@@ -39 +39 @@
 {
   this->init();
-  this->loadParams(root);
+  if( root != NULL)
+    this->loadParams(root);
 
 //  if (this->model != NULL)

trunk/src/world_entities/weapons/targeting_turret.cc

@@ -48 +48 @@
 {
   this->init();
-  this->loadParams(root);
+  if( root != NULL)
+    this->loadParams(root);
 }
 

trunk/src/world_entities/weapons/weapon.cc

@@ -100 +100 @@
 
   this->energyWidget = NULL;
+
+  // set this object to be synchronized over network
+  //this->setSynchronized(true);
 }
 

trunk/src/world_entities/world_entity.cc

@@ -54 +54 @@
   this->energyMax = 1.0f;
   this->energy = 1.0f;
+  this->scaling = 1.0f;
+
+  /* OSOLETE */
+  this->bVisible = true;
+  this->bCollide = true;
 
   this->md2TextureFileName = NULL;
-
-
-  this->setVisibiliy(true);
 
   this->objectListNumber = OM_INIT;
@@ -122 +124 @@
 void WorldEntity::loadModel(const char* fileName, float scaling, unsigned int modelNumber)
 {
+  this->modelLODName = fileName;
   this->scaling = scaling;
   if ( fileName != NULL && strcmp(fileName, "") )
@@ -515 +518 @@
   //check if modelFileName is relative to datadir or absolute
 
+
+  PRINTF(0)("================ LOADING MODEL %s, %f\n", modelFileName, scaling);
+
   if ( strcmp(modelFileName, "") )
   {
-    loadModel( modelFileName, scaling );
+    loadModel( modelFileName, scaling);
+    PRINTF(0)("modelfilename: %s\n", getModel( 0 )->getName());
   }
   delete[] modelFileName;

trunk/src/world_entities/world_entity.h

@@ -111 +111 @@
   std::vector<Model*>     models;             //!< The model that should be loaded for this entity.
   const char*             md2TextureFileName; //!< the file name of the md2 model texture, only if this
+  const char*             modelLODName;       //!< the name of the model lod file
   BVTree*                 obbTree;            //!< this is the obb tree reference needed for collision detection