Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/MouseAPI_FS19/src/orxonox/controllers/FightingController.cc @ 12412

Last change on this file since 12412 was 11083, checked in by muemart, 9 years ago

Fix some clang-tidy warnings.
Also, Serialise.h was doing some C-style casts that ended up being const casts. I moved those const casts as close to the source as possible and changed the loadAndIncrease functions to not do that.

  • Property svn:eol-style set to native
File size: 12.3 KB
Line 
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:
23 *      Gani Aliguzhinov
24 *   Co-authors:
25 *      Fabian 'x3n' Landau, Dominik Solenicki
26 *
27 */
28#include "controllers/FightingController.h"
29#include "util/Math.h"
30
31
32#include "worldentities/pawns/SpaceShip.h"
33
34#include "weaponsystem/WeaponMode.h"
35#include "weaponsystem/WeaponPack.h"
36#include "weaponsystem/Weapon.h"
37#include "weaponsystem/WeaponSlot.h"
38#include "weaponsystem/WeaponSystem.h"
39#include "weaponsystem/Munition.h"
40
41namespace orxonox
42{
43
44    RegisterClass (FightingController);
45   
46    FightingController::FightingController( Context* context ): FlyingController( context )
47    {
48        this->attackRange_ = 2500;
49        this->stopLookingAtTarget();
50        this->bSetupWorked = false;
51        this->timeout_ = 0;
52        RegisterObject( FightingController );
53    }
54    FightingController::~FightingController() 
55    {
56       
57    }
58    void FightingController::lookAtTarget(float dt)
59    {
60        if (!this->getControllableEntity())
61            return;
62        ControllableEntity* entity = this->getControllableEntity();
63        if ( !entity )
64            return;
65        Vector2 coord = get2DViewCoordinates
66            ( entity->getPosition() , 
67            entity->getOrientation()  * WorldEntity::FRONT, 
68            entity->getOrientation()  * WorldEntity::UP, 
69            positionOfTarget_ );
70
71        //rotates should be in range [-1,+1], clamp cuts off all that is not
72        float rotateX = -clamp( coord.x * 10, -1.0f, 1.0f );
73        float rotateY = clamp( coord.y * 10, -1.0f, 1.0f ); 
74   
75        //Yaw and Pitch are enough to start facing the target
76        this->getControllableEntity() ->rotateYaw( ROTATEFACTOR * rotateX * dt );
77        this->getControllableEntity() ->rotatePitch( ROTATEFACTOR * rotateY * dt );
78    }
79    void FightingController::stopLookingAtTarget()
80    {
81        this->bLookAtTarget_ = false;
82    }
83    void FightingController::startLookingAtTarget()
84    {
85        this->bLookAtTarget_ = true;
86    }
87    bool FightingController::hasTarget() const
88    {
89        if ( this->target_ )
90            return true;
91        return false;
92    }
93
94    void FightingController::setTarget( ControllableEntity* target )
95    {
96        this->target_ = target;       
97        if ( this->target_ )
98        {
99            this->setPositionOfTarget( target_->getWorldPosition() );
100        }
101    }
102    void FightingController::setPositionOfTarget( const Vector3& target )
103    {
104        this->positionOfTarget_ = target;
105        this->bHasPositionOfTarget_ = true;
106    }
107    void FightingController::setOrientationOfTarget( const Quaternion& orient )
108    {
109        this->orientationOfTarget_=orient;
110        this->bHasOrientationOfTarget_=true;
111    }
112   
113    void FightingController::maneuver() 
114    {
115        if ( !this->target_ || !this->getControllableEntity())
116            return;
117
118
119        Vector3 thisPosition = this->getControllableEntity()->getWorldPosition();
120        this->setPositionOfTarget(this->target_->getWorldPosition());
121        //this->setOrientationOfTarget(this->target_->getOrientation());
122        Vector3 diffVector = this->positionOfTarget_ - thisPosition;
123        float diffLength = diffVector.length();
124        Vector3 diffUnit = diffVector/diffLength;
125
126        //too far? well, come closer then
127        if (diffLength > this->attackRange_)
128        {
129            this->spread_ = 400;
130            this->formationMode_ = FormationMode::DIAMOND;
131            this->bKeepFormation_ = true;
132           
133            this->setTargetPosition(this->positionOfTarget_ - diffUnit * 100.0f);
134        }
135        else
136        {   
137            bool bTargetIsLookingAtThis = CommonController::isLooking (this->target_, this->getControllableEntity(), math::pi/20.0f)
138                || this->deltaHp < 0;
139            this->bKeepFormation_ = false;
140
141            if (!this->bDodge_)
142            {
143                this->bStartedDodging_ = false;
144
145                this->setTargetPosition(this->positionOfTarget_ - diffUnit * 50.0f);   
146                return;
147            }
148            else if (bTargetIsLookingAtThis || diffLength < 700.0f)
149            {
150                if (!this->bStartedDodging_)
151                {
152                    this->bStartedDodging_ = true;
153                    dodge(thisPosition, diffLength, diffUnit);       
154                }
155            }
156            else
157            {
158                if (diffLength < 1000)
159                {
160                    this->stopMoving();
161                    this->startLookingAtTarget();
162
163                }
164                else
165                {
166                    this->setTargetPosition(this->positionOfTarget_ - diffUnit * 300.0f);
167                }
168            }
169        }
170    }
171   
172    void FightingController::dodge(const Vector3& thisPosition, float diffLength, Vector3& diffUnit)
173    {
174        //d.x*x + d.y*y + d.z*z == 0
175        //z = 1/d.z * (-d.y*y - d.x * x)
176        float x = CommonController::randomInRange (300, 800) * (CommonController::randomInRange(0,1) <= 0.5 ? 1 : -1);
177        float y = CommonController::randomInRange (300, 800) * (CommonController::randomInRange(0,1) <= 0.5 ? 1 : -1);
178        float z = diffUnit.z == 0 ? 0 : (1/diffUnit.z) * (-x * diffUnit.x - y * diffUnit.y);
179        if (diffLength < 150.0f)
180        {
181            this->setTargetPosition(this->positionOfTarget_ + Vector3(z,x,y));
182        }
183        else
184        {
185        this->setTargetPosition(thisPosition + Vector3(x,y,z) + (this->deltaHp < 0 ? -diffUnit * 450.0f : 
186            (diffLength < 700.0f ? -diffUnit*700.0f : diffUnit * 50.0f)));
187
188        }
189        this->boostControl();
190
191    }
192    bool FightingController::canFire() 
193    {
194        //no target? why fire?
195        if (!this->target_ || !this->getControllableEntity())
196            return false;
197        Vector3 newPositionOfTarget = getPredictedPosition(this->getControllableEntity()->getWorldPosition(), 
198                                                           HARDCODED_PROJECTILE_SPEED, this->target_->getWorldPosition(),
199                                                           this->target_->getVelocity());
200        if (!this->target_ || !this->getControllableEntity())
201            return false;
202        //Vector3.isNaN() is what I used on my machine and it worked...
203        if (!(std::isnan(newPositionOfTarget.x) || std::isnan(newPositionOfTarget.y) || std::isnan(newPositionOfTarget.z)))
204        {
205            this->setPositionOfTarget(newPositionOfTarget);
206        }
207
208        return squaredDistanceToTarget() < this->attackRange_*this->attackRange_ && this->isLookingAtTarget(math::pi / 20.0f);
209    }
210
211
212    float FightingController::squaredDistanceToTarget()  const
213    {
214        if (!this->getControllableEntity())
215            return 0;
216        if (!this->target_ || !this->getControllableEntity())
217            return (this->getControllableEntity()->getPosition().squaredDistance(this->targetPosition_));
218        else
219            return (this->getControllableEntity()->getPosition().squaredDistance(this->positionOfTarget_));
220    }
221    bool FightingController::isLookingAtTarget( float angle ) const
222    {
223        if ( !this->getControllableEntity()  || !this->target_ )
224            return false;
225        return CommonController::isLooking(this->getControllableEntity(), this->getTarget(), angle);
226    }
227    void FightingController::setClosestTarget()
228    {
229        this->setTarget (static_cast<ControllableEntity*>( closestTarget() ) ); 
230    }
231   
232    Pawn* FightingController::closestTarget() const
233    {
234        if (!this->getControllableEntity())
235            return nullptr;
236
237        Pawn* closestTarget = nullptr;
238        float minDistance =  std::numeric_limits<float>::infinity();
239        Gametype* gt = this->getGametype();
240        for (Pawn* pawn : ObjectList<Pawn>())
241        {
242            if ( CommonController::sameTeam (this->getControllableEntity(), static_cast<ControllableEntity*>(pawn), gt) )
243                continue;
244
245            float distance = CommonController::distance (pawn, this->getControllableEntity());
246            if (distance < minDistance)
247            {
248                closestTarget = pawn;
249                minDistance = distance;
250            }
251        }
252        if (closestTarget)
253        {
254           return closestTarget;
255        } 
256        return nullptr;
257    }
258    //I checked it out, rockets DO NOT cause any problems! this->getControllableEntity() is always a SpaceShip
259    void FightingController::doFire()
260    {
261        if (!this->bSetupWorked)
262        {
263            this->setupWeapons();
264        }
265        if (!this->target_ || !this->getControllableEntity())
266        {
267            return;
268        }
269
270        Pawn* pawn = orxonox_cast<Pawn*> (this->getControllableEntity());
271        if (pawn)
272            pawn->setAimPosition (this->positionOfTarget_);
273
274        int firemode;
275        float distance = CommonController::distance (this->getControllableEntity(), this->target_);
276
277
278       
279        if (distance < 1500)
280        {
281            if (this->rocketsLeft_ > 0 && !this->bFiredRocket_)
282            {
283                firemode = getFiremode ("RocketFire");
284            }
285            else
286            {
287                if (distance > 800)
288                    firemode = getFiremode ("HsW01");
289                else
290                    firemode = getFiremode ("LightningGun");
291            }
292
293        } 
294   
295
296        else if (distance < 2000)
297        {
298            firemode = getFiremode ("HsW01");
299        }
300        else
301        {
302            firemode = getFiremode ("LightningGun");
303        }
304        if (firemode < 0)
305        {
306            //assuming there is always some weapon with index 0
307            firemode = 0;
308        }
309        if (firemode == getFiremode("RocketFire"))
310        {
311            this->timeout_ = 5;
312            this->rocketsLeft_--;
313            this->bFiredRocket_ = true;
314        }
315        if (firemode == getFiremode("SimpleRocketFire"))
316        {
317            this->rocketsLeft_--;
318        }
319             
320        this->getControllableEntity()->fire(firemode);
321       
322    }
323    void FightingController::setupWeapons() //TODO: Make this function generic!! (at the moment is is based on conventions)
324    {
325        this->bSetupWorked = false;
326        if(this->getControllableEntity())
327        {
328            Pawn* pawn = orxonox_cast<Pawn*>(this->getControllableEntity());
329            if(pawn && pawn->isA(Class(SpaceShip))) //fix for First Person Mode: check for SpaceShip
330            {
331                this->weaponModes_.clear(); // reset previous weapon information
332                WeaponSlot* wSlot = nullptr;
333                for(int l=0; (wSlot = pawn->getWeaponSlot(l)) ; l++)
334                {
335                    WeaponMode* wMode = nullptr;
336                    for(int i=0; (wMode = wSlot->getWeapon()->getWeaponmode(i)) ; i++)
337                    {
338                        std::string wName = wMode->getIdentifier()->getName();
339                        // SubclassIdentifier<Munition> munition =  ClassByString(wName);
340                        if (wName == "RocketFire")
341                            this->rocketsLeft_ = 10;
342                        if(this->getFiremode(wName) == -1) //only add a weapon, if it is "new"
343                            weaponModes_[wName] = wMode->getMode();
344                    }
345                }
346                if(weaponModes_.size())//at least one weapon detected
347                    this->bSetupWorked = true;
348            }
349        }
350
351    }
352
353    int FightingController::getFiremode(const std::string& name)
354    {
355        for (const auto& mapEntry : this->weaponModes_)
356        {
357            if (mapEntry.first == name)
358                return mapEntry.second;
359        }
360        return -1;
361    }
362}
Note: See TracBrowser for help on using the repository browser.