Changeset 10910 for code/branches/campaignHS15/src/orxonox

Timestamp:

Dec 1, 2015, 4:33:46 PM (9 years ago)

Author:

gania

Message:

didn'change any behaviour yet, but implemented some methods that I don't use yet

Location:

code/branches/campaignHS15/src/orxonox/controllers

Files:

• ActionpointController.cc (modified) (1 diff)
• ActionpointController.h (modified) (2 diffs)

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

@@ -143 +143 @@
         SUPER(ActionpointController, tick, dt);
     }
+    std::pair <ControllableEntity*, ControllableEntity*> ActionpointController::closestTargets()
+    {
+        WeakPtr<ControllableEntity> firstTarget, secondTarget, tempTarget;
+        float firstDistance = std::numeric_limits<float>::infinity(), secondDistance = std::numeric_limits<float>::infinity(), tempDistance = 0;
+        Gametype* gt = this->getGametype();
+        for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
+        {
+            tempTarget = static_cast<ControllableEntity*>(*itP);
+            if (CommonController::sameTeam (this->getControllableEntity(), tempTarget, gt))
+                continue;
+
+            tempDistance = CommonController::distance (*itP, this->getControllableEntity());
+            if (tempDistance < firstDistance)
+            {
+                secondDistance = firstDistance;
+                secondTarget = firstTarget;
+
+                firstDistance = tempDistance;
+                firstTarget = tempTarget;
+            }
+            else if (tempDistance < secondDistance)
+            {
+                secondDistance = tempDistance;
+                secondTarget = tempTarget;
+            }
+        }
+        return std::make_pair (firstTarget, secondTarget);  
+    }
+
+    //patrol can only be called by divisionController or others if they don't have a leader
+    //searches for closest enemy and sets target to it. If wasn't fighting, pushes Action::FIGHT on a stack.
+    //patrol gets called constantly either if this is fighting or if this->bDefaultPatrol_ is set to true via XML
+    bool ActionpointController::patrol()
+    {
+        std::pair <ControllableEntity*, ControllableEntity*> newTargets = this->closestTargets();
+        if (!newTargets.first)
+            return false;
+        ControllableEntity* newTarget = newTargets.first;
+
+        float distance = CommonController::distance (this->getControllableEntity(), newTarget);
+        if (distance < this->attackRange_ && distance < CommonController::distance(this->getControllableEntity(), this->target_))
+        {
+            this->setTarget (newTarget);
+
+            if (this->getIdentifier()->getName() == "DivisionController")
+            {
+                if (!newTargets.second)
+                {
+                    if (this->myFollower_)
+                        this->myFollower_->setTarget(newTargets.first);
+                }
+                else
+                {
+                    if (this->myFollower_ && CommonController::distance(this->getControllableEntity(), newTargets.second) < this->attackRange_ + 600.0f)
+                        this->myFollower_->setTarget(newTargets.second);
+                    else if (this->myFollower_)
+                        this->myFollower_->setTarget(newTargets.first);
+                }
+            }
+            if (this->action_ != Action::FIGHT && this->action_ != Action::FIGHTALL)
+            {
+                this->bPatrolling_ = true;
+                if (this->bLoop_)
+                {
+                    Point p = { Action::FIGHT, "", Vector3::ZERO, true };
+                    this->loopActionpoints_.push_back(p);
+                    this->executeActionpoint();
+                }
+                else
+                {
+                    Point p = { Action::FIGHT, "", Vector3::ZERO, false };
+                    this->parsedActionpoints_.push_back(p);
+                    this->executeActionpoint();   
+                }                    
+            }
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+    //checks if state is still to be executed and makes a transition otherwise.
+    //if this->bDefaultPatrol_ == true, patrols area for enemies and, if not fighting, pushes a state with action = FIGHT
+    void ActionpointController::stateMachine()
+    {
+        //Check if calculations needed
+        if (!this->getControllableEntity() || !orxonox_cast<Pawn*> (this->getControllableEntity()) || !this->isActive())
+            return;
+
+        //state NONE means that either previous state finished executing and next state is to be fetched or no states are left to execute
+        //NONE is never on a stack -> it is only a transition state saved in a variable
+        if (this->action_ == Action::NONE || this->bTakenOver_)
+        {
+            //no actionpoints a.k.a. states left to execute
+            if (this->parsedActionpoints_.empty() && this->loopActionpoints_.empty())
+            {
+                //default action is fighting
+                if (this->bDefaultFightAll_)
+                {
+                    //make state
+                    Point p = { Action::FIGHTALL, "", Vector3::ZERO, false };
+                    //push it on the stack
+                    this->parsedActionpoints_.push_back (p);
+                }
+                //default action is nothing
+                else
+                {
+                    this->bActive_ = false;
+                    return;
+                }     
+            }
+            //switch to the new state
+            this->executeActionpoint(); 
+            this->bTakenOver_ = false; 
+        }
+        if (this->action_ == Action::FIGHTALL)
+        {
+            if (!this->hasTarget())
+            {
+                ControllableEntity* newTarget = this->closestTarget();    
+                if (newTarget)
+                {
+                    this->setTarget (newTarget);
+                }
+                else
+                {
+                    this->nextActionpoint();
+                    this->executeActionpoint();
+                }
+            }
+            else
+            {
+                bool b = this->patrol();
+            }
+
+        }
+        if (this->action_ == Action::FIGHT)
+        {
+            if (!this->hasTarget() )
+            {
+                if (!this->patrol())
+                {
+                    if (this->bPatrolling_)
+                    {
+                        if (this->bLoop_)
+                        {
+                            if (!this->loopActionpoints_.empty())
+                            {
+                                this->loopActionpoints_.pop_back();
+                            }
+                        }
+                        else
+                        {
+                            if (!this->parsedActionpoints_.empty())
+                            {
+                                this->parsedActionpoints_.pop_back();
+                            }            
+                        }
+                        this->setAction(Action::NONE);
+                        this->bHasTargetPosition_ = false;
+                        this->bPatrolling_ = false;
+                    }
+                    else
+                    {
+                        this->nextActionpoint();
+                    }
+                    this->executeActionpoint();
+                }
+            }
+            else if (this->hasTarget())
+            {
+                if (CommonController::distance (this->getControllableEntity(), this->target_) > this->attackRange_)
+                {
+                    this->setTarget(0);
+                    this->stateMachine();
+                }
+            }
+        }
+        if (this->action_ == Action::FLY)
+        {
+            if (this->squaredDistanceToTarget() <= this->squaredaccuracy_)
+            {
+                this->nextActionpoint();   
+                this->executeActionpoint();
+            }
+            else if (this->bDefaultPatrol_)
+            {
+                bool b = this->patrol();
+            }
+        }
+        if (this->action_ == Action::PROTECT)
+        {
+            if (!this->getProtect())
+            {
+                this->nextActionpoint();
+                this->executeActionpoint(); 
+            }
+            else
+            {
+                this->stayNearProtect();
+            }
+            if (this->bDefaultPatrol_)
+            {
+                bool b = this->patrol();
+            }
+        }
+        if (this->action_ == Action::ATTACK)
+        {   
+            if (!this->hasTarget())
+            {
+                this->nextActionpoint();
+                this->executeActionpoint();
+            }
+            if (this->bDefaultPatrol_)
+            {
+                bool b = this->patrol();
+            }
+        }
+    }
+
+
+
     void ActionpointController::action()
     {

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

@@ -180 +180 @@
             virtual bool hasFollower()
                 { return true; }
+            void stateMachine();
+            bool patrol();
+            std::pair <ControllableEntity*, ControllableEntity*> closestTargets();
 
         protected:
@@ -239 +242 @@
                 bool bActionCalled_;
                 bool bManeuverCalled_;
+                bool bDefaultFightAll_;
+                bool bActive_;
+                bool bPatrolling_;
+                bool bDefaultPatrol_;
 
         private: