Changeset 2759 for code/trunk/src/network/packet

Timestamp:

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

Author:

scheusso

Message:

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

Location:

code/trunk/src/network/packet

Files:

• ClassID.cc (modified) (5 diffs)
• ClassID.h (modified) (2 diffs)
• Gamestate.cc (modified) (10 diffs)
• Gamestate.h (modified) (1 diff)

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_)
 
 };