Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Oct 31, 2015, 4:07:29 PM (9 years ago)
Author:
gania
Message:

added a little bit of firing functionality

Location:
code/branches/AI_HS15/src/orxonox/controllers
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r10729 r10731  
    3535    static const float ROTATEFACTOR = 0.2f;
    3636
    37     /*static const float SPEED_FREE = 0.8f;
    38     static const float ROTATEFACTOR_FREE = 0.8f;*/
    39    
     37    CommonController::CommonController(Context* context) : Controller(context)
     38    {
     39
     40        RegisterObject(CommonController);
     41    }
     42
     43
     44    CommonController::~CommonController()
     45    {
     46    }
     47
     48
     49
     50
    4051    bool CommonController::setWingman (CommonController* wingman)
    4152    {
    4253        return false;
    4354    }
    44     bool CommonController::isLeader ()
    45     {
    46         return false;
    47     }
     55   
    4856    bool CommonController::hasWingman()
    4957    {
    … …  
    5159    }
    5260
    53     CommonController::CommonController(Context* context) : Controller(context)
    54     {
    55 
    56         RegisterObject(CommonController);
    57     }
    58 
    59 
    60     CommonController::~CommonController()
    61     {
    62     }
     61
     62
     63
     64    void CommonController::setTargetPosition(const Vector3& target)
     65    {
     66        this->targetPosition_ = target;
     67        this->bHasTargetPosition_ = true;
     68    }
     69
     70    void CommonController::setTargetOrientation(const Quaternion& orient)
     71    {
     72        this->targetOrientation_=orient;
     73        this->bHasTargetOrientation_=true;
     74    }
     75
     76    void CommonController::setTargetOrientation(ControllableEntity* target)
     77    {
     78        if (target)
     79            setTargetOrientation(target->getOrientation());
     80    }
     81
     82    /*void CommonController::spin()
     83    {
     84        this->moveToTargetPosition();
     85        this->getControllableEntity()->rotateRoll(8.0f);
     86    }
     87    void CommonController::turn180()
     88    {
     89        Vector2 coord = get2DViewdirection(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, this->targetPosition_);
     90
     91        this->getControllableEntity()->rotateYaw(-2.0f * sgn(coord.x) * coord.x*coord.x);
     92        this->getControllableEntity()->rotatePitch(2.0f * sgn(coord.y) * coord.y*coord.y);
     93
     94        this->getControllableEntity()->moveFrontBack(SPEED);
     95    }*/
     96
     97
     98
    6399    //copy the Roll orientation of given Quaternion.
    64100    void CommonController::copyOrientation(const Quaternion& orient)
    … …  
    69105        while(diff<-math::twoPi) diff+=math::twoPi;
    70106        this->getControllableEntity()->rotateRoll(-diff);
    71 
    72 
    73 
    74     }
    75     void CommonController::setTargetPosition(const Vector3& target)
    76     {
    77         this->targetPosition_ = target;
    78         this->bHasTargetPosition_ = true;
    79     }
    80 
     107    }
    81108    void CommonController::copyTargetOrientation()
    82109    {
    … …  
    86113        }
    87114    }
    88     void CommonController::setTargetOrientation(const Quaternion& orient)
    89     {
    90         this->targetOrientation_=orient;
    91         this->bHasTargetOrientation_=true;
    92     }
    93     void CommonController::setTargetOrientation(ControllableEntity* target)
    94     {
    95         if (target)
    96             setTargetOrientation(target->getOrientation());
    97     }
    98 
    99 
     115
     116
     117
     118
     119    void CommonController::moveToTargetPosition()
     120    {
     121        this->moveToPosition(this->targetPosition_);
     122    }
    100123    void CommonController::moveToPosition(const Vector3& target)
    101124    {
    … …  
    146169            bHasTargetOrientation_ = false;
    147170        }
    148 
    149      
    150     }
    151     void CommonController::moveToTargetPosition()
    152     {
    153         this->moveToPosition(this->targetPosition_);
    154     }
     171    }
     172    void CommonController::doFire()
     173    {
     174         if (this->isLookingAtTarget(math::pi / 20.0f))
     175            this->getControllableEntity()->fire(0); //ai uses lens flare if they're close enough to the target
     176    }
     177    bool CommonController::isLookingAtTarget(float angle) const
     178    {
     179        if (!this->getControllableEntity())
     180            return false;
     181
     182        return (getAngle(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->targetPosition_) < angle);
     183    }
     184
     185    void CommonController::aimAtTarget()
     186    {
     187        if (!this->target_ || !this->getControllableEntity())
     188            return;
     189
     190        static const float hardcoded_projectile_speed = 750;
     191
     192        Vector3 aimPosition = getPredictedPosition(this->getControllableEntity()->getWorldPosition(),
     193            hardcoded_projectile_speed, this->target_->getWorldPosition(), this->target_->getVelocity());
     194
     195        Pawn* pawn = orxonox_cast<Pawn*>(this->getControllableEntity());
     196        if (pawn)
     197            pawn->setAimPosition(aimPosition);
     198    }
     199   
    155200 
    156201

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

    r10729 r10731  
    3333#include "controllers/Controller.h"
    3434#include "worldentities/ControllableEntity.h"
     35#include "worldentities/pawns/Pawn.h"
     36
    3537
    3638namespace orxonox
    … …  
    3941    {
    4042        public:
     43
    4144            static const float ACTION_INTERVAL = 1.0f;
    4245
    43             enum FormationMode {VEE,FINGER4,DIAMOND, WALL};
     46
     47            CommonController(Context* context);
     48            virtual ~CommonController();
     49
     50
     51
     52            enum FormationMode { VEE, FINGER4, DIAMOND, WALL };
    4453            virtual void setFormationMode(FormationMode val)
    4554                { this->formationMode_ = val; }
    … …  
    4756                { return this->formationMode_; }
    4857
    49             CommonController(Context* context);
    50             virtual ~CommonController();
    51             virtual bool isLeader();
     58            enum Rank { NONE, SECTIONLEADER, DIVISIONLEADER, WINGMAN };
     59            virtual void setRank(Rank val)
     60                { this->rank_ = val; }
     61            inline Rank getRank() const
     62                { return this->rank_; }
     63
     64
     65
     66
    5267            virtual bool setWingman(CommonController* wingman);
    5368            virtual bool hasWingman();
    … …  
    5873            void setTargetPosition(const Vector3& target);
    5974
     75            /*void spin();
     76            void turn180();*/
     77
     78
    6079        protected:
     80
    6181            void moveToPosition(const Vector3& target);
    62             virtual void positionReached() {}
     82            void moveToTargetPosition();
    6383
    64        
    65             void moveToTargetPosition();
     84
    6685            void copyOrientation(const Quaternion& orient);
    6786            void copyTargetOrientation();
    6887
     88            void doFire();
     89            void aimAtTarget();
     90            bool isLookingAtTarget(float angle) const;
    6991
    7092            bool bHasTargetPosition_;
    … …  
    7395            Quaternion targetOrientation_;
    7496
     97
    7598            WeakPtr<ControllableEntity> target_;
    7699            bool bShooting_;
    77100
     101
    78102            FormationMode formationMode_;
    79 
     103            Rank rank_;
    80104
    81105

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

    r10729 r10731  
    4040        this->setFormationMode(WALL);
    4141
    42         bIsDivisionLeader_ = true;
    4342        this->myFollower_ = 0;
    4443        this->myWingman_ = 0;
    4544        this->actionTimer_.setTimer(ACTION_INTERVAL, true, createExecutor(createFunctor(&DivisionController::action, this)));
    46        
    47         /*Vector3* pos = new Vector3(500,500,-500);
    48         this->setTargetPosition(*pos);*/
     45        this->rank_ = DIVISIONLEADER;
     46
     47        Vector3* pos = new Vector3(500,500,-500);
     48        this->setTargetPosition(*pos);
    4949
    5050    }
    … …  
    5454     
    5555    }
     56
     57   
    5658    void DivisionController::tick(float dt)
    5759    {
     60        if (this->target_)
     61        {
     62            this->aimAtTarget();
     63            this->doFire();
     64        }
     65     
    5866        if (this->bHasTargetPosition_)
    5967        {
    … …  
    6876        setTargetPositionOfFollower();
    6977        setTargetPositionOfWingman();
    70     }
    71 
    72     bool DivisionController::setFollower(LeaderController* myFollower)
    73     {
    74          if (!this->myFollower_)
    75         {
    76             this->myFollower_ = myFollower;
    77             return true;
    78         }
    79         else
    80         {
    81             return false;
    82         }
    83     }
     78
     79        for (ObjectList<Controller>::iterator it = ObjectList<Controller>::begin(); it; ++it)
     80        {
     81            if (this->getControllableEntity()->getTeam() != (it)->getControllableEntity()->getTeam())
     82            {
     83                this->target_=it->getControllableEntity();
     84                this->setTargetPosition(this->target_->getWorldPosition());
     85                break;
     86            }
     87        }
     88           
     89     
     90    }
     91
     92   
    8493
    8594    void DivisionController::setTargetPositionOfWingman()
    … …  
    149158       
    150159    }
     160
     161
     162    bool DivisionController::setWingman(CommonController* cwingman)
     163    {
     164
     165        WeakPtr<WingmanController> wingman = orxonox_cast<WingmanController*>(cwingman);
     166        if (!this->myWingman_)
     167        {
     168            this->myWingman_ = wingman;
     169            return true;
     170        }
     171        else
     172        {
     173            return false;
     174        }
     175   
     176    }
     177    bool DivisionController::setFollower(LeaderController* myFollower)
     178    {
     179         if (!this->myFollower_)
     180        {
     181            this->myFollower_ = myFollower;
     182            return true;
     183        }
     184        else
     185        {
     186            return false;
     187        }
     188    }
     189    bool DivisionController::hasWingman()
     190    {
     191        if (this->myWingman_)
     192            return true;
     193        else
     194            return false;
     195    }
     196    bool DivisionController::hasFollower()
     197    {
     198        if (this->myFollower_)
     199            return true;
     200        else
     201            return false;
     202    }
     203
     204
    151205    void DivisionController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
    152206    {

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

    r10729 r10731  
    4242      {
    4343        public:
     44
    4445                DivisionController(Context* context);
    4546                virtual ~DivisionController();
    4647
    47                 virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     48            virtual void tick(float dt); //<! Carrying out the targets set in action().
    4849
    49                 //Using british military aircraft formations
    50                
    5150               
    5251                        virtual bool setFollower(LeaderController* myFollower);
    53                         virtual bool setWingman(CommonController* cwingman)
    54             {
    55                 WeakPtr<WingmanController> wingman = orxonox_cast<WingmanController*>(cwingman);
    56                 if (!this->myWingman_)
    57                 {
    58                     this->myWingman_ = wingman;
    59                     return true;
    60                 }
    61                 else
    62                 {
    63                     return false;
    64                 }
    65             };
    66             virtual bool hasWingman()
    67             {
    68                 if (this->myWingman_)
    69                     return true;
    70                 else
    71                     return false;
    72             }
    73             virtual bool hasFollower()
    74             {
    75                 if (this->myFollower_)
    76                     return true;
    77                 else
    78                     return false;
    79             };
    80            
     52                        virtual bool setWingman(CommonController* cwingman);
     53            virtual bool hasWingman();
     54            virtual bool hasFollower();
    8155
    82             virtual void tick(float dt); //<! Carrying out the targets set in action().
    83 
     56            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);         
    8457
    8558        protected:
     59           
    8660            void setTargetPositionOfWingman();
    8761            void setTargetPositionOfFollower();
     62
    8863            virtual void action(); //<! action() is called in regular intervals managing the bot's behaviour ~ setting targets.
    8964           
    9065        private:
     66
    9167            Timer actionTimer_; //<! Regularly calls action().
    9268

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

    r10722 r10731  
    4343      /*  this->goalTarget_ = NULL;
    4444        this->goalProtect_ = NULL;*/
    45         this->nTicks_ = 0;
    46         this->bTicked_ = false;
     45       
    4746        //this->actionTimer_.setTimer(ACTION_INTERVAL, true, createExecutor(createFunctor(&FleetController::action, this)));
    4847    }
    … …  
    6362    {
    6463
    65          /*if (nTicks_ == 30)
    66          {
    67             std::vector<WeakPtr<WingmanController> > wingmen;
    68             std::vector<WeakPtr<LeaderController> > leaders;
    69 
    70             //--------------------------Put all WingmanController's in a vector--------------------------
    71             for (ObjectList<WingmanController>::iterator it = ObjectList<WingmanController>::begin(); it; ++it)
    72             {
    73 
    74                
    75                 if ((*it)->getTeam() == this->getTeam())
    76                 {
    77                     orxout(internal_error) << "ANOTHER SUCKER" << endl;
    78                     wingmen.push_back(*it);
    79                 }
    80                
    81             }
    82             //--------------------------Substitute half of WingmanController's with LeaderController--------------------------
    83 
    84             bool nowLeader = true;
    85             LeaderController* leader;
    86 
    87             for (std::vector<WeakPtr<WingmanController> >::iterator it = wingmen.begin() ; it != wingmen.end(); ++it)
    88             {
    89                 if (nowLeader)
    90                 {
    91                     leader = new LeaderController(this->getContext());
    92                     leader->setTeam(this->team_);
    93 
    94                     (*it)->getControllableEntity()->setController(leader);
    95                     leaders.push_back(leader);
    96                     nowLeader = !nowLeader;
    97                     orxout(internal_error) << "NEW SUCKER" << endl;
    98 
    99                 }
    100                 else
    101                 {
    102                     if (leader)
    103                     {
    104                         leader->setWingman(*it);
    105                         nowLeader = !nowLeader;
    106                         orxout(internal_error) << "I OWN THE SUCKER" << endl;
    107 
    108                     }
    109                 }
    110             }
    111 
    112             //--------------------------Substitute half of LeaderController's with DivisionController--------------------------
    113             bool nowDivision = true;
    114             DivisionController* division;
    115 
    116             for (std::vector<WeakPtr<LeaderController> >::iterator it = leaders.begin() ; it != leaders.end(); ++it)
    117             {
    118                 if (nowDivision)
    119                 {
    120                     division = new DivisionController(this->getContext());
    121                     division->setTeam(this->team_);
    122 
    123                     (*it)->getControllableEntity()->setController(division);
    124 
    125                     divisions_.push_back(division);
    126 
    127                     nowDivision = !nowDivision;
    128                 }
    129                 else
    130                 {
    131                     if (division)
    132                     {
    133                         division->setLeader(*it);
    134                         nowDivision = !nowDivision;
    135                     }
    136                 }
    137             }
    138             bTicked_ = true;
    139             nTicks_ += 1;
    140          }
    141          else if (!bTicked_)
    142          {
    143             nTicks_ += 1;
    144 
    145          }*/
    14664        SUPER(FleetController, tick, dt);
    14765

  • code/branches/AI_HS15/src/orxonox/controllers/FleetController.h

    r10722 r10731  
    8383            virtual void action();
    8484        private:
    85             int nTicks_;
    86             bool bTicked_;
    87 
     85       
    8886            std::vector<WeakPtr<DivisionController> > divisions_;
    8987            //Timer actionTimer_; //<! Regularly calls action().

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

    r10729 r10731  
    4545            LeaderController(Context* context);
    4646            virtual ~LeaderController();
    47             virtual bool isLeader()
    48             {
    49                 return true;
    50             };
    51             bool bIsDivisionLeader_;
     47           
    5248            virtual bool setFollower(LeaderController* myFollower)
    53             {
    54                 return false;
    55             };
    56             virtual bool bIsDivisionLeader()
    57             {
    58                 return bIsDivisionLeader_;
    59             };
     49                { return false; }
     50           
    6051            virtual bool hasFollower()
    61             {
    62                 return true;
    63             };
     52                { return true; }
     53           
     54
     55
     56
     57        protected:
     58         
    6459            WeakPtr<WingmanController> myWingman_;
    6560
    … …  
    6762            WeakPtr<LeaderController> myDivisionLeader_;
    6863
    69 
    70         protected:
    71          
     64           
    7265        private:
    7366           

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

    r10729 r10731  
    3939        this->setFormationMode(WALL);
    4040
    41         bIsDivisionLeader_ = false;
    4241        this->actionTimer_.setTimer(ACTION_INTERVAL, true, createExecutor(createFunctor(&SectionController::action, this)));
    4342        this->myWingman_ = 0;
    4443        this->myDivisionLeader_ = 0;
     44        this->rank_ = SECTIONLEADER;
    4545
    4646        orxout(internal_error) << this << "Was created" << endl;
    … …  
    5252       
    5353    }
     54
     55    void SectionController::tick(float dt)
     56    {
     57        if (!this->isActive())
     58            return;
     59       
     60        if (this->bHasTargetPosition_)
     61        {
     62            this->moveToTargetPosition();
     63        }
     64
     65       
     66        SUPER(SectionController, tick, dt);
     67    }
     68
     69    void SectionController::action()
     70    {
     71        //this->target_ = this->sectionTarget_;       
     72        if (!myDivisionLeader_)
     73        {
     74            LeaderController* newDivisionLeader = findNewDivisionLeader();
     75            this->myDivisionLeader_ = newDivisionLeader;
     76            if (newDivisionLeader)
     77                orxout(internal_error) << "new DivisionLeader set" << endl;
     78
     79        }
     80        setTargetPositionOfWingman();
     81
     82    }
     83   
    5484    void SectionController::setTargetPositionOfWingman()
    5585    {
    … …  
    85115       
    86116    }
    87 
    88117    LeaderController* SectionController::findNewDivisionLeader()
    89118    {
    … …  
    98127        {
    99128            //0ptr or not DivisionController?
    100             if (!(it) || !(it)->bIsDivisionLeader_ || !(it->getControllableEntity()))
     129            if (!(it) || !((it)->getRank() == DIVISIONLEADER) || !(it->getControllableEntity()))
    101130                continue;
    102131            //same team?
    … …  
    126155
    127156    }
     157    bool SectionController::setWingman(CommonController* cwingman)
     158    {
     159        WeakPtr<WingmanController> wingman = orxonox_cast<WingmanController*>(cwingman);
    128160
    129     void SectionController::action()
    130     {
    131         //this->target_ = this->sectionTarget_;       
    132         if (!myDivisionLeader_)
     161        if (!this->myWingman_)
    133162        {
    134             LeaderController* newDivisionLeader = findNewDivisionLeader();
    135             this->myDivisionLeader_ = newDivisionLeader;
    136             if (newDivisionLeader)
    137                 orxout(internal_error) << "new DivisionLeader set" << endl;
    138 
     163            this->myWingman_ = wingman;
     164            return true;
    139165        }
    140         setTargetPositionOfWingman();
    141 
    142     }
    143     /*
    144     Wingmen and Leaders attack target_, which is a member variable of their classes.
    145     Wingmen's target_ is set to sectionTarget_, which is a member variable of SectionController class, unless
    146     Wingman covers Leader's rear.
    147     Leader's target_ must always equal sectionTarget_.
    148     if section has a target, its Leader shoots at it, but doesn't follow.
    149     Every section is a part of division. Division consisting of one Section is still a division.
    150     Division's leader's target_ must always equal divisionTarget_, which is a member variable of DivisionController.
    151     Division leader ONLY can follow target_ while in formation flight.
    152     If Division doesn't have a target, Division Leader stays in place, unless it has a waypoint.
    153     Division Leader's sectionTarget_ must equal divisionTarget_,
    154     but the other section, that is not a leading section, can attack any target that is near divisonTarget_
    155 
    156     */
    157    
    158     void SectionController::tick(float dt)
    159     {
    160         if (!this->isActive())
    161             return;
    162        
    163         if (this->bHasTargetPosition_)
     166        else
    164167        {
    165             this->moveToTargetPosition();
     168            return false;
    166169        }
    167 
    168        
    169         SUPER(SectionController, tick, dt);
    170170    }
    171171   
     172    bool SectionController::hasWingman()
     173    {
     174        if (this->myWingman_)
     175            return true;
     176        else
     177            return false;
     178    }
    172179
    173180    void SectionController::XMLPort(Element& xmlelement, XMLPort::Mode mode)

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

    r10729 r10731  
    4040    {
    4141        public:
     42
    4243            SectionController(Context* context);
    4344            virtual ~SectionController();
    44             virtual bool setWingman(CommonController* cwingman)
    45             {
    46                 WeakPtr<WingmanController> wingman = orxonox_cast<WingmanController*>(cwingman);
     45           
     46            virtual void tick(float dt); //<! Carrying out the targets set in action().
     47           
    4748
    48                 if (!this->myWingman_)
    49                 {
    50                     this->myWingman_ = wingman;
    51                     return true;
    52                 }
    53                 else
    54                 {
    55                     return false;
    56                 }
    57             }
    58 
    59 
    60             virtual bool hasWingman()
    61             {
    62                 if (this->myWingman_)
    63                     return true;
    64                 else
    65                     return false;
    66             }
    67 
    68             virtual void tick(float dt); //<! Carrying out the targets set in action().
    69 
     49            LeaderController* findNewDivisionLeader();
     50            virtual bool setWingman(CommonController* cwingman);
     51            virtual bool hasWingman();
     52           
    7053            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    71             LeaderController* findNewDivisionLeader();
    7254
    7355        protected:
     56
    7457            void setTargetPositionOfWingman();
    75             //A division is the biggest block of spaceships.
    76             //In division one section is leading, the other one always stays on the same position
    77             //relative to the Leader of the leading section.
    78             //In section a Wingman always stays on same position relative to the Leader.
    79             //That position is desiredRelativePosition_
     58           
    8059            virtual void action(); //<! action() is called in regular intervals managing the bot's behaviour ~ setting targets.
    8160
     61        private:
    8262
    83            
    84 
    85        
    86         private:
    8763            Timer actionTimer_; //<! Regularly calls action().
    8864           

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

    r10729 r10731  
    4141        this->actionTimer_.setTimer(ACTION_INTERVAL, true, createExecutor(createFunctor(&WingmanController::action, this)));
    4242        this->myLeader_ = 0;
     43        this->rank_ = WINGMAN;
     44
    4345    }
    4446
    … …  
    4850    }
    4951
    50     CommonController* WingmanController::findNewLeader()
    51     {
    52 
    53         if (!this->getControllableEntity())
    54             return 0;
    55 
    56         CommonController* closestLeader = 0;
    57         float minDistance =  std::numeric_limits<float>::infinity();
    58 
    59         for (ObjectList<CommonController>::iterator it = ObjectList<CommonController>::begin(); it; ++it)
    60         {
    61             //0ptr?
    62             if (!it || !it->isLeader() || !(it->getControllableEntity()))
    63                 continue;
    64             //same team?
    65             if (this->getControllableEntity()->getTeam() != (it)->getControllableEntity()->getTeam())
    66                 continue;
    67             //is equal to this?
    68             if (it->getControllableEntity() == this->getControllableEntity())
    69                 continue;
    70 
    71             float distance = (it->getControllableEntity()->getPosition() - this->getControllableEntity()->getPosition()).length();
    72             if (distance < minDistance && !(it->hasWingman()))
    73             {
    74                 closestLeader = *it;
    75                 minDistance = distance;
    76             }
    77            
    78         }
    79         if (closestLeader)
    80         {
    81             if (closestLeader->setWingman(this))
    82                 return closestLeader;
    83         }
    84         return 0;
    85     }
    86    
    87     void WingmanController::action()
    88     {
    89         if (!this->myLeader_)
    90         {
    91             CommonController* newLeader = findNewLeader();
    92             this->myLeader_ = newLeader;
    93             if (newLeader)
    94                 orxout(internal_error) << "new Leader set" << endl;
    95             else
    96                 orxout(internal_error) << "0 leader" << endl;
    97 
    98         }
    99         else
    100         {
    101 
    102         }
    103     }
    104  /*//collect data for AI behaviour
    105             Vector3* meanOfEnemiesPtr = new Vector3(0.0,0.0,0.0);
    106             Vector3* meanOfAlliesPtr  = new Vector3(0.0,0.0,0.0);
    107             Vector3 meanOfAllies = *meanOfAlliesPtr;
    108             Vector3 meanOfEnemies = *meanOfEnemiesPtr;
    109 
    110 
    111             for (ObjectList<AIController>::iterator it = ObjectList<AIController>::begin(); it; ++it)
    112             {
    113 
    114                 Gametype* gt=this->getGametype();
    115                 if (!gt)
    116                 {
    117                     gt=it->getGametype();
    118                 }
    119                 if (!FormationController::sameTeam(this->getControllableEntity(), it->getControllableEntity(),gt))
    120                 {
    121                     enemies_.push_back(*it);
    122                 }
    123                 else {
    124                     allies_.push_back(*it);
    125                 }
    126             }
    127             if (enemies_.size() != 0 && allies_.size() != 0){
    128                 for (std::vector<WeakPtr<AIController> >::iterator it = enemies_.begin() ; it != enemies_.end(); ++it)
    129                     meanOfEnemies += (*it)->getControllableEntity()->getWorldPosition();
    130 
    131                 meanOfEnemies /= enemies_.size();
    132 
    133                 for (std::vector<WeakPtr<AIController> >::iterator it = allies_.begin() ; it != allies_.end(); ++it)
    134                     meanOfAllies += (*it)->getControllableEntity()->getWorldPosition();
    135 
    136                 meanOfAllies /= allies_.size();
    137 
    138                 //orxout(internal_error) << "There are " << enemies_Counter << " enemies_, mean position is " << meanOfEnemies << endl;
    139                 orxout(internal_error) << "Distance is " << (meanOfEnemies-meanOfAllies).length() << endl;
    140                 orxout(internal_error) << "mean of allies_ is " << meanOfAllies << ", with a size " << allies_.size() << endl;
    141                 orxout(internal_error) << "mean of enemies_ is " << meanOfEnemies << ", with a size " << enemies_.size() << endl;
    142             }*/
    143 
    144      
    145    
    14652    void WingmanController::tick(float dt)
    14753    {   
    … …  
    17278        SUPER(WingmanController, tick, dt);
    17379    }
     80   
     81    void WingmanController::action()
     82    {
     83        if (!this->myLeader_)
     84        {
     85            CommonController* newLeader = findNewLeader();
     86            this->myLeader_ = newLeader;
     87            if (newLeader)
     88                orxout(internal_error) << "new Leader set" << endl;
     89            else
     90                orxout(internal_error) << "0 leader" << endl;
     91
     92        }
     93        else
     94        {
     95
     96        }
     97    }
     98     
     99   
     100   
     101
     102    CommonController* WingmanController::findNewLeader()
     103    {
     104
     105        if (!this->getControllableEntity())
     106            return 0;
     107
     108        CommonController* closestLeader = 0;
     109        float minDistance =  std::numeric_limits<float>::infinity();
     110
     111        for (ObjectList<CommonController>::iterator it = ObjectList<CommonController>::begin(); it; ++it)
     112        {
     113            //0ptr?
     114            if (!it ||
     115                (it->getRank() != SECTIONLEADER && it->getRank() != DIVISIONLEADER) ||
     116                !(it->getControllableEntity()))
     117                continue;
     118            //same team?
     119            if (this->getControllableEntity()->getTeam() != (it)->getControllableEntity()->getTeam())
     120                continue;
     121            //is equal to this?
     122            if (it->getControllableEntity() == this->getControllableEntity())
     123                continue;
     124
     125            float distance = (it->getControllableEntity()->getPosition() - this->getControllableEntity()->getPosition()).length();
     126            if (distance < minDistance && !(it->hasWingman()))
     127            {
     128                closestLeader = *it;
     129                minDistance = distance;
     130            }
     131           
     132        }
     133        if (closestLeader)
     134        {
     135            if (closestLeader->setWingman(this))
     136                return closestLeader;
     137        }
     138        return 0;
     139    }
    174140
    175141    void WingmanController::XMLPort(Element& xmlelement, XMLPort::Mode mode)

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

    r10729 r10731  
    4747            WingmanController(Context* context);
    4848            virtual ~WingmanController();
    49             virtual bool isLeader()
    50             {
    51                 return false;
    52             };
    53 
     49           
    5450            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
    5551            virtual void tick(float dt); //<! Carrying out the targets set in action().
Note: See TracChangeset for help on using the changeset viewer.