Index: /code/branches/weapons/src/orxonox/OrxonoxPrereqs.h
===================================================================
--- /code/branches/weapons/src/orxonox/OrxonoxPrereqs.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/OrxonoxPrereqs.h	(revision 2918)
@@ -157,7 +157,12 @@
     class WeaponPack;
     class Weapon;
+    class WeaponMode;
     class DefaultWeaponmodeLink;
+
+    class LaserFire;
+    class FusionFire;
+
+    class ReplenishingMunition;
     class Munition;
-    class LaserGun;
     class LaserGunMunition;
     class FusionMunition;
Index: /code/branches/weapons/src/orxonox/objects/controllers/HumanController.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/controllers/HumanController.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/controllers/HumanController.cc	(revision 2918)
@@ -46,4 +46,5 @@
     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,4 +115,10 @@
     }
 
+    void HumanController::reload()
+    {
+        if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
+            HumanController::localController_s->controllableEntity_->reload();
+    }
+
     void HumanController::boost()
     {
Index: /code/branches/weapons/src/orxonox/objects/controllers/HumanController.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/controllers/HumanController.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/controllers/HumanController.h	(revision 2918)
@@ -52,4 +52,5 @@
 
             static void fire(unsigned int firemode);
+            static void reload();
 
             static void boost();
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/CMakeLists.txt
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/CMakeLists.txt	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/CMakeLists.txt	(revision 2918)
@@ -2,4 +2,5 @@
   Munition.cc
   Weapon.cc
+  WeaponMode.cc
   WeaponPack.cc
   WeaponSet.cc
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/Munition.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/Munition.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/Munition.cc	(revision 2918)
@@ -20,6 +20,7 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- *   Author:
+ *   Authors:
  *      Martin Polak
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
@@ -40,4 +41,15 @@
         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,70 +57,425 @@
     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_;
     }
 }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/Munition.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/Munition.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/Munition.h	(revision 2918)
@@ -20,6 +20,7 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
- *   Author:
+ *   Authors:
  *      Martin Polak
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
@@ -31,5 +32,9 @@
 
 #include "OrxonoxPrereqs.h"
+
+#include <map>
+
 #include "core/BaseObject.h"
+#include "tools/Timer.h"
 
 namespace orxonox
@@ -37,29 +42,66 @@
     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;
     };
 }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/Weapon.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/Weapon.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/Weapon.cc	(revision 2918)
@@ -22,4 +22,5 @@
  *   Author:
  *      Martin Polak
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
@@ -33,5 +34,5 @@
 #include "core/XMLPort.h"
 
-#include "Munition.h"
+#include "WeaponMode.h"
 #include "WeaponPack.h"
 #include "WeaponSystem.h"
@@ -45,17 +46,11 @@
         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,6 +60,13 @@
     {
 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,167 +75,80 @@
         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);
+    }
 }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/Weapon.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/Weapon.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/Weapon.h	(revision 2918)
@@ -22,4 +22,5 @@
  *   Author:
  *      Martin Polak
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
@@ -34,5 +35,4 @@
 
 #include "tools/Timer.h"
-#include "core/Identifier.h"
 
 namespace orxonox
@@ -46,48 +46,14 @@
             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,24 +62,15 @@
                 { 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_;
     };
 }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponMode.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponMode.cc	(revision 2918)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponMode.cc	(revision 2918)
@@ -0,0 +1,372 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Martin Polak
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+#include "WeaponMode.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+
+#include "Munition.h"
+#include "Weapon.h"
+#include "WeaponPack.h"
+#include "WeaponSystem.h"
+
+namespace orxonox
+{
+    WeaponMode::WeaponMode(BaseObject* creator) : BaseObject(creator)
+    {
+        RegisterObject(WeaponMode);
+
+        this->weapon_ = 0;
+        this->mode_ = WeaponSystem::WEAPON_MODE_UNASSIGNED;
+
+        this->munition_ = 0;
+        this->initialMunition_ = 0;
+        this->initialMagazines_ = 0;
+        this->munitionPerShot_ = 1;
+
+        this->reloadTime_ = 0.25;
+        this->bReloading_ = false;
+        this->bAutoReload_ = true;
+        this->bParallelReload_ = true;
+
+        this->reloadTimer_.setTimer(0.0f, false, this, createExecutor(createFunctor(&WeaponMode::reloaded)));
+        this->reloadTimer_.stopTimer();
+
+        this->damage_ = 0;
+        this->muzzleOffset_ = Vector3::ZERO;
+
+COUT(0) << "+WeaponMode" << std::endl;
+    }
+
+    WeaponMode::~WeaponMode()
+    {
+COUT(0) << "~WeaponMode" << std::endl;
+    }
+
+    void WeaponMode::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(WeaponMode, XMLPort, xmlelement, mode);
+
+        XMLPortParam(WeaponMode, "mode",             setMode,             getMode,             xmlelement, mode);
+
+        XMLPortParam(WeaponMode, "munitiontype",     setMunitionName,     getMunitionName,     xmlelement, mode);
+        XMLPortParam(WeaponMode, "initialmunition",  setInitialMunition,  getInitialMunition,  xmlelement, mode);
+        XMLPortParam(WeaponMode, "initialmagazines", setInitialMagazines, getInitialMagazines, xmlelement, mode);
+        XMLPortParam(WeaponMode, "munitionpershot",  setMunitionPerShot,  getMunitionPerShot,  xmlelement, mode);
+
+        XMLPortParam(WeaponMode, "reloadtime",       setReloadTime,       getReloadTime,       xmlelement, mode);
+        XMLPortParam(WeaponMode, "autoreload",       setAutoReload,       getAutoReload,       xmlelement, mode).description("If true, the weapon reloads the magazine automatically");
+        XMLPortParam(WeaponMode, "parallelreload",   setParallelReload,   getParallelReload,   xmlelement, mode).description("If true, the weapon reloads in parallel to the magazine reloading");
+
+        XMLPortParam(WeaponMode, "damage",           setDamage,           getDamage,           xmlelement, mode);
+        XMLPortParam(WeaponMode, "muzzleoffset",     setMuzzleOffset,     getMuzzleOffset,     xmlelement, mode);
+    }
+
+    bool WeaponMode::fire(float* reloadTime)
+    {
+        (*reloadTime) = this->reloadTime_;
+
+        if (!this->bReloading_ && this->munition_ && this->munition_->takeMunition(this->munitionPerShot_, this))
+        {
+            float reloadtime = this->reloadTime_;
+
+            if (this->bAutoReload_ && this->munition_->needReload(this))
+            {
+                if (this->munition_->reload(this))
+                {
+                    if (!this->bParallelReload_)
+                        reloadtime += this->munition_->getReloadTime();
+                }
+            }
+
+            this->bReloading_ = true;
+            this->reloadTimer_.setInterval(reloadtime);
+            this->reloadTimer_.startTimer();
+
+            this->fire();
+
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    bool WeaponMode::reload()
+    {
+        if (this->munition_ && this->munition_->reload(this))
+        {
+            if (!this->bParallelReload_)
+            {
+                this->bReloading_ = true;
+                this->reloadTimer_.setInterval(this->reloadTime_ + this->munition_->getReloadTime());
+                this->reloadTimer_.startTimer();
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    void WeaponMode::setMunitionType(Identifier* identifier)
+    {
+        this->munitionname_ = identifier->getName();
+        this->munitiontype_ = identifier;
+        this->updateMunition();
+    }
+
+    void WeaponMode::setMunitionName(const std::string& munitionname)
+    {
+        this->munitionname_ = munitionname;
+        this->munitiontype_ = ClassByString(this->munitionname_);
+        this->updateMunition();
+    }
+
+    void WeaponMode::updateMunition()
+    {
+        if (this->munitiontype_ && this->weapon_ && this->weapon_->getWeaponPack() && this->weapon_->getWeaponPack()->getWeaponSystem())
+        {
+            this->munition_ = this->weapon_->getWeaponPack()->getWeaponSystem()->getMunition(&this->munitiontype_);
+
+            if (this->munition_)
+            {
+                // Add the initial magazines
+                this->munition_->addMagazines(this->initialMagazines_);
+
+                // Maybe we have to reload (if this munition is used the first time or if there weren't any magazines available before)
+                if (this->munition_->needReload(this))
+                    this->munition_->reload(this, false);
+
+                // Add the initial munition
+                if (this->initialMunition_ > 0 && this->munition_->getNumMunitionInCurrentMagazine(this) == this->munition_->getMaxMunitionPerMagazine())
+                {
+                    // The current magazine is still full, so let's just add another magazine to
+                    // the stack and reduce the current magazine to the given amount of munition
+
+                    unsigned int initialmunition = this->initialMunition_;
+                    if (initialmunition > this->munition_->getMaxMunitionPerMagazine())
+                        initialmunition = this->munition_->getMaxMunitionPerMagazine();
+
+                    this->munition_->takeMunition(this->munition_->getMaxMunitionPerMagazine() - initialmunition, this);
+                    this->munition_->addMagazines(1);
+                }
+                else
+                {
+                    // The current magazine isn't full, add the munition directly
+
+                    this->munition_->addMunition(this->initialMunition_);
+                }
+            }
+        }
+        else
+            this->munition_ = 0;
+    }
+
+    void WeaponMode::reloaded()
+    {
+        this->bReloading_ = false;
+    }
+
+    Vector3 WeaponMode::getMuzzlePosition() const
+    {
+        if (this->weapon_)
+            return (this->weapon_->getWorldPosition() + this->muzzleOffset_);
+        else
+            return this->muzzleOffset_;
+    }
+
+    const Quaternion& WeaponMode::getMuzzleOrientation() const
+    {
+        if (this->weapon_)
+            return this->weapon_->getWorldOrientation();
+        else
+            return Quaternion::IDENTITY;
+    }
+
+    Vector3 WeaponMode::getMuzzleDirection() const
+    {
+        if (this->weapon_)
+            return (this->weapon_->getWorldOrientation() * WorldEntity::FRONT);
+        else
+            return WorldEntity::FRONT;
+    }
+
+/*
+    WeaponMode::WeaponMode(BaseObject* creator) : StaticEntity(creator)
+    {
+        RegisterObject(WeaponMode);
+
+        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);
+COUT(0) << "+WeaponMode" << std::endl;
+    }
+
+    WeaponMode::~WeaponMode()
+    {
+COUT(0) << "~WeaponMode" << std::endl;
+        if (this->isInitialized() && this->weaponPack_)
+            this->weaponPack_->removeWeapon(this);
+    }
+
+    void WeaponMode::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(WeaponMode, XMLPort, xmlelement, mode);
+
+        XMLPortParam(WeaponMode, "munitionType", setMunitionType, getMunitionType, xmlelement, mode);
+        XMLPortParam(WeaponMode, "bulletLoadingTime", setBulletLoadingTime, getBulletLoadingTime, xmlelement, mode);
+        XMLPortParam(WeaponMode, "magazineLoadingTime", setMagazineLoadingTime, getMagazineLoadingTime, xmlelement, mode);
+        XMLPortParam(WeaponMode, "bullets", setBulletAmount, getBulletAmount, xmlelement, mode);
+        XMLPortParam(WeaponMode, "magazines", setMagazineAmount, getMagazineAmount, xmlelement, mode);
+        XMLPortParam(WeaponMode, "unlimitedMunition", setUnlimitedMunition, getUnlimitedMunition, xmlelement, mode);
+    }
+
+    void WeaponMode::setWeapon()
+    {
+        this->munition_->fillBullets();
+        this->munition_->fillMagazines();
+    }
+
+    void WeaponMode::setMunition()
+    {
+        this->munition_->setMaxBullets(this->bulletAmount_);
+        this->munition_->setMaxMagazines(this->magazineAmount_);
+    }
+
+    void WeaponMode::fire()
+    {
+        if ( this->bulletReadyToShoot_ && this->magazineReadyToShoot_ && !this->bReloading_)
+        {
+            this->bulletReadyToShoot_ = false;
+            if ( this->unlimitedMunition_== true )
+            {
+                //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
+        }
+    }
+
+
+    //weapon reloading
+    void WeaponMode::bulletTimer(float bulletLoadingTime)
+    {
+        this->bReloading_ = true;
+        this->bulletReloadTimer_.setTimer( bulletLoadingTime , false , this , createExecutor(createFunctor(&WeaponMode::bulletReloaded)));
+    }
+    void WeaponMode::magazineTimer(float magazineLoadingTime)
+    {
+        this->bReloading_ = true;
+        this->magazineReloadTimer_.setTimer( magazineLoadingTime , false , this , createExecutor(createFunctor(&WeaponMode::magazineReloaded)));
+    }
+
+    void WeaponMode::bulletReloaded()
+    {
+        this->bReloading_ = false;
+        this->bulletReadyToShoot_ = true;
+    }
+
+    void WeaponMode::magazineReloaded()
+    {
+        this->bReloading_ = false;
+        this->munition_->fillBullets();
+    }
+
+
+
+    void WeaponMode::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();
+            }
+        }
+    }
+
+
+    Munition * WeaponMode::getAttachedMunition(const std::string& munitionType)
+    {
+        this->munition_ = this->weaponSystem_->getMunitionType(munitionType);
+        return this->munition_;
+    }
+*/
+}
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponMode.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponMode.h	(revision 2918)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponMode.h	(revision 2918)
@@ -0,0 +1,246 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Martin Polak
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _WeaponMode_H__
+#define _WeaponMode_H__
+
+#include "OrxonoxPrereqs.h"
+#include "core/BaseObject.h"
+
+#include "tools/Timer.h"
+#include "core/Identifier.h"
+#include "util/Math.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport WeaponMode : public BaseObject
+    {
+        public:
+            WeaponMode(BaseObject* creator);
+            virtual ~WeaponMode();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+
+            bool fire(float* reloadTime);
+            bool reload();
+
+
+            // Munition
+            inline Munition* getMunition() const
+                { return this->munition_; }
+
+            void setMunitionType(Identifier* identifier);
+            inline Identifier* getMunitionType() const
+                { return this->munitiontype_; }
+
+            void setMunitionName(const std::string& munitionname);
+            inline const std::string& getMunitionName() const
+                { return this->munitionname_; }
+
+            inline void setInitialMunition(unsigned int amount)
+                { this->initialMunition_ = amount; }
+            inline unsigned int getInitialMunition() const
+                { return this->initialMunition_; }
+
+            inline void setInitialMagazines(unsigned int amount)
+                { this->initialMagazines_ = amount; }
+            inline unsigned int getInitialMagazines() const
+                { return this->initialMagazines_; }
+
+            inline void setMunitionPerShot(unsigned int amount)
+                { this->munitionPerShot_ = amount; }
+            inline unsigned int getMunitionPerShot() const
+                { return this->munitionPerShot_; }
+
+
+            // Reloading
+            inline void setReloadTime(float time)
+                { this->reloadTime_ = time; }
+            inline float getReloadTime() const
+                { return this->reloadTime_; }
+
+            inline void setAutoReload(bool autoreload)
+                { this->bAutoReload_ = autoreload; }
+            inline bool getAutoReload() const
+                { return this->bAutoReload_; }
+
+            inline void setParallelReload(bool parallelreload)
+                { this->bParallelReload_ = parallelreload; }
+            inline bool getParallelReload() const
+                { return this->bParallelReload_; }
+
+
+            // Fire
+            inline void setDamage(float damage)
+                { this->damage_ = damage; }
+            inline float getDamage() const
+                { return this->damage_; }
+
+            inline void setMuzzleOffset(const Vector3& offset)
+                { this->muzzleOffset_ = offset; }
+            inline const Vector3& getMuzzleOffset() const
+                { return this->muzzleOffset_; }
+
+            Vector3 getMuzzlePosition() const;
+            const Quaternion& getMuzzleOrientation() const;
+            Vector3 getMuzzleDirection() const;
+
+
+            // Weapon
+            inline void setWeapon(Weapon* weapon)
+                { this->weapon_ = weapon; this->updateMunition(); }
+            inline Weapon* getWeapon() const
+                { return this->weapon_; }
+
+            inline void setMode(unsigned int mode)
+                { this->mode_ = mode; }
+            inline unsigned int getMode() const
+                { return this->mode_; }
+
+        protected:
+            virtual void fire() = 0;
+
+            unsigned int initialMunition_;
+            unsigned int initialMagazines_;
+            unsigned int munitionPerShot_;
+
+            float reloadTime_;
+            bool bAutoReload_;
+            bool bParallelReload_;
+
+            float damage_;
+            Vector3 muzzleOffset_;
+
+        private:
+            void updateMunition();
+            void reloaded();
+
+            Weapon* weapon_;
+            unsigned int mode_;
+
+            Munition* munition_;
+            SubclassIdentifier<Munition> munitiontype_;
+            std::string munitionname_;
+
+            Timer<WeaponMode> reloadTimer_;
+            bool bReloading_;
+/*
+            virtual void fire();
+            void attachNeededMunition(const std::string& munitionType);
+            Munition * getAttachedMunition(const std::string& munitiontype);
+
+            //reloading
+            void bulletTimer(float bulletLoadingTime);
+            void magazineTimer(float magazineLoadingTime);
+            void bulletReloaded();
+            void magazineReloaded();
+
+            //get and set functions for XMLPort
+            void setMunitionType(const std::string& munitionType)
+                {   this->munitionType_ = munitionType; }
+            std::string& getMunitionType() const
+                {   return this->munitionType_;  }
+
+            void setBulletLoadingTime(float loadingTime)
+                {   this->bulletLoadingTime_ = loadingTime; }
+            float getBulletLoadingTime() const
+                {   return this->bulletLoadingTime_;  }
+
+            void setMagazineLoadingTime(float loadingTime)
+                {   this->magazineLoadingTime_ = loadingTime; }
+            float getMagazineLoadingTime() const
+                {   return this->magazineLoadingTime_;  }
+
+            void setBulletAmount(unsigned int amount)
+                {   this->bulletAmount_ = amount; }
+            unsigned int getBulletAmount() const
+                {   return this->bulletAmount_;  }
+
+            void setMagazineAmount(unsigned int amount)
+                {   this->magazineAmount_ = amount; }
+            unsigned int getMagazineAmount() const
+                {   return this->magazineAmount_;   }
+
+            void setUnlimitedMunition(bool unlimitedMunition)
+                {   this->unlimitedMunition_ = unlimitedMunition;   }
+            bool getUnlimitedMunition() const
+                {   return this->unlimitedMunition_;    }
+
+            //weapon actions
+            //these function are defined in the weapon classes
+            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 WeaponPack * getWeaponPack() const
+                { return this->weaponPack_; };
+
+            inline void setWeaponSlot(WeaponSlot * wSlot)
+                { this->weaponSlot_ = wSlot; }
+            inline WeaponSlot * getWeaponSlot() const
+                { return this->weaponSlot_; }
+
+        protected:
+            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<WeaponMode> bulletReloadTimer_;
+            Timer<WeaponMode> magazineReloadTimer_;
+*/
+    };
+}
+
+#endif /* _WeaponMode_H__ */
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponPack.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponPack.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponPack.cc	(revision 2918)
@@ -72,5 +72,5 @@
         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,5 +79,11 @@
     {
         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,19 +120,4 @@
     }
 
-    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,3 +146,9 @@
         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);
+    }
 }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponPack.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponPack.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponPack.h	(revision 2918)
@@ -48,4 +48,5 @@
 
             void fire(unsigned int weaponmode);
+            void reload();
 
             void addWeapon(Weapon * weapon);
@@ -61,16 +62,11 @@
             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_;
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSet.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSet.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSet.cc	(revision 2918)
@@ -64,42 +64,4 @@
         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,4 +71,11 @@
             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();
     }
 
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSet.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSet.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSet.h	(revision 2918)
@@ -47,7 +47,6 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
-//            void attachWeaponPack(WeaponPack *wPack);
-
             void fire();
+            void reload();
 
             void setWeaponmodeLink(WeaponPack* weaponpack, unsigned int weaponmode);
@@ -66,5 +65,5 @@
 
         private:
-            WeaponSystem *weaponSystem_;
+            WeaponSystem * weaponSystem_;
             unsigned int desiredFiremode_;
             std::map<WeaponPack*, unsigned int> weaponpacks_;
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSlot.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSlot.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSlot.cc	(revision 2918)
@@ -64,5 +64,5 @@
         SUPER(WeaponSlot, XMLPort, xmlelement, mode);
 
-        // ...
+        // In the future, there might be parameters like allowed weapon types or max size of the weapon
     }
 
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSystem.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSystem.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSystem.cc	(revision 2918)
@@ -37,4 +37,5 @@
 #include "WeaponSet.h"
 #include "Weapon.h"
+#include "Munition.h"
 
 /* WeaponSystem
@@ -63,18 +64,15 @@
                 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,20 +282,4 @@
     }
 
-    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,3 +288,31 @@
             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;
+        }
+    }
 }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSystem.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSystem.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/WeaponSystem.h	(revision 2918)
@@ -69,9 +69,7 @@
 
             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,5 +94,5 @@
             std::vector<WeaponSlot *> weaponSlots_;
             std::set<WeaponPack *> weaponPacks_;
-            std::map<std::string, Munition *> munitionSet_;
+            std::map<Identifier *, Munition *> munitions_;
             Pawn * pawn_;
     };
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/CMakeLists.txt
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/CMakeLists.txt	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/CMakeLists.txt	(revision 2918)
@@ -1,3 +1,4 @@
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
+  ReplenishingMunition.cc
   LaserGunMunition.cc
   FusionMunition.cc
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/FusionMunition.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/FusionMunition.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/FusionMunition.cc	(revision 2918)
@@ -40,17 +40,14 @@
         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)
-    {
-
-    }
-
 }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/FusionMunition.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/FusionMunition.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/FusionMunition.h	(revision 2918)
@@ -39,12 +39,5 @@
         public:
             FusionMunition(BaseObject* creator);
-            virtual ~FusionMunition();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-
-
-        private:
-
-
+            virtual ~FusionMunition() {}
     };
 }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.cc	(revision 2918)
@@ -36,21 +36,20 @@
     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)
-    {
-
-    }
-
 }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/LaserGunMunition.h	(revision 2918)
@@ -31,20 +31,13 @@
 
 #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() {}
     };
 }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/ReplenishingMunition.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/ReplenishingMunition.cc	(revision 2918)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/ReplenishingMunition.cc	(revision 2918)
@@ -0,0 +1,70 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+#include "ReplenishingMunition.h"
+
+#include "core/CoreIncludes.h"
+
+namespace orxonox
+{
+    CreateFactory(ReplenishingMunition);
+
+    ReplenishingMunition::ReplenishingMunition(BaseObject* creator) : Munition(creator)
+    {
+        RegisterObject(ReplenishingMunition);
+
+        this->replenishIntervall_ = 1.0f;
+        this->replenishMunitionAmount_ = 1;
+
+        // Use the timer to initialize itself after the first tick (because the real values for
+        // replenishIntervall_ and replenishMunitionAmount_ will be set in the constructor of the
+        // inheriting class, which comes after this constructor)
+        this->replenishingTimer_.setTimer(0.0f, false, this, createExecutor(createFunctor(&ReplenishingMunition::initializeTimer)));
+    }
+
+    void ReplenishingMunition::initializeTimer()
+    {
+        // Initialize the timer
+        this->replenishingTimer_.setTimer(this->replenishIntervall_, true, this, createExecutor(createFunctor(&ReplenishingMunition::replenish)));
+    }
+
+    void ReplenishingMunition::replenish()
+    {
+        // Make a temporary copy of bAllowMunitionRefilling_, because this might be disallowed in every
+        // case except the internal munition replenishing
+        bool temp = this->bAllowMunitionRefilling_;
+        this->bAllowMunitionRefilling_ = true;
+
+        // Replenish munition
+        this->addMunition(this->replenishMunitionAmount_);
+
+        // Write back the temporary value
+        this->bAllowMunitionRefilling_ = temp;
+    }
+}
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/ReplenishingMunition.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/ReplenishingMunition.h	(revision 2918)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/munitions/ReplenishingMunition.h	(revision 2918)
@@ -0,0 +1,56 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _ReplenishingMunition_H__
+#define _ReplenishingMunition_H__
+
+#include "OrxonoxPrereqs.h"
+#include "objects/weaponSystem/Munition.h"
+#include "tools/Timer.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport ReplenishingMunition : public Munition
+    {
+        public:
+            ReplenishingMunition(BaseObject* creator);
+            virtual ~ReplenishingMunition() {}
+
+        protected:
+            float replenishIntervall_;
+            unsigned int replenishMunitionAmount_;
+
+        private:
+            void replenish();
+            void initializeTimer();
+
+            Timer<ReplenishingMunition> replenishingTimer_;
+    };
+}
+
+#endif /* _ReplenishingMunition_H__ */
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/projectiles/Projectile.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/projectiles/Projectile.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/projectiles/Projectile.cc	(revision 2918)
@@ -101,4 +101,7 @@
         if (!this->bDestroy_ && GameMode::isMaster())
         {
+            if (otherObject == this->owner_)
+                return true;
+
             this->bDestroy_ = true;
 
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/projectiles/Projectile.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/projectiles/Projectile.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/projectiles/Projectile.h	(revision 2918)
@@ -51,4 +51,9 @@
             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; }
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/CMakeLists.txt
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/CMakeLists.txt	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/CMakeLists.txt	(revision 2918)
@@ -1,5 +1,4 @@
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
-  Fusion.cc
-  LaserGun.cc
-#  Missile.cc
+  FusionFire.cc
+  LaserFire.cc
 )
Index: de/branches/weapons/src/orxonox/objects/weaponSystem/weapons/Fusion.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/Fusion.cc	(revision 2917)
+++ 	(revision )
@@ -1,76 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Martin Polak
- *   Co-authors:
- *      ...
- *
- */
-
-#include "OrxonoxStableHeaders.h"
-#include "Fusion.h"
-
-#include "core/CoreIncludes.h"
-
-#include "objects/weaponSystem/Munition.h"
-#include "objects/weaponSystem/projectiles/ParticleProjectile.h"
-#include "objects/weaponSystem/WeaponSystem.h"
-
-namespace orxonox
-{
-    CreateFactory(Fusion);
-
-    Fusion::Fusion(BaseObject* creator) : Weapon(creator)
-    {
-        RegisterObject(Fusion);
-
-        this->speed_ = 1250;
-
-    }
-
-    Fusion::~Fusion()
-    {
-    }
-
-    void Fusion::takeBullets()
-    {
-//COUT(0) << "Fusion::takeBullets" << std::endl;
-        this->munition_->removeBullets(1);
-        this->bulletTimer(this->bulletLoadingTime_);
-    }
-
-    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());
-    }
-}
Index: de/branches/weapons/src/orxonox/objects/weaponSystem/weapons/Fusion.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/Fusion.h	(revision 2917)
+++ 	(revision )
@@ -1,53 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Martin Polak
- *   Co-authors:
- *      ...
- *
- */
-
-#ifndef _Fusion_H__
-#define _Fusion_H__
-
-#include "OrxonoxPrereqs.h"
-#include "objects/weaponSystem/Weapon.h"
-
-namespace orxonox
-{
-    class _OrxonoxExport Fusion : public Weapon
-    {
-        public:
-            Fusion(BaseObject* creator);
-            virtual ~Fusion();
-
-            virtual void takeBullets();
-            virtual void takeMagazines();
-            virtual void createProjectile();
-
-        private:
-            float speed_;
-
-    };
-}
-
-#endif /* _Fusion_H__ */
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/FusionFire.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/FusionFire.cc	(revision 2918)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/FusionFire.cc	(revision 2918)
@@ -0,0 +1,67 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Martin Polak
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+#include "FusionFire.h"
+
+#include "core/CoreIncludes.h"
+#include "objects/weaponSystem/projectiles/BillboardProjectile.h"
+
+#include "objects/weaponSystem/Weapon.h"
+#include "objects/weaponSystem/WeaponPack.h"
+#include "objects/weaponSystem/WeaponSystem.h"
+
+namespace orxonox
+{
+    CreateFactory(FusionFire);
+
+    FusionFire::FusionFire(BaseObject* creator) : WeaponMode(creator)
+    {
+        RegisterObject(FusionFire);
+
+        this->reloadTime_ = 1.0;
+        this->bParallelReload_ = false;
+        this->damage_ = 40;
+        this->speed_ = 1250;
+
+        this->setMunitionName("FusionMunition");
+    }
+
+    void FusionFire::fire()
+    {
+        BillboardProjectile* projectile = new BillboardProjectile(this);
+
+        projectile->setOrientation(this->getMuzzleOrientation());
+        projectile->setPosition(this->getMuzzlePosition());
+        projectile->setVelocity(this->getMuzzleDirection() * this->speed_);
+
+        projectile->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
+        projectile->setDamage(this->getDamage());
+        projectile->setColour(ColourValue(1.0f, 0.7f, 0.3f, 1.0f));
+    }
+}
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/FusionFire.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/FusionFire.h	(revision 2918)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/FusionFire.h	(revision 2918)
@@ -0,0 +1,50 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Martin Polak
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _FusionFire_H__
+#define _FusionFire_H__
+
+#include "OrxonoxPrereqs.h"
+#include "objects/weaponSystem/WeaponMode.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport FusionFire : public WeaponMode
+    {
+        public:
+            FusionFire(BaseObject* creator);
+            virtual ~FusionFire() {}
+
+            virtual void fire();
+
+        private:
+            float speed_;
+    };
+}
+
+#endif /* _FusionFire_H__ */
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserFire.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserFire.cc	(revision 2918)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserFire.cc	(revision 2918)
@@ -0,0 +1,65 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Martin Polak
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+#include "LaserFire.h"
+
+#include "core/CoreIncludes.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(LaserFire);
+
+    LaserFire::LaserFire(BaseObject* creator) : WeaponMode(creator)
+    {
+        RegisterObject(LaserFire);
+
+        this->reloadTime_ = 0.25;
+        this->damage_ = 15;
+        this->speed_ = 1250;
+
+        this->setMunitionName("LaserGunMunition");
+    }
+
+    void LaserFire::fire()
+    {
+        ParticleProjectile* projectile = new ParticleProjectile(this);
+
+        projectile->setOrientation(this->getMuzzleOrientation());
+        projectile->setPosition(this->getMuzzlePosition());
+        projectile->setVelocity(this->getMuzzleDirection() * this->speed_);
+
+        projectile->setOwner(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
+        projectile->setDamage(this->getDamage());
+    }
+}
Index: /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserFire.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserFire.h	(revision 2918)
+++ /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserFire.h	(revision 2918)
@@ -0,0 +1,50 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Martin Polak
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _LaserFire_H__
+#define _LaserFire_H__
+
+#include "OrxonoxPrereqs.h"
+#include "objects/weaponSystem/WeaponMode.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport LaserFire : public WeaponMode
+    {
+        public:
+            LaserFire(BaseObject* creator);
+            virtual ~LaserFire() {}
+
+            virtual void fire();
+
+        private:
+            float speed_;
+    };
+}
+
+#endif /* _LaserFire_H__ */
Index: de/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserGun.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserGun.cc	(revision 2917)
+++ 	(revision )
@@ -1,82 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Martin Polak
- *   Co-authors:
- *      ...
- *
- */
-
-#include "OrxonoxStableHeaders.h"
-#include "LaserGun.h"
-
-#include "core/CoreIncludes.h"
-
-#include "objects/weaponSystem/Munition.h"
-#include "objects/weaponSystem/projectiles/ParticleProjectile.h"
-#include "objects/weaponSystem/WeaponSystem.h"
-
-namespace orxonox
-{
-    CreateFactory(LaserGun);
-
-    LaserGun::LaserGun(BaseObject* creator) : Weapon(creator)
-    {
-        RegisterObject(LaserGun);
-
-        this->speed_ = 1250;
-
-    }
-
-    LaserGun::~LaserGun()
-    {
-    }
-
-    void LaserGun::reloadBullet()
-    {
-        this->bulletTimer(this->bulletLoadingTime_);
-    }
-
-    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());
-    }
-}
Index: de/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserGun.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/LaserGun.h	(revision 2917)
+++ 	(revision )
@@ -1,55 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Martin Polak
- *   Co-authors:
- *      ...
- *
- */
-
-#ifndef _LaserGun_H__
-#define _LaserGun_H__
-
-#include "OrxonoxPrereqs.h"
-#include "objects/weaponSystem/Weapon.h"
-
-namespace orxonox
-{
-    class _OrxonoxExport LaserGun : public Weapon
-    {
-        public:
-            LaserGun(BaseObject* creator);
-            virtual ~LaserGun();
-
-            virtual void takeBullets();
-            virtual void takeMagazines();
-            virtual void createProjectile();
-            virtual void reloadBullet();
-            virtual void reloadMagazine();
-
-        private:
-            float speed_;
-
-    };
-}
-
-#endif /* _LaserGun_H__ */
Index: de/branches/weapons/src/orxonox/objects/weaponSystem/weapons/Missile.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/Missile.cc	(revision 2917)
+++ 	(revision )
@@ -1,51 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Martin Polak
- *   Co-authors:
- *      ...
- *
- */
-
-#include "OrxonoxStableHeaders.h"
-#include "Missile.h"
-
-#include "core/CoreIncludes.h"
-#include "core/XMLPort.h"
-
-namespace orxonox
-{
-    Missile::Missile(BaseObject* creator) : Weapon(creator)
-    {
-        RegisterObject(Missile);
-    }
-
-    Missile::~Missile()
-    {
-    }
-
-    void Missile::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-
-    }
-
-}
Index: de/branches/weapons/src/orxonox/objects/weaponSystem/weapons/Missile.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/weaponSystem/weapons/Missile.h	(revision 2917)
+++ 	(revision )
@@ -1,52 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Martin Polak
- *   Co-authors:
- *      ...
- *
- */
-
-#ifndef _Missile_H__
-#define _Missile_H__
-
-#include "OrxonoxPrereqs.h"
-#include "objects/weaponSystem/Weapon.h"
-
-namespace orxonox
-{
-    class _OrxonoxExport Missile : public Weapon
-    {
-        public:
-            Missile(BaseObject* creator);
-            virtual ~Missile();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-
-
-        private:
-
-
-    };
-}
-
-#endif /* _Missile_H__ */
Index: /code/branches/weapons/src/orxonox/objects/worldentities/ControllableEntity.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/worldentities/ControllableEntity.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/worldentities/ControllableEntity.h	(revision 2918)
@@ -82,4 +82,5 @@
 
             virtual void fire(unsigned int firemode) {}
+            virtual void reload() {}
 
             virtual void boost() {}
Index: /code/branches/weapons/src/orxonox/objects/worldentities/pawns/Pawn.cc
===================================================================
--- /code/branches/weapons/src/orxonox/objects/worldentities/pawns/Pawn.cc	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/worldentities/pawns/Pawn.cc	(revision 2918)
@@ -56,4 +56,5 @@
         this->fire_ = 0x0;
         this->firehack_ = 0x0;
+        this->bReload_ = false;
 
         this->health_ = 0;
@@ -115,4 +116,5 @@
         registerVariable(this->initialHealth_, variableDirection::toclient);
         registerVariable(this->fire_,          variableDirection::toserver);
+        registerVariable(this->bReload_,       variableDirection::toserver);
     }
 
@@ -121,12 +123,17 @@
         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,4 +265,9 @@
     }
 
+    void Pawn::reload()
+    {
+        this->bReload_ = true;
+    }
+
     void Pawn::postSpawn()
     {
Index: /code/branches/weapons/src/orxonox/objects/worldentities/pawns/Pawn.h
===================================================================
--- /code/branches/weapons/src/orxonox/objects/worldentities/pawns/Pawn.h	(revision 2917)
+++ /code/branches/weapons/src/orxonox/objects/worldentities/pawns/Pawn.h	(revision 2918)
@@ -81,4 +81,5 @@
 
             virtual void fire(unsigned int firemode);
+            virtual void reload();
             virtual void postSpawn();
 
@@ -131,4 +132,5 @@
             unsigned int fire_;
             unsigned int firehack_;
+            bool bReload_;
 
             std::string spawnparticlesource_;
