Changeset 11071 for code/trunk/src/orxonox/worldentities

Timestamp:

Jan 17, 2016, 10:29:21 PM (8 years ago)

Author:

landauf

Message:

merged branch cpp11_v3 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/orxonox/worldentities/Actionpoint.h (modified) (1 diff)
• src/orxonox/worldentities/CameraPosition.h (modified) (1 diff)
• src/orxonox/worldentities/ControllableEntity.cc (modified) (15 diffs)
• src/orxonox/worldentities/ControllableEntity.h (modified) (7 diffs)
• src/orxonox/worldentities/Drone.cc (modified) (2 diffs)
• src/orxonox/worldentities/Drone.h (modified) (1 diff)
• src/orxonox/worldentities/EffectContainer.cc (modified) (3 diffs)
• src/orxonox/worldentities/EffectContainer.h (modified) (2 diffs)
• src/orxonox/worldentities/ExplosionChunk.cc (modified) (1 diff)
• src/orxonox/worldentities/ExplosionChunk.h (modified) (1 diff)
• src/orxonox/worldentities/ExplosionPart.cc (modified) (1 diff)
• src/orxonox/worldentities/ExplosionPart.h (modified) (1 diff)
• src/orxonox/worldentities/MobileEntity.cc (modified) (1 diff)
• src/orxonox/worldentities/MobileEntity.h (modified) (3 diffs)
• src/orxonox/worldentities/MovableEntity.cc (modified) (2 diffs)
• src/orxonox/worldentities/MovableEntity.h (modified) (2 diffs)
• src/orxonox/worldentities/SpawnPoint.cc (modified) (1 diff)
• src/orxonox/worldentities/SpawnPoint.h (modified) (1 diff)
• src/orxonox/worldentities/StaticEntity.cc (modified) (1 diff)
• src/orxonox/worldentities/StaticEntity.h (modified) (2 diffs)
• src/orxonox/worldentities/TeamSpawnPoint.h (modified) (2 diffs)
• src/orxonox/worldentities/WorldEntity.cc (modified) (23 diffs)
• src/orxonox/worldentities/WorldEntity.h (modified) (7 diffs)
• src/orxonox/worldentities/pawns/FpsPlayer.cc (modified) (4 diffs)
• src/orxonox/worldentities/pawns/FpsPlayer.h (modified) (1 diff)
• src/orxonox/worldentities/pawns/ModularSpaceShip.cc (modified) (10 diffs)
• src/orxonox/worldentities/pawns/ModularSpaceShip.h (modified) (1 diff)
• src/orxonox/worldentities/pawns/Pawn.cc (modified) (12 diffs)
• src/orxonox/worldentities/pawns/Pawn.h (modified) (11 diffs)
• src/orxonox/worldentities/pawns/SpaceShip.cc (modified) (16 diffs)
• src/orxonox/worldentities/pawns/Spectator.cc (modified) (1 diff)
• src/orxonox/worldentities/pawns/TeamBaseMatchBase.cc (modified) (3 diffs)
• src/orxonox/worldentities/pawns/TeamBaseMatchBase.h (modified) (4 diffs)

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

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

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

@@ -41 +41 @@
             virtual ~CameraPosition();
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 
             inline void setDrag(bool bDrag)

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

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

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

@@ -54 +54 @@
             virtual ~ControllableEntity();
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            virtual void tick(float dt);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+            virtual void tick(float dt) override;
             void setConfigValues();
 
@@ -121 +121 @@
             void addCameraPosition(CameraPosition* position);
             CameraPosition* getCameraPosition(unsigned int index) const;
-            inline const std::list<StrongPtr<CameraPosition> >& getCameraPositions() const
+            inline const std::list<StrongPtr<CameraPosition>>& getCameraPositions() const
                 { return this->cameraPositions_; }
             unsigned int getCurrentCameraIndex() const;
@@ -141 +141 @@
             using MobileEntity::setAngularVelocity;
 
-            void setPosition(const Vector3& position);
-            void setOrientation(const Quaternion& orientation);
-            void setVelocity(const Vector3& velocity);
-            void setAngularVelocity(const Vector3& velocity);
+            virtual void setPosition(const Vector3& position) override;
+            virtual void setOrientation(const Quaternion& orientation) override;
+            virtual void setVelocity(const Vector3& velocity) override;
+            virtual void setAngularVelocity(const Vector3& velocity) override;
 
             inline bool hasLocalController() const
@@ -177 +177 @@
 
         protected:
-            virtual void preDestroy();
+            virtual void preDestroy() override;
 
             virtual void setPlayer(PlayerInfo* player); // don't call this directly, use friend class PlayerInfo instead
@@ -184 +184 @@
             virtual void startLocalHumanControl();
             virtual void stopLocalHumanControl();
-            virtual void parentChanged();
+            virtual void parentChanged() override;
 
             inline void setHudTemplate(const std::string& name)
@@ -214 +214 @@
 
             // Bullet btMotionState related
-            void setWorldTransform(const btTransform& worldTrans);
+            virtual void setWorldTransform(const btTransform& worldTrans) override;
 
             unsigned int server_overwrite_;
@@ -242 +242 @@
             bool bMouseLook_;
             float mouseLookSpeed_;
-            std::list<StrongPtr<CameraPosition> > cameraPositions_;
+            std::list<StrongPtr<CameraPosition>> cameraPositions_;
             CameraPosition* currentCameraPosition_;
             std::string cameraPositionTemplate_;

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

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

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

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

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

@@ -44 +44 @@
     EffectContainer::EffectContainer(Context* context)
         : BaseObject(context)
-        , lua_(NULL)
+        , lua_(nullptr)
     {
         RegisterObject(EffectContainer);
@@ -89 +89 @@
     {
         unsigned int i = 0;
-        for (std::vector<WorldEntity*>::const_iterator it = this->effects_.begin(); it != this->effects_.end(); ++it)
+        for (WorldEntity* effect : this->effects_)
             if (i == index)
-                return (*it);
-        return NULL;
+                return effect;
+        return nullptr;
     }
 
@@ -103 +103 @@
             bool result = (bool)lua_toboolean(this->lua_->getInternalLuaState(), -1);
             lua_pop(this->lua_->getInternalLuaState(), 1);
-            for (std::vector<WorldEntity*>::const_iterator it = this->effects_.begin(); it != this->effects_.end(); ++it)
+            for (WorldEntity* effect : this->effects_)
             {
-                (*it)->setMainState(result);
+                effect->setMainState(result);
             }
         }

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

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

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

@@ -62 +62 @@
             {
                 orxout(internal_error) << "Couldn't load particle effect in ExplosionChunk: " << ex.what() << endl;
-                this->fire_ = 0;
-                this->smoke_ = 0;
+                this->fire_ = nullptr;
+                this->smoke_ = nullptr;
             }
         }
         else
         {
-            this->fire_ = 0;
-            this->smoke_ = 0;
+            this->fire_ = nullptr;
+            this->smoke_ = nullptr;
         }
 

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

@@ -43 +43 @@
             virtual ~ExplosionChunk();
 
-            virtual void tick(float dt);
+            virtual void tick(float dt) override;
 
             inline void setLOD(LODParticle::Value level)

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

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

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

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

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

@@ -189 +189 @@
     bool MobileEntity::isCollisionTypeLegal(WorldEntity::CollisionType type) const
     {
-        if (type == WorldEntity::Static)
+        if (type == WorldEntity::CollisionType::Static)
         {
             orxout(internal_warning) << "Cannot tell a MobileEntity to have static collision type! Ignoring." << endl;

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

@@ -57 +57 @@
             virtual ~MobileEntity();
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            virtual void tick(float dt);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
+            virtual void tick(float dt) override;
 
-            virtual void setPosition(const Vector3& position);
-            virtual void setOrientation(const Quaternion& orientation);
+            virtual void setPosition(const Vector3& position) override;
+            virtual void setOrientation(const Quaternion& orientation) override;
 
             virtual void setVelocity(const Vector3& velocity);
             inline void setVelocity(float x, float y, float z)
                 { this->setVelocity(Vector3(x, y, z)); }
-            inline const Vector3& getVelocity() const
+            virtual inline const Vector3& getVelocity() const override
                 { return this->linearVelocity_; }
             /**
@@ -110 +110 @@
         protected:
             // Bullet btMotionState related
-            virtual void setWorldTransform(const btTransform& worldTrans);
-            void getWorldTransform(btTransform& worldTrans) const;
+            virtual void setWorldTransform(const btTransform& worldTrans) override;
+            virtual void getWorldTransform(btTransform& worldTrans) const override;
 
             Vector3 linearAcceleration_;
@@ -119 +119 @@
 
         private:
-            virtual bool isCollisionTypeLegal(WorldEntity::CollisionType type) const;
+            virtual bool isCollisionTypeLegal(WorldEntity::CollisionType type) const override;
     };
 }

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

@@ -50 +50 @@
         this->overwrite_orientation_ = Quaternion::IDENTITY;
 
-        this->continuousResynchroTimer_ = 0;
+        this->continuousResynchroTimer_ = nullptr;
 
         this->setPriority(Priority::Low);
@@ -80 +80 @@
             {
                 float damage = this->collisionDamage_ * (victim->getVelocity() - this->getVelocity()).length();
-                victim->hit(0, contactPoint, ownCollisionShape, damage);
+                victim->hit(nullptr, contactPoint, ownCollisionShape, damage);
             }
         }

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

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

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

@@ -43 +43 @@
         RegisterObject(SpawnPoint);
 
-        this->template_ = 0;
+        this->template_ = nullptr;
 
         if (this->getGametype())

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

@@ -44 +44 @@
             virtual ~SpawnPoint() {}
 
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
 
             inline void setSpawnClass(Identifier* identifier)

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

@@ -95 +95 @@
     bool StaticEntity::isCollisionTypeLegal(WorldEntity::CollisionType type) const
     {
-        if (type == WorldEntity::Kinematic || type == WorldEntity::Dynamic)
+        if (type == WorldEntity::CollisionType::Kinematic || type == WorldEntity::CollisionType::Dynamic)
         {
             orxout(internal_warning) << "Cannot tell a StaticEntity to have kinematic or dynamic collision type! Ignoring." << endl;

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

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

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

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

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

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

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

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

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

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

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

@@ -69 +69 @@
             virtual void fire();
 
-            bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
+            virtual bool collidesAgainst(WorldEntity* otherObject, const btCollisionShape* ownCollisionShape, btManifoldPoint& contactPoint) override;
 
             virtual void addedWeaponPack(WeaponPack* wPack);

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

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

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

@@ -109 +109 @@
             ShipPart* getPartOfEntity(StaticEntity* entity) const;
 
-            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL, const btCollisionShape* cs = NULL);
+            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = nullptr, const btCollisionShape* cs = nullptr);
 
             static void killShipPartStatic(std::string name);

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

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

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

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

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

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

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

@@ -58 +58 @@
         this->localVelocity_ = Vector3::ZERO;
         this->setHudTemplate("spectatorhud");
-        this->greetingFlare_ = 0;
+        this->greetingFlare_ = nullptr;
 
         this->setDestroyWhenPlayerLeft(true);

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

@@ -51 +51 @@
         }
 
-        this->setRadarObjectShape(RadarViewable::Triangle);
+        this->setRadarObjectShape(RadarViewable::Shape::Triangle);
     }
 
@@ -80 +80 @@
 
         std::set<WorldEntity*> attachments = this->getAttachedObjects();
-        for (std::set<WorldEntity*>::iterator it = attachments.begin(); it != attachments.end(); ++it)
+        for (WorldEntity* attachment : attachments)
         {
-            if ((*it)->isA(Class(TeamColourable)))
+            if (attachment->isA(Class(TeamColourable)))
             {
-                TeamColourable* tc = orxonox_cast<TeamColourable*>(*it);
+                TeamColourable* tc = orxonox_cast<TeamColourable*>(attachment);
                 tc->setTeamColour(colour);
             }
@@ -92 +92 @@
 
         // Call this so bots stop shooting at the base after they converted it
-        for (ObjectList<ArtificialController>::iterator it = ObjectList<ArtificialController>::begin(); it != ObjectList<ArtificialController>::end(); ++it)
-            it->abandonTarget(this);
+        for (ArtificialController* controller : ObjectList<ArtificialController>())
+            controller->abandonTarget(this);
     }
 }

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

@@ -36 +36 @@
 namespace orxonox
 {
-    namespace BaseState
+    enum class BaseState
     {
-        enum Value
-        {
-            Uncontrolled,
-            ControlTeam1,
-            ControlTeam2,
-        };
-    }
+        Uncontrolled,
+        ControlTeam1,
+        ControlTeam2,
+    };
 
 
@@ -58 +55 @@
 
             // Set the state of a base to whatever the argument of the function is
-            void setState(BaseState::Value state)
+            void setState(BaseState state)
             {
                 this->state_ = state;
@@ -66 +63 @@
 
             // Get the state of a base as a return value
-            BaseState::Value getState() const
+            BaseState getState() const
             {
                 return this->state_;
@@ -75 +72 @@
             void changeTeamColour();
 
-            BaseState::Value state_;
+            BaseState state_;
     };
 }