Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Sep 28, 2010, 5:31:59 PM (14 years ago)
Author:
dafrick
Message:

Some documenting and cleaning up/re-organization in pickups module.

Location:
code/trunk/src/orxonox/interfaces
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

  • code/trunk/src/orxonox/interfaces/CMakeLists.txt

    r6524 r7494  
    22  InterfaceCompilation.cc
    33  Pickupable.cc
     4  PickupCarrier.cc
    45  RadarViewable.cc
    56)

  • code/trunk/src/orxonox/interfaces/InterfaceCompilation.cc

    r7163 r7494  
    3434
    3535#include "GametypeMessageListener.h"
    36 #include "PickupCarrier.h"
    3736#include "PlayerTrigger.h"
    3837#include "RadarListener.h"
    … …  
    5150    {
    5251        RegisterRootObject(GametypeMessageListener);
    53     }
    54 
    55     //----------------------------
    56     // PickupCarrier
    57     //----------------------------
    58     PickupCarrier::PickupCarrier()
    59     {
    60         RegisterRootObject(PickupCarrier);
    61     }
    62 
    63     PickupCarrier::~PickupCarrier()
    64     {
    65 
    66     }
    67 
    68     void PickupCarrier::preDestroy(void)
    69     {
    70         std::set<Pickupable*>::iterator it = this->pickups_.begin();
    71         std::set<Pickupable*>::iterator temp;
    72         while(it != this->pickups_.end())
    73         {
    74             (*it)->carrierDestroyed();
    75             temp = it;
    76             it = this->pickups_.begin();
    77             if(it == temp) // Infinite loop avoidance, in case the pickup wasn't removed from the carrier somewhere in the carrierDestroy() procedure.
    78             {
    79                 COUT(2) << "Oops. In a PickupCarrier, while cleaning up, a Pickupable (&" << (*temp) << ") didn't unregister itself as it should have." << std::endl;;
    80                 it++;
    81             }
    82         }
    83 
    84         this->pickups_.clear();
    8552    }
    8653

  • code/trunk/src/orxonox/interfaces/PickupCarrier.h

    r7456 r7494  
    3838#include "OrxonoxPrereqs.h"
    3939
    40 #include <list>
    4140#include <set>
    42 #include "Pickupable.h"
    43 #include "core/Identifier.h"
    44 #include "core/WeakPtr.h"
     41#include <vector>
    4542
    4643#include "core/OrxonoxClass.h"
    … …  
    4946{
    5047
    51     //! Forward-declarations.
     48    // Forward-declarations.
    5249    class PickupManager;
    5350    class Pickup;
    … …  
    6057    /**
    6158    @brief
    62         The PickupCarrier interface provides the means, for any class implementing it, to possess Pickupables.
     59        The PickupCarrier interface provides the means, for any class implementing it, to possess @ref orxonox::Pickupable "Pickupables".
     60
     61        For a class to use the PickupCarrier interface it must implement the follwing three methods:
     62        - <b>getCarrierPosition()</b> The getCarrierPosition() method returns the absolute position (in space) of the PickupCarrier.
     63
     64        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.
     65        But this structure has to be established first.
     66        - <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".
     67        - <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.
     68
    6369    @author
    6470        Damian 'Mozork' Frick
    … …  
    6672    class _OrxonoxExport PickupCarrier : virtual public OrxonoxClass
    6773    {
    68         //! So that the different Pickupables have full access to their PickupCarrier.
     74        // So that the different Pickupables have full access to their PickupCarrier.
    6975        friend class Pickupable;
    7076        friend class PickupManager;
    71         //! Friends.
     77        // Friends.
    7278        friend class Pickup;
    7379        friend class HealthPickup;
    … …  
    8086            PickupCarrier(); //!< Constructor.
    8187            virtual ~PickupCarrier(); //!< Destructor.
    82             void preDestroy(void);
     88            void preDestroy(void); //!< Is called before the PickupCarrier is effectively destroyed.
    8389
    84             /**
    85             @brief Can be used to check whether the PickupCarrier or a child of his is a target ot the input Pickupable.
    86             @param pickup A pointer to the Pickupable.
    87             @return Returns true if the PickupCarrier or one of its children is a target, false if not.
    88             */
    89             bool isTarget(const Pickupable* pickup)
    90                 {
    91                     if(pickup->isTarget(this)) //!< If the PickupCarrier itself is a target.
    92                         return true;
    93 
    94                     //! Go recursively through all children to check whether they are a target.
    95                     std::vector<PickupCarrier*>* children = this->getCarrierChildren();
    96                     for(std::vector<PickupCarrier*>::const_iterator it = children->begin(); it != children->end(); it++)
    97                     {
    98                         if((*it)->isTarget(pickup))
    99                             return true;
    100                     }
    101 
    102                     children->clear();
    103                     delete children;
    104 
    105                     return false;
    106                 }
    107 
    108             /**
    109             @brief Get the carrier that is both a child of the PickupCarrier (or the PickupCarrier itself) and a target of the input Pickupable.
    110             @param pickup A pounter to the Pickupable.
    111             @return Returns a pointer to the PickupCarrier that is the target of the input Pickupable.
    112             */
    113             PickupCarrier* getTarget(const Pickupable* pickup)
    114                 {
    115                     if(!this->isTarget(pickup))
    116                         return NULL;
    117 
    118                     if(pickup->isTarget(this)) //!< If the PickupCarrier itself is a target.
    119                         return this;
    120 
    121                     //! Go recursively through all children to check whether they are the target.
    122                     std::vector<PickupCarrier*>* children = this->getCarrierChildren();
    123                     for(std::vector<PickupCarrier*>::iterator it = children->begin(); it != children->end(); it++)
    124                     {
    125                         if(pickup->isTarget(*it))
    126                             return *it;
    127                     }
    128 
    129                     children->clear();
    130                     delete children;
    131 
    132                     return NULL;
    133                 }
     90            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.
     91            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.
    13492
    13593            /**
    … …  
    149107            virtual std::vector<PickupCarrier*>* getCarrierChildren(void) = 0;
    150108            /**
    151             @brief Get the parent of this PickupSpawner
     109            @brief Get the parent of this PickupSpawner.
    152110                   This method needs to be implemented by any direct derivative class of PickupCarrier.
    153111            @return Returns a pointer to the parent.
    … …  
    165123            std::set<Pickupable*> pickups_; //!< The list of Pickupables carried by this PickupCarrier.
    166124
    167             /**
    168             @brief Adds a Pickupable to the list of pickups that are carried by this PickupCarrier.
    169             @param pickup A pointer to the pickup to be added.
    170             @return Returns true if successfull, false if the Pickupable was already present.
    171             */
    172             bool addPickup(Pickupable* pickup)
    173                 {
    174                     COUT(4) << "Adding Pickupable (&" << pickup << ") to PickupCarrier (&" << this << ")" << std::endl;
    175                     return this->pickups_.insert(pickup).second;
    176                 }
    177 
    178             /**
    179             @brief Removes a Pickupable from the list of pickups that are carried by thsi PickupCarrier.
    180             @param pickup A pointer to the pickup to be removed.
    181             @return Returns true if successfull, false if the Pickupable was not present in the list.
    182             */
    183             bool removePickup(Pickupable* pickup)
    184                 {
    185                     COUT(4) << "Removing Pickupable (&" << pickup << ") from PickupCarrier (&" << this << ")" << std::endl;
    186                     return this->pickups_.erase(pickup) == 1;
    187                 }
     125            bool addPickup(Pickupable* pickup); //!< Adds a Pickupable to the list of pickups that are carried by this PickupCarrier.
     126            bool removePickup(Pickupable* pickup); //!< Removes a Pickupable from the list of pickups that are carried by this PickupCarrier.
    188127
    189128    };

  • code/trunk/src/orxonox/interfaces/Pickupable.cc

    r7493 r7494  
    3939#include "core/CoreIncludes.h"
    4040#include "util/Convert.h"
     41
    4142#include "infos/PlayerInfo.h"
    4243#include "pickup/PickupIdentifier.h"
    4344#include "worldentities/pawns/Pawn.h"
     45
    4446#include "PickupCarrier.h"
    4547
    … …  
    130132        this->changedUsed();
    131133
     134        //TODO: Synchronize & make safe for dedicated server.
    132135        GUIManager::getInstance().getLuaState()->doString("PickupInventory.update()");
    133136        return true;
    … …  
    277280            this->getCarrier()->removePickup(this);
    278281        this->changedPickedUp();
     282
     283        //TODO: Synchronize & make safe for dedicated server.
    279284        GUIManager::getInstance().getLuaState()->doString("PickupInventory.update()");
    280285        return true;
    … …  
    303308                return false;
    304309        }
    305        
     310
    306311        this->carrier_ = carrier;
    307312        this->changedCarrier();

  • code/trunk/src/orxonox/interfaces/Pickupable.h

    r7456 r7494  
    5050    @brief
    5151        An Interface (or more precisely an abstract class) to model and represent different (all kinds of) pickups.
     52
     53        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.
     54
     55        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.
     56
    5257    @author
    5358        Damian 'Mozork' Frick
    … …  
    6368
    6469            /**
    65             @brief Get whether the pickup is currently in use or not.
    66             @return Returns true if the pickup is currently in use.
     70            @brief Get whether the Pickupable is currently in use or not.
     71            @return Returns true if the Pickupable is currently in use.
    6772            */
    6873            inline bool isUsed(void) { return this->used_; }  // tolua_export
    6974            /**
    70             @brief  Should be called when the pickup has transited from used to unused or the other way around.
     75            @brief  Should be called when the Pickupable has transited from used to unused or the other way around.
    7176                    Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedUsed); to their changdeUsed method.
    7277            */
    … …  
    7479
    7580            /**
    76             @brief Get the carrier of the pickup.
    77             @return Returns a pointer to the carrier of the pickup.
     81            @brief Get the carrier of the Pickupable.
     82            @return Returns a pointer to the carrier of the Pickupable.
    7883            */
    7984            inline PickupCarrier* getCarrier(void)
    8085                { return this->carrier_; }
    8186            /**
    82             @brief Should be called when the pickup has changed its PickupCarrier.
     87            @brief Should be called when the Pickupable has changed its PickupCarrier.
    8388                   Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedCarrier); to their changedCarrier method.
    8489            */
    … …  
    9196            inline bool isPickedUp(void) { return this->pickedUp_; }  // tolua_export
    9297            /**
    93             @brief  Should be called when the pickup has transited from picked up to dropped or the other way around.
     98            @brief  Should be called when the Pickupable has transited from picked up to dropped or the other way around.
    9499                    Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedPickedUp); to their changedPickedUp method.
    95100            */
    … …  
    119124            bool drop(bool createSpawner = true); //!< Can be called to drop a Pickupable.
    120125
    121             virtual bool isTarget(PickupCarrier* carrier) const; //!< Get whether the given PickupCarrier is a target of this pickup.
     126            virtual bool isTarget(PickupCarrier* carrier) const; //!< Get whether the given PickupCarrier is a target of this Pickupable.
    122127            bool isTarget(const Identifier* identifier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this Pickupable.
    123             bool addTarget(PickupCarrier* target); //!< Add a PickupCarrier as target of this pickup.
    124             bool addTarget(Identifier* identifier); //!< Add a class, representetd by the input Identifier, as target of this pickup.
     128            bool addTarget(PickupCarrier* target); //!< Add a PickupCarrier as target of this Pickupable.
     129            bool addTarget(Identifier* identifier); //!< Add a class, representetd by the input Identifier, as target of this Pickupable.
    125130
    126131            Pickupable* clone(void); //!< Creates a duplicate of the Pickupable.
    … …  
    137142            bool setPickedUp(bool pickedUp); //!< Helper method to set the Pickupable to either picked up or not picked up.
    138143            //TODO: private?
    139             bool setCarrier(PickupCarrier* carrier, bool tell = true); //!< Sets the carrier of the pickup.
     144            bool setCarrier(PickupCarrier* carrier, bool tell = true); //!< Sets the carrier of the Pickupable.
    140145
    141146            //TODO: private?
    142147            virtual void carrierDestroyed(void); //!< Is called by the PickupCarrier when it is being destroyed.
    143148
    144             void destroy(void); //!< Is called internally within the pickup module to destroy pickups.
     149            void destroy(void); //!< Is called internally within the Pickupable module to destroy pickups.
    145150
    146151        protected:
    … …  
    187192    };  // tolua_export
    188193
     194    //! SUPER functions.
    189195    SUPER_FUNCTION(10, Pickupable, changedUsed, false);
    190196    SUPER_FUNCTION(12, Pickupable, changedCarrier, false);
Note: See TracChangeset for help on using the changeset viewer.