src/game/ThreatManager.cpp

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