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

Timestamp:

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

Author:

dafrick

Message:

Reverse merge to revert last, failed, merge. Apparently you can't partially commit a merge.

Location:

code/branches/presentation/src/orxonox

Files:

• controllers/Controller.h (modified) (1 diff)
• controllers/HumanController.cc (modified) (5 diffs)
• controllers/HumanController.h (modified) (3 diffs)
• graphics/Camera.cc (modified) (1 diff)
• graphics/Camera.h (modified) (1 diff)
• items/Engine.cc (modified) (1 diff)
• weaponsystem/WeaponMode.cc (modified) (2 diffs)
• weaponsystem/WeaponMode.h (modified) (2 diffs)
• worldentities/ControllableEntity.cc (modified) (1 diff)
• worldentities/ControllableEntity.h (modified) (1 diff)
• worldentities/pawns/Pawn.cc (modified) (7 diffs)
• worldentities/pawns/Pawn.h (modified) (4 diffs)
• worldentities/pawns/SpaceShip.cc (modified) (10 diffs)
• 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();
@@ -52 +51 @@
     SetConsoleCommand("HumanController", __CC_fire_name,           &HumanController::fire          ).addShortcut().keybindMode(KeybindMode::OnHold);
     SetConsoleCommand("HumanController", "reload",                 &HumanController::reload        ).addShortcut();
-    SetConsoleCommand("HumanController", __CC_boost_name,          &HumanController::keepBoost     ).addShortcut().keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand("HumanController", "boost",                  &HumanController::boost         ).addShortcut().keybindMode(KeybindMode::OnHold);
     SetConsoleCommand("HumanController", "greet",                  &HumanController::greet         ).addShortcut();
     SetConsoleCommand("HumanController", "switchCamera",           &HumanController::switchCamera  ).addShortcut();
@@ -67 +66 @@
 
     HumanController* HumanController::localController_s = 0;
-    /*static*/ const float HumanController::BOOSTING_TIME = 0.1f;
 
     HumanController::HumanController(BaseObject* creator) : Controller(creator)
@@ -73 +71 @@
         RegisterObject(HumanController);
 
-        this->controlPaused_ = false;
-        this->boosting_ = false;
+        controlPaused_ = false;
 
         HumanController::localController_s = this;
-        this->boostingTimeout_.setTimer(HumanController::BOOSTING_TIME, false, createExecutor(createFunctor(&HumanController::terminateBoosting, this)));
-        this->boostingTimeout_.stopTimer();
     }
 
@@ -168 +163 @@
     }
 
-    /**
-    @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;
+    void HumanController::boost()
+    {
+        if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
+            HumanController::localController_s->controllableEntity_->boost();
     }
 

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"
@@ -65 +64 @@
             static void reload();
 
-            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 boost();
             static void greet();
             static void switchCamera();
@@ -102 +92 @@
             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) : MovableEntity(creator)
+    Camera::Camera(BaseObject* creator) : StaticEntity(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/MovableEntity.h"
+#include "worldentities/StaticEntity.h"
 
 namespace orxonox
 {
-
-    class _OrxonoxExport Camera : public MovableEntity, public TimeFactorListener, public WindowEventListener
+    class _OrxonoxExport Camera : public StaticEntity, public Tickable, 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;
@@ -108 +106 @@
 
         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)
@@ -155 +146 @@
 
             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() {}
 
-            /**
-            @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 boost() {}
             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;
@@ -116 +109 @@
 
         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);
 
@@ -127 +118 @@
         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);
     }
 
@@ -136 +124 @@
         registerVariable(this->bAlive_,           VariableDirection::ToClient);
         registerVariable(this->health_,           VariableDirection::ToClient);
-        registerVariable(this->maxHealth_,        VariableDirection::ToClient);
+        registerVariable(this->initialHealth_,    VariableDirection::ToClient);
         registerVariable(this->shieldHealth_,     VariableDirection::ToClient);
-        registerVariable(this->maxShieldHealth_,  VariableDirection::ToClient);
         registerVariable(this->shieldAbsorption_, VariableDirection::ToClient);
         registerVariable(this->bReload_,          VariableDirection::ToServer);
@@ -150 +137 @@
         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 wants to know about the death.
+                this->fireEvent(); // Event to notify anyone who want's to know about the death.
                 this->death();
             }
-        }
     }
 
@@ -194 +168 @@
     }
 
-
     void Pawn::setHealth(float health)
     {
-        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)
+        this->health_ = std::min(health, this->maxHealth_);
+    }
+
+    void Pawn::damage(float damage, Pawn* originator)
     {
         if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
         {
-            if (shielddamage >= this->getShieldHealth())
+            //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())
             {
+                healthdamage += shielddamage-this->getShieldHealth();
                 this->setShieldHealth(0);
-                this->setHealth(this->health_ - (healthdamage + damage));
             }
-            else
+
+            this->setHealth(this->health_ - healthdamage);
+
+            if (this->getShieldHealth() > 0)
             {
                 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;
-        }
-    }
-
-// 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)
+
+            // play damage effect
+        }
+    }
+
+    void Pawn::hit(Pawn* originator, const Vector3& force, float damage)
     {
         if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
         {
-            this->damage(damage, healthdamage, shielddamage, originator);
+            this->damage(damage, originator);
             this->setVelocity(this->getVelocity() + force);
-        }
-    }
-
-
-    void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage, float shielddamage)
+
+            // play hit effect
+        }
+    }
+
+    void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage)
     {
         if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
         {
-            this->damage(damage, healthdamage, shielddamage, originator);
+            this->damage(damage, originator);
 
             if ( this->getController() )
-                this->getController()->hit(originator, contactpoint, damage); // changed to damage, why shielddamage?
-        }
-    }
-
+                this->getController()->hit(originator, contactpoint, damage);
+
+            // play hit effect
+        }
+    }
 
     void Pawn::kill()

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

@@ -72 +72 @@
                 { return this->initialHealth_; }
 
-            virtual void setShieldHealth(float shieldHealth);
-
+            inline void setShieldHealth(float shieldHealth)
+            { this->shieldHealth_ = 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)
@@ -102 +82 @@
             { 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, 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 hit(Pawn* originator, const Vector3& force, float damage);
+            virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
             virtual void kill();
 
@@ -182 +142 @@
             virtual void spawneffect();
 
-            //virtual void damage(float damage, Pawn* originator = 0);
-            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL);
+            virtual void damage(float damage, Pawn* originator = 0);
 
             bool bAlive_;
@@ -195 +154 @@
             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
@@ -56 +53 @@
         this->localAngularAcceleration_.setValue(0, 0, 0);
         this->bBoost_ = false;
+        this->bPermanentBoost_ = false;
         this->steering_ = Vector3::ZERO;
         this->engine_ = 0;
@@ -78 +76 @@
         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;
     }
 
@@ -106 +96 @@
         XMLPortParamVariable(SpaceShip, "boostRate", boostRate_, xmlelement, mode);
         XMLPortParamVariable(SpaceShip, "boostCooldownDuration", boostCooldownDuration_, xmlelement, mode);
-        XMLPortParamVariable(SpaceShip, "shakeFrequency", shakeFrequency_, xmlelement, mode);
-        XMLPortParamVariable(SpaceShip, "shakeAmplitude", shakeAmplitude_, xmlelement, mode);
     }
 
@@ -115 +103 @@
         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);
     }
 
@@ -147 +128 @@
         if (this->hasLocalController())
         {
-
 /*
             this->localLinearAcceleration_.setX(this->localLinearAcceleration_.x() * getMass() * this->auxilaryThrust_);
@@ -170 +150 @@
                 this->boostPower_ += this->boostPowerRate_*dt;
             }
-
             if(this->bBoost_)
             {
@@ -176 +155 @@
                 if(this->boostPower_ <= 0.0f)
                 {
-                    this->boost(false);
+                    this->bBoost_ = false;
                     this->bBoostCooldown_ = true;
                     this->timer_.setTimer(this->boostCooldownDuration_, false, createExecutor(createFunctor(&SpaceShip::boostCooledDown, this)));
-
                 }
-
-                shakeCamera(dt);
-            }
-        }
+            }
+        }
+    }
+
+    void SpaceShip::boostCooledDown(void)
+    {
+        this->bBoostCooldown_ = false;
     }
 
@@ -226 +207 @@
     }
 
+    // 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_)
+            return;
+
+        if(bBoost)
+            this->boost();
+        else
+        {
+            this->bBoost_ = false;
+        }
+    }
+
     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";
+    void SpaceShip::boost()
+    {
+        if(!this->bBoostCooldown_)
             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;
-        }
-    
-        shakeDt_ = 0;
-        //
-        c->setPosition(this->cameraOriginalPosition_);
-        c->setOrientation(this->cameraOriginalOrientation_);
     }
 
@@ -343 +273 @@
         return list;
     }
-    
-
 }

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

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