Changeset 10849 for code/branches/campaignHS15/src

Timestamp:

Nov 24, 2015, 5:21:03 PM (9 years ago)

Author:

gania

Message:

major change: introduced Actionpoints, look AITest.oxw. Only FLY works for now

Location:

code/branches/campaignHS15/src/orxonox/controllers

Files:

• CommonController.cc (modified) (13 diffs)
• CommonController.h (modified) (3 diffs)
• DivisionController.cc (modified) (8 diffs)

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

@@ -58 +58 @@
     CommonController::CommonController( Context* context ): Controller( context )
     {
-        this->action_ = Action::FLY;
+        this->squaredaccuracy_ = 500;
+        this->action_ = Action::NONE;
         this->stopLookingAtTarget();
-        this->attackRange_ = 2500;
+        this->attackRange_ = 800;
         RegisterObject( CommonController );
     }
@@ -69 +70 @@
         //orxout(internal_error) << "I died, my Rank is " << rank_ << endl;
     }
-    void CommonController::backupAction()
-    {
-        this->actionpoints_.push_back (this->currentActionpoint_);
-    }
-    void CommonController::restoreAction()
-    {
-        this->currentActionpoint_ = this->actionpoints_.back();
-        this->actionpoints_.pop_back();
-    }
-    void CommonController::popAction()
-    {
-        this->currentActionpoint_ = actionpoints_.back();
-        actionpoints_.pop_back();
-    }
-
+    
+  
     void CommonController::XMLPort( Element& xmlelement, XMLPort::Mode mode )
     {
@@ -120 +108 @@
         if (!this->getProtect())
             return "noProtectWasSet";
-        return CommonController::getName (this->getProtect());
+        return CommonController::getName (orxonox_cast<Pawn*>(this->getProtect()));
     }
     std::string CommonController::getName(Pawn* entity)
@@ -256 +244 @@
     {
         this->action_ = action;
-        if (action == Action::FIGHT)
+        if (action == Action::FIGHT || action == Action::FIGHTALL || action == Action::ATTACK)
         {   
             if (target)
@@ -334 +322 @@
             }
             else
-                ThrowException( ParseError, std::string( "Attempting to set an unknown Action: '" )+ val + "'." );
+                ThrowException( ParseError, std::string( "Attempting to set an unknown Action: '" )+ actionName + "'." );
             //this->setAction( value );
-            parsedActionpoints_.push_back( std::make_tuple (value, targetName, position) );
-        }
-        else
-        {
-            parsedActionpoints_.push_back( 
-                std::make_tuple (Action::FLY, "", actionpoint->getWorldPosition()) );
+            Point p = { value, targetName, position };
+            parsedActionpoints_.push_back(p);
+            orxout(internal_error) << "Pushed " << p.action << endl;
+        }
+        else
+        {
+            Point p = { Action::FLY, "", actionpoint->getWorldPosition() };
+            parsedActionpoints_.push_back(p);
         }
             this->actionpoints_.push_back(actionpoint);
@@ -357 +347 @@
     void CommonController::setClosestTarget()
     {
-        this->setTarget (closestTarget()); 
-    }
-    ControllableEntity* CommonController::closestTarget()
+        this->setTarget (static_cast<ControllableEntity*>( closestTarget() ) ); 
+    }
+    Pawn* CommonController::closestTarget()
     {
         if (!this->getControllableEntity())
@@ -381 +371 @@
         if (closestTarget)
         {
-           return static_cast<ControllableEntity*>(closestTarget);
+           return closestTarget;
         } 
         return 0;  
@@ -391 +381 @@
         if (!this->parsedActionpoints_.empty())
         {
-            this->action_ = std::get<0>( this->parsedActionpoints_.back() );
+            this->action_ = this->parsedActionpoints_.back().action;
 
             switch ( this->action_ )
@@ -401 +391 @@
                 case Action::FLY:
                 {
-                    this->setTargetPosition(std::get<2>( this->parsedActionpoints_.back() ));
+                    this->setTargetPosition( this->parsedActionpoints_.back().position );
                     if (this->squaredDistanceToTarget() <= this->squaredaccuracy_)
                     {
@@ -411 +401 @@
                 case Action::PROTECT:
                 {
-                    std::string protectName = std::get<1>( this->parsedActionpoints_.back() );
+                    std::string protectName = this->parsedActionpoints_.back().name;
 
                     for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
@@ -437 +427 @@
                 case Action::ATTACK:
                 {
-                    std::string targetName = std::get<1>( this->parsedActionpoints_.back() );
+                    std::string targetName = this->parsedActionpoints_.back().name;
 
                     for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
@@ -443 +433 @@
                         if (CommonController::getName(*itP) == targetName)
                         {
+                            orxout(internal_error) << "Attacking" << endl;
                             this->setTarget (static_cast<ControllableEntity*>(*itP));
                         }
@@ -465 +456 @@
             this->action_ = Action::NONE;
         }
+        orxout(internal_error) << "Executing action " << this->getActionXML() << endl;
     }
     void CommonController::nextActionpoint()

code/branches/campaignHS15/src/orxonox/controllers/CommonController.h

@@ -65 +65 @@
             NONE, FLY, FIGHT, PROTECT, FIGHTALL, ATTACK
         };
+        
     }
+    
+    struct Point {
+        Action::Value action;
+        std::string name;
+        Vector3 position;
+    } ;
+
+
+    
  
 
@@ -171 +181 @@
                 void doFire();
                 void setClosestTarget();
-                ControllableEntity* closestTarget();
+                Pawn* closestTarget();
 
                 bool bShooting_;
@@ -200 +210 @@
                 std::vector<WeakPtr<WorldEntity> > actionpoints_;
                 float squaredaccuracy_;
-                <tuple<Action::Value ,std::string ,Vector3 > > currentActionpoint_;
-                std::vector<tuple<Action::Value ,std::string ,Vector3 > > parsedActionpoints_;
+                Point  currentActionpoint_;
+                std::vector<Point > parsedActionpoints_;
+                void executeActionpoint();
+                void nextActionpoint();
             //----[/Actionpoint information]----
             //----["Private" variables]----

code/branches/campaignHS15/src/orxonox/controllers/DivisionController.cc

@@ -28 +28 @@
 
 #include "DivisionController.h"
-
+#include "infos/PlayerInfo.h"
 
 namespace orxonox
@@ -93 +93 @@
         if (this->action_ != Action::FIGHT && this->action_ != Action::FIGHTALL)
         {
-            if ((this->target_ && CommonController::distance (this->getControllableEntity(), this->target_) > this->attackRange_) ||
-             !this->target_)
-            {
-                ControllableEntity* newTarget = this->closestTarget();
+            if ( (this->target_ && CommonController::distance (this->getControllableEntity(), this->target_) > this->attackRange_) 
+                || !this->target_ )
+            {
+                Pawn* newTarget = this->closestTarget();
                 if ( newTarget && 
-                    CommonController::distance (this->getControllableEntity(), newTarget) < this->attackRange_ )
+                    CommonController::distance (this->getControllableEntity(), static_cast<ControllableEntity*>(newTarget))
+                        <= this->attackRange_ )
                 {
                     // this->backupAction();
                     // this->setAction (Action::FIGHT, newTarget);
-                    this->parsedActionpoints_.push_back(
-                        std::make_tuple (Action::FIGHT, CommonController::getName(newTarget), Vector3::ZERO) );
+                    Point p = { Action::FIGHT, CommonController::getName(newTarget), Vector3::ZERO };
+                    this->parsedActionpoints_.push_back(p);
+                    this->executeActionpoint();
                 }
             }
@@ -113 +115 @@
         if (this->action_ == Action::NONE)
         {
-
-        }
-
-        this->executeActionpoint();
+            this->executeActionpoint();
+        }
+
 
         //this->action_ is what I am actually executing, this->target_ is what I am 
@@ -142 +143 @@
                 else if (this->action_ == Action::FIGHTALL)
                 {
-                    if (newTarget)
+                    if (newTarget && newTarget->getController())
                     {
                         this->setAction (Action::FIGHTALL, newTarget);
@@ -158 +159 @@
                 //----fly in formation if far enough----
                 Vector3 diffVector = this->positionOfTarget_ - this->getControllableEntity()->getWorldPosition();         
+                
+                    
                 if (diffVector.length() > this->attackRange_)
                 {
@@ -198 +201 @@
         else if (this->action_ == Action::FLY)
         {
+
+            if (this->squaredDistanceToTarget() <= this->squaredaccuracy_)
+            {
+                orxout(internal_error) << "arrived";
+                this->nextActionpoint();
+                return;
+            }
             this->setTargetPositionOfWingman();
             this->setTargetPositionOfFollower();
@@ -203 +213 @@
         else if (this->action_ == Action::PROTECT)
         {
+            if (!this->getProtect())
+            {
+                this->nextActionpoint();
+                return;
+            }
            /* if (this->myWingman_)
                 this->myWingman_->setAction (Action::PROTECT, this->getProtect());
@@ -218 +233 @@
             this->setTargetPositionOfWingman();
             this->setTargetPositionOfFollower();
+
         }
         else if (this->action_ == Action::ATTACK)
         {   
-            if (this->hasTarget())
-            {
-                //----fly in formation if far enough----
-                Vector3 diffVector = this->positionOfTarget_ - this->getControllableEntity()->getWorldPosition();         
-                if (diffVector.length() > this->attackRange_)
-                {
-                    this->setTargetPositionOfWingman();
-                    this->setTargetPositionOfFollower();                    
-                }
-                else
-                {
-                    //----wingmans shall support the fire of their leaders----
-                    if (this->myWingman_)
-                    {
-                        this->myWingman_->setAction (this->action_, this->target_);     
-                    }
-                    if (this->myFollower_)
-                    {
-                        this->myFollower_->setAction (this->action_);                                    
-                    }
-
-                }
-                
-            }
-            if (this->hasTarget())
-            {
-                //----choose where to go----
-                this->maneuver();
-                //----fire if you can----
-                this->bShooting_ = this->canFire();                
-            }
+            if (!this->hasTarget())
+            {
+                this->nextActionpoint();
+                return;
+            }
+            //----fly in formation if far enough----
+            Vector3 diffVector = this->positionOfTarget_ - this->getControllableEntity()->getWorldPosition();         
+            if (diffVector.length() > this->attackRange_)
+            {
+                this->setTargetPositionOfWingman();
+                this->setTargetPositionOfFollower();                    
+            }
+            else
+            {
+                //----wingmans shall support the fire of their leaders----
+                if (this->myWingman_)
+                {
+                    this->myWingman_->setAction (this->action_, this->target_);     
+                }
+                if (this->myFollower_)
+                {
+                    this->myFollower_->setAction (this->action_);                                    
+                }
+
+            }
+            
+            //----choose where to go----
+            this->maneuver();
+            //----fire if you can----
+            this->bShooting_ = this->canFire();                
         }