Index: /code/branches/towerdefenseHS14/src/modules/objects/controllers/TeamTargetProxy.cc
===================================================================
--- /code/branches/towerdefenseHS14/src/modules/objects/controllers/TeamTargetProxy.cc	(revision 10242)
+++ /code/branches/towerdefenseHS14/src/modules/objects/controllers/TeamTargetProxy.cc	(revision 10243)
@@ -33,5 +33,5 @@
 namespace orxonox
 {
-	RegisterClass(TeamTargetProxy);
+    RegisterClass(TeamTargetProxy);
 
    /**
@@ -42,10 +42,10 @@
        The context
     */
-	TeamTargetProxy::TeamTargetProxy(Context* context) : FormationController(context)
- 	{
- 		RegisterObject(TeamTargetProxy);
+    TeamTargetProxy::TeamTargetProxy(Context* context) : FormationController(context)
+    {
+        RegisterObject(TeamTargetProxy);
 
- 		this->once_ = false;
- 	}
+        this->once_ = false;
+    }
 
     /**
@@ -53,7 +53,7 @@
         Destructor. Nothing to see here.
      */
- 	TeamTargetProxy::~TeamTargetProxy()
- 	{
- 	}
+    TeamTargetProxy::~TeamTargetProxy()
+    {
+    }
 
     /**
@@ -63,8 +63,8 @@
         That's all there is.
     */
- 	void TeamTargetProxy::tick(float dt)
- 	{
-	    if (!this->isActive() || !this->getControllableEntity())
-	        return;
+    void TeamTargetProxy::tick(float dt)
+    {
+        if (!this->isActive() || !this->getControllableEntity())
+            return;
 
         ControllableEntity* parent = orxonox_cast<ControllableEntity*> (this->getControllableEntity()->getParent());
@@ -102,4 +102,4 @@
             }
         }
- 	}
+    }
 }
Index: /code/branches/towerdefenseHS14/src/modules/objects/controllers/TeamTargetProxy.h
===================================================================
--- /code/branches/towerdefenseHS14/src/modules/objects/controllers/TeamTargetProxy.h	(revision 10242)
+++ /code/branches/towerdefenseHS14/src/modules/objects/controllers/TeamTargetProxy.h	(revision 10243)
@@ -30,30 +30,30 @@
 #define _TeamTargetProxy_H__
 
-#include "OrxonoxPrereqs.h"
+#include "objects/ObjectsPrereqs.h"
 #include "controllers/FormationController.h"
 
  namespace orxonox
  {
- 	/**
- 		@brief
- 		A controller, that just copies the team and the target of a parent for itself and it's controllable entity.
+    /**
+        @brief
+        A controller, that just copies the team and the target of a parent for itself and it's controllable entity.
 
- 		Useful for following (and similar) situations: (-> means attached to)
-			turret (rotates) -> some kind of turret base (looks nice) -> spaceship (flies around)
-			The turret has a controller that wants to copy the spaceship's target and team. In this case it doesn't work though,
-			because the turret isn't directly attached to the spaceship. Here's where this controller comes in. Drawback: the base
-			has to be controllable and ticks every second (performance?)
- 	*/
- 	class _OrxonoxExport TeamTargetProxy : public FormationController, public Tickable
- 	{
- 		public:
- 			TeamTargetProxy(Context* context);
- 			virtual ~TeamTargetProxy();
+        Useful for following (and similar) situations: (-> means attached to)
+            turret (rotates) -> some kind of turret base (looks nice) -> spaceship (flies around)
+            The turret has a controller that wants to copy the spaceship's target and team. In this case it doesn't work though,
+            because the turret isn't directly attached to the spaceship. Here's where this controller comes in. Drawback: the base
+            has to be controllable and ticks every second (performance?)
+    */
+    class _ObjectsExport TeamTargetProxy : public FormationController, public Tickable
+    {
+        public:
+            TeamTargetProxy(Context* context);
+            virtual ~TeamTargetProxy();
 
- 			virtual void tick(float dt);
+            virtual void tick(float dt);
 
- 		private:
- 			bool once_; //!< Flag for executing code in the tick function only once.
- 	};
+        private:
+            bool once_; //!< Flag for executing code in the tick function only once.
+    };
  }
 
Index: /code/branches/towerdefenseHS14/src/modules/objects/controllers/TurretController.cc
===================================================================
--- /code/branches/towerdefenseHS14/src/modules/objects/controllers/TurretController.cc	(revision 10242)
+++ /code/branches/towerdefenseHS14/src/modules/objects/controllers/TurretController.cc	(revision 10243)
@@ -29,9 +29,9 @@
 #include "TurretController.h"
 #include "worldentities/pawns/Pawn.h"
-#include "Turret.h"
+#include "objects/Turret.h"
 
  namespace orxonox
  {
- 	RegisterClass(TurretController);
+    RegisterClass(TurretController);
 
     /**
@@ -42,11 +42,11 @@
         The context
     */
- 	TurretController::TurretController(Context* context) : ArtificialController(context)
- 	{
- 		RegisterObject(TurretController);
-
- 		this->once_ = false;
-
- 	}
+    TurretController::TurretController(Context* context) : ArtificialController(context)
+    {
+        RegisterObject(TurretController);
+
+        this->once_ = false;
+
+    }
 
     /**
@@ -54,8 +54,8 @@
         Destructor. Nothing to see here.
     */
- 	TurretController::~TurretController()
- 	{
-
- 	}
+    TurretController::~TurretController()
+    {
+
+    }
 
     /**
@@ -69,6 +69,6 @@
         The function that scores the pawns.
     */
- 	void TurretController::searchTarget()
- 	{
+    void TurretController::searchTarget()
+    {
         Turret* turret = orxonox_cast<Turret*>(this->getControllableEntity());
 
@@ -76,10 +76,10 @@
         if(this->target_ && turret->isInRange(target_) != -1.f && !FormationController::sameTeam(turret, this->target_, this->getGametype()))
         {
-        	return;
+            return;
         }
         else
         {
-        	this->forgetTarget();
-        	turret->setTarget(0);
+            this->forgetTarget();
+            turret->setTarget(0);
         }
 
@@ -88,11 +88,11 @@
         if(parent)
         {
-        	Pawn* parenttarget = orxonox_cast<Pawn*>(parent->getTarget());
-        	if(parenttarget && turret->isInRange(parenttarget))
-        	{
-        		this->setTarget(parenttarget);
-        		turret->setTarget(parenttarget);
-        		return;
-        	}
+            Pawn* parenttarget = orxonox_cast<Pawn*>(parent->getTarget());
+            if(parenttarget && turret->isInRange(parenttarget))
+            {
+                this->setTarget(parenttarget);
+                turret->setTarget(parenttarget);
+                return;
+            }
         }
 
@@ -101,22 +101,22 @@
         Pawn* minScorePawn = 0;
 
-  		for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)     
-        {
-        	Pawn* entity = orxonox_cast<Pawn*>(*it);
+        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+        {
+            Pawn* entity = orxonox_cast<Pawn*>(*it);
             if (!entity || FormationController::sameTeam(this->getControllableEntity(), entity, this->getGametype()))
-            	continue;
+                continue;
             tempScore = turret->isInRange(entity);
             if(tempScore != -1.f)
             {
-            	if(tempScore < minScore)
-            	{
-            		minScore = tempScore;
-            		minScorePawn = entity;
-            	}
-            }
-    	}
+                if(tempScore < minScore)
+                {
+                    minScore = tempScore;
+                    minScorePawn = entity;
+                }
+            }
+        }
         this->setTarget(minScorePawn);
         turret->setTarget(minScorePawn);
- 	}
+    }
 
     /**
@@ -124,8 +124,8 @@
         Tests, if the turret is looking at the target, with a specified tolerance
 
-		This uses the world position as opposed to the local position in the old version.
-
-		@param angle
-		The tolerance, in radians
+        This uses the world position as opposed to the local position in the old version.
+
+        @param angle
+        The tolerance, in radians
     */
     bool TurretController::isLookingAtTargetNew(float angle) const
@@ -140,26 +140,26 @@
         The more health and distance a pawn has, the higher the score. This means lower equals better.
 
-		@param pawn
-		The pawn to score
-
-		@param distance
-		The distance. Can be squared or normed, doesn't matter as long as all are treated the same.
+        @param pawn
+        The pawn to score
+
+        @param distance
+        The distance. Can be squared or normed, doesn't matter as long as all are treated the same.
     */   
- 	float TurretController::targetScore(Pawn* pawn, float distance) const
- 	{
- 		return pawn->getHealth()/pawn->getMaxHealth() + distance;
- 	}
-
-    /**
-    	@brief
-    	Does all the controlling of the turret.
-
-    	If the turret has a parent, copies the team from there, if it's not already set.
-    	Other actions are: Search a target. If a target has been found, aim and shoot at it.
-    */
- 	void TurretController::tick(float dt)
- 	{
-	    if (!this->isActive() || !this->getControllableEntity())
-	        return;
+    float TurretController::targetScore(Pawn* pawn, float distance) const
+    {
+        return pawn->getHealth()/pawn->getMaxHealth() + distance;
+    }
+
+    /**
+        @brief
+        Does all the controlling of the turret.
+
+        If the turret has a parent, copies the team from there, if it's not already set.
+        Other actions are: Search a target. If a target has been found, aim and shoot at it.
+    */
+    void TurretController::tick(float dt)
+    {
+        if (!this->isActive() || !this->getControllableEntity())
+            return;
 
 
@@ -171,5 +171,5 @@
 
         if(!this->once_)
-        	this->once_ = true;
+            this->once_ = true;
      
         //Teams aren't set immediately, after creation, so we have to check every tick...
@@ -188,15 +188,15 @@
         }
 
- 		this->searchTarget();
-		if(this->target_)
- 		{
- 			Turret* turret = orxonox_cast<Turret*> (this->getControllableEntity());
- 			this->aimAtTarget();
- 			turret->aimAtPosition(target_->getWorldPosition());
- 			if(this->isLookingAtTargetNew(Degree(5).valueRadians()))
- 			{
- 				this->getControllableEntity()->fire(0);
- 			}
- 		}
- 	}
+        this->searchTarget();
+        if(this->target_)
+        {
+            Turret* turret = orxonox_cast<Turret*> (this->getControllableEntity());
+            this->aimAtTarget();
+            turret->aimAtPosition(target_->getWorldPosition());
+            if(this->isLookingAtTargetNew(Degree(5).valueRadians()))
+            {
+                this->getControllableEntity()->fire(0);
+            }
+        }
+    }
  }
Index: /code/branches/towerdefenseHS14/src/modules/objects/controllers/TurretController.h
===================================================================
--- /code/branches/towerdefenseHS14/src/modules/objects/controllers/TurretController.h	(revision 10242)
+++ /code/branches/towerdefenseHS14/src/modules/objects/controllers/TurretController.h	(revision 10243)
@@ -34,31 +34,31 @@
 #define _TurretController_H__
 
-#include "OrxonoxPrereqs.h"
+#include "objects/ObjectsPrereqs.h"
 #include "controllers/ArtificialController.h"
 
  namespace orxonox
  {
- 	/**
- 		@brief
- 		Controller for turrets. Chooses a target, and makes the turret aim/shoot at it.
+    /**
+        @brief
+        Controller for turrets. Chooses a target, and makes the turret aim/shoot at it.
 
- 		The controllableEntity gets casted to Turret, so this controller won't work for anything else.
- 	*/
- 	class _OrxonoxExport TurretController : public ArtificialController, public Tickable
- 	{
- 		public:
- 			TurretController(Context* context);
- 			virtual ~TurretController();
+        The controllableEntity gets casted to Turret, so this controller won't work for anything else.
+    */
+    class _ObjectsExport TurretController : public ArtificialController, public Tickable
+    {
+        public:
+            TurretController(Context* context);
+            virtual ~TurretController();
 
- 			virtual void tick(float dt);
+            virtual void tick(float dt);
 
- 		private:
+        private:
 
- 			void searchTarget();
- 			bool isLookingAtTargetNew(float angle) const;
- 			float targetScore(Pawn* pawn, float distance) const;
+            void searchTarget();
+            bool isLookingAtTargetNew(float angle) const;
+            float targetScore(Pawn* pawn, float distance) const;
 
- 			bool once_; //!< Flag for executing code in the tick function only once.
- 	};
+            bool once_; //!< Flag for executing code in the tick function only once.
+    };
  }
 
