Changeset 10060 for code/branches/turretFS14/src/modules/objects/controllers

Timestamp:

May 15, 2014, 5:10:55 PM (11 years ago)

Author:

muemart

Message:

Fix team acquisition, edit test level and start to try to make a raytest

Location:

code/branches/turretFS14/src/modules/objects/controllers

Files:

• TeamTargetProxy.cc (modified) (4 diffs)
• TeamTargetProxy.h (modified) (2 diffs)
• TurretController.cc (modified) (7 diffs)
• TurretController.h (modified) (1 diff)

code/branches/turretFS14/src/modules/objects/controllers/TeamTargetProxy.cc

@@ -28 +28 @@
 
 #include "TeamTargetProxy.h"
+#include "worldentities/ControllableEntity.h"
 #include "worldentities/pawns/Pawn.h"
 
- namespace orxonox
- {
-        RegisterClass(TeamTargetProxy);
+namespace orxonox
+{
+        RegisterClass(TeamTargetProxy);
 
-        TeamTargetProxy::TeamTargetProxy(Context* context) : FormationController(context)
+   /**
+       @brief 
+       Sets default values for all variables.
+
+       @param context
+       The context
+    */
+        TeamTargetProxy::TeamTargetProxy(Context* context) : FormationController(context)
         {
                 RegisterObject(TeamTargetProxy);
@@ -41 +49 @@
         }
 
+    /**
+        @brief 
+        Destructor. Nothing to see here.
+     */
         TeamTargetProxy::~TeamTargetProxy()
         {
         }
 
+    /**
+        @brief
+        Copies the team and the target from the parent.
+
+        That's all there is.
+    */
         void TeamTargetProxy::tick(float dt)
         {
@@ -51 +69 @@
 
         ControllableEntity* parent = orxonox_cast<ControllableEntity*> (this->getControllableEntity()->getParent());
-                
 
+        if(this->getTeam() != -1 && !this->once_ && parent)
+        {
+            orxout(internal_warning) << "TeamTargetProxy: Team already set, may result in undesired behaviour. Will get overridden by the parent's team." << endl;
+        }
+
+        if(!this->once_)
+            this->once_ = true;
+
+        //Teams aren't set immediately, after creation, so we have to check every tick...
+        if(parent)
+        {
+            Controller* parentcontroller = parent->getController();
+            if(parentcontroller)
+            {
+                this->setTeam(parentcontroller->getTeam());
+            }
+            else
+            {
+                this->setTeam(parent->getTeam());
+            }
+            this->getControllableEntity()->setTeam(parent->getTeam());
+        }
 
         if(parent)
         {
-
-            if(!this->once_)
-            {
-                //Set the same team
-                if(parent)
-                {
-                    Controller* parentcontroller = parent->getController();
-                    if(parentcontroller)
-                    {
-                        this->setTeam(parentcontroller->getTeam());
-                    }
-                    else
-                    {
-                        this->setTeam(parent->getTeam());
-                    }
-                    this->getControllableEntity()->setTeam(parent->getTeam());
-                }
-                this->once_ = true;
-            }
-
             Pawn* parenttarget = orxonox_cast<Pawn*>(parent->getTarget());
             if(parenttarget)
@@ -83 +102 @@
             }
         }
-
         }
- }
+}

code/branches/turretFS14/src/modules/objects/controllers/TeamTargetProxy.h

@@ -35 +35 @@
  namespace orxonox
  {
+        /**
+                @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
         {
@@ -44 +54 @@
 
                 private:
-                        bool once_;
+                        bool once_; //!< Flag for executing code in the tick function only once.
         };
  }

code/branches/turretFS14/src/modules/objects/controllers/TurretController.cc

@@ -35 +35 @@
         RegisterClass(TurretController);
 
+    /**
+        @brief 
+        Sets default values for all variables.
+
+        @param context
+        The context
+    */
         TurretController::TurretController(Context* context) : ArtificialController(context)
         {
@@ -43 +50 @@
         }
 
+    /**
+        @brief 
+        Destructor. Nothing to see here.
+    */
         TurretController::~TurretController()
         {
@@ -48 +59 @@
         }
 
+    /**
+        @brief 
+        Searches a valid target for the turret to aim at.
+
+        Loops through all pawns and tests, if it is in range. Scores every pawn and chooses the best one (the one with the lowest score).
+        If the turret has a parent, try to aim at the same target the parent has, if there is one.
+
+        @see targetScore
+        The function that scores the pawns.
+    */
         void TurretController::searchTarget()
         {
         Turret* turret = orxonox_cast<Turret*>(this->getControllableEntity());
-        if(target_ && turret->isInRange(target_->getWorldPosition()))
+
+        //The controller might find a target before teams are set, so we need to check again here.
+        if(this->target_ && turret->isInRange(target_) != -1.f && !FormationController::sameTeam(turret, this->target_, this->getGametype()))
         {
                 return;
@@ -66 +89 @@
         {
                 Pawn* parenttarget = orxonox_cast<Pawn*>(parent->getTarget());
-                if(parenttarget && turret->isInRange(parenttarget->getWorldPosition()))
+                if(parenttarget && turret->isInRange(parenttarget))
                 {
                         this->setTarget(parenttarget);
@@ -74 +97 @@
         }
 
-                for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+        float maxScore = 0;
+        float tempScore;
+        Pawn* maxScorePawn = 0;
+
+                for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)     
         {
                 Pawn* entity = orxonox_cast<Pawn*>(*it);
-            if (this->FormationController::sameTeam(this->getControllableEntity(), entity, this->getGametype()))
+            if (!entity || FormationController::sameTeam(this->getControllableEntity(), entity, this->getGametype()))
                 continue;
-
-            if(turret->isInRange(entity->getWorldPosition()))
+            tempScore = turret->isInRange(entity);
+            if(tempScore != -1.f)
             {
-                this->setTarget(entity);
-                turret->setTarget(entity);
-                break;
+                if(tempScore > maxScore)
+                {
+                        maxScore = tempScore;
+                        maxScorePawn = entity;
+                }
             }
-        }               
-        }
-
+        }
+        this->setTarget(maxScorePawn);
+        turret->setTarget(maxScorePawn);
+        }
+
+    /**
+        @brief 
+        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
+    */
     bool TurretController::isLookingAtTargetNew(float angle) const
     {
@@ -94 +134 @@
     }
 
+    /**
+        @brief 
+        Scores a pawn as a target, based on distance and health.
+
+        The more health and distance a pawn has, the higher the score. This means lower equals better target.
+
+                @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)
         {
@@ -100 +164 @@
 
 
-                if(!this->once_)
-                {
-                        if(this->getTeam() != -1)
-                        {
-                                orxout(internal_warning) << "Turret: Team already set, may result in undesired behaviour" << endl;
-                        }
-                        else
-                        {
-                    //Make sure the turret is in the same team as the parent
-                    ControllableEntity* parent = orxonox_cast<ControllableEntity*> (this->getControllableEntity()->getParent());
-                    if(parent)
-                    {
-                        Controller* parentcontroller = parent->getController();
-                        if(parentcontroller)
-                        {
-                            this->setTeam(parentcontroller->getTeam());
-                        }
-                        else
-                        {
-                            this->setTeam(parent->getTeam());
-                        }
-                        this->getControllableEntity()->setTeam(parent->getTeam());
-                    }
-                }
-            this->once_ = true;
+        ControllableEntity* parent = orxonox_cast<ControllableEntity*> (this->getControllableEntity()->getParent());
+        if(this->getTeam() != -1 && !this->once_ && parent)
+        {
+            orxout(internal_warning) << "TurretController: Team already set, may result in undesired behaviour. Will get overridden by the parent's team." << endl;
+        }
+
+        if(!this->once_)
+                this->once_ = true;
+     
+        //Teams aren't set immediately, after creation, so we have to check every tick...
+        if(parent)
+        {
+            Controller* parentcontroller = parent->getController();
+            if(parentcontroller)
+            {
+                this->setTeam(parentcontroller->getTeam());
+            }
+            else
+            {
+                this->setTeam(parent->getTeam());
+            }
+            this->getControllableEntity()->setTeam(parent->getTeam());
         }
 
                 this->searchTarget();
-                if(target_)
+                if(this->target_)
                 {
                         Turret* turret = orxonox_cast<Turret*> (this->getControllableEntity());

code/branches/turretFS14/src/modules/objects/controllers/TurretController.h

@@ -57 +57 @@
                         void searchTarget();
                         bool isLookingAtTargetNew(float angle) const;
+                        float targetScore(Pawn* pawn, float distance) const;
 
-                        bool once_;
+                        bool once_; //!< Flag for executing code in the tick function only once.
         };
  }