Changeset 2918

Timestamp:

Apr 18, 2009, 6:14:52 PM (16 years ago)

Author:

landauf

Message:

Added many new features in the Munition class:

• there are now 3 modes: a) every weapon has it's own magazine b) all weapons use the same magazin c) no magazines, just a big munition pool
• the Munition class handles the reloading of the magazine

Split the Weapon class into Weapon and WeaponMode. WeaponMode creates the fire of the Weapon. A weapon can own several WeaponModes (for example primary and secondary fire). But it's also possible to have a weapon with several muzzles which all fire at the same time (there's a WeaponMode for each muzzle).

Renamed LaserGun to LaserFire and Fusion to FusionFire. They inherit now from WeaponMode.

Changed the code in the Weapon class to use the new Munition functionality.

Added ReplenishingMunition, a subclass of Munition that replenishes itself (used for LaserGunMunition).

Added a reload command to reload magazines.

Location:

code/branches/weapons/src/orxonox

Files:

• OrxonoxPrereqs.h (modified) (1 diff)
• objects/controllers/HumanController.cc (modified) (2 diffs)
• objects/controllers/HumanController.h (modified) (1 diff)
• objects/weaponSystem/CMakeLists.txt (modified) (1 diff)
• objects/weaponSystem/Munition.cc (modified) (3 diffs)
• objects/weaponSystem/Munition.h (modified) (3 diffs)
• objects/weaponSystem/Weapon.cc (modified) (5 diffs)
• objects/weaponSystem/Weapon.h (modified) (4 diffs)
• objects/weaponSystem/WeaponMode.cc (added)
• objects/weaponSystem/WeaponMode.h (added)
• objects/weaponSystem/WeaponPack.cc (modified) (4 diffs)
• objects/weaponSystem/WeaponPack.h (modified) (2 diffs)
• objects/weaponSystem/WeaponSet.cc (modified) (2 diffs)
• objects/weaponSystem/WeaponSet.h (modified) (2 diffs)
• objects/weaponSystem/WeaponSlot.cc (modified) (1 diff)
• objects/weaponSystem/WeaponSystem.cc (modified) (4 diffs)
• objects/weaponSystem/WeaponSystem.h (modified) (2 diffs)
• objects/weaponSystem/munitions/CMakeLists.txt (modified) (1 diff)
• objects/weaponSystem/munitions/FusionMunition.cc (modified) (1 diff)
• objects/weaponSystem/munitions/FusionMunition.h (modified) (1 diff)
• objects/weaponSystem/munitions/LaserGunMunition.cc (modified) (1 diff)
• objects/weaponSystem/munitions/LaserGunMunition.h (modified) (1 diff)
• objects/weaponSystem/munitions/ReplenishingMunition.cc (added)
• objects/weaponSystem/munitions/ReplenishingMunition.h (added)
• objects/weaponSystem/projectiles/Projectile.cc (modified) (1 diff)
• objects/weaponSystem/projectiles/Projectile.h (modified) (1 diff)
• objects/weaponSystem/weapons/CMakeLists.txt (modified) (1 diff)
• objects/weaponSystem/weapons/FusionFire.cc (moved) (moved from code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/Fusion.cc) (1 diff, 1 prop)
• objects/weaponSystem/weapons/FusionFire.h (moved) (moved from code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/Fusion.h) (1 diff, 1 prop)
• objects/weaponSystem/weapons/LaserFire.cc (moved) (moved from code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserGun.cc) (1 diff, 1 prop)
• objects/weaponSystem/weapons/LaserFire.h (moved) (moved from code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserGun.h) (1 diff, 1 prop)
• objects/weaponSystem/weapons/Missile.cc (deleted)
• objects/weaponSystem/weapons/Missile.h (deleted)
• objects/worldentities/ControllableEntity.h (modified) (1 diff)
• objects/worldentities/pawns/Pawn.cc (modified) (4 diffs)
• objects/worldentities/pawns/Pawn.h (modified) (2 diffs)

code/branches/weapons/src/orxonox/OrxonoxPrereqs.h

@@ -157 +157 @@
     class WeaponPack;
     class Weapon;
+    class WeaponMode;
     class DefaultWeaponmodeLink;
+
+    class LaserFire;
+    class FusionFire;
+
+    class ReplenishingMunition;
     class Munition;
-    class LaserGun;
     class LaserGunMunition;
     class FusionMunition;

code/branches/weapons/src/orxonox/objects/controllers/HumanController.cc

@@ -46 +46 @@
     SetConsoleCommand(HumanController, rotateRoll,    true).setAsInputCommand();
     SetConsoleCommand(HumanController, fire,          true).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(HumanController, reload,        true);
     SetConsoleCommand(HumanController, boost,         true).keybindMode(KeybindMode::OnHold);
     SetConsoleCommand(HumanController, greet,         true);
@@ -114 +115 @@
     }
 
+    void HumanController::reload()
+    {
+        if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
+            HumanController::localController_s->controllableEntity_->reload();
+    }
+
     void HumanController::boost()
     {

code/branches/weapons/src/orxonox/objects/controllers/HumanController.h

@@ -52 +52 @@
 
             static void fire(unsigned int firemode);
+            static void reload();
 
             static void boost();

code/branches/weapons/src/orxonox/objects/weaponSystem/CMakeLists.txt

@@ -2 +2 @@
   Munition.cc
   Weapon.cc
+  WeaponMode.cc
   WeaponPack.cc
   WeaponSet.cc

code/branches/weapons/src/orxonox/objects/weaponSystem/Munition.cc

@@ -20 +20 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- *   Author:
+ *   Authors:
  *      Martin Polak
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
@@ -40 +41 @@
         RegisterObject(Munition);
 
+        this->maxMunitionPerMagazine_ = 10;
+        this->maxMagazines_ = 10;
+        this->magazines_ = 10;
+
+        this->bUseSeparateMagazines_ = false;
+        this->bStackMunition_ = true;
+        this->bAllowMunitionRefilling_ = true;
+        this->bAllowMultiMunitionRemovementUnderflow_ = true;
+
+        this->reloadTime_ = 0;
+
 COUT(0) << "+Munition" << std::endl;
     }
@@ -45 +57 @@
     Munition::~Munition()
     {
+        for (std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.begin(); it != this->currentMagazines_.end(); ++it)
+            delete it->second;
+
 COUT(0) << "~Munition" << std::endl;
     }
 
-    unsigned int Munition::bullets()
-    {
-        if (this->bullets_ > 0)
-            return bullets_;
+    Munition::Magazine* Munition::getMagazine(WeaponMode* user) const
+    {
+        if (this->bUseSeparateMagazines_)
+        {
+            // For separated magazines we definitively need a given user
+            if (!user)
+                return 0;
+
+            // Use the map to get the magazine assigned to the given user
+            std::map<WeaponMode*, Magazine*>::const_iterator it = this->currentMagazines_.find(user);
+            if (it != this->currentMagazines_.end())
+                return it->second;
+        }
+        else
+        {
+            // We don't use separate magazines for each user, so just take the first magazine
+            if (this->currentMagazines_.size() > 0)
+                return this->currentMagazines_.begin()->second;
+        }
+
+        return 0;
+    }
+
+    unsigned int Munition::getNumMunition(WeaponMode* user) const
+    {
+        Magazine* magazine = this->getMagazine(user);
+        if (magazine)
+        {
+            if (this->bStackMunition_)
+                // With stacked munition every magazine contributes to the total amount
+                return this->maxMunitionPerMagazine_ * this->magazines_ + magazine->munition_;
+            else
+                // Wihtout stacked munition we just consider the current magazine
+                return magazine->munition_;
+        }
+        return 0;
+    }
+
+    unsigned int Munition::getNumMunitionInCurrentMagazine(WeaponMode* user) const
+    {
+        // In contrast to getNumMunition() we really just consider the current magazine, even if we're stacking munition
+        Magazine* magazine = this->getMagazine(user);
+        if (magazine)
+            return magazine->munition_;
         else
             return 0;
     }
 
-    unsigned int Munition::magazines()
-    {
-        if (this->magazines_ > 0)
-            return magazines_;
-        else
-            return 0;
-    }
-
-    void Munition::setMaxBullets(unsigned int amount)
-    { this->maxBullets_ = amount; }
-
-    void Munition::setMaxMagazines(unsigned int amount)
-    { this->maxMagazines_ = amount; }
-
-    void Munition::removeBullets(unsigned int amount)
-    {
-        if ( this->bullets_ != 0 )
-            this->bullets_ = this->bullets_ - amount;
-    }
-
-    void Munition::removeMagazines(unsigned int amount)
-    {
-        if ( this->magazines_ != 0 )
-            this->magazines_ = this->magazines_ - amount;
-    }
-
-    void Munition::addBullets(unsigned int amount)
-    {
-        if ( this->bullets_ == this->maxBullets_ )
-        {
-            //cannot add bullets to actual magazine
-        }
-        else
-            this->bullets_ = this->bullets_ + amount;
-    }
-
-    void Munition::addMagazines(unsigned int amount)
-    {
-        if ( this->magazines_ == this->maxMagazines_ )
-        {
-            //no more capacity for another magazine
-        }
-        else
-            this->magazines_ = this->magazines_ + amount;
-    }
-
-
-    void Munition::fillBullets()
-    {
-        this->bullets_ = this->maxBullets_;
-    }
-
-    void Munition::fillMagazines()
-    {
-        this->magazines_ = this->maxMagazines_;
+    unsigned int Munition::getNumMagazines() const
+    {
+        if (this->bStackMunition_)
+        {
+            // If we stack munition and the current magazine is still full, it counts too
+            Magazine* magazine = this->getMagazine(0);
+            if (magazine && magazine->munition_ == this->maxMunitionPerMagazine_)
+                return this->magazines_ + 1;
+        }
+
+        return this->magazines_;
+    }
+
+    unsigned int Munition::getMaxMunition() const
+    {
+        if (this->bStackMunition_)
+            return this->maxMunitionPerMagazine_ * this->maxMagazines_;
+        else
+            return this->maxMunitionPerMagazine_;
+    }
+
+    bool Munition::canTakeMunition(unsigned int amount, WeaponMode* user) const
+    {
+        Magazine* magazine = this->getMagazine(user);
+        if (magazine && magazine->bLoaded_)
+        {
+            unsigned int munition = magazine->munition_;
+
+            // If we stack munition, we con't care about the current magazine - we just need enough munition in total
+            if (this->bStackMunition_)
+                munition += this->maxMunitionPerMagazine_ * this->magazines_;
+
+            if (munition == 0)
+                // Absolutely no munition - no chance to take munition
+                return false;
+            else if (this->bAllowMultiMunitionRemovementUnderflow_)
+                // We're not empty AND we allow underflow, so this will always work
+                return true;
+            else
+                // We don't allow underflow, so we have to check the amount
+                return (munition >= amount);
+        }
+        return false;
+    }
+
+    bool Munition::takeMunition(unsigned int amount, WeaponMode* user)
+    {
+        if (!this->canTakeMunition(amount, user))
+            return false;
+
+        Magazine* magazine = this->getMagazine(user);
+        if (magazine && magazine->bLoaded_)
+        {
+            if (magazine->munition_ >= amount)
+            {
+                // Enough munition
+                magazine->munition_ -= amount;
+                return true;
+            }
+            else
+            {
+                // Not enough munition
+                if (this->bStackMunition_)
+                {
+                    // We stack munition, so just take what we can and then load the next magazine
+                    amount -= magazine->munition_;
+                    magazine->munition_ = 0;
+
+                    if (this->reload(0))
+                        // Successfully reloaded, continue recursively
+                        return this->takeMunition(amount, 0);
+                    else
+                        // We don't have more magazines, so let's just hope we allow underflow
+                        return this->bAllowMultiMunitionRemovementUnderflow_;
+                }
+                else
+                {
+                    // We don't stack, so we can only take munition if this is allowed
+                    if (magazine->munition_ > 0 && this->bAllowMultiMunitionRemovementUnderflow_)
+                    {
+                        magazine->munition_ -= 0;
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    bool Munition::canReload() const
+    {
+        // As long as we have enough magazines (and don't stack munition) we can reload
+        return (this->magazines_ > 0 && !this->bStackMunition_);
+    }
+
+    bool Munition::needReload(WeaponMode* user) const
+    {
+        Magazine* magazine = this->getMagazine(user);
+        if (magazine)
+        {
+            if (this->bStackMunition_)
+                // With stacked munition, we never have to reload
+                return false;
+            else
+                // We need to reload if an already loaded magazine is empty
+                return (magazine->bLoaded_ && magazine->munition_ == 0);
+        }
+        else
+            // No magazine - we definitively need to reload
+            return true;
+    }
+
+    bool Munition::reload(WeaponMode* user, bool bUseReloadTime)
+    {
+        // Don't reload if we're already reloading
+        Magazine* magazine = this->getMagazine(user);
+        if (magazine && !magazine->bLoaded_)
+            return false;
+
+        // Check if we actually can reload
+        if (this->magazines_ == 0)
+            return false;
+
+        // If we use separate magazines for each user, we definitively need a user given
+        if (this->bUseSeparateMagazines_ && !user)
+            return false;
+
+        // If we don't use separate magazines, set user to 0
+        if (!this->bUseSeparateMagazines_)
+            user = 0;
+
+        // Remove the current magazine for the given user
+        std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.find(user);
+        if (it != this->currentMagazines_.end())
+        {
+            delete it->second;
+            this->currentMagazines_.erase(it);
+        }
+
+        // Load a new magazine
+        this->currentMagazines_[user] = new Magazine(this, bUseReloadTime);
+        this->magazines_--;
+
+        return true;
+    }
+
+    bool Munition::canAddMunition(unsigned int amount) const
+    {
+        if (!this->bAllowMunitionRefilling_)
+            return false;
+
+        if (this->bStackMunition_)
+        {
+            // If we stack munition, we can always add munition until we reach the limit
+            return (this->getNumMunition(0) < this->getMaxMunition());
+        }
+        else
+        {
+            // Return true if any of the current magazines is not full (loading counts as full although it returns 0 munition)
+            for (std::map<WeaponMode*, Magazine*>::const_iterator it = this->currentMagazines_.begin(); it != this->currentMagazines_.end(); ++it)
+                if (it->second->munition_ < this->maxMunitionPerMagazine_ && it->second->bLoaded_)
+                    return true;
+        }
+
+        return false;
+    }
+
+    bool Munition::addMunition(unsigned int amount)
+    {
+        if (!this->canAddMunition(amount))
+            return false;
+
+        if (this->bStackMunition_)
+        {
+            // Stacking munition means, if a magazine gets full, the munition adds to a new magazine
+            Magazine* magazine = this->getMagazine(0);
+            if (magazine)
+            {
+                // Add the whole amount
+                magazine->munition_ += amount;
+
+                // Add new magazines if the current magazine is overfull
+                while (magazine->munition_ > this->maxMunitionPerMagazine_)
+                {
+                    magazine->munition_ -= this->maxMunitionPerMagazine_;
+                    this->magazines_++;
+                }
+
+                // If we reached the limit, reduze both magazines and munition to the maximum
+                if (this->magazines_ >= this->maxMagazines_)
+                {
+                    this->magazines_ = this->maxMagazines_ - 1;
+                    magazine->munition_ = this->maxMunitionPerMagazine_;
+                }
+
+                return true;
+            }
+
+            // Something went wrong
+            return false;
+        }
+        else
+        {
+            // Share the munition equally to the current magazines
+            while (amount > 0)
+            {
+                bool change = false;
+                for (std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.begin(); it != this->currentMagazines_.end(); ++it)
+                {
+                    // Add munition if the magazine isn't full (but only to loaded magazines)
+                    if (amount > 0 && it->second->munition_ < this->maxMunitionPerMagazine_ && it->second->bLoaded_)
+                    {
+                        it->second->munition_++;
+                        amount--;
+                        change = true;
+                    }
+                }
+
+                // If there was no change in a loop, all magazines are full (or locked due to loading)
+                if (!change)
+                    break;
+            }
+
+            return true;
+        }
+    }
+
+    bool Munition::canAddMagazines(unsigned int amount) const
+    {
+        if (this->bStackMunition_)
+            // If we stack munition, we can always add new magazines because they contribute directly to the munition
+            return (this->getNumMunition(0) < this->getMaxMunition());
+        else
+            // If we don't stack munition, we're more limited
+            return ((this->currentMagazines_.size() + this->magazines_) < this->maxMagazines_);
+    }
+
+    bool Munition::addMagazines(unsigned int amount)
+    {
+        if (!this->canAddMagazines(amount))
+            return false;
+
+        // Calculate how many magazines are needed
+        int needed_magazines = this->maxMagazines_ - this->magazines_ - this->currentMagazines_.size();
+
+        // If zero or less magazines are needed, we definitively don't need more magazines (unless we stack munition - then a magazine contributes directly to the munition)
+        if (needed_magazines <= 0 && !this->bStackMunition_)
+            return false;
+
+        if (amount <= needed_magazines)
+        {
+            // We need more magazines than we get, so just add them
+            this->magazines_ += amount;
+        }
+        else
+        {
+            // We get more magazines than we need, so just add the needed amount
+            this->magazines_ += needed_magazines;
+            if (this->bStackMunition_)
+            {
+                // We stack munition, so the additional amount contributes directly to the munition of the current magazine
+                Magazine* magazine = this->getMagazine(0);
+                if (magazine)
+                    magazine->munition_ = this->maxMunitionPerMagazine_;
+            }
+        }
+
+        return true;
+    }
+
+    bool Munition::canRemoveMagazines(unsigned int amount) const
+    {
+        if (this->bStackMunition_)
+        {
+            if (this->magazines_ >= amount)
+            {
+                // We have enough magazines
+                return true;
+            }
+            else if (this->magazines_ == amount - 1)
+            {
+                // We lack one magazine, check if the current magazine is still full, if yes we're fine
+                Magazine* magazine = this->getMagazine(0);
+                if (magazine && magazine->munition_ == this->maxMunitionPerMagazine_)
+                    return true;
+            }
+            else
+            {
+                // We don't have enough magazines
+                return false;
+            }
+        }
+        else
+        {
+            // In case we're not stacking munition, just check the number of magazines
+            return (this->magazines_ >= amount);
+        }
+    }
+
+    bool Munition::removeMagazines(unsigned int amount)
+    {
+        if (!this->canRemoveMagazines(amount))
+            return false;
+
+        if (this->magazines_ >= amount)
+        {
+            // We have enough magazines, just remove the amount
+            this->magazines_ -= amount;
+        }
+        else if (this->bStackMunition_)
+        {
+            // We don't have enough magazines, but we're stacking munition, so additionally remove the bullets from the current magazine
+            this->magazines_ = 0;
+            Magazine* magazine = this->getMagazine(0);
+            if (magazine)
+                magazine->munition_ = 0;
+        }
+
+        return true;
+    }
+
+    bool Munition::dropMagazine(WeaponMode* user)
+    {
+        // If we use separate magazines, we need a user
+        if (this->bUseSeparateMagazines_ && !user)
+            return false;
+
+        // If we don't use separate magazines, set user to 0
+        if (!this->bUseSeparateMagazines_)
+            user = 0;
+
+        // Remove the current magazine for the given user
+        std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.find(user);
+        if (it != this->currentMagazines_.end())
+        {
+            delete it->second;
+            this->currentMagazines_.erase(it);
+            return true;
+        }
+
+        return false;
+    }
+
+
+    /////////////////////
+    // Magazine struct //
+    /////////////////////
+    Munition::Magazine::Magazine(Munition* munition, bool bUseReloadTime)
+    {
+        this->munition_ = 0;
+        this->bLoaded_ = false;
+
+        if (bUseReloadTime && (munition->reloadTime_ > 0 || munition->bStackMunition_))
+        {
+            ExecutorMember<Magazine>* executor = createExecutor(createFunctor(&Magazine::loaded));
+            executor->setDefaultValues(munition);
+
+            this->loadTimer_.setTimer(munition->reloadTime_, false, this, executor);
+        }
+        else
+            this->loaded(munition);
+    }
+
+    void Munition::Magazine::loaded(Munition* munition)
+    {
+        this->bLoaded_ = true;
+        this->munition_ = munition->maxMunitionPerMagazine_;
     }
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/Munition.h

@@ -20 +20 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- *   Author:
+ *   Authors:
  *      Martin Polak
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
@@ -31 +32 @@
 
 #include "OrxonoxPrereqs.h"
+
+#include <map>
+
 #include "core/BaseObject.h"
+#include "tools/Timer.h"
 
 namespace orxonox
@@ -37 +42 @@
     class _OrxonoxExport Munition : public BaseObject
     {
+        struct Magazine
+        {
+            public:
+                Magazine(Munition* munition, bool bUseReloadTime = true);
+
+                unsigned int munition_;
+                Timer<Magazine> loadTimer_;
+                bool bLoaded_;
+
+            private:
+                void loaded(Munition* munition);
+        };
+
         public:
             Munition(BaseObject* creator);
             virtual ~Munition();
 
-            void setMaxBullets(unsigned int amount);
-            void setMaxMagazines(unsigned int amount);
+            unsigned int getNumMunition(WeaponMode* user) const;
+            unsigned int getNumMunitionInCurrentMagazine(WeaponMode* user) const;
+            unsigned int getNumMagazines() const;
 
-            void fillBullets();
-            void fillMagazines();
+            unsigned int getMaxMunition() const;
+            inline unsigned int getMaxMagazines() const
+                { return this->maxMagazines_; }
+            inline unsigned int getMaxMunitionPerMagazine() const
+                { return this->maxMunitionPerMagazine_; }
 
-            unsigned int bullets();
-            unsigned int magazines();
+            bool canTakeMunition(unsigned int amount, WeaponMode* user) const;
+            bool takeMunition(unsigned int amount, WeaponMode* user);
 
-            void removeBullets(unsigned int k);
-            void removeMagazines(unsigned int k);
-            void addBullets(unsigned int k);
-            void addMagazines(unsigned int k);
+            bool canReload() const;
+            bool needReload(WeaponMode* user) const;
+            bool reload(WeaponMode* user, bool bUseReloadTime = true);
+            inline float getReloadTime() const
+                { return this->reloadTime_; }
+
+            bool canAddMunition(unsigned int amount) const;
+            bool addMunition(unsigned int amount);
+
+            bool canAddMagazines(unsigned int amount) const;
+            bool addMagazines(unsigned int amount);
+
+            bool canRemoveMagazines(unsigned int amount) const;
+            bool removeMagazines(unsigned int amount);
+
+            bool dropMagazine(WeaponMode* user);
+
+        protected:
+            unsigned int maxMunitionPerMagazine_;
+            unsigned int maxMagazines_;
+            unsigned int magazines_;
+            std::map<WeaponMode*, Magazine*> currentMagazines_;
+
+            bool bUseSeparateMagazines_;
+            bool bStackMunition_;
+            bool bAllowMunitionRefilling_;
+            bool bAllowMultiMunitionRemovementUnderflow_;
+
+            float reloadTime_;
 
         private:
-
-        protected:
-            unsigned int bullets_;
-            unsigned int magazines_;
-            unsigned int maxBullets_;
-            unsigned int maxMagazines_;
+            Magazine* getMagazine(WeaponMode* user) const;
     };
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/Weapon.cc

@@ -22 +22 @@
  *   Author:
  *      Martin Polak
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
@@ -33 +34 @@
 #include "core/XMLPort.h"
 
-#include "Munition.h"
+#include "WeaponMode.h"
 #include "WeaponPack.h"
 #include "WeaponSystem.h"
@@ -45 +46 @@
         RegisterObject(Weapon);
 
-        this->bulletReadyToShoot_ = true;
-        this->magazineReadyToShoot_ = true;
-        this->weaponSystem_ = 0;
         this->weaponPack_ = 0;
         this->weaponSlot_ = 0;
-        this->bulletLoadingTime_ = 0;
-        this->magazineLoadingTime_ = 0;
         this->bReloading_ = false;
-        this->bulletAmount_= 0;
-        this->magazineAmount_ = 0;
-        this->munition_ = 0;
-        this->unlimitedMunition_ = false;
-        this->setObjectMode(0x0);
+        this->reloadingWeaponmode_ = WeaponSystem::WEAPON_MODE_UNASSIGNED;
+
+        this->reloadTimer_.setTimer(0.0f, false, this, createExecutor(createFunctor(&Weapon::reloaded)));
+        this->reloadTimer_.stopTimer();
 
 COUT(0) << "+Weapon" << std::endl;
@@ -65 +60 @@
     {
 COUT(0) << "~Weapon" << std::endl;
-        if (this->isInitialized() && this->weaponPack_)
-            this->weaponPack_->removeWeapon(this);
+
+        if (this->isInitialized())
+        {
+            if (this->weaponPack_)
+                this->weaponPack_->removeWeapon(this);
+
+            for (std::multimap<unsigned int, WeaponMode*>::iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it)
+                delete it->second;
+        }
     }
 
@@ -73 +75 @@
         SUPER(Weapon, XMLPort, xmlelement, mode);
 
-        XMLPortParam(Weapon, "munitionType", setMunitionType, getMunitionType, xmlelement, mode);
-        XMLPortParam(Weapon, "bulletLoadingTime", setBulletLoadingTime, getBulletLoadingTime, xmlelement, mode);
-        XMLPortParam(Weapon, "magazineLoadingTime", setMagazineLoadingTime, getMagazineLoadingTime, xmlelement, mode);
-        XMLPortParam(Weapon, "bullets", setBulletAmount, getBulletAmount, xmlelement, mode);
-        XMLPortParam(Weapon, "magazines", setMagazineAmount, getMagazineAmount, xmlelement, mode);
-        XMLPortParam(Weapon, "unlimitedMunition", setUnlimitedMunition, getUnlimitedMunition, xmlelement, mode);
+        XMLPortObject(Weapon, WeaponMode, "", addWeaponmode, getWeaponmode, xmlelement, mode);
     }
 
-    void Weapon::setWeapon()
+    void Weapon::addWeaponmode(WeaponMode* weaponmode)
     {
-        this->munition_->fillBullets();
-        this->munition_->fillMagazines();
+        if (!weaponmode)
+            return;
+
+        this->weaponmodes_.insert(std::pair<unsigned int, WeaponMode*>(weaponmode->getMode(), weaponmode));
+        weaponmode->setWeapon(this);
     }
 
-    void Weapon::setMunition()
+    WeaponMode* Weapon::getWeaponmode(unsigned int index) const
     {
-        this->munition_->setMaxBullets(this->bulletAmount_);
-        this->munition_->setMaxMagazines(this->magazineAmount_);
+        unsigned int i = 0;
+        for (std::multimap<unsigned int, WeaponMode*>::const_iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it)
+        {
+            if (i == index)
+                return it->second;
+
+            ++i;
+        }
+        return 0;
     }
 
-    void Weapon::fire()
+    void Weapon::fire(unsigned int mode)
     {
-        if ( this->bulletReadyToShoot_ && this->magazineReadyToShoot_ && !this->bReloading_)
+        // To avoid firing with more than one mode at the same time, we lock the weapon (reloading) for
+        // all modes except the one which is currently reloading.
+        //
+        // Example:
+        // WeaponMode A -> mode 0
+        // WeaponMode B -> mode 0
+        // WeaponMode C -> mode 1
+        //
+        // -> A and B can fire at the same time, but C has to wait until both (A and B) have reloaded
+        // -> If C fires, A and B have to wait until C has reloaded
+        //
+        // Note: The reloading of each WeaponMode is internally handled by each A, B and C.
+        //       The reloading of the weapon is only performed to avoid firing with different modes at the same time.
+        if (this->bReloading_ && this->reloadingWeaponmode_ != mode)
+            return;
+
+        std::multimap<unsigned int, WeaponMode*>::iterator start = this->weaponmodes_.lower_bound(mode);
+        std::multimap<unsigned int, WeaponMode*>::iterator end   = this->weaponmodes_.upper_bound(mode);
+
+        for (std::multimap<unsigned int, WeaponMode*>::iterator it = start; it != end; ++it)
         {
-            this->bulletReadyToShoot_ = false;
-            if ( this->unlimitedMunition_== true )
+            float reloading_time = 0;
+            if (it->second->fire(&reloading_time))
             {
-                //shoot
-                this->reloadBullet();
-                this->createProjectile();
-            }
-            else
-            {
-                if ( this->munition_->bullets() > 0)
-                {
-                    //shoot and reload
-                    this->takeBullets();
-                    this->reloadBullet();
-                    this->createProjectile();
-                }
-                //if there are no bullets, but magazines
-                else if ( this->munition_->magazines() > 0 && this->munition_->bullets() == 0 )
-                {
-                    //reload magazine
-                    this->takeMagazines();
-                    this->reloadMagazine();
-                }
-                else
-                {
-                    //no magazines
-                }
-            }
-        }
-        else
-        {
-            //weapon not reloaded
-        }
+                this->bReloading_ = true;
+                this->reloadingWeaponmode_ = mode;
 
-    }
-
-
-    //weapon reloading
-    void Weapon::bulletTimer(float bulletLoadingTime)
-    {
-        this->bReloading_ = true;
-        this->bulletReloadTimer_.setTimer( bulletLoadingTime , false , this , createExecutor(createFunctor(&Weapon::bulletReloaded)));
-    }
-    void Weapon::magazineTimer(float magazineLoadingTime)
-    {
-        this->bReloading_ = true;
-        this->magazineReloadTimer_.setTimer( magazineLoadingTime , false , this , createExecutor(createFunctor(&Weapon::magazineReloaded)));
-    }
-
-    void Weapon::bulletReloaded()
-    {
-        this->bReloading_ = false;
-        this->bulletReadyToShoot_ = true;
-    }
-
-    void Weapon::magazineReloaded()
-    {
-        this->bReloading_ = false;
-        this->munition_->fillBullets();
-    }
-
-
-
-    void Weapon::attachNeededMunition(const std::string& munitionName)
-    {
-        /*  if munition type already exists attach it, else create a new one of this type and attach it to the weapon and to the WeaponSystem
-        */
-        if (this->weaponSystem_)
-        {
-            //getMunitionType returns 0 if there is no such munitionType
-            Munition* munition = this->weaponSystem_->getMunitionType(munitionName);
-            if ( munition )
-            {
-                this->munition_ = munition;
-                this->setMunition();
-            }
-            else
-            {
-                //create new munition with identifier because there is no such munitionType
-                this->munitionIdentifier_ = ClassByString(munitionName);
-                this->munition_ = this->munitionIdentifier_.fabricate(this);
-                this->weaponSystem_->setNewMunition(munitionName, this->munition_);
-                this->setMunition();
+                this->reloadTimer_.setInterval(reloading_time);
+                this->reloadTimer_.startTimer();
             }
         }
     }
 
-
-    Munition * Weapon::getAttachedMunition(const std::string& munitionType)
+    void Weapon::reload()
     {
-        this->munition_ = this->weaponSystem_->getMunitionType(munitionType);
-        return this->munition_;
+        for (std::multimap<unsigned int, WeaponMode*>::iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it)
+            it->second->reload();
     }
 
+    void Weapon::reloaded()
+    {
+        this->bReloading_ = false;
+        this->reloadingWeaponmode_ = WeaponSystem::WEAPON_MODE_UNASSIGNED;
+    }
 
-    //these function are defined in the weapon classes
-    void Weapon::takeBullets() { };
-    void Weapon::createProjectile() { };
-    void Weapon::takeMagazines() { };
-    void Weapon::reloadBullet() { };
-    void Weapon::reloadMagazine() { };
-
-
-    //get and set functions for XMLPort
-    void Weapon::setMunitionType(const std::string& munitionType)
-    {   this->munitionType_ = munitionType; }
-
-    const std::string& Weapon::getMunitionType() const
-    {   return this->munitionType_;  }
-
-    void Weapon::setBulletLoadingTime(float loadingTime)
-    {   this->bulletLoadingTime_ = loadingTime; }
-
-    const float Weapon::getBulletLoadingTime() const
-    {   return this->bulletLoadingTime_;  }
-
-    void Weapon::setMagazineLoadingTime(float loadingTime)
-    {   this->magazineLoadingTime_ = loadingTime; }
-
-    const float Weapon::getMagazineLoadingTime() const
-    {   return this->magazineLoadingTime_;  }
-
-    void Weapon::setBulletAmount(unsigned int amount)
-    {   this->bulletAmount_ = amount; }
-
-    const unsigned int Weapon::getBulletAmount() const
-    {   return this->bulletAmount_;  }
-
-    void Weapon::setMagazineAmount(unsigned int amount)
-    {   this->magazineAmount_ = amount; }
-
-    const unsigned int Weapon::getMagazineAmount() const
-    {   return this->magazineAmount_;   }
-
-    void Weapon::setUnlimitedMunition(bool unlimitedMunition)
-    {   this->unlimitedMunition_ = unlimitedMunition;   }
-
-    const bool Weapon::getUnlimitedMunition() const
-    {   return this->unlimitedMunition_;    }
-
+    void Weapon::notifyWeaponModes()
+    {
+        for (std::multimap<unsigned int, WeaponMode*>::iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it)
+            it->second->setWeapon(this);
+    }
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/Weapon.h

@@ -22 +22 @@
  *   Author:
  *      Martin Polak
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
@@ -34 +35 @@
 
 #include "tools/Timer.h"
-#include "core/Identifier.h"
 
 namespace orxonox
@@ -46 +46 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
-            virtual void fire();
-            void attachNeededMunition(const std::string& munitionType);
-            Munition * getAttachedMunition(const std::string& munitiontype);
+            void fire(unsigned int mode);
+            void reload();
 
-            //reloading
-            void bulletTimer(float bulletLoadingTime);
-            void magazineTimer(float magazineLoadingTime);
-            void bulletReloaded();
-            void magazineReloaded();
+            void addWeaponmode(WeaponMode* weaponmode);
+            WeaponMode* getWeaponmode(unsigned int index) const;
 
-            //XMLPort functions
-            virtual void setMunitionType(const std::string& munitionType);
-            virtual const std::string& getMunitionType() const;
-            virtual void setBulletLoadingTime(float loadingTime);
-            virtual const float getBulletLoadingTime() const;
-            virtual void setMagazineLoadingTime(float loadingTime);
-            virtual const float getMagazineLoadingTime() const;
-            virtual void setBulletAmount(unsigned int amount);
-            virtual const unsigned int getBulletAmount() const;
-            virtual void setMagazineAmount(unsigned int amount);
-            virtual const unsigned int getMagazineAmount() const;
-            virtual void setUnlimitedMunition(bool unlimitedMunition);
-            virtual const bool getUnlimitedMunition() const;
-
-            //weapon actions
-            virtual void takeBullets();
-            virtual void takeMagazines();
-            virtual void createProjectile();
-            virtual void reloadBullet();
-            virtual void reloadMagazine();
-
-            //manually set or reset
-            virtual void setWeapon();
-            virtual void setMunition();
-
-            inline void setWeaponSystem(WeaponSystem *weaponSystem)
-                { this->weaponSystem_ = weaponSystem; };
-            inline WeaponSystem * getWeaponSystem() const
-                { return this->weaponSystem_; };
-
-            inline void setWeaponPack(WeaponPack *weaponPack)
-                { this->weaponPack_ = weaponPack; };
+            inline void setWeaponPack(WeaponPack * weaponPack)
+                { this->weaponPack_ = weaponPack; this->notifyWeaponModes(); }
             inline WeaponPack * getWeaponPack() const
-                { return this->weaponPack_; };
+                { return this->weaponPack_; }
 
             inline void setWeaponSlot(WeaponSlot * wSlot)
@@ -96 +62 @@
                 { return this->weaponSlot_; }
 
-        protected:
+        private:
+            void reloaded();
+            void notifyWeaponModes();
+
+            WeaponPack* weaponPack_;
+            WeaponSlot* weaponSlot_;
+            std::multimap<unsigned int, WeaponMode*> weaponmodes_;
+
+            Timer<Weapon> reloadTimer_;
             bool bReloading_;
-            bool bulletReadyToShoot_;
-            bool magazineReadyToShoot_;
-            bool unlimitedMunition_;
-            float bulletLoadingTime_;
-            float magazineLoadingTime_;
-            unsigned int bulletAmount_;
-            unsigned int magazineAmount_;
-            std::string munitionType_;
-
-            WeaponSlot * weaponSlot_;
-            Munition * munition_;
-            WeaponSystem * weaponSystem_;
-            WeaponPack* weaponPack_;
-
-            SubclassIdentifier<Munition> munitionIdentifier_;
-
-            Timer<Weapon> bulletReloadTimer_;
-            Timer<Weapon> magazineReloadTimer_;
+            unsigned int reloadingWeaponmode_;
     };
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponPack.cc

@@ -72 +72 @@
         SUPER(WeaponPack, XMLPort, xmlelement, mode);
 
-        XMLPortObject(WeaponPack, Weapon, "", addWeapon, getWeapon, xmlelement, mode);
+        XMLPortObjectExtended(WeaponPack, Weapon, "", addWeapon, getWeapon, xmlelement, mode, false, false);
         XMLPortObject(WeaponPack, DefaultWeaponmodeLink, "links", addDefaultWeaponmodeLink, getDefaultWeaponmodeLink, xmlelement, mode);
     }
@@ -79 +79 @@
     {
         for (std::set<Weapon *>::iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it)
-            (*it)->fire();
+            (*it)->fire(weaponmode);
+    }
+
+    void WeaponPack::reload()
+    {
+        for (std::set<Weapon *>::iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it)
+            (*it)->reload();
     }
 
@@ -114 +120 @@
     }
 
-    void WeaponPack::setWeaponSystemToAllWeapons()
-    {
-        for (std::set<Weapon *>::const_iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it)
-            (*it)->setWeaponSystem(this->weaponSystem_);
-    }
-
-    void WeaponPack::attachNeededMunitionToAllWeapons()
-    {
-        for (std::set<Weapon *>::const_iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it)
-        {
-            (*it)->attachNeededMunition((*it)->getMunitionType());
-            (*it)->setWeapon();
-        }
-    }
-
     void WeaponPack::addDefaultWeaponmodeLink(DefaultWeaponmodeLink* link)
     {
@@ -155 +146 @@
         return WeaponSystem::WEAPON_MODE_UNASSIGNED;
     }
+
+    void WeaponPack::notifyWeapons()
+    {
+        for (std::set<Weapon *>::const_iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it)
+            (*it)->setWeaponPack(this);
+    }
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponPack.h

@@ -48 +48 @@
 
             void fire(unsigned int weaponmode);
+            void reload();
 
             void addWeapon(Weapon * weapon);
@@ -61 +62 @@
             unsigned int getDesiredWeaponmode(unsigned int firemode) const;
 
-            inline void setWeaponSystem(WeaponSystem *weaponSystem)
-            {
-                this->weaponSystem_ = weaponSystem;
-                this->setWeaponSystemToAllWeapons();
-                this->attachNeededMunitionToAllWeapons();
-            }
+            inline void setWeaponSystem(WeaponSystem * weaponSystem)
+                { this->weaponSystem_ = weaponSystem; this->notifyWeapons(); }
             inline WeaponSystem * getWeaponSystem() const
                 { return this->weaponSystem_; }
 
         private:
-            void setWeaponSystemToAllWeapons();
-            void attachNeededMunitionToAllWeapons();
+            void notifyWeapons();
 
             std::set<Weapon *> weapons_;

code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSet.cc

@@ -64 +64 @@
         XMLPortParam(WeaponSet, "firemode", setDesiredFiremode, getDesiredFiremode, xmlelement, mode);
     }
-/*
-    void WeaponSet::attachWeaponPack(WeaponPack *wPack)
-    {
-        if ( this->weaponSystem_->getWeaponSlotSize()>0 && wPack->getSize()>0 && ( wPack->getSize() <= this->weaponSystem_->getWeaponSlotSize() ) )
-        {
-            this->attachedWeaponPack_ = wPack;
-            int wPackWeapon = 0;    //WeaponCounter for Attaching
-
-            //should be possible to choose which slot to use
-            //attach every weapon of the weaponPack to a weaponSlot
-            for (  int i=0; i < wPack->getSize() ; i++  )
-            {
-                //at the moment this function only works for one weaponPack in the entire WeaponSystem...
-                //it also takes the first free weaponSlot...
-                if ( this->weaponSystem_->getWeaponSlot(i)->getAttachedWeapon() == 0 && this->weaponSystem_->getWeaponSlot(i) != 0) //if slot not full
-                {
-                    this->setWeaponSlots_.push_back( this->weaponSystem_->getWeaponSlot(i) );
-                    this->weaponSystem_->getWeaponSlot(i)->attachWeapon( wPack->getWeaponPointer(wPackWeapon) );
-                    this->weaponSystem_->getPawn()->attach( wPack->getWeaponPointer(wPackWeapon) );
-                    wPackWeapon++;
-                }
-                else
-                {
-                    for (int k=0; k < this->weaponSystem_->getWeaponSlotSize(); k++)
-                    {
-                        if ( this->weaponSystem_->getWeaponSlot(k)->getAttachedWeapon() == 0 )
-                        {
-                            this->setWeaponSlots_.push_back( this->weaponSystem_->getWeaponSlot(k) );
-                            this->weaponSystem_->getWeaponSlot(k)->attachWeapon( wPack->getWeaponPointer(wPackWeapon) );
-                            this->weaponSystem_->getPawn()->attach( wPack->getWeaponPointer(wPackWeapon) );
-                            wPackWeapon++;
-                        }
-                    }
-                }
-            }
-        }
-    }
-*/
 
     void WeaponSet::fire()
@@ -109 +71 @@
             if (it->second != WeaponSystem::WEAPON_MODE_UNASSIGNED)
                 it->first->fire(it->second);
+    }
+
+    void WeaponSet::reload()
+    {
+        // fire all WeaponPacks with their defined weaponmode
+        for (std::map<WeaponPack*, unsigned int>::iterator it = this->weaponpacks_.begin(); it != this->weaponpacks_.end(); ++it)
+            it->first->reload();
     }
 

code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSet.h

@@ -47 +47 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
-//            void attachWeaponPack(WeaponPack *wPack);
-
             void fire();
+            void reload();
 
             void setWeaponmodeLink(WeaponPack* weaponpack, unsigned int weaponmode);
@@ -66 +65 @@
 
         private:
-            WeaponSystem *weaponSystem_;
+            WeaponSystem * weaponSystem_;
             unsigned int desiredFiremode_;
             std::map<WeaponPack*, unsigned int> weaponpacks_;

code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSlot.cc

@@ -64 +64 @@
         SUPER(WeaponSlot, XMLPort, xmlelement, mode);
 
-        // ...
+        // In the future, there might be parameters like allowed weapon types or max size of the weapon
     }
 

code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSystem.cc

@@ -37 +37 @@
 #include "WeaponSet.h"
 #include "Weapon.h"
+#include "Munition.h"
 
 /* WeaponSystem
@@ -63 +64 @@
                 this->pawn_->setWeaponSystem(0);
 
-//            for (std::map<unsigned int, WeaponSet*>::iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); )
-//                delete (it++)->second;
             while (!this->weaponSets_.empty())
                 delete (this->weaponSets_.begin()->second);
 
-//            for (std::set<WeaponPack*>::iterator it = this->weaponPacks_.begin(); it != this->weaponPacks_.end(); )
-//                delete (*(it++));
             while (!this->weaponPacks_.empty())
                 delete (*this->weaponPacks_.begin());
 
-//            for (std::vector<WeaponSlot*>::iterator it = this->weaponSlots_.begin(); it != this->weaponSlots_.end(); )
-//                delete (*(it++));
             while (!this->weaponSlots_.empty())
                 delete (*this->weaponSlots_.begin());
+
+            while (!this->munitions_.empty())
+                { delete (this->munitions_.begin()->second); this->munitions_.erase(this->munitions_.begin()); }
         }
     }
@@ -284 +282 @@
     }
 
-    void WeaponSystem::setNewMunition(const std::string& munitionType, Munition * munitionToAdd)
-    {
-        this->munitionSet_[munitionType] = munitionToAdd;
-    }
-
-
-    //returns the Pointer to the munitionType, if this munitionType doesn't exist returns 0, see Weapon::attachNeededMunition
-    Munition * WeaponSystem::getMunitionType(const std::string& munitionType) const
-    {
-        std::map<std::string, Munition *>::const_iterator it = this->munitionSet_.find(munitionType);
-        if (it != this->munitionSet_.end())
-            return it->second;
-        else
-            return 0;
-    }
-
     void WeaponSystem::fire(unsigned int firemode)
     {
@@ -306 +288 @@
             it->second->fire();
     }
+
+    void WeaponSystem::reload()
+    {
+        for (std::map<unsigned int, WeaponSet *>::iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); ++it)
+            it->second->reload();
+    }
+
+    Munition * WeaponSystem::getMunition(SubclassIdentifier<Munition> * identifier)
+    {
+        if (!identifier || !identifier->getIdentifier())
+            return 0;
+
+        std::map<Identifier *, Munition *>::iterator it = this->munitions_.find(identifier->getIdentifier());
+        if (it != this->munitions_.end())
+        {
+            return it->second;
+        }
+        else if (identifier->getIdentifier()->isA(Class(Munition)))
+        {
+            Munition* munition = identifier->fabricate(this);
+            this->munitions_[identifier->getIdentifier()] = munition;
+            return munition;
+        }
+        else
+        {
+            return 0;
+        }
+    }
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSystem.h

@@ -69 +69 @@
 
             void fire(unsigned int firemode);
+            void reload();
 
-
-            void setNewMunition(const std::string& munitionType, Munition * munitionToAdd);
-            void setNewSharedMunition(const std::string& munitionType, Munition * munitionToAdd);
-            Munition * getMunitionType(const std::string& munitionType) const;
+            Munition * getMunition(SubclassIdentifier<Munition> * identifier);
 
             inline void setPawn(Pawn * pawn)
@@ -96 +94 @@
             std::vector<WeaponSlot *> weaponSlots_;
             std::set<WeaponPack *> weaponPacks_;
-            std::map<std::string, Munition *> munitionSet_;
+            std::map<Identifier *, Munition *> munitions_;
             Pawn * pawn_;
     };

code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
+  ReplenishingMunition.cc
   LaserGunMunition.cc
   FusionMunition.cc

code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/FusionMunition.cc

@@ -40 +40 @@
         RegisterObject(FusionMunition);
 
-        //default if not defined in XML
-        this->maxBullets_ = 10;
-        this->maxMagazines_ = 100;
+        this->maxMunitionPerMagazine_ = 10;
+        this->maxMagazines_ = 10;
+        this->magazines_ = 10;
+
+        this->bUseSeparateMagazines_ = true;
+        this->bStackMunition_ = false;
+        this->reloadTime_ = 1.0f;
+
+        this->bAllowMunitionRefilling_ = true;
+        this->bAllowMultiMunitionRemovementUnderflow_ = true;
     }
-
-    FusionMunition::~FusionMunition()
-    {
-    }
-
-    void FusionMunition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-
-    }
-
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/FusionMunition.h

@@ -39 +39 @@
         public:
             FusionMunition(BaseObject* creator);
-            virtual ~FusionMunition();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-
-
-        private:
-
-
+            virtual ~FusionMunition() {}
     };
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.cc

@@ -36 +36 @@
     CreateFactory(LaserGunMunition);
 
-    LaserGunMunition::LaserGunMunition(BaseObject* creator) : Munition(creator)
+    LaserGunMunition::LaserGunMunition(BaseObject* creator) : ReplenishingMunition(creator)
     {
         RegisterObject(LaserGunMunition);
 
-        //default if not defined in XML
-        this->maxBullets_ = 40;
-        this->maxMagazines_ = 100;
+        this->maxMunitionPerMagazine_ = 20;
+        this->maxMagazines_ = 1;
+        this->magazines_ = 1;
+
+        this->bUseSeparateMagazines_ = false;
+        this->bStackMunition_ = true;
+
+        this->bAllowMunitionRefilling_ = true;
+        this->bAllowMultiMunitionRemovementUnderflow_ = true;
+
+        this->replenishIntervall_ = 0.5f;
+        this->replenishMunitionAmount_ = 1;
     }
-
-    LaserGunMunition::~LaserGunMunition()
-    {
-    }
-
-    void LaserGunMunition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-
-    }
-
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.h

@@ -31 +31 @@
 
 #include "OrxonoxPrereqs.h"
-#include "objects/weaponSystem/Munition.h"
+#include "ReplenishingMunition.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport LaserGunMunition : public Munition
+    class _OrxonoxExport LaserGunMunition : public ReplenishingMunition
     {
         public:
             LaserGunMunition(BaseObject* creator);
-            virtual ~LaserGunMunition();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-
-
-        private:
-
-
+            virtual ~LaserGunMunition() {}
     };
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/projectiles/Projectile.cc

@@ -101 +101 @@
         if (!this->bDestroy_ && GameMode::isMaster())
         {
+            if (otherObject == this->owner_)
+                return true;
+
             this->bDestroy_ = true;
 

code/branches/weapons/src/orxonox/objects/weaponSystem/projectiles/Projectile.h

@@ -51 +51 @@
             virtual void destroyedPawn(Pawn* pawn);
 
+            inline void setDamage(float damage)
+                { this->damage_ = damage; }
+            inline float getDamage() const
+                { return this->damage_; }
+
             inline void setOwner(Pawn* owner)
                 { this->owner_ = owner; }

code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
-  Fusion.cc
-  LaserGun.cc
-#  Missile.cc
+  FusionFire.cc
+  LaserFire.cc
 )

code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/FusionFire.cc

@@ -28 +28 @@
 
 #include "OrxonoxStableHeaders.h"
-#include "Fusion.h"
+#include "FusionFire.h"
 
 #include "core/CoreIncludes.h"
+#include "objects/weaponSystem/projectiles/BillboardProjectile.h"
 
-#include "objects/weaponSystem/Munition.h"
-#include "objects/weaponSystem/projectiles/ParticleProjectile.h"
+#include "objects/weaponSystem/Weapon.h"
+#include "objects/weaponSystem/WeaponPack.h"
 #include "objects/weaponSystem/WeaponSystem.h"
 
 namespace orxonox
 {
-    CreateFactory(Fusion);
+    CreateFactory(FusionFire);
 
-    Fusion::Fusion(BaseObject* creator) : Weapon(creator)
+    FusionFire::FusionFire(BaseObject* creator) : WeaponMode(creator)
     {
-        RegisterObject(Fusion);
+        RegisterObject(FusionFire);
 
+        this->reloadTime_ = 1.0;
+        this->bParallelReload_ = false;
+        this->damage_ = 40;
         this->speed_ = 1250;
 
+        this->setMunitionName("FusionMunition");
     }
 
-    Fusion::~Fusion()
+    void FusionFire::fire()
     {
-    }
+        BillboardProjectile* projectile = new BillboardProjectile(this);
 
-    void Fusion::takeBullets()
-    {
-//COUT(0) << "Fusion::takeBullets" << std::endl;
-        this->munition_->removeBullets(1);
-        this->bulletTimer(this->bulletLoadingTime_);
-    }
+        projectile->setOrientation(this->getMuzzleOrientation());
+        projectile->setPosition(this->getMuzzlePosition());
+        projectile->setVelocity(this->getMuzzleDirection() * this->speed_);
 
-    void Fusion::takeMagazines()
-    {
-        this->munition_->removeMagazines(1);
-        this->magazineTimer(this->magazineLoadingTime_);
-    }
-
-    void Fusion::createProjectile()
-    {
-//COUT(0) << "Fusion::createProjectile" << std::endl;
-        BillboardProjectile* projectile = new ParticleProjectile(this);
-        projectile->setOrientation(this->getWorldOrientation());
-        projectile->setPosition(this->getWorldPosition());
-        projectile->setVelocity(this->getWorldOrientation() * WorldEntity::FRONT * this->speed_);
-        projectile->setOwner(this->getWeaponSystem()->getPawn());
+        projectile->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
+        projectile->setDamage(this->getDamage());
+        projectile->setColour(ColourValue(1.0f, 0.7f, 0.3f, 1.0f));
     }
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/FusionFire.h

@@ -27 +27 @@
  */
 
-#ifndef _Fusion_H__
-#define _Fusion_H__
+#ifndef _FusionFire_H__
+#define _FusionFire_H__
 
 #include "OrxonoxPrereqs.h"
-#include "objects/weaponSystem/Weapon.h"
+#include "objects/weaponSystem/WeaponMode.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Fusion : public Weapon
+    class _OrxonoxExport FusionFire : public WeaponMode
     {
         public:
-            Fusion(BaseObject* creator);
-            virtual ~Fusion();
+            FusionFire(BaseObject* creator);
+            virtual ~FusionFire() {}
 
-            virtual void takeBullets();
-            virtual void takeMagazines();
-            virtual void createProjectile();
+            virtual void fire();
 
         private:
             float speed_;
-
     };
 }
 
-#endif /* _Fusion_H__ */
+#endif /* _FusionFire_H__ */

code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserFire.cc

@@ -28 +28 @@
 
 #include "OrxonoxStableHeaders.h"
-#include "LaserGun.h"
+#include "LaserFire.h"
 
 #include "core/CoreIncludes.h"
+#include "objects/weaponSystem/projectiles/ParticleProjectile.h"
 
-#include "objects/weaponSystem/Munition.h"
-#include "objects/weaponSystem/projectiles/ParticleProjectile.h"
+#include "objects/weaponSystem/Weapon.h"
+#include "objects/weaponSystem/WeaponPack.h"
 #include "objects/weaponSystem/WeaponSystem.h"
 
 namespace orxonox
 {
-    CreateFactory(LaserGun);
+    CreateFactory(LaserFire);
 
-    LaserGun::LaserGun(BaseObject* creator) : Weapon(creator)
+    LaserFire::LaserFire(BaseObject* creator) : WeaponMode(creator)
     {
-        RegisterObject(LaserGun);
+        RegisterObject(LaserFire);
 
+        this->reloadTime_ = 0.25;
+        this->damage_ = 15;
         this->speed_ = 1250;
 
+        this->setMunitionName("LaserGunMunition");
     }
 
-    LaserGun::~LaserGun()
+    void LaserFire::fire()
     {
-    }
+        ParticleProjectile* projectile = new ParticleProjectile(this);
 
-    void LaserGun::reloadBullet()
-    {
-        this->bulletTimer(this->bulletLoadingTime_);
-    }
+        projectile->setOrientation(this->getMuzzleOrientation());
+        projectile->setPosition(this->getMuzzlePosition());
+        projectile->setVelocity(this->getMuzzleDirection() * this->speed_);
 
-    void LaserGun::reloadMagazine()
-    {
-        this->magazineTimer(this->magazineLoadingTime_);
-    }
-
-    void LaserGun::takeBullets()
-    {
-        this->munition_->removeBullets(1);
-    }
-
-    void LaserGun::takeMagazines()
-    {
-        this->munition_->removeMagazines(1);
-    }
-
-    void LaserGun::createProjectile()
-    {
-        BillboardProjectile* projectile = new ParticleProjectile(this);
-        projectile->setOrientation(this->getWorldOrientation());
-        projectile->setPosition(this->getWorldPosition());
-        projectile->setVelocity(this->getWorldOrientation() * WorldEntity::FRONT * this->speed_);
-        projectile->setOwner(this->getWeaponSystem()->getPawn());
+        projectile->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
+        projectile->setDamage(this->getDamage());
     }
 }

code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserFire.h

@@ -27 +27 @@
  */
 
-#ifndef _LaserGun_H__
-#define _LaserGun_H__
+#ifndef _LaserFire_H__
+#define _LaserFire_H__
 
 #include "OrxonoxPrereqs.h"
-#include "objects/weaponSystem/Weapon.h"
+#include "objects/weaponSystem/WeaponMode.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport LaserGun : public Weapon
+    class _OrxonoxExport LaserFire : public WeaponMode
     {
         public:
-            LaserGun(BaseObject* creator);
-            virtual ~LaserGun();
+            LaserFire(BaseObject* creator);
+            virtual ~LaserFire() {}
 
-            virtual void takeBullets();
-            virtual void takeMagazines();
-            virtual void createProjectile();
-            virtual void reloadBullet();
-            virtual void reloadMagazine();
+            virtual void fire();
 
         private:
             float speed_;
-
     };
 }
 
-#endif /* _LaserGun_H__ */
+#endif /* _LaserFire_H__ */

code/branches/weapons/src/orxonox/objects/worldentities/ControllableEntity.h

@@ -82 +82 @@
 
             virtual void fire(unsigned int firemode) {}
+            virtual void reload() {}
 
             virtual void boost() {}

code/branches/weapons/src/orxonox/objects/worldentities/pawns/Pawn.cc

@@ -56 +56 @@
         this->fire_ = 0x0;
         this->firehack_ = 0x0;
+        this->bReload_ = false;
 
         this->health_ = 0;
@@ -115 +116 @@
         registerVariable(this->initialHealth_, variableDirection::toclient);
         registerVariable(this->fire_,          variableDirection::toserver);
+        registerVariable(this->bReload_,       variableDirection::toserver);
     }
 
@@ -121 +123 @@
         SUPER(Pawn, tick, dt);
 
-        if (this->weaponSystem_)
+        if (this->weaponSystem_ && GameMode::isMaster())
         {
             for (unsigned int firemode = 0; firemode < WeaponSystem::MAX_FIRE_MODES; firemode++)
                 if (this->fire_ & WeaponSystem::getFiremodeMask(firemode))
                     this->weaponSystem_->fire(firemode);
-        }
+
+            if (this->bReload_)
+                this->weaponSystem_->reload();
+        }
+
         this->fire_ = this->firehack_;
         this->firehack_ = 0x0;
+        this->bReload_ = false;
 
         if (this->health_ <= 0)
@@ -258 +265 @@
     }
 
+    void Pawn::reload()
+    {
+        this->bReload_ = true;
+    }
+
     void Pawn::postSpawn()
     {

code/branches/weapons/src/orxonox/objects/worldentities/pawns/Pawn.h

@@ -81 +81 @@
 
             virtual void fire(unsigned int firemode);
+            virtual void reload();
             virtual void postSpawn();
 
@@ -131 +132 @@
             unsigned int fire_;
             unsigned int firehack_;
+            bool bReload_;
 
             std::string spawnparticlesource_;