Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
May 25, 2011, 9:22:53 PM (14 years ago)
Author:
dafrick
Message:

Merging game immersion branch into presentation branch.

Location:
code/branches/presentation
Files:
31 edited
6 copied

Legend:

Unmodified
Added
Removed
  • code/branches/presentation/data/defaultConfig/keybindings.ini

    r8480 r8578  
    2121KeyDown="scale -1 moveFrontBack"
    2222KeyE="scale -1 rotateRoll"
    23 KeyEnd=boost
     23KeyEnd="boost"
    2424KeyEquals=
    2525KeyEscape="keyESC"
     
    119119KeySlash=
    120120KeySleep=
    121 KeySpace=boost
     121KeySpace="boost"
    122122KeyStop=
    123123KeySystemRequest="printScreen"
  • code/branches/presentation/data/levels/includes/weaponSettingsAssff.oxi

    r7845 r8578  
    2626          <HsW01 mode=0 munitionpershot=0 delay=0.125 damage=3.14159 material="Flares/point_lensflare" muzzleoffset=" 0.1, 1.6,-2" />
    2727          <HsW01 mode=0 munitionpershot=0 delay=0     damage=3.14159 material="Flares/point_lensflare" muzzleoffset="-1.6, 1.3,-2" />
    28           <LightningGun mode=1 muzzleoffset="0,0,0" damage=23 />
     28          <LightningGun mode=1 muzzleoffset="0,0,0" damage=3.14159 shielddamage=20 />
    2929        </Weapon>
    3030        <Weapon>
     
    3636          <HsW01 mode=0 munitionpershot=0 delay=0     damage=3.14159 material="Flares/point_lensflare" muzzleoffset=" 1.6, 1.3, -2.0" />
    3737          <HsW01 mode=0 munitionpershot=0 delay=0.125 damage=3.14159 material="Flares/point_lensflare" muzzleoffset="-0.1, 1.6, -2.0" />
    38           <LightningGun mode=1 muzzleoffset="0,0,0" damage=23 />
     38          <LightningGun mode=1 muzzleoffset="0,0,0" damage=3.14159 shielddamage=20 />
    3939        </Weapon>
    4040        <Weapon>
    41           <SimpleRocketFire mode=2 muzzleoffset="0,0,0" damage=50 />
    42           <RocketFire mode=3 muzzleoffset="0,0,0" damage=100 />
     41          <SimpleRocketFire mode=2 muzzleoffset="0,0,0" damage=30 shielddamage=20 />
     42          <RocketFire mode=3 muzzleoffset="0,0,0" damage=30 healthdamage=50 shielddamage=20 />
    4343        </Weapon>
    4444      </WeaponPack>
  • code/branches/presentation/data/levels/templates/spaceshipAssff.oxt

    r7845 r8578  
    1212   initialhealth     = 100
    1313
    14    primaryThrust     = 100;
    15    auxilaryThrust    = 30;
    16    rotationThrust    = 25;
     14   shieldhealth        = 30
     15   initialshieldhealth = 30
     16   maxshieldhealth     = 50
     17   shieldabsorption    = 0.8
     18   reloadrate          = 1
     19   reloadwaittime      = 1
     20
     21   primaryThrust     = 100
     22   auxilaryThrust    = 30
     23   rotationThrust    = 25
     24
     25   boostPower            = 15
     26   boostPowerRate        = 1
     27   boostRate             = 5
     28   boostCooldownDuration = 10
     29
     30   shakeFrequency = 15
     31   shakeAmplitude = 7
    1732
    1833   collisionType     = "dynamic"
  • code/branches/presentation/src/modules/weapons/projectiles/CMakeLists.txt

    r7163 r8578  
    66  Rocket.cc
    77  SimpleRocket.cc
     8  BasicProjectile.cc
    89)
  • code/branches/presentation/src/modules/weapons/projectiles/Projectile.cc

    r7284 r8578  
    2323 *      Fabian 'x3n' Landau
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    4141    CreateFactory(Projectile);
    4242
    43     Projectile::Projectile(BaseObject* creator) : MovableEntity(creator)
     43    Projectile::Projectile(BaseObject* creator) : MovableEntity(creator), BasicProjectile()
    4444    {
    4545        RegisterObject(Projectile);
    4646
    4747        this->setConfigValues();
    48         this->bDestroy_ = false;
    4948        this->owner_ = 0;
    50         this->damage_ = 15;
    5149
    5250        // Get notification about collisions
    53 
    5451        if (GameMode::isMaster())
    5552        {
     
    8481            return;
    8582
    86         if (this->bDestroy_)
     83        if (this->getBDestroy())
    8784            this->destroy(); // TODO: use a scheduler instead of deleting the object right here in tick()
    8885    }
     
    9491    }
    9592
     93    /* Calls the collidesAgainst function of BasicProjectile
     94     */
    9695    bool Projectile::collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)
    9796    {
    98         if (!this->bDestroy_ && GameMode::isMaster())
    99         {
    100             if (otherObject == this->owner_)
    101                 return false;
    102 
    103             this->bDestroy_ = true;
    104 
    105             if (this->owner_)
    106             {
    107                 {
    108                     ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
    109                     effect->setPosition(this->getPosition());
    110                     effect->setOrientation(this->getOrientation());
    111                     effect->setDestroyAfterLife(true);
    112                     effect->setSource("Orxonox/explosion3");
    113                     effect->setLifetime(2.0f);
    114                 }
    115                 {
    116                     ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
    117                     effect->setPosition(this->getPosition());
    118                     effect->setOrientation(this->getOrientation());
    119                     effect->setDestroyAfterLife(true);
    120                     effect->setSource("Orxonox/smoke4");
    121                     effect->setLifetime(3.0f);
    122                 }
    123             }
    124 
    125             Pawn* victim = orxonox_cast<Pawn*>(otherObject);
    126             if (victim)
    127                 victim->hit(this->owner_, contactPoint, this->damage_);
    128         }
    129         return false;
     97        return BasicProjectile::basicCollidesAgainst(otherObject,contactPoint,this->getOwner(),this);
    13098    }
    13199
  • code/branches/presentation/src/modules/weapons/projectiles/Projectile.h

    r5929 r8578  
    2323 *      Fabian 'x3n' Landau
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    3535#include "worldentities/MovableEntity.h"
    3636
     37#include "BasicProjectile.h"
     38
    3739namespace orxonox
    3840{
    39     class _WeaponsExport Projectile : public MovableEntity
     41    class _WeaponsExport Projectile : public MovableEntity, public BasicProjectile
    4042    {
    4143        public:
     
    4951            virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
    5052
    51             inline void setDamage(float damage)
    52                 { this->damage_ = damage; }
    53             inline float getDamage() const
    54                 { return this->damage_; }
    55 
    5653            void setOwner(Pawn* owner);
    5754            inline Pawn* getOwner() const
    5855                { return this->owner_; }
    5956
     57
    6058        private:
    6159            WeakPtr<Pawn> owner_;
    6260            float lifetime_;
    63             float damage_;
    64             bool bDestroy_;
    6561            Timer destroyTimer_;
    6662    };
  • code/branches/presentation/src/modules/weapons/projectiles/Rocket.cc

    r7848 r8578  
    2323 *      Oliver Scheuss
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    5252        Constructor. Registers the object and initializes some default values.
    5353    */
    54     Rocket::Rocket(BaseObject* creator) : ControllableEntity(creator)
     54    Rocket::Rocket(BaseObject* creator) : ControllableEntity(creator), BasicProjectile()
    5555    {
    5656        RegisterObject(Rocket);// - register the Rocket class to the core
    5757
    5858        this->localAngularVelocity_ = 0;
    59         this->bDestroy_ = false;
    6059        this->lifetime_ = 100;
    6160
     
    146145    {
    147146        this->owner_ = owner;
    148         this->player_ = this->owner_->getPlayer();
    149         this->owner_->getPlayer()->startTemporaryControl(this);
     147        this->player_ = this->getOwner()->getPlayer();
     148        this->getOwner()->getPlayer()->startTemporaryControl(this);
    150149
    151150        if( GameMode::isMaster() )
     
    175174        if( GameMode::isMaster() )
    176175        {
    177             if( this->bDestroy_ )
     176            if( this->getBDestroy() )
    178177                this->destroy();
    179178
     
    181180    }
    182181
     182    /* Calls the collidesAgainst function of BasicProjectile
     183     */
    183184    bool Rocket::collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)
    184185    {
    185         if (!this->bDestroy_ && GameMode::isMaster())
    186         {
    187             if (otherObject == this->owner_)
    188                 return false;
    189 
    190             this->bDestroy_ = true;
    191 
    192             if (this->owner_)
    193             {
    194                 {
    195                     ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
    196                     effect->setPosition(this->getPosition());
    197                     effect->setOrientation(this->getOrientation());
    198                     effect->setDestroyAfterLife(true);
    199                     effect->setSource("Orxonox/explosion4");
    200                     effect->setLifetime(2.0f);
    201                 }
    202 
    203                 {
    204                     ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
    205                     effect->setPosition(this->getPosition());
    206                     effect->setOrientation(this->getOrientation());
    207                     effect->setDestroyAfterLife(true);
    208                     effect->setSource("Orxonox/smoke4");
    209                     effect->setLifetime(3.0f);
    210                 }
    211             }
    212 
    213             Pawn* victim = orxonox_cast<Pawn*>(otherObject);
    214             if (victim)
    215                 victim->hit(this->owner_, contactPoint, this->damage_);
    216 //             this->destroy();
    217         }
    218         return false;
     186        return BasicProjectile::basicCollidesAgainst(otherObject,contactPoint,this->getOwner(),this);
    219187    }
    220188
     
    233201    void Rocket::fired(unsigned int firemode)
    234202    {
    235 //         if (this->owner_)
    236 //         {
    237             this->destroy();
    238 //         }
     203        this->destroy();
    239204    }
    240205
     
    242207    {
    243208        ParticleSpawner *effect1, *effect2;
    244         if( this->owner_ )
    245         {
    246             effect1 = new ParticleSpawner(this->owner_->getCreator());
    247             effect2 = new ParticleSpawner(this->owner_->getCreator());
     209        if( this->getOwner() )
     210        {
     211            effect1 = new ParticleSpawner(this->getOwner()->getCreator());
     212            effect2 = new ParticleSpawner(this->getOwner()->getCreator());
    248213        }
    249214        else
  • code/branches/presentation/src/modules/weapons/projectiles/Rocket.h

    r7163 r8578  
    2323 *      Oliver Scheuss
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    3434#include "tools/Timer.h"
    3535#include "worldentities/ControllableEntity.h"
     36
     37#include "BasicProjectile.h"
    3638
    3739namespace orxonox
     
    4648        Oli Scheuss
    4749    */
    48     class _WeaponsExport Rocket : public ControllableEntity
     50    class _WeaponsExport Rocket : public ControllableEntity, public BasicProjectile
    4951    {
    5052        public:
     
    109111                { return this->owner_; }
    110112
    111             inline void setDamage(float damage)
    112                 { this->damage_ = damage; }
    113             inline float getDamage() const
    114                 { return this->damage_; }
    115113            virtual void fired(unsigned int firemode);
    116114
     
    118116            WeakPtr<Pawn> owner_;
    119117            Vector3 localAngularVelocity_;
    120             float damage_;
    121             bool bDestroy_;
    122118
    123119            WeakPtr<PlayerInfo> player_;
  • code/branches/presentation/src/modules/weapons/projectiles/SimpleRocket.cc

    r7163 r8578  
    2323 *      Oliver Scheuss
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    4848    CreateFactory(SimpleRocket);
    4949
    50     SimpleRocket::SimpleRocket(BaseObject* creator) : ControllableEntity(creator)
     50    SimpleRocket::SimpleRocket(BaseObject* creator) : ControllableEntity(creator), BasicProjectile()
    5151    {
    5252        RegisterObject(SimpleRocket);// - register the SimpleRocket class to the core
    5353
    5454        this->localAngularVelocity_ = 0;
    55         this->bDestroy_ = false;
    5655        this->lifetime_ = 120;
    5756
    5857        this->setMass(15);
    59         COUT(4) << "simplerocket constructed\n";
     58//        COUT(4) << "simplerocket constructed\n";
    6059
    6160        if (GameMode::isMaster())
     
    115114                this->disableFire();
    116115
    117             if( this->bDestroy_ )
     116            if( this->getBDestroy() )
    118117                this->destroy();
    119118        }
     
    159158    {
    160159        this->owner_ = owner;
    161         this->player_ = this->owner_->getPlayer();
    162     }
    163 
    164 
    165 
    166 
     160        this->player_ = this->getOwner()->getPlayer();
     161    }
     162
     163
     164    /* Calls the collidesAgainst function of BasicProjectile
     165     */
    167166    bool SimpleRocket::collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)
    168167    {
    169         if (!this->bDestroy_ && GameMode::isMaster())
    170         {
    171             if (otherObject == this->owner_)
    172                 return false;
    173 
    174             this->bDestroy_ = true;
    175 
    176             if (this->owner_)
    177             {
    178                 {
    179                     ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
    180                     effect->setPosition(this->getPosition());
    181                     effect->setOrientation(this->getOrientation());
    182                     effect->setDestroyAfterLife(true);
    183                     effect->setSource("Orxonox/explosion4");
    184                     effect->setLifetime(2.0f);
    185                 }
    186 
    187                 {
    188                     ParticleSpawner* effect = new ParticleSpawner(this->owner_->getCreator());
    189                     effect->setPosition(this->getPosition());
    190                     effect->setOrientation(this->getOrientation());
    191                     effect->setDestroyAfterLife(true);
    192                     effect->setSource("Orxonox/smoke4");
    193                     effect->setLifetime(3.0f);
    194                 }
    195             }
    196 
    197             float dmg = this->damage_;
    198 //             if (this->owner_)
    199 //                 dmg = this->owner_->getPickups().processModifiers(ModifierType::Damage, dmg, false);
    200 
    201             Pawn* victim = orxonox_cast<Pawn*>(otherObject);
    202             if (victim)
    203                 victim->hit(this->owner_, contactPoint, dmg);
    204         }
    205         return false;
     168        return BasicProjectile::basicCollidesAgainst(otherObject,contactPoint,this->getOwner(),this);
    206169    }
    207170
  • code/branches/presentation/src/modules/weapons/projectiles/SimpleRocket.h

    r7163 r8578  
    2323 *      Oliver Scheuss
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    3636#include "graphics/ParticleSpawner.h"
    3737
     38#include "BasicProjectile.h"
     39
    3840namespace orxonox
    3941{
     
    4648       Gabriel Nadler (Original file: Oli Scheuss)
    4749    */
    48     class _WeaponsExport SimpleRocket : public ControllableEntity
     50    class _WeaponsExport SimpleRocket : public ControllableEntity, public BasicProjectile
    4951    {
    5052        public:
     
    111113            inline Pawn* getOwner() const
    112114                { return this->owner_; }
     115
    113116            inline bool hasFuel() const
    114117            { return this->fuel_; }
    115 
    116             inline void setDamage(float damage)
    117                 { this->damage_ = damage; }
    118             inline float getDamage() const
    119                 { return this->damage_; }
    120118
    121119
     
    123121            WeakPtr<Pawn> owner_;
    124122            Vector3 localAngularVelocity_;
    125             float damage_;
    126             bool bDestroy_;
    127123            bool fuel_; //!< Bool is true while the rocket "has fuel"
    128124
  • code/branches/presentation/src/modules/weapons/weaponmodes/EnergyDrink.cc

    r7284 r8578  
    2323 *      Hagen Seifert
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    5050
    5151        this->reloadTime_ = 0.25;
    52         this->damage_ = 15;
     52        this->damage_ = 0; //default 15
    5353        this->speed_ = 2500;
    5454        this->delay_ = 0;
     
    9797    }
    9898
     99    /* Creates the projectile object, sets its properties to the EnergyDrink properties, calls muendungsfeuer()
     100     */
    99101    void EnergyDrink::shot()
    100102    {
     
    112114        projectile->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
    113115        projectile->setDamage(this->getDamage());
     116        projectile->setShieldDamage(this->getShieldDamage());
     117        projectile->setHealthDamage(this->getHealthDamage());
    114118
    115119        EnergyDrink::muendungsfeuer();
  • code/branches/presentation/src/modules/weapons/weaponmodes/FusionFire.cc

    r6732 r8578  
    2323 *      Martin Polak
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    4848        this->reloadTime_ = 1.0;
    4949        this->bParallelReload_ = false;
    50         this->damage_ = 40;
     50        this->damage_ = 0; //default 40
    5151        this->speed_ = 1250;
    5252
     
    5454    }
    5555
     56    /* Creates the projectile (BillboardProjectile) object, sets its properties to the FusionFire properties
     57     */
    5658    void FusionFire::fire()
    5759    {
     
    6567        projectile->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
    6668        projectile->setDamage(this->getDamage());
     69        projectile->setShieldDamage(this->getShieldDamage());
     70        projectile->setHealthDamage(this->getHealthDamage());
     71
    6772        projectile->setColour(ColourValue(1.0f, 0.7f, 0.3f, 1.0f));
    6873    }
  • code/branches/presentation/src/modules/weapons/weaponmodes/HsW01.cc

    r7284 r8578  
    2323 *      Hagen Seifert
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    5151
    5252        this->reloadTime_ = 0.25;
    53         this->damage_ = 15;
     53        this->damage_ = 0; //default 15
    5454        this->speed_ = 2500;
    5555        this->delay_ = 0;
     
    109109    }
    110110
     111    /* Creates the projectile object, sets its properties to the HsW01 properties, calls muendungsfeuer()
     112     */
    111113    void HsW01::shot()
    112114    {
     
    126128        projectile->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
    127129        projectile->setDamage(this->getDamage());
     130        projectile->setShieldDamage(this->getShieldDamage());
     131        projectile->setHealthDamage(this->getHealthDamage());
    128132
    129133        HsW01::muendungsfeuer();
  • code/branches/presentation/src/modules/weapons/weaponmodes/LaserFire.cc

    r6732 r8578  
    2323 *      Martin Polak
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    4545
    4646        this->reloadTime_ = 0.25;
    47         this->damage_ = 15;
     47        this->damage_ = 0; //default 15
    4848        this->speed_ = 1250;
    4949
     
    5151    }
    5252
     53    /* Creates the projectile object, sets its properties to the LaserFire properties
     54     */
    5355    void LaserFire::fire()
    5456    {
     
    6163        projectile->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
    6264        projectile->setDamage(this->getDamage());
     65        projectile->setShieldDamage(this->getShieldDamage());
     66        projectile->setHealthDamage(this->getHealthDamage());
    6367    }
    6468}
  • code/branches/presentation/src/modules/weapons/weaponmodes/LightningGun.cc

    r6732 r8578  
    2323 *      Joel Smely
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    4545
    4646        this->reloadTime_ = 1;
    47         this->damage_ = 100;
     47        this->damage_ = 0; //default 100
    4848        this->speed_ = 150;
    4949
     
    5656    }
    5757
     58    /* Creates the projectile (LightningGunProjectile) object, sets its properties to the LightningGun properties
     59     */
    5860    void LightningGun::fire()
    5961    {
     
    6971        projectile->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
    7072        projectile->setDamage(this->getDamage());
     73        projectile->setShieldDamage(this->getShieldDamage());
     74        projectile->setHealthDamage(this->getHealthDamage());
    7175    }
    7276}
  • code/branches/presentation/src/modules/weapons/weaponmodes/RocketFire.cc

    r7846 r8578  
    2323 *      Oliver Scheuss
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    4848        this->reloadTime_ = 0.20f;
    4949        this->bParallelReload_ = false;
    50         this->damage_ = 100;
     50        this->damage_ = 0;
    5151        this->speed_ = 500;
    5252
     
    5959    }
    6060
     61    /* Creates the Rocket object, sets its properties to the RocketFire properties
     62     */
    6163    void RocketFire::fire()
    6264    {
     
    7173        rocket->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
    7274        rocket->setDamage(this->getDamage());
     75        rocket->setShieldDamage(this->getShieldDamage());
     76        rocket->setHealthDamage(this->getHealthDamage());
    7377    }
    7478}
  • code/branches/presentation/src/modules/weapons/weaponmodes/SimpleRocketFire.cc

    r7846 r8578  
    2323 *      Oliver Scheuss
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    5050        this->reloadTime_ = 1;
    5151        this->bParallelReload_ = false;
    52         this->damage_ = 100;
     52        this->damage_ = 0;
    5353        this->speed_ = 500;
    5454
     
    6262    }
    6363
     64    /* Creates the Rocket (RocketController) object, sets its properties to the SimpleRocketFire properties, sets target
     65     */
    6466    void SimpleRocketFire::fire()
    6567    {
     
    7173        rocket->setVelocity(this->getMuzzleDirection()*this->speed_);
    7274        rocket->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
     75
    7376        rocket->setDamage(this->damage_);
     77        rocket->setShieldDamage(this->getShieldDamage());
     78        rocket->setHealthDamage(this->getHealthDamage());
     79
    7480        WorldEntity* pawnn=static_cast<ControllableEntity*>(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn())->getTarget();
    7581        if (pawnn) con->setTarget(pawnn);
  • code/branches/presentation/src/orxonox/controllers/Controller.h

    r6417 r8578  
    5252            virtual inline void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage) {};
    5353
     54/* Override needed for different visual effects (e.g. in "NewHumanController.cc") depending on
     55   the DIFFERENT AMOUNT OF DAMAGE done to the shield and to the health of "victim" (see Projectile.cc, Pawn.cc)
     56
     57//            virtual inline void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage, float shielddamage) {};
     58*/
     59
    5460            void setGodMode( bool mode ){ this->bGodMode_ = mode; }
    5561            bool getGodMode(){ return this->bGodMode_; }
  • code/branches/presentation/src/orxonox/controllers/HumanController.cc

    r8079 r8578  
    4242    extern const std::string __CC_fire_name = "fire";
    4343    extern const std::string __CC_suicide_name = "suicide";
     44    const std::string __CC_boost_name = "boost";
    4445
    4546    SetConsoleCommand("HumanController", "moveFrontBack",          &HumanController::moveFrontBack ).addShortcut().setAsInputCommand();
     
    5152    SetConsoleCommand("HumanController", __CC_fire_name,           &HumanController::fire          ).addShortcut().keybindMode(KeybindMode::OnHold);
    5253    SetConsoleCommand("HumanController", "reload",                 &HumanController::reload        ).addShortcut();
    53     SetConsoleCommand("HumanController", "boost",                  &HumanController::boost         ).addShortcut().keybindMode(KeybindMode::OnHold);
     54    SetConsoleCommand("HumanController", __CC_boost_name,          &HumanController::keepBoost     ).addShortcut().keybindMode(KeybindMode::OnHold);
    5455    SetConsoleCommand("HumanController", "greet",                  &HumanController::greet         ).addShortcut();
    5556    SetConsoleCommand("HumanController", "switchCamera",           &HumanController::switchCamera  ).addShortcut();
     
    6667
    6768    HumanController* HumanController::localController_s = 0;
     69    /*static*/ const float HumanController::BOOSTING_TIME = 0.1f;
    6870
    6971    HumanController::HumanController(BaseObject* creator) : Controller(creator)
     
    7173        RegisterObject(HumanController);
    7274
    73         controlPaused_ = false;
     75        this->controlPaused_ = false;
     76        this->boosting_ = false;
    7477
    7578        HumanController::localController_s = this;
     79        this->boostingTimeout_.setTimer(HumanController::BOOSTING_TIME, false, createExecutor(createFunctor(&HumanController::terminateBoosting, this)));
     80        this->boostingTimeout_.stopTimer();
    7681    }
    7782
     
    163168    }
    164169
    165     void HumanController::boost()
    166     {
    167         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
    168             HumanController::localController_s->controllableEntity_->boost();
     170    /**
     171    @brief
     172        Static method,keeps boosting.
     173    */
     174    /*static*/ void HumanController::keepBoost()
     175    {
     176        if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
     177            HumanController::localController_s->keepBoosting();
     178    }
     179   
     180    /**
     181    @brief
     182        Starts, or keeps the boosting mode.
     183        Resets the boosting timeout and ells the ControllableEntity to boost (or not boost anymore).
     184    */
     185    void HumanController::keepBoosting(void)
     186    {
     187        if(this->boostingTimeout_.isActive())
     188        {
     189            this->boostingTimeout_.stopTimer();
     190            this->boostingTimeout_.startTimer();
     191        }
     192        else
     193        {
     194            this->boosting_ = true;
     195            this->boostingTimeout_.startTimer();
     196           
     197            this->controllableEntity_->boost(this->boosting_);
     198            COUT(4) << "Start boosting" << endl;
     199        }
     200    }
     201
     202    /**
     203    @brief
     204        Terminates the boosting mode.
     205    */
     206    void HumanController::terminateBoosting(void)
     207    {
     208        this->boosting_ = false;
     209        this->boostingTimeout_.stopTimer();
     210
     211        this->controllableEntity_->boost(this->boosting_);
     212        COUT(4) << "Stop boosting" << endl;
    169213    }
    170214
  • code/branches/presentation/src/orxonox/controllers/HumanController.h

    r8079 r8578  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "tools/Timer.h"
    3435#include "tools/interfaces/Tickable.h"
    3536#include "Controller.h"
     
    6465            static void reload();
    6566
    66             static void boost();
     67            static void keepBoost(); // Static method, keeps boosting.
     68            /**
     69            @brief Check whether the HumanController is in boosting mode.
     70            @return Returns true if it is, false if not.
     71            */
     72            inline bool isBoosting(void)
     73                { return this->boosting_; }
     74            void keepBoosting(void);
     75            void terminateBoosting(void);
     76           
    6777            static void greet();
    6878            static void switchCamera();
     
    92102            static HumanController* localController_s;
    93103            bool controlPaused_;
     104       
     105        private:
     106            bool boosting_; // Whether the HumanController is in boosting mode or not.
     107            Timer boostingTimeout_; // A timer to check whether the player is no longer boosting.
     108            static const float BOOSTING_TIME; // The time after it is checked, whether the player is no longer boosting.
     109
    94110    }; // tolua_export
    95111} // tolua_export
  • code/branches/presentation/src/orxonox/graphics/Camera.cc

    r8079 r8578  
    4848    CreateFactory(Camera);
    4949
    50     Camera::Camera(BaseObject* creator) : StaticEntity(creator)
     50    Camera::Camera(BaseObject* creator) : MovableEntity(creator)
    5151    {
    5252        RegisterObject(Camera);
  • code/branches/presentation/src/orxonox/graphics/Camera.h

    r8079 r8578  
    3636#include "tools/interfaces/Tickable.h"
    3737#include "tools/interfaces/TimeFactorListener.h"
    38 #include "worldentities/StaticEntity.h"
     38#include "worldentities/MovableEntity.h"
    3939
    4040namespace orxonox
    4141{
    42     class _OrxonoxExport Camera : public StaticEntity, public Tickable, public TimeFactorListener, public WindowEventListener
     42
     43    class _OrxonoxExport Camera : public MovableEntity, public TimeFactorListener, public WindowEventListener
    4344    {
    4445        friend class CameraManager;
  • code/branches/presentation/src/orxonox/items/Engine.cc

    r8079 r8578  
    204204        this->ship_->setAcceleration(this->ship_->getOrientation() * (acceleration*this->getSpeedMultiply()+Vector3(0,0,-this->getSpeedAdd())));
    205205
    206         if (!this->ship_->getPermanentBoost())
    207             this->ship_->setBoost(false);
    208206        this->ship_->setSteeringDirection(Vector3::ZERO);
    209207
  • code/branches/presentation/src/orxonox/weaponsystem/WeaponMode.cc

    r7847 r8578  
    6666
    6767        this->damage_ = 0;
     68        this->healthdamage_ = 0;
     69        this->shielddamage_ = 0;
    6870
    6971        this->muzzleOffset_ = Vector3::ZERO;
     
    106108
    107109        XMLPortParam(WeaponMode, "damage",           setDamage,           getDamage,           xmlelement, mode);
     110        XMLPortParam(WeaponMode, "healthdamage",     setHealthDamage,     getHealthDamage,     xmlelement, mode);
     111        XMLPortParam(WeaponMode, "shielddamage",     setShieldDamage,     getShieldDamage,     xmlelement, mode);
    108112        XMLPortParam(WeaponMode, "muzzleoffset",     setMuzzleOffset,     getMuzzleOffset,     xmlelement, mode);
    109113    }
  • code/branches/presentation/src/orxonox/weaponsystem/WeaponMode.h

    r7163 r8578  
    104104            // Fire
    105105            inline void setDamage(float damage)
    106                 { this->damage_ = damage; }
     106                { this->damage_ = damage;}
    107107            inline float getDamage() const
    108108                { return this->damage_; }
     109            inline void setHealthDamage(float healthdamage)
     110                { this->healthdamage_ = healthdamage; }
     111            inline float getHealthDamage() const
     112                { return this->healthdamage_; }
     113
     114            inline void setShieldDamage(float shielddamage)
     115                { this->shielddamage_ = shielddamage;}
     116            inline float getShieldDamage() const
     117                { return this->shielddamage_; }
    109118
    110119            inline void setMuzzleOffset(const Vector3& offset)
     
    146155
    147156            float damage_;
     157            float healthdamage_;
     158            float shielddamage_;
    148159            Vector3 muzzleOffset_;
    149160
  • code/branches/presentation/src/orxonox/worldentities/ControllableEntity.cc

    r7892 r8578  
    8484        this->client_angular_velocity_ = Vector3::ZERO;
    8585
    86 
    8786        this->setConfigValues();
    8887        this->setPriority( Priority::VeryHigh );
  • code/branches/presentation/src/orxonox/worldentities/ControllableEntity.h

    r7889 r8578  
    9393            virtual void reload() {}
    9494
    95             virtual void boost() {}
     95            /**
     96            @brief Tells the ControllableEntity to either start or stop boosting.
     97                   This doesn't mean, that the ControllableEntity will do so, there might be additional restrictions on boosting, but if it can, then it will.
     98            @param bBoost If true the ControllableEntity is told to start boosting, if false it is told to stop.
     99            */
     100            virtual void boost(bool bBoost) {}
     101           
    96102            virtual void greet() {}
    97103            virtual void switchCamera();
  • code/branches/presentation/src/orxonox/worldentities/pawns/Pawn.cc

    r8351 r8578  
    2323 *      Fabian 'x3n' Landau
    2424 *   Co-authors:
    25  *      ...
     25 *      simonmie
    2626 *
    2727 */
     
    6464        this->maxHealth_ = 0;
    6565        this->initialHealth_ = 0;
     66
    6667        this->shieldHealth_ = 0;
     68        this->initialShieldHealth_ = 0;
     69        this->maxShieldHealth_ = 100; //otherwise shield might increase to float_max
    6770        this->shieldAbsorption_ = 0.5;
     71
     72        this->reloadRate_ = 0;
     73        this->reloadWaitTime_ = 1.0f;
     74        this->reloadWaitCountdown_ = 0;
    6875
    6976        this->lastHitOriginator_ = 0;
     
    109116
    110117        XMLPortParam(Pawn, "shieldhealth", setShieldHealth, getShieldHealth, xmlelement, mode).defaultValues(0);
     118        XMLPortParam(Pawn, "initialshieldhealth", setInitialShieldHealth, getInitialShieldHealth, xmlelement, mode).defaultValues(0);
     119        XMLPortParam(Pawn, "maxshieldhealth", setMaxShieldHealth, getMaxShieldHealth, xmlelement, mode).defaultValues(100);
    111120        XMLPortParam(Pawn, "shieldabsorption", setShieldAbsorption, getShieldAbsorption, xmlelement, mode).defaultValues(0);
    112121
     
    118127        XMLPortObject(Pawn, WeaponSet, "weaponsets", addWeaponSet, getWeaponSet, xmlelement, mode);
    119128        XMLPortObject(Pawn, WeaponPack, "weapons", addWeaponPackXML, getWeaponPack, xmlelement, mode);
     129
     130        XMLPortParam(Pawn, "reloadrate", setReloadRate, getReloadRate, xmlelement, mode).defaultValues(0);
     131        XMLPortParam(Pawn, "reloadwaittime", setReloadWaitTime, getReloadWaitTime, xmlelement, mode).defaultValues(1.0f);
    120132    }
    121133
     
    124136        registerVariable(this->bAlive_,           VariableDirection::ToClient);
    125137        registerVariable(this->health_,           VariableDirection::ToClient);
    126         registerVariable(this->initialHealth_,    VariableDirection::ToClient);
     138        registerVariable(this->maxHealth_,        VariableDirection::ToClient);
    127139        registerVariable(this->shieldHealth_,     VariableDirection::ToClient);
     140        registerVariable(this->maxShieldHealth_,  VariableDirection::ToClient);
    128141        registerVariable(this->shieldAbsorption_, VariableDirection::ToClient);
    129142        registerVariable(this->bReload_,          VariableDirection::ToServer);
     
    137150        this->bReload_ = false;
    138151
     152        // TODO: use the existing timer functions instead
     153        if(this->reloadWaitCountdown_ > 0)
     154        {
     155            this->decreaseReloadCountdownTime(dt);
     156        }
     157        else
     158        {
     159            this->addShieldHealth(this->getReloadRate() * dt);
     160            this->resetReloadCountdown();
     161        }
     162
    139163        if (GameMode::isMaster())
     164        {
    140165            if (this->health_ <= 0 && bAlive_)
    141166            {
    142                 this->fireEvent(); // Event to notify anyone who want's to know about the death.
     167                this->fireEvent(); // Event to notify anyone who wants to know about the death.
    143168                this->death();
    144169            }
     170        }
    145171    }
    146172
     
    168194    }
    169195
     196
    170197    void Pawn::setHealth(float health)
    171198    {
    172         this->health_ = std::min(health, this->maxHealth_);
    173     }
    174 
    175     void Pawn::damage(float damage, Pawn* originator)
     199        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
     200    }
     201
     202    void Pawn::setShieldHealth(float shieldHealth)
     203    {
     204        this->shieldHealth_ = std::min(shieldHealth, this->maxShieldHealth_);
     205    }
     206
     207    void Pawn::setMaxShieldHealth(float maxshieldhealth)
     208    {
     209        this->maxShieldHealth_ = maxshieldhealth;
     210    }
     211
     212    void Pawn::setReloadRate(float reloadrate)
     213    {
     214        this->reloadRate_ = reloadrate;
     215    }
     216
     217    void Pawn::setReloadWaitTime(float reloadwaittime)
     218    {
     219        this->reloadWaitTime_ = reloadwaittime;
     220    }
     221
     222    void Pawn::decreaseReloadCountdownTime(float dt)
     223    {
     224        this->reloadWaitCountdown_ -= dt;
     225    }
     226
     227    void Pawn::damage(float damage, float healthdamage, float shielddamage, Pawn* originator)
    176228    {
    177229        if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
    178230        {
    179             //share the dealt damage to the shield and the Pawn.
    180             float shielddamage = damage*this->shieldAbsorption_;
    181             float healthdamage = damage*(1-this->shieldAbsorption_);
    182 
    183             // In case the shield can not take all the shield damage.
    184             if (shielddamage > this->getShieldHealth())
     231            if (shielddamage >= this->getShieldHealth())
    185232            {
    186                 healthdamage += shielddamage-this->getShieldHealth();
    187233                this->setShieldHealth(0);
     234                this->setHealth(this->health_ - (healthdamage + damage));
    188235            }
    189 
    190             this->setHealth(this->health_ - healthdamage);
    191 
    192             if (this->getShieldHealth() > 0)
     236            else
    193237            {
    194238                this->setShieldHealth(this->shieldHealth_ - shielddamage);
     239
     240                // remove remaining shieldAbsorpton-Part of damage from shield
     241                shielddamage = damage * this->shieldAbsorption_;
     242                shielddamage = std::min(this->getShieldHealth(),shielddamage);
     243                this->setShieldHealth(this->shieldHealth_ - shielddamage);
     244
     245                // set remaining damage to health
     246                this->setHealth(this->health_ - (damage - shielddamage) - healthdamage);
    195247            }
    196248
    197249            this->lastHitOriginator_ = originator;
    198 
    199             // play damage effect
    200         }
    201     }
    202 
    203     void Pawn::hit(Pawn* originator, const Vector3& force, float damage)
     250        }
     251    }
     252
     253// TODO: Still valid?
     254/* HIT-Funktionen
     255    Die hit-Funktionen muessen auch in src/orxonox/controllers/Controller.h angepasst werden! (Visuelle Effekte)
     256
     257*/
     258
     259    void Pawn::hit(Pawn* originator, const Vector3& force, float damage, float healthdamage, float shielddamage)
    204260    {
    205261        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
    206262        {
    207             this->damage(damage, originator);
     263            this->damage(damage, healthdamage, shielddamage, originator);
    208264            this->setVelocity(this->getVelocity() + force);
    209 
    210             // play hit effect
    211         }
    212     }
    213 
    214     void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage)
     265        }
     266    }
     267
     268
     269    void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage, float shielddamage)
    215270    {
    216271        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
    217272        {
    218             this->damage(damage, originator);
     273            this->damage(damage, healthdamage, shielddamage, originator);
    219274
    220275            if ( this->getController() )
    221                 this->getController()->hit(originator, contactpoint, damage);
    222 
    223             // play hit effect
    224         }
    225     }
     276                this->getController()->hit(originator, contactpoint, damage); // changed to damage, why shielddamage?
     277        }
     278    }
     279
    226280
    227281    void Pawn::kill()
  • code/branches/presentation/src/orxonox/worldentities/pawns/Pawn.h

    r7889 r8578  
    7272                { return this->initialHealth_; }
    7373
    74             inline void setShieldHealth(float shieldHealth)
    75             { this->shieldHealth_ = shieldHealth; }
     74            virtual void setShieldHealth(float shieldHealth);
     75
    7676            inline float getShieldHealth()
    7777            { return this->shieldHealth_; }
     78
     79            inline void addShieldHealth(float amount)
     80            { this->setShieldHealth(this->shieldHealth_ + amount); }
     81
     82            inline bool hasShield()
     83            { return (this->getShieldHealth() > 0); }
     84
     85            virtual void setMaxShieldHealth(float maxshieldhealth);
     86            inline float getMaxShieldHealth() const
     87                { return this->maxShieldHealth_; }
     88
     89            inline void setInitialShieldHealth(float initialshieldhealth)
     90                { this->initialShieldHealth_ = initialshieldhealth; this->setShieldHealth(initialshieldhealth); }
     91            inline float getInitialShieldHealth() const
     92                { return this->initialShieldHealth_; }
     93
     94            inline void restoreInitialShieldHealth()
     95                { this->setShieldHealth(this->initialShieldHealth_); }
     96            inline void restoreMaxShieldHealth()
     97                { this->setShieldHealth(this->maxShieldHealth_); }
    7898
    7999            inline void setShieldAbsorption(float shieldAbsorption)
     
    82102            { return this->shieldAbsorption_; }
    83103
     104            // TODO: Rename to shieldRechargeRate
     105            virtual void setReloadRate(float reloadrate);
     106            inline float getReloadRate() const
     107                { return this->reloadRate_; }
     108
     109            virtual void setReloadWaitTime(float reloadwaittime);
     110            inline float getReloadWaitTime() const
     111                { return this->reloadWaitTime_; }
     112
     113            inline void resetReloadCountdown()
     114            { this->reloadWaitCountdown_ = 0; }
     115
     116            inline void startReloadCountdown()
     117            { this->reloadWaitCountdown_ = this->getReloadWaitTime(); } // TODO: Implement in Projectile.cc
     118
     119            virtual void decreaseReloadCountdownTime(float dt);
     120
    84121            inline ControllableEntity* getLastHitOriginator() const
    85122                { return this->lastHitOriginator_; }
    86123
    87             virtual void hit(Pawn* originator, const Vector3& force, float damage);
    88             virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
     124            //virtual void hit(Pawn* originator, const Vector3& force, float damage);
     125            //virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
     126            virtual void hit(Pawn* originator, const Vector3& force, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
     127            virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
     128
    89129            virtual void kill();
    90130
     
    142182            virtual void spawneffect();
    143183
    144             virtual void damage(float damage, Pawn* originator = 0);
     184            //virtual void damage(float damage, Pawn* originator = 0);
     185            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL);
    145186
    146187            bool bAlive_;
     
    154195            float maxHealth_;
    155196            float initialHealth_;
     197           
    156198            float shieldHealth_;
     199            float maxShieldHealth_;
     200            float initialShieldHealth_;
    157201            float shieldAbsorption_; // Has to be between 0 and 1
     202            float reloadRate_;
     203            float reloadWaitTime_;
     204            float reloadWaitCountdown_;
    158205
    159206            WeakPtr<Pawn> lastHitOriginator_;
  • code/branches/presentation/src/orxonox/worldentities/pawns/SpaceShip.cc

    r7860 r8578  
    3636#include "core/XMLPort.h"
    3737#include "items/Engine.h"
     38#include "graphics/Camera.h"
     39#include "CameraManager.h"
     40#include "util/Math.h"
    3841
    3942namespace orxonox
     
    5356        this->localAngularAcceleration_.setValue(0, 0, 0);
    5457        this->bBoost_ = false;
    55         this->bPermanentBoost_ = false;
    5658        this->steering_ = Vector3::ZERO;
    5759        this->engine_ = 0;
     
    7678        this->setConfigValues();
    7779        this->registerVariables();
     80       
     81        Camera* camera = CameraManager::getInstance().getActiveCamera();
     82        this->cameraOriginalPosition_ = camera->getPosition();
     83        this->cameraOriginalOrientation_ = camera->getOrientation();
     84
     85        this->shakeFrequency_ = 15;
     86        this->shakeAmplitude_ = 5;
     87        this->shakeDt_ = 0;
    7888    }
    7989
     
    96106        XMLPortParamVariable(SpaceShip, "boostRate", boostRate_, xmlelement, mode);
    97107        XMLPortParamVariable(SpaceShip, "boostCooldownDuration", boostCooldownDuration_, xmlelement, mode);
     108        XMLPortParamVariable(SpaceShip, "shakeFrequency", shakeFrequency_, xmlelement, mode);
     109        XMLPortParamVariable(SpaceShip, "shakeAmplitude", shakeAmplitude_, xmlelement, mode);
    98110    }
    99111
     
    103115        registerVariable(this->auxilaryThrust_, VariableDirection::ToClient);
    104116        registerVariable(this->rotationThrust_, VariableDirection::ToClient);
     117        // TODO: Synchronization of boost needed?
     118        registerVariable(this->boostPower_, VariableDirection::ToClient);
     119        registerVariable(this->boostPowerRate_, VariableDirection::ToClient);
     120        registerVariable(this->boostRate_, VariableDirection::ToClient);
     121        registerVariable(this->boostCooldownDuration_, VariableDirection::ToClient);
     122        registerVariable(this->shakeFrequency_, VariableDirection::ToClient);
     123        registerVariable(this->shakeAmplitude_, VariableDirection::ToClient);
    105124    }
    106125
     
    128147        if (this->hasLocalController())
    129148        {
     149
    130150/*
    131151            this->localLinearAcceleration_.setX(this->localLinearAcceleration_.x() * getMass() * this->auxilaryThrust_);
     
    150170                this->boostPower_ += this->boostPowerRate_*dt;
    151171            }
     172
    152173            if(this->bBoost_)
    153174            {
     
    155176                if(this->boostPower_ <= 0.0f)
    156177                {
    157                     this->bBoost_ = false;
     178                    this->boost(false);
    158179                    this->bBoostCooldown_ = true;
    159180                    this->timer_.setTimer(this->boostCooldownDuration_, false, createExecutor(createFunctor(&SpaceShip::boostCooledDown, this)));
     181
    160182                }
    161             }
    162         }
    163     }
    164 
    165     void SpaceShip::boostCooledDown(void)
    166     {
    167         this->bBoostCooldown_ = false;
     183
     184                shakeCamera(dt);
     185            }
     186        }
    168187    }
    169188
     
    207226    }
    208227
    209     // TODO: something seems to call this function every tick, could probably handled a little more efficiently!
    210     void SpaceShip::setBoost(bool bBoost)
    211     {
    212         if(bBoost == this->bBoost_)
     228    void SpaceShip::fire()
     229    {
     230    }
     231
     232    /**
     233    @brief
     234        Starts or stops boosting.
     235    @param bBoost
     236        Whether to start or stop boosting.
     237    */
     238    void SpaceShip::boost(bool bBoost)
     239    {
     240        if(bBoost && !this->bBoostCooldown_)
     241        {
     242            //COUT(0) << "Boost startet!\n";
     243            this->bBoost_ = true;
     244        }
     245        if(!bBoost)
     246        {
     247            //COUT(0) << "Boost stoppt\n";
     248            this->resetCamera();
     249            this->bBoost_ = false;
     250        }
     251    }
     252   
     253    void SpaceShip::boostCooledDown(void)
     254    {
     255        this->bBoostCooldown_ = false;
     256    }
     257   
     258    void SpaceShip::shakeCamera(float dt)
     259    {
     260        //make sure the ship is only shaking if it's moving
     261        if (this->getVelocity().squaredLength() > 80)
     262        {
     263            this->shakeDt_ += dt;
     264   
     265            int frequency = this->shakeFrequency_ * (this->getVelocity().squaredLength());
     266   
     267            if (this->shakeDt_ >= 1 /(frequency))
     268            {
     269                this->shakeDt_ -= 1/(frequency);
     270            }
     271   
     272            Degree angle = Degree(sin(this->shakeDt_ * 2* math::pi * frequency) * this->shakeAmplitude_);
     273   
     274            //COUT(0) << "Angle: " << angle << std::endl;
     275            Camera* c = this->getCamera();
     276
     277            //Shaking Camera effect
     278            if (c != 0)
     279            {
     280                c->setOrientation(Vector3::UNIT_X, angle);
     281            }
     282        }
     283    }
     284   
     285    void SpaceShip::resetCamera()
     286    {
     287   
     288        //COUT(0) << "Resetting camera\n";
     289        Camera *c = this->getCamera();
     290   
     291        if (c == 0)
     292        {
     293            COUT(2) << "Failed to reset camera!";
    213294            return;
    214 
    215         if(bBoost)
    216             this->boost();
    217         else
    218         {
    219             this->bBoost_ = false;
    220         }
    221     }
    222 
    223     void SpaceShip::fire()
    224     {
    225     }
    226 
    227     void SpaceShip::boost()
    228     {
    229         if(!this->bBoostCooldown_)
    230             this->bBoost_ = true;
     295        }
     296   
     297        shakeDt_ = 0;
     298        //
     299        c->setPosition(this->cameraOriginalPosition_);
     300        c->setOrientation(this->cameraOriginalOrientation_);
    231301    }
    232302
     
    273343        return list;
    274344    }
     345   
     346
    275347}
  • code/branches/presentation/src/orxonox/worldentities/pawns/SpaceShip.h

    r7801 r8578  
    5959
    6060            virtual void fire();
    61             virtual void boost();
     61            virtual void boost(bool bBoost); // Starts or stops boosting.
    6262
    6363            void setEngine(Engine* engine);
     
    7070                { return this->steering_; }
    7171
    72             void setBoost(bool bBoost);
    7372            inline bool getBoost() const
    7473                { return this->bBoost_; }
     
    7978                { return this->enginetemplate_; }
    8079
    81             inline void setPermanentBoost(bool bPermanent)
    82                 { this->bPermanentBoost_ = bPermanent; }
    83             inline bool getPermanentBoost() const
    84                 { return this->bPermanentBoost_; }
    85 
    8680        protected:
    8781            virtual std::vector<PickupCarrier*>* getCarrierChildren(void) const;
     
    9084            bool bBoost_;
    9185            bool bBoostCooldown_;
    92             bool bPermanentBoost_;
    9386            float boostPower_;
    9487            float initialBoostPower_;
     
    10396            btVector3 localAngularAcceleration_;
    10497
     98            float shakeFrequency_;
     99            float shakeAmplitude_;
     100
    105101        private:
    106102            void registerVariables();
     
    110106           
    111107            void boostCooledDown(void);
     108       
     109            void resetCamera();
     110            void shakeCamera(float dt);
    112111
    113112            std::string enginetemplate_;
    114113            Engine* engine_;
    115114            Timer timer_;
     115            Vector3 cameraOriginalPosition_;
     116            Quaternion cameraOriginalOrientation_;
     117       
     118            float shakeDt_;
    116119    };
    117120}
Note: See TracChangeset for help on using the changeset viewer.