*Massive cleanup (\n\n -> \n, *\n -> \n, cleanup for(...) to for (...), and some other cleanups by hand)

*Fix a possible crash in Spell::DoAllEffectOnTarget

--HG--
branch : trunk

1 files changed, 0 insertions, 84 deletions

diff --git a/src/game/ThreatManager.cpp b/src/game/ThreatManager.cpp
index 11e4f2ab61e..6e16125d348 100644
--- a/src/game/ThreatManager.cpp
+++ b/src/game/ThreatManager.cpp
@@ -17,7 +17,6 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
-
 #include "ThreatManager.h"
 #include "Unit.h"
 #include "Creature.h"
@@ -26,26 +25,21 @@
 #include "Player.h"
 #include "ObjectAccessor.h"
 #include "UnitEvents.h"
-
 //==============================================================
 //================= ThreatCalcHelper ===========================
 //==============================================================
-
 // The pHatingUnit is not used yet
 float ThreatCalcHelper::calcThreat(Unit* pHatedUnit, Unit* pHatingUnit, float pThreat, SpellSchoolMask schoolMask, SpellEntry const *pThreatSpell)
 {
     if (pThreatSpell)
         if (Player* modOwner = pHatedUnit->GetSpellModOwner())
             modOwner->ApplySpellMod(pThreatSpell->Id, SPELLMOD_THREAT, pThreat);
-
     float threat = pHatedUnit->ApplyTotalThreatModifier(pThreat, schoolMask);
     return threat;
 }
-
 //============================================================
 //================= HostilReference ==========================
 //============================================================
-
 HostilReference::HostilReference(Unit* pUnit, ThreatManager *pThreatManager, float pThreat)
 {
     iThreat = pThreat;
@@ -55,40 +49,32 @@ HostilReference::HostilReference(Unit* pUnit, ThreatManager *pThreatManager, flo
     iOnline = true;
     iAccessible = true;
 }
-
 //============================================================
 // Tell our refTo (target) object that we have a link
 void HostilReference::targetObjectBuildLink()
 {
     getTarget()->addHatedBy(this);
 }
-
 //============================================================
 // Tell our refTo (taget) object, that the link is cut
 void HostilReference::targetObjectDestroyLink()
 {
     getTarget()->removeHatedBy(this);
 }
-
 //============================================================
 // Tell our refFrom (source) object, that the link is cut (Target destroyed)
-
 void HostilReference::sourceObjectDestroyLink()
 {
     setOnlineOfflineState(false);
 }
-
 //============================================================
 // Inform the source, that the status of the reference changed
-
 void HostilReference::fireStatusChanged(ThreatRefStatusChangeEvent& pThreatRefStatusChangeEvent)
 {
     if(getSource())
         getSource()->processThreatEvent(&pThreatRefStatusChangeEvent);
 }
-
 //============================================================
-
 void HostilReference::addThreat(float pMod)
 {
     iThreat += pMod;
@@ -101,7 +87,6 @@ void HostilReference::addThreat(float pMod)
         ThreatRefStatusChangeEvent event(UEV_THREAT_REF_THREAT_CHANGE, this, pMod);
         fireStatusChanged(event);
     }
-
     if(isValid() && pMod >= 0)
     {
         Unit* victim_owner = getTarget()->GetCharmerOrOwner();
@@ -109,15 +94,12 @@ void HostilReference::addThreat(float pMod)
             getSource()->addThreat(victim_owner, 0.0f);     // create a threat to the owner of a pet, if the pet attacks
     }
 }
-
 //============================================================
 // check, if source can reach target and set the status
-
 void HostilReference::updateOnlineStatus()
 {
     bool online = false;
     bool accessible = false;
-
     if(!isValid())
     {
         Unit* target = ObjectAccessor::GetUnit(*getSourceUnit(), getUnitGuid());
@@ -141,15 +123,12 @@ void HostilReference::updateOnlineStatus()
         }
         else
             accessible = true;
-
     }
     setAccessibleState(accessible);
     setOnlineOfflineState(online);
 }
-
 //============================================================
 // set the status and fire the event on status change
-
 void HostilReference::setOnlineOfflineState(bool pIsOnline)
 {
     if(iOnline != pIsOnline)
@@ -157,48 +136,37 @@ void HostilReference::setOnlineOfflineState(bool pIsOnline)
         iOnline = pIsOnline;
         if(!iOnline)
             setAccessibleState(false);                      // if not online that not accessable as well
-
         ThreatRefStatusChangeEvent event(UEV_THREAT_REF_ONLINE_STATUS, this);
         fireStatusChanged(event);
     }
 }
-
 //============================================================
-
 void HostilReference::setAccessibleState(bool pIsAccessible)
 {
     if(iAccessible != pIsAccessible)
     {
         iAccessible = pIsAccessible;
-
         ThreatRefStatusChangeEvent event(UEV_THREAT_REF_ASSECCIBLE_STATUS, this);
         fireStatusChanged(event);
     }
 }
-
 //============================================================
 // prepare the reference for deleting
 // this is called be the target
-
 void HostilReference::removeReference()
 {
     invalidate();
-
     ThreatRefStatusChangeEvent event(UEV_THREAT_REF_REMOVE_FROM_LIST, this);
     fireStatusChanged(event);
 }
-
 //============================================================
-
 Unit* HostilReference::getSourceUnit()
 {
     return (getSource()->getOwner());
 }
-
 //============================================================
 //================ ThreatContainer ===========================
 //============================================================
-
 void ThreatContainer::clearReferences()
 {
     for(std::list<HostilReference*>::const_iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
@@ -208,13 +176,11 @@ void ThreatContainer::clearReferences()
     }
     iThreatList.clear();
 }
-
 //============================================================
 // Return the HostilReference of NULL, if not found
 HostilReference* ThreatContainer::getReferenceByTarget(Unit* pVictim)
 {
     HostilReference* result = NULL;
-        
     uint64 guid = pVictim->GetGUID();
     for(std::list<HostilReference*>::const_iterator i = iThreatList.begin(); i != iThreatList.end(); ++i)
     {
@@ -224,13 +190,10 @@ HostilReference* ThreatContainer::getReferenceByTarget(Unit* pVictim)
             break;
         }
     }
-
     return result;
 }
-
 //============================================================
 // Add the threat, if we find the reference
-
 HostilReference* ThreatContainer::addThreat(Unit* pVictim, float pThreat)
 {
     HostilReference* ref = getReferenceByTarget(pVictim);
@@ -238,26 +201,20 @@ HostilReference* ThreatContainer::addThreat(Unit* pVictim, float pThreat)
         ref->addThreat(pThreat);
     return ref;
 }
-
 //============================================================
-
 void ThreatContainer::modifyThreatPercent(Unit *pVictim, int32 pPercent)
 {
     if(HostilReference* ref = getReferenceByTarget(pVictim))
         ref->addThreatPercent(pPercent);
 }
-
 //============================================================
-
 bool HostilReferenceSortPredicate(const HostilReference* lhs, const HostilReference* rhs)
 {
     // std::list::sort ordering predicate must be: (Pred(x,y)&&Pred(y,x))==false
     return lhs->getThreat() > rhs->getThreat();             // reverse sorting
 }
-
 //============================================================
 // Check if the list is dirty and sort if necessary
-
 void ThreatContainer::update()
 {
     if(iDirty && iThreatList.size() >1)
@@ -266,27 +223,21 @@ void ThreatContainer::update()
     }
     iDirty = false;
 }
-
 //============================================================
 // return the next best victim
 // could be the current victim
-
 HostilReference* ThreatContainer::selectNextVictim(Creature* pAttacker, HostilReference* pCurrentVictim)
 {
     HostilReference* currentRef = NULL;
     bool found = false;
     bool noPriorityTargetFound = false;
-
     std::list<HostilReference*>::const_iterator lastRef = iThreatList.end();
     lastRef--;
-
     for(std::list<HostilReference*>::const_iterator iter = iThreatList.begin(); iter != iThreatList.end() && !found;)
     {
         currentRef = (*iter);
-
         Unit* target = currentRef->getTarget();
         assert(target);                                     // if the ref has status online the target must be there !
-
         // some units are prefered in comparison to others
         if(!noPriorityTargetFound && (target->IsImmunedToDamage(pAttacker->GetMeleeDamageSchoolMask()) || target->hasNegativeAuraWithInterruptFlag(AURA_INTERRUPT_FLAG_TAKE_DAMAGE)) )
         {
@@ -306,7 +257,6 @@ HostilReference* ThreatContainer::selectNextVictim(Creature* pAttacker, HostilRe
                 continue;
             }
         }
-
         if(pAttacker->canCreatureAttack(target))           // skip non attackable currently targets
         {
             if(pCurrentVictim)                              // select 1.3/1.1 better target in comparison current target
@@ -318,7 +268,6 @@ HostilReference* ThreatContainer::selectNextVictim(Creature* pAttacker, HostilRe
                     found = true;
                     break;
                 }
-
                 if (currentRef->getThreat() > 1.3f * pCurrentVictim->getThreat() ||
                     currentRef->getThreat() > 1.1f * pCurrentVictim->getThreat() &&
                     pAttacker->IsWithinMeleeRange(target))
@@ -337,20 +286,15 @@ HostilReference* ThreatContainer::selectNextVictim(Creature* pAttacker, HostilRe
     }
     if(!found)
         currentRef = NULL;
-
     return currentRef;
 }
-
 //============================================================
 //=================== ThreatManager ==========================
 //============================================================
-
 ThreatManager::ThreatManager(Unit* owner) : iCurrentVictim(NULL), iOwner(owner), iUpdateTimer(THREAT_UPDATE_INTERVAL)
 {
 }
-
 //============================================================
-
 void ThreatManager::clearReferences()
 {
     iThreatContainer.clearReferences();
@@ -358,32 +302,24 @@ void ThreatManager::clearReferences()
     iCurrentVictim = NULL;
     iUpdateTimer = THREAT_UPDATE_INTERVAL;
 }
-
 //============================================================
-
 void ThreatManager::addThreat(Unit* pVictim, float pThreat, SpellSchoolMask schoolMask, SpellEntry const *pThreatSpell)
 {
     //function deals with adding threat and adding players and pets into ThreatList
     //mobs, NPCs, guards have ThreatList and HateOfflineList
     //players and pets have only InHateListOf
     //HateOfflineList is used co contain unattackable victims (in-flight, in-water, GM etc.)
-
     // not to self
     if (pVictim == getOwner())
         return;
-
     // not to GM
     if(!pVictim || (pVictim->GetTypeId() == TYPEID_PLAYER && ((Player*)pVictim)->isGameMaster()) )
         return;
-
     // not to dead and not for dead
     if(!pVictim->isAlive() || !getOwner()->isAlive() )
         return;
-
     assert(getOwner()->GetTypeId()== TYPEID_UNIT);
-
     float threat = ThreatCalcHelper::calcThreat(pVictim, iOwner, pThreat, schoolMask, pThreatSpell);
-
     // must check > 0.0f, otherwise dead loop
     if(threat > 0.0f && pVictim->GetReducedThreatPercent())
     {
@@ -392,17 +328,14 @@ void ThreatManager::addThreat(Unit* pVictim, float pThreat, SpellSchoolMask scho
         if(Unit *unit = pVictim->GetMisdirectionTarget())
             _addThreat(unit, reducedThreat);
     }
-
     _addThreat(pVictim, threat);
 }
-
 void ThreatManager::_addThreat(Unit *pVictim, float threat)
 {
     HostilReference* ref = iThreatContainer.addThreat(pVictim, threat);
     // Ref is not in the online refs, search the offline refs next
     if(!ref)
         ref = iThreatOfflineContainer.addThreat(pVictim, threat);
-
     if(!ref)                                                // there was no ref => create a new one
     {
                                                             // threat has to be 0 here
@@ -413,16 +346,12 @@ void ThreatManager::_addThreat(Unit *pVictim, float threat)
             hostilReference->setOnlineOfflineState(false);  // GM is always offline
     }
 }
-
 //============================================================
-
 void ThreatManager::modifyThreatPercent(Unit *pVictim, int32 pPercent)
 {
     iThreatContainer.modifyThreatPercent(pVictim, pPercent);
 }
-
 //============================================================
-
 Unit* ThreatManager::getHostilTarget()
 {
     iThreatContainer.update();
@@ -430,9 +359,7 @@ Unit* ThreatManager::getHostilTarget()
     setCurrentVictim(nextVictim);
     return getCurrentVictim() != NULL ? getCurrentVictim()->getTarget() : NULL;
 }
-
 //============================================================
-
 float ThreatManager::getThreat(Unit *pVictim, bool pAlsoSearchOfflineList)
 {
     float threat = 0.0f;
@@ -443,9 +370,7 @@ float ThreatManager::getThreat(Unit *pVictim, bool pAlsoSearchOfflineList)
         threat = ref->getThreat();
     return threat;
 }
-
 //============================================================
-
 void ThreatManager::tauntApply(Unit* pTaunter)
 {
     HostilReference* ref = iThreatContainer.getReferenceByTarget(pTaunter);
@@ -456,18 +381,14 @@ void ThreatManager::tauntApply(Unit* pTaunter)
             ref->setTempThreat(getCurrentVictim()->getThreat());
     }
 }
-
 //============================================================
-
 void ThreatManager::tauntFadeOut(Unit *pTaunter)
 {
     HostilReference* ref = iThreatContainer.getReferenceByTarget(pTaunter);
     if(ref)
         ref->resetTempThreat();
 }
-
 //============================================================
-
 void ThreatManager::setCurrentVictim(HostilReference* pHostilReference)
 {
     if (pHostilReference && pHostilReference != iCurrentVictim)
@@ -476,17 +397,13 @@ void ThreatManager::setCurrentVictim(HostilReference* pHostilReference)
     }
     iCurrentVictim = pHostilReference;
 }
-
 //============================================================
 // The hated unit is gone, dead or deleted
 // return true, if the event is consumed
-
 void ThreatManager::processThreatEvent(ThreatRefStatusChangeEvent* threatRefStatusChangeEvent)
 {
     threatRefStatusChangeEvent->setThreatManager(this);     // now we can set the threat manager
-
     HostilReference* hostilReference = threatRefStatusChangeEvent->getReference();
-
     switch(threatRefStatusChangeEvent->getType())
     {
         case UEV_THREAT_REF_THREAT_CHANGE:
@@ -527,7 +444,6 @@ void ThreatManager::processThreatEvent(ThreatRefStatusChangeEvent* threatRefStat
             break;
     }
 }
-
 bool ThreatManager::isNeedUpdateToClient(uint32 time)
 {
     if (isThreatListEmpty())