mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-14 07:37:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Various Cleanups (game S)

Browse source
This commit is contained in:
Schmoozerd 2012-07-19 21:52:06 +02:00
parent 865f7d7428
commit 08fd085549
18 changed files with 3168 additions and 3146 deletions
Download patch file Download diff file Expand all files Collapse all files

76
src/game/ScriptMgr.cpp
View file

@ -236,7 +236,7 @@ void ScriptMgr::LoadScripts(ScriptMapMapName& scripts, const char* tablename)
continue;
}
for(int i = 0; i < MAX_TEXT_ID; ++i)
for (int i = 0; i < MAX_TEXT_ID; ++i)
{
if (tmp.textId[i] && (tmp.textId[i] < MIN_DB_SCRIPT_STRING_ID || tmp.textId[i] >= MAX_DB_SCRIPT_STRING_ID))
{
@ -630,7 +630,8 @@ void ScriptMgr::LoadScripts(ScriptMapMapName& scripts, const char* tablename)
scripts.second[tmp.id].insert(ScriptMap::value_type(tmp.delay, tmp));
++count;
} while(result->NextRow());
}
while (result->NextRow());
delete result;
@ -643,7 +644,7 @@ void ScriptMgr::LoadGameObjectScripts()
LoadScripts(sGameObjectScripts, "gameobject_scripts");
// check ids
for(ScriptMapMap::const_iterator itr = sGameObjectScripts.second.begin(); itr != sGameObjectScripts.second.end(); ++itr)
for (ScriptMapMap::const_iterator itr = sGameObjectScripts.second.begin(); itr != sGameObjectScripts.second.end(); ++itr)
{
if (!sObjectMgr.GetGOData(itr->first))
sLog.outErrorDb("Table `gameobject_scripts` has not existing gameobject (GUID: %u) as script id", itr->first);
@ -667,7 +668,7 @@ void ScriptMgr::LoadQuestEndScripts()
LoadScripts(sQuestEndScripts, "quest_end_scripts");
// check ids
for(ScriptMapMap::const_iterator itr = sQuestEndScripts.second.begin(); itr != sQuestEndScripts.second.end(); ++itr)
for (ScriptMapMap::const_iterator itr = sQuestEndScripts.second.begin(); itr != sQuestEndScripts.second.end(); ++itr)
{
if (!sObjectMgr.GetQuestTemplate(itr->first))
sLog.outErrorDb("Table `quest_end_scripts` has not existing quest (Id: %u) as script id", itr->first);
@ -679,7 +680,7 @@ void ScriptMgr::LoadQuestStartScripts()
LoadScripts(sQuestStartScripts, "quest_start_scripts");
// check ids
for(ScriptMapMap::const_iterator itr = sQuestStartScripts.second.begin(); itr != sQuestStartScripts.second.end(); ++itr)
for (ScriptMapMap::const_iterator itr = sQuestStartScripts.second.begin(); itr != sQuestStartScripts.second.end(); ++itr)
{
if (!sObjectMgr.GetQuestTemplate(itr->first))
sLog.outErrorDb("Table `quest_start_scripts` has not existing quest (Id: %u) as script id", itr->first);
@ -723,7 +724,7 @@ void ScriptMgr::LoadEventScripts()
std::set<uint32> evt_scripts;
// Load all possible script entries from gameobjects
for(uint32 i = 1; i < sGOStorage.MaxEntry; ++i)
for (uint32 i = 1; i < sGOStorage.MaxEntry; ++i)
{
if (GameObjectInfo const* goInfo = sGOStorage.LookupEntry<GameObjectInfo>(i))
{
@ -745,12 +746,12 @@ void ScriptMgr::LoadEventScripts()
}
// Load all possible script entries from spells
for(uint32 i = 1; i < sSpellStore.GetNumRows(); ++i)
for (uint32 i = 1; i < sSpellStore.GetNumRows(); ++i)
{
SpellEntry const* spell = sSpellStore.LookupEntry(i);
if (spell)
{
for(int j = 0; j < MAX_EFFECT_INDEX; ++j)
for (int j = 0; j < MAX_EFFECT_INDEX; ++j)
{
if (spell->Effect[j] == SPELL_EFFECT_SEND_EVENT)
{
@ -761,9 +762,9 @@ void ScriptMgr::LoadEventScripts()
}
}
for(size_t path_idx = 0; path_idx < sTaxiPathNodesByPath.size(); ++path_idx)
for (size_t path_idx = 0; path_idx < sTaxiPathNodesByPath.size(); ++path_idx)
{
for(size_t node_idx = 0; node_idx < sTaxiPathNodesByPath[path_idx].size(); ++node_idx)
for (size_t node_idx = 0; node_idx < sTaxiPathNodesByPath[path_idx].size(); ++node_idx)
{
TaxiPathNodeEntry const& node = sTaxiPathNodesByPath[path_idx][node_idx];
@ -776,7 +777,7 @@ void ScriptMgr::LoadEventScripts()
}
// Then check if all scripts are in above list of possible script entries
for(ScriptMapMap::const_iterator itr = sEventScripts.second.begin(); itr != sEventScripts.second.end(); ++itr)
for (ScriptMapMap::const_iterator itr = sEventScripts.second.begin(); itr != sEventScripts.second.end(); ++itr)
{
std::set<uint32>::const_iterator itr2 = evt_scripts.find(itr->first);
if (itr2 == evt_scripts.end())
@ -805,7 +806,7 @@ void ScriptMgr::LoadDbScriptStrings()
std::set<int32> ids;
for(int32 i = MIN_DB_SCRIPT_STRING_ID; i < MAX_DB_SCRIPT_STRING_ID; ++i)
for (int32 i = MIN_DB_SCRIPT_STRING_ID; i < MAX_DB_SCRIPT_STRING_ID; ++i)
if (sObjectMgr.GetMangosStringLocale(i))
ids.insert(i);
@ -820,22 +821,22 @@ void ScriptMgr::LoadDbScriptStrings()
sWaypointMgr.CheckTextsExistance(ids);
for(std::set<int32>::const_iterator itr = ids.begin(); itr != ids.end(); ++itr)
for (std::set<int32>::const_iterator itr = ids.begin(); itr != ids.end(); ++itr)
sLog.outErrorDb("Table `db_script_string` has unused string id %u", *itr);
}
void ScriptMgr::CheckScriptTexts(ScriptMapMapName const& scripts, std::set<int32>& ids)
{
for(ScriptMapMap::const_iterator itrMM = scripts.second.begin(); itrMM != scripts.second.end(); ++itrMM)
for (ScriptMapMap::const_iterator itrMM = scripts.second.begin(); itrMM != scripts.second.end(); ++itrMM)
{
for(ScriptMap::const_iterator itrM = itrMM->second.begin(); itrM != itrMM->second.end(); ++itrM)
for (ScriptMap::const_iterator itrM = itrMM->second.begin(); itrM != itrMM->second.end(); ++itrM)
{
if (itrM->second.command == SCRIPT_COMMAND_TALK)
{
for(int i = 0; i < MAX_TEXT_ID; ++i)
for (int i = 0; i < MAX_TEXT_ID; ++i)
{
if (itrM->second.textId[i] && !sObjectMgr.GetMangosStringLocale(itrM->second.textId[i]))
sLog.outErrorDb( "Table `db_script_string` is missing string id %u, used in database script table %s id %u.", itrM->second.textId[i], scripts.first, itrMM->first);
sLog.outErrorDb("Table `db_script_string` is missing string id %u, used in database script table %s id %u.", itrM->second.textId[i], scripts.first, itrMM->first);
if (ids.find(itrM->second.textId[i]) != ids.end())
ids.erase(itrM->second.textId[i]);
@ -1042,7 +1043,7 @@ void ScriptAction::HandleScriptStep()
if (m_script->textId[1])
{
int i = 2;
for(; i < MAX_TEXT_ID; ++i)
for (; i < MAX_TEXT_ID; ++i)
{
if (!m_script->textId[i])
break;
@ -1472,7 +1473,7 @@ void ScriptAction::HandleScriptStep()
// Consider add additional checks for cases where creature should not change movementType
// (pet? in combat? already using same MMgen as script try to apply?)
switch(m_script->movement.movementType)
switch (m_script->movement.movementType)
{
case IDLE_MOTION_TYPE:
((Creature*)pSource)->GetMotionMaster()->MoveIdle();
@ -1661,7 +1662,7 @@ void ScriptAction::HandleScriptStep()
void ScriptMgr::LoadAreaTriggerScripts()
{
m_AreaTriggerScripts.clear(); // need for reload case
QueryResult *result = WorldDatabase.Query("SELECT entry, ScriptName FROM scripted_areatrigger");
QueryResult* result = WorldDatabase.Query("SELECT entry, ScriptName FROM scripted_areatrigger");
uint32 count = 0;
@ -1682,10 +1683,10 @@ void ScriptMgr::LoadAreaTriggerScripts()
++count;
bar.step();
Field *fields = result->Fetch();
Field* fields = result->Fetch();
uint32 triggerId = fields[0].GetUInt32();
const char *scriptName = fields[1].GetString();
const char* scriptName = fields[1].GetString();
if (!sAreaTriggerStore.LookupEntry(triggerId))
{
@ -1694,7 +1695,8 @@ void ScriptMgr::LoadAreaTriggerScripts()
}
m_AreaTriggerScripts[triggerId] = GetScriptId(scriptName);
} while(result->NextRow());
}
while (result->NextRow());
delete result;
@ -1705,7 +1707,7 @@ void ScriptMgr::LoadAreaTriggerScripts()
void ScriptMgr::LoadEventIdScripts()
{
m_EventIdScripts.clear(); // need for reload case
QueryResult *result = WorldDatabase.Query("SELECT id, ScriptName FROM scripted_event_id");
QueryResult* result = WorldDatabase.Query("SELECT id, ScriptName FROM scripted_event_id");
uint32 count = 0;
@ -1747,12 +1749,12 @@ void ScriptMgr::LoadEventIdScripts()
}
// Load all possible event entries from spells
for(uint32 i = 1; i < sSpellStore.GetNumRows(); ++i)
for (uint32 i = 1; i < sSpellStore.GetNumRows(); ++i)
{
SpellEntry const* spell = sSpellStore.LookupEntry(i);
if (spell)
{
for(int j = 0; j < MAX_EFFECT_INDEX; ++j)
for (int j = 0; j < MAX_EFFECT_INDEX; ++j)
{
if (spell->Effect[j] == SPELL_EFFECT_SEND_EVENT)
{
@ -1764,9 +1766,9 @@ void ScriptMgr::LoadEventIdScripts()
}
// Load all possible event entries from taxi path nodes
for(size_t path_idx = 0; path_idx < sTaxiPathNodesByPath.size(); ++path_idx)
for (size_t path_idx = 0; path_idx < sTaxiPathNodesByPath.size(); ++path_idx)
{
for(size_t node_idx = 0; node_idx < sTaxiPathNodesByPath[path_idx].size(); ++node_idx)
for (size_t node_idx = 0; node_idx < sTaxiPathNodesByPath[path_idx].size(); ++node_idx)
{
TaxiPathNodeEntry const& node = sTaxiPathNodesByPath[path_idx][node_idx];
@ -1783,10 +1785,10 @@ void ScriptMgr::LoadEventIdScripts()
++count;
bar.step();
Field *fields = result->Fetch();
Field* fields = result->Fetch();
uint32 eventId = fields[0].GetUInt32();
const char *scriptName = fields[1].GetString();
const char* scriptName = fields[1].GetString();
std::set<uint32>::const_iterator itr = evt_scripts.find(eventId);
if (itr == evt_scripts.end())
@ -1794,7 +1796,8 @@ void ScriptMgr::LoadEventIdScripts()
eventId, SPELL_EFFECT_SEND_EVENT);
m_EventIdScripts[eventId] = GetScriptId(scriptName);
} while(result->NextRow());
}
while (result->NextRow());
delete result;
@ -1805,7 +1808,7 @@ void ScriptMgr::LoadEventIdScripts()
void ScriptMgr::LoadScriptNames()
{
m_scriptNames.push_back("");
QueryResult *result = WorldDatabase.Query(
QueryResult* result = WorldDatabase.Query(
"SELECT DISTINCT(ScriptName) FROM creature_template WHERE ScriptName <> '' "
"UNION "
"SELECT DISTINCT(ScriptName) FROM gameobject_template WHERE ScriptName <> '' "
@ -1837,7 +1840,8 @@ void ScriptMgr::LoadScriptNames()
bar.step();
m_scriptNames.push_back((*result)[0].GetString());
++count;
} while (result->NextRow());
}
while (result->NextRow());
delete result;
std::sort(m_scriptNames.begin(), m_scriptNames.end());
@ -1845,7 +1849,7 @@ void ScriptMgr::LoadScriptNames()
sLog.outString(">> Loaded %d Script Names", count);
}
uint32 ScriptMgr::GetScriptId(const char *name) const
uint32 ScriptMgr::GetScriptId(const char* name) const
{
// use binary search to find the script name in the sorted vector
// assume "" is the first element
@ -2033,7 +2037,7 @@ ScriptLoadResult ScriptMgr::LoadScriptLibrary(const char* libName)
}
// let check used mangosd revision for build library (unsafe use with different revision because changes in inline functions, define and etc)
char const* (MANGOS_IMPORT* pGetMangosRevStr) ();
char const* (MANGOS_IMPORT* pGetMangosRevStr)();
GET_SCRIPT_HOOK_PTR(pGetMangosRevStr, "GetMangosRevStr");
@ -2130,7 +2134,7 @@ uint32 GetEventIdScriptId(uint32 eventId)
return sScriptMgr.GetEventIdScriptId(eventId);
}
uint32 GetScriptId(const char *name)
uint32 GetScriptId(const char* name)
{
return sScriptMgr.GetScriptId(name);
}

53
src/game/ScriptMgr.h
View file

@ -96,7 +96,8 @@ enum ScriptCommand // resSource, resTar
#define MAX_TEXT_ID 4 // used for SCRIPT_COMMAND_TALK
enum ScriptInfoDataFlags
{ // default: s/b -> t
{
// default: s/b -> t
SCRIPT_FLAG_BUDDY_AS_TARGET = 0x01, // s -> b
SCRIPT_FLAG_REVERSE_DIRECTION = 0x02, // t* -> s* (* result after previous flag is evaluated)
SCRIPT_FLAG_SOURCE_TARGETS_SELF = 0x04, // s* -> s* (* result after previous flag is evaluated)
@ -429,7 +430,7 @@ class ScriptMgr
uint32 GetEventIdScriptId(uint32 eventId) const;
const char* GetScriptName(uint32 id) const { return id < m_scriptNames.size() ? m_scriptNames[id].c_str() : ""; }
uint32 GetScriptId(const char *name) const;
uint32 GetScriptId(const char* name) const;
uint32 GetScriptIdsCount() const { return m_scriptNames.size(); }
ScriptLoadResult LoadScriptLibrary(const char* libName);
@ -493,37 +494,37 @@ class ScriptMgr
void (MANGOS_IMPORT* m_pOnFreeScriptLibrary)();
const char* (MANGOS_IMPORT* m_pGetScriptLibraryVersion)();
CreatureAI* (MANGOS_IMPORT* m_pGetCreatureAI) (Creature*);
InstanceData* (MANGOS_IMPORT* m_pCreateInstanceData) (Map*);
CreatureAI* (MANGOS_IMPORT* m_pGetCreatureAI)(Creature*);
InstanceData* (MANGOS_IMPORT* m_pCreateInstanceData)(Map*);
bool (MANGOS_IMPORT* m_pOnGossipHello) (Player*, Creature*);
bool (MANGOS_IMPORT* m_pOnGOGossipHello) (Player*, GameObject*);
bool (MANGOS_IMPORT* m_pOnGossipSelect) (Player*, Creature*, uint32, uint32);
bool (MANGOS_IMPORT* m_pOnGOGossipSelect) (Player*, GameObject*, uint32, uint32);
bool (MANGOS_IMPORT* m_pOnGossipSelectWithCode) (Player*, Creature*, uint32, uint32, const char*);
bool (MANGOS_IMPORT* m_pOnGOGossipSelectWithCode) (Player*, GameObject*, uint32, uint32, const char*);
bool (MANGOS_IMPORT* m_pOnQuestAccept) (Player*, Creature*, Quest const*);
bool (MANGOS_IMPORT* m_pOnGOQuestAccept) (Player*, GameObject*, Quest const*);
bool (MANGOS_IMPORT* m_pOnItemQuestAccept) (Player*, Item*, Quest const*);
bool (MANGOS_IMPORT* m_pOnQuestRewarded) (Player*, Creature*, Quest const*);
bool (MANGOS_IMPORT* m_pOnGOQuestRewarded) (Player*, GameObject*, Quest const*);
uint32 (MANGOS_IMPORT* m_pGetNPCDialogStatus) (Player*, Creature*);
uint32 (MANGOS_IMPORT* m_pGetGODialogStatus) (Player*, GameObject*);
bool (MANGOS_IMPORT* m_pOnGOUse) (Player*, GameObject*);
bool (MANGOS_IMPORT* m_pOnItemUse) (Player*, Item*, SpellCastTargets const&);
bool (MANGOS_IMPORT* m_pOnAreaTrigger) (Player*, AreaTriggerEntry const*);
bool (MANGOS_IMPORT* m_pOnProcessEvent) (uint32, Object*, Object*, bool);
bool (MANGOS_IMPORT* m_pOnEffectDummyCreature) (Unit*, uint32, SpellEffectIndex, Creature*);
bool (MANGOS_IMPORT* m_pOnEffectDummyGO) (Unit*, uint32, SpellEffectIndex, GameObject*);
bool (MANGOS_IMPORT* m_pOnEffectDummyItem) (Unit*, uint32, SpellEffectIndex, Item*);
bool (MANGOS_IMPORT* m_pOnAuraDummy) (Aura const*, bool);
bool (MANGOS_IMPORT* m_pOnGossipHello)(Player*, Creature*);
bool (MANGOS_IMPORT* m_pOnGOGossipHello)(Player*, GameObject*);
bool (MANGOS_IMPORT* m_pOnGossipSelect)(Player*, Creature*, uint32, uint32);
bool (MANGOS_IMPORT* m_pOnGOGossipSelect)(Player*, GameObject*, uint32, uint32);
bool (MANGOS_IMPORT* m_pOnGossipSelectWithCode)(Player*, Creature*, uint32, uint32, const char*);
bool (MANGOS_IMPORT* m_pOnGOGossipSelectWithCode)(Player*, GameObject*, uint32, uint32, const char*);
bool (MANGOS_IMPORT* m_pOnQuestAccept)(Player*, Creature*, Quest const*);
bool (MANGOS_IMPORT* m_pOnGOQuestAccept)(Player*, GameObject*, Quest const*);
bool (MANGOS_IMPORT* m_pOnItemQuestAccept)(Player*, Item*, Quest const*);
bool (MANGOS_IMPORT* m_pOnQuestRewarded)(Player*, Creature*, Quest const*);
bool (MANGOS_IMPORT* m_pOnGOQuestRewarded)(Player*, GameObject*, Quest const*);
uint32(MANGOS_IMPORT* m_pGetNPCDialogStatus)(Player*, Creature*);
uint32(MANGOS_IMPORT* m_pGetGODialogStatus)(Player*, GameObject*);
bool (MANGOS_IMPORT* m_pOnGOUse)(Player*, GameObject*);
bool (MANGOS_IMPORT* m_pOnItemUse)(Player*, Item*, SpellCastTargets const&);
bool (MANGOS_IMPORT* m_pOnAreaTrigger)(Player*, AreaTriggerEntry const*);
bool (MANGOS_IMPORT* m_pOnProcessEvent)(uint32, Object*, Object*, bool);
bool (MANGOS_IMPORT* m_pOnEffectDummyCreature)(Unit*, uint32, SpellEffectIndex, Creature*);
bool (MANGOS_IMPORT* m_pOnEffectDummyGO)(Unit*, uint32, SpellEffectIndex, GameObject*);
bool (MANGOS_IMPORT* m_pOnEffectDummyItem)(Unit*, uint32, SpellEffectIndex, Item*);
bool (MANGOS_IMPORT* m_pOnAuraDummy)(Aura const*, bool);
};
#define sScriptMgr MaNGOS::Singleton<ScriptMgr>::Instance()
MANGOS_DLL_SPEC uint32 GetAreaTriggerScriptId(uint32 triggerId);
MANGOS_DLL_SPEC uint32 GetEventIdScriptId(uint32 eventId);
MANGOS_DLL_SPEC uint32 GetScriptId(const char *name);
MANGOS_DLL_SPEC uint32 GetScriptId(const char* name);
MANGOS_DLL_SPEC char const* GetScriptName(uint32 id);
MANGOS_DLL_SPEC uint32 GetScriptIdsCount();

28
src/game/SharedDefines.h
View file

@ -172,30 +172,30 @@ enum SpellSchoolMask
{
SPELL_SCHOOL_MASK_NONE = 0x00, // not exist
SPELL_SCHOOL_MASK_NORMAL = (1 << SPELL_SCHOOL_NORMAL), // PHYSICAL (Armor)
SPELL_SCHOOL_MASK_HOLY = (1 << SPELL_SCHOOL_HOLY ),
SPELL_SCHOOL_MASK_FIRE = (1 << SPELL_SCHOOL_FIRE ),
SPELL_SCHOOL_MASK_HOLY = (1 << SPELL_SCHOOL_HOLY),
SPELL_SCHOOL_MASK_FIRE = (1 << SPELL_SCHOOL_FIRE),
SPELL_SCHOOL_MASK_NATURE = (1 << SPELL_SCHOOL_NATURE),
SPELL_SCHOOL_MASK_FROST = (1 << SPELL_SCHOOL_FROST ),
SPELL_SCHOOL_MASK_FROST = (1 << SPELL_SCHOOL_FROST),
SPELL_SCHOOL_MASK_SHADOW = (1 << SPELL_SCHOOL_SHADOW),
SPELL_SCHOOL_MASK_ARCANE = (1 << SPELL_SCHOOL_ARCANE),
// unions
// 124, not include normal and holy damage
SPELL_SCHOOL_MASK_SPELL = ( SPELL_SCHOOL_MASK_FIRE |
SPELL_SCHOOL_MASK_SPELL = (SPELL_SCHOOL_MASK_FIRE |
SPELL_SCHOOL_MASK_NATURE | SPELL_SCHOOL_MASK_FROST |
SPELL_SCHOOL_MASK_SHADOW | SPELL_SCHOOL_MASK_ARCANE ),
SPELL_SCHOOL_MASK_SHADOW | SPELL_SCHOOL_MASK_ARCANE),
// 126
SPELL_SCHOOL_MASK_MAGIC = ( SPELL_SCHOOL_MASK_HOLY | SPELL_SCHOOL_MASK_SPELL ),
SPELL_SCHOOL_MASK_MAGIC = (SPELL_SCHOOL_MASK_HOLY | SPELL_SCHOOL_MASK_SPELL),
// 127
SPELL_SCHOOL_MASK_ALL = ( SPELL_SCHOOL_MASK_NORMAL | SPELL_SCHOOL_MASK_MAGIC )
SPELL_SCHOOL_MASK_ALL = (SPELL_SCHOOL_MASK_NORMAL | SPELL_SCHOOL_MASK_MAGIC)
};
inline SpellSchools GetFirstSchoolInMask(SpellSchoolMask mask)
{
for(int i = 0; i < MAX_SPELL_SCHOOL; ++i)
if(mask & (1 << i))
for (int i = 0; i < MAX_SPELL_SCHOOL; ++i)
if (mask & (1 << i))
return SpellSchools(i);
return SPELL_SCHOOL_NORMAL;
@ -215,7 +215,8 @@ enum ItemQualities
#define MAX_ITEM_QUALITY 8
const uint32 ItemQualityColors[MAX_ITEM_QUALITY] = {
const uint32 ItemQualityColors[MAX_ITEM_QUALITY] =
{
0xff9d9d9d, //GREY
0xffffffff, //WHITE
0xff1eff00, //GREEN
@ -1065,7 +1066,8 @@ enum SpellCastResultCustom
// Spell aura states
enum AuraState
{ // (C) used in caster aura state (T) used in target aura state
{
// (C) used in caster aura state (T) used in target aura state
// (c) used in caster aura state-not (t) used in target aura state-not
AURA_STATE_DEFENSE = 1, // C |
AURA_STATE_HEALTHLESS_20_PERCENT = 2, // CcT |
@ -2224,7 +2226,7 @@ enum QuestSort
inline uint8 ClassByQuestSort(int32 QuestSort)
{
switch(QuestSort)
switch (QuestSort)
{
case QUEST_SORT_WARLOCK: return CLASS_WARLOCK;
case QUEST_SORT_WARRIOR: return CLASS_WARRIOR;
@ -2400,7 +2402,7 @@ enum SkillType
inline SkillType SkillByLockType(LockType locktype)
{
switch(locktype)
switch (locktype)
{
case LOCKTYPE_PICKLOCK: return SKILL_LOCKPICKING;
case LOCKTYPE_HERBALISM: return SKILL_HERBALISM;

27
src/game/SkillDiscovery.cpp
View file

@ -54,12 +54,12 @@ void LoadSkillDiscoveryTable()
uint32 count = 0;
// 0 1 2 3
QueryResult *result = WorldDatabase.Query("SELECT spellId, reqSpell, reqSkillValue, chance FROM skill_discovery_template");
QueryResult* result = WorldDatabase.Query("SELECT spellId, reqSpell, reqSkillValue, chance FROM skill_discovery_template");
if (!result)
{
sLog.outString();
sLog.outString( ">> Loaded 0 skill discovery definitions. DB table `skill_discovery_template` is empty." );
sLog.outString(">> Loaded 0 skill discovery definitions. DB table `skill_discovery_template` is empty.");
return;
}
@ -70,7 +70,7 @@ void LoadSkillDiscoveryTable()
do
{
Field *fields = result->Fetch();
Field* fields = result->Fetch();
bar.step();
uint32 spellId = fields[0].GetUInt32();
@ -113,7 +113,7 @@ void LoadSkillDiscoveryTable()
continue;
}
SkillDiscoveryStore[reqSkillOrSpell].push_back( SkillDiscoveryEntry(spellId, reqSkillValue, chance) );
SkillDiscoveryStore[reqSkillOrSpell].push_back(SkillDiscoveryEntry(spellId, reqSkillValue, chance));
}
else if (reqSkillOrSpell == 0) // skill case
{
@ -125,8 +125,8 @@ void LoadSkillDiscoveryTable()
continue;
}
for(SkillLineAbilityMap::const_iterator _spell_idx = bounds.first; _spell_idx != bounds.second; ++_spell_idx)
SkillDiscoveryStore[-int32(_spell_idx->second->skillId)].push_back( SkillDiscoveryEntry(spellId, reqSkillValue, chance) );
for (SkillLineAbilityMap::const_iterator _spell_idx = bounds.first; _spell_idx != bounds.second; ++_spell_idx)
SkillDiscoveryStore[-int32(_spell_idx->second->skillId)].push_back(SkillDiscoveryEntry(spellId, reqSkillValue, chance));
}
else
{
@ -135,17 +135,18 @@ void LoadSkillDiscoveryTable()
}
++count;
} while (result->NextRow());
}
while (result->NextRow());
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u skill discovery definitions", count );
sLog.outString(">> Loaded %u skill discovery definitions", count);
if (!ssNonDiscoverableEntries.str().empty())
sLog.outErrorDb("Some items can't be successfully discovered: have in chance field value < 0.000001 in `skill_discovery_template` DB table . List:\n%s",ssNonDiscoverableEntries.str().c_str());
// report about empty data for explicit discovery spells
for(uint32 spell_id = 1; spell_id < sSpellStore.GetNumRows(); ++spell_id)
for (uint32 spell_id = 1; spell_id < sSpellStore.GetNumRows(); ++spell_id)
{
SpellEntry const* spellEntry = sSpellStore.LookupEntry(spell_id);
if (!spellEntry)
@ -172,7 +173,7 @@ uint32 GetExplicitDiscoverySpell(uint32 spellId, Player* player)
uint32 skillvalue = bounds.first != bounds.second ? player->GetSkillValue(bounds.first->second->skillId) : 0;
float full_chance = 0;
for(SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
for (SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
if (item_iter->reqSkillValue <= skillvalue)
if (!player->HasSpell(item_iter->spellId))
full_chance += item_iter->chance;
@ -180,7 +181,7 @@ uint32 GetExplicitDiscoverySpell(uint32 spellId, Player* player)
float rate = full_chance / 100.0f;
float roll = rand_chance_f() * rate; // roll now in range 0..full_chance
for(SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
for (SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
{
if (item_iter->reqSkillValue > skillvalue)
continue;
@ -206,7 +207,7 @@ uint32 GetSkillDiscoverySpell(uint32 skillId, uint32 spellId, Player* player)
if (tab != SkillDiscoveryStore.end())
{
for(SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
for (SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
{
if (roll_chance_f(item_iter->chance * sWorld.getConfig(CONFIG_FLOAT_RATE_SKILL_DISCOVERY)) &&
item_iter->reqSkillValue <= skillvalue &&
@ -224,7 +225,7 @@ uint32 GetSkillDiscoverySpell(uint32 skillId, uint32 spellId, Player* player)
tab = SkillDiscoveryStore.find(-(int32)skillId);
if (tab != SkillDiscoveryStore.end())
{
for(SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
for (SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
{
if (roll_chance_f(item_iter->chance * sWorld.getConfig(CONFIG_FLOAT_RATE_SKILL_DISCOVERY)) &&
item_iter->reqSkillValue <= skillvalue &&

17
src/game/SkillExtraItems.cpp
View file

@ -59,7 +59,7 @@ void LoadSkillExtraItemTable()
SkillExtraItemStore.clear(); // need for reload
// 0 1 2 3
QueryResult *result = WorldDatabase.Query("SELECT spellId, requiredSpecialization, additionalCreateChance, additionalMaxNum FROM skill_extra_item_template");
QueryResult* result = WorldDatabase.Query("SELECT spellId, requiredSpecialization, additionalCreateChance, additionalMaxNum FROM skill_extra_item_template");
if (result)
{
@ -67,7 +67,7 @@ void LoadSkillExtraItemTable()
do
{
Field *fields = result->Fetch();
Field* fields = result->Fetch();
bar.step();
uint32 spellId = fields[0].GetUInt32();
@ -106,7 +106,8 @@ void LoadSkillExtraItemTable()
skillExtraItemEntry.additionalMaxNum = additionalMaxNum;
++count;
} while (result->NextRow());
}
while (result->NextRow());
delete result;
@ -116,25 +117,25 @@ void LoadSkillExtraItemTable()
else
{
sLog.outString();
sLog.outString( ">> Loaded 0 spell specialization definitions. DB table `skill_extra_item_template` is empty." );
sLog.outString(">> Loaded 0 spell specialization definitions. DB table `skill_extra_item_template` is empty.");
}
}
bool canCreateExtraItems(Player * player, uint32 spellId, float &additionalChance, uint8 &additionalMax)
bool canCreateExtraItems(Player* player, uint32 spellId, float& additionalChance, uint8& additionalMax)
{
// get the info for the specified spell
SkillExtraItemMap::const_iterator ret = SkillExtraItemStore.find(spellId);
if(ret==SkillExtraItemStore.end())
if (ret==SkillExtraItemStore.end())
return false;
SkillExtraItemEntry const* specEntry = &ret->second;
// if no entry, then no extra items can be created
if(!specEntry)
if (!specEntry)
return false;
// the player doesn't have the required specialization, return false
if(!player->HasSpell(specEntry->requiredSpecialization))
if (!player->HasSpell(specEntry->requiredSpecialization))
return false;
// set the arguments to the appropriate values

2
src/game/SkillExtraItems.h
View file

@ -24,7 +24,7 @@
// predef classes used in functions
class Player;
// returns true and sets the appropriate info if the player can create extra items with the given spellId
bool canCreateExtraItems(Player * player, uint32 spellId, float &additionalChance, uint8 &additionalMax);
bool canCreateExtraItems(Player* player, uint32 spellId, float& additionalChance, uint8& additionalMax);
// function to load the extra item creation info from DB
void LoadSkillExtraItemTable();
#endif

16
src/game/SkillHandler.cpp
View file

@ -25,7 +25,7 @@
#include "WorldSession.h"
#include "UpdateMask.h"
void WorldSession::HandleLearnTalentOpcode( WorldPacket & recv_data )
void WorldSession::HandleLearnTalentOpcode(WorldPacket& recv_data)
{
uint32 talent_id, requested_rank;
recv_data >> talent_id >> requested_rank;
@ -43,7 +43,7 @@ void WorldSession::HandleLearnPreviewTalents(WorldPacket& recvPacket)
uint32 talentId, talentRank;
for(uint32 i = 0; i < talentsCount; ++i)
for (uint32 i = 0; i < talentsCount; ++i)
{
recvPacket >> talentId >> talentRank;
@ -53,16 +53,16 @@ void WorldSession::HandleLearnPreviewTalents(WorldPacket& recvPacket)
_player->SendTalentsInfoData(false);
}
void WorldSession::HandleTalentWipeConfirmOpcode( WorldPacket & recv_data )
void WorldSession::HandleTalentWipeConfirmOpcode(WorldPacket& recv_data)
{
DETAIL_LOG("MSG_TALENT_WIPE_CONFIRM");
ObjectGuid guid;
recv_data >> guid;
Creature *unit = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_TRAINER);
Creature* unit = GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_TRAINER);
if (!unit)
{
DEBUG_LOG( "WORLD: HandleTalentWipeConfirmOpcode - %s not found or you can't interact with him.", guid.GetString().c_str());
DEBUG_LOG("WORLD: HandleTalentWipeConfirmOpcode - %s not found or you can't interact with him.", guid.GetString().c_str());
return;
}
@ -72,10 +72,10 @@ void WorldSession::HandleTalentWipeConfirmOpcode( WorldPacket & recv_data )
if (!(_player->resetTalents()))
{
WorldPacket data( MSG_TALENT_WIPE_CONFIRM, 8+4); //you have not any talent
WorldPacket data(MSG_TALENT_WIPE_CONFIRM, 8+4); //you have not any talent
data << uint64(0);
data << uint32(0);
SendPacket( &data );
SendPacket(&data);
return;
}
@ -83,7 +83,7 @@ void WorldSession::HandleTalentWipeConfirmOpcode( WorldPacket & recv_data )
unit->CastSpell(_player, 14867, true); //spell: "Untalent Visual Effect"
}
void WorldSession::HandleUnlearnSkillOpcode(WorldPacket & recv_data)
void WorldSession::HandleUnlearnSkillOpcode(WorldPacket& recv_data)
{
uint32 skill_id;
recv_data >> skill_id;

88
src/game/SocialMgr.cpp
View file

@ -26,7 +26,7 @@
#include "World.h"
#include "Util.h"
INSTANTIATE_SINGLETON_1( SocialMgr );
INSTANTIATE_SINGLETON_1(SocialMgr);
PlayerSocial::PlayerSocial()
{
@ -40,9 +40,9 @@ PlayerSocial::~PlayerSocial()
uint32 PlayerSocial::GetNumberOfSocialsWithFlag(SocialFlag flag)
{
uint32 counter = 0;
for(PlayerSocialMap::const_iterator itr = m_playerSocialMap.begin(); itr != m_playerSocialMap.end(); ++itr)
for (PlayerSocialMap::const_iterator itr = m_playerSocialMap.begin(); itr != m_playerSocialMap.end(); ++itr)
{
if(itr->second.Flags & flag)
if (itr->second.Flags & flag)
++counter;
}
return counter;
@ -51,23 +51,23 @@ uint32 PlayerSocial::GetNumberOfSocialsWithFlag(SocialFlag flag)
bool PlayerSocial::AddToSocialList(ObjectGuid friend_guid, bool ignore)
{
// check client limits
if(ignore)
if (ignore)
{
if(GetNumberOfSocialsWithFlag(SOCIAL_FLAG_IGNORED) >= SOCIALMGR_IGNORE_LIMIT)
if (GetNumberOfSocialsWithFlag(SOCIAL_FLAG_IGNORED) >= SOCIALMGR_IGNORE_LIMIT)
return false;
}
else
{
if(GetNumberOfSocialsWithFlag(SOCIAL_FLAG_FRIEND) >= SOCIALMGR_FRIEND_LIMIT)
if (GetNumberOfSocialsWithFlag(SOCIAL_FLAG_FRIEND) >= SOCIALMGR_FRIEND_LIMIT)
return false;
}
uint32 flag = SOCIAL_FLAG_FRIEND;
if(ignore)
if (ignore)
flag = SOCIAL_FLAG_IGNORED;
PlayerSocialMap::const_iterator itr = m_playerSocialMap.find(friend_guid.GetCounter());
if(itr != m_playerSocialMap.end())
if (itr != m_playerSocialMap.end())
{
CharacterDatabase.PExecute("UPDATE character_social SET flags = (flags | %u) WHERE guid = '%u' AND friend = '%u'", flag, m_playerLowGuid, friend_guid.GetCounter());
m_playerSocialMap[friend_guid.GetCounter()].Flags |= flag;
@ -85,15 +85,15 @@ bool PlayerSocial::AddToSocialList(ObjectGuid friend_guid, bool ignore)
void PlayerSocial::RemoveFromSocialList(ObjectGuid friend_guid, bool ignore)
{
PlayerSocialMap::iterator itr = m_playerSocialMap.find(friend_guid.GetCounter());
if(itr == m_playerSocialMap.end()) // not exist
if (itr == m_playerSocialMap.end()) // not exist
return;
uint32 flag = SOCIAL_FLAG_FRIEND;
if(ignore)
if (ignore)
flag = SOCIAL_FLAG_IGNORED;
itr->second.Flags &= ~flag;
if(itr->second.Flags == 0)
if (itr->second.Flags == 0)
{
CharacterDatabase.PExecute("DELETE FROM character_social WHERE guid = '%u' AND friend = '%u'", m_playerLowGuid, friend_guid.GetCounter());
m_playerSocialMap.erase(itr);
@ -107,7 +107,7 @@ void PlayerSocial::RemoveFromSocialList(ObjectGuid friend_guid, bool ignore)
void PlayerSocial::SetFriendNote(ObjectGuid friend_guid, std::string note)
{
PlayerSocialMap::const_iterator itr = m_playerSocialMap.find(friend_guid.GetCounter());
if(itr == m_playerSocialMap.end()) // not exist
if (itr == m_playerSocialMap.end()) // not exist
return;
utf8truncate(note,48); // DB and client size limitation
@ -120,8 +120,8 @@ void PlayerSocial::SetFriendNote(ObjectGuid friend_guid, std::string note)
void PlayerSocial::SendSocialList()
{
Player *plr = sObjectMgr.GetPlayer(ObjectGuid(HIGHGUID_PLAYER, m_playerLowGuid));
if(!plr)
Player* plr = sObjectMgr.GetPlayer(ObjectGuid(HIGHGUID_PLAYER, m_playerLowGuid));
if (!plr)
return;
uint32 size = m_playerSocialMap.size();
@ -130,17 +130,17 @@ void PlayerSocial::SendSocialList()
data << uint32(7); // unk flag (0x1, 0x2, 0x4), 0x7 if it include ignore list
data << uint32(size); // friends count
for(PlayerSocialMap::iterator itr = m_playerSocialMap.begin(); itr != m_playerSocialMap.end(); ++itr)
for (PlayerSocialMap::iterator itr = m_playerSocialMap.begin(); itr != m_playerSocialMap.end(); ++itr)
{
sSocialMgr.GetFriendInfo(plr, itr->first, itr->second);
data << ObjectGuid(HIGHGUID_PLAYER, itr->first); // player guid
data << uint32(itr->second.Flags); // player flag (0x1-friend?, 0x2-ignored?, 0x4-muted?)
data << itr->second.Note; // string note
if(itr->second.Flags & SOCIAL_FLAG_FRIEND) // if IsFriend()
if (itr->second.Flags & SOCIAL_FLAG_FRIEND) // if IsFriend()
{
data << uint8(itr->second.Status); // online/offline/etc?
if(itr->second.Status) // if online
if (itr->second.Status) // if online
{
data << uint32(itr->second.Area); // player area
data << uint32(itr->second.Level); // player level
@ -156,7 +156,7 @@ void PlayerSocial::SendSocialList()
bool PlayerSocial::HasFriend(ObjectGuid friend_guid)
{
PlayerSocialMap::const_iterator itr = m_playerSocialMap.find(friend_guid.GetCounter());
if(itr != m_playerSocialMap.end())
if (itr != m_playerSocialMap.end())
return itr->second.Flags & SOCIAL_FLAG_FRIEND;
return false;
}
@ -164,7 +164,7 @@ bool PlayerSocial::HasFriend(ObjectGuid friend_guid)
bool PlayerSocial::HasIgnore(ObjectGuid ignore_guid)
{
PlayerSocialMap::const_iterator itr = m_playerSocialMap.find(ignore_guid.GetCounter());
if(itr != m_playerSocialMap.end())
if (itr != m_playerSocialMap.end())
return itr->second.Flags & SOCIAL_FLAG_IGNORED;
return false;
}
@ -179,20 +179,20 @@ SocialMgr::~SocialMgr()
}
void SocialMgr::GetFriendInfo(Player *player, uint32 friend_lowguid, FriendInfo &friendInfo)
void SocialMgr::GetFriendInfo(Player* player, uint32 friend_lowguid, FriendInfo& friendInfo)
{
if(!player)
if (!player)
return;
Player *pFriend = ObjectAccessor::FindPlayer(ObjectGuid(HIGHGUID_PLAYER, friend_lowguid));
Player* pFriend = ObjectAccessor::FindPlayer(ObjectGuid(HIGHGUID_PLAYER, friend_lowguid));
Team team = player->GetTeam();
AccountTypes security = player->GetSession()->GetSecurity();
bool allowTwoSideWhoList = sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_WHO_LIST);
AccountTypes gmLevelInWhoList = AccountTypes (sWorld.getConfig(CONFIG_UINT32_GM_LEVEL_IN_WHO_LIST));
AccountTypes gmLevelInWhoList = AccountTypes(sWorld.getConfig(CONFIG_UINT32_GM_LEVEL_IN_WHO_LIST));
PlayerSocialMap::iterator itr = player->GetSocial()->m_playerSocialMap.find(friend_lowguid);
if(itr != player->GetSocial()->m_playerSocialMap.end())
if (itr != player->GetSocial()->m_playerSocialMap.end())
friendInfo.Note = itr->second.Note;
// PLAYER see his team only and PLAYER can't see MODERATOR, GAME MASTER, ADMINISTRATOR characters
@ -203,9 +203,9 @@ void SocialMgr::GetFriendInfo(Player *player, uint32 friend_lowguid, FriendInfo
pFriend->IsVisibleGloballyFor(player))
{
friendInfo.Status = FRIEND_STATUS_ONLINE;
if(pFriend->isAFK())
if (pFriend->isAFK())
friendInfo.Status = FRIEND_STATUS_AFK;
if(pFriend->isDND())
if (pFriend->isDND())
friendInfo.Status = FRIEND_STATUS_DND;
friendInfo.Area = pFriend->GetZoneId();
friendInfo.Level = pFriend->getLevel();
@ -220,14 +220,14 @@ void SocialMgr::GetFriendInfo(Player *player, uint32 friend_lowguid, FriendInfo
}
}
void SocialMgr::MakeFriendStatusPacket(FriendsResult result, uint32 guid, WorldPacket *data)
void SocialMgr::MakeFriendStatusPacket(FriendsResult result, uint32 guid, WorldPacket* data)
{
data->Initialize(SMSG_FRIEND_STATUS, 5);
*data << uint8(result);
*data << ObjectGuid(HIGHGUID_PLAYER, guid);
}
void SocialMgr::SendFriendStatus(Player *player, FriendsResult result, ObjectGuid friend_guid, bool broadcast)
void SocialMgr::SendFriendStatus(Player* player, FriendsResult result, ObjectGuid friend_guid, bool broadcast)
{
uint32 friend_lowguid = friend_guid.GetCounter();
@ -236,7 +236,7 @@ void SocialMgr::SendFriendStatus(Player *player, FriendsResult result, ObjectGui
WorldPacket data;
MakeFriendStatusPacket(result, friend_lowguid, &data);
GetFriendInfo(player, friend_lowguid, fi);
switch(result)
switch (result)
{
case FRIEND_ADDED_OFFLINE:
case FRIEND_ADDED_ONLINE:
@ -246,7 +246,7 @@ void SocialMgr::SendFriendStatus(Player *player, FriendsResult result, ObjectGui
break;
}
switch(result)
switch (result)
{
case FRIEND_ADDED_ONLINE:
case FRIEND_ONLINE:
@ -259,15 +259,15 @@ void SocialMgr::SendFriendStatus(Player *player, FriendsResult result, ObjectGui
break;
}
if(broadcast)
if (broadcast)
BroadcastToFriendListers(player, &data);
else
player->GetSession()->SendPacket(&data);
}
void SocialMgr::BroadcastToFriendListers(Player *player, WorldPacket *packet)
void SocialMgr::BroadcastToFriendListers(Player* player, WorldPacket* packet)
{
if(!player)
if (!player)
return;
Team team = player->GetTeam();
@ -276,12 +276,12 @@ void SocialMgr::BroadcastToFriendListers(Player *player, WorldPacket *packet)
AccountTypes gmLevelInWhoList = AccountTypes(sWorld.getConfig(CONFIG_UINT32_GM_LEVEL_IN_WHO_LIST));
bool allowTwoSideWhoList = sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_WHO_LIST);
for(SocialMap::const_iterator itr = m_socialMap.begin(); itr != m_socialMap.end(); ++itr)
for (SocialMap::const_iterator itr = m_socialMap.begin(); itr != m_socialMap.end(); ++itr)
{
PlayerSocialMap::const_iterator itr2 = itr->second.m_playerSocialMap.find(guid);
if(itr2 != itr->second.m_playerSocialMap.end() && (itr2->second.Flags & SOCIAL_FLAG_FRIEND))
if (itr2 != itr->second.m_playerSocialMap.end() && (itr2->second.Flags & SOCIAL_FLAG_FRIEND))
{
Player *pFriend = ObjectAccessor::FindPlayer(ObjectGuid(HIGHGUID_PLAYER, itr->first));
Player* pFriend = ObjectAccessor::FindPlayer(ObjectGuid(HIGHGUID_PLAYER, itr->first));
// PLAYER see his team only and PLAYER can't see MODERATOR, GAME MASTER, ADMINISTRATOR characters
// MODERATOR, GAME MASTER, ADMINISTRATOR can see all
@ -296,12 +296,12 @@ void SocialMgr::BroadcastToFriendListers(Player *player, WorldPacket *packet)
}
}
PlayerSocial *SocialMgr::LoadFromDB(QueryResult *result, ObjectGuid guid)
PlayerSocial* SocialMgr::LoadFromDB(QueryResult* result, ObjectGuid guid)
{
PlayerSocial *social = &m_socialMap[guid.GetCounter()];
PlayerSocial* social = &m_socialMap[guid.GetCounter()];
social->SetPlayerGuid(guid);
if(!result)
if (!result)
return social;
uint32 friend_guid = 0;
@ -313,25 +313,25 @@ PlayerSocial *SocialMgr::LoadFromDB(QueryResult *result, ObjectGuid guid)
do
{
Field *fields = result->Fetch();
Field* fields = result->Fetch();
friend_guid = fields[0].GetUInt32();
flags = fields[1].GetUInt32();
note = fields[2].GetCppString();
if((flags & SOCIAL_FLAG_IGNORED) && ignoreCounter >= SOCIALMGR_IGNORE_LIMIT)
if ((flags & SOCIAL_FLAG_IGNORED) && ignoreCounter >= SOCIALMGR_IGNORE_LIMIT)
continue;
if((flags & SOCIAL_FLAG_FRIEND) && friendCounter >= SOCIALMGR_FRIEND_LIMIT)
if ((flags & SOCIAL_FLAG_FRIEND) && friendCounter >= SOCIALMGR_FRIEND_LIMIT)
continue;
social->m_playerSocialMap[friend_guid] = FriendInfo(flags, note);
if(flags & SOCIAL_FLAG_IGNORED)
if (flags & SOCIAL_FLAG_IGNORED)
ignoreCounter++;
else
friendCounter++;
}
while( result->NextRow() );
while (result->NextRow());
delete result;
return social;
}

10
src/game/SocialMgr.h
View file

@ -143,13 +143,13 @@ class SocialMgr
// Misc
void RemovePlayerSocial(uint32 guid) { m_socialMap.erase(guid); }
void GetFriendInfo(Player *player, uint32 friendGUID, FriendInfo &friendInfo);
void GetFriendInfo(Player* player, uint32 friendGUID, FriendInfo& friendInfo);
// Packet management
void MakeFriendStatusPacket(FriendsResult result, uint32 friend_guid, WorldPacket *data);
void SendFriendStatus(Player *player, FriendsResult result, ObjectGuid friend_guid, bool broadcast);
void BroadcastToFriendListers(Player *player, WorldPacket *packet);
void MakeFriendStatusPacket(FriendsResult result, uint32 friend_guid, WorldPacket* data);
void SendFriendStatus(Player* player, FriendsResult result, ObjectGuid friend_guid, bool broadcast);
void BroadcastToFriendListers(Player* player, WorldPacket* packet);
// Loading
PlayerSocial *LoadFromDB(QueryResult *result, ObjectGuid guid);
PlayerSocial* LoadFromDB(QueryResult* result, ObjectGuid guid);
private:
SocialMap m_socialMap;
};

1190
src/game/Spell.cpp
View file

File diff suppressed because it is too large Load diff

138
src/game/Spell.h
View file

@ -107,12 +107,12 @@ class SpellCastTargets
SpellCastTargets();
~SpellCastTargets();
void read( ByteBuffer& data, Unit *caster );
void write( ByteBuffer& data ) const;
void read(ByteBuffer& data, Unit* caster);
void write(ByteBuffer& data) const;
SpellCastTargetsReader ReadForCaster(Unit* caster) { return SpellCastTargetsReader(*this,caster); }
SpellCastTargets& operator=(const SpellCastTargets &target)
SpellCastTargets& operator=(const SpellCastTargets& target)
{
m_unitTarget = target.m_unitTarget;
m_itemTarget = target.m_itemTarget;
@ -143,14 +143,14 @@ class SpellCastTargets
}
ObjectGuid getUnitTargetGuid() const { return m_unitTargetGUID; }
Unit *getUnitTarget() const { return m_unitTarget; }
void setUnitTarget(Unit *target);
Unit* getUnitTarget() const { return m_unitTarget; }
void setUnitTarget(Unit* target);
void setDestination(float x, float y, float z);
void setSource(float x, float y, float z);
ObjectGuid getGOTargetGuid() const { return m_GOTargetGUID; }
GameObject *getGOTarget() const { return m_GOTarget; }
void setGOTarget(GameObject *target);
GameObject* getGOTarget() const { return m_GOTarget; }
void setGOTarget(GameObject* target);
ObjectGuid getCorpseTargetGuid() const { return m_CorpseTargetGUID; }
void setCorpseTarget(Corpse* corpse);
@ -162,7 +162,7 @@ class SpellCastTargets
void setTradeItemTarget(Player* caster);
void updateTradeSlotItem()
{
if(m_itemTarget && (m_targetMask & TARGET_FLAG_TRADE_ITEM))
if (m_itemTarget && (m_targetMask & TARGET_FLAG_TRADE_ITEM))
{
m_itemTargetGUID = m_itemTarget->GetObjectGuid();
m_itemTargetEntry = m_itemTarget->GetEntry();
@ -180,9 +180,9 @@ class SpellCastTargets
uint32 m_targetMask;
private:
// objects (can be used at spell creating and after Update at casting
Unit *m_unitTarget;
GameObject *m_GOTarget;
Item *m_itemTarget;
Unit* m_unitTarget;
GameObject* m_GOTarget;
Item* m_itemTarget;
// object GUID/etc, can be used always
ObjectGuid m_unitTargetGUID;
@ -230,7 +230,7 @@ class Spell
{
friend struct MaNGOS::SpellNotifierPlayer;
friend struct MaNGOS::SpellNotifierCreatureAndPlayer;
friend void Unit::SetCurrentCastedSpell( Spell * pSpell );
friend void Unit::SetCurrentCastedSpell(Spell* pSpell);
public:
void EffectEmpty(SpellEffectIndex eff_idx);
@ -322,7 +322,7 @@ class Spell
void EffectDispelMechanic(SpellEffectIndex eff_idx);
void EffectSummonDeadPet(SpellEffectIndex eff_idx);
void EffectSummonAllTotems(SpellEffectIndex eff_idx);
void EffectBreakPlayerTargeting (SpellEffectIndex eff_idx);
void EffectBreakPlayerTargeting(SpellEffectIndex eff_idx);
void EffectDestroyAllTotems(SpellEffectIndex eff_idx);
void EffectDurabilityDamage(SpellEffectIndex eff_idx);
void EffectSkill(SpellEffectIndex eff_idx);
@ -353,7 +353,7 @@ class Spell
void EffectActivateSpec(SpellEffectIndex eff_idx);
void EffectCancelAura(SpellEffectIndex eff_idx);
Spell(Unit* caster, SpellEntry const *info, bool triggered, ObjectGuid originalCasterGUID = ObjectGuid(), SpellEntry const* triggeredBy = NULL);
Spell(Unit* caster, SpellEntry const* info, bool triggered, ObjectGuid originalCasterGUID = ObjectGuid(), SpellEntry const* triggeredBy = NULL);
~Spell();
void prepare(SpellCastTargets const* targets, Aura* triggeredByAura = NULL);
@ -399,16 +399,16 @@ class Spell
typedef std::list<Unit*> UnitList;
void FillTargetMap();
void SetTargetMap(SpellEffectIndex effIndex, uint32 targetMode, UnitList &targetUnitMap);
void SetTargetMap(SpellEffectIndex effIndex, uint32 targetMode, UnitList& targetUnitMap);
void FillAreaTargets(UnitList &targetUnitMap, float radius, SpellNotifyPushType pushType, SpellTargets spellTargets, WorldObject* originalCaster = NULL);
void FillRaidOrPartyTargets(UnitList &targetUnitMap, Unit* member, Unit* center, float radius, bool raid, bool withPets, bool withcaster);
void FillRaidOrPartyManaPriorityTargets(UnitList &targetUnitMap, Unit* member, Unit* center, float radius, uint32 count, bool raid, bool withPets, bool withcaster);
void FillRaidOrPartyHealthPriorityTargets(UnitList &targetUnitMap, Unit* member, Unit* center, float radius, uint32 count, bool raid, bool withPets, bool withcaster);
void FillAreaTargets(UnitList& targetUnitMap, float radius, SpellNotifyPushType pushType, SpellTargets spellTargets, WorldObject* originalCaster = NULL);
void FillRaidOrPartyTargets(UnitList& targetUnitMap, Unit* member, Unit* center, float radius, bool raid, bool withPets, bool withcaster);
void FillRaidOrPartyManaPriorityTargets(UnitList& targetUnitMap, Unit* member, Unit* center, float radius, uint32 count, bool raid, bool withPets, bool withcaster);
void FillRaidOrPartyHealthPriorityTargets(UnitList& targetUnitMap, Unit* member, Unit* center, float radius, uint32 count, bool raid, bool withPets, bool withcaster);
template<typename T> WorldObject* FindCorpseUsing();
bool CheckTarget( Unit* target, SpellEffectIndex eff );
bool CheckTarget(Unit* target, SpellEffectIndex eff);
bool CanAutoCast(Unit* target);
static void MANGOS_DLL_SPEC SendCastResult(Player* caster, SpellEntry const* spellInfo, uint8 cast_count, SpellCastResult result);
@ -423,7 +423,7 @@ class Spell
void SendResurrectRequest(Player* target);
void SendPlaySpellVisual(uint32 SpellID);
void HandleEffects(Unit *pUnitTarget,Item *pItemTarget,GameObject *pGOTarget,SpellEffectIndex i, float DamageMultiplier = 1.0);
void HandleEffects(Unit* pUnitTarget,Item* pItemTarget,GameObject* pGOTarget,SpellEffectIndex i, float DamageMultiplier = 1.0);
void HandleThreatSpells();
//void HandleAddAura(Unit* Target);
@ -523,7 +523,7 @@ class Spell
uint8 m_delayAtDamageCount;
bool isDelayableNoMore()
{
if(m_delayAtDamageCount >= 2)
if (m_delayAtDamageCount >= 2)
return true;
m_delayAtDamageCount++;
@ -597,7 +597,7 @@ class Spell
struct ItemTargetInfo
{
Item *item;
Item* item;
uint8 effectMask;
};
@ -614,13 +614,13 @@ class Spell
void AddGOTarget(GameObject* target, SpellEffectIndex effIndex);
void AddGOTarget(ObjectGuid goGuid, SpellEffectIndex effIndex);
void AddItemTarget(Item* target, SpellEffectIndex effIndex);
void DoAllEffectOnTarget(TargetInfo *target);
void HandleDelayedSpellLaunch(TargetInfo *target);
void DoAllEffectOnTarget(TargetInfo* target);
void HandleDelayedSpellLaunch(TargetInfo* target);
void InitializeDamageMultipliers();
void ResetEffectDamageAndHeal();
void DoSpellHitOnUnit(Unit *unit, uint32 effectMask);
void DoAllEffectOnTarget(GOTargetInfo *target);
void DoAllEffectOnTarget(ItemTargetInfo *target);
void DoSpellHitOnUnit(Unit* unit, uint32 effectMask);
void DoAllEffectOnTarget(GOTargetInfo* target);
void DoAllEffectOnTarget(ItemTargetInfo* target);
bool IsAliveUnitPresentInTargetList();
SpellCastResult CanOpenLock(SpellEffectIndex effIndex, uint32 lockid, SkillType& skillid, int32& reqSkillValue, int32& skillValue);
// -------------------------------------------
@ -679,43 +679,43 @@ namespace MaNGOS
{
struct MANGOS_DLL_DECL SpellNotifierPlayer // Currently unused. When put to use this one requires handling for source-location (smilar to below)
{
Spell::UnitList &i_data;
Spell &i_spell;
Spell::UnitList& i_data;
Spell& i_spell;
const uint32& i_index;
float i_radius;
WorldObject* i_originalCaster;
SpellNotifierPlayer(Spell &spell, Spell::UnitList &data, const uint32 &i, float radius)
SpellNotifierPlayer(Spell& spell, Spell::UnitList& data, const uint32& i, float radius)
: i_data(data), i_spell(spell), i_index(i), i_radius(radius)
{
i_originalCaster = i_spell.GetAffectiveCasterObject();
}
void Visit(PlayerMapType &m)
void Visit(PlayerMapType& m)
{
if(!i_originalCaster)
if (!i_originalCaster)
return;
for(PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
for (PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
{
Player * pPlayer = itr->getSource();
if( !pPlayer->isAlive() || pPlayer->IsTaxiFlying())
Player* pPlayer = itr->getSource();
if (!pPlayer->isAlive() || pPlayer->IsTaxiFlying())
continue;
if( i_originalCaster->IsFriendlyTo(pPlayer) )
if (i_originalCaster->IsFriendlyTo(pPlayer))
continue;
if( pPlayer->IsWithinDist3d(i_spell.m_targets.m_destX, i_spell.m_targets.m_destY, i_spell.m_targets.m_destZ,i_radius))
if (pPlayer->IsWithinDist3d(i_spell.m_targets.m_destX, i_spell.m_targets.m_destY, i_spell.m_targets.m_destZ,i_radius))
i_data.push_back(pPlayer);
}
}
template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
template<class SKIP> void Visit(GridRefManager<SKIP>&) {}
};
struct MANGOS_DLL_DECL SpellNotifierCreatureAndPlayer
{
Spell::UnitList *i_data;
Spell &i_spell;
Spell::UnitList* i_data;
Spell& i_spell;
SpellNotifyPushType i_push_type;
float i_radius;
SpellTargets i_TargetType;
@ -729,7 +729,7 @@ namespace MaNGOS
float GetCenterX() const { return i_centerX; }
float GetCenterY() const { return i_centerY; }
SpellNotifierCreatureAndPlayer(Spell &spell, Spell::UnitList &data, float radius, SpellNotifyPushType type,
SpellNotifierCreatureAndPlayer(Spell& spell, Spell::UnitList& data, float radius, SpellNotifyPushType type,
SpellTargets TargetType = SPELL_TARGETS_NOT_FRIENDLY, WorldObject* originalCaster = NULL)
: i_data(&data), i_spell(spell), i_push_type(type), i_radius(radius), i_TargetType(TargetType),
i_originalCaster(originalCaster), i_castingObject(i_spell.GetCastingObject())
@ -738,7 +738,7 @@ namespace MaNGOS
i_originalCaster = i_spell.GetAffectiveCasterObject();
i_playerControlled = i_originalCaster ? i_originalCaster->IsControlledByPlayer() : false;
switch(i_push_type)
switch (i_push_type)
{
case PUSH_IN_FRONT:
case PUSH_IN_FRONT_90:
@ -778,14 +778,14 @@ namespace MaNGOS
}
}
template<class T> inline void Visit(GridRefManager<T> &m)
template<class T> inline void Visit(GridRefManager<T>& m)
{
MANGOS_ASSERT(i_data);
if (!i_originalCaster || !i_castingObject)
return;
for(typename GridRefManager<T>::iterator itr = m.begin(); itr != m.end(); ++itr)
for (typename GridRefManager<T>::iterator itr = m.begin(); itr != m.end(); ++itr)
{
// there are still more spells which can be casted on dead, but
// they are no AOE and don't have such a nice SPELL_ATTR flag
@ -797,19 +797,19 @@ namespace MaNGOS
switch (i_TargetType)
{
case SPELL_TARGETS_HOSTILE:
if (!i_originalCaster->IsHostileTo( itr->getSource() ))
if (!i_originalCaster->IsHostileTo(itr->getSource()))
continue;
break;
case SPELL_TARGETS_NOT_FRIENDLY:
if (i_originalCaster->IsFriendlyTo( itr->getSource() ))
if (i_originalCaster->IsFriendlyTo(itr->getSource()))
continue;
break;
case SPELL_TARGETS_NOT_HOSTILE:
if (i_originalCaster->IsHostileTo( itr->getSource() ))
if (i_originalCaster->IsHostileTo(itr->getSource()))
continue;
break;
case SPELL_TARGETS_FRIENDLY:
if (!i_originalCaster->IsFriendlyTo( itr->getSource() ))
if (!i_originalCaster->IsFriendlyTo(itr->getSource()))
continue;
break;
case SPELL_TARGETS_AOE_DAMAGE:
@ -819,12 +819,12 @@ namespace MaNGOS
if (i_playerControlled)
{
if (i_originalCaster->IsFriendlyTo( itr->getSource() ))
if (i_originalCaster->IsFriendlyTo(itr->getSource()))
continue;
}
else
{
if (!i_originalCaster->IsHostileTo( itr->getSource() ))
if (!i_originalCaster->IsHostileTo(itr->getSource()))
continue;
}
}
@ -835,26 +835,26 @@ namespace MaNGOS
}
// we don't need to check InMap here, it's already done some lines above
switch(i_push_type)
switch (i_push_type)
{
case PUSH_IN_FRONT:
if (i_castingObject->isInFront((Unit*)(itr->getSource()), i_radius, 2*M_PI_F/3 ))
if (i_castingObject->isInFront((Unit*)(itr->getSource()), i_radius, 2*M_PI_F/3))
i_data->push_back(itr->getSource());
break;
case PUSH_IN_FRONT_90:
if (i_castingObject->isInFront((Unit*)(itr->getSource()), i_radius, M_PI_F/2 ))
if (i_castingObject->isInFront((Unit*)(itr->getSource()), i_radius, M_PI_F/2))
i_data->push_back(itr->getSource());
break;
case PUSH_IN_FRONT_30:
if (i_castingObject->isInFront((Unit*)(itr->getSource()), i_radius, M_PI_F/6 ))
if (i_castingObject->isInFront((Unit*)(itr->getSource()), i_radius, M_PI_F/6))
i_data->push_back(itr->getSource());
break;
case PUSH_IN_FRONT_15:
if (i_castingObject->isInFront((Unit*)(itr->getSource()), i_radius, M_PI_F/12 ))
if (i_castingObject->isInFront((Unit*)(itr->getSource()), i_radius, M_PI_F/12))
i_data->push_back(itr->getSource());
break;
case PUSH_IN_BACK:
if (i_castingObject->isInBack((Unit*)(itr->getSource()), i_radius, 2*M_PI_F/3 ))
if (i_castingObject->isInBack((Unit*)(itr->getSource()), i_radius, 2*M_PI_F/3))
i_data->push_back(itr->getSource());
break;
case PUSH_SELF_CENTER:
@ -873,20 +873,20 @@ namespace MaNGOS
}
}
#ifdef WIN32
template<> inline void Visit(CorpseMapType & ) {}
template<> inline void Visit(GameObjectMapType & ) {}
template<> inline void Visit(DynamicObjectMapType & ) {}
template<> inline void Visit(CameraMapType & ) {}
#endif
#ifdef WIN32
template<> inline void Visit(CorpseMapType&) {}
template<> inline void Visit(GameObjectMapType&) {}
template<> inline void Visit(DynamicObjectMapType&) {}
template<> inline void Visit(CameraMapType&) {}
#endif
};
#ifndef WIN32
template<> inline void SpellNotifierCreatureAndPlayer::Visit(CorpseMapType& ) {}
template<> inline void SpellNotifierCreatureAndPlayer::Visit(GameObjectMapType& ) {}
template<> inline void SpellNotifierCreatureAndPlayer::Visit(DynamicObjectMapType& ) {}
template<> inline void SpellNotifierCreatureAndPlayer::Visit(CameraMapType& ) {}
#endif
#ifndef WIN32
template<> inline void SpellNotifierCreatureAndPlayer::Visit(CorpseMapType&) {}
template<> inline void SpellNotifierCreatureAndPlayer::Visit(GameObjectMapType&) {}
template<> inline void SpellNotifierCreatureAndPlayer::Visit(DynamicObjectMapType&) {}
template<> inline void SpellNotifierCreatureAndPlayer::Visit(CameraMapType&) {}
#endif
}
typedef void(Spell::*pEffect)(SpellEffectIndex eff_idx);

1320
src/game/SpellAuras.cpp
View file

File diff suppressed because it is too large Load diff

38
src/game/SpellAuras.h
View file

@ -43,10 +43,10 @@ struct ReapplyAffectedPassiveAurasHelper;
class MANGOS_DLL_SPEC SpellAuraHolder
{
public:
SpellAuraHolder (SpellEntry const* spellproto, Unit *target, WorldObject *caster, Item *castItem);
SpellAuraHolder(SpellEntry const* spellproto, Unit* target, WorldObject* caster, Item* castItem);
Aura* m_auras[MAX_EFFECT_INDEX];
void AddAura(Aura *aura, SpellEffectIndex index);
void AddAura(Aura* aura, SpellEffectIndex index);
void RemoveAura(SpellEffectIndex index);
void ApplyAuraModifiers(bool apply, bool real = false);
void _AddSpellAuraHolder();
@ -93,11 +93,11 @@ class MANGOS_DLL_SPEC SpellAuraHolder
void SetInUse(bool state)
{
if(state)
if (state)
++m_in_use;
else
{
if(m_in_use)
if (m_in_use)
--m_in_use;
}
}
@ -206,7 +206,7 @@ typedef void(Aura::*pAuraHandler)(bool Apply, bool Real);
class MANGOS_DLL_SPEC Aura
{
friend struct ReapplyAffectedPassiveAurasHelper;
friend Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32 *currentBasePoints, SpellAuraHolder *holder, Unit *target, Unit *caster, Item* castItem);
friend Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster, Item* castItem);
public:
//aura handlers
@ -384,13 +384,13 @@ class MANGOS_DLL_SPEC Aura
int32 GetMiscBValue() const { return m_spellAuraHolder->GetSpellProto()->EffectMiscValueB[m_effIndex]; }
SpellEntry const* GetSpellProto() const { return GetHolder()->GetSpellProto(); }
uint32 GetId() const{ return GetHolder()->GetSpellProto()->Id; }
uint32 GetId() const { return GetHolder()->GetSpellProto()->Id; }
ObjectGuid const& GetCastItemGuid() const { return GetHolder()->GetCastItemGuid(); }
ObjectGuid const& GetCasterGuid() const { return GetHolder()->GetCasterGuid(); }
Unit* GetCaster() const { return GetHolder()->GetCaster(); }
Unit* GetTarget() const { return GetHolder()->GetTarget(); }
SpellEffectIndex GetEffIndex() const{ return m_effIndex; }
SpellEffectIndex GetEffIndex() const { return m_effIndex; }
int32 GetBasePoints() const { return m_currentBasePoints; }
int32 GetAuraMaxDuration() const { return GetHolder()->GetAuraMaxDuration(); }
@ -409,7 +409,7 @@ class MANGOS_DLL_SPEC Aura
m_modifier.m_amount = damage;
m_modifier.periodictime = periodicTime;
if(uint32 maxticks = GetAuraMaxTicks())
if (uint32 maxticks = GetAuraMaxTicks())
m_periodicTick = maxticks - GetAuraDuration() / m_modifier.periodictime;
}
@ -421,11 +421,11 @@ class MANGOS_DLL_SPEC Aura
void SetInUse(bool state)
{
if(state)
if (state)
++m_in_use;
else
{
if(m_in_use)
if (m_in_use)
--m_in_use;
}
}
@ -444,8 +444,8 @@ class MANGOS_DLL_SPEC Aura
void TriggerSpellWithValue();
ClassFamilyMask const& GetAuraSpellClassMask() const { return m_spellAuraHolder->GetSpellProto()->GetEffectSpellClassMask(m_effIndex); }
bool isAffectedOnSpell(SpellEntry const *spell) const;
bool CanProcFrom(SpellEntry const *spell, uint32 procFlag, uint32 EventProcEx, uint32 procEx, bool active, bool useClassMask) const;
bool isAffectedOnSpell(SpellEntry const* spell) const;
bool CanProcFrom(SpellEntry const* spell, uint32 procFlag, uint32 EventProcEx, uint32 procEx, bool active, bool useClassMask) const;
//SpellAuraHolder const* GetHolder() const { return m_spellHolder; }
SpellAuraHolder* GetHolder() { return m_spellAuraHolder; }
@ -455,7 +455,7 @@ class MANGOS_DLL_SPEC Aura
bool HasMechanic(uint32 mechanic) const;
protected:
Aura(SpellEntry const* spellproto, SpellEffectIndex eff, int32 *currentBasePoints, SpellAuraHolder *holder, Unit *target, Unit *caster = NULL, Item* castItem = NULL);
Aura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster = NULL, Item* castItem = NULL);
// must be called only from Aura::UpdateAura
virtual void Update(uint32 diff);
@ -494,7 +494,7 @@ class MANGOS_DLL_SPEC Aura
class MANGOS_DLL_SPEC AreaAura : public Aura
{
public:
AreaAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32 *currentBasePoints, SpellAuraHolder *holder, Unit *target, Unit *caster = NULL, Item* castItem = NULL);
AreaAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster = NULL, Item* castItem = NULL);
~AreaAura();
protected:
void Update(uint32 diff);
@ -506,7 +506,7 @@ class MANGOS_DLL_SPEC AreaAura : public Aura
class MANGOS_DLL_SPEC PersistentAreaAura : public Aura
{
public:
PersistentAreaAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32 *currentBasePoints, SpellAuraHolder *holder, Unit *target, Unit *caster = NULL, Item* castItem = NULL);
PersistentAreaAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster = NULL, Item* castItem = NULL);
~PersistentAreaAura();
protected:
void Update(uint32 diff);
@ -514,17 +514,17 @@ class MANGOS_DLL_SPEC PersistentAreaAura : public Aura
class MANGOS_DLL_SPEC SingleEnemyTargetAura : public Aura
{
friend Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32 *currentBasePoints, SpellAuraHolder *holder, Unit *target, Unit *caster, Item* castItem);
friend Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster, Item* castItem);
public:
~SingleEnemyTargetAura();
Unit* GetTriggerTarget() const;
protected:
SingleEnemyTargetAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32 *currentBasePoints, SpellAuraHolder *holder, Unit *target, Unit *caster = NULL, Item* castItem = NULL);
SingleEnemyTargetAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster = NULL, Item* castItem = NULL);
ObjectGuid m_castersTargetGuid;
};
Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32 *currentBasePoints, SpellAuraHolder *holder, Unit *target, Unit *caster = NULL, Item* castItem = NULL);
SpellAuraHolder* CreateSpellAuraHolder(SpellEntry const* spellproto, Unit *target, WorldObject *caster, Item *castItem = NULL);
Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster = NULL, Item* castItem = NULL);
SpellAuraHolder* CreateSpellAuraHolder(SpellEntry const* spellproto, Unit* target, WorldObject* caster, Item* castItem = NULL);
#endif

1030
src/game/SpellEffects.cpp
View file

File diff suppressed because it is too large Load diff

120
src/game/SpellHandler.cpp
View file

@ -54,32 +54,32 @@ void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket)
if (glyphIndex >= MAX_GLYPH_SLOT_INDEX)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
return;
}
Item *pItem = pUser->GetItemByPos(bagIndex, slot);
Item* pItem = pUser->GetItemByPos(bagIndex, slot);
if (!pItem)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
return;
}
if (pItem->GetObjectGuid() != itemGuid)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
return;
}
DETAIL_LOG("WORLD: CMSG_USE_ITEM packet, bagIndex: %u, slot: %u, cast_count: %u, spellid: %u, Item: %u, glyphIndex: %u, unk_flags: %u, data length = %i", bagIndex, slot, cast_count, spellid, pItem->GetEntry(), glyphIndex, unk_flags, (uint32)recvPacket.size());
ItemPrototype const *proto = pItem->GetProto();
ItemPrototype const* proto = pItem->GetProto();
if (!proto)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL);
return;
}
@ -87,7 +87,7 @@ void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket)
if (proto->InventoryType != INVTYPE_NON_EQUIP && !pItem->IsEquipped())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL);
return;
}
@ -95,7 +95,7 @@ void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket)
if (msg != EQUIP_ERR_OK)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError( msg, pItem, NULL );
pUser->SendEquipError(msg, pItem, NULL);
return;
}
@ -103,7 +103,7 @@ void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket)
if (pItem->IsInTrade())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL);
return;
}
@ -119,9 +119,9 @@ void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket)
if (pUser->isInCombat())
{
for(int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
for (int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
{
if (SpellEntry const *spellInfo = sSpellStore.LookupEntry(proto->Spells[i].SpellId))
if (SpellEntry const* spellInfo = sSpellStore.LookupEntry(proto->Spells[i].SpellId))
{
if (IsNonCombatSpell(spellInfo))
{
@ -142,12 +142,12 @@ void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket)
}
// check also BIND_WHEN_PICKED_UP and BIND_QUEST_ITEM for .additem or .additemset case by GM (not binded at adding to inventory)
if( pItem->GetProto()->Bonding == BIND_WHEN_USE || pItem->GetProto()->Bonding == BIND_WHEN_PICKED_UP || pItem->GetProto()->Bonding == BIND_QUEST_ITEM )
if (pItem->GetProto()->Bonding == BIND_WHEN_USE || pItem->GetProto()->Bonding == BIND_WHEN_PICKED_UP || pItem->GetProto()->Bonding == BIND_QUEST_ITEM)
{
if (!pItem->IsSoulBound())
{
pItem->SetState(ITEM_CHANGED, pUser);
pItem->SetBinding( true );
pItem->SetBinding(true);
}
}
@ -206,47 +206,47 @@ void WorldSession::HandleOpenItemOpcode(WorldPacket& recvPacket)
if (!pUser->IsSelfMover())
return;
Item *pItem = pUser->GetItemByPos(bagIndex, slot);
if(!pItem)
Item* pItem = pUser->GetItemByPos(bagIndex, slot);
if (!pItem)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL);
return;
}
ItemPrototype const *proto = pItem->GetProto();
if(!proto)
ItemPrototype const* proto = pItem->GetProto();
if (!proto)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL);
return;
}
// locked item
uint32 lockId = proto->LockID;
if(lockId && !pItem->HasFlag(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_UNLOCKED))
if (lockId && !pItem->HasFlag(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_UNLOCKED))
{
LockEntry const *lockInfo = sLockStore.LookupEntry(lockId);
LockEntry const* lockInfo = sLockStore.LookupEntry(lockId);
if (!lockInfo)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_LOCKED, pItem, NULL );
sLog.outError( "WORLD::OpenItem: item [guid = %u] has an unknown lockId: %u!", pItem->GetGUIDLow() , lockId);
pUser->SendEquipError(EQUIP_ERR_ITEM_LOCKED, pItem, NULL);
sLog.outError("WORLD::OpenItem: item [guid = %u] has an unknown lockId: %u!", pItem->GetGUIDLow() , lockId);
return;
}
// required picklocking
if(lockInfo->Skill[1] || lockInfo->Skill[0])
if (lockInfo->Skill[1] || lockInfo->Skill[0])
{
pUser->SendEquipError(EQUIP_ERR_ITEM_LOCKED, pItem, NULL );
pUser->SendEquipError(EQUIP_ERR_ITEM_LOCKED, pItem, NULL);
return;
}
}
if (pItem->HasFlag(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_WRAPPED))// wrapped?
{
QueryResult *result = CharacterDatabase.PQuery("SELECT entry, flags FROM character_gifts WHERE item_guid = '%u'", pItem->GetGUIDLow());
QueryResult* result = CharacterDatabase.PQuery("SELECT entry, flags FROM character_gifts WHERE item_guid = '%u'", pItem->GetGUIDLow());
if (result)
{
Field *fields = result->Fetch();
Field* fields = result->Fetch();
uint32 entry = fields[0].GetUInt32();
uint32 flags = fields[1].GetUInt32();
@ -272,7 +272,7 @@ void WorldSession::HandleOpenItemOpcode(WorldPacket& recvPacket)
pUser->SendLoot(pItem->GetObjectGuid(),LOOT_CORPSE);
}
void WorldSession::HandleGameObjectUseOpcode( WorldPacket & recv_data )
void WorldSession::HandleGameObjectUseOpcode(WorldPacket& recv_data)
{
ObjectGuid guid;
@ -284,8 +284,8 @@ void WorldSession::HandleGameObjectUseOpcode( WorldPacket & recv_data )
if (!_player->IsSelfMover())
return;
GameObject *obj = GetPlayer()->GetMap()->GetGameObject(guid);
if(!obj)
GameObject* obj = GetPlayer()->GetMap()->GetGameObject(guid);
if (!obj)
return;
// Additional check preventing exploits (ie loot despawned chests)
@ -327,7 +327,7 @@ void WorldSession::HandleGameobjectReportUse(WorldPacket& recvPacket)
if (!go)
return;
if(!go->IsWithinDistInMap(_player,INTERACTION_DISTANCE))
if (!go->IsWithinDistInMap(_player,INTERACTION_DISTANCE))
return;
_player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_USE_GAMEOBJECT, go->GetEntry());
@ -352,9 +352,9 @@ void WorldSession::HandleCastSpellOpcode(WorldPacket& recvPacket)
DEBUG_LOG("WORLD: got cast spell packet, spellId - %u, cast_count: %u, unk_flags %u, data length = %i",
spellId, cast_count, unk_flags, (uint32)recvPacket.size());
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId );
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellId);
if(!spellInfo)
if (!spellInfo)
{
sLog.outError("WORLD: unknown spell id %u", spellId);
recvPacket.rpos(recvPacket.wpos()); // prevent spam at ignore packet
@ -364,7 +364,7 @@ void WorldSession::HandleCastSpellOpcode(WorldPacket& recvPacket)
if (mover->GetTypeId()==TYPEID_PLAYER)
{
// not have spell in spellbook or spell passive and not casted by client
if (!((Player*)mover)->HasActiveSpell (spellId) || IsPassiveSpell(spellInfo))
if (!((Player*)mover)->HasActiveSpell(spellId) || IsPassiveSpell(spellInfo))
{
sLog.outError("World: Player %u casts spell %u which he shouldn't have", mover->GetGUIDLow(), spellId);
//cheater? kick? ban?
@ -396,7 +396,7 @@ void WorldSession::HandleCastSpellOpcode(WorldPacket& recvPacket)
recvPacket >> Unused<float>(); // unk1, coords?
recvPacket >> Unused<float>(); // unk1, coords?
recvPacket >> unk1; // >> 1 or 0
if(unk1)
if (unk1)
{
ObjectGuid guid; // guid - unused
MovementInfo movementInfo;
@ -411,11 +411,11 @@ void WorldSession::HandleCastSpellOpcode(WorldPacket& recvPacket)
if (Unit* target = targets.getUnitTarget())
{
// if rank not found then function return NULL but in explicit cast case original spell can be casted and later failed with appropriate error message
if (SpellEntry const *actualSpellInfo = sSpellMgr.SelectAuraRankForLevel(spellInfo, target->getLevel()))
if (SpellEntry const* actualSpellInfo = sSpellMgr.SelectAuraRankForLevel(spellInfo, target->getLevel()))
spellInfo = actualSpellInfo;
}
Spell *spell = new Spell(mover, spellInfo, false);
Spell* spell = new Spell(mover, spellInfo, false);
spell->m_cast_count = cast_count; // set count of casts
spell->prepare(&targets);
}
@ -433,19 +433,19 @@ void WorldSession::HandleCancelCastOpcode(WorldPacket& recvPacket)
return;
//FIXME: hack, ignore unexpected client cancel Deadly Throw cast
if(spellId==26679)
if (spellId==26679)
return;
if(mover->IsNonMeleeSpellCasted(false))
if (mover->IsNonMeleeSpellCasted(false))
mover->InterruptNonMeleeSpells(false,spellId);
}
void WorldSession::HandleCancelAuraOpcode( WorldPacket& recvPacket)
void WorldSession::HandleCancelAuraOpcode(WorldPacket& recvPacket)
{
uint32 spellId;
recvPacket >> spellId;
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId);
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellId);
if (!spellInfo)
return;
@ -462,7 +462,7 @@ void WorldSession::HandleCancelAuraOpcode( WorldPacket& recvPacket)
{
// except own aura spells
bool allow = false;
for(int k = 0; k < MAX_EFFECT_INDEX; ++k)
for (int k = 0; k < MAX_EFFECT_INDEX; ++k)
{
if (spellInfo->EffectApplyAuraName[k] == SPELL_AURA_MOD_POSSESS ||
spellInfo->EffectApplyAuraName[k] == SPELL_AURA_MOD_POSSESS_PET)
@ -473,7 +473,7 @@ void WorldSession::HandleCancelAuraOpcode( WorldPacket& recvPacket)
}
// this also include case when aura not found
if(!allow)
if (!allow)
return;
}
else
@ -489,7 +489,7 @@ void WorldSession::HandleCancelAuraOpcode( WorldPacket& recvPacket)
return;
}
SpellAuraHolder *holder = _player->GetSpellAuraHolder(spellId);
SpellAuraHolder* holder = _player->GetSpellAuraHolder(spellId);
// not own area auras can't be cancelled (note: maybe need to check for aura on holder and not general on spell)
if (holder && holder->GetCasterGuid() != _player->GetObjectGuid() && HasAreaAuraEffect(holder->GetSpellProto()))
@ -499,7 +499,7 @@ void WorldSession::HandleCancelAuraOpcode( WorldPacket& recvPacket)
_player->RemoveAurasDueToSpellByCancel(spellId);
}
void WorldSession::HandlePetCancelAuraOpcode( WorldPacket& recvPacket)
void WorldSession::HandlePetCancelAuraOpcode(WorldPacket& recvPacket)
{
ObjectGuid guid;
uint32 spellId;
@ -511,8 +511,8 @@ void WorldSession::HandlePetCancelAuraOpcode( WorldPacket& recvPacket)
if (!_player->IsSelfMover())
return;
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellId );
if(!spellInfo)
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellId);
if (!spellInfo)
{
sLog.outError("WORLD: unknown PET spell id %u", spellId);
return;
@ -543,19 +543,19 @@ void WorldSession::HandlePetCancelAuraOpcode( WorldPacket& recvPacket)
pet->AddCreatureSpellCooldown(spellId);
}
void WorldSession::HandleCancelGrowthAuraOpcode( WorldPacket& /*recvPacket*/)
void WorldSession::HandleCancelGrowthAuraOpcode(WorldPacket& /*recvPacket*/)
{
// nothing do
}
void WorldSession::HandleCancelAutoRepeatSpellOpcode( WorldPacket& /*recvPacket*/)
void WorldSession::HandleCancelAutoRepeatSpellOpcode(WorldPacket& /*recvPacket*/)
{
// cancel and prepare for deleting
// do not send SMSG_CANCEL_AUTO_REPEAT! client will send this Opcode again (loop)
_player->GetMover()->InterruptSpell(CURRENT_AUTOREPEAT_SPELL, true, false);
}
void WorldSession::HandleCancelChanneling( WorldPacket & recv_data)
void WorldSession::HandleCancelChanneling(WorldPacket& recv_data)
{
recv_data.read_skip<uint32>(); // spellid, not used
@ -567,7 +567,7 @@ void WorldSession::HandleCancelChanneling( WorldPacket & recv_data)
mover->InterruptSpell(CURRENT_CHANNELED_SPELL);
}
void WorldSession::HandleTotemDestroyed( WorldPacket& recvPacket)
void WorldSession::HandleTotemDestroyed(WorldPacket& recvPacket)
{
uint8 slotId;
@ -584,21 +584,21 @@ void WorldSession::HandleTotemDestroyed( WorldPacket& recvPacket)
totem->UnSummon();
}
void WorldSession::HandleSelfResOpcode( WorldPacket & /*recv_data*/ )
void WorldSession::HandleSelfResOpcode(WorldPacket& /*recv_data*/)
{
DEBUG_FILTER_LOG(LOG_FILTER_SPELL_CAST, "WORLD: CMSG_SELF_RES"); // empty opcode
if(_player->GetUInt32Value(PLAYER_SELF_RES_SPELL))
if (_player->GetUInt32Value(PLAYER_SELF_RES_SPELL))
{
SpellEntry const *spellInfo = sSpellStore.LookupEntry(_player->GetUInt32Value(PLAYER_SELF_RES_SPELL));
if(spellInfo)
SpellEntry const* spellInfo = sSpellStore.LookupEntry(_player->GetUInt32Value(PLAYER_SELF_RES_SPELL));
if (spellInfo)
_player->CastSpell(_player, spellInfo, false);
_player->SetUInt32Value(PLAYER_SELF_RES_SPELL, 0);
}
}
void WorldSession::HandleSpellClick( WorldPacket & recv_data )
void WorldSession::HandleSpellClick(WorldPacket& recv_data)
{
ObjectGuid guid;
recv_data >> guid;
@ -606,17 +606,17 @@ void WorldSession::HandleSpellClick( WorldPacket & recv_data )
if (_player->isInCombat()) // client prevent click and set different icon at combat state
return;
Creature *unit = _player->GetMap()->GetAnyTypeCreature(guid);
Creature* unit = _player->GetMap()->GetAnyTypeCreature(guid);
if (!unit || unit->isInCombat()) // client prevent click and set different icon at combat state
return;
SpellClickInfoMapBounds clickPair = sObjectMgr.GetSpellClickInfoMapBounds(unit->GetEntry());
for(SpellClickInfoMap::const_iterator itr = clickPair.first; itr != clickPair.second; ++itr)
for (SpellClickInfoMap::const_iterator itr = clickPair.first; itr != clickPair.second; ++itr)
{
if (itr->second.IsFitToRequirements(_player))
{
Unit *caster = (itr->second.castFlags & 0x1) ? (Unit*)_player : (Unit*)unit;
Unit *target = (itr->second.castFlags & 0x2) ? (Unit*)_player : (Unit*)unit;
Unit* caster = (itr->second.castFlags & 0x1) ? (Unit*)_player : (Unit*)unit;
Unit* target = (itr->second.castFlags & 0x2) ? (Unit*)_player : (Unit*)unit;
caster->CastSpell(target, itr->second.spellId, true);
}

575
src/game/SpellMgr.cpp
View file

File diff suppressed because it is too large Load diff

186
src/game/SpellMgr.h
View file

@ -76,39 +76,39 @@ enum SpellSpecific
SpellSpecific GetSpellSpecific(uint32 spellId);
// Different spell properties
inline float GetSpellRadius(SpellRadiusEntry const *radius) { return (radius ? radius->Radius : 0); }
inline float GetSpellRadius(SpellRadiusEntry const* radius) { return (radius ? radius->Radius : 0); }
uint32 GetSpellCastTime(SpellEntry const* spellInfo, Spell const* spell = NULL);
uint32 GetSpellCastTimeForBonus( SpellEntry const *spellProto, DamageEffectType damagetype );
float CalculateDefaultCoefficient(SpellEntry const *spellProto, DamageEffectType const damagetype);
inline float GetSpellMinRange(SpellRangeEntry const *range, bool friendly = false)
uint32 GetSpellCastTimeForBonus(SpellEntry const* spellProto, DamageEffectType damagetype);
float CalculateDefaultCoefficient(SpellEntry const* spellProto, DamageEffectType const damagetype);
inline float GetSpellMinRange(SpellRangeEntry const* range, bool friendly = false)
{
if(!range)
if (!range)
return 0;
return (friendly ? range->minRangeFriendly : range->minRange);
}
inline float GetSpellMaxRange(SpellRangeEntry const *range, bool friendly = false)
inline float GetSpellMaxRange(SpellRangeEntry const* range, bool friendly = false)
{
if(!range)
if (!range)
return 0;
return (friendly ? range->maxRangeFriendly : range->maxRange);
}
inline uint32 GetSpellRecoveryTime(SpellEntry const *spellInfo) { return spellInfo->RecoveryTime > spellInfo->CategoryRecoveryTime ? spellInfo->RecoveryTime : spellInfo->CategoryRecoveryTime; }
int32 GetSpellDuration(SpellEntry const *spellInfo);
int32 GetSpellMaxDuration(SpellEntry const *spellInfo);
int32 CalculateSpellDuration(SpellEntry const *spellInfo, Unit const* caster = NULL);
inline uint32 GetSpellRecoveryTime(SpellEntry const* spellInfo) { return spellInfo->RecoveryTime > spellInfo->CategoryRecoveryTime ? spellInfo->RecoveryTime : spellInfo->CategoryRecoveryTime; }
int32 GetSpellDuration(SpellEntry const* spellInfo);
int32 GetSpellMaxDuration(SpellEntry const* spellInfo);
int32 CalculateSpellDuration(SpellEntry const* spellInfo, Unit const* caster = NULL);
uint16 GetSpellAuraMaxTicks(SpellEntry const* spellInfo);
uint16 GetSpellAuraMaxTicks(uint32 spellId);
WeaponAttackType GetWeaponAttackType(SpellEntry const *spellInfo);
WeaponAttackType GetWeaponAttackType(SpellEntry const* spellInfo);
inline bool IsSpellHaveEffect(SpellEntry const *spellInfo, SpellEffects effect)
inline bool IsSpellHaveEffect(SpellEntry const* spellInfo, SpellEffects effect)
{
for(int i = 0; i < MAX_EFFECT_INDEX; ++i)
if(SpellEffects(spellInfo->Effect[i])==effect)
for (int i = 0; i < MAX_EFFECT_INDEX; ++i)
if (SpellEffects(spellInfo->Effect[i])==effect)
return true;
return false;
}
inline bool IsAuraApplyEffect(SpellEntry const *spellInfo, SpellEffectIndex effecIdx)
inline bool IsAuraApplyEffect(SpellEntry const* spellInfo, SpellEffectIndex effecIdx)
{
switch (spellInfo->Effect[effecIdx])
{
@ -124,9 +124,9 @@ inline bool IsAuraApplyEffect(SpellEntry const *spellInfo, SpellEffectIndex effe
return false;
}
inline bool IsSpellAppliesAura(SpellEntry const *spellInfo, uint32 effectMask = ((1 << EFFECT_INDEX_0) | (1 << EFFECT_INDEX_1) | (1 << EFFECT_INDEX_2)))
inline bool IsSpellAppliesAura(SpellEntry const* spellInfo, uint32 effectMask = ((1 << EFFECT_INDEX_0) | (1 << EFFECT_INDEX_1) | (1 << EFFECT_INDEX_2)))
{
for(int i = 0; i < MAX_EFFECT_INDEX; ++i)
for (int i = 0; i < MAX_EFFECT_INDEX; ++i)
if (effectMask & (1 << i))
if (IsAuraApplyEffect(spellInfo, SpellEffectIndex(i)))
return true;
@ -134,7 +134,7 @@ inline bool IsSpellAppliesAura(SpellEntry const *spellInfo, uint32 effectMask =
return false;
}
inline bool IsEffectHandledOnDelayedSpellLaunch(SpellEntry const *spellInfo, SpellEffectIndex effecIdx)
inline bool IsEffectHandledOnDelayedSpellLaunch(SpellEntry const* spellInfo, SpellEffectIndex effecIdx)
{
switch (spellInfo->Effect[effecIdx])
{
@ -149,7 +149,7 @@ inline bool IsEffectHandledOnDelayedSpellLaunch(SpellEntry const *spellInfo, Spe
}
}
inline bool IsPeriodicRegenerateEffect(SpellEntry const *spellInfo, SpellEffectIndex effecIdx)
inline bool IsPeriodicRegenerateEffect(SpellEntry const* spellInfo, SpellEffectIndex effecIdx)
{
switch (AuraType(spellInfo->EffectApplyAuraName[effecIdx]))
{
@ -162,27 +162,27 @@ inline bool IsPeriodicRegenerateEffect(SpellEntry const *spellInfo, SpellEffectI
}
}
bool IsCastEndProcModifierAura(SpellEntry const *spellInfo, SpellEffectIndex effecIdx, SpellEntry const *procSpell);
bool IsCastEndProcModifierAura(SpellEntry const* spellInfo, SpellEffectIndex effecIdx, SpellEntry const* procSpell);
inline bool IsSpellHaveAura(SpellEntry const *spellInfo, AuraType aura)
inline bool IsSpellHaveAura(SpellEntry const* spellInfo, AuraType aura)
{
for(int i = 0; i < MAX_EFFECT_INDEX; ++i)
if(AuraType(spellInfo->EffectApplyAuraName[i])==aura)
for (int i = 0; i < MAX_EFFECT_INDEX; ++i)
if (AuraType(spellInfo->EffectApplyAuraName[i])==aura)
return true;
return false;
}
inline bool IsSpellLastAuraEffect(SpellEntry const *spellInfo, SpellEffectIndex effecIdx)
inline bool IsSpellLastAuraEffect(SpellEntry const* spellInfo, SpellEffectIndex effecIdx)
{
for(int i = effecIdx+1; i < MAX_EFFECT_INDEX; ++i)
if(spellInfo->EffectApplyAuraName[i])
for (int i = effecIdx+1; i < MAX_EFFECT_INDEX; ++i)
if (spellInfo->EffectApplyAuraName[i])
return false;
return true;
}
bool IsNoStackAuraDueToAura(uint32 spellId_1, uint32 spellId_2);
inline bool IsSealSpell(SpellEntry const *spellInfo)
inline bool IsSealSpell(SpellEntry const* spellInfo)
{
//Collection of all the seal family flags. No other paladin spell has any of those.
return spellInfo->IsFitToFamily(SPELLFAMILY_PALADIN, UI64LIT(0x26000C000A000000)) &&
@ -190,13 +190,13 @@ inline bool IsSealSpell(SpellEntry const *spellInfo)
spellInfo->EffectImplicitTargetA[EFFECT_INDEX_0] == TARGET_SELF;
}
inline bool IsElementalShield(SpellEntry const *spellInfo)
inline bool IsElementalShield(SpellEntry const* spellInfo)
{
// family flags 10 (Lightning), 42 (Earth), 37 (Water), proc shield from T2 8 pieces bonus
return (spellInfo->SpellFamilyFlags & UI64LIT(0x42000000400)) || spellInfo->Id == 23552;
}
inline bool IsExplicitDiscoverySpell(SpellEntry const *spellInfo)
inline bool IsExplicitDiscoverySpell(SpellEntry const* spellInfo)
{
return (((spellInfo->Effect[EFFECT_INDEX_0] == SPELL_EFFECT_CREATE_RANDOM_ITEM
|| spellInfo->Effect[EFFECT_INDEX_0] == SPELL_EFFECT_CREATE_ITEM_2)
@ -204,7 +204,7 @@ inline bool IsExplicitDiscoverySpell(SpellEntry const *spellInfo)
|| spellInfo->Id == 64323); // Book of Glyph Mastery (Effect0==SPELL_EFFECT_SCRIPT_EFFECT without any other data)
}
inline bool IsLootCraftingSpell(SpellEntry const *spellInfo)
inline bool IsLootCraftingSpell(SpellEntry const* spellInfo)
{
return (spellInfo->Effect[EFFECT_INDEX_0] == SPELL_EFFECT_CREATE_RANDOM_ITEM ||
// different random cards from Inscription (121==Virtuoso Inking Set category) r without explicit item
@ -224,7 +224,7 @@ bool IsPassiveSpell(SpellEntry const* spellProto);
inline bool IsPassiveSpellStackableWithRanks(SpellEntry const* spellProto)
{
if(!IsPassiveSpell(spellProto))
if (!IsPassiveSpell(spellProto))
return false;
return !IsSpellHaveEffect(spellProto,SPELL_EFFECT_APPLY_AURA);
@ -242,35 +242,35 @@ inline bool IsSpellRemoveAllMovementAndControlLossEffects(SpellEntry const* spel
(SPELL_ATTR_EX5_USABLE_WHILE_CONFUSED|SPELL_ATTR_EX5_USABLE_WHILE_FEARED|SPELL_ATTR_EX5_USABLE_WHILE_STUNNED))*/;
}
inline bool IsDeathOnlySpell(SpellEntry const *spellInfo)
inline bool IsDeathOnlySpell(SpellEntry const* spellInfo)
{
return spellInfo->HasAttribute(SPELL_ATTR_EX3_CAST_ON_DEAD) || spellInfo->Id == 2584;
}
inline bool IsDeathPersistentSpell(SpellEntry const *spellInfo)
inline bool IsDeathPersistentSpell(SpellEntry const* spellInfo)
{
return spellInfo->HasAttribute(SPELL_ATTR_EX3_DEATH_PERSISTENT);
}
inline bool IsNonCombatSpell(SpellEntry const *spellInfo)
inline bool IsNonCombatSpell(SpellEntry const* spellInfo)
{
return spellInfo->HasAttribute(SPELL_ATTR_CANT_USED_IN_COMBAT);
}
bool IsPositiveSpell(uint32 spellId);
bool IsPositiveSpell(SpellEntry const *spellproto);
bool IsPositiveEffect(SpellEntry const *spellInfo, SpellEffectIndex effIndex);
bool IsPositiveSpell(SpellEntry const* spellproto);
bool IsPositiveEffect(SpellEntry const* spellInfo, SpellEffectIndex effIndex);
bool IsPositiveTarget(uint32 targetA, uint32 targetB);
bool IsExplicitPositiveTarget(uint32 targetA);
bool IsExplicitNegativeTarget(uint32 targetA);
bool IsSingleTargetSpell(SpellEntry const *spellInfo);
bool IsSingleTargetSpells(SpellEntry const *spellInfo1, SpellEntry const *spellInfo2);
bool IsSingleTargetSpell(SpellEntry const* spellInfo);
bool IsSingleTargetSpells(SpellEntry const* spellInfo1, SpellEntry const* spellInfo2);
inline bool IsCasterSourceTarget(uint32 target)
{
switch (target )
switch (target)
{
case TARGET_SELF:
case TARGET_PET:
@ -300,25 +300,25 @@ inline bool IsCasterSourceTarget(uint32 target)
inline bool IsSpellWithCasterSourceTargetsOnly(SpellEntry const* spellInfo)
{
for(int i = 0; i < MAX_EFFECT_INDEX; ++i)
for (int i = 0; i < MAX_EFFECT_INDEX; ++i)
{
uint32 targetA = spellInfo->EffectImplicitTargetA[i];
if(targetA && !IsCasterSourceTarget(targetA))
if (targetA && !IsCasterSourceTarget(targetA))
return false;
uint32 targetB = spellInfo->EffectImplicitTargetB[i];
if(targetB && !IsCasterSourceTarget(targetB))
if (targetB && !IsCasterSourceTarget(targetB))
return false;
if(!targetA && !targetB)
if (!targetA && !targetB)
return false;
}
return true;
}
inline bool IsPointEffectTarget( Targets target )
inline bool IsPointEffectTarget(Targets target)
{
switch (target )
switch (target)
{
case TARGET_INNKEEPER_COORDINATES:
case TARGET_TABLE_X_Y_Z_COORDINATES:
@ -342,9 +342,9 @@ inline bool IsPointEffectTarget( Targets target )
return false;
}
inline bool IsAreaEffectPossitiveTarget( Targets target )
inline bool IsAreaEffectPossitiveTarget(Targets target)
{
switch (target )
switch (target)
{
case TARGET_ALL_PARTY_AROUND_CASTER:
case TARGET_ALL_FRIENDLY_UNITS_AROUND_CASTER:
@ -361,9 +361,9 @@ inline bool IsAreaEffectPossitiveTarget( Targets target )
return false;
}
inline bool IsAreaEffectTarget( Targets target )
inline bool IsAreaEffectTarget(Targets target)
{
switch (target )
switch (target)
{
case TARGET_AREAEFFECT_INSTANT:
case TARGET_AREAEFFECT_CUSTOM:
@ -388,20 +388,20 @@ inline bool IsAreaEffectTarget( Targets target )
return false;
}
inline bool IsAreaOfEffectSpell(SpellEntry const *spellInfo)
inline bool IsAreaOfEffectSpell(SpellEntry const* spellInfo)
{
if(IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetA[EFFECT_INDEX_0])) || IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetB[EFFECT_INDEX_0])))
if (IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetA[EFFECT_INDEX_0])) || IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetB[EFFECT_INDEX_0])))
return true;
if(IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetA[EFFECT_INDEX_1])) || IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetB[EFFECT_INDEX_1])))
if (IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetA[EFFECT_INDEX_1])) || IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetB[EFFECT_INDEX_1])))
return true;
if(IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetA[EFFECT_INDEX_2])) || IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetB[EFFECT_INDEX_2])))
if (IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetA[EFFECT_INDEX_2])) || IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetB[EFFECT_INDEX_2])))
return true;
return false;
}
inline bool IsAreaAuraEffect(uint32 effect)
{
if( effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY ||
if (effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY ||
effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID ||
effect == SPELL_EFFECT_APPLY_AREA_AURA_FRIEND ||
effect == SPELL_EFFECT_APPLY_AREA_AURA_ENEMY ||
@ -411,7 +411,7 @@ inline bool IsAreaAuraEffect(uint32 effect)
return false;
}
inline bool HasAreaAuraEffect(SpellEntry const *spellInfo)
inline bool HasAreaAuraEffect(SpellEntry const* spellInfo)
{
for (int32 i = 0; i < MAX_EFFECT_INDEX; ++i)
if (IsAreaAuraEffect(spellInfo->Effect[i]))
@ -419,11 +419,11 @@ inline bool HasAreaAuraEffect(SpellEntry const *spellInfo)
return false;
}
inline bool HasAuraWithTriggerEffect(SpellEntry const *spellInfo)
inline bool HasAuraWithTriggerEffect(SpellEntry const* spellInfo)
{
for (int32 i = 0; i < MAX_EFFECT_INDEX; ++i)
{
switch(spellInfo->Effect[i])
switch (spellInfo->Effect[i])
{
case SPELL_AURA_PERIODIC_TRIGGER_SPELL:
case SPELL_AURA_PROC_TRIGGER_SPELL:
@ -435,7 +435,7 @@ inline bool HasAuraWithTriggerEffect(SpellEntry const *spellInfo)
return false;
}
inline bool IsDispelSpell(SpellEntry const *spellInfo)
inline bool IsDispelSpell(SpellEntry const* spellInfo)
{
return IsSpellHaveEffect(spellInfo, SPELL_EFFECT_DISPEL);
}
@ -455,7 +455,7 @@ inline bool IsSpellRequiresRangedAP(SpellEntry const* spellInfo)
return (spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER && spellInfo->DmgClass != SPELL_DAMAGE_CLASS_MELEE);
}
SpellCastResult GetErrorAtShapeshiftedCast (SpellEntry const *spellInfo, uint32 form);
SpellCastResult GetErrorAtShapeshiftedCast(SpellEntry const* spellInfo, uint32 form);
inline bool IsChanneledSpell(SpellEntry const* spellInfo)
{
@ -717,12 +717,12 @@ class PetAura
uint32 GetAura(uint32 petEntry) const
{
std::map<uint32, uint32>::const_iterator itr = auras.find(petEntry);
if(itr != auras.end())
if (itr != auras.end())
return itr->second;
else
{
std::map<uint32, uint32>::const_iterator itr2 = auras.find(0);
if(itr2 != auras.end())
if (itr2 != auras.end())
return itr2->second;
else
return 0;
@ -859,7 +859,7 @@ class SpellMgr
uint32 GetSpellElixirMask(uint32 spellid) const
{
SpellElixirMap::const_iterator itr = mSpellElixirs.find(spellid);
if(itr==mSpellElixirs.end())
if (itr==mSpellElixirs.end())
return 0x0;
return itr->second;
@ -868,13 +868,13 @@ class SpellMgr
SpellSpecific GetSpellElixirSpecific(uint32 spellid) const
{
uint32 mask = GetSpellElixirMask(spellid);
if((mask & ELIXIR_FLASK_MASK)==ELIXIR_FLASK_MASK)
if ((mask & ELIXIR_FLASK_MASK)==ELIXIR_FLASK_MASK)
return SPELL_FLASK_ELIXIR;
else if(mask & ELIXIR_BATTLE_MASK)
else if (mask & ELIXIR_BATTLE_MASK)
return SPELL_BATTLE_ELIXIR;
else if(mask & ELIXIR_GUARDIAN_MASK)
else if (mask & ELIXIR_GUARDIAN_MASK)
return SPELL_GUARDIAN_ELIXIR;
else if(mask & ELIXIR_WELL_FED)
else if (mask & ELIXIR_WELL_FED)
return SPELL_WELL_FED;
else
return SPELL_NORMAL;
@ -889,12 +889,12 @@ class SpellMgr
return NULL;
}
float GetSpellThreatMultiplier(SpellEntry const *spellInfo) const
float GetSpellThreatMultiplier(SpellEntry const* spellInfo) const
{
if (!spellInfo)
return 1.0f;
if (SpellThreatEntry const *entry = GetSpellThreatEntry(spellInfo->Id))
if (SpellThreatEntry const* entry = GetSpellThreatEntry(spellInfo->Id))
return entry->multiplier;
return 1.0f;
@ -904,7 +904,7 @@ class SpellMgr
SpellProcEventEntry const* GetSpellProcEvent(uint32 spellId) const
{
SpellProcEventMap::const_iterator itr = mSpellProcEventMap.find(spellId);
if( itr != mSpellProcEventMap.end( ) )
if (itr != mSpellProcEventMap.end())
return &itr->second;
return NULL;
}
@ -913,20 +913,20 @@ class SpellMgr
float GetItemEnchantProcChance(uint32 spellid) const
{
SpellProcItemEnchantMap::const_iterator itr = mSpellProcItemEnchantMap.find(spellid);
if(itr==mSpellProcItemEnchantMap.end())
if (itr==mSpellProcItemEnchantMap.end())
return 0.0f;
return itr->second;
}
static bool IsSpellProcEventCanTriggeredBy( SpellProcEventEntry const * spellProcEvent, uint32 EventProcFlag, SpellEntry const * procSpell, uint32 procFlags, uint32 procExtra);
static bool IsSpellProcEventCanTriggeredBy(SpellProcEventEntry const* spellProcEvent, uint32 EventProcFlag, SpellEntry const* procSpell, uint32 procFlags, uint32 procExtra);
// Spell bonus data
SpellBonusEntry const* GetSpellBonusData(uint32 spellId) const
{
// Lookup data
SpellBonusMap::const_iterator itr = mSpellBonusMap.find(spellId);
if( itr != mSpellBonusMap.end( ) )
if (itr != mSpellBonusMap.end())
return &itr->second;
return NULL;
@ -935,8 +935,8 @@ class SpellMgr
// Spell target coordinates
SpellTargetPosition const* GetSpellTargetPosition(uint32 spell_id) const
{
SpellTargetPositionMap::const_iterator itr = mSpellTargetPositions.find( spell_id );
if( itr != mSpellTargetPositions.end( ) )
SpellTargetPositionMap::const_iterator itr = mSpellTargetPositions.find(spell_id);
if (itr != mSpellTargetPositions.end())
return &itr->second;
return NULL;
}
@ -945,7 +945,7 @@ class SpellMgr
SpellChainNode const* GetSpellChainNode(uint32 spell_id) const
{
SpellChainMap::const_iterator itr = mSpellChains.find(spell_id);
if(itr == mSpellChains.end())
if (itr == mSpellChains.end())
return NULL;
return &itr->second;
@ -953,7 +953,7 @@ class SpellMgr
uint32 GetFirstSpellInChain(uint32 spell_id) const
{
if(SpellChainNode const* node = GetSpellChainNode(spell_id))
if (SpellChainNode const* node = GetSpellChainNode(spell_id))
return node->first;
return spell_id;
@ -961,7 +961,7 @@ class SpellMgr
uint32 GetPrevSpellInChain(uint32 spell_id) const
{
if(SpellChainNode const* node = GetSpellChainNode(spell_id))
if (SpellChainNode const* node = GetSpellChainNode(spell_id))
return node->prev;
return 0;
@ -973,7 +973,7 @@ class SpellMgr
void doForHighRanks(uint32 spellid, Worker& worker)
{
SpellChainMapNext const& nextMap = GetSpellChainNext();
for(SpellChainMapNext::const_iterator itr = nextMap.lower_bound(spellid); itr != nextMap.upper_bound(spellid); ++itr)
for (SpellChainMapNext::const_iterator itr = nextMap.lower_bound(spellid); itr != nextMap.upper_bound(spellid); ++itr)
{
worker(itr->second);
doForHighRanks(itr->second,worker);
@ -984,7 +984,7 @@ class SpellMgr
// Use IsHighRankOfSpell instead
uint8 GetSpellRank(uint32 spell_id) const
{
if(SpellChainNode const* node = GetSpellChainNode(spell_id))
if (SpellChainNode const* node = GetSpellChainNode(spell_id))
return node->rank;
return 0;
@ -997,21 +997,21 @@ class SpellMgr
uint32 rank2 = GetSpellRank(spell2);
// not ordered correctly by rank value
if(itr == mSpellChains.end() || !rank2 || itr->second.rank <= rank2)
if (itr == mSpellChains.end() || !rank2 || itr->second.rank <= rank2)
return false;
// check present in same rank chain
for(; itr != mSpellChains.end(); itr = mSpellChains.find(itr->second.prev))
if(itr->second.prev==spell2)
for (; itr != mSpellChains.end(); itr = mSpellChains.find(itr->second.prev))
if (itr->second.prev==spell2)
return true;
return false;
}
bool IsRankSpellDueToSpell(SpellEntry const *spellInfo_1,uint32 spellId_2) const;
bool IsRankSpellDueToSpell(SpellEntry const* spellInfo_1,uint32 spellId_2) const;
bool IsNoStackSpellDueToSpell(uint32 spellId_1, uint32 spellId_2) const;
bool canStackSpellRanksInSpellBook(SpellEntry const *spellInfo) const;
bool IsRankedSpellNonStackableInSpellBook(SpellEntry const *spellInfo) const
bool canStackSpellRanksInSpellBook(SpellEntry const* spellInfo) const;
bool IsRankedSpellNonStackableInSpellBook(SpellEntry const* spellInfo) const
{
return !canStackSpellRanksInSpellBook(spellInfo) && GetSpellRank(spellInfo->Id) != 0;
}
@ -1022,7 +1022,7 @@ class SpellMgr
SpellLearnSkillNode const* GetSpellLearnSkill(uint32 spell_id) const
{
SpellLearnSkillMap::const_iterator itr = mSpellLearnSkills.find(spell_id);
if(itr != mSpellLearnSkills.end())
if (itr != mSpellLearnSkills.end())
return &itr->second;
else
return NULL;
@ -1041,7 +1041,7 @@ class SpellMgr
bool IsSpellLearnToSpell(uint32 spell_id1,uint32 spell_id2) const
{
SpellLearnSpellMapBounds bounds = GetSpellLearnSpellMapBounds(spell_id1);
for(SpellLearnSpellMap::const_iterator i = bounds.first; i != bounds.second; ++i)
for (SpellLearnSpellMap::const_iterator i = bounds.first; i != bounds.second; ++i)
if (i->second.spell==spell_id2)
return true;
return false;
@ -1063,7 +1063,7 @@ class SpellMgr
}
// Spell correctness for client using
static bool IsSpellValid(SpellEntry const * spellInfo, Player* pl = NULL, bool msg = true);
static bool IsSpellValid(SpellEntry const* spellInfo, Player* pl = NULL, bool msg = true);
SkillLineAbilityMapBounds GetSkillLineAbilityMapBounds(uint32 spell_id) const
{
@ -1078,7 +1078,7 @@ class SpellMgr
PetAura const* GetPetAura(uint32 spell_id, SpellEffectIndex eff)
{
SpellPetAuraMap::const_iterator itr = mSpellPetAuraMap.find((spell_id<<8) + eff);
if(itr != mSpellPetAuraMap.end())
if (itr != mSpellPetAuraMap.end())
return &itr->second;
else
return NULL;
@ -1087,7 +1087,7 @@ class SpellMgr
PetLevelupSpellSet const* GetPetLevelupSpellList(uint32 petFamily) const
{
PetLevelupSpellMap::const_iterator itr = mPetLevelupSpellMap.find(petFamily);
if(itr != mPetLevelupSpellMap.end())
if (itr != mPetLevelupSpellMap.end())
return &itr->second;
else
return NULL;
@ -1097,12 +1097,12 @@ class SpellMgr
PetDefaultSpellsEntry const* GetPetDefaultSpellsEntry(int32 id) const
{
PetDefaultSpellsMap::const_iterator itr = mPetDefaultSpellsMap.find(id);
if(itr != mPetDefaultSpellsMap.end())
if (itr != mPetDefaultSpellsMap.end())
return &itr->second;
return NULL;
}
SpellCastResult GetSpellAllowedInLocationError(SpellEntry const *spellInfo, uint32 map_id, uint32 zone_id, uint32 area_id, Player const* player = NULL);
SpellCastResult GetSpellAllowedInLocationError(SpellEntry const* spellInfo, uint32 map_id, uint32 zone_id, uint32 area_id, Player const* player = NULL);
SpellAreaMapBounds GetSpellAreaMapBounds(uint32 spell_id) const
{

160
src/game/StatSystem.cpp
View file

@ -31,7 +31,7 @@
bool Player::UpdateStats(Stats stat)
{
if(stat > STAT_SPIRIT)
if (stat > STAT_SPIRIT)
return false;
// value = ((base_value * base_pct) + total_value) * total_pct
@ -39,14 +39,14 @@ bool Player::UpdateStats(Stats stat)
SetStat(stat, int32(value));
if(stat == STAT_STAMINA || stat == STAT_INTELLECT)
if (stat == STAT_STAMINA || stat == STAT_INTELLECT)
{
Pet *pet = GetPet();
if(pet)
Pet* pet = GetPet();
if (pet)
pet->UpdateStats(stat);
}
switch(stat)
switch (stat)
{
case STAT_STRENGTH:
UpdateShieldBlockValue();
@ -79,7 +79,7 @@ bool Player::UpdateStats(Stats stat)
// Update ratings in exist SPELL_AURA_MOD_RATING_FROM_STAT and only depends from stat
uint32 mask = 0;
AuraList const& modRatingFromStat = GetAurasByType(SPELL_AURA_MOD_RATING_FROM_STAT);
for(AuraList::const_iterator i = modRatingFromStat.begin();i != modRatingFromStat.end(); ++i)
for (AuraList::const_iterator i = modRatingFromStat.begin(); i != modRatingFromStat.end(); ++i)
if (Stats((*i)->GetMiscBValue()) == stat)
mask |= (*i)->GetMiscValue();
if (mask)
@ -97,7 +97,7 @@ void Player::ApplySpellPowerBonus(int32 amount, bool apply)
// For speed just update for client
ApplyModUInt32Value(PLAYER_FIELD_MOD_HEALING_DONE_POS, amount, apply);
for(int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
for (int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
ApplyModUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS+i, amount, apply);;
}
@ -108,7 +108,7 @@ void Player::UpdateSpellDamageAndHealingBonus()
// Get healing bonus for all schools
SetStatInt32Value(PLAYER_FIELD_MOD_HEALING_DONE_POS, SpellBaseHealingBonusDone(SPELL_SCHOOL_MASK_ALL));
// Get damage bonus for all schools
for(int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
for (int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
SetStatInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS+i, SpellBaseDamageBonusDone(SpellSchoolMask(1 << i)));
}
@ -125,7 +125,7 @@ bool Player::UpdateAllStats()
UpdateAttackPowerAndDamage(true);
UpdateMaxHealth();
for(int i = POWER_MANA; i < MAX_POWERS; ++i)
for (int i = POWER_MANA; i < MAX_POWERS; ++i)
UpdateMaxPower(Powers(i));
UpdateAllRatings();
@ -146,13 +146,13 @@ bool Player::UpdateAllStats()
void Player::UpdateResistances(uint32 school)
{
if(school > SPELL_SCHOOL_NORMAL)
if (school > SPELL_SCHOOL_NORMAL)
{
float value = GetTotalAuraModValue(UnitMods(UNIT_MOD_RESISTANCE_START + school));
SetResistance(SpellSchools(school), int32(value));
Pet *pet = GetPet();
if(pet)
Pet* pet = GetPet();
if (pet)
pet->UpdateResistances(school);
}
else
@ -171,10 +171,10 @@ void Player::UpdateArmor()
//add dynamic flat mods
AuraList const& mResbyIntellect = GetAurasByType(SPELL_AURA_MOD_RESISTANCE_OF_STAT_PERCENT);
for(AuraList::const_iterator i = mResbyIntellect.begin();i != mResbyIntellect.end(); ++i)
for (AuraList::const_iterator i = mResbyIntellect.begin(); i != mResbyIntellect.end(); ++i)
{
Modifier* mod = (*i)->GetModifier();
if(mod->m_miscvalue & SPELL_SCHOOL_MASK_NORMAL)
if (mod->m_miscvalue & SPELL_SCHOOL_MASK_NORMAL)
value += int32(GetStat(Stats((*i)->GetMiscBValue())) * mod->m_amount / 100.0f);
}
@ -182,8 +182,8 @@ void Player::UpdateArmor()
SetArmor(int32(value));
Pet *pet = GetPet();
if(pet)
Pet* pet = GetPet();
if (pet)
pet->UpdateArmor();
UpdateAttackPowerAndDamage(); // armor dependent auras update for SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR
@ -244,7 +244,7 @@ void Player::ApplyFeralAPBonus(int32 amount, bool apply)
UpdateAttackPowerAndDamage();
}
void Player::UpdateAttackPowerAndDamage(bool ranged )
void Player::UpdateAttackPowerAndDamage(bool ranged)
{
float val2 = 0.0f;
float level = float(getLevel());
@ -255,19 +255,19 @@ void Player::UpdateAttackPowerAndDamage(bool ranged )
uint16 index_mod = UNIT_FIELD_ATTACK_POWER_MODS;
uint16 index_mult = UNIT_FIELD_ATTACK_POWER_MULTIPLIER;
if(ranged)
if (ranged)
{
index = UNIT_FIELD_RANGED_ATTACK_POWER;
index_mod = UNIT_FIELD_RANGED_ATTACK_POWER_MODS;
index_mult = UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER;
switch(getClass())
switch (getClass())
{
case CLASS_HUNTER: val2 = level * 2.0f + GetStat(STAT_AGILITY) - 10.0f; break;
case CLASS_ROGUE: val2 = level + GetStat(STAT_AGILITY) - 10.0f; break;
case CLASS_WARRIOR:val2 = level + GetStat(STAT_AGILITY) - 10.0f; break;
case CLASS_DRUID:
switch(GetShapeshiftForm())
switch (GetShapeshiftForm())
{
case FORM_CAT:
case FORM_BEAR:
@ -282,7 +282,7 @@ void Player::UpdateAttackPowerAndDamage(bool ranged )
}
else
{
switch(getClass())
switch (getClass())
{
case CLASS_WARRIOR: val2 = level*3.0f + GetStat(STAT_STRENGTH)*2.0f - 20.0f; break;
case CLASS_PALADIN: val2 = level*3.0f + GetStat(STAT_STRENGTH)*2.0f - 20.0f; break;
@ -296,7 +296,7 @@ void Player::UpdateAttackPowerAndDamage(bool ranged )
//Check if Predatory Strikes is skilled
float mLevelBonus = 0.0f;
float mBonusWeaponAtt = 0.0f;
switch(form)
switch (form)
{
case FORM_CAT:
case FORM_BEAR:
@ -304,9 +304,9 @@ void Player::UpdateAttackPowerAndDamage(bool ranged )
case FORM_MOONKIN:
{
Unit::AuraList const& mDummy = GetAurasByType(SPELL_AURA_DUMMY);
for(Unit::AuraList::const_iterator itr = mDummy.begin(); itr != mDummy.end(); ++itr)
for (Unit::AuraList::const_iterator itr = mDummy.begin(); itr != mDummy.end(); ++itr)
{
if((*itr)->GetSpellProto()->SpellIconID != 1563)
if ((*itr)->GetSpellProto()->SpellIconID != 1563)
continue;
// Predatory Strikes (effect 0)
@ -324,7 +324,7 @@ void Player::UpdateAttackPowerAndDamage(bool ranged )
default: break;
}
switch(form)
switch (form)
{
case FORM_CAT:
val2 = GetStat(STAT_STRENGTH)*2.0f + GetStat(STAT_AGILITY) - 20.0f + mLevelBonus + m_baseFeralAP + mBonusWeaponAtt; break;
@ -350,23 +350,23 @@ void Player::UpdateAttackPowerAndDamage(bool ranged )
float attPowerMod = GetModifierValue(unitMod, TOTAL_VALUE);
//add dynamic flat mods
if( ranged )
if (ranged)
{
if ((getClassMask() & CLASSMASK_WAND_USERS)==0)
{
AuraList const& mRAPbyStat = GetAurasByType(SPELL_AURA_MOD_RANGED_ATTACK_POWER_OF_STAT_PERCENT);
for(AuraList::const_iterator i = mRAPbyStat.begin();i != mRAPbyStat.end(); ++i)
for (AuraList::const_iterator i = mRAPbyStat.begin(); i != mRAPbyStat.end(); ++i)
attPowerMod += int32(GetStat(Stats((*i)->GetModifier()->m_miscvalue)) * (*i)->GetModifier()->m_amount / 100.0f);
}
}
else
{
AuraList const& mAPbyStat = GetAurasByType(SPELL_AURA_MOD_ATTACK_POWER_OF_STAT_PERCENT);
for(AuraList::const_iterator i = mAPbyStat.begin();i != mAPbyStat.end(); ++i)
for (AuraList::const_iterator i = mAPbyStat.begin(); i != mAPbyStat.end(); ++i)
attPowerMod += int32(GetStat(Stats((*i)->GetModifier()->m_miscvalue)) * (*i)->GetModifier()->m_amount / 100.0f);
AuraList const& mAPbyArmor = GetAurasByType(SPELL_AURA_MOD_ATTACK_POWER_OF_ARMOR);
for(AuraList::const_iterator iter = mAPbyArmor.begin(); iter != mAPbyArmor.end(); ++iter)
for (AuraList::const_iterator iter = mAPbyArmor.begin(); iter != mAPbyArmor.end(); ++iter)
// always: ((*i)->GetModifier()->m_miscvalue == 1 == SPELL_SCHOOL_MASK_NORMAL)
attPowerMod += int32(GetArmor() / (*iter)->GetModifier()->m_amount);
}
@ -378,18 +378,18 @@ void Player::UpdateAttackPowerAndDamage(bool ranged )
SetFloatValue(index_mult, attPowerMultiplier); //UNIT_FIELD_(RANGED)_ATTACK_POWER_MULTIPLIER field
//automatically update weapon damage after attack power modification
if(ranged)
if (ranged)
{
UpdateDamagePhysical(RANGED_ATTACK);
Pet *pet = GetPet(); //update pet's AP
if(pet)
Pet* pet = GetPet(); //update pet's AP
if (pet)
pet->UpdateAttackPowerAndDamage();
}
else
{
UpdateDamagePhysical(BASE_ATTACK);
if(CanDualWield() && haveOffhandWeapon()) //allow update offhand damage only if player knows DualWield Spec and has equipped offhand weapon
if (CanDualWield() && haveOffhandWeapon()) //allow update offhand damage only if player knows DualWield Spec and has equipped offhand weapon
UpdateDamagePhysical(OFF_ATTACK);
}
}
@ -404,7 +404,7 @@ void Player::CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, fl
UnitMods unitMod;
UnitMods attPower;
switch(attType)
switch (attType)
{
case BASE_ATTACK:
default:
@ -462,7 +462,7 @@ void Player::UpdateDamagePhysical(WeaponAttackType attType)
CalculateMinMaxDamage(attType,false,mindamage,maxdamage);
switch(attType)
switch (attType)
{
case BASE_ATTACK:
default:
@ -491,7 +491,7 @@ void Player::UpdateBlockPercentage()
{
// No block
float value = 0.0f;
if(CanBlock())
if (CanBlock())
{
// Base value
value = 5.0f;
@ -512,7 +512,7 @@ void Player::UpdateCritPercentage(WeaponAttackType attType)
uint16 index;
CombatRating cr;
switch(attType)
switch (attType)
{
case OFF_ATTACK:
modGroup = OFFHAND_CRIT_PERCENTAGE;
@ -644,7 +644,7 @@ void Player::UpdateDodgePercentage()
void Player::UpdateSpellCritChance(uint32 school)
{
// For normal school set zero crit chance
if(school == SPELL_SCHOOL_NORMAL)
if (school == SPELL_SCHOOL_NORMAL)
{
SetFloatValue(PLAYER_SPELL_CRIT_PERCENTAGE1, 0.0f);
return;
@ -692,28 +692,28 @@ void Player::UpdateAllSpellCritChances()
void Player::UpdateExpertise(WeaponAttackType attack)
{
if(attack==RANGED_ATTACK)
if (attack==RANGED_ATTACK)
return;
int32 expertise = int32(GetRatingBonusValue(CR_EXPERTISE));
Item *weapon = GetWeaponForAttack(attack);
Item* weapon = GetWeaponForAttack(attack);
AuraList const& expAuras = GetAurasByType(SPELL_AURA_MOD_EXPERTISE);
for(AuraList::const_iterator itr = expAuras.begin(); itr != expAuras.end(); ++itr)
for (AuraList::const_iterator itr = expAuras.begin(); itr != expAuras.end(); ++itr)
{
// item neutral spell
if((*itr)->GetSpellProto()->EquippedItemClass == -1)
if ((*itr)->GetSpellProto()->EquippedItemClass == -1)
expertise += (*itr)->GetModifier()->m_amount;
// item dependent spell
else if(weapon && weapon->IsFitToSpellRequirements((*itr)->GetSpellProto()))
else if (weapon && weapon->IsFitToSpellRequirements((*itr)->GetSpellProto()))
expertise += (*itr)->GetModifier()->m_amount;
}
if(expertise < 0)
if (expertise < 0)
expertise = 0;
switch(attack)
switch (attack)
{
case BASE_ATTACK: SetUInt32Value(PLAYER_EXPERTISE, expertise); break;
case OFF_ATTACK: SetUInt32Value(PLAYER_OFFHAND_EXPERTISE, expertise); break;
@ -726,20 +726,20 @@ void Player::UpdateArmorPenetration()
m_armorPenetrationPct = GetRatingBonusValue(CR_ARMOR_PENETRATION);
AuraList const& armorAuras = GetAurasByType(SPELL_AURA_MOD_TARGET_ARMOR_PCT);
for(AuraList::const_iterator itr = armorAuras.begin(); itr != armorAuras.end(); ++itr)
for (AuraList::const_iterator itr = armorAuras.begin(); itr != armorAuras.end(); ++itr)
{
// affects all weapons
if((*itr)->GetSpellProto()->EquippedItemClass == -1)
if ((*itr)->GetSpellProto()->EquippedItemClass == -1)
{
m_armorPenetrationPct += (*itr)->GetModifier()->m_amount;
continue;
}
// dependent on weapon class
for(uint8 i = 0; i < MAX_ATTACK; ++i)
for (uint8 i = 0; i < MAX_ATTACK; ++i)
{
Item *weapon = GetWeaponForAttack(WeaponAttackType(i));
if(weapon && weapon->IsFitToSpellRequirements((*itr)->GetSpellProto()))
Item* weapon = GetWeaponForAttack(WeaponAttackType(i));
if (weapon && weapon->IsFitToSpellRequirements((*itr)->GetSpellProto()))
{
m_armorPenetrationPct += (*itr)->GetModifier()->m_amount;
break;
@ -767,7 +767,7 @@ void Player::UpdateManaRegen()
// Get bonus from SPELL_AURA_MOD_MANA_REGEN_FROM_STAT aura
AuraList const& regenAura = GetAurasByType(SPELL_AURA_MOD_MANA_REGEN_FROM_STAT);
for(AuraList::const_iterator i = regenAura.begin();i != regenAura.end(); ++i)
for (AuraList::const_iterator i = regenAura.begin(); i != regenAura.end(); ++i)
{
Modifier* mod = (*i)->GetModifier();
power_regen_mp5 += GetStat(Stats(mod->m_miscvalue)) * mod->m_amount / 500.0f;
@ -822,10 +822,10 @@ bool Creature::UpdateAllStats()
UpdateMaxHealth();
UpdateAttackPowerAndDamage();
for(int i = POWER_MANA; i < MAX_POWERS; ++i)
for (int i = POWER_MANA; i < MAX_POWERS; ++i)
UpdateMaxPower(Powers(i));
for(int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
UpdateResistances(i);
return true;
@ -833,7 +833,7 @@ bool Creature::UpdateAllStats()
void Creature::UpdateResistances(uint32 school)
{
if(school > SPELL_SCHOOL_NORMAL)
if (school > SPELL_SCHOOL_NORMAL)
{
float value = GetTotalAuraModValue(UnitMods(UNIT_MOD_RESISTANCE_START + school));
SetResistance(SpellSchools(school), int32(value));
@ -926,28 +926,28 @@ void Creature::UpdateDamagePhysical(WeaponAttackType attType)
bool Pet::UpdateStats(Stats stat)
{
if(stat > STAT_SPIRIT)
if (stat > STAT_SPIRIT)
return false;
// value = ((base_value * base_pct) + total_value) * total_pct
float value = GetTotalStatValue(stat);
Unit *owner = GetOwner();
if ( stat == STAT_STAMINA )
Unit* owner = GetOwner();
if (stat == STAT_STAMINA)
{
if(owner)
if (owner)
value += float(owner->GetStat(stat)) * 0.3f;
}
//warlock's and mage's pets gain 30% of owner's intellect
else if ( stat == STAT_INTELLECT && getPetType() == SUMMON_PET )
else if (stat == STAT_INTELLECT && getPetType() == SUMMON_PET)
{
if(owner && (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE) )
if (owner && (owner->getClass() == CLASS_WARLOCK || owner->getClass() == CLASS_MAGE))
value += float(owner->GetStat(stat)) * 0.3f;
}
SetStat(stat, int32(value));
switch(stat)
switch (stat)
{
case STAT_STRENGTH: UpdateAttackPowerAndDamage(); break;
case STAT_AGILITY: UpdateArmor(); break;
@ -966,7 +966,7 @@ bool Pet::UpdateAllStats()
for (int i = STAT_STRENGTH; i < MAX_STATS; ++i)
UpdateStats(Stats(i));
for(int i = POWER_MANA; i < MAX_POWERS; ++i)
for (int i = POWER_MANA; i < MAX_POWERS; ++i)
UpdateMaxPower(Powers(i));
for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
@ -977,13 +977,13 @@ bool Pet::UpdateAllStats()
void Pet::UpdateResistances(uint32 school)
{
if(school > SPELL_SCHOOL_NORMAL)
if (school > SPELL_SCHOOL_NORMAL)
{
float value = GetTotalAuraModValue(UnitMods(UNIT_MOD_RESISTANCE_START + school));
Unit *owner = GetOwner();
Unit* owner = GetOwner();
// hunter and warlock pets gain 40% of owner's resistance
if(owner && (getPetType() == HUNTER_PET || (getPetType() == SUMMON_PET && owner->getClass() == CLASS_WARLOCK)))
if (owner && (getPetType() == HUNTER_PET || (getPetType() == SUMMON_PET && owner->getClass() == CLASS_WARLOCK)))
value += float(owner->GetResistance(SpellSchools(school))) * 0.4f;
SetResistance(SpellSchools(school), int32(value));
@ -998,9 +998,9 @@ void Pet::UpdateArmor()
float bonus_armor = 0.0f;
UnitMods unitMod = UNIT_MOD_ARMOR;
Unit *owner = GetOwner();
Unit* owner = GetOwner();
// hunter and warlock pets gain 35% of owner's armor value
if(owner && (getPetType() == HUNTER_PET || (getPetType() == SUMMON_PET && owner->getClass() == CLASS_WARLOCK)))
if (owner && (getPetType() == HUNTER_PET || (getPetType() == SUMMON_PET && owner->getClass() == CLASS_WARLOCK)))
bonus_armor = 0.35f * float(owner->GetArmor());
value = GetModifierValue(unitMod, BASE_VALUE);
@ -1041,44 +1041,44 @@ void Pet::UpdateMaxPower(Powers power)
void Pet::UpdateAttackPowerAndDamage(bool ranged)
{
if(ranged)
if (ranged)
return;
float val = 0.0f;
float bonusAP = 0.0f;
UnitMods unitMod = UNIT_MOD_ATTACK_POWER;
if(GetEntry() == 416) // imp's attack power
if (GetEntry() == 416) // imp's attack power
val = GetStat(STAT_STRENGTH) - 10.0f;
else
val = 2 * GetStat(STAT_STRENGTH) - 20.0f;
Unit* owner = GetOwner();
if( owner && owner->GetTypeId()==TYPEID_PLAYER)
if (owner && owner->GetTypeId()==TYPEID_PLAYER)
{
if(getPetType() == HUNTER_PET) //hunter pets benefit from owner's attack power
if (getPetType() == HUNTER_PET) //hunter pets benefit from owner's attack power
{
bonusAP = owner->GetTotalAttackPowerValue(RANGED_ATTACK) * 0.22f;
SetBonusDamage( int32(owner->GetTotalAttackPowerValue(RANGED_ATTACK) * 0.1287f));
SetBonusDamage(int32(owner->GetTotalAttackPowerValue(RANGED_ATTACK) * 0.1287f));
}
//demons benefit from warlocks shadow or fire damage
else if(getPetType() == SUMMON_PET && owner->getClass() == CLASS_WARLOCK)
else if (getPetType() == SUMMON_PET && owner->getClass() == CLASS_WARLOCK)
{
int32 fire = int32(owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE)) - owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);
int32 shadow = int32(owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_SHADOW)) - owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_SHADOW);
int32 maximum = (fire > shadow) ? fire : shadow;
if(maximum < 0)
if (maximum < 0)
maximum = 0;
SetBonusDamage( int32(maximum * 0.15f));
SetBonusDamage(int32(maximum * 0.15f));
bonusAP = maximum * 0.57f;
}
//water elementals benefit from mage's frost damage
else if(getPetType() == SUMMON_PET && owner->getClass() == CLASS_MAGE)
else if (getPetType() == SUMMON_PET && owner->getClass() == CLASS_MAGE)
{
int32 frost = int32(owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FROST)) - owner->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FROST);
if(frost < 0)
if (frost < 0)
frost = 0;
SetBonusDamage( int32(frost * 0.4f));
SetBonusDamage(int32(frost * 0.4f));
}
}
@ -1102,7 +1102,7 @@ void Pet::UpdateAttackPowerAndDamage(bool ranged)
void Pet::UpdateDamagePhysical(WeaponAttackType attType)
{
if(attType > BASE_ATTACK)
if (attType > BASE_ATTACK)
return;
UnitMods unitMod = UNIT_MOD_DAMAGE_MAINHAND;
@ -1123,7 +1123,7 @@ void Pet::UpdateDamagePhysical(WeaponAttackType attType)
// Pet's base damage changes depending on happiness
if (getPetType() == HUNTER_PET && attType == BASE_ATTACK)
{
switch(GetHappinessState())
switch (GetHappinessState())
{
case HAPPY:
// 125% of normal damage