Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 4384 was 3325, checked in by rgrieder, 15 years ago

Merged orxonox_cast related revisions from core4 back to trunk.

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