Index: code/trunk/src/libraries/network/Client.cc
===================================================================
--- code/trunk/src/libraries/network/Client.cc	(revision 11052)
+++ code/trunk/src/libraries/network/Client.cc	(revision 11071)
@@ -161,8 +161,7 @@
         {
           std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
-          std::vector<packet::Gamestate*>::iterator it;
-          for( it = gamestates.begin(); it != gamestates.end(); ++it )
+          for( packet::Gamestate* gamestate : gamestates )
           {
-            (*it)->send( static_cast<Host*>(this) );
+            gamestate->send( static_cast<Host*>(this) );
           }
         }
Index: code/trunk/src/libraries/network/Client.h
===================================================================
--- code/trunk/src/libraries/network/Client.h	(revision 11052)
+++ code/trunk/src/libraries/network/Client.h	(revision 11071)
@@ -76,20 +76,20 @@
     static Client* getInstance(){ return singletonPtr_s; } // tolua_export
 
-    bool establishConnection();
+    virtual bool establishConnection() override;
     void setDestination( const std::string& serverAddress, unsigned int port ); // tolua_export
-    bool closeConnection();
-    void queuePacket(ENetPacket* packet, int clientID, uint8_t channelID);
-    virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
-    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
-    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
-    virtual void printRTT();
+    virtual bool closeConnection() override;
+    virtual void queuePacket(ENetPacket* packet, int clientID, uint8_t channelID) override;
+    virtual bool sendPacket( packet::Packet* packet ) override{ return packet->send( static_cast<Host*>(this) ); }
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
+    virtual void printRTT() override;
 
     void update(const Clock& time);
   protected:
-    virtual void connectionClosed();
+    virtual void connectionClosed() override;
   private:
     Client(const Client& copy); // not used
-    virtual bool isServer_(){return false;}
-    void processPacket(packet::Packet* packet);
+    virtual bool isServer_() override{return false;}
+    virtual void processPacket(packet::Packet* packet) override;
 
     static Client* singletonPtr_s;
Index: code/trunk/src/libraries/network/ClientConnection.cc
===================================================================
--- code/trunk/src/libraries/network/ClientConnection.cc	(revision 11052)
+++ code/trunk/src/libraries/network/ClientConnection.cc	(revision 11071)
@@ -44,5 +44,5 @@
     Connection(NETWORK_PEER_ID_SERVER),
     established_(false),
-    server_(NULL)
+    server_(nullptr)
   {
     this->serverAddress_ = new ENetAddress();
@@ -72,9 +72,9 @@
 
     // create host
-    this->host_ = enet_host_create(NULL, NETWORK_CLIENT_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
+    this->host_ = enet_host_create(nullptr, NETWORK_CLIENT_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
     
-    if ( this->host_ == NULL )
+    if ( this->host_ == nullptr )
     {
-      orxout(internal_error, context::network) << "ClientConnection: host_ == NULL" << endl;
+      orxout(internal_error, context::network) << "ClientConnection: host_ == nullptr" << endl;
       // error handling
       return false;
@@ -93,7 +93,7 @@
 
     this->server_ = enet_host_connect(this->host_, serverAddress_, NETWORK_CHANNEL_COUNT, 0);
-    if ( this->server_==NULL )
+    if ( this->server_==nullptr )
     {
-      orxout(internal_error, context::network) << "ClientConnection: server_ == NULL" << endl;
+      orxout(internal_error, context::network) << "ClientConnection: server_ == nullptr" << endl;
       // error handling
       return false;
Index: code/trunk/src/libraries/network/ClientConnection.h
===================================================================
--- code/trunk/src/libraries/network/ClientConnection.h	(revision 11052)
+++ code/trunk/src/libraries/network/ClientConnection.h	(revision 11071)
@@ -57,6 +57,6 @@
     uint32_t getRTT();
   private:
-    virtual void addPeer(uint32_t peerID);
-    virtual void removePeer(uint32_t peerID);
+    virtual void addPeer(uint32_t peerID) override;
+    virtual void removePeer(uint32_t peerID) override;
 
     bool disconnectConnection();
Index: code/trunk/src/libraries/network/ClientConnectionListener.cc
===================================================================
--- code/trunk/src/libraries/network/ClientConnectionListener.cc	(revision 11052)
+++ code/trunk/src/libraries/network/ClientConnectionListener.cc	(revision 11071)
@@ -44,12 +44,12 @@
     void ClientConnectionListener::broadcastClientConnected(unsigned int clientID)
     {
-        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
-            it->clientConnected(clientID);
+        for (ClientConnectionListener* listener : ObjectList<ClientConnectionListener>())
+            listener->clientConnected(clientID);
     }
 
     void ClientConnectionListener::broadcastClientDisconnected(unsigned int clientID)
     {
-        for (ObjectList<ClientConnectionListener>::iterator it = ObjectList<ClientConnectionListener>::begin(); it != ObjectList<ClientConnectionListener>::end(); ++it)
-            it->clientDisconnected(clientID);
+        for (ClientConnectionListener* listener : ObjectList<ClientConnectionListener>())
+            listener->clientDisconnected(clientID);
     }
 
Index: code/trunk/src/libraries/network/Connection.cc
===================================================================
--- code/trunk/src/libraries/network/Connection.cc	(revision 11052)
+++ code/trunk/src/libraries/network/Connection.cc	(revision 11071)
@@ -46,5 +46,5 @@
 
   Connection::Connection(uint32_t firstPeerID):
-    host_(0), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
+    host_(nullptr), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
   {
     enet_initialize();
@@ -81,5 +81,5 @@
   {
 //     this->overallMutex_->lock();
-    outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, 0, 0 };
+    outgoingEvent outEvent = { peerID, OutgoingEventType::disconnectPeer, nullptr, 0 };
     
     this->outgoingEventsMutex_->lock();
@@ -91,5 +91,5 @@
   void Connection::disconnectPeers()
   {
-    outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, 0, 0 };
+    outgoingEvent outEvent = { 0, OutgoingEventType::disconnectPeers, nullptr, 0 };
     
     this->outgoingEventsMutex_->lock();
@@ -101,5 +101,5 @@
   {
 //     this->overallMutex_->lock();
-    outgoingEvent outEvent = { peerID, outgoingEventType::sendPacket, packet, channelID };
+    outgoingEvent outEvent = { peerID, OutgoingEventType::sendPacket, packet, channelID };
     
     this->outgoingEventsMutex_->lock();
@@ -112,5 +112,5 @@
   {
 //     this->overallMutex_->lock();
-    outgoingEvent outEvent = { 0, outgoingEventType::broadcastPacket, packet, channelID };
+    outgoingEvent outEvent = { 0, OutgoingEventType::broadcastPacket, packet, channelID };
     
     this->outgoingEventsMutex_->lock();
@@ -197,5 +197,5 @@
     switch( event.type )
     {
-      case outgoingEventType::sendPacket:
+      case OutgoingEventType::sendPacket:
         // check whether the peer is still/already in the peer list
         if( this->peerMap_.find(event.peerID) != this->peerMap_.end() )
@@ -211,5 +211,5 @@
         }
         break;
-      case outgoingEventType::disconnectPeer:
+      case OutgoingEventType::disconnectPeer:
         if( this->peerMap_.find(event.peerID) != this->peerMap_.end() )
         {
@@ -223,8 +223,8 @@
         }
         break;
-      case outgoingEventType::disconnectPeers:
+      case OutgoingEventType::disconnectPeers:
         disconnectPeersInternal();
         break;
-      case outgoingEventType::broadcastPacket:
+      case OutgoingEventType::broadcastPacket:
         enet_host_broadcast( this->host_, event.channelID, event.packet );
         break;
@@ -237,8 +237,7 @@
   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);
+    for( const auto& mapEntry : this->peerMap_ )
+    {
+      enet_peer_disconnect(mapEntry.second, 0);
     }
     uint32_t iterations = NETWORK_DISCONNECT_TIMEOUT/NETWORK_WAIT_TIMEOUT;
@@ -272,11 +271,11 @@
       switch( inEvent.type )
       {
-        case incomingEventType::peerConnect:
+        case IncomingEventType::peerConnect:
           addPeer(inEvent.peerID);
           break;
-        case incomingEventType::peerDisconnect:
+        case IncomingEventType::peerDisconnect:
           removePeer(inEvent.peerID);
           break;
-        case incomingEventType::receivePacket:
+        case IncomingEventType::receivePacket:
           processPacket(inEvent.packet);
           break;
@@ -323,5 +322,5 @@
     
     // create new peerEvent and return it
-    incomingEvent inEvent = { peerID, incomingEventType::peerConnect, 0 };
+    incomingEvent inEvent = { peerID, IncomingEventType::peerConnect, nullptr };
     return inEvent;
   }
@@ -338,5 +337,5 @@
     
     // create new peerEvent and return it
-    incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, 0 };
+    incomingEvent inEvent = { peerID, IncomingEventType::peerDisconnect, nullptr };
     return inEvent;
   }
@@ -352,5 +351,5 @@
     
     // create new peerEvent and return it
-    incomingEvent inEvent = { peerID, incomingEventType::receivePacket, p };
+    incomingEvent inEvent = { peerID, IncomingEventType::receivePacket, p };
     return inEvent;
   }
Index: code/trunk/src/libraries/network/Connection.h
===================================================================
--- code/trunk/src/libraries/network/Connection.h	(revision 11052)
+++ code/trunk/src/libraries/network/Connection.h	(revision 11071)
@@ -46,5 +46,4 @@
 #include <map>
 #include <enet/enet.h>
-#include <boost/concept_check.hpp>
 
 namespace boost
@@ -61,40 +60,32 @@
   const unsigned int NETWORK_MAX_QUEUE_PROCESS_TIME = 5;
   
-  namespace incomingEventType
+  enum class IncomingEventType
   {
-    enum Value
-    {
-      receivePacket   = 1,  // incoming packet
-      peerConnect     = 2,  // incoming connect request
-      peerDisconnect  = 3   // incoming disconnect request
-    };
-    
-  }
+    receivePacket   = 1,  // incoming packet
+    peerConnect     = 2,  // incoming connect request
+    peerDisconnect  = 3   // incoming disconnect request
+  };
   
-  namespace outgoingEventType
+  enum class OutgoingEventType
   {
-    enum Value
-    {
-      sendPacket      = 1,  // outgoing packet
-      broadcastPacket = 2,  // outgoing broadcast packet
-      disconnectPeer  = 3,  // outgoing disconnect request
-      disconnectPeers = 4   // outgoing disconnect request
-    };
-    
-  }
+    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;
+    uint32_t          peerID;
+    IncomingEventType type;
+    packet::Packet*   packet;
   };
   
   struct _NetworkExport outgoingEvent
   {
-    uint32_t                  peerID;
-    outgoingEventType::Value  type;
-    ENetPacket*               packet;
-    ENetChannelID             channelID;
+    uint32_t          peerID;
+    OutgoingEventType type;
+    ENetPacket*       packet;
+    ENetChannelID     channelID;
   };
   
Index: code/trunk/src/libraries/network/FunctionCall.cc
===================================================================
--- code/trunk/src/libraries/network/FunctionCall.cc	(revision 11052)
+++ code/trunk/src/libraries/network/FunctionCall.cc	(revision 11071)
@@ -48,5 +48,5 @@
 bool FunctionCall::execute(){
   NetworkFunctionBase* fct = NetworkFunctionManager::getInstance().getFunctionByNetworkId( this->functionID_ );
-  assert( fct != NULL );
+  assert( fct != nullptr );
   assert( this->nrOfArguments_==this->arguments_.size() );
   switch(this->nrOfArguments_)
@@ -119,5 +119,5 @@
   for( unsigned int i=0; i<this->nrOfArguments_; ++i )
   {
-    this->arguments_.push_back(MultiType());
+    this->arguments_.emplace_back();
     this->arguments_.back().importData(mem);
   }
@@ -131,7 +131,7 @@
   *(uint32_t*)(mem+2*sizeof(uint32_t)) = this->objectID_;
   mem += 3*sizeof(uint32_t);
-  for( std::vector<MultiType>::iterator it = this->arguments_.begin(); it!=this->arguments_.end(); ++it )
+  for(const MultiType& argument : this->arguments_)
   {
-    it->exportData( mem );
+    argument.exportData( mem );
   }
 }
Index: code/trunk/src/libraries/network/FunctionCallManager.cc
===================================================================
--- code/trunk/src/libraries/network/FunctionCallManager.cc	(revision 11052)
+++ code/trunk/src/libraries/network/FunctionCallManager.cc	(revision 11071)
@@ -37,5 +37,5 @@
 
 std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::sPeerMap_;
-std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > > FunctionCallManager::sIncomingFunctionCallBuffer_;
+std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>> FunctionCallManager::sIncomingFunctionCallBuffer_;
 
 
@@ -54,9 +54,8 @@
 void FunctionCallManager::sendCalls(orxonox::Host* host)
 {
-  std::map<uint32_t, packet::FunctionCalls*>::iterator it;
-  for (it = FunctionCallManager::sPeerMap_.begin(); it != FunctionCallManager::sPeerMap_.end(); ++it )
+  for (const auto& mapEntry : FunctionCallManager::sPeerMap_ )
   {
     assert(!FunctionCallManager::sPeerMap_.empty());
-    it->second->send(host);
+    mapEntry.second->send(host);
   }
   FunctionCallManager::sPeerMap_.clear();
@@ -65,10 +64,10 @@
 void FunctionCallManager::bufferIncomingFunctionCall(const orxonox::FunctionCall& fctCall, uint32_t minGamestateID, uint32_t peerID)
 {
-  FunctionCallManager::sIncomingFunctionCallBuffer_.push_back( std::make_pair(fctCall, std::make_pair(minGamestateID, peerID)));
+  FunctionCallManager::sIncomingFunctionCallBuffer_.emplace_back(fctCall, std::make_pair(minGamestateID, peerID));
 }
 
 void FunctionCallManager::processBufferedFunctionCalls()
 {
-  std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t> > >::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
+  std::vector<std::pair<FunctionCall, std::pair<uint32_t, uint32_t>>>::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
   while( it!=FunctionCallManager::sIncomingFunctionCallBuffer_.end() )
   {
Index: code/trunk/src/libraries/network/FunctionCallManager.h
===================================================================
--- code/trunk/src/libraries/network/FunctionCallManager.h	(revision 11052)
+++ code/trunk/src/libraries/network/FunctionCallManager.h	(revision 11071)
@@ -54,5 +54,5 @@
 
   static std::map<uint32_t, packet::FunctionCalls*>                           sPeerMap_;
-  static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t> > > sIncomingFunctionCallBuffer_;
+  static std::vector<std::pair<FunctionCall,std::pair<uint32_t, uint32_t>>> sIncomingFunctionCallBuffer_;
 protected:
   FunctionCallManager();
Index: code/trunk/src/libraries/network/GamestateHandler.cc
===================================================================
--- code/trunk/src/libraries/network/GamestateHandler.cc	(revision 11052)
+++ code/trunk/src/libraries/network/GamestateHandler.cc	(revision 11071)
@@ -32,5 +32,5 @@
 namespace orxonox {
 
-// GamestateHandler *GamestateHandler::instance_=0;
+// GamestateHandler *GamestateHandler::instance_=nullptr;
 
 GamestateHandler::GamestateHandler()
Index: code/trunk/src/libraries/network/GamestateManager.cc
===================================================================
--- code/trunk/src/libraries/network/GamestateManager.cc	(revision 11052)
+++ code/trunk/src/libraries/network/GamestateManager.cc	(revision 11071)
@@ -60,5 +60,5 @@
 { 
   GamestateManager::GamestateManager() :
-  currentGamestate_(0), id_(0)
+  currentGamestate_(nullptr), id_(0)
   {
 //     trafficControl_ = new TrafficControl();
@@ -70,13 +70,11 @@
   {
     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<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;
+        delete this->currentGamestate_;
+    for( const auto& mapEntry : gamestateQueue )
+      delete mapEntry.second;
+    for( const auto& mapEntryPeer : peerMap_ )
+    {
+      for( const auto& mapEntryGamestate : mapEntryPeer.second.gamestates )
+        delete mapEntryGamestate.second;
     }
 //     this->trafficControl_->destroy();
@@ -107,11 +105,10 @@
     if( this->gamestateQueue.empty() )
         return true;
-    std::map<unsigned int, packet::Gamestate*>::iterator it;
     // now push only the most recent gamestates we received (ignore obsolete ones)
-    for(it = gamestateQueue.begin(); it!=gamestateQueue.end(); it++)
-    {
-      OrxVerify(processGamestate(it->second), "ERROR: could not process Gamestate");
-      sendAck( it->second->getID(), it->second->getPeerID() );
-      delete it->second;
+    for(const auto& mapEntry : gamestateQueue)
+    {
+      OrxVerify(processGamestate(mapEntry.second), "ERROR: could not process Gamestate");
+      sendAck( mapEntry.second->getID(), mapEntry.second->getPeerID() );
+      delete mapEntry.second;
     }
     // now clear the queue
@@ -140,5 +137,5 @@
 
   bool GamestateManager::getSnapshot(){
-    if ( currentGamestate_ != 0 )
+    if ( currentGamestate_ != nullptr )
       delete currentGamestate_;
     uint8_t gsMode;
@@ -165,5 +162,5 @@
     { //we have no data to send
       delete currentGamestate_;
-      currentGamestate_=0;
+      currentGamestate_=nullptr;
       return false;
     }
@@ -177,19 +174,18 @@
     std::vector<packet::Gamestate*> peerGamestates;
     
-    std::map<uint32_t, peerInfo>::iterator peerIt;
-    for( peerIt=peerMap_.begin(); peerIt!=peerMap_.end(); ++peerIt )
-    {
-      if( !peerIt->second.isSynched )
+    for( const auto& mapEntry : peerMap_ )
+    {
+      if( !mapEntry.second.isSynched )
       {
         orxout(verbose_more, context::network) << "Server: not sending gamestate" << endl;
         continue;
       }
-      orxout(verbose_more, context::network) << "client id: " << peerIt->first << endl;
+      orxout(verbose_more, context::network) << "client id: " << mapEntry.first << endl;
       orxout(verbose_more, context::network) << "Server: doing gamestate gamestate preparation" << endl;
-      int peerID = peerIt->first; //get client id
-
-      unsigned int lastAckedGamestateID = peerIt->second.lastAckedGamestateID;
-
-      packet::Gamestate* baseGamestate=0;
+      int peerID = mapEntry.first; //get client id
+
+      unsigned int lastAckedGamestateID = mapEntry.second.lastAckedGamestateID;
+
+      packet::Gamestate* baseGamestate=nullptr;
       if(lastAckedGamestateID != GAMESTATEID_INITIAL)
       {
@@ -200,7 +196,7 @@
       }
 
-      peerGamestates.push_back(0);  // insert an empty gamestate* to be changed
+      peerGamestates.push_back(nullptr);  // insert an empty gamestate* to be changed
       finishGamestate( peerID, peerGamestates.back(), baseGamestate, currentGamestate_ );
-      if( peerGamestates.back()==0 )
+      if( peerGamestates.back()==nullptr )
         // nothing to send to remove pointer from vector
         peerGamestates.pop_back();
@@ -243,5 +239,5 @@
       {
         delete diffed1;
-        destgamestate = 0;
+        destgamestate = nullptr;
         return;
       }
@@ -340,8 +336,7 @@
   {
     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;
+    for( const auto& mapEntry : peerMap_[peerID].gamestates )
+    {
+      delete mapEntry.second;
     }
     peerMap_.erase(peerMap_.find(peerID));
@@ -351,5 +346,5 @@
 //   void GamestateManager::removeClient(ClientInformation* client){
 //     assert(client);
-//     std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(client->getID());
+//     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;
Index: code/trunk/src/libraries/network/GamestateManager.h
===================================================================
--- code/trunk/src/libraries/network/GamestateManager.h	(revision 11052)
+++ code/trunk/src/libraries/network/GamestateManager.h	(revision 11071)
@@ -47,5 +47,4 @@
 #include "core/CorePrereqs.h"
 #include "packet/Gamestate.h"
-#include <boost/concept_check.hpp>
 
 namespace orxonox
@@ -84,8 +83,8 @@
     ~GamestateManager();
 
-    virtual bool      addGamestate(packet::Gamestate *gs, unsigned int peerID);
-    virtual bool      ackGamestate(unsigned int gamestateID, unsigned int peerID);
-    virtual uint32_t  getLastReceivedGamestateID( unsigned int peerID );
-    virtual uint32_t  getCurrentGamestateID(){ if( currentGamestate_) return currentGamestate_->getID(); else return GAMESTATEID_INITIAL; }
+    virtual bool      addGamestate(packet::Gamestate *gs, unsigned int peerID) override;
+    virtual bool      ackGamestate(unsigned int gamestateID, unsigned int peerID) override;
+    virtual uint32_t  getLastReceivedGamestateID( unsigned int peerID ) override;
+    virtual uint32_t  getCurrentGamestateID() override{ if( currentGamestate_) return currentGamestate_->getID(); else return GAMESTATEID_INITIAL; }
 
     bool processGamestates();
@@ -108,5 +107,5 @@
     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;
 //     std::map<unsigned int, uint32_t> lastProcessedGamestateID_;
Index: code/trunk/src/libraries/network/Host.cc
===================================================================
--- code/trunk/src/libraries/network/Host.cc	(revision 11052)
+++ code/trunk/src/libraries/network/Host.cc	(revision 11071)
@@ -44,5 +44,5 @@
   SetConsoleCommand(__CC_printRTT_group, __CC_printRTT_name, &Host::printRTT);
 
-  // Host*               Host::instance_=0;
+  // Host*               Host::instance_=nullptr;
   uint32_t            Host::clientID_s=0;
 //   uint32_t            Host::shipID_s=-1;
@@ -54,5 +54,5 @@
   Host::Host()
   {
-  //   assert(instance_==0);
+  //   assert(instance_==nullptr);
     instances_s.push_back(this);
     ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(this);
@@ -62,5 +62,5 @@
 
   /**
-  * @brief Destructor: resets the instance pointer to 0
+  * @brief Destructor: resets the instance pointer to nullptr
   */
   Host::~Host()
@@ -68,5 +68,5 @@
     assert( std::find( instances_s.begin(), instances_s.end(), this )!=instances_s.end() );
     instances_s.erase(std::find( instances_s.begin(), instances_s.end(), this ));
-    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(0);
+    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(nullptr);
   }
 
@@ -80,9 +80,9 @@
   void Host::addPacket(ENetPacket *packet, int clientID, uint8_t channelID)
   {
-    for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
+    for(Host* host : instances_s)
     {
-      if( (*it)->isActive() )
+      if( host->isActive() )
       {
-        (*it)->queuePacket(packet, clientID, channelID);
+        host->queuePacket(packet, clientID, channelID);
       }
     }
@@ -97,7 +97,7 @@
   void Host::sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
   {
-    for( std::vector<Host*>::iterator it = instances_s.begin(); it!=instances_s.end(); ++it )
-      if( (*it)->isActive() )
-        (*it)->doSendChat(message, sourceID, targetID);
+    for(Host* host : instances_s)
+      if( host->isActive() )
+        host->doSendChat(message, sourceID, targetID);
   }
 
@@ -107,6 +107,6 @@
   void Host::doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
   {
-    for (ObjectList<NetworkChatListener>::iterator it = ObjectList<NetworkChatListener>::begin(); it != ObjectList<NetworkChatListener>::end(); ++it)
-      it->incomingChat(message, sourceID);
+    for (NetworkChatListener* listener : ObjectList<NetworkChatListener>())
+      listener->incomingChat(message, sourceID);
   }
 
@@ -114,9 +114,9 @@
   bool Host::isServer()
   {
-    for (std::vector<Host*>::iterator it=instances_s.begin(); it!=instances_s.end(); ++it )
+    for (Host* host : instances_s)
     {
-      if( (*it)->isActive() )
+      if( host->isActive() )
       {
-        if( (*it)->isServer_() )
+        if( host->isServer_() )
           return true;
       }
@@ -135,5 +135,5 @@
         ++it;
     }
-    return 0;
+    return nullptr;
   }
 
Index: code/trunk/src/libraries/network/LANDiscoverable.cc
===================================================================
--- code/trunk/src/libraries/network/LANDiscoverable.cc	(revision 11052)
+++ code/trunk/src/libraries/network/LANDiscoverable.cc	(revision 11071)
@@ -46,5 +46,5 @@
   RegisterClassNoArgs(LANDiscoverable);
 
-  LANDiscoverable::LANDiscoverable() : bActive_(false), host_(0)
+  LANDiscoverable::LANDiscoverable() : bActive_(false), host_(nullptr)
   {
     /* register object in orxonox */
@@ -82,13 +82,13 @@
       bindAddress.host = ENET_HOST_ANY;
       bindAddress.port = LAN_DISCOVERY_PORT;
-      assert( this->host_ == 0 );
+      assert( this->host_ == nullptr );
       this->host_ = enet_host_create( &bindAddress, 10, 0, 0, 0 );
-      if ( this->host_ == NULL )
-          orxout(internal_error, context::network) << "LANDiscoverable: host_ == NULL" << endl;
+      if ( this->host_ == nullptr )
+          orxout(internal_error, context::network) << "LANDiscoverable: host_ == nullptr" << endl;
     }
     else
     {
       enet_host_destroy( this->host_ );
-      this->host_ = 0;
+      this->host_ = nullptr;
     }
       this->bActive_ = bActive;
Index: code/trunk/src/libraries/network/LANDiscovery.cc
===================================================================
--- code/trunk/src/libraries/network/LANDiscovery.cc	(revision 11052)
+++ code/trunk/src/libraries/network/LANDiscovery.cc	(revision 11071)
@@ -42,12 +42,12 @@
   LANDiscovery::LANDiscovery()
   {
-    this->host_ = enet_host_create(NULL, 10, 0, 0, 0 );
-    if ( this->host_ == NULL )
-        orxout(internal_error, context::network) << "LANDiscovery: host_ == NULL" << endl;
+    this->host_ = enet_host_create(nullptr, 10, 0, 0, 0 );
+    if ( this->host_ == nullptr )
+        orxout(internal_error, context::network) << "LANDiscovery: host_ == nullptr" << endl;
   }
 
   LANDiscovery::~LANDiscovery()
   {
-    if (this->host_ != NULL)
+    if (this->host_ != nullptr)
       enet_host_destroy(this->host_);
   }
@@ -65,5 +65,5 @@
     address.host = ENET_HOST_BROADCAST;
     peer = enet_host_connect(this->host_, &address, 0, 0);
-    if (peer == NULL)
+    if (peer == nullptr)
         orxout(internal_error, context::network) << "Could not send LAN discovery to IPv4 Broadcast." << endl;
 
@@ -71,5 +71,5 @@
     enet_address_set_host(&address, "ff02::1"); // TODO: use a multicast group
     peer = enet_host_connect(this->host_, &address, 0, 0);
-    if (peer == NULL)
+    if (peer == nullptr)
         orxout(internal_error, context::network) << "Could not send LAN discovery to IPv6 Multicast." << endl;
 
Index: code/trunk/src/libraries/network/MasterServer.cc
===================================================================
--- code/trunk/src/libraries/network/MasterServer.cc	(revision 11052)
+++ code/trunk/src/libraries/network/MasterServer.cc	(revision 11071)
@@ -43,5 +43,5 @@
 
   /* forward declaration so the linker doesn't complain */
-  MasterServer *MasterServer::instance = NULL;
+  MasterServer *MasterServer::instance = nullptr;
 
   /* command: list servers */
@@ -49,15 +49,11 @@
   MasterServer::listServers( void )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     /* print list header */
     orxout(user_info) << "List of connected servers" << std::endl;
 
     /* loop through list elements */
-    for( i = MasterServer::getInstance()->mainlist.serverlist.begin();
-      i != MasterServer::getInstance()->mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : MasterServer::getInstance()->mainlist.serverlist )
     {
-      orxout(user_info) << "  " << (*i).ServerInfo.getServerIP() << std::endl;
+      orxout(user_info) << "  " << elem.ServerInfo.getServerIP() << std::endl;
     }
 
@@ -112,17 +108,13 @@
   MasterServer::helper_sendlist( ENetEvent *event )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     /* packet holder */
     ENetPacket *reply;
 
     /* loop through list elements */
-    for( i = mainlist.serverlist.begin(); i
-        != mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : mainlist.serverlist )
     {
       /* send this particular server */
       /* build reply string */
-      int packetlen = MSPROTO_SERVERLIST_ITEM_LEN + 1 + (*i).ServerInfo.getServerIP().length() + 1 + (*i).ServerInfo.getServerName().length() + 1 + sizeof((*i).ServerInfo.getClientNumber()) + 1;
+      int packetlen = MSPROTO_SERVERLIST_ITEM_LEN + 1 + elem.ServerInfo.getServerIP().length() + 1 + elem.ServerInfo.getServerName().length() + 1 + sizeof(elem.ServerInfo.getClientNumber()) + 1;
       char *tosend = (char *)calloc(packetlen ,1 );
       if( !tosend )
@@ -131,5 +123,5 @@
       }
       sprintf( tosend, "%s %s %s %u", MSPROTO_SERVERLIST_ITEM,
-          (*i).ServerInfo.getServerIP().c_str(), (*i).ServerInfo.getServerName().c_str(), (*i).ServerInfo.getClientNumber());
+          elem.ServerInfo.getServerIP().c_str(), elem.ServerInfo.getServerName().c_str(), elem.ServerInfo.getClientNumber());
 
       /* create packet from it */
@@ -167,21 +159,17 @@
   MasterServer::helper_cleanupServers( void )
   {
-    /* get an iterator */
-    std::list<ServerListElem>::iterator i;
-
     if( mainlist.serverlist.size() == 0 )
       return;
 
     /* loop through list elements */
-    for( i = mainlist.serverlist.begin(); i
-        != mainlist.serverlist.end(); ++i )
+    for( const ServerListElem& elem : mainlist.serverlist )
     { /* see if we have a disconnected peer */
-      if( (*i).peer &&
-         ((*i).peer->state == ENET_PEER_STATE_DISCONNECTED ||
-          (*i).peer->state == ENET_PEER_STATE_ZOMBIE ))
+      if( elem.peer &&
+         (elem.peer->state == ENET_PEER_STATE_DISCONNECTED ||
+          elem.peer->state == ENET_PEER_STATE_ZOMBIE ))
       {
         /* Remove it from the list */
-        orxout(internal_warning) << (char*)(*i).peer->data << " timed out.\n";
-        mainlist.delServerByName( (*i).ServerInfo.getServerName() );
+        orxout(internal_warning) << (char*)elem.peer->data << " timed out.\n";
+        mainlist.delServerByName( elem.ServerInfo.getServerName() );
 
         /* stop iterating, we manipulated the list */
@@ -345,5 +333,5 @@
     /***** ENTER MAIN LOOP *****/
     ENetEvent *event = (ENetEvent *)calloc(sizeof(ENetEvent), sizeof(char));
-    if( event == NULL )
+    if( event == nullptr )
     {
       orxout(user_error, context::master_server) << "Could not create ENetEvent structure, exiting." << endl;
Index: code/trunk/src/libraries/network/MasterServerComm.cc
===================================================================
--- code/trunk/src/libraries/network/MasterServerComm.cc	(revision 11052)
+++ code/trunk/src/libraries/network/MasterServerComm.cc	(revision 11071)
@@ -54,5 +54,5 @@
 
     /* initiate the client */
-    this->client = enet_host_create( NULL /* create a client host */,
+    this->client = enet_host_create( nullptr /* create a client host */,
         1,
         2, /* allow up 2 channels to be used, 0 and 1 */
@@ -61,5 +61,5 @@
 
     /* see if it worked */
-    if (this->client == NULL)
+    if (this->client == nullptr)
     { orxout(internal_error, context::master_server) << "An error occurred while trying to create an " 
         << "ENet client host." << endl;
@@ -85,5 +85,5 @@
     this->peer = enet_host_connect(this->client, &this->address, 2, 0);    
 
-    if( this->peer == NULL )
+    if( this->peer == nullptr )
     { orxout(internal_error, context::master_server) << "No available peers for initiating an ENet"
         << " connection." << endl;
@@ -157,5 +157,5 @@
 
     /* address buffer */
-    char *addrconv = NULL;
+    char *addrconv = nullptr;
     int retval = 0;
 
@@ -193,5 +193,5 @@
 
           /* call the supplied callback, if any. */
-          if( listener != NULL )
+          if( listener != nullptr )
             retval = listener->rhandler( addrconv, &(this->event) );
 
Index: code/trunk/src/libraries/network/NetworkFunction.h
===================================================================
--- code/trunk/src/libraries/network/NetworkFunction.h	(revision 11052)
+++ code/trunk/src/libraries/network/NetworkFunction.h	(revision 11071)
@@ -45,9 +45,9 @@
 
 #if defined(ORXONOX_COMPILER_GCC) && defined(ORXONOX_ARCH_32)
-static const unsigned int MAX_FUNCTION_POINTER_SIZE = 8;
+static constexpr unsigned int MAX_FUNCTION_POINTER_SIZE = 8;
 #else
-static const unsigned int MAX_FUNCTION_POINTER_SIZE = 16;
+static constexpr unsigned int MAX_FUNCTION_POINTER_SIZE = 16;
 #endif //ORXONOX_COMPILER_GCC
-static const unsigned int MAX_FUNCTION_POINTER_INTS = (MAX_FUNCTION_POINTER_SIZE-1)/4+1;
+static constexpr unsigned int MAX_FUNCTION_POINTER_INTS = (MAX_FUNCTION_POINTER_SIZE-1)/4+1;
 
 struct _NetworkExport NetworkFunctionPointer {
@@ -114,10 +114,10 @@
 
     // ignore the objectID because its a static function
-    virtual bool call(uint32_t objectID){ (*this->functor_)(); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1){ (*this->functor_)(mt1); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2){ (*this->functor_)(mt1, mt2); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3){ (*this->functor_)(mt1, mt2, mt3); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4){ (*this->functor_)(mt1, mt2, mt3, mt4); return true; }
-    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5){ (*this->functor_)(mt1, mt2, mt3, mt4, mt5); return true; }
+    virtual bool call(uint32_t objectID) override{ (*this->functor_)(); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1) override{ (*this->functor_)(mt1); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2) override{ (*this->functor_)(mt1, mt2); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3) override{ (*this->functor_)(mt1, mt2, mt3); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4) override{ (*this->functor_)(mt1, mt2, mt3, mt4); return true; }
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5) override{ (*this->functor_)(mt1, mt2, mt3, mt4, mt5); return true; }
 
   private:
@@ -142,7 +142,7 @@
     { }
 
-    inline bool call(uint32_t objectID)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)));
@@ -152,7 +152,7 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1);
@@ -162,7 +162,7 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2);
@@ -172,7 +172,7 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3);
@@ -182,7 +182,7 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4);
@@ -192,7 +192,7 @@
         return false;
     }
-    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    virtual inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5) override
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
       {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4, mt5);
Index: code/trunk/src/libraries/network/NetworkFunctionIncludes.h
===================================================================
--- code/trunk/src/libraries/network/NetworkFunctionIncludes.h	(revision 11052)
+++ code/trunk/src/libraries/network/NetworkFunctionIncludes.h	(revision 11071)
@@ -33,5 +33,4 @@
 
 #include <boost/preprocessor/cat.hpp>
-#include <boost/static_assert.hpp>
 
 #include "NetworkFunction.h"
@@ -57,6 +56,6 @@
             ~StaticallyInitializedNetworkFunction() { delete function_; }
 
-            virtual void load();
-            virtual void unload();
+            virtual void load() override;
+            virtual void unload() override;
 
             inline NetworkFunctionBase& getFunction()
@@ -72,5 +71,5 @@
     inline NetworkFunctionBase* registerStaticNetworkFunctionFct(PT ptr, const std::string& name)
     {
-        BOOST_STATIC_ASSERT(sizeof(PT) <= sizeof(NetworkFunctionPointer)); // if this fails your compiler uses bigger pointers for static functions than defined above
+        static_assert(sizeof(PT) <= sizeof(NetworkFunctionPointer), "check pointer size"); // if this fails your compiler uses bigger pointers for static functions than defined above
         NetworkFunctionPointer destptr;
         copyPtr(ptr, destptr);
@@ -81,5 +80,5 @@
     inline NetworkFunctionBase* registerMemberNetworkFunctionFct(PT ptr, const std::string& name)
     {
-        BOOST_STATIC_ASSERT(sizeof(PT) <= sizeof(NetworkFunctionPointer)); // if this fails your compiler uses bigger pointers for a specific kind of member functions than defined above
+        static_assert(sizeof(PT) <= sizeof(NetworkFunctionPointer), "check pointer size"); // if this fails your compiler uses bigger pointers for a specific kind of member functions than defined above
         NetworkFunctionPointer destptr;
         copyPtr(ptr, destptr);
Index: code/trunk/src/libraries/network/NetworkFunctionManager.cc
===================================================================
--- code/trunk/src/libraries/network/NetworkFunctionManager.cc	(revision 11052)
+++ code/trunk/src/libraries/network/NetworkFunctionManager.cc	(revision 11071)
@@ -32,5 +32,5 @@
 namespace orxonox
 {
-    NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = 0;
+    NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = nullptr;
 
     void NetworkFunctionManager::registerFunction(NetworkFunctionBase* function)
@@ -71,5 +71,5 @@
             return it->second;
         else
-            return NULL;
+            return nullptr;
     }
 
Index: code/trunk/src/libraries/network/NetworkPrereqs.h
===================================================================
--- code/trunk/src/libraries/network/NetworkPrereqs.h	(revision 11052)
+++ code/trunk/src/libraries/network/NetworkPrereqs.h	(revision 11071)
@@ -67,14 +67,14 @@
 namespace orxonox
 {
-  static const unsigned int GAMESTATEID_INITIAL       = static_cast<unsigned int>(-1);
+  static constexpr unsigned int GAMESTATEID_INITIAL       = static_cast<unsigned int>(-1);
   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;
-  static const unsigned int NETWORK_CHANNEL_COUNT       = 2;
+  static constexpr unsigned int LAN_DISCOVERY_PORT          = 55558;
+  static constexpr unsigned int NETWORK_PEER_ID_SERVER      = 0;
+  static constexpr unsigned int NETWORK_PEER_ID_BROADCAST   = static_cast<unsigned int>(-1);
+  static constexpr unsigned int NETWORK_PEER_ID_UNKNOWN     = static_cast<unsigned int>(-2);
+  static constexpr unsigned int NETWORK_CHANNEL_DEFAULT     = 0;
+  static constexpr unsigned int NETWORK_CHANNEL_UNRELIABLE  = 1;
+  static constexpr unsigned int NETWORK_CHANNEL_COUNT       = 2;
 }
 
@@ -89,10 +89,7 @@
     namespace PacketFlag
     {
-      enum Value
-      {
-        Reliable    = 1,
-        Unsequenced = 2,
-        NoAllocate  = 4
-      };
+      static constexpr uint32_t Reliable    = 1;
+      static constexpr uint32_t Unsequenced = 2;
+      static constexpr uint32_t NoAllocate  = 4;
     }
   }
@@ -101,5 +98,5 @@
   {
     typedef int Type;
-    static const Type NETWORK_FUNCTION = 6;
+    static constexpr Type NETWORK_FUNCTION = 6;
   }
 }
Index: code/trunk/src/libraries/network/NetworkStaticInitializationHandler.h
===================================================================
--- code/trunk/src/libraries/network/NetworkStaticInitializationHandler.h	(revision 11052)
+++ code/trunk/src/libraries/network/NetworkStaticInitializationHandler.h	(revision 11071)
@@ -39,9 +39,9 @@
     {
         public:
-            virtual void setupHandler();
-            virtual void shutdownHandler();
+            virtual void setupHandler() override;
+            virtual void shutdownHandler() override;
 
-            virtual void loadModule(ModuleInstance* module);
-            virtual void unloadModule(ModuleInstance* module);
+            virtual void loadModule(ModuleInstance* module) override;
+            virtual void unloadModule(ModuleInstance* module) override;
     };
 }
Index: code/trunk/src/libraries/network/PeerList.cc
===================================================================
--- code/trunk/src/libraries/network/PeerList.cc	(revision 11052)
+++ code/trunk/src/libraries/network/PeerList.cc	(revision 11071)
@@ -41,5 +41,5 @@
   PeerList::addPeer( ENetPeer *toadd )
   { /* error correction */
-    if( toadd == NULL )
+    if( toadd == nullptr )
     { orxout(internal_error, context::master_server) << "PeerList::addPeer: empty peer given." << endl;
       return -1;
@@ -65,12 +65,10 @@
   bool
   PeerList::remPeerByAddr( ENetAddress addr )
-  { /* get an iterator */
-    std::list<ENetPeer *>::iterator i;
-
+  {
     /* loop through list elements */
-    for( i = peerlist.begin(); i != peerlist.end(); ++i )
-      if( !sub_compAddr((*i)->address, addr ) )
+    for( ENetPeer* peer : peerlist )
+      if( !sub_compAddr(peer->address, addr ) )
       { /* found this name, remove and quit */
-        this->peerlist.remove( *i );
+        this->peerlist.remove( peer );
         return true;
       }
@@ -82,15 +80,13 @@
   ENetPeer *
   PeerList::findPeerByAddr( ENetAddress addr )
-  { /* get an iterator */
-    std::list<ENetPeer *>::iterator i;
-
+  {
     /* loop through list elements */
-    for( i = peerlist.begin(); i != peerlist.end(); ++i )
-      if( !sub_compAddr((*i)->address, addr ) )
+    for( ENetPeer* peer : peerlist )
+      if( !sub_compAddr(peer->address, addr ) )
         /* found this name, remove and quit */
-        return *i;
+        return peer;
 
     /* not found */
-    return NULL;
+    return nullptr;
   }
 
Index: code/trunk/src/libraries/network/Server.cc
===================================================================
--- code/trunk/src/libraries/network/Server.cc	(revision 11052)
+++ code/trunk/src/libraries/network/Server.cc	(revision 11071)
@@ -194,5 +194,5 @@
   void Server::printRTT()
   {
-//     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=0; temp=temp->next() )
+//     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=nullptr; temp=temp->next() )
 //       orxout(message) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
   }
@@ -232,8 +232,7 @@
   {
     std::vector<packet::Gamestate*> gamestates = GamestateManager::getGamestates();
-    std::vector<packet::Gamestate*>::iterator it;
-    for( it = gamestates.begin(); it != gamestates.end(); ++it )
+    for( packet::Gamestate* gamestate : gamestates )
     {
-      (*it)->send(static_cast<Host*>(this));
+      gamestate->send(static_cast<Host*>(this));
     }
     return true;
@@ -244,5 +243,5 @@
   {
 //     ClientInformation *temp = ClientInformation::getBegin();
-//     if( temp == NULL )
+//     if( temp == nullptr )
       //no client connected
     if( this->clientIDs_.size()==0 )
@@ -255,5 +254,5 @@
     }
 //     orxout(verbose, context::network) << "sending DeleteObjects" << endl;
-//     while(temp != NULL){
+//     while(temp != nullptr){
 //       if( !(temp->getSynched()) )
 //       {
@@ -434,7 +433,6 @@
       return true;
 
-    std::vector<uint32_t>::iterator it;
-    for( it=this->clientIDs_.begin(); it!=this->clientIDs_.end(); ++it )
-      if( *it == targetID )
+    for( uint32_t id : this->clientIDs_ )
+      if( id == targetID )
         return true;
 
Index: code/trunk/src/libraries/network/Server.h
===================================================================
--- code/trunk/src/libraries/network/Server.h	(revision 11052)
+++ code/trunk/src/libraries/network/Server.h	(revision 11071)
@@ -61,9 +61,9 @@
     void open();
     void close();
-    void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID);
-    virtual bool sendPacket( packet::Packet* packet ){ return packet->send( static_cast<Host*>(this) ); }
+    virtual void queuePacket(ENetPacket *packet, int clientID, uint8_t channelID) override;
+    virtual bool sendPacket( packet::Packet* packet ) override{ return packet->send( static_cast<Host*>(this) ); }
     void update(const Clock& time);
     unsigned int getRTT(unsigned int clientID);
-    virtual void printRTT();
+    virtual void printRTT() override;
     float getPacketLoss(unsigned int clientID);
     int getClientCount() { return this->clientIDs_.size();}
@@ -73,10 +73,10 @@
     void updateGamestate();
   private:
-    virtual bool isServer_(){return true;}
+    virtual bool isServer_() override{return true;}
     unsigned int playerID(){return 0;}
 
-    void addPeer(uint32_t peerID);
-    void removePeer(uint32_t peerID);
-    void processPacket(packet::Packet* packet);
+    virtual void addPeer(uint32_t peerID) override;
+    virtual void removePeer(uint32_t peerID) override;
+    virtual void processPacket(packet::Packet* packet) override;
 
     bool createClient(int clientID);
@@ -85,6 +85,6 @@
     bool sendObjectDeletes();
     bool isValidTarget(unsigned int targetID);
-    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
-    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID);
+    virtual void doSendChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
+    virtual void doReceiveChat(const std::string& message, unsigned int sourceID, unsigned int targetID) override;
     void syncClassid(unsigned int clientID);
 
Index: code/trunk/src/libraries/network/ServerConnection.cc
===================================================================
--- code/trunk/src/libraries/network/ServerConnection.cc	(revision 11052)
+++ code/trunk/src/libraries/network/ServerConnection.cc	(revision 11071)
@@ -73,7 +73,7 @@
     this->host_ = enet_host_create(this->bindAddress_, NETWORK_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
     
-    if ( this->host_ == NULL )
+    if ( this->host_ == nullptr )
     {
-        orxout(internal_error, context::network) << "ServerConnection: host_ == NULL" << endl;
+        orxout(internal_error, context::network) << "ServerConnection: host_ == nullptr" << endl;
         return false;
     }
Index: code/trunk/src/libraries/network/TrafficControl.cc
===================================================================
--- code/trunk/src/libraries/network/TrafficControl.cc	(revision 11052)
+++ code/trunk/src/libraries/network/TrafficControl.cc	(revision 11071)
@@ -30,5 +30,5 @@
 
 #include <cassert>
-#include <boost/bind.hpp>
+#include <functional>
 
 #include "core/CoreIncludes.h"
@@ -38,5 +38,6 @@
 namespace orxonox {
 
-  static const unsigned int SCHED_PRIORITY_OFFSET = static_cast<unsigned int>(-1);
+  static constexpr unsigned int SCHED_PRIORITY_OFFSET = static_cast<unsigned int>(-1);
+  namespace arg = std::placeholders;
 
   objInfo::objInfo(uint32_t ID, uint32_t creatorID, int32_t curGsID, int32_t diffGsID, uint32_t size, unsigned int prioperm, unsigned int priosched)
@@ -64,5 +65,5 @@
 *Initializing protected members
 */
-    TrafficControl *TrafficControl::instance_=0;
+    TrafficControl *TrafficControl::instance_=nullptr;
 
     /**
@@ -72,5 +73,5 @@
     {
     RegisterObject(TrafficControl);
-      assert(instance_==0);
+      assert(instance_==nullptr);
       instance_=this;
     this->setConfigValues();
@@ -78,9 +79,9 @@
 
     /**
-    * @brief Destructor: resets the instance pointer to 0
+    * @brief Destructor: resets the instance pointer to nullptr
     */
     TrafficControl::~TrafficControl()
     {
-      instance_=0;
+      instance_=nullptr;
     }
 
@@ -148,5 +149,5 @@
     // shortcut for maps
     std::map<unsigned int, objInfo >& objectListPerm = clientListPerm_[clientID];
-    std::map<unsigned int, std::list<obj> >& objectListTemp = clientListTemp_[clientID];
+    std::map<unsigned int, std::list<obj>>& objectListTemp = clientListTemp_[clientID];
 
     for(itvec = objectListTemp[gamestateID].begin(); itvec != objectListTemp[gamestateID].end(); itvec++)
@@ -180,5 +181,5 @@
     void TrafficControl::insertinClientListPerm(unsigned int clientID, obj objinf)
     {
-      std::map<unsigned int,std::map<unsigned int, objInfo> >::iterator itperm;//iterator clientListPerm over clientIDs
+      std::map<unsigned int,std::map<unsigned int, objInfo>>::iterator itperm;//iterator clientListPerm over clientIDs
     unsigned int gsid=GAMESTATEID_INITIAL, gsdiff=currentGamestateID, prioperm=Synchronisable::getSynchronisable(objinf.objID)->getPriority(), priomom=0;
     clientListPerm_[clientID][objinf.objID] = objInfo(objinf.objID, objinf.objCreatorID,gsid,gsdiff, objinf.objSize,prioperm,priomom);
@@ -258,9 +259,9 @@
 
       //sort copied list according to priorities
-      // use boost bind here because we need to pass a memberfunction to stl sort
-//       sort( list.begin(), list.end(), boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
-      list.sort( boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
-
-//       list.sort(boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
+      // use std::bind here because we need to pass a memberfunction to stl sort
+//       sort( list.begin(), list.end(), std::bind(&TrafficControl::prioritySort, this, clientID, arg::_1, arg::_2) );
+      list.sort( std::bind(&TrafficControl::prioritySort, this, clientID, arg::_1, arg::_2) );
+
+//       list.sort(std::bind(&TrafficControl::prioritySort, this, clientID, arg::_1, arg::_2) );
 
       //now we check, that the creator of an object always exists on a client
@@ -275,6 +276,6 @@
       cut(list, targetSize);
       //now sort again after objDataOffset
-//       sort(list.begin(), list.end(), boost::bind(&TrafficControl::dataSort, this, _1, _2) );
-      list.sort( boost::bind(&TrafficControl::dataSort, this, _1, _2) );
+//       sort(list.begin(), list.end(), std::bind(&TrafficControl::dataSort, this, arg::_1, arg::_2) );
+      list.sort( std::bind(&TrafficControl::dataSort, this, arg::_1, arg::_2) );
 
       //diese Funktion updateClientList muss noch gemacht werden
Index: code/trunk/src/libraries/network/TrafficControl.h
===================================================================
--- code/trunk/src/libraries/network/TrafficControl.h	(revision 11052)
+++ code/trunk/src/libraries/network/TrafficControl.h	(revision 11071)
@@ -82,5 +82,5 @@
     *permanent client list: contains client ids, object ids and objectInfos (in this order)
     */
-    std::map<unsigned int, std::map<unsigned int, objInfo > > clientListPerm_;
+    std::map<unsigned int, std::map<unsigned int, objInfo >> clientListPerm_;
     //has to be created with constructor and then needs to be updated by evaluateList().
 
@@ -88,5 +88,5 @@
     *temporary client list: contains client ids, gamestate ids and object ids (in this order)
     */
-    std::map<unsigned int, std::map<unsigned int, std::list<obj> > > clientListTemp_;
+    std::map<unsigned int, std::map<unsigned int, std::list<obj>>> clientListTemp_;
 
     /**updateReferenceList
@@ -109,6 +109,6 @@
 
     //ClientConnectionListener functions
-    virtual void clientConnected(unsigned int clientID){};
-    virtual void clientDisconnected(unsigned int clientID);
+    virtual void clientConnected(unsigned int clientID) override{};
+    virtual void clientDisconnected(unsigned int clientID) override;
 
 
Index: code/trunk/src/libraries/network/packet/Acknowledgement.cc
===================================================================
--- code/trunk/src/libraries/network/packet/Acknowledgement.cc	(revision 11052)
+++ code/trunk/src/libraries/network/packet/Acknowledgement.cc	(revision 11071)
@@ -38,5 +38,5 @@
 #define PACKET_FLAGS_ACK    0
 #define _PACKETID           0
-#define _ACKID              _PACKETID + sizeof(packet::Type::Value)
+#define _ACKID              _PACKETID + sizeof(packet::Type)
 
 Acknowledgement::Acknowledgement( unsigned int id, unsigned int peerID )
@@ -45,5 +45,5 @@
   flags_ = flags_ | PACKET_FLAGS_ACK;
   data_=new uint8_t[ getSize() ];
-  *(Type::Value *)(data_ + _PACKETID ) = Type::Acknowledgement;
+  *(Type *)(data_ + _PACKETID ) = Type::Acknowledgement;
   *(uint32_t *)(data_ + _ACKID ) = id;
   peerID_=peerID;
Index: code/trunk/src/libraries/network/packet/Acknowledgement.h
===================================================================
--- code/trunk/src/libraries/network/packet/Acknowledgement.h	(revision 11052)
+++ code/trunk/src/libraries/network/packet/Acknowledgement.h	(revision 11071)
@@ -46,6 +46,6 @@
   ~Acknowledgement();
 
-  inline unsigned int getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual inline unsigned int getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
   unsigned int getAckID();
Index: code/trunk/src/libraries/network/packet/Chat.cc
===================================================================
--- code/trunk/src/libraries/network/packet/Chat.cc	(revision 11052)
+++ code/trunk/src/libraries/network/packet/Chat.cc	(revision 11071)
@@ -40,5 +40,5 @@
 /* Some lengths */
 #define _PACKETID         0
-#define _SOURCEID         _PACKETID + sizeof(Type::Value)
+#define _SOURCEID         _PACKETID + sizeof(Type)
 #define _TARGETID         _SOURCEID + sizeof(uint32_t)
 #define _MESSAGELENGTH    _TARGETID + sizeof(uint32_t)
@@ -57,5 +57,5 @@
   data_=new unsigned char[ getSize() ];
 
-  *(Type::Value *)(data_ + _PACKETID ) = Type::Chat;
+  *(Type *)(data_ + _PACKETID ) = Type::Chat;
   *(unsigned int *)(data_ + _SOURCEID ) = sourceID;
   *(unsigned int *)(data_ + _TARGETID ) = targetID;
Index: code/trunk/src/libraries/network/packet/Chat.h
===================================================================
--- code/trunk/src/libraries/network/packet/Chat.h	(revision 11052)
+++ code/trunk/src/libraries/network/packet/Chat.h	(revision 11071)
@@ -49,8 +49,8 @@
 
   /* get size of packet */
-  inline unsigned int getSize() const;
+  virtual inline unsigned int getSize() const override;
 
   /* process chat message packet and remove it afterwards */
-  virtual bool process(orxonox::Host* host);
+  virtual bool process(orxonox::Host* host) override;
 
   /* Get the length of the message (not the full size of the packet) */
Index: code/trunk/src/libraries/network/packet/ClassID.cc
===================================================================
--- code/trunk/src/libraries/network/packet/ClassID.cc	(revision 11052)
+++ code/trunk/src/libraries/network/packet/ClassID.cc	(revision 11071)
@@ -52,11 +52,10 @@
   uint32_t network_id;
   flags_ = flags_ | PACKET_FLAGS_CLASSID;
-  std::queue<std::pair<uint32_t, std::string> > tempQueue;
+  std::queue<std::pair<uint32_t, std::string>> tempQueue;
 
   //calculate total needed size (for all strings and integers)
-  std::map<std::string, Identifier*>::const_iterator it = IdentifierManager::getInstance().getIdentifierByStringMap().begin();
-  for(;it != IdentifierManager::getInstance().getIdentifierByStringMap().end();++it){
-    id = it->second;
-    if(id == NULL || !id->hasFactory())
+  for(const auto& mapEntry : IdentifierManager::getInstance().getIdentifierByStringMap()){
+    id = mapEntry.second;
+    if(id == nullptr || !id->hasFactory())
       continue;
     const std::string& classname = id->getName();
@@ -71,5 +70,5 @@
   //set the appropriate packet id
   assert(this->data_);
-  *(Type::Value *)(this->data_ + _PACKETID ) = Type::ClassID;
+  *(Type *)(this->data_ + _PACKETID ) = Type::ClassID;
 
   uint8_t *temp=data_+sizeof(uint32_t);
@@ -144,5 +143,5 @@
     id=ClassByString( std::string((const char*)classname) );
     orxout(internal_info, context::packets) << "processing classid: " << networkID << " name: " << classname << " id: " << id << endl;
-    if(id==NULL){
+    if(id==nullptr){
       orxout(user_error, context::packets) << "Received a bad classname" << endl;
       abort();
Index: code/trunk/src/libraries/network/packet/ClassID.h
===================================================================
--- code/trunk/src/libraries/network/packet/ClassID.h	(revision 11052)
+++ code/trunk/src/libraries/network/packet/ClassID.h	(revision 11071)
@@ -47,6 +47,6 @@
   ~ClassID();
 
-  uint32_t getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual uint32_t getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:
Index: code/trunk/src/libraries/network/packet/DeleteObjects.cc
===================================================================
--- code/trunk/src/libraries/network/packet/DeleteObjects.cc	(revision 11052)
+++ code/trunk/src/libraries/network/packet/DeleteObjects.cc	(revision 11071)
@@ -39,5 +39,5 @@
 #define PACKET_FLAG_DELETE  PacketFlag::Reliable
 #define _PACKETID           0
-#define _QUANTITY           _PACKETID + sizeof(Type::Value)
+#define _QUANTITY           _PACKETID + sizeof(Type)
 #define _OBJECTIDS          _QUANTITY + sizeof(uint32_t)
 
@@ -63,9 +63,9 @@
     return false;
   orxout(verbose, context::packets) << "sending DeleteObjects: ";
-  unsigned int size = sizeof(Type::Value) + sizeof(uint32_t)*(number+1);
+  unsigned int size = sizeof(Type) + sizeof(uint32_t)*(number+1);
   data_ = new uint8_t[size];
   uint8_t *tdata = data_;
-  *reinterpret_cast<Type::Value*>(tdata) = Type::DeleteObjects;
-  tdata += sizeof(Type::Value);
+  *reinterpret_cast<Type*>(tdata) = Type::DeleteObjects;
+  tdata += sizeof(Type);
   *(uint32_t *)tdata = number;
   tdata += sizeof(uint32_t);
Index: code/trunk/src/libraries/network/packet/DeleteObjects.h
===================================================================
--- code/trunk/src/libraries/network/packet/DeleteObjects.h	(revision 11052)
+++ code/trunk/src/libraries/network/packet/DeleteObjects.h	(revision 11071)
@@ -48,6 +48,6 @@
   bool fetchIDs();
 
-  inline unsigned int getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual inline unsigned int getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:
Index: code/trunk/src/libraries/network/packet/FunctionCalls.cc
===================================================================
--- code/trunk/src/libraries/network/packet/FunctionCalls.cc	(revision 11052)
+++ code/trunk/src/libraries/network/packet/FunctionCalls.cc	(revision 11071)
@@ -96,5 +96,5 @@
   assert(this->functionCalls_.size());
   data_=new uint8_t[ currentSize_ ];
-  *(Type::Value *)(data_ + _PACKETID ) = Type::FunctionCalls; // Set the Packet ID
+  *(Type *)(data_ + _PACKETID ) = Type::FunctionCalls; // Set the Packet ID
   *(uint32_t*)(data_+sizeof(uint32_t)) = this->functionCalls_.size(); // set nrOfCalls
   *(uint32_t*)(data_+2*sizeof(uint32_t)) = this->minGamestateID_; // set minGamestateID_
Index: code/trunk/src/libraries/network/packet/FunctionCalls.h
===================================================================
--- code/trunk/src/libraries/network/packet/FunctionCalls.h	(revision 11052)
+++ code/trunk/src/libraries/network/packet/FunctionCalls.h	(revision 11071)
@@ -52,10 +52,10 @@
   ~FunctionCalls();
 
-  inline unsigned int getSize() const
+  virtual inline unsigned int getSize() const override
     { assert(!this->isDataENetAllocated()); return currentSize_; }
-  virtual bool process(orxonox::Host* host);
+  virtual bool process(orxonox::Host* host) override;
 
   void addCall( uint32_t networkID, uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5);
-  virtual bool send(orxonox::Host* host);
+  virtual bool send(orxonox::Host* host) override;
 private:
   std::queue<orxonox::FunctionCall> functionCalls_;
Index: code/trunk/src/libraries/network/packet/FunctionIDs.cc
===================================================================
--- code/trunk/src/libraries/network/packet/FunctionIDs.cc	(revision 11052)
+++ code/trunk/src/libraries/network/packet/FunctionIDs.cc	(revision 11071)
@@ -53,5 +53,5 @@
   uint32_t networkID;
   flags_ = flags_ | PACKET_FLAGS_FUNCTIONIDS;
-  std::queue<std::pair<uint32_t, std::string> > tempQueue;
+  std::queue<std::pair<uint32_t, std::string>> tempQueue;
 
   //calculate total needed size (for all strings and integers)
@@ -71,5 +71,5 @@
   //set the appropriate packet id
   assert(this->data_);
-  *(Type::Value *)(this->data_ + _PACKETID ) = Type::FunctionIDs;
+  *(Type *)(this->data_ + _PACKETID ) = Type::FunctionIDs;
 
   uint8_t *temp=data_+sizeof(uint32_t);
Index: code/trunk/src/libraries/network/packet/FunctionIDs.h
===================================================================
--- code/trunk/src/libraries/network/packet/FunctionIDs.h	(revision 11052)
+++ code/trunk/src/libraries/network/packet/FunctionIDs.h	(revision 11071)
@@ -47,6 +47,6 @@
   ~FunctionIDs();
 
-  virtual uint32_t getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual uint32_t getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:
Index: code/trunk/src/libraries/network/packet/Gamestate.cc
===================================================================
--- code/trunk/src/libraries/network/packet/Gamestate.cc	(revision 11052)
+++ code/trunk/src/libraries/network/packet/Gamestate.cc	(revision 11071)
@@ -106,5 +106,5 @@
 {
   uint32_t tempsize=0, currentsize=0;
-  assert(data_==0);
+  assert(data_==nullptr);
   uint32_t size = calcGamestateSize(id, mode);
 
@@ -126,5 +126,5 @@
   mem += GamestateHeader::getSize();
   ObjectList<Synchronisable>::iterator it;
-  for(it = ObjectList<Synchronisable>::begin(); it; ++it)
+  for(it = ObjectList<Synchronisable>().begin(); it; ++it)
   {
 
@@ -133,5 +133,5 @@
     tempsize = it->getData(mem, this->sizes_, id, mode);
     if ( tempsize != 0 )
-      dataVector_.push_back( obj(it->getObjectID(), it->getContextID(), tempsize, mem-data_) );
+      dataVector_.emplace_back(it->getObjectID(), it->getContextID(), tempsize, mem-data_);
 
 #ifndef NDEBUG
@@ -213,14 +213,13 @@
   {
     std::list<uint32_t> v1;
-    ObjectList<Synchronisable>::iterator it;
-    for (it = ObjectList<Synchronisable>::begin(); it != ObjectList<Synchronisable>::end(); ++it)
-    {
-      if (it->getObjectID() == OBJECTID_UNKNOWN)
-      {
-        if (it->objectMode_ != 0x0)
+    for (Synchronisable* synchronisable : ObjectList<Synchronisable>())
+    {
+      if (synchronisable->getObjectID() == OBJECTID_UNKNOWN)
+      {
+        if (synchronisable->objectMode_ != 0x0)
         {
           orxout(user_error, context::packets) << "Found object with OBJECTID_UNKNOWN on the client with objectMode != 0x0!" << endl;
           orxout(user_error, context::packets) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << endl;
-          orxout(user_error, context::packets) << "Objects class: " << it->getIdentifier()->getName() << endl;
+          orxout(user_error, context::packets) << "Objects class: " << synchronisable->getIdentifier()->getName() << endl;
           assert(false);
         }
@@ -228,8 +227,7 @@
       else
       {
-        std::list<uint32_t>::iterator it2;
-        for (it2 = v1.begin(); it2 != v1.end(); ++it2)
+        for (uint32_t id : v1)
         {
-          if (it->getObjectID() == *it2)
+          if (synchronisable->getObjectID() == id)
           {
             orxout(user_error, context::packets) << "Found duplicate objectIDs on the client!" << endl
@@ -239,5 +237,5 @@
           }
         }
-        v1.push_back(it->getObjectID());
+        v1.push_back(synchronisable->getObjectID());
       }
     }
@@ -608,5 +606,5 @@
 
   if(dest_length==0)
-    return NULL;
+    return nullptr;
 
   uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
@@ -645,5 +643,5 @@
 
   if(dest_length==0)
-    return NULL;
+    return nullptr;
 
   uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
@@ -762,10 +760,8 @@
   uint32_t size = 0;
   uint32_t nrOfVariables = 0;
-    // get the start of the Synchronisable list
-  ObjectList<Synchronisable>::iterator it;
     // get total size of gamestate
-  for(it = ObjectList<Synchronisable>::begin(); it; ++it){
-    size+=it->getSize(id, mode); // size of the actual data of the synchronisable
-    nrOfVariables += it->getNrOfVariables();
+  for(Synchronisable* synchronisable : ObjectList<Synchronisable>()){
+    size+=synchronisable->getSize(id, mode); // size of the actual data of the synchronisable
+    nrOfVariables += synchronisable->getNrOfVariables();
   }
 //   orxout() << "allocating " << nrOfVariables << " ints" << endl;
Index: code/trunk/src/libraries/network/packet/Gamestate.h
===================================================================
--- code/trunk/src/libraries/network/packet/Gamestate.h	(revision 11052)
+++ code/trunk/src/libraries/network/packet/Gamestate.h	(revision 11071)
@@ -48,17 +48,17 @@
 {
     
-static const uint8_t GAMESTATE_MODE_SERVER = 0x1;
-static const uint8_t GAMESTATE_MODE_CLIENT = 0x2;
+static constexpr uint8_t GAMESTATE_MODE_SERVER = 0x1;
+static constexpr uint8_t GAMESTATE_MODE_CLIENT = 0x2;
 
 class _NetworkExport GamestateHeader
 {
   public:
-    GamestateHeader(){ data_=0; }
+    GamestateHeader(){ data_=nullptr; }
     GamestateHeader(uint8_t* data)
-      { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }
+      { assert(data); data_ = data; *(Type*)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; }
+      { assert(data); data_ = data; *(Type*)data_ = Type::Gamestate; }
     static inline uint32_t getSize()
       { return 21; }
@@ -138,6 +138,6 @@
 //     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 bool process(orxonox::Host* host);
+    virtual uint32_t getSize() const override;
+    virtual bool process(orxonox::Host* host) override;
     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 );
Index: code/trunk/src/libraries/network/packet/Packet.cc
===================================================================
--- code/trunk/src/libraries/network/packet/Packet.cc	(revision 11052)
+++ code/trunk/src/libraries/network/packet/Packet.cc	(revision 11071)
@@ -34,5 +34,4 @@
 #define WIN32_LEAN_AND_MEAN
 #include <enet/enet.h>
-#include <boost/static_assert.hpp>
 #include <boost/thread/mutex.hpp>
 
@@ -54,7 +53,7 @@
 
 // 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::Unsequenced) == static_cast<int>(ENET_PACKET_FLAG_UNSEQUENCED));
-BOOST_STATIC_ASSERT(static_cast<int>(PacketFlag::NoAllocate)  == static_cast<int>(ENET_PACKET_FLAG_NO_ALLOCATE));
+static_assert(static_cast<int>(PacketFlag::Reliable)    == static_cast<int>(ENET_PACKET_FLAG_RELIABLE),    "check enum");
+static_assert(static_cast<int>(PacketFlag::Unsequenced) == static_cast<int>(ENET_PACKET_FLAG_UNSEQUENCED), "check enum");
+static_assert(static_cast<int>(PacketFlag::NoAllocate)  == static_cast<int>(ENET_PACKET_FLAG_NO_ALLOCATE), "check enum");
 
 #define PACKET_FLAG_DEFAULT PacketFlag::NoAllocate
@@ -69,6 +68,6 @@
   packetDirection_ = Direction::Outgoing;
   peerID_=0;
-  data_=0;
-  enetPacket_=0;
+  data_=nullptr;
+  enetPacket_=nullptr;
   bDataENetAllocated_ = false;
 }
@@ -80,5 +79,5 @@
   peerID_=peerID;
   data_=data;
-  enetPacket_=0;
+  enetPacket_=nullptr;
   bDataENetAllocated_ = false;
 }
@@ -95,5 +94,5 @@
     memcpy(data_, p.data_, p.getSize());
   }else
-    data_=0;
+    data_=nullptr;
   bDataENetAllocated_ = p.bDataENetAllocated_;
 }
@@ -122,5 +121,5 @@
   // Destroy the ENetPacket if necessary.
   // Note: For the case ENet used the callback to destroy the packet, we have already set
-  // enetPacket_ to NULL to avoid destroying it again.
+  // enetPacket_ to nullptr to avoid destroying it again.
   if (this->enetPacket_)
   {
@@ -158,5 +157,5 @@
   }
 #ifndef NDEBUG
-  switch( *(Type::Value *)(data_ + _PACKETID) )
+  switch( *(Type *)(data_ + _PACKETID) )
   {
     case Type::Acknowledgement:
@@ -175,5 +174,5 @@
 #endif
 //  ENetPacket *temp = enetPacket_;
-//  enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
+//  enetPacket_ = nullptr; // otherwise we have a double free because enet already handles the deallocation of the packet
   if( this->flags_ & PacketFlag::Reliable )
     host->addPacket( enetPacket_, peerID_, NETWORK_CHANNEL_DEFAULT);
@@ -191,7 +190,7 @@
 //   if( peerID==static_cast<unsigned int>(-2))
 //     peerID = NETWORK_PEER_ID_SERVER;
-  Packet *p = 0;
-//   orxout(verbose_ultra, context::packets) << "packet type: " << *(Type::Value *)&data[_PACKETID] << endl;
-  switch( *(Type::Value *)(data + _PACKETID) )
+  Packet *p = nullptr;
+//   orxout(verbose_ultra, context::packets) << "packet type: " << *(Type *)&data[_PACKETID] << endl;
+  switch( *(Type *)(data + _PACKETID) )
   {
     case Type::Acknowledgement:
@@ -251,5 +250,5 @@
   assert(it != packetMap_.end());
   // Make sure we don't delete it again in the destructor
-  it->second->enetPacket_ = 0;
+  it->second->enetPacket_ = nullptr;
   delete it->second;
   packetMap_.erase(it);
Index: code/trunk/src/libraries/network/packet/Packet.h
===================================================================
--- code/trunk/src/libraries/network/packet/Packet.h	(revision 11052)
+++ code/trunk/src/libraries/network/packet/Packet.h	(revision 11071)
@@ -38,27 +38,21 @@
 {
 
-namespace Direction
+enum class Direction
 {
-  enum Value
-  {
-    Incoming,
-    Outgoing,
-    Bidirectional
-  };
-}
-namespace Type
+  Incoming,
+  Outgoing,
+  Bidirectional
+};
+enum class Type : uint8_t
 {
-  enum Value
-  {
-    Acknowledgement,
-    Chat,
-    ClassID,
-    DeleteObjects,
-    FunctionIDs,
-    FunctionCalls,
-    Gamestate,
-    Welcome
-  };
-}
+  Acknowledgement,
+  Chat,
+  ClassID,
+  DeleteObjects,
+  FunctionIDs,
+  FunctionCalls,
+  Gamestate,
+  Welcome
+};
 
 /**
@@ -98,5 +92,5 @@
     unsigned int peerID_;
     uint32_t requiredGamestateID_;
-    Direction::Value packetDirection_;
+    Direction packetDirection_;
     /** Pointer to the data. Be careful when deleting it because it might
         point to a location that was allocated by ENet.
Index: code/trunk/src/libraries/network/packet/ServerInformation.cc
===================================================================
--- code/trunk/src/libraries/network/packet/ServerInformation.cc	(revision 11052)
+++ code/trunk/src/libraries/network/packet/ServerInformation.cc	(revision 11071)
@@ -87,10 +87,11 @@
   } // namespace packet
 
-  std::ostream& operator<<(std::ostream& out, const ENetAddress& address)
-  {
-      char addr[64];
-      if (!enet_address_get_host_ip(&address, addr, 64))
-          out << addr;
-      return out;
-  }
 } // namespace orxonox
+
+std::ostream& operator<<(std::ostream& out, const ENetAddress& address)
+{
+    char addr[64];
+    if (!enet_address_get_host_ip(&address, addr, 64))
+        out << addr;
+    return out;
+}
Index: code/trunk/src/libraries/network/packet/ServerInformation.h
===================================================================
--- code/trunk/src/libraries/network/packet/ServerInformation.h	(revision 11052)
+++ code/trunk/src/libraries/network/packet/ServerInformation.h	(revision 11071)
@@ -50,10 +50,10 @@
         void          send( ENetPeer* peer );
         void          setServerName(std::string name) { this->serverName_ = name; }
-        std::string   getServerName() { return this->serverName_; }
+        std::string   getServerName() const { return this->serverName_; }
         void          setServerIP( std::string IP ) { this->serverIP_ = IP; }
-        std::string   getServerIP() { return this->serverIP_; }
+        std::string   getServerIP() const { return this->serverIP_; }
         void          setClientNumber( int clientNumber ) { this->clientNumber_ = clientNumber; }
-        int           getClientNumber() { return this->clientNumber_; }
-        uint32_t      getServerRTT() { return this->serverRTT_; }
+        int           getClientNumber() const { return this->clientNumber_; }
+        uint32_t      getServerRTT() const { return this->serverRTT_; }
 
       private:
@@ -66,6 +66,7 @@
   }
 
-  _NetworkExport std::ostream& operator<<(std::ostream& out, const ENetAddress& address);
 }
 
+_NetworkExport std::ostream& operator<<(std::ostream& out, const ENetAddress& address);
+
 #endif // SERVERINFORMATION_H
Index: code/trunk/src/libraries/network/packet/Welcome.cc
===================================================================
--- code/trunk/src/libraries/network/packet/Welcome.cc	(revision 11052)
+++ code/trunk/src/libraries/network/packet/Welcome.cc	(revision 11071)
@@ -41,5 +41,5 @@
 #define PACKET_FLAGS_CLASSID  PacketFlag::Reliable
 #define _PACKETID             0
-#define _CLIENTID             _PACKETID + sizeof(Type::Value)
+#define _CLIENTID             _PACKETID + sizeof(Type)
 #define _ENDIANTEST           _CLIENTID + sizeof(uint32_t)
 
@@ -51,5 +51,5 @@
   data_=new uint8_t[ getSize() ];
   assert(data_);
-  *(packet::Type::Value *)(data_ + _PACKETID ) = packet::Type::Welcome;
+  *(packet::Type *)(data_ + _PACKETID ) = packet::Type::Welcome;
   *(uint32_t *)(data_ + _CLIENTID ) = static_cast<uint32_t>(clientID);
   *(uint32_t *)(data_ + _ENDIANTEST ) = 0xFEDC4321;
@@ -70,5 +70,5 @@
 
 unsigned int Welcome::getSize() const{
-  return sizeof(packet::Type::Value) + 2*sizeof(uint32_t);
+  return sizeof(packet::Type) + 2*sizeof(uint32_t);
 }
 
Index: code/trunk/src/libraries/network/packet/Welcome.h
===================================================================
--- code/trunk/src/libraries/network/packet/Welcome.h	(revision 11052)
+++ code/trunk/src/libraries/network/packet/Welcome.h	(revision 11071)
@@ -45,7 +45,7 @@
   virtual ~Welcome();
 
-  uint8_t *getData();
-  inline unsigned int getSize() const;
-  virtual bool process(orxonox::Host* host);
+  virtual uint8_t *getData() override;
+  virtual inline unsigned int getSize() const override;
+  virtual bool process(orxonox::Host* host) override;
 
 private:
Index: code/trunk/src/libraries/network/synchronisable/NetworkCallback.h
===================================================================
--- code/trunk/src/libraries/network/synchronisable/NetworkCallback.h	(revision 11052)
+++ code/trunk/src/libraries/network/synchronisable/NetworkCallback.h	(revision 11071)
@@ -53,5 +53,5 @@
       NetworkCallback(T* object, void (T::*function) (void)) : object_(object), function_(function) {}
       virtual ~NetworkCallback() {}
-      virtual void call()
+      virtual void call() override
         { (this->object_->*function_)(); }
 
@@ -68,5 +68,5 @@
       NetworkCallbackNotify() {}
       virtual ~NetworkCallbackNotify() {}
-      virtual void call()
+      virtual void call() override
         { (this->object_->*function_)( this->oldValue_ ); }
       void setOldValue(const U& value){ this->oldValue_ = value; }
Index: code/trunk/src/libraries/network/synchronisable/Serialise.h
===================================================================
--- code/trunk/src/libraries/network/synchronisable/Serialise.h	(revision 11052)
+++ code/trunk/src/libraries/network/synchronisable/Serialise.h	(revision 11071)
@@ -90,5 +90,5 @@
     {
 //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
-        *const_cast<typename Loki::TypeTraits<StrongPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
+        *const_cast<typename Loki::TypeTraits<StrongPtr<T>>::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
         mem += returnSize( variable );
     }
@@ -125,5 +125,5 @@
     {
         //         *const_cast<typename Loki::TypeTraits<T*>::UnqualifiedType*>(&variable) = dynamic_cast<T*>(variable->getSynchronisable( *(uint32_t*)(mem) ));
-        *const_cast<typename Loki::TypeTraits<WeakPtr<T> >::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
+        *const_cast<typename Loki::TypeTraits<WeakPtr<T>>::UnqualifiedType*>(&variable) = orxonox_cast<T*>(T::getSynchronisable(*(uint32_t*)(mem)));
         mem += returnSize( variable );
     }
Index: code/trunk/src/libraries/network/synchronisable/Synchronisable.cc
===================================================================
--- code/trunk/src/libraries/network/synchronisable/Synchronisable.cc	(revision 11052)
+++ code/trunk/src/libraries/network/synchronisable/Synchronisable.cc	(revision 11071)
@@ -88,6 +88,6 @@
     }
     // delete all Synchronisable Variables from syncList_ ( which are also in stringList_ )
-    for(std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin(); it!=syncList_.end(); it++)
-      delete (*it);
+    for(SynchronisableVariableBase* variable : syncList_)
+      delete variable;
     syncList_.clear();
     stringList_.clear();
@@ -105,9 +105,9 @@
   uint32_t Synchronisable::findContextID(Context* context)
   {
-      if (context == NULL)
+      if (context == nullptr)
           return OBJECTID_UNKNOWN;
 
       Synchronisable* synchronisableContext = orxonox_cast<Synchronisable*>(context);
-      if (synchronisableContext != NULL)
+      if (synchronisableContext != nullptr)
           return synchronisableContext->getObjectID();
       else
@@ -140,5 +140,5 @@
     {
       mem += header.getDataSize() + header.getSize();
-      return 0;
+      return nullptr;
     }
 //     assert( !header.isDiffed() );
@@ -156,5 +156,5 @@
     }
     assert(id);
-    Context* context = 0;
+    Context* context = nullptr;
     if (header.getContextID() != OBJECTID_UNKNOWN)
     {
@@ -164,5 +164,5 @@
         mem += header.getDataSize()+SynchronisableHeader::getSize(); //.TODO: this suckz.... remove size from header
         assert(0); // TODO: uncomment this if we have a clean objecthierarchy (with destruction of children of objects) ^^
-        return 0;
+        return nullptr;
       }
       else
@@ -172,5 +172,5 @@
       context = Context::getRootContext();
 
-    assert(getSynchronisable(header.getObjectID())==0);   //make sure no object with this id exists
+    assert(getSynchronisable(header.getObjectID())==nullptr);   //make sure no object with this id exists
     BaseObject *bo = orxonox_cast<BaseObject*>(id->fabricate(context));
     assert(bo);
@@ -226,5 +226,5 @@
       return it1->second;
     // if the objects not in the map it should'nt exist at all anymore
-    return NULL;
+    return nullptr;
   }
 
@@ -266,5 +266,4 @@
     assert(this->classID_==this->getIdentifier()->getNetworkID());
     assert(this->objectID_!=OBJECTID_UNKNOWN);
-    std::vector<SynchronisableVariableBase*>::iterator i;
 
     // start copy header
@@ -276,7 +275,7 @@
 //     orxout(verbose, context::network) << "objectid: " << this->objectID_ << ":";
     // copy to location
-    for(i=syncList_.begin(); i!=syncList_.end(); ++i)
-    {
-      uint32_t varsize = (*i)->getData( mem, mode );
+    for(SynchronisableVariableBase* variable : syncList_)
+    {
+      uint32_t varsize = variable->getData( mem, mode );
 //       orxout(verbose, context::network) << " " << varsize;
       tempsize += varsize;
@@ -348,9 +347,8 @@
       assert( this->getContextID() == syncHeader2.getContextID() );
       mem += SynchronisableHeader::getSize();
-      std::vector<SynchronisableVariableBase *>::iterator i;
-      for(i=syncList_.begin(); i!=syncList_.end(); ++i)
+      for(SynchronisableVariableBase* variable : syncList_)
       {
         assert( mem <= data+syncHeader2.getDataSize()+SynchronisableHeader::getSize() ); // always make sure we don't exceed the datasize in our stream
-        (*i)->putData( mem, mode, forceCallback );
+        variable->putData( mem, mode, forceCallback );
       }
       assert(mem == data+syncHeaderLight.getDataSize()+SynchronisableHeader::getSize() );
@@ -388,8 +386,7 @@
     assert( mode==state_ );
     tsize += this->dataSize_;
-    std::vector<SynchronisableVariableBase*>::iterator i;
-    for(i=stringList_.begin(); i!=stringList_.end(); ++i)
-    {
-      tsize += (*i)->getSize( mode );
+    for(SynchronisableVariableBase* variable : stringList_)
+    {
+      tsize += variable->getSize( mode );
     }
     return tsize;
Index: code/trunk/src/libraries/network/synchronisable/Synchronisable.h
===================================================================
--- code/trunk/src/libraries/network/synchronisable/Synchronisable.h	(revision 11052)
+++ code/trunk/src/libraries/network/synchronisable/Synchronisable.h	(revision 11071)
@@ -38,4 +38,5 @@
 #include <queue>
 #include <set>
+#include <type_traits>
 
 #include "util/mbool.h"
@@ -171,6 +172,6 @@
   protected:
     Synchronisable(Context* context);
-    template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
-    template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
+    template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=nullptr, bool bidirectional=false);
+    template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=nullptr, bool bidirectional=false);
     template <class T> void unregisterVariable(T& var);
 
@@ -203,14 +204,26 @@
   };
 
-  template <class T> void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
-  {
+  namespace detail
+  {
+    template <class T, bool = std::is_enum<T>::value>
+    struct UnderlyingType;
+    template <class T>
+    struct UnderlyingType<T, true> { typedef typename std::underlying_type<T>::type type; };
+    template <class T>
+    struct UnderlyingType<T, false> { typedef T type; };
+  }
+
+  template <class T>
+  void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+  {
+    typedef typename detail::UnderlyingType<T>::type UnderlyingType;
     if (bidirectional)
     {
-      syncList_.push_back(new SynchronisableVariableBidirectional<T>(variable, mode, cb));
+      syncList_.push_back(new SynchronisableVariableBidirectional<UnderlyingType>(reinterpret_cast<UnderlyingType&>(variable), mode, cb));
       this->dataSize_ += syncList_.back()->getSize(state_);
     }
     else
     {
-      syncList_.push_back(new SynchronisableVariable<T>(variable, mode, cb));
+      syncList_.push_back(new SynchronisableVariable<UnderlyingType>(reinterpret_cast<UnderlyingType&>(variable), mode, cb));
       if ( this->state_ == mode )
         this->dataSize_ += syncList_.back()->getSize(state_);
@@ -218,5 +231,6 @@
   }
   
-  template <class T> void Synchronisable::unregisterVariable(T& variable)
+  template <class T>
+  void Synchronisable::unregisterVariable(T& variable)
   {
     std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin();
@@ -238,11 +252,13 @@
   }
 
-  template <class T> void Synchronisable::registerVariable( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
-  {
+  template <class T>
+  void Synchronisable::registerVariable( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+  {
+    typedef typename detail::UnderlyingType<T>::type UnderlyingType;
     SynchronisableVariableBase* sv;
     if (bidirectional)
-      sv = new SynchronisableVariableBidirectional<std::set<T> >(variable, mode, cb);
+      sv = new SynchronisableVariableBidirectional<std::set<UnderlyingType>>(reinterpret_cast<std::set<UnderlyingType>&>(variable), mode, cb);
     else
-      sv = new SynchronisableVariable<std::set<T> >(variable, mode, cb);
+      sv = new SynchronisableVariable<std::set<UnderlyingType>>(reinterpret_cast<std::set<UnderlyingType>&>(variable), mode, cb);
     syncList_.push_back(sv);
     stringList_.push_back(sv);
@@ -250,5 +266,5 @@
 
   template <> _NetworkExport void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
-//   template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T> >( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
+//   template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T>>( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
   template <> _NetworkExport void Synchronisable::unregisterVariable( std::string& variable );
 
Index: code/trunk/src/libraries/network/synchronisable/SynchronisableVariable.h
===================================================================
--- code/trunk/src/libraries/network/synchronisable/SynchronisableVariable.h	(revision 11052)
+++ code/trunk/src/libraries/network/synchronisable/SynchronisableVariable.h	(revision 11071)
@@ -71,12 +71,12 @@
   {
     public:
-      SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=0);
+      SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=nullptr);
       virtual ~SynchronisableVariable();
 
-      virtual inline uint8_t getMode(){ return mode_; }
-      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode);
-      virtual inline void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
-      virtual inline uint32_t getSize(uint8_t mode);
-      virtual inline void* getReference(){ return static_cast<void*>(const_cast<typename Loki::TypeTraits<T>::UnqualifiedType*>(&this->variable_)); }
+      virtual inline uint8_t getMode() override{ return mode_; }
+      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode) override;
+      virtual inline void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false) override;
+      virtual inline uint32_t getSize(uint8_t mode) override;
+      virtual inline void* getReference() override{ return static_cast<void*>(const_cast<typename Loki::TypeTraits<T>::UnqualifiedType*>(&this->variable_)); }
     protected:
       T&                       variable_;
@@ -89,5 +89,5 @@
   {
     public:
-      SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=0);
+      SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=nullptr);
       virtual ~SynchronisableVariableBidirectional();
 
