Changeset 10793 for code/branches/AI_HS15/src/orxonox/controllers

Timestamp:

Nov 10, 2015, 4:37:34 PM (9 years ago)

Author:

gania

Message:

added choose maneuver type functionality

Location:

code/branches/AI_HS15/src/orxonox/controllers

Files:

• CommonController.cc (modified) (4 diffs)
• CommonController.h (modified) (3 diffs)
• DivisionController.cc (modified) (2 diffs)
• FleetController.cc (modified) (1 diff)

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

@@ -55 +55 @@
         this->executingMoveToPoint_ = false;
 
+        this->maneuverType_ = ManeuverType::NONE;
         RegisterObject(CommonController);
     }
@@ -116 +117 @@
         }
     }
-
+    void CommonController::chooseManeuverType()
+    {
+
+        if (this->target_ && this->bHasPositionOfTarget_ && this->getControllableEntity())
+        {
+            Vector3 diffVector = this->positionOfTarget_ - this->getControllableEntity()->getWorldPosition();
+            Vector3 myForwardVector = this->getControllableEntity()->getOrientation() * WorldEntity::FRONT;
+            float myDotProduct = diffVector.dotProduct(myForwardVector);
+
+            Vector3 opponentForwardVector = this->target_->getOrientation() * WorldEntity::FRONT;
+            float opponentDotProduct = diffVector.dotProduct(opponentForwardVector);            
+
+
+            switch ((myDotProduct > 0) - (myDotProduct < 0))
+            {
+                case 1:
+                {
+                    switch ((opponentDotProduct > 0) - (opponentDotProduct < 0))
+                    {
+                        case 1:
+                        {
+                            this->maneuverType_ = ManeuverType::OFFENSIVE;
+                            break;
+                        }
+                        case 0:
+                        {
+                            this->maneuverType_ = ManeuverType::OFFENSIVE;
+                            break;
+                        }
+                        case -1:
+                        {
+                            this->maneuverType_ = ManeuverType::NEUTRAL;
+                            break;
+                        }
+                    }
+                    break;
+                }
+                case 0:
+                {
+                    switch ((opponentDotProduct > 0) - (opponentDotProduct < 0))
+                    {
+                        case 1:
+                        {
+                            this->maneuverType_ = ManeuverType::OFFENSIVE;
+                            break;
+                        }
+                        case 0:
+                        {
+                            this->maneuverType_ = ManeuverType::NEUTRAL;
+                            break;
+                        }
+                        case -1:
+                        {
+                            this->maneuverType_ = ManeuverType::DEFENCIVE;
+                            break;
+                        }
+                    }
+
+                    break;
+                }
+                case -1:
+                {
+                    switch ((opponentDotProduct > 0) - (opponentDotProduct < 0))
+                    {
+                        case 1:
+                        {
+                            this->maneuverType_ = ManeuverType::NEUTRAL;
+                            break;
+                        }
+                        case 0:
+                        {
+                            this->maneuverType_ = ManeuverType::DEFENCIVE;
+                            break;
+                        }
+                        case -1:
+                        {
+                            this->maneuverType_ = ManeuverType::DEFENCIVE;
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        if (this->getControllableEntity() && !this->target_)
+        {
+            this->maneuverType_ = ManeuverType::NONE;
+        }
+        orxout (internal_error) << "ManeuverType = " << this->maneuverType_ << endl;
+    }
     bool CommonController::setWingman (CommonController* wingman)
     {
@@ -130 +220 @@
         this->target_ = target;
         orxout (internal_error) << " TARGET SET " << endl;
-        if (target)
-            this->targetPosition_ = target->getPosition();
-    }
-
-
+        
+        if (this->target_ )
+        {
+            this->setPositionOfTarget(target_->getWorldPosition());
+
+        }
+    }
+    bool CommonController::hasTarget()
+    {
+        if (this->target_)
+            return true;
+        return false;
+    }
+    void CommonController::setPositionOfTarget(const Vector3& target)
+    {
+        this->positionOfTarget_ = target;
+        this->bHasPositionOfTarget_ = true;
+    }
+    void CommonController::setOrientationOfTarget(const Quaternion& orient)
+    {
+        this->orientationOfTarget_=orient;
+        this->bHasOrientationOfTarget_=true;
+    }
 
     void CommonController::setTargetPosition(const Vector3& target)
@@ -370 +478 @@
 
         Pawn* pawn = orxonox_cast<Pawn*>(this->getControllableEntity());
+
         if (pawn)
-            pawn->setAimPosition(this->getControllableEntity()->getWorldPosition() + 4000*(this->getControllableEntity()->getOrientation() * WorldEntity::FRONT));
+            //pawn->setAimPosition(this->getControllableEntity()->getWorldPosition() + 4000*(this->getControllableEntity()->getOrientation() * WorldEntity::FRONT));
+            pawn->setAimPosition(this->targetPosition_);
     
         this->getControllableEntity()->fire(0);

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

@@ -111 +111 @@
 
             void setTarget(ControllableEntity* target);
-            
+            bool hasTarget();
             void setTargetOrientation(const Quaternion& orient);
             void setTargetOrientation(ControllableEntity* target);
@@ -153 +153 @@
             Quaternion targetOrientation_;
 
-
+            void setPositionOfTarget(const Vector3& target);
+            void setOrientationOfTarget(const Quaternion& orient);
             bool bHasPositionOfTarget_;
             Vector3 positionOfTarget_;
@@ -165 +166 @@
 
 
+            void chooseManeuverType();
 
             FormationMode::Value formationMode_;

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

@@ -57 +57 @@
     void DivisionController::tick(float dt)
     {
+        if (this->target_ )
+        {
+            this->setPositionOfTarget(target_->getWorldPosition());
+
+        }
         /*if (this->target_)
         {
@@ -82 +87 @@
         Vector3* pos = new Vector3(4000,1000,2000);
         this->setTargetPosition(*pos);*/
-
-        setTargetPositionOfFollower();
-        setTargetPositionOfWingman();
+       
+/*        if (!this->target_)
+        {
+
+            for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+            {
+                if (this->getControllableEntity()->getTeam() == static_cast<ControllableEntity*>(*it)->getTeam())
+                    continue;
+
+               
+
+                if (static_cast<ControllableEntity*>(*it) != this->getControllableEntity())
+                {
+                    this->setTarget(*it);
+                }
+            }
+        }*/
+        this->chooseManeuverType();
+        switch (this->maneuverType_)
+        {
+            case ManeuverType::NONE:
+            {
+                setTargetPositionOfFollower();
+                setTargetPositionOfWingman();
+                break;
+            }
+            case ManeuverType::DEFENSIVE:
+            {
+                this->gunsD();
+            }
+            case ManeuverType::OFFENSIVE:
+            {
+                this->attack();
+            }
+        }
+       
         if (!executingMoveToPoint_)
         {

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

@@ -80 +80 @@
             } 
         }*/
+        for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
+        {
+            if (this->getControllableEntity()->getTeam() == static_cast<ControllableEntity*>(*itP)->getTeam())
+                continue;           
+
+            for(std::vector<WeakPtr<DivisionController> >::iterator it = divisions_.begin(); it != divisions_.end(); ++it) 
+            {
+                if (static_cast<ControllableEntity*>(*itP) != (*it)->getControllableEntity() && !(*it)->hasTarget())
+                {
+                    (*it)->setTarget(*itP);
+                }
+                
+            }   
+           
+        }
 
     }