Index: code/trunk/src/modules/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/CMakeLists.txt	(revision 6502)
+++ code/trunk/src/modules/CMakeLists.txt	(revision 6524)
@@ -29,4 +29,5 @@
 ADD_SUBDIRECTORY(objects)
 ADD_SUBDIRECTORY(overlays)
+ADD_SUBDIRECTORY(pickup)
 ADD_SUBDIRECTORY(pong)
 ADD_SUBDIRECTORY(questsystem)
Index: code/trunk/src/modules/pickup/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/pickup/CMakeLists.txt	(revision 6524)
+++ code/trunk/src/modules/pickup/CMakeLists.txt	(revision 6524)
@@ -0,0 +1,24 @@
+SET_SOURCE_FILES(PICKUP_SRC_FILES
+  DroppedPickup.cc
+  Pickup.cc
+  PickupCollection.cc
+  PickupCollectionIdentifier.cc
+  PickupManager.cc
+  PickupRepresentation.cc
+  PickupSpawner.cc
+)
+
+ADD_SUBDIRECTORY(items)
+
+ORXONOX_ADD_LIBRARY(pickup
+  MODULE
+  FIND_HEADER_FILES
+  TOLUA_FILES
+  DEFINE_SYMBOL
+    "PICKUP_SHARED_BUILD"
+  PCH_FILE
+    PickupPrecompiledHeaders.h
+  LINK_LIBRARIES
+    orxonox
+  SOURCE_FILES ${PICKUP_SRC_FILES}
+)
Index: code/trunk/src/modules/pickup/DroppedPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/DroppedPickup.cc	(revision 6524)
+++ code/trunk/src/modules/pickup/DroppedPickup.cc	(revision 6524)
@@ -0,0 +1,98 @@
+/*
+ *   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:
+ *      Daniel 'Huty' Haggenmueller
+ *   Co-authors:
+ *      Damian 'Mozork' Frick
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of the DroppedPickup class.
+*/
+
+#include "DroppedPickup.h"
+
+#include "core/CoreIncludes.h"
+#include "interfaces/Pickupable.h"
+#include "graphics/Model.h"
+
+namespace orxonox
+{
+    
+    CreateFactory(DroppedPickup);
+    
+    /**
+    @brief
+        Default constructor. Registers object and sets default values.
+    */
+    DroppedPickup::DroppedPickup(BaseObject* creator) : PickupSpawner(creator)
+    {
+        RegisterObject(DroppedPickup);
+        
+    }
+
+    /**
+    @brief
+        Constructor. Registers the object and sets values.
+    @param creator
+        The creator of the DroppedPickup.
+    @param pickup
+        The Pickupable that was dropped.
+    @param position
+        The position at which the DroppedPickup should be created.
+    @param triggerDistance
+        The distance at which the PickupSpawner triggers. Default is 10.
+    */
+    DroppedPickup::DroppedPickup(BaseObject* creator, Pickupable* pickup, const Vector3& position, float triggerDistance) : PickupSpawner(creator, pickup, triggerDistance, 10, 1)
+    {   
+        RegisterObject(DroppedPickup);
+
+        this->setPosition(position);
+        this->setActive(false);
+        this->startRespawnTimer();
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
+    DroppedPickup::~DroppedPickup()
+    {
+        if(this->pickup_ != NULL && this->pickup_->isPickedUp())
+        {
+            this->pickup_ = NULL;
+        }
+    }
+
+    /**
+    @brief
+        Creates the Pickupable that is going to get picked up.
+        In the case of the DroppedItem it is the one and only Pickupable that was dropped. No additional Pickupables of the same type are created.
+    */
+    Pickupable* DroppedPickup::getPickup(void)
+    {
+        return this->pickup_;
+    }
+
+}
Index: code/trunk/src/modules/pickup/DroppedPickup.h
===================================================================
--- code/trunk/src/modules/pickup/DroppedPickup.h	(revision 6524)
+++ code/trunk/src/modules/pickup/DroppedPickup.h	(revision 6524)
@@ -0,0 +1,64 @@
+/*
+ *   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:
+ *      Daniel 'Huty' Haggenmueller
+ *   Co-authors:
+ *      Damian 'Mozork' Frick
+ *
+ */
+
+/**
+    @file
+    @brief Definition of the DroppedPickup class.
+*/
+
+#ifndef _DroppedPickup_H__
+#define _DroppedPickup_H__
+
+#include "PickupPrereqs.h"
+
+#include "PickupSpawner.h"
+
+namespace orxonox
+{
+    
+    /**
+    @brief
+        Special PickupSpawner that is created whe a Pickupable is dropped. It just spawns one pickup, the one that was dropped.
+    @author
+        Daniel 'Huty' Haggenmueller
+        Damian 'Mozork' Frick
+    */
+    class _PickupExport DroppedPickup : public PickupSpawner
+    {
+        public:
+            DroppedPickup(BaseObject* creator); //!< Default constructor.
+            DroppedPickup(BaseObject* creator, Pickupable* pickup, const Vector3& position, float triggerDistance = 10.0); //!< Constructor.
+            virtual ~DroppedPickup(); //!< Destructor.
+
+        protected:
+            virtual Pickupable* getPickup(void); //!< Creates the Pickupable that is going to get picked up.
+
+    };
+}
+
+#endif /* _DroppedPickup_H__ */
Index: code/trunk/src/modules/pickup/Pickup.cc
===================================================================
--- code/trunk/src/modules/pickup/Pickup.cc	(revision 6524)
+++ code/trunk/src/modules/pickup/Pickup.cc	(revision 6524)
@@ -0,0 +1,233 @@
+/*
+ *   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:
+ *      ...
+ *
+*/
+
+#include "Pickup.h"
+
+#include "core/CoreIncludes.h"
+#include "util/StringUtils.h"
+#include "pickup/PickupIdentifier.h"
+#include "DroppedPickup.h"
+
+namespace orxonox
+{
+    
+    /*static*/ const std::string Pickup::activationTypeImmediate_s = "immediate";
+    /*static*/ const std::string Pickup::activationTypeOnUse_s = "onUse";
+    /*static*/ const std::string Pickup::durationTypeOnce_s = "once";
+    /*static*/ const std::string Pickup::durationTypeContinuous_s = "continuous";
+    
+    //TODO: Should this be here? Does it work without?
+    CreateFactory(Pickup);
+    
+    Pickup::Pickup(BaseObject* creator) : BaseObject(creator)
+    {
+        RegisterObject(Pickup);
+        
+        this->initialize();
+    }
+    
+    Pickup::~Pickup()
+    {
+        
+    }
+    
+    /**
+    @brief
+        Initializes the member variables.
+    */
+    void Pickup::initialize(void)
+    {
+        this->activationType_ = pickupActivationType::immediate;
+        this->durationType_ = pickupDurationType::once;
+    }
+    
+    /**
+    @brief
+        Initializes the PickupIdentififer of this Pickup.
+    */
+    void Pickup::initializeIdentifier(void)
+    {        
+        //TODO: Works?
+        std::string val1 = this->getActivationType();
+        std::string type1 = "activationType";
+        this->pickupIdentifier_->addParameter(type1, val1);
+        
+        std::string val2 = this->getDurationType();
+        std::string type2 = "durationType";
+        this->pickupIdentifier_->addParameter(type2, val2);
+    }
+    
+    /**
+    @brief
+        Method for creating a Pickup object through XML.
+    */
+    void Pickup::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(Pickup, XMLPort, xmlelement, mode);
+
+        XMLPortParam(Pickup, "activationType", setActivationType, getActivationType, xmlelement, mode);
+        XMLPortParam(Pickup, "durationType", setDurationType, getDurationType, xmlelement, mode);
+        
+        this->initializeIdentifier();
+    }
+    
+    /**
+    @brief
+        Get the activation type of the pickup.
+    @return
+        Returns a string containing the activation type.
+    */
+    const std::string& Pickup::getActivationType(void)
+    {
+        switch(this->activationType_)
+        {
+            case pickupActivationType::immediate:
+                return activationTypeImmediate_s;
+            case pickupActivationType::onUse:
+                return activationTypeOnUse_s;
+            default:
+                return BLANKSTRING;
+        }
+    }
+        
+    /**
+    @brief
+        Get the duration type of the pickup.
+    @return
+        Returns a string containing the duration type.
+    */
+    const std::string& Pickup::getDurationType(void)
+    {
+        switch(this->durationType_)
+        {
+            case pickupDurationType::once:
+                return durationTypeOnce_s;
+            case pickupDurationType::continuous:
+                return durationTypeContinuous_s;
+            default:
+                return BLANKSTRING;
+        }
+    }
+    
+    /**
+    @brief
+        Set the activation type of the Pickup.
+    @param type
+        The activation type of the Pickup as a string.
+    */
+    void Pickup::setActivationType(const std::string& type)
+    {
+        if(type == activationTypeImmediate_s)
+        {
+            this->activationType_ = pickupActivationType::immediate;
+        }
+        else if(type == activationTypeOnUse_s)
+        {
+            this->activationType_ = pickupActivationType::onUse;
+        }
+        else
+        {
+            COUT(1) << "Invalid activationType in pickup." << std::endl;
+        }
+    }
+        
+    /**
+    @brief
+        Set the duration type of the Pickup.
+    @param type
+        The duration type of the Pickup as a string.
+    */
+    void Pickup::setDurationType(const std::string& type)
+    {
+        if(type == durationTypeOnce_s)
+        {
+            this->durationType_ = pickupDurationType::once;
+        }
+        else if(type == durationTypeContinuous_s)
+        {
+            this->durationType_ = pickupDurationType::continuous;
+        }
+        else
+        {
+            COUT(1) << "Invalid durationType in pickup." << std::endl;
+        }
+    }
+    
+    /**
+    @brief
+        Should be 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 Pickup::changedPickedUp(void)
+    {
+        SUPER(Pickup, changedPickedUp);
+        
+        //! Sets the Pickup to used if the Pickup has activation type 'immediate' and gets picked up.
+        if(this->getCarrier() != NULL && this->isPickedUp() && this->isImmediate())
+        {
+            this->setUsed(true);
+        }
+    }
+    
+    /**
+    @brief
+        Creates a duplicate of the Pickup.
+    @return
+        Returns the clone of this pickup as a pointer to a Pickupable.
+    */
+    void Pickup::clone(OrxonoxClass*& item)
+    {
+        if(item == NULL)
+            item = new Pickup(this);
+        
+        SUPER(Pickup, clone, item);
+        
+        Pickup* pickup = dynamic_cast<Pickup*>(item);
+        pickup->setActivationTypeDirect(this->getActivationTypeDirect());
+        pickup->setDurationTypeDirect(this->getDurationTypeDirect());
+        
+        pickup->initializeIdentifier();
+    }
+        
+    /**
+    @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);
+    @param position
+        The position at which the PickupSpawner should be placed.
+    @return
+        Returns true if a spawner was created, false if not.
+    */
+    bool Pickup::createSpawner(const Vector3& position)
+    {
+        new DroppedPickup(this, this, position);
+        return true;
+    }
+    
+}
Index: code/trunk/src/modules/pickup/Pickup.h
===================================================================
--- code/trunk/src/modules/pickup/Pickup.h	(revision 6524)
+++ code/trunk/src/modules/pickup/Pickup.h	(revision 6524)
@@ -0,0 +1,158 @@
+/*
+ *   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:
+ *      ...
+ *
+*/
+
+#ifndef _Pickup_H__
+#define _Pickup_H__
+
+#include "pickup/PickupPrereqs.h"
+
+#include "core/BaseObject.h"
+#include "core/XMLPort.h"
+
+#include "interfaces/Pickupable.h"
+
+namespace orxonox
+{
+
+    //! Enum for the activation type.
+    namespace pickupActivationType
+    {
+        enum Value
+        {
+            immediate,
+            onUse,
+        };
+    }
+    
+    //! Enum for the duration tyoe.
+    namespace pickupDurationType
+    {
+        enum Value
+        {
+            once,
+            continuous,
+        };
+    }
+    
+    /**
+    @brief
+        Pickup class. Offers base functionality for a wide range of pickups.
+        Pickups ingeriting from this class cann choose an activation type and a duration type.
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _PickupExport Pickup : public Pickupable, public BaseObject
+    {
+        
+        public:
+            Pickup(BaseObject* creator); //!< Constructor.
+            virtual ~Pickup(); //!< Destructor.
+            
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            
+            /**
+            @brief Get the activation type of the pickup.
+            @return Returns the activation type of the pickup.
+            */
+            inline pickupActivationType::Value getActivationTypeDirect(void)
+                { return this->activationType_; }
+            /**
+            @brief Get the duration type of the pickup.
+            @return Returns the duration type of the pickup.
+            */
+            inline pickupDurationType::Value getDurationTypeDirect(void)
+                { return this->durationType_; }
+            
+            const std::string& getActivationType(void); //!< Get the activation type of the pickup.
+            const std::string& getDurationType(void); //!< Get the duration type of the pickup.
+            
+            /**
+            @brief Get whether the activation type is 'immediate'.
+            @return Returns true if the activation type is 'immediate'.
+            */
+            inline bool isImmediate(void)
+                { return this->getActivationTypeDirect() == pickupActivationType::immediate; }
+            /**
+            @brief Get whether the activation type is 'onUse'.
+            @return Returns true if the activation type is 'onUse'.
+            */
+            inline bool isOnUse(void)
+                { return this->getActivationTypeDirect() == pickupActivationType::onUse; }
+            /**
+            @brief Get whether the duration type is 'once'.
+            @return Returns true if the duration type is 'once'.
+            */
+            inline bool isOnce(void)
+                { return this->getDurationTypeDirect() == pickupDurationType::once; }
+            /**
+            @brief Get whether the duration type is 'continuous'.
+            @return Returns true if the duration type is 'continuous'.
+            */
+            inline bool isContinuous(void)
+                { return this->getDurationTypeDirect() == pickupDurationType::continuous; }
+            
+            virtual void changedPickedUp(void); //!< Should be called when the pickup has transited from picked up to dropped or the other way around.
+                                    
+            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the Pickup.
+                
+        protected:
+            void initializeIdentifier(void);
+            
+            virtual bool createSpawner(const Vector3& position); //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
+            
+            /**
+            @brief Set the activation type of the pickup.
+            @param type The activation type of the pickup.
+            */
+            inline void setActivationTypeDirect(pickupActivationType::Value type)
+                { this->activationType_ = type; }
+            /**
+            @brief Set the duration type of the pickup.
+            @param type The duration type of the pickup.
+            */
+            inline void setDurationTypeDirect(pickupDurationType::Value type)
+                { this->durationType_ = type; }
+                
+            void setActivationType(const std::string& type); //!< Set the activation type of the pickup.
+            void setDurationType(const std::string& type); //!< Set the duration type of the pickup
+                
+        private:
+            void initialize(void); //!< Initializes the member variables.
+            
+            pickupActivationType::Value activationType_; //!< The activation type of the Pickup.
+            pickupDurationType::Value durationType_; //!< The duration type of the pickup.
+            
+            static const std::string activationTypeImmediate_s;
+            static const std::string activationTypeOnUse_s;
+            static const std::string durationTypeOnce_s;
+            static const std::string durationTypeContinuous_s;
+        
+    };
+    
+}
+#endif // _Pickup_H__
Index: code/trunk/src/modules/pickup/PickupCollection.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupCollection.cc	(revision 6524)
+++ code/trunk/src/modules/pickup/PickupCollection.cc	(revision 6524)
@@ -0,0 +1,206 @@
+/*
+ *   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 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"
+
+namespace orxonox
+{
+ 
+    CreateFactory(PickupCollection);
+
+    /**
+    @brief
+        Default Constructor.
+    */
+    PickupCollection::PickupCollection(BaseObject* creator) : BaseObject(creator)
+    {
+        RegisterObject(PickupCollection);
+        
+        this->pickupCollectionIdentifier_ = new PickupCollectionIdentifier(this);
+    }
+    
+    /**
+    @brief
+        Destructor.
+    */
+    PickupCollection::~PickupCollection()
+    {
+        //! Destroy all Pickupables constructing this PickupCollection.
+        for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            (*it)->destroy();
+        }
+    }
+    
+    /**
+    @brief
+        Creates an instance of this Class through XML.
+    */
+    void PickupCollection::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(PickupCollection, XMLPort, xmlelement, mode);
+        
+        XMLPortObject(PickupCollection, Pickupable, "pickupables", addPickupable, getPickupable, xmlelement, mode);
+        
+        this->initializeIdentifier();
+    }
+    
+    void PickupCollection::initializeIdentifier(void)
+    {
+        for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            this->pickupCollectionIdentifier_->addPickup((*it)->getPickupIdentifier());
+        }
+    }
+    
+    /**
+    @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);
+    @param position
+        The position at which the PickupSpawner should be placed.
+    @return
+        Returns true if a spawner was created, false if not.
+    */
+    bool PickupCollection::createSpawner(const Vector3& position)
+    {
+        new DroppedPickup(this, this, position);
+        return true;
+    }
+    
+    /**
+    @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;
+        
+        this->pickups_.push_back(pickup);
+        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]; //TODO. Does this work?
+    }
+    
+    void PickupCollection::changedUsed(void)
+    {
+        SUPER(PickupCollection, changedUsed);
+        
+        //! Change used for all Pickupables this PickupCollection consists of.
+        for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            (*it)->setUsed(this->isUsed());
+        }
+    }
+    
+    void PickupCollection::changedCarrier(void)
+    {
+        SUPER(PickupCollection, changedCarrier);
+        
+        //! Change used for all Pickupables this PickupCollection consists of.
+        for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            (*it)->setCarrier(this->getCarrier());
+        }
+    }
+    
+    void PickupCollection::changedPickedUp()
+    {
+        SUPER(PickupCollection, changedPickedUp);
+        
+        //! Change the carrier for all Pickupables this PickupCollection consists of.
+        for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            (*it)->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<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            Pickupable* newPickup = (*it)->clone();
+            pickup->addPickupable(newPickup);
+        }
+
+        pickup->initializeIdentifier();
+    }
+    
+    bool PickupCollection::isTarget(Identifier* identifier) const
+    {
+        for(std::vector<Pickupable*>::const_iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            if(!(*it)->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 6524)
+++ code/trunk/src/modules/pickup/PickupCollection.h	(revision 6524)
@@ -0,0 +1,87 @@
+/*
+ *   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:
+ *      ...
+ *
+ */
+
+#ifndef _PickupCollection_H__
+#define _PickupCollection_H__
+
+#include "PickupPrereqs.h"
+
+#include "interfaces/Pickupable.h"
+#include "core/BaseObject.h"
+#include "core/XMLPort.h"
+
+#include <list>
+
+namespace orxonox
+{
+
+    /**
+    @brief
+        The PickupCollection combines different Pickupables to a coherent, single pickup and makes the seem (from the outside looking in) just as if they were just one Pickupable.
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _PickupExport PickupCollection : public Pickupable, public BaseObject
+    {
+        
+        public:
+            
+            PickupCollection(BaseObject* creator);
+            virtual ~PickupCollection();
+            
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+
+            virtual void changedUsed(void);
+            virtual void changedCarrier(void);
+            virtual void changedPickedUp(void);
+            
+            virtual void clone(OrxonoxClass*& item);
+            
+            virtual bool isTarget(Identifier* identifier) const;
+            
+            virtual const PickupIdentifier* getPickupIdentifier(void);
+            
+            bool addPickupable(Pickupable* pickup);
+            const Pickupable* getPickupable(unsigned int index);
+            
+        protected:
+            void initializeIdentifier(void);
+            
+            virtual bool createSpawner(const Vector3& position); //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
+            
+            PickupCollectionIdentifier* pickupCollectionIdentifier_;
+            
+        private:
+            
+            std::vector<Pickupable*> pickups_;
+        
+    };
+    
+}
+
+#endif /* _PickupCollection_H__ */
Index: code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc	(revision 6524)
+++ code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc	(revision 6524)
@@ -0,0 +1,77 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+*/
+
+#include "PickupCollectionIdentifier.h"
+
+#include "core/CoreIncludes.h"
+
+namespace orxonox
+{
+    
+    PickupCollectionIdentifier::PickupCollectionIdentifier(Pickupable* pickup) : PickupIdentifier(pickup)
+    {
+        RegisterObject(PickupCollectionIdentifier);
+    }
+    
+    PickupCollectionIdentifier::~PickupCollectionIdentifier()
+    {
+        
+    }
+
+    int PickupCollectionIdentifier::compare(const PickupIdentifier* identifier) const
+    {
+        PickupIdentifier* temp = const_cast<PickupIdentifier*>(identifier);
+        const PickupCollectionIdentifier* collectionIdentifier = dynamic_cast<PickupCollectionIdentifier*>(temp);
+        if(collectionIdentifier == NULL)
+        {
+            return this->PickupIdentifier::compare(identifier);
+        }
+        
+        if(this->identifiers_.size() != collectionIdentifier->identifiers_.size())
+            return this->identifiers_.size()-collectionIdentifier->identifiers_.size();
+        
+        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++)
+        {
+            
+            if((*it)->compare(*it2) < 0)
+                return -1;
+            if((*it2)->compare(*it) < 0)
+                return 1;
+        }
+        
+        return 0;
+    }
+    
+    void PickupCollectionIdentifier::addPickup(const PickupIdentifier* identifier)
+    {
+        this->identifiers_.insert(identifier);
+    }
+    
+}
+
Index: code/trunk/src/modules/pickup/PickupCollectionIdentifier.h
===================================================================
--- code/trunk/src/modules/pickup/PickupCollectionIdentifier.h	(revision 6524)
+++ code/trunk/src/modules/pickup/PickupCollectionIdentifier.h	(revision 6524)
@@ -0,0 +1,58 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+*/
+
+#ifndef _PickupCollectionIdentifier_H__
+#define _PickupCollectionIdentifier_H_
+
+#include "PickupPrereqs.h"
+
+#include "pickup/PickupIdentifier.h"
+#include <set>
+
+namespace orxonox
+{
+
+    class _PickupExport PickupCollectionIdentifier : public PickupIdentifier
+    {
+        
+        public:
+            PickupCollectionIdentifier(Pickupable* pickup);
+            ~PickupCollectionIdentifier();
+            
+            virtual int compare(const PickupIdentifier* identifier) const;
+            
+            void addPickup(const PickupIdentifier* identifier);
+            
+        private:
+            std::set<const PickupIdentifier*, PickupIdentifierCompare> identifiers_;
+            
+    };
+    
+}
+
+#endif // _PickupCollectionIdentifier_H_
Index: code/trunk/src/modules/pickup/PickupManager.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupManager.cc	(revision 6524)
+++ code/trunk/src/modules/pickup/PickupManager.cc	(revision 6524)
@@ -0,0 +1,118 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+*/
+
+/**
+    @file
+    @brief Implementation of the PickupManager class.
+*/
+
+#include "PickupManager.h"
+
+#include "core/CoreIncludes.h"
+#include "core/ScopedSingletonManager.h"
+#include "core/Identifier.h"
+#include "interfaces/PickupCarrier.h"
+#include "worldentities/pawns/Pawn.h"
+#include "PickupRepresentation.h"
+
+namespace orxonox
+{
+
+    ManageScopedSingleton(PickupManager, ScopeID::Root, false);
+    
+    /**
+    @brief
+        Constructor. Registers the PickupManager and creates the default PickupRepresentation.
+    */
+    PickupManager::PickupManager()
+    {
+        this->defaultRepresentation_ = NULL;
+        this->pickupCarrierStructure_ = NULL;
+        RegisterRootObject(PickupManager);
+        
+        this->defaultRepresentation_ = new PickupRepresentation();
+    }
+    
+    /**
+    @brief
+        Destructor.
+        Destroys the default PickupRepresentation.
+    */
+    PickupManager::~PickupManager()
+    {
+        if(this->defaultRepresentation_ != NULL)
+            this->defaultRepresentation_->destroy();
+        
+        if(this->pickupCarrierStructure_ != NULL)
+            delete this->pickupCarrierStructure_;
+    }
+    
+    /**
+    @brief
+        Registers a PickupRepresentation together with the PickupIdentifier of the Pickupable the PickupRepresentation represents.
+        For every type of Pickupable (uniquely idnetified by a PickupIdentifier) there can be one (and just one) PickupRepresentation registered.
+    @param identifier
+        The PickupIdentifier identifying the Pickupable.
+    @param representation
+        A pointer to the PickupRepresentation.
+    @return
+        Returns true if successful and false if not.
+    */
+    //TODO: Make sure that either the PickupRepresentation is destroyed upon destruction of the PickupManager if the representation wasn't created with XMLPort.
+    bool PickupManager::registerRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation)
+    {
+        if(this->representations_.find(identifier) != this->representations_.end()) //!< If the Pickupable already has a RepresentationRegistered.
+            return false;
+        
+        this->representations_[identifier] = representation;
+        
+        COUT(4) << "PickupRepresentation " << representation << " registered with the PickupManager." << std::endl;
+        return true;
+    }
+    
+    /**
+    @brief
+        Get the PickupRepresentation representing the Pickupable with the input PickupIdentifier.
+    @param identifier
+        The PickupIdentifier.
+    @return
+        Returns a pointer to the PickupRepresentation.
+    */
+    PickupRepresentation* PickupManager::getRepresentation(const PickupIdentifier* identifier)
+    {
+        std::map<const PickupIdentifier*, PickupRepresentation*, PickupIdentifierCompare>::iterator it = this->representations_.find(identifier);
+        if(it == this->representations_.end())
+        {
+            COUT(4) << "PickupManager::getRepresentation() returned default representation." << std::endl;
+            return this->defaultRepresentation_;
+        }
+        
+        return it->second;
+    }
+    
+}
Index: code/trunk/src/modules/pickup/PickupManager.h
===================================================================
--- code/trunk/src/modules/pickup/PickupManager.h	(revision 6524)
+++ code/trunk/src/modules/pickup/PickupManager.h	(revision 6524)
@@ -0,0 +1,92 @@
+/*
+ *   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 Definition of the PickupManager class.
+*/
+
+#ifndef _PickupManager_H__
+#define _PickupManager_H__
+
+#include "PickupPrereqs.h"
+
+#include <map>
+#include "util/Singleton.h"
+#include "pickup/PickupIdentifier.h"
+#include "PickupRepresentation.h"
+
+#include "core/OrxonoxClass.h"
+
+namespace orxonox
+{
+    //TODO: Actually utilize this.
+    struct PickupCarrierNode
+    {
+        Identifier* identifier;
+        std::set<PickupCarrierNode*> children;
+    };
+
+    /**
+    @brief
+        Manages Pickupables.
+        In essence has two tasks to fulfill. Firstly it must link Pickupables (through their PickupIdentifiers) and their PickupRepresentations. Secondly it manages the Pickup GUI.
+        //TODO: Manage Pickup GUI.
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _PickupExport PickupManager : public Singleton<PickupManager>, public OrxonoxClass
+    {
+        friend class Singleton<PickupManager>;
+        
+        public:
+            PickupManager();
+            virtual ~PickupManager();
+            
+            static PickupManager& getInstance() { return Singleton<PickupManager>::getInstance(); }
+            
+            bool registerRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation); //!< Registers a PickupRepresentation together with the PickupIdentifier of the Pickupable the PickupRepresentation represents.
+            PickupRepresentation* getRepresentation(const PickupIdentifier* identifier); //!< Get the PickupRepresentation representing the Pickupable with the input PickupIdentifier.
+            
+            //TODO: Delete or utilitze this.
+            //bool registerCarrier(Identifier* parent, )
+            
+        private:
+            static PickupManager* singletonPtr_s;
+            
+            PickupRepresentation* defaultRepresentation_; //!< The default PickupRepresentation.
+            std::map<const PickupIdentifier*, PickupRepresentation*, PickupIdentifierCompare> representations_; //!< Map linking PickupIdentifiers (representing types if Pickupables) and PickupRepresentations.
+            
+            //TODO: Delete or utilize this.
+            PickupCarrierNode* pickupCarrierStructure_;
+        
+    };
+    
+}
+
+#endif // _PickupManager_H__
Index: code/trunk/src/modules/pickup/PickupPrereqs.h
===================================================================
--- code/trunk/src/modules/pickup/PickupPrereqs.h	(revision 6524)
+++ code/trunk/src/modules/pickup/PickupPrereqs.h	(revision 6524)
@@ -0,0 +1,82 @@
+/*
+ *   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
+    Shared library macros, enums, constants and forward declarations for the questsystem module
+*/
+
+#ifndef _PickupPrereqs_H__
+#define _PickupPrereqs_H__
+
+#include "OrxonoxConfig.h"
+#include "OrxonoxPrereqs.h"
+
+//-----------------------------------------------------------------------
+// Shared library settings
+//-----------------------------------------------------------------------
+
+#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(ORXONOX_STATIC_BUILD)
+#  ifdef PICKUP_SHARED_BUILD
+#    define _PickupExport __declspec(dllexport)
+#  else
+#    if defined( __MINGW32__ )
+#      define _PickupExport
+#    else
+#      define _PickupExport __declspec(dllimport)
+#    endif
+#  endif
+#elif defined ( ORXONOX_GCC_VISIBILITY )
+#  define _PickupExport  __attribute__ ((visibility("default")))
+#else
+#  define _PickupExport
+#endif
+
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+
+namespace orxonox
+{
+
+    class DroppedPickup;
+    class Pickup;
+    class PickupCollection;
+    class PickupCollectionIdentifier;
+    class PickupManager;
+    class PickupRepresentation;
+    class PickupSpawner;
+    
+    //items
+    class HealthPickup;
+    class MetaPickup;
+    
+}
+
+#endif /* _PickupPrereqs_H__ */
Index: code/trunk/src/modules/pickup/PickupRepresentation.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupRepresentation.cc	(revision 6524)
+++ code/trunk/src/modules/pickup/PickupRepresentation.cc	(revision 6524)
@@ -0,0 +1,170 @@
+/*
+ *   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:
+ *      ...
+ *
+*/
+
+#include "PickupRepresentation.h"
+
+#include "core/CoreIncludes.h"
+#include "graphics/Billboard.h"
+#include "util/StringUtils.h"
+#include "PickupManager.h"
+
+namespace orxonox
+{
+    
+    CreateFactory(PickupRepresentation);
+    
+    /**
+    @brief
+        Constructor. Registers the object and initializes its member variables.
+        This is primarily for use of the PickupManager in creating a default PickupRepresentation.
+    */
+    //TODO: Not this as creator!!!
+    PickupRepresentation::PickupRepresentation() : BaseObject(this)
+    {
+        this->spawnerRepresentation_ = NULL;
+        
+        RegisterObject(PickupRepresentation);
+        
+        this->initialize();
+    }
+    
+    /**
+    @brief
+        Default Constructor. Registers the object and initializes its member variables.
+    */
+    PickupRepresentation::PickupRepresentation(BaseObject* creator) : BaseObject(creator)
+    {
+        this->spawnerRepresentation_ = NULL;
+        
+        RegisterObject(PickupRepresentation);
+        
+        this->initialize();
+    }
+    
+    /**
+    @brief
+        Destructor.
+    */
+    PickupRepresentation::~PickupRepresentation()
+    {
+        if(this->spawnerRepresentation_ != NULL)
+            this->spawnerRepresentation_->destroy();
+    }
+    
+    /**
+    @brief
+        Initializes the member variables of this PickupRepresentation.
+    */
+    void PickupRepresentation::initialize(void)
+    {
+        this->description_ = "This is a pickup.";
+        this->name_ = "Pickup";
+        this->spawnerTemplate_ = "";
+        this->pickup_ = NULL;
+    }
+    
+    /**
+    @brief
+        Method for creating a PickupRepresentation object through XML.
+    */
+    void PickupRepresentation::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(PickupRepresentation, XMLPort, xmlelement, mode);
+        
+        XMLPortParam(PickupRepresentation, "name", setName, getName, xmlelement, mode);
+        XMLPortParam(PickupRepresentation, "description", setDescription, getDescription, xmlelement, mode);
+        XMLPortParam(PickupRepresentation, "spawnerTemplate", setSpawnerTemplate, getSpawnerTemplate, xmlelement, mode);
+        XMLPortObject(PickupRepresentation, Pickupable, "pickup", setPickup, getPickup, xmlelement, mode);
+        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(this->spawnerRepresentation_ != NULL)
+            this->spawnerRepresentation_->setVisible(false);
+        
+        COUT(4) << "PickupRepresentation created: name: '" << this->name_ << "', description: '" << this->description_ << "', spawnerTemplate: '" << this->spawnerTemplate_ << "'." << std::endl;
+    }
+    
+    /**
+    @brief
+        Get a spawnerRepresentation for a specific PickupSpawner.
+    @param spawner
+        A pointer to the PickupSpawner.
+    @return
+        Returns a pointer to the StaticEntity.
+    */
+    StaticEntity* PickupRepresentation::getSpawnerRepresentation(PickupSpawner* spawner)
+    {
+        if(this->spawnerRepresentation_ == NULL)
+        {
+            COUT(4) << "PickupRepresentation: No spawner representation found." << std::endl;
+            if(this->spawnerTemplate_ == BLANKSTRING)
+            {
+                COUT(4) << "PickupRepresentation: Spawner template is empty." << std::endl;
+                //!< If neither spawnerRepresentation nor spawnerTemplate was specified
+                return this->getDefaultSpawnerRepresentation(spawner);
+            }
+            this->addTemplate(this->spawnerTemplate_);
+        }
+        
+        StaticEntity* representation = this->spawnerRepresentation_;
+        representation->setVisible(true);
+        
+        this->addTemplate(this->spawnerTemplate_);
+        this->spawnerRepresentation_->setVisible(false);
+        
+        return representation;
+    }
+    
+    /**
+    @brief
+        Get the default spawnerRepresentation for a specific PickupSpawner.
+        Helper method of internal use.
+    @param spawner
+        A pointer to the PickupSpawner.
+    @return
+        Returns a pointer to the StaticEntity.
+    */
+    //TODO: Think of more elegant solution.
+    StaticEntity* PickupRepresentation::getDefaultSpawnerRepresentation(PickupSpawner* spawner)
+    {
+        StaticEntity* representation = new StaticEntity(spawner);
+        Billboard* sphere = new Billboard(spawner);
+        sphere->setColour(ColourValue(0.95, 0.85, 0.27));
+        sphere->setMaterial("Sphere2");
+        sphere->setScale(0.1);
+        Billboard* icon = new Billboard(spawner);
+        icon->setColour(ColourValue(0.89, 0.79, 0.08));
+        icon->setMaterial("Asterix");
+        icon->setScale(0.5);
+        sphere->attach(icon);
+        representation->attach(sphere);
+        return representation;
+    }
+    
+}
Index: code/trunk/src/modules/pickup/PickupRepresentation.h
===================================================================
--- code/trunk/src/modules/pickup/PickupRepresentation.h	(revision 6524)
+++ code/trunk/src/modules/pickup/PickupRepresentation.h	(revision 6524)
@@ -0,0 +1,143 @@
+/*
+ *   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:
+ *      ...
+ *
+*/
+
+#ifndef _PickupRepresentation_H__
+#define _PickupRepresentation_H__
+
+#include "PickupPrereqs.h"
+
+#include "core/XMLPort.h"
+#include "interfaces/Pickupable.h"
+#include "pickup/PickupIdentifier.h"
+#include "worldentities/StaticEntity.h"
+#include "PickupSpawner.h"
+
+#include "core/BaseObject.h"
+
+namespace orxonox
+{
+
+    /**
+    @brief
+        The PickupRepresentation class represents a specific pickup type (identified by its PickupIdentifier). It defines the information displayed in the GUI and how PickupSpawners that spawn the pickup type look like.
+        They are created through XML and are registered with the PickupManager.
+    */
+    class _PickupExport PickupRepresentation : public BaseObject
+    {
+        
+        public:
+            PickupRepresentation(); //!< Constructor
+            PickupRepresentation(BaseObject* creator); //!< Default constructor.
+            virtual ~PickupRepresentation(); //!< Destructor.
+            
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            
+            /**
+            @brief Set the name of the Pickupable represented by this PickupRepresentation.
+            @param name The name.
+            */
+            inline void setName(const std::string& name)
+                { this->name_ = name; }
+            /**
+            @brief Set the description of the Pickupable represented by this PickupRepresentation.
+            @param description The Description.
+            */
+            inline void setDescription(const std::string& description)
+                { this->description_ = description; }
+            /**
+            @brief Set the spawnerTemplate of the Pickupable represented by this PickupRepresentation.
+                   The spawnerTemplate is a name of a template defined in XML that defines the StaticEntity that is the spawnerRepresentation of this PickupRepresentation.
+            @param spawnerTemplate The name of the template.
+            */
+            inline void setSpawnerTemplate(const std::string& spawnerTemplate)
+                { this->spawnerTemplate_ = spawnerTemplate; }
+            /**
+            @brief Set the StaticEntity that defines how the PickupSpawner of the Pickupable represented by this PickupRepresentation looks like.
+                   This will be set by the spawnerTemplate. Setting it when creating the PickupRepresentation without creating a template and specifying its name will be futile, because through the course of the game many PickupSpawners for one specific pickup type may have to be created, thus the StaticEntity that is the spawnerRepresentation has to be generated (with the template) for every new PickupSpawner spawning the Pickupable represented by this PickupRepresentation. The spawnerRepresentation that is set here, however can only be used once.
+            @param representation A pointer to the StaticEntity that is the spawnerRepresentation of this PickupRepresentation.
+            */
+            inline void setSpawnerRepresentation(StaticEntity* representation)
+                { this->spawnerRepresentation_ = representation; }
+            /**
+            @brief Set the Pickupable that is represented by this PickupRepresentation.
+            @param pickup A pointer to the Pickupable.
+            */
+            inline void setPickup(Pickupable* pickup)
+                { this->pickup_ = pickup; }
+                
+            /**
+            @brief Get the name of the Pickupable represented by this PickupRepresentation.
+            @return Returns the name.
+            */
+            inline const std::string& getName(void)
+                { return this->name_; }
+            /**
+            @brief Get the description of the Pickupable represented by this PickupRepresentation.
+            @return Returns the description.
+            */
+            inline const std::string& getDescription(void)
+                { return this->description_; }
+            /**
+            @brief Get the name of spawnerTemplate the Pickupable represented by this PickupRepresentation.
+            @return Returns the name of the spawnerTemplate.
+            */
+            inline const std::string& getSpawnerTemplate(void)
+                { return this->spawnerTemplate_; }
+            /**
+            @brief Get the StaticEntity that defines how the PickupSpawner of the Pickupable represented by this PickupRepresentation looks like.
+            @param index The index.
+            @return Returns (for index = 0) a pointer to the StaticEntity. For index > 0 it returns NULL.
+            */
+            inline const StaticEntity* getSpawnerRepresentationIndex(unsigned int index)
+                { if(index == 0) return this->spawnerRepresentation_; return NULL; }
+            /**
+            @brief Get the Pickupable represented by this PickupRepresentation.
+            @param index The index.
+            @return Returns (for index = 0) a pointer to the Pickupable. For index > 0 it returns NULL.
+            */
+            inline const Pickupable* getPickup(unsigned int index)
+                { if(index == 0) return this->pickup_; return NULL; }
+                
+            StaticEntity* getSpawnerRepresentation(PickupSpawner* spawner); //!< Get a spawnerRepresentation for a specific PickupSpawner.
+        
+        private:
+            void initialize(void); //!< Initializes the member variables of this PickupRepresentation.
+            StaticEntity* getDefaultSpawnerRepresentation(PickupSpawner* spawner); //!< Get the default spawnerRepresentation for a specific PickupSpawner.
+            
+            std::string name_; //!< The name of the Pickupable represented by this PickupRepresentation.
+            std::string description_; //!< The description of the Pickupable represented by this PickupRepresentation.
+            std::string spawnerTemplate_; //!<  The name of the template of this PickupRepresentation.
+            StaticEntity* spawnerRepresentation_; //!< The spawnerRepresentation of this PickupRepresentation.
+            
+            Pickupable* pickup_; //!< The Pickupable that is represented by this PickupRepresentation.
+            
+    };
+
+}
+    
+#endif // _PickupRepresentation_H__
Index: code/trunk/src/modules/pickup/PickupSpawner.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupSpawner.cc	(revision 6524)
+++ code/trunk/src/modules/pickup/PickupSpawner.cc	(revision 6524)
@@ -0,0 +1,360 @@
+/*
+ *   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:
+ *      Daniel 'Huty' Haggenmueller
+ *   Co-authors:
+ *      Damian 'Mozork' Frick
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of PickupSpawner.
+*/
+
+#include "PickupSpawner.h"
+
+#include "core/CoreIncludes.h"
+#include "core/Template.h"
+#include "core/XMLPort.h"
+#include "worldentities/pawns/Pawn.h"
+#include "PickupManager.h"
+#include "PickupRepresentation.h"
+
+namespace orxonox
+{
+
+    CreateFactory(PickupSpawner);
+
+    /**
+    @brief
+        Constructor. Creates a blank PickupSpawner.
+    @param creator
+        Pointer to the object which created this item.
+    */
+    PickupSpawner::PickupSpawner(BaseObject* creator) : StaticEntity(creator)
+    {
+        this->initialize();
+
+        RegisterObject(PickupSpawner);
+    }
+
+    /**
+    @brief
+        Constructor, Creates a fully functional PickupSpawner.
+    @param creator
+        The creator of this PickupSpawner.
+    @param pickup
+        The Pickupable to be spawned by this PickupSpawner.
+    @param triggerDistance
+        The distance at which the PickupSpawner will trigger.
+    @param respawnTime
+        The minimum time between two spawns.
+    @param maySpawnedItems
+        The maximum number of items spawned by this PickupSpawner.
+    */
+    PickupSpawner::PickupSpawner(BaseObject* creator, Pickupable* pickup, float triggerDistance, float respawnTime, int maxSpawnedItems) : StaticEntity(creator)
+    {
+        RegisterObject(PickupSpawner);
+        
+        this->initialize();
+  
+        this->pickup_ = pickup;
+
+        this->triggerDistance_ = triggerDistance;
+        this->respawnTime_ = respawnTime;
+        this->setMaxSpawnedItems(maxSpawnedItems);
+        
+        if(this->pickup_ == NULL)
+        {
+            COUT(2) << "A PickupSpawner was created without a valid Pickupable. This won't work." << std::endl;
+            this->setActive(false);
+        }
+        else
+        {
+            PickupRepresentation* representation = PickupManager::getInstance().getRepresentation(this->pickup_->getPickupIdentifier());
+            this->attach(representation->getSpawnerRepresentation(this));
+        }
+    }
+
+    /**
+    @brief
+        Registers the object and sets some default values.
+    */
+    void PickupSpawner::initialize(void)
+    {
+        this->pickup_ = NULL;
+        
+        this->triggerDistance_ = 20;
+        this->respawnTime_ = 0;
+        this->maxSpawnedItems_ = INF;
+        this->spawnsRemaining_ = INF;
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
+    PickupSpawner::~PickupSpawner()
+    {
+        if(this->pickup_ != NULL)
+            this->pickup_->destroy();
+    }
+
+    /**
+    @brief
+        Method for creating a PickupSpawner through XML.
+    @param xmlelement
+        XML element which contains the PickupSpawner.
+    @param mode
+        XMLPort mode.
+    */
+    void PickupSpawner::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(PickupSpawner, XMLPort, xmlelement, mode);
+
+        XMLPortObject(PickupSpawner, Pickupable, "pickup", setPickupable, getPickupable, xmlelement, mode);
+        
+        XMLPortParam(PickupSpawner, "triggerDistance", setTriggerDistance, getTriggerDistance, xmlelement, mode);
+        XMLPortParam(PickupSpawner, "respawnTime", setRespawnTime, getRespawnTime, xmlelement, mode);
+        XMLPortParam(PickupSpawner, "maxSpawnedItems", setMaxSpawnedItems, getMaxSpawnedItems, xmlelement, mode);
+        
+        if(this->pickup_ == NULL)
+        {
+            COUT(2) << "A PickupSpawner was created without a valid Pickupable. This won't work." << std::endl;
+            this->setActive(false);
+        }
+        else
+        {
+            PickupRepresentation* representation = PickupManager::getInstance().getRepresentation(this->pickup_->getPickupIdentifier());
+            representation->setVisible(this->isActive());
+            this->attach(representation->getSpawnerRepresentation(this));
+            this->setActive(true);
+        }
+    }
+    
+    /**
+    @brief
+        Invoked when the activity has changed. Sets visibility of attached objects.
+    */
+    void PickupSpawner::changedActivity()
+    {
+        SUPER(PickupSpawner, changedActivity);
+
+        this->setVisible(this->isActive());
+    }
+     
+    /**
+    @brief
+        Tick, checks if any Pawn is close enough to trigger.
+    @param dt
+        Time since last tick.
+    */
+    //TODO: Replace this with a real DistanceTrigger? Or better with collisions?
+    void PickupSpawner::tick(float dt)
+    {
+        //! If the PickupSpawner is active.
+        if (this->isActive())
+        {
+            //! Iterate trough all Pawns.
+            for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+            {
+                Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
+                //! If a Pawn, that fits the target-range of the item spawned by this Pickup, is in trigger-distance.
+                if (distance.length() < this->triggerDistance_ && this->pickup_->isTarget(*it))
+                {
+                    this->trigger(*it);
+                }
+            }
+        }
+    }
+    
+    /**
+    @brief
+        Sets the maximum number of spawned items.
+    @param items
+        The maximum number of spawned items to be set.
+    */
+    void PickupSpawner::setMaxSpawnedItems(int items)
+    {
+        this->maxSpawnedItems_ = items;
+        this->spawnsRemaining_ = items;
+    }
+    
+    /**
+    @brief
+        Decrements the number of remaining spawns.
+        Sets the PickupSpawner to inactive for the duration of the respawnTime.
+        Destroys the PickupSpawner if the number of remaining spawns has reached zero.
+    */
+    void PickupSpawner::decrementSpawnsRemaining(void)
+    {
+        if(this->spawnsRemaining_ != INF)
+        {
+            this->spawnsRemaining_--;
+        }
+        if(this->spawnsRemaining_ != 0 && this->respawnTime_ > 0)
+        {
+            //TODO: Nicer? Does this even work?
+            this->startRespawnTimer();
+
+            this->setActive(false);
+            this->fireEvent();
+        }
+        else
+        {
+            COUT(3) << "PickupSpawner empty, selfdestruct initialized." << std::endl;
+            this->setActive(false);
+            this->destroy();
+        }
+    }
+    
+    /**
+    @brief
+        Starts the respawn timer.
+    */
+    void PickupSpawner::startRespawnTimer(void)
+    {
+        this->respawnTimer_.setTimer(this->respawnTime_, false, createExecutor(createFunctor(&PickupSpawner::respawnTimerCallback, this)));
+    }
+    
+    /**
+    @brief
+        Sets a Pickupable for the PickupSpawner to spawn.
+    @param pickup
+        The Pickupable to be set.
+    */
+    void PickupSpawner::setPickupable(Pickupable* pickup)
+    {
+        if(this->pickup_ != NULL)
+        {
+            COUT(1) << "In PickupSpawner: setPickupable called, with this->pickup_ already set." << std::endl;
+            return;
+        }
+        if(pickup == NULL)
+        {
+            COUT(1) << "In PickupSpawner: Argument of setPickupable is NULL." << std::endl;
+            return;
+        }
+        
+        this->pickup_ = pickup;
+    }
+    
+    /**
+    @brief
+        Get the Pickupable that is spawned by this PickupSpawner.
+    @return
+        Returns the Pickupable that is spawned by this PickupSpawner.
+    */
+    const Pickupable* PickupSpawner::getPickupable(void)
+    {
+        return this->pickup_;
+    }
+
+    /**
+    @brief
+        Trigger the PickupSpawner.
+        Adds the pickup to the Pawn that triggered, sets the timer to re-activate and deactives the PickupSpawner.
+    @param pawn
+        Pawn which triggered the PickupSpawner.
+    */
+    //TODO: Make more generic -> without pawn.
+    void PickupSpawner::trigger(Pawn* pawn)
+    {
+        if (this->isActive()) //!< Checks whether PickupSpawner is active.
+        {
+            COUT(3) << "PickupSpawner triggered and active." << std::endl;
+            
+            PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(pawn);
+            if(carrier == NULL)
+            {
+                COUT(1) << "This is bad. Pawn isn't PickupCarrier." << std::endl;
+                return;
+            }
+            
+            if(!carrier->isTarget(this->pickup_))
+            {
+                COUT(4) << "PickupSpawner triggered but Pawn wasn't a target of the Pickupable." << std::endl;
+                return;
+            }
+            
+            PickupCarrier* target = carrier->getTarget(this->pickup_);
+            Pickupable* pickup = this->getPickup();
+            
+            if(target != NULL && pickup != NULL)
+            {
+                if(target->pickup(pickup))
+                {
+                    this->decrementSpawnsRemaining();
+                }
+                else
+                {
+                    pickup->destroy();
+                }
+            }
+            else
+            {
+                //TODO: Really that severe?
+                if(target == NULL)
+                    COUT(1) << "PickupSpawner: Pickupable has no target." << std::endl;
+                
+                if(pickup == NULL)
+                {
+                    COUT(1) << "PickupSpawner: getPickup produced an error, no Pickupable created." << std::endl;
+                }
+                else
+                {
+                    pickup->destroy();
+                }
+            }
+        }
+    }
+
+    /**
+    @brief
+        Creates a new Pickupable.
+    @return
+        The Pickupable created.
+    */    
+    Pickupable* PickupSpawner::getPickup(void)
+    {
+        if(this->spawnsRemaining_ == 0)
+        {
+            COUT(1) << "Massive Error: PickupSpawner still alive until having spawned last item." << std::endl;
+            return NULL;
+        }
+        
+        Pickupable* pickup = this->pickup_->clone();
+        return pickup;
+    }
+
+    /**
+    @brief
+        Invoked by the timer, re-activates the PickupSpawner.
+    */
+    void PickupSpawner::respawnTimerCallback()
+    {
+        COUT(3) << "PickupSpawner reactivated." << std::endl;
+
+        this->setActive(true);
+    }
+}
Index: code/trunk/src/modules/pickup/PickupSpawner.h
===================================================================
--- code/trunk/src/modules/pickup/PickupSpawner.h	(revision 6524)
+++ code/trunk/src/modules/pickup/PickupSpawner.h	(revision 6524)
@@ -0,0 +1,131 @@
+/*
+ *   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:
+ *      Daniel 'Huty' Haggenmueller
+ *   Co-authors:
+ *      Damian 'Mozork' Frick
+ *
+ */
+
+/**
+    @file
+    @brief Definition of PickupSpawner.
+*/
+
+#ifndef _PickupSpawner_H__
+#define _PickupSpawner_H__
+
+#include "PickupPrereqs.h"
+
+#include <string>
+#include "interfaces/Pickupable.h"
+#include "tools/Timer.h"
+
+#include "tools/interfaces/Tickable.h"
+#include "worldentities/StaticEntity.h"
+
+namespace orxonox
+{
+    /**
+        @brief
+            The PickupSpawner class is responsible for spawning pickups of a specific type.
+            Forthermore it can be specified how long the time interval between spawning two items is and how many pickups are spawned at maximum, amongst other things.
+        @author
+            Daniel 'Huty' Haggenmueller
+            Damian 'Mozork' Frick
+    */
+    class _PickupExport PickupSpawner : public StaticEntity, public Tickable
+    {
+        public:
+            PickupSpawner(BaseObject* creator); //!< Default Constructor.
+            PickupSpawner(BaseObject* creator, Pickupable* pickup, float triggerDistance, float respawnTime, int maxSpawnedItems); //!< Constructor.
+            virtual ~PickupSpawner(); //!< Destructor.
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);  //!< Method for creating a PickupSpawner through XML.
+            virtual void changedActivity(); //!< Invoked when activity has changed (set visibilty).
+            virtual void tick(float dt);
+
+            /**
+            @brief Get the distance in which to trigger.
+            @return Returns the distance in which this gets triggered.
+            */
+            inline float getTriggerDistance() const
+                { return this->triggerDistance_; }
+            /**
+            @brief Set the distance in which to trigger.
+            @param value The new distance in which to trigger.
+            */
+            inline void setTriggerDistance(float value)
+                { this->triggerDistance_ = value; }
+
+            /**
+            @brief Get the time to respawn.
+            @returns Returns the time after which this gets re-actived.
+            */
+            inline float getRespawnTime() const
+                { return this->respawnTime_; }
+            /**
+            @brief Set the time to respawn.
+            @param time New time after which this gets re-actived.
+            */
+            inline void setRespawnTime(float time)
+                { this->respawnTime_ = time; }
+
+            /**
+            @brief Get the maximum number of items that will be spawned by this PickupSpawner.
+            @return Returns the maximum number of items spawned by this PickupSpawner.
+            */
+            inline int getMaxSpawnedItems(void)
+                { return this->maxSpawnedItems_; }
+            void setMaxSpawnedItems(int items); //!< Sets the maximum number of spawned items.
+
+        protected:
+            void decrementSpawnsRemaining(void); //!< Decrements the number of remaining spawns.
+                        
+            void startRespawnTimer(void);
+            
+            virtual Pickupable* getPickup(void); //!< Creates a new Pickupable.
+            
+            void setPickupable(Pickupable* pickup); //!< Sets a Pickupable for the PickupSpawner to spawn.
+            const Pickupable* getPickupable(void); //!< Get the Pickupable that is spawned by this PickupSpawner.
+            
+            Pickupable* pickup_; //!< The pickup to be spawned.
+
+        private:
+            void initialize(void);
+            
+            void trigger(Pawn* pawn); //!< Method called when a Pawn is close enough.
+            void respawnTimerCallback(); //!< Method called when the timer runs out.
+
+            int maxSpawnedItems_; //!< Maximum number of items spawned by this PickupSpawner.
+            int spawnsRemaining_; //!< Number of items that can be spawned by this PickupSpawner until it selfdestructs.
+
+            float triggerDistance_; //!< Distance in which this gets triggered.
+
+            float respawnTime_; //!< Time after which this gets re-actived.
+            Timer respawnTimer_; //!< Timer used for re-activating.
+
+            static const int INF = -1; //!< Constant for infinity.
+    };
+}
+
+#endif /* _PickupSpawner_H__ */
Index: code/trunk/src/modules/pickup/items/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/pickup/items/CMakeLists.txt	(revision 6524)
+++ code/trunk/src/modules/pickup/items/CMakeLists.txt	(revision 6524)
@@ -0,0 +1,4 @@
+ADD_SOURCE_FILES(PICKUP_SRC_FILES
+  HealthPickup.cc
+  MetaPickup.cc
+)
Index: code/trunk/src/modules/pickup/items/HealthPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/HealthPickup.cc	(revision 6524)
+++ code/trunk/src/modules/pickup/items/HealthPickup.cc	(revision 6524)
@@ -0,0 +1,382 @@
+/*
+ *   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:
+ *      ...
+ *
+ */
+
+#include "HealthPickup.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "util/StringUtils.h"
+
+#include "worldentities/pawns/Pawn.h"
+#include "pickup/PickupIdentifier.h"
+
+#include <sstream>
+
+namespace orxonox
+{
+    
+    /*static*/ const std::string HealthPickup::healthTypeLimited_s = "limited";
+    /*static*/ const std::string HealthPickup::healthTypeTemporary_s = "temporary";
+    /*static*/ const std::string HealthPickup::healthTypePermanent_s = "permanent";
+    
+    CreateFactory(HealthPickup);
+    
+    /**
+    @brief
+        Constructor. Registers the object and initializes the member variables.
+    */
+    HealthPickup::HealthPickup(BaseObject* creator) : Pickup(creator)
+    {
+        RegisterObject(HealthPickup);
+        
+        this->initialize();
+    }
+    
+    /**
+    @brief
+        Destructor.
+    */
+    HealthPickup::~HealthPickup()
+    {
+        
+    }
+    
+    /**
+    @brief 
+        Initializes the member variables.
+    */
+    void HealthPickup::initialize(void)
+    {        
+        this->health_ = 0;
+        this->healthRate_ = 0;
+        this->healthType_ = pickupHealthType::limited;
+        this->maxHealthSave_ = 0;
+        this->maxHealthOverwrite_ = 0;
+        
+        this->addTarget(ClassIdentifier<Pawn>::getIdentifier());
+    }
+    
+    /**
+    @brief
+        Initializes the PickupIdentifier of this pickup.
+    */
+    void HealthPickup::initializeIdentifier(void)
+    {
+        std::stringstream stream;
+        stream << this->getHealth();
+        std::string type1 = "health";
+        std::string val1 = stream.str();
+        this->pickupIdentifier_->addParameter(type1, val1);
+        
+        //TODO: Does this work, is val valid outside the function scope?
+        std::string val2 = this->getHealthType();
+        std::string type2 = "healthType";
+        this->pickupIdentifier_->addParameter(type2, val2);
+        
+        stream.clear();
+        stream << this->getHealthRate();
+        std::string val3 = stream.str();
+        std::string type3 = "healthRate";
+        this->pickupIdentifier_->addParameter(type3, val3);
+    }
+    
+    /**
+    @brief
+        Method for creating a HealthPickup object through XML.
+    */
+    void HealthPickup::XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode)
+    {
+        SUPER(HealthPickup, XMLPort, xmlelement, mode);
+        
+        XMLPortParam(HealthPickup, "health", setHealth, getHealth, xmlelement, mode);
+        XMLPortParam(HealthPickup, "healthRate", setHealthRate, getHealthRate, xmlelement, mode);
+        XMLPortParam(HealthPickup, "healthType", setHealthType, getHealthType, xmlelement, mode);
+        
+        if(!this->isContinuous())
+            this->healthRate_ = 0.0;
+        
+        this->initializeIdentifier();
+    }
+    
+    /**
+    @brief
+        Is called every tick.
+        Does all the continuous stuff of this HealthPickup.
+    @param dt
+        The duration of the last tick.
+    */
+    void HealthPickup::tick(float dt)
+    {
+        if(this->isContinuous() && this->isUsed())
+        {
+            Pawn* pawn = this->carrierToPawnHelper();
+            if(pawn == NULL) //!< If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+                this->destroy();
+            
+            //! Calculate the health that is added this tick.
+            float health = dt*this->getHealthRate();
+            if(health > this->getHealth())
+                health = this->getHealth();
+            //! Calculate the health the Pawn will have once the health is added.
+            float fullHealth = pawn->getHealth() + health;
+            this->setHealth(this->getHealth()-health);
+                    
+            switch(this->getHealthTypeDirect())
+            {
+                case pickupHealthType::permanent:
+                    if(pawn->getMaxHealth() < fullHealth)
+                        pawn->setMaxHealth(fullHealth);
+                case pickupHealthType::limited:
+                    pawn->addHealth(health);
+                    break;
+                case pickupHealthType::temporary:
+                    if(pawn->getMaxHealth() > fullHealth)
+                    {
+                        this->maxHealthSave_ = pawn->getMaxHealth();
+                        this->maxHealthOverwrite_ = fullHealth;
+                        pawn->setMaxHealth(fullHealth);
+                    }
+                    pawn->addHealth(health);
+                    break;
+                default:
+                    COUT(1) << "Invalid healthType in HealthPickup." << std::endl;
+            }
+            
+            //! If all health has been transfered.
+            if(this->getHealth() == 0)
+            {
+                this->setUsed(false);
+            }
+        }
+    }
+    
+    /**
+    @brief
+        Is called when the pickup has transited from used to unused or the other way around.
+    */
+    void HealthPickup::changedUsed(void)
+    {
+        SUPER(HealthPickup, changedUsed);
+        
+        //! If the pickup is not picked up nothing must be done.
+        if(!this->isPickedUp())
+            return;
+        
+        //! If the pickup has transited to used.
+        if(this->isUsed())
+        {
+            if(this->isOnce())
+            {
+                Pawn* pawn = this->carrierToPawnHelper();
+                if(pawn == NULL) //!< If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+                    this->destroy();
+                
+                float health = 0;
+                switch(this->getHealthTypeDirect())
+                {
+                    case pickupHealthType::permanent:
+                        health = pawn->getHealth()+this->getHealth();
+                        if(pawn->getMaxHealth() < health)
+                            pawn->setMaxHealth(health);
+                    case pickupHealthType::limited:
+                        pawn->addHealth(this->getHealth());
+                        break;
+                    case pickupHealthType::temporary:
+                        health = pawn->getHealth()+this->getHealth();
+                        if(pawn->getMaxHealth() < health)
+                        {
+                            this->maxHealthSave_ = pawn->getMaxHealth();
+                            this->maxHealthOverwrite_ = health;
+                            pawn->setMaxHealth(health);
+                        }
+                        pawn->addHealth(this->getHealth());
+                        break;
+                    default:
+                        COUT(1) << "Invalid healthType in HealthPickup." << std::endl;
+                }
+                
+                //! The pickup has been used up.
+                this->setUsed(false);
+            }
+        }
+        else
+        {
+            if(this->getHealthTypeDirect() == pickupHealthType::temporary)
+            {
+                PickupCarrier* carrier = this->getCarrier();
+                Pawn* pawn = dynamic_cast<Pawn*>(carrier);
+                
+                if(pawn == NULL)
+                {
+                    COUT(1) << "Something went horribly wrong in Health Pickup. PickupCarrier is no Pawn." << std::endl;
+                    this->destroy();
+                    return;
+                }
+                
+                if(pawn->getMaxHealth() == this->maxHealthOverwrite_)
+                {
+                    pawn->setMaxHealth(this->maxHealthSave_);
+                    this->maxHealthOverwrite_ = 0;
+                    this->maxHealthSave_ = 0;
+                }
+            }
+            
+            //! If either the pickup can only be used once or it is continuous and used up, it is destroyed upon setting it to unused.
+            if(this->isOnce() || (this->isContinuous() && this->getHealth() == 0))
+            {
+                this->destroy();
+            }
+        }
+    }
+    
+    /**
+    @brief
+        Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
+    @return
+        A pointer to the Pawn, or NULL if the conversion failed.
+    */
+    Pawn* HealthPickup::carrierToPawnHelper(void)
+    {
+        PickupCarrier* carrier = this->getCarrier();
+        Pawn* pawn = dynamic_cast<Pawn*>(carrier);
+        
+        if(pawn == NULL)
+        {
+            COUT(1) << "Invalid PickupCarrier in HealthPickup." << std::endl;
+        }
+        
+        return pawn;
+    }
+    
+    /**
+    @brief
+        Creates a duplicate of the input OrxonoxClass.
+    @param item
+        A pointer to the Orxonox class.
+    */
+    void HealthPickup::clone(OrxonoxClass*& item)
+    {
+        if(item == NULL)
+            item = new HealthPickup(this);
+        
+        SUPER(HealthPickup, clone, item);
+        
+        HealthPickup* pickup = dynamic_cast<HealthPickup*>(item);
+        pickup->setHealth(this->getHealth());
+        pickup->setHealthRate(this->getHealthRate());
+        pickup->setHealthTypeDirect(this->getHealthTypeDirect());
+        
+        pickup->initializeIdentifier();
+    }
+    
+    /**
+    @brief
+        Get the health type of this pickup.
+    @return
+        Returns the health type as a string.
+    */
+    const std::string& HealthPickup::getHealthType(void)
+    {
+        switch(this->getHealthTypeDirect())
+        {
+            case pickupHealthType::limited:
+                return HealthPickup::healthTypeLimited_s;
+            case pickupHealthType::temporary:
+                return HealthPickup::healthTypeTemporary_s;
+            case pickupHealthType::permanent:
+                return HealthPickup::healthTypePermanent_s;
+            default:
+                COUT(1) << "Invalid healthType in HealthPickup." << std::endl;
+                return BLANKSTRING;
+        }
+    }
+    
+    /**
+    @brief
+        Sets the health.
+    @param health
+        The health.
+    */
+    void HealthPickup::setHealth(float health)
+    {
+        if(health >= 0.0f)
+        {
+            this->health_ = health;
+        }
+        else
+        {
+            COUT(1) << "Invalid health in HealthPickup." << std::endl;
+            this->health_ = 0.0;
+        }
+    }
+    
+    /**
+    @brief
+        Set the rate at which health is transferred if the pickup is continuous.
+    @param rate
+        The rate.
+    */
+    void HealthPickup::setHealthRate(float rate)
+    {
+        if(rate >= 0)
+        {
+            this->healthRate_ = rate;
+        }
+        else
+        {
+            COUT(1) << "Invalid healthSpeed in HealthPickup." << std::endl; 
+        }
+    }
+    
+    /**
+    @brief
+        Set the type of the HealthPickup.
+    @param type
+        The type as a string.
+    */
+    void HealthPickup::setHealthType(std::string type)
+    {
+        if(type == HealthPickup::healthTypeLimited_s)
+        {
+            this->setHealthTypeDirect(pickupHealthType::limited);
+        }
+        else if(type == HealthPickup::healthTypeTemporary_s)
+        {
+            this->setHealthTypeDirect(pickupHealthType::temporary);
+        }
+        else if(type == HealthPickup::healthTypePermanent_s)
+        {
+            this->setHealthTypeDirect(pickupHealthType::permanent);
+        }
+        else
+        {
+            COUT(1) << "Invalid healthType in HealthPickup." << std::endl;
+        }
+    }
+
+}
Index: code/trunk/src/modules/pickup/items/HealthPickup.h
===================================================================
--- code/trunk/src/modules/pickup/items/HealthPickup.h	(revision 6524)
+++ code/trunk/src/modules/pickup/items/HealthPickup.h	(revision 6524)
@@ -0,0 +1,131 @@
+/*
+ *   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:
+ *      ...
+ *
+ */
+
+#ifndef _HealthPickup_H__
+#define _HealthPickup_H__
+
+#include "pickup/PickupPrereqs.h"
+
+#include <string>
+#include <worldentities/pawns/Pawn.h>
+#include "worldentities/StaticEntity.h"
+
+#include "pickup/Pickup.h"
+#include "tools/interfaces/Tickable.h"
+
+namespace orxonox {
+    
+    //! Enum for the type of the HealthPickup
+    namespace pickupHealthType
+    {
+        enum Value
+        {
+            limited,
+            temporary,
+            permanent
+        };
+    }
+    
+    /**
+    @brief
+        A pickup that can do (dependent upon the parameters) lots of different things to the health of a Pawn.
+        There are 4 parameters that can be chosen:
+        1) The health. The amount of health that (in a way dependent on the other parameters) is transfered to the Pawn.
+        2) The activation type: It can be chosen to be either 'immediate' or 'onUse'. The activation type essentially (as indicated by the name) defines when the health is transfered, either immediately after being picked up or only after the player uses it.
+        3) The duration type: It can be chosen to be either 'once' or 'continuous'. For 'once' the specified health is transfered once to the Pawn, for 'continuous' the set health is transfered over a span of time at a rate defined by the health rate parameter.
+        4) The health type: The health type can be chosen to be 'limited', 'temporary' or 'permanent'. 'limited' means that the health is increased only to the maximum health of the Pawn. 'temporary' means that the maximum health is temporarily elevated but will be set back as soon as the pickup is no longer in use. 'permanent' means that the maximum health of the Pawn is increased such that the health provided by the pickup will fit in and the maximum health stays that way.
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _PickupExport HealthPickup : public Pickup, public Tickable
+    {
+        public:
+        
+            HealthPickup(BaseObject* creator); //!< Constructor.
+            virtual ~HealthPickup(); //!< Destructor.
+            
+            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a HealthPickup object through XML.
+            virtual void tick(float dt); //!< Is called every tick.
+            
+            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 Get the health that is transfered to the Pawn upon usage of this pickup.
+            @return Returns the health.
+            */
+            inline float getHealth(void)
+                { return this->health_; }
+            /**
+            @brief Get the rate at which the health is transferred to the Pawn, if this pickup has duration type 'continuous'.
+            @return Returns the rate.
+            */
+            inline float getHealthRate(void)
+                { return this->healthRate_; }
+                
+            /**
+            @brief Get the type of HealthPickup, this pickup is.
+            @return Returns the health type as an enum. 
+            */
+            inline pickupHealthType::Value getHealthTypeDirect(void)
+                { return this->healthType_; }
+            const std::string& getHealthType(void); //!< Get the health type of this pickup.
+            
+        protected:
+            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
+
+            void setHealth(float health); //!< Sets the health.
+            void setHealthRate(float speed); //!< Set the rate at which health is transferred if the pickup is continuous.
+            
+            /**
+            @brief Set the health type of this pickup.
+            @param type The type of this pickup as an enum.
+            */
+            inline void setHealthTypeDirect(pickupHealthType::Value type)
+                { this->healthType_ = type; }
+            void setHealthType(std::string type); //!< Set the type of the HealthPickup.
+        
+        private:
+            void initialize(void); //!< Initializes the member variables.
+            Pawn* carrierToPawnHelper(void); //!< Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
+            
+            float health_; //!< The health that is transferred to the Pawn.
+            float healthRate_; //!< The rate at which the health is transferred.
+            float maxHealthSave_; //!< Helper to remember what the actual maxHealth of the Pawn was before we changed it.
+            float maxHealthOverwrite_; //!< Helper to remember with which value we overwrote the maxHealh, to detect if someone else changed it as well.
+            pickupHealthType::Value healthType_; //!< The type of the HealthPickup.
+            
+            //! Strings for the health types.
+            static const std::string healthTypeLimited_s;
+            static const std::string healthTypeTemporary_s;
+            static const std::string healthTypePermanent_s;
+        
+    };
+}
+
+#endif // _HealthPickup_H__
Index: code/trunk/src/modules/pickup/items/MetaPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/MetaPickup.cc	(revision 6524)
+++ code/trunk/src/modules/pickup/items/MetaPickup.cc	(revision 6524)
@@ -0,0 +1,161 @@
+/*
+ *   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 MetaPickup class.
+*/
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "interfaces/PickupCarrier.h"
+#include "pickup/PickupIdentifier.h"
+
+#include "MetaPickup.h"
+
+namespace orxonox {
+ 
+    CreateFactory(MetaPickup);
+    
+    /*static*/ const std::string MetaPickup::metaTypeNone_s = "none";
+    /*static*/ const std::string MetaPickup::metaTypeUse_s = "use";
+    /*static*/ const std::string MetaPickup::metaTypeDrop_s = "drop";
+    
+    /**
+    @brief
+        Constructor. 
+    */
+    MetaPickup::MetaPickup(BaseObject* creator) : Pickup(creator)
+    {
+        RegisterObject(MetaPickup);
+        
+        this->addTarget(ClassIdentifier<PickupCarrier>::getIdentifier());
+        this->setActivationTypeDirect(pickupActivationType::immediate);
+        this->setDurationTypeDirect(pickupDurationType::once);
+        this->metaType_ = pickupMetaType::none;
+    }
+    
+    MetaPickup::~MetaPickup()
+    {
+        
+    }
+    
+    void MetaPickup::initializeIdentifier(void)
+    {
+        std::string val = this->getMetaType();
+        std::string type = "metaType";
+        this->pickupIdentifier_->addParameter(type, val);
+    }
+    
+    void MetaPickup::XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode)
+    {
+        SUPER(MetaPickup, XMLPort, xmlelement, mode);
+        
+        XMLPortParam(MetaPickup, "metaType", setMetaType, getMetaType, xmlelement, mode);
+        
+        this->initializeIdentifier();
+    }
+    
+    void MetaPickup::changedUsed(void)
+    {
+        SUPER(MetaPickup, changedUsed);
+        
+        if(this->isUsed())
+        {
+            PickupCarrier* carrier = this->getCarrier();
+            if(this->getMetaTypeDirect() != pickupMetaType::none && carrier != NULL)
+            {
+                std::set<Pickupable*> pickups = carrier->getPickups();
+                for(std::set<Pickupable*>::iterator it = pickups.begin(); it != pickups.end(); it++)
+                {
+                    Pickup* pickup = dynamic_cast<Pickup*>(*it);
+                    if(this->getMetaTypeDirect() == pickupMetaType::use)
+                    {
+                        if(pickup != NULL && pickup != this && pickup->isOnUse() && !pickup->isUsed())
+                        {
+                            pickup->setUsed(true);
+                        }
+                    }
+                    if(this->getMetaTypeDirect() == pickupMetaType::drop)
+                    {
+                        if(pickup != NULL && pickup != this)
+                        {
+                            carrier->drop(pickup);
+                        }
+                    }
+                }
+            }
+            this->destroy();
+        }
+    }
+    
+    const std::string& MetaPickup::getMetaType(void)
+    {
+        switch(this->getMetaTypeDirect())
+        {
+            case pickupMetaType::none:
+                return MetaPickup::metaTypeNone_s;
+            case pickupMetaType::use:
+                return MetaPickup::metaTypeUse_s;
+            case pickupMetaType::drop:
+                return MetaPickup::metaTypeDrop_s;
+            default:
+                return BLANKSTRING;
+        }
+    }
+    
+    void MetaPickup::setMetaType(const std::string& type)
+    {
+        if(type == MetaPickup::metaTypeNone_s)
+        {
+            this->setMetaTypeDirect(pickupMetaType::none);
+        }
+        else if(type == MetaPickup::metaTypeUse_s)
+        {
+            this->setMetaTypeDirect(pickupMetaType::use);
+        }
+        else if(type == MetaPickup::metaTypeDrop_s)
+        {
+            this->setMetaTypeDirect(pickupMetaType::drop);
+        }
+    }
+    
+    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 6524)
+++ code/trunk/src/modules/pickup/items/MetaPickup.h	(revision 6524)
@@ -0,0 +1,96 @@
+/*
+ *   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 Definition of the MetaPickup class.
+*/
+
+#ifndef _MetaPickup_H__
+#define _MetaPickup_H__
+
+#include "pickup/PickupPrereqs.h"
+
+#include "pickup/Pickup.h"
+
+namespace orxonox {
+
+    //! The meta type, deciding what the pickup does exactly.
+    namespace pickupMetaType
+    {
+        enum Value
+        {
+            none,
+            use,
+            drop
+        };
+    }
+    
+    /**
+    @brief
+        The MetaPickup is a pickup that can, depending on the parameters, either drop all pickups of the PickupCarrier that picks it up, or use all the unused pickups of the PickupCarrier, that picks it up. The parameter to set for this is the metaType and it can be used with the values 'none', 'drop' and 'use'.
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _PickupExport MetaPickup : public Pickup
+    {
+        
+        public:
+            MetaPickup(BaseObject* creator);
+            virtual ~MetaPickup();
+            
+            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a HealthPickup 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.
+            
+            inline pickupMetaType::Value getMetaTypeDirect(void)
+                { return this->metaType_; }
+            const std::string& getMetaType(void);
+            
+        protected:
+            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
+            
+            inline void setMetaTypeDirect(pickupMetaType::Value type)
+                { this->metaType_ =  type; }
+            void setMetaType(const std::string& type);
+            
+        private:
+            void initialize(void); //!< Initializes the member variables.
+            
+            pickupMetaType::Value metaType_;
+            static const std::string metaTypeNone_s;
+            static const std::string metaTypeUse_s;
+            static const std::string metaTypeDrop_s;
+            
+        
+    };
+
+}
+
+#endif // _TestPickup_H__
Index: code/trunk/src/modules/weapons/projectiles/Projectile.cc
===================================================================
--- code/trunk/src/modules/weapons/projectiles/Projectile.cc	(revision 6502)
+++ code/trunk/src/modules/weapons/projectiles/Projectile.cc	(revision 6524)
@@ -124,6 +124,7 @@
 
             float dmg = this->damage_;
-            if (this->owner_)
-                dmg = this->owner_->getPickups().processModifiers(ModifierType::Damage, dmg, false);
+            //TODO: Remove.
+//             if (this->owner_)
+//                 dmg = this->owner_->getPickups().processModifiers(ModifierType::Damage, dmg, false);
 
             Pawn* victim = orxonox_cast<Pawn*>(otherObject);
Index: code/trunk/src/modules/weapons/projectiles/Rocket.cc
===================================================================
--- code/trunk/src/modules/weapons/projectiles/Rocket.cc	(revision 6502)
+++ code/trunk/src/modules/weapons/projectiles/Rocket.cc	(revision 6524)
@@ -201,6 +201,7 @@
 
             float dmg = this->damage_;
-            if (this->owner_)
-                dmg = this->owner_->getPickups().processModifiers(ModifierType::Damage, dmg, false);
+            //TODO: This souldn't be necessary here.
+            //if (this->owner_)
+            //    dmg = this->owner_->getPickups().processModifiers(ModifierType::Damage, dmg, false);
 
             Pawn* victim = orxonox_cast<Pawn*>(otherObject);
