src/game/ThreatManager.cpp

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "ThreatManager.h"
  20 #include "Unit.h"
  21 #include "Creature.h"
  22 #include "CreatureAI.h"
  23 #include "Map.h"
  24 #include "Player.h"
  25 #include "ObjectAccessor.h"
  26 #include "UnitEvents.h"
  27
  28 //==============================================================
  29 //================= ThreatCalcHelper ===========================
  30 //==============================================================
  31
  32 // The pHatingUnit is not used yet
  33 float ThreatCalcHelper::calcThreat(Unit* pHatedUnit, Unit* pHatingUnit, float pThreat, SpellSchoolMask schoolMask, SpellEntry const *pThreatSpell)
  34 {
  35     if(pThreatSpell)
  36     {
  37         if( Player* modOwner = pHatingUnit->GetSpellModOwner() )
  38             modOwner->ApplySpellMod(pThreatSpell->Id, SPELLMOD_THREAT, pThreat);
  39     }
  40
  41     float threat = pHatedUnit->ApplyTotalThreatModifier(pThreat, schoolMask);
  42     return threat;
  43 }
  44
  45 //============================================================
  46 //================= HostilReference ==========================
  47 //============================================================
  48
  49 HostilReference::HostilReference(Unit* pUnit, ThreatManager *pThreatManager, float pThreat)
  50 {
  51     iThreat = pThreat;
  52     iTempThreatModifyer = 0.0f;
  53     link(pUnit, pThreatManager);
  54     iUnitGuid = pUnit->GetGUID();
  55     iOnline = true;
  56     iAccessible = true;
  57 }
  58
  59 //============================================================
  60 // Tell our refTo (target) object that we have a link
  61 void HostilReference::targetObjectBuildLink()
  62 {
  63     getTarget()->addHatedBy(this);
  64 }
  65
  66 //============================================================
  67 // Tell our refTo (taget) object, that the link is cut
  68 void HostilReference::targetObjectDestroyLink()
  69 {
  70     getTarget()->removeHatedBy(this);
  71 }
  72
  73 //============================================================
  74 // Tell our refFrom (source) object, that the link is cut (Target destroyed)
  75
  76 void HostilReference::sourceObjectDestroyLink()
  77 {
  78     setOnlineOfflineState(false);
  79 }
  80
  81 //============================================================
  82 // Inform the source, that the status of the reference changed
  83
  84 void HostilReference::fireStatusChanged(const ThreatRefStatusChangeEvent& pThreatRefStatusChangeEvent)
  85 {
  86     if(getSource())
  87         getSource()->processThreatEvent(&pThreatRefStatusChangeEvent);
  88 }
  89
  90 //============================================================
  91
  92 void HostilReference::addThreat(float pMod)
  93 {
  94     iThreat += pMod;
  95     // the threat is changed. Source and target unit have to be availabe
  96     // if the link was cut before relink it again
  97     if(!isOnline())
  98         updateOnlineStatus();
  99     if(pMod != 0.0f)
 100         fireStatusChanged(ThreatRefStatusChangeEvent(UEV_THREAT_REF_THREAT_CHANGE, this, pMod));
 101     if(isValid() && pMod >= 0)
 102     {
 103         Unit* victim_owner = getTarget()->GetOwner();
 104         if(victim_owner && victim_owner->isAlive())
 105             getSource()->addThreat(victim_owner, 0.0f);     // create a threat to the owner of a pet, if the pet attacks
 106     }
 107 }
 108
 109 //============================================================
 110 // check, if source can reach target and set the status
 111
 112 void HostilReference::updateOnlineStatus()
 113 {
 114     bool online = false;
 115     bool accessible = false;
 116
 117     if(!isValid())
 118     {
 119         Unit* target = ObjectAccessor::GetUnit(*getSourceUnit(), getUnitGuid());
 120         if(target)
 121             link(target, getSource());
 122     }
 123     // only check for online status if
 124     // ref is valid
 125     // target is no player or not gamemaster
 126     // target is not in flight
 127     if(isValid() &&
 128         ((getTarget()->GetTypeId() != TYPEID_PLAYER || !((Player*)getTarget())->isGameMaster()) ||
 129         !getTarget()->hasUnitState(UNIT_STAT_IN_FLIGHT)))
 130     {
 131         Creature* creature = (Creature* ) getSourceUnit();
 132         online = getTarget()->isInAccessablePlaceFor(creature);
 133         if(!online)
 134         {
 135             if(creature->AI()->canReachByRangeAttack(getTarget()))
 136                 online = true;                              // not accessable but stays online
 137         }
 138         else
 139             accessible = true;
 140
 141     }
 142     setAccessibleState(accessible);
 143     setOnlineOfflineState(online);
 144 }
 145
 146 //============================================================
 147 // set the status and fire the event on status change
 148
 149 void HostilReference::setOnlineOfflineState(bool pIsOnline)
 150 {
 151     if(iOnline != pIsOnline)
 152     {
 153         iOnline = pIsOnline;
 154         if(!iOnline)
 155             setAccessibleState(false);                      // if not online that not accessable as well
 156         fireStatusChanged(ThreatRefStatusChangeEvent(UEV_THREAT_REF_ONLINE_STATUS, this));
 157     }
 158 }
 159
 160 //============================================================
 161
 162 void HostilReference::setAccessibleState(bool pIsAccessible)
 163 {
 164     if(iAccessible != pIsAccessible)
 165     {
 166         iAccessible = pIsAccessible;
 167         fireStatusChanged(ThreatRefStatusChangeEvent(UEV_THREAT_REF_ASSECCIBLE_STATUS, this));
 168     }
 169 }
 170
 171 //============================================================
 172 // prepare the reference for deleting
 173 // this is called be the target
 174
 175 void HostilReference::removeReference()
 176 {
 177     invalidate();
 178     fireStatusChanged(ThreatRefStatusChangeEvent(UEV_THREAT_REF_REMOVE_FROM_LIST, this));
 179 }
 180
 181 //============================================================
 182
 183 Unit* HostilReference::getSourceUnit()
 184 {
 185     return (getSource()->getOwner());
 186 }
 187
 188 //============================================================
 189 //================ ThreatContainer ===========================
 190 //============================================================
 191
 192 void ThreatContainer::clearReferences()
 193 {
 194     for(std::list<HostilReference*>::iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
 195     {
 196         (*i)->unlink();
 197         delete (*i);
 198     }
 199     iThreatList.clear();
 200 }
 201
 202 //============================================================
 203 // Return the HostilReference of NULL, if not found
 204 HostilReference* ThreatContainer::getReferenceByTarget(Unit* pVictim)
 205 {
 206     HostilReference* result = NULL;
 207     uint64 guid = pVictim->GetGUID();
 208     for(std::list<HostilReference*>::iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
 209     {
 210         if((*i)->getUnitGuid() == guid)
 211         {
 212             result = (*i);
 213             break;
 214         }
 215     }
 216
 217     return result;
 218 }
 219
 220 //============================================================
 221 // Add the threat, if we find the reference
 222
 223 HostilReference* ThreatContainer::addThreat(Unit* pVictim, float pThreat)
 224 {
 225     HostilReference* ref = getReferenceByTarget(pVictim);
 226     if(ref)
 227         ref->addThreat(pThreat);
 228     return ref;
 229 }
 230
 231 //============================================================
 232
 233 void ThreatContainer::modifyThreatPercent(Unit *pVictim, int32 pPercent)
 234 {
 235     if(HostilReference* ref = getReferenceByTarget(pVictim))
 236         ref->addThreatPercent(pPercent);
 237 }
 238
 239 //============================================================
 240
 241 bool HostilReferenceSortPredicate(const HostilReference* lhs, const HostilReference* rhs)
 242 {
 243     // std::list::sort ordering predicate must be: (Pred(x,y)&&Pred(y,x))==false
 244     return lhs->getThreat() > rhs->getThreat();             // reverse sorting
 245 }
 246
 247 //============================================================
 248 // Check if the list is dirty and sort if necessary
 249
 250 void ThreatContainer::update()
 251 {
 252     if(iDirty && iThreatList.size() >1)
 253     {
 254         iThreatList.sort(HostilReferenceSortPredicate);
 255     }
 256     iDirty = false;
 257 }
 258
 259 //============================================================
 260 // return the next best victim
 261 // could be the current victim
 262
 263 HostilReference* ThreatContainer::selectNextVictim(Creature* pAttacker, HostilReference* pCurrentVictim)
 264 {
 265     HostilReference* currentRef = NULL;
 266     bool found = false;
 267     bool noPriorityTargetFound = false;
 268
 269     std::list<HostilReference*>::iterator lastRef = iThreatList.end();
 270     lastRef--;
 271
 272     for(std::list<HostilReference*>::iterator iter = iThreatList.begin(); iter != iThreatList.end() && !found;)
 273     {
 274         currentRef = (*iter);
 275
 276         Unit* target = currentRef->getTarget();
 277         assert(target);                                     // if the ref has status online the target must be there !
 278
 279         // some units are prefered in comparison to others
 280         if(!noPriorityTargetFound && (target->IsImmunedToDamage(pAttacker->GetMeleeDamageSchoolMask()) || target->hasNegativeAuraWithInterruptFlag(AURA_INTERRUPT_FLAG_DAMAGE)) )
 281         {
 282             if(iter != lastRef)
 283             {
 284                 // current victim is a second choice target, so don't compare threat with it below
 285                 if(currentRef == pCurrentVictim)
 286                     pCurrentVictim = NULL;
 287                 ++iter;
 288                 continue;
 289             }
 290             else
 291             {
 292                 // if we reached to this point, everyone in the threatlist is a second choice target. In such a situation the target with the highest threat should be attacked.
 293                 noPriorityTargetFound = true;
 294                 iter = iThreatList.begin();
 295                 continue;
 296             }
 297         }
 298
 299         if(!pAttacker->IsOutOfThreatArea(target))           // skip non attackable currently targets
 300         {
 301             if(pCurrentVictim)                              // select 1.3/1.1 better target in comparison current target
 302             {
 303                 // list sorted and and we check current target, then this is best case
 304                 if(pCurrentVictim == currentRef || currentRef->getThreat() <= 1.1f * pCurrentVictim->getThreat() )
 305                 {
 306                     currentRef = pCurrentVictim;            // for second case
 307                     found = true;
 308                     break;
 309                 }
 310
 311                 if( currentRef->getThreat() > 1.3f * pCurrentVictim->getThreat() ||
 312                     currentRef->getThreat() > 1.1f * pCurrentVictim->getThreat() && pAttacker->IsWithinDistInMap(target, ATTACK_DISTANCE) )
 313                 {                                           //implement 110% threat rule for targets in melee range
 314                     found = true;                           //and 130% rule for targets in ranged distances
 315                     break;                                  //for selecting alive targets
 316                 }
 317             }
 318             else                                            // select any
 319             {
 320                 found = true;
 321                 break;
 322             }
 323         }
 324         ++iter;
 325     }
 326     if(!found)
 327         currentRef = NULL;
 328
 329     return currentRef;
 330 }
 331
 332 //============================================================
 333 //=================== ThreatManager ==========================
 334 //============================================================
 335
 336 ThreatManager::ThreatManager(Unit* owner) : iCurrentVictim(NULL), iOwner(owner)
 337 {
 338 }
 339
 340 //============================================================
 341
 342 void ThreatManager::clearReferences()
 343 {
 344     iThreatContainer.clearReferences();
 345     iThreatOfflineContainer.clearReferences();
 346     iCurrentVictim = NULL;
 347 }
 348
 349 //============================================================
 350
 351 void ThreatManager::addThreat(Unit* pVictim, float pThreat, SpellSchoolMask schoolMask, SpellEntry const *pThreatSpell)
 352 {
 353     //function deals with adding threat and adding players and pets into ThreatList
 354     //mobs, NPCs, guards have ThreatList and HateOfflineList
 355     //players and pets have only InHateListOf
 356     //HateOfflineList is used co contain unattackable victims (in-flight, in-water, GM etc.)
 357
 358     if (pVictim == getOwner())                              // only for same creatures :)
 359         return;
 360
 361     if(!pVictim || (pVictim->GetTypeId() == TYPEID_PLAYER && ((Player*)pVictim)->isGameMaster()) )
 362         return;
 363
 364     assert(getOwner()->GetTypeId()== TYPEID_UNIT);
 365
 366     float threat = ThreatCalcHelper::calcThreat(pVictim, iOwner, pThreat, schoolMask, pThreatSpell);
 367
 368     HostilReference* ref = iThreatContainer.addThreat(pVictim, threat);
 369     // Ref is not in the online refs, search the offline refs next
 370     if(!ref)
 371         ref = iThreatOfflineContainer.addThreat(pVictim, threat);
 372
 373     if(!ref)                                                // there was no ref => create a new one
 374     {
 375                                                             // threat has to be 0 here
 376         HostilReference* hostilReference = new HostilReference(pVictim, this, 0);
 377         iThreatContainer.addReference(hostilReference);
 378         hostilReference->addThreat(threat);                 // now we add the real threat
 379         if(pVictim->GetTypeId() == TYPEID_PLAYER && ((Player*)pVictim)->isGameMaster())
 380             hostilReference->setOnlineOfflineState(false);  // GM is always offline
 381     }
 382 }
 383
 384 //============================================================
 385
 386 void ThreatManager::modifyThreatPercent(Unit *pVictim, int32 pPercent)
 387 {
 388     iThreatContainer.modifyThreatPercent(pVictim, pPercent);
 389 }
 390
 391 //============================================================
 392
 393 Unit* ThreatManager::getHostilTarget()
 394 {
 395     iThreatContainer.update();
 396     HostilReference* nextVictim = iThreatContainer.selectNextVictim((Creature*) getOwner(), getCurrentVictim());
 397     setCurrentVictim(nextVictim);
 398     return getCurrentVictim() != NULL ? getCurrentVictim()->getTarget() : NULL;
 399 }
 400
 401 //============================================================
 402
 403 float ThreatManager::getThreat(Unit *pVictim, bool pAlsoSearchOfflineList)
 404 {
 405     float threat = 0.0f;
 406     HostilReference* ref = iThreatContainer.getReferenceByTarget(pVictim);
 407     if(!ref && pAlsoSearchOfflineList)
 408         ref = iThreatOfflineContainer.getReferenceByTarget(pVictim);
 409     if(ref)
 410         threat = ref->getThreat();
 411     return threat;
 412 }
 413
 414 //============================================================
 415
 416 void ThreatManager::tauntApply(Unit* pTaunter)
 417 {
 418     HostilReference* ref = iThreatContainer.getReferenceByTarget(pTaunter);
 419     if(getCurrentVictim() && ref && (ref->getThreat() < getCurrentVictim()->getThreat()))
 420     {
 421         if(ref->getTempThreatModifyer() == 0.0f)
 422                                                             // Ok, temp threat is unused
 423             ref->setTempThreat(getCurrentVictim()->getThreat());
 424     }
 425 }
 426
 427 //============================================================
 428
 429 void ThreatManager::tauntFadeOut(Unit *pTaunter)
 430 {
 431     HostilReference* ref = iThreatContainer.getReferenceByTarget(pTaunter);
 432     if(ref)
 433         ref->resetTempThreat();
 434 }
 435
 436 //============================================================
 437
 438 void ThreatManager::setCurrentVictim(HostilReference* pHostilReference)
 439 {
 440     iCurrentVictim = pHostilReference;
 441 }
 442
 443 //============================================================
 444 // The hated unit is gone, dead or deleted
 445 // return true, if the event is consumed
 446
 447 bool ThreatManager::processThreatEvent(const UnitBaseEvent* pUnitBaseEvent)
 448 {
 449     bool consumed = false;
 450
 451     ThreatRefStatusChangeEvent* threatRefStatusChangeEvent;
 452     HostilReference* hostilReference;
 453
 454     threatRefStatusChangeEvent = (ThreatRefStatusChangeEvent*) pUnitBaseEvent;
 455     threatRefStatusChangeEvent->setThreatManager(this);     // now we can set the threat manager
 456     hostilReference = threatRefStatusChangeEvent->getReference();
 457
 458     switch(pUnitBaseEvent->getType())
 459     {
 460         case UEV_THREAT_REF_THREAT_CHANGE:
 461             if((getCurrentVictim() == hostilReference && threatRefStatusChangeEvent->getFValue()<0.0f) ||
 462                 (getCurrentVictim() != hostilReference && threatRefStatusChangeEvent->getFValue()>0.0f))
 463                 setDirty(true);                             // the order in the threat list might have changed
 464             break;
 465         case UEV_THREAT_REF_ONLINE_STATUS:
 466             if(!hostilReference->isOnline())
 467             {
 468                 if (hostilReference == getCurrentVictim())
 469                 {
 470                     setCurrentVictim(NULL);
 471                     setDirty(true);
 472                 }
 473                 iThreatContainer.remove(hostilReference);
 474                 iThreatOfflineContainer.addReference(hostilReference);
 475             }
 476             else
 477             {
 478                 if(getCurrentVictim() && hostilReference->getThreat() > (1.1f * getCurrentVictim()->getThreat()))
 479                     setDirty(true);
 480                 iThreatContainer.addReference(hostilReference);
 481                 iThreatOfflineContainer.remove(hostilReference);
 482             }
 483             break;
 484         case UEV_THREAT_REF_REMOVE_FROM_LIST:
 485             if (hostilReference == getCurrentVictim())
 486             {
 487                 setCurrentVictim(NULL);
 488                 setDirty(true);
 489             }
 490             if(hostilReference->isOnline())
 491                 iThreatContainer.remove(hostilReference);
 492             else
 493                 iThreatOfflineContainer.remove(hostilReference);
 494             break;
 495     }
 496     return consumed;
 497 }