Changeset 10435 for code/branches/weaponFS15/src/modules

Timestamp:

May 7, 2015, 5:43:36 PM (10 years ago)

Author:

meggiman

Message:

Added new models and fixed dammage bug. Bomb now fully working.

Location:

code/branches/weaponFS15/src/modules/weapons

Files:

• projectiles/GravityBomb.cc (modified) (4 diffs)
• projectiles/GravityBomb.h (modified) (1 diff)
• projectiles/GravityBombField.cc (modified) (3 diffs)
• projectiles/GravityBombField.h (modified) (2 diffs)
• weaponmodes/GravityBombFire.cc (modified) (2 diffs)
• weaponmodes/GravityBombFire.h (modified) (1 diff)

code/branches/weaponFS15/src/modules/weapons/projectiles/GravityBomb.cc

@@ -12 +12 @@
         RegisterClass(GravityBomb);
 
+        const float GravityBomb::LIFETIME = 5;
+
         GravityBomb::GravityBomb(Context* context):
                                 BasicProjectile(),
@@ -24 +26 @@
                         {
                                 //Define CollisionType of the bomb
-                                this->timeToLife_= 5;
+                                this->timeToLife_= LIFETIME;
                                 this->setCollisionResponse(false);
                                 this->setCollisionType(WorldEntity::Dynamic);
@@ -35 +37 @@
 
                                 //Create Bomb Model
-                    Model* model = new Model(this->getContext());
-                    model->setMeshSource("rocket.mesh"); //Demo Model from SimpleRocket
-                    model->scale(0.7f);
-                    this->attach(model);
+                    Model* rocketModel = new Model(this->getContext());
+                    rocketModel->setMeshSource("GravityBombRocket.mesh"); //Demo Model from SimpleRocket
+                    rocketModel->scale(3.0f);
+                    this->attach(rocketModel);
+
+                    Model* bombModel =  new Model(this->getContext());
+                    bombModel->setMeshSource("GravityBomb.mesh"); //Demo Model from SimpleRocket
+                                bombModel->scale(3.0f);
+                                this->attach(bombModel);
 
                         }
@@ -82 +89 @@
         {
                 GravityBombField* field = new GravityBombField(this->getContext());
+                field->setShooter(this->getShooter());
                 field->setPosition(getPosition());
                 orxout(debug_output) << "detonating. Creating GravityBombField." <<endl;

code/branches/weaponFS15/src/modules/weapons/projectiles/GravityBomb.h

@@ -65 +65 @@
                         void detonate();
                 private:
+                static const float LIFETIME;
+
                 bool isDetonated_; //Used to check whether the Bomb has to be destroyed during next tick.
                 float timeToLife_; //Time the bomb flies before it explodes.

code/branches/weaponFS15/src/modules/weapons/projectiles/GravityBombField.cc

@@ -15 +15 @@
         const float GravityBombField::FORCE_SPHERE_START_RADIUS = 250;
         const float GravityBombField::FORCE_SPHERE_START_STRENGTH = -500;
+        const float GravityBombField::PEAK_EXPLOSION_FORCE = 1e6;
+        const float GravityBombField::FORCE_FIELD_EXPLOSION_DAMMAGE = 100;
+        const float GravityBombField::EXPLOSION_DURATION = 1;
+        const float GravityBombField::EXPLOSION_RADIUS = 400;
+        const float GravityBombField::PEAK_ANGULAR_VELOCITY = 20;
 
         GravityBombField::GravityBombField(Context* context) : ForceField(context),RadarViewable(this, static_cast<WorldEntity*>(this))
@@ -33 +38 @@
                 this->setRadarObjectScale(0.5f);
 
-                //Attach Demo Model for debuging.
-                        Model* model = new Model(this->getContext());
-                        model->setMeshSource("rocket.mesh"); //Demo Model from SimpleRocket
-                        model->scale(0.7f);
-                        this->attach(model);
+                //Attach Model
+                Model* model = new Model(this->getContext());
+                model->setMeshSource("GravityBomb.mesh"); //Demo Model from SimpleRocket
+                model->scale(3.0f);
+                bombModel_ = new MovableEntity(context);
+                bombModel_->attach(model);
+                this->attach(bombModel_);
+
+                Backlight* centreLight = new Backlight(context);
+                centreLight->setColour(ColourValue(0.9,0.5,0.5,1));
+                centreLight->setScale(1.0);
+                centreLight->setTrailMaterial("Trail/backlighttrail");
+                centreLight->setMaterial("Examples/Flare");
+                centreLight->setLifetime(20);
+                bombModel_->attach(centreLight);
+
+                Vector3 randomRotation;
+                srand(time(NULL));
+                randomRotation.x = rand();
+                randomRotation.y = rand();
+                randomRotation.y = rand();
+                randomRotation.normalise();
+                bombModel_->setAngularAcceleration(randomRotation*(PEAK_ANGULAR_VELOCITY/FORCE_FIELD_LIFETIME));
+
+                //Add Collision Shape
+                SphereCollisionShape* collisionShape = new SphereCollisionShape(context);
+                collisionShape->setRadius(3.0);
+                this->attachCollisionShape(collisionShape);
 
                 this->particleSphere_ = new ParticleEmitter(this->getContext());
                 this->attach(this->particleSphere_);
-
                 particleSphere_->setSource("Orxonox/GravityBombField");
         }
@@ -51 +78 @@
                 SUPER(GravityBombField,tick,dt);
                 lifetime_-=dt;
-                forceStrength_ *= (1+dt/10);
-                if(lifetime_ < 0.2 && !fieldExploded_)
+
+                if(lifetime_ > EXPLOSION_DURATION)
                 {
-                        forceStrength_ *= -2;
-                        forceSphereRadius_ *= 2;
-                        fieldExploded_ = true;
-                        orxout(debug_output) << "Field exploded. Inverting Force." << endl;
+                        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_)
+                        {
+                                forceStrength_ = PEAK_EXPLOSION_FORCE;
+                                fieldExploded_ = true;
+
+                                explosionCross_ = new ParticleEmitter(this->getContext());
+                                this->attach(explosionCross_);
+                                explosionCross_->setSource("Orxonox/FieldExplosion");
+                        }
+
+                        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);
+//                                               it->removeHealth(damage);
+                                                 victimsAlreadyDamaged_.push_back(*it);
+                                         }
+                                 }
+                        }
+
+                        forceSphereRadius_ = EXPLOSION_RADIUS*(1-lifetime_/EXPLOSION_DURATION);
+                        explosionCross_->setScale(forceSphereRadius_/FORCE_SPHERE_START_RADIUS);
+                }
+                else if (lifetime_ > -4)
+                {
+                        bombModel_->setVisible(false);
+                        this->setRadarVisibility(false);
+                        forceStrength_ = 0;
+                        forceSphereRadius_ = 0.00001;
+                        particleSphere_->getParticleInterface()->removeAllEmitters();
+                        explosionCross_->getParticleInterface()->removeAllEmitters();
                 }
 
                 setDiameter(forceSphereRadius_*2);
                 setVelocity(forceStrength_);
+                particleSphere_->setScale(forceSphereRadius_/FORCE_SPHERE_START_RADIUS);
 
-                if(lifetime_ < 0)
+                if (lifetime_ <= -4)
                 {
                         orxout(debug_output) << "Timeout. Destroying field." << endl;

code/branches/weaponFS15/src/modules/weapons/projectiles/GravityBombField.h

@@ -17 +17 @@
 #include "GravityBomb.h"
 #include "graphics/ParticleSpawner.h"
-
+#include "tools/ParticleInterface.h"
+#include <stdlib.h>
+#include <time.h>
+#include "graphics/Backlight.h"
 
 namespace orxonox {
@@ -26 +29 @@
         virtual void tick(float dt);
         virtual void destroy();
+
+        void setShooter(Pawn* shooter)
+        { this->shooter_ = shooter; }
+
+        Pawn* getShooter()
+        { return this->shooter_; }
+
 private:
         static const float FORCE_FIELD_LIFETIME;
         static const float FORCE_SPHERE_START_RADIUS;
         static const float FORCE_SPHERE_START_STRENGTH;
+        static const float FORCE_FIELD_EXPLOSION_DAMMAGE;
+        static const float EXPLOSION_DURATION;
+        static const float EXPLOSION_RADIUS;
+        static const float PEAK_ANGULAR_VELOCITY;
+        static const float PEAK_EXPLOSION_FORCE;
 
         float forceSphereRadius_;
         float forceStrength_;
         float lifetime_;
+        Vector3 rotationVector_;
         bool fieldExploded_;
         ParticleEmitter * particleSphere_;
-
+        ParticleEmitter * explosionCross_;
+        std::vector<Pawn*> victimsAlreadyDamaged_;
+        MovableEntity * bombModel_;
+        Pawn* shooter_;
 };
 

code/branches/weaponFS15/src/modules/weapons/weaponmodes/GravityBombFire.cc

@@ -19 +19 @@
         RegisterClass(GravityBombFire);
 
+        const float GravityBombFire::BOMB_VELOCITY = 400.0;
+
         GravityBombFire::GravityBombFire(Context* context) : WeaponMode(context)
         {
@@ -26 +28 @@
                 this->bParallelReload_ = false;
                 this->damage_ = 0.0f;
-                this->speed_ = 100.0f;
+                this->speed_ = BOMB_VELOCITY;
 
                 this->setMunitionName("GravityBombMunition");

code/branches/weaponFS15/src/modules/weapons/weaponmodes/GravityBombFire.h

@@ -58 +58 @@
         private:
             float speed_; //!< The initial speed of the bomb when it is launched.
+            static const float BOMB_VELOCITY;
     };
 }