Changeset 10889 for code/branches/particleEffectsHS15/src/modules/weapons/projectiles

Timestamp:

Nov 29, 2015, 9:05:26 PM (10 years ago)

Author:

fvultier

Message:

promised wor for Jannis.

Location:

code/branches/particleEffectsHS15/src/modules/weapons/projectiles

Files:

• MineProjectile.cc (modified) (3 diffs)
• MineProjectile.h (modified) (3 diffs)
• Projectile.h (modified) (1 diff)

code/branches/particleEffectsHS15/src/modules/weapons/projectiles/MineProjectile.cc

@@ -35 +35 @@
 
 #include "core/CoreIncludes.h"
+#include "graphics/Model.h"
 #include "core/command/Executor.h"
-#include "util/Convert.h"
-#include "util/Math.h"
-
-#include "core/CoreIncludes.h"
-#include "graphics/Model.h"
-#include "graphics/ParticleSpawner.h"
-#include "Scene.h"
-#include "core/command/Executor.h"
-#include "tools/ParticleInterface.h"
 
 namespace orxonox
@@ -50 +42 @@
     RegisterClass(MineProjectile);
 
-    MineProjectile::MineProjectile(Context* context) : Projectile(context)
+    MineProjectile::MineProjectile(Context* context) : MovableEntity(context), BasicProjectile()
     {
         RegisterObject(MineProjectile);
 
-        this->lifeTime_ = 1.0f;
+        this->bActive_ = false;
+        this->maxTimeUntilExplosion_ = 10.0f;
+        this->timeUntilActivation_ = 1.0f;
 
-        Model* model = new Model(this->getContext());
-        model->setMeshSource("sphere.mesh");
-        model->setScale(15.0);
-        this->attach(model);
-        model->setPosition(Vector3(0,0,0));
+        rings_ = new MovableEntity(this->getContext());
+        this->attach(rings_);
+        rings_->setPosition(Vector3(0.0,0.0,0.0));
+        rings_->setAngularVelocity(Vector3(0.0,5.0,0.0));
+
+        modelCore_ = new Model(this->getContext());
+        modelCore_->setMeshSource("Mine_Core.mesh");
+        modelCore_->setScale(15.0);
+        this->attach(modelCore_);
+        modelCore_->setPosition(Vector3(0,0,0));
+
+        modelRing1_ = new Model(this->getContext());
+        modelRing1_->setMeshSource("Mine_Ring.mesh");
+        modelRing1_->setScale(15.0);
+        rings_->attach(modelRing1_);
+        modelRing1_->setPosition(Vector3(0,0,0));
+        modelRing1_->yaw(Degree(0));
+
+        modelRing2_ = new Model(this->getContext());
+        modelRing2_->setMeshSource("Mine_Ring.mesh");
+        modelRing2_->setScale(15.0);
+        rings_->attach(modelRing2_);
+        modelRing2_->setPosition(Vector3(0,0,0));
+        modelRing2_->yaw(Degree(180));
+
+        if (GameMode::isMaster())
+        {
+            this->setMass(10.0f);
+            this->setFriction(100.0f);
+            this->enableCollisionCallback();
+            this->setCollisionResponse(false);
+            this->setCollisionType(Dynamic);
+
+            // Create a sphere collision shape and attach it to the projectile.
+            collisionShape_ = new SphereCollisionShape(this->getContext());
+            collisionShape_->setRadius(10.0f);
+            this->attachCollisionShape(collisionShape_);
+
+            // Create a distance trigger and attach it to the projectile.
+            distanceTrigger_ = new DistanceTrigger(this->getContext());
+            this->attach(distanceTrigger_);
+            distanceTrigger_->setPosition(Vector3(0,0,0));
+            distanceTrigger_->setDistance(40.0f);
+            distanceTrigger_->addTarget("Pawn");
+            distanceTrigger_->setStayActive(true);
+        }
     }
 
-    
+    MineProjectile::~MineProjectile()
+    {
+        /*if (modelCore_ != NULL)
+        {
+            modelCore_->destroy();
+        }*/
+        /*if (distanceTrigger_ != NULL)
+        {
+            distanceTrigger_->destroy();
+        }*/
+    }
+
     /**
     @brief
-        This function starts a timer that will cause the projectile to Mine after a time defined by the argument @param LifeTime.        
+        TODO
     */
-    void MineProjectile::setLifeTime(float lifeTime)
+    void MineProjectile::setMaxTimeUntilExplosion(float maxTimeUntilExplosion)
     {
-        orxout() << lifeTime << endl;
-
-        if (lifeTime >= 0)
+        if (maxTimeUntilExplosion >= 0)
         {
-            this->lifeTime_ = lifeTime;
-            this->explodeTimer.setTimer(this->lifeTime_, false, createExecutor(createFunctor(&MineProjectile::Explode, this)));
+            this->maxTimeUntilExplosion_ = maxTimeUntilExplosion;
+            if (GameMode::isMaster())
+            {
+                this->explodeTimer_.setTimer(this->maxTimeUntilExplosion_, false, createExecutor(createFunctor(&MineProjectile::Explode, this)));
+            }
         }
         else
         {
-            this->lifeTime_ = 0;
+            this->maxTimeUntilExplosion_ = 0;
         }
     }
 
+    /**
+    @brief
+        TODO
+    */
+    void MineProjectile::setTimeUntilActivation(float timeUntilActivation)
+    {
+        timeUntilActivation_ = timeUntilActivation;
+
+        if (GameMode::isMaster())
+        {
+            this->activationTimer_.setTimer(this->timeUntilActivation_, false, createExecutor(createFunctor(&MineProjectile::Activate, this)));
+        }
+    }
 
     /**
     @brief
-        This is the setter function for the damageReduction_ variable. The value of the variable is bounded between 0 and 1.
-    */
-
-
-    /**
-    @brief
-        If this function is called the projectile Mines up into many child projectiles. The original projectiles does not get destroyed but it will never Mine up again.
+        TODO
     */
     void MineProjectile::Explode()
     {
-        orxout() << "Explode" << endl;
+        orxout() << "MineProjectile::Explode" << endl;
 
         this->destroyLater();
@@ -102 +156 @@
 
     }
+
+    /**
+    @brief
+        TODO
+    */
+    void MineProjectile::Activate()
+    {
+        orxout() << "MineProjectile::Activate" << endl;
+
+        bActive_ = true;
+    }
 }

code/branches/particleEffectsHS15/src/modules/weapons/projectiles/MineProjectile.h

@@ -28 +28 @@
 
 /**
-    @file IceGunProjectile.h
+    @file MineProjectile.h
     @brief Definition of the MineProjectile class.
 */
@@ -36 +36 @@
 
 #include "weapons/WeaponsPrereqs.h"
-
-#include <string>
 #include "tools/Timer.h"
-#include "Projectile.h"
+#include "worldentities/MovableEntity.h"
+#include "objects/collisionshapes/SphereCollisionShape.h"
+#include "objects/triggers/DistanceTrigger.h"
+#include "BasicProjectile.h"
 
 namespace orxonox
@@ -46 +47 @@
     /**
     @brief
-        The MineProjectile is a projectile that may Mine up into many child projectiles.
-    @author
-        Fabien Vultier
+        TODO
     @ingroup WeaponsProjectiles
     */
-    class _WeaponsExport MineProjectile : public Projectile
+    class _WeaponsExport MineProjectile : public MovableEntity, public BasicProjectile
     {
         public:
             MineProjectile(Context* context);
-            virtual ~MineProjectile() {}
+            virtual ~MineProjectile();
 
-            virtual void setLifeTime(float LifeTime);
-            
+            virtual void setMaxTimeUntilExplosion(float maxTimeUntilExplosion);
+            virtual void setTimeUntilActivation(float timeUntilActivation);
 
+        private:
+            bool bActive_; // The mine can only explode if it is active
+            float maxTimeUntilExplosion_;
+            float timeUntilActivation_;
+            Timer activationTimer_;
+            Timer explodeTimer_;
+            Model* modelCore_;
+            Model* modelRing1_;
+            Model* modelRing2_;
+            MovableEntity* rings_;
 
-        private:            
-            float lifeTime_;
-            Timer explodeTimer;
+            WeakPtr<SphereCollisionShape> collisionShape_; // The collision shape of the projectile.
+            WeakPtr<DistanceTrigger> distanceTrigger_;
 
-            virtual void Explode();            
+            virtual void Activate();
+            virtual void Explode();
     };
 }

code/branches/particleEffectsHS15/src/modules/weapons/projectiles/Projectile.h

@@ -69 +69 @@
         protected:
             virtual void setCollisionShapeRadius(float radius);
+            float lifetime_; //!< The time the projectile exists.
 
         private:
-            float lifetime_; //!< The time the projectile exists.
             Timer destroyTimer_; //!< Timer to destroy the projectile after its lifetime has run out.
-            WeakPtr<SphereCollisionShape> collisionShape_; // The collision shape of the projectile.            
+            WeakPtr<SphereCollisionShape> collisionShape_; // The collision shape of the projectile.
     };
 }