Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/tgidronFS16/src/orxonox/worldentities/pawns/Pawn.h @ 11184

Last change on this file since 11184 was 11184, checked in by tgidron, 8 years ago

New Pickup + try to create ground from separate tiles

  • Property svn:eol-style set to native
File size: 10.9 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 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#ifndef _Pawn_H__
30#define _Pawn_H__
31
32#include "OrxonoxPrereqs.h"
33
34#include <string>
35#include <vector>
36#include "interfaces/PickupCarrier.h"
37#include "interfaces/RadarViewable.h"
38#include "worldentities/ControllableEntity.h"
39#include "worldentities/ExplosionPart.h"
40
41
42namespace orxonox // tolua_export
43{
44    /**
45    @brief
46        Everything in Orxonox that has a health attribute is a Pawn. After a Pawn is spawned its health is set to
47        its initial health. In every call of the Pawns tick function the game checks whether the pawns health is at
48        or below zero. If it is, the pawn gets killed.
49
50        Pawns can carry pickups and fire weapons. They can also have shields.
51
52        Notice that every Pawn is a ControllableEntity.
53    */
54
55    // tolua_export
56    class _OrxonoxExport Pawn // tolua_export
57        : public ControllableEntity, public RadarViewable, public PickupCarrier
58    { // tolua_export
59        friend class WeaponSystem;
60
61        public:
62            Pawn(Context* context);
63            virtual ~Pawn();
64
65            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
66            virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode) override;
67            virtual void tick(float dt) override;
68
69            inline bool isAlive() const
70                { return this->bAlive_; }
71
72
73            void setHealth(float health);
74            inline void addHealth(float health)
75                { this->setHealth(this->health_ + health); }
76            inline void removeHealth(float health)
77                { this->setHealth(this->health_ - health); }
78            inline float getHealth() const
79                { return this->health_; }
80
81            inline void setMaxHealth(float maxhealth)
82                { this->maxHealth_ = maxhealth; this->setHealth(this->health_); }
83            inline float getMaxHealth() const
84                { return this->maxHealth_; }
85
86            inline void setInitialHealth(float initialhealth)
87                { this->initialHealth_ = initialhealth; this->setHealth(initialhealth); }
88            inline float getInitialHealth() const
89                { return this->initialHealth_; }
90
91            void setShieldHealth(float shieldHealth);
92
93            inline float getShieldHealth()
94                { return this->shieldHealth_; }
95
96            inline void addShieldHealth(float amount)
97                { this->setShieldHealth(this->shieldHealth_ + amount); }
98
99            inline bool hasShield()
100                { return (this->getShieldHealth() > 0); }
101
102            void setMaxShieldHealth(float maxshieldhealth);
103            inline float getMaxShieldHealth() const
104                { return this->maxShieldHealth_; }
105
106            inline void setInitialShieldHealth(float initialshieldhealth)
107                { this->initialShieldHealth_ = initialshieldhealth; this->setShieldHealth(initialshieldhealth); }
108            inline float getInitialShieldHealth() const
109                { return this->initialShieldHealth_; }
110
111            inline void restoreInitialShieldHealth()
112                { this->setShieldHealth(this->initialShieldHealth_); }
113            inline void restoreMaxShieldHealth()
114                { this->setShieldHealth(this->maxShieldHealth_); }
115
116            inline void setShieldAbsorption(float shieldAbsorption)
117                { this->shieldAbsorption_ = shieldAbsorption; }
118            inline float getShieldAbsorption()
119                { return this->shieldAbsorption_; }
120
121            void setShieldRechargeRate(float shieldRechargeRate);
122            inline float getShieldRechargeRate() const
123                { return this->shieldRechargeRate_; }
124
125            void setShieldRechargeWaitTime(float shieldRechargeWaitTime);
126            inline float getShieldRechargeWaitTime() const
127                { return this->shieldRechargeWaitTime_; }
128
129            inline void resetShieldRechargeCountdown()
130                { this->shieldRechargeWaitCountdown_ = 0; }
131
132            inline void startShieldRechargeCountdown()
133                { this->shieldRechargeWaitCountdown_ = this->getShieldRechargeWaitTime(); } // TODO: Implement in Projectile.cc
134
135            void decreaseShieldRechargeCountdownTime(float dt);
136
137            /** @brief Sets the state of the pawns vulnerability. @param bVulnerable */
138            inline void setVulnerable(bool bVulnerable)
139            {
140                if (this->bVulnerable_ != bVulnerable)
141                {
142                    this->bVulnerable_ = bVulnerable;
143                    this->changedVulnerability();
144                }
145            }
146            /** @brief Returns the state of the pawns vulnerability. @return The state of the vulnerability */
147            inline const bool& isVulnerable() const { return this->bVulnerable_; }
148            /** @brief This function gets called if the vulnerability of the pawn changes. */
149            virtual void changedVulnerability();
150
151            inline ControllableEntity* getLastHitOriginator() const
152                { return this->lastHitOriginator_; }
153
154            virtual void hit(Pawn* originator, const Vector3& force, const btCollisionShape* cs, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
155            virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, const btCollisionShape* cs, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
156
157            virtual void kill();
158
159            virtual void fired(unsigned int firemode) override;
160            virtual void postSpawn();
161
162            void addExplosionPart(ExplosionPart* ePart);
163            ExplosionPart * getExplosionPart();
164
165            void addWeaponSlot(WeaponSlot * wSlot);
166            WeaponSlot * getWeaponSlot(unsigned int index) const;
167            void addWeaponSet(WeaponSet * wSet);
168            WeaponSet * getWeaponSet(unsigned int index) const;
169            void addWeaponPack(WeaponPack * wPack);
170            void addWeaponPackXML(WeaponPack * wPack);
171            WeaponPack * getWeaponPack(unsigned int index) const;
172
173            void addMunitionXML(Munition* munition);
174            Munition* getMunitionXML() const;
175           
176            Munition* getMunition(SubclassIdentifier<Munition> * identifier);
177
178            virtual void addedWeaponPack(WeaponPack* wPack) {}
179
180            inline void setSpawnParticleSource(const std::string& source)
181                { this->spawnparticlesource_ = source; }
182            inline const std::string& getSpawnParticleSource() const
183                { return this->spawnparticlesource_; }
184
185            inline void setSpawnParticleDuration(float duration)
186                { this->spawnparticleduration_ = duration; }
187            inline float getSpawnParticleDuration() const
188                { return this->spawnparticleduration_; }
189
190            inline void setExplosionChunks(unsigned int chunks)
191                { this->numexplosionchunks_ = chunks; }
192            inline unsigned int getExplosionChunks() const
193                { return this->numexplosionchunks_; }
194
195            // These are used with the Damage Boost Pickup to use the damage multiplier.
196            inline void setDamageMultiplier(float multiplier)
197                { this->damageMultiplier_ = multiplier; }
198            inline float getDamageMultiplier() const
199                { return this->damageMultiplier_; }
200
201
202            virtual void startLocalHumanControl() override;
203
204            void setAimPosition( Vector3 position )
205                { this->aimPosition_ = position; }
206            Vector3 getAimPosition()
207                { return this->aimPosition_; }
208
209            virtual const Vector3& getCarrierPosition(void) const override
210                { return this->getWorldPosition(); };
211
212            virtual void changedVisibility() override;
213
214            void setExplosionSound(const std::string& engineSound);
215            const std::string& getExplosionSound();
216
217            inline const WeaponSystem* getWeaponSystem() const
218                { return this->weaponSystem_; }
219
220            static void consoleCommand_debugDrawWeapons(bool bDraw);
221
222        protected:
223            virtual void preDestroy() override;
224
225            virtual void setPlayer(PlayerInfo* player) override;
226            virtual void removePlayer() override;
227
228            virtual void death();
229            virtual bool hasSlaves();
230            virtual Controller* getSlave();
231            virtual void goWithStyle();
232            virtual void spawneffect();
233
234            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = nullptr, const btCollisionShape* cs = nullptr);
235
236            bool bAlive_;
237            bool bVulnerable_; ///< If this is false, then the pawn may not take damage
238
239            virtual std::vector<PickupCarrier*>* getCarrierChildren(void) const override
240                { return new std::vector<PickupCarrier*>(); }
241            virtual PickupCarrier* getCarrierParent(void) const override
242                { return nullptr; }
243
244
245            float health_;
246            float maxHealth_;
247            float initialHealth_;
248
249            float shieldHealth_;
250            float maxShieldHealth_;
251            float initialShieldHealth_;
252            float shieldAbsorption_; ///< Has to be between 0 and 1
253            float shieldRechargeRate_;
254            float shieldRechargeWaitTime_;
255            float shieldRechargeWaitCountdown_;
256
257            float damageMultiplier_; ///< Used by the Damage Boost Pickup.
258
259            WeakPtr<Pawn> lastHitOriginator_;
260
261            WeaponSystem* weaponSystem_;
262
263            std::string spawnparticlesource_;
264            float spawnparticleduration_;
265            unsigned int numexplosionchunks_;
266
267            std::vector<ExplosionPart*> explosionPartList_;
268
269        private:
270            void registerVariables();
271            inline void setWeaponSystem(WeaponSystem* weaponsystem)
272                { this->weaponSystem_ = weaponsystem; }
273            void drawWeapons(bool bDraw);
274
275            Vector3 aimPosition_;
276
277            WorldSound* explosionSound_; // TODO: Does this really belong here? Maybe move it to BigExplosion?
278
279            std::vector<Model*> debugWeaponSlotModels_;
280
281    }; // tolua_export
282} // tolua_export
283
284#endif /* _Pawn_H__ */
Note: See TracBrowser for help on using the repository browser.