Changeset 8580 for code/branches/presentation/src/orxonox

Timestamp:

May 25, 2011, 9:41:29 PM (13 years ago)

Author:

dafrick

Message:

Merging game immersion branch into presentation branch.

Location:

code/branches/presentation

Files:

• . (modified) (1 prop)
• src/orxonox/controllers/Controller.h (modified) (1 diff)
• src/orxonox/controllers/HumanController.cc (modified) (5 diffs)
• src/orxonox/controllers/HumanController.h (modified) (3 diffs)
• src/orxonox/graphics/Camera.cc (modified) (1 diff)
• src/orxonox/graphics/Camera.h (modified) (1 diff)
• src/orxonox/items/Engine.cc (modified) (1 diff)
• src/orxonox/weaponsystem/WeaponMode.cc (modified) (2 diffs)
• src/orxonox/weaponsystem/WeaponMode.h (modified) (2 diffs)
• src/orxonox/worldentities/ControllableEntity.cc (modified) (1 diff)
• src/orxonox/worldentities/ControllableEntity.h (modified) (1 diff)
• src/orxonox/worldentities/pawns/Pawn.cc (modified) (7 diffs)
• src/orxonox/worldentities/pawns/Pawn.h (modified) (4 diffs)
• src/orxonox/worldentities/pawns/SpaceShip.cc (modified) (10 diffs)
• src/orxonox/worldentities/pawns/SpaceShip.h (modified) (6 diffs)

code/branches/presentation/src/orxonox/controllers/Controller.h

@@ -52 +52 @@
             virtual inline void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage) {};
 
+/* Override needed for different visual effects (e.g. in "NewHumanController.cc") depending on
+   the DIFFERENT AMOUNT OF DAMAGE done to the shield and to the health of "victim" (see Projectile.cc, Pawn.cc)
+
+//            virtual inline void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage, float shielddamage) {};
+*/
+
             void setGodMode( bool mode ){ this->bGodMode_ = mode; }
             bool getGodMode(){ return this->bGodMode_; }

code/branches/presentation/src/orxonox/controllers/HumanController.cc

@@ -42 +42 @@
     extern const std::string __CC_fire_name = "fire";
     extern const std::string __CC_suicide_name = "suicide";
+    const std::string __CC_boost_name = "boost";
 
     SetConsoleCommand("HumanController", "moveFrontBack",          &HumanController::moveFrontBack ).addShortcut().setAsInputCommand();
@@ -51 +52 @@
     SetConsoleCommand("HumanController", __CC_fire_name,           &HumanController::fire          ).addShortcut().keybindMode(KeybindMode::OnHold);
     SetConsoleCommand("HumanController", "reload",                 &HumanController::reload        ).addShortcut();
-    SetConsoleCommand("HumanController", "boost",                  &HumanController::boost         ).addShortcut().keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand("HumanController", __CC_boost_name,          &HumanController::keepBoost     ).addShortcut().keybindMode(KeybindMode::OnHold);
     SetConsoleCommand("HumanController", "greet",                  &HumanController::greet         ).addShortcut();
     SetConsoleCommand("HumanController", "switchCamera",           &HumanController::switchCamera  ).addShortcut();
@@ -66 +67 @@
 
     HumanController* HumanController::localController_s = 0;
+    /*static*/ const float HumanController::BOOSTING_TIME = 0.1f;
 
     HumanController::HumanController(BaseObject* creator) : Controller(creator)
@@ -71 +73 @@
         RegisterObject(HumanController);
 
-        controlPaused_ = false;
+        this->controlPaused_ = false;
+        this->boosting_ = false;
 
         HumanController::localController_s = this;
+        this->boostingTimeout_.setTimer(HumanController::BOOSTING_TIME, false, createExecutor(createFunctor(&HumanController::terminateBoosting, this)));
+        this->boostingTimeout_.stopTimer();
     }
 
@@ -163 +168 @@
     }
 
-    void HumanController::boost()
-    {
-        if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
-            HumanController::localController_s->controllableEntity_->boost();
+    /**
+    @brief
+        Static method,keeps boosting.
+    */
+    /*static*/ void HumanController::keepBoost()
+    {
+        if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
+            HumanController::localController_s->keepBoosting();
+    }
+    
+    /**
+    @brief
+        Starts, or keeps the boosting mode.
+        Resets the boosting timeout and ells the ControllableEntity to boost (or not boost anymore).
+    */
+    void HumanController::keepBoosting(void)
+    {
+        if(this->boostingTimeout_.isActive())
+        {
+            this->boostingTimeout_.stopTimer();
+            this->boostingTimeout_.startTimer();
+        }
+        else
+        {
+            this->boosting_ = true;
+            this->boostingTimeout_.startTimer();
+            
+            this->controllableEntity_->boost(this->boosting_);
+            COUT(4) << "Start boosting" << endl;
+        }
+    }
+
+    /**
+    @brief
+        Terminates the boosting mode.
+    */
+    void HumanController::terminateBoosting(void)
+    {
+        this->boosting_ = false;
+        this->boostingTimeout_.stopTimer();
+
+        this->controllableEntity_->boost(this->boosting_);
+        COUT(4) << "Stop boosting" << endl;
     }
 

code/branches/presentation/src/orxonox/controllers/HumanController.h

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 
+#include "tools/Timer.h"
 #include "tools/interfaces/Tickable.h"
 #include "Controller.h"
@@ -64 +65 @@
             static void reload();
 
-            static void boost();
+            static void keepBoost(); // Static method, keeps boosting.
+            /**
+            @brief Check whether the HumanController is in boosting mode.
+            @return Returns true if it is, false if not.
+            */
+            inline bool isBoosting(void)
+                { return this->boosting_; }
+            void keepBoosting(void);
+            void terminateBoosting(void);
+            
             static void greet();
             static void switchCamera();
@@ -92 +102 @@
             static HumanController* localController_s;
             bool controlPaused_;
+        
+        private:
+            bool boosting_; // Whether the HumanController is in boosting mode or not.
+            Timer boostingTimeout_; // A timer to check whether the player is no longer boosting.
+            static const float BOOSTING_TIME; // The time after it is checked, whether the player is no longer boosting.
+
     }; // tolua_export
 } // tolua_export

code/branches/presentation/src/orxonox/graphics/Camera.cc

@@ -48 +48 @@
     CreateFactory(Camera);
 
-    Camera::Camera(BaseObject* creator) : StaticEntity(creator)
+    Camera::Camera(BaseObject* creator) : MovableEntity(creator)
     {
         RegisterObject(Camera);

code/branches/presentation/src/orxonox/graphics/Camera.h

@@ -36 +36 @@
 #include "tools/interfaces/Tickable.h"
 #include "tools/interfaces/TimeFactorListener.h"
-#include "worldentities/StaticEntity.h"
+#include "worldentities/MovableEntity.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Camera : public StaticEntity, public Tickable, public TimeFactorListener, public WindowEventListener
+
+    class _OrxonoxExport Camera : public MovableEntity, public TimeFactorListener, public WindowEventListener
     {
         friend class CameraManager;

code/branches/presentation/src/orxonox/items/Engine.cc

@@ -204 +204 @@
         this->ship_->setAcceleration(this->ship_->getOrientation() * (acceleration*this->getSpeedMultiply()+Vector3(0,0,-this->getSpeedAdd())));
 
-        if (!this->ship_->getPermanentBoost())
-            this->ship_->setBoost(false);
         this->ship_->setSteeringDirection(Vector3::ZERO);
 

code/branches/presentation/src/orxonox/weaponsystem/WeaponMode.cc

@@ -66 +66 @@
 
         this->damage_ = 0;
+        this->healthdamage_ = 0;
+        this->shielddamage_ = 0;
 
         this->muzzleOffset_ = Vector3::ZERO;
@@ -106 +108 @@
 
         XMLPortParam(WeaponMode, "damage",           setDamage,           getDamage,           xmlelement, mode);
+        XMLPortParam(WeaponMode, "healthdamage",     setHealthDamage,     getHealthDamage,     xmlelement, mode);
+        XMLPortParam(WeaponMode, "shielddamage",     setShieldDamage,     getShieldDamage,     xmlelement, mode);
         XMLPortParam(WeaponMode, "muzzleoffset",     setMuzzleOffset,     getMuzzleOffset,     xmlelement, mode);
     }

code/branches/presentation/src/orxonox/weaponsystem/WeaponMode.h

@@ -104 +104 @@
             // Fire
             inline void setDamage(float damage)
-                { this->damage_ = damage; }
+                { this->damage_ = damage;}
             inline float getDamage() const
                 { return this->damage_; }
+            inline void setHealthDamage(float healthdamage)
+                { this->healthdamage_ = healthdamage; }
+            inline float getHealthDamage() const
+                { return this->healthdamage_; }
+
+            inline void setShieldDamage(float shielddamage)
+                { this->shielddamage_ = shielddamage;}
+            inline float getShieldDamage() const
+                { return this->shielddamage_; }
 
             inline void setMuzzleOffset(const Vector3& offset)
@@ -146 +155 @@
 
             float damage_;
+            float healthdamage_;
+            float shielddamage_;
             Vector3 muzzleOffset_;
 

code/branches/presentation/src/orxonox/worldentities/ControllableEntity.cc

@@ -84 +84 @@
         this->client_angular_velocity_ = Vector3::ZERO;
 
-
         this->setConfigValues();
         this->setPriority( Priority::VeryHigh );

code/branches/presentation/src/orxonox/worldentities/ControllableEntity.h

@@ -93 +93 @@
             virtual void reload() {}
 
-            virtual void boost() {}
+            /**
+            @brief Tells the ControllableEntity to either start or stop boosting.
+                   This doesn't mean, that the ControllableEntity will do so, there might be additional restrictions on boosting, but if it can, then it will.
+            @param bBoost If true the ControllableEntity is told to start boosting, if false it is told to stop.
+            */
+            virtual void boost(bool bBoost) {}
+            
             virtual void greet() {}
             virtual void switchCamera();

code/branches/presentation/src/orxonox/worldentities/pawns/Pawn.cc

@@ -23 +23 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      simonmie
  *
  */
@@ -64 +64 @@
         this->maxHealth_ = 0;
         this->initialHealth_ = 0;
+
         this->shieldHealth_ = 0;
+        this->initialShieldHealth_ = 0;
+        this->maxShieldHealth_ = 100; //otherwise shield might increase to float_max
         this->shieldAbsorption_ = 0.5;
+
+        this->reloadRate_ = 0;
+        this->reloadWaitTime_ = 1.0f;
+        this->reloadWaitCountdown_ = 0;
 
         this->lastHitOriginator_ = 0;
@@ -109 +116 @@
 
         XMLPortParam(Pawn, "shieldhealth", setShieldHealth, getShieldHealth, xmlelement, mode).defaultValues(0);
+        XMLPortParam(Pawn, "initialshieldhealth", setInitialShieldHealth, getInitialShieldHealth, xmlelement, mode).defaultValues(0);
+        XMLPortParam(Pawn, "maxshieldhealth", setMaxShieldHealth, getMaxShieldHealth, xmlelement, mode).defaultValues(100);
         XMLPortParam(Pawn, "shieldabsorption", setShieldAbsorption, getShieldAbsorption, xmlelement, mode).defaultValues(0);
 
@@ -118 +127 @@
         XMLPortObject(Pawn, WeaponSet, "weaponsets", addWeaponSet, getWeaponSet, xmlelement, mode);
         XMLPortObject(Pawn, WeaponPack, "weapons", addWeaponPackXML, getWeaponPack, xmlelement, mode);
+
+        XMLPortParam(Pawn, "reloadrate", setReloadRate, getReloadRate, xmlelement, mode).defaultValues(0);
+        XMLPortParam(Pawn, "reloadwaittime", setReloadWaitTime, getReloadWaitTime, xmlelement, mode).defaultValues(1.0f);
     }
 
@@ -124 +136 @@
         registerVariable(this->bAlive_,           VariableDirection::ToClient);
         registerVariable(this->health_,           VariableDirection::ToClient);
-        registerVariable(this->initialHealth_,    VariableDirection::ToClient);
+        registerVariable(this->maxHealth_,        VariableDirection::ToClient);
         registerVariable(this->shieldHealth_,     VariableDirection::ToClient);
+        registerVariable(this->maxShieldHealth_,  VariableDirection::ToClient);
         registerVariable(this->shieldAbsorption_, VariableDirection::ToClient);
         registerVariable(this->bReload_,          VariableDirection::ToServer);
@@ -137 +150 @@
         this->bReload_ = false;
 
+        // TODO: use the existing timer functions instead
+        if(this->reloadWaitCountdown_ > 0)
+        {
+            this->decreaseReloadCountdownTime(dt);
+        }
+        else
+        {
+            this->addShieldHealth(this->getReloadRate() * dt);
+            this->resetReloadCountdown();
+        }
+
         if (GameMode::isMaster())
+        {
             if (this->health_ <= 0 && bAlive_)
             {
-                this->fireEvent(); // Event to notify anyone who want's to know about the death.
+                this->fireEvent(); // Event to notify anyone who wants to know about the death.
                 this->death();
             }
+        }
     }
 
@@ -168 +194 @@
     }
 
+
     void Pawn::setHealth(float health)
     {
-        this->health_ = std::min(health, this->maxHealth_);
-    }
-
-    void Pawn::damage(float damage, Pawn* originator)
+        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
+    }
+
+    void Pawn::setShieldHealth(float shieldHealth)
+    {
+        this->shieldHealth_ = std::min(shieldHealth, this->maxShieldHealth_);
+    }
+
+    void Pawn::setMaxShieldHealth(float maxshieldhealth)
+    {
+        this->maxShieldHealth_ = maxshieldhealth;
+    }
+
+    void Pawn::setReloadRate(float reloadrate)
+    {
+        this->reloadRate_ = reloadrate;
+    }
+
+    void Pawn::setReloadWaitTime(float reloadwaittime)
+    {
+        this->reloadWaitTime_ = reloadwaittime;
+    }
+
+    void Pawn::decreaseReloadCountdownTime(float dt)
+    {
+        this->reloadWaitCountdown_ -= dt;
+    }
+
+    void Pawn::damage(float damage, float healthdamage, float shielddamage, Pawn* originator)
     {
         if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
         {
-            //share the dealt damage to the shield and the Pawn.
-            float shielddamage = damage*this->shieldAbsorption_;
-            float healthdamage = damage*(1-this->shieldAbsorption_);
-
-            // In case the shield can not take all the shield damage.
-            if (shielddamage > this->getShieldHealth())
+            if (shielddamage >= this->getShieldHealth())
             {
-                healthdamage += shielddamage-this->getShieldHealth();
                 this->setShieldHealth(0);
+                this->setHealth(this->health_ - (healthdamage + damage));
             }
-
-            this->setHealth(this->health_ - healthdamage);
-
-            if (this->getShieldHealth() > 0)
+            else
             {
                 this->setShieldHealth(this->shieldHealth_ - shielddamage);
+
+                // remove remaining shieldAbsorpton-Part of damage from shield
+                shielddamage = damage * this->shieldAbsorption_;
+                shielddamage = std::min(this->getShieldHealth(),shielddamage);
+                this->setShieldHealth(this->shieldHealth_ - shielddamage);
+
+                // set remaining damage to health
+                this->setHealth(this->health_ - (damage - shielddamage) - healthdamage);
             }
 
             this->lastHitOriginator_ = originator;
-
-            // play damage effect
-        }
-    }
-
-    void Pawn::hit(Pawn* originator, const Vector3& force, float damage)
+        }
+    }
+
+// TODO: Still valid?
+/* HIT-Funktionen
+    Die hit-Funktionen muessen auch in src/orxonox/controllers/Controller.h angepasst werden! (Visuelle Effekte)
+
+*/
+
+    void Pawn::hit(Pawn* originator, const Vector3& force, float damage, float healthdamage, float shielddamage)
     {
         if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
         {
-            this->damage(damage, originator);
+            this->damage(damage, healthdamage, shielddamage, originator);
             this->setVelocity(this->getVelocity() + force);
-
-            // play hit effect
-        }
-    }
-
-    void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage)
+        }
+    }
+
+
+    void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage, float shielddamage)
     {
         if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
         {
-            this->damage(damage, originator);
+            this->damage(damage, healthdamage, shielddamage, originator);
 
             if ( this->getController() )
-                this->getController()->hit(originator, contactpoint, damage);
-
-            // play hit effect
-        }
-    }
+                this->getController()->hit(originator, contactpoint, damage); // changed to damage, why shielddamage?
+        }
+    }
+
 
     void Pawn::kill()

code/branches/presentation/src/orxonox/worldentities/pawns/Pawn.h

@@ -72 +72 @@
                 { return this->initialHealth_; }
 
-            inline void setShieldHealth(float shieldHealth)
-            { this->shieldHealth_ = shieldHealth; }
+            virtual void setShieldHealth(float shieldHealth);
+
             inline float getShieldHealth()
             { return this->shieldHealth_; }
+
+            inline void addShieldHealth(float amount)
+            { this->setShieldHealth(this->shieldHealth_ + amount); }
+
+            inline bool hasShield()
+            { return (this->getShieldHealth() > 0); }
+
+            virtual void setMaxShieldHealth(float maxshieldhealth);
+            inline float getMaxShieldHealth() const
+                { return this->maxShieldHealth_; }
+
+            inline void setInitialShieldHealth(float initialshieldhealth)
+                { this->initialShieldHealth_ = initialshieldhealth; this->setShieldHealth(initialshieldhealth); }
+            inline float getInitialShieldHealth() const
+                { return this->initialShieldHealth_; }
+
+            inline void restoreInitialShieldHealth()
+                { this->setShieldHealth(this->initialShieldHealth_); }
+            inline void restoreMaxShieldHealth()
+                { this->setShieldHealth(this->maxShieldHealth_); }
 
             inline void setShieldAbsorption(float shieldAbsorption)
@@ -82 +102 @@
             { return this->shieldAbsorption_; }
 
+            // TODO: Rename to shieldRechargeRate
+            virtual void setReloadRate(float reloadrate);
+            inline float getReloadRate() const
+                { return this->reloadRate_; }
+
+            virtual void setReloadWaitTime(float reloadwaittime);
+            inline float getReloadWaitTime() const
+                { return this->reloadWaitTime_; }
+
+            inline void resetReloadCountdown()
+            { this->reloadWaitCountdown_ = 0; }
+
+            inline void startReloadCountdown()
+            { this->reloadWaitCountdown_ = this->getReloadWaitTime(); } // TODO: Implement in Projectile.cc
+
+            virtual void decreaseReloadCountdownTime(float dt);
+
             inline ControllableEntity* getLastHitOriginator() const
                 { return this->lastHitOriginator_; }
 
-            virtual void hit(Pawn* originator, const Vector3& force, float damage);
-            virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
+            //virtual void hit(Pawn* originator, const Vector3& force, float damage);
+            //virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
+            virtual void hit(Pawn* originator, const Vector3& force, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
+            virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
+
             virtual void kill();
 
@@ -142 +182 @@
             virtual void spawneffect();
 
-            virtual void damage(float damage, Pawn* originator = 0);
+            //virtual void damage(float damage, Pawn* originator = 0);
+            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL);
 
             bool bAlive_;
@@ -154 +195 @@
             float maxHealth_;
             float initialHealth_;
+            
             float shieldHealth_;
+            float maxShieldHealth_;
+            float initialShieldHealth_;
             float shieldAbsorption_; // Has to be between 0 and 1
+            float reloadRate_;
+            float reloadWaitTime_;
+            float reloadWaitCountdown_;
 
             WeakPtr<Pawn> lastHitOriginator_;

code/branches/presentation/src/orxonox/worldentities/pawns/SpaceShip.cc

@@ -36 +36 @@
 #include "core/XMLPort.h"
 #include "items/Engine.h"
+#include "graphics/Camera.h"
+#include "CameraManager.h"
+#include "util/Math.h"
 
 namespace orxonox
@@ -53 +56 @@
         this->localAngularAcceleration_.setValue(0, 0, 0);
         this->bBoost_ = false;
-        this->bPermanentBoost_ = false;
         this->steering_ = Vector3::ZERO;
         this->engine_ = 0;
@@ -76 +78 @@
         this->setConfigValues();
         this->registerVariables();
+        
+        Camera* camera = CameraManager::getInstance().getActiveCamera();
+        this->cameraOriginalPosition_ = camera->getPosition();
+        this->cameraOriginalOrientation_ = camera->getOrientation();
+
+        this->shakeFrequency_ = 15;
+        this->shakeAmplitude_ = 5;
+        this->shakeDt_ = 0;
     }
 
@@ -96 +106 @@
         XMLPortParamVariable(SpaceShip, "boostRate", boostRate_, xmlelement, mode);
         XMLPortParamVariable(SpaceShip, "boostCooldownDuration", boostCooldownDuration_, xmlelement, mode);
+        XMLPortParamVariable(SpaceShip, "shakeFrequency", shakeFrequency_, xmlelement, mode);
+        XMLPortParamVariable(SpaceShip, "shakeAmplitude", shakeAmplitude_, xmlelement, mode);
     }
 
@@ -103 +115 @@
         registerVariable(this->auxilaryThrust_, VariableDirection::ToClient);
         registerVariable(this->rotationThrust_, VariableDirection::ToClient);
+        // TODO: Synchronization of boost needed?
+        registerVariable(this->boostPower_, VariableDirection::ToClient);
+        registerVariable(this->boostPowerRate_, VariableDirection::ToClient);
+        registerVariable(this->boostRate_, VariableDirection::ToClient);
+        registerVariable(this->boostCooldownDuration_, VariableDirection::ToClient);
+        registerVariable(this->shakeFrequency_, VariableDirection::ToClient);
+        registerVariable(this->shakeAmplitude_, VariableDirection::ToClient);
     }
 
@@ -128 +147 @@
         if (this->hasLocalController())
         {
+
 /*
             this->localLinearAcceleration_.setX(this->localLinearAcceleration_.x() * getMass() * this->auxilaryThrust_);
@@ -150 +170 @@
                 this->boostPower_ += this->boostPowerRate_*dt;
             }
+
             if(this->bBoost_)
             {
@@ -155 +176 @@
                 if(this->boostPower_ <= 0.0f)
                 {
-                    this->bBoost_ = false;
+                    this->boost(false);
                     this->bBoostCooldown_ = true;
                     this->timer_.setTimer(this->boostCooldownDuration_, false, createExecutor(createFunctor(&SpaceShip::boostCooledDown, this)));
+
                 }
-            }
-        }
-    }
-
-    void SpaceShip::boostCooledDown(void)
-    {
-        this->bBoostCooldown_ = false;
+
+                shakeCamera(dt);
+            }
+        }
     }
 
@@ -207 +226 @@
     }
 
-    // TODO: something seems to call this function every tick, could probably handled a little more efficiently!
-    void SpaceShip::setBoost(bool bBoost)
-    {
-        if(bBoost == this->bBoost_)
+    void SpaceShip::fire()
+    {
+    }
+
+    /**
+    @brief
+        Starts or stops boosting.
+    @param bBoost
+        Whether to start or stop boosting.
+    */
+    void SpaceShip::boost(bool bBoost)
+    {
+        if(bBoost && !this->bBoostCooldown_)
+        {
+            //COUT(0) << "Boost startet!\n";
+            this->bBoost_ = true;
+        }
+        if(!bBoost)
+        {
+            //COUT(0) << "Boost stoppt\n";
+            this->resetCamera();
+            this->bBoost_ = false;
+        }
+    }
+    
+    void SpaceShip::boostCooledDown(void)
+    {
+        this->bBoostCooldown_ = false;
+    }
+    
+    void SpaceShip::shakeCamera(float dt)
+    {
+        //make sure the ship is only shaking if it's moving
+        if (this->getVelocity().squaredLength() > 80)
+        {
+            this->shakeDt_ += dt;
+    
+            int frequency = this->shakeFrequency_ * (this->getVelocity().squaredLength());
+    
+            if (this->shakeDt_ >= 1 /(frequency))
+            {
+                this->shakeDt_ -= 1/(frequency);
+            }
+    
+            Degree angle = Degree(sin(this->shakeDt_ * 2* math::pi * frequency) * this->shakeAmplitude_);
+    
+            //COUT(0) << "Angle: " << angle << std::endl;
+            Camera* c = this->getCamera();
+
+            //Shaking Camera effect
+            if (c != 0)
+            {
+                c->setOrientation(Vector3::UNIT_X, angle);
+            }
+        }
+    }
+    
+    void SpaceShip::resetCamera()
+    {
+    
+        //COUT(0) << "Resetting camera\n";
+        Camera *c = this->getCamera();
+    
+        if (c == 0)
+        {
+            COUT(2) << "Failed to reset camera!";
             return;
-
-        if(bBoost)
-            this->boost();
-        else
-        {
-            this->bBoost_ = false;
-        }
-    }
-
-    void SpaceShip::fire()
-    {
-    }
-
-    void SpaceShip::boost()
-    {
-        if(!this->bBoostCooldown_)
-            this->bBoost_ = true;
+        }
+    
+        shakeDt_ = 0;
+        //
+        c->setPosition(this->cameraOriginalPosition_);
+        c->setOrientation(this->cameraOriginalOrientation_);
     }
 
@@ -273 +343 @@
         return list;
     }
+    
+
 }

code/branches/presentation/src/orxonox/worldentities/pawns/SpaceShip.h

@@ -59 +59 @@
 
             virtual void fire();
-            virtual void boost();
+            virtual void boost(bool bBoost); // Starts or stops boosting.
 
             void setEngine(Engine* engine);
@@ -70 +70 @@
                 { return this->steering_; }
 
-            void setBoost(bool bBoost);
             inline bool getBoost() const
                 { return this->bBoost_; }
@@ -79 +78 @@
                 { return this->enginetemplate_; }
 
-            inline void setPermanentBoost(bool bPermanent)
-                { this->bPermanentBoost_ = bPermanent; }
-            inline bool getPermanentBoost() const
-                { return this->bPermanentBoost_; }
-
         protected:
             virtual std::vector<PickupCarrier*>* getCarrierChildren(void) const;
@@ -90 +84 @@
             bool bBoost_;
             bool bBoostCooldown_;
-            bool bPermanentBoost_;
             float boostPower_;
             float initialBoostPower_;
@@ -103 +96 @@
             btVector3 localAngularAcceleration_;
 
+            float shakeFrequency_;
+            float shakeAmplitude_;
+
         private:
             void registerVariables();
@@ -110 +106 @@
             
             void boostCooledDown(void);
+        
+            void resetCamera();
+            void shakeCamera(float dt);
 
             std::string enginetemplate_;
             Engine* engine_;
             Timer timer_;
+            Vector3 cameraOriginalPosition_;
+            Quaternion cameraOriginalOrientation_;
+        
+            float shakeDt_;
     };
 }