Changeset 10805 for code/branches/AI_HS15/src/orxonox/controllers/CommonController.cc

Timestamp:

Nov 15, 2015, 4:47:35 PM (9 years ago)

Author:

gania

Message:

Finished groundwork: AI fights enemies like I want it to. TODO implement all the functionality of old AI, like Waypoints, XMLPort

File:

• code/branches/AI_HS15/src/orxonox/controllers/CommonController.cc (modified) (9 diffs)

code/branches/AI_HS15/src/orxonox/controllers/CommonController.cc

@@ -55 +55 @@
         this->executingManeuver_ = false;
         this->executingMoveToPoint_ = false;
+        this->action_ = Action::FLY;
         this->stopLookingAtTarget();
         this->maneuverType_ = ManeuverType::NONE;
@@ -63 +64 @@
     CommonController::~CommonController() 
     {
+        orxout(internal_error) << "I died, my Rank is " << rank_ << endl;
     }
 
@@ -118 +120 @@
         }
     }
+    Action::Value CommonController::getAction ()
+    {
+        return this->action_;
+    }
+
+    void CommonController::setAction (Action::Value action, ControllableEntity* target)
+    {
+        this->action_ = action;
+        if (action == Action::FIGHT)
+        {   
+            if (target)
+                this->setTarget (target);
+        }
+        else if (action == Action::PROTECT)
+        {
+        }
+    }
+    void CommonController::setAction (Action::Value action, const Vector3& target)
+    {
+        this->action_ = action;
+        if (action == Action::FLY)
+        {
+            this->setTargetPosition (target);
+        }
+        else if (action == Action::PROTECT)
+        {
+
+        }
+    }
+    void CommonController::setAction (Action::Value action, const Vector3& target,  const Quaternion& orient )
+    {
+        this->action_ = action;
+        if (action == Action::FLY)
+        {
+            this->setTargetPosition (target);
+            this->setTargetOrientation (orient);
+        }
+        else if (action == Action::PROTECT)
+        {
+            
+        }
+    }
     void CommonController::maneuver() 
     {
@@ -145 +189 @@
 
             //bool bThisIsLookingAtTarget = this->isLooking ( getControllableEntity(), this->target_, math::pi/4 );
-            bool bTargetIsLookingAtThis = this->isLooking ( this->target_, getControllableEntity(), math::pi/8.0f );
+            bool bTargetIsLookingAtThis = this->isLooking ( this->target_, getControllableEntity(), math::pi/5.0f );
             
 
 
             //too far? well, come closer then
-            if ( diffLength > 5000 )
+            if ( diffLength > 3000 )
             {
                 if (diffLength < 6000)
                 {
-                    this->bEngaging_ = true;
+
                 }
                 else
                 {
-                    this->bEngaging_ = false;
                 }
                 this->setTargetPosition( this->positionOfTarget_ );
             }
             //too close? How do u expect to dodge anything? Just attack!
-            else if ( diffLength < 600 )
+            else if ( diffLength < 500 )
             {   
                 //at this point, just look and shoot
-                if ( diffLength < 300 )
+                if ( diffLength < 250 )
                 {
                     this->stopMoving();
@@ -205 +248 @@
         if ( this->getControllableEntity()  && !this->target_ )
         {
-            this->bEngaging_ = false;
+
             this->maneuverType_ = ManeuverType::NONE;
         }
-        orxout ( internal_error ) << "ManeuverType = " << this->maneuverType_ << endl;
+        //orxout ( internal_error ) << "ManeuverType = " << this->maneuverType_ << endl;
     }
     ControllableEntity* CommonController::getTarget()
@@ -305 +348 @@
     {
         this->target_ = target;
-        orxout ( internal_error ) << " TARGET SET " << endl;
+        //orxout ( internal_error ) << " TARGET SET " << endl;
         
         if ( this->target_ )
@@ -376 +419 @@
     void CommonController::moveToPosition( const Vector3& target, float dt )
     {
-        float factor = 1;
-        if ( !this->getControllableEntity() )
-            return;
-        if ( this->rank_ == Rank::DIVISIONLEADER )
-            factor = 0.9;
-        if ( this->rank_ == Rank::SECTIONLEADER )
-            factor = 0.95;
+     
         
         //100 is ( so far )the smallest tolerance ( empirically found )that can be reached, 
@@ -421 +458 @@
             }
 
-            this->getControllableEntity() ->moveFrontBack( SPEED*factor * dt );
+            this->getControllableEntity() ->moveFrontBack( SPEED * dt );
         }
         else
@@ -560 +597 @@
         float squaredDistance = squaredDistanceToTarget();
 
-        if ( squaredDistance < 25000000.0f && this->isLookingAtTarget( math::pi / 10.0f)) {
+        if ( squaredDistance < 9000000.0f && this->isLookingAtTarget( math::pi / 10.0f)) {
             return true;
         }