DB2Manager Class Reference

#include <DB2Stores.h>

Public Types
typedef std::map< uint32, DB2StorageBase * >	StorageMap
typedef std::unordered_map < uint32, std::vector< uint32 > >	AreaGroupMemberContainer
typedef std::unordered_map < uint32, CharStartOutfitEntry const * >	CharStartOutfitContainer
typedef std::set < GlyphSlotEntry const *, GlyphSlotEntryComparator >	GlyphSlotContainer
typedef std::map< uint32, std::map< uint32, CurvePointEntry const *, std::greater< uint32 > > >	HeirloomCurvesContainer
typedef std::unordered_map < uint32, HeirloomEntry const * >	HeirloomItemsContainer
typedef std::vector < ItemBonusEntry const * >	ItemBonusList
typedef std::unordered_map < uint32, ItemBonusList >	ItemBonusListContainer
typedef std::unordered_multimap < uint32, uint32 >	ItemToBonusTreeContainer
typedef std::unordered_map < uint32, uint32 >	ItemDisplayIdContainer
typedef std::unordered_map < uint32, std::set < ItemBonusTreeNodeEntry const * > >	ItemBonusTreeContainer
typedef std::unordered_map < uint32, std::vector < ItemSpecOverrideEntry const * > >	ItemSpecOverridesContainer
typedef std::unordered_map < uint32, MountEntry const * >	MountContainer
typedef std::set < MountTypeXCapabilityEntry const *, MountTypeXCapabilityEntryComparator >	MountTypeXCapabilitySet
typedef std::unordered_map < uint32, MountTypeXCapabilitySet >	MountCapabilitiesByTypeContainer
typedef std::unordered_map < uint32, std::array < std::vector< NameGenEntry const * >, 2 > >	NameGenContainer
typedef std::array < std::vector< boost::regex > , TOTAL_LOCALES+1 >	NameValidationRegexContainer
typedef std::unordered_map < uint32, std::set< uint32 > >	PhaseGroupContainer
typedef std::unordered_map < uint32, std::vector < QuestPackageItemEntry const * > >	QuestPackageItemContainer
typedef std::unordered_map < uint32, std::vector < SpecializationSpellsEntry const * > >	SpecializationSpellsContainer
typedef std::unordered_map < uint32, std::vector < SpellPowerEntry const * > >	SpellPowerContainer
typedef std::unordered_map < uint32, std::unordered_map < uint32, std::vector < SpellPowerEntry const * > > >	SpellPowerDifficultyContainer
typedef std::unordered_set < uint32 >	ToyItemIdsContainer

Public Member Functions
	DEFINE_DB2_SET_COMPARATOR (ChrClassesXPowerTypesEntry)
	DEFINE_DB2_SET_COMPARATOR (GlyphSlotEntry)
	DEFINE_DB2_SET_COMPARATOR (MountTypeXCapabilityEntry)
void	LoadStores (std::string const &dataPath, uint32 defaultLocale)
DB2StorageBase const *	GetStorage (uint32 type) const
void	LoadHotfixData ()
HotfixData const *	GetHotfixData () const
time_t	GetHotfixDate (uint32 entry, uint32 type) const
std::vector< uint32 >	GetAreasForGroup (uint32 areaGroupId) const
CharStartOutfitEntry const *	GetCharStartOutfitEntry (uint8 race, uint8 class_, uint8 gender) const
uint32	GetPowerIndexByClass (uint32 powerType, uint32 classId) const
GlyphSlotContainer const &	GetGlyphSlots () const
uint32	GetHeirloomItemLevel (uint32 curveId, uint32 level) const
HeirloomEntry const *	GetHeirloomByItemId (uint32 itemId) const
ItemBonusList const *	GetItemBonusList (uint32 bonusListId) const
std::set< uint32 >	GetItemBonusTree (uint32 itemId, uint32 itemBonusTreeMod) const
uint32	GetItemDisplayId (uint32 itemId, uint32 appearanceModId) const
std::vector < ItemSpecOverrideEntry const * > const *	GetItemSpecOverrides (uint32 itemId) const
std::string	GetNameGenEntry (uint8 race, uint8 gender, LocaleConstant locale) const
MountEntry const *	GetMount (uint32 spellId) const
MountEntry const *	GetMountById (uint32 id) const
MountTypeXCapabilitySet const *	GetMountCapabilities (uint32 mountType) const
ResponseCodes	ValidateName (std::string const &name, LocaleConstant locale) const
std::vector < QuestPackageItemEntry const * > const *	GetQuestPackageItems (uint32 questPackageID) const
uint32	GetQuestUniqueBitFlag (uint32 questId)
std::set< uint32 >	GetPhasesForGroup (uint32 group) const
std::vector < SpecializationSpellsEntry const * > const *	GetSpecializationSpells (uint32 specId) const
std::vector< SpellPowerEntry const * >	GetSpellPowers (uint32 spellId, Difficulty difficulty=DIFFICULTY_NONE, bool *hasDifficultyPowers=nullptr) const
bool	IsToyItem (uint32 toy) const

Static Public Member Functions
static DB2Manager &	Instance ()
static char const *	GetBroadcastTextValue (BroadcastTextEntry const *broadcastText, LocaleConstant locale=DEFAULT_LOCALE, uint8 gender=GENDER_MALE, bool forceGender=false)

Private Attributes
StorageMap	_stores
HotfixData	_hotfixData
AreaGroupMemberContainer	_areaGroupMembers
CharStartOutfitContainer	_charStartOutfits
uint32	_powersByClass [MAX_CLASSES][MAX_POWERS]
GlyphSlotContainer	_glyphSlots
HeirloomItemsContainer	_heirlooms
HeirloomCurvesContainer	_heirloomCurvePoints
ItemBonusListContainer	_itemBonusLists
ItemBonusTreeContainer	_itemBonusTrees
ItemDisplayIdContainer	_itemDisplayIDs
ItemToBonusTreeContainer	_itemToBonusTree
ItemSpecOverridesContainer	_itemSpecOverrides
MountContainer	_mountsBySpellId
MountCapabilitiesByTypeContainer	_mountCapabilitiesByType
NameGenContainer	_nameGenData
NameValidationRegexContainer	_nameValidators
PhaseGroupContainer	_phasesByGroup
QuestPackageItemContainer	_questPackages
SpecializationSpellsContainer	_specializationSpellsBySpec
SpellPowerContainer	_spellPowers
SpellPowerDifficultyContainer	_spellPowerDifficulties
ToyItemIdsContainer	_toys

Member Typedef Documentation

typedef std::unordered_map<uint32 , std::vector<uint32> > DB2Manager::AreaGroupMemberContainer

typedef std::unordered_map<uint32, CharStartOutfitEntry const*> DB2Manager::CharStartOutfitContainer

typedef std::set<GlyphSlotEntry const*, GlyphSlotEntryComparator> DB2Manager::GlyphSlotContainer

typedef std::map<uint32 , std::map<uint32, CurvePointEntry const*, std::greater<uint32> > > DB2Manager::HeirloomCurvesContainer

typedef std::unordered_map<uint32, HeirloomEntry const*> DB2Manager::HeirloomItemsContainer

typedef std::vector<ItemBonusEntry const*> DB2Manager::ItemBonusList

typedef std::unordered_map<uint32 , ItemBonusList> DB2Manager::ItemBonusListContainer

typedef std::unordered_map<uint32, std::set<ItemBonusTreeNodeEntry const*> > DB2Manager::ItemBonusTreeContainer

typedef std::unordered_map<uint32 , uint32> DB2Manager::ItemDisplayIdContainer

typedef std::unordered_map<uint32, std::vector<ItemSpecOverrideEntry const*> > DB2Manager::ItemSpecOverridesContainer

typedef std::unordered_multimap<uint32 , uint32 > DB2Manager::ItemToBonusTreeContainer

typedef std::unordered_map<uint32, MountTypeXCapabilitySet> DB2Manager::MountCapabilitiesByTypeContainer

typedef std::unordered_map<uint32, MountEntry const*> DB2Manager::MountContainer

typedef std::set<MountTypeXCapabilityEntry const*, MountTypeXCapabilityEntryComparator> DB2Manager::MountTypeXCapabilitySet

typedef std::unordered_map<uint32, std::array<std::vector<NameGenEntry const*>, 2> > DB2Manager::NameGenContainer

typedef std::array<std::vector<boost::regex>, TOTAL_LOCALES + 1> DB2Manager::NameValidationRegexContainer

typedef std::unordered_map<uint32, std::set<uint32> > DB2Manager::PhaseGroupContainer

typedef std::unordered_map<uint32, std::vector<QuestPackageItemEntry const*> > DB2Manager::QuestPackageItemContainer

typedef std::unordered_map<uint32, std::vector<SpecializationSpellsEntry const*> > DB2Manager::SpecializationSpellsContainer

typedef std::unordered_map<uint32, std::vector<SpellPowerEntry const*> > DB2Manager::SpellPowerContainer

typedef std::unordered_map<uint32, std::unordered_map<uint32, std::vector<SpellPowerEntry const*> > > DB2Manager::SpellPowerDifficultyContainer

typedef std::map<uint32 , DB2StorageBase*> DB2Manager::StorageMap

typedef std::unordered_set<uint32> DB2Manager::ToyItemIdsContainer

Member Function Documentation

DB2Manager::DEFINE_DB2_SET_COMPARATOR

(

ChrClassesXPowerTypesEntry

)

DB2Manager::DEFINE_DB2_SET_COMPARATOR

(

GlyphSlotEntry

)

DB2Manager::DEFINE_DB2_SET_COMPARATOR

(

MountTypeXCapabilityEntry

)

std::vector< uint32 > DB2Manager::GetAreasForGroup

(

uint32

areaGroupId

)

const

{
 auto itr = _areaGroupMembers.find(areaGroupId);
 if (itr != _areaGroupMembers.end())
 return itr->second;

 return std::vector<uint32>();
}

char const * DB2Manager::GetBroadcastTextValue ( BroadcastTextEntry const *  broadcastText, LocaleConstant  locale = DEFAULT_LOCALE, uint8  gender = GENDER_MALE, bool  forceGender = false  )

static

{
 if (gender == GENDER_FEMALE && (forceGender || broadcastText->FemaleText->Str[DEFAULT_LOCALE][0] != '\0'))
 {
 if (broadcastText->FemaleText->Str[locale][0] != '\0')
 return broadcastText->FemaleText->Str[locale];

 return broadcastText->FemaleText->Str[DEFAULT_LOCALE];
 }

 if (broadcastText->MaleText->Str[locale][0] != '\0')
 return broadcastText->MaleText->Str[locale];

 return broadcastText->MaleText->Str[DEFAULT_LOCALE];
}

Here is the caller graph for this function:

CharStartOutfitEntry const * DB2Manager::GetCharStartOutfitEntry	(	uint8	race,
		uint8	class_,
		uint8	gender
	)		const

{
 auto itr = _charStartOutfits.find(race | (class_ << 8) | (gender << 16));
 if (itr == _charStartOutfits.end())
 return nullptr;

 return itr->second;
}

GlyphSlotContainer const& DB2Manager::GetGlyphSlots ( ) const

inline

{ return _glyphSlots; }

HeirloomEntry const * DB2Manager::GetHeirloomByItemId

(

uint32

itemId

)

const

{
 auto itr = _heirlooms.find(itemId);
 if (itr != _heirlooms.end())
 return itr->second;

 return nullptr;
}

uint32 DB2Manager::GetHeirloomItemLevel	(	uint32	curveId,
		uint32	level
	)		const

{
 // Assuming linear item level scaling for heirlooms
 auto itr = _heirloomCurvePoints.find(curveId);
 if (itr == _heirloomCurvePoints.end())
 return 0;

 auto it2 = itr->second.begin(); // Highest scaling point
 if (level >= it2->second->X)
 return it2->second->Y;

 auto previousItr = it2++;
 for (; it2 != itr->second.end(); ++it2, ++previousItr)
 if (level >= it2->second->X)
 return uint32((previousItr->second->Y - it2->second->Y) / (previousItr->second->X - it2->second->X) * (float(level) - it2->second->X) + it2->second->Y);

 return uint32(previousItr->second->Y); // Lowest scaling point
}

HotfixData const* DB2Manager::GetHotfixData ( ) const

inline

{ return &_hotfixData; }

time_t DB2Manager::GetHotfixDate	(	uint32	entry,
		uint32	type
	)		const

{
 time_t ret = 0;
 for (HotfixNotify const& hotfix : _hotfixData)
 if (hotfix.Entry == entry && hotfix.TableHash == type)
 if (time_t(hotfix.Timestamp) > ret)
 ret = time_t(hotfix.Timestamp);

 return ret ? ret : time(NULL);
}

DB2Manager::ItemBonusList const * DB2Manager::GetItemBonusList

(

uint32

bonusListId

)

const

{
 auto itr = _itemBonusLists.find(bonusListId);
 if (itr != _itemBonusLists.end())
 return &itr->second;

 return nullptr;
}

std::set< uint32 > DB2Manager::GetItemBonusTree	(	uint32	itemId,
		uint32	itemBonusTreeMod
	)		const

{
 std::set<uint32> bonusListIDs;
 auto itemIdRange = _itemToBonusTree.equal_range(itemId);
 if (itemIdRange.first == itemIdRange.second)
 return bonusListIDs;

 for (auto itemTreeItr = itemIdRange.first; itemTreeItr != itemIdRange.second; ++itemTreeItr)
 {
 auto treeItr = _itemBonusTrees.find(itemTreeItr->second);
 if (treeItr == _itemBonusTrees.end())
 continue;

 for (ItemBonusTreeNodeEntry const* bonusTreeNode : treeItr->second)
 if (bonusTreeNode->BonusTreeModID == itemBonusTreeMod)
 bonusListIDs.insert(bonusTreeNode->BonusListID);
 }

 return bonusListIDs;
}

uint32 DB2Manager::GetItemDisplayId	(	uint32	itemId,
		uint32	appearanceModId
	)		const

{
 auto itr = _itemDisplayIDs.find(itemId | (appearanceModId << 24));
 if (itr != _itemDisplayIDs.end())
 return itr->second;

 // Fall back to unmodified appearance
 if (appearanceModId)
 {
 itr = _itemDisplayIDs.find(itemId);
 if (itr != _itemDisplayIDs.end())
 return itr->second;
 }

 return 0;
}

std::vector< ItemSpecOverrideEntry const * > const * DB2Manager::GetItemSpecOverrides

(

uint32

itemId

)

const

{
 auto itr = _itemSpecOverrides.find(itemId);
 if (itr != _itemSpecOverrides.end())
 return &itr->second;

 return nullptr;
}

MountEntry const * DB2Manager::GetMount

(

uint32

spellId

)

const

{
 auto itr = _mountsBySpellId.find(spellId);
 if (itr != _mountsBySpellId.end())
 return itr->second;

 return nullptr;
}

MountEntry const * DB2Manager::GetMountById

(

uint32

id

)

const

{
 return sMountStore.LookupEntry(id);
}

DB2Manager::MountTypeXCapabilitySet const * DB2Manager::GetMountCapabilities

(

uint32

mountType

)

const

{
 auto itr = _mountCapabilitiesByType.find(mountType);
 if (itr != _mountCapabilitiesByType.end())
 return &itr->second;

 return nullptr;
}

std::string DB2Manager::GetNameGenEntry	(	uint8	race,
		uint8	gender,
		LocaleConstant	locale
	)		const

{
 ASSERT(gender < GENDER_NONE);
 auto ritr = _nameGenData.find(race);
 if (ritr == _nameGenData.end())
 return "";

 if (ritr->second[gender].empty())
 return "";

 LocalizedString* data = Trinity::Containers::SelectRandomContainerElement(ritr->second[gender])->Name;
 if (*data->Str[locale] != '\0')
 return data->Str[locale];

 return data->Str[sWorld->GetDefaultDbcLocale()];
}

Here is the call graph for this function:

std::set< uint32 > DB2Manager::GetPhasesForGroup

(

uint32

group

)

const

{
 auto itr = _phasesByGroup.find(group);
 if (itr != _phasesByGroup.end())
 return itr->second;

 return std::set<uint32>();
}

uint32 DB2Manager::GetPowerIndexByClass	(	uint32	powerType,
		uint32	classId
	)		const

{
 return _powersByClass[classId][powerType];
}

std::vector< QuestPackageItemEntry const * > const * DB2Manager::GetQuestPackageItems

(

uint32

questPackageID

)

const

{
 auto itr = _questPackages.find(questPackageID);
 if (itr != _questPackages.end())
 return &itr->second;

 return nullptr;
}

uint32 DB2Manager::GetQuestUniqueBitFlag

(

uint32

questId

)

{
 QuestV2Entry const* v2 = sQuestV2Store.LookupEntry(questId);
 if (!v2)
 return 0;

 return v2->UniqueBitFlag;
}

std::vector< SpecializationSpellsEntry const * > const * DB2Manager::GetSpecializationSpells

(

uint32

specId

)

const

{
 auto itr = _specializationSpellsBySpec.find(specId);
 if (itr != _specializationSpellsBySpec.end())
 return &itr->second;

 return nullptr;
}

std::vector< SpellPowerEntry const * > DB2Manager::GetSpellPowers	(	uint32	spellId,
		Difficulty	difficulty = DIFFICULTY_NONE,
		bool *	hasDifficultyPowers = nullptr
	)		const

{
 std::vector<SpellPowerEntry const*> powers;

 auto difficultyItr = _spellPowerDifficulties.find(spellId);
 if (difficultyItr != _spellPowerDifficulties.end())
 {
 if (hasDifficultyPowers)
 *hasDifficultyPowers = true;

 DifficultyEntry const* difficultyEntry = sDifficultyStore.LookupEntry(difficulty);
 while (difficultyEntry)
 {
 auto powerDifficultyItr = difficultyItr->second.find(difficultyEntry->ID);
 if (powerDifficultyItr != difficultyItr->second.end())
 {
 if (powerDifficultyItr->second.size() > powers.size())
 powers.resize(powerDifficultyItr->second.size());

 for (SpellPowerEntry const* difficultyPower : powerDifficultyItr->second)
 if (!powers[difficultyPower->PowerIndex])
 powers[difficultyPower->PowerIndex] = difficultyPower;
 }

 difficultyEntry = sDifficultyStore.LookupEntry(difficultyEntry->FallbackDifficultyID);
 }
 }

 auto itr = _spellPowers.find(spellId);
 if (itr != _spellPowers.end())
 {
 if (itr->second.size() > powers.size())
 powers.resize(itr->second.size());

 for (SpellPowerEntry const* power : itr->second)
 if (!powers[power->PowerIndex])
 powers[power->PowerIndex] = power;
 }

 return powers;
}

DB2StorageBase const * DB2Manager::GetStorage

(

uint32

type

)

const

{
 StorageMap::const_iterator itr = _stores.find(type);
 if (itr != _stores.end())
 return itr->second;

 return nullptr;
}

DB2Manager & DB2Manager::Instance ( )

static

{
 static DB2Manager instance;
 return instance;
}

bool DB2Manager::IsToyItem

(

uint32

toy

)

const

{
 return _toys.count(toy) > 0;
}

void DB2Manager::LoadHotfixData

(

)

{
 uint32 oldMSTime = getMSTime();

 QueryResult result = HotfixDatabase.Query("SELECT TableHash, RecordID, `Timestamp`, Deleted FROM hotfix_data");

 if (!result)
 {
 TC_LOG_INFO("misc", ">> Loaded 0 hotfix info entries.");
 return;
 }

 uint32 count = 0;

 _hotfixData.reserve(result->GetRowCount());

 do
 {
 Field* fields = result->Fetch();

 HotfixNotify info;
 info.TableHash = fields[0].GetUInt32();
 info.Entry = fields[1].GetUInt32();
 info.Timestamp = fields[2].GetUInt32();
 _hotfixData.push_back(info);

 if (fields[3].GetBool())
 {
 auto itr = _stores.find(info.TableHash);
 if (itr != _stores.end())
 itr->second->EraseRecord(info.Entry);
 }

 ++count;
 } while (result->NextRow());

 TC_LOG_INFO("misc", ">> Loaded %u hotfix info entries in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}

Here is the call graph for this function:

void DB2Manager::LoadStores	(	std::string const &	dataPath,
		uint32	defaultLocale
	)

{
 uint32 oldMSTime = getMSTime();

 std::string db2Path = dataPath + "dbc/";

 DB2StoreProblemList bad_db2_files;
 uint32 availableDb2Locales = 0xFF;

#define LOAD_DB2(store) LoadDB2(availableDb2Locales, bad_db2_files, _stores, &store, db2Path, defaultLocale)

 LOAD_DB2(sAchievementStore);
 LOAD_DB2(sAreaGroupMemberStore);
 LOAD_DB2(sBattlePetBreedQualityStore);
 LOAD_DB2(sBattlePetBreedStateStore);
 LOAD_DB2(sAuctionHouseStore);
 LOAD_DB2(sBarberShopStyleStore);
 LOAD_DB2(sBattlePetSpeciesStore);
 LOAD_DB2(sBattlePetSpeciesStateStore);
 LOAD_DB2(sBroadcastTextStore);
 LOAD_DB2(sCharStartOutfitStore);
 LOAD_DB2(sChrClassesXPowerTypesStore);
 LOAD_DB2(sCinematicSequencesStore);
 LOAD_DB2(sCreatureDisplayInfoStore);
 LOAD_DB2(sCreatureTypeStore);
 LOAD_DB2(sCriteriaStore);
 LOAD_DB2(sCriteriaTreeStore);
 LOAD_DB2(sCurrencyTypesStore);
 LOAD_DB2(sCurvePointStore);
 LOAD_DB2(sDestructibleModelDataStore);
 LOAD_DB2(sDurabilityQualityStore);
 LOAD_DB2(sGameObjectsStore);
 LOAD_DB2(sGameTablesStore);
 LOAD_DB2(sGarrAbilityStore);
 LOAD_DB2(sGarrBuildingPlotInstStore);
 LOAD_DB2(sGarrBuildingStore);
 LOAD_DB2(sGarrClassSpecStore);
 LOAD_DB2(sGarrFollowerStore);
 LOAD_DB2(sGarrFollowerXAbilityStore);
 LOAD_DB2(sGarrPlotBuildingStore);
 LOAD_DB2(sGarrPlotInstanceStore);
 LOAD_DB2(sGarrPlotStore);
 LOAD_DB2(sGarrSiteLevelPlotInstStore);
 LOAD_DB2(sGarrSiteLevelStore);
 LOAD_DB2(sGlyphSlotStore);
 LOAD_DB2(sGuildPerkSpellsStore);
 LOAD_DB2(sHeirloomStore);
 LOAD_DB2(sHolidaysStore);
 LOAD_DB2(sImportPriceArmorStore);
 LOAD_DB2(sImportPriceQualityStore);
 LOAD_DB2(sImportPriceShieldStore);
 LOAD_DB2(sImportPriceWeaponStore);
 LOAD_DB2(sItemAppearanceStore);
 LOAD_DB2(sItemBonusStore);
 LOAD_DB2(sItemBonusTreeNodeStore);
 LOAD_DB2(sItemClassStore);
 LOAD_DB2(sItemCurrencyCostStore);
 LOAD_DB2(sItemDisenchantLootStore);
 LOAD_DB2(sItemEffectStore);
 LOAD_DB2(sItemExtendedCostStore);
 LOAD_DB2(sItemLimitCategoryStore);
 LOAD_DB2(sItemModifiedAppearanceStore);
 LOAD_DB2(sItemPriceBaseStore);
 LOAD_DB2(sItemRandomPropertiesStore);
 LOAD_DB2(sItemRandomSuffixStore);
 LOAD_DB2(sItemSparseStore);
 LOAD_DB2(sItemSpecOverrideStore);
 LOAD_DB2(sItemSpecStore);
 LOAD_DB2(sItemStore);
 LOAD_DB2(sItemToBattlePetSpeciesStore);
 LOAD_DB2(sItemXBonusTreeStore);
 LOAD_DB2(sKeyChainStore);
 LOAD_DB2(sMailTemplateStore);
 LOAD_DB2(sModifierTreeStore);
 LOAD_DB2(sMountCapabilityStore);
 LOAD_DB2(sMountStore);
 LOAD_DB2(sMountTypeXCapabilityStore);
 LOAD_DB2(sNameGenStore);
 LOAD_DB2(sNamesProfanityStore);
 LOAD_DB2(sNamesReservedStore);
 LOAD_DB2(sNamesReservedLocaleStore);
 LOAD_DB2(sOverrideSpellDataStore);
 LOAD_DB2(sPhaseXPhaseGroupStore);
 LOAD_DB2(sPlayerConditionStore);
 LOAD_DB2(sQuestMoneyRewardStore);
 LOAD_DB2(sQuestPackageItemStore);
 LOAD_DB2(sQuestSortStore);
 LOAD_DB2(sQuestV2Store);
 LOAD_DB2(sQuestXPStore);
 LOAD_DB2(sScalingStatDistributionStore);
 LOAD_DB2(sSoundEntriesStore);
 LOAD_DB2(sSpecializationSpellsStore);
 LOAD_DB2(sSpellAuraRestrictionsStore);
 LOAD_DB2(sSpellCastTimesStore);
 LOAD_DB2(sSpellCastingRequirementsStore);
 LOAD_DB2(sSpellClassOptionsStore);
 LOAD_DB2(sSpellDurationStore);
 LOAD_DB2(sSpellItemEnchantmentConditionStore);
 LOAD_DB2(sSpellLearnSpellStore);
 LOAD_DB2(sSpellMiscStore);
 LOAD_DB2(sSpellPowerDifficultyStore);
 LOAD_DB2(sSpellPowerStore);
 LOAD_DB2(sSpellRadiusStore);
 LOAD_DB2(sSpellRangeStore);
 LOAD_DB2(sSpellReagentsStore);
 LOAD_DB2(sSpellRuneCostStore);
 LOAD_DB2(sSpellTotemsStore);
 LOAD_DB2(sSpellXSpellVisualStore);
 LOAD_DB2(sTaxiNodesStore);
 LOAD_DB2(sTaxiPathNodeStore);
 LOAD_DB2(sTaxiPathStore);
 LOAD_DB2(sTotemCategoryStore);
 LOAD_DB2(sToyStore);
 LOAD_DB2(sTransportAnimationStore);
 LOAD_DB2(sTransportRotationStore);
 LOAD_DB2(sUnitPowerBarStore);
 LOAD_DB2(sWorldMapOverlayStore);

#undef LOAD_DB2

 for (AreaGroupMemberEntry const* areaGroupMember : sAreaGroupMemberStore)
 _areaGroupMembers[areaGroupMember->AreaGroupID].push_back(areaGroupMember->AreaID);

 for (CharStartOutfitEntry const* outfit : sCharStartOutfitStore)
 _charStartOutfits[outfit->RaceID | (outfit->ClassID << 8) | (outfit->GenderID << 16)] = outfit;

 sChrClassesXPowerTypesStore.Sort(&ChrClassesXPowerTypesEntryComparator::Compare);
 for (uint32 i = 0; i < MAX_CLASSES; ++i)
 for (uint32 j = 0; j < MAX_POWERS; ++j)
 _powersByClass[i][j] = MAX_POWERS;

 for (ChrClassesXPowerTypesEntry const* power : sChrClassesXPowerTypesStore)
 {
 uint32 index = 0;
 for (uint32 j = 0; j < MAX_POWERS; ++j)
 if (_powersByClass[power->ClassID][j] != MAX_POWERS)
 ++index;

 _powersByClass[power->ClassID][power->PowerType] = index;
 }

 for (GlyphSlotEntry const* glyphSlot : sGlyphSlotStore)
 if (glyphSlot->Type == GLYPH_SLOT_MAJOR || glyphSlot->Type == GLYPH_SLOT_MINOR)
 _glyphSlots.insert(glyphSlot);

 for (ItemBonusEntry const* bonus : sItemBonusStore)
 _itemBonusLists[bonus->BonusListID].push_back(bonus);

 for (ItemBonusTreeNodeEntry const* bonusTreeNode : sItemBonusTreeNodeStore)
 {
 uint32 bonusTreeId = bonusTreeNode->BonusTreeID;
 while (bonusTreeNode)
 {
 _itemBonusTrees[bonusTreeId].insert(bonusTreeNode);
 bonusTreeNode = sItemBonusTreeNodeStore.LookupEntry(bonusTreeNode->SubTreeID);
 }
 }

 for (ItemModifiedAppearanceEntry const* appearanceMod : sItemModifiedAppearanceStore)
 if (ItemAppearanceEntry const* appearance = sItemAppearanceStore.LookupEntry(appearanceMod->AppearanceID))
 _itemDisplayIDs[appearanceMod->ItemID | (appearanceMod->AppearanceModID << 24)] = appearance->DisplayID;

 for (ItemSpecOverrideEntry const* entry : sItemSpecOverrideStore)
 _itemSpecOverrides[entry->ItemID].push_back(entry);

 for (ItemXBonusTreeEntry const* itemBonusTreeAssignment : sItemXBonusTreeStore)
 _itemToBonusTree.insert({ itemBonusTreeAssignment->ItemID, itemBonusTreeAssignment->BonusTreeID });

 {
 std::set<uint32> scalingCurves;
 for (ScalingStatDistributionEntry const* ssd : sScalingStatDistributionStore)
 scalingCurves.insert(ssd->ItemLevelCurveID);

 for (CurvePointEntry const* curvePoint : sCurvePointStore)
 if (scalingCurves.count(curvePoint->CurveID))
 _heirloomCurvePoints[curvePoint->CurveID][curvePoint->Index] = curvePoint;
 }

 for (MountEntry const* mount : sMountStore)
 _mountsBySpellId[mount->SpellId] = mount;

 for (MountTypeXCapabilityEntry const* mount : sMountTypeXCapabilityStore)
 _mountCapabilitiesByType[mount->MountTypeID].insert(mount);

 for (NameGenEntry const* entry : sNameGenStore)
 _nameGenData[entry->Race][entry->Sex].push_back(entry);

 for (NamesProfanityEntry const* namesProfanity : sNamesProfanityStore)
 {
 ASSERT(namesProfanity->Language < TOTAL_LOCALES || namesProfanity->Language == -1);
 if (namesProfanity->Language != -1)
 _nameValidators[namesProfanity->Language].emplace_back(namesProfanity->Name, boost::regex::perl | boost::regex::icase | boost::regex::optimize);
 else
 {
 for (uint32 i = 0; i < TOTAL_LOCALES; ++i)
 {
 if (i == LOCALE_none)
 continue;

 _nameValidators[i].emplace_back(namesProfanity->Name, boost::regex::perl | boost::regex::icase | boost::regex::optimize);
 }
 }
 }

 for (NamesReservedEntry const* namesReserved : sNamesReservedStore)
 _nameValidators[TOTAL_LOCALES].emplace_back(namesReserved->Name, boost::regex::perl | boost::regex::icase | boost::regex::optimize);

 for (NamesReservedLocaleEntry const* namesReserved : sNamesReservedLocaleStore)
 {
 ASSERT(!(namesReserved->LocaleMask & ~((1 << TOTAL_LOCALES) - 1)));
 for (uint32 i = 0; i < TOTAL_LOCALES; ++i)
 {
 if (i == LOCALE_none)
 continue;

 if (namesReserved->LocaleMask & (1 << i))
 _nameValidators[i].emplace_back(namesReserved->Name, boost::regex::perl | boost::regex::icase | boost::regex::optimize);
 }
 }

 for (PhaseXPhaseGroupEntry const* group : sPhaseXPhaseGroupStore)
 if (PhaseEntry const* phase = sPhaseStore.LookupEntry(group->PhaseID))
 _phasesByGroup[group->PhaseGroupID].insert(phase->ID);

 for (QuestPackageItemEntry const* questPackageItem : sQuestPackageItemStore)
 _questPackages[questPackageItem->QuestPackageID].push_back(questPackageItem);

 for (SpecializationSpellsEntry const* specSpells : sSpecializationSpellsStore)
 _specializationSpellsBySpec[specSpells->SpecID].push_back(specSpells);

 for (SpellPowerEntry const* power : sSpellPowerStore)
 {
 if (SpellPowerDifficultyEntry const* powerDifficulty = sSpellPowerDifficultyStore.LookupEntry(power->ID))
 {
 std::vector<SpellPowerEntry const*>& powers = _spellPowerDifficulties[power->SpellID][powerDifficulty->DifficultyID];
 if (powers.size() <= powerDifficulty->PowerIndex)
 powers.resize(powerDifficulty->PowerIndex + 1);

 powers[powerDifficulty->PowerIndex] = power;
 }
 else
 {
 std::vector<SpellPowerEntry const*>& powers = _spellPowers[power->SpellID];
 if (powers.size() <= power->PowerIndex)
 powers.resize(power->PowerIndex + 1);

 powers[power->PowerIndex] = power;
 }
 }

 for (TaxiPathEntry const* entry : sTaxiPathStore)
 sTaxiPathSetBySource[entry->From][entry->To] = TaxiPathBySourceAndDestination(entry->ID, entry->Cost);

 uint32 pathCount = sTaxiPathStore.GetNumRows();

 // Calculate path nodes count
 std::vector<uint32> pathLength;
 pathLength.resize(pathCount); // 0 and some other indexes not used
 for (TaxiPathNodeEntry const* entry : sTaxiPathNodeStore)
 if (pathLength[entry->PathID] < entry->NodeIndex + 1)
 pathLength[entry->PathID] = entry->NodeIndex + 1;

 // Set path length
 sTaxiPathNodesByPath.resize(pathCount); // 0 and some other indexes not used
 for (uint32 i = 0; i < sTaxiPathNodesByPath.size(); ++i)
 sTaxiPathNodesByPath[i].resize(pathLength[i]);

 // fill data
 for (TaxiPathNodeEntry const* entry : sTaxiPathNodeStore)
 sTaxiPathNodesByPath[entry->PathID][entry->NodeIndex] = entry;

 // Initialize global taxinodes mask
 // include existed nodes that have at least single not spell base (scripted) path
 {
 if (sTaxiNodesStore.GetNumRows())
 {
 ASSERT(TaxiMaskSize >= ((sTaxiNodesStore.GetNumRows() - 1) / 8) + 1,
 "TaxiMaskSize is not large enough to contain all taxi nodes! (current value %d, required %d)",
 TaxiMaskSize, (((sTaxiNodesStore.GetNumRows() - 1) / 8) + 1));
 }

 sTaxiNodesMask.fill(0);
 sOldContinentsNodesMask.fill(0);
 sHordeTaxiNodesMask.fill(0);
 sAllianceTaxiNodesMask.fill(0);
 for (TaxiNodesEntry const* node : sTaxiNodesStore)
 {
 if (!(node->Flags & (TAXI_NODE_FLAG_ALLIANCE | TAXI_NODE_FLAG_HORDE)))
 continue;

 // valid taxi network node
 uint8 field = (uint8)((node->ID - 1) / 8);
 uint32 submask = 1 << ((node->ID - 1) % 8);

 sTaxiNodesMask[field] |= submask;
 if (node->Flags & TAXI_NODE_FLAG_HORDE)
 sHordeTaxiNodesMask[field] |= submask;
 if (node->Flags & TAXI_NODE_FLAG_ALLIANCE)
 sAllianceTaxiNodesMask[field] |= submask;

 uint32 nodeMap;
 DeterminaAlternateMapPosition(node->MapID, node->Pos.X, node->Pos.Y, node->Pos.Z, &nodeMap);
 if (nodeMap < 2)
 sOldContinentsNodesMask[field] |= submask;
 }
 }

 for (TransportAnimationEntry const* anim : sTransportAnimationStore)
 sTransportMgr->AddPathNodeToTransport(anim->TransportID, anim->TimeIndex, anim);

 for (TransportRotationEntry const* rot : sTransportRotationStore)
 sTransportMgr->AddPathRotationToTransport(rot->TransportID, rot->TimeIndex, rot);

 for (ToyEntry const* toy : sToyStore)
 _toys.insert(toy->ItemID);

 for (HeirloomEntry const* heirloom : sHeirloomStore)
 _heirlooms[heirloom->ItemID] = heirloom;

 // error checks
 if (bad_db2_files.size() >= DB2FilesCount)
 {
 TC_LOG_ERROR("misc", "\nIncorrect DataDir value in worldserver.conf or ALL required *.db2 files (%d) not found by path: %sdbc/%s/", DB2FilesCount, dataPath.c_str(), localeNames[defaultLocale]);
 exit(1);
 }
 else if (!bad_db2_files.empty())
 {
 std::string str;
 for (std::list<std::string>::iterator i = bad_db2_files.begin(); i != bad_db2_files.end(); ++i)
 str += *i + "\n";

 TC_LOG_ERROR("misc", "\nSome required *.db2 files (%u from %d) not found or not compatible:\n%s", (uint32)bad_db2_files.size(), DB2FilesCount, str.c_str());
 exit(1);
 }

 // Check loaded DB2 files proper version
 if (!sItemStore.LookupEntry(128706) || // last item added in 6.2.0 (20216)
 !sItemExtendedCostStore.LookupEntry(5923) ) // last item extended cost added in 6.2.0 (20216)
 {
 TC_LOG_ERROR("misc", "You have _outdated_ DB2 files. Please extract correct versions from current using client.");
 exit(1);
 }

 TC_LOG_INFO("server.loading", ">> Initialized %d DB2 data stores in %u ms", DB2FilesCount, GetMSTimeDiffToNow(oldMSTime));
}

Here is the call graph for this function:

ResponseCodes DB2Manager::ValidateName	(	std::string const &	name,
		LocaleConstant	locale
	)		const

{
 for (boost::regex const& regex : _nameValidators[locale])
 if (boost::regex_search(name, regex))
 return CHAR_NAME_PROFANE;

 // regexes at TOTAL_LOCALES are loaded from NamesReserved which is not locale specific
 for (boost::regex const& regex : _nameValidators[TOTAL_LOCALES])
 if (boost::regex_search(name, regex))
 return CHAR_NAME_RESERVED;

 return CHAR_NAME_SUCCESS;
}

Member Data Documentation

AreaGroupMemberContainer DB2Manager::_areaGroupMembers

private

CharStartOutfitContainer DB2Manager::_charStartOutfits

private

GlyphSlotContainer DB2Manager::_glyphSlots

private

HeirloomCurvesContainer DB2Manager::_heirloomCurvePoints

private

HeirloomItemsContainer DB2Manager::_heirlooms

private

HotfixData DB2Manager::_hotfixData

private

ItemBonusListContainer DB2Manager::_itemBonusLists

private

ItemBonusTreeContainer DB2Manager::_itemBonusTrees

private

ItemDisplayIdContainer DB2Manager::_itemDisplayIDs

private

ItemSpecOverridesContainer DB2Manager::_itemSpecOverrides

private

ItemToBonusTreeContainer DB2Manager::_itemToBonusTree

private

MountCapabilitiesByTypeContainer DB2Manager::_mountCapabilitiesByType

private

MountContainer DB2Manager::_mountsBySpellId

private

NameGenContainer DB2Manager::_nameGenData

private

NameValidationRegexContainer DB2Manager::_nameValidators

private

PhaseGroupContainer DB2Manager::_phasesByGroup

private

uint32 DB2Manager::_powersByClass[MAX_CLASSES][MAX_POWERS]

private

QuestPackageItemContainer DB2Manager::_questPackages

private

SpecializationSpellsContainer DB2Manager::_specializationSpellsBySpec

private

SpellPowerDifficultyContainer DB2Manager::_spellPowerDifficulties

private

SpellPowerContainer DB2Manager::_spellPowers

private

StorageMap DB2Manager::_stores

private

ToyItemIdsContainer DB2Manager::_toys

private

---

The documentation for this class was generated from the following files:

• src/server/game/DataStores/DB2Stores.h
• src/server/game/DataStores/DB2Stores.cpp