Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 10864


Ignore:
Timestamp:
Nov 26, 2015, 9:08:11 AM (9 years ago)
Author:
gania
Message:

split up some code

Location:
code/branches/campaignHS15/src/orxonox/controllers
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

  • code/branches/campaignHS15/src/orxonox/controllers/CMakeLists.txt

    r10834 r10864  
    1616  SectionController.cc
    1717  CommonController.cc
     18  ActionpointController.cc
    1819)

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

    r10863 r10864  
    6868    CommonController::CommonController( Context* context ): Controller( context )
    6969    {
    70         this->squaredaccuracy_ = 2500;
    7170        this->bFirstTick_ = true;
    7271        this->tolerance_ = 50;
    73         this->action_ = Action::NONE;
    7472        this->stopLookingAtTarget();
    7573        this->attackRange_ = 2500;
    76         this->bInLoop_ = false;
    77         this->bLoop_ = false;
    78         this->bEndLoop_ = false;
    79         this->parsedActionpoints_.clear();
    8074        RegisterObject( CommonController );
    81         this->bTakenOver_ = false;
     75
    8276    }
    8377    CommonController::~CommonController()
    8478    {
    85         parsedActionpoints_.clear();
    86         actionpoints_.clear();
     79       
    8780    }
    8881    void CommonController::tick(float dt)
    8982    {
    90         if (this->bHasTargetPosition_)
    91         {
    92             this->moveToTargetPosition(dt);
    93         }
    94         else if (this->bLookAtTarget_)
    95         {
    96             this->lookAtTarget(dt);
    97         }
    98         if (bShooting_)
    99         {
    100             this->doFire();
    101         }
    102         if (this->bFirstTick_)
    103         {
    104             std::reverse(parsedActionpoints_.begin(), parsedActionpoints_.end());
    105             std::reverse(actionpoints_.begin(), actionpoints_.end());
    106             if (this->parsedActionpoints_.empty())
    107             {
    108                 this->action_ = Action::FIGHTALL;
    109             }
    110         }
    111         if (this->bFirstTick_)
    112             this->bFirstTick_ = false;
     83       
    11384        SUPER(CommonController, tick, dt);
    11485    }
    … …  
    12293        SUPER( CommonController, XMLPort, xmlelement, mode );
    12394        XMLPortParam( CommonController, "formationMode", setFormationModeXML, getFormationModeXML,  xmlelement, mode );
    124         XMLPortObject(CommonController, WorldEntity, "actionpoints", addActionpoint, getActionpoint,  xmlelement, mode);
    12595    }
    12696    void CommonController::setFormationModeXML( std::string val )
    … …  
    169139        return this->rank_;
    170140    }
    171     void CommonController::addActionpoint(WorldEntity* actionpoint)
    172     {
    173         std::string actionName;
    174         Vector3 position;
    175         std::string targetName;
    176         bool inLoop = false;
    177         Point p;
    178         if (static_cast<Actionpoint*> (actionpoint))
    179         {
    180             Actionpoint* ap = static_cast<Actionpoint*> (actionpoint);
    181             actionName = ap->getActionXML();
    182             targetName = ap->getName();
    183             position = ap->getWorldPosition();
    184 
    185             if (this->bEndLoop_)
    186             {
    187                 this->bInLoop_ = false;
    188             }
    189             if (!this->bInLoop_ && ap->getLoopStart())
    190             {
    191                 this->bInLoop_ = true;
    192             }
    193             if (this->bInLoop_ && ap->getLoopEnd())
    194             {
    195                 this->bEndLoop_ = true;
    196             }
    197             inLoop = this->bInLoop_;
    198 
    199             Action::Value value;
    200            
    201             if ( actionName == "FIGHT" )
    202             { value = Action::FIGHT; }
    203             else if ( actionName == "FLY" )
    204             { value = Action::FLY; }
    205             else if ( actionName == "PROTECT" )
    206             { value = Action::PROTECT; }
    207             else if ( actionName == "NONE" )
    208             { value = Action::NONE; }
    209             else if ( actionName == "FIGHTALL" )
    210             { value = Action::FIGHTALL; }
    211             else if ( actionName == "ATTACK" )
    212             { value = Action::ATTACK; }
    213             else
    214                 ThrowException( ParseError, std::string( "Attempting to set an unknown Action: '" )+ actionName + "'." );
    215             p.action = value; p.name = targetName; p.position = position; p.inLoop = inLoop;
    216         }
    217         else
    218         {
    219             p.action = Action::FLY; p.name = ""; p.position = actionpoint->getWorldPosition(); p.inLoop = inLoop;
    220         }
    221             parsedActionpoints_.push_back(p);
    222             this->actionpoints_.push_back(actionpoint);
    223     }
    224     WorldEntity* CommonController::getActionpoint(unsigned int index) const
    225     {
    226         if (index < this->actionpoints_.size())
    227             return this->actionpoints_[index];
    228         else
    229             return 0;
    230     }
    231 
     141   
    232142    //------------------------------------------------------------------------------
    233143    //-------------------------------World interaction------------------------------
    … …  
    249159        return this->target_;
    250160    }
    251     Action::Value CommonController::getAction ()
    252     {
    253         return this->action_;
    254     }
    255     std::string CommonController::getActionName()
    256     {
    257         switch ( this->action_ )
    258         {
    259             case Action::FIGHT:
    260             { return "FIGHT"; break; }
    261             case Action::FLY:
    262             { return "FLY"; break; }
    263             case Action::PROTECT:
    264             { return "PROTECT"; break; }
    265             case Action::NONE:
    266             { return "NONE"; break; }
    267             case Action::FIGHTALL:
    268             { return "FIGHTALL"; break; }
    269             case Action::ATTACK:
    270             { return "ATTACK"; break; }
    271             default:
    272                 return "NONE";
    273                 break;
    274         }
    275     }
    276     void CommonController::setAction (Action::Value action)
    277     {
    278         this->action_ = action;
    279     }
    280     void CommonController::setAction (Action::Value action, ControllableEntity* target)
    281     {
    282         this->action_ = action;
    283         if (action == Action::FIGHT || action == Action::FIGHTALL || action == Action::ATTACK)
    284         {   
    285             if (target)
    286                 this->setTarget (target);
    287         }
    288         else if (action == Action::PROTECT)
    289         {
    290             if (target)
    291                 this->setProtect (target);
    292         }
    293     }
    294     void CommonController::setAction (Action::Value action, const Vector3& target)
    295     {
    296         this->action_ = action;
    297         if (action == Action::FLY)
    298         {
    299             this->setTargetPosition (target);
    300         }
    301     }
    302     void CommonController::setAction (Action::Value action, const Vector3& target,  const Quaternion& orient )
    303     {
    304         this->action_ = action;
    305         if (action == Action::FLY)
    306         {
    307             this->setTargetPosition (target);
    308             this->setTargetOrientation (orient);
    309         } 
    310     }
     161 
    311162
    312163    //------------------------------------------------------------------------------
    … …  
    603454        this->bHasOrientationOfTarget_=true;
    604455    }
    605     void CommonController::setProtect (ControllableEntity* protect)
    606     {
    607         this->protect_ = protect;
    608     }
    609     ControllableEntity* CommonController::getProtect ()
    610     {
    611         return this->protect_;
    612     }
     456   
    613457    void CommonController::maneuver()
    614458    {
    … …  
    739583        this->getControllableEntity() ->fire( 0 );
    740584    }
    741     void CommonController::setClosestTarget()
    742     {
    743         this->setTarget (static_cast<ControllableEntity*>( closestTarget() ) );
    744     }
    745     Pawn* CommonController::closestTarget()
    746     {
    747         if (!this->getControllableEntity())
    748             return 0;
    749 
    750         Pawn* closestTarget = 0;
    751         float minDistance =  std::numeric_limits<float>::infinity();
    752         Gametype* gt = this->getGametype();
    753         for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
    754         {
    755             if ( CommonController::sameTeam (this->getControllableEntity(), static_cast<ControllableEntity*>(*itP), gt) )
    756                 continue;
    757 
    758             float distance = CommonController::distance (*itP, this->getControllableEntity());
    759             if (distance < minDistance)
    760             {
    761                 closestTarget = *itP;
    762                 minDistance = distance;
    763             }
    764         }
    765         if (closestTarget)
    766         {
    767            return closestTarget;
    768         }
    769         return 0; 
    770     }
    771     void CommonController::startAttackingEnemiesThatAreClose()
    772     {
    773         if (this->action_ != Action::FIGHT && this->action_ != Action::FIGHTALL)
    774         {
    775             if ( (this->target_ && this->distance (this->getControllableEntity(), this->target_) > this->attackRange_)
    776                 || !this->target_ )
    777             {
    778                 Pawn* newTarget = this->closestTarget();
    779                 if ( newTarget &&
    780                     this->distance (this->getControllableEntity(), static_cast<ControllableEntity*>(newTarget))
    781                         <= this->attackRange_ )
    782                 {
    783                     Point p = { Action::FIGHT, this->getName(newTarget), Vector3::ZERO, false };
    784                     this->parsedActionpoints_.push_back(p);
    785                     this->executeActionpoint();
    786                 }
    787             }
    788         }
    789     }
    790 
    791     //------------------------------------------------------------------------------
    792     //------------------------------Actionpoint methods-----------------------------
    793     //------------------------------------------------------------------------------
    794 
    795     //POST: this starts doing what was asked by the last element of parsedActionpoints_,
    796     //if last element was failed to be parsed, next element will be executed.
    797     void CommonController::executeActionpoint()
    798     {
    799         if (this->bLoop_)
    800         {
    801             if (!this->loopActionpoints_.empty())
    802             {
    803                 this->action_ = this->loopActionpoints_.back().action;
    804                 switch ( this->action_ )
    805                 {
    806                     case Action::FIGHT:
    807                     {
    808                         std::string targetName = this->loopActionpoints_.back().name;
    809                         if (targetName == "")
    810                         {
    811                             break;
    812                         }
    813                         for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
    814                         {
    815                             if (CommonController::getName(*itP) == targetName)
    816                             {
    817                                 this->setTarget (static_cast<ControllableEntity*>(*itP));
    818                             }
    819                         }         
    820                         break;
    821                     }
    822                     case Action::FLY:
    823                     {
    824                         this->setTargetPosition( this->loopActionpoints_.back().position );
    825                         if (this->squaredDistanceToTarget() <= this->squaredaccuracy_)
    826                         {
    827                             this->nextActionpoint();
    828                             this->executeActionpoint();
    829                         }
    830                         break;
    831                     }
    832                     case Action::PROTECT:
    833                     {
    834                         std::string protectName = this->loopActionpoints_.back().name;
    835                         if (protectName == "reservedKeyword:human")
    836                         {
    837                             for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
    838                             {
    839                                 if (orxonox_cast<ControllableEntity*>(*itP) && ((*itP)->getController()) && orxonox_cast <NewHumanController*> ((*itP)->getController()))
    840                                 {
    841                                     this->setProtect (static_cast<ControllableEntity*>(*itP));
    842                                 }
    843                             }
    844                         }
    845                         else
    846                         {
    847                             for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
    848                             {
    849                                 if (CommonController::getName(*itP) == protectName)
    850                                 {
    851                                     this->setProtect (static_cast<ControllableEntity*>(*itP));
    852                                 }
    853                             }                           
    854                         }
    855                         if (!this->getProtect())
    856                         {
    857                             this->nextActionpoint();
    858                             this->executeActionpoint();
    859                         }
    860                         break;
    861                     }
    862                     case Action::NONE:
    863                     {
    864                         break;
    865                     }
    866                     case Action::FIGHTALL:
    867                     {
    868                         break;
    869                     }
    870                     case Action::ATTACK:
    871                     {
    872                         std::string targetName = this->loopActionpoints_.back().name;
    873 
    874                         for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
    875                         {
    876                             if (CommonController::getName(*itP) == targetName)
    877                             {
    878                                 this->setTarget (static_cast<ControllableEntity*>(*itP));
    879                             }
    880                         }
    881                         if (!this->hasTarget())
    882                         {
    883                             this->nextActionpoint();
    884                             this->executeActionpoint();
    885                         }
    886                         break;
    887                     }
    888                     default:
    889                         break;
    890                 }
    891             }
    892             else
    893             {
    894                 this->bLoop_ = false;
    895             }
    896         }
    897         else
    898         {
    899             if (!this->parsedActionpoints_.empty())
    900             {
    901                 if (this->parsedActionpoints_.back().inLoop)
    902                 {
    903                     //MOVES all points that are in loop to a loop vector
    904                     this->fillLoop();
    905                     this->bLoop_ = true;
    906                     executeActionpoint();
    907                     return;
    908                 }
    909                 this->action_ = this->parsedActionpoints_.back().action;
    910                 switch ( this->action_ )
    911                 {
    912                     case Action::FIGHT:
    913                     {
    914                         std::string targetName = this->parsedActionpoints_.back().name;
    915                         if (targetName == "")
    916                         {
    917                             break;
    918                         }
    919                         for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
    920                         {
    921                             if (CommonController::getName(*itP) == targetName)
    922                             {
    923                                 this->setTarget (static_cast<ControllableEntity*>(*itP));
    924                             }
    925                         }         
    926                         break;
    927                     }
    928                     case Action::FLY:
    929                     {
    930                         this->setTargetPosition( this->parsedActionpoints_.back().position );
    931                         if (this->squaredDistanceToTarget() <= this->squaredaccuracy_)
    932                         {
    933                             this->nextActionpoint();
    934                             this->executeActionpoint();
    935                         }
    936                         break;
    937                     }
    938                     case Action::PROTECT:
    939                     {
    940                        
    941                         std::string protectName = this->parsedActionpoints_.back().name;
    942                         if (protectName == "reservedKeyword:human")
    943                         {
    944                             for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
    945                             {
    946                                 if (orxonox_cast<ControllableEntity*>(*itP) && ((*itP)->getController()) && orxonox_cast <NewHumanController*> ((*itP)->getController()))
    947                                 {
    948                                     this->setProtect (static_cast<ControllableEntity*>(*itP));
    949                                 }
    950                             }
    951                         }
    952                         else
    953                         {
    954                             for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
    955                             {
    956                                 if (CommonController::getName(*itP) == protectName)
    957                                 {
    958                                     this->setProtect (static_cast<ControllableEntity*>(*itP));
    959                                 }
    960                             }                           
    961                         }
    962                         if (!this->getProtect())
    963                         {
    964                             this->nextActionpoint();
    965                             this->executeActionpoint();
    966                         }
    967                         break;
    968                     }
    969                     case Action::NONE:
    970                     {
    971                         break;
    972                     }
    973                     case Action::FIGHTALL:
    974                     {
    975                         break;
    976                     }
    977                     case Action::ATTACK:
    978                     {
    979                         std::string targetName = this->parsedActionpoints_.back().name;
    980 
    981                         for (ObjectList<Pawn>::iterator itP = ObjectList<Pawn>::begin(); itP; ++itP)
    982                         {
    983                             if (CommonController::getName(*itP) == targetName)
    984                             {
    985                                 this->setTarget (static_cast<ControllableEntity*>(*itP));
    986                             }
    987                         }
    988                         if (!this->hasTarget())
    989                         {
    990                             this->nextActionpoint();
    991                             this->executeActionpoint();
    992                         }
    993                         break;
    994                     }
    995                     default:
    996                         break;
    997                 }
    998             }
    999             else
    1000             {
    1001                 this->setTarget(0);
    1002                 this->setTargetPosition(this->getControllableEntity()->getWorldPosition());
    1003                 this->action_ = Action::NONE;
    1004             }
    1005         }
    1006 
    1007     }
    1008     void CommonController::stayNearProtect()
    1009     {
    1010         Vector3* targetRelativePosition;
    1011         targetRelativePosition = new Vector3 (0, 300, 300); 
    1012         Vector3 targetAbsolutePosition = ((this->getProtect()->getWorldPosition()) +
    1013             (this->getProtect()->getWorldOrientation()* (*targetRelativePosition)));
    1014         this->setTargetPosition(targetAbsolutePosition);
    1015     }
    1016     void CommonController::nextActionpoint()
    1017     {
    1018         if (!this || !this->getControllableEntity())
    1019             return;
    1020         if (this->bLoop_)
    1021         {
    1022             if (!this->loopActionpoints_.empty())
    1023             {
    1024                 this->moveBackToTop();
    1025             }
    1026         }
    1027         else
    1028         {
    1029             if (!this->parsedActionpoints_.empty())
    1030             {
    1031                 this->parsedActionpoints_.pop_back();
    1032             }           
    1033         }
    1034         this->setAction(Action::NONE);
    1035     }
    1036     void CommonController::moveBackToTop()
    1037     {
    1038         Point temp = loopActionpoints_.back();
    1039         loopActionpoints_.pop_back();
    1040         std::reverse (loopActionpoints_.begin(), loopActionpoints_.end());
    1041         loopActionpoints_.push_back(temp);
    1042         std::reverse (loopActionpoints_.begin(), loopActionpoints_.end());
    1043     }
    1044     void CommonController::fillLoop()
    1045     {
    1046         loopActionpoints_.clear();
    1047         fillLoopReversed();
    1048         std::reverse (loopActionpoints_.begin(), loopActionpoints_.end());
    1049     }
    1050     void CommonController::fillLoopReversed()
    1051     {
    1052         if (parsedActionpoints_.back().inLoop)
    1053         {
    1054             loopActionpoints_.push_back(parsedActionpoints_.back());
    1055             parsedActionpoints_.pop_back();
    1056         }
    1057         if (parsedActionpoints_.back().inLoop)
    1058         {
    1059             fillLoopReversed();
    1060         }
    1061     }
    1062     void CommonController::action()
    1063     {
    1064         if (!this || !this->getControllableEntity())
    1065             return;
    1066         // orxout (internal_error) << "Size of actions is " << this->parsedActionpoints_.size() << endl;
    1067         this->startAttackingEnemiesThatAreClose();
    1068         //No action -> pop one from stack
    1069         if (this->action_ == Action::NONE || this->bTakenOver_)
    1070         {
    1071             if (this->parsedActionpoints_.empty() && this->loopActionpoints_.empty())
    1072             {
    1073                 Point p = { Action::FIGHTALL, "", Vector3::ZERO, false };
    1074                 this->parsedActionpoints_.push_back (p);
    1075             }
    1076             this->executeActionpoint();
    1077             this->bTakenOver_ = false;
    1078         }
    1079         //Action fightall -> fight till nobody alive
    1080         if (this->action_ == Action::FIGHTALL)
    1081         {
    1082             if (!this->hasTarget())
    1083             {
    1084                 //----find a target----
    1085                 ControllableEntity* newTarget = this->closestTarget();   
    1086                 if (newTarget)
    1087                 {
    1088                     this->setAction (Action::FIGHTALL, newTarget);
    1089                 }
    1090                 else
    1091                 {
    1092                     this->nextActionpoint();
    1093                     return;
    1094                 }
    1095             }
    1096             else if (this->hasTarget())
    1097             {
    1098 
    1099             }
    1100         }
    1101         //Action fight -> fight as long as enemies in range
    1102         else if (this->action_ == Action::FIGHT)
    1103         {
    1104             if (!this->hasTarget())
    1105             {
    1106                 //----find a target----
    1107                 ControllableEntity* newTarget = this->closestTarget();   
    1108                 if (newTarget &&
    1109                         CommonController::distance (this->getControllableEntity(), newTarget) < this->attackRange_)
    1110                 {
    1111                     this->setAction (Action::FIGHT, newTarget);
    1112                 }
    1113                 else
    1114                 {
    1115                     this->nextActionpoint();
    1116                     return;
    1117                 }
    1118             }
    1119             else if (this->hasTarget())
    1120             {
    1121                 //----fly in formation if far enough----
    1122                 Vector3 diffVector = this->positionOfTarget_ - this->getControllableEntity()->getWorldPosition();         
    1123                    
    1124                 if (diffVector.length() > this->attackRange_)
    1125                 {
    1126                     ControllableEntity* newTarget = this->closestTarget();
    1127                    
    1128                     if (newTarget &&
    1129                         CommonController::distance (this->getControllableEntity(), newTarget) < this->attackRange_)
    1130                     {
    1131                         this->setAction (Action::FIGHT, newTarget);
    1132                     }
    1133                     else
    1134                     {
    1135                         this->nextActionpoint();
    1136                         return;
    1137                     }
    1138                 }
    1139             }
    1140         }
    1141         else if (this->action_ == Action::FLY)
    1142         {
    1143             if (this->squaredDistanceToTarget() <= this->squaredaccuracy_)
    1144             {
    1145                 this->nextActionpoint();   
    1146                 return;
    1147             }
    1148         }
    1149         else if (this->action_ == Action::PROTECT)
    1150         {
    1151             if (!this->getProtect())
    1152             {
    1153                 this->nextActionpoint();
    1154                 return;
    1155             }
    1156             this->stayNearProtect();
    1157         }
    1158         else if (this->action_ == Action::ATTACK)
    1159         {   
    1160             if (!this->hasTarget())
    1161             {
    1162                 this->nextActionpoint();
    1163                 return;
    1164             }
    1165         }
    1166         if (this->hasTarget())
    1167         {
    1168             //----choose where to go----
    1169             this->maneuver();
    1170             //----fire if you can----
    1171             this->bShooting_ = this->canFire();               
    1172         }
    1173     }
    1174     void CommonController::takeActionpoints (std::vector<Point > vector, std::vector<Point > loop, bool b)
    1175     {
    1176       this->parsedActionpoints_ = vector;
    1177       this->loopActionpoints_ = loop;
    1178       this->bLoop_ = this->bLoop_;
    1179       this->bTakenOver_ = true;
    1180       // orxout(internal_error) << "Top action is " << this->parsedActionpoints_.back().action << endl;
    1181     }
     585
     586
     587   
    1182588    void CommonController::boostControl()
    1183589    {

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

    r10861 r10864  
    6161
    6262    }
    63     namespace Action
    64     { 
    65         enum Value
    66         {
    67             NONE, FLY, FIGHT, PROTECT, FIGHTALL, ATTACK
    68         };
    69        
    70     }
    71    
    72     struct Point {
    73         Action::Value action;
    74         std::string name;
    75         Vector3 position;
    76         bool inLoop;
    77     } ;
    78 
     63   
    7964
    8065   
    … …  
    9681                virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    9782               
    98                     void setFormationModeXML(std::string val);
    99                     std::string getFormationModeXML();
    100                     void setFormationMode(FormationMode::Value val);
    101                     FormationMode::Value getFormationMode() const;
     83                void setFormationModeXML(std::string val);
     84                std::string getFormationModeXML();
     85                void setFormationMode(FormationMode::Value val);
     86                FormationMode::Value getFormationMode() const;
    10287
    103                     void setRank(Rank::Value val);
    104                     Rank::Value getRank() const;
    105                
    106                     void addActionpoint(WorldEntity* waypoint);
    107                     WorldEntity* getActionpoint(unsigned int index) const;
     88                void setRank(Rank::Value val);
     89                Rank::Value getRank() const;
     90           
     91
    10892            //----[/XML methods]----
    10993
    … …  
    11599                ControllableEntity* getTarget();
    116100                     
    117                 Action::Value getAction ();
    118                 std::string getActionName();
    119 
    120                 void setAction (Action::Value action);
    121                 void setAction (Action::Value action, ControllableEntity* target);
    122                 void setAction (Action::Value action, const Vector3& target);
    123                 void setAction (Action::Value action, const Vector3& target,  const Quaternion& orient );
    124             //----[/Interaction with other Controllers]----
     101             //----[/Interaction with other Controllers]----
    125102
    126103            //----[Helper methods]----
    … …  
    135112            //----[/Helper methods]----
    136113
    137              
    138                 virtual void stayNearProtect();
    139                 virtual void action(); //<! action() is called in regular intervals managing the bot's behaviour.
    140                  virtual void takeActionpoints (std::vector<Point > vector, std::vector<Point > loop, bool b);
    141    
     114 
    142115        protected:
    143116            //----[Flying methods]----
    … …  
    168141                void setOrientationOfTarget(const Quaternion& orient);
    169142
    170                 void setProtect (ControllableEntity* protect);
    171                 ControllableEntity* getProtect ();
    172143
    173144                void maneuver();
    … …  
    175146                bool canFire();
    176147                void doFire();
    177                 void setClosestTarget();
    178                 Pawn* closestTarget();
    179                 void startAttackingEnemiesThatAreClose();
     148
    180149            //----[/Fighting methods]----           
    181150           
    … …  
    200169            //----[/who-to-kill information]----
    201170
    202             //----[Actionpoint information]----
    203171
    204                 std::vector<WeakPtr<WorldEntity> > actionpoints_;
    205                 float squaredaccuracy_;
    206                 std::vector<Point > parsedActionpoints_;
    207                 std::vector<Point > loopActionpoints_;
    208 
    209             //----[/Actionpoint information]----
    210             //----[Actionpoint methods]----
    211                 void executeActionpoint();
    212                 void nextActionpoint();
    213                 void fillLoop();
    214                 void fillLoopReversed();
    215                 void moveBackToTop();
    216             //----[Actionpoint methods]----
    217172            //----["Private" variables]----
    218173                FormationMode::Value formationMode_;
    219174                Rank::Value rank_;
    220                 std::string protectName_;
    221                 std::string targetName_;
    222                 Action::Value action_;
     175
    223176                int attackRange_;
    224177                bool bLookAtTarget_;       
    … …  
    227180                int tolerance_;
    228181                bool bFirstTick_;
    229                 bool bInLoop_;
    230                 bool bLoop_;   
    231                 bool bEndLoop_; 
    232                 bool bTakenOver_;             
     182           
    233183            //----[/"Private" variables]----   
    234184           

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

    r10861 r10864  
    9191            return;
    9292       
    93         CommonController::action();
     93        ActionpointController::action();
    9494        if (!this || !this->getControllableEntity())
    9595            return;
    … …  
    109109    void DivisionController::stayNearProtect()
    110110    {
    111         CommonController::stayNearProtect();
     111        ActionpointController::stayNearProtect();
    112112    }
    113113   
    114     bool DivisionController::setWingman(CommonController* cwingman)
     114    bool DivisionController::setWingman(ActionpointController* cwingman)
    115115    {
    116116

  • code/branches/campaignHS15/src/orxonox/controllers/DivisionController.h

    r10856 r10864  
    5353            //----[own functions]----
    5454                virtual bool setFollower(LeaderController* myFollower);
    55                 virtual bool setWingman(CommonController* cwingman);
     55                virtual bool setWingman(ActionpointController* cwingman);
    5656                virtual bool hasWingman();
    5757                virtual bool hasFollower();

  • code/branches/campaignHS15/src/orxonox/controllers/LeaderController.cc

    r10859 r10864  
    3636
    3737    //CommonController contains all common functionality of AI Controllers
    38     LeaderController::LeaderController(Context* context) : CommonController(context)
     38    LeaderController::LeaderController(Context* context) : ActionpointController(context)
    3939    {
    4040

  • code/branches/campaignHS15/src/orxonox/controllers/LeaderController.h

    r10856 r10864  
    3030#define _LeaderController_H__
    3131
    32 #include "controllers/CommonController.h"
     32#include "controllers/ActionpointController.h"
    3333#include "controllers/WingmanController.h"
    3434
    … …  
    3838namespace orxonox
    3939{
    40     class _OrxonoxExport LeaderController : public CommonController
     40    class _OrxonoxExport LeaderController : public ActionpointController
    4141    {
    4242        public:

  • code/branches/campaignHS15/src/orxonox/controllers/SectionController.cc

    r10861 r10864  
    9999        {
    100100           
    101             CommonController::action();
     101            ActionpointController::action();
    102102            if (!this || !this->getControllableEntity())
    103103                return;
    … …  
    307307        return 0;
    308308    }
    309     bool SectionController::setWingman(CommonController* cwingman)
     309    bool SectionController::setWingman(ActionpointController* cwingman)
    310310    {
    311311        WeakPtr<WingmanController> wingman = orxonox_cast<WingmanController*>(cwingman);

  • code/branches/campaignHS15/src/orxonox/controllers/SectionController.h

    r10856 r10864  
    5353                LeaderController* findNewDivisionLeader();
    5454
    55                 virtual bool setWingman(CommonController* cwingman);
     55                virtual bool setWingman(ActionpointController* cwingman);
    5656                virtual bool hasWingman();
    5757

  • code/branches/campaignHS15/src/orxonox/controllers/WingmanController.cc

    r10859 r10864  
    3535    RegisterClass(WingmanController);
    3636   
    37     //CommonController contains all common functionality of AI Controllers
    38     WingmanController::WingmanController(Context* context) : CommonController(context)
     37    //ActionpointController contains all common functionality of AI Controllers
     38    WingmanController::WingmanController(Context* context) : ActionpointController(context)
    3939    {
    4040        RegisterObject(WingmanController);
    … …  
    8181        if (!this->myLeader_)
    8282        {
    83             CommonController* newLeader = findNewLeader();
     83            ActionpointController* newLeader = findNewLeader();
    8484            this->myLeader_ = newLeader;
    8585           
    … …  
    9292        if (!this->myLeader_)
    9393        {
    94            CommonController::action();
     94           ActionpointController::action();
    9595        }
    9696        else if (this->myLeader_)
    … …  
    217217    }
    218218    //----POST: closest leader that is ready to take a new wingman is returned----
    219     CommonController* WingmanController::findNewLeader()
     219    ActionpointController* WingmanController::findNewLeader()
    220220    {
    221221
    … …  
    224224
    225225        //----vars for finding the closest leader----
    226         CommonController* closestLeader = 0;
     226        ActionpointController* closestLeader = 0;
    227227        float minDistance =  std::numeric_limits<float>::infinity();
    228228        Gametype* gt = this->getGametype();
    229         for (ObjectList<CommonController>::iterator it = ObjectList<CommonController>::begin(); it; ++it)
     229        for (ObjectList<ActionpointController>::iterator it = ObjectList<ActionpointController>::begin(); it; ++it)
    230230        {
    231231            //----0ptr or not a leader or dead?----

  • code/branches/campaignHS15/src/orxonox/controllers/WingmanController.h

    r10856 r10864  
    3131
    3232
    33 #include "controllers/CommonController.h"
     33#include "controllers/ActionpointController.h"
    3434
    3535
    3636namespace orxonox
    3737{
    38     class _OrxonoxExport WingmanController : public CommonController
     38    class _OrxonoxExport WingmanController : public ActionpointController
    3939    {
    4040        public:
    … …  
    5252
    5353            //----[own functions]----
    54                CommonController* findNewLeader();
     54               ActionpointController* findNewLeader();
    5555            //----[/own functions]----
    5656
    … …  
    6262        private:
    6363            //----private variables-----
    64                 WeakPtr<CommonController> myLeader_;
     64                WeakPtr<ActionpointController> myLeader_;
    6565                Timer actionTimer_; //<! Regularly calls action().
    6666                bool bFirstAction_;
Note: See TracChangeset for help on using the changeset viewer.