Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Oct 12, 2008, 12:15:30 PM (16 years ago)
Author:
scheusso
Message:

Lots of changes:
Some fixes/hacks in objects
Changes in Gamestates and bugfixes
Removed some asserts

File:
1 edited

Legend:

Unmodified
Added
Removed

  • code/branches/network/src/network/packet/Gamestate.cc

    r1834 r1901  
    4747
    4848 
     49#define PACKET_FLAG_GAMESTATE  ENET_PACKET_FLAG_RELIABLE
     50 
    4951Gamestate::Gamestate()
    5052{
    51 }
    52 
    53 Gamestate::Gamestate(unsigned char *data, int clientID):
     53  flags_ = flags_ | PACKET_FLAG_GAMESTATE;
     54}
     55
     56Gamestate::Gamestate(uint8_t *data, unsigned int clientID):
    5457    Packet(data, clientID)
    5558{
    56 }
    57 
    58 Gamestate::Gamestate(unsigned char *data)
    59 {
     59  flags_ = flags_ | PACKET_FLAG_GAMESTATE;
     60}
     61
     62Gamestate::Gamestate(uint8_t *data)
     63{
     64  flags_ = flags_ | PACKET_FLAG_GAMESTATE;
    6065  data_=data;
    6166}
    … …  
    8691#endif
    8792  //start collect data synchronisable by synchronisable
    88   unsigned char *mem=data_;
     93  uint8_t *mem=data_;
    8994  mem+=sizeof(GamestateHeader);
    9095  orxonox::ObjectList<Synchronisable>::iterator it;
    … …  
    99104      while(++temp)
    100105        addsize+=temp->getSize(id, mode);
    101       data_ = (unsigned char *)realloc(data_, sizeof(GamestateHeader) + currentsize + addsize);
     106      data_ = (uint8_t *)realloc(data_, sizeof(GamestateHeader) + currentsize + addsize);
    102107      if(!data_)
    103108        return false;
    … …  
    140145  assert(!HEADER->compressed);
    141146  assert(!HEADER->diffed);
    142   unsigned char *mem=data_+sizeof(GamestateHeader);
     147  uint8_t *mem=data_+sizeof(GamestateHeader);
    143148    // get the start of the Synchronisable list
    144149  //orxonox::ObjectList<Synchronisable>::iterator it=orxonox::ObjectList<Synchronisable>::begin();
    … …  
    159164    else
    160165    {
    161       assert(s->updateData(mem, mode));
     166      bool b = s->updateData(mem, mode);
     167      assert(b);
    162168      //if(!s->updateData(mem, mode))
    163169        //return false;
    … …  
    186192
    187193bool Gamestate::operator==(packet::Gamestate gs){
    188   unsigned char *d1 = data_+sizeof(GamestateHeader);
    189   unsigned char *d2 = gs.data_+sizeof(GamestateHeader);
     194  uint8_t *d1 = data_+sizeof(GamestateHeader);
     195  uint8_t *d2 = gs.data_+sizeof(GamestateHeader);
    190196  assert(!isCompressed());
    191197  assert(!gs.isCompressed());
    … …  
    215221    return false;
    216222
    217   unsigned char *ndata = new unsigned char[buffer+sizeof(GamestateHeader)];
    218   unsigned char *dest = GAMESTATE_START(ndata);
     223  uint8_t *ndata = new uint8_t[buffer+sizeof(GamestateHeader)];
     224  uint8_t *dest = GAMESTATE_START(ndata);
    219225  //unsigned char *dest = new unsigned char[buffer];
    220   unsigned char *source = GAMESTATE_START(data_);
     226  uint8_t *source = GAMESTATE_START(data_);
    221227  int retval;
    222228  retval = compress( dest, &buffer, source, (uLong)(HEADER->datasize) );
    … …  
    229235#ifndef NDEBUG
    230236  //decompress and compare the start and the decompressed data
    231   unsigned char *rdata = new unsigned char[HEADER->datasize+sizeof(GamestateHeader)];
    232   unsigned char *d2 = GAMESTATE_START(rdata);
     237  uint8_t *rdata = new uint8_t[HEADER->datasize+sizeof(GamestateHeader)];
     238  uint8_t *d2 = GAMESTATE_START(rdata);
    233239  uLongf length2 = HEADER->datasize;
    234240  uncompress(d2, &length2, dest, buffer);
    … …  
    265271  bufsize = datasize;
    266272  assert(bufsize!=0);
    267   unsigned char *ndata = new unsigned char[bufsize + sizeof(GamestateHeader)];
    268   unsigned char *dest = ndata + sizeof(GamestateHeader);
    269   unsigned char *source = data_ + sizeof(GamestateHeader);
     273  uint8_t *ndata = new uint8_t[bufsize + sizeof(GamestateHeader)];
     274  uint8_t *dest = ndata + sizeof(GamestateHeader);
     275  uint8_t *source = data_ + sizeof(GamestateHeader);
    270276  int retval;
    271277  uLongf length=bufsize;
    … …  
    299305  assert(!HEADER->diffed);
    300306  //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
    301   unsigned char *basep = GAMESTATE_START(base->data_), *gs = GAMESTATE_START(this->data_);
     307  uint8_t *basep = GAMESTATE_START(base->data_), *gs = GAMESTATE_START(this->data_);
    302308  unsigned int of=0; // pointers offset
    303309  unsigned int dest_length=0;
    … …  
    305311  if(dest_length==0)
    306312    return NULL;
    307   unsigned char *ndata = new unsigned char[dest_length*sizeof(unsigned char)+sizeof(GamestateHeader)];
    308   unsigned char *dest = ndata + sizeof(GamestateHeader);
     313  uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+sizeof(GamestateHeader)];
     314  uint8_t *dest = ndata + sizeof(GamestateHeader);
    309315  while(of < GAMESTATE_HEADER(base->data_)->datasize && of < HEADER->datasize){
    310316    *(dest+of)=*(basep+of)^*(gs+of); // do the xor
    … …  
    312318  }
    313319  if(GAMESTATE_HEADER(base->data_)->datasize!=HEADER->datasize){
    314     unsigned char n=0;
     320    uint8_t n=0;
    315321    if(GAMESTATE_HEADER(base->data_)->datasize < HEADER->datasize){
    316322      while(of<dest_length){
    … …  
    335341 
    336342  Gamestate *gs = new Gamestate(*this);
    337   unsigned char *ndata = gs->data_ + sizeof(GamestateHeader);
     343  uint8_t *ndata = gs->data_ + sizeof(GamestateHeader);
    338344  synchronisableHeader *objectheader;
    339345  unsigned int objectOffset;
    … …  
    344350    unsigned int objectsize = objectheader->size;
    345351    assert(it->second->objectID==objectheader->objectID);
    346     objectOffset=sizeof(unsigned int)+sizeof(bool); //skip the size and the availableDate variables in the objectheader
     352    objectOffset=sizeof(uint8_t)+sizeof(bool); //skip the size and the availableDate variables in the objectheader
    347353    if(!it->second->doSelection(HEADER->id)){
    348354      while(objectOffset<objectsize){
    … …  
    370376  //preparations
    371377  std::map<unsigned int, Synchronisable *>::iterator it;
    372   unsigned char *origdata, *basedata, *destdata, *ndata;
     378  uint8_t *origdata, *basedata, *destdata, *ndata;
    373379  unsigned int objectOffset, streamOffset=0;    //data offset
    374380  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
    … …  
    378384  origdata = GAMESTATE_START(this->data_);
    379385  basedata = GAMESTATE_START(base->data_);
    380   ndata = new unsigned char[HEADER->datasize + sizeof(GamestateHeader)];
     386  ndata = new uint8_t[HEADER->datasize + sizeof(GamestateHeader)];
    381387  destdata = ndata + sizeof(GamestateHeader);
    382388 
    … …  
    390396    //copy and partially diff the object header
    391397    assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
    392     *(unsigned int*)destdata = *(unsigned int*)origdata; //size (do not diff)
    393     *(bool*)(destdata+sizeof(unsigned int)) = sendData;
     398    *(uint32_t*)destdata = *(uint32_t*)origdata; //size (do not diff)
     399    *(bool*)(destdata+sizeof(uint32_t)) = sendData;
    394400    if(sendData){
    395       *(unsigned int*)(destdata+sizeof(unsigned int)+sizeof(bool)) = *(unsigned int*)(basedata+sizeof(unsigned int)+sizeof(bool)) ^ *(unsigned int*)(origdata+sizeof(unsigned int)+sizeof(bool)); //objectid (diff it)
    396       *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = *(unsigned int*)(basedata+2*sizeof(unsigned int)+sizeof(bool)) ^ *(unsigned int*)(origdata+2*sizeof(unsigned int)+sizeof(bool)); //classid (diff it)
     401      *(uint32_t*)(destdata+sizeof(uint32_t)+sizeof(bool)) = *(uint32_t*)(basedata+sizeof(uint32_t)+sizeof(bool)) ^ *(uint32_t*)(origdata+sizeof(uint32_t)+sizeof(bool)); //objectid (diff it)
     402      *(uint32_t*)(destdata+2*sizeof(uint32_t)+sizeof(bool)) = *(uint32_t*)(basedata+2*sizeof(uint32_t)+sizeof(bool)) ^ *(uint32_t*)(origdata+2*sizeof(uint32_t)+sizeof(bool)); //classid (diff it)
    397403    }else{
    398       *(unsigned int*)(destdata+sizeof(unsigned int)+sizeof(bool)) = 0;
    399       *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = 0;
     404      *(uint32_t*)(destdata+sizeof(uint32_t)+sizeof(bool)) = 0;
     405      *(uint32_t*)(destdata+2*sizeof(uint32_t)+sizeof(bool)) = 0;
    400406    }
    401407    objectOffset=sizeof(synchronisableHeader);
    … …  
    408414        *(destdata+objectOffset)=*(basedata+objectOffset)^*(origdata+objectOffset); // do the xor
    409415      else if(sendData)
    410         *(destdata+objectOffset)=((unsigned char)0)^*(origdata+objectOffset); // xor with 0 (basestream is too short)
     416        *(destdata+objectOffset)=((uint8_t)0)^*(origdata+objectOffset); // xor with 0 (basestream is too short)
    411417      else
    412418        *(destdata+objectOffset)=0; // set to 0 because this object should not be transfered
    … …  
    438444  //preparations
    439445  std::map<unsigned int, Synchronisable *>::iterator it;
    440   unsigned char *origdata, *basedata, *destdata, *ndata;
     446  uint8_t *origdata, *basedata, *destdata, *ndata;
    441447  unsigned int objectOffset, streamOffset=0;    //data offset
    442448  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
    … …  
    446452  origdata = GAMESTATE_START(this->data_);
    447453  basedata = GAMESTATE_START(base->data_);
    448   ndata = new unsigned char[HEADER->datasize + sizeof(GamestateHeader)];
     454  ndata = new uint8_t[HEADER->datasize + sizeof(GamestateHeader)];
    449455  destdata = ndata + sizeof(GamestateHeader);
    450456 
    … …  
    502508  assert(!HEADER->compressed && !GAMESTATE_HEADER(base->data_)->compressed);
    503509  //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
    504   unsigned char *basep = GAMESTATE_START(base->data_);
    505   unsigned char *gs = GAMESTATE_START(this->data_);
     510  uint8_t *basep = GAMESTATE_START(base->data_);
     511  uint8_t *gs = GAMESTATE_START(this->data_);
    506512  unsigned int of=0; // pointers offset
    507513  unsigned int dest_length=0;
    … …  
    509515  if(dest_length==0)
    510516    return NULL;
    511   unsigned char *ndata = new unsigned char[dest_length*sizeof(unsigned char)+sizeof(GamestateHeader)];
    512   unsigned char *dest = ndata + sizeof(GamestateHeader);
     517  uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+sizeof(GamestateHeader)];
     518  uint8_t *dest = ndata + sizeof(GamestateHeader);
    513519  while(of < GAMESTATE_HEADER(base->data_)->datasize && of < HEADER->datasize){
    514520    *(dest+of)=*(basep+of)^*(gs+of); // do the xor
    … …  
    516522  }
    517523  if(GAMESTATE_HEADER(base->data_)->datasize!=HEADER->datasize){
    518     unsigned char n=0;
     524    uint8_t n=0;
    519525    if(GAMESTATE_HEADER(base->data_)->datasize < HEADER->datasize){
    520526      while(of < dest_length){
Note: See TracChangeset for help on using the changeset viewer.