Index: /code/trunk/src/libraries/network/Client.cc
===================================================================
--- /code/trunk/src/libraries/network/Client.cc	(revision 7494)
+++ /code/trunk/src/libraries/network/Client.cc	(revision 7495)
@@ -175,4 +175,5 @@
     if(gamestate->processGamestates())
     {
+      FunctionCallManager::processBufferedFunctionCalls();
       if(!isSynched_)
         isSynched_=true;
Index: /code/trunk/src/libraries/network/FunctionCall.cc
===================================================================
--- /code/trunk/src/libraries/network/FunctionCall.cc	(revision 7494)
+++ /code/trunk/src/libraries/network/FunctionCall.cc	(revision 7495)
@@ -80,20 +80,26 @@
     {
       case 0:
-        fct->call(this->objectID_);
+        if( !fct->call(this->objectID_) )
+          return false;
         break;
       case 1:
-        fct->call(this->objectID_, this->arguments_[0]);
+        if( !fct->call(this->objectID_, this->arguments_[0]) )
+          return false;
         break;
       case 2:
-        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1]);
+        if( !fct->call(this->objectID_, this->arguments_[0], this->arguments_[1]) )
+          return false;
         break;
       case 3:
-        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2]);
+        if( !fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2]) )
+          return false;
         break;
       case 4:
-        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3]);
+        if( !fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3]) )
+          return false;
         break;
       case 5:
-        fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3], this->arguments_[4]);
+        if( !fct->call(this->objectID_, this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3], this->arguments_[4]) )
+          return false;
         break;
       default:
Index: /code/trunk/src/libraries/network/FunctionCall.h
===================================================================
--- /code/trunk/src/libraries/network/FunctionCall.h	(revision 7494)
+++ /code/trunk/src/libraries/network/FunctionCall.h	(revision 7495)
@@ -32,4 +32,5 @@
 #include "network/NetworkPrereqs.h"
 #include "util/UtilPrereqs.h"
+#include "util/MultiType.h"
 
 #include <cassert>
Index: /code/trunk/src/libraries/network/FunctionCallManager.cc
===================================================================
--- /code/trunk/src/libraries/network/FunctionCallManager.cc	(revision 7494)
+++ /code/trunk/src/libraries/network/FunctionCallManager.cc	(revision 7495)
@@ -29,8 +29,10 @@
 #include "FunctionCallManager.h"
 #include "packet/FunctionCalls.h"
+#include "core/GameMode.h"
 
 namespace orxonox {
 
-std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::clientMap_;
+std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::sClientMap_;
+std::vector<FunctionCall> FunctionCallManager::sIncomingFunctionCallBuffer_;
 
 // Static calls
@@ -38,55 +40,55 @@
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallStatic(functionID);
+  FunctionCallManager::sClientMap_[clientID]->addCallStatic(functionID);
 }
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager:: clientMap_[clientID]->addCallStatic(functionID, &mt1);
+  FunctionCallManager:: sClientMap_[clientID]->addCallStatic(functionID, &mt1);
 }
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager:: clientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2);
+  FunctionCallManager:: sClientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2);
 }
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager:: clientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3);
+  FunctionCallManager:: sClientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3);
 }
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager:: clientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4);
+  FunctionCallManager:: sClientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4);
 }
 void FunctionCallManager::addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager:: clientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4, &mt5);
+  FunctionCallManager:: sClientMap_[clientID]->addCallStatic(functionID, &mt1, &mt2, &mt3, &mt4, &mt5);
 }
 
@@ -96,55 +98,55 @@
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID);
 }
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID, &mt1);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID, &mt1);
 }
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2);
 }
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3);
 }
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4);
 }
 void FunctionCallManager::addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
 {
-  if(clientMap_.find(clientID)==clientMap_.end())
+  if(sClientMap_.find(clientID)==sClientMap_.end())
   {
-    FunctionCallManager::clientMap_[clientID] = new packet::FunctionCalls;
-    FunctionCallManager::clientMap_[clientID]->setClientID(clientID);
+    FunctionCallManager::sClientMap_[clientID] = new packet::FunctionCalls;
+    FunctionCallManager::sClientMap_[clientID]->setClientID(clientID);
   }
-  FunctionCallManager::clientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4, &mt5);
+  FunctionCallManager::sClientMap_[clientID]->addCallMember(functionID, objectID, &mt1, &mt2, &mt3, &mt4, &mt5);
 }
 
@@ -154,10 +156,28 @@
 {
   std::map<uint32_t, packet::FunctionCalls*>::iterator it;
-  for (it = FunctionCallManager::clientMap_.begin(); it != FunctionCallManager::clientMap_.end(); it++ )
+  for (it = FunctionCallManager::sClientMap_.begin(); it != FunctionCallManager::sClientMap_.end(); ++it )
   {
-    assert(!FunctionCallManager::clientMap_.empty());
+    assert(!FunctionCallManager::sClientMap_.empty());
     it->second->send();
   }
-  FunctionCallManager::clientMap_.clear();
+  FunctionCallManager::sClientMap_.clear();
+}
+
+void FunctionCallManager::bufferIncomingFunctionCall(const orxonox::FunctionCall& fctCall)
+{
+  if( !GameMode::isMaster() )
+    FunctionCallManager::sIncomingFunctionCallBuffer_.push_back( fctCall );
+}
+
+void FunctionCallManager::processBufferedFunctionCalls()
+{
+  std::vector<FunctionCall>::iterator it = FunctionCallManager::sIncomingFunctionCallBuffer_.begin();
+  while( it!=FunctionCallManager::sIncomingFunctionCallBuffer_.end() )
+  {
+    if( it->execute() )
+      FunctionCallManager::sIncomingFunctionCallBuffer_.erase(it);
+    else
+      ++it;
+  }
 }
 
Index: /code/trunk/src/libraries/network/FunctionCallManager.h
===================================================================
--- /code/trunk/src/libraries/network/FunctionCallManager.h	(revision 7494)
+++ /code/trunk/src/libraries/network/FunctionCallManager.h	(revision 7495)
@@ -33,5 +33,7 @@
 
 #include <map>
+#include <vector>
 #include "util/UtilPrereqs.h"
+#include "FunctionCall.h"
 
 namespace orxonox {
@@ -58,6 +60,10 @@
 
   static void sendCalls();
+  
+  static void bufferIncomingFunctionCall( const FunctionCall& fctCall );
+  static void processBufferedFunctionCalls();
 
-  static std::map<uint32_t, packet::FunctionCalls*> clientMap_;
+  static std::map<uint32_t, packet::FunctionCalls*> sClientMap_;
+  static std::vector<FunctionCall>                  sIncomingFunctionCallBuffer_;
 protected:
   FunctionCallManager();
Index: /code/trunk/src/libraries/network/NetworkFunction.h
===================================================================
--- /code/trunk/src/libraries/network/NetworkFunction.h	(revision 7494)
+++ /code/trunk/src/libraries/network/NetworkFunction.h	(revision 7495)
@@ -139,10 +139,10 @@
 
     //
-    virtual void call(uint32_t objectID)=0;
-    virtual void call(uint32_t objectID, const MultiType& mt1)=0;
-    virtual void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)=0;
-    virtual void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)=0;
-    virtual void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)=0;
-    virtual void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)=0;
+    virtual bool call(uint32_t objectID)=0;
+    virtual bool call(uint32_t objectID, const MultiType& mt1)=0;
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)=0;
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)=0;
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)=0;
+    virtual bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)=0;
 
   private:
@@ -156,33 +156,63 @@
     NetworkMemberFunction(const FunctorMemberPtr<T>& functor, const std::string& name, const NetworkFunctionPointer& p);
 
-    inline void call(uint32_t objectID)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+    inline bool call(uint32_t objectID)
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)));
-    }
-    inline void call(uint32_t objectID, const MultiType& mt1)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+        return true;
+      }
+      else
+        return false;
+    }
+    inline bool call(uint32_t objectID, const MultiType& mt1)
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1);
-    }
-    inline void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+        return true;
+      }
+      else
+        return false;
+    }
+    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2);
-    }
-    inline void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+        return true;
+      }
+      else
+        return false;
+    }
+    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
+    {
+      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3);
-    }
-    inline void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+        return true;
+      }
+      else
+        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 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4);
-    }
-    inline void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
-    {
-      if ( Synchronisable::getSynchronisable(objectID)!=0 )
+        return true;
+      }
+      else
+        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 )
+      {
         (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4, mt5);
+        return true;
+      }
+      else
+        return false;
     }
 
Index: /code/trunk/src/libraries/network/packet/FunctionCalls.cc
===================================================================
--- /code/trunk/src/libraries/network/packet/FunctionCalls.cc	(revision 7494)
+++ /code/trunk/src/libraries/network/packet/FunctionCalls.cc	(revision 7495)
@@ -31,4 +31,5 @@
 #include <cassert>
 #include "network/FunctionCall.h"
+#include "network/FunctionCallManager.h"
 
 namespace orxonox {
@@ -66,5 +67,6 @@
     FunctionCall fctCall;
     fctCall.loadData(temp);
-    fctCall.execute();
+    if( !fctCall.execute() )
+      FunctionCallManager::bufferIncomingFunctionCall( fctCall );
   }
   
Index: /code/trunk/src/orxonox/worldentities/ControllableEntity.cc
===================================================================
--- /code/trunk/src/orxonox/worldentities/ControllableEntity.cc	(revision 7494)
+++ /code/trunk/src/orxonox/worldentities/ControllableEntity.cc	(revision 7495)
@@ -87,4 +87,7 @@
         this->setPriority( Priority::VeryHigh );
         this->registerVariables();
+        COUT(0) << "CE creator" << endl;
+        if( GameMode::isMaster() )
+          callMemberNetworkFunction(ControllableEntity, fire, this->getObjectID(), 1, 0);
     }
 
@@ -241,4 +244,5 @@
     void ControllableEntity::fire(unsigned int firemode)
     {
+        COUT(0) << "fire........." << endl;
         if(GameMode::isMaster())
         {
