Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/orxonox/worldentities/pawns/Pawn.cc @ 9370

Last change on this file since 9370 was 9348, checked in by landauf, 12 years ago

merged branch presentation2012merge back to trunk

  • Property svn:eol-style set to native
File size: 15.3 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 *      Simon Miescher
26 *
27 */
28
29#include "Pawn.h"
30
31#include <algorithm>
32
33#include "core/CoreIncludes.h"
34#include "core/GameMode.h"
35#include "core/XMLPort.h"
36#include "network/NetworkFunction.h"
37
38#include "infos/PlayerInfo.h"
39#include "controllers/Controller.h"
40#include "gametypes/Gametype.h"
41#include "graphics/ParticleSpawner.h"
42#include "worldentities/ExplosionChunk.h"
43#include "worldentities/BigExplosion.h"
44#include "weaponsystem/WeaponSystem.h"
45#include "weaponsystem/WeaponSlot.h"
46#include "weaponsystem/WeaponPack.h"
47#include "weaponsystem/WeaponSet.h"
48
49namespace orxonox
50{
51    CreateFactory(Pawn);
52
53    Pawn::Pawn(BaseObject* creator)
54        : ControllableEntity(creator)
55        , RadarViewable(creator, static_cast<WorldEntity*>(this))
56    {
57        RegisterObject(Pawn);
58
59        this->bAlive_ = true;
60        this->bReload_ = false;
61
62        this->health_ = 0;
63        this->maxHealth_ = 0;
64        this->initialHealth_ = 0;
65
66        this->shieldHealth_ = 0;
67        this->initialShieldHealth_ = 0;
68        this->maxShieldHealth_ = 100; //otherwise shield might increase to float_max
69        this->shieldAbsorption_ = 0.5;
70
71        this->reloadRate_ = 0;
72        this->reloadWaitTime_ = 1.0f;
73        this->reloadWaitCountdown_ = 0;
74
75        this->lastHitOriginator_ = 0;
76
77        // set damage multiplier to default value 1, meaning nominal damage
78        this->damageMultiplier_ = 1;
79
80        this->spawnparticleduration_ = 3.0f;
81
82        this->aimPosition_ = Vector3::ZERO;
83
84        if (GameMode::isMaster())
85        {
86            this->weaponSystem_ = new WeaponSystem(this);
87            this->weaponSystem_->setPawn(this);
88        }
89        else
90            this->weaponSystem_ = 0;
91
92        this->setRadarObjectColour(ColourValue::Red);
93        this->setRadarObjectShape(RadarViewable::Dot);
94
95        this->registerVariables();
96
97        this->isHumanShip_ = this->hasLocalController();
98
99        this->setSyncMode(ObjectDirection::Bidirectional); // needed to synchronise e.g. aimposition
100    }
101
102    Pawn::~Pawn()
103    {
104        if (this->isInitialized())
105        {
106            if (this->weaponSystem_)
107                this->weaponSystem_->destroy();
108        }
109    }
110
111    void Pawn::XMLPort(Element& xmlelement, XMLPort::Mode mode)
112    {
113        SUPER(Pawn, XMLPort, xmlelement, mode);
114
115        XMLPortParam(Pawn, "health", setHealth, getHealth, xmlelement, mode).defaultValues(100);
116        XMLPortParam(Pawn, "maxhealth", setMaxHealth, getMaxHealth, xmlelement, mode).defaultValues(200);
117        XMLPortParam(Pawn, "initialhealth", setInitialHealth, getInitialHealth, xmlelement, mode).defaultValues(100);
118
119        XMLPortParam(Pawn, "shieldhealth", setShieldHealth, getShieldHealth, xmlelement, mode).defaultValues(0);
120        XMLPortParam(Pawn, "initialshieldhealth", setInitialShieldHealth, getInitialShieldHealth, xmlelement, mode).defaultValues(0);
121        XMLPortParam(Pawn, "maxshieldhealth", setMaxShieldHealth, getMaxShieldHealth, xmlelement, mode).defaultValues(100);
122        XMLPortParam(Pawn, "shieldabsorption", setShieldAbsorption, getShieldAbsorption, xmlelement, mode).defaultValues(0);
123
124        XMLPortParam(Pawn, "spawnparticlesource", setSpawnParticleSource, getSpawnParticleSource, xmlelement, mode);
125        XMLPortParam(Pawn, "spawnparticleduration", setSpawnParticleDuration, getSpawnParticleDuration, xmlelement, mode).defaultValues(3.0f);
126        XMLPortParam(Pawn, "explosionchunks", setExplosionChunks, getExplosionChunks, xmlelement, mode).defaultValues(7);
127
128        XMLPortObject(Pawn, WeaponSlot, "weaponslots", addWeaponSlot, getWeaponSlot, xmlelement, mode);
129        XMLPortObject(Pawn, WeaponSet, "weaponsets", addWeaponSet, getWeaponSet, xmlelement, mode);
130        XMLPortObject(Pawn, WeaponPack, "weapons", addWeaponPackXML, getWeaponPack, xmlelement, mode);
131
132        XMLPortParam(Pawn, "reloadrate", setReloadRate, getReloadRate, xmlelement, mode).defaultValues(0);
133        XMLPortParam(Pawn, "reloadwaittime", setReloadWaitTime, getReloadWaitTime, xmlelement, mode).defaultValues(1.0f);
134
135        XMLPortParam ( RadarViewable, "radarname", setRadarName, getRadarName, xmlelement, mode );
136    }
137
138    void Pawn::registerVariables()
139    {
140        registerVariable(this->bAlive_,           VariableDirection::ToClient);
141        registerVariable(this->health_,           VariableDirection::ToClient);
142        registerVariable(this->maxHealth_,        VariableDirection::ToClient);
143        registerVariable(this->shieldHealth_,     VariableDirection::ToClient);
144        registerVariable(this->maxShieldHealth_,  VariableDirection::ToClient);
145        registerVariable(this->shieldAbsorption_, VariableDirection::ToClient);
146        registerVariable(this->bReload_,          VariableDirection::ToServer);
147        registerVariable(this->aimPosition_,      VariableDirection::ToServer);  // For the moment this variable gets only transfered to the server
148    }
149
150    void Pawn::tick(float dt)
151    {
152        SUPER(Pawn, tick, dt);
153
154        this->bReload_ = false;
155
156        // TODO: use the existing timer functions instead
157        if(this->reloadWaitCountdown_ > 0)
158        {
159            this->decreaseReloadCountdownTime(dt);
160        }
161        else
162        {
163            this->addShieldHealth(this->getReloadRate() * dt);
164            this->resetReloadCountdown();
165        }
166
167        if (GameMode::isMaster())
168        {
169            if (this->health_ <= 0 && bAlive_)
170            {
171                this->fireEvent(); // Event to notify anyone who wants to know about the death.
172                this->death();
173            }
174        }
175    }
176
177    void Pawn::preDestroy()
178    {
179        // yay, multiple inheritance!
180        this->ControllableEntity::preDestroy();
181        this->PickupCarrier::preDestroy();
182    }
183
184    void Pawn::setPlayer(PlayerInfo* player)
185    {
186        ControllableEntity::setPlayer(player);
187
188        if (this->getGametype())
189            this->getGametype()->playerStartsControllingPawn(player, this);
190    }
191
192    void Pawn::removePlayer()
193    {
194        if (this->getGametype())
195            this->getGametype()->playerStopsControllingPawn(this->getPlayer(), this);
196
197        ControllableEntity::removePlayer();
198    }
199
200
201    void Pawn::setHealth(float health)
202    {
203        this->health_ = std::min(health, this->maxHealth_); //Health can't be set to a value bigger than maxHealth, otherwise it will be reduced at first hit
204    }
205
206    void Pawn::setShieldHealth(float shieldHealth)
207    {
208        this->shieldHealth_ = std::min(shieldHealth, this->maxShieldHealth_);
209    }
210
211    void Pawn::setMaxShieldHealth(float maxshieldhealth)
212    {
213        this->maxShieldHealth_ = maxshieldhealth;
214    }
215
216    void Pawn::setReloadRate(float reloadrate)
217    {
218        this->reloadRate_ = reloadrate;
219    }
220
221    void Pawn::setReloadWaitTime(float reloadwaittime)
222    {
223        this->reloadWaitTime_ = reloadwaittime;
224    }
225
226    void Pawn::decreaseReloadCountdownTime(float dt)
227    {
228        this->reloadWaitCountdown_ -= dt;
229    }
230
231    void Pawn::damage(float damage, float healthdamage, float shielddamage, Pawn* originator)
232    {
233        // Applies multiplier given by the DamageBoost Pickup.
234        if (originator)
235            damage *= originator->getDamageMultiplier();
236
237        if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
238        {
239            if (shielddamage >= this->getShieldHealth())
240            {
241                this->setShieldHealth(0);
242                this->setHealth(this->health_ - (healthdamage + damage));
243            }
244            else
245            {
246                this->setShieldHealth(this->shieldHealth_ - shielddamage);
247
248                // remove remaining shieldAbsorpton-Part of damage from shield
249                shielddamage = damage * this->shieldAbsorption_;
250                shielddamage = std::min(this->getShieldHealth(),shielddamage);
251                this->setShieldHealth(this->shieldHealth_ - shielddamage);
252
253                // set remaining damage to health
254                this->setHealth(this->health_ - (damage - shielddamage) - healthdamage);
255            }
256
257            this->lastHitOriginator_ = originator;
258        }
259    }
260
261// TODO: Still valid?
262/* HIT-Funktionen
263    Die hit-Funktionen muessen auch in src/orxonox/controllers/Controller.h angepasst werden! (Visuelle Effekte)
264
265*/
266    void Pawn::hit(Pawn* originator, const Vector3& force, float damage, float healthdamage, float shielddamage)
267    {
268        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
269        {
270            this->damage(damage, healthdamage, shielddamage, originator);
271            this->setVelocity(this->getVelocity() + force);
272        }
273    }
274
275
276    void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage, float shielddamage)
277    {
278        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
279        {
280            this->damage(damage, healthdamage, shielddamage, originator);
281
282            if ( this->getController() )
283                this->getController()->hit(originator, contactpoint, damage); // changed to damage, why shielddamage?
284        }
285    }
286
287
288    void Pawn::kill()
289    {
290        this->damage(this->health_);
291        this->death();
292    }
293
294    void Pawn::spawneffect()
295    {
296        // play spawn effect
297        if (!this->spawnparticlesource_.empty())
298        {
299            ParticleSpawner* effect = new ParticleSpawner(this->getCreator());
300            effect->setPosition(this->getPosition());
301            effect->setOrientation(this->getOrientation());
302            effect->setDestroyAfterLife(true);
303            effect->setSource(this->spawnparticlesource_);
304            effect->setLifetime(this->spawnparticleduration_);
305        }
306    }
307
308    void Pawn::death()
309    {
310        this->setHealth(1);
311        if (this->getGametype() && this->getGametype()->allowPawnDeath(this, this->lastHitOriginator_))
312        {
313            // Set bAlive_ to false and wait for PawnManager to do the destruction
314            this->bAlive_ = false;
315
316            this->setDestroyWhenPlayerLeft(false);
317
318            if (this->getGametype())
319                this->getGametype()->pawnKilled(this, this->lastHitOriginator_);
320
321            if (this->getPlayer() && this->getPlayer()->getControllableEntity() == this)
322                this->getPlayer()->stopControl();
323
324            if (GameMode::isMaster())
325            {
326//                this->deathEffect();
327                this->goWithStyle();
328            }
329        }
330    }
331    void Pawn::goWithStyle()
332    {
333        this->bAlive_ = false;
334        this->setDestroyWhenPlayerLeft(false);
335
336        BigExplosion* chunk = new BigExplosion(this->getCreator());
337        chunk->setPosition(this->getPosition());
338
339    }
340    void Pawn::deatheffect()
341    {
342        // play death effect
343        {
344            ParticleSpawner* effect = new ParticleSpawner(this->getCreator());
345            effect->setPosition(this->getPosition());
346            effect->setOrientation(this->getOrientation());
347            effect->setDestroyAfterLife(true);
348            effect->setSource("Orxonox/explosion2b");
349            effect->setLifetime(4.0f);
350        }
351        {
352            ParticleSpawner* effect = new ParticleSpawner(this->getCreator());
353            effect->setPosition(this->getPosition());
354            effect->setOrientation(this->getOrientation());
355            effect->setDestroyAfterLife(true);
356            effect->setSource("Orxonox/smoke6");
357            effect->setLifetime(4.0f);
358        }
359        {
360            ParticleSpawner* effect = new ParticleSpawner(this->getCreator());
361            effect->setPosition(this->getPosition());
362            effect->setOrientation(this->getOrientation());
363            effect->setDestroyAfterLife(true);
364            effect->setSource("Orxonox/sparks");
365            effect->setLifetime(4.0f);
366        }
367        for (unsigned int i = 0; i < this->numexplosionchunks_; ++i)
368        {
369            ExplosionChunk* chunk = new ExplosionChunk(this->getCreator());
370            chunk->setPosition(this->getPosition());
371        }
372    }
373
374    void Pawn::fired(unsigned int firemode)
375    {
376        if (this->weaponSystem_)
377            this->weaponSystem_->fire(firemode);
378    }
379
380    void Pawn::reload()
381    {
382        this->bReload_ = true;
383    }
384
385    void Pawn::postSpawn()
386    {
387        this->setHealth(this->initialHealth_);
388        if (GameMode::isMaster())
389            this->spawneffect();
390    }
391
392    /* WeaponSystem:
393    *   functions load Slot, Set, Pack from XML and make sure all parent-pointers are set.
394    *   with setWeaponPack you can not just load a Pack from XML but if a Pack already exists anywhere, you can attach it.
395    *       --> e.g. Pickup-Items
396    */
397    void Pawn::addWeaponSlot(WeaponSlot * wSlot)
398    {
399        this->attach(wSlot);
400        if (this->weaponSystem_)
401            this->weaponSystem_->addWeaponSlot(wSlot);
402    }
403
404    WeaponSlot * Pawn::getWeaponSlot(unsigned int index) const
405    {
406        if (this->weaponSystem_)
407            return this->weaponSystem_->getWeaponSlot(index);
408        else
409            return 0;
410    }
411
412    void Pawn::addWeaponSet(WeaponSet * wSet)
413    {
414        if (this->weaponSystem_)
415            this->weaponSystem_->addWeaponSet(wSet);
416    }
417
418    WeaponSet * Pawn::getWeaponSet(unsigned int index) const
419    {
420        if (this->weaponSystem_)
421            return this->weaponSystem_->getWeaponSet(index);
422        else
423            return 0;
424    }
425
426    void Pawn::addWeaponPack(WeaponPack * wPack)
427    {
428        if (this->weaponSystem_)
429        {
430            this->weaponSystem_->addWeaponPack(wPack);
431            this->addedWeaponPack(wPack);
432        }
433    }
434
435    void Pawn::addWeaponPackXML(WeaponPack * wPack)
436    {
437        if (this->weaponSystem_)
438        {
439            if (!this->weaponSystem_->addWeaponPack(wPack))
440                wPack->destroy();
441            else
442                this->addedWeaponPack(wPack);
443        }
444    }
445
446    WeaponPack * Pawn::getWeaponPack(unsigned int index) const
447    {
448        if (this->weaponSystem_)
449            return this->weaponSystem_->getWeaponPack(index);
450        else
451            return 0;
452    }
453
454    //Tell the Map (RadarViewable), if this is a playership
455    void Pawn::startLocalHumanControl()
456    {
457//        SUPER(ControllableEntity, changedPlayer());
458        ControllableEntity::startLocalHumanControl();
459        this->isHumanShip_ = true;
460    }
461
462    void Pawn::changedVisibility(void)
463    {
464        SUPER(Pawn, changedVisibility);
465
466        // enable proper radarviewability when the visibility is changed
467        this->RadarViewable::settingsChanged();
468    }
469
470}
Note: See TracBrowser for help on using the repository browser.