Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Nov 1, 2008, 7:04:09 PM (15 years ago)
Author:
landauf
Message:

merged objecthierarchy branch back to trunk

Location:
code/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • code/trunk

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

    r1907 r2087  
    4646#define HEADER GAMESTATE_HEADER(data_)
    4747
    48  
     48
    4949#define PACKET_FLAG_GAMESTATE  ENET_PACKET_FLAG_RELIABLE
    50  
     50
    5151Gamestate::Gamestate()
    5252{
    … …  
    8585    return false;
    8686  }
    87  
     87
    8888#ifndef NDEBUG
    8989  std::list<Synchronisable*> slist;
    … …  
    115115    slist.push_back(*it);
    116116#endif
    117    
     117
    118118    //if(it->doSelection(id))
    119119    dataMap_[mem-data_]=(*it);  // save the mem location of the synchronisable data
    … …  
    157157    if(!s)
    158158    {
    159       s = Synchronisable::fabricate(mem, mode);
    160       assert(s);
    161 //       if(!s)
    162 //         return false;
     159      Synchronisable::fabricate(mem, mode);
    163160    }
    164161    else
    … …  
    257254  HEADER->compressed = true;
    258255  assert(HEADER->compressed);
    259   COUT(3) << "gamestate compress datasize: " << HEADER->datasize << " compsize: " << HEADER->compsize << std::endl;
     256  COUT(4) << "gamestate compress datasize: " << HEADER->datasize << " compsize: " << HEADER->compsize << std::endl;
    260257  return true;
    261258}
    … …  
    264261  assert(HEADER);
    265262  assert(HEADER->compressed);
    266   COUT(3) << "GameStateClient: uncompressing gamestate. id: " << HEADER->id << ", baseid: " << HEADER->base_id << ", datasize: " << HEADER->datasize << ", compsize: " << HEADER->compsize << std::endl;
     263  COUT(4) << "GameStateClient: uncompressing gamestate. id: " << HEADER->id << ", baseid: " << HEADER->base_id << ", datasize: " << HEADER->datasize << ", compsize: " << HEADER->compsize << std::endl;
    267264  unsigned int datasize = HEADER->datasize;
    268265  unsigned int compsize = HEADER->compsize;
    269266  unsigned int bufsize;
    270   assert(compsize<=datasize);
     267//  assert(compsize<=datasize);
    271268  bufsize = datasize;
    272269  assert(bufsize!=0);
    … …  
    289286  //copy over the header
    290287  *GAMESTATE_HEADER(ndata) = *HEADER;
    291   //delete old (compressed data)
    292   delete[] data_;
     288
     289  if (this->bDataENetAllocated_){
     290    // Memory was allocated by ENet. --> We let it be since enet_packet_destroy will
     291    // deallocated it anyway. So data and packet stay together.
     292    this->bDataENetAllocated_ = false;
     293  }
     294  else{
     295    // We allocated the memory in the first place (unlikely). So we destroy the old data
     296    // and overwrite it with the new decompressed data.
     297    delete[] this->data_;
     298  }
     299
    293300  //set new pointers
    294301  data_ = ndata;
    … …  
    339346  assert(data_);
    340347  std::map<unsigned int, Synchronisable *>::iterator it;
    341  
     348
    342349  // allocate memory for new data
    343350  uint8_t *gdata = new uint8_t[HEADER->datasize+sizeof(GamestateHeader)];
    … …  
    346353  uint8_t *newdata = gdata + sizeof(GamestateHeader);
    347354  uint8_t *origdata = GAMESTATE_START(data_);
    348  
     355
    349356  //copy the GamestateHeader
    350357  *(GamestateHeader*)gdata = *HEADER;
    351  
     358
    352359  synchronisableHeader *oldobjectheader, *newobjectheader;
    353360  unsigned int objectOffset;
    354  
     361
    355362  //copy in the zeros
    356363  for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
    … …  
    360367    assert(it->second->objectID==oldobjectheader->objectID);
    361368    *newobjectheader = *oldobjectheader;
    362     objectOffset=sizeof(uint8_t)+sizeof(bool); //skip the size and the availableDate variables in the objectheader
     369    objectOffset=sizeof(uint8_t)+sizeof(bool); //skip the size and the availableData variables in the objectheader
    363370    if(it->second->doSelection(HEADER->id)){
    364371      newobjectheader->dataAvailable=true; //TODO: probably not neccessary
    … …  
    390397  assert(!HEADER->compressed);
    391398  assert(!HEADER->diffed);
    392  
     399
    393400  //preparations
    394401  std::map<unsigned int, Synchronisable *>::iterator it;
    395402  uint8_t *origdata, *basedata, *destdata, *ndata;
    396403  unsigned int objectOffset, streamOffset=0;    //data offset
    397   unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize; 
     404  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
    398405  synchronisableHeader *origheader;
    399406  synchronisableHeader *destheader;
    400  
     407
    401408  origdata = GAMESTATE_START(this->data_);
    402409  basedata = GAMESTATE_START(base->data_);
    403410  ndata = new uint8_t[HEADER->datasize + sizeof(GamestateHeader)];
    404411  destdata = ndata + sizeof(GamestateHeader);
    405  
     412
    406413  // do the diff
    407414  for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
    … …  
    410417    origheader = (synchronisableHeader *)(origdata+streamOffset);
    411418    destheader = (synchronisableHeader *)(destdata+streamOffset);
    412    
     419
    413420    //copy and partially diff the object header
    414421    assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
    … …  
    420427    }else{
    421428      *(uint32_t*)(destdata+sizeof(uint32_t)+sizeof(bool)) = 0;
    422       *(uint32_t*)(destdata+2*sizeof(uint32_t)+sizeof(bool)) = 0; 
     429      *(uint32_t*)(destdata+2*sizeof(uint32_t)+sizeof(bool)) = 0;
    423430    }
    424431    objectOffset=sizeof(synchronisableHeader);
    425432    streamOffset+=sizeof(synchronisableHeader);
    426    
     433
    427434    //now handle the object data or fill with zeros
    428435    while(objectOffset<origheader->size ){
    429      
     436
    430437      if(sendData && streamOffset<minsize)
    431438        *(destdata+objectOffset)=*(basedata+objectOffset)^*(origdata+objectOffset); // do the xor
    … …  
    434441      else
    435442        *(destdata+objectOffset)=0; // set to 0 because this object should not be transfered
    436      
     443
    437444      objectOffset++;
    438445      streamOffset++;
    … …  
    442449    basedata+=objectOffset;
    443450  }
    444  
     451
    445452  //copy over the gamestate header and set the diffed flag
    446453  *(GamestateHeader *)ndata = *HEADER; //copy over the header
    … …  
    458465  assert(!HEADER->compressed);
    459466  assert(HEADER->diffed);
    460  
     467
    461468  //preparations
    462469  std::map<unsigned int, Synchronisable *>::iterator it;
    463470  uint8_t *origdata, *basedata, *destdata, *ndata;
    464471  unsigned int objectOffset, streamOffset=0;    //data offset
    465   unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize; 
     472  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
    466473  synchronisableHeader *origheader;
    467474  synchronisableHeader *destheader;
    468  
     475
    469476  origdata = GAMESTATE_START(this->data_);
    470477  basedata = GAMESTATE_START(base->data_);
    471478  ndata = new uint8_t[HEADER->datasize + sizeof(GamestateHeader)];
    472479  destdata = ndata + sizeof(GamestateHeader);
    473  
     480
    474481  // do the undiff
    475482  for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
    … …  
    478485    destheader = (synchronisableHeader *)(destdata+streamOffset);
    479486    bool sendData;
    480    
     487
    481488    //copy and partially diff the object header
    482489    assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
    … …  
    489496    }else{
    490497      *(unsigned int*)(destdata+sizeof(unsigned int)+sizeof(bool)) = 0;
    491       *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = 0; 
     498      *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = 0;
    492499    }
    493500    objectOffset=sizeof(synchronisableHeader);
    494501    streamOffset+=sizeof(synchronisableHeader);
    495    
     502
    496503    //now handle the object data or fill with zeros
    497504    while(objectOffset<origheader->size ){
    498      
     505
    499506      if(sendData && streamOffset<minsize)
    500507        *(destdata+objectOffset)=*(basedata+objectOffset)^*(origdata+objectOffset); // do the xor
    … …  
    503510      else
    504511        *(destdata+objectOffset)=0; // set to 0 because this object should not be transfered
    505      
     512
    506513      objectOffset++;
    507514      streamOffset++;
    … …  
    511518    basedata+=objectOffset;
    512519  }
    513  
     520
    514521  //copy over the gamestate header and set the diffed flag
    515522  *(GamestateHeader *)ndata = *HEADER; //copy over the header
Note: See TracChangeset for help on using the changeset viewer.