Changeset 2759 for code/trunk/src/network

Timestamp:

Mar 8, 2009, 4:51:27 PM (15 years ago)

Author:

scheusso

Message:

merged network branch (windows,multiplayer fixes) back to trunk

Location:

code/trunk/src/network

Files:

• ConnectionManager.cc (modified) (5 diffs)
• ConnectionManager.h (modified) (1 diff)
• packet/ClassID.cc (modified) (5 diffs)
• packet/ClassID.h (modified) (2 diffs)
• packet/Gamestate.cc (modified) (10 diffs)
• packet/Gamestate.h (modified) (1 diff)
• synchronisable/Synchronisable.cc (modified) (7 diffs)
• synchronisable/Synchronisable.h (modified) (2 diffs)

code/trunk/src/network/ConnectionManager.cc

@@ -46 +46 @@
 #include <boost/bind.hpp>
 
-#include "core/CoreIncludes.h"
-#include "core/BaseObject.h"
-#include "core/Iterator.h"
 #include "util/Math.h"
 #include "util/Sleep.h"
@@ -124 +121 @@
   void ConnectionManager::createListener() {
     receiverThread_ = new boost::thread(boost::bind(&ConnectionManager::receiverThread, this));
-    //network_threads.create_thread(boost::bind(boost::mem_fn(&ConnectionManager::receiverThread), this));
-         //boost::thread thr(boost::bind(boost::mem_fn(&ConnectionManager::receiverThread), this));
     return;
   }
@@ -131 +126 @@
   bool ConnectionManager::quitListener() {
     quit=true;
-    //network_threads.join_all();
     receiverThread_->join();
     return true;
@@ -206 +200 @@
         // log handling ================
         case ENET_EVENT_TYPE_CONNECT:
-          //COUT(3) << "adding event_type_connect to queue" << std::endl;
         case ENET_EVENT_TYPE_DISCONNECT:
-          //addClient(event);
-          //this is a workaround to ensure thread safety
-          //COUT(5) << "Con.Man: connection event has occured" << std::endl;
-          //break;
         case ENET_EVENT_TYPE_RECEIVE:
-          //std::cout << "received data" << std::endl;
-          //COUT(5) << "Con.Man: receive event has occured" << std::endl;
-          // only add, if client has connected yet and not been disconnected
-          //if(head_->findClient(&event->peer->address))
             processData(event);
             event = new ENetEvent;
-//           else
-//             COUT(3) << "received a packet from a client we don't know" << std::endl;
           break;
-        //case ENET_EVENT_TYPE_DISCONNECT:
-          //clientDisconnect(event->peer);
-          //break;
         case ENET_EVENT_TYPE_NONE:
           //receiverThread_->yield();
@@ -299 +279 @@
   }
 
-  /**
-   *
-   * @param clientID
-   */
+
   void ConnectionManager::syncClassid(unsigned int clientID) {
-    unsigned int network_id=0, failures=0;
-    std::string classname;
-    Identifier *id;
-    std::map<std::string, Identifier*>::const_iterator it = Factory::getFactoryMapBegin();
-    while(it != Factory::getFactoryMapEnd()){
-      id = (*it).second;
-      if(id == NULL)
-        continue;
-      classname = id->getName();
-      network_id = id->getNetworkID();
-      if(network_id==0)
-        COUT(3) << "we got a null class id: " << id->getName() << std::endl;
-      COUT(4) << "Con.Man:syncClassid:\tnetwork_id: " << network_id << ", classname: " << classname << std::endl;
-
-      packet::ClassID *classid = new packet::ClassID( network_id, classname );
-      classid->setClientID(clientID);
-      while(!classid->send() && failures < 10){
-        failures++;
-      }
-      ++it;
-    }
-    //sendPackets();
+    int failures=0;
+    packet::ClassID *classid = new packet::ClassID();
+    classid->setClientID(clientID);
+    while(!classid->send() && failures < 10){
+      failures++;
+    }
+    assert(failures<10);
     COUT(4) << "syncClassid:\tall synchClassID packets have been sent" << std::endl;
   }
-
+  
 
   void ConnectionManager::disconnectClient(ClientInformation *client){

code/trunk/src/network/ConnectionManager.h

@@ -80 +80 @@
     static boost::recursive_mutex enet_mutex;
     ConnectionManager();
-    //ConnectionManager(ClientInformation *head);
     ConnectionManager(int port);
     ConnectionManager(int port, const char *address);
     ConnectionManager(int port, const std::string& address);
     ~ConnectionManager();
-    //ENetPacket *getPacket(ENetAddress &address); // thread1
-    //ENetPacket *getPacket(int &clientID);
     ENetEvent *getEvent();
     bool queueEmpty();
     void createListener();
     bool quitListener();
-//     bool addPacket(Packet::Packet *packet);
     static bool addPacket(ENetPacket *packet, ENetPeer *peer);
     static bool addPacket(ENetPacket *packet, int ID);
     static bool addPacketAll(ENetPacket *packet);
-  //  bool sendPackets(ENetEvent *event);
     bool sendPackets();
-    //bool createClient(int clientID);
     void disconnectClient(ClientInformation *client);
     void syncClassid(unsigned int clientID);
 
   private:
-//     bool clientDisconnect(ENetPeer *peer);
-//     bool removeClient(int clientID);
     bool processData(ENetEvent *event);
-    //bool addClient(ENetEvent *event);
     void receiverThread();
     void disconnectClients();

code/trunk/src/network/packet/ClassID.cc

@@ -31 +31 @@
 #include "ClassID.h"
 #include "core/CoreIncludes.h"
+#include "core/Factory.h"
 #include <cstring>
+#include <string>
 #include <assert.h>
+#include <map>
+#include <queue>
 
 namespace orxonox {
@@ -38 +42 @@
 
 
+#define PACKET_FLAGS_CLASSID  ENET_PACKET_FLAG_RELIABLE
+#define _PACKETID             0
 
-  ClassID::ClassID( unsigned int classID, std::string className )
- : Packet()
-{
+
+ClassID::ClassID( ) : Packet(){
+  Identifier *id;
+  std::string classname;
+  unsigned int nrOfClasses=0; 
+  unsigned int packetSize=2*sizeof(uint32_t); //space for the packetID and for the nrofclasses
+  uint32_t network_id;
   flags_ = flags_ | PACKET_FLAGS_CLASSID;
-  classNameLength_=className.length()+1;
-  assert(getSize());
-  data_=new unsigned char[ getSize() ];
-  assert(data_);
-  *(ENUM::Type *)(data_ + _PACKETID ) = ENUM::ClassID;
-  *(unsigned int *)(data_ + _CLASSID ) = classID;
-  *(unsigned int *)(data_ + _CLASSNAMELENGTH ) = classNameLength_;
-  memcpy( data_+_CLASSNAME, (void *)className.c_str(), classNameLength_ );
+  std::queue<std::pair<uint32_t, std::string> > tempQueue;
+  
+  //calculate total needed size (for all strings and integers)
+  std::map<std::string, Identifier*>::const_iterator it = Factory::getFactoryMapBegin();
+  for(;it != Factory::getFactoryMapEnd();++it){
+    id = (*it).second;
+    if(id == NULL)
+      continue;
+    classname = id->getName();
+    network_id = id->getNetworkID();
+    if(network_id==0)
+      COUT(3) << "we got a null class id: " << id->getName() << std::endl;
+    // now push the network id and the classname to the stack
+    tempQueue.push( std::pair<unsigned int, std::string>(network_id, classname) );
+    ++nrOfClasses;
+    packetSize += (classname.size()+1)+sizeof(uint32_t)+sizeof(uint32_t);
+  }
+  
+  this->data_=new uint8_t[ packetSize ];
+  //set the appropriate packet id
+  assert(this->data_);
+  *(ENUM::Type *)(this->data_ + _PACKETID ) = ENUM::ClassID;
+  
+  uint8_t *temp=data_+sizeof(uint32_t);
+  // save the number of all classes
+  *(uint32_t*)temp = nrOfClasses;
+  temp += sizeof(uint32_t);
+  
+  // now save all classids and classnames
+  std::pair<uint32_t, std::string> tempPair;
+  while( !tempQueue.empty() ){
+    tempPair = tempQueue.front();
+    tempQueue.pop();
+    *(uint32_t*)temp = tempPair.first;
+    *(uint32_t*)(temp+sizeof(uint32_t)) = tempPair.second.size()+1;
+    memcpy(temp+2*sizeof(uint32_t), tempPair.second.c_str(), tempPair.second.size()+1);
+    temp+=2*sizeof(uint32_t)+tempPair.second.size()+1;
+  }
+  
+  COUT(0) << "classid packetSize is " << packetSize << endl;
+  
 }
 
@@ -56 +99 @@
   : Packet(data, clientID)
 {
-  memcpy( (void *)&classNameLength_, &data[ _CLASSNAMELENGTH ], sizeof(classNameLength_) );
 }
 
@@ -63 +105 @@
 }
 
-unsigned int ClassID::getSize() const{
-  return sizeof(packet::ENUM::Type) + 2*sizeof(uint32_t) + classNameLength_;
+uint32_t ClassID::getSize() const{
+  uint8_t *temp = data_+sizeof(uint32_t); // packet identification
+  uint32_t totalsize = sizeof(uint32_t); // packet identification
+  uint32_t nrOfClasses = *(uint32_t*)temp;
+  temp += sizeof(uint32_t);
+  totalsize += sizeof(uint32_t); // storage size for nr of all classes
+  
+  for(unsigned int i=0; i<nrOfClasses; i++){
+    totalsize += 2*sizeof(uint32_t) + *(uint32_t*)(temp + sizeof(uint32_t));
+  }
+  return totalsize;
 }
 
+
 bool ClassID::process(){
-  COUT(3) << "processing classid: " << getClassID() << " name: " << getClassName() << std::endl;
-  Identifier *id=ClassByString( std::string(getClassName()) );
-  if(id==NULL)
-    return false;
-  id->setNetworkID( getClassID() );
+  int nrOfClasses;
+  uint8_t *temp = data_+sizeof(uint32_t); //skip the packetid
+  uint32_t networkID;
+  uint32_t stringsize;
+  unsigned char *classname;
+  
+  
+  //clean the map of network ids
+  Factory::cleanNetworkIDs();
+  
+  COUT(4) << "=== processing classids: " << endl;
+  std::pair<uint32_t, std::string> tempPair;
+  Identifier *id;
+  // read the total number of classes
+  nrOfClasses = *(uint32_t*)temp;
+  temp += sizeof(uint32_t);
+  
+  for( int i=0; i<nrOfClasses; i++){
+    networkID = *(uint32_t*)temp;
+    stringsize = *(uint32_t*)(temp+sizeof(uint32_t));
+    classname = temp+2*sizeof(uint32_t);
+    id=ClassByString( std::string((const char*)classname) );
+    COUT(0) << "processing classid: " << networkID << " name: " << classname << " id: " << id << std::endl;
+    if(id==NULL){
+      COUT(0) << "Recieved a bad classname" << endl;
+      abort();
+    }
+    id->setNetworkID( networkID );
+    temp += 2*sizeof(uint32_t) + stringsize;
+  }
   delete this;
   return true;
@@ -78 +155 @@
 
 
-unsigned int ClassID::getClassID(){
-  return *(uint32_t *)(data_ + _CLASSID);
-}
-
 } //namespace packet
 }//namespace orxonox

code/trunk/src/network/packet/ClassID.h

@@ -38 +38 @@
 namespace packet {
 
-#define PACKET_FLAGS_CLASSID  ENET_PACKET_FLAG_RELIABLE
-#define _PACKETID             0
-#define _CLASSID              _PACKETID + sizeof(ENUM::Type)
-#define _CLASSNAMELENGTH      _CLASSID + sizeof(uint32_t)
-#define _CLASSNAME            _CLASSNAMELENGTH + sizeof(classNameLength_)
   
 /**
@@ -50 +45 @@
 {
 public:
-  ClassID( unsigned int classID, std::string className );
+  ClassID( );
   ClassID( uint8_t* data, unsigned int clientID );
   ~ClassID();
 
-  inline unsigned int getSize() const;
+  uint32_t getSize() const;
   bool process();
 
-  unsigned int getClassID();
-  unsigned int getClassNameLength(){ return classNameLength_; }
-  const char *getClassName(){ return (const char*)(data_+_CLASSNAME); }
 private:
-  uint32_t classNameLength_;
 };
 

code/trunk/src/network/packet/Gamestate.cc

@@ -48 +48 @@
 #define PACKET_FLAG_GAMESTATE  ENET_PACKET_FLAG_RELIABLE
 
-// Gamestate::Gamestate()
-// {
-//   flags_ = flags_ | PACKET_FLAG_GAMESTATE;
-// }
 
 Gamestate::Gamestate()
@@ -127 +123 @@
 #endif
 
-    //if(it->doSelection(id))
     if ( it->doSync( id, mode ) )
       dataMap_.push_back( obj(it->getObjectID(), it->getCreatorID(), tempsize, mem-data_) );
-//     dataMap_[mem-data_]=(*it);  // save the mem location of the synchronisable data
     if(!it->getData(mem, id, mode))
       return false; // mem pointer gets automatically increased because of call by reference
@@ -158 +152 @@
   assert(!header_->isDiffed());
   uint8_t *mem=data_+GamestateHeader::getSize();
-    // get the start of the Synchronisable list
-  //ObjectList<Synchronisable>::iterator it=ObjectList<Synchronisable>::begin();
   Synchronisable *s;
 
@@ -177 +169 @@
         mem += objectheader.getDataSize();
       }
-//         COUT(0) << "could not fabricate synchronisable: " << objectheader->objectID << " classid: " << objectheader->classID << " creator: " << objectheader->creatorID << endl;
-//       else
-//         COUT(0) << "fabricated: " << objectheader->objectID << " classid: " << objectheader->classID << " creator: "  << objectheader->creatorID << endl;
     }
     else
     {
       bool b = s->updateData(mem, mode);
-//      if(!b)
-//        COUT(0) << "data could not be updated" << endl;
       assert(b);
     }
@@ -262 +249 @@
   uint8_t *ndata = new uint8_t[buffer+GamestateHeader::getSize()];
   uint8_t *dest = ndata + GamestateHeader::getSize();
-  //unsigned char *dest = new unsigned char[buffer];
   uint8_t *source = data_ + GamestateHeader::getSize();
   int retval;
@@ -294 +280 @@
   uint32_t compsize = header_->getCompSize();
   uint32_t bufsize;
-//  assert(compsize<=datasize);
   bufsize = datasize;
   assert(bufsize!=0);
@@ -340 +325 @@
   assert(!header_->isDiffed());
   GamestateHeader diffHeader(base->data_);
-  //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
   uint8_t *basep = GAMESTATE_START(base->data_), *gs = GAMESTATE_START(this->data_);
   uint32_t of=0; // pointers offset
@@ -397 +381 @@
   //copy in the zeros
   for(it=dataMap_.begin(); it!=dataMap_.end();){
-//    if((*it).objSize==0)
-//      continue;
-//    if(it->second->getSize(HEADER->id)==0) // merged from objecthierarchy2, doesn't work anymore; TODO: change this
-//      continue;                            // merged from objecthierarchy2, doesn't work anymore; TODO: change this
     SynchronisableHeader oldobjectheader(origdata);
     SynchronisableHeader newobjectheader(newdata);
@@ -408 +388 @@
       continue;
     }
-//     object = Synchronisable::getSynchronisable( (*it).objID );
-//     assert(object->objectID == oldobjectheader->objectID);
     objectsize = oldobjectheader.getDataSize();
     objectOffset=SynchronisableHeader::getSize(); //skip the size and the availableData variables in the objectheader
@@ -447 +425 @@
   assert(header_->isDiffed());
   assert(!header_->isCompressed() && !base->header_->isCompressed());
-  //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
   uint8_t *basep = GAMESTATE_START(base->data_);
   uint8_t *gs = GAMESTATE_START(this->data_);

code/trunk/src/network/packet/Gamestate.h

@@ -93 +93 @@
   private:
     uint8_t *data_;
-//#define GAMESTATE_START(data) (data + sizeof(GamestateHeader))
-//#define GAMESTATE_HEADER(data) ((GamestateHeader *)data)
-//#define HEADER GAMESTATE_HEADER(data_)
 
 };

code/trunk/src/network/synchronisable/Synchronisable.cc

@@ -100 +100 @@
       if (this->objectMode_ != 0x0 && (Host::running() && Host::isServer()))
         deletedObjects_.push(objectID);
-//       COUT(3) << "destruct synchronisable +++" << objectID << " | " << classID << std::endl;
-//       COUT(3) << " bump ---" << objectID << " | " << &objectMap_ << std::endl;
-//       assert(objectMap_[objectID]->objectID==objectID);
-//       objectMap_.erase(objectID);
     }
     std::map<uint32_t, Synchronisable*>::iterator it;
@@ -110 +106 @@
       objectMap_.erase(it);
 
-    //HACK HACK HACK HACK HACK HACK
-    // this hack ensures that children of this object also get destroyed
-//     ObjectList<Synchronisable>::iterator it2, it3;
-//     // get total size of gamestate
-//     for(it2 = ObjectList<Synchronisable>::begin(); it2; ++it2)
-//     {
-//       if ( it2->getCreatorID() == this->objectID && it2->getCreatorID() != OBJECTID_UNKNOWN )
-//       {
-//         Synchronisable::deleteObject( it2->getObjectID() );
-//       }
-//     }
-    //HACK HACK HACK HACK HACK HACK
   }
 
@@ -158 +142 @@
     if (!id)
     {
+        for(int i = 0; i<100; i++)
+            COUT(0) << "classid: " << i << " identifier: " << ClassByID(i) << endl;
         COUT(0) << "Assertion failed: id" << std::endl;
         COUT(0) << "Possible reason for this error: Client received a synchronizable object whose class has no factory." << std::endl;
@@ -203 +189 @@
    */
   bool Synchronisable::deleteObject(uint32_t objectID){
-//     assert(getSynchronisable(objectID));
     if(!getSynchronisable(objectID))
       return false;
     assert(getSynchronisable(objectID)->objectID==objectID);
-//     delete objectMap_[objectID];
     Synchronisable *s = getSynchronisable(objectID);
     if(s)
@@ -258 +242 @@
     if(!doSync(id, mode))
       return true;
-    //std::cout << "inside getData" << std::endl;
     uint32_t tempsize = 0;
     if (this->classID==0)
@@ -267 +250 @@
 
     assert(this->classID==this->getIdentifier()->getNetworkID());
-//     this->classID=this->getIdentifier()->getNetworkID(); // TODO: correct this
     std::list<SynchronisableVariableBase*>::iterator i;
     uint32_t size;
@@ -305 +287 @@
       mode=state_;
     std::list<SynchronisableVariableBase *>::iterator i;
-    //assert(objectMode_!=0x0);
-    //assert( (mode ^ objectMode_) != 0);
     if(syncList.empty()){
       assert(0);

code/trunk/src/network/synchronisable/Synchronisable.h

@@ -142 +142 @@
   protected:
     Synchronisable(BaseObject* creator);
-//     void registerVariable(void *var, int size, variableType t, uint8_t mode=0x1, NetworkCallbackBase *cb=0);
     template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
     template <class T> void unregisterVariable(T& var);
@@ -205 +204 @@
   template <> _NetworkExport void Synchronisable::registerVariable( const Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
   template <> _NetworkExport void Synchronisable::registerVariable( Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
-//   template <> _NetworkExport void Synchronisable::registerVariable( LODParticle::LOD& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
-//   template <> _NetworkExport void Synchronisable::registerVariable( Ogre::Light::LightTypes& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
 }