Changeset 6466 for code/branches/pickup3

Timestamp:

Mar 4, 2010, 11:56:26 AM (15 years ago)

Author:

dafrick

Message:

Lots of things done in pickups module. Compiles, but it seems, that I've also introduced an error preventing steering of the spaceship.

Location:

code/branches/pickup3/src

Files:

• libraries/core/OrxonoxClass.h (modified) (3 diffs)
• libraries/core/Super.h (modified) (3 diffs)
• modules/pickup/CMakeLists.txt (modified) (2 diffs)
• modules/pickup/DroppedItem.cc (modified) (1 diff)
• modules/pickup/DroppedItem.h (modified) (1 diff)
• modules/pickup/PickupCollection.cc (modified) (2 diffs)
• modules/pickup/PickupCollection.h (modified) (2 diffs)
• modules/pickup/PickupPrereqs.h (modified) (1 diff)
• modules/pickup/PickupSpawner.cc (modified) (8 diffs)
• modules/pickup/PickupSpawner.h (modified) (1 diff)
• orxonox/CMakeLists.txt (modified) (1 diff)
• orxonox/OrxonoxPrereqs.h (modified) (1 diff)
• orxonox/interfaces/CMakeLists.txt (modified) (1 diff)
• orxonox/interfaces/InterfaceCompilation.cc (modified) (2 diffs)
• orxonox/interfaces/PickupCarrier.h (modified) (1 diff)
• orxonox/interfaces/Pickupable.h (modified) (3 diffs)
• orxonox/pickup/CMakeLists.txt (modified) (1 diff)
• orxonox/worldentities/pawns/Pawn.h (modified) (2 diffs)

code/branches/pickup3/src/libraries/core/OrxonoxClass.h

@@ -39 +39 @@
 
 #include "CorePrereqs.h"
+#include "Super.h"
 
 #include <set>
@@ -107 +108 @@
             bool isParentOf(const OrxonoxClass* object);
             bool isDirectParentOf(const OrxonoxClass* object);
+            
+            virtual void clone(OrxonoxClass* item) {}
 
             inline unsigned int getReferenceCount() const
@@ -169 +172 @@
             std::vector<std::pair<unsigned int, void*> > objectPointers_;
     };
+    
+    SUPER_FUNCTION(11, OrxonoxClass, clone, true);
+    
 }
 

code/branches/pickup3/src/libraries/core/Super.h

@@ -270 +270 @@
     #define SUPER_changedUsed(classname, functionname, ...) \
         SUPER_NOARGS(classname, functionname)
+        
+    #define SUPER_clone(classname, functionname, ...) \
+        SUPER_ARGS(classname, functionname, __VA_ARGS__)
+        
+    #define SUPER_changedCarrier(classname, functionname, ...) \
+        SUPER_NOARGS(classname, functionname)
+        
     // (1/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
 
@@ -524 +531 @@
             ()
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(11, clone, true, OrxonoxClass* item)
+            (item)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(12, changedCarrier, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+
         // (2/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
 
@@ -578 +594 @@
     SUPER_INTRUSIVE_DECLARATION(changedGametype);
     SUPER_INTRUSIVE_DECLARATION(changedUsed);
+    SUPER_INTRUSIVE_DECLARATION(clone);
+    SUPER_INTRUSIVE_DECLARATION(changedCarrier);
     // (3/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
 

code/branches/pickup3/src/modules/pickup/CMakeLists.txt

@@ -1 +1 @@
 SET_SOURCE_FILES(PICKUP_SRC_FILES
+  DroppedItem.cc
+  Pickup.cc
   PickupCollection.cc
+  PickupCollectionIdentifier.cc
+  PickupManager.cc
+  PickupRepresentation.cc
   PickupSpawner.cc
 )
+
+ADD_SUBDIRECTORY(items)
 
 ORXONOX_ADD_LIBRARY(pickup
@@ -16 +23 @@
   SOURCE_FILES ${PICKUP_SRC_FILES}
 )
-

code/branches/pickup3/src/modules/pickup/DroppedItem.cc

@@ -75 +75 @@
     }
     
+    //TODO; Doesn't seem to be needed anymore, just put setPosition in the constructor.
     void DroppedItem::createDrop(const Vector3& position)
     {

code/branches/pickup3/src/modules/pickup/DroppedItem.h

@@ -35 +35 @@
 #define _DroppedItem_H__
 
-#include "pickup/PickupPrereqs.h"
+#include "PickupPrereqs.h"
 
 #include "PickupSpawner.h"

code/branches/pickup3/src/modules/pickup/PickupCollection.cc

@@ -72 +72 @@
         SUPER(PickupCollection, XMLPort, xmlelement, mode);
         
-        //TODO: Does this work? Problem could be, that Pickupable itself cannot be instantiated through XML...
+        //TODO: Does this work? Problem could be, that Pickupable itself cannot be instantiated through XML, doubt that, though.
         XMLPortObject(PickupCollection, PickupCollection, "pickupables", addPickupable, getPickupable, xmlelement, mode);
+        
+        this->initializeIdentifier();
+    }
+    
+    void PickupCollection::initializeIdentifier(void)
+    {
+        this->pickupCollectionIdentifier_.addClass(this->getIdentifier());
+        
+        for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
+            this->pickupCollectionIdentifier_.addPickup((*it)->getPickupIdentifier());
+        }
     }
     
@@ -114 +126 @@
         for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
         {
-            (*it)->changedUsed();
+            (*it)->setUsed(this->isUsed());
         }
     }
     
-    /**
-    @brief
-        Puts the PickupCollection in use.
-    @return
-        Returns true if successful.
-    */
-    //TODO: Revert if one fails? (same for unused)
-    bool PickupCollection::use(void)
+    void PickupCollection::changedCarrier()
     {
-        if(this->isUsed())
-            return false;
+        SUPER(PickupCollection, changedCarrier);
         
-        bool success = true;
-        //! Set all Pickupables to used.
+        //! Change the carrier for all Pickupables this PickupCollection consists of.
         for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
         {
-            if(!(*it)->use())
-            {
-                success = false;
-            }
+            (*it)->setCarrier(this->getCarrier());
         }
-        
-        this->changedUsed();
-        
-        return success;
-    }
-    
-    /**
-    @brief
-        Puts the PickupCollection out of use.
-    @return
-        Returns true if successful.
-    */
-    bool PickupCollection::unuse(void)
-    {
-        if(!this->isUsed())
-            return false;
-        
-        bool success = true;
-        //! Set all Pickupables to unused.
-        for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
-        {
-            if(!(*it)->unuse())
-            {
-                success = false;
-            }
-        }
-        
-        this->changedUsed();
-        
-        return success;
-    }
-
-    /**
-    @brief
-        Is invoked when the pickup is picked up.
-    @param carrier
-        The PickupCarrier that is picking up this pickup.
-    @return
-        Returns true if successful.
-    */
-    //TODO: Something should happen in the carrier as well, maybe just in the carrier. Owner might not be correct if the carrier hands the pickup down or up. Maybe even a Pawn as input instead fo a carrier. Or do this in Spawner?
-    bool PickupCollection::pickup(PickupCarrier* carrier)
-    {
-        if(this->getOwner() != NULL)
-        {
-            COUT(2) << "Pickup wanted to get picked up by a new carrier, but it already has a carrier." << std::endl;
-            return false;
-        }
-        for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
-        {
-            (*it)->setOwner(carrier);
-        }
-        
-        this->setOwner(carrier);
-        
-        return true;
-    }
-    
-    /**
-    @brief
-        Drop the pickup.
-    @return
-        Return true if successful.
-    */
-    bool PickupCollection::drop(void)
-    {
-        this->unuse();
-        this->setOwner(NULL);
-        
-        //TODO: Create new Pickupspawner/DroppedPickup
-        return true;
     }
     
     //TODO: Steal description from Pickupable.
-    Pickupable* PickupCollection::clone()
+    void PickupCollection::clone(OrxonoxClass* item)
     {
-        Template* collectionTemplate = Template::getTemplate(this->getIdentifier()->getName());
-        BaseObject* newObject = collectionTemplate->getBaseclassIdentifier()->fabricate(this);
+        if(item == NULL)
+            item = new PickupCollection(this);
         
-        PickupCollection* newCollection = dynamic_cast<PickupCollection*>(newObject);
+        SUPER(PickupCollection, clone, item);
+        
+        PickupCollection* pickup = dynamic_cast<PickupCollection*>(item);
         for(std::vector<Pickupable*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
         {
             Pickupable* newPickup = (*it)->clone();
-            newCollection->pickups_.push_back(newPickup);
+            pickup->addPickupable(newPickup);
         }
-        
-        Pickupable* pickup = dynamic_cast<Pickupable*>(newCollection);
-        return pickup;
+
+        pickup->initializeIdentifier();
     }
     

code/branches/pickup3/src/modules/pickup/PickupCollection.h

@@ -30 +30 @@
 #define _PickupCollection_H__
 
-#include "pickup/PickupPrereqs.h"
+#include "PickupPrereqs.h"
 
 #include "interfaces/Pickupable.h"
 #include "core/BaseObject.h"
 #include "core/XMLPort.h"
+
+#include "PickupCollectionIdentifier.h"
 
 #include <list>
@@ -60 +62 @@
             virtual void changedUsed(void);
             
-            virtual bool use(void);
-            virtual bool unuse(void);
+            virtual void changedCarrier(void);
             
-            virtual bool pickup(PickupCarrier* carrier);
-            virtual bool drop(void);
+            virtual void clone(OrxonoxClass* item);
             
-            virtual Pickupable* clone(void);
+            virtual const PickupIdentifier* getPickupIdentifier(void)
+                { return &this->pickupCollectionIdentifier_; }
             
             bool addPickupable(Pickupable* pickup);
             const Pickupable* getPickupable(unsigned int index);
+            
+        protected:
+            void initializeIdentifier(void);
+            
+            PickupCollectionIdentifier pickupCollectionIdentifier_;
             
         private:

code/branches/pickup3/src/modules/pickup/PickupPrereqs.h

@@ -67 +67 @@
 
     class DroppedItem;
+    class Pickup;
     class PickupCollection;
+    class PickupCollectionIdentifier;
+    class PickupManager;
+    class PickupRepresentation;
     class PickupSpawner;
+    
+    //items
+    class HealthPickup;
     
 }

code/branches/pickup3/src/modules/pickup/PickupSpawner.cc

@@ -39 +39 @@
 #include "core/XMLPort.h"
 #include "worldentities/pawns/Pawn.h"
+#include "PickupManager.h"
+#include "PickupRepresentation.h"
 //#include "PickupInventory.h"    // HACK; Only for hack, remove later
 
@@ -59 +61 @@
     PickupSpawner::PickupSpawner(BaseObject* creator) : StaticEntity(creator)
     {
+        RegisterObject(PickupSpawner);
+        
         this->initialize();
+        
+        PickupRepresentation* representation = PickupManager::getInstance().getRepresentation(NULL);
+        
+        COUT(1) << "MUP4 " << representation << std::endl;
+        this->attach(representation->getSpawnerRepresentation(this));
+        
+        COUT(1) << "MUP6" << std::endl;
     }
 
@@ -78 +89 @@
     PickupSpawner::PickupSpawner(BaseObject* creator, Pickupable* pickup, float triggerDistance, float respawnTime, int maxSpawnedItems) : StaticEntity(creator)
     {
+        RegisterObject(PickupSpawner);
+        
         this->initialize();
   
@@ -85 +98 @@
         this->respawnTime_ = respawnTime;
         this->setMaxSpawnedItems(maxSpawnedItems);
+        
+        PickupRepresentation* representation = PickupManager::getInstance().getRepresentation(this->pickup_->getPickupIdentifier());
+        this->attach(representation->getSpawnerRepresentation(this));
     }
 
@@ -93 +109 @@
     void PickupSpawner::initialize(void)
     {
-        RegisterObject(PickupSpawner);
-
         this->pickup_ = NULL;
         
@@ -215 +229 @@
         Time since last tick.
     */
-    //TODO: Replace this with a real DistanceTrigger?
+    //TODO: Replace this with a real DistanceTrigger? Or better with collisions?
     void PickupSpawner::tick(float dt)
     {
@@ -259 +273 @@
             if (pickup != NULL) //!< If everything went ok, and pickup is not NULL.
             {
+                //TODO: Not correct anymore.
                 PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(pawn);
                 if(carrier == NULL)
@@ -266 +281 @@
                 }
                 
-                if(pickup->pickup(carrier))
+                if(carrier->pickup(pickup))
                 {
                     COUT(3) << "Pickup got picked up." << std::endl;

code/branches/pickup3/src/modules/pickup/PickupSpawner.h

@@ -35 +35 @@
 #define _PickupSpawner_H__
 
-#include "pickup/PickupPrereqs.h"
+#include "PickupPrereqs.h"
 
 #include <string>

code/branches/pickup3/src/orxonox/CMakeLists.txt

@@ -47 +47 @@
 ADD_SUBDIRECTORY(items)
 ADD_SUBDIRECTORY(overlays)
+ADD_SUBDIRECTORY(pickup)
 ADD_SUBDIRECTORY(sound)
 ADD_SUBDIRECTORY(weaponsystem)

code/branches/pickup3/src/orxonox/OrxonoxPrereqs.h

@@ -135 +135 @@
     class OrxonoxOverlay;
     class OverlayGroup;
+    
+    // pickup
+    class PickupIdentifier;
 
     //sound

code/branches/pickup3/src/orxonox/interfaces/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
   InterfaceCompilation.cc
+  Pickupable.cc
   RadarViewable.cc
 )

code/branches/pickup3/src/orxonox/interfaces/InterfaceCompilation.cc

@@ -34 +34 @@
 
 #include "GametypeMessageListener.h"
-#include "Pickupable.h"
 #include "PickupCarrier.h"
 #include "PlayerTrigger.h"
@@ -52 +51 @@
     {
         RegisterRootObject(GametypeMessageListener);
-    }
-    
-    //----------------------------
-    // Pickupable
-    //----------------------------
-    Pickupable::Pickupable()
-    {
-        RegisterRootObject(Pickupable);
-
-        this->used_ = false;
-        this->owner_ = NULL;
     }
     

code/branches/pickup3/src/orxonox/interfaces/PickupCarrier.h

@@ -37 +37 @@
 #include "OrxonoxPrereqs.h"
 #include "core/OrxonoxClass.h"
+#include "Pickupable.h"
 
 #include <set>
+#include <list>
 
 namespace orxonox
 {
 
-    class _OrxonoxExport PickupCarrier : public OrxonoxClass
+    class _OrxonoxExport PickupCarrier : virtual public OrxonoxClass
     {
+        friend class Pickupable;
         
         public:
             PickupCarrier();
             virtual ~PickupCarrier() {}
+            
+            //TODO: Secure uniqueness of each item in the set, if neccessary, check.
+            inline bool pickup(Pickupable* pickup)
+                {
+                    bool pickedUp = this->pickups_.insert(pickup).second;
+                    if(pickedUp) pickup->pickedUp(this);
+                    return pickedUp;
+                }
+                
+            inline bool drop(Pickupable* pickup)
+                { 
+                   bool dropped = this->pickups_.erase(pickup) == 1;
+                   if(dropped)
+                   {
+                       pickup->dropped();
+                        //TODO: Create Spawner.
+                   }
+                   return dropped;
+                }
+                
+            inline bool isTarget(Pickupable* pickup)
+                {
+                    if(pickup->isTarget(this))
+                        return true;
+                    const std::list<PickupCarrier*>* children = this->getChildren();
+                    for(std::list<PickupCarrier*>::const_iterator it = children->begin(); it != children->end(); it++)
+                    {
+                        if((*it)->isTarget(pickup))
+                            return true;
+                    }
+                    
+                    return false;
+                }
+            
+        protected:            
+            //TODO: Good return type?
+            virtual const std::list<PickupCarrier*>* getChildren(void) = 0;
+            virtual PickupCarrier* getParent(void) = 0;
         
         private:
+            std::set<Pickupable*> pickups_;
             
-            std::set<Pickupable*> pickups_;
         
     };

code/branches/pickup3/src/orxonox/interfaces/Pickupable.h

@@ -38 +38 @@
 #include "core/OrxonoxClass.h"
 
-#include "core/Identifier.h"
 #include "core/Super.h"
-#include "interfaces/PickupCarrier.h"
-#include "worldentities/pawns/Pawn.h"
+#include "pickup/PickupIdentifier.h"
 #include <list>
 
 namespace orxonox
 {
-
-    //! Enum for the activation type.
-    namespace pickupActivationType
-    {
-        enum Value
-        {
-            immediate,
-            onUse,
-        };
-    }
-    
-    //! Enum for the duration tyoe.
-    namespace pickupDurationType
-    {
-        enum Value
-        {
-            once,
-            continuous,
-        };
-    }
     
     /**
     @brief
-        An Interface (or more precisely an abstract Class) to model and manage 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
@@ -76 +54 @@
     class _OrxonoxExport Pickupable : virtual public OrxonoxClass
     {
+        
         public:
             Pickupable(); //!< Default constructor.
             virtual ~Pickupable() {} //!< Default destructor.
-            
-            /**
-            @brief Get the activation type of the pickup.
-            @return Returns the activation type of the pickup.
-            */
-            inline pickupActivationType::Value getActivationType(void)
-                { return this->activationType_; }
-            /**
-            @brief Get the duration type of the pickup.
-            @return Returns the duration type of the pickup.
-            */
-            inline pickupDurationType::Value getDurationType(void)
-                { return this->durationType_; }
                 
             /**
-            @brief Get the owner of the pickup.
-            @return Returns a pointer to the owner of the pickup.
+            @brief Get the carrier of the pickup.
+            @return Returns a pointer to the carrier of the pickup.
             */
-            inline PickupCarrier* getOwner(void)
-                { return this->owner_; }
+            inline PickupCarrier* getCarrier(void)
+                { return this->carrier_; }
                 
             /**
@@ -107 +73 @@
                 { return this->used_; }
                 
-            /**
-            @brief Get whether the given pawn is a target of this pickup.
-            @param pawn The Pawn of which it has to be determinde whether it is a target of this pickup.
-            @return Retruns true if the given Pawn is a target.
-            */
-            //TODO: Determine whether Pawn includes all possible cases and if PickupCarrier wouldn't be better.
-            inline bool isTarget(Pawn* pawn)
-                {
-                    Identifier* identifier = pawn->getIdentifier();
-                    for(std::list<Identifier*>::iterator it = this->targets_.begin(); it != this->targets_.end(); it++)
-                    {
-                        if(identifier->isA(*it))
-                            return true;
-                    }
-                    return false;
-                }
+            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_; }
                 
-            /**
-            @brief  Should be called when the pickup has transitetd 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 changeUsed method.
-            */
-            virtual inline void changedUsed(void)
-                {
-                    if(this->isUsed())
-                        this->used_ = false;
-                    else
-                        this->used_ = true;
-                }
-
-            /**
-            @brief  Sets the pickup to used and makes sure the effects of the pickup take effect at the right places.
-                    This method needs to be implemented by any Class inheriting from Pickupable.
-            @return Returns false if for some reason the method could not take effect, e.g. because it is already in use, or some other circumstance.
-            */
-            virtual bool use(void) = 0;
-            /**
-            @brief  Sets the pickup to unused and makes sure the effects of the pickup no longer take effect.
-                    This method needs to be implemented by any Class inheriting from Pickupable.
-            @return Returns false if for some reason the method could not take effect, e.g. because the pickup is already unused, or some other circumstance.
-            */
-            virtual bool unuse(void) = 0;
+            virtual void clone(OrxonoxClass* item);
             
             /**
-            @brief  Adds the pickup to the input PickupCarrier.
-                    This method needs to be implemented by any Class inheriting from Pickupable.
-            @return Returns false if, for some reason, the pickup could not be picked up.
+            @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.
             */
-            //TODO: Maybe better in PickupCarrier?
-            virtual bool pickup(PickupCarrier* carrier) = 0;
-            /**
-            @brief  Drops the pickup. Creates a PickupSpawner at the place the Pickup has been dropped.
-                    This method needs to be implemented by any Class inheriting from Pickupable.
-            @return Returns false if the pickup could not be dropped.
-            */
-            //TODO: Probably could be done here?
-            virtual bool drop(void) = 0;
+            virtual void changedUsed(void) {}
             
             /**
-            @brief  Creates a duplicate of the pickup.
-                    This method needs to e implemented by any Class inheriting from Pickupable.
-            @return Returns the clone of this pickup as a pointer to a Pickupable.
+            @brief  Should be called when the pickup has transited from picked up to dropped or the other way around.
+                    Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedCarrier); to their changedCarrier method.
             */
-            //TODO: Would be nicer if standard case was implemented here.
-            virtual Pickupable* clone(void) = 0;
+            virtual void changedCarrier(void) {}
             
-            /**
-            @brief Sets the owner of the pickup.
-            @param owner Sets the input PickupCarrier as the owner of the pickup.
-            */
-            //TODO: Protected? Check for NULL and return true/false?
-            inline void setOwner(PickupCarrier* owner)
-                { this->owner_ = owner; }
+            bool setCarrier(PickupCarrier* carrier);
+            
+        protected:
+            void initializeIdentifier(void) {}
+            
+            PickupIdentifier pickupIdentifier_;
             
         private:
-            
-            pickupActivationType::Value activationType_; //!< The activation type of the Pickup.
-            pickupDurationType::Value durationType_; //!< The duration type of the pickup.
+            inline void setPickedUp(bool pickedUp)
+                { this->pickedUp_ = pickedUp; }
             
             bool used_; //!< Whether the pickup is currently in use or not.
+            bool pickedUp_; //!< Whether the pickup is currently picked up or not.
             
-            PickupCarrier* owner_; //!< The owner of the pickup.
+            PickupCarrier* carrier_; //!< The owner of the pickup.
             std::list<Identifier*> targets_; //!< The possible targets of this pickup.
 
     };
     
-    SUPER_FUNCTION(10, Pickupable, changedUsed, true)
+    SUPER_FUNCTION(10, Pickupable, changedUsed, false);
+    SUPER_FUNCTION(12, Pickupable, changedCarrier, false);
 }
 

code/branches/pickup3/src/orxonox/pickup/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
-  BaseItem.cc
-  EquipmentItem.cc
-  ModifierPickup.cc
-  PassiveItem.cc
-  PickupCollection.cc
-  PickupInventory.cc
-  UsableItem.cc
+  PickupIdentifier.cc
 )
 
-ADD_SUBDIRECTORY(items)

code/branches/pickup3/src/orxonox/worldentities/pawns/Pawn.h

@@ -33 +33 @@
 
 #include <string>
+#include "interfaces/PickupCarrier.h"
 #include "interfaces/RadarViewable.h"
 #include "worldentities/ControllableEntity.h"
-//TODO: Remove.
-//#include "pickup/PickupCollection.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Pawn : public ControllableEntity, public RadarViewable
+    class _OrxonoxExport Pawn : public ControllableEntity, public RadarViewable, public PickupCarrier
     {
         friend class WeaponSystem;
@@ -139 +138 @@
             //TODO: Remove.
             //PickupCollection pickups_;
+            virtual const std::list<PickupCarrier*>* getChildren(void)
+                { return new std::list<PickupCarrier*>(); }
+            virtual PickupCarrier* getParent(void)
+                { return NULL; }
 
             float health_;