Changeset 11071 for code/trunk/src/orxonox

code/trunk

Property svn:mergeinfo changed

/code/branches/cpp11 (added)	merged: 10439-10441,10443,10545
/code/branches/cpp11_v2	merged: 10732-10734,10736,10742,10744-10745,10765,10768-10778,10781,10813,10817-10818,10821-10822,10825,10828-10830,10845-10846,10852-10853,10857,10865,10876,10916-10920,10922,10975-10994,10996-11008,11010
/code/branches/cpp11_v3 (added)	merged: 11053-11054,11057-11070

code/trunk/src/orxonox/CameraManager.cc

-                      r10624
+                      r11071
             return this->cameraList_.front();
         else
             return 0;
+            return nullptr;
+    }
 …
                 this->cameraList_.front()->setFocus();
             else
                 this->useCamera(NULL);
+                this->useCamera(nullptr);
+        }
         else

code/trunk/src/orxonox/CameraManager.h

-                      r9667
+                      r11071
         private:
+            CameraManager(const CameraManager&); // don't use
+            // non-copyable:
+            CameraManager(const CameraManager&) = delete;
+            CameraManager& operator=(const CameraManager&) = delete;
             std::list<Camera*>    cameraList_;

code/trunk/src/orxonox/Level.cc

r10624	r11071
30	30
31	31	#include "util/Math.h"
	32	#include "util/SubString.h"
32	33	#include "core/CoreIncludes.h"
33	34	#include "core/Loader.h"
…	…
54	55	this->registerVariables();
55	56	this->xmlfilename_ = this->getFilename();
56		this->xmlfile_ = 0;
	57	this->xmlfile_ = nullptr;
57	58	}
58	59
…	…
105	106	void Level::networkCallbackTemplatesChanged()
106	107	{
107		for( ~~std::set<std::string>::iterator it = this->networkTemplateNames_.begin(); it!=this->networkTemplateNames_.end(); ++it~~ )
108		{
109		assert(Template::getTemplate(*it));
110		Template::getTemplate(*it)->applyOn(this);
	108	for(const std::string& name : this->networkTemplateNames_)
	109	{
	110	assert(Template::getTemplate(name));
	111	Template::getTemplate(name)->applyOn(this);
111	112	}
112	113	}
…	…
134	135	// objects alive when ~Level is called. This is the reason why we cannot directly destroy() the Plugins - instead we need
135	136	// to call destroyLater() to ensure that no instances from this plugin exist anymore.
136		for (~~std::list<PluginReference*>::iterator it = this->plugins_.begin(); it != this->plugins_.end(); ++it~~)
137		~~(*it)~~->destroyLater();
	137	for (PluginReference* plugin : this->plugins_)
	138	plugin->destroyLater();
138	139	this->plugins_.clear();
139	140	}
…	…
172	173	{
173	174	unsigned int i = 0;
174		for (~~std::list<BaseObject*>::const_iterator it = this->objects_.begin(); it != this->objects_.end(); ++it~~)
	175	for (BaseObject* object : this->objects_)
175	176	{
176	177	if (i == index)
177		return ~~(*it)~~;
	178	return object;
178	179	++i;
179	180	}
180		return 0;
	181	return nullptr;
181	182	}
182	183
…	…
195	196	return this->lodInformation_.find(meshName)->second;
196	197
197		return 0;
	198	return nullptr;
198	199	}
199	200
…	…
207	208	{
208	209	orxout(internal_info) << "player left level (id: " << player->getClientID() << ", name: " << player->getName() << ')' << endl;
209		player->switchGametype(0);
	210	player->switchGametype(nullptr);
210	211	}
211	212	}

code/trunk/src/orxonox/Level.h

-                      r10624
+                      r11071
 #include "core/BaseObject.h"
 #include "network/synchronisable/Synchronisable.h"
+#include "core/object/Context.h"
 #include "graphics/MeshLodInformation.h"
 …
             virtual ~Level();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void playerEntered(PlayerInfo* player);

code/trunk/src/orxonox/LevelInfo.cc

-                      r9667
+                      r11071
+    {
         SubString substr = SubString(tags, ",", " "); // Split the string into tags.
         const std::vector<std::string>& strings = substr.getAllStrings();
         for (std::vector<std::string>::const_iterator it = strings.begin(); it != strings.end(); it++)
             this->addTag(*it, false);
+        const std::vector<std::string>& tokens = substr.getAllStrings();
+        for (const std::string& token : tokens)
+            this->addTag(token, false);
         this->tagsUpdated();
 …
+    {
         SubString substr = SubString(ships, ",", " "); // Split the string into tags.
         const std::vector<std::string>& strings = substr.getAllStrings();
         for(std::vector<std::string>::const_iterator it = strings.begin(); it != strings.end(); it++)
             this->addStartingShip(*it, false);
+        const std::vector<std::string>& tokens = substr.getAllStrings();
+        for(const std::string& token : tokens)
+            this->addStartingShip(token, false);
         this->startingshipsUpdated();

code/trunk/src/orxonox/LevelInfo.h

r9667	r11071
207	207	virtual ~LevelInfo();
208	208
209		virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Creates a LevelInfo object through XML.
	209	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override; //!< Creates a LevelInfo object through XML.
210	210
211	211	/**

code/trunk/src/orxonox/LevelManager.cc

-                      r11020
+                      r11071
+    {
         // Delete all the LevelInfoItem objects because the LevelManager created them
+        std::set<LevelInfoItem*, LevelInfoCompare>::iterator it = availableLevels_.begin();
+        for (; it != availableLevels_.end(); ++it)
+            (*it)->destroy();
+        for (LevelInfoItem* info : availableLevels_)
+            info->destroy();
+    }
 …
         Get the currently active Level.
     @return
         Returns a pointer to the currently active level or NULL if there currently are no active Levels.
+        Returns a pointer to the currently active level or nullptr if there currently are no active Levels.
     */
     Level* LevelManager::getActiveLevel()
 …
             return this->levels_.front();
         else
             return 0;
+            return nullptr;
+    }
 …
             this->levels_.front()->setActive(true);
             // Make every player enter the newly activated level.
             for (std::map<unsigned int, PlayerInfo*>::const_iterator it = PlayerManager::getInstance().getClients().begin(); it != PlayerManager::getInstance().getClients().end(); ++it)
                 this->levels_.front()->playerEntered(it->second);
+            for (const auto& mapEntry : PlayerManager::getInstance().getClients())
+                this->levels_.front()->playerEntered(mapEntry.second);
+        }
+    }
 …
+    {
         if(index >= this->availableLevels_.size())
             return NULL;
+            return nullptr;
         // If this index directly follows the last we can optimize a lot.
 …
             if (it->find("old/") != 0)
+            {
                 LevelInfoItem* info = NULL;
+                LevelInfoItem* info = nullptr;
                 // Load the LevelInfo object from the level file.
 …
                 // Find the LevelInfo object we've just loaded (if there was one)
                 for(ObjectList<LevelInfo>::iterator item = ObjectList<LevelInfo>::begin(); item != ObjectList<LevelInfo>::end(); ++item)
                     if(item->getXMLFilename() == *it)
                         info = item->copy();
+                for(LevelInfo* levelInfo : ObjectList<LevelInfo>())
+                    if(levelInfo->getXMLFilename() == *it)
+                        info = levelInfo->copy();
                 // We don't need the loaded stuff anymore
                 Loader::getInstance().unload(&file);
                 if(info == NULL)
+                if(info == nullptr)
+                {
                     // Create a default LevelInfoItem object that merely contains the name

code/trunk/src/orxonox/LevelManager.h

-                      r10258
+                      r11071
         private:
+            LevelManager(const LevelManager&);
+            // non-copyable:
+            LevelManager(const LevelManager&) = delete;
+            LevelManager& operator=(const LevelManager&) = delete;
             void activateNextLevel(); //!< Activate the next level.

code/trunk/src/orxonox/Main.h

r5693	r11071
33	33	#include "OrxonoxPrereqs.h"
34	34
	35	#include <string>
	36
35	37	namespace orxonox
36	38	{

code/trunk/src/orxonox/MoodManager.cc

r10624	r11071
103	103	/static/ void MoodListener::changedMood(const std::string& mood)
104	104	{
105		for (~~ObjectList<MoodListener>::iterator it = ObjectList<MoodListener>::begin(); it; ++it~~)
106		it->moodChanged(mood);
	105	for (MoodListener* listener : ObjectList<MoodListener>())
	106	listener->moodChanged(mood);
107	107	}
108	108	}

code/trunk/src/orxonox/PlayerManager.cc

r10624	r11071
62	62
63	63	// create new HumanPlayer instance
64		HumanPlayer* player = new HumanPlayer(0);
	64	HumanPlayer* player = new HumanPlayer(nullptr);
65	65	player->setClientID(clientID);
66	66
…	…
111	111	else
112	112	{
113		for (~~ObjectList<PlayerInfo>::iterator it = ObjectList<PlayerInfo>::begin(); it != ObjectList<PlayerInfo>::end(); ++it~~)
114		if (it->getClientID() == clientID)
115		return ~~(*it)~~;
	113	for (PlayerInfo* info : ObjectList<PlayerInfo>())
	114	if (info->getClientID() == clientID)
	115	return info;
116	116	}
117		return 0;
	117	return nullptr;
118	118	}
119	119	}

code/trunk/src/orxonox/PlayerManager.h

-                      r5966
+                      r11071
                 { return this->clients_; }
             void clientConnected(unsigned int clientID);
             void clientDisconnected(unsigned int clientID);
+            virtual void clientConnected(unsigned int clientID) override;
+            virtual void clientDisconnected(unsigned int clientID) override;
             void disconnectAllClients();

code/trunk/src/orxonox/Radar.cc

-                      r10624
+                      r11071
     Radar::Radar()
         : itFocus_(0)
         , focus_(0)
+        : itFocus_(nullptr)
+        , focus_(nullptr)
         , objectTypeCounter_(0)
+    {
         // TODO: make this mapping configurable. Maybe there's a possibility with self configured
         //       configValues..
         this->objectTypes_["Asteroid"] = RadarViewable::Dot;
         this->objectTypes_["SpaceShip"] = RadarViewable::Square;
         this->objectTypes_["AsdfQwerty"] = RadarViewable::Triangle;
+        this->objectTypes_["Asteroid"] = RadarViewable::Shape::Dot;
+        this->objectTypes_["SpaceShip"] = RadarViewable::Shape::Square;
+        this->objectTypes_["AsdfQwerty"] = RadarViewable::Shape::Triangle;
         /*WorldEntity* object;
 …
         this->radarObjects_.insert(rv);
         // iterate through all radarlisteners and notify them
         for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        {
             (*itListener)->addObject(rv);
+        for (RadarListener* listener : ObjectList<RadarListener>())
+        {
+            listener->addObject(rv);
+        }
+    }
 …
         this->radarObjects_.erase(rv);
         // iterate through all radarlisteners and notify them
         for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        {
             (*itListener)->removeObject(rv);
+        for (RadarListener* listener : ObjectList<RadarListener>())
+        {
+            listener->removeObject(rv);
+        }
+    }
 …
             return *(this->itFocus_);
         else
             return 0;
+            return nullptr;
+    }
 …
         std::map<std::string, RadarViewable::Shape>::iterator it = this->objectTypes_.find(name);
         if (it == this->objectTypes_.end())
             return this->objectTypes_[name] = RadarViewable::Square; // default, configure!!
+            return this->objectTypes_[name] = RadarViewable::Shape::Square; // default, configure!!
         else
             return this->objectTypes_[name];
 …
+        {
             // focus object was deleted, release focus
             this->focus_ = 0;
             this->itFocus_ = 0;
+        }
         for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        {
             (*itListener)->radarTick(dt);
+            this->focus_ = nullptr;
+            this->itFocus_ = nullptr;
+        }
+        for (RadarListener* listener : ObjectList<RadarListener>())
+        {
+            listener->radarTick(dt);
+        }
+    }
 …
     void Radar::cycleFocus()
+    {
+        if (ObjectList<RadarViewable>::begin() == ObjectList<RadarViewable>::end())
+        ObjectList<RadarViewable> listRadarViewable;
+        if (listRadarViewable.size() == 0)
+        {
             // list is empty
             this->itFocus_ = 0;
             this->focus_ = 0;
+            this->itFocus_ = nullptr;
+            this->focus_ = nullptr;
+        }
 …
             float nextDistance = FLT_MAX;
             float minimumDistance = FLT_MAX;
             ObjectList<RadarViewable>::iterator itFallback = 0;
             for (ObjectList<RadarViewable>::iterator it = ObjectList<RadarViewable>::begin(); it; ++it)
+            ObjectList<RadarViewable>::iterator itFallback = nullptr;
+            for (ObjectList<RadarViewable>::iterator it = listRadarViewable.begin(); it; ++it)
+            {
                 if (*it == static_cast<RadarViewable*>(HumanController::getLocalControllerEntityAsPawn()))
 …
     void Radar::releaseFocus()
+    {
         this->itFocus_ = 0;
         this->focus_ = 0;
+        this->itFocus_ = nullptr;
+        this->focus_ = nullptr;
+    }
 …
         // iterate through all Radar Objects
         unsigned int i = 0;
+        for (ObjectList<RadarViewable>::iterator it = ObjectList<RadarViewable>::begin(); it; ++it, ++i)
+        {
+            orxout(debug_output) << i++ << ": " << (*it)->getRVWorldPosition() << endl;
+        for (RadarViewable* viewable : ObjectList<RadarViewable>())
+        {
+            orxout(debug_output) << i++ << ": " << viewable->getRVWorldPosition() << endl;
+            ++i;
+        }
+    }
 …
     void Radar::radarObjectChanged(RadarViewable* rv)
+    {
         for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        {
           (*itListener)->objectChanged(rv);
+        for (RadarListener* listener : ObjectList<RadarListener>())
+        {
+            listener->objectChanged(rv);
+        }
+    }

code/trunk/src/orxonox/Radar.h

r9667	r11071
54	54	virtual ~Radar();
55	55
56		virtual void tick(float dt);
	56	virtual void tick(float dt) override;
57	57
58	58	const RadarViewable* getFocus();

code/trunk/src/orxonox/Scene.cc

-                      r10727
+                      r11071
         this->bShadows_ = true;
         this->bDebugDrawPhysics_ = false;
         this->debugDrawer_ = NULL;
+        this->debugDrawer_ = nullptr;
         this->soundReferenceDistance_ = 20.0;
         this->bIsUpdatingPhysics_ = false;
 …
             this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
             this->radar_ = 0;
+            this->radar_ = nullptr;
+        }
 …
         this->positiveWorldRange_ = Vector3::UNIT_SCALE *  defaultMaxWorldSize;
         this->gravity_ = Vector3::ZERO;
         this->physicalWorld_   = 0;
         this->solver_          = 0;
         this->dispatcher_      = 0;
         this->collisionConfig_ = 0;
         this->broadphase_      = 0;
+        this->physicalWorld_   = nullptr;
+        this->solver_          = nullptr;
+        this->dispatcher_      = nullptr;
+        this->collisionConfig_ = nullptr;
+        this->broadphase_      = nullptr;
         this->registerVariables();
 …
+        {
             // Remove all WorldEntities and shove them to the queue since they would still like to be in a physical world.
+            for (std::set<WorldEntity*>::const_iterator it = this->physicalObjects_.begin();
+                it != this->physicalObjects_.end(); ++it)
+            for (WorldEntity* object : this->physicalObjects_)
+            {
                 this->physicalWorld_->removeRigidBody((*it)->physicalBody_);
                 this->physicalObjectQueue_.insert(*it);
+                this->physicalWorld_->removeRigidBody(object->physicalBody_);
+                this->physicalObjectQueue_.insert(object);
+            }
             this->physicalObjects_.clear();
 …
             delete this->collisionConfig_;
             delete this->broadphase_;
             this->physicalWorld_   = 0;
             this->solver_          = 0;
             this->dispatcher_      = 0;
             this->collisionConfig_ = 0;
             this->broadphase_      = 0;
+            this->physicalWorld_   = nullptr;
+            this->solver_          = nullptr;
+            this->dispatcher_      = nullptr;
+            this->collisionConfig_ = nullptr;
+            this->broadphase_      = nullptr;
+        }
+    }
 …
+            {
                 // Add all scheduled WorldEntities
+                for (std::set<WorldEntity*>::const_iterator it = this->physicalObjectQueue_.begin();
+                    it != this->physicalObjectQueue_.end(); ++it)
+                for (WorldEntity* object : this->physicalObjectQueue_)
+                {
                     this->physicalWorld_->addRigidBody((*it)->physicalBody_);
                     this->physicalObjects_.insert(*it);
+                    this->physicalWorld_->addRigidBody(object->physicalBody_);
+                    this->physicalObjects_.insert(object);
+                }
                 this->physicalObjectQueue_.clear();
 …
+    {
         unsigned int i = 0;
         for (std::list<BaseObject*>::const_iterator it = this->objects_.begin(); it != this->objects_.end(); ++it)
+        for (BaseObject* object : this->objects_)
+        {
             if (i == index)
                 return (*it);
+                return object;
             ++i;
+        }
         return 0;
+        return nullptr;
+    }
 …
     /*static*/ void Scene::consoleCommand_debugDrawPhysics(bool bDraw, bool bFill, float fillAlpha)
+    {
         for (ObjectListIterator<Scene> it = ObjectList<Scene>::begin(); it != ObjectList<Scene>::end(); ++it)
             it->setDebugDrawPhysics(bDraw, bFill, fillAlpha);
+        for (Scene* scene : ObjectList<Scene>())
+            scene->setDebugDrawPhysics(bDraw, bFill, fillAlpha);
+    }
+}

code/trunk/src/orxonox/Scene.h

-                      r10624
+                      r11071
 #include "util/OgreForwardRefs.h"
 #include "core/BaseObject.h"
+#include "core/object/Context.h"
 #include "network/synchronisable/Synchronisable.h"
 #include "tools/interfaces/Tickable.h"
 …
             virtual ~Scene();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void registerVariables();
 …
                 { return this->radar_; }
             inline virtual uint32_t getSceneID() const { return this->getObjectID(); }
+            virtual inline uint32_t getSceneID() const override { return this->getObjectID(); }
             virtual void tick(float dt);
+            virtual void tick(float dt) override;
         private:
 …
         public:
             inline bool hasPhysics() const
                 { return this->physicalWorld_ != 0; }
+                { return this->physicalWorld_ != nullptr; }
             void setPhysicalWorld(bool wantsPhysics);

code/trunk/src/orxonox/Test.cc

-                      r10624
+                      r11071
     registerMemberNetworkFunction( Test, printBlaBla );
     Test* Test::instance_ = 0;
+    Test* Test::instance_ = nullptr;
     Test::Test(Context* context) : BaseObject(context), Synchronisable(context)
+    {
         assert(instance_==0);
+        assert(instance_==nullptr);
         instance_=this;
         RegisterObject ( Test );
 …
         registerVariables();
         setSyncMode(0x3);
         this->pointer_ = 0;
+        this->pointer_ = nullptr;
+    }
     Test::~Test()
+    {
         instance_=0;
+        instance_=nullptr;
+    }

code/trunk/src/orxonox/chat/ChatHistory.cc

-                      r10624
+                      r11071
 #include "core/singleton/ScopedSingletonIncludes.h"
 #include "core/ConfigurablePaths.h"
+#include "core/CoreIncludes.h"
 #ifndef CHATTEST
 …
   void ChatHistory::debug_printhist()
+  {
-    /* create deque iterator */
-    std::deque<std::string>::iterator it;
     /* output all the strings */
+    for( it = this->hist_buffer.begin(); it != this->hist_buffer.end();
+      ++it )
+      orxout(debug_output) << *it << endl;
+    for( const std::string& hist : this->hist_buffer )
+      orxout(debug_output) << hist << endl;
     /* output size */

code/trunk/src/orxonox/chat/ChatHistory.h

r10624	r11071
82	82	* \param senderID Identification number of the sender
83	83	*/
84		virtual void incomingChat(const std::string& message, const std::string& name);
	84	virtual void incomingChat(const std::string& message, const std::string& name) override;
85	85
86	86	/** Synchronize logfile onto the hard drive

code/trunk/src/orxonox/chat/ChatInputHandler.cc

r10624	r11071
79	79	this->inpbuf = new InputBuffer();
80	80	this->disp_offset = 0;
81		assert( this->inpbuf != ~~NULL~~ );
	81	assert( this->inpbuf != nullptr );
82	82
83	83	/* generate chatbox ui and chatbox-inputonly ui */

code/trunk/src/orxonox/chat/ChatInputHandler.h

r9675	r11071
125	125	* history window of the full chat window)
126	126	*/
127		v~~oid incomingChat(const std::string& message, const std::string& name)~~;
	127	virtual void incomingChat(const std::string& message, const std::string& name) override;
128	128
129	129	/** \param full true means show full chat window with history,

code/trunk/src/orxonox/chat/ChatManager.cc

-                      r10624
+                      r11071
         // notify all listeners
         for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
             it->incomingChat(text, name);
+        for (ChatListener* listener : ObjectList<ChatListener>())
+            listener->incomingChat(text, name);
+    }

code/trunk/src/orxonox/chat/ChatManager.h

-                      r8858
+                      r11071
         public:
             ChatManager();
             virtual ~ChatManager() {}
+            virtual ~ChatManager() = default;
             static void message(const std::string& message, unsigned int targetID = NETWORK_PEER_ID_BROADCAST);
 …
         protected:
+            ChatManager(const ChatManager&);
+            // non-copyable:
+            ChatManager(const ChatManager&) = delete;
+            ChatManager& operator=(const ChatManager&) = delete;
             virtual void incomingChat(const std::string& message, unsigned int sourceID);
+            virtual void incomingChat(const std::string& message, unsigned int sourceID) override;
             static ChatManager* singletonPtr_s;

code/trunk/src/orxonox/collisionshapes/CollisionShape.cc

-                      r10624
+                      r11071
         RegisterObject(CollisionShape);
         this->parent_ = 0;
+        this->parent_ = nullptr;
         this->parentID_ = OBJECTID_UNKNOWN;
         this->collisionShape_ = 0;
+        this->collisionShape_ = nullptr;
         this->position_ = Vector3::ZERO;
         this->orientation_ = Quaternion::IDENTITY;
 …
     void CollisionShape::notifyDetached()
+    {
         this->parent_ = 0;
+        this->parent_ = nullptr;
         this->parentID_ = OBJECTID_UNKNOWN;
+    }

code/trunk/src/orxonox/collisionshapes/CollisionShape.h

-                      r9667
+                      r11071
             virtual ~CollisionShape();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             /**
 …
             btCollisionShape*       collisionShape_; //!< The bullet collision shape of this CollisionShape.
             CompoundCollisionShape* parent_; //!< The CompoundCollisionShape this CollisionShape belongs to, NULL if it doesn't belong to one.
+            CompoundCollisionShape* parent_; //!< The CompoundCollisionShape this CollisionShape belongs to, nullptr if it doesn't belong to one.
             unsigned int            parentID_; //!< The objectID of the parent of this CollisionShape, which can either be a CompoundCollisionShape or a WorldEntity.

code/trunk/src/orxonox/collisionshapes/CompoundCollisionShape.cc

-                      r10624
+                      r11071
+        {
             // Delete all children
+            for (std::map<CollisionShape*, btCollisionShape*>::iterator it = this->attachedShapes_.begin();
+                it != this->attachedShapes_.end(); ++it)
+            for (const auto& mapEntry : this->attachedShapes_)
+            {
                 // make sure that the child doesn't want to detach itself --> speedup because of the missing update
                 it->first->notifyDetached();
                 it->first->destroy();
                 if (this->collisionShape_ == it->second)
                     this->collisionShape_ = NULL; // don't destroy it twice
+                mapEntry.first->notifyDetached();
+                mapEntry.first->destroy();
+                if (this->collisionShape_ == mapEntry.second)
+                    this->collisionShape_ = nullptr; // don't destroy it twice
+            }
             delete this->compoundShape_;
             if (this->collisionShape_ == this->compoundShape_)
                 this->collisionShape_ = NULL; // don't destroy it twice
+                this->collisionShape_ = nullptr; // don't destroy it twice
+        }
+    }
 …
     void CompoundCollisionShape::attach(CollisionShape* shape)
+    {
         // If either the input shape is NULL or we try to attach the CollisionShape to itself.
+        // If either the input shape is nullptr or we try to attach the CollisionShape to itself.
         if (!shape || static_cast<CollisionShape*>(this) == shape)
             return;
 …
     void CompoundCollisionShape::updatePublicShape()
+    {
         btCollisionShape* primitive = 0; // The primitive shape, if there is one.
+        btCollisionShape* primitive = nullptr; // The primitive shape, if there is one.
         bool bPrimitive = true; // Whether the CompoundCollisionShape has just one non-empty CollisionShape. And that shape also has no transformation.
         bool bEmpty = true; // Whether the CompoundCollisionShape is empty.
         // Iterate over all CollisionShapes that belong to this CompoundCollisionShape.
         for (std::map<CollisionShape*, btCollisionShape*>::const_iterator it = this->attachedShapes_.begin(); it != this->attachedShapes_.end(); ++it)
+        for (const auto& mapEntry : this->attachedShapes_)
+        {
             // TODO: Make sure this is correct.
             if (it->second)
+            if (mapEntry.second)
+            {
                 bEmpty = false;
                 if (!it->first->hasTransform() && bPrimitive)
                     primitive = it->second;
+                if (!mapEntry.first->hasTransform() && bPrimitive)
+                    primitive = mapEntry.second;
                 else
+                {
 …
+        {
             // If there was none all along, nothing needs to be changed.
             if (this->collisionShape_ == 0)
+            if (this->collisionShape_ == nullptr)
                 return;
             this->collisionShape_ = 0;
+            this->collisionShape_ = nullptr;
+        }
         // If the CompoundCollisionShape is just a primitive.
 …
+    {
         unsigned int i = 0;
         for (std::map<CollisionShape*, btCollisionShape*>::const_iterator it = this->attachedShapes_.begin(); it != this->attachedShapes_.end(); ++it)
+        for (const auto& mapEntry : this->attachedShapes_)
+        {
             if (i == index)
                 return it->first;
+                return mapEntry.first;
             ++i;
+        }
         return 0;
+        return nullptr;
+    }
 …
         std::vector<CollisionShape*> shapes;
         // Iterate through all attached CollisionShapes and add them to the list of shapes.
         for(std::map<CollisionShape*, btCollisionShape*>::iterator it = this->attachedShapes_.begin(); it != this->attachedShapes_.end(); it++)
             shapes.push_back(it->first);
+        for(const auto& mapEntry : this->attachedShapes_)
+            shapes.push_back(mapEntry.first);
         // Delete the compound shape and create a new one.
 …
         // Re-attach all CollisionShapes.
+        for(std::vector<CollisionShape*>::iterator it = shapes.begin(); it != shapes.end(); it++)
+        {
+            CollisionShape* shape = *it;
+        for(CollisionShape* shape : shapes)
+        {
             shape->setScale3D(this->getScale3D());
             // Only actually attach if we didn't pick a CompoundCollisionShape with no content.

code/trunk/src/orxonox/collisionshapes/CompoundCollisionShape.h

-                      r9667
+                      r11071
             virtual ~CompoundCollisionShape();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void attach(CollisionShape* shape);
 …
             void updateAttachedShape(CollisionShape* shape);
             virtual void changedScale();
+            virtual void changedScale() override;
         private:
             void updatePublicShape();
             inline virtual btCollisionShape* createNewShape() const
                 { assert(false); return 0; }
+            virtual inline btCollisionShape* createNewShape() const override
+                { assert(false); return nullptr; }
             btCompoundShape* compoundShape_;

code/trunk/src/orxonox/collisionshapes/WorldEntityCollisionShape.cc

-                      r10624
+                      r11071
         RegisterObject(WorldEntityCollisionShape);
         this->worldEntityOwner_ = NULL;
+        this->worldEntityOwner_ = nullptr;
         // suppress synchronisation
         this->setSyncMode(ObjectDirection::None);
 …
         CollisionShape::updateParent();
         assert(this->worldEntityOwner_ != 0);
+        assert(this->worldEntityOwner_ != nullptr);
         this->worldEntityOwner_->notifyCollisionShapeChanged();
+    }

code/trunk/src/orxonox/collisionshapes/WorldEntityCollisionShape.h

-                      r10624
+                      r11071
         protected:
             virtual void updateParent();
+            virtual void updateParent() override;
         private:
             void parentChanged();
+            virtual void parentChanged() override;
             WorldEntity* worldEntityOwner_;

code/trunk/src/orxonox/controllers/AIController.cc

r9667	r11071
249	249	}
250	250	else
251		this->setPreviousMode();//If bot dies -> getControllableEntity == ~~NULL~~ -> get out of ROCKET mode
	251	this->setPreviousMode();//If bot dies -> getControllableEntity == nullptr -> get out of ROCKET mode
252	252	}//END_OF ROCKET MODE
253	253

code/trunk/src/orxonox/controllers/AIController.h

r9667	r11071
44	44	virtual ~AIController();
45	45
46		virtual void tick(float dt); //<! Carrying out the targets set in action().
	46	virtual void tick(float dt) override; //<! Carrying out the targets set in action().
47	47
48	48	protected:

code/trunk/src/orxonox/controllers/ActionpointController.cc

r11052	r11071
339	339	inLoop = this->bInLoop_;
340	340
341		Action~~::Value~~ value;
	341	Action value;
342	342
343	343	if ( actionName == "FIGHT" )
…	…
371	371	return this->actionpoints_[index];
372	372	else
373		return 0;
	373	return nullptr;
374	374	}
375	375	//XML method
376		Action~~::Value~~ ActionpointController::getAction ()
	376	Action ActionpointController::getAction ()
377	377	{
378	378	return this->action_;
…	…
401	401	}
402	402	//XML method
403		void ActionpointController::setAction (Action~~::Value~~ action)
	403	void ActionpointController::setAction (Action action)
404	404	{
405	405	this->action_ = action;
406	406	}
407	407	//set action and target/protect
408		void ActionpointController::setAction (Action~~::Value~~ action, ControllableEntity* target)
	408	void ActionpointController::setAction (Action action, ControllableEntity* target)
409	409	{
410	410	if (!this \|\| !this->getControllableEntity())
…	…
423	423	}
424	424	//set action and target position
425		void ActionpointController::setAction (Action~~::Value~~ action, const Vector3& target)
	425	void ActionpointController::setAction (Action action, const Vector3& target)
426	426	{
427	427	if (!this \|\| !this->getControllableEntity())
…	…
434	434	}
435	435	//set action and target position and orientation
436		void ActionpointController::setAction (Action~~::Value~~ action, const Vector3& target, const Quaternion& orient )
	436	void ActionpointController::setAction (Action action, const Vector3& target, const Quaternion& orient )
437	437	{
438	438	if (!this \|\| !this->getControllableEntity())
…	…
476	476	return;
477	477
478		this->setTarget(0);
	478	this->setTarget(nullptr);
479	479	this->setTargetPosition(this->getControllableEntity()->getWorldPosition());
480	480	this->action_ = Action::NONE;
…	…
506	506	if (targetName == "")
507	507	break;
508		for (~~ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP~~)
509		{
510		if (!this \|\| !this->getControllableEntity())
511		return;
512		if (CommonController::getName(*itP) == targetName)
	508	for (Pawn* pawn : ObjectList<Pawn>())
	509	{
	510	if (!this \|\| !this->getControllableEntity())
	511	return;
	512	if (CommonController::getName(pawn) == targetName)
513	513	{
514		this->setTarget (static_cast<ControllableEntity>(itP));
	514	this->setTarget (static_cast<ControllableEntity*>(pawn));
515	515	}
516	516	}
…	…
541	541	if (protectName == "reservedKeyword:human")
542	542	{
543		for (~~ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP~~)
	543	for (Pawn* pawn : ObjectList<Pawn>())
544	544	{
545		if (orxonox_cast<ControllableEntity>(itP) && ((itP)->getController()) && ((itP)->getController()->getIdentifier()->getName() == "NewHumanController"))
	545	if (orxonox_cast<ControllableEntity*>(pawn) && (pawn->getController()) && (pawn->getController()->getIdentifier()->getName() == "NewHumanController"))
546	546	{
547		this->setProtect (static_cast<ControllableEntity>(itP));
	547	this->setProtect (static_cast<ControllableEntity*>(pawn));
548	548	}
549	549	}
…	…
551	551	else
552	552	{
553		for (~~ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP~~)
	553	for (Pawn* pawn : ObjectList<Pawn>())
554	554	{
555		if (CommonController::getName(*itP) == protectName)
	555	if (CommonController::getName(pawn) == protectName)
556	556	{
557		this->setProtect (static_cast<ControllableEntity>(itP));
	557	this->setProtect (static_cast<ControllableEntity*>(pawn));
558	558	}
559	559	}
…	…
578	578	std::string targetName = p.name;
579	579
580		for (~~ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP~~)
581		{
582		if (CommonController::getName(*itP) == targetName)
	580	for (Pawn* pawn : ObjectList<Pawn>())
	581	{
	582	if (CommonController::getName(pawn) == targetName)
583	583	{
584	584	if (!this \|\| !this->getControllableEntity())
585	585	return;
586		this->setTarget (static_cast<ControllableEntity>(itP));
	586	this->setTarget (static_cast<ControllableEntity*>(pawn));
587	587	}
588	588	}
…	…
702	702	{
703	703	if (!this \|\| !this->getControllableEntity())
704		return 0;
705
706		Pawn* closestTarget = 0;
	704	return nullptr;
	705
	706	Pawn* closestTarget = nullptr;
707	707	float minDistance = std::numeric_limits<float>::infinity();
708	708	Gametype* gt = this->getGametype();
709		for (~~ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP~~)
	709	for (Pawn* pawn : ObjectList<Pawn>())
710	710	{
711	711	if (!this \|\| !this->getControllableEntity())
712		return 0;
713		if ( CommonController::sameTeam (this->getControllableEntity(), static_cast<ControllableEntity>(itP), gt) )
	712	return nullptr;
	713	if ( CommonController::sameTeam (this->getControllableEntity(), static_cast<ControllableEntity*>(pawn), gt) )
714	714	continue;
715	715
716		float distance = CommonController::distance (*itP, this->getControllableEntity());
	716	float distance = CommonController::distance (pawn, this->getControllableEntity());
717	717	if (distance < minDistance)
718	718	{
719		closestTarget = *itP;
	719	closestTarget = pawn;
720	720	minDistance = distance;
721	721	}
…	…
725	725	return closestTarget;
726	726	}
727		return 0;
	727	return nullptr;
728	728	}
729	729	//push action FIGHT to the stack and set target to the closest enemy

code/trunk/src/orxonox/controllers/ActionpointController.h

-                      r11052
+                      r11071
         All the demos are in a file called AITest.oxw. In the menu look for New AI Testing Level.
     */
     namespace Action
+    enum class Action
+    {
+        enum Value
+        {
+            NONE, FLY, FIGHT, PROTECT, FIGHTALL, ATTACK
+        };
+    }
+        NONE, FLY, FIGHT, PROTECT, FIGHTALL, ATTACK
+    };
     struct Point {
         Action::Value action;
+        Action action;
         std::string name;
         Vector3 position;
         bool inLoop;
+    } ;
+    namespace PickupType
+    {
+        enum Value
+        {
+            NONE, DAMAGE, HEALTH, SPEED, PORTAL
+        };
+    }
+    };
     class _OrxonoxExport ActionpointController : public FightingController, public Tickable
 …
             ActionpointController(Context* context);
             virtual ~ActionpointController();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             /**
 …
                 In tick ship flies and fires.
             */
             virtual void tick(float dt);
+            virtual void tick(float dt) override;
             /**
             @brief
 …
             virtual void takeActionpoints (const std::vector<Point>& vector, const std::vector<Point>& loop, bool b);
             virtual Action::Value getAction ();
+            virtual Action getAction ();
             virtual std::string getActionName();
             void setAction (Action::Value action);
             void setAction (Action::Value action, ControllableEntity* target);
             void setAction (Action::Value action, const Vector3& target);
             void setAction (Action::Value action, const Vector3& target,  const Quaternion& orient );
+            void setAction (Action action);
+            void setAction (Action action, ControllableEntity* target);
+            void setAction (Action action, const Vector3& target);
+            void setAction (Action action, const Vector3& target,  const Quaternion& orient );
             virtual bool setWingman(ActionpointController* wingman)
 …
                 WeakPtr<ActionpointController> myDivisionLeader_;
             //----[Actionpoint information]----
                 Action::Value action_;
+                Action action_;
                 std::string protectName_;
                 std::string targetName_;
                 std::vector<WeakPtr<WorldEntity> > actionpoints_;
+                std::vector<WeakPtr<WorldEntity>> actionpoints_;
                 float squaredaccuracy_;
                 std::vector<Point > parsedActionpoints_;//<! actionpoints as they are stored here after being parsed from XML
                 std::vector<Point > loopActionpoints_;  //<! actionpoints that are to be looped
+                std::vector<Point> parsedActionpoints_; //<! actionpoints as they are stored here after being parsed from XML
+                std::vector<Point> loopActionpoints_;   //<! actionpoints that are to be looped
                 bool bInLoop_;                          //<! variable for addActionpoint method
                 bool bLoop_;                            //<! is state machine looping?

code/trunk/src/orxonox/controllers/ArtificialController.cc

-                      r11052
+                      r11071
         this->currentWaypoint_ = 0;
         this->setAccuracy(5);
         this->defaultWaypoint_ = NULL;
+        this->defaultWaypoint_ = nullptr;
         this->mode_ = DEFAULT;//Vector-implementation: mode_.push_back(DEFAULT);
+    }
 …
+            {
                 this->weaponModes_.clear(); // reset previous weapon information
                 WeaponSlot* wSlot = 0;
+                WeaponSlot* wSlot = nullptr;
                 for(int l=0; (wSlot = pawn->getWeaponSlot(l)) ; l++)
+                {
                     WeaponMode* wMode = 0;
+                    WeaponMode* wMode = nullptr;
                     for(int i=0; (wMode = wSlot->getWeapon()->getWeaponmode(i)) ; i++)
+                    {
 …
     void ArtificialController::setAllBotLevel(float level)
+    {
         for (ObjectList<ArtificialController>::iterator it = ObjectList<ArtificialController>::begin(); it != ObjectList<ArtificialController>::end(); ++it)
             it->setBotLevel(level);
+        for (ArtificialController* controller : ObjectList<ArtificialController>())
+            controller->setBotLevel(level);
+    }
 …
+    {
         SpaceShip* ship = orxonox_cast<SpaceShip*>(this->getControllableEntity());
         if(ship == NULL) return;
+        if(ship == nullptr) return;
         if(ship->getBoostPower()*1.5f > ship->getInitialBoostPower() ) //upper limit ->boost
             this->getControllableEntity()->boost(true);
 …
     int ArtificialController::getFiremode(std::string name)
+    {
         for (std::map< std::string, int >::iterator it = this->weaponModes_.begin(); it != this->weaponModes_.end(); ++it)
+        {
             if (it->first == name)
                 return it->second;
+        for (const auto& mapEntry : this->weaponModes_)
+        {
+            if (mapEntry.first == name)
+                return mapEntry.second;
+        }
         return -1;
 …
             return this->waypoints_[index];
         else
             return 0;
+            return nullptr;
+    }
 …
     void ArtificialController::updatePointsOfInterest(std::string name, float searchDistance)
+    {
         WorldEntity* waypoint = NULL;
         for (ObjectList<WorldEntity>::iterator it = ObjectList<WorldEntity>::begin(); it != ObjectList<WorldEntity>::end(); ++it)
+        {
             if((*it)->getIdentifier() == ClassByString(name))
+        WorldEntity* waypoint = nullptr;
+        for (WorldEntity* we : ObjectList<WorldEntity>())
+        {
+            if(we->getIdentifier() == ClassByString(name))
+            {
                 ControllableEntity* controllable = this->getControllableEntity();
                 if(!controllable) continue;
                 float actualDistance = ( (*it)->getPosition() - controllable->getPosition() ).length();
+                float actualDistance = ( we->getPosition() - controllable->getPosition() ).length();
                 if(actualDistance > searchDistance || actualDistance < 5.0f) continue;
                     // TODO: PickupSpawner: adjust waypoint accuracy to PickupSpawner's triggerdistance
 …
                 else
+                {
                     waypoint = *it;
+                    waypoint = we;
                     break;
+                }

code/trunk/src/orxonox/controllers/ArtificialController.h

-                      r9667
+                      r11071
             virtual ~ArtificialController();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void abandonTarget(Pawn* target);
             virtual void changedControllableEntity();
+            virtual void changedControllableEntity() override;
             virtual void doFire();
 …
             //WAYPOINT DATA
             std::vector<WeakPtr<WorldEntity> > waypoints_;
+            std::vector<WeakPtr<WorldEntity>> waypoints_;
             size_t currentWaypoint_;
             float squaredaccuracy_;

code/trunk/src/orxonox/controllers/CommonController.cc

-                      r11052
+                      r11071
         int team2 = entity2->getTeam();
         Controller* controller = 0;
+        Controller* controller = nullptr;
         if (entity1->getController())
             controller = entity1->getController();
 …
+        }
         TeamBaseMatchBase* base = 0;
+        TeamBaseMatchBase* base = nullptr;
         base = orxonox_cast<TeamBaseMatchBase*>(entity1);
         if (base)
 …
+        }
         DroneController* droneController = 0;
+        DroneController* droneController = nullptr;
         droneController = orxonox_cast<DroneController*>(entity1->getController());
         if (droneController && static_cast<ControllableEntity*>(droneController->getOwner()) == entity2)

code/trunk/src/orxonox/controllers/Controller.cc

-                      r9797
+                      r11071
         RegisterObject(Controller);
         this->player_ = 0;
         this->controllableEntity_ = 0;
+        this->player_ = nullptr;
+        this->controllableEntity_ = nullptr;
         this->bGodMode_ = false;
         this->team_=-1;

code/trunk/src/orxonox/controllers/Controller.h

r9797	r11071
45	45	Controller(Context* context);
46	46	virtual ~Controller();
47		virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
	47	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
48	48	inline void setPlayer(PlayerInfo* player)
49	49	{ this->player_ = player; }

code/trunk/src/orxonox/controllers/ControllerDirector.cc

-                      r10622
+                      r11071
         // Initialize member variables
         this->player_ = NULL;
         this->entity_ = NULL;
         this->pTrigger_ = NULL;
+        this->player_ = nullptr;
+        this->entity_ = nullptr;
+        this->pTrigger_ = nullptr;
         this->context_ = context;
+    }
 …
+    {
         this->pTrigger_ = orxonox_cast<PlayerTrigger*>(trigger);
         this->player_ = NULL;
+        this->player_ = nullptr;
         orxout(verbose) << "Preparation to take Control!" << endl;
         // Check whether it is a player trigger and extract pawn from it
         if(this->pTrigger_ != NULL)
+        if(this->pTrigger_ != nullptr)
+        {
             // Get the object which triggered the event.
 …
             // Check if there actually was a player returned.
             if( this->player_ == NULL) return false;
+            if( this->player_ == nullptr) return false;
+        }
         else

code/trunk/src/orxonox/controllers/ControllerDirector.h

-                      r10622
+                      r11071
             virtual ~ControllerDirector() { }
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             bool party(bool bTriggered, BaseObject* trigger);
             virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode) override;
             inline void setScriptName(const std::string& name) { this->scriptname_ = name; }

code/trunk/src/orxonox/controllers/DivisionController.cc

-                      r11052
+                      r11071
         RegisterObject(DivisionController);
         this->setFormationMode(FormationMode::DIAMOND);
         this->target_ = 0;
         this->myFollower_ = 0;
         this->myWingman_ = 0;
+        this->target_ = nullptr;
+        this->myFollower_ = nullptr;
+        this->myWingman_ = nullptr;
+    }
     DivisionController::~DivisionController()
+    {
         for (size_t i = 0; i < this->actionpoints_.size(); ++i)
+        for (WorldEntity* actionpoint : this->actionpoints_)
+        {
             if(this->actionpoints_[i])
                 this->actionpoints_[i]->destroy();
+            if (actionpoint)
+                actionpoint->destroy();
+        }
         this->parsedActionpoints_.clear();
         this->actionpoints_.clear();
+    }
-    void DivisionController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
-        SUPER(DivisionController, XMLPort, xmlelement, mode);
+    }
-    void DivisionController::tick(float dt)
+    {
-        if (!this->isActive())
-            return;
-        SUPER(DivisionController, tick, dt);
+    }
     void DivisionController::action()
+    {

code/trunk/src/orxonox/controllers/DivisionController.h

-                      r11052
+                      r11071
             //----[/language demanded functions]----
-            //----[orxonox demanded functions]----
-                virtual void tick(float dt);
-                virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            //----[orxonox demanded functions]----
             //----[own functions]----
                 virtual bool setFollower(ActionpointController* newFollower);
                 virtual bool setWingman(ActionpointController* newWingman);
                 virtual bool hasWingman();
                 virtual bool hasFollower();
+                virtual bool setFollower(ActionpointController* newFollower) override;
+                virtual bool setWingman(ActionpointController* newWingman) override;
+                virtual bool hasWingman() override;
+                virtual bool hasFollower() override;
             //----[/own functions]----
             virtual void stayNearProtect();
+            virtual void stayNearProtect() override;
         protected:
             //----action must only be managed by this----
             virtual void action(); //<! action() is called in regular intervals managing the bot's behaviour.
+            virtual void action() override; //<! action() is called in regular intervals managing the bot's behaviour.
         private:

code/trunk/src/orxonox/controllers/DroneController.cc

-                      r9667
+                      r11071
         RegisterObject(DroneController);
         this->owner_ = 0;
         this->drone_ = 0;
+        this->owner_ = nullptr;
+        this->drone_ = nullptr;
         this->isShooting_ = false;
         this->setAccuracy(10);

code/trunk/src/orxonox/controllers/DroneController.h

r9667	r11071
53	53	virtual ~DroneController();
54	54
55		virtual void tick(float dt); //!< The controlling happens here. This method defines what the controller has to do each tick.
	55	virtual void tick(float dt) override; //!< The controlling happens here. This method defines what the controller has to do each tick.
56	56
57	57	void setOwner(Pawn* owner);

code/trunk/src/orxonox/controllers/FightingController.cc

-                      r11052
+                      r11071
  */
 #include "controllers/FightingController.h"
-#include "core/XMLPort.h"
 #include "util/Math.h"
 …
+    {
+    }
-    void FightingController::XMLPort( Element& xmlelement, XMLPort::Mode mode )
+    {
-        SUPER( FightingController, XMLPort, xmlelement, mode );
+    }
     void FightingController::lookAtTarget(float dt)
 …
+    {
         if (!this || !this->getControllableEntity())
             return 0;
         Pawn* closestTarget = 0;
+            return nullptr;
+        Pawn* closestTarget = nullptr;
         float minDistance =  std::numeric_limits<float>::infinity();
         Gametype* gt = this->getGametype();
         for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
+        {
             if ( CommonController::sameTeam (this->getControllableEntity(), static_cast<ControllableEntity*>(*itP), gt) )
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            if ( CommonController::sameTeam (this->getControllableEntity(), static_cast<ControllableEntity*>(pawn), gt) )
                 continue;
             float distance = CommonController::distance (*itP, this->getControllableEntity());
+            float distance = CommonController::distance (pawn, this->getControllableEntity());
             if (distance < minDistance)
+            {
                 closestTarget = *itP;
+                closestTarget = pawn;
                 minDistance = distance;
+            }
 …
            return closestTarget;
+        }
         return 0;
+        return nullptr;
+    }
     //I checked it out, rockets DO NOT cause any problems! this->getControllableEntity() is always a SpaceShip
 …
+            {
                 this->weaponModes_.clear(); // reset previous weapon information
                 WeaponSlot* wSlot = 0;
+                WeaponSlot* wSlot = nullptr;
                 for(int l=0; (wSlot = pawn->getWeaponSlot(l)) ; l++)
+                {
                     WeaponMode* wMode = 0;
+                    WeaponMode* wMode = nullptr;
                     for(int i=0; (wMode = wSlot->getWeapon()->getWeaponmode(i)) ; i++)
+                    {
 …
+    }
     int FightingController::getFiremode(std::string name)
+    {
         for (std::map< std::string, int >::iterator it = this->weaponModes_.begin(); it != this->weaponModes_.end(); ++it)
+        {
             if (it->first == name)
                 return it->second;
+    int FightingController::getFiremode(const std::string& name)
+    {
+        for (const auto& mapEntry : this->weaponModes_)
+        {
+            if (mapEntry.first == name)
+                return mapEntry.second;
+        }
         return -1;

code/trunk/src/orxonox/controllers/FightingController.h

-                      r11052
+                      r11071
             virtual ~FightingController();
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             float squaredDistanceToTarget() const;
             bool isLookingAtTarget(float angle) const;
 …
                                                                         //<! this and target_ plus or minus some amount in difference vector direction,
                                                                         //<! depending on whether it is better to close up or survive.
-            void dodgeTowards (Vector3& position);  //fly towards position and awoid being hit
             void doFire();  //<! choose weapon, set aim at target_ and fire
             WeakPtr<ControllableEntity> target_;
 …
             void setupWeapons(); //<! Defines which weapons are available for a bot. Is recalled whenever a bot was killed.
             bool bSetupWorked; //<! If false, setupWeapons() is called.
             int getFiremode(std::string name);
+            int getFiremode(const std::string& name);
     };

code/trunk/src/orxonox/controllers/FlyingController.cc

-                      r11052
+                      r11071
+    }
     void FlyingController::setFormationModeXML(std::string val)
+    void FlyingController::setFormationModeXML(const std::string& val)
+    {
         const std::string valUpper = getUppercase(val);
         FormationMode::Value value;
+        FormationMode value;
         if (valUpper == "WALL")
 …
             return;
         SpaceShip* ship = orxonox_cast<SpaceShip*>(this->getControllableEntity());
         if(ship == NULL) return;
+        if(ship == nullptr) return;
         if(ship->getBoostPower()*1.5f > ship->getInitialBoostPower()) //upper limit ->boost
+        {

code/trunk/src/orxonox/controllers/FlyingController.h

-                      r11052
+                      r11071
     //Formation mode for the divisions
     namespace FormationMode
+    enum class FormationMode
+    {
+        enum Value
+        {
+            FINGER4, DIAMOND, WALL
+        };
+    }
+        FINGER4, DIAMOND, WALL
+    };
     class _OrxonoxExport FlyingController : public CommonController
 …
             FlyingController(Context* context);
             virtual ~FlyingController();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void setSpread (int spread)                         //<! spread is a multiplier for formation flight, should be bigger than 100
 …
                 { return this->spread_; }
             void setFormationModeXML(std::string val);
+            void setFormationModeXML(const std::string& val);
             std::string getFormationModeXML() const;
             void setFormationMode(FormationMode::Value val)
+            void setFormationMode(FormationMode val)
                 { this->formationMode_ = val; }
             FormationMode::Value getFormationMode() const
+            FormationMode getFormationMode() const
                 { return this->formationMode_; }
             bool bCopyOrientation_;                             //<! set to true by default, MasterController sets it in its tick(),
 …
                                                                     //<! this stays in a certain position relative to leader
             FormationMode::Value formationMode_;
+            FormationMode formationMode_;
             float rotationProgress_;    //<! for slerping

code/trunk/src/orxonox/controllers/FormationController.cc

-                      r11052
+                      r11071
     RegisterClass(FormationController);
     static const unsigned int STANDARD_MAX_FORMATION_SIZE = 9;
     static const int RADIUS_TO_SEARCH_FOR_MASTERS = 5000;
     static const float FORMATION_LENGTH =  110;
     static const float FORMATION_WIDTH =  110;
     static const int FREEDOM_COUNT = 4; //seconds the slaves in a formation will be set free when master attacks an enemy
     static const float SPEED_MASTER = 0.6f;
     static const float ROTATEFACTOR_MASTER = 0.2f;
     static const float SPEED_FREE = 0.8f;
     static const float ROTATEFACTOR_FREE = 0.8f;
+    static constexpr unsigned int STANDARD_MAX_FORMATION_SIZE = 9;
+    static constexpr int RADIUS_TO_SEARCH_FOR_MASTERS = 5000;
+    static constexpr float FORMATION_LENGTH =  110;
+    static constexpr float FORMATION_WIDTH =  110;
+    static constexpr int FREEDOM_COUNT = 4; //seconds the slaves in a formation will be set free when master attacks an enemy
+    static constexpr float SPEED_MASTER = 0.6f;
+    static constexpr float ROTATEFACTOR_MASTER = 0.2f;
+    static constexpr float SPEED_FREE = 0.8f;
+    static constexpr float ROTATEFACTOR_FREE = 0.8f;
     FormationController::FormationController(Context* context) : Controller(context)
 …
         RegisterObject(FormationController);
         this->target_ = 0;
+        this->target_ = nullptr;
         this->formationFlight_ = false;
         this->passive_ = false;
         this->maxFormationSize_ = STANDARD_MAX_FORMATION_SIZE;
         this->myMaster_ = 0;
+        this->myMaster_ = nullptr;
         this->freedomCount_ = 0;
 …
             this->removeFromFormation();
             for (ObjectList<FormationController>::iterator it = ObjectList<FormationController>::begin(); it; ++it)
+            {
                 if (*it != this)
+            for (FormationController* controller : ObjectList<FormationController>())
+            {
+                if (controller != this)
+                {
                     if (it->myMaster_ == this)
+                    if (controller->myMaster_ == this)
+                    {
                         orxout(internal_error) << this << " is still master in " << (*it) << endl;
                         it->myMaster_ = 0;
+                        orxout(internal_error) << this << " is still master in " << controller << endl;
+                        controller->myMaster_ = nullptr;
+                    }
                     while (true)
+                    {
                         std::vector<FormationController*>::iterator it2 = std::find(it->slaves_.begin(), it->slaves_.end(), this);
                         if (it2 != it->slaves_.end())
+                        std::vector<FormationController*>::iterator it2 = std::find(controller->slaves_.begin(), controller->slaves_.end(), this);
+                        if (it2 != controller->slaves_.end())
+                        {
                             orxout(internal_error) << this << " is still slave in " << (*it) << endl;
                             it->slaves_.erase(it2);
+                            orxout(internal_error) << this << " is still slave in " << controller << endl;
+                            controller->slaves_.erase(it2);
+                        }
                         else
 …
     void FormationController::formationflight(const bool form)
+    {
         for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
             Controller* controller = 0;
             if (it->getController())
                 controller = it->getController();
             else if (it->getXMLController())
                 controller = it->getXMLController();
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            Controller* controller = nullptr;
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
             if (!controller)
 …
     void FormationController::masteraction(const int action)
+    {
         for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
             Controller* controller = 0;
             if (it->getController())
                 controller = it->getController();
             else if (it->getXMLController())
                 controller = it->getXMLController();
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            Controller* controller = nullptr;
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
             if (!controller)
 …
     void FormationController::passivebehaviour(const bool passive)
+    {
         for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
             Controller* controller = 0;
             if (it->getController())
                 controller = it->getController();
             else if (it->getXMLController())
                 controller = it->getXMLController();
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            Controller* controller = nullptr;
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
             if (!controller)
 …
     void FormationController::formationsize(const int size)
+    {
         for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
             Controller* controller = 0;
             if (it->getController())
                 controller = it->getController();
             else if (it->getXMLController())
                 controller = it->getXMLController();
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            Controller* controller = nullptr;
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
             if (!controller)
 …
+        }
         this->myMaster_ = 0;
+        this->myMaster_ = nullptr;
         this->state_ = FREE;
+    }
 …
         int teamSize = 0;
         //go through all pawns
         for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
 …
             if (!gt)
+            {
                 gt=it->getGametype();
+            }
             if (!FormationController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(*it),gt))
+                gt=pawn->getGametype();
+            }
+            if (!FormationController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(pawn),gt))
                 continue;
             //has it an FormationController?
             Controller* controller = 0;
             if (it->getController())
                 controller = it->getController();
             else if (it->getXMLController())
                 controller = it->getXMLController();
+            Controller* controller = nullptr;
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
             if (!controller)
 …
             //is pawn oneself?
             if (orxonox_cast<ControllableEntity*>(*it) == this->getControllableEntity())
+            if (orxonox_cast<ControllableEntity*>(pawn) == this->getControllableEntity())
                 continue;
 …
                 continue;
             float distance = (it->getPosition() - this->getControllableEntity()->getPosition()).length();
+            float distance = (pawn->getPosition() - this->getControllableEntity()->getPosition()).length();
             // is pawn in range?
 …
                 if(newMaster->slaves_.size() > this->maxFormationSize_) continue;
                 for(std::vector<FormationController*>::iterator itSlave = this->slaves_.begin(); itSlave != this->slaves_.end(); itSlave++)
+                for(FormationController* slave : this->slaves_)
+                {
                     (*itSlave)->myMaster_ = newMaster;
                     newMaster->slaves_.push_back(*itSlave);
+                    slave->myMaster_ = newMaster;
+                    newMaster->slaves_.push_back(slave);
+                }
                 this->slaves_.clear();
 …
+        {
             this->state_ = MASTER;
             this->myMaster_ = 0;
+            this->myMaster_ = nullptr;
+        }
+    }
 …
             int i = 1;
             for(std::vector<FormationController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
+            for(FormationController* slave : slaves_)
+            {
                 pos = Vector3::ZERO;
 …
                     dest+=FORMATION_LENGTH*(orient*WorldEntity::BACK);
+                }
                 (*it)->setTargetOrientation(orient);
                 (*it)->setTargetPosition(pos);
+                slave->setTargetOrientation(orient);
+                slave->setTargetPosition(pos);
                 left=!left;
+            }
 …
             newMaster->state_ = MASTER;
             newMaster->slaves_ = this->slaves_;
             newMaster->myMaster_ = 0;
             for(std::vector<FormationController*>::iterator it = newMaster->slaves_.begin(); it != newMaster->slaves_.end(); it++)
+            {
                 (*it)->myMaster_ = newMaster;
+            newMaster->myMaster_ = nullptr;
+            for(FormationController* slave : newMaster->slaves_)
+            {
+                slave->myMaster_ = newMaster;
+            }
+        }
 …
                 newMaster->state_ = MASTER;
                 newMaster->slaves_ = this->slaves_;
                 newMaster->myMaster_ = 0;
                 for(std::vector<FormationController*>::iterator it = newMaster->slaves_.begin(); it != newMaster->slaves_.end(); it++)
+                newMaster->myMaster_ = nullptr;
+                for(FormationController* slave : newMaster->slaves_)
+                {
                     (*it)->myMaster_ = newMaster;
+                    slave->myMaster_ = newMaster;
+                }
+            }
 …
         if(this->state_ != MASTER) return;
         for(std::vector<FormationController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
+        {
             (*it)->state_ = FREE;
             (*it)->myMaster_ = 0;
+        for(FormationController* slave : slaves_)
+        {
+            slave->state_ = FREE;
+            slave->myMaster_ = nullptr;
+        }
         this->slaves_.clear();
 …
         if(this->state_ != MASTER) return;
         for(std::vector<FormationController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
+        {
             (*it)->state_ = FREE;
             (*it)->forceFreedom();
             (*it)->targetPosition_ = this->targetPosition_;
             (*it)->bShooting_ = true;
+        for(FormationController* slave : slaves_)
+        {
+            slave->state_ = FREE;
+            slave->forceFreedom();
+            slave->targetPosition_ = this->targetPosition_;
+            slave->bShooting_ = true;
 //             (*it)->getControllableEntity()->fire(0);// fire once for fun
+        }
 …
         //search new Master, then take lead
         if (this->state_==FREE && this->myMaster_==0)
+        if (this->state_==FREE && this->myMaster_==nullptr)
+        {
           searchNewMaster();
 …
             this->slaves_.push_back(this->myMaster_);
             //set this as new master
             for(std::vector<FormationController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
+            {
                  (*it)->myMaster_=this;
+            }
             this->myMaster_=0;
+            for(FormationController* slave : slaves_)
+            {
+                 slave->myMaster_=this;
+            }
+            this->myMaster_=nullptr;
             this->state_=MASTER;
+        }
 …
         if (this->state_ == MASTER)
+        {
             for(std::vector<FormationController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
+            {
                  (*it)->formationMode_ = val;
+            for(FormationController* slave : slaves_)
+            {
+                 slave->formationMode_ = val;
                  if (val == ATTACK)
                      (*it)->forgetTarget();
+                     slave->forgetTarget();
+            }
+        }
 …
+    {
         Pawn *humanPawn = NULL;
         NewHumanController *currentHumanController = NULL;
+        Pawn *humanPawn = nullptr;
+        NewHumanController *currentHumanController = nullptr;
         std::vector<FormationController*> allMasters;
         for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
             Controller* controller = 0;
             if (it->getController())
                 controller = it->getController();
             else if (it->getXMLController())
                 controller = it->getXMLController();
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            Controller* controller = nullptr;
+            if (pawn->getController())
+                controller = pawn->getController();
+            else if (pawn->getXMLController())
+                controller = pawn->getXMLController();
             if (!controller)
 …
             currentHumanController = orxonox_cast<NewHumanController*>(controller);
             if(currentHumanController) humanPawn = *it;
+            if(currentHumanController) humanPawn = pawn;
             FormationController *aiController = orxonox_cast<FormationController*>(controller);
 …
+        }
         if((humanPawn != NULL) && (allMasters.size() != 0))
+        if((humanPawn != nullptr) && (allMasters.size() != 0))
+        {
             float posHuman = humanPawn->getPosition().length();
 …
             int i = 0;
             for(std::vector<FormationController*>::iterator it = allMasters.begin(); it != allMasters.end(); it++, i++)
+            {
                 if (!FormationController::sameTeam((*it)->getControllableEntity(), humanPawn, (*it)->getGametype())) continue;
                 distance = posHuman - (*it)->getControllableEntity()->getPosition().length();
+            for(FormationController* master : allMasters)
+            {
+                if (!FormationController::sameTeam(master->getControllableEntity(), humanPawn, master->getGametype())) continue;
+                distance = posHuman - master->getControllableEntity()->getPosition().length();
                 if(distance < minDistance) index = i;
+                i++;
+            }
             allMasters[index]->followInit(humanPawn);
 …
     void FormationController::followInit(Pawn* pawn, const bool always, const int secondsToFollow)
+    {
         if (pawn == NULL || this->state_ != MASTER)
+        if (pawn == nullptr || this->state_ != MASTER)
             return;
         this->specificMasterAction_  =  FOLLOW;
 …
+    {
         Pawn *humanPawn = NULL;
         NewHumanController *currentHumanController = NULL;
         for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
             if (!it->getController())
+        Pawn *humanPawn = nullptr;
+        NewHumanController *currentHumanController = nullptr;
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            if (!pawn->getController())
                 continue;
             currentHumanController = orxonox_cast<NewHumanController*>(it->getController());
+            currentHumanController = orxonox_cast<NewHumanController*>(pawn->getController());
             if(currentHumanController)
+            {
                 if (!FormationController::sameTeam(this->getControllableEntity(), *it, this->getGametype())) continue;
                 humanPawn = *it;
+                if (!FormationController::sameTeam(this->getControllableEntity(), pawn, this->getGametype())) continue;
+                humanPawn = pawn;
                 break;
+            }
+        }
         if((humanPawn != NULL))
+        if((humanPawn != nullptr))
                 this->followInit(humanPawn);
+    }
 …
         this->forgetTarget();
         for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
             if (FormationController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(*it), this->getGametype()))
+        for (Pawn* pawn : ObjectList<Pawn>())
+        {
+            if (FormationController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(pawn), this->getGametype()))
                 continue;
             /* So AI won't choose invisible Spaceships as target */
             if (!it->getRadarVisibility())
+            if (!pawn->getRadarVisibility())
                 continue;
             if (static_cast<ControllableEntity*>(*it) != this->getControllableEntity())
+            if (static_cast<ControllableEntity*>(pawn) != this->getControllableEntity())
+            {
                 float speed = this->getControllableEntity()->getVelocity().length();
                 Vector3 distanceCurrent = this->targetPosition_ - this->getControllableEntity()->getPosition();
                 Vector3 distanceNew = it->getPosition() - this->getControllableEntity()->getPosition();
                 if (!this->target_ || it->getPosition().squaredDistance(this->getControllableEntity()->getPosition()) * (1.5f + acos((this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).dotProduct(distanceNew) / speed / distanceNew.length()) / math::twoPi)
+                Vector3 distanceNew = pawn->getPosition() - this->getControllableEntity()->getPosition();
+                if (!this->target_ || pawn->getPosition().squaredDistance(this->getControllableEntity()->getPosition()) * (1.5f + acos((this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).dotProduct(distanceNew) / speed / distanceNew.length()) / math::twoPi)
                         < this->targetPosition_.squaredDistance(this->getControllableEntity()->getPosition()) * (1.5f + acos((this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).dotProduct(distanceCurrent) / speed / distanceCurrent.length()) / math::twoPi) + rnd(-250, 250))
+                {
                     this->setTarget(*it);
+                    this->setTarget(pawn);
+                }
+            }
 …
     void FormationController::forgetTarget()
+    {
         this->target_ = 0;
+        this->target_ = nullptr;
         this->bShooting_ = false;
+    }
 …
         int team2 = entity2->getTeam();
         Controller* controller = 0;
+        Controller* controller = nullptr;
         if (entity1->getController())
             controller = entity1->getController();
 …
+        }
         TeamBaseMatchBase* base = 0;
+        TeamBaseMatchBase* base = nullptr;
         base = orxonox_cast<TeamBaseMatchBase*>(entity1);
         if (base)
 …
+        }
         DroneController* droneController = 0;
+        DroneController* droneController = nullptr;
         droneController = orxonox_cast<DroneController*>(entity1->getController());
         if (droneController && static_cast<ControllableEntity*>(droneController->getOwner()) == entity2)

code/trunk/src/orxonox/controllers/FormationController.h

-                      r10631
+                      r11071
       virtual ~FormationController();
       virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+      virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 …
            { return this->formationMode_; }
       virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
+      virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage) override;
       FormationController* getMaster( void ) { return myMaster_; }
 …
       FormationController* getSlave( void ) { return this->slaves_.back(); }
       virtual void changedControllableEntity();
+      virtual void changedControllableEntity() override;
   protected:

code/trunk/src/orxonox/controllers/HumanController.cc

-                      r11052
+                      r11071
     RegisterUnloadableClass(HumanController);
     HumanController* HumanController::localController_s = 0;
+    HumanController* HumanController::localController_s = nullptr;
     HumanController::HumanController(Context* context) : FormationController(context)
 …
             HumanController::localController_s->removeFromFormation();
+        }
         HumanController::localController_s = 0;
+        HumanController::localController_s = nullptr;
+    }
 …
             return orxonox_cast<Pawn*>(HumanController::localController_s->getControllableEntity());
         else
             return NULL;
+            return nullptr;
+    }

code/trunk/src/orxonox/controllers/HumanController.h

r10624	r11071
47	47	virtual ~HumanController();
48	48
49		virtual void tick(float dt);
	49	virtual void tick(float dt) override;
50	50
51	51	static void moveFrontBack(const Vector2& value);

code/trunk/src/orxonox/controllers/MasterController.cc

r11052	r11071
58	58	{
59	59	//fill the vector in the first tick
60		for (~~ObjectList<ActionpointController>::iterator it = ObjectList<ActionpointController>::begin(); it; ++it~~)
	60	for (ActionpointController* controller : ObjectList<ActionpointController>())
61	61	{
62	62	//----0ptr?----
63		if (!it)
	63	if (!controller)
64	64	continue;
65		this->controllers_.push_back(*it);
	65	this->controllers_.push_back(controller);
66	66	}
67	67	}

code/trunk/src/orxonox/controllers/MasterController.h

-                      r11052
+                      r11071
             //----[orxonox demanded functions]----
                 virtual void tick(float dt);
+                virtual void tick(float dt) override;
             //----[orxonox demanded functions]----
 …
         private:
             std::vector<WeakPtr<ActionpointController> > controllers_;  //<! vector of controllers, which action(), canFire() and maneuver() methods are to be called
+            std::vector<WeakPtr<ActionpointController>> controllers_;//<! vector of controllers, which action(), canFire() and maneuver() methods are to be called
             size_t indexOfCurrentController_;                        //<! index of current controller
             unsigned int numberOfTicksPassedSinceLastActionCall_;

code/trunk/src/orxonox/controllers/NewHumanController.cc

-                      r10631
+                      r11071
     RegisterUnloadableClass(NewHumanController);
     NewHumanController* NewHumanController::localController_s = 0;
+    NewHumanController* NewHumanController::localController_s = nullptr;
     NewHumanController::NewHumanController(Context* context)
         : HumanController(context)
         , crossHairOverlay_(NULL)
         , centerOverlay_(NULL)
         , damageOverlayTop_(NULL)
         , damageOverlayRight_(NULL)
         , damageOverlayBottom_(NULL)
         , damageOverlayLeft_(NULL)
+        , crossHairOverlay_(nullptr)
+        , centerOverlay_(nullptr)
+        , damageOverlayTop_(nullptr)
+        , damageOverlayRight_(nullptr)
+        , damageOverlayBottom_(nullptr)
+        , damageOverlayLeft_(nullptr)
         , damageOverlayTT_(0)
         , damageOverlayTR_(0)
         , damageOverlayTB_(0)
         , damageOverlayTL_(0)
         , arrowsOverlay1_(NULL)
         , arrowsOverlay2_(NULL)
         , arrowsOverlay3_(NULL)
         , arrowsOverlay4_(NULL)
+        , arrowsOverlay1_(nullptr)
+        , arrowsOverlay2_(nullptr)
+        , arrowsOverlay3_(nullptr)
+        , arrowsOverlay4_(nullptr)
+    {
         RegisterObject(NewHumanController);
 …
             pawn->setAimPosition( mouseRay.getOrigin() + mouseRay.getDirection() * 3000 );
         if( this->getControllableEntity() && this->getControllableEntity()->getTarget() != 0 )
             this->getControllableEntity()->setTarget( 0 );
+        if( this->getControllableEntity() && this->getControllableEntity()->getTarget() != nullptr )
+            this->getControllableEntity()->setTarget( nullptr );
         //return this->controllableEntity_->getWorldPosition() + (this->controllableEntity_->getWorldOrientation() * Vector3::NEGATIVE_UNIT_Z * 2000);

code/trunk/src/orxonox/controllers/NewHumanController.h

-                      r9667
+                      r11071
             virtual ~NewHumanController();
             virtual void tick(float dt);
+            virtual void tick(float dt) override;
             virtual void frontback(const Vector2& value);
             virtual void yaw(const Vector2& value);
             virtual void pitch(const Vector2& value);
+            virtual void frontback(const Vector2& value) override;
+            virtual void yaw(const Vector2& value) override;
+            virtual void pitch(const Vector2& value) override;
             static void accelerate();
             static void decelerate();
             virtual void doFire(unsigned int firemode);
+            virtual void doFire(unsigned int firemode) override;
             virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
+            virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage) override;
             static void unfire();
 …
             static void changeMode();
             virtual void changedControllableEntity();
             virtual void doPauseControl();
             virtual void doResumeControl();
+            virtual void changedControllableEntity() override;
+            virtual void doPauseControl() override;
+            virtual void doResumeControl() override;
             float getCurrentYaw(){ return this->currentYaw_; }

code/trunk/src/orxonox/controllers/ScriptController.cc

-                      r10622
+                      r11071
         /* Set default values for all variables */
         /* - pointers to zero */
         this->player_ = NULL;
         this->entity_ = NULL;
+        this->player_ = nullptr;
+        this->entity_ = nullptr;
         /* - times */
 …
       /* Debugging: print all the scriptcontroller object pointers */
+      for(ObjectList<ScriptController>::iterator it =
+        ObjectList<ScriptController>::begin();
+        it != ObjectList<ScriptController>::end(); ++it)
+      { orxout(verbose) << "Have object in list: " << *it << endl; }
+      for(ScriptController* controller : ObjectList<ScriptController>())
+      { orxout(verbose) << "Have object in list: " << controller << endl; }
       /* Find the first one with a nonzero ID */
+      for(ObjectList<ScriptController>::iterator it =
+        ObjectList<ScriptController>::begin();
+        it != ObjectList<ScriptController>::end(); ++it)
+      for(ScriptController* controller : ObjectList<ScriptController>())
+      {
         // TODO: do some selection here. Currently just returns the first one
         if( (*it)->getID() > 0 )
         { orxout(verbose) << "Controller to return: " << *it << endl;
           return *it;
+        if( controller->getID() > 0 )
+        { orxout(verbose) << "Controller to return: " << controller << endl;
+          return controller;
+        }
+      }
       return NULL;
+      return nullptr;
+    }

code/trunk/src/orxonox/controllers/ScriptController.h

r10622	r11071
71	71	void setPlayer(PlayerInfo* player) { this->player_ = player; }
72	72
73		virtual void tick(float dt);
	73	virtual void tick(float dt) override;
74	74
75	75	// LUA interface

code/trunk/src/orxonox/controllers/SectionController.cc

-                      r11052
+                      r11071
         this->setFormationMode(FormationMode::FINGER4);
         this->myWingman_ = 0;
         this->myDivisionLeader_ = 0;
+        this->myWingman_ = nullptr;
+        this->myDivisionLeader_ = nullptr;
         this->bFirstAction_ = true;
 …
     SectionController::~SectionController()
+    {
        for (size_t i = 0; i < this->actionpoints_.size(); ++i)
+        {
             if(this->actionpoints_[i])
                 this->actionpoints_[i]->destroy();
+        for (WorldEntity* actionpoint : this->actionpoints_)
+        {
+            if (actionpoint)
+                actionpoint->destroy();
+        }
         this->parsedActionpoints_.clear();
         this->actionpoints_.clear();
+    }
-    void SectionController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
-        SUPER(SectionController, XMLPort, xmlelement, mode);
+    }
-    //----in tick, move (or look) and shoot----
-    void SectionController::tick(float dt)
+    {
-        if (!this->isActive())
-            return;
-        SUPER(SectionController, tick, dt);
+    }
 …
+    {
         //----If division leader fights, cover him by fighting emenies close to his target----
         Action::Value action = this->myDivisionLeader_->getAction();
+        Action action = this->myDivisionLeader_->getAction();
         if (action == Action::FIGHT || action == Action::FIGHTALL || action == Action::ATTACK)
 …
                     Vector3 divisionTargetPosition = this->myDivisionLeader_->getTarget()->getWorldPosition();
                     Gametype* gt = this->getGametype();
                     for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
+                    for (Pawn* pawn : ObjectList<Pawn>())
+                    {
                         //----is enemy?----
                         if ( CommonController::sameTeam (this->getControllableEntity(), static_cast<ControllableEntity*>(*itP), gt) )
+                        if ( CommonController::sameTeam (this->getControllableEntity(), static_cast<ControllableEntity*>(pawn), gt) )
                             continue;
                         //----in range?----
                         if (((*itP)->getWorldPosition() - divisionTargetPosition).length() < 3000 &&
                             (*itP) != this->myDivisionLeader_->getTarget())
+                        if ((pawn->getWorldPosition() - divisionTargetPosition).length() < 3000 &&
+                            pawn != this->myDivisionLeader_->getTarget())
+                        {
                             foundTarget = true;
                             target =  (*itP);
+                            target = pawn;
                             break;
+                        }
 …
         this->setFormationMode( this->myDivisionLeader_->getFormationMode() );
         this->spread_ = this->myDivisionLeader_->getSpread();
-        Vector3* targetRelativePosition;
         switch (this->formationMode_){
             case FormationMode::WALL:
+            {
+                targetRelativePosition = new Vector3 (-2.0f*this->spread_, 0, 0);
+                break;
+            }
+                return Vector3 (-2.0f*this->spread_, 0, 0);
             case FormationMode::FINGER4:
+            {
+                targetRelativePosition = new Vector3 (-2.0f*this->spread_, 0, 1.0f*this->spread_);
+                break;
+            }
+                return Vector3 (-2.0f*this->spread_, 0, 1.0f*this->spread_);
             case FormationMode::DIAMOND:
+            {
+                targetRelativePosition = new Vector3 (-2.0f*this->spread_, 0, 1.0f*this->spread_);
+                break;
+            }
+        }
+        Vector3 result = *targetRelativePosition;
+        delete targetRelativePosition;
+        return result;
+                return Vector3 (-2.0f*this->spread_, 0, 1.0f*this->spread_);
+            default:
+                return Vector3::ZERO;
+        }
+    }
 …
         if (!this->getControllableEntity())
             return 0;
         ActionpointController* closestLeader = 0;
+            return nullptr;
+        ActionpointController* closestLeader = nullptr;
         float minDistance =  std::numeric_limits<float>::infinity();
         //go through all pawns
         for (ObjectList<ActionpointController>::iterator it = ObjectList<ActionpointController>::begin(); it; ++it)
+        for (ActionpointController* controller : ObjectList<ActionpointController>())
+        {
             //0ptr or not DivisionController?
             if (!(it) || !((it)->getIdentifier()->getName() == "DivisionController") || !(it->getControllableEntity()))
+            if (!controller || !(controller->getIdentifier()->getName() == "DivisionController") || !(controller->getControllableEntity()))
                 continue;
             //same team?
             if ((this->getControllableEntity()->getTeam() != (it)->getControllableEntity()->getTeam()))
+            if ((this->getControllableEntity()->getTeam() != controller->getControllableEntity()->getTeam()))
                 continue;
             //is equal to this?
             if (orxonox_cast<ControllableEntity*>(*it) == this->getControllableEntity())
+            if (orxonox_cast<ControllableEntity*>(controller) == this->getControllableEntity())
                 continue;
             float distance = CommonController::distance (it->getControllableEntity(), this->getControllableEntity());
+            float distance = CommonController::distance (controller->getControllableEntity(), this->getControllableEntity());
             if (distance < minDistance && !(it->hasFollower()))
+            {
                 closestLeader = *it;
+            if (distance < minDistance && !(controller->hasFollower()))
+            {
+                closestLeader = controller;
                 minDistance = distance;
+            }
 …
                 return closestLeader;
+        }
         return 0;
+        return nullptr;
+    }

code/trunk/src/orxonox/controllers/SectionController.h

-                      r11052
+                      r11071
             //----[/language demanded functions]----
-            //----[orxonox demanded functions]----
-                virtual void tick(float dt);
-                virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            //----[/orxonox demanded functions]----
             //----[own functions]----
                 ActionpointController* findNewDivisionLeader();
                 virtual bool setWingman(ActionpointController* newWingman);
                 virtual bool hasWingman();
                 virtual bool hasFollower()
+                virtual bool setWingman(ActionpointController* newWingman) override;
+                virtual bool hasWingman() override;
+                virtual bool hasFollower() override
                     { return false; }
                 void chooseTarget();
 …
         protected:
             //----action must only be managed by this----
                 virtual void action(); //<! action() is called in regular intervals by MasterController managing the bot's behaviour.
+                virtual void action() override; //<! action() is called in regular intervals by MasterController managing the bot's behaviour.
                 Vector3 getFormationPosition ();
                 void keepFormation();

code/trunk/src/orxonox/controllers/WaypointController.cc

r9667	r11071
44	44	WaypointController::~WaypointController()
45	45	{
46		for (~~size_t i = 0; i < this->waypoints_.size(); ++i~~)
	46	for (WorldEntity* waypoint : this->waypoints_)
47	47	{
48		if(~~this->waypoints_[i]~~)
49		~~this->waypoints_[i]~~->destroy();
	48	if(waypoint)
	49	waypoint->destroy();
50	50	}
51	51	}

code/trunk/src/orxonox/controllers/WaypointController.h

r9667	r11071
44	44	virtual ~WaypointController();
45	45
46		virtual void tick(float dt);
	46	virtual void tick(float dt) override;
47	47
48	48	protected:

code/trunk/src/orxonox/controllers/WaypointPatrolController.cc

r9716	r11071
87	87	float shortestsqdistance = (float)static_cast<unsigned int>(-1);
88	88
89		for (~~ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it~~)
	89	for (Pawn* pawn : ObjectList<Pawn>())
90	90	{
91		if (ArtificialController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity>(it), this->getGametype()))
	91	if (ArtificialController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(pawn), this->getGametype()))
92	92	continue;
93	93
94		float sqdistance = it->getPosition().squaredDistance(myposition);
	94	float sqdistance = pawn->getPosition().squaredDistance(myposition);
95	95	if (sqdistance < shortestsqdistance)
96	96	{
97	97	shortestsqdistance = sqdistance;
98		this->target_ = ~~(*it)~~;
	98	this->target_ = pawn;
99	99	}
100	100	}
101	101
102	102	if (shortestsqdistance > (this->alertnessradius_ * this->alertnessradius_))
103		this->target_ = 0;
	103	this->target_ = nullptr;
104	104	}
105	105	}

code/trunk/src/orxonox/controllers/WaypointPatrolController.h

-                      r9716
+                      r11071
             virtual ~WaypointPatrolController() {}
             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;
             inline void setAlertnessRadius(float radius)

code/trunk/src/orxonox/controllers/WingmanController.cc

-                      r11052
+                      r11071
+    {
         RegisterObject(WingmanController);
         this->myLeader_ = 0;
+        this->myLeader_ = nullptr;
         this->bFirstAction_ = true;
 …
     WingmanController::~WingmanController()
+    {
         for (size_t i = 0; i < this->actionpoints_.size(); ++i)
+        for (WorldEntity* actionpoint : this->actionpoints_)
+        {
             if(this->actionpoints_[i])
                 this->actionpoints_[i]->destroy();
+            if (actionpoint)
+                actionpoint->destroy();
+        }
         this->parsedActionpoints_.clear();
         this->actionpoints_.clear();
+    }
-    void WingmanController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
-        SUPER(WingmanController, XMLPort, xmlelement, mode);
+    }
-    //----in tick, move (or look) and shoot----
-    void WingmanController::tick(float dt)
+    {
-        if (!this->isActive())
-            return;
-        SUPER(WingmanController, tick, dt);
+    }
 …
     Vector3 WingmanController::getFormationPosition ()
+    {
         this->setFormationMode( this->myLeader_->getFormationMode() );
-        Vector3* targetRelativePosition;
         this->spread_ = this->myLeader_->getSpread();
         if (this->myLeader_->getIdentifier()->getName() == "DivisionController")
 …
             switch (this->formationMode_){
                 case FormationMode::WALL:
+                {
+                    targetRelativePosition = new Vector3 (2.0f*this->spread_, 0, 0 - 1.0f*this->tolerance_);
+                    break;
+                }
+                    return Vector3 (2.0f*this->spread_, 0, 0 - 1.0f*this->tolerance_);
                 case FormationMode::FINGER4:
+                {
+                    targetRelativePosition = new Vector3 (2.0f*this->spread_, 0, this->spread_ - 1.0f*this->tolerance_);
+                    break;
+                }
+                    return Vector3 (2.0f*this->spread_, 0, this->spread_ - 1.0f*this->tolerance_);
                 case FormationMode::DIAMOND:
+                {
+                    targetRelativePosition = new Vector3 (2.0f*this->spread_, 0, this->spread_ - 1.0f*this->tolerance_);
+                    break;
+                }
+                    return Vector3 (2.0f*this->spread_, 0, this->spread_ - 1.0f*this->tolerance_);
+                default:
+                    return Vector3::ZERO;
+            }
+        }
 …
             switch (this->formationMode_){
                 case FormationMode::WALL:
+                {
+                    targetRelativePosition = new Vector3 (-2.0f*this->spread_, 0, 0 - 1.0f*this->tolerance_);
+                    break;
+                }
+                    return Vector3 (-2.0f*this->spread_, 0, 0 - 1.0f*this->tolerance_);
                 case FormationMode::FINGER4:
+                {
+                    targetRelativePosition = new Vector3 (-2.0f*this->spread_, 0, this->spread_ - 1.0f*this->tolerance_);
+                    break;
+                }
+                    return Vector3 (-2.0f*this->spread_, 0, this->spread_ - 1.0f*this->tolerance_);
                 case FormationMode::DIAMOND:
+                {
+                    targetRelativePosition = new Vector3 (2.0f*this->spread_, -1.0f*this->spread_, 0 - 1.0f*this->tolerance_);
+                    break;
+                }
+                    return Vector3 (2.0f*this->spread_, -1.0f*this->spread_, 0 - 1.0f*this->tolerance_);
+                default:
+                    return Vector3::ZERO;
+            }
+        }
-        Vector3 result = *targetRelativePosition;
-        delete targetRelativePosition;
-        return result;
+    }
     void WingmanController::keepFormation()
 …
         if (!this->getControllableEntity())
             return 0;
+            return nullptr;
         //----vars for finding the closest leader----
         ActionpointController* closestLeader = 0;
+        ActionpointController* closestLeader = nullptr;
         float minDistance =  std::numeric_limits<float>::infinity();
         Gametype* gt = this->getGametype();
         for (ObjectList<ActionpointController>::iterator it = ObjectList<ActionpointController>::begin(); it; ++it)
+        for (ActionpointController* controller : ObjectList<ActionpointController>())
+        {
             //----0ptr or not a leader or dead?----
             if (!it ||
                 (it->getIdentifier()->getName() != "SectionController" && it->getIdentifier()->getName() != "DivisionController") ||
                 !(it->getControllableEntity()))
+            if (!controller ||
+                (controller->getIdentifier()->getName() != "SectionController" && controller->getIdentifier()->getName() != "DivisionController") ||
+                !(controller->getControllableEntity()))
                 continue;
             //----same team?----
             if ( !CommonController::sameTeam (this->getControllableEntity(), (it)->getControllableEntity(), gt) )
+            if ( !CommonController::sameTeam (this->getControllableEntity(), controller->getControllableEntity(), gt) )
                 continue;
             //----check distance----
             float distance = CommonController::distance (it->getControllableEntity(), this->getControllableEntity());
             if (distance < minDistance && !(it->hasWingman()))
+            float distance = CommonController::distance (controller->getControllableEntity(), this->getControllableEntity());
+            if (distance < minDistance && !(controller->hasWingman()))
+            {
                 closestLeader = *it;
+                closestLeader = controller;
                 minDistance = distance;
+            }
 …
+            }
+        }
         return 0;
+        return nullptr;
+    }

code/trunk/src/orxonox/controllers/WingmanController.h

-                      r11052
+                      r11071
             //----[orxonox demanded functions]----
+                virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+                virtual void tick(float dt);
+                virtual bool hasWingman()
+                virtual bool hasWingman() override
                     { return false; }
                 virtual bool hasFollower()
+                virtual bool hasFollower() override
                     { return false; }
             //----[/orxonox demanded functions]----
 …
         protected:
             //----action must only be managed by this----
                 virtual void action(); //<! action() is called in regular intervals managing the bot's behaviour.
+                virtual void action() override; //<! action() is called in regular intervals managing the bot's behaviour.
                 Vector3 getFormationPosition ();
                 void keepFormation();

code/trunk/src/orxonox/gamestates/GSClient.h

-                      r7163
+                      r11071
         ~GSClient();
         void activate();
         void deactivate();
         void update(const Clock& time);
+        virtual void activate() override;
+        virtual void deactivate() override;
+        virtual void update(const Clock& time) override;
     };
+}

code/trunk/src/orxonox/gamestates/GSGraphics.h

-                      r6417
+                      r11071
         ~GSGraphics();
         void activate();
         void deactivate();
         void update(const Clock& time);
+        virtual void activate() override;
+        virtual void deactivate() override;
+        virtual void update(const Clock& time) override;
     private:

code/trunk/src/orxonox/gamestates/GSLevel.cc

-                      r10624
+                      r11071
     GSLevel::GSLevel(const GameStateInfo& info)
         : GameState(info)
         , gameInputState_(0)
         , guiMouseOnlyInputState_(0)
         , guiKeysOnlyInputState_(0)
         , startFile_(0)
+        , gameInputState_(nullptr)
+        , guiMouseOnlyInputState_(nullptr)
+        , guiKeysOnlyInputState_(nullptr)
+        , startFile_(nullptr)
         , bShowIngameGUI_(false)
+    {
 …
 #endif
             gameInputState_->setHandler(0);
             guiMouseOnlyInputState_->setHandler(0);
             guiKeysOnlyInputState_->setHandler(0);
+            gameInputState_->setHandler(nullptr);
+            guiMouseOnlyInputState_->setHandler(nullptr);
+            guiKeysOnlyInputState_->setHandler(nullptr);
             InputManager::getInstance().destroyState("game");
             InputManager::getInstance().destroyState("guiKeysOnly");
 …
+        {
             ModifyConsoleCommand(__CC_changeGame_name).deactivate();
             ModifyConsoleCommand(__CC_reloadLevel_name).setObject(NULL).deactivate();
+            ModifyConsoleCommand(__CC_reloadLevel_name).setObject(nullptr).deactivate();
+        }
+    }
 …
         // Note: Temporarily moved to GSRoot.
         //// Call the scene objects
         //for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
         //    it->tick(time.getDeltaTime() * this->timeFactor_);
+        //for (Tickable* tickable : ObjectList<Tickable>())
+        //    tickable->tick(time.getDeltaTime() * this->timeFactor_);
+    }
     void GSLevel::prepareObjectTracking()
+    {
         for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
             this->staticObjects_.insert(*it);
+        for (BaseObject* baseObject : ObjectList<BaseObject>())
+            this->staticObjects_.insert(baseObject);
+    }
 …
         orxout(internal_info) << "Remaining objects:" << endl;
         unsigned int i = 0;
         for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); ++it)
+        {
             std::set<BaseObject*>::const_iterator find = this->staticObjects_.find(*it);
+        for (BaseObject* baseObject : ObjectList<BaseObject>())
+        {
+            std::set<BaseObject*>::const_iterator find = this->staticObjects_.find(baseObject);
             if (find == this->staticObjects_.end())
+            {
                 orxout(internal_warning) << ++i << ": " << it->getIdentifier()->getName() << " (" << *it << "), references: " << it->getReferenceCount() << endl;
+                orxout(internal_warning) << ++i << ": " << baseObject->getIdentifier()->getName() << " (" << baseObject << "), references: " << baseObject->getReferenceCount() << endl;
+            }
+        }
 …
     void GSLevel::unloadLevelAsClient()
+    {
+        for (ObjectList<Level>::iterator it = ObjectList<Level>::begin(); it != ObjectList<Level>::end(); )
+        ObjectList<Level> listLevel;
+        for (ObjectList<Level>::iterator it = listLevel.begin(); it != listLevel.end(); )
+        {
             StrongPtr<Level> level = *(it++); // StrongPtr prevents that the Level gets destroyed while we loop over it
+            for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(level); it != ObjectList<BaseObject>::end(level); )
+            ObjectList<BaseObject> listBaseObject(level);
+            for (ObjectList<BaseObject>::iterator it = listBaseObject.begin(); it != listBaseObject.end(); )
                 (it++)->destroy();
+        }
+        for (ObjectList<Synchronisable>::iterator it = ObjectList<Synchronisable>::begin(); it != ObjectList<Synchronisable>::end(); )
+        ObjectList<Synchronisable> listSynchronisable;
+        for (ObjectList<Synchronisable>::iterator it = listSynchronisable.begin(); it != listSynchronisable.end(); )
+        {
             if (it->getSyncMode() != 0x0)
 …
         // export all states
         std::vector<GSLevelMementoState*> states;
         for (ObjectList<GSLevelMemento>::iterator it = ObjectList<GSLevelMemento>::begin(); it != ObjectList<GSLevelMemento>::end(); ++it)
+        {
             GSLevelMementoState* state = it->exportMementoState();
+        for (GSLevelMemento* memento : ObjectList<GSLevelMemento>())
+        {
+            GSLevelMementoState* state = memento->exportMementoState();
             if (state)
                 states.push_back(state);
 …
         // import all states
         for (ObjectList<GSLevelMemento>::iterator it = ObjectList<GSLevelMemento>::begin(); it != ObjectList<GSLevelMemento>::end(); ++it)
             it->importMementoState(states);
+        for (GSLevelMemento* memento : ObjectList<GSLevelMemento>())
+            memento->importMementoState(states);
         // delete states
         for (size_t i = 0; i < states.size(); ++i)
             delete states[i];
+        for (GSLevelMementoState* state : states)
+            delete state;
+    }

code/trunk/src/orxonox/gamestates/GSLevel.h

-                      r10624
+                      r11071
         ~GSLevel();
         void activate();
         void deactivate();
         void update(const Clock& time);
+        virtual void activate() override;
+        virtual void deactivate() override;
+        virtual void update(const Clock& time) override;
         static void startMainMenu(void); //!< Starts the MainMenu

code/trunk/src/orxonox/gamestates/GSLevelMemento.h

r10281	r11071
48	48	protected:
49	49	/**
50		* Returns the state of this memento. Returns ~~NULL~~ if no state needed to persist.
	50	* Returns the state of this memento. Returns nullptr if no state needed to persist.
51	51	*/
52	52	virtual GSLevelMementoState* exportMementoState() = 0;

code/trunk/src/orxonox/gamestates/GSMainMenu.cc

-                      r10624
+                      r11071
         // create an empty Scene
         this->scene_ = new Scene(NULL);
+        this->scene_ = new Scene(nullptr);
         this->scene_->setSyncMode( 0x0 );
         // and a Camera
 …
         InputManager::getInstance().leaveState("MainMenuHackery");
         GraphicsManager::getInstance().setCamera(0);
+        GraphicsManager::getInstance().setCamera(nullptr);
         GUIManager::getInstance().setBackgroundImage("");
         GUIManager::hideGUI("MainMenu");
 …
         ModifyConsoleCommand(__CC_startClient_name    ).deactivate();
         ModifyConsoleCommand(__CC_startDedicated_name ).deactivate();
         ModifyConsoleCommand(__CC_setMainMenuSoundPath_name).setObject(0);
+        ModifyConsoleCommand(__CC_setMainMenuSoundPath_name).setObject(nullptr);
+    }

code/trunk/src/orxonox/gamestates/GSMainMenu.h

-                      r9667
+                      r11071
         ~GSMainMenu();
         void activate();
         void deactivate();
         void update(const Clock& time);
+        virtual void activate() override;
+        virtual void deactivate() override;
+        virtual void update(const Clock& time) override;
         void setConfigValues();

code/trunk/src/orxonox/gamestates/GSMasterServer.h

-                      r7801
+                      r11071
       ~GSMasterServer();
       void activate();
       void deactivate();
       void update(const Clock& time);
+      virtual void activate() override;
+      virtual void deactivate() override;
+      virtual void update(const Clock& time) override;
     private:

code/trunk/src/orxonox/gamestates/GSRoot.cc

-                      r10624
+                      r11071
 #include "core/GameMode.h"
 #include "core/command/ConsoleCommandIncludes.h"
+#include "core/object/ObjectList.h"
 #include "network/NetworkFunctionIncludes.h"
 #include "tools/Timer.h"
 …
+    {
         unsigned int nr=0;
         for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it; ++it)
+        {
             Synchronisable* synchronisable = orxonox_cast<Synchronisable*>(*it);
+        for (BaseObject* baseObject : ObjectList<BaseObject>())
+        {
+            Synchronisable* synchronisable = orxonox_cast<Synchronisable*>(baseObject);
             if (synchronisable)
                 orxout(debug_output) << "object: " << it->getIdentifier()->getName() << " id: " << synchronisable->getObjectID() << endl;
+                orxout(debug_output) << "object: " << baseObject->getIdentifier()->getName() << " id: " << synchronisable->getObjectID() << endl;
             else
                 orxout(debug_output) << "object: " << it->getIdentifier()->getName() << endl;
+                orxout(debug_output) << "object: " << baseObject->getIdentifier()->getName() << endl;
             nr++;
+        }
 …
     void GSRoot::deactivate()
+    {
         ModifyConsoleCommand(__CC_setTimeFactor_name).setObject(0);
         ModifyConsoleCommand(__CC_getTimeFactor_name).setObject(0);
         ModifyConsoleCommand(__CC_setPause_name).setObject(0);
         ModifyConsoleCommand(__CC_pause_name).setObject(0);
+        ModifyConsoleCommand(__CC_setTimeFactor_name).setObject(nullptr);
+        ModifyConsoleCommand(__CC_getTimeFactor_name).setObject(nullptr);
+        ModifyConsoleCommand(__CC_setPause_name).setObject(nullptr);
+        ModifyConsoleCommand(__CC_pause_name).setObject(nullptr);
+    }
 …
+        }
+        for (ObjectList<Timer>::iterator it = ObjectList<Timer>::begin(); it; )
+        ObjectList<Timer> listTimer;
+        for (ObjectList<Timer>::iterator it = listTimer.begin(); it; )
+        {
             Timer* object = *it;
 …
+        }
         float realdt = leveldt * TimeFactorListener::getTimeFactor();
+        for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; )
+        ObjectList<Tickable> listTickable;
+        for (ObjectList<Tickable>::iterator it = listTickable.begin(); it; )
+        {
             Tickable* object = *it;

code/trunk/src/orxonox/gamestates/GSRoot.h

-                      r8706
+                      r11071
         static void printObjects();
         void activate();
         void deactivate();
         void update(const Clock& time);
+        virtual void activate() override;
+        virtual void deactivate() override;
+        virtual void update(const Clock& time) override;
         // this has to be public because proteced triggers a bug in msvc
 …
     protected:
         virtual void changedTimeFactor(float factor_new, float factor_old);
+        virtual void changedTimeFactor(float factor_new, float factor_old) override;
     private:

code/trunk/src/orxonox/gamestates/GSServer.cc

r10624	r11071
44	44	GSServer::GSServer(const GameStateInfo& info)
45	45	: GameState(info)
46		, server_(0)
	46	, server_(nullptr)
47	47	{
48	48	}

code/trunk/src/orxonox/gamestates/GSServer.h

-                      r5929
+                      r11071
         ~GSServer();
         void activate();
         void deactivate();
         void update(const Clock& time);
+        virtual void activate() override;
+        virtual void deactivate() override;
+        virtual void update(const Clock& time) override;
     private:

code/trunk/src/orxonox/gamestates/GSStandalone.h

-                      r5929
+                      r11071
         ~GSStandalone();
         void activate();
         void deactivate();
         void update(const Clock& time);
+        virtual void activate() override;
+        virtual void deactivate() override;
+        virtual void update(const Clock& time) override;
     private:

code/trunk/src/orxonox/gametypes/Asteroids.h

-                      r9667
+                      r11071
             virtual ~Asteroids() {}
             virtual void tick(float dt);
+            virtual void tick(float dt) override;
             virtual void start();
             virtual void end();
+            virtual void start() override;
+            virtual void end() override;
             inline void firstCheckpointReached(bool reached)
 …
         protected:
             virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
+            virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr) override;
         private:

code/trunk/src/orxonox/gametypes/Deathmatch.h

-                      r9667
+                      r11071
             virtual ~Deathmatch() {}
             virtual void start();
             virtual void end();
             virtual void playerEntered(PlayerInfo* player);
             virtual bool playerLeft(PlayerInfo* player);
             virtual bool playerChangedName(PlayerInfo* player);
+            virtual void start() override;
+            virtual void end() override;
+            virtual void playerEntered(PlayerInfo* player) override;
+            virtual bool playerLeft(PlayerInfo* player) override;
+            virtual bool playerChangedName(PlayerInfo* player) override;
             virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
             virtual void playerScored(PlayerInfo* player, int score = 1);
+            virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr) override;
+            virtual void playerScored(PlayerInfo* player, int score = 1) override;
     };
+}

code/trunk/src/orxonox/gametypes/Dynamicmatch.cc

-                      r11052
+                      r11071
     Dynamicmatch::~Dynamicmatch()
+    {
         for (std::set<Timer*>::iterator it = this->piggyTimers_.begin(); it != this->piggyTimers_.end(); ++it)
             delete (*it);
+        for (Timer* timer : this->piggyTimers_)
+            delete timer;
+    }
 …
     void Dynamicmatch::rewardPig()
+    {
         for (std::map< PlayerInfo*, int >::iterator it = this->playerParty_.begin(); it != this->playerParty_.end(); ++it) //durch alle Spieler iterieren und alle piggys finden
+        {
             if (it->second==piggy)//Spieler mit der Pig-party frags++
+            {
                  this->playerScored(it->first);
+        for (const auto& mapEntry : this->playerParty_) //durch alle Spieler iterieren und alle piggys finden
+        {
+            if (mapEntry.second==piggy)//Spieler mit der Pig-party frags++
+            {
+                 this->playerScored(mapEntry.first);
+            }
+        }
 …
                 std::set<WorldEntity*> pawnAttachments = pawn->getAttachedObjects();
                 for (std::set<WorldEntity*>::iterator it = pawnAttachments.begin(); it != pawnAttachments.end(); ++it)
+                {
                     if ((*it)->isA(Class(TeamColourable)))
+                for (WorldEntity* pawnAttachment : pawnAttachments)
+                {
+                    if (pawnAttachment->isA(Class(TeamColourable)))
+                    {
                         TeamColourable* tc = orxonox_cast<TeamColourable*>(*it);
+                        TeamColourable* tc = orxonox_cast<TeamColourable*>(pawnAttachment);
                         tc->setTeamColour(this->partyColours_[it_player->second]);
+                    }
 …
             if (tutorial) // Announce selectionphase
+            {
              for (std::map<PlayerInfo*, int>::iterator it = this->playerParty_.begin(); it != this->playerParty_.end(); ++it)
+                {
                     if (!it->first)//in order to catch nullpointer
+             for (const auto& mapEntry : this->playerParty_)
+                {
+                    if (!mapEntry.first)//in order to catch nullpointer
                         continue;
                     if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                    if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",it->first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
+                    this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",mapEntry.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
+                }
+            }
 …
              if(tutorial&&(!notEnoughKillers)&&(!notEnoughChasers)) //Selection phase over
+             {
                   for (std::map<PlayerInfo*, int>::iterator it = this->playerParty_.begin(); it != this->playerParty_.end(); ++it)
+                  for (const auto& mapEntry : this->playerParty_)
+                  {
                        if (!it->first)//in order to catch nullpointer
+                       if (!mapEntry.first)//in order to catch nullpointer
                            continue;
                        if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                       if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                            continue;
                        else if (it->second==chaser)
+                       else if (mapEntry.second==chaser)
+                       {
                            if (numberOf[killer]>0)
                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",it->first->getClientID(),partyColours_[piggy]);
+                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",mapEntry.first->getClientID(),partyColours_[piggy]);
                            else
                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",it->first->getClientID(),partyColours_[piggy]);
+                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",mapEntry.first->getClientID(),partyColours_[piggy]);
                            //this->gtinfo_->sendFadingMessage("You're now a chaser.",it->first->getClientID());
+                       }
                        else if (it->second==piggy)
+                       {
                            this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",it->first->getClientID(),partyColours_[chaser]);
+                       else if (mapEntry.second==piggy)
+                       {
+                           this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",mapEntry.first->getClientID(),partyColours_[chaser]);
                            //this->gtinfo_->sendFadingMessage("You're now a victim.",it->first->getClientID());
+                       }
                        else if (it->second==killer)
+                       {
                            this->gtinfo_->sendStaticMessage("Take the chasers down.",it->first->getClientID(),partyColours_[chaser]);
+                       else if (mapEntry.second==killer)
+                       {
+                           this->gtinfo_->sendStaticMessage("Take the chasers down.",mapEntry.first->getClientID(),partyColours_[chaser]);
                            //this->gtinfo_->sendFadingMessage("You're now a killer.",it->first->getClientID());
+                       }
 …
             if (tutorial) // Announce selectionphase
+            {
              for (std::map<PlayerInfo*, int>::iterator it = this->playerParty_.begin(); it != this->playerParty_.end(); ++it)
+                {
                     if (!it->first)//in order to catch nullpointer
+             for (const auto& mapEntry : this->playerParty_)
+                {
+                    if (!mapEntry.first)//in order to catch nullpointer
                         continue;
                     if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                    if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",it->first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
+                    this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",mapEntry.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
+                }
+            }
 …
             if(tutorial&&(!notEnoughPigs)&&(!notEnoughChasers)) //Selection phase over
+             {
                   for (std::map<PlayerInfo*, int>::iterator it = this->playerParty_.begin(); it != this->playerParty_.end(); ++it)
+                  for (const auto& mapEntry : this->playerParty_)
+                  {
                        if (!it->first)
+                       if (!mapEntry.first)
                            continue;
                        if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                       if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                            continue;
                        else if (it->second==chaser)
+                       else if (mapEntry.second==chaser)
+                       {
                            if (numberOf[killer]>0)
                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",it->first->getClientID(),partyColours_[piggy]);
+                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",mapEntry.first->getClientID(),partyColours_[piggy]);
                            else
                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",it->first->getClientID(),partyColours_[piggy]);
+                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",mapEntry.first->getClientID(),partyColours_[piggy]);
                            //this->gtinfo_->sendFadingMessage("You're now a chaser.",it->first->getClientID());
+                       }
                        else if (it->second==piggy)
+                       {
                            this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",it->first->getClientID(),partyColours_[piggy]);
+                       else if (mapEntry.second==piggy)
+                       {
+                           this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",mapEntry.first->getClientID(),partyColours_[piggy]);
                            //this->gtinfo_->sendFadingMessage("You're now a victim.",it->first->getClientID());
+                       }
                        else if (it->second==killer)
+                       {
                            this->gtinfo_->sendStaticMessage("Take the chasers down.",it->first->getClientID(),partyColours_[piggy]);
+                       else if (mapEntry.second==killer)
+                       {
+                           this->gtinfo_->sendStaticMessage("Take the chasers down.",mapEntry.first->getClientID(),partyColours_[piggy]);
                            //this->gtinfo_->sendFadingMessage("You're now a killer.",it->first->getClientID());
+                       }
 …
             if (tutorial) // Announce selectionphase
+            {
              for (std::map<PlayerInfo*, int>::iterator it = this->playerParty_.begin(); it != this->playerParty_.end(); ++it)
+                {
                     if (!it->first)//in order to catch nullpointer
+             for (const auto& mapEntry : this->playerParty_)
+                {
+                    if (!mapEntry.first)//in order to catch nullpointer
                         continue;
                     if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                    if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",it->first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
+                    this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",mapEntry.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
+                }
+            }
 …
              if(tutorial&&(!notEnoughPigs)&&(!notEnoughKillers)) //Selection phase over
+             {
                   for (std::map<PlayerInfo*, int>::iterator it = this->playerParty_.begin(); it != this->playerParty_.end(); ++it)
+                  for (const auto& mapEntry : this->playerParty_)
+                  {
                        if (!it->first)
+                       if (!mapEntry.first)
                            continue;
                        if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                       if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                            continue;
                        else if (it->second==chaser)
+                       else if (mapEntry.second==chaser)
+                       {
                            if (numberOf[killer]>0)
                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",it->first->getClientID(),partyColours_[piggy]);
+                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible. Defend yourself against the killers.",mapEntry.first->getClientID(),partyColours_[piggy]);
                            else
                                this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",it->first->getClientID(),partyColours_[piggy]);
+                               this->gtinfo_->sendStaticMessage("Shoot at the victim as often as possible.",mapEntry.first->getClientID(),partyColours_[piggy]);
                            //this->gtinfo_->sendFadingMessage("You're now a chaser.",it->first->getClientID());
+                       }
                        else if (it->second==piggy)
+                       {
                            this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",it->first->getClientID(),partyColours_[chaser]);
+                       else if (mapEntry.second==piggy)
+                       {
+                           this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",mapEntry.first->getClientID(),partyColours_[chaser]);
                            //this->gtinfo_->sendFadingMessage("You're now a victim.",it->first->getClientID());
+                       }
                        else if (it->second==killer)
+                       {
                            this->gtinfo_->sendStaticMessage("Take the chasers down.",it->first->getClientID(),partyColours_[chaser]);
+                       else if (mapEntry.second==killer)
+                       {
+                           this->gtinfo_->sendStaticMessage("Take the chasers down.",mapEntry.first->getClientID(),partyColours_[chaser]);
                            //this->gtinfo_->sendFadingMessage("You're now a killer.",it->first->getClientID());
+                       }
 …
         else if(tutorial) // Announce selectionphase
+        {
             for (std::map<PlayerInfo*, int>::iterator it = this->playerParty_.begin(); it != this->playerParty_.end(); ++it)
+            {
                 if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+            for (const auto& mapEntry : this->playerParty_)
+            {
+                if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                     continue;
                 this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",it->first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
+                this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",mapEntry.first->getClientID(),ColourValue(1.0f, 1.0f, 0.5f));
+            }
+        }
 …
             unsigned int randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
             unsigned int index = 0;
             for (std::set<SpawnPoint*>::const_iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); ++it)
+            for (SpawnPoint* teamSpawnPoint : teamSpawnPoints)
+            {
                 if (index == randomspawn)
                     return (*it);
+                    return teamSpawnPoint;
                 ++index;
 …
+        }
         return 0;
+        return nullptr;
+    }

code/trunk/src/orxonox/gametypes/Dynamicmatch.h

-                      r11052
+                      r11071
             bool tutorial; //goal: new players receive messages how the new gametype works - later it can be switched off.
             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0); //ok - score function and management of parties
             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0); //ok - simple
             virtual void start();
             virtual void end(); //Wie geht das mit der Punkteausgabe aendern? Z.B: Persoenliche Nachricht?
             virtual void playerEntered(PlayerInfo* player);
             virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn);//is used to initialize the player's party and colour
             virtual bool playerLeft(PlayerInfo* player);
             virtual bool playerChangedName(PlayerInfo* player);//unchanged
+            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr) override; //ok - score function and management of parties
+            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr) override; //ok - simple
+            virtual void start() override;
+            virtual void end() override; //Wie geht das mit der Punkteausgabe aendern? Z.B: Persoenliche Nachricht?
+            virtual void playerEntered(PlayerInfo* player) override;
+            virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn) override;//is used to initialize the player's party and colour
+            virtual bool playerLeft(PlayerInfo* player) override;
+            virtual bool playerChangedName(PlayerInfo* player) override;//unchanged
             /*virtual void instructions();
 …
             void grantPigBoost(SpaceShip* spaceship); // Grant the piggy a boost.
             void resetSpeedFactor(SpaceShip* spaceship, Timer* timer);
             void tick (float dt);// used to end the game
             SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;
+            virtual void tick (float dt) override;// used to end the game
+            virtual SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const override;

code/trunk/src/orxonox/gametypes/Gametype.cc

-                      r10624
+                      r11071
         this->defaultControllableEntity_ = Class(Spectator);
         this->scoreboard_ = 0;
+        this->scoreboard_ = nullptr;
         this->bAutoStart_ = false;
 …
                 this->gtinfo_->destroy();
             ModifyConsoleCommand(__CC_addBots_name).setObject(NULL);
             ModifyConsoleCommand(__CC_killBots_name).setObject(NULL);
+            ModifyConsoleCommand(__CC_addBots_name).setObject(nullptr);
+            ModifyConsoleCommand(__CC_killBots_name).setObject(nullptr);
+        }
+    }
 …
         if (!this->gtinfo_->hasStarted())
+        {
             for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+            for (const auto& mapEntry : this->players_)
+            {
                 // Inform the GametypeInfo that the player is ready to spawn.
                 if(it->first->isHumanPlayer() && it->first->isReadyToSpawn())
                     this->gtinfo_->playerReadyToSpawn(it->first);
+                if(mapEntry.first->isHumanPlayer() && mapEntry.first->isReadyToSpawn())
+                    this->gtinfo_->playerReadyToSpawn(mapEntry.first);
+            }
 …
+        }
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+        {
             if (it->first->getControllableEntity())
+            {
                 ControllableEntity* oldentity = it->first->getControllableEntity();
+        for (const auto& mapEntry : this->players_)
+        {
+            if (mapEntry.first->getControllableEntity())
+            {
+                ControllableEntity* oldentity = mapEntry.first->getControllableEntity();
                 ControllableEntity* entity = this->defaultControllableEntity_.fabricate(oldentity->getContext());
 …
                     entity->setOrientation(oldentity->getWorldOrientation());
+                }
                 it->first->startControl(entity);
+                mapEntry.first->startControl(entity);
+            }
             else
                 this->spawnPlayerAsDefaultPawn(it->first);
+                this->spawnPlayerAsDefaultPawn(mapEntry.first);
+        }
+    }
 …
+        {
             // Fallback spawn point if there is no active one, choose a random one.
             SpawnPoint* fallbackSpawnPoint = NULL;
+            SpawnPoint* fallbackSpawnPoint = nullptr;
             unsigned int randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(this->spawnpoints_.size())));
             unsigned int index = 0;
             std::vector<SpawnPoint*> activeSpawnPoints;
             for (std::set<SpawnPoint*>::const_iterator it = this->spawnpoints_.begin(); it != this->spawnpoints_.end(); ++it)
+            for (SpawnPoint* spawnpoint : this->spawnpoints_)
+            {
                 if (index == randomspawn)
                     fallbackSpawnPoint = (*it);
                 if (*it != NULL && (*it)->isActive())
                     activeSpawnPoints.push_back(*it);
+                    fallbackSpawnPoint = spawnpoint;
+                if (spawnpoint != nullptr && spawnpoint->isActive())
+                    activeSpawnPoints.push_back(spawnpoint);
                 ++index;
 …
             return fallbackSpawnPoint;
+        }
         return 0;
+        return nullptr;
+    }
     void Gametype::assignDefaultPawnsIfNeeded()
+    {
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+        {
             if (!it->first->getControllableEntity())
+            {
                 it->second.state_ = PlayerState::Dead;
                 if (!it->first->isReadyToSpawn() || !this->gtinfo_->hasStarted())
+                {
                     this->spawnPlayerAsDefaultPawn(it->first);
                     it->second.state_ = PlayerState::Dead;
+        for (auto& mapEntry : this->players_)
+        {
+            if (!mapEntry.first->getControllableEntity())
+            {
+                mapEntry.second.state_ = PlayerState::Dead;
+                if (!mapEntry.first->isReadyToSpawn() || !this->gtinfo_->hasStarted())
+                {
+                    this->spawnPlayerAsDefaultPawn(mapEntry.first);
+                    mapEntry.second.state_ = PlayerState::Dead;
+                }
+            }
 …
                     bool allplayersready = true;
                     bool hashumanplayers = false;
                     for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+                    for (const auto& mapEntry : this->players_)
+                    {
                         if (!it->first->isReadyToSpawn())
+                        if (!mapEntry.first->isReadyToSpawn())
                             allplayersready = false;
                         if (it->first->isHumanPlayer())
+                        if (mapEntry.first->isHumanPlayer())
                             hashumanplayers = true;
+                    }
 …
     void Gametype::spawnPlayersIfRequested()
+    {
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+        {
             if (it->first->isReadyToSpawn() || this->bForceSpawn_)
                 this->spawnPlayer(it->first);
+        for (const auto& mapEntry : this->players_)
+        {
+            if (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_)
+                this->spawnPlayer(mapEntry.first);
+        }
+    }
 …
     void Gametype::spawnDeadPlayersIfRequested()
+    {
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
             if (it->second.state_ == PlayerState::Dead)
                 if (it->first->isReadyToSpawn() || this->bForceSpawn_)
                     this->spawnPlayer(it->first);
+        for (const auto& mapEntry : this->players_)
+            if (mapEntry.second.state_ == PlayerState::Dead)
+                if (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_)
+                    this->spawnPlayer(mapEntry.first);
+    }
 …
+    {
         unsigned int i = 0;
+        for (ObjectList<Bot>::iterator it = ObjectList<Bot>::begin(); (it != ObjectList<Bot>::end()) && ((amount == 0) || (i < amount)); )
+        ObjectList<Bot> list;
+        for (ObjectList<Bot>::iterator it = list.begin(); (it != list.end()) && ((amount == 0) || (i < amount)); )
+        {
             if (it->getGametype() == this)
 …
     GSLevelMementoState* Gametype::exportMementoState()
+    {
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+        {
             if (it->first->isHumanPlayer() && it->first->getControllableEntity() && it->first->getControllableEntity()->getCamera())
+            {
                 Camera* camera = it->first->getControllableEntity()->getCamera();
+        for (const auto& mapEntry : this->players_)
+        {
+            if (mapEntry.first->isHumanPlayer() && mapEntry.first->getControllableEntity() && mapEntry.first->getControllableEntity()->getCamera())
+            {
+                Camera* camera = mapEntry.first->getControllableEntity()->getCamera();
                 GametypeMementoState* state = new GametypeMementoState();
 …
+        }
         return NULL;
+        return nullptr;
+    }
 …
+    {
         // find correct memento state
         GametypeMementoState* state = NULL;
         for (size_t i = 0; i < states.size(); ++i)
+        {
             state = dynamic_cast<GametypeMementoState*>(states[i]);
+        GametypeMementoState* state = nullptr;
+        for (GSLevelMementoState* temp : states)
+        {
+            state = dynamic_cast<GametypeMementoState*>(temp);
             if (state)
                 break;
 …
         // find correct scene
         Scene* scene = NULL;
         for (ObjectList<Scene>::iterator it = ObjectList<Scene>::begin(); it != ObjectList<Scene>::end(); ++it)
+        {
             if (it->getName() == state->sceneName_)
+            {
                 scene = *it;
+        Scene* scene = nullptr;
+        for (Scene* someScene : ObjectList<Scene>())
+        {
+            if (someScene->getName() == state->sceneName_)
+            {
+                scene = someScene;
                 break;
+            }
 …
         // find correct player and assign default entity with original position & orientation
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+        {
             if (it->first->isHumanPlayer())
+        for (const auto& mapEntry : this->players_)
+        {
+            if (mapEntry.first->isHumanPlayer())
+            {
                 ControllableEntity* entity = this->defaultControllableEntity_.fabricate(scene->getContext());
                 entity->setPosition(state->cameraPosition_);
                 entity->setOrientation(state->cameraOrientation_);
                 it->first->startControl(entity);
+                mapEntry.first->startControl(entity);
                 break;
+            }

code/trunk/src/orxonox/gametypes/Gametype.h

-                      r10624
+                      r11071
 namespace orxonox
+{
+    namespace PlayerState
+    {
+        enum Value
+        {
+            Uninitialized,
+            Joined,
+            Alive,
+            Dead
+        };
+    }
+    enum class PlayerState
+    {
+        Uninitialized,
+        Joined,
+        Alive,
+        Dead
+    };
     struct Player
+    {
         PlayerInfo* info_;
         PlayerState::Value state_;
+        PlayerState state_;
         int frags_;
         int killed_;
 …
             void setConfigValues();
             virtual void tick(float dt);
+            virtual void tick(float dt) override;
             inline const GametypeInfo* getGametypeInfo() const
 …
             virtual void playerScored(PlayerInfo* player, int score = 1);
             virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
             virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
+            virtual bool allowPawnHit(Pawn* victim, Pawn* originator = nullptr);
+            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr);
+            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr);
+            virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr);
             virtual void pawnPreSpawn(Pawn* pawn);
             virtual void pawnPostSpawn(Pawn* pawn);
 …
             virtual void spawnDeadPlayersIfRequested();
             virtual GSLevelMementoState* exportMementoState();
             virtual void importMementoState(const std::vector<GSLevelMementoState*>& states);
+            virtual GSLevelMementoState* exportMementoState() override;
+            virtual void importMementoState(const std::vector<GSLevelMementoState*>& states) override;
             WeakPtr<GametypeInfo> gtinfo_;

code/trunk/src/orxonox/gametypes/LastManStanding.cc

-                      r9667
+                      r11071
     void LastManStanding::spawnDeadPlayersIfRequested()
+    {
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
             if (it->second.state_ == PlayerState::Dead)
+            {
                 bool alive = (0<playerLives_[it->first]&&(inGame_[it->first]));
                 if (alive&&(it->first->isReadyToSpawn() || this->bForceSpawn_))
+                {
                     this->spawnPlayer(it->first);
+        for (const auto& mapEntry : this->players_)
+            if (mapEntry.second.state_ == PlayerState::Dead)
+            {
+                bool alive = (0<playerLives_[mapEntry.first]&&(inGame_[mapEntry.first]));
+                if (alive&&(mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                {
+                    this->spawnPlayer(mapEntry.first);
+                }
+            }
 …
+    {
         int min=lives;
         for (std::map<PlayerInfo*, int>::iterator it = this->playerLives_.begin(); it != this->playerLives_.end(); ++it)
+        {
             if (it->second<=0)
+        for (const auto& mapEntry : this->playerLives_)
+        {
+            if (mapEntry.second<=0)
                 continue;
             if (it->second<lives)
                 min=it->second;
+            if (mapEntry.second<lives)
+                min=mapEntry.second;
+        }
         return min;
 …
         Gametype::end();
         for (std::map<PlayerInfo*, int>::iterator it = this->playerLives_.begin(); it != this->playerLives_.end(); ++it)
+        {
             if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+        for (const auto& mapEntry : this->playerLives_)
+        {
+            if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
             if (it->second > 0)
                 this->gtinfo_->sendAnnounceMessage("You have won the match!", it->first->getClientID());
+            if (mapEntry.second > 0)
+                this->gtinfo_->sendAnnounceMessage("You have won the match!", mapEntry.first->getClientID());
             else
                 this->gtinfo_->sendAnnounceMessage("You have lost the match!", it->first->getClientID());
+                this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
+        }
+    }
 …
                 this->end();
+            }
             for (std::map<PlayerInfo*, float>::iterator it = this->timeToAct_.begin(); it != this->timeToAct_.end(); ++it)
+            {
                 if (playerGetLives(it->first)<=0)//Players without lives shouldn't be affected by time.
+            for (auto& mapEntry : this->timeToAct_)
+            {
+                if (playerGetLives(mapEntry.first)<=0)//Players without lives shouldn't be affected by time.
                     continue;
                 it->second-=dt;//Decreases punishment time.
                 if (!inGame_[it->first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
+                {
                     playerDelayTime_[it->first]-=dt;
                     if (playerDelayTime_[it->first]<=0)
                     this->inGame_[it->first]=true;
                     if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
+                mapEntry.second-=dt;//Decreases punishment time.
+                if (!inGame_[mapEntry.first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
+                {
+                    playerDelayTime_[mapEntry.first]-=dt;
+                    if (playerDelayTime_[mapEntry.first]<=0)
+                    this->inGame_[mapEntry.first]=true;
+                    if (mapEntry.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     int output=1+(int)playerDelayTime_[it->first];
+                    int output=1+(int)playerDelayTime_[mapEntry.first];
                     const std::string& message = "Respawn in " +multi_cast<std::string>(output)+ " seconds." ;//Countdown
                     this->gtinfo_->sendFadingMessage(message,it->first->getClientID());
+                }
                 else if (it->second<0.0f)
+                {
                     it->second=timeRemaining+3.0f;//reset punishment-timer
                     if (playerGetLives(it->first)>0)
+                    this->gtinfo_->sendFadingMessage(message,mapEntry.first->getClientID());
+                }
+                else if (mapEntry.second<0.0f)
+                {
+                    mapEntry.second=timeRemaining+3.0f;//reset punishment-timer
+                    if (playerGetLives(mapEntry.first)>0)
+                    {
                         this->punishPlayer(it->first);
                         if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
+                        this->punishPlayer(mapEntry.first);
+                        if (mapEntry.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                             return;
                         const std::string& message = ""; // resets Camper-Warning-message
                         this->gtinfo_->sendFadingMessage(message,it->first->getClientID());
+                        this->gtinfo_->sendFadingMessage(message,mapEntry.first->getClientID());
+                    }
+                }
                 else if (it->second<timeRemaining/5)//Warning message
+                {
                     if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
+                else if (mapEntry.second<timeRemaining/5)//Warning message
+                {
+                    if (mapEntry.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     const std::string& message = "Camper Warning! Don't forget to shoot.";
                     this->gtinfo_->sendFadingMessage(message,it->first->getClientID());
+                    this->gtinfo_->sendFadingMessage(message,mapEntry.first->getClientID());
+                }
+            }

code/trunk/src/orxonox/gametypes/LastManStanding.h

-                      r9667
+                      r11071
             bool bHardPunishment; //!< Switches between damage and death as punishment.
             float punishDamageRate; //!< Makes Damage adjustable.
             virtual void spawnDeadPlayersIfRequested(); //!< Prevents dead players to respawn.
+            virtual void spawnDeadPlayersIfRequested() override; //!< Prevents dead players to respawn.
             virtual int getMinLives(); //!< Returns minimum of each player's lives; players with 0 lives are skipped;
 …
             void setConfigValues(); //!< Makes values configurable.
             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0); //!< If a player shoot's an opponent, his punishment countdown will be resetted.
             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0); //!< Manages each players lives.
+            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr) override; //!< If a player shoot's an opponent, his punishment countdown will be resetted.
+            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr) override; //!< Manages each players lives.
             virtual void end(); //!< Sends an end message.
+            virtual void end() override; //!< Sends an end message.
             int playerGetLives(PlayerInfo* player); //!< getFunction for the map "playerLives_".
             int getNumPlayersAlive() const; //!< Returns the number of players that are still alive.
             virtual void playerEntered(PlayerInfo* player); //!< Initializes values.
             virtual bool playerLeft(PlayerInfo* player); //!< Manages all local variables.
             virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn); //!< Resets punishment time and respawn delay.
+            virtual void playerEntered(PlayerInfo* player) override; //!< Initializes values.
+            virtual bool playerLeft(PlayerInfo* player) override; //!< Manages all local variables.
+            virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn) override; //!< Resets punishment time and respawn delay.
             void punishPlayer(PlayerInfo* player); //!< Function in order to kill a player. Punishment for hiding longer than "timeRemaining".
             void tick (float dt); //!< used to end the game
+            virtual void tick (float dt) override; //!< used to end the game
     };
+}

code/trunk/src/orxonox/gametypes/LastTeamStanding.cc

-                      r9941
+                      r11071
     void LastTeamStanding::spawnDeadPlayersIfRequested()
+    {
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
             if (it->second.state_ == PlayerState::Dead)
+            {
                 bool alive = (0 < playerLives_[it->first]&&(inGame_[it->first]));
                 if (alive&&(it->first->isReadyToSpawn() || this->bForceSpawn_))
+                {
                     this->spawnPlayer(it->first);
+        for (const auto& mapEntry : this->players_)
+            if (mapEntry.second.state_ == PlayerState::Dead)
+            {
+                bool alive = (0 < playerLives_[mapEntry.first]&&(inGame_[mapEntry.first]));
+                if (alive&&(mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                {
+                    this->spawnPlayer(mapEntry.first);
+                }
+            }
 …
                 this->end();
+            }
             for (std::map<PlayerInfo*, float>::iterator it = this->timeToAct_.begin(); it != this->timeToAct_.end(); ++it)
+            {
                 if (playerGetLives(it->first) <= 0)//Players without lives shouldn't be affected by time.
+            for (auto& mapEntry : this->timeToAct_)
+            {
+                if (playerGetLives(mapEntry.first) <= 0)//Players without lives shouldn't be affected by time.
                     continue;
                 it->second -= dt;//Decreases punishment time.
                 if (!inGame_[it->first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
+                {
                     playerDelayTime_[it->first] -= dt;
                     if (playerDelayTime_[it->first] <= 0)
                     this->inGame_[it->first] = true;
                     if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
+                mapEntry.second -= dt;//Decreases punishment time.
+                if (!inGame_[mapEntry.first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
+                {
+                    playerDelayTime_[mapEntry.first] -= dt;
+                    if (playerDelayTime_[mapEntry.first] <= 0)
+                    this->inGame_[mapEntry.first] = true;
+                    if (mapEntry.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     int output = 1 + (int)playerDelayTime_[it->first];
+                    int output = 1 + (int)playerDelayTime_[mapEntry.first];
                     const std::string& message = "Respawn in " +multi_cast<std::string>(output)+ " seconds." ;//Countdown
                     this->gtinfo_->sendFadingMessage(message,it->first->getClientID());
+                }
                 else if (it->second < 0.0f)
+                {
                     it->second = timeRemaining + 3.0f;//reset punishment-timer
                     if (playerGetLives(it->first) > 0)
+                    this->gtinfo_->sendFadingMessage(message,mapEntry.first->getClientID());
+                }
+                else if (mapEntry.second < 0.0f)
+                {
+                    mapEntry.second = timeRemaining + 3.0f;//reset punishment-timer
+                    if (playerGetLives(mapEntry.first) > 0)
+                    {
                         this->punishPlayer(it->first);
                         if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                        this->punishPlayer(mapEntry.first);
+                        if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                             return;
                         const std::string& message = ""; // resets Camper-Warning-message
                         this->gtinfo_->sendFadingMessage(message, it->first->getClientID());
+                        this->gtinfo_->sendFadingMessage(message, mapEntry.first->getClientID());
+                    }
+                }
                 else if (it->second < timeRemaining/5)//Warning message
+                {
                   if (it->first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
+                else if (mapEntry.second < timeRemaining/5)//Warning message
+                {
+                  if (mapEntry.first->getClientID()== NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     const std::string& message = "Camper Warning! Don't forget to shoot.";
                     this->gtinfo_->sendFadingMessage(message, it->first->getClientID());
+                    this->gtinfo_->sendFadingMessage(message, mapEntry.first->getClientID());
+                }
+            }
 …
         int party = -1;
         //find a player who survived
         for (std::map<PlayerInfo*, int>::iterator it = this->playerLives_.begin(); it != this->playerLives_.end(); ++it)
+        {
           if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+        for (const auto& mapEntry : this->playerLives_)
+        {
+          if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
             if (it->second > 0)//a player that is alive
+            if (mapEntry.second > 0)//a player that is alive
+            {
                 //which party has survived?
                 std::map<PlayerInfo*, int>::iterator it2 = this->teamnumbers_.find(it->first);
+                std::map<PlayerInfo*, int>::iterator it2 = this->teamnumbers_.find(mapEntry.first);
                 if (it2 != this->teamnumbers_.end())
+                {
 …
+    {
         int min = lives;
         for (std::map<PlayerInfo*, int>::iterator it = this->playerLives_.begin(); it != this->playerLives_.end(); ++it)
+        {
             if (it->second <= 0)
+        for (const auto& mapEntry : this->playerLives_)
+        {
+            if (mapEntry.second <= 0)
                 continue;
             if (it->second < lives)
                 min = it->second;
+            if (mapEntry.second < lives)
+                min = mapEntry.second;
+        }
         return min;

code/trunk/src/orxonox/gametypes/LastTeamStanding.h

-                      r9667
+                      r11071
             std::map<PlayerInfo*, bool> inGame_; //!< Indicates each Player's state.
             virtual void spawnDeadPlayersIfRequested(); //!< Prevents dead players to respawn.
+            virtual void spawnDeadPlayersIfRequested() override; //!< Prevents dead players to respawn.
             virtual int getMinLives(); //!< Returns minimum of each player's lives; players with 0 lives are skipped;
 …
             virtual ~LastTeamStanding(); //!< Default Destructor.
             virtual void playerEntered(PlayerInfo* player); //!< Initializes values.
             virtual bool playerLeft(PlayerInfo* player); //!< Manages all local variables.
+            virtual void playerEntered(PlayerInfo* player) override; //!< Initializes values.
+            virtual bool playerLeft(PlayerInfo* player) override; //!< Manages all local variables.
             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0); //!< Manages each player's lost lives.
             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0); //!< If a player shoot's an opponent, his punishment countdown will be resetted.
             virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn); //!< Resets punishment time and respawn delay.
             void tick (float dt); //!< used to end the game
             virtual void end(); //!< Sends an end message.
+            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr) override; //!< Manages each player's lost lives.
+            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr) override; //!< If a player shoot's an opponent, his punishment countdown will be resetted.
+            virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn) override; //!< Resets punishment time and respawn delay.
+            virtual void tick (float dt) override; //!< used to end the game
+            virtual void end() override; //!< Sends an end message.
             void punishPlayer(PlayerInfo* player); //!< Function in order to kill a player. Punishment for hiding longer than "timeRemaining".
             int playerGetLives(PlayerInfo* player); //!< getFunction for the map "playerLives_".

code/trunk/src/orxonox/gametypes/Mission.cc

r10624	r11071
101	101	void Mission::setTeams()
102	102	{ //Set pawn-colours
103		for (~~ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it~~)
	103	for (Pawn* pawn : ObjectList<Pawn>())
104	104	{
105		~~Pawn* pawn = static_cast<Pawn>(it);~~
106	105	if (!pawn)
107	106	continue;
…	…
111	110	void Mission::endMission(bool accomplished)
112	111	{
113		for (~~ObjectList<Mission>::iterator it = ObjectList<Mission>::begin(); it != ObjectList<Mission>::end(); ++it~~)
	112	for (Mission* mission : ObjectList<Mission>())
114	113	{ //TODO: make sure that only the desired mission is ended !! This is a dirty HACK, that would end ALL missions!
115		it->setMissionAccomplished(accomplished);
116		it->end();
	114	mission->setMissionAccomplished(accomplished);
	115	mission->end();
117	116	}
118	117	}
…	…
120	119	void Mission::setLivesWrapper(unsigned int amount)
121	120	{
122		for (~~ObjectList<Mission>::iterator it = ObjectList<Mission>::begin(); it != ObjectList<Mission>::end(); ++it~~)
	121	for (Mission* mission : ObjectList<Mission>())
123	122	{ //TODO: make sure that only the desired mission is ended !! This is a dirty HACK, that would affect ALL missions!
124		it->setLives(amount);
	123	mission->setLives(amount);
125	124	}
126	125	}

code/trunk/src/orxonox/gametypes/Mission.h

-                      r9729
+                      r11071
             virtual ~Mission() {}
             virtual void tick(float dt);
+            virtual void tick(float dt) override;
             virtual void start();
             virtual void end();
+            virtual void start() override;
+            virtual void end() override;
             virtual void setTeams();
             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
             inline void setLives(unsigned int amount)
                 {this->lives_ = amount;}
 …
         protected:
             virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
+            virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr) override;
             bool missionAccomplished_; //<! indicates if player successfully finsihed the mission;
             int lives_; //<! amount of player's lives <-> nr. of retries

code/trunk/src/orxonox/gametypes/TeamBaseMatch.cc

-                      r9667
+                      r11071
         int amountControlled2 = 0;
         for (std::set<TeamBaseMatchBase*>::const_iterator it = this->bases_.begin(); it != this->bases_.end(); ++it)
+        {
             if((*it)->getState() == BaseState::ControlTeam1)
+        for (TeamBaseMatchBase* base : this->bases_)
+        {
+            if(base->getState() == BaseState::ControlTeam1)
+            {
                 amountControlled++;
+            }
             if((*it)->getState() == BaseState::ControlTeam2)
+            if(base->getState() == BaseState::ControlTeam2)
+            {
                 amountControlled2++;
 …
+            }
             for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
+            {
                 if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+            for (const auto& mapEntry : this->teamnumbers_)
+            {
+                if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                     continue;
                 if (it->second == winningteam)
                     this->gtinfo_->sendAnnounceMessage("You have won the match!", it->first->getClientID());
+                if (mapEntry.second == winningteam)
+                    this->gtinfo_->sendAnnounceMessage("You have won the match!", mapEntry.first->getClientID());
                 else
                     this->gtinfo_->sendAnnounceMessage("You have lost the match!", it->first->getClientID());
+                    this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
+            }
 …
         int count = 0;
         for (std::set<TeamBaseMatchBase*>::const_iterator it = this->bases_.begin(); it != this->bases_.end(); ++it)
+        {
             if ((*it)->getState() == BaseState::ControlTeam1 && team == 0)
+        for (TeamBaseMatchBase* base : this->bases_)
+        {
+            if (base->getState() == BaseState::ControlTeam1 && team == 0)
                 count++;
             if ((*it)->getState() == BaseState::ControlTeam2 && team == 1)
+            if (base->getState() == BaseState::ControlTeam2 && team == 1)
                 count++;
+        }
 …
+    {
         unsigned int i = 0;
         for (std::set<TeamBaseMatchBase*>::const_iterator it = this->bases_.begin(); it != this->bases_.end(); ++it)
+        for (TeamBaseMatchBase* base : this->bases_)
+        {
             i++;
             if (i > index)
                 return (*it);
+        }
         return 0;
+                return base;
+        }
+        return nullptr;
+    }

code/trunk/src/orxonox/gametypes/TeamBaseMatch.h

-                      r9667
+                      r11071
             virtual ~TeamBaseMatch() {}
             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator);
+            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr) override;
+            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator) override;
             virtual void playerScored(PlayerInfo* player, int score = 1);
+            virtual void playerScored(PlayerInfo* player, int score = 1) override;
             virtual void showPoints();
             virtual void endGame();

code/trunk/src/orxonox/gametypes/TeamDeathmatch.cc

r9941	r11071
69	69	int winnerTeam = 0;
70	70	int highestScore = 0;
71		for (~~std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it~~)
	71	for (const auto& mapEntry : this->players_)
72	72	{
73		if ( this->getTeamScore(~~it->~~first) > highestScore )
	73	if ( this->getTeamScore(mapEntry.first) > highestScore )
74	74	{
75		winnerTeam = this->getTeam(~~it->~~first);
76		highestScore = this->getTeamScore(~~it->~~first);
	75	winnerTeam = this->getTeam(mapEntry.first);
	76	highestScore = this->getTeamScore(mapEntry.first);
77	77	}
78	78	}

code/trunk/src/orxonox/gametypes/TeamDeathmatch.h

-                      r9941
+                      r11071
             void setConfigValues();
             virtual void start();
             virtual void end();
             virtual void playerEntered(PlayerInfo* player);
             virtual bool playerLeft(PlayerInfo* player);
             virtual bool playerChangedName(PlayerInfo* player);
+            virtual void start() override;
+            virtual void end() override;
+            virtual void playerEntered(PlayerInfo* player) override;
+            virtual bool playerLeft(PlayerInfo* player) override;
+            virtual bool playerChangedName(PlayerInfo* player) override;
             virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
             virtual void playerScored(PlayerInfo* player, int score = 1);
+            virtual void pawnKilled(Pawn* victim, Pawn* killer = nullptr) override;
+            virtual void playerScored(PlayerInfo* player, int score = 1) override;
        protected:
             int maxScore_;

code/trunk/src/orxonox/gametypes/TeamGametype.cc

-                      r9941
+                      r11071
     void TeamGametype::playerEntered(PlayerInfo* player)
+    {
         if(player == NULL) return; // catch null pointers
+        if(player == nullptr) return; // catch null pointers
         Gametype::playerEntered(player);
         this->findAndSetTeam(player);
 …
     void TeamGametype::findAndSetTeam(PlayerInfo* player)
+    {
         if(player == NULL) return; // catch null pointers
+        if(player == nullptr) return; // catch null pointers
         std::vector<unsigned int> playersperteam(this->teams_, 0);
         for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
             if (it->second < static_cast<int>(this->teams_) && it->second >= 0)
                 playersperteam[it->second]++;
+        for (const auto& mapEntry : this->teamnumbers_)
+            if (mapEntry.second < static_cast<int>(this->teams_) && mapEntry.second >= 0)
+                playersperteam[mapEntry.second]++;
         unsigned int minplayers = static_cast<unsigned int>(-1);
 …
         if( (this->players_.size() >= maxPlayers_) && (allowedInGame_[player] == true) ) // if there's a "waiting list"
+        {
             for (std::map<PlayerInfo*, bool>::iterator it = this->allowedInGame_.begin(); it != this->allowedInGame_.end(); ++it)
+            {
                  if(it->second == false) // waiting player found
                  {it->second = true; break;} // allow player to enter
+            for (auto& mapEntry : this->allowedInGame_)
+            {
+                 if(mapEntry.second == false) // waiting player found
+                 {mapEntry.second = true; break;} // allow player to enter
+            }
+        }
 …
     void TeamGametype::spawnDeadPlayersIfRequested()
+    {
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)\
+        {
             if(allowedInGame_[it->first] == false)//check if dead player is allowed to enter
+        for (const auto& mapEntry : this->players_)\
+        {
+            if(allowedInGame_[mapEntry.first] == false)//check if dead player is allowed to enter
+            {
                 continue;
+            }
             if (it->second.state_ == PlayerState::Dead)
+            {
                 if ((it->first->isReadyToSpawn() || this->bForceSpawn_))
+            if (mapEntry.second.state_ == PlayerState::Dead)
+            {
+                if ((mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                {
                    this->spawnPlayer(it->first);
+                   this->spawnPlayer(mapEntry.first);
+                }
+            }
 …
         if(!player || this->getTeam(player) == -1)
             return 0;
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+        {
             if ( this->getTeam(it->first) ==  this->getTeam(player) )
+            {
                 teamscore += it->second.frags_;
+        for (const auto& mapEntry : this->players_)
+        {
+            if ( this->getTeam(mapEntry.first) ==  this->getTeam(player) )
+            {
+                teamscore += mapEntry.second.frags_;
+            }
+        }
 …
+    {
         int teamSize = 0;
         for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
+        {
             if (it->second == team)
+        for (const auto& mapEntry : this->teamnumbers_)
+        {
+            if (mapEntry.second == team)
                 teamSize++;
+        }
 …
+    {
         int teamSize = 0;
         for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
+        {
             if (it->second == team  && it->first->isHumanPlayer())
+        for (const auto& mapEntry : this->teamnumbers_)
+        {
+            if (mapEntry.second == team  && mapEntry.first->isHumanPlayer())
                 teamSize++;
+        }
 …
+        }
         SpawnPoint* fallbackSpawnPoint = NULL;
+        SpawnPoint* fallbackSpawnPoint = nullptr;
         if (teamSpawnPoints.size() > 0)
+        {
 …
             unsigned int index = 0;
             // Get random fallback spawnpoint in case there is no active SpawnPoint.
             for (std::set<SpawnPoint*>::const_iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); ++it)
+            for (SpawnPoint* teamSpawnPoint : teamSpawnPoints)
+            {
                 if (index == randomspawn)
+                {
                     fallbackSpawnPoint = (*it);
+                    fallbackSpawnPoint = teamSpawnPoint;
                     break;
+                }
 …
             randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
             index = 0;
             for (std::set<SpawnPoint*>::const_iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); ++it)
+            for (SpawnPoint* teamSpawnPoint : teamSpawnPoints)
+            {
                 if (index == randomspawn)
                     return (*it);
+                    return teamSpawnPoint;
                 ++index;
 …
+        }
         return 0;
+        return nullptr;
+    }
 …
     void TeamGametype::setDefaultObjectColour(Pawn* pawn)
+    {
         if(pawn == NULL)
+        if(pawn == nullptr)
             return;
 …
         ControllableEntity* entity = orxonox_cast<ControllableEntity*>(pawn);
         Controller* controller = 0;
+        Controller* controller = nullptr;
         if (entity->getController())
             controller = entity->getController();
 …
         ArtificialController* artificial =  orxonox_cast<ArtificialController*>(controller);
         //get Teamnumber - get the data
         if(artificial == NULL)
+        if(artificial == nullptr)
             return;
         teamnumber= artificial->getTeam();
 …
     void TeamGametype::colourPawn(Pawn* pawn, int teamNr)
     {// catch: no-colouring-case and wrong input
         if(teamNr < 0 || teamNr+1 > int(this->teamcolours_.size()) ||pawn == NULL) return;
+        if(teamNr < 0 || teamNr+1 > int(this->teamcolours_.size()) ||pawn == nullptr) return;
         pawn->setRadarObjectColour(this->teamcolours_[teamNr]);
         std::set<WorldEntity*> pawnAttachments = pawn->getAttachedObjects();
         for (std::set<WorldEntity*>::iterator it = pawnAttachments.begin(); it != pawnAttachments.end(); ++it)
+        {
             if ((*it)->isA(Class(TeamColourable)))
+            {
                 TeamColourable* tc = orxonox_cast<TeamColourable*>(*it);
+        for (WorldEntity* pawnAttachment : pawnAttachments)
+        {
+            if (pawnAttachment->isA(Class(TeamColourable)))
+            {
+                TeamColourable* tc = orxonox_cast<TeamColourable*>(pawnAttachment);
                 tc->setTeamColour(this->teamcolours_[teamNr]);
+            }
 …
     void TeamGametype::announceTeamWin(int winnerTeam)
+    {
         for (std::map<PlayerInfo*, int>::iterator it3 = this->teamnumbers_.begin(); it3 != this->teamnumbers_.end(); ++it3)
+        {
             if (it3->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+        for (const auto& mapEntry : this->teamnumbers_)
+        {
+            if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
             if (it3->second == winnerTeam)
+            {
                 this->gtinfo_->sendAnnounceMessage("Your team has won the match!", it3->first->getClientID());
+            if (mapEntry.second == winnerTeam)
+            {
+                this->gtinfo_->sendAnnounceMessage("Your team has won the match!", mapEntry.first->getClientID());
+            }
             else
+            {
                 this->gtinfo_->sendAnnounceMessage("Your team has lost the match!", it3->first->getClientID());
+                this->gtinfo_->sendAnnounceMessage("Your team has lost the match!", mapEntry.first->getClientID());
+            }
+        }

code/trunk/src/orxonox/gametypes/TeamGametype.h

-                      r9941
+                      r11071
             void setConfigValues();
             virtual void playerEntered(PlayerInfo* player);
+            virtual void playerEntered(PlayerInfo* player) override;
             virtual void findAndSetTeam(PlayerInfo* player);
             virtual bool playerLeft(PlayerInfo* player);
             virtual void spawnDeadPlayersIfRequested(); //!< Prevents players to respawn.
+            virtual bool playerLeft(PlayerInfo* player) override;
+            virtual void spawnDeadPlayersIfRequested() override; //!< Prevents players to respawn.
             virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
+            virtual bool allowPawnHit(Pawn* victim, Pawn* originator = nullptr) override;
+            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr) override;
+            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr) override;
             virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn);
+            virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn) override;
 …
         protected:
             virtual SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;
+            virtual SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const override;
             bool pawnsAreInTheSameTeam(Pawn* pawn1, Pawn* pawn2);

code/trunk/src/orxonox/gametypes/UnderAttack.cc

-                      r9941
+                      r11071
         this->gameTime_ = 180;
         this->teams_ = 2;
         this->destroyer_ = 0;
+        this->destroyer_ = nullptr;
         this->destroyer_.setCallback(createFunctor(&UnderAttack::killedDestroyer, this));
         this->gameEnded_ = false;
 …
         this->gameEnded_ = true;
         for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
+        {
             if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+        for (const auto& mapEntry : this->teamnumbers_)
+        {
+            if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
             if (it->second == attacker_)
                 this->gtinfo_->sendAnnounceMessage("You have won the match!", it->first->getClientID());
+            if (mapEntry.second == attacker_)
+                this->gtinfo_->sendAnnounceMessage("You have won the match!", mapEntry.first->getClientID());
             else
                 this->gtinfo_->sendAnnounceMessage("You have lost the match!", it->first->getClientID());
+                this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
+        }
+    }
 …
                 ChatManager::message(message);
                 for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
+                {
                     if (it->first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                for (const auto& mapEntry : this->teamnumbers_)
+                {
+                    if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                         continue;
                     if (it->second == 1)
                         this->gtinfo_->sendAnnounceMessage("You have won the match!", it->first->getClientID());
+                    if (mapEntry.second == 1)
+                        this->gtinfo_->sendAnnounceMessage("You have won the match!", mapEntry.first->getClientID());
                     else
                         this->gtinfo_->sendAnnounceMessage("You have lost the match!", it->first->getClientID());
+                        this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
+                }
+            }
 …
     void UnderAttack::setTransporterHealth()
+    {
         if (this->destroyer_ != 0)
+        if (this->destroyer_ != nullptr)
+        {
             //Calculation: Each attacker deals about 3500 damage. A human attacker deals 1500 damage additionally.

code/trunk/src/orxonox/gametypes/UnderAttack.h

-                      r9941
+                      r11071
             void setConfigValues();
             void tick (float dt);
+            virtual void tick (float dt) override;
             void addDestroyer(Destroyer* destroyer);
             inline Destroyer* getDestroyer() const
                 { return this->destroyer_; }
             virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
             virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
             virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
             virtual void playerEntered(PlayerInfo* player);
+            virtual bool allowPawnHit(Pawn* victim, Pawn* originator = nullptr) override;
+            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = nullptr) override;
+            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = nullptr) override;
+            virtual void playerEntered(PlayerInfo* player) override;
         protected:

code/trunk/src/orxonox/graphics/AnimatedModel.h

-                      r9667
+                      r11071
             virtual ~AnimatedModel();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void registerVariables();
 …
             virtual void setAnimEnabled(bool enabled);
             virtual void setAnimLoop(bool loop);
             virtual void tick(float dt);
+            virtual void tick(float dt) override;
             virtual void changedMesh();

code/trunk/src/orxonox/graphics/Backlight.cc

-                      r9667
+                      r11071
         RegisterObject(Backlight);
         this->ribbonTrail_ = 0;
         this->ribbonTrailNode_ = 0;
+        this->ribbonTrail_ = nullptr;
+        this->ribbonTrailNode_ = nullptr;
         this->width_ = 0;

code/trunk/src/orxonox/graphics/Backlight.h

-                      r9667
+                      r11071
             virtual ~Backlight();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void tick(float dt);
             virtual void changedVisibility();
+            virtual void tick(float dt) override;
+            virtual void changedVisibility() override;
             inline void setWidth(float width)
 …
                 { return this->trailmaterial_; }
             virtual void changedScale();
+            virtual void changedScale() override;
         protected:
             virtual void changedTimeFactor(float factor_new, float factor_old);
+            virtual void changedTimeFactor(float factor_new, float factor_old) override;
         private:
             void registerVariables();
             virtual void startturnonoff();
             virtual void stopturnonoff();
             virtual void poststopturnonoff();
             virtual void changedColour();
+            virtual void startturnonoff() override;
+            virtual void stopturnonoff() override;
+            virtual void poststopturnonoff() override;
+            virtual void changedColour() override;
             void update_width();
             void update_lifetime();

code/trunk/src/orxonox/graphics/Billboard.cc

r9667	r11071
139	139	{
140	140	Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
141		if( bSet != ~~NULL~~ )
	141	if( bSet != nullptr )
142	142	{
143	143	bSet->setBillboardType(bbt);
…	…
148	148	{
149	149	Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
150		if( bSet != ~~NULL~~ )
	150	if( bSet != nullptr )
151	151	{
152	152	bSet->setCommonDirection( vec );
…	…
157	157	{
158	158	Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
159		if( bSet != ~~NULL~~ )
	159	if( bSet != nullptr )
160	160	{
161	161	bSet->setCommonUpVector( vec );
…	…
166	166	{
167	167	Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
168		if( bSet != ~~NULL~~ )
	168	if( bSet != nullptr )
169	169	{
170	170	bSet->setDefaultDimensions(width, height);

code/trunk/src/orxonox/graphics/Billboard.h

-                      r9667
+                      r11071
             virtual ~Billboard();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void changedVisibility();
+            virtual void changedVisibility() override;
             inline const BillboardSet& getBillboardSet() const
 …
             virtual void setTeamColour(const ColourValue& colour)
+            virtual void setTeamColour(const ColourValue& colour) override
                 { this->setColour(colour); }

code/trunk/src/orxonox/graphics/BlinkingBillboard.h

-                      r9667
+                      r11071
             virtual ~BlinkingBillboard();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void tick(float dt);
+            virtual void tick(float dt) override;
             inline void setAmplitude(float amplitude)

code/trunk/src/orxonox/graphics/Camera.h

-                      r9667
+                      r11071
             void setConfigValues();
             virtual void tick(float dt);
+            virtual void tick(float dt) override;
             void requestFocus();
 …
             void configvaluecallback_changedNearClipDistance();
             void windowResized(unsigned int newWidth, unsigned int newHeight);
+            virtual void windowResized(unsigned int newWidth, unsigned int newHeight) override;
             Ogre::Camera*    camera_;

code/trunk/src/orxonox/graphics/FadingBillboard.h

-                      r9667
+                      r11071
             virtual ~FadingBillboard();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void tick(float dt);
             virtual void changedActivity();
             virtual void changedVisibility();
+            virtual void tick(float dt) override;
+            virtual void changedActivity() override;
+            virtual void changedVisibility() override;
             inline void setTurnOnTime(float turnontime)
 …
             virtual void stopturnonoff();
             virtual void poststopturnonoff();
             virtual void changedColour();
+            virtual void changedColour() override;
             float turnontime_;

code/trunk/src/orxonox/graphics/GlobalShader.h

-                      r9667
+                      r11071
             virtual ~GlobalShader();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void changedVisibility();
+            virtual void changedVisibility() override;
             inline const Shader& getShader() const

code/trunk/src/orxonox/graphics/Light.cc

-                      r9667
+                      r11071
 #include <OgreSceneManager.h>
 #include <OgreLight.h>
-#include <boost/static_assert.hpp>
 #include "util/StringUtils.h"
 …
     // Be sure we don't do bad conversions
     BOOST_STATIC_ASSERT((int)Ogre::Light::LT_POINT       == (int)Light::Point);
     BOOST_STATIC_ASSERT((int)Ogre::Light::LT_DIRECTIONAL == (int)Light::Directional);
     BOOST_STATIC_ASSERT((int)Ogre::Light::LT_SPOTLIGHT   == (int)Light::Spotlight);
+    static_assert((int)Ogre::Light::LT_POINT       == (int)Light::Type::Point,       "check enum");
+    static_assert((int)Ogre::Light::LT_DIRECTIONAL == (int)Light::Type::Directional, "check enum");
+    static_assert((int)Ogre::Light::LT_SPOTLIGHT   == (int)Light::Type::Spotlight,   "check enum");
     Light::Light(Context* context) : StaticEntity(context)
 …
         RegisterObject(Light);
         this->light_ = 0;
+        this->light_ = nullptr;
         this->diffuse_ = ColourValue::White;
         this->specular_ = ColourValue::White;
         this->type_ = Light::Point;
+        this->type_ = Type::Point;
         this->attenuation_ = Vector4(100000, 1, 0, 0);
         this->spotlightRange_ = Vector3(40.0f, 30.0f, 1.0f);
 …
     void Light::registerVariables()
+    {
         registerVariable((int&)this->type_,     VariableDirection::ToClient, new NetworkCallback<Light>(this, &Light::updateType));
+        registerVariable(this->type_,           VariableDirection::ToClient, new NetworkCallback<Light>(this, &Light::updateType));
         registerVariable(this->diffuse_,        VariableDirection::ToClient, new NetworkCallback<Light>(this, &Light::updateDiffuseColour));
         registerVariable(this->specular_,       VariableDirection::ToClient, new NetworkCallback<Light>(this, &Light::updateSpecularColour));
 …
     void Light::updateAttenuation()
+    {
         if (this->light_ && this->type_ != Light::Directional)
+        if (this->light_ && this->type_ != Type::Directional)
             this->light_->setAttenuation(this->attenuation_.x, this->attenuation_.y, this->attenuation_.z, this->attenuation_.w);
+    }
 …
     void Light::updateSpotlightRange()
+    {
         if (this->light_ && this->type_ == Light::Spotlight)
+        if (this->light_ && this->type_ == Type::Spotlight)
             this->light_->setSpotlightRange(Degree(this->spotlightRange_.x), Degree(this->spotlightRange_.y), this->spotlightRange_.z);
+    }
 …
+    {
         if (type == "point")
             this->setType(Light::Point);
+            this->setType(Type::Point);
         else if (type == "directional")
             this->setType(Light::Directional);
+            this->setType(Type::Directional);
         else if (type == "spotlight")
             this->setType(Light::Spotlight);
+            this->setType(Type::Spotlight);
         else
             this->setType(Light::Point);
+            this->setType(Type::Point);
+    }
 …
         switch (this->type_)
+        {
             case Light::Directional:
+            case Type::Directional:
                 return "directional";
             case Light::Spotlight:
+            case Type::Spotlight:
                 return "spotlight";
             case Light::Point:
+            case Type::Point:
             default:
                 return "point";
 …
             this->light_->setType(static_cast<Ogre::Light::LightTypes>(this->type_));
             if (this->type_ != Light::Directional)
+            if (this->type_ != Type::Directional)
                 this->updateAttenuation();
             if (this->type_ == Light::Spotlight)
+            if (this->type_ == Type::Spotlight)
                 this->updateSpotlightRange();
+        }

code/trunk/src/orxonox/graphics/Light.h

-                      r9667
+                      r11071
+    {
         public:
             enum LightTypes // Copy from the Ogre enum
+            enum class Type // Copy from the Ogre enum
+            {
                 /// Point light sources give off light equally in all directions, so require only position not direction
 …
             virtual ~Light();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void changedVisibility();
+            virtual void changedVisibility() override;
             inline Ogre::Light* getLight()
                 { return this->light_; }
             inline void setType(Light::LightTypes type)
+            inline void setType(Light::Type type)
                 { this->type_ = type; this->updateType(); }
             inline Light::LightTypes getType() const
+            inline Light::Type getType() const
                 { return this->type_; }
 …
                 { return this->specular_; }
             virtual void setTeamColour(const ColourValue& colour)
+            virtual void setTeamColour(const ColourValue& colour) override
                 { this->setDiffuseColour(colour); this->setSpecularColour(colour); }
 …
             Ogre::Light* light_;
             LightTypes type_;
+            Light::Type type_;
             ColourValue diffuse_;
             ColourValue specular_;

code/trunk/src/orxonox/graphics/MeshLodInformation.h

r9667	r11071
50	50	float getReductionRate(){ return this->reductionRate_; }
51	51
52		virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
	52	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
53	53
54	54	private:

code/trunk/src/orxonox/graphics/Model.cc

-                      r10728
+                      r11071
             Level* level = this->getLevel();
             assert( level != 0 );
+            assert( level != nullptr );
             MeshLodInformation* lodInfo = level->getLodInfo(this->meshSrc_);
 …
                 BaseObject* creatorPtr = this;
                 while(creatorPtr!=NULL&&orxonox_cast<WorldEntity*>(creatorPtr))
+                while(creatorPtr!=nullptr&&orxonox_cast<WorldEntity*>(creatorPtr))
+                {
                     scaleFactor *= getBiggestScale(((WorldEntity*) creatorPtr)->getScale3D());

code/trunk/src/orxonox/graphics/Model.h

-                      r9667
+                      r11071
             void setConfigValues();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void changedVisibility();
+            virtual void changedVisibility() override;
             inline const Mesh& getMesh() const

code/trunk/src/orxonox/graphics/ParticleEmitter.cc

-                      r9950
+                      r11071
             ThrowException(AbortLoading, "Can't create ParticleEmitter, no scene or no scene manager given.");
         this->particles_ = 0;
+        this->particles_ = nullptr;
         this->LOD_ = LODParticle::Normal;
 …
+        {
             delete this->particles_;
             this->particles_ = 0;
+            this->particles_ = nullptr;
+        }

code/trunk/src/orxonox/graphics/ParticleEmitter.h

-                      r9950
+                      r11071
             virtual ~ParticleEmitter();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void changedVisibility();
             virtual void changedActivity();
+            virtual void changedVisibility() override;
+            virtual void changedActivity() override;
             inline ParticleInterface* getParticleInterface() const

code/trunk/src/orxonox/graphics/ParticleSpawner.h

-                      r9667
+                      r11071
             virtual ~ParticleSpawner();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+            virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode) override;
             inline void stop(bool bDestroy)

code/trunk/src/orxonox/infos/Bot.h

-                      r9667
+                      r11071
             void setConfigValues();
             inline bool isInitialized() const
+            virtual inline bool isInitialized() const override
                 { return true; }
             inline float getPing() const
+            virtual inline float getPing() const override
                 { return 0; }
             inline float getPacketLossRatio() const
+            virtual inline float getPacketLossRatio() const override
                 { return 0; }

code/trunk/src/orxonox/infos/GametypeInfo.cc

r10624	r11071
291	291	if(GameMode::isMaster())
292	292	{
293		NotificationListener::sendNotification("Press [Fire] to respawn", GametypeInfo::NOTIFICATION_SENDER, ~~notificationMessageType::info, n~~otificationSendMode::network, player->getClientID());
	293	NotificationListener::sendNotification("Press [Fire] to respawn", GametypeInfo::NOTIFICATION_SENDER, NotificationMessageType::info, NotificationSendMode::network, player->getClientID());
294	294	// Remove the player from the list of players that have spawned, since it currently is not.
295	295	this->spawnedPlayers_.erase(player);
…	…
346	346	// Display "Press [Fire] to start the match" if the game has not yet ended.
347	347	if(!this->hasEnded())
348		NotificationListener::sendNotification("Press [Fire] to start the match", GametypeInfo::NOTIFICATION_SENDER, ~~notificationMessageType::info, n~~otificationSendMode::network, player->getClientID());
	348	NotificationListener::sendNotification("Press [Fire] to start the match", GametypeInfo::NOTIFICATION_SENDER, NotificationMessageType::info, NotificationSendMode::network, player->getClientID());
349	349	// Else display "Game has ended".
350	350	else
351		NotificationListener::sendNotification("Game has ended", GametypeInfo::NOTIFICATION_SENDER, ~~notificationMessageType::info, n~~otificationSendMode::network, player->getClientID());
	351	NotificationListener::sendNotification("Game has ended", GametypeInfo::NOTIFICATION_SENDER, NotificationMessageType::info, NotificationSendMode::network, player->getClientID());
352	352	}
353	353	}
…	…
461	461	void GametypeInfo::dispatchAnnounceMessage(const std::string& message) const
462	462	{
463		for (~~ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it~~)
464		it->announcemessage(this, message);
	463	for (GametypeMessageListener* listener : ObjectList<GametypeMessageListener>())
	464	listener->announcemessage(this, message);
465	465	}
466	466
467	467	void GametypeInfo::dispatchKillMessage(const std::string& message) const
468	468	{
469		for (~~ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it~~)
470		it->killmessage(this, message);
	469	for (GametypeMessageListener* listener : ObjectList<GametypeMessageListener>())
	470	listener->killmessage(this, message);
471	471	}
472	472
473	473	void GametypeInfo::dispatchDeathMessage(const std::string& message) const
474	474	{
475		for (~~ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it~~)
476		it->deathmessage(this, message);
	475	for (GametypeMessageListener* listener : ObjectList<GametypeMessageListener>())
	476	listener->deathmessage(this, message);
477	477	}
478	478
479	479	void GametypeInfo::dispatchStaticMessage(const std::string& message, const ColourValue& colour) const
480	480	{
481		for (~~ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it~~)
482		it->staticmessage(this, message, colour);
	481	for (GametypeMessageListener* listener : ObjectList<GametypeMessageListener>())
	482	listener->staticmessage(this, message, colour);
483	483	}
484	484
485	485	void GametypeInfo::dispatchFadingMessage(const std::string& message) const
486	486	{
487		for (~~ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it~~)
488		it->fadingmessage(this, message);
	487	for (GametypeMessageListener* listener : ObjectList<GametypeMessageListener>())
	488	listener->fadingmessage(this, message);
489	489	}
490	490	}

code/trunk/src/orxonox/infos/HumanPlayer.cc

r10624	r11071
53	53	this->defaultController_ = Class(NewHumanController);
54	54
55		this->humanHud_ = 0;
56		this->gametypeHud_ = 0;
	55	this->humanHud_ = nullptr;
	56	this->gametypeHud_ = nullptr;
57	57
58	58	this->setConfigValues();
…	…
178	178	{
179	179	this->humanHud_->destroy();
180		this->humanHud_ = 0;
	180	this->humanHud_ = nullptr;
181	181	}
182	182
…	…
194	194	{
195	195	this->gametypeHud_->destroy();
196		this->gametypeHud_ = 0;
	196	this->gametypeHud_ = nullptr;
197	197	}
198	198

code/trunk/src/orxonox/infos/HumanPlayer.h

-                      r10624
+                      r11071
             void setConfigValues();
             bool isInitialized() const;
             float getPing() const;
             float getPacketLossRatio() const;
+            virtual bool isInitialized() const override;
+            virtual float getPing() const override;
+            virtual float getPacketLossRatio() const override;
             void setClientID(unsigned int clientID);
             virtual void switchGametype(Gametype* gametype);
+            virtual void switchGametype(Gametype* gametype) override;
             inline void setHumanHUDTemplate(const std::string& name)

code/trunk/src/orxonox/infos/PlayerInfo.cc

-                      r11052
+                      r11071
         this->bReadyToSpawn_ = false;
         this->bSetUnreadyAfterSpawn_ = true;
         this->controller_ = 0;
         this->controllableEntity_ = 0;
+        this->controller_ = nullptr;
+        this->controllableEntity_ = nullptr;
         this->controllableEntityID_ = OBJECTID_UNKNOWN;
         this->gtinfo_ = 0;
+        this->gtinfo_ = nullptr;
         this->gtinfoID_ = OBJECTID_UNKNOWN;
         this->updateGametypeInfo(this->getGametype());
 …
+            {
                 this->controller_->destroy();
                 this->controller_ = 0;
+                this->controller_ = nullptr;
+            }
 …
     void PlayerInfo::updateGametypeInfo(Gametype* gametype)
+    {
         this->gtinfo_ = 0;
+        this->gtinfo_ = nullptr;
         this->gtinfoID_ = OBJECTID_UNKNOWN;
 …
+        {
             this->controller_->destroy();
             this->controller_ = 0;
+            this->controller_ = nullptr;
+        }
         this->controller_ = this->defaultController_.fabricate(this->getContext());
 …
         RadarViewable* radarviewable = orxonox_cast<RadarViewable*>(entity);
         if (radarviewable != NULL)
+        if (radarviewable != nullptr)
             radarviewable->setRadarName(this->getName());
+    }
 …
             return;
         this->controllableEntity_->setController(0);
         this->controllableEntity_ = 0;
+        this->controllableEntity_->setController(nullptr);
+        this->controllableEntity_ = nullptr;
         this->controllableEntityID_ = OBJECTID_UNKNOWN;
         if (this->controller_)
             this->controller_->setControllableEntity(0);
+            this->controller_->setControllableEntity(nullptr);
         if ( GameMode::isMaster() )
 …
         Controller* tmp =this->controllableEntity_->getController();
         if (tmp == NULL)
+        {
             orxout(verbose) <<  "PlayerInfo: pauseControl, Controller is NULL " << endl;
+        if (tmp == nullptr)
+        {
+            orxout(verbose) <<  "PlayerInfo: pauseControl, Controller is nullptr " << endl;
             return;
+        }
         tmp->setActive(false);
         //this->controllableEntity_->getController()->setControllableEntity(NULL);
         this->controllableEntity_->setController(0);
+        //this->controllableEntity_->getController()->setControllableEntity(nullptr);
+        this->controllableEntity_->setController(nullptr);
+    }
 …
         ControllableEntity* entity = this->controllableEntity_;
         assert(this->controllableEntity_ != NULL);
+        assert(this->controllableEntity_ != nullptr);
         if( !entity || this->previousControllableEntity_.size() == 0 )
             return;
 …
         entity->destroyHud(); // HACK-ish
         this->controllableEntity_->setController(0);
+        this->controllableEntity_->setController(nullptr);
         if(this->isHumanPlayer()) // TODO: Multiplayer?
             this->controllableEntity_->destroyHud(); // HACK-ish
 …
         do {
             this->controllableEntity_ = this->previousControllableEntity_.back();
         } while(this->controllableEntity_ == NULL && this->previousControllableEntity_.size() > 0);
+        } while(this->controllableEntity_ == nullptr && this->previousControllableEntity_.size() > 0);
         this->controllableEntityID_ = this->controllableEntity_->getObjectID();
         this->previousControllableEntity_.pop_back();
         if ( this->controllableEntity_ != NULL && this->controller_ != NULL)
+        if ( this->controllableEntity_ != nullptr && this->controller_ != nullptr)
             this->controller_->setControllableEntity(this->controllableEntity_);
          // HACK-ish
         if(this->controllableEntity_ != NULL && this->isHumanPlayer())
+        if(this->controllableEntity_ != nullptr && this->isHumanPlayer())
             this->controllableEntity_->createHud();

code/trunk/src/orxonox/infos/PlayerInfo.h

-                      r10624
+                      r11071
             virtual ~PlayerInfo();
             virtual void changedName();
+            virtual void changedName() override;
             virtual void switchGametype(Gametype* gametype);
 …
             Controller* controller_;
             ControllableEntity* controllableEntity_;
             std::vector< WeakPtr<ControllableEntity> > previousControllableEntity_; //!< List of the previous ControllableEntities if repeatedly startTemporary control was called. The ControllableEntity at the back is the most recent.
+            std::vector<WeakPtr<ControllableEntity>> previousControllableEntity_; //!< List of the previous ControllableEntities if repeatedly startTemporary control was called. The ControllableEntity at the back is the most recent.
             unsigned int controllableEntityID_;

code/trunk/src/orxonox/interfaces/NotificationListener.cc

r10624	r11071
74	74	The type of the notification, can be either 'info' or 'important'.
75	75	*/
76		/static/ void NotificationListener::sendNetworkHelper(const std::string& message, const std::string& sender, ~~notificationSendMode::Value sendMode, unsigned int clientId, bool isCommand, notificationMessageType::Valu~~e messageType)
	76	/static/ void NotificationListener::sendNetworkHelper(const std::string& message, const std::string& sender, NotificationSendMode sendMode, unsigned int clientId, bool isCommand, NotificationMessageType messageType)
77	77	{
78	78	// If we're in standalone mode or we're already no the right client we create and send the notification/command.
79		if(GameMode::isStandalone() \|\| sendMode == ~~notificationSendMode::local \|\| (sendMode == n~~otificationSendMode::network && Host::getPlayerID() == clientId))
	79	if(GameMode::isStandalone() \|\| sendMode == NotificationSendMode::local \|\| (sendMode == NotificationSendMode::network && Host::getPlayerID() == clientId))
80	80	{
81	81	sendHelper(message, sender, isCommand, messageType);
82	82	}
83	83	// If we're on the server (and the server is not the intended recipient of the notification/command) we send it over the network.
84		else if(GameMode::isServer() && sendMode == notificationSendMode::network && Host::getPlayerID() != clientId)
	84	else if(GameMode::isServer() && sendMode == NotificationSendMode::network && Host::getPlayerID() != clientId)
85	85	{
86		callStaticNetworkFunction(&NotificationListener::sendHelper, clientId, message, sender, isCommand, ~~(unsigned int)~~messageType);
	86	callStaticNetworkFunction(&NotificationListener::sendHelper, clientId, message, sender, isCommand, messageType);
87	87	}
88		else if(GameMode::isServer() && sendMode == notificationSendMode::broadcast)
	88	else if(GameMode::isServer() && sendMode == NotificationSendMode::broadcast)
89	89	{
90	90	// TODO: Works as intended?
91		callStaticNetworkFunction(&NotificationListener::sendHelper, NETWORK_PEER_ID_BROADCAST, message, sender, isCommand, ~~(unsigned int)~~messageType);
	91	callStaticNetworkFunction(&NotificationListener::sendHelper, NETWORK_PEER_ID_BROADCAST, message, sender, isCommand, messageType);
92	92	}
93	93	}
…	…
105	105	The type of the notification.
106	106	*/
107		/static/ void NotificationListener::sendHelper(const std::string& message, const std::string& sender, bool isCommand, ~~unsigned int messageT~~ype)
	107	/static/ void NotificationListener::sendHelper(const std::string& message, const std::string& sender, bool isCommand, NotificationMessageType type)
108	108	{
109	109	// Iterate through all NotificationListeners and notify them by calling the method they overloaded.
110		for(~~ObjectList<NotificationListener>::iterator it = ObjectList<NotificationListener>::begin(); it != ObjectList<NotificationListener>::end(); ++it~~)
	110	for(NotificationListener* listener : ObjectList<NotificationListener>())
111	111	{
112	112	// If the notification is a message.
113	113	if(!isCommand)
114		~~it->registerNotification(message, sender, notificationMessageType::Value(messageType)~~);
	114	listener->registerNotification(message, sender, type);
115	115
116	116	// If the notification is a command.
117	117	if(isCommand)
118	118	{
119		~~notificationCommand::Value~~ command = str2Command(message);
120		if(command != notificationCommand::none)
121		it->executeCommand(command, sender);
	119	NotificationCommand command = str2Command(message);
	120	if(command != NotificationCommand::none)
	121	listener->executeCommand(command, sender);
122	122	}
123	123	}
…	…
130	130	The string to be converted.
131	131	@return
132		Returns the corresponding enum, notificationCommand::none if the command doesn't exist.
	132	Returns the corresponding enum, NotificationCommand::none if the command doesn't exist.
133	133	*/
134		/static/ ~~notificationCommand::Value~~ NotificationListener::str2Command(const std::string& string)
	134	/static/ NotificationCommand NotificationListener::str2Command(const std::string& string)
135	135	{
136		~~notificationCommand::Value command = n~~otificationCommand::none;
	136	NotificationCommand command = NotificationCommand::none;
137	137
138	138	if(string == NotificationListener::COMMAND_CLEAR)
139		command = notificationCommand::clear;
	139	command = NotificationCommand::clear;
140	140
141	141	return command;
…	…
150	150	Returns the corresponding string.
151	151	*/
152		/static/ const std::string& NotificationListener::command2Str(~~notificationCommand::Value~~ command)
	152	/static/ const std::string& NotificationListener::command2Str(NotificationCommand command)
153	153	{
154	154	switch(command)
155	155	{
156		case notificationCommand::clear:
	156	case NotificationCommand::clear:
157	157	return NotificationListener::COMMAND_CLEAR;
158	158	default:

code/trunk/src/orxonox/interfaces/NotificationListener.h

-                      r9667
+                      r11071
+{
     // TODO: Document.
+    namespace notificationMessageType
+    {
+        enum Value {
+            info,
+            important
+        };
+    }
+    enum class NotificationMessageType {
+        info,
+        important
+    };
+    namespace notificationSendMode
+    {
+        enum Value {
+            local,
+            network,
+            broadcast
+        };
+    }
+    enum class NotificationSendMode {
+        local,
+        network,
+        broadcast
+    };
+    namespace notificationCommand
+    {
+        enum Value {
+            none,
+            clear
+        };
+    }
+    enum class NotificationCommand {
+        none,
+        clear
+    };
     // TODO: Update doc.
 …
             @param sender The sender that sent the notification. Default is 'none'.
             @param messageType The type of the message, can be either 'info' or 'important'. Default is 'info'.
             @param sendMode The mode in which the notification is sent, can be 'local' to send the notification to the client where this function is executed, 'network' if the notification is to be sent to the client with the specified clientID, or 'broadcast' if the notification should be sent to all hosts. Default is notificationSendMode::local.
+            @param sendMode The mode in which the notification is sent, can be 'local' to send the notification to the client where this function is executed, 'network' if the notification is to be sent to the client with the specified clientID, or 'broadcast' if the notification should be sent to all hosts. Default is NotificationSendMode::local.
             @param clientId The id of the client the notification should be sent to. Default is 0.
             */
             static void sendNotification(const std::string& message, const std::string& sender = NotificationListener::NONE, notificationMessageType::Value messageType = notificationMessageType::info, notificationSendMode::Value sendMode = notificationSendMode::local, unsigned int clientId = 0)
+            static void sendNotification(const std::string& message, const std::string& sender = NotificationListener::NONE, NotificationMessageType messageType = NotificationMessageType::info, NotificationSendMode sendMode = NotificationSendMode::local, unsigned int clientId = 0)
                 { NotificationListener::sendNetworkHelper(message, sender, sendMode, clientId, false, messageType); }
             /**
 …
             @param command The command that should be sent (and later executed).
             @param sender The sender that sent the notification. Default is 'none'.
             @param sendMode The mode in which the command is sent, can be 'local' to send the command to the client where this function is executed, 'network' if the command is to be sent to the client with the specified clientID, or 'broadcast' if the command should be sent to all hosts. Default is notificationSendMode::local.
+            @param sendMode The mode in which the command is sent, can be 'local' to send the command to the client where this function is executed, 'network' if the command is to be sent to the client with the specified clientID, or 'broadcast' if the command should be sent to all hosts. Default is NotificationSendMode::local.
             @param clientId The id of the client the command should be sent to. Default is 0.
             */
             static void sendCommand(const std::string& command, const std::string& sender = NotificationListener::NONE, notificationSendMode::Value sendMode = notificationSendMode::local, unsigned int clientId = 0)
+            static void sendCommand(const std::string& command, const std::string& sender = NotificationListener::NONE, NotificationSendMode sendMode = NotificationSendMode::local, unsigned int clientId = 0)
                 { NotificationListener::sendNetworkHelper(command, sender, sendMode, clientId, true); }
             static void sendHelper(const std::string& message, const std::string& sender, bool isCommand = false, unsigned int messageMode = 0); // Helper method to register a notification/execute a command with all NotificationListeners after it has been sent over the network.
+            static void sendHelper(const std::string& message, const std::string& sender, bool isCommand, NotificationMessageType type); // Helper method to register a notification/execute a command with all NotificationListeners after it has been sent over the network.
             //TODO: Make protected?
 …
             @return Returns true if the notification was successfully registered, false if not.
             */
             virtual bool registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
+            virtual bool registerNotification(const std::string& message, const std::string& sender, NotificationMessageType type)
                 { return false; }
             /**
 …
             @return Returns true if the command was successfully executed, false if not.
             */
             virtual bool executeCommand(notificationCommand::Value command, const std::string& sender) { return false; }
+            virtual bool executeCommand(NotificationCommand command, const std::string& sender) { return false; }
         public:
 …
         protected:
             static void sendNetworkHelper(const std::string& message, const std::string& sender, notificationSendMode::Value sendMode, unsigned int clientId, bool isCommand = false, notificationMessageType::Value messageType = notificationMessageType::info); // Helper method to send both notifications and commands over the network.
+            static void sendNetworkHelper(const std::string& message, const std::string& sender, NotificationSendMode sendMode, unsigned int clientId, bool isCommand = false, NotificationMessageType messageType = NotificationMessageType::info); // Helper method to send both notifications and commands over the network.
             static notificationCommand::Value str2Command(const std::string& string); // Helper method. Converts a string into the enum for a command.
             static const std::string& command2Str(notificationCommand::Value command); // Helper method. Converts a command enum into its corresponding string.
+            static NotificationCommand str2Command(const std::string& string); // Helper method. Converts a string into the enum for a command.
+            static const std::string& command2Str(NotificationCommand command); // Helper method. Converts a command enum into its corresponding string.
     };
+}

code/trunk/src/orxonox/interfaces/PickupCarrier.cc

-                      r10624
+                      r11071
         // Go recursively through all children to check whether they are a target.
         std::vector<PickupCarrier*>* children = this->getCarrierChildren();
         for(std::vector<PickupCarrier*>::const_iterator it = children->begin(); it != children->end(); it++)
+        for(PickupCarrier* carrier : *children)
+        {
             if((*it)->isTarget(pickup))
+            if(carrier->isTarget(pickup))
+            {
                 isTarget = true;
 …
+    {
         if(!this->isTarget(pickup))
             return NULL;
+            return nullptr;
         if(pickup->isTarget(this)) // If the PickupCarrier itself is a target.
             return this;
         PickupCarrier* target = NULL;
+        PickupCarrier* target = nullptr;
         // Go recursively through all children to check whether they are the target.
         std::vector<PickupCarrier*>* children = this->getCarrierChildren();
         for(std::vector<PickupCarrier*>::iterator it = children->begin(); it != children->end(); it++)
+        for(PickupCarrier* child : *children)
+        {
             if(pickup->isTarget(*it))
+            if(pickup->isTarget(child))
+            {
                 target = *it;
+                target = child;
                 break;
+            }

code/trunk/src/orxonox/interfaces/PickupCarrier.h

-                      r9667
+                      r11071
         But this structure has to be established first.
         - <b>getCarrierChildren()</b> To this end a PickupCarrier needs to implement getCarrierChildren() which returns a list of its direct PickupCarrier children. If you need an example, have a look at @ref orxonox::Pawn "Pawn" and @ref orxonox::Engine "Engine".
         - <b>getCarrierParent()</b> This is the method in the other direction. It returns the parent of this PickupCarrier, or NULL if the PickupCarrier is a root node in this hierarchy.
+        - <b>getCarrierParent()</b> This is the method in the other direction. It returns the parent of this PickupCarrier, or nullptr if the PickupCarrier is a root node in this hierarchy.
     @author
 …
             PickupCarrier(); //!< Constructor.
             virtual ~PickupCarrier(); //!< Destructor.
             void preDestroy(void); //!< Is called before the PickupCarrier is effectively destroyed.
+            virtual void preDestroy(void) override; //!< Is called before the PickupCarrier is effectively destroyed.
             bool isTarget(const Pickupable* pickup) const; //!< Can be used to check whether the PickupCarrier or a child of his is a target ot the input Pickupable.

code/trunk/src/orxonox/interfaces/PickupListener.cc

-                      r10624
+                      r11071
         // Iterate through all PickupListeners and notify them by calling the method they overloaded.
         for(ObjectList<PickupListener>::iterator it = ObjectList<PickupListener>::begin(); it != ObjectList<PickupListener>::end(); ++it)
             it->pickupChangedUsed(pickup, used);
+        for(PickupListener* listener : ObjectList<PickupListener>())
+            listener->pickupChangedUsed(pickup, used);
+    }
 …
         // Iterate through all PickupListeners and notify them by calling the method they overloaded.
         for(ObjectList<PickupListener>::iterator it = ObjectList<PickupListener>::begin(); it != ObjectList<PickupListener>::end(); ++it)
             it->pickupChangedPickedUp(pickup, pickedUp);
+        for(PickupListener* listener : ObjectList<PickupListener>())
+            listener->pickupChangedPickedUp(pickup, pickedUp);
+    }

code/trunk/src/orxonox/interfaces/Pickupable.cc

-                      r10624
+                      r11071
         RegisterObject(Pickupable);
         this->carrier_ = NULL;
+        this->carrier_ = nullptr;
         this->beingDestroyed_ = false;
 …
     bool Pickupable::isTarget(const PickupCarrier* carrier) const
+    {
         if(carrier == NULL)
+        if(carrier == nullptr)
             return false;
 …
+    {
         // Iterate through all targets of this Pickupable.
         for(std::list<Identifier*>::const_iterator it = this->targets_.begin(); it != this->targets_.end(); it++)
+        for(Identifier* target : this->targets_)
+        {
             if(identifier->isA(*it))
+            if(identifier->isA(target))
                 return true;
+        }
 …
     bool Pickupable::pickup(PickupCarrier* carrier)
+    {
         if(carrier == NULL || this->isPickedUp()) // If carrier is NULL or the Pickupable is already picked up.
+        if(carrier == nullptr || this->isPickedUp()) // If carrier is nullptr or the Pickupable is already picked up.
             return false;
 …
             return false;
         assert(this->getCarrier()); // The Carrier cannot be NULL at this point.
+        assert(this->getCarrier()); // The Carrier cannot be nullptr at this point.
         if(!this->getCarrier()->removePickup(this)) //TODO Shouldn't this be a little later?
             orxout(internal_warning, context::pickups) << "Pickupable (&" << this << ", " << this->getIdentifier()->getName() << ") is being dropped, but it was not present in the PickupCarriers list of pickups." << endl;
 …
             created = this->createSpawner();
         this->setCarrier(NULL);
+        this->setCarrier(nullptr);
         if(!created && createSpawner) // If a PickupSpawner should have been created but wasn't.
 …
         orxout(verbose, context::pickups) << "Pickupable (&" << this << ") changed Carrier (& " << carrier << ")." << endl;
         if(carrier != NULL && tell)
+        if(carrier != nullptr && tell)
+        {
             if(!carrier->addPickup(this))

code/trunk/src/orxonox/interfaces/Pickupable.h

-                      r10624
+                      r11071
         protected:
             virtual void preDestroy(void); //!< A method that is called by Destroyable::destroy() before the object is actually destroyed.
+            virtual void preDestroy(void) override; //!< A method that is called by Destroyable::destroy() before the object is actually destroyed.
             virtual void destroyPickup(void); //!< Destroys a Pickupable.
             virtual void carrierDestroyed(void); //!< Is called by the PickupCarrier when it is being destroyed.
 …
         // For implementing the Rewardable interface:
         public:
             virtual bool reward(PlayerInfo* player); //!< Method to transcribe a Pickupable as a Rewardable to the player.
+            virtual bool reward(PlayerInfo* player) override; //!< Method to transcribe a Pickupable as a Rewardable to the player.
     };

code/trunk/src/orxonox/interfaces/RadarViewable.cc

r10624	r11071
49	49	, wePtr_(wePtr)
50	50	, radarObjectCamouflage_(0.0f)
51		, radarObjectShape_(Dot)
	51	, radarObjectShape_(Shape::Dot)
52	52	, radarObjectDescription_("staticObject")
53	53	, scale_(1.0f)

code/trunk/src/orxonox/interfaces/RadarViewable.h

r10624	r11071
49	49	{
50	50	public:
51		enum Shape
	51	enum class Shape
52	52	{
53	53	Square,
…	…
66	66	if (name == "HIDDEN")
67	67	{
68		this->bVisibility_ = 0;
	68	this->bVisibility_ = false;
69	69	this->settingsChanged();
70	70	}

code/trunk/src/orxonox/items/Engine.cc

-                      r9667
+                      r11071
         RegisterObject(Engine);
         this->ship_ = 0;
+        this->ship_ = nullptr;
         this->shipID_ = OBJECTID_UNKNOWN;
         this->relativePosition_ = Vector3::ZERO;
 …
     void Engine::networkcallback_shipID()
+    {
         this->ship_ = 0;
+        this->ship_ = nullptr;
         if (this->shipID_ != OBJECTID_UNKNOWN)
 …
     void Engine::run(float dt)
+    {
         if (this->ship_ == NULL)
+        if (this->ship_ == nullptr)
+        {
             if (this->shipID_ != 0)
 …
                 this->networkcallback_shipID();
                 if (this->ship_ == NULL)
+                if (this->ship_ == nullptr)
                     return;
+            }

code/trunk/src/orxonox/items/Engine.h

-                      r9667
+                      r11071
             virtual ~Engine();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void setConfigValues();
 …
             /**
             @brief Get the SpaceShip this Engine is mounted on.
             @return Returns a pointer to the SpaceShip. NULL if it isn't mounted on any ship.
+            @return Returns a pointer to the SpaceShip. nullptr if it isn't mounted on any ship.
             */
             inline SpaceShip* getShip() const

code/trunk/src/orxonox/items/MultiStateEngine.cc

-                      r9939
+                      r11071
         else
+        {
             this->defEngineSndBoost_ = 0;
             this->defEngineSndNormal_ = 0;
             this->lua_ = 0;
+            this->defEngineSndBoost_ = nullptr;
+            this->defEngineSndNormal_ = nullptr;
+            this->lua_ = nullptr;
+        }
         this->state_ = 0;
 …
+            {
                 // We have no ship, so the effects are not attached and won't be destroyed automatically
                 for (std::vector<EffectContainer*>::const_iterator it = this->effectContainers_.begin(); it != this->effectContainers_.end(); ++it)
                     for (std::vector<WorldEntity*>::const_iterator it2 = (*it)->getEffectsBegin(); it2 != (*it)->getEffectsBegin(); ++it2)
                         (*it2)->destroy();
+                for (EffectContainer* container : this->effectContainers_)
+                    for (WorldEntity* effect : container->getEffects())
+                        effect->destroy();
                 if (this->defEngineSndNormal_)
                     this->defEngineSndNormal_->destroy();
 …
                 this->state_ = 0;
                 if (this->getShip()->isBoosting() && forward)
                     this->state_ = Boost;
+                    this->state_ = EngineState::Boost;
                 else if (forward && !this->state_) // this->state_ == Boost
                     this->state_ = Normal;
+                    this->state_ = EngineState::Normal;
                 else if (direction.z > 0.0 && velocity.z < 0.0)
                     this->state_ = Brake;
+                    this->state_ = EngineState::Brake;
                 else
                     this->state_ = Idle;
                 if (this->state_ == Idle && this->getSpeedAdd() > 0)
                     this->state_ = Normal;
+                    this->state_ = EngineState::Idle;
+                if (this->state_ == EngineState::Idle && this->getSpeedAdd() > 0)
+                    this->state_ = EngineState::Normal;
+            }
 …
                 float pitch = velocity.length();
                 if (this->state_ & Normal)
+                if (this->state_ & EngineState::Normal)
                     defEngineSndNormal_->setPitch(clamp(pitch/MAX_VELOCITY_NORMAL + 1, 0.5f, 2.0f));
                 if (this->state_ & Boost)
+                if (this->state_ & EngineState::Boost)
                     defEngineSndBoost_->setPitch(clamp(pitch/MAX_VELOCITY_BOOST + 1, 0.5f, 2.0f));
                 if (changes & Idle)
+                {
                     lua_pushboolean(this->lua_->getInternalLuaState(), this->state_ & Idle);
+                if (changes & EngineState::Idle)
+                {
+                    lua_pushboolean(this->lua_->getInternalLuaState(), this->state_ & EngineState::Idle);
                     lua_setglobal(this->lua_->getInternalLuaState(), "idle");
+                }
                 if (changes & Normal)
+                {
                     lua_pushboolean(this->lua_->getInternalLuaState(), this->state_ & Normal);
+                if (changes & EngineState::Normal)
+                {
+                    lua_pushboolean(this->lua_->getInternalLuaState(), this->state_ & EngineState::Normal);
                     lua_setglobal(this->lua_->getInternalLuaState(), "normal");
                     if (this->state_ & Normal)
+                    if (this->state_ & EngineState::Normal)
                         defEngineSndNormal_->play();
                     else
                         defEngineSndNormal_->stop();
+                }
                 if (changes & Brake)
+                {
                     lua_pushboolean(this->lua_->getInternalLuaState(), this->state_ & Brake);
+                if (changes & EngineState::Brake)
+                {
+                    lua_pushboolean(this->lua_->getInternalLuaState(), this->state_ & EngineState::Brake);
                     lua_setglobal(this->lua_->getInternalLuaState(), "brake");
+                }
                 if (changes & Boost)
+                {
                     lua_pushboolean(this->lua_->getInternalLuaState(), this->state_ & Boost);
+                if (changes & EngineState::Boost)
+                {
+                    lua_pushboolean(this->lua_->getInternalLuaState(), this->state_ & EngineState::Boost);
                     lua_setglobal(this->lua_->getInternalLuaState(), "boost");
                     if (this->state_ & Boost)
+                    if (this->state_ & EngineState::Boost)
                         defEngineSndBoost_->play();
                     else
 …
                 // Update all effect conditions
                 for (std::vector<EffectContainer*>::const_iterator it = this->effectContainers_.begin(); it != this->effectContainers_.end(); ++it)
                     (*it)->updateCondition();
+                for (EffectContainer* container : this->effectContainers_)
+                    container->updateCondition();
+            }
+        }
 …
             this->getShip()->attach(defEngineSndBoost_);
         for (std::vector<EffectContainer*>::const_iterator it = this->effectContainers_.begin(); it != this->effectContainers_.end(); ++it)
             for (std::vector<WorldEntity*>::const_iterator it2 = (*it)->getEffectsBegin(); it2 != (*it)->getEffectsEnd(); ++it2)
                 this->getShip()->attach(*it2);
+    }
     void MultiStateEngine::addEffectContainer(EffectContainer* effect)
+    {
         if (effect == NULL)
+        for (EffectContainer* container : this->effectContainers_)
+            for (WorldEntity* effect : container->getEffects())
+                this->getShip()->attach(effect);
+    }
+    void MultiStateEngine::addEffectContainer(EffectContainer* container)
+    {
+        if (container == nullptr)
             return;
         effect->setLuaState(this->lua_, 'f' + multi_cast<std::string>(this->effectContainers_.size()));
         this->effectContainers_.push_back(effect);
+        container->setLuaState(this->lua_, 'f' + multi_cast<std::string>(this->effectContainers_.size()));
+        this->effectContainers_.push_back(container);
         if (this->getShip())
+        {
             for (std::vector<WorldEntity*>::const_iterator it = effect->getEffectsBegin(); it != effect->getEffectsBegin(); ++it)
                 this->getShip()->attach(*it);
+            for (WorldEntity* effect : container->getEffects())
+                this->getShip()->attach(effect);
+        }
+    }
 …
+    {
         unsigned int i = 0;
         for (std::vector<EffectContainer*>::const_iterator it = this->effectContainers_.begin(); it != this->effectContainers_.end(); ++it)
+        for (EffectContainer* effectContainer : this->effectContainers_)
+        {
             if (i == index)
+                return (*it);
+        }
+        return NULL;
+                return effectContainer;
+            i++;
+        }
+        return nullptr;
+    }

code/trunk/src/orxonox/items/MultiStateEngine.h

-                      r9667
+                      r11071
+    {
         public:
             enum EngineState
+            struct EngineState
+            {
                 Idle    = 1,
                 Normal  = 2,
                 Brake   = 4,
                 Boost   = 8
+                static constexpr int Idle    = 1;
+                static constexpr int Normal  = 2;
+                static constexpr int Brake   = 4;
+                static constexpr int Boost   = 8;
             };
 …
             virtual ~MultiStateEngine();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void run(float dt);
+            virtual void run(float dt) override;
             virtual void addToSpaceShip(SpaceShip* ship);
+            virtual void addToSpaceShip(SpaceShip* ship) override;
             void addEffectContainer(EffectContainer* effect);

code/trunk/src/orxonox/items/PartDestructionEvent.cc

r10262	r11071
98	98	{
99	99	switch (this->targetParam_) {
100		case shieldhealth:
	100	case TargetParam::shieldhealth:
101	101	this->parent_->getParent()->setShieldHealth(operate(this->parent_->getParent()->getShieldHealth()));
102	102	break;
103		case boostpower:
	103	case TargetParam::boostpower:
104	104	this->parent_->getParent()->setInitialBoostPower(operate(this->parent_->getParent()->getInitialBoostPower()));
105	105	break;
106		case boostpowerrate:
	106	case TargetParam::boostpowerrate:
107	107	this->parent_->getParent()->setBoostPowerRate(operate(this->parent_->getParent()->getBoostPowerRate()));
108	108	break;
109		case rotationthrust:
	109	case TargetParam::rotationthrust:
110	110	this->parent_->getParent()->setRotationThrust(operate(this->parent_->getParent()->getRotationThrust()));
111	111	break;
…	…
120	120	{
121	121	switch (this->targetParam_) {
122		case null:
	122	case TargetParam::null:
123	123	this->parent_->getParent()->getEngineByName(targetName_)->destroy();
124	124	break;
125		case boostfactor:
	125	case TargetParam::boostfactor:
126	126	this->parent_->getParent()->getEngineByName(targetName_)->setBoostFactor(operate(this->parent_->getParent()->getEngineByName(targetName_)->getBoostFactor()));
127	127	break;
128		case speedfront:
	128	case TargetParam::speedfront:
129	129	this->parent_->getParent()->getEngineByName(targetName_)->setMaxSpeedFront(operate(this->parent_->getParent()->getEngineByName(targetName_)->getMaxSpeedFront()));
130	130	break;
131		case accelerationfront:
	131	case TargetParam::accelerationfront:
132	132	this->parent_->getParent()->getEngineByName(targetName_)->setAccelerationFront(operate(this->parent_->getParent()->getEngineByName(targetName_)->getAccelerationFront()));
133	133	break;
…	…
142	142	{
143	143	switch (this->targetParam_) {
144		case null:
	144	case TargetParam::null:
145	145	if (!this->parent_->getParent()->getShipPartByName(targetName_))
146	146	return;
…	…
214	214	if (param == "NULL")
215	215	{
216		this->targetParam_ = null;
	216	this->targetParam_ = TargetParam::null;
217	217	return;
218	218	}
219	219	if (param == "boostfactor")
220	220	{
221		this->targetParam_ = boostfactor;
	221	this->targetParam_ = TargetParam::boostfactor;
222	222	return;
223	223	}
224	224	if (param == "speedfront")
225	225	{
226		this->targetParam_ = speedfront;
	226	this->targetParam_ = TargetParam::speedfront;
227	227	return;
228	228	}
229	229	if (param == "accelerationfront")
230	230	{
231		this->targetParam_ = accelerationfront;
	231	this->targetParam_ = TargetParam::accelerationfront;
232	232	return;
233	233	}
…	…
244	244	if (param == "shieldhealth")
245	245	{
246		this->targetParam_ = shieldhealth;
	246	this->targetParam_ = TargetParam::shieldhealth;
247	247	return;
248	248	}
249	249	if (param == "boostpower")
250	250	{
251		this->targetParam_ = boostpower;
	251	this->targetParam_ = TargetParam::boostpower;
252	252	return;
253	253	}
254	254	if (param == "boostpowerrate")
255	255	{
256		this->targetParam_ = boostpowerrate;
	256	this->targetParam_ = TargetParam::boostpowerrate;
257	257	return;
258	258	}
259	259	if (param == "rotationthrust")
260	260	{
261		this->targetParam_ = rotationthrust;
	261	this->targetParam_ = TargetParam::rotationthrust;
262	262	return;
263	263	}
…	…
271	271	if (param == "NULL")
272	272	{
273		this->targetParam_ = null;
	273	this->targetParam_ = TargetParam::null;
274	274	return;
275	275	}

code/trunk/src/orxonox/items/PartDestructionEvent.h

-                      r10262
+                      r11071
                     List of all allowed parameters.
                 */
             enum TargetParam
+            enum class TargetParam
+            {
                 shieldhealth,
 …
             virtual ~PartDestructionEvent();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void execute();

code/trunk/src/orxonox/items/ShipPart.cc

-                      r11052
+                      r11071
     ShipPart::ShipPart(Context* context)
         : Item(context), parent_(NULL)
+        : Item(context), parent_(nullptr)
+    {
         RegisterObject(ShipPart);
 …
     void ShipPart::addEntity(StaticEntity* entity)
+    {
         OrxAssert(entity != NULL, "The Entity cannot be NULL.");
+        OrxAssert(entity != nullptr, "The Entity cannot be nullptr.");
         this->entityList_.push_back(entity);
+    }
 …
         Get the i-th StaticEntity of the ShipPart.
     @return
         Returns a pointer to the i-the StaticEntity. NULL if there is no StaticEntity with that index.
+        Returns a pointer to the i-the StaticEntity. nullptr if there is no StaticEntity with that index.
     */
     StaticEntity* ShipPart::getEntity(unsigned int index)
+    {
         if(this->entityList_.size() >= index)
             return NULL;
+            return nullptr;
         else
             return this->entityList_[index];
 …
     @brief
         Check whether the ShipPart has a particular Entity.
     @param engine
+    @param search
         A pointer to the Entity to be checked.
     */
     bool ShipPart::hasEntity(StaticEntity* entity) const
+    {
         for(unsigned int i = 0; i < this->entityList_.size(); i++)
+        {
             if(this->entityList_[i] == entity)
+    bool ShipPart::hasEntity(StaticEntity* search) const
+    {
+        for(StaticEntity* entity : this->entityList_)
+        {
+            if(entity == search)
                 return true;
+        }
 …
     void ShipPart::addDestructionEvent(PartDestructionEvent* event)
+    {
         OrxAssert(event != NULL, "The PartDestructionEvent cannot be NULL.");
+        OrxAssert(event != nullptr, "The PartDestructionEvent cannot be nullptr.");
         event->setParent(this);
         this->eventList_.push_back(event);
 …
         Get the i-th PartDestructionEvent of the ShipPart.
     @return
         Returns a pointer to the i-the PartDestructionEvent. NULL if there is no PartDestructionEvent with that index.
+        Returns a pointer to the i-the PartDestructionEvent. nullptr if there is no PartDestructionEvent with that index.
     */
     PartDestructionEvent* ShipPart::getDestructionEvent(unsigned int index)
+    {
         if(this->eventList_.size() <= index)
             return NULL;
+            return nullptr;
         else
             return this->eventList_[index];
+    }
-    void ShipPart::setDamageAbsorption(float value)
+    {
-        this->damageAbsorption_ = value;
+    }
     void ShipPart::setParent(ModularSpaceShip* ship)
+    {
         this->parent_ = ship;
+    }
-    /**
-    @brief
-        Sets the health of the ShipPart.
-    */
-    void ShipPart::setHealth(float health)
+    {
-        this->health_ = health;
+    }

code/trunk/src/orxonox/items/ShipPart.h

-                      r10624
+                      r11071
             virtual ~ShipPart();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void handleHit(float damage, float healthdamage, float shielddamage, Pawn* originator);
 …
             PartDestructionEvent* getDestructionEvent(unsigned int index);
+            virtual void setDamageAbsorption(float value);
+            inline float getDamageAbsorption()
+            inline void setDamageAbsorption(float value)
+                { this->damageAbsorption_ = value; }
+            inline float getDamageAbsorption() const
                 { return this->damageAbsorption_; }
             void setParent(ModularSpaceShip* ship);
             inline ModularSpaceShip* getParent()
+            inline ModularSpaceShip* getParent() const
                 { return this->parent_; }
             inline void setEventExecution(bool var)
                 { this->eventExecution_ = var; }
             inline bool isEventExecution()
+            inline bool isEventExecution() const
                 { return this->eventExecution_; }
+            virtual void setHealth(float health);
+            inline void setHealth(float health)
+                { this->health_ = health; }
             inline void addHealth(float health)
                 { this->setHealth(this->health_ + health); }

code/trunk/src/orxonox/overlays/GUISheet.h

r9667	r11071
44	44	~GUISheet();
45	45
46		v~~oid XMLPort(Element& xmlelement, XMLPort::Mode mode)~~;
	46	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
47	47
48	48	void show();

code/trunk/src/orxonox/overlays/InGameConsole.cc

-                      r10624
+                      r11071
         : shell_(new Shell("InGameConsole", true))
         , bShowCursor_(false)
         , consoleOverlay_(0)
         , consoleOverlayContainer_(0)
         , consoleOverlayNoise_(0)
         , consoleOverlayCursor_(0)
         , consoleOverlayBorder_(0)
         , consoleOverlayTextAreas_(0)
         , inputState_(0)
+        , consoleOverlay_(nullptr)
+        , consoleOverlayContainer_(nullptr)
+        , consoleOverlayNoise_(nullptr)
+        , consoleOverlayCursor_(nullptr)
+        , consoleOverlayBorder_(nullptr)
+        , consoleOverlayTextAreas_(nullptr)
+        , inputState_(nullptr)
+    {
         RegisterObject(InGameConsole);
 …
                     if (this->consoleOverlayTextAreas_[i])
                         Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->consoleOverlayTextAreas_[i]);
                     this->consoleOverlayTextAreas_[i] = 0;
+                    this->consoleOverlayTextAreas_[i] = nullptr;
+                }
 …
+        {
             delete[] this->consoleOverlayTextAreas_;
             this->consoleOverlayTextAreas_ = 0;
+            this->consoleOverlayTextAreas_ = nullptr;
+        }
 …
             else
+            {
                 inputState_->setMouseHandler(0);
                 inputState_->setJoyStickHandler(0);
+                inputState_->setMouseHandler(nullptr);
+                inputState_->setJoyStickHandler(nullptr);
+            }
+        }
 …
         for (int i = LINES - 1; i > max; --i)
             this->print("", Shell::DebugOutput, i, true);
+            this->print("", Shell::LineType::DebugOutput, i, true);
         for (int i = max; i >= 1; --i)
 …
+    {
         if (LINES > 0)
             this->print(this->shell_->getInput(), Shell::Input, 0);
+            this->print(this->shell_->getInput(), Shell::LineType::Input, 0);
         if (this->shell_->getInput().empty())
 …
     void InGameConsole::executed()
+    {
         this->shell_->addOutput(this->shell_->getInput(), Shell::Command);
+        this->shell_->addOutput(this->shell_->getInput(), Shell::LineType::Command);
+    }
 …
         switch (type)
+        {
             case Shell::Message:
             case Shell::DebugOutput:     colourTop = ColourValue(0.9f, 0.9f, 0.9f); break;
             case Shell::UserError:       colourTop = ColourValue(0.9f, 0.0f, 0.0f); break;
             case Shell::UserWarning:     colourTop = ColourValue(0.9f, 0.5f, 0.0f); break;
             case Shell::UserStatus:      colourTop = ColourValue(0.0f, 0.9f, 0.0f); break;
             case Shell::UserInfo:        colourTop = ColourValue(0.0f, 0.8f, 0.8f); break;
             case Shell::InternalError:   colourTop = ColourValue(0.5f, 0.0f, 0.0f); break;
             case Shell::InternalWarning: colourTop = ColourValue(0.5f, 0.2f, 0.0f); break;
             case Shell::InternalStatus:  colourTop = ColourValue(0.0f, 0.5f, 0.0f); break;
             case Shell::InternalInfo:    colourTop = ColourValue(0.0f, 0.4f, 0.4f); break;
             case Shell::Verbose:         colourTop = ColourValue(0.3f, 0.3f, 0.9f); break;
             case Shell::VerboseMore:     colourTop = ColourValue(0.2f, 0.2f, 0.7f); break;
             case Shell::VerboseUltra:    colourTop = ColourValue(0.1f, 0.1f, 0.5f); break;
             case Shell::Command:         colourTop = ColourValue(0.8f, 0.2f, 0.8f); break;
             case Shell::Hint:            colourTop = ColourValue(0.4f, 0.0f, 0.4f); break;
             case Shell::Input:           colourTop = ColourValue(0.9f, 0.9f, 0.9f); break;
             default:                     colourTop = ColourValue(0.5f, 0.5f, 0.5f); break;
+            case Shell::LineType::Message:
+            case Shell::LineType::DebugOutput:     colourTop = ColourValue(0.9f, 0.9f, 0.9f); break;
+            case Shell::LineType::UserError:       colourTop = ColourValue(0.9f, 0.0f, 0.0f); break;
+            case Shell::LineType::UserWarning:     colourTop = ColourValue(0.9f, 0.5f, 0.0f); break;
+            case Shell::LineType::UserStatus:      colourTop = ColourValue(0.0f, 0.9f, 0.0f); break;
+            case Shell::LineType::UserInfo:        colourTop = ColourValue(0.0f, 0.8f, 0.8f); break;
+            case Shell::LineType::InternalError:   colourTop = ColourValue(0.5f, 0.0f, 0.0f); break;
+            case Shell::LineType::InternalWarning: colourTop = ColourValue(0.5f, 0.2f, 0.0f); break;
+            case Shell::LineType::InternalStatus:  colourTop = ColourValue(0.0f, 0.5f, 0.0f); break;
+            case Shell::LineType::InternalInfo:    colourTop = ColourValue(0.0f, 0.4f, 0.4f); break;
+            case Shell::LineType::Verbose:         colourTop = ColourValue(0.3f, 0.3f, 0.9f); break;
+            case Shell::LineType::VerboseMore:     colourTop = ColourValue(0.2f, 0.2f, 0.7f); break;
+            case Shell::LineType::VerboseUltra:    colourTop = ColourValue(0.1f, 0.1f, 0.5f); break;
+            case Shell::LineType::Command:         colourTop = ColourValue(0.8f, 0.2f, 0.8f); break;
+            case Shell::LineType::Hint:            colourTop = ColourValue(0.4f, 0.0f, 0.4f); break;
+            case Shell::LineType::Input:           colourTop = ColourValue(0.9f, 0.9f, 0.9f); break;
+            default:                               colourTop = ColourValue(0.5f, 0.5f, 0.5f); break;
+        }

code/trunk/src/orxonox/overlays/InGameConsole.h

-                      r10624
+                      r11071
         void setConfigValues();
         void preUpdate(const Clock& time);
         void postUpdate(const Clock& time) { /*no action*/ }
+        virtual void preUpdate(const Clock& time) override;
+        virtual void postUpdate(const Clock& time) override { /*no action*/ }
         static void openConsole();
 …
         void deactivate();
         void linesChanged();
         void lineAdded();
         void inputChanged();
         void cursorChanged();
         void executed();
         void exit();
+        virtual void linesChanged() override;
+        virtual void lineAdded() override;
+        virtual void inputChanged() override;
+        virtual void cursorChanged() override;
+        virtual void executed() override;
+        virtual void exit() override;
         void shiftLines();
 …
         void print(const std::string& text, Shell::LineType type, int index, bool alwaysShift = false);
         void windowResized(unsigned int newWidth, unsigned int newHeight);
+        virtual void windowResized(unsigned int newWidth, unsigned int newHeight) override;
         // config value related

code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc

-                      r11052
+                      r11071
         RegisterObject(OrxonoxOverlay);
         this->owner_ = 0;
         this->group_ = 0;
+        this->owner_ = nullptr;
+        this->group_ = nullptr;
         if (!GameMode::showsGraphics())
 …
         this->angle_ = Degree(0.0);
         this->bCorrectAspect_ = false;
         this->rotState_ = Horizontal;
+        this->rotState_ = RotationState::Horizontal;
         this->angleChanged(); // updates all other values as well
 …
+            {
                 tempAspect = 1.0f / this->windowAspectRatio_;
                 rotState_ = Vertical;
+                rotState_ = RotationState::Vertical;
+            }
             else if (angle > 179 || angle < 1)
+            {
                 tempAspect = this->windowAspectRatio_;
                 rotState_ = Horizontal;
+                rotState_ = RotationState::Horizontal;
+            }
             else
+            {
                 tempAspect = 1.0f;
                 rotState_ = Inbetween;
+                rotState_ = RotationState::Inbetween;
+            }

code/trunk/src/orxonox/overlays/OrxonoxOverlay.h

-                      r11052
+                      r11071
             and in between is everything else.
         */
         enum RotationState
+        enum class RotationState
+        {
             Horizontal,
 …
         virtual ~OrxonoxOverlay();
         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
         virtual void changedName();
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+        virtual void changedName() override;
         //! Shows the overlay with an detour to BaseObject::visibility_
 …
         void setBackgroundColour(ColourValue colour);
         virtual void changedVisibility();
+        virtual void changedVisibility() override;
         inline void setOwner(BaseObject* owner)
 …
         virtual void changedOverlayGroup()
             { this->changedVisibility(); }
         virtual void setZOrder(unsigned short order);
+        void setZOrder(unsigned short order);
     protected:
 …
     private:
         void windowResized(unsigned int newWidth, unsigned int newHeight);
+        virtual void windowResized(unsigned int newWidth, unsigned int newHeight) override;
         static unsigned int hudOverlayCounter_s;   //!< Static counter for hud elements

code/trunk/src/orxonox/overlays/OverlayGroup.cc

r11052	r11071
51	51	{
52	52	ArgumentCompletionList names;
53		for (O~~bjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it~~)
54		names.push_back(ArgumentCompletionListElement(~~it->getName(), getLowercase(it~~->getName())));
	53	for (OverlayGroup* overlayGroup : ObjectList<OverlayGroup>())
	54	names.push_back(ArgumentCompletionListElement(overlayGroup->getName(), getLowercase(overlayGroup->getName())));
55	55	return names;
56	56	}
…	…
69	69	RegisterObject(OverlayGroup);
70	70
71		this->owner_ = 0;
	71	this->owner_ = nullptr;
72	72
73	73	setScale(Vector2(1.0, 1.0));
…	…
77	77	OverlayGroup::~OverlayGroup()
78	78	{
79		for (~~std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it~~)
80		~~(*it)~~->destroy();
	79	for (OrxonoxOverlay* hudElement : hudElements_)
	80	hudElement->destroy();
81	81	this->hudElements_.clear();
82	82	}
…	…
101	101	void OverlayGroup::setScale(const Vector2& scale)
102	102	{
103		for (~~std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it~~)
104		~~(*it)~~->scale(scale / this->scale_);
	103	for (OrxonoxOverlay* hudElement : hudElements_)
	104	hudElement->scale(scale / this->scale_);
105	105	this->scale_ = scale;
106	106	}
…	…
109	109	void OverlayGroup::setScroll(const Vector2& scroll)
110	110	{
111		for (~~std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it~~)
112		~~(*it)~~->scroll(scroll - this->scroll_);
	111	for (OrxonoxOverlay* hudElement : hudElements_)
	112	hudElement->scroll(scroll - this->scroll_);
113	113	this->scroll_ = scroll;
114	114	}
…	…
148	148	if (index < this->hudElements_.size())
149	149	{
150		std::set< ~~StrongPtr<OrxonoxOverlay>~~ >::const_iterator it = hudElements_.begin();
	150	std::set<StrongPtr<OrxonoxOverlay>>::const_iterator it = hudElements_.begin();
151	151	for (unsigned int i = 0; i != index; ++it, ++i)
152	152	;
…	…
154	154	}
155	155	else
156		return 0;
	156	return nullptr;
157	157	}
158	158
…	…
162	162	SUPER( OverlayGroup, changedVisibility );
163	163
164		for (~~std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it~~)
165		~~(*it)~~->changedVisibility(); //inform all Child Overlays that our visibility has changed
	164	for (OrxonoxOverlay* hudElement : hudElements_)
	165	hudElement->changedVisibility(); //inform all Child Overlays that our visibility has changed
166	166	}
167	167
…	…
170	170	this->owner_ = owner;
171	171
172		for (~~std::set< StrongPtr<OrxonoxOverlay> >::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it~~)
173		~~(*it)~~->setOwner(owner);
	172	for (OrxonoxOverlay* hudElement : hudElements_)
	173	hudElement->setOwner(owner);
174	174	}
175	175
…	…
185	185	/static/ void OverlayGroup::toggleVisibility(const std::string& name)
186	186	{
187		for (O~~bjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it~~)
188		{
189		if (~~(*it)~~->getName() == name)
190		~~(it)->setVisible(!((it)~~->isVisible()));
	187	for (OverlayGroup* group : ObjectList<OverlayGroup>())
	188	{
	189	if (group->getName() == name)
	190	group->setVisible(!(group->isVisible()));
191	191	}
192	192	}
…	…
200	200	/static/ void OverlayGroup::show(const std::string& name)
201	201	{
202		for (O~~bjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it~~)
203		{
204		if (~~(*it)~~->getName() == name)
	202	for (OverlayGroup* group : ObjectList<OverlayGroup>())
	203	{
	204	if (group->getName() == name)
205	205	{
206		if(~~(*it)~~->isVisible())
207		~~(*it)~~->changedVisibility();
	206	if(group->isVisible())
	207	group->changedVisibility();
208	208	else
209		~~(it)->setVisible(!((it)~~->isVisible()));
	209	group->setVisible(!(group->isVisible()));
210	210	}
211	211	}
…	…
223	223	/static/ void OverlayGroup::scaleGroup(const std::string& name, float scale)
224	224	{
225		for (O~~bjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it~~)
226		{
227		if (~~(*it)~~->getName() == name)
228		~~(*it)~~->scale(Vector2(scale, scale));
	225	for (OverlayGroup* group : ObjectList<OverlayGroup>())
	226	{
	227	if (group->getName() == name)
	228	group->scale(Vector2(scale, scale));
229	229	}
230	230	}
…	…
241	241	/static/ void OverlayGroup::scrollGroup(const std::string& name, const Vector2& scroll)
242	242	{
243		for (O~~bjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it~~)
244		{
245		if (~~(*it)~~->getName() == name)
246		~~(*it)~~->scroll(scroll);
	243	for (OverlayGroup* group : ObjectList<OverlayGroup>())
	244	{
	245	if (group->getName() == name)
	246	group->scroll(scroll);
247	247	}
248	248	}

code/trunk/src/orxonox/overlays/OverlayGroup.h

-                      r10624
+                      r11071
         ~OverlayGroup();
         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
         static void toggleVisibility(const std::string& name);
 …
         static void scrollGroup(const std::string& name, const Vector2& scroll);
         inline const std::set< StrongPtr<OrxonoxOverlay> >& getOverlays() const
+        inline const std::set<StrongPtr<OrxonoxOverlay>>& getOverlays() const
             { return this->hudElements_; }
         virtual void changedVisibility();
+        virtual void changedVisibility() override;
         void setOwner(BaseObject* owner);
 …
     private:
         std::set< StrongPtr<OrxonoxOverlay> > hudElements_;    //!< Contains all the OrxonoxOverlays of the this group.
+        std::set<StrongPtr<OrxonoxOverlay>> hudElements_;    //!< Contains all the OrxonoxOverlays of the this group.
         Vector2 scale_;                            //!< Current scale (independent of the elements).
         Vector2 scroll_;                           //!< Current scrolling offset.

code/trunk/src/orxonox/sound/AmbientSound.cc

r10624	r11071
92	92	{
93	93	const std::string& path = "ambient/" + mood + '/' + this->ambientSource_;
94		shared_ptr<ResourceInfo> fileInfo = Resource::getInfo(path);
95		if (fileInfo != ~~NULL~~)
	94	std::shared_ptr<ResourceInfo> fileInfo = Resource::getInfo(path);
	95	if (fileInfo != nullptr)
96	96	{
97	97	orxout(user_info) << "Loading ambient sound " << path << "..." << endl; // TODO: make this output internal if we implement sound streaming

code/trunk/src/orxonox/sound/AmbientSound.h

-                      r9939
+                      r11071
         AmbientSound();
         void play();
         bool stop();
         void pause();
+        virtual void play() override;
+        virtual bool stop() override;
+        virtual void pause() override;
         bool setAmbientSource(const std::string& source);
 …
     private:
         void preDestroy();
         float getRealVolume();
         bool moodChanged(const std::string& mood);
+        virtual void preDestroy() override;
+        virtual float getRealVolume() override;
+        virtual bool moodChanged(const std::string& mood) override;
         inline void ambientSourceChanged()
             { this->setAmbientSource(this->ambientSource_); }

code/trunk/src/orxonox/sound/BaseSound.cc

-                      r10624
+                      r11071
         , volume_(0.7)
         , bLooping_(false)
         , state_(Stopped)
+        , state_(State::Stopped)
         , pitch_ (1.0)
+    {
 …
     BaseSound::~BaseSound()
+    {
         if (this->state_ != Stopped)
+        if (this->state_ != State::Stopped)
             this->stop();
         // Release buffer
         if (this->soundBuffer_ != NULL)
+        if (this->soundBuffer_ != nullptr)
+        {
             assert(GameMode::playsSound());
 …
     void BaseSound::doPlay()
+    {
         this->state_ = Playing;
         if (GameMode::playsSound() && this->getSourceState() != AL_PLAYING && this->soundBuffer_ != NULL)
+        this->state_ = State::Playing;
+        if (GameMode::playsSound() && this->getSourceState() != AL_PLAYING && this->soundBuffer_ != nullptr)
+        {
             if (!alIsSource(this->audioSource_))
 …
     bool BaseSound::doStop()
+    {
         this->state_ = Stopped;
+        this->state_ = State::Stopped;
         if (alIsSource(this->audioSource_))
+        {
 …
         if (this->isStopped())
             return;
         this->state_ = Paused;
+        this->state_ = State::Paused;
         if (alIsSource(this->audioSource_))
             alSourcePause(this->audioSource_);
 …
             orxout(internal_warning, context::sound) << "Setting source parameters to 0 failed: "
                                                      << SoundManager::getALErrorString(error) << endl;
         assert(this->soundBuffer_ != NULL);
+        assert(this->soundBuffer_ != nullptr);
         alSourcei(this->audioSource_, AL_BUFFER, this->soundBuffer_->getBuffer());
         if (ALuint error = alGetError())
 …
+        }
         if (this->soundBuffer_ != NULL)
+        if (this->soundBuffer_ != nullptr)
+        {
             if (this->soundBuffer_->getFilename() == source)
 …
         // Get new sound buffer
         this->soundBuffer_ = SoundManager::getInstance().getSoundBuffer(this->source_);
         if (this->soundBuffer_ == NULL)
+        if (this->soundBuffer_ == nullptr)
             return;
 …
         else // No source acquired so far, but might be set to playing or paused
+        {
             State state = static_cast<State>(this->state_); // save
+            State state = this->state_; // save
             if (this->isPlaying() || this->isPaused())
                 doPlay();
             if (state == Paused)
+            {
                 this->state_ = Paused;
+            if (state == State::Paused)
+            {
+                this->state_ = State::Paused;
                 doPause();
+            }
 …
         switch (this->state_)
+        {
             case Playing:
+            case State::Playing:
                 this->play();
                 break;
             case Paused:
+            case State::Paused:
                 this->pause();
                 break;
             case Stopped:
+            case State::Stopped:
             default:
                 this->stop();

code/trunk/src/orxonox/sound/BaseSound.h

-                      r9667
+                      r11071
 #include <string>
 #include <boost/shared_ptr.hpp>
+#include <memory>
 #include <OgreDataStream.h>
 #include "core/object/Listable.h"
 …
         virtual void pause() { this->doPause(); }
         bool isPlaying() const { return this->state_ == Playing; }
         bool isPaused()  const { return this->state_ == Paused; }
         bool isStopped() const { return this->state_ == Stopped; }
+        bool isPlaying() const { return this->state_ == State::Playing; }
+        bool isPaused()  const { return this->state_ == State::Paused; }
+        bool isStopped() const { return this->state_ == State::Stopped; }
         virtual void setSource(const std::string& source);
 …
     protected:
         enum State
+        enum class State
+        {
             Stopped,
 …
         ALuint          audioSource_;
         bool            bPooling_;
         shared_ptr<SoundBuffer> soundBuffer_;
+        std::shared_ptr<SoundBuffer> soundBuffer_;
         std::string     source_;
         float           volume_;
         bool            bLooping_;
         uint8_t         state_;       // This Variable is actually of type State
+        State           state_;       // This Variable is actually of type State
         float           pitch_;

code/trunk/src/orxonox/sound/SoundBuffer.cc

-                      r8858
+                      r11071
 namespace orxonox
+{
     SoundBuffer::SoundBuffer(const std::string& filename, std::list<shared_ptr<SoundBuffer> >::iterator poolIterator)
+    SoundBuffer::SoundBuffer(const std::string& filename, std::list<std::shared_ptr<SoundBuffer>>::iterator poolIterator)
         : filename_(filename)
         , audioBuffer_(AL_NONE)
 …
+    {
         if (this->filename_.empty())
             ThrowException(General, "SoundBuffer construction: fileInfo was NULL");
+            ThrowException(General, "SoundBuffer construction: fileInfo was nullptr");
         // Get resource info
         shared_ptr<ResourceInfo> fileInfo = Resource::getInfo(filename);
         if (fileInfo == NULL)
+        std::shared_ptr<ResourceInfo> fileInfo = Resource::getInfo(filename);
+        if (fileInfo == nullptr)
+        {
             orxout(internal_error, context::sound) << "Sound file '" << filename << "' not found" << endl;
 …
+    }
     void SoundBuffer::loadStandard(const shared_ptr<ResourceInfo>& fileInfo, DataStreamPtr dataStream)
+    void SoundBuffer::loadStandard(const std::shared_ptr<ResourceInfo>& fileInfo, DataStreamPtr dataStream)
+    {
         // Read everything into a temporary buffer
 …
+    }
     void SoundBuffer::loadOgg(const shared_ptr<ResourceInfo>& fileInfo, DataStreamPtr dataStream)
+    void SoundBuffer::loadOgg(const std::shared_ptr<ResourceInfo>& fileInfo, DataStreamPtr dataStream)
+    {
         char inbuffer[256*1024];
 …
         vorbisCallbacks.seek_func  = &seekVorbis;
         vorbisCallbacks.tell_func  = &tellVorbis;
         vorbisCallbacks.close_func = NULL;
+        vorbisCallbacks.close_func = nullptr;
         OggVorbis_File vf;
         int ret = ov_open_callbacks(dataStream.get(), &vf, NULL, 0, vorbisCallbacks);
+        int ret = ov_open_callbacks(dataStream.get(), &vf, nullptr, 0, vorbisCallbacks);
         if (ret < 0)
+        {

code/trunk/src/orxonox/sound/SoundBuffer.h

-                      r10624
+                      r11071
 #include <list>
 #include <boost/shared_ptr.hpp>
+#include <memory>
 #include "core/Resource.h"
 …
+    {
         friend class SoundManager;
-#if !defined(_MSC_VER) || _MSC_VER >= 1500
-        // Make sure nobody deletes an instance (using strong pointers)
-        template <class T>
-        friend void boost::checked_delete(T*);
-#endif
     public:
-#if defined(_MSC_VER) && _MSC_VER < 1500
         ~SoundBuffer();
-#endif
         inline ALuint getBuffer()
             { return this->audioBuffer_; }
 …
     private:
+        SoundBuffer(const std::string& filename, std::list<shared_ptr<SoundBuffer> >::iterator poolIterator);
+#if !defined(_MSC_VER) || _MSC_VER >= 1500
+        ~SoundBuffer();
+#endif
+        void loadStandard(const shared_ptr<ResourceInfo>& fileInfo, DataStreamPtr dataStream);
+        void loadOgg(const shared_ptr<ResourceInfo>& fileInfo, DataStreamPtr dataStream);
+        SoundBuffer(const std::string& filename, std::list<std::shared_ptr<SoundBuffer>>::iterator poolIterator);
+        void loadStandard(const std::shared_ptr<ResourceInfo>& fileInfo, DataStreamPtr dataStream);
+        void loadOgg(const std::shared_ptr<ResourceInfo>& fileInfo, DataStreamPtr dataStream);
         std::string filename_;
         ALuint audioBuffer_;
         std::list<shared_ptr<SoundBuffer> >::iterator poolIterator_;
+        std::list<std::shared_ptr<SoundBuffer>>::iterator poolIterator_;
     };
+}

code/trunk/src/orxonox/sound/SoundManager.cc

-                      r10624
+                      r11071
             ThrowException(InitialisationAborted, "Sound: Not loading at all");
 #if !defined(ORXONOX_PLATFORM_APPLE)
         if (!alutInitWithoutContext(NULL, NULL))
+        if (!alutInitWithoutContext(nullptr, nullptr))
             ThrowException(InitialisationFailed, "Sound Error: ALUT initialisation failed: " << alutGetErrorString(alutGetError()));
         Loki::ScopeGuard alutExitGuard = Loki::MakeGuard(&alutExit);
 …
 /*
         // Get list of available sound devices and display them
         const char* devices = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
+        const char* devices = alcGetString(nullptr, ALC_DEVICE_SPECIFIER);
         char* device = new char[strlen(devices)+1];
         strcpy(device, devices);
 …
         this->device_ = alcOpenDevice(renderDevice.c_str());
 */
         this->device_ = alcOpenDevice(NULL);
         if (this->device_ == NULL)
+        this->device_ = alcOpenDevice(nullptr);
+        if (this->device_ == nullptr)
             ThrowException(InitialisationFailed, "Sound Error: Could not open sound device.");
         Loki::ScopeGuard closeDeviceGuard = Loki::MakeGuard(&alcCloseDevice, this->device_);
         // Create sound context and make it the currently used one
         this->context_ = alcCreateContext(this->device_, NULL);
         if (this->context_ == NULL)
+        this->context_ = alcCreateContext(this->device_, nullptr);
+        if (this->context_ == nullptr)
             ThrowException(InitialisationFailed, "Sound Error: Could not create ALC context");
         Loki::ScopeGuard desroyContextGuard = Loki::MakeGuard(&alcDestroyContext, this->context_);
 …
         // Relieve context to destroy it
         if (!alcMakeContextCurrent(NULL))
+        if (!alcMakeContextCurrent(nullptr))
             orxout(internal_error, context::sound) << "Could not unset ALC context" << endl;
         alcDestroyContext(this->context_);
 …
+        {
         case SoundType::All:
             for (ObjectList<BaseSound>::iterator it = ObjectList<BaseSound>::begin(); it != ObjectList<BaseSound>::end(); ++it)
                 (*it)->updateVolume();
+            for (BaseSound* sound : ObjectList<BaseSound>())
+                sound->updateVolume();
             break;
         case SoundType::Music:
             for (ObjectList<AmbientSound>::iterator it = ObjectList<AmbientSound>::begin(); it != ObjectList<AmbientSound>::end(); ++it)
                 (*it)->updateVolume();
+            for (AmbientSound* sound : ObjectList<AmbientSound>())
+                sound->updateVolume();
             break;
         case SoundType::Effects:
             for (ObjectList<WorldSound>::iterator it = ObjectList<WorldSound>::begin(); it != ObjectList<WorldSound>::end(); ++it)
                 (*it)->updateVolume();
+            for (WorldSound* sound : ObjectList<WorldSound>())
+                sound->updateVolume();
             break;
         default:
 …
     void SoundManager::registerAmbientSound(AmbientSound* newAmbient)
+    {
         if (newAmbient != NULL && !this->bDestructorCalled_)
+        if (newAmbient != nullptr && !this->bDestructorCalled_)
+        {
             for (AmbientList::const_iterator it = this->ambientSounds_.begin(); it != this->ambientSounds_.end(); ++it)
 …
     void SoundManager::unregisterAmbientSound(AmbientSound* oldAmbient)
+    {
         if (oldAmbient == NULL || ambientSounds_.empty() || this->bDestructorCalled_)
+        if (oldAmbient == nullptr || ambientSounds_.empty() || this->bDestructorCalled_)
             return;
 …
     void SoundManager::pauseAmbientSound(AmbientSound* ambient)
+    {
         if (ambient != NULL)
+        {
             for (AmbientList::iterator it = this->ambientSounds_.begin(); it != this->ambientSounds_.end(); ++it)
+            {
                 if (it->first == ambient)
+        if (ambient != nullptr)
+        {
+            for (std::pair<AmbientSound*, bool>& pair : this->ambientSounds_)
+            {
+                if (pair.first == ambient)
+                {
                     it->second = true;
                     this->fadeOut(it->first);
+                    pair.second = true;
+                    this->fadeOut(pair.first);
                     return;
+                }
 …
+    {
         // If we're already fading out --> remove that
         for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); it++)
+        for (std::list<StrongPtr<AmbientSound>>::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); it++)
+        {
             if (*it == sound)
 …
+    {
         // If we're already fading in --> remove that
         for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeInList_.begin(); it != this->fadeInList_.end(); it++)
+        for (std::list<StrongPtr<AmbientSound>>::iterator it = this->fadeInList_.begin(); it != this->fadeInList_.end(); it++)
+        {
             if (*it == sound)
 …
         // FADE IN
         for (std::list<StrongPtr<AmbientSound> >::iterator it= this->fadeInList_.begin(); it != this->fadeInList_.end(); )
+        for (std::list<StrongPtr<AmbientSound>>::iterator it= this->fadeInList_.begin(); it != this->fadeInList_.end(); )
+        {
             if ((*it)->getVolume() + this->crossFadeStep_*dt > 1.0f)
 …
         // FADE OUT
         for (std::list<StrongPtr<AmbientSound> >::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); )
+        for (std::list<StrongPtr<AmbientSound>>::iterator it = this->fadeOutList_.begin(); it != this->fadeOutList_.end(); )
+        {
             if ((*it)->getVolume() - this->crossFadeStep_*dt < 0.0f)
 …
+    }
     shared_ptr<SoundBuffer> SoundManager::getSoundBuffer(const std::string& filename)
+    {
         shared_ptr<SoundBuffer> buffer;
+    std::shared_ptr<SoundBuffer> SoundManager::getSoundBuffer(const std::string& filename)
+    {
+        std::shared_ptr<SoundBuffer> buffer;
         // Check active or pooled buffers
         SoundBufferMap::const_iterator it = this->soundBuffers_.find(filename);
 …
+    }
     void SoundManager::releaseSoundBuffer(const shared_ptr<SoundBuffer>& buffer, bool bPoolBuffer)
+    void SoundManager::releaseSoundBuffer(const std::shared_ptr<SoundBuffer>& buffer, bool bPoolBuffer)
+    {
         // Check if others are still using the buffer
 …
                 while (this->effectsPoolSize_ + it->second->getSize() > this->maxEffectsPoolSize_s && !this->effectsPool_.empty())
+                {
                     shared_ptr<SoundBuffer> bufferDel = this->effectsPool_.back();
+                    std::shared_ptr<SoundBuffer> bufferDel = this->effectsPool_.back();
                     this->effectsPoolSize_ -= bufferDel->getSize();
                     bufferDel->poolIterator_ = this->effectsPool_.end();
 …
             ALuint source = this->availableSoundSources_.back();
             this->availableSoundSources_.pop_back();
             this->usedSoundSources_.push_back(std::make_pair(source, object));
+            this->usedSoundSources_.emplace_back(source, object);
             return source;
+        }
 …
                 if (alIsSource(source) && !alGetError())
+                {
                     this->usedSoundSources_.push_back(std::make_pair(source, object));
+                    this->usedSoundSources_.emplace_back(source, object);
                     return source;
+                }
 …
 #endif
         this->availableSoundSources_.push_back(source);
         for (std::vector<std::pair<ALuint, BaseSound*> >::iterator it = this->usedSoundSources_.begin();
+        for (std::vector<std::pair<ALuint, BaseSound*>>::iterator it = this->usedSoundSources_.begin();
             it != this->usedSoundSources_.end(); ++it)
+        {

code/trunk/src/orxonox/sound/SoundManager.h

-                      r10624
+                      r11071
 #include <map>
 #include <string>
 #include <boost/shared_ptr.hpp>
+#include <memory>
 #include "util/Singleton.h"
 …
         ~SoundManager();
         void preUpdate(const Clock& time);
         void postUpdate(const Clock& time) { /*no action*/ }
+        virtual void preUpdate(const Clock& time) override;
+        virtual void postUpdate(const Clock& time) override { /*no action*/ }
         void setConfigValues();
 …
         // tolua_end
         shared_ptr<SoundBuffer> getSoundBuffer(const std::string& filename);
         void releaseSoundBuffer(const shared_ptr<SoundBuffer>& buffer, bool bPoolBuffer);
+        std::shared_ptr<SoundBuffer> getSoundBuffer(const std::string& filename);
+        void releaseSoundBuffer(const std::shared_ptr<SoundBuffer>& buffer, bool bPoolBuffer);
         ALuint getSoundSource(BaseSound* object);
 …
         // Ambient sound related
         typedef std::list<std::pair<AmbientSound*, bool> > AmbientList;
+        typedef std::list<std::pair<AmbientSound*, bool>> AmbientList;
         AmbientList                        ambientSounds_;
         //! Absolute change per second (0.1 means 10% of the nominal volume) for cross fading
         float                              crossFadeStep_;
         std::list<StrongPtr<AmbientSound> > fadeInList_;
         std::list<StrongPtr<AmbientSound> > fadeOutList_;
+        std::list<StrongPtr<AmbientSound>> fadeInList_;
+        std::list<StrongPtr<AmbientSound>> fadeOutList_;
         // Volume related
 …
         static const unsigned int maxEffectsPoolSize_s = 40 * 1024 * 1024;
         unsigned int effectsPoolSize_;
         typedef std::list<shared_ptr<SoundBuffer> > EffectsPoolList;
+        typedef std::list<std::shared_ptr<SoundBuffer>> EffectsPoolList;
         EffectsPoolList effectsPool_;
         typedef std::map<std::string, shared_ptr<SoundBuffer> > SoundBufferMap;
+        typedef std::map<std::string, std::shared_ptr<SoundBuffer>> SoundBufferMap;
         SoundBufferMap soundBuffers_;
 …
         unsigned int maxSources_;
         std::vector<ALuint> availableSoundSources_;
         std::vector<std::pair<ALuint, BaseSound*> > usedSoundSources_;
+        std::vector<std::pair<ALuint, BaseSound*>> usedSoundSources_;
         bool bDestructorCalled_; ///< Becomes true if the destructor is called - used to prevent ambient sounds from registering after the lists were cleared

code/trunk/src/orxonox/sound/SoundStreamer.cc

-                      r8858
+                      r11071
         vorbisCallbacks.seek_func  = &seekVorbis;
         vorbisCallbacks.tell_func  = &tellVorbis;
         vorbisCallbacks.close_func = NULL;
+        vorbisCallbacks.close_func = nullptr;
         OggVorbis_File vf;
         int ret = ov_open_callbacks(dataStream.get(), &vf, NULL, 0, vorbisCallbacks);
+        int ret = ov_open_callbacks(dataStream.get(), &vf, nullptr, 0, vorbisCallbacks);
         if (ret < 0)
+        {
 …
         int current_section;
         for(int i = 0; i < 4; i++)
+        for(ALuint& initbuffer : initbuffers)
+        {
             long ret = ov_read(&vf, inbuffer, sizeof(inbuffer), 0, 2, 1, &current_section);
 …
+            }
             alBufferData(initbuffers[i], format, &inbuffer, ret, vorbisInfo->rate);
+            alBufferData(initbuffer, format, &inbuffer, ret, vorbisInfo->rate);
+        }
         alSourceQueueBuffers(audioSource, 4, initbuffers);

code/trunk/src/orxonox/sound/WorldAmbientSound.cc

-                      r10624
+                      r11071
         this->ambientSound_ = new AmbientSound();
         this->registerVariables();
         soundList_.push_back("Earth.ogg");
         soundList_.push_back("Jupiter.ogg");
         soundList_.push_back("Mars.ogg");
         soundList_.push_back("allgorythm-lift_up.ogg");
         soundList_.push_back("allgorythm-resonance_blaster.ogg");
         soundList_.push_back("AlphaCentauri.ogg");
         soundList_.push_back("Asteroid_rocks.ogg");
         soundList_.push_back("Ganymede.ogg");
         soundList_.push_back("luke_grey_-_hypermode.ogg");
+        soundList_.emplace_back("Earth.ogg");
+        soundList_.emplace_back("Jupiter.ogg");
+        soundList_.emplace_back("Mars.ogg");
+        soundList_.emplace_back("allgorythm-lift_up.ogg");
+        soundList_.emplace_back("allgorythm-resonance_blaster.ogg");
+        soundList_.emplace_back("AlphaCentauri.ogg");
+        soundList_.emplace_back("Asteroid_rocks.ogg");
+        soundList_.emplace_back("Ganymede.ogg");
+        soundList_.emplace_back("luke_grey_-_hypermode.ogg");
+    }
 …
         //HACK: Assuption - there is only one WorldAmbientSound in a level and only one level is used.
+        for (ObjectList<WorldAmbientSound>::iterator it = ObjectList<WorldAmbientSound>::begin();
+             it != ObjectList<WorldAmbientSound>::end(); ++it)
+        for (WorldAmbientSound* sound : ObjectList<WorldAmbientSound>())
+        {
             while(it->ambientSound_->setAmbientSource(WorldAmbientSound::soundList_[WorldAmbientSound::soundNumber_]) == false){
+            while(sound->ambientSound_->setAmbientSource(WorldAmbientSound::soundList_[WorldAmbientSound::soundNumber_]) == false){
                 WorldAmbientSound::soundNumber_ = (WorldAmbientSound::soundNumber_ + 1) % WorldAmbientSound::soundList_.size();
+            }

code/trunk/src/orxonox/sound/WorldAmbientSound.h

-                      r9939
+                      r11071
             virtual ~WorldAmbientSound();
             void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+            virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual void changedActivity();
+            virtual void changedActivity() override;
             void play();

code/trunk/src/orxonox/sound/WorldSound.cc

r9939	r11071
58	58	registerVariable(bLooping_, ObjectDirection::ToClient, new NetworkCallback<WorldSound>(this, &WorldSound::loopingChanged));
59	59	registerVariable(pitch_, ObjectDirection::ToClient, new NetworkCallback<WorldSound>(this, &WorldSound::pitchChanged));
60		registerVariable(~~(uint8_t&)(BaseSound::state_)~~, ObjectDirection::ToClient, new NetworkCallback<WorldSound>(this, &WorldSound::stateChanged));
	60	registerVariable(BaseSound::state_, ObjectDirection::ToClient, new NetworkCallback<WorldSound>(this, &WorldSound::stateChanged));
61	61	}
62	62

code/trunk/src/orxonox/sound/WorldSound.h

-                      r9667
+                      r11071
         WorldSound(Context* context);
         void XMLPort(Element& xmlelement, XMLPort::Mode mode);
         void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
         void changedActivity();
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+        virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode) override;
+        virtual void changedActivity() override;
         void tick(float dt);
+        virtual void tick(float dt) override;
     protected:
 …
     private:
         void registerVariables();
         void initialiseSource();
         float getRealVolume();
+        virtual void initialiseSource() override;
+        virtual float getRealVolume() override;
     };
+}

code/trunk/src/orxonox/weaponsystem/DefaultWeaponmodeLink.h

r9667	r11071
42	42	virtual ~DefaultWeaponmodeLink();
43	43
44		virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
	44	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
45	45
46	46	inline void setFiremode(const unsigned int firemode)

code/trunk/src/orxonox/weaponsystem/Munition.cc

-                      r11052
+                      r11071
         this->reloadTime_ = 0.5f;
         this->lastFilledWeaponMode_ = NULL;
+        this->lastFilledWeaponMode_ = nullptr;
+    }
     Munition::~Munition()
+    {
         for (std::map<WeaponMode*, Magazine*>::iterator it = this->assignedMagazines_.begin(); it != this->assignedMagazines_.end(); ++it)
             delete it->second;
+        for (const auto& mapEntry : this->assignedMagazines_)
+            delete mapEntry.second;
+    }
 …
             // For separated magazines we definitively need a given user
             if (!user)
                 return 0;
+                return nullptr;
             // Use the map to get the magazine assigned to the given user
 …
+        }
         return 0;
+        return nullptr;
+    }
 …
                     magazine->munition_ = 0;
                     if (this->reload(NULL))
+                    if (this->reload(nullptr))
                         // Successfully reloaded, continue recursively
                         return this->takeMunition(amount, 0);
 …
         if (deployment_ != MunitionDeployment::Separate)
+        {
             user = NULL;
+            user = nullptr;
+        }
 …
             if (it->first == lastFilledWeaponMode_)
+            {
                 lastFilledWeaponMode_ = NULL;
+                lastFilledWeaponMode_ = nullptr;
+            }
             delete it->second;
 …
+        {
             // Return true if any of the current magazines is not full (loading counts as full although it returns 0 munition)
             for (std::map<WeaponMode*, Magazine*>::const_iterator it = this->assignedMagazines_.begin(); it != this->assignedMagazines_.end(); ++it)
                 if (it->second->munition_ < this->maxMunitionPerMagazine_ && it->second->bLoaded_)
+            for (const auto& mapEntry : this->assignedMagazines_)
+                if (mapEntry.second->munition_ < this->maxMunitionPerMagazine_ && mapEntry.second->bLoaded_)
                     return true;
+        }
 …
+        {
             // Stacking munition means, if a magazine gets full, the munition adds to a new magazine
             Magazine* magazine = this->getMagazine(NULL);
+            Magazine* magazine = this->getMagazine(nullptr);
             if (magazine)
+            {
 …
             std::map<WeaponMode*, Magazine*>::iterator it;
             // If the pointer to the weapon mode whose magazine got munition added to is NULL, then set the iterator to the beginning of the map
+            // If the pointer to the weapon mode whose magazine got munition added to is nullptr, then set the iterator to the beginning of the map
             // Otherwise set it to the next weapon mode
             if (lastFilledWeaponMode_ == NULL)
+            if (lastFilledWeaponMode_ == nullptr)
+            {
                 it = this->assignedMagazines_.begin();
 …
         for (unsigned int i = 0; i < addedMagazines; ++i)
+        {
             for (std::map<WeaponMode*, Magazine*>::iterator it = this->assignedMagazines_.begin(); it != this->assignedMagazines_.end(); ++it)
+            {
                 if (needReload(it->first))
+                {
                     reload(it->first);
+            for (const auto& mapEntry : this->assignedMagazines_)
+            {
+                if (needReload(mapEntry.first))
+                {
+                    reload(mapEntry.first);
                     break;
+                }
 …
         // If we don't use separate magazines, set user to 0
         if (deployment_ != MunitionDeployment::Separate)
             user = NULL;
+            user = nullptr;
         // Remove the current magazine for the given user
 …
             if (it->first == lastFilledWeaponMode_)
+            {
                 lastFilledWeaponMode_ = NULL;
+                lastFilledWeaponMode_ = nullptr;
+            }
             delete it->second;

code/trunk/src/orxonox/weaponsystem/Munition.h

-                      r11052
+                      r11071
 namespace orxonox
+{
     namespace MunitionDeployment
+    enum class MunitionDeployment
+    {
+        enum Value
+        {
+            Separate, // Every comsuming weapon mode has its own magazine. It is possible that one weapon mode is out of ammo while another still has some.
+            Share, // All comsuming weapon modes take their munition from the same magazine. If this magazine is empty a new one is loaded.
+            Stack // There is only one magazine where all the munition is stored. Use this deployment mode for heavy weapons loke rockets, bombs, ...
+        };
+    }
+        Separate, // Every comsuming weapon mode has its own magazine. It is possible that one weapon mode is out of ammo while another still has some.
+        Share, // All comsuming weapon modes take their munition from the same magazine. If this magazine is empty a new one is loaded.
+        Stack // There is only one magazine where all the munition is stored. Use this deployment mode for heavy weapons loke rockets, bombs, ...
+    };
     class _OrxonoxExport Munition : public BaseObject
 …
             virtual ~Munition();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             unsigned int getNumMunition(WeaponMode* user) const;
 …
             inline unsigned int getMaxMunitionPerMagazine() const
                 { return this->maxMunitionPerMagazine_; }
             inline MunitionDeployment::Value getMunitionDeployment() const
+            inline MunitionDeployment getMunitionDeployment() const
                 { return deployment_; }
 …
             std::map<WeaponMode*, Magazine*> assignedMagazines_; // Maps weapon modes to magazines that are currently used.
             MunitionDeployment::Value deployment_; // Defines the behaviour how munition and magazines are distributed to the consuming weapon modes.
+            MunitionDeployment deployment_; // Defines the behaviour how munition and magazines are distributed to the consuming weapon modes.
             bool bAllowMunitionRefilling_;

code/trunk/src/orxonox/weaponsystem/ReplenishingMunition.h

-                      r11052
+                      r11071
         public:
             ReplenishingMunition(Context* context);
             virtual ~ReplenishingMunition() {}
+            virtual ~ReplenishingMunition() = default;
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             virtual float getProgress();
+            float getProgress();
             inline unsigned int getReplenishAmount() const
                 { return replenishAmount_; }

code/trunk/src/orxonox/weaponsystem/Weapon.cc

r11052	r11071
45	45	RegisterObject(Weapon);
46	46
47		this->weaponPack_ = 0;
48		this->weaponSlot_ = 0;
	47	this->weaponPack_ = nullptr;
	48	this->weaponSlot_ = nullptr;
49	49	this->bReloading_ = false;
50	50	this->reloadingWeaponmode_ = WeaponSystem::WEAPON_MODE_UNASSIGNED;
…	…
61	61	this->weaponPack_->removeWeapon(this);
62	62
63		for (~~std::multimap<unsigned int, WeaponMode*>::iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it~~)
64		~~it->~~second->destroy();
	63	for (const auto& mapEntry : this->weaponmodes_)
	64	mapEntry.second->destroy();
65	65	}
66	66	}
…	…
85	85	{
86	86	unsigned int i = 0;
87		for (~~std::multimap<unsigned int, WeaponMode*>::const_iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it~~)
	87	for (const auto& mapEntry : this->weaponmodes_)
88	88	{
89	89	if (i == index)
90		return ~~it->~~second;
	90	return mapEntry.second;
91	91
92	92	++i;
93	93	}
94		return 0;
	94	return nullptr;
95	95	}
96	96
…	…
140	140	void Weapon::reload()
141	141	{
142		for (~~std::multimap<unsigned int, WeaponMode*>::iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it~~)
143		~~it->~~second->reload();
	142	for (const auto& mapEntry : this->weaponmodes_)
	143	mapEntry.second->reload();
144	144	}
145	145
…	…
152	152	void Weapon::notifyWeaponModes()
153	153	{
154		for (~~std::multimap<unsigned int, WeaponMode*>::iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it~~)
155		~~it->~~second->setWeapon(this);
	154	for (const auto& mapEntry : this->weaponmodes_)
	155	mapEntry.second->setWeapon(this);
156	156	}
157	157
158	158	void Weapon::updateMunition()
159	159	{
160		for (~~std::multimap<unsigned int, WeaponMode*>::iterator it = this->weaponmodes_.begin(); it != this->weaponmodes_.end(); ++it~~)
161		~~it->~~second->updateMunition();
	160	for (const auto& mapEnty : this->weaponmodes_)
	161	mapEnty.second->updateMunition();
162	162	}
163	163	}

code/trunk/src/orxonox/weaponsystem/Weapon.h

-                      r11052
+                      r11071
             virtual ~Weapon();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void fire(unsigned int mode);
 …
             void addWeaponmode(WeaponMode* weaponmode);
             WeaponMode* getWeaponmode(unsigned int index) const;
             inline std::multimap<unsigned int, WeaponMode*>* getAllWeaponmodes()
                 { return &weaponmodes_; }
+            inline const std::multimap<unsigned int, WeaponMode*>& getAllWeaponmodes() const
+                { return weaponmodes_; }
             inline int getNumWeaponModes() const
                 { return weaponmodes_.size(); }

code/trunk/src/orxonox/weaponsystem/WeaponMode.cc

-                      r11052
+                      r11071
         RegisterObject(WeaponMode);
         this->weapon_ = 0;
+        this->weapon_ = nullptr;
         this->mode_ = WeaponSystem::WEAPON_MODE_UNASSIGNED;
         this->munition_ = 0;
+        this->munition_ = nullptr;
         this->initialMunition_ = 0;
         this->initialMagazines_ = 0;
 …
         else
+        {
             this->munition_ = NULL;
+            this->munition_ = nullptr;
+        }
+    }

code/trunk/src/orxonox/weaponsystem/WeaponMode.h

r11052	r11071
52	52	virtual ~WeaponMode();
53	53
54		virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
	54	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
55	55
56	56	bool fire(float* reloadTime);

code/trunk/src/orxonox/weaponsystem/WeaponPack.cc

r11052	r11071
44	44	RegisterObject(WeaponPack);
45	45
46		this->weaponSystem_ = 0;
	46	this->weaponSystem_ = nullptr;
47	47	}
48	48
…	…
76	76	void WeaponPack::fire(unsigned int weaponmode)
77	77	{
78		for (~~std::vector<Weapon *>::iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it~~)
79		~~(*it)~~->fire(weaponmode);
	78	for (Weapon* weapon : this->weapons_)
	79	weapon->fire(weaponmode);
80	80	}
81	81
…	…
86	86	void WeaponPack::reload()
87	87	{
88		for (~~std::vector<Weapon *>::iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it~~)
89		~~(*it)~~->reload();
	88	for (Weapon* weapon : this->weapons_)
	89	weapon->reload();
90	90	}
91	91
…	…
107	107	assert(it != this->weapons_.end());
108	108	this->weapons_.erase(it);
109		weapon->setWeaponPack(0);
	109	weapon->setWeaponPack(nullptr);
110	110	}
111	111
…	…
114	114	unsigned int i = 0;
115	115
116		for (~~std::vector<Weapon *>::const_iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it~~)
	116	for (Weapon* weapon : this->weapons_)
117	117	{
118	118	if (i == index)
119		return ~~(*it)~~;
	119	return weapon;
120	120	++i;
121	121	}
122	122
123		return 0;
	123	return nullptr;
124	124	}
125
126		~~std::vector<Weapon> WeaponPack::getAllWeapons()~~
127		{
128		~~return &weapons_;~~
129		}
130	125
131	126	void WeaponPack::addDefaultWeaponmodeLink(DefaultWeaponmodeLink* link)
…	…
137	132	{
138	133	unsigned int i = 0;
139		for (~~std::set<DefaultWeaponmodeLink*>::const_iterator it = this->links_.begin(); it != this->links_.end(); ++it~~)
	134	for (DefaultWeaponmodeLink* link : this->links_)
140	135	{
141	136	if (i == index)
142		return ~~(*it)~~;
	137	return link;
143	138
144	139	++i;
145	140	}
146		return 0;
	141	return nullptr;
147	142	}
148	143
149	144	unsigned int WeaponPack::getDesiredWeaponmode(unsigned int firemode) const
150	145	{
151		for (~~std::set<DefaultWeaponmodeLink*>::const_iterator it = this->links_.begin(); it != this->links_.end(); ++it~~)
152		if (~~(*it)~~->getFiremode() == firemode)
153		return ~~(*it)~~->getWeaponmode();
	146	for (DefaultWeaponmodeLink* link : this->links_)
	147	if (link->getFiremode() == firemode)
	148	return link->getWeaponmode();
154	149
155	150	return WeaponSystem::WEAPON_MODE_UNASSIGNED;
…	…
158	153	void WeaponPack::notifyWeapons()
159	154	{
160		for (~~std::vector<Weapon *>::const_iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it~~)
161		~~(*it)~~->setWeaponPack(this);
	155	for (Weapon* weapon : this->weapons_)
	156	weapon->setWeaponPack(this);
162	157	}
163	158
164	159	void WeaponPack::updateMunition()
165	160	{
166		for (~~std::vector<Weapon *>::const_iterator it = this->weapons_.begin(); it != this->weapons_.end(); ++it~~)
167		~~(*it)~~->updateMunition();
	161	for (Weapon* weapon : this->weapons_)
	162	weapon->updateMunition();
168	163	}
169	164	}

code/trunk/src/orxonox/weaponsystem/WeaponPack.h

-                      r11052
+                      r11071
             virtual ~WeaponPack();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void fire(unsigned int weaponmode);
 …
             void removeWeapon(Weapon * weapon);
             Weapon * getWeapon(unsigned int index) const;
+            std::vector<Weapon*>* getAllWeapons();
+            inline const std::vector<Weapon*>& getAllWeapons() const
+                { return weapons_; }
             inline size_t getNumWeapons() const

code/trunk/src/orxonox/weaponsystem/WeaponSet.cc

r10650	r11071
43	43	RegisterObject(WeaponSet);
44	44
45		this->weaponSystem_ = 0;
	45	this->weaponSystem_ = nullptr;
46	46	this->desiredFiremode_ = WeaponSystem::FIRE_MODE_UNASSIGNED;
47	47	}
…	…
63	63	{
64	64	// Fire all WeaponPacks with their defined weaponmode
65		for (~~std::map<WeaponPack*, unsigned int>::iterator it = this->weaponpacks_.begin(); it != this->weaponpacks_.end(); ++it~~)
66		if (~~it->~~second != WeaponSystem::WEAPON_MODE_UNASSIGNED)
67		~~it->first->fire(it->~~second);
	65	for (const auto& mapEntry : this->weaponpacks_)
	66	if (mapEntry.second != WeaponSystem::WEAPON_MODE_UNASSIGNED)
	67	mapEntry.first->fire(mapEntry.second);
68	68	}
69	69
…	…
71	71	{
72	72	// Reload all WeaponPacks with their defined weaponmode
73		for (~~std::map<WeaponPack*, unsigned int>::iterator it = this->weaponpacks_.begin(); it != this->weaponpacks_.end(); ++it~~)
74		~~it->~~first->reload();
	73	for (const auto& mapEntry : this->weaponpacks_)
	74	mapEntry.first->reload();
75	75	}
76	76

code/trunk/src/orxonox/weaponsystem/WeaponSet.h

r9667	r11071
44	44	virtual ~WeaponSet();
45	45
46		virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
	46	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
47	47
48	48	void fire();

code/trunk/src/orxonox/weaponsystem/WeaponSlot.cc

-                      r10648
+                      r11071
         RegisterObject(WeaponSlot);
         this->weaponSystem_ = 0;
         this->weapon_ = 0;
+        this->weaponSystem_ = nullptr;
+        this->weapon_ = nullptr;
         this->setSyncMode(ObjectDirection::None);
 …
         if (this->weapon_)
+        {
             this->weapon_->setWeaponSlot(0);
             this->weapon_ = 0;
+            this->weapon_->setWeaponSlot(nullptr);
+            this->weapon_ = nullptr;
+        }
+    }

code/trunk/src/orxonox/weaponsystem/WeaponSlot.h

-                      r10650
+                      r11071
             virtual ~WeaponSlot();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void attachWeapon(Weapon * weapon);
 …
             */
             inline bool isOccupied() const
                 { return (this->weapon_ != 0); }
+                { return (this->weapon_ != nullptr); }
             inline void setWeaponSystem(WeaponSystem * weaponSystem)

code/trunk/src/orxonox/weaponsystem/WeaponSystem.cc

-                      r11052
+                      r11071
         RegisterObject(WeaponSystem);
         this->pawn_ = 0;
+        this->pawn_ = nullptr;
+    }
 …
+        {
             if (this->pawn_)
                 this->pawn_->setWeaponSystem(0);
+                this->pawn_->setWeaponSystem(nullptr);
             while (!this->weaponSets_.empty())
 …
+    {
         unsigned int i = 0;
         for (std::vector<WeaponSlot*>::const_iterator it = this->weaponSlots_.begin(); it != this->weaponSlots_.end(); ++it)
+        for (WeaponSlot* weaponSlot : this->weaponSlots_)
+        {
             ++i;
             if (i > index)
                 return (*it);
+        }
         return 0;
+                return weaponSlot;
+        }
+        return nullptr;
+    }
 …
+    {
         unsigned int i = 0;
         for (std::map<unsigned int, WeaponSet*>::const_iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); ++it)
+        for (const auto& mapEntry : this->weaponSets_)
+        {
             ++i;
             if (i > index)
                 return it->second;
+        }
         return 0;
+                return mapEntry.second;
+        }
+        return nullptr;
+    }
 …
         unsigned int freeSlots = 0;
         for (std::vector<WeaponSlot*>::iterator it = this->weaponSlots_.begin(); it != this->weaponSlots_.end(); ++it)
+        {
             if (!(*it)->isOccupied())
+        for (WeaponSlot* weaponSlot : this->weaponSlots_)
+        {
+            if (!weaponSlot->isOccupied())
                 ++freeSlots;
+        }
 …
         // Attach all weapons to the first free slots (and to the Pawn)
         unsigned int i = 0;
         for (std::vector<WeaponSlot*>::iterator it = this->weaponSlots_.begin(); it != this->weaponSlots_.end(); ++it)
+        {
             if (!(*it)->isOccupied() && i < wPack->getNumWeapons())
+        for (WeaponSlot* weaponSlot : this->weaponSlots_)
+        {
+            if (!weaponSlot->isOccupied() && i < wPack->getNumWeapons())
+            {
                 Weapon* weapon = wPack->getWeapon(i);
                 (*it)->attachWeapon(weapon);
+                weaponSlot->attachWeapon(weapon);
                 this->getPawn()->attach(weapon);
                 ++i;
 …
         // Assign the desired weaponmode to the firemodes
         for (std::map<unsigned int, WeaponSet *>::iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); ++it)
+        {
             unsigned int weaponmode = wPack->getDesiredWeaponmode(it->first);
+        for (const auto& mapEntry : this->weaponSets_)
+        {
+            unsigned int weaponmode = wPack->getDesiredWeaponmode(mapEntry.first);
             if (weaponmode != WeaponSystem::WEAPON_MODE_UNASSIGNED)
                 it->second->setWeaponmodeLink(wPack, weaponmode);
+                mapEntry.second->setWeaponmodeLink(wPack, weaponmode);
+        }
 …
         // Remove all weapons from their WeaponSlot
         unsigned int i = 0;
         Weapon* weapon = 0;
+        Weapon* weapon = nullptr;
         while ((weapon = wPack->getWeapon(i++)))
             if (weapon->getWeaponSlot())
 …
         // Remove all added links from the WeaponSets
         for (std::map<unsigned int, WeaponSet *>::iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); ++it)
             it->second->removeWeaponmodeLink(wPack);
+        for (const auto& mapEntry : this->weaponSets_)
+            mapEntry.second->removeWeaponmodeLink(wPack);
         // Remove the WeaponPack from the WeaponSystem
 …
+    {
         unsigned int i = 0;
         for (std::vector<WeaponPack*>::const_iterator it = this->weaponPacks_.begin(); it != this->weaponPacks_.end(); ++it)
+        for (WeaponPack* weaponPack : this->weaponPacks_)
+        {
             ++i;
             if (i > index)
+                return (*it);
+        }
+        return 0;
+    }
+    std::vector<WeaponPack *> * WeaponSystem::getAllWeaponPacks()
+    {
+        return &weaponPacks_;
+    }
+                return weaponPack;
+        }
+        return nullptr;
+    }
     bool WeaponSystem::swapWeaponSlots(WeaponSlot * wSlot1, WeaponSlot * wSlot2)
 …
         // Check if the WeaponSet belongs to this WeaponSystem
         bool foundWeaponSet = false;
         for (std::map<unsigned int, WeaponSet *>::iterator it2 = this->weaponSets_.begin(); it2 != this->weaponSets_.end(); ++it2)
+        {
             if (it2->second == wSet)
+        for (const auto& mapEntry : this->weaponSets_)
+        {
+            if (mapEntry.second == wSet)
+            {
                 foundWeaponSet = true;
 …
     void WeaponSystem::reload()
+    {
         for (std::map<unsigned int, WeaponSet *>::iterator it = this->weaponSets_.begin(); it != this->weaponSets_.end(); ++it)
             it->second->reload();
+        for (const auto& mapEntry : this->weaponSets_)
+            mapEntry.second->reload();
+    }
 …
+    {
         if (!identifier || !identifier->getIdentifier())
             return 0;
+            return nullptr;
         std::map<Identifier *, Munition *>::iterator it = this->munitions_.find(identifier->getIdentifier());
 …
         else
+        {
             return NULL;
+            return nullptr;
+        }
+    }
 …
     void WeaponSystem::addMunition(Munition* munition)
+    {
         if (munition == NULL)
+        if (munition == nullptr)
+        {
             return;
 …
         else
+        {
             orxout(internal_warning) << "Adding munition failed. identifier == NULL " << endl;
+            orxout(internal_warning) << "Adding munition failed. identifier == nullptr " << endl;
+        }
+    }
 …
     void WeaponSystem::updateMunition()
+    {
         for (std::vector<WeaponPack*>::iterator it = this->weaponPacks_.begin(); it != this->weaponPacks_.end(); ++it)
+        {
             (*it)->updateMunition();
+        for (WeaponPack* weaponPack : this->weaponPacks_)
+        {
+            weaponPack->updateMunition();
+        }
+    }

code/trunk/src/orxonox/weaponsystem/WeaponSystem.h

-                      r11052
+                      r11071
             void removeWeaponPack(WeaponPack * wPack);
             WeaponPack * getWeaponPack(unsigned int index) const;
+            std::vector<WeaponPack *> * getAllWeaponPacks();
+            inline const std::vector<WeaponPack *>& getAllWeaponPacks() const
+                { return weaponPacks_; }
             // configure slots and firemodes

code/trunk/src/orxonox/worldentities/Actionpoint.h

-                      r11052
+                      r11071
         public:
             Actionpoint(Context* context);
             virtual ~Actionpoint() {}
+            virtual ~Actionpoint() = default;
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             /** @brief Decides what AI will do. @param val action to execute */

code/trunk/src/orxonox/worldentities/CameraPosition.h

r9667	r11071
41	41	virtual ~CameraPosition();
42	42
43		virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
	43	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
44	44
45	45	inline void setDrag(bool bDrag)

code/trunk/src/orxonox/worldentities/ControllableEntity.cc

-                      r10624
+                      r11071
         this->server_overwrite_ = 0;
         this->client_overwrite_ = 0;
         this->player_ = 0;
         this->formerPlayer_ = NULL;
+        this->player_ = nullptr;
+        this->formerPlayer_ = nullptr;
         this->playerID_ = OBJECTID_UNKNOWN;
         this->hud_ = 0;
         this->camera_ = 0;
         this->xmlcontroller_ = 0;
         //this->controller_ = 0;
         this->reverseCamera_ = 0;
+        this->hud_ = nullptr;
+        this->camera_ = nullptr;
+        this->xmlcontroller_ = nullptr;
+        //this->controller_ = nullptr;
+        this->reverseCamera_ = nullptr;
         this->bDestroyWhenPlayerLeft_ = false;
         this->cameraPositionRootNode_ = this->node_->createChildSceneNode();
         this->currentCameraPosition_ = 0;
+        this->currentCameraPosition_ = nullptr;
         this->bMouseLook_ = false;
         this->mouseLookSpeed_ = 200;
 …
                 this->camera_->destroy();
             for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
                 (*it)->destroy();
+            for (CameraPosition* cameraPosition : this->cameraPositions_)
+                cameraPosition->destroy();
             if (this->getScene()->getSceneManager())
 …
+    {
         unsigned int i = 0;
         for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+        for (CameraPosition* cameraPosition : this->cameraPositions_)
+        {
             if (i == index)
                 return (*it);
+                return cameraPosition;
             ++i;
+        }
         return 0;
+        return nullptr;
+    }
 …
         unsigned int counter = 0;
         for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+        {
             if ((*it) == this->currentCameraPosition_)
+        for (CameraPosition* cameraPosition : this->cameraPositions_)
+        {
+            if (cameraPosition == this->currentCameraPosition_)
                 break;
             counter++;
 …
     bool ControllableEntity::setCameraPosition(unsigned int index)
+    {
         if(this->camera_ != NULL && this->cameraPositions_.size() > 0)
+        if(this->camera_ != nullptr && this->cameraPositions_.size() > 0)
+        {
             if(index >= this->cameraPositions_.size())
 …
             else if (this->cameraPositions_.size() > 0)
+            {
                 for (std::list<StrongPtr<CameraPosition> >::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+                for (std::list<StrongPtr<CameraPosition>>::const_iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
+                {
                     if ((*it) == this->camera_->getParent())
 …
+            {
                 this->camera_->attachToNode(this->cameraPositionRootNode_);
                 this->currentCameraPosition_ = 0;
+                this->currentCameraPosition_ = nullptr;
+            }
 …
         if ( !GameMode::isMaster() )
+        {
             if ( target != 0 )
+            if ( target != nullptr )
+            {
                 callMemberNetworkFunction(&ControllableEntity::setTargetInternal, this->getObjectID(), 0, target->getObjectID() );
 …
         this->bHasLocalController_ = player->isLocalPlayer();
         this->bHasHumanController_ = player->isHumanPlayer();
         if(controller_ != NULL)
+        if(controller_ != nullptr)
             this->team_ = controller_->getTeam(); // forward controller team number
 …
             this->stopLocalHumanControl();
         this->player_ = 0;
+        this->player_ = nullptr;
         this->playerID_ = OBJECTID_UNKNOWN;
         this->bHasLocalController_ = false;
 …
+            {
                 this->camera_->attachToNode(this->cameraPositionRootNode_);
                 this->currentCameraPosition_ = 0;
+                this->currentCameraPosition_ = nullptr;
+            }
+        }
 …
     void ControllableEntity::destroyHud(void)
+    {
         if (this->hud_ != NULL)
+        if (this->hud_ != nullptr)
+        {
             this->hud_->destroy();
             this->hud_ = NULL;
+            this->hud_ = nullptr;
+        }
+    }
 …
             this->camera_->detachFromParent();
             this->camera_->destroy();
             this->camera_ = 0;
+            this->camera_ = nullptr;
+        }
 …
+        {
             this->hud_->destroy();
             this->hud_ = 0;
+            this->hud_ = nullptr;
+        }
+    }
 …
         if (parent)
+        {
             for (std::list<StrongPtr<CameraPosition> >::iterator it = this->cameraPositions_.begin(); it != this->cameraPositions_.end(); ++it)
                 if ((*it)->getIsAbsolute())
                     parent->attach((*it));
+            for (CameraPosition* cameraPosition : this->cameraPositions_)
+                if (cameraPosition->getIsAbsolute())
+                    parent->attach(cameraPosition);
+        }
+    }

code/trunk/src/orxonox/worldentities/ControllableEntity.h

-                      r10624
+                      r11071
             virtual ~ControllableEntity();
             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;
             void setConfigValues();
 …
             void addCameraPosition(CameraPosition* position);
             CameraPosition* getCameraPosition(unsigned int index) const;
             inline const std::list<StrongPtr<CameraPosition> >& getCameraPositions() const
+            inline const std::list<StrongPtr<CameraPosition>>& getCameraPositions() const
                 { return this->cameraPositions_; }
             unsigned int getCurrentCameraIndex() const;
 …
             using MobileEntity::setAngularVelocity;
             void setPosition(const Vector3& position);
             void setOrientation(const Quaternion& orientation);
             void setVelocity(const Vector3& velocity);
             void setAngularVelocity(const Vector3& velocity);
+            virtual void setPosition(const Vector3& position) override;
+            virtual void setOrientation(const Quaternion& orientation) override;
+            virtual void setVelocity(const Vector3& velocity) override;
+            virtual void setAngularVelocity(const Vector3& velocity) override;
             inline bool hasLocalController() const
 …
         protected:
             virtual void preDestroy();
+            virtual void preDestroy() override;
             virtual void setPlayer(PlayerInfo* player); // don't call this directly, use friend class PlayerInfo instead
 …
             virtual void startLocalHumanControl();
             virtual void stopLocalHumanControl();
             virtual void parentChanged();
+            virtual void parentChanged() override;
             inline void setHudTemplate(const std::string& name)
 …
             // Bullet btMotionState related
             void setWorldTransform(const btTransform& worldTrans);
+            virtual void setWorldTransform(const btTransform& worldTrans) override;
             unsigned int server_overwrite_;
 …
             bool bMouseLook_;
             float mouseLookSpeed_;
             std::list<StrongPtr<CameraPosition> > cameraPositions_;
+            std::list<StrongPtr<CameraPosition>> cameraPositions_;
             CameraPosition* currentCameraPosition_;
             std::string cameraPositionTemplate_;

code/trunk/src/orxonox/worldentities/Drone.cc

-                      r9667
+                      r11071
 #include "core/XMLPort.h"
+#include "core/CoreIncludes.h"
 #include "BulletDynamics/Dynamics/btRigidBody.h"
 …
         RegisterObject(Drone);
         this->myController_ = 0;
+        this->myController_ = nullptr;
         this->localLinearAcceleration_.setValue(0, 0, 0);
         this->localAngularAcceleration_.setValue(0, 0, 0);
         this->setRadarVisibility(false);
         this->setCollisionType(WorldEntity::Dynamic);
+        this->setCollisionType(WorldEntity::CollisionType::Dynamic);
         myController_ = new DroneController(this->getContext()); //!< Creates a new controller and passes our this pointer to it as creator.

code/trunk/src/orxonox/worldentities/Drone.h

-                      r9667
+                      r11071
             virtual ~Drone();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a Drone through XML.
             virtual void tick(float dt); //!< Defines which actions the Drone has to take in each tick.
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override; //!< Method for creating a Drone through XML.
+            virtual void tick(float dt) override; //!< Defines which actions the Drone has to take in each tick.
             virtual void moveFrontBack(const Vector2& value);
             virtual void moveRightLeft(const Vector2& value);
             virtual void moveUpDown(const Vector2& value);
+            virtual void moveFrontBack(const Vector2& value) override;
+            virtual void moveRightLeft(const Vector2& value) override;
+            virtual void moveUpDown(const Vector2& value) override;
             virtual void rotateYaw(const Vector2& value);
             virtual void rotatePitch(const Vector2& value);
             virtual void rotateRoll(const Vector2& value);
+            virtual void rotateYaw(const Vector2& value) override;
+            virtual void rotatePitch(const Vector2& value) override;
+            virtual void rotateRoll(const Vector2& value) override;
             /**

code/trunk/src/orxonox/worldentities/EffectContainer.cc

r9667	r11071
44	44	EffectContainer::EffectContainer(Context* context)
45	45	: BaseObject(context)
46		, lua_(~~NULL~~)
	46	, lua_(nullptr)
47	47	{
48	48	RegisterObject(EffectContainer);
…	…
89	89	{
90	90	unsigned int i = 0;
91		for (~~std::vector<WorldEntity*>::const_iterator it = this->effects_.begin(); it != this->effects_.end(); ++it~~)
	91	for (WorldEntity* effect : this->effects_)
92	92	if (i == index)
93		return ~~(*it)~~;
94		return ~~NULL~~;
	93	return effect;
	94	return nullptr;
95	95	}
96	96
…	…
103	103	bool result = (bool)lua_toboolean(this->lua_->getInternalLuaState(), -1);
104	104	lua_pop(this->lua_->getInternalLuaState(), 1);
105		for (~~std::vector<WorldEntity*>::const_iterator it = this->effects_.begin(); it != this->effects_.end(); ++it~~)
	105	for (WorldEntity* effect : this->effects_)
106	106	{
107		~~(*it)~~->setMainState(result);
	107	effect->setMainState(result);
108	108	}
109	109	}

code/trunk/src/orxonox/worldentities/EffectContainer.h

-                      r9667
+                      r11071
             virtual ~EffectContainer();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void setLuaState(LuaState* state, const std::string& functionName);
 …
             WorldEntity* getEffect(unsigned int index) const;
+            inline std::vector<WorldEntity*>::const_iterator getEffectsBegin()
+                { return this->effects_.begin(); }
+            inline std::vector<WorldEntity*>::const_iterator getEffectsEnd()
+                { return this->effects_.end(); }
+            inline const std::vector<WorldEntity*>& getEffects() const
+                { return this->effects_; }
             void updateCondition();

code/trunk/src/orxonox/worldentities/ExplosionChunk.cc

r9667	r11071
62	62	{
63	63	orxout(internal_error) << "Couldn't load particle effect in ExplosionChunk: " << ex.what() << endl;
64		this->fire_ = 0;
65		this->smoke_ = 0;
	64	this->fire_ = nullptr;
	65	this->smoke_ = nullptr;
66	66	}
67	67	}
68	68	else
69	69	{
70		this->fire_ = 0;
71		this->smoke_ = 0;
	70	this->fire_ = nullptr;
	71	this->smoke_ = nullptr;
72	72	}
73	73

code/trunk/src/orxonox/worldentities/ExplosionChunk.h

r9667	r11071
43	43	virtual ~ExplosionChunk();
44	44
45		virtual void tick(float dt);
	45	virtual void tick(float dt) override;
46	46
47	47	inline void setLOD(LODParticle::Value level)

code/trunk/src/orxonox/worldentities/ExplosionPart.cc

-                      r11052
+                      r11071
         this->effect2_ = "";
         this->model_= new Model(this->getContext());
         this->effect1Particle_= NULL;
         this->effect2Particle_= NULL;
+        this->effect1Particle_= nullptr;
+        this->effect2Particle_= nullptr;
         this->explosionEntity_ = new MovableEntity(this->getContext());
         this->posOffset_ = Vector3::ZERO;

code/trunk/src/orxonox/worldentities/ExplosionPart.h

-                      r11052
+                      r11071
             ExplosionPart(Context* context);
             ~ExplosionPart();
+            void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void Explode();
             void stop();

code/trunk/src/orxonox/worldentities/MobileEntity.cc

r9667	r11071
189	189	bool MobileEntity::isCollisionTypeLegal(WorldEntity::CollisionType type) const
190	190	{
191		if (type == WorldEntity::Static)
	191	if (type == WorldEntity::CollisionType::Static)
192	192	{
193	193	orxout(internal_warning) << "Cannot tell a MobileEntity to have static collision type! Ignoring." << endl;

code/trunk/src/orxonox/worldentities/MobileEntity.h

-                      r11052
+                      r11071
             virtual ~MobileEntity();
             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;
             virtual void setPosition(const Vector3& position);
             virtual void setOrientation(const Quaternion& orientation);
+            virtual void setPosition(const Vector3& position) override;
+            virtual void setOrientation(const Quaternion& orientation) override;
             virtual void setVelocity(const Vector3& velocity);
             inline void setVelocity(float x, float y, float z)
                 { this->setVelocity(Vector3(x, y, z)); }
             inline const Vector3& getVelocity() const
+            virtual inline const Vector3& getVelocity() const override
                 { return this->linearVelocity_; }
             /**
 …
         protected:
             // Bullet btMotionState related
             virtual void setWorldTransform(const btTransform& worldTrans);
             void getWorldTransform(btTransform& worldTrans) const;
+            virtual void setWorldTransform(const btTransform& worldTrans) override;
+            virtual void getWorldTransform(btTransform& worldTrans) const override;
             Vector3 linearAcceleration_;
 …
         private:
             virtual bool isCollisionTypeLegal(WorldEntity::CollisionType type) const;
+            virtual bool isCollisionTypeLegal(WorldEntity::CollisionType type) const override;
     };
+}

code/trunk/src/orxonox/worldentities/MovableEntity.cc

r11018	r11071
50	50	this->overwrite_orientation_ = Quaternion::IDENTITY;
51	51
52		this->continuousResynchroTimer_ = 0;
	52	this->continuousResynchroTimer_ = nullptr;
53	53
54	54	this->setPriority(Priority::Low);
…	…
80	80	{
81	81	float damage = this->collisionDamage_ * (victim->getVelocity() - this->getVelocity()).length();
82		victim->hit(0, contactPoint, ownCollisionShape, damage);
	82	victim->hit(nullptr, contactPoint, ownCollisionShape, damage);
83	83	}
84	84	}

code/trunk/src/orxonox/worldentities/MovableEntity.h

-                      r10216
+                      r11071
             virtual ~MovableEntity();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual bool collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+            virtual bool collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint) override;
             using WorldEntity::setPosition;
             using WorldEntity::setOrientation;
             inline void setPosition(const Vector3& position)
+            virtual inline void setPosition(const Vector3& position) override
                 { MobileEntity::setPosition(position); this->overwrite_position_ = this->getPosition(); }
             inline void setOrientation(const Quaternion& orientation)
+            virtual inline void setOrientation(const Quaternion& orientation) override
                 { MobileEntity::setOrientation(orientation); this->overwrite_orientation_ = this->getOrientation(); }
 …
         private:
             void registerVariables();
             void clientConnected(unsigned int clientID);
             void clientDisconnected(unsigned int clientID);
+            virtual void clientConnected(unsigned int clientID) override;
+            virtual void clientDisconnected(unsigned int clientID) override;
             void resynchronize();

code/trunk/src/orxonox/worldentities/SpawnPoint.cc

r9667	r11071
43	43	RegisterObject(SpawnPoint);
44	44
45		this->template_ = 0;
	45	this->template_ = nullptr;
46	46
47	47	if (this->getGametype())

code/trunk/src/orxonox/worldentities/SpawnPoint.h

r11052	r11071
44	44	virtual ~SpawnPoint() {}
45	45
46		virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
	46	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
47	47
48	48	inline void setSpawnClass(Identifier* identifier)

code/trunk/src/orxonox/worldentities/StaticEntity.cc

r9667	r11071
95	95	bool StaticEntity::isCollisionTypeLegal(WorldEntity::CollisionType type) const
96	96	{
97		if (type == WorldEntity::~~Kinematic \|\| type == WorldEntity~~::Dynamic)
	97	if (type == WorldEntity::CollisionType::Kinematic \|\| type == WorldEntity::CollisionType::Dynamic)
98	98	{
99	99	orxout(internal_warning) << "Cannot tell a StaticEntity to have kinematic or dynamic collision type! Ignoring." << endl;

code/trunk/src/orxonox/worldentities/StaticEntity.h

-                      r11052
+                      r11071
             using WorldEntity::setOrientation;
             void setPosition(const Vector3& position);
             void setOrientation(const Quaternion& orientation);
+            virtual void setPosition(const Vector3& position) override;
+            virtual void setOrientation(const Quaternion& orientation) override;
         private:
             void registerVariables();
             bool isCollisionTypeLegal(CollisionType type) const;
+            virtual bool isCollisionTypeLegal(CollisionType type) const override;
             // network callbacks
 …
             // Bullet btMotionState related
             void setWorldTransform(const btTransform& worldTrans);
             void getWorldTransform(btTransform& worldTrans) const;
+            virtual void setWorldTransform(const btTransform& worldTrans) override;
+            virtual void getWorldTransform(btTransform& worldTrans) const override;
     };
+}

code/trunk/src/orxonox/worldentities/TeamSpawnPoint.h

-                      r11052
+                      r11071
             virtual ~TeamSpawnPoint() {}
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             void setTeamNumber(unsigned int team)
 …
             unsigned int getTeamNumber() const
                 { return this->teamNumber_; }
             virtual Pawn* spawn();
+            virtual Pawn* spawn() override;
         private:

code/trunk/src/orxonox/worldentities/WorldEntity.cc

-                      r10624
+                      r11071
 #include <OgreSceneNode.h>
 #include <BulletDynamics/Dynamics/btRigidBody.h>
-#include <boost/static_assert.hpp>
 #include "util/OrxAssert.h"
 …
     // Be sure we don't do bad conversions
     BOOST_STATIC_ASSERT((int)Ogre::Node::TS_LOCAL  == (int)WorldEntity::Local);
     BOOST_STATIC_ASSERT((int)Ogre::Node::TS_PARENT == (int)WorldEntity::Parent);
     BOOST_STATIC_ASSERT((int)Ogre::Node::TS_WORLD  == (int)WorldEntity::World);
+    static_assert((int)Ogre::Node::TS_LOCAL  == (int)WorldEntity::TransformSpace::Local,  "check enum");
+    static_assert((int)Ogre::Node::TS_PARENT == (int)WorldEntity::TransformSpace::Parent, "check enum");
+    static_assert((int)Ogre::Node::TS_WORLD  == (int)WorldEntity::TransformSpace::World,  "check enum");
     RegisterAbstractClass(WorldEntity).inheritsFrom<BaseObject>().inheritsFrom<Synchronisable>();
 …
         this->node_ = this->getScene()->getRootSceneNode()->createChildSceneNode();
         this->parent_ = 0;
+        this->parent_ = nullptr;
         this->parentID_ = OBJECTID_UNKNOWN;
         this->bDeleteWithParent_ = true;
 …
         // Default behaviour does not include physics
         this->physicalBody_   = 0;
+        this->physicalBody_   = nullptr;
         this->bPhysicsActive_ = false;
         this->bPhysicsActiveSynchronised_    = false;
 …
         this->collisionShape_ = new WorldEntityCollisionShape(this->getContext());
         this->collisionShape_->setWorldEntityOwner(this);
         this->collisionType_             = None;
         this->collisionTypeSynchronised_ = None;
+        this->collisionType_             = CollisionType::None;
+        this->collisionTypeSynchronised_ = CollisionType::None;
         this->mass_                 = 1.0f;
         this->childrenMass_         = 0;
 …
         registerVariable(this->bCollisionResponseActive_,
                                                 VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionResponseActivityChanged));
         registerVariable((int&)this->collisionTypeSynchronised_,
+        registerVariable(this->collisionTypeSynchronised_,
                                                 VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionTypeChanged));
         registerVariable(this->bPhysicsActiveSynchronised_,
 …
             // iterate over all children and change their activity as well
             for (std::set<WorldEntity*>::const_iterator it = this->getAttachedObjects().begin(); it != this->getAttachedObjects().end(); it++)
+            for (WorldEntity* object : this->getAttachedObjects())
+            {
                 if(!this->isActive())
+                {
                     (*it)->bActiveMem_ = (*it)->isActive();
                     (*it)->setActive(this->isActive());
+                    object->bActiveMem_ = object->isActive();
+                    object->setActive(this->isActive());
+                }
                 else
+                {
                     (*it)->setActive((*it)->bActiveMem_);
+                    object->setActive(object->bActiveMem_);
+                }
+            }
 …
+        {
             // iterate over all children and change their visibility as well
             for (std::set<WorldEntity*>::const_iterator it = this->getAttachedObjects().begin(); it != this->getAttachedObjects().end(); it++)
+            for (WorldEntity* object : this->getAttachedObjects())
+            {
                 if(!this->isVisible())
+                {
                     (*it)->bVisibleMem_ = (*it)->isVisible();
                     (*it)->setVisible(this->isVisible());
+                    object->bVisibleMem_ = object->isVisible();
+                    object->setVisible(this->isVisible());
+                }
                 else
+                {
                     (*it)->setVisible((*it)->bVisibleMem_);
+                    object->setVisible(object->bVisibleMem_);
+                }
+            }
 …
     void WorldEntity::collisionTypeChanged()
+    {
         if (this->collisionTypeSynchronised_ != Dynamic &&
             this->collisionTypeSynchronised_ != Kinematic &&
             this->collisionTypeSynchronised_ != Static &&
             this->collisionTypeSynchronised_ != None)
+        if (this->collisionTypeSynchronised_ != CollisionType::Dynamic &&
+            this->collisionTypeSynchronised_ != CollisionType::Kinematic &&
+            this->collisionTypeSynchronised_ != CollisionType::Static &&
+            this->collisionTypeSynchronised_ != CollisionType::None)
+        {
             orxout(internal_error) << "Error when collsion Type was received over network. Unknown enum value:" << this->collisionTypeSynchronised_ << endl;
 …
     void WorldEntity::notifyDetached()
+    {
         this->parent_ = 0;
+        this->parent_ = nullptr;
         this->parentID_ = OBJECTID_UNKNOWN;
 …
+    {
         unsigned int i = 0;
         for (std::set<WorldEntity*>::const_iterator it = this->children_.begin(); it != this->children_.end(); ++it)
+        for (WorldEntity* child : this->children_)
+        {
             if (i == index)
                 return (*it);
+                return child;
             ++i;
+        }
         return 0;
+        return nullptr;
+    }
 …
     void WorldEntity::detachOgreObject(Ogre::MovableObject* object)
+    {
         object->setUserAny(Ogre::Any(static_cast<OrxonoxClass*>(NULL)));
+        object->setUserAny(Ogre::Any(static_cast<OrxonoxClass*>(nullptr)));
         this->node_->detachObject(object);
+    }
 …
+    {
         // If physics is enabled scale the attached CollisionShape.
         /*if (this->hasPhysics() && this->collisionShape_ != NULL)
+        /*if (this->hasPhysics() && this->collisionShape_ != nullptr)
+        {
             this->collisionShape_->setScale3D(scale);
 …
         switch (relativeTo)
+        {
         case WorldEntity::Local:
+        case TransformSpace::Local:
             // position is relative to parent so transform downwards
             this->setPosition(this->getPosition() + this->getOrientation() * distance);
             break;
         case WorldEntity::Parent:
+        case TransformSpace::Parent:
             this->setPosition(this->getPosition() + distance);
             break;
         case WorldEntity::World:
+        case TransformSpace::World:
             // position is relative to parent so transform upwards
             if (this->node_->getParent())
 …
         switch(relativeTo)
+        {
         case WorldEntity::Local:
+        case TransformSpace::Local:
             this->setOrientation(this->getOrientation() * rotation);
             break;
         case WorldEntity::Parent:
+        case TransformSpace::Parent:
             // Rotations are normally relative to local axes, transform up
             this->setOrientation(rotation * this->getOrientation());
             break;
         case WorldEntity::World:
+        case TransformSpace::World:
             // Rotations are normally relative to local axes, transform up
             this->setOrientation(this->getOrientation() * this->getWorldOrientation().Inverse()
 …
         switch (relativeTo)
+        {
         case WorldEntity::Local:
+        case TransformSpace::Local:
             origin = Vector3::ZERO;
             break;
         case WorldEntity::Parent:
+        case TransformSpace::Parent:
             origin = this->getPosition();
             break;
         case WorldEntity::World:
+        case TransformSpace::World:
             origin = this->getWorldPosition();
             break;
 …
         // Check whether we have to create or destroy.
         if (type != None && this->collisionType_ == None)
+        if (type != CollisionType::None && this->collisionType_ == CollisionType::None)
+        {
 /*
 …
             this->physicalBody_->setActivationState(DISABLE_DEACTIVATION);
+        }
         else if (type == None && this->collisionType_ != None)
+        else if (type == CollisionType::None && this->collisionType_ != CollisionType::None)
+        {
             // Destroy rigid body
 …
             deactivatePhysics();
             delete this->physicalBody_;
             this->physicalBody_ = 0;
             this->collisionType_ = None;
             this->collisionTypeSynchronised_ = None;
+            this->physicalBody_ = nullptr;
+            this->collisionType_ = CollisionType::None;
+            this->collisionTypeSynchronised_ = CollisionType::None;
             return;
+        }
 …
         switch (type)
+        {
         case Dynamic:
+        case CollisionType::Dynamic:
             this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_STATIC_OBJECT & !btCollisionObject::CF_KINEMATIC_OBJECT);
             break;
         case Kinematic:
+        case CollisionType::Kinematic:
             this->physicalBody_->setCollisionFlags((this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_STATIC_OBJECT) | btCollisionObject::CF_KINEMATIC_OBJECT);
             break;
         case Static:
+        case CollisionType::Static:
             this->physicalBody_->setCollisionFlags((this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_KINEMATIC_OBJECT) | btCollisionObject::CF_STATIC_OBJECT);
             break;
         case None:
+        case CollisionType::None:
             assert(false); // Doesn't happen
             return;
 …
         CollisionType type;
         if (typeStrLower == "dynamic")
             type = Dynamic;
+            type = CollisionType::Dynamic;
         else if (typeStrLower == "static")
             type = Static;
+            type = CollisionType::Static;
         else if (typeStrLower == "kinematic")
             type = Kinematic;
+            type = CollisionType::Kinematic;
         else if (typeStrLower == "none")
             type = None;
+            type = CollisionType::None;
         else
             ThrowException(ParseError, std::string("Attempting to set an unknown collision type: '") + typeStr + "'.");
 …
         switch (this->getCollisionType())
+        {
             case Dynamic:
+            case CollisionType::Dynamic:
                 return "dynamic";
             case Kinematic:
+            case CollisionType::Kinematic:
                 return "kinematic";
             case Static:
+            case CollisionType::Static:
                 return "static";
             case None:
+            case CollisionType::None:
                 return "none";
             default:
 …
         // Recalculate mass
         this->childrenMass_ = 0.0f;
         for (std::set<WorldEntity*>::const_iterator it = this->children_.begin(); it != this->children_.end(); ++it)
             this->childrenMass_ += (*it)->getMass();
+        for (WorldEntity* child : this->children_)
+            this->childrenMass_ += child->getMass();
         recalculateMassProps();
         // Notify parent WE

code/trunk/src/orxonox/worldentities/WorldEntity.h

-                      r10726
+                      r11071
                 Enumeration denoting the spaces which a transform can be relative to.
             */
             enum TransformSpace
+            enum class TransformSpace
+            {
                 //! Transform is relative to the local space
 …
             virtual ~WorldEntity();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
             inline const Ogre::SceneNode* getNode() const
 …
             static const Vector3 UP;
             virtual void changedActivity(void);
             virtual void changedVisibility(void);
+            virtual void changedActivity(void) override;
+            virtual void changedVisibility(void) override;
             virtual void setPosition(const Vector3& position) = 0;
 …
             const Vector3& getWorldPosition() const;
             void translate(const Vector3& distance, TransformSpace relativeTo = WorldEntity::Parent);
             inline void translate(float x, float y, float z, TransformSpace relativeTo = WorldEntity::Parent)
+            void translate(const Vector3& distance, TransformSpace relativeTo = TransformSpace::Parent);
+            inline void translate(float x, float y, float z, TransformSpace relativeTo = TransformSpace::Parent)
                 { this->translate(Vector3(x, y, z), relativeTo); }
 …
             const Quaternion& getWorldOrientation() const;
             void rotate(const Quaternion& rotation, TransformSpace relativeTo = WorldEntity::Local);
             inline void rotate(const Vector3& axis, const Degree& angle, TransformSpace relativeTo = WorldEntity::Local)
+            void rotate(const Quaternion& rotation, TransformSpace relativeTo = TransformSpace::Local);
+            inline void rotate(const Vector3& axis, const Degree& angle, TransformSpace relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, axis), relativeTo); }
             inline void yaw(const Degree& angle, TransformSpace relativeTo = WorldEntity::Local)
+            inline void yaw(const Degree& angle, TransformSpace relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, Vector3::UNIT_Y), relativeTo); }
             inline void pitch(const Degree& angle, TransformSpace relativeTo = WorldEntity::Local)
+            inline void pitch(const Degree& angle, TransformSpace relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, Vector3::UNIT_X), relativeTo); }
             inline void roll(const Degree& angle, TransformSpace relativeTo = WorldEntity::Local)
+            inline void roll(const Degree& angle, TransformSpace relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, Vector3::UNIT_Z), relativeTo); }
             void lookAt(const Vector3& target, TransformSpace relativeTo = WorldEntity::Parent, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
             void setDirection(const Vector3& direction, TransformSpace relativeTo = WorldEntity::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
             inline void setDirection(float x, float y, float z, TransformSpace relativeTo = WorldEntity::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
+            void lookAt(const Vector3& target, TransformSpace relativeTo = TransformSpace::Parent, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+            void setDirection(const Vector3& direction, TransformSpace relativeTo = TransformSpace::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+            inline void setDirection(float x, float y, float z, TransformSpace relativeTo = TransformSpace::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
                 { this->setDirection(Vector3(x, y, z), relativeTo, localDirectionVector); }
 …
                 None:      The object has no physics at all.
             */
             enum CollisionType
+            enum class CollisionType
+            {
                 Dynamic,
 …
             //! Tells whether the object has any connection to the Bullet physics engine. If hasPhysics() is false, the object may still have a velocity.
             bool hasPhysics()       const { return getCollisionType() != None     ; }
+            bool hasPhysics()       const { return getCollisionType() != CollisionType::None     ; }
             //! @see CollisionType
             bool isStatic()         const { return getCollisionType() == Static   ; }
+            bool isStatic()         const { return getCollisionType() == CollisionType::Static   ; }
             //! @see CollisionType
             bool isKinematic()      const { return getCollisionType() == Kinematic; }
+            bool isKinematic()      const { return getCollisionType() == CollisionType::Kinematic; }
             //! @see CollisionType
             bool isDynamic()        const { return getCollisionType() == Dynamic  ; }
+            bool isDynamic()        const { return getCollisionType() == CollisionType::Dynamic  ; }
             //! Tells whether physics has been activated (you can temporarily deactivate it)
             bool isPhysicsActive()  const { return this->bPhysicsActive_; }

code/trunk/src/orxonox/worldentities/pawns/FpsPlayer.cc

-                      r9667
+                      r11071
         // FpsPlayer is always a physical object per default
         // Be aware of this call: The collision type legality check will not reach derived classes!
         this->setCollisionType(WorldEntity::Dynamic);
+        this->setCollisionType(WorldEntity::CollisionType::Dynamic);
         // Get notification about collisions
         this->enableCollisionCallback();
 …
     bool FpsPlayer::isCollisionTypeLegal(WorldEntity::CollisionType type) const
+    {
         if (type != WorldEntity::Dynamic)
+        if (type != WorldEntity::CollisionType::Dynamic)
+        {
             orxout(internal_warning) << "Cannot tell a FpsPlayer not to be dynamic! Ignoring." << endl;
 …
             if (!this->isInMouseLook())
+            {
                 this->yaw(Radian(this->yaw_ * this->getMouseLookSpeed()), WorldEntity::Parent);
+                this->yaw(Radian(this->yaw_ * this->getMouseLookSpeed()), WorldEntity::TransformSpace::Parent);
                 Radian pitch = this->cameraPositionRootNode_->getOrientation().getPitch();
 …
+    }
     bool FpsPlayer::collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)
+    bool FpsPlayer::collidesAgainst(WorldEntity* otherObject, const btCollisionShape* ownCollisionShape, btManifoldPoint& contactPoint)
+    {
         if (contactPoint.m_normalWorldOnB.y() > 0.6)

code/trunk/src/orxonox/worldentities/pawns/FpsPlayer.h

r9667	r11071
69	69	virtual void fire();
70	70
71		~~bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)~~;
	71	virtual bool collidesAgainst(WorldEntity* otherObject, const btCollisionShape* ownCollisionShape, btManifoldPoint& contactPoint) override;
72	72
73	73	virtual void addedWeaponPack(WeaponPack* wPack);

code/trunk/src/orxonox/worldentities/pawns/ModularSpaceShip.cc

-                      r10624
+                      r11071
     RegisterClass(ModularSpaceShip);
     std::map<StaticEntity*, ShipPart*>* ModularSpaceShip::partMap_s = 0;
+    std::map<StaticEntity*, ShipPart*>* ModularSpaceShip::partMap_s = nullptr;
     ModularSpaceShip::ModularSpaceShip(Context* context) : SpaceShip(context)
 …
         for (unsigned int i=0; i < this->getAttachedObjects().size(); i++)
+        {
             if (this->getAttachedObject(i) == NULL)
+            if (this->getAttachedObject(i) == nullptr)
+            {
                 break;
+            }
             // iterate through all attached parts
             for(unsigned int j = 0; j < this->partList_.size(); j++)
+            for(ShipPart* part : this->partList_)
+            {
                 // if the name of the part matches the name of the object, add the object to that parts entitylist (unless it was already done).
                 if((this->partList_[j]->getName() == this->getAttachedObject(i)->getName()) && !this->partList_[j]->hasEntity(orxonox_cast<StaticEntity*>(this->getAttachedObject(i))))
+                if((part->getName() == this->getAttachedObject(i)->getName()) && !part->hasEntity(orxonox_cast<StaticEntity*>(this->getAttachedObject(i))))
+                {
                     // The Entity is added to the part's entityList_
                     this->partList_[j]->addEntity(orxonox_cast<StaticEntity*>(this->getAttachedObject(i)));
+                    part->addEntity(orxonox_cast<StaticEntity*>(this->getAttachedObject(i)));
                     // An entry in the partMap_ is created, assigning the part to the entity.
                     this->addPartEntityAssignment((StaticEntity*)(this->getAttachedObject(i)), this->partList_[j]);
+                    this->addPartEntityAssignment((StaticEntity*)(this->getAttachedObject(i)), part);
+                }
+            }
 …
     ShipPart* ModularSpaceShip::getPartOfEntity(StaticEntity* entity) const
+    {
         for (std::map<StaticEntity*, ShipPart*>::const_iterator it = this->partMap_.begin(); it != this->partMap_.end(); ++it)
+        {
             if (it->first == entity)
                 return it->second;
+        }
         return NULL;
+        for (const auto& mapEntry : this->partMap_)
+        {
+            if (mapEntry.first == entity)
+                return mapEntry.second;
+        }
+        return nullptr;
+    }
 …
     void ModularSpaceShip::damage(float damage, float healthdamage, float shielddamage, Pawn* originator, const btCollisionShape* cs)
+    {
         if (cs != NULL && this->getPartOfEntity((StaticEntity*)(cs->getUserPointer())) != NULL)
+        if (cs != nullptr && this->getPartOfEntity((StaticEntity*)(cs->getUserPointer())) != nullptr)
             this->getPartOfEntity((StaticEntity*)(cs->getUserPointer()))->handleHit(damage, healthdamage, shielddamage, originator);
         else
 …
     void ModularSpaceShip::killShipPartStatic(std::string name)
+    {
         for (std::map<StaticEntity*, ShipPart*>::const_iterator it = ModularSpaceShip::partMap_s->begin(); it != ModularSpaceShip::partMap_s->end(); ++it)
+        {
             if (it->second->getName() == name)
+            {
                 it->second->death();
+        for (const auto& mapEntry : *ModularSpaceShip::partMap_s)
+        {
+            if (mapEntry.second->getName() == name)
+            {
+                mapEntry.second->death();
                 return;
+            }
 …
     void ModularSpaceShip::killShipPart(std::string name)
+    {
         for (std::map<StaticEntity*, ShipPart*>::const_iterator it = ModularSpaceShip::partMap_.begin(); it != ModularSpaceShip::partMap_.end(); ++it)
+        {
             if (it->second->getName() == name)
+            {
                 it->second->death();
+        for (const auto& mapEntry : ModularSpaceShip::partMap_)
+        {
+            if (mapEntry.second->getName() == name)
+            {
+                mapEntry.second->death();
                 return;
+            }
 …
     void ModularSpaceShip::addShipPart(ShipPart* part)
+    {
         OrxAssert(part != NULL, "The ShipPart cannot be NULL.");
+        OrxAssert(part != nullptr, "The ShipPart cannot be nullptr.");
         this->partList_.push_back(part);
         part->setParent(this);
 …
         Get the i-th ShipPart of the SpaceShip.
     @return
         Returns a pointer to the i-the ShipPart. NULL if there is no ShipPart with that index.
+        Returns a pointer to the i-the ShipPart. nullptr if there is no ShipPart with that index.
     */
     ShipPart* ModularSpaceShip::getShipPart(unsigned int index)
+    {
         if(this->partList_.size() <= index)
             return NULL;
+            return nullptr;
         else
             return this->partList_[index];
 …
         The name of the ShipPart to be returned.
     @return
         Pointer to the ShipPart with the given name, or NULL if not found.
+        Pointer to the ShipPart with the given name, or nullptr if not found.
     */
     ShipPart* ModularSpaceShip::getShipPartByName(std::string name)
+    {
         for(std::vector<ShipPart*>::iterator it = this->partList_.begin(); it != this->partList_.end(); ++it)
+        {
             if(orxonox_cast<ShipPart*>(*it)->getName() == name)
+            {
                 return orxonox_cast<ShipPart*>(*it);
+        for(ShipPart* part : this->partList_)
+        {
+            if(orxonox_cast<ShipPart*>(part)->getName() == name)
+            {
+                return orxonox_cast<ShipPart*>(part);
+            }
+        }
         orxout(internal_warning) << "Couldn't find ShipPart with name \"" << name << "\"." << endl;
         return NULL;
+        return nullptr;
+    }
 …
     @brief
         Check whether the SpaceShip has a particular Engine.
     @param engine
+    @param search
         A pointer to the Engine to be checked.
     */
     bool ModularSpaceShip::hasShipPart(ShipPart* part) const
+    {
         for(unsigned int i = 0; i < this->partList_.size(); i++)
+        {
             if(this->partList_[i] == part)
+    bool ModularSpaceShip::hasShipPart(ShipPart* search) const
+    {
+        for(ShipPart* part : this->partList_)
+        {
+            if(part == search)
                 return true;
+        }

code/trunk/src/orxonox/worldentities/pawns/ModularSpaceShip.h

r10262	r11071
109	109	ShipPart* getPartOfEntity(StaticEntity* entity) const;
110	110
111		virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = ~~NULL, const btCollisionShape* cs = NULL~~);
	111	virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = nullptr, const btCollisionShape* cs = nullptr);
112	112
113	113	static void killShipPartStatic(std::string name);

code/trunk/src/orxonox/worldentities/pawns/Pawn.cc

-                      r11052
+                      r11071
         this->shieldRechargeWaitCountdown_ = 0;
         this->lastHitOriginator_ = 0;
+        this->lastHitOriginator_ = nullptr;
         // set damage multiplier to default value 1, meaning nominal damage
 …
         this->aimPosition_ = Vector3::ZERO;
         //this->explosionPartList_ = NULL;
+        //this->explosionPartList_ = nullptr;
         if (GameMode::isMaster())
 …
+        }
         else
             this->weaponSystem_ = 0;
+            this->weaponSystem_ = nullptr;
         this->setRadarObjectColour(ColourValue::Red);
         this->setRadarObjectShape(RadarViewable::Dot);
+        this->setRadarObjectShape(RadarViewable::Shape::Dot);
         this->registerVariables();
 …
         else
+        {
             this->explosionSound_ = 0;
+            this->explosionSound_ = nullptr;
+        }
+    }
 …
+                    {
                         // delete the AIController // <-- TODO: delete? nothing is deleted here... should we delete the controller?
                         slave->setControllableEntity(0);
+                        slave->setControllableEntity(nullptr);
                         // set a new master within the formation
 …
             return this->weaponSystem_->getWeaponSlot(index);
         else
             return 0;
+            return nullptr;
+    }
 …
             return this->weaponSystem_->getWeaponSet(index);
         else
             return 0;
+            return nullptr;
+    }
 …
             return this->weaponSystem_->getWeaponPack(index);
         else
+            return 0;
+    }
+    std::vector<WeaponPack *> * Pawn::getAllWeaponPacks()
+    {
+        if (this->weaponSystem_)
+            return this->weaponSystem_->getAllWeaponPacks();
+        else
+            return 0;
+            return nullptr;
+    }
 …
     Munition* Pawn::getMunitionXML() const
+    {
         return NULL;
+        return nullptr;
+    }
 …
+        }
         return NULL;
+        return nullptr;
+    }
 …
     bool Pawn::hasSlaves()
+    {
+        for (ObjectList<FormationController>::iterator it =
+             ObjectList<FormationController>::begin();
+             it != ObjectList<FormationController>::end(); ++it )
+        for (FormationController* controller : ObjectList<FormationController>())
+        {
             // checks if the pawn's controller has a slave
             if (this->hasHumanController() && it->getMaster() == this->getPlayer()->getController())
+            if (this->hasHumanController() && controller->getMaster() == this->getPlayer()->getController())
                 return true;
+        }
 …
     // A function that returns a slave of the pawn's controller
     Controller* Pawn::getSlave(){
+        for (ObjectList<FormationController>::iterator it =
+                ObjectList<FormationController>::begin();
+                it != ObjectList<FormationController>::end(); ++it )
+        {
+            if (this->hasHumanController() && it->getMaster() == this->getPlayer()->getController())
+                return it->getController();
+        }
+        return 0;
+        for (FormationController* controller : ObjectList<FormationController>())
+        {
+            if (this->hasHumanController() && controller->getMaster() == this->getPlayer()->getController())
+                return controller->getController();
+        }
+        return nullptr;
+    }

code/trunk/src/orxonox/worldentities/pawns/Pawn.h

-                      r11052
+                      r11071
             virtual ~Pawn();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void tick(float dt);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+            virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode) override;
+            virtual void tick(float dt) override;
             inline bool isAlive() const
 …
             virtual void setHealth(float health);
+            void setHealth(float health);
             inline void addHealth(float health)
                 { this->setHealth(this->health_ + health); }
 …
                 { return this->initialHealth_; }
             virtual void setShieldHealth(float shieldHealth);
+            void setShieldHealth(float shieldHealth);
             inline float getShieldHealth()
 …
                 { return (this->getShieldHealth() > 0); }
             virtual void setMaxShieldHealth(float maxshieldhealth);
+            void setMaxShieldHealth(float maxshieldhealth);
             inline float getMaxShieldHealth() const
                 { return this->maxShieldHealth_; }
 …
                 { return this->shieldAbsorption_; }
             virtual void setShieldRechargeRate(float shieldRechargeRate);
+            void setShieldRechargeRate(float shieldRechargeRate);
             inline float getShieldRechargeRate() const
                 { return this->shieldRechargeRate_; }
             virtual void setShieldRechargeWaitTime(float shieldRechargeWaitTime);
+            void setShieldRechargeWaitTime(float shieldRechargeWaitTime);
             inline float getShieldRechargeWaitTime() const
                 { return this->shieldRechargeWaitTime_; }
 …
                 { this->shieldRechargeWaitCountdown_ = this->getShieldRechargeWaitTime(); } // TODO: Implement in Projectile.cc
             virtual void decreaseShieldRechargeCountdownTime(float dt);
+            void decreaseShieldRechargeCountdownTime(float dt);
             /** @brief Sets the state of the pawns vulnerability. @param bVulnerable */
 …
             virtual void kill();
             virtual void fired(unsigned int firemode);
+            virtual void fired(unsigned int firemode) override;
             virtual void postSpawn();
 …
             void addWeaponPackXML(WeaponPack * wPack);
             WeaponPack * getWeaponPack(unsigned int index) const;
-            std::vector<WeaponPack *> * getAllWeaponPacks();
             void addMunitionXML(Munition* munition);
 …
             virtual void startLocalHumanControl();
+            virtual void startLocalHumanControl() override;
             void setAimPosition( Vector3 position )
 …
                 { return this->aimPosition_; }
             virtual const Vector3& getCarrierPosition(void) const
+            virtual const Vector3& getCarrierPosition(void) const override
                 { return this->getWorldPosition(); };
             virtual void changedVisibility();
+            virtual void changedVisibility() override;
             void setExplosionSound(const std::string& engineSound);
             const std::string& getExplosionSound();
             virtual const WeaponSystem* getWeaponSystem() const
+            inline const WeaponSystem* getWeaponSystem() const
                 { return this->weaponSystem_; }
         protected:
             virtual void preDestroy();
             virtual void setPlayer(PlayerInfo* player);
             virtual void removePlayer();
+            virtual void preDestroy() override;
+            virtual void setPlayer(PlayerInfo* player) override;
+            virtual void removePlayer() override;
             virtual void death();
 …
             virtual void spawneffect();
             virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL, const btCollisionShape* cs = NULL);
+            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = nullptr, const btCollisionShape* cs = nullptr);
             bool bAlive_;
             bool bVulnerable_; ///< If false the pawn may not ged damaged
             virtual std::vector<PickupCarrier*>* getCarrierChildren(void) const
+            virtual std::vector<PickupCarrier*>* getCarrierChildren(void) const override
                 { return new std::vector<PickupCarrier*>(); }
             virtual PickupCarrier* getCarrierParent(void) const
                 { return NULL; }
+            virtual PickupCarrier* getCarrierParent(void) const override
+                { return nullptr; }

code/trunk/src/orxonox/worldentities/pawns/SpaceShip.cc

-                      r11052
+                      r11071
     RegisterClass(SpaceShip);
     SpaceShip::SpaceShip(Context* context) : Pawn(context), boostBlur_(NULL)
+    SpaceShip::SpaceShip(Context* context) : Pawn(context), boostBlur_(nullptr)
+    {
         RegisterObject(SpaceShip);
 …
         // SpaceShip is always a physical object per default
         // Be aware of this call: The collision type legality check will not reach derived classes!
         this->setCollisionType(WorldEntity::Dynamic);
+        this->setCollisionType(WorldEntity::CollisionType::Dynamic);
         // Get notification about collisions
         this->enableCollisionCallback();
 …
     bool SpaceShip::isCollisionTypeLegal(WorldEntity::CollisionType type) const
+    {
         if (type != WorldEntity::Dynamic)
+        if (type != WorldEntity::CollisionType::Dynamic)
+        {
             orxout(internal_warning) << "Cannot tell a SpaceShip not to be dynamic! Ignoring." << endl;
 …
         // Run the engines
         for(std::vector<Engine*>::iterator it = this->engineList_.begin(); it != this->engineList_.end(); it++)
             (*it)->run(dt);
+        for(Engine* engine : this->engineList_)
+            engine->run(dt);
         if (this->hasLocalController())
 …
             if(this->bEnableMotionBlur_)
+            {
                 if (this->boostBlur_ == NULL && this->hasLocalController() && this->hasHumanController())
+                if (this->boostBlur_ == nullptr && this->hasLocalController() && this->hasHumanController())
+                {
                     this->boostBlur_ = new Shader(this->getScene()->getSceneManager());
 …
     void SpaceShip::addEngine(orxonox::Engine* engine)
+    {
         OrxAssert(engine != NULL, "The engine cannot be NULL.");
+        OrxAssert(engine != nullptr, "The engine cannot be nullptr.");
         this->engineList_.push_back(engine);
         engine->addToSpaceShip(this);
 …
     @brief
         Check whether the SpaceShip has a particular Engine.
     @param engine
+    @param search
         A pointer to the Engine to be checked.
     */
     bool SpaceShip::hasEngine(Engine* engine) const
+    {
         for(unsigned int i = 0; i < this->engineList_.size(); i++)
+        {
             if(this->engineList_[i] == engine)
+    bool SpaceShip::hasEngine(Engine* search) const
+    {
+        for(Engine* engine : this->engineList_)
+        {
+            if(engine == search)
                 return true;
+        }
 …
         Get the i-th Engine of the SpaceShip.
     @return
         Returns a pointer to the i-the Engine. NULL if there is no Engine with that index.
+        Returns a pointer to the i-the Engine. nullptr if there is no Engine with that index.
     */
     Engine* SpaceShip::getEngine(unsigned int i)
+    {
         if(this->engineList_.size() >= i)
             return NULL;
+            return nullptr;
         else
             return this->engineList_[i];
 …
         The name of the engine to be returned.
     @return
         Pointer to the engine with the given name, or NULL if not found.
+        Pointer to the engine with the given name, or nullptr if not found.
     */
     Engine* SpaceShip::getEngineByName(const std::string& name)
+    {
         for(size_t i = 0; i < this->engineList_.size(); ++i)
             if(this->engineList_[i]->getName() == name)
                 return this->engineList_[i];
+        for(Engine* engine : this->engineList_)
+            if(engine->getName() == name)
+                return engine;
         orxout(internal_warning) << "Couldn't find Engine with name \"" << name << "\"." << endl;
         return NULL;
+        return nullptr;
+    }
 …
     void SpaceShip::addSpeedFactor(float factor)
+    {
         for(unsigned int i=0; i<this->engineList_.size(); i++)
             this->engineList_[i]->addSpeedMultiply(factor);
+        for(Engine* engine : this->engineList_)
+            engine->addSpeedMultiply(factor);
+    }
 …
     void SpaceShip::addSpeed(float speed)
+    {
         for(unsigned int i=0; i<this->engineList_.size(); i++)
             this->engineList_[i]->addSpeedAdd(speed);
+        for(Engine* engine : this->engineList_)
+            engine->addSpeedAdd(speed);
+    }
 …
+    {
         float speed=0;
         for(unsigned int i=0; i<this->engineList_.size(); i++)
+        {
             if(this->engineList_[i]->getMaxSpeedFront() > speed)
                 speed = this->engineList_[i]->getMaxSpeedFront();
+        for(Engine* engine : this->engineList_)
+        {
+            if(engine->getMaxSpeedFront() > speed)
+                speed = engine->getMaxSpeedFront();
+        }
         return speed;
 …
     void SpaceShip::changedEnableMotionBlur()
+    {
         if (!this->bEnableMotionBlur_ && this->boostBlur_ != NULL)
+        if (!this->bEnableMotionBlur_ && this->boostBlur_ != nullptr)
+        {
             delete this->boostBlur_;
             this->boostBlur_ = NULL;
+            this->boostBlur_ = nullptr;
+        }
+    }
 …
             Camera* camera = this->getCamera();
             //Shaking Camera effect
             if (camera != 0)
+            if (camera != nullptr)
                 camera->setOrientation(Vector3::UNIT_X, angle);
 …
+    {
         Camera* camera = CameraManager::getInstance().getActiveCamera();
         if(camera != NULL)
+        if(camera != nullptr)
+        {
             this->cameraOriginalPosition_ = camera->getPosition();
 …
+        {
             Camera *camera = this->getCamera();
             if (camera == 0)
+            if (camera == nullptr)
+            {
                 orxout(internal_warning) << "Failed to reset camera!" << endl;

code/trunk/src/orxonox/worldentities/pawns/Spectator.cc

r10624	r11071
58	58	this->localVelocity_ = Vector3::ZERO;
59	59	this->setHudTemplate("spectatorhud");
60		this->greetingFlare_ = 0;
	60	this->greetingFlare_ = nullptr;
61	61
62	62	this->setDestroyWhenPlayerLeft(true);

code/trunk/src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc

r10624	r11071
51	51	}
52	52
53		this->setRadarObjectShape(RadarViewable::Triangle);
	53	this->setRadarObjectShape(RadarViewable::Shape::Triangle);
54	54	}
55	55
…	…
80	80
81	81	std::set<WorldEntity*> attachments = this->getAttachedObjects();
82		for (~~std::set<WorldEntity*>::iterator it = attachments.begin(); it != attachments.end(); ++it~~)
	82	for (WorldEntity* attachment : attachments)
83	83	{
84		if (~~(*it)~~->isA(Class(TeamColourable)))
	84	if (attachment->isA(Class(TeamColourable)))
85	85	{
86		TeamColourable* tc = orxonox_cast<TeamColourable>(it);
	86	TeamColourable* tc = orxonox_cast<TeamColourable*>(attachment);
87	87	tc->setTeamColour(colour);
88	88	}
…	…
92	92
93	93	// Call this so bots stop shooting at the base after they converted it
94		for (~~ObjectList<ArtificialController>::iterator it = ObjectList<ArtificialController>::begin(); it != ObjectList<ArtificialController>::end(); ++it~~)
95		it->abandonTarget(this);
	94	for (ArtificialController* controller : ObjectList<ArtificialController>())
	95	controller->abandonTarget(this);
96	96	}
97	97	}

code/trunk/src/orxonox/worldentities/pawns/TeamBaseMatchBase.h

-                      r9667
+                      r11071
 namespace orxonox
+{
     namespace BaseState
+    enum class BaseState
+    {
+        enum Value
+        {
+            Uncontrolled,
+            ControlTeam1,
+            ControlTeam2,
+        };
+    }
+        Uncontrolled,
+        ControlTeam1,
+        ControlTeam2,
+    };
 …
             // Set the state of a base to whatever the argument of the function is
             void setState(BaseState::Value state)
+            void setState(BaseState state)
+            {
                 this->state_ = state;
 …
             // Get the state of a base as a return value
             BaseState::Value getState() const
+            BaseState getState() const
+            {
                 return this->state_;
 …
             void changeTeamColour();
             BaseState::Value state_;
+            BaseState state_;
     };
+}

Context Navigation

Legend: