Index: code/branches/pickup3/src/orxonox/interfaces/InterfaceCompilation.cc
===================================================================
--- code/branches/pickup3/src/orxonox/interfaces/InterfaceCompilation.cc	(revision 6467)
+++ code/branches/pickup3/src/orxonox/interfaces/InterfaceCompilation.cc	(revision 6474)
@@ -59,4 +59,15 @@
     {
         RegisterRootObject(PickupCarrier);
+        
+    }
+    
+    PickupCarrier::~PickupCarrier()
+    {
+        for(std::set<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            (*it)->destroy();
+        }
+        
+        this->pickups_.clear();
     }
 
Index: code/branches/pickup3/src/orxonox/interfaces/PickupCarrier.h
===================================================================
--- code/branches/pickup3/src/orxonox/interfaces/PickupCarrier.h	(revision 6467)
+++ code/branches/pickup3/src/orxonox/interfaces/PickupCarrier.h	(revision 6474)
@@ -36,29 +36,46 @@
 
 #include "OrxonoxPrereqs.h"
-#include "core/OrxonoxClass.h"
+
+#include <list>
+#include <set>
 #include "Pickupable.h"
 
-#include <set>
-#include <list>
+#include "core/OrxonoxClass.h"
 
 namespace orxonox
 {
 
+    /**
+    @brief
+        The PickupCarrier interface provides the means, for any class implementing it, to possess Pickupables.
+    @author
+        Damian 'Mozork' Frick
+    */
     class _OrxonoxExport PickupCarrier : virtual public OrxonoxClass
     {
-        friend class Pickupable;
+        friend class Pickupable; //!< The Pickupable has full acces to its PickupCarrier.
         
         public:
-            PickupCarrier();
-            virtual ~PickupCarrier() {}
+            PickupCarrier(); //!< Constructor.
+            virtual ~PickupCarrier(); //!< Destructor.
             
-            //TODO: Secure uniqueness of each item in the set, if neccessary, check.
+            /**
+            @brief Can be called to pick up a Pickupable.
+            @param pickup A pointer to the Pickupable.
+            @return Returns true if the Pickupable was picked up, false if not.
+            */
             inline bool pickup(Pickupable* pickup)
                 {
                     bool pickedUp = this->pickups_.insert(pickup).second;
-                    if(pickedUp) pickup->pickedUp(this);
+                    if(pickedUp)
+                        pickup->pickedUp(this);
                     return pickedUp;
                 }
                 
+            /**
+            @brief Can be called to drop a Pickupable.
+            @param pickup A pointer to the Pickupable.
+            @return Returns true if the Pickupable has been dropped, false if not.
+            */
             inline bool drop(Pickupable* pickup)
                 { 
Index: code/branches/pickup3/src/orxonox/interfaces/Pickupable.cc
===================================================================
--- code/branches/pickup3/src/orxonox/interfaces/Pickupable.cc	(revision 6474)
+++ code/branches/pickup3/src/orxonox/interfaces/Pickupable.cc	(revision 6474)
@@ -0,0 +1,210 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of the Pickupable class.
+*/
+
+#include "Pickupable.h"
+
+#include "core/Identifier.h"
+#include "core/CoreIncludes.h"
+#include "PickupCarrier.h"
+
+namespace orxonox
+{
+    
+    /**
+    @brief
+        Constructor. Registers the objects and initializes its member variables.
+    */
+    Pickupable::Pickupable()
+    {
+        RegisterRootObject(Pickupable);
+
+        this->used_ = false;
+        this->pickedUp_ = false;
+        this->carrier_ = NULL;
+    }
+    
+    /**
+    @brief
+        Destructor. 
+    */
+    Pickupable::~Pickupable()
+    {
+        
+    }
+    
+    /**
+    @brief
+        Sets the Pickupable to used or unused, depending on the input.
+    @param used
+        If used is true the Pickupable is set to used, it is set to unused, otherwise.
+    @return
+        Returns true if the used state was changed, false if not.
+    */
+    bool Pickupable::setUsed(bool used)
+    {
+        if(this->used_ == used)
+            return false;
+        
+        COUT(4) << "Pickupable (&" << this << ") set to used " << used << "." << std::endl;
+        
+        this->used_ = used;
+        this->changedUsed();
+        return true;
+    }
+    
+    /**
+    @brief
+        Get whether the given PickupCarrier is a target of this pickup.
+    @param carrier
+        The PickupCarrier of which it has to be determinde whether it is a target of this pickup.
+    @return
+        Returns true if the given PickupCarrier is a target.
+    */
+    bool Pickupable::isTarget(PickupCarrier* carrier)
+    {
+        Identifier* identifier = carrier->getIdentifier();
+        //! Iterate through all targets of this Pickupable.
+        for(std::list<Identifier*>::const_iterator it = this->targets_.begin(); it != this->targets_.end(); it++)
+        {
+            if(identifier->isA(*it))
+                return true;
+        }
+        return false;
+    }
+    
+    /**
+    @brief
+        Add a PickupCarrier as target of this pickup.
+    @param target
+        The PickupCarrier to be added.
+    @return
+        Returns true if the target was added, false if not.
+    */
+    bool Pickupable::addTarget(PickupCarrier* target)
+    {
+        if(this->isTarget(target)) //!< If the input target is already present in the list of targets.
+            return false;
+        
+        COUT(4) << "Target (&" << target << ") added to Pickupable (&" << this << ")." << std::endl;
+        this->targets_.push_back(target->getIdentifier());
+        return true;
+    }
+    
+    /**
+    @brief  
+        Sets the Pickupable to picked up.
+        This method will be called by the PickupCarrier picking the Pickupable up.
+    @param carrier
+        The PickupCarrier that picked the Pickupable up.
+    @return
+        Returns false if, for some reason, the pickup could not be picked up, e.g. it was picked up already.
+    */
+    bool Pickupable::pickedUp(PickupCarrier* carrier)
+    {
+        if(this->isPickedUp()) //!< If the Pickupable is already picked up.
+            return false;
+        
+        COUT(4) << "Pickupable (&" << this << ") got picked up by a PickupCarrier (&" << carrier << ")." << std::endl;
+        this->setCarrier(carrier);
+        this->setPickedUp(true);
+        return true;
+    }
+    
+    /**
+    @brief 
+        Sets the Pickupable to not picked up or dropped.
+        This method will be called by the PickupCarrier dropping the Pickupable.
+    @return
+        Returns false if the pickup could not be dropped.
+    */
+    bool Pickupable::dropped(void)
+    {
+        if(!this->isPickedUp()) //!< If the Pickupable is not picked up.
+            return false;
+        
+        COUT(4) << "Pickupable (&" << this << ") got dropped up by a PickupCarrier (&" << this->getCarrier() << ")." << std::endl;
+        this->setUsed(false);
+        this->setPickedUp(false);
+        this->setCarrier(NULL);
+        return true;
+    }
+    
+        
+    /**
+    @brief
+        Sets the carrier of the pickup.
+    @param carrier
+        Sets the input PickupCarrier as the carrier of the pickup.
+    @return
+        Returns true if the carrier was changed, false if not.
+    */
+    bool Pickupable::setCarrier(PickupCarrier* carrier)
+    {
+        if(this->getCarrier() == carrier)
+            return false;
+        
+        this->carrier_ = carrier;
+        this->changedCarrier();
+        return true;
+    }
+    
+    /**
+    @brief
+        Creates a duplicate of the Pickupable.
+    @return
+        Returns the clone of this pickup as a pointer to a Pickupable.
+    */
+    //TODO: Does this work?
+    Pickupable* Pickupable::clone(void)
+    {
+        Pickupable* pickup = NULL;
+        this->clone(pickup);
+        
+        COUT(4) << "Pickupable (&" << this << ") cloned. Clone is new Pickupable (&" << pickup << ")." << std::endl;
+        return pickup;
+    }
+    
+    /**
+    @brief
+        Creates a duplicate of the input OrxonoxClass.
+        This method needs to be implemented by any Class inheriting from Pickupable.
+    @param item
+        A pointer to the OrxonoxClass that is to be duplicated.
+    */
+    //TODO: Specify how the implementation must be done in detail.
+    void Pickupable::clone(OrxonoxClass* item)
+    {
+        SUPER(Pickupable, clone, item);
+    }
+    
+}
Index: code/branches/pickup3/src/orxonox/interfaces/Pickupable.h
===================================================================
--- code/branches/pickup3/src/orxonox/interfaces/Pickupable.h	(revision 6467)
+++ code/branches/pickup3/src/orxonox/interfaces/Pickupable.h	(revision 6474)
@@ -36,9 +36,10 @@
 
 #include "OrxonoxPrereqs.h"
-#include "core/OrxonoxClass.h"
 
+#include <list>
 #include "core/Super.h"
 #include "pickup/PickupIdentifier.h"
-#include <list>
+
+#include "core/OrxonoxClass.h"
 
 namespace orxonox
@@ -47,5 +48,5 @@
     /**
     @brief
-        An Interface (or more precisely an abstract Class) to model and represent different (all kinds of) pickups.
+        An Interface (or more precisely an abstract class) to model and represent different (all kinds of) pickups.
     @author
         Damian 'Mozork' Frick
@@ -57,6 +58,32 @@
         public:
             Pickupable(); //!< Default constructor.
-            virtual ~Pickupable() {} //!< Default destructor.
-                
+            virtual ~Pickupable(); //!< Default destructor.
+            
+            /**
+            @brief Get whether the pickup is currently in use or not.
+            @return Returns true if the pickup is currently in use.
+            */
+            inline bool isUsed(void)
+                { return this->used_; }
+            /**
+            @brief  Should be called when the pickup has transited from used to unused or the other way around.
+                    Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedUsed); to their changdeUsed method.
+            */
+            virtual void changedUsed(void) {}
+            bool setUsed(bool used); //!< Sets the Pickupable to used or unused, depending on the input.
+            
+            /**
+            @brief Returns whether the Pickupable is currently picked up.
+            @return Returns true if the Pickupable is currently picked up, false if not.
+            */
+            inline bool isPickedUp(void)
+                { return this->pickedUp_; }
+            //TODO: Better private, or protected?
+            bool pickedUp(PickupCarrier* carrier); //!< Sets the Pickupable to picked up.
+            bool dropped(void); //!< Sets the Pickupable to not picked up or dropped.
+            
+            bool isTarget(PickupCarrier* carrier); //!< Get whether the given PickupCarrier is a target of this pickup.
+            bool addTarget(PickupCarrier* target); //!< Add a PickupCarrier as target of this pickup.
+            
             /**
             @brief Get the carrier of the pickup.
@@ -65,36 +92,4 @@
             inline PickupCarrier* getCarrier(void)
                 { return this->carrier_; }
-                
-            /**
-            @brief Get whether the pickup is currently in use or not.
-            @return Returns true if the pickup is currently in use.
-            */
-            inline bool isUsed(void)
-                { return this->used_; }
-                
-            bool isTarget(PickupCarrier* carrier);
-            bool addTarget(PickupCarrier* target);
-
-            bool setUsed(bool used);
-            
-            bool pickedUp(PickupCarrier* carrier);
-            bool dropped(void);
-            
-            inline bool isPickedUp(void)
-                { return this->pickedUp_; }
-            
-            Pickupable* clone(void);
-            
-            virtual const PickupIdentifier* getPickupIdentifier(void)
-                { return &this->pickupIdentifier_; }
-                
-            virtual void clone(OrxonoxClass* item);
-            
-            /**
-            @brief  Should be called when the pickup has transited from used to unused or the other way around.
-                    Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedUsed); to their changdeUsed method.
-            */
-            virtual void changedUsed(void) {}
-            
             /**
             @brief  Should be called when the pickup has transited from picked up to dropped or the other way around.
@@ -102,13 +97,35 @@
             */
             virtual void changedCarrier(void) {}
+            //TODO: Maybe private?
+            bool setCarrier(PickupCarrier* carrier); //!< Sets the carrier of the pickup.
             
-            bool setCarrier(PickupCarrier* carrier);
+            Pickupable* clone(void); //!< Creates a duplicate of the Pickupable.
+            virtual void clone(OrxonoxClass* item); //!< Creates a duplicate of the input OrxonoxClass.
+            
+            /**
+            @brief Get the PickupIdentifier of this Pickupable.
+            @return Returns a pointer to the PickupIdentifier of this Pickupable.
+            */
+            virtual const PickupIdentifier* getPickupIdentifier(void)
+                { return &this->pickupIdentifier_; }
+                
+            virtual void destroy(void)
+                { delete this; }
             
         protected:
+            /**
+            @brief Helper method to initialize the PickupIdentifier.
+            */
+            //TODO: Really needed?
             void initializeIdentifier(void) {}
             
-            PickupIdentifier pickupIdentifier_;
+            //TODO: Move to private and create get method in protected.
+            PickupIdentifier pickupIdentifier_; //!< The PickupIdentifier of this Pickupable.
             
         private:
+            /**
+            @brief Helper method to set the Pickupable to either picked up or not picked up.
+            @param pickedUp The value this->pickedUp_ should be set to.
+            */
             inline void setPickedUp(bool pickedUp)
                 { this->pickedUp_ = pickedUp; }
@@ -117,5 +134,5 @@
             bool pickedUp_; //!< Whether the pickup is currently picked up or not.
             
-            PickupCarrier* carrier_; //!< The owner of the pickup.
+            PickupCarrier* carrier_; //!< The carrier of the pickup.
             std::list<Identifier*> targets_; //!< The possible targets of this pickup.
 
Index: code/branches/pickup3/src/orxonox/pickup/BaseItem.cc
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/BaseItem.cc	(revision 6467)
+++ 	(revision )
@@ -1,109 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of BaseItem (base-class for items/pickups).
-*/
-
-#include "BaseItem.h"
-
-#include "core/CoreIncludes.h"
-#include "core/XMLPort.h"
-#include "worldentities/pawns/Pawn.h"
-
-namespace orxonox
-{
-    /**
-    @brief Constructor. Registers the BaseItem.
-    @param creator Pointer to the object which created this item.
-    */
-    BaseItem::BaseItem(BaseObject* creator) : BaseObject(creator)
-    {
-        RegisterObject(BaseItem);
-
-        this->setOwner(0);
-        this->setPickupIdentifier(this->getName());
-        this->setGUIImage("");
-        this->setGUIText("");
-    }
-    //! Destructor.
-    BaseItem::~BaseItem()
-    {
-    }
-
-    /**
-    @brief XMLPort for BaseItem.
-    @param xmlelement Element of the XML-file.
-    @param mode XMLPort mode to use.
-    */
-    void BaseItem::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-        SUPER(BaseItem, XMLPort, xmlelement, mode);
-
-        XMLPortParam(BaseItem, "guiText", setGUIText, getGUIText, xmlelement, mode);
-        XMLPortParam(BaseItem, "guiImage", setGUIImage, getGUIImage, xmlelement, mode);
-    }
-
-    /**
-    @brief Method to add the item to a pawn.
-    @param pawn Pawn to which the item should get added.
-    @return Returns whether the pawn's PickupCollection accepted the item.
-    */
-    bool BaseItem::addTo(Pawn* pawn)
-    {
-        this->setOwner(pawn);
-
-        if (pawn->getPickups().add(this)) //TODO: Does the pawn store his pickups?
-        {
-            COUT(3) << "Added '" << this->getPickupIdentifier() << "' item." << std::endl;
-            return true;
-        }
-        return false;
-    }
-    /**
-        @brief Removes the item from a pawn.
-        @param pawn Pawn from which to remove the item.
-        @return Returns whether the pawn's PickupCollection was able to locate and remove the item.
-    */
-    bool BaseItem::removeFrom(Pawn* pawn)
-    {
-        this->setOwner(0);
-
-        COUT(3) << "Removing '" << this->getPickupIdentifier() << "' item." << std::endl;
-
-        pawn->getPickups().remove(this, false);
-
-        return true;
-    }
-
-    const std::string& BaseItem::getGUIText() const
-    {
-        return this->guiText_;
-    }
-}
Index: code/branches/pickup3/src/orxonox/pickup/BaseItem.h
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/BaseItem.h	(revision 6467)
+++ 	(revision )
@@ -1,156 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of BaseItem (base-class for items/pickups).
-*/
-
-#ifndef _BaseItem_H__
-#define _BaseItem_H__
-
-#include "OrxonoxPrereqs.h"
-
-#include <string>
-#include "core/BaseObject.h"
-
-// tolua_begin
-namespace orxonox
-{
-    /**
-    @brief
-        Base class for all items/pickups.
-
-        Provides common methods to be used in derived classes.
-    @author
-        Daniel 'Huty' Haggenmueller
-    */
-    class _OrxonoxExport BaseItem : public BaseObject
-    {
-// tolua_end
-        public:
-            BaseItem(BaseObject* creator);
-            virtual ~BaseItem();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);  //!< XMLPort
-
-            /**
-            @brief Checks how many instances of this item can be carried at a time.
-            @return How many of this item can be carried.
-            */
-            virtual int getMaxCarryAmount() const //TODO: Maybe, better to just be virtual.
-                { return BaseItem::MAX_CARRY_AMOUNT; }
-
-            //TODO: Need to be public?
-            bool addTo(Pawn* pawn);             //!< Add the item to a pawn.
-            bool removeFrom(Pawn* pawn);        //!< Removes the item from a pawn.
-            /**
-            @brief
-                Method invoked when the item gets picked up.
-
-                Has to be overridden for an item to work,
-                should contain a call to addTo().
-
-            @param pawn Pawn who picks up the item.
-            @return Returns whether the pawn was able to pick up the item.
-            */
-            virtual bool pickedUp(Pawn* pawn) //TODO: Maybe better to be just virtual.
-                { return false; }
-            /**
-            @brief
-                Method invoked when the item is dropped from a player.
-
-                Should be overridden by derived classes,
-                should also contain a call to removeFrom().
-
-            @param pawn Pawn which dropped the item.
-            @return Returns whether the item was able to get dropped by the pawn.
-            */
-            virtual bool dropped(Pawn* pawn)
-                { return false; }
-
-            /**
-            @brief Gets the current owner of the pickup.
-            @return Returns the current owner.
-            */
-            inline Pawn* getOwner() const
-                { return this->owner_; }
-            /**
-            @brief Sets the owner of the pickup.
-            @param owner New owner for the pickup.
-            */
-            inline void setOwner(Pawn* owner)
-                { this->owner_ = owner; }
-
-            /**
-            @brief Gets the pickupIdentifier of the item.
-            @return Returns the pickupIdentifier of the item.
-            @see pickupIdentifier_
-            */
-            inline const std::string& getPickupIdentifier() const
-                { return this->pickupIdentifier_; }
-            /**
-            @brief Sets the pickupIdentifier for the item.
-            @param identifier New pickupIdentifier for the item.
-            @see pickupIdentifier_
-            */
-            //TODO: Needs to be public?
-            inline void setPickupIdentifier(const std::string& identifier)
-                { this->pickupIdentifier_ = identifier; }
-
-            // GUI stuff
-            //TODO: Comment. Maybe seperate GUI from Pickup, e.g. ItemDescription...
-            virtual const std::string& getGUIText() const; // tolua_export
-            inline void setGUIText(const std::string& text)
-                { this->guiText_ = text; }
-
-            virtual const std::string& getGUIImage() const
-                { return this->guiImage_; }
-            inline void setGUIImage(const std::string& image)
-                { this->guiImage_ = image; }
-        private:
-            static const int MAX_CARRY_AMOUNT = 1;
-
-            Pawn* owner_;   //!< The current owner of the item.
-
-            /**
-            @brief
-                The pickupIdentifier of the item..
-
-                Usually set to the template name used by a PickupSpawner,
-                used to index items in the PickupCollection.
-            */
-            std::string pickupIdentifier_; //TODO: Remove, when always just this->getName().
-
-            //TODO: Comment.
-            std::string guiText_;
-            std::string guiImage_;
-    }; // tolua_export
-} // tolua_export
-
-#endif /* _BaseItem_H__ */
Index: code/branches/pickup3/src/orxonox/pickup/DroppedItem.cc
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/DroppedItem.cc	(revision 6467)
+++ 	(revision )
@@ -1,123 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-#include "DroppedItem.h"
-
-#include "util/Math.h"
-#include "core/CoreIncludes.h"
-#include "core/Executor.h"
-#include "BaseItem.h"
-#include "graphics/Billboard.h"
-#include "graphics/Model.h"
-#include "worldentities/pawns/Pawn.h"
-
-namespace orxonox
-{
-    CreateFactory(DroppedItem);
-
-    DroppedItem::DroppedItem(BaseObject* creator) : StaticEntity(creator)
-    {
-        RegisterObject(DroppedItem);
-
-        this->triggerDistance_ = 20.0f;
-        this->timeToLive_ = 0;
-        this->item_ = 0;
-    }
-    DroppedItem::~DroppedItem()
-    {
-    }
-    void DroppedItem::tick(float dt)
-    {
-        if (this->item_)
-        {
-            for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
-            {
-                Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
-                if (distance.length() < this->triggerDistance_)
-                    this->trigger(*it);
-            }
-        }
-    }
-    void DroppedItem::trigger(Pawn* pawn)
-    {
-        if (this->item_->pickedUp(pawn))
-        {
-            COUT(3) << "DroppedItem '" << this->item_->getPickupIdentifier() << "' picked up." << std::endl;
-            this->destroy();
-        }
-    }
-    void DroppedItem::createTimer()
-    {
-        if (this->timeToLive_ > 0)
-        {
-            this->timer_.setTimer(this->timeToLive_, false, createExecutor(createFunctor(&DroppedItem::timerCallback, this)), false);
-        }
-    }
-    void DroppedItem::timerCallback()
-    {
-        if (this->item_)
-        {
-            COUT(3) << "Delete DroppedItem with '" << this->item_->getPickupIdentifier() << '\'' << std::endl;
-            this->item_->destroy();
-        }
-
-        this->destroy();
-    }
-
-    DroppedItem* DroppedItem::createDefaultDrop(BaseItem* item, const Vector3& position, const ColourValue& flareColour, float timeToLive)
-    {
-        DroppedItem* drop = new DroppedItem(item);
-        Model* model = new Model(item);
-        Billboard* billboard = new Billboard(item);
-
-        model->setMeshSource("sphere.mesh");
-        model->setScale(3.0f);
-
-        billboard->setMaterial("Examples/Flare");
-        billboard->setColour(flareColour);
-        billboard->setScale(0.5f);
-
-        drop->setPosition(position);
-        drop->attach(model);
-        drop->attach(billboard);
-
-        drop->setItem(item);
-
-        drop->setTimeToLive(timeToLive);
-        drop->createTimer();
-
-        COUT(3) << "Created DroppedItem for '" << item->getPickupIdentifier() << "' at (" << position.x << ',' << position.y << ',' << position.z << ")." << std::endl;
-
-        return drop;
-    }
-    DroppedItem* DroppedItem::createDefaultDrop(BaseItem* item, Pawn* pawn, const ColourValue& flareColour, float timeToLive)
-    {
-        Vector3 after = pawn->getPosition() + pawn->getOrientation() * Vector3(0.0f, 0.0f, 50.0f);
-        return DroppedItem::createDefaultDrop(item, after, flareColour, timeToLive);
-    }
-}
Index: code/branches/pickup3/src/orxonox/pickup/EquipmentItem.cc
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/EquipmentItem.cc	(revision 6467)
+++ 	(revision )
@@ -1,47 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of EquipmentItem.
-*/
-
-#include "EquipmentItem.h"
-#include "core/CoreIncludes.h"
-
-namespace orxonox
-{
-    /**
-    @brief Constructor. Registers the EquipmentItem.
-    @param creator Pointer to the object which created this item.
-    */
-    EquipmentItem::EquipmentItem(BaseObject* creator) : BaseItem(creator)
-    {
-        RegisterObject(EquipmentItem);
-    }
-}
Index: code/branches/pickup3/src/orxonox/pickup/EquipmentItem.h
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/EquipmentItem.h	(revision 6467)
+++ 	(revision )
@@ -1,59 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of EquipmentItem (base-class for equipment-type items).
-*/
-
-#ifndef _EquipmentPickup_H__
-#define _EquipmentPickup_H__
-
-#include "OrxonoxPrereqs.h"
-
-#include "BaseItem.h"
-namespace orxonox
-{
-    /**
-    @brief Base class for all equipment-type items.
-    @author Daniel 'Huty' Haggenmueller
-    */
-    class _OrxonoxExport EquipmentItem : public BaseItem
-    {
-        //TODO: What is this class for?
-        //Probably falls under UsableItem or PassiveItem
-        public:
-            EquipmentItem(BaseObject* creator);
-            virtual ~EquipmentItem() {}
-
-        
-
-    };
-}
-
-#endif /* _EquipmentPickup_H__ */
Index: code/branches/pickup3/src/orxonox/pickup/ModifierPickup.cc
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/ModifierPickup.cc	(revision 6467)
+++ 	(revision )
@@ -1,242 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of ModifierPickup (temporary(?) pickup for testing).
-*/
-
-#include "ModifierPickup.h"
-
-#include "core/CoreIncludes.h"
-#include "core/XMLPort.h"
-#include "worldentities/pawns/Pawn.h"
-
-namespace orxonox
-{
-    CreateFactory(ModifierPickup);
-
-    /**
-    @brief
-        Constructor. Registers the ModifierPickup.
-    @param creator
-        Pointer to the object which created this item.
-    */
-    ModifierPickup::ModifierPickup(BaseObject* creator) : PassiveItem(creator)
-    {
-        RegisterObject(ModifierPickup);
-
-        this->duration_ = 0.0f;
-    }
-
-    /**
-    @brief
-        Destructor.
-    */
-    ModifierPickup::~ModifierPickup()
-    {
-        
-    }
-
-    /**
-    @brief
-        Method for loading information from a level file.
-    @param element
-        XMLElement from which to read the data.
-    @param mode
-        XMLPort mode to use.
-    */
-    //TODO: Comments: params can probably be ommitted. 
-    void ModifierPickup::XMLPort(Element& element, XMLPort::Mode mode)
-    {
-        SUPER(ModifierPickup, XMLPort, element, mode);
-
-        XMLPortParam(ModifierPickup, "duration", setDuration, getDuration, element, mode);
-
-        XMLPortParamTemplate(ModifierPickup, "damageAdd", setAdditiveDamage, getAdditiveDamage, element, mode, float);
-        XMLPortParamTemplate(ModifierPickup, "damageMulti", setMultiplicativeDamage, getMultiplicativeDamage, element, mode, float);
-
-        XMLPortParamTemplate(ModifierPickup, "accelerationAdd", setAdditiveAcceleration, getAdditiveAcceleration, element, mode, float);
-        XMLPortParamTemplate(ModifierPickup, "accelerationMulti", setMultiplicativeAcceleration, getMultiplicativeAcceleration, element, mode, float);
-    }
-
-    /**
-    @brief
-        Invoked when a pawn picks up the pickup.
-
-        Adds the modifiers to the pawn and sets a timer (if effect is limited)
-        if the pickup could be added to the pawn's PickupCollection.
-
-    @param pawn
-        Pawn which picked up the pickup.
-    @return
-        Returns whether the pickup was able to be added to the pawn.
-    */
-    bool ModifierPickup::pickedUp(Pawn* pawn)
-    {
-        if (this->addTo(pawn))
-        {
-            std::map<ModifierType::Value, float>::iterator it;
-
-            for (it = this->additiveModifiers_.begin(); it != this->additiveModifiers_.end(); it++)
-            {
-                pawn->getPickups().addAdditiveModifier(it->first, it->second);
-            }
-
-            for (it = this->multiplicativeModifiers_.begin(); it != this->multiplicativeModifiers_.end(); it++)
-            {
-                pawn->getPickups().addMultiplicativeModifier(it->first, it->second);
-            }
-
-            if (this->duration_ > 0.0f)
-            {
-                Executor* executor = createExecutor(createFunctor(&ModifierPickup::timerCallback, this));
-                executor->setDefaultValues(pawn);
-                this->timer_.setTimer(this->duration_, false, executor);
-            }
-
-            return true;
-        }
-        return false;
-    }
-
-    /**
-    @brief
-        Invoked when a pawn drops the pickup.
-
-        Removes the modifiers from the pawn if the pickup
-        was successfully removed from it's PickupCollection.
-
-    @param pawn
-        Pawn which dropped the pickup.
-    @return 
-        Returns whether the pickup could be removed.
-    */
-    bool ModifierPickup::dropped(Pawn* pawn)
-    {
-        if (this->removeFrom(pawn))
-        {
-            std::map<ModifierType::Value, float>::iterator it;
-
-            for (it = this->additiveModifiers_.begin(); it != this->additiveModifiers_.end(); it++)
-            {
-                pawn->getPickups().removeAdditiveModifier(it->first, it->second);
-            }
-
-            for (it = this->multiplicativeModifiers_.begin(); it != this->multiplicativeModifiers_.end(); it++)
-            {
-                pawn->getPickups().removeMultiplicativeModifier(it->first, it->second);
-            }
-
-            if (this->timer_.getRemainingTime() > 0.0f)
-                this->timer_.stopTimer();
-
-            this->destroy();
-
-            return true;
-        }
-        return false;
-    }
-
-    /**
-    @brief Invoked when the timer finished, calls dropped().
-    */
-    //TODO: Other name for function?
-    void ModifierPickup::timerCallback(Pawn* pawn)
-    {
-        if (!this->dropped(pawn))
-            COUT(2) << "Failed to remove modifier pickup after the timer ran out!" << std::endl;
-    }
-
-    /**
-    @brief
-        Gets the additive modifier of a given type.
-    @param type
-        ModifierType for which to return the modifier.
-    @return
-        Returns the additive modifier for type (or 0 if not exists).
-    */
-    float ModifierPickup::getAdditiveModifier(ModifierType::Value type) const
-    {
-        std::map<ModifierType::Value, float>::const_iterator it = this->additiveModifiers_.find(type);
-        if (it != this->additiveModifiers_.end())
-            return it->second;
-        else
-            return 0.0f;
-    }
-
-    /**
-    @brief
-        Gets the multiplicative modifier of a given type.
-    @param type
-        ModifierType for which to return the modifier.
-    @return
-        Returns the multiplicative modifier for type (or 1 if not exists).
-    */
-    float ModifierPickup::getMultiplicativeModifier(ModifierType::Value type) const
-    {
-        std::map<ModifierType::Value, float>::const_iterator it = this->multiplicativeModifiers_.find(type);
-        if (it != this->multiplicativeModifiers_.end())
-            return it->second;
-        else
-            return 1.0f;
-    }
-
-    /**
-    @brief
-        Gets the additive modifier of a given type.
-    @param type
-        ModifierType for which to return the modifier.
-    @param value
-        The new additive modifier for type.
-    */
-    void ModifierPickup::setAdditiveModifier(ModifierType::Value type, float value)
-    {
-        if (this->additiveModifiers_.find(type) == this->additiveModifiers_.end())
-            this->additiveModifiers_.insert( std::pair<ModifierType::Value, float>(type, value) );
-        else
-            this->additiveModifiers_[type] = value;
-    }
-
-    /**
-    @brief
-        Gets the multiplicative modifier of a given type.
-    @param type
-        ModifierType for which to return the modifier.
-    @param value
-        The new multiplicative modifier for type.
-    */
-    void ModifierPickup::setMultiplicativeModifier(ModifierType::Value type, float value)
-    {
-        if (this->multiplicativeModifiers_.find(type) == this->multiplicativeModifiers_.end())
-            this->multiplicativeModifiers_.insert( std::pair<ModifierType::Value, float>(type, value) );
-        else
-            this->multiplicativeModifiers_[type] = value;
-    }
-
-}
Index: code/branches/pickup3/src/orxonox/pickup/ModifierPickup.h
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/ModifierPickup.h	(revision 6467)
+++ 	(revision )
@@ -1,159 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of ModifierPickup (temporary(?) pickup for testing).
-*/
-
-#ifndef _ModifierPickup_H__
-#define _ModifierPickup_H__
-
-#include "OrxonoxPrereqs.h"
-
-#include <climits>
-#include <map>
-
-#include "tools/Timer.h"
-#include "ModifierType.h"
-#include "PassiveItem.h"
-
-namespace orxonox
-{
-    /**
-    @brief Class for a (temporary) modifier effect.
-    @author Daniel 'Huty' Haggenmueller
-    */
-    //TODO: More elaborate comments.
-    class _OrxonoxExport ModifierPickup : public PassiveItem
-    {
-        //TODO: What does being derived from PassiveItem add exactly? Probably better to kill PassiveItem and just derive from BaseItem.
-        //Include ModifierType here, no additional header file needed for that, imo.
-        public:
-            ModifierPickup(BaseObject* creator);
-            virtual ~ModifierPickup();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< To create a ModifierPickup through the level file.
-
-            virtual bool pickedUp(Pawn* pawn); //!< Override of the BaseItem::pickedUp() method.
-            virtual bool dropped(Pawn* pawn); //!< Override of the BaseItem::dropped() method
-
-            //TODO: Where does this INT_MAX come from? Comment.
-            virtual int getMaxCarryAmount() //!< Allow the player to carry infinite ModPickups
-                { return INT_MAX; }
-
-            /**
-            @brief Get the duration of this pickup.
-            @return Returns how long the effect holds on.
-            */
-            inline float getDuration() const
-                { return this->duration_; }
-            /**
-            @brief Set the duration of this pickup.
-            @param duration How long the effect should hold.
-            */
-            //TODO: Better be private?
-            inline void setDuration(float duration)
-                { this->duration_ = duration; }
-
-            //TODO: Shouldn't these all be seperate pickup items? But, then, would this class really be needed? What does it actually add?
-            //Duration! Thus create two virtual functions addEffect() and removeEffect().
-            //Export the ideas here into seperate, individual subclasses.
-            //Shouldn't this, as an item be in the items folder? or is it, as merely the equivalent of an abstract class not specific enough?
-            //Specify what ModifierItem should do exactly. If the limited duration is the core functionality, another name would probably more fitting.
-            //Perhaps, limited effect duration could also just be another feature of BaseItem...
-            /**
-            @brief Get the amount of damage this pickup adds.
-            @return Returns how much damage this pickup adds.
-            */
-            inline float getAdditiveDamage() const
-                { return this->getAdditiveModifier(ModifierType::Damage); }
-            /**
-            @brief Get the factor by which this pickup multiplies the damage.
-            @return Returns the factor by which to multiply damage.
-            */
-            inline float getMultiplicativeDamage() const
-                { return this->getMultiplicativeModifier(ModifierType::Damage); }
-
-            /**
-            @brief Set the amount of damage this pickup adds.
-            @param value How much damage this pickup adds.
-            */
-            inline void setAdditiveDamage(float value)
-                { this->setAdditiveModifier(ModifierType::Damage, value); }
-            /**
-            @brief Set the factor by which this pickup multiplies the damage.
-            @param value Factor by which to multiply damage.
-            */
-            inline void setMultiplicativeDamage(float value)
-                { this->setMultiplicativeModifier(ModifierType::Damage, value); }
-
-            /**
-            @brief Get the amount of acceleration this pickup adds.
-            @return Returns how much acceleration this pickup adds.
-            */
-            inline float getAdditiveAcceleration() const
-                { return this->getAdditiveModifier(ModifierType::Acceleration); }
-            /**
-            @brief Get the factor by which this pickup multiplies the acceleration.
-            @return Returns the factor by which to multiply acceleration.
-            */
-            inline float getMultiplicativeAcceleration() const
-                { return this->getMultiplicativeModifier(ModifierType::Acceleration); }
-
-            /**
-            @brief Set the amount of acceleration this pickup adds.
-            @param value How much acceleration this pickup adds.
-            */
-            inline void setAdditiveAcceleration(float value)
-                { this->setAdditiveModifier(ModifierType::Acceleration, value); }
-            /**
-            @brief Set the factor by which this pickup multiplies the acceleration.
-            @param value Factor by which to multiply acceleration.
-            */
-            inline void setMultiplicativeAcceleration(float value)
-                { this->setMultiplicativeModifier(ModifierType::Acceleration, value); }
-
-            //TODO: Make private?
-            void timerCallback(Pawn* pawn);     //!< Method called when the timer runs out.
-
-        private:
-            float getAdditiveModifier(ModifierType::Value type) const;               //!< Get the additive modifier for a given ModifierType.
-            float getMultiplicativeModifier(ModifierType::Value type) const;         //!< Get the multiplicative modifier for a given ModifierType.
-            void setAdditiveModifier(ModifierType::Value type, float value);         //!< Set the additive modifier for a given ModifierType.
-            void setMultiplicativeModifier(ModifierType::Value type, float value);   //!< Set the multiplicative modifier for a given ModifierType
-
-            std::map<ModifierType::Value, float> additiveModifiers_;                 //!< Map of additive modifiers, indexed by ModifierType.
-            std::map<ModifierType::Value, float> multiplicativeModifiers_;           //!< Map of multiplicative modifiers, indexed by ModifierType.
-
-            float duration_;                                                         //!< Duration of this pickup's effect (0 for unlimited).
-            Timer timer_;                                                            //!< Timer used if the pickup's effect has a time limit.
-    };
-}
-
-#endif /* _ModifierPickup_H__ */
Index: code/branches/pickup3/src/orxonox/pickup/ModifierType.h
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/ModifierType.h	(revision 6467)
+++ 	(revision )
@@ -1,56 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Contains enumeration for different types of modifiers.
-*/
-
-#ifndef _ModifierType_H__
-#define _ModifierType_H__
-
-#include "OrxonoxPrereqs.h"
-
-namespace orxonox
-{
-    //TODO: Merge with ModifierPickup.
-    namespace ModifierType
-    {
-        /**
-            @brief Gives the available types for modifiers.
-        */
-        enum Value
-        {
-            Unknown = 0,
-            Damage,
-            Acceleration
-        };
-    }
-}
-
-#endif /* _ModifierType_H__ */
Index: code/branches/pickup3/src/orxonox/pickup/PassiveItem.cc
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/PassiveItem.cc	(revision 6467)
+++ 	(revision )
@@ -1,42 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-#include "PassiveItem.h"
-#include "core/CoreIncludes.h"
-
-namespace orxonox
-{
-    /**
-    @brief Constructor. Registers the PassiveItem.
-    @param creator Pointer to the object which created this item.
-    */
-    PassiveItem::PassiveItem(BaseObject* creator) : BaseItem(creator)
-    {
-        RegisterObject(PassiveItem);
-    }
-}
Index: code/branches/pickup3/src/orxonox/pickup/PassiveItem.h
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/PassiveItem.h	(revision 6467)
+++ 	(revision )
@@ -1,57 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of PassiveItem (base class for passive items).
-*/
-
-#ifndef _PassiveItem_H__
-#define _PassiveItem_H__
-
-#include "OrxonoxPrereqs.h"
-#include "BaseItem.h"
-
-namespace orxonox
-{
-    /**
-    @brief Base class for all passive items.
-    @author Daniel 'Huty' Haggenmueller
-    */
-    class _OrxonoxExport PassiveItem : public BaseItem
-    {
-        //TODO: What is this Class for. Where is ActiveItem?
-        //Rename it InstantItem?
-        public:
-            PassiveItem(BaseObject* creator);
-            virtual ~PassiveItem() {}
-
-    };
-}
-
-#endif /* _PassiveItem_H__ */
Index: code/branches/pickup3/src/orxonox/pickup/PickupCollection.cc
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/PickupCollection.cc	(revision 6467)
+++ 	(revision )
@@ -1,379 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of PickupCollection.
-*/
-
-#include "PickupCollection.h"
-
-#include "core/CoreIncludes.h"
-#include "EquipmentItem.h"
-#include "PassiveItem.h"
-#include "UsableItem.h"
-
-namespace orxonox
-{
-    typedef std::pair<std::multimap<std::string, BaseItem*>::iterator, std::multimap<std::string, BaseItem*>::iterator> item_range;
-    typedef std::pair<std::multimap<ModifierType::Value, float>::iterator, std::multimap<ModifierType::Value, float>::iterator> modifier_range;
-
-    //! Constructor
-    PickupCollection::PickupCollection()
-    {
-        this->bBlockRemovals_ = false;
-        this->currentUsable_ = NULL;
-    }
-
-    /**
-    @brief
-        Add an item to the collection.
-
-        Only adds the item if there's a free slot for it.
-
-    @param item
-        Item to add to the collection.
-    @return
-        Returns whether the item has been added to the collection.
-    */
-    bool PickupCollection::add(BaseItem* item)
-    {
-        if (this->checkSlot(item))
-        {
-            Identifier* ident = Class(UsableItem);
-            if(this->currentUsable_ == NULL && item->isA(ident))
-                this->currentUsable_ = orxonox_cast<UsableItem*>(item);
-
-            this->items_.insert( std::pair<std::string, BaseItem*> (item->getPickupIdentifier(), item) );
-            return true;
-        }
-        else
-            return false;
-    }
-    /**
-        @brief
-            Check if there's a free slot for an item.
-
-            Compares the amount of the item-type in the collection
-            against the maximal amount of the item that can be carried.
-
-        @param item Item to check for a slot.
-        @return Returns if there's a free slot for the item.
-    */
-    bool PickupCollection::checkSlot(BaseItem* item)
-    {
-        return (static_cast<int>(this->items_.count(item->getPickupIdentifier())) < item->getMaxCarryAmount());
-    }
-    /**
-        @brief
-            Empty the collection.
-
-            Calls dropped() on all the items in the collection,
-            then clears the collection.
-    */
-    void PickupCollection::clear()
-    {
-        this->bBlockRemovals_ = true;
-        for (std::multimap<std::string, BaseItem*>::iterator it = this->items_.begin(); it != this->items_.end(); it++)
-        {
-            if(it->second && it->second->getOwner())
-                it->second->dropped(it->second->getOwner());
-        }
-        this->currentUsable_ = NULL;
-        this->items_.clear();
-        this->bBlockRemovals_ = false;
-    }
-    /**
-        @brief Check if an item/type of item is in the collection.
-        @param item Item to check.
-        @param anyOfType If it should look for any item of the item's type (default: false).
-        @return Whether the collection contains the item/type of item.
-    */
-    bool PickupCollection::contains(BaseItem* item, bool anyOfType)
-    {
-        if (anyOfType)
-        {
-            return (this->items_.count(item->getPickupIdentifier()) > 0);
-        }
-        else
-        {
-            item_range bounds = this->items_.equal_range(item->getPickupIdentifier());
-            for (std::multimap<std::string, BaseItem*>::iterator it = bounds.first; it != bounds.second && it != this->items_.end(); it++)
-            {
-                if (it->second == item)
-                {
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-    //! Uses the first usable item in the collection on the owner.
-    void PickupCollection::useItem()
-    {
-        if(this->currentUsable_)
-            this->currentUsable_->used(this->owner_);
-    }
-    /**
-        @brief Uses a usable item on the owner of the collection.
-        @param item Item to use.
-    */
-    void PickupCollection::useItem(UsableItem* item)
-    {
-        if (item && this->owner_)
-            item->used(this->owner_);
-    }
-    /**
-        @brief Remove an item/all of a type from the collection.
-        @param item Item to remove.
-        @param removeAllOfType Whether to remove all the items with the item's type (default: false).
-    */
-    void PickupCollection::remove(BaseItem* item, bool removeAllOfType)
-    {
-        if (!item || !this->contains(item, removeAllOfType) || this->bBlockRemovals_)
-            return;
-
-        bool getNewUsable = false;
-        if (item == this->currentUsable_ || (this->currentUsable_ && removeAllOfType && this->currentUsable_->getPickupIdentifier() == item->getPickupIdentifier()))
-        {
-            getNewUsable = true;
-        }
-
-        if (removeAllOfType)
-        {
-            std::multimap<std::string, BaseItem*>::iterator it;
-            while ((it = this->items_.find(item->getPickupIdentifier())) != this->items_.end())
-            {
-                this->items_.erase(it);
-            }
-        }
-        else
-        {
-            item_range bounds = this->items_.equal_range(item->getPickupIdentifier());
-            for (std::multimap<std::string, BaseItem*>::iterator it = bounds.first; it != bounds.second && it != this->items_.end(); it++)
-            {
-                if (it->second == item)
-                {
-                    this->items_.erase(it);
-                    break;
-                }
-            }
-        }
-
-        if (getNewUsable)
-        {
-            std::deque<UsableItem*> usables = this->getUsableItems();
-
-            if(usables.size() > 0)
-                this->currentUsable_ = usables.at(0);
-            else
-                this->currentUsable_ = NULL;
-
-        }
-    }
-    /**
-        @brief Add an additive modifier.
-        @param type ModifierType to add.
-        @param value Value for the modifier.
-    */
-    void PickupCollection::addAdditiveModifier(ModifierType::Value type, float value)
-    {
-        this->additiveModifiers_.insert( std::pair<ModifierType::Value, float>(type, value) );
-    }
-    /**
-        @brief Get the total amount of an additive modifier.
-        @param type Type for which to get the total.
-        @return Returns the sum of the additive modifiers of the type.
-    */
-    float PickupCollection::getAdditiveModifier(ModifierType::Value type)
-    {
-        float v = 0.0f;
-
-        modifier_range range = this->additiveModifiers_.equal_range(type);
-
-        for (std::multimap<ModifierType::Value, float>::iterator it = range.first; it != range.second && it != this->additiveModifiers_.end(); it++)
-        {
-            v += it->second;
-        }
-
-        return v;
-    }
-    /**
-        @brief Remove an additive modifier.
-        @param type Type of modifier.
-        @param value Value which is to be removed.
-    */
-    void PickupCollection::removeAdditiveModifier(ModifierType::Value type, float value)
-    {
-        modifier_range range = this->additiveModifiers_.equal_range(type);
-        for (std::multimap<ModifierType::Value, float>::iterator it = range.first; it != range.second && it != this->additiveModifiers_.end(); it++)
-        {
-            if (it->second == value)
-            {
-                this->additiveModifiers_.erase(it);
-                return;
-            }
-        }
-    }
-    /**
-        @brief Add a multiplicative modifier.
-        @param type ModifierType to add.
-        @param value Value for the modifier.
-    */
-    void PickupCollection::addMultiplicativeModifier(ModifierType::Value type, float value)
-    {
-        this->multiplicativeModifiers_.insert( std::pair<ModifierType::Value, float>(type, value) );
-    }
-    /**
-        @brief Get the total amount of a multiplicative modifier.
-        @param type Type for which to get the total.
-        @return Returns the product of the multiplicative modifiers of the type.
-    */
-    float PickupCollection::getMultiplicativeModifier(ModifierType::Value type)
-    {
-        float v = 1.0f;
-
-        modifier_range range = this->multiplicativeModifiers_.equal_range(type);
-        for (std::multimap<ModifierType::Value, float>::iterator it = range.first; it != range.second && it != this->multiplicativeModifiers_.end(); it++)
-        {
-            v *= it->second;
-        }
-
-        return v;
-    }
-    /**
-        @brief Remove a multiplicative modifier.
-        @param type Type of modifier.
-        @param value Value which is to be removed.
-    */
-    void PickupCollection::removeMultiplicativeModifier(ModifierType::Value type, float value)
-    {
-        modifier_range range = this->multiplicativeModifiers_.equal_range(type);
-        for (std::multimap<ModifierType::Value, float>::iterator it = range.first; it != range.second && it != this->multiplicativeModifiers_.end(); it++)
-        {
-            if (it->second == value)
-            {
-                this->multiplicativeModifiers_.erase(it);
-                return;
-            }
-        }
-    }
-    /**
-        @brief Applies modifiers to a float.
-        @param type Type of modifier tp apply.
-        @param inputValue Value which is to be processed.
-        @param addBeforeMultiplication Whether to apply the additive modifier before the multiplicative one (default: false).
-        @return Returns the value after being processed.
-    */
-    float PickupCollection::processModifiers(ModifierType::Value type, float inputValue, bool addBeforeMultiplication)
-    {
-        float outputValue = inputValue;
-
-        if (addBeforeMultiplication)
-            outputValue += this->getAdditiveModifier(type);
-
-        outputValue *= this->getMultiplicativeModifier(type);
-
-        if (!addBeforeMultiplication)
-            outputValue += this->getAdditiveModifier(type);
-
-        return outputValue;
-    }
-    /**
-        @brief Applies modifiers to a Vector3.
-        @param type Type of modifier tp apply.
-        @param inputValue Value which is to be processed.
-        @param addBeforeMultiplication Whether to apply the additive modifier before the multiplicative one (default: false).
-        @return Returns the value after being processed.
-    */
-    Vector3 PickupCollection::processModifiers(ModifierType::Value type, Vector3 inputValue, bool addBeforeMultiplication)
-    {
-        Vector3 outputValue = inputValue;
-
-        if (addBeforeMultiplication)
-            outputValue += Vector3(this->getAdditiveModifier(type));
-
-        outputValue *= this->getMultiplicativeModifier(type);
-
-        if (!addBeforeMultiplication)
-            outputValue += Vector3(this->getAdditiveModifier(type));
-
-        return outputValue;
-    }
-    /**
-        @brief Get a list of equipment-type items.
-        @return Returns a list of all the equipment-type items in the collection.
-    */
-    std::deque<EquipmentItem*> PickupCollection::getEquipmentItems()
-    {
-        std::deque<EquipmentItem*> ret;
-        Identifier* ident = Class(EquipmentItem);
-
-        for (std::multimap<std::string, BaseItem*>::iterator it = this->items_.begin(); it != this->items_.end(); it++)
-        {
-            if (it->second->isA(ident))
-                ret.push_back(orxonox_cast<EquipmentItem*>(it->second));
-        }
-
-        return ret;
-    }
-    /**
-        @brief Get a list of passive items.
-        @return Returns a list of all the passive items in the collection.
-    */
-    std::deque<PassiveItem*> PickupCollection::getPassiveItems()
-    {
-        std::deque<PassiveItem*> ret;
-        Identifier* ident = Class(PassiveItem);
-
-        for (std::multimap<std::string, BaseItem*>::iterator it = this->items_.begin(); it != this->items_.end(); it++)
-        {
-            if (it->second->isA(ident))
-                ret.push_back(orxonox_cast<PassiveItem*>(it->second));
-        }
-
-        return ret;
-    }
-    /**
-        @brief Get a list of usable items.
-        @return Returns a list of all the usable items in the collection.
-    */
-    std::deque<UsableItem*> PickupCollection::getUsableItems()
-    {
-        std::deque<UsableItem*> ret;
-        Identifier* ident = Class(UsableItem);
-
-        for (std::multimap<std::string, BaseItem*>::iterator it = this->items_.begin(); it != this->items_.end(); it++)
-        {
-            if (it->second->isA(ident))
-                ret.push_back(orxonox_cast<UsableItem*>(it->second));
-        }
-
-        return ret;
-    }
-}
Index: code/branches/pickup3/src/orxonox/pickup/PickupCollection.h
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/PickupCollection.h	(revision 6467)
+++ 	(revision )
@@ -1,101 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of PickupCollection.
-*/
-
-#ifndef _PickupCollection_H__
-#define _PickupCollection_H__
-
-#include "OrxonoxPrereqs.h"
-
-#include <deque>
-#include <map>
-#include <string>
-
-#include "util/Math.h"
-#include "ModifierType.h"
-
-namespace orxonox
-{
-    /**
-    @brief PickupCollection for organising items.
-    @author Daniel 'Huty' Haggenmueller
-    */
-    class _OrxonoxExport PickupCollection : public orxonox::OrxonoxClass
-    {
-        public:
-            PickupCollection();
-
-            bool add(BaseItem* item);       //!< Add an item to the collection.
-
-            bool checkSlot(BaseItem* item); //!< Check if there's a free slot in the collection for an item.
-
-            void clear();                   //!< Empty the collection
-            bool contains(BaseItem* item, bool anyOfType = false);                      //!< Check if the collection contains an item.
-
-            void remove(BaseItem* item, bool removeAllOfType = false);                  //!< Remove an item from the collection.
-
-            //TODO: Hmm... probably should stay...
-            void useItem();                                                             //!< Use the first usable item.
-            void useItem(UsableItem* item);                                             //!< Use a usable item.
-
-            /**
-                @brief Get the owner of the PickupCollection.
-                @return Returns the pawn which owns the PickupCollection.
-            */
-            inline Pawn* getOwner() const
-                { return this->owner_; }
-            /**
-                @brief Set the owner of the PickupCollection.
-                @param owner The new Pawn which owns the PickupCollection.
-            */
-            inline void setOwner(Pawn* owner)
-                { this->owner_ = owner; }
-
-            inline UsableItem* getCurrentUsable()
-                { return this->currentUsable_; };
-            inline void setCurrentUsable(UsableItem* usable)
-                { this->currentUsable_ = usable; }
-
-            std::deque<EquipmentItem*> getEquipmentItems();   //!< Get a list of equipment-type items.
-            std::deque<PassiveItem*> getPassiveItems();     //!< Get a list of passive items.
-            std::deque<UsableItem*> getUsableItems();      //!< Get a list of usable items.
-
-        private:
-            Pawn* owner_; //!< The owner of the PickupCollection.
-            UsableItem* currentUsable_;
-            int slots_;
-
-            std::multimap<std::string, BaseItem*> items_;                       //!< Map of items in the collection (indexed by pickupIdentifier of the items).
-    };
-}
-
-#endif /* _PickupCollection_H__ */
Index: code/branches/pickup3/src/orxonox/pickup/PickupIdentifier.cc
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/PickupIdentifier.cc	(revision 6474)
+++ code/branches/pickup3/src/orxonox/pickup/PickupIdentifier.cc	(revision 6474)
@@ -0,0 +1,99 @@
+/*
+ *   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 "PickupIdentifier.h"
+
+#include "core/CoreIncludes.h"
+
+namespace orxonox
+{
+    
+    PickupIdentifier::PickupIdentifier()
+    {
+        RegisterRootObject(PickupIdentifier);
+        
+        
+    }
+    
+    PickupIdentifier::~PickupIdentifier()
+    {
+        
+    }
+    
+    /**
+    @brief
+        Compares two PickupIdentifiers and returns 0 if a == b, <0 if a < b and >0 if a > b for a.compare(b).
+    @param identifier
+        Pointer to the second PickupIdentifier, b.
+    @return
+        Returns an int.
+    */
+    int PickupIdentifier::compare(const PickupIdentifier& identifier) const
+    {
+        if(!identifier.classIdentifier_->isExactlyA(this->classIdentifier_))
+            return this->classIdentifier_->getName().compare(identifier.classIdentifier_->getName());
+        
+        if(!(this->parameters_.size() == identifier.parameters_.size()))
+        {
+            COUT(1) << "Something went wrong in PickupIdentifier!" << std::endl;
+            return this->parameters_.size()-identifier.parameters_.size();
+        }
+        
+        for(std::map<std::string, std::string>::const_iterator it = this->parameters_.begin(); it != this->parameters_.end(); it++)
+        {
+            if(identifier.parameters_.find(it->first) == identifier.parameters_.end())
+            {
+                COUT(1) << "Something went wrong in PickupIdentifier!" << std::endl;
+                return -1;
+            }
+            if(identifier.parameters_.find(it->first)->second != it->second)
+                return it->second.compare(identifier.parameters_.find(it->first)->second);
+        }
+            
+        return false;
+    }
+    
+    void PickupIdentifier::addClass(Identifier* identifier)
+    {
+        this->classIdentifier_ = identifier;
+    }
+    
+    bool PickupIdentifier::addParameter(std::string & name, std::string & value)
+    {
+        if(!(this->parameters_.find(name) == this->parameters_.end()))
+        {
+            COUT(2) << "Request for adding a parameter that already exists for the PickupIdentififer was denied." << std::endl;
+            return false;
+        }
+        
+        this->parameters_[name] = value;
+        
+        return true;
+    }
+    
+}
Index: code/branches/pickup3/src/orxonox/pickup/PickupIdentifier.h
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/PickupIdentifier.h	(revision 6474)
+++ code/branches/pickup3/src/orxonox/pickup/PickupIdentifier.h	(revision 6474)
@@ -0,0 +1,76 @@
+/*
+ *   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 _PickupIdentifier_H__
+#define _PickupIdentifier_H__
+
+#include "OrxonoxPrereqs.h"
+
+#include "core/OrxonoxClass.h" 
+#include "core/Identifier.h"
+#include <map>
+#include <string>
+
+namespace orxonox
+{
+    
+    class _OrxonoxExport PickupIdentifier : virtual public OrxonoxClass
+    {
+        
+        public:
+            PickupIdentifier(void);
+            ~PickupIdentifier();
+            
+            virtual int compare(const PickupIdentifier& identifier) const;
+            
+            void addClass(Identifier* identifier);
+            bool addParameter(std::string & name, std::string & value);
+            
+        private:
+            Identifier* classIdentifier_;
+            std::map<std::string, std::string> parameters_;
+            
+            
+    };
+    
+    //TODO: Needed?
+    struct PickupIdentifierCompare
+    {
+        bool operator() (const PickupIdentifier& lhs, const PickupIdentifier& rhs) const
+            { return lhs.compare(rhs) < 0; }
+    };
+    
+    struct PickupIdentifierPtrCompare
+    {
+        bool operator() (const PickupIdentifier* lhs, const PickupIdentifier* rhs) const
+            { return lhs->compare(*rhs) < 0; }
+    };
+    
+}
+
+#endif // _PickupIdentifier_H__
Index: code/branches/pickup3/src/orxonox/pickup/PickupInventory.cc
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/PickupInventory.cc	(revision 6467)
+++ 	(revision )
@@ -1,387 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-#include "PickupInventory.h"
-
-#include <CEGUIImage.h>
-#include <CEGUIImageset.h>
-#include <CEGUIImagesetManager.h>
-#include <CEGUIWindow.h>
-#include <CEGUIWindowManager.h>
-#include <elements/CEGUITabControl.h>
-
-#include "core/ConsoleCommand.h"
-#include "core/GUIManager.h"
-#include "core/input/InputManager.h"
-#include "controllers/HumanController.h"
-#include "worldentities/pawns/Pawn.h"
-
-#include "EquipmentItem.h"
-#include "PassiveItem.h"
-#include "UsableItem.h"
-
-
-namespace orxonox
-{
-    SetConsoleCommandShortcut(PickupInventory, toggleInventory);
-
-    PickupInventory* PickupInventory::pickupInventory_s = NULL;
-
-    //TODO: Comment.
-
-    /**
-    @brief
-        Get a Pointer to the PickupInventory Singleton.
-    @return
-        A Pointer to the PickupInventory.
-    */
-    //TODO: Make SingeltonPtr?
-    PickupInventory* PickupInventory::getSingleton()
-    {
-        if(!PickupInventory::pickupInventory_s)
-            PickupInventory::pickupInventory_s = new PickupInventory();
-
-        return PickupInventory::pickupInventory_s;
-    }
-
-    /**
-    @brief
-        Constructor. 
-    */
-    PickupInventory::PickupInventory()
-    {
-        //TODO: Maybe some abstraction for the usableWindows, e.g. push and pop...
-        //RegisterObject() ? In some other Class, too. Which?
-        this->bInventoryVisible_ = false; //TODO: If OrxonoxClass, this should already be there...
-        this->visibleEquipmentWindows_ = this->visibleUsableWindows_ = 0;
-
-        // Create some windows to avoid creating them while playing
-        CEGUI::WindowManager* winMgr = CEGUI::WindowManager::getSingletonPtr();
-        for(int i = 0; i < 10; i++)
-        {
-            std::ostringstream id;
-            id << i;
-
-            PickupInventory::createItemWindows(winMgr, "equ/" + id.str(), i % 5, i / 5);
-            PickupInventory::createItemWindows(winMgr, "use/" + id.str(), i % 5, i / 5);
-        }
-        this->createdEquipmentWindows_ = this->createdUsableWindows_ = 10;
-    }
-
-    /**
-    @brief
-        Destructor.
-    */
-    //TODO: Destroy something?
-    PickupInventory::~PickupInventory()
-    {
-    }
-
-    /**
-    @brief
-        Toggles the visibility of the inventory.
-    */
-    /*static*/ void PickupInventory::toggleInventory()
-    {
-        if(PickupInventory::getSingleton()->isVisible()) {
-            GUIManager::hideGUI("PickupInventory");
-        }
-        else
-        {
-            GUIManager::showGUI("PickupInventory");
-        }
-        PickupInventory::getSingleton()->setVisible(!PickupInventory::getSingleton()->isVisible());
-    }
-
-    /**
-    @brief
-        
-    */
-    unsigned int PickupInventory::getCurrentUsableIndex()
-    {
-        Pawn* pawn = HumanController::getLocalControllerEntityAsPawn();
-        if(pawn && pawn->getPickups().getCurrentUsable())
-        {
-            UsableItem* use = pawn->getPickups().getCurrentUsable();
-            std::deque<UsableItem*> items = pawn->getPickups().getUsableItems();
-            for(unsigned int i = 0; i < items.size(); i++)
-            {
-                if(items.at(i) == use)
-                    return i;
-            }
-        }
-
-        return 0;
-    }
-
-    bool PickupInventory::isCurrentUsable(const BaseItem* item)
-    {
-        Pawn* pawn = HumanController::getLocalControllerEntityAsPawn();
-        if(pawn)
-            return (pawn->getPickups().getCurrentUsable() == item);
-        else
-            return false;
-    }
-
-    void PickupInventory::selectUsable(unsigned int i)
-    {
-        Pawn* pawn = HumanController::getLocalControllerEntityAsPawn();
-        if(pawn)
-        {
-            std::deque<UsableItem*> items = pawn->getPickups().getUsableItems();
-            if(i < items.size())
-                pawn->getPickups().setCurrentUsable(items.at(i));
-        }
-    }
-
-    unsigned int PickupInventory::getEquipmentCount()
-    {
-        Pawn* pawn = HumanController::getLocalControllerEntityAsPawn();
-        if(pawn)
-            return pawn->getPickups().getEquipmentItems().size();
-        else
-            return 0;
-    }
-
-    unsigned int PickupInventory::getUsableCount()
-    {
-        Pawn* pawn = HumanController::getLocalControllerEntityAsPawn();
-        if(pawn)
-            return pawn->getPickups().getUsableItems().size();
-        else
-            return 0;
-    }
-
-    unsigned int PickupInventory::getPassiveCount()
-    {
-        Pawn* pawn = HumanController::getLocalControllerEntityAsPawn();
-        if(pawn)
-            return pawn->getPickups().getPassiveItems().size();
-        else
-            return 0;
-    }
-
-    BaseItem* PickupInventory::getEquipmentItem(unsigned int i)
-    {
-        Pawn* pawn = HumanController::getLocalControllerEntityAsPawn();
-        if(pawn)
-        {
-            std::deque<EquipmentItem*> l = pawn->getPickups().getEquipmentItems();
-            if (i >= l.size()) { return NULL; }
-            return l.at(i);
-        }
-        else
-            return NULL;
-    }
-
-    BaseItem* PickupInventory::getUsableItem(unsigned int i)
-    {
-        Pawn* pawn = HumanController::getLocalControllerEntityAsPawn();
-        if(pawn)
-        {
-            std::deque<UsableItem*> l = pawn->getPickups().getUsableItems();
-            if (i >= l.size()) { return NULL; }
-            return l.at(i);
-        }
-        else
-            return NULL;
-    }
-
-    BaseItem* PickupInventory::getPassiveItem(unsigned int i)
-    {
-        Pawn* pawn = HumanController::getLocalControllerEntityAsPawn();
-        if(pawn)
-        {
-            std::deque<PassiveItem*> l = pawn->getPickups().getPassiveItems();
-            if (i >= l.size()) { return NULL; }
-            return l.at(i);
-        }
-        else
-            return NULL;
-    }
-
-    std::string PickupInventory::getImageForItem(const BaseItem* item)
-    {
-        if(!item)
-            return "";
-
-        const std::string& name = "pickup_" + item->getGUIImage();
-
-        if(!CEGUI::ImagesetManager::getSingletonPtr()->isImagesetPresent(name))
-        {
-            CEGUI::ImagesetManager::getSingletonPtr()->createImagesetFromImageFile(name, item->getGUIImage(), "");
-        }
-
-        return ("set:" + name + " image:full_image");
-    }
-
-    void PickupInventory::clearInventory(CEGUI::WindowManager* winMgr, CEGUI::Window* equipPane, CEGUI::Window* usablePane)
-    {
-        for(unsigned int i = 0; i < this->visibleEquipmentWindows_; i++)
-        {
-            std::ostringstream id;
-            id << i;
-
-            winMgr->getWindow("orxonox/Inventory/Frame/equ/" + id.str())->setVisible(false);
-            winMgr->getWindow("orxonox/Inventory/Title/equ/" + id.str())->setVisible(false);
-            winMgr->getWindow("orxonox/Inventory/Items/equ/" + id.str())->setVisible(false);
-
-            /*equipPane->removeChildWindow("orxonox/Inventory/Frame/equ/" + id.str());
-            equipPane->removeChildWindow("orxonox/Inventory/Title/equ/" + id.str());
-            equipPane->removeChildWindow("orxonox/Inventory/Items/equ/" + id.str());*/
-        }
-        for(unsigned int i = 0; i < this->visibleUsableWindows_; i++)
-        {
-            std::ostringstream id;
-            id << i;
-
-            winMgr->getWindow("orxonox/Inventory/Frame/use/" + id.str())->setVisible(false);
-            winMgr->getWindow("orxonox/Inventory/Title/use/" + id.str())->setVisible(false);
-            winMgr->getWindow("orxonox/Inventory/Items/use/" + id.str())->setVisible(false);
-
-            /*usablePane->removeChildWindow("orxonox/Inventory/Frame/use/" + id.str());
-            usablePane->removeChildWindow("orxonox/Inventory/Title/use/" + id.str());
-            usablePane->removeChildWindow("orxonox/Inventory/Items/use/" + id.str());*/
-        }
-    }
-
-    void PickupInventory::updateTabs(CEGUI::WindowManager *winMgr, CEGUI::Window *equipWindow, CEGUI::Window *usableWindow)
-    {
-        this->updateEquipment(winMgr, equipWindow);
-        this->updateUsable(winMgr, usableWindow);
-    }
-
-    void PickupInventory::updateEquipment(CEGUI::WindowManager* winMgr, CEGUI::Window* target)
-    {
-        Pawn* pawn;
-        if((pawn = HumanController::getLocalControllerEntityAsPawn()))
-        {
-            std::deque<EquipmentItem*> items = pawn->getPickups().getEquipmentItems();
-            for(unsigned int i = 0; i < items.size(); i++)
-            {
-                std::ostringstream id;
-                id << "equ/" << i;
-
-                EquipmentItem* item = items.at(i);
-
-                if(this->createdEquipmentWindows_ <= i)
-                {
-                    PickupInventory::createItemWindows(winMgr, id.str(), i % 5, i / 5);
-                    this->createdEquipmentWindows_++;
-                }
-
-                PickupInventory::setWindowProperties(winMgr, target, id.str(), item, "FFFFFFFF");
-            }
-            this->visibleEquipmentWindows_ = items.size();
-        }
-    }
-
-    void PickupInventory::updateUsable(CEGUI::WindowManager* winMgr, CEGUI::Window* target)
-    {
-        Pawn* pawn;
-        if((pawn = HumanController::getLocalControllerEntityAsPawn()))
-        {
-            std::deque<UsableItem*> items = pawn->getPickups().getUsableItems();
-            for(unsigned int i = 0; i < items.size(); i++)
-            {
-                std::ostringstream id;
-                id << "use/" << i;
-
-                UsableItem* item = items.at(i);
-                std::string colour;
-
-                if(PickupInventory::isCurrentUsable(item))
-                    colour = "FFFF5555";
-                else
-                    colour = "FFFFFFFF";
-
-                if(this->createdUsableWindows_ <= i)
-                {
-                    PickupInventory::createItemWindows(winMgr, id.str(), i % 5, i / 5);
-                    this->createdUsableWindows_++;
-                }
-
-                PickupInventory::setWindowProperties(winMgr, target, id.str(), item, colour);
-            }
-            this->visibleUsableWindows_ = items.size();
-        }
-    }
-
-    void PickupInventory::createItemWindows(CEGUI::WindowManager* winMgr, const std::string& id, int x, int y)
-    {
-        if(!winMgr) { return; }
-
-        CEGUI::Window* frame = winMgr->createWindow("TaharezLook/StaticImage", "orxonox/Inventory/Frame/" + id);
-        frame->setPosition(CEGUI::UVector2(CEGUI::UDim(0, 5 + x * 70), CEGUI::UDim(0, 5 + y * 90)));
-        frame->setSize(CEGUI::UVector2(CEGUI::UDim(0, 65), CEGUI::UDim(0, 65)));
-        frame->setRiseOnClickEnabled(false);
-        frame->setVisible(false);
-
-        CEGUI::Window* text = winMgr->createWindow("TaharezLook/StaticText", "orxonox/Inventory/Title/" + id);
-        text->setPosition(CEGUI::UVector2(CEGUI::UDim(0, 5 + x * 70), CEGUI::UDim(0, 70 + y * 90)));
-        text->setSize(CEGUI::UVector2(CEGUI::UDim(0, 65), CEGUI::UDim(0, 20)));
-        text->setProperty("FrameEnabled", "False");
-        text->setProperty("BackgroundEnabled", "False");
-        text->setProperty("HorzFormatting", "HorzCentred");
-        text->setProperty("VertFormatting", "VertCentred");
-        text->setProperty("TextColours", "tl:FFFFFFFF tr:FFFFFFFF bl:FFFFFFFF br:FFFFFFFF");
-        text->setVisible(false);
-
-        CEGUI::Window* btn = winMgr->createWindow("TaharezLook/Button", "orxonox/Inventory/Items/" + id);
-        btn->setPosition(CEGUI::UVector2(CEGUI::UDim(0, 8 + x * 70), CEGUI::UDim(0, 8 + y * 90)));
-        btn->setSize(CEGUI::UVector2(CEGUI::UDim(0, 59), CEGUI::UDim(0, 59)));
-        btn->subscribeScriptedEvent("Clicked", "PickupInventory.itemClicked");
-        btn->setVisible(false);
-    }
-
-    void PickupInventory::setWindowProperties(CEGUI::WindowManager* winMgr, CEGUI::Window* target, const std::string& id, const BaseItem* item, const std::string& textColour)
-    {
-        CEGUI::Window* txt = winMgr->getWindow("orxonox/Inventory/Title/" + id);
-        CEGUI::Window* btn = winMgr->getWindow("orxonox/Inventory/Items/" + id);
-        CEGUI::Window* frm = winMgr->getWindow("orxonox/Inventory/Frame/" + id);
-
-        frm->setVisible(true);
-
-        txt->setVisible(true);
-        txt->setProperty("Text", item->getGUIText());
-        txt->setProperty("TextColours", "tl:" + textColour + " tr:" + textColour + " bl:" + textColour + " br:" + textColour);
-
-        const std::string& image = PickupInventory::getImageForItem(item);
-        btn->setVisible(true);
-        btn->setProperty("NormalImage", image);
-        btn->setProperty("HoverImage", image);
-        btn->setProperty("PushedImage", image);
-        btn->setProperty("DisabledImage", image);
-        btn->setProperty("Tooltip", item->getGUIText());
-
-        target->addChildWindow(frm);
-        target->addChildWindow(txt);
-        target->addChildWindow(btn);
-    }
-
-}
Index: code/branches/pickup3/src/orxonox/pickup/PickupInventory.h
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/PickupInventory.h	(revision 6467)
+++ 	(revision )
@@ -1,100 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Declaration of static class for the inventory GUI window.
-*/
-
-#ifndef _PickupInventory_H__
-#define _PickupInventory_H__
-
-#include "OrxonoxPrereqs.h"
-
-#include <CEGUIForwardRefs.h>
-#include "core/BaseObject.h"
-
-// tolua_begin
-namespace orxonox
-{
-    /**
-    @brief Static class for the inventory GUI window.
-    @author Daniel 'Huty' Haggenmueller
-    */
-    class _OrxonoxExport PickupInventory
-    {
-// tolua_end
-        public:
-            //TODO: Be derived from OrxonoxClass and ScopedSingleton.
-            //Make some methods private?
-            PickupInventory();
-            virtual ~PickupInventory();
-
-            static PickupInventory* getSingleton(); // tolua_export
-
-            static void toggleInventory(); // tolua_export
-
-            static unsigned int getEquipmentCount(); // tolua_export
-            static unsigned int getUsableCount(); // tolua_export
-            static unsigned int getPassiveCount(); // tolua_export
-
-            static unsigned int getCurrentUsableIndex(); // tolua_export
-            static bool isCurrentUsable(const BaseItem* item); // tolua_export
-            static void selectUsable(unsigned int i); // tolua_export
-
-            static BaseItem* getEquipmentItem(unsigned int i); // tolua_export
-            static BaseItem* getUsableItem(unsigned int i); // tolua_export
-            static BaseItem* getPassiveItem(unsigned int i); // tolua_export
-
-            static std::string getImageForItem(const BaseItem* item); // tolua_export
-
-            void clearInventory(CEGUI::WindowManager* winMgr, CEGUI::Window* equipPane, CEGUI::Window* usablePane); // tolua_export
-            void updateTabs(CEGUI::WindowManager* winMgr, CEGUI::Window* equipWindow, CEGUI::Window* usableWindow); // tolua_export
-
-            void updateEquipment(CEGUI::WindowManager* winMgr, CEGUI::Window* target);
-            void updateUsable(CEGUI::WindowManager* winMgr, CEGUI::Window* target);
-
-            static void createItemWindows(CEGUI::WindowManager* winMgr, const std::string& id, int x, int y);
-            static void setWindowProperties(CEGUI::WindowManager* winMgr, CEGUI::Window* target, const std::string& id, const BaseItem* item, const std::string& textColour);
-
-            const bool isVisible() const
-                { return this->bInventoryVisible_; }
-            void setVisible(bool visible)
-                { this->bInventoryVisible_ = visible; }
-        private:
-            bool bInventoryVisible_;
-            unsigned int createdEquipmentWindows_;
-            unsigned int createdUsableWindows_;
-            unsigned int visibleEquipmentWindows_;
-            unsigned int visibleUsableWindows_;
-
-            static PickupInventory* pickupInventory_s;
-    }; // tolua_export
-} // tolua_export
-
-#endif /* _PickupInventory_H__ */
Index: code/branches/pickup3/src/orxonox/pickup/PickupSpawner.cc
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/PickupSpawner.cc	(revision 6467)
+++ 	(revision )
@@ -1,188 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of PickupSpawner.
-*/
-
-#include "PickupSpawner.h"
-
-#include "BaseItem.h"
-
-#include "core/CoreIncludes.h"
-#include "core/GUIManager.h"     // HACK; see below
-#include "core/Template.h"
-#include "core/XMLPort.h"
-#include "worldentities/pawns/Pawn.h"
-#include "PickupInventory.h"    // HACK; Only for hack, remove later
-
-
-namespace orxonox
-{
-    const float PickupSpawner::bounceSpeed_s = 6.0f;
-    const float PickupSpawner::rotationSpeed_s = 1.0f;
-    const float PickupSpawner::bounceDistance_s = 4.0f;
-
-    CreateFactory(PickupSpawner);
-
-    /**
-        @brief Constructor. Registers the PickupSpawner.
-        @param creator Pointer to the object which created this item.
-    */
-    PickupSpawner::PickupSpawner(BaseObject* creator) : StaticEntity(creator)
-    {
-        RegisterObject(PickupSpawner);
-
-        this->itemTemplate_ = 0;
-        this->triggerDistance_ = 20;
-        this->respawnTime_ = 0.0f;
-        this->tickSum_ = 0.0f;
-    }
-    //! Deconstructor.
-    PickupSpawner::~PickupSpawner()
-    {
-    }
-    /**
-        @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);
-
-        XMLPortParam(PickupSpawner, "item", setItemTemplateName, getItemTemplateName, xmlelement, mode);
-        XMLPortParam(PickupSpawner, "triggerDistance", setTriggerDistance, getTriggerDistance, xmlelement, mode);
-        XMLPortParam(PickupSpawner, "respawnTime", setRespawnTime, getRespawnTime, xmlelement, mode);
-
-        // HACKs
-        // Load the GUI image as soon as the PickupSpawner gets loaded
-        //  = less delays while running
-        BaseObject* newObject = this->itemTemplate_->getBaseclassIdentifier()->fabricate(this);
-        BaseItem* asItem = orxonox_cast<BaseItem*>(newObject);
-        if (asItem)
-        {
-            asItem->addTemplate(this->itemTemplate_);
-            PickupInventory::getImageForItem(asItem);
-            newObject->destroy();
-        }
-
-        //  & load the GUI itself too, along with some empty windows
-        //   = even less delays
-        GUIManager::showGUI("PickupInventory");
-        GUIManager::hideGUI("PickupInventory");
-        PickupInventory::getSingleton();
-    }
-    /**
-        @brief Invoked when the activity has changed. Sets visibility of attached objects.
-    */
-    void PickupSpawner::changedActivity()
-    {
-        SUPER(PickupSpawner, changedActivity);
-
-        for (std::set<WorldEntity*>::const_iterator it = this->getAttachedObjects().begin(); it != this->getAttachedObjects().end(); it++)
-            (*it)->setVisible(this->isActive());
-    }
-    /**
-        @brief Set the template name of the item to spawn, also loads the template.
-        @param name Name of the new template.
-    */
-    void PickupSpawner::setItemTemplateName(const std::string& name)
-    {
-        this->itemTemplateName_ = name;
-        this->itemTemplate_ = Template::getTemplate(name);
-    }
-    /**
-        @brief Tick, checks if any Pawn is close enough to trigger.
-        @param dt Time since last tick.
-    */
-    void PickupSpawner::tick(float dt)
-    {
-        if (this->isActive())
-        {
-            for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
-            {
-                Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
-                if (distance.length() < this->triggerDistance_)
-                    this->trigger(*it);
-            }
-            this->yaw(Radian(rotationSpeed_s*dt));
-            this->tickSum_ += bounceSpeed_s*dt;
-            this->translate(Vector3(0,bounceDistance_s*dt*sin(this->tickSum_),0));
-            if (this->tickSum_ > 2*Ogre::Math::PI)
-                this->tickSum_ -= 2*Ogre::Math::PI;
-        }
-    }
-    /**
-        @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.
-    */
-    void PickupSpawner::trigger(Pawn* pawn)
-    {
-        if (this->isActive() && this->itemTemplate_ && this->itemTemplate_->getBaseclassIdentifier())
-        {
-            BaseObject* newObject = this->itemTemplate_->getBaseclassIdentifier()->fabricate(this);
-            BaseItem* asItem = orxonox_cast<BaseItem*>(newObject);
-            if (asItem)
-            {
-                asItem->setPickupIdentifier(this->itemTemplateName_);
-                asItem->addTemplate(this->itemTemplate_);
-
-                if (asItem->pickedUp(pawn))
-                {
-                    COUT(3) << this->itemTemplateName_ << " got picked up." << std::endl;
-
-                    if (this->respawnTime_ > 0.0f)
-                    {
-                        this->respawnTimer_.setTimer(this->respawnTime_, false, createExecutor(createFunctor(&PickupSpawner::respawnTimerCallback, this)));
-
-                        this->setActive(false);
-                        this->fireEvent();
-                    }
-                }
-                else
-                    newObject->destroy();
-            }
-        }
-    }
-    /**
-        @brief Invoked by the timer, re-activates the PickupSpawner.
-    */
-    void PickupSpawner::respawnTimerCallback()
-    {
-        COUT(3) << "PickupSpawner reactivated." << std::endl;
-
-        this->setActive(true);
-    }
-}
Index: code/branches/pickup3/src/orxonox/pickup/UsableItem.cc
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/UsableItem.cc	(revision 6467)
+++ 	(revision )
@@ -1,47 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of UsableItem.
-*/
-
-#include "UsableItem.h"
-#include "core/CoreIncludes.h"
-
-namespace orxonox
-{
-    /**
-    @brief Constructor. Registers the UsableItem.
-    @param creator Pointer to the object which created this item.
-    */
-    UsableItem::UsableItem(BaseObject* creator) : BaseItem(creator)
-    {
-        RegisterObject(UsableItem);
-    }
-}
Index: code/branches/pickup3/src/orxonox/pickup/UsableItem.h
===================================================================
--- code/branches/pickup3/src/orxonox/pickup/UsableItem.h	(revision 6467)
+++ 	(revision )
@@ -1,61 +1,0 @@
-/*
- *   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:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of UsableItem.
-*/
-
-#ifndef _UsableItem_H__
-#define _UsableItem_H__
-
-#include "OrxonoxPrereqs.h"
-#include "BaseItem.h"
-
-namespace orxonox
-{
-    /**
-        @brief Base class for all usable items (not usable yet).
-        @author Daniel 'Huty' Haggenmueller
-    */
-    class _OrxonoxExport UsableItem : public BaseItem
-    {
-        //TODO: What is this exactly?
-        public:
-            UsableItem(BaseObject* creator);
-            virtual ~UsableItem() { }
-
-            /**
-                @brief Method invoked when the item is being used.
-                @param pawn Pawn which is using the item.
-            */
-            virtual void used(Pawn* pawn) { }
-    };
-}
-
-#endif /* _UsableItem_H__ */
