Index: code/trunk/src/modules/pickup/CollectiblePickup.cc
===================================================================
--- code/trunk/src/modules/pickup/CollectiblePickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/CollectiblePickup.cc	(revision 11071)
@@ -47,5 +47,5 @@
         Registers the object and initializes variables.
     */
-    CollectiblePickup::CollectiblePickup() : collection_(NULL)
+    CollectiblePickup::CollectiblePickup() : collection_(nullptr)
     {
         RegisterObject(CollectiblePickup);
@@ -103,5 +103,5 @@
     void CollectiblePickup::wasRemovedFromCollection(void)
     {
-        this->collection_ = NULL;
+        this->collection_ = nullptr;
     }
 }
Index: code/trunk/src/modules/pickup/CollectiblePickup.h
===================================================================
--- code/trunk/src/modules/pickup/CollectiblePickup.h	(revision 11052)
+++ code/trunk/src/modules/pickup/CollectiblePickup.h	(revision 11071)
@@ -61,6 +61,6 @@
             virtual ~CollectiblePickup(); //! Destructor.
 
-            virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
-            virtual void changedPickedUp(void); //!< Is called when the pickup has transited from picked up to dropped or the other way around.
+            virtual void changedUsed(void) override; //!< Is called when the pickup has transited from used to unused or the other way around.
+            virtual void changedPickedUp(void) override; //!< Is called when the pickup has transited from picked up to dropped or the other way around.
 
             /**
@@ -69,5 +69,5 @@
             */
             bool isInCollection(void) const
-                { return this->collection_ != NULL; }
+                { return this->collection_ != nullptr; }
 
         private:
Index: code/trunk/src/modules/pickup/Pickup.cc
===================================================================
--- code/trunk/src/modules/pickup/Pickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/Pickup.cc	(revision 11071)
@@ -78,6 +78,6 @@
     void Pickup::initialize(void)
     {
-        this->activationType_ = pickupActivationType::immediate;
-        this->durationType_ = pickupDurationType::once;
+        this->activationType_ = PickupActivationType::immediate;
+        this->durationType_ = PickupDurationType::once;
     }
 
@@ -105,7 +105,7 @@
         switch(this->getActivationType())
         {
-            case pickupActivationType::immediate:
+            case PickupActivationType::immediate:
                 return activationTypeImmediate_s;
-            case pickupActivationType::onUse:
+            case PickupActivationType::onUse:
                 return activationTypeOnUse_s;
             default:
@@ -124,7 +124,7 @@
         switch(this->getDurationType())
         {
-            case pickupDurationType::once:
+            case PickupDurationType::once:
                 return durationTypeOnce_s;
-            case pickupDurationType::continuous:
+            case PickupDurationType::continuous:
                 return durationTypeContinuous_s;
             default:
@@ -142,7 +142,7 @@
     {
         if(type == Pickup::activationTypeImmediate_s)
-            this->setActivationType(pickupActivationType::immediate);
+            this->setActivationType(PickupActivationType::immediate);
         else if(type == Pickup::activationTypeOnUse_s)
-            this->setActivationType(pickupActivationType::onUse);
+            this->setActivationType(PickupActivationType::onUse);
         else
             orxout(internal_error, context::pickups) << "Invalid activationType '" << type << "' in " << this->getIdentifier()->getName() << "." << endl;
@@ -158,7 +158,7 @@
     {
         if(type == Pickup::durationTypeOnce_s)
-            this->setDurationType(pickupDurationType::once);
+            this->setDurationType(PickupDurationType::once);
         else if(type == Pickup::durationTypeContinuous_s)
-            this->setDurationType(pickupDurationType::continuous);
+            this->setDurationType(PickupDurationType::continuous);
         else
             orxout(internal_error, context::pickups) << "Invalid durationType '" << type << "' in " << this->getIdentifier()->getName() << "." << endl;
Index: code/trunk/src/modules/pickup/Pickup.h
===================================================================
--- code/trunk/src/modules/pickup/Pickup.h	(revision 11052)
+++ code/trunk/src/modules/pickup/Pickup.h	(revision 11071)
@@ -53,12 +53,9 @@
     @ingroup Pickup
     */
-    namespace pickupActivationType
+    enum class PickupActivationType
     {
-        enum Value
-        {
-            immediate, //!< Means that the @ref orxonox::Pickup "Pickup" will be used immediately after pickup.
-            onUse, //!< Means that the @ref orxonox::Pickup "Pickup" will be used at a later point trough some external influence.
-        };
-    }
+        immediate, //!< Means that the @ref orxonox::Pickup "Pickup" will be used immediately after pickup.
+        onUse, //!< Means that the @ref orxonox::Pickup "Pickup" will be used at a later point trough some external influence.
+    };
 
     /**
@@ -68,12 +65,9 @@
     @ingroup Pickup
     */
-    namespace pickupDurationType
+    enum class PickupDurationType
     {
-        enum Value
-        {
-            once, //!< Means that the @ref orxonox::Pickup "Pickup" will be used only once at a singular time instant.
-            continuous, //!< Means that the @ref orxonox::Pickup "Pickup" will be used over a continuous timespan.
-        };
-    }
+        once, //!< Means that the @ref orxonox::Pickup "Pickup" will be used only once at a singular time instant.
+        continuous, //!< Means that the @ref orxonox::Pickup "Pickup" will be used over a continuous timespan.
+    };
 
     /**
@@ -103,7 +97,7 @@
             virtual ~Pickup(); //!< Destructor.
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 
-            virtual const std::string& getRepresentationName() const
+            virtual const std::string& getRepresentationName() const override
                 { return this->representationName_; }
 
@@ -112,5 +106,5 @@
             @return Returns the activation type of the Pickup.
             */
-            inline pickupActivationType::Value getActivationType(void) const
+            inline PickupActivationType getActivationType(void) const
                 { return this->activationType_; }
             /**
@@ -118,5 +112,5 @@
             @return Returns the duration type of the Pickup.
             */
-            inline pickupDurationType::Value getDurationType(void) const
+            inline PickupDurationType getDurationType(void) const
                 { return this->durationType_; }
 
@@ -129,5 +123,5 @@
             */
             inline bool isImmediate(void) const
-                { return this->getActivationType() == pickupActivationType::immediate; }
+                { return this->getActivationType() == PickupActivationType::immediate; }
             /**
             @brief Get whether the activation type is 'onUse'.
@@ -135,5 +129,5 @@
             */
             inline bool isOnUse(void) const
-                { return this->getActivationType() == pickupActivationType::onUse; }
+                { return this->getActivationType() == PickupActivationType::onUse; }
             /**
             @brief Get whether the duration type is 'once'.
@@ -141,5 +135,5 @@
             */
             inline bool isOnce(void) const
-                { return this->getDurationType() == pickupDurationType::once; }
+                { return this->getDurationType() == PickupDurationType::once; }
             /**
             @brief Get whether the duration type is 'continuous'.
@@ -147,10 +141,10 @@
             */
             inline bool isContinuous(void) const
-                { return this->getDurationType() == pickupDurationType::continuous; }
+                { return this->getDurationType() == PickupDurationType::continuous; }
 
-            virtual void changedPickedUp(void); //!< Should be called when the pickup has transited from picked up to dropped or the other way around.
+            virtual void changedPickedUp(void) override; //!< Should be called when the pickup has transited from picked up to dropped or the other way around.
 
         protected:
-            virtual bool createSpawner(void); //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
+            virtual bool createSpawner(void) override; //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
 
             /**
@@ -164,5 +158,5 @@
             @param type The activation type of the Pickup.
             */
-            inline void setActivationType(pickupActivationType::Value type)
+            inline void setActivationType(PickupActivationType type)
                 { this->activationType_ = type; }
             /**
@@ -170,5 +164,5 @@
             @param type The duration type of the Pickup.
             */
-            inline void setDurationType(pickupDurationType::Value type)
+            inline void setDurationType(PickupDurationType type)
                 { this->durationType_ = type; }
 
@@ -180,6 +174,6 @@
 
             std::string representationName_; //!< The name of the associated PickupRepresentation.
-            pickupActivationType::Value activationType_; //!< The activation type of the Pickup.
-            pickupDurationType::Value durationType_; //!< The duration type of the Pickup.
+            PickupActivationType activationType_; //!< The activation type of the Pickup.
+            PickupDurationType durationType_; //!< The duration type of the Pickup.
 
             //! Strings for the activation and duration types.
Index: code/trunk/src/modules/pickup/PickupCollection.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupCollection.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/PickupCollection.cc	(revision 11071)
@@ -68,8 +68,8 @@
     {
         // Destroy all Pickupables constructing this PickupCollection.
-        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
-        {
-            (*it)->wasRemovedFromCollection();
-            (*it)->destroy();
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            pickup->wasRemovedFromCollection();
+            pickup->destroy();
         }
         this->pickups_.clear();
@@ -99,6 +99,6 @@
         this->processingUsed_ = true;
         // Change used for all Pickupables this PickupCollection consists of.
-        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
-            (*it)->setUsed(this->isUsed());
+        for(CollectiblePickup* pickup : this->pickups_)
+            pickup->setUsed(this->isUsed());
 
         this->processingUsed_ = false;
@@ -119,9 +119,9 @@
         size_t numPickupsEnabled = 0;
         size_t numPickupsInUse = 0;
-        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
-        {
-            if ((*it)->isEnabled())
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            if (pickup->isEnabled())
                 ++numPickupsEnabled;
-            if ((*it)->isUsed())
+            if (pickup->isUsed())
                 ++numPickupsInUse;
         }
@@ -146,10 +146,10 @@
 
         // Change the PickupCarrier for all Pickupables this PickupCollection consists of.
-        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
-        {
-            if(this->getCarrier() == NULL)
-                (*it)->setCarrier(NULL);
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            if(this->getCarrier() == nullptr)
+                pickup->setCarrier(nullptr);
             else
-                (*it)->setCarrier(this->getCarrier()->getTarget(*it));
+                pickup->setCarrier(this->getCarrier()->getTarget(pickup));
         }
     }
@@ -186,7 +186,7 @@
         // If at least all the enabled pickups of this PickupCollection are no longer picked up.
         bool isOnePickupEnabledAndPickedUp = false;
-        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
-        {
-            if ((*it)->isEnabled() && (*it)->isPickedUp())
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            if (pickup->isEnabled() && pickup->isPickedUp())
             {
                 isOnePickupEnabledAndPickedUp = true;
@@ -208,7 +208,7 @@
     bool PickupCollection::isTarget(const PickupCarrier* carrier) const
     {
-        for(std::list<CollectiblePickup*>::const_iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
-        {
-            if(!carrier->isTarget(*it))
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            if(!carrier->isTarget(pickup))
                 return false;
         }
@@ -227,5 +227,5 @@
     bool PickupCollection::addPickupable(CollectiblePickup* pickup)
     {
-        if(pickup == NULL)
+        if(pickup == nullptr)
             return false;
 
@@ -247,5 +247,5 @@
     {
         if(this->pickups_.size() >= index)
-            return NULL;
+            return nullptr;
 
         std::list<CollectiblePickup*>::const_iterator it = this->pickups_.begin();
Index: code/trunk/src/modules/pickup/PickupCollection.h
===================================================================
--- code/trunk/src/modules/pickup/PickupCollection.h	(revision 11052)
+++ code/trunk/src/modules/pickup/PickupCollection.h	(revision 11071)
@@ -73,15 +73,15 @@
             virtual ~PickupCollection(); //!< Destructor.
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Creates an instance of this Class through XML.
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override; //!< Creates an instance of this Class through XML.
 
-            virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
-            virtual void changedCarrier(void); //!< Is called when the pickup has changed its PickupCarrier.
-            virtual void changedPickedUp(void); //!< Is called when the pickup has transited from picked up to dropped or the other way around.
+            virtual void changedUsed(void) override; //!< Is called when the pickup has transited from used to unused or the other way around.
+            virtual void changedCarrier(void) override; //!< Is called when the pickup has changed its PickupCarrier.
+            virtual void changedPickedUp(void) override; //!< Is called when the pickup has transited from picked up to dropped or the other way around.
 
-            virtual bool isTarget(const PickupCarrier* carrier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this PickupCollection.
+            virtual bool isTarget(const PickupCarrier* carrier) const override; //!< Get whether a given class, represented by the input Identifier, is a target of this PickupCollection.
 
             inline void setRepresentationName(const std::string& name)
                 { this->representationName_ = name; }
-            virtual const std::string& getRepresentationName() const
+            virtual const std::string& getRepresentationName() const override
                 { return this->representationName_; }
 
@@ -98,5 +98,5 @@
 
         protected:
-            virtual bool createSpawner(void); //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
+            virtual bool createSpawner(void) override; //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
 
         private:
Index: code/trunk/src/modules/pickup/PickupManager.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupManager.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/PickupManager.cc	(revision 11071)
@@ -68,5 +68,5 @@
         Constructor. Registers the PickupManager and creates the default PickupRepresentation.
     */
-    PickupManager::PickupManager() : guiLoaded_(false), pickupHighestIndex_(0), defaultRepresentation_(NULL)
+    PickupManager::PickupManager() : guiLoaded_(false), pickupHighestIndex_(0), defaultRepresentation_(nullptr)
     {
         RegisterObject(PickupManager);
@@ -85,5 +85,5 @@
     {
         // Destroying the default representation.
-        if(this->defaultRepresentation_ != NULL)
+        if(this->defaultRepresentation_ != nullptr)
             this->defaultRepresentation_->destroy();
 
@@ -91,6 +91,6 @@
 
         // Destroying all the PickupInventoryContainers that are still there.
-        for(std::map<uint32_t, PickupInventoryContainer*>::iterator it = this->pickupInventoryContainers_.begin(); it != this->pickupInventoryContainers_.end(); it++)
-            delete it->second;
+        for(const auto& mapEntry : this->pickupInventoryContainers_)
+            delete mapEntry.second;
         this->pickupInventoryContainers_.clear();
 
@@ -184,16 +184,16 @@
         CollectiblePickup* collectible = orxonox_cast<CollectiblePickup*>(pickup);
         // If the Pickupable is part of a PickupCollection it isn't displayed in the PickupInventory, just the PickupCollection is.
-        if(collectible != NULL && collectible->isInCollection())
+        if(collectible != nullptr && collectible->isInCollection())
             return;
 
         // Getting clientId of the host this change of the pickup's used status concerns.
         PickupCarrier* carrier = pickup->getCarrier();
-        while(carrier->getCarrierParent() != NULL)
+        while(carrier->getCarrierParent() != nullptr)
             carrier = carrier->getCarrierParent();
         Pawn* pawn = orxonox_cast<Pawn*>(carrier);
-        if(pawn == NULL)
+        if(pawn == nullptr)
             return;
         PlayerInfo* info = pawn->getPlayer();
-        if(info == NULL)
+        if(info == nullptr)
             return;
         unsigned int clientId = info->getClientID();
@@ -265,16 +265,16 @@
         CollectiblePickup* collectible = orxonox_cast<CollectiblePickup*>(pickup);
         // If the Pickupable is part of a PickupCollection it isn't displayed in the PickupInventory, just the PickupCollection is.
-        if(collectible != NULL && collectible->isInCollection())
+        if(collectible != nullptr && collectible->isInCollection())
             return;
 
         // Getting clientId of the host this change of the pickup's pickedUp status concerns.
         PickupCarrier* carrier = pickup->getCarrier();
-        while(carrier->getCarrierParent() != NULL)
+        while(carrier->getCarrierParent() != nullptr)
             carrier = carrier->getCarrierParent();
         Pawn* pawn = orxonox_cast<Pawn*>(carrier);
-        if(pawn == NULL)
+        if(pawn == nullptr)
             return;
         PlayerInfo* info = pawn->getFormerPlayer();
-        if(info == NULL)
+        if(info == nullptr)
             return;
         unsigned int clientId = info->getClientID();
@@ -399,5 +399,5 @@
                 return;
             Pickupable* pickupable = this->pickups_.find(pickup)->second;
-            if(pickupable != NULL)
+            if(pickupable != nullptr)
                 pickupable->drop();
         }
@@ -442,5 +442,5 @@
                 return;
             Pickupable* pickupable = this->pickups_.find(pickup)->second;
-            if(pickupable != NULL)
+            if(pickupable != nullptr)
                 pickupable->setUsed(use);
         }
Index: code/trunk/src/modules/pickup/PickupManager.h
===================================================================
--- code/trunk/src/modules/pickup/PickupManager.h	(revision 11052)
+++ code/trunk/src/modules/pickup/PickupManager.h	(revision 11071)
@@ -117,7 +117,7 @@
             PickupRepresentation* getRepresentation(const std::string& name); // tolua_export
 
-            virtual void pickupChangedUsed(Pickupable* pickup, bool used); //!< Is called by the PickupListener to notify the PickupManager, that the input Pickupable has transited to the input used state.
+            virtual void pickupChangedUsed(Pickupable* pickup, bool used) override; //!< Is called by the PickupListener to notify the PickupManager, that the input Pickupable has transited to the input used state.
             static void pickupChangedUsedNetwork(uint32_t pickup, bool inUse, bool usable, bool unusable); //!< Helper method to react to the change in the used status of a Pickupable.
-            virtual void pickupChangedPickedUp(Pickupable* pickup, bool pickedUp); //!< Is called by the PickupListener to notify the PickupManager, that the input Pickupable has transited to the input pickedUp state.
+            virtual void pickupChangedPickedUp(Pickupable* pickup, bool pickedUp) override; //!< Is called by the PickupListener to notify the PickupManager, that the input Pickupable has transited to the input pickedUp state.
             static void pickupChangedPickedUpNetwork(uint32_t pickup, bool usable, uint32_t representationObjectId, const std::string& representationName, bool pickedUp); //!< Helper method to react to the change in the pickedUp status of a Pickupable.
 
@@ -161,5 +161,5 @@
             std::map<uint32_t, PickupInventoryContainer*>::iterator pickupsIterator_; //!< An iterator pointing to the current Pickupable in pickupsList_.
 
-            std::map<uint32_t, WeakPtr<Pickupable> > pickups_; //!< Map linking a number identifying a Pickupable to a weak pointer of a Pickupable.
+            std::map<uint32_t, WeakPtr<Pickupable>> pickups_; //!< Map linking a number identifying a Pickupable to a weak pointer of a Pickupable.
             std::map<Pickupable*, uint32_t> indexes_;//!< Map linking Pickupable to the number identifying it.
 
Index: code/trunk/src/modules/pickup/PickupRepresentation.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupRepresentation.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/PickupRepresentation.cc	(revision 11071)
@@ -52,5 +52,5 @@
         This is primarily for use of the PickupManager in creating a default PickupRepresentation.
     */
-    PickupRepresentation::PickupRepresentation() : BaseObject(NULL), Synchronisable(NULL), spawnerRepresentation_(NULL)
+    PickupRepresentation::PickupRepresentation() : BaseObject(nullptr), Synchronisable(nullptr), spawnerRepresentation_(nullptr)
     {
         RegisterObject(PickupRepresentation);
@@ -64,5 +64,5 @@
         Default Constructor. Registers the object and initializes its member variables.
     */
-    PickupRepresentation::PickupRepresentation(Context* context) : BaseObject(context), Synchronisable(context), spawnerRepresentation_(NULL)
+    PickupRepresentation::PickupRepresentation(Context* context) : BaseObject(context), Synchronisable(context), spawnerRepresentation_(nullptr)
     {
         RegisterObject(PickupRepresentation);
@@ -78,5 +78,5 @@
     PickupRepresentation::~PickupRepresentation()
     {
-        if(this->spawnerRepresentation_ != NULL)
+        if(this->spawnerRepresentation_ != nullptr)
             this->spawnerRepresentation_->destroy();
 
@@ -135,5 +135,5 @@
     StaticEntity* PickupRepresentation::createSpawnerRepresentation(PickupSpawner* spawner)
     {
-        if(this->spawnerRepresentation_ == NULL)
+        if(this->spawnerRepresentation_ == nullptr)
         {
             orxout(verbose, context::pickups) << "PickupRepresentation: No spawner representation found." << endl;
@@ -149,5 +149,5 @@
         this->spawnerRepresentation_->setVisible(true);
         StaticEntity* temp = this->spawnerRepresentation_;
-        this->spawnerRepresentation_ = NULL;
+        this->spawnerRepresentation_ = nullptr;
 
         return temp;
@@ -164,5 +164,5 @@
     {
         this->spawnerRepresentation_ = representation;
-        if(this->spawnerRepresentation_ != NULL)
+        if(this->spawnerRepresentation_ != nullptr)
             this->spawnerRepresentation_->setVisible(false);
     }
Index: code/trunk/src/modules/pickup/PickupRepresentation.h
===================================================================
--- code/trunk/src/modules/pickup/PickupRepresentation.h	(revision 11052)
+++ code/trunk/src/modules/pickup/PickupRepresentation.h	(revision 11071)
@@ -98,5 +98,5 @@
             virtual ~PickupRepresentation(); //!< Destructor.
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a PickupRepresentation object through XML.
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override; //!< Method for creating a PickupRepresentation object through XML.
 
             /**
@@ -119,8 +119,8 @@
             @brief Get the StaticEntity that defines how the PickupSpawner of the Pickupable represented by this PickupRepresentation looks like.
             @param index The index.
-            @return Returns (for index = 0) a pointer to the StaticEntity. For index > 0 it returns NULL.
+            @return Returns (for index = 0) a pointer to the StaticEntity. For index > 0 it returns nullptr.
             */
             inline const StaticEntity* getSpawnerRepresentationIndex(unsigned int index) const
-                { if(index == 0) return this->spawnerRepresentation_; return NULL; }
+                { if(index == 0) return this->spawnerRepresentation_; return nullptr; }
             /**
             @brief Get the name of the image representing the pickup in the PickupInventory.
@@ -129,5 +129,5 @@
             inline const std::string& getInventoryRepresentation(void) const { return this->inventoryRepresentation_; } // tolua_export
 
-            virtual void changedName();
+            virtual void changedName() override;
 
             StaticEntity* createSpawnerRepresentation(PickupSpawner* spawner); //!< Create a spawnerRepresentation for a specific PickupSpawner.
Index: code/trunk/src/modules/pickup/PickupSpawner.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupSpawner.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/PickupSpawner.cc	(revision 11071)
@@ -55,5 +55,5 @@
         Pointer to the object which created this item.
     */
-    PickupSpawner::PickupSpawner(Context* context) : StaticEntity(context), pickup_(NULL), representation_(NULL), pickupTemplate_(NULL)
+    PickupSpawner::PickupSpawner(Context* context) : StaticEntity(context), pickup_(nullptr), representation_(nullptr), pickupTemplate_(nullptr)
     {
         RegisterObject(PickupSpawner);
@@ -74,5 +74,5 @@
         this->selfDestruct_ = false;
 
-        this->setPickupable(NULL);
+        this->setPickupable(nullptr);
     }
 
@@ -83,5 +83,5 @@
     PickupSpawner::~PickupSpawner()
     {
-        if(this->isInitialized() && this->selfDestruct_ && this->pickup_ != NULL)
+        if(this->isInitialized() && this->selfDestruct_ && this->pickup_ != nullptr)
             this->pickup_->destroy();
     }
@@ -158,16 +158,16 @@
 
             // Iterate trough all Pawns.
-            for(ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+            for(Pawn* pawn : ObjectList<Pawn>())
             {
-                if(spawner == NULL) // Stop if the PickupSpawner has been deleted (e.g. because it has run out of pickups to distribute).
+                if(spawner == nullptr) // Stop if the PickupSpawner has been deleted (e.g. because it has run out of pickups to distribute).
                     break;
 
-                Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
-                PickupCarrier* carrier = static_cast<PickupCarrier*>(*it);
+                Vector3 distance = pawn->getWorldPosition() - this->getWorldPosition();
+                PickupCarrier* carrier = static_cast<PickupCarrier*>(pawn);
                 // If a PickupCarrier, that fits the target-range of the Pickupable spawned by this PickupSpawner, is in trigger-distance and the carrier is not blocked.
-                if(distance.length() < this->triggerDistance_ && carrier != NULL && this->blocked_.find(carrier) == this->blocked_.end())
+                if(distance.length() < this->triggerDistance_ && carrier != nullptr && this->blocked_.find(carrier) == this->blocked_.end())
                 {
                     if(carrier->isTarget(this->pickup_))
-                        this->trigger(*it);
+                        this->trigger(pawn);
                 }
             }
@@ -195,5 +195,5 @@
         pickedUp = false; // To avoid compiler warning.
 
-        this->setPickupable(NULL);
+        this->setPickupable(nullptr);
         this->decrementSpawnsRemaining();
     }
@@ -282,11 +282,11 @@
         {
             orxout(internal_error, context::pickups) << "Massive Error: PickupSpawner still alive until having spawned last item." << endl;
-            return NULL;
-        }
-
-        if (this->pickupTemplate_ != NULL)
+            return nullptr;
+        }
+
+        if (this->pickupTemplate_ != nullptr)
         {
             Identifier* identifier = this->pickupTemplate_->getBaseclassIdentifier();
-            if (identifier != NULL)
+            if (identifier != nullptr)
             {
                 Pickupable* pickup = orxonox_cast<Pickupable*>(identifier->fabricate(this->getContext()));
@@ -298,5 +298,5 @@
         }
 
-        return NULL;
+        return nullptr;
     }
 
@@ -309,13 +309,13 @@
     void PickupSpawner::setPickupable(Pickupable* pickup)
     {
-        if (this->representation_ != NULL)
+        if (this->representation_ != nullptr)
         {
             this->representation_->destroy();
-            this->representation_ = NULL;
-        }
-
-        if (pickup != NULL)
-        {
-            if (this->pickup_ != NULL)
+            this->representation_ = nullptr;
+        }
+
+        if (pickup != nullptr)
+        {
+            if (this->pickup_ != nullptr)
                 this->pickup_->destroy();
 
Index: code/trunk/src/modules/pickup/PickupSpawner.h
===================================================================
--- code/trunk/src/modules/pickup/PickupSpawner.h	(revision 11052)
+++ code/trunk/src/modules/pickup/PickupSpawner.h	(revision 11071)
@@ -82,6 +82,6 @@
             static PickupSpawner* createDroppedPickup(Context* context, Pickupable* pickup, PickupCarrier* carrier, float triggerDistance = 10.0);
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);  //!< Method for creating a PickupSpawner through XML.
-            virtual void tick(float dt); //!< Tick, checks if any Pawn is close enough to trigger.
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;  //!< Method for creating a PickupSpawner through XML.
+            virtual void tick(float dt) override; //!< Tick, checks if any Pawn is close enough to trigger.
 
             /**
Index: code/trunk/src/modules/pickup/items/BoostPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/BoostPickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/items/BoostPickup.cc	(revision 11071)
@@ -106,5 +106,5 @@
 
         SpaceShip* ship = this->carrierToSpaceShipHelper();
-        if(ship == NULL) // If the PickupCarrier is no SpaceShip, then this pickup is useless and therefore is destroyed.
+        if(ship == nullptr) // If the PickupCarrier is no SpaceShip, then this pickup is useless and therefore is destroyed.
             this->Pickupable::destroy();
 
@@ -128,5 +128,5 @@
         Helper to transform the PickupCarrier to a SpaceShip, and throw an error message if the conversion fails.
     @return
-        A pointer to the SpaceShip, or NULL if the conversion failed.
+        A pointer to the SpaceShip, or nullptr if the conversion failed.
     */
     SpaceShip* BoostPickup::carrierToSpaceShipHelper(void)
@@ -135,5 +135,5 @@
         SpaceShip* ship = orxonox_cast<SpaceShip*>(carrier);
 
-        if(ship == NULL)
+        if(ship == nullptr)
         {
             orxout(internal_error, context::pickups) << "Invalid PickupCarrier in BoostPickup." << endl;
Index: code/trunk/src/modules/pickup/items/BoostPickup.h
===================================================================
--- code/trunk/src/modules/pickup/items/BoostPickup.h	(revision 11052)
+++ code/trunk/src/modules/pickup/items/BoostPickup.h	(revision 11071)
@@ -52,7 +52,7 @@
             virtual ~BoostPickup(); //!< Destructor.
 
-            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a BoostPickup object through XML.
+            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode) override; //!< Method for creating a BoostPickup object through XML.
 
-            virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
+            virtual void changedUsed(void) override; //!< Is called when the pickup has transited from used to unused or the other way around.
             inline float getBoostRefill()
                 { return this->boostRefill_; }
Index: code/trunk/src/modules/pickup/items/DamageBoostPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/DamageBoostPickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/items/DamageBoostPickup.cc	(revision 11071)
@@ -106,5 +106,5 @@
 
         SpaceShip* ship = this->carrierToSpaceShipHelper();
-        if(ship == NULL) // If the PickupCarrier is no SpaceShip, then this pickup is useless and therefore is destroyed.
+        if(ship == nullptr) // If the PickupCarrier is no SpaceShip, then this pickup is useless and therefore is destroyed.
             this->Pickupable::destroy();
 
@@ -152,5 +152,5 @@
         Helper to transform the PickupCarrier to a SpaceShip, and throw an error message if the conversion fails.
     @return
-        A pointer to the SpaceShip, or NULL if the conversion failed.
+        A pointer to the SpaceShip, or nullptr if the conversion failed.
     */
     SpaceShip* DamageBoostPickup::carrierToSpaceShipHelper(void)
@@ -159,5 +159,5 @@
         SpaceShip* ship = orxonox_cast<SpaceShip*>(carrier);
 
-        if(ship == NULL)
+        if(ship == nullptr)
         {
             orxout(internal_error, context::pickups) << "Invalid PickupCarrier in DamageBoostPickup." << endl;
Index: code/trunk/src/modules/pickup/items/DronePickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/DronePickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/items/DronePickup.cc	(revision 11071)
@@ -74,5 +74,5 @@
     {
         this->addTarget(ClassIdentifier<Pawn>::getIdentifier());
-        this->setDurationType(pickupDurationType::once);
+        this->setDurationType(PickupDurationType::once);
         this->droneTemplate_ = "";
     }
@@ -122,5 +122,5 @@
 
                 Pawn* pawn = this->carrierToPawnHelper();
-                if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
                     this->Pickupable::destroy();
 
@@ -131,5 +131,5 @@
                 Controller* controller = drone->getController();
                 DroneController* droneController = orxonox_cast<DroneController*>(controller);
-                if(droneController != NULL)
+                if(droneController != nullptr)
                 {
                     droneController->setOwner(pawn);
@@ -156,5 +156,5 @@
         Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
     @return
-        A pointer to the Pawn, or NULL if the conversion failed.
+        A pointer to the Pawn, or nullptr if the conversion failed.
     */
     Pawn* DronePickup::carrierToPawnHelper(void)
@@ -163,5 +163,5 @@
         Pawn* pawn = orxonox_cast<Pawn*>(carrier);
 
-        if(pawn == NULL)
+        if(pawn == nullptr)
         {
             orxout(internal_error, context::pickups) << "Invalid PickupCarrier in DronePickup." << endl;
Index: code/trunk/src/modules/pickup/items/HealthPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/HealthPickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/items/HealthPickup.cc	(revision 11071)
@@ -77,5 +77,5 @@
         this->health_ = 0.0f;
         this->healthRate_ = 0.0f;
-        this->healthType_ = pickupHealthType::limited;
+        this->healthType_ = PickupHealthType::limited;
         this->maxHealthSave_ = 0.0f;
         this->maxHealthOverwrite_ = 0.0f;
@@ -114,5 +114,5 @@
         {
             Pawn* pawn = this->carrierToPawnHelper();
-            if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+            if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
                 this->Pickupable::destroy();
 
@@ -127,11 +127,11 @@
             switch(this->getHealthType())
             {
-                case pickupHealthType::permanent:
+                case PickupHealthType::permanent:
                     if(pawn->getMaxHealth() < fullHealth)
                         pawn->setMaxHealth(fullHealth);
-                case pickupHealthType::limited:
+                case PickupHealthType::limited:
                     pawn->addHealth(health);
                     break;
-                case pickupHealthType::temporary:
+                case PickupHealthType::temporary:
                     if(pawn->getMaxHealth() > fullHealth)
                     {
@@ -168,5 +168,5 @@
             {
                 Pawn* pawn = this->carrierToPawnHelper();
-                if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
                     this->Pickupable::destroy();
 
@@ -174,12 +174,12 @@
                 switch(this->getHealthType())
                 {
-                    case pickupHealthType::permanent:
+                    case PickupHealthType::permanent:
                         health = pawn->getHealth()+this->getHealth();
                         if(pawn->getMaxHealth() < health)
                             pawn->setMaxHealth(health);
-                    case pickupHealthType::limited:
+                    case PickupHealthType::limited:
                         pawn->addHealth(this->getHealth());
                         break;
-                    case pickupHealthType::temporary:
+                    case PickupHealthType::temporary:
                         health = pawn->getHealth()+this->getHealth();
                         if(pawn->getMaxHealth() < health)
@@ -201,10 +201,10 @@
         else
         {
-            if(this->getHealthType() == pickupHealthType::temporary)
+            if(this->getHealthType() == PickupHealthType::temporary)
             {
                 PickupCarrier* carrier = this->getCarrier();
                 Pawn* pawn = orxonox_cast<Pawn*>(carrier);
 
-                if(pawn == NULL)
+                if(pawn == nullptr)
                 {
                     orxout(internal_error, context::pickups) << "Something went horribly wrong in Health Pickup. PickupCarrier is '" << carrier->getIdentifier()->getName() << "' instead of Pawn." << endl;
@@ -233,5 +233,5 @@
         Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
     @return
-        A pointer to the Pawn, or NULL if the conversion failed.
+        A pointer to the Pawn, or nullptr if the conversion failed.
     */
     Pawn* HealthPickup::carrierToPawnHelper(void)
@@ -240,5 +240,5 @@
         Pawn* pawn = orxonox_cast<Pawn*>(carrier);
 
-        if(pawn == NULL)
+        if(pawn == nullptr)
             orxout(internal_error, context::pickups) << "Invalid PickupCarrier in HealthPickup." << endl;
 
@@ -256,9 +256,9 @@
         switch(this->getHealthType())
         {
-            case pickupHealthType::limited:
+            case PickupHealthType::limited:
                 return HealthPickup::healthTypeLimited_s;
-            case pickupHealthType::temporary:
+            case PickupHealthType::temporary:
                 return HealthPickup::healthTypeTemporary_s;
-            case pickupHealthType::permanent:
+            case PickupHealthType::permanent:
                 return HealthPickup::healthTypePermanent_s;
             default:
@@ -308,9 +308,9 @@
     {
         if(type == HealthPickup::healthTypeLimited_s)
-            this->setHealthType(pickupHealthType::limited);
+            this->setHealthType(PickupHealthType::limited);
         else if(type == HealthPickup::healthTypeTemporary_s)
-            this->setHealthType(pickupHealthType::temporary);
+            this->setHealthType(PickupHealthType::temporary);
         else if(type == HealthPickup::healthTypePermanent_s)
-            this->setHealthType(pickupHealthType::permanent);
+            this->setHealthType(PickupHealthType::permanent);
         else
             orxout(internal_error, context::pickups) << "Invalid healthType '" << type << "' in HealthPickup." << endl;
Index: code/trunk/src/modules/pickup/items/HealthPickup.h
===================================================================
--- code/trunk/src/modules/pickup/items/HealthPickup.h	(revision 11052)
+++ code/trunk/src/modules/pickup/items/HealthPickup.h	(revision 11071)
@@ -51,13 +51,10 @@
     @ingroup PickupItems
     */
-    namespace pickupHealthType
+    enum class PickupHealthType
     {
-        enum Value
-        {
-            limited, //!< Means that the @ref orxonox::HealthPickup "HealthPickup" only increases the users health to its maximum health.
-            temporary, //!< Means that the @ref orxonox::HealthPickup "HealthPickup" temporarily increases the users health even above its maximum health, but only as long as it is in use.
-            permanent //!< Means that the @ref orxonox::HealthPickup "HealthPickup" increases the users health even above its maximum health and increases the maximum health permanently such that it matches the new health.
-        };
-    }
+        limited, //!< Means that the @ref orxonox::HealthPickup "HealthPickup" only increases the users health to its maximum health.
+        temporary, //!< Means that the @ref orxonox::HealthPickup "HealthPickup" temporarily increases the users health even above its maximum health, but only as long as it is in use.
+        permanent //!< Means that the @ref orxonox::HealthPickup "HealthPickup" increases the users health even above its maximum health and increases the maximum health permanently such that it matches the new health.
+    };
 
     /**
@@ -115,5 +112,5 @@
             @return Returns the health type as an enum.
             */
-            inline pickupHealthType::Value getHealthType(void) const
+            inline PickupHealthType getHealthType(void) const
                 { return this->healthType_; }
             const std::string& getHealthTypeAsString(void) const; //!< Get the health type of this pickup.
@@ -127,5 +124,5 @@
             @param type The type of this pickup as an enum.
             */
-            inline void setHealthType(pickupHealthType::Value type)
+            inline void setHealthType(PickupHealthType type)
                 { this->healthType_ = type; }
             void setHealthTypeAsString(const std::string& type); //!< Set the type of the HealthPickup.
@@ -139,5 +136,5 @@
             float maxHealthSave_; //!< Helper to remember what the actual maxHealth of the Pawn was before we changed it.
             float maxHealthOverwrite_; //!< Helper to remember with which value we overwrote the maxHealh, to detect if someone else changed it as well.
-            pickupHealthType::Value healthType_; //!< The type of the HealthPickup.
+            PickupHealthType healthType_; //!< The type of the HealthPickup.
 
             //! Strings for the health types.
Index: code/trunk/src/modules/pickup/items/InvisiblePickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/InvisiblePickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/items/InvisiblePickup.cc	(revision 11071)
@@ -139,5 +139,5 @@
     {
         Pawn* pawn = this->carrierToPawnHelper();
-        if(pawn == NULL)
+        if(pawn == nullptr)
             return false;
 
@@ -163,5 +163,5 @@
         Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
     @return
-        A pointer to the Pawn, or NULL if the conversion failed.
+        A pointer to the Pawn, or nullptr if the conversion failed.
     */
     Pawn* InvisiblePickup::carrierToPawnHelper(void)
@@ -170,5 +170,5 @@
         Pawn* pawn = orxonox_cast<Pawn*>(carrier);
 
-        if(pawn == NULL)
+        if(pawn == nullptr)
         {
             orxout(internal_error, context::pickups) << "Invalid PickupCarrier in InvisiblePickup." << endl;
Index: code/trunk/src/modules/pickup/items/MetaPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/MetaPickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/items/MetaPickup.cc	(revision 11071)
@@ -79,6 +79,6 @@
         this->addTarget(ClassIdentifier<PickupCarrier>::getIdentifier());
 
-        this->setDurationType(pickupDurationType::once);
-        this->metaType_ = pickupMetaType::none;
+        this->setDurationType(PickupDurationType::once);
+        this->metaType_ = PickupMetaType::none;
     }
 
@@ -104,11 +104,11 @@
 
         // If the MetaPickup transited to used, and the metaType is not none.
-        if(this->isUsed() && this->metaType_ != pickupMetaType::none)
+        if(this->isUsed() && this->metaType_ != PickupMetaType::none)
         {
             PickupCarrier* carrier = this->getCarrier();
-            if(this->getMetaType() != pickupMetaType::none && carrier != NULL)
+            if(this->getMetaType() != PickupMetaType::none && carrier != nullptr)
             {
                 // If the metaType is destroyCarrier, then the PickupCarrier is destroyed.
-                if(this->getMetaType() == pickupMetaType::destroyCarrier)
+                if(this->getMetaType() == PickupMetaType::destroyCarrier)
                 {
                     Pawn* pawn = orxonox_cast<Pawn*>(carrier);
@@ -118,22 +118,21 @@
                 std::set<Pickupable*> pickups = carrier->getPickups();
                 // Iterate over all Pickupables of the PickupCarrier.
-                for(std::set<Pickupable*>::iterator it = pickups.begin(); it != pickups.end(); it++)
+                for(Pickupable* pickup : pickups)
                 {
-                    Pickupable* pickup = (*it);
-                    if(pickup == NULL || pickup == this)
+                    if(pickup == nullptr || pickup == this)
                         continue;
 
                     // If the metaType is use, then the Pickupable is set to used.
-                    if(this->getMetaType() == pickupMetaType::use && !pickup->isUsed())
+                    if(this->getMetaType() == PickupMetaType::use && !pickup->isUsed())
                     {
                         pickup->setUsed(true);
                     }
                     // If the metaType is drop, then the Pickupable is dropped.
-                    else if(this->getMetaType() == pickupMetaType::drop)
+                    else if(this->getMetaType() == PickupMetaType::drop)
                     {
                         pickup->drop();
                     }
                     // If the metaType is destroy, then the Pickupable is destroyed.
-                    else if(this->getMetaType() == pickupMetaType::destroy)
+                    else if(this->getMetaType() == PickupMetaType::destroy)
                     {
                         pickup->Pickupable::destroy();
@@ -155,13 +154,13 @@
         switch(this->getMetaType())
         {
-            case pickupMetaType::none:
+            case PickupMetaType::none:
                 return MetaPickup::metaTypeNone_s;
-            case pickupMetaType::use:
+            case PickupMetaType::use:
                 return MetaPickup::metaTypeUse_s;
-            case pickupMetaType::drop:
+            case PickupMetaType::drop:
                 return MetaPickup::metaTypeDrop_s;
-            case pickupMetaType::destroy:
+            case PickupMetaType::destroy:
                 return MetaPickup::metaTypeDestroy_s;
-            case pickupMetaType::destroyCarrier:
+            case PickupMetaType::destroyCarrier:
                 return MetaPickup::metaTypeDestroyCarrier_s;
             default:
@@ -180,21 +179,21 @@
         if(type == MetaPickup::metaTypeNone_s)
         {
-            this->setMetaType(pickupMetaType::none);
+            this->setMetaType(PickupMetaType::none);
         }
         else if(type == MetaPickup::metaTypeUse_s)
         {
-            this->setMetaType(pickupMetaType::use);
+            this->setMetaType(PickupMetaType::use);
         }
         else if(type == MetaPickup::metaTypeDrop_s)
         {
-            this->setMetaType(pickupMetaType::drop);
+            this->setMetaType(PickupMetaType::drop);
         }
         else if(type == MetaPickup::metaTypeDestroy_s)
         {
-            this->setMetaType(pickupMetaType::destroy);
+            this->setMetaType(PickupMetaType::destroy);
         }
         else if(type == MetaPickup::metaTypeDestroyCarrier_s)
         {
-            this->setMetaType(pickupMetaType::destroyCarrier);
+            this->setMetaType(PickupMetaType::destroyCarrier);
         }
         else
Index: code/trunk/src/modules/pickup/items/MetaPickup.h
===================================================================
--- code/trunk/src/modules/pickup/items/MetaPickup.h	(revision 11052)
+++ code/trunk/src/modules/pickup/items/MetaPickup.h	(revision 11071)
@@ -48,15 +48,12 @@
     @ingroup PickupItems
     */
-    namespace pickupMetaType
+    enum class PickupMetaType
     {
-        enum Value
-        {
-            none, //!< The @ref orxonox::MetaPickup "MetaPickup" does nothing.
-            use, //!< The @ref orxonox::MetaPickup "MetaPickup" uses all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
-            drop, //!< The @ref orxonox::MetaPickup "MetaPickup" drops all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
-            destroy, //!< The @ref orxonox::MetaPickup "MetaPickup" destroys all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
-            destroyCarrier //!< The @ref orxonox::MetaPickup "MetaPickup" destroys the @ref orxonox::PickupCarrier "PickupCarrier".
-        };
-    }
+        none, //!< The @ref orxonox::MetaPickup "MetaPickup" does nothing.
+        use, //!< The @ref orxonox::MetaPickup "MetaPickup" uses all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
+        drop, //!< The @ref orxonox::MetaPickup "MetaPickup" drops all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
+        destroy, //!< The @ref orxonox::MetaPickup "MetaPickup" destroys all the @ref orxonox::PickupCarrier "PickupCarriers'" @ref orxonox::Pickupable "Pickupables".
+        destroyCarrier //!< The @ref orxonox::MetaPickup "MetaPickup" destroys the @ref orxonox::PickupCarrier "PickupCarrier".
+    };
 
     /**
@@ -100,5 +97,5 @@
             @return Returns an enum with the meta type of the MetaPickup.
             */
-            inline pickupMetaType::Value getMetaType(void) const
+            inline PickupMetaType getMetaType(void) const
                 { return this->metaType_; }
             const std::string& getMetaTypeAsString(void) const; //!< Get the meta type of this MetaPickup.
@@ -109,5 +106,5 @@
             @param type The meta type as an enum.
             */
-            inline void setMetaType(pickupMetaType::Value type)
+            inline void setMetaType(PickupMetaType type)
                 { this->metaType_ =  type; }
             void setMetaTypeAsString(const std::string& type); //!< Set the meta type of this MetaPickup.
@@ -116,5 +113,5 @@
             void initialize(void); //!< Initializes the member variables.
 
-            pickupMetaType::Value metaType_; //!< The meta type of the MetaPickup, determines which actions are taken.
+            PickupMetaType metaType_; //!< The meta type of the MetaPickup, determines which actions are taken.
 
             //! Static strings for the meta types.
Index: code/trunk/src/modules/pickup/items/MunitionContainer.h
===================================================================
--- code/trunk/src/modules/pickup/items/MunitionContainer.h	(revision 11052)
+++ code/trunk/src/modules/pickup/items/MunitionContainer.h	(revision 11071)
@@ -53,5 +53,5 @@
             virtual ~MunitionContainer();
 
-            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode) override;
 
             inline const std::string& getMunitionName() const
Index: code/trunk/src/modules/pickup/items/MunitionPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/MunitionPickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/items/MunitionPickup.cc	(revision 11071)
@@ -86,5 +86,5 @@
     void MunitionPickup::addMunitionContainer(MunitionContainer* munitionContainer)
     {
-        OrxAssert(munitionContainer != NULL, "The munitionContainer cannot be NULL.");
+        OrxAssert(munitionContainer != nullptr, "The munitionContainer cannot be nullptr.");
         this->munitionContainers_.push_back(munitionContainer);
     }
@@ -93,5 +93,5 @@
     {
         if(this->munitionContainers_.size() >= index)
-            return NULL;
+            return nullptr;
         else
             return this->munitionContainers_[index];
@@ -108,5 +108,5 @@
         Pawn* pawn = this->carrierToPawnHelper();
 
-        if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+        if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
             this->Pickupable::destroy();
 
@@ -114,16 +114,16 @@
         if(this->isUsed())
         {
-            for(std::vector<MunitionContainer*>::iterator it = this->munitionContainers_.begin(); it != this->munitionContainers_.end(); ++it)
+            for(MunitionContainer* container : this->munitionContainers_)
             {
                 //Get pointer to the appropriate munition
-                SubclassIdentifier<Munition> identifier = (*it)->getMunitionType();
+                SubclassIdentifier<Munition> identifier = container->getMunitionType();
                 Munition* munition = pawn->getMunition(&identifier);
                 if (munition)
                 {
                     // Add munition and magzines
-                    munition->addMunition((*it)->getMunitionAmount());
-                    munition->addMagazines((*it)->getMagazinesAmount());
+                    munition->addMunition(container->getMunitionAmount());
+                    munition->addMagazines(container->getMagazinesAmount());
                 }
-                (*it)->destroy();
+                container->destroy();
             }
             // This will destroy the pickp
@@ -140,5 +140,5 @@
         Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
     @return
-        A pointer to the Pawn, or NULL if the conversion failed.
+        A pointer to the Pawn, or nullptr if the conversion failed.
     */
     Pawn* MunitionPickup::carrierToPawnHelper(void)
@@ -147,5 +147,5 @@
         Pawn* pawn = orxonox_cast<Pawn*>(carrier);
 
-        if(pawn == NULL)
+        if(pawn == nullptr)
         {
             orxout(internal_error, context::pickups) << "Invalid PickupCarrier in MunitionPickup." << endl;
Index: code/trunk/src/modules/pickup/items/MunitionPickup.h
===================================================================
--- code/trunk/src/modules/pickup/items/MunitionPickup.h	(revision 11052)
+++ code/trunk/src/modules/pickup/items/MunitionPickup.h	(revision 11071)
@@ -59,9 +59,9 @@
             virtual ~MunitionPickup(); //!< Destructor.
 
-            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a MunitionPickup object through XML.
+            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode) override; //!< Method for creating a MunitionPickup object through XML.
 
-            virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
+            virtual void changedUsed(void) override; //!< Is called when the pickup has transited from used to unused or the other way around.
 
-            virtual void addMunitionContainer(MunitionContainer* munitionContainer);
+            void addMunitionContainer(MunitionContainer* munitionContainer);
             MunitionContainer* getMunitionContainer(unsigned int index);
 
Index: code/trunk/src/modules/pickup/items/ShieldPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/ShieldPickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/items/ShieldPickup.cc	(revision 11071)
@@ -99,5 +99,5 @@
 
         Pawn* pawn = this->carrierToPawnHelper();
-        if(pawn == NULL)
+        if(pawn == nullptr)
             this->Pickupable::destroy();
 
@@ -143,5 +143,5 @@
     Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
     @return
-    A pointer to the Pawn, or NULL if the conversion failed.
+    A pointer to the Pawn, or nullptr if the conversion failed.
     */
     Pawn* ShieldPickup::carrierToPawnHelper(void)
@@ -150,5 +150,5 @@
         Pawn* pawn = orxonox_cast<Pawn*>(carrier);
 
-        if(pawn == NULL)
+        if(pawn == nullptr)
         {
             orxout(internal_error, context::pickups) << "Invalid PickupCarrier in ShieldPickup." << endl;
Index: code/trunk/src/modules/pickup/items/ShrinkPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/ShrinkPickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/items/ShrinkPickup.cc	(revision 11071)
@@ -146,5 +146,5 @@
         {
             Pawn* pawn = this->carrierToPawnHelper();
-            if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+            if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
             {
                 this->Pickupable::destroy();
@@ -173,5 +173,5 @@
                 //TODO: Deploy particle effect.
                 Pawn* pawn = this->carrierToPawnHelper();
-                if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
                     return;
 
@@ -182,10 +182,10 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
                 {
                     CameraPosition* cameraPos = pawn->getCameraPosition(index);
-                    if(cameraPos == NULL)
+                    if(cameraPos == nullptr)
                         continue;
                     cameraPos->setPosition(cameraPos->getPosition()/factor);
@@ -201,5 +201,5 @@
                 //TODO: Deploy particle effect.
                 Pawn* pawn = this->carrierToPawnHelper();
-                if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
                     return;
 
@@ -208,10 +208,10 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
                 {
                     CameraPosition* cameraPos = pawn->getCameraPosition(index);
-                    if(cameraPos == NULL)
+                    if(cameraPos == nullptr)
                         continue;
                     cameraPos->setPosition(cameraPos->getPosition()/this->shrinkFactor_);
@@ -237,5 +237,5 @@
             {
                 Pawn* pawn = this->carrierToPawnHelper();
-                if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
                 {
                     this->Pickupable::destroy();
@@ -263,10 +263,10 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
                 {
                     CameraPosition* cameraPos = pawn->getCameraPosition(index);
-                    if(cameraPos == NULL)
+                    if(cameraPos == nullptr)
                         continue;
                     cameraPos->setPosition(cameraPos->getPosition()/factor);
@@ -277,5 +277,5 @@
             {
                 Pawn* pawn = this->carrierToPawnHelper();
-                if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
                     this->Pickupable::destroy();
 
@@ -304,10 +304,10 @@
 
                 // Iterate over all camera positions and inversely move the camera to create a shrinking sensation.
-                const std::list< StrongPtr<CameraPosition> >& cameraPositions = pawn->getCameraPositions();
+                const std::list<StrongPtr<CameraPosition>>& cameraPositions = pawn->getCameraPositions();
                 int size = cameraPositions.size();
                 for(int index = 0; index < size; index++)
                 {
                     CameraPosition* cameraPos = pawn->getCameraPosition(index);
-                    if(cameraPos == NULL)
+                    if(cameraPos == nullptr)
                         continue;
                     cameraPos->setPosition(cameraPos->getPosition()/factor);
Index: code/trunk/src/modules/pickup/items/SpeedPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/SpeedPickup.cc	(revision 11052)
+++ code/trunk/src/modules/pickup/items/SpeedPickup.cc	(revision 11071)
@@ -99,5 +99,5 @@
 
         SpaceShip* ship = this->carrierToSpaceShipHelper();
-        if(ship == NULL) // If the PickupCarrier is no SpaceShip, then this pickup is useless and therefore is destroyed.
+        if(ship == nullptr) // If the PickupCarrier is no SpaceShip, then this pickup is useless and therefore is destroyed.
             this->Pickupable::destroy();
 
@@ -143,5 +143,5 @@
         Helper to transform the PickupCarrier to a SpaceShip, and throw an error message if the conversion fails.
     @return
-        A pointer to the SpaceShip, or NULL if the conversion failed.
+        A pointer to the SpaceShip, or nullptr if the conversion failed.
     */
     SpaceShip* SpeedPickup::carrierToSpaceShipHelper(void)
@@ -150,5 +150,5 @@
         SpaceShip* ship = orxonox_cast<SpaceShip*>(carrier);
 
-        if(ship == NULL)
+        if(ship == nullptr)
         {
             orxout(internal_error, context::pickups) << "Invalid PickupCarrier in SpeedPickup." << endl;
