Changeset 8327 for code/trunk

Timestamp:

Apr 25, 2011, 8:22:36 PM (14 years ago)

Author:

scheusso

Message:

merging network6 into trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/Thread.cc (modified) (4 diffs)
• src/libraries/core/ThreadWin.cc (copied) (copied from code/branches/network6/src/libraries/core/ThreadWin.cc)
• src/libraries/network/CMakeLists.txt (modified) (2 diffs)
• src/libraries/network/Client.cc (modified) (2 diffs)
• src/libraries/network/ClientConnection.cc (modified) (4 diffs)
• src/libraries/network/ClientConnection.h (modified) (1 diff)
• src/libraries/network/ClientConnectionListener.cc (modified) (2 diffs)
• src/libraries/network/ClientConnectionListener.h (modified) (1 diff)
• src/libraries/network/ClientInformation.cc (deleted)
• src/libraries/network/ClientInformation.h (deleted)
• src/libraries/network/Connection.cc (modified) (11 diffs)
• src/libraries/network/Connection.h (modified) (3 diffs)
• src/libraries/network/GamestateClient.cc (deleted)
• src/libraries/network/GamestateClient.h (deleted)
• src/libraries/network/GamestateHandler.h (modified) (1 diff)
• src/libraries/network/GamestateManager.cc (modified) (11 diffs)
• src/libraries/network/GamestateManager.h (modified) (3 diffs)
• src/libraries/network/Host.cc (modified) (1 diff)
• src/libraries/network/NetworkPrereqs.h (modified) (1 diff)
• src/libraries/network/Server.cc (modified) (12 diffs)
• src/libraries/network/Server.h (modified) (3 diffs)
• src/libraries/network/ServerConnection.cc (modified) (4 diffs)
• src/libraries/network/ServerConnection.h (modified) (2 diffs)
• src/libraries/network/WANDiscovery.cc (modified) (1 diff)
• src/libraries/network/packet/Gamestate.cc (modified) (2 diffs)
• src/libraries/network/packet/Packet.cc (modified) (7 diffs)
• src/libraries/network/packet/Packet.h (modified) (3 diffs)
• src/libraries/network/synchronisable/Synchronisable.cc (modified) (2 diffs)
• src/modules/overlays/hud/ChatOverlay.cc (modified) (1 diff)
• src/orxonox/ChatHistory.cc (modified) (1 diff)
• src/orxonox/ChatInputHandler.cc (modified) (1 diff)
• src/orxonox/PlayerManager.cc (modified) (1 diff)
• src/orxonox/gamestates/GSRoot.cc (modified) (1 diff)
• src/orxonox/gametypes/Dynamicmatch.cc (modified) (7 diffs)
• src/orxonox/gametypes/Gametype.cc (modified) (1 diff)
• src/orxonox/gametypes/LastManStanding.cc (modified) (6 diffs)
• src/orxonox/gametypes/LastTeamStanding.cc (modified) (8 diffs)
• src/orxonox/gametypes/TeamBaseMatch.cc (modified) (1 diff)
• src/orxonox/gametypes/UnderAttack.cc (modified) (2 diffs)
• src/orxonox/infos/GametypeInfo.cc (modified) (1 diff)
• src/orxonox/infos/HumanPlayer.cc (modified) (2 diffs)
• src/orxonox/infos/PlayerInfo.cc (modified) (2 diffs)

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

@@ -26 +26 @@
  *
  */
+
+#if defined(ORXONOX_PLATFORM_WINDOWS)
+  #include "ThreadWin.cc"
+#elif defined(ORXONOX_PLATFORM_UNIX)
+
 
 #include "Thread.h"
@@ -91 +96 @@
         while( !stopThread )
         {
-            //this->executorMutex_->lock();
+            this->executorMutex_->lock();
             ExecutorPtr executor = this->executor_;
-            //this->executorMutex_->unlock();
+            this->executorMutex_->unlock();
             if( executor )
             {
@@ -108 +113 @@
                 this->workerThread_->yield();
             }
-            //this->stopThreadMutex_->lock();
+            this->stopThreadMutex_->lock();
             stopThread = this->stopThread_;
-            //this->stopThreadMutex_->unlock();
+            this->stopThreadMutex_->unlock();
         }
     }
@@ -127 +132 @@
     }
 }
+
+#endif

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

@@ -22 +22 @@
   Client.cc
   ClientConnection.cc
-  ClientInformation.cc
   ClientConnectionListener.cc
   Connection.cc
@@ -50 +49 @@
   ClientConnection.h
   ClientConnectionListener.h
-  ClientInformation.h
   Connection.h
   FunctionCall.h

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

@@ -155 +155 @@
         COUT(4) << "popping partial gamestate: " << std::endl;
 //         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 )
+        if( GamestateManager::update() )
         {
-          (*it)->send( static_cast<Host*>(this) );
+          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
@@ -207 +209 @@
     if( packet->isReliable() )
     {
-      if( this->getLastProcessedGamestateID(packet->getPeerID()) >= packet->getRequiredGamestateID() )
+      if( this->getLastReceivedGamestateID(packet->getPeerID()) >= packet->getRequiredGamestateID() )
         packet->process(static_cast<Host*>(this));
       else

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

@@ -42 +42 @@
 
   ClientConnection::ClientConnection():
+    Connection(NETWORK_PEER_ID_SERVER),
     established_(false),
     server_(NULL)
@@ -103 +104 @@
       if( enet_host_service(this->host_, &event, NETWORK_CLIENT_WAIT_TIME)>=0 && event.type == ENET_EVENT_TYPE_CONNECT )
       {
+        // manually add server to list of peers
+        /*incomingEvent inEvent = */Connection::preprocessConnectEvent(event);
+//         addPeer(inEvent.peerID);
+        // start communication thread
         this->established_=true;
         Connection::startCommunicationThread();
@@ -118 +123 @@
       return true;
     this->established_ = false;
+    
+    // stop communication thread and disconnect server
     Connection::stopCommunicationThread();
     enet_peer_disconnect(this->server_, 0);
@@ -148 +155 @@
     assert( this->server_ );
     assert( packet );
-    return Connection::addPacket( packet, this->server_, channelID );
+//     return Connection::addPacket( packet, NETWORK_PEER_ID_SERVER, channelID );
+    // HACK: actually there should be a way to do this using addPacket and the correct peerID
+    return Connection::broadcastPacket(packet, channelID);
   }
 
-  void ClientConnection::addPeer(ENetEvent* event)
+  void ClientConnection::addPeer(uint32_t peerID)
   {
     assert(0);
   }
-  void ClientConnection::removePeer(ENetEvent* event)
+  void ClientConnection::removePeer(uint32_t peerID)
   {
     this->established_=false;

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

@@ -57 +57 @@
     uint32_t getRTT();
   private:
-    virtual void addPeer(ENetEvent* event);
-    virtual void removePeer(ENetEvent* event);
+    virtual void addPeer(uint32_t peerID);
+    virtual void removePeer(uint32_t peerID);
 
     bool disconnectConnection();

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

@@ -31 +31 @@
 #include "core/CoreIncludes.h"
 #include "core/GameMode.h"
-#include "ClientInformation.h"
+// #include "ClientInformation.h"
 
 namespace orxonox
@@ -52 +52 @@
     }
 
-    void ClientConnectionListener::getConnectedClients()
-    {
-        ClientInformation* client = ClientInformation::getBegin();
-        while (client)
-        {
-            this->clientConnected(client->getID());
-            client = client->next();
-        }
-    }
+//     void ClientConnectionListener::getConnectedClients()
+//     {
+//         ClientInformation* client = ClientInformation::getBegin();
+//         while (client)
+//         {
+//             this->clientConnected(client->getID());
+//             client = client->next();
+//         }
+//     }
 }
 

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

@@ -48 +48 @@
 
         protected:
-            void getConnectedClients();
+//             void getConnectedClients();
     };
 }

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

@@ -38 +38 @@
 
 #include "packet/Packet.h"
+#include <util/Sleep.h>
 
 namespace orxonox
 {
-  const boost::posix_time::millisec NETWORK_COMMUNICATION_THREAD_WAIT_TIME(20);
-
-  Connection::Connection():
-    host_(0), bCommunicationThreadRunning_(false)
+  const boost::posix_time::millisec NETWORK_COMMUNICATION_THREAD_WAIT_TIME(200);
+  const unsigned int                NETWORK_DISCONNECT_TIMEOUT = 500;
+
+  Connection::Connection(uint32_t firstPeerID):
+    host_(0), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
   {
     enet_initialize();
@@ -50 +52 @@
     this->incomingEventsMutex_ = new boost::mutex;
     this->outgoingEventsMutex_ = new boost::mutex;
+//     this->overallMutex_ = new boost::mutex;
   }
 
@@ -75 +78 @@
   }
 
-
-//   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 };
+  void Connection::disconnectPeer(uint32_t peerID)
+  {
+//     this->overallMutex_->lock();
+    outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, 0, 0 };
     
     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->overallMutex_->unlock();
+  }
+  
+  void Connection::disconnectPeers()
+  {
+    outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, 0, 0 };
     
     this->outgoingEventsMutex_->lock();
@@ -99 +97 @@
     this->outgoingEventsMutex_->unlock();
   }
+
+  void Connection::addPacket(ENetPacket* packet, uint32_t peerID, uint8_t channelID)
+  {
+//     this->overallMutex_->lock();
+    outgoingEvent outEvent = { peerID, outgoingEventType::sendPacket, packet, channelID };
+    
+    this->outgoingEventsMutex_->lock();
+    this->outgoingEvents_.push_back(outEvent);
+    this->outgoingEventsMutex_->unlock();
+//     this->overallMutex_->unlock();
+  }
   
   void Connection::broadcastPacket(ENetPacket* packet, uint8_t channelID)
   {
-    outgoingEvent outEvent = { (ENetPeer*)15, outgoingEventType::broadcastPacket, packet, channelID };
+//     this->overallMutex_->lock();
+    outgoingEvent outEvent = { 0, outgoingEventType::broadcastPacket, packet, channelID };
     
     this->outgoingEventsMutex_->lock();
     this->outgoingEvents_.push_back(outEvent);
     this->outgoingEventsMutex_->unlock();
+//     this->overallMutex_->unlock();
   }
 
@@ -114 +125 @@
     ENetEvent event;
     
+//     this->overallMutex_->lock();
     while( bCommunicationThreadRunning_ )
     {
@@ -119 +131 @@
       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();
-      }
+        processIncomingEvent(event);
+      }
+      
+//       this->overallMutex_->unlock();
+      msleep(1);
+//       this->overallMutex_->lock();
       
       // Send all waiting outgoing packets
@@ -138 +150 @@
         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);
-        }
+        processOutgoingEvent(outEvent);
+        
         this->outgoingEventsMutex_->lock();
         outgoingEventsCount = this->outgoingEvents_.size();
@@ -160 +160 @@
       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();
+        processIncomingEvent(event);
+      }
+    }
+//     this->overallMutex_->unlock();
+  }
+  
+  void Connection::processIncomingEvent(ENetEvent& event)
+  {
+    incomingEvent inEvent;
+    // preprocess event
+    switch( event.type )
+    {
+      case ENET_EVENT_TYPE_CONNECT:
+        inEvent = preprocessConnectEvent(event);
+        break;
+      case ENET_EVENT_TYPE_RECEIVE:
+        inEvent = preprocessReceiveEvent(event);
+        break;
+      case ENET_EVENT_TYPE_DISCONNECT:
+        inEvent = preprocessDisconnectEvent(event);
+        break;
+      case ENET_EVENT_TYPE_NONE:
+      default:
+        return;
+    }
+    
+    // pushing event to queue
+    this->incomingEventsMutex_->lock();
+    this->incomingEvents_.push_back(inEvent);
+    this->incomingEventsMutex_->unlock();
+  }
+  
+  void Connection::processOutgoingEvent(outgoingEvent& event)
+  {
+    ENetPeer* peer;
+    switch( event.type )
+    {
+      case outgoingEventType::sendPacket:
+        // check whether the peer is still/already in the peer list
+        if( this->peerMap_.find(event.peerID) != this->peerMap_.end() )
+        {
+          peer = this->peerMap_[event.peerID];
+          enet_peer_send( peer, event.channelID, event.packet );
+        }
+        else
+        {
+          // peer probably already disconnected so just discard packet
+          assert(event.peerID<this->nextPeerID_);
+          enet_packet_destroy(event.packet);
+        }
+        break;
+      case outgoingEventType::disconnectPeer:
+        if( this->peerMap_.find(event.peerID) != this->peerMap_.end() )
+        {
+          peer = this->peerMap_[event.peerID];
+          enet_peer_disconnect(peer, 0);
+        }
+        else
+        {
+          // peer probably already disconnected so just discard disconnect event
+          assert(event.peerID<this->nextPeerID_);
+        }
+        break;
+      case outgoingEventType::disconnectPeers:
+        disconnectPeersInternal();
+        break;
+      case outgoingEventType::broadcastPacket:
+        enet_host_broadcast( this->host_, event.channelID, event.packet );
+        break;
+      default:
+        assert(0);
+    }
+  }
+
+
+  void Connection::disconnectPeersInternal()
+  {
+    std::map<uint32_t, ENetPeer*>::iterator it;
+    for( it=this->peerMap_.begin(); it!=this->peerMap_.end(); ++it )
+    {
+      enet_peer_disconnect(it->second, 0);
+    }
+    uint32_t iterations = NETWORK_DISCONNECT_TIMEOUT/NETWORK_WAIT_TIMEOUT;
+    uint32_t i = 0;
+    while( this->peerMap_.size() && i++ < iterations )
+    {
+      ENetEvent event;
+      if( enet_host_service( this->host_, &event, NETWORK_WAIT_TIMEOUT ) > 0 )
+      {
+        processIncomingEvent(event);
       }
     }
@@ -171 +256 @@
   void Connection::processQueue()
   {
-    ENetEvent event;
+    incomingEvent inEvent;
 
     this->incomingEventsMutex_->lock();
@@ -178 +263 @@
     while( incomingEventsCount > 0 )
     {
-      packet::Packet* p;
+      // pop event from queue
       this->incomingEventsMutex_->lock();
-      event = this->incomingEvents_.front();
+      inEvent = this->incomingEvents_.front();
       this->incomingEvents_.pop_front();
       this->incomingEventsMutex_->unlock();
       
-      switch(event.type)
-      {
-        // log handling ================
-        case ENET_EVENT_TYPE_CONNECT:
-          addPeer( &event );
+      // process event
+      switch( inEvent.type )
+      {
+        case incomingEventType::peerConnect:
+          addPeer(inEvent.peerID);
           break;
-        case ENET_EVENT_TYPE_DISCONNECT:
-          removePeer( &event );
+        case incomingEventType::peerDisconnect:
+          removePeer(inEvent.peerID);
           break;
-        case ENET_EVENT_TYPE_RECEIVE:
-//           COUT(0) << "ENET_EVENT_TYPE_RECEIVE" << endl;
-          p = createPacket( &event );
-          processPacket(p);
+        case incomingEventType::receivePacket:
+          processPacket(inEvent.packet);
           break;
-        case ENET_EVENT_TYPE_NONE:
+        default:
           break;
       }
       
+      // check whether there are still events in the queue
       this->incomingEventsMutex_->lock();
       incomingEventsCount = this->incomingEvents_.size();
@@ -207 +291 @@
     }
   }
-
-  packet::Packet* Connection::createPacket(ENetEvent* event)
-  {
-    packet::Packet *p = packet::Packet::createPacket(event->packet, event->peer);
-    return p;
-//     return p->process();
-  }
+  
+  void Connection::waitOutgoingQueue()
+  {
+    uint32_t outgoingEventsCount;
+    this->outgoingEventsMutex_->lock();
+    outgoingEventsCount = this->outgoingEvents_.size();
+    this->outgoingEventsMutex_->unlock();
+    while( outgoingEventsCount )
+    {
+      msleep(1);
+      this->outgoingEventsMutex_->lock();
+      outgoingEventsCount = this->outgoingEvents_.size();
+      this->outgoingEventsMutex_->unlock();
+    }
+  }
+
+
+  incomingEvent Connection::preprocessConnectEvent(ENetEvent& event)
+  {
+    // make sure this peer doesn't exist
+    assert( this->peerMap_.find(this->nextPeerID_) == this->peerMap_.end() );
+    assert( this->peerIDMap_.find(event.peer) == this->peerIDMap_.end() );
+    
+    // give peer a new id and increase peerID for next peer
+    uint32_t peerID = this->nextPeerID_;
+    ++this->nextPeerID_;
+    
+    // add peer/peerID into peerMap_ and peerIDMap_
+    this->peerMap_[peerID] = event.peer;
+    this->peerIDMap_[event.peer] = peerID;
+    
+    // create new peerEvent and return it
+    incomingEvent inEvent = { peerID, incomingEventType::peerConnect, 0 };
+    return inEvent;
+  }
+  
+  incomingEvent Connection::preprocessDisconnectEvent(ENetEvent& event)
+  {
+    // assert that the peer exists and get peerID
+    assert( this->peerIDMap_.find(event.peer) != this->peerIDMap_.end() );
+    uint32_t peerID = this->peerIDMap_[event.peer];
+    
+    // remove peer/peerID from maps
+    this->peerIDMap_.erase(this->peerIDMap_.find(event.peer));
+    this->peerMap_.erase(this->peerMap_.find(peerID));
+    
+    // create new peerEvent and return it
+    incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, 0 };
+    return inEvent;
+  }
+  
+  incomingEvent Connection::preprocessReceiveEvent(ENetEvent& event)
+  {
+    // assert that the peer exists and get peerID
+    assert( this->peerIDMap_.find(event.peer) != this->peerIDMap_.end() );
+    uint32_t peerID = this->peerIDMap_[event.peer];
+    
+    // create new Packet from ENetPacket
+    packet::Packet* p = packet::Packet::createPacket(event.packet, peerID);
+    
+    // create new peerEvent and return it
+    incomingEvent inEvent = { peerID, incomingEventType::receivePacket, p };
+    return inEvent;
+  }
+
   
   void Connection::enableCompression()

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

@@ -44 +44 @@
 
 #include <deque>
+#include <map>
 #include <enet/enet.h>
+#include <boost/concept_check.hpp>
 
 namespace boost
@@ -59 +61 @@
   const unsigned int NETWORK_MAX_QUEUE_PROCESS_TIME = 5;
   
+  namespace incomingEventType
+  {
+    enum Value
+    {
+      receivePacket   = 1,  // incoming packet
+      peerConnect     = 2,  // incoming connect request
+      peerDisconnect  = 3   // incoming disconnect request
+    };
+    
+  }
+  
   namespace outgoingEventType
   {
     enum Value
     {
-      sendPacket      = 1,
-      disconnectPeer  = 2,
-      broadcastPacket = 3
+      sendPacket      = 1,  // outgoing packet
+      broadcastPacket = 2,  // outgoing broadcast packet
+      disconnectPeer  = 3,  // outgoing disconnect request
+      disconnectPeers = 4   // outgoing disconnect request
     };
     
   }
   
+  struct _NetworkExport incomingEvent
+  {
+    uint32_t                  peerID;
+    incomingEventType::Value  type;
+    packet::Packet*           packet;
+  };
+  
   struct _NetworkExport outgoingEvent
   {
-    ENetPeer*                 peer;
+    uint32_t                  peerID;
     outgoingEventType::Value  type;
     ENetPacket*               packet;
@@ -83 +104 @@
     virtual ~Connection();
 
-    void addPacket(ENetPacket *packet, ENetPeer *peer, uint8_t channelID);
-    void broadcastPacket(ENetPacket* packet, uint8_t channelID);
-//     ENetHost* getHost(){ return this->host_; }
-
   protected:
-    Connection();
-//     static Connection* getInstance(){ return Connection::instance_; }
-
-//     int service(ENetEvent* event);
+    Connection(uint32_t firstPeerID = NETWORK_PEER_ID_SERVER+1);
+    
     void startCommunicationThread();
     void stopCommunicationThread();
-    void communicationThread();
-    virtual void disconnectPeer(ENetPeer *peer);
+    
+    void addPacket(ENetPacket *packet, uint32_t peerID, uint8_t channelID);
+    void broadcastPacket(ENetPacket* packet, uint8_t channelID);
+    void disconnectPeer(uint32_t peerID);
+    void disconnectPeers();
     
     void enableCompression();
 
     void processQueue();
-    virtual void addPeer(ENetEvent* event)=0;
-    virtual void removePeer(ENetEvent* event)=0;
+    void waitOutgoingQueue();     // wait for the outgoing queue to become empty (everything processed by communication thread)
+    virtual void addPeer(uint32_t peerID)=0;
+    virtual void removePeer(uint32_t peerID)=0;
     virtual void processPacket( packet::Packet* packet)=0;
-    virtual packet::Packet* createPacket(ENetEvent* event);
+    
+    incomingEvent preprocessConnectEvent(ENetEvent& event);
+    incomingEvent preprocessDisconnectEvent(ENetEvent& event);
+    incomingEvent preprocessReceiveEvent(ENetEvent& event);
+    
+    void processIncomingEvent(ENetEvent& event);
+    void processOutgoingEvent(outgoingEvent& event);
+    
+    void disconnectPeersInternal();
 
-    ENetHost*                   host_;
+    ENetHost*                     host_;
   private:
-    boost::thread*              communicationThread_;
-    bool                        bCommunicationThreadRunning_;
-    ENetAddress*                bindAddress_;
-    std::deque<ENetEvent>       incomingEvents_;
-    std::deque<outgoingEvent>   outgoingEvents_;
-    boost::mutex*               incomingEventsMutex_;
-    boost::mutex*               outgoingEventsMutex_;
-
-//     static Connection *instance_;
+    void communicationThread();
+    
+    boost::thread*                communicationThread_;
+    bool                          bCommunicationThreadRunning_;
+    ENetAddress*                  bindAddress_;
+    std::deque<incomingEvent>     incomingEvents_;
+    std::deque<outgoingEvent>     outgoingEvents_;
+    boost::mutex*                 incomingEventsMutex_;
+    boost::mutex*                 outgoingEventsMutex_;
+    boost::mutex*                 overallMutex_;
+    std::map<uint32_t, ENetPeer*> peerMap_;
+    std::map<ENetPeer*, uint32_t> peerIDMap_;
+    uint32_t                      nextPeerID_;
 
   };

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

@@ -51 +51 @@
     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  getLastReceivedGamestateID( unsigned int clientID )=0;
     virtual uint32_t  getCurrentGamestateID()=0;
 };

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

@@ -57 +57 @@
 
 namespace orxonox
-{
+{ 
   GamestateManager::GamestateManager() :
   currentGamestate_(0), id_(0)
@@ -122 +122 @@
   bool GamestateManager::sendAck(unsigned int gamestateID, uint32_t peerID)
   {
+    assert( gamestateID != ACKID_NACK );
     packet::Acknowledgement *ack = new packet::Acknowledgement(gamestateID, peerID);
     if( !this->sendPacket(ack))
@@ -139 +140 @@
     if ( currentGamestate_ != 0 )
       delete currentGamestate_;
-    currentGamestate_ = new packet::Gamestate();
     uint8_t gsMode;
     if( GameMode::isMaster() )
@@ -149 +149 @@
       newID = ++id_;
     else
-      newID = peerMap_[NETWORK_PEER_ID_SERVER].lastProcessedGamestateID;
+    {
+      assert(peerMap_.size()!=0);
+      newID = peerMap_[NETWORK_PEER_ID_SERVER].lastReceivedGamestateID;
+      if( newID == GAMESTATEID_INITIAL )
+      {
+        return false;
+      }
+    }
     
-    if(!currentGamestate_->collectData(newID, gsMode)){ //we have no data to send
+    currentGamestate_ = new packet::Gamestate();
+    
+    if(!currentGamestate_->collectData(newID, gsMode))
+    { //we have no data to send
       delete currentGamestate_;
       currentGamestate_=0;
+      return false;
     }
     return true;
@@ -172 +183 @@
         continue;
       }
-      COUT(4) << "client id: " << peerIt->first << std::endl;
+      COUT(5) << "client id: " << peerIt->first << std::endl;
       COUT(5) << "Server: doing gamestate gamestate preparation" << std::endl;
       int peerID = peerIt->first; //get client id
@@ -187 +198 @@
       }
 
-      peerGamestates.push_back(0);  // insert an empty gamestate* to change
+      peerGamestates.push_back(0);  // insert an empty gamestate* to be changed
       finishGamestate( peerID, peerGamestates.back(), baseGamestate, currentGamestate_ );
       if( peerGamestates.back()==0 )
@@ -244 +255 @@
 //     assert(b);
     clock.capture();
-    COUT(4) << "diff and compress time: " << clock.getDeltaTime() << endl;
+    COUT(5) << "diff and compress time: " << clock.getDeltaTime() << endl;
 //     COUT(5) << "sending gamestate with id " << gs->getID();
 //     if(gamestate->isDiffed())
@@ -263 +274 @@
     unsigned int curid = it->second.lastAckedGamestateID;
 
-    if(gamestateID == ACKID_NACK){
-      it->second.lastAckedGamestateID = GAMESTATEID_INITIAL;
-//       temp->setGamestateID(GAMESTATEID_INITIAL);
-      // now delete all saved gamestates for this client
-      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 peerID: " << peerID << " curid: " << curid << std::endl;
+    assert(gamestateID != ACKID_NACK);
+//     if(gamestateID == ACKID_NACK){
+//       it->second.lastAckedGamestateID = GAMESTATEID_INITIAL;
+// //       temp->setGamestateID(GAMESTATEID_INITIAL);
+//       // now delete all saved gamestates for this client
+//       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); // this line is commented out because acknowledgements are unreliable and may arrive in distorted order
+    if( gamestateID <= curid )
+        return true;
+COUT(4) << "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(); )
@@ -300 +314 @@
   }
   
-  uint32_t GamestateManager::getLastProcessedGamestateID(unsigned int peerID)
+  uint32_t GamestateManager::getLastReceivedGamestateID(unsigned int peerID)
   {
     assert( this->peerMap_.find(peerID)!=this->peerMap_.end() );
     if( this->peerMap_.find(peerID) != this->peerMap_.end() )
-      return this->peerMap_[peerID].lastProcessedGamestateID;
+      return this->peerMap_[peerID].lastReceivedGamestateID;
     else
       return GAMESTATEID_INITIAL;
@@ -314 +328 @@
     assert(peerMap_.find(peerID)==peerMap_.end());
     peerMap_[peerID].peerID = peerID;
-    peerMap_[peerID].lastProcessedGamestateID = GAMESTATEID_INITIAL;
+    peerMap_[peerID].lastReceivedGamestateID = GAMESTATEID_INITIAL;
     peerMap_[peerID].lastAckedGamestateID = GAMESTATEID_INITIAL;
     if( GameMode::isMaster() )
@@ -360 +374 @@
     if( gs->spreadData(gsMode) )
     {
-      this->peerMap_[gs->getPeerID()].lastProcessedGamestateID = gs->getID();
+      this->peerMap_[gs->getPeerID()].lastReceivedGamestateID = gs->getID();
       return true;
     }

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

@@ -73 +73 @@
     {
       uint32_t  peerID;
-      uint32_t  lastProcessedGamestateID;
-      uint32_t  lastAckedGamestateID;
+      uint32_t  lastReceivedGamestateID;  //!< id of the last gamestate which was received (and processed) from the peer
+      uint32_t  lastAckedGamestateID;     //!< id of the last gamestate on which we received an ack from the peer
       bool      isSynched;
       std::map< uint32_t, packet::Gamestate* > gamestates;
@@ -86 +86 @@
     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  getLastReceivedGamestateID( unsigned int peerID );
     virtual uint32_t  getCurrentGamestateID(){ return currentGamestate_->getID(); }
     
@@ -101 +101 @@
       { assert(peerMap_.find(peerID)!=peerMap_.end()); peerMap_[peerID].isSynched = true; }
     void removePeer( uint32_t peerID );
+    bool hasPeers(){ return this->peerMap_.size()!=0; }
 //     void removeClient(ClientInformation *client);
   protected:

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

@@ -117 +117 @@
     {
       for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
-        it->incomingChat(message, CLIENTID_UNKNOWN);
+        it->incomingChat(message, NETWORK_PEER_ID_BROADCAST);
       return true;
     }

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

@@ -65 +65 @@
 {
   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          = 55558;
   static const unsigned int NETWORK_PEER_ID_SERVER      = 0;
+  static const unsigned int NETWORK_PEER_ID_BROADCAST   = static_cast<unsigned int>(-1);
+  static const unsigned int NETWORK_PEER_ID_UNKNOWN     = static_cast<unsigned int>(-2);
   static const unsigned int NETWORK_CHANNEL_DEFAULT     = 0;
   static const unsigned int NETWORK_CHANNEL_UNRELIABLE  = 1;

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

@@ -57 +57 @@
 #include "packet/Welcome.h"
 #include "ChatListener.h"
-#include "ClientInformation.h"
+// #include "ClientInformation.h"
 #include "FunctionCallManager.h"
 #include "GamestateManager.h"
@@ -152 +152 @@
   bool Server::processChat(const std::string& message, unsigned int playerID)
   {
-    ClientInformation *temp = ClientInformation::getBegin();
+//     ClientInformation *temp = ClientInformation::getBegin();
     packet::Chat *chat;
-    while(temp){
-      chat = new packet::Chat(message, playerID);
-      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();
-    }
+//     while(temp){
+    chat = new packet::Chat(message, playerID);
+    chat->setPeerID(NETWORK_PEER_ID_BROADCAST);
+    chat->send( static_cast<Host*>(this) );
+//         COUT(3) << "could not send Chat message to client ID: " << temp->getID() << std::endl;
+//       temp = temp->next();
+//     }
 //    COUT(1) << "Player " << playerID << ": " << message << std::endl;
     return true;
@@ -207 +207 @@
     //helper_HandleMasterServerRequests();
 
-    if ( ClientInformation::hasClients() )
+    if ( GamestateManager::hasPeers() )
     {
       // process incoming gamestates
@@ -237 +237 @@
   unsigned int Server::getRTT(unsigned int clientID)
   {
-    assert(ClientInformation::findClient(clientID));
-    return ClientInformation::findClient(clientID)->getRTT();
+//     assert(ClientInformation::findClient(clientID));
+//     return ClientInformation::findClient(clientID)->getRTT();
+    // TODO: reimplement
+    return 0;
   }
 
   void Server::printRTT()
   {
-    for( ClientInformation* temp=ClientInformation::getBegin(); temp!=0; temp=temp->next() )
-      COUT(0) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
+//     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=0; temp=temp->next() )
+//       COUT(0) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
   }
 
@@ -252 +254 @@
   double Server::getPacketLoss(unsigned int clientID)
   {
-    assert(ClientInformation::findClient(clientID));
-    return ClientInformation::findClient(clientID)->getPacketLoss();
+//     assert(ClientInformation::findClient(clientID));
+//     return ClientInformation::findClient(clientID)->getPacketLoss();
+    return 0.;
   }
 
@@ -261 +264 @@
   void Server::updateGamestate()
   {
-    if( ClientInformation::getBegin()==NULL )
+    if( this->clientIDs_.size()==0 )
       //no client connected
       return;
@@ -291 +294 @@
   bool Server::sendObjectDeletes()
   {
-    ClientInformation *temp = ClientInformation::getBegin();
-    if( temp == NULL )
+//     ClientInformation *temp = ClientInformation::getBegin();
+//     if( temp == NULL )
       //no client connected
+    if( this->clientIDs_.size()==0 )
       return true;
     packet::DeleteObjects *del = new packet::DeleteObjects();
@@ -302 +306 @@
     }
 //     COUT(3) << "sending DeleteObjects" << std::endl;
-    while(temp != NULL){
-      if( !(temp->getSynched()) )
-      {
-        COUT(5) << "Server: not sending gamestate" << std::endl;
-        temp=temp->next();
-        continue;
-      }
-      int cid = temp->getID(); //get client id
-      packet::DeleteObjects *cd = new packet::DeleteObjects(*del);
-      assert(cd);
-      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();
+//     while(temp != NULL){
+//       if( !(temp->getSynched()) )
+//       {
+//         COUT(5) << "Server: not sending gamestate" << std::endl;
+//         temp=temp->next();
+//         continue;
+//       }
+//       int cid = temp->getID(); //get client id
+//       packet::DeleteObjects *cd = new packet::DeleteObjects(*del);
+//       assert(cd);
+    del->setPeerID(NETWORK_PEER_ID_BROADCAST);
+    if ( !del->send( static_cast<Host*>(this) ) )
+      COUT(3) << "Server: could not broadcast deleteObjects packet" << std::endl;
+//       temp=temp->next();
       // gs gets automatically deleted by enet callback
-    }
-    delete del;
+//     }
+//     delete del;
     return true;
   }
 
 
-  void Server::addPeer(ENetEvent *event)
-  {
-    static unsigned int newid=1;
-
-    COUT(2) << "Server: adding client" << std::endl;
-    ClientInformation *temp = ClientInformation::insertBack(new ClientInformation);
-    if(!temp)
-    {
-      COUT(2) << "Server: could not add client" << std::endl;
-    }
-    temp->setID(newid);
-    temp->setPeer(event->peer);
+  void Server::addPeer(uint32_t peerID)
+  {
+//     static unsigned int newid=1;
+// 
+//     COUT(2) << "Server: adding client" << std::endl;
+//     ClientInformation *temp = ClientInformation::insertBack(new ClientInformation);
+//     if(!temp)
+//     {
+//       COUT(2) << "Server: could not add client" << std::endl;
+//     }
+//     temp->setID(newid);
+//     temp->setPeer(event->peer);
 
     // inform all the listeners
-    ClientConnectionListener::broadcastClientConnected(newid);
-    GamestateManager::addPeer(newid);
-
-    ++newid;
-
-    COUT(3) << "Server: added client id: " << temp->getID() << std::endl;
-    createClient(temp->getID());
+    this->clientIDs_.push_back(peerID);
+    ClientConnectionListener::broadcastClientConnected(peerID);
+    GamestateManager::addPeer(peerID);
+
+//     ++newid;
+
+    COUT(3) << "Server: added client id: " << peerID << std::endl;
+    createClient(peerID);
 }
 
-  void Server::removePeer(ENetEvent *event)
+  void Server::removePeer(uint32_t peerID)
   {
     COUT(4) << "removing client from list" << std::endl;
-    ClientInformation *client = ClientInformation::findClient(&event->peer->address);
-    if(!client)
-      return;
-    else
-    {
-      GamestateManager::removePeer(client->getID());
+//     ClientInformation *client = ClientInformation::findClient(&event->peer->address);
+//     if(!client)
+//       return;
+//     else
+//     {
+  std::vector<uint32_t>::iterator it;
+  for( it=this->clientIDs_.begin(); it!=this->clientIDs_.end(); ++it )
+  {
+    if( *it == peerID )
+    {
+      this->clientIDs_.erase(it);
+      break;
+    }
+  }
+  ClientConnectionListener::broadcastClientDisconnected(peerID);
+  GamestateManager::removePeer(peerID);
       //ServerConnection::disconnectClient( client );
       //ClientConnectionListener::broadcastClientDisconnected( client->getID() ); //this is done in ClientInformation now
-      delete client;
-    }
+//       delete client;
+//     }
   }
   
@@ -365 +380 @@
     if( packet->isReliable() )
     {
-      if( this->getLastProcessedGamestateID(packet->getPeerID()) >= packet->getRequiredGamestateID() )
+      if( this->getLastReceivedGamestateID(packet->getPeerID()) >= packet->getRequiredGamestateID() )
         packet->process(static_cast<Host*>(this));
       else
@@ -377 +392 @@
   bool Server::createClient(int clientID)
   {
-    ClientInformation *temp = ClientInformation::findClient(clientID);
-    if(!temp)
-    {
-      COUT(2) << "Conn.Man. could not create client with id: " << clientID << std::endl;
-      return false;
-    }
-    COUT(4) << "Con.Man: creating client id: " << temp->getID() << std::endl;
+//     ClientInformation *temp = ClientInformation::findClient(clientID);
+//     if(!temp)
+//     {
+//       COUT(2) << "Server. could not create client with id: " << clientID << std::endl;
+//       return false;
+//     }
+//     COUT(4) << "Con.Man: creating client id: " << temp->getID() << std::endl;
 
     // synchronise class ids
-    syncClassid(temp->getID());
+    syncClassid(clientID);
 
     // now synchronise functionIDs
@@ -394 +409 @@
     assert(b);
 
-    temp->setSynched(true);
+//     temp->setSynched(true);
     GamestateManager::setSynched(clientID);
     
     COUT(4) << "sending welcome" << std::endl;
-    packet::Welcome *w = new packet::Welcome(temp->getID(), temp->getShipID());
-    w->setPeerID(temp->getID());
+    packet::Welcome *w = new packet::Welcome(clientID, OBJECTID_UNKNOWN);
+    w->setPeerID(clientID);
     b = w->send( static_cast<Host*>(this) );
     assert(b);
-    packet::Gamestate *g = new packet::Gamestate();
-    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();
+//     packet::Gamestate *g = new packet::Gamestate();
+//     g->setPeerID(clientID);
+//     b = g->collectData(0,packet::GAMESTATE_MODE_SERVER);
 //     assert(b);
-    b = g->send( static_cast<Host*>(this) );
-    assert(b);
+//     if(!b)
+//       return false; //no data for the client
+// //     b = g->compressData();
+// //     assert(b);
+//     b = g->send( static_cast<Host*>(this) );
+//     assert(b);
     return true;
   }
 
-  void Server::disconnectClient( ClientInformation *client )
-  {
-    ServerConnection::disconnectClient( client );
-    GamestateManager::removePeer(client->getID());
+  void Server::disconnectClient( uint32_t clientID )
+  {
+    ServerConnection::disconnectClient( clientID );
+    GamestateManager::removePeer( clientID );
     // inform all the listeners
     // ClientConnectionListener::broadcastClientDisconnected(client->getID()); // this is done in ClientInformation now
@@ -430 +445 @@
   bool Server::broadcast(const std::string& message)
   {
-      return this->sendChat(message, CLIENTID_UNKNOWN);
+      return this->sendChat(message, NETWORK_PEER_ID_BROADCAST);
   }
 
   bool Server::sendChat(const std::string& message, unsigned int clientID)
   {
-    ClientInformation *temp = ClientInformation::getBegin();
+//     ClientInformation *temp = ClientInformation::getBegin();
     packet::Chat *chat;
-    while(temp)
+//     while(temp)
     {
       chat = new packet::Chat(message, clientID);
-      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();
+      chat->setPeerID(NETWORK_PEER_ID_BROADCAST);
+      chat->send( static_cast<Host*>(this) );
+//         COUT(3) << "could not send Chat message to client ID: " << temp->getID() << std::endl;
+//       temp = temp->next();
     }
 //    COUT(1) << "Player " << Host::getPlayerID() << ": " << message << std::endl;

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

@@ -33 +33 @@
 
 #include <deque>
+#include <vector>
 
 #include "util/UtilPrereqs.h"
@@ -80 +81 @@
     unsigned int playerID(){return 0;}
 
-    void addPeer(ENetEvent *event);
-    void removePeer(ENetEvent *event);
+    void addPeer(uint32_t peerID);
+    void removePeer(uint32_t peerID);
     void processPacket(packet::Packet* packet);
 
     bool createClient(int clientID);
-    void disconnectClient( ClientInformation *client);
+    void disconnectClient( uint32_t clientID );
     bool sendGameStates();
     bool sendObjectDeletes();
@@ -95 +96 @@
     float timeSinceLastUpdate_;
     std::deque<packet::Packet*> packetQueue_;
+    std::vector<uint32_t>       clientIDs_;
   };
 

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

@@ -35 +35 @@
 
 #include "util/Debug.h"
-#include "ClientInformation.h"
+#include <util/Sleep.h>
+// #include "ClientInformation.h"
 
 namespace orxonox
@@ -44 +45 @@
   {
     this->bindAddress_ = new ENetAddress();
-    memset(this->bindAddress_, 0, sizeof(ENetAddress));
+//     memset(this->bindAddress_, 0, sizeof(ENetAddress));
     this->bindAddress_->host = ENET_HOST_ANY;
     this->bindAddress_->port = NETWORK_PORT;
+    this->bindAddress_->scopeID = 0;
   }
 
@@ -104 +106 @@
   void ServerConnection::addPacket(ENetPacket *packet, unsigned int clientID, uint8_t channelID)
   {
-    if ( clientID == CLIENTID_UNKNOWN )
+    if ( clientID == NETWORK_PEER_ID_BROADCAST )
     {
       broadcastPacket(packet, channelID);
@@ -110 +112 @@
     else
     {
-      ClientInformation *temp = ClientInformation::findClient(clientID);
-      if(!temp){
-        COUT(3) << "C.Man: addPacket findClient failed" << std::endl;
-      }
-      Connection::addPacket(packet, temp->getPeer(), channelID);
+//       ClientInformation *temp = ClientInformation::findClient(clientID);
+//       if(!temp){
+//         COUT(3) << "C.Man: addPacket findClient failed" << std::endl;
+//       }
+      Connection::addPacket(packet, clientID, channelID);
     }
   }
 
-  void ServerConnection::disconnectClient(ClientInformation *client)
-  {
-    Connection::disconnectPeer( client->getPeer() );
-  }
+//   void ServerConnection::disconnectClient(ClientInformation *client)
+//   {
+//     Connection::disconnectPeer( client->getPeer() );
+//   }
 
   void ServerConnection::disconnectClient(int clientID)
   {
-    ClientInformation *client = ClientInformation::findClient(clientID);
-    if(client)
-      ServerConnection::disconnectClient(client);
+//     ClientInformation *client = ClientInformation::findClient(clientID);
+//     if(client)
+    ServerConnection::disconnectClient(clientID);
   }
 
   void ServerConnection::disconnectClients()
   {
-    ClientInformation *temp = ClientInformation::getBegin();
-    while(temp!=0)
-    {
-      ServerConnection::disconnectClient( temp );
-      temp = temp->next();
-    }
+    Connection::disconnectPeers();
+    Connection::waitOutgoingQueue();
     return;
   }
 
 
-  int ServerConnection::getClientID(ENetPeer* peer)
-  {
-    return getClientID(&(peer->address));
-  }
+//   int ServerConnection::getClientID(ENetPeer* peer)
+//   {
+//     return getClientID(&(peer->address));
+//   }
 
-  int ServerConnection::getClientID(ENetAddress* address)
-  {
-    return ClientInformation::findClient(address)->getID();
-  }
-
-  ENetPeer *ServerConnection::getClientPeer(int clientID)
-  {
-    return ClientInformation::findClient(clientID)->getPeer();
-  }
+//   int ServerConnection::getClientID(ENetAddress* address)
+//   {
+//     return ClientInformation::findClient(address)->getID();
+//   }
+// 
+//   ENetPeer *ServerConnection::getClientPeer(int clientID)
+//   {
+//     return ClientInformation::findClient(clientID)->getPeer();
+//   }
 
 

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

@@ -57 +57 @@
     bool closeListener();
     void addPacket(ENetPacket *packet, unsigned int ID, uint8_t channelID);
-    virtual void disconnectClient(ClientInformation *client);
+//     virtual void disconnectClient(ClientInformation *client);
     void disconnectClient(int clientID);
   protected:
@@ -64 +64 @@
 
   private:
-    int getClientID(ENetPeer* peer);
-    int getClientID(ENetAddress* address);
-    ENetPeer* getClientPeer(int clientID);
+//     int getClientID(ENetPeer* peer);
+//     int getClientID(ENetAddress* address);
+//     ENetPeer* getClientPeer(int clientID);
 
     ENetAddress* bindAddress_;

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

@@ -71 +71 @@
      * has changed. 
      */
-    SetConfigValue( msaddress, "orxonox.net");
+    SetConfigValue( msaddress, "master.orxonox.net");
   } 
 

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

@@ -107 +107 @@
   uint32_t size = calcGamestateSize(id, mode);
 
-  COUT(4) << "G.ST.Man: producing gamestate with id: " << id << std::endl;
+  COUT(5) << "G.ST.Man: producing gamestate with id: " << id << std::endl;
   if(size==0)
     return false;
@@ -158 +158 @@
   //start write gamestate header
   header_.setDataSize( currentsize );
+  header_.setCompSize( 0 );
   header_.setID( id );
   header_.setBaseID( GAMESTATEID_INITIAL );

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

@@ -47 +47 @@
 #include "Welcome.h"
 #include "network/Host.h"
-#include "network/ClientInformation.h"
+// #include "network/ClientInformation.h"
 
 namespace orxonox{
@@ -85 +85 @@
 
 
-Packet::Packet(const Packet &p){
+Packet::Packet(const Packet &p)
+{
   enetPacket_=p.enetPacket_;
   flags_=p.flags_;
@@ -104 +105 @@
     That also means destroying the ENetPacket if one exists. There
 */
-Packet::~Packet(){
+Packet::~Packet()
+{
   // Deallocate data_ memory if necessary.
-  if (this->bDataENetAllocated_){
+  if (this->bDataENetAllocated_)
+  {
     // In this case ENet allocated data_ and will destroy it.
   }
-  else if (this->data_) {
+  else if (this->data_)
+  {
     // This destructor was probably called as a consequence of ENet executing our callback.
     // It simply serves us to be able to deallocate the packet content (data_) ourselves since
@@ -119 +123 @@
   // Note: For the case ENet used the callback to destroy the packet, we have already set
   // enetPacket_ to NULL to avoid destroying it again.
-  if (this->enetPacket_){
+  if (this->enetPacket_)
+  {
     // enetPacket_->data gets destroyed too by ENet if it was allocated by it.
     enet_packet_destroy(enetPacket_);
@@ -125 +130 @@
 }
 
-bool Packet::send(orxonox::Host* host){
-  if(packetDirection_ != Direction::Outgoing && packetDirection_ != Direction::Bidirectional ){
+bool Packet::send(orxonox::Host* host)
+{
+  if(packetDirection_ != Direction::Outgoing && packetDirection_ != Direction::Bidirectional )
+  {
     assert(0);
     return false;
   }
-  if(!enetPacket_){
+  if(!enetPacket_)
+  {
     if(!data_){
       assert(0);
@@ -175 +183 @@
 }
 
-Packet *Packet::createPacket(ENetPacket *packet, ENetPeer *peer){
+Packet *Packet::createPacket(ENetPacket* packet, uint32_t peerID)
+{
   uint8_t *data = packet->data;
-  assert(ClientInformation::findClient(&peer->address)->getID() != static_cast<unsigned int>(-2) || !Host::isServer());
-  unsigned int peerID = ClientInformation::findClient(&peer->address)->getID();
+//   assert(ClientInformation::findClient(&peer->address)->getID() != static_cast<unsigned int>(-2) || !Host::isServer());
+//   unsigned int peerID = ClientInformation::findClient(&peer->address)->getID();
   // HACK
-  if( peerID==static_cast<unsigned int>(-2))
-    peerID = NETWORK_PEER_ID_SERVER;
+//   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;
@@ -235 +244 @@
     data we allocated ourselves.
 */
-void Packet::deletePacket(ENetPacket *enetPacket){
+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();

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

@@ -32 +32 @@
 #include <map>
 
-namespace orxonox {
+namespace orxonox
+{
 
-namespace packet{
+namespace packet
+{
 
-namespace Direction{
-  enum Value{
+namespace Direction
+{
+  enum Value
+  {
     Incoming,
     Outgoing,
@@ -43 +47 @@
   };
 }
-namespace Type{
-  enum Value{
+namespace Type
+{
+  enum Value
+  {
     Acknowledgement,
     Chat,
@@ -59 +65 @@
     @author Oliver Scheuss <scheusso [at] ee.ethz.ch>
 */
-class _NetworkExport Packet{
+class _NetworkExport Packet
+{
   public:
     Packet(const Packet &p);
     virtual ~Packet();
-    static Packet *createPacket(ENetPacket *packet, ENetPeer *peer);
-    static void deletePacket(ENetPacket *packet);
+    static Packet* createPacket(ENetPacket* packet, uint32_t peerID);
+    static void deletePacket(ENetPacket* packet);
 
-    virtual unsigned char *getData(){ return data_; };
+    virtual unsigned char* getData(){ return data_; };
     virtual unsigned int getSize() const =0;
     virtual bool process(orxonox::Host* host)=0;

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

@@ -295 +295 @@
    * @param mem pointer to the bytestream
    * @param mode same as in getData
-   * @param forceCallback FIXME - add doc!
+   * @param forceCallback this makes updateData call each callback
    * @return true/false
    */
@@ -372 +372 @@
    * This function determines, wheter the object should be saved to the bytestream (according to its syncmode/direction)
    * @param id gamestate id
-   * @param mode FIXME - add doc!
+   * @param mode Synchronisation mode (toclient, toserver or bidirectional)
    * @return true/false
    */
   bool Synchronisable::doSync(int32_t id, uint8_t mode)
   {
-    if(mode==0x0)
-      mode=state_;
+//     if(mode==0x0)
+//       mode=state_;
+    assert(mode!=0x0);
     return ( (this->objectMode_ & mode)!=0 && (!syncList_.empty() ) );
   }

code/trunk/src/modules/overlays/hud/ChatOverlay.cc

@@ -71 +71 @@
         std::string text;
 
-        if (senderID != CLIENTID_UNKNOWN)
+        if (senderID != NETWORK_PEER_ID_UNKNOWN)
         {
             std::string name = "unknown";

code/trunk/src/orxonox/ChatHistory.cc

@@ -82 +82 @@
 #ifndef CHATTEST
     /* get sender ID and prepend it to the message */
-    if (senderID != CLIENTID_UNKNOWN)
+    if (senderID != NETWORK_PEER_ID_UNKNOWN)
     {
       /* if we can't find anything, use "unknown" as default */

code/trunk/src/orxonox/ChatInputHandler.cc

@@ -220 +220 @@
 
     /* setup player name info */
-    if (senderID != CLIENTID_UNKNOWN)
+    if (senderID != NETWORK_PEER_ID_UNKNOWN)
     {
        PlayerInfo* player = PlayerManager::getInstance().getClient(senderID);

code/trunk/src/orxonox/PlayerManager.cc

@@ -45 +45 @@
         RegisterRootObject(PlayerManager);
 
-        this->getConnectedClients();
+//         this->getConnectedClients();
     }
 

code/trunk/src/orxonox/gamestates/GSRoot.cc

@@ -183 +183 @@
     {
         if (!GameMode::isStandalone())
-            callStaticNetworkFunction(&TimeFactorListener::setTimeFactor, CLIENTID_UNKNOWN, factor_new);
+            callStaticNetworkFunction(&TimeFactorListener::setTimeFactor, NETWORK_PEER_ID_BROADCAST, factor_new);
     }
 

code/trunk/src/orxonox/gametypes/Dynamicmatch.cc

@@ -452 +452 @@
                     if (!it->first)//in order to catch nullpointer
                         continue;
-                    if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                    if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",it->first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
@@ -467 +467 @@
                        if (!it->first)//in order to catch nullpointer
                            continue;
-                       if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                       if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                            continue;
                        else if (it->second==chaser)
@@ -501 +501 @@
                     if (!it->first)//in order to catch nullpointer
                         continue;
-                    if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                    if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",it->first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
@@ -516 +516 @@
                        if (!it->first)
                            continue;
-                       if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                       if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                            continue;
                        else if (it->second==chaser)
@@ -551 +551 @@
                     if (!it->first)//in order to catch nullpointer
                         continue;
-                    if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                    if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",it->first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
@@ -566 +566 @@
                        if (!it->first)
                            continue;
-                       if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                       if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                            continue;
                        else if (it->second==chaser)
@@ -632 +632 @@
             for (std::map<PlayerInfo*, int>::iterator it = this->playerParty_.begin(); it != this->playerParty_.end(); ++it)
             {
-                if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                     continue;
                 this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",it->first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));

code/trunk/src/orxonox/gametypes/Gametype.cc

@@ -263 +263 @@
                         it->second.frags_++;
 
-                        if (killer->getPlayer()->getClientID() != CLIENTID_UNKNOWN)
+                        if (killer->getPlayer()->getClientID() != NETWORK_PEER_ID_UNKNOWN)
                             this->gtinfo_->sendKillMessage("You killed " + victim->getPlayer()->getName(), killer->getPlayer()->getClientID());
-                        if (victim->getPlayer()->getClientID() != CLIENTID_UNKNOWN)
+                        if (victim->getPlayer()->getClientID() != NETWORK_PEER_ID_UNKNOWN)
                             this->gtinfo_->sendDeathMessage("You were killed by " + killer->getPlayer()->getName(), victim->getPlayer()->getClientID());
                     }

code/trunk/src/orxonox/gametypes/LastManStanding.cc

@@ -86 +86 @@
             if (it != this->players_.end())
             {
-                if (it->first->getClientID()== CLIENTID_UNKNOWN)
+                if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                     return true;
                 const std::string& message = ""; // resets Camper-Warning-message
@@ -131 +131 @@
         for (std::map<PlayerInfo*, int>::iterator it = this->playerLives_.begin(); it != this->playerLives_.end(); ++it)
         {
-            if (it->first->getClientID() == CLIENTID_UNKNOWN)
+            if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
 
@@ -194 +194 @@
         if (it != this->players_.end())
         {
-            if (it->first->getClientID()== CLIENTID_UNKNOWN)
+            if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                 return;
             const std::string& message = ""; // resets Camper-Warning-message
@@ -249 +249 @@
                     this->inGame_[it->first]=true;
 
-                    if (it->first->getClientID()== CLIENTID_UNKNOWN)
+                    if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     int output=1+(int)playerDelayTime_[it->first];
@@ -261 +261 @@
                     {
                         this->punishPlayer(it->first);
-                        if (it->first->getClientID()== CLIENTID_UNKNOWN)
+                        if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                             return;
                         const std::string& message = ""; // resets Camper-Warning-message
@@ -269 +269 @@
                 else if (it->second<timeRemaining/5)//Warning message
                 {
-                    if (it->first->getClientID()== CLIENTID_UNKNOWN)
+                    if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     const std::string& message = "Camper Warning! Don't forget to shoot.";

code/trunk/src/orxonox/gametypes/LastTeamStanding.cc

@@ -30 +30 @@
 
 #include "core/CoreIncludes.h"
+#include "network/NetworkPrereqs.h"
 #include "network/Host.h"
 #include "infos/PlayerInfo.h"
@@ -135 +136 @@
             if (it != this->players_.end())
             {
-                if (it->first->getClientID()== CLIENTID_UNKNOWN)
+                if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                     return true;
                 const std::string& message = ""; // resets Camper-Warning-message
@@ -169 +170 @@
         if (it != this->players_.end())
         {
-            if (it->first->getClientID()== CLIENTID_UNKNOWN)
+            if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                 return;
             const std::string& message = ""; // resets Camper-Warning-message
@@ -196 +197 @@
                     this->inGame_[it->first] = true;
 
-                    if (it->first->getClientID()== CLIENTID_UNKNOWN)
+                    if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     int output = 1 + (int)playerDelayTime_[it->first];
@@ -208 +209 @@
                     {
                         this->punishPlayer(it->first);
-                        if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                        if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                             return;
                         const std::string& message = ""; // resets Camper-Warning-message
@@ -216 +217 @@
                 else if (it->second < timeRemaining/5)//Warning message
                 {
-                    if (it->first->getClientID()== CLIENTID_UNKNOWN)
+                  if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     const std::string& message = "Camper Warning! Don't forget to shoot.";
@@ -232 +233 @@
         for (std::map<PlayerInfo*, int>::iterator it = this->playerLives_.begin(); it != this->playerLives_.end(); ++it)
         {
-            if (it->first->getClientID() == CLIENTID_UNKNOWN)
+          if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
 
@@ -247 +248 @@
                 for (std::map<PlayerInfo*, int>::iterator it3 = this->teamnumbers_.begin(); it3 != this->teamnumbers_.end(); ++it3)
                 {
-                    if (it3->first->getClientID() == CLIENTID_UNKNOWN)
+                  if (it3->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     if (it3->second == party)

code/trunk/src/orxonox/gametypes/TeamBaseMatch.cc

@@ -190 +190 @@
             for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
             {
-                if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                     continue;
 

code/trunk/src/orxonox/gametypes/UnderAttack.cc

@@ -76 +76 @@
         for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
         {
-            if (it->first->getClientID() == CLIENTID_UNKNOWN)
+            if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
 
@@ -158 +158 @@
                 for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
                 {
-                    if (it->first->getClientID() == CLIENTID_UNKNOWN)
+                    if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                         continue;
 

code/trunk/src/orxonox/infos/GametypeInfo.cc

@@ -74 +74 @@
         if (GameMode::isMaster())
         {
-            callMemberNetworkFunction(GametypeInfo, dispatchAnnounceMessage, this->getObjectID(), CLIENTID_UNKNOWN, message);
+            callMemberNetworkFunction(GametypeInfo, dispatchAnnounceMessage, this->getObjectID(), NETWORK_PEER_ID_BROADCAST, message);
             this->dispatchAnnounceMessage(message);
         }

code/trunk/src/orxonox/infos/HumanPlayer.cc

@@ -32 +32 @@
 #include "core/ConfigValueIncludes.h"
 #include "core/GameMode.h"
-#include "network/ClientInformation.h"
+// #include "network/ClientInformation.h"
 #include "network/Host.h"
 #include "controllers/HumanController.h"
@@ -144 +144 @@
     float HumanPlayer::getPing() const
     {
-        return static_cast<float>(ClientInformation::findClient(this->getClientID())->getRTT());
+//         return static_cast<float>(ClientInformation::findClient(this->getClientID())->getRTT());
+        return 0.; //TODO: reimplement this
     }
 
     float HumanPlayer::getPacketLossRatio() const
     {
-        return static_cast<float>(ClientInformation::findClient(this->getClientID())->getPacketLoss());
+      //         return static_cast<float>(ClientInformation::findClient(this->getClientID())->getPacketLoss());
+        return 0.; //TODO: reimplement this
     }
 

code/trunk/src/orxonox/infos/PlayerInfo.cc

@@ -32 +32 @@
 
 #include "core/CoreIncludes.h"
-#include "network/ClientInformation.h"
+// #include "network/ClientInformation.h"
 #include "gametypes/Gametype.h"
 #include "worldentities/ControllableEntity.h"
@@ -43 +43 @@
         RegisterObject(PlayerInfo);
 
-        this->clientID_ = CLIENTID_UNKNOWN;
+        this->clientID_ = NETWORK_PEER_ID_UNKNOWN;
         this->bHumanPlayer_ = false;
         this->bLocalPlayer_ = false;