#include "DBCStore.h"
#include "DBCStructure.h"
#include "DB2Structure.h"
#include "SharedDefines.h"

Include dependency graph for DBCStores.h:

This graph shows which files directly or indirectly include this file:

Classes
class	GameTable< T >

Typedefs
typedef ChrSpecializationEntry const *	ChrSpecializationByIndexArray [MAX_CLASSES][MAX_SPECIALIZATIONS]

typedef std::vector < ItemSetSpellEntry const * >	ItemSetSpells

typedef std::unordered_map < uint32, ItemSetSpells >	ItemSetSpellsStore

typedef std::unordered_map < uint32, std::unordered_map < uint32, MapDifficultyEntry const * > >	MapDifficultyMap

typedef std::unordered_multimap < uint32, SkillRaceClassInfoEntry const * >	SkillRaceClassInfoMap

typedef std::pair < SkillRaceClassInfoMap::iterator, SkillRaceClassInfoMap::iterator >	SkillRaceClassInfoBounds

typedef std::unordered_map < uint32, uint32 >	SpellEffectScallingByEffectId

typedef std::vector < TalentEntry const * >	TalentsByPosition [MAX_CLASSES][MAX_TALENT_TIERS][MAX_TALENT_COLUMNS]

Functions
TC_GAME_API CharSectionsEntry const *	GetCharSectionEntry (uint8 race, CharSectionType genType, uint8 gender, uint8 type, uint8 color)

TC_GAME_API char const *	GetClassName (uint8 class_, uint8 locale)

TC_GAME_API char const *	GetRaceName (uint8 race, uint8 locale)

TC_GAME_API char const *	GetCreatureFamilyPetName (uint32 petfamily, uint32 locale)

TC_GAME_API EmotesTextSoundEntry const *	FindTextSoundEmoteFor (uint32 emote, uint32 race, uint32 gender)

TC_GAME_API std::vector < uint32 > const *	GetFactionTeamList (uint32 faction)

TC_GAME_API LFGDungeonEntry const *	GetLFGDungeon (uint32 mapId, Difficulty difficulty)
	Returns LFGDungeonEntry for a specific map and difficulty. Will return first found entry if multiple dungeons use the same map (such as Scarlet Monastery) More...

TC_GAME_API uint32	GetDefaultMapLight (uint32 mapId)

TC_GAME_API uint32	GetLiquidFlags (uint32 liquidType)

TC_GAME_API MapDifficultyEntry const *	GetDefaultMapDifficulty (uint32 mapId, Difficulty *difficulty=nullptr)

TC_GAME_API MapDifficultyEntry const *	GetMapDifficultyData (uint32 mapId, Difficulty difficulty)

TC_GAME_API MapDifficultyEntry const *	GetDownscaledMapDifficultyData (uint32 mapId, Difficulty &difficulty)

TC_GAME_API PvPDifficultyEntry const *	GetBattlegroundBracketByLevel (uint32 mapid, uint32 level)

TC_GAME_API PvPDifficultyEntry const *	GetBattlegroundBracketById (uint32 mapid, BattlegroundBracketId id)

TC_GAME_API SkillRaceClassInfoEntry const *	GetSkillRaceClassInfo (uint32 skill, uint8 race, uint8 class_)

TC_GAME_API bool	IsTotemCategoryCompatibleWith (uint32 itemTotemCategoryId, uint32 requiredTotemCategoryId)

TC_GAME_API WMOAreaTableEntry const *	GetWMOAreaTableEntryByTripple (int32 rootid, int32 adtid, int32 groupid)

TC_GAME_API uint32	GetVirtualMapForMapAndZone (uint32 mapid, uint32 zoneId)

TC_GAME_API void	Zone2MapCoordinates (float &x, float &y, uint32 worldMapAreaId)

TC_GAME_API void	Map2ZoneCoordinates (float &x, float &y, uint32 worldMapAreaId)

TC_GAME_API void	DeterminaAlternateMapPosition (uint32 mapId, float x, float y, float z, uint32 newMapId=nullptr, DBCPosition2D newPos=nullptr)

TC_GAME_API uint32	GetMaxLevelForExpansion (uint32 expansion)

TC_GAME_API uint32	GetExpansionForLevel (uint32 level)

TC_GAME_API void	LoadDBCStores (const std::string &dataPath, uint32 defaultLocale)

TC_GAME_API void	LoadGameTables (const std::string &dataPath, uint32 defaultLocale)

Variables
TC_GAME_API DBCStorage < AnimKitEntry >	sAnimKitStore

TC_GAME_API DBCStorage < AreaTableEntry >	sAreaTableStore

TC_GAME_API DBCStorage < AreaTriggerEntry >	sAreaTriggerStore

TC_GAME_API DBCStorage < ArmorLocationEntry >	sArmorLocationStore

TC_GAME_API DBCStorage < BankBagSlotPricesEntry >	sBankBagSlotPricesStore

TC_GAME_API DBCStorage < BannedAddOnsEntry >	sBannedAddOnsStore

TC_GAME_API DBCStorage < BattlemasterListEntry >	sBattlemasterListStore

TC_GAME_API DBCStorage < CharSectionsEntry >	sCharSectionsStore

TC_GAME_API DBCStorage < CharTitlesEntry >	sCharTitlesStore

TC_GAME_API DBCStorage < ChatChannelsEntry >	sChatChannelsStore

TC_GAME_API DBCStorage < ChrClassesEntry >	sChrClassesStore

TC_GAME_API DBCStorage < ChrRacesEntry >	sChrRacesStore

TC_GAME_API DBCStorage < ChrSpecializationEntry >	sChrSpecializationStore

TC_GAME_API ChrSpecializationByIndexArray	sChrSpecializationByIndexStore

TC_GAME_API DBCStorage < CreatureDisplayInfoExtraEntry >	sCreatureDisplayInfoExtraStore

TC_GAME_API DBCStorage < CreatureFamilyEntry >	sCreatureFamilyStore

TC_GAME_API DBCStorage < CreatureModelDataEntry >	sCreatureModelDataStore

TC_GAME_API DBCStorage < DifficultyEntry >	sDifficultyStore

TC_GAME_API DBCStorage < DungeonEncounterEntry >	sDungeonEncounterStore

TC_GAME_API DBCStorage < DurabilityCostsEntry >	sDurabilityCostsStore

TC_GAME_API DBCStorage < EmotesEntry >	sEmotesStore

TC_GAME_API DBCStorage < EmotesTextEntry >	sEmotesTextStore

TC_GAME_API DBCStorage < FactionEntry >	sFactionStore

TC_GAME_API DBCStorage < FactionTemplateEntry >	sFactionTemplateStore

TC_GAME_API DBCStorage < GameObjectDisplayInfoEntry >	sGameObjectDisplayInfoStore

TC_GAME_API DBCStorage < GemPropertiesEntry >	sGemPropertiesStore

TC_GAME_API DBCStorage < GlyphPropertiesEntry >	sGlyphPropertiesStore

TC_GAME_API DBCStorage < GuildColorBackgroundEntry >	sGuildColorBackgroundStore

TC_GAME_API DBCStorage < GuildColorBorderEntry >	sGuildColorBorderStore

TC_GAME_API DBCStorage < GuildColorEmblemEntry >	sGuildColorEmblemStore

TC_GAME_API DBCStorage < ItemArmorQualityEntry >	sItemArmorQualityStore

TC_GAME_API DBCStorage < ItemArmorShieldEntry >	sItemArmorShieldStore

TC_GAME_API DBCStorage < ItemArmorTotalEntry >	sItemArmorTotalStore

TC_GAME_API DBCStorage < ItemBagFamilyEntry >	sItemBagFamilyStore

TC_GAME_API DBCStorage < ItemDamageEntry >	sItemDamageAmmoStore

TC_GAME_API DBCStorage < ItemDamageEntry >	sItemDamageOneHandCasterStore

TC_GAME_API DBCStorage < ItemDamageEntry >	sItemDamageOneHandStore

TC_GAME_API DBCStorage < ItemDamageEntry >	sItemDamageRangedStore

TC_GAME_API DBCStorage < ItemDamageEntry >	sItemDamageThrownStore

TC_GAME_API DBCStorage < ItemDamageEntry >	sItemDamageTwoHandCasterStore

TC_GAME_API DBCStorage < ItemDamageEntry >	sItemDamageTwoHandStore

TC_GAME_API DBCStorage < ItemDamageEntry >	sItemDamageWandStore

TC_GAME_API DBCStorage < ItemSetEntry >	sItemSetStore

TC_GAME_API DBCStorage < ItemSetSpellEntry >	sItemSetSpellStore

TC_GAME_API ItemSetSpellsStore	sItemSetSpellsStore

TC_GAME_API DBCStorage < LFGDungeonEntry >	sLFGDungeonStore

TC_GAME_API DBCStorage < LiquidTypeEntry >	sLiquidTypeStore

TC_GAME_API DBCStorage< LockEntry >	sLockStore

TC_GAME_API DBCStorage< MapEntry >	sMapStore

TC_GAME_API MapDifficultyMap	sMapDifficultyMap

TC_GAME_API DBCStorage < MovieEntry >	sMovieStore

TC_GAME_API DBCStorage < PhaseEntry >	sPhaseStore

TC_GAME_API DBCStorage < PowerDisplayEntry >	sPowerDisplayStore

TC_GAME_API DBCStorage < QuestFactionRewEntry >	sQuestFactionRewardStore

TC_GAME_API DBCStorage < RandomPropertiesPointsEntry >	sRandomPropertiesPointsStore

TC_GAME_API DBCStorage < SkillLineAbilityEntry >	sSkillLineAbilityStore

TC_GAME_API DBCStorage < SkillLineEntry >	sSkillLineStore

TC_GAME_API DBCStorage < SkillRaceClassInfoEntry >	sSkillRaceClassInfoStore

TC_GAME_API DBCStorage < SpellAuraOptionsEntry >	sSpellAuraOptionsStore

TC_GAME_API DBCStorage < SpellCategoriesEntry >	sSpellCategoriesStore

TC_GAME_API DBCStorage < SpellCategoryEntry >	sSpellCategoryStore

TC_GAME_API DBCStorage < SpellCooldownsEntry >	sSpellCooldownsStore

TC_GAME_API DBCStorage < SpellEffectEntry >	sSpellEffectStore

TC_GAME_API DBCStorage < SpellEffectScalingEntry >	sSpellEffectScalingStore

TC_GAME_API SpellEffectScallingByEffectId	sSpellEffectScallingByEffectId

TC_GAME_API DBCStorage < SpellEntry >	sSpellStore

TC_GAME_API DBCStorage < SpellEquippedItemsEntry >	sSpellEquippedItemsStore

TC_GAME_API DBCStorage < SpellFocusObjectEntry >	sSpellFocusObjectStore

TC_GAME_API DBCStorage < SpellInterruptsEntry >	sSpellInterruptsStore

TC_GAME_API DBCStorage < SpellItemEnchantmentEntry >	sSpellItemEnchantmentStore

TC_GAME_API DBCStorage < SpellLevelsEntry >	sSpellLevelsStore

TC_GAME_API DBCStorage < SpellScalingEntry >	sSpellScalingStore

TC_GAME_API DBCStorage < SpellShapeshiftEntry >	sSpellShapeshiftStore

TC_GAME_API DBCStorage < SpellShapeshiftFormEntry >	sSpellShapeshiftFormStore

TC_GAME_API DBCStorage < SpellTargetRestrictionsEntry >	sSpellTargetRestrictionsStore

TC_GAME_API DBCStorage < SummonPropertiesEntry >	sSummonPropertiesStore

TC_GAME_API DBCStorage < TalentEntry >	sTalentStore

TC_GAME_API TalentsByPosition	sTalentByPos

TC_GAME_API DBCStorage < VehicleEntry >	sVehicleStore

TC_GAME_API DBCStorage < VehicleSeatEntry >	sVehicleSeatStore

TC_GAME_API DBCStorage < WMOAreaTableEntry >	sWMOAreaTableStore

TC_GAME_API DBCStorage < WorldSafeLocsEntry >	sWorldSafeLocsStore

TC_GAME_API GameTable < GtBarberShopCostBaseEntry >	sGtBarberShopCostBaseStore

TC_GAME_API GameTable < GtChanceToMeleeCritBaseEntry >	sGtChanceToMeleeCritBaseStore

TC_GAME_API GameTable < GtChanceToMeleeCritEntry >	sGtChanceToMeleeCritStore

TC_GAME_API GameTable < GtChanceToSpellCritBaseEntry >	sGtChanceToSpellCritBaseStore

TC_GAME_API GameTable < GtChanceToSpellCritEntry >	sGtChanceToSpellCritStore

TC_GAME_API GameTable < GtCombatRatingsEntry >	sGtCombatRatingsStore

TC_GAME_API GameTable < GtItemSocketCostPerLevelEntry >	sGtItemSocketCostPerLevelStore

TC_GAME_API GameTable < GtNPCManaCostScalerEntry >	sGtNPCManaCostScalerStore

TC_GAME_API GameTable < GtNpcTotalHpEntry >	sGtNpcTotalHpStore

TC_GAME_API GameTable < GtNpcTotalHpExp1Entry >	sGtNpcTotalHpExp1Store

TC_GAME_API GameTable < GtNpcTotalHpExp2Entry >	sGtNpcTotalHpExp2Store

TC_GAME_API GameTable < GtNpcTotalHpExp3Entry >	sGtNpcTotalHpExp3Store

TC_GAME_API GameTable < GtNpcTotalHpExp4Entry >	sGtNpcTotalHpExp4Store

TC_GAME_API GameTable < GtNpcTotalHpExp5Entry >	sGtNpcTotalHpExp5Store

TC_GAME_API GameTable < GtOCTBaseHPByClassEntry >	sGtOCTBaseHPByClassStore

TC_GAME_API GameTable < GtOCTBaseMPByClassEntry >	sGtOCTBaseMPByClassStore

TC_GAME_API GameTable < GtOCTLevelExperienceEntry >	sGtOCTLevelExperienceStore

TC_GAME_API GameTable < GtRegenMPPerSptEntry >	sGtRegenMPPerSptStore

TC_GAME_API GameTable < GtSpellScalingEntry >	sGtSpellScalingStore

TC_GAME_API GameTable < GtOCTHpPerStaminaEntry >	sGtOCTHpPerStaminaStore

Typedef Documentation

typedef ChrSpecializationEntry const* ChrSpecializationByIndexArray[MAX_CLASSES][MAX_SPECIALIZATIONS]

typedef std::vector<ItemSetSpellEntry const*> ItemSetSpells

typedef std::unordered_map<uint32, ItemSetSpells> ItemSetSpellsStore

typedef std::unordered_map<uint32, std::unordered_map<uint32, MapDifficultyEntry const*> > MapDifficultyMap

typedef std::pair<SkillRaceClassInfoMap::iterator, SkillRaceClassInfoMap::iterator> SkillRaceClassInfoBounds

typedef std::unordered_multimap<uint32, SkillRaceClassInfoEntry const*> SkillRaceClassInfoMap

typedef std::unordered_map<uint32, uint32> SpellEffectScallingByEffectId

typedef std::vector<TalentEntry const*> TalentsByPosition[MAX_CLASSES][MAX_TALENT_TIERS][MAX_TALENT_COLUMNS]

Function Documentation

TC_GAME_API void DeterminaAlternateMapPosition	(	uint32	mapId,
		float	x,
		float	y,
		float	z,
		uint32 *	newMapId = `nullptr`,
		DBCPosition2D *	newPos = `nullptr`
	)

 {
  ASSERT(newMapId || newPos);
  WorldMapTransformsEntry const* transformation = nullptr;
  for (WorldMapTransformsEntry const* transform : sWorldMapTransformsStore)
  {
  if (transform->MapID != mapId)
  continue;
 
  if (transform->RegionMin.X > x || transform->RegionMax.X < x)
  continue;
  if (transform->RegionMin.Y > y || transform->RegionMax.Y < y)
  continue;
  if (transform->RegionMin.Z > z || transform->RegionMax.Z < z)
  continue;
 
  transformation = transform;
  break;
  }
 
  if (!transformation)
  {
  if (newMapId)
  *newMapId = mapId;
 
  if (newPos)
  {
  newPos->X = x;
  newPos->Y = y;
  }
  return;
  }
 
  if (newMapId)
  *newMapId = transformation->NewMapID;
 
  if (!newPos)
  return;
 
  if (transformation->RegionScale > 0.0f && transformation->RegionScale < 1.0f)
  {
  x = (x - transformation->RegionMin.X) * transformation->RegionScale + transformation->RegionMin.X;
  y = (y - transformation->RegionMin.Y) * transformation->RegionScale + transformation->RegionMin.Y;
  }
 
  newPos->X = x + transformation->RegionOffset.X;
  newPos->Y = y + transformation->RegionOffset.Y;
 }

Here is the caller graph for this function:

TC_GAME_API EmotesTextSoundEntry const* FindTextSoundEmoteFor	(	uint32	emote,
		uint32	race,
		uint32	gender
	)

 {
  auto itr = sEmotesTextSoundMap.find(EmotesTextSoundKey(emote, race, gender));
  return itr != sEmotesTextSoundMap.end() ? itr->second : nullptr;
 }

Here is the caller graph for this function:

TC_GAME_API PvPDifficultyEntry const* GetBattlegroundBracketById	(	uint32	mapid,
		BattlegroundBracketId	id
	)

 {
  for (uint32 i = 0; i < sPvpDifficultyStore.GetNumRows(); ++i)
  if (PvPDifficultyEntry const* entry = sPvpDifficultyStore.LookupEntry(i))
  if (entry->MapID == mapid && entry->GetBracketId() == id)
  return entry;
 
  return NULL;
 }

Here is the caller graph for this function:

TC_GAME_API PvPDifficultyEntry const* GetBattlegroundBracketByLevel	(	uint32	mapid,
		uint32	level
	)

 {
  PvPDifficultyEntry const* maxEntry = NULL; // used for level > max listed level case
  for (uint32 i = 0; i < sPvpDifficultyStore.GetNumRows(); ++i)
  {
  if (PvPDifficultyEntry const* entry = sPvpDifficultyStore.LookupEntry(i))
  {
  // skip unrelated and too-high brackets
  if (entry->MapID != mapid || entry->MinLevel > level)
  continue;
 
  // exactly fit
  if (entry->MaxLevel >= level)
  return entry;
 
  // remember for possible out-of-range case (search higher from existed)
  if (!maxEntry || maxEntry->MaxLevel < entry->MaxLevel)
  maxEntry = entry;
  }
  }
 
  return maxEntry;
 }

Here is the caller graph for this function:

TC_GAME_API CharSectionsEntry const* GetCharSectionEntry	(	uint8	race,
		CharSectionType	genType,
		uint8	gender,
		uint8	type,
		uint8	color
	)

 {
  std::pair<CharSectionsMap::const_iterator, CharSectionsMap::const_iterator> eqr = sCharSectionMap.equal_range(uint32(genType) | uint32(gender << 8) | uint32(race << 16));
  for (CharSectionsMap::const_iterator itr = eqr.first; itr != eqr.second; ++itr)
  {
  if (itr->second->Type == type && itr->second->Color == color)
  return itr->second;
  }
 
  return NULL;
 }

TC_GAME_API char const* GetClassName	(	uint8	class_,
		uint8	locale
	)

 {
  ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(class_);
  return classEntry ? classEntry->Name_lang : NULL;
 }

Here is the caller graph for this function:

TC_GAME_API char const* GetCreatureFamilyPetName	(	uint32	petfamily,
		uint32	locale
	)

 {
  if (!petfamily)
  return nullptr;
 
  CreatureFamilyEntry const* pet_family = sCreatureFamilyStore.LookupEntry(petfamily);
  if (!pet_family)
  return nullptr;
 
  return pet_family->Name_lang ? pet_family->Name_lang : NULL;
 }

Here is the caller graph for this function:

TC_GAME_API MapDifficultyEntry const* GetDefaultMapDifficulty	(	uint32	mapId,
		Difficulty *	difficulty = `nullptr`
	)

 {
  auto itr = sMapDifficultyMap.find(mapId);
  if (itr == sMapDifficultyMap.end())
  return nullptr;
 
  if (itr->second.empty())
  return nullptr;
 
  for (auto& p : itr->second)
  {
  DifficultyEntry const* difficultyEntry = sDifficultyStore.LookupEntry(p.first);
  if (!difficultyEntry)
  continue;
 
  if (difficultyEntry->Flags & DIFFICULTY_FLAG_DEFAULT)
  {
  if (difficulty)
  *difficulty = Difficulty(p.first);
 
  return p.second;
  }
  }
 
  if (difficulty)
  *difficulty = Difficulty(itr->second.begin()->first);
 
  return itr->second.begin()->second;
 }

Here is the caller graph for this function:

TC_GAME_API uint32 GetDefaultMapLight ( uint32 mapId )

 {
  for (int32 i = sLightStore.GetNumRows(); i >= 0; --i)
  {
  LightEntry const* light = sLightStore.LookupEntry(uint32(i));
  if (!light)
  continue;
 
  if (light->MapID == mapId && light->Pos.X == 0.0f && light->Pos.Y == 0.0f && light->Pos.Z == 0.0f)
  return light->ID;
  }
 
  return 0;
 }

TC_GAME_API MapDifficultyEntry const* GetDownscaledMapDifficultyData	(	uint32	mapId,
		Difficulty &	difficulty
	)

 {
  DifficultyEntry const* diffEntry = sDifficultyStore.LookupEntry(difficulty);
  if (!diffEntry)
  return GetDefaultMapDifficulty(mapId, &difficulty);
 
  uint32 tmpDiff = difficulty;
  MapDifficultyEntry const* mapDiff = GetMapDifficultyData(mapId, Difficulty(tmpDiff));
  while (!mapDiff)
  {
  tmpDiff = diffEntry->FallbackDifficultyID;
  diffEntry = sDifficultyStore.LookupEntry(tmpDiff);
  if (!diffEntry)
  return GetDefaultMapDifficulty(mapId, &difficulty);
 
  // pull new data
  mapDiff = GetMapDifficultyData(mapId, Difficulty(tmpDiff)); // we are 10 normal or 25 normal
  }
 
  difficulty = Difficulty(tmpDiff);
  return mapDiff;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

TC_GAME_API uint32 GetExpansionForLevel ( uint32 level )

 {
  if (level < 60)
  return EXPANSION_CLASSIC;
  else if (level < 70)
  return EXPANSION_THE_BURNING_CRUSADE;
  else if (level < 80)
  return EXPANSION_WRATH_OF_THE_LICH_KING;
  else if (level < 85)
  return EXPANSION_CATACLYSM;
  else if (level < 90)
  return EXPANSION_MISTS_OF_PANDARIA;
  else
  return CURRENT_EXPANSION;
 }

Here is the caller graph for this function:

TC_GAME_API std::vector<uint32> const* GetFactionTeamList ( uint32 faction )

 {
  FactionTeamMap::const_iterator itr = sFactionTeamMap.find(faction);
  if (itr != sFactionTeamMap.end())
  return &itr->second;
 
  return NULL;
 }

Here is the caller graph for this function:

TC_GAME_API LFGDungeonEntry const* GetLFGDungeon	(	uint32	mapId,
		Difficulty	difficulty
	)

Returns LFGDungeonEntry for a specific map and difficulty. Will return first found entry if multiple dungeons use the same map (such as Scarlet Monastery)

 {
  for (uint32 i = 0; i < sLFGDungeonStore.GetNumRows(); ++i)
  {
  LFGDungeonEntry const* dungeon = sLFGDungeonStore.LookupEntry(i);
  if (!dungeon)
  continue;
 
  if (dungeon->MapID == int32(mapId) && Difficulty(dungeon->DifficultyID) == difficulty)
  return dungeon;
  }
 
  return NULL;
 }

Here is the caller graph for this function:

TC_GAME_API uint32 GetLiquidFlags ( uint32 liquidType )

 {
  if (LiquidTypeEntry const* liq = sLiquidTypeStore.LookupEntry(liquidType))
  return 1 << liq->Type;
 
  return 0;
 }

Here is the caller graph for this function:

TC_GAME_API MapDifficultyEntry const* GetMapDifficultyData	(	uint32	mapId,
		Difficulty	difficulty
	)

 {
  auto itr = sMapDifficultyMap.find(mapId);
  if (itr == sMapDifficultyMap.end())
  return nullptr;
 
  auto diffItr = itr->second.find(difficulty);
  if (diffItr == itr->second.end())
  return nullptr;
 
  return diffItr->second;
 }

Here is the caller graph for this function:

TC_GAME_API uint32 GetMaxLevelForExpansion ( uint32 expansion )

 {
  switch (expansion)
  {
  case EXPANSION_CLASSIC:
  return 60;
  case EXPANSION_THE_BURNING_CRUSADE:
  return 70;
  case EXPANSION_WRATH_OF_THE_LICH_KING:
  return 80;
  case EXPANSION_CATACLYSM:
  return 85;
  case EXPANSION_MISTS_OF_PANDARIA:
  return 90;
  case EXPANSION_WARLORDS_OF_DRAENOR:
  return 100;
  default:
  break;
  }
  return 0;
 }

Here is the caller graph for this function:

TC_GAME_API char const* GetRaceName	(	uint8	race,
		uint8	locale
	)

 {
  ChrRacesEntry const* raceEntry = sChrRacesStore.LookupEntry(race);
  return raceEntry ? raceEntry->Name_lang : NULL;
 }

Here is the caller graph for this function:

TC_GAME_API SkillRaceClassInfoEntry const* GetSkillRaceClassInfo	(	uint32	skill,
		uint8	race,
		uint8	class_
	)

 {
  SkillRaceClassInfoBounds bounds = SkillRaceClassInfoBySkill.equal_range(skill);
  for (SkillRaceClassInfoMap::iterator itr = bounds.first; itr != bounds.second; ++itr)
  {
  if (itr->second->RaceMask && !(itr->second->RaceMask & (1 << (race - 1))))
  continue;
  if (itr->second->ClassMask && !(itr->second->ClassMask & (1 << (class_ - 1))))
  continue;
 
  return itr->second;
  }
 
  return NULL;
 }

Here is the caller graph for this function:

TC_GAME_API uint32 GetVirtualMapForMapAndZone	(	uint32	mapid,
		uint32	zoneId
	)

 {
  if (mapid != 530 && mapid != 571 && mapid != 732) // speed for most cases
  return mapid;
 
  if (WorldMapAreaEntry const* wma = sWorldMapAreaStore.LookupEntry(zoneId))
  return wma->DisplayMapID >= 0 ? wma->DisplayMapID : wma->MapID;
 
  return mapid;
 }

Here is the caller graph for this function:

TC_GAME_API WMOAreaTableEntry const* GetWMOAreaTableEntryByTripple	(	int32	rootid,
		int32	adtid,
		int32	groupid
	)

 {
  WMOAreaInfoByTripple::iterator i = sWMOAreaInfoByTripple.find(WMOAreaTableTripple(rootid, adtid, groupid));
  if (i == sWMOAreaInfoByTripple.end())
  return NULL;
  return i->second;
 }

Here is the caller graph for this function:

TC_GAME_API bool IsTotemCategoryCompatibleWith	(	uint32	itemTotemCategoryId,
		uint32	requiredTotemCategoryId
	)

 {
  if (requiredTotemCategoryId == 0)
  return true;
  if (itemTotemCategoryId == 0)
  return false;
 
  TotemCategoryEntry const* itemEntry = sTotemCategoryStore.LookupEntry(itemTotemCategoryId);
  if (!itemEntry)
  return false;
  TotemCategoryEntry const* reqEntry = sTotemCategoryStore.LookupEntry(requiredTotemCategoryId);
  if (!reqEntry)
  return false;
 
  if (itemEntry->CategoryType != reqEntry->CategoryType)
  return false;
 
  return (itemEntry->CategoryMask & reqEntry->CategoryMask) == reqEntry->CategoryMask;
 }

TC_GAME_API void LoadDBCStores	(	const std::string &	dataPath,
		uint32	defaultLocale
	)

 {
  uint32 oldMSTime = getMSTime();
 
  std::string dbcPath = dataPath + "dbc/";
 
  StoreProblemList bad_dbc_files;
  uint32 availableDbcLocales = 0xFFFFFFFF;
 
 #define LOAD_DBC(store, file) LoadDBC(availableDbcLocales, bad_dbc_files, store, dbcPath, file, defaultLocale)
 
  LOAD_DBC(sAnimKitStore, "AnimKit.dbc");//20444
  LOAD_DBC(sAreaTableStore, "AreaTable.dbc");//20444
  LOAD_DBC(sAreaTriggerStore, "AreaTrigger.dbc");//20444
  LOAD_DBC(sArmorLocationStore, "ArmorLocation.dbc");//20444
  LOAD_DBC(sBankBagSlotPricesStore, "BankBagSlotPrices.dbc");//20444
  LOAD_DBC(sBannedAddOnsStore, "BannedAddOns.dbc");//20444
  LOAD_DBC(sBattlemasterListStore, "BattlemasterList.dbc");//20444
  LOAD_DBC(sCharSectionsStore, "CharSections.dbc");//20444
  LOAD_DBC(sCharTitlesStore, "CharTitles.dbc");//20444
  LOAD_DBC(sChatChannelsStore, "ChatChannels.dbc");//20444
  LOAD_DBC(sChrClassesStore, "ChrClasses.dbc");//20444
  LOAD_DBC(sChrRacesStore, "ChrRaces.dbc");//20444
  LOAD_DBC(sChrSpecializationStore, "ChrSpecialization.dbc");//20444
  LOAD_DBC(sCreatureDisplayInfoExtraStore, "CreatureDisplayInfoExtra.dbc");//20444
  LOAD_DBC(sCreatureFamilyStore, "CreatureFamily.dbc");//20444
  LOAD_DBC(sCreatureModelDataStore, "CreatureModelData.dbc");//20444
  LOAD_DBC(sDifficultyStore, "Difficulty.dbc");//20444
  LOAD_DBC(sDungeonEncounterStore, "DungeonEncounter.dbc");//20444
  LOAD_DBC(sDurabilityCostsStore, "DurabilityCosts.dbc");//20444
  LOAD_DBC(sEmotesStore, "Emotes.dbc");//20444
  LOAD_DBC(sEmotesTextStore, "EmotesText.dbc");//20444
  LOAD_DBC(sEmotesTextSoundStore, "EmotesTextSound.dbc");
  LOAD_DBC(sFactionStore, "Faction.dbc");//20444
  LOAD_DBC(sFactionTemplateStore, "FactionTemplate.dbc");//20444
  LOAD_DBC(sGameObjectDisplayInfoStore, "GameObjectDisplayInfo.dbc");//20444
  LOAD_DBC(sGemPropertiesStore, "GemProperties.dbc");//20444
  LOAD_DBC(sGlyphPropertiesStore, "GlyphProperties.dbc");//20444
  LOAD_DBC(sGuildColorBackgroundStore, "GuildColorBackground.dbc");//20444
  LOAD_DBC(sGuildColorBorderStore, "GuildColorBorder.dbc"); //20444
  LOAD_DBC(sGuildColorEmblemStore, "GuildColorEmblem.dbc");//20444
  LOAD_DBC(sItemArmorQualityStore, "ItemArmorQuality.dbc");//20444
  LOAD_DBC(sItemArmorShieldStore, "ItemArmorShield.dbc");//20444
  LOAD_DBC(sItemArmorTotalStore, "ItemArmorTotal.dbc");//20444
  LOAD_DBC(sItemBagFamilyStore, "ItemBagFamily.dbc");//20444
  LOAD_DBC(sItemDamageAmmoStore, "ItemDamageAmmo.dbc");//20444
  LOAD_DBC(sItemDamageOneHandCasterStore, "ItemDamageOneHandCaster.dbc");//20444
  LOAD_DBC(sItemDamageOneHandStore, "ItemDamageOneHand.dbc");//20444
  LOAD_DBC(sItemDamageRangedStore, "ItemDamageRanged.dbc");//20444
  LOAD_DBC(sItemDamageThrownStore, "ItemDamageThrown.dbc");//20444
  LOAD_DBC(sItemDamageTwoHandCasterStore, "ItemDamageTwoHandCaster.dbc");//20444
  LOAD_DBC(sItemDamageTwoHandStore, "ItemDamageTwoHand.dbc");//20444
  LOAD_DBC(sItemDamageWandStore, "ItemDamageWand.dbc");//20444
  LOAD_DBC(sItemSetSpellStore, "ItemSetSpell.dbc");//20444
  LOAD_DBC(sItemSetStore, "ItemSet.dbc");//20444
  LOAD_DBC(sLFGDungeonStore, "LfgDungeons.dbc");//20444
  LOAD_DBC(sLightStore, "Light.dbc"); //20444
  LOAD_DBC(sLiquidTypeStore, "LiquidType.dbc");//20444
  LOAD_DBC(sLockStore, "Lock.dbc");//20444
  LOAD_DBC(sMapDifficultyStore, "MapDifficulty.dbc");//20444
  LOAD_DBC(sMapStore, "Map.dbc");//20444
  LOAD_DBC(sMovieStore, "Movie.dbc");//20444
  LOAD_DBC(sPhaseStore, "Phase.dbc"); // 20444
  LOAD_DBC(sPowerDisplayStore, "PowerDisplay.dbc");//20444
  LOAD_DBC(sPvpDifficultyStore, "PvpDifficulty.dbc");//20444
  LOAD_DBC(sQuestFactionRewardStore, "QuestFactionReward.dbc");//20444
  LOAD_DBC(sRandomPropertiesPointsStore, "RandPropPoints.dbc");//20444
  LOAD_DBC(sSkillLineAbilityStore, "SkillLineAbility.dbc");//20444
  LOAD_DBC(sSkillLineStore, "SkillLine.dbc");//20444
  LOAD_DBC(sSkillRaceClassInfoStore, "SkillRaceClassInfo.dbc");//20444
  LOAD_DBC(sSpellAuraOptionsStore, "SpellAuraOptions.dbc");//20444
  LOAD_DBC(sSpellCategoriesStore, "SpellCategories.dbc");//20444
  LOAD_DBC(sSpellCategoryStore, "SpellCategory.dbc");//20444
  LOAD_DBC(sSpellCooldownsStore, "SpellCooldowns.dbc");//20444
  LOAD_DBC(sSpellEffectScalingStore, "SpellEffectScaling.dbc");//20444
  LOAD_DBC(sSpellEffectStore, "SpellEffect.dbc"/*, &CustomSpellEffectfmt, &CustomSpellEffectEntryIndex*/);//20444
  LOAD_DBC(sSpellEquippedItemsStore, "SpellEquippedItems.dbc");//20444
  LOAD_DBC(sSpellFocusObjectStore, "SpellFocusObject.dbc");//20444
  LOAD_DBC(sSpellInterruptsStore, "SpellInterrupts.dbc");//20444
  LOAD_DBC(sSpellItemEnchantmentStore, "SpellItemEnchantment.dbc");//20444
  LOAD_DBC(sSpellLevelsStore, "SpellLevels.dbc");//20444
  LOAD_DBC(sSpellScalingStore, "SpellScaling.dbc");//20444
  LOAD_DBC(sSpellShapeshiftFormStore, "SpellShapeshiftForm.dbc");//20444
  LOAD_DBC(sSpellShapeshiftStore, "SpellShapeshift.dbc");//20444
  LOAD_DBC(sSpellStore, "Spell.dbc"/*, &CustomSpellfmt, &CustomSpellEntryIndex*/);//20444
  LOAD_DBC(sSpellTargetRestrictionsStore, "SpellTargetRestrictions.dbc");//20444
  LOAD_DBC(sSummonPropertiesStore, "SummonProperties.dbc");//20444
  LOAD_DBC(sTalentStore, "Talent.dbc");//20444
  LOAD_DBC(sVehicleSeatStore, "VehicleSeat.dbc");//20444
  LOAD_DBC(sVehicleStore, "Vehicle.dbc");//20444
  LOAD_DBC(sWMOAreaTableStore, "WMOAreaTable.dbc");//20444
  LOAD_DBC(sWorldMapAreaStore, "WorldMapArea.dbc");//20444
  LOAD_DBC(sWorldMapTransformsStore, "WorldMapTransforms.dbc");//20444
  LOAD_DBC(sWorldSafeLocsStore, "WorldSafeLocs.dbc"); // 20444
 
 #undef LOAD_DBC
 
  for (uint32 i = 0; i < sCharSectionsStore.GetNumRows(); ++i)
  if (CharSectionsEntry const* entry = sCharSectionsStore.LookupEntry(i))
  if (entry->Race && ((1 << (entry->Race - 1)) & RACEMASK_ALL_PLAYABLE) != 0) //ignore Nonplayable races
  sCharSectionMap.insert({ entry->GenType | (entry->Gender << 8) | (entry->Race << 16), entry });
 
  memset(sChrSpecializationByIndexStore, 0, sizeof(sChrSpecializationByIndexStore));
  for (uint32 i = 0; i < sChrSpecializationStore.GetNumRows(); ++i)
  if (ChrSpecializationEntry const* chrSpec = sChrSpecializationStore.LookupEntry(i))
  sChrSpecializationByIndexStore[chrSpec->ClassID][chrSpec->OrderIndex] = chrSpec;
 
  ASSERT(MAX_DIFFICULTY >= sDifficultyStore.GetNumRows(),
  "MAX_DIFFICULTY is not large enough to contain all difficulties! (current value %d, required %d)",
  MAX_DIFFICULTY, sDifficultyStore.GetNumRows());
 
  for (uint32 i = 0; i < sEmotesTextSoundStore.GetNumRows(); ++i)
  if (EmotesTextSoundEntry const* entry = sEmotesTextSoundStore.LookupEntry(i))
  sEmotesTextSoundMap[EmotesTextSoundKey(entry->EmotesTextId, entry->RaceId, entry->SexId)] = entry;
 
  for (uint32 i = 0; i < sFactionStore.GetNumRows(); ++i)
  {
  FactionEntry const* faction = sFactionStore.LookupEntry(i);
  if (faction && faction->ParentFactionID)
  {
  std::vector<uint32> &flist = sFactionTeamMap[faction->ParentFactionID];
  flist.push_back(i);
  }
  }
 
  for (uint32 i = 0; i < sGameObjectDisplayInfoStore.GetNumRows(); ++i)
  {
  if (GameObjectDisplayInfoEntry const* info = sGameObjectDisplayInfoStore.LookupEntry(i))
  {
  if (info->GeoBoxMax.X < info->GeoBoxMin.X)
  std::swap(*(float*)(&info->GeoBoxMax.X), *(float*)(&info->GeoBoxMin.X));
  if (info->GeoBoxMax.Y < info->GeoBoxMin.Y)
  std::swap(*(float*)(&info->GeoBoxMax.Y), *(float*)(&info->GeoBoxMin.Y));
  if (info->GeoBoxMax.Z < info->GeoBoxMin.Z)
  std::swap(*(float*)(&info->GeoBoxMax.Z), *(float*)(&info->GeoBoxMin.Z));
  }
  }
 
  for (ItemSetSpellEntry const* entry : sItemSetSpellStore)
  sItemSetSpellsStore[entry->ItemSetID].push_back(entry);
 
  // fill data
  for (uint32 i = 0; i < sMapDifficultyStore.GetNumRows(); ++i)
  if (MapDifficultyEntry const* entry = sMapDifficultyStore.LookupEntry(i))
  sMapDifficultyMap[entry->MapID][entry->DifficultyID] = entry;
  sMapDifficultyMap[0][0] = sMapDifficultyMap[1][0]; //map 0 is missing from MapDifficulty.dbc use this till its ported to sql
 
  for (uint32 i = 0; i < sPvpDifficultyStore.GetNumRows(); ++i)
  if (PvPDifficultyEntry const* entry = sPvpDifficultyStore.LookupEntry(i))
  if (entry->BracketID > MAX_BATTLEGROUND_BRACKETS)
  ASSERT(false && "Need update MAX_BATTLEGROUND_BRACKETS by DBC data");
 
  for (uint32 i = 0; i < sSkillRaceClassInfoStore.GetNumRows(); ++i)
  if (SkillRaceClassInfoEntry const* entry = sSkillRaceClassInfoStore.LookupEntry(i))
  if (sSkillLineStore.LookupEntry(entry->SkillID))
  SkillRaceClassInfoBySkill.emplace(entry->SkillID, entry);
 
  for (uint32 j = 0; j < sSpellEffectScalingStore.GetNumRows(); j++)
  {
  SpellEffectScalingEntry const* spellEffectScaling = sSpellEffectScalingStore.LookupEntry(j);
  if (!spellEffectScaling)
  continue;
 
  sSpellEffectScallingByEffectId.insert(std::make_pair(spellEffectScaling->SpellEffectID, j));
  }
 
  for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
  {
  if (TalentEntry const* talentInfo = sTalentStore.LookupEntry(i))
  {
  if (talentInfo->ClassID < MAX_CLASSES && talentInfo->TierID < MAX_TALENT_TIERS && talentInfo->ColumnIndex < MAX_TALENT_COLUMNS)
  sTalentByPos[talentInfo->ClassID][talentInfo->TierID][talentInfo->ColumnIndex].push_back(talentInfo);
  else
  TC_LOG_ERROR("server.loading", "Value of class (found: %u, max allowed %u) or (found: %u, max allowed %u) tier or column (found: %u, max allowed %u) is invalid.",
  talentInfo->ClassID, MAX_CLASSES, talentInfo->TierID, MAX_TALENT_TIERS, talentInfo->ColumnIndex, MAX_TALENT_COLUMNS);
  }
  }
 
  for (uint32 i = 0; i < sWMOAreaTableStore.GetNumRows(); ++i)
  if (WMOAreaTableEntry const* entry = sWMOAreaTableStore.LookupEntry(i))
  sWMOAreaInfoByTripple.insert(WMOAreaInfoByTripple::value_type(WMOAreaTableTripple(entry->WMOID, entry->NameSet, entry->WMOGroupID), entry));
 
  // error checks
  if (bad_dbc_files.size() >= DBCFileCount)
  {
  TC_LOG_ERROR("misc", "Incorrect DataDir value in worldserver.conf or ALL required *.dbc files (%d) not found by path: %sdbc/%s/", DBCFileCount, dataPath.c_str(), localeNames[defaultLocale]);
  exit(1);
  }
  else if (!bad_dbc_files.empty())
  {
  std::string str;
  for (StoreProblemList::iterator i = bad_dbc_files.begin(); i != bad_dbc_files.end(); ++i)
  str += *i + "\n";
 
  TC_LOG_ERROR("misc", "Some required *.dbc files (%u from %d) not found or not compatible:\n%s", (uint32)bad_dbc_files.size(), DBCFileCount, str.c_str());
  exit(1);
  }
 
  // Check loaded DBC files proper version
  if (!sAreaTableStore.LookupEntry(7941) || // last area added in 6.2.2 (20444)
  !sCharTitlesStore.LookupEntry(457) || // last char title added in 6.2.2 (20444)
  !sGemPropertiesStore.LookupEntry(2544) || // last gem property added in 6.2.2 (20444)
  !sMapStore.LookupEntry(1497) || // last map added in 6.2.2 (20444)
  !sSpellStore.LookupEntry(197204)       )      // last spell added in 6.2.2 (20444)
     {
         TC_LOG_ERROR("misc", "You have _outdated_ DBC files. Please extract correct versions from current using client.");
         exit(1);
     }
 
     TC_LOG_INFO("server.loading", ">> Initialized %d DBC data stores in %u ms", DBCFileCount, GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

TC_GAME_API void LoadGameTables	(	const std::string &	dataPath,
		uint32	defaultLocale
	)

 {
     uint32 oldMSTime = getMSTime();
 
     std::string dbcPath = dataPath + "dbc/" + localeNames[defaultLocale] + '/';
 
     StoreProblemList bad_dbc_files;
 
 #define LOAD_GT(tableName, store, file) LoadGameTable(bad_dbc_files, tableName, store, dbcPath, file)
 
     LOAD_GT("BarberShopCostBase", sGtBarberShopCostBaseStore, "gtBarberShopCostBase.dbc");                      // 20444
     LOAD_GT("CombatRatings", sGtCombatRatingsStore, "gtCombatRatings.dbc");                                     // 20444
     LOAD_GT("ChanceToMeleeCritBase", sGtChanceToMeleeCritBaseStore, "gtChanceToMeleeCritBase.dbc");             // 20444
     LOAD_GT("ChanceToMeleeCrit", sGtChanceToMeleeCritStore, "gtChanceToMeleeCrit.dbc");                         // 20444
     LOAD_GT("ChanceToSpellCritBase", sGtChanceToSpellCritBaseStore, "gtChanceToSpellCritBase.dbc");             // 20444
     LOAD_GT("ChanceToSpellCrit", sGtChanceToSpellCritStore, "gtChanceToSpellCrit.dbc");                         // 20444
     LOAD_GT("ItemSocketCostPerLevel", sGtItemSocketCostPerLevelStore, "gtItemSocketCostPerLevel.dbc");          // 20444
     LOAD_GT("NPCManaCostScaler", sGtNPCManaCostScalerStore, "gtNPCManaCostScaler.dbc");                         // 20444
     LOAD_GT("NpcTotalHp", sGtNpcTotalHpStore, "gtNpcTotalHp.dbc");                                              // 20444
     LOAD_GT("NpcTotalHpExp1", sGtNpcTotalHpExp1Store, "gtNpcTotalHpExp1.dbc");                                  // 20444
     LOAD_GT("NpcTotalHpExp2", sGtNpcTotalHpExp2Store, "gtNpcTotalHpExp2.dbc");                                  // 20444
     LOAD_GT("NpcTotalHpExp3", sGtNpcTotalHpExp3Store, "gtNpcTotalHpExp3.dbc");                                  // 20444
     LOAD_GT("NpcTotalHpExp4", sGtNpcTotalHpExp4Store, "gtNpcTotalHpExp4.dbc");                                  // 20444
     LOAD_GT("NpcTotalHpExp5", sGtNpcTotalHpExp5Store, "gtNpcTotalHpExp5.dbc");                                  // 20444
     LOAD_GT("OCTHPPerStamina", sGtOCTHpPerStaminaStore, "gtOCTHpPerStamina.dbc");                               // 20444
     LOAD_GT("OCTLevelExperience", sGtOCTLevelExperienceStore, "gtOCTLevelExperience.dbc");                      // 20444
     LOAD_GT("RegenMPPerSpt", sGtRegenMPPerSptStore, "gtRegenMPPerSpt.dbc");                                     // 20444
     LOAD_GT("SpellScaling", sGtSpellScalingStore, "gtSpellScaling.dbc");                                        // 20444
     LOAD_GT("OCTBaseHPByClass", sGtOCTBaseHPByClassStore, "gtOCTBaseHPByClass.dbc");                            // 20444
     LOAD_GT("OCTBaseMPByClass", sGtOCTBaseMPByClassStore, "gtOCTBaseMPByClass.dbc");                            // 20444
 
 #undef LOAD_GT
 
     // error checks
     if (bad_dbc_files.size() >= GameTableCount)
     {
         TC_LOG_ERROR("misc", "Incorrect DataDir value in worldserver.conf or ALL required *.dbc GameTable files (%d) not found by path: %sdbc/%s/", DBCFileCount, dataPath.c_str(), localeNames[defaultLocale]);
         exit(1);
     }
     else if (!bad_dbc_files.empty())
     {
         std::string str;
         for (StoreProblemList::iterator i = bad_dbc_files.begin(); i != bad_dbc_files.end(); ++i)
             str += *i + "\n";
 
         TC_LOG_ERROR("misc", "Some required *.dbc GameTable files (%u from %d) not found or not compatible:\n%s", (uint32)bad_dbc_files.size(), GameTableCount, str.c_str());
         exit(1);
     }
 
     TC_LOG_INFO("server.loading", ">> Initialized %d DBC GameTables data stores in %u ms", GameTableCount, GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

TC_GAME_API void Map2ZoneCoordinates	(	float &	x,
		float &	y,
		uint32	worldMapAreaId
	)

 {
     WorldMapAreaEntry const* maEntry = sWorldMapAreaStore.LookupEntry(worldMapAreaId);
 
     // if not listed then map coordinates (instance)
     if (!maEntry)
         return;
 
     x = (x - maEntry->LocTop) / ((maEntry->LocBottom - maEntry->LocTop) / 100);
     y = (y - maEntry->LocLeft) / ((maEntry->LocRight - maEntry->LocLeft) / 100);    // client y coord from top to down
     std::swap(x, y);                                         // client have map coords swapped
 }

Here is the caller graph for this function:

TC_GAME_API void Zone2MapCoordinates	(	float &	x,
		float &	y,
		uint32	worldMapAreaId
	)

 {
     WorldMapAreaEntry const* maEntry = sWorldMapAreaStore.LookupEntry(worldMapAreaId);
 
     // if not listed then map coordinates (instance)
     if (!maEntry)
         return;
 
     std::swap(x, y);                                         // at client map coords swapped
     x = x*((maEntry->LocBottom-maEntry->LocTop)/100)+maEntry->LocTop;
     y = y*((maEntry->LocRight-maEntry->LocLeft)/100)+maEntry->LocLeft;      // client y coord from top to down
 }