src/game/ThreatManager.cpp

   1 /*
   2  * Copyright (C) 2005-2010 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, bool crit, SpellSchoolMask schoolMask, SpellEntry const *pThreatSpell)
  34 {
  35     // all flat mods applied early
  36     if(!pThreat)
  37         return 0.0f;
  38
  39     if (pThreatSpell)
  40     {
  41         if (Player* modOwner = pHatedUnit->GetSpellModOwner())
  42             modOwner->ApplySpellMod(pThreatSpell->Id, SPELLMOD_THREAT, pThreat);
  43
  44         if(crit)
  45             pThreat *= pHatedUnit->GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_CRITICAL_THREAT,schoolMask);
  46     }
  47
  48     float threat = pHatedUnit->ApplyTotalThreatModifier(pThreat, schoolMask);
  49     return threat;
  50 }
  51
  52 //============================================================
  53 //================= HostileReference ==========================
  54 //============================================================
  55
  56 HostileReference::HostileReference(Unit* pUnit, ThreatManager *pThreatManager, float pThreat)
  57 {
  58     iThreat = pThreat;
  59     iTempThreatModifyer = 0.0f;
  60     link(pUnit, pThreatManager);
  61     iUnitGuid = pUnit->GetGUID();
  62     iOnline = true;
  63     iAccessible = true;
  64 }
  65
  66 //============================================================
  67 // Tell our refTo (target) object that we have a link
  68 void HostileReference::targetObjectBuildLink()
  69 {
  70     getTarget()->addHatedBy(this);
  71 }
  72
  73 //============================================================
  74 // Tell our refTo (taget) object, that the link is cut
  75 void HostileReference::targetObjectDestroyLink()
  76 {
  77     getTarget()->removeHatedBy(this);
  78 }
  79
  80 //============================================================
  81 // Tell our refFrom (source) object, that the link is cut (Target destroyed)
  82
  83 void HostileReference::sourceObjectDestroyLink()
  84 {
  85     setOnlineOfflineState(false);
  86 }
  87
  88 //============================================================
  89 // Inform the source, that the status of the reference changed
  90
  91 void HostileReference::fireStatusChanged(ThreatRefStatusChangeEvent& pThreatRefStatusChangeEvent)
  92 {
  93     if(getSource())
  94         getSource()->processThreatEvent(&pThreatRefStatusChangeEvent);
  95 }
  96
  97 //============================================================
  98
  99 void HostileReference::addThreat(float pMod)
 100 {
 101     iThreat += pMod;
 102     // the threat is changed. Source and target unit have to be availabe
 103     // if the link was cut before relink it again
 104     if(!isOnline())
 105         updateOnlineStatus();
 106     if(pMod != 0.0f)
 107     {
 108         ThreatRefStatusChangeEvent event(UEV_THREAT_REF_THREAT_CHANGE, this, pMod);
 109         fireStatusChanged(event);
 110     }
 111
 112     if(isValid() && pMod >= 0)
 113     {
 114         Unit* victim_owner = getTarget()->GetOwner();
 115         if(victim_owner && victim_owner->isAlive())
 116             getSource()->addThreat(victim_owner, 0.0f);     // create a threat to the owner of a pet, if the pet attacks
 117     }
 118 }
 119
 120 //============================================================
 121 // check, if source can reach target and set the status
 122
 123 void HostileReference::updateOnlineStatus()
 124 {
 125     bool online = false;
 126     bool accessible = false;
 127
 128     if(!isValid())
 129     {
 130         Unit* target = ObjectAccessor::GetUnit(*getSourceUnit(), getUnitGuid());
 131         if(target)
 132             link(target, getSource());
 133     }
 134     // only check for online status if
 135     // ref is valid
 136     // target is no player or not gamemaster
 137     // target is not in flight
 138     if(isValid() &&
 139         ((getTarget()->GetTypeId() != TYPEID_PLAYER || !((Player*)getTarget())->isGameMaster()) ||
 140         !getTarget()->hasUnitState(UNIT_STAT_IN_FLIGHT)))
 141     {
 142         Creature* creature = (Creature* ) getSourceUnit();
 143         online = getTarget()->isInAccessablePlaceFor(creature);
 144         if(!online)
 145         {
 146             if(creature->AI()->canReachByRangeAttack(getTarget()))
 147                 online = true;                              // not accessable but stays online
 148         }
 149         else
 150             accessible = true;
 151
 152     }
 153     setAccessibleState(accessible);
 154     setOnlineOfflineState(online);
 155 }
 156
 157 //============================================================
 158 // set the status and fire the event on status change
 159
 160 void HostileReference::setOnlineOfflineState(bool pIsOnline)
 161 {
 162     if(iOnline != pIsOnline)
 163     {
 164         iOnline = pIsOnline;
 165         if(!iOnline)
 166             setAccessibleState(false);                      // if not online that not accessable as well
 167
 168         ThreatRefStatusChangeEvent event(UEV_THREAT_REF_ONLINE_STATUS, this);
 169         fireStatusChanged(event);
 170     }
 171 }
 172
 173 //============================================================
 174
 175 void HostileReference::setAccessibleState(bool pIsAccessible)
 176 {
 177     if(iAccessible != pIsAccessible)
 178     {
 179         iAccessible = pIsAccessible;
 180
 181         ThreatRefStatusChangeEvent event(UEV_THREAT_REF_ASSECCIBLE_STATUS, this);
 182         fireStatusChanged(event);
 183     }
 184 }
 185
 186 //============================================================
 187 // prepare the reference for deleting
 188 // this is called be the target
 189
 190 void HostileReference::removeReference()
 191 {
 192     invalidate();
 193
 194     ThreatRefStatusChangeEvent event(UEV_THREAT_REF_REMOVE_FROM_LIST, this);
 195     fireStatusChanged(event);
 196 }
 197
 198 //============================================================
 199
 200 Unit* HostileReference::getSourceUnit()
 201 {
 202     return (getSource()->getOwner());
 203 }
 204
 205 //============================================================
 206 //================ ThreatContainer ===========================
 207 //============================================================
 208
 209 void ThreatContainer::clearReferences()
 210 {
 211     for(ThreatList::const_iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
 212     {
 213         (*i)->unlink();
 214         delete (*i);
 215     }
 216     iThreatList.clear();
 217 }
 218
 219 //============================================================
 220 // Return the HostileReference of NULL, if not found
 221 HostileReference* ThreatContainer::getReferenceByTarget(Unit* pVictim)
 222 {
 223     HostileReference* result = NULL;
 224     uint64 guid = pVictim->GetGUID();
 225     for(ThreatList::const_iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
 226     {
 227         if((*i)->getUnitGuid() == guid)
 228         {
 229             result = (*i);
 230             break;
 231         }
 232     }
 233
 234     return result;
 235 }
 236
 237 //============================================================
 238 // Add the threat, if we find the reference
 239
 240 HostileReference* ThreatContainer::addThreat(Unit* pVictim, float pThreat)
 241 {
 242     HostileReference* ref = getReferenceByTarget(pVictim);
 243     if(ref)
 244         ref->addThreat(pThreat);
 245     return ref;
 246 }
 247
 248 //============================================================
 249
 250 void ThreatContainer::modifyThreatPercent(Unit *pVictim, int32 pPercent)
 251 {
 252     if(HostileReference* ref = getReferenceByTarget(pVictim))
 253         ref->addThreatPercent(pPercent);
 254 }
 255
 256 //============================================================
 257
 258 bool HostileReferenceSortPredicate(const HostileReference* lhs, const HostileReference* rhs)
 259 {
 260     // std::list::sort ordering predicate must be: (Pred(x,y)&&Pred(y,x))==false
 261     return lhs->getThreat() > rhs->getThreat();             // reverse sorting
 262 }
 263
 264 //============================================================
 265 // Check if the list is dirty and sort if necessary
 266
 267 void ThreatContainer::update()
 268 {
 269     if(iDirty && iThreatList.size() >1)
 270     {
 271         iThreatList.sort(HostileReferenceSortPredicate);
 272     }
 273     iDirty = false;
 274 }
 275
 276 //============================================================
 277 // return the next best victim
 278 // could be the current victim
 279
 280 HostileReference* ThreatContainer::selectNextVictim(Creature* pAttacker, HostileReference* pCurrentVictim)
 281 {
 282     HostileReference* currentRef = NULL;
 283     bool found = false;
 284     bool noPriorityTargetFound = false;
 285
 286     ThreatList::const_iterator lastRef = iThreatList.end();
 287     lastRef--;
 288
 289     for(ThreatList::const_iterator iter = iThreatList.begin(); iter != iThreatList.end() && !found;)
 290     {
 291         currentRef = (*iter);
 292
 293         Unit* target = currentRef->getTarget();
 294         assert(target);                                     // if the ref has status online the target must be there !
 295
 296         // some units are prefered in comparison to others
 297         if(!noPriorityTargetFound && (target->IsImmunedToDamage(pAttacker->GetMeleeDamageSchoolMask()) || target->hasNegativeAuraWithInterruptFlag(AURA_INTERRUPT_FLAG_DAMAGE)) )
 298         {
 299             if(iter != lastRef)
 300             {
 301                 // current victim is a second choice target, so don't compare threat with it below
 302                 if(currentRef == pCurrentVictim)
 303                     pCurrentVictim = NULL;
 304                 ++iter;
 305                 continue;
 306             }
 307             else
 308             {
 309                 // 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.
 310                 noPriorityTargetFound = true;
 311                 iter = iThreatList.begin();
 312                 continue;
 313             }
 314         }
 315
 316         if(!pAttacker->IsOutOfThreatArea(target))           // skip non attackable currently targets
 317         {
 318             if(pCurrentVictim)                              // select 1.3/1.1 better target in comparison current target
 319             {
 320                 // list sorted and and we check current target, then this is best case
 321                 if(pCurrentVictim == currentRef || currentRef->getThreat() <= 1.1f * pCurrentVictim->getThreat() )
 322                 {
 323                     currentRef = pCurrentVictim;            // for second case
 324                     found = true;
 325                     break;
 326                 }
 327
 328                 if (currentRef->getThreat() > 1.3f * pCurrentVictim->getThreat() ||
 329                      (currentRef->getThreat() > 1.1f * pCurrentVictim->getThreat() &&
 330                      pAttacker->IsWithinDistInMap(target, ATTACK_DISTANCE)) )
 331                 {                                           //implement 110% threat rule for targets in melee range
 332                     found = true;                           //and 130% rule for targets in ranged distances
 333                     break;                                  //for selecting alive targets
 334                 }
 335             }
 336             else                                            // select any
 337             {
 338                 found = true;
 339                 break;
 340             }
 341         }
 342         ++iter;
 343     }
 344     if(!found)
 345         currentRef = NULL;
 346
 347     return currentRef;
 348 }
 349
 350 //============================================================
 351 //=================== ThreatManager ==========================
 352 //============================================================
 353
 354 ThreatManager::ThreatManager(Unit* owner)
 355 : iCurrentVictim(NULL), iOwner(owner), iUpdateTimer(THREAT_UPDATE_INTERVAL), iUpdateNeed(false)
 356 {
 357 }
 358
 359 //============================================================
 360
 361 void ThreatManager::clearReferences()
 362 {
 363     iThreatContainer.clearReferences();
 364     iThreatOfflineContainer.clearReferences();
 365     iCurrentVictim = NULL;
 366     iUpdateTimer.Reset(THREAT_UPDATE_INTERVAL);
 367     iUpdateNeed = false;
 368 }
 369
 370 //============================================================
 371
 372 void ThreatManager::addThreat(Unit* pVictim, float pThreat, bool crit, SpellSchoolMask schoolMask, SpellEntry const *pThreatSpell)
 373 {
 374     //function deals with adding threat and adding players and pets into ThreatList
 375     //mobs, NPCs, guards have ThreatList and HateOfflineList
 376     //players and pets have only InHateListOf
 377     //HateOfflineList is used co contain unattackable victims (in-flight, in-water, GM etc.)
 378
 379     // not to self
 380     if (pVictim == getOwner())
 381         return;
 382
 383     // not to GM
 384     if (!pVictim || (pVictim->GetTypeId() == TYPEID_PLAYER && ((Player*)pVictim)->isGameMaster()) )
 385         return;
 386
 387     // not to dead and not for dead
 388     if(!pVictim->isAlive() || !getOwner()->isAlive() )
 389         return;
 390
 391     assert(getOwner()->GetTypeId()== TYPEID_UNIT);
 392
 393     float threat = ThreatCalcHelper::calcThreat(pVictim, iOwner, pThreat, crit, schoolMask, pThreatSpell);
 394
 395     HostileReference* ref = iThreatContainer.addThreat(pVictim, threat);
 396     // Ref is online
 397     if (ref)
 398         iUpdateNeed = true;
 399     // Ref is not in the online refs, search the offline refs next
 400     else
 401         ref = iThreatOfflineContainer.addThreat(pVictim, threat);
 402
 403     if(!ref)                                                // there was no ref => create a new one
 404     {
 405                                                             // threat has to be 0 here
 406         HostileReference* hostileReference = new HostileReference(pVictim, this, 0);
 407         iThreatContainer.addReference(hostileReference);
 408         hostileReference->addThreat(threat);                // now we add the real threat
 409         iUpdateNeed = true;
 410         if(pVictim->GetTypeId() == TYPEID_PLAYER && ((Player*)pVictim)->isGameMaster())
 411             hostileReference->setOnlineOfflineState(false); // GM is always offline
 412     }
 413 }
 414
 415 //============================================================
 416
 417 void ThreatManager::modifyThreatPercent(Unit *pVictim, int32 pPercent)
 418 {
 419     iThreatContainer.modifyThreatPercent(pVictim, pPercent);
 420     iUpdateNeed = true;
 421 }
 422
 423 //============================================================
 424
 425 Unit* ThreatManager::getHostileTarget()
 426 {
 427     iThreatContainer.update();
 428     HostileReference* nextVictim = iThreatContainer.selectNextVictim((Creature*) getOwner(), getCurrentVictim());
 429     setCurrentVictim(nextVictim);
 430     return getCurrentVictim() != NULL ? getCurrentVictim()->getTarget() : NULL;
 431 }
 432
 433 //============================================================
 434
 435 float ThreatManager::getThreat(Unit *pVictim, bool pAlsoSearchOfflineList)
 436 {
 437     float threat = 0.0f;
 438     HostileReference* ref = iThreatContainer.getReferenceByTarget(pVictim);
 439     if(!ref && pAlsoSearchOfflineList)
 440         ref = iThreatOfflineContainer.getReferenceByTarget(pVictim);
 441     if(ref)
 442         threat = ref->getThreat();
 443     return threat;
 444 }
 445
 446 //============================================================
 447
 448 void ThreatManager::tauntApply(Unit* pTaunter)
 449 {
 450     if(HostileReference* ref = iThreatContainer.getReferenceByTarget(pTaunter))
 451     {
 452         if(getCurrentVictim() && (ref->getThreat() < getCurrentVictim()->getThreat()))
 453         {
 454             // Ok, temp threat is unused
 455             if(ref->getTempThreatModifyer() == 0.0f)
 456             {
 457                 ref->setTempThreat(getCurrentVictim()->getThreat());
 458                 iUpdateNeed = true;
 459             }
 460         }
 461     }
 462 }
 463
 464 //============================================================
 465
 466 void ThreatManager::tauntFadeOut(Unit *pTaunter)
 467 {
 468     if(HostileReference* ref = iThreatContainer.getReferenceByTarget(pTaunter))
 469     {
 470         ref->resetTempThreat();
 471         iUpdateNeed = true;
 472     }
 473 }
 474
 475 //============================================================
 476
 477 void ThreatManager::setCurrentVictim(HostileReference* pHostileReference)
 478 {
 479     // including NULL==NULL case
 480     if (pHostileReference == iCurrentVictim)
 481         return;
 482
 483     if (pHostileReference)
 484         iOwner->SendHighestThreatUpdate(pHostileReference);
 485
 486     iCurrentVictim = pHostileReference;
 487     iUpdateNeed = true;
 488 }
 489
 490 //============================================================
 491 // The hated unit is gone, dead or deleted
 492 // return true, if the event is consumed
 493
 494 void ThreatManager::processThreatEvent(ThreatRefStatusChangeEvent* threatRefStatusChangeEvent)
 495 {
 496     threatRefStatusChangeEvent->setThreatManager(this);     // now we can set the threat manager
 497
 498     HostileReference* hostileReference = threatRefStatusChangeEvent->getReference();
 499
 500     switch(threatRefStatusChangeEvent->getType())
 501     {
 502         case UEV_THREAT_REF_THREAT_CHANGE:
 503             if((getCurrentVictim() == hostileReference && threatRefStatusChangeEvent->getFValue()<0.0f) ||
 504                 (getCurrentVictim() != hostileReference && threatRefStatusChangeEvent->getFValue()>0.0f))
 505                 setDirty(true);                             // the order in the threat list might have changed
 506             break;
 507         case UEV_THREAT_REF_ONLINE_STATUS:
 508             if(!hostileReference->isOnline())
 509             {
 510                 if (hostileReference == getCurrentVictim())
 511                 {
 512                     setCurrentVictim(NULL);
 513                     setDirty(true);
 514                 }
 515                 iOwner->SendThreatRemove(hostileReference);
 516                 iThreatContainer.remove(hostileReference);
 517                 iUpdateNeed = true;
 518                 iThreatOfflineContainer.addReference(hostileReference);
 519             }
 520             else
 521             {
 522                 if(getCurrentVictim() && hostileReference->getThreat() > (1.1f * getCurrentVictim()->getThreat()))
 523                     setDirty(true);
 524                 iThreatContainer.addReference(hostileReference);
 525                 iUpdateNeed = true;
 526                 iThreatOfflineContainer.remove(hostileReference);
 527             }
 528             break;
 529         case UEV_THREAT_REF_REMOVE_FROM_LIST:
 530             if (hostileReference == getCurrentVictim())
 531             {
 532                 setCurrentVictim(NULL);
 533                 setDirty(true);
 534             }
 535             if(hostileReference->isOnline())
 536             {
 537                 iOwner->SendThreatRemove(hostileReference);
 538                 iThreatContainer.remove(hostileReference);
 539                 iUpdateNeed = true;
 540             }
 541             else
 542                 iThreatOfflineContainer.remove(hostileReference);
 543             break;
 544     }
 545 }
 546
 547 void ThreatManager::UpdateForClient(uint32 diff)
 548 {
 549     if (!iUpdateNeed || isThreatListEmpty())
 550         return;
 551
 552     iUpdateTimer.Update(diff);
 553     if (iUpdateTimer.Passed())
 554     {
 555         iOwner->SendThreatUpdate();
 556         iUpdateTimer.Reset(THREAT_UPDATE_INTERVAL);
 557         iUpdateNeed = false;
 558     }
 559 }