Changeset 10855 for code/branches/campaignHS15/src

Timestamp:

Nov 25, 2015, 1:51:10 PM (9 years ago)

Author:

gania

Message:

introduced loops

Location:

code/branches/campaignHS15/src/orxonox

Files:

• controllers/CommonController.cc (modified) (7 diffs)
• controllers/CommonController.h (modified) (4 diffs)
• controllers/DivisionController.cc (modified) (1 diff)
• worldentities/ActionPoint.cc (modified) (1 diff)
• worldentities/ActionPoint.h (modified) (5 diffs)

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

@@ -69 +69 @@
         this->stopLookingAtTarget();
         this->attackRange_ = 2500;
+        this->bInLoop_ = false;
+        this->bLoop_ = false;
         RegisterObject( CommonController );
     }
@@ -159 +161 @@
         Vector3 position;
         std::string targetName;
+        bool inLoop;
         Point p;
         if (static_cast<Actionpoint*> (actionpoint))
@@ -166 +169 @@
             targetName = ap->getName();
             position = ap->getWorldPosition();
+
+            if (!this->bInLoop_ && ap->getStartLoop())
+            {
+                this->bInLoop_ = true;
+            }
+            if (this->bInLoop_ && ap->getEndLoop())
+            {
+                this->bInLoop_ = false;
+            }
+            inLoop = this->bInLoop_;
 
             Action::Value value;
@@ -183 +196 @@
             else
                 ThrowException( ParseError, std::string( "Attempting to set an unknown Action: '" )+ actionName + "'." );
-            p.action = value; p.name = targetName; p.position = position;
+            p.action = value; p.name = targetName; p.position = position; p.inLoop = inLoop;
             parsedActionpoints_.push_back(p);
         }
         else
         {
-            p.action = Action::FLY; p.name = ""; p.position = actionpoint->getWorldPosition();
+            p.action = Action::FLY; p.name = ""; p.position = actionpoint->getWorldPosition(); p.inLoop = inLoop;
         }
             parsedActionpoints_.push_back(p);
@@ -752 +765 @@
                         <= this->attackRange_ )
                 {
-                    Point p = { Action::FIGHT, this->getName(newTarget), Vector3::ZERO };
+                    Point p = { Action::FIGHT, this->getName(newTarget), Vector3::ZERO, false };
                     this->parsedActionpoints_.push_back(p);
                     this->executeActionpoint();
@@ -768 +781 @@
     void CommonController::executeActionpoint()
     {
-        if (!this->parsedActionpoints_.empty())
-        {
-            this->action_ = this->parsedActionpoints_.back().action;
-
-            switch ( this->action_ )
-            {
-                case Action::FIGHT:
+        if (this->bLoop_)
+        {
+            if (!this->loopActionpoints_.empty())
+            {
+                this->action_ = this->loopActionpoints_.back().action;
+                switch ( this->action_ )
                 {
-                    std::string targetName = this->parsedActionpoints_.back().name;
-                    if (targetName == "")
-                    {
-                        break;
-                    }
-                    for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
-                    {
-                        if (CommonController::getName(*itP) == targetName)
-                        {
-                            this->setTarget (static_cast<ControllableEntity*>(*itP));
+                    case Action::FIGHT:
+                    {
+                        std::string targetName = this->loopActionpoints_.back().name;
+                        if (targetName == "")
+                        {
+                            break;
                         }
-                    }          
-                    break;
+                        for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
+                        {
+                            if (CommonController::getName(*itP) == targetName)
+                            {
+                                this->setTarget (static_cast<ControllableEntity*>(*itP));
+                            }
+                        }          
+                        break;
+                    }
+                    case Action::FLY:
+                    {
+                        this->setTargetPosition( this->loopActionpoints_.back().position );
+                        if (this->squaredDistanceToTarget() <= this->squaredaccuracy_)
+                        {
+                            this->nextActionpoint();
+                            this->executeActionpoint();
+                        }
+                        break;
+                    }
+                    case Action::PROTECT:
+                    {
+                        std::string protectName = this->loopActionpoints_.back().name;
+
+                        for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
+                        {
+                            if (CommonController::getName(*itP) == protectName)
+                            {
+                                this->setProtect (static_cast<ControllableEntity*>(*itP));
+                            }
+                        }
+                        if (!this->getProtect())
+                        {
+                            this->nextActionpoint();
+                            this->executeActionpoint();
+                        }
+                        break;
+                    }
+                    case Action::NONE:
+                    {
+                        break;
+                    }
+                    case Action::FIGHTALL:
+                    {
+                        break;
+                    }
+                    case Action::ATTACK:
+                    {
+                        std::string targetName = this->loopActionpoints_.back().name;
+
+                        for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
+                        {
+                            if (CommonController::getName(*itP) == targetName)
+                            {
+                                this->setTarget (static_cast<ControllableEntity*>(*itP));
+                            }
+                        }
+                        if (!this->hasTarget())
+                        {
+                            this->nextActionpoint();
+                            this->executeActionpoint();
+                        }
+                        break;
+                    }
+                    default:
+                        break;
                 }
-                case Action::FLY:
+            }
+            else
+            {
+                this->bLoop_ = false;
+            }
+        }
+        else
+        {
+            if (!this->parsedActionpoints_.empty())
+            {
+                if (this->parsedActionpoints_.back().inLoop)
                 {
-                    this->setTargetPosition( this->parsedActionpoints_.back().position );
-                    if (this->squaredDistanceToTarget() <= this->squaredaccuracy_)
-                    {
-                        this->nextActionpoint();
-                        this->executeActionpoint();
-                    }
-                    break;
+                    //MOVES all points that are in loop to a loop vector
+                    this->fillLoop();
+                    this->bLoop_ = true;
+                    executeActionpoint();
+                    return;
                 }
-                case Action::PROTECT:
+                this->action_ = this->parsedActionpoints_.back().action;
+                switch ( this->action_ )
                 {
-                    std::string protectName = this->parsedActionpoints_.back().name;
-
-                    for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
-                    {
-                        if (CommonController::getName(*itP) == protectName)
-                        {
-                            this->setProtect (static_cast<ControllableEntity*>(*itP));
+                    case Action::FIGHT:
+                    {
+                        std::string targetName = this->parsedActionpoints_.back().name;
+                        if (targetName == "")
+                        {
+                            break;
                         }
-                    }
-                    if (!this->getProtect())
-                    {
-                        this->nextActionpoint();
-                        this->executeActionpoint();
-                    }
-                    break;
+                        for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
+                        {
+                            if (CommonController::getName(*itP) == targetName)
+                            {
+                                this->setTarget (static_cast<ControllableEntity*>(*itP));
+                            }
+                        }          
+                        break;
+                    }
+                    case Action::FLY:
+                    {
+                        this->setTargetPosition( this->parsedActionpoints_.back().position );
+                        if (this->squaredDistanceToTarget() <= this->squaredaccuracy_)
+                        {
+                            this->nextActionpoint();
+                            this->executeActionpoint();
+                        }
+                        break;
+                    }
+                    case Action::PROTECT:
+                    {
+                        std::string protectName = this->parsedActionpoints_.back().name;
+
+                        for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
+                        {
+                            if (CommonController::getName(*itP) == protectName)
+                            {
+                                this->setProtect (static_cast<ControllableEntity*>(*itP));
+                            }
+                        }
+                        if (!this->getProtect())
+                        {
+                            this->nextActionpoint();
+                            this->executeActionpoint();
+                        }
+                        break;
+                    }
+                    case Action::NONE:
+                    {
+                        break;
+                    }
+                    case Action::FIGHTALL:
+                    {
+                        break;
+                    }
+                    case Action::ATTACK:
+                    {
+                        std::string targetName = this->parsedActionpoints_.back().name;
+
+                        for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
+                        {
+                            if (CommonController::getName(*itP) == targetName)
+                            {
+                                this->setTarget (static_cast<ControllableEntity*>(*itP));
+                            }
+                        }
+                        if (!this->hasTarget())
+                        {
+                            this->nextActionpoint();
+                            this->executeActionpoint();
+                        }
+                        break;
+                    }
+                    default:
+                        break;
                 }
-                case Action::NONE:
-                {
-                    break;
-                }
-                case Action::FIGHTALL:
-                {
-                    break;
-                }
-                case Action::ATTACK:
-                {
-                    std::string targetName = this->parsedActionpoints_.back().name;
-
-                    for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
-                    {
-                        if (CommonController::getName(*itP) == targetName)
-                        {
-                            this->setTarget (static_cast<ControllableEntity*>(*itP));
-                        }
-                    }
-                    if (!this->hasTarget())
-                    {
-                        this->nextActionpoint();
-                        this->executeActionpoint();
-                    }
-                    break;
-                }
-                default:
-                    break;
-            }
-        }
-        else
-        {
-            this->setTarget(0);
-            this->setTargetPosition(this->getControllableEntity()->getWorldPosition());
-            this->action_ = Action::NONE;
-        }
+            }
+            else
+            {
+                this->setTarget(0);
+                this->setTargetPosition(this->getControllableEntity()->getWorldPosition());
+                this->action_ = Action::NONE;
+            }
+        }
+
     }
     void CommonController::stayNearProtect()
@@ -865 +975 @@
     void CommonController::nextActionpoint()
     {
-        if (!this->parsedActionpoints_.empty())
-        {
-            this->parsedActionpoints_.pop_back();
+        if (this->bLoop_)
+        {
+            if (!this->loopActionpoints_.empty())
+            {
+                this->moveBackToTop();
+            }
+        }
+        else
+        {
+            if (!this->parsedActionpoints_.empty())
+            {
+                this->parsedActionpoints_.pop_back();
+            }            
         }
         this->setAction(Action::NONE);
+    }
+    void CommonController::moveBackToTop()
+    {
+        Point temp = loopActionpoints_.back();
+        loopActionpoints_.pop_back();
+        std::reverse (loopActionpoints_.begin(), loopActionpoints_.end());
+        loopActionpoints_.push_back(temp);
+        std::reverse (loopActionpoints_.begin(), loopActionpoints_.end());
+    }
+    void CommonController::fillLoop()
+    {
+        loopActionpoints_.clear();
+        fillLoopReversed();
+        std::reverse (loopActionpoints_.begin(), loopActionpoints_.end());
+    }
+    void CommonController::fillLoopReversed()
+    {
+        if (parsedActionpoints_.back().inLoop)
+        {
+            loopActionpoints_.push_back(parsedActionpoints_.back());
+            parsedActionpoints_.pop_back();
+        }
+        if (parsedActionpoints_.back().inLoop)
+        {
+            fillLoopReversed();
+        }
     }
     void CommonController::action()

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

@@ -74 +74 @@
         std::string name;
         Vector3 position;
+        bool inLoop;
     } ;
 
@@ -202 +203 @@
                 float squaredaccuracy_;
                 std::vector<Point > parsedActionpoints_;
+                std::vector<Point > loopActionpoints_;
 
             //----[/Actionpoint information]----
@@ -207 +209 @@
                 void executeActionpoint();
                 void nextActionpoint();
+                void fillLoop();
+                void fillLoopReversed();
+                void moveBackToTop();
             //----[Actionpoint methods]----
             //----["Private" variables]----
@@ -219 +224 @@
                 int maneuverCounter_;
                 int tolerance_; 
-                bool bFirstTick_;                        
+                bool bFirstTick_; 
+                bool bInLoop_;
+                bool bLoop_;                   
             //----[/"Private" variables]----               
     };

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

@@ -78 +78 @@
     {   
         CommonController::action();
-        
     }
     void DivisionController::stayNearProtect()

code/branches/campaignHS15/src/orxonox/worldentities/ActionPoint.cc

@@ -72 +72 @@
         XMLPortParam( Actionpoint, "protectMe", setProtectMeXML, getProtectMeXML,  xmlelement, mode ).defaultValues(false);
         XMLPortParam( Actionpoint, "fightAll", setFightAllXML, getFightAllXML,  xmlelement, mode ).defaultValues(false);
+        XMLPortParam( Actionpoint, "loopStart", setLoopStart, getLoopStart,  xmlelement, mode ).defaultValues(false);
+        XMLPortParam( Actionpoint, "loopEnd", setLoopEnd, getLoopEnd,  xmlelement, mode ).defaultValues(false);
 
     }

code/branches/campaignHS15/src/orxonox/worldentities/ActionPoint.h

@@ -68 +68 @@
                     inline void setProtectMeXML(bool c)
                     {
-                        this->protectMe_ = c;
+                        this->bProtectMe_ = c;
                     }
                     inline bool getProtectMeXML ()
                     {
-                        return this->protectMe_;
+                        return this->bProtectMe_;
                     }
 
@@ -79 +79 @@
                     inline void setFightAllXML(bool c)
                     {
-                        this->fightAll_ = c;
+                        this->bFightAll_ = c;
                     }
                     inline bool getFightAllXML ()
                     {
-                        return this->fightAll_;
+                        return this->bFightAll_;
                     }
                 //----[/FightAll data]----
@@ -102 +102 @@
                         return "";
                 }
+                void setLoopStart(bool value)
+                {
+                    this->bLoopStart_ = value;
+                }
+                void setLoopEnd (bool value)
+                {
+                    this->bLoopEnd_ = value;
+                }
             //----["Waypoints" data]----
                 void setTargetPosition(const Vector3& target);
@@ -107 +115 @@
             //----[/"Waypoints" data]----
 
+            bool getLoopStart()
+            {
+                return this->bLoopStart_;
+            }
+            bool getLoopEnd();
+            {
+                return this->bLoopEnd_;
+            }
         private:
             
@@ -115 +131 @@
             WeakPtr<ControllableEntity> enemy_;
 
-            bool protectMe_;
-            bool fightAll_;
+            bool bLoopStart_;
+            bool bLoopEnd_;
+            bool bProtectMe_;
+            bool bFightAll_;
             Vector3 targetPosition_;
     };