Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jan 10, 2016, 1:54:11 PM (9 years ago)
Author:
landauf
Message:

merged branch cpp11_v2 into cpp11_v3

Location:
code/branches/cpp11_v3
Files:
55 edited

Legend:

Unmodified
Added
Removed

  • code/branches/cpp11_v3

  • code/branches/cpp11_v3/src/modules/overlays/FadeoutText.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/GUIOverlay.cc

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/GUIOverlay.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/OverlayText.cc

    r9667 r11054  
    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::Left,   "check enum");
     45    static_assert((int)Ogre::TextAreaOverlayElement::Center == (int)OverlayText::Center, "check enum");
     46    static_assert((int)Ogre::TextAreaOverlayElement::Right  == (int)OverlayText::Right,  "check enum");
    4847
    4948    OverlayText::OverlayText(Context* context)

  • code/branches/cpp11_v3/src/modules/overlays/OverlayText.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/debugging/DebugFPSText.h

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

  • code/branches/cpp11_v3/src/modules/overlays/debugging/DebugPositionText.cc

    r9943 r11054  
    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/branches/cpp11_v3/src/modules/overlays/debugging/DebugPositionText.h

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

  • code/branches/cpp11_v3/src/modules/overlays/debugging/DebugRTRText.h

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/AnnounceMessage.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/AnnounceMessage.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/ChatOverlay.cc

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/ChatOverlay.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/CountDown.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/CountDown.h

    r9943 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/DeathMessage.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/DeathMessage.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/GametypeFadingMessage.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/GametypeFadingMessage.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/GametypeStaticMessage.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/GametypeStaticMessage.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDBar.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/HUDBar.h

    r11052 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDBoostBar.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/HUDBoostBar.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDEnemyHealthBar.cc

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDEnemyHealthBar.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDHealthBar.cc

    r11052 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDHealthBar.h

    r11052 r11054  
    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)

  • code/branches/cpp11_v3/src/modules/overlays/hud/HUDNavigation.cc

    r11023 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDNavigation.h

    r10291 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDRadar.cc

    r11052 r11054  
    6868        this->shapeMaterials_[RadarViewable::Triangle] = "RadarTriangle.png";
    6969        this->shapeMaterials_[RadarViewable::Square]   = "RadarSquare.png";
    70         this->owner_ = 0;
     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/branches/cpp11_v3/src/modules/overlays/hud/HUDRadar.h

    r9945 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDSpeedBar.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/HUDSpeedBar.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDTimer.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/HUDTimer.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/HUDWeapon.cc

    r11052 r11054  
    141141    void HUDWeapon::updateWeaponModeList()
    142142    {
    143         if (owner_ == NULL || weapon_ == NULL)
     143        if (owner_ == nullptr || weapon_ == nullptr)
    144144        {
    145145            return;

  • code/branches/cpp11_v3/src/modules/overlays/hud/HUDWeaponSystem.cc

    r11052 r11054  
    117117    void HUDWeaponSystem::updateWeaponList()
    118118    {
    119         if (owner_ == NULL)
     119        if (owner_ == nullptr)
    120120        {
    121121            return;

  • code/branches/cpp11_v3/src/modules/overlays/hud/KillMessage.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/KillMessage.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/LastManStandingInfos.cc

    r10624 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/LastManStandingInfos.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/LastTeamStandingInfos.cc

    r10624 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/LastTeamStandingInfos.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/PauseNotice.cc

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

  • code/branches/cpp11_v3/src/modules/overlays/hud/PauseNotice.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/TeamBaseMatchScore.cc

    r10624 r11054  
    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/branches/cpp11_v3/src/modules/overlays/hud/TeamBaseMatchScore.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/stats/CreateLines.cc

    r6502 r11054  
    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/branches/cpp11_v3/src/modules/overlays/stats/Scoreboard.cc

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/stats/Scoreboard.h

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/stats/Stats.cc

    r9667 r11054  
    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/branches/cpp11_v3/src/modules/overlays/stats/Stats.h

    r9667 r11054  
    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.