[6405] | 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 | /** |
---|
[6538] | 30 | @file Pickupable.h |
---|
[6405] | 31 | @brief Definition of the Pickupable class. |
---|
[7456] | 32 | @ingroup Pickup |
---|
[6405] | 33 | */ |
---|
| 34 | |
---|
| 35 | #ifndef _Pickupable_H__ |
---|
| 36 | #define _Pickupable_H__ |
---|
| 37 | |
---|
| 38 | #include "OrxonoxPrereqs.h" |
---|
| 39 | |
---|
[6474] | 40 | #include <list> |
---|
[6405] | 41 | #include "core/Super.h" |
---|
| 42 | |
---|
[6474] | 43 | #include "core/OrxonoxClass.h" |
---|
[7163] | 44 | #include "Rewardable.h" |
---|
[6474] | 45 | |
---|
[7504] | 46 | namespace orxonox |
---|
| 47 | { |
---|
[7163] | 48 | |
---|
[6405] | 49 | /** |
---|
| 50 | @brief |
---|
[6474] | 51 | An Interface (or more precisely an abstract class) to model and represent different (all kinds of) pickups. |
---|
[7494] | 52 | |
---|
[7547] | 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. |
---|
[7494] | 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 | |
---|
[6405] | 57 | @author |
---|
| 58 | Damian 'Mozork' Frick |
---|
[7547] | 59 | |
---|
| 60 | @ingroup Pickup |
---|
[6405] | 61 | */ |
---|
[7504] | 62 | class _OrxonoxExport Pickupable : virtual public OrxonoxClass, public Rewardable |
---|
| 63 | { |
---|
[7552] | 64 | friend class PickupCarrier; |
---|
| 65 | |
---|
[6540] | 66 | protected: |
---|
| 67 | Pickupable(); //!< Default constructor. |
---|
[7163] | 68 | |
---|
[6405] | 69 | public: |
---|
[6474] | 70 | virtual ~Pickupable(); //!< Default destructor. |
---|
[7163] | 71 | |
---|
[6405] | 72 | /** |
---|
[7494] | 73 | @brief Get whether the Pickupable is currently in use or not. |
---|
| 74 | @return Returns true if the Pickupable is currently in use. |
---|
[6405] | 75 | */ |
---|
[7547] | 76 | inline bool isUsed(void) const |
---|
[7504] | 77 | { return this->used_; } |
---|
[6474] | 78 | /** |
---|
[7494] | 79 | @brief Should be called when the Pickupable has transited from used to unused or the other way around. |
---|
[6474] | 80 | Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedUsed); to their changdeUsed method. |
---|
| 81 | */ |
---|
| 82 | virtual void changedUsed(void) {} |
---|
[7163] | 83 | |
---|
[6474] | 84 | /** |
---|
[7494] | 85 | @brief Get the carrier of the Pickupable. |
---|
| 86 | @return Returns a pointer to the carrier of the Pickupable. |
---|
[6521] | 87 | */ |
---|
| 88 | inline PickupCarrier* getCarrier(void) |
---|
| 89 | { return this->carrier_; } |
---|
| 90 | /** |
---|
[7494] | 91 | @brief Should be called when the Pickupable has changed its PickupCarrier. |
---|
[6521] | 92 | Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedCarrier); to their changedCarrier method. |
---|
| 93 | */ |
---|
| 94 | virtual void changedCarrier(void) {} |
---|
[7163] | 95 | |
---|
[6521] | 96 | /** |
---|
[6474] | 97 | @brief Returns whether the Pickupable is currently picked up. |
---|
| 98 | @return Returns true if the Pickupable is currently picked up, false if not. |
---|
| 99 | */ |
---|
[7547] | 100 | inline bool isPickedUp(void) const |
---|
[7504] | 101 | { return this->pickedUp_; } |
---|
[6521] | 102 | /** |
---|
[7494] | 103 | @brief Should be called when the Pickupable has transited from picked up to dropped or the other way around. |
---|
[6521] | 104 | Any Class overwriting this method must call its SUPER function by adding SUPER(Classname, changedPickedUp); to their changedPickedUp method. |
---|
| 105 | */ |
---|
[6523] | 106 | virtual void changedPickedUp(void) {} |
---|
[7163] | 107 | |
---|
| 108 | /** |
---|
| 109 | @brief Returns whether the Pickupable can be used. |
---|
| 110 | @return Returns true if it can be used. |
---|
| 111 | */ |
---|
[7547] | 112 | inline bool isUsable(void) const |
---|
[7504] | 113 | { return this->enabled_; } |
---|
| 114 | |
---|
[7163] | 115 | /** |
---|
| 116 | @brief Returns whether the Pickupable can be unused. |
---|
| 117 | @return Returns true if it can be unused. |
---|
| 118 | */ |
---|
[7547] | 119 | inline bool isUnusable(void) const |
---|
[7504] | 120 | { return this->enabled_; } |
---|
[7163] | 121 | |
---|
| 122 | /** |
---|
| 123 | @brief Returns whether the Pickupable is enabled. |
---|
| 124 | Once a Pickupable is disabled it cannot be enabled again. A Pickupable that is disabled can neither be used nor unused. |
---|
| 125 | @return Returns true if the Pickupable is enabled. |
---|
| 126 | */ |
---|
[7547] | 127 | inline bool isEnabled(void) const |
---|
[7163] | 128 | { return this->enabled_; } |
---|
| 129 | |
---|
| 130 | bool pickup(PickupCarrier* carrier); //!< Can be called to pick up a Pickupable. |
---|
| 131 | bool drop(bool createSpawner = true); //!< Can be called to drop a Pickupable. |
---|
| 132 | |
---|
[7547] | 133 | virtual bool isTarget(const PickupCarrier* carrier) const; //!< Get whether the given PickupCarrier is a target of this Pickupable. |
---|
[6731] | 134 | bool isTarget(const Identifier* identifier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this Pickupable. |
---|
[7494] | 135 | bool addTarget(PickupCarrier* target); //!< Add a PickupCarrier as target of this Pickupable. |
---|
| 136 | bool addTarget(Identifier* identifier); //!< Add a class, representetd by the input Identifier, as target of this Pickupable. |
---|
[7163] | 137 | |
---|
[6474] | 138 | Pickupable* clone(void); //!< Creates a duplicate of the Pickupable. |
---|
[6497] | 139 | virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass. |
---|
[7163] | 140 | |
---|
[6474] | 141 | /** |
---|
| 142 | @brief Get the PickupIdentifier of this Pickupable. |
---|
| 143 | @return Returns a pointer to the PickupIdentifier of this Pickupable. |
---|
| 144 | */ |
---|
[7547] | 145 | virtual const PickupIdentifier* getPickupIdentifier(void) const |
---|
[6475] | 146 | { return this->pickupIdentifier_; } |
---|
[7163] | 147 | |
---|
[6521] | 148 | bool setUsed(bool used); //!< Sets the Pickupable to used or unused, depending on the input. |
---|
| 149 | bool setPickedUp(bool pickedUp); //!< Helper method to set the Pickupable to either picked up or not picked up. |
---|
[7494] | 150 | bool setCarrier(PickupCarrier* carrier, bool tell = true); //!< Sets the carrier of the Pickupable. |
---|
[7163] | 151 | |
---|
[7494] | 152 | void destroy(void); //!< Is called internally within the Pickupable module to destroy pickups. |
---|
[7163] | 153 | |
---|
[6466] | 154 | protected: |
---|
[6474] | 155 | /** |
---|
| 156 | @brief Helper method to initialize the PickupIdentifier. |
---|
| 157 | */ |
---|
[6466] | 158 | void initializeIdentifier(void) {} |
---|
[7163] | 159 | |
---|
| 160 | virtual void preDestroy(void); //!< A method that is called by OrxonoxClass::destroy() before the object is actually destroyed. |
---|
| 161 | virtual void destroyPickup(void); //!< Destroys a Pickupable. |
---|
[7552] | 162 | virtual void carrierDestroyed(void); //!< Is called by the PickupCarrier when it is being destroyed. |
---|
[7163] | 163 | |
---|
[6475] | 164 | /** |
---|
[7163] | 165 | @brief Sets the Pickuapble to disabled. |
---|
| 166 | */ |
---|
| 167 | inline void setDisabled(void) |
---|
| 168 | { this->enabled_ = false; } |
---|
| 169 | |
---|
| 170 | /** |
---|
[6475] | 171 | @brief Facilitates the creation of a PickupSpawner upon dropping of the Pickupable. |
---|
| 172 | This method must be implemented by any class directly inheriting from Pickupable. It is most easily done by just creating a new DroppedPickup, e.g.: |
---|
[7401] | 173 | DroppedPickup(BaseObject* creator, Pickupable* pickup, PickupCarrier* carrier, float triggerDistance); |
---|
[6475] | 174 | @return Returns true if a spawner was created, false if not. |
---|
| 175 | */ |
---|
[6540] | 176 | virtual bool createSpawner(void) = 0; |
---|
[7163] | 177 | |
---|
[6475] | 178 | PickupIdentifier* pickupIdentifier_; //!< The PickupIdentifier of this Pickupable. |
---|
[7163] | 179 | |
---|
[6405] | 180 | private: |
---|
| 181 | |
---|
[7163] | 182 | bool used_; //!< Whether the Pickupable is currently in use or not. |
---|
| 183 | bool pickedUp_; //!< Whether the Pickupable is currently picked up or not. |
---|
| 184 | |
---|
| 185 | bool enabled_; //!< Whether the Pickupable is enabled or not. |
---|
| 186 | |
---|
| 187 | PickupCarrier* carrier_; //!< The PickupCarrier of the Pickupable. |
---|
| 188 | std::list<Identifier*> targets_; //!< The possible targets of this Pickupable. |
---|
| 189 | |
---|
| 190 | bool beingDestroyed_; //!< Is true if the Pickupable is in the process of being destroyed. |
---|
| 191 | |
---|
| 192 | // For implementing the Rewardable interface: |
---|
| 193 | public: |
---|
| 194 | virtual bool reward(PlayerInfo* player); //!< Method to transcribe a Pickupable as a Rewardable to the player. |
---|
| 195 | |
---|
[7504] | 196 | }; |
---|
[7163] | 197 | |
---|
[7494] | 198 | //! SUPER functions. |
---|
[6466] | 199 | SUPER_FUNCTION(10, Pickupable, changedUsed, false); |
---|
| 200 | SUPER_FUNCTION(12, Pickupable, changedCarrier, false); |
---|
[6521] | 201 | SUPER_FUNCTION(13, Pickupable, changedPickedUp, false); |
---|
[7504] | 202 | } |
---|
[6405] | 203 | |
---|
| 204 | #endif /* _Pickupable_H__ */ |
---|