Index: code/trunk/src/orxonox/interfaces/PickupCarrier.cc
===================================================================
--- code/trunk/src/orxonox/interfaces/PickupCarrier.cc	(revision 7504)
+++ code/trunk/src/orxonox/interfaces/PickupCarrier.cc	(revision 7547)
@@ -36,4 +36,5 @@
 #include "core/CoreIncludes.h"
 #include "core/Identifier.h"
+
 #include "Pickupable.h"
 
@@ -89,5 +90,5 @@
         Returns true if the PickupCarrier or one of its children is a target, false if not.
     */
-    bool PickupCarrier::isTarget(const Pickupable* pickup)
+    bool PickupCarrier::isTarget(const Pickupable* pickup) const
     {
         if(pickup->isTarget(this)) // If the PickupCarrier itself is a target.
Index: code/trunk/src/orxonox/interfaces/PickupCarrier.h
===================================================================
--- code/trunk/src/orxonox/interfaces/PickupCarrier.h	(revision 7504)
+++ code/trunk/src/orxonox/interfaces/PickupCarrier.h	(revision 7547)
@@ -64,9 +64,11 @@
         Different PickupCarriers are structured hierarchically, a pickup can be picked up by a PickupCarrier that can't really carry that particular pickup but one of its children (or one of their children) can, and thus it gets "handed down" until it is at the right place.
         But this structure has to be established first.
-        - <b>getCarrierChildren()</b> To this end a PickupCarrier needs to implement getCarrierChildren() which returns a list of its direct PickupCarrier children. If you need an example, have a look at @ref orxonox::Pawn "Pawn" and @ref orxonx::Engine "Engine".
+        - <b>getCarrierChildren()</b> To this end a PickupCarrier needs to implement getCarrierChildren() which returns a list of its direct PickupCarrier children. If you need an example, have a look at @ref orxonox::Pawn "Pawn" and @ref orxonox::Engine "Engine".
         - <b>getCarrierParent()</b> This is the method in the other direction. It returns the parent of this PickupCarrier, or NULL if the PickupCarrier is a root node in this hierarchy.
 
     @author
         Damian 'Mozork' Frick
+
+    @ingroup Pickup
     */
     class _OrxonoxExport PickupCarrier : virtual public OrxonoxClass
@@ -88,5 +90,5 @@
             void preDestroy(void); //!< Is called before the PickupCarrier is effectively destroyed.
 
-            bool isTarget(const Pickupable* pickup); //!< Can be used to check whether the PickupCarrier or a child of his is a target ot the input Pickupable.
+            bool isTarget(const Pickupable* pickup) const; //!< Can be used to check whether the PickupCarrier or a child of his is a target ot the input Pickupable.
             PickupCarrier* getTarget(const Pickupable* pickup); //!< Get the carrier that is both a child of the PickupCarrier (or the PickupCarrier itself) and a target of the input Pickupable.
 
@@ -96,5 +98,5 @@
             @return Returns the position as a Vector3.
             */
-            virtual const Vector3& getCarrierPosition(void) = 0;
+            virtual const Vector3& getCarrierPosition(void) const = 0;
 
         protected:
@@ -105,5 +107,5 @@
             @return Returns a pointer to a list of all direct children.
             */
-            virtual std::vector<PickupCarrier*>* getCarrierChildren(void) = 0;
+            virtual std::vector<PickupCarrier*>* getCarrierChildren(void) const = 0;
             /**
             @brief Get the parent of this PickupSpawner.
@@ -111,5 +113,5 @@
             @return Returns a pointer to the parent.
             */
-            virtual PickupCarrier* getCarrierParent(void) = 0;
+            virtual PickupCarrier* getCarrierParent(void) const = 0;
 
             /**
Index: code/trunk/src/orxonox/interfaces/PickupListener.h
===================================================================
--- code/trunk/src/orxonox/interfaces/PickupListener.h	(revision 7504)
+++ code/trunk/src/orxonox/interfaces/PickupListener.h	(revision 7547)
@@ -48,7 +48,10 @@
         The PickupListener class facilitates the flow of information regarding the picking up, dropping, using and unusing of @ref orxonox::Pickupable "Pickupables" to interested parties (such as the @ref orxonox::PickupManager "PickupManager").
 
-        All you need to to do be notified is to inherit from PickupListener and implement the two methods pickupChangedUsed() and pickupChangedPickedUp().
+        All you need to to do be notified is to inherit from PickupListener and implement the two methods <code>pickupChangedUsed()</code> and <code>pickupChangedPickedUp()</code>.
+
     @author
         Damian 'Mozork' Frick
+
+    @ingroup Pickup
     */
     class _OrxonoxExport PickupListener : virtual public OrxonoxClass
Index: code/trunk/src/orxonox/interfaces/Pickupable.cc
===================================================================
--- code/trunk/src/orxonox/interfaces/Pickupable.cc	(revision 7504)
+++ code/trunk/src/orxonox/interfaces/Pickupable.cc	(revision 7547)
@@ -147,5 +147,5 @@
         Returns true if the given PickupCarrier is a target.
     */
-    bool Pickupable::isTarget(PickupCarrier* carrier) const
+    bool Pickupable::isTarget(const PickupCarrier* carrier) const
     {
         if(carrier == NULL)
@@ -165,5 +165,5 @@
     bool Pickupable::isTarget(const Identifier* identifier) const
     {
-        //! Iterate through all targets of this Pickupable.
+        // Iterate through all targets of this Pickupable.
         for(std::list<Identifier*>::const_iterator it = this->targets_.begin(); it != this->targets_.end(); it++)
         {
@@ -198,5 +198,5 @@
     bool Pickupable::addTarget(Identifier* target)
     {
-        if(this->isTarget(target)) //!< If the input target is already present in the list of targets.
+        if(this->isTarget(target)) // If the input target is already present in the list of targets.
             return false;
 
@@ -216,5 +216,5 @@
     bool Pickupable::pickup(PickupCarrier* carrier)
     {
-        if(carrier == NULL || this->isPickedUp()) //!< If carrier is NULL or the Pickupable is already picked up.
+        if(carrier == NULL || this->isPickedUp()) // If carrier is NULL or the Pickupable is already picked up.
             return false;
 
Index: code/trunk/src/orxonox/interfaces/Pickupable.h
===================================================================
--- code/trunk/src/orxonox/interfaces/Pickupable.h	(revision 7504)
+++ code/trunk/src/orxonox/interfaces/Pickupable.h	(revision 7547)
@@ -51,5 +51,5 @@
         An Interface (or more precisely an abstract class) to model and represent different (all kinds of) pickups.
 
-        Pickups (@ref orxonox:Pickupable "Pickupables") are objects that (quite unsurprisingly) can be picked up. Additionally they can be used and unused (transition from used to not used), and also dropped.
+        Pickups (@ref orxonox::Pickupable "Pickupables") are objects that (quite unsurprisingly) can be picked up. Additionally they can be used and unused (transition from used to not used), and also dropped.
 
         A class of Pickups can incorporate many different types of pickups (see @ref orxonox::PickupIdentifier "PickupIdentifier"), each type is uniquely defined by a @ref orxonox::PickupIdentifier "PickupIdentifier". Each pickup has such an identifier identiying its type. This means that two pickups of the same type have identifiers which are equal.
@@ -57,4 +57,6 @@
     @author
         Damian 'Mozork' Frick
+
+    @ingroup Pickup
     */
     class _OrxonoxExport Pickupable : virtual public OrxonoxClass, public Rewardable
@@ -70,5 +72,5 @@
             @return Returns true if the Pickupable is currently in use.
             */
-            inline bool isUsed(void)
+            inline bool isUsed(void) const
                 { return this->used_; }
             /**
@@ -94,5 +96,5 @@
             @return Returns true if the Pickupable is currently picked up, false if not.
             */
-            inline bool isPickedUp(void)
+            inline bool isPickedUp(void) const
                 { return this->pickedUp_; }
             /**
@@ -106,5 +108,5 @@
             @return Returns true if it can be used.
             */
-            inline bool isUsable(void)
+            inline bool isUsable(void) const
                 { return this->enabled_; }
 
@@ -113,5 +115,5 @@
             @return Returns true if it can be unused.
             */
-            inline bool isUnusable(void)
+            inline bool isUnusable(void) const
                 { return this->enabled_; }
 
@@ -121,5 +123,5 @@
             @return Returns true if the Pickupable is enabled.
             */
-            inline bool isEnabled(void)
+            inline bool isEnabled(void) const
                 { return this->enabled_; }
 
@@ -127,5 +129,5 @@
             bool drop(bool createSpawner = true); //!< Can be called to drop a Pickupable.
 
-            virtual bool isTarget(PickupCarrier* carrier) const; //!< Get whether the given PickupCarrier is a target of this Pickupable.
+            virtual bool isTarget(const PickupCarrier* carrier) const; //!< Get whether the given PickupCarrier is a target of this Pickupable.
             bool isTarget(const Identifier* identifier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this Pickupable.
             bool addTarget(PickupCarrier* target); //!< Add a PickupCarrier as target of this Pickupable.
@@ -139,5 +141,5 @@
             @return Returns a pointer to the PickupIdentifier of this Pickupable.
             */
-            virtual const PickupIdentifier* getPickupIdentifier(void)
+            virtual const PickupIdentifier* getPickupIdentifier(void) const
                 { return this->pickupIdentifier_; }
 
