Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 10732 was 10650, checked in by fvultier, 9 years ago

There is now a spaceship that uses the gravity bomb. Minor documentation improvements.

  • Property svn:eol-style set to native
File size: 21.0 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#include "sound/WorldSound.h"
49
50#include "controllers/FormationController.h"
51
52namespace orxonox
53{
54    RegisterClass(Pawn);
55
56    Pawn::Pawn(Context* context)
57        : ControllableEntity(context)
58        , RadarViewable(this, static_cast<WorldEntity*>(this))
59    {
60        RegisterObject(Pawn);
61
62        this->bAlive_ = true;
63        this->bReload_ = false;
64
65        this->health_ = 0;
66        this->maxHealth_ = 0;
67        this->initialHealth_ = 0;
68
69        this->shieldHealth_ = 0;
70        this->initialShieldHealth_ = 0;
71        this->maxShieldHealth_ = 100; //otherwise shield might increase to float_max
72        this->shieldAbsorption_ = 0.5;
73
74        this->reloadRate_ = 0;
75        this->reloadWaitTime_ = 1.0f;
76        this->reloadWaitCountdown_ = 0;
77
78        this->lastHitOriginator_ = 0;
79
80        // set damage multiplier to default value 1, meaning nominal damage
81        this->damageMultiplier_ = 1;
82
83        this->spawnparticleduration_ = 3.0f;
84
85        this->aimPosition_ = Vector3::ZERO;
86
87        if (GameMode::isMaster())
88        {
89            this->weaponSystem_ = new WeaponSystem(this->getContext());
90            this->weaponSystem_->setPawn(this);
91        }
92        else
93            this->weaponSystem_ = 0;
94
95        this->setRadarObjectColour(ColourValue::Red);
96        this->setRadarObjectShape(RadarViewable::Dot);
97
98        this->registerVariables();
99
100        this->isHumanShip_ = this->hasLocalController();
101
102        this->setSyncMode(ObjectDirection::Bidirectional); // needed to synchronise e.g. aimposition
103
104        if (GameMode::isMaster())
105        {
106            this->explosionSound_ = new WorldSound(this->getContext());
107            this->explosionSound_->setVolume(1.0f);
108        }
109        else
110        {
111            this->explosionSound_ = 0;
112        }
113    }
114
115    Pawn::~Pawn()
116    {
117        if (this->isInitialized())
118        {
119            if (this->weaponSystem_)
120                this->weaponSystem_->destroy();
121        }
122    }
123
124    void Pawn::XMLPort(Element& xmlelement, XMLPort::Mode mode)
125    {
126        SUPER(Pawn, XMLPort, xmlelement, mode);
127
128        XMLPortParam(Pawn, "health", setHealth, getHealth, xmlelement, mode).defaultValues(100);
129        XMLPortParam(Pawn, "maxhealth", setMaxHealth, getMaxHealth, xmlelement, mode).defaultValues(200);
130        XMLPortParam(Pawn, "initialhealth", setInitialHealth, getInitialHealth, xmlelement, mode).defaultValues(100);
131
132        XMLPortParam(Pawn, "shieldhealth", setShieldHealth, getShieldHealth, xmlelement, mode).defaultValues(0);
133        XMLPortParam(Pawn, "initialshieldhealth", setInitialShieldHealth, getInitialShieldHealth, xmlelement, mode).defaultValues(0);
134        XMLPortParam(Pawn, "maxshieldhealth", setMaxShieldHealth, getMaxShieldHealth, xmlelement, mode).defaultValues(100);
135        XMLPortParam(Pawn, "shieldabsorption", setShieldAbsorption, getShieldAbsorption, xmlelement, mode).defaultValues(0);
136
137        XMLPortParam(Pawn, "spawnparticlesource", setSpawnParticleSource, getSpawnParticleSource, xmlelement, mode);
138        XMLPortParam(Pawn, "spawnparticleduration", setSpawnParticleDuration, getSpawnParticleDuration, xmlelement, mode).defaultValues(3.0f);
139        XMLPortParam(Pawn, "explosionchunks", setExplosionChunks, getExplosionChunks, xmlelement, mode).defaultValues(7);
140
141        XMLPortObject(Pawn, WeaponSlot, "weaponslots", addWeaponSlot, getWeaponSlot, xmlelement, mode);
142        XMLPortObject(Pawn, WeaponSet, "weaponsets", addWeaponSet, getWeaponSet, xmlelement, mode);
143        XMLPortObject(Pawn, WeaponPack, "weapons", addWeaponPackXML, getWeaponPack, xmlelement, mode);
144
145        XMLPortParam(Pawn, "reloadrate", setReloadRate, getReloadRate, xmlelement, mode).defaultValues(0);
146        XMLPortParam(Pawn, "reloadwaittime", setReloadWaitTime, getReloadWaitTime, xmlelement, mode).defaultValues(1.0f);
147
148        XMLPortParam(Pawn, "explosionSound",  setExplosionSound,  getExplosionSound,  xmlelement, mode);
149
150        XMLPortParam ( RadarViewable, "radarname", setRadarName, getRadarName, xmlelement, mode );
151    }
152
153    void Pawn::registerVariables()
154    {
155        registerVariable(this->bAlive_,           VariableDirection::ToClient);
156        registerVariable(this->health_,           VariableDirection::ToClient);
157        registerVariable(this->maxHealth_,        VariableDirection::ToClient);
158        registerVariable(this->shieldHealth_,     VariableDirection::ToClient);
159        registerVariable(this->maxShieldHealth_,  VariableDirection::ToClient);
160        registerVariable(this->shieldAbsorption_, VariableDirection::ToClient);
161        registerVariable(this->bReload_,          VariableDirection::ToServer);
162        registerVariable(this->aimPosition_,      VariableDirection::ToServer);  // For the moment this variable gets only transfered to the server
163    }
164
165    void Pawn::tick(float dt)
166    {
167        SUPER(Pawn, tick, dt);
168
169        this->bReload_ = false;
170
171        // TODO: use the existing timer functions instead
172        if(this->reloadWaitCountdown_ > 0)
173        {
174            this->decreaseReloadCountdownTime(dt);
175        }
176        else
177        {
178            this->addShieldHealth(this->getReloadRate() * dt);
179            this->resetReloadCountdown();
180        }
181
182        if (GameMode::isMaster())
183        {
184            if (this->health_ <= 0 && bAlive_)
185            {
186                this->fireEvent(); // Event to notify anyone who wants to know about the death.
187                this->death();
188            }
189        }
190    }
191
192    void Pawn::preDestroy()
193    {
194        // yay, multiple inheritance!
195        this->ControllableEntity::preDestroy();
196        this->PickupCarrier::preDestroy();
197    }
198
199    void Pawn::setPlayer(PlayerInfo* player)
200    {
201        ControllableEntity::setPlayer(player);
202
203        if (this->getGametype())
204            this->getGametype()->playerStartsControllingPawn(player, this);
205    }
206
207    void Pawn::removePlayer()
208    {
209        if (this->getGametype())
210            this->getGametype()->playerStopsControllingPawn(this->getPlayer(), this);
211
212        ControllableEntity::removePlayer();
213    }
214
215
216    void Pawn::setHealth(float health)
217    {
218        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
219    }
220
221    void Pawn::setShieldHealth(float shieldHealth)
222    {
223        this->shieldHealth_ = std::min(shieldHealth, this->maxShieldHealth_);
224    }
225
226    void Pawn::setMaxShieldHealth(float maxshieldhealth)
227    {
228        this->maxShieldHealth_ = maxshieldhealth;
229    }
230
231    void Pawn::setReloadRate(float reloadrate)
232    {
233        this->reloadRate_ = reloadrate;
234    }
235
236    void Pawn::setReloadWaitTime(float reloadwaittime)
237    {
238        this->reloadWaitTime_ = reloadwaittime;
239    }
240
241    void Pawn::decreaseReloadCountdownTime(float dt)
242    {
243        this->reloadWaitCountdown_ -= dt;
244    }
245
246    void Pawn::damage(float damage, float healthdamage, float shielddamage, Pawn* originator, const btCollisionShape* cs)
247    {
248        // Applies multiplier given by the DamageBoost Pickup.
249        if (originator)
250            damage *= originator->getDamageMultiplier();
251
252        if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
253        {
254            if (shielddamage >= this->getShieldHealth())
255            {
256                this->setShieldHealth(0);
257                this->setHealth(this->health_ - (healthdamage + damage));
258            }
259            else
260            {
261                this->setShieldHealth(this->shieldHealth_ - shielddamage);
262
263                // remove remaining shieldAbsorpton-Part of damage from shield
264                shielddamage = damage * this->shieldAbsorption_;
265                shielddamage = std::min(this->getShieldHealth(),shielddamage);
266                this->setShieldHealth(this->shieldHealth_ - shielddamage);
267
268                // set remaining damage to health
269                this->setHealth(this->health_ - (damage - shielddamage) - healthdamage);
270            }
271
272            this->lastHitOriginator_ = originator;
273        }
274    }
275
276// TODO: Still valid?
277/* HIT-Funktionen
278    Die hit-Funktionen muessen auch in src/orxonox/controllers/Controller.h angepasst werden! (Visuelle Effekte)
279
280*/
281    void Pawn::hit(Pawn* originator, const Vector3& force, const btCollisionShape* cs, float damage, float healthdamage, float shielddamage)
282    {
283        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
284        {
285            this->damage(damage, healthdamage, shielddamage, originator, cs);
286            this->setVelocity(this->getVelocity() + force);
287        }
288    }
289
290    void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, const btCollisionShape* cs, float damage, float healthdamage, float shielddamage)
291    {
292        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
293        {
294            this->damage(damage, healthdamage, shielddamage, originator, cs);
295
296            if ( this->getController() )
297                this->getController()->hit(originator, contactpoint, damage); // changed to damage, why shielddamage?
298        }
299    }
300
301    void Pawn::kill()
302    {
303        this->damage(this->health_);
304        this->death();
305    }
306
307    void Pawn::spawneffect()
308    {
309        // play spawn effect
310        if (!this->spawnparticlesource_.empty())
311        {
312            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
313            effect->setPosition(this->getPosition());
314            effect->setOrientation(this->getOrientation());
315            effect->setDestroyAfterLife(true);
316            effect->setSource(this->spawnparticlesource_);
317            effect->setLifetime(this->spawnparticleduration_);
318        }
319    }
320
321    void Pawn::death()
322    {
323        this->setHealth(1);
324        if (this->getGametype() && this->getGametype()->allowPawnDeath(this, this->lastHitOriginator_))
325        {
326            // Set bAlive_ to false and wait for destroyLater() to do the destruction
327            this->bAlive_ = false;
328            this->destroyLater();
329
330            this->setDestroyWhenPlayerLeft(false);
331
332            if (this->getGametype())
333                this->getGametype()->pawnKilled(this, this->lastHitOriginator_);
334
335            if (this->getPlayer() && this->getPlayer()->getControllableEntity() == this)
336            {
337                // Start to control a new entity if you're the master of a formation
338                if(this->hasSlaves())
339                {
340                    Controller* slave = this->getSlave();
341                    ControllableEntity* entity = slave->getControllableEntity();
342
343
344                    if(!entity->hasHumanController())
345                    {
346                        // delete the AIController // <-- TODO: delete? nothing is deleted here... should we delete the controller?
347                        slave->setControllableEntity(0);
348
349                        // set a new master within the formation
350                        orxonox_cast<FormationController*>(this->getController())->setNewMasterWithinFormation(orxonox_cast<FormationController*>(slave));
351
352                        // start to control a slave
353                        this->getPlayer()->startControl(entity);
354                    }
355                    else
356                    {
357                        this->getPlayer()->stopControl();
358                    }
359
360                }
361                else
362                {
363                    this->getPlayer()->stopControl();
364                }
365            }
366            if (GameMode::isMaster())
367            {
368                this->deatheffect();
369                this->goWithStyle();
370            }
371        }
372    }
373    void Pawn::goWithStyle()
374    {
375        this->bAlive_ = false;
376        this->setDestroyWhenPlayerLeft(false);
377
378        BigExplosion* chunk = new BigExplosion(this->getContext());
379        chunk->setPosition(this->getPosition());
380        chunk->setVelocity(this->getVelocity());
381
382        this->explosionSound_->setPosition(this->getPosition());
383        this->explosionSound_->play();
384    }
385    void Pawn::deatheffect()
386    {
387        // play death effect
388        /*{
389            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
390            effect->setPosition(this->getPosition());
391            effect->setOrientation(this->getOrientation());
392            effect->setDestroyAfterLife(true);
393            effect->setSource("Orxonox/explosion2b");
394            effect->setLifetime(4.0f);
395        }
396        {
397            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
398            effect->setPosition(this->getPosition());
399            effect->setOrientation(this->getOrientation());
400            effect->setDestroyAfterLife(true);
401            effect->setSource("Orxonox/smoke6");
402            effect->setLifetime(4.0f);
403        }
404        {
405            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
406            effect->setPosition(this->getPosition());
407            effect->setOrientation(this->getOrientation());
408            effect->setDestroyAfterLife(true);
409            effect->setSource("Orxonox/sparks");
410            effect->setLifetime(4.0f);
411        }*/
412       
413       
414        {
415            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
416            effect->setPosition(this->getPosition());
417            effect->setOrientation(this->getOrientation());
418            effect->setDestroyAfterLife(true);
419            effect->setSource("orxonox/explosion_flash2");
420            effect->setLifetime(5.0f);
421        }
422        {
423            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
424            effect->setPosition(this->getPosition());
425            effect->setOrientation(this->getOrientation());
426            effect->setDestroyAfterLife(true);
427            effect->setSource("orxonox/explosion_flame2");
428            effect->setLifetime(5.0f);
429        }
430        {
431            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
432            effect->setPosition(this->getPosition());
433            effect->setOrientation(this->getOrientation());
434            effect->setDestroyAfterLife(true);
435            effect->setSource("orxonox/explosion_shockwave2");
436            effect->scale(20);
437            effect->setLifetime(5.0f);
438        }{
439            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
440            effect->setPosition(this->getPosition());
441            effect->setOrientation(this->getOrientation());
442            effect->setDestroyAfterLife(true);
443            effect->setSource("orxonox/explosion_sparks2");
444            effect->setLifetime(5.0f);
445        }
446        {
447            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
448            effect->setPosition(this->getPosition());
449            effect->setOrientation(this->getOrientation());
450            effect->setDestroyAfterLife(true);
451            effect->setSource("orxonox/explosion_streak2");
452            effect->setLifetime(5.0f);
453        }
454        {
455            ParticleSpawner* effect = new ParticleSpawner(this->getContext());
456            effect->setPosition(this->getPosition());
457            effect->setOrientation(this->getOrientation());
458            effect->setDestroyAfterLife(true);
459            effect->setSource("orxonox/explosion_afterglow");
460            effect->scale(20);
461            effect->setLifetime(5.0f);
462        }
463       
464       
465        for (unsigned int i = 0; i < this->numexplosionchunks_; ++i)
466        {
467            ExplosionChunk* chunk = new ExplosionChunk(this->getContext());
468            chunk->setPosition(this->getPosition());
469        }
470    }
471
472    /**
473    @brief
474        Check whether the Pawn has a @ref Orxonox::WeaponSystem and fire it with the specified firemode if it has one.
475    */
476    void Pawn::fired(unsigned int firemode)
477    {
478        if (this->weaponSystem_)
479            this->weaponSystem_->fire(firemode);
480    }
481
482    void Pawn::reload()
483    {
484        this->bReload_ = true;
485    }
486
487    void Pawn::postSpawn()
488    {
489        this->setHealth(this->initialHealth_);
490        if (GameMode::isMaster())
491            this->spawneffect();
492    }
493
494    /* WeaponSystem:
495    *   functions load Slot, Set, Pack from XML and make sure all parent-pointers are set.
496    *   with setWeaponPack you can not just load a Pack from XML but if a Pack already exists anywhere, you can attach it.
497    *       --> e.g. Pickup-Items
498    */
499    void Pawn::addWeaponSlot(WeaponSlot * wSlot)
500    {
501        this->attach(wSlot);
502        if (this->weaponSystem_)
503            this->weaponSystem_->addWeaponSlot(wSlot);
504    }
505
506    WeaponSlot * Pawn::getWeaponSlot(unsigned int index) const
507    {
508        if (this->weaponSystem_)
509            return this->weaponSystem_->getWeaponSlot(index);
510        else
511            return 0;
512    }
513
514    void Pawn::addWeaponSet(WeaponSet * wSet)
515    {
516        if (this->weaponSystem_)
517            this->weaponSystem_->addWeaponSet(wSet);
518    }
519
520    WeaponSet * Pawn::getWeaponSet(unsigned int index) const
521    {
522        if (this->weaponSystem_)
523            return this->weaponSystem_->getWeaponSet(index);
524        else
525            return 0;
526    }
527
528    void Pawn::addWeaponPack(WeaponPack * wPack)
529    {
530        if (this->weaponSystem_)
531        {
532            this->weaponSystem_->addWeaponPack(wPack);
533            this->addedWeaponPack(wPack);
534        }
535    }
536
537    void Pawn::addWeaponPackXML(WeaponPack * wPack)
538    {
539        if (this->weaponSystem_)
540        {
541            if (!this->weaponSystem_->addWeaponPack(wPack))
542                wPack->destroy();
543            else
544                this->addedWeaponPack(wPack);
545        }
546    }
547
548    WeaponPack * Pawn::getWeaponPack(unsigned int index) const
549    {
550        if (this->weaponSystem_)
551            return this->weaponSystem_->getWeaponPack(index);
552        else
553            return 0;
554    }
555
556    //Tell the Map (RadarViewable), if this is a playership
557    void Pawn::startLocalHumanControl()
558    {
559//        SUPER(ControllableEntity, changedPlayer());
560        ControllableEntity::startLocalHumanControl();
561        this->isHumanShip_ = true;
562    }
563
564    void Pawn::changedVisibility(void)
565    {
566        SUPER(Pawn, changedVisibility);
567
568        // enable proper radarviewability when the visibility is changed
569        this->RadarViewable::settingsChanged();
570    }
571
572
573    // A function to check if this pawn's controller is the master of any formationcontroller
574    bool Pawn::hasSlaves()
575    {
576        for (ObjectList<FormationController>::iterator it =
577             ObjectList<FormationController>::begin();
578             it != ObjectList<FormationController>::end(); ++it )
579        {
580            // checks if the pawn's controller has a slave
581            if (this->hasHumanController() && it->getMaster() == this->getPlayer()->getController())
582                return true;
583        }
584        return false;
585    }
586
587    // A function that returns a slave of the pawn's controller
588    Controller* Pawn::getSlave(){
589        for (ObjectList<FormationController>::iterator it =
590                ObjectList<FormationController>::begin();
591                it != ObjectList<FormationController>::end(); ++it )
592        {
593            if (this->hasHumanController() && it->getMaster() == this->getPlayer()->getController())
594                return it->getController();
595        }
596        return 0;
597    }
598
599
600    void Pawn::setExplosionSound(const std::string &explosionSound)
601    {
602        if(explosionSound_ )
603            explosionSound_->setSource(explosionSound);
604        else
605            assert(0); // This should never happen, because soundpointer is only available on master
606    }
607
608    const std::string& Pawn::getExplosionSound()
609    {
610        if( explosionSound_ )
611            return explosionSound_->getSource();
612        else
613            assert(0);
614        return BLANKSTRING;
615    }
616}
Note: See TracBrowser for help on using the repository browser.