Changeset 7801 for code/trunk/src/libraries

code/trunk

Property svn:mergeinfo changed

/code/branches/masterserver (added)	merged: 7565-7566,7568-7569,7574,7580,7589-7590,7611,7630-7634,7650-7651,7657-7659,7661-7662,7665-7668,7672,7684,7688,7692,7717,7725,7727-7731,7733,7737-7738
/code/branches/network3 (added)	merged: 7333,7336-7337,7344
/code/branches/network4 (added)	merged: 7497,7718,7753-7755
/code/branches/network5 (added)	merged: 7757-7759,7772-7778,7780-7781
/code/branches/presentation	merged: 7736,7739-7741,7743-7752,7756,7760-7765,7768-7770,7779,7786
/code/branches/presentation2	merged: 7787-7788,7790-7800

code/trunk/src/libraries/core/GUIManager.cc

-                      r7709
+                      r7801
 #include "util/Exception.h"
 #include "util/OrxAssert.h"
+#include "ConfigValueIncludes.h"
 #include "Core.h"
+#include "CoreIncludes.h"
 #include "GraphicsManager.h"
 #include "LuaState.h"
 …
     GUIManager* GUIManager::singletonPtr_s = 0;
+    /*static*/ const std::string GUIManager::defaultScheme_ = "TaharezGreen";
     SetConsoleCommand("showGUI", &GUIManager::showGUI).defaultValue(1, false).defaultValue(2, false);
 …
         , camera_(NULL)
+    {
+        RegisterRootObject(GUIManager);
+        this->setConfigValues();
         using namespace CEGUI;
 …
     GUIManager::~GUIManager()
+    {
+    }
+    void GUIManager::setConfigValues(void)
+    {
+        SetConfigValue(guiScheme_, GUIManager::defaultScheme_) .description("Changes the current GUI scheme.") .callback(this, &GUIManager::changedGUIScheme);
+    }
+    void GUIManager::changedGUIScheme(void)
+    {
+    }

code/trunk/src/libraries/core/GUIManager.h

-                      r7648
+                      r7801
 #include "util/Singleton.h"
 #include "input/InputHandler.h"
+#include "OrxonoxClass.h"
 // Tolua includes (have to be relative to the current directory)
 …
     */
     class _CoreExport GUIManager // tolua_export
         : public Singleton<GUIManager>, public InputHandler
+        : public Singleton<GUIManager>, public InputHandler, public OrxonoxClass
     { // tolua_export
         friend class Singleton<GUIManager>;
 …
         GUIManager(const std::pair<int, int>& mousePosition);
         ~GUIManager();
+        void setConfigValues(void);
+        void changedGUIScheme(void);
         void preUpdate(const Clock& time);
 …
         static GUIManager*                   singletonPtr_s;    //!< Singleton reference to GUIManager
+        // The used CEGUI scheme.
+        static const std::string defaultScheme_;
+        std::string guiScheme_;
     }; // tolua_export
 } // tolua_export

code/trunk/src/libraries/network/CMakeLists.txt

-                      r7490
+                      r7801
   FunctionCallManager.cc
   GamestateManager.cc
   GamestateClient.cc
+  #GamestateClient.cc
   GamestateHandler.cc
   LANDiscoverable.cc
   LANDiscovery.cc
+  WANDiscoverable.cc
+  WANDiscovery.cc
+  MasterServerComm.cc
   NetworkFunction.cc
   Host.cc
   Server.cc
+  MasterServer.cc
+  PeerList.cc
+  ServerList.cc
   ServerConnection.cc
   TrafficControl.cc
 …
   FunctionCall.h
   FunctionCallManager.h
   GamestateClient.h
+  #GamestateClient.h
   GamestateHandler.h
   GamestateManager.h
 …
   LANDiscoverable.h
   LANDiscovery.h
+  WANDiscoverable.h
+  WANDiscovery.h
+  MasterServerComm.h
   NetworkFunction.h
   NetworkPrecompiledHeaders.h
   NetworkPrereqs.h
   Server.h
+  MasterServer.h
+  PeerList.h
+  ServerList.h
   ServerConnection.h
   TrafficControl.h
 …
     Client.h
     LANDiscovery.h
+    WANDiscovery.h
   PCH_FILE
     NetworkPrecompiledHeaders.h

code/trunk/src/libraries/network/Client.cc

-                      r7495
+                      r7801
   */
   Client::Client():
-      gamestate(0),
       isSynched_(false),
       gameStateFailure_(false),
 …
+  {
     Synchronisable::setClient(true);
-    this->gamestate = new GamestateClient();
     if( ClientConnection::establishConnection() )
+    {
       Host::setActive(true);
+      GamestateManager::addPeer(NETWORK_PEER_ID_SERVER);
       return true;
+    }
 …
   bool Client::closeConnection()
+  {
-    assert(this->gamestate);
-    delete this->gamestate;
-    this->gamestate = 0;
     Host::setActive(false);
+    GamestateManager::removePeer(NETWORK_PEER_ID_SERVER);
     return ClientConnection::closeConnection();
+  }
 …
+  }
+  bool Client::queuePacket(ENetPacket *packet, int clientID)
+  {
+    bool b = ClientConnection::addPacket(packet);
+    assert(b);
+    return b;
+  void Client::queuePacket(ENetPacket *packet, int clientID, uint8_t channelID)
+  {
+    ClientConnection::addPacket(packet, channelID);
+  }
 …
+  {
     packet::Chat *m = new packet::Chat(message, Host::getPlayerID());
     return m->send();
+    return m->send(static_cast<Host*>(this));
+  }
 …
+      {
         COUT(4) << "popping partial gamestate: " << std::endl;
+        packet::Gamestate *gs = gamestate->getGamestate();
+//         packet::Gamestate *gs = GamestateClient::getGamestate();
+        GamestateManager::update();
+        std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
+        std::vector<packet::Gamestate*>::iterator it;
+        for( it = gamestates.begin(); it != gamestates.end(); ++it )
+        {
+          (*it)->send( static_cast<Host*>(this) );
+        }
         //assert(gs); <--- there might be the case that no data has to be sent, so its commented out now
         if(gs){
           COUT(4) << "client tick: sending gs " << gs << std::endl;
           if( !gs->send() )
             COUT(3) << "Problem adding partial gamestate to queue" << std::endl;
         // gs gets automatically deleted by enet callback
+        }
         FunctionCallManager::sendCalls();
+//         if(gs){
+//           COUT(4) << "client tick: sending gs " << gs << std::endl;
+//           if( !gs->send() )
+//             COUT(2) << "Problem adding partial gamestate to queue" << std::endl;
+//         // gs gets automatically deleted by enet callback
+//         }
+        FunctionCallManager::sendCalls(static_cast<Host*>(this));
+      }
+    }
     sendPackets(); // flush the enet queue
+//     sendPackets(); // flush the enet queue
     Connection::processQueue();
     if(gamestate->processGamestates())
+    if(GamestateManager::processGamestates())
+    {
       FunctionCallManager::processBufferedFunctionCalls();
 …
         isSynched_=true;
+    }
     gamestate->cleanup();
     Connection::sendPackets();
+//     GamestateManager::cleanup();;
+//     Connection::sendPackets();
     return;
 …
     Game::getInstance().popState();
+  }
+  void Client::processPacket(packet::Packet* packet)
+  {
+    if( packet->isReliable() )
+    {
+      if( this->getLastProcessedGamestateID(packet->getPeerID()) >= packet->getRequiredGamestateID() )
+        packet->process(static_cast<Host*>(this));
+      else
+        this->packetQueue_.push_back(packet);
+    }
+    else
+      packet->process(static_cast<Host*>(this));
+  }

code/trunk/src/libraries/network/Client.h

-                      r7163
+                      r7801
 #include <string>
+#include <deque>
 #include "util/UtilPrereqs.h"
 #include "util/Singleton.h"
 #include "ClientConnection.h"
 #include "GamestateClient.h"
+// #include "GamestateClient.h"
 #include "Host.h"
 #include "LANDiscovery.h"
 …
     void setDestination( const std::string& serverAddress, unsigned int port ); // tolua_export
     bool closeConnection();
+    bool queuePacket(ENetPacket *packet, int clientID);
+    void queuePacket(ENetPacket* packet, int clientID, uint8_t channelID);
+    virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
     bool processChat(const std::string& message, unsigned int playerID);
     virtual bool chat(const std::string& message);
 …
     Client(const Client& copy); // not used
     virtual bool isServer_(){return false;}
+    void processPacket(packet::Packet* packet);
     static Client* singletonPtr_s;
-    GamestateClient* gamestate;
     bool isSynched_;
+    std::deque<packet::Packet*> packetQueue_;
     bool gameStateFailure_;

code/trunk/src/libraries/network/ClientConnection.cc

-                      r7459
+                      r7801
   const unsigned int NETWORK_CLIENT_CONNECTION_TIMEOUT = 3000; //millisecs
   const unsigned int NETWORK_CLIENT_MAX_CONNECTIONS = 1;
-  const unsigned int NETWORK_CLIENT_CHANNELS = 1;
 …
     ENetEvent event;
+    this->host_ = enet_host_create(NULL, NETWORK_CLIENT_MAX_CONNECTIONS, 0, 0, 0);
+    // create host
+    this->host_ = enet_host_create(NULL, NETWORK_CLIENT_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
     if ( this->host_ == NULL )
+    {
 …
       return false;
+    }
+    // enable compression
+    this->enableCompression();
     assert( this->host_->socket4 != ENET_SOCKET_NULL || this->host_->socket6 != ENET_SOCKET_NULL );
     if (this->host_->socket4 == ENET_SOCKET_NULL)
 …
         COUT(3) << "Info: Using IPv4 and IPv6 Sockets." << std::endl;
     this->server_ = enet_host_connect(this->host_, serverAddress_, NETWORK_CLIENT_CHANNELS, 0);
+    this->server_ = enet_host_connect(this->host_, serverAddress_, NETWORK_CHANNEL_COUNT, 0);
     if ( this->server_==NULL )
+    {
 …
+      {
         this->established_=true;
+        Connection::startCommunicationThread();
         return true;
+      }
 …
       return true;
     this->established_ = false;
+    Connection::stopCommunicationThread();
     enet_peer_disconnect(this->server_, 0);
     for( unsigned int i=0; i<NETWORK_CLIENT_CONNECTION_TIMEOUT/NETWORK_CLIENT_WAIT_TIME; i++)
 …
   bool ClientConnection::addPacket(ENetPacket *packet) {
+  void ClientConnection::addPacket(ENetPacket *packet, uint8_t channelID) {
     assert( this->server_ );
     assert( packet );
     return Connection::addPacket( packet, this->server_ );
+    return Connection::addPacket( packet, this->server_, channelID );
+  }
 …
     COUT(1) << "Received disconnect Packet from Server!" << endl;
         // server closed the connection
+    this->stopCommunicationThread();
     this->connectionClosed();
+  }

code/trunk/src/libraries/network/ClientConnection.h

-                      r6417
+                      r7801
     void setPort( unsigned int port );
     ENetEvent *getEvent();
+//     ENetEvent *getEvent();
     // check wheter the packet queue is empty
     bool queueEmpty();
+//     bool queueEmpty();
     // create a new listener thread
     virtual bool establishConnection();
     virtual bool closeConnection();
     // add a packet to queue for the server
     bool addPacket(ENetPacket *packet);
+    void addPacket(ENetPacket *packet, uint8_t channelID);
     inline bool isConnected(){ return this->established_; }
   protected:

code/trunk/src/libraries/network/ClientInformation.cc

-                      r7459
+                      r7801
     preve=0;
     nexte=0;
-    partialGamestateID_=GAMESTATEID_INITIAL-1;
     synched_=false;
+  }
 …
+  }
-  bool ClientInformation::setPartialGamestateID(int id){
-    if(!this)
-      return false;
-    partialGamestateID_=id;
-    return true;
+  }
   unsigned int ClientInformation::getID() {
     if(!this)
 …
+  }
-  int ClientInformation::getFailures(){
-    return failures_;
+  }
-  void ClientInformation::addFailure(){
-    failures_++;
+  }
-  void ClientInformation::resetFailures(){
-    failures_=0;
+  }
   uint32_t ClientInformation::getRTT(){
     return this->peer_->roundTripTime;
 …
     if(this)
       return gamestateID_;
-    else
-      return static_cast<unsigned int>(-1);
+  }
-  unsigned int ClientInformation::getPartialGamestateID() {
-    if(this)
-      return partialGamestateID_;
     else
       return static_cast<unsigned int>(-1);

code/trunk/src/libraries/network/ClientInformation.h

-                      r5781
+                      r7801
     bool setPeer(ENetPeer *peer);
     bool setGamestateID(int id);
-    bool setPartialGamestateID(int id);
     inline void setShipID(unsigned int id){ShipID_=id;}
 …
     unsigned int getID();
     unsigned int getGamestateID();
-    unsigned int getPartialGamestateID();
     ENetPeer *getPeer();
-    int getFailures();
-    void addFailure();
-    void resetFailures();
     uint32_t getRTT();
     double getPacketLoss();
 …
     unsigned int clientID_;
     unsigned int gamestateID_;
-    unsigned int partialGamestateID_;
     unsigned int ShipID_;   // this is the unique objectID
     bool synched_;
-    unsigned short failures_;
   };

code/trunk/src/libraries/network/Connection.cc

-                      r7163
+                      r7801
 #include <cassert>
+#include <deque>
 #define WIN32_LEAN_AND_MEAN
 #include <enet/enet.h>
+#include <boost/thread.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/date_time.hpp>
 #include "packet/Packet.h"
 namespace orxonox
+{
 //   Connection *Connection::instance_=0;
+  const boost::posix_time::millisec NETWORK_COMMUNICATION_THREAD_WAIT_TIME(20);
   Connection::Connection():
+    host_(0)
+  {
+//     assert(instance_==0);
+//     Connection::instance_=this;
+    host_(0), bCommunicationThreadRunning_(false)
+  {
     enet_initialize();
     atexit(enet_deinitialize);
+  }
+  Connection::~Connection(){
+//     Connection::instance_=0;
+  }
+  int Connection::service(ENetEvent* event) {
+    return enet_host_service( this->host_, event, NETWORK_WAIT_TIMEOUT );
+  }
+  void Connection::disconnectPeer(ENetPeer *peer) {
+    enet_peer_disconnect(peer, 0);
+  }
+  bool Connection::addPacket(ENetPacket *packet, ENetPeer *peer) {
+    if(enet_peer_send(peer, NETWORK_DEFAULT_CHANNEL, packet)!=0)
+      return false;
+    else
+      return true;
+  }
+  bool Connection::sendPackets() {
+    if ( /*!Connection::instance_ || */this->host_==NULL )
+      return false;
+    enet_host_flush(this->host_);
+    return true;
+  }
+  void Connection::processQueue() {
+    this->incomingEventsMutex_ = new boost::mutex;
+    this->outgoingEventsMutex_ = new boost::mutex;
+  }
+  Connection::~Connection()
+  {
+    delete this->incomingEventsMutex_;
+    delete this->outgoingEventsMutex_;
+  }
+  void Connection::startCommunicationThread()
+  {
+    this->bCommunicationThreadRunning_ = true;
+    this->communicationThread_ = new boost::thread(&Connection::communicationThread, this);
+  }
+  void Connection::stopCommunicationThread()
+  {
+    this->bCommunicationThreadRunning_ = false;
+    if( !this->communicationThread_->timed_join(NETWORK_COMMUNICATION_THREAD_WAIT_TIME) )
+    {
+      // force thread to stop
+      this->communicationThread_->interrupt();
+    }
+    delete this->communicationThread_;
+  }
+//   int Connection::service(ENetEvent* event) {
+//     return enet_host_service( this->host_, event, NETWORK_WAIT_TIMEOUT );
+//   }
+  void Connection::disconnectPeer(ENetPeer *peer)
+  {
+    assert(peer);
+    outgoingEvent outEvent = { peer, outgoingEventType::disconnectPeer, (ENetPacket*)10, 15 };
+    this->outgoingEventsMutex_->lock();
+    this->outgoingEvents_.push_back(outEvent);
+    this->outgoingEventsMutex_->unlock();
+  }
+  void Connection::addPacket(ENetPacket *packet, ENetPeer *peer, uint8_t channelID)
+  {
+    assert(peer);
+    outgoingEvent outEvent = { peer, outgoingEventType::sendPacket, packet, channelID };
+    this->outgoingEventsMutex_->lock();
+    this->outgoingEvents_.push_back(outEvent);
+    this->outgoingEventsMutex_->unlock();
+  }
+  void Connection::broadcastPacket(ENetPacket* packet, uint8_t channelID)
+  {
+    outgoingEvent outEvent = { (ENetPeer*)15, outgoingEventType::broadcastPacket, packet, channelID };
+    this->outgoingEventsMutex_->lock();
+    this->outgoingEvents_.push_back(outEvent);
+    this->outgoingEventsMutex_->unlock();
+  }
+  void Connection::communicationThread()
+  {
     ENetEvent event;
+    assert(this->host_);
+    while( enet_host_service( this->host_, &event, NETWORK_WAIT_TIMEOUT ) > 0 )
+    while( bCommunicationThreadRunning_ )
+    {
+      switch(event.type){
+      // Receive all pending incoming Events (such as packets, connects and disconnects)
+      while( enet_host_check_events( this->host_, &event ) > 0 )
+      {
+//         COUT(0) << "incoming event" << endl;
+        // received an event
+        this->incomingEventsMutex_->lock();
+        this->incomingEvents_.push_back(event);
+        this->incomingEventsMutex_->unlock();
+      }
+      // Send all waiting outgoing packets
+      this->outgoingEventsMutex_->lock();
+      uint32_t outgoingEventsCount = this->outgoingEvents_.size();
+      this->outgoingEventsMutex_->unlock();
+      while( outgoingEventsCount > 0 )
+      {
+//         COUT(0) << "outgoing event" << endl;
+        this->outgoingEventsMutex_->lock();
+        outgoingEvent outEvent = this->outgoingEvents_.front();
+        this->outgoingEvents_.pop_front();
+        this->outgoingEventsMutex_->unlock();
+        switch( outEvent.type )
+        {
+          case outgoingEventType::sendPacket:
+            enet_peer_send( outEvent.peer, outEvent.channelID, outEvent.packet );
+            break;
+          case outgoingEventType::disconnectPeer:
+            enet_peer_disconnect(outEvent.peer, 0);
+            break;
+          case outgoingEventType::broadcastPacket:
+            enet_host_broadcast( this->host_, outEvent.channelID, outEvent.packet );
+            break;
+          default:
+            assert(0);
+        }
+        this->outgoingEventsMutex_->lock();
+        outgoingEventsCount = this->outgoingEvents_.size();
+        this->outgoingEventsMutex_->unlock();
+      }
+      // Wait for incoming events (at most NETWORK_WAIT_TIMEOUT ms)
+      if( enet_host_service( this->host_, &event, NETWORK_WAIT_TIMEOUT ) > 0 )
+      {
+//         COUT(0) << "incoming event after wait" << endl;
+        //received an event
+        this->incomingEventsMutex_->lock();
+        this->incomingEvents_.push_back(event);
+        this->incomingEventsMutex_->unlock();
+      }
+    }
+  }
+  void Connection::processQueue()
+  {
+    ENetEvent event;
+    this->incomingEventsMutex_->lock();
+    uint32_t incomingEventsCount = this->incomingEvents_.size();
+    this->incomingEventsMutex_->unlock();
+    while( incomingEventsCount > 0 )
+    {
+      packet::Packet* p;
+      this->incomingEventsMutex_->lock();
+      event = this->incomingEvents_.front();
+      this->incomingEvents_.pop_front();
+      this->incomingEventsMutex_->unlock();
+      switch(event.type)
+      {
         // log handling ================
         case ENET_EVENT_TYPE_CONNECT:
 …
           break;
         case ENET_EVENT_TYPE_RECEIVE:
+          processPacket( &event );
+//           COUT(0) << "ENET_EVENT_TYPE_RECEIVE" << endl;
+          p = createPacket( &event );
+          processPacket(p);
           break;
         case ENET_EVENT_TYPE_NONE:
           break;
+      }
+      this->incomingEventsMutex_->lock();
+      incomingEventsCount = this->incomingEvents_.size();
+      this->incomingEventsMutex_->unlock();
+    }
+  }
+  bool Connection::processPacket(ENetEvent* event) {
+  packet::Packet* Connection::createPacket(ENetEvent* event)
+  {
     packet::Packet *p = packet::Packet::createPacket(event->packet, event->peer);
+    return p->process();
+  }
+    return p;
+//     return p->process();
+  }
+  void Connection::enableCompression()
+  {
+    enet_host_compress_with_range_coder( this->host_ );
+  }
+}

code/trunk/src/libraries/network/Connection.h

-                      r7163
+                      r7801
 #include "NetworkPrereqs.h"
+#include <deque>
+#include <enet/enet.h>
+namespace boost
+{
+  class thread;
+  class mutex;
+}
 namespace orxonox
+{
+    const unsigned int NETWORK_PORT = 55556;
+    const unsigned int NETWORK_MAX_CONNECTIONS = 50;
+    const unsigned int NETWORK_WAIT_TIMEOUT = 0;
+    const unsigned int NETWORK_DEFAULT_CHANNEL = 0;
+    const unsigned int NETWORK_MAX_QUEUE_PROCESS_TIME = 5;
+  class _NetworkExport Connection{
+  const unsigned int NETWORK_PORT                   = 55556;
+  const unsigned int NETWORK_MAX_CONNECTIONS        = 50;
+  const unsigned int NETWORK_WAIT_TIMEOUT           = 1;
+  const unsigned int NETWORK_MAX_QUEUE_PROCESS_TIME = 5;
+  namespace outgoingEventType
+  {
+    enum Value
+    {
+      sendPacket      = 1,
+      disconnectPeer  = 2,
+      broadcastPacket = 3
+    };
+  }
+  struct _NetworkExport outgoingEvent
+  {
+    ENetPeer*                 peer;
+    outgoingEventType::Value  type;
+    ENetPacket*               packet;
+    ENetChannelID             channelID;
+  };
+  class _NetworkExport Connection
+  {
   public:
     virtual ~Connection();
     static bool addPacket(ENetPacket *packet, ENetPeer *peer);
     bool sendPackets();
     ENetHost* getHost(){ return this->host_; }
+    void addPacket(ENetPacket *packet, ENetPeer *peer, uint8_t channelID);
+    void broadcastPacket(ENetPacket* packet, uint8_t channelID);
+//     ENetHost* getHost(){ return this->host_; }
   protected:
 …
 //     static Connection* getInstance(){ return Connection::instance_; }
+    int service(ENetEvent* event);
+//     int service(ENetEvent* event);
+    void startCommunicationThread();
+    void stopCommunicationThread();
+    void communicationThread();
     virtual void disconnectPeer(ENetPeer *peer);
+    void enableCompression();
     void processQueue();
     virtual void addPeer(ENetEvent* event)=0;
     virtual void removePeer(ENetEvent* event)=0;
+    virtual bool processPacket(ENetEvent* event);
+    virtual void processPacket( packet::Packet* packet)=0;
+    virtual packet::Packet* createPacket(ENetEvent* event);
     ENetHost *host_;
+    ENetHost*                   host_;
   private:
+    ENetAddress *bindAddress_;
+    boost::thread*              communicationThread_;
+    bool                        bCommunicationThreadRunning_;
+    ENetAddress*                bindAddress_;
+    std::deque<ENetEvent>       incomingEvents_;
+    std::deque<outgoingEvent>   outgoingEvents_;
+    boost::mutex*               incomingEventsMutex_;
+    boost::mutex*               outgoingEventsMutex_;
 //     static Connection *instance_;

code/trunk/src/libraries/network/FunctionCallManager.cc

r7495	r7801
30	30	#include "packet/FunctionCalls.h"
31	31	#include "core/GameMode.h"
	32	#include "GamestateHandler.h"
32	33
33	34	namespace orxonox {
34	35
35		std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::s~~Client~~Map_;
36		std::vector<~~FunctionCall~~> FunctionCallManager::sIncomingFunctionCallBuffer_;
	36	std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::sPeerMap_;
	37	std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > > FunctionCallManager::sIncomingFunctionCallBuffer_;
37	38
38	39	// Static calls
39	40
40		void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t ~~client~~ID)
	41	void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t peerID)
41	42	{
42		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	43	if(sPeerMap_.find(peerID)==sPeerMap_.end())
43	44	{
44		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
45		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	45	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	46	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
46	47	}
47		FunctionCallManager::s~~ClientMap_[client~~ID]->addCallStatic(functionID);
	48	FunctionCallManager::sPeerMap_[peerID]->addCallStatic(functionID);
48	49	}
49		void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t ~~client~~ID, const MultiType& mt1)
	50	void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t peerID, const MultiType& mt1)
50	51	{
51		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	52	if(sPeerMap_.find(peerID)==sPeerMap_.end())
52	53	{
53		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
54		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	54	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	55	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
55	56	}
56		FunctionCallManager:: s~~ClientMap_[client~~ID]->addCallStatic(functionID, &mt1);
	57	FunctionCallManager:: sPeerMap_[peerID]->addCallStatic(functionID, &mt1);
57	58	}
58		void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t ~~client~~ID, const MultiType& mt1, const MultiType& mt2)
	59	void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2)
59	60	{
60		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	61	if(sPeerMap_.find(peerID)==sPeerMap_.end())
61	62	{
62		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
63		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	63	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	64	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
64	65	}
65		FunctionCallManager:: s~~ClientMap_[client~~ID]->addCallStatic(functionID, &mt1, &mt2);
	66	FunctionCallManager:: sPeerMap_[peerID]->addCallStatic(functionID, &mt1, &mt2);
66	67	}
67		void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t ~~client~~ID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
	68	void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
68	69	{
69		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	70	if(sPeerMap_.find(peerID)==sPeerMap_.end())
70	71	{
71		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
72		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	72	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	73	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
73	74	}
74		FunctionCallManager:: s~~ClientMap_[client~~ID]->addCallStatic(functionID, &mt1, &mt2, &mt3);
	75	FunctionCallManager:: sPeerMap_[peerID]->addCallStatic(functionID, &mt1, &mt2, &mt3);
75	76	}
76		void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t ~~client~~ID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
	77	void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
77	78	{
78		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	79	if(sPeerMap_.find(peerID)==sPeerMap_.end())
79	80	{
80		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
81		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	81	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	82	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
82	83	}
83		FunctionCallManager:: s~~ClientMap_[client~~ID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4);
	84	FunctionCallManager:: sPeerMap_[peerID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4);
84	85	}
85		void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t ~~client~~ID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
	86	void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
86	87	{
87		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	88	if(sPeerMap_.find(peerID)==sPeerMap_.end())
88	89	{
89		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
90		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	90	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	91	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
91	92	}
92		FunctionCallManager:: s~~ClientMap_[client~~ID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4, &mt5);
	93	FunctionCallManager:: sPeerMap_[peerID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4, &mt5);
93	94	}
94	95
…	…
96	97	// MemberCalls
97	98
98		void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t ~~client~~ID)
	99	void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID)
99	100	{
100		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	101	if(sPeerMap_.find(peerID)==sPeerMap_.end())
101	102	{
102		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
103		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	103	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	104	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
104	105	}
105		FunctionCallManager::s~~ClientMap_[client~~ID]->addCallMember(functionID, objectID);
	106	FunctionCallManager::sPeerMap_[peerID]->addCallMember(functionID, objectID);
106	107	}
107		void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t ~~client~~ID, const MultiType& mt1)
	108	void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID, const MultiType& mt1)
108	109	{
109		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	110	if(sPeerMap_.find(peerID)==sPeerMap_.end())
110	111	{
111		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
112		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	112	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	113	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
113	114	}
114		FunctionCallManager::s~~ClientMap_[client~~ID]->addCallMember(functionID, objectID, &mt1);
	115	FunctionCallManager::sPeerMap_[peerID]->addCallMember(functionID, objectID, &mt1);
115	116	}
116		void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t ~~client~~ID, const MultiType& mt1, const MultiType& mt2)
	117	void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2)
117	118	{
118		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	119	if(sPeerMap_.find(peerID)==sPeerMap_.end())
119	120	{
120		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
121		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	121	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	122	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
122	123	}
123		FunctionCallManager::s~~ClientMap_[client~~ID]->addCallMember(functionID, objectID, &mt1, &mt2);
	124	FunctionCallManager::sPeerMap_[peerID]->addCallMember(functionID, objectID, &mt1, &mt2);
124	125	}
125		void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t ~~client~~ID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
	126	void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
126	127	{
127		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	128	if(sPeerMap_.find(peerID)==sPeerMap_.end())
128	129	{
129		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
130		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	130	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	131	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
131	132	}
132		FunctionCallManager::s~~ClientMap_[client~~ID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3);
	133	FunctionCallManager::sPeerMap_[peerID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3);
133	134	}
134		void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t ~~client~~ID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
	135	void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
135	136	{
136		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	137	if(sPeerMap_.find(peerID)==sPeerMap_.end())
137	138	{
138		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
139		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	139	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	140	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
140	141	}
141		FunctionCallManager::s~~ClientMap_[client~~ID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4);
	142	FunctionCallManager::sPeerMap_[peerID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4);
142	143	}
143		void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t ~~client~~ID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
	144	void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
144	145	{
145		if(s~~ClientMap_.find(clientID)==sClient~~Map_.end())
	146	if(sPeerMap_.find(peerID)==sPeerMap_.end())
146	147	{
147		FunctionCallManager::s~~ClientMap_[client~~ID] = new packet::FunctionCalls;
148		FunctionCallManager::s~~ClientMap_[clientID]->setClientID(client~~ID);
	148	FunctionCallManager::sPeerMap_[peerID] = new packet::FunctionCalls;
	149	FunctionCallManager::sPeerMap_[peerID]->setPeerID(peerID);
149	150	}
150		FunctionCallManager::s~~ClientMap_[client~~ID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4, &mt5);
	151	FunctionCallManager::sPeerMap_[peerID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4, &mt5);
151	152	}
152	153
153	154	// Send calls
154	155
155		void FunctionCallManager::sendCalls()
	156	void FunctionCallManager::sendCalls(orxonox::Host* host)
156	157	{
157	158	std::map<uint32_t, packet::FunctionCalls*>::iterator it;
158		for (it = FunctionCallManager::s~~ClientMap_.begin(); it != FunctionCallManager::sClient~~Map_.end(); ++it )
	159	for (it = FunctionCallManager::sPeerMap_.begin(); it != FunctionCallManager::sPeerMap_.end(); ++it )
159	160	{
160		assert(!FunctionCallManager::s~~Client~~Map_.empty());
161		it->second->send();
	161	assert(!FunctionCallManager::sPeerMap_.empty());
	162	it->second->send(host);
162	163	}
163		FunctionCallManager::s~~Client~~Map_.clear();
	164	FunctionCallManager::sPeerMap_.clear();
164	165	}
165	166
166		void FunctionCallManager::bufferIncomingFunctionCall(const orxonox::FunctionCall& fctCall)
	167	void FunctionCallManager::bufferIncomingFunctionCall(const orxonox::FunctionCall& fctCall, uint32_t minGamestateID, uint32_t peerID)
167	168	{
168		if( !GameMode::isMaster() )
169		FunctionCallManager::sIncomingFunctionCallBuffer_.push_back( fctCall );
	169	FunctionCallManager::sIncomingFunctionCallBuffer_.push_back( std::make_pair(fctCall, std::make_pair(minGamestateID, peerID)));
170	170	}
171	171
172	172	void FunctionCallManager::processBufferedFunctionCalls()
173	173	{
174		std::vector<~~FunctionCall~~>::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
	174	std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > >::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
175	175	while( it!=FunctionCallManager::sIncomingFunctionCallBuffer_.end() )
176	176	{
177		if( it->execute() )
	177	if( it->first.execute() )
178	178	FunctionCallManager::sIncomingFunctionCallBuffer_.erase(it);
179	179	else
	180	{
180	181	++it;
	182	}
181	183	}
182	184	}

code/trunk/src/libraries/network/FunctionCallManager.h

-                      r7495
+                      r7801
 #include <map>
 #include <vector>
+#include <utility>
 #include "util/UtilPrereqs.h"
 #include "FunctionCall.h"
 …
+{
 public:
   static void addCallStatic(uint32_t functionID, uint32_t clientID);
   static void addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1);
   static void addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2);
   static void addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3);
   static void addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4);
   static void addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5);
+  static void addCallStatic(uint32_t functionID, uint32_t peerID);
+  static void addCallStatic(uint32_t functionID, uint32_t peerID, const MultiType& mt1);
+  static void addCallStatic(uint32_t functionID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2);
+  static void addCallStatic(uint32_t functionID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3);
+  static void addCallStatic(uint32_t functionID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4);
+  static void addCallStatic(uint32_t functionID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5);
   static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID);
   static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1);
   static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2);
   static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3);
   static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4);
   static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5);
+  static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID);
+  static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID, const MultiType& mt1);
+  static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2);
+  static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3);
+  static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4);
+  static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t peerID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5);
   static void sendCalls();
+  static void sendCalls(orxonox::Host* host);
   static void bufferIncomingFunctionCall( const FunctionCall& fctCall );
+  static void bufferIncomingFunctionCall( const FunctionCall& fctCall, uint32_t minGamestateID, uint32_t peerID );
   static void processBufferedFunctionCalls();
   static std::map<uint32_t, packet::FunctionCalls*> sClientMap_;
   static std::vector<FunctionCall>                  sIncomingFunctionCallBuffer_;
+  static std::map<uint32_t, packet::FunctionCalls*>                           sPeerMap_;
+  static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t> > > sIncomingFunctionCallBuffer_;
 protected:
   FunctionCallManager();

code/trunk/src/libraries/network/GamestateClient.cc

-                      r7401
+                      r7801
 namespace orxonox
+{
+  struct _NetworkExport GameStateItem{
+  struct _NetworkExport GameStateItem
+  {
     packet::Gamestate *state;
     unsigned int id;
   };
+  GamestateClient::GamestateClient() {
+  GamestateClient::GamestateClient()
+  {
     COUT(5) << "this: " << this << std::endl;
     last_diff_=0;
     last_gamestate_=GAMESTATEID_INITIAL-1;
+    lastAckedGamestateID_=GAMESTATEID_INITIAL-1;
+    lastProcessedGamestateID_=GAMESTATEID_INITIAL-1;
     tempGamestate_=NULL;
+  }
+  GamestateClient::~GamestateClient() {
+  GamestateClient::~GamestateClient()
+  {
       std::map<unsigned int, packet::Gamestate *>::iterator it;
       for ( it = this->gamestateMap_.begin(); it != this->gamestateMap_.end(); ++it )
 …
+  }
+  bool GamestateClient::ack(unsigned int gamestateID, unsigned int clientID){
+  bool GamestateClient::ackGamestate(unsigned int gamestateID, unsigned int clientID)
+  {
     return true;
+  }
+  bool GamestateClient::add(packet::Gamestate *gs, unsigned int clientID){
+    if(tempGamestate_!=NULL){
+  bool GamestateClient::addGamestate(packet::Gamestate *gs, unsigned int clientID)
+  {
+    if(tempGamestate_!=NULL)
+    {
       //delete the obsolete gamestate
       if(tempGamestate_->getID()>gs->getID())
 …
+  }
+  bool GamestateClient::processGamestates(){
+  bool GamestateClient::processGamestates()
+  {
     if(tempGamestate_==NULL)
       return false;
 …
     NetworkCallbackManager::callCallbacks();
+    if (!processed){
+    if (!processed)
+    {
+      assert(0);
       sendAck(0);
       return false;
 …
     tempGamestate_=NULL;
     gamestateMap_[processed->getID()]=processed;
+    lastProcessedGamestateID_ = processed->getID();
     if(isDiffed)
       last_diff_ = processed->getBaseID();
+      lastAckedGamestateID_ = processed->getBaseID();
     id = processed->getID();
     sendAck(id);
 …
   * @return iterator pointing to the next object in the list
   */
+  void GamestateClient::removeObject(ObjectListIterator<Synchronisable> &it) {
+  void GamestateClient::removeObject(ObjectListIterator<Synchronisable> &it)
+  {
     ObjectListIterator<Synchronisable> temp=it;
     ++it;
 …
+  }
+  packet::Gamestate *GamestateClient::getGamestate(){
+  packet::Gamestate *GamestateClient::getGamestate()
+  {
     packet::Gamestate *gs = new packet::Gamestate();
+    if(!gs->collectData(0,0x2)){
+    if(!gs->collectData(this->getLastProcessedGamestateID(NETWORK_PEER_ID_SERVER), 0x2))
+    {
       delete gs;
       return 0;
 …
+  }
+  void GamestateClient::cleanup(){
+  void GamestateClient::cleanup()
+  {
     std::map<unsigned int, packet::Gamestate*>::iterator temp, it = gamestateMap_.begin();
+    while(it!=gamestateMap_.end()){
+      if(it->first>=last_diff_)
+    while(it!=gamestateMap_.end())
+    {
+      if(it->first>=lastAckedGamestateID_)
         break;
       // otherwise delete that stuff
 …
+  }
+  void GamestateClient::printGamestateMap(){
+  void GamestateClient::printGamestateMap()
+  {
     std::map<unsigned int, packet::Gamestate*>::iterator it;
     COUT(4) << "gamestates: ";
+    for(it=gamestateMap_.begin(); it!=gamestateMap_.end(); it++){
+    for(it=gamestateMap_.begin(); it!=gamestateMap_.end(); it++)
+    {
       COUT(4) << it->first << ':' << it->second << '|';
+    }
 …
+  }
+  bool GamestateClient::sendAck(unsigned int gamestateID){
+  bool GamestateClient::sendAck(unsigned int gamestateID)
+  {
     packet::Acknowledgement *ack = new packet::Acknowledgement(gamestateID, 0);
+    if(!ack->send()){
+    if(!ack->send())
+    {
       COUT(3) << "could not ack gamestate: " << gamestateID << std::endl;
       return false;
+    }
+    else{
+    else
+    {
       COUT(5) << "acked a gamestate: " << gamestateID << std::endl;
       return true;
 …
+  }
+  packet::Gamestate *GamestateClient::processGamestate(packet::Gamestate *gs){
+  packet::Gamestate *GamestateClient::processGamestate(packet::Gamestate *gs)
+  {
     if(gs->isCompressed())
+    {

code/trunk/src/libraries/network/GamestateClient.h

-                      r5781
+                      r7801
     ~GamestateClient();
+    bool add(packet::Gamestate *gs, unsigned int clientID);
+    bool ack(unsigned int gamestateID, unsigned int clientID);
+    virtual bool      addGamestate(packet::Gamestate *gs, unsigned int clientID);
+    virtual bool      ackGamestate(unsigned int gamestateID, unsigned int clientID);
+    virtual uint32_t  getLastProcessedGamestateID(unsigned int clientID=0) { return this->lastProcessedGamestateID_; }
+    virtual uint32_t  getCurrentGamestateID(){ return this->lastProcessedGamestateID_; }
     bool processGamestates();
 …
     bool sendAck(unsigned int gamestateID);
     unsigned int           last_diff_;
     unsigned int           last_gamestate_;
+    unsigned int           lastAckedGamestateID_;
+    unsigned int           lastProcessedGamestateID_;
     std::map<unsigned int, packet::Gamestate *> gamestateMap_;
     packet::Gamestate *tempGamestate_; // we save the received gamestates here during processQueue

code/trunk/src/libraries/network/GamestateHandler.cc

r6417	r7801
32	32	namespace orxonox {
33	33
34		GamestateHandler *GamestateHandler::instance_=0;
	34	// GamestateHandler *GamestateHandler::instance_=0;
35	35
36	36	GamestateHandler::GamestateHandler()
37	37	{
38		~~assert(instance_==0);~~
39		~~instance_=this;~~
40	38	}
41	39
…	…
43	41	GamestateHandler::~GamestateHandler()
44	42	{
45		~~instance_=0;~~
46	43	}
47	44

code/trunk/src/libraries/network/GamestateHandler.h

-                      r6073
+                      r7801
 #include "NetworkPrereqs.h"
+#include <cassert>
 namespace orxonox {
 …
     @author Oliver Scheuss
 */
+class _NetworkExport GamestateHandler{
+class _NetworkExport GamestateHandler
+{
   private:
-    virtual bool add(packet::Gamestate *gs, unsigned int clientID)=0;
-    virtual bool ack(unsigned int gamestateID, unsigned int clientID)=0;
-    static GamestateHandler *instance_;
 …
   public:
+    static bool addGamestate(packet::Gamestate *gs, unsigned int clientID){ return instance_->add(gs, clientID); }
+    static bool ackGamestate(unsigned int gamestateID, unsigned int clientID){ return instance_->ack(gamestateID, clientID); }
+    virtual bool      addGamestate(packet::Gamestate* gs, unsigned int clientID) = 0;
+    virtual bool      ackGamestate(unsigned int gamestateID, unsigned int clientID) = 0;
+    virtual uint32_t  getLastProcessedGamestateID( unsigned int clientID )=0;
+    virtual uint32_t  getCurrentGamestateID()=0;
 };

code/trunk/src/libraries/network/GamestateManager.cc

-                      r7284
+                      r7801
 #include <cassert>
 #include <queue>
-#include "util/Clock.h"
 // #include <boost/thread/mutex.hpp>
-#include "util/Debug.h"
-#include "core/ThreadPool.h"
-#include "core/command/Executor.h"
-#include "ClientInformation.h"
 #include "packet/Acknowledgement.h"
 #include "packet/Gamestate.h"
 #include "synchronisable/NetworkCallbackManager.h"
+#include "TrafficControl.h"
+#include "core/ThreadPool.h"
+#include "core/command/Executor.h"
+#include "core/GameMode.h"
+#include "util/Debug.h"
+#include "util/Clock.h"
+// #include "TrafficControl.h"
 namespace orxonox
+{
   GamestateManager::GamestateManager() :
   reference(0), id_(0)
+  {
     trafficControl_ = new TrafficControl();
+  currentGamestate_(0), id_(0)
+  {
+//     trafficControl_ = new TrafficControl();
 //     threadMutex_ = new boost::mutex();
 //     threadPool_ = new ThreadPool();
 …
   GamestateManager::~GamestateManager()
+  {
     if( this->reference )
         delete this->reference;std::map<unsigned int, packet::Gamestate*>::iterator it;
+    if( this->currentGamestate_ )
+        delete this->currentGamestate_;std::map<unsigned int, packet::Gamestate*>::iterator it;
     for( it = gamestateQueue.begin(); it != gamestateQueue.end(); ++it )
       delete it->second;
     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> >::iterator it1;
     std::map<unsigned int, packet::Gamestate*>::iterator it2;
     for( it1 = gamestateMap_.begin(); it1 != gamestateMap_.end(); ++it1 )
+    {
       for( it2 = it1->second.begin(); it2 != it1->second.end(); ++it2 )
         delete it2->second;
+    }
     this->trafficControl_->destroy();
+    std::map<uint32_t, peerInfo>::iterator peerIt;
+    std::map<uint32_t, packet::Gamestate*>::iterator gamestateIt;
+    for( peerIt = peerMap_.begin(); peerIt != peerMap_.end(); ++peerIt )
+    {
+      for( gamestateIt = peerIt->second.gamestates.begin(); gamestateIt != peerIt->second.gamestates.end(); ++gamestateIt )
+        delete gamestateIt->second;
+    }
+//     this->trafficControl_->destroy();
 //     delete this->threadMutex_;
 //     delete this->threadPool_;
 …
+  }
+  bool GamestateManager::add(packet::Gamestate *gs, unsigned int clientID){
+  bool GamestateManager::addGamestate(packet::Gamestate *gs, unsigned int clientID)
+  {
     assert(gs);
     std::map<unsigned int, packet::Gamestate*>::iterator it = gamestateQueue.find(clientID);
 …
+  }
+  bool GamestateManager::processGamestates(){
+  bool GamestateManager::processGamestates()
+  {
     if( this->gamestateQueue.empty() )
         return true;
 …
       bool b = processGamestate(it->second);
       assert(b);
+      sendAck( it->second->getID(), it->second->getPeerID() );
       delete it->second;
+    }
 …
     return true;
+  }
+  bool GamestateManager::sendAck(unsigned int gamestateID, uint32_t peerID)
+  {
+    packet::Acknowledgement *ack = new packet::Acknowledgement(gamestateID, peerID);
+    if( !this->sendPacket(ack))
+    {
+      COUT(3) << "could not ack gamestate: " << gamestateID << std::endl;
+      return false;
+    }
+    else
+    {
+      COUT(5) << "acked a gamestate: " << gamestateID << std::endl;
+      return true;
+    }
+  }
   bool GamestateManager::getSnapshot(){
+    if ( reference != 0 )
+      delete reference;
+    reference = new packet::Gamestate();
+    if(!reference->collectData(++id_, 0x1)){ //we have no data to send
+      delete reference;
+      reference=0;
+    if ( currentGamestate_ != 0 )
+      delete currentGamestate_;
+    currentGamestate_ = new packet::Gamestate();
+    uint8_t gsMode;
+    if( GameMode::isMaster() )
+      gsMode = packet::GAMESTATE_MODE_SERVER;
+    else
+      gsMode = packet::GAMESTATE_MODE_CLIENT;
+    uint32_t newID;
+    if( GameMode::isMaster() )
+      newID = ++id_;
+    else
+      newID = peerMap_[NETWORK_PEER_ID_SERVER].lastProcessedGamestateID;
+    if(!currentGamestate_->collectData(newID, gsMode)){ //we have no data to send
+      delete currentGamestate_;
+      currentGamestate_=0;
+    }
     return true;
+  }
+  void GamestateManager::sendGamestates()
+  {
+    ClientInformation *temp = ClientInformation::getBegin();
+    std::queue<packet::Gamestate*> clientGamestates;
+    while(temp != NULL){
+      if( !(temp->getSynched()) ){
+  std::vector<packet::Gamestate*> GamestateManager::getGamestates()
+  {
+    if(!currentGamestate_)
+      return std::vector<packet::Gamestate*>();
+    std::vector<packet::Gamestate*> peerGamestates;
+    std::map<uint32_t, peerInfo>::iterator peerIt;
+    for( peerIt=peerMap_.begin(); peerIt!=peerMap_.end(); ++peerIt )
+    {
+      if( !peerIt->second.isSynched )
+      {
         COUT(5) << "Server: not sending gamestate" << std::endl;
-        temp=temp->next();
-        if(!temp)
-          break;
         continue;
+      }
       COUT(4) << "client id: " << temp->getID() << " RTT: " << temp->getRTT() << " loss: " << temp->getPacketLoss() << std::endl;
+      COUT(4) << "client id: " << peerIt->first << std::endl;
       COUT(5) << "Server: doing gamestate gamestate preparation" << std::endl;
       int cid = temp->getID(); //get client id
       unsigned int gID = temp->getGamestateID();
+      if(!reference)
         return;
       packet::Gamestate *client=0;
       if(gID != GAMESTATEID_INITIAL){
         assert(gamestateMap_.find(cid)!=gamestateMap_.end());
         std::map<unsigned int, packet::Gamestate*>::iterator it = gamestateMap_[cid].find(gID);
         if(it!=gamestateMap_[cid].end())
+        {
+          client = it->second;
+        }
+      }
       clientGamestates.push(0);
       finishGamestate( cid, clientGamestates.back(), client, reference );
+      int peerID = peerIt->first; //get client id
+      unsigned int lastAckedGamestateID = peerIt->second.lastAckedGamestateID;
+      packet::Gamestate* baseGamestate=0;
+      if(lastAckedGamestateID != GAMESTATEID_INITIAL)
+      {
+        assert(peerMap_.find(peerID)!=peerMap_.end());
+        std::map<uint32_t, packet::Gamestate*>::iterator it = peerMap_[peerID].gamestates.find(lastAckedGamestateID);
+        assert(it!=peerMap_[peerID].gamestates.end());
+        baseGamestate = it->second;
+      }
+      peerGamestates.push_back(0);  // insert an empty gamestate* to change
+      finishGamestate( peerID, peerGamestates.back(), baseGamestate, currentGamestate_ );
+      if( peerGamestates.back()==0 )
+        // nothing to send to remove pointer from vector
+        peerGamestates.pop_back();
       //FunctorMember<GamestateManager>* functor =
 //       ExecutorMember<GamestateManager>* executor = createExecutor( createFunctor(&GamestateManager::finishGamestate, this) );
 //       executor->setDefaultValues( cid, &clientGamestates.back(), client, reference );
+//       executor->setDefaultValues( cid, &clientGamestates.back(), client, currentGamestate_ );
 //       (*static_cast<Executor*>(executor))();
 //       this->threadPool_->passFunction( executor, true );
+//       (*functor)( cid, &(clientGamestates.back()), client, reference );
+      temp = temp->next();
+//       (*functor)( cid, &(clientGamestates.back()), client, currentGamestate_ );
+    }
 //     threadPool_->synchronise();
+    while( !clientGamestates.empty() )
+    {
+      if(clientGamestates.front())
+        clientGamestates.front()->send();
+      clientGamestates.pop();
+    }
+  }
+  void GamestateManager::finishGamestate( unsigned int clientID, packet::Gamestate*& destgamestate, packet::Gamestate* base, packet::Gamestate* gamestate ) {
+    return peerGamestates;
+  }
+  void GamestateManager::finishGamestate( unsigned int peerID, packet::Gamestate*& destgamestate, packet::Gamestate* base, packet::Gamestate* gamestate ) {
     //why are we searching the same client's gamestate id as we searched in
     //Server::sendGameState?
 …
 //     gs->collectData( id_, 0x1 );
 //     this->threadMutex_->lock();
     gamestateMap_[clientID][gamestate->getID()]=gs;
+    peerMap_[peerID].gamestates[gamestate->getID()]=gs;
 //     this->threadMutex_->unlock();
       Clock clock;
       clock.capture();
+    Clock clock;
+    clock.capture();
     if(base)
 …
     bool b = gs->compressData();
     assert(b);
       clock.capture();
       COUT(0) << "diff time: " << clock.getDeltaTime() << endl;
+//     bool b = gs->compressData();
+//     assert(b);
+    clock.capture();
+    COUT(4) << "diff and compress time: " << clock.getDeltaTime() << endl;
 //     COUT(5) << "sending gamestate with id " << gs->getID();
 //     if(gamestate->isDiffed())
 …
 //     else
 //       COUT(5) << endl;
     gs->setClientID(clientID);
+    gs->setPeerID(peerID);
     destgamestate = gs;
+  }
+  bool GamestateManager::ack(unsigned int gamestateID, unsigned int clientID) {
+    ClientInformation *temp = ClientInformation::findClient(clientID);
+    assert(temp);
+    unsigned int curid = temp->getGamestateID();
+  bool GamestateManager::ackGamestate(unsigned int gamestateID, unsigned int peerID)
+  {
+//     ClientInformation *temp = ClientInformation::findClient(peerID);
+//     assert(temp);
+    std::map<uint32_t, peerInfo>::iterator it = this->peerMap_.find(peerID);
+    assert(it!=this->peerMap_.end());
+    unsigned int curid = it->second.lastAckedGamestateID;
     if(gamestateID == ACKID_NACK){
+      temp->setGamestateID(GAMESTATEID_INITIAL);
+      it->second.lastAckedGamestateID = GAMESTATEID_INITIAL;
+//       temp->setGamestateID(GAMESTATEID_INITIAL);
       // now delete all saved gamestates for this client
+      std::map<unsigned int, packet::Gamestate*>::iterator it;
+      for(it = gamestateMap_[clientID].begin(); it!=gamestateMap_[clientID].end(); ){
+        delete it->second;
+        gamestateMap_[clientID].erase(it++);
+      }
+      std::map<uint32_t, packet::Gamestate*>::iterator it2;
+      for(it2 = it->second.gamestates.begin(); it2!=it->second.gamestates.end(); ++it2 ){
+        delete it2->second;
+      }
+      it->second.gamestates.clear();
       return true;
+    }
+    assert(curid==GAMESTATEID_INITIAL || curid<gamestateID);
+    COUT(5) << "acking gamestate " << gamestateID << " for clientid: " << clientID << " curid: " << curid << std::endl;
+    std::map<unsigned int, packet::Gamestate*>::iterator it;
+    for(it = gamestateMap_[clientID].begin(); it!=gamestateMap_[clientID].end() && it->first<gamestateID; ){
+      delete it->second;
+      gamestateMap_[clientID].erase(it++);
+    }
+    temp->setGamestateID(gamestateID);
+    TrafficControl::processAck(clientID, gamestateID);
+    assert(curid==GAMESTATEID_INITIAL || curid<=gamestateID);
+    COUT(5) << "acking gamestate " << gamestateID << " for peerID: " << peerID << " curid: " << curid << std::endl;
+    std::map<uint32_t, packet::Gamestate*>::iterator it2;
+    for( it2=it->second.gamestates.begin(); it2!=it->second.gamestates.end(); )
+    {
+      if( it2->second->getID() < gamestateID )
+      {
+        delete it2->second;
+        it->second.gamestates.erase(it2++);
+      }
+      else
+        ++it2;
+    }
+//     std::map<unsigned int, packet::Gamestate*>::iterator it;
+//     for(it = gamestateMap_[peerID].begin(); it!=gamestateMap_[peerID].end() && it->first<gamestateID; ){
+//       delete it->second;
+//       gamestateMap_[peerID].erase(it++);
+//     }
+    it->second.lastAckedGamestateID = gamestateID;
+//     temp->setGamestateID(gamestateID);
+//     TrafficControl::processAck(peerID, gamestateID);
     return true;
+  }
+  void GamestateManager::removeClient(ClientInformation* client){
+    assert(client);
+    std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(client->getID());
+    // first delete all remained gamestates
+    std::map<unsigned int, packet::Gamestate*>::iterator it;
+    for(it=clientMap->second.begin(); it!=clientMap->second.end(); it++)
+      delete it->second;
+    // now delete the clients gamestatemap
+    gamestateMap_.erase(clientMap);
+  }
+  bool GamestateManager::processGamestate(packet::Gamestate *gs){
+  uint32_t GamestateManager::getLastProcessedGamestateID(unsigned int peerID)
+  {
+    assert( this->peerMap_.find(peerID)!=this->peerMap_.end() );
+    if( this->peerMap_.find(peerID) != this->peerMap_.end() )
+      return this->peerMap_[peerID].lastProcessedGamestateID;
+    else
+      return GAMESTATEID_INITIAL;
+  }
+  void GamestateManager::addPeer(uint32_t peerID)
+  {
+    assert(peerMap_.find(peerID)==peerMap_.end());
+    peerMap_[peerID].peerID = peerID;
+    peerMap_[peerID].lastProcessedGamestateID = GAMESTATEID_INITIAL;
+    peerMap_[peerID].lastAckedGamestateID = GAMESTATEID_INITIAL;
+    if( GameMode::isMaster() )
+      peerMap_[peerID].isSynched = false;
+    else
+      peerMap_[peerID].isSynched = true;
+  }
+  void GamestateManager::removePeer(uint32_t peerID)
+  {
+    assert(peerMap_.find(peerID)!=peerMap_.end());
+    std::map<uint32_t, packet::Gamestate*>::iterator peerIt;
+    for( peerIt = peerMap_[peerID].gamestates.begin(); peerIt!=peerMap_[peerID].gamestates.end(); ++peerIt )
+    {
+      delete peerIt->second;
+    }
+    peerMap_.erase(peerMap_.find(peerID));
+  }
+//   void GamestateManager::removeClient(ClientInformation* client){
+//     assert(client);
+//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(client->getID());
+//     // first delete all remained gamestates
+//     std::map<unsigned int, packet::Gamestate*>::iterator it;
+//     for(it=clientMap->second.begin(); it!=clientMap->second.end(); it++)
+//       delete it->second;
+//     // now delete the clients gamestatemap
+//     gamestateMap_.erase(clientMap);
+//   }
+  bool GamestateManager::processGamestate(packet::Gamestate *gs)
+  {
     if(gs->isCompressed())
+    {
 …
+    }
     assert(!gs->isDiffed());
+    return gs->spreadData(0x1);
+    uint8_t gsMode;
+    if( GameMode::isMaster() )
+      gsMode = packet::GAMESTATE_MODE_SERVER;
+    else
+      gsMode = packet::GAMESTATE_MODE_CLIENT;
+    if( gs->spreadData(gsMode) )
+    {
+      this->peerMap_[gs->getPeerID()].lastProcessedGamestateID = gs->getID();
+      return true;
+    }
+    else
+      return false;
+  }

code/trunk/src/libraries/network/GamestateManager.h

-                      r7163
+                      r7801
 #include "GamestateHandler.h"
 #include "core/CorePrereqs.h"
+#include "packet/Gamestate.h"
+#include <boost/concept_check.hpp>
 namespace orxonox
 …
   * @author Oliver Scheuss
   */
+  class _NetworkExport GamestateManager: public GamestateHandler{
+  class _NetworkExport GamestateManager: public GamestateHandler
+  {
+    struct peerInfo
+    {
+      uint32_t  peerID;
+      uint32_t  lastProcessedGamestateID;
+      uint32_t  lastAckedGamestateID;
+      bool      isSynched;
+      std::map< uint32_t, packet::Gamestate* > gamestates;
+    };
   public:
     GamestateManager();
     ~GamestateManager();
+    bool add(packet::Gamestate *gs, unsigned int clientID);
+    virtual bool      addGamestate(packet::Gamestate *gs, unsigned int peerID);
+    virtual bool      ackGamestate(unsigned int gamestateID, unsigned int peerID);
+    virtual uint32_t  getLastProcessedGamestateID( unsigned int peerID );
+    virtual uint32_t  getCurrentGamestateID(){ return currentGamestate_->getID(); }
     bool processGamestates();
+    bool sendAck(unsigned int gamestateID, uint32_t peerID);
     bool update();
+    void sendGamestates();
+//     packet::Gamestate *popGameState(unsigned int clientID);
+    void finishGamestate( unsigned int clientID, packet::Gamestate*& destgamestate, packet::Gamestate* base, packet::Gamestate* gamestate );
+    std::vector<packet::Gamestate*> getGamestates();
+    void finishGamestate( unsigned int peerID, packet::Gamestate*& destgamestate, packet::Gamestate* base, packet::Gamestate* gamestate );
     bool getSnapshot();
+    bool ack(unsigned int gamestateID, unsigned int clientID);
+    void removeClient(ClientInformation *client);
+    void addPeer( uint32_t peerID );
+    void setSynched( uint32_t peerID )
+      { assert(peerMap_.find(peerID)!=peerMap_.end()); peerMap_[peerID].isSynched = true; }
+    void removePeer( uint32_t peerID );
+//     void removeClient(ClientInformation *client);
+  protected:
+    virtual bool sendPacket( packet::Packet* packet ) = 0;
   private:
     bool processGamestate(packet::Gamestate *gs);
     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> > gamestateMap_;
+//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> > gamestateMap_;
     std::map<unsigned int, packet::Gamestate*> gamestateQueue;
+    packet::Gamestate *reference;
+    TrafficControl *trafficControl_;
+//     std::map<unsigned int, uint32_t> lastProcessedGamestateID_;
+    std::map<uint32_t, peerInfo> peerMap_;
+    packet::Gamestate* currentGamestate_;
+//     TrafficControl *trafficControl_;
     unsigned int id_;
 //     boost::mutex* threadMutex_;

code/trunk/src/libraries/network/Host.cc

r7284	r7801
45	45	// Host* Host::instance_=0;
46	46	uint32_t Host::clientID_s=0;
47		uint32_t Host::shipID_s=-1;
	47	// uint32_t Host::shipID_s=-1;
48	48	std::vector<Host*> Host::instances_s;
49	49
…	…
76	76	* @return success?
77	77	*/
78		~~bool Host::addPacket(ENetPacket *packet, int client~~ID)
	78	void Host::addPacket(ENetPacket *packet, int clientID, uint8_t channelID)
79	79	{
80		~~bool result = true;~~
81	80	for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
82	81	{
83	82	if( (*it)->isActive() )
84	83	{
85		if( !(*it)->queuePacket(packet, clientID) )
86		result = false;
	84	(*it)->queuePacket(packet, clientID, channelID);
87	85	}
88	86	}
89		~~return result;~~
90	87	}
91	88

code/trunk/src/libraries/network/Host.h

-                      r7284
+                      r7801
 #include "NetworkPrereqs.h"
+#include "GamestateManager.h"
 #include "core/CorePrereqs.h"
 …
 *       @author Oliver Scheuss
 */
+class _NetworkExport Host{
+class _NetworkExport Host: public GamestateManager
+{
   private:
     //TODO add these functions or adequate
     //virtual bool processChat(packet::Chat *message, unsigned int clientID)=0;
     //virtual bool sendChat(packet::Chat *chat)=0;
     virtual bool queuePacket(ENetPacket *packet, int clientID)=0;
+    virtual void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID)=0;
     virtual bool chat(const std::string& message)=0;
     virtual bool broadcast(const std::string& message)=0;
 …
 //     static Host* getInstance(){ return instance_; }
     static bool running(){ return instances_s.size(); }
     static bool addPacket(ENetPacket *packet, int clientID=0);
+    static void addPacket(ENetPacket* packet, int clientID = NETWORK_PEER_ID_SERVER, uint8_t channelID = 0);
     //static bool chat(std::string& message);
 //     static bool receiveChat(packet::Chat *message, unsigned int clientID);
     static unsigned int getPlayerID(){ return clientID_s; }
-    static unsigned int getShipID(){return shipID_s;}
     static void setClientID(unsigned int id){ clientID_s = id; }
-    static void setShipID(unsigned int id){ shipID_s = id; }
     static bool isServer();
     static void Chat(const std::string& message);
 …
   private:
     static uint32_t clientID_s;
-    static uint32_t shipID_s;
     static std::vector<Host*> instances_s;
     bool bIsActive_;

code/trunk/src/libraries/network/LANDiscoverable.cc

r7459	r7801
45	45	this->host_ = 0;
46	46	this->bActive_ = false;
47		this->setActivity(true);
	47	// this->setActivity(true);
48	48	}
49	49

code/trunk/src/libraries/network/MasterServer.cc

-                      r7786
+                      r7801
      * any input/output bandwidth */
     this->server = enet_host_create( &this->address, ORX_MSERVER_MAXCONNS,
+        ORX_MSERVER_MAXCHANS, 0, 0 );
+        ORX_MSERVER_MAXCHANS, 0, 0 );
+    assert(this->server);
     /* see if creation worked */

code/trunk/src/libraries/network/MasterServer.h

-                      r7786
+                      r7801
 #define _MasterServer_H__
+#include "NetworkPrereqs.h"
 /* orxonox includes */
 #include <enet/enet.h>
 …
+{
   /* singleton */
   class MasterServer
+  class _NetworkExport MasterServer
+  {
     public:

code/trunk/src/libraries/network/MasterServerComm.cc

-                      r7786
+                      r7801
     /* initialize the event holder */
     this->event = (ENetEvent *)calloc( sizeof(ENetEvent), 1 );
+//     this->event = (ENetEvent *)calloc( sizeof(ENetEvent), 1 );
 …
     /* Wait up to 2 seconds for the connection attempt to succeed. */
     if (enet_host_service (this->client, this->event, 2000) > 0 &&
         this->event->type == ENET_EVENT_TYPE_CONNECT )
+    if (enet_host_service (this->client, &this->event, 500) > 0 &&
+        this->event.type == ENET_EVENT_TYPE_CONNECT )
       COUT(3) << "Connection to master server succeeded.\n";
     else
 …
     return 0;
+  }
+void MasterServerComm::update()
+{
+  while( enet_host_service( this->client, &this->event, 1 ) );
+}
   int MasterServerComm::disconnect( void )
+  {
+    while( enet_host_service( this->client, &this->event, 1 ) );
     enet_peer_disconnect( this->peer, 0 );
 …
      * and drop any packets received packets.
      */
     while (enet_host_service (this->client, this->event, 1000) > 0)
+    while (enet_host_service (this->client, &this->event, 1000) > 0)
+    {
       switch (this->event->type)
+      switch (this->event.type)
+      {
         case ENET_EVENT_TYPE_RECEIVE:
           enet_packet_destroy (event->packet);
+          enet_packet_destroy (event.packet);
           break;
 …
     /* enet_host_service returns 0 if no event occured */
     /* just newly set below test to >0 from >= 0, to be tested */
     if( enet_host_service( this->client, this->event, delayms ) > 0 )
+    if( enet_host_service( this->client, &this->event, delayms ) > 0 )
+    {
       /* check what type of event it is and react accordingly */
       switch (this->event->type)
+      switch (this->event.type)
       { /* new connection, not supposed to happen. */
         case ENET_EVENT_TYPE_CONNECT: break;
 …
           /* resolve IP */
           enet_address_get_host_ip( &(this->event->peer->address),
+          enet_address_get_host_ip( &(this->event.peer->address),
             addrconv, 49 );
           /* DEBUG */
           COUT(3) << "MasterServer Debug: A packet of length "
             << this->event->packet->dataLength
             << " containing " << this->event->packet->data
+            << this->event.packet->dataLength
+            << " containing " << this->event.packet->data
             << " was received from " << addrconv
             << " on channel " << this->event->channelID;
+            << " on channel " << this->event.channelID;
           /* END DEBUG */
           /* call the supplied callback, if any. */
           if( (*callback) != NULL )
             retval = (*callback)( addrconv, (this->event) );
+            retval = (*callback)( addrconv, &(this->event) );
           /* clean up */
           enet_packet_destroy( event->packet );
+          enet_packet_destroy( event.packet );
           if( addrconv )
             free( addrconv );
 …
     /* free the packet */
+    enet_packet_destroy( packet );
+    // PLEASE: never do this, because enet will free the packet once it's delivered. this will cause double frees
+//     enet_packet_destroy( packet );
     /* all done. */
 …
     /* One could just use enet_host_service() instead. */
     enet_host_flush( this->client );
+    enet_packet_destroy( packet );
+    // PLEASE: never do this, because enet will free the packet once it's delivered. this will cause double frees
+//     enet_packet_destroy( packet );
     /* all done. */

code/trunk/src/libraries/network/MasterServerComm.h

-                      r7786
+                      r7801
 #define _MasterServerComm_H__
+#include "NetworkPrereqs.h"
 #include <cstdlib>
 #include <cstdio>
 …
 namespace orxonox
+{
   class MasterServerComm
+  class _NetworkExport MasterServerComm
+  {
     public:
 …
        */
       int initialize();
+      void update();
 …
     private:
       /** client handle */
       ENetHost *client;
+      ENetHost* client;
       /** event data holder */
       ENetEvent *event;
+      ENetEvent event;
       /** address holder */
 …
       /** peer data holder */
       ENetPeer *peer;
+      ENetPeer* peer;
   };

code/trunk/src/libraries/network/NetworkPrereqs.h

-                      r7490
+                      r7801
 namespace orxonox
+{
   static const unsigned int GAMESTATEID_INITIAL     = static_cast<unsigned int>(-1);
   static const unsigned int CLIENTID_UNKNOWN        = static_cast<unsigned int>(-2);
+  static const unsigned int GAMESTATEID_INITIAL       = static_cast<unsigned int>(-1);
+  static const unsigned int CLIENTID_UNKNOWN          = static_cast<unsigned int>(-2);
   extern const char* LAN_DISCOVERY_MESSAGE;
   extern const char* LAN_DISCOVERY_ACK;
+  static const unsigned int LAN_DISCOVERY_PORT      = 55557;
+  static const unsigned int LAN_DISCOVERY_PORT          = 55558;
+  static const unsigned int NETWORK_PEER_ID_SERVER      = 0;
+  static const unsigned int NETWORK_CHANNEL_DEFAULT     = 0;
+  static const unsigned int NETWORK_CHANNEL_UNRELIABLE  = 1;
+  static const unsigned int NETWORK_CHANNEL_COUNT       = 2;
+}
 …
       enum Value
+      {
         Reliable   = 1,
         Unsequence = 2,
         NoAllocate = 4
+        Reliable    = 1,
+        Unsequenced = 2,
+        NoAllocate  = 4
       };
+    }
 …
 // from ENet
 struct _ENetPeer;
 typedef _ENetPeer ENetPeer;
+typedef _ENetPeer     ENetPeer;
 struct _ENetPacket;
 typedef _ENetPacket ENetPacket;
+typedef _ENetPacket   ENetPacket;
 struct _ENetEvent;
 typedef _ENetEvent ENetEvent;
+typedef _ENetEvent    ENetEvent;
 struct _ENetHost;
 typedef _ENetHost ENetHost;
+typedef _ENetHost     ENetHost;
 struct _ENetAddress;
+typedef _ENetAddress ENetAddress;
+typedef _ENetAddress  ENetAddress;
+typedef uint8_t       ENetChannelID;
 namespace orxonox
 …
+}
+namespace boost
+{
+  class mutex;
+  class thread;
+}
 #endif /* _NetworkPrereqs_H__ */

code/trunk/src/libraries/network/Server.cc

-                      r7284
+                      r7801
 #include "FunctionCallManager.h"
 #include "GamestateManager.h"
+#include "WANDiscovery.h"
 namespace orxonox
 …
+  }
+  /** helper that connects to the master server */
+  void Server::helper_ConnectToMasterserver()
+  {
+//     WANDiscovery::getInstance().msc.sendRequest( MSPROTO_GAME_SERVER " "
+//       MSPROTO_REGISTER_SERVER );
+  }
   /**
   * This function opens the server by creating the listener thread
 …
     COUT(4) << "opening server" << endl;
     this->openListener();
+    /* make discoverable on LAN */
     LANDiscoverable::setActivity(true);
+    /* make discoverable on WAN */
+    WANDiscoverable::setActivity(true);
+    /* TODO this needs to be optional, we need a switch from the UI to
+     * enable/disable this
+     */
+//     helper_ConnectToMasterserver();
+    /* done */
     return;
+  }
 …
     this->disconnectClients();
     this->closeListener();
+    /* tell master server we're closing */
+    COUT(2) << "disconnecting." << endl;
+    WANDiscoverable::setActivity(false);
+    COUT(2) << "disconnecting done" << endl;
     LANDiscoverable::setActivity(false);
     return;
 …
     while(temp){
       chat = new packet::Chat(message, playerID);
       chat->setClientID(temp->getID());
       if(!chat->send())
+      chat->setPeerID(temp->getID());
+      if(!chat->send( static_cast<Host*>(this) ))
         COUT(3) << "could not send Chat message to client ID: " << temp->getID() << std::endl;
       temp = temp->next();
 …
+  }
+  /* handle incoming data */
+  int rephandler( char *addr, ENetEvent *ev )
+  {
+    /* reply to pings */
+    if( !strncmp( (char *)ev->packet->data, MSPROTO_PING_GAMESERVER,
+      MSPROTO_PING_GAMESERVER_LEN ) )
+      //this->msc.sendRequest( MSPROTO_ACK );
+      /* NOTE implement this after pollForReply
+       * reimplementation
+       */
+      return 0;
+    /* done handling, return all ok code 0 */
+    return 0;
+  }
+  void Server::helper_HandleMasterServerRequests()
+  {
+    /* poll the master server for replies and see whether something
+     * has to be done or changed.
+     */
+    //WANDiscovery::getInstance().msc.pollForReply( rhandler, 10 );
+  }
   /**
 …
     // receive incoming packets
     Connection::processQueue();
     // receive and process incoming discovery packets
     LANDiscoverable::update();
+    // receive and process requests from master server
+    /* todo */
+    //helper_HandleMasterServerRequests();
     if ( ClientInformation::hasClients() )
 …
       // process incoming gamestates
       GamestateManager::processGamestates();
+      FunctionCallManager::processBufferedFunctionCalls();
       // send function calls to clients
       FunctionCallManager::sendCalls();
+      FunctionCallManager::sendCalls( static_cast<Host*>(this) );
       //this steers our network frequency
 …
         updateGamestate();
+      }
       sendPackets(); // flush the enet queue
+    }
+  }
   bool Server::queuePacket(ENetPacket *packet, int clientID)
+  {
     return ServerConnection::addPacket(packet, clientID);
+//       sendPackets(); // flush the enet queue
+    }
+  }
+  void Server::queuePacket(ENetPacket *packet, int clientID, uint8_t channelID)
+  {
+    ServerConnection::addPacket(packet, clientID, channelID);
+  }
 …
       return;
     GamestateManager::update();
     COUT(5) << "Server: one gamestate update complete, goig to sendGameState" << std::endl;
+//     COUT(5) << "Server: one gamestate update complete, goig to sendGameState" << std::endl;
     //std::cout << "updated gamestate, sending it" << std::endl;
     //if(clients->getGamestateID()!=GAMESTATEID_INITIAL)
     sendGameState();
+    sendGameStates();
     sendObjectDeletes();
     COUT(5) << "Server: one sendGameState turn complete, repeat in next tick" << std::endl;
+//     COUT(5) << "Server: one sendGameState turn complete, repeat in next tick" << std::endl;
     //std::cout << "sent gamestate" << std::endl;
+  }
+  bool Server::processPacket( ENetPacket *packet, ENetPeer *peer ){
+    packet::Packet *p = packet::Packet::createPacket(packet, peer);
+    return p->process();
+  }
+  /**
+  * sends the gamestate
+  */
+  bool Server::sendGameState()
+  {
+//     COUT(5) << "Server: starting function sendGameState" << std::endl;
+//     ClientInformation *temp = ClientInformation::getBegin();
+//     bool added=false;
+//     while(temp != NULL){
+//       if( !(temp->getSynched()) ){
+//         COUT(5) << "Server: not sending gamestate" << std::endl;
+//         temp=temp->next();
+//         if(!temp)
+//           break;
+//         continue;
+//       }
+//       COUT(4) << "client id: " << temp->getID() << " RTT: " << temp->getRTT() << " loss: " << temp->getPacketLoss() << std::endl;
+//       COUT(5) << "Server: doing gamestate gamestate preparation" << std::endl;
+//       int cid = temp->getID(); //get client id
+//       packet::Gamestate *gs = GamestateManager::popGameState(cid);
+//       if(gs==NULL){
+//         COUT(2) << "Server: could not generate gamestate (NULL from compress)" << std::endl;
+//         temp = temp->next();
+//         continue;
+//       }
+//       //std::cout << "adding gamestate" << std::endl;
+//       gs->setClientID(cid);
+//       if ( !gs->send() ){
+//         COUT(3) << "Server: packet with client id (cid): " << cid << " not sended: " << temp->getFailures() << std::endl;
+//         temp->addFailure();
+//       }else
+//         temp->resetFailures();
+//       added=true;
+//       temp=temp->next();
+//       // gs gets automatically deleted by enet callback
+//     }
+    GamestateManager::sendGamestates();
+  /**
+  * sends the current gamestate to all peers
+  */
+  bool Server::sendGameStates()
+  {
+    std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
+    std::vector<packet::Gamestate*>::iterator it;
+    for( it = gamestates.begin(); it != gamestates.end(); ++it )
+    {
+      (*it)->send(static_cast<Host*>(this));
+    }
     return true;
+  }
   bool Server::sendObjectDeletes()
 …
       packet::DeleteObjects *cd = new packet::DeleteObjects(*del);
       assert(cd);
       cd->setClientID(cid);
       if ( !cd->send() )
         COUT(3) << "Server: packet with client id (cid): " << cid << " not sended: " << temp->getFailures() << std::endl;
+      cd->setPeerID(cid);
+      if ( !cd->send( static_cast<Host*>(this) ) )
+        COUT(3) << "Server: packet with client id (cid): " << cid << " not sended" << std::endl;
       temp=temp->next();
       // gs gets automatically deleted by enet callback
 …
     // inform all the listeners
     ClientConnectionListener::broadcastClientConnected(newid);
+    GamestateManager::addPeer(newid);
     ++newid;
 …
     else
+    {
+      GamestateManager::removePeer(client->getID());
       //ServerConnection::disconnectClient( client );
       //ClientConnectionListener::broadcastClientDisconnected( client->getID() ); //this is done in ClientInformation now
 …
+    }
+  }
+  void Server::processPacket(packet::Packet* packet)
+  {
+    if( packet->isReliable() )
+    {
+      if( this->getLastProcessedGamestateID(packet->getPeerID()) >= packet->getRequiredGamestateID() )
+        packet->process(static_cast<Host*>(this));
+      else
+        this->packetQueue_.push_back(packet);
+    }
+    else
+      packet->process(static_cast<Host*>(this));
+  }
   bool Server::createClient(int clientID)
 …
       return false;
+    }
     COUT(5) << "Con.Man: creating client id: " << temp->getID() << std::endl;
+    COUT(4) << "Con.Man: creating client id: " << temp->getID() << std::endl;
     // synchronise class ids
 …
     // now synchronise functionIDs
     packet::FunctionIDs *fIDs = new packet::FunctionIDs();
     fIDs->setClientID(clientID);
     bool b = fIDs->send();
+    fIDs->setPeerID(clientID);
+    bool b = fIDs->send( static_cast<Host*>(this) );
     assert(b);
     temp->setSynched(true);
+    GamestateManager::setSynched(clientID);
     COUT(4) << "sending welcome" << std::endl;
     packet::Welcome *w = new packet::Welcome(temp->getID(), temp->getShipID());
     w->setClientID(temp->getID());
     b = w->send();
+    w->setPeerID(temp->getID());
+    b = w->send( static_cast<Host*>(this) );
     assert(b);
     packet::Gamestate *g = new packet::Gamestate();
+    g->setClientID(temp->getID());
+    b = g->collectData(0,0x1);
+    g->setPeerID(temp->getID());
+    b = g->collectData(0,packet::GAMESTATE_MODE_SERVER);
+    assert(b);
     if(!b)
       return false; //no data for the client
     b = g->compressData();
     assert(b);
     b = g->send();
+//     b = g->compressData();
+//     assert(b);
+    b = g->send( static_cast<Host*>(this) );
     assert(b);
     return true;
 …
+  {
     ServerConnection::disconnectClient( client );
     GamestateManager::removeClient(client);
+    GamestateManager::removePeer(client->getID());
     // inform all the listeners
     // ClientConnectionListener::broadcastClientDisconnected(client->getID()); // this is done in ClientInformation now
 …
+    {
       chat = new packet::Chat(message, clientID);
       chat->setClientID(temp->getID());
       if(!chat->send())
+      chat->setPeerID(temp->getID());
+      if(!chat->send( static_cast<Host*>(this) ))
         COUT(3) << "could not send Chat message to client ID: " << temp->getID() << std::endl;
       temp = temp->next();
 …
     int failures=0;
     packet::ClassID *classid = new packet::ClassID();
     classid->setClientID(clientID);
     while(!classid->send() && failures < 10){
+    classid->setPeerID(clientID);
+    while(!classid->send( static_cast<Host*>(this) ) && failures < 10){
       failures++;
+    }

code/trunk/src/libraries/network/Server.h

-                      r7163
+                      r7801
 #include "NetworkPrereqs.h"
+#include <deque>
 #include "util/UtilPrereqs.h"
 #include "core/CorePrereqs.h"
 #include "Host.h"
 #include "GamestateManager.h"
+// #include "GamestateManager.h"
 #include "ServerConnection.h"
 #include "LANDiscoverable.h"
+#include "WANDiscoverable.h"
+// #include "MasterServerComm.h"
+// #include "MasterServerProtocol.h"
 namespace orxonox
 …
   * It implements all functions necessary for a Server
   */
+  class _NetworkExport Server : public Host, public ServerConnection, public GamestateManager, public LANDiscoverable{
+  class _NetworkExport Server : public Host, public ServerConnection, public LANDiscoverable, public WANDiscoverable
+  {
   public:
     Server();
 …
     ~Server();
+    /* helpers */
+    void helper_ConnectToMasterserver();
+    void helper_HandleMasterServerRequests();
+    int replyhandler( char *addr, ENetEvent *ev );
     void open();
     void close();
     bool processChat(const std::string& message, unsigned int playerID);
+    bool queuePacket(ENetPacket *packet, int clientID);
+    void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID);
+    virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
     void update(const Clock& time);
     unsigned int getRTT(unsigned int clientID);
 …
   private:
     virtual bool isServer_(){return true;}
-    unsigned int shipID(){return 0;}
     unsigned int playerID(){return 0;}
     void addPeer(ENetEvent *event);
     void removePeer(ENetEvent *event);
+    void processPacket(packet::Packet* packet);
     bool createClient(int clientID);
     void disconnectClient( ClientInformation *client);
+    bool processPacket( ENetPacket *packet, ENetPeer *peer );
+    bool sendGameState();
+    bool sendGameStates();
     bool sendObjectDeletes();
     virtual bool chat(const std::string& message);
 …
     float timeSinceLastUpdate_;
+    std::deque<packet::Packet*> packetQueue_;
   };

code/trunk/src/libraries/network/ServerConnection.cc

-                      r7459
+                      r7801
+  }
+  ServerConnection::~ServerConnection(){
+  ServerConnection::~ServerConnection()
+  {
     if ( this->bListening_ )
       closeListener();
 …
+  }
+  void ServerConnection::setBindAddress( const std::string& bindAddress ) {
+  void ServerConnection::setBindAddress( const std::string& bindAddress )
+  {
     if (enet_address_set_host (this->bindAddress_, bindAddress.c_str()) < 0)
         COUT(1) << "Error: Could not resolve \"" << bindAddress << "\"." << std::endl;
 …
+  }
+  bool ServerConnection::openListener() {
+    this->host_ = enet_host_create(this->bindAddress_, NETWORK_MAX_CONNECTIONS, 0, 0, 0);
+  bool ServerConnection::openListener()
+  {
+    // create host
+    this->host_ = enet_host_create(this->bindAddress_, NETWORK_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
     if ( this->host_ == NULL )
+    {
 …
         return false;
+    }
+    // enable compression
+    this->enableCompression();
     assert( this->host_->socket4 != ENET_SOCKET_NULL || this->host_->socket6 != ENET_SOCKET_NULL );
     if (this->host_->socket4 == ENET_SOCKET_NULL)
 …
     else
         COUT(3) << "Info: Using IPv4 and IPv6 Sockets." << std::endl;
+    // start communication thread
+    Connection::startCommunicationThread();
     return true;
+  }
+  bool ServerConnection::closeListener() {
+  bool ServerConnection::closeListener()
+  {
     this->bListening_=false;
     disconnectClients();
+    Connection::stopCommunicationThread();
     enet_host_destroy(this->host_);
     return true;
+  }
+  bool ServerConnection::addPacket(ENetPacket *packet, unsigned int clientID) {
+  void ServerConnection::addPacket(ENetPacket *packet, unsigned int clientID, uint8_t channelID)
+  {
     if ( clientID == CLIENTID_UNKNOWN )
+    {
       return addPacketAll(packet);
+      broadcastPacket(packet, channelID);
+    }
     else
 …
       if(!temp){
         COUT(3) << "C.Man: addPacket findClient failed" << std::endl;
-        return false;
+      }
       return Connection::addPacket(packet, temp->getPeer());
+      Connection::addPacket(packet, temp->getPeer(), channelID);
+    }
+  }
-  bool ServerConnection::addPacketAll(ENetPacket *packet) {
-//     if ( !Connection::getInstance() )
-//       return false;
-    enet_host_broadcast( Connection::getHost(), 0, packet);
-    return true;
+  }
 …
+  }
+  void ServerConnection::disconnectClient(int clientID){
+  void ServerConnection::disconnectClient(int clientID)
+  {
     ClientInformation *client = ClientInformation::findClient(clientID);
     if(client)
 …
+  }
   void ServerConnection::disconnectClients() {
     ENetEvent event;
+  void ServerConnection::disconnectClients()
+  {
     ClientInformation *temp = ClientInformation::getBegin();
+    while(temp!=0){
+    while(temp!=0)
+    {
       ServerConnection::disconnectClient( temp );
       temp = temp->next();
+    }
-    temp = ClientInformation::getBegin();
-    while( temp!=0 ){
-      if( service( &event ) )
+      {
-        switch (event.type)
+        {
-        case ENET_EVENT_TYPE_NONE: break;
-        case ENET_EVENT_TYPE_CONNECT: break;
-        case ENET_EVENT_TYPE_RECEIVE:
-          enet_packet_destroy(event.packet);
-          break;
-        case ENET_EVENT_TYPE_DISCONNECT:
-          removePeer( &event );
-          temp = ClientInformation::getBegin();
-          break;
+        }
+      }
+    }
     return;
 …
+  int ServerConnection::getClientID(ENetPeer* peer) {
+  int ServerConnection::getClientID(ENetPeer* peer)
+  {
     return getClientID(&(peer->address));
+  }
+  int ServerConnection::getClientID(ENetAddress* address) {
+  int ServerConnection::getClientID(ENetAddress* address)
+  {
     return ClientInformation::findClient(address)->getID();
+  }
+  ENetPeer *ServerConnection::getClientPeer(int clientID) {
+  ENetPeer *ServerConnection::getClientPeer(int clientID)
+  {
     return ClientInformation::findClient(clientID)->getPeer();
+  }

code/trunk/src/libraries/network/ServerConnection.h

-                      r7163
+                      r7801
     bool openListener();
     bool closeListener();
+    bool addPacket(ENetPacket *packet, unsigned int ID);
+    bool addPacketAll(ENetPacket *packet);
+    void addPacket(ENetPacket *packet, unsigned int ID, uint8_t channelID);
     virtual void disconnectClient(ClientInformation *client);
     void disconnectClient(int clientID);

code/trunk/src/libraries/network/WANDiscovery.cc

-                      r7786
+                      r7801
 namespace orxonox
+{
   ManageScopedSingleton(WANDiscovery, ScopeID::Root, true);
+  ManageScopedSingleton(WANDiscovery, ScopeID::Graphics, true);
 …
      * has changed.
      */
     SetConfigValue( msaddress, "localhost");
+    SetConfigValue( msaddress, "orxonox.net");
+  }

code/trunk/src/libraries/network/packet/Acknowledgement.cc

-                      r6417
+                      r7801
 #include "util/Debug.h"
 #include "network/GamestateHandler.h"
+#include "network/Host.h"
 namespace orxonox {
 …
 #define _ACKID              _PACKETID + sizeof(packet::Type::Value)
 Acknowledgement::Acknowledgement( unsigned int id, unsigned int clientID )
+Acknowledgement::Acknowledgement( unsigned int id, unsigned int peerID )
  : Packet()
+{
 …
   *(Type::Value *)(data_ + _PACKETID ) = Type::Acknowledgement;
   *(uint32_t *)(data_ + _ACKID ) = id;
   clientID_=clientID;
+  peerID_=peerID;
+}
 Acknowledgement::Acknowledgement( uint8_t *data, unsigned int clientID )
   : Packet(data, clientID)
+Acknowledgement::Acknowledgement( uint8_t *data, unsigned int peerID )
+  : Packet(data, peerID)
+{
+}
 …
+}
 bool Acknowledgement::process(){
+bool Acknowledgement::process(orxonox::Host* host){
   COUT(5) << "processing ACK with ID: " << getAckID() << endl;
   bool b = GamestateHandler::ackGamestate(getAckID(), clientID_);
+  bool b = host->ackGamestate(getAckID(), peerID_);
   delete this;
   return b;

code/trunk/src/libraries/network/packet/Acknowledgement.h

-                      r6073
+                      r7801
+{
 public:
   Acknowledgement( unsigned int id, unsigned int clientID );
   Acknowledgement( uint8_t* data, unsigned int clientID );
+  Acknowledgement( unsigned int id, unsigned int peerID );
+  Acknowledgement( uint8_t* data, unsigned int peerID );
   ~Acknowledgement();
   inline unsigned int getSize() const;
   bool process();
+  virtual bool process(orxonox::Host* host);
   unsigned int getAckID();

code/trunk/src/libraries/network/packet/Chat.cc

-                      r7163
+                      r7801
+}
 bool Chat::process(){
   bool b = Host::incomingChat(std::string((const char*)data_+_MESSAGE), *(uint32_t *)(data_+_PLAYERID));
+bool Chat::process(orxonox::Host* host){
+  bool b = host->incomingChat(std::string((const char*)data_+_MESSAGE), *(uint32_t *)(data_+_PLAYERID));
   delete this;
   return b;

code/trunk/src/libraries/network/packet/Chat.h

r7163	r7801
52	52
53	53	/* process chat message packet and remove it afterwards */
54		~~bool process(~~);
	54	virtual bool process(orxonox::Host* host);
55	55
56	56	/* Get the length of the message (not the full size of the packet) */

code/trunk/src/libraries/network/packet/ClassID.cc

r7163	r7801
120	120
121	121
122		bool ClassID::process(){
	122	bool ClassID::process(orxonox::Host* host){
123	123	int nrOfClasses;
124	124	uint8_t *temp = data_+sizeof(uint32_t); //skip the packetid

code/trunk/src/libraries/network/packet/ClassID.h

r6417	r7801
48	48
49	49	uint32_t getSize() const;
50		~~bool process(~~);
	50	virtual bool process(orxonox::Host* host);
51	51
52	52	private:

code/trunk/src/libraries/network/packet/DeleteObjects.cc

-                      r6417
+                      r7801
+}
+bool DeleteObjects::fetchIDs(){
+bool DeleteObjects::fetchIDs()
+{
   unsigned int number = Synchronisable::getNumberOfDeletedObject();
   if(number==0)
 …
+}
+unsigned int DeleteObjects::getSize() const{
+unsigned int DeleteObjects::getSize() const
+{
   assert(data_);
   return _OBJECTIDS + *(uint32_t*)(data_+_QUANTITY)*sizeof(uint32_t);
+}
+bool DeleteObjects::process(){
+  for(unsigned int i=0; i<*(unsigned int *)(data_+_QUANTITY); i++){
+bool DeleteObjects::process(orxonox::Host* host)
+{
+  for(unsigned int i=0; i<*(unsigned int *)(data_+_QUANTITY); i++)
+  {
     COUT(4) << "deleting object with id: " << *(uint32_t*)(data_+_OBJECTIDS+i*sizeof(uint32_t)) << std::endl;
     Synchronisable::deleteObject( *(uint32_t*)(data_+_OBJECTIDS+i*sizeof(uint32_t)) );

code/trunk/src/libraries/network/packet/DeleteObjects.h

-                      r6073
+                      r7801
 #include "Packet.h"
+namespace orxonox {
+namespace packet {
+namespace orxonox
+{
+namespace packet
+{
 /**
     @author
 …
   inline unsigned int getSize() const;
   bool process();
+  virtual bool process(orxonox::Host* host);
 private:

code/trunk/src/libraries/network/packet/FunctionCalls.cc

-                      r7495
+                      r7801
 #include "network/FunctionCall.h"
 #include "network/FunctionCallManager.h"
+#include "network/GamestateHandler.h"
 namespace orxonox {
 …
 const unsigned int FUNCTIONCALLS_MEM_ALLOCATION = 1000;
 FunctionCalls::FunctionCalls()
  : Packet()
+FunctionCalls::FunctionCalls():
+  Packet(), minGamestateID_(GAMESTATEID_INITIAL)
+{
   flags_ = flags_ | PACKET_FLAGS_FUNCTIONCALLS;
   currentSize_ = 2*sizeof(uint32_t); // for packetid and nrOfCalls
+  currentSize_ = 3*sizeof(uint32_t); // for packetid, nrOfCalls and minGamestateID_
+}
 FunctionCalls::FunctionCalls( uint8_t* data, unsigned int clientID )
   : Packet(data, clientID)
+FunctionCalls::FunctionCalls( uint8_t* data, unsigned int clientID ):
+  Packet(data, clientID), minGamestateID_(GAMESTATEID_INITIAL)
+{
+}
 …
+bool FunctionCalls::process(){
+bool FunctionCalls::process(orxonox::Host* host)
+{
   assert(isDataENetAllocated());
   uint8_t* temp = data_+sizeof(uint32_t); //skip packetid
   uint32_t nrOfCalls = *(uint32_t*)temp;
+  temp += sizeof(uint32_t);
+  this->minGamestateID_ = *(uint32_t*)temp;
   temp += sizeof(uint32_t);
   for( unsigned int i = 0; i<nrOfCalls; i++ )
 …
     fctCall.loadData(temp);
     if( !fctCall.execute() )
+      FunctionCallManager::bufferIncomingFunctionCall( fctCall );
+    {
+      FunctionCallManager::bufferIncomingFunctionCall( fctCall, minGamestateID_, this->getPeerID() );
+    }
+  }
 …
+}
+void FunctionCalls::addCallStatic( uint32_t networkID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5){
+void FunctionCalls::addCallStatic( uint32_t networkID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5)
+{
   assert(!isDataENetAllocated());
 …
+}
+void FunctionCalls::addCallMember( uint32_t networkID, uint32_t objectID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5){
+void FunctionCalls::addCallMember( uint32_t networkID, uint32_t objectID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5)
+{
   assert(!isDataENetAllocated());
 …
+}
 bool FunctionCalls::send()
+bool FunctionCalls::send(orxonox::Host* host)
+{
+  this->minGamestateID_ = host->getCurrentGamestateID();
   assert(this->functionCalls_.size());
   data_=new uint8_t[ currentSize_ ];
   *(Type::Value *)(data_ + _PACKETID ) = Type::FunctionCalls; // Set the Packet ID
+  *(uint32_t*)(data_+sizeof(uint32_t)) = this->functionCalls_.size(); // set nrOfCalls to 0
+  uint8_t* temp = data_+2*sizeof(uint32_t);
+  *(uint32_t*)(data_+sizeof(uint32_t)) = this->functionCalls_.size(); // set nrOfCalls
+  *(uint32_t*)(data_+2*sizeof(uint32_t)) = this->minGamestateID_; // set minGamestateID_
+  uint8_t* temp = data_+3*sizeof(uint32_t);
   while( this->functionCalls_.size() )
 …
   assert( temp==data_+currentSize_ );
   Packet::send();
+  Packet::send(host);
   return true;
+}

code/trunk/src/libraries/network/packet/FunctionCalls.h

-                      r7490
+                      r7801
   inline unsigned int getSize() const
     { assert(!this->isDataENetAllocated()); return currentSize_; }
   bool process();
+  virtual bool process(orxonox::Host* host);
   void addCallStatic( uint32_t networkID, const MultiType* mt1=0, const MultiType* mt2=0, const MultiType* mt3=0, const MultiType* mt4=0, const MultiType* mt5=0);
   void addCallMember( uint32_t networkID, uint32_t objectID, const MultiType* mt1=0, const MultiType* mt2=0, const MultiType* mt3=0, const MultiType* mt4=0, const MultiType* mt5=0);
   virtual bool send();
+  virtual bool send(orxonox::Host* host);
 private:
   std::queue<orxonox::FunctionCall> functionCalls_;
   unsigned int                      clientID_;
+  uint32_t                          minGamestateID_;
   uint32_t                          currentSize_;
 };

code/trunk/src/libraries/network/packet/FunctionIDs.cc

-                      r6417
+                      r7801
+FunctionIDs::FunctionIDs( ) : Packet(){
+FunctionIDs::FunctionIDs( ) : Packet()
+{
   unsigned int nrOfFunctions=0;
   unsigned int packetSize=2*sizeof(uint32_t); //space for the packetID and for the nroffunctions
 …
   //calculate total needed size (for all strings and integers)
   ObjectList<NetworkFunctionBase>::iterator it;
+  for(it = ObjectList<NetworkFunctionBase>::begin(); it; ++it){
+  for(it = ObjectList<NetworkFunctionBase>::begin(); it; ++it)
+  {
     const std::string& functionname = it->getName();
     networkID = it->getNetworkID();
 …
   // now save all classids and classnames
   std::pair<uint32_t, std::string> tempPair;
+  while( !tempQueue.empty() ){
+  while( !tempQueue.empty() )
+  {
     tempPair = tempQueue.front();
     tempQueue.pop();
 …
+}
+uint32_t FunctionIDs::getSize() const{
+uint32_t FunctionIDs::getSize() const
+{
   assert(this->data_);
   uint8_t *temp = data_+sizeof(uint32_t); // packet identification
 …
+bool FunctionIDs::process(){
+bool FunctionIDs::process(orxonox::Host* host)
+{
   int nrOfFunctions;
   uint8_t *temp = data_+sizeof(uint32_t); //skip the packetid
 …
   temp += sizeof(uint32_t);
+  for( int i=0; i<nrOfFunctions; i++){
+  for( int i=0; i<nrOfFunctions; i++)
+  {
     networkID = *(uint32_t*)temp;
     stringsize = *(uint32_t*)(temp+sizeof(uint32_t));

code/trunk/src/libraries/network/packet/FunctionIDs.h

-                      r6417
+                      r7801
   ~FunctionIDs();
   uint32_t getSize() const;
   bool process();
+  virtual uint32_t getSize() const;
+  virtual bool process(orxonox::Host* host);
 private:

code/trunk/src/libraries/network/packet/Gamestate.cc

-                      r7163
+                      r7801
 #include "network/synchronisable/Synchronisable.h"
 #include "network/GamestateHandler.h"
+#include "network/Host.h"
 namespace orxonox {
 …
 #define GAMESTATE_START(data) (data + GamestateHeader::getSize())
+#define PACKET_FLAG_GAMESTATE  PacketFlag::Reliable
+// #define PACKET_FLAG_GAMESTATE  PacketFlag::Reliable
+#define PACKET_FLAG_GAMESTATE  0
 inline bool memzero( uint8_t* data, uint32_t datalength)
 …
 Gamestate::Gamestate():
   header_(0)
+  header_()
+{
   flags_ = flags_ | PACKET_FLAG_GAMESTATE;
 …
 Gamestate::Gamestate(uint8_t *data, unsigned int clientID):
   Packet(data, clientID)
+  Packet(data, clientID), header_(data)
+{
   flags_ = flags_ | PACKET_FLAG_GAMESTATE;
+  header_ = new GamestateHeader(data_);
+}
 Gamestate::Gamestate(uint8_t *data)
+}
+Gamestate::Gamestate(uint8_t *data):
+  header_(data)
+{
   flags_ = flags_ | PACKET_FLAG_GAMESTATE;
   data_ = data;
-  header_ = new GamestateHeader(data_);
+}
 Gamestate::Gamestate(const Gamestate& g) :
     Packet( *(Packet*)&g ), nrOfVariables_(0)
+  Packet( *(Packet*)&g ), header_(this->data_), nrOfVariables_(0)
+{
   flags_ = flags_ | PACKET_FLAG_GAMESTATE;
-  header_ = new GamestateHeader(data_);
   sizes_ = g.sizes_;
+}
 …
 Gamestate::~Gamestate()
+{
-  if( header_ )
-    delete header_;
+}
 …
 bool Gamestate::collectData(int id, uint8_t mode)
+{
-  assert(this->header_==0); // make sure the header didn't exist before
   uint32_t tempsize=0, currentsize=0;
   assert(data_==0);
 …
+  }
+  // create the header object
+  assert( header_ == 0 );
+  header_ = new GamestateHeader(data_);
+  // tell the gamestate header where to store the data
+  header_.setData(this->data_);
   //start collect data synchronisable by synchronisable
 …
       assert(0); // if we don't use multithreading this part shouldn't be neccessary
       // start allocate additional memory
       COUT(3) << "G.St.Man: need additional memory" << std::endl;
+      COUT(3) << "Gamestate: need additional memory" << std::endl;
       ObjectList<Synchronisable>::iterator temp = it;
       uint32_t addsize=tempsize;
 …
   //start write gamestate header
   header_->setDataSize( currentsize );
   header_->setID( id );
   header_->setBaseID( GAMESTATEID_INITIAL );
   header_->setDiffed( false );
   header_->setComplete( true );
   header_->setCompressed( false );
+  header_.setDataSize( currentsize );
+  header_.setID( id );
+  header_.setBaseID( GAMESTATEID_INITIAL );
+  header_.setDiffed( false );
+  header_.setComplete( true );
+  header_.setCompressed( false );
   //stop write gamestate header
   COUT(5) << "G.ST.Man: Gamestate size: " << currentsize << std::endl;
   COUT(5) << "G.ST.Man: 'estimated' (and corrected) Gamestate size: " << size << std::endl;
+  COUT(5) << "Gamestate: Gamestate size: " << currentsize << std::endl;
+  COUT(5) << "Gamestate: 'estimated' (and corrected) Gamestate size: " << size << std::endl;
   return true;
+}
 …
 bool Gamestate::spreadData(uint8_t mode)
+{
   COUT(4) << "processing gamestate with id " << header_->getID() << endl;
+  COUT(5) << "processing gamestate with id " << header_.getID() << endl;
   assert(data_);
   assert(!header_->isCompressed());
+  assert(!header_.isCompressed());
   uint8_t *mem=data_+GamestateHeader::getSize();
   Synchronisable *s;
   // update the data of the objects we received
   while(mem < data_+GamestateHeader::getSize()+header_->getDataSize())
+  while(mem < data_+GamestateHeader::getSize()+header_.getDataSize())
+  {
     SynchronisableHeader objectheader(mem);
 …
       else
+      {
+//         COUT(4) << "not creating object of classid " << objectheader.getClassID() << endl;
         mem += objectheader.getDataSize() + ( objectheader.isDiffed() ? SynchronisableHeaderLight::getSize() : SynchronisableHeader::getSize() );
+      }
 …
     else
+    {
+//       COUT(4) << "updating object of classid " << objectheader.getClassID() << endl;
       bool b = s->updateData(mem, mode);
       assert(b);
+    }
+  }
+  assert(mem-data_ == GamestateHeader::getSize()+header_.getDataSize());
    // In debug mode, check first, whether there are no duplicate objectIDs
 #ifndef NDEBUG
 …
+{
   assert(data_);
   if(header_->isCompressed())
     return header_->getCompSize()+GamestateHeader::getSize();
+  if(header_.isCompressed())
+    return header_.getCompSize()+GamestateHeader::getSize();
   else
+  {
     return header_->getDataSize()+GamestateHeader::getSize();
+    return header_.getDataSize()+GamestateHeader::getSize();
+  }
+}
 …
 bool Gamestate::process()
+{
   return GamestateHandler::addGamestate(this, getClientID());
+bool Gamestate::process(orxonox::Host* host)
+{
+  return host->addGamestate(this, getPeerID());
+}
 …
+{
   assert(data_);
   assert(!header_->isCompressed());
   uLongf buffer = (uLongf)(((header_->getDataSize() + 12)*1.01)+1);
+  assert(!header_.isCompressed());
+  uLongf buffer = (uLongf)(((header_.getDataSize() + 12)*1.01)+1);
   if(buffer==0)
     return false;
 …
   uint8_t *source = data_ + GamestateHeader::getSize();
   int retval;
   retval = compress( dest, &buffer, source, (uLong)(header_->getDataSize()) );
+  retval = compress( dest, &buffer, source, (uLong)(header_.getDataSize()) );
   switch ( retval )
+  {
 …
   //copy and modify header
+  GamestateHeader *temp = header_;
+  header_ = new GamestateHeader(ndata, temp);
+  GamestateHeader *temp = new GamestateHeader(data_);
+  header_.setData(ndata);
+  header_ = *temp;
   delete temp;
   //delete old data
 …
   //save new data
   data_ = ndata;
   header_->setCompSize( buffer );
   header_->setCompressed( true );
   COUT(0) << "gamestate compress datasize: " << header_->getDataSize() << " compsize: " << header_->getCompSize() << std::endl;
+  header_.setCompSize( buffer );
+  header_.setCompressed( true );
+  COUT(4) << "gamestate compress datasize: " << header_.getDataSize() << " compsize: " << header_.getCompSize() << std::endl;
   return true;
+}
 …
+{
   assert(data_);
   assert(header_->isCompressed());
   COUT(4) << "GameStateClient: uncompressing gamestate. id: " << header_->getID() << ", baseid: " << header_->getBaseID() << ", datasize: " << header_->getDataSize() << ", compsize: " << header_->getCompSize() << std::endl;
   uint32_t datasize = header_->getDataSize();
   uint32_t compsize = header_->getCompSize();
+  assert(header_.isCompressed());
+  COUT(4) << "GameStateClient: uncompressing gamestate. id: " << header_.getID() << ", baseid: " << header_.getBaseID() << ", datasize: " << header_.getDataSize() << ", compsize: " << header_.getCompSize() << std::endl;
+  uint32_t datasize = header_.getDataSize();
+  uint32_t compsize = header_.getCompSize();
   uint32_t bufsize;
   bufsize = datasize;
 …
   //copy over the header
+  GamestateHeader *temp = header_;
+  header_ = new GamestateHeader( data_, header_ );
+  GamestateHeader* temp = new GamestateHeader( data_ );
+  header_.setData(ndata);
+  header_ = *temp;
   delete temp;
 …
   //set new pointers
   data_ = ndata;
   header_->setCompressed( false );
   assert(header_->getDataSize()==datasize);
   assert(header_->getCompSize()==compsize);
+  header_.setCompressed( false );
+  assert(header_.getDataSize()==datasize);
+  assert(header_.getCompSize()==compsize);
   return true;
+}
+inline void /*Gamestate::*/diffObject( uint8_t*& newDataPtr, uint8_t*& origDataPtr, uint8_t*& baseDataPtr, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes )
+{
+  assert( objectHeader.getDataSize() == SynchronisableHeader(baseDataPtr).getDataSize() );
+  uint32_t objectOffset = SynchronisableHeader::getSize(); // offset inside the object in the origData and baseData
+  // Check whether the whole object stayed the same
+  if( memcmp( origDataPtr+objectOffset, baseDataPtr+objectOffset, objectHeader.getDataSize()) == 0 )
+  {
+//     COUT(4) << "skip object " << Synchronisable::getSynchronisable(objectHeader.getObjectID())->getIdentifier()->getName() << endl;
+    origDataPtr += objectOffset + objectHeader.getDataSize(); // skip the whole object
+    baseDataPtr += objectOffset + objectHeader.getDataSize();
+    sizes += Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables();
+  }
+  else
+  {
+    // Now start to diff the Object
+    SynchronisableHeaderLight newObjectHeader(newDataPtr);
+    newObjectHeader = objectHeader; // copy over the objectheader
+    VariableID variableID = 0;
+    uint32_t diffedObjectOffset = SynchronisableHeaderLight::getSize();
+    // iterate through all variables
+    while( objectOffset < objectHeader.getDataSize()+SynchronisableHeader::getSize() )
+    {
+      // check whether variable changed and write id and copy over variable to the new stream
+      // otherwise skip variable
+      uint32_t varSize = *sizes;
+      assert( varSize == Synchronisable::getSynchronisable(objectHeader.getObjectID())->getVarSize(variableID) );
+      if ( varSize != 0 )
+      {
+        if ( memcmp(origDataPtr+objectOffset, baseDataPtr+objectOffset, varSize) != 0 )
+        {
+          *(VariableID*)(newDataPtr+diffedObjectOffset) = variableID; // copy over the variableID
+          diffedObjectOffset += sizeof(VariableID);
+          memcpy( newDataPtr+diffedObjectOffset, origDataPtr+objectOffset, varSize );
+          diffedObjectOffset += varSize;
+          objectOffset += varSize;
+        }
+        else
+        {
+          objectOffset += varSize;
+        }
+      }
+      ++variableID;
+      ++sizes;
+    }
+    // if there are variables from this object with 0 size left in sizes
+    if( Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables() != variableID )
+      sizes += Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables() - variableID;
+    newObjectHeader.setDiffed(true);
+    newObjectHeader.setDataSize(diffedObjectOffset-SynchronisableHeaderLight::getSize());
+    assert(objectOffset == objectHeader.getDataSize()+SynchronisableHeader::getSize());
+    assert(newObjectHeader.getDataSize()>0);
+    origDataPtr += objectOffset;
+    baseDataPtr += objectOffset;
+    newDataPtr += diffedObjectOffset;
+  }
+}
+inline void /*Gamestate::*/copyObject( uint8_t*& newData, uint8_t*& origData, uint8_t*& baseData, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes )
+{
+  //       COUT(4) << "docopy" << endl;
+  // Just copy over the whole Object
+  memcpy( newData, origData, objectHeader.getDataSize()+SynchronisableHeader::getSize() );
+  SynchronisableHeader(newData).setDiffed(false);
+  newData += objectHeader.getDataSize()+SynchronisableHeader::getSize();
+  origData += objectHeader.getDataSize()+SynchronisableHeader::getSize();
+//   SynchronisableHeader baseHeader( baseData );
+//   baseData += baseHeader.getDataSize()+SynchronisableHeader::getSize();
+  //       COUT(4) << "copy " << h.getObjectID() << endl;
+  //       COUT(4) << "copy " << h.getObjectID() << ":";
+  sizes += Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables();
+//   for( unsigned int i = 0; i < Synchronisable::getSynchronisable(objectHeader.getObjectID())->getNrOfVariables(); ++i )
+//   {
+//     //         COUT(4) << " " << *sizes;
+//     ++sizes;
+//   }
+    //       COUT(4) << endl;
+}
+inline bool findObject(uint8_t*& dataPtr, uint8_t* endPtr, SynchronisableHeader& objectHeader)
+{
+  // Some assertions to make sure the dataPtr is valid (pointing to a SynchronisableHeader)
+  {
+    SynchronisableHeader htemp2(dataPtr);
+    assert(htemp2.getClassID()<500);
+    assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
+    assert(htemp2.isDiffed()==false);
+  }
+  uint32_t objectID = objectHeader.getObjectID();
+  while ( dataPtr < endPtr )
+  {
+    SynchronisableHeader htemp(dataPtr);
+    assert( htemp.getDataSize()!=0 );
+    if ( htemp.getObjectID() == objectID )
+    {
+      assert( objectHeader.getClassID() == htemp.getClassID() );
+      assert( objectHeader.getCreatorID() == htemp.getCreatorID() );
+      return true;
+    }
+    {
+      if( dataPtr+htemp.getDataSize()+SynchronisableHeader::getSize() < endPtr )
+      {
+        SynchronisableHeader htemp2(dataPtr+htemp.getDataSize()+SynchronisableHeader::getSize());
+        assert(htemp2.getClassID()<500);
+        assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
+        assert(htemp2.isDiffed()==false);
+      }
+    }
+    dataPtr += htemp.getDataSize()+SynchronisableHeader::getSize();
+  }
+  assert(dataPtr == endPtr);
+  return false;
+}
 Gamestate* Gamestate::diffVariables(Gamestate *base)
+{
   assert(this && base); assert(data_ && base->data_);
+  assert(!header_->isCompressed() && !base->header_->isCompressed());
+  assert(!header_->isDiffed());
+  assert(!header_.isCompressed() && !base->header_.isCompressed());
+  assert(!header_.isDiffed());
+  assert( header_.getDataSize() && base->header_.getDataSize() );
   // *** first do a raw diff of the two gamestates
   uint8_t *baseData = GAMESTATE_START(base->data_);
   uint8_t *origData = GAMESTATE_START(this->data_);
   uint32_t origLength = header_->getDataSize();
   uint32_t baseLength = base->header_->getDataSize();
   assert( origLength && baseLength );
   uint8_t *nData = new uint8_t[origLength + GamestateHeader::getSize() + sizeof(uint32_t)*this->nrOfVariables_]; // this is the maximum size needed in the worst case
   uint8_t *dest = GAMESTATE_START(nData);
   uint32_t baseOffset = 0; //offset in the diffed stream
+  uint32_t origOffset = 0; //offset in the new stream with removed 0's
   std::vector<uint32_t>::iterator sizes = this->sizes_.begin();
   while( origOffset < origLength )
+  uint8_t *baseDataPtr = GAMESTATE_START(base->data_);
+  uint8_t *origDataPtr = GAMESTATE_START(this->data_);
+  uint8_t *origDataEnd = origDataPtr + header_.getDataSize();
+  uint8_t *baseDataEnd = baseDataPtr + base->header_.getDataSize();
+//   uint32_t origLength = header_.getDataSize();
+//   uint32_t baseLength = base->header_.getDataSize();
+  // Allocate new space for diffed gamestate
+  uint32_t newDataSize = header_.getDataSize() + GamestateHeader::getSize() + sizeof(uint32_t)*this->nrOfVariables_;
+  uint8_t *newData = new uint8_t[newDataSize]; // this is the maximum size needed in the worst case
+  uint8_t *destDataPtr = GAMESTATE_START(newData);
+  std::vector<uint32_t>::iterator sizesIt = this->sizes_.begin();
+  while( origDataPtr < origDataEnd )
+  {
     //iterate through all objects
     SynchronisableHeader h(origData+origOffset);
+    SynchronisableHeader origHeader(origDataPtr);
     // Find (if possible) the current object in the datastream of the old gamestate
     // Start at the current offset position
+    if(baseOffset >= baseLength)
+      baseOffset = 0;
+    uint8_t* temp = baseData + baseOffset;
+    uint32_t objectID = h.getObjectID();
+    assert(temp < baseData+baseLength);
+    assert(dest < nData + origLength + GamestateHeader::getSize() + sizeof(uint32_t)*this->nrOfVariables_);
+    assert(sizes != this->sizes_.end());
+    while ( temp < baseData+baseLength )
+    {
+      SynchronisableHeader htemp(temp);
+      assert( htemp.getDataSize()!=0 );
+      if ( htemp.getObjectID() == objectID )
+      {
+        assert( h.getClassID() == htemp.getClassID() );
+        goto DODIFF;
+      }
+//       {
+//         SynchronisableHeader htemp2(temp+htemp.getDataSize()+SynchronisableHeader::getSize());
+//         if( temp+htemp.getDataSize()+SynchronisableHeader::getSize() < baseData+baseLength )
+//         {
+//           assert(htemp2.getClassID()<500);
+//           assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
+//           assert(htemp2.isDiffed()==false);
+//         }
+//       }
+      temp += htemp.getDataSize()+SynchronisableHeader::getSize();
+    if(baseDataPtr == baseDataEnd)
+      baseDataPtr = GAMESTATE_START(base->data_);
+    uint8_t* oldBaseDataPtr = baseDataPtr;
+    assert(baseDataPtr < baseDataEnd);
+    assert(destDataPtr < newData + newDataSize);
+    assert(sizesIt != this->sizes_.end());
+    assert(Synchronisable::getSynchronisable(origHeader.getObjectID()));
+    assert(ClassByID(origHeader.getClassID()));
+    assert(origHeader.getDataSize() < 500);
+    bool diffedObject = false;
+    if( findObject(baseDataPtr, baseDataEnd, origHeader) )
+    {
+      SynchronisableHeader baseHeader(baseDataPtr);
+      assert(Synchronisable::getSynchronisable(baseHeader.getObjectID()));
+      assert(ClassByID(baseHeader.getClassID()));
+      assert(baseHeader.getDataSize() < 500);
+      if( SynchronisableHeader(baseDataPtr).getDataSize()==origHeader.getDataSize() )
+      {
+//         COUT(4) << "diffing object in order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+        diffObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
+        diffedObject = true;
+      }
+      else
+      {
+//         COUT(4) << "copy object because of different data sizes (1): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+        copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
+        assert(sizesIt != this->sizes_.end() || origDataPtr==origDataEnd);
+      }
+    }
+    // If not found start looking at the beginning
+    assert( temp==baseData+baseLength );
+    temp = baseData;
+//     {
+//       SynchronisableHeader htemp2(temp);
+//       if( temp < baseData+baseLength )
+//       {
+//         assert(htemp2.getClassID()<500);
+//         assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
+//         assert(htemp2.isDiffed()==false);
+//       }
+//     }
+    while ( temp < baseData+baseOffset )
+    {
+      SynchronisableHeader htemp(temp);
+      if ( htemp.getObjectID() == objectID )
+      {
+        assert( h.getClassID() == htemp.getClassID() );
+        goto DODIFF;
+      }
+//       {
+//         SynchronisableHeader htemp2(temp+htemp.getDataSize()+SynchronisableHeader::getSize());
+//         if( temp+htemp.getDataSize()+SynchronisableHeader::getSize() < baseData+baseLength )
+//         {
+//           assert(htemp2.getClassID()<500);
+//           assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
+//           assert(htemp2.isDiffed()==false);
+//         }
+//       }
+      temp += htemp.getDataSize()+SynchronisableHeader::getSize();
+    }
+    // Object is new, thus never transmitted -> just copy over
+    goto DOCOPY;
+DODIFF:
+    {
+//       COUT(4) << "dodiff" << endl;
+//       if(baseOffset==0)
+//       {
+//         assert(origOffset==0);
+//       }
+      uint32_t objectOffset = SynchronisableHeader::getSize(); // offset inside the object in the origData and baseData
+      // Check whether the whole object stayed the same
+      if( memcmp( origData+origOffset+objectOffset, temp+objectOffset, h.getDataSize()) == 0 )
+      {
+//         COUT(4) << "skip object" << Synchronisable::getSynchronisable(h.getObjectID())->getIdentifier()->getName() << endl;
+        origOffset += objectOffset+ h.getDataSize(); // skip the whole object
+        baseOffset = temp + h.getDataSize()+SynchronisableHeader::getSize() - baseData;
+        sizes += Synchronisable::getSynchronisable(h.getObjectID())->getNrOfVariables();
+    else
+    {
+      assert( baseDataPtr == baseDataEnd );
+      baseDataPtr = GAMESTATE_START(base->data_);
+      if( findObject(baseDataPtr, oldBaseDataPtr, origHeader) )
+      {
+        SynchronisableHeader baseHeader(baseDataPtr);
+        assert(Synchronisable::getSynchronisable(baseHeader.getObjectID()));
+        assert(ClassByID(baseHeader.getClassID()));
+        assert(baseHeader.getDataSize() < 500);
+        if( SynchronisableHeader(baseDataPtr).getDataSize()==origHeader.getDataSize() )
+        {
+//           COUT(4) << "diffing object out of order: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+          diffObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
+          diffedObject = true;
+        }
+        else
+        {
+//           COUT(4) << "copy object because of different data sizes (2): " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+          copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
+          assert(sizesIt != this->sizes_.end() || origDataPtr==origDataEnd);
+        }
+      }
       else
+      {
+//         if( Synchronisable::getSynchronisable(h.getObjectID())->getIdentifier()->getName() == "Bot" )
+//           COUT(0) << "blub" << endl;
+//         COUT(4) << "object diff: " << Synchronisable::getSynchronisable(h.getObjectID())->getIdentifier()->getName() << endl;
+//         COUT(4) << "diff " << h.getObjectID() << ":";
+        // Now start to diff the Object
+        SynchronisableHeaderLight h2(dest);
+        h2 = h; // copy over the objectheader
+        VariableID variableID = 0;
+        uint32_t newObjectOffset = SynchronisableHeaderLight::getSize();
+        // iterate through all variables
+        while( objectOffset < h.getDataSize()+SynchronisableHeader::getSize() )
+        {
+          // check whether variable changed and write id and copy over variable to the new stream
+          // otherwise skip variable
+          assert(sizes != this->sizes_.end());
+          uint32_t varSize = *sizes;
+          assert( varSize == Synchronisable::getSynchronisable(h.getObjectID())->getVarSize(variableID) );
+          if ( varSize != 0 )
+          {
+            if ( memcmp(origData+origOffset+objectOffset, temp+objectOffset, varSize) != 0 )
+            {
+//               COUT(4) << "copy variable" << endl;
+              *(VariableID*)(dest+newObjectOffset) = variableID; // copy over the variableID
+              newObjectOffset += sizeof(VariableID);
+              memcpy( dest+newObjectOffset, origData+origOffset+objectOffset, varSize );
+              newObjectOffset += varSize;
+              objectOffset += varSize;
+            }
+            else
+            {
+//               COUT(4) << "skip variable" << endl;
+              objectOffset += varSize;
+            }
+          }
+//           else
+//             COUT(4) << "varsize 0" << endl;
+          ++variableID;
+          ++sizes;
+        }
+        if( Synchronisable::getSynchronisable(h.getObjectID())->getNrOfVariables() != variableID )
+          sizes += Synchronisable::getSynchronisable(h.getObjectID())->getNrOfVariables() - variableID;
+//         COUT(4) << endl;
+        h2.setDiffed(true);
+        h2.setDataSize(newObjectOffset-SynchronisableHeaderLight::getSize());
+        assert(objectOffset == h.getDataSize()+SynchronisableHeader::getSize());
+        origOffset += objectOffset;
+//         baseOffset += temp + h.getDataSize()+SynchronisableHeader::getSize() - baseData;
+        //baseOffset += objectOffset;
+//         SynchronisableHeader htemp(temp);
+//         baseOffset += SynchronisableHeader::getSize() + htemp.getDataSize();
+//         {
+//           SynchronisableHeader htemp2( baseData+(temp-baseData+objectOffset) );
+//           if( baseData+(temp-baseData+objectOffset) < baseData+baseLength )
+//           {
+//             assert(htemp2.getClassID()<500);
+//             assert(htemp2.getDataSize()!=0 && htemp2.getDataSize()<1000);
+//             assert(htemp2.isDiffed()==false);
+//           }
+//         }
+        baseOffset = temp-baseData + objectOffset;
+        dest += newObjectOffset;
+      }
+      continue;
+    }
+DOCOPY:
+    {
+//       COUT(4) << "docopy" << endl;
+      // Just copy over the whole Object
+      memcpy( dest, origData+origOffset, h.getDataSize()+SynchronisableHeader::getSize() );
+      dest += h.getDataSize()+SynchronisableHeader::getSize();
+      origOffset += h.getDataSize()+SynchronisableHeader::getSize();
+      assert( Synchronisable::getSynchronisable(h.getObjectID()) );
+//       COUT(4) << "copy " << h.getObjectID() << endl;
+//       COUT(4) << "copy " << h.getObjectID() << ":";
+      //sizes += Synchronisable::getSynchronisable(h.getObjectID())->getNrOfVariables();
+      for( unsigned int i = 0; i < Synchronisable::getSynchronisable(h.getObjectID())->getNrOfVariables(); ++i )
+      {
+//         COUT(4) << " " << *sizes;
+        ++sizes;
+      }
+//       COUT(4) << endl;
+      assert(sizes != this->sizes_.end() || origOffset>=origLength);
+      continue;
+    }
+  }
+  Gamestate *g = new Gamestate(nData, getClientID());
+  assert(g->header_);
+  *(g->header_) = *header_;
+  g->header_->setBaseID( base->getID() );
+  g->header_->setDataSize(dest - nData - GamestateHeader::getSize());
+//         COUT(4) << "copy object: " << Synchronisable::getSynchronisable(origHeader.getObjectID())->getIdentifier()->getName() << endl;
+        assert(baseDataPtr == oldBaseDataPtr);
+        copyObject(destDataPtr, origDataPtr, baseDataPtr, origHeader, sizesIt);
+        assert(sizesIt != this->sizes_.end() || origDataPtr==origDataEnd);
+      }
+    }
+  }
+  assert(sizesIt==this->sizes_.end());
+  Gamestate *g = new Gamestate(newData, getPeerID());
+  (g->header_) = header_;
+  g->header_.setBaseID( base->getID() );
+  g->header_.setDataSize(destDataPtr - newData - GamestateHeader::getSize());
   g->flags_=flags_;
   g->packetDirection_ = packetDirection_;
 …
 Gamestate* Gamestate::diffData(Gamestate *base)
+/*Gamestate* Gamestate::diffData(Gamestate *base)
+{
   assert(this && base); assert(data_ && base->data_);
   assert(!header_->isCompressed() && !base->header_->isCompressed());
   assert(!header_->isDiffed());
+  assert(!header_.isCompressed() && !base->header_.isCompressed());
+  assert(!header_.isDiffed());
   uint8_t *basep = GAMESTATE_START(base->data_);
   uint8_t *gs = GAMESTATE_START(this->data_);
   uint32_t dest_length = header_->getDataSize();
+  uint32_t dest_length = header_.getDataSize();
   if(dest_length==0)
 …
   uint8_t *dest = GAMESTATE_START(ndata);
   rawDiff( dest, gs, basep, header_->getDataSize(), base->header_->getDataSize() );
+  rawDiff( dest, gs, basep, header_.getDataSize(), base->header_.getDataSize() );
 #ifndef NDEBUG
   uint8_t *dest2 = new uint8_t[dest_length];
   rawDiff( dest2, dest, basep, header_->getDataSize(), base->header_->getDataSize() );
+  rawDiff( dest2, dest, basep, header_.getDataSize(), base->header_.getDataSize() );
   assert( memcmp( dest2, gs, dest_length) == 0 );
   delete dest2;
 …
   assert(g->header_);
   *(g->header_) = *header_;
   g->header_->setDiffed( true );
   g->header_->setBaseID( base->getID() );
+  g->header_.setDiffed( true );
+  g->header_.setBaseID( base->getID() );
   g->flags_=flags_;
   g->packetDirection_ = packetDirection_;
 …
+{
   assert(this && base); assert(data_ && base->data_);
   assert(!header_->isCompressed() && !base->header_->isCompressed());
   assert(header_->isDiffed());
+  assert(!header_.isCompressed() && !base->header_.isCompressed());
+  assert(header_.isDiffed());
   uint8_t *basep = GAMESTATE_START(base->data_);
   uint8_t *gs = GAMESTATE_START(this->data_);
   uint32_t dest_length = header_->getDataSize();
+  uint32_t dest_length = header_.getDataSize();
   if(dest_length==0)
 …
   uint8_t *dest = ndata + GamestateHeader::getSize();
   rawDiff( dest, gs, basep, header_->getDataSize(), base->header_->getDataSize() );
+  rawDiff( dest, gs, basep, header_.getDataSize(), base->header_.getDataSize() );
   Gamestate *g = new Gamestate(ndata, getClientID());
   assert(g->header_);
   *(g->header_) = *header_;
   g->header_->setDiffed( false );
+  g->header_.setDiffed( false );
   g->flags_=flags_;
   g->packetDirection_ = packetDirection_;
 …
+  }
   assert(j==datalength);
+}
 Gamestate* Gamestate::doSelection(unsigned int clientID, unsigned int targetSize){
+}*/
+/*Gamestate* Gamestate::doSelection(unsigned int clientID, unsigned int targetSize){
   assert(data_);
   std::list<obj>::iterator it;
   // allocate memory for new data
   uint8_t *gdata = new uint8_t[header_->getDataSize()+GamestateHeader::getSize()];
+  uint8_t *gdata = new uint8_t[header_.getDataSize()+GamestateHeader::getSize()];
   // create a gamestate out of it
   Gamestate *gs = new Gamestate(gdata);
 …
   //call TrafficControl
   TrafficControl::getInstance()->processObjectList( clientID, header_->getID(), dataVector_ );
+  TrafficControl::getInstance()->processObjectList( clientID, header_.getID(), dataVector_ );
   //copy in the zeros
 …
 #ifndef NDEBUG
   uint32_t origsize = destsize;
   while ( origsize < header_->getDataSize() )
+  while ( origsize < header_.getDataSize() )
+  {
     SynchronisableHeader oldobjectheader(origdata);
 …
     origsize += objectsize;
+  }
   assert(origsize==header_->getDataSize());
+  assert(origsize==header_.getDataSize());
   assert(destsize!=0);
 #endif
   gs->header_->setDataSize( destsize );
+  gs->header_.setDataSize( destsize );
   return gs;
+}
 uint32_t Gamestate::calcGamestateSize(int32_t id, uint8_t mode)
+}*/
+uint32_t Gamestate::calcGamestateSize(uint32_t id, uint8_t mode)
+{
   uint32_t size = 0;

code/trunk/src/libraries/network/packet/Gamestate.h

-                      r7163
+                      r7801
 #include "Packet.h"
+namespace orxonox {
+namespace orxonox
+{
+namespace packet {
+namespace packet
+{
+static const uint8_t GAMESTATE_MODE_SERVER = 0x1;
+static const uint8_t GAMESTATE_MODE_CLIENT = 0x2;
+class _NetworkExport GamestateHeader{
+class _NetworkExport GamestateHeader
+{
   public:
+    GamestateHeader(uint8_t *data){ assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
+    GamestateHeader(uint8_t *data, GamestateHeader* h)
+    { assert(data); data_=data; memcpy(data_, h->data_, getSize()); }
+    GamestateHeader(){ data_=0; }
+    GamestateHeader(uint8_t* data)
+      { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
+    /*GamestateHeader(uint8_t* data, GamestateHeader* h)
+      { assert(data); data_=data; memcpy(data_, h->data_, getSize()); }*/
+    void setData(uint8_t* data)
+      { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
     static inline uint32_t getSize()
     { return 21; }
+      { return 21; }
     inline int32_t getID() const
     { assert(data_); return *(int32_t*)(data_+4); }
     inline void setID(int32_t id)
     { assert(data_); *(int32_t*)(data_+4) = id; }
+    inline uint32_t getID() const
+      { assert(data_); return *(uint32_t*)(data_+4); }
+    inline void setID(uint32_t id)
+      { assert(data_); *(uint32_t*)(data_+4) = id; }
     inline int32_t getBaseID() const
     { assert(data_); return *(int32_t*)(data_+8); }
     inline void setBaseID(int32_t id)
     { assert(data_); *(int32_t*)(data_+8) = id; }
+    inline uint32_t getBaseID() const
+      { assert(data_); return *(uint32_t*)(data_+8); }
+    inline void setBaseID(uint32_t id)
+      { assert(data_); *(uint32_t*)(data_+8) = id; }
     inline uint32_t getDataSize() const
     { assert(data_); return *(uint32_t*)(data_+12); }
+      { assert(data_); return *(uint32_t*)(data_+12); }
     inline void setDataSize(uint32_t size)
     { assert(data_); *(uint32_t*)(data_+12) = size; }
+      { assert(data_); *(uint32_t*)(data_+12) = size; }
     inline uint32_t getCompSize() const
 …
     inline bool isDiffed() const
     { assert(data_); return *(int8_t*)(data_+20) & 0x1; }
+      { assert(data_); return *(int8_t*)(data_+20) & 0x1; }
     inline void setDiffed(bool b)
     { assert(data_); *(int8_t*)(data_+20) = (b<<0) | (*(int8_t*)(data_+20) & 0x6 ); }
+      { assert(data_); *(int8_t*)(data_+20) = (b<<0) | (*(int8_t*)(data_+20) & 0x6 ); }
     inline bool isComplete() const
     { assert(data_); return *(int8_t*)(data_+20) & 0x2; }
+      { assert(data_); return *(int8_t*)(data_+20) & 0x2; }
     inline void setComplete(bool b)
     { assert(data_); *(int8_t*)(data_+20) = (b<<1) | (*(int8_t*)(data_+20) & 0x5 ); }
+      { assert(data_); *(int8_t*)(data_+20) = (b<<1) | (*(int8_t*)(data_+20) & 0x5 ); }
     inline bool isCompressed() const
     { assert(data_); return *(int8_t*)(data_+20) & 0x4; }
+      { assert(data_); return *(int8_t*)(data_+20) & 0x4; }
     inline void setCompressed(bool b)
     { assert(data_); *(int8_t*)(data_+20) = (b<<2) | (*(int8_t*)(data_+20) & 0x3 ); }
+      { assert(data_); *(int8_t*)(data_+20) = (b<<2) | (*(int8_t*)(data_+20) & 0x3 ); }
     inline void operator=(GamestateHeader& h)
     { assert(data_); assert(h.data_); memcpy( data_, h.data_, getSize()); }
+      { assert(data_); assert(h.data_); memcpy( data_, h.data_, getSize()); }
   private:
     uint8_t *data_;
+    uint8_t* data_;
 };
 …
     @author Oliver Scheuss
 */
+class _NetworkExport Gamestate: public Packet{
+class _NetworkExport Gamestate: public Packet
+{
   public:
     Gamestate();
 …
     bool collectData(int id, uint8_t mode=0x0);
     bool spreadData( uint8_t mode=0x0);
     inline int32_t getID() const { return header_->getID(); }
     inline bool isDiffed() const { return header_->isDiffed(); }
     inline bool isCompressed() const { return header_->isCompressed(); }
     inline int32_t getBaseID() const { return header_->getBaseID(); }
     inline uint32_t getDataSize() const { return header_->getDataSize(); }
+    inline uint32_t getID() const { return header_.getID(); }
+    inline bool isDiffed() const { return header_.isDiffed(); }
+    inline bool isCompressed() const { return header_.isCompressed(); }
+    inline int32_t getBaseID() const { return header_.getBaseID(); }
+    inline uint32_t getDataSize() const { return header_.getDataSize(); }
     Gamestate* diffVariables(Gamestate *base);
     Gamestate* diffData(Gamestate *base);
     Gamestate *undiff(Gamestate *base);
     Gamestate* doSelection(unsigned int clientID, unsigned int targetSize);
+//     Gamestate* diffData(Gamestate *base);
+//     Gamestate *undiff(Gamestate *base);
+//     Gamestate* doSelection(unsigned int clientID, unsigned int targetSize);
     bool compressData();
     bool decompressData();
 …
     // Packet functions
   private:
     void rawDiff( uint8_t* newdata, uint8_t* data, uint8_t* basedata, uint32_t datalength, uint32_t baselength);
     inline uint32_t findObject( const SynchronisableHeader& header, uint8_t* mem, uint32_t dataLength, uint32_t startPosition = 0 );
+//     void rawDiff( uint8_t* newdata, uint8_t* data, uint8_t* basedata, uint32_t datalength, uint32_t baselength);
+//     inline uint32_t findObject( const SynchronisableHeader& header, uint8_t* mem, uint32_t dataLength, uint32_t startPosition = 0 );
     virtual uint32_t getSize() const;
+    virtual inline bool process();
+    uint32_t calcGamestateSize(int32_t id, uint8_t mode=0x0);
+    virtual bool process(orxonox::Host* host);
+    uint32_t calcGamestateSize(uint32_t id, uint8_t mode=0x0);
+//     inline void diffObject( uint8_t*& newData, uint8_t*& origData, uint8_t*& baseData, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes );
+//     inline void copyObject( uint8_t*& newData, uint8_t*& origData, uint8_t*& baseData, SynchronisableHeader& objectHeader, std::vector<uint32_t>::iterator& sizes );
     std::list<obj>          dataVector_;
     GamestateHeader*        header_;
+    GamestateHeader         header_;
     std::vector<uint32_t>   sizes_;
     uint32_t                nrOfVariables_;

code/trunk/src/libraries/network/packet/Packet.cc

-                      r7163
+                      r7801
 #include <enet/enet.h>
 #include <boost/static_assert.hpp>
+#include <boost/thread/mutex.hpp>
 #include "util/Debug.h"
 …
 // Make sure we assume the right values
 BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Reliable)   == static_cast<int>(ENET_PACKET_FLAG_RELIABLE));
 BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Unsequence) == static_cast<int>(ENET_PACKET_FLAG_UNSEQUENCED));
 BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::NoAllocate) == static_cast<int>(ENET_PACKET_FLAG_NO_ALLOCATE));
+BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Reliable)    == static_cast<int>(ENET_PACKET_FLAG_RELIABLE));
+BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::Unsequenced) == static_cast<int>(ENET_PACKET_FLAG_UNSEQUENCED));
+BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::NoAllocate)  == static_cast<int>(ENET_PACKET_FLAG_NO_ALLOCATE));
 #define PACKET_FLAG_DEFAULT PacketFlag::NoAllocate
 …
 std::map<size_t, Packet *> Packet::packetMap_;
+boost::mutex Packet::packetMapMutex_;
 Packet::Packet()
 …
   flags_ = PACKET_FLAG_DEFAULT;
   packetDirection_ = Direction::Outgoing;
   clientID_=0;
+  peerID_=0;
   data_=0;
   enetPacket_=0;
 …
+}
 Packet::Packet(uint8_t *data, unsigned int clientID)
+Packet::Packet(uint8_t *data, unsigned int peerID)
+{
   flags_ = PACKET_FLAG_DEFAULT;
   packetDirection_ = Direction::Incoming;
   clientID_=clientID;
+  peerID_=peerID;
   data_=data;
   enetPacket_=0;
 …
   flags_=p.flags_;
   packetDirection_ = p.packetDirection_;
   clientID_ = p.clientID_;
+  peerID_ = p.peerID_;
   if(p.data_){
     data_ = new uint8_t[p.getSize()];
 …
+}
 bool Packet::send(){
+bool Packet::send(orxonox::Host* host){
   if(packetDirection_ != Direction::Outgoing && packetDirection_ != Direction::Bidirectional ){
     assert(0);
 …
       // Assures we don't create a packet and destroy it right after in another thread
       // without having a reference in the packetMap_
+      Packet::packetMapMutex_.lock();
       packetMap_[reinterpret_cast<size_t>(enetPacket_)] = this;
+      Packet::packetMapMutex_.unlock();
+    }
+  }
 …
 //  ENetPacket *temp = enetPacket_;
 //  enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
+  if(!Host::addPacket( enetPacket_, clientID_))
+    enet_packet_destroy(this->enetPacket_); // if we could not add the packet to the enet queue delete it manually
+  if( this->flags_ & PacketFlag::Reliable )
+    host->addPacket( enetPacket_, peerID_, NETWORK_CHANNEL_DEFAULT);
+  else
+    host->addPacket( enetPacket_, peerID_, NETWORK_CHANNEL_UNRELIABLE);
   return true;
+}
 …
   uint8_t *data = packet->data;
   assert(ClientInformation::findClient(&peer->address)->getID() != static_cast<unsigned int>(-2) || !Host::isServer());
+  unsigned int clientID = ClientInformation::findClient(&peer->address)->getID();
+  unsigned int peerID = ClientInformation::findClient(&peer->address)->getID();
+  // HACK
+  if( peerID==static_cast<unsigned int>(-2))
+    peerID = NETWORK_PEER_ID_SERVER;
   Packet *p = 0;
   COUT(6) << "packet type: " << *(Type::Value *)&data[_PACKETID] << std::endl;
+//   COUT(6) << "packet type: " << *(Type::Value *)&data[_PACKETID] << std::endl;
   switch( *(Type::Value *)(data + _PACKETID) )
+  {
     case Type::Acknowledgement:
       COUT(5) << "ack" << std::endl;
       p = new Acknowledgement( data, clientID );
+//       COUT(5) << "ack" << std::endl;
+    p = new Acknowledgement( data, peerID );
       break;
     case Type::Chat:
       COUT(5) << "chat" << std::endl;
       p = new Chat( data, clientID );
+//       COUT(5) << "chat" << std::endl;
+      p = new Chat( data, peerID );
       break;
     case Type::ClassID:
       COUT(5) << "classid" << std::endl;
       p = new ClassID( data, clientID );
+//       COUT(5) << "classid" << std::endl;
+      p = new ClassID( data, peerID );
       break;
     case Type::Gamestate:
+      COUT(5) << "gamestate" << std::endl;
+      // TODO: remove brackets
+      p = new Gamestate( data, clientID );
+//       COUT(5) << "gamestate" << std::endl;
+      p = new Gamestate( data, peerID );
       break;
     case Type::Welcome:
       COUT(5) << "welcome" << std::endl;
       p = new Welcome( data, clientID );
+//       COUT(5) << "welcome" << std::endl;
+      p = new Welcome( data, peerID );
       break;
     case Type::DeleteObjects:
       COUT(5) << "deleteobjects" << std::endl;
       p = new DeleteObjects( data, clientID );
+//       COUT(5) << "deleteobjects" << std::endl;
+      p = new DeleteObjects( data, peerID );
       break;
     case Type::FunctionCalls:
       COUT(5) << "functionCalls" << std::endl;
       p = new FunctionCalls( data, clientID );
+//       COUT(5) << "functionCalls" << std::endl;
+      p = new FunctionCalls( data, peerID );
       break;
     case Type::FunctionIDs:
       COUT(5) << "functionIDs" << std::endl;
       p = new FunctionIDs( data, clientID );
+//       COUT(5) << "functionIDs" << std::endl;
+      p = new FunctionIDs( data, peerID );
       break;
     default:
       assert(0); //TODO: repair this
+      assert(0);
       break;
+  }
 …
 void Packet::deletePacket(ENetPacket *enetPacket){
   // Get our Packet from a global map with all Packets created in the send() method of Packet.
+  Packet::packetMapMutex_.lock();
   std::map<size_t, Packet*>::iterator it = packetMap_.find(reinterpret_cast<size_t>(enetPacket));
   assert(it != packetMap_.end());
 …
   delete it->second;
   packetMap_.erase(it);
+  COUT(6) << "PacketMap size: " << packetMap_.size() << std::endl;
+  Packet::packetMapMutex_.unlock();
+//   COUT(6) << "PacketMap size: " << packetMap_.size() << std::endl;
+}

code/trunk/src/libraries/network/packet/Packet.h

-                      r7490
+                      r7801
     virtual unsigned char *getData(){ return data_; };
     virtual unsigned int getSize() const =0;
     virtual bool process()=0;
+    virtual bool process(orxonox::Host* host)=0;
     inline uint32_t getFlags()
       { return flags_; }
+    inline int getClientID()
+      { return clientID_; }
+    inline void setClientID( int id )
+      { clientID_ = id; }
+    inline int getPeerID()
+      { return peerID_; }
+    inline void setPeerID( int id )
+      { peerID_ = id; }
+    inline bool isReliable()
+      { return this->flags_ & PacketFlag::Reliable; }
+    inline uint32_t getRequiredGamestateID()
+      { return this->requiredGamestateID_; }
     virtual bool send();
+    virtual bool send(orxonox::Host* host);
   protected:
     Packet();
     Packet(uint8_t *data, unsigned int clientID);
+    Packet(uint8_t *data, unsigned int peerID);
 //    Packet(ENetPacket *packet, ENetPeer *peer);
     inline bool isDataENetAllocated() const
 …
     uint32_t flags_;
+    unsigned int clientID_;
+    unsigned int peerID_;
+    uint32_t requiredGamestateID_;
     Direction::Value packetDirection_;
     /** Pointer to the data. Be careful when deleting it because it might
 …
   private:
     static std::map<size_t, Packet *> packetMap_;
+    static boost::mutex               packetMapMutex_;
     ENetPacket *enetPacket_;
 };

code/trunk/src/libraries/network/packet/ServerInformation.cc

-                      r7461
+                      r7801
+ *
  *   Author:
  *      Fabian 'x3n' Landau
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
 …
       char* ack = new char[strlen(LAN_DISCOVERY_ACK)+1];
       loadAndIncrease((char*&)ack, temp);
+      assert(strcmp(ack, (const char*)LAN_DISCOVERY_ACK)==0);
+      /* Fabian, what is this used for? it crashes the masterserver, hence commenting it */
+      // written by Oli: this is just to make sure that loadAndIncrease really writes the whole ACK string into char* ack
+//       assert(strcmp(ack, (const char*)LAN_DISCOVERY_ACK)==0);
       // Save Server Name
       loadAndIncrease(this->serverName_, temp);

code/trunk/src/libraries/network/packet/ServerInformation.h

-                      r7459
+                      r7801
+ *
  *   Author:
  *      Fabian 'x3n' Landau
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
 …
         std::string   getServerName() { return this->serverName_; }
         void          setServerName(std::string name) { this->serverName_ = name; }
+        void          setServerIP( std::string IP ) { this->serverIP_ = IP; }
         uint32_t      getServerRTT() { return this->serverRTT_; }

code/trunk/src/libraries/network/packet/Welcome.cc

-                      r5781
+                      r7801
+}
 bool Welcome::process(){
+bool Welcome::process(orxonox::Host* host){
   uint32_t clientID;
   clientID = *(uint32_t *)(data_ + _CLIENTID );
   assert(*(uint32_t *)(data_ + _ENDIANTEST ) == 0xFEDC4321);
   Host::setClientID(clientID);
+  host->setClientID(clientID);
   COUT(3) << "Welcome set clientId: " << clientID << endl;
   Synchronisable::setClient(true);

code/trunk/src/libraries/network/packet/Welcome.h

r6073	r7801
47	47	uint8_t *getData();
48	48	inline unsigned int getSize() const;
49		~~bool process(~~);
	49	virtual bool process(orxonox::Host* host);
50	50
51	51	private:

code/trunk/src/libraries/network/synchronisable/Synchronisable.cc

-                      r7401
+                      r7801
+  {
     SynchronisableHeader header(mem);
+    assert( !header.isDiffed() );
+    if( header.isDiffed() )
+    {
+      mem += header.getDataSize() + header.getSize();
+      return 0;
+    }
+//     assert( !header.isDiffed() );
     COUT(4) << "fabricating object with id: " << header.getObjectID() << std::endl;
 …
    * length of varx: size saved int syncvarlist
    * @param mem pointer to allocated memory with enough size
    * @param sizes FIXME - add doc!
+   * @param sizes vector containing sizes of all objects in gamestate (to be appended)
    * @param id gamestateid of the gamestate to be saved (important for priorities)
    * @param mode defines the direction in which the data will be send/received
    *             0x1: server->client
    *             0x2: client->server (not recommended)
+   *             0x2: client->server
    *             0x3: bidirectional
    * @return true: if !doSync or if everything was successfully saved
 …
       //tempsize += (*i)->getSize( mode );
+    }
+    assert(tempsize!=0);  // if this happens an empty object (with no variables) would be transmitted
 //     COUT(4) << endl;
 …
       mem += SynchronisableHeader::getSize();
       std::vector<SynchronisableVariableBase *>::iterator i;
       for(i=syncList_.begin(); i!=syncList_.end(); i++)
+      for(i=syncList_.begin(); i!=syncList_.end(); ++i)
+      {
         assert( mem <= data+syncHeader2.getDataSize()+SynchronisableHeader::getSize() ); // always make sure we don't exceed the datasize in our stream

code/trunk/src/libraries/network/synchronisable/Synchronisable.h

-                      r7163
+                      r7801
     };
+  }
-  typedef uint8_t VariableID;
-  /**
-   * @brief: stores information about a Synchronisable
+   *
-   * This class stores the information about a Synchronisable (objectID_, classID_, creatorID_, dataSize)
-   * in an emulated bitset.
-   * Bit 1 to 31 store the size of the Data the synchronisable consumes in the stream
-   * Bit 32 is a bool and defines whether the variables are stored in diff mode
-   * Byte 5 to 8: objectID_
-   * Byte 9 to 12: classID_
-   * Byte 13 to 16: creatorID_
-   */
-  class _NetworkExport SynchronisableHeader{
-    friend class SynchronisableHeaderLight;
-    private:
-      uint8_t* data_;
-    public:
-      SynchronisableHeader(uint8_t* data)
-        { data_ = data; }
-      inline static uint32_t getSize()
-        { return 14; }
-      inline uint16_t getDataSize() const
-        { return (*(uint16_t*)data_) & 0x7FFF; } //only use the first 15 bits
-      inline void setDataSize(uint16_t size)
-        { *(uint16_t*)(data_) = (size & 0x7FFF) | (*(uint16_t*)(data_) & 0x8000 ); }
-      inline bool isDiffed() const
-        { return ( (*(uint16_t*)data_) & 0x8000 ) == 0x8000; }
-      inline void setDiffed( bool b)
-        { *(uint16_t*)(data_) = (b << 15) | (*(uint16_t*)(data_) & 0x7FFF ); }
-      inline uint32_t getObjectID() const
-        { return *(uint32_t*)(data_+2); }
-      inline void setObjectID(uint32_t objectID_)
-        { *(uint32_t*)(data_+2) = objectID_; }
-      inline uint32_t getClassID() const
-        { return *(uint32_t*)(data_+6); }
-      inline void setClassID(uint32_t classID_)
-        { *(uint32_t*)(data_+6) = classID_; }
-      inline uint32_t getCreatorID() const
-        { return *(uint32_t*)(data_+10); }
-      inline void setCreatorID(uint32_t creatorID_)
-        { *(uint32_t*)(data_+10) = creatorID_; }
-      inline void operator=(SynchronisableHeader& h)
-        { memcpy(data_, h.data_, getSize()); }
-  };
     /**
 …
    * Byte 5 to 8: objectID_
    */
+  class _NetworkExport SynchronisableHeaderLight{
+    private:
+  class _NetworkExport SynchronisableHeaderLight
+  {
+    protected:
       uint8_t* data_;
     public:
 …
       inline void setObjectID(uint32_t objectID_)
         { *(uint32_t*)(data_+2) = objectID_; }
+      inline void operator=(SynchronisableHeaderLight& h)
+        { memcpy(data_, h.data_, SynchronisableHeaderLight::getSize()); }
+  };
+  typedef uint8_t VariableID;
+  /**
+   * @brief: stores information about a Synchronisable
+   *
+   * This class stores the information about a Synchronisable (objectID_, classID_, creatorID_, dataSize)
+   * in an emulated bitset.
+   * Bit 1 to 31 store the size of the Data the synchronisable consumes in the stream
+   * Bit 32 is a bool and defines whether the variables are stored in diff mode
+   * Byte 5 to 8: objectID_
+   * Byte 9 to 12: classID_
+   * Byte 13 to 16: creatorID_
+   */
+  class _NetworkExport SynchronisableHeader: public SynchronisableHeaderLight
+  {
+    public:
+      SynchronisableHeader(uint8_t* data): SynchronisableHeaderLight(data)
+        {}
+      inline static uint32_t getSize()
+        { return SynchronisableHeaderLight::getSize()+8; }
+      inline uint32_t getClassID() const
+        { return *(uint32_t*)(data_+SynchronisableHeaderLight::getSize()); }
+      inline void setClassID(uint32_t classID_)
+        { *(uint32_t*)(data_+SynchronisableHeaderLight::getSize()) = classID_; }
+      inline uint32_t getCreatorID() const
+        { return *(uint32_t*)(data_+SynchronisableHeaderLight::getSize()+4); }
+      inline void setCreatorID(uint32_t creatorID_)
+        { *(uint32_t*)(data_+SynchronisableHeaderLight::getSize()+4) = creatorID_; }
       inline void operator=(SynchronisableHeader& h)
         { memcpy(data_, h.data_, getSize()); }
   };
+//   inline void operator=(SynchronisableHeaderLight& h1, SynchronisableHeader& h2)
+//   {
+//     memcpy(h1.data_, h2.data_, h1.getSize());
+//   }
   /**

code/trunk/src/libraries/util/SignalHandler.cc

-                      r7457
+                      r7801
 #include <X11/Xutil.h>
 #include <X11/keysym.h>
+#include <sys/prctl.h>
 namespace orxonox
 …
       COUT(0) << "Received signal " << sigName.c_str() << std::endl << "Try to write backtrace to file orxonox_crash.log" << std::endl;
+      int sigPipe[2];
+      if ( pipe(sigPipe) == -1 )
+      {
+        perror("pipe failed!\n");
+        exit(EXIT_FAILURE);
+      }
+      int sigPid = fork();
+      if ( sigPid == -1 )
+      {
+        perror("fork failed!\n");
+        exit(EXIT_FAILURE);
+      }
+      // gdb will be attached to this process
+      if ( sigPid == 0 )
+      {
+        getInstance().dontCatch();
+        // wait for message from parent when it has attached gdb
+        int someData;
+        read( sigPipe[0], &someData, sizeof(someData) );
+        if ( someData != 0x12345678 )
+        {
+          COUT(0) << "something went wrong :(" << std::endl;
+        }
+        return;
+      }
+      // First start GDB which will be attached to this process later on
       int gdbIn[2];
       int gdbOut[2];
       int gdbErr[2];
       if ( pipe(gdbIn) == -1 || pipe(gdbOut) == -1 || pipe(gdbErr) == -1 )
+      {
         perror("pipe failed!\n");
-        kill( sigPid, SIGTERM );
-        waitpid( sigPid, NULL, 0 );
         exit(EXIT_FAILURE);
+      }
       int gdbPid = fork();
       // this process will run gdb
       if ( gdbPid == -1 )
+      {
         perror("fork failed\n");
-        kill( sigPid, SIGTERM );
-        waitpid( sigPid, NULL, 0 );
         exit(EXIT_FAILURE);
+      }
       if ( gdbPid == 0 )
+      {
         // start gdb
         close(gdbIn[1]);
         close(gdbOut[0]);
         close(gdbErr[0]);
         dup2( gdbIn[0], STDIN_FILENO );
         dup2( gdbOut[1], STDOUT_FILENO );
         dup2( gdbErr[1], STDERR_FILENO );
         execlp( "sh", "sh", "-c", "gdb", static_cast<void*>(NULL));
+      }
+      // Now start a fork of this process on which GDB will be attached on
+      int sigPipe[2];
+      if ( pipe(sigPipe) == -1 )
+      {
+        perror("pipe failed!\n");
+        kill( gdbPid, SIGTERM );
+        waitpid( gdbPid, NULL, 0 );
+        exit(EXIT_FAILURE);
+      }
+      int sigPid = fork();
+      if ( sigPid == -1 )
+      {
+        perror("fork failed!\n");
+        kill( gdbPid, SIGTERM );
+        waitpid( gdbPid, NULL, 0 );
+        exit(EXIT_FAILURE);
+      }
+      // gdb will be attached to this process
+      if ( sigPid == 0 )
+      {
+        getInstance().dontCatch();
+        // make sure gdb is allowed to attach to our PID even if there are some system restrictions
+#ifdef PR_SET_PTRACER
+        if( prctl(PR_SET_PTRACER, gdbPid, 0, 0, 0) == -1 )
+          COUT(0) << "could not set proper permissions for GDB to attach to process..." << endl;
+#endif
+        // wait for message from parent when it has attached gdb
+        int someData;
+        if( read( sigPipe[0], &someData, sizeof(someData) ) != sizeof(someData) )
+          COUT(0) << "something went wrong :(" << std::endl;
+        if ( someData != 0x12345678 )
+        {
+          COUT(0) << "something went wrong :(" << std::endl;
+        }
+        return;
+      }

Context Navigation

Legend:

Download in other formats: