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(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     {
 101         ThreatRefStatusChangeEvent event(UEV_THREAT_REF_THREAT_CHANGE, this, pMod);
 102         fireStatusChanged(event);
 103     }
 104
 105     if(isValid() && pMod >= 0)
 106     {
 107         Unit* victim_owner = getTarget()->GetOwner();
 108         if(victim_owner && victim_owner->isAlive())
 109             getSource()->addThreat(victim_owner, 0.0f);     // create a threat to the owner of a pet, if the pet attacks
 110     }
 111 }
 112
 113 //============================================================
 114 // check, if source can reach target and set the status
 115
 116 void HostilReference::updateOnlineStatus()
 117 {
 118     bool online = false;
 119     bool accessible = false;
 120
 121     if(!isValid())
 122     {
 123         Unit* target = ObjectAccessor::GetUnit(*getSourceUnit(), getUnitGuid());
 124         if(target)
 125             link(target, getSource());
 126     }
 127     // only check for online status if
 128     // ref is valid
 129     // target is no player or not gamemaster
 130     // target is not in flight
 131     if(isValid() &&
 132         ((getTarget()->GetTypeId() != TYPEID_PLAYER || !((Player*)getTarget())->isGameMaster()) ||
 133         !getTarget()->hasUnitState(UNIT_STAT_IN_FLIGHT)))
 134     {
 135         Creature* creature = (Creature* ) getSourceUnit();
 136         online = getTarget()->isInAccessablePlaceFor(creature);
 137         if(!online)
 138         {
 139             if(creature->AI()->canReachByRangeAttack(getTarget()))
 140                 online = true;                              // not accessable but stays online
 141         }
 142         else
 143             accessible = true;
 144
 145     }
 146     setAccessibleState(accessible);
 147     setOnlineOfflineState(online);
 148 }
 149
 150 //============================================================
 151 // set the status and fire the event on status change
 152
 153 void HostilReference::setOnlineOfflineState(bool pIsOnline)
 154 {
 155     if(iOnline != pIsOnline)
 156     {
 157         iOnline = pIsOnline;
 158         if(!iOnline)
 159             setAccessibleState(false);                      // if not online that not accessable as well
 160
 161         ThreatRefStatusChangeEvent event(UEV_THREAT_REF_ONLINE_STATUS, this);
 162         fireStatusChanged(event);
 163     }
 164 }
 165
 166 //============================================================
 167
 168 void HostilReference::setAccessibleState(bool pIsAccessible)
 169 {
 170     if(iAccessible != pIsAccessible)
 171     {
 172         iAccessible = pIsAccessible;
 173
 174         ThreatRefStatusChangeEvent event(UEV_THREAT_REF_ASSECCIBLE_STATUS, this);
 175         fireStatusChanged(event);
 176     }
 177 }
 178
 179 //============================================================
 180 // prepare the reference for deleting
 181 // this is called be the target
 182
 183 void HostilReference::removeReference()
 184 {
 185     invalidate();
 186
 187     ThreatRefStatusChangeEvent event(UEV_THREAT_REF_REMOVE_FROM_LIST, this);
 188     fireStatusChanged(event);
 189 }
 190
 191 //============================================================
 192
 193 Unit* HostilReference::getSourceUnit()
 194 {
 195     return (getSource()->getOwner());
 196 }
 197
 198 //============================================================
 199 //================ ThreatContainer ===========================
 200 //============================================================
 201
 202 void ThreatContainer::clearReferences()
 203 {
 204     for(std::list<HostilReference*>::const_iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
 205     {
 206         (*i)->unlink();
 207         delete (*i);
 208     }
 209     iThreatList.clear();
 210 }
 211
 212 //============================================================
 213 // Return the HostilReference of NULL, if not found
 214 HostilReference* ThreatContainer::getReferenceByTarget(Unit* pVictim)
 215 {
 216     HostilReference* result = NULL;
 217     uint64 guid = pVictim->GetGUID();
 218     for(std::list<HostilReference*>::const_iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
 219     {
 220         if((*i)->getUnitGuid() == guid)
 221         {
 222             result = (*i);
 223             break;
 224         }
 225     }
 226
 227     return result;
 228 }
 229
 230 //============================================================
 231 // Add the threat, if we find the reference
 232
 233 HostilReference* ThreatContainer::addThreat(Unit* pVictim, float pThreat)
 234 {
 235     HostilReference* ref = getReferenceByTarget(pVictim);
 236     if(ref)
 237         ref->addThreat(pThreat);
 238     return ref;
 239 }
 240
 241 //============================================================
 242
 243 void ThreatContainer::modifyThreatPercent(Unit *pVictim, int32 pPercent)
 244 {
 245     if(HostilReference* ref = getReferenceByTarget(pVictim))
 246         ref->addThreatPercent(pPercent);
 247 }
 248
 249 //============================================================
 250
 251 bool HostilReferenceSortPredicate(const HostilReference* lhs, const HostilReference* rhs)
 252 {
 253     // std::list::sort ordering predicate must be: (Pred(x,y)&&Pred(y,x))==false
 254     return lhs->getThreat() > rhs->getThreat();             // reverse sorting
 255 }
 256
 257 //============================================================
 258 // Check if the list is dirty and sort if necessary
 259
 260 void ThreatContainer::update()
 261 {
 262     if(iDirty && iThreatList.size() >1)
 263     {
 264         iThreatList.sort(HostilReferenceSortPredicate);
 265     }
 266     iDirty = false;
 267 }
 268
 269 //============================================================
 270 // return the next best victim
 271 // could be the current victim
 272
 273 HostilReference* ThreatContainer::selectNextVictim(Creature* pAttacker, HostilReference* pCurrentVictim)
 274 {
 275     HostilReference* currentRef = NULL;
 276     bool found = false;
 277     bool noPriorityTargetFound = false;
 278
 279     std::list<HostilReference*>::const_iterator lastRef = iThreatList.end();
 280     lastRef--;
 281
 282     for(std::list<HostilReference*>::const_iterator iter = iThreatList.begin(); iter != iThreatList.end() && !found;)
 283     {
 284         currentRef = (*iter);
 285
 286         Unit* target = currentRef->getTarget();
 287         assert(target);                                     // if the ref has status online the target must be there !
 288
 289         // some units are prefered in comparison to others
 290         if(!noPriorityTargetFound && (target->IsImmunedToDamage(pAttacker->GetMeleeDamageSchoolMask()) || target->hasNegativeAuraWithInterruptFlag(AURA_INTERRUPT_FLAG_DAMAGE)) )
 291         {
 292             if(iter != lastRef)
 293             {
 294                 // current victim is a second choice target, so don't compare threat with it below
 295                 if(currentRef == pCurrentVictim)
 296                     pCurrentVictim = NULL;
 297                 ++iter;
 298                 continue;
 299             }
 300             else
 301             {
 302                 // 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.
 303                 noPriorityTargetFound = true;
 304                 iter = iThreatList.begin();
 305                 continue;
 306             }
 307         }
 308
 309         if(!pAttacker->IsOutOfThreatArea(target))           // skip non attackable currently targets
 310         {
 311             if(pCurrentVictim)                              // select 1.3/1.1 better target in comparison current target
 312             {
 313                 // list sorted and and we check current target, then this is best case
 314                 if(pCurrentVictim == currentRef || currentRef->getThreat() <= 1.1f * pCurrentVictim->getThreat() )
 315                 {
 316                     currentRef = pCurrentVictim;            // for second case
 317                     found = true;
 318                     break;
 319                 }
 320
 321                 if ((currentRef->getThreat() > 1.3f * pCurrentVictim->getThreat() ||
 322                      currentRef->getThreat() > 1.1f * pCurrentVictim->getThreat()) &&
 323                      pAttacker->IsWithinDistInMap(target, ATTACK_DISTANCE))
 324                 {                                           //implement 110% threat rule for targets in melee range
 325                     found = true;                           //and 130% rule for targets in ranged distances
 326                     break;                                  //for selecting alive targets
 327                 }
 328             }
 329             else                                            // select any
 330             {
 331                 found = true;
 332                 break;
 333             }
 334         }
 335         ++iter;
 336     }
 337     if(!found)
 338         currentRef = NULL;
 339
 340     return currentRef;
 341 }
 342
 343 //============================================================
 344 //=================== ThreatManager ==========================
 345 //============================================================
 346
 347 ThreatManager::ThreatManager(Unit* owner) : iCurrentVictim(NULL), iOwner(owner)
 348 {
 349 }
 350
 351 //============================================================
 352
 353 void ThreatManager::clearReferences()
 354 {
 355     iThreatContainer.clearReferences();
 356     iThreatOfflineContainer.clearReferences();
 357     iCurrentVictim = NULL;
 358 }
 359
 360 //============================================================
 361
 362 void ThreatManager::addThreat(Unit* pVictim, float pThreat, SpellSchoolMask schoolMask, SpellEntry const *pThreatSpell)
 363 {
 364     //function deals with adding threat and adding players and pets into ThreatList
 365     //mobs, NPCs, guards have ThreatList and HateOfflineList
 366     //players and pets have only InHateListOf
 367     //HateOfflineList is used co contain unattackable victims (in-flight, in-water, GM etc.)
 368
 369     // not to self
 370     if (pVictim == getOwner())
 371         return;
 372
 373     // not to GM
 374     if(!pVictim || (pVictim->GetTypeId() == TYPEID_PLAYER && ((Player*)pVictim)->isGameMaster()) )
 375         return;
 376
 377     // not to dead and not for dead
 378     if(!pVictim->isAlive() || !getOwner()->isAlive() )
 379         return;
 380
 381     assert(getOwner()->GetTypeId()== TYPEID_UNIT);
 382
 383     float threat = ThreatCalcHelper::calcThreat(pVictim, iOwner, pThreat, schoolMask, pThreatSpell);
 384
 385     HostilReference* ref = iThreatContainer.addThreat(pVictim, threat);
 386     // Ref is not in the online refs, search the offline refs next
 387     if(!ref)
 388         ref = iThreatOfflineContainer.addThreat(pVictim, threat);
 389
 390     if(!ref)                                                // there was no ref => create a new one
 391     {
 392                                                             // threat has to be 0 here
 393         HostilReference* hostilReference = new HostilReference(pVictim, this, 0);
 394         iThreatContainer.addReference(hostilReference);
 395         hostilReference->addThreat(threat);                 // now we add the real threat
 396         if(pVictim->GetTypeId() == TYPEID_PLAYER && ((Player*)pVictim)->isGameMaster())
 397             hostilReference->setOnlineOfflineState(false);  // GM is always offline
 398     }
 399 }
 400
 401 //============================================================
 402
 403 void ThreatManager::modifyThreatPercent(Unit *pVictim, int32 pPercent)
 404 {
 405     iThreatContainer.modifyThreatPercent(pVictim, pPercent);
 406 }
 407
 408 //============================================================
 409
 410 Unit* ThreatManager::getHostilTarget()
 411 {
 412     iThreatContainer.update();
 413     HostilReference* nextVictim = iThreatContainer.selectNextVictim((Creature*) getOwner(), getCurrentVictim());
 414     setCurrentVictim(nextVictim);
 415     return getCurrentVictim() != NULL ? getCurrentVictim()->getTarget() : NULL;
 416 }
 417
 418 //============================================================
 419
 420 float ThreatManager::getThreat(Unit *pVictim, bool pAlsoSearchOfflineList)
 421 {
 422     float threat = 0.0f;
 423     HostilReference* ref = iThreatContainer.getReferenceByTarget(pVictim);
 424     if(!ref && pAlsoSearchOfflineList)
 425         ref = iThreatOfflineContainer.getReferenceByTarget(pVictim);
 426     if(ref)
 427         threat = ref->getThreat();
 428     return threat;
 429 }
 430
 431 //============================================================
 432
 433 void ThreatManager::tauntApply(Unit* pTaunter)
 434 {
 435     HostilReference* ref = iThreatContainer.getReferenceByTarget(pTaunter);
 436     if(getCurrentVictim() && ref && (ref->getThreat() < getCurrentVictim()->getThreat()))
 437     {
 438         if(ref->getTempThreatModifyer() == 0.0f)
 439                                                             // Ok, temp threat is unused
 440             ref->setTempThreat(getCurrentVictim()->getThreat());
 441     }
 442 }
 443
 444 //============================================================
 445
 446 void ThreatManager::tauntFadeOut(Unit *pTaunter)
 447 {
 448     HostilReference* ref = iThreatContainer.getReferenceByTarget(pTaunter);
 449     if(ref)
 450         ref->resetTempThreat();
 451 }
 452
 453 //============================================================
 454
 455 void ThreatManager::setCurrentVictim(HostilReference* pHostilReference)
 456 {
 457     iCurrentVictim = pHostilReference;
 458 }
 459
 460 //============================================================
 461 // The hated unit is gone, dead or deleted
 462 // return true, if the event is consumed
 463
 464 void ThreatManager::processThreatEvent(ThreatRefStatusChangeEvent* threatRefStatusChangeEvent)
 465 {
 466     threatRefStatusChangeEvent->setThreatManager(this);     // now we can set the threat manager
 467
 468     HostilReference* hostilReference = threatRefStatusChangeEvent->getReference();
 469
 470     switch(threatRefStatusChangeEvent->getType())
 471     {
 472         case UEV_THREAT_REF_THREAT_CHANGE:
 473             if((getCurrentVictim() == hostilReference && threatRefStatusChangeEvent->getFValue()<0.0f) ||
 474                 (getCurrentVictim() != hostilReference && threatRefStatusChangeEvent->getFValue()>0.0f))
 475                 setDirty(true);                             // the order in the threat list might have changed
 476             break;
 477         case UEV_THREAT_REF_ONLINE_STATUS:
 478             if(!hostilReference->isOnline())
 479             {
 480                 if (hostilReference == getCurrentVictim())
 481                 {
 482                     setCurrentVictim(NULL);
 483                     setDirty(true);
 484                 }
 485                 iThreatContainer.remove(hostilReference);
 486                 iThreatOfflineContainer.addReference(hostilReference);
 487             }
 488             else
 489             {
 490                 if(getCurrentVictim() && hostilReference->getThreat() > (1.1f * getCurrentVictim()->getThreat()))
 491                     setDirty(true);
 492                 iThreatContainer.addReference(hostilReference);
 493                 iThreatOfflineContainer.remove(hostilReference);
 494             }
 495             break;
 496         case UEV_THREAT_REF_REMOVE_FROM_LIST:
 497             if (hostilReference == getCurrentVictim())
 498             {
 499                 setCurrentVictim(NULL);
 500                 setDirty(true);
 501             }
 502             if(hostilReference->isOnline())
 503                 iThreatContainer.remove(hostilReference);
 504             else
 505                 iThreatOfflineContainer.remove(hostilReference);
 506             break;
 507     }
 508 }