Index: /code/trunk/src/modules/pickup/PickupCollection.cc
===================================================================
--- /code/trunk/src/modules/pickup/PickupCollection.cc	(revision 6537)
+++ /code/trunk/src/modules/pickup/PickupCollection.cc	(revision 6538)
@@ -28,17 +28,15 @@
 
 /**
-    @file
+    @file PickupCollection.cc
     @brief Implementation of PickupCollection.
 */
 
-#include "PickupCollection.h"
-
 #include "core/CoreIncludes.h"
-#include "core/Template.h"
 #include "core/XMLPort.h"
 #include "interfaces/PickupCarrier.h"
 #include "DroppedPickup.h"
-
 #include "PickupCollectionIdentifier.h"
+
+#include "PickupCollection.h"
 
 namespace orxonox
@@ -60,5 +58,5 @@
     /**
     @brief
-        Destructor.
+        Destructor. Iterates through all Pickupables this PickupCollection consists of and destroys them if they haven't been already.
     */
     PickupCollection::~PickupCollection()
@@ -85,4 +83,8 @@
     }
     
+    /**
+    @brief
+        Initializes the PickupIdentifier for this pickup.
+    */
     void PickupCollection::initializeIdentifier(void)
     {
@@ -93,4 +95,139 @@
     }
     
+    /**
+    @brief
+        Is called when the pickup has transited from used to unused or the other way around.
+        Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedUsed); to their changdeUsed method.
+    */
+    void PickupCollection::changedUsed(void)
+    {
+        SUPER(PickupCollection, changedUsed);
+        
+        //! Change used for all Pickupables this PickupCollection consists of.
+        for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            (*it).get()->setUsed(this->isUsed());
+        }
+    }
+    
+    /**
+    @brief
+        Is called when the pickup has changed its PickupCarrier.
+        Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedCarrier); to their changedCarrier method.
+    */
+    void PickupCollection::changedCarrier(void)
+    {
+        SUPER(PickupCollection, changedCarrier);
+        
+        //! Change the PickupCarrier for all Pickupables this PickupCollection consists of.
+        for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            (*it).get()->setCarrier(this->getCarrier());
+        }
+    }
+    
+    /**
+    @brief
+        Is called when the pickup has transited from picked up to dropped or the other way around.
+        Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedPickedUp); to their changedPickedUp method.
+    */
+    void PickupCollection::changedPickedUp()
+    {
+        SUPER(PickupCollection, changedPickedUp);
+        
+        //! Change the pickedUp status for all Pickupables this PickupCollection consists of.
+        for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            (*it).get()->setPickedUp(this->isPickedUp());
+        }
+    }
+    
+    /**
+    @brief
+        Creates a duplicate of the input OrxonoxClass.
+        This method needs to be implemented by any Class inheriting from Pickupable.
+    @param item
+        A reference to a pointer to the OrxonoxClass that is to be duplicated.
+    */
+    void PickupCollection::clone(OrxonoxClass*& item)
+    {
+        if(item == NULL)
+            item = new PickupCollection(this);
+        
+        SUPER(PickupCollection, clone, item);
+        
+        PickupCollection* pickup = dynamic_cast<PickupCollection*>(item);
+        //! Clone allPickupables this PickupCollection consist of.
+        for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            Pickupable* newPickup = (*it).get()->clone();
+            pickup->addPickupable(newPickup);
+        }
+
+        pickup->initializeIdentifier();
+    }
+    
+    /**
+    @brief
+        Get whether a given class, represented by the input Identifier, is a target of this PickupCollection.
+    @param identifier
+        A pointer to the PickupIdentifier of the PickupCarrier we want to know of, whether it is a target of this PickupCollection.
+    @return
+        Returns true if the PickupCarrier identified by the input PickupIdentififer it is a target of this PickupCollection, false if not.
+    */
+    bool PickupCollection::isTarget(Identifier* identifier) const
+    {
+        for(std::vector<WeakPtr<Pickupable> >::const_iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            if(!(*it).get()->isTarget(identifier))
+                return false;
+        }
+        
+        return true;
+    }
+    
+    /**
+    @brief
+        Get the PickupIdentifier of this PickupCollection.
+        This is in fact the PickupCollectionIdentifier.
+    @return
+        Returns a pointer to the PickupIdentifier of this PickupCollection.
+    */
+    const PickupIdentifier* PickupCollection::getPickupIdentifier(void)
+    {
+        return this->pickupCollectionIdentifier_;
+    }
+    
+    /**
+    @brief
+        Add the input Pickupable to list of Pickupables combined by this PickupCollection.
+    @param pickup
+        The Pickupable to be added.
+    @return
+        Returns true if successful,
+    */
+    bool PickupCollection::addPickupable(Pickupable* pickup)
+    {
+        if(pickup == NULL)
+            return false;
+        
+        WeakPtr<Pickupable> ptr = pickup; //!< Create a weak pointer to be able to test in the constructor if the Pointer is still valid.
+        this->pickups_.push_back(ptr);
+        return true;
+    }
+    
+    /**
+    @brief
+        Get the Pickupable at the given index.
+    @param index
+        The index the Pickupable is fetched from.
+    @return
+        Returns a pointer to the Pickupable at the index given by index.
+    */
+    const Pickupable* PickupCollection::getPickupable(unsigned int index)
+    {
+        return this->pickups_[index].get();
+    }
+        
     /**
     @brief
@@ -109,100 +246,3 @@
     }
     
-    /**
-    @brief
-        Add the input Pickupable to list of Pickupables combined by this PickupCollection.
-    @param pickup
-        The Pickupable to be added.
-    @return
-        Returns true if successful,
-    */
-    bool PickupCollection::addPickupable(Pickupable* pickup)
-    {
-        if(pickup == NULL)
-            return false;
-        
-        WeakPtr<Pickupable> ptr = pickup;
-        this->pickups_.push_back(ptr);
-        return true;
-    }
-    
-    /**
-    @brief
-        Get the Pickupable at the given index.
-    @param index
-        The index the Pickupable is fetched from.
-    @return
-        Returns a pointer to the Pickupable at the index given by index.
-    */
-    const Pickupable* PickupCollection::getPickupable(unsigned int index)
-    {
-        return this->pickups_[index].get(); //TODO. Does this work?
-    }
-    
-    void PickupCollection::changedUsed(void)
-    {
-        SUPER(PickupCollection, changedUsed);
-        
-        //! Change used for all Pickupables this PickupCollection consists of.
-        for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
-        {
-            (*it).get()->setUsed(this->isUsed());
-        }
-    }
-    
-    void PickupCollection::changedCarrier(void)
-    {
-        SUPER(PickupCollection, changedCarrier);
-        
-        //! Change used for all Pickupables this PickupCollection consists of.
-        for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
-        {
-            (*it).get()->setCarrier(this->getCarrier());
-        }
-    }
-    
-    void PickupCollection::changedPickedUp()
-    {
-        SUPER(PickupCollection, changedPickedUp);
-        
-        //! Change the carrier for all Pickupables this PickupCollection consists of.
-        for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
-        {
-            (*it).get()->setPickedUp(this->isPickedUp());
-        }
-    }
-    
-    void PickupCollection::clone(OrxonoxClass*& item)
-    {
-        if(item == NULL)
-            item = new PickupCollection(this);
-        
-        SUPER(PickupCollection, clone, item);
-        
-        PickupCollection* pickup = dynamic_cast<PickupCollection*>(item);
-        for(std::vector<WeakPtr<Pickupable> >::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
-        {
-            Pickupable* newPickup = (*it).get()->clone();
-            pickup->addPickupable(newPickup);
-        }
-
-        pickup->initializeIdentifier();
-    }
-    
-    bool PickupCollection::isTarget(Identifier* identifier) const
-    {
-        for(std::vector<WeakPtr<Pickupable> >::const_iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
-        {
-            if(!(*it).get()->isTarget(identifier))
-                return false;
-        }
-        
-        return true;
-    }
-    
-    const PickupIdentifier* PickupCollection::getPickupIdentifier(void)
-    {
-        return this->pickupCollectionIdentifier_;
-    }
-    
 }
Index: /code/trunk/src/modules/pickup/PickupCollection.h
===================================================================
--- /code/trunk/src/modules/pickup/PickupCollection.h	(revision 6537)
+++ /code/trunk/src/modules/pickup/PickupCollection.h	(revision 6538)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file PickupCollection.h
+    @brief Declaration of PickupCollection.
+*/
+
 #ifndef _PickupCollection_H__
 #define _PickupCollection_H__
@@ -34,5 +39,4 @@
 #include "interfaces/Pickupable.h"
 #include "core/BaseObject.h"
-#include "core/XMLPort.h"
 
 #include <list>
@@ -52,32 +56,32 @@
         public:
             
-            PickupCollection(BaseObject* creator);
-            virtual ~PickupCollection();
+            PickupCollection(BaseObject* creator); //!< Default Constructor.
+            virtual ~PickupCollection(); //!< Destructor.
             
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Creates an instance of this Class through XML.
 
-            virtual void changedUsed(void);
-            virtual void changedCarrier(void);
-            virtual void changedPickedUp(void);
+            virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
+            virtual void changedCarrier(void); //!< Is called when the pickup has changed its PickupCarrier.
+            virtual void changedPickedUp(void); //!< Is called when the pickup has transited from picked up to dropped or the other way around.
             
-            virtual void clone(OrxonoxClass*& item);
+            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
             
-            virtual bool isTarget(Identifier* identifier) const;
+            virtual bool isTarget(Identifier* identifier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this PickupCollection.
             
-            virtual const PickupIdentifier* getPickupIdentifier(void);
+            virtual const PickupIdentifier* getPickupIdentifier(void); //!< Get the PickupIdentifier of this PickupCollection.
             
-            bool addPickupable(Pickupable* pickup);
-            const Pickupable* getPickupable(unsigned int index);
+            bool addPickupable(Pickupable* pickup); //!< Add the input Pickupable to list of Pickupables combined by this PickupCollection.
+            const Pickupable* getPickupable(unsigned int index); //!< Get the Pickupable at the given index.
             
         protected:
-            void initializeIdentifier(void);
+            void initializeIdentifier(void); //!< Initializes the PickupIdentifier for this pickup.
             
             virtual bool createSpawner(const Vector3& position); //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
             
-            PickupCollectionIdentifier* pickupCollectionIdentifier_;
+            PickupCollectionIdentifier* pickupCollectionIdentifier_; //!< The PickupCollectionIdentifier of this PickupCollection. Is used to distinguish different PickupCollections amongst themselves.
             
         private:
             
-            std::vector<WeakPtr<Pickupable> > pickups_;
+            std::vector<WeakPtr<Pickupable> > pickups_; //!< The list of the pointers of all the Pickupables this PickupCollection consists of. They are weak pointers to facilitate testing, whether the pointers are still valid.
         
     };
Index: /code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc
===================================================================
--- /code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc	(revision 6537)
+++ /code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc	(revision 6538)
@@ -21,5 +21,5 @@
  *
  *   Author:
- *      ...
+ *      Damian 'Mozork' Frick
  *   Co-authors:
  *      ...
@@ -27,11 +27,20 @@
 */
 
-#include "PickupCollectionIdentifier.h"
+/**
+    @file PickupCollectionIdentifier.cc
+    @brief Implementation of PickupCollectionIdentifier.
+*/
 
 #include "core/CoreIncludes.h"
+
+#include "PickupCollectionIdentifier.h"
 
 namespace orxonox
 {
     
+    /**
+    @brief
+        Constructor. Registers the object.
+    */
     PickupCollectionIdentifier::PickupCollectionIdentifier(Pickupable* pickup) : PickupIdentifier(pickup)
     {
@@ -39,4 +48,8 @@
     }
     
+    /**
+    @brief
+        Destructor.
+    */
     PickupCollectionIdentifier::~PickupCollectionIdentifier()
     {
@@ -44,8 +57,19 @@
     }
 
+    /**
+    @brief
+        Compares a PickupCollectionIdentifier with a PickupIdentifier and returns 0 if a == b, <0 if a < b and >0 if a > b for a.compare(b), where a is a PickupCollectionIdentifier and b is just some PickupIdentifier.
+    @param identifier
+        Pointer to the second PickupIdentifier, b.
+    @return
+        Returns an integer. 0 if the two compared PickupIdentifiers are the same, <0 if a < b and >0 if a > b.
+    */
     int PickupCollectionIdentifier::compare(const PickupIdentifier* identifier) const
     {
+        //! Slight un-niceity to cast the PickupIdentifier to a PickupCollectionIdentifier.
         PickupIdentifier* temp = const_cast<PickupIdentifier*>(identifier);
         const PickupCollectionIdentifier* collectionIdentifier = dynamic_cast<PickupCollectionIdentifier*>(temp);
+        
+        //! If the input PickupIdentifier 'identifier' is no PickupCollectionIdentifier then just the two PickupIdentifiers are compared.
         if(collectionIdentifier == NULL)
         {
@@ -53,7 +77,9 @@
         }
         
+        //! If the number of Pickupables each of the two PickupCollectionIdentifiers contain differ, the one with less is considered smaller.
         if(this->identifiers_.size() != collectionIdentifier->identifiers_.size())
             return this->identifiers_.size()-collectionIdentifier->identifiers_.size();
         
+        //! Compare the Pickupables of the two PickupCollectionIdentifiers one after the other. the one with the first 'smaller' one is considered smaller.
         std::set<const PickupIdentifier*, PickupIdentifierCompare>::const_iterator it2 = collectionIdentifier->identifiers_.begin();
         for(std::set<const PickupIdentifier*, PickupIdentifierCompare>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); it++)
@@ -66,7 +92,14 @@
         }
         
+        //! Means they are equal.
         return 0;
     }
     
+    /**
+    @brief
+        Add a Pickupable to the PickupCollectionIdentifier.
+    @param
+        A pointer to the PickupIdentifier of the Pickupable to be added.
+    */
     void PickupCollectionIdentifier::addPickup(const PickupIdentifier* identifier)
     {
Index: /code/trunk/src/modules/pickup/PickupCollectionIdentifier.h
===================================================================
--- /code/trunk/src/modules/pickup/PickupCollectionIdentifier.h	(revision 6537)
+++ /code/trunk/src/modules/pickup/PickupCollectionIdentifier.h	(revision 6538)
@@ -21,8 +21,13 @@
  *
  *   Author:
- *      ...
+ *      Damian 'Mozork' Frick
  *   Co-authors:
  *      ...
  *
+*/
+
+/**
+    @file PickupCollectionIdentifier.h
+    @brief Declaration of PickupCollectionIdentifier.
 */
 
@@ -33,4 +38,5 @@
 
 #include "pickup/PickupIdentifier.h"
+
 #include <set>
 
@@ -38,17 +44,25 @@
 {
 
+    /**
+    @brief
+        The PickupCollectionIdentifier is the specialization of the PickupIdentifier for the PickupCollection class.
+        It identifies PickupCollections based on the different Pickupables they consist of.
+        Pickupables can be added to the PickupCollectionIdentifier via the addPickup method.
+    @author
+        Damian 'Mozork' Frick
+    */
     class _PickupExport PickupCollectionIdentifier : public PickupIdentifier
     {
         
         public:
-            PickupCollectionIdentifier(Pickupable* pickup);
-            ~PickupCollectionIdentifier();
+            PickupCollectionIdentifier(Pickupable* pickup); //!< Constructor.
+            ~PickupCollectionIdentifier(); //!< Destructor.
             
-            virtual int compare(const PickupIdentifier* identifier) const;
+            virtual int compare(const PickupIdentifier* identifier) const; //!< Compares a PickupCollectionIdentifier with a PickupIdentifier.
             
-            void addPickup(const PickupIdentifier* identifier);
+            void addPickup(const PickupIdentifier* identifier); //!< Add a Pickupable to the PickupCollectionIdentifier.
             
         private:
-            std::set<const PickupIdentifier*, PickupIdentifierCompare> identifiers_;
+            std::set<const PickupIdentifier*, PickupIdentifierCompare> identifiers_; //!< The set of PickupIdentifiers of the Pickupables the PickupCollection with this PickupCollectionIdentifier consists of, ordered by the rule set by PickupIdentifierCompare.
             
     };
Index: /code/trunk/src/modules/pickup/items/MetaPickup.cc
===================================================================
--- /code/trunk/src/modules/pickup/items/MetaPickup.cc	(revision 6537)
+++ /code/trunk/src/modules/pickup/items/MetaPickup.cc	(revision 6538)
@@ -28,5 +28,5 @@
 
 /**
-    @file
+    @file MetaPickup.cc
     @brief Implementation of the MetaPickup class.
 */
@@ -43,4 +43,5 @@
     CreateFactory(MetaPickup);
     
+    //! Setting the static variables to their values.
     /*static*/ const std::string MetaPickup::metaTypeNone_s = "none";
     /*static*/ const std::string MetaPickup::metaTypeUse_s = "use";
@@ -49,5 +50,5 @@
     /**
     @brief
-        Constructor. 
+        Constructor. Registers and initializes the object.
     */
     MetaPickup::MetaPickup(BaseObject* creator) : Pickup(creator)
@@ -55,5 +56,24 @@
         RegisterObject(MetaPickup);
         
+        this->initialize();
+    }
+    
+    /**
+    @brief
+        Destructor.
+    */
+    MetaPickup::~MetaPickup()
+    {
+        
+    }
+    
+    /**
+    @brief
+        Initializes the object.
+    */
+    void MetaPickup::initialize(void)
+    {
         this->addTarget(ClassIdentifier<PickupCarrier>::getIdentifier());
+        
         this->setActivationTypeDirect(pickupActivationType::immediate);
         this->setDurationTypeDirect(pickupDurationType::once);
@@ -61,9 +81,8 @@
     }
     
-    MetaPickup::~MetaPickup()
-    {
-        
-    }
-    
+    /**
+    @brief
+        Helper method to initialize the PickupIdentifier.
+    */
     void MetaPickup::initializeIdentifier(void)
     {
@@ -73,4 +92,8 @@
     }
     
+    /**
+    @brief
+        Method for creating a MetaPickup object through XML.
+    */
     void MetaPickup::XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode)
     {
@@ -82,8 +105,14 @@
     }
     
+    /**
+    @brief
+        Is called when the pickup has transited from used to unused or the other way around.
+        Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedUsed); to their changdeUsed method.
+    */
     void MetaPickup::changedUsed(void)
     {
         SUPER(MetaPickup, changedUsed);
         
+        //! If the MetaPickup transited to used.
         if(this->isUsed())
         {
@@ -92,4 +121,5 @@
             {
                 std::set<Pickupable*> pickups = carrier->getPickups();
+                //! Set all Pickupables carried by the PickupCarrier either to used or drop them, depending o the meta type.
                 for(std::set<Pickupable*>::iterator it = pickups.begin(); it != pickups.end(); it++)
                 {
@@ -114,5 +144,30 @@
         }
     }
-    
+        
+    /**
+    @brief
+        Creates a duplicate of the input OrxonoxClass.
+    @param item
+        A pointer to the Orxonox class.
+    */
+    void MetaPickup::clone(OrxonoxClass*& item)
+    {
+        if(item == NULL)
+            item = new MetaPickup(this);
+        
+        SUPER(MetaPickup, clone, item);
+        
+        MetaPickup* pickup = dynamic_cast<MetaPickup*>(item);
+        pickup->setMetaTypeDirect(this->getMetaTypeDirect());
+        
+        pickup->initializeIdentifier();
+    }
+    
+    /**
+    @brief
+        Get the meta type of this MetaPickup.
+    @return
+        Returns a string with the meta type of the MetaPickup.
+    */
     const std::string& MetaPickup::getMetaType(void)
     {
@@ -130,4 +185,10 @@
     }
     
+    /**
+    @brief
+        Set the meta type of this MetaPickup.
+    @param type
+        A string with the type to be set.
+    */
     void MetaPickup::setMetaType(const std::string& type)
     {
@@ -146,16 +207,3 @@
     }
     
-    void MetaPickup::clone(OrxonoxClass*& item)
-    {
-        if(item == NULL)
-            item = new MetaPickup(this);
-        
-        SUPER(MetaPickup, clone, item);
-        
-        MetaPickup* pickup = dynamic_cast<MetaPickup*>(item);
-        pickup->setMetaTypeDirect(this->getMetaTypeDirect());
-        
-        pickup->initializeIdentifier();
-    }
-    
 }
Index: /code/trunk/src/modules/pickup/items/MetaPickup.h
===================================================================
--- /code/trunk/src/modules/pickup/items/MetaPickup.h	(revision 6537)
+++ /code/trunk/src/modules/pickup/items/MetaPickup.h	(revision 6538)
@@ -28,5 +28,5 @@
 
 /**
-    @file
+    @file MetaPickup.h
     @brief Definition of the MetaPickup class.
 */
@@ -62,27 +62,38 @@
         
         public:
-            MetaPickup(BaseObject* creator);
-            virtual ~MetaPickup();
+            MetaPickup(BaseObject* creator); //!< Constructor. Registers and initializes the object.
+            virtual ~MetaPickup(); //!< Destructor.
             
-            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a HealthPickup object through XML.
+            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a MetaPickup object through XML.
             
             virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
             virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
             
+            /**
+            @brief Returns the meta type of the MetaPickup.
+            @return Returns an enum with the meta type of the MetaPickup.
+            */
             inline pickupMetaType::Value getMetaTypeDirect(void)
                 { return this->metaType_; }
-            const std::string& getMetaType(void);
+            const std::string& getMetaType(void); //!< Get the meta type of this MetaPickup.
             
         protected:
+            void initialize(void); //!< Initializes the object.
             void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
             
+            /**
+            @brief Set the meta type of the MetaPickup.
+            @param type The meta type as an enum.
+            */
             inline void setMetaTypeDirect(pickupMetaType::Value type)
                 { this->metaType_ =  type; }
-            void setMetaType(const std::string& type);
+            void setMetaType(const std::string& type); //!< Set the meta type of this MetaPickup.
             
         private:
             void initialize(void); //!< Initializes the member variables.
             
-            pickupMetaType::Value metaType_;
+            pickupMetaType::Value metaType_; //!< The meta type of the MetaPickup, determines which actions are taken.
+            
+            //! Static strings for the meta types.
             static const std::string metaTypeNone_s;
             static const std::string metaTypeUse_s;
Index: /code/trunk/src/orxonox/interfaces/Pickupable.cc
===================================================================
--- /code/trunk/src/orxonox/interfaces/Pickupable.cc	(revision 6537)
+++ /code/trunk/src/orxonox/interfaces/Pickupable.cc	(revision 6538)
@@ -28,5 +28,5 @@
 
 /**
-    @file
+    @file Pickupable.cc
     @brief Implementation of the Pickupable class.
 */
@@ -96,7 +96,7 @@
     /**
     @brief
-        Get whether the given PickupCarrier is a target of this pickup.
+        Get whether the given PickupCarrier is a target of this Pickupable.
     @param carrier
-        The PickupCarrier of which it has to be determinde whether it is a target of this pickup.
+        The PickupCarrier of which it has to be determinde whether it is a target of this Pickupable.
     @return
         Returns true if the given PickupCarrier is a target.
@@ -109,7 +109,7 @@
     /**
     @brief
-        Get whether a given class, represented by the input Identifier, is a target of this pickup.
+        Get whether a given class, represented by the input Identifier, is a target of this Pickupable.
     @param target
-        The Identifier of which it has to be determinde whether it is a target of this pickup.
+        The Identifier of which it has to be determinde whether it is a target of this Pickupable.
     @return
         Returns true if the given Identifier is a target.
@@ -128,5 +128,5 @@
     /**
     @brief
-        Add a PickupCarrier as target of this pickup.
+        Add a PickupCarrier as target of this Pickupable.
     @param target
         The PickupCarrier to be added.
@@ -141,5 +141,5 @@
     /**
     @brief
-        Add a class, representetd by the input Identifier, as target of this pickup.
+        Add a class, representetd by the input Identifier, as target of this Pickupable.
     @param target
         The Identifier to be added.
@@ -199,5 +199,5 @@
     /**
     @brief
-        Sets the carrier of the pickup.
+        Sets the carrier of the Pickupable.
     @param carrier
         Sets the input PickupCarrier as the carrier of the pickup.
@@ -265,5 +265,5 @@
         This method needs to be implemented by any Class inheriting from Pickupable.
     @param item
-        A pointer to the OrxonoxClass that is to be duplicated.
+        A reference to a pointer to the OrxonoxClass that is to be duplicated.
     */
     //TODO: Specify how the implementation must be done in detail.
Index: /code/trunk/src/orxonox/interfaces/Pickupable.h
===================================================================
--- /code/trunk/src/orxonox/interfaces/Pickupable.h	(revision 6537)
+++ /code/trunk/src/orxonox/interfaces/Pickupable.h	(revision 6538)
@@ -28,5 +28,5 @@
 
 /**
-    @file
+    @file Pickupable.h
     @brief Definition of the Pickupable class.
 */
@@ -100,5 +100,5 @@
             
             bool isTarget(const PickupCarrier* carrier) const; //!< Get whether the given PickupCarrier is a target of this pickup.
-            virtual bool isTarget(Identifier* identifier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this pickup.
+            virtual bool isTarget(Identifier* identifier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this Pickupable.
             bool addTarget(PickupCarrier* target); //!< Add a PickupCarrier as target of this pickup.
             bool addTarget(Identifier* identifier); //!< Add a class, representetd by the input Identifier, as target of this pickup.
@@ -123,5 +123,4 @@
             @brief Helper method to initialize the PickupIdentifier.
             */
-            //TODO: Really needed?
             void initializeIdentifier(void) {}
             
