Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/orxonox/controllers/FormationController.cc @ 9541

Last change on this file since 9541 was 9348, checked in by landauf, 12 years ago

merged branch presentation2012merge back to trunk

  • Property svn:eol-style set to native
File size: 36.2 KB
RevLine 
[8978]1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
[9255]23 *      ...
[8978]24 *   Co-authors:
25 *      Dominik Solenicki
26 *
27 */
28
29#include <climits>
30#include "controllers/FormationController.h"
31
32#include "core/CoreIncludes.h"
33
34#include "core/XMLPort.h"
35#include "core/command/ConsoleCommand.h"
36
37#include "worldentities/ControllableEntity.h"
38#include "worldentities/pawns/Pawn.h"
39#include "worldentities/pawns/TeamBaseMatchBase.h"
40#include "gametypes/TeamDeathmatch.h"
41#include "gametypes/Dynamicmatch.h"
[8995]42#include "gametypes/Mission.h"
[8978]43#include "gametypes/Gametype.h"
44#include "controllers/WaypointPatrolController.h"
45#include "controllers/NewHumanController.h"
46#include "controllers/DroneController.h"
47
48
49namespace orxonox
50{
51
[9348]52    SetConsoleCommand("FormationController", "formationflight",  &FormationController::formationflight);
53    SetConsoleCommand("FormationController", "masteraction",     &FormationController::masteraction);
54    SetConsoleCommand("FormationController", "followme",         &FormationController::followme);
55    SetConsoleCommand("FormationController", "passivebehaviour", &FormationController::passivebehaviour);
56    SetConsoleCommand("FormationController", "formationsize",    &FormationController::formationsize);
[8978]57
58
59
60
[9348]61    static const unsigned int STANDARD_MAX_FORMATION_SIZE = 9;
62    static const int RADIUS_TO_SEARCH_FOR_MASTERS = 5000;
63    static const float FORMATION_LENGTH =  110;
64    static const float FORMATION_WIDTH =  110;
65    static const int FREEDOM_COUNT = 4; //seconds the slaves in a formation will be set free when master attacks an enemy
66    static const float SPEED_MASTER = 0.6f;
67    static const float ROTATEFACTOR_MASTER = 0.2f;
68    static const float SPEED_FREE = 0.8f;
69    static const float ROTATEFACTOR_FREE = 0.8f;
[8978]70
[9348]71    FormationController::FormationController(BaseObject* creator) : Controller(creator)
72    {
[8978]73        RegisterObject(FormationController);
74
75        this->target_ = 0;
76        this->formationFlight_ = false;
77        this->passive_ = false;
78        this->maxFormationSize_ = STANDARD_MAX_FORMATION_SIZE;
79        this->myMaster_ = 0;
80        this->freedomCount_ = 0;
81
82        this->state_ = FREE;
[8991]83        this->formationMode_ = NORMAL;
[8978]84        this->specificMasterAction_ = NONE;
85        this->specificMasterActionHoldCount_  = 0;
86        this->bShooting_ = false;
87        this->bHasTargetPosition_ = false;
[9006]88        this->bHasTargetOrientation_=false;
[8978]89        this->speedCounter_ = 0.2f;
90        this->targetPosition_ = Vector3::ZERO;
[8995]91        this->team_=-1;
[8978]92        this->target_.setCallback(createFunctor(&FormationController::targetDied, this));
[9348]93    }
[8978]94
[9348]95    FormationController::~FormationController()
96    {
97        if (this->isInitialized())
[8978]98        {
99            this->removeFromFormation();
100
101            for (ObjectList<FormationController>::iterator it = ObjectList<FormationController>::begin(); it; ++it)
102            {
103                if (*it != this)
104                {
105                    if (it->myMaster_ == this)
106                    {
107                        orxout(internal_error) << this << " is still master in " << (*it) << endl;
108                        it->myMaster_ = 0;
109                    }
110
111                    while (true)
112                    {
113                        std::vector<FormationController*>::iterator it2 = std::find(it->slaves_.begin(), it->slaves_.end(), this);
114                        if (it2 != it->slaves_.end())
115                        {
116                            orxout(internal_error) << this << " is still slave in " << (*it) << endl;
117                            it->slaves_.erase(it2);
118                        }
119                        else
120                            break;
121                    }
122                }
123            }
124        }
[9348]125    }
[8978]126
[9348]127    void FormationController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
[8978]128    {
129        SUPER(FormationController, XMLPort, xmlelement, mode);
130
[8996]131        XMLPortParam(FormationController, "team", setTeam, getTeam, xmlelement, mode).defaultValues(-1);
[8978]132        XMLPortParam(FormationController, "formationFlight", setFormationFlight, getFormationFlight, xmlelement, mode).defaultValues(false);
133        XMLPortParam(FormationController, "formationSize", setFormationSize, getFormationSize, xmlelement, mode).defaultValues(STANDARD_MAX_FORMATION_SIZE);
134        XMLPortParam(FormationController, "passive", setPassive, getPassive, xmlelement, mode).defaultValues(false);
135    }
136
137
138
[9348]139    /**
[8978]140        @brief Activates / deactivates formationflight behaviour
141        @param form activate formflight if form is true
142    */
[9348]143    void FormationController::formationflight(const bool form)
[8978]144    {
145        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
146        {
147            Controller* controller = 0;
148
149            if (it->getController())
150                controller = it->getController();
151            else if (it->getXMLController())
152                controller = it->getXMLController();
153
154            if (!controller)
155                continue;
156
157            FormationController *aiController = orxonox_cast<FormationController*>(controller);
158
159            if (aiController)
160            {
161                aiController->formationFlight_ = form;
162                if (!form)
163                {
164                    aiController->removeFromFormation();
165                }
166            }
167        }
168    }
169
[9348]170    /**
[8978]171        @brief Get all masters to do a "specific master action"
172        @param action which action to perform (integer, so it can be called with a console command (tmp solution))
173    */
174    void FormationController::masteraction(const int action)
175    {
176        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
177        {
178            Controller* controller = 0;
179
180            if (it->getController())
181                controller = it->getController();
182            else if (it->getXMLController())
183                controller = it->getXMLController();
184
185            if (!controller)
186                continue;
187
188            FormationController *aiController = orxonox_cast<FormationController*>(controller);
189
190            if(aiController && aiController->state_ == MASTER)
191            {
192                if (action == 1)
193                    aiController->spinInit();
194                if (action == 2)
195                    aiController->turn180Init();
196            }
197        }
198    }
199
[9348]200    /**
[8978]201        @brief Sets shooting behaviour of pawns.
202        @param passive if true, bots won't shoot.
203    */
204    void FormationController::passivebehaviour(const bool passive)
205    {
206        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
207        {
208            Controller* controller = 0;
209
210            if (it->getController())
211                controller = it->getController();
212            else if (it->getXMLController())
213                controller = it->getXMLController();
214
215            if (!controller)
216                continue;
217
218            FormationController *aiController = orxonox_cast<FormationController*>(controller);
219
220            if(aiController)
221            {
222                aiController->passive_ = passive;
223            }
224        }
225    }
226
[9348]227    /**
[8978]228        @brief Sets maximal formation size
229        @param size maximal formation size.
230    */
231    void FormationController::formationsize(const int size)
232    {
233        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
234        {
235            Controller* controller = 0;
236
237            if (it->getController())
238                controller = it->getController();
239            else if (it->getXMLController())
240                controller = it->getXMLController();
241
242            if (!controller)
243                continue;
244
245            FormationController *aiController = orxonox_cast<FormationController*>(controller);
246
247            if(aiController)
248            {
249                aiController->maxFormationSize_ = size;
250            }
251        }
252    }
253
[9348]254    //used, when slaves are in DEFEND mode.
255    void FormationController::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage)
256    {
257        if (!this->formationFlight_ || this->state_ != MASTER || this->formationMode_ != DEFEND)
258            return;
259        this->masterAttacked(originator);
260    }
261
[9256]262    void FormationController::removeFromFormation()
[8978]263    {
264        if (this->state_ == SLAVE || this->myMaster_) // slaves can also be temporary free, so check if myMaster_ is set
265            this->unregisterSlave();
266        else if (this->state_ == MASTER)
267            this->setNewMasterWithinFormation();
268    }
269
270    void FormationController::moveToPosition(const Vector3& target)
271    {
272        if (!this->getControllableEntity())
273            return;
274
275        // Slave uses special movement if its master is in FOLLOW mode
276        if(this->state_ == SLAVE && this->myMaster_ && this->myMaster_->specificMasterAction_ == FOLLOW)
277        {
278//             this->followForSlaves(target);
279//             return;
280        }
281
[9348]282        Vector2 coord = get2DViewcoordinates(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
[8978]283        float distance = (target - this->getControllableEntity()->getPosition()).length();
[9348]284        float rotateX = clamp(coord.x * 10, -1.0f, 1.0f);
285        float rotateY = clamp(coord.y * 10, -1.0f, 1.0f);
[8978]286
287        if(this->state_ == FREE)
288        {
289            if (this->target_ || distance > 10)
290            {
291                // Multiply with ROTATEFACTOR_FREE to make them a bit slower
[9348]292                this->getControllableEntity()->rotateYaw(-1.0f * ROTATEFACTOR_FREE * rotateX);
293                this->getControllableEntity()->rotatePitch(ROTATEFACTOR_FREE * rotateY);
[8978]294            }
295
[9348]296            if (this->target_ && distance <  200 && this->getControllableEntity()->getVelocity().squaredLength() > this->target_->getVelocity().squaredLength())
[8978]297            {
298              this->getControllableEntity()->moveFrontBack(-0.05f); // They don't brake with full power to give the player a chance
299            } else this->getControllableEntity()->moveFrontBack(SPEED_FREE);
300        }
301
302
303
304        if(this->state_ == MASTER)
305        {
306            if (this->target_ || distance > 10)
307            {
[9348]308                this->getControllableEntity()->rotateYaw(-1.0f * ROTATEFACTOR_MASTER * rotateX);
309                this->getControllableEntity()->rotatePitch(ROTATEFACTOR_MASTER * rotateY);
[8978]310            }
311
312            if (this->target_ && distance < 200 && this->getControllableEntity()->getVelocity().squaredLength() > this->target_->getVelocity().squaredLength())
313            {
314                this->getControllableEntity()->moveFrontBack(-0.05f);
315            } else this->getControllableEntity()->moveFrontBack(SPEED_MASTER);
316        }
317
318
319
320        if(this->state_ == SLAVE)
321        {
322
[9348]323            this->getControllableEntity()->rotateYaw(-2.0f * ROTATEFACTOR_MASTER * rotateX);
324            this->getControllableEntity()->rotatePitch(2.0f * ROTATEFACTOR_MASTER * rotateY);
[8978]325
326            if (distance < 300)
327            {
[9348]328                if (bHasTargetOrientation_)
329                {
330                    copyTargetOrientation();
331                }
[8978]332                if (distance < 100)
[9348]333                { //linear speed reduction
[8978]334                    this->getControllableEntity()->moveFrontBack(distance/100.0f*0.4f*SPEED_MASTER);
[9348]335                }
336                else
337                    this->getControllableEntity()->moveFrontBack(1.2f*SPEED_MASTER);
338            }
339            else
[8978]340                this->getControllableEntity()->moveFrontBack(1.2f*SPEED_MASTER + distance/300.0f);
341        }
342
343        if (distance < 10)
344        {
345            this->positionReached();
[9348]346            bHasTargetOrientation_=false;
[8978]347        }
348    }
349
350
351
[9348]352    void FormationController::moveToTargetPosition()
[8978]353    {
354        this->moveToPosition(this->targetPosition_);
355    }
356
[9348]357    //copy the Roll orientation of given Quaternion.
358    void FormationController::copyOrientation(const Quaternion& orient)
[8978]359    {
360        //roll angle difference in radian
361        float diff=orient.getRoll(false).valueRadians()-(this->getControllableEntity()->getOrientation().getRoll(false).valueRadians());
362        while(diff>math::twoPi) diff-=math::twoPi;
363        while(diff<-math::twoPi) diff+=math::twoPi;
364        this->getControllableEntity()->rotateRoll(diff*ROTATEFACTOR_MASTER);
365    }
366
367    void FormationController::copyTargetOrientation()
368    {
369        if (bHasTargetOrientation_)
370        {
371            copyOrientation(targetOrientation_);
372        }
373    }
374
375
[9348]376    /**
[8978]377        @brief Unregisters a slave from its master. Initiated by a slave.
378    */
379    void FormationController::unregisterSlave()
380    {
381        if (this->myMaster_)
382        {
383            std::vector<FormationController*>::iterator it = std::find(this->myMaster_->slaves_.begin(), this->myMaster_->slaves_.end(), this);
384            if (it != this->myMaster_->slaves_.end())
385                this->myMaster_->slaves_.erase(it);
386        }
387
388        this->myMaster_ = 0;
389        this->state_ = FREE;
390    }
391
392    void FormationController::searchNewMaster()
393    {
[9255]394        if (this->state_==SLAVE)
[9005]395           return;
[8978]396        if (!this->getControllableEntity())
397            return;
398
399        this->targetPosition_ = this->getControllableEntity()->getPosition();
400        this->forgetTarget();
401        int teamSize = 0;
402        //go through all pawns
403        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
404        {
[9255]405
[8978]406            //same team?
407            Gametype* gt=this->getGametype();
408            if (!gt)
409            {
410                gt=it->getGametype();
411            }
412            if (!FormationController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(*it),gt))
413                continue;
414
415            //has it an FormationController?
416            Controller* controller = 0;
417
418            if (it->getController())
419                controller = it->getController();
420            else if (it->getXMLController())
421                controller = it->getXMLController();
422
423            if (!controller)
424                continue;
425
426            //is pawn oneself?
427            if (orxonox_cast<ControllableEntity*>(*it) == this->getControllableEntity())
428                continue;
429
430            teamSize++;
431
432            FormationController *newMaster = orxonox_cast<FormationController*>(controller);
433
434            //is it a master?
435            if (!newMaster || newMaster->state_ != MASTER)
436                continue;
437
438            float distance = (it->getPosition() - this->getControllableEntity()->getPosition()).length();
439
440            // is pawn in range?
441            if (distance < RADIUS_TO_SEARCH_FOR_MASTERS)
442            {
443                if(newMaster->slaves_.size() > this->maxFormationSize_) continue;
444
445                for(std::vector<FormationController*>::iterator itSlave = this->slaves_.begin(); itSlave != this->slaves_.end(); itSlave++)
446                {
447                    (*itSlave)->myMaster_ = newMaster;
448                    newMaster->slaves_.push_back(*itSlave);
449                }
450                this->slaves_.clear();
451                this->state_ = SLAVE;
452
453                this->myMaster_ = newMaster;
454                newMaster->slaves_.push_back(this);
455
456                break;
457            }
458        }
459
460        if (this->state_ != SLAVE  && teamSize != 0)
461        {
462            this->state_ = MASTER;
463            this->myMaster_ = 0;
464        }
465    }
[9348]466
467    /**
[8978]468        @brief Commands the slaves of a master into a formation. Sufficiently fast not to be called within tick. Initiated by a master.
469    */
[9348]470    void FormationController::commandSlaves()
[8978]471    {
472        if(this->state_ != MASTER) return;
473
474        Quaternion orient = this->getControllableEntity()->getOrientation();
475        Vector3 dest = this->getControllableEntity()->getPosition();
476
477        // 1 slave: follow
478        if (this->slaves_.size() == 1)
479        {
480            dest += 4*orient*WorldEntity::BACK;
481            this->slaves_.front()->setTargetPosition(dest);
482        }
483        else
[9348]484        // formation:
[8978]485        {
486            dest += 1.0f*orient*WorldEntity::BACK;
487            Vector3 pos = Vector3::ZERO;
[9348]488            bool left=true;
[8978]489            int i = 1;
[9255]490
[8978]491            for(std::vector<FormationController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
492            {
493                pos = Vector3::ZERO;
494                if (left)
495                {
496                    pos+=dest+i*FORMATION_WIDTH*(orient*WorldEntity::LEFT);
497                } else{
498                    pos+=dest+i*FORMATION_WIDTH*(orient*WorldEntity::RIGHT);
499                    i++;
500                    dest+=FORMATION_LENGTH*(orient*WorldEntity::BACK);
[9255]501                }
[8978]502                (*it)->setTargetOrientation(orient);
503                (*it)->setTargetPosition(pos);
504                left=!left;
505            }
506        }
507    }
508
509    /**
510        @brief Sets a new master within the formation. Called by a master.
511    */
512    void FormationController::setNewMasterWithinFormation()
513    {
514        if(this->state_ != MASTER) return;
515
516        if (!this->slaves_.empty())
517        {
518            FormationController *newMaster = this->slaves_.back();
519            this->slaves_.pop_back();
520
521            newMaster->state_ = MASTER;
522            newMaster->slaves_ = this->slaves_;
523            newMaster->myMaster_ = 0;
524
525            for(std::vector<FormationController*>::iterator it = newMaster->slaves_.begin(); it != newMaster->slaves_.end(); it++)
526            {
527                (*it)->myMaster_ = newMaster;
528            }
529        }
530
531        this->slaves_.clear();
532        this->specificMasterAction_ = NONE;
533        this->state_ = FREE;
534    }
535
536
537  /**
538        @brief Frees all slaves form a master. Initiated by a master.
539    */
540    void FormationController::freeSlaves()
541    {
542        if(this->state_ != MASTER) return;
543
544        for(std::vector<FormationController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
545        {
546            (*it)->state_ = FREE;
547            (*it)->myMaster_ = 0;
548        }
549        this->slaves_.clear();
550    }
551
552    /**
553        @brief Master sets its slaves free for @ref FREEDOM_COUNT seconds.
554    */
555    void FormationController::forceFreeSlaves()
556    {
557        if(this->state_ != MASTER) return;
558
559        for(std::vector<FormationController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
560        {
561            (*it)->state_ = FREE;
562            (*it)->forceFreedom();
563            (*it)->targetPosition_ = this->targetPosition_;
564            (*it)->bShooting_ = true;
565//             (*it)->getControllableEntity()->fire(0);// fire once for fun
566        }
567    }
568
569    void FormationController::loseMasterState()
570    {
571        this->freeSlaves();
572        this->state_ = FREE;
573    }
574
575
576    void FormationController::forceFreedom()
577    {
578        this->freedomCount_ = FREEDOM_COUNT;
579    }
580
581    /**
582        @brief Checks wether caller has been forced free, decrements time to stay forced free.
583        @return true if forced free.
584    */
585    bool FormationController::forcedFree()
586    {
587        if(this->freedomCount_ > 0)
588        {
589            this->freedomCount_--;
590            return true;
591        } else return false;
592    }
593
594
595    /**
596        @brief Call to take the lead of formation (if free, become slave of nearest formation, then, if Slave, become Master)
597    */
598    void FormationController::takeLeadOfFormation()
599    {
[9005]600        if (!this->getControllableEntity() || this->state_==MASTER)
[8978]601            return;
602
603        //search new Master, then take lead
[9005]604        if (this->state_==FREE && this->myMaster_==0)
[8978]605        {
606          searchNewMaster();
607        }
608
609        if (this->state_==SLAVE)  //become master of this formation
[9255]610        {
[8978]611            this->slaves_=this->myMaster_->slaves_;
612            this->myMaster_->slaves_.clear();
613            this->myMaster_->state_=SLAVE;
614            this->myMaster_->myMaster_=this;
[9255]615
[8978]616            //delete myself in slavelist
617            std::vector<FormationController*>::iterator it2 = std::find(this->slaves_.begin(), this->slaves_.end(), this);
618            if (it2 != this->slaves_.end())
619            {
620                 this->slaves_.erase(it2);
621            }
622            //add previous master
623            this->slaves_.push_back(this->myMaster_);
624            //set this as new master
625            for(std::vector<FormationController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
626            {
627                 (*it)->myMaster_=this;
628            }
629            this->myMaster_=0;
630            this->state_=MASTER;
631        }
632        /*/debug
633        if (this->state_==SLAVE)
634           {orxout(debug_output) << this << " is slave "<< endl;}
635        else if (this->state_==MASTER)
636           {orxout(debug_output) << this << " is now a master of "<<this->slaves_.size()<<" slaves."<< endl;}
637        if (this->state_==FREE)
638           {orxout(debug_output) << this << " is free "<< endl;}*/
639    }
640    /**
641      @brief if called, half of the formation will attack the originator
642    */
643    void FormationController::masterAttacked(Pawn* originator)
644    {
645       if (this->state_!=MASTER) return;
646       unsigned int i=0;
647       for(std::vector<FormationController*>::reverse_iterator it = slaves_.rbegin(); it != slaves_.rend(); it++)
648       {
649           if ((*it)->state_!=FREE)
650           {
651               (*it)->state_=FREE;
652               (*it)->forceFreedom();
653               (*it)->target_=originator;
654           }
655           i++;
656           if (i>=slaves_.size()/2) break; //half the formation should attack.
657       }
[9255]658    }
[8978]659
660
661    /**
662      @brief Sets the new mode. If master, set it for all slaves.
663    */
[8991]664    void FormationController::setFormationMode(FormationMode val)
[8978]665    {
[8991]666        this->formationMode_ = val;
667        if (this->state_ == MASTER)
[8978]668        {
669            for(std::vector<FormationController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
670            {
[8991]671                 (*it)->formationMode_ = val;
672                 if (val == ATTACK)
[8978]673                     (*it)->forgetTarget();
674            }
675        }
676    }
677
678    /**
679        @brief Used to continue a "specific master action" for a certain time and resuming normal behaviour after.
680    */
681    void FormationController::specificMasterActionHold()
682    {
683        if(this->state_ != MASTER) return;
684
685        if (specificMasterActionHoldCount_ == 0)
[9348]686        {
[8978]687            this->specificMasterAction_ = NONE;
688            this->searchNewTarget();
[9348]689        }
690        else
691            specificMasterActionHoldCount_--;
[8978]692    }
693
694    /**
695        @brief Master initializes a 180 degree turn. Leads to a "specific master action".
696    */
697    void FormationController::turn180Init()
698    {
699        if(this->state_ != MASTER) return;
700
701        Quaternion orient = this->getControllableEntity()->getOrientation();
702
703        this->setTargetPosition(this->getControllableEntity()->getPosition() + 1000.0f*orient*WorldEntity::BACK);
704
705        this->specificMasterActionHoldCount_ = 4;
706
707        this->specificMasterAction_ = TURN180;
708    }
709
710    /**
711        @brief Execute the 180 degree turn. Called within tick.
712    */
713    void FormationController::turn180()
714    {
[9348]715        Vector2 coord = get2DViewdirection(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, this->targetPosition_);
[8978]716
[9348]717        this->getControllableEntity()->rotateYaw(-2.0f * sgn(coord.x) * coord.x*coord.x);
718        this->getControllableEntity()->rotatePitch(2.0f * sgn(coord.y) * coord.y*coord.y);
[8978]719
[9348]720        this->getControllableEntity()->moveFrontBack(SPEED_MASTER);
[8978]721    }
722
723    /**
724        @brief Master initializes a spin around its looking direction axis. Leads to a "specific master action".
725    */
726    void FormationController::spinInit()
727    {
728        if(this->state_ != MASTER) return;
729        this->specificMasterAction_ = SPIN;
730        this->specificMasterActionHoldCount_ = 10;
731    }
732
733    /**
734        @brief Execute the spin. Called within tick.
735    */
736    void FormationController::spin()
737    {
[9348]738        this->moveToTargetPosition();
739        this->getControllableEntity()->rotateRoll(0.8f);
[8978]740    }
741
742  /**
743        @brief A human player gets followed by its nearest master. Initiated by console command, so far intended for demonstration puproses (possible future pickup).
744    */
745    void FormationController::followme()
746    {
747
748        Pawn *humanPawn = NULL;
749        NewHumanController *currentHumanController = NULL;
750        std::vector<FormationController*> allMasters;
751
752        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
753        {
754            Controller* controller = 0;
755
756            if (it->getController())
757                controller = it->getController();
758            else if (it->getXMLController())
759                controller = it->getXMLController();
760
761            if (!controller)
762                continue;
763
764            currentHumanController = orxonox_cast<NewHumanController*>(controller);
765
766            if(currentHumanController) humanPawn = *it;
767
768            FormationController *aiController = orxonox_cast<FormationController*>(controller);
769
770            if(aiController && aiController->state_ == MASTER)
771                allMasters.push_back(aiController);
772
773        }
774
775        if((humanPawn != NULL) && (allMasters.size() != 0))
776        {
[9348]777            float posHuman = humanPawn->getPosition().length();
778            float distance = 0.0f;
779            float minDistance = FLT_MAX;
780            int index = 0;
781            int i = 0;
[8978]782
[9348]783            for(std::vector<FormationController*>::iterator it = allMasters.begin(); it != allMasters.end(); it++, i++)
784            {
785                if (!FormationController::sameTeam((*it)->getControllableEntity(), humanPawn, (*it)->getGametype())) continue;
786                distance = posHuman - (*it)->getControllableEntity()->getPosition().length();
787                if(distance < minDistance) index = i;
[8978]788            }
[9348]789            allMasters[index]->followInit(humanPawn);
790        }
[8978]791    }
792
793    /**
794        @brief Master begins to follow a pawn. Is a "specific master action".
795        @param pawn pawn to follow.
796        @param always follows pawn forever if true (false if omitted).
797        @param secondsToFollow seconds to follow the pawn if always is false. Will follow pawn 100 seconds if omitted (set in header).
798    */
799    void FormationController::followInit(Pawn* pawn, const bool always, const int secondsToFollow)
800    {
801        if (pawn == NULL || this->state_ != MASTER)
802            return;
803        this->specificMasterAction_  =  FOLLOW;
804
805        this->setTarget(pawn);
806        if (!always)
807            this->specificMasterActionHoldCount_ = secondsToFollow;
808        else
809            this->specificMasterActionHoldCount_ = INT_MAX; //for now...
810
811    }
812
[9348]813    /**
[8978]814        @brief Master begins to follow a randomly chosen human player of the same team. Is a "specific master action".
815    */
816    void FormationController::followRandomHumanInit()
817    {
818
819        Pawn *humanPawn = NULL;
820        NewHumanController *currentHumanController = NULL;
821
822        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
823        {
824            if (!it->getController())
825                continue;
826
827            currentHumanController = orxonox_cast<NewHumanController*>(it->getController());
828            if(currentHumanController)
829            {
830                if (!FormationController::sameTeam(this->getControllableEntity(), *it, this->getGametype())) continue;
831                humanPawn = *it;
832                break;
833            }
834        }
835
836        if((humanPawn != NULL))
837                this->followInit(humanPawn);
838    }
839
840
[9348]841    /**
[8978]842        @brief Master follows target with adjusted speed. Called within tick.
843    */
844    void FormationController::follow()
845    {
846        if (this->target_)
847            this->moveToPosition(this->target_->getPosition());
848        else
849            this->specificMasterActionHoldCount_ = 0;
850    }
851
852
[9348]853    void FormationController::setTargetPosition(const Vector3& target)
[8978]854    {
855        this->targetPosition_ = target;
856        this->bHasTargetPosition_ = true;
857    }
858
859    void FormationController::searchRandomTargetPosition()
860    {
861        this->targetPosition_ = Vector3(rnd(-2000,2000), rnd(-2000,2000), rnd(-2000,2000));
862        this->bHasTargetPosition_ = true;
863    }
864
865    void FormationController::setTargetOrientation(const Quaternion& orient)
866    {
[9255]867        this->targetOrientation_=orient;
[8978]868        this->bHasTargetOrientation_=true;
869    }
870
871    void FormationController::setTargetOrientation(Pawn* target)
872    {
873        if (target)
874            setTargetOrientation(target->getOrientation());
875    }
876
877    void FormationController::setTarget(Pawn* target)
878    {
879        this->target_ = target;
880
881        if (target)
882            this->targetPosition_ = target->getPosition();
883    }
884
885    void FormationController::searchNewTarget()
886    {
887        if (!this->getControllableEntity())
888            return;
889
890        this->targetPosition_ = this->getControllableEntity()->getPosition();
891        this->forgetTarget();
892
893        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
894        {
895            if (FormationController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(*it), this->getGametype()))
896                continue;
897
898            /* So AI won't choose invisible Spaceships as target */
899            if (!it->getRadarVisibility())
900                continue;
901
902            if (static_cast<ControllableEntity*>(*it) != this->getControllableEntity())
903            {
904                float speed = this->getControllableEntity()->getVelocity().length();
905                Vector3 distanceCurrent = this->targetPosition_ - this->getControllableEntity()->getPosition();
906                Vector3 distanceNew = it->getPosition() - this->getControllableEntity()->getPosition();
907                if (!this->target_ || it->getPosition().squaredDistance(this->getControllableEntity()->getPosition()) * (1.5f + acos((this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).dotProduct(distanceNew) / speed / distanceNew.length()) / math::twoPi)
908                        < this->targetPosition_.squaredDistance(this->getControllableEntity()->getPosition()) * (1.5f + acos((this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).dotProduct(distanceCurrent) / speed / distanceCurrent.length()) / math::twoPi) + rnd(-250, 250))
909                {
910                    this->target_ = (*it);
911                    this->targetPosition_ = it->getPosition();
912                }
913            }
914        }
915    }
916
[9348]917    void FormationController::forgetTarget()
[8978]918    {
919        this->target_ = 0;
920        this->bShooting_ = false;
921    }
922
[9348]923    void FormationController::targetDied()
[8978]924    {
925        this->forgetTarget();
926        this->searchRandomTargetPosition();
927    }
928
[9348]929    bool FormationController::sameTeam(ControllableEntity* entity1, ControllableEntity* entity2, Gametype* gametype)
[8978]930    {
931        if (entity1 == entity2)
932            return true;
933
934        int team1 = -1;
935        int team2 = -1;
936
937        Controller* controller = 0;
938        if (entity1->getController())
939            controller = entity1->getController();
940        else
941            controller = entity1->getXMLController();
942        if (controller)
943        {
944            FormationController* ac = orxonox_cast<FormationController*>(controller);
945            if (ac)
946                team1 = ac->getTeam();
947        }
948
949        if (entity2->getController())
950            controller = entity2->getController();
951        else
952            controller = entity2->getXMLController();
953        if (controller)
954        {
955            FormationController* ac = orxonox_cast<FormationController*>(controller);
956            if (ac)
957                team2 = ac->getTeam();
958        }
959
960        TeamDeathmatch* tdm = orxonox_cast<TeamDeathmatch*>(gametype);
961        if (tdm)
962        {
963            if (entity1->getPlayer())
964                team1 = tdm->getTeam(entity1->getPlayer());
965
966            if (entity2->getPlayer())
967                team2 = tdm->getTeam(entity2->getPlayer());
968        }
969
[8992]970        Mission* miss = orxonox_cast<Mission*>(gametype);
[8989]971        if (miss)
972        {
973            if (entity1->getPlayer())
974                team1 = miss->getTeam(entity1->getPlayer());
975
976            if (entity2->getPlayer())
977                team2 = miss->getTeam(entity2->getPlayer());
[8992]978        }
[8989]979
[8978]980        TeamBaseMatchBase* base = 0;
981        base = orxonox_cast<TeamBaseMatchBase*>(entity1);
982        if (base)
983        {
984            switch (base->getState())
985            {
986                case BaseState::ControlTeam1:
987                    team1 = 0;
988                    break;
989                case BaseState::ControlTeam2:
990                    team1 = 1;
991                    break;
992                case BaseState::Uncontrolled:
993                default:
994                    team1 = -1;
995            }
996        }
997        base = orxonox_cast<TeamBaseMatchBase*>(entity2);
998        if (base)
999        {
1000            switch (base->getState())
1001            {
1002                case BaseState::ControlTeam1:
1003                    team2 = 0;
1004                    break;
1005                case BaseState::ControlTeam2:
1006                    team2 = 1;
1007                    break;
1008                case BaseState::Uncontrolled:
1009                default:
1010                    team2 = -1;
1011            }
1012        }
1013
1014        DroneController* droneController = 0;
1015        droneController = orxonox_cast<DroneController*>(entity1->getController());
1016        if (droneController && static_cast<ControllableEntity*>(droneController->getOwner()) == entity2)
1017            return true;
1018        droneController = orxonox_cast<DroneController*>(entity2->getController());
1019        if (droneController && static_cast<ControllableEntity*>(droneController->getOwner()) == entity1)
1020            return true;
1021        DroneController* droneController1 = orxonox_cast<DroneController*>(entity1->getController());
1022        DroneController* droneController2 = orxonox_cast<DroneController*>(entity2->getController());
1023        if (droneController1 && droneController2 && droneController1->getOwner() == droneController2->getOwner())
1024            return true;
1025
1026        Dynamicmatch* dynamic = orxonox_cast<Dynamicmatch*>(gametype);
1027        if (dynamic)
1028        {
1029            if (dynamic->notEnoughPigs||dynamic->notEnoughKillers||dynamic->notEnoughChasers) {return false;}
1030
1031            if (entity1->getPlayer())
1032                team1 = dynamic->getParty(entity1->getPlayer());
1033
1034            if (entity2->getPlayer())
1035                team2 = dynamic->getParty(entity2->getPlayer());
1036
1037            if (team1 ==-1 ||team2 ==-1 ) {return false;}
1038            else if (team1 == dynamic->chaser && team2 != dynamic->chaser) {return false;}
1039            else if (team1 == dynamic->piggy && team2 == dynamic->chaser) {return false;}
1040            else if (team1 == dynamic->killer && team2 == dynamic->chaser) {return false;}
1041            else return true;
1042        }
1043
1044        return (team1 == team2 && team1 != -1);
1045    }
1046
[8992]1047    void FormationController::absoluteMoveToPosition(const Vector3& target)
1048    {
1049        float minDistance = 40.0f;
1050        if (!this->getControllableEntity())
1051            return;
1052
[9348]1053        Vector2 coord = get2DViewcoordinates(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
[8992]1054        float distance = (target - this->getControllableEntity()->getPosition()).length();
1055
1056            if (this->target_ || distance > minDistance)
1057            {
1058                // Multiply with ROTATEFACTOR_FREE to make them a bit slower
[9348]1059                this->getControllableEntity()->rotateYaw(-1.0f * ROTATEFACTOR_FREE * clamp(coord.x * 10, -1.0f, 1.0f));
1060                this->getControllableEntity()->rotatePitch(ROTATEFACTOR_FREE * clamp(coord.y * 10, -1.0f, 1.0f));
[8992]1061                this->getControllableEntity()->moveFrontBack(SPEED_FREE);
1062            }
1063
1064
1065        if (distance < minDistance)
1066        {
1067            this->positionReached();
1068        }
1069    }
1070
[8978]1071}
Note: See TracBrowser for help on using the repository browser.