Changeset 11108 for code/trunk/src/orxonox

Timestamp:

Feb 4, 2016, 11:54:04 PM (9 years ago)

Author:

fvultier

Message:

A few modifications in the weapon system: WeaponModes may play a reload sound now. Fireing Sounds of WeaponModes may overlap now. New weapon: FlameGun, a flame thrower for close combat (e.g. for the FPS player)

Location:

code/trunk/src/orxonox/weaponsystem

Files:

• WeaponMode.cc (modified) (7 diffs)
• WeaponMode.h (modified) (4 diffs)

code/trunk/src/orxonox/weaponsystem/WeaponMode.cc

@@ -77 +77 @@
         hudImageString_ = "Orxonox/WSHUD_WM_Unknown";
 
-        if( GameMode::isMaster() )
-        {
-            this->defSndWpnFire_ = new WorldSound(this->getContext());
-            this->defSndWpnFire_->setLooping(false);
-            this->defSndWpnFire_->setVolume(0.8f);
-            this->bSoundAttached_ = false;
-        }
-        else
-            this->defSndWpnFire_ = 0;
+        this->fireSoundPath_ = BLANKSTRING;
+        this->fireSoundVolume_ = 1.0;
+        this->fireSounds_.clear();
+
+        this->reloadSoundPath_ = BLANKSTRING;
+        this->reloadSoundVolume_ = 1.0;
+        this->reloadSound_ = nullptr;
     }
 
@@ -92 +90 @@
         if (this->isInitialized())
         {
-            if (this->defSndWpnFire_)
-                this->defSndWpnFire_->destroy();
+            for (auto sound : fireSounds_)
+            {
+                sound->destroy();
+            }
         }
     }
@@ -121 +121 @@
     {
         (*reloadTime) = this->reloadTime_;
-        if( !this->bSoundAttached_ && GameMode::isMaster() )
-        {
-            assert(this->getWeapon());
-            this->getWeapon()->attach(this->defSndWpnFire_);
-            this->bSoundAttached_ = true;
-        }
         
         // Fireing is only possible if this weapon mode is not reloading and there is enough munition
@@ -147 +141 @@
                         // The time needed to reload is the sum of the reload time of the weapon mode and the magazine.
                         tempReloadtime = this->reloadTime_ + this->munition_->getReloadTime();
-                    }                        
+                    }
+                    playReloadSound();
                 }
+            }
+
+            // For stacked munition, a reload sound is played after every fired projectile
+            if (this->munition_->getMunitionDeployment() == MunitionDeployment::Stack)
+            {
+                playReloadSound();
             }
 
@@ -156 +157 @@
             this->reloadTimer_.startTimer();
 
-            if( this->defSndWpnFire_ && !(this->defSndWpnFire_->isPlaying()))
-            {
-                this->defSndWpnFire_->play();
-            }
-
+            // Play the fire sound and fire the weapon mode
+            this->playFireSound();
             this->fire();
 
@@ -250 +248 @@
     void WeaponMode::reloaded()
     {
-        if( this->defSndWpnFire_ && this->defSndWpnFire_->isPlaying())
-        {
-            this->defSndWpnFire_->stop();
-        }
         this->bReloading_ = false;
     }
@@ -282 +276 @@
     }
 
-    void WeaponMode::setDefaultSound(const std::string& soundPath)
-    {
-        if( this->defSndWpnFire_ )
-            this->defSndWpnFire_->setSource(soundPath);
-    }
-
-    const std::string& WeaponMode::getDefaultSound()
-    {
-        if( this->defSndWpnFire_ )
-            return this->defSndWpnFire_->getSource();
-        else
-            return BLANKSTRING;
-    }
-
-    void WeaponMode::setDefaultSoundWithVolume(const std::string& soundPath, const float soundVolume)
-    {
-        if (this->defSndWpnFire_)
-        {
-            this->defSndWpnFire_->setSource(soundPath);
-            this->defSndWpnFire_->setVolume(soundVolume);
-        }
-    }
-
+    void WeaponMode::setFireSound(const std::string& soundPath, const float soundVolume)
+    {
+        fireSoundPath_ = soundPath;
+        fireSoundVolume_ = soundVolume;
+    }
+
+    const std::string& WeaponMode::getFireSound()
+    {
+        return fireSoundPath_;
+    }
+
+    void WeaponMode::setReloadSound(const std::string& soundPath, const float soundVolume)
+    {
+        reloadSoundPath_ = soundPath;
+        reloadSoundVolume_ = soundVolume;
+    }
+
+    const std::string& WeaponMode::getReloadSound()
+    {
+        return reloadSoundPath_;
+    }
+
+    void WeaponMode::playFireSound()
+    {
+        WorldSound* unusedSound = nullptr;
+
+        if (!GameMode::isMaster())
+        {
+            return;
+        }
+
+        // If no sound path or no weapon was specified, then no sound is played.
+        if (fireSoundPath_ == BLANKSTRING || !this->getWeapon())
+        {
+            return;
+        }
+
+        // Search in the sound list for a WorldSound that may be used. It must be an idle WorldSound instance (i.e. it is not playing a sound now)
+        for (auto sound : fireSounds_)
+        {
+            if( sound && !(sound->isPlaying()))
+            {
+                // Unused sound found
+                unusedSound = sound;
+                break;
+            }
+        }
+
+        // If no unused sound was found, create a new one and add it to the list
+        if (!unusedSound)
+        {
+            unusedSound = new WorldSound(this->getContext());
+            fireSounds_.push_back(unusedSound);
+            unusedSound->setLooping(false);
+            unusedSound->setSource(fireSoundPath_);
+            unusedSound->setVolume(fireSoundVolume_);
+            this->getWeapon()->attach(unusedSound);
+        }
+
+        // Play the fire sound
+        unusedSound->play();
+    }
+
+    void WeaponMode::playReloadSound()
+    {
+        if (!GameMode::isMaster())
+        {
+            return;
+        }
+
+        // If no sound path or no weapon was specified, then no sound is played.
+        if (reloadSoundPath_ == BLANKSTRING || !this->getWeapon())
+        {
+            return;
+        }
+
+        // Create a reload WorldSound if not done yet
+        if (!reloadSound_)
+        {
+            reloadSound_ = new WorldSound(this->getContext());
+            reloadSound_->setSource(reloadSoundPath_);
+            reloadSound_->setVolume(reloadSoundVolume_);
+            this->getWeapon()->attach(reloadSound_);
+        }
+
+        // Play the reload sound
+        reloadSound_->play();
+    }
 }

code/trunk/src/orxonox/weaponsystem/WeaponMode.h

@@ -34 +34 @@
 
 #include <string>
+#include <vector>
 #include "util/Math.h"
 #include "core/BaseObject.h"
@@ -54 +55 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 
-            bool fire(float* reloadTime);
+            virtual bool fire(float* reloadTime);
             bool reload();
-
-            // Interacting with the default Firing sound
-            void setDefaultSound(const std::string& soundPath);
-            const std::string& getDefaultSound();
-            void setDefaultSoundWithVolume(const std::string& soundPath, const float soundVolume);
 
             // Munition
@@ -155 +151 @@
             void updateMunition();
         protected:
+            // Interacting with the firing sound
+            void setFireSound(const std::string& soundPath, const float soundVolume = 1.0);
+            const std::string& getFireSound();
+            void playFireSound();
+
+            // Interacting with the reloading sound
+            void setReloadSound(const std::string& soundPath, const float soundVolume = 1.0);
+            const std::string& getReloadSound();
+            void playReloadSound();
+
             virtual void fire() = 0;
 
@@ -188 +194 @@
             Quaternion muzzleOrientation_;
 
-            WorldSound* defSndWpnFire_;
-            bool bSoundAttached_;
+            std::string fireSoundPath_; // The path of the sound played when fireing
+            float fireSoundVolume_; // The volume of the sound played when fireing
+            std::vector<WorldSound*> fireSounds_; // List of sounds used by the weapon mode. Because multiple sounds may overlap, we need mor than one WorldSound instance.
+            std::string reloadSoundPath_; // The path of the sound played when reloading
+            float reloadSoundVolume_; // The volume of the sound played when reloading
+            WorldSound* reloadSound_;
     };
 }