[4597] | 1 | /*! |
---|
[3573] | 2 | \file weapon.h |
---|
[4836] | 3 | * a weapon that a can use |
---|
[3573] | 4 | |
---|
| 5 | |
---|
| 6 | A weapon is characterized by: |
---|
| 7 | o firing-rate: the initial firing rate of a weapon (1/s = Herz) |
---|
| 8 | o slowdown-factor: this is a factor d: exp(-d*x), d is element of all positive R. it determines how fast the firing-rate will slow down. if no slowdown: d=0, the bigger d is, the faster the weapon will slow down! |
---|
| 9 | o energy-consumption: this determines the energy that has to be used to produce this projectile = costs per projectile |
---|
[4597] | 10 | |
---|
[3573] | 11 | Furthermore there are some other attributes, that will help to represent a firing |
---|
| 12 | weapon in this world: |
---|
| 13 | o sound file/ressource: this is a pointer to the sound-file/ressource. however it may be represented |
---|
[4885] | 14 | o animations |
---|
[3573] | 15 | */ |
---|
| 16 | |
---|
| 17 | |
---|
| 18 | #ifndef _WEAPON_H |
---|
| 19 | #define _WEAPON_H |
---|
| 20 | |
---|
| 21 | #include "world_entity.h" |
---|
| 22 | |
---|
[4759] | 23 | // FORWARD DECLARATION |
---|
[3575] | 24 | class Projectile; |
---|
[3862] | 25 | class Weapon; |
---|
[3886] | 26 | class Animation3D; |
---|
[4759] | 27 | class TiXmlElement; |
---|
[3573] | 28 | |
---|
[4890] | 29 | //! An enumerator defining Actions a Weapon can take |
---|
[4830] | 30 | typedef enum { |
---|
| 31 | WA_NONE = 0, //!< No Action taken |
---|
| 32 | WA_SHOOT = 1, //!< emitting Shot |
---|
| 33 | WA_CHARGE = 2, //!< charge action (one click before the shot) |
---|
| 34 | WA_RELOAD = 3, //!< reload right after shoot is finished |
---|
| 35 | WA_ACTIVATE = 4, //!< activate the GUN |
---|
| 36 | WA_DEACTIVATE = 5, //!< deactivate the GUN |
---|
| 37 | WA_SPECIAL1 = 6, //!< Special Action taken |
---|
[4826] | 38 | |
---|
[4832] | 39 | WA_ACTION_COUNT = 7 //!< This must match the count of enumerations-members. |
---|
[4885] | 40 | } WeaponAction; |
---|
[4826] | 41 | |
---|
[4827] | 42 | //! An enumerator defining the States of a Weapon |
---|
[3583] | 43 | typedef enum { |
---|
[4830] | 44 | WS_NONE = 0, //!< No State at all (if set, there is something wrong, or the weapon is not yet availiable) |
---|
| 45 | WS_SHOOTING = 1, //!< The State of the Shooting |
---|
[4885] | 46 | WS_CHARGING = 2, //!< The state of charging th weapon |
---|
[4830] | 47 | WS_RELOADING = 3, //!< The State of the Reloading |
---|
| 48 | WS_ACTIVATING = 4, //!< The State in which the weapon gets activated |
---|
| 49 | WS_DEACTIVATING = 5, //!< The State in which the weapon gets deactivated |
---|
| 50 | WS_INACTIVE = 6, //!< The State where the weapon is inactive (unable to shoot) |
---|
| 51 | WS_IDLE = 7, //!< The State where the weapon is idle |
---|
[4827] | 52 | |
---|
[4875] | 53 | WS_STATE_COUNT = 8 //!< This must match the count of enumerations-members. |
---|
[4826] | 54 | } WeaponState; |
---|
[3583] | 55 | |
---|
[3870] | 56 | |
---|
[3886] | 57 | //! a weapon can be left or right sided |
---|
[4830] | 58 | /** |
---|
| 59 | * @todo this will be reset with mirror X/Y/Z |
---|
| 60 | */ |
---|
[4759] | 61 | #define W_LEFT 0 |
---|
| 62 | #define W_RIGHT 1 |
---|
[3886] | 63 | |
---|
[4827] | 64 | //! An abstract class, that describes weapons |
---|
| 65 | /** |
---|
| 66 | * This is used as a container for all the different kinds of weapons that may exist |
---|
| 67 | */ |
---|
[4597] | 68 | class Weapon : public WorldEntity |
---|
[3573] | 69 | { |
---|
[4885] | 70 | public: |
---|
| 71 | // INITIALISATION // |
---|
| 72 | Weapon (PNode* parent, const Vector& coordinate, const Quaternion& direction); |
---|
| 73 | Weapon(const TiXmlElement* root); |
---|
| 74 | virtual ~Weapon (); |
---|
[3573] | 75 | |
---|
[4885] | 76 | void init(); |
---|
| 77 | void loadParams(const TiXmlElement* root); |
---|
| 78 | //////////////////// |
---|
[4597] | 79 | |
---|
[4885] | 80 | void requestAction(WeaponAction action); |
---|
[4890] | 81 | float increaseEnergy(float energyToAdd); |
---|
[4759] | 82 | |
---|
[4906] | 83 | /** @returns true if the Weapon is Active (this is used to check if the weapon must be drawn)*/ |
---|
| 84 | inline bool isActive() const { return (this->currentState == WS_INACTIVE)?false:true; }; |
---|
| 85 | /** @returns true if the weapon must be drawn */ |
---|
| 86 | inline bool isVisible() const { return (this->currentState != WS_INACTIVE || !this->hideInactive)?true:false; }; |
---|
[3577] | 87 | |
---|
[4885] | 88 | // FUNCTIONS TO SET THE WEAPONS PROPERTIES. |
---|
| 89 | /** @param projectile a projectile for this weapon */ |
---|
| 90 | void setProjectile(Projectile* projectile) { this->projectile = projectile; }; |
---|
| 91 | /** @returns The projectile if availiable */ |
---|
| 92 | Projectile* getProjectile() { return this->projectile; }; |
---|
[3575] | 93 | |
---|
[4892] | 94 | void setEmissionPoint(const Vector& point); |
---|
| 95 | /** @see void setEmissionPoint(const Vector& point); */ |
---|
| 96 | inline void setEmissionPoint(float x, float y, float z) { this->setEmissionPoint(Vector(x,y,z)); }; |
---|
| 97 | |
---|
[4885] | 98 | /** @param state the State to time @param duration the duration of the State */ |
---|
| 99 | inline void setStateDuration(const char* state, float duration) { setStateDuration(charToState(state), duration); }; |
---|
| 100 | /** @param state the State to time @param duration the duration of the State */ |
---|
| 101 | inline void setStateDuration(WeaponState state, float duration) { /*(state < WS_STATE_COUNT)?*/this->times[state] = duration; }; |
---|
| 102 | /** @param state The state to query @returns the Time the queried State takes to complete */ |
---|
| 103 | inline float getStateDuration(WeaponState state) const { return (state < WS_STATE_COUNT)?this->times[state]:0.0; }; |
---|
| 104 | /** @returns true if the time of the currentState is elapsed, false otherwise */ |
---|
| 105 | inline bool stateTimeElapsed() const { return (this->stateDuration > this->times[currentState])?true:false; }; |
---|
| 106 | /** @returns the current State of the Weapon */ |
---|
| 107 | inline WeaponState getCurrentState() const { return this->currentState; }; |
---|
[4892] | 108 | |
---|
[4885] | 109 | /** @param energyMax the maximum energy the Weapon can have @param energyLoadedMax the maximum energy in the weapon buffers */ |
---|
| 110 | inline void setMaximumEnergy(float energyMax, float energyLoadedMax = 0.0) { this->energyMax = energyMax; this->energyLoadedMax = energyLoadedMax; }; |
---|
[3575] | 111 | |
---|
[4885] | 112 | void setActionSound(WeaponAction action, const char* soundFile); |
---|
| 113 | /** @see void setActionSound(WeaponAction action, const char* soundFile); */ |
---|
| 114 | void setActionSound(const char* action, const char* soundFile) { this->setActionSound(charToAction(action), soundFile); }; |
---|
[3575] | 115 | |
---|
[4895] | 116 | Animation3D* getAnimation(WeaponState state, PNode* node = NULL); |
---|
[4906] | 117 | Animation3D* copyAnimation(WeaponState from, WeaponState to); |
---|
[4597] | 118 | |
---|
[4885] | 119 | // FLOW |
---|
[4906] | 120 | void 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 |
---|
| 121 | virtual void tick(float dt) {}; |
---|
[4885] | 122 | virtual void draw(); |
---|
[3573] | 123 | |
---|
[4891] | 124 | bool check() const; |
---|
[4885] | 125 | void debug() const; |
---|
[3886] | 126 | |
---|
[4885] | 127 | protected: |
---|
| 128 | //! ACTION: these functions are handled by the Weapon itself, and must be called by requestAction(WeaponAction); |
---|
[4892] | 129 | virtual void activate() {}; |
---|
| 130 | virtual void deactivate() {}; |
---|
| 131 | virtual void charge() {}; |
---|
| 132 | virtual void fire() {}; |
---|
| 133 | virtual void reload() {}; |
---|
| 134 | virtual void destroy() {}; |
---|
[3886] | 135 | |
---|
[4890] | 136 | |
---|
| 137 | // utility: |
---|
| 138 | static WeaponAction charToAction(const char* action); |
---|
| 139 | static const char* actionToChar(WeaponAction action); |
---|
| 140 | static WeaponState charToState(const char* state); |
---|
| 141 | static const char* stateToChar(WeaponState state); |
---|
[4891] | 142 | |
---|
[4885] | 143 | private: |
---|
[4892] | 144 | /** executive functions, that handle timing with actions. |
---|
| 145 | * This is for the action-functions in derived functions to be easy |
---|
| 146 | * The main function is execute, that calls all the other functions |
---|
| 147 | * for being fast, the Functions are private and as such will be inlined |
---|
| 148 | * into the execute function. (this is work of the compiler) |
---|
| 149 | */ |
---|
| 150 | bool execute(); |
---|
| 151 | bool activateW(); |
---|
| 152 | bool deactivateW(); |
---|
| 153 | bool chargeW(); |
---|
| 154 | bool fireW(); |
---|
| 155 | bool reloadW(); |
---|
| 156 | |
---|
[4926] | 157 | inline void enterState(WeaponState state); |
---|
[3886] | 158 | |
---|
[4926] | 159 | |
---|
[4885] | 160 | protected: |
---|
| 161 | // it is all about energy |
---|
[4890] | 162 | float energy; //!< The energy stored in the weapons secondary buffers (reserve) |
---|
| 163 | float energyLoaded; //!< The energy stored in the weapons primary buffers (firewithout reload) |
---|
| 164 | float energyMax; //!< The maximal energy that can be stored in the secondary buffers (reserveMax) |
---|
| 165 | float energyLoadedMax; //!< The maximal energy that can be stored in the primary buffers |
---|
[4910] | 166 | //! @todo move this to projectile |
---|
[4890] | 167 | float minCharge; //!< The minimal energy to be loaded onto one projectile if chargeable otherwise the power consumed by one projectile |
---|
| 168 | float maxCharge; //!< The maximal energy to be loaded onto one projectile (this is only availible if chargeable is enabled) |
---|
[3573] | 169 | |
---|
[4885] | 170 | //////////// |
---|
| 171 | // PHASES // |
---|
| 172 | //////////// |
---|
| 173 | private: |
---|
[4910] | 174 | SoundSource* soundSource; //!< A SoundSource to play sound from (this is connected to the PNode of the Weapon) |
---|
| 175 | |
---|
[4885] | 176 | WeaponState currentState; //!< The State the weapon is in. |
---|
| 177 | WeaponAction requestedAction; //!< An action to try to Engage after the currentState ends. |
---|
| 178 | float stateDuration; //!< how long the state has taken until now. |
---|
| 179 | float times[WS_STATE_COUNT]; //!< Times to stay in the different States @see WeaponState. |
---|
| 180 | Animation3D* animation[WS_STATE_COUNT]; //!< Animations for all the States (you can say yourself on what part of the gun this animation acts). |
---|
| 181 | SoundBuffer* soundBuffers[WA_ACTION_COUNT]; //!< SoundBuffers for all actions @see WeaponAction. |
---|
| 182 | |
---|
[4892] | 183 | PNode emissionPoint; //!< The point, where the projectiles are emitted. (this is coppled with the Weapon by default) |
---|
[4885] | 184 | |
---|
| 185 | bool hideInactive; //!< Hides the Weapon if it is inactive |
---|
[4890] | 186 | bool chargeable; //!< if the Weapon is charcheable |
---|
[4885] | 187 | |
---|
| 188 | Projectile* projectile; //!< the projectile used for this weapon |
---|
| 189 | }; |
---|
| 190 | |
---|
[3573] | 191 | #endif /* _WEAPON_H */ |
---|