Index: code/branches/pickup3/src/orxonox/interfaces/InterfaceCompilation.cc
===================================================================
--- code/branches/pickup3/src/orxonox/interfaces/InterfaceCompilation.cc	(revision 6466)
+++ code/branches/pickup3/src/orxonox/interfaces/InterfaceCompilation.cc	(revision 6474)
@@ -59,4 +59,15 @@
     {
         RegisterRootObject(PickupCarrier);
+        
+    }
+    
+    PickupCarrier::~PickupCarrier()
+    {
+        for(std::set<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            (*it)->destroy();
+        }
+        
+        this->pickups_.clear();
     }
 
Index: code/branches/pickup3/src/orxonox/interfaces/PickupCarrier.h
===================================================================
--- code/branches/pickup3/src/orxonox/interfaces/PickupCarrier.h	(revision 6466)
+++ code/branches/pickup3/src/orxonox/interfaces/PickupCarrier.h	(revision 6474)
@@ -36,29 +36,46 @@
 
 #include "OrxonoxPrereqs.h"
-#include "core/OrxonoxClass.h"
+
+#include <list>
+#include <set>
 #include "Pickupable.h"
 
-#include <set>
-#include <list>
+#include "core/OrxonoxClass.h"
 
 namespace orxonox
 {
 
+    /**
+    @brief
+        The PickupCarrier interface provides the means, for any class implementing it, to possess Pickupables.
+    @author
+        Damian 'Mozork' Frick
+    */
     class _OrxonoxExport PickupCarrier : virtual public OrxonoxClass
     {
-        friend class Pickupable;
+        friend class Pickupable; //!< The Pickupable has full acces to its PickupCarrier.
         
         public:
-            PickupCarrier();
-            virtual ~PickupCarrier() {}
+            PickupCarrier(); //!< Constructor.
+            virtual ~PickupCarrier(); //!< Destructor.
             
-            //TODO: Secure uniqueness of each item in the set, if neccessary, check.
+            /**
+            @brief Can be called to pick up a Pickupable.
+            @param pickup A pointer to the Pickupable.
+            @return Returns true if the Pickupable was picked up, false if not.
+            */
             inline bool pickup(Pickupable* pickup)
                 {
                     bool pickedUp = this->pickups_.insert(pickup).second;
-                    if(pickedUp) pickup->pickedUp(this);
+                    if(pickedUp)
+                        pickup->pickedUp(this);
                     return pickedUp;
                 }
                 
+            /**
+            @brief Can be called to drop a Pickupable.
+            @param pickup A pointer to the Pickupable.
+            @return Returns true if the Pickupable has been dropped, false if not.
+            */
             inline bool drop(Pickupable* pickup)
                 { 
Index: code/branches/pickup3/src/orxonox/interfaces/Pickupable.cc
===================================================================
--- code/branches/pickup3/src/orxonox/interfaces/Pickupable.cc	(revision 6474)
+++ code/branches/pickup3/src/orxonox/interfaces/Pickupable.cc	(revision 6474)
@@ -0,0 +1,210 @@
+/*
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of the Pickupable class.
+*/
+
+#include "Pickupable.h"
+
+#include "core/Identifier.h"
+#include "core/CoreIncludes.h"
+#include "PickupCarrier.h"
+
+namespace orxonox
+{
+    
+    /**
+    @brief
+        Constructor. Registers the objects and initializes its member variables.
+    */
+    Pickupable::Pickupable()
+    {
+        RegisterRootObject(Pickupable);
+
+        this->used_ = false;
+        this->pickedUp_ = false;
+        this->carrier_ = NULL;
+    }
+    
+    /**
+    @brief
+        Destructor. 
+    */
+    Pickupable::~Pickupable()
+    {
+        
+    }
+    
+    /**
+    @brief
+        Sets the Pickupable to used or unused, depending on the input.
+    @param used
+        If used is true the Pickupable is set to used, it is set to unused, otherwise.
+    @return
+        Returns true if the used state was changed, false if not.
+    */
+    bool Pickupable::setUsed(bool used)
+    {
+        if(this->used_ == used)
+            return false;
+        
+        COUT(4) << "Pickupable (&" << this << ") set to used " << used << "." << std::endl;
+        
+        this->used_ = used;
+        this->changedUsed();
+        return true;
+    }
+    
+    /**
+    @brief
+        Get whether the given PickupCarrier is a target of this pickup.
+    @param carrier
+        The PickupCarrier of which it has to be determinde whether it is a target of this pickup.
+    @return
+        Returns true if the given PickupCarrier is a target.
+    */
+    bool Pickupable::isTarget(PickupCarrier* carrier)
+    {
+        Identifier* identifier = carrier->getIdentifier();
+        //! Iterate through all targets of this Pickupable.
+        for(std::list<Identifier*>::const_iterator it = this->targets_.begin(); it != this->targets_.end(); it++)
+        {
+            if(identifier->isA(*it))
+                return true;
+        }
+        return false;
+    }
+    
+    /**
+    @brief
+        Add a PickupCarrier as target of this pickup.
+    @param target
+        The PickupCarrier to be added.
+    @return
+        Returns true if the target was added, false if not.
+    */
+    bool Pickupable::addTarget(PickupCarrier* target)
+    {
+        if(this->isTarget(target)) //!< If the input target is already present in the list of targets.
+            return false;
+        
+        COUT(4) << "Target (&" << target << ") added to Pickupable (&" << this << ")." << std::endl;
+        this->targets_.push_back(target->getIdentifier());
+        return true;
+    }
+    
+    /**
+    @brief  
+        Sets the Pickupable to picked up.
+        This method will be called by the PickupCarrier picking the Pickupable up.
+    @param carrier
+        The PickupCarrier that picked the Pickupable up.
+    @return
+        Returns false if, for some reason, the pickup could not be picked up, e.g. it was picked up already.
+    */
+    bool Pickupable::pickedUp(PickupCarrier* carrier)
+    {
+        if(this->isPickedUp()) //!< If the Pickupable is already picked up.
+            return false;
+        
+        COUT(4) << "Pickupable (&" << this << ") got picked up by a PickupCarrier (&" << carrier << ")." << std::endl;
+        this->setCarrier(carrier);
+        this->setPickedUp(true);
+        return true;
+    }
+    
+    /**
+    @brief 
+        Sets the Pickupable to not picked up or dropped.
+        This method will be called by the PickupCarrier dropping the Pickupable.
+    @return
+        Returns false if the pickup could not be dropped.
+    */
+    bool Pickupable::dropped(void)
+    {
+        if(!this->isPickedUp()) //!< If the Pickupable is not picked up.
+            return false;
+        
+        COUT(4) << "Pickupable (&" << this << ") got dropped up by a PickupCarrier (&" << this->getCarrier() << ")." << std::endl;
+        this->setUsed(false);
+        this->setPickedUp(false);
+        this->setCarrier(NULL);
+        return true;
+    }
+    
+        
+    /**
+    @brief
+        Sets the carrier of the pickup.
+    @param carrier
+        Sets the input PickupCarrier as the carrier of the pickup.
+    @return
+        Returns true if the carrier was changed, false if not.
+    */
+    bool Pickupable::setCarrier(PickupCarrier* carrier)
+    {
+        if(this->getCarrier() == carrier)
+            return false;
+        
+        this->carrier_ = carrier;
+        this->changedCarrier();
+        return true;
+    }
+    
+    /**
+    @brief
+        Creates a duplicate of the Pickupable.
+    @return
+        Returns the clone of this pickup as a pointer to a Pickupable.
+    */
+    //TODO: Does this work?
+    Pickupable* Pickupable::clone(void)
+    {
+        Pickupable* pickup = NULL;
+        this->clone(pickup);
+        
+        COUT(4) << "Pickupable (&" << this << ") cloned. Clone is new Pickupable (&" << pickup << ")." << std::endl;
+        return pickup;
+    }
+    
+    /**
+    @brief
+        Creates a duplicate of the input OrxonoxClass.
+        This method needs to be implemented by any Class inheriting from Pickupable.
+    @param item
+        A pointer to the OrxonoxClass that is to be duplicated.
+    */
+    //TODO: Specify how the implementation must be done in detail.
+    void Pickupable::clone(OrxonoxClass* item)
+    {
+        SUPER(Pickupable, clone, item);
+    }
+    
+}
Index: code/branches/pickup3/src/orxonox/interfaces/Pickupable.h
===================================================================
--- code/branches/pickup3/src/orxonox/interfaces/Pickupable.h	(revision 6466)
+++ code/branches/pickup3/src/orxonox/interfaces/Pickupable.h	(revision 6474)
@@ -36,9 +36,10 @@
 
 #include "OrxonoxPrereqs.h"
-#include "core/OrxonoxClass.h"
 
+#include <list>
 #include "core/Super.h"
 #include "pickup/PickupIdentifier.h"
-#include <list>
+
+#include "core/OrxonoxClass.h"
 
 namespace orxonox
@@ -47,5 +48,5 @@
     /**
     @brief
-        An Interface (or more precisely an abstract Class) to model and represent different (all kinds of) pickups.
+        An Interface (or more precisely an abstract class) to model and represent different (all kinds of) pickups.
     @author
         Damian 'Mozork' Frick
@@ -57,6 +58,32 @@
         public:
             Pickupable(); //!< Default constructor.
-            virtual ~Pickupable() {} //!< Default destructor.
-                
+            virtual ~Pickupable(); //!< Default destructor.
+            
+            /**
+            @brief Get whether the pickup is currently in use or not.
+            @return Returns true if the pickup is currently in use.
+            */
+            inline bool isUsed(void)
+                { return this->used_; }
+            /**
+            @brief  Should be 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.
+            */
+            virtual void changedUsed(void) {}
+            bool setUsed(bool used); //!< Sets the Pickupable to used or unused, depending on the input.
+            
+            /**
+            @brief Returns whether the Pickupable is currently picked up.
+            @return Returns true if the Pickupable is currently picked up, false if not.
+            */
+            inline bool isPickedUp(void)
+                { return this->pickedUp_; }
+            //TODO: Better private, or protected?
+            bool pickedUp(PickupCarrier* carrier); //!< Sets the Pickupable to picked up.
+            bool dropped(void); //!< Sets the Pickupable to not picked up or dropped.
+            
+            bool isTarget(PickupCarrier* carrier); //!< Get whether the given PickupCarrier is a target of this pickup.
+            bool addTarget(PickupCarrier* target); //!< Add a PickupCarrier as target of this pickup.
+            
             /**
             @brief Get the carrier of the pickup.
@@ -65,36 +92,4 @@
             inline PickupCarrier* getCarrier(void)
                 { return this->carrier_; }
-                
-            /**
-            @brief Get whether the pickup is currently in use or not.
-            @return Returns true if the pickup is currently in use.
-            */
-            inline bool isUsed(void)
-                { return this->used_; }
-                
-            bool isTarget(PickupCarrier* carrier);
-            bool addTarget(PickupCarrier* target);
-
-            bool setUsed(bool used);
-            
-            bool pickedUp(PickupCarrier* carrier);
-            bool dropped(void);
-            
-            inline bool isPickedUp(void)
-                { return this->pickedUp_; }
-            
-            Pickupable* clone(void);
-            
-            virtual const PickupIdentifier* getPickupIdentifier(void)
-                { return &this->pickupIdentifier_; }
-                
-            virtual void clone(OrxonoxClass* item);
-            
-            /**
-            @brief  Should be 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.
-            */
-            virtual void changedUsed(void) {}
-            
             /**
             @brief  Should be called when the pickup has transited from picked up to dropped or the other way around.
@@ -102,13 +97,35 @@
             */
             virtual void changedCarrier(void) {}
+            //TODO: Maybe private?
+            bool setCarrier(PickupCarrier* carrier); //!< Sets the carrier of the pickup.
             
-            bool setCarrier(PickupCarrier* carrier);
+            Pickupable* clone(void); //!< Creates a duplicate of the Pickupable.
+            virtual void clone(OrxonoxClass* item); //!< Creates a duplicate of the input OrxonoxClass.
+            
+            /**
+            @brief Get the PickupIdentifier of this Pickupable.
+            @return Returns a pointer to the PickupIdentifier of this Pickupable.
+            */
+            virtual const PickupIdentifier* getPickupIdentifier(void)
+                { return &this->pickupIdentifier_; }
+                
+            virtual void destroy(void)
+                { delete this; }
             
         protected:
+            /**
+            @brief Helper method to initialize the PickupIdentifier.
+            */
+            //TODO: Really needed?
             void initializeIdentifier(void) {}
             
-            PickupIdentifier pickupIdentifier_;
+            //TODO: Move to private and create get method in protected.
+            PickupIdentifier pickupIdentifier_; //!< The PickupIdentifier of this Pickupable.
             
         private:
+            /**
+            @brief Helper method to set the Pickupable to either picked up or not picked up.
+            @param pickedUp The value this->pickedUp_ should be set to.
+            */
             inline void setPickedUp(bool pickedUp)
                 { this->pickedUp_ = pickedUp; }
@@ -117,5 +134,5 @@
             bool pickedUp_; //!< Whether the pickup is currently picked up or not.
             
-            PickupCarrier* carrier_; //!< The owner of the pickup.
+            PickupCarrier* carrier_; //!< The carrier of the pickup.
             std::list<Identifier*> targets_; //!< The possible targets of this pickup.
 
