Index: code/trunk/src/modules/pickup/PickupManager.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupManager.cc	(revision 7494)
+++ code/trunk/src/modules/pickup/PickupManager.cc	(revision 7504)
@@ -40,4 +40,6 @@
 #include "core/GUIManager.h"
 #include "core/Identifier.h"
+#include "network/Host.h"
+#include "network/NetworkFunction.h"
 #include "interfaces/PickupCarrier.h"
 #include "infos/PlayerInfo.h"
@@ -53,17 +55,20 @@
     DeclareToluaInterface(Pickup);
 
-    ManageScopedSingleton(PickupManager, ScopeID::Graphics, false);
+    ManageScopedSingleton(PickupManager, ScopeID::Root, false);
 
     /*static*/ const std::string PickupManager::guiName_s = "PickupInventory";
 
+    registerStaticNetworkFunction(PickupManager::pickupChangedUsedNetwork);
+    registerStaticNetworkFunction(PickupManager::pickupChangedPickedUpNetwork);
+    registerStaticNetworkFunction(PickupManager::dropPickupNetworked);
+    registerStaticNetworkFunction(PickupManager::usePickupNetworked);
+
     /**
     @brief
         Constructor. Registers the PickupManager and creates the default PickupRepresentation.
     */
-    PickupManager::PickupManager() : defaultRepresentation_(NULL)
-    {
-        RegisterRootObject(PickupManager);
-
-        GUIManager::getInstance().loadGUI(PickupManager::guiName_s);
+    PickupManager::PickupManager() : guiLoaded_(false), pickupIndex_(0), defaultRepresentation_(NULL)
+    {
+        RegisterObject(PickupManager);
 
         this->defaultRepresentation_ = new PickupRepresentation();
@@ -83,4 +88,6 @@
 
         this->representations_.clear();
+
+        //TODO: Destroy properly...
 
         COUT(3) << "PickupManager destroyed." << std::endl;
@@ -103,5 +110,5 @@
         assert(representation);
 
-        if(this->representations_.find(identifier) != this->representations_.end()) // If the Pickupable already has a Representation registered.
+        if(!this->representations_.empty() && this->representations_.find(identifier) != this->representations_.end()) // If the Pickupable already has a Representation registered.
             return false;
 
@@ -109,4 +116,15 @@
 
         COUT(4) << "PickupRepresentation &" << representation << " registered with the PickupManager." << std::endl;
+        return true;
+    }
+
+    bool PickupManager::registerRepresentation(PickupRepresentation* representation)
+    {
+        assert(representation);
+
+        if(!this->representationsNetworked_.empty() && this->representationsNetworked_.find(representation->getObjectID()) != this->representationsNetworked_.end()) // If the PickupRepresentation is already registered.
+            return false;
+
+        this->representationsNetworked_[representation->getObjectID()] = representation;
         return true;
     }
@@ -137,4 +155,16 @@
     }
 
+    bool PickupManager::unregisterRepresentation(PickupRepresentation* representation)
+    {
+        assert(representation);
+
+        std::map<uint32_t, PickupRepresentation*>::iterator it = this->representationsNetworked_.find(representation->getObjectID());
+        if(it == this->representationsNetworked_.end()) //!< If the Pickupable is not registered in the first place.
+            return false;
+
+        this->representationsNetworked_.erase(it);
+        return true;
+    }
+
     /**
     @brief
@@ -166,10 +196,19 @@
         Returns the PickupRepresentation of the input Pickupable or NULL if an error occurred.
     */
-    orxonox::PickupRepresentation* PickupManager::getPickupRepresentation(orxonox::Pickupable* pickup)
-    {
-        if(pickup != NULL)
-            return this->getRepresentation(pickup->getPickupIdentifier());
-
-        return NULL;
+    orxonox::PickupRepresentation* PickupManager::getPickupRepresentation(uint64_t pickup)
+    {
+        this->representationsNetworked_.clear();
+        for(ObjectList<PickupRepresentation>::iterator it = ObjectList<PickupRepresentation>::begin(); it != ObjectList<PickupRepresentation>::end(); ++it)
+            this->representationsNetworked_[it->getObjectID()] = *it;
+
+        std::map<uint64_t, PickupInventoryContainer*>::iterator it = this->pickupInventoryContainers_.find(pickup);
+        if(it == this->pickupInventoryContainers_.end())
+            return this->defaultRepresentation_;
+
+        std::map<uint32_t, PickupRepresentation*>::iterator it2 = this->representationsNetworked_.find(it->second->representationObjectId);
+        if(it2 == this->representationsNetworked_.end())
+            return this->defaultRepresentation_;
+
+        return it2->second;
     }
 
@@ -183,57 +222,6 @@
     int PickupManager::getNumPickups(void)
     {
-        this->pickupsList_.clear(); // Clear the list if Pickupables.
-
-        PlayerInfo* player = GUIManager::getInstance().getPlayer(PickupManager::guiName_s);
-        PickupCarrier* carrier = NULL;
-        if (player != NULL)
-            carrier =  orxonox_cast<PickupCarrier*>(player->getControllableEntity());
-        else
-            return 0;
-
-        std::vector<PickupCarrier*>* carriers = this->getAllCarriers(carrier); // Get a list of all the entities which carry the players Pickupables.
-        // Iterate through all the carriers and add their Pickupable to the list.
-        for(std::vector<PickupCarrier*>::iterator it = carriers->begin(); it != carriers->end(); it++)
-        {
-            std::set<Pickupable*> pickups = (*it)->getPickups();
-            for(std::set<Pickupable*>::iterator pickup = pickups.begin(); pickup != pickups.end(); pickup++)
-            {
-                CollectiblePickup* collectible = orxonox_cast<CollectiblePickup*>(*pickup);
-                // If the Pickupable is in a PickupCollection it is not added to the list and thus not displayed in the PickupInventory.
-                if(collectible == NULL || !collectible->isInCollection())
-                    this->pickupsList_.insert(std::pair<Pickupable*, WeakPtr<Pickupable> >(*pickup, WeakPtr<Pickupable>(*pickup)));
-            }
-        }
-        delete carriers;
-
-        this->pickupsIterator_ = this->pickupsList_.begin(); //Set the iterator to the start of the list.
-        return this->pickupsList_.size();
-    }
-
-    /**
-    @brief
-        Helper method. Get all the PickupCarriers that carry Pickupables, recursively.
-    @param carrier
-        The PickupCarrier whose children should be added to the list of PickupCarriers.
-    @param carriers
-        The list of PickupCarriers, used in "recursive-mode".
-        For the first instance this is just NULL (which is default and can be omitted) upon which a new list is allocated.
-    @return
-        Returns the list of PickupCarriers.
-    */
-    std::vector<PickupCarrier*>* PickupManager::getAllCarriers(PickupCarrier* carrier, std::vector<PickupCarrier*>* carriers)
-    {
-        if(carriers == NULL) // Create a new list if no list was passed.
-            carriers = new std::vector<PickupCarrier*>();
-
-        carriers->insert(carriers->end(), carrier); // Add the input PickupCarrier to the list.
-
-        std::vector<PickupCarrier*>* children = carrier->getCarrierChildren(); // Get the children of the input PickupCarrier.
-        // Iterate through the children and add them (and their children) to the list by recursively executing getAllCarriers().
-        for(std::vector<PickupCarrier*>::iterator it = children->begin(); it != children->end(); it++)
-            this->getAllCarriers(*it, carriers);
-        delete children;
-
-        return carriers;
+        this->pickupsIterator_ = this->pickupInventoryContainers_.begin();
+        return this->pickupInventoryContainers_.size();
     }
 
@@ -245,15 +233,29 @@
         The Pickupable to be dropped.
     */
-    void PickupManager::dropPickup(orxonox::Pickupable* pickup)
-    {
-        if(pickup == NULL)
-            return;
-
-        std::map<Pickupable*, WeakPtr<Pickupable> >::iterator it = this->pickupsList_.find(pickup); // Get the WeakPointer of the Pickupable.
-        // If either the input Pickupable is not in the PickupManagers list or it no longer exists, the method returns.
-        if(it == this->pickupsList_.end() || it->second.get() == NULL)
-            return;
-
-        pickup->drop(); // The Pickupable is dropped.
+    void PickupManager::dropPickup(uint64_t pickup)
+    {
+        if(GameMode::isMaster() && !this->pickups_.empty())
+        {
+            Pickupable* pickupable = this->pickups_.find(pickup)->second->get();
+            if(pickupable != NULL)
+                pickupable->drop();
+        }
+        else
+        {
+            callStaticNetworkFunction(PickupManager::dropPickupNetworked, 0, pickup);
+        }
+    }
+
+    /*static*/ void PickupManager::dropPickupNetworked(uint64_t pickup)
+    {
+        if(GameMode::isServer())
+        {
+            PickupManager& manager = PickupManager::getInstance();
+            if(manager.pickups_.empty())
+                return;
+            Pickupable* pickupable = manager.pickups_.find(pickup)->second->get();
+            if(pickupable != NULL)
+                pickupable->drop();
+        }
     }
 
@@ -267,15 +269,29 @@
         If true the input Pickupable is used, if false it is unused.
     */
-    void PickupManager::usePickup(orxonox::Pickupable* pickup, bool use)
-    {
-        if(pickup == NULL)
-            return;
-
-        std::map<Pickupable*, WeakPtr<Pickupable> >::iterator it = this->pickupsList_.find(pickup); // Get the WeakPointer of the Pickupable.
-        // If either the input Pickupable is not in the PickupManagers list or it no longer exists, the method returns.
-        if(it == this->pickupsList_.end() || it->second.get() == NULL)
-            return;
-
-        pickup->setUsed(use); // The Pickupable is used (or unused).
+    void PickupManager::usePickup(uint64_t pickup, bool use)
+    {
+        if(GameMode::isMaster() && !this->pickups_.empty())
+        {
+            Pickupable* pickupable = this->pickups_.find(pickup)->second->get();
+            if(pickupable != NULL)
+                pickupable->setUsed(use);
+        }
+        else
+        {
+            callStaticNetworkFunction(PickupManager::usePickupNetworked, 0, pickup, use);
+        }
+    }
+
+    /*static*/ void PickupManager::usePickupNetworked(uint64_t pickup, bool use)
+    {
+        if(GameMode::isServer())
+        {
+            PickupManager& manager = PickupManager::getInstance();
+            if(manager.pickups_.empty())
+                return;
+            Pickupable* pickupable = manager.pickups_.find(pickup)->second->get();
+            if(pickupable != NULL)
+                pickupable->setUsed(use);
+        }
     }
 
@@ -288,10 +304,166 @@
         Returns true if the input Pickupable is still valid, false if not.
     */
-    bool PickupManager::isValidPickup(orxonox::Pickupable* pickup)
-    {
-        std::map<Pickupable*, WeakPtr<Pickupable> >::iterator it = this->pickupsList_.find(pickup); // Get the WeakPointer of the Pickupable.
-        if(it == this->pickupsList_.end()) // If the Pickupable is not in the PickupManager's list.
-            return false;
-        return it->second.get() != NULL; // Returns whether the Pickupable still exists.
+    bool PickupManager::isValidPickup(uint64_t pickup)
+    {
+        return this->pickups_.find(pickup) != this->pickups_.end();
+    }
+
+    void PickupManager::pickupChangedUsed(Pickupable* pickup, bool used)
+    {
+        assert(pickup);
+
+        if(!GameMode::isMaster()) // If this is neither standalone nor the server.
+            return;
+
+        CollectiblePickup* collectible = orxonox_cast<CollectiblePickup*>(pickup);
+        // If the Picupable is part of a PickupCollection it isn't displayed in the PickupInventory, just the PickupCollection is.
+        if(collectible != NULL && collectible->isInCollection())
+            return;
+
+        PickupCarrier* carrier = pickup->getCarrier();
+        while(carrier->getCarrierParent() != NULL)
+            carrier = carrier->getCarrierParent();
+        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
+        if(pawn == NULL)
+            return;
+        PlayerInfo* info = pawn->getPlayer();
+        if(info == NULL)
+            return;
+        unsigned int clientId = info->getClientID();
+
+        std::map<Pickupable*, uint64_t>::iterator it = this->indexes_.find(pickup);
+        assert(it != this->indexes_.end());
+
+        uint64_t index = it->second;
+        if(GameMode::isStandalone() || Host::getPlayerID() == clientId)
+        {
+            PickupManager::pickupChangedUsedNetwork(index, used, pickup->isUsable(), pickup->isUnusable());
+        }
+        else
+        {
+            callStaticNetworkFunction(PickupManager::pickupChangedUsedNetwork, clientId, index, used, pickup->isUsable(), pickup->isUnusable());
+        }
+    }
+
+    /*static*/ void PickupManager::pickupChangedUsedNetwork(uint64_t pickup, bool inUse, bool usable, bool unusable)
+    {
+        PickupManager& manager = PickupManager::getInstance();
+        if(manager.pickupInventoryContainers_.find(pickup) == manager.pickupInventoryContainers_.end())
+        {
+            COUT(1) << "Error: Pickupable &(" << pickup << ") was not registered with PickupManager for the PickupInventory, when it changed used." << std::endl;
+            return;
+        }
+
+        manager.pickupInventoryContainers_[pickup]->inUse = inUse;
+        manager.pickupInventoryContainers_[pickup]->usable = usable;
+        manager.pickupInventoryContainers_[pickup]->unusable = unusable;
+
+        manager.updateGUI();
+    }
+
+    void PickupManager::pickupChangedPickedUp(Pickupable* pickup, bool pickedUp)
+    {
+        assert(pickup);
+
+        if(!GameMode::isMaster())
+            return;
+
+        CollectiblePickup* collectible = orxonox_cast<CollectiblePickup*>(pickup);
+        // If the Picupable is part of a PickupCollection it isn't displayed in the PickupInventory, just the PickupCollection is.
+        if(collectible != NULL && collectible->isInCollection())
+            return;
+
+        PickupCarrier* carrier = pickup->getCarrier();
+        while(carrier->getCarrierParent() != NULL)
+            carrier = carrier->getCarrierParent();
+        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
+        if(pawn == NULL)
+            return;
+        PlayerInfo* info = pawn->getPlayer();
+        if(info == NULL)
+            return;
+        unsigned int clientId = info->getClientID();
+
+        uint64_t index = 0;
+        if(pickedUp)
+        {
+            index = this->getPickupIndex();
+            this->indexes_[pickup] = index;
+            this->pickups_[index] = new WeakPtr<Pickupable>(pickup);
+        }
+        else
+        {
+            std::map<Pickupable*, uint64_t>::iterator it = this->indexes_.find(pickup);
+            index = it->second;
+            WeakPtr<Pickupable>* ptr = this->pickups_[index];
+            this->indexes_.erase(it);
+            this->pickups_.erase(index);
+            delete ptr;
+        }
+
+        if(GameMode::isStandalone() || Host::getPlayerID() == clientId)
+        {
+            PickupManager::pickupChangedPickedUpNetwork(index, pickup->isUsable(), this->representations_[pickup->getPickupIdentifier()]->getObjectID(), pickedUp);
+        }
+        else
+        {
+            callStaticNetworkFunction(PickupManager::pickupChangedPickedUpNetwork, clientId, index, pickup->isUsable(), this->representations_[pickup->getPickupIdentifier()]->getObjectID(), pickedUp);
+        }
+
+    }
+
+    /*static*/ void PickupManager::pickupChangedPickedUpNetwork(uint64_t pickup, bool usable, uint32_t representationObjectId, bool pickedUp)
+    {
+        PickupManager& manager = PickupManager::getInstance();
+        if(pickedUp)
+        {
+            PickupInventoryContainer* container = new PickupInventoryContainer;
+            container->pickup = pickup;
+            container->inUse = false;
+            container->pickedUp = pickedUp;
+            container->usable = usable;
+            container->unusable = false;
+            container->representationObjectId = representationObjectId;
+            manager.pickupInventoryContainers_.insert(std::pair<uint64_t, PickupInventoryContainer*>(pickup, container));
+
+            if(GameMode::showsGraphics())
+            {
+                if(!manager.guiLoaded_)
+                {
+                    GUIManager::getInstance().loadGUI(PickupManager::guiName_s);
+                    manager.guiLoaded_ = true;
+                }
+                GUIManager::getInstance().getLuaState()->doString(PickupManager::guiName_s + ".update()");
+            }
+        }
+        else
+        {
+            std::map<uint64_t, PickupInventoryContainer*>::iterator it = manager.pickupInventoryContainers_.find(pickup);
+            if(it != manager.pickupInventoryContainers_.end())
+                delete it->second;
+            manager.pickupInventoryContainers_.erase(pickup);
+
+            manager.updateGUI();
+        }
+    }
+
+    inline void PickupManager::updateGUI(void)
+    {
+        if(GameMode::showsGraphics())
+        {
+            if(!this->guiLoaded_)
+            {
+                GUIManager::getInstance().loadGUI(PickupManager::guiName_s);
+                this->guiLoaded_ = true;
+            }
+            GUIManager::getInstance().getLuaState()->doString(PickupManager::guiName_s + ".update()");
+        }
+    }
+
+    uint64_t PickupManager::getPickupIndex(void)
+    {
+        if(this->pickupIndex_ == uint64_t(~0x0)-1)
+            this->pickupIndex_ = 0;
+        return this->pickupIndex_++;
     }
 
Index: code/trunk/src/modules/pickup/PickupManager.h
===================================================================
--- code/trunk/src/modules/pickup/PickupManager.h	(revision 7494)
+++ code/trunk/src/modules/pickup/PickupManager.h	(revision 7504)
@@ -39,13 +39,28 @@
 
 #include <map>
-#include "util/Singleton.h"
+
 #include "core/WeakPtr.h"
+
 #include "pickup/PickupIdentifier.h"
+
 #include "PickupRepresentation.h"
 
-#include "core/OrxonoxClass.h"
+#include "util/Singleton.h"
+#include "interfaces/PickupListener.h"
 
 namespace orxonox // tolua_export
 { // tolua_export
+
+    // tolua_begin
+    struct PickupInventoryContainer
+    {
+        uint64_t pickup;
+        bool inUse;
+        bool pickedUp;
+        bool usable;
+        bool unusable;
+        uint32_t representationObjectId;
+    };
+    // tolua_end
 
     /**
@@ -57,5 +72,5 @@
     */
     class _PickupExport PickupManager // tolua_export
-        : public Singleton<PickupManager>, public OrxonoxClass
+        : public Singleton<PickupManager>, public PickupListener
     { // tolua_export
         friend class Singleton<PickupManager>;
@@ -68,9 +83,11 @@
 
             bool registerRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation); //!< Registers a PickupRepresentation together with the PickupIdentifier of the Pickupable the PickupRepresentation represents.
+            bool registerRepresentation(PickupRepresentation* representation);
             bool unregisterRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation); //!< Unegisters a PickupRepresentation together with the PickupIdentifier of the Pickupable the PickupRepresentation represents.
+            bool unregisterRepresentation(PickupRepresentation* representation);
             PickupRepresentation* getRepresentation(const PickupIdentifier* identifier); //!< Get the PickupRepresentation representing the Pickupable with the input PickupIdentifier.
 
             // tolua_begin
-            orxonox::PickupRepresentation* getPickupRepresentation(orxonox::Pickupable* pickup); //!< Get the PickupRepresentation of an input Pickupable.
+            orxonox::PickupRepresentation* getPickupRepresentation(uint64_t pickup); //!< Get the PickupRepresentation of an input Pickupable.
 
             int getNumPickups(void); //!< Update the list of picked up Pickupables and get the number of Pickupables in the list.
@@ -80,22 +97,37 @@
             @return Returns the next Pickupable in the list.
             */
-            orxonox::Pickupable* popPickup(void) { return (this->pickupsIterator_++)->first; }
+            orxonox::PickupInventoryContainer* popPickup(void) { return (this->pickupsIterator_++)->second; }
 
-            void dropPickup(orxonox::Pickupable* pickup); //!< Drop the input Pickupable.
-            void usePickup(orxonox::Pickupable* pickup, bool use); //!< Use (or unuse) the input Pickupable.
-            bool isValidPickup(orxonox::Pickupable* pickup); //!< Check whether the input Pickupable is valid, meaning that it is in the PickupManager's list and still exists.
+            void dropPickup(uint64_t pickup); //!< Drop the input Pickupable.
+            void usePickup(uint64_t pickup, bool use); //!< Use (or unuse) the input Pickupable.
+            bool isValidPickup(uint64_t pickup); //!< Check whether the input Pickupable is valid, meaning that it is in the PickupManager's list and still exists.
             // tolua_end
+
+            static void dropPickupNetworked(uint64_t pickup);
+            static void usePickupNetworked(uint64_t pickup, bool use);
+
+            virtual void pickupChangedUsed(Pickupable* pickup, bool used);
+            static void pickupChangedUsedNetwork(uint64_t pickup, bool inUse, bool usable, bool unusable);
+            virtual void pickupChangedPickedUp(Pickupable* pickup, bool pickedUp);
+            static void pickupChangedPickedUpNetwork(uint64_t pickup, bool usable, uint32_t representationObjectId, bool pickedUp);
 
         private:
             static PickupManager* singletonPtr_s;
             static const std::string guiName_s; //!< The name of the PickupInventory
+            bool guiLoaded_;
+            uint64_t pickupIndex_;
 
             PickupRepresentation* defaultRepresentation_; //!< The default PickupRepresentation.
             std::map<const PickupIdentifier*, PickupRepresentation*, PickupIdentifierCompare> representations_; //!< Map linking PickupIdentifiers (representing types if Pickupables) and PickupRepresentations.
+            std::map<uint32_t, PickupRepresentation*> representationsNetworked_;
 
-            std::map<Pickupable*, WeakPtr<Pickupable> > pickupsList_; //!< A list of all the picked up Pickupables.
-            std::map<Pickupable*, WeakPtr<Pickupable> >::iterator pickupsIterator_; //!< An iterator pointing to the current Pickupable in pickupsList_.
+            std::map<uint64_t, PickupInventoryContainer*> pickupInventoryContainers_;
+            std::map<uint64_t, PickupInventoryContainer*>::iterator pickupsIterator_; //!< An iterator pointing to the current Pickupable in pickupsList_.
 
-            std::vector<PickupCarrier*>* getAllCarriers(PickupCarrier* carrier, std::vector<PickupCarrier*>* carriers = NULL); //!< Helper method. Get all the PickupCarriers that carry Pickupables, recursively.
+            std::map<uint64_t, WeakPtr<Pickupable>*> pickups_;
+            std::map<Pickupable*, uint64_t> indexes_;
+
+            void updateGUI(void);
+            uint64_t getPickupIndex(void);
 
     }; // tolua_export
Index: code/trunk/src/modules/pickup/PickupRepresentation.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupRepresentation.cc	(revision 7494)
+++ code/trunk/src/modules/pickup/PickupRepresentation.cc	(revision 7504)
@@ -35,4 +35,5 @@
 
 #include "core/CoreIncludes.h"
+#include "core/GameMode.h"
 #include "graphics/Billboard.h"
 #include "util/StringUtils.h"
@@ -49,9 +50,10 @@
         This is primarily for use of the PickupManager in creating a default PickupRepresentation.
     */
-    PickupRepresentation::PickupRepresentation() : BaseObject(NULL), spawnerRepresentation_(NULL), pickup_(NULL)
+    PickupRepresentation::PickupRepresentation() : BaseObject(NULL), Synchronisable(NULL), spawnerRepresentation_(NULL), pickup_(NULL)
     {
         RegisterObject(PickupRepresentation);
 
         this->initialize();
+        this->setSyncMode(0x0);
     }
 
@@ -60,9 +62,12 @@
         Default Constructor. Registers the object and initializes its member variables.
     */
-    PickupRepresentation::PickupRepresentation(BaseObject* creator) : BaseObject(creator), spawnerRepresentation_(NULL), pickup_(NULL)
+    PickupRepresentation::PickupRepresentation(BaseObject* creator) : BaseObject(creator), Synchronisable(creator), spawnerRepresentation_(NULL), pickup_(NULL)
     {
         RegisterObject(PickupRepresentation);
 
         this->initialize();
+        this->registerVariables();
+
+        PickupManager::getInstance().registerRepresentation(this); //!< Registers the PickupRepresentation with the PickupManager.
     }
 
@@ -76,6 +81,15 @@
             this->spawnerRepresentation_->destroy();
 
-        if(this->pickup_ != NULL)
-            PickupManager::getInstance().unregisterRepresentation(this->pickup_->getPickupIdentifier(), this);
+        if(this->isInitialized())
+        {
+            if(GameMode::isMaster() && this->pickup_ != NULL)
+            {
+                PickupManager::getInstance().unregisterRepresentation(this->pickup_->getPickupIdentifier(), this);
+            }
+            if(!GameMode::isMaster())
+            {
+                PickupManager::getInstance().unregisterRepresentation(this);
+            }
+        }
     }
 
@@ -90,4 +104,11 @@
         this->spawnerTemplate_ = "";
         this->inventoryRepresentation_ = "Default";
+    }
+
+    void PickupRepresentation::registerVariables(void)
+    {
+        registerVariable(this->description_, VariableDirection::ToClient);
+        registerVariable(this->name_, VariableDirection::ToClient);
+        registerVariable(this->inventoryRepresentation_, VariableDirection::ToClient);
     }
 
@@ -107,5 +128,8 @@
         XMLPortObject(PickupRepresentation, StaticEntity, "spawner-representation", setSpawnerRepresentation, getSpawnerRepresentationIndex, xmlelement, mode);
 
-        PickupManager::getInstance().registerRepresentation(this->pickup_->getPickupIdentifier(), this); //!< Registers the PickupRepresentation with the PickupManager through the PickupIdentifier of the Pickupable it represents.
+        if(GameMode::isMaster())
+        {
+            PickupManager::getInstance().registerRepresentation(this->pickup_->getPickupIdentifier(), this); //!< Registers the PickupRepresentation with the PickupManager through the PickupIdentifier of the Pickupable it represents.
+        }
 
         if(this->spawnerRepresentation_ != NULL)
Index: code/trunk/src/modules/pickup/PickupRepresentation.h
===================================================================
--- code/trunk/src/modules/pickup/PickupRepresentation.h	(revision 7494)
+++ code/trunk/src/modules/pickup/PickupRepresentation.h	(revision 7504)
@@ -45,4 +45,5 @@
 
 #include "core/BaseObject.h"
+#include "network/synchronisable/Synchronisable.h"
 
 namespace orxonox // tolua_export
@@ -55,5 +56,5 @@
     */
     class _PickupExport PickupRepresentation // tolua_export
-        : public BaseObject
+        : public BaseObject, public Synchronisable
     { // tolua_export
 
@@ -146,4 +147,6 @@
             StaticEntity* getDefaultSpawnerRepresentation(PickupSpawner* spawner); //!< Get the default spawnerRepresentation for a specific PickupSpawner.
 
+            void registerVariables(void); //!< Register some variables for synchronisation.
+
             std::string name_; //!< The name of the Pickupable represented by this PickupRepresentation.
             std::string description_; //!< The description of the Pickupable represented by this PickupRepresentation.
