Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/libraries/network/synchronisable/Synchronisable.cc @ 7324

Last change on this file since 7324 was 7183, checked in by rgrieder, 14 years ago

Removed a load of warnings for VS 2005 and possibly VS 2008.

  • Property svn:eol-style set to native
File size: 14.6 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 *      Dumeni Manatschal, (C) 2007
24 *      Oliver Scheuss, (C) 2007
25 *   Co-authors:
26 *      ...
27 *
28 */
29
30
31#include "Synchronisable.h"
32
33#include <cstdlib>
34#include "core/CoreIncludes.h"
35#include "core/GameMode.h"
36#include "core/BaseObject.h"
37#include "network/Host.h"
38
39namespace orxonox
40{
41
42  std::map<uint32_t, Synchronisable *> Synchronisable::objectMap_;
43  std::queue<uint32_t> Synchronisable::deletedObjects_;
44
45  uint8_t Synchronisable::state_=0x1; // detemines wheter we are server (default) or client
46
47  /**
48  * Constructor:
49  * Initializes all Variables and sets the right objectID_
50  */
51  Synchronisable::Synchronisable(BaseObject* creator )
52  {
53    RegisterRootObject(Synchronisable);
54    static uint32_t idCounter=0;
55    objectMode_=0x1; // by default do not send data to server
56    if ( GameMode::isMaster()/* || ( Host::running() && Host::isServer() )*/ )
57    {
58      this->setObjectID( idCounter++ );
59    }
60    else
61    {
62      objectID_=OBJECTID_UNKNOWN;
63    }
64    classID_ = static_cast<uint32_t>(-1);
65
66    // set dataSize to 0
67    this->dataSize_ = 0;
68    // set standard priority
69    this->setPriority( Priority::Normal );
70
71    // get creator id
72    if( creator )
73      this->creatorID_ = creator->getSceneID();
74    else
75      this->creatorID_ = OBJECTID_UNKNOWN;
76  }
77
78  /**
79   * Destructor:
80   * Delete all callback objects and remove objectID_ from the objectMap_
81   */
82  Synchronisable::~Synchronisable()
83  {
84    // delete callback function objects
85    if(!Identifier::isCreatingHierarchy()){
86      // remove object from the static objectMap
87      if (this->objectMode_ != 0x0 && (Host::running() && Host::isServer()))
88        deletedObjects_.push(objectID_);
89    }
90    // delete all Synchronisable Variables from syncList_ ( which are also in stringList_ )
91    for(std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin(); it!=syncList_.end(); it++)
92      delete (*it);
93    syncList_.clear();
94    stringList_.clear();
95    std::map<uint32_t, Synchronisable*>::iterator it2;
96    it2 = objectMap_.find(objectID_);
97    if (it2 != objectMap_.end())
98      objectMap_.erase(it2);
99
100  }
101
102
103  /**
104   * This function sets the internal mode for synchronisation
105   * @param b true if this object is located on a client or on a server
106   */
107  void Synchronisable::setClient(bool b)
108  {
109    if(b) // client
110      state_=0x2;
111    else  // server
112      state_=0x1;
113  }
114
115  /**
116   * This function fabricated a new synchrnisable (and children of it), sets calls updateData and create
117   * After calling this function the mem pointer will be increased by the size of the needed data
118   * @param mem pointer to where the appropriate data is located
119   * @param mode defines the mode, how the data should be loaded
120   * @return pointer to the newly created synchronisable
121   */
122  Synchronisable *Synchronisable::fabricate(uint8_t*& mem, uint8_t mode)
123  {
124    SynchronisableHeader header(mem);
125    assert( !header.isDiffed() );
126
127    COUT(4) << "fabricating object with id: " << header.getObjectID() << std::endl;
128
129    Identifier* id = ClassByID(header.getClassID());
130    if (!id)
131    {
132        for(int i = 0; i<160; i++)
133            COUT(0) << "classid: " << i << " identifier: " << ClassByID(i) << endl;
134        COUT(0) << "Assertion failed: id" << std::endl;
135        COUT(0) << "Possible reason for this error: Client received a synchronizable object whose class has no factory." << std::endl;
136        abort();
137    }
138    assert(id);
139    BaseObject* creator = 0;
140    if (header.getCreatorID() != OBJECTID_UNKNOWN)
141    {
142      Synchronisable* synchronisable_creator = Synchronisable::getSynchronisable(header.getCreatorID());
143      if (!synchronisable_creator)
144      {
145        mem += header.getDataSize()+SynchronisableHeader::getSize(); //.TODO: this suckz.... remove size from header
146        assert(0); // TODO: uncomment this if we have a clean objecthierarchy (with destruction of children of objects) ^^
147        return 0;
148      }
149      else
150        creator = orxonox_cast<BaseObject*>(synchronisable_creator);
151    }
152    assert(getSynchronisable(header.getObjectID())==0);   //make sure no object with this id exists
153    BaseObject *bo = id->fabricate(creator);
154    assert(bo);
155    Synchronisable *no = orxonox_cast<Synchronisable*>(bo);
156    assert(no);
157    assert( Synchronisable::objectMap_.find(header.getObjectID()) == Synchronisable::objectMap_.end() );
158    no->setObjectID(header.getObjectID());
159    //no->creatorID=header.getCreatorID(); //TODO: remove this
160    no->setClassID(header.getClassID());
161    assert(no->creatorID_ == header.getCreatorID());
162    if( creator )
163      bo->setLevel(creator->getLevel());          // Note: this ensures that the level is known on the client for child objects of the scene (and the scene itself)
164    //assert(no->classID_ == header.getClassID());
165    COUT(4) << "fabricate objectID_: " << no->objectID_ << " classID_: " << no->classID_ << std::endl;
166          // update data and create object/entity...
167    bool b = no->updateData(mem, mode, true);
168    assert(b);
169    if (b)
170    {
171//        b = no->create();
172        assert(b);
173    }
174    return no;
175  }
176
177
178  /**
179   * Finds and deletes the Synchronisable with the appropriate objectID_
180   * @param objectID_ objectID_ of the Synchronisable
181   * @return true/false
182   */
183  bool Synchronisable::deleteObject(uint32_t objectID_)
184  {
185    if(!getSynchronisable(objectID_))
186      return false;
187    assert(getSynchronisable(objectID_)->objectID_==objectID_);
188    Synchronisable *s = getSynchronisable(objectID_);
189    if(s)
190      s->destroy(); // or delete?
191    else
192      return false;
193    return true;
194  }
195
196  /**
197   * This function looks up the objectID_ in the objectMap_ and returns a pointer to the right Synchronisable
198   * @param objectID_ objectID_ of the Synchronisable
199   * @return pointer to the Synchronisable with the objectID_
200   */
201  Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID_)
202  {
203    std::map<uint32_t, Synchronisable*>::iterator it1;
204    it1 = objectMap_.find(objectID_);
205    if (it1 != objectMap_.end())
206      return it1->second;
207    // if the objects not in the map it should'nt exist at all anymore
208    return NULL;
209  }
210
211
212  /**
213   * This function takes all SynchronisableVariables out of the Synchronisable and saves them together with the size, objectID_ and classID_ to the given memory
214   * takes a pointer to already allocated memory (must have at least getSize bytes length)
215   * structure of the bitstream:
216   * |totalsize,objectID_,classID_,var1,var2,string1_length,string1,var3,...|
217   * length of varx: size saved int syncvarlist
218   * @param mem pointer to allocated memory with enough size
219   * @param id gamestateid of the gamestate to be saved (important for priorities)
220   * @param mode defines the direction in which the data will be send/received
221   *             0x1: server->client
222   *             0x2: client->server (not recommended)
223   *             0x3: bidirectional
224   * @return true: if !doSync or if everything was successfully saved
225   */
226  uint32_t Synchronisable::getData(uint8_t*& mem, std::vector<uint32_t>& sizes, int32_t id, uint8_t mode)
227  {
228    unsigned int test = 0;
229    if(mode==0x0)
230      mode=state_;
231    //if this tick is we dont synchronise, then abort now
232    if(!doSync(id, mode))
233      return 0;
234    uint32_t tempsize = 0;
235#ifndef NDEBUG
236    uint8_t* oldmem = mem;
237    if (this->classID_==0)
238      COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
239#endif
240
241    if (this->classID_ == static_cast<uint32_t>(-1))
242        this->classID_ = this->getIdentifier()->getNetworkID();
243
244    assert(ClassByID(this->classID_));
245    assert(this->classID_==this->getIdentifier()->getNetworkID());
246    assert(this->objectID_!=OBJECTID_UNKNOWN);
247    std::vector<SynchronisableVariableBase*>::iterator i;
248
249    // start copy header
250    SynchronisableHeader header(mem);
251    mem += SynchronisableHeader::getSize();
252    // end copy header
253
254    CCOUT(5) << "getting data from objectID_: " << objectID_ << ", classID_: " << classID_ << std::endl;
255//     COUT(4) << "objectid: " << this->objectID_ << ":";
256    // copy to location
257    for(i=syncList_.begin(); i!=syncList_.end(); ++i)
258    {
259      uint32_t varsize = (*i)->getData( mem, mode );
260//       COUT(4) << " " << varsize;
261      tempsize += varsize;
262      sizes.push_back(varsize);
263      ++test;
264      //tempsize += (*i)->getSize( mode );
265    }
266//     COUT(4) << endl;
267
268    header.setObjectID( this->objectID_ );
269    header.setCreatorID( this->creatorID_ );
270    header.setClassID( this->classID_ );
271    header.setDataSize( tempsize );
272    assert( tempsize == mem-oldmem-SynchronisableHeader::getSize() );
273    assert( test == this->getNrOfVariables() );
274    header.setDiffed(false);
275    tempsize += SynchronisableHeader::getSize();
276
277#ifndef NDEBUG
278    uint32_t size;
279    size=getSize(id, mode);
280    assert(tempsize==size);
281#endif
282    return tempsize;
283  }
284
285
286  /**
287   * This function takes a bytestream and loads the data into the registered variables
288   * @param mem pointer to the bytestream
289   * @param mode same as in getData
290   * @return true/false
291   */
292  bool Synchronisable::updateData(uint8_t*& mem, uint8_t mode, bool forceCallback)
293  {
294    if(mode==0x0)
295      mode=state_;
296    if(syncList_.empty())
297    {
298      assert(0);
299      COUT(2) << "Synchronisable::updateData syncList_ is empty" << std::endl;
300      return false;
301    }
302
303    uint8_t* data=mem;
304    // start extract header
305    SynchronisableHeaderLight syncHeaderLight(mem);
306    assert(syncHeaderLight.getObjectID()==this->getObjectID());
307
308    //COUT(5) << "Synchronisable: objectID_ " << syncHeader.getObjectID() << ", classID_ " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << std::endl;
309    if( !syncHeaderLight.isDiffed() )
310    {
311      SynchronisableHeader syncHeader2(mem);
312      assert( this->getClassID() == syncHeader2.getClassID() );
313      assert( this->getCreatorID() == syncHeader2.getCreatorID() );
314      mem += SynchronisableHeader::getSize();
315      std::vector<SynchronisableVariableBase *>::iterator i;
316      for(i=syncList_.begin(); i!=syncList_.end(); i++)
317      {
318        assert( mem <= data+syncHeader2.getDataSize()+SynchronisableHeader::getSize() ); // always make sure we don't exceed the datasize in our stream
319        (*i)->putData( mem, mode, forceCallback );
320      }
321      assert(mem == data+syncHeaderLight.getDataSize()+SynchronisableHeader::getSize() );
322    }
323    else
324    {
325      mem += SynchronisableHeaderLight::getSize();
326//       COUT(0) << "objectID: " << this->objectID_ << endl;
327      while( mem < data+syncHeaderLight.getDataSize()+SynchronisableHeaderLight::getSize() )
328      {
329        VariableID varID = *(VariableID*)mem;
330//         COUT(0) << "varID: " << varID << endl;
331        assert( varID < syncList_.size() );
332        mem += sizeof(VariableID);
333        syncList_[varID]->putData( mem, mode, forceCallback );
334      }
335      assert(mem == data+syncHeaderLight.getDataSize()+SynchronisableHeaderLight::getSize() );
336    }
337    return true;
338  }
339
340  /**
341  * This function returns the total amount of bytes needed by getData to save the whole content of the variables
342  * @param id id of the gamestate
343  * @param mode same as getData
344  * @return amount of bytes
345  */
346  uint32_t Synchronisable::getSize(int32_t id, uint8_t mode)
347  {
348    uint32_t tsize=SynchronisableHeader::getSize();
349    if (mode==0x0)
350      mode=state_;
351    if (!doSync(id, mode))
352      return 0;
353    assert( mode==state_ );
354    tsize += this->dataSize_;
355    std::vector<SynchronisableVariableBase*>::iterator i;
356    for(i=stringList_.begin(); i!=stringList_.end(); ++i)
357    {
358      tsize += (*i)->getSize( mode );
359    }
360    return tsize;
361  }
362
363  /**
364   * This function determines, wheter the object should be saved to the bytestream (according to its syncmode/direction)
365   * @param id gamestate id
366   * @return true/false
367   */
368  bool Synchronisable::doSync(int32_t id, uint8_t mode)
369  {
370    if(mode==0x0)
371      mode=state_;
372    return ( (this->objectMode_ & mode)!=0 && (!syncList_.empty() ) );
373  }
374
375  /**
376   * This function sets the synchronisation mode of the object
377   * If set to 0x0 variables will not be synchronised at all
378   * If set to 0x1 variables will only be synchronised to the client
379   * If set to 0x2 variables will only be synchronised to the server
380   * If set to 0x3 variables will be synchronised bidirectionally (only if set so in registerVar)
381   * @param mode same as in registerVar
382   */
383  void Synchronisable::setSyncMode(uint8_t mode)
384  {
385    assert(mode==0x0 || mode==0x1 || mode==0x2 || mode==0x3);
386    this->objectMode_=mode;
387  }
388
389  template <> void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
390  {
391    SynchronisableVariableBase* sv;
392    if (bidirectional)
393      sv = new SynchronisableVariableBidirectional<std::string>(variable, mode, cb);
394    else
395      sv = new SynchronisableVariable<std::string>(variable, mode, cb);
396    syncList_.push_back(sv);
397    stringList_.push_back(sv);
398  }
399
400template <> void Synchronisable::unregisterVariable( std::string& variable )
401  {
402    bool unregistered_nonexistent_variable = true;
403    std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin();
404    while(it!=syncList_.end())
405    {
406      if( ((*it)->getReference()) == &variable )
407      {
408        delete (*it);
409        syncList_.erase(it);
410        unregistered_nonexistent_variable = false;
411        break;
412      }
413      else
414        ++it;
415    }
416    assert(unregistered_nonexistent_variable == false);
417   
418    it = stringList_.begin();
419    while(it!=stringList_.end())
420    {
421      if( ((*it)->getReference()) == &variable )
422      {
423        delete (*it);
424        stringList_.erase(it);
425        return;
426      }
427      else
428        ++it;
429    }
430    unregistered_nonexistent_variable = true;
431    assert(unregistered_nonexistent_variable == false); //if we reach this point something went wrong:
432    // the variable has not been registered before
433  }
434
435
436}
Note: See TracBrowser for help on using the repository browser.