Index: /code/branches/cpp11_v2/src/libraries/core/BaseObject.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/BaseObject.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/BaseObject.cc	(revision 10916)
@@ -234,8 +234,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->templates_)
+        for (Template* temp : this->templates_)
         {
             if (i == index)
-                return (elem);
+                return temp;
             i++;
         }
@@ -269,11 +269,11 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->eventSources_)
-        {
-            if (elem.second != state)
+        for (const auto& mapEntry : this->eventSources_)
+        {
+            if (mapEntry.second != state)
                 continue;
 
             if (i == index)
-                return elem.first;
+                return mapEntry.first;
             ++i;
         }
@@ -296,8 +296,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->eventListenersXML_)
+        for (BaseObject* listener : this->eventListenersXML_)
         {
             if (i == index)
-                return elem;
+                return listener;
             ++i;
         }
@@ -358,8 +358,8 @@
         Event event(activate, originator, name);
 
-        for (const auto & elem : this->eventListeners_)
-        {
-            event.statename_ = (elem)->eventSources_[this];
-            (elem)->processEvent(event);
+        for (BaseObject* listener : this->eventListeners_)
+        {
+            event.statename_ = listener->eventSources_[this];
+            listener->processEvent(event);
         }
     }
@@ -370,6 +370,6 @@
     void BaseObject::fireEvent(Event& event)
     {
-        for (const auto & elem : this->eventListeners_)
-            (elem)->processEvent(event);
+        for (BaseObject* listener : this->eventListeners_)
+            listener->processEvent(event);
     }
 
@@ -474,8 +474,6 @@
 
             // iterate through all states and get the event sources
-            for (auto & statename : eventnames)
-            {
-                
-
+            for (const std::string& statename : eventnames)
+            {
                 // if the event state is already known, continue with the next state
                 orxonox::EventState* eventstate = object->getEventState(statename);
Index: /code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc	(revision 10916)
@@ -293,8 +293,8 @@
         {
             // No it's not: Search for classes inheriting from the given class and add the rules for them
-            for (const auto & elem : subclass->getDirectChildren())
-                if ((elem)->isA(this->root_->getClass()))
-                    if (overwrite || (!this->nodeExists(elem))) // If we don't want to overwrite, only add nodes that don't already exist
-                        this->add(this->root_, elem, bInclude, overwrite);
+            for (const Identifier* directChild : subclass->getDirectChildren())
+                if (directChild->isA(this->root_->getClass()))
+                    if (overwrite || (!this->nodeExists(directChild))) // If we don't want to overwrite, only add nodes that don't already exist
+                        this->add(this->root_, directChild, bInclude, overwrite);
         }
 
@@ -325,10 +325,10 @@
         {
             // Search for an already existing node, containing the subclass we want to add
-            for (auto & elem : node->subnodes_)
+            for (ClassTreeMaskNode* subnode : node->subnodes_)
             {
-                if (subclass->isA((elem)->getClass()))
+                if (subclass->isA(subnode->getClass()))
                 {
                     // We've found an existing node -> delegate the work with a recursive function-call and return
-                    this->add(elem, subclass, bInclude, overwrite);
+                    this->add(subnode, subclass, bInclude, overwrite);
                     return;
                 }
@@ -392,6 +392,6 @@
         if (!subclass)
             return;
-        for (const auto & elem : subclass->getDirectChildren())
-            this->add(elem, this->isIncluded(elem), false, false);
+        for (const Identifier* directChild : subclass->getDirectChildren())
+            this->add(directChild, this->isIncluded(directChild), false, false);
 
         this->add(subclass, bInclude, false, clean);
@@ -435,7 +435,7 @@
 
             // Go through the list of subnodes and look for a node containing the searched subclass and delegate the request by a recursive function-call.
-            for (auto & elem : node->subnodes_)
-                if (subclass->isA((elem)->getClass()))
-                    return isIncluded(elem, subclass);
+            for (ClassTreeMaskNode* subnode : node->subnodes_)
+                if (subclass->isA(subnode->getClass()))
+                    return isIncluded(subnode, subclass);
 
             // There is no subnode containing our class -> the rule of the current node takes in effect
@@ -957,6 +957,6 @@
             // The bool is "false", meaning they have no subnodes and therefore need no further checks
             if (node->isIncluded())
-                for (const auto & elem : directChildren)
-                    this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(elem, false));
+                for (const Identifier* directChild : directChildren)
+                    this->subclasses_.insert(this->subclasses_.end(), std::pair<const Identifier*, bool>(directChild, false));
         }
     }
Index: /code/branches/cpp11_v2/src/libraries/core/Core.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/Core.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/Core.cc	(revision 10916)
@@ -279,5 +279,5 @@
 
         const std::vector<std::string>& modulePaths = ApplicationPaths::getInstance().getModulePaths();
-        for (const auto & modulePath : modulePaths)
+        for (const std::string& modulePath : modulePaths)
         {
             ModuleInstance* module = new ModuleInstance(modulePath);
@@ -309,7 +309,6 @@
     void Core::unloadModules()
     {
-        for (auto module : this->modules_)
-        {
-            
+        for (ModuleInstance* module : this->modules_)
+        {
             this->unloadModule(module);
             delete module;
Index: /code/branches/cpp11_v2/src/libraries/core/CoreStaticInitializationHandler.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/CoreStaticInitializationHandler.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/CoreStaticInitializationHandler.cc	(revision 10916)
@@ -99,5 +99,5 @@
         std::set<Identifier*> identifiers;
         const std::set<StaticallyInitializedInstance*>& instances = module->getInstances(StaticInitialization::IDENTIFIER);
-        for (const auto & instance : instances)
+        for (StaticallyInitializedInstance* instance : instances)
             identifiers.insert(&static_cast<StaticallyInitializedIdentifier*>(instance)->getIdentifier());
 
@@ -106,16 +106,16 @@
         // that objects within one module may reference each other by strong pointers. but it is not allowed that objects from another
         // module (which is not unloaded) uses strong pointers to point at objects inside the unloaded module. this will lead to a crash.
-        for (const auto & identifier : identifiers)
-            (identifier)->destroyObjects();
+        for (Identifier* identifier : identifiers)
+            identifier->destroyObjects();
 
         // check if all objects were really destroyed. this is not the case if an object is referenced by a strong pointer from another
         // module (or if two objects inside this module reference each other). this will lead to a crash and must be fixed (e.g. by
         // changing object dependencies; or by changing the logic that allows modules to be unloaded).
-        for (const auto & identifier : identifiers)
+        for (Identifier* identifier : identifiers)
         {
             ObjectListBase* objectList = Context::getRootContext()->getObjectList(identifier);
             if (objectList->size() > 0)
             {
-                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << (identifier)->getName()
+                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << identifier->getName()
                     << " after unloading the Identifier. This may lead to a crash" << endl;
             }
@@ -123,12 +123,12 @@
 
         // destroy object-lists in all contexts
-        for (const auto & identifier : identifiers)
+        for (Identifier* identifier : identifiers)
         {
             // only do this if the Identifier is not a Context itself; otherwise we delete the list we're iterating over
-            if (!(identifier)->isExactlyA(Class(Context)))
+            if (!identifier->isExactlyA(Class(Context)))
             {
                 // iterate over all contexts
                 for (ObjectList<Context>::iterator it_context = ObjectList<Context>::begin(); it_context != ObjectList<Context>::end(); ++it_context)
-                    it_context->destroyObjectList((identifier));
+                    it_context->destroyObjectList(identifier);
             }
         }
Index: /code/branches/cpp11_v2/src/libraries/core/Game.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/Game.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/Game.cc	(revision 10916)
@@ -612,6 +612,6 @@
         // Check if graphics is still required
         bool graphicsRequired = false;
-        for (auto & elem : loadedStates_)
-            graphicsRequired |= elem->getInfo().bGraphicsMode;
+        for (const std::shared_ptr<GameState>& state : loadedStates_)
+            graphicsRequired |= state->getInfo().bGraphicsMode;
         if (!graphicsRequired)
             this->unloadGraphics(!this->bAbort_); // if abort is false, that means the game is still running while unloading graphics. in this case we load a graphics manager without renderer (to keep all necessary ogre instances alive)
Index: /code/branches/cpp11_v2/src/libraries/core/Language.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/Language.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/Language.cc	(revision 10916)
@@ -107,6 +107,6 @@
     Language::~Language()
     {
-        for (auto & elem : this->languageEntries_)
-            delete (elem.second);
+        for (auto& mapEntry : this->languageEntries_)
+            delete (mapEntry.second);
     }
 
@@ -319,7 +319,7 @@
 
         // Iterate through the list an write the lines into the file
-        for (const auto & elem : this->languageEntries_)
-        {
-            file << elem.second->getLabel() << '=' << elem.second->getDefault() << endl;
+        for (const auto& mapEntry : this->languageEntries_)
+        {
+            file << mapEntry.second->getLabel() << '=' << mapEntry.second->getDefault() << endl;
         }
 
Index: /code/branches/cpp11_v2/src/libraries/core/Loader.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/Loader.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/Loader.cc	(revision 10916)
@@ -165,7 +165,7 @@
                         std::ostringstream message;
                         message << "Possible sources of error:" << endl;
-                        for (auto & linesource : linesources)
+                        for (const std::pair<std::string, size_t>& pair : linesources)
                         {
-                            message << linesource.first << ", Line " << linesource.second << endl;
+                            message << pair.first << ", Line " << pair.second << endl;
                         }
                         orxout(user_error, context::loader) << message.str() << endl;
@@ -261,7 +261,7 @@
         {
             bool expectedValue = true;
-            for (auto & luaTag : luaTags)
-            {
-                if (luaTag.second == expectedValue)
+            for (auto& mapEntry : luaTags)
+            {
+                if (mapEntry.second == expectedValue)
                     expectedValue = !expectedValue;
                 else
Index: /code/branches/cpp11_v2/src/libraries/core/LuaState.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/LuaState.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/LuaState.cc	(revision 10916)
@@ -326,7 +326,7 @@
     /*static*/ bool LuaState::addToluaInterface(int (*function)(lua_State*), const std::string& name)
     {
-        for (const auto & interface : getToluaInterfaces())
-        {
-            if (interface.first == name || interface.second == function)
+        for (const auto& mapEntry : getToluaInterfaces())
+        {
+            if (mapEntry.first == name || mapEntry.second == function)
             {
                 orxout(internal_warning, context::lua) << "Trying to add a Tolua interface with the same name or function." << endl;
@@ -337,5 +337,5 @@
 
         // Open interface in all LuaStates
-        for (const auto & state : getInstances())
+        for (LuaState* state : getInstances())
             (*function)(state->luaState_);
 
@@ -354,5 +354,5 @@
 
         // Close interface in all LuaStates
-        for (const auto & state : getInstances())
+        for (LuaState* state : getInstances())
         {
             lua_pushnil(state->luaState_);
@@ -369,14 +369,14 @@
     /*static*/ void LuaState::openToluaInterfaces(lua_State* state)
     {
-        for (const auto & interface : getToluaInterfaces())
-            (interface.second)(state);
+        for (const auto& mapEntry : getToluaInterfaces())
+            (mapEntry.second)(state);
     }
 
     /*static*/ void LuaState::closeToluaInterfaces(lua_State* state)
     {
-        for (const auto & interface : getToluaInterfaces())
+        for (const auto& mapEntry : getToluaInterfaces())
         {
             lua_pushnil(state);
-            lua_setglobal(state, interface.first.c_str());
+            lua_setglobal(state, mapEntry.first.c_str());
         }
     }
Index: /code/branches/cpp11_v2/src/libraries/core/Namespace.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/Namespace.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/Namespace.cc	(revision 10916)
@@ -53,6 +53,6 @@
     {
         if (this->bRoot_)
-            for (auto & elem : this->representingNamespaces_)
-                delete elem;
+            for (NamespaceNode* node : this->representingNamespaces_)
+                delete node;
     }
 
@@ -80,7 +80,7 @@
             for (unsigned int i = 0; i < tokens.size(); i++)
             {
-                for (auto & elem : this->getNamespace()->representingNamespaces_)
+                for (NamespaceNode* node : this->getNamespace()->representingNamespaces_)
                 {
-                    std::set<NamespaceNode*> temp = elem->getNodeRelative(tokens[i]);
+                    std::set<NamespaceNode*> temp = node->getNodeRelative(tokens[i]);
                     this->representingNamespaces_.insert(temp.begin(), temp.end());
                 }
@@ -93,8 +93,8 @@
         if (this->bAutogeneratedFileRootNamespace_)
         {
-            for (auto & elem : this->representingNamespaces_)
+            for (NamespaceNode* node : this->representingNamespaces_)
             {
-                elem->setRoot(true);
-                elem->setHidden(true);
+                node->setRoot(true);
+                node->setHidden(true);
             }
         }
@@ -114,9 +114,9 @@
     bool Namespace::includes(const Namespace* ns) const
     {
-        for (const auto & elem1 : this->representingNamespaces_)
+        for (NamespaceNode* node1 : this->representingNamespaces_)
         {
-            for (const auto & elem2 : ns->representingNamespaces_)
+            for (NamespaceNode* node2 : ns->representingNamespaces_)
             {
-                if (elem1->includes(elem2))
+                if (node1->includes(node2))
                 {
                     if (this->operator_ == "or")
@@ -149,10 +149,10 @@
 
         int i = 0;
-        for (const auto & elem : this->representingNamespaces_)
+        for (NamespaceNode* node : this->representingNamespaces_)
         {
             if (i > 0)
                 output += " / ";
 
-            output += elem->toString();
+            output += node->toString();
             i++;
         }
@@ -166,10 +166,10 @@
 
         int i = 0;
-        for (const auto & elem : this->representingNamespaces_)
+        for (NamespaceNode* node : this->representingNamespaces_)
         {
             if (i > 0)
                 output += '\n';
 
-            output += elem->toString(indentation);
+            output += node->toString(indentation);
             i++;
         }
Index: /code/branches/cpp11_v2/src/libraries/core/NamespaceNode.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/NamespaceNode.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/NamespaceNode.cc	(revision 10916)
@@ -103,9 +103,9 @@
                 bool bFoundMatchingNamespace = false;
 
-                for (auto & elem : this->subnodes_)
+                for (auto& mapEntry : this->subnodes_)
                 {
-                    if (elem.first.find(firstPart) == (elem.first.size() - firstPart.size()))
+                    if (mapEntry.first.find(firstPart) == (mapEntry.first.size() - firstPart.size()))
                     {
-                        std::set<NamespaceNode*> temp2 = elem.second->getNodeRelative(secondPart);
+                        std::set<NamespaceNode*> temp2 = mapEntry.second->getNodeRelative(secondPart);
                         nodes.insert(temp2.begin(), temp2.end());
                         bFoundMatchingNamespace = true;
@@ -132,6 +132,6 @@
         else
         {
-            for (const auto & elem : this->subnodes_)
-                if (elem.second->includes(ns))
+            for (const auto& mapEntry : this->subnodes_)
+                if (mapEntry.second->includes(ns))
                     return true;
         }
@@ -167,6 +167,6 @@
         std::string output = (indentation + this->name_ + '\n');
 
-        for (const auto & elem : this->subnodes_)
-            output += elem.second->toString(indentation + "  ");
+        for (const auto& mapEntry : this->subnodes_)
+            output += mapEntry.second->toString(indentation + "  ");
 
         return output;
Index: /code/branches/cpp11_v2/src/libraries/core/Resource.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/Resource.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/Resource.cc	(revision 10916)
@@ -58,5 +58,5 @@
         DataStreamListPtr resources(new Ogre::DataStreamList());
         const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
-        for (const auto & group : groups)
+        for (const std::string& group : groups)
         {
             DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, group);
@@ -121,5 +121,5 @@
         StringVectorPtr resourceNames(new Ogre::StringVector());
         const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
-        for (const auto & group : groups)
+        for (const std::string& group : groups)
         {
             StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(group, pattern);
Index: /code/branches/cpp11_v2/src/libraries/core/class/Identifier.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/class/Identifier.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/class/Identifier.cc	(revision 10916)
@@ -87,15 +87,15 @@
         for (std::list<const Identifier*>::const_iterator it = this->directParents_.begin(); it != this->directParents_.end(); ++it)
             const_cast<Identifier*>(*it)->directChildren_.erase(this);
-        for (const auto & elem : this->children_)
-            const_cast<Identifier*>(elem)->parents_.remove(this);
-        for (const auto & elem : this->directChildren_)
-            const_cast<Identifier*>(elem)->directParents_.remove(this);
-
-        for (auto & elem : this->configValues_)
-            delete (elem.second);
-        for (auto & elem : this->xmlportParamContainers_)
-            delete (elem.second);
-        for (auto & elem : this->xmlportObjectContainers_)
-            delete (elem.second);
+        for (const Identifier* child : this->children_)
+            const_cast<Identifier*>(child)->parents_.remove(this);
+        for (const Identifier* directChild : this->directChildren_)
+            const_cast<Identifier*>(directChild)->directParents_.remove(this);
+
+        for (auto& mapEntry : this->configValues_)
+            delete (mapEntry.second);
+        for (auto& mapEntry : this->xmlportParamContainers_)
+            delete (mapEntry.second);
+        for (auto& mapEntry : this->xmlportObjectContainers_)
+            delete (mapEntry.second);
     }
 
@@ -157,7 +157,7 @@
         if (this->directParents_.empty())
         {
-            for (const auto & elem : initializationTrace)
-                if (elem != this)
-                    this->parents_.push_back(elem);
+            for (const Identifier* identifier : initializationTrace)
+                if (identifier != this)
+                    this->parents_.push_back(identifier);
         }
         else
@@ -261,20 +261,20 @@
 
         // if any parent class is virtual, it will be instantiated first, so we need to add them first.
-        for (const auto & elem : this->parents_)
-        {
-            if ((elem)->isVirtualBase())
+        for (const Identifier* parent : this->parents_)
+        {
+            if (parent->isVirtualBase())
             {
-                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(elem)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(elem)->parents_.end(); ++it_parent_parent)
+                for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(parent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(parent)->parents_.end(); ++it_parent_parent)
                     this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
-                this->addIfNotExists(expectedIdentifierTrace, elem);
+                this->addIfNotExists(expectedIdentifierTrace, parent);
             }
         }
 
         // now all direct parents get created recursively. already added identifiers (e.g. virtual base classes) are not added again.
-        for (const auto & elem : this->directParents_)
-        {
-            for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(elem)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(elem)->parents_.end(); ++it_parent_parent)
+        for (const Identifier* directParent : this->directParents_)
+        {
+            for (std::list<const Identifier*>::const_iterator it_parent_parent = const_cast<Identifier*>(directParent)->parents_.begin(); it_parent_parent != const_cast<Identifier*>(directParent)->parents_.end(); ++it_parent_parent)
                 this->addIfNotExists(expectedIdentifierTrace, *it_parent_parent);
-            this->addIfNotExists(expectedIdentifierTrace, elem);
+            this->addIfNotExists(expectedIdentifierTrace, directParent);
         }
 
@@ -285,6 +285,6 @@
 
             orxout(internal_warning) << "  Actual trace (after creating a sample instance):" << endl << "    ";
-            for (const auto & elem : this->parents_)
-                orxout(internal_warning) << " " << (elem)->getName();
+            for (const Identifier* parent : this->parents_)
+                orxout(internal_warning) << " " << parent->getName();
             orxout(internal_warning) << endl;
 
@@ -295,6 +295,6 @@
 
             orxout(internal_warning) << "  Direct parents (according to class hierarchy definitions):" << endl << "    ";
-            for (const auto & elem : this->directParents_)
-                orxout(internal_warning) << " " << (elem)->getName();
+            for (const Identifier* directParent : this->directParents_)
+                orxout(internal_warning) << " " << directParent->getName();
             orxout(internal_warning) << endl;
         }
Index: /code/branches/cpp11_v2/src/libraries/core/class/Identifier.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/class/Identifier.h	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/class/Identifier.h	(revision 10916)
@@ -462,6 +462,6 @@
 
         if (updateChildren)
-            for (const auto & elem : this->getChildren())
-                (elem)->updateConfigValues(false);
+            for (const Identifier* child : this->getChildren())
+                child->updateConfigValues(false);
     }
 
Index: /code/branches/cpp11_v2/src/libraries/core/class/IdentifierManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/class/IdentifierManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/class/IdentifierManager.cc	(revision 10916)
@@ -93,7 +93,6 @@
         {
             Context temporaryContext(nullptr);
-            for (auto identifier : this->identifiers_)
+            for (Identifier* identifier : this->identifiers_)
             {
-                
                 if (identifier->isInitialized())
                     continue;
@@ -127,6 +126,6 @@
 
         // finish the initialization of all identifiers
-        for (const auto & initializedIdentifier : initializedIdentifiers)
-            (initializedIdentifier)->finishInitialization();
+        for (Identifier* initializedIdentifier : initializedIdentifiers)
+            initializedIdentifier->finishInitialization();
 
         // only check class hierarchy in dev mode because it's an expensive operation and it requires a developer to fix detected problems anyway.
@@ -144,26 +143,26 @@
     {
         // check if there are any uninitialized identifiers remaining
-        for (const auto & elem : this->identifiers_)
-            if (!(elem)->isInitialized())
-                orxout(internal_error) << "Identifier was registered late and is not initialized: " << (elem)->getName() << " / " << (elem)->getTypeInfo().name() << endl;
+        for (Identifier* identifier : this->identifiers_)
+            if (!identifier->isInitialized())
+                orxout(internal_error) << "Identifier was registered late and is not initialized: " << identifier->getName() << " / " << identifier->getTypeInfo().name() << endl;
 
         // for all initialized identifiers, check if a sample instance behaves as expected according to the class hierarchy
         Context temporaryContext(nullptr);
-        for (const auto & initializedIdentifier : initializedIdentifiers)
+        for (Identifier* initializedIdentifier : initializedIdentifiers)
         {
-            if (!(initializedIdentifier)->hasFactory())
+            if (!initializedIdentifier->hasFactory())
                 continue;
 
-            Identifiable* temp = (initializedIdentifier)->fabricate(&temporaryContext);
-
-            for (const auto & elem : this->identifiers_)
+            Identifiable* temp = initializedIdentifier->fabricate(&temporaryContext);
+
+            for (Identifier* identifier : this->identifiers_)
             {
-                bool isA_AccordingToRtti = (elem)->canDynamicCastObjectToIdentifierClass(temp);
-                bool isA_AccordingToClassHierarchy = temp->isA((elem));
+                bool isA_AccordingToRtti = identifier->canDynamicCastObjectToIdentifierClass(temp);
+                bool isA_AccordingToClassHierarchy = temp->isA(identifier);
 
                 if (isA_AccordingToRtti != isA_AccordingToClassHierarchy)
                 {
-                    orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << (initializedIdentifier)->getName() <<
-                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << (elem)->getName() << " but RTTI says the opposite." << endl;
+                    orxout(internal_error) << "Class hierarchy does not match RTTI: Class hierarchy claims that " << initializedIdentifier->getName() <<
+                        (isA_AccordingToClassHierarchy ? " is a " : " is not a ") << identifier->getName() << " but RTTI says the opposite." << endl;
                 }
             }
@@ -184,6 +183,6 @@
     {
         orxout(internal_status) << "Destroy class-hierarchy" << endl;
-        for (const auto & elem : this->identifiers_)
-            (elem)->reset();
+        for (Identifier* identifier : this->identifiers_)
+            identifier->reset();
     }
 
@@ -260,7 +259,7 @@
     {
         // TODO: use std::type_index and a map to find identifiers by type_info (only with c++11)
-        for (const auto & elem : this->identifiers_)
-            if ((elem)->getTypeInfo() == typeInfo)
-                return (elem);
+        for (Identifier* identifer : this->identifiers_)
+            if (identifer->getTypeInfo() == typeInfo)
+                return identifer;
         return nullptr;
     }
Index: /code/branches/cpp11_v2/src/libraries/core/command/ArgumentCompletionFunctions.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/command/ArgumentCompletionFunctions.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/command/ArgumentCompletionFunctions.cc	(revision 10916)
@@ -77,6 +77,6 @@
             bool groupIsVisible(const std::map<std::string, ConsoleCommand*>& group, bool bOnlyShowHidden)
             {
-                for (const auto & elem : group)
-                    if (elem.second->isActive() && elem.second->hasAccess() && (!elem.second->isHidden())^bOnlyShowHidden)
+                for (const auto& mapEntry : group)
+                    if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.second->isHidden())^bOnlyShowHidden)
                         return true;
 
@@ -100,7 +100,7 @@
                 // get all the groups that are visible (except the shortcut group "")
                 const std::map<std::string, std::map<std::string, ConsoleCommand*>>& commands = ConsoleCommandManager::getInstance().getCommands();
-                for (const auto & command : commands)
-                    if (groupIsVisible(command.second, bOnlyShowHidden) && command.first != "" && (fragmentLC == "" || getLowercase(command.first).find(fragmentLC) == 0))
-                        groupList.push_back(ArgumentCompletionListElement(command.first, getLowercase(command.first)));
+                for (const auto& mapEntry : commands)
+                    if (groupIsVisible(mapEntry.second, bOnlyShowHidden) && mapEntry.first != "" && (fragmentLC == "" || getLowercase(mapEntry.first).find(fragmentLC) == 0))
+                        groupList.push_back(ArgumentCompletionListElement(mapEntry.first, getLowercase(mapEntry.first)));
 
                 // now add all shortcuts (in group "")
@@ -113,7 +113,7 @@
 
                     // add the shortcuts
-                    for (const auto & elem : it_group->second)
-                        if (elem.second->isActive() && elem.second->hasAccess() && (!elem.second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(elem.first).find(fragmentLC) == 0))
-                            groupList.push_back(ArgumentCompletionListElement(elem.first, getLowercase(elem.first)));
+                    for (const auto& mapEntry : it_group->second)
+                        if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(mapEntry.first).find(fragmentLC) == 0))
+                            groupList.push_back(ArgumentCompletionListElement(mapEntry.first, getLowercase(mapEntry.first)));
                 }
 
@@ -146,7 +146,7 @@
                 if (it_group != ConsoleCommandManager::getInstance().getCommands().end())
                 {
-                    for (const auto & elem : it_group->second)
-                        if (elem.second->isActive() && elem.second->hasAccess() && (!elem.second->isHidden())^bOnlyShowHidden)
-                            commandList.push_back(ArgumentCompletionListElement(elem.first, getLowercase(elem.first)));
+                    for (const auto& mapEntry : it_group->second)
+                        if (mapEntry.second->isActive() && mapEntry.second->hasAccess() && (!mapEntry.second->isHidden())^bOnlyShowHidden)
+                            commandList.push_back(ArgumentCompletionListElement(mapEntry.first, getLowercase(mapEntry.first)));
                 }
 
@@ -281,5 +281,5 @@
 
             const std::set<std::string>& names = SettingsConfigFile::getInstance().getSectionNames();
-            for (const auto & name : names)
+            for (const std::string& name : names)
                 sectionList.push_back(ArgumentCompletionListElement(name, getLowercase(name)));
 
Index: /code/branches/cpp11_v2/src/libraries/core/command/CommandEvaluation.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/command/CommandEvaluation.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/command/CommandEvaluation.cc	(revision 10916)
@@ -306,6 +306,6 @@
                 // the user typed 1-2 arguments, check what he tried to type and print a suitable error
                 std::string groupLC = getLowercase(this->getToken(0));
-                for (const auto & elem : ConsoleCommandManager::getInstance().getCommandsLC())
-                    if (elem.first == groupLC)
+                for (const auto& mapEntry : ConsoleCommandManager::getInstance().getCommandsLC())
+                    if (mapEntry.first == groupLC)
                         return std::string("Error: There is no command in group \"") + this->getToken(0) + "\" starting with \"" + this->getToken(1) + "\".";
 
@@ -328,11 +328,11 @@
 
         // iterate through all groups and their commands and calculate the distance to the current command. keep the best.
-        for (const auto & elem : ConsoleCommandManager::getInstance().getCommandsLC())
-        {
-            if (elem.first != "")
-            {
-                for (std::map<std::string, ConsoleCommand*>::const_iterator it_name = elem.second.begin(); it_name != elem.second.end(); ++it_name)
-                {
-                    std::string command = elem.first + " " + it_name->first;
+        for (const auto& mapEntry : ConsoleCommandManager::getInstance().getCommandsLC())
+        {
+            if (mapEntry.first != "")
+            {
+                for (std::map<std::string, ConsoleCommand*>::const_iterator it_name = mapEntry.second.begin(); it_name != mapEntry.second.end(); ++it_name)
+                {
+                    std::string command = mapEntry.first + " " + it_name->first;
                     unsigned int distance = getLevenshteinDistance(command, token0_LC + " " + token1_LC);
                     if (distance < nearestDistance)
@@ -349,7 +349,7 @@
         if (it_group !=  ConsoleCommandManager::getInstance().getCommandsLC().end())
         {
-            for (const auto & elem : it_group->second)
-            {
-                std::string command = elem.first;
+            for (const auto& mapEntry : it_group->second)
+            {
+                std::string command = mapEntry.first;
                 unsigned int distance = getLevenshteinDistance(command, token0_LC);
                 if (distance < nearestDistance)
@@ -429,6 +429,6 @@
     {
         size_t count = 0;
-        for (const auto & elem : list)
-            if (elem.getComparable() != "")
+        for (const ArgumentCompletionListElement& element : list)
+            if (element.getComparable() != "")
                 ++count;
         return count;
@@ -495,13 +495,13 @@
         {
             // only one (non-empty) value in the list - search it and return it
-            for (const auto & elem : list)
-            {
-                if (elem.getComparable() != "")
+            for (const ArgumentCompletionListElement& element : list)
+            {
+                if (element.getComparable() != "")
                 {
                     // arguments that have a separate string to be displayed need a little more care - just return them without modification. add a space character to the others.
-                    if (elem.hasDisplay())
-                        return (elem.getString());
+                    if (element.hasDisplay())
+                        return (element.getString());
                     else
-                        return (elem.getString() + ' ');
+                        return (element.getString() + ' ');
                 }
             }
@@ -517,8 +517,8 @@
                 char tempComparable = '\0';
                 char temp = '\0';
-                for (const auto & elem : list)
-                {
-                    const std::string& argumentComparable = elem.getComparable();
-                    const std::string& argument = elem.getString();
+                for (const ArgumentCompletionListElement& element : list)
+                {
+                    const std::string& argumentComparable = element.getComparable();
+                    const std::string& argument = element.getString();
 
                     // ignore empty arguments
@@ -560,10 +560,10 @@
     {
         std::string output;
-        for (const auto & elem : list)
-        {
-            output += elem.getDisplay();
+        for (const ArgumentCompletionListElement& element : list)
+        {
+            output += element.getDisplay();
 
             // add a space character between two elements for all non-empty arguments
-            if (elem.getComparable() != "")
+            if (element.getComparable() != "")
                 output += ' ';
         }
Index: /code/branches/cpp11_v2/src/libraries/core/command/ConsoleCommand.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/command/ConsoleCommand.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/command/ConsoleCommand.cc	(revision 10916)
@@ -75,6 +75,6 @@
         this->baseFunctor_ = executor->getFunctor();
 
-        for (auto & elem : this->argumentCompleter_)
-            elem = nullptr;
+        for (ArgumentCompleter*& completer : this->argumentCompleter_)
+            completer = nullptr;
 
         this->keybindMode_ = KeybindMode::OnPress;
Index: /code/branches/cpp11_v2/src/libraries/core/command/Shell.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/command/Shell.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/command/Shell.cc	(revision 10916)
@@ -258,5 +258,5 @@
         vectorize(text, '\n', &lines);
 
-        for (auto & line : lines)
+        for (const std::string& line : lines)
             this->addLine(line, type);
     }
Index: /code/branches/cpp11_v2/src/libraries/core/command/TclThreadList.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/command/TclThreadList.h	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/command/TclThreadList.h	(revision 10916)
@@ -262,6 +262,6 @@
         boost::shared_lock<boost::shared_mutex> lock(this->mutex_);
 
-        for (const auto & elem : this->list_)
-            if (elem == value)
+        for (const T& element : this->list_)
+            if (element == value)
                 return true;
 
Index: /code/branches/cpp11_v2/src/libraries/core/command/TclThreadManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/command/TclThreadManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/command/TclThreadManager.cc	(revision 10916)
@@ -551,7 +551,7 @@
 
         std::list<unsigned int> threads;
-        for (const auto & elem : this->interpreterBundles_)
-            if (elem.first > 0 && elem.first <= this->numInterpreterBundles_) // only list autonumbered interpreters (created with create()) - exclude the default interpreter 0 and all manually numbered interpreters)
-                threads.push_back(elem.first);
+        for (const auto& mapEntry : this->interpreterBundles_)
+            if (mapEntry.first > 0 && mapEntry.first <= this->numInterpreterBundles_) // only list autonumbered interpreters (created with create()) - exclude the default interpreter 0 and all manually numbered interpreters)
+                threads.push_back(mapEntry.first);
         return threads;
     }
Index: /code/branches/cpp11_v2/src/libraries/core/commandline/CommandLineParser.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/commandline/CommandLineParser.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/commandline/CommandLineParser.cc	(revision 10916)
@@ -124,5 +124,5 @@
             std::string shortcut;
             std::string value;
-            for (auto & argument : arguments)
+            for (const std::string& argument : arguments)
             {
                 if (argument.size() != 0)
Index: /code/branches/cpp11_v2/src/libraries/core/config/ConfigFile.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/config/ConfigFile.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/config/ConfigFile.cc	(revision 10916)
@@ -234,9 +234,9 @@
         }
 
-        for (const auto & elem : this->sections_)
-        {
-            file << (elem)->getFileEntry() << endl;
-
-            for (std::list<ConfigFileEntry*>::const_iterator it_entries = (elem)->getEntriesBegin(); it_entries != (elem)->getEntriesEnd(); ++it_entries)
+        for (ConfigFileSection* section : this->sections_)
+        {
+            file << section->getFileEntry() << endl;
+
+            for (std::list<ConfigFileEntry*>::const_iterator it_entries = section->getEntriesBegin(); it_entries != section->getEntriesEnd(); ++it_entries)
                 file << (*it_entries)->getFileEntry() << endl;
 
@@ -278,9 +278,9 @@
         @brief Returns a pointer to the section with given name (or nullptr if the section doesn't exist).
     */
-    ConfigFileSection* ConfigFile::getSection(const std::string& section) const
-    {
-        for (const auto & elem : this->sections_)
-            if ((elem)->getName() == section)
-                return (elem);
+    ConfigFileSection* ConfigFile::getSection(const std::string& sectionName) const
+    {
+        for (ConfigFileSection* section : this->sections_)
+            if (section->getName() == sectionName)
+                return section;
         return nullptr;
     }
@@ -289,13 +289,13 @@
         @brief Returns a pointer to the section with given name. If it doesn't exist, the section is created.
     */
-    ConfigFileSection* ConfigFile::getOrCreateSection(const std::string& section)
-    {
-        for (auto & elem : this->sections_)
-            if ((elem)->getName() == section)
-                return (elem);
+    ConfigFileSection* ConfigFile::getOrCreateSection(const std::string& sectionName)
+    {
+        for (ConfigFileSection* section : this->sections_)
+            if (section->getName() == sectionName)
+                return section;
 
         this->bUpdated_ = true;
 
-        return (*this->sections_.insert(this->sections_.end(), new ConfigFileSection(section)));
+        return (*this->sections_.insert(this->sections_.end(), new ConfigFileSection(sectionName)));
     }
 
@@ -307,10 +307,10 @@
         bool sectionsUpdated = false;
 
-        for (auto & elem : this->sections_)
-        {
-            if ((elem)->bUpdated_)
+        for (ConfigFileSection* section : this->sections_)
+        {
+            if (section->bUpdated_)
             {
                 sectionsUpdated = true;
-                (elem)->bUpdated_ = false;
+                section->bUpdated_ = false;
             }
         }
Index: /code/branches/cpp11_v2/src/libraries/core/config/ConfigFileManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/config/ConfigFileManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/config/ConfigFileManager.cc	(revision 10916)
@@ -53,7 +53,7 @@
     ConfigFileManager::~ConfigFileManager()
     {
-        for (const auto & elem : this->configFiles_)
-            if (elem)
-                delete (elem);
+        for (ConfigFile* configFile : this->configFiles_)
+            if (configFile)
+                delete configFile;
     }
 
Index: /code/branches/cpp11_v2/src/libraries/core/config/ConfigFileSection.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/config/ConfigFileSection.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/config/ConfigFileSection.cc	(revision 10916)
@@ -80,8 +80,8 @@
     {
         unsigned int size = 0;
-        for (const auto & elem : this->entries_)
-            if ((elem)->getName() == name)
-                if ((elem)->getIndex() >= size)
-                    size = (elem)->getIndex() + 1;
+        for (ConfigFileEntry* entry : this->entries_)
+            if (entry->getName() == name)
+                if (entry->getIndex() >= size)
+                    size = entry->getIndex() + 1;
         return size;
     }
@@ -105,8 +105,8 @@
     ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name) const
     {
-        for (const auto & elem : this->entries_)
+        for (ConfigFileEntry* entry : this->entries_)
         {
-            if ((elem)->getName() == name)
-                return elem;
+            if (entry->getName() == name)
+                return entry;
         }
         return nullptr;
@@ -121,8 +121,8 @@
     ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name, unsigned int index) const
     {
-        for (const auto & elem : this->entries_)
+        for (ConfigFileEntry* entry : this->entries_)
         {
-            if (((elem)->getName() == name) && ((elem)->getIndex() == index))
-                return elem;
+            if ((entry->getName() == name) && (entry->getIndex() == index))
+                return entry;
         }
         return nullptr;
Index: /code/branches/cpp11_v2/src/libraries/core/config/ConfigValueContainer.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/config/ConfigValueContainer.h	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/config/ConfigValueContainer.h	(revision 10916)
@@ -130,6 +130,6 @@
 
                 this->value_ = V();
-                for (auto & elem : defvalue)
-                    this->valueVector_.push_back(MultiType(elem));
+                for (const D& defvalueElement : defvalue)
+                    this->valueVector_.push_back(MultiType(defvalueElement));
 
                 this->initVector();
@@ -183,6 +183,6 @@
                     std::vector<T> temp = *value;
                     value->clear();
-                    for (auto & elem : this->valueVector_)
-                        value->push_back(elem);
+                    for (const MultiType& vectorEntry : this->valueVector_)
+                        value->push_back(vectorEntry);
 
                     if (value->size() != temp.size())
@@ -211,6 +211,6 @@
                 {
                     value->clear();
-                    for (auto & elem : this->valueVector_)
-                        value->push_back(elem);
+                    for (const MultiType& vectorEntry : this->valueVector_)
+                        value->push_back(vectorEntry);
                 }
                 return *this;
Index: /code/branches/cpp11_v2/src/libraries/core/input/Button.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/input/Button.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/input/Button.cc	(revision 10916)
@@ -196,11 +196,11 @@
 
                     // add command to the buffer if not yet existing
-                    for (auto & elem : *paramCommandBuffer_)
-                    {
-                        if (elem->evaluation_.getConsoleCommand()
+                    for (BufferedParamCommand* command : *paramCommandBuffer_)
+                    {
+                        if (command->evaluation_.getConsoleCommand()
                             == eval.getConsoleCommand())
                         {
                             // already in list
-                            cmd->paramCommand_ = elem;
+                            cmd->paramCommand_ = command;
                             break;
                         }
Index: /code/branches/cpp11_v2/src/libraries/core/input/InputBuffer.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/input/InputBuffer.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/input/InputBuffer.cc	(revision 10916)
@@ -110,10 +110,10 @@
     void InputBuffer::insert(const std::string& input, bool update)
     {
-        for (auto & elem : input)
-        {
-            this->insert(elem, false);
+        for (const char& inputChar : input)
+        {
+            this->insert(inputChar, false);
 
             if (update)
-                this->updated(elem, false);
+                this->updated(inputChar, false);
         }
 
@@ -170,8 +170,8 @@
     void InputBuffer::updated()
     {
-        for (auto & elem : this->listeners_)
-        {
-            if ((elem)->bListenToAllChanges_)
-                (elem)->callFunction();
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+        {
+            if (listener->bListenToAllChanges_)
+                listener->callFunction();
         }
     }
@@ -179,8 +179,8 @@
     void InputBuffer::updated(const char& update, bool bSingleInput)
     {
-        for (auto & elem : this->listeners_)
-        {
-            if ((!(elem)->trueKeyFalseChar_) && ((elem)->bListenToAllChanges_ || ((elem)->char_ == update)) && (!(elem)->bOnlySingleInput_ || bSingleInput))
-                (elem)->callFunction();
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+        {
+            if ((!listener->trueKeyFalseChar_) && (listener->bListenToAllChanges_ || (listener->char_ == update)) && (!listener->bOnlySingleInput_ || bSingleInput))
+                listener->callFunction();
         }
     }
@@ -201,8 +201,8 @@
             return;
 
-        for (auto & elem : this->listeners_)
-        {
-            if ((elem)->trueKeyFalseChar_ && ((elem)->key_ == evt.getKeyCode()))
-                (elem)->callFunction();
+        for (BaseInputBufferListenerTuple* listener : this->listeners_)
+        {
+            if (listener->trueKeyFalseChar_ && (listener->key_ == evt.getKeyCode()))
+                listener->callFunction();
         }
 
Index: /code/branches/cpp11_v2/src/libraries/core/input/InputDevice.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/input/InputDevice.h	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/input/InputDevice.h	(revision 10916)
@@ -158,12 +158,12 @@
 
             // Call all the states with the held button event
-            for (auto & button : pressedButtons_)
-                for (auto & state : inputStates_)
+            for (ButtonType& button : pressedButtons_)
+                for (InputState* state : inputStates_)
                     state->template buttonEvent<ButtonEvent::THold, typename Traits::ButtonTypeParam>(
                         this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
 
             // Call states with device update events
-            for (auto & elem : inputStates_)
-                elem->update(time.getDeltaTime(), this->getDeviceID());
+            for (InputState* state : inputStates_)
+                state->update(time.getDeltaTime(), this->getDeviceID());
 
             static_cast<DeviceClass*>(this)->updateImpl(time);
@@ -196,6 +196,6 @@
 
             // Call states
-            for (auto & elem : inputStates_)
-                elem->template buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
+            for (InputState* state : inputStates_)
+                state->template buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
         }
 
@@ -218,6 +218,6 @@
 
             // Call states
-            for (auto & elem : inputStates_)
-                elem->template buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
+            for (InputState* state : inputStates_)
+                state->template buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
         }
 
Index: /code/branches/cpp11_v2/src/libraries/core/input/InputManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/input/InputManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/input/InputManager.cc	(revision 10916)
@@ -373,9 +373,9 @@
         // check whether a state has changed its EMPTY situation
         bool bUpdateRequired = false;
-        for (auto & elem : activeStates_)
-        {
-            if (elem.second->hasExpired())
-            {
-                elem.second->resetExpiration();
+        for (auto& mapEntry : activeStates_)
+        {
+            if (mapEntry.second->hasExpired())
+            {
+                mapEntry.second->resetExpiration();
                 bUpdateRequired = true;
             }
@@ -391,6 +391,6 @@
 
         // Collect function calls for the update
-        for (auto & elem : activeStatesTicked_)
-            elem->update(time.getDeltaTime());
+        for (InputState* state : activeStatesTicked_)
+            state->update(time.getDeltaTime());
 
         // Execute all cached function calls in order
@@ -401,6 +401,6 @@
         // If we delay the calls, then OIS and and the InputStates are not anymore
         // in the call stack and can therefore be edited.
-        for (auto & elem : this->callBuffer_)
-            elem();
+        for (auto& function : this->callBuffer_)
+            function();
 
         this->callBuffer_.clear();
@@ -437,13 +437,13 @@
         // Using an std::set to avoid duplicates
         std::set<InputState*> tempSet;
-        for (auto & elem : devices_)
-            if (elem != nullptr)
-                for (unsigned int iState = 0; iState < elem->getStateListRef().size(); ++iState)
-                    tempSet.insert(elem->getStateListRef()[iState]);
+        for (InputDevice* device : devices_)
+            if (device != nullptr)
+                for (unsigned int iState = 0; iState < device->getStateListRef().size(); ++iState)
+                    tempSet.insert(device->getStateListRef()[iState]);
 
         // Copy the content of the std::set back to the actual vector
         activeStatesTicked_.clear();
-        for (const auto & elem : tempSet)
-            activeStatesTicked_.push_back(elem);
+        for (InputState* state : tempSet)
+            activeStatesTicked_.push_back(state);
 
         // Check whether we have to change the mouse mode
Index: /code/branches/cpp11_v2/src/libraries/core/input/JoyStick.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/input/JoyStick.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/input/JoyStick.cc	(revision 10916)
@@ -186,6 +186,6 @@
     void JoyStick::clearBuffersImpl()
     {
-        for (auto & elem : povStates_)
-            elem = 0;
+        for (int& state : povStates_)
+            state = 0;
     }
 
Index: /code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.cc	(revision 10916)
@@ -153,7 +153,7 @@
     void KeyBinder::buttonThresholdChanged()
     {
-        for (auto & elem : allHalfAxes_)
-            if (!elem->bButtonThresholdUser_)
-                elem->buttonThreshold_ = this->buttonThreshold_;
+        for (HalfAxis* halfAxis : allHalfAxes_)
+            if (!halfAxis->bButtonThresholdUser_)
+                halfAxis->buttonThreshold_ = this->buttonThreshold_;
     }
 
@@ -383,6 +383,6 @@
             it->second->clear();
 
-        for (auto & elem : paramCommandBuffer_)
-            delete elem;
+        for (BufferedParamCommand* command : paramCommandBuffer_)
+            delete command;
         paramCommandBuffer_.clear();
     }
@@ -394,7 +394,7 @@
     {
         // iterate over all buttons
-        for (const auto & elem : this->allButtons_)
-        {
-            Button* button = elem.second;
+        for (const auto& mapEntry : this->allButtons_)
+        {
+            Button* button = mapEntry.second;
 
             // iterate over all modes
@@ -465,6 +465,6 @@
         this->mousePosition_[1] = 0.0f;
 
-        for (auto & elem : mouseAxes_)
-            elem.reset();
+        for (HalfAxis& axis : mouseAxes_)
+            axis.reset();
     }
 
@@ -505,5 +505,5 @@
         }
 
-        for (auto & elem : mouseAxes_)
+        for (HalfAxis& axis : mouseAxes_)
         {
             // Why dividing relative value by dt? The reason lies in the simple fact, that when you
@@ -515,8 +515,8 @@
             {
                 // just ignore if dt == 0.0 because we have multiplied by 0.0 anyway..
-                elem.relVal_ /= dt;
-            }
-
-            tickHalfAxis(elem);
+                axis.relVal_ /= dt;
+            }
+
+            tickHalfAxis(axis);
         }
     }
Index: /code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.h	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.h	(revision 10916)
@@ -226,13 +226,13 @@
     {
         // execute all buffered bindings (additional parameter)
-        for (auto & elem : paramCommandBuffer_)
+        for (BufferedParamCommand* command : paramCommandBuffer_)
         {
-            elem->rel_ *= dt;
-            elem->execute();
+            command->rel_ *= dt;
+            command->execute();
         }
 
         // always reset the relative movement of the mouse
-        for (auto & elem : mouseAxes_)
-            elem.relVal_ = 0.0f;
+        for (HalfAxis& axis : mouseAxes_)
+            axis.relVal_ = 0.0f;
     }
 }// tolua_export
Index: /code/branches/cpp11_v2/src/libraries/core/input/Mouse.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/input/Mouse.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/input/Mouse.cc	(revision 10916)
@@ -82,6 +82,6 @@
             IntVector2 rel(e.state.X.rel, e.state.Y.rel);
             IntVector2 clippingSize(e.state.width, e.state.height);
-            for (auto & elem : inputStates_)
-                elem->mouseMoved(abs, rel, clippingSize);
+            for (InputState* state : inputStates_)
+                state->mouseMoved(abs, rel, clippingSize);
         }
 
@@ -89,6 +89,6 @@
         if (e.state.Z.rel != 0)
         {
-            for (auto & elem : inputStates_)
-                elem->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
+            for (InputState* state : inputStates_)
+                state->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
         }
 
Index: /code/branches/cpp11_v2/src/libraries/core/module/DynLibManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/module/DynLibManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/module/DynLibManager.cc	(revision 10916)
@@ -75,8 +75,8 @@
     {
         // Unload & delete resources in turn
-        for (auto & elem : mLibList)
+        for (auto& mapEntry : mLibList)
         {
-            elem.second->unload();
-            delete elem.second;
+            mapEntry.second->unload();
+            delete mapEntry.second;
         }
 
Index: /code/branches/cpp11_v2/src/libraries/core/module/ModuleInstance.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/module/ModuleInstance.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/module/ModuleInstance.cc	(revision 10916)
@@ -59,6 +59,6 @@
     {
         const std::set<StaticallyInitializedInstance*>& instances = this->staticallyInitializedInstancesByType_[type];
-        for (const auto & instance : instances)
-            (instance)->load();
+        for (StaticallyInitializedInstance* instance : instances)
+            instance->load();
     }
 
@@ -75,6 +75,6 @@
         std::map<StaticInitialization::Type, std::set<StaticallyInitializedInstance*>> copy(this->staticallyInitializedInstancesByType_);
         this->staticallyInitializedInstancesByType_.clear();
-        for (auto & elem : copy)
-            for (std::set<StaticallyInitializedInstance*>::iterator it2 = elem.second.begin(); it2 != elem.second.end(); ++it2)
+        for (auto& mapEntry : copy)
+            for (std::set<StaticallyInitializedInstance*>::iterator it2 = mapEntry.second.begin(); it2 != mapEntry.second.end(); ++it2)
                 delete (*it2);
     }
Index: /code/branches/cpp11_v2/src/libraries/core/module/PluginManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/module/PluginManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/module/PluginManager.cc	(revision 10916)
@@ -59,8 +59,8 @@
         ModifyConsoleCommand("PluginManager", __CC_PluginManager_unload_name).setObject(nullptr);
 
-        for (auto & elem : this->references_)
-            delete elem.second;
-        for (auto & elem : this->plugins_)
-            delete elem.second;
+        for (auto& mapEntry : this->references_)
+            delete mapEntry.second;
+        for (auto& mapEntry : this->plugins_)
+            delete mapEntry.second;
     }
 
@@ -68,8 +68,7 @@
     {
         const std::vector<std::string>& pluginPaths = ApplicationPaths::getInstance().getPluginPaths();
-        for (auto libraryName : pluginPaths)
+        for (const std::string& libraryName : pluginPaths)
         {
             std::string name;
-            
             std::string filename = libraryName +  + specialConfig::pluginExtension;
             std::ifstream infile(filename.c_str());
Index: /code/branches/cpp11_v2/src/libraries/core/module/StaticInitializationManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/module/StaticInitializationManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/module/StaticInitializationManager.cc	(revision 10916)
@@ -50,6 +50,6 @@
     {
         // attention: loading a module may add new handlers to the list
-        for (auto & elem : this->handlers_)
-            (elem)->loadModule(module);
+        for (StaticInitializationHandler* handler : this->handlers_)
+            handler->loadModule(module);
     }
 
Index: /code/branches/cpp11_v2/src/libraries/core/object/Context.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/object/Context.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/object/Context.cc	(revision 10916)
@@ -70,6 +70,6 @@
         // unregister context from object lists before object lists are destroyed
         this->unregisterObject();
-        for (auto & elem : this->objectLists_)
-            delete elem;
+        for (ObjectListBase* objectList : this->objectLists_)
+            delete objectList;
     }
 
Index: /code/branches/cpp11_v2/src/libraries/core/object/Listable.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/object/Listable.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/object/Listable.cc	(revision 10916)
@@ -76,6 +76,6 @@
     void Listable::unregisterObject()
     {
-        for (auto & elem : this->elements_)
-            Listable::deleteObjectListElement(elem);
+        for (ObjectListBaseElement* element : this->elements_)
+            Listable::deleteObjectListElement(element);
         this->elements_.clear();
     }
@@ -91,8 +91,8 @@
         this->elements_.clear();
 
-        for (auto & elem : copy)
+        for (ObjectListBaseElement* element : copy)
         {
-            elem->changeContext(this->context_, context);
-            Listable::deleteObjectListElement(elem);
+            element->changeContext(this->context_, context);
+            Listable::deleteObjectListElement(element);
         }
 
Index: /code/branches/cpp11_v2/src/libraries/core/object/ObjectListBase.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/object/ObjectListBase.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/object/ObjectListBase.cc	(revision 10916)
@@ -92,6 +92,6 @@
     void ObjectListBase::notifyRemovalListeners(ObjectListBaseElement* element) const
     {
-        for (const auto & elem : this->listeners_)
-            (elem)->removedElement(element);
+        for (ObjectListElementRemovalListener* listener : this->listeners_)
+            listener->removedElement(element);
     }
 
Index: /code/branches/cpp11_v2/src/libraries/core/singleton/ScopeManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/core/singleton/ScopeManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/core/singleton/ScopeManager.cc	(revision 10916)
@@ -73,12 +73,12 @@
     void ScopeManager::activateListenersForScope(ScopeID::Value scope)
     {
-        for (const auto & elem : this->listeners_[scope])
-            this->activateListener(elem);
+        for (ScopeListener* listener : this->listeners_[scope])
+            this->activateListener(listener);
     }
 
     void ScopeManager::deactivateListenersForScope(ScopeID::Value scope)
     {
-        for (const auto & elem : this->listeners_[scope])
-            this->deactivateListener(elem);
+        for (ScopeListener* listener : this->listeners_[scope])
+            this->deactivateListener(listener);
     }
 
Index: /code/branches/cpp11_v2/src/libraries/network/FunctionCall.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/network/FunctionCall.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/network/FunctionCall.cc	(revision 10916)
@@ -131,7 +131,7 @@
   *(uint32_t*)(mem+2*sizeof(uint32_t)) = this->objectID_;
   mem += 3*sizeof(uint32_t);
-  for(auto & elem : this->arguments_)
+  for(const MultiType& argument : this->arguments_)
   {
-    elem.exportData( mem );
+    argument.exportData( mem );
   }
 }
Index: /code/branches/cpp11_v2/src/libraries/network/Host.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/network/Host.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/network/Host.cc	(revision 10916)
@@ -80,9 +80,9 @@
   void Host::addPacket(ENetPacket *packet, int clientID, uint8_t channelID)
   {
-    for(auto & instances_ : instances_s)
+    for(Host* host : instances_s)
     {
-      if( (instances_)->isActive() )
+      if( host->isActive() )
       {
-        (instances_)->queuePacket(packet, clientID, channelID);
+        host->queuePacket(packet, clientID, channelID);
       }
     }
@@ -97,7 +97,7 @@
   void Host::sendChat(const std::string& message, unsigned int sourceID, unsigned int targetID)
   {
-    for(auto & instances_ : instances_s)
-      if( (instances_)->isActive() )
-        (instances_)->doSendChat(message, sourceID, targetID);
+    for(Host* host : instances_s)
+      if( host->isActive() )
+        host->doSendChat(message, sourceID, targetID);
   }
 
@@ -114,9 +114,9 @@
   bool Host::isServer()
   {
-    for (auto & instances_ : instances_s)
+    for (Host* host : instances_s)
     {
-      if( (instances_)->isActive() )
+      if( host->isActive() )
       {
-        if( (instances_)->isServer_() )
+        if( host->isServer_() )
           return true;
       }
Index: /code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.cc	(revision 10916)
@@ -88,6 +88,6 @@
     }
     // delete all Synchronisable Variables from syncList_ ( which are also in stringList_ )
-    for(auto & elem : syncList_)
-      delete (elem);
+    for(SynchronisableVariableBase* variable : syncList_)
+      delete variable;
     syncList_.clear();
     stringList_.clear();
Index: /code/branches/cpp11_v2/src/libraries/tools/DebugDrawer.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/tools/DebugDrawer.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/tools/DebugDrawer.cc	(revision 10916)
@@ -392,11 +392,11 @@
             manualObject->estimateVertexCount(lineVertices.size());
             manualObject->estimateIndexCount(lineIndices.size());
-            for (auto & elem : lineVertices)
+            for (const VertexPair& pair : lineVertices)
             {
-                manualObject->position(elem.first);
-                manualObject->colour(elem.second);
+                manualObject->position(pair.first);
+                manualObject->colour(pair.second);
             }
-            for (auto & elem : lineIndices)
-                manualObject->index(elem);
+            for (int lineIndex : lineIndices)
+                manualObject->index(lineIndex);
         }
         else
@@ -409,11 +409,11 @@
             manualObject->estimateVertexCount(triangleVertices.size());
             manualObject->estimateIndexCount(triangleIndices.size());
-            for (auto & elem : triangleVertices)
+            for (const VertexPair& pair : triangleVertices)
             {
-                manualObject->position(elem.first);
-                manualObject->colour(elem.second.r, elem.second.g, elem.second.b, fillAlpha);
+                manualObject->position(pair.first);
+                manualObject->colour(pair.second.r, pair.second.g, pair.second.b, fillAlpha);
             }
-            for (auto & elem : triangleIndices)
-                manualObject->index(elem);
+            for (int triangleIndex : triangleIndices)
+                manualObject->index(triangleIndex);
         }
         else
Index: /code/branches/cpp11_v2/src/libraries/tools/IcoSphere.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/tools/IcoSphere.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/tools/IcoSphere.cc	(revision 10916)
@@ -116,7 +116,6 @@
             std::list<TriangleIndices> faces2;
 
-            for (auto f : faces)
+            for (const TriangleIndices& f : faces)
             {
-                
                 int a = getMiddlePoint(f.v1, f.v2);
                 int b = getMiddlePoint(f.v2, f.v3);
@@ -194,8 +193,8 @@
     void IcoSphere::addToLineIndices(int baseIndex, std::list<int>* target) const
     {
-        for (const auto & elem : lineIndices)
+        for (const LineIndices& line : lineIndices)
         {
-            target->push_back(baseIndex + (elem).v1);
-            target->push_back(baseIndex + (elem).v2);
+            target->push_back(baseIndex + line.v1);
+            target->push_back(baseIndex + line.v2);
         }
     }
@@ -203,9 +202,9 @@
     void IcoSphere::addToTriangleIndices(int baseIndex, std::list<int>* target) const
     {
-        for (const auto & elem : faces)
+        for (const TriangleIndices& triangle : faces)
         {
-            target->push_back(baseIndex + (elem).v1);
-            target->push_back(baseIndex + (elem).v2);
-            target->push_back(baseIndex + (elem).v3);
+            target->push_back(baseIndex + triangle.v1);
+            target->push_back(baseIndex + triangle.v2);
+            target->push_back(baseIndex + triangle.v3);
         }
     }
@@ -217,6 +216,6 @@
         transform.setScale(Ogre::Vector3(scale, scale, scale));
 
-        for (auto & elem : vertices)
-            target->push_back(VertexPair(transform * elem, colour));
+        for (const Ogre::Vector3& vertex : vertices)
+            target->push_back(VertexPair(transform * vertex, colour));
 
         return vertices.size();
Index: /code/branches/cpp11_v2/src/libraries/tools/Shader.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/tools/Shader.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/tools/Shader.cc	(revision 10916)
@@ -197,23 +197,23 @@
     {
         // iterate through the list of parameters
-        for (auto & elem : this->parameters_)
-        {
-            Ogre::Technique* techniquePtr = materialPtr->getTechnique(elem.technique_);
+        for (const ParameterContainer& parameter : this->parameters_)
+        {
+            Ogre::Technique* techniquePtr = materialPtr->getTechnique(parameter.technique_);
             if (techniquePtr)
             {
-                Ogre::Pass* passPtr = techniquePtr->getPass(elem.pass_);
+                Ogre::Pass* passPtr = techniquePtr->getPass(parameter.pass_);
                 if (passPtr)
                 {
                     // change the value of the parameter depending on its type
-                    if (elem.value_.isType<int>())
-                        passPtr->getFragmentProgramParameters()->setNamedConstant(elem.parameter_, elem.value_.get<int>());
-                    else if (elem.value_.isType<float>())
-                        passPtr->getFragmentProgramParameters()->setNamedConstant(elem.parameter_, elem.value_.get<float>());
+                    if (parameter.value_.isType<int>())
+                        passPtr->getFragmentProgramParameters()->setNamedConstant(parameter.parameter_, parameter.value_.get<int>());
+                    else if (parameter.value_.isType<float>())
+                        passPtr->getFragmentProgramParameters()->setNamedConstant(parameter.parameter_, parameter.value_.get<float>());
                 }
                 else
-                    orxout(internal_warning) << "No pass " << elem.pass_ << " in technique " << elem.technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
+                    orxout(internal_warning) << "No pass " << parameter.pass_ << " in technique " << parameter.technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
             }
             else
-                orxout(internal_warning) << "No technique " << elem.technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
+                orxout(internal_warning) << "No technique " << parameter.technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
         }
         this->parameters_.clear();
@@ -228,5 +228,5 @@
         {
             const Ogre::Root::PluginInstanceList& plugins = Ogre::Root::getSingleton().getInstalledPlugins();
-            for (auto & plugin : plugins)
+            for (Ogre::Plugin* plugin : plugins)
                 if (plugin->getName() == "Cg Program Manager")
                     return true;
Index: /code/branches/cpp11_v2/src/libraries/util/DisplayStringConversions.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/util/DisplayStringConversions.h	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/util/DisplayStringConversions.h	(revision 10916)
@@ -51,7 +51,7 @@
             {
                 Ogre::UTFString::code_point cp;
-                for (auto & elem : input)
+                for (const char& character : input)
                 {
-                  cp = elem;
+                  cp = character;
                   cp &= 0xFF;
                   output->append(1, cp);
Index: /code/branches/cpp11_v2/src/libraries/util/Serialise.h
===================================================================
--- /code/branches/cpp11_v2/src/libraries/util/Serialise.h	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/util/Serialise.h	(revision 10916)
@@ -672,6 +672,6 @@
     {
         uint32_t tempsize = sizeof(uint32_t); // for the number of entries
-        for(const auto & elem : *((std::set<T>*)(&variable)))
-            tempsize += returnSize( elem );
+        for(const T& element : *((std::set<T>*)(&variable)))
+            tempsize += returnSize( element );
         return tempsize;
     }
Index: /code/branches/cpp11_v2/src/libraries/util/SignalHandler.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/util/SignalHandler.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/util/SignalHandler.cc	(revision 10916)
@@ -81,7 +81,7 @@
     void SignalHandler::dontCatch()
     {
-      for (auto & elem : sigRecList)
-      {
-        signal( elem.signal, elem.handler );
+      for (const SignalRec& sigRec : sigRecList)
+      {
+        signal( sigRec.signal, sigRec.handler );
       }
 
@@ -133,7 +133,7 @@
       }
 
-      for (auto & elem : SignalHandler::getInstance().callbackList)
-      {
-        (*(elem.cb))( elem.someData );
+      for (const SignalCallbackRec& callback : SignalHandler::getInstance().callbackList)
+      {
+        (*(callback.cb))( callback.someData );
       }
 
Index: /code/branches/cpp11_v2/src/libraries/util/SmallObjectAllocator.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/util/SmallObjectAllocator.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/util/SmallObjectAllocator.cc	(revision 10916)
@@ -53,6 +53,6 @@
     SmallObjectAllocator::~SmallObjectAllocator()
     {
-        for (auto & elem : this->blocks_)
-            delete[] elem;
+        for (char* block : this->blocks_)
+            delete[] block;
     }
 
Index: /code/branches/cpp11_v2/src/libraries/util/StringUtils.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/util/StringUtils.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/util/StringUtils.cc	(revision 10916)
@@ -262,7 +262,7 @@
         std::string output(str.size() * 2, ' ');
         size_t i = 0;
-        for (auto & elem : str)
-        {
-            switch (elem)
+        for (const char& character : str)
+        {
+            switch (character)
             {
             case '\\': output[i] = '\\'; output[i + 1] = '\\'; break;
@@ -276,5 +276,5 @@
             case  '"': output[i] = '\\'; output[i + 1] =  '"'; break;
             case '\0': output[i] = '\\'; output[i + 1] =  '0'; break;
-            default  : output[i] = elem; ++i; continue;
+            default  : output[i] = character; ++i; continue;
             }
             i += 2;
@@ -336,7 +336,7 @@
     void lowercase(std::string* str)
     {
-        for (auto & elem : *str)
-        {
-            elem = static_cast<char>(tolower(elem));
+        for (char& character : *str)
+        {
+            character = static_cast<char>(tolower(character));
         }
     }
@@ -353,7 +353,7 @@
     void uppercase(std::string* str)
     {
-        for (auto & elem : *str)
-        {
-            elem = static_cast<char>(toupper(elem));
+        for (char& character : *str)
+        {
+            character = static_cast<char>(toupper(character));
         }
     }
@@ -460,9 +460,9 @@
     {
         size_t j = 0;
-        for (auto & elem : str)
-        {
-            if (elem == target)
+        for (char& character : str)
+        {
+            if (character == target)
             {
-                elem = replacement;
+                character = replacement;
                 ++j;
             }
Index: /code/branches/cpp11_v2/src/libraries/util/output/BaseWriter.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/util/output/BaseWriter.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/util/output/BaseWriter.cc	(revision 10916)
@@ -116,8 +116,6 @@
 
         // iterate over all strings in the config-vector
-        for (auto & full_name : this->configurableAdditionalContexts_)
+        for (const std::string& full_name : this->configurableAdditionalContexts_)
         {
-            
-
             // split the name into main-name and sub-name (if given; otherwise sub-name remains empty). both names are separated by ::
             std::string name = full_name;
Index: /code/branches/cpp11_v2/src/libraries/util/output/MemoryWriter.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/util/output/MemoryWriter.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/util/output/MemoryWriter.cc	(revision 10916)
@@ -65,7 +65,6 @@
     void MemoryWriter::resendOutput(OutputListener* listener) const
     {
-        for (auto & message : this->messages_)
+        for (const Message& message : this->messages_)
         {
-            
             listener->unfilteredOutput(message.level, *message.context, message.lines);
         }
Index: /code/branches/cpp11_v2/src/libraries/util/output/OutputListener.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/util/output/OutputListener.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/util/output/OutputListener.cc	(revision 10916)
@@ -111,6 +111,6 @@
         this->levelMask_ = mask;
 
-        for (auto & elem : this->listeners_)
-            elem->updatedLevelMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedLevelMask(this);
     }
 
@@ -142,6 +142,6 @@
         this->additionalContextsLevelMask_ = mask;
 
-        for (auto & elem : this->listeners_)
-            elem->updatedAdditionalContextsLevelMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedAdditionalContextsLevelMask(this);
     }
 
@@ -153,6 +153,6 @@
         this->additionalContextsMask_ = mask;
 
-        for (auto & elem : this->listeners_)
-            elem->updatedAdditionalContextsMask(this);
+        for (AdditionalContextListener* listener : this->listeners_)
+            listener->updatedAdditionalContextsMask(this);
     }
 
Index: /code/branches/cpp11_v2/src/libraries/util/output/OutputManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/util/output/OutputManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/util/output/OutputManager.cc	(revision 10916)
@@ -131,6 +131,6 @@
         vectorize(message, '\n', &lines);
 
-        for (auto & elem : this->listeners_)
-            elem->unfilteredOutput(level, context, lines);
+        for (OutputListener* listener : this->listeners_)
+            listener->unfilteredOutput(level, context, lines);
     }
 
@@ -178,6 +178,6 @@
     {
         int mask = 0;
-        for (auto & elem : this->listeners_)
-            mask |= elem->getLevelMask();
+        for (OutputListener* listener : this->listeners_)
+            mask |= listener->getLevelMask();
         this->combinedLevelMask_ = static_cast<OutputLevel>(mask);
     }
@@ -189,6 +189,6 @@
     {
         int mask = 0;
-        for (auto & elem : this->listeners_)
-            mask |= elem->getAdditionalContextsLevelMask();
+        for (OutputListener* listener : this->listeners_)
+            mask |= listener->getAdditionalContextsLevelMask();
         this->combinedAdditionalContextsLevelMask_ = static_cast<OutputLevel>(mask);
     }
@@ -200,6 +200,6 @@
     {
         this->combinedAdditionalContextsMask_ = 0;
-        for (auto & elem : this->listeners_)
-            this->combinedAdditionalContextsMask_ |= elem->getAdditionalContextsMask();
+        for (OutputListener* listener : this->listeners_)
+            this->combinedAdditionalContextsMask_ |= listener->getAdditionalContextsMask();
     }
 
Index: /code/branches/cpp11_v2/src/libraries/util/output/SubcontextOutputListener.cc
===================================================================
--- /code/branches/cpp11_v2/src/libraries/util/output/SubcontextOutputListener.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/libraries/util/output/SubcontextOutputListener.cc	(revision 10916)
@@ -79,8 +79,8 @@
 
         // compose the mask of subcontexts and build the set of sub-context-IDs
-        for (const auto & subcontext : subcontexts)
+        for (const OutputContextContainer* subcontext : subcontexts)
         {
-            this->subcontextsCheckMask_ |= (subcontext)->mask;
-            this->subcontexts_.insert((subcontext)->sub_id);
+            this->subcontextsCheckMask_ |= subcontext->mask;
+            this->subcontexts_.insert(subcontext->sub_id);
         }
 
Index: /code/branches/cpp11_v2/src/modules/docking/Dock.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/docking/Dock.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/docking/Dock.cc	(revision 10916)
@@ -327,8 +327,8 @@
     const DockingEffect* Dock::getEffect(unsigned int i) const
     {
-        for (const auto & elem : this->effects_)
+        for (DockingEffect* effect : this->effects_)
         {
             if(i == 0)
-               return elem;
+               return effect;
             i--;
         }
@@ -346,8 +346,8 @@
     const DockingAnimation* Dock::getAnimation(unsigned int i) const
     {
-        for (const auto & elem : this->animations_)
+        for (DockingAnimation* animation : this->animations_)
         {
             if(i == 0)
-               return elem;
+               return animation;
             i--;
         }
Index: /code/branches/cpp11_v2/src/modules/docking/DockingAnimation.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/docking/DockingAnimation.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/docking/DockingAnimation.cc	(revision 10916)
@@ -57,10 +57,10 @@
         bool check = true;
 
-        for (auto & animations_animation : animations)
+        for (DockingAnimation* animation : animations)
         {
             if(dock)
-                check &= (animations_animation)->docking(player);
+                check &= animation->docking(player);
             else
-                check &= (animations_animation)->release(player);
+                check &= animation->release(player);
         }
 
Index: /code/branches/cpp11_v2/src/modules/docking/DockingEffect.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/docking/DockingEffect.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/docking/DockingEffect.cc	(revision 10916)
@@ -53,10 +53,10 @@
         bool check = true;
 
-        for (auto & effects_effect : effects)
+        for (DockingEffect* effect : effects)
         {
             if (dock)
-                check &= (effects_effect)->docking(player);
+                check &= effect->docking(player);
             else
-                check &= (effects_effect)->release(player);
+                check &= effect->release(player);
         }
 
Index: /code/branches/cpp11_v2/src/modules/gametypes/RaceCheckPoint.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/gametypes/RaceCheckPoint.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/gametypes/RaceCheckPoint.cc	(revision 10916)
@@ -146,11 +146,11 @@
     {
         Vector3 checkpoints(-1,-1,-1); int count=0;
-        for (const auto & elem : nextCheckpoints_)
+        for (int nextCheckpoint : nextCheckpoints_)
         {
             switch (count)
             {
-                case 0: checkpoints.x = static_cast<Ogre::Real>(elem); break;
-                case 1: checkpoints.y = static_cast<Ogre::Real>(elem); break;
-                case 2: checkpoints.z = static_cast<Ogre::Real>(elem); break;
+                case 0: checkpoints.x = static_cast<Ogre::Real>(nextCheckpoint); break;
+                case 1: checkpoints.y = static_cast<Ogre::Real>(nextCheckpoint); break;
+                case 2: checkpoints.z = static_cast<Ogre::Real>(nextCheckpoint); break;
             }
             ++count;
Index: /code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceController.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceController.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceController.cc	(revision 10916)
@@ -154,16 +154,16 @@
     {
         std::map<RaceCheckPoint*, int> zaehler; // counts how many times the checkpoint was reached (for simulation)
-        for (auto & allCheckpoint : allCheckpoints)
-        {
-            zaehler.insert(std::pair<RaceCheckPoint*, int>(allCheckpoint,0));
+        for (RaceCheckPoint* checkpoint : allCheckpoints)
+        {
+            zaehler.insert(std::pair<RaceCheckPoint*, int>(checkpoint,0));
         }
         int maxWays = rekSimulationCheckpointsReached(currentCheckpoint, zaehler);
 
         std::vector<RaceCheckPoint*> returnVec;
-        for (auto & elem : zaehler)
-        {
-            if (elem.second == maxWays)
-            {
-                returnVec.push_back(elem.first);
+        for (auto& mapEntry : zaehler)
+        {
+            if (mapEntry.second == maxWays)
+            {
+                returnVec.push_back(mapEntry.first);
             }
         }
@@ -226,7 +226,7 @@
 
         // find the next checkpoint with the minimal distance
-        for (auto elem : raceCheckpoint->getNextCheckpoints())
-        {
-            RaceCheckPoint* nextRaceCheckPoint = findCheckpoint(elem);
+        for (int checkpointIndex : raceCheckpoint->getNextCheckpoints())
+        {
+            RaceCheckPoint* nextRaceCheckPoint = findCheckpoint(checkpointIndex);
             float distance = recCalculateDistance(nextRaceCheckPoint, this->getControllableEntity()->getPosition());
 
@@ -289,7 +289,7 @@
     RaceCheckPoint* SpaceRaceController::findCheckpoint(int index) const
     {
-        for (auto & elem : this->checkpoints_)
-            if (elem->getCheckpointIndex() == index)
-                return elem;
+        for (RaceCheckPoint* checkpoint : this->checkpoints_)
+            if (checkpoint->getCheckpointIndex() == index)
+                return checkpoint;
         return nullptr;
     }
@@ -414,9 +414,9 @@
         btScalar radiusObject;
 
-        for (const auto & allObject : allObjects)
-        {
-            for (int everyShape=0; (allObject)->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
-            {
-                btCollisionShape* currentShape = (allObject)->getAttachedCollisionShape(everyShape)->getCollisionShape();
+        for (StaticEntity* object : allObjects)
+        {
+            for (int everyShape=0; object->getAttachedCollisionShape(everyShape) != nullptr; everyShape++)
+            {
+                btCollisionShape* currentShape = object->getAttachedCollisionShape(everyShape)->getCollisionShape();
                 if(currentShape == nullptr)
                 continue;
Index: /code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceManager.cc	(revision 10916)
@@ -54,6 +54,6 @@
     SpaceRaceManager::~SpaceRaceManager()
     {
-        for (auto & elem : this->checkpoints_)
-        elem->destroy();
+        for (RaceCheckPoint* checkpoint : this->checkpoints_)
+        checkpoint->destroy();
     }
 
@@ -77,11 +77,11 @@
         }
 
-        for (auto & elem : players_)
+        for (auto& mapEntry : players_)
         {
 
-            for (auto & _i : this->checkpoints_)
+            for (RaceCheckPoint* checkpoint : this->checkpoints_)
             {
-                if (_i->playerWasHere(elem.first)){
-                this->checkpointReached(_i, elem.first /*this->checkpoints_[i]->getPlayer()*/);
+                if (checkpoint->playerWasHere(mapEntry.first)){
+                this->checkpointReached(checkpoint, mapEntry.first /*this->checkpoints_[i]->getPlayer()*/);
                 }
             }
@@ -113,7 +113,7 @@
     RaceCheckPoint* SpaceRaceManager::findCheckpoint(int index) const
     {
-        for (auto & elem : this->checkpoints_)
-        if (elem->getCheckpointIndex() == index)
-        return elem;
+        for (RaceCheckPoint* checkpoint : this->checkpoints_)
+        if (checkpoint->getCheckpointIndex() == index)
+        return checkpoint;
         return nullptr;
     }
@@ -125,5 +125,5 @@
             // the player already visited an old checkpoint; see which checkpoints are possible now
             const std::set<int>& possibleCheckpoints = oldCheckpoint->getNextCheckpoints();
-            for (const auto & possibleCheckpoint : possibleCheckpoints)
+            for (int possibleCheckpoint : possibleCheckpoints)
             if (this->findCheckpoint(possibleCheckpoint) == newCheckpoint)
             return true;
@@ -179,6 +179,6 @@
         {
             const std::set<int>& oldVisible = oldCheckpoint->getNextCheckpoints();
-            for (const auto & elem : oldVisible)
-            this->findCheckpoint(elem)->setRadarVisibility(false);
+            for (int checkpointIndex : oldVisible)
+            this->findCheckpoint(checkpointIndex)->setRadarVisibility(false);
         }
 
@@ -188,6 +188,6 @@
 
             const std::set<int>& newVisible = newCheckpoint->getNextCheckpoints();
-            for (const auto & elem : newVisible)
-            this->findCheckpoint(elem)->setRadarVisibility(true);
+            for (int checkpointIndex : newVisible)
+            this->findCheckpoint(checkpointIndex)->setRadarVisibility(true);
         }
     }
Index: /code/branches/cpp11_v2/src/modules/jump/Jump.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/jump/Jump.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/jump/Jump.cc	(revision 10916)
@@ -633,10 +633,10 @@
 
 
-        for (auto & elem : matrix)
+        for (int i = 0; i < numI; ++i)
         {
             for (int j = 0; j < numJ; ++j)
             {
-                elem[j].type = PLATFORM_EMPTY;
-                elem[j].done = false;
+                matrix[i][j].type = PLATFORM_EMPTY;
+                matrix[i][j].done = false;
             }
         }
@@ -795,5 +795,5 @@
 
         // Fill matrix with selected platform types
-        for (auto & elem : matrix)
+        for (int i = 0; i < numI; ++ i)
         {
             for (int j = 0; j < numJ; ++ j)
@@ -801,11 +801,11 @@
                 if (rand()%3 == 0)
                 {
-                    elem[j].type = platformtype1;
+                    matrix[i][j].type = platformtype1;
                 }
                 else
                 {
-                    elem[j].type = platformtype2;
+                    matrix[i][j].type = platformtype2;
                 }
-                elem[j].done = false;
+                matrix[i][j].done = false;
             }
         }
Index: /code/branches/cpp11_v2/src/modules/mini4dgame/Mini4Dgame.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/mini4dgame/Mini4Dgame.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/mini4dgame/Mini4Dgame.cc	(revision 10916)
@@ -155,11 +155,11 @@
     {
         // first spawn human players to assign always the left bat to the player in singleplayer
-        for (auto & elem : this->players_)
-            if (elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(mapEntry.first);
         // now spawn bots
-        for (auto & elem : this->players_)
-            if (!elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (!mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(mapEntry.first);
     }
 
Index: /code/branches/cpp11_v2/src/modules/notifications/NotificationManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/notifications/NotificationManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/notifications/NotificationManager.cc	(revision 10916)
@@ -69,6 +69,6 @@
     {
         // Destroys all Notifications.
-        for(auto & elem : this->allNotificationsList_)
-            elem.second->destroy();
+        for(auto& mapEntry : this->allNotificationsList_)
+            mapEntry.second->destroy();
         this->allNotificationsList_.clear();
 
@@ -152,10 +152,10 @@
         bool executed = false;
         // Clear all NotificationQueues that have the input sender as target.
-        for(auto & elem : this->queues_) // Iterate through all NotificationQueues.
-        {
-            const std::set<std::string>& set = elem.second->getTargetsSet();
+        for(auto& mapEntry : this->queues_) // Iterate through all NotificationQueues.
+        {
+            const std::set<std::string>& set = mapEntry.second->getTargetsSet();
             // If either the sender is 'all', the NotificationQueue has as target all or the NotificationQueue has the input sender as a target.
             if(all || set.find(NotificationListener::ALL) != set.end() || set.find(sender) != set.end())
-                executed = elem.second->tidy() || executed;
+                executed = mapEntry.second->tidy() || executed;
         }
 
@@ -187,7 +187,7 @@
 
         // Insert the Notification in all NotificationQueues that have its sender as target.
-        for(auto & elem : this->queues_) // Iterate through all NotificationQueues.
-        {
-            const std::set<std::string>& set = elem.second->getTargetsSet();
+        for(auto& mapEntry : this->queues_) // Iterate through all NotificationQueues.
+        {
+            const std::set<std::string>& set = mapEntry.second->getTargetsSet();
             bool bAll = set.find(NotificationListener::ALL) != set.end();
             // If either the Notification has as sender 'all', the NotificationQueue displays all Notifications or the NotificationQueue has the sender of the Notification as target.
@@ -195,6 +195,6 @@
             {
                 if(!bAll)
-                    this->notificationLists_[elem.second->getName()]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationQueue.
-                elem.second->update(notification, time); // Update the NotificationQueue.
+                    this->notificationLists_[mapEntry.second->getName()]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationQueue.
+                mapEntry.second->update(notification, time); // Update the NotificationQueue.
             }
         }
@@ -345,8 +345,8 @@
 
         // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationQueue.
-        for(auto & elem : this->allNotificationsList_)
-        {
-            if(!bAll && set.find(elem.second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
-                map->insert(std::pair<std::time_t, Notification*>(elem.first, elem.second));
+        for(auto& mapEntry : this->allNotificationsList_)
+        {
+            if(!bAll && set.find(mapEntry.second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
+                map->insert(std::pair<std::time_t, Notification*>(mapEntry.first, mapEntry.second));
         }
 
Index: /code/branches/cpp11_v2/src/modules/notifications/NotificationQueue.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/notifications/NotificationQueue.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/notifications/NotificationQueue.cc	(revision 10916)
@@ -206,8 +206,8 @@
         {
             // Add all Notifications that have been created after this NotificationQueue was created.
-            for(auto & notification : *notifications)
+            for(auto& mapEntry : *notifications)
             {
-                if(notification.first >= this->creationTime_)
-                    this->push(notification.second, notification.first);
+                if(mapEntry.first >= this->creationTime_)
+                    this->push(mapEntry.second, mapEntry.first);
             }
         }
@@ -336,6 +336,6 @@
         this->ordering_.clear();
         // Delete all NotificationContainers in the list.
-        for(auto & elem : this->notifications_)
-            delete elem;
+        for(NotificationContainer* notification : this->notifications_)
+            delete notification;
 
         this->notifications_.clear();
@@ -426,5 +426,5 @@
         bool first = true;
         // Iterate through the set of targets.
-        for(const auto & elem : this->targets_)
+        for(const std::string& target : this->targets_)
         {
             if(!first)
@@ -432,5 +432,5 @@
             else
                 first = false;
-            stream << elem;
+            stream << target;
         }
 
Index: /code/branches/cpp11_v2/src/modules/objects/Attacher.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/objects/Attacher.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/objects/Attacher.cc	(revision 10916)
@@ -61,6 +61,6 @@
         SUPER(Attacher, changedActivity);
 
-        for (auto & elem : this->objects_)
-            (elem)->setActive(this->isActive());
+        for (WorldEntity* object : this->objects_)
+            object->setActive(this->isActive());
     }
 
@@ -69,6 +69,6 @@
         SUPER(Attacher, changedVisibility);
 
-        for (auto & elem : this->objects_)
-            (elem)->setVisible(this->isVisible());
+        for (WorldEntity* object : this->objects_)
+            object->setVisible(this->isVisible());
     }
 
@@ -83,8 +83,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->objects_)
+        for (WorldEntity* object : this->objects_)
         {
             if (i == index)
-                return (elem);
+                return object;
 
             ++i;
Index: /code/branches/cpp11_v2/src/modules/objects/Script.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/objects/Script.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/objects/Script.cc	(revision 10916)
@@ -196,7 +196,7 @@
             {
                 const std::map<unsigned int, PlayerInfo*> clients = PlayerManager::getInstance().getClients();
-                for(const auto & client : clients)
+                for(const auto& mapEntry : clients)
                 {
-                    callStaticNetworkFunction(&Script::executeHelper, client.first, this->getCode(), this->getMode(), this->getNeedsGraphics());
+                    callStaticNetworkFunction(&Script::executeHelper, mapEntry.first, this->getCode(), this->getMode(), this->getNeedsGraphics());
                     if(this->times_ != Script::INF) // Decrement the number of remaining executions.
                     {
Index: /code/branches/cpp11_v2/src/modules/objects/SpaceBoundaries.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/objects/SpaceBoundaries.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/objects/SpaceBoundaries.cc	(revision 10916)
@@ -59,9 +59,9 @@
             this->pawnsIn_.clear();
 
-            for(auto & elem : this->billboards_)
+            for(BillboardAdministration& billboard : this->billboards_)
             {
-                if( elem.billy != nullptr)
-                {
-                    delete elem.billy;
+                if( billboard.billy != nullptr)
+                {
+                    delete billboard.billy;
                 }
             }
@@ -138,8 +138,8 @@
     void SpaceBoundaries::removeAllBillboards()
     {
-        for(auto & elem : this->billboards_)
-        {
-            elem.usedYet = false;
-            elem.billy->setVisible(false);
+        for(BillboardAdministration& billboard : this->billboards_)
+        {
+            billboard.usedYet = false;
+            billboard.billy->setVisible(false);
         }
     }
@@ -208,7 +208,6 @@
         float distance;
         bool humanItem;
-        for(auto currentPawn : pawnsIn_)
-        {
-            
+        for(Pawn* currentPawn : pawnsIn_)
+        {
             if( currentPawn && currentPawn->getNode() ) 
             {
Index: /code/branches/cpp11_v2/src/modules/objects/eventsystem/EventDispatcher.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/objects/eventsystem/EventDispatcher.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/objects/eventsystem/EventDispatcher.cc	(revision 10916)
@@ -45,6 +45,6 @@
     {
         if (this->isInitialized())
-            for (auto & elem : this->targets_)
-                (elem)->destroy();
+            for (BaseObject* target : this->targets_)
+                target->destroy();
     }
 
@@ -61,6 +61,6 @@
     void EventDispatcher::processEvent(Event& event)
     {
-        for (auto & elem : this->targets_)
-            (elem)->processEvent(event);
+        for (BaseObject* target : this->targets_)
+            target->processEvent(event);
     }
 
@@ -73,8 +73,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->targets_)
+        for (BaseObject* target : this->targets_)
         {
             if (i == index)
-                return (elem);
+                return target;
             ++i;
         }
Index: /code/branches/cpp11_v2/src/modules/objects/eventsystem/EventFilter.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/objects/eventsystem/EventFilter.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/objects/eventsystem/EventFilter.cc	(revision 10916)
@@ -96,8 +96,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->sources_)
+        for (BaseObject* source : this->sources_)
         {
             if (i == index)
-                return (elem);
+                return source;
             ++i;
         }
@@ -113,8 +113,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->names_)
+        for (EventName* name : this->names_)
         {
             if (i == index)
-                return (elem);
+                return name;
             ++i;
         }
Index: /code/branches/cpp11_v2/src/modules/objects/triggers/DistanceMultiTrigger.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/objects/triggers/DistanceMultiTrigger.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/objects/triggers/DistanceMultiTrigger.cc	(revision 10916)
@@ -158,9 +158,9 @@
             {
                 
-                const std::set<WorldEntity*> attached = entity->getAttachedObjects();
+                const std::set<WorldEntity*> attachedObjects = entity->getAttachedObjects();
                 bool found = false;
-                for(const auto & elem : attached)
+                for(WorldEntity* attachedObject : attachedObjects)
                 {
-                    if((elem)->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(elem)->getName() == this->targetName_)
+                    if(attachedObject->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(attachedObject)->getName() == this->targetName_)
                     {
                         found = true;
Index: /code/branches/cpp11_v2/src/modules/objects/triggers/DistanceTrigger.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/objects/triggers/DistanceTrigger.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/objects/triggers/DistanceTrigger.cc	(revision 10916)
@@ -180,9 +180,9 @@
             {
 
-                const std::set<WorldEntity*> attached = entity->getAttachedObjects();
+                const std::set<WorldEntity*> attachedObjects = entity->getAttachedObjects();
                 bool found = false;
-                for(const auto & elem : attached)
+                for(WorldEntity* attachedObject : attachedObjects)
                 {
-                    if((elem)->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(elem)->getName() == this->targetName_)
+                    if(attachedObject->isA(ClassIdentifier<DistanceTriggerBeacon>::getIdentifier()) && static_cast<DistanceTriggerBeacon*>(attachedObject)->getName() == this->targetName_)
                     {
                         found = true;
Index: /code/branches/cpp11_v2/src/modules/objects/triggers/MultiTrigger.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/objects/triggers/MultiTrigger.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/objects/triggers/MultiTrigger.cc	(revision 10916)
@@ -504,7 +504,6 @@
     bool MultiTrigger::checkAnd(BaseObject* triggerer)
     {
-        for(auto trigger : this->children_)
-        {
-            
+        for(TriggerBase* trigger : this->children_)
+        {
             if(trigger->isMultiTrigger())
             {
@@ -531,7 +530,6 @@
     bool MultiTrigger::checkOr(BaseObject* triggerer)
     {
-        for(auto trigger : this->children_)
-        {
-            
+        for(TriggerBase* trigger : this->children_)
+        {
             if(trigger->isMultiTrigger())
             {
@@ -559,7 +557,6 @@
     {
         bool triggered = false;
-        for(auto trigger : this->children_)
-        {
-            
+        for(TriggerBase* trigger : this->children_)
+        {
             if(triggered)
             {
Index: /code/branches/cpp11_v2/src/modules/objects/triggers/Trigger.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/objects/triggers/Trigger.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/objects/triggers/Trigger.cc	(revision 10916)
@@ -234,7 +234,7 @@
     {
         // Iterate over all sub-triggers.
-        for (const auto & elem : this->children_)
-        {
-            if (!(elem)->isActive())
+        for (TriggerBase* child : this->children_)
+        {
+            if (!child->isActive())
                 return false;
         }
@@ -252,7 +252,7 @@
     {
         // Iterate over all sub-triggers.
-        for (const auto & elem : this->children_)
-        {
-            if ((elem)->isActive())
+        for (TriggerBase* child : this->children_)
+        {
+            if (child->isActive())
                 return true;
         }
@@ -270,9 +270,9 @@
     {
         bool test = false;
-        for (const auto & elem : this->children_)
-        {
-            if (test && (elem)->isActive())
+        for (TriggerBase* child : this->children_)
+        {
+            if (test && child->isActive())
                 return false;
-            if ((elem)->isActive())
+            if (child->isActive())
                 test = true;
         }
Index: /code/branches/cpp11_v2/src/modules/overlays/hud/ChatOverlay.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/overlays/hud/ChatOverlay.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/overlays/hud/ChatOverlay.cc	(revision 10916)
@@ -58,6 +58,6 @@
     ChatOverlay::~ChatOverlay()
     {
-        for (const auto & elem : this->timers_)
-            delete (elem);
+        for (Timer* timer : this->timers_)
+            delete timer;
     }
 
@@ -92,7 +92,7 @@
         this->text_->setCaption("");
 
-        for (auto & elem : this->messages_)
+        for (const Ogre::DisplayString& message : this->messages_)
         {
-            this->text_->setCaption(this->text_->getCaption() + "\n" + (elem));
+            this->text_->setCaption(this->text_->getCaption() + "\n" + message);
         }
     }
Index: /code/branches/cpp11_v2/src/modules/overlays/hud/HUDNavigation.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/overlays/hud/HUDNavigation.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/overlays/hud/HUDNavigation.cc	(revision 10916)
@@ -131,8 +131,8 @@
         }
         this->fontName_ = font;
-        for (auto & elem : this->activeObjectList_)
-        {
-            if (elem.second.text_ != nullptr)
-                elem.second.text_->setFontName(this->fontName_);
+        for (auto& mapEntry : this->activeObjectList_)
+        {
+            if (mapEntry.second.text_ != nullptr)
+                mapEntry.second.text_->setFontName(this->fontName_);
         }
     }
@@ -151,8 +151,8 @@
         }
         this->textSize_ = size;
-        for (auto & elem : this->activeObjectList_)
-        {
-            if (elem.second.text_)
-                elem.second.text_->setCharHeight(size);
+        for (auto& mapEntry : this->activeObjectList_)
+        {
+            if (mapEntry.second.text_)
+                mapEntry.second.text_->setCharHeight(size);
         }
     }
@@ -186,6 +186,6 @@
         const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
 
-        for (auto & elem : this->sortedObjectList_)
-        elem.second = (int)((elem.first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
+        for (std::pair<RadarViewable*, unsigned int>& pair : this->sortedObjectList_)
+        pair.second = (int)((pair.first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
 
         this->sortedObjectList_.sort(compareDistance);
@@ -531,16 +531,16 @@
         float yScale = this->getActualSize().y;
 
-        for (auto & elem : this->activeObjectList_)
-        {
-            if (elem.second.health_ != nullptr)
-                elem.second.health_->setDimensions(this->healthMarkerSize_ * xScale, this->healthMarkerSize_ * yScale);
-            if (elem.second.healthLevel_ != nullptr)
-                elem.second.healthLevel_->setDimensions(this->healthLevelMarkerSize_ * xScale, this->healthLevelMarkerSize_ * yScale);
-            if (elem.second.panel_ != nullptr)
-                elem.second.panel_->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
-            if (elem.second.text_ != nullptr)
-                elem.second.text_->setCharHeight(this->textSize_ * yScale);
-            if (elem.second.target_ != nullptr)
-                elem.second.target_->setDimensions(this->aimMarkerSize_ * xScale, this->aimMarkerSize_ * yScale);
+        for (auto& mapEntry : this->activeObjectList_)
+        {
+            if (mapEntry.second.health_ != nullptr)
+                mapEntry.second.health_->setDimensions(this->healthMarkerSize_ * xScale, this->healthMarkerSize_ * yScale);
+            if (mapEntry.second.healthLevel_ != nullptr)
+                mapEntry.second.healthLevel_->setDimensions(this->healthLevelMarkerSize_ * xScale, this->healthLevelMarkerSize_ * yScale);
+            if (mapEntry.second.panel_ != nullptr)
+                mapEntry.second.panel_->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
+            if (mapEntry.second.text_ != nullptr)
+                mapEntry.second.text_->setCharHeight(this->textSize_ * yScale);
+            if (mapEntry.second.target_ != nullptr)
+                mapEntry.second.target_->setDimensions(this->aimMarkerSize_ * xScale, this->aimMarkerSize_ * yScale);
         }
     }
@@ -670,7 +670,7 @@
     {
         const std::set<RadarViewable*>& respawnObjects = this->getOwner()->getScene()->getRadar()->getRadarObjects();
-        for (const auto & respawnObject : respawnObjects)
-        {
-            if (!(respawnObject)->isHumanShip_)
+        for (RadarViewable* respawnObject : respawnObjects)
+        {
+            if (!respawnObject->isHumanShip_)
             this->addObject(respawnObject);
         }
Index: /code/branches/cpp11_v2/src/modules/overlays/hud/HUDRadar.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/overlays/hud/HUDRadar.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/overlays/hud/HUDRadar.cc	(revision 10916)
@@ -92,7 +92,7 @@
             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->map3DBack_);
 
-            for (auto & elem : this->radarObjects_)
-            {
-                Ogre::OverlayManager::getSingleton().destroyOverlayElement(elem.second);
+            for (auto& mapEntry : this->radarObjects_)
+            {
+                Ogre::OverlayManager::getSingleton().destroyOverlayElement(mapEntry.second);
             }
         }
Index: /code/branches/cpp11_v2/src/modules/overlays/stats/Scoreboard.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/overlays/stats/Scoreboard.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/overlays/stats/Scoreboard.cc	(revision 10916)
@@ -60,6 +60,6 @@
         SUPER(Scoreboard, changedVisibility);
 
-        for (auto & elem : this->lines_)
-            elem->changedVisibility();
+        for (CreateLines* line : this->lines_)
+            line->changedVisibility();
     }
 
@@ -94,9 +94,9 @@
 
         unsigned int index = 0;
-        for (const auto & elem : playerList)
+        for (const auto& mapEntry : playerList)
         {
-            this->lines_[index]->setPlayerName(multi_cast<std::string>(elem.first->getName()));
-            this->lines_[index]->setScore(multi_cast<std::string>(elem.second.frags_));
-            this->lines_[index]->setDeaths(multi_cast<std::string>(elem.second.killed_));
+            this->lines_[index]->setPlayerName(multi_cast<std::string>(mapEntry.first->getName()));
+            this->lines_[index]->setScore(multi_cast<std::string>(mapEntry.second.frags_));
+            this->lines_[index]->setDeaths(multi_cast<std::string>(mapEntry.second.killed_));
             index++;
         }
Index: /code/branches/cpp11_v2/src/modules/pickup/PickupCollection.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/pickup/PickupCollection.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/pickup/PickupCollection.cc	(revision 10916)
@@ -68,8 +68,8 @@
     {
         // Destroy all Pickupables constructing this PickupCollection.
-        for(auto & elem : this->pickups_)
-        {
-            (elem)->wasRemovedFromCollection();
-            (elem)->destroy();
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            pickup->wasRemovedFromCollection();
+            pickup->destroy();
         }
         this->pickups_.clear();
@@ -99,6 +99,6 @@
         this->processingUsed_ = true;
         // Change used for all Pickupables this PickupCollection consists of.
-        for(auto & elem : this->pickups_)
-            (elem)->setUsed(this->isUsed());
+        for(CollectiblePickup* pickup : this->pickups_)
+            pickup->setUsed(this->isUsed());
 
         this->processingUsed_ = false;
@@ -119,9 +119,9 @@
         size_t numPickupsEnabled = 0;
         size_t numPickupsInUse = 0;
-        for(auto & elem : this->pickups_)
-        {
-            if ((elem)->isEnabled())
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            if (pickup->isEnabled())
                 ++numPickupsEnabled;
-            if ((elem)->isUsed())
+            if (pickup->isUsed())
                 ++numPickupsInUse;
         }
@@ -146,10 +146,10 @@
 
         // Change the PickupCarrier for all Pickupables this PickupCollection consists of.
-        for(auto & elem : this->pickups_)
+        for(CollectiblePickup* pickup : this->pickups_)
         {
             if(this->getCarrier() == nullptr)
-                (elem)->setCarrier(nullptr);
+                pickup->setCarrier(nullptr);
             else
-                (elem)->setCarrier(this->getCarrier()->getTarget(elem));
+                pickup->setCarrier(this->getCarrier()->getTarget(pickup));
         }
     }
@@ -186,7 +186,7 @@
         // If at least all the enabled pickups of this PickupCollection are no longer picked up.
         bool isOnePickupEnabledAndPickedUp = false;
-        for(auto & elem : this->pickups_)
-        {
-            if ((elem)->isEnabled() && (elem)->isPickedUp())
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            if (pickup->isEnabled() && pickup->isPickedUp())
             {
                 isOnePickupEnabledAndPickedUp = true;
@@ -208,7 +208,7 @@
     bool PickupCollection::isTarget(const PickupCarrier* carrier) const
     {
-        for(const auto & elem : this->pickups_)
-        {
-            if(!carrier->isTarget(elem))
+        for(CollectiblePickup* pickup : this->pickups_)
+        {
+            if(!carrier->isTarget(pickup))
                 return false;
         }
Index: /code/branches/cpp11_v2/src/modules/pickup/PickupManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/pickup/PickupManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/pickup/PickupManager.cc	(revision 10916)
@@ -91,6 +91,6 @@
 
         // Destroying all the PickupInventoryContainers that are still there.
-        for(auto & elem : this->pickupInventoryContainers_)
-            delete elem.second;
+        for(auto& mapEntry : this->pickupInventoryContainers_)
+            delete mapEntry.second;
         this->pickupInventoryContainers_.clear();
 
Index: /code/branches/cpp11_v2/src/modules/pickup/items/MetaPickup.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/pickup/items/MetaPickup.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/pickup/items/MetaPickup.cc	(revision 10916)
@@ -118,7 +118,6 @@
                 std::set<Pickupable*> pickups = carrier->getPickups();
                 // Iterate over all Pickupables of the PickupCarrier.
-                for(auto pickup : pickups)
+                for(Pickupable* pickup : pickups)
                 {
-                    
                     if(pickup == nullptr || pickup == this)
                         continue;
Index: /code/branches/cpp11_v2/src/modules/pong/Pong.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/pong/Pong.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/pong/Pong.cc	(revision 10916)
@@ -145,10 +145,10 @@
 
             // If one of the bats is missing, create it. Apply the template for the bats as specified in the centerpoint.
-            for (auto & elem : this->bat_)
+            for (WeakPtr<orxonox::PongBat>& bat : this->bat_)
             {
-                if (elem == nullptr)
+                if (bat == nullptr)
                 {
-                    elem = new PongBat(this->center_->getContext());
-                    elem->addTemplate(this->center_->getBattemplate());
+                    bat = new PongBat(this->center_->getContext());
+                    bat->addTemplate(this->center_->getBattemplate());
                 }
             }
@@ -211,11 +211,11 @@
     {
         // first spawn human players to assign always the left bat to the player in singleplayer
-        for (auto & elem : this->players_)
-            if (elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(mapEntry.first);
         // now spawn bots
-        for (auto & elem : this->players_)
-            if (!elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (!mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(mapEntry.first);
     }
 
Index: /code/branches/cpp11_v2/src/modules/pong/PongAI.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/pong/PongAI.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/pong/PongAI.cc	(revision 10916)
@@ -77,6 +77,6 @@
     PongAI::~PongAI()
     {
-        for (auto & elem : this->reactionTimers_)
-            elem.first->destroy();
+        for (std::pair<Timer*, char>& pair : this->reactionTimers_)
+            pair.first->destroy();
     }
 
Index: /code/branches/cpp11_v2/src/modules/questsystem/GlobalQuest.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/questsystem/GlobalQuest.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/questsystem/GlobalQuest.cc	(revision 10916)
@@ -94,6 +94,6 @@
 
         // Iterate through all players possessing this Quest.
-        for(const auto & elem : players_)
-            QuestEffect::invokeEffects(elem, this->getFailEffectList());
+        for(PlayerInfo* questPlayer : players_)
+            QuestEffect::invokeEffects(questPlayer, this->getFailEffectList());
 
         return true;
@@ -119,6 +119,6 @@
 
         // Iterate through all players possessing the Quest.
-        for(const auto & elem : players_)
-            QuestEffect::invokeEffects(elem, this->getCompleteEffectList());
+        for(PlayerInfo* questPlayer : players_)
+            QuestEffect::invokeEffects(questPlayer, this->getCompleteEffectList());
 
         Quest::complete(player);
@@ -242,8 +242,8 @@
     {
         int i = index;
-        for (const auto & elem : this->rewards_)
+        for (QuestEffect* reward : this->rewards_)
         {
             if(i == 0)
-               return elem;
+               return reward;
 
             i--;
Index: /code/branches/cpp11_v2/src/modules/questsystem/Quest.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/questsystem/Quest.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/questsystem/Quest.cc	(revision 10916)
@@ -190,8 +190,8 @@
 
         // Iterate through all subquests.
-        for (const auto & elem : this->subQuests_)
+        for (Quest* quest : this->subQuests_)
         {
             if(i == 0) // We're counting down...
-               return elem;
+               return quest;
 
             i--;
@@ -214,8 +214,8 @@
 
         // Iterate through all QuestHints.
-        for (const auto & elem : this->hints_)
+        for (QuestHint* hint : this->hints_)
         {
             if(i == 0) // We're counting down...
-               return elem;
+               return hint;
 
             i--;
@@ -237,8 +237,8 @@
 
         // Iterate through all fail QuestEffects.
-        for (const auto & elem : this->failEffects_)
+        for (QuestEffect* effect : this->failEffects_)
         {
             if(i == 0) // We're counting down...
-               return elem;
+               return effect;
 
             i--;
@@ -260,8 +260,8 @@
 
         // Iterate through all complete QuestEffects.
-        for (const auto & elem : this->completeEffects_)
+        for (QuestEffect* effect : this->completeEffects_)
         {
             if(i == 0) // We're counting down...
-               return elem;
+               return effect;
 
             i--;
Index: /code/branches/cpp11_v2/src/modules/questsystem/QuestEffect.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/questsystem/QuestEffect.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/questsystem/QuestEffect.cc	(revision 10916)
@@ -74,6 +74,6 @@
         orxout(verbose, context::quests) << "Invoking QuestEffects on player: " << player << " ."  << endl;
 
-        for (auto & effects_effect : effects)
-            temp = temp && (effects_effect)->invoke(player);
+        for (QuestEffect* effect : effects)
+            temp = temp && effect->invoke(player);
 
         return temp;
Index: /code/branches/cpp11_v2/src/modules/questsystem/QuestEffectBeacon.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/questsystem/QuestEffectBeacon.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/questsystem/QuestEffectBeacon.cc	(revision 10916)
@@ -236,8 +236,8 @@
     {
         int i = index;
-        for (const auto & elem : this->effects_)
+        for (QuestEffect* effect : this->effects_)
         {
             if(i == 0)
-               return elem;
+               return effect;
 
             i--;
Index: /code/branches/cpp11_v2/src/modules/questsystem/QuestListener.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/questsystem/QuestListener.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/questsystem/QuestListener.cc	(revision 10916)
@@ -97,7 +97,6 @@
     /* static */ void QuestListener::advertiseStatusChange(std::list<QuestListener*> & listeners, const std::string & status)
     {
-        for (auto listener : listeners) // Iterate through all QuestListeners
-        {
-            
+        for (QuestListener* listener : listeners) // Iterate through all QuestListeners
+        {
             if(listener->getMode() == status || listener->getMode() == QuestListener::ALL) // Check whether the status change affects the give QuestListener.
                 listener->execute();
Index: /code/branches/cpp11_v2/src/modules/questsystem/QuestManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/questsystem/QuestManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/questsystem/QuestManager.cc	(revision 10916)
@@ -235,7 +235,7 @@
     {
         int numQuests = 0;
-        for(auto & elem : this->questMap_)
-        {
-            if(elem.second->getParentQuest() == nullptr && !elem.second->isInactive(player))
+        for(auto& mapEntry : this->questMap_)
+        {
+            if(mapEntry.second->getParentQuest() == nullptr && !mapEntry.second->isInactive(player))
                 numQuests++;
         }
@@ -255,8 +255,8 @@
     Quest* QuestManager::getRootQuest(PlayerInfo* player, int index)
     {
-        for(auto & elem : this->questMap_)
-        {
-            if(elem.second->getParentQuest() == nullptr && !elem.second->isInactive(player) && index-- == 0)
-                return elem.second;
+        for(auto& mapEntry : this->questMap_)
+        {
+            if(mapEntry.second->getParentQuest() == nullptr && !mapEntry.second->isInactive(player) && index-- == 0)
+                return mapEntry.second;
         }
         return nullptr;
@@ -280,7 +280,7 @@
         std::list<Quest*> quests = quest->getSubQuestList();
         int numQuests = 0;
-        for(auto & quest : quests)
-        {
-            if(!(quest)->isInactive(player))
+        for(Quest* subquest : quests)
+        {
+            if(!subquest->isInactive(player))
                 numQuests++;
         }
@@ -304,7 +304,7 @@
 
         std::list<Quest*> quests = quest->getSubQuestList();
-        for(auto & quest : quests)
-        {
-            if(!(quest)->isInactive(player) && index-- == 0)
+        for(Quest* subquest : quests)
+        {
+            if(!subquest->isInactive(player) && index-- == 0)
                 return quest;
         }
@@ -326,7 +326,7 @@
         std::list<QuestHint*> hints = quest->getHintsList();
         int numHints = 0;
-        for(auto & hint : hints)
-        {
-            if((hint)->isActive(player))
+        for(QuestHint* hint : hints)
+        {
+            if(hint->isActive(player))
                 numHints++;
         }
@@ -349,7 +349,7 @@
     {
         std::list<QuestHint*> hints = quest->getHintsList();
-        for(auto & hint : hints)
-        {
-            if((hint)->isActive(player) && index-- == 0)
+        for(QuestHint* hint : hints)
+        {
+            if(hint->isActive(player) && index-- == 0)
                 return hint;
         }
Index: /code/branches/cpp11_v2/src/modules/questsystem/effects/AddReward.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/questsystem/effects/AddReward.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/questsystem/effects/AddReward.cc	(revision 10916)
@@ -84,8 +84,8 @@
     {
         int i = index;
-        for (const auto & elem : this->rewards_)
+        for (Rewardable* reward : this->rewards_)
         {
             if(i == 0)
-               return elem;
+               return reward;
             i--;
         }
@@ -106,6 +106,6 @@
 
         bool temp = true;
-        for (auto & elem : this->rewards_)
-            temp = temp && (elem)->reward(player);
+        for (Rewardable* reward : this->rewards_)
+            temp = temp && reward->reward(player);
 
         orxout(verbose, context::quests) << "Rewardable successfully added to player." << player << " ." << endl;
Index: /code/branches/cpp11_v2/src/modules/tetris/Tetris.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/tetris/Tetris.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/tetris/Tetris.cc	(revision 10916)
@@ -104,6 +104,6 @@
         }
 
-        for (auto & elem : this->stones_)
-            (elem)->destroy();
+        for (TetrisStone* stone : this->stones_)
+            stone->destroy();
         this->stones_.clear();
     }
@@ -341,7 +341,7 @@
     {
         // Spawn a human player.
-        for (auto & elem : this->players_)
-            if (elem.first->isHumanPlayer() && (elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (mapEntry.first->isHumanPlayer() && (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(mapEntry.first);
     }
     
@@ -502,8 +502,8 @@
         }
       // adjust height of stones above the deleted row //TODO: check if this could be a source of a bug.
-        for(auto & elem : this->stones_)
-        {
-            if(static_cast<unsigned int>(((elem)->getPosition().y - 5)/this->center_->getStoneSize()) > row)
-                (elem)->setPosition((elem)->getPosition()-Vector3(0,10,0));
+        for(TetrisStone* stone : this->stones_)
+        {
+            if(static_cast<unsigned int>((stone->getPosition().y - 5)/this->center_->getStoneSize()) > row)
+                stone->setPosition(stone->getPosition()-Vector3(0,10,0));
         }
 
Index: /code/branches/cpp11_v2/src/modules/tetris/TetrisBrick.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/tetris/TetrisBrick.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/tetris/TetrisBrick.cc	(revision 10916)
@@ -239,9 +239,9 @@
     {
         assert(this->tetris_);
-        for(auto & elem : this->brickStones_)
-        {
-            elem->detachFromParent();
-            elem->attachToParent(center);
-            elem->setPosition(this->getPosition()+this->tetris_->rotateVector(elem->getPosition(),this->rotationCount_ ));
+        for(TetrisStone* stone : this->brickStones_)
+        {
+            stone->detachFromParent();
+            stone->attachToParent(center);
+            stone->setPosition(this->getPosition()+this->tetris_->rotateVector(stone->getPosition(),this->rotationCount_ ));
         }
         this->brickStones_.clear();
Index: /code/branches/cpp11_v2/src/modules/towerdefense/TowerDefense.cc
===================================================================
--- /code/branches/cpp11_v2/src/modules/towerdefense/TowerDefense.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/modules/towerdefense/TowerDefense.cc	(revision 10916)
@@ -183,8 +183,8 @@
             en1->lookAt(waypoints_.at(1)->getPosition() + offset_);
 
-            for (auto & elem : waypoints_)
+            for (TowerDefenseField* field : waypoints_)
             {
                 orxonox::WeakPtr<MovableEntity> waypoint = new MovableEntity(this->center_->getContext());
-                waypoint->setPosition(elem->getPosition() + offset_);
+                waypoint->setPosition(field->getPosition() + offset_);
                 controller->addWaypoint(waypoint);
             }
Index: /code/branches/cpp11_v2/src/orxonox/Level.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/Level.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/Level.cc	(revision 10916)
@@ -106,8 +106,8 @@
     void Level::networkCallbackTemplatesChanged()
     {
-        for(const auto & elem : this->networkTemplateNames_)
-        {
-            assert(Template::getTemplate(elem));
-            Template::getTemplate(elem)->applyOn(this);
+        for(const std::string& name : this->networkTemplateNames_)
+        {
+            assert(Template::getTemplate(name));
+            Template::getTemplate(name)->applyOn(this);
         }
     }
@@ -135,6 +135,6 @@
         //       objects alive when ~Level is called. This is the reason why we cannot directly destroy() the Plugins - instead we need
         //       to call destroyLater() to ensure that no instances from this plugin exist anymore.
-        for (auto & elem : this->plugins_)
-            (elem)->destroyLater();
+        for (PluginReference* plugin : this->plugins_)
+            plugin->destroyLater();
         this->plugins_.clear();
     }
@@ -173,8 +173,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->objects_)
+        for (BaseObject* object : this->objects_)
         {
             if (i == index)
-                return (elem);
+                return object;
             ++i;
         }
Index: /code/branches/cpp11_v2/src/orxonox/LevelInfo.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/LevelInfo.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/LevelInfo.cc	(revision 10916)
@@ -106,7 +106,7 @@
     {
         SubString substr = SubString(tags, ",", " "); // Split the string into tags.
-        const std::vector<std::string>& strings = substr.getAllStrings();
-        for (const auto & strings_it : strings)
-            this->addTag(strings_it, false);
+        const std::vector<std::string>& tokens = substr.getAllStrings();
+        for (const std::string& token : tokens)
+            this->addTag(token, false);
 
         this->tagsUpdated();
@@ -121,7 +121,7 @@
     {
         SubString substr = SubString(ships, ",", " "); // Split the string into tags.
-        const std::vector<std::string>& strings = substr.getAllStrings();
-        for(const auto & strings_it : strings)
-            this->addStartingShip(strings_it, false);
+        const std::vector<std::string>& tokens = substr.getAllStrings();
+        for(const std::string& token : tokens)
+            this->addStartingShip(token, false);
 
         this->startingshipsUpdated();
Index: /code/branches/cpp11_v2/src/orxonox/LevelManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/LevelManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/LevelManager.cc	(revision 10916)
@@ -175,6 +175,6 @@
             this->levels_.front()->setActive(true);
             // Make every player enter the newly activated level.
-            for (const auto & elem : PlayerManager::getInstance().getClients())
-                this->levels_.front()->playerEntered(elem.second);
+            for (const auto& mapEntry : PlayerManager::getInstance().getClients())
+                this->levels_.front()->playerEntered(mapEntry.second);
         }
     }
Index: /code/branches/cpp11_v2/src/orxonox/Scene.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/Scene.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/Scene.cc	(revision 10916)
@@ -220,8 +220,8 @@
         {
             // Remove all WorldEntities and shove them to the queue since they would still like to be in a physical world.
-            for (const auto & elem : this->physicalObjects_)
+            for (WorldEntity* object : this->physicalObjects_)
             {
-                this->physicalWorld_->removeRigidBody((elem)->physicalBody_);
-                this->physicalObjectQueue_.insert(elem);
+                this->physicalWorld_->removeRigidBody(object->physicalBody_);
+                this->physicalObjectQueue_.insert(object);
             }
             this->physicalObjects_.clear();
@@ -255,8 +255,8 @@
             {
                 // Add all scheduled WorldEntities
-                for (const auto & elem : this->physicalObjectQueue_)
+                for (WorldEntity* object : this->physicalObjectQueue_)
                 {
-                    this->physicalWorld_->addRigidBody((elem)->physicalBody_);
-                    this->physicalObjects_.insert(elem);
+                    this->physicalWorld_->addRigidBody(object->physicalBody_);
+                    this->physicalObjects_.insert(object);
                 }
                 this->physicalObjectQueue_.clear();
@@ -319,8 +319,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->objects_)
+        for (BaseObject* object : this->objects_)
         {
             if (i == index)
-                return (elem);
+                return object;
             ++i;
         }
Index: /code/branches/cpp11_v2/src/orxonox/collisionshapes/CompoundCollisionShape.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/collisionshapes/CompoundCollisionShape.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/collisionshapes/CompoundCollisionShape.cc	(revision 10916)
@@ -65,10 +65,10 @@
         {
             // Delete all children
-            for (auto & elem : this->attachedShapes_)
+            for (auto& mapEntry : this->attachedShapes_)
             {
                 // make sure that the child doesn't want to detach itself --> speedup because of the missing update
-                elem.first->notifyDetached();
-                elem.first->destroy();
-                if (this->collisionShape_ == elem.second)
+                mapEntry.first->notifyDetached();
+                mapEntry.first->destroy();
+                if (this->collisionShape_ == mapEntry.second)
                     this->collisionShape_ = nullptr; // don't destroy it twice
             }
@@ -246,8 +246,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->attachedShapes_)
+        for (const auto& mapEntry : this->attachedShapes_)
         {
             if (i == index)
-                return elem.first;
+                return mapEntry.first;
             ++i;
         }
@@ -266,6 +266,6 @@
         std::vector<CollisionShape*> shapes;
         // Iterate through all attached CollisionShapes and add them to the list of shapes.
-        for(auto & elem : this->attachedShapes_)
-            shapes.push_back(elem.first);
+        for(auto& mapEntry : this->attachedShapes_)
+            shapes.push_back(mapEntry.first);
 
         // Delete the compound shape and create a new one.
@@ -274,7 +274,6 @@
 
         // Re-attach all CollisionShapes.
-        for(auto shape : shapes)
-        {
-            
+        for(CollisionShape* shape : shapes)
+        {
             shape->setScale3D(this->getScale3D());
             // Only actually attach if we didn't pick a CompoundCollisionShape with no content.
Index: /code/branches/cpp11_v2/src/orxonox/controllers/ArtificialController.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/controllers/ArtificialController.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/controllers/ArtificialController.cc	(revision 10916)
@@ -231,8 +231,8 @@
     int ArtificialController::getFiremode(std::string name)
     {
-        for (auto firemode : this->weaponModes_)
-        {
-            if (firemode.first == name)
-                return firemode.second;
+        for (auto& mapEntry : this->weaponModes_)
+        {
+            if (mapEntry.first == name)
+                return mapEntry.second;
         }
         return -1;
Index: /code/branches/cpp11_v2/src/orxonox/controllers/FormationController.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/controllers/FormationController.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/controllers/FormationController.cc	(revision 10916)
@@ -440,8 +440,8 @@
                 if(newMaster->slaves_.size() > this->maxFormationSize_) continue;
 
-                for(auto & elem : this->slaves_)
+                for(FormationController* slave : this->slaves_)
                 {
-                    (elem)->myMaster_ = newMaster;
-                    newMaster->slaves_.push_back(elem);
+                    slave->myMaster_ = newMaster;
+                    newMaster->slaves_.push_back(slave);
                 }
                 this->slaves_.clear();
@@ -486,5 +486,5 @@
             int i = 1;
 
-            for(auto & elem : slaves_)
+            for(FormationController* slave : slaves_)
             {
                 pos = Vector3::ZERO;
@@ -497,6 +497,6 @@
                     dest+=FORMATION_LENGTH*(orient*WorldEntity::BACK);
                 }
-                (elem)->setTargetOrientation(orient);
-                (elem)->setTargetPosition(pos);
+                slave->setTargetOrientation(orient);
+                slave->setTargetPosition(pos);
                 left=!left;
             }
@@ -569,8 +569,8 @@
         if(this->state_ != MASTER) return;
 
-        for(auto & elem : slaves_)
-        {
-            (elem)->state_ = FREE;
-            (elem)->myMaster_ = nullptr;
+        for(FormationController* slave : slaves_)
+        {
+            slave->state_ = FREE;
+            slave->myMaster_ = nullptr;
         }
         this->slaves_.clear();
@@ -584,10 +584,10 @@
         if(this->state_ != MASTER) return;
 
-        for(auto & elem : slaves_)
-        {
-            (elem)->state_ = FREE;
-            (elem)->forceFreedom();
-            (elem)->targetPosition_ = this->targetPosition_;
-            (elem)->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
         }
@@ -650,7 +650,7 @@
             this->slaves_.push_back(this->myMaster_);
             //set this as new master
-            for(auto & elem : slaves_)
-            {
-                 (elem)->myMaster_=this;
+            for(FormationController* slave : slaves_)
+            {
+                 slave->myMaster_=this;
             }
             this->myMaster_=nullptr;
@@ -694,9 +694,9 @@
         if (this->state_ == MASTER)
         {
-            for(auto & elem : slaves_)
-            {
-                 (elem)->formationMode_ = val;
+            for(FormationController* slave : slaves_)
+            {
+                 slave->formationMode_ = val;
                  if (val == ATTACK)
-                     (elem)->forgetTarget();
+                     slave->forgetTarget();
             }
         }
Index: /code/branches/cpp11_v2/src/orxonox/controllers/WaypointController.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/controllers/WaypointController.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/controllers/WaypointController.cc	(revision 10916)
@@ -44,8 +44,8 @@
     WaypointController::~WaypointController()
     {
-        for (auto & elem : this->waypoints_)
+        for (WorldEntity* waypoint : this->waypoints_)
         {
-            if(elem)
-                elem->destroy();
+            if(waypoint)
+                waypoint->destroy();
         }
     }
Index: /code/branches/cpp11_v2/src/orxonox/gamestates/GSLevel.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/gamestates/GSLevel.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/gamestates/GSLevel.cc	(revision 10916)
@@ -251,5 +251,5 @@
 
         // delete states
-        for (auto & state : states)
+        for (GSLevelMementoState* state : states)
             delete state;
     }
Index: /code/branches/cpp11_v2/src/orxonox/gametypes/Dynamicmatch.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/gametypes/Dynamicmatch.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/gametypes/Dynamicmatch.cc	(revision 10916)
@@ -405,9 +405,9 @@
     void Dynamicmatch::rewardPig()
     {
-        for (auto & elem : this->playerParty_) //durch alle Spieler iterieren und alle piggys finden
-        {
-            if (elem.second==piggy)//Spieler mit der Pig-party frags++
-            {
-                 this->playerScored(elem.first);
+        for (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);
             }
         }
@@ -422,7 +422,7 @@
 
                 std::set<WorldEntity*> pawnAttachments = pawn->getAttachedObjects();
-                for (const auto & pawnAttachment : pawnAttachments)
-                {
-                    if ((pawnAttachment)->isA(Class(TeamColourable)))
+                for (WorldEntity* pawnAttachment : pawnAttachments)
+                {
+                    if (pawnAttachment->isA(Class(TeamColourable)))
                     {
                         TeamColourable* tc = orxonox_cast<TeamColourable*>(pawnAttachment);
@@ -441,11 +441,11 @@
             if (tutorial) // Announce selectionphase
             {
-             for (auto & elem : this->playerParty_)
-                {
-                    if (!elem.first)//in order to catch nullpointer
+             for (auto& mapEntry : this->playerParty_)
+                {
+                    if (!mapEntry.first)//in order to catch nullpointer
                         continue;
-                    if (elem.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.",elem.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));
                 }
             }
@@ -456,26 +456,26 @@
              if(tutorial&&(!notEnoughKillers)&&(!notEnoughChasers)) //Selection phase over
              {
-                  for (auto & elem : this->playerParty_)
+                  for (auto& mapEntry : this->playerParty_)
                   {
-                       if (!elem.first)//in order to catch nullpointer
+                       if (!mapEntry.first)//in order to catch nullpointer
                            continue;
-                       if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                       if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                            continue;
-                       else if (elem.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.",elem.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.",elem.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 (elem.second==piggy)
-                       {
-                           this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",elem.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 (elem.second==killer)
-                       {
-                           this->gtinfo_->sendStaticMessage("Take the chasers down.",elem.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());
                        }
@@ -490,11 +490,11 @@
             if (tutorial) // Announce selectionphase
             {
-             for (auto & elem : this->playerParty_)
-                {
-                    if (!elem.first)//in order to catch nullpointer
+             for (auto& mapEntry : this->playerParty_)
+                {
+                    if (!mapEntry.first)//in order to catch nullpointer
                         continue;
-                    if (elem.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.",elem.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));
                 }
             }
@@ -505,26 +505,26 @@
             if(tutorial&&(!notEnoughPigs)&&(!notEnoughChasers)) //Selection phase over
              {
-                  for (auto & elem : this->playerParty_)
+                  for (auto& mapEntry : this->playerParty_)
                   {
-                       if (!elem.first)
+                       if (!mapEntry.first)
                            continue;
-                       if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                       if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                            continue;
-                       else if (elem.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.",elem.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.",elem.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 (elem.second==piggy)
-                       {
-                           this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",elem.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 (elem.second==killer)
-                       {
-                           this->gtinfo_->sendStaticMessage("Take the chasers down.",elem.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());
                        }
@@ -540,11 +540,11 @@
             if (tutorial) // Announce selectionphase
             {
-             for (auto & elem : this->playerParty_)
-                {
-                    if (!elem.first)//in order to catch nullpointer
+             for (auto& mapEntry : this->playerParty_)
+                {
+                    if (!mapEntry.first)//in order to catch nullpointer
                         continue;
-                    if (elem.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.",elem.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));
                 }
             }
@@ -555,26 +555,26 @@
              if(tutorial&&(!notEnoughPigs)&&(!notEnoughKillers)) //Selection phase over
              {
-                  for (auto & elem : this->playerParty_)
+                  for (auto& mapEntry : this->playerParty_)
                   {
-                       if (!elem.first)
+                       if (!mapEntry.first)
                            continue;
-                       if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                       if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                            continue;
-                       else if (elem.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.",elem.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.",elem.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 (elem.second==piggy)
-                       {
-                           this->gtinfo_->sendStaticMessage("Either hide or shoot a chaser.",elem.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 (elem.second==killer)
-                       {
-                           this->gtinfo_->sendStaticMessage("Take the chasers down.",elem.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());
                        }
@@ -620,9 +620,9 @@
         else if(tutorial) // Announce selectionphase
         {
-            for (auto & elem : this->playerParty_)
-            {
-                if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+            for (auto& mapEntry : this->playerParty_)
+            {
+                if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                     continue;
-                this->gtinfo_->sendStaticMessage("Selection phase: Shoot at everything that moves.",elem.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));
             }
         }
@@ -676,8 +676,8 @@
             unsigned int randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
             unsigned int index = 0;
-            for (const auto & teamSpawnPoint : teamSpawnPoints)
+            for (SpawnPoint* teamSpawnPoint : teamSpawnPoints)
             {
                 if (index == randomspawn)
-                    return (teamSpawnPoint);
+                    return teamSpawnPoint;
 
                 ++index;
Index: /code/branches/cpp11_v2/src/orxonox/gametypes/Gametype.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/gametypes/Gametype.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/gametypes/Gametype.cc	(revision 10916)
@@ -139,9 +139,9 @@
         if (!this->gtinfo_->hasStarted())
         {
-            for (auto & elem : this->players_)
+            for (auto& mapEntry : this->players_)
             {
                 // Inform the GametypeInfo that the player is ready to spawn.
-                if(elem.first->isHumanPlayer() && elem.first->isReadyToSpawn())
-                    this->gtinfo_->playerReadyToSpawn(elem.first);
+                if(mapEntry.first->isHumanPlayer() && mapEntry.first->isReadyToSpawn())
+                    this->gtinfo_->playerReadyToSpawn(mapEntry.first);
             }
 
@@ -169,9 +169,9 @@
         }
 
-        for (auto & elem : this->players_)
-        {
-            if (elem.first->getControllableEntity())
-            {
-                ControllableEntity* oldentity = elem.first->getControllableEntity();
+        for (auto& mapEntry : this->players_)
+        {
+            if (mapEntry.first->getControllableEntity())
+            {
+                ControllableEntity* oldentity = mapEntry.first->getControllableEntity();
 
                 ControllableEntity* entity = this->defaultControllableEntity_.fabricate(oldentity->getContext());
@@ -186,8 +186,8 @@
                     entity->setOrientation(oldentity->getWorldOrientation());
                 }
-                elem.first->startControl(entity);
+                mapEntry.first->startControl(entity);
             }
             else
-                this->spawnPlayerAsDefaultPawn(elem.first);
+                this->spawnPlayerAsDefaultPawn(mapEntry.first);
         }
     }
@@ -341,11 +341,11 @@
             unsigned int index = 0;
             std::vector<SpawnPoint*> activeSpawnPoints;
-            for (const auto & elem : this->spawnpoints_)
+            for (SpawnPoint* spawnpoint : this->spawnpoints_)
             {
                 if (index == randomspawn)
-                    fallbackSpawnPoint = (elem);
-
-                if (elem != nullptr && (elem)->isActive())
-                    activeSpawnPoints.push_back(elem);
+                    fallbackSpawnPoint = spawnpoint;
+
+                if (spawnpoint != nullptr && spawnpoint->isActive())
+                    activeSpawnPoints.push_back(spawnpoint);
 
                 ++index;
@@ -366,14 +366,14 @@
     void Gametype::assignDefaultPawnsIfNeeded()
     {
-        for (auto & elem : this->players_)
-        {
-            if (!elem.first->getControllableEntity())
-            {
-                elem.second.state_ = PlayerState::Dead;
-
-                if (!elem.first->isReadyToSpawn() || !this->gtinfo_->hasStarted())
-                {
-                    this->spawnPlayerAsDefaultPawn(elem.first);
-                    elem.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;
                 }
             }
@@ -404,9 +404,9 @@
                     bool allplayersready = true;
                     bool hashumanplayers = false;
-                    for (auto & elem : this->players_)
+                    for (auto& mapEntry : this->players_)
                     {
-                        if (!elem.first->isReadyToSpawn())
+                        if (!mapEntry.first->isReadyToSpawn())
                             allplayersready = false;
-                        if (elem.first->isHumanPlayer())
+                        if (mapEntry.first->isHumanPlayer())
                             hashumanplayers = true;
                     }
@@ -430,8 +430,8 @@
     void Gametype::spawnPlayersIfRequested()
     {
-        for (auto & elem : this->players_)
-        {
-            if (elem.first->isReadyToSpawn() || this->bForceSpawn_)
-                this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+        {
+            if (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_)
+                this->spawnPlayer(mapEntry.first);
         }
     }
@@ -439,8 +439,8 @@
     void Gametype::spawnDeadPlayersIfRequested()
     {
-        for (auto & elem : this->players_)
-            if (elem.second.state_ == PlayerState::Dead)
-                if (elem.first->isReadyToSpawn() || this->bForceSpawn_)
-                    this->spawnPlayer(elem.first);
+        for (auto& mapEntry : this->players_)
+            if (mapEntry.second.state_ == PlayerState::Dead)
+                if (mapEntry.first->isReadyToSpawn() || this->bForceSpawn_)
+                    this->spawnPlayer(mapEntry.first);
     }
 
@@ -538,9 +538,9 @@
     GSLevelMementoState* Gametype::exportMementoState()
     {
-        for (auto & elem : this->players_)
-        {
-            if (elem.first->isHumanPlayer() && elem.first->getControllableEntity() && elem.first->getControllableEntity()->getCamera())
-            {
-                Camera* camera = elem.first->getControllableEntity()->getCamera();
+        for (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();
@@ -559,7 +559,7 @@
         // find correct memento state
         GametypeMementoState* state = nullptr;
-        for (auto & states_i : states)
-        {
-            state = dynamic_cast<GametypeMementoState*>(states_i);
+        for (GSLevelMementoState* temp : states)
+        {
+            state = dynamic_cast<GametypeMementoState*>(temp);
             if (state)
                 break;
@@ -587,12 +587,12 @@
 
         // find correct player and assign default entity with original position & orientation
-        for (auto & elem : this->players_)
-        {
-            if (elem.first->isHumanPlayer())
+        for (auto& mapEntry : this->players_)
+        {
+            if (mapEntry.first->isHumanPlayer())
             {
                 ControllableEntity* entity = this->defaultControllableEntity_.fabricate(scene->getContext());
                 entity->setPosition(state->cameraPosition_);
                 entity->setOrientation(state->cameraOrientation_);
-                elem.first->startControl(entity);
+                mapEntry.first->startControl(entity);
                 break;
             }
Index: /code/branches/cpp11_v2/src/orxonox/gametypes/LastManStanding.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/gametypes/LastManStanding.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/gametypes/LastManStanding.cc	(revision 10916)
@@ -56,11 +56,11 @@
     void LastManStanding::spawnDeadPlayersIfRequested()
     {
-        for (auto & elem : this->players_)
-            if (elem.second.state_ == PlayerState::Dead)
-            {
-                bool alive = (0<playerLives_[elem.first]&&(inGame_[elem.first]));
-                if (alive&&(elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                {
-                    this->spawnPlayer(elem.first);
+        for (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);
                 }
             }
@@ -114,10 +114,10 @@
     {
         int min=lives;
-        for (auto & elem : this->playerLives_)
-        {
-            if (elem.second<=0)
+        for (auto& mapEntry : this->playerLives_)
+        {
+            if (mapEntry.second<=0)
                 continue;
-            if (elem.second<lives)
-                min=elem.second;
+            if (mapEntry.second<lives)
+                min=mapEntry.second;
         }
         return min;
@@ -128,13 +128,13 @@
         Gametype::end();
 
-        for (auto & elem : this->playerLives_)
-        {
-            if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+        for (auto& mapEntry : this->playerLives_)
+        {
+            if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
 
-            if (elem.second > 0)
-                this->gtinfo_->sendAnnounceMessage("You have won the match!", elem.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!", elem.first->getClientID());
+                this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
         }
     }
@@ -237,39 +237,39 @@
                 this->end();
             }
-            for (auto & elem : this->timeToAct_)
-            {
-                if (playerGetLives(elem.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;
-                elem.second-=dt;//Decreases punishment time.
-                if (!inGame_[elem.first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
-                {
-                    playerDelayTime_[elem.first]-=dt;
-                    if (playerDelayTime_[elem.first]<=0)
-                    this->inGame_[elem.first]=true;
-
-                    if (elem.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_[elem.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,elem.first->getClientID());
-                }
-                else if (elem.second<0.0f)
-                {
-                    elem.second=timeRemaining+3.0f;//reset punishment-timer
-                    if (playerGetLives(elem.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(elem.first);
-                        if (elem.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,elem.first->getClientID());
+                        this->gtinfo_->sendFadingMessage(message,mapEntry.first->getClientID());
                     }
                 }
-                else if (elem.second<timeRemaining/5)//Warning message
-                {
-                    if (elem.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,elem.first->getClientID());
+                    this->gtinfo_->sendFadingMessage(message,mapEntry.first->getClientID());
                 }
             }
Index: /code/branches/cpp11_v2/src/orxonox/gametypes/LastTeamStanding.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/gametypes/LastTeamStanding.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/gametypes/LastTeamStanding.cc	(revision 10916)
@@ -145,11 +145,11 @@
     void LastTeamStanding::spawnDeadPlayersIfRequested()
     {
-        for (auto & elem : this->players_)
-            if (elem.second.state_ == PlayerState::Dead)
-            {
-                bool alive = (0 < playerLives_[elem.first]&&(inGame_[elem.first]));
-                if (alive&&(elem.first->isReadyToSpawn() || this->bForceSpawn_))
-                {
-                    this->spawnPlayer(elem.first);
+        for (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);
                 }
             }
@@ -184,39 +184,39 @@
                 this->end();
             }
-            for (auto & elem : this->timeToAct_)
-            {
-                if (playerGetLives(elem.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;
-                elem.second -= dt;//Decreases punishment time.
-                if (!inGame_[elem.first])//Manages respawn delay - player is forced to respawn after the delaytime is used up.
-                {
-                    playerDelayTime_[elem.first] -= dt;
-                    if (playerDelayTime_[elem.first] <= 0)
-                    this->inGame_[elem.first] = true;
-
-                    if (elem.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_[elem.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,elem.first->getClientID());
-                }
-                else if (elem.second < 0.0f)
-                {
-                    elem.second = timeRemaining + 3.0f;//reset punishment-timer
-                    if (playerGetLives(elem.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(elem.first);
-                        if (elem.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, elem.first->getClientID());
+                        this->gtinfo_->sendFadingMessage(message, mapEntry.first->getClientID());
                     }
                 }
-                else if (elem.second < timeRemaining/5)//Warning message
-                {
-                  if (elem.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, elem.first->getClientID());
+                    this->gtinfo_->sendFadingMessage(message, mapEntry.first->getClientID());
                 }
             }
@@ -229,13 +229,13 @@
         int party = -1;
         //find a player who survived
-        for (auto & elem : this->playerLives_)
-        {
-          if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+        for (auto& mapEntry : this->playerLives_)
+        {
+          if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
 
-            if (elem.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(elem.first);
+                std::map<PlayerInfo*, int>::iterator it2 = this->teamnumbers_.find(mapEntry.first);
                 if (it2 != this->teamnumbers_.end())
                 {
@@ -255,10 +255,10 @@
     {
         int min = lives;
-        for (auto & elem : this->playerLives_)
-        {
-            if (elem.second <= 0)
+        for (auto& mapEntry : this->playerLives_)
+        {
+            if (mapEntry.second <= 0)
                 continue;
-            if (elem.second < lives)
-                min = elem.second;
+            if (mapEntry.second < lives)
+                min = mapEntry.second;
         }
         return min;
Index: /code/branches/cpp11_v2/src/orxonox/gametypes/TeamBaseMatch.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/gametypes/TeamBaseMatch.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/gametypes/TeamBaseMatch.cc	(revision 10916)
@@ -152,11 +152,11 @@
         int amountControlled2 = 0;
 
-        for (const auto & elem : this->bases_)
-        {
-            if((elem)->getState() == BaseState::ControlTeam1)
+        for (TeamBaseMatchBase* base : this->bases_)
+        {
+            if(base->getState() == BaseState::ControlTeam1)
             {
                 amountControlled++;
             }
-            if((elem)->getState() == BaseState::ControlTeam2)
+            if(base->getState() == BaseState::ControlTeam2)
             {
                 amountControlled2++;
@@ -187,13 +187,13 @@
             }
 
-            for (auto & elem : this->teamnumbers_)
-            {
-                if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+            for (auto& mapEntry : this->teamnumbers_)
+            {
+                if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                     continue;
 
-                if (elem.second == winningteam)
-                    this->gtinfo_->sendAnnounceMessage("You have won the match!", elem.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!", elem.first->getClientID());
+                    this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
             }
 
@@ -238,9 +238,9 @@
         int count = 0;
 
-        for (const auto & elem : this->bases_)
-        {
-            if ((elem)->getState() == BaseState::ControlTeam1 && team == 0)
+        for (TeamBaseMatchBase* base : this->bases_)
+        {
+            if (base->getState() == BaseState::ControlTeam1 && team == 0)
                 count++;
-            if ((elem)->getState() == BaseState::ControlTeam2 && team == 1)
+            if (base->getState() == BaseState::ControlTeam2 && team == 1)
                 count++;
         }
@@ -258,9 +258,9 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->bases_)
+        for (TeamBaseMatchBase* base : this->bases_)
         {
             i++;
             if (i > index)
-                return (elem);
+                return base;
         }
         return nullptr;
Index: /code/branches/cpp11_v2/src/orxonox/gametypes/TeamDeathmatch.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/gametypes/TeamDeathmatch.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/gametypes/TeamDeathmatch.cc	(revision 10916)
@@ -69,10 +69,10 @@
         int winnerTeam = 0;
         int highestScore = 0;
-        for (auto & elem : this->players_)
+        for (auto& mapEntry : this->players_)
         {
-            if ( this->getTeamScore(elem.first) > highestScore )
+            if ( this->getTeamScore(mapEntry.first) > highestScore )
             {
-                winnerTeam = this->getTeam(elem.first);
-                highestScore = this->getTeamScore(elem.first);
+                winnerTeam = this->getTeam(mapEntry.first);
+                highestScore = this->getTeamScore(mapEntry.first);
             }
         }
Index: /code/branches/cpp11_v2/src/orxonox/gametypes/TeamGametype.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/gametypes/TeamGametype.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/gametypes/TeamGametype.cc	(revision 10916)
@@ -99,7 +99,7 @@
         std::vector<unsigned int> playersperteam(this->teams_, 0);
 
-        for (auto & elem : this->teamnumbers_)
-            if (elem.second < static_cast<int>(this->teams_) && elem.second >= 0)
-                playersperteam[elem.second]++;
+        for (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);
@@ -123,8 +123,8 @@
         if( (this->players_.size() >= maxPlayers_) && (allowedInGame_[player] == true) ) // if there's a "waiting list"
         {
-            for (auto & elem : this->allowedInGame_)
-            {
-                 if(elem.second == false) // waiting player found
-                 {elem.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
             }
         }
@@ -141,15 +141,15 @@
     void TeamGametype::spawnDeadPlayersIfRequested()
     {
-        for (auto & elem : this->players_)\
-        {
-            if(allowedInGame_[elem.first] == false)//check if dead player is allowed to enter
+        for (auto& mapEntry : this->players_)\
+        {
+            if(allowedInGame_[mapEntry.first] == false)//check if dead player is allowed to enter
             {
                 continue;
             }
-            if (elem.second.state_ == PlayerState::Dead)
-            {
-                if ((elem.first->isReadyToSpawn() || this->bForceSpawn_))
+            if (mapEntry.second.state_ == PlayerState::Dead)
+            {
+                if ((mapEntry.first->isReadyToSpawn() || this->bForceSpawn_))
                 {
-                   this->spawnPlayer(elem.first);
+                   this->spawnPlayer(mapEntry.first);
                 }
             }
@@ -178,9 +178,9 @@
         if(!player || this->getTeam(player) == -1)
             return 0;
-        for (auto & elem : this->players_)
-        {
-            if ( this->getTeam(elem.first) ==  this->getTeam(player) )
-            {
-                teamscore += elem.second.frags_;
+        for (auto& mapEntry : this->players_)
+        {
+            if ( this->getTeam(mapEntry.first) ==  this->getTeam(player) )
+            {
+                teamscore += mapEntry.second.frags_;
             }
         }
@@ -191,7 +191,7 @@
     {
         int teamSize = 0;
-        for (auto & elem : this->teamnumbers_)
-        {
-            if (elem.second == team)
+        for (auto& mapEntry : this->teamnumbers_)
+        {
+            if (mapEntry.second == team)
                 teamSize++;
         }
@@ -202,7 +202,7 @@
     {
         int teamSize = 0;
-        for (auto & elem : this->teamnumbers_)
-        {
-            if (elem.second == team  && elem.first->isHumanPlayer())
+        for (auto& mapEntry : this->teamnumbers_)
+        {
+            if (mapEntry.second == team  && mapEntry.first->isHumanPlayer())
                 teamSize++;
         }
@@ -241,9 +241,9 @@
             unsigned int index = 0;
             // Get random fallback spawnpoint in case there is no active SpawnPoint.
-            for (const auto & teamSpawnPoint : teamSpawnPoints)
+            for (SpawnPoint* teamSpawnPoint : teamSpawnPoints)
             {
                 if (index == randomspawn)
                 {
-                    fallbackSpawnPoint = (teamSpawnPoint);
+                    fallbackSpawnPoint = teamSpawnPoint;
                     break;
                 }
@@ -266,8 +266,8 @@
             randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
             index = 0;
-            for (const auto & teamSpawnPoint : teamSpawnPoints)
+            for (SpawnPoint* teamSpawnPoint : teamSpawnPoints)
             {
                 if (index == randomspawn)
-                    return (teamSpawnPoint);
+                    return teamSpawnPoint;
 
                 ++index;
@@ -364,7 +364,7 @@
 
         std::set<WorldEntity*> pawnAttachments = pawn->getAttachedObjects();
-        for (const auto & pawnAttachment : pawnAttachments)
-        {
-            if ((pawnAttachment)->isA(Class(TeamColourable)))
+        for (WorldEntity* pawnAttachment : pawnAttachments)
+        {
+            if (pawnAttachment->isA(Class(TeamColourable)))
             {
                 TeamColourable* tc = orxonox_cast<TeamColourable*>(pawnAttachment);
@@ -376,15 +376,15 @@
     void TeamGametype::announceTeamWin(int winnerTeam)
     {
-        for (auto & elem : this->teamnumbers_)
-        {
-            if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+        for (auto& mapEntry : this->teamnumbers_)
+        {
+            if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
-            if (elem.second == winnerTeam)
-            {
-                this->gtinfo_->sendAnnounceMessage("Your team has won the match!", elem.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!", elem.first->getClientID());
+                this->gtinfo_->sendAnnounceMessage("Your team has lost the match!", mapEntry.first->getClientID());
             }
         }   
Index: /code/branches/cpp11_v2/src/orxonox/gametypes/UnderAttack.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/gametypes/UnderAttack.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/gametypes/UnderAttack.cc	(revision 10916)
@@ -74,13 +74,13 @@
         this->gameEnded_ = true;
 
-        for (auto & elem : this->teamnumbers_)
-        {
-            if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+        for (auto& mapEntry : this->teamnumbers_)
+        {
+            if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                 continue;
 
-            if (elem.second == attacker_)
-                this->gtinfo_->sendAnnounceMessage("You have won the match!", elem.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!", elem.first->getClientID());
+                this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
         }
     }
@@ -155,13 +155,13 @@
                 ChatManager::message(message);
 
-                for (auto & elem : this->teamnumbers_)
-                {
-                    if (elem.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
+                for (auto& mapEntry : this->teamnumbers_)
+                {
+                    if (mapEntry.first->getClientID() == NETWORK_PEER_ID_UNKNOWN)
                         continue;
 
-                    if (elem.second == 1)
-                        this->gtinfo_->sendAnnounceMessage("You have won the match!", elem.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!", elem.first->getClientID());
+                        this->gtinfo_->sendAnnounceMessage("You have lost the match!", mapEntry.first->getClientID());
                 }
             }
Index: /code/branches/cpp11_v2/src/orxonox/interfaces/PickupCarrier.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/interfaces/PickupCarrier.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/interfaces/PickupCarrier.cc	(revision 10916)
@@ -135,9 +135,9 @@
         // Go recursively through all children to check whether they are the target.
         std::vector<PickupCarrier*>* children = this->getCarrierChildren();
-        for(auto & elem : *children)
+        for(PickupCarrier* child : *children)
         {
-            if(pickup->isTarget(elem))
+            if(pickup->isTarget(child))
             {
-                target = elem;
+                target = child;
                 break;
             }
Index: /code/branches/cpp11_v2/src/orxonox/interfaces/Pickupable.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/interfaces/Pickupable.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/interfaces/Pickupable.cc	(revision 10916)
@@ -160,7 +160,7 @@
     {
         // Iterate through all targets of this Pickupable.
-        for(const auto & elem : this->targets_)
+        for(Identifier* target : this->targets_)
         {
-            if(identifier->isA(elem))
+            if(identifier->isA(target))
                 return true;
         }
Index: /code/branches/cpp11_v2/src/orxonox/items/MultiStateEngine.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/items/MultiStateEngine.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/items/MultiStateEngine.cc	(revision 10916)
@@ -219,8 +219,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->effectContainers_)
+        for (EffectContainer* effectContainer : this->effectContainers_)
         {
             if (i == index)
-                return (elem);
+                return effectContainer;
             i++;
         }
Index: /code/branches/cpp11_v2/src/orxonox/items/ShipPart.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/items/ShipPart.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/items/ShipPart.cc	(revision 10916)
@@ -143,12 +143,12 @@
     @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(auto & elem : this->entityList_)
-        {
-            if(elem == entity)
+    bool ShipPart::hasEntity(StaticEntity* search) const
+    {
+        for(StaticEntity* entity : this->entityList_)
+        {
+            if(entity == search)
                 return true;
         }
Index: /code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/overlays/OverlayGroup.cc	(revision 10916)
@@ -62,6 +62,6 @@
     OverlayGroup::~OverlayGroup()
     {
-        for (const auto & elem : hudElements_)
-            (elem)->destroy();
+        for (OrxonoxOverlay* hudElement : hudElements_)
+            hudElement->destroy();
         this->hudElements_.clear();
     }
@@ -86,6 +86,6 @@
     void OverlayGroup::setScale(const Vector2& scale)
     {
-        for (const auto & elem : hudElements_)
-            (elem)->scale(scale / this->scale_);
+        for (OrxonoxOverlay* hudElement : hudElements_)
+            hudElement->scale(scale / this->scale_);
         this->scale_ = scale;
     }
@@ -94,6 +94,6 @@
     void OverlayGroup::setScroll(const Vector2& scroll)
     {
-        for (const auto & elem : hudElements_)
-            (elem)->scroll(scroll - this->scroll_);
+        for (OrxonoxOverlay* hudElement : hudElements_)
+            hudElement->scroll(scroll - this->scroll_);
         this->scroll_ = scroll;
     }
@@ -147,6 +147,6 @@
         SUPER( OverlayGroup, changedVisibility );
 
-        for (const auto & elem : hudElements_)
-            (elem)->changedVisibility(); //inform all Child Overlays that our visibility has changed
+        for (OrxonoxOverlay* hudElement : hudElements_)
+            hudElement->changedVisibility(); //inform all Child Overlays that our visibility has changed
     }
 
@@ -155,6 +155,6 @@
         this->owner_ = owner;
 
-        for (const auto & elem : hudElements_)
-            (elem)->setOwner(owner);
+        for (OrxonoxOverlay* hudElement : hudElements_)
+            hudElement->setOwner(owner);
     }
 
Index: /code/branches/cpp11_v2/src/orxonox/sound/SoundManager.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/sound/SoundManager.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/sound/SoundManager.cc	(revision 10916)
@@ -407,10 +407,10 @@
         if (ambient != nullptr)
         {
-            for (auto & elem : this->ambientSounds_)
-            {
-                if (elem.first == ambient)
+            for (std::pair<AmbientSound*, bool>& pair : this->ambientSounds_)
+            {
+                if (pair.first == ambient)
                 {
-                    elem.second = true;
-                    this->fadeOut(elem.first);
+                    pair.second = true;
+                    this->fadeOut(pair.first);
                     return;
                 }
Index: /code/branches/cpp11_v2/src/orxonox/sound/SoundStreamer.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/sound/SoundStreamer.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/sound/SoundStreamer.cc	(revision 10916)
@@ -68,5 +68,5 @@
         int current_section;
 
-        for(auto & initbuffer : initbuffers)
+        for(ALuint& initbuffer : initbuffers)
         {
             long ret = ov_read(&vf, inbuffer, sizeof(inbuffer), 0, 2, 1, &current_section);
Index: /code/branches/cpp11_v2/src/orxonox/weaponsystem/Munition.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/weaponsystem/Munition.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/weaponsystem/Munition.cc	(revision 10916)
@@ -55,6 +55,6 @@
     Munition::~Munition()
     {
-        for (auto & elem : this->currentMagazines_)
-            delete elem.second;
+        for (auto& mapEntry : this->currentMagazines_)
+            delete mapEntry.second;
     }
 
@@ -268,6 +268,6 @@
         {
             // Return true if any of the current magazines is not full (loading counts as full although it returns 0 munition)
-            for (const auto & elem : this->currentMagazines_)
-                if (elem.second->munition_ < this->maxMunitionPerMagazine_ && elem.second->bLoaded_)
+            for (const auto& mapEntry : this->currentMagazines_)
+                if (mapEntry.second->munition_ < this->maxMunitionPerMagazine_ && mapEntry.second->bLoaded_)
                     return true;
         }
@@ -316,10 +316,10 @@
             {
                 bool change = false;
-                for (auto & elem : this->currentMagazines_)
+                for (auto& mapEntry : this->currentMagazines_)
                 {
                     // Add munition if the magazine isn't full (but only to loaded magazines)
-                    if (amount > 0 && elem.second->munition_ < this->maxMunitionPerMagazine_ && elem.second->bLoaded_)
+                    if (amount > 0 && mapEntry.second->munition_ < this->maxMunitionPerMagazine_ && mapEntry.second->bLoaded_)
                     {
-                        elem.second->munition_++;
+                        mapEntry.second->munition_++;
                         amount--;
                         change = true;
Index: /code/branches/cpp11_v2/src/orxonox/weaponsystem/Weapon.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/weaponsystem/Weapon.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/weaponsystem/Weapon.cc	(revision 10916)
@@ -61,6 +61,6 @@
                 this->weaponPack_->removeWeapon(this);
 
-            for (auto & elem : this->weaponmodes_)
-                elem.second->destroy();
+            for (auto& mapEntry : this->weaponmodes_)
+                mapEntry.second->destroy();
         }
     }
@@ -85,8 +85,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->weaponmodes_)
+        for (const auto& mapEntry : this->weaponmodes_)
         {
             if (i == index)
-                return elem.second;
+                return mapEntry.second;
 
             ++i;
@@ -136,6 +136,6 @@
     void Weapon::reload()
     {
-        for (auto & elem : this->weaponmodes_)
-            elem.second->reload();
+        for (auto& mapEntry : this->weaponmodes_)
+            mapEntry.second->reload();
     }
 
@@ -148,6 +148,6 @@
     void Weapon::notifyWeaponModes()
     {
-        for (auto & elem : this->weaponmodes_)
-            elem.second->setWeapon(this);
+        for (auto& mapEntry : this->weaponmodes_)
+            mapEntry.second->setWeapon(this);
     }
 }
Index: /code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponPack.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponPack.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponPack.cc	(revision 10916)
@@ -76,6 +76,6 @@
     void WeaponPack::fire(unsigned int weaponmode)
     {
-        for (auto & elem : this->weapons_)
-            (elem)->fire(weaponmode);
+        for (Weapon* weapon : this->weapons_)
+            weapon->fire(weaponmode);
     }
 
@@ -86,6 +86,6 @@
     void WeaponPack::reload()
     {
-        for (auto & elem : this->weapons_)
-            (elem)->reload();
+        for (Weapon* weapon : this->weapons_)
+            weapon->reload();
     }
 
@@ -114,8 +114,8 @@
         unsigned int i = 0;
 
-        for (const auto & elem : this->weapons_)
+        for (Weapon* weapon : this->weapons_)
         {
             if (i == index)
-                return (elem);
+                return weapon;
             ++i;
         }
@@ -132,8 +132,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->links_)
+        for (DefaultWeaponmodeLink* link : this->links_)
         {
             if (i == index)
-                return (elem);
+                return link;
 
             ++i;
@@ -144,7 +144,7 @@
     unsigned int WeaponPack::getDesiredWeaponmode(unsigned int firemode) const
     {
-        for (const auto & elem : this->links_)
-            if ((elem)->getFiremode() == firemode)
-                return (elem)->getWeaponmode();
+        for (DefaultWeaponmodeLink* link : this->links_)
+            if (link->getFiremode() == firemode)
+                return link->getWeaponmode();
 
         return WeaponSystem::WEAPON_MODE_UNASSIGNED;
Index: /code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSet.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSet.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSet.cc	(revision 10916)
@@ -63,7 +63,7 @@
     {
         // Fire all WeaponPacks with their defined weaponmode
-        for (auto & elem : this->weaponpacks_)
-            if (elem.second != WeaponSystem::WEAPON_MODE_UNASSIGNED)
-                elem.first->fire(elem.second);
+        for (auto& mapEntry : this->weaponpacks_)
+            if (mapEntry.second != WeaponSystem::WEAPON_MODE_UNASSIGNED)
+                mapEntry.first->fire(mapEntry.second);
     }
 
@@ -71,6 +71,6 @@
     {
         // Reload all WeaponPacks with their defined weaponmode
-        for (auto & elem : this->weaponpacks_)
-            elem.first->reload();
+        for (auto& mapEntry : this->weaponpacks_)
+            mapEntry.first->reload();
     }
 
Index: /code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSystem.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSystem.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/weaponsystem/WeaponSystem.cc	(revision 10916)
@@ -106,9 +106,9 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->weaponSlots_)
+        for (WeaponSlot* weaponSlot : this->weaponSlots_)
         {
             ++i;
             if (i > index)
-                return (elem);
+                return weaponSlot;
         }
         return nullptr;
@@ -153,9 +153,9 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->weaponSets_)
+        for (const auto& mapEntry : this->weaponSets_)
         {
             ++i;
             if (i > index)
-                return elem.second;
+                return mapEntry.second;
         }
         return nullptr;
@@ -168,7 +168,7 @@
 
         unsigned int freeSlots = 0;
-        for (auto & elem : this->weaponSlots_)
-        {
-            if (!(elem)->isOccupied())
+        for (WeaponSlot* weaponSlot : this->weaponSlots_)
+        {
+            if (!weaponSlot->isOccupied())
                 ++freeSlots;
         }
@@ -184,10 +184,10 @@
         // Attach all weapons to the first free slots (and to the Pawn)
         unsigned int i = 0;
-        for (auto & elem : this->weaponSlots_)
-        {
-            if (!(elem)->isOccupied() && i < wPack->getNumWeapons())
+        for (WeaponSlot* weaponSlot : this->weaponSlots_)
+        {
+            if (!weaponSlot->isOccupied() && i < wPack->getNumWeapons())
             {
                 Weapon* weapon = wPack->getWeapon(i);
-                (elem)->attachWeapon(weapon);
+                weaponSlot->attachWeapon(weapon);
                 this->getPawn()->attach(weapon);
                 ++i;
@@ -196,9 +196,9 @@
 
         // Assign the desired weaponmode to the firemodes
-        for (auto & elem : this->weaponSets_)
-        {
-            unsigned int weaponmode = wPack->getDesiredWeaponmode(elem.first);
+        for (auto& mapEntry : this->weaponSets_)
+        {
+            unsigned int weaponmode = wPack->getDesiredWeaponmode(mapEntry.first);
             if (weaponmode != WeaponSystem::WEAPON_MODE_UNASSIGNED)
-                elem.second->setWeaponmodeLink(wPack, weaponmode);
+                mapEntry.second->setWeaponmodeLink(wPack, weaponmode);
         }
 
@@ -219,6 +219,6 @@
 
         // Remove all added links from the WeaponSets
-        for (auto & elem : this->weaponSets_)
-            elem.second->removeWeaponmodeLink(wPack);
+        for (auto& mapEntry : this->weaponSets_)
+            mapEntry.second->removeWeaponmodeLink(wPack);
 
         // Remove the WeaponPack from the WeaponSystem
@@ -231,9 +231,9 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->weaponPacks_)
+        for (WeaponPack* weaponPack : this->weaponPacks_)
         {
             ++i;
             if (i > index)
-                return (elem);
+                return weaponPack;
         }
         return nullptr;
@@ -268,7 +268,7 @@
         // Check if the WeaponSet belongs to this WeaponSystem
         bool foundWeaponSet = false;
-        for (auto & elem : this->weaponSets_)
-        {
-            if (elem.second == wSet)
+        for (auto& mapEntry : this->weaponSets_)
+        {
+            if (mapEntry.second == wSet)
             {
                 foundWeaponSet = true;
@@ -296,6 +296,6 @@
     void WeaponSystem::reload()
     {
-        for (auto & elem : this->weaponSets_)
-            elem.second->reload();
+        for (auto& mapEntry : this->weaponSets_)
+            mapEntry.second->reload();
     }
 
Index: /code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.cc	(revision 10916)
@@ -165,8 +165,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->cameraPositions_)
+        for (CameraPosition* cameraPosition : this->cameraPositions_)
         {
             if (i == index)
-                return (elem);
+                return cameraPosition;
             ++i;
         }
@@ -180,7 +180,7 @@
 
         unsigned int counter = 0;
-        for (const auto & elem : this->cameraPositions_)
-        {
-            if ((elem) == this->currentCameraPosition_)
+        for (CameraPosition* cameraPosition : this->cameraPositions_)
+        {
+            if (cameraPosition == this->currentCameraPosition_)
                 break;
             counter++;
@@ -477,7 +477,7 @@
         if (parent)
         {
-            for (auto & elem : this->cameraPositions_)
-                if ((elem)->getIsAbsolute())
-                    parent->attach((elem));
+            for (CameraPosition* cameraPosition : this->cameraPositions_)
+                if (cameraPosition->getIsAbsolute())
+                    parent->attach(cameraPosition);
         }
     }
Index: /code/branches/cpp11_v2/src/orxonox/worldentities/EffectContainer.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/worldentities/EffectContainer.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/worldentities/EffectContainer.cc	(revision 10916)
@@ -89,7 +89,7 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->effects_)
+        for (WorldEntity* effect : this->effects_)
             if (i == index)
-                return (elem);
+                return effect;
         return nullptr;
     }
Index: /code/branches/cpp11_v2/src/orxonox/worldentities/WorldEntity.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/worldentities/WorldEntity.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/worldentities/WorldEntity.cc	(revision 10916)
@@ -233,14 +233,14 @@
 
             // iterate over all children and change their activity as well
-            for (const auto & elem : this->getAttachedObjects())
+            for (WorldEntity* object : this->getAttachedObjects())
             {
                 if(!this->isActive())
                 {
-                    (elem)->bActiveMem_ = (elem)->isActive();
-                    (elem)->setActive(this->isActive());
+                    object->bActiveMem_ = object->isActive();
+                    object->setActive(this->isActive());
                 }
                 else
                 {
-                    (elem)->setActive((elem)->bActiveMem_);
+                    object->setActive(object->bActiveMem_);
                 }
             }
@@ -259,14 +259,14 @@
         {
             // iterate over all children and change their visibility as well
-            for (const auto & elem : this->getAttachedObjects())
+            for (WorldEntity* object : this->getAttachedObjects())
             {
                 if(!this->isVisible())
                 {
-                    (elem)->bVisibleMem_ = (elem)->isVisible();
-                    (elem)->setVisible(this->isVisible());
+                    object->bVisibleMem_ = object->isVisible();
+                    object->setVisible(this->isVisible());
                 }
                 else
                 {
-                    (elem)->setVisible((elem)->bVisibleMem_);
+                    object->setVisible(object->bVisibleMem_);
                 }
             }
@@ -518,8 +518,8 @@
     {
         unsigned int i = 0;
-        for (const auto & elem : this->children_)
+        for (WorldEntity* child : this->children_)
         {
             if (i == index)
-                return (elem);
+                return child;
             ++i;
         }
@@ -938,6 +938,6 @@
         // Recalculate mass
         this->childrenMass_ = 0.0f;
-        for (const auto & elem : this->children_)
-            this->childrenMass_ += (elem)->getMass();
+        for (WorldEntity* child : this->children_)
+            this->childrenMass_ += child->getMass();
         recalculateMassProps();
         // Notify parent WE
Index: /code/branches/cpp11_v2/src/orxonox/worldentities/pawns/ModularSpaceShip.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/worldentities/pawns/ModularSpaceShip.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/worldentities/pawns/ModularSpaceShip.cc	(revision 10916)
@@ -99,13 +99,13 @@
             }
             // iterate through all attached parts
-            for(auto & elem : this->partList_)
+            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((elem->getName() == this->getAttachedObject(i)->getName()) && !elem->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_
-                    elem->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)), elem);
+                    this->addPartEntityAssignment((StaticEntity*)(this->getAttachedObject(i)), part);
                 }
             }
@@ -146,8 +146,8 @@
     ShipPart* ModularSpaceShip::getPartOfEntity(StaticEntity* entity) const
     {
-        for (const auto & elem : this->partMap_)
-        {
-            if (elem.first == entity)
-                return elem.second;
+        for (const auto& mapEntry : this->partMap_)
+        {
+            if (mapEntry.first == entity)
+                return mapEntry.second;
         }
         return nullptr;
@@ -242,9 +242,9 @@
     ShipPart* ModularSpaceShip::getShipPartByName(std::string name)
     {
-        for(auto & elem : this->partList_)
-        {
-            if(orxonox_cast<ShipPart*>(elem)->getName() == name)
-            {
-                return orxonox_cast<ShipPart*>(elem);
+        for(ShipPart* part : this->partList_)
+        {
+            if(orxonox_cast<ShipPart*>(part)->getName() == name)
+            {
+                return orxonox_cast<ShipPart*>(part);
             }
         }
@@ -256,12 +256,12 @@
     @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(auto & elem : this->partList_)
-        {
-            if(elem == part)
+    bool ModularSpaceShip::hasShipPart(ShipPart* search) const
+    {
+        for(ShipPart* part : this->partList_)
+        {
+            if(part == search)
                 return true;
         }
Index: /code/branches/cpp11_v2/src/orxonox/worldentities/pawns/SpaceShip.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/worldentities/pawns/SpaceShip.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/worldentities/pawns/SpaceShip.cc	(revision 10916)
@@ -158,6 +158,6 @@
 
         // Run the engines
-        for(auto & elem : this->engineList_)
-            (elem)->run(dt);
+        for(Engine* engine : this->engineList_)
+            engine->run(dt);
 
         if (this->hasLocalController())
@@ -313,12 +313,12 @@
     @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(auto & elem : this->engineList_)
-        {
-            if(elem == engine)
+    bool SpaceShip::hasEngine(Engine* search) const
+    {
+        for(Engine* engine : this->engineList_)
+        {
+            if(engine == search)
                 return true;
         }
@@ -350,7 +350,7 @@
     Engine* SpaceShip::getEngineByName(const std::string& name)
     {
-        for(auto & elem : this->engineList_)
-            if(elem->getName() == name)
-                return elem;
+        for(Engine* engine : this->engineList_)
+            if(engine->getName() == name)
+                return engine;
 
         orxout(internal_warning) << "Couldn't find Engine with name \"" << name << "\"." << endl;
@@ -396,6 +396,6 @@
     void SpaceShip::addSpeedFactor(float factor)
     {
-        for(auto & elem : this->engineList_)
-            elem->addSpeedMultiply(factor);
+        for(Engine* engine : this->engineList_)
+            engine->addSpeedMultiply(factor);
     }
 
@@ -408,6 +408,6 @@
     void SpaceShip::addSpeed(float speed)
     {
-        for(auto & elem : this->engineList_)
-            elem->addSpeedAdd(speed);
+        for(Engine* engine : this->engineList_)
+            engine->addSpeedAdd(speed);
     }
 
@@ -436,8 +436,8 @@
     {
         float speed=0;
-        for(auto & elem : this->engineList_)
-        {
-            if(elem->getMaxSpeedFront() > speed)
-                speed = elem->getMaxSpeedFront();
+        for(Engine* engine : this->engineList_)
+        {
+            if(engine->getMaxSpeedFront() > speed)
+                speed = engine->getMaxSpeedFront();
         }
         return speed;
Index: /code/branches/cpp11_v2/src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc
===================================================================
--- /code/branches/cpp11_v2/src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc	(revision 10915)
+++ /code/branches/cpp11_v2/src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc	(revision 10916)
@@ -80,7 +80,7 @@
 
         std::set<WorldEntity*> attachments = this->getAttachedObjects();
-        for (const auto & attachment : attachments)
+        for (WorldEntity* attachment : attachments)
         {
-            if ((attachment)->isA(Class(TeamColourable)))
+            if (attachment->isA(Class(TeamColourable)))
             {
                 TeamColourable* tc = orxonox_cast<TeamColourable*>(attachment);
