Changeset 12281 for code/branches/OrxoBlox_FS19/src/modules/OrxoBlox

Timestamp:

Apr 4, 2019, 4:37:19 PM (6 years ago)

Author:

pomselj

Message:

weapon stuff

Location:

code/branches/OrxoBlox_FS19/src/modules/OrxoBlox/BallGun

Files:

• BallGun.cc (modified) (5 diffs)
• BallGun.h (modified) (5 diffs)
• BallMunition.cc (modified) (1 diff)
• BallMunition.h (modified) (2 diffs)
• BallProjectile.cc (modified) (6 diffs)
• BallProjectile.h (modified) (1 diff)

code/branches/OrxoBlox_FS19/src/modules/OrxoBlox/BallGun/BallGun.cc

@@ -21 +21 @@
  *
  *   Author:
- *      Fabien Vultier
+ *      Hagen Seifert
  *   Co-authors:
- *      ...
+ *      simonmie
  *
  */
 
 /**
-    @file IceGun.cc
-    @brief Implementation of the IceGun class.
+    @file HsW01.h
+    @brief Implementation of the HsW01 class.
 */
 
@@ -35 +35 @@
 
 #include "core/CoreIncludes.h"
-#include "core/XMLPort.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 "BallProjectile.h"
+#include "weapons/projectiles/Projectile.h"
+#include "weapons/MuzzleFlash.h"
 
 namespace orxonox
@@ -51 +56 @@
         RegisterObject(BallGun);
 
-        // Default values
-        this->reloadTime_ = 1.0f;
-        this->damage_ = 0.0f;
-        this->speed_ = 1200.0f;
+        this->reloadTime_ = 0.25f;
+        this->damage_ = 0.0f; //default 15
+        this->speed_ = 750.0f;
+        this->delay_ = 0.0f;
+        this->setMunitionName("BallMunition");
+        this->mesh_ = "laserbeam.mesh";
 
 
-        this->setMunitionName("BallMunition");
-        this->setFireSound("sounds/Weapon_LightningGun.ogg");
-        this->setReloadSound("sounds/Reload_IceGun.ogg", 0.4);
+        this->delayTimer_.setTimer(this->delay_, false, createExecutor(createFunctor(&BallGun::shot, this)));
+        this->delayTimer_.stopTimer();
 
-        hudImageString_ = "Orxonox/WSHUD_WM_IceGun";
+        this->setFireSound("sounds/Weapon_HsW01.ogg");
+        this->setReloadSound("sounds/Reload_HsW01.ogg", 0.5);
+
+        hudImageString_ = "Orxonox/WSHUD_WM_HsW01";
     }
 
@@ -68 +77 @@
     }
 
+    void BallGun::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(BallGun, XMLPort, xmlelement, mode);
+
+        XMLPortParam(BallGun, "delay", setDelay, getDelay, xmlelement, mode);
+        XMLPortParam(BallGun, "material", setMaterial, getMaterial, xmlelement, mode);
+        XMLPortParam(BallGun, "projectileMesh", setMesh, getMesh, xmlelement, mode);
+        XMLPortParam(BallGun, "sound", setSound, getSound, xmlelement, mode);
+    }
+
+    /**
+    @brief
+        Set the firing delay.
+    @param delay
+        The firing delay in seconds.
+    */
+    void BallGun::setDelay(float delay)
+    {
+        orxout() << "delay" << endl;
+        this->delay_ = delay;
+        this->delayTimer_.setInterval(this->delay_);
+    }
+
+    void BallGun::fire()
+    {
+        orxout() << "fire" << endl;
+        this->delayTimer_.startTimer();
+    }
+
     /**
     @brief
         Fires the weapon. Creates a projectile and fires it.
     */
-    void BallGun::fire()
+    void BallGun::shot()
     {
-        BallProjectile* projectile = new BallProjectile(this->getContext());
+        assert( this->getWeapon() && this->getWeapon()->getWeaponPack() && this->getWeapon()->getWeaponPack()->getWeaponSystem() && this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn() );
+        orxout() << "sajkfg" << endl;
+        // Create the projectile.
+        Projectile* projectile = new Projectile(this->getContext());
+        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());
@@ -85 +131 @@
         projectile->setShieldDamage(this->getShieldDamage());
         projectile->setHealthDamage(this->getHealthDamage());
+
+        // Display the muzzle flash.
+        this->BallGun::muzzleflash();
+    }
+
+    /**
+    @brief
+        Displays the muzzle flash.
+    */
+    void BallGun::muzzleflash()
+    {
+        MuzzleFlash *muzzleFlash = new MuzzleFlash(this->getContext());
+        this->getWeapon()->attach(muzzleFlash);
+        muzzleFlash->setPosition(this->getMuzzleOffset());
+        muzzleFlash->setMaterial(this->material_);
     }
 }

code/branches/OrxoBlox_FS19/src/modules/OrxoBlox/BallGun/BallGun.h

@@ -21 +21 @@
  *
  *   Author:
- *      Fabien Vultier
+ *      Hagen Seifert
  *   Co-authors:
  *      ...
@@ -28 +28 @@
 
 /**
-    @file IceGun.h
-    @brief Definition of the IceGun class.
+    @file HsW01.h
+    @brief Definition of the HsW01 class.
 */
 
@@ -36 +36 @@
 
 #include "weapons/WeaponsPrereqs.h"
+
+#include "tools/Timer.h"
 #include "weaponsystem/WeaponMode.h"
 
@@ -43 +45 @@
     /**
     @brief
-        A Gun that fires ice arrows that slow down any SpaceShip object that gets hit.
+        Shoots laser beams.
     @author
-        Fabien Vultier
+        Hagen Seifert
     @ingroup WeaponsWeaponModes
     */
@@ -55 +57 @@
 
             virtual void fire() override;
-            
-       private:
-            float speed_; //The speed of the fired projectile.
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+
+        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.
     };
 }
 
-#endif /* _IceGun_H__ */
+#endif /* _HsW01_H__ */

code/branches/OrxoBlox_FS19/src/modules/OrxoBlox/BallGun/BallMunition.cc

@@ -39 +39 @@
     RegisterClass(BallMunition);
 
-    BallMunition::BallMunition(Context* context) : Munition(context)
+    BallMunition::BallMunition(Context* context) : ReplenishingMunition(context)
     {
         RegisterObject(BallMunition);
 
-        this->maxMunitionPerMagazine_ = 1;
-        this->maxMagazines_ = 50;
-        this->unassignedMagazines_ = 25;
+        this->maxMunitionPerMagazine_ = 20;
+        this->maxMagazines_ = 10;
+        this->unassignedMagazines_ = 10;
 
-        this->deployment_ = MunitionDeployment::Stack;
+        this->deployment_ = MunitionDeployment::Separate;
 
         this->bAllowMunitionRefilling_ = true;
-        this->bAllowMultiMunitionRemovementUnderflow_ = false;
+        this->bAllowMultiMunitionRemovementUnderflow_ = true;
 
-        this->reloadTime_ = 0.5f;
+        this->replenishInterval_ = 7.0f;
+        this->replenishAmount_ = 1;
+
+        this->reloadTime_ = 0.6f;
     }
 }

code/branches/OrxoBlox_FS19/src/modules/OrxoBlox/BallGun/BallMunition.h

@@ -36 +36 @@
 
 #include "weapons/WeaponsPrereqs.h"
-#include "weaponsystem/Munition.h"
+#include "weaponsystem/ReplenishingMunition.h"
 
 namespace orxonox
@@ -48 +48 @@
     @ingroup WeaponsMunitions
     */
-    class _WeaponsExport BallMunition : public Munition
+    class _WeaponsExport BallMunition : public ReplenishingMunition
     {
         public:

code/branches/OrxoBlox_FS19/src/modules/OrxoBlox/BallGun/BallProjectile.cc

@@ -38 +38 @@
 #include "tools/ParticleInterface.h"
 #include "Scene.h"
+#include "core/command/Executor.h"
+#include "util/Convert.h"
 
 namespace orxonox
@@ -43 +45 @@
     RegisterClass(BallProjectile);
 
-    BallProjectile::BallProjectile(Context* context) : Projectile(context)
+    BallProjectile::BallProjectile(Context* context) : BillboardProjectile(context)
     {
         RegisterObject(BallProjectile);
-
-        this->particles_ = nullptr;
+        orxout() << "It's a bird, it's a plane' it's a BallParticle..." << endl;
+        this->textureIndex_ = 1;
+        this->setMass(0.1f);
+        this->maxTextureIndex_ = 8;
         this->setDestroyAfterCollision(false); //I want the ball to bounce, not to be destroyed
 
@@ -53 +57 @@
     }
 
-    BallProjectile::~BallProjectile()
+    void BallProjectile::registerVariables()
     {
-        if (this->isInitialized() && this->particles_)
-        {
-            this->detachOgreObject(this->particles_->getParticleSystem());
-            delete this->particles_;
-        }
+        registerVariable(this->materialBase_);
+    }
+
+    /**
+    @brief
+        Set the material.
+    @param material
+        The name of the material. Material names with 1 to 8 appended must exist.
+    */
+    void BallProjectile::setMaterial(const std::string& material)
+    {
+        this->materialBase_ = material;
+
+        BillboardProjectile::setMaterial(material + multi_cast<std::string>(this->textureIndex_));
+    }
+
+    /**
+    @brief
+        Change the texture.
+    */
+    void BallProjectile::changeTexture()
+    {
+        this->textureIndex_++;
+        if (this->textureIndex_ > this->maxTextureIndex_)
+            this->textureIndex_ = 1;
+
+        this->setMaterial(this->materialBase_);
     }
 
@@ -68 +94 @@
         Vector3 contactPosition = this->getPosition();
 
-        if (positionOtherObject.y < 0) {
-            this->destroy();
-        }
-        else {
+        //if (positionOtherObject.y < 0) {
+            //this.destroy()
+        //}
+        //else {
+        
             int distance_X = positionOtherObject.x - contactPosition.x;
+            int distance_Y = positionOtherObject.y - contactPosition.y;
 
             if (distance_X < 0)
-                distance_X = -distance_X;
-
-            int distance_Y = positionOtherObject.y - contactPosition.y;    
+                distance_Y = -distance_Y;
+    
 
             if (distance_Y < 0)
-                distance_Y = -distance_Y;
+                distance_X = -distance_X;
 
             if (distance_X < distance_Y)
@@ -90 +117 @@
                 velocity.y = -velocity.y;
             }
-        }
+        //}
     }
-
 
 /**
@@ -110 +136 @@
     */
 
+    /*
+    bool BallProjectile::collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint)
+    {
+        orxout() << "I collided against something" << endl;
+        return this->processCollision(otherObject, contactPoint, cs);
+    }
+    */
+    
+    bool BallProjectile::processCollision(WorldEntity* otherObject, btManifoldPoint& contactPoint, const btCollisionShape*)
+    {
 
-    bool BallProjectile::processCollision(WorldEntity* otherObject, btManifoldPoint& contactPoint, const btCollisionShape* cs)
-    {
-        if (GameMode::isMaster())
-        {
+        orxout() << "wanna bounce..." << endl;
+        bool result = BasicProjectile::processCollision(otherObject, contactPoint, cs);
+        Bounce(otherObject, contactPoint, cs);
+        orxout() << "BOUNCED!" << endl;
 
-            Pawn* victim = orxonox_cast<Pawn*>(otherObject); // If otherObject isn't a Pawn, then victim is nullptr
-
-            WorldEntity* entity = orxonox_cast<WorldEntity*>(this);
-            assert(entity); // The projectile must not be a WorldEntity.
-
-            // If visual effects after destruction cause problems, put this block below the effects code block
-            if (victim)
-            {
-                victim->hit(this->getShooter(), contactPoint, cs, this->getDamage(), this->getHealthDamage(), this->getShieldDamage());
-                victim->startShieldRechargeCountdown();
-            }
-
-            // Visual effects for being hit, depending on whether the shield is hit or not
-            if (this->getShooter()) // If the owner does not exist (anymore?), no effects are displayed.
-            {
-                // Damping and explosion effect is only played if the victim is no Pawn (see cast above)
-                // or if the victim is a Pawn, has no shield left, is still alive and any damage goes to the health
-                if (!victim || (victim && !victim->hasShield() && victim->getHealth() > 0.0f && (this->getDamage() > 0.0f || this->getHealthDamage() > 0.0f)))
-                {
-                    {
-                        ParticleSpawner* effect = new ParticleSpawner(this->getShooter()->getContext());
-                        effect->setPosition(entity->getPosition());
-                        effect->setOrientation(entity->getOrientation());
-                        effect->setDestroyAfterLife(true);
-                        effect->setSource("Orxonox/explosion3");
-                        effect->setLifetime(2.0f);
-                    }
-                    // Second effect with same condition
-                    {
-                        ParticleSpawner* effect = new ParticleSpawner(this->getShooter()->getContext());
-                        effect->setPosition(entity->getPosition());
-                        effect->setOrientation(entity->getOrientation());
-                        effect->setDestroyAfterLife(true);
-                        effect->setSource("Orxonox/smoke4");
-                        effect->setLifetime(3.0f);
-                    }
-                }
-
-                // victim->isAlive() is not false until the next tick, so getHealth() > 0 is used instead
-                if (victim && victim->hasShield() && (this->getDamage() > 0.0f || this->getShieldDamage() > 0.0f) && victim->getHealth() > 0.0f)
-                {
-                    ParticleSpawner* effect = new ParticleSpawner(this->getShooter()->getContext());
-                    effect->setDestroyAfterLife(true);
-                    effect->setSource("Orxonox/Shield");
-                    effect->setLifetime(0.5f);
-                    victim->attach(effect);
-                }
-            }
-
-            Bounce(otherObject, contactPoint, cs);
-
-            return true;
-        }
-        return false;
+        return result;
     }
 }

code/branches/OrxoBlox_FS19/src/modules/OrxoBlox/BallGun/BallProjectile.h

@@ -48 +48 @@
     @ingroup WeaponsProjectiles
     */
-    class _WeaponsExport BallProjectile : public Projectile
+    class _WeaponsExport BallProjectile : public BillboardProjectile
     {
         public:
             BallProjectile(Context* context);
-            virtual ~BallProjectile();
-            virtual void Bounce(WorldEntity* otherObject, btManifoldPoint& contactPoint, const btCollisionShape* cs);
-            virtual bool processCollision(WorldEntity* otherObject, btManifoldPoint& contactPoint, const btCollisionShape* cs);
+             void Bounce(WorldEntity* otherObject, btManifoldPoint& contactPoint, const btCollisionShape* cs);
+             //bool BallProjectile::collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint);
+             bool BallProjectile::processCollision(WorldEntity* otherObject, btManifoldPoint& contactPoint, const btCollisionShape*);
+            virtual void setMaterial(const std::string& material) override;
+
         private:
-            ParticleInterface* particles_; //!< The particles.
+
+            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.
+            std::string materialBase_; //!< The base name of the material.
     };
 }