Changeset 7759 for code/branches/network5/src/libraries/network/packet

Timestamp:

Dec 14, 2010, 8:54:00 PM (14 years ago)

Author:

scheusso

Message:

a lot of changes:

• some fixes (mostly gamestate:diff)
• FunctionCall buffering (if Gamestate is not recent enough)

Location:

code/branches/network5/src/libraries/network/packet

Files:

• FunctionCalls.cc (modified) (4 diffs)
• FunctionCalls.h (modified) (1 diff)
• Gamestate.cc (modified) (10 diffs)
• Packet.cc (modified) (3 diffs)

code/branches/network5/src/libraries/network/packet/FunctionCalls.cc

@@ -32 +32 @@
 #include "network/FunctionCall.h"
 #include "network/FunctionCallManager.h"
+#include "network/GamestateHandler.h"
 
 namespace orxonox {
@@ -40 +41 @@
 const unsigned int FUNCTIONCALLS_MEM_ALLOCATION = 1000;
 
-FunctionCalls::FunctionCalls()
- : Packet()
+FunctionCalls::FunctionCalls():
+  Packet(), minGamestateID_(GAMESTATEID_INITIAL)
 {
   flags_ = flags_ | PACKET_FLAGS_FUNCTIONCALLS;
-  currentSize_ = 2*sizeof(uint32_t); // for packetid and nrOfCalls
+  currentSize_ = 3*sizeof(uint32_t); // for packetid, nrOfCalls and minGamestateID_
 }
 
-FunctionCalls::FunctionCalls( uint8_t* data, unsigned int clientID )
-  : Packet(data, clientID)
+FunctionCalls::FunctionCalls( uint8_t* data, unsigned int clientID ): 
+  Packet(data, clientID), minGamestateID_(GAMESTATEID_INITIAL)
 {
 }
@@ -63 +64 @@
   uint32_t nrOfCalls = *(uint32_t*)temp;
   temp += sizeof(uint32_t);
+  this->minGamestateID_ = *(uint32_t*)temp;
+  temp += sizeof(uint32_t);
   for( unsigned int i = 0; i<nrOfCalls; i++ )
   {
     FunctionCall fctCall;
     fctCall.loadData(temp);
-    if( !fctCall.execute() )
-      FunctionCallManager::bufferIncomingFunctionCall( fctCall );
+    if( this->minGamestateID_ > GamestateHandler::getInstance()->getLastProcessedGamestateID(this->getClientID()) || !fctCall.execute() )
+    {
+      FunctionCallManager::bufferIncomingFunctionCall( fctCall, minGamestateID_, this->getClientID() );
+    }
   }
   
@@ -93 +98 @@
 bool FunctionCalls::send()
 {
+  this->minGamestateID_ = GamestateHandler::getInstance()->getCurrentGamestateID();
   assert(this->functionCalls_.size());
   data_=new uint8_t[ currentSize_ ];
   *(Type::Value *)(data_ + _PACKETID ) = Type::FunctionCalls; // Set the Packet ID
-  *(uint32_t*)(data_+sizeof(uint32_t)) = this->functionCalls_.size(); // set nrOfCalls to 0
-  uint8_t* temp = data_+2*sizeof(uint32_t);
+  *(uint32_t*)(data_+sizeof(uint32_t)) = this->functionCalls_.size(); // set nrOfCalls
+  *(uint32_t*)(data_+2*sizeof(uint32_t)) = this->minGamestateID_; // set minGamestateID_
+  uint8_t* temp = data_+3*sizeof(uint32_t);
   
   while( this->functionCalls_.size() )

code/branches/network5/src/libraries/network/packet/FunctionCalls.h

@@ -62 +62 @@
   std::queue<orxonox::FunctionCall> functionCalls_;
   unsigned int                      clientID_;
+  uint32_t                          minGamestateID_;
   uint32_t                          currentSize_;
 };

code/branches/network5/src/libraries/network/packet/Gamestate.cc

@@ -43 +43 @@
 #define GAMESTATE_START(data) (data + GamestateHeader::getSize())
 
-#define PACKET_FLAG_GAMESTATE  0 //PacketFlag::Reliable
+// #define PACKET_FLAG_GAMESTATE  PacketFlag::Unsequenced
+// #define PACKET_FLAG_GAMESTATE  0
+#define PACKET_FLAG_GAMESTATE  PacketFlag::Reliable
 
 inline bool memzero( uint8_t* data, uint32_t datalength)
@@ -364 +366 @@
 inline void /*Gamestate::*/diffObject( uint8_t*& newDataPtr, uint8_t*& origDataPtr, uint8_t*& baseDataPtr, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes )
 {
-  //       COUT(4) << "dodiff" << endl;
-  //       if(baseOffset==0)
-  //       {
-  //         assert(origOffset==0);
-  //       }
   assert( objectHeader.getDataSize() == SynchronisableHeader(baseDataPtr).getDataSize() );
   
@@ -382 +379 @@
   else
   {
-    //         if( Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() == "Bot" )
-    //           COUT(0) << "blub" << endl;
-    //         COUT(4) << "object diff: " << Synchronisable::getSynchronisable(h.getObjectID())->getIdentifier()->getName() << endl;
-    //         COUT(4) << "diff " << h.getObjectID() << ":";
     // Now start to diff the Object
     SynchronisableHeaderLight newObjectHeader(newDataPtr);
@@ -396 +389 @@
       // check whether variable changed and write id and copy over variable to the new stream
       // otherwise skip variable
-//       assert(sizes != this->sizes_.end());
       uint32_t varSize = *sizes;
       assert( varSize == Synchronisable::getSynchronisable(objectHeader.getObjectID())->getVarSize(variableID) );
@@ -403 +395 @@
         if ( memcmp(origDataPtr+objectOffset, baseDataPtr+objectOffset, varSize) != 0 )
         {
-          //               COUT(4) << "copy variable" << endl;
           *(VariableID*)(newDataPtr+diffedObjectOffset) = variableID; // copy over the variableID
           diffedObjectOffset += sizeof(VariableID);
@@ -412 +403 @@
         else
         {
-          //               COUT(4) << "skip variable" << endl;
           objectOffset += varSize;
         }
       }
-//           else
-//             COUT(4) << "varsize 0" << endl;
 
       ++variableID;
       ++sizes;
     }
-            
+    
+    // if there are variables from this object with 0 size left in sizes
     if( Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables() != variableID )
       sizes += Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables() - variableID;
-    //         COUT(4) << endl;
     
     newObjectHeader.setDiffed(true);
@@ -431 +419 @@
     assert(objectOffset == objectHeader.getDataSize()+SynchronisableHeader::getSize());
     assert(newObjectHeader.getDataSize()>0);
+    
     origDataPtr += objectOffset;
-    //         baseOffset += temp + h.getDataSize()+SynchronisableHeader::getSize() - baseData;
-    //baseOffset += objectOffset;
-    //         SynchronisableHeader htemp(temp);
-    //         baseOffset += SynchronisableHeader::getSize() + htemp.getDataSize();
-    //         {
-      //           SynchronisableHeader htemp2( baseData+(temp-baseData+objectOffset) );
-    //           if( baseData+(temp-baseData+objectOffset) < baseData+baseLength )
-    //           {
-      //             assert(htemp2.getClassID()<500);
-    //             assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
-    //             assert(htemp2.isDiffed()==false);
-    //           }
-    //         }
     baseDataPtr += objectOffset;
     newDataPtr += diffedObjectOffset;
@@ -455 +431 @@
   // Just copy over the whole Object
   memcpy( newData, origData, objectHeader.getDataSize()+SynchronisableHeader::getSize() );
+  SynchronisableHeader(newData).setDiffed(false);
+  
   newData += objectHeader.getDataSize()+SynchronisableHeader::getSize();
   origData += objectHeader.getDataSize()+SynchronisableHeader::getSize();
@@ -547 +525 @@
     assert(sizesIt != this->sizes_.end());
     
+    assert(Synchronisable::getSynchronisable(origHeader.getObjectID()));
+    assert(ClassByID(origHeader.getClassID()));
+    assert(origHeader.getDataSize() < 500);
+    
     bool diffedObject = false;
     if( findObject(baseDataPtr, baseDataEnd, origHeader) )
     {
+      SynchronisableHeader baseHeader(baseDataPtr);
+      assert(Synchronisable::getSynchronisable(baseHeader.getObjectID()));
+      assert(ClassByID(baseHeader.getClassID()));
+      assert(baseHeader.getDataSize() < 500);
       if( SynchronisableHeader(baseDataPtr).getDataSize()==origHeader.getDataSize() )
       {
@@ -570 +556 @@
       if( findObject(baseDataPtr, oldBaseDataPtr, origHeader) )
       {
+        SynchronisableHeader baseHeader(baseDataPtr);
+        assert(Synchronisable::getSynchronisable(baseHeader.getObjectID()));
+        assert(ClassByID(baseHeader.getClassID()));
+        assert(baseHeader.getDataSize() < 500);
         if( SynchronisableHeader(baseDataPtr).getDataSize()==origHeader.getDataSize() )
         {

code/branches/network5/src/libraries/network/packet/Packet.cc

@@ -53 +53 @@
 
 // Make sure we assume the right values
-BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Reliable)   == static_cast<int>(ENET_PACKET_FLAG_RELIABLE));
-BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Unsequence) == static_cast<int>(ENET_PACKET_FLAG_UNSEQUENCED));
-BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::NoAllocate) == static_cast<int>(ENET_PACKET_FLAG_NO_ALLOCATE));
+BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Reliable)    == static_cast<int>(ENET_PACKET_FLAG_RELIABLE));
+BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Unsequenced) == static_cast<int>(ENET_PACKET_FLAG_UNSEQUENCED));
+BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::NoAllocate)  == static_cast<int>(ENET_PACKET_FLAG_NO_ALLOCATE));
 
 #define PACKET_FLAG_DEFAULT PacketFlag::NoAllocate
@@ -174 +174 @@
   unsigned int clientID = ClientInformation::findClient(&peer->address)->getID();
   Packet *p = 0;
-  COUT(6) << "packet type: " << *(Type::Value *)&data[_PACKETID] << std::endl;
+//   COUT(6) << "packet type: " << *(Type::Value *)&data[_PACKETID] << std::endl;
   switch( *(Type::Value *)(data + _PACKETID) )
   {
     case Type::Acknowledgement:
-      COUT(5) << "ack" << std::endl;
+//       COUT(5) << "ack" << std::endl;
       p = new Acknowledgement( data, clientID );
       break;
     case Type::Chat:
-      COUT(5) << "chat" << std::endl;
+//       COUT(5) << "chat" << std::endl;
       p = new Chat( data, clientID );
       break;
     case Type::ClassID:
-      COUT(5) << "classid" << std::endl;
+//       COUT(5) << "classid" << std::endl;
       p = new ClassID( data, clientID );
       break;
     case Type::Gamestate:
-      COUT(5) << "gamestate" << std::endl;
-      // TODO: remove brackets
+//       COUT(5) << "gamestate" << std::endl;
       p = new Gamestate( data, clientID );
       break;
     case Type::Welcome:
-      COUT(5) << "welcome" << std::endl;
+//       COUT(5) << "welcome" << std::endl;
       p = new Welcome( data, clientID );
       break;
     case Type::DeleteObjects:
-      COUT(5) << "deleteobjects" << std::endl;
+//       COUT(5) << "deleteobjects" << std::endl;
       p = new DeleteObjects( data, clientID );
       break;
     case Type::FunctionCalls:
-      COUT(5) << "functionCalls" << std::endl;
+//       COUT(5) << "functionCalls" << std::endl;
       p = new FunctionCalls( data, clientID );
       break;
     case Type::FunctionIDs:
-      COUT(5) << "functionIDs" << std::endl;
+//       COUT(5) << "functionIDs" << std::endl;
       p = new FunctionIDs( data, clientID );
       break;
     default:
-      assert(0); //TODO: repair this
+      assert(0);
       break;
   }
@@ -235 +234 @@
   delete it->second;
   packetMap_.erase(it);
-  COUT(6) << "PacketMap size: " << packetMap_.size() << std::endl;
+//   COUT(6) << "PacketMap size: " << packetMap_.size() << std::endl;
 }