[Orxonox-commit 3063] r7758 - in code/branches/network5: . src/libraries/network src/libraries/network/packet src/libraries/network/synchronisable src/modules/weapons src/orxonox/gametypes
scheusso at orxonox.net
scheusso at orxonox.net
Sun Dec 12 23:13:01 CET 2010
Author: scheusso
Date: 2010-12-12 23:13:01 +0100 (Sun, 12 Dec 2010)
New Revision: 7758
Modified:
code/branches/network5/
code/branches/network5/src/libraries/network/GamestateManager.cc
code/branches/network5/src/libraries/network/packet/Gamestate.cc
code/branches/network5/src/libraries/network/packet/Gamestate.h
code/branches/network5/src/libraries/network/synchronisable/Synchronisable.cc
code/branches/network5/src/modules/weapons/MuzzleFlash.cc
code/branches/network5/src/orxonox/gametypes/Gametype.cc
code/branches/network5/src/orxonox/gametypes/Gametype.h
Log:
merging network4 into network5 branch
Property changes on: code/branches/network5
___________________________________________________________________
Modified: svn:mergeinfo
- /code/branches/ai:6592-7033
/code/branches/buildsystem:1874-2276,2278-2400
/code/branches/buildsystem2:2506-2658
/code/branches/buildsystem3:2662-2708
/code/branches/ceguilua:1802-1808
/code/branches/chat:6527-6797
/code/branches/chat2:6836-6910
/code/branches/console:5941-6104
/code/branches/consolecommands2:6451-7178
/code/branches/consolecommands3:7178-7283
/code/branches/core3:1572-1739
/code/branches/core4:3221-3224,3227,3234-3238,3242,3244-3250,3252-3254,3256,3259-3261,3264-3265,3268-3275,3277-3278,3280,3284-3285,3287,3289-3294,3305,3309-3310
/code/branches/core5:5768-5928,6009
/code/branches/data_cleanup:7537-7686
/code/branches/doc:7290-7400
/code/branches/dynamicmatch:6584-7030
/code/branches/fps:6591-7072
/code/branches/gamestate:6430-6572,6621-6661
/code/branches/gamestates2:6594-6745
/code/branches/gametypes:2826-3031
/code/branches/gcc43:1580
/code/branches/gui:1635-1723,2795-2894
/code/branches/hudelements:6584-6941
/code/branches/ingamemenu:6000-6023
/code/branches/input:1629-1636
/code/branches/ipv6:7293-7458
/code/branches/lastmanstanding:7479-7644
/code/branches/libraries:5612-5692
/code/branches/libraries2:5703-5737
/code/branches/lod:6586-6911
/code/branches/lodfinal:2372-2411
/code/branches/map:2801-3086,3089
/code/branches/masterserver:7502-7738
/code/branches/menu:5941-6146,6148,7536-7687
/code/branches/miniprojects:2754-2824
/code/branches/netp2:2835-2988
/code/branches/netp3:2988-3082
/code/branches/netp6:3214-3302
/code/branches/network:2356
/code/branches/network2:6434-6465
/code/branches/network64:2210-2355
/code/branches/notifications:7314-7401
/code/branches/objecthierarchy:1911-2085,2100,2110-2169
/code/branches/objecthierarchy2:2171-2479
/code/branches/overlay:2117-2385
/code/branches/particles:2829-3085
/code/branches/particles2:6050-6106,6109
/code/branches/pch:3113-3194
/code/branches/physics:1912-2055,2107-2439
/code/branches/physics_merge:2436-2457
/code/branches/pickup2:5942-6405
/code/branches/pickup3:6418-6523
/code/branches/pickup4:6594-6710
/code/branches/pickups:1926-2086,2127,2827-2915
/code/branches/pickups2:2107-2497,2915-3071
/code/branches/png2:7262-7263
/code/branches/ppspickups1:6552-6708
/code/branches/ppspickups2:6527-6532,6554-6709
/code/branches/ppspickups3:6757-6997
/code/branches/ppspickups4:7003-7089
/code/branches/presentation:2369-2652,2654-2660
/code/branches/presentation2:6106-6416
/code/branches/presentation3:6913-7162
/code/branches/questsystem:1894-2088
/code/branches/questsystem2:2107-2259
/code/branches/questsystem5:2776-2905
/code/branches/releasetodo:7614-7647
/code/branches/resource:3327-3366
/code/branches/resource2:3372-5694
/code/branches/rocket:6523-6950
/code/branches/rocket2:6953-6970
/code/branches/script_trigger:1295-1953,1955
/code/branches/skybox2:6559-6989
/code/branches/sound:2829-3010
/code/branches/sound3:5941-6102
/code/branches/steering:5949-6091
/code/branches/weapon:1925-2094
/code/branches/weapon2:2107-2488
/code/branches/weapons:2897-3051
/code/branches/weaponsystem:2742-2890
+ /code/branches/ai:6592-7033
/code/branches/buildsystem:1874-2276,2278-2400
/code/branches/buildsystem2:2506-2658
/code/branches/buildsystem3:2662-2708
/code/branches/ceguilua:1802-1808
/code/branches/chat:6527-6797
/code/branches/chat2:6836-6910
/code/branches/console:5941-6104
/code/branches/consolecommands2:6451-7178
/code/branches/consolecommands3:7178-7283
/code/branches/core3:1572-1739
/code/branches/core4:3221-3224,3227,3234-3238,3242,3244-3250,3252-3254,3256,3259-3261,3264-3265,3268-3275,3277-3278,3280,3284-3285,3287,3289-3294,3305,3309-3310
/code/branches/core5:5768-5928,6009
/code/branches/data_cleanup:7537-7686
/code/branches/doc:7290-7400
/code/branches/dynamicmatch:6584-7030
/code/branches/fps:6591-7072
/code/branches/gamestate:6430-6572,6621-6661
/code/branches/gamestates2:6594-6745
/code/branches/gametypes:2826-3031
/code/branches/gcc43:1580
/code/branches/gui:1635-1723,2795-2894
/code/branches/hudelements:6584-6941
/code/branches/ingamemenu:6000-6023
/code/branches/input:1629-1636
/code/branches/ipv6:7293-7458
/code/branches/lastmanstanding:7479-7644
/code/branches/libraries:5612-5692
/code/branches/libraries2:5703-5737
/code/branches/lod:6586-6911
/code/branches/lodfinal:2372-2411
/code/branches/map:2801-3086,3089
/code/branches/masterserver:7502-7738
/code/branches/menu:5941-6146,6148,7536-7687
/code/branches/miniprojects:2754-2824
/code/branches/netp2:2835-2988
/code/branches/netp3:2988-3082
/code/branches/netp6:3214-3302
/code/branches/network:2356
/code/branches/network2:6434-6465
/code/branches/network3:7196-7344
/code/branches/network4:7497-7755
/code/branches/network64:2210-2355
/code/branches/notifications:7314-7401
/code/branches/objecthierarchy:1911-2085,2100,2110-2169
/code/branches/objecthierarchy2:2171-2479
/code/branches/overlay:2117-2385
/code/branches/particles:2829-3085
/code/branches/particles2:6050-6106,6109
/code/branches/pch:3113-3194
/code/branches/physics:1912-2055,2107-2439
/code/branches/physics_merge:2436-2457
/code/branches/pickup2:5942-6405
/code/branches/pickup3:6418-6523
/code/branches/pickup4:6594-6710
/code/branches/pickups:1926-2086,2127,2827-2915
/code/branches/pickups2:2107-2497,2915-3071
/code/branches/png2:7262-7263
/code/branches/ppspickups1:6552-6708
/code/branches/ppspickups2:6527-6532,6554-6709
/code/branches/ppspickups3:6757-6997
/code/branches/ppspickups4:7003-7089
/code/branches/presentation:2369-2652,2654-2660
/code/branches/presentation2:6106-6416
/code/branches/presentation3:6913-7162
/code/branches/questsystem:1894-2088
/code/branches/questsystem2:2107-2259
/code/branches/questsystem5:2776-2905
/code/branches/releasetodo:7614-7647
/code/branches/resource:3327-3366
/code/branches/resource2:3372-5694
/code/branches/rocket:6523-6950
/code/branches/rocket2:6953-6970
/code/branches/script_trigger:1295-1953,1955
/code/branches/skybox2:6559-6989
/code/branches/sound:2829-3010
/code/branches/sound3:5941-6102
/code/branches/steering:5949-6091
/code/branches/weapon:1925-2094
/code/branches/weapon2:2107-2488
/code/branches/weapons:2897-3051
/code/branches/weaponsystem:2742-2890
Modified: code/branches/network5/src/libraries/network/GamestateManager.cc
===================================================================
--- code/branches/network5/src/libraries/network/GamestateManager.cc 2010-12-12 21:50:14 UTC (rev 7757)
+++ code/branches/network5/src/libraries/network/GamestateManager.cc 2010-12-12 22:13:01 UTC (rev 7758)
@@ -218,7 +218,7 @@
bool b = gs->compressData();
assert(b);
clock.capture();
- COUT(0) << "diff time: " << clock.getDeltaTime() << endl;
+ COUT(4) << "diff and compress time: " << clock.getDeltaTime() << endl;
// COUT(5) << "sending gamestate with id " << gs->getID();
// if(gamestate->isDiffed())
// COUT(5) << " and baseid " << gs->getBaseID() << endl;
Modified: code/branches/network5/src/libraries/network/packet/Gamestate.cc
===================================================================
--- code/branches/network5/src/libraries/network/packet/Gamestate.cc 2010-12-12 21:50:14 UTC (rev 7757)
+++ code/branches/network5/src/libraries/network/packet/Gamestate.cc 2010-12-12 22:13:01 UTC (rev 7758)
@@ -42,7 +42,7 @@
#define GAMESTATE_START(data) (data + GamestateHeader::getSize())
-#define PACKET_FLAG_GAMESTATE PacketFlag::Reliable
+#define PACKET_FLAG_GAMESTATE 0 //PacketFlag::Reliable
inline bool memzero( uint8_t* data, uint32_t datalength)
{
@@ -64,47 +64,42 @@
Gamestate::Gamestate():
- header_(0)
+ header_()
{
flags_ = flags_ | PACKET_FLAG_GAMESTATE;
}
Gamestate::Gamestate(uint8_t *data, unsigned int clientID):
- Packet(data, clientID)
+ Packet(data, clientID), header_(data)
{
flags_ = flags_ | PACKET_FLAG_GAMESTATE;
- header_ = new GamestateHeader(data_);
}
-Gamestate::Gamestate(uint8_t *data)
+Gamestate::Gamestate(uint8_t *data):
+ header_(data)
{
flags_ = flags_ | PACKET_FLAG_GAMESTATE;
data_ = data;
- header_ = new GamestateHeader(data_);
}
Gamestate::Gamestate(const Gamestate& g) :
- Packet( *(Packet*)&g ), nrOfVariables_(0)
+ Packet( *(Packet*)&g ), header_(this->data_), nrOfVariables_(0)
{
flags_ = flags_ | PACKET_FLAG_GAMESTATE;
- header_ = new GamestateHeader(data_);
sizes_ = g.sizes_;
}
Gamestate::~Gamestate()
{
- if( header_ )
- delete header_;
}
bool Gamestate::collectData(int id, uint8_t mode)
{
- assert(this->header_==0); // make sure the header didn't exist before
uint32_t tempsize=0, currentsize=0;
assert(data_==0);
uint32_t size = calcGamestateSize(id, mode);
@@ -119,9 +114,8 @@
return false;
}
- // create the header object
- assert( header_ == 0 );
- header_ = new GamestateHeader(data_);
+ // tell the gamestate header where to store the data
+ header_.setData(this->data_);
//start collect data synchronisable by synchronisable
uint8_t *mem = data_; // in this stream store all data of the variables and the headers of the synchronisable
@@ -160,12 +154,12 @@
//start write gamestate header
- header_->setDataSize( currentsize );
- header_->setID( id );
- header_->setBaseID( GAMESTATEID_INITIAL );
- header_->setDiffed( false );
- header_->setComplete( true );
- header_->setCompressed( false );
+ header_.setDataSize( currentsize );
+ header_.setID( id );
+ header_.setBaseID( GAMESTATEID_INITIAL );
+ header_.setDiffed( false );
+ header_.setComplete( true );
+ header_.setCompressed( false );
//stop write gamestate header
COUT(5) << "G.ST.Man: Gamestate size: " << currentsize << std::endl;
@@ -176,14 +170,14 @@
bool Gamestate::spreadData(uint8_t mode)
{
- COUT(4) << "processing gamestate with id " << header_->getID() << endl;
+ COUT(4) << "processing gamestate with id " << header_.getID() << endl;
assert(data_);
- assert(!header_->isCompressed());
+ assert(!header_.isCompressed());
uint8_t *mem=data_+GamestateHeader::getSize();
Synchronisable *s;
-
+
// update the data of the objects we received
- while(mem < data_+GamestateHeader::getSize()+header_->getDataSize())
+ while(mem < data_+GamestateHeader::getSize()+header_.getDataSize())
{
SynchronisableHeader objectheader(mem);
@@ -196,11 +190,13 @@
}
else
{
+// COUT(4) << "not creating object of classid " << objectheader.getClassID() << endl;
mem += objectheader.getDataSize() + ( objectheader.isDiffed() ? SynchronisableHeaderLight::getSize() : SynchronisableHeader::getSize() );
}
}
else
{
+// COUT(4) << "updating object of classid " << objectheader.getClassID() << endl;
bool b = s->updateData(mem, mode);
assert(b);
}
@@ -248,11 +244,11 @@
uint32_t Gamestate::getSize() const
{
assert(data_);
- if(header_->isCompressed())
- return header_->getCompSize()+GamestateHeader::getSize();
+ if(header_.isCompressed())
+ return header_.getCompSize()+GamestateHeader::getSize();
else
{
- return header_->getDataSize()+GamestateHeader::getSize();
+ return header_.getDataSize()+GamestateHeader::getSize();
}
}
@@ -279,8 +275,8 @@
bool Gamestate::compressData()
{
assert(data_);
- assert(!header_->isCompressed());
- uLongf buffer = (uLongf)(((header_->getDataSize() + 12)*1.01)+1);
+ assert(!header_.isCompressed());
+ uLongf buffer = (uLongf)(((header_.getDataSize() + 12)*1.01)+1);
if(buffer==0)
return false;
@@ -288,7 +284,7 @@
uint8_t *dest = ndata + GamestateHeader::getSize();
uint8_t *source = data_ + GamestateHeader::getSize();
int retval;
- retval = compress( dest, &buffer, source, (uLong)(header_->getDataSize()) );
+ retval = compress( dest, &buffer, source, (uLong)(header_.getDataSize()) );
switch ( retval )
{
case Z_OK: COUT(5) << "G.St.Man: compress: successfully compressed" << std::endl; break;
@@ -298,16 +294,17 @@
}
//copy and modify header
- GamestateHeader *temp = header_;
- header_ = new GamestateHeader(ndata, temp);
+ GamestateHeader *temp = new GamestateHeader(data_);
+ header_.setData(ndata);
+ header_ = *temp;
delete temp;
//delete old data
delete[] data_;
//save new data
data_ = ndata;
- header_->setCompSize( buffer );
- header_->setCompressed( true );
- COUT(0) << "gamestate compress datasize: " << header_->getDataSize() << " compsize: " << header_->getCompSize() << std::endl;
+ header_.setCompSize( buffer );
+ header_.setCompressed( true );
+ COUT(4) << "gamestate compress datasize: " << header_.getDataSize() << " compsize: " << header_.getCompSize() << std::endl;
return true;
}
@@ -315,10 +312,10 @@
bool Gamestate::decompressData()
{
assert(data_);
- assert(header_->isCompressed());
- COUT(4) << "GameStateClient: uncompressing gamestate. id: " << header_->getID() << ", baseid: " << header_->getBaseID() << ", datasize: " << header_->getDataSize() << ", compsize: " << header_->getCompSize() << std::endl;
- uint32_t datasize = header_->getDataSize();
- uint32_t compsize = header_->getCompSize();
+ assert(header_.isCompressed());
+ COUT(4) << "GameStateClient: uncompressing gamestate. id: " << header_.getID() << ", baseid: " << header_.getBaseID() << ", datasize: " << header_.getDataSize() << ", compsize: " << header_.getCompSize() << std::endl;
+ uint32_t datasize = header_.getDataSize();
+ uint32_t compsize = header_.getCompSize();
uint32_t bufsize;
bufsize = datasize;
assert(bufsize!=0);
@@ -337,8 +334,9 @@
}
//copy over the header
- GamestateHeader *temp = header_;
- header_ = new GamestateHeader( data_, header_ );
+ GamestateHeader* temp = new GamestateHeader( data_ );
+ header_.setData(ndata);
+ header_ = *temp;
delete temp;
if (this->bDataENetAllocated_)
@@ -356,221 +354,250 @@
//set new pointers
data_ = ndata;
- header_->setCompressed( false );
- assert(header_->getDataSize()==datasize);
- assert(header_->getCompSize()==compsize);
+ header_.setCompressed( false );
+ assert(header_.getDataSize()==datasize);
+ assert(header_.getCompSize()==compsize);
return true;
}
+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() );
+
+ uint32_t objectOffset = SynchronisableHeader::getSize(); // offset inside the object in the origData and baseData
+ // Check whether the whole object stayed the same
+ if( memcmp( origDataPtr+objectOffset, baseDataPtr+objectOffset, objectHeader.getDataSize()) == 0 )
+ {
+// COUT(4) << "skip object " << Synchronisable::getSynchronisable(objectHeader.getObjectID())->getIdentifier()->getName() << endl;
+ origDataPtr += objectOffset + objectHeader.getDataSize(); // skip the whole object
+ baseDataPtr += objectOffset + objectHeader.getDataSize();
+ sizes += Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables();
+ }
+ 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);
+ newObjectHeader = objectHeader; // copy over the objectheader
+ VariableID variableID = 0;
+ uint32_t diffedObjectOffset = SynchronisableHeaderLight::getSize();
+ // iterate through all variables
+ while( objectOffset < objectHeader.getDataSize()+SynchronisableHeader::getSize() )
+ {
+ // 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) );
+ if ( varSize != 0 )
+ {
+ if ( memcmp(origDataPtr+objectOffset, baseDataPtr+objectOffset, varSize) != 0 )
+ {
+ // COUT(4) << "copy variable" << endl;
+ *(VariableID*)(newDataPtr+diffedObjectOffset) = variableID; // copy over the variableID
+ diffedObjectOffset += sizeof(VariableID);
+ memcpy( newDataPtr+diffedObjectOffset, origDataPtr+objectOffset, varSize );
+ diffedObjectOffset += varSize;
+ objectOffset += varSize;
+ }
+ else
+ {
+ // COUT(4) << "skip variable" << endl;
+ objectOffset += varSize;
+ }
+ }
+// else
+// COUT(4) << "varsize 0" << endl;
+
+ ++variableID;
+ ++sizes;
+ }
+
+ if( Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables() != variableID )
+ sizes += Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables() - variableID;
+ // COUT(4) << endl;
+
+ newObjectHeader.setDiffed(true);
+ newObjectHeader.setDataSize(diffedObjectOffset-SynchronisableHeaderLight::getSize());
+ 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;
+ }
+}
+
+inline void /*Gamestate::*/copyObject( uint8_t*& newData, uint8_t*& origData, uint8_t*& baseData, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes )
+{
+ // COUT(4) << "docopy" << endl;
+ // Just copy over the whole Object
+ memcpy( newData, origData, objectHeader.getDataSize()+SynchronisableHeader::getSize() );
+ newData += objectHeader.getDataSize()+SynchronisableHeader::getSize();
+ origData += objectHeader.getDataSize()+SynchronisableHeader::getSize();
+// SynchronisableHeader baseHeader( baseData );
+// baseData += baseHeader.getDataSize()+SynchronisableHeader::getSize();
+ // COUT(4) << "copy " << h.getObjectID() << endl;
+ // COUT(4) << "copy " << h.getObjectID() << ":";
+ sizes += Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables();
+// for( unsigned int i = 0; i < Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables(); ++i )
+// {
+// // COUT(4) << " " << *sizes;
+// ++sizes;
+// }
+ // COUT(4) << endl;
+}
+
+inline bool findObject(uint8_t*& dataPtr, uint8_t* endPtr, SynchronisableHeader& objectHeader)
+{
+ // Some assertions to make sure the dataPtr is valid (pointing to a SynchronisableHeader)
+ {
+ SynchronisableHeader htemp2(dataPtr);
+ assert(htemp2.getClassID()<500);
+ assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
+ assert(htemp2.isDiffed()==false);
+ }
+ uint32_t objectID = objectHeader.getObjectID();
+ while ( dataPtr < endPtr )
+ {
+ SynchronisableHeader htemp(dataPtr);
+ assert( htemp.getDataSize()!=0 );
+ if ( htemp.getObjectID() == objectID )
+ {
+ assert( objectHeader.getClassID() == htemp.getClassID() );
+ assert( objectHeader.getCreatorID() == htemp.getCreatorID() );
+ return true;
+ }
+ {
+ if( dataPtr+htemp.getDataSize()+SynchronisableHeader::getSize() < endPtr )
+ {
+ SynchronisableHeader htemp2(dataPtr+htemp.getDataSize()+SynchronisableHeader::getSize());
+ assert(htemp2.getClassID()<500);
+ assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
+ assert(htemp2.isDiffed()==false);
+ }
+ }
+ dataPtr += htemp.getDataSize()+SynchronisableHeader::getSize();
+
+ }
+ assert(dataPtr == endPtr);
+
+ return false;
+}
+
Gamestate* Gamestate::diffVariables(Gamestate *base)
{
assert(this && base); assert(data_ && base->data_);
- assert(!header_->isCompressed() && !base->header_->isCompressed());
- assert(!header_->isDiffed());
+ assert(!header_.isCompressed() && !base->header_.isCompressed());
+ assert(!header_.isDiffed());
+ assert( header_.getDataSize() && base->header_.getDataSize() );
// *** first do a raw diff of the two gamestates
- uint8_t *baseData = GAMESTATE_START(base->data_);
- uint8_t *origData = GAMESTATE_START(this->data_);
- uint32_t origLength = header_->getDataSize();
- uint32_t baseLength = base->header_->getDataSize();
+ uint8_t *baseDataPtr = GAMESTATE_START(base->data_);
+ uint8_t *origDataPtr = GAMESTATE_START(this->data_);
+ uint8_t *origDataEnd = origDataPtr + header_.getDataSize();
+ uint8_t *baseDataEnd = baseDataPtr + base->header_.getDataSize();
+// uint32_t origLength = header_.getDataSize();
+// uint32_t baseLength = base->header_.getDataSize();
- assert( origLength && baseLength );
+ // Allocate new space for diffed gamestate
+ uint32_t newDataSize = header_.getDataSize() + GamestateHeader::getSize() + sizeof(uint32_t)*this->nrOfVariables_;
+ uint8_t *newData = new uint8_t[newDataSize]; // this is the maximum size needed in the worst case
+ uint8_t *destDataPtr = GAMESTATE_START(newData);
- uint8_t *nData = new uint8_t[origLength + GamestateHeader::getSize() + sizeof(uint32_t)*this->nrOfVariables_]; // this is the maximum size needed in the worst case
- uint8_t *dest = GAMESTATE_START(nData);
+ std::vector<uint32_t>::iterator sizesIt = this->sizes_.begin();
- uint32_t baseOffset = 0; //offset in the diffed stream
- uint32_t origOffset = 0; //offset in the new stream with removed 0's
- std::vector<uint32_t>::iterator sizes = this->sizes_.begin();
-
- while( origOffset < origLength )
+ while( origDataPtr < origDataEnd )
{
//iterate through all objects
- SynchronisableHeader h(origData+origOffset);
+ SynchronisableHeader origHeader(origDataPtr);
// Find (if possible) the current object in the datastream of the old gamestate
// Start at the current offset position
- if(baseOffset >= baseLength)
- baseOffset = 0;
- uint8_t* temp = baseData + baseOffset;
- uint32_t objectID = h.getObjectID();
- assert(temp < baseData+baseLength);
- assert(dest < nData + origLength + GamestateHeader::getSize() + sizeof(uint32_t)*this->nrOfVariables_);
- assert(sizes != this->sizes_.end());
- while ( temp < baseData+baseLength )
+ if(baseDataPtr == baseDataEnd)
+ baseDataPtr = GAMESTATE_START(base->data_);
+ uint8_t* oldBaseDataPtr = baseDataPtr;
+
+ assert(baseDataPtr < baseDataEnd);
+ assert(destDataPtr < newData + newDataSize);
+ assert(sizesIt != this->sizes_.end());
+
+ bool diffedObject = false;
+ if( findObject(baseDataPtr, baseDataEnd, origHeader) )
{
- SynchronisableHeader htemp(temp);
- assert( htemp.getDataSize()!=0 );
- if ( htemp.getObjectID() == objectID )
+ if( SynchronisableHeader(baseDataPtr).getDataSize()==origHeader.getDataSize() )
{
- assert( h.getClassID() == htemp.getClassID() );
- goto DODIFF;
+// COUT(4) << "diffing object in order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+ diffObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
+ diffedObject = true;
}
-// {
-// SynchronisableHeader htemp2(temp+htemp.getDataSize()+SynchronisableHeader::getSize());
-// if( temp+htemp.getDataSize()+SynchronisableHeader::getSize() < baseData+baseLength )
-// {
-// assert(htemp2.getClassID()<500);
-// assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
-// assert(htemp2.isDiffed()==false);
-// }
-// }
- temp += htemp.getDataSize()+SynchronisableHeader::getSize();
-
- }
- // If not found start looking at the beginning
- assert( temp==baseData+baseLength );
- temp = baseData;
-// {
-// SynchronisableHeader htemp2(temp);
-// if( temp < baseData+baseLength )
-// {
-// assert(htemp2.getClassID()<500);
-// assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
-// assert(htemp2.isDiffed()==false);
-// }
-// }
- while ( temp < baseData+baseOffset )
- {
- SynchronisableHeader htemp(temp);
- if ( htemp.getObjectID() == objectID )
+ else
{
- assert( h.getClassID() == htemp.getClassID() );
- goto DODIFF;
+// COUT(4) << "copy object because of different data sizes (1): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+ copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
+ assert(sizesIt != this->sizes_.end() || origDataPtr==origDataEnd);
}
-// {
-// SynchronisableHeader htemp2(temp+htemp.getDataSize()+SynchronisableHeader::getSize());
-// if( temp+htemp.getDataSize()+SynchronisableHeader::getSize() < baseData+baseLength )
-// {
-// assert(htemp2.getClassID()<500);
-// assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
-// assert(htemp2.isDiffed()==false);
-// }
-// }
- temp += htemp.getDataSize()+SynchronisableHeader::getSize();
+
}
- // Object is new, thus never transmitted -> just copy over
- goto DOCOPY;
-
-
-DODIFF:
+ else
{
-// COUT(4) << "dodiff" << endl;
-// if(baseOffset==0)
-// {
-// assert(origOffset==0);
-// }
- uint32_t objectOffset = SynchronisableHeader::getSize(); // offset inside the object in the origData and baseData
- // Check whether the whole object stayed the same
- if( memcmp( origData+origOffset+objectOffset, temp+objectOffset, h.getDataSize()) == 0 )
+ assert( baseDataPtr == baseDataEnd );
+ baseDataPtr = GAMESTATE_START(base->data_);
+ if( findObject(baseDataPtr, oldBaseDataPtr, origHeader) )
{
-// COUT(4) << "skip object" << Synchronisable::getSynchronisable(h.getObjectID())->getIdentifier()->getName() << endl;
- origOffset += objectOffset+ h.getDataSize(); // skip the whole object
- baseOffset = temp + h.getDataSize()+SynchronisableHeader::getSize() - baseData;
- sizes += Synchronisable::getSynchronisable(h.getObjectID())->getNrOfVariables();
- }
- else
- {
-// if( Synchronisable::getSynchronisable(h.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 h2(dest);
- h2 = h; // copy over the objectheader
- VariableID variableID = 0;
- uint32_t newObjectOffset = SynchronisableHeaderLight::getSize();
- // iterate through all variables
- while( objectOffset < h.getDataSize()+SynchronisableHeader::getSize() )
+ if( SynchronisableHeader(baseDataPtr).getDataSize()==origHeader.getDataSize() )
{
- // 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(h.getObjectID())->getVarSize(variableID) );
- if ( varSize != 0 )
- {
- if ( memcmp(origData+origOffset+objectOffset, temp+objectOffset, varSize) != 0 )
- {
-// COUT(4) << "copy variable" << endl;
- *(VariableID*)(dest+newObjectOffset) = variableID; // copy over the variableID
- newObjectOffset += sizeof(VariableID);
- memcpy( dest+newObjectOffset, origData+origOffset+objectOffset, varSize );
- newObjectOffset += varSize;
- objectOffset += varSize;
- }
- else
- {
-// COUT(4) << "skip variable" << endl;
- objectOffset += varSize;
- }
- }
-// else
-// COUT(4) << "varsize 0" << endl;
-
- ++variableID;
- ++sizes;
+// COUT(4) << "diffing object out of order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+ diffObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
+ diffedObject = true;
}
-
- if( Synchronisable::getSynchronisable(h.getObjectID())->getNrOfVariables() != variableID )
- sizes += Synchronisable::getSynchronisable(h.getObjectID())->getNrOfVariables() - variableID;
-// COUT(4) << endl;
- h2.setDiffed(true);
- h2.setDataSize(newObjectOffset-SynchronisableHeaderLight::getSize());
- assert(objectOffset == h.getDataSize()+SynchronisableHeader::getSize());
- origOffset += 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);
-// }
-// }
- baseOffset = temp-baseData + objectOffset;
- dest += newObjectOffset;
+ else
+ {
+// COUT(4) << "copy object because of different data sizes (2): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+ copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
+ assert(sizesIt != this->sizes_.end() || origDataPtr==origDataEnd);
+ }
}
-
- continue;
- }
-
-DOCOPY:
- {
-// COUT(4) << "docopy" << endl;
- // Just copy over the whole Object
- memcpy( dest, origData+origOffset, h.getDataSize()+SynchronisableHeader::getSize() );
- dest += h.getDataSize()+SynchronisableHeader::getSize();
- origOffset += h.getDataSize()+SynchronisableHeader::getSize();
- assert( Synchronisable::getSynchronisable(h.getObjectID()) );
-// COUT(4) << "copy " << h.getObjectID() << endl;
-// COUT(4) << "copy " << h.getObjectID() << ":";
- //sizes += Synchronisable::getSynchronisable(h.getObjectID())->getNrOfVariables();
- for( unsigned int i = 0; i < Synchronisable::getSynchronisable(h.getObjectID())->getNrOfVariables(); ++i )
+ else
{
-// COUT(4) << " " << *sizes;
- ++sizes;
+// COUT(4) << "copy object: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+ assert(baseDataPtr == oldBaseDataPtr);
+ copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
+ assert(sizesIt != this->sizes_.end() || origDataPtr==origDataEnd);
}
-// COUT(4) << endl;
- assert(sizes != this->sizes_.end() || origOffset>=origLength);
- continue;
}
}
+ assert(sizesIt==this->sizes_.end());
- Gamestate *g = new Gamestate(nData, getClientID());
- assert(g->header_);
- *(g->header_) = *header_;
- g->header_->setBaseID( base->getID() );
- g->header_->setDataSize(dest - nData - GamestateHeader::getSize());
+ Gamestate *g = new Gamestate(newData, getClientID());
+ (g->header_) = header_;
+ g->header_.setBaseID( base->getID() );
+ g->header_.setDataSize(destDataPtr - newData - GamestateHeader::getSize());
g->flags_=flags_;
g->packetDirection_ = packetDirection_;
assert(!g->isCompressed());
@@ -578,15 +605,15 @@
}
-Gamestate* Gamestate::diffData(Gamestate *base)
+/*Gamestate* Gamestate::diffData(Gamestate *base)
{
assert(this && base); assert(data_ && base->data_);
- assert(!header_->isCompressed() && !base->header_->isCompressed());
- assert(!header_->isDiffed());
+ assert(!header_.isCompressed() && !base->header_.isCompressed());
+ assert(!header_.isDiffed());
uint8_t *basep = GAMESTATE_START(base->data_);
uint8_t *gs = GAMESTATE_START(this->data_);
- uint32_t dest_length = header_->getDataSize();
+ uint32_t dest_length = header_.getDataSize();
if(dest_length==0)
return NULL;
@@ -594,10 +621,10 @@
uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
uint8_t *dest = GAMESTATE_START(ndata);
- rawDiff( dest, gs, basep, header_->getDataSize(), base->header_->getDataSize() );
+ rawDiff( dest, gs, basep, header_.getDataSize(), base->header_.getDataSize() );
#ifndef NDEBUG
uint8_t *dest2 = new uint8_t[dest_length];
- rawDiff( dest2, dest, basep, header_->getDataSize(), base->header_->getDataSize() );
+ rawDiff( dest2, dest, basep, header_.getDataSize(), base->header_.getDataSize() );
assert( memcmp( dest2, gs, dest_length) == 0 );
delete dest2;
#endif
@@ -605,8 +632,8 @@
Gamestate *g = new Gamestate(ndata, getClientID());
assert(g->header_);
*(g->header_) = *header_;
- g->header_->setDiffed( true );
- g->header_->setBaseID( base->getID() );
+ g->header_.setDiffed( true );
+ g->header_.setBaseID( base->getID() );
g->flags_=flags_;
g->packetDirection_ = packetDirection_;
assert(g->isDiffed());
@@ -618,12 +645,12 @@
Gamestate* Gamestate::undiff(Gamestate *base)
{
assert(this && base); assert(data_ && base->data_);
- assert(!header_->isCompressed() && !base->header_->isCompressed());
- assert(header_->isDiffed());
+ assert(!header_.isCompressed() && !base->header_.isCompressed());
+ assert(header_.isDiffed());
uint8_t *basep = GAMESTATE_START(base->data_);
uint8_t *gs = GAMESTATE_START(this->data_);
- uint32_t dest_length = header_->getDataSize();
+ uint32_t dest_length = header_.getDataSize();
if(dest_length==0)
return NULL;
@@ -631,12 +658,12 @@
uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
uint8_t *dest = ndata + GamestateHeader::getSize();
- rawDiff( dest, gs, basep, header_->getDataSize(), base->header_->getDataSize() );
+ rawDiff( dest, gs, basep, header_.getDataSize(), base->header_.getDataSize() );
Gamestate *g = new Gamestate(ndata, getClientID());
assert(g->header_);
*(g->header_) = *header_;
- g->header_->setDiffed( false );
+ g->header_.setDiffed( false );
g->flags_=flags_;
g->packetDirection_ = packetDirection_;
assert(!g->isDiffed());
@@ -669,15 +696,15 @@
*(newdata+j) = *(data+j); // just copy
}
assert(j==datalength);
-}
+}*/
-Gamestate* Gamestate::doSelection(unsigned int clientID, unsigned int targetSize){
+/*Gamestate* Gamestate::doSelection(unsigned int clientID, unsigned int targetSize){
assert(data_);
std::list<obj>::iterator it;
// allocate memory for new data
- uint8_t *gdata = new uint8_t[header_->getDataSize()+GamestateHeader::getSize()];
+ uint8_t *gdata = new uint8_t[header_.getDataSize()+GamestateHeader::getSize()];
// create a gamestate out of it
Gamestate *gs = new Gamestate(gdata);
uint8_t *newdata = gdata + GamestateHeader::getSize();
@@ -693,7 +720,7 @@
//Synchronisable *object;
//call TrafficControl
- TrafficControl::getInstance()->processObjectList( clientID, header_->getID(), dataVector_ );
+ TrafficControl::getInstance()->processObjectList( clientID, header_.getID(), dataVector_ );
//copy in the zeros
// std::list<obj>::iterator itt;
@@ -724,19 +751,19 @@
}
#ifndef NDEBUG
uint32_t origsize = destsize;
- while ( origsize < header_->getDataSize() )
+ while ( origsize < header_.getDataSize() )
{
SynchronisableHeader oldobjectheader(origdata);
objectsize = oldobjectheader.getDataSize()+SynchronisableHeader::getSize();
origdata += objectsize;
origsize += objectsize;
}
- assert(origsize==header_->getDataSize());
+ assert(origsize==header_.getDataSize());
assert(destsize!=0);
#endif
- gs->header_->setDataSize( destsize );
+ gs->header_.setDataSize( destsize );
return gs;
-}
+}*/
uint32_t Gamestate::calcGamestateSize(int32_t id, uint8_t mode)
Modified: code/branches/network5/src/libraries/network/packet/Gamestate.h
===================================================================
--- code/branches/network5/src/libraries/network/packet/Gamestate.h 2010-12-12 21:50:14 UTC (rev 7757)
+++ code/branches/network5/src/libraries/network/packet/Gamestate.h 2010-12-12 22:13:01 UTC (rev 7758)
@@ -47,26 +47,30 @@
class _NetworkExport GamestateHeader{
public:
- GamestateHeader(uint8_t *data){ assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
- GamestateHeader(uint8_t *data, GamestateHeader* h)
- { assert(data); data_=data; memcpy(data_, h->data_, getSize()); }
+ GamestateHeader(){ data_=0; }
+ GamestateHeader(uint8_t* data)
+ { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
+ /*GamestateHeader(uint8_t* data, GamestateHeader* h)
+ { assert(data); data_=data; memcpy(data_, h->data_, getSize()); }*/
+ void setData(uint8_t* data)
+ { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
static inline uint32_t getSize()
- { return 21; }
+ { return 21; }
inline int32_t getID() const
- { assert(data_); return *(int32_t*)(data_+4); }
+ { assert(data_); return *(int32_t*)(data_+4); }
inline void setID(int32_t id)
- { assert(data_); *(int32_t*)(data_+4) = id; }
+ { assert(data_); *(int32_t*)(data_+4) = id; }
inline int32_t getBaseID() const
- { assert(data_); return *(int32_t*)(data_+8); }
+ { assert(data_); return *(int32_t*)(data_+8); }
inline void setBaseID(int32_t id)
- { assert(data_); *(int32_t*)(data_+8) = id; }
+ { assert(data_); *(int32_t*)(data_+8) = id; }
inline uint32_t getDataSize() const
- { assert(data_); return *(uint32_t*)(data_+12); }
+ { assert(data_); return *(uint32_t*)(data_+12); }
inline void setDataSize(uint32_t size)
- { assert(data_); *(uint32_t*)(data_+12) = size; }
+ { assert(data_); *(uint32_t*)(data_+12) = size; }
inline uint32_t getCompSize() const
{ assert(data_); return *(uint32_t*)(data_+16); }
@@ -74,24 +78,24 @@
{ assert(data_); *(uint32_t*)(data_+16) = size; }
inline bool isDiffed() const
- { assert(data_); return *(int8_t*)(data_+20) & 0x1; }
+ { assert(data_); return *(int8_t*)(data_+20) & 0x1; }
inline void setDiffed(bool b)
- { assert(data_); *(int8_t*)(data_+20) = (b<<0) | (*(int8_t*)(data_+20) & 0x6 ); }
+ { assert(data_); *(int8_t*)(data_+20) = (b<<0) | (*(int8_t*)(data_+20) & 0x6 ); }
inline bool isComplete() const
- { assert(data_); return *(int8_t*)(data_+20) & 0x2; }
+ { assert(data_); return *(int8_t*)(data_+20) & 0x2; }
inline void setComplete(bool b)
- { assert(data_); *(int8_t*)(data_+20) = (b<<1) | (*(int8_t*)(data_+20) & 0x5 ); }
+ { assert(data_); *(int8_t*)(data_+20) = (b<<1) | (*(int8_t*)(data_+20) & 0x5 ); }
inline bool isCompressed() const
- { assert(data_); return *(int8_t*)(data_+20) & 0x4; }
+ { assert(data_); return *(int8_t*)(data_+20) & 0x4; }
inline void setCompressed(bool b)
- { assert(data_); *(int8_t*)(data_+20) = (b<<2) | (*(int8_t*)(data_+20) & 0x3 ); }
+ { assert(data_); *(int8_t*)(data_+20) = (b<<2) | (*(int8_t*)(data_+20) & 0x3 ); }
inline void operator=(GamestateHeader& h)
- { assert(data_); assert(h.data_); memcpy( data_, h.data_, getSize()); }
+ { assert(data_); assert(h.data_); memcpy( data_, h.data_, getSize()); }
private:
- uint8_t *data_;
+ uint8_t* data_;
};
@@ -109,29 +113,31 @@
bool collectData(int id, uint8_t mode=0x0);
bool spreadData( uint8_t mode=0x0);
- inline int32_t getID() const { return header_->getID(); }
- inline bool isDiffed() const { return header_->isDiffed(); }
- inline bool isCompressed() const { return header_->isCompressed(); }
- inline int32_t getBaseID() const { return header_->getBaseID(); }
- inline uint32_t getDataSize() const { return header_->getDataSize(); }
+ inline int32_t getID() const { return header_.getID(); }
+ inline bool isDiffed() const { return header_.isDiffed(); }
+ inline bool isCompressed() const { return header_.isCompressed(); }
+ inline int32_t getBaseID() const { return header_.getBaseID(); }
+ inline uint32_t getDataSize() const { return header_.getDataSize(); }
Gamestate* diffVariables(Gamestate *base);
- Gamestate* diffData(Gamestate *base);
- Gamestate *undiff(Gamestate *base);
- Gamestate* doSelection(unsigned int clientID, unsigned int targetSize);
+// Gamestate* diffData(Gamestate *base);
+// Gamestate *undiff(Gamestate *base);
+// Gamestate* doSelection(unsigned int clientID, unsigned int targetSize);
bool compressData();
bool decompressData();
bool operator ==(packet::Gamestate gs);
// Packet functions
private:
- void rawDiff( uint8_t* newdata, uint8_t* data, uint8_t* basedata, uint32_t datalength, uint32_t baselength);
- inline uint32_t findObject( const SynchronisableHeader& header, uint8_t* mem, uint32_t dataLength, uint32_t startPosition = 0 );
+// void rawDiff( uint8_t* newdata, uint8_t* data, uint8_t* basedata, uint32_t datalength, uint32_t baselength);
+// inline uint32_t findObject( const SynchronisableHeader& header, uint8_t* mem, uint32_t dataLength, uint32_t startPosition = 0 );
virtual uint32_t getSize() const;
virtual inline bool process();
uint32_t calcGamestateSize(int32_t id, uint8_t mode=0x0);
+// inline void diffObject( uint8_t*& newData, uint8_t*& origData, uint8_t*& baseData, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes );
+// inline void copyObject( uint8_t*& newData, uint8_t*& origData, uint8_t*& baseData, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes );
std::list<obj> dataVector_;
- GamestateHeader* header_;
+ GamestateHeader header_;
std::vector<uint32_t> sizes_;
uint32_t nrOfVariables_;
};
Modified: code/branches/network5/src/libraries/network/synchronisable/Synchronisable.cc
===================================================================
--- code/branches/network5/src/libraries/network/synchronisable/Synchronisable.cc 2010-12-12 21:50:14 UTC (rev 7757)
+++ code/branches/network5/src/libraries/network/synchronisable/Synchronisable.cc 2010-12-12 22:13:01 UTC (rev 7758)
@@ -122,7 +122,12 @@
Synchronisable *Synchronisable::fabricate(uint8_t*& mem, uint8_t mode)
{
SynchronisableHeader header(mem);
- assert( !header.isDiffed() );
+ if( header.isDiffed() )
+ {
+ mem += header.getDataSize() + header.getSize();
+ return 0;
+ }
+// assert( !header.isDiffed() );
COUT(4) << "fabricating object with id: " << header.getObjectID() << std::endl;
@@ -216,11 +221,11 @@
* |totalsize,objectID_,classID_,var1,var2,string1_length,string1,var3,...|
* length of varx: size saved int syncvarlist
* @param mem pointer to allocated memory with enough size
- * @param sizes FIXME - add doc!
+ * @param sizes vector containing sizes of all objects in gamestate (to be appended)
* @param id gamestateid of the gamestate to be saved (important for priorities)
* @param mode defines the direction in which the data will be send/received
* 0x1: server->client
- * 0x2: client->server (not recommended)
+ * 0x2: client->server
* 0x3: bidirectional
* @return true: if !doSync or if everything was successfully saved
*/
@@ -264,6 +269,7 @@
++test;
//tempsize += (*i)->getSize( mode );
}
+ assert(tempsize!=0); // if this happens an empty object (with no variables) would be transmitted
// COUT(4) << endl;
header.setObjectID( this->objectID_ );
@@ -315,7 +321,7 @@
assert( this->getCreatorID() == syncHeader2.getCreatorID() );
mem += SynchronisableHeader::getSize();
std::vector<SynchronisableVariableBase *>::iterator i;
- for(i=syncList_.begin(); i!=syncList_.end(); i++)
+ for(i=syncList_.begin(); i!=syncList_.end(); ++i)
{
assert( mem <= data+syncHeader2.getDataSize()+SynchronisableHeader::getSize() ); // always make sure we don't exceed the datasize in our stream
(*i)->putData( mem, mode, forceCallback );
Modified: code/branches/network5/src/modules/weapons/MuzzleFlash.cc
===================================================================
--- code/branches/network5/src/modules/weapons/MuzzleFlash.cc 2010-12-12 21:50:14 UTC (rev 7757)
+++ code/branches/network5/src/modules/weapons/MuzzleFlash.cc 2010-12-12 22:13:01 UTC (rev 7758)
@@ -41,6 +41,7 @@
RegisterObject(MuzzleFlash);
this->setScale(0.1f);
- this->delayTimer_.setTimer(0.1f, false, createExecutor(createFunctor(&MuzzleFlash::destroy, this)));
+ if( GameMode::isMaster() )
+ this->delayTimer_.setTimer(0.1f, false, createExecutor(createFunctor(&MuzzleFlash::destroy, this)));
}
}
Modified: code/branches/network5/src/orxonox/gametypes/Gametype.cc
===================================================================
--- code/branches/network5/src/orxonox/gametypes/Gametype.cc 2010-12-12 21:50:14 UTC (rev 7757)
+++ code/branches/network5/src/orxonox/gametypes/Gametype.cc 2010-12-12 22:13:01 UTC (rev 7758)
@@ -78,6 +78,11 @@
}
else
this->scoreboard_ = 0;
+
+ /* HACK HACK HACK */
+ this->dedicatedAddBots_ = createConsoleCommand( "dedicatedAddBots", createExecutor( createFunctor(&Gametype::addBots, this) ) );
+ this->dedicatedKillBots_ = createConsoleCommand( "dedicatedKillBots", createExecutor( createFunctor(&Gametype::killBots, this) ) );
+ /* HACK HACK HACK */
}
Gametype::~Gametype()
@@ -85,6 +90,10 @@
if (this->isInitialized())
{
this->gtinfo_->destroy();
+ if( this->dedicatedAddBots_ )
+ delete this->dedicatedAddBots_;
+ if( this->dedicatedKillBots_ )
+ delete this->dedicatedKillBots_;
}
}
Modified: code/branches/network5/src/orxonox/gametypes/Gametype.h
===================================================================
--- code/branches/network5/src/orxonox/gametypes/Gametype.h 2010-12-12 21:50:14 UTC (rev 7757)
+++ code/branches/network5/src/orxonox/gametypes/Gametype.h 2010-12-12 22:13:01 UTC (rev 7758)
@@ -183,6 +183,11 @@
// Config Values
std::string scoreboardTemplate_;
+
+ /* HACK HACK HACK */
+ ConsoleCommand* dedicatedAddBots_;
+ ConsoleCommand* dedicatedKillBots_;
+ /* HACK HACK HACK */
};
}
More information about the Orxonox-commit
mailing list