Index: code/branches/netp/src/network/ClientConnection.cc
===================================================================
--- code/branches/netp/src/network/ClientConnection.cc	(revision 2793)
+++ code/branches/netp/src/network/ClientConnection.cc	(revision 2794)
@@ -42,4 +42,5 @@
 #include <enet/enet.h>
 #include <iostream>
+#include <cassert>
 // boost.thread library for multithreading support
 #include <boost/thread/thread.hpp>
@@ -166,4 +167,5 @@
         if(enet_host_service(client, event, NETWORK_CLIENT_WAIT_TIME)<0){
           // we should never reach this point
+	        assert(0);
           quit=true;
           continue;
@@ -206,5 +208,5 @@
     boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
     enet_peer_disconnect(server, 0);
-    while(enet_host_service(client, &event, NETWORK_CLIENT_WAIT_TIME) > 0){
+    while(enet_host_service(client, &event, NETWORK_CLIENT_WAIT_TIME) >= 0){
       switch (event.type)
       {
Index: code/branches/netp/src/network/ClientConnection.h
===================================================================
--- code/branches/netp/src/network/ClientConnection.h	(revision 2793)
+++ code/branches/netp/src/network/ClientConnection.h	(revision 2794)
@@ -53,6 +53,6 @@
     const int NETWORK_PORT = 55556;
     const int NETWORK_CLIENT_MAX_CONNECTIONS = 5;
-    const int NETWORK_CLIENT_WAIT_TIME = 1;
-    const int NETWORK_CLIENT_CONNECT_TIMEOUT = 3000; // miliseconds
+    const int NETWORK_CLIENT_WAIT_TIME = 10;
+    const int NETWORK_CLIENT_CONNECT_TIMEOUT = 10000; // miliseconds
     const int NETWORK_CLIENT_CHANNELS = 2;
 
Index: code/branches/netp/src/network/ConnectionManager.cc
===================================================================
--- code/branches/netp/src/network/ConnectionManager.cc	(revision 2793)
+++ code/branches/netp/src/network/ConnectionManager.cc	(revision 2794)
@@ -57,8 +57,5 @@
 {
   bool operator< (ENetAddress a, ENetAddress b) {
-    if(a.host <= b.host)
-      return true;
-    else
-      return false;
+    return a.host <= b.host;
   }
 }
@@ -198,4 +195,5 @@
         if(enet_host_service(server, event, NETWORK_WAIT_TIMEOUT)<0){
           // we should never reach this point
+          assert(0);
           quit=true;
           continue;
@@ -214,5 +212,5 @@
         case ENET_EVENT_TYPE_NONE:
           //receiverThread_->yield();
-          msleep(1);
+          msleep(10);
           break;
       }
@@ -266,11 +264,4 @@
   }
 
-  bool ConnectionManager::processData(ENetEvent *event) {
-    // just add packet to the buffer
-    // this can be extended with some preprocessing
-    return buffer.push(event);
-  }
-
-
 
   int ConnectionManager::getClientID(ENetPeer* peer) {
Index: code/branches/netp/src/network/ConnectionManager.h
===================================================================
--- code/branches/netp/src/network/ConnectionManager.h	(revision 2793)
+++ code/branches/netp/src/network/ConnectionManager.h	(revision 2794)
@@ -55,5 +55,5 @@
     const int NETWORK_PORT = 55556;
     const int NETWORK_MAX_CONNECTIONS = 50;
-    const int NETWORK_WAIT_TIMEOUT = 1;
+    const int NETWORK_WAIT_TIMEOUT = 10;
     const int NETWORK_DEFAULT_CHANNEL = 0;
 
@@ -84,5 +84,5 @@
   private:
     ConnectionManager(const ConnectionManager& copy); // not used
-    bool processData(ENetEvent *event);
+    inline bool processData(ENetEvent *event){ return buffer.push(event); }
     void receiverThread();
     void disconnectClients();
Index: code/branches/netp/src/network/TrafficControl.cc
===================================================================
--- code/branches/netp/src/network/TrafficControl.cc	(revision 2793)
+++ code/branches/netp/src/network/TrafficControl.cc	(revision 2794)
@@ -90,6 +90,6 @@
   void TrafficControl::setConfigValues()
   {
-    SetConfigValue ( bActive_, true );
-    SetConfigValue ( targetSize, 5000 );
+    SetConfigValue ( bActive_, false );
+    SetConfigValue ( targetSize, 10000 );
   }
 
Index: code/branches/netp/src/network/packet/Packet.h
===================================================================
--- code/branches/netp/src/network/packet/Packet.h	(revision 2793)
+++ code/branches/netp/src/network/packet/Packet.h	(revision 2794)
@@ -66,9 +66,9 @@
     virtual unsigned int getSize() const =0;
     virtual bool process()=0;
-    uint32_t getFlags()
+    inline uint32_t getFlags()
       { return flags_; }
-    int getClientID()
+    inline int getClientID()
       { return clientID_; }
-    void setClientID( int id )
+    inline void setClientID( int id )
       { clientID_ = id; }
 
Index: code/branches/netp/src/network/synchronisable/SynchronisableVariable.cc
===================================================================
--- code/branches/netp/src/network/synchronisable/SynchronisableVariable.cc	(revision 2793)
+++ 	(revision )
@@ -1,433 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Oliver Scheuss, (C) 2008
- *   Co-authors:
- *      ...
- *
- */
-
-#include "SynchronisableVariable.h"
-#include <cstring>
-#include "util/Math.h"
-
-
-namespace orxonox{
-
-uint8_t SynchronisableVariableBase::state_ = 0;
-
-
-
-// =================== Template specialisation stuff =============
-
-// =========== bool
-
-template <> uint32_t SynchronisableVariable<const bool>::returnSize()
-{
-  return sizeof(uint8_t);
-}
-
-template <> void SynchronisableVariable<const bool>::setAndIncrease( uint8_t*& mem )
-{
-  *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
-  mem += SynchronisableVariable<const bool>::returnSize();
-}
-
-template <> void SynchronisableVariable<const bool>::getAndIncrease( uint8_t*& mem )
-{
-  *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
-  mem += SynchronisableVariable<const bool>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const bool>::checkEquality( uint8_t* mem )
-{
-  return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
-}
-
-// =========== char
-
-template <> uint32_t SynchronisableVariable<const char>::returnSize()
-{
-  return sizeof(uint8_t);
-}
-
-template <> void SynchronisableVariable<const char>::setAndIncrease( uint8_t*& mem )
-{
-  *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
-  mem += SynchronisableVariable<const char>::returnSize();
-}
-
-template <> void SynchronisableVariable<const char>::getAndIncrease( uint8_t*& mem )
-{
-  *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
-  mem += SynchronisableVariable<const char>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const char>::checkEquality( uint8_t* mem )
-{
-  return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
-}
-
-// =========== unsigned char
-
-template <> uint32_t SynchronisableVariable<const unsigned char>::returnSize()
-{
-  return sizeof(uint8_t);
-}
-
-template <> void SynchronisableVariable<const unsigned char>::setAndIncrease( uint8_t*& mem )
-{
-  *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
-  mem += SynchronisableVariable<const unsigned char>::returnSize();
-}
-
-template <> void SynchronisableVariable<const unsigned char>::getAndIncrease( uint8_t*& mem )
-{
-  *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
-  mem += SynchronisableVariable<const unsigned char>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const unsigned char>::checkEquality( uint8_t* mem )
-{
-  return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
-}
-
-// =========== short
-
-template <> uint32_t SynchronisableVariable<const short>::returnSize()
-{
-  return sizeof(int16_t);
-}
-
-template <> void SynchronisableVariable<const short>::setAndIncrease( uint8_t*& mem )
-{
-  *(short*)(&this->variable_) = *(int16_t*)(mem);
-  mem += SynchronisableVariable<const short>::returnSize();
-}
-
-template <> void SynchronisableVariable<const short>::getAndIncrease( uint8_t*& mem )
-{
-  *(int16_t*)(mem) = this->variable_;
-  mem += SynchronisableVariable<const short>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const short>::checkEquality( uint8_t* mem )
-{
-  return *(int16_t*)(mem) == static_cast<int16_t>(this->variable_);
-}
-
-// =========== unsigned short
-
-template <> uint32_t SynchronisableVariable<const unsigned short>::returnSize()
-{
-  return sizeof(uint16_t);
-}
-
-template <> void SynchronisableVariable<const unsigned short>::setAndIncrease( uint8_t*& mem )
-{
-  *(unsigned short*)(&this->variable_) = *(uint16_t*)(mem);
-  mem += SynchronisableVariable<const unsigned short>::returnSize();
-}
-
-template <> void SynchronisableVariable<const unsigned short>::getAndIncrease( uint8_t*& mem )
-{
-  *(uint16_t*)(mem) = this->variable_;
-  mem += SynchronisableVariable<const unsigned short>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const unsigned short>::checkEquality( uint8_t* mem )
-{
-  return *(uint16_t*)(mem) == this->variable_;
-}
-
-// =========== int
-
-template <> uint32_t SynchronisableVariable<const int>::returnSize()
-{
-  return sizeof(int32_t);
-}
-
-template <> void SynchronisableVariable<const int>::setAndIncrease( uint8_t*& mem )
-{
-  *(int *)(&this->variable_) = *(int32_t*)(mem);
-  mem += SynchronisableVariable<const int>::returnSize();
-}
-
-template <> void SynchronisableVariable<const int>::getAndIncrease( uint8_t*& mem )
-{
-  *(int32_t*)(mem) = this->variable_;
-  mem += SynchronisableVariable<const int>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const int>::checkEquality( uint8_t* mem )
-{
-  return *(int32_t*)(mem) == this->variable_;
-}
-
-// =========== unsigned int
-
-template <> uint32_t SynchronisableVariable<const unsigned int>::returnSize()
-{
-  return sizeof(uint32_t);
-}
-    
-template <> void SynchronisableVariable<const unsigned int>::setAndIncrease( uint8_t*& mem )
-{
-  *(unsigned int*)(&this->variable_) = *(uint32_t*)(mem);
-  mem += SynchronisableVariable<const unsigned int>::returnSize();
-}
-
-template <> void SynchronisableVariable<const unsigned int>::getAndIncrease( uint8_t*& mem )
-{
-  *(uint32_t*)(mem) = this->variable_;
-  mem += SynchronisableVariable<const unsigned int>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const unsigned int>::checkEquality( uint8_t* mem )
-{
-  return *(uint32_t*)(mem) == this->variable_;
-}
-
-// =========== long
-
-template <> uint32_t SynchronisableVariable<const long>::returnSize()
-{
-  return sizeof(int32_t);
-}
-
-template <> void SynchronisableVariable<const long>::setAndIncrease( uint8_t*& mem )
-{
-  *(long*)(&this->variable_) = *(int32_t*)(mem);
-  mem += SynchronisableVariable<const long>::returnSize();
-}
-
-template <> void SynchronisableVariable<const long>::getAndIncrease( uint8_t*& mem )
-{
-  *(int32_t*)(mem) = this->variable_;
-  mem += SynchronisableVariable<const long>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const long>::checkEquality( uint8_t* mem )
-{
-  return *(int32_t*)(mem) == this->variable_;
-}
-
-// =========== unsigned long
-
-template <> uint32_t SynchronisableVariable<const unsigned long>::returnSize()
-{
-  return sizeof(uint32_t);
-}
-
-template <> void SynchronisableVariable<const unsigned long>::setAndIncrease( uint8_t*& mem )
-{
-  *(unsigned long*)(&this->variable_) = *(uint32_t*)(mem);
-  mem += SynchronisableVariable<const unsigned long>::returnSize();
-}
-
-template <> void SynchronisableVariable<const unsigned long>::getAndIncrease( uint8_t*& mem )
-{
-  *(uint32_t*)(mem) = this->variable_;
-  mem += SynchronisableVariable<const unsigned long>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const unsigned long>::checkEquality( uint8_t* mem )
-{
-  return *(uint32_t*)(mem) == this->variable_;
-}
-
-// =========== long long
-
-template <> uint32_t SynchronisableVariable<const long long>::returnSize()
-{
-  return sizeof(int64_t);
-}
-
-template <> void SynchronisableVariable<const long long>::setAndIncrease( uint8_t*& mem )
-{
-  *(long long*)(&this->variable_) = *(int64_t*)(mem);
-  mem += SynchronisableVariable<const long long>::returnSize();
-}
-
-template <> void SynchronisableVariable<const long long>::getAndIncrease( uint8_t*& mem )
-{
-  *(int64_t*)(mem) = this->variable_;
-  mem += SynchronisableVariable<const long long>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const long long>::checkEquality( uint8_t* mem )
-{
-  return *(int64_t*)(mem) == this->variable_;
-}
-
-// =========== unsigned long long
-
-template <> uint32_t SynchronisableVariable<const unsigned long long>::returnSize()
-{
-  return sizeof(uint64_t);
-}
-
-template <> void SynchronisableVariable<const unsigned long long>::setAndIncrease( uint8_t*& mem )
-{
-  *(unsigned long long*)(&this->variable_) = *(uint64_t*)(mem);
-  mem += SynchronisableVariable<const unsigned long long>::returnSize();
-}
-
-template <> void SynchronisableVariable<const unsigned long long>::getAndIncrease( uint8_t*& mem )
-{
-  *(uint64_t*)(mem) = this->variable_;
-  mem += SynchronisableVariable<const unsigned long long>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const unsigned long long>::checkEquality( uint8_t* mem )
-{
-  return *(uint64_t*)(mem) == this->variable_;
-}
-
-// =========== float
-
-template <> uint32_t SynchronisableVariable<const float>::returnSize()
-{
-  return sizeof(uint32_t);
-}
-
-template <> void SynchronisableVariable<const float>::setAndIncrease( uint8_t*& mem )
-{
-  *(uint32_t*)(&this->variable_) = *(uint32_t*)(mem);
-  mem += SynchronisableVariable<const float>::returnSize();
-}
-
-template <> void SynchronisableVariable<const float>::getAndIncrease( uint8_t*& mem )
-{
-  *(uint32_t*)(mem) = *(uint32_t*)(&this->variable_);
-  mem += SynchronisableVariable<const float>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const float>::checkEquality( uint8_t* mem )
-{
-  return *(uint32_t*)(mem) == *(uint32_t*)(&this->variable_);
-}
-
-// =========== double
-
-template <> uint32_t SynchronisableVariable<const double>::returnSize()
-{
-  return sizeof(uint64_t);
-}
-
-template <> void SynchronisableVariable<const double>::setAndIncrease( uint8_t*& mem )
-{
-  *(uint64_t*)(&this->variable_) = *(uint64_t*)(mem);
-  mem += SynchronisableVariable<const double>::returnSize();
-}
-
-template <> void SynchronisableVariable<const double>::getAndIncrease( uint8_t*& mem )
-{
-  *(uint64_t*)(mem) = *(uint64_t*)(&this->variable_);
-  mem += SynchronisableVariable<const double>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const double>::checkEquality( uint8_t* mem )
-{
-  return *(uint64_t*)(mem) == *(uint64_t*)(&this->variable_);
-}
-
-// =========== long double
-
-template <> uint32_t SynchronisableVariable<const long double>::returnSize()
-{
-  return sizeof(uint64_t);
-}
-
-template <> void SynchronisableVariable<const long double>::setAndIncrease( uint8_t*& mem )
-{
-  double temp;
-  memcpy(&temp, mem, sizeof(uint64_t));
-  *(long double*)(&this->variable_) = static_cast<const long double>(temp);
-  mem += SynchronisableVariable<const long double>::returnSize();
-}
-
-template <> void SynchronisableVariable<const long double>::getAndIncrease( uint8_t*& mem )
-{
-  double temp = static_cast<double>(this->variable_);
-  memcpy(mem, &temp, sizeof(uint64_t));
-  mem += SynchronisableVariable<const long double>::returnSize();
-}
-
-template <> bool SynchronisableVariable<const long double>::checkEquality( uint8_t* mem )
-{
-  double temp = static_cast<double>(this->variable_);
-  return memcmp(&temp, mem, sizeof(uint64_t))==0;
-}
-
-// =========== string
-
-template <> uint32_t SynchronisableVariable<const std::string>::returnSize()
-{
-  return variable_.length()+1;
-}
-
-template <> void SynchronisableVariable<const std::string>::getAndIncrease( uint8_t*& mem )
-{
-  memcpy(mem, this->variable_.c_str(), this->variable_.length()+1);
-  mem += this->variable_.length()+1;
-}
-
-template <> void SynchronisableVariable<const std::string>::setAndIncrease( uint8_t*& mem )
-{
-  *(std::string*)(&this->variable_) = std::string((const char *)mem);
-  mem += this->variable_.length()+1;
-}
-
-template <> bool SynchronisableVariable<const std::string>::checkEquality( uint8_t* mem )
-{
-  return std::string((const char*)mem)==this->variable_;
-}
-
-// =========== Degree
-
-template <> uint32_t SynchronisableVariable<const Degree>::returnSize()
-{
-  return sizeof(Ogre::Real);
-}
-
-template <> void SynchronisableVariable<const Degree>::getAndIncrease( uint8_t*& mem )
-{
-  Ogre::Real r = this->variable_.valueDegrees();
-  memcpy(mem, &r, returnSize());
-  mem += returnSize();
-}
-
-template <> void SynchronisableVariable<const Degree>::setAndIncrease( uint8_t*& mem )
-{
-  Ogre::Real* r = (Ogre::Real*)mem;
-  (Degree&)this->variable_ = *r;
-  mem += returnSize();
-}
-
-template <> bool SynchronisableVariable<const Degree>::checkEquality( uint8_t* mem )
-{
-  Ogre::Real* r = (Ogre::Real*)mem;
-  return this->variable_==Degree(*r);
-}
-
-}
Index: code/branches/netp/src/network/synchronisable/SynchronisableVariable.h
===================================================================
--- code/branches/netp/src/network/synchronisable/SynchronisableVariable.h	(revision 2793)
+++ code/branches/netp/src/network/synchronisable/SynchronisableVariable.h	(revision 2794)
@@ -79,8 +79,8 @@
       virtual inline void* getReference(){ return (void *)&this->variable_; }
     protected:
-      bool checkEquality(uint8_t* mem);
-      void setAndIncrease(uint8_t*& mem);
-      void getAndIncrease(uint8_t*& mem);
-      uint32_t returnSize();
+      inline bool checkEquality(uint8_t* mem);
+      inline void setAndIncrease(uint8_t*& mem);
+      inline void getAndIncrease(uint8_t*& mem);
+      inline uint32_t returnSize();
       
       T& variable_;
@@ -97,7 +97,7 @@
       
       virtual inline uint8_t getMode(){ return 0x3; } //this basically is a hack ^^
-      virtual void getData(uint8_t*& mem, uint8_t mode);
+      virtual inline void getData(uint8_t*& mem, uint8_t mode);
       virtual void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
-      virtual uint32_t getSize(uint8_t mode);
+      virtual inline uint32_t getSize(uint8_t mode);
     private:
       T varBuffer_;
@@ -122,5 +122,5 @@
   }
 
-  template <class T> void SynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode)
+  template <class T> inline void SynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode)
   {
     if ( state_ == this->mode_ )
@@ -143,12 +143,10 @@
   // write the data
     setAndIncrease( mem );
-//   mem += SynchronisableVariable<T>::getSize();
   // now do a callback if neccessary
     if ( callback )
       NetworkCallbackManager::triggerCallback( this->callback_ );
-      //this->callback_->call();
-  }
-
-  template <class T> uint32_t SynchronisableVariable<T>::getSize(uint8_t mode)
+  }
+
+  template <class T> inline uint32_t SynchronisableVariable<T>::getSize(uint8_t mode)
   {
     if ( mode == this->mode_ )
@@ -304,5 +302,5 @@
     }
 
-    template <class T> uint32_t SynchronisableVariableBidirectional<T>::getSize(uint8_t mode)
+    template <class T> inline uint32_t SynchronisableVariableBidirectional<T>::getSize(uint8_t mode)
     {
       return SynchronisableVariable<T>::returnSize() + sizeof(varReference_);
@@ -312,4 +310,5 @@
 }
 
+#include "network/synchronisable/SynchronisableVariableSpecialisations.h"
 
 #endif
Index: code/branches/netp/src/network/synchronisable/SynchronisableVariableSpecialisations.h
===================================================================
--- code/branches/netp/src/network/synchronisable/SynchronisableVariableSpecialisations.h	(revision 2794)
+++ code/branches/netp/src/network/synchronisable/SynchronisableVariableSpecialisations.h	(revision 2794)
@@ -0,0 +1,435 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Oliver Scheuss, (C) 2008
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include <cstring>
+#include "util/Math.h"
+
+#ifndef _NETWORK_SYNCHRONISABLEVARIABLESPECIALISATIONS__
+#define _NETWORK_SYNCHRONISABLEVARIABLESPECIALISATIONS__
+
+namespace orxonox{
+
+
+
+// =================== Template specialisation stuff =============
+
+// =========== bool
+
+template <> inline uint32_t SynchronisableVariable<const bool>::returnSize()
+{
+  return sizeof(uint8_t);
+}
+
+template <> inline void SynchronisableVariable<const bool>::setAndIncrease( uint8_t*& mem )
+{
+  *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
+  mem += SynchronisableVariable<const bool>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const bool>::getAndIncrease( uint8_t*& mem )
+{
+  *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
+  mem += SynchronisableVariable<const bool>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const bool>::checkEquality( uint8_t* mem )
+{
+  return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
+}
+
+// =========== char
+
+template <> inline uint32_t SynchronisableVariable<const char>::returnSize()
+{
+  return sizeof(uint8_t);
+}
+
+template <> inline void SynchronisableVariable<const char>::setAndIncrease( uint8_t*& mem )
+{
+  *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
+  mem += SynchronisableVariable<const char>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const char>::getAndIncrease( uint8_t*& mem )
+{
+  *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
+  mem += SynchronisableVariable<const char>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const char>::checkEquality( uint8_t* mem )
+{
+  return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
+}
+
+// =========== unsigned char
+
+template <> inline uint32_t SynchronisableVariable<const unsigned char>::returnSize()
+{
+  return sizeof(uint8_t);
+}
+
+template <> inline void SynchronisableVariable<const unsigned char>::setAndIncrease( uint8_t*& mem )
+{
+  *(uint8_t*)(&this->variable_) = *static_cast<uint8_t*>(mem);
+  mem += SynchronisableVariable<const unsigned char>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const unsigned char>::getAndIncrease( uint8_t*& mem )
+{
+  *static_cast<uint8_t*>(mem) = *(uint8_t*)(&this->variable_);
+  mem += SynchronisableVariable<const unsigned char>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const unsigned char>::checkEquality( uint8_t* mem )
+{
+  return *static_cast<uint8_t*>(mem) == *(uint8_t*)(&this->variable_);
+}
+
+// =========== short
+
+template <> inline uint32_t SynchronisableVariable<const short>::returnSize()
+{
+  return sizeof(int16_t);
+}
+
+template <> inline void SynchronisableVariable<const short>::setAndIncrease( uint8_t*& mem )
+{
+  *(short*)(&this->variable_) = *(int16_t*)(mem);
+  mem += SynchronisableVariable<const short>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const short>::getAndIncrease( uint8_t*& mem )
+{
+  *(int16_t*)(mem) = this->variable_;
+  mem += SynchronisableVariable<const short>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const short>::checkEquality( uint8_t* mem )
+{
+  return *(int16_t*)(mem) == static_cast<int16_t>(this->variable_);
+}
+
+// =========== unsigned short
+
+template <> inline uint32_t SynchronisableVariable<const unsigned short>::returnSize()
+{
+  return sizeof(uint16_t);
+}
+
+template <> inline void SynchronisableVariable<const unsigned short>::setAndIncrease( uint8_t*& mem )
+{
+  *(unsigned short*)(&this->variable_) = *(uint16_t*)(mem);
+  mem += SynchronisableVariable<const unsigned short>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const unsigned short>::getAndIncrease( uint8_t*& mem )
+{
+  *(uint16_t*)(mem) = this->variable_;
+  mem += SynchronisableVariable<const unsigned short>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const unsigned short>::checkEquality( uint8_t* mem )
+{
+  return *(uint16_t*)(mem) == this->variable_;
+}
+
+// =========== int
+
+template <> inline uint32_t SynchronisableVariable<const int>::returnSize()
+{
+  return sizeof(int32_t);
+}
+
+template <> inline void SynchronisableVariable<const int>::setAndIncrease( uint8_t*& mem )
+{
+  *(int *)(&this->variable_) = *(int32_t*)(mem);
+  mem += SynchronisableVariable<const int>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const int>::getAndIncrease( uint8_t*& mem )
+{
+  *(int32_t*)(mem) = this->variable_;
+  mem += SynchronisableVariable<const int>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const int>::checkEquality( uint8_t* mem )
+{
+  return *(int32_t*)(mem) == this->variable_;
+}
+
+// =========== unsigned int
+
+template <> inline uint32_t SynchronisableVariable<const unsigned int>::returnSize()
+{
+  return sizeof(uint32_t);
+}
+    
+template <> inline void SynchronisableVariable<const unsigned int>::setAndIncrease( uint8_t*& mem )
+{
+  *(unsigned int*)(&this->variable_) = *(uint32_t*)(mem);
+  mem += SynchronisableVariable<const unsigned int>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const unsigned int>::getAndIncrease( uint8_t*& mem )
+{
+  *(uint32_t*)(mem) = this->variable_;
+  mem += SynchronisableVariable<const unsigned int>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const unsigned int>::checkEquality( uint8_t* mem )
+{
+  return *(uint32_t*)(mem) == this->variable_;
+}
+
+// =========== long
+
+template <> inline uint32_t SynchronisableVariable<const long>::returnSize()
+{
+  return sizeof(int32_t);
+}
+
+template <> inline void SynchronisableVariable<const long>::setAndIncrease( uint8_t*& mem )
+{
+  *(long*)(&this->variable_) = *(int32_t*)(mem);
+  mem += SynchronisableVariable<const long>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const long>::getAndIncrease( uint8_t*& mem )
+{
+  *(int32_t*)(mem) = this->variable_;
+  mem += SynchronisableVariable<const long>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const long>::checkEquality( uint8_t* mem )
+{
+  return *(int32_t*)(mem) == this->variable_;
+}
+
+// =========== unsigned long
+
+template <> inline uint32_t SynchronisableVariable<const unsigned long>::returnSize()
+{
+  return sizeof(uint32_t);
+}
+
+template <> inline void SynchronisableVariable<const unsigned long>::setAndIncrease( uint8_t*& mem )
+{
+  *(unsigned long*)(&this->variable_) = *(uint32_t*)(mem);
+  mem += SynchronisableVariable<const unsigned long>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const unsigned long>::getAndIncrease( uint8_t*& mem )
+{
+  *(uint32_t*)(mem) = this->variable_;
+  mem += SynchronisableVariable<const unsigned long>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const unsigned long>::checkEquality( uint8_t* mem )
+{
+  return *(uint32_t*)(mem) == this->variable_;
+}
+
+// =========== long long
+
+template <> inline uint32_t SynchronisableVariable<const long long>::returnSize()
+{
+  return sizeof(int64_t);
+}
+
+template <> inline void SynchronisableVariable<const long long>::setAndIncrease( uint8_t*& mem )
+{
+  *(long long*)(&this->variable_) = *(int64_t*)(mem);
+  mem += SynchronisableVariable<const long long>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const long long>::getAndIncrease( uint8_t*& mem )
+{
+  *(int64_t*)(mem) = this->variable_;
+  mem += SynchronisableVariable<const long long>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const long long>::checkEquality( uint8_t* mem )
+{
+  return *(int64_t*)(mem) == this->variable_;
+}
+
+// =========== unsigned long long
+
+template <> inline uint32_t SynchronisableVariable<const unsigned long long>::returnSize()
+{
+  return sizeof(uint64_t);
+}
+
+template <> inline void SynchronisableVariable<const unsigned long long>::setAndIncrease( uint8_t*& mem )
+{
+  *(unsigned long long*)(&this->variable_) = *(uint64_t*)(mem);
+  mem += SynchronisableVariable<const unsigned long long>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const unsigned long long>::getAndIncrease( uint8_t*& mem )
+{
+  *(uint64_t*)(mem) = this->variable_;
+  mem += SynchronisableVariable<const unsigned long long>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const unsigned long long>::checkEquality( uint8_t* mem )
+{
+  return *(uint64_t*)(mem) == this->variable_;
+}
+
+// =========== float
+
+template <> inline uint32_t SynchronisableVariable<const float>::returnSize()
+{
+  return sizeof(uint32_t);
+}
+
+template <> inline void SynchronisableVariable<const float>::setAndIncrease( uint8_t*& mem )
+{
+  *(uint32_t*)(&this->variable_) = *(uint32_t*)(mem);
+  mem += SynchronisableVariable<const float>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const float>::getAndIncrease( uint8_t*& mem )
+{
+  *(uint32_t*)(mem) = *(uint32_t*)(&this->variable_);
+  mem += SynchronisableVariable<const float>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const float>::checkEquality( uint8_t* mem )
+{
+  return *(uint32_t*)(mem) == *(uint32_t*)(&this->variable_);
+}
+
+// =========== double
+
+template <> inline uint32_t SynchronisableVariable<const double>::returnSize()
+{
+  return sizeof(uint64_t);
+}
+
+template <> inline void SynchronisableVariable<const double>::setAndIncrease( uint8_t*& mem )
+{
+  *(uint64_t*)(&this->variable_) = *(uint64_t*)(mem);
+  mem += SynchronisableVariable<const double>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const double>::getAndIncrease( uint8_t*& mem )
+{
+  *(uint64_t*)(mem) = *(uint64_t*)(&this->variable_);
+  mem += SynchronisableVariable<const double>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const double>::checkEquality( uint8_t* mem )
+{
+  return *(uint64_t*)(mem) == *(uint64_t*)(&this->variable_);
+}
+
+// =========== long double
+
+template <> inline uint32_t SynchronisableVariable<const long double>::returnSize()
+{
+  return sizeof(uint64_t);
+}
+
+template <> inline void SynchronisableVariable<const long double>::setAndIncrease( uint8_t*& mem )
+{
+  double temp;
+  memcpy(&temp, mem, sizeof(uint64_t));
+  *(long double*)(&this->variable_) = static_cast<const long double>(temp);
+  mem += SynchronisableVariable<const long double>::returnSize();
+}
+
+template <> inline void SynchronisableVariable<const long double>::getAndIncrease( uint8_t*& mem )
+{
+  double temp = static_cast<double>(this->variable_);
+  memcpy(mem, &temp, sizeof(uint64_t));
+  mem += SynchronisableVariable<const long double>::returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const long double>::checkEquality( uint8_t* mem )
+{
+  double temp = static_cast<double>(this->variable_);
+  return memcmp(&temp, mem, sizeof(uint64_t))==0;
+}
+
+// =========== string
+
+template <> inline uint32_t SynchronisableVariable<const std::string>::returnSize()
+{
+  return variable_.length()+1;
+}
+
+template <> inline void SynchronisableVariable<const std::string>::getAndIncrease( uint8_t*& mem )
+{
+  memcpy(mem, this->variable_.c_str(), this->variable_.length()+1);
+  mem += this->variable_.length()+1;
+}
+
+template <> inline void SynchronisableVariable<const std::string>::setAndIncrease( uint8_t*& mem )
+{
+  *(std::string*)(&this->variable_) = std::string((const char *)mem);
+  mem += this->variable_.length()+1;
+}
+
+template <> inline bool SynchronisableVariable<const std::string>::checkEquality( uint8_t* mem )
+{
+  return std::string((const char*)mem)==this->variable_;
+}
+
+// =========== Degree
+
+template <> inline uint32_t SynchronisableVariable<const Degree>::returnSize()
+{
+  return sizeof(Ogre::Real);
+}
+
+template <> inline void SynchronisableVariable<const Degree>::getAndIncrease( uint8_t*& mem )
+{
+  Ogre::Real r = this->variable_.valueDegrees();
+  memcpy(mem, &r, returnSize());
+  mem += returnSize();
+}
+
+template <> inline void SynchronisableVariable<const Degree>::setAndIncrease( uint8_t*& mem )
+{
+  Ogre::Real* r = (Ogre::Real*)mem;
+  (Degree&)this->variable_ = *r;
+  mem += returnSize();
+}
+
+template <> inline bool SynchronisableVariable<const Degree>::checkEquality( uint8_t* mem )
+{
+  Ogre::Real* r = (Ogre::Real*)mem;
+  return this->variable_==Degree(*r);
+}
+
+}
+
+
+#endif
Index: code/branches/netp/src/orxonox/objects/controllers/AIController.cc
===================================================================
--- code/branches/netp/src/orxonox/objects/controllers/AIController.cc	(revision 2793)
+++ code/branches/netp/src/orxonox/objects/controllers/AIController.cc	(revision 2794)
@@ -101,15 +101,18 @@
     void AIController::tick(float dt)
     {
-        if (!this->isActive())
-            return;
-
-        if (this->target_)
-            this->aimAtTarget();
-
-        if (this->bHasTargetPosition_)
-            this->moveToTargetPosition(dt);
-
-        if (this->getControllableEntity() && this->bShooting_ && this->isCloseAtTarget(500) && this->isLookingAtTarget(Ogre::Math::PI / 20.0))
-            this->getControllableEntity()->fire(WeaponMode::fire);
+        if(Core::isMaster())
+        {
+            if (!this->isActive())
+                return;
+    
+            if (this->target_)
+                this->aimAtTarget();
+    
+            if (this->bHasTargetPosition_)
+                this->moveToTargetPosition(dt);
+    
+            if (this->getControllableEntity() && this->bShooting_ && this->isCloseAtTarget(500) && this->isLookingAtTarget(Ogre::Math::PI / 20.0))
+                this->getControllableEntity()->fire(WeaponMode::fire);
+        }
 
         SUPER(AIController, tick, dt);
