[4597] | 1 | /*! |
---|
[4959] | 2 | * @file weapon.h |
---|
| 3 | * |
---|
| 4 | * Weapon is the mayor baseclass for all weapons. it is quite extensive, and expensive in use, |
---|
| 5 | * because each weapon will know virutal functions for the WorldEntity's part, and also virtuals |
---|
| 6 | * for Fireing/Reloading/..., |
---|
| 7 | * quickly said: Weapon is a wrapper for weapons, that makes it easy to very quickly implement |
---|
| 8 | * new Weapons, and with them make this game better, than any game before it, because still |
---|
| 9 | * Weapons (GUNS) are the most important thing in life :?... no to be serious |
---|
| 10 | * @see Weapon |
---|
| 11 | */ |
---|
[3573] | 12 | |
---|
| 13 | |
---|
| 14 | #ifndef _WEAPON_H |
---|
| 15 | #define _WEAPON_H |
---|
| 16 | |
---|
| 17 | #include "world_entity.h" |
---|
[6669] | 18 | #include "count_pointer.h" |
---|
| 19 | #include "ammo_container.h" |
---|
[3573] | 20 | |
---|
[4759] | 21 | // FORWARD DECLARATION |
---|
[3575] | 22 | class Projectile; |
---|
[4955] | 23 | class WeaponManager; |
---|
[3886] | 24 | class Animation3D; |
---|
[4759] | 25 | class TiXmlElement; |
---|
[5355] | 26 | class FastFactory; |
---|
[4934] | 27 | template<class T> class tFastFactory; |
---|
[6438] | 28 | class GLGuiWidget; |
---|
[3573] | 29 | |
---|
[4890] | 30 | //! An enumerator defining Actions a Weapon can take |
---|
[4830] | 31 | typedef enum { |
---|
| 32 | WA_NONE = 0, //!< No Action taken |
---|
| 33 | WA_SHOOT = 1, //!< emitting Shot |
---|
| 34 | WA_CHARGE = 2, //!< charge action (one click before the shot) |
---|
| 35 | WA_RELOAD = 3, //!< reload right after shoot is finished |
---|
| 36 | WA_ACTIVATE = 4, //!< activate the GUN |
---|
| 37 | WA_DEACTIVATE = 5, //!< deactivate the GUN |
---|
| 38 | WA_SPECIAL1 = 6, //!< Special Action taken |
---|
[4826] | 39 | |
---|
[4832] | 40 | WA_ACTION_COUNT = 7 //!< This must match the count of enumerations-members. |
---|
[4885] | 41 | } WeaponAction; |
---|
[4826] | 42 | |
---|
[4827] | 43 | //! An enumerator defining the States of a Weapon |
---|
[3583] | 44 | typedef enum { |
---|
[4830] | 45 | WS_NONE = 0, //!< No State at all (if set, there is something wrong, or the weapon is not yet availiable) |
---|
| 46 | WS_SHOOTING = 1, //!< The State of the Shooting |
---|
[4885] | 47 | WS_CHARGING = 2, //!< The state of charging th weapon |
---|
[4830] | 48 | WS_RELOADING = 3, //!< The State of the Reloading |
---|
| 49 | WS_ACTIVATING = 4, //!< The State in which the weapon gets activated |
---|
| 50 | WS_DEACTIVATING = 5, //!< The State in which the weapon gets deactivated |
---|
| 51 | WS_INACTIVE = 6, //!< The State where the weapon is inactive (unable to shoot) |
---|
| 52 | WS_IDLE = 7, //!< The State where the weapon is idle |
---|
[4827] | 53 | |
---|
[4875] | 54 | WS_STATE_COUNT = 8 //!< This must match the count of enumerations-members. |
---|
[4826] | 55 | } WeaponState; |
---|
[3583] | 56 | |
---|
[4959] | 57 | //! an enumerator defining capabilities of a WeaponSlot |
---|
| 58 | typedef enum |
---|
| 59 | { |
---|
| 60 | WTYPE_DIRECTIONAL = 0x00000001, //!< Weapon is directional/Slot is able to carry directional weapons |
---|
| 61 | WTYPE_TURRET = 0x00000002, //!< Weapon is a turret/slot is able to carry turrets |
---|
| 62 | WTYPE_ALLKINDS = 0x0000000f, //!< Weapon is all types/Slot is able to carry all kinds of weapons |
---|
[3870] | 63 | |
---|
[4959] | 64 | WTYPE_FORWARD = 0x00000010, //!< Weapon fires forwards/Slot is able to carry weapons firing forwards |
---|
| 65 | WTYPE_BACKWARD = 0x00000020, //!< Weapon fires backwards/Slot is able to carry weapons firing backwards |
---|
| 66 | WTYPE_LEFT = 0x00000040, //!< Weapon fires to the left/Slot is able to carry weapons firing to the left |
---|
| 67 | WTYPE_RIGHT = 0x00000080, //!< Weapon fires to the right/Slot is able to carry weapons firing to the right |
---|
| 68 | WTYPE_ALLDIRS = 0x000000f0, //!< Weapon has no specific firing direction/Slot can fire into all directions |
---|
[3886] | 69 | |
---|
[4959] | 70 | WTYPE_ALL = 0x000000ff, //!< Weapon has no limitations/Slot can handle all kinds of Weapon. |
---|
| 71 | } W_Capability; |
---|
| 72 | |
---|
[4827] | 73 | //! An abstract class, that describes weapons |
---|
| 74 | /** |
---|
| 75 | * This is used as a container for all the different kinds of weapons that may exist |
---|
[4975] | 76 | * |
---|
| 77 | * Weapons have certain states, and actions, that can inflict them. |
---|
| 78 | * ex. Action WA_SHOOT leeds to State WS_SHOOTING. |
---|
| 79 | * each action has a sound connected to it, |
---|
| 80 | * each state a time and an animation. |
---|
[4827] | 81 | */ |
---|
[4597] | 82 | class Weapon : public WorldEntity |
---|
[3573] | 83 | { |
---|
[4885] | 84 | public: |
---|
| 85 | // INITIALISATION // |
---|
[5750] | 86 | Weapon (); |
---|
[4885] | 87 | virtual ~Weapon (); |
---|
[3573] | 88 | |
---|
[4885] | 89 | void init(); |
---|
[6512] | 90 | virtual void loadParams(const TiXmlElement* root); |
---|
[4885] | 91 | //////////////////// |
---|
[4597] | 92 | |
---|
[4947] | 93 | // INTERACTIVITY // |
---|
[4885] | 94 | void requestAction(WeaponAction action); |
---|
[4890] | 95 | float increaseEnergy(float energyToAdd); |
---|
[4947] | 96 | /////////////////// |
---|
[4759] | 97 | |
---|
[4906] | 98 | /** @returns true if the Weapon is Active (this is used to check if the weapon must be drawn)*/ |
---|
[5750] | 99 | inline bool isActive() const { return (this->currentState == WS_INACTIVE)? false : true; }; |
---|
[4906] | 100 | /** @returns true if the weapon must be drawn */ |
---|
[5750] | 101 | inline bool isVisible() const { return (this->currentState != WS_INACTIVE || !this->hideInactive) ? true : false; }; |
---|
[4949] | 102 | /** @returns true if the Weapon is chargeable */ |
---|
| 103 | inline bool isChargeable() const { return this->chargeable; }; |
---|
[3577] | 104 | |
---|
[4885] | 105 | // FUNCTIONS TO SET THE WEAPONS PROPERTIES. |
---|
[5441] | 106 | /** sets the Weapons Capabilities */ |
---|
| 107 | inline void setCapability(long capabilities) { this->capability = capabilities; }; |
---|
| 108 | /** @returns the Capabilities of this Weapon */ |
---|
[6669] | 109 | inline long getCapability() const { return this->capability; }; |
---|
[5356] | 110 | void setProjectileType(ClassID projectile); |
---|
| 111 | void setProjectileType(const char* projectile); |
---|
[4947] | 112 | /** @returns The projectile's classID */ |
---|
[5356] | 113 | inline ClassID getProjectileType() { return this->projectile; }; |
---|
[4947] | 114 | /** @returns the FastFactory, that creates Projectiles of type getProjectile */ |
---|
| 115 | inline FastFactory* getProjectileFactory() { return this->projectileFactory; }; |
---|
[5356] | 116 | void prepareProjectiles(unsigned int count); |
---|
| 117 | Projectile* getProjectile(); |
---|
[3575] | 118 | |
---|
[4947] | 119 | |
---|
[5750] | 120 | // EMISSION |
---|
[4892] | 121 | void setEmissionPoint(const Vector& point); |
---|
| 122 | /** @see void setEmissionPoint(const Vector& point); */ |
---|
[4972] | 123 | inline void setEmissionPoint(float x, float y, float z) { this->setEmissionPoint(Vector(x, y, z)); }; |
---|
[4927] | 124 | /** @returns the absolute Position of the EmissionPoint */ |
---|
| 125 | inline const Vector& getEmissionPoint() const { return this->emissionPoint.getAbsCoor(); }; |
---|
[4892] | 126 | |
---|
[5750] | 127 | // STATE CHANGES // |
---|
[4885] | 128 | /** @param state the State to time @param duration the duration of the State */ |
---|
| 129 | inline void setStateDuration(const char* state, float duration) { setStateDuration(charToState(state), duration); }; |
---|
| 130 | /** @param state the State to time @param duration the duration of the State */ |
---|
| 131 | inline void setStateDuration(WeaponState state, float duration) { /*(state < WS_STATE_COUNT)?*/this->times[state] = duration; }; |
---|
| 132 | /** @param state The state to query @returns the Time the queried State takes to complete */ |
---|
[5750] | 133 | inline float getStateDuration(WeaponState state) const { return (state < WS_STATE_COUNT)? this->times[state] : 0.0; }; |
---|
[4885] | 134 | /** @returns true if the time of the currentState is elapsed, false otherwise */ |
---|
[5750] | 135 | inline bool stateTimeElapsed() const { return (this->stateDuration > this->times[currentState])? true : false; }; |
---|
[4885] | 136 | /** @returns the current State of the Weapon */ |
---|
| 137 | inline WeaponState getCurrentState() const { return this->currentState; }; |
---|
[4892] | 138 | |
---|
[6671] | 139 | /** @param energyMax the maximum energy the Weapon can have */ |
---|
| 140 | inline void setEnergyMax(float energyMax) { this->energyMax = energyMax; }; |
---|
| 141 | inline float getEnergy() const { return this->energy; }; |
---|
[6306] | 142 | inline float getEnergyMax() const { return this->energyMax; }; |
---|
[6669] | 143 | inline void setAmmoContainer(const CountPointer<AmmoContainer>& ammoContainer) { this->ammoContainer = ammoContainer;} |
---|
[3575] | 144 | |
---|
[4885] | 145 | void setActionSound(WeaponAction action, const char* soundFile); |
---|
| 146 | /** @see void setActionSound(WeaponAction action, const char* soundFile); */ |
---|
| 147 | void setActionSound(const char* action, const char* soundFile) { this->setActionSound(charToAction(action), soundFile); }; |
---|
[3575] | 148 | |
---|
[4895] | 149 | Animation3D* getAnimation(WeaponState state, PNode* node = NULL); |
---|
[4906] | 150 | Animation3D* copyAnimation(WeaponState from, WeaponState to); |
---|
[4597] | 151 | |
---|
[6438] | 152 | GLGuiWidget* getEnergyWidget(); |
---|
| 153 | |
---|
[4885] | 154 | // FLOW |
---|
[6736] | 155 | bool tickW(float dt); //!< this is a function that must be called by the weaponManager, or any other weaponHandler, all other functions are handled from within |
---|
[5750] | 156 | |
---|
[6736] | 157 | virtual void tick(float dt) { tickW(dt); }; |
---|
[6439] | 158 | |
---|
[4891] | 159 | bool check() const; |
---|
[4885] | 160 | void debug() const; |
---|
[3886] | 161 | |
---|
[4885] | 162 | protected: |
---|
| 163 | //! ACTION: these functions are handled by the Weapon itself, and must be called by requestAction(WeaponAction); |
---|
[4892] | 164 | virtual void activate() {}; |
---|
| 165 | virtual void deactivate() {}; |
---|
| 166 | virtual void charge() {}; |
---|
| 167 | virtual void fire() {}; |
---|
| 168 | virtual void reload() {}; |
---|
| 169 | virtual void destroy() {}; |
---|
[3886] | 170 | |
---|
[4890] | 171 | |
---|
| 172 | // utility: |
---|
| 173 | static WeaponAction charToAction(const char* action); |
---|
| 174 | static const char* actionToChar(WeaponAction action); |
---|
| 175 | static WeaponState charToState(const char* state); |
---|
| 176 | static const char* stateToChar(WeaponState state); |
---|
[4891] | 177 | |
---|
[4885] | 178 | private: |
---|
[4892] | 179 | /** executive functions, that handle timing with actions. |
---|
| 180 | * This is for the action-functions in derived functions to be easy |
---|
| 181 | * The main function is execute, that calls all the other functions |
---|
| 182 | * for being fast, the Functions are private and as such will be inlined |
---|
| 183 | * into the execute function. (this is work of the compiler) |
---|
| 184 | */ |
---|
| 185 | bool execute(); |
---|
| 186 | bool activateW(); |
---|
| 187 | bool deactivateW(); |
---|
| 188 | bool chargeW(); |
---|
| 189 | bool fireW(); |
---|
| 190 | bool reloadW(); |
---|
[4926] | 191 | inline void enterState(WeaponState state); |
---|
[3886] | 192 | |
---|
[6438] | 193 | void updateWidgets(); |
---|
[4926] | 194 | |
---|
[4927] | 195 | private: |
---|
[5441] | 196 | // type of Weapon |
---|
| 197 | long capability; //!< what capabilities the Weapon has @see W_Capability |
---|
| 198 | |
---|
[4885] | 199 | // it is all about energy |
---|
[6671] | 200 | float energy; //!< The energy stored in the weapons buffers |
---|
| 201 | float energyMax; //!< The maximal energy that can be stored in the secondary buffers (reserveMax) |
---|
[6669] | 202 | CountPointer<AmmoContainer> ammoContainer; //!< Pointer to the AmmoContainer this weapon grabs Energy from. |
---|
[4910] | 203 | //! @todo move this to projectile |
---|
[4890] | 204 | float minCharge; //!< The minimal energy to be loaded onto one projectile if chargeable otherwise the power consumed by one projectile |
---|
| 205 | float maxCharge; //!< The maximal energy to be loaded onto one projectile (this is only availible if chargeable is enabled) |
---|
[3573] | 206 | |
---|
[6438] | 207 | GLGuiBar* energyWidget; |
---|
| 208 | |
---|
[4885] | 209 | //////////// |
---|
| 210 | // PHASES // |
---|
| 211 | //////////// |
---|
[4910] | 212 | SoundSource* soundSource; //!< A SoundSource to play sound from (this is connected to the PNode of the Weapon) |
---|
| 213 | |
---|
[4885] | 214 | WeaponState currentState; //!< The State the weapon is in. |
---|
| 215 | WeaponAction requestedAction; //!< An action to try to Engage after the currentState ends. |
---|
| 216 | float stateDuration; //!< how long the state has taken until now. |
---|
| 217 | float times[WS_STATE_COUNT]; //!< Times to stay in the different States @see WeaponState. |
---|
| 218 | Animation3D* animation[WS_STATE_COUNT]; //!< Animations for all the States (you can say yourself on what part of the gun this animation acts). |
---|
| 219 | SoundBuffer* soundBuffers[WA_ACTION_COUNT]; //!< SoundBuffers for all actions @see WeaponAction. |
---|
| 220 | |
---|
[4892] | 221 | PNode emissionPoint; //!< The point, where the projectiles are emitted. (this is coppled with the Weapon by default) |
---|
[4885] | 222 | |
---|
| 223 | bool hideInactive; //!< Hides the Weapon if it is inactive |
---|
[4930] | 224 | bool chargeable; //!< if the Weapon is charcheable (if true, the weapon will charge before it fires.) |
---|
[4885] | 225 | |
---|
[4947] | 226 | ClassID projectile; //!< the projectile used for this weapon (since they should be generated via macro and the FastFactory, only the ClassID must be known.) |
---|
| 227 | FastFactory* projectileFactory; //!< A factory, that produces and handles the projectiles. |
---|
[4885] | 228 | }; |
---|
| 229 | |
---|
[3573] | 230 | #endif /* _WEAPON_H */ |
---|