Changeset 12284 for code/branches/Boxhead_FS19/src/modules

Timestamp:

Apr 4, 2019, 5:13:42 PM (6 years ago)

Author:

cwaupoti

Message:

added working HoverGun

Location:

code/branches/Boxhead_FS19/src/modules/weapons

Files:

• projectiles/HoverGunProjectile.cc (modified) (3 diffs)
• projectiles/HoverGunProjectile.h (modified) (3 diffs)
• weaponmodes/HoverGun.cc (modified) (5 diffs)
• weaponmodes/HoverGun.h (modified) (4 diffs)
• weaponmodes/IceGun.cc (modified) (1 diff)
• weaponmodes/LightningGun.cc (modified) (2 diffs)

code/branches/Boxhead_FS19/src/modules/weapons/projectiles/HoverGunProjectile.cc

@@ -21 +21 @@
  *
  *   Author:
- *      Joel Smely
+ *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      simonmie
  *
  */
@@ -34 +34 @@
 #include "HoverGunProjectile.h"
 
+#include "core/config/ConfigValueIncludes.h"
 #include "core/CoreIncludes.h"
+#include "core/GameMode.h"
 #include "core/command/Executor.h"
-#include "util/Convert.h"
+
+#include "worldentities/pawns/Pawn.h"
 
 namespace orxonox
@@ -42 +45 @@
     RegisterClass(HoverGunProjectile);
 
-    HoverGunProjectile::HoverGunProjectile(Context* context) : BillboardProjectile(context)
+    HoverGunProjectile::HoverGunProjectile(Context* context) : MovableEntity(context), BasicProjectile()
     {
         RegisterObject(HoverGunProjectile);
 
-        this->textureIndex_ = 1;
-        this->setMass(0.1f);
-        this->setCollisionType(CollisionType::Dynamic);
-        this->maxTextureIndex_ = 8;
-        this->textureTimer_.setTimer(0.01f, true, createExecutor(createFunctor(&HoverGunProjectile::changeTexture, this)));
+        this->setConfigValues();
 
-        registerVariables();
+        // Get notification about collisions
+        if (GameMode::isMaster())
+        {
+            this->setMass(0.0000000001f);
+            this->enableCollisionCallback();
+            this->setCollisionResponse(false);
+            this->setCollisionType(CollisionType::Dynamic);
+
+            // Create a sphere collision shape and attach it to the projectile.
+            collisionShape_ = new SphereCollisionShape(this->getContext());
+            setCollisionShapeRadius(2.0f);
+            this->attachCollisionShape(collisionShape_);
+
+            this->destroyTimer_.setTimer(this->lifetime_, false, createExecutor(createFunctor(&BasicProjectile::destroyObject, this)));
+        }
     }
 
-    void HoverGunProjectile::registerVariables()
+    HoverGunProjectile::~HoverGunProjectile()
     {
-        registerVariable(this->materialBase_);
     }
 
-    /**
-    @brief
-        Set the material.
-    @param material
-        The name of the material. Material names with 1 to 8 appended must exist.
-    */
-    void HoverGunProjectile::setMaterial(const std::string& material)
+    void HoverGunProjectile::setConfigValues()
     {
-        this->materialBase_ = material;
-
-        BillboardProjectile::setMaterial(material + multi_cast<std::string>(this->textureIndex_));
+        SetConfigValue(lifetime_, 4.0f).description("The time in seconds a projectile stays alive");
     }
 
-    /**
-    @brief
-        Change the texture.
-    */
-    void HoverGunProjectile::changeTexture()
+
+    bool HoverGunProjectile::collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint)
     {
-        this->textureIndex_++;
-        if (this->textureIndex_ > this->maxTextureIndex_)
-            this->textureIndex_ = 1;
+        return this->processCollision(otherObject, contactPoint, cs);
+    }
 
-        this->setMaterial(this->materialBase_);
+    void HoverGunProjectile::setCollisionShapeRadius(float radius)
+    {
+        if (collisionShape_ != nullptr && radius > 0)
+        {
+            collisionShape_->setRadius(radius);
+        }        
     }
 }

code/branches/Boxhead_FS19/src/modules/weapons/projectiles/HoverGunProjectile.h

@@ -21 +21 @@
  *
  *   Author:
- *      Joel Smely
+ *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      simonmie
  *
  */
@@ -37 +37 @@
 #include "weapons/WeaponsPrereqs.h"
 
-#include <string>
 #include "tools/Timer.h"
-#include "BillboardProjectile.h"
+#include "worldentities/MovableEntity.h"
+#include "objects/collisionshapes/SphereCollisionShape.h"
+
+#include "BasicProjectile.h"
 
 namespace orxonox
@@ -46 +48 @@
     /**
     @brief
-        The HoverGunProjectile is a projectile that is represented by a looped series of billboards.
-        
+        Represents all 'standard' projectiles.
+
     @author
-        Joel Smely
+        Fabian 'x3n' Landau
+    @author
+        Simon Miescher
     @ingroup WeaponsProjectiles
     */
-    class _WeaponsExport HoverGunProjectile : public BillboardProjectile
+    class _WeaponsExport HoverGunProjectile : public MovableEntity, public BasicProjectile
     {
         public:
             HoverGunProjectile(Context* context);
-            virtual ~HoverGunProjectile() {}
+            virtual ~HoverGunProjectile();
 
-            virtual void setMaterial(const std::string& material) override;
+            void setConfigValues();
 
-/**
-    @file LightningGunProjectile.h
-    @brief Definition of the LightningGunProjectile class.
-*/
+           
+            virtual bool collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint) override;
 
-#ifndef _HoverGunProjectile_H__
-#define _HoverGunProjectile_H__
-
-#include "weapons/WeaponsPrereqs.h"
-
-#include <string>
-#include "tools/Timer.h"
-#include "BillboardProjectile.h"
-
-namespace orxonox
-{
-
-    /**
-    @brief
-        The LightningGunProjectile is a projectile that is represented by a looped series of billboards.
-        
-    @author
-        Joel Smely
-    @ingroup WeaponsProjectiles
-    */
-    class _WeaponsExport HoverGunProjectile : public BillboardProjectile
-    {
-        public:
-            HoverGunProjectile(Context* context);
-            virtual ~HoverGunProjectile() {}
-
-            virtual void setMaterial(const std::string& material) override;
+        protected:
+            virtual void setCollisionShapeRadius(float radius);
+            float lifetime_; //!< The time the projectile exists.
 
         private:
-            void registerVariables();
-            void changeTexture();
-            
-            unsigned int textureIndex_; //!< The current index of the texture. (i.e. the index of the currently displayed texture)
-            unsigned int maxTextureIndex_; //!< The maximal index.
-            Timer textureTimer_; //!< A timer that loops and changes textures each time it expires.
-            std::string materialBase_; //!< The base name of the material.
+            Timer destroyTimer_; //!< Timer to destroy the projectile after its lifetime has run out.
+            WeakPtr<SphereCollisionShape> collisionShape_; // The collision shape of the projectile.
     };
 }
 
-#endif /* _HoverGunProjectile_H__ */
+#endif /* _Projectile_H__ */

code/branches/Boxhead_FS19/src/modules/weapons/weaponmodes/HoverGun.cc

@@ -21 +21 @@
  *
  *   Author:
- *      Joel Smely
+ *      Hagen Seifert
  *   Co-authors:
  *      simonmie
@@ -35 +35 @@
 
 #include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "core/command/Executor.h"
+
+#include "graphics/Model.h"
 #include "weaponsystem/Weapon.h"
 #include "weaponsystem/WeaponPack.h"
 #include "weaponsystem/WeaponSystem.h"
+#include "worldentities/WorldEntity.h"
 #include "worldentities/pawns/Pawn.h"
 
 #include "weapons/projectiles/HoverGunProjectile.h"
+#include "weapons/MuzzleFlash.h"
 
 namespace orxonox
@@ -50 +56 @@
         RegisterObject(HoverGun);
 
-        this->reloadTime_ = 1.0f;
-        this->damage_ = 0.0f;
+        this->reloadTime_ = 0.25f;
+        this->damage_ = 0.0f; //default 15
         this->speed_ = 750.0f;
+        this->delay_ = 0.0f;
+        this->setMunitionName("LaserMunition");
+        this->mesh_ = "laserbeam.mesh";
 
-        this->setMunitionName("HoverMunition");
-        this->setFireSound("sounds/Weapon_HoverGun.ogg");
 
-        hudImageString_ = "Orxonox/WSHUD_WM_HoverGun";
+        this->delayTimer_.setTimer(this->delay_, false, createExecutor(createFunctor(&HoverGun::shot, this)));
+        this->delayTimer_.stopTimer();
+
+        this->setFireSound("sounds/Weapon_HsW01.ogg");
+        this->setReloadSound("sounds/Reload_HsW01.ogg", 0.5);
+
+        hudImageString_ = "Orxonox/WSHUD_WM_HsW01";
     }
 
@@ -64 +77 @@
     }
 
+    void HoverGun::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(HoverGun, XMLPort, xmlelement, mode);
+
+        XMLPortParam(HoverGun, "delay", setDelay, getDelay, xmlelement, mode);
+        XMLPortParam(HoverGun, "material", setMaterial, getMaterial, xmlelement, mode);
+        XMLPortParam(HoverGun, "projectileMesh", setMesh, getMesh, xmlelement, mode);
+        XMLPortParam(HoverGun, "sound", setSound, getSound, xmlelement, mode);
+    }
+
+    /**
+    @brief
+        Set the firing delay.
+    @param delay
+        The firing delay in seconds.
+    */
+    void HoverGun::setDelay(float delay)
+    {
+        this->delay_ = delay;
+        this->delayTimer_.setInterval(this->delay_);
+    }
+
+    void HoverGun::fire()
+    {
+        this->delayTimer_.startTimer();
+    }
+
     /**
     @brief
         Fires the weapon. Creates a projectile and fires it.
     */
-    void HoverGun::fire()
+    void HoverGun::shot()
     {
+        assert( this->getWeapon() && this->getWeapon()->getWeaponPack() && this->getWeapon()->getWeaponPack()->getWeaponSystem() && this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn() );
+
+        // Create the projectile.
         HoverGunProjectile* projectile = new HoverGunProjectile(this->getContext());
-        projectile->setMaterial("Flares/HoverBall_");
+        Model* model = new Model(projectile->getContext());
+        model->setMeshSource(mesh_);
+        model->setCastShadows(false);
+        projectile->attach(model);
+        model->setScale(5);
 
         this->computeMuzzleParameters(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn()->getAimPosition());
@@ -82 +129 @@
         projectile->setShieldDamage(this->getShieldDamage());
         projectile->setHealthDamage(this->getHealthDamage());
+
+        // Display the muzzle flash.
+        this->HoverGun::muzzleflash();
+    }
+
+    /**
+    @brief
+        Displays the muzzle flash.
+    */
+    void HoverGun::muzzleflash()
+    {
+        MuzzleFlash *muzzleFlash = new MuzzleFlash(this->getContext());
+        this->getWeapon()->attach(muzzleFlash);
+        muzzleFlash->setPosition(this->getMuzzleOffset());
+        muzzleFlash->setMaterial(this->material_);
     }
 }

code/branches/Boxhead_FS19/src/modules/weapons/weaponmodes/HoverGun.h

@@ -21 +21 @@
  *
  *   Author:
- *      Joel Smely
+ *      Hagen Seifert
  *   Co-authors:
  *      ...
@@ -36 +36 @@
 
 #include "weapons/WeaponsPrereqs.h"
+
+#include "tools/Timer.h"
 #include "weaponsystem/WeaponMode.h"
 
@@ -43 +45 @@
     /**
     @brief
-        A slow ball of lightning.
+        Shoots laser beams.
     @author
-        Joel Smely
+        Hagen Seifert
     @ingroup WeaponsWeaponModes
     */
@@ -55 +57 @@
 
             virtual void fire() override;
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 
-       private:
+        protected:
+            /**
+            @brief Set the mesh.
+            @param mesh The mesh name.
+            */
+            void setMesh(const std::string& mesh)
+                { this->mesh_ = mesh; }
+
+            /**
+            @brief Get the mesh.
+            @return Returns the mesh name.
+            */
+            const std::string& getMesh() const
+                { return this->mesh_; }
+
+            /**
+            @brief Set the sound.
+            @param sound The Sound name.
+            */
+            void setSound(const std::string& sound)
+                { this->sound_ = sound; }
+
+            /**
+            @brief Get the sound.
+            @return Returns the sound name.
+            */
+            const std::string& getSound() const
+                { return this->sound_; }
+
+            /**
+            @brief Set the material.
+            @param material The material name.
+            */
+            void setMaterial(const std::string& material)
+                { this->material_ = material; }
+            /**
+            @brief Get the material.
+            @return Returns the material name.
+            */
+            const std::string& getMaterial() const
+                { return this->material_; }
+
+            void setDelay(float delay);
+            /**
+            @brief Get the firing delay.
+            @return Returns the firing delay in seconds.
+            */
+            float getDelay() const
+                { return this->delay_; }
+
+            virtual void shot();
+            void muzzleflash();
+
+            std::string material_; //!< The material.
+            std::string mesh_; //!< The mesh.
+            std::string sound_; //!< The sound.
+
+
+
             float speed_; //!< The speed of the fired projectile.
+            float delay_; //!< The firing delay.
+            Timer delayTimer_; //!< A timer to delay the firing.
     };
 }

code/branches/Boxhead_FS19/src/modules/weapons/weaponmodes/IceGun.cc

@@ -49 +49 @@
     IceGun::IceGun(Context* context) : WeaponMode(context)
     {
+        orxout() << "DEBUG Fire HoverGun";   
         RegisterObject(IceGun);
 

code/branches/Boxhead_FS19/src/modules/weapons/weaponmodes/LightningGun.cc

@@ -48 +48 @@
     LightningGun::LightningGun(Context* context) : WeaponMode(context)
     {
+        orxout() << "DEBUG Fire HoverGun";   
         RegisterObject(LightningGun);
 
@@ -70 +71 @@
     void LightningGun::fire()
     {
+
         LightningGunProjectile* projectile = new LightningGunProjectile(this->getContext());
         projectile->setMaterial("Flares/LightningBall_");