Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/network/src/network/packet/Gamestate.cc @ 1834

Last change on this file since 1834 was 1834, checked in by scheusso, 16 years ago

Fix in Projectiles (network fix)
different improvements in synchronisable and gamestates

  • Property svn:eol-style set to native
File size: 19.0 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Oliver Scheuss, (C) 2008
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#include "Gamestate.h"
30#include "network/ClientInformation.h"
31#include "network/GamestateHandler.h"
32#include "core/CoreIncludes.h"
33#include "core/Iterator.h"
34
35#include <zlib.h>
36#include <assert.h>
37
38
39
40namespace network {
41
42namespace packet {
43
44#define GAMESTATE_START(data) (data + sizeof(GamestateHeader))
45#define GAMESTATE_HEADER(data) ((GamestateHeader *)data)
46#define HEADER GAMESTATE_HEADER(data_)
47
48 
49Gamestate::Gamestate()
50{
51}
52
53Gamestate::Gamestate(unsigned char *data, int clientID):
54    Packet(data, clientID)
55{
56}
57
58Gamestate::Gamestate(unsigned char *data)
59{
60  data_=data;
61}
62
63
64Gamestate::~Gamestate()
65{
66}
67
68bool Gamestate::collectData(int id, int mode)
69{
70  int tempsize=0, currentsize=0;
71  assert(data_==0);
72  int size = calcGamestateSize(id, mode);
73
74  COUT(4) << "G.ST.Man: producing gamestate with id: " << id << std::endl;
75  if(size==0)
76    return false;
77  data_ = new unsigned char[size + sizeof(GamestateHeader)];
78  if(!data_){
79    COUT(2) << "GameStateManager: could not allocate memory" << std::endl;
80    return false;
81  }
82 
83#ifndef NDEBUG
84  std::list<Synchronisable*> slist;
85  std::list<Synchronisable*>::iterator iit;
86#endif
87  //start collect data synchronisable by synchronisable
88  unsigned char *mem=data_;
89  mem+=sizeof(GamestateHeader);
90  orxonox::ObjectList<Synchronisable>::iterator it;
91  for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
92    tempsize=it->getSize(id, mode);
93
94    if(currentsize+tempsize > size){
95      // start allocate additional memory
96      COUT(3) << "G.St.Man: need additional memory" << std::endl;
97      orxonox::ObjectList<Synchronisable>::iterator temp = it;
98      int addsize=tempsize;
99      while(++temp)
100        addsize+=temp->getSize(id, mode);
101      data_ = (unsigned char *)realloc(data_, sizeof(GamestateHeader) + currentsize + addsize);
102      if(!data_)
103        return false;
104      size = currentsize+addsize;
105    }// stop allocate additional memory
106
107#ifndef NDEBUG
108    for(iit=slist.begin(); iit!=slist.end(); iit++)
109      assert((*iit)!=*it);
110    slist.push_back(*it);
111#endif
112   
113    //if(it->doSelection(id))
114    dataMap_[mem-data_]=(*it);  // save the mem location of the synchronisable data
115    if(!it->getData(mem, id, mode))
116      return false; // mem pointer gets automatically increased because of call by reference
117    // increase size counter by size of current synchronisable
118    currentsize+=tempsize;
119  }
120
121
122  //start write gamestate header
123  HEADER->packetType = ENUM::Gamestate;
124  assert( *(ENUM::Type *)(data_) == ENUM::Gamestate);
125  HEADER->datasize = currentsize;
126  HEADER->id = id;
127  HEADER->diffed = false;
128  HEADER->complete = true;
129  HEADER->compressed = false;
130  //stop write gamestate header
131
132  COUT(5) << "G.ST.Man: Gamestate size: " << currentsize << std::endl;
133  COUT(5) << "G.ST.Man: 'estimated' (and corrected) Gamestate size: " << size << std::endl;
134  return true;
135}
136
137bool Gamestate::spreadData(int mode)
138{
139  assert(data_);
140  assert(!HEADER->compressed);
141  assert(!HEADER->diffed);
142  unsigned char *mem=data_+sizeof(GamestateHeader);
143    // get the start of the Synchronisable list
144  //orxonox::ObjectList<Synchronisable>::iterator it=orxonox::ObjectList<Synchronisable>::begin();
145  Synchronisable *s;
146
147  // update the data of the objects we received
148  while(mem < data_+sizeof(GamestateHeader)+HEADER->datasize){
149    synchronisableHeader *objectheader = (synchronisableHeader*)mem;
150
151    s = Synchronisable::getSynchronisable( objectheader->objectID );
152    if(!s)
153    {
154      s = Synchronisable::fabricate(mem, mode);
155      assert(s);
156//       if(!s)
157//         return false;
158    }
159    else
160    {
161      assert(s->updateData(mem, mode));
162      //if(!s->updateData(mem, mode))
163        //return false;
164    }
165  }
166
167  return true;
168}
169
170
171
172int Gamestate::getID(){
173  return HEADER->id;
174}
175
176unsigned int Gamestate::getSize() const
177{
178  assert(data_);
179  if(HEADER->compressed)
180    return HEADER->compsize+sizeof(GamestateHeader);
181  else
182  {
183    return HEADER->datasize+sizeof(GamestateHeader);
184  }
185}
186
187bool Gamestate::operator==(packet::Gamestate gs){
188  unsigned char *d1 = data_+sizeof(GamestateHeader);
189  unsigned char *d2 = gs.data_+sizeof(GamestateHeader);
190  assert(!isCompressed());
191  assert(!gs.isCompressed());
192  while(d1<data_+HEADER->datasize)
193  {
194    if(*d1!=*d2)
195      return false;
196    d1++;
197    d2++;
198  }
199  return true;
200}
201
202bool Gamestate::process()
203{
204  return GamestateHandler::addGamestate(this, getClientID());
205}
206
207
208
209bool Gamestate::compressData()
210{
211  assert(HEADER);
212  assert(!HEADER->compressed);
213  uLongf buffer = (uLongf)(((HEADER->datasize + 12)*1.01)+1);
214  if(buffer==0)
215    return false;
216
217  unsigned char *ndata = new unsigned char[buffer+sizeof(GamestateHeader)];
218  unsigned char *dest = GAMESTATE_START(ndata);
219  //unsigned char *dest = new unsigned char[buffer];
220  unsigned char *source = GAMESTATE_START(data_);
221  int retval;
222  retval = compress( dest, &buffer, source, (uLong)(HEADER->datasize) );
223  switch ( retval ) {
224    case Z_OK: COUT(5) << "G.St.Man: compress: successfully compressed" << std::endl; break;
225    case Z_MEM_ERROR: COUT(1) << "G.St.Man: compress: not enough memory available in gamestate.compress" << std::endl; return false;
226    case Z_BUF_ERROR: COUT(2) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << std::endl; return false;
227    case Z_DATA_ERROR: COUT(2) << "G.St.Man: compress: data corrupted in gamestate.compress" << std::endl; return false;
228  }
229#ifndef NDEBUG
230  //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);
233  uLongf length2 = HEADER->datasize;
234  uncompress(d2, &length2, dest, buffer);
235  for(unsigned int i=0; i<HEADER->datasize; i++){
236    assert(*(source+i)==*(d2+i));
237  }
238  delete[] rdata;
239#endif
240
241  //copy and modify header
242#ifndef NDEBUG
243  HEADER->crc32 = calcCRC(data_+sizeof(GamestateHeader), HEADER->datasize);
244#endif
245  *GAMESTATE_HEADER(ndata) = *HEADER;
246  //delete old data
247  delete[] data_;
248  //save new data
249  data_ = ndata;
250  HEADER->compsize = buffer;
251  HEADER->compressed = true;
252  assert(HEADER->compressed);
253  COUT(3) << "gamestate compress datasize: " << HEADER->datasize << " compsize: " << HEADER->compsize << std::endl;
254  return true;
255}
256bool Gamestate::decompressData()
257{
258  assert(HEADER);
259  assert(HEADER->compressed);
260  COUT(3) << "GameStateClient: uncompressing gamestate. id: " << HEADER->id << ", baseid: " << HEADER->base_id << ", datasize: " << HEADER->datasize << ", compsize: " << HEADER->compsize << std::endl;
261  unsigned int datasize = HEADER->datasize;
262  unsigned int compsize = HEADER->compsize;
263  unsigned int bufsize;
264  assert(compsize<=datasize);
265  bufsize = datasize;
266  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);
270  int retval;
271  uLongf length=bufsize;
272  retval = uncompress( dest, &length, source, (uLong)compsize );
273  switch ( retval ) {
274    case Z_OK: COUT(5) << "successfully decompressed" << std::endl; break;
275    case Z_MEM_ERROR: COUT(1) << "not enough memory available" << std::endl; return false;
276    case Z_BUF_ERROR: COUT(2) << "not enough memory available in the buffer" << std::endl; return false;
277    case Z_DATA_ERROR: COUT(2) << "data corrupted (zlib)" << std::endl; return false;
278  }
279#ifndef NDEBUG
280  assert(HEADER->crc32==calcCRC(ndata+sizeof(GamestateHeader), HEADER->datasize));
281#endif
282
283  //copy over the header
284  *GAMESTATE_HEADER(ndata) = *HEADER;
285  //delete old (compressed data)
286  delete[] data_;
287  //set new pointers
288  data_ = ndata;
289  HEADER->compressed = false;
290  assert(HEADER->datasize==datasize);
291  assert(HEADER->compsize==compsize);
292  return true;
293}
294
295Gamestate *Gamestate::diff(Gamestate *base)
296{
297  assert(HEADER);
298  assert(!HEADER->compressed);
299  assert(!HEADER->diffed);
300  //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
301  unsigned char *basep = GAMESTATE_START(base->data_), *gs = GAMESTATE_START(this->data_);
302  unsigned int of=0; // pointers offset
303  unsigned int dest_length=0;
304  dest_length=HEADER->datasize;
305  if(dest_length==0)
306    return NULL;
307  unsigned char *ndata = new unsigned char[dest_length*sizeof(unsigned char)+sizeof(GamestateHeader)];
308  unsigned char *dest = ndata + sizeof(GamestateHeader);
309  while(of < GAMESTATE_HEADER(base->data_)->datasize && of < HEADER->datasize){
310    *(dest+of)=*(basep+of)^*(gs+of); // do the xor
311    ++of;
312  }
313  if(GAMESTATE_HEADER(base->data_)->datasize!=HEADER->datasize){
314    unsigned char n=0;
315    if(GAMESTATE_HEADER(base->data_)->datasize < HEADER->datasize){
316      while(of<dest_length){
317        *(dest+of)=n^*(gs+of);
318        of++;
319      }
320    }
321  }
322
323  *GAMESTATE_HEADER(ndata) = *HEADER;
324  GAMESTATE_HEADER(ndata)->diffed = true;
325  GAMESTATE_HEADER(ndata)->base_id = base->getID();
326  Gamestate *g = new Gamestate(ndata, getClientID());
327  g->flags_=flags_;
328  g->packetDirection_ = packetDirection_;
329  return g;
330}
331
332Gamestate* Gamestate::doSelection(unsigned int clientID){
333  assert(data_);
334  std::map<unsigned int, Synchronisable *>::iterator it;
335 
336  Gamestate *gs = new Gamestate(*this);
337  unsigned char *ndata = gs->data_ + sizeof(GamestateHeader);
338  synchronisableHeader *objectheader;
339  unsigned int objectOffset;
340 
341  //copy in the zeros
342  for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
343    objectheader = (synchronisableHeader*)ndata;
344    unsigned int objectsize = objectheader->size;
345    assert(it->second->objectID==objectheader->objectID);
346    objectOffset=sizeof(unsigned int)+sizeof(bool); //skip the size and the availableDate variables in the objectheader
347    if(!it->second->doSelection(HEADER->id)){
348      while(objectOffset<objectsize){
349        objectheader->dataAvailable=false;
350        *(ndata+objectOffset)=0;    // set to 0
351        objectOffset++;
352      }
353      assert(objectOffset==objectsize);
354    }
355    ndata+=objectsize;
356  }
357  return gs;
358}
359
360
361Gamestate* Gamestate::intelligentDiff(Gamestate *base, unsigned int clientID){
362  // asserts
363  assert(data_);
364  assert(base->data_);
365  assert(!GAMESTATE_HEADER(base->data_)->diffed);
366  assert(!GAMESTATE_HEADER(base->data_)->compressed);
367  assert(!HEADER->compressed);
368  assert(!HEADER->diffed);
369 
370  //preparations
371  std::map<unsigned int, Synchronisable *>::iterator it;
372  unsigned char *origdata, *basedata, *destdata, *ndata;
373  unsigned int objectOffset, streamOffset=0;    //data offset
374  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize; 
375  synchronisableHeader *origheader;
376  synchronisableHeader *destheader;
377 
378  origdata = GAMESTATE_START(this->data_);
379  basedata = GAMESTATE_START(base->data_);
380  ndata = new unsigned char[HEADER->datasize + sizeof(GamestateHeader)];
381  destdata = ndata + sizeof(GamestateHeader);
382 
383  // do the diff
384  for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
385    assert(streamOffset<HEADER->datasize);
386    bool sendData = it->second->doSelection(HEADER->id);
387    origheader = (synchronisableHeader *)(origdata+streamOffset);
388    destheader = (synchronisableHeader *)(destdata+streamOffset);
389   
390    //copy and partially diff the object header
391    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;
394    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)
397    }else{
398      *(unsigned int*)(destdata+sizeof(unsigned int)+sizeof(bool)) = 0;
399      *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = 0; 
400    }
401    objectOffset=sizeof(synchronisableHeader);
402    streamOffset+=sizeof(synchronisableHeader);
403   
404    //now handle the object data or fill with zeros
405    while(objectOffset<origheader->size ){
406     
407      if(sendData && streamOffset<minsize)
408        *(destdata+objectOffset)=*(basedata+objectOffset)^*(origdata+objectOffset); // do the xor
409      else if(sendData)
410        *(destdata+objectOffset)=((unsigned char)0)^*(origdata+objectOffset); // xor with 0 (basestream is too short)
411      else
412        *(destdata+objectOffset)=0; // set to 0 because this object should not be transfered
413     
414      objectOffset++;
415      streamOffset++;
416    }
417    destdata+=objectOffset;
418    origdata+=objectOffset;
419    basedata+=objectOffset;
420  }
421 
422  //copy over the gamestate header and set the diffed flag
423  *(GamestateHeader *)ndata = *HEADER; //copy over the header
424  Gamestate *gs = new Gamestate(ndata);
425  GAMESTATE_HEADER(ndata)->diffed=true;
426  return gs;
427}
428
429Gamestate* Gamestate::intelligentUnDiff(Gamestate *base){
430  // asserts
431  assert(data_);
432  assert(base->data_);
433  assert(!GAMESTATE_HEADER(base->data_)->diffed);
434  assert(!GAMESTATE_HEADER(base->data_)->compressed);
435  assert(!HEADER->compressed);
436  assert(HEADER->diffed);
437 
438  //preparations
439  std::map<unsigned int, Synchronisable *>::iterator it;
440  unsigned char *origdata, *basedata, *destdata, *ndata;
441  unsigned int objectOffset, streamOffset=0;    //data offset
442  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize; 
443  synchronisableHeader *origheader;
444  synchronisableHeader *destheader;
445 
446  origdata = GAMESTATE_START(this->data_);
447  basedata = GAMESTATE_START(base->data_);
448  ndata = new unsigned char[HEADER->datasize + sizeof(GamestateHeader)];
449  destdata = ndata + sizeof(GamestateHeader);
450 
451  // do the undiff
452  for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
453    assert(streamOffset<HEADER->datasize);
454    origheader = (synchronisableHeader *)(origdata+streamOffset);
455    destheader = (synchronisableHeader *)(destdata+streamOffset);
456    bool sendData;
457   
458    //copy and partially diff the object header
459    assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
460    *(unsigned int*)destdata = *(unsigned int*)origdata; //size (do not diff)
461    *(bool*)(destdata+sizeof(unsigned int)) = *(bool*)(origdata+sizeof(unsigned int));
462    sendData = *(bool*)(origdata+sizeof(unsigned int));
463    if(sendData){
464      *(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)
465      *(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)
466    }else{
467      *(unsigned int*)(destdata+sizeof(unsigned int)+sizeof(bool)) = 0;
468      *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = 0; 
469    }
470    objectOffset=sizeof(synchronisableHeader);
471    streamOffset+=sizeof(synchronisableHeader);
472   
473    //now handle the object data or fill with zeros
474    while(objectOffset<origheader->size ){
475     
476      if(sendData && streamOffset<minsize)
477        *(destdata+objectOffset)=*(basedata+objectOffset)^*(origdata+objectOffset); // do the xor
478      else if(sendData)
479        *(destdata+objectOffset)=((unsigned char)0)^*(origdata+objectOffset); // xor with 0 (basestream is too short)
480      else
481        *(destdata+objectOffset)=0; // set to 0 because this object should not be transfered
482     
483      objectOffset++;
484      streamOffset++;
485    }
486    destdata+=objectOffset;
487    origdata+=objectOffset;
488    basedata+=objectOffset;
489  }
490 
491  //copy over the gamestate header and set the diffed flag
492  *(GamestateHeader *)ndata = *HEADER; //copy over the header
493  Gamestate *gs = new Gamestate(ndata);
494  GAMESTATE_HEADER(ndata)->diffed=false;
495  return gs;
496}
497
498Gamestate *Gamestate::undiff(Gamestate *base)
499{
500  assert(this && base);assert(HEADER);
501  assert(HEADER->diffed);
502  assert(!HEADER->compressed && !GAMESTATE_HEADER(base->data_)->compressed);
503  //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
504  unsigned char *basep = GAMESTATE_START(base->data_);
505  unsigned char *gs = GAMESTATE_START(this->data_);
506  unsigned int of=0; // pointers offset
507  unsigned int dest_length=0;
508  dest_length=HEADER->datasize;
509  if(dest_length==0)
510    return NULL;
511  unsigned char *ndata = new unsigned char[dest_length*sizeof(unsigned char)+sizeof(GamestateHeader)];
512  unsigned char *dest = ndata + sizeof(GamestateHeader);
513  while(of < GAMESTATE_HEADER(base->data_)->datasize && of < HEADER->datasize){
514    *(dest+of)=*(basep+of)^*(gs+of); // do the xor
515    ++of;
516  }
517  if(GAMESTATE_HEADER(base->data_)->datasize!=HEADER->datasize){
518    unsigned char n=0;
519    if(GAMESTATE_HEADER(base->data_)->datasize < HEADER->datasize){
520      while(of < dest_length){
521        *(dest+of)=n^*(gs+of);
522        of++;
523      }
524    }
525  }
526  *GAMESTATE_HEADER(ndata) = *HEADER;
527  GAMESTATE_HEADER(ndata)->diffed = false;
528  Gamestate *g = new Gamestate(ndata, getClientID());
529  g->flags_=flags_;
530  g->packetDirection_ = packetDirection_;
531  assert(!g->isDiffed());
532  assert(!g->isCompressed());
533  return g;
534}
535
536
537unsigned int Gamestate::calcGamestateSize(unsigned int id, int mode)
538{
539  int size=0;
540    // get the start of the Synchronisable list
541  orxonox::ObjectList<Synchronisable>::iterator it;
542    // get total size of gamestate
543  for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it)
544    size+=it->getSize(id, mode); // size of the actual data of the synchronisable
545//  size+=sizeof(GamestateHeader);
546  return size;
547}
548
549/**
550 * This function removes a Synchronisable out of the universe
551 * @param it iterator of the list pointing to the object
552 * @return iterator pointing to the next object in the list
553 */
554  void Gamestate::removeObject(orxonox::ObjectList<Synchronisable>::iterator &it) {
555    orxonox::ObjectList<Synchronisable>::iterator temp=it;
556    ++it;
557    delete  *temp;
558  }
559
560  bool Gamestate::isDiffed(){
561    return HEADER->diffed;
562  }
563
564  bool Gamestate::isCompressed(){
565    return HEADER->compressed;
566  }
567
568  int Gamestate::getBaseID(){
569    return HEADER->base_id;
570  }
571}
572
573}
Note: See TracBrowser for help on using the repository browser.