Changeset 2309 for code/branches/network64/src/network

Timestamp:

Dec 2, 2008, 9:10:00 PM (16 years ago)

Author:

scheusso

Message:

made some adjustments mostly to the networkid (classid) in order to have it platform independent

Location:

code/branches/network64/src/network

Files:

• GamestateClient.cc (modified) (2 diffs)
• GamestateManager.cc (modified) (2 diffs)
• NetworkPrereqs.h (modified) (1 diff)
• packet/Gamestate.cc (modified) (13 diffs)
• packet/Gamestate.h (modified) (1 diff)
• synchronisable/CMakeLists.txt (modified) (1 diff)
• synchronisable/NetworkCallback.h (modified) (2 diffs)
• synchronisable/Synchronisable.cc (modified) (11 diffs)
• synchronisable/Synchronisable.h (modified) (4 diffs)
• synchronisable/SynchronisableSpecialisations.cc (modified) (5 diffs)
• synchronisable/SynchronisableVariable.cc (modified) (1 diff)
• synchronisable/SynchronisableVariable.h (modified) (4 diffs)

code/branches/network64/src/network/GamestateClient.cc

@@ -36 +36 @@
 #include "core/Iterator.h"
 #include "synchronisable/Synchronisable.h"
+#include "synchronisable/NetworkCallbackManager.h"
 #include "packet/Acknowledgement.h"
 
@@ -77 +78 @@
     packet::Gamestate *processed = processGamestate(tempGamestate_);
 //    assert(processed);
+    
+    //now call the queued callbacks
+    NetworkCallbackManager::callCallbacks();
+    
     if (!processed)
         return false;

code/branches/network64/src/network/GamestateManager.cc

@@ -50 +50 @@
 #include "ClientInformation.h"
 #include "synchronisable/Synchronisable.h"
+#include "synchronisable/NetworkCallbackManager.h"
 
 namespace orxonox
@@ -86 +87 @@
     // now clear the queue
     gamestateQueue.clear();
+    //and call all queued callbacks
+    NetworkCallbackManager::callCallbacks();
     return true;
   }

code/branches/network64/src/network/NetworkPrereqs.h

@@ -71 +71 @@
   class GamestateHandler;
   class NetworkCallbackBase;
+  template <class T> class NetworkCallback;
+  class NetworkCallbackManager;
   class PacketBuffer;
   class Server;

code/branches/network64/src/network/packet/Gamestate.cc

@@ -73 +73 @@
 bool Gamestate::collectData(int id, uint8_t mode)
 {
-  unsigned int tempsize=0, currentsize=0;
+  uint32_t tempsize=0, currentsize=0;
   assert(data_==0);
-  unsigned int size = calcGamestateSize(id, mode);
+  uint32_t size = calcGamestateSize(id, mode);
 
   COUT(4) << "G.ST.Man: producing gamestate with id: " << id << std::endl;
@@ -166 +166 @@
 }
 
-unsigned int Gamestate::getSize() const
+uint32_t Gamestate::getSize() const
 {
   assert(data_);
@@ -251 +251 @@
   assert(HEADER->compressed);
   COUT(4) << "GameStateClient: uncompressing gamestate. id: " << HEADER->id << ", baseid: " << HEADER->base_id << ", datasize: " << HEADER->datasize << ", compsize: " << HEADER->compsize << std::endl;
-  unsigned int datasize = HEADER->datasize;
-  unsigned int compsize = HEADER->compsize;
-  unsigned int bufsize;
+  uint32_t datasize = HEADER->datasize;
+  uint32_t compsize = HEADER->compsize;
+  uint32_t bufsize;
 //  assert(compsize<=datasize);
   bufsize = datasize;
@@ -302 +302 @@
   //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
   uint8_t *basep = GAMESTATE_START(base->data_), *gs = GAMESTATE_START(this->data_);
-  unsigned int of=0; // pointers offset
-  unsigned int dest_length=0;
+  uint32_t of=0; // pointers offset
+  uint32_t dest_length=0;
   dest_length=HEADER->datasize;
   if(dest_length==0)
@@ -334 +334 @@
 Gamestate* Gamestate::doSelection(unsigned int clientID){
   assert(data_);
-  std::map<unsigned int, Synchronisable *>::iterator it;
+  std::map<uint32_t, Synchronisable *>::iterator it;
 
   // allocate memory for new data
@@ -347 +347 @@
 
   synchronisableHeader *oldobjectheader, *newobjectheader;
-  unsigned int objectOffset;
+  uint32_t objectOffset;
 
   //copy in the zeros
@@ -353 +353 @@
     oldobjectheader = (synchronisableHeader*)origdata;
     newobjectheader = (synchronisableHeader*)newdata;
-    unsigned int objectsize = oldobjectheader->size;
+    uint32_t objectsize = oldobjectheader->size;
     assert(it->second->objectID==oldobjectheader->objectID);
     *newobjectheader = *oldobjectheader;
@@ -382 +382 @@
 
   //preparations
-  std::map<unsigned int, Synchronisable *>::iterator it;
+  std::map<uint32_t, Synchronisable *>::iterator it;
   uint8_t *origdata, *basedata, *destdata, *ndata;
-  unsigned int objectOffset, streamOffset=0;    //data offset
-  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
+  uint32_t objectOffset, streamOffset=0;    //data offset
+  uint32_t minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
   synchronisableHeader *origheader;
   synchronisableHeader *destheader;
@@ -402 +402 @@
 
     //copy and partially diff the object header
-    assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
+    assert(sizeof(synchronisableHeader)==3*sizeof(uint32_t)+sizeof(bool));
     *(uint32_t*)destdata = *(uint32_t*)origdata; //size (do not diff)
     *(bool*)(destdata+sizeof(uint32_t)) = sendData;
@@ -450 +450 @@
 
   //preparations
-  std::map<unsigned int, Synchronisable *>::iterator it;
+  std::map<uint32_t, Synchronisable *>::iterator it;
   uint8_t *origdata, *basedata, *destdata, *ndata;
-  unsigned int objectOffset, streamOffset=0;    //data offset
-  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
+  uint32_t objectOffset, streamOffset=0;    //data offset
+  uint32_t minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
   synchronisableHeader *origheader;
   synchronisableHeader *destheader;
@@ -470 +470 @@
 
     //copy and partially diff the object header
-    assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
-    *(unsigned int*)destdata = *(unsigned int*)origdata; //size (do not diff)
-    *(bool*)(destdata+sizeof(unsigned int)) = *(bool*)(origdata+sizeof(unsigned int));
-    sendData = *(bool*)(origdata+sizeof(unsigned int));
+    assert(sizeof(synchronisableHeader)==3*sizeof(uint32_t)+sizeof(bool));
+    *(uint32_t*)destdata = *(uint32_t*)origdata; //size (do not diff)
+    *(bool*)(destdata+sizeof(uint32_t)) = *(bool*)(origdata+sizeof(uint32_t));
+    sendData = *(bool*)(origdata+sizeof(uint32_t));
     if(sendData){
-      *(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)
-      *(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)
+      *(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)
+      *(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)
     }else{
-      *(unsigned int*)(destdata+sizeof(unsigned int)+sizeof(bool)) = 0;
-      *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = 0;
+      *(uint32_t*)(destdata+sizeof(uint32_t)+sizeof(bool)) = 0;
+      *(uint32_t*)(destdata+2*sizeof(uint32_t)+sizeof(bool)) = 0;
     }
     objectOffset=sizeof(synchronisableHeader);
@@ -517 +517 @@
   uint8_t *basep = GAMESTATE_START(base->data_);
   uint8_t *gs = GAMESTATE_START(this->data_);
-  unsigned int of=0; // pointers offset
-  unsigned int dest_length=0;
+  uint32_t of=0; // pointers offset
+  uint32_t dest_length=0;
   dest_length=HEADER->datasize;
   if(dest_length==0)
@@ -548 +548 @@
 
 
-unsigned int Gamestate::calcGamestateSize(unsigned int id, uint8_t mode)
-{
-  unsigned int size=0;
+uint32_t Gamestate::calcGamestateSize(int32_t id, uint8_t mode)
+{
+  uint32_t size=0;
     // get the start of the Synchronisable list
   ObjectList<Synchronisable>::iterator it;

code/branches/network64/src/network/packet/Gamestate.h

@@ -85 +85 @@
     // Packet functions
   private:
-    virtual unsigned int getSize() const;
+    virtual uint32_t getSize() const;
     virtual bool process();
 
     bool operator ==(packet::Gamestate gs);
   private:
-    unsigned int calcGamestateSize(unsigned int id, uint8_t mode=0x0);
+    uint32_t calcGamestateSize(int32_t id, uint8_t mode=0x0);
     void removeObject(ObjectListIterator<Synchronisable> &it);
-    std::map<unsigned int, Synchronisable*> dataMap_;
+    std::map<uint32_t, Synchronisable*> dataMap_;
 };
 

code/branches/network64/src/network/synchronisable/CMakeLists.txt

@@ -1 +1 @@
 SET( SRC_FILES
+  NetworkCallbackManager.cc
   Synchronisable.cc
   SynchronisableSpecialisations.cc

code/branches/network64/src/network/synchronisable/NetworkCallback.h

@@ +1 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Oliver Scheuss, (C) 2008
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+
 #ifndef _NETWORK_CALLBACK__
 #define _NETWORK_CALLBACK__
 
 #include "network/NetworkPrereqs.h"
+#include "NetworkCallbackManager.h"
 
 namespace orxonox{
+  
   class _NetworkExport NetworkCallbackBase
   {
     public:
       virtual void call() = 0;
-          virtual ~NetworkCallbackBase() {}
+      NetworkCallbackBase(){ NetworkCallbackManager::registerCallback( this ); }
+      virtual ~NetworkCallbackBase() {}
   };
 
@@ -26 +58 @@
   };
 
-
 }
 

code/branches/network64/src/network/synchronisable/Synchronisable.cc

@@ -55 +55 @@
 
 
-  std::map<unsigned int, Synchronisable *> Synchronisable::objectMap_;
-  std::queue<unsigned int> Synchronisable::deletedObjects_;
+  std::map<uint32_t, Synchronisable *> Synchronisable::objectMap_;
+  std::queue<uint32_t> Synchronisable::deletedObjects_;
 
   uint8_t Synchronisable::state_=0x1; // detemines wheter we are server (default) or client
@@ -77 +77 @@
     else
       objectID=OBJECTID_UNKNOWN;
-    classID = (unsigned int)-1;
+    classID = static_cast<uint32_t>(-1);
 
 
@@ -122 +122 @@
 //       objectMap_.erase(objectID);
     }
-    std::map<unsigned int, Synchronisable*>::iterator it;
+    std::map<uint32_t, Synchronisable*>::iterator it;
     it = objectMap_.find(objectID);
     if (it != objectMap_.end())
@@ -199 +199 @@
    * @return true/false
    */
-  bool Synchronisable::deleteObject(unsigned int objectID){
+  bool Synchronisable::deleteObject(uint32_t objectID){
 //     assert(getSynchronisable(objectID));
     if(!getSynchronisable(objectID))
@@ -218 +218 @@
    * @return pointer to the Synchronisable with the objectID
    */
-  Synchronisable* Synchronisable::getSynchronisable(unsigned int objectID){
-    std::map<unsigned int, Synchronisable*>::iterator it1;
+  Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID){
+    std::map<uint32_t, Synchronisable*>::iterator it1;
     it1 = objectMap_.find(objectID);
     if (it1 != objectMap_.end())
@@ -295 +295 @@
    * @return true: if !doSync or if everything was successfully saved
    */
-  bool Synchronisable::getData(uint8_t*& mem, unsigned int id, uint8_t mode){
+  bool Synchronisable::getData(uint8_t*& mem, int32_t id, uint8_t mode){
     if(mode==0x0)
       mode=state_;
@@ -302 +302 @@
       return true;
     //std::cout << "inside getData" << std::endl;
-    unsigned int tempsize = 0;
+    uint32_t tempsize = 0;
     if(classID==0)
       COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
 
-    if (this->classID == (unsigned int)-1)
+    if (this->classID == static_cast<uint32_t>(-1))
         this->classID = this->getIdentifier()->getNetworkID();
 
@@ -312 +312 @@
 //     this->classID=this->getIdentifier()->getNetworkID(); // TODO: correct this
     std::list<SynchronisableVariableBase*>::iterator i;
-    unsigned int size;
+    uint32_t size;
     size=getSize(id, mode);
 
@@ -384 +384 @@
   * @return amount of bytes
   */
-  uint32_t Synchronisable::getSize(unsigned int id, uint8_t mode){
+  uint32_t Synchronisable::getSize(int32_t id, uint8_t mode){
     int tsize=sizeof(synchronisableHeader);
     if(mode==0x0)
@@ -402 +402 @@
    * @return true/false
    */
-  bool Synchronisable::doSync(unsigned int id, uint8_t mode){
+  bool Synchronisable::doSync(int32_t id, uint8_t mode){
     if(mode==0x0)
       mode=state_;
@@ -408 +408 @@
   }
 
-  bool Synchronisable::doSelection(unsigned int id){
+  bool Synchronisable::doSelection(int32_t id){
     return true; //TODO: change this
     //return ( id==0 || id%objectFrequency_==objectID%objectFrequency_ ) && ((objectMode_&state_)!=0);

code/branches/network64/src/network/synchronisable/Synchronisable.h

@@ -53 +53 @@
 namespace orxonox
 {
-  static const unsigned int OBJECTID_UNKNOWN = (unsigned int)-1;
+  static const uint32_t OBJECTID_UNKNOWN = static_cast<uint32_t>(-1);
 
   namespace objectDirection{
@@ -86 +86 @@
 
     static Synchronisable *fabricate(uint8_t*& mem, uint8_t mode=0x0);
-    static bool deleteObject(unsigned int objectID);
-    static Synchronisable *getSynchronisable(unsigned int objectID);
+    static bool deleteObject(uint32_t objectID);
+    static Synchronisable *getSynchronisable(uint32_t objectID);
     static unsigned int getNumberOfDeletedObject(){ return deletedObjects_.size(); }
-    static unsigned int popDeletedObject(){ unsigned int i = deletedObjects_.front(); deletedObjects_.pop(); return i; }
+    static uint32_t popDeletedObject(){ uint32_t i = deletedObjects_.front(); deletedObjects_.pop(); return i; }
 
-    inline unsigned int getObjectID(){return objectID;}
-    inline unsigned int getClassID(){return classID;}
+    inline uint32_t getObjectID(){return objectID;}
+    inline uint32_t getClassID(){return classID;}
   protected:
     Synchronisable(BaseObject* creator);
@@ -103 +103 @@
 
   private:
-    bool getData(uint8_t*& men, unsigned int id, uint8_t mode=0x0);
-    uint32_t getSize(unsigned int id, uint8_t mode=0x0);
+    bool getData(uint8_t*& men, int32_t id, uint8_t mode=0x0);
+    uint32_t getSize(int32_t id, uint8_t mode=0x0);
     bool updateData(uint8_t*& mem, uint8_t mode=0x0, bool forceCallback=false);
     bool isMyData(uint8_t* mem);
-    bool doSelection(unsigned int id);
-    bool doSync(unsigned int id, uint8_t mode=0x0);
+    bool doSelection(int32_t id);
+    bool doSync(int32_t id, uint8_t mode=0x0);
 
-    unsigned int objectID;
-    unsigned int creatorID;
-    unsigned int classID;
+    uint32_t objectID;
+    uint32_t creatorID;
+    uint32_t classID;
 
     std::list<SynchronisableVariableBase*> syncList;
@@ -119 +119 @@
     unsigned int objectFrequency_;
     int objectMode_;
-    static std::map<unsigned int, Synchronisable *> objectMap_;
-    static std::queue<unsigned int> deletedObjects_;
+    static std::map<uint32_t, Synchronisable *> objectMap_;
+    static std::queue<uint32_t> deletedObjects_;
   };
   

code/branches/network64/src/network/synchronisable/SynchronisableSpecialisations.cc

@@ -37 +37 @@
   template <> void Synchronisable::registerVariable( const ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
   {
-    registerVariable(variable.r, mode, 0, bidirectional);
-    registerVariable(variable.g, mode, 0, bidirectional);
-    registerVariable(variable.b, mode, 0, bidirectional);
+    registerVariable(variable.r, mode, cb, bidirectional);
+    registerVariable(variable.g, mode, cb, bidirectional);
+    registerVariable(variable.b, mode, cb, bidirectional);
     registerVariable(variable.a, mode, cb, bidirectional);
   }
@@ -49 +49 @@
   template <> void Synchronisable::registerVariable( const Vector2& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
   {
-    registerVariable(variable.x, mode, 0, bidirectional);
+    registerVariable(variable.x, mode, cb, bidirectional);
     registerVariable(variable.y, mode, cb, bidirectional);
   }
@@ -59 +59 @@
   template <> void Synchronisable::registerVariable( const Vector3& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
   {
-    registerVariable(variable.x, mode, 0, bidirectional);
-    registerVariable(variable.y, mode, 0, bidirectional);
+    registerVariable(variable.x, mode, cb, bidirectional);
+    registerVariable(variable.y, mode, cb, bidirectional);
     registerVariable(variable.z, mode, cb, bidirectional);
   }
@@ -70 +70 @@
   template <> void Synchronisable::registerVariable( const Vector4& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
   {
-    registerVariable(variable.x, mode, 0, bidirectional);
-    registerVariable(variable.y, mode, 0, bidirectional);
-    registerVariable(variable.z, mode, 0, bidirectional);
+    registerVariable(variable.x, mode, cb, bidirectional);
+    registerVariable(variable.y, mode, cb, bidirectional);
+    registerVariable(variable.z, mode, cb, bidirectional);
     registerVariable(variable.w, mode, cb, bidirectional);
   }
@@ -87 +87 @@
   template <> void Synchronisable::registerVariable( const Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
   {
-    registerVariable(variable.w, mode, 0, bidirectional);
-    registerVariable(variable.x, mode, 0, bidirectional);
-    registerVariable(variable.y, mode, 0, bidirectional);
+    registerVariable(variable.x, mode, cb, bidirectional);
+    registerVariable(variable.y, mode, cb, bidirectional);
     registerVariable(variable.z, mode, cb, bidirectional);
+    registerVariable(variable.w, mode, cb, bidirectional);
   }
   template <> void Synchronisable::registerVariable( Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)

code/branches/network64/src/network/synchronisable/SynchronisableVariable.cc

@@ -64 +64 @@
 }
 
+// =========== char
+
+template <> uint32_t SynchronisableVariable<const char>::returnSize()
+{
+  return sizeof(uint8_t);
+}
+
+template <> void SynchronisableVariable<const char>::setAndIncrease( uint8_t*& mem )
+{
+  *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
+  mem += SynchronisableVariable<const char>::returnSize();
+}
+
+template <> void SynchronisableVariable<const char>::getAndIncrease( uint8_t*& mem )
+{
+  *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
+  mem += SynchronisableVariable<const char>::returnSize();
+}
+
+template <> bool SynchronisableVariable<const char>::checkEquality( uint8_t* mem )
+{
+  return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
+}
+
 // =========== unsigned char
 

code/branches/network64/src/network/synchronisable/SynchronisableVariable.h

@@ -39 +39 @@
 #include "core/CoreIncludes.h"
 #include "network/synchronisable/NetworkCallback.h"
+#include "network/synchronisable/NetworkCallbackManager.h"
 
 namespace orxonox{
@@ -119 +120 @@
   {
     if (this->callback_ != 0)
-      delete this->callback_;
+      NetworkCallbackManager::deleteCallback(this->callback_); //safe call for deletion
   }
 
@@ -146 +147 @@
   // now do a callback if neccessary
     if ( callback )
-      this->callback_->call();
+      NetworkCallbackManager::triggerCallback( this->callback_ );
+      //this->callback_->call();
   }
 
@@ -299 +301 @@
   // now do a callback if neccessary
       if ( callback )
-        this->callback_->call();
+        NetworkCallbackManager::triggerCallback( this->callback_ );
+        //this->callback_->call();
     }