Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/orxonox/worldentities/pawns/Pawn.h @ 10901

Last change on this file since 10901 was 10437, checked in by fvultier, 10 years ago

Removed unnecessary output to console in kump minigame. Added a small description to some classes often used by PPS students: Pawn, StaticEntity, MobileEntity, ControllableEntity.

  • Property svn:eol-style set to native
File size: 9.6 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 "interfaces/PickupCarrier.h"
36#include "interfaces/RadarViewable.h"
37#include "worldentities/ControllableEntity.h"
38
39
40namespace orxonox // tolua_export
41{
42    /**
43    @brief
44        Everything in Orxonoy that has a health attribute is a Pawn. After a Pawn is spawned its health is set to
45        its initial health. In every call of the Pawns tick function the game checks whether the pawns health is at
46        or below zero. If it is, the pawn gets killed.
47
48        Pawns can carry pickups and fire weapons. The can also have shields.
49
50        Notice that every Pawn is a ControllableEntity.
51    */
52
53    // tolua_export
54    class _OrxonoxExport Pawn // tolua_export
55        : public ControllableEntity, public RadarViewable, public PickupCarrier
56    { // tolua_export
57        friend class WeaponSystem;
58
59        public:
60            Pawn(Context* context);
61            virtual ~Pawn();
62
63            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
64            virtual void tick(float dt);
65
66            inline bool isAlive() const
67                { return this->bAlive_; }
68
69
70            virtual void setHealth(float health);
71            inline void addHealth(float health)
72                { this->setHealth(this->health_ + health); }
73            inline void removeHealth(float health)
74                { this->setHealth(this->health_ - health); }
75            inline float getHealth() const
76                { return this->health_; }
77
78            inline void setMaxHealth(float maxhealth)
79                { this->maxHealth_ = maxhealth; this->setHealth(this->health_); }
80            inline float getMaxHealth() const
81                { return this->maxHealth_; }
82
83            inline void setInitialHealth(float initialhealth)
84                { this->initialHealth_ = initialhealth; this->setHealth(initialhealth); }
85            inline float getInitialHealth() const
86                { return this->initialHealth_; }
87
88            virtual void setShieldHealth(float shieldHealth);
89
90            inline float getShieldHealth()
91                { return this->shieldHealth_; }
92
93            inline void addShieldHealth(float amount)
94                { this->setShieldHealth(this->shieldHealth_ + amount); }
95
96            inline bool hasShield()
97                { return (this->getShieldHealth() > 0); }
98
99            virtual void setMaxShieldHealth(float maxshieldhealth);
100            inline float getMaxShieldHealth() const
101                { return this->maxShieldHealth_; }
102
103            inline void setInitialShieldHealth(float initialshieldhealth)
104                { this->initialShieldHealth_ = initialshieldhealth; this->setShieldHealth(initialshieldhealth); }
105            inline float getInitialShieldHealth() const
106                { return this->initialShieldHealth_; }
107
108            inline void restoreInitialShieldHealth()
109                { this->setShieldHealth(this->initialShieldHealth_); }
110            inline void restoreMaxShieldHealth()
111                { this->setShieldHealth(this->maxShieldHealth_); }
112
113            inline void setShieldAbsorption(float shieldAbsorption)
114                { this->shieldAbsorption_ = shieldAbsorption; }
115            inline float getShieldAbsorption()
116                { return this->shieldAbsorption_; }
117
118            // TODO: Rename to shieldRechargeRate
119            virtual void setReloadRate(float reloadrate);
120            inline float getReloadRate() const
121                { return this->reloadRate_; }
122
123            virtual void setReloadWaitTime(float reloadwaittime);
124            inline float getReloadWaitTime() const
125                { return this->reloadWaitTime_; }
126
127            inline void resetReloadCountdown()
128                { this->reloadWaitCountdown_ = 0; }
129
130            inline void startReloadCountdown()
131                { this->reloadWaitCountdown_ = this->getReloadWaitTime(); } // TODO: Implement in Projectile.cc
132
133            virtual void decreaseReloadCountdownTime(float dt);
134
135            inline ControllableEntity* getLastHitOriginator() const
136                { return this->lastHitOriginator_; }
137
138            //virtual void hit(Pawn* originator, const Vector3& force, float damage);
139            //virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
140            virtual void hit(Pawn* originator, const Vector3& force, const btCollisionShape* cs, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
141            virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, const btCollisionShape* cs, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
142
143            virtual void kill();
144
145            virtual void fired(unsigned int firemode);
146            virtual void reload();
147            virtual void postSpawn();
148
149            void addWeaponSlot(WeaponSlot * wSlot);
150            WeaponSlot * getWeaponSlot(unsigned int index) const;
151            void addWeaponSet(WeaponSet * wSet);
152            WeaponSet * getWeaponSet(unsigned int index) const;
153            void addWeaponPack(WeaponPack * wPack);
154            void addWeaponPackXML(WeaponPack * wPack);
155            WeaponPack * getWeaponPack(unsigned int index) const;
156
157            virtual void addedWeaponPack(WeaponPack* wPack) {}
158
159            inline void setSpawnParticleSource(const std::string& source)
160                { this->spawnparticlesource_ = source; }
161            inline const std::string& getSpawnParticleSource() const
162                { return this->spawnparticlesource_; }
163
164            inline void setSpawnParticleDuration(float duration)
165                { this->spawnparticleduration_ = duration; }
166            inline float getSpawnParticleDuration() const
167                { return this->spawnparticleduration_; }
168
169            inline void setExplosionChunks(unsigned int chunks)
170                { this->numexplosionchunks_ = chunks; }
171            inline unsigned int getExplosionChunks() const
172                { return this->numexplosionchunks_; }
173
174            // These are used with the Damage Boost Pickup to use the damage multiplier.
175            inline void setDamageMultiplier(float multiplier)
176                { this->damageMultiplier_ = multiplier; }
177            inline float getDamageMultiplier() const
178                { return this->damageMultiplier_; }
179
180
181            virtual void startLocalHumanControl();
182
183            void setAimPosition( Vector3 position )
184                { this->aimPosition_ = position; }
185            Vector3 getAimPosition()
186                { return this->aimPosition_; }
187
188            virtual const Vector3& getCarrierPosition(void) const
189                { return this->getWorldPosition(); };
190
191            virtual void changedVisibility();
192
193            void setExplosionSound(const std::string& engineSound);
194            const std::string& getExplosionSound();
195
196        protected:
197            virtual void preDestroy();
198
199            virtual void setPlayer(PlayerInfo* player);
200            virtual void removePlayer();
201
202            virtual void death();
203            virtual bool hasSlaves();
204            virtual Controller* getSlave();
205            virtual void goWithStyle();
206            virtual void deatheffect();
207            virtual void spawneffect();
208
209            //virtual void damage(float damage, Pawn* originator = 0);
210            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL, const btCollisionShape* cs = NULL);
211
212            bool bAlive_;
213
214            virtual std::vector<PickupCarrier*>* getCarrierChildren(void) const
215                { return new std::vector<PickupCarrier*>(); }
216            virtual PickupCarrier* getCarrierParent(void) const
217                { return NULL; }
218
219
220            float health_;
221            float maxHealth_;
222            float initialHealth_;
223
224            float shieldHealth_;
225            float maxShieldHealth_;
226            float initialShieldHealth_;
227            float shieldAbsorption_; ///< Has to be between 0 and 1
228            float reloadRate_;
229            float reloadWaitTime_;
230            float reloadWaitCountdown_;
231
232            float damageMultiplier_; ///< Used by the Damage Boost Pickup.
233
234            WeakPtr<Pawn> lastHitOriginator_;
235
236            WeaponSystem* weaponSystem_;
237            bool bReload_;
238
239            std::string spawnparticlesource_;
240            float spawnparticleduration_;
241            unsigned int numexplosionchunks_;
242
243        private:
244            void registerVariables();
245            inline void setWeaponSystem(WeaponSystem* weaponsystem)
246                { this->weaponSystem_ = weaponsystem; }
247
248            Vector3 aimPosition_;
249
250            WorldSound* explosionSound_; // TODO: Does this really belong here? Maybe move it to BigExplosion?
251
252    }; // tolua_export
253} // tolua_export
254
255#endif /* _Pawn_H__ */
Note: See TracBrowser for help on using the repository browser.