Index: code/trunk/src/modules/weapons/WeaponsPrereqs.h
===================================================================
--- code/trunk/src/modules/weapons/WeaponsPrereqs.h	(revision 10299)
+++ code/trunk/src/modules/weapons/WeaponsPrereqs.h	(revision 10622)
@@ -75,4 +75,5 @@
     class ReplenishingMunition;
     class RocketMunition;
+    class GravityBombMuntion;
 
     // projectiles
@@ -82,5 +83,7 @@
     class Projectile;
     class Rocket;
+    class RocketOld;
     class SimpleRocket;
+    class GravityBomb;
 
     // weaponmodes
@@ -91,5 +94,7 @@
     class LightningGun;
     class RocketFire;
+    class RocketFireOld;
     class SimpleRocketFire;
+    class GravityBombFire;
 }
 
Index: code/trunk/src/modules/weapons/munitions/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/weapons/munitions/CMakeLists.txt	(revision 10299)
+++ code/trunk/src/modules/weapons/munitions/CMakeLists.txt	(revision 10622)
@@ -4,3 +4,4 @@
   FusionMunition.cc
   RocketMunition.cc
+  GravityBombMunition.cc
 )
Index: code/trunk/src/modules/weapons/munitions/GravityBombMunition.cc
===================================================================
--- code/trunk/src/modules/weapons/munitions/GravityBombMunition.cc	(revision 10622)
+++ code/trunk/src/modules/weapons/munitions/GravityBombMunition.cc	(revision 10622)
@@ -0,0 +1,32 @@
+/*
+ * GravityBombMunition.cc
+ *
+ *  Created on: Apr 16, 2015
+ *      Author: Manuel Eggimann
+ */
+#include "GravityBombMunition.h"
+#include "core/CoreIncludes.h"
+
+namespace orxonox
+{
+RegisterClass(GravityBombMunition);
+
+    GravityBombMunition::GravityBombMunition(Context* context) : Munition(context)
+    {
+        RegisterObject(GravityBombMunition);
+        this->maxMunitionPerMagazine_ = 1;
+        this->maxMagazines_ = 30;
+        this->magazines_ = 15;
+
+        this->bUseSeparateMagazines_ = false;
+        this->bStackMunition_ = true;
+
+        this->bAllowMunitionRefilling_ = true;
+        this->bAllowMultiMunitionRemovementUnderflow_ = false;
+    }
+
+}
+
+
+
+
Index: code/trunk/src/modules/weapons/munitions/GravityBombMunition.h
===================================================================
--- code/trunk/src/modules/weapons/munitions/GravityBombMunition.h	(revision 10622)
+++ code/trunk/src/modules/weapons/munitions/GravityBombMunition.h	(revision 10622)
@@ -0,0 +1,35 @@
+/*
+ * GravityBombMunition.h
+ *
+ *  Created on: Apr 16, 2015
+ *      Author: meggiman
+ */
+
+#ifndef GRAVITYBOMBMUNITION_H_
+#define GRAVITYBOMBMUNITION_H_
+
+#include "weapons/WeaponsPrereqs.h"
+#include "weaponsystem/Munition.h"
+
+namespace orxonox
+{
+    /**
+     * @class   GravityBombMunition
+     *
+     * @brief   This class is used to set the behaviour of various 
+     *          munition specific attributes of the GravityBomb like max count of munition per magazine.
+     *
+     * @author  Manuel
+     * @date    23.05.2015
+     */
+    class _WeaponsExport GravityBombMunition : public Munition
+    {
+        public:
+            GravityBombMunition(Context* context);
+            virtual ~GravityBombMunition() {}
+    };
+
+}
+
+
+#endif /* GRAVITYBOMBMUNITION_H_ */
Index: code/trunk/src/modules/weapons/projectiles/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/weapons/projectiles/CMakeLists.txt	(revision 10299)
+++ code/trunk/src/modules/weapons/projectiles/CMakeLists.txt	(revision 10622)
@@ -6,4 +6,7 @@
   LightningGunProjectile.cc
   Rocket.cc
+  RocketOld.cc
   SimpleRocket.cc
+  GravityBomb.cc
+  GravityBombField.cc
 )
Index: code/trunk/src/modules/weapons/projectiles/GravityBomb.cc
===================================================================
--- code/trunk/src/modules/weapons/projectiles/GravityBomb.cc	(revision 10622)
+++ code/trunk/src/modules/weapons/projectiles/GravityBomb.cc	(revision 10622)
@@ -0,0 +1,102 @@
+/*
+ * GravityBomb.cc
+ *
+ *  Created on: Mar 26, 2015
+ *      Author: Manuel Eggimann
+ */
+#include "GravityBomb.h"
+#include "graphics/Model.h"
+
+
+namespace orxonox{
+    RegisterClass(GravityBomb);
+
+    const float GravityBomb::LIFETIME = 2.5;  ///< The gravity bomb lifetime in seconds.
+
+    GravityBomb::GravityBomb(Context* context):
+                BasicProjectile(),
+                MovableEntity(context),
+                RadarViewable(this,static_cast<WorldEntity*>(this))
+        {
+            RegisterObject(GravityBomb);
+
+            this->setMass(10.0);
+            this->hasCollided_ = false;
+            if (GameMode::isMaster())
+            {
+                //Define CollisionType of the bomb
+                this->timeToLife_= LIFETIME;
+                this->setCollisionResponse(false);
+                this->setCollisionType(WorldEntity::Dynamic);
+                this->enableCollisionCallback();
+
+                //Add Collision Shape
+                SphereCollisionShape* collisionShape = new SphereCollisionShape(context);
+                collisionShape->setRadius(1.0);
+                this->attachCollisionShape(collisionShape);
+
+                //Create Bomb Model
+                Model* rocketModel = new Model(this->getContext());
+                rocketModel->setMeshSource("GravityBombRocket.mesh"); //Demo Model from SimpleRocket
+                rocketModel->scale(3.0f);
+                this->attach(rocketModel);
+                //Add second model because the bomb consists of the bomb and attached rockets (2 separate models)
+                Model* bombModel =  new Model(this->getContext());
+                bombModel->setMeshSource("GravityBomb.mesh"); //Demo Model from SimpleRocket
+                bombModel->scale(3.0f);
+                this->attach(bombModel);
+
+                //Add particle effect to the flying rockets.
+                ParticleEmitter* fire = new ParticleEmitter(this->getContext());
+                fire->setOrientation(this->getOrientation());
+                fire->setSource("Orxonox/simplerocketfire");
+                this->attach(fire);
+
+                //Add sound effect while the bomb is flying.
+                WorldSound* bombSound = new WorldSound(context);
+                bombSound->setSource("sounds/GravityBombFlight.ogg");
+                bombSound->setLooping(true);
+                bombSound->setVolume(1.0);
+                this->attach(bombSound);
+                bombSound->play();
+            }
+        }
+
+    GravityBomb::~GravityBomb(){}
+
+    void GravityBomb::tick(float dt)
+    {
+        SUPER(GravityBomb, tick, dt);
+        timeToLife_ -= dt;
+        if (timeToLife_ < 0)
+        {
+            //orxout(debug_output) << "bomb has stoped moving" <<endl;
+            setVelocity(Vector3::ZERO); //Stop the bomb.
+            detonate();
+            this->destroy();
+        }
+        else 
+        {
+            if (hasCollided_) detonate();
+            destroyCheck(); //Bomb is going to be destroyed by destroyCheck(). As written in BasicProectile, this Method should be called by every Projectile.
+        }
+    }
+
+    bool GravityBomb::collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint)
+    {
+        hasCollided_ = processCollision(otherObject, contactPoint, cs);
+        return hasCollided_;
+    }
+
+    void GravityBomb::detonate()
+    {
+        //Create the GravityBombField and destroy the Projectil.
+        GravityBombField* field = new GravityBombField(this->getContext());
+        field->setShooter(this->getShooter());
+        field->setPosition(getPosition());
+        //orxout(debug_output) << "detonating. Creating GravityBombField." <<endl;
+        //orxout(debug_output) << "Field is at Position: " << getPosition() << endl;
+    }
+}
+
+
Index: code/trunk/src/modules/weapons/projectiles/GravityBomb.h
===================================================================
--- code/trunk/src/modules/weapons/projectiles/GravityBomb.h	(revision 10622)
+++ code/trunk/src/modules/weapons/projectiles/GravityBomb.h	(revision 10622)
@@ -0,0 +1,55 @@
+/*
+ * GravityBomb.h
+ *
+ *  Created on: Mar 19, 2015
+ *      Author: meggiman
+ */
+
+#ifndef GravityBOMB_H_
+#define GravityBOMB_H_
+
+#include "weapons/WeaponsPrereqs.h"
+
+#include "tools/Timer.h"
+
+#include "graphics/ParticleSpawner.h"
+#include "interfaces/RadarViewable.h"
+#include "objects/ForceField.h"
+#include "BasicProjectile.h"
+#include "worldentities/MovableEntity.h"
+#include "core/CoreIncludes.h"
+#include "objects/collisionshapes/SphereCollisionShape.h"
+#include "worldentities/WorldEntity.h"
+#include "GravityBombField.h"
+#include "sound/WorldSound.h"
+
+namespace orxonox
+{
+    /**
+     * @class   GravityBomb
+     *
+     * @brief   This class implements how long the bomb flies before it places the GravityField at it's last possition.
+     *          The field will be created either because the timelimit of the bomb expired or it hit something. After creation of the field,
+     *          the projectile (this object) is destroyed.
+     *
+     * @author  Manuel Eggimann
+     * @date    23.05.2015
+     */
+    class _WeaponsExport GravityBomb : public BasicProjectile , public MovableEntity, public RadarViewable
+    {
+        public:
+            GravityBomb(Context* context);
+            virtual ~GravityBomb();
+            virtual void tick(float dt);
+
+            virtual bool collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint);
+            void detonate();
+        private:
+        static const float LIFETIME;
+
+        bool hasCollided_;
+        float timeToLife_; //Time the bomb flies before it explodes.
+        WorldSound* bombSound_;
+    };
+}
+#endif /* GravityBOMB_H_ */
Index: code/trunk/src/modules/weapons/projectiles/GravityBombField.cc
===================================================================
--- code/trunk/src/modules/weapons/projectiles/GravityBombField.cc	(revision 10622)
+++ code/trunk/src/modules/weapons/projectiles/GravityBombField.cc	(revision 10622)
@@ -0,0 +1,176 @@
+/*
+ * GravityBombField.cc
+ *
+ *  Created on: Apr 2, 2015
+ *      Author: Manuel Eggimann
+ */
+
+#include "GravityBombField.h"
+#include "graphics/Model.h"
+
+namespace orxonox{
+    RegisterClass(GravityBombField);
+
+    //Change these constants to alter the behaviour of the field.
+    
+    const float GravityBombField::FORCE_FIELD_LIFETIME = 15;
+    const float GravityBombField::FORCE_SPHERE_START_RADIUS = 250;
+    const float GravityBombField::FORCE_SPHERE_START_STRENGTH = -700;
+    const float GravityBombField::PEAK_EXPLOSION_FORCE = 5e4;
+    const float GravityBombField::FORCE_FIELD_EXPLOSION_DAMMAGE = 100;
+    const float GravityBombField::EXPLOSION_DURATION = 1;
+    const float GravityBombField::EXPLOSION_RADIUS = 600;
+    const float GravityBombField::PEAK_ANGULAR_VELOCITY = 20;
+    const float GravityBombField::CENTRE_MODEL_END_SIZE = 1.5;
+
+    GravityBombField::GravityBombField(Context* context) : ForceField(context),RadarViewable(this, static_cast<WorldEntity*>(this))
+    {
+        RegisterObject(GravityBombField);
+        //Initialize variable with their initial values.
+        lifetime_=FORCE_FIELD_LIFETIME;
+        forceStrength_ = FORCE_SPHERE_START_STRENGTH;
+        forceSphereRadius_ = FORCE_SPHERE_START_RADIUS;
+        modelScaling_ = 1;
+        fieldExploded_ = false;
+
+        setVelocity(FORCE_SPHERE_START_STRENGTH);
+        setDiameter(2*FORCE_SPHERE_START_RADIUS);
+        setMode(modeSphere_s);
+        setCollisionResponse(false);
+
+        //Make the Field visible on Radar and minimap.
+        this->setRadarObjectColour(ColourValue(1.0, 0.0, 0.2,1)); // Red
+        this->setRadarObjectShape(RadarViewable::Dot);
+        this->setRadarObjectScale(1.0f);
+        
+
+        //Attach Model
+        Model* model = new Model(this->getContext());
+        model->setMeshSource("GravityBomb.mesh"); //Demo Model from SimpleRocket
+        model->scale(2.5f);
+        bombModel_ = new MovableEntity(context);
+        bombModel_->attach(model);
+        this->attach(bombModel_);
+
+        //Add a Backlight to the centre.
+        centreLight_ = new Backlight(context);
+        centreLight_->setColour(ColourValue(0.2,0.9,0.2,1));
+        centreLight_->setScale(0.3);
+        centreLight_->setTrailMaterial("Trail/backlighttrail");
+        centreLight_->setMaterial("Examples/Flare");
+        centreLight_->setLifetime(20);
+        bombModel_->attach(centreLight_);
+
+        //Let the Bomb Modell in the centre rotate in a random direction.
+        Vector3 randomRotation;
+        randomRotation.x = rnd();
+        randomRotation.y = rnd();
+        randomRotation.y = rnd();
+        randomRotation.normalise();
+        bombModel_->setAngularAcceleration(randomRotation*(PEAK_ANGULAR_VELOCITY/FORCE_FIELD_LIFETIME));
+
+        //Add Collision Shape
+        SphereCollisionShape* collisionShape = new SphereCollisionShape(context);
+        collisionShape->setRadius(10.0);
+        this->attachCollisionShape(collisionShape);
+
+        //Add particle effect to visualize the force field.
+        this->particleSphere_ = new ParticleEmitter(this->getContext());
+        this->attach(this->particleSphere_);
+        particleSphere_->setSource("Orxonox/GravityBombField");
+
+        //Add a sound effect to the field.
+        WorldSound* fieldSound = new WorldSound(context);
+        fieldSound->setSource("sounds/GravityField.ogg");
+        fieldSound->setLooping(true);
+        fieldSound->setVolume(1.0);
+        this->attach(fieldSound);
+        fieldSound->play();
+    }
+
+    GravityBombField::~GravityBombField(){}
+
+    
+    void GravityBombField::tick(float dt)
+    {
+        SUPER(GravityBombField,tick,dt);
+        lifetime_-=dt;
+
+        if(lifetime_ > EXPLOSION_DURATION)//If field is still alive, make it smaller and stronger.
+        {
+            modelScaling_ += ((CENTRE_MODEL_END_SIZE-1) / FORCE_FIELD_LIFETIME)*dt;
+            forceStrength_ *= (1+dt/10);
+            forceSphereRadius_ = FORCE_SPHERE_START_RADIUS*(1-((FORCE_FIELD_LIFETIME-lifetime_)/FORCE_FIELD_LIFETIME)*((FORCE_FIELD_LIFETIME-lifetime_)/FORCE_FIELD_LIFETIME)*((FORCE_FIELD_LIFETIME-lifetime_)/FORCE_FIELD_LIFETIME));
+        }
+        else if(lifetime_ > 0)
+        {
+            if (!fieldExploded_) // Start the field explosion if it has not been started yet.
+            {
+                forceStrength_ = pow((EXPLOSION_DURATION + lifetime_),4)/EXPLOSION_DURATION * PEAK_EXPLOSION_FORCE;
+                fieldExploded_ = true;
+
+                //Add particle effect to visualize explosion
+                explosionCross_ = new ParticleEmitter(this->getContext());
+                explosionCross_->setSource("Orxonox/FieldExplosion");
+                explosionCross_->setOrientation(rnd(), rnd(), rnd(), rnd());
+                explosionCross_->setScale(0.7);
+                this->attach(explosionCross_);
+
+                //Add explosion sound effect.
+                explosionSound_ = new WorldSound(getContext());
+                explosionSound_->setSource("sounds/GravityFieldExplosion.ogg");
+                explosionSound_->setVolume(1.0);
+                explosionSound_->play();
+            }
+
+            //Check if any pawn is inside the shockwave and hit it with dammage proportional to the distance between explosion centre and pawn. Make sure, the same pawn is damaged only once.
+            for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+            {
+                Vector3 distanceVector = it->getWorldPosition()-this->getWorldPosition();
+                 //orxout(debug_output) << "Found Pawn:" << it->getWorldPosition() << endl;
+                if(distanceVector.length()< forceSphereRadius_)
+                {
+                    //orxout(debug_output) << "Force sphere radius is: " << forceSphereRadius_ << " Distance to Pawn is: " << distanceVector.length();
+                    if (std::find(victimsAlreadyDamaged_.begin(),victimsAlreadyDamaged_.end(),*it) == victimsAlreadyDamaged_.end())
+                    {
+                        //orxout(debug_output) << "Found Pawn to damage: " << it->getWorldPosition() << endl;
+                        float damage = FORCE_FIELD_EXPLOSION_DAMMAGE*(1-distanceVector.length()/EXPLOSION_RADIUS);
+                        //orxout(debug_output) << "Damage: " << damage << endl;
+                        it->hit(shooter_, it->getWorldPosition(), NULL, damage, 0,0);
+                        victimsAlreadyDamaged_.push_back(*it);
+                    }
+                }
+            }
+
+            forceSphereRadius_ = EXPLOSION_RADIUS*(1-lifetime_/EXPLOSION_DURATION);
+            explosionCross_->setScale(forceSphereRadius_/FORCE_SPHERE_START_RADIUS);
+        }
+        else if (lifetime_ > -6) //The field has to exist for 6 more seconds for the particles of the particle effect to vanish smoothly.
+        {
+            //Make the bomb model invisible, let the strength of the field be zero and remove all particle emitters so the particle effect will slowly vanish.
+            bombModel_->setVisible(false);
+            this->setRadarVisibility(false);
+            forceStrength_ = 0;
+            forceSphereRadius_ = 0.00001;
+            particleSphere_->getParticleInterface()->removeAllEmitters();
+            explosionCross_->getParticleInterface()->removeAllEmitters();
+        }
+        
+        setDiameter(forceSphereRadius_*2);
+        setVelocity(forceStrength_);
+        if(lifetime_>0) particleSphere_->setScale(forceSphereRadius_/FORCE_SPHERE_START_RADIUS);
+        bombModel_->setScale(modelScaling_);
+
+        if (lifetime_ <= -4)
+        {
+            orxout(debug_output) << "Timeout. Destroying field." << endl;
+            this->destroy();
+        }
+    }
+
+    void GravityBombField::destroy()
+    {
+        ForceField::destroy();
+    }
+
+}
Index: code/trunk/src/modules/weapons/projectiles/GravityBombField.h
===================================================================
--- code/trunk/src/modules/weapons/projectiles/GravityBombField.h	(revision 10622)
+++ code/trunk/src/modules/weapons/projectiles/GravityBombField.h	(revision 10622)
@@ -0,0 +1,90 @@
+/*
+ * GravityBombField.h
+ *
+ *  Created on: Apr 2, 2015
+ *      Author: meggiman
+ */
+
+#ifndef GRAVITYBOMBFIELD_H_
+#define GRAVITYBOMBFIELD_H_
+
+#include "graphics/ParticleSpawner.h"
+#include "interfaces/RadarViewable.h"
+#include "objects/ForceField.h"
+#include "BasicProjectile.h"
+#include "worldentities/MovableEntity.h"
+#include "core/CoreIncludes.h"
+#include "GravityBomb.h"
+#include "graphics/ParticleSpawner.h"
+#include "tools/ParticleInterface.h"
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+#include "graphics/Backlight.h"
+#include "sound/WorldSound.h"
+
+namespace orxonox {
+
+/**
+ * @class   GravityBombField
+ *
+ * @brief   This class is used by GravityBomb to place the ForceField and Visual effect to the environment.
+ *          The field has a maximum lifetime and gets smaller and stronger the more time passes. In the end, the field explodes and damages all pawns nearby.
+ *
+ * @author  Manuel Eggimann
+ * @date    23.05.2015
+ */
+class GravityBombField: public ForceField, public RadarViewable {
+public:
+    GravityBombField(Context* context);
+    virtual ~GravityBombField();
+    virtual void tick(float dt);
+    virtual void destroy();
+
+    /**
+     * @fn  void GravityBombField::setShooter(Pawn* shooter)
+     *
+     * @brief   This function is used to determine save the pawn who created the field and is used inside the GravityBomb class.
+     *
+     * @author  Manuel Eggimann
+     * @date    23.05.2015
+     *
+     * @param [in,out]  the Pawn that created the field.
+     */
+    void setShooter(Pawn* shooter)
+    { this->shooter_ = shooter; }
+
+    Pawn* getShooter()
+    { return this->shooter_; }
+
+private:
+    //Set these constants inside GravityBombField.cc to alter the behaviour of the field.
+    
+    static const float FORCE_FIELD_LIFETIME;    ///< The lifetime of the ForceField in seconds. After lifetime seconds, has already exploded and the particle effects will start to vanish. 
+    static const float FORCE_SPHERE_START_RADIUS;   ///< The initial sphere radius of the Force Field. The forcefield gets smaller by time.
+    static const float FORCE_SPHERE_START_STRENGTH; ///< The initial Force the Field exerts on every object with non-zero mass.
+    static const float FORCE_FIELD_EXPLOSION_DAMMAGE;   ///< The maximum dammage a pawn gets nearby an exploding field. The farer away from explosion center the smaller the dammage.
+    static const float EXPLOSION_DURATION;  ///< Determines how fast the shockwave of the Explosion expands. It takes GravityBombField::EXPLOSION_DURATION seconds for the field to expand from 0 radius to GravityBombField::EXPLOSION_RADIUS.
+    static const float EXPLOSION_RADIUS;    ///< How far does the shockwave reach. All pawns which outside of a sphere witch this radius rest unharmed by the explosion.
+    static const float PEAK_ANGULAR_VELOCITY;   ///< The model of the bomb in the center of the Field does rotate faster and faster as time passes until it reaches PEAK_ANGULAR_VELOCITY at the fields end of life.
+    static const float PEAK_EXPLOSION_FORCE;    ///< The peak force the explosion exerts on the pawns nearby.
+    static const float CENTRE_MODEL_END_SIZE;   ///< Size of the 3d-model of the bomb in the fields centre.
+
+    float forceSphereRadius_;
+    float forceStrength_;
+    float lifetime_;
+    float modelScaling_;
+    Vector3 rotationVector_;
+    bool fieldExploded_;
+    ParticleEmitter * particleSphere_;
+    ParticleEmitter * explosionCross_;
+    std::vector<Pawn*> victimsAlreadyDamaged_;
+    MovableEntity * bombModel_;
+    Pawn* shooter_;
+    Backlight* centreLight_;
+    WorldSound* explosionSound_;
+};
+
+}
+#endif /* GRAVITYBOMBFIELD_H_ */
+
Index: code/trunk/src/modules/weapons/projectiles/LightningGunProjectile.cc
===================================================================
--- code/trunk/src/modules/weapons/projectiles/LightningGunProjectile.cc	(revision 10299)
+++ code/trunk/src/modules/weapons/projectiles/LightningGunProjectile.cc	(revision 10622)
@@ -47,4 +47,6 @@
 
         this->textureIndex_ = 1;
+        this->setMass(2);
+        this->setCollisionType(Dynamic);
         this->maxTextureIndex_ = 8;
         this->textureTimer_.setTimer(0.01f, true, createExecutor(createFunctor(&LightningGunProjectile::changeTexture, this)));
Index: code/trunk/src/modules/weapons/projectiles/Rocket.cc
===================================================================
--- code/trunk/src/modules/weapons/projectiles/Rocket.cc	(revision 10299)
+++ code/trunk/src/modules/weapons/projectiles/Rocket.cc	(revision 10622)
@@ -48,4 +48,5 @@
 #include "worldentities/CameraPosition.h"
 #include "worldentities/pawns/Pawn.h"
+//#include "particleuniverse/include/ParticleUniverseSystemManager.h"
 
 namespace orxonox
@@ -83,4 +84,9 @@
             fire->setOrientation(this->getOrientation());
             fire->setSource("Orxonox/rocketfire");
+            
+            // Add Particle Universe Effects
+            //ParticleUniverse::ParticleSystemManager* pManager = ParticleUniverse::ParticleSystemManager::getSingletonPtr();
+            //ParticleUniverse::ParticleSystem* pSys1 = pManager->createParticleSystem("pSys1", "bubbles", this->getScene()->getSceneManager());
+            //this->attachOgreObject(pSys1);
 
             this->enableCollisionCallback();
@@ -223,9 +229,12 @@
     void Rocket::destructionEffect()
     {
-        ParticleSpawner *effect1, *effect2;
+        ParticleSpawner *effect1, *effect2, *effect3, *effect4, *effect5;
         if(this->getShooter())
         {
             effect1 = new ParticleSpawner(this->getShooter()->getContext());
             effect2 = new ParticleSpawner(this->getShooter()->getContext());
+            effect3 = new ParticleSpawner(this->getShooter()->getContext());
+            effect4 = new ParticleSpawner(this->getShooter()->getContext());
+            effect5 = new ParticleSpawner(this->getShooter()->getContext());
         }
         else
@@ -233,4 +242,7 @@
             effect1 = new ParticleSpawner(this->getContext());
             effect2 = new ParticleSpawner(this->getContext());
+            effect3 = new ParticleSpawner(this->getContext());
+            effect4 = new ParticleSpawner(this->getContext());
+            effect5 = new ParticleSpawner(this->getContext());
         }
 
@@ -238,5 +250,5 @@
         effect1->setOrientation(this->getOrientation());
         effect1->setDestroyAfterLife(true);
-        effect1->setSource("Orxonox/explosion4");
+        effect1->setSource("orxonox/explosion_flash");
         effect1->setLifetime(2.0f);
 
@@ -244,6 +256,24 @@
         effect2->setOrientation(this->getOrientation());
         effect2->setDestroyAfterLife(true);
-        effect2->setSource("Orxonox/smoke4");
+        effect2->setSource("orxonox/explosion_flame");
         effect2->setLifetime(3.0f);
+
+        effect3->setPosition(this->getPosition());
+        effect3->setOrientation(this->getOrientation());
+        effect3->setDestroyAfterLife(true);
+        effect3->setSource("orxonox/explosion_shockwave");
+        effect3->setLifetime(3.0f);
+
+        effect4->setPosition(this->getPosition());
+        effect4->setOrientation(this->getOrientation());
+        effect4->setDestroyAfterLife(true);
+        effect4->setSource("orxonox/explosion_sparks");
+        effect4->setLifetime(3.0f);
+
+        effect5->setPosition(this->getPosition());
+        effect5->setOrientation(this->getOrientation());
+        effect5->setDestroyAfterLife(true);
+        effect5->setSource("orxonox/explosion_streak1");
+        effect5->setLifetime(3.0f);
     }
 
Index: code/trunk/src/modules/weapons/projectiles/RocketOld.cc
===================================================================
--- code/trunk/src/modules/weapons/projectiles/RocketOld.cc	(revision 10622)
+++ code/trunk/src/modules/weapons/projectiles/RocketOld.cc	(revision 10622)
@@ -0,0 +1,298 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Oliver Scheuss
+ *   Co-authors:
+ *      simonmie
+ *
+ */
+
+/**
+    @file RocketOld.h
+    @brief Implementation of the RocketOld class.
+*/
+
+#include "RocketOld.h"
+
+#include <BulletDynamics/Dynamics/btRigidBody.h>
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+
+#include "Scene.h"
+#include "controllers/Controller.h"
+#include "graphics/Model.h"
+#include "graphics/ParticleSpawner.h"
+#include "infos/PlayerInfo.h"
+#include "objects/collisionshapes/ConeCollisionShape.h"
+#include "sound/WorldSound.h"
+#include "worldentities/CameraPosition.h"
+#include "worldentities/pawns/Pawn.h"
+//#include "particleuniverse/include/ParticleUniverseSystemManager.h"
+
+namespace orxonox
+{
+    RegisterClass(RocketOld);
+
+    /**
+    @brief
+        Constructor. Registers the object and initializes some default values.
+    */
+    RocketOld::RocketOld(Context* context)
+        : ControllableEntity(context)
+        , BasicProjectile()
+        , RadarViewable(this, static_cast<WorldEntity*>(this))
+    {
+        RegisterObject(RocketOld);// Register the RocketOld class to the core
+
+        this->localAngularVelocity_ = 0;
+        this->lifetime_ = 100.0f;
+
+        if (GameMode::isMaster())
+        {
+            this->setCollisionType(WorldEntity::Kinematic);
+            this->setVelocity(0,0,-100);
+
+            // Create RocketOld model
+            Model* model = new Model(this->getContext());
+            model->setMeshSource("rocket.mesh");
+            model->scale(0.7f);
+            this->attach(model);
+
+            // Add effects.
+            ParticleEmitter* fire = new ParticleEmitter(this->getContext());
+            this->attach(fire);
+            fire->setOrientation(this->getOrientation());
+            fire->setSource("Orxonox/rocketfire");
+            
+            // Add Particle Universe Effects
+            //ParticleUniverse::ParticleSystemManager* pManager = ParticleUniverse::ParticleSystemManager::getSingletonPtr();
+            //ParticleUniverse::ParticleSystem* pSys1 = pManager->createParticleSystem("pSys1", "bubbles", this->getScene()->getSceneManager());
+            //this->attachOgreObject(pSys1);
+
+            this->enableCollisionCallback();
+            this->setCollisionResponse(false);
+            this->setCollisionType(Kinematic);
+
+            // Add collision shape
+            ConeCollisionShape* collisionShape = new ConeCollisionShape(this->getContext());
+            collisionShape->setRadius(3);
+            collisionShape->setHeight(500);
+            this->attachCollisionShape(collisionShape);
+
+            this->destroyTimer_.setTimer(this->lifetime_, false, createExecutor(createFunctor(&BasicProjectile::destroyObject, this)));
+
+            // Add sound
+            this->defSndWpnEngine_ = new WorldSound(this->getContext());
+            this->defSndWpnEngine_->setLooping(true);
+            this->defSndWpnEngine_->setSource("sounds/Rocket_engine.ogg");
+            this->defSndWpnEngine_->setVolume(1.0f);
+            this->attach(defSndWpnEngine_);
+
+            this->defSndWpnLaunch_ = new WorldSound(this->getContext());
+            this->defSndWpnLaunch_->setLooping(false);
+            this->defSndWpnLaunch_->setSource("sounds/Rocket_launch.ogg");
+            this->defSndWpnLaunch_->setVolume(1.0f);
+            this->attach(defSndWpnLaunch_);
+        }
+        else
+        {
+            this->defSndWpnEngine_ = 0;
+            this->defSndWpnLaunch_ = 0;
+        }
+
+        // Add camera
+        CameraPosition* camPosition = new CameraPosition(this->getContext());
+        camPosition->setPosition(0,4,15);
+        camPosition->setAllowMouseLook(true);
+        this->addCameraPosition(camPosition);
+
+        this->setRadarObjectColour(ColourValue(1.0, 0.5, 0.0)); // orange
+        this->setRadarObjectShape(RadarViewable::Triangle);
+        this->setRadarObjectScale(0.5f);
+    }
+
+    /**
+    @brief
+        Destructor. Destroys controller, if present and kills sounds, if playing.
+    */
+    RocketOld::~RocketOld()
+    {
+        if(this->isInitialized())
+        {
+            if (GameMode::isMaster())
+            {
+                this->destructionEffect();
+
+                if (this->getPlayer() && this->getController())
+                    this->player_->stopTemporaryControl();
+            }
+
+            if ( this->defSndWpnEngine_ )
+                this->defSndWpnEngine_->destroy();
+
+            if ( this->defSndWpnLaunch_ )
+                this->defSndWpnLaunch_->destroy();
+        }
+    }
+
+    /**
+    @brief
+        Sets the entity that fired the RocketOld.
+    @param shooter
+        A pointer to the Pawn that fired the RocketOld.
+    */
+    void RocketOld::setShooter(Pawn* shooter)
+    {
+        this->BasicProjectile::setShooter(shooter);
+        
+        this->player_ = this->getShooter()->getPlayer();
+        if(this->player_)
+            this->player_->startTemporaryControl(this);
+
+        if( GameMode::isMaster() )
+        {
+            this->defSndWpnEngine_->play();
+            this->defSndWpnLaunch_->play();
+        }
+    }
+
+    /**
+    @brief
+        Defines which actions the RocketOld has to take in each tick.
+    @param dt
+        The length of the tick.
+    */
+    void RocketOld::tick(float dt)
+    {
+        SUPER(RocketOld, tick, dt);
+
+        if( this->hasLocalController() )
+        {
+            this->setAngularVelocity(this->getOrientation() * this->localAngularVelocity_);
+            this->setVelocity( this->getOrientation()*WorldEntity::FRONT*this->getVelocity().length() );
+            this->localAngularVelocity_ = 0;
+        }
+
+       this->destroyCheck();
+    }
+
+    bool RocketOld::collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint)
+    {
+        return this->processCollision(otherObject, contactPoint, cs);
+    }
+
+    /**
+    @brief
+        Destroys the RocketOld and stops the sound,
+    */
+    void RocketOld::destroyObject(void)
+    {
+        if (GameMode::isMaster() && this->defSndWpnEngine_->isPlaying())
+            this->defSndWpnEngine_->stop();
+
+        this->BasicProjectile::destroyObject();
+    }
+
+    /**
+    @brief
+        Destroys the RocketOld upon pressing "fire".
+    */
+    void RocketOld::fired(unsigned int firemode)
+    {
+        this->destroyObject();
+    }
+
+    /**
+    @brief
+        The effects that are displayed, when the RocketOld is destroyed.
+    */
+    void RocketOld::destructionEffect()
+    {
+        ParticleSpawner *effect1, *effect2;
+        if(this->getShooter())
+        {
+            effect1 = new ParticleSpawner(this->getShooter()->getContext());
+            effect2 = new ParticleSpawner(this->getShooter()->getContext());
+        }
+        else
+        {
+            effect1 = new ParticleSpawner(this->getContext());
+            effect2 = new ParticleSpawner(this->getContext());
+        }
+
+        effect1->setPosition(this->getPosition());
+        effect1->setOrientation(this->getOrientation());
+        effect1->setDestroyAfterLife(true);
+        effect1->setSource("Orxonox/explosion4");
+        effect1->setLifetime(2.0f);
+
+        effect2->setPosition(this->getPosition());
+        effect2->setOrientation(this->getOrientation());
+        effect2->setDestroyAfterLife(true);
+        effect2->setSource("Orxonox/smoke4");
+        effect2->setLifetime(3.0f);
+    }
+
+    /**
+    @brief
+        Rotates the RocketOld around the y-axis by the amount specified by the first component of the input 2-dim vector.
+    @param value
+        The vector determining the amount of the angular movement.
+    */
+    void RocketOld::rotateYaw(const Vector2& value)
+    {
+        ControllableEntity::rotateYaw(value);
+
+        if( !this->isInMouseLook() )
+            this->localAngularVelocity_.y += value.x;
+    }
+
+    /**
+    @brief
+        Rotates the RocketOld around the x-axis by the amount specified by the first component of the input 2-dim vector.
+    @param value
+        The vector determining the amount of the angular movement.
+    */
+    void RocketOld::rotatePitch(const Vector2& value)
+    {
+        ControllableEntity::rotatePitch(value);
+
+        if( !this->isInMouseLook() )
+            this->localAngularVelocity_.x += value.x;
+    }
+
+    /**
+    @brief
+        Rotates the RocketOld around the z-axis by the amount specified by the first component of the input 2-dim vector.
+    @param value
+        The vector determining the amount of the angular movement.
+    */
+    void RocketOld::rotateRoll(const Vector2& value)
+    {
+        ControllableEntity::rotateRoll(value);
+
+        if( !this->isInMouseLook() )
+            this->localAngularVelocity_.z += value.x;
+    }
+
+}
Index: code/trunk/src/modules/weapons/projectiles/RocketOld.h
===================================================================
--- code/trunk/src/modules/weapons/projectiles/RocketOld.h	(revision 10622)
+++ code/trunk/src/modules/weapons/projectiles/RocketOld.h	(revision 10622)
@@ -0,0 +1,134 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Oliver Scheuss
+ *   Co-authors:
+ *      simonmie
+ *
+ */
+
+/**
+    @file RocketOld.h
+    @brief Definition of the RocketOld class.
+*/
+
+#ifndef _RocketOld_H__
+#define _RocketOld_H__
+
+#include "weapons/WeaponsPrereqs.h"
+
+#include "tools/Timer.h"
+
+#include "interfaces/RadarViewable.h"
+#include "worldentities/ControllableEntity.h"
+
+#include "BasicProjectile.h"
+
+namespace orxonox
+{
+    class ConeCollisionShape;
+
+    /**
+    @brief
+        RocketOld that can be steered by the player.
+
+    @author
+        Oli Scheuss
+    @ingroup WeaponsProjectiles
+    */
+    class _WeaponsExport RocketOld : public ControllableEntity, public BasicProjectile, public RadarViewable
+    {
+        public:
+            RocketOld(Context* context);
+            virtual ~RocketOld();
+
+            virtual void tick(float dt); //!< Defines which actions the RocketOld has to take in each tick.
+
+            virtual bool collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint);
+            virtual void destroyObject(void);
+            void destructionEffect();
+
+            virtual void moveFrontBack(const Vector2& value) {}
+            virtual void moveRightLeft(const Vector2& value) {}
+            virtual void moveUpDown(const Vector2& value) {}
+
+            virtual void rotateYaw(const Vector2& value);
+            virtual void rotatePitch(const Vector2& value);
+            virtual void rotateRoll(const Vector2& value);
+
+            /**
+            @brief Moves the RocketOld in the Front/Back-direction by the specifed amount.
+            @param value  The amount by which the RocketOld is to be moved.
+            */
+            inline void moveFrontBack(float value)
+                { this->moveFrontBack(Vector2(value, 0)); }
+            /**
+            @brief Moves the RocketOld in the Right/Left-direction by the specifed amount.
+            @param value  The amount by which the RocketOld is to be moved.
+            */
+            inline void moveRightLeft(float value)
+                { this->moveRightLeft(Vector2(value, 0)); }
+            /**
+            @brief Moves the RocketOld in the Up/Down-direction by the specifed amount.
+            @param value  The amount by which the RocketOld is to be moved.
+            */
+            inline void moveUpDown(float value)
+                { this->moveUpDown(Vector2(value, 0)); }
+
+            /**
+            @brief Rotates the RocketOld around the y-axis by the specifed amount.
+            @param value  The amount by which the RocketOld is to be rotated.
+            */
+            inline void rotateYaw(float value)
+                { this->rotateYaw(Vector2(value, 0)); }
+            /**
+            @brief Rotates the RocketOld around the x-axis by the specifed amount.
+            @param value  The amount by which the RocketOld is to be rotated.
+            */
+            inline void rotatePitch(float value)
+                { this->rotatePitch(Vector2(value, 0)); }
+            /**
+            @brief Rotates the RocketOld around the z-axis by the specifed amount.
+            @param value  The amount by which the RocketOld is to be rotated.
+            */
+            inline void rotateRoll(float value)
+                { this->rotateRoll(Vector2(value, 0)); }
+
+            virtual void setShooter(Pawn* shooter);
+
+            virtual void fired(unsigned int firemode);
+
+        private:
+            Vector3 localAngularVelocity_; //!< Variable to temporarily store accumulated steering command input.
+
+            WeakPtr<PlayerInfo> player_; //!< The player that controls the RocketOld.
+            //WeakPtr<Pawn> pawn_; //!< The pawn that controls the RocketOld. TODO
+            Timer destroyTimer_; //!< Timer to destroy the projectile after its lifetime has run out.
+            float lifetime_; //!< The time the projectile exists.
+
+            WorldSound* defSndWpnEngine_; //!< Engine sound.
+            WorldSound* defSndWpnLaunch_; //!< Launch sound.
+    };
+
+}
+
+#endif /* _RocketOld_H__ */
Index: code/trunk/src/modules/weapons/weaponmodes/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/weapons/weaponmodes/CMakeLists.txt	(revision 10299)
+++ code/trunk/src/modules/weapons/weaponmodes/CMakeLists.txt	(revision 10622)
@@ -6,4 +6,6 @@
   LightningGun.cc
   RocketFire.cc
+  RocketFireOld.cc
   SimpleRocketFire.cc
+  GravityBombFire.cc
 )
Index: code/trunk/src/modules/weapons/weaponmodes/EnergyDrink.cc
===================================================================
--- code/trunk/src/modules/weapons/weaponmodes/EnergyDrink.cc	(revision 10299)
+++ code/trunk/src/modules/weapons/weaponmodes/EnergyDrink.cc	(revision 10622)
@@ -108,4 +108,5 @@
         model->setScale(5);
 
+        this->computeMuzzleParameters(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn()->getAimPosition());
         projectile->setOrientation(this->getMuzzleOrientation());
         projectile->setPosition(this->getMuzzlePosition());
Index: code/trunk/src/modules/weapons/weaponmodes/FusionFire.cc
===================================================================
--- code/trunk/src/modules/weapons/weaponmodes/FusionFire.cc	(revision 10299)
+++ code/trunk/src/modules/weapons/weaponmodes/FusionFire.cc	(revision 10622)
@@ -68,4 +68,5 @@
         BillboardProjectile* projectile = new BillboardProjectile(this->getContext());
 
+        this->computeMuzzleParameters(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn()->getAimPosition());
         projectile->setOrientation(this->getMuzzleOrientation());
         projectile->setPosition(this->getMuzzlePosition());
Index: code/trunk/src/modules/weapons/weaponmodes/GravityBombFire.cc
===================================================================
--- code/trunk/src/modules/weapons/weaponmodes/GravityBombFire.cc	(revision 10622)
+++ code/trunk/src/modules/weapons/weaponmodes/GravityBombFire.cc	(revision 10622)
@@ -0,0 +1,56 @@
+/*
+ * GravityBombFire.cc
+ *
+ *  Created on: Apr 16, 2015
+ *      Author: Manuel Eggimann
+ */
+#include "GravityBombFire.h"
+
+#include "core/CoreIncludes.h"
+#include "weaponsystem/Weapon.h"
+#include "weaponsystem/WeaponPack.h"
+#include "weaponsystem/WeaponSystem.h"
+#include "worldentities/pawns/Pawn.h"
+
+#include "weapons/projectiles/GravityBomb.h"
+
+namespace orxonox
+{
+    RegisterClass(GravityBombFire);
+
+    const float GravityBombFire::BOMB_VELOCITY = 600.0; ///< The velocity of the bomb after launch
+
+    GravityBombFire::GravityBombFire(Context* context) : WeaponMode(context)
+    {
+        RegisterObject(GravityBombFire);
+
+        this->reloadTime_ = 0.50f; 
+        this->bParallelReload_ = false;
+        this->damage_ = 20.0f;  ///< The damage of the Bomb if it hits a pawn.
+
+        this->setMunitionName("GravityBombMunition");
+        this->setDefaultSoundWithVolume("sounds/Rocket_launch.ogg",0.8);    ///< sets sound of the bomb as it is fired.
+    }
+
+    GravityBombFire::~GravityBombFire(){};
+
+    void GravityBombFire::fire()
+    {
+        GravityBomb* bomb = new GravityBomb(this->getContext());
+        //Create a new Bomb in 3D-Space and set the right direction speed and orientation.
+        this->computeMuzzleParameters(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn()->getAimPosition());
+        bomb->setOrientation(this->getMuzzleOrientation());
+        bomb->setPosition(this->getMuzzlePosition());
+        bomb->setVelocity(this->getMuzzleDirection() * (this->BOMB_VELOCITY+this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn()->getVelocity().length()));
+
+        //Set the shooter of the bomb so it is possible to determine the pawn that killed another one and define damage to shield and healt the bomb does.
+        bomb->setShooter(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
+        bomb->setDamage(this->getDamage());
+        bomb->setShieldDamage(this->getShieldDamage());
+        bomb->setHealthDamage(this->getHealthDamage());
+    }
+
+
+}
+
+
Index: code/trunk/src/modules/weapons/weaponmodes/GravityBombFire.h
===================================================================
--- code/trunk/src/modules/weapons/weaponmodes/GravityBombFire.h	(revision 10622)
+++ code/trunk/src/modules/weapons/weaponmodes/GravityBombFire.h	(revision 10622)
@@ -0,0 +1,43 @@
+/*
+* GravityBombFire.h
+*
+*  Created on: Apr 16, 2015
+*      Author: Manuel Eggimann
+*/
+
+/**
+    @file GravityBombFire.h
+    @brief Definition of the GravityBombFire class.
+*/
+
+#ifndef _GravityBombFire_H__
+#define _GravityBombFire_H__
+
+#include "weapons/WeaponsPrereqs.h"
+#include "weaponsystem/WeaponMode.h"
+
+namespace orxonox
+{
+
+    /**
+    *@brief
+    *   Fires the GravityBomb. This class implements everything needed to fire the BasicProjectile GravityBomb.
+    *   Everything that has to do with the bombs behaviour after launching it is implemented in GravityBomb and GravityBombField.
+    *@author
+    *    Manuel Eggimann
+    *@ingroup WeaponsWeaponModes
+    */
+    class _WeaponsExport GravityBombFire : public WeaponMode
+    {
+        public:
+            GravityBombFire(Context* context);
+            virtual ~GravityBombFire();
+
+            virtual void fire();
+
+        private:
+            static const float BOMB_VELOCITY; //!< The initial speed of the bomb when it is launched.
+    };
+}
+
+#endif /* _GravityBombFire_H__ */
Index: code/trunk/src/modules/weapons/weaponmodes/LaserFire.cc
===================================================================
--- code/trunk/src/modules/weapons/weaponmodes/LaserFire.cc	(revision 10299)
+++ code/trunk/src/modules/weapons/weaponmodes/LaserFire.cc	(revision 10622)
@@ -66,4 +66,5 @@
         ParticleProjectile* projectile = new ParticleProjectile(this->getContext());
 
+        this->computeMuzzleParameters(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn()->getAimPosition());
         projectile->setOrientation(this->getMuzzleOrientation());
         projectile->setPosition(this->getMuzzlePosition());
Index: code/trunk/src/modules/weapons/weaponmodes/RocketFireOld.cc
===================================================================
--- code/trunk/src/modules/weapons/weaponmodes/RocketFireOld.cc	(revision 10622)
+++ code/trunk/src/modules/weapons/weaponmodes/RocketFireOld.cc	(revision 10622)
@@ -0,0 +1,86 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Oliver Scheuss
+ *   Co-authors:
+ *      simonmie
+ *
+ */
+
+/**
+    @file RocketFire.h
+    @brief Implementation of the RocketFire class.
+*/
+
+#include "RocketFireOld.h"
+
+#include "core/CoreIncludes.h"
+#include "util/Math.h"
+
+#include "weaponsystem/Weapon.h"
+#include "weaponsystem/WeaponPack.h"
+#include "weaponsystem/WeaponSystem.h"
+#include "worldentities/pawns/Pawn.h"
+
+#include "weapons/projectiles/RocketOld.h"
+
+namespace orxonox
+{
+    RegisterClass(RocketFireOld);
+
+    RocketFireOld::RocketFireOld(Context* context) : WeaponMode(context)
+    {
+        RegisterObject(RocketFireOld);
+
+        this->reloadTime_ = 0.20f;
+        this->bParallelReload_ = false;
+        this->damage_ = 0.0f;
+        this->speed_ = 500.0f;
+
+        this->setMunitionName("RocketMunition");
+        // The firing sound of the Rocket is played in Rocket.cc (because of OpenAl sound positioning)
+    }
+
+    RocketFireOld::~RocketFireOld()
+    {
+    }
+
+    /**
+    @brief
+        Fires the weapon. Creates the Rocket and fires it.
+    */
+    void RocketFireOld::fire()
+    {
+        RocketOld* rocket = new RocketOld(this->getContext());
+
+        this->computeMuzzleParameters(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn()->getAimPosition());
+        rocket->setOrientation(this->getMuzzleOrientation());
+        rocket->setPosition(this->getMuzzlePosition());
+        rocket->setVelocity(this->getMuzzleDirection() * this->speed_);
+        rocket->scale(2);
+
+        rocket->setShooter(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
+        rocket->setDamage(this->getDamage());
+        rocket->setShieldDamage(this->getShieldDamage());
+        rocket->setHealthDamage(this->getHealthDamage());
+    }
+}
Index: code/trunk/src/modules/weapons/weaponmodes/RocketFireOld.h
===================================================================
--- code/trunk/src/modules/weapons/weaponmodes/RocketFireOld.h	(revision 10622)
+++ code/trunk/src/modules/weapons/weaponmodes/RocketFireOld.h	(revision 10622)
@@ -0,0 +1,63 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Oliver Scheuss
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file RocketFireOld.h
+    @brief Definition of the RocketFire class.
+*/
+
+#ifndef _RocketFireOld_H__
+#define _RocketFireOld_H__
+
+#include "weapons/WeaponsPrereqs.h"
+#include "weaponsystem/WeaponMode.h"
+
+namespace orxonox
+{
+
+    /**
+    @brief
+        Fires the (steerable) RocketOld.
+    @author
+        Oliver Scheuss
+    @ingroup WeaponsWeaponModes
+    */
+    class _WeaponsExport RocketFireOld : public WeaponMode
+    {
+        public:
+            RocketFireOld(Context* context);
+            virtual ~RocketFireOld();
+
+            virtual void fire();
+
+        private:
+            float speed_; //!< The speed of the Rocket.
+    };
+}
+
+#endif /* _RocketFireOld_H__ */
