Index: code/trunk/src/modules/gametypes/OldRaceCheckPoint.cc
===================================================================
--- code/trunk/src/modules/gametypes/OldRaceCheckPoint.cc	(revision 10624)
+++ code/trunk/src/modules/gametypes/OldRaceCheckPoint.cc	(revision 11071)
@@ -49,5 +49,5 @@
 
         this->setRadarObjectColour(ColourValue::Blue);
-        this->setRadarObjectShape(RadarViewable::Triangle);
+        this->setRadarObjectShape(RadarViewable::Shape::Triangle);
         this->setRadarVisibility(false);
     }
Index: code/trunk/src/modules/gametypes/OldRaceCheckPoint.h
===================================================================
--- code/trunk/src/modules/gametypes/OldRaceCheckPoint.h	(revision 10624)
+++ code/trunk/src/modules/gametypes/OldRaceCheckPoint.h	(revision 11071)
@@ -48,9 +48,9 @@
             virtual ~OldRaceCheckPoint();
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            virtual void tick(float dt);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+            virtual void tick(float dt) override;
 
             protected:
-            virtual void triggered(bool bIsTriggered);
+            virtual void triggered(bool bIsTriggered) override;
             inline void setLast(bool isLast)
                 { this->bIsLast_ = isLast; }
@@ -64,5 +64,5 @@
             inline float getTimeLimit()
                 { return this->bTimeLimit_;}
-            inline const WorldEntity* getWorldEntity() const
+            virtual inline const WorldEntity* getWorldEntity() const override
                 { return this; }
 
Index: code/trunk/src/modules/gametypes/OldSpaceRace.h
===================================================================
--- code/trunk/src/modules/gametypes/OldSpaceRace.h	(revision 10624)
+++ code/trunk/src/modules/gametypes/OldSpaceRace.h	(revision 11071)
@@ -55,9 +55,9 @@
             virtual ~OldSpaceRace() {}
 
-            virtual void start();
-            virtual void end();
+            virtual void start() override;
+            virtual void end() override;
 
             virtual void newCheckpointReached();
-            virtual void addBots(unsigned int amount){} //<! overwrite function in order to bypass the addbots command.
+            virtual void addBots(unsigned int amount) override{} //<! overwrite function in order to bypass the addbots command.
                                                         //<! This is only a temporary solution. Better: create racingBots.
 
Index: code/trunk/src/modules/gametypes/RaceCheckPoint.cc
===================================================================
--- code/trunk/src/modules/gametypes/RaceCheckPoint.cc	(revision 10624)
+++ code/trunk/src/modules/gametypes/RaceCheckPoint.cc	(revision 11071)
@@ -53,5 +53,5 @@
 
         this->setRadarObjectColour(ColourValue::Blue);
-        this->setRadarObjectShape(RadarViewable::Triangle);
+        this->setRadarObjectShape(RadarViewable::Shape::Triangle);
         this->setRadarVisibility(false);
         this->settingsChanged();
@@ -125,5 +125,5 @@
             }
         }
-        return NULL;
+        return nullptr;
     }
 
@@ -146,11 +146,11 @@
     {
         Vector3 checkpoints(-1,-1,-1); int count=0;
-        for (std::set<int>::iterator it= nextCheckpoints_.begin();it!=nextCheckpoints_.end(); it++ )
+        for (int nextCheckpoint : nextCheckpoints_)
         {
             switch (count)
             {
-                case 0: checkpoints.x = static_cast<Ogre::Real>(*it); break;
-                case 1: checkpoints.y = static_cast<Ogre::Real>(*it); break;
-                case 2: checkpoints.z = static_cast<Ogre::Real>(*it); break;
+                case 0: checkpoints.x = static_cast<Ogre::Real>(nextCheckpoint); break;
+                case 1: checkpoints.y = static_cast<Ogre::Real>(nextCheckpoint); break;
+                case 2: checkpoints.z = static_cast<Ogre::Real>(nextCheckpoint); break;
             }
             ++count;
Index: code/trunk/src/modules/gametypes/RaceCheckPoint.h
===================================================================
--- code/trunk/src/modules/gametypes/RaceCheckPoint.h	(revision 10624)
+++ code/trunk/src/modules/gametypes/RaceCheckPoint.h	(revision 11071)
@@ -48,5 +48,5 @@
             virtual ~RaceCheckPoint();
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 
             inline void setCheckpointIndex(int checkpointIndex)
@@ -92,7 +92,7 @@
         protected:
 
-            virtual void fire(bool bIsTriggered, BaseObject* originator);
+            virtual void fire(bool bIsTriggered, BaseObject* originator) override;
 
-            inline const WorldEntity* getWorldEntity() const
+            virtual inline const WorldEntity* getWorldEntity() const override
             {
                 return this;
Index: code/trunk/src/modules/gametypes/SpaceRace.cc
===================================================================
--- code/trunk/src/modules/gametypes/SpaceRace.cc	(revision 10624)
+++ code/trunk/src/modules/gametypes/SpaceRace.cc	(revision 11071)
@@ -88,6 +88,6 @@
             this->cantMove_ = true;
 
-            for (ObjectList<Engine>::iterator it = ObjectList<Engine>::begin(); it; ++it)
-                it->setActive(false);
+            for (Engine* engine : ObjectList<Engine>())
+                engine->setActive(false);
         }
 
@@ -95,6 +95,6 @@
         if (!this->isStartCountdownRunning() && this->cantMove_)
         {
-            for (ObjectList<Engine>::iterator it = ObjectList<Engine>::begin(); it; ++it)
-                it->setActive(true);
+            for (Engine* engine : ObjectList<Engine>())
+                engine->setActive(true);
 
             this->cantMove_= false;
Index: code/trunk/src/modules/gametypes/SpaceRace.h
===================================================================
--- code/trunk/src/modules/gametypes/SpaceRace.h	(revision 10624)
+++ code/trunk/src/modules/gametypes/SpaceRace.h	(revision 11071)
@@ -57,7 +57,7 @@
             virtual ~SpaceRace() {}
 
-            void tick(float dt);
+            virtual void tick(float dt) override;
 
-            virtual void end();
+            virtual void end() override;
 
             void newCheckpointReached(RaceCheckPoint* checkpoint, PlayerInfo* player);
@@ -70,7 +70,7 @@
                 { return this->clock_; }
 
-            bool allowPawnHit(Pawn* victim, Pawn* originator);
-            bool allowPawnDamage(Pawn* victim, Pawn* originator);
-            bool allowPawnDeath(Pawn* victim, Pawn* originator);
+            virtual bool allowPawnHit(Pawn* victim, Pawn* originator) override;
+            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator) override;
+            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator) override;
 
         private:
Index: code/trunk/src/modules/gametypes/SpaceRaceController.cc
===================================================================
--- code/trunk/src/modules/gametypes/SpaceRaceController.cc	(revision 10624)
+++ code/trunk/src/modules/gametypes/SpaceRaceController.cc	(revision 11071)
@@ -59,10 +59,10 @@
 
         virtualCheckPointIndex = -2;
-        if (ObjectList<SpaceRaceManager>::size() != 1)
-            orxout(internal_warning) << "Expected 1 instance of SpaceRaceManager but found " << ObjectList<SpaceRaceManager>::size() << endl;
-        for (ObjectList<SpaceRaceManager>::iterator it = ObjectList<SpaceRaceManager>::begin(); it != ObjectList<SpaceRaceManager>::end(); ++it)
-        {
-            checkpoints = it->getAllCheckpoints();
-            nextRaceCheckpoint_ = it->findCheckpoint(0);
+        if (ObjectList<SpaceRaceManager>().size() != 1)
+            orxout(internal_warning) << "Expected 1 instance of SpaceRaceManager but found " << ObjectList<SpaceRaceManager>().size() << endl;
+        for (SpaceRaceManager* manager : ObjectList<SpaceRaceManager>())
+        {
+            checkpoints = manager->getAllCheckpoints();
+            nextRaceCheckpoint_ = manager->findCheckpoint(0);
         }
 
@@ -98,5 +98,5 @@
                     RaceCheckPoint* point2 = findCheckpoint((*numb));
 
-                    //if(point2 != NULL)
+                    //if(point2 != nullptr)
                     //placeVirtualCheckpoints((*it), point2);
                 }
@@ -126,8 +126,8 @@
         staticRacePoints_ = findStaticCheckpoints(nextRaceCheckpoint_, checkpoints);
         // initialisation of currentRaceCheckpoint_
-        currentRaceCheckpoint_ = NULL;
+        currentRaceCheckpoint_ = nullptr;
 
         int i;
-        for (i = -2; findCheckpoint(i) != NULL; i--)
+        for (i = -2; findCheckpoint(i) != nullptr; i--)
         {
             continue;
@@ -154,16 +154,16 @@
     {
         std::map<RaceCheckPoint*, int> zaehler; // counts how many times the checkpoint was reached (for simulation)
-        for (unsigned int i = 0; i < allCheckpoints.size(); i++)
-        {
-            zaehler.insert(std::pair<RaceCheckPoint*, int>(allCheckpoints[i],0));
+        for (RaceCheckPoint* checkpoint : allCheckpoints)
+        {
+            zaehler.insert(std::pair<RaceCheckPoint*, int>(checkpoint,0));
         }
         int maxWays = rekSimulationCheckpointsReached(currentCheckpoint, zaehler);
 
         std::vector<RaceCheckPoint*> returnVec;
-        for (std::map<RaceCheckPoint*, int>::iterator iter = zaehler.begin(); iter != zaehler.end(); iter++)
-        {
-            if (iter->second == maxWays)
-            {
-                returnVec.push_back(iter->first);
+        for (const auto& mapEntry : zaehler)
+        {
+            if (mapEntry.second == maxWays)
+            {
+                returnVec.push_back(mapEntry.first);
             }
         }
@@ -187,15 +187,15 @@
         {
             int numberOfWays = 0; // counts number of ways from this Point to the last point
-            for (std::set<int>::iterator it = currentCheckpoint->getNextCheckpoints().begin(); it!= currentCheckpoint->getNextCheckpoints().end(); ++it)
-            {
-                if (currentCheckpoint == findCheckpoint(*it))
+            for (int checkpointIndex : currentCheckpoint->getNextCheckpoints())
+            {
+                if (currentCheckpoint == findCheckpoint(checkpointIndex))
                 {
                     //orxout() << currentCheckpoint->getCheckpointIndex()<<endl;
                     continue;
                 }
-                if (findCheckpoint(*it) == NULL)
-                    orxout(internal_warning) << "Problematic Point: " << (*it) << endl;
+                if (findCheckpoint(checkpointIndex) == nullptr)
+                    orxout(internal_warning) << "Problematic Point: " << checkpointIndex << endl;
                 else
-                    numberOfWays += rekSimulationCheckpointsReached(findCheckpoint(*it), zaehler);
+                    numberOfWays += rekSimulationCheckpointsReached(findCheckpoint(checkpointIndex), zaehler);
             }
             zaehler[currentCheckpoint] += numberOfWays;
@@ -209,5 +209,5 @@
     float SpaceRaceController::distanceSpaceshipToCheckPoint(RaceCheckPoint* CheckPoint)
     {
-        if (this->getControllableEntity() != NULL)
+        if (this->getControllableEntity() != nullptr)
         {
             return (CheckPoint->getPosition()- this->getControllableEntity()->getPosition()).length();
@@ -223,13 +223,13 @@
     {
         float minDistance = 0;
-        RaceCheckPoint* minNextRaceCheckPoint = NULL;
+        RaceCheckPoint* minNextRaceCheckPoint = nullptr;
 
         // find the next checkpoint with the minimal distance
-        for (std::set<int>::iterator it = raceCheckpoint->getNextCheckpoints().begin(); it != raceCheckpoint->getNextCheckpoints().end(); ++it)
-        {
-            RaceCheckPoint* nextRaceCheckPoint = findCheckpoint(*it);
+        for (int checkpointIndex : raceCheckpoint->getNextCheckpoints())
+        {
+            RaceCheckPoint* nextRaceCheckPoint = findCheckpoint(checkpointIndex);
             float distance = recCalculateDistance(nextRaceCheckPoint, this->getControllableEntity()->getPosition());
 
-            if (distance < minDistance || minNextRaceCheckPoint == NULL)
+            if (distance < minDistance || minNextRaceCheckPoint == nullptr)
             {
                 minDistance = distance;
@@ -255,9 +255,9 @@
         {
             float minimum = std::numeric_limits<float>::max();
-            for (std::set<int>::iterator it = currentCheckPoint->getNextCheckpoints().begin(); it != currentCheckPoint->getNextCheckpoints().end(); ++it)
+            for (int checkpointIndex : currentCheckPoint->getNextCheckpoints())
             {
                 int dist_currentCheckPoint_currentPosition = static_cast<int> ((currentPosition- currentCheckPoint->getPosition()).length());
 
-                minimum = std::min(minimum, dist_currentCheckPoint_currentPosition + recCalculateDistance(findCheckpoint(*it), currentCheckPoint->getPosition()));
+                minimum = std::min(minimum, dist_currentCheckPoint_currentPosition + recCalculateDistance(findCheckpoint(checkpointIndex), currentCheckPoint->getPosition()));
                 // minimum of distanz from 'currentPosition' to the next static Checkpoint
             }
@@ -271,5 +271,5 @@
     RaceCheckPoint* SpaceRaceController::adjustNextPoint()
     {
-        if (currentRaceCheckpoint_ == NULL) // no Adjust possible
+        if (currentRaceCheckpoint_ == nullptr) // no Adjust possible
 
         {
@@ -289,8 +289,8 @@
     RaceCheckPoint* SpaceRaceController::findCheckpoint(int index) const
     {
-        for (size_t i = 0; i < this->checkpoints_.size(); ++i)
-            if (this->checkpoints_[i]->getCheckpointIndex() == index)
-                return this->checkpoints_[i];
-        return NULL;
+        for (RaceCheckPoint* checkpoint : this->checkpoints_)
+            if (checkpoint->getCheckpointIndex() == index)
+                return checkpoint;
+        return nullptr;
     }
 
@@ -299,5 +299,6 @@
         orxout()<<"add VCP at"<<virtualCheckPointPosition.x<<", "<<virtualCheckPointPosition.y<<", "<<virtualCheckPointPosition.z<<endl;
         RaceCheckPoint* newTempRaceCheckPoint;
-        for (ObjectList<SpaceRaceManager>::iterator it = ObjectList<SpaceRaceManager>::begin(); it!= ObjectList<SpaceRaceManager>::end(); ++it)
+        ObjectList<SpaceRaceManager> list;
+        for (ObjectList<SpaceRaceManager>::iterator it = list.begin(); it!= list.end(); ++it)
         {
             newTempRaceCheckPoint = new RaceCheckPoint((*it));
@@ -347,5 +348,5 @@
     void SpaceRaceController::tick(float dt)
     {
-        if (this->getControllableEntity() == NULL || this->getControllableEntity()->getPlayer() == NULL )
+        if (this->getControllableEntity() == nullptr || this->getControllableEntity()->getPlayer() == nullptr )
         {
             //orxout()<< this->getControllableEntity() << " in tick"<<endl;
@@ -414,10 +415,10 @@
         btScalar radiusObject;
 
-        for (std::vector<StaticEntity*>::const_iterator it = allObjects.begin(); it != allObjects.end(); ++it)
-        {
-            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != 0; everyShape++)
-            {
-                btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
-                if(currentShape == NULL)
+        for (StaticEntity* object : allObjects)
+        {
+            for (int everyShape=0; object->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
+            {
+                btCollisionShape* currentShape = object->getAttachedCollisionShape(everyShape)->getCollisionShape();
+                if(currentShape == nullptr)
                 continue;
 
@@ -444,8 +445,8 @@
         for (std::vector<StaticEntity*>::iterator it = allObjects.begin(); it != allObjects.end(); ++it)
         {
-            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != 0; everyShape++)
+            for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
             {
                 btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
-                if(currentShape == NULL)
+                if(currentShape == nullptr)
                 continue;
 
@@ -488,8 +489,9 @@
         std::vector<StaticEntity*> problematicObjects;
 
-        for (ObjectList<StaticEntity>::iterator it = ObjectList<StaticEntity>::begin(); it!= ObjectList<StaticEntity>::end(); ++it)
-        {
-
-            if (dynamic_cast<RaceCheckPoint*>(*it) != NULL)
+        ObjectList<StaticEntity> list;
+        for (ObjectList<StaticEntity>::iterator it = list.begin(); it!= list.end(); ++it)
+        {
+
+            if (dynamic_cast<RaceCheckPoint*>(*it) != nullptr)
             {
                 continue;
@@ -537,10 +539,10 @@
         //                    btVector3 positionObject;
         //                    btScalar radiusObject;
-        //                    if((*it)==NULL)
+        //                    if((*it)==nullptr)
         //                    {   orxout()<<"Problempoint 1.1"<<endl; continue;}
         //                    //TODO: Probably it points on a wrong object
-        //                    for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
+        //                    for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=nullptr; everyShape++)
         //                    {
-        //                        if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==NULL)
+        //                        if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==nullptr)
         //                        {    continue;}
         //
@@ -570,9 +572,9 @@
         //                        btVector3 positionObject;
         //                        btScalar radiusObject;
-        //                        if((*it)==NULL)
+        //                        if((*it)==nullptr)
         //                        {   orxout()<<"Problempoint 1"<<endl; continue;}
-        //                        for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
+        //                        for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=nullptr; everyShape++)
         //                        {
-        //                            if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==NULL)
+        //                            if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==nullptr)
         //                            {   orxout()<<"Problempoint 2.2"<<endl; continue;}
         //                            (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()->getBoundingSphere(positionObject,radiusObject);
Index: code/trunk/src/modules/gametypes/SpaceRaceController.h
===================================================================
--- code/trunk/src/modules/gametypes/SpaceRaceController.h	(revision 10624)
+++ code/trunk/src/modules/gametypes/SpaceRaceController.h	(revision 11071)
@@ -42,6 +42,6 @@
             SpaceRaceController(Context* context);
             virtual ~SpaceRaceController();
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            virtual void tick(float dt);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+            virtual void tick(float dt) override;
 
         private:
Index: code/trunk/src/modules/gametypes/SpaceRaceManager.cc
===================================================================
--- code/trunk/src/modules/gametypes/SpaceRaceManager.cc	(revision 10624)
+++ code/trunk/src/modules/gametypes/SpaceRaceManager.cc	(revision 11071)
@@ -54,6 +54,6 @@
     SpaceRaceManager::~SpaceRaceManager()
     {
-        for (size_t i = 0; i < this->checkpoints_.size(); ++i)
-        this->checkpoints_[i]->destroy();
+        for (RaceCheckPoint* checkpoint : this->checkpoints_)
+        checkpoint->destroy();
     }
 
@@ -71,5 +71,5 @@
         this->players_ = this->race_->getPlayers();
 
-        if (this->checkpoints_[0] != NULL && !this->firstcheckpointvisible_)
+        if (this->checkpoints_[0] != nullptr && !this->firstcheckpointvisible_)
         {
             this->checkpoints_[0]->setRadarVisibility(true);
@@ -77,11 +77,11 @@
         }
 
-        for ( std::map< PlayerInfo*, Player>::iterator it = players_.begin(); it != players_.end(); ++it)
+        for (const auto& mapEntry : players_)
         {
 
-            for (size_t i = 0; i < this->checkpoints_.size(); ++i)
+            for (RaceCheckPoint* checkpoint : this->checkpoints_)
             {
-                if (this->checkpoints_[i]->playerWasHere(it->first)){
-                this->checkpointReached(this->checkpoints_[i], it->first /*this->checkpoints_[i]->getPlayer()*/);
+                if (checkpoint->playerWasHere(mapEntry.first)){
+                this->checkpointReached(checkpoint, mapEntry.first /*this->checkpoints_[i]->getPlayer()*/);
                 }
             }
@@ -100,5 +100,5 @@
         return this->checkpoints_[index];
         else
-        return 0;
+        return nullptr;
     }
 
@@ -113,18 +113,18 @@
     RaceCheckPoint* SpaceRaceManager::findCheckpoint(int index) const
     {
-        for (size_t i = 0; i < this->checkpoints_.size(); ++i)
-        if (this->checkpoints_[i]->getCheckpointIndex() == index)
-        return this->checkpoints_[i];
-        return 0;
+        for (RaceCheckPoint* checkpoint : this->checkpoints_)
+        if (checkpoint->getCheckpointIndex() == index)
+        return checkpoint;
+        return nullptr;
     }
 
     bool SpaceRaceManager::reachedValidCheckpoint(RaceCheckPoint* oldCheckpoint, RaceCheckPoint* newCheckpoint, PlayerInfo* player) const
     {
-        if (oldCheckpoint != NULL)
+        if (oldCheckpoint != nullptr)
         {
             // the player already visited an old checkpoint; see which checkpoints are possible now
             const std::set<int>& possibleCheckpoints = oldCheckpoint->getNextCheckpoints();
-            for (std::set<int>::const_iterator it = possibleCheckpoints.begin(); it != possibleCheckpoints.end(); ++it)
-            if (this->findCheckpoint(*it) == newCheckpoint)
+            for (int possibleCheckpoint : possibleCheckpoints)
+            if (this->findCheckpoint(possibleCheckpoint) == newCheckpoint)
             return true;
             return false;
@@ -179,6 +179,6 @@
         {
             const std::set<int>& oldVisible = oldCheckpoint->getNextCheckpoints();
-            for (std::set<int>::const_iterator it = oldVisible.begin(); it != oldVisible.end(); ++it)
-            this->findCheckpoint(*it)->setRadarVisibility(false);
+            for (int checkpointIndex : oldVisible)
+            this->findCheckpoint(checkpointIndex)->setRadarVisibility(false);
         }
 
@@ -188,6 +188,6 @@
 
             const std::set<int>& newVisible = newCheckpoint->getNextCheckpoints();
-            for (std::set<int>::const_iterator it = newVisible.begin(); it != newVisible.end(); ++it)
-            this->findCheckpoint(*it)->setRadarVisibility(true);
+            for (int checkpointIndex : newVisible)
+            this->findCheckpoint(checkpointIndex)->setRadarVisibility(true);
         }
     }
Index: code/trunk/src/modules/gametypes/SpaceRaceManager.h
===================================================================
--- code/trunk/src/modules/gametypes/SpaceRaceManager.h	(revision 10624)
+++ code/trunk/src/modules/gametypes/SpaceRaceManager.h	(revision 11071)
@@ -58,5 +58,5 @@
             virtual ~SpaceRaceManager() ;
 
-            void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 
             void addCheckpoint(RaceCheckPoint* checkpoint);
@@ -69,5 +69,5 @@
             std::vector<RaceCheckPoint*> getAllCheckpoints();
 
-            void tick(float dt);
+            virtual void tick(float dt) override;
 
         protected:
