Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/HUD_HS16/src/orxonox/interfaces/Pickupable.h @ 11574

Last change on this file since 11574 was 11323, checked in by patricwi, 8 years ago

bug when ending or restarting a game with non-empty inventory and size and address of pickups still has to be specified so that the item corresponds to the right pickup symbol

  • Property svn:eol-style set to native
File size: 8.0 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Damian 'Mozork' Frick
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30    @file Pickupable.h
31    @brief Definition of the Pickupable class.
32    @ingroup Pickup
33*/
34
35#ifndef _Pickupable_H__
36#define _Pickupable_H__
37
38#include "OrxonoxPrereqs.h"
39
40#include <list>
41#include "core/class/Super.h"
42
43#include "core/class/OrxonoxInterface.h"
44#include "Rewardable.h"
45
46namespace orxonox
47{
48
49    /**
50    @brief
51        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    @author
56        Damian 'Mozork' Frick
57
58    @ingroup Pickup
59    */
60    class _OrxonoxExport Pickupable : virtual public OrxonoxInterface, public Rewardable
61    {
62        friend class PickupCarrier;
63
64        protected:
65            Pickupable(); //!< Default constructor.
66
67        public:
68            virtual ~Pickupable(); //!< Default destructor.
69
70            //! @brief Returns the representation name which refers to the name of the PickupRepresentation that is used to represent this pickup.
71            virtual const std::string& getRepresentationName() const = 0;
72
73            /**
74            @brief Get whether the Pickupable is currently in use or not.
75            @return Returns true if the Pickupable is currently in use.
76            */
77            inline bool isUsed(void) const
78                { return this->used_; }
79            /**
80            @brief  Should be called when the Pickupable has transited from used to unused or the other way around.
81                    Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedUsed); to their changdeUsed method.
82            */
83            virtual void changedUsed(void) {}
84
85            /**
86            @brief Get the carrier of the Pickupable.
87            @return Returns a pointer to the carrier of the Pickupable.
88            */
89            inline PickupCarrier* getCarrier(void)
90                { return this->carrier_; }
91            /**
92            @brief Should be called when the Pickupable has changed its PickupCarrier.
93                   Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedCarrier); to their changedCarrier method.
94            */
95            virtual void changedCarrier(void) {}
96
97            /**
98            @brief Check whether the Pickupable is in the process of being destroyed.
99            @return Returns true if so.
100            */
101            inline bool isBeingDestroyed(void)
102                { return this->beingDestroyed_; }
103               
104            /**
105            @brief Returns whether the Pickupable is currently picked up.
106            @return Returns true if the Pickupable is currently picked up, false if not.
107            */
108            inline bool isPickedUp(void) const
109                { return this->pickedUp_; }
110            /**
111            @brief  Should be called when the Pickupable has transited from picked up to dropped or the other way around.
112                    Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedPickedUp); to their changedPickedUp method.
113            */
114            virtual void changedPickedUp(void) {}
115
116            /**
117            @brief Returns whether the Pickupable can be used.
118            @return Returns true if it can be used.
119            */
120            inline bool isUsable(void) const
121                { return this->enabled_; }
122
123            /**
124            @brief Returns whether the Pickupable can be unused.
125            @return Returns true if it can be unused.
126            */
127            inline bool isUnusable(void) const
128                { return this->enabled_; }
129
130            /**
131            @brief Returns whether the Pickupable is enabled.
132                   Once a Pickupable is disabled it cannot be enabled again. A Pickupable that is disabled can neither be used nor unused.
133            @return Returns true if the Pickupable is enabled.
134            */
135            inline bool isEnabled(void) const
136                { return this->enabled_; }
137
138            bool pickup(PickupCarrier* carrier); //!< Can be called to pick up a Pickupable.
139            bool drop(bool createSpawner = true); //!< Can be called to drop a Pickupable.
140
141            virtual bool isTarget(const PickupCarrier* carrier) const; //!< Get whether the given PickupCarrier is a target of this Pickupable.
142            bool isTarget(const Identifier* identifier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this Pickupable.
143            bool addTarget(PickupCarrier* target); //!< Add a PickupCarrier as target of this Pickupable.
144            bool addTarget(Identifier* identifier); //!< Add a class, representetd by the input Identifier, as target of this Pickupable.
145
146            bool setUsed(bool used); //!< Sets the Pickupable to used or unused, depending on the input.
147            bool setPickedUp(bool pickedUp); //!< Helper method to set the Pickupable to either picked up or not picked up.
148            bool setCarrier(PickupCarrier* carrier, bool tell = true); //!< Sets the carrier of the Pickupable.
149
150            void destroy(void); //!< Is called internally within the Pickupable module to destroy pickups.
151
152        protected:
153            virtual void preDestroy(void) override; //!< A method that is called by Destroyable::destroy() before the object is actually destroyed.
154            virtual void destroyPickup(void); //!< Destroys a Pickupable.
155            virtual void carrierDestroyed(void); //!< Is called by the PickupCarrier when it is being destroyed.
156
157            /**
158            @brief Sets the Pickuapble to disabled.
159            */
160            inline void setDisabled(void)
161                { this->enabled_ = false; }
162
163            /**
164            @brief Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
165                   This method must be implemented by any class directly inheriting from Pickupable.
166            @return Returns true if a spawner was created, false if not.
167            */
168            virtual bool createSpawner(void) = 0;
169
170        private:
171
172            bool used_; //!< Whether the Pickupable is currently in use or not.
173            bool pickedUp_; //!< Whether the Pickupable is currently picked up or not.
174
175            bool enabled_; //!< Whether the Pickupable is enabled or not.
176
177            PickupCarrier* carrier_; //!< The PickupCarrier of the Pickupable.
178            std::list<Identifier*> targets_; //!< The possible targets of this Pickupable.
179
180            bool beingDestroyed_; //!< Is true if the Pickupable is in the process of being destroyed.
181
182        // For implementing the Rewardable interface:
183        public:
184            virtual bool reward(PlayerInfo* player) override; //!< Method to transcribe a Pickupable as a Rewardable to the player.
185
186    };
187
188    //! SUPER functions.
189    SUPER_FUNCTION(9, Pickupable, changedUsed, false);
190    SUPER_FUNCTION(10, Pickupable, changedCarrier, false);
191    SUPER_FUNCTION(11, Pickupable, changedPickedUp, false);
192}
193
194#endif /* _Pickupable_H__ */
Note: See TracBrowser for help on using the repository browser.