Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jan 17, 2016, 10:29:21 PM (9 years ago)
Author:
landauf
Message:

merged branch cpp11_v3 back to trunk

Location:
code/trunk
Files:
66 edited

Legend:

Unmodified
Added
Removed

  • code/trunk

  • code/trunk/src/modules/overlays/FadeoutText.h

    r9667 r11071  
    4444            virtual ~FadeoutText() {}
    4545
    46             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    47             virtual void tick(float dt);
     46            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
     47            virtual void tick(float dt) override;
    4848
    4949            inline void setDelay(float delay)
    … …  
    5858
    5959        private:
    60             virtual void changedColour();
    61             virtual void changedCaption();
     60            virtual void changedColour() override;
     61            virtual void changedCaption() override;
    6262
    6363            void fadeout();

  • code/trunk/src/modules/overlays/GUIOverlay.cc

    r9667 r11071  
    9292            ControllableEntity* entity = orxonox_cast<ControllableEntity*>(this->getOwner());
    9393            if (entity)
    94                 GUIManager::getInstance().setPlayer(name, entity->getPlayer()); //Set Player is going to be NULL, so it needs to be set in changedVisibility() as well.
     94                GUIManager::getInstance().setPlayer(name, entity->getPlayer()); //Set Player is going to be nullptr, so it needs to be set in changedVisibility() as well.
    9595        }
    9696    }

  • code/trunk/src/modules/overlays/GUIOverlay.h

    r9667 r11071  
    4444            virtual ~GUIOverlay();
    4545
    46             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     46            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
    4747
    4848            void setGUIName(const std::string& name);
    4949            inline const std::string& getGUIName() const { return this->guiName_; }
    5050
    51             virtual void changedVisibility();
    52             virtual void changedOwner();
     51            virtual void changedVisibility() override;
     52            virtual void changedOwner() override;
    5353
    5454        private:

  • code/trunk/src/modules/overlays/OverlayText.cc

    r9667 r11071  
    3232#include <OgrePanelOverlayElement.h>
    3333#include <OgreTextAreaOverlayElement.h>
    34 #include <boost/static_assert.hpp>
    3534
    3635#include "util/StringUtils.h"
    … …  
    4342    RegisterClass(OverlayText);
    4443
    45     BOOST_STATIC_ASSERT((int)Ogre::TextAreaOverlayElement::Left   == (int)OverlayText::Left);
    46     BOOST_STATIC_ASSERT((int)Ogre::TextAreaOverlayElement::Center == (int)OverlayText::Center);
    47     BOOST_STATIC_ASSERT((int)Ogre::TextAreaOverlayElement::Right  == (int)OverlayText::Right);
     44    static_assert((int)Ogre::TextAreaOverlayElement::Left   == (int)OverlayText::Alignment::Left,   "check enum");
     45    static_assert((int)Ogre::TextAreaOverlayElement::Center == (int)OverlayText::Alignment::Center, "check enum");
     46    static_assert((int)Ogre::TextAreaOverlayElement::Right  == (int)OverlayText::Alignment::Right,  "check enum");
    4847
    4948    OverlayText::OverlayText(Context* context)
    … …  
    8685    {
    8786        if (alignment == "right")
    88             this->setAlignment(OverlayText::Right);
     87            this->setAlignment(OverlayText::Alignment::Right);
    8988        else if (alignment == "center")
    90             this->setAlignment(OverlayText::Center);
     89            this->setAlignment(OverlayText::Alignment::Center);
    9190        else // "left" and default
    92             this->setAlignment(OverlayText::Left);
     91            this->setAlignment(OverlayText::Alignment::Left);
    9392    }
    9493
    … …  
    112111    void OverlayText::sizeChanged()
    113112    {
    114         if (this->rotState_ == Horizontal)
     113        if (this->rotState_ == RotationState::Horizontal)
    115114            this->overlay_->setScale(size_.y * sizeCorrection_.y, size_.y * sizeCorrection_.y);
    116         else if (this->rotState_ == Vertical)
     115        else if (this->rotState_ == RotationState::Vertical)
    117116            this->overlay_->setScale(size_.y / (sizeCorrection_.y * sizeCorrection_.y), size_.y * sizeCorrection_.y);
    118117        else

  • code/trunk/src/modules/overlays/OverlayText.h

    r9667 r11071  
    4242    {
    4343    public:
    44         enum Alignment
     44        enum class Alignment
    4545        {
    4646            Left,
    … …  
    5252        virtual ~OverlayText();
    5353
    54         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     54        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
    5555
    5656        void setCaption(const std::string& caption);
    … …  
    7676
    7777    protected:
    78         virtual void sizeChanged();
     78        virtual void sizeChanged() override;
    7979        virtual void changedColour() {}
    8080        virtual void changedCaption() {}

  • code/trunk/src/modules/overlays/debugging/DebugFPSText.h

    r9667 r11071  
    4343        virtual ~DebugFPSText();
    4444
    45         virtual void tick(float dt);
     45        virtual void tick(float dt) override;
    4646    };
    4747}

  • code/trunk/src/modules/overlays/debugging/DebugPositionText.cc

    r9943 r11071  
    5252        SUPER(DebugPositionText, tick, dt);
    5353       
    54         ObjectList<NewHumanController>::iterator it = ObjectList<NewHumanController>::begin();
     54        ObjectList<NewHumanController>::iterator it = ObjectList<NewHumanController>().begin();
    5555        if (it && it->getControllableEntity() )
    5656        {

  • code/trunk/src/modules/overlays/debugging/DebugPositionText.h

    r9943 r11071  
    4343        virtual ~DebugPositionText();
    4444
    45         virtual void tick(float dt);
     45        virtual void tick(float dt) override;
    4646    };
    4747}

  • code/trunk/src/modules/overlays/debugging/DebugRTRText.h

    r9667 r11071  
    4343        virtual ~DebugRTRText();
    4444
    45         virtual void tick(float dt);
     45        virtual void tick(float dt) override;
    4646    };
    4747}

  • code/trunk/src/modules/overlays/hud/AnnounceMessage.cc

    r9667 r11071  
    4040        RegisterObject(AnnounceMessage);
    4141
    42         this->owner_ = 0;
     42        this->owner_ = nullptr;
    4343
    4444        this->setDelay(3.0f);

  • code/trunk/src/modules/overlays/hud/AnnounceMessage.h

    r9667 r11071  
    4343            virtual ~AnnounceMessage() {}
    4444
    45             virtual void changedOwner();
     45            virtual void changedOwner() override;
    4646
    47             void announcemessage(const GametypeInfo* gtinfo, const std::string& message);
     47            virtual void announcemessage(const GametypeInfo* gtinfo, const std::string& message) override;
    4848
    4949        private:

  • code/trunk/src/modules/overlays/hud/ChatOverlay.cc

    r9667 r11071  
    5858    ChatOverlay::~ChatOverlay()
    5959    {
    60         for (std::set<Timer*>::iterator it = this->timers_.begin(); it != this->timers_.end(); ++it)
    61             delete (*it);
     60        for (Timer* timer : this->timers_)
     61            delete timer;
    6262    }
    6363
    … …  
    9292        this->text_->setCaption("");
    9393
    94         for (std::list<Ogre::DisplayString>::iterator it = this->messages_.begin(); it != this->messages_.end(); ++it)
     94        for (const Ogre::DisplayString& message : this->messages_)
    9595        {
    96             this->text_->setCaption(this->text_->getCaption() + "\n" + (*it));
     96            this->text_->setCaption(this->text_->getCaption() + "\n" + message);
    9797        }
    9898    }

  • code/trunk/src/modules/overlays/hud/ChatOverlay.h

    r9667 r11071  
    4949
    5050        protected:
    51             virtual void incomingChat(const std::string& message, const std::string& name);
     51            virtual void incomingChat(const std::string& message, const std::string& name) override;
    5252
    5353            std::list<Ogre::DisplayString> messages_;

  • code/trunk/src/modules/overlays/hud/CountDown.cc

    r9943 r11071  
    7171        RegisterObject(CountDown);
    7272
    73         this->owner_ = 0;
     73        this->owner_ = nullptr;
    7474        this->hasStopped_ = false;
    7575    }

  • code/trunk/src/modules/overlays/hud/CountDown.h

    r9943 r11071  
    4444            virtual ~CountDown();
    4545
    46             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    47             virtual void changedOwner();
    48             virtual void tick(float dt);
     46            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
     47            virtual void changedOwner() override;
     48            virtual void tick(float dt) override;
    4949
    5050            inline void setCounter(float value)

  • code/trunk/src/modules/overlays/hud/DeathMessage.cc

    r9667 r11071  
    4040        RegisterObject(DeathMessage);
    4141
    42         this->owner_ = 0;
     42        this->owner_ = nullptr;
    4343
    4444        this->setDelay(2.0f);

  • code/trunk/src/modules/overlays/hud/DeathMessage.h

    r9667 r11071  
    4343            virtual ~DeathMessage() {}
    4444
    45             virtual void changedOwner();
     45            virtual void changedOwner() override;
    4646
    47             void deathmessage(const GametypeInfo* gtinfo, const std::string& message);
     47            virtual void deathmessage(const GametypeInfo* gtinfo, const std::string& message) override;
    4848
    4949        private:

  • code/trunk/src/modules/overlays/hud/GametypeFadingMessage.cc

    r9667 r11071  
    4040        RegisterObject(GametypeFadingMessage);
    4141
    42         this->owner_ = 0;
     42        this->owner_ = nullptr;
    4343        this->setDelay(2.0f);
    4444        this->setFadeouttime(0.5f);

  • code/trunk/src/modules/overlays/hud/GametypeFadingMessage.h

    r9667 r11071  
    4343            virtual ~GametypeFadingMessage();
    4444
    45             virtual void changedOwner();
     45            virtual void changedOwner() override;
    4646
    47             void fadingmessage(const GametypeInfo* gtinfo, const std::string& message);
     47            virtual void fadingmessage(const GametypeInfo* gtinfo, const std::string& message) override;
    4848
    4949        private:

  • code/trunk/src/modules/overlays/hud/GametypeStaticMessage.cc

    r9667 r11071  
    4242    {
    4343        RegisterObject(GametypeStaticMessage);
    44         this->owner_ = 0;
     44        this->owner_ = nullptr;
    4545    }
    4646

  • code/trunk/src/modules/overlays/hud/GametypeStaticMessage.h

    r9667 r11071  
    4646            virtual ~GametypeStaticMessage();
    4747
    48             virtual void changedOwner();
     48            virtual void changedOwner() override;
    4949
    50             void staticmessage(const GametypeInfo* gtinfo, const std::string& message, const ColourValue& colour);
     50            virtual void staticmessage(const GametypeInfo* gtinfo, const std::string& message, const ColourValue& colour) override;
    5151
    5252        private:

  • code/trunk/src/modules/overlays/hud/HUDBar.cc

    r11052 r11071  
    219219            return barColours_[index];
    220220        else
    221             return 0;
     221            return nullptr;
    222222    }
    223223

  • code/trunk/src/modules/overlays/hud/HUDBar.h

    r11052 r11071  
    5252        virtual ~BarColour() { }
    5353
    54         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);     
     54        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
    5555
    5656        void setColour(const ColourValue& colour) { this->colour_ = colour; }
    … …  
    7272        virtual ~HUDBar();
    7373
    74         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     74        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
    7575
    7676        void clearColours();

  • code/trunk/src/modules/overlays/hud/HUDBoostBar.cc

    r11052 r11071  
    4242        RegisterObject(HUDBoostBar);
    4343
    44         this->owner_ = 0;
     44        this->owner_ = nullptr;
    4545        this->flashInterval_ = 0.25f;
    4646        this->flashDt_ = 0.0f;

  • code/trunk/src/modules/overlays/hud/HUDBoostBar.h

    r9667 r11071  
    4343        virtual ~HUDBoostBar();
    4444
    45         virtual void tick(float dt);
    46         virtual void changedOwner();
     45        virtual void tick(float dt) override;
     46        virtual void changedOwner() override;
    4747
    4848    private:

  • code/trunk/src/modules/overlays/hud/HUDEnemyHealthBar.cc

    r9667 r11071  
    3030
    3131#include "core/config/ConfigValueIncludes.h"
     32#include "core/CoreIncludes.h"
    3233#include "worldentities/pawns/Pawn.h"
    3334
    … …  
    4142
    4243        this->setConfigValues();
    43         this->owner_ = 0;
     44        this->owner_ = nullptr;
    4445    }
    4546
    … …  
    6263    void HUDEnemyHealthBar::updateTarget()
    6364    {
    64         Pawn* pawn = NULL;
     65        Pawn* pawn = nullptr;
    6566        if (this->owner_ && this->useEnemyBar_)
    6667        {
    … …  
    7374            // Don't show the HealthBar if the pawn is invisible
    7475            if (pawn && !pawn->isVisible())
    75                 pawn = NULL;
     76                pawn = nullptr;
    7677        }
    7778        // Set the pawn as owner of the HealthBar
    7879        this->setHealthBarOwner(pawn);
    79         this->setVisible(pawn != NULL);
     80        this->setVisible(pawn != nullptr);
    8081    }
    8182

  • code/trunk/src/modules/overlays/hud/HUDEnemyHealthBar.h

    r9667 r11071  
    4141
    4242            void setConfigValues();
    43             virtual void tick(float dt);
     43            virtual void tick(float dt) override;
    4444
    45             void changedOwner();
     45            virtual void changedOwner() override;
    4646
    4747        private:

  • code/trunk/src/modules/overlays/hud/HUDEnemyShieldBar.cc

    r11052 r11071  
    4141
    4242        this->setConfigValues();
    43         this->owner_ = NULL;
     43        this->owner_ = nullptr;
    4444    }
    4545
    … …  
    6262    void HUDEnemyShieldBar::updateTarget()
    6363    {
    64         Pawn* pawn = NULL;
     64        Pawn* pawn = nullptr;
    6565        if (this->owner_ && this->useEnemyBar_)
    6666        {
    … …  
    7373            // Don't show the EnemyShieldBar if the pawn is invisible
    7474            if (pawn && !pawn->isVisible())
    75                 pawn = NULL;
     75                pawn = nullptr;
    7676        }
    7777        // Set the pawn as owner of the EnemyShieldBar
    7878        this->setShieldBarOwner(pawn);
    79         this->setVisible(pawn != NULL);
     79        this->setVisible(pawn != nullptr);
    8080    }
    8181

  • code/trunk/src/modules/overlays/hud/HUDEnemyShieldBar.h

    r11052 r11071  
    4545
    4646            void setConfigValues();
    47             virtual void tick(float dt);
     47            virtual void tick(float dt) override;
    4848
    49             void changedOwner();
     49            virtual void changedOwner() override;
    5050
    5151        private:

  • code/trunk/src/modules/overlays/hud/HUDHealthBar.cc

    r11052 r11071  
    4343        RegisterObject(HUDHealthBar);
    4444
    45         this->owner_ = 0;
     45        this->owner_ = nullptr;
    4646        this->bUseBarColour_ = false;
    4747        this->textOffset_ = Vector2(0.0f, 0.0f);
    … …  
    6666        {
    6767            this->textoverlay_->destroy();
    68             this->textoverlay_ = NULL;
     68            this->textoverlay_ = nullptr;
    6969        }
    7070    }

  • code/trunk/src/modules/overlays/hud/HUDHealthBar.h

    r11052 r11071  
    4545            virtual ~HUDHealthBar();
    4646
    47             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    48             virtual void tick(float dt);
    49             virtual void changedOwner();
    50             virtual void changedOverlayGroup();
    51             virtual void changedVisibility();
    52             virtual void changedName();
     47            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
     48            virtual void tick(float dt) override;
     49            virtual void changedOwner() override;
     50            virtual void changedOverlayGroup() override;
     51            virtual void changedVisibility() override;
     52            virtual void changedName() override;
    5353
    5454            inline void setTextFont(const std::string& font)
    … …  
    112112                { this->owner_ = owner; }
    113113        protected:
    114             virtual void positionChanged();
    115             virtual void sizeChanged();
     114            virtual void positionChanged() override;
     115            virtual void sizeChanged() override;
    116116        private:
    117             virtual void positionText();
     117            void positionText();
    118118            WeakPtr<Pawn> owner_;
    119119            StrongPtr<OverlayText> textoverlay_;

  • code/trunk/src/modules/overlays/hud/HUDNavigation.cc

    r11023 r11071  
    5353#include "core/config/ConfigValueIncludes.h"
    5454#include "tools/TextureGenerator.h"
    55 // #include <boost/bind/bind_template.hpp>
    5655
    5756
    … …  
    6968    RegisterClass ( HUDNavigation );
    7069
    71     HUDNavigation* HUDNavigation::localHUD_s = 0;
     70    HUDNavigation* HUDNavigation::localHUD_s = nullptr;
    7271
    7372    HUDNavigation::HUDNavigation(Context* context) :
    … …  
    132131        }
    133132        this->fontName_ = font;
    134         for (std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.begin(); it != this->activeObjectList_.end(); ++it)
    135         {
    136             if (it->second.text_ != NULL)
    137                 it->second.text_->setFontName(this->fontName_);
     133        for (const auto& mapEntry : this->activeObjectList_)
     134        {
     135            if (mapEntry.second.text_ != nullptr)
     136                mapEntry.second.text_->setFontName(this->fontName_);
    138137        }
    139138    }
    … …  
    152151        }
    153152        this->textSize_ = size;
    154         for (std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.begin(); it!=this->activeObjectList_.end(); ++it)
    155         {
    156             if (it->second.text_)
    157                 it->second.text_->setCharHeight(size);
     153        for (const auto& mapEntry : this->activeObjectList_)
     154        {
     155            if (mapEntry.second.text_)
     156                mapEntry.second.text_->setCharHeight(size);
    158157        }
    159158    }
    … …  
    183182
    184183        Camera* cam = CameraManager::getInstance().getActiveCamera();
    185         if (cam == NULL)
     184        if (cam == nullptr)
    186185        return;
    187186        const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
    188187
    189         for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
    190         listIt->second = (int)((listIt->first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
     188        for (std::pair<RadarViewable*, unsigned int>& pair : this->sortedObjectList_)
     189        pair.second = (int)((pair.first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
    191190
    192191        this->sortedObjectList_.sort(compareDistance);
    … …  
    209208        bool nextHasToBeSelected = false;
    210209
    211         for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++markerCount, ++listIt)
     210        for (std::list<std::pair<RadarViewable*, unsigned int>>::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++markerCount, ++listIt)
    212211        {
    213212
    … …  
    469468                    if(!it->second.selected_
    470469                            || it->first->getRVVelocity().squaredLength() == 0
    471                             || pawn == NULL
     470                            || pawn == nullptr
    472471                            /* TODO : improve getTeam in such a way that it works
    473                              * || humanPawn == NULL
     472                             * || humanPawn == nullptr
    474473                             * || pawn->getTeam() == humanPawn->getTeam()*/)
    475474                    {
    … …  
    525524        float yScale = this->getActualSize().y;
    526525
    527         for (std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.begin(); it != this->activeObjectList_.end(); ++it)
    528         {
    529             if (it->second.health_ != NULL)
    530                 it->second.health_->setDimensions(this->healthMarkerSize_ * xScale, this->healthMarkerSize_ * yScale);
    531             if (it->second.healthLevel_ != NULL)
    532                 it->second.healthLevel_->setDimensions(this->healthLevelMarkerSize_ * xScale, this->healthLevelMarkerSize_ * yScale);
    533             if (it->second.panel_ != NULL)
    534                 it->second.panel_->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
    535             if (it->second.text_ != NULL)
    536                 it->second.text_->setCharHeight(this->textSize_ * yScale);
    537             if (it->second.target_ != NULL)
    538                 it->second.target_->setDimensions(this->aimMarkerSize_ * xScale, this->aimMarkerSize_ * yScale);
     526        for (const auto& mapEntry : this->activeObjectList_)
     527        {
     528            if (mapEntry.second.health_ != nullptr)
     529                mapEntry.second.health_->setDimensions(this->healthMarkerSize_ * xScale, this->healthMarkerSize_ * yScale);
     530            if (mapEntry.second.healthLevel_ != nullptr)
     531                mapEntry.second.healthLevel_->setDimensions(this->healthLevelMarkerSize_ * xScale, this->healthLevelMarkerSize_ * yScale);
     532            if (mapEntry.second.panel_ != nullptr)
     533                mapEntry.second.panel_->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
     534            if (mapEntry.second.text_ != nullptr)
     535                mapEntry.second.text_->setCharHeight(this->textSize_ * yScale);
     536            if (mapEntry.second.target_ != nullptr)
     537                mapEntry.second.target_->setDimensions(this->aimMarkerSize_ * xScale, this->aimMarkerSize_ * yScale);
    539538        }
    540539    }
    … …  
    546545
    547546        if (this->activeObjectList_.size() >= this->markerLimit_)
    548         if (object == NULL)
     547        if (object == nullptr)
    549548        return;
    550549
    … …  
    634633        }
    635634
    636         for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
     635        for (std::list<std::pair<RadarViewable*, unsigned int>>::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
    637636        {
    638637            if ((listIt->first) == viewable)
    … …  
    664663    {
    665664        const std::set<RadarViewable*>& respawnObjects = this->getOwner()->getScene()->getRadar()->getRadarObjects();
    666         for (std::set<RadarViewable*>::const_iterator it = respawnObjects.begin(); it != respawnObjects.end(); ++it)
    667         {
    668             if (!(*it)->isHumanShip_)
    669             this->addObject(*it);
     665        for (RadarViewable* respawnObject : respawnObjects)
     666        {
     667            if (!respawnObject->isHumanShip_)
     668            this->addObject(respawnObject);
    670669        }
    671670    }

  • code/trunk/src/modules/overlays/hud/HUDNavigation.h

    r10291 r11071  
    5151            void setConfigValues();
    5252
    53             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    54             virtual void tick(float dt);
     53            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
     54            virtual void tick(float dt) override;
    5555
    5656            // RadarListener interface
    57             virtual void addObject(RadarViewable* object);
    58             virtual void removeObject(RadarViewable* viewable);
    59             virtual void objectChanged(RadarViewable* viewable);
     57            virtual void addObject(RadarViewable* object) override;
     58            virtual void removeObject(RadarViewable* viewable) override;
     59            virtual void objectChanged(RadarViewable* viewable) override;
    6060
    61             virtual void changedOwner();
    62             virtual void sizeChanged();
    63             virtual void angleChanged() { }
    64             virtual void positionChanged() { }
    65             virtual void radarTick(float dt) {}
     61            virtual void changedOwner() override;
     62            virtual void sizeChanged() override;
     63            virtual void angleChanged() override { }
     64            virtual void positionChanged() override { }
     65            virtual void radarTick(float dt) override {}
    6666
    67             inline float getRadarSensitivity() const
     67            virtual inline float getRadarSensitivity() const override
    6868                { return 1.0f; }
    6969
    … …  
    141141
    142142            std::map<RadarViewable*, ObjectInfo> activeObjectList_;
    143             std::list<std::pair<RadarViewable*, unsigned int> > sortedObjectList_;
     143            std::list<std::pair<RadarViewable*, unsigned int>> sortedObjectList_;
    144144
    145145            float healthMarkerSize_;

  • code/trunk/src/modules/overlays/hud/HUDRadar.cc

    r11052 r11071  
    6565        this->setMaximumDotSize3D(0.07f);
    6666
    67         this->shapeMaterials_[RadarViewable::Dot]      = "RadarDot.png";
    68         this->shapeMaterials_[RadarViewable::Triangle] = "RadarTriangle.png";
    69         this->shapeMaterials_[RadarViewable::Square]   = "RadarSquare.png";
    70         this->owner_ = 0;
     67        this->shapeMaterials_[RadarViewable::Shape::Dot]      = "RadarDot.png";
     68        this->shapeMaterials_[RadarViewable::Shape::Triangle] = "RadarTriangle.png";
     69        this->shapeMaterials_[RadarViewable::Shape::Square]   = "RadarSquare.png";
     70        this->owner_ = nullptr;
    7171
    7272        this->map3DFront_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
    … …  
    9292            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->map3DBack_);
    9393
    94             for (std::map<RadarViewable*,Ogre::PanelOverlayElement*>::iterator it = this->radarObjects_.begin();
    95                 it != this->radarObjects_.end(); ++it)
    96             {
    97                 Ogre::OverlayManager::getSingleton().destroyOverlayElement(it->second);
     94            for (const auto& mapEntry : this->radarObjects_)
     95            {
     96                Ogre::OverlayManager::getSingleton().destroyOverlayElement(mapEntry.second);
    9897            }
    9998        }
    … …  
    166165    {
    167166        const std::set<RadarViewable*>& objectSet = this->getCreator()->getScene()->getRadar()->getRadarObjects();
    168         std::set<RadarViewable*>::const_iterator it;
    169         for( it=objectSet.begin(); it!=objectSet.end(); ++it )
    170             this->addObject(*it);
     167        for( RadarViewable* viewable : objectSet )
     168            this->addObject(viewable);
    171169        this->radarTick(0);
    172170    }
    … …  
    184182
    185183        // update the distances for all objects
    186         std::map<RadarViewable*,Ogre::PanelOverlayElement*>::iterator it;
    187 
    188184
    189185        if(RadarMode_)
    … …  
    202198        }
    203199
    204         for( it = this->radarObjects_.begin(); it != this->radarObjects_.end(); ++it )
     200        for( const auto& mapEntry : this->radarObjects_ )
    205201        {
    206202            // Make sure the object really is a WorldEntity
    207             const WorldEntity* wePointer = it->first->getWorldEntity();
     203            const WorldEntity* wePointer = mapEntry.first->getWorldEntity();
    208204            if( !wePointer )
    209205            {
    … …  
    211207                assert(0);
    212208            }
    213             bool isFocus = (it->first == focusObject);
     209            bool isFocus = (mapEntry.first == focusObject);
    214210            // set size to fit distance...
    215211            float distance = (wePointer->getWorldPosition() - this->owner_->getPosition()).length();
    … …  
    218214            float size;
    219215            if(RadarMode_)
    220                 size = maximumDotSize3D_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * it->first->getRadarObjectScale();
     216                size = maximumDotSize3D_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * mapEntry.first->getRadarObjectScale();
    221217            else
    222                 size = maximumDotSize_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * it->first->getRadarObjectScale();
    223             it->second->setDimensions(size, size);
     218                size = maximumDotSize_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * mapEntry.first->getRadarObjectScale();
     219            mapEntry.second->setDimensions(size, size);
    224220
    225221            // calc position on radar...
    … …  
    235231                int zOrder = determineMap3DZOrder(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition(), detectionLimit_);
    236232                if(overXZPlain == false /*&& (it->second->getZOrder() >  100 * this->overlay_->getZOrder())*/) // it appears that zOrder of attached Overlayelements is 100 times the zOrder of the Overlay
    237                     it->second->_notifyZOrder(this->overlay_->getZOrder() * 100 - 70 + zOrder);
     233                    mapEntry.second->_notifyZOrder(this->overlay_->getZOrder() * 100 - 70 + zOrder);
    238234                if(overXZPlain == true /*&& (it->second->getZOrder() <= 100 * this->overlay_->getZOrder())*/)
    239                     it->second->_notifyZOrder(this->overlay_->getZOrder() * 100 + 70 + zOrder);
     235                    mapEntry.second->_notifyZOrder(this->overlay_->getZOrder() * 100 + 70 + zOrder);
    240236            }
    241237            else
    … …  
    243239
    244240            coord *= math::pi / 3.5f; // small adjustment to make it fit the texture
    245             it->second->setPosition((1.0f + coord.x - size) * 0.5f, (1.0f - coord.y - size) * 0.5f);
     241            mapEntry.second->setPosition((1.0f + coord.x - size) * 0.5f, (1.0f - coord.y - size) * 0.5f);
    246242
    247243            if( distance < detectionLimit_ || detectionLimit_ < 0 )
    248                 it->second->show();
     244                mapEntry.second->show();
    249245            else
    250                 it->second->hide();
     246                mapEntry.second->hide();
    251247
    252248            // if this object is in focus, then set the focus marker
    … …  
    256252                this->marker_->setPosition((1.0f + coord.x - size * 1.5f) * 0.5f, (1.0f - coord.y - size * 1.5f) * 0.5f);
    257253                if(RadarMode_)
    258                     this->marker_->_notifyZOrder(it->second->getZOrder() -1);
     254                    this->marker_->_notifyZOrder(mapEntry.second->getZOrder() -1);
    259255                this->marker_->show();
    260256            }

  • code/trunk/src/modules/overlays/hud/HUDRadar.h

    r9945 r11071  
    5050        virtual ~HUDRadar();
    5151
    52         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    53         virtual void changedOwner();
     52        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
     53        virtual void changedOwner() override;
    5454        void setConfigValues();
    5555
    … …  
    8080        void set3DMaterialBack(std::string material3DBack) { this->material3DBack_ = material3DBack; }
    8181
    82         float getRadarSensitivity() const { return this->sensitivity_; }
     82        virtual float getRadarSensitivity() const override { return this->sensitivity_; }
    8383        // used also by RadarListener interface!
    8484        void setRadarSensitivity(float sensitivity) { this->sensitivity_ = sensitivity; }
    … …  
    8989
    9090        // RadarListener interface
    91         virtual void addObject(RadarViewable* viewable);
    92         virtual void removeObject(RadarViewable* viewable);
    93         virtual void objectChanged( RadarViewable* rv );
    94         void radarTick(float dt);
     91        virtual void addObject(RadarViewable* viewable) override;
     92        virtual void removeObject(RadarViewable* viewable) override;
     93        virtual void objectChanged( RadarViewable* rv ) override;
     94        virtual void radarTick(float dt) override;
    9595        bool showObject( RadarViewable* rv ); //!< Do not display an object on radar, if showObject(.) is false.
    9696

  • code/trunk/src/modules/overlays/hud/HUDRocketFuelBar.cc

    r11052 r11071  
    4040        RegisterObject(HUDRocketFuelBar);
    4141
    42         this->owner_ = NULL;
     42        this->owner_ = nullptr;
    4343    }
    4444

  • code/trunk/src/modules/overlays/hud/HUDRocketFuelBar.h

    r11052 r11071  
    4949        virtual ~HUDRocketFuelBar();
    5050
    51         virtual void tick(float dt);
    52         virtual void changedOwner();
     51        virtual void tick(float dt) override;
     52        virtual void changedOwner() override;
    5353
    5454    private:

  • code/trunk/src/modules/overlays/hud/HUDShieldBar.cc

    r11052 r11071  
    4141        RegisterObject(HUDShieldBar);
    4242
    43         this->owner_ = NULL;
     43        this->owner_ = nullptr;
    4444    }
    4545

  • code/trunk/src/modules/overlays/hud/HUDShieldBar.h

    r11052 r11071  
    4949        virtual ~HUDShieldBar();
    5050
    51         virtual void tick(float dt);
    52         virtual void changedOwner();
     51        virtual void tick(float dt) override;
     52        virtual void changedOwner() override;
    5353
    5454        inline void setShieldBarOwner(Pawn* owner)

  • code/trunk/src/modules/overlays/hud/HUDSpeedBar.cc

    r9667 r11071  
    4343        RegisterObject(HUDSpeedBar);
    4444
    45         this->owner_ = 0;
     45        this->owner_ = nullptr;
    4646    }
    4747

  • code/trunk/src/modules/overlays/hud/HUDSpeedBar.h

    r9667 r11071  
    4444        virtual ~HUDSpeedBar();
    4545
    46         virtual void tick(float dt);
    47         virtual void changedOwner();
     46        virtual void tick(float dt) override;
     47        virtual void changedOwner() override;
    4848
    4949    private:

  • code/trunk/src/modules/overlays/hud/HUDTimer.cc

    r9667 r11071  
    4242        RegisterObject(HUDTimer);
    4343
    44         this->owner_ = 0;
     44        this->owner_ = nullptr;
    4545    }
    4646

  • code/trunk/src/modules/overlays/hud/HUDTimer.h

    r9667 r11071  
    4343        virtual ~HUDTimer();
    4444
    45         virtual void tick(float dt);
     45        virtual void tick(float dt) override;
    4646
    47         virtual void changedOwner();
     47        virtual void changedOwner() override;
    4848
    4949    private:

  • code/trunk/src/modules/overlays/hud/HUDWeapon.cc

    r11052 r11071  
    4444        weaponModeHUDActualSize_ = Vector2(0.0f,0.0f);
    4545
    46         weaponModes_ = NULL;
    4746        weaponIndex_ = 0;
    4847        hudWeaponModes_.clear();
    … …  
    7776        if (!weapon_)
    7877        {
    79             // TODO: destroy this HUD id the Weapon does no more exist. (Wehen the weak pointer is NULL)
     78            // TODO: destroy this HUD id the Weapon does no more exist. (Wehen the weak pointer is null)
    8079        }
    8180    }   
    … …  
    115114        bool visible = this->isVisible();
    116115
    117         for (std::vector<WeakPtr<HUDWeaponMode> >::iterator it = hudWeaponModes_.begin(); it != hudWeaponModes_.end(); ++it)
    118         {
    119             (*it)->changedVisibility(); //inform all Child Overlays that our visibility has changed
    120             (*it)->setVisible(visible);
     116        for (HUDWeaponMode* hudWeaponMode : hudWeaponModes_)
     117        {
     118            hudWeaponMode->changedVisibility(); //inform all Child Overlays that our visibility has changed
     119            hudWeaponMode->setVisible(visible);
    121120        }
    122121    }
    … …  
    141140    void HUDWeapon::updateWeaponModeList()
    142141    {
    143         if (owner_ == NULL || weapon_ == NULL)
     142        if (owner_ == nullptr || weapon_ == nullptr)
    144143        {
    145144            return;
    … …  
    147146           
    148147        destroyHUDChilds();
    149 
    150         weaponModes_ = weapon_->getAllWeaponmodes();
    151148
    152149        updateSize();
    … …  
    157154    void HUDWeapon::createHUDChilds()
    158155    {
    159         if (weaponModes_ == NULL)
     156        if (weapon_ == nullptr)
    160157        {
    161158            return;
    … …  
    164161        int positionIndex = 0;
    165162
    166         for (std::multimap<unsigned int, WeaponMode*>::iterator it = weaponModes_->begin(); it != weaponModes_->end(); ++it)
     163        for (const auto& mapEntry : weapon_->getAllWeaponmodes())
    167164        {
    168165            HUDWeaponMode* hudWeaponMode = new HUDWeaponMode(this->getContext());
    … …  
    170167            hudWeaponMode->setOverlayGroup(this->getOverlayGroup());
    171168            hudWeaponMode->setVisible(this->isVisible());
    172             hudWeaponMode->setWeaponMode(it->second);
     169            hudWeaponMode->setWeaponMode(mapEntry.second);
    173170            hudWeaponMode->setWeaponIndex(this->weaponIndex_);                   
    174171            hudWeaponMode->setAspectCorrection(false);
    … …  
    185182        int positionIndex = 0;
    186183
    187         for (std::vector<WeakPtr<HUDWeaponMode> >::iterator it = hudWeaponModes_.begin(); it != hudWeaponModes_.end(); ++it)
    188         {
    189             (*it)->setPositionOffset(this->positionOffset_);
    190             (*it)->setWeaponModeIndex(positionIndex);
    191             (*it)->setWeaponIndex(this->weaponIndex_);
    192             (*it)->setWeaponModeHUDActualSize(this->weaponModeHUDActualSize_);
     184        for (HUDWeaponMode* hudWeaponMode : hudWeaponModes_)
     185        {
     186            hudWeaponMode->setPositionOffset(this->positionOffset_);
     187            hudWeaponMode->setWeaponModeIndex(positionIndex);
     188            hudWeaponMode->setWeaponIndex(this->weaponIndex_);
     189            hudWeaponMode->setWeaponModeHUDActualSize(this->weaponModeHUDActualSize_);
    193190
    194191            ++ positionIndex;
    … …  
    198195    void HUDWeapon::destroyHUDChilds()
    199196    {
    200         for (std::vector<WeakPtr<HUDWeaponMode> >::iterator it = hudWeaponModes_.begin(); it != hudWeaponModes_.end(); ++it)
    201         {
    202             (*it)->destroy();
     197        for (HUDWeaponMode* hudWeaponMode : hudWeaponModes_)
     198        {
     199            hudWeaponMode->destroy();
    203200        }
    204201
    … …  
    208205    void HUDWeapon::updateSize()
    209206    {
    210         if (weaponModes_ != NULL)
    211         {
    212             this->setSize(Vector2(weaponModeHUDActualSize_.x,weaponModeHUDActualSize_.y*weaponModes_->size()));
     207        if (weapon_ != nullptr)
     208        {
     209            this->setSize(Vector2(weaponModeHUDActualSize_.x,weaponModeHUDActualSize_.y*weapon_->getAllWeaponmodes().size()));
    213210            updatePosition();
    214211        }       
    … …  
    217214    void HUDWeapon::updatePosition()
    218215    {
    219         if (weaponModes_ != NULL)
     216        if (weapon_ != nullptr)
    220217        {
    221218            this->setPosition(Vector2(weaponModeHUDActualSize_.x*weaponIndex_,0.0f) + this->positionOffset_);

  • code/trunk/src/modules/overlays/hud/HUDWeapon.h

    r11052 r11071  
    5555        virtual ~HUDWeapon();
    5656
    57         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    58         virtual void tick(float dt);
    59         virtual void changedOwner();
    60         virtual void changedOverlayGroup();
    61         virtual void changedVisibility();
    62         virtual void changedName();
    63         virtual void positionChanged();
    64         virtual void sizeChanged();
     57        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
     58        virtual void tick(float dt) override;
     59        virtual void changedOwner() override;
     60        virtual void changedOverlayGroup() override;
     61        virtual void changedVisibility() override;
     62        virtual void changedName() override;
     63        virtual void positionChanged() override;
     64        virtual void sizeChanged() override;
    6565
    66         virtual void setWeapon(Weapon* weapon);
     66        void setWeapon(Weapon* weapon);
    6767
    6868        inline void setWeaponModeHUDActualSize(Vector2 vector)
    … …  
    8484
    8585    private:
    86         virtual void createHUDChilds();
    87         virtual void positionHUDChilds();
    88         virtual void destroyHUDChilds();
    89         virtual void updateWeaponModeList();
    90         virtual void updateSize();
    91         virtual void updatePosition();
     86        void createHUDChilds();
     87        void positionHUDChilds();
     88        void destroyHUDChilds();
     89        void updateWeaponModeList();
     90        void updateSize();
     91        void updatePosition();
    9292
    9393        WeakPtr<Pawn> owner_;
    9494        WeakPtr<Weapon> weapon_;
    9595
    96         std::multimap<unsigned int, WeaponMode*>* weaponModes_;
    97         std::vector<WeakPtr<HUDWeaponMode> > hudWeaponModes_;
     96        std::vector<WeakPtr<HUDWeaponMode>> hudWeaponModes_;
    9897
    9998        Ogre::PanelOverlayElement* overlayElement_;

  • code/trunk/src/modules/overlays/hud/HUDWeaponMode.cc

    r11052 r11071  
    2929#include "HUDWeaponMode.h"
    3030
     31#include "util/Convert.h"
     32#include "util/StringUtils.h"
    3133#include "core/CoreIncludes.h"
    32 #include "core/XMLPort.h"
    33 #include "util/Convert.h"
    3434#include "core/class/Super.h"
    3535
    … …  
    7676        textOverlayLeft_->setPickPoint(Vector2(0.0f,0.0f));
    7777        textOverlayLeft_->setVisible(true);
    78         textOverlayLeft_->setAlignment(OverlayText::Center);
     78        textOverlayLeft_->setAlignment(OverlayText::Alignment::Center);
    7979        textOverlayLeft_->setTextSize(0.02f);
    8080        textOverlayLeft_->setColour(ColourValue(0.21,0.70,0.21,1.0));
    … …  
    8787        textOverlayRight_->setPickPoint(Vector2(0.0f,0.0f));
    8888        textOverlayRight_->setVisible(true);
    89         textOverlayRight_->setAlignment(OverlayText::Center);
     89        textOverlayRight_->setAlignment(OverlayText::Alignment::Center);
    9090        textOverlayRight_->setTextSize(0.02f);
    9191        textOverlayRight_->setColour(ColourValue(0.21,0.70,0.21,1.0));
    … …  
    107107    }
    108108
    109     void HUDWeaponMode::XMLPort(Element& xmlelement, XMLPort::Mode mode)
    110     {
    111         SUPER(HUDWeaponMode, XMLPort, xmlelement, mode);
    112     }
    113 
    114109    void HUDWeaponMode::tick(float dt)
    115110    {
    … …  
    131126            Munition* munition = this->weaponMode_->getMunition();
    132127
    133             if (munition != NULL)
    134             {
    135                 MunitionDeployment::Value deployment = munition->getMunitionDeployment();
     128            if (munition != nullptr)
     129            {
     130                MunitionDeployment deployment = munition->getMunitionDeployment();
    136131
    137132                if (deployment == MunitionDeployment::Share)
    … …  
    242237        Munition* munition = this->weaponMode_->getMunition();
    243238
    244         if (munition != NULL)
    245         {
    246             MunitionDeployment::Value deployment = munition->getMunitionDeployment();
     239        if (munition != nullptr)
     240        {
     241            MunitionDeployment deployment = munition->getMunitionDeployment();
    247242
    248243            if (deployment == MunitionDeployment::Share)

  • code/trunk/src/modules/overlays/hud/HUDWeaponMode.h

    r11052 r11071  
    5757        virtual ~HUDWeaponMode();
    5858
    59         virtual void tick(float dt);
    60         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    61         virtual void changedOwner();
    62         virtual void changedOverlayGroup();
    63         virtual void changedVisibility();
    64         virtual void changedName();
    65         virtual void positionChanged();
    66         virtual void sizeChanged();
     59        virtual void tick(float dt) override;
     60        virtual void changedOwner() override;
     61        virtual void changedOverlayGroup() override;
     62        virtual void changedVisibility() override;
     63        virtual void changedName() override;
     64        virtual void positionChanged() override;
     65        virtual void sizeChanged() override;
    6766
    68         virtual void setWeaponMode(WeaponMode* weaponMode);
     67        void setWeaponMode(WeaponMode* weaponMode);
    6968
    7069        inline void setWeaponModeHUDActualSize(Vector2 vector)
    … …  
    8988
    9089    private:
    91         virtual void updateSize();
    92         virtual void updatePosition();
    93         virtual void positionHUDChilds();
     90        void updateSize();
     91        void updatePosition();
     92        void positionHUDChilds();
    9493
    9594        WeakPtr<Pawn> owner_;

  • code/trunk/src/modules/overlays/hud/HUDWeaponSystem.cc

    r11052 r11071  
    103103        bool visible = this->isVisible();
    104104
    105         for (std::vector<WeakPtr<HUDWeapon> >::iterator it = hudWeapons_.begin(); it != hudWeapons_.end(); ++it)
     105        for (HUDWeapon* hudWeapon : hudWeapons_)
    106106        {
    107             (*it)->changedVisibility(); //inform all Child Overlays that our visibility has changed
    108             (*it)->setVisible(visible);
     107            hudWeapon->changedVisibility(); //inform all Child Overlays that our visibility has changed
     108            hudWeapon->setVisible(visible);
    109109        }
    110110    }
    … …  
    117117    void HUDWeaponSystem::updateWeaponList()
    118118    {
    119         if (owner_ == NULL)
     119        if (owner_ == nullptr)
    120120        {
    121121            return;
    … …  
    126126        destroyHUDChilds();
    127127
    128         std::vector<WeaponPack*>* weaponPacks = owner_->getAllWeaponPacks();
     128        if (owner_->getWeaponSystem())
     129        {
     130            const std::vector<WeaponPack*>& weaponPacks = owner_->getWeaponSystem()->getAllWeaponPacks();
     131            for (WeaponPack* weaponPack : weaponPacks)
     132            {
     133                const std::vector<Weapon*>& weapons = weaponPack->getAllWeapons();
     134                for (Weapon* weapon : weapons)
     135                {
     136                    this->weapons_.push_back(weapon);
     137                }
     138            }
    129139
    130         for (std::vector<WeaponPack*>::const_iterator itPacks = weaponPacks->begin(); itPacks != weaponPacks->end(); ++itPacks)
    131         {
    132             std::vector<Weapon*>* weapons = (*itPacks)->getAllWeapons();
    133 
    134             for (std::vector<Weapon*>::const_iterator itWeapons = weapons->begin(); itWeapons != weapons->end(); ++itWeapons)
    135             {
    136                 this->weapons_.push_back(*itWeapons);
    137             }
     140            createHUDChilds();
     141            positionHUDChilds();
    138142        }
    139 
    140         createHUDChilds();
    141         positionHUDChilds();
    142143    }
    143144
    … …  
    146147        int positionIndex = 0;
    147148
    148         for (std::vector<WeakPtr<Weapon> >::iterator it = weapons_.begin(); it != weapons_.end(); ++it)
     149        for (Weapon* weapon : weapons_)
    149150        {
    150151            HUDWeapon* hudWeapon = new HUDWeapon(this->getContext());
    … …  
    152153            hudWeapon->setOverlayGroup(this->getOverlayGroup());
    153154            hudWeapon->setVisible(this->isVisible());
    154             hudWeapon->setWeapon(*it);
     155            hudWeapon->setWeapon(weapon);
    155156            hudWeapon->setAspectCorrection(false);
    156157            hudWeapon->setPickPoint(Vector2(0.0f,0.0f));
    … …  
    167168        Vector2 offset = this->getPosition();
    168169
    169         for (std::vector<WeakPtr<HUDWeapon> >::iterator it = hudWeapons_.begin(); it != hudWeapons_.end(); ++it)
     170        for (HUDWeapon* hudWeapon : hudWeapons_)
    170171        {
    171             (*it)->setPositionOffset(offset);
    172             (*it)->setWeaponIndex(positionIndex);
    173             (*it)->setWeaponModeHUDActualSize(this->weaponModeHUDActualSize_);
     172            hudWeapon->setPositionOffset(offset);
     173            hudWeapon->setWeaponIndex(positionIndex);
     174            hudWeapon->setWeaponModeHUDActualSize(this->weaponModeHUDActualSize_);
    174175
    175176            ++ positionIndex;
    … …  
    179180    void HUDWeaponSystem::destroyHUDChilds()
    180181    {
    181         for (std::vector<WeakPtr<HUDWeapon> >::iterator it = hudWeapons_.begin(); it != hudWeapons_.end(); ++it)
     182        for (HUDWeapon* hudWeapon : hudWeapons_)
    182183        {
    183             (*it)->destroy();
     184            hudWeapon->destroy();
    184185        }
    185186

  • code/trunk/src/modules/overlays/hud/HUDWeaponSystem.h

    r11052 r11071  
    4949        virtual ~HUDWeaponSystem();
    5050
    51         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    52         virtual void changedOwner();
    53         virtual void changedOverlayGroup();
    54         virtual void changedVisibility();
    55         virtual void changedName();
    56         virtual void positionChanged();
    57         virtual void sizeChanged();
     51        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
     52        virtual void changedOwner() override;
     53        virtual void changedOverlayGroup() override;
     54        virtual void changedVisibility() override;
     55        virtual void changedName() override;
     56        virtual void positionChanged() override;
     57        virtual void sizeChanged() override;
    5858    protected:
    5959        inline void setWeaponModeHUDSize(Vector2 vector)
    … …  
    6464            { return weaponModeHUDSize_; }
    6565    private:
    66         virtual void updateWeaponList();
    67         virtual void createHUDChilds();
    68         virtual void positionHUDChilds();
    69         virtual void destroyHUDChilds();
     66        void updateWeaponList();
     67        void createHUDChilds();
     68        void positionHUDChilds();
     69        void destroyHUDChilds();
    7070
    7171        WeakPtr<Pawn> owner_;
    7272
    73         std::vector<WeakPtr<Weapon> > weapons_;
    74         std::vector<WeakPtr<HUDWeapon> > hudWeapons_;
     73        std::vector<WeakPtr<Weapon>> weapons_;
     74        std::vector<WeakPtr<HUDWeapon>> hudWeapons_;
    7575
    7676        Vector2 weaponModeHUDSize_;

  • code/trunk/src/modules/overlays/hud/KillMessage.cc

    r9667 r11071  
    4040        RegisterObject(KillMessage);
    4141
    42         this->owner_ = 0;
     42        this->owner_ = nullptr;
    4343
    4444        this->setDelay(2.0f);

  • code/trunk/src/modules/overlays/hud/KillMessage.h

    r9667 r11071  
    4343            virtual ~KillMessage() {}
    4444
    45             virtual void changedOwner();
     45            virtual void changedOwner() override;
    4646
    47             void killmessage(const GametypeInfo* gtinfo, const std::string& message);
     47            virtual void killmessage(const GametypeInfo* gtinfo, const std::string& message) override;
    4848
    4949        private:

  • code/trunk/src/modules/overlays/hud/LastManStandingInfos.cc

    r10624 r11071  
    4343        RegisterObject(LastManStandingInfos);
    4444
    45         this->lms_ = 0;
    46         this->player_ = 0;
     45        this->lms_ = nullptr;
     46        this->player_ = nullptr;
    4747        this->bShowLives_ = false;
    4848        this->bShowPlayers_ = false;
    … …  
    9191        else
    9292        {
    93             this->player_ = 0;
    94             this->lms_ = 0;
     93            this->player_ = nullptr;
     94            this->lms_ = nullptr;
    9595        }
    9696    }

  • code/trunk/src/modules/overlays/hud/LastManStandingInfos.h

    r9667 r11071  
    4343            virtual ~LastManStandingInfos();
    4444
    45             virtual void tick(float dt);
    46             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    47             virtual void changedOwner();
     45            virtual void tick(float dt) override;
     46            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
     47            virtual void changedOwner() override;
    4848
    4949            inline void setShowLives(bool value)

  • code/trunk/src/modules/overlays/hud/LastTeamStandingInfos.cc

    r10624 r11071  
    4343        RegisterObject(LastTeamStandingInfos);
    4444
    45         this->lts_ = 0;
    46         this->player_ = 0;
     45        this->lts_ = nullptr;
     46        this->player_ = nullptr;
    4747        this->bShowLives_ = false;
    4848        this->bShowTeams_ = false;
    … …  
    9191        else
    9292        {
    93             this->player_ = 0;
    94             this->lts_ = 0;
     93            this->player_ = nullptr;
     94            this->lts_ = nullptr;
    9595        }
    9696    }

  • code/trunk/src/modules/overlays/hud/LastTeamStandingInfos.h

    r9667 r11071  
    4343            virtual ~LastTeamStandingInfos();
    4444
    45             virtual void tick(float dt);
    46             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    47             virtual void changedOwner();
     45            virtual void tick(float dt) override;
     46            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
     47            virtual void changedOwner() override;
    4848
    4949            inline void setShowLives(bool value)

  • code/trunk/src/modules/overlays/hud/PauseNotice.cc

    r9667 r11071  
    4040        RegisterObject(PauseNotice);
    4141
    42         this->owner_ = 0;
     42        this->owner_ = nullptr;
    4343    }
    4444

  • code/trunk/src/modules/overlays/hud/PauseNotice.h

    r9667 r11071  
    4242            PauseNotice(Context* context);
    4343
    44             virtual void changedOwner();
     44            virtual void changedOwner() override;
    4545
    4646        protected:
    47             virtual void changedTimeFactor(float factor_new, float factor_old);
     47            virtual void changedTimeFactor(float factor_new, float factor_old) override;
    4848
    4949        private:

  • code/trunk/src/modules/overlays/hud/TeamBaseMatchScore.cc

    r10624 r11071  
    4343        RegisterObject(TeamBaseMatchScore);
    4444
    45         this->owner_ = 0;
     45        this->owner_ = nullptr;
    4646
    4747        this->bShowBases_ = false;
    … …  
    120120            this->owner_ = orxonox_cast<TeamBaseMatch*>(this->getOwner()->getGametype());
    121121        else
    122             this->owner_ = 0;
     122            this->owner_ = nullptr;
    123123    }
    124124}

  • code/trunk/src/modules/overlays/hud/TeamBaseMatchScore.h

    r9667 r11071  
    4343            virtual ~TeamBaseMatchScore();
    4444
    45             virtual void tick(float dt);
    46             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    47             virtual void changedOwner();
     45            virtual void tick(float dt) override;
     46            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
     47            virtual void changedOwner() override;
    4848
    4949            inline void setShowBases(bool value)

  • code/trunk/src/modules/overlays/stats/CreateLines.cc

    r6502 r11071  
    3737    CreateLines::CreateLines(float leftOffset, float topOffset, float width, float height)
    3838    {
    39         playerNameText_ = new OverlayText(0);
     39        playerNameText_ = new OverlayText(nullptr);
    4040        playerNameText_->setTextSize(0.04f);
    4141        playerNameText_->setColour(ColourValue(0.0f, 0.75f, 0.2f, 1.0f));
    4242        playerNameText_->setPosition(Vector2(0.1f, topOffset + 0.01f));
    4343
    44         scoreText_ = new OverlayText(0);
     44        scoreText_ = new OverlayText(nullptr);
    4545        scoreText_->setTextSize(0.04f);
    4646        scoreText_->setColour(ColourValue(0.0f, 0.75f, 0.2f, 1.0f));
    4747        scoreText_->setPosition(Vector2(0.6f, topOffset + 0.01f));
    4848
    49         deathsText_ = new OverlayText(0);
     49        deathsText_ = new OverlayText(nullptr);
    5050        deathsText_->setTextSize(0.04f);
    5151        deathsText_->setColour(ColourValue(0, 0.75f, 0.2f, 1.0f));
    5252        deathsText_->setPosition(Vector2(0.8f, topOffset + 0.01f));
    5353
    54         background_ = new Stats(0);
     54        background_ = new Stats(nullptr);
    5555        background_->setPosition(Vector2(leftOffset, topOffset));
    5656        background_->setSize(Vector2(width, height));

  • code/trunk/src/modules/overlays/stats/CreateLines.h

    r5980 r11071  
    2929
    3030#include "overlays/OverlaysPrereqs.h"
     31
     32#include <string>
    3133
    3234namespace orxonox

  • code/trunk/src/modules/overlays/stats/Scoreboard.cc

    r9667 r11071  
    6060        SUPER(Scoreboard, changedVisibility);
    6161
    62         for (unsigned int i = 0; i < this->lines_.size(); ++i)
    63             this->lines_[i]->changedVisibility();
     62        for (CreateLines* line : this->lines_)
     63            line->changedVisibility();
    6464    }
    6565
    … …  
    9494
    9595        unsigned int index = 0;
    96         for (std::map<PlayerInfo*, Player>::const_iterator it = playerList.begin(); it != playerList.end(); ++it)
     96        for (const auto& mapEntry : playerList)
    9797        {
    98             this->lines_[index]->setPlayerName(multi_cast<std::string>(it->first->getName()));
    99             this->lines_[index]->setScore(multi_cast<std::string>(it->second.frags_));
    100             this->lines_[index]->setDeaths(multi_cast<std::string>(it->second.killed_));
     98            this->lines_[index]->setPlayerName(multi_cast<std::string>(mapEntry.first->getName()));
     99            this->lines_[index]->setScore(multi_cast<std::string>(mapEntry.second.frags_));
     100            this->lines_[index]->setDeaths(multi_cast<std::string>(mapEntry.second.killed_));
    101101            index++;
    102102        }

  • code/trunk/src/modules/overlays/stats/Scoreboard.h

    r9667 r11071  
    4444        virtual ~Scoreboard();
    4545
    46         virtual void tick(float dt);
     46        virtual void tick(float dt) override;
    4747
    4848        inline void setCreateLines(CreateLines* cl)
    … …  
    5151            { return this->createlines_; }
    5252
    53         virtual void changedVisibility();
     53        virtual void changedVisibility() override;
    5454
    5555    private: // functions

  • code/trunk/src/modules/overlays/stats/Stats.cc

    r9667 r11071  
    4646    Stats::Stats(Context* context)
    4747        : OrxonoxOverlay(context)
    48         , statsOverlayNoise_(0)
    49         , statsOverlayBorder_(0)
     48        , statsOverlayNoise_(nullptr)
     49        , statsOverlayBorder_(nullptr)
    5050    {
    5151        RegisterObject(Stats);

  • code/trunk/src/modules/overlays/stats/Stats.h

    r9667 r11071  
    4646        void setConfigValues();
    4747
    48         virtual void tick(float dt);
     48        virtual void tick(float dt) override;
    4949
    5050    private: // variables
Note: See TracChangeset for help on using the changeset viewer.