Index: code/branches/pickup3/src/orxonox/interfaces/PickupCarrier.h
===================================================================
--- code/branches/pickup3/src/orxonox/interfaces/PickupCarrier.h	(revision 6474)
+++ code/branches/pickup3/src/orxonox/interfaces/PickupCarrier.h	(revision 6475)
@@ -65,5 +65,5 @@
             @return Returns true if the Pickupable was picked up, false if not.
             */
-            inline bool pickup(Pickupable* pickup)
+            bool pickup(Pickupable* pickup)
                 {
                     bool pickedUp = this->pickups_.insert(pickup).second;
@@ -78,5 +78,5 @@
             @return Returns true if the Pickupable has been dropped, false if not.
             */
-            inline bool drop(Pickupable* pickup)
+            bool drop(Pickupable* pickup)
                 { 
                    bool dropped = this->pickups_.erase(pickup) == 1;
@@ -84,14 +84,21 @@
                    {
                        pickup->dropped();
-                        //TODO: Create Spawner.
                    }
                    return dropped;
                 }
                 
-            inline bool isTarget(Pickupable* pickup)
+            /**
+            @brief Can be used to check whether the PickupCarrier or a child of his is a target ot the input Pickupable.
+            @param pickup A pointer to the Pickupable.
+            @return Returns true if the PickupCarrier or one of its children is a target, false if not.
+            */
+            //TODO: Use?
+            bool isTarget(const Pickupable* pickup)
                 {
-                    if(pickup->isTarget(this))
+                    if(pickup->isTarget(this)) //!< If the PickupCarrier itself is a target.
                         return true;
-                    const std::list<PickupCarrier*>* children = this->getChildren();
+                    
+                    //! Go recursively through all children to check whether they are a target.
+                    std::list<PickupCarrier*>* children = this->getCarrierChildren();
                     for(std::list<PickupCarrier*>::const_iterator it = children->begin(); it != children->end(); it++)
                     {
@@ -100,18 +107,62 @@
                     }
                     
+                    children->clear();
+                    delete children;
+                    
                     return false;
                 }
+                
+            /**
+            @brief Get the carrier that is both a child of the PickupCarrier (or the PickupCarrier itself) and a target of the input Pickupable.
+            @param pickup A pounter to the Pickupable.
+            @return Returns a pointer to the PickupCarrier that is the target of the input Pickupable.
+            */
+            PickupCarrier* getTarget(const Pickupable* pickup)
+                {
+                    if(!this->isTarget(pickup))
+                        return NULL;
+                    
+                    if(pickup->isTarget(this)) //!< If the PickupCarrier itself is a target.
+                        return this;
+                    
+                    //! Go recursively through all children to check whether they are the target.
+                    std::list<PickupCarrier*>* children = this->getCarrierChildren();
+                    for(std::list<PickupCarrier*>::iterator it = children->begin(); it != children->end(); it++)
+                    {
+                        if(pickup->isTarget(*it))
+                            return *it;
+                    }
+                    
+                    children->clear();
+                    delete children;
+                    
+                    return NULL;
+                }
             
-        protected:            
-            //TODO: Good return type?
-            virtual const std::list<PickupCarrier*>* getChildren(void) = 0;
-            virtual PickupCarrier* getParent(void) = 0;
+        protected:        
+            /**
+            @brief Get all direct children of this PickupSpawner.
+                   This method needs to be implemented by any direct derivative class of PickupCarrier.
+            @return Returns a pointer to a list of all direct children. 
+            */
+            //TODO: Good return type? Maybe not const and destroyed in isTarget...
+            virtual std::list<PickupCarrier*>* getCarrierChildren(void) = 0;
+            /**
+            @brief Get the parent of this PickupSpawner
+                   This method needs to be implemented by any direct derivative class of PickupCarrier.
+            @return Returns a pointer to the parent.
+            */
+            virtual PickupCarrier* getCarrierParent(void) = 0;
+            /**
+            @brief Get the (absolute) position of the PickupCarrier.
+                   This method needs to be implemented by any direct derivative class of PickupCarrier.
+            @return Returns the position as a Vector3.
+            */
+            virtual const Vector3& getCarrierPosition(void) = 0;
         
         private:
-            std::set<Pickupable*> pickups_;
+            std::set<Pickupable*> pickups_; //!< The list of Pickupables carried by this PickupCarrier.
             
-        
     };
-    
 }
 
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 6475)
@@ -36,4 +36,5 @@
 #include "core/Identifier.h"
 #include "core/CoreIncludes.h"
+#include "pickup/PickupIdentifier.h"
 #include "PickupCarrier.h"
 
@@ -52,4 +53,6 @@
         this->pickedUp_ = false;
         this->carrier_ = NULL;
+        
+        this->pickupIdentifier_ = new PickupIdentifier();
     }
     
@@ -91,5 +94,5 @@
         Returns true if the given PickupCarrier is a target.
     */
-    bool Pickupable::isTarget(PickupCarrier* carrier)
+    bool Pickupable::isTarget(const PickupCarrier* carrier) const
     {
         Identifier* identifier = carrier->getIdentifier();
@@ -156,5 +159,11 @@
         this->setUsed(false);
         this->setPickedUp(false);
+        
+        bool created = this->createSpawner(this->getCarrier()->getCarrierPosition());
+        
         this->setCarrier(NULL);
+        if(!created)
+            this->destroy();
+        
         return true;
     }
Index: code/branches/pickup3/src/orxonox/interfaces/Pickupable.h
===================================================================
--- code/branches/pickup3/src/orxonox/interfaces/Pickupable.h	(revision 6474)
+++ code/branches/pickup3/src/orxonox/interfaces/Pickupable.h	(revision 6475)
@@ -39,5 +39,4 @@
 #include <list>
 #include "core/Super.h"
-#include "pickup/PickupIdentifier.h"
 
 #include "core/OrxonoxClass.h"
@@ -83,5 +82,5 @@
             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 isTarget(const PickupCarrier* carrier) const; //!< Get whether the given PickupCarrier is a target of this pickup.
             bool addTarget(PickupCarrier* target); //!< Add a PickupCarrier as target of this pickup.
             
@@ -108,5 +107,5 @@
             */
             virtual const PickupIdentifier* getPickupIdentifier(void)
-                { return &this->pickupIdentifier_; }
+                { return this->pickupIdentifier_; }
                 
             virtual void destroy(void)
@@ -120,6 +119,15 @@
             void initializeIdentifier(void) {}
             
+            /**
+            @brief Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
+                   This method must be implemented by any class directly inheriting from Pickupable. It is most easily done by just creating a new DroppedPickup, e.g.:
+                   DroppedPickup(BaseObject* creator, Pickupable* pickup, const Vector3& position, float triggerDistance);
+            @param position The position at which the PickupSpawner should be placed.
+            @return Returns true if a spawner was created, false if not.
+            */
+            virtual bool createSpawner(const Vector3& position) = 0;
+            
             //TODO: Move to private and create get method in protected.
-            PickupIdentifier pickupIdentifier_; //!< The PickupIdentifier of this Pickupable.
+            PickupIdentifier* pickupIdentifier_; //!< The PickupIdentifier of this Pickupable.
             
         private:
