Changeset 10961 for code/branches/presentationHS15/src/orxonox

Timestamp:

Dec 9, 2015, 2:45:58 PM (9 years ago)

Author:

maxima

Message:

Merged presentation and fabiens branch. Had to modify hoverHUD and invaderHUD, because the text of the healthbar wasn't correctly displayed and the weapon settings of the hovership.

Location:

code/branches/presentationHS15

Files:

• . (modified) (1 prop)
• src/orxonox/OrxonoxPrereqs.h (modified) (1 diff)
• src/orxonox/controllers/HumanController.cc (modified) (1 diff)
• src/orxonox/infos/PlayerInfo.cc (modified) (2 diffs)
• src/orxonox/overlays/OrxonoxOverlay.cc (modified) (1 diff)
• src/orxonox/overlays/OrxonoxOverlay.h (modified) (2 diffs)
• src/orxonox/weaponsystem/CMakeLists.txt (modified) (1 diff)
• src/orxonox/weaponsystem/Munition.cc (modified) (25 diffs)
• src/orxonox/weaponsystem/Munition.h (modified) (6 diffs)
• src/orxonox/weaponsystem/ReplenishingMunition.cc (copied) (copied from code/branches/fabienHS15/src/orxonox/weaponsystem/ReplenishingMunition.cc)
• src/orxonox/weaponsystem/ReplenishingMunition.h (copied) (copied from code/branches/fabienHS15/src/orxonox/weaponsystem/ReplenishingMunition.h)
• src/orxonox/weaponsystem/Weapon.cc (modified) (2 diffs)
• src/orxonox/weaponsystem/Weapon.h (modified) (2 diffs)
• src/orxonox/weaponsystem/WeaponMode.cc (modified) (5 diffs)
• src/orxonox/weaponsystem/WeaponMode.h (modified) (7 diffs)
• src/orxonox/weaponsystem/WeaponPack.cc (modified) (2 diffs)
• src/orxonox/weaponsystem/WeaponPack.h (modified) (2 diffs)
• src/orxonox/weaponsystem/WeaponSystem.cc (modified) (2 diffs)
• src/orxonox/weaponsystem/WeaponSystem.h (modified) (3 diffs)
• src/orxonox/worldentities/MobileEntity.h (modified) (1 diff)
• src/orxonox/worldentities/StaticEntity.h (modified) (1 diff)
• src/orxonox/worldentities/pawns/Pawn.cc (modified) (10 diffs)
• src/orxonox/worldentities/pawns/Pawn.h (modified) (7 diffs)
• src/orxonox/worldentities/pawns/SpaceShip.cc (modified) (1 diff)
• src/orxonox/worldentities/pawns/SpaceShip.h (modified) (4 diffs)

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

@@ -167 +167 @@
     class DefaultWeaponmodeLink;
     class Munition;
+    class ReplenishingMunition;
     class Weapon;
     class WeaponMode;

code/branches/presentationHS15/src/orxonox/controllers/HumanController.cc

@@ -199 +199 @@
     @brief
         Starts the boosting mode.
-        Resets the boosting timeout and ells the ControllableEntity to boost (or not boost anymore).
+        Resets the boosting timeout and tells the ControllableEntity to boost (or not boost anymore).
     */
     void HumanController::startBoosting(void)

code/branches/presentationHS15/src/orxonox/infos/PlayerInfo.cc

@@ -202 +202 @@
 
         this->changedControllableEntity();
+
+         // HACK-ish
+        if(this->isHumanPlayer())
+            entity->createHud();
     }
 
@@ -252 +256 @@
         if( !entity || this->previousControllableEntity_.size() == 0 )
             return;
+
+        entity->destroyHud(); // HACK-ish
 
         this->controllableEntity_->setController(0);

code/branches/presentationHS15/src/orxonox/overlays/OrxonoxOverlay.cc

@@ -450 +450 @@
         tempTx->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, colour);
     }
+
+    void OrxonoxOverlay::setZOrder(unsigned short order)
+    {
+        if (this->overlay_)
+        {
+            this->overlay_->setZOrder(order);
+        }
+    }
 }

code/branches/presentationHS15/src/orxonox/overlays/OrxonoxOverlay.h

@@ -65 +65 @@
           only for displaying a picture).
         - Reacts to changes of the window aspect
-        - Last but not least: On demand you can tell the overlay to automatically resale to correct for
+        - Last but not least: On demand you can tell the overlay to automatically rescale to correct for
           aspect distortion. E.g. if you play 1024x768 you wouldn't want a round object to be oval.
           Remark: This can (due to the Ogre::Overlay transformation order) only work for angle that are
@@ -186 +186 @@
         virtual void changedOverlayGroup()
             { this->changedVisibility(); }
+        virtual void setZOrder(unsigned short order);
 
     protected:

code/branches/presentationHS15/src/orxonox/weaponsystem/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
   Munition.cc
+  ReplenishingMunition.cc
   Weapon.cc
   WeaponMode.cc

code/branches/presentationHS15/src/orxonox/weaponsystem/Munition.cc

@@ -24 +24 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Fabien Vultier
  *
  */
@@ -32 +32 @@
 #include "core/CoreIncludes.h"
 #include "core/command/Executor.h"
+#include "core/XMLPort.h"
 
 namespace orxonox
@@ -43 +44 @@
         this->maxMunitionPerMagazine_ = 10;
         this->maxMagazines_ = 10;
-        this->magazines_ = 10;
-
-        this->bUseSeparateMagazines_ = false;
-        this->bStackMunition_ = true;
+        this->unassignedMagazines_ = 10;
+
+        this->deployment_ = MunitionDeployment::Stack;
         this->bAllowMunitionRefilling_ = true;
         this->bAllowMultiMunitionRemovementUnderflow_ = true;
 
-        this->reloadTime_ = 0;
+        this->reloadTime_ = 0.5f;
+
+        this->lastFilledWeaponMode_ = NULL;
     }
 
     Munition::~Munition()
     {
-        for (std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.begin(); it != this->currentMagazines_.end(); ++it)
+        for (std::map<WeaponMode*, Magazine*>::iterator it = this->assignedMagazines_.begin(); it != this->assignedMagazines_.end(); ++it)
             delete it->second;
     }
 
+    void Munition::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(Munition, XMLPort, xmlelement, mode);
+
+        XMLPortParam(Munition, "initialmagazines", setNumMagazines, getNumMagazines, xmlelement, mode);
+        XMLPortParam(Munition, "maxmagazines", setMaxMagazines, getMaxMagazines, xmlelement, mode);
+        XMLPortParam(Munition, "munitionpermagazine", setMaxMunitionPerMagazine, getMaxMunitionPerMagazine, xmlelement, mode);
+    }
+
     Munition::Magazine* Munition::getMagazine(WeaponMode* user) const
     {
-        if (this->bUseSeparateMagazines_)
+        if (deployment_ == MunitionDeployment::Separate)
         {
             // For separated magazines we definitively need a given user
@@ -68 +79 @@
 
             // 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())
+            std::map<WeaponMode*, Magazine*>::const_iterator it = this->assignedMagazines_.find(user);
+            if (it != this->assignedMagazines_.end())
                 return it->second;
         }
@@ -75 +86 @@
         {
             // 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;
+            if (this->assignedMagazines_.size() > 0)
+                return this->assignedMagazines_.begin()->second;
         }
 
@@ -87 +98 @@
         if (magazine)
         {
-            if (this->bStackMunition_)
+            if (deployment_ == MunitionDeployment::Stack)
                 // With stacked munition every magazine contributes to the total amount
-                return this->maxMunitionPerMagazine_ * this->magazines_ + magazine->munition_;
+                return this->maxMunitionPerMagazine_ * this->unassignedMagazines_ + magazine->munition_;
             else
                 // Wihtout stacked munition we just consider the current magazine
@@ -109 +120 @@
     unsigned int Munition::getNumMagazines() const
     {
-        if (this->bStackMunition_)
+        if (deployment_ == MunitionDeployment::Stack)
         {
             // 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_;
+                return this->unassignedMagazines_ + 1;
+        }
+
+        return this->unassignedMagazines_;
+    }
+
+    void Munition::setNumMagazines(unsigned int numMagazines)
+    {
+        this->unassignedMagazines_ = numMagazines;
     }
 
     unsigned int Munition::getMaxMunition() const
     {
-        if (this->bStackMunition_)
+        if (deployment_ == MunitionDeployment::Stack)
             return this->maxMunitionPerMagazine_ * this->maxMagazines_;
         else
@@ -135 +151 @@
             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 we stack munition, we don't care about the current magazine - we just need enough munition in total
+            if (deployment_ == MunitionDeployment::Stack)
+            {
+                munition += this->maxMunitionPerMagazine_ * this->unassignedMagazines_;
+            }
 
             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;
@@ -169 +194 @@
             {
                 // Not enough munition
-                if (this->bStackMunition_)
+                if (deployment_ == MunitionDeployment::Stack)
                 {
                     // We stack munition, so just take what we can and then load the next magazine
@@ -175 +200 @@
                     magazine->munition_ = 0;
 
-                    if (this->reload(0))
+                    if (this->reload(NULL))
                         // Successfully reloaded, continue recursively
                         return this->takeMunition(amount, 0);
@@ -199 +224 @@
     {
         // As long as we have enough magazines (and don't stack munition) we can reload
-        return (this->magazines_ > 0 && !this->bStackMunition_);
+        return (this->unassignedMagazines_ > 0 && deployment_ != MunitionDeployment::Stack);
     }
 
@@ -207 +232 @@
         if (magazine)
         {
-            if (this->bStackMunition_)
+            if (deployment_ == MunitionDeployment::Stack)
                 // With stacked munition, we never have to reload
                 return false;
@@ -227 +252 @@
 
         // Check if we actually can reload
-        if (this->magazines_ == 0)
+        if (this->unassignedMagazines_ == 0)
             return false;
 
         // If we use separate magazines for each user, we definitively need a user given
-        if (this->bUseSeparateMagazines_ && !user)
+        if (deployment_ == MunitionDeployment::Separate && !user)
             return false;
 
         // If we don't use separate magazines, set user to 0
-        if (!this->bUseSeparateMagazines_)
-            user = 0;
+        if (deployment_ != MunitionDeployment::Separate)
+        {
+            user = NULL;
+        }
 
         // Remove the current magazine for the given user
-        std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.find(user);
-        if (it != this->currentMagazines_.end())
-        {
+        std::map<WeaponMode*, Magazine*>::iterator it = this->assignedMagazines_.find(user);
+        if (it != this->assignedMagazines_.end())
+        {
+            if (it->first == lastFilledWeaponMode_)
+            {
+                lastFilledWeaponMode_ = NULL;
+            }            
             delete it->second;
-            this->currentMagazines_.erase(it);
+            this->assignedMagazines_.erase(it);
         }
 
         // Load a new magazine
-        this->currentMagazines_[user] = new Magazine(this, bUseReloadTime);
-        this->magazines_--;
+        this->assignedMagazines_[user] = new Magazine(this, bUseReloadTime);
+        this->unassignedMagazines_--;
 
         return true;
@@ -260 +291 @@
             return false;
 
-        if (this->bStackMunition_)
+        if (deployment_ == MunitionDeployment::Stack)
         {
             // If we stack munition, we can always add munition until we reach the limit
@@ -268 +299 @@
         {
             // 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)
+            for (std::map<WeaponMode*, Magazine*>::const_iterator it = this->assignedMagazines_.begin(); it != this->assignedMagazines_.end(); ++it)
                 if (it->second->munition_ < this->maxMunitionPerMagazine_ && it->second->bLoaded_)
                     return true;
@@ -281 +312 @@
             return false;
 
-        if (this->bStackMunition_)
+        if (deployment_ == MunitionDeployment::Stack)
         {
             // Stacking munition means, if a magazine gets full, the munition adds to a new magazine
-            Magazine* magazine = this->getMagazine(0);
+            Magazine* magazine = this->getMagazine(NULL);
             if (magazine)
             {
@@ -294 +325 @@
                 {
                     magazine->munition_ -= this->maxMunitionPerMagazine_;
-                    this->magazines_++;
+                    this->unassignedMagazines_++;
                 }
 
-                // If we reached the limit, reduze both magazines and munition to the maximum
-                if (this->magazines_ >= this->maxMagazines_)
-                {
-                    this->magazines_ = this->maxMagazines_ - 1;
+                // If we reached the limit, reduce both magazines and munition to the maximum
+                if (this->unassignedMagazines_ >= this->maxMagazines_)
+                {
+                    this->unassignedMagazines_ = this->maxMagazines_;
                     magazine->munition_ = this->maxMunitionPerMagazine_;
                 }
@@ -312 +343 @@
         else
         {
+            std::map<WeaponMode*, Magazine*>::iterator it;
+
+            // If the pointer to the weapon mode whose magazine got munition added to is NULL, then set the iterator to the beginning of the map
+            // Otherwise set it to the next weapon mode
+            if (lastFilledWeaponMode_ == NULL)
+            {
+                it = this->assignedMagazines_.begin();
+            }
+            else
+            {
+                it = this->assignedMagazines_.find(lastFilledWeaponMode_);
+                ++ it;
+            }
+
             // Share the munition equally to the current magazines
+            bool firstLoop = true;
             while (amount > 0)
             {
                 bool change = false;
-                for (std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.begin(); it != this->currentMagazines_.end(); ++it)
+                while (it != this->assignedMagazines_.end())
                 {
                     // Add munition if the magazine isn't full (but only to loaded magazines)
@@ -323 +369 @@
                         it->second->munition_++;
                         amount--;
+                        lastFilledWeaponMode_ = it->first;
                         change = true;
                     }
+
+                    ++it;
                 }
 
                 // If there was no change in a loop, all magazines are full (or locked due to loading)
-                if (!change)
+                // Because the first loop does not start at the beginning of the map we have to treat is separately
+                if (!change && !firstLoop)
+                {
                     break;
+                }                    
+
+                it = this->assignedMagazines_.begin();
+                firstLoop = false;
             }
 
@@ -340 +395 @@
         // TODO: 'amount' is not used
 
-        if (this->bStackMunition_)
+        if (deployment_ == MunitionDeployment::Stack)
             // 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)
-    {
+            return ((this->assignedMagazines_.size() + this->unassignedMagazines_) < this->maxMagazines_);
+    }
+
+    unsigned int Munition::addMagazines(unsigned int amount)
+    {
+        unsigned int addedMagazines = 0;
+
         if (!this->canAddMagazines(amount))
-            return false;
+            return 0;
 
         // Calculate how many magazines are needed
-        int needed_magazines = this->maxMagazines_ - this->magazines_ - this->currentMagazines_.size();
+        int needed_magazines = this->maxMagazines_ - this->unassignedMagazines_ - this->assignedMagazines_.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 (needed_magazines <= 0 && deployment_ != MunitionDeployment::Stack)
+            return 0;
 
         if (amount <= static_cast<unsigned int>(needed_magazines))
         {
             // We need more magazines than we get, so just add them
-            this->magazines_ += amount;
+            this->unassignedMagazines_ += amount;
+            addedMagazines = amount;
         }
         else
         {
             // We get more magazines than we need, so just add the needed amount
-            this->magazines_ += needed_magazines;
-            if (this->bStackMunition_)
+            this->unassignedMagazines_ += needed_magazines;
+            addedMagazines = needed_magazines;
+            if (deployment_ == MunitionDeployment::Stack)
             {
                 // We stack munition, so the additional amount contributes directly to the munition of the current magazine
@@ -378 +437 @@
         }
 
-        return true;
+        // Reload as many empty magazines as possible
+        // Double loop and break is needed because the reload function changes the assigned magazines. This may confuse the iterator.
+        for (unsigned int i = 0; i < addedMagazines; ++i)
+        {
+            for (std::map<WeaponMode*, Magazine*>::iterator it = this->assignedMagazines_.begin(); it != this->assignedMagazines_.end(); ++it)
+            {
+                if (needReload(it->first))
+                {
+                    reload(it->first);
+                    break;
+                }
+            }
+        }
+
+        return addedMagazines;
     }
 
     bool Munition::canRemoveMagazines(unsigned int amount) const
     {
-        if (this->bStackMunition_)
-        {
-            if (this->magazines_ >= amount)
+        if (deployment_ == MunitionDeployment::Stack)
+        {
+            if (this->unassignedMagazines_ >= amount)
             {
                 // We have enough magazines
                 return true;
             }
-            else if (this->magazines_ == amount - 1)
+            else if (this->unassignedMagazines_ == amount - 1)
             {
                 // We lack one magazine, check if the current magazine is still full, if yes we're fine
@@ -406 +479 @@
         {
             // In case we're not stacking munition, just check the number of magazines
-            return (this->magazines_ >= amount);
+            return (this->unassignedMagazines_ >= amount);
         }
 
@@ -417 +490 @@
             return false;
 
-        if (this->magazines_ >= amount)
+        if (this->unassignedMagazines_ >= amount)
         {
             // We have enough magazines, just remove the amount
-            this->magazines_ -= amount;
-        }
-        else if (this->bStackMunition_)
+            this->unassignedMagazines_ -= amount;
+        }
+        else if (deployment_ == MunitionDeployment::Stack)
         {
             // We don't have enough magazines, but we're stacking munition, so additionally remove the bullets from the current magazine
-            this->magazines_ = 0;
+            this->unassignedMagazines_ = 0;
             Magazine* magazine = this->getMagazine(0);
             if (magazine)
@@ -437 +510 @@
     {
         // If we use separate magazines, we need a user
-        if (this->bUseSeparateMagazines_ && !user)
+        if (deployment_ == MunitionDeployment::Separate && !user)
             return false;
 
         // If we don't use separate magazines, set user to 0
-        if (!this->bUseSeparateMagazines_)
-            user = 0;
+        if (deployment_ != MunitionDeployment::Separate)
+            user = NULL;
 
         // Remove the current magazine for the given user
-        std::map<WeaponMode*, Magazine*>::iterator it = this->currentMagazines_.find(user);
-        if (it != this->currentMagazines_.end())
-        {
+        std::map<WeaponMode*, Magazine*>::iterator it = this->assignedMagazines_.find(user);
+        if (it != this->assignedMagazines_.end())
+        {
+            if (it->first == lastFilledWeaponMode_)
+            {
+                lastFilledWeaponMode_ = NULL;
+            }
             delete it->second;
-            this->currentMagazines_.erase(it);
+            this->assignedMagazines_.erase(it);           
             return true;
         }
@@ -465 +542 @@
         this->bLoaded_ = false;
 
-        if (bUseReloadTime && munition->reloadTime_ > 0 && !munition->bStackMunition_)
+        if (bUseReloadTime && munition->reloadTime_ > 0 && !munition->deployment_ == MunitionDeployment::Stack)
         {
             const ExecutorPtr& executor = createExecutor(createFunctor(&Magazine::loaded, this));

code/branches/presentationHS15/src/orxonox/weaponsystem/Munition.h

@@ -24 +24 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Fabien Vultier
  *
  */
@@ -39 +39 @@
 namespace orxonox
 {
+    namespace MunitionDeployment
+    {
+        enum Value
+        {
+            Separate, // Every comsuming weapon mode has its own magazine. It is possible that one weapon mode is out of ammo while another still has some.
+            Share, // All comsuming weapon modes take their munition from the same magazine. If this magazine is empty a new one is loaded.
+            Stack // There is only one magazine where all the munition is stored. Use this deployment mode for heavy weapons loke rockets, bombs, ...
+        };
+    }
+
     class _OrxonoxExport Munition : public BaseObject
-    {
+    {        
         struct Magazine
         {
@@ -59 +69 @@
             virtual ~Munition();
 
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+
             unsigned int getNumMunition(WeaponMode* user) const;
             unsigned int getNumMunitionInCurrentMagazine(WeaponMode* user) const;
@@ -68 +80 @@
             inline unsigned int getMaxMunitionPerMagazine() const
                 { return this->maxMunitionPerMagazine_; }
+            inline MunitionDeployment::Value getMunitionDeployment() const
+                { return deployment_; }
+
 
             bool canTakeMunition(unsigned int amount, WeaponMode* user) const;
@@ -82 +97 @@
 
             bool canAddMagazines(unsigned int amount) const;
-            bool addMagazines(unsigned int amount);
+            /**
+            @brief Try to add magazines.
+            @param amount The amount of magazines tried to add.
+            @return The amount of magazines sucessfully added.
+            */
+            unsigned int addMagazines(unsigned int amount);
 
             bool canRemoveMagazines(unsigned int amount) const;
@@ -92 +112 @@
             unsigned int maxMunitionPerMagazine_;
             unsigned int maxMagazines_;
-            unsigned int magazines_;
-            std::map<WeaponMode*, Magazine*> currentMagazines_;
+            unsigned int unassignedMagazines_; // Number of magazines that are not assigned to a weapon mode. These are alway treated as full.
+            std::map<WeaponMode*, Magazine*> assignedMagazines_; // Maps weapon modes to magazines that are currently used.
 
-            bool bUseSeparateMagazines_;
-            bool bStackMunition_;
+            MunitionDeployment::Value deployment_; // Defines the behaviour how munition and magazines are distributed to the consuming weapon modes.
+
             bool bAllowMunitionRefilling_;
             bool bAllowMultiMunitionRemovementUnderflow_;
 
-            float reloadTime_;
+            float reloadTime_; // The time needed to replace a magazine by a new one.
+            WeaponMode* lastFilledWeaponMode_; // Pointer to the weapon mode that got the last munition during the last call of addMunition.
 
         private:
             Magazine* getMagazine(WeaponMode* user) const;
+            inline void setMaxMagazines(unsigned int maxMagazines)
+                { this->maxMagazines_ = maxMagazines; }
+            inline void setMaxMunitionPerMagazine(unsigned int maxMunitionPerMagazine)
+                { this->maxMunitionPerMagazine_ = maxMunitionPerMagazine; }
+            void setNumMagazines(unsigned int numMagazines);
     };
 }

code/branches/presentationHS15/src/orxonox/weaponsystem/Weapon.cc

@@ -134 +134 @@
     }
 
+    /**
+    @brief
+        Reload all @ref orxonox::WeaponMode weapon modes of this weapon.
+    */
     void Weapon::reload()
     {
@@ -151 +155 @@
             it->second->setWeapon(this);
     }
+
+    void Weapon::updateMunition()
+    {
+        for (std::multimap<unsigned int, WeaponMode*>::iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it)
+            it->second->updateMunition();
+    }
 }

code/branches/presentationHS15/src/orxonox/weaponsystem/Weapon.h

@@ -57 +57 @@
             void addWeaponmode(WeaponMode* weaponmode);
             WeaponMode* getWeaponmode(unsigned int index) const;
+            inline std::multimap<unsigned int, WeaponMode*>* getAllWeaponmodes()
+                { return &weaponmodes_; }
+            inline int getNumWeaponModes() const
+                { return weaponmodes_.size(); }
 
             /**
@@ -75 +79 @@
             inline WeaponSlot * getWeaponSlot() const
                 { return this->weaponSlot_; }
+            void updateMunition();
 
         private:

code/branches/presentationHS15/src/orxonox/weaponsystem/WeaponMode.cc

@@ -75 +75 @@
         this->muzzleOrientation_ = Quaternion::IDENTITY;
 
+        hudImageString_ = "WSHUD_WM_Unknown";
+
         if( GameMode::isMaster() )
         {
@@ -125 +127 @@
             this->bSoundAttached_ = true;
         }
-
+        
+        // Fireing is only possible if this weapon mode is not reloading and there is enough munition
         if (!this->bReloading_ && this->munition_ && this->munition_->takeMunition(this->munitionPerShot_, this))
         {
@@ -134 +137 @@
                 if (this->munition_->reload(this))
                 {
+                    // If true, the weapon reloads in parallel to the magazine reloading
                     if (this->bParallelReload_)
+                    {
+                        // The time needed to reload is the maximum of the reload time of the weapon mode and the magazine.
                         tempReloadtime = std::max(this->reloadTime_, this->munition_->getReloadTime());
+                    }                        
                     else
+                    {
+                        // The time needed to reload is the sum of the reload time of the weapon mode and the magazine.
                         tempReloadtime = this->reloadTime_ + this->munition_->getReloadTime();
+                    }                        
                 }
             }
 
+            // Mark this weapon mode as reloading and start the reload timer
             this->bReloading_ = true;
             this->reloadTimer_.setInterval(tempReloadtime);
@@ -232 +243 @@
         }
         else
-            this->munition_ = 0;
+        {
+            this->munition_ = NULL;
+        }
     }
 
@@ -283 +296 @@
     }
 
-    void WeaponMode::setDefaultSoundWithVolume(const std::string& soundPath, const float soundVolume){
-        if (this->defSndWpnFire_) {
+    void WeaponMode::setDefaultSoundWithVolume(const std::string& soundPath, const float soundVolume)
+    {
+        if (this->defSndWpnFire_)
+        {
             this->defSndWpnFire_->setSource(soundPath);
             this->defSndWpnFire_->setVolume(soundVolume);

code/branches/presentationHS15/src/orxonox/weaponsystem/WeaponMode.h

@@ -38 +38 @@
 #include "core/class/SubclassIdentifier.h"
 #include "tools/Timer.h"
+#include "Munition.h"
 
 namespace orxonox
@@ -104 +105 @@
             inline bool getParallelReload() const
                 { return this->bParallelReload_; }
+            inline bool getReloading() const
+                { return this->bReloading_; }
 
 
@@ -147 +150 @@
             Vector3 getTarget();
 
+            inline const std::string& getHUDImageString() const
+                { return this->hudImageString_; }            
+
+            void updateMunition();
         protected:
             virtual void fire() = 0;
@@ -155 +162 @@
 
             float reloadTime_;
-            bool bAutoReload_;
-            bool bParallelReload_;
+            bool bAutoReload_; // If true, the weapon reloads the magazine automatically.
+            bool bParallelReload_; // If true, the weapon reloads in parallel to the magazine reloading.
 
             float damage_;
@@ -163 +170 @@
             Vector3 muzzleOffset_;
 
-        private:
-            void updateMunition();
+            std::string hudImageString_;
+
+        private:            
             void reloaded();
 
@@ -175 +183 @@
 
             Timer reloadTimer_;
-            bool bReloading_;
+            bool bReloading_; // If true, this weapon mode is marked as reloading.
 
             Vector3 muzzlePosition_;
@@ -181 +189 @@
 
             WorldSound* defSndWpnFire_;
-            bool        bSoundAttached_;
+            bool bSoundAttached_;
     };
 }

code/branches/presentationHS15/src/orxonox/weaponsystem/WeaponPack.cc

@@ -124 +124 @@
     }
 
+    std::vector<Weapon*>* WeaponPack::getAllWeapons()
+    {
+        return &weapons_;        
+    }    
+
     void WeaponPack::addDefaultWeaponmodeLink(DefaultWeaponmodeLink* link)
     {
@@ -156 +161 @@
             (*it)->setWeaponPack(this);
     }
+
+    void WeaponPack::updateMunition()
+    {
+        for (std::vector<Weapon *>::const_iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it)
+            (*it)->updateMunition();
+    }
 }

code/branches/presentationHS15/src/orxonox/weaponsystem/WeaponPack.h

@@ -52 +52 @@
             void removeWeapon(Weapon * weapon);
             Weapon * getWeapon(unsigned int index) const;
+            std::vector<Weapon*>* getAllWeapons();
 
             inline size_t getNumWeapons() const
@@ -65 +66 @@
             inline WeaponSystem * getWeaponSystem() const
                 { return this->weaponSystem_; }
+            void updateMunition();
 
         private:

code/branches/presentationHS15/src/orxonox/weaponsystem/WeaponSystem.cc

@@ -240 +240 @@
     }
 
+    std::vector<WeaponPack *> * WeaponSystem::getAllWeaponPacks()
+    {
+        return &weaponPacks_;
+    }    
+
     bool WeaponSystem::swapWeaponSlots(WeaponSlot * wSlot1, WeaponSlot * wSlot2)
     {
@@ -310 +315 @@
             return it->second;
         }
-        else if (identifier->getIdentifier()->isA(Class(Munition)))
-        {
-            Munition* munition = identifier->fabricate(this->getContext());
-            this->munitions_[identifier->getIdentifier()] = munition;
-            return munition;
-        }
         else
         {
-            return 0;
+            return NULL;
+        }
+    }
+
+    void WeaponSystem::addMunition(Munition* munition)
+    {
+        if (munition == NULL)
+        {
+            return;
+        }
+
+        SubclassIdentifier<Munition> identifier = munition->getIdentifier();
+
+        if (identifier)
+        {
+            this->munitions_[identifier] = munition;
+            updateMunition();
+        }
+        else
+        {
+            orxout(internal_warning) << "Adding munition failed. identifier == NULL " << endl;
+        }
+    }
+
+    void WeaponSystem::updateMunition()
+    {
+        for (std::vector<WeaponPack*>::iterator it = this->weaponPacks_.begin(); it != this->weaponPacks_.end(); ++it)
+        {
+            (*it)->updateMunition();
         }
     }

code/branches/presentationHS15/src/orxonox/weaponsystem/WeaponSystem.h

@@ -67 +67 @@
             void removeWeaponPack(WeaponPack * wPack);
             WeaponPack * getWeaponPack(unsigned int index) const;
+            std::vector<WeaponPack *> * getAllWeaponPacks();
 
             // configure slots and firemodes
@@ -76 +77 @@
 
             Munition * getMunition(SubclassIdentifier<Munition> * identifier);
+            void addMunition(Munition* munition);
 
             inline void setPawn(Pawn * pawn)
@@ -95 +97 @@
 
         private:
+            void updateMunition();
+            
             std::map<unsigned int, WeaponSet *> weaponSets_;
             std::vector<WeaponSlot *> weaponSlots_;

code/branches/presentationHS15/src/orxonox/worldentities/MobileEntity.h

@@ -47 +47 @@
         linear velocity. Then the linear velocity is multiplied by the time since the last call of tick and then added to the position. The same happens with
         the angular acceleration and velocity. With this procedure MobileEntities can change their position and orientation with time.
+
+        A MobileEntity can only have the collisition type WorldEntity::None, WorldEntity::Dynamic or WorldEntity::Kinematic. The collsion type WorldEntity::Static is illegal.
     */
 

code/branches/presentationHS15/src/orxonox/worldentities/StaticEntity.h

@@ -44 +44 @@
         it is called StaticEntity. It will keep the same position (always with respect to its parent) forever unless you call the
         function @see setPosition to changee it.
+
+        A StaticEntity can only have the collisition type WorldEntity::None or WorldEntity::Static. The collsion types WorldEntity::Dynamic and WorldEntity::Kinematic are illegal.
     */
 

code/branches/presentationHS15/src/orxonox/worldentities/pawns/Pawn.cc

@@ -46 +46 @@
 #include "weaponsystem/WeaponPack.h"
 #include "weaponsystem/WeaponSet.h"
+#include "weaponsystem/Munition.h"
 #include "sound/WorldSound.h"
 
@@ -61 +62 @@
 
         this->bAlive_ = true;
-        this->bReload_ = false;
 
         this->health_ = 0;
@@ -71 +71 @@
         this->maxShieldHealth_ = 100; //otherwise shield might increase to float_max
         this->shieldAbsorption_ = 0.5;
-
-        this->reloadRate_ = 0;
-        this->reloadWaitTime_ = 1.0f;
-        this->reloadWaitCountdown_ = 0;
+        this->shieldRechargeRate_ = 0;
+        this->shieldRechargeWaitTime_ = 1.0f;
+        this->shieldRechargeWaitCountdown_ = 0;
 
         this->lastHitOriginator_ = 0;
@@ -141 +140 @@
         XMLPortObject(Pawn, WeaponSlot, "weaponslots", addWeaponSlot, getWeaponSlot, xmlelement, mode);
         XMLPortObject(Pawn, WeaponSet, "weaponsets", addWeaponSet, getWeaponSet, xmlelement, mode);
-        XMLPortObject(Pawn, WeaponPack, "weapons", addWeaponPackXML, getWeaponPack, xmlelement, mode);
-
-        XMLPortParam(Pawn, "reloadrate", setReloadRate, getReloadRate, xmlelement, mode).defaultValues(0);
-        XMLPortParam(Pawn, "reloadwaittime", setReloadWaitTime, getReloadWaitTime, xmlelement, mode).defaultValues(1.0f);
+        XMLPortObject(Pawn, WeaponPack, "weaponpacks", addWeaponPackXML, getWeaponPack, xmlelement, mode);
+        XMLPortObject(Pawn, Munition, "munition", addMunitionXML, getMunitionXML, xmlelement, mode);
+
+        XMLPortParam(Pawn, "shieldrechargerate", setShieldRechargeRate, getShieldRechargeRate, xmlelement, mode).defaultValues(0);
+        XMLPortParam(Pawn, "shieldrechargewaittime", setShieldRechargeWaitTime, getShieldRechargeWaitTime, xmlelement, mode).defaultValues(1.0f);
 
         XMLPortParam(Pawn, "explosionSound",  setExplosionSound,  getExplosionSound,  xmlelement, mode);
@@ -153 +153 @@
     void Pawn::registerVariables()
     {
-        registerVariable(this->bAlive_,           VariableDirection::ToClient);
-        registerVariable(this->health_,           VariableDirection::ToClient);
-        registerVariable(this->maxHealth_,        VariableDirection::ToClient);
-        registerVariable(this->shieldHealth_,     VariableDirection::ToClient);
-        registerVariable(this->maxShieldHealth_,  VariableDirection::ToClient);
-        registerVariable(this->shieldAbsorption_, VariableDirection::ToClient);
-        registerVariable(this->bReload_,          VariableDirection::ToServer);
-        registerVariable(this->aimPosition_,      VariableDirection::ToServer);  // For the moment this variable gets only transfered to the server
+        registerVariable(this->bAlive_,            VariableDirection::ToClient);
+        registerVariable(this->health_,            VariableDirection::ToClient);
+        registerVariable(this->maxHealth_,         VariableDirection::ToClient);
+        registerVariable(this->shieldHealth_,      VariableDirection::ToClient);
+        registerVariable(this->maxShieldHealth_,   VariableDirection::ToClient);
+        registerVariable(this->shieldAbsorption_,  VariableDirection::ToClient);
+        registerVariable(this->aimPosition_,       VariableDirection::ToServer);  // For the moment this variable gets only transfered to the server
     }
 
@@ -167 +166 @@
         SUPER(Pawn, tick, dt);
 
-        this->bReload_ = false;
-
+        // Recharge the shield
         // TODO: use the existing timer functions instead
-        if(this->reloadWaitCountdown_ > 0)
-        {
-            this->decreaseReloadCountdownTime(dt);
-        }
-        else
-        {
-            this->addShieldHealth(this->getReloadRate() * dt);
-            this->resetReloadCountdown();
+        if(this->shieldRechargeWaitCountdown_ > 0)
+        {
+            this->decreaseShieldRechargeCountdownTime(dt);
+        }
+        else
+        {
+            this->addShieldHealth(this->getShieldRechargeRate() * dt);
+            this->resetShieldRechargeCountdown();
         }
 
@@ -229 +227 @@
     }
 
-    void Pawn::setReloadRate(float reloadrate)
-    {
-        this->reloadRate_ = reloadrate;
-    }
-
-    void Pawn::setReloadWaitTime(float reloadwaittime)
-    {
-        this->reloadWaitTime_ = reloadwaittime;
-    }
-
-    void Pawn::decreaseReloadCountdownTime(float dt)
-    {
-        this->reloadWaitCountdown_ -= dt;
+    void Pawn::setShieldRechargeRate(float shieldRechargeRate)
+    {
+        this->shieldRechargeRate_ = shieldRechargeRate;
+    }
+
+    void Pawn::setShieldRechargeWaitTime(float shieldRechargeWaitTime)
+    {
+        this->shieldRechargeWaitTime_ = shieldRechargeWaitTime;
+    }
+
+    void Pawn::decreaseShieldRechargeCountdownTime(float dt)
+    {
+        this->shieldRechargeWaitCountdown_ -= dt;
     }
 
@@ -252 +250 @@
         if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
         {
+            // Health-damage cannot be absorbed by shields.
+            // Shield-damage only reduces shield health. 
+            // Normal damage can be (partially) absorbed by shields.
+
             if (shielddamage >= this->getShieldHealth())
             {
@@ -480 +482 @@
     }
 
-    void Pawn::reload()
-    {
-        this->bReload_ = true;
-    }
-
     void Pawn::postSpawn()
     {
@@ -554 +551 @@
     }
 
+    std::vector<WeaponPack *> * Pawn::getAllWeaponPacks()
+    {
+        if (this->weaponSystem_)
+            return this->weaponSystem_->getAllWeaponPacks();
+        else
+            return 0;        
+    }
+
+    void Pawn::addMunitionXML(Munition* munition)
+    {
+        if (this->weaponSystem_ && munition)
+        {
+            this->weaponSystem_->addMunition(munition);
+        }
+    }
+
+    Munition* Pawn::getMunitionXML() const
+    {
+        return NULL;
+    }
+
+    Munition* Pawn::getMunition(SubclassIdentifier<Munition> * identifier)
+    {
+        if (weaponSystem_)
+        {
+            return weaponSystem_->getMunition(identifier);
+        }
+
+        return NULL;
+    }
+
     //Tell the Map (RadarViewable), if this is a playership
     void Pawn::startLocalHumanControl()
     {
-//        SUPER(ControllableEntity, changedPlayer());
+//        SUPER(ControllableEntity, startLocalHumanControl());
         ControllableEntity::startLocalHumanControl();
         this->isHumanShip_ = true;

code/branches/presentationHS15/src/orxonox/worldentities/pawns/Pawn.h

@@ -42 +42 @@
     /**
     @brief
-        Everything in Orxonoy that has a health attribute is a Pawn. After a Pawn is spawned its health is set to
+        Everything in Orxonox that has a health attribute is a Pawn. After a Pawn is spawned its health is set to
         its initial health. In every call of the Pawns tick function the game checks whether the pawns health is at
         or below zero. If it is, the pawn gets killed.
 
-        Pawns can carry pickups and fire weapons. The can also have shields.
+        Pawns can carry pickups and fire weapons. They can also have shields.
 
         Notice that every Pawn is a ControllableEntity.
@@ -116 +116 @@
                 { return this->shieldAbsorption_; }
 
-            // TODO: Rename to shieldRechargeRate
-            virtual void setReloadRate(float reloadrate);
-            inline float getReloadRate() const
-                { return this->reloadRate_; }
-
-            virtual void setReloadWaitTime(float reloadwaittime);
-            inline float getReloadWaitTime() const
-                { return this->reloadWaitTime_; }
-
-            inline void resetReloadCountdown()
-                { this->reloadWaitCountdown_ = 0; }
-
-            inline void startReloadCountdown()
-                { this->reloadWaitCountdown_ = this->getReloadWaitTime(); } // TODO: Implement in Projectile.cc
-
-            virtual void decreaseReloadCountdownTime(float dt);
+            virtual void setShieldRechargeRate(float shieldRechargeRate);
+            inline float getShieldRechargeRate() const
+                { return this->shieldRechargeRate_; }
+
+            virtual void setShieldRechargeWaitTime(float shieldRechargeWaitTime);
+            inline float getShieldRechargeWaitTime() const
+                { return this->shieldRechargeWaitTime_; }
+
+            inline void resetShieldRechargeCountdown()
+                { this->shieldRechargeWaitCountdown_ = 0; }
+
+            inline void startShieldRechargeCountdown()
+                { this->shieldRechargeWaitCountdown_ = this->getShieldRechargeWaitTime(); } // TODO: Implement in Projectile.cc
+
+            virtual void decreaseShieldRechargeCountdownTime(float dt);
 
             inline ControllableEntity* getLastHitOriginator() const
                 { return this->lastHitOriginator_; }
 
-            //virtual void hit(Pawn* originator, const Vector3& force, float damage);
-            //virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
             virtual void hit(Pawn* originator, const Vector3& force, const btCollisionShape* cs, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
             virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, const btCollisionShape* cs, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
@@ -144 +141 @@
 
             virtual void fired(unsigned int firemode);
-            virtual void reload();
             virtual void postSpawn();
 
@@ -154 +150 @@
             void addWeaponPackXML(WeaponPack * wPack);
             WeaponPack * getWeaponPack(unsigned int index) const;
+            std::vector<WeaponPack *> * getAllWeaponPacks();
+
+            void addMunitionXML(Munition* munition);
+            Munition* getMunitionXML() const;
+            
+            Munition* getMunition(SubclassIdentifier<Munition> * identifier);
 
             virtual void addedWeaponPack(WeaponPack* wPack) {}
@@ -207 +209 @@
             virtual void spawneffect();
 
-            //virtual void damage(float damage, Pawn* originator = 0);
             virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL, const btCollisionShape* cs = NULL);
 
@@ -226 +227 @@
             float initialShieldHealth_;
             float shieldAbsorption_; ///< Has to be between 0 and 1
-            float reloadRate_;
-            float reloadWaitTime_;
-            float reloadWaitCountdown_;
+            float shieldRechargeRate_;
+            float shieldRechargeWaitTime_;
+            float shieldRechargeWaitCountdown_;
 
             float damageMultiplier_; ///< Used by the Damage Boost Pickup.
@@ -235 +236 @@
 
             WeaponSystem* weaponSystem_;
-            bool bReload_;
 
             std::string spawnparticlesource_;

code/branches/presentationHS15/src/orxonox/worldentities/pawns/SpaceShip.cc

@@ -297 +297 @@
         }
     }
+
+    void SpaceShip::gainBoostPower(float gainedBoostPower)
+    {
+        this->boostPower_ += gainedBoostPower;
+        
+        if (this->boostPower_ > this->initialBoostPower_)
+        {
+            this->boostPower_ = this->initialBoostPower_;
+        }
+
+        // If the booster is in cooldown mode and we gained boost power, the abort the cooldown.
+        if (this->isBoostCoolingDown() && this->boostPower_ > 0.0f)
+        {
+            timer_.stopTimer();
+            this->boostCooledDown();
+        }
+    }
+
     /**
     @brief

code/branches/presentationHS15/src/orxonox/worldentities/pawns/SpaceShip.h

@@ -53 +53 @@
         - The <b>boost</b>, there are quite some parameters pertaining to boosting. The boost is a special move of the SpaceShip, where, for a limited amount of time, it can fly considerably faster than usual. The <b>boostPower</b> is the amount of power available for boosting. The <b>boostPowerRate</b> is the rate at which the boost power is replenished. The <b>boostRate</b> is the rate at which boosting uses power. And the <b>boostCooldownDuration</b> is the time the SpaceShip cannot boost, once all the boost power has been used up. Naturally all of these parameters must be non-negative.
         - The <b>boost shaking</b>, when the SpaceShip boosts, the camera shakes to create a more immersive effect. Two parameters can be used to adjust the effect. The <b>shakeFrequency</b> is the frequency with which the camera shakes. And the <b>shakeAmplitude</b> is the amount with which the camera shakes. Again these parameters must bee non-negative.
-        - The <b>lift</b> creates a more natural flight feeling through the addition of a lift force. There are again tow parameters that can be specified. The <b>lift</b> which is the lift force that is applied. And the <b>stallSpeed</b> which is the forward speed after which no more lift is generated.
+        - The <b>lift</b> creates a more natural flight feeling through the addition of a lift force. There are again two parameters that can be specified. The <b>lift</b> which is the lift force that is applied. And the <b>stallSpeed</b> which is the forward speed after which no more lift is generated.
+
+        A spaceship always needs to have the collision type "dynamic". Other collision types are illegal.
 
         As mentioned @ref orxonox::Engine Engines can be mounted on the SpaceShip. Here is a (primitive) example of a SpaceShip defined in XML:
@@ -250 +252 @@
             inline float getShakeAmplitude() const
                 { return this->shakeAmplitude_; }
+            /**
+            @brief Add boost power. Is non-negative.
+            @return Returns the current boost power.
+            */
+            void gainBoostPower(float gainedBoostPower);
 
         protected:
@@ -262 +269 @@
             bool bBoostCooldown_;         //!< Whether the SpaceShip is currently in boost cooldown, during which boosting is impossible.
             float initialBoostPower_;     //!< The initial (and maximal) boost power.
-            float boostPower_;            //!< The current boost power.
+            float boostPower_;            //!< The current boost power. If the boost power is reduced to zero the boost cooldown will start.
             float boostPowerRate_;        //!< The rate at which the boost power is recharged.
             float boostRate_;             //!< The rate at which boost power is used up.
@@ -289 +296 @@
             std::vector<Engine*> engineList_; //!< The list of all Engines mounted on this SpaceShip.
 
-            Timer timer_;                          //!< Timer for the cooldown duration.
+            Timer timer_;                          //!< Timer for the cooldown of the boost.
             float shakeDt_;                        //!< Temporary variable for the shaking of the camera.
             Vector3 cameraOriginalPosition_;       //!< The original position of the camera before shaking it.