Changeset 10889

Timestamp:

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

Author:

fvultier

Message:

promised wor for Jannis.

Location:

code/branches/particleEffectsHS15

Files:

• data/levels/includes/weaponSettingsEscort.oxi (modified) (1 diff)
• src/modules/weapons/WeaponsPrereqs.h (modified) (1 diff)
• src/modules/weapons/projectiles/MineProjectile.cc (modified) (3 diffs)
• src/modules/weapons/projectiles/MineProjectile.h (modified) (3 diffs)
• src/modules/weapons/projectiles/Projectile.h (modified) (1 diff)
• src/modules/weapons/weaponmodes/MineGun.cc (modified) (4 diffs)
• src/modules/weapons/weaponmodes/MineGun.h (modified) (2 diffs)

code/branches/particleEffectsHS15/data/levels/includes/weaponSettingsEscort.oxi

@@ -14 +14 @@
         </links>
         <Weapon>
-          <MineGun mode=0 munitionpershot=0 delay=0.125 damage=9.3 muzzleoffset=" 0.1, 1.4,-3" />
+          <MineGun mode=0 munitionpershot=0 delay=0.125 damage=9.3 muzzleoffset=" 0.1, 1.4,-3" maxtimeuntilexplosion=5 timeuntilactivation=1.5/>
         </Weapon>
         <Weapon>

code/branches/particleEffectsHS15/src/modules/weapons/WeaponsPrereqs.h

@@ -93 +93 @@
     class LaserFire;
     class LightningGun;
+    class MineGun;
     class RocketFire;
     class RocketFireOld;

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.
     };
 }

code/branches/particleEffectsHS15/src/modules/weapons/weaponmodes/MineGun.cc

@@ -51 +51 @@
         RegisterObject(MineGun);
 
+        this->speed_ = 0.0f;
         this->reloadTime_ = 1.0f;
         this->damage_ = 0.0f;
-        this->speed_ = 0.0f;
-        this->lifeTime_ = 7500.0f;
+        this->maxTimeUntilExplosion_ = 0.0f;
 
         this->setMunitionName("MineMunition");
@@ -66 +66 @@
     /**
     @brief
-        XMLPort for the MineGun. You can define how often the projectiles Mine, how many childs should be created per Mine, the spread and the time between two Mines.
+        XMLPort for the MineGun.
     */
     void MineGun::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
         SUPER(MineGun, XMLPort, xmlelement, mode);
-        XMLPortParam(MineGun, "Lifetime", setLifeTime, getLifeTime, xmlelement, mode);
+
+        XMLPortParam(MineGun, "maxtimeuntilexplosion", setMaxTimeUntilExplosion, getMaxTimeUntilExplosion, xmlelement, mode).defaultValues(10.0f);
+        XMLPortParam(MineGun, "timeuntilactivation", setTimeUntilActivation, getTimeUntilActivation, xmlelement, mode).defaultValues(3.0f);
     }
 
@@ -81 +83 @@
     {
         MineProjectile* projectile = new MineProjectile(this->getContext());
-        //projectile->setMaterial("Flares/energyflare");
 
         this->computeMuzzleParameters(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn()->getAimPosition());
@@ -88 +89 @@
         projectile->setVelocity(this->getMuzzleDirection() * this->speed_);
 
-        // Pass important information to the projectile: Number of Mines, Number of childs, Mine time, spread and the damage reduction
-        /*projectile->setNumberOfMines(getNumberOfMines());
-        projectile->setNumberOfChilds(getNumberOfChilds());*/
-        projectile->setLifeTime(getLifeTime());
-        /*projectile->setSpread(getSpread());
-        projectile->setDamageReduction(getDamageReduction());*/
+        projectile->setMaxTimeUntilExplosion(getMaxTimeUntilExplosion());
+        projectile->setTimeUntilActivation(getTimeUntilActivation());
 
         projectile->setShooter(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());

code/branches/particleEffectsHS15/src/modules/weapons/weaponmodes/MineGun.h

@@ -44 +44 @@
     @brief
         A Mine that explodes when a ship is too close
-    @author
-        Fabien Vultier
     @ingroup WeaponsWeaponModes
     */
@@ -56 +54 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void fire();
-            inline void setLifeTime(float lifeTime)
-                { this->lifeTime_ = lifeTime; }
-            inline float getLifeTime() const
-                { return this->lifeTime_; }
 
-       private:
+            inline float getMaxTimeUntilExplosion() const
+                { return this->maxTimeUntilExplosion_; }
+            inline float getTimeUntilActivation() const
+                { return this->timeUntilActivation_; }
+        protected:
+            inline void setMaxTimeUntilExplosion(float maxTimeUntilExplosion)
+                { this->maxTimeUntilExplosion_ = maxTimeUntilExplosion; }
+            inline void setTimeUntilActivation(float timeUntilActivation)
+                { this->timeUntilActivation_ = timeUntilActivation; }
+        private:
             float speed_; //The speed of the fired projectile.
-            float lifeTime_;
-
+            float maxTimeUntilExplosion_;
+            float timeUntilActivation_;
     };
 }