Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 2132 was 2132, checked in by scheusso, 15 years ago

bidirectional synchronisation works now:
register variables with mode direction::serverMaster or direction::clientMaster
clientMaster: both sides may change the variable but the client is master
serverMaster: both sides may change the variable but the server is master

  • Property svn:eol-style set to native
File size: 19.5 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 orxonox {
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
49#define PACKET_FLAG_GAMESTATE  ENET_PACKET_FLAG_RELIABLE
50
51Gamestate::Gamestate()
52{
53  flags_ = flags_ | PACKET_FLAG_GAMESTATE;
54}
55
56Gamestate::Gamestate(uint8_t *data, unsigned int clientID):
57    Packet(data, clientID)
58{
59  flags_ = flags_ | PACKET_FLAG_GAMESTATE;
60}
61
62Gamestate::Gamestate(uint8_t *data)
63{
64  flags_ = flags_ | PACKET_FLAG_GAMESTATE;
65  data_=data;
66}
67
68
69Gamestate::~Gamestate()
70{
71}
72
73bool Gamestate::collectData(int id, uint8_t mode)
74{
75  unsigned int tempsize=0, currentsize=0;
76  assert(data_==0);
77  unsigned int size = calcGamestateSize(id, mode);
78
79  COUT(4) << "G.ST.Man: producing gamestate with id: " << id << std::endl;
80  if(size==0)
81    return false;
82  data_ = new unsigned char[size + sizeof(GamestateHeader)];
83  if(!data_){
84    COUT(2) << "GameStateManager: could not allocate memory" << std::endl;
85    return false;
86  }
87
88  //start collect data synchronisable by synchronisable
89  uint8_t *mem=data_;
90  mem+=sizeof(GamestateHeader);
91  ObjectList<Synchronisable>::iterator it;
92  for(it = ObjectList<Synchronisable>::begin(); it; ++it){
93    tempsize=it->getSize(id, mode);
94
95    if(currentsize+tempsize > size){
96      assert(0); // if we don't use multithreading this part shouldn't be neccessary
97      // start allocate additional memory
98      COUT(3) << "G.St.Man: need additional memory" << std::endl;
99      ObjectList<Synchronisable>::iterator temp = it;
100      int addsize=tempsize;
101      while(++temp)
102        addsize+=temp->getSize(id, mode);
103      data_ = (uint8_t *)realloc(data_, sizeof(GamestateHeader) + currentsize + addsize);
104      if(!data_)
105        return false;
106      size = currentsize+addsize;
107    }// stop allocate additional memory
108
109
110    //if(it->doSelection(id))
111    dataMap_[mem-data_]=(*it);  // save the mem location of the synchronisable data
112    if(!it->getData(mem, id, mode))
113      return false; // mem pointer gets automatically increased because of call by reference
114    // increase size counter by size of current synchronisable
115    currentsize+=tempsize;
116  }
117
118
119  //start write gamestate header
120  HEADER->packetType = ENUM::Gamestate;
121  HEADER->datasize = currentsize;
122  HEADER->id = id;
123  HEADER->diffed = false;
124  HEADER->complete = true;
125  HEADER->compressed = false;
126  //stop write gamestate header
127
128  COUT(5) << "G.ST.Man: Gamestate size: " << currentsize << std::endl;
129  COUT(5) << "G.ST.Man: 'estimated' (and corrected) Gamestate size: " << size << std::endl;
130  return true;
131}
132
133bool Gamestate::spreadData(uint8_t mode)
134{
135  assert(data_);
136  assert(!HEADER->compressed);
137  assert(!HEADER->diffed);
138  uint8_t *mem=data_+sizeof(GamestateHeader);
139    // get the start of the Synchronisable list
140  //ObjectList<Synchronisable>::iterator it=ObjectList<Synchronisable>::begin();
141  Synchronisable *s;
142
143  // update the data of the objects we received
144  while(mem < data_+sizeof(GamestateHeader)+HEADER->datasize){
145    synchronisableHeader *objectheader = (synchronisableHeader*)mem;
146
147    s = Synchronisable::getSynchronisable( objectheader->objectID );
148    if(!s)
149    {
150      Synchronisable::fabricate(mem, mode);
151    }
152    else
153    {
154      bool b = s->updateData(mem, mode);
155      assert(b);
156    }
157  }
158
159  return true;
160}
161
162
163
164int Gamestate::getID(){
165  return HEADER->id;
166}
167
168unsigned int Gamestate::getSize() const
169{
170  assert(data_);
171  if(HEADER->compressed)
172    return HEADER->compsize+sizeof(GamestateHeader);
173  else
174  {
175    return HEADER->datasize+sizeof(GamestateHeader);
176  }
177}
178
179bool Gamestate::operator==(packet::Gamestate gs){
180  uint8_t *d1 = data_+sizeof(GamestateHeader);
181  uint8_t *d2 = gs.data_+sizeof(GamestateHeader);
182  assert(!isCompressed());
183  assert(!gs.isCompressed());
184  while(d1<data_+HEADER->datasize)
185  {
186    if(*d1!=*d2)
187      return false;
188    d1++;
189    d2++;
190  }
191  return true;
192}
193
194bool Gamestate::process()
195{
196  return GamestateHandler::addGamestate(this, getClientID());
197}
198
199
200
201bool Gamestate::compressData()
202{
203  assert(HEADER);
204  assert(!HEADER->compressed);
205  uLongf buffer = (uLongf)(((HEADER->datasize + 12)*1.01)+1);
206  if(buffer==0)
207    return false;
208
209  uint8_t *ndata = new uint8_t[buffer+sizeof(GamestateHeader)];
210  uint8_t *dest = GAMESTATE_START(ndata);
211  //unsigned char *dest = new unsigned char[buffer];
212  uint8_t *source = GAMESTATE_START(data_);
213  int retval;
214  retval = compress( dest, &buffer, source, (uLong)(HEADER->datasize) );
215  switch ( retval ) {
216    case Z_OK: COUT(5) << "G.St.Man: compress: successfully compressed" << std::endl; break;
217    case Z_MEM_ERROR: COUT(1) << "G.St.Man: compress: not enough memory available in gamestate.compress" << std::endl; return false;
218    case Z_BUF_ERROR: COUT(2) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << std::endl; return false;
219    case Z_DATA_ERROR: COUT(2) << "G.St.Man: compress: data corrupted in gamestate.compress" << std::endl; return false;
220  }
221#ifndef NDEBUG
222  //decompress and compare the start and the decompressed data
223  uint8_t *rdata = new uint8_t[HEADER->datasize+sizeof(GamestateHeader)];
224  uint8_t *d2 = GAMESTATE_START(rdata);
225  uLongf length2 = HEADER->datasize;
226  uncompress(d2, &length2, dest, buffer);
227  for(unsigned int i=0; i<HEADER->datasize; i++){
228    assert(*(source+i)==*(d2+i));
229  }
230  delete[] rdata;
231#endif
232
233  //copy and modify header
234#ifndef NDEBUG
235  HEADER->crc32 = calcCRC(data_+sizeof(GamestateHeader), HEADER->datasize);
236#endif
237  *GAMESTATE_HEADER(ndata) = *HEADER;
238  //delete old data
239  delete[] data_;
240  //save new data
241  data_ = ndata;
242  HEADER->compsize = buffer;
243  HEADER->compressed = true;
244  assert(HEADER->compressed);
245  COUT(4) << "gamestate compress datasize: " << HEADER->datasize << " compsize: " << HEADER->compsize << std::endl;
246  return true;
247}
248bool Gamestate::decompressData()
249{
250  assert(HEADER);
251  assert(HEADER->compressed);
252  COUT(4) << "GameStateClient: uncompressing gamestate. id: " << HEADER->id << ", baseid: " << HEADER->base_id << ", datasize: " << HEADER->datasize << ", compsize: " << HEADER->compsize << std::endl;
253  unsigned int datasize = HEADER->datasize;
254  unsigned int compsize = HEADER->compsize;
255  unsigned int bufsize;
256//  assert(compsize<=datasize);
257  bufsize = datasize;
258  assert(bufsize!=0);
259  uint8_t *ndata = new uint8_t[bufsize + sizeof(GamestateHeader)];
260  uint8_t *dest = ndata + sizeof(GamestateHeader);
261  uint8_t *source = data_ + sizeof(GamestateHeader);
262  int retval;
263  uLongf length=bufsize;
264  retval = uncompress( dest, &length, source, (uLong)compsize );
265  switch ( retval ) {
266    case Z_OK: COUT(5) << "successfully decompressed" << std::endl; break;
267    case Z_MEM_ERROR: COUT(1) << "not enough memory available" << std::endl; return false;
268    case Z_BUF_ERROR: COUT(2) << "not enough memory available in the buffer" << std::endl; return false;
269    case Z_DATA_ERROR: COUT(2) << "data corrupted (zlib)" << std::endl; return false;
270  }
271#ifndef NDEBUG
272  assert(HEADER->crc32==calcCRC(ndata+sizeof(GamestateHeader), HEADER->datasize));
273#endif
274
275  //copy over the header
276  *GAMESTATE_HEADER(ndata) = *HEADER;
277
278  if (this->bDataENetAllocated_){
279    // Memory was allocated by ENet. --> We let it be since enet_packet_destroy will
280    // deallocated it anyway. So data and packet stay together.
281    this->bDataENetAllocated_ = false;
282  }
283  else{
284    // We allocated the memory in the first place (unlikely). So we destroy the old data
285    // and overwrite it with the new decompressed data.
286    delete[] this->data_;
287  }
288
289  //set new pointers
290  data_ = ndata;
291  HEADER->compressed = false;
292  assert(HEADER->datasize==datasize);
293  assert(HEADER->compsize==compsize);
294  return true;
295}
296
297Gamestate *Gamestate::diff(Gamestate *base)
298{
299  assert(HEADER);
300  assert(!HEADER->compressed);
301  assert(!HEADER->diffed);
302  //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
303  uint8_t *basep = GAMESTATE_START(base->data_), *gs = GAMESTATE_START(this->data_);
304  unsigned int of=0; // pointers offset
305  unsigned int dest_length=0;
306  dest_length=HEADER->datasize;
307  if(dest_length==0)
308    return NULL;
309  uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+sizeof(GamestateHeader)];
310  uint8_t *dest = ndata + sizeof(GamestateHeader);
311  while(of < GAMESTATE_HEADER(base->data_)->datasize && of < HEADER->datasize){
312    *(dest+of)=*(basep+of)^*(gs+of); // do the xor
313    ++of;
314  }
315  if(GAMESTATE_HEADER(base->data_)->datasize!=HEADER->datasize){
316    uint8_t n=0;
317    if(GAMESTATE_HEADER(base->data_)->datasize < HEADER->datasize){
318      while(of<dest_length){
319        *(dest+of)=n^*(gs+of);
320        of++;
321      }
322    }
323  }
324
325  *GAMESTATE_HEADER(ndata) = *HEADER;
326  GAMESTATE_HEADER(ndata)->diffed = true;
327  GAMESTATE_HEADER(ndata)->base_id = base->getID();
328  Gamestate *g = new Gamestate(ndata, getClientID());
329  g->flags_=flags_;
330  g->packetDirection_ = packetDirection_;
331  return g;
332}
333
334Gamestate* Gamestate::doSelection(unsigned int clientID){
335  assert(data_);
336  std::map<unsigned int, Synchronisable *>::iterator it;
337
338  // allocate memory for new data
339  uint8_t *gdata = new uint8_t[HEADER->datasize+sizeof(GamestateHeader)];
340  // create a gamestate out of it
341  Gamestate *gs = new Gamestate(gdata);
342  uint8_t *newdata = gdata + sizeof(GamestateHeader);
343  uint8_t *origdata = GAMESTATE_START(data_);
344
345  //copy the GamestateHeader
346  *(GamestateHeader*)gdata = *HEADER;
347
348  synchronisableHeader *oldobjectheader, *newobjectheader;
349  unsigned int objectOffset;
350
351  //copy in the zeros
352  for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
353    oldobjectheader = (synchronisableHeader*)origdata;
354    newobjectheader = (synchronisableHeader*)newdata;
355    unsigned int objectsize = oldobjectheader->size;
356    assert(it->second->objectID==oldobjectheader->objectID);
357    *newobjectheader = *oldobjectheader;
358    objectOffset=sizeof(synchronisableHeader); //skip the size and the availableData variables in the objectheader
359    if(it->second->doSelection(HEADER->id)){
360      newobjectheader->dataAvailable=true; //TODO: probably not neccessary
361      while(objectOffset<objectsize){
362        *(newdata + objectOffset)=*(origdata + objectOffset);    // copy the data
363        objectOffset++;
364      }
365    }else{
366      newobjectheader->dataAvailable=false;
367      while(objectOffset<objectsize){
368        *(newdata+objectOffset)=0;    // set to 0
369        objectOffset++;
370      }
371      assert(objectOffset==objectsize);
372    }
373    newdata += objectsize;
374    origdata += objectsize;
375  }
376  return gs;
377}
378
379
380Gamestate* Gamestate::intelligentDiff(Gamestate *base, unsigned int clientID){
381  // asserts
382  assert(data_);
383  assert(base->data_);
384  assert(!GAMESTATE_HEADER(base->data_)->diffed);
385  assert(!GAMESTATE_HEADER(base->data_)->compressed);
386  assert(!HEADER->compressed);
387  assert(!HEADER->diffed);
388
389  //preparations
390  std::map<unsigned int, Synchronisable *>::iterator it;
391  uint8_t *origdata, *basedata, *destdata, *ndata;
392  unsigned int objectOffset, streamOffset=0;    //data offset
393  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
394  synchronisableHeader *origheader;
395  synchronisableHeader *destheader;
396
397  origdata = GAMESTATE_START(this->data_);
398  basedata = GAMESTATE_START(base->data_);
399  ndata = new uint8_t[HEADER->datasize + sizeof(GamestateHeader)];
400  destdata = ndata + sizeof(GamestateHeader);
401
402  // do the diff
403  for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
404    assert(streamOffset<HEADER->datasize);
405    bool sendData = it->second->doSelection(HEADER->id);
406    origheader = (synchronisableHeader *)(origdata+streamOffset);
407    destheader = (synchronisableHeader *)(destdata+streamOffset);
408
409    //copy and partially diff the object header
410    assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
411    *(uint32_t*)destdata = *(uint32_t*)origdata; //size (do not diff)
412    *(bool*)(destdata+sizeof(uint32_t)) = sendData;
413    if(sendData){
414      *(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)
415      *(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)
416    }else{
417      *(uint32_t*)(destdata+sizeof(uint32_t)+sizeof(bool)) = 0;
418      *(uint32_t*)(destdata+2*sizeof(uint32_t)+sizeof(bool)) = 0;
419    }
420    objectOffset=sizeof(synchronisableHeader);
421    streamOffset+=sizeof(synchronisableHeader);
422
423    //now handle the object data or fill with zeros
424    while(objectOffset<origheader->size ){
425
426      if(sendData && streamOffset<minsize)
427        *(destdata+objectOffset)=*(basedata+objectOffset)^*(origdata+objectOffset); // do the xor
428      else if(sendData)
429        *(destdata+objectOffset)=((uint8_t)0)^*(origdata+objectOffset); // xor with 0 (basestream is too short)
430      else
431        *(destdata+objectOffset)=0; // set to 0 because this object should not be transfered
432
433      objectOffset++;
434      streamOffset++;
435    }
436    destdata+=objectOffset;
437    origdata+=objectOffset;
438    basedata+=objectOffset;
439  }
440
441  //copy over the gamestate header and set the diffed flag
442  *(GamestateHeader *)ndata = *HEADER; //copy over the header
443  Gamestate *gs = new Gamestate(ndata);
444  GAMESTATE_HEADER(ndata)->diffed=true;
445  return gs;
446}
447
448Gamestate* Gamestate::intelligentUnDiff(Gamestate *base){
449  // asserts
450  assert(data_);
451  assert(base->data_);
452  assert(!GAMESTATE_HEADER(base->data_)->diffed);
453  assert(!GAMESTATE_HEADER(base->data_)->compressed);
454  assert(!HEADER->compressed);
455  assert(HEADER->diffed);
456
457  //preparations
458  std::map<unsigned int, Synchronisable *>::iterator it;
459  uint8_t *origdata, *basedata, *destdata, *ndata;
460  unsigned int objectOffset, streamOffset=0;    //data offset
461  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
462  synchronisableHeader *origheader;
463  synchronisableHeader *destheader;
464
465  origdata = GAMESTATE_START(this->data_);
466  basedata = GAMESTATE_START(base->data_);
467  ndata = new uint8_t[HEADER->datasize + sizeof(GamestateHeader)];
468  destdata = ndata + sizeof(GamestateHeader);
469
470  // do the undiff
471  for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
472    assert(streamOffset<HEADER->datasize);
473    origheader = (synchronisableHeader *)(origdata+streamOffset);
474    destheader = (synchronisableHeader *)(destdata+streamOffset);
475    bool sendData;
476
477    //copy and partially diff the object header
478    assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
479    *(unsigned int*)destdata = *(unsigned int*)origdata; //size (do not diff)
480    *(bool*)(destdata+sizeof(unsigned int)) = *(bool*)(origdata+sizeof(unsigned int));
481    sendData = *(bool*)(origdata+sizeof(unsigned int));
482    if(sendData){
483      *(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)
484      *(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)
485    }else{
486      *(unsigned int*)(destdata+sizeof(unsigned int)+sizeof(bool)) = 0;
487      *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = 0;
488    }
489    objectOffset=sizeof(synchronisableHeader);
490    streamOffset+=sizeof(synchronisableHeader);
491
492    //now handle the object data or fill with zeros
493    while(objectOffset<origheader->size ){
494
495      if(sendData && streamOffset<minsize)
496        *(destdata+objectOffset)=*(basedata+objectOffset)^*(origdata+objectOffset); // do the xor
497      else if(sendData)
498        *(destdata+objectOffset)=((unsigned char)0)^*(origdata+objectOffset); // xor with 0 (basestream is too short)
499      else
500        *(destdata+objectOffset)=0; // set to 0 because this object should not be transfered
501
502      objectOffset++;
503      streamOffset++;
504    }
505    destdata+=objectOffset;
506    origdata+=objectOffset;
507    basedata+=objectOffset;
508  }
509
510  //copy over the gamestate header and set the diffed flag
511  *(GamestateHeader *)ndata = *HEADER; //copy over the header
512  Gamestate *gs = new Gamestate(ndata);
513  GAMESTATE_HEADER(ndata)->diffed=false;
514  return gs;
515}
516
517Gamestate *Gamestate::undiff(Gamestate *base)
518{
519  assert(this && base);assert(HEADER);
520  assert(HEADER->diffed);
521  assert(!HEADER->compressed && !GAMESTATE_HEADER(base->data_)->compressed);
522  //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
523  uint8_t *basep = GAMESTATE_START(base->data_);
524  uint8_t *gs = GAMESTATE_START(this->data_);
525  unsigned int of=0; // pointers offset
526  unsigned int dest_length=0;
527  dest_length=HEADER->datasize;
528  if(dest_length==0)
529    return NULL;
530  uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+sizeof(GamestateHeader)];
531  uint8_t *dest = ndata + sizeof(GamestateHeader);
532  while(of < GAMESTATE_HEADER(base->data_)->datasize && of < HEADER->datasize){
533    *(dest+of)=*(basep+of)^*(gs+of); // do the xor
534    ++of;
535  }
536  if(GAMESTATE_HEADER(base->data_)->datasize!=HEADER->datasize){
537    uint8_t n=0;
538    if(GAMESTATE_HEADER(base->data_)->datasize < HEADER->datasize){
539      while(of < dest_length){
540        *(dest+of)=n^*(gs+of);
541        of++;
542      }
543    }
544  }
545  *GAMESTATE_HEADER(ndata) = *HEADER;
546  GAMESTATE_HEADER(ndata)->diffed = false;
547  Gamestate *g = new Gamestate(ndata, getClientID());
548  g->flags_=flags_;
549  g->packetDirection_ = packetDirection_;
550  assert(!g->isDiffed());
551  assert(!g->isCompressed());
552  return g;
553}
554
555
556unsigned int Gamestate::calcGamestateSize(unsigned int id, uint8_t mode)
557{
558  unsigned int size=0;
559    // get the start of the Synchronisable list
560  ObjectList<Synchronisable>::iterator it;
561    // get total size of gamestate
562  for(it = ObjectList<Synchronisable>::begin(); it; ++it)
563    size+=it->getSize(id, mode); // size of the actual data of the synchronisable
564//  size+=sizeof(GamestateHeader);
565  return size;
566}
567
568/**
569 * This function removes a Synchronisable out of the universe
570 * @param it iterator of the list pointing to the object
571 * @return iterator pointing to the next object in the list
572 */
573  void Gamestate::removeObject(ObjectList<Synchronisable>::iterator &it) {
574    ObjectList<Synchronisable>::iterator temp=it;
575    ++it;
576    delete  *temp;
577  }
578
579  bool Gamestate::isDiffed(){
580    return HEADER->diffed;
581  }
582
583  bool Gamestate::isCompressed(){
584    return HEADER->compressed;
585  }
586
587  int Gamestate::getBaseID(){
588    return HEADER->base_id;
589  }
590}
591
592}
Note: See TracBrowser for help on using the repository browser.