Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/world_entities/weapons/weapon.h @ 10356

Last change on this file since 10356 was 9869, checked in by bensch, 18 years ago

orxonox/trunk: merged the new_class_id branche back to the trunk.
merged with command:
svn merge https://svn.orxonox.net/orxonox/branches/new_class_id trunk -r9683:HEAD
no conflicts… puh..

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