TrinityCore
DB2Stores.cpp
Go to the documentation of this file.
1/*
2 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18#include "DB2Stores.h"
19#include "Containers.h"
20#include "DatabaseEnv.h"
21#include "DB2LoadInfo.h"
22#include "Hash.h"
23#include "ItemTemplate.h"
24#include "IteratorPair.h"
25#include "Log.h"
26#include "Random.h"
27#include "Regex.h"
28#include "Timer.h"
29#include "Util.h"
30#include "World.h"
31#include <boost/filesystem/operations.hpp>
32#include <array>
33#include <bitset>
34#include <numeric>
35#include <sstream>
36#include <cctype>
37
38// temporary hack until includes are sorted out (don't want to pull in Windows.h)
39#ifdef GetClassName
40#undef GetClassName
41#endif
42
43DB2Storage<AchievementEntry> sAchievementStore("Achievement.db2", &AchievementLoadInfo::Instance);
44DB2Storage<Achievement_CategoryEntry> sAchievementCategoryStore("Achievement_Category.db2", &AchievementCategoryLoadInfo::Instance);
45DB2Storage<AdventureJournalEntry> sAdventureJournalStore("AdventureJournal.db2", &AdventureJournalLoadInfo::Instance);
46DB2Storage<AdventureMapPOIEntry> sAdventureMapPOIStore("AdventureMapPOI.db2", &AdventureMapPoiLoadInfo::Instance);
47DB2Storage<AnimationDataEntry> sAnimationDataStore("AnimationData.db2", &AnimationDataLoadInfo::Instance);
48DB2Storage<AnimKitEntry> sAnimKitStore("AnimKit.db2", &AnimKitLoadInfo::Instance);
49DB2Storage<AreaGroupMemberEntry> sAreaGroupMemberStore("AreaGroupMember.db2", &AreaGroupMemberLoadInfo::Instance);
50DB2Storage<AreaTableEntry> sAreaTableStore("AreaTable.db2", &AreaTableLoadInfo::Instance);
51DB2Storage<AreaTriggerEntry> sAreaTriggerStore("AreaTrigger.db2", &AreaTriggerLoadInfo::Instance);
52DB2Storage<ArmorLocationEntry> sArmorLocationStore("ArmorLocation.db2", &ArmorLocationLoadInfo::Instance);
53DB2Storage<ArtifactEntry> sArtifactStore("Artifact.db2", &ArtifactLoadInfo::Instance);
54DB2Storage<ArtifactAppearanceEntry> sArtifactAppearanceStore("ArtifactAppearance.db2", &ArtifactAppearanceLoadInfo::Instance);
55DB2Storage<ArtifactAppearanceSetEntry> sArtifactAppearanceSetStore("ArtifactAppearanceSet.db2", &ArtifactAppearanceSetLoadInfo::Instance);
56DB2Storage<ArtifactCategoryEntry> sArtifactCategoryStore("ArtifactCategory.db2", &ArtifactCategoryLoadInfo::Instance);
57DB2Storage<ArtifactPowerEntry> sArtifactPowerStore("ArtifactPower.db2", &ArtifactPowerLoadInfo::Instance);
58DB2Storage<ArtifactPowerLinkEntry> sArtifactPowerLinkStore("ArtifactPowerLink.db2", &ArtifactPowerLinkLoadInfo::Instance);
59DB2Storage<ArtifactPowerPickerEntry> sArtifactPowerPickerStore("ArtifactPowerPicker.db2", &ArtifactPowerPickerLoadInfo::Instance);
60DB2Storage<ArtifactPowerRankEntry> sArtifactPowerRankStore("ArtifactPowerRank.db2", &ArtifactPowerRankLoadInfo::Instance);
61DB2Storage<ArtifactQuestXPEntry> sArtifactQuestXPStore("ArtifactQuestXP.db2", &ArtifactQuestXpLoadInfo::Instance);
62DB2Storage<ArtifactTierEntry> sArtifactTierStore("ArtifactTier.db2", &ArtifactTierLoadInfo::Instance);
63DB2Storage<ArtifactUnlockEntry> sArtifactUnlockStore("ArtifactUnlock.db2", &ArtifactUnlockLoadInfo::Instance);
64DB2Storage<AuctionHouseEntry> sAuctionHouseStore("AuctionHouse.db2", &AuctionHouseLoadInfo::Instance);
65DB2Storage<AzeriteEmpoweredItemEntry> sAzeriteEmpoweredItemStore("AzeriteEmpoweredItem.db2", &AzeriteEmpoweredItemLoadInfo::Instance);
66DB2Storage<AzeriteEssenceEntry> sAzeriteEssenceStore("AzeriteEssence.db2", &AzeriteEssenceLoadInfo::Instance);
67DB2Storage<AzeriteEssencePowerEntry> sAzeriteEssencePowerStore("AzeriteEssencePower.db2", &AzeriteEssencePowerLoadInfo::Instance);
68DB2Storage<AzeriteItemEntry> sAzeriteItemStore("AzeriteItem.db2", &AzeriteItemLoadInfo::Instance);
69DB2Storage<AzeriteItemMilestonePowerEntry> sAzeriteItemMilestonePowerStore("AzeriteItemMilestonePower.db2", &AzeriteItemMilestonePowerLoadInfo::Instance);
70DB2Storage<AzeriteKnowledgeMultiplierEntry> sAzeriteKnowledgeMultiplierStore("AzeriteKnowledgeMultiplier.db2", &AzeriteKnowledgeMultiplierLoadInfo::Instance);
71DB2Storage<AzeriteLevelInfoEntry> sAzeriteLevelInfoStore("AzeriteLevelInfo.db2", &AzeriteLevelInfoLoadInfo::Instance);
72DB2Storage<AzeritePowerEntry> sAzeritePowerStore("AzeritePower.db2", &AzeritePowerLoadInfo::Instance);
73DB2Storage<AzeritePowerSetMemberEntry> sAzeritePowerSetMemberStore("AzeritePowerSetMember.db2", &AzeritePowerSetMemberLoadInfo::Instance);
74DB2Storage<AzeriteTierUnlockEntry> sAzeriteTierUnlockStore("AzeriteTierUnlock.db2", &AzeriteTierUnlockLoadInfo::Instance);
75DB2Storage<AzeriteTierUnlockSetEntry> sAzeriteTierUnlockSetStore("AzeriteTierUnlockSet.db2", &AzeriteTierUnlockSetLoadInfo::Instance);
76DB2Storage<AzeriteUnlockMappingEntry> sAzeriteUnlockMappingStore("AzeriteUnlockMapping.db2", &AzeriteUnlockMappingLoadInfo::Instance);
77DB2Storage<BankBagSlotPricesEntry> sBankBagSlotPricesStore("BankBagSlotPrices.db2", &BankBagSlotPricesLoadInfo::Instance);
78DB2Storage<BannedAddonsEntry> sBannedAddonsStore("BannedAddons.db2", &BannedAddonsLoadInfo::Instance);
79DB2Storage<BarberShopStyleEntry> sBarberShopStyleStore("BarberShopStyle.db2", &BarberShopStyleLoadInfo::Instance);
80DB2Storage<BattlePetAbilityEntry> sBattlePetAbilityStore("BattlePetAbility.db2", &BattlePetAbilityLoadInfo::Instance);
81DB2Storage<BattlePetBreedQualityEntry> sBattlePetBreedQualityStore("BattlePetBreedQuality.db2", &BattlePetBreedQualityLoadInfo::Instance);
82DB2Storage<BattlePetBreedStateEntry> sBattlePetBreedStateStore("BattlePetBreedState.db2", &BattlePetBreedStateLoadInfo::Instance);
83DB2Storage<BattlePetSpeciesEntry> sBattlePetSpeciesStore("BattlePetSpecies.db2", &BattlePetSpeciesLoadInfo::Instance);
84DB2Storage<BattlePetSpeciesStateEntry> sBattlePetSpeciesStateStore("BattlePetSpeciesState.db2", &BattlePetSpeciesStateLoadInfo::Instance);
85DB2Storage<BattlemasterListEntry> sBattlemasterListStore("BattlemasterList.db2", &BattlemasterListLoadInfo::Instance);
86DB2Storage<BroadcastTextEntry> sBroadcastTextStore("BroadcastText.db2", &BroadcastTextLoadInfo::Instance);
87DB2Storage<BroadcastTextDurationEntry> sBroadcastTextDurationStore("BroadcastTextDuration.db2", &BroadcastTextDurationLoadInfo::Instance);
88DB2Storage<Cfg_CategoriesEntry> sCfgCategoriesStore("Cfg_Categories.db2", &CfgCategoriesLoadInfo::Instance);
89DB2Storage<Cfg_RegionsEntry> sCfgRegionsStore("Cfg_Regions.db2", &CfgRegionsLoadInfo::Instance);
90DB2Storage<ChallengeModeItemBonusOverrideEntry> sChallengeModeItemBonusOverrideStore("ChallengeModeItemBonusOverride.db2", &ChallengeModeItemBonusOverrideLoadInfo::Instance);
91DB2Storage<CharTitlesEntry> sCharTitlesStore("CharTitles.db2", &CharTitlesLoadInfo::Instance);
92DB2Storage<CharacterLoadoutEntry> sCharacterLoadoutStore("CharacterLoadout.db2", &CharacterLoadoutLoadInfo::Instance);
93DB2Storage<CharacterLoadoutItemEntry> sCharacterLoadoutItemStore("CharacterLoadoutItem.db2", &CharacterLoadoutItemLoadInfo::Instance);
94DB2Storage<ChatChannelsEntry> sChatChannelsStore("ChatChannels.db2", &ChatChannelsLoadInfo::Instance);
95DB2Storage<ChrClassUIDisplayEntry> sChrClassUIDisplayStore("ChrClassUIDisplay.db2", &ChrClassUiDisplayLoadInfo::Instance);
96DB2Storage<ChrClassesEntry> sChrClassesStore("ChrClasses.db2", &ChrClassesLoadInfo::Instance);
97DB2Storage<ChrClassesXPowerTypesEntry> sChrClassesXPowerTypesStore("ChrClassesXPowerTypes.db2", &ChrClassesXPowerTypesLoadInfo::Instance);
98DB2Storage<ChrCustomizationChoiceEntry> sChrCustomizationChoiceStore("ChrCustomizationChoice.db2", &ChrCustomizationChoiceLoadInfo::Instance);
99DB2Storage<ChrCustomizationDisplayInfoEntry> sChrCustomizationDisplayInfoStore("ChrCustomizationDisplayInfo.db2", &ChrCustomizationDisplayInfoLoadInfo::Instance);
100DB2Storage<ChrCustomizationElementEntry> sChrCustomizationElementStore("ChrCustomizationElement.db2", &ChrCustomizationElementLoadInfo::Instance);
101DB2Storage<ChrCustomizationOptionEntry> sChrCustomizationOptionStore("ChrCustomizationOption.db2", &ChrCustomizationOptionLoadInfo::Instance);
102DB2Storage<ChrCustomizationReqEntry> sChrCustomizationReqStore("ChrCustomizationReq.db2", &ChrCustomizationReqLoadInfo::Instance);
103DB2Storage<ChrCustomizationReqChoiceEntry> sChrCustomizationReqChoiceStore("ChrCustomizationReqChoice.db2", &ChrCustomizationReqChoiceLoadInfo::Instance);
104DB2Storage<ChrModelEntry> sChrModelStore("ChrModel.db2", &ChrModelLoadInfo::Instance);
105DB2Storage<ChrRaceXChrModelEntry> sChrRaceXChrModelStore("ChrRaceXChrModel.db2", &ChrRaceXChrModelLoadInfo::Instance);
106DB2Storage<ChrRacesEntry> sChrRacesStore("ChrRaces.db2", &ChrRacesLoadInfo::Instance);
107DB2Storage<ChrSpecializationEntry> sChrSpecializationStore("ChrSpecialization.db2", &ChrSpecializationLoadInfo::Instance);
108DB2Storage<CinematicCameraEntry> sCinematicCameraStore("CinematicCamera.db2", &CinematicCameraLoadInfo::Instance);
109DB2Storage<CinematicSequencesEntry> sCinematicSequencesStore("CinematicSequences.db2", &CinematicSequencesLoadInfo::Instance);
110DB2Storage<ConditionalChrModelEntry> sConditionalChrModelStore("ConditionalChrModel.db2", &ConditionalChrModelLoadInfo::Instance);
111DB2Storage<ConditionalContentTuningEntry> sConditionalContentTuningStore("ConditionalContentTuning.db2", &ConditionalContentTuningLoadInfo::Instance);
112DB2Storage<ContentTuningEntry> sContentTuningStore("ContentTuning.db2", &ContentTuningLoadInfo::Instance);
113DB2Storage<ContentTuningXExpectedEntry> sContentTuningXExpectedStore("ContentTuningXExpected.db2", &ContentTuningXExpectedLoadInfo::Instance);
114DB2Storage<ContentTuningXLabelEntry> sContentTuningXLabelStore("ContentTuningXLabel.db2", &ContentTuningXLabelLoadInfo::Instance);
115DB2Storage<ConversationLineEntry> sConversationLineStore("ConversationLine.db2", &ConversationLineLoadInfo::Instance);
116DB2Storage<CorruptionEffectsEntry> sCorruptionEffectsStore("CorruptionEffects.db2", &CorruptionEffectsLoadInfo::Instance);
117DB2Storage<CreatureDisplayInfoEntry> sCreatureDisplayInfoStore("CreatureDisplayInfo.db2", &CreatureDisplayInfoLoadInfo::Instance);
118DB2Storage<CreatureDisplayInfoExtraEntry> sCreatureDisplayInfoExtraStore("CreatureDisplayInfoExtra.db2", &CreatureDisplayInfoExtraLoadInfo::Instance);
119DB2Storage<CreatureFamilyEntry> sCreatureFamilyStore("CreatureFamily.db2", &CreatureFamilyLoadInfo::Instance);
120DB2Storage<CreatureModelDataEntry> sCreatureModelDataStore("CreatureModelData.db2", &CreatureModelDataLoadInfo::Instance);
121DB2Storage<CreatureTypeEntry> sCreatureTypeStore("CreatureType.db2", &CreatureTypeLoadInfo::Instance);
122DB2Storage<CriteriaEntry> sCriteriaStore("Criteria.db2", &CriteriaLoadInfo::Instance);
123DB2Storage<CriteriaTreeEntry> sCriteriaTreeStore("CriteriaTree.db2", &CriteriaTreeLoadInfo::Instance);
124DB2Storage<CurrencyContainerEntry> sCurrencyContainerStore("CurrencyContainer.db2", &CurrencyContainerLoadInfo::Instance);
125DB2Storage<CurrencyTypesEntry> sCurrencyTypesStore("CurrencyTypes.db2", &CurrencyTypesLoadInfo::Instance);
126DB2Storage<CurveEntry> sCurveStore("Curve.db2", &CurveLoadInfo::Instance);
127DB2Storage<CurvePointEntry> sCurvePointStore("CurvePoint.db2", &CurvePointLoadInfo::Instance);
128DB2Storage<DestructibleModelDataEntry> sDestructibleModelDataStore("DestructibleModelData.db2", &DestructibleModelDataLoadInfo::Instance);
129DB2Storage<DifficultyEntry> sDifficultyStore("Difficulty.db2", &DifficultyLoadInfo::Instance);
130DB2Storage<DungeonEncounterEntry> sDungeonEncounterStore("DungeonEncounter.db2", &DungeonEncounterLoadInfo::Instance);
131DB2Storage<DurabilityCostsEntry> sDurabilityCostsStore("DurabilityCosts.db2", &DurabilityCostsLoadInfo::Instance);
132DB2Storage<DurabilityQualityEntry> sDurabilityQualityStore("DurabilityQuality.db2", &DurabilityQualityLoadInfo::Instance);
133DB2Storage<EmotesEntry> sEmotesStore("Emotes.db2", &EmotesLoadInfo::Instance);
134DB2Storage<EmotesTextEntry> sEmotesTextStore("EmotesText.db2", &EmotesTextLoadInfo::Instance);
135DB2Storage<EmotesTextSoundEntry> sEmotesTextSoundStore("EmotesTextSound.db2", &EmotesTextSoundLoadInfo::Instance);
136DB2Storage<ExpectedStatEntry> sExpectedStatStore("ExpectedStat.db2", &ExpectedStatLoadInfo::Instance);
137DB2Storage<ExpectedStatModEntry> sExpectedStatModStore("ExpectedStatMod.db2", &ExpectedStatModLoadInfo::Instance);
138DB2Storage<FactionEntry> sFactionStore("Faction.db2", &FactionLoadInfo::Instance);
139DB2Storage<FactionTemplateEntry> sFactionTemplateStore("FactionTemplate.db2", &FactionTemplateLoadInfo::Instance);
140DB2Storage<FriendshipRepReactionEntry> sFriendshipRepReactionStore("FriendshipRepReaction.db2", &FriendshipRepReactionLoadInfo::Instance);
141DB2Storage<FriendshipReputationEntry> sFriendshipReputationStore("FriendshipReputation.db2", &FriendshipReputationLoadInfo::Instance);
142DB2Storage<GameObjectArtKitEntry> sGameObjectArtKitStore("GameObjectArtKit.db2", &GameobjectArtKitLoadInfo::Instance);
143DB2Storage<GameObjectDisplayInfoEntry> sGameObjectDisplayInfoStore("GameObjectDisplayInfo.db2", &GameobjectDisplayInfoLoadInfo::Instance);
144DB2Storage<GameObjectsEntry> sGameObjectsStore("GameObjects.db2", &GameobjectsLoadInfo::Instance);
145DB2Storage<GarrAbilityEntry> sGarrAbilityStore("GarrAbility.db2", &GarrAbilityLoadInfo::Instance);
146DB2Storage<GarrBuildingEntry> sGarrBuildingStore("GarrBuilding.db2", &GarrBuildingLoadInfo::Instance);
147DB2Storage<GarrBuildingPlotInstEntry> sGarrBuildingPlotInstStore("GarrBuildingPlotInst.db2", &GarrBuildingPlotInstLoadInfo::Instance);
148DB2Storage<GarrClassSpecEntry> sGarrClassSpecStore("GarrClassSpec.db2", &GarrClassSpecLoadInfo::Instance);
149DB2Storage<GarrFollowerEntry> sGarrFollowerStore("GarrFollower.db2", &GarrFollowerLoadInfo::Instance);
150DB2Storage<GarrFollowerXAbilityEntry> sGarrFollowerXAbilityStore("GarrFollowerXAbility.db2", &GarrFollowerXAbilityLoadInfo::Instance);
151DB2Storage<GarrMissionEntry> sGarrMissionStore("GarrMission.db2", &GarrMissionLoadInfo::Instance);
152DB2Storage<GarrPlotEntry> sGarrPlotStore("GarrPlot.db2", &GarrPlotLoadInfo::Instance);
153DB2Storage<GarrPlotBuildingEntry> sGarrPlotBuildingStore("GarrPlotBuilding.db2", &GarrPlotBuildingLoadInfo::Instance);
154DB2Storage<GarrPlotInstanceEntry> sGarrPlotInstanceStore("GarrPlotInstance.db2", &GarrPlotInstanceLoadInfo::Instance);
155DB2Storage<GarrSiteLevelEntry> sGarrSiteLevelStore("GarrSiteLevel.db2", &GarrSiteLevelLoadInfo::Instance);
156DB2Storage<GarrSiteLevelPlotInstEntry> sGarrSiteLevelPlotInstStore("GarrSiteLevelPlotInst.db2", &GarrSiteLevelPlotInstLoadInfo::Instance);
157DB2Storage<GarrTalentTreeEntry> sGarrTalentTreeStore("GarrTalentTree.db2", &GarrTalentTreeLoadInfo::Instance);
158DB2Storage<GemPropertiesEntry> sGemPropertiesStore("GemProperties.db2", &GemPropertiesLoadInfo::Instance);
159DB2Storage<GlobalCurveEntry> sGlobalCurveStore("GlobalCurve.db2", &GlobalCurveLoadInfo::Instance);
160DB2Storage<GlyphBindableSpellEntry> sGlyphBindableSpellStore("GlyphBindableSpell.db2", &GlyphBindableSpellLoadInfo::Instance);
161DB2Storage<GlyphPropertiesEntry> sGlyphPropertiesStore("GlyphProperties.db2", &GlyphPropertiesLoadInfo::Instance);
162DB2Storage<GlyphRequiredSpecEntry> sGlyphRequiredSpecStore("GlyphRequiredSpec.db2", &GlyphRequiredSpecLoadInfo::Instance);
163DB2Storage<GossipNPCOptionEntry> sGossipNPCOptionStore("GossipNPCOption.db2", &GossipNpcOptionLoadInfo::Instance);
164DB2Storage<GuildColorBackgroundEntry> sGuildColorBackgroundStore("GuildColorBackground.db2", &GuildColorBackgroundLoadInfo::Instance);
165DB2Storage<GuildColorBorderEntry> sGuildColorBorderStore("GuildColorBorder.db2", &GuildColorBorderLoadInfo::Instance);
166DB2Storage<GuildColorEmblemEntry> sGuildColorEmblemStore("GuildColorEmblem.db2", &GuildColorEmblemLoadInfo::Instance);
167DB2Storage<GuildPerkSpellsEntry> sGuildPerkSpellsStore("GuildPerkSpells.db2", &GuildPerkSpellsLoadInfo::Instance);
168DB2Storage<HeirloomEntry> sHeirloomStore("Heirloom.db2", &HeirloomLoadInfo::Instance);
169DB2Storage<HolidaysEntry> sHolidaysStore("Holidays.db2", &HolidaysLoadInfo::Instance);
170DB2Storage<ImportPriceArmorEntry> sImportPriceArmorStore("ImportPriceArmor.db2", &ImportPriceArmorLoadInfo::Instance);
171DB2Storage<ImportPriceQualityEntry> sImportPriceQualityStore("ImportPriceQuality.db2", &ImportPriceQualityLoadInfo::Instance);
172DB2Storage<ImportPriceShieldEntry> sImportPriceShieldStore("ImportPriceShield.db2", &ImportPriceShieldLoadInfo::Instance);
173DB2Storage<ImportPriceWeaponEntry> sImportPriceWeaponStore("ImportPriceWeapon.db2", &ImportPriceWeaponLoadInfo::Instance);
174DB2Storage<ItemAppearanceEntry> sItemAppearanceStore("ItemAppearance.db2", &ItemAppearanceLoadInfo::Instance);
175DB2Storage<ItemArmorQualityEntry> sItemArmorQualityStore("ItemArmorQuality.db2", &ItemArmorQualityLoadInfo::Instance);
176DB2Storage<ItemArmorShieldEntry> sItemArmorShieldStore("ItemArmorShield.db2", &ItemArmorShieldLoadInfo::Instance);
177DB2Storage<ItemArmorTotalEntry> sItemArmorTotalStore("ItemArmorTotal.db2", &ItemArmorTotalLoadInfo::Instance);
178DB2Storage<ItemBagFamilyEntry> sItemBagFamilyStore("ItemBagFamily.db2", &ItemBagFamilyLoadInfo::Instance);
179DB2Storage<ItemBonusEntry> sItemBonusStore("ItemBonus.db2", &ItemBonusLoadInfo::Instance);
180DB2Storage<ItemBonusListGroupEntryEntry> sItemBonusListGroupEntryStore("ItemBonusListGroupEntry.db2", &ItemBonusListGroupEntryLoadInfo::Instance);
181DB2Storage<ItemBonusListLevelDeltaEntry> sItemBonusListLevelDeltaStore("ItemBonusListLevelDelta.db2", &ItemBonusListLevelDeltaLoadInfo::Instance);
182DB2Storage<ItemBonusTreeEntry> sItemBonusTreeStore("ItemBonusTree.db2", &ItemBonusTreeLoadInfo::Instance);
183DB2Storage<ItemBonusTreeNodeEntry> sItemBonusTreeNodeStore("ItemBonusTreeNode.db2", &ItemBonusTreeNodeLoadInfo::Instance);
184DB2Storage<ItemChildEquipmentEntry> sItemChildEquipmentStore("ItemChildEquipment.db2", &ItemChildEquipmentLoadInfo::Instance);
185DB2Storage<ItemClassEntry> sItemClassStore("ItemClass.db2", &ItemClassLoadInfo::Instance);
186DB2Storage<ItemContextPickerEntryEntry> sItemContextPickerEntryStore("ItemContextPickerEntry.db2", &ItemContextPickerEntryLoadInfo::Instance);
187DB2Storage<ItemCurrencyCostEntry> sItemCurrencyCostStore("ItemCurrencyCost.db2", &ItemCurrencyCostLoadInfo::Instance);
188DB2Storage<ItemDamageAmmoEntry> sItemDamageAmmoStore("ItemDamageAmmo.db2", &ItemDamageAmmoLoadInfo::Instance);
189DB2Storage<ItemDamageOneHandEntry> sItemDamageOneHandStore("ItemDamageOneHand.db2", &ItemDamageOneHandLoadInfo::Instance);
190DB2Storage<ItemDamageOneHandCasterEntry> sItemDamageOneHandCasterStore("ItemDamageOneHandCaster.db2", &ItemDamageOneHandCasterLoadInfo::Instance);
191DB2Storage<ItemDamageTwoHandEntry> sItemDamageTwoHandStore("ItemDamageTwoHand.db2", &ItemDamageTwoHandLoadInfo::Instance);
192DB2Storage<ItemDamageTwoHandCasterEntry> sItemDamageTwoHandCasterStore("ItemDamageTwoHandCaster.db2", &ItemDamageTwoHandCasterLoadInfo::Instance);
193DB2Storage<ItemDisenchantLootEntry> sItemDisenchantLootStore("ItemDisenchantLoot.db2", &ItemDisenchantLootLoadInfo::Instance);
194DB2Storage<ItemEffectEntry> sItemEffectStore("ItemEffect.db2", &ItemEffectLoadInfo::Instance);
195DB2Storage<ItemEntry> sItemStore("Item.db2", &ItemLoadInfo::Instance);
196DB2Storage<ItemExtendedCostEntry> sItemExtendedCostStore("ItemExtendedCost.db2", &ItemExtendedCostLoadInfo::Instance);
197DB2Storage<ItemLevelSelectorEntry> sItemLevelSelectorStore("ItemLevelSelector.db2", &ItemLevelSelectorLoadInfo::Instance);
198DB2Storage<ItemLevelSelectorQualityEntry> sItemLevelSelectorQualityStore("ItemLevelSelectorQuality.db2", &ItemLevelSelectorQualityLoadInfo::Instance);
199DB2Storage<ItemLevelSelectorQualitySetEntry> sItemLevelSelectorQualitySetStore("ItemLevelSelectorQualitySet.db2", &ItemLevelSelectorQualitySetLoadInfo::Instance);
200DB2Storage<ItemLimitCategoryEntry> sItemLimitCategoryStore("ItemLimitCategory.db2", &ItemLimitCategoryLoadInfo::Instance);
201DB2Storage<ItemLimitCategoryConditionEntry> sItemLimitCategoryConditionStore("ItemLimitCategoryCondition.db2", &ItemLimitCategoryConditionLoadInfo::Instance);
202DB2Storage<ItemModifiedAppearanceEntry> sItemModifiedAppearanceStore("ItemModifiedAppearance.db2", &ItemModifiedAppearanceLoadInfo::Instance);
203DB2Storage<ItemModifiedAppearanceExtraEntry> sItemModifiedAppearanceExtraStore("ItemModifiedAppearanceExtra.db2", &ItemModifiedAppearanceExtraLoadInfo::Instance);
204DB2Storage<ItemNameDescriptionEntry> sItemNameDescriptionStore("ItemNameDescription.db2", &ItemNameDescriptionLoadInfo::Instance);
205DB2Storage<ItemPriceBaseEntry> sItemPriceBaseStore("ItemPriceBase.db2", &ItemPriceBaseLoadInfo::Instance);
206DB2Storage<ItemSearchNameEntry> sItemSearchNameStore("ItemSearchName.db2", &ItemSearchNameLoadInfo::Instance);
207DB2Storage<ItemSetEntry> sItemSetStore("ItemSet.db2", &ItemSetLoadInfo::Instance);
208DB2Storage<ItemSetSpellEntry> sItemSetSpellStore("ItemSetSpell.db2", &ItemSetSpellLoadInfo::Instance);
209DB2Storage<ItemSparseEntry> sItemSparseStore("ItemSparse.db2", &ItemSparseLoadInfo::Instance);
210DB2Storage<ItemSpecEntry> sItemSpecStore("ItemSpec.db2", &ItemSpecLoadInfo::Instance);
211DB2Storage<ItemSpecOverrideEntry> sItemSpecOverrideStore("ItemSpecOverride.db2", &ItemSpecOverrideLoadInfo::Instance);
212DB2Storage<ItemXBonusTreeEntry> sItemXBonusTreeStore("ItemXBonusTree.db2", &ItemXBonusTreeLoadInfo::Instance);
213DB2Storage<ItemXItemEffectEntry> sItemXItemEffectStore("ItemXItemEffect.db2", &ItemXItemEffectLoadInfo::Instance);
214DB2Storage<JournalEncounterEntry> sJournalEncounterStore("JournalEncounter.db2", &JournalEncounterLoadInfo::Instance);
215DB2Storage<JournalEncounterSectionEntry> sJournalEncounterSectionStore("JournalEncounterSection.db2", &JournalEncounterSectionLoadInfo::Instance);
216DB2Storage<JournalInstanceEntry> sJournalInstanceStore("JournalInstance.db2", &JournalInstanceLoadInfo::Instance);
217DB2Storage<JournalTierEntry> sJournalTierStore("JournalTier.db2", &JournalTierLoadInfo::Instance);
218DB2Storage<KeychainEntry> sKeychainStore("Keychain.db2", &KeychainLoadInfo::Instance);
219DB2Storage<KeystoneAffixEntry> sKeystoneAffixStore("KeystoneAffix.db2", &KeystoneAffixLoadInfo::Instance);
220DB2Storage<LanguageWordsEntry> sLanguageWordsStore("LanguageWords.db2", &LanguageWordsLoadInfo::Instance);
221DB2Storage<LanguagesEntry> sLanguagesStore("Languages.db2", &LanguagesLoadInfo::Instance);
222DB2Storage<LFGDungeonsEntry> sLFGDungeonsStore("LFGDungeons.db2", &LfgDungeonsLoadInfo::Instance);
223DB2Storage<LightEntry> sLightStore("Light.db2", &LightLoadInfo::Instance);
224DB2Storage<LiquidTypeEntry> sLiquidTypeStore("LiquidType.db2", &LiquidTypeLoadInfo::Instance);
225DB2Storage<LockEntry> sLockStore("Lock.db2", &LockLoadInfo::Instance);
226DB2Storage<MailTemplateEntry> sMailTemplateStore("MailTemplate.db2", &MailTemplateLoadInfo::Instance);
227DB2Storage<MapEntry> sMapStore("Map.db2", &MapLoadInfo::Instance);
228DB2Storage<MapChallengeModeEntry> sMapChallengeModeStore("MapChallengeMode.db2", &MapChallengeModeLoadInfo::Instance);
229DB2Storage<MapDifficultyEntry> sMapDifficultyStore("MapDifficulty.db2", &MapDifficultyLoadInfo::Instance);
230DB2Storage<MapDifficultyXConditionEntry> sMapDifficultyXConditionStore("MapDifficultyXCondition.db2", &MapDifficultyXConditionLoadInfo::Instance);
231DB2Storage<MawPowerEntry> sMawPowerStore("MawPower.db2", &MawPowerLoadInfo::Instance);
232DB2Storage<ModifierTreeEntry> sModifierTreeStore("ModifierTree.db2", &ModifierTreeLoadInfo::Instance);
233DB2Storage<MountCapabilityEntry> sMountCapabilityStore("MountCapability.db2", &MountCapabilityLoadInfo::Instance);
234DB2Storage<MountEntry> sMountStore("Mount.db2", &MountLoadInfo::Instance);
235DB2Storage<MountTypeXCapabilityEntry> sMountTypeXCapabilityStore("MountTypeXCapability.db2", &MountTypeXCapabilityLoadInfo::Instance);
236DB2Storage<MountXDisplayEntry> sMountXDisplayStore("MountXDisplay.db2", &MountXDisplayLoadInfo::Instance);
237DB2Storage<MovieEntry> sMovieStore("Movie.db2", &MovieLoadInfo::Instance);
238DB2Storage<MythicPlusSeasonEntry> sMythicPlusSeasonStore("MythicPlusSeason.db2", &MythicPlusSeasonLoadInfo::Instance);
239DB2Storage<NameGenEntry> sNameGenStore("NameGen.db2", &NameGenLoadInfo::Instance);
240DB2Storage<NamesProfanityEntry> sNamesProfanityStore("NamesProfanity.db2", &NamesProfanityLoadInfo::Instance);
241DB2Storage<NamesReservedEntry> sNamesReservedStore("NamesReserved.db2", &NamesReservedLoadInfo::Instance);
242DB2Storage<NamesReservedLocaleEntry> sNamesReservedLocaleStore("NamesReservedLocale.db2", &NamesReservedLocaleLoadInfo::Instance);
243DB2Storage<NumTalentsAtLevelEntry> sNumTalentsAtLevelStore("NumTalentsAtLevel.db2", &NumTalentsAtLevelLoadInfo::Instance);
244DB2Storage<OverrideSpellDataEntry> sOverrideSpellDataStore("OverrideSpellData.db2", &OverrideSpellDataLoadInfo::Instance);
245DB2Storage<ParagonReputationEntry> sParagonReputationStore("ParagonReputation.db2", &ParagonReputationLoadInfo::Instance);
246DB2Storage<PhaseEntry> sPhaseStore("Phase.db2", &PhaseLoadInfo::Instance);
247DB2Storage<PhaseXPhaseGroupEntry> sPhaseXPhaseGroupStore("PhaseXPhaseGroup.db2", &PhaseXPhaseGroupLoadInfo::Instance);
248DB2Storage<PlayerConditionEntry> sPlayerConditionStore("PlayerCondition.db2", &PlayerConditionLoadInfo::Instance);
249DB2Storage<PowerDisplayEntry> sPowerDisplayStore("PowerDisplay.db2", &PowerDisplayLoadInfo::Instance);
250DB2Storage<PowerTypeEntry> sPowerTypeStore("PowerType.db2", &PowerTypeLoadInfo::Instance);
251DB2Storage<PrestigeLevelInfoEntry> sPrestigeLevelInfoStore("PrestigeLevelInfo.db2", &PrestigeLevelInfoLoadInfo::Instance);
252DB2Storage<PVPDifficultyEntry> sPVPDifficultyStore("PVPDifficulty.db2", &PvpDifficultyLoadInfo::Instance);
253DB2Storage<PVPItemEntry> sPVPItemStore("PVPItem.db2", &PvpItemLoadInfo::Instance);
254DB2Storage<PVPStatEntry> sPVPStatStore("PVPStat.db2", &PvpStatLoadInfo::Instance);
255DB2Storage<PvpSeasonEntry> sPvpSeasonStore("PvpSeason.db2", &PvpSeasonLoadInfo::Instance);
256DB2Storage<PvpTalentEntry> sPvpTalentStore("PvpTalent.db2", &PvpTalentLoadInfo::Instance);
257DB2Storage<PvpTalentCategoryEntry> sPvpTalentCategoryStore("PvpTalentCategory.db2", &PvpTalentCategoryLoadInfo::Instance);
258DB2Storage<PvpTalentSlotUnlockEntry> sPvpTalentSlotUnlockStore("PvpTalentSlotUnlock.db2", &PvpTalentSlotUnlockLoadInfo::Instance);
259DB2Storage<PvpTierEntry> sPvpTierStore("PvpTier.db2", &PvpTierLoadInfo::Instance);
260DB2Storage<QuestFactionRewardEntry> sQuestFactionRewardStore("QuestFactionReward.db2", &QuestFactionRewardLoadInfo::Instance);
261DB2Storage<QuestInfoEntry> sQuestInfoStore("QuestInfo.db2", &QuestInfoLoadInfo::Instance);
262DB2Storage<QuestLineXQuestEntry> sQuestLineXQuestStore("QuestLineXQuest.db2", &QuestLineXQuestLoadInfo::Instance);
263DB2Storage<QuestMoneyRewardEntry> sQuestMoneyRewardStore("QuestMoneyReward.db2", &QuestMoneyRewardLoadInfo::Instance);
264DB2Storage<QuestPackageItemEntry> sQuestPackageItemStore("QuestPackageItem.db2", &QuestPackageItemLoadInfo::Instance);
265DB2Storage<QuestSortEntry> sQuestSortStore("QuestSort.db2", &QuestSortLoadInfo::Instance);
266DB2Storage<QuestV2Entry> sQuestV2Store("QuestV2.db2", &QuestV2LoadInfo::Instance);
267DB2Storage<QuestXPEntry> sQuestXPStore("QuestXP.db2", &QuestXpLoadInfo::Instance);
268DB2Storage<RandPropPointsEntry> sRandPropPointsStore("RandPropPoints.db2", &RandPropPointsLoadInfo::Instance);
269DB2Storage<RewardPackEntry> sRewardPackStore("RewardPack.db2", &RewardPackLoadInfo::Instance);
270DB2Storage<RewardPackXCurrencyTypeEntry> sRewardPackXCurrencyTypeStore("RewardPackXCurrencyType.db2", &RewardPackXCurrencyTypeLoadInfo::Instance);
271DB2Storage<RewardPackXItemEntry> sRewardPackXItemStore("RewardPackXItem.db2", &RewardPackXItemLoadInfo::Instance);
272DB2Storage<ScenarioEntry> sScenarioStore("Scenario.db2", &ScenarioLoadInfo::Instance);
273DB2Storage<ScenarioStepEntry> sScenarioStepStore("ScenarioStep.db2", &ScenarioStepLoadInfo::Instance);
274DB2Storage<SceneScriptEntry> sSceneScriptStore("SceneScript.db2", &SceneScriptLoadInfo::Instance);
275DB2Storage<SceneScriptGlobalTextEntry> sSceneScriptGlobalTextStore("SceneScriptGlobalText.db2", &SceneScriptGlobalTextLoadInfo::Instance);
276DB2Storage<SceneScriptPackageEntry> sSceneScriptPackageStore("SceneScriptPackage.db2", &SceneScriptPackageLoadInfo::Instance);
277DB2Storage<SceneScriptTextEntry> sSceneScriptTextStore("SceneScriptText.db2", &SceneScriptTextLoadInfo::Instance);
278DB2Storage<ServerMessagesEntry> sServerMessagesStore("ServerMessages.db2", &ServerMessagesLoadInfo::Instance);
279DB2Storage<SkillLineEntry> sSkillLineStore("SkillLine.db2", &SkillLineLoadInfo::Instance);
280DB2Storage<SkillLineAbilityEntry> sSkillLineAbilityStore("SkillLineAbility.db2", &SkillLineAbilityLoadInfo::Instance);
281DB2Storage<SkillLineXTraitTreeEntry> sSkillLineXTraitTreeStore("SkillLineXTraitTree.db2", &SkillLineXTraitTreeLoadInfo::Instance);
282DB2Storage<SkillRaceClassInfoEntry> sSkillRaceClassInfoStore("SkillRaceClassInfo.db2", &SkillRaceClassInfoLoadInfo::Instance);
283DB2Storage<SoulbindConduitRankEntry> sSoulbindConduitRankStore("SoulbindConduitRank.db2", &SoulbindConduitRankLoadInfo::Instance);
284DB2Storage<SoundKitEntry> sSoundKitStore("SoundKit.db2", &SoundKitLoadInfo::Instance);
285DB2Storage<SpecializationSpellsEntry> sSpecializationSpellsStore("SpecializationSpells.db2", &SpecializationSpellsLoadInfo::Instance);
286DB2Storage<SpecSetMemberEntry> sSpecSetMemberStore("SpecSetMember.db2", &SpecSetMemberLoadInfo::Instance);
287DB2Storage<SpellAuraOptionsEntry> sSpellAuraOptionsStore("SpellAuraOptions.db2", &SpellAuraOptionsLoadInfo::Instance);
288DB2Storage<SpellAuraRestrictionsEntry> sSpellAuraRestrictionsStore("SpellAuraRestrictions.db2", &SpellAuraRestrictionsLoadInfo::Instance);
289DB2Storage<SpellCastTimesEntry> sSpellCastTimesStore("SpellCastTimes.db2", &SpellCastTimesLoadInfo::Instance);
290DB2Storage<SpellCastingRequirementsEntry> sSpellCastingRequirementsStore("SpellCastingRequirements.db2", &SpellCastingRequirementsLoadInfo::Instance);
291DB2Storage<SpellCategoriesEntry> sSpellCategoriesStore("SpellCategories.db2", &SpellCategoriesLoadInfo::Instance);
292DB2Storage<SpellCategoryEntry> sSpellCategoryStore("SpellCategory.db2", &SpellCategoryLoadInfo::Instance);
293DB2Storage<SpellClassOptionsEntry> sSpellClassOptionsStore("SpellClassOptions.db2", &SpellClassOptionsLoadInfo::Instance);
294DB2Storage<SpellCooldownsEntry> sSpellCooldownsStore("SpellCooldowns.db2", &SpellCooldownsLoadInfo::Instance);
295DB2Storage<SpellDurationEntry> sSpellDurationStore("SpellDuration.db2", &SpellDurationLoadInfo::Instance);
296DB2Storage<SpellEffectEntry> sSpellEffectStore("SpellEffect.db2", &SpellEffectLoadInfo::Instance);
297DB2Storage<SpellEquippedItemsEntry> sSpellEquippedItemsStore("SpellEquippedItems.db2", &SpellEquippedItemsLoadInfo::Instance);
298DB2Storage<SpellFocusObjectEntry> sSpellFocusObjectStore("SpellFocusObject.db2", &SpellFocusObjectLoadInfo::Instance);
299DB2Storage<SpellInterruptsEntry> sSpellInterruptsStore("SpellInterrupts.db2", &SpellInterruptsLoadInfo::Instance);
300DB2Storage<SpellItemEnchantmentEntry> sSpellItemEnchantmentStore("SpellItemEnchantment.db2", &SpellItemEnchantmentLoadInfo::Instance);
301DB2Storage<SpellItemEnchantmentConditionEntry> sSpellItemEnchantmentConditionStore("SpellItemEnchantmentCondition.db2", &SpellItemEnchantmentConditionLoadInfo::Instance);
302DB2Storage<SpellKeyboundOverrideEntry> sSpellKeyboundOverrideStore("SpellKeyboundOverride.db2", &SpellKeyboundOverrideLoadInfo::Instance);
303DB2Storage<SpellLabelEntry> sSpellLabelStore("SpellLabel.db2", &SpellLabelLoadInfo::Instance);
304DB2Storage<SpellLearnSpellEntry> sSpellLearnSpellStore("SpellLearnSpell.db2", &SpellLearnSpellLoadInfo::Instance);
305DB2Storage<SpellLevelsEntry> sSpellLevelsStore("SpellLevels.db2", &SpellLevelsLoadInfo::Instance);
306DB2Storage<SpellMiscEntry> sSpellMiscStore("SpellMisc.db2", &SpellMiscLoadInfo::Instance);
307DB2Storage<SpellNameEntry> sSpellNameStore("SpellName.db2", &SpellNameLoadInfo::Instance);
308DB2Storage<SpellPowerEntry> sSpellPowerStore("SpellPower.db2", &SpellPowerLoadInfo::Instance);
309DB2Storage<SpellPowerDifficultyEntry> sSpellPowerDifficultyStore("SpellPowerDifficulty.db2", &SpellPowerDifficultyLoadInfo::Instance);
310DB2Storage<SpellProcsPerMinuteEntry> sSpellProcsPerMinuteStore("SpellProcsPerMinute.db2", &SpellProcsPerMinuteLoadInfo::Instance);
311DB2Storage<SpellProcsPerMinuteModEntry> sSpellProcsPerMinuteModStore("SpellProcsPerMinuteMod.db2", &SpellProcsPerMinuteModLoadInfo::Instance);
312DB2Storage<SpellRadiusEntry> sSpellRadiusStore("SpellRadius.db2", &SpellRadiusLoadInfo::Instance);
313DB2Storage<SpellRangeEntry> sSpellRangeStore("SpellRange.db2", &SpellRangeLoadInfo::Instance);
314DB2Storage<SpellReagentsEntry> sSpellReagentsStore("SpellReagents.db2", &SpellReagentsLoadInfo::Instance);
315DB2Storage<SpellReagentsCurrencyEntry> sSpellReagentsCurrencyStore("SpellReagentsCurrency.db2", &SpellReagentsCurrencyLoadInfo::Instance);
316DB2Storage<SpellScalingEntry> sSpellScalingStore("SpellScaling.db2", &SpellScalingLoadInfo::Instance);
317DB2Storage<SpellShapeshiftEntry> sSpellShapeshiftStore("SpellShapeshift.db2", &SpellShapeshiftLoadInfo::Instance);
318DB2Storage<SpellShapeshiftFormEntry> sSpellShapeshiftFormStore("SpellShapeshiftForm.db2", &SpellShapeshiftFormLoadInfo::Instance);
319DB2Storage<SpellTargetRestrictionsEntry> sSpellTargetRestrictionsStore("SpellTargetRestrictions.db2", &SpellTargetRestrictionsLoadInfo::Instance);
320DB2Storage<SpellTotemsEntry> sSpellTotemsStore("SpellTotems.db2", &SpellTotemsLoadInfo::Instance);
321DB2Storage<SpellVisualEntry> sSpellVisualStore("SpellVisual.db2", &SpellVisualLoadInfo::Instance);
322DB2Storage<SpellVisualEffectNameEntry> sSpellVisualEffectNameStore("SpellVisualEffectName.db2", &SpellVisualEffectNameLoadInfo::Instance);
323DB2Storage<SpellVisualMissileEntry> sSpellVisualMissileStore("SpellVisualMissile.db2", &SpellVisualMissileLoadInfo::Instance);
324DB2Storage<SpellVisualKitEntry> sSpellVisualKitStore("SpellVisualKit.db2", &SpellVisualKitLoadInfo::Instance);
325DB2Storage<SpellXSpellVisualEntry> sSpellXSpellVisualStore("SpellXSpellVisual.db2", &SpellXSpellVisualLoadInfo::Instance);
326DB2Storage<SummonPropertiesEntry> sSummonPropertiesStore("SummonProperties.db2", &SummonPropertiesLoadInfo::Instance);
327DB2Storage<TactKeyEntry> sTactKeyStore("TactKey.db2", &TactKeyLoadInfo::Instance);
328DB2Storage<TalentEntry> sTalentStore("Talent.db2", &TalentLoadInfo::Instance);
329DB2Storage<TaxiNodesEntry> sTaxiNodesStore("TaxiNodes.db2", &TaxiNodesLoadInfo::Instance);
330DB2Storage<TaxiPathEntry> sTaxiPathStore("TaxiPath.db2", &TaxiPathLoadInfo::Instance);
331DB2Storage<TaxiPathNodeEntry> sTaxiPathNodeStore("TaxiPathNode.db2", &TaxiPathNodeLoadInfo::Instance);
332DB2Storage<TotemCategoryEntry> sTotemCategoryStore("TotemCategory.db2", &TotemCategoryLoadInfo::Instance);
333DB2Storage<ToyEntry> sToyStore("Toy.db2", &ToyLoadInfo::Instance);
334DB2Storage<TraitCondEntry> sTraitCondStore("TraitCond.db2", &TraitCondLoadInfo::Instance);
335DB2Storage<TraitCostEntry> sTraitCostStore("TraitCost.db2", &TraitCostLoadInfo::Instance);
336DB2Storage<TraitCurrencyEntry> sTraitCurrencyStore("TraitCurrency.db2", &TraitCurrencyLoadInfo::Instance);
337DB2Storage<TraitCurrencySourceEntry> sTraitCurrencySourceStore("TraitCurrencySource.db2", &TraitCurrencySourceLoadInfo::Instance);
338DB2Storage<TraitDefinitionEntry> sTraitDefinitionStore("TraitDefinition.db2", &TraitDefinitionLoadInfo::Instance);
339DB2Storage<TraitDefinitionEffectPointsEntry> sTraitDefinitionEffectPointsStore("TraitDefinitionEffectPoints.db2", &TraitDefinitionEffectPointsLoadInfo::Instance);
340DB2Storage<TraitEdgeEntry> sTraitEdgeStore("TraitEdge.db2", &TraitEdgeLoadInfo::Instance);
341DB2Storage<TraitNodeEntry> sTraitNodeStore("TraitNode.db2", &TraitNodeLoadInfo::Instance);
342DB2Storage<TraitNodeEntryEntry> sTraitNodeEntryStore("TraitNodeEntry.db2", &TraitNodeEntryLoadInfo::Instance);
343DB2Storage<TraitNodeEntryXTraitCondEntry> sTraitNodeEntryXTraitCondStore("TraitNodeEntryXTraitCond.db2", &TraitNodeEntryXTraitCondLoadInfo::Instance);
344DB2Storage<TraitNodeEntryXTraitCostEntry> sTraitNodeEntryXTraitCostStore("TraitNodeEntryXTraitCost.db2", &TraitNodeEntryXTraitCostLoadInfo::Instance);
345DB2Storage<TraitNodeGroupEntry> sTraitNodeGroupStore("TraitNodeGroup.db2", &TraitNodeGroupLoadInfo::Instance);
346DB2Storage<TraitNodeGroupXTraitCondEntry> sTraitNodeGroupXTraitCondStore("TraitNodeGroupXTraitCond.db2", &TraitNodeGroupXTraitCondLoadInfo::Instance);
347DB2Storage<TraitNodeGroupXTraitCostEntry> sTraitNodeGroupXTraitCostStore("TraitNodeGroupXTraitCost.db2", &TraitNodeGroupXTraitCostLoadInfo::Instance);
348DB2Storage<TraitNodeGroupXTraitNodeEntry> sTraitNodeGroupXTraitNodeStore("TraitNodeGroupXTraitNode.db2", &TraitNodeGroupXTraitNodeLoadInfo::Instance);
349DB2Storage<TraitNodeXTraitCondEntry> sTraitNodeXTraitCondStore("TraitNodeXTraitCond.db2", &TraitNodeXTraitCondLoadInfo::Instance);
350DB2Storage<TraitNodeXTraitCostEntry> sTraitNodeXTraitCostStore("TraitNodeXTraitCost.db2", &TraitNodeXTraitCostLoadInfo::Instance);
351DB2Storage<TraitNodeXTraitNodeEntryEntry> sTraitNodeXTraitNodeEntryStore("TraitNodeXTraitNodeEntry.db2", &TraitNodeXTraitNodeEntryLoadInfo::Instance);
352DB2Storage<TraitTreeEntry> sTraitTreeStore("TraitTree.db2", &TraitTreeLoadInfo::Instance);
353DB2Storage<TraitTreeLoadoutEntry> sTraitTreeLoadoutStore("TraitTreeLoadout.db2", &TraitTreeLoadoutLoadInfo::Instance);
354DB2Storage<TraitTreeLoadoutEntryEntry> sTraitTreeLoadoutEntryStore("TraitTreeLoadoutEntry.db2", &TraitTreeLoadoutEntryLoadInfo::Instance);
355DB2Storage<TraitTreeXTraitCostEntry> sTraitTreeXTraitCostStore("TraitTreeXTraitCost.db2", &TraitTreeXTraitCostLoadInfo::Instance);
356DB2Storage<TraitTreeXTraitCurrencyEntry> sTraitTreeXTraitCurrencyStore("TraitTreeXTraitCurrency.db2", &TraitTreeXTraitCurrencyLoadInfo::Instance);
357DB2Storage<TransmogHolidayEntry> sTransmogHolidayStore("TransmogHoliday.db2", &TransmogHolidayLoadInfo::Instance);
358DB2Storage<TransmogIllusionEntry> sTransmogIllusionStore("TransmogIllusion.db2", &TransmogIllusionLoadInfo::Instance);
359DB2Storage<TransmogSetEntry> sTransmogSetStore("TransmogSet.db2", &TransmogSetLoadInfo::Instance);
360DB2Storage<TransmogSetGroupEntry> sTransmogSetGroupStore("TransmogSetGroup.db2", &TransmogSetGroupLoadInfo::Instance);
361DB2Storage<TransmogSetItemEntry> sTransmogSetItemStore("TransmogSetItem.db2", &TransmogSetItemLoadInfo::Instance);
362DB2Storage<TransportAnimationEntry> sTransportAnimationStore("TransportAnimation.db2", &TransportAnimationLoadInfo::Instance);
363DB2Storage<TransportRotationEntry> sTransportRotationStore("TransportRotation.db2", &TransportRotationLoadInfo::Instance);
364DB2Storage<UiMapEntry> sUiMapStore("UiMap.db2", &UiMapLoadInfo::Instance);
365DB2Storage<UiMapAssignmentEntry> sUiMapAssignmentStore("UiMapAssignment.db2", &UiMapAssignmentLoadInfo::Instance);
366DB2Storage<UiMapLinkEntry> sUiMapLinkStore("UiMapLink.db2", &UiMapLinkLoadInfo::Instance);
367DB2Storage<UiMapXMapArtEntry> sUiMapXMapArtStore("UiMapXMapArt.db2", &UiMapXMapArtLoadInfo::Instance);
368DB2Storage<UISplashScreenEntry> sUISplashScreenStore("UISplashScreen.db2", &UiSplashScreenLoadInfo::Instance);
369DB2Storage<UnitConditionEntry> sUnitConditionStore("UnitCondition.db2", &UnitConditionLoadInfo::Instance);
370DB2Storage<UnitPowerBarEntry> sUnitPowerBarStore("UnitPowerBar.db2", &UnitPowerBarLoadInfo::Instance);
371DB2Storage<VehicleEntry> sVehicleStore("Vehicle.db2", &VehicleLoadInfo::Instance);
372DB2Storage<VehicleSeatEntry> sVehicleSeatStore("VehicleSeat.db2", &VehicleSeatLoadInfo::Instance);
373DB2Storage<VignetteEntry> sVignetteStore("Vignette.db2", &VignetteLoadInfo::Instance);
374DB2Storage<WMOAreaTableEntry> sWMOAreaTableStore("WMOAreaTable.db2", &WmoAreaTableLoadInfo::Instance);
375DB2Storage<WorldEffectEntry> sWorldEffectStore("WorldEffect.db2", &WorldEffectLoadInfo::Instance);
376DB2Storage<WorldMapOverlayEntry> sWorldMapOverlayStore("WorldMapOverlay.db2", &WorldMapOverlayLoadInfo::Instance);
377DB2Storage<WorldStateExpressionEntry> sWorldStateExpressionStore("WorldStateExpression.db2", &WorldStateExpressionLoadInfo::Instance);
378
379TaxiMask sTaxiNodesMask;
380TaxiMask sOldContinentsNodesMask;
381TaxiMask sHordeTaxiNodesMask;
382TaxiMask sAllianceTaxiNodesMask;
383TaxiPathNodesByPath sTaxiPathNodesByPath;
384
385DEFINE_DB2_SET_COMPARATOR(ChrClassesXPowerTypesEntry)
386
387typedef std::map<uint32 /*hash*/, DB2StorageBase*> StorageMap;
388typedef std::unordered_map<uint32 /*areaGroupId*/, std::vector<uint32/*areaId*/>> AreaGroupMemberContainer;
389typedef std::unordered_map<uint32, std::vector<ArtifactPowerEntry const*>> ArtifactPowersContainer;
390typedef std::unordered_map<uint32, std::vector<uint32>> ArtifactPowerLinksContainer;
391typedef std::unordered_map<std::pair<uint32, uint8>, ArtifactPowerRankEntry const*> ArtifactPowerRanksContainer;
392typedef ChrSpecializationEntry const* ChrSpecializationByIndexContainer[MAX_CLASSES + 1][MAX_SPECIALIZATIONS];
393typedef std::unordered_map<uint32 /*curveID*/, std::vector<DBCPosition2D>> CurvePointsContainer;
394typedef std::map<std::tuple<uint32, uint8, uint8, uint8>, EmotesTextSoundEntry const*> EmotesTextSoundContainer;
395typedef std::unordered_map<uint32, std::vector<uint32>> FactionTeamContainer;
396typedef std::unordered_map<uint32, HeirloomEntry const*> HeirloomItemsContainer;
397typedef std::unordered_map<uint32 /*glyphPropertiesId*/, std::vector<uint32>> GlyphBindableSpellsContainer;
398typedef std::unordered_map<uint32 /*glyphPropertiesId*/, std::vector<ChrSpecialization>> GlyphRequiredSpecsContainer;
399typedef std::unordered_map<uint32 /*itemId*/, ItemChildEquipmentEntry const*> ItemChildEquipmentContainer;
400typedef std::array<ItemClassEntry const*, 20> ItemClassByOldEnumContainer;
401typedef std::unordered_map<uint32, std::vector<ItemLimitCategoryConditionEntry const*>> ItemLimitCategoryConditionContainer;
402typedef std::unordered_map<uint32 /*itemId | appearanceMod << 24*/, ItemModifiedAppearanceEntry const*> ItemModifiedAppearanceByItemContainer;
403typedef std::unordered_map<uint32, std::vector<ItemSetSpellEntry const*>> ItemSetSpellContainer;
404typedef std::unordered_map<uint32, std::vector<ItemSpecOverrideEntry const*>> ItemSpecOverridesContainer;
405typedef std::unordered_map<uint32, std::unordered_map<uint32, MapDifficultyEntry const*>> MapDifficultyContainer;
406typedef std::unordered_map<uint32, DB2Manager::MountTypeXCapabilitySet> MountCapabilitiesByTypeContainer;
407typedef std::unordered_map<uint32, DB2Manager::MountXDisplayContainer> MountDisplaysCointainer;
408typedef std::unordered_map<uint32, std::array<std::vector<NameGenEntry const*>, 2>> NameGenContainer;
409typedef std::array<std::vector<Trinity::wregex>, TOTAL_LOCALES + 1> NameValidationRegexContainer;
410typedef std::unordered_map<uint32, std::vector<uint32>> PhaseGroupContainer;
411typedef std::array<PowerTypeEntry const*, MAX_POWERS> PowerTypesContainer;
412typedef std::unordered_map<uint32, std::pair<std::vector<QuestPackageItemEntry const*>, std::vector<QuestPackageItemEntry const*>>> QuestPackageItemContainer;
413typedef std::unordered_multimap<uint32, SkillRaceClassInfoEntry const*> SkillRaceClassInfoContainer;
414typedef std::unordered_map<uint32, std::vector<SpecializationSpellsEntry const*>> SpecializationSpellsContainer;
415typedef std::unordered_map<uint32, std::vector<SpellPowerEntry const*>> SpellPowerContainer;
416typedef std::unordered_map<uint32, std::unordered_map<uint32, std::vector<SpellPowerEntry const*>>> SpellPowerDifficultyContainer;
417typedef std::unordered_map<uint32, std::vector<SpellProcsPerMinuteModEntry const*>> SpellProcsPerMinuteModContainer;
418typedef std::vector<TalentEntry const*> TalentsByPosition[MAX_CLASSES][MAX_TALENT_TIERS][MAX_TALENT_COLUMNS];
419typedef std::unordered_set<uint32> ToyItemIdsContainer;
420typedef std::tuple<uint16, uint8, int32> WMOAreaTableKey;
421typedef std::map<WMOAreaTableKey, WMOAreaTableEntry const*> WMOAreaTableLookupContainer;
422typedef std::pair<uint32 /*tableHash*/, int32 /*recordId*/> HotfixBlobKey;
423typedef std::map<HotfixBlobKey, std::vector<uint8>> HotfixBlobMap;
424using AllowedHotfixOptionalData = std::pair<uint32 /*optional data key*/, bool(*)(std::vector<uint8> const& data) /*validator*/>;
425
426namespace
427{
428 struct UiMapBounds
429 {
430 // these coords are mixed when calculated and used... its a mess
431 float Bounds[4];
432 bool IsUiAssignment;
433 bool IsUiLink;
434 };
435
436 StorageMap _stores;
437 DB2Manager::HotfixContainer _hotfixData;
438 std::array<HotfixBlobMap, TOTAL_LOCALES> _hotfixBlob;
439 std::unordered_multimap<uint32 /*tableHash*/, AllowedHotfixOptionalData> _allowedHotfixOptionalData;
440 std::array<std::map<HotfixBlobKey, std::vector<DB2Manager::HotfixOptionalData>>, TOTAL_LOCALES> _hotfixOptionalData;
441
442 AreaGroupMemberContainer _areaGroupMembers;
443 ArtifactPowersContainer _artifactPowers;
444 ArtifactPowerLinksContainer _artifactPowerLinks;
445 ArtifactPowerRanksContainer _artifactPowerRanks;
446 std::unordered_map<uint32 /*itemId*/, AzeriteEmpoweredItemEntry const*> _azeriteEmpoweredItems;
447 std::unordered_map<std::pair<uint32 /*azeriteEssenceId*/, uint32 /*rank*/>, AzeriteEssencePowerEntry const*> _azeriteEssencePowersByIdAndRank;
448 std::vector<AzeriteItemMilestonePowerEntry const*> _azeriteItemMilestonePowers;
449 std::array<AzeriteItemMilestonePowerEntry const*, MAX_AZERITE_ESSENCE_SLOT> _azeriteItemMilestonePowerByEssenceSlot;
450 std::unordered_map<uint32 /*azeritePowerSetId*/, std::vector<AzeritePowerSetMemberEntry const*>> _azeritePowers;
451 std::unordered_map<std::pair<uint32 /*azeriteUnlockSetId*/, ItemContext>, std::array<uint8, MAX_AZERITE_EMPOWERED_TIER>> _azeriteTierUnlockLevels;
452 std::unordered_map<std::pair<int32 /*broadcastTextId*/, CascLocaleBit /*cascLocaleBit*/>, int32> _broadcastTextDurations;
453 std::array<ChrClassUIDisplayEntry const*, MAX_CLASSES> _uiDisplayByClass;
454 std::array<std::array<uint32, MAX_POWERS>, MAX_CLASSES> _powersByClass;
455 std::unordered_map<uint32 /*chrCustomizationOptionId*/, std::vector<ChrCustomizationChoiceEntry const*>> _chrCustomizationChoicesByOption;
456 std::unordered_map<std::pair<uint8, uint8>, ChrModelEntry const*> _chrModelsByRaceAndGender;
457 std::map<std::tuple<uint8 /*race*/, uint8/*gender*/, uint8/*shapeshift*/>, ShapeshiftFormModelData> _chrCustomizationChoicesForShapeshifts;
458 std::unordered_map<std::pair<uint8 /*race*/, uint8/*gender*/>, std::vector<ChrCustomizationOptionEntry const*>> _chrCustomizationOptionsByRaceAndGender;
459 std::unordered_map<uint32 /*chrCustomizationReqId*/, std::vector<std::pair<uint32 /*chrCustomizationOptionId*/, std::vector<uint32>>>> _chrCustomizationRequiredChoices;
460 ChrSpecializationByIndexContainer _chrSpecializationsByIndex;
461 std::unordered_map<int32, ConditionalChrModelEntry const*> _conditionalChrModelsByChrModelId;
462 std::unordered_multimap<uint32, ConditionalContentTuningEntry const*> _conditionalContentTuning;
463 std::unordered_set<std::pair<uint32, int32>> _contentTuningLabels;
464 std::unordered_multimap<uint32, CurrencyContainerEntry const*> _currencyContainers;
465 CurvePointsContainer _curvePoints;
466 EmotesTextSoundContainer _emoteTextSounds;
467 std::unordered_map<std::pair<uint32 /*level*/, int32 /*expansion*/>, ExpectedStatEntry const*> _expectedStatsByLevel;
468 std::unordered_map<uint32 /*contentTuningId*/, std::vector<ContentTuningXExpectedEntry const*>> _expectedStatModsByContentTuning;
469 FactionTeamContainer _factionTeams;
470 std::unordered_map<uint32, std::set<FriendshipRepReactionEntry const*, DB2Manager::FriendshipRepReactionEntryComparator>> _friendshipRepReactions;
471 HeirloomItemsContainer _heirlooms;
472 GlyphBindableSpellsContainer _glyphBindableSpells;
473 GlyphRequiredSpecsContainer _glyphRequiredSpecs;
474 ItemChildEquipmentContainer _itemChildEquipment;
475 ItemClassByOldEnumContainer _itemClassByOldEnum;
476 std::unordered_set<uint32> _itemsWithCurrencyCost;
477 ItemLimitCategoryConditionContainer _itemCategoryConditions;
478 ItemModifiedAppearanceByItemContainer _itemModifiedAppearancesByItem;
479 ItemSetSpellContainer _itemSetSpells;
480 ItemSpecOverridesContainer _itemSpecOverrides;
481 std::vector<JournalTierEntry const*> _journalTiersByIndex;
482 MapDifficultyContainer _mapDifficulties;
483 std::unordered_map<uint32, DB2Manager::MapDifficultyConditionsContainer> _mapDifficultyConditions;
484 std::unordered_map<uint32, MountEntry const*> _mountsBySpellId;
485 MountCapabilitiesByTypeContainer _mountCapabilitiesByType;
486 MountDisplaysCointainer _mountDisplays;
487 NameGenContainer _nameGenData;
488 NameValidationRegexContainer _nameValidators;
489 std::unordered_map<uint32, ParagonReputationEntry const*> _paragonReputations;
490 PhaseGroupContainer _phasesByGroup;
491 PowerTypesContainer _powerTypes;
492 std::unordered_map<uint32, uint8> _pvpItemBonus;
493 PvpTalentSlotUnlockEntry const* _pvpTalentSlotUnlock[MAX_PVP_TALENT_SLOTS];
494 std::unordered_map<uint32, std::vector<QuestLineXQuestEntry const*>> _questsByQuestLine;
495 QuestPackageItemContainer _questPackages;
496 std::unordered_map<uint32, std::vector<RewardPackXCurrencyTypeEntry const*>> _rewardPackCurrencyTypes;
497 std::unordered_map<uint32, std::vector<RewardPackXItemEntry const*>> _rewardPackItems;
498 std::unordered_map<uint32, std::vector<SkillLineEntry const*>> _skillLinesByParentSkillLine;
499 std::unordered_map<uint32, std::vector<SkillLineAbilityEntry const*>> _skillLineAbilitiesBySkillupSkill;
500 SkillRaceClassInfoContainer _skillRaceClassInfoBySkill;
501 std::unordered_map<std::pair<int32, int32>, SoulbindConduitRankEntry const*> _soulbindConduitRanks;
502 SpecializationSpellsContainer _specializationSpellsBySpec;
503 std::unordered_set<std::pair<int32, uint32>> _specsBySpecSet;
504 std::unordered_set<uint8> _spellFamilyNames;
505 SpellProcsPerMinuteModContainer _spellProcsPerMinuteMods;
506 std::unordered_map<int32, std::vector<SpellVisualMissileEntry const*>> _spellVisualMissilesBySet;
507 TalentsByPosition _talentsByPosition;
508 std::unordered_map<std::pair<uint32, uint32>, TaxiPathEntry const*> _taxiPaths;
509 ToyItemIdsContainer _toys;
510 std::unordered_map<uint32, TransmogIllusionEntry const*> _transmogIllusionsByEnchantmentId;
511 std::unordered_map<uint32, std::vector<TransmogSetEntry const*>> _transmogSetsByItemModifiedAppearance;
512 std::unordered_map<uint32, std::vector<TransmogSetItemEntry const*>> _transmogSetItemsByTransmogSet;
513 std::unordered_map<int32, UiMapBounds> _uiMapBounds;
514 std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByMap[MAX_UI_MAP_SYSTEM];
515 std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByArea[MAX_UI_MAP_SYSTEM];
516 std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByWmoDoodadPlacement[MAX_UI_MAP_SYSTEM];
517 std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByWmoGroup[MAX_UI_MAP_SYSTEM];
518 std::unordered_set<int32> _uiMapPhases;
519 WMOAreaTableLookupContainer _wmoAreaTableLookup;
520 std::unordered_map<uint32, std::unordered_set<uint32>> _pvpStatIdsByMap;
521}
522
523void LoadDB2(std::bitset<TOTAL_LOCALES>& availableDb2Locales, std::vector<std::string>& errlist, StorageMap& stores, DB2StorageBase* storage, std::string const& db2Path,
524 LocaleConstant defaultLocale, std::size_t cppRecordSize)
525{
526 // validate structure
527 {
528 DB2LoadInfo const* loadInfo = storage->GetLoadInfo();
529 std::string clientMetaString, ourMetaString;
530 for (std::size_t i = 0; i < loadInfo->Meta->FieldCount; ++i)
531 {
532 for (std::size_t j = 0; j < loadInfo->Meta->Fields[i].ArraySize; ++j)
533 {
534 if (i >= loadInfo->Meta->FileFieldCount && int32(i) == loadInfo->Meta->ParentIndexField)
535 {
536 clientMetaString += char(FT_INT);
537 continue;
538 }
539
540 clientMetaString += char(loadInfo->Meta->Fields[i].Type);
541 }
542 }
543
544 for (std::size_t i = loadInfo->Meta->HasIndexFieldInData() ? 0 : 1; i < loadInfo->FieldCount; ++i)
545 ourMetaString += char(loadInfo->Fields[i].Type);
546
547 ASSERT(clientMetaString == ourMetaString,
548 "%s C++ structure fields %s do not match generated types from the client %s",
549 storage->GetFileName().c_str(), ourMetaString.c_str(), clientMetaString.c_str());
550
551 // compatibility format and C++ structure sizes
552 ASSERT(loadInfo->Meta->GetRecordSize() == cppRecordSize,
553 "Size of '%s' set by format string (%u) not equal size of C++ structure (" SZFMTD ").",
554 storage->GetFileName().c_str(), loadInfo->Meta->GetRecordSize(), cppRecordSize);
555 }
556
557 try
558 {
559 storage->Load(db2Path + localeNames[defaultLocale] + '/', defaultLocale);
560 }
561 catch (std::system_error const& e)
562 {
563 if (e.code() == std::errc::no_such_file_or_directory)
564 {
565 errlist.push_back(Trinity::StringFormat("File {}{}/{} does not exist", db2Path, localeNames[defaultLocale], storage->GetFileName()));
566 }
567 else
568 throw;
569 }
570 catch (std::exception const& e)
571 {
572 errlist.emplace_back(e.what());
573 return;
574 }
575
576 // load additional data and enUS strings from db
577 storage->LoadFromDB();
578
579 for (LocaleConstant i = LOCALE_enUS; i < TOTAL_LOCALES; i = LocaleConstant(i + 1))
580 {
581 if (defaultLocale == i || !availableDb2Locales[i])
582 continue;
583
584 try
585 {
586 storage->LoadStringsFrom((db2Path + localeNames[i] + '/'), i);
587 }
588 catch (std::system_error const& e)
589 {
590 if (e.code() != std::errc::no_such_file_or_directory)
591 throw;
592
593 // locale db2 files are optional, do not error if nothing is found
594 }
595 catch (std::exception const& e)
596 {
597 errlist.emplace_back(e.what());
598 }
599 }
600
601 for (LocaleConstant i = LOCALE_koKR; i < TOTAL_LOCALES; i = LocaleConstant(i + 1))
602 if (availableDb2Locales[i])
603 storage->LoadStringsFromDB(i);
604
605 stores[storage->GetTableHash()] = storage;
606}
607
608DB2Manager& DB2Manager::Instance()
609{
610 static DB2Manager instance;
611 return instance;
612}
613
614uint32 DB2Manager::LoadStores(std::string const& dataPath, LocaleConstant defaultLocale)
615{
616 uint32 oldMSTime = getMSTime();
617
618 std::string db2Path = dataPath + "dbc/";
619
620 std::vector<std::string> loadErrors;
621 std::bitset<TOTAL_LOCALES> availableDb2Locales = [&]()
622 {
623 std::bitset<TOTAL_LOCALES> foundLocales;
624 boost::filesystem::directory_iterator db2PathItr(db2Path), end;
625 while (db2PathItr != end)
626 {
627 LocaleConstant locale = GetLocaleByName(db2PathItr->path().filename().string());
628 if (IsValidLocale(locale))
629 foundLocales[locale] = true;
630
631 ++db2PathItr;
632 }
633 return foundLocales;
634 }();
635
636 if (!availableDb2Locales[defaultLocale])
637 return 0;
638
639 auto LOAD_DB2 = [&]<typename T>(DB2Storage<T>& store)
640 {
641 LoadDB2(availableDb2Locales, loadErrors, _stores, &store, db2Path, defaultLocale, sizeof(T));
642 };
643
644 LOAD_DB2(sAchievementStore);
645 LOAD_DB2(sAchievementCategoryStore);
646 LOAD_DB2(sAdventureJournalStore);
647 LOAD_DB2(sAdventureMapPOIStore);
648 LOAD_DB2(sAnimationDataStore);
649 LOAD_DB2(sAnimKitStore);
650 LOAD_DB2(sAreaGroupMemberStore);
651 LOAD_DB2(sAreaTableStore);
652 LOAD_DB2(sAreaTriggerStore);
653 LOAD_DB2(sArmorLocationStore);
654 LOAD_DB2(sArtifactStore);
655 LOAD_DB2(sArtifactAppearanceStore);
656 LOAD_DB2(sArtifactAppearanceSetStore);
657 LOAD_DB2(sArtifactCategoryStore);
658 LOAD_DB2(sArtifactPowerStore);
659 LOAD_DB2(sArtifactPowerLinkStore);
660 LOAD_DB2(sArtifactPowerPickerStore);
661 LOAD_DB2(sArtifactPowerRankStore);
662 LOAD_DB2(sArtifactTierStore);
663 LOAD_DB2(sArtifactUnlockStore);
664 LOAD_DB2(sAuctionHouseStore);
665 LOAD_DB2(sAzeriteEmpoweredItemStore);
666 LOAD_DB2(sAzeriteEssenceStore);
667 LOAD_DB2(sAzeriteEssencePowerStore);
668 LOAD_DB2(sAzeriteItemStore);
669 LOAD_DB2(sAzeriteItemMilestonePowerStore);
670 LOAD_DB2(sAzeriteKnowledgeMultiplierStore);
671 LOAD_DB2(sAzeriteLevelInfoStore);
672 LOAD_DB2(sAzeritePowerStore);
673 LOAD_DB2(sAzeritePowerSetMemberStore);
674 LOAD_DB2(sAzeriteTierUnlockStore);
675 LOAD_DB2(sAzeriteTierUnlockSetStore);
676 LOAD_DB2(sAzeriteUnlockMappingStore);
677 LOAD_DB2(sBankBagSlotPricesStore);
678 LOAD_DB2(sBannedAddonsStore);
679 LOAD_DB2(sBarberShopStyleStore);
680 LOAD_DB2(sBattlePetAbilityStore);
681 LOAD_DB2(sBattlePetBreedQualityStore);
682 LOAD_DB2(sBattlePetBreedStateStore);
683 LOAD_DB2(sBattlePetSpeciesStore);
684 LOAD_DB2(sBattlePetSpeciesStateStore);
685 LOAD_DB2(sBattlemasterListStore);
686 LOAD_DB2(sBroadcastTextStore);
687 LOAD_DB2(sBroadcastTextDurationStore);
688 LOAD_DB2(sCfgCategoriesStore);
689 LOAD_DB2(sCfgRegionsStore);
690 LOAD_DB2(sChallengeModeItemBonusOverrideStore);
691 LOAD_DB2(sCharTitlesStore);
692 LOAD_DB2(sCharacterLoadoutStore);
693 LOAD_DB2(sCharacterLoadoutItemStore);
694 LOAD_DB2(sChatChannelsStore);
695 LOAD_DB2(sChrClassUIDisplayStore);
696 LOAD_DB2(sChrClassesStore);
697 LOAD_DB2(sChrClassesXPowerTypesStore);
698 LOAD_DB2(sChrCustomizationChoiceStore);
699 LOAD_DB2(sChrCustomizationDisplayInfoStore);
700 LOAD_DB2(sChrCustomizationElementStore);
701 LOAD_DB2(sChrCustomizationOptionStore);
702 LOAD_DB2(sChrCustomizationReqStore);
703 LOAD_DB2(sChrCustomizationReqChoiceStore);
704 LOAD_DB2(sChrModelStore);
705 LOAD_DB2(sChrRaceXChrModelStore);
706 LOAD_DB2(sChrRacesStore);
707 LOAD_DB2(sChrSpecializationStore);
708 LOAD_DB2(sCinematicCameraStore);
709 LOAD_DB2(sCinematicSequencesStore);
710 LOAD_DB2(sConditionalChrModelStore);
711 LOAD_DB2(sConditionalContentTuningStore);
712 LOAD_DB2(sContentTuningStore);
713 LOAD_DB2(sContentTuningXExpectedStore);
714 LOAD_DB2(sContentTuningXLabelStore);
715 LOAD_DB2(sConversationLineStore);
716 LOAD_DB2(sCorruptionEffectsStore);
717 LOAD_DB2(sCreatureDisplayInfoStore);
718 LOAD_DB2(sCreatureDisplayInfoExtraStore);
719 LOAD_DB2(sCreatureFamilyStore);
720 LOAD_DB2(sCreatureModelDataStore);
721 LOAD_DB2(sCreatureTypeStore);
722 LOAD_DB2(sCriteriaStore);
723 LOAD_DB2(sCriteriaTreeStore);
724 LOAD_DB2(sCurrencyContainerStore);
725 LOAD_DB2(sCurrencyTypesStore);
726 LOAD_DB2(sCurveStore);
727 LOAD_DB2(sCurvePointStore);
728 LOAD_DB2(sDestructibleModelDataStore);
729 LOAD_DB2(sDifficultyStore);
730 LOAD_DB2(sDungeonEncounterStore);
731 LOAD_DB2(sDurabilityCostsStore);
732 LOAD_DB2(sDurabilityQualityStore);
733 LOAD_DB2(sEmotesStore);
734 LOAD_DB2(sEmotesTextStore);
735 LOAD_DB2(sEmotesTextSoundStore);
736 LOAD_DB2(sExpectedStatStore);
737 LOAD_DB2(sExpectedStatModStore);
738 LOAD_DB2(sFactionStore);
739 LOAD_DB2(sFactionTemplateStore);
740 LOAD_DB2(sFriendshipRepReactionStore);
741 LOAD_DB2(sFriendshipReputationStore);
742 LOAD_DB2(sGameObjectsStore);
743 LOAD_DB2(sGameObjectArtKitStore);
744 LOAD_DB2(sGameObjectDisplayInfoStore);
745 LOAD_DB2(sGarrAbilityStore);
746 LOAD_DB2(sGarrBuildingStore);
747 LOAD_DB2(sGarrBuildingPlotInstStore);
748 LOAD_DB2(sGarrClassSpecStore);
749 LOAD_DB2(sGarrFollowerStore);
750 LOAD_DB2(sGarrFollowerXAbilityStore);
751 LOAD_DB2(sGarrMissionStore);
752 LOAD_DB2(sGarrPlotStore);
753 LOAD_DB2(sGarrPlotBuildingStore);
754 LOAD_DB2(sGarrPlotInstanceStore);
755 LOAD_DB2(sGarrSiteLevelStore);
756 LOAD_DB2(sGarrSiteLevelPlotInstStore);
757 LOAD_DB2(sGarrTalentTreeStore);
758 LOAD_DB2(sGemPropertiesStore);
759 LOAD_DB2(sGlobalCurveStore);
760 LOAD_DB2(sGlyphBindableSpellStore);
761 LOAD_DB2(sGlyphPropertiesStore);
762 LOAD_DB2(sGlyphRequiredSpecStore);
763 LOAD_DB2(sGossipNPCOptionStore);
764 LOAD_DB2(sGuildColorBackgroundStore);
765 LOAD_DB2(sGuildColorBorderStore);
766 LOAD_DB2(sGuildColorEmblemStore);
767 LOAD_DB2(sGuildPerkSpellsStore);
768 LOAD_DB2(sHeirloomStore);
769 LOAD_DB2(sHolidaysStore);
770 LOAD_DB2(sImportPriceArmorStore);
771 LOAD_DB2(sImportPriceQualityStore);
772 LOAD_DB2(sImportPriceShieldStore);
773 LOAD_DB2(sImportPriceWeaponStore);
774 LOAD_DB2(sItemAppearanceStore);
775 LOAD_DB2(sItemArmorQualityStore);
776 LOAD_DB2(sItemArmorShieldStore);
777 LOAD_DB2(sItemArmorTotalStore);
778 LOAD_DB2(sItemBagFamilyStore);
779 LOAD_DB2(sItemBonusStore);
780 LOAD_DB2(sItemBonusListGroupEntryStore);
781 LOAD_DB2(sItemBonusListLevelDeltaStore);
782 LOAD_DB2(sItemBonusTreeStore);
783 LOAD_DB2(sItemBonusTreeNodeStore);
784 LOAD_DB2(sItemChildEquipmentStore);
785 LOAD_DB2(sItemClassStore);
786 LOAD_DB2(sItemContextPickerEntryStore);
787 LOAD_DB2(sItemCurrencyCostStore);
788 LOAD_DB2(sItemDamageAmmoStore);
789 LOAD_DB2(sItemDamageOneHandStore);
790 LOAD_DB2(sItemDamageOneHandCasterStore);
791 LOAD_DB2(sItemDamageTwoHandStore);
792 LOAD_DB2(sItemDamageTwoHandCasterStore);
793 LOAD_DB2(sItemDisenchantLootStore);
794 LOAD_DB2(sItemEffectStore);
795 LOAD_DB2(sItemStore);
796 LOAD_DB2(sItemExtendedCostStore);
797 LOAD_DB2(sItemLevelSelectorStore);
798 LOAD_DB2(sItemLevelSelectorQualityStore);
799 LOAD_DB2(sItemLevelSelectorQualitySetStore);
800 LOAD_DB2(sItemLimitCategoryStore);
801 LOAD_DB2(sItemLimitCategoryConditionStore);
802 LOAD_DB2(sItemModifiedAppearanceStore);
803 LOAD_DB2(sItemModifiedAppearanceExtraStore);
804 LOAD_DB2(sItemNameDescriptionStore);
805 LOAD_DB2(sItemPriceBaseStore);
806 LOAD_DB2(sItemSearchNameStore);
807 LOAD_DB2(sItemSetStore);
808 LOAD_DB2(sItemSetSpellStore);
809 LOAD_DB2(sItemSparseStore);
810 LOAD_DB2(sItemSpecStore);
811 LOAD_DB2(sItemSpecOverrideStore);
812 LOAD_DB2(sItemXBonusTreeStore);
813 LOAD_DB2(sItemXItemEffectStore);
814 LOAD_DB2(sJournalEncounterStore);
815 LOAD_DB2(sJournalEncounterSectionStore);
816 LOAD_DB2(sJournalInstanceStore);
817 LOAD_DB2(sJournalTierStore);
818 LOAD_DB2(sKeychainStore);
819 LOAD_DB2(sKeystoneAffixStore);
820 LOAD_DB2(sLanguageWordsStore);
821 LOAD_DB2(sLanguagesStore);
822 LOAD_DB2(sLFGDungeonsStore);
823 LOAD_DB2(sLightStore);
824 LOAD_DB2(sLiquidTypeStore);
825 LOAD_DB2(sLockStore);
826 LOAD_DB2(sMailTemplateStore);
827 LOAD_DB2(sMapStore);
828 LOAD_DB2(sMapChallengeModeStore);
829 LOAD_DB2(sMapDifficultyStore);
830 LOAD_DB2(sMapDifficultyXConditionStore);
831 LOAD_DB2(sMawPowerStore);
832 LOAD_DB2(sModifierTreeStore);
833 LOAD_DB2(sMountCapabilityStore);
834 LOAD_DB2(sMountStore);
835 LOAD_DB2(sMountTypeXCapabilityStore);
836 LOAD_DB2(sMountXDisplayStore);
837 LOAD_DB2(sMovieStore);
838 LOAD_DB2(sMythicPlusSeasonStore);
839 LOAD_DB2(sNameGenStore);
840 LOAD_DB2(sNamesProfanityStore);
841 LOAD_DB2(sNamesReservedStore);
842 LOAD_DB2(sNamesReservedLocaleStore);
843 LOAD_DB2(sNumTalentsAtLevelStore);
844 LOAD_DB2(sOverrideSpellDataStore);
845 LOAD_DB2(sParagonReputationStore);
846 LOAD_DB2(sPhaseStore);
847 LOAD_DB2(sPhaseXPhaseGroupStore);
848 LOAD_DB2(sPlayerConditionStore);
849 LOAD_DB2(sPowerDisplayStore);
850 LOAD_DB2(sPowerTypeStore);
851 LOAD_DB2(sPrestigeLevelInfoStore);
852 LOAD_DB2(sPVPDifficultyStore);
853 LOAD_DB2(sPVPItemStore);
854 LOAD_DB2(sPVPStatStore);
855 LOAD_DB2(sPvpSeasonStore);
856 LOAD_DB2(sPvpTalentStore);
857 LOAD_DB2(sPvpTalentCategoryStore);
858 LOAD_DB2(sPvpTalentSlotUnlockStore);
859 LOAD_DB2(sPvpTierStore);
860 LOAD_DB2(sQuestFactionRewardStore);
861 LOAD_DB2(sQuestInfoStore);
862 LOAD_DB2(sQuestLineXQuestStore);
863 LOAD_DB2(sQuestMoneyRewardStore);
864 LOAD_DB2(sQuestPackageItemStore);
865 LOAD_DB2(sQuestSortStore);
866 LOAD_DB2(sQuestV2Store);
867 LOAD_DB2(sQuestXPStore);
868 LOAD_DB2(sRandPropPointsStore);
869 LOAD_DB2(sRewardPackStore);
870 LOAD_DB2(sRewardPackXCurrencyTypeStore);
871 LOAD_DB2(sRewardPackXItemStore);
872 LOAD_DB2(sScenarioStore);
873 LOAD_DB2(sScenarioStepStore);
874 LOAD_DB2(sSceneScriptStore);
875 LOAD_DB2(sSceneScriptGlobalTextStore);
876 LOAD_DB2(sSceneScriptPackageStore);
877 LOAD_DB2(sSceneScriptTextStore);
878 LOAD_DB2(sServerMessagesStore);
879 LOAD_DB2(sSkillLineStore);
880 LOAD_DB2(sSkillLineAbilityStore);
881 LOAD_DB2(sSkillLineXTraitTreeStore);
882 LOAD_DB2(sSkillRaceClassInfoStore);
883 LOAD_DB2(sSoulbindConduitRankStore);
884 LOAD_DB2(sSoundKitStore);
885 LOAD_DB2(sSpecializationSpellsStore);
886 LOAD_DB2(sSpecSetMemberStore);
887 LOAD_DB2(sSpellAuraOptionsStore);
888 LOAD_DB2(sSpellAuraRestrictionsStore);
889 LOAD_DB2(sSpellCastTimesStore);
890 LOAD_DB2(sSpellCastingRequirementsStore);
891 LOAD_DB2(sSpellCategoriesStore);
892 LOAD_DB2(sSpellCategoryStore);
893 LOAD_DB2(sSpellClassOptionsStore);
894 LOAD_DB2(sSpellCooldownsStore);
895 LOAD_DB2(sSpellDurationStore);
896 LOAD_DB2(sSpellEffectStore);
897 LOAD_DB2(sSpellEquippedItemsStore);
898 LOAD_DB2(sSpellFocusObjectStore);
899 LOAD_DB2(sSpellInterruptsStore);
900 LOAD_DB2(sSpellItemEnchantmentStore);
901 LOAD_DB2(sSpellItemEnchantmentConditionStore);
902 LOAD_DB2(sSpellKeyboundOverrideStore);
903 LOAD_DB2(sSpellLabelStore);
904 LOAD_DB2(sSpellLearnSpellStore);
905 LOAD_DB2(sSpellLevelsStore);
906 LOAD_DB2(sSpellMiscStore);
907 LOAD_DB2(sSpellNameStore);
908 LOAD_DB2(sSpellPowerStore);
909 LOAD_DB2(sSpellPowerDifficultyStore);
910 LOAD_DB2(sSpellProcsPerMinuteStore);
911 LOAD_DB2(sSpellProcsPerMinuteModStore);
912 LOAD_DB2(sSpellRadiusStore);
913 LOAD_DB2(sSpellRangeStore);
914 LOAD_DB2(sSpellReagentsStore);
915 LOAD_DB2(sSpellReagentsCurrencyStore);
916 LOAD_DB2(sSpellScalingStore);
917 LOAD_DB2(sSpellShapeshiftStore);
918 LOAD_DB2(sSpellShapeshiftFormStore);
919 LOAD_DB2(sSpellTargetRestrictionsStore);
920 LOAD_DB2(sSpellTotemsStore);
921 LOAD_DB2(sSpellVisualStore);
922 LOAD_DB2(sSpellVisualEffectNameStore);
923 LOAD_DB2(sSpellVisualMissileStore);
924 LOAD_DB2(sSpellVisualKitStore);
925 LOAD_DB2(sSpellXSpellVisualStore);
926 LOAD_DB2(sSummonPropertiesStore);
927 LOAD_DB2(sTactKeyStore);
928 LOAD_DB2(sTalentStore);
929 LOAD_DB2(sTaxiNodesStore);
930 LOAD_DB2(sTaxiPathStore);
931 LOAD_DB2(sTaxiPathNodeStore);
932 LOAD_DB2(sTotemCategoryStore);
933 LOAD_DB2(sToyStore);
934 LOAD_DB2(sTraitCondStore);
935 LOAD_DB2(sTraitCostStore);
936 LOAD_DB2(sTraitCurrencyStore);
937 LOAD_DB2(sTraitCurrencySourceStore);
938 LOAD_DB2(sTraitDefinitionStore);
939 LOAD_DB2(sTraitDefinitionEffectPointsStore);
940 LOAD_DB2(sTraitEdgeStore);
941 LOAD_DB2(sTraitNodeStore);
942 LOAD_DB2(sTraitNodeEntryStore);
943 LOAD_DB2(sTraitNodeEntryXTraitCondStore);
944 LOAD_DB2(sTraitNodeEntryXTraitCostStore);
945 LOAD_DB2(sTraitNodeGroupStore);
946 LOAD_DB2(sTraitNodeGroupXTraitCondStore);
947 LOAD_DB2(sTraitNodeGroupXTraitCostStore);
948 LOAD_DB2(sTraitNodeGroupXTraitNodeStore);
949 LOAD_DB2(sTraitNodeXTraitCondStore);
950 LOAD_DB2(sTraitNodeXTraitCostStore);
951 LOAD_DB2(sTraitNodeXTraitNodeEntryStore);
952 LOAD_DB2(sTraitTreeStore);
953 LOAD_DB2(sTraitTreeLoadoutStore);
954 LOAD_DB2(sTraitTreeLoadoutEntryStore);
955 LOAD_DB2(sTraitTreeXTraitCostStore);
956 LOAD_DB2(sTraitTreeXTraitCurrencyStore);
957 LOAD_DB2(sTransmogHolidayStore);
958 LOAD_DB2(sTransmogIllusionStore);
959 LOAD_DB2(sTransmogSetStore);
960 LOAD_DB2(sTransmogSetGroupStore);
961 LOAD_DB2(sTransmogSetItemStore);
962 LOAD_DB2(sTransportAnimationStore);
963 LOAD_DB2(sTransportRotationStore);
964 LOAD_DB2(sUiMapStore);
965 LOAD_DB2(sUiMapAssignmentStore);
966 LOAD_DB2(sUiMapLinkStore);
967 LOAD_DB2(sUiMapXMapArtStore);
968 LOAD_DB2(sUISplashScreenStore);
969 LOAD_DB2(sUnitConditionStore);
970 LOAD_DB2(sUnitPowerBarStore);
971 LOAD_DB2(sVehicleStore);
972 LOAD_DB2(sVehicleSeatStore);
973 LOAD_DB2(sVignetteStore);
974 LOAD_DB2(sWMOAreaTableStore);
975 LOAD_DB2(sWorldEffectStore);
976 LOAD_DB2(sWorldMapOverlayStore);
977 LOAD_DB2(sWorldStateExpressionStore);
978
979#undef LOAD_DB2
980
981 // error checks
982 if (!loadErrors.empty())
983 {
984 sLog->SetSynchronous(); // server will shut down after this, so set sync logging to prevent messages from getting lost
985
986 for (std::string const& error : loadErrors)
987 TC_LOG_ERROR("misc", "{}", error);
988
989 return 0;
990 }
991
992 // Check loaded DB2 files proper version
993 if (!sAreaTableStore.LookupEntry(15151) || // last area added in 10.2.5 (53007)
994 !sCharTitlesStore.LookupEntry(805) || // last char title added in 10.2.5 (53007)
995 !sGemPropertiesStore.LookupEntry(4081) || // last gem property added in 10.2.5 (53007)
996 !sItemStore.LookupEntry(215160) || // last item added in 10.2.5 (53007)
997 !sItemExtendedCostStore.LookupEntry(8510) || // last item extended cost added in 10.2.5 (53007)
998 !sMapStore.LookupEntry(2708) || // last map added in 10.2.5 (53007)
999 !sSpellNameStore.LookupEntry(438878)) // last spell added in 10.2.5 (53007)
1000 {
1001 TC_LOG_ERROR("misc", "You have _outdated_ DB2 files. Please extract correct versions from current using client.");
1002 exit(1);
1003 }
1004
1005 for (AreaGroupMemberEntry const* areaGroupMember : sAreaGroupMemberStore)
1006 _areaGroupMembers[areaGroupMember->AreaGroupID].push_back(areaGroupMember->AreaID);
1007
1008 for (AreaTableEntry const* areaTable : sAreaTableStore)
1009 {
1010 ASSERT(areaTable->AreaBit <= 0 || (size_t(areaTable->AreaBit / 64) < PLAYER_EXPLORED_ZONES_SIZE),
1011 "PLAYER_EXPLORED_ZONES_SIZE must be at least %d", (areaTable->AreaBit + 63) / 64);
1012 }
1013
1014 for (ArtifactPowerEntry const* artifactPower : sArtifactPowerStore)
1015 _artifactPowers[artifactPower->ArtifactID].push_back(artifactPower);
1016
1017 for (ArtifactPowerLinkEntry const* artifactPowerLink : sArtifactPowerLinkStore)
1018 {
1019 _artifactPowerLinks[artifactPowerLink->PowerA].push_back(artifactPowerLink->PowerB);
1020 _artifactPowerLinks[artifactPowerLink->PowerB].push_back(artifactPowerLink->PowerA);
1021 }
1022
1023 for (ArtifactPowerRankEntry const* artifactPowerRank : sArtifactPowerRankStore)
1024 _artifactPowerRanks[std::pair<uint32, uint8>{ artifactPowerRank->ArtifactPowerID, artifactPowerRank->RankIndex }] = artifactPowerRank;
1025
1026 for (AzeriteEmpoweredItemEntry const* azeriteEmpoweredItem : sAzeriteEmpoweredItemStore)
1027 _azeriteEmpoweredItems[azeriteEmpoweredItem->ItemID] = azeriteEmpoweredItem;
1028
1029 for (AzeriteEssencePowerEntry const* azeriteEssencePower : sAzeriteEssencePowerStore)
1030 _azeriteEssencePowersByIdAndRank[std::pair<uint32, uint32>{ azeriteEssencePower->AzeriteEssenceID, azeriteEssencePower->Tier }] = azeriteEssencePower;
1031
1032 for (AzeriteItemMilestonePowerEntry const* azeriteItemMilestonePower : sAzeriteItemMilestonePowerStore)
1033 _azeriteItemMilestonePowers.push_back(azeriteItemMilestonePower);
1034
1035 std::sort(_azeriteItemMilestonePowers.begin(), _azeriteItemMilestonePowers.end(), [](AzeriteItemMilestonePowerEntry const* a1, AzeriteItemMilestonePowerEntry const* a2)
1036 {
1037 return a1->RequiredLevel < a2->RequiredLevel;
1038 });
1039
1040 {
1041 uint32 azeriteEssenceSlot = 0;
1042 for (AzeriteItemMilestonePowerEntry const* azeriteItemMilestonePower : _azeriteItemMilestonePowers)
1043 {
1044 AzeriteItemMilestoneType type = AzeriteItemMilestoneType(azeriteItemMilestonePower->Type);
1045 if (type == AzeriteItemMilestoneType::MajorEssence || type == AzeriteItemMilestoneType::MinorEssence)
1046 {
1047 ASSERT(azeriteEssenceSlot < MAX_AZERITE_ESSENCE_SLOT);
1048 _azeriteItemMilestonePowerByEssenceSlot[azeriteEssenceSlot] = azeriteItemMilestonePower;
1049 ++azeriteEssenceSlot;
1050 }
1051 }
1052 }
1053
1054 for (AzeritePowerSetMemberEntry const* azeritePowerSetMember : sAzeritePowerSetMemberStore)
1055 if (sAzeritePowerStore.LookupEntry(azeritePowerSetMember->AzeritePowerID))
1056 _azeritePowers[azeritePowerSetMember->AzeritePowerSetID].push_back(azeritePowerSetMember);
1057
1058 for (AzeriteTierUnlockEntry const* azeriteTierUnlock : sAzeriteTierUnlockStore)
1059 _azeriteTierUnlockLevels[std::pair<uint32, ItemContext>{ azeriteTierUnlock->AzeriteTierUnlockSetID, ItemContext(azeriteTierUnlock->ItemCreationContext) }][azeriteTierUnlock->Tier] = azeriteTierUnlock->AzeriteLevel;
1060
1061 for (BattlemasterListEntry const* battlemaster : sBattlemasterListStore)
1062 {
1063 if (battlemaster->MaxLevel < battlemaster->MinLevel)
1064 {
1065 TC_LOG_ERROR("db2.hotfix.battlemaster_list", "Battlemaster ({}) contains bad values for MinLevel ({}) and MaxLevel ({}). Swapping values.", battlemaster->ID, battlemaster->MinLevel, battlemaster->MaxLevel);
1066 std::swap(const_cast<BattlemasterListEntry*>(battlemaster)->MaxLevel, const_cast<BattlemasterListEntry*>(battlemaster)->MinLevel);
1067 }
1068 if (battlemaster->MaxPlayers < battlemaster->MinPlayers)
1069 {
1070 TC_LOG_ERROR("db2.hotfix.battlemaster_list", "Battlemaster ({}) contains bad values for MinPlayers ({}) and MaxPlayers ({}). Swapping values.", battlemaster->ID, battlemaster->MinPlayers, battlemaster->MaxPlayers);
1071 int8 minPlayers = battlemaster->MinPlayers;
1072 const_cast<BattlemasterListEntry*>(battlemaster)->MinPlayers = battlemaster->MaxPlayers;
1073 const_cast<BattlemasterListEntry*>(battlemaster)->MaxPlayers = minPlayers;
1074 }
1075 }
1076
1077 _broadcastTextDurations.reserve(sBroadcastTextDurationStore.GetNumRows());
1078 for (BroadcastTextDurationEntry const* broadcastTextDuration : sBroadcastTextDurationStore)
1079 _broadcastTextDurations[{ broadcastTextDuration->BroadcastTextID, CascLocaleBit(broadcastTextDuration->Locale) }] = broadcastTextDuration->Duration;
1080
1081 for (ChrClassUIDisplayEntry const* uiDisplay : sChrClassUIDisplayStore)
1082 {
1083 ASSERT(uiDisplay->ChrClassesID < MAX_CLASSES);
1084 _uiDisplayByClass[uiDisplay->ChrClassesID] = uiDisplay;
1085 }
1086
1087 {
1088 std::set<ChrClassesXPowerTypesEntry const*, ChrClassesXPowerTypesEntryComparator> powers;
1089 for (ChrClassesXPowerTypesEntry const* power : sChrClassesXPowerTypesStore)
1090 powers.insert(power);
1091
1092 for (std::size_t i = 0; i < _powersByClass.size(); ++i)
1093 _powersByClass[i].fill(MAX_POWERS);
1094
1095 for (ChrClassesXPowerTypesEntry const* power : powers)
1096 {
1097 uint32 index = 0;
1098 for (uint32 j = 0; j < MAX_POWERS; ++j)
1099 if (_powersByClass[power->ClassID][j] != MAX_POWERS)
1100 ++index;
1101
1102 ASSERT(power->ClassID < MAX_CLASSES);
1103 ASSERT(power->PowerType < MAX_POWERS);
1104 _powersByClass[power->ClassID][power->PowerType] = index;
1105 }
1106 }
1107
1108 for (ChrCustomizationChoiceEntry const* customizationChoice : sChrCustomizationChoiceStore)
1109 _chrCustomizationChoicesByOption[customizationChoice->ChrCustomizationOptionID].push_back(customizationChoice);
1110
1111 std::unordered_multimap<uint32, std::pair<uint32, uint8>> shapeshiftFormByModel;
1112 std::unordered_map<uint32, ChrCustomizationDisplayInfoEntry const*> displayInfoByCustomizationChoice;
1113
1114 // build shapeshift form model lookup
1115 for (ChrCustomizationElementEntry const* customizationElement : sChrCustomizationElementStore)
1116 {
1117 if (ChrCustomizationDisplayInfoEntry const* customizationDisplayInfo = sChrCustomizationDisplayInfoStore.LookupEntry(customizationElement->ChrCustomizationDisplayInfoID))
1118 {
1119 if (ChrCustomizationChoiceEntry const* customizationChoice = sChrCustomizationChoiceStore.LookupEntry(customizationElement->ChrCustomizationChoiceID))
1120 {
1121 displayInfoByCustomizationChoice[customizationElement->ChrCustomizationChoiceID] = customizationDisplayInfo;
1122 if (ChrCustomizationOptionEntry const* customizationOption = sChrCustomizationOptionStore.LookupEntry(customizationChoice->ChrCustomizationOptionID))
1123 shapeshiftFormByModel.emplace(customizationOption->ChrModelID, std::make_pair(customizationOption->ID, uint8(customizationDisplayInfo->ShapeshiftFormID)));
1124 }
1125 }
1126 }
1127
1128 std::unordered_map<uint32, std::vector<ChrCustomizationOptionEntry const*>> customizationOptionsByModel;
1129 for (ChrCustomizationOptionEntry const* customizationOption : sChrCustomizationOptionStore)
1130 customizationOptionsByModel[customizationOption->ChrModelID].push_back(customizationOption);
1131
1132 for (ChrCustomizationReqChoiceEntry const* reqChoice : sChrCustomizationReqChoiceStore)
1133 {
1134 if (ChrCustomizationChoiceEntry const* customizationChoice = sChrCustomizationChoiceStore.LookupEntry(reqChoice->ChrCustomizationChoiceID))
1135 {
1136 std::vector<std::pair<uint32, std::vector<uint32>>>& requiredChoicesForReq = _chrCustomizationRequiredChoices[reqChoice->ChrCustomizationReqID];
1137 std::vector<uint32>* choices = nullptr;
1138 for (std::pair<uint32, std::vector<uint32>>& choicesForOption : requiredChoicesForReq)
1139 {
1140 if (int32(choicesForOption.first) == customizationChoice->ChrCustomizationOptionID)
1141 {
1142 choices = &choicesForOption.second;
1143 break;
1144 }
1145 }
1146 if (!choices)
1147 {
1148 std::pair<uint32, std::vector<uint32>>& choicesForReq = requiredChoicesForReq.emplace_back();
1149 choicesForReq.first = customizationChoice->ChrCustomizationOptionID;
1150 choices = &choicesForReq.second;
1151 }
1152 choices->push_back(reqChoice->ChrCustomizationChoiceID);
1153 }
1154 }
1155
1156 std::unordered_map<uint32, uint32> parentRaces;
1157 for (ChrRacesEntry const* chrRace : sChrRacesStore)
1158 if (chrRace->UnalteredVisualRaceID)
1159 parentRaces[chrRace->UnalteredVisualRaceID] = chrRace->ID;
1160
1161 for (ChrRaceXChrModelEntry const* raceModel : sChrRaceXChrModelStore)
1162 {
1163 if (ChrModelEntry const* model = sChrModelStore.LookupEntry(raceModel->ChrModelID))
1164 {
1165 _chrModelsByRaceAndGender[{ uint8(raceModel->ChrRacesID), uint8(raceModel->Sex) }] = model;
1166
1167 if (std::vector<ChrCustomizationOptionEntry const*> const* customizationOptionsForModel = Trinity::Containers::MapGetValuePtr(customizationOptionsByModel, model->ID))
1168 {
1169 std::vector<ChrCustomizationOptionEntry const*>& raceOptions = _chrCustomizationOptionsByRaceAndGender[{ uint8(raceModel->ChrRacesID), uint8(raceModel->Sex) }];
1170 raceOptions.insert(raceOptions.end(), customizationOptionsForModel->begin(), customizationOptionsForModel->end());
1171
1172 if (uint32 const* parentRace = Trinity::Containers::MapGetValuePtr(parentRaces, raceModel->ChrRacesID))
1173 {
1174 std::vector<ChrCustomizationOptionEntry const*>& parentRaceOptions = _chrCustomizationOptionsByRaceAndGender[{ uint8(*parentRace), uint8(raceModel->Sex) }];
1175 parentRaceOptions.insert(parentRaceOptions.end(), customizationOptionsForModel->begin(), customizationOptionsForModel->end());
1176 }
1177 }
1178
1179 // link shapeshift displays to race/gender/form
1180 for (std::pair<uint32 const, std::pair<uint32, uint8>> const& shapeshiftOptionsForModel : Trinity::Containers::MapEqualRange(shapeshiftFormByModel, model->ID))
1181 {
1182 ShapeshiftFormModelData& data = _chrCustomizationChoicesForShapeshifts[{ uint8(raceModel->ChrRacesID), uint8(raceModel->Sex), shapeshiftOptionsForModel.second.second }];
1183 data.OptionID = shapeshiftOptionsForModel.second.first;
1184 data.Choices = Trinity::Containers::MapGetValuePtr(_chrCustomizationChoicesByOption, shapeshiftOptionsForModel.second.first);
1185 if (data.Choices)
1186 {
1187 data.Displays.resize(data.Choices->size());
1188 for (std::size_t i = 0; i < data.Choices->size(); ++i)
1189 data.Displays[i] = Trinity::Containers::MapGetValuePtr(displayInfoByCustomizationChoice, (*data.Choices)[i]->ID);
1190 }
1191 }
1192 }
1193 }
1194
1195 memset(_chrSpecializationsByIndex, 0, sizeof(_chrSpecializationsByIndex));
1196 for (ChrSpecializationEntry const* chrSpec : sChrSpecializationStore)
1197 {
1198 ASSERT(chrSpec->ClassID < MAX_CLASSES);
1199 ASSERT(chrSpec->OrderIndex < MAX_SPECIALIZATIONS);
1200
1201 uint32 storageIndex = chrSpec->ClassID;
1202 if (chrSpec->GetFlags().HasFlag(ChrSpecializationFlag::PetOverrideSpec))
1203 {
1204 ASSERT(!chrSpec->ClassID);
1205 storageIndex = PET_SPEC_OVERRIDE_CLASS_INDEX;
1206 }
1207
1208 _chrSpecializationsByIndex[storageIndex][chrSpec->OrderIndex] = chrSpec;
1209 }
1210
1211 for (ConditionalChrModelEntry const* conditionalChrModel : sConditionalChrModelStore)
1212 _conditionalChrModelsByChrModelId[conditionalChrModel->ChrModelID] = conditionalChrModel;
1213
1214 for (ConditionalContentTuningEntry const* conditionalContentTuning : sConditionalContentTuningStore)
1215 _conditionalContentTuning.emplace(conditionalContentTuning->ParentContentTuningID, conditionalContentTuning);
1216
1217 for (ContentTuningXExpectedEntry const* contentTuningXExpectedStat : sContentTuningXExpectedStore)
1218 if (sExpectedStatModStore.LookupEntry(contentTuningXExpectedStat->ExpectedStatModID))
1219 _expectedStatModsByContentTuning[contentTuningXExpectedStat->ContentTuningID].push_back(contentTuningXExpectedStat);
1220
1221 for (ContentTuningXLabelEntry const* contentTuningXLabel : sContentTuningXLabelStore)
1222 _contentTuningLabels.emplace(contentTuningXLabel->ContentTuningID, contentTuningXLabel->LabelID);
1223
1224 for (CurrencyContainerEntry const* currencyContainer : sCurrencyContainerStore)
1225 _currencyContainers.emplace(currencyContainer->CurrencyTypesID, currencyContainer);
1226
1227 {
1228 std::unordered_map<uint32 /*curveID*/, std::vector<CurvePointEntry const*>> unsortedPoints;
1229 for (CurvePointEntry const* curvePoint : sCurvePointStore)
1230 if (sCurveStore.LookupEntry(curvePoint->CurveID))
1231 unsortedPoints[curvePoint->CurveID].push_back(curvePoint);
1232
1233 for (auto& [curveId, curvePoints] : unsortedPoints)
1234 {
1235 std::sort(curvePoints.begin(), curvePoints.end(), [](CurvePointEntry const* point1, CurvePointEntry const* point2) { return point1->OrderIndex < point2->OrderIndex; });
1236 std::vector<DBCPosition2D>& points = _curvePoints[curveId];
1237 points.resize(curvePoints.size());
1238 std::transform(curvePoints.begin(), curvePoints.end(), points.begin(), [](CurvePointEntry const* point) { return point->Pos; });
1239 }
1240 }
1241
1242 for (EmotesTextSoundEntry const* emoteTextSound : sEmotesTextSoundStore)
1243 _emoteTextSounds[EmotesTextSoundContainer::key_type(emoteTextSound->EmotesTextID, emoteTextSound->RaceID, emoteTextSound->SexID, emoteTextSound->ClassID)] = emoteTextSound;
1244
1245 for (ExpectedStatEntry const* expectedStat : sExpectedStatStore)
1246 _expectedStatsByLevel[std::make_pair(expectedStat->Lvl, expectedStat->ExpansionID)] = expectedStat;
1247
1248 for (FactionEntry const* faction : sFactionStore)
1249 if (faction->ParentFactionID)
1250 _factionTeams[faction->ParentFactionID].push_back(faction->ID);
1251
1252 for (FriendshipRepReactionEntry const* friendshipRepReaction : sFriendshipRepReactionStore)
1253 _friendshipRepReactions[friendshipRepReaction->FriendshipRepID].insert(friendshipRepReaction);
1254
1255 for (GameObjectDisplayInfoEntry const* gameObjectDisplayInfo : sGameObjectDisplayInfoStore)
1256 {
1257 if (gameObjectDisplayInfo->GeoBoxMax.X < gameObjectDisplayInfo->GeoBoxMin.X)
1258 std::swap(const_cast<GameObjectDisplayInfoEntry*>(gameObjectDisplayInfo)->GeoBoxMax.X, const_cast<GameObjectDisplayInfoEntry*>(gameObjectDisplayInfo)->GeoBoxMin.X);
1259 if (gameObjectDisplayInfo->GeoBoxMax.Y < gameObjectDisplayInfo->GeoBoxMin.Y)
1260 std::swap(const_cast<GameObjectDisplayInfoEntry*>(gameObjectDisplayInfo)->GeoBoxMax.Y, const_cast<GameObjectDisplayInfoEntry*>(gameObjectDisplayInfo)->GeoBoxMin.Y);
1261 if (gameObjectDisplayInfo->GeoBoxMax.Z < gameObjectDisplayInfo->GeoBoxMin.Z)
1262 std::swap(const_cast<GameObjectDisplayInfoEntry*>(gameObjectDisplayInfo)->GeoBoxMax.Z, const_cast<GameObjectDisplayInfoEntry*>(gameObjectDisplayInfo)->GeoBoxMin.Z);
1263 }
1264
1265 for (HeirloomEntry const* heirloom : sHeirloomStore)
1266 _heirlooms[heirloom->ItemID] = heirloom;
1267
1268 for (GlyphBindableSpellEntry const* glyphBindableSpell : sGlyphBindableSpellStore)
1269 _glyphBindableSpells[glyphBindableSpell->GlyphPropertiesID].push_back(glyphBindableSpell->SpellID);
1270
1271 for (GlyphRequiredSpecEntry const* glyphRequiredSpec : sGlyphRequiredSpecStore)
1272 _glyphRequiredSpecs[glyphRequiredSpec->GlyphPropertiesID].push_back(ChrSpecialization(glyphRequiredSpec->ChrSpecializationID));
1273
1274 for (ItemChildEquipmentEntry const* itemChildEquipment : sItemChildEquipmentStore)
1275 {
1276 ASSERT(_itemChildEquipment.find(itemChildEquipment->ParentItemID) == _itemChildEquipment.end(), "Item must have max 1 child item.");
1277 _itemChildEquipment[itemChildEquipment->ParentItemID] = itemChildEquipment;
1278 }
1279
1280 for (ItemClassEntry const* itemClass : sItemClassStore)
1281 {
1282 ASSERT(itemClass->ClassID < int32(_itemClassByOldEnum.size()));
1283 ASSERT(!_itemClassByOldEnum[itemClass->ClassID]);
1284 _itemClassByOldEnum[itemClass->ClassID] = itemClass;
1285 }
1286
1287 for (ItemCurrencyCostEntry const* itemCurrencyCost : sItemCurrencyCostStore)
1288 _itemsWithCurrencyCost.insert(itemCurrencyCost->ItemID);
1289
1290 for (ItemLimitCategoryConditionEntry const* condition : sItemLimitCategoryConditionStore)
1291 _itemCategoryConditions[condition->ParentItemLimitCategoryID].push_back(condition);
1292
1293 for (ItemModifiedAppearanceEntry const* appearanceMod : sItemModifiedAppearanceStore)
1294 {
1295 ASSERT(appearanceMod->ItemID <= 0xFFFFFF);
1296 _itemModifiedAppearancesByItem[appearanceMod->ItemID | (appearanceMod->ItemAppearanceModifierID << 24)] = appearanceMod;
1297 }
1298
1299 for (ItemSetSpellEntry const* itemSetSpell : sItemSetSpellStore)
1300 _itemSetSpells[itemSetSpell->ItemSetID].push_back(itemSetSpell);
1301
1302 for (ItemSpecOverrideEntry const* itemSpecOverride : sItemSpecOverrideStore)
1303 _itemSpecOverrides[itemSpecOverride->ItemID].push_back(itemSpecOverride);
1304
1305 for (JournalTierEntry const* journalTier : sJournalTierStore)
1306 _journalTiersByIndex.push_back(journalTier);
1307
1308 for (MapDifficultyEntry const* entry : sMapDifficultyStore)
1309 _mapDifficulties[entry->MapID][entry->DifficultyID] = entry;
1310
1311 std::vector<MapDifficultyXConditionEntry const*> mapDifficultyConditions;
1312 mapDifficultyConditions.reserve(sMapDifficultyXConditionStore.GetNumRows());
1313 for (MapDifficultyXConditionEntry const* mapDifficultyCondition : sMapDifficultyXConditionStore)
1314 mapDifficultyConditions.push_back(mapDifficultyCondition);
1315
1316 std::sort(mapDifficultyConditions.begin(), mapDifficultyConditions.end(), [](MapDifficultyXConditionEntry const* left, MapDifficultyXConditionEntry const* right)
1317 {
1318 return left->OrderIndex < right->OrderIndex;
1319 });
1320
1321 for (MapDifficultyXConditionEntry const* mapDifficultyCondition : mapDifficultyConditions)
1322 if (PlayerConditionEntry const* playerCondition = sPlayerConditionStore.LookupEntry(mapDifficultyCondition->PlayerConditionID))
1323 _mapDifficultyConditions[mapDifficultyCondition->MapDifficultyID].emplace_back(mapDifficultyCondition->ID, playerCondition);
1324
1325 for (MountEntry const* mount : sMountStore)
1326 _mountsBySpellId[mount->SourceSpellID] = mount;
1327
1328 for (MountTypeXCapabilityEntry const* mountTypeCapability : sMountTypeXCapabilityStore)
1329 _mountCapabilitiesByType[mountTypeCapability->MountTypeID].insert(mountTypeCapability);
1330
1331 for (MountXDisplayEntry const* mountDisplay : sMountXDisplayStore)
1332 _mountDisplays[mountDisplay->MountID].push_back(mountDisplay);
1333
1334 for (NameGenEntry const* nameGen : sNameGenStore)
1335 _nameGenData[nameGen->RaceID][nameGen->Sex].push_back(nameGen);
1336
1337 for (NamesProfanityEntry const* namesProfanity : sNamesProfanityStore)
1338 {
1339 ASSERT(namesProfanity->Language < TOTAL_LOCALES || namesProfanity->Language == -1);
1340 std::wstring name;
1341 bool conversionResult = Utf8toWStr(namesProfanity->Name, name);
1342 ASSERT(conversionResult);
1343 if (namesProfanity->Language != -1)
1344 _nameValidators[namesProfanity->Language].emplace_back(name, Trinity::regex::perl | Trinity::regex::icase | Trinity::regex::optimize);
1345 else
1346 {
1347 for (uint32 i = 0; i < TOTAL_LOCALES; ++i)
1348 {
1349 if (i == LOCALE_none)
1350 continue;
1351
1352 _nameValidators[i].emplace_back(name, Trinity::regex::perl | Trinity::regex::icase | Trinity::regex::optimize);
1353 }
1354 }
1355 }
1356
1357 for (NamesReservedEntry const* namesReserved : sNamesReservedStore)
1358 {
1359 std::wstring name;
1360 bool conversionResult = Utf8toWStr(namesReserved->Name, name);
1361 ASSERT(conversionResult);
1362 _nameValidators[TOTAL_LOCALES].emplace_back(name, Trinity::regex::perl | Trinity::regex::icase | Trinity::regex::optimize);
1363 }
1364
1365 for (NamesReservedLocaleEntry const* namesReserved : sNamesReservedLocaleStore)
1366 {
1367 ASSERT(!(namesReserved->LocaleMask & ~((1u << TOTAL_LOCALES) - 1)));
1368 std::wstring name;
1369 bool conversionResult = Utf8toWStr(namesReserved->Name, name);
1370 ASSERT(conversionResult);
1371 for (uint32 i = 0; i < TOTAL_LOCALES; ++i)
1372 {
1373 if (i == LOCALE_none)
1374 continue;
1375
1376 if (namesReserved->LocaleMask & (1 << i))
1377 _nameValidators[i].emplace_back(name, Trinity::regex::perl | Trinity::regex::icase | Trinity::regex::optimize);
1378 }
1379 }
1380
1381 for (ParagonReputationEntry const* paragonReputation : sParagonReputationStore)
1382 if (sFactionStore.HasRecord(paragonReputation->FactionID))
1383 _paragonReputations[paragonReputation->FactionID] = paragonReputation;
1384
1385 for (PhaseXPhaseGroupEntry const* group : sPhaseXPhaseGroupStore)
1386 if (PhaseEntry const* phase = sPhaseStore.LookupEntry(group->PhaseID))
1387 _phasesByGroup[group->PhaseGroupID].push_back(phase->ID);
1388
1389 for (PowerTypeEntry const* powerType : sPowerTypeStore)
1390 {
1391 ASSERT(powerType->PowerTypeEnum < MAX_POWERS);
1392 ASSERT(!_powerTypes[powerType->PowerTypeEnum]);
1393
1394 _powerTypes[powerType->PowerTypeEnum] = powerType;
1395 }
1396
1397 for (PVPDifficultyEntry const* entry : sPVPDifficultyStore)
1398 {
1399 ASSERT(entry->RangeIndex < MAX_BATTLEGROUND_BRACKETS, "PvpDifficulty bracket (%d) exceeded max allowed value (%d)", entry->RangeIndex, MAX_BATTLEGROUND_BRACKETS);
1400 }
1401
1402 for (PVPItemEntry const* pvpItem : sPVPItemStore)
1403 _pvpItemBonus[pvpItem->ItemID] = pvpItem->ItemLevelDelta;
1404
1405 for (PvpTalentSlotUnlockEntry const* talentUnlock : sPvpTalentSlotUnlockStore)
1406 {
1407 ASSERT(talentUnlock->Slot < (1 << MAX_PVP_TALENT_SLOTS));
1408 for (int8 i = 0; i < MAX_PVP_TALENT_SLOTS; ++i)
1409 {
1410 if (talentUnlock->Slot & (1 << i))
1411 {
1412 ASSERT(!_pvpTalentSlotUnlock[i]);
1413 _pvpTalentSlotUnlock[i] = talentUnlock;
1414 }
1415 }
1416 }
1417
1418 for (QuestLineXQuestEntry const* questLineQuest : sQuestLineXQuestStore)
1419 _questsByQuestLine[questLineQuest->QuestLineID].push_back(questLineQuest);
1420
1421 for (QuestPackageItemEntry const* questPackageItem : sQuestPackageItemStore)
1422 {
1423 if (questPackageItem->DisplayType != QUEST_PACKAGE_FILTER_UNMATCHED)
1424 _questPackages[questPackageItem->PackageID].first.push_back(questPackageItem);
1425 else
1426 _questPackages[questPackageItem->PackageID].second.push_back(questPackageItem);
1427 }
1428
1429 for (RewardPackXCurrencyTypeEntry const* rewardPackXCurrencyType : sRewardPackXCurrencyTypeStore)
1430 _rewardPackCurrencyTypes[rewardPackXCurrencyType->RewardPackID].push_back(rewardPackXCurrencyType);
1431
1432 for (RewardPackXItemEntry const* rewardPackXItem : sRewardPackXItemStore)
1433 _rewardPackItems[rewardPackXItem->RewardPackID].push_back(rewardPackXItem);
1434
1435 for (SkillLineEntry const* skill : sSkillLineStore)
1436 if (skill->ParentSkillLineID)
1437 _skillLinesByParentSkillLine[skill->ParentSkillLineID].push_back(skill);
1438
1439 for (SkillLineAbilityEntry const* skillLineAbility : sSkillLineAbilityStore)
1440 _skillLineAbilitiesBySkillupSkill[skillLineAbility->SkillupSkillLineID ? skillLineAbility->SkillupSkillLineID : skillLineAbility->SkillLine].push_back(skillLineAbility);
1441
1442 for (SkillRaceClassInfoEntry const* entry : sSkillRaceClassInfoStore)
1443 if (sSkillLineStore.LookupEntry(entry->SkillID))
1444 _skillRaceClassInfoBySkill.insert(SkillRaceClassInfoContainer::value_type(entry->SkillID, entry));
1445
1446 for (SoulbindConduitRankEntry const* soulbindConduitRank : sSoulbindConduitRankStore)
1447 _soulbindConduitRanks[{ soulbindConduitRank->SoulbindConduitID, soulbindConduitRank->RankIndex }] = soulbindConduitRank;
1448
1449 for (SpecializationSpellsEntry const* specSpells : sSpecializationSpellsStore)
1450 _specializationSpellsBySpec[specSpells->SpecID].push_back(specSpells);
1451
1452 for (SpecSetMemberEntry const* specSetMember : sSpecSetMemberStore)
1453 _specsBySpecSet.insert(std::make_pair(specSetMember->SpecSetID, uint32(specSetMember->ChrSpecializationID)));
1454
1455 for (SpellClassOptionsEntry const* classOption : sSpellClassOptionsStore)
1456 _spellFamilyNames.insert(classOption->SpellClassSet);
1457
1458 for (SpellProcsPerMinuteModEntry const* ppmMod : sSpellProcsPerMinuteModStore)
1459 _spellProcsPerMinuteMods[ppmMod->SpellProcsPerMinuteID].push_back(ppmMod);
1460
1461 for (SpellVisualMissileEntry const* spellVisualMissile : sSpellVisualMissileStore)
1462 _spellVisualMissilesBySet[spellVisualMissile->SpellVisualMissileSetID].push_back(spellVisualMissile);
1463
1464 for (TalentEntry const* talentInfo : sTalentStore)
1465 {
1466 ASSERT(talentInfo->ClassID < MAX_CLASSES);
1467 ASSERT(talentInfo->TierID < MAX_TALENT_TIERS, "MAX_TALENT_TIERS must be at least %u", talentInfo->TierID + 1);
1468 ASSERT(talentInfo->ColumnIndex < MAX_TALENT_COLUMNS, "MAX_TALENT_COLUMNS must be at least %u", talentInfo->ColumnIndex + 1);
1469
1470 _talentsByPosition[talentInfo->ClassID][talentInfo->TierID][talentInfo->ColumnIndex].push_back(talentInfo);
1471 }
1472
1473 for (TaxiPathEntry const* entry : sTaxiPathStore)
1474 _taxiPaths[{ entry->FromTaxiNode, entry->ToTaxiNode }] = entry;
1475
1476 uint32 pathCount = sTaxiPathStore.GetNumRows();
1477
1478 // Calculate path nodes count
1479 std::vector<uint32> pathLength;
1480 pathLength.resize(pathCount); // 0 and some other indexes not used
1481 for (TaxiPathNodeEntry const* entry : sTaxiPathNodeStore)
1482 if (pathLength[entry->PathID] < entry->NodeIndex + 1u)
1483 pathLength[entry->PathID] = entry->NodeIndex + 1u;
1484
1485 // Set path length
1486 sTaxiPathNodesByPath.resize(pathCount); // 0 and some other indexes not used
1487 for (uint32 i = 0; i < sTaxiPathNodesByPath.size(); ++i)
1488 sTaxiPathNodesByPath[i].resize(pathLength[i]);
1489
1490 // fill data
1491 for (TaxiPathNodeEntry const* entry : sTaxiPathNodeStore)
1492 sTaxiPathNodesByPath[entry->PathID][entry->NodeIndex] = entry;
1493
1494 for (ToyEntry const* toy : sToyStore)
1495 _toys.insert(toy->ItemID);
1496
1497 for (TransmogIllusionEntry const* transmogIllusion : sTransmogIllusionStore)
1498 _transmogIllusionsByEnchantmentId[transmogIllusion->SpellItemEnchantmentID] = transmogIllusion;
1499
1500 for (TransmogSetItemEntry const* transmogSetItem : sTransmogSetItemStore)
1501 {
1502 TransmogSetEntry const* set = sTransmogSetStore.LookupEntry(transmogSetItem->TransmogSetID);
1503 if (!set)
1504 continue;
1505
1506 _transmogSetsByItemModifiedAppearance[transmogSetItem->ItemModifiedAppearanceID].push_back(set);
1507 _transmogSetItemsByTransmogSet[transmogSetItem->TransmogSetID].push_back(transmogSetItem);
1508 }
1509
1510 std::unordered_multimap<int32, UiMapAssignmentEntry const*> uiMapAssignmentByUiMap;
1511 for (UiMapAssignmentEntry const* uiMapAssignment : sUiMapAssignmentStore)
1512 {
1513 uiMapAssignmentByUiMap.emplace(uiMapAssignment->UiMapID, uiMapAssignment);
1514 if (UiMapEntry const* uiMap = sUiMapStore.LookupEntry(uiMapAssignment->UiMapID))
1515 {
1516 ASSERT(uiMap->System < MAX_UI_MAP_SYSTEM, "MAX_UI_MAP_SYSTEM must be at least %u", uiMap->System + 1);
1517 if (uiMapAssignment->MapID >= 0)
1518 _uiMapAssignmentByMap[uiMap->System].emplace(uiMapAssignment->MapID, uiMapAssignment);
1519 if (uiMapAssignment->AreaID)
1520 _uiMapAssignmentByArea[uiMap->System].emplace(uiMapAssignment->AreaID, uiMapAssignment);
1521 if (uiMapAssignment->WmoDoodadPlacementID)
1522 _uiMapAssignmentByWmoDoodadPlacement[uiMap->System].emplace(uiMapAssignment->WmoDoodadPlacementID, uiMapAssignment);
1523 if (uiMapAssignment->WmoGroupID)
1524 _uiMapAssignmentByWmoGroup[uiMap->System].emplace(uiMapAssignment->WmoGroupID, uiMapAssignment);
1525 }
1526 }
1527
1528 std::unordered_map<std::pair<int32, uint32>, UiMapLinkEntry const*> uiMapLinks;
1529 for (UiMapLinkEntry const* uiMapLink : sUiMapLinkStore)
1530 uiMapLinks[std::make_pair(uiMapLink->ParentUiMapID, uint32(uiMapLink->ChildUiMapID))] = uiMapLink;
1531
1532 for (UiMapEntry const* uiMap : sUiMapStore)
1533 {
1534 UiMapBounds& bounds = _uiMapBounds[uiMap->ID];
1535 memset(&bounds, 0, sizeof(bounds));
1536 if (UiMapEntry const* parentUiMap = sUiMapStore.LookupEntry(uiMap->ParentUiMapID))
1537 {
1538 if (parentUiMap->GetFlags().HasFlag(UiMapFlag::NoWorldPositions))
1539 continue;
1540
1541 UiMapAssignmentEntry const* uiMapAssignment = nullptr;
1542 UiMapAssignmentEntry const* parentUiMapAssignment = nullptr;
1543 for (std::pair<int32 const, UiMapAssignmentEntry const*> const& uiMapAssignmentForMap : Trinity::Containers::MapEqualRange(uiMapAssignmentByUiMap, uiMap->ID))
1544 {
1545 if (uiMapAssignmentForMap.second->MapID >= 0 &&
1546 uiMapAssignmentForMap.second->Region[1].X - uiMapAssignmentForMap.second->Region[0].X > 0 &&
1547 uiMapAssignmentForMap.second->Region[1].Y - uiMapAssignmentForMap.second->Region[0].Y > 0)
1548 {
1549 uiMapAssignment = uiMapAssignmentForMap.second;
1550 break;
1551 }
1552 }
1553
1554 if (!uiMapAssignment)
1555 continue;
1556
1557 for (std::pair<int32 const, UiMapAssignmentEntry const*> const& uiMapAssignmentForMap : Trinity::Containers::MapEqualRange(uiMapAssignmentByUiMap, uiMap->ParentUiMapID))
1558 {
1559 if (uiMapAssignmentForMap.second->MapID == uiMapAssignment->MapID &&
1560 uiMapAssignmentForMap.second->Region[1].X - uiMapAssignmentForMap.second->Region[0].X > 0 &&
1561 uiMapAssignmentForMap.second->Region[1].Y - uiMapAssignmentForMap.second->Region[0].Y > 0)
1562 {
1563 parentUiMapAssignment = uiMapAssignmentForMap.second;
1564 break;
1565 }
1566 }
1567
1568 if (!parentUiMapAssignment)
1569 continue;
1570
1571 float parentXsize = parentUiMapAssignment->Region[1].X - parentUiMapAssignment->Region[0].X;
1572 float parentYsize = parentUiMapAssignment->Region[1].Y - parentUiMapAssignment->Region[0].Y;
1573 float bound0scale = (uiMapAssignment->Region[1].X - parentUiMapAssignment->Region[0].X) / parentXsize;
1574 float bound0 = ((1.0f - bound0scale) * parentUiMapAssignment->UiMax.Y) + (bound0scale * parentUiMapAssignment->UiMin.Y);
1575 float bound2scale = (uiMapAssignment->Region[0].X - parentUiMapAssignment->Region[0].X) / parentXsize;
1576 float bound2 = ((1.0f - bound2scale) * parentUiMapAssignment->UiMax.Y) + (bound2scale * parentUiMapAssignment->UiMin.Y);
1577 float bound1scale = (uiMapAssignment->Region[1].Y - parentUiMapAssignment->Region[0].Y) / parentYsize;
1578 float bound1 = ((1.0f - bound1scale) * parentUiMapAssignment->UiMax.X) + (bound1scale * parentUiMapAssignment->UiMin.X);
1579 float bound3scale = (uiMapAssignment->Region[0].Y - parentUiMapAssignment->Region[0].Y) / parentYsize;
1580 float bound3 = ((1.0f - bound3scale) * parentUiMapAssignment->UiMax.X) + (bound3scale * parentUiMapAssignment->UiMin.X);
1581 if ((bound3 - bound1) > 0.0f || (bound2 - bound0) > 0.0f)
1582 {
1583 bounds.Bounds[0] = bound0;
1584 bounds.Bounds[1] = bound1;
1585 bounds.Bounds[2] = bound2;
1586 bounds.Bounds[3] = bound3;
1587 bounds.IsUiAssignment = true;
1588 }
1589 }
1590
1591 if (UiMapLinkEntry const* uiMapLink = Trinity::Containers::MapGetValuePtr(uiMapLinks, std::make_pair(uiMap->ParentUiMapID, uiMap->ID)))
1592 {
1593 bounds.IsUiAssignment = false;
1594 bounds.IsUiLink = true;
1595 bounds.Bounds[0] = uiMapLink->UiMin.Y;
1596 bounds.Bounds[1] = uiMapLink->UiMin.X;
1597 bounds.Bounds[2] = uiMapLink->UiMax.Y;
1598 bounds.Bounds[3] = uiMapLink->UiMax.X;
1599 }
1600 }
1601
1602 for (UiMapXMapArtEntry const* uiMapArt : sUiMapXMapArtStore)
1603 if (uiMapArt->PhaseID)
1604 _uiMapPhases.insert(uiMapArt->PhaseID);
1605
1606 for (WMOAreaTableEntry const* entry : sWMOAreaTableStore)
1607 _wmoAreaTableLookup[WMOAreaTableKey(entry->WmoID, entry->NameSetID, entry->WmoGroupID)] = entry;
1608
1609 // Initialize global taxinodes mask
1610 // reinitialize internal storage for globals after loading TaxiNodes.db2
1611 sTaxiNodesMask = {};
1612 sHordeTaxiNodesMask = {};
1613 sAllianceTaxiNodesMask = {};
1614 sOldContinentsNodesMask = {};
1615 // include existed nodes that have at least single not spell base (scripted) path
1616 for (TaxiNodesEntry const* node : sTaxiNodesStore)
1617 {
1618 if (!node->IsPartOfTaxiNetwork())
1619 continue;
1620
1621 // valid taxi network node
1622 uint32 field = uint32((node->ID - 1) / (sizeof(TaxiMask::value_type) * 8));
1623 TaxiMask::value_type submask = TaxiMask::value_type(1 << ((node->ID - 1) % (sizeof(TaxiMask::value_type) * 8)));
1624
1625 sTaxiNodesMask[field] |= submask;
1626 if (node->GetFlags().HasFlag(TaxiNodeFlags::ShowOnHordeMap))
1627 sHordeTaxiNodesMask[field] |= submask;
1628 if (node->GetFlags().HasFlag(TaxiNodeFlags::ShowOnAllianceMap))
1629 sAllianceTaxiNodesMask[field] |= submask;
1630
1631 int32 uiMapId = -1;
1632 if (!GetUiMapPosition(node->Pos.X, node->Pos.Y, node->Pos.Z, node->ContinentID, 0, 0, 0, UI_MAP_SYSTEM_ADVENTURE, false, &uiMapId))
1633 GetUiMapPosition(node->Pos.X, node->Pos.Y, node->Pos.Z, node->ContinentID, 0, 0, 0, UI_MAP_SYSTEM_TAXI, false, &uiMapId);
1634
1635 if (uiMapId == 985 || uiMapId == 986)
1636 sOldContinentsNodesMask[field] |= submask;
1637 }
1638
1639 for (PVPStatEntry const* pvpStat : sPVPStatStore)
1640 _pvpStatIdsByMap[pvpStat->MapID].insert(pvpStat->ID);
1641
1642 TC_LOG_INFO("server.loading", ">> Initialized {} DB2 data stores in {} ms", _stores.size(), GetMSTimeDiffToNow(oldMSTime));
1643
1644 return availableDb2Locales.to_ulong();
1645}
1646
1647DB2StorageBase const* DB2Manager::GetStorage(uint32 type) const
1648{
1649 auto itr = _stores.find(type);
1650 if (itr != _stores.end())
1651 return itr->second;
1652
1653 return nullptr;
1654}
1655
1656void DB2Manager::LoadHotfixData(uint32 localeMask)
1657{
1658 uint32 oldMSTime = getMSTime();
1659
1660 QueryResult result = HotfixDatabase.Query("SELECT Id, UniqueId, TableHash, RecordId, Status FROM hotfix_data ORDER BY Id");
1661
1662 if (!result)
1663 {
1664 TC_LOG_INFO("server.loading", ">> Loaded 0 hotfix info entries.");
1665 return;
1666 }
1667
1668 uint32 count = 0;
1669
1670 std::map<std::pair<uint32, int32>, bool> deletedRecords;
1671
1672 do
1673 {
1674 Field* fields = result->Fetch();
1675
1676 int32 id = fields[0].GetInt32();
1677 uint32 uniqueId = fields[1].GetUInt32();
1678 uint32 tableHash = fields[2].GetUInt32();
1679 int32 recordId = fields[3].GetInt32();
1680 HotfixRecord::Status status = static_cast<HotfixRecord::Status>(fields[4].GetUInt8());
1681 std::bitset<TOTAL_LOCALES> availableDb2Locales = localeMask;
1682 if (status == HotfixRecord::Status::Valid && !_stores.contains(tableHash))
1683 {
1684 HotfixBlobKey key = std::make_pair(tableHash, recordId);
1685 for (std::size_t locale = 0; locale < TOTAL_LOCALES; ++locale)
1686 {
1687 if (!availableDb2Locales[locale])
1688 continue;
1689
1690 if (!_hotfixBlob[locale].contains(key))
1691 availableDb2Locales[locale] = false;
1692 }
1693
1694 if (availableDb2Locales.none())
1695 {
1696 TC_LOG_ERROR("sql.sql", "Table `hotfix_data` references unknown DB2 store by hash 0x{:X} and has no reference to `hotfix_blob` in hotfix id {} with RecordID: {}", tableHash, id, recordId);
1697 continue;
1698 }
1699 }
1700
1701 HotfixRecord hotfixRecord;
1702 hotfixRecord.TableHash = tableHash;
1703 hotfixRecord.RecordID = recordId;
1704 hotfixRecord.ID.PushID = id;
1705 hotfixRecord.ID.UniqueID = uniqueId;
1706 hotfixRecord.HotfixStatus = status;
1707 hotfixRecord.AvailableLocalesMask = availableDb2Locales.to_ulong();
1708
1709 HotfixPush& push = _hotfixData[id];
1710 push.Records.push_back(hotfixRecord);
1711 push.AvailableLocalesMask |= hotfixRecord.AvailableLocalesMask;
1712
1713 _maxHotfixId = std::max(_maxHotfixId, id);
1714 deletedRecords[std::make_pair(tableHash, recordId)] = status == HotfixRecord::Status::RecordRemoved;
1715 ++count;
1716 } while (result->NextRow());
1717
1718 for (auto itr = deletedRecords.begin(); itr != deletedRecords.end(); ++itr)
1719 if (itr->second)
1720 if (DB2StorageBase* store = Trinity::Containers::MapGetValuePtr(_stores, itr->first.first))
1721 store->EraseRecord(itr->first.second);
1722
1723 TC_LOG_INFO("server.loading", ">> Loaded {} hotfix records in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
1724}
1725
1726void DB2Manager::LoadHotfixBlob(uint32 localeMask)
1727{
1728 uint32 oldMSTime = getMSTime();
1729
1730 QueryResult result = HotfixDatabase.Query("SELECT TableHash, RecordId, locale, `Blob` FROM hotfix_blob ORDER BY TableHash");
1731
1732 if (!result)
1733 {
1734 TC_LOG_INFO("server.loading", ">> Loaded 0 hotfix blob entries.");
1735 return;
1736 }
1737
1738 std::bitset<TOTAL_LOCALES> availableDb2Locales = localeMask;
1739 uint32 hotfixBlobCount = 0;
1740 do
1741 {
1742 Field* fields = result->Fetch();
1743
1744 uint32 tableHash = fields[0].GetUInt32();
1745 auto storeItr = _stores.find(tableHash);
1746 if (storeItr != _stores.end())
1747 {
1748 TC_LOG_ERROR("sql.sql", "Table hash 0x{:X} points to a loaded DB2 store {}, fill related table instead of hotfix_blob",
1749 tableHash, storeItr->second->GetFileName());
1750 continue;
1751 }
1752
1753 int32 recordId = fields[1].GetInt32();
1754 std::string localeName = fields[2].GetString();
1755 LocaleConstant locale = GetLocaleByName(localeName);
1756
1757 if (!IsValidLocale(locale))
1758 {
1759 TC_LOG_ERROR("sql.sql", "`hotfix_blob` contains invalid locale: {} at TableHash: 0x{:X} and RecordID: {}", localeName, tableHash, recordId);
1760 continue;
1761 }
1762
1763 if (!availableDb2Locales[locale])
1764 continue;
1765
1766 _hotfixBlob[locale][std::make_pair(tableHash, recordId)] = fields[3].GetBinary();
1767 hotfixBlobCount++;
1768 } while (result->NextRow());
1769
1770 TC_LOG_INFO("server.loading", ">> Loaded {} hotfix blob records in {} ms", hotfixBlobCount, GetMSTimeDiffToNow(oldMSTime));
1771}
1772
1773bool ValidateBroadcastTextTactKeyOptionalData(std::vector<uint8> const& data)
1774{
1775 return data.size() == 8 + 16;
1776}
1777
1778void DB2Manager::LoadHotfixOptionalData(uint32 localeMask)
1779{
1780 // Register allowed optional data keys
1781 _allowedHotfixOptionalData.emplace(sBroadcastTextStore.GetTableHash(), std::make_pair(sTactKeyStore.GetTableHash(), &ValidateBroadcastTextTactKeyOptionalData));
1782
1783 uint32 oldMSTime = getMSTime();
1784
1785 QueryResult result = HotfixDatabase.Query("SELECT TableHash, RecordId, locale, `Key`, `Data` FROM hotfix_optional_data ORDER BY TableHash");
1786
1787 if (!result)
1788 {
1789 TC_LOG_INFO("server.loading", ">> Loaded 0 hotfix optional data records.");
1790 return;
1791 }
1792
1793 std::bitset<TOTAL_LOCALES> availableDb2Locales = localeMask;
1794 uint32 hotfixOptionalDataCount = 0;
1795 do
1796 {
1797 Field* fields = result->Fetch();
1798
1799 uint32 tableHash = fields[0].GetUInt32();
1800 auto allowedHotfixes = Trinity::Containers::MapEqualRange(_allowedHotfixOptionalData, tableHash);
1801 if (allowedHotfixes.begin() == allowedHotfixes.end())
1802 {
1803 TC_LOG_ERROR("sql.sql", "Table `hotfix_optional_data` references DB2 store by hash 0x{:X} that is not allowed to have optional data", tableHash);
1804 continue;
1805 }
1806
1807 uint32 recordId = fields[1].GetInt32();
1808 auto storeItr = _stores.find(tableHash);
1809 if (storeItr == _stores.end())
1810 {
1811 TC_LOG_ERROR("sql.sql", "Table `hotfix_optional_data` references unknown DB2 store by hash 0x{:X} with RecordID: {}", tableHash, recordId);
1812 continue;
1813 }
1814
1815 std::string localeName = fields[2].GetString();
1816 LocaleConstant locale = GetLocaleByName(localeName);
1817
1818 if (!IsValidLocale(locale))
1819 {
1820 TC_LOG_ERROR("sql.sql", "`hotfix_optional_data` contains invalid locale: {} at TableHash: 0x{:X} and RecordID: {}", localeName, tableHash, recordId);
1821 continue;
1822 }
1823
1824 if (!availableDb2Locales[locale])
1825 continue;
1826
1827 DB2Manager::HotfixOptionalData optionalData;
1828 optionalData.Key = fields[3].GetUInt32();
1829 auto allowedHotfixItr = std::find_if(allowedHotfixes.begin(), allowedHotfixes.end(), [&](std::pair<uint32 const, AllowedHotfixOptionalData> const& v)
1830 {
1831 return v.second.first == optionalData.Key;
1832 });
1833 if (allowedHotfixItr == allowedHotfixes.end())
1834 {
1835 TC_LOG_ERROR("sql.sql", "Table `hotfix_optional_data` references non-allowed optional data key 0x{:X} for DB2 store by hash 0x{:X} and RecordID: {}",
1836 optionalData.Key, tableHash, recordId);
1837 continue;
1838 }
1839
1840 optionalData.Data = fields[4].GetBinary();
1841 if (!allowedHotfixItr->second.second(optionalData.Data))
1842 {
1843 TC_LOG_ERROR("sql.sql", "Table `hotfix_optional_data` contains invalid data for DB2 store 0x{:X}, RecordID: {} and Key: 0x{:X}",
1844 tableHash, recordId, optionalData.Key);
1845 continue;
1846 }
1847
1848 _hotfixOptionalData[locale][std::make_pair(tableHash, recordId)].push_back(std::move(optionalData));
1849 hotfixOptionalDataCount++;
1850 } while (result->NextRow());
1851
1852 TC_LOG_INFO("server.loading", ">> Loaded {} hotfix optional data records in {} ms", hotfixOptionalDataCount, GetMSTimeDiffToNow(oldMSTime));
1853}
1854
1855uint32 DB2Manager::GetHotfixCount() const
1856{
1857 return _hotfixData.size();
1858}
1859
1860DB2Manager::HotfixContainer const& DB2Manager::GetHotfixData() const
1861{
1862 return _hotfixData;
1863}
1864
1865std::vector<uint8> const* DB2Manager::GetHotfixBlobData(uint32 tableHash, int32 recordId, LocaleConstant locale) const
1866{
1867 ASSERT(IsValidLocale(locale), "Locale %u is invalid locale", uint32(locale));
1868
1869 return Trinity::Containers::MapGetValuePtr(_hotfixBlob[locale], std::make_pair(tableHash, recordId));
1870}
1871
1872std::vector<DB2Manager::HotfixOptionalData> const* DB2Manager::GetHotfixOptionalData(uint32 tableHash, int32 recordId, LocaleConstant locale) const
1873{
1874 ASSERT(IsValidLocale(locale), "Locale %u is invalid locale", uint32(locale));
1875
1876 return Trinity::Containers::MapGetValuePtr(_hotfixOptionalData[locale], std::make_pair(tableHash, recordId));
1877}
1878
1879uint32 DB2Manager::GetEmptyAnimStateID() const
1880{
1881 return sAnimationDataStore.GetNumRows();
1882}
1883
1884void DB2Manager::InsertNewHotfix(uint32 tableHash, uint32 recordId)
1885{
1886 HotfixRecord hotfixRecord;
1887 hotfixRecord.TableHash = tableHash;
1888 hotfixRecord.RecordID = recordId;
1889 hotfixRecord.ID.PushID = ++_maxHotfixId;
1890 hotfixRecord.ID.UniqueID = rand32();
1891 hotfixRecord.AvailableLocalesMask = 0xDFF;
1892
1893 HotfixPush& push = _hotfixData[hotfixRecord.ID.PushID];
1894 push.Records.push_back(hotfixRecord);
1895 push.AvailableLocalesMask |= hotfixRecord.AvailableLocalesMask;
1896}
1897
1898std::vector<uint32> DB2Manager::GetAreasForGroup(uint32 areaGroupId) const
1899{
1900 auto itr = _areaGroupMembers.find(areaGroupId);
1901 if (itr != _areaGroupMembers.end())
1902 return itr->second;
1903
1904 return std::vector<uint32>();
1905}
1906
1907bool DB2Manager::IsInArea(uint32 objectAreaId, uint32 areaId)
1908{
1909 do
1910 {
1911 if (objectAreaId == areaId)
1912 return true;
1913
1914 AreaTableEntry const* objectArea = sAreaTableStore.LookupEntry(objectAreaId);
1915 if (!objectArea)
1916 break;
1917
1918 objectAreaId = objectArea->ParentAreaID;
1919 } while (objectAreaId);
1920
1921 return false;
1922}
1923
1924ContentTuningEntry const* DB2Manager::GetContentTuningForArea(AreaTableEntry const* areaEntry)
1925{
1926 if (!areaEntry)
1927 return nullptr;
1928
1929 // Get ContentTuning for the area
1930 if (ContentTuningEntry const* contentTuning = sContentTuningStore.LookupEntry(areaEntry->ContentTuningID))
1931 return contentTuning;
1932
1933 // If there is no data for the current area and it has a parent area, get data from the last (recursive)
1934 if (AreaTableEntry const* parentAreaEntry = sAreaTableStore.LookupEntry(areaEntry->ParentAreaID))
1935 return GetContentTuningForArea(parentAreaEntry);
1936
1937 return nullptr;
1938}
1939
1940std::vector<ArtifactPowerEntry const*> DB2Manager::GetArtifactPowers(uint8 artifactId) const
1941{
1942 auto itr = _artifactPowers.find(artifactId);
1943 if (itr != _artifactPowers.end())
1944 return itr->second;
1945
1946 return std::vector<ArtifactPowerEntry const*>{};
1947}
1948
1949std::vector<uint32> const* DB2Manager::GetArtifactPowerLinks(uint32 artifactPowerId) const
1950{
1951 return Trinity::Containers::MapGetValuePtr(_artifactPowerLinks, artifactPowerId);
1952}
1953
1954ArtifactPowerRankEntry const* DB2Manager::GetArtifactPowerRank(uint32 artifactPowerId, uint8 rank) const
1955{
1956 return Trinity::Containers::MapGetValuePtr(_artifactPowerRanks, { artifactPowerId, rank });
1957}
1958
1959AzeriteEmpoweredItemEntry const* DB2Manager::GetAzeriteEmpoweredItem(uint32 itemId) const
1960{
1961 return Trinity::Containers::MapGetValuePtr(_azeriteEmpoweredItems, itemId);
1962}
1963
1964bool DB2Manager::IsAzeriteItem(uint32 itemId) const
1965{
1966 return std::find_if(sAzeriteItemStore.begin(), sAzeriteItemStore.end(),
1967 [&](AzeriteItemEntry const* azeriteItem) { return azeriteItem->ItemID == int32(itemId); }) != sAzeriteItemStore.end();
1968}
1969
1970AzeriteEssencePowerEntry const* DB2Manager::GetAzeriteEssencePower(uint32 azeriteEssenceId, uint32 rank) const
1971{
1972 return Trinity::Containers::MapGetValuePtr(_azeriteEssencePowersByIdAndRank, std::make_pair(azeriteEssenceId, rank));
1973}
1974
1975std::vector<AzeriteItemMilestonePowerEntry const*> const& DB2Manager::GetAzeriteItemMilestonePowers() const
1976{
1977 return _azeriteItemMilestonePowers;
1978}
1979
1980AzeriteItemMilestonePowerEntry const* DB2Manager::GetAzeriteItemMilestonePower(uint8 slot) const
1981{
1982 ASSERT(slot < MAX_AZERITE_ESSENCE_SLOT, "Slot %u must be lower than MAX_AZERITE_ESSENCE_SLOT (%u)", uint32(slot), MAX_AZERITE_ESSENCE_SLOT);
1983 return _azeriteItemMilestonePowerByEssenceSlot[slot];
1984}
1985
1986std::vector<AzeritePowerSetMemberEntry const*> const* DB2Manager::GetAzeritePowers(uint32 itemId) const
1987{
1988 if (AzeriteEmpoweredItemEntry const* azeriteEmpoweredItem = GetAzeriteEmpoweredItem(itemId))
1989 return Trinity::Containers::MapGetValuePtr(_azeritePowers, azeriteEmpoweredItem->AzeritePowerSetID);
1990
1991 return nullptr;
1992}
1993
1994uint32 DB2Manager::GetRequiredAzeriteLevelForAzeritePowerTier(uint32 azeriteUnlockSetId, ItemContext context, uint32 tier) const
1995{
1996 ASSERT(tier < MAX_AZERITE_EMPOWERED_TIER);
1997 if (std::array<uint8, MAX_AZERITE_EMPOWERED_TIER> const* levels = Trinity::Containers::MapGetValuePtr(_azeriteTierUnlockLevels, std::make_pair(azeriteUnlockSetId, context)))
1998 return (*levels)[tier];
1999
2000 AzeriteTierUnlockSetEntry const* azeriteTierUnlockSet = sAzeriteTierUnlockSetStore.LookupEntry(azeriteUnlockSetId);
2001 if (azeriteTierUnlockSet && azeriteTierUnlockSet->Flags & AZERITE_TIER_UNLOCK_SET_FLAG_DEFAULT)
2002 if (std::array<uint8, MAX_AZERITE_EMPOWERED_TIER> const* levels = Trinity::Containers::MapGetValuePtr(_azeriteTierUnlockLevels, std::make_pair(azeriteUnlockSetId, ItemContext::NONE)))
2003 return (*levels)[tier];
2004
2005 return sAzeriteLevelInfoStore.GetNumRows();
2006}
2007
2008char const* DB2Manager::GetBroadcastTextValue(BroadcastTextEntry const* broadcastText, LocaleConstant locale /*= DEFAULT_LOCALE*/, uint8 gender /*= GENDER_MALE*/, bool forceGender /*= false*/)
2009{
2010 if ((gender == GENDER_FEMALE || gender == GENDER_NONE) && (forceGender || broadcastText->Text1[DEFAULT_LOCALE][0] != '\0'))
2011 {
2012 if (broadcastText->Text1[locale][0] != '\0')
2013 return broadcastText->Text1[locale];
2014
2015 return broadcastText->Text1[DEFAULT_LOCALE];
2016 }
2017
2018 if (broadcastText->Text[locale][0] != '\0')
2019 return broadcastText->Text[locale];
2020
2021 return broadcastText->Text[DEFAULT_LOCALE];
2022}
2023
2024int32 const* DB2Manager::GetBroadcastTextDuration(int32 broadcastTextId, LocaleConstant locale /*= DEFAULT_LOCALE*/) const
2025{
2026 return Trinity::Containers::MapGetValuePtr(_broadcastTextDurations, { broadcastTextId, WowLocaleToCascLocaleBit[locale] });
2027}
2028
2029ChrClassUIDisplayEntry const* DB2Manager::GetUiDisplayForClass(Classes unitClass) const
2030{
2031 ASSERT(unitClass < MAX_CLASSES);
2032 return _uiDisplayByClass[unitClass];
2033}
2034
2035char const* DB2Manager::GetClassName(uint8 class_, LocaleConstant locale /*= DEFAULT_LOCALE*/)
2036{
2037 ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(class_);
2038 if (!classEntry)
2039 return "";
2040
2041 if (classEntry->Name[locale][0] != '\0')
2042 return classEntry->Name[locale];
2043
2044 return classEntry->Name[DEFAULT_LOCALE];
2045}
2046
2047uint32 DB2Manager::GetPowerIndexByClass(Powers power, uint32 classId) const
2048{
2049 return _powersByClass[classId][power];
2050}
2051
2052std::vector<ChrCustomizationChoiceEntry const*> const* DB2Manager::GetCustomiztionChoices(uint32 chrCustomizationOptionId) const
2053{
2054 return Trinity::Containers::MapGetValuePtr(_chrCustomizationChoicesByOption, chrCustomizationOptionId);
2055}
2056
2057std::vector<ChrCustomizationOptionEntry const*> const* DB2Manager::GetCustomiztionOptions(uint8 race, uint8 gender) const
2058{
2059 return Trinity::Containers::MapGetValuePtr(_chrCustomizationOptionsByRaceAndGender, { race,gender });
2060}
2061
2062std::vector<std::pair<uint32, std::vector<uint32>>> const* DB2Manager::GetRequiredCustomizationChoices(uint32 chrCustomizationReqId) const
2063{
2064 return Trinity::Containers::MapGetValuePtr(_chrCustomizationRequiredChoices, chrCustomizationReqId);
2065}
2066
2067ChrModelEntry const* DB2Manager::GetChrModel(uint8 race, uint8 gender) const
2068{
2069 return Trinity::Containers::MapGetValuePtr(_chrModelsByRaceAndGender, { race, gender });
2070}
2071
2072ConditionalChrModelEntry const* DB2Manager::GetConditionalChrModel(int32 chrModelId)
2073{
2074 return Trinity::Containers::MapGetValuePtr(_conditionalChrModelsByChrModelId, chrModelId);
2075}
2076
2077char const* DB2Manager::GetChrRaceName(uint8 race, LocaleConstant locale /*= DEFAULT_LOCALE*/)
2078{
2079 ChrRacesEntry const* raceEntry = sChrRacesStore.LookupEntry(race);
2080 if (!raceEntry)
2081 return "";
2082
2083 if (raceEntry->Name[locale][0] != '\0')
2084 return raceEntry->Name[locale];
2085
2086 return raceEntry->Name[DEFAULT_LOCALE];
2087}
2088
2089ChrSpecializationEntry const* DB2Manager::GetChrSpecializationByIndex(uint32 class_, uint32 index) const
2090{
2091 return _chrSpecializationsByIndex[class_][index];
2092}
2093
2094ChrSpecializationEntry const* DB2Manager::GetDefaultChrSpecializationForClass(uint32 class_) const
2095{
2096 return GetChrSpecializationByIndex(class_, INITIAL_SPECIALIZATION_INDEX);
2097}
2098
2099uint32 DB2Manager::GetRedirectedContentTuningId(uint32 contentTuningId, uint32 redirectFlag) const
2100{
2101 for (auto [_, conditionalContentTuning] : Trinity::Containers::MapEqualRange(_conditionalContentTuning, contentTuningId))
2102 if (conditionalContentTuning->RedirectFlag & redirectFlag)
2103 return conditionalContentTuning->RedirectContentTuningID;
2104
2105 return contentTuningId;
2106}
2107
2108Optional<ContentTuningLevels> DB2Manager::GetContentTuningData(uint32 contentTuningId, uint32 redirectFlag, bool forItem /*= false*/) const
2109{
2110 ContentTuningEntry const* contentTuning = sContentTuningStore.LookupEntry(GetRedirectedContentTuningId(contentTuningId, redirectFlag));
2111 if (!contentTuning)
2112 return {};
2113
2114 if (forItem && contentTuning->GetFlags().HasFlag(ContentTuningFlag::DisabledForItem))
2115 return {};
2116
2117 auto getLevelAdjustment = [](ContentTuningCalcType type) -> int32
2118 {
2119 switch (type)
2120 {
2121 case ContentTuningCalcType::PlusOne:
2122 return 1;
2123 case ContentTuningCalcType::PlusMaxLevelForExpansion:
2124 return GetMaxLevelForExpansion(sWorld->getIntConfig(CONFIG_EXPANSION));
2125 default:
2126 break;
2127 }
2128
2129 return 0;
2130 };
2131
2132 ContentTuningLevels levels;
2133 levels.MinLevel = contentTuning->MinLevel + getLevelAdjustment(static_cast<ContentTuningCalcType>(contentTuning->MinLevelType));
2134 levels.MaxLevel = contentTuning->MaxLevel + getLevelAdjustment(static_cast<ContentTuningCalcType>(contentTuning->MaxLevelType));
2135 levels.MinLevelWithDelta = std::clamp<int32>(levels.MinLevel + contentTuning->TargetLevelDelta, 1, MAX_LEVEL);
2136 levels.MaxLevelWithDelta = std::clamp<int32>(levels.MaxLevel + contentTuning->TargetLevelMaxDelta, 1, MAX_LEVEL);
2137
2138 // clamp after calculating levels with delta (delta can bring "overflown" level back into correct range)
2139 levels.MinLevel = std::clamp<int32>(levels.MinLevel, 1, MAX_LEVEL);
2140 levels.MaxLevel = std::clamp<int32>(levels.MaxLevel, 1, MAX_LEVEL);
2141
2142 if (contentTuning->TargetLevelMin)
2143 levels.TargetLevelMin = contentTuning->TargetLevelMin;
2144 else
2145 levels.TargetLevelMin = levels.MinLevelWithDelta;
2146
2147 if (contentTuning->TargetLevelMax)
2148 levels.TargetLevelMax = contentTuning->TargetLevelMax;
2149 else
2150 levels.TargetLevelMax = levels.MaxLevelWithDelta;
2151
2152 return levels;
2153}
2154
2155bool DB2Manager::HasContentTuningLabel(uint32 contentTuningId, int32 label) const
2156{
2157 return _contentTuningLabels.contains({ contentTuningId, label });
2158}
2159
2160char const* DB2Manager::GetCreatureFamilyPetName(uint32 petfamily, LocaleConstant locale)
2161{
2162 if (!petfamily)
2163 return nullptr;
2164
2165 CreatureFamilyEntry const* petFamily = sCreatureFamilyStore.LookupEntry(petfamily);
2166 if (!petFamily)
2167 return nullptr;
2168
2169 return petFamily->Name[locale][0] != '\0' ? petFamily->Name[locale] : nullptr;
2170}
2171
2172CurrencyContainerEntry const* DB2Manager::GetCurrencyContainerForCurrencyQuantity(uint32 currencyId, int32 quantity) const
2173{
2174 for (std::pair<uint32 const, CurrencyContainerEntry const*> const& p : Trinity::Containers::MapEqualRange(_currencyContainers, currencyId))
2175 if (quantity >= p.second->MinAmount && (!p.second->MaxAmount || quantity <= p.second->MaxAmount))
2176 return p.second;
2177
2178 return nullptr;
2179}
2180
2181std::pair<float, float> DB2Manager::GetCurveXAxisRange(uint32 curveId) const
2182{
2183 if (std::vector<DBCPosition2D> const* points = Trinity::Containers::MapGetValuePtr(_curvePoints, curveId))
2184 return { points->front().X, points->back().X };
2185
2186 return { 0.0f, 0.0f };
2187}
2188
2189static CurveInterpolationMode DetermineCurveType(CurveEntry const* curve, std::vector<DBCPosition2D> const& points)
2190{
2191 switch (curve->Type)
2192 {
2193 case 1:
2194 return points.size() < 4 ? CurveInterpolationMode::Cosine : CurveInterpolationMode::CatmullRom;
2195 case 2:
2196 {
2197 switch (points.size())
2198 {
2199 case 1:
2200 return CurveInterpolationMode::Constant;
2201 case 2:
2202 return CurveInterpolationMode::Linear;
2203 case 3:
2204 return CurveInterpolationMode::Bezier3;
2205 case 4:
2206 return CurveInterpolationMode::Bezier4;
2207 default:
2208 break;
2209 }
2210 return CurveInterpolationMode::Bezier;
2211 }
2212 case 3:
2213 return CurveInterpolationMode::Cosine;
2214 default:
2215 break;
2216 }
2217
2218 return points.size() != 1 ? CurveInterpolationMode::Linear : CurveInterpolationMode::Constant;
2219}
2220
2221float DB2Manager::GetCurveValueAt(uint32 curveId, float x) const
2222{
2223 auto itr = _curvePoints.find(curveId);
2224 if (itr == _curvePoints.end())
2225 return 0.0f;
2226
2227 CurveEntry const* curve = sCurveStore.AssertEntry(curveId);
2228 std::vector<DBCPosition2D> const& points = itr->second;
2229 if (points.empty())
2230 return 0.0f;
2231
2232 return GetCurveValueAt(DetermineCurveType(curve, points), points, x);
2233}
2234
2235float DB2Manager::GetCurveValueAt(CurveInterpolationMode mode, std::span<DBCPosition2D const> points, float x) const
2236{
2237 switch (mode)
2238 {
2239 case CurveInterpolationMode::Linear:
2240 {
2241 std::size_t pointIndex = 0;
2242 while (pointIndex < points.size() && points[pointIndex].X <= x)
2243 ++pointIndex;
2244 if (!pointIndex)
2245 return points[0].Y;
2246 if (pointIndex >= points.size())
2247 return points.back().Y;
2248 float xDiff = points[pointIndex].X - points[pointIndex - 1].X;
2249 if (xDiff == 0.0)
2250 return points[pointIndex].Y;
2251 return (((x - points[pointIndex - 1].X) / xDiff) * (points[pointIndex].Y - points[pointIndex - 1].Y)) + points[pointIndex - 1].Y;
2252 }
2253 case CurveInterpolationMode::Cosine:
2254 {
2255 std::size_t pointIndex = 0;
2256 while (pointIndex < points.size() && points[pointIndex].X <= x)
2257 ++pointIndex;
2258 if (!pointIndex)
2259 return points[0].Y;
2260 if (pointIndex >= points.size())
2261 return points.back().Y;
2262 float xDiff = points[pointIndex].X - points[pointIndex - 1].X;
2263 if (xDiff == 0.0)
2264 return points[pointIndex].Y;
2265 return ((points[pointIndex].Y - points[pointIndex - 1].Y) * (1.0f - std::cos((x - points[pointIndex - 1].X) / xDiff * float(M_PI))) * 0.5f) + points[pointIndex - 1].Y;
2266 }
2267 case CurveInterpolationMode::CatmullRom:
2268 {
2269 std::size_t pointIndex = 1;
2270 while (pointIndex < points.size() && points[pointIndex].X <= x)
2271 ++pointIndex;
2272 if (pointIndex == 1)
2273 return points[1].Y;
2274 if (pointIndex >= points.size() - 1)
2275 return points[points.size() - 2].Y;
2276 float xDiff = points[pointIndex].X - points[pointIndex - 1].X;
2277 if (xDiff == 0.0)
2278 return points[pointIndex].Y;
2279
2280 float mu = (x - points[pointIndex - 1].X) / xDiff;
2281 float a0 = -0.5f * points[pointIndex - 2].Y + 1.5f * points[pointIndex - 1].Y - 1.5f * points[pointIndex].Y + 0.5f * points[pointIndex + 1].Y;
2282 float a1 = points[pointIndex - 2].Y - 2.5f * points[pointIndex - 1].Y + 2.0f * points[pointIndex].Y - 0.5f * points[pointIndex + 1].Y;
2283 float a2 = -0.5f * points[pointIndex - 2].Y + 0.5f * points[pointIndex].Y;
2284 float a3 = points[pointIndex - 1].Y;
2285
2286 return a0 * mu * mu * mu + a1 * mu * mu + a2 * mu + a3;
2287 }
2288 case CurveInterpolationMode::Bezier3:
2289 {
2290 float xDiff = points[2].X - points[0].X;
2291 if (xDiff == 0.0)
2292 return points[1].Y;
2293 float mu = (x - points[0].X) / xDiff;
2294 return ((1.0f - mu) * (1.0f - mu) * points[0].Y) + (1.0f - mu) * 2.0f * mu * points[1].Y + mu * mu * points[2].Y;
2295 }
2296 case CurveInterpolationMode::Bezier4:
2297 {
2298 float xDiff = points[3].X - points[0].X;
2299 if (xDiff == 0.0)
2300 return points[1].Y;
2301 float mu = (x - points[0].X) / xDiff;
2302 return (1.0f - mu) * (1.0f - mu) * (1.0f - mu) * points[0].Y
2303 + 3.0f * mu * (1.0f - mu) * (1.0f - mu) * points[1].Y
2304 + 3.0f * mu * mu * (1.0f - mu) * points[2].Y
2305 + mu * mu * mu * points[3].Y;
2306 }
2307 case CurveInterpolationMode::Bezier:
2308 {
2309 float xDiff = points.back().X - points[0].X;
2310 if (xDiff == 0.0f)
2311 return points.back().Y;
2312
2313 std::vector<float> tmp(points.size());
2314 for (std::size_t i = 0; i < points.size(); ++i)
2315 tmp[i] = points[i].Y;
2316
2317 float mu = (x - points[0].X) / xDiff;
2318 int32 i = int32(points.size()) - 1;
2319 while (i > 0)
2320 {
2321 for (int32 k = 0; k < i; ++k)
2322 {
2323 float val = tmp[k] + mu * (tmp[k + 1] - tmp[k]);
2324 tmp[k] = val;
2325 }
2326 --i;
2327 }
2328 return tmp[0];
2329 }
2330 case CurveInterpolationMode::Constant:
2331 return points[0].Y;
2332 default:
2333 break;
2334 }
2335
2336 return 0.0f;
2337}
2338
2339EmotesTextSoundEntry const* DB2Manager::GetTextSoundEmoteFor(uint32 emote, uint8 race, uint8 gender, uint8 class_) const
2340{
2341 if (EmotesTextSoundEntry const* emotesTextSound = Trinity::Containers::MapGetValuePtr(_emoteTextSounds, { emote, race, gender, class_ }))
2342 return emotesTextSound;
2343
2344 if (EmotesTextSoundEntry const* emotesTextSound = Trinity::Containers::MapGetValuePtr(_emoteTextSounds, { emote, race, gender, uint8(0) }))
2345 return emotesTextSound;
2346
2347 return nullptr;
2348}
2349
2350template<float(ExpectedStatModEntry::*field)>
2351struct ExpectedStatModReducer
2352{
2353 explicit ExpectedStatModReducer(int32 mythicPlusMilestoneSeason) : ActiveMilestoneSeason(mythicPlusMilestoneSeason) { }
2354
2355 float operator()(float mod, ContentTuningXExpectedEntry const* contentTuningXExpected) const
2356 {
2357 if (!contentTuningXExpected)
2358 return mod;
2359
2360 if (contentTuningXExpected->MinMythicPlusSeasonID)
2361 if (MythicPlusSeasonEntry const* mythicPlusSeason = sMythicPlusSeasonStore.LookupEntry(contentTuningXExpected->MinMythicPlusSeasonID))
2362 if (ActiveMilestoneSeason < mythicPlusSeason->MilestoneSeason)
2363 return mod;
2364
2365 if (contentTuningXExpected->MaxMythicPlusSeasonID)
2366 if (MythicPlusSeasonEntry const* mythicPlusSeason = sMythicPlusSeasonStore.LookupEntry(contentTuningXExpected->MaxMythicPlusSeasonID))
2367 if (ActiveMilestoneSeason >= mythicPlusSeason->MilestoneSeason)
2368 return mod;
2369
2370 return mod * sExpectedStatModStore.AssertEntry(contentTuningXExpected->ExpectedStatModID)->*field;
2371 }
2372
2373 int32 ActiveMilestoneSeason = 0;
2374};
2375
2376float DB2Manager::EvaluateExpectedStat(ExpectedStatType stat, uint32 level, int32 expansion, uint32 contentTuningId, Classes unitClass, int32 mythicPlusMilestoneSeason) const
2377{
2378 auto expectedStatItr = _expectedStatsByLevel.find(std::make_pair(level, expansion));
2379 if (expectedStatItr == _expectedStatsByLevel.end())
2380 expectedStatItr = _expectedStatsByLevel.find(std::make_pair(level, -2));
2381
2382 if (expectedStatItr == _expectedStatsByLevel.end())
2383 return 1.0f;
2384
2385 ExpectedStatModEntry const* classMod = nullptr;
2386 switch (unitClass)
2387 {
2388 case CLASS_WARRIOR:
2389 classMod = sExpectedStatModStore.LookupEntry(4);
2390 break;
2391 case CLASS_PALADIN:
2392 classMod = sExpectedStatModStore.LookupEntry(2);
2393 break;
2394 case CLASS_ROGUE:
2395 classMod = sExpectedStatModStore.LookupEntry(3);
2396 break;
2397 case CLASS_MAGE:
2398 classMod = sExpectedStatModStore.LookupEntry(1);
2399 break;
2400 default:
2401 break;
2402 }
2403
2404 std::vector<ContentTuningXExpectedEntry const*> const* contentTuningMods = Trinity::Containers::MapGetValuePtr(_expectedStatModsByContentTuning, contentTuningId);
2405 float value = 0.0f;
2406 switch (stat)
2407 {
2408 case ExpectedStatType::CreatureHealth:
2409 value = expectedStatItr->second->CreatureHealth;
2410 if (contentTuningMods)
2411 value *= std::accumulate(contentTuningMods->begin(), contentTuningMods->end(), 1.0f,
2412 ExpectedStatModReducer<&ExpectedStatModEntry::CreatureHealthMod>(mythicPlusMilestoneSeason));
2413 if (classMod)
2414 value *= classMod->CreatureHealthMod;
2415 break;
2416 case ExpectedStatType::PlayerHealth:
2417 value = expectedStatItr->second->PlayerHealth;
2418 if (contentTuningMods)
2419 value *= std::accumulate(contentTuningMods->begin(), contentTuningMods->end(), 1.0f,
2420 ExpectedStatModReducer<&ExpectedStatModEntry::PlayerHealthMod>(mythicPlusMilestoneSeason));
2421 if (classMod)
2422 value *= classMod->PlayerHealthMod;
2423 break;
2424 case ExpectedStatType::CreatureAutoAttackDps:
2425 value = expectedStatItr->second->CreatureAutoAttackDps;
2426 if (contentTuningMods)
2427 value *= std::accumulate(contentTuningMods->begin(), contentTuningMods->end(), 1.0f,
2428 ExpectedStatModReducer<&ExpectedStatModEntry::CreatureAutoAttackDPSMod>(mythicPlusMilestoneSeason));
2429 if (classMod)
2430 value *= classMod->CreatureAutoAttackDPSMod;
2431 break;
2432 case ExpectedStatType::CreatureArmor:
2433 value = expectedStatItr->second->CreatureArmor;
2434 if (contentTuningMods)
2435 value *= std::accumulate(contentTuningMods->begin(), contentTuningMods->end(), 1.0f,
2436 ExpectedStatModReducer<&ExpectedStatModEntry::CreatureArmorMod>(mythicPlusMilestoneSeason));
2437 if (classMod)
2438 value *= classMod->CreatureArmorMod;
2439 break;
2440 case ExpectedStatType::PlayerMana:
2441 value = expectedStatItr->second->PlayerMana;
2442 if (contentTuningMods)
2443 value *= std::accumulate(contentTuningMods->begin(), contentTuningMods->end(), 1.0f,
2444 ExpectedStatModReducer<&ExpectedStatModEntry::PlayerManaMod>(mythicPlusMilestoneSeason));
2445 if (classMod)
2446 value *= classMod->PlayerManaMod;
2447 break;
2448 case ExpectedStatType::PlayerPrimaryStat:
2449 value = expectedStatItr->second->PlayerPrimaryStat;
2450 if (contentTuningMods)
2451 value *= std::accumulate(contentTuningMods->begin(), contentTuningMods->end(), 1.0f,
2452 ExpectedStatModReducer<&ExpectedStatModEntry::PlayerPrimaryStatMod>(mythicPlusMilestoneSeason));
2453 if (classMod)
2454 value *= classMod->PlayerPrimaryStatMod;
2455 break;
2456 case ExpectedStatType::PlayerSecondaryStat:
2457 value = expectedStatItr->second->PlayerSecondaryStat;
2458 if (contentTuningMods)
2459 value *= std::accumulate(contentTuningMods->begin(), contentTuningMods->end(), 1.0f,
2460 ExpectedStatModReducer<&ExpectedStatModEntry::PlayerSecondaryStatMod>(mythicPlusMilestoneSeason));
2461 if (classMod)
2462 value *= classMod->PlayerSecondaryStatMod;
2463 break;
2464 case ExpectedStatType::ArmorConstant:
2465 value = expectedStatItr->second->ArmorConstant;
2466 if (contentTuningMods)
2467 value *= std::accumulate(contentTuningMods->begin(), contentTuningMods->end(), 1.0f,
2468 ExpectedStatModReducer<&ExpectedStatModEntry::ArmorConstantMod>(mythicPlusMilestoneSeason));
2469 if (classMod)
2470 value *= classMod->ArmorConstantMod;
2471 break;
2472 case ExpectedStatType::None:
2473 break;
2474 case ExpectedStatType::CreatureSpellDamage:
2475 value = expectedStatItr->second->CreatureSpellDamage;
2476 if (contentTuningMods)
2477 value *= std::accumulate(contentTuningMods->begin(), contentTuningMods->end(), 1.0f,
2478 ExpectedStatModReducer<&ExpectedStatModEntry::CreatureSpellDamageMod>(mythicPlusMilestoneSeason));
2479 if (classMod)
2480 value *= classMod->CreatureSpellDamageMod;
2481 break;
2482 default:
2483 break;
2484 }
2485
2486 return value;
2487}
2488
2489std::vector<uint32> const* DB2Manager::GetFactionTeamList(uint32 faction) const
2490{
2491 return Trinity::Containers::MapGetValuePtr(_factionTeams, faction);
2492}
2493
2494DB2Manager::FriendshipRepReactionSet const* DB2Manager::GetFriendshipRepReactions(uint32 friendshipRepID) const
2495{
2496 return Trinity::Containers::MapGetValuePtr(_friendshipRepReactions, friendshipRepID);
2497}
2498
2499uint32 DB2Manager::GetGlobalCurveId(GlobalCurve globalCurveType) const
2500{
2501 for (GlobalCurveEntry const* globalCurveEntry : sGlobalCurveStore)
2502 if (GlobalCurve(globalCurveEntry->Type) == globalCurveType)
2503 return globalCurveEntry->CurveID;
2504
2505 return 0;
2506}
2507
2508std::vector<uint32> const* DB2Manager::GetGlyphBindableSpells(uint32 glyphPropertiesId) const
2509{
2510 return Trinity::Containers::MapGetValuePtr(_glyphBindableSpells, glyphPropertiesId);
2511}
2512
2513std::vector<ChrSpecialization> const* DB2Manager::GetGlyphRequiredSpecs(uint32 glyphPropertiesId) const
2514{
2515 return Trinity::Containers::MapGetValuePtr(_glyphRequiredSpecs, glyphPropertiesId);
2516}
2517
2518HeirloomEntry const* DB2Manager::GetHeirloomByItemId(uint32 itemId) const
2519{
2520 return Trinity::Containers::MapGetValuePtr(_heirlooms, itemId);
2521}
2522
2523ItemChildEquipmentEntry const* DB2Manager::GetItemChildEquipment(uint32 itemId) const
2524{
2525 return Trinity::Containers::MapGetValuePtr(_itemChildEquipment, itemId);
2526}
2527
2528ItemClassEntry const* DB2Manager::GetItemClassByOldEnum(uint32 itemClass) const
2529{
2530 return _itemClassByOldEnum[itemClass];
2531}
2532
2533bool DB2Manager::HasItemCurrencyCost(uint32 itemId) const
2534{
2535 return _itemsWithCurrencyCost.count(itemId) > 0;
2536}
2537
2538std::vector<ItemLimitCategoryConditionEntry const*> const* DB2Manager::GetItemLimitCategoryConditions(uint32 categoryId) const
2539{
2540 return Trinity::Containers::MapGetValuePtr(_itemCategoryConditions, categoryId);
2541}
2542
2543uint32 DB2Manager::GetItemDisplayId(uint32 itemId, uint32 appearanceModId) const
2544{
2545 if (ItemModifiedAppearanceEntry const* modifiedAppearance = GetItemModifiedAppearance(itemId, appearanceModId))
2546 if (ItemAppearanceEntry const* itemAppearance = sItemAppearanceStore.LookupEntry(modifiedAppearance->ItemAppearanceID))
2547 return itemAppearance->ItemDisplayInfoID;
2548
2549 return 0;
2550}
2551
2552ItemModifiedAppearanceEntry const* DB2Manager::GetItemModifiedAppearance(uint32 itemId, uint32 appearanceModId) const
2553{
2554 auto itr = _itemModifiedAppearancesByItem.find(itemId | (appearanceModId << 24));
2555 if (itr != _itemModifiedAppearancesByItem.end())
2556 return itr->second;
2557
2558 // Fall back to unmodified appearance
2559 if (appearanceModId)
2560 {
2561 itr = _itemModifiedAppearancesByItem.find(itemId);
2562 if (itr != _itemModifiedAppearancesByItem.end())
2563 return itr->second;
2564 }
2565
2566 return nullptr;
2567}
2568
2569ItemModifiedAppearanceEntry const* DB2Manager::GetDefaultItemModifiedAppearance(uint32 itemId) const
2570{
2571 return Trinity::Containers::MapGetValuePtr(_itemModifiedAppearancesByItem, itemId);
2572}
2573
2574std::vector<ItemSetSpellEntry const*> const* DB2Manager::GetItemSetSpells(uint32 itemSetId) const
2575{
2576 return Trinity::Containers::MapGetValuePtr(_itemSetSpells, itemSetId);
2577}
2578
2579std::vector<ItemSpecOverrideEntry const*> const* DB2Manager::GetItemSpecOverrides(uint32 itemId) const
2580{
2581 return Trinity::Containers::MapGetValuePtr(_itemSpecOverrides, itemId);
2582}
2583
2584JournalTierEntry const* DB2Manager::GetJournalTier(uint32 index) const
2585{
2586 if (index < _journalTiersByIndex.size())
2587 return _journalTiersByIndex[index];
2588 return nullptr;
2589}
2590
2591LFGDungeonsEntry const* DB2Manager::GetLfgDungeon(uint32 mapId, Difficulty difficulty)
2592{
2593 for (LFGDungeonsEntry const* dungeon : sLFGDungeonsStore)
2594 if (dungeon->MapID == int32(mapId) && Difficulty(dungeon->DifficultyID) == difficulty)
2595 return dungeon;
2596
2597 return nullptr;
2598}
2599
2600uint32 DB2Manager::GetDefaultMapLight(uint32 mapId)
2601{
2602 for (int32 i = sLightStore.GetNumRows(); i >= 0; --i)
2603 {
2604 LightEntry const* light = sLightStore.LookupEntry(uint32(i));
2605 if (!light)
2606 continue;
2607
2608 if (light->ContinentID == int32(mapId) && light->GameCoords.X == 0.0f && light->GameCoords.Y == 0.0f && light->GameCoords.Z == 0.0f)
2609 return uint32(i);
2610 }
2611
2612 return 0;
2613}
2614
2615uint32 DB2Manager::GetLiquidFlags(uint32 liquidType)
2616{
2617 if (LiquidTypeEntry const* liq = sLiquidTypeStore.LookupEntry(liquidType))
2618 return 1 << liq->SoundBank;
2619
2620 return 0;
2621}
2622
2623MapDifficultyEntry const* DB2Manager::GetDefaultMapDifficulty(uint32 mapId, Difficulty* difficulty /*= nullptr*/) const
2624{
2625 auto itr = _mapDifficulties.find(mapId);
2626 if (itr == _mapDifficulties.end())
2627 return nullptr;
2628
2629 if (itr->second.empty())
2630 return nullptr;
2631
2632 for (auto& p : itr->second)
2633 {
2634 DifficultyEntry const* difficultyEntry = sDifficultyStore.LookupEntry(p.first);
2635 if (!difficultyEntry)
2636 continue;
2637
2638 if (difficultyEntry->Flags & DIFFICULTY_FLAG_DEFAULT)
2639 {
2640 if (difficulty)
2641 *difficulty = Difficulty(p.first);
2642
2643 return p.second;
2644 }
2645 }
2646
2647 if (difficulty)
2648 *difficulty = Difficulty(itr->second.begin()->first);
2649
2650 return itr->second.begin()->second;
2651}
2652
2653MapDifficultyEntry const* DB2Manager::GetMapDifficultyData(uint32 mapId, Difficulty difficulty) const
2654{
2655 auto itr = _mapDifficulties.find(mapId);
2656 if (itr == _mapDifficulties.end())
2657 return nullptr;
2658
2659 auto diffItr = itr->second.find(difficulty);
2660 if (diffItr == itr->second.end())
2661 return nullptr;
2662
2663 return diffItr->second;
2664}
2665
2666MapDifficultyEntry const* DB2Manager::GetDownscaledMapDifficultyData(uint32 mapId, Difficulty& difficulty) const
2667{
2668 DifficultyEntry const* diffEntry = sDifficultyStore.LookupEntry(difficulty);
2669 if (!diffEntry)
2670 return GetDefaultMapDifficulty(mapId, &difficulty);
2671
2672 uint32 tmpDiff = difficulty;
2673 MapDifficultyEntry const* mapDiff = GetMapDifficultyData(mapId, Difficulty(tmpDiff));
2674 while (!mapDiff)
2675 {
2676 tmpDiff = diffEntry->FallbackDifficultyID;
2677 diffEntry = sDifficultyStore.LookupEntry(tmpDiff);
2678 if (!diffEntry)
2679 return GetDefaultMapDifficulty(mapId, &difficulty);
2680
2681 // pull new data
2682 mapDiff = GetMapDifficultyData(mapId, Difficulty(tmpDiff)); // we are 10 normal or 25 normal
2683 }
2684
2685 difficulty = Difficulty(tmpDiff);
2686 return mapDiff;
2687}
2688
2689DB2Manager::MapDifficultyConditionsContainer const* DB2Manager::GetMapDifficultyConditions(uint32 mapDifficultyId) const
2690{
2691 return Trinity::Containers::MapGetValuePtr(_mapDifficultyConditions, mapDifficultyId);
2692}
2693
2694MountEntry const* DB2Manager::GetMount(uint32 spellId) const
2695{
2696 return Trinity::Containers::MapGetValuePtr(_mountsBySpellId, spellId);
2697}
2698
2699MountEntry const* DB2Manager::GetMountById(uint32 id) const
2700{
2701 return sMountStore.LookupEntry(id);
2702}
2703
2704DB2Manager::MountTypeXCapabilitySet const* DB2Manager::GetMountCapabilities(uint32 mountType) const
2705{
2706 return Trinity::Containers::MapGetValuePtr(_mountCapabilitiesByType, mountType);
2707}
2708
2709DB2Manager::MountXDisplayContainer const* DB2Manager::GetMountDisplays(uint32 mountId) const
2710{
2711 return Trinity::Containers::MapGetValuePtr(_mountDisplays, mountId);
2712}
2713
2714std::string DB2Manager::GetNameGenEntry(uint8 race, uint8 gender) const
2715{
2716 ASSERT(gender < GENDER_NONE);
2717 auto ritr = _nameGenData.find(race);
2718 if (ritr == _nameGenData.end())
2719 return "";
2720
2721 if (ritr->second[gender].empty())
2722 return "";
2723
2724 return Trinity::Containers::SelectRandomContainerElement(ritr->second[gender])->Name;
2725}
2726
2727ResponseCodes DB2Manager::ValidateName(std::wstring const& name, LocaleConstant locale) const
2728{
2729 for (Trinity::wregex const& regex : _nameValidators[locale])
2730 if (Trinity::regex_search(name, regex))
2731 return CHAR_NAME_PROFANE;
2732
2733 // regexes at TOTAL_LOCALES are loaded from NamesReserved which is not locale specific
2734 for (Trinity::wregex const& regex : _nameValidators[TOTAL_LOCALES])
2735 if (Trinity::regex_search(name, regex))
2736 return CHAR_NAME_RESERVED;
2737
2738 return CHAR_NAME_SUCCESS;
2739}
2740
2741int32 DB2Manager::GetNumTalentsAtLevel(uint32 level, Classes playerClass)
2742{
2743 NumTalentsAtLevelEntry const* numTalentsAtLevel = sNumTalentsAtLevelStore.LookupEntry(level);
2744 if (!numTalentsAtLevel)
2745 numTalentsAtLevel = sNumTalentsAtLevelStore.LookupEntry(sNumTalentsAtLevelStore.GetNumRows() - 1);
2746
2747 if (numTalentsAtLevel)
2748 {
2749 switch (playerClass)
2750 {
2751 case CLASS_DEATH_KNIGHT:
2752 return numTalentsAtLevel->NumTalentsDeathKnight;
2753 case CLASS_DEMON_HUNTER:
2754 return numTalentsAtLevel->NumTalentsDemonHunter;
2755 default:
2756 return numTalentsAtLevel->NumTalents;
2757 }
2758 }
2759
2760 return 0;
2761}
2762
2763ParagonReputationEntry const* DB2Manager::GetParagonReputation(uint32 factionId) const
2764{
2765 return Trinity::Containers::MapGetValuePtr(_paragonReputations, factionId);
2766}
2767
2768PVPDifficultyEntry const* DB2Manager::GetBattlegroundBracketByLevel(uint32 mapid, uint32 level)
2769{
2770 PVPDifficultyEntry const* maxEntry = nullptr; // used for level > max listed level case
2771 for (PVPDifficultyEntry const* entry : sPVPDifficultyStore)
2772 {
2773 // skip unrelated and too-high brackets
2774 if (entry->MapID != mapid || entry->MinLevel > level)
2775 continue;
2776
2777 // exactly fit
2778 if (entry->MaxLevel >= level)
2779 return entry;
2780
2781 // remember for possible out-of-range case (search higher from existed)
2782 if (!maxEntry || maxEntry->MaxLevel < entry->MaxLevel)
2783 maxEntry = entry;
2784 }
2785
2786 return maxEntry;
2787}
2788
2789PVPDifficultyEntry const* DB2Manager::GetBattlegroundBracketById(uint32 mapid, BattlegroundBracketId id)
2790{
2791 for (PVPDifficultyEntry const* entry : sPVPDifficultyStore)
2792 if (entry->MapID == mapid && entry->GetBracketId() == id)
2793 return entry;
2794
2795 return nullptr;
2796}
2797
2798uint32 DB2Manager::GetRequiredLevelForPvpTalentSlot(uint8 slot, Classes class_) const
2799{
2800 ASSERT(slot < MAX_PVP_TALENT_SLOTS);
2801 if (_pvpTalentSlotUnlock[slot])
2802 {
2803 switch (class_)
2804 {
2805 case CLASS_DEATH_KNIGHT:
2806 return _pvpTalentSlotUnlock[slot]->DeathKnightLevelRequired;
2807 case CLASS_DEMON_HUNTER:
2808 return _pvpTalentSlotUnlock[slot]->DemonHunterLevelRequired;
2809 default:
2810 break;
2811 }
2812 return _pvpTalentSlotUnlock[slot]->LevelRequired;
2813 }
2814
2815 return 0;
2816}
2817
2818int32 DB2Manager::GetPvpTalentNumSlotsAtLevel(uint32 level, Classes class_) const
2819{
2820 int32 slots = 0;
2821 for (uint8 slot = 0; slot < MAX_PVP_TALENT_SLOTS; ++slot)
2822 if (level >= GetRequiredLevelForPvpTalentSlot(slot, class_))
2823 ++slots;
2824
2825 return slots;
2826}
2827
2828std::vector<QuestLineXQuestEntry const*> const* DB2Manager::GetQuestsForQuestLine(uint32 questLineId) const
2829{
2830 return Trinity::Containers::MapGetValuePtr(_questsByQuestLine, questLineId);
2831}
2832
2833std::vector<QuestPackageItemEntry const*> const* DB2Manager::GetQuestPackageItems(uint32 questPackageID) const
2834{
2835 auto itr = _questPackages.find(questPackageID);
2836 if (itr != _questPackages.end())
2837 return &itr->second.first;
2838
2839 return nullptr;
2840}
2841
2842std::vector<QuestPackageItemEntry const*> const* DB2Manager::GetQuestPackageItemsFallback(uint32 questPackageID) const
2843{
2844 auto itr = _questPackages.find(questPackageID);
2845 if (itr != _questPackages.end())
2846 return &itr->second.second;
2847
2848 return nullptr;
2849}
2850
2851uint32 DB2Manager::GetQuestUniqueBitFlag(uint32 questId)
2852{
2853 QuestV2Entry const* v2 = sQuestV2Store.LookupEntry(questId);
2854 if (!v2)
2855 return 0;
2856
2857 return v2->UniqueBitFlag;
2858}
2859
2860std::vector<uint32> const* DB2Manager::GetPhasesForGroup(uint32 group) const
2861{
2862 return Trinity::Containers::MapGetValuePtr(_phasesByGroup, group);
2863}
2864
2865PowerTypeEntry const* DB2Manager::GetPowerTypeEntry(Powers power) const
2866{
2867 ASSERT(power < MAX_POWERS);
2868 return _powerTypes[power];
2869}
2870
2871PowerTypeEntry const* DB2Manager::GetPowerTypeByName(std::string const& name) const
2872{
2873 for (PowerTypeEntry const* powerType : sPowerTypeStore)
2874 {
2875 std::string powerName = powerType->NameGlobalStringTag;
2876 strToLower(powerName);
2877 if (powerName == name)
2878 return powerType;
2879
2880 powerName.erase(std::remove(powerName.begin(), powerName.end(), '_'), powerName.end());
2881 if (powerName == name)
2882 return powerType;
2883 }
2884
2885 return nullptr;
2886}
2887
2888uint8 DB2Manager::GetPvpItemLevelBonus(uint32 itemId) const
2889{
2890 auto itr = _pvpItemBonus.find(itemId);
2891 if (itr != _pvpItemBonus.end())
2892 return itr->second;
2893
2894 return 0;
2895}
2896
2897std::vector<RewardPackXCurrencyTypeEntry const*> const* DB2Manager::GetRewardPackCurrencyTypesByRewardID(uint32 rewardPackID) const
2898{
2899 return Trinity::Containers::MapGetValuePtr(_rewardPackCurrencyTypes, rewardPackID);
2900}
2901
2902std::vector<RewardPackXItemEntry const*> const* DB2Manager::GetRewardPackItemsByRewardID(uint32 rewardPackID) const
2903{
2904 return Trinity::Containers::MapGetValuePtr(_rewardPackItems, rewardPackID);
2905}
2906
2907ShapeshiftFormModelData const* DB2Manager::GetShapeshiftFormModelData(uint8 race, uint8 gender, uint8 form) const
2908{
2909 return Trinity::Containers::MapGetValuePtr(_chrCustomizationChoicesForShapeshifts, { race, gender, form });
2910}
2911
2912std::vector<SkillLineEntry const*> const* DB2Manager::GetSkillLinesForParentSkill(uint32 parentSkillId) const
2913{
2914 return Trinity::Containers::MapGetValuePtr(_skillLinesByParentSkillLine, parentSkillId);
2915}
2916
2917std::vector<SkillLineAbilityEntry const*> const* DB2Manager::GetSkillLineAbilitiesBySkill(uint32 skillId) const
2918{
2919 return Trinity::Containers::MapGetValuePtr(_skillLineAbilitiesBySkillupSkill, skillId);
2920}
2921
2922SkillRaceClassInfoEntry const* DB2Manager::GetSkillRaceClassInfo(uint32 skill, uint8 race, uint8 class_) const
2923{
2924 for (auto&& [_, skllRaceClassInfo] : Trinity::Containers::MapEqualRange(_skillRaceClassInfoBySkill, skill))
2925 {
2926 if (!skllRaceClassInfo->RaceMask.IsEmpty() && !(skllRaceClassInfo->RaceMask.HasRace(race)))
2927 continue;
2928 if (skllRaceClassInfo->ClassMask && !(skllRaceClassInfo->ClassMask & (1 << (class_ - 1))))
2929 continue;
2930
2931 return skllRaceClassInfo;
2932 }
2933
2934 return nullptr;
2935}
2936
2937std::vector<SkillRaceClassInfoEntry const*> DB2Manager::GetSkillRaceClassInfo(uint32 skill) const
2938{
2939 std::vector<SkillRaceClassInfoEntry const*> result;
2940 for (auto const& [_, skillRaceClassInfo] : Trinity::Containers::MapEqualRange(_skillRaceClassInfoBySkill, skill))
2941 result.push_back(skillRaceClassInfo);
2942
2943 return result;
2944}
2945
2946SoulbindConduitRankEntry const* DB2Manager::GetSoulbindConduitRank(int32 soulbindConduitId, int32 rank) const
2947{
2948 return Trinity::Containers::MapGetValuePtr(_soulbindConduitRanks, { soulbindConduitId, rank });
2949}
2950
2951std::vector<SpecializationSpellsEntry const*> const* DB2Manager::GetSpecializationSpells(uint32 specId) const
2952{
2953 return Trinity::Containers::MapGetValuePtr(_specializationSpellsBySpec, specId);
2954}
2955
2956bool DB2Manager::IsSpecSetMember(int32 specSetId, uint32 specId) const
2957{
2958 return _specsBySpecSet.count(std::make_pair(specSetId, specId)) > 0;
2959}
2960
2961bool DB2Manager::IsValidSpellFamiliyName(SpellFamilyNames family)
2962{
2963 return _spellFamilyNames.count(family) > 0;
2964}
2965
2966std::vector<SpellProcsPerMinuteModEntry const*> DB2Manager::GetSpellProcsPerMinuteMods(uint32 spellprocsPerMinuteId) const
2967{
2968 auto itr = _spellProcsPerMinuteMods.find(spellprocsPerMinuteId);
2969 if (itr != _spellProcsPerMinuteMods.end())
2970 return itr->second;
2971
2972 return std::vector<SpellProcsPerMinuteModEntry const*>();
2973}
2974
2975std::vector<SpellVisualMissileEntry const*> const* DB2Manager::GetSpellVisualMissiles(int32 spellVisualMissileSetId) const
2976{
2977 return Trinity::Containers::MapGetValuePtr(_spellVisualMissilesBySet, spellVisualMissileSetId);
2978}
2979
2980std::vector<TalentEntry const*> const& DB2Manager::GetTalentsByPosition(uint32 class_, uint32 tier, uint32 column) const
2981{
2982 return _talentsByPosition[class_][tier][column];
2983}
2984
2985TaxiPathEntry const* DB2Manager::GetTaxiPath(uint32 from, uint32 to) const
2986{
2987 return Trinity::Containers::MapGetValuePtr(_taxiPaths, { from, to });
2988}
2989
2990bool DB2Manager::IsTotemCategoryCompatibleWith(uint32 itemTotemCategoryId, uint32 requiredTotemCategoryId, bool requireAllTotems /*= true*/)
2991{
2992 if (requiredTotemCategoryId == 0)
2993 return true;
2994 if (itemTotemCategoryId == 0)
2995 return false;
2996
2997 TotemCategoryEntry const* itemEntry = sTotemCategoryStore.LookupEntry(itemTotemCategoryId);
2998 if (!itemEntry)
2999 return false;
3000 TotemCategoryEntry const* reqEntry = sTotemCategoryStore.LookupEntry(requiredTotemCategoryId);
3001 if (!reqEntry)
3002 return false;
3003
3004 if (itemEntry->TotemCategoryType != reqEntry->TotemCategoryType)
3005 return false;
3006
3007 int32 sharedMask = itemEntry->TotemCategoryMask & reqEntry->TotemCategoryMask;
3008 return requireAllTotems ? sharedMask == reqEntry->TotemCategoryMask : sharedMask != 0;
3009}
3010
3011bool DB2Manager::IsToyItem(uint32 toy) const
3012{
3013 return _toys.count(toy) > 0;
3014}
3015
3016TransmogIllusionEntry const* DB2Manager::GetTransmogIllusionForEnchantment(uint32 spellItemEnchantmentId) const
3017{
3018 return Trinity::Containers::MapGetValuePtr(_transmogIllusionsByEnchantmentId, spellItemEnchantmentId);
3019}
3020
3021std::vector<TransmogSetEntry const*> const* DB2Manager::GetTransmogSetsForItemModifiedAppearance(uint32 itemModifiedAppearanceId) const
3022{
3023 return Trinity::Containers::MapGetValuePtr(_transmogSetsByItemModifiedAppearance, itemModifiedAppearanceId);
3024}
3025
3026std::vector<TransmogSetItemEntry const*> const* DB2Manager::GetTransmogSetItems(uint32 transmogSetId) const
3027{
3028 return Trinity::Containers::MapGetValuePtr(_transmogSetItemsByTransmogSet, transmogSetId);
3029}
3030
3031struct UiMapAssignmentStatus
3032{
3033 UiMapAssignmentEntry const* UiMapAssignment = nullptr;
3034 // distances if inside
3035 struct
3036 {
3037 float DistanceToRegionCenterSquared = std::numeric_limits<float>::max();
3038 float DistanceToRegionBottom = std::numeric_limits<float>::max();
3039 } Inside;
3040
3041 // distances if outside
3042 struct
3043 {
3044 float DistanceToRegionEdgeSquared = std::numeric_limits<float>::max();
3045 float DistanceToRegionTop = std::numeric_limits<float>::max();
3046 float DistanceToRegionBottom = std::numeric_limits<float>::max();
3047 } Outside;
3048
3049 int8 MapPriority = 3;
3050 int8 AreaPriority = -1;
3051 int8 WmoPriority = 3;
3052
3053 bool IsInside() const
3054 {
3055 return Outside.DistanceToRegionEdgeSquared < std::numeric_limits<float>::epsilon() &&
3056 std::abs(Outside.DistanceToRegionTop) < std::numeric_limits<float>::epsilon() &&
3057 std::abs(Outside.DistanceToRegionBottom) < std::numeric_limits<float>::epsilon();
3058 }
3059};
3060
3061static bool operator<(UiMapAssignmentStatus const& left, UiMapAssignmentStatus const& right)
3062{
3063 bool leftInside = left.IsInside();
3064 bool rightInside = right.IsInside();
3065 if (leftInside != rightInside)
3066 return leftInside;
3067
3068 if (left.UiMapAssignment && right.UiMapAssignment &&
3069 left.UiMapAssignment->UiMapID == right.UiMapAssignment->UiMapID &&
3070 left.UiMapAssignment->OrderIndex != right.UiMapAssignment->OrderIndex)
3071 return left.UiMapAssignment->OrderIndex < right.UiMapAssignment->OrderIndex;
3072
3073 if (left.WmoPriority != right.WmoPriority)
3074 return left.WmoPriority < right.WmoPriority;
3075
3076 if (left.AreaPriority != right.AreaPriority)
3077 return left.AreaPriority < right.AreaPriority;
3078
3079 if (left.MapPriority != right.MapPriority)
3080 return left.MapPriority < right.MapPriority;
3081
3082 if (leftInside)
3083 {
3084 if (left.Inside.DistanceToRegionBottom != right.Inside.DistanceToRegionBottom)
3085 return left.Inside.DistanceToRegionBottom < right.Inside.DistanceToRegionBottom;
3086
3087 float leftUiSizeX = left.UiMapAssignment ? (left.UiMapAssignment->UiMax.X - left.UiMapAssignment->UiMin.X) : 0.0f;
3088 float rightUiSizeX = right.UiMapAssignment ? (right.UiMapAssignment->UiMax.X - right.UiMapAssignment->UiMin.X) : 0.0f;
3089
3090 if (leftUiSizeX > std::numeric_limits<float>::epsilon() && rightUiSizeX > std::numeric_limits<float>::epsilon())
3091 {
3092 float leftScale = (left.UiMapAssignment->Region[1].X - left.UiMapAssignment->Region[0].X) / leftUiSizeX;
3093 float rightScale = (right.UiMapAssignment->Region[1].X - right.UiMapAssignment->Region[0].X) / rightUiSizeX;
3094 if (leftScale != rightScale)
3095 return leftScale < rightScale;
3096 }
3097
3098 if (left.Inside.DistanceToRegionCenterSquared != right.Inside.DistanceToRegionCenterSquared)
3099 return left.Inside.DistanceToRegionCenterSquared < right.Inside.DistanceToRegionCenterSquared;
3100 }
3101 else
3102 {
3103 if (left.Outside.DistanceToRegionTop != right.Outside.DistanceToRegionTop)
3104 return left.Outside.DistanceToRegionTop < right.Outside.DistanceToRegionTop;
3105
3106 if (left.Outside.DistanceToRegionBottom != right.Outside.DistanceToRegionBottom)
3107 return left.Outside.DistanceToRegionBottom < right.Outside.DistanceToRegionBottom;
3108
3109 if (left.Outside.DistanceToRegionEdgeSquared != right.Outside.DistanceToRegionEdgeSquared)
3110 return left.Outside.DistanceToRegionEdgeSquared < right.Outside.DistanceToRegionEdgeSquared;
3111 }
3112
3113 return true;
3114}
3115
3116static bool CheckUiMapAssignmentStatus(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId,
3117 UiMapAssignmentEntry const* uiMapAssignment, UiMapAssignmentStatus* status)
3118{
3119 status->UiMapAssignment = uiMapAssignment;
3120 // x,y not in region
3121 if (x < uiMapAssignment->Region[0].X || x > uiMapAssignment->Region[1].X || y < uiMapAssignment->Region[0].Y || y > uiMapAssignment->Region[1].Y)
3122 {
3123 float xDiff, yDiff;
3124 if (x >= uiMapAssignment->Region[0].X)
3125 {
3126 xDiff = 0.0f;
3127 if (x > uiMapAssignment->Region[1].X)
3128 xDiff = x - uiMapAssignment->Region[0].X;
3129 }
3130 else
3131 xDiff = uiMapAssignment->Region[0].X - x;
3132
3133 if (y >= uiMapAssignment->Region[0].Y)
3134 {
3135 yDiff = 0.0f;
3136 if (y > uiMapAssignment->Region[1].Y)
3137 yDiff = y - uiMapAssignment->Region[0].Y;
3138 }
3139 else
3140 yDiff = uiMapAssignment->Region[0].Y - y;
3141
3142 status->Outside.DistanceToRegionEdgeSquared = xDiff * xDiff + yDiff * yDiff;
3143 }
3144 else
3145 {
3146 status->Inside.DistanceToRegionCenterSquared =
3147 (x - (uiMapAssignment->Region[0].X + uiMapAssignment->Region[1].X) * 0.5f) * (x - (uiMapAssignment->Region[0].X + uiMapAssignment->Region[1].X) * 0.5f)
3148 + (y - (uiMapAssignment->Region[0].Y + uiMapAssignment->Region[1].Y) * 0.5f) * (y - (uiMapAssignment->Region[0].Y + uiMapAssignment->Region[1].Y) * 0.5f);
3149 status->Outside.DistanceToRegionEdgeSquared = 0.0f;
3150 }
3151
3152 // z not in region
3153 if (z < uiMapAssignment->Region[0].Z || z > uiMapAssignment->Region[1].Z)
3154 {
3155 if (z < uiMapAssignment->Region[1].Z)
3156 {
3157 if (z < uiMapAssignment->Region[0].Z)
3158 status->Outside.DistanceToRegionBottom = std::min(uiMapAssignment->Region[0].Z - z, 10000.0f);
3159 }
3160 else
3161 status->Outside.DistanceToRegionTop = std::min(z - uiMapAssignment->Region[1].Z, 10000.0f);
3162 }
3163 else
3164 {
3165 status->Outside.DistanceToRegionTop = 0.0f;
3166 status->Outside.DistanceToRegionBottom = 0.0f;
3167 status->Inside.DistanceToRegionBottom = std::min(uiMapAssignment->Region[0].Z - z, 10000.0f);
3168 }
3169
3170 if (areaId && uiMapAssignment->AreaID)
3171 {
3172 int8 areaPriority = 0;
3173 while (areaId != uiMapAssignment->AreaID)
3174 {
3175 if (AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId))
3176 {
3177 areaId = areaEntry->ParentAreaID;
3178 ++areaPriority;
3179 }
3180 else
3181 return false;
3182 }
3183
3184 status->AreaPriority = areaPriority;
3185 }
3186
3187 if (mapId >= 0 && uiMapAssignment->MapID >= 0)
3188 {
3189 if (mapId != uiMapAssignment->MapID)
3190 {
3191 if (MapEntry const* mapEntry = sMapStore.LookupEntry(mapId))
3192 {
3193 if (mapEntry->ParentMapID == uiMapAssignment->MapID)
3194 status->MapPriority = 1;
3195 else if (mapEntry->CosmeticParentMapID == uiMapAssignment->MapID)
3196 status->MapPriority = 2;
3197 else
3198 return false;
3199 }
3200 else
3201 return false;
3202 }
3203 else
3204 status->MapPriority = 0;
3205 }
3206
3207 if (wmoGroupId || wmoDoodadPlacementId)
3208 {
3209 if (uiMapAssignment->WmoGroupID || uiMapAssignment->WmoDoodadPlacementID)
3210 {
3211 bool hasDoodadPlacement = false;
3212 if (wmoDoodadPlacementId && uiMapAssignment->WmoDoodadPlacementID)
3213 {
3214 if (wmoDoodadPlacementId != uiMapAssignment->WmoDoodadPlacementID)
3215 return false;
3216
3217 hasDoodadPlacement = true;
3218 }
3219
3220 if (wmoGroupId && uiMapAssignment->WmoGroupID)
3221 {
3222 if (wmoGroupId != uiMapAssignment->WmoGroupID)
3223 return false;
3224
3225 if (hasDoodadPlacement)
3226 status->WmoPriority = 0;
3227 else
3228 status->WmoPriority = 2;
3229 }
3230 else if (hasDoodadPlacement)
3231 status->WmoPriority = 1;
3232 }
3233 }
3234
3235 return true;
3236}
3237
3238static UiMapAssignmentEntry const* FindNearestMapAssignment(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapSystem system)
3239{
3240 UiMapAssignmentStatus nearestMapAssignment;
3241 auto iterateUiMapAssignments = [&](std::unordered_multimap<int32, UiMapAssignmentEntry const*> const& assignments, int32 id)
3242 {
3243 for (auto assignment : Trinity::Containers::MapEqualRange(assignments, id))
3244 {
3245 UiMapAssignmentStatus status;
3246 if (CheckUiMapAssignmentStatus(x, y, z, mapId, areaId, wmoDoodadPlacementId, wmoGroupId, assignment.second, &status))
3247 if (status < nearestMapAssignment)
3248 nearestMapAssignment = status;
3249 }
3250 };
3251
3252 iterateUiMapAssignments(_uiMapAssignmentByWmoGroup[system], wmoGroupId);
3253 iterateUiMapAssignments(_uiMapAssignmentByWmoDoodadPlacement[system], wmoDoodadPlacementId);
3254
3255 AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId);
3256 while (areaEntry)
3257 {
3258 iterateUiMapAssignments(_uiMapAssignmentByArea[system], areaEntry->ID);
3259 areaEntry = sAreaTableStore.LookupEntry(areaEntry->ParentAreaID);
3260 }
3261
3262 if (MapEntry const* mapEntry = sMapStore.LookupEntry(mapId))
3263 {
3264 iterateUiMapAssignments(_uiMapAssignmentByMap[system], mapEntry->ID);
3265 if (mapEntry->ParentMapID >= 0)
3266 iterateUiMapAssignments(_uiMapAssignmentByMap[system], mapEntry->ParentMapID);
3267 if (mapEntry->CosmeticParentMapID >= 0)
3268 iterateUiMapAssignments(_uiMapAssignmentByMap[system], mapEntry->CosmeticParentMapID);
3269 }
3270
3271 return nearestMapAssignment.UiMapAssignment;
3272}
3273
3274static DBCPosition2D CalculateGlobalUiMapPosition(int32 uiMapID, DBCPosition2D uiPosition)
3275{
3276 UiMapEntry const* uiMap = sUiMapStore.LookupEntry(uiMapID);
3277 while (uiMap)
3278 {
3279 if (uiMap->Type <= UI_MAP_TYPE_CONTINENT)
3280 break;
3281
3282 UiMapBounds const* bounds = Trinity::Containers::MapGetValuePtr(_uiMapBounds, uiMap->ID);
3283 if (!bounds || !bounds->IsUiAssignment)
3284 break;
3285
3286 uiPosition.X = ((1.0 - uiPosition.X) * bounds->Bounds[1]) + (bounds->Bounds[3] * uiPosition.X);
3287 uiPosition.Y = ((1.0 - uiPosition.Y) * bounds->Bounds[0]) + (bounds->Bounds[2] * uiPosition.Y);
3288
3289 uiMap = sUiMapStore.LookupEntry(uiMap->ParentUiMapID);
3290 }
3291
3292 return uiPosition;
3293}
3294
3295bool DB2Manager::GetUiMapPosition(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapSystem system, bool local,
3296 int32* uiMapId /*= nullptr*/, DBCPosition2D* newPos /*= nullptr*/)
3297{
3298 if (uiMapId)
3299 *uiMapId = -1;
3300
3301 if (newPos)
3302 {
3303 newPos->X = 0.0f;
3304 newPos->Y = 0.0f;
3305 }
3306
3307 UiMapAssignmentEntry const* uiMapAssignment = FindNearestMapAssignment(x, y, z, mapId, areaId, wmoDoodadPlacementId, wmoGroupId, system);
3308 if (!uiMapAssignment)
3309 return false;
3310
3311 if (uiMapId)
3312 *uiMapId = uiMapAssignment->UiMapID;
3313
3314 DBCPosition2D relativePosition{ 0.5f, 0.5f };
3315 DBCPosition2D regionSize{ uiMapAssignment->Region[1].X - uiMapAssignment->Region[0].X, uiMapAssignment->Region[1].Y - uiMapAssignment->Region[0].Y };
3316 if (regionSize.X > 0.0f)
3317 relativePosition.X = (x - uiMapAssignment->Region[0].X) / regionSize.X;
3318 if (regionSize.Y > 0.0f)
3319 relativePosition.Y = (y - uiMapAssignment->Region[0].Y) / regionSize.Y;
3320
3321 DBCPosition2D uiPosition
3322 {
3323 // x and y are swapped
3324 ((1.0f - (1.0f - relativePosition.Y)) * uiMapAssignment->UiMin.X) + ((1.0f - relativePosition.Y) * uiMapAssignment->UiMax.X),
3325 ((1.0f - (1.0f - relativePosition.X)) * uiMapAssignment->UiMin.Y) + ((1.0f - relativePosition.X) * uiMapAssignment->UiMax.Y)
3326 };
3327
3328 if (!local)
3329 uiPosition = CalculateGlobalUiMapPosition(uiMapAssignment->UiMapID, uiPosition);
3330
3331 if (newPos)
3332 *newPos = uiPosition;
3333
3334 return true;
3335}
3336
3337bool DB2Manager::Zone2MapCoordinates(uint32 areaId, float& x, float& y) const
3338{
3339 AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId);
3340 if (!areaEntry)
3341 return false;
3342
3343 for (auto assignment : Trinity::Containers::MapEqualRange(_uiMapAssignmentByArea[UI_MAP_SYSTEM_WORLD], areaId))
3344 {
3345 if (assignment.second->MapID >= 0 && assignment.second->MapID != areaEntry->ContinentID)
3346 continue;
3347
3348 float tmpY = (y - assignment.second->UiMax.Y) / (assignment.second->UiMin.Y - assignment.second->UiMax.Y);
3349 float tmpX = (x - assignment.second->UiMax.X) / (assignment.second->UiMin.X - assignment.second->UiMax.X);
3350 x = assignment.second->Region[0].X + tmpY * (assignment.second->Region[1].X - assignment.second->Region[0].X);
3351 y = assignment.second->Region[0].Y + tmpX * (assignment.second->Region[1].Y - assignment.second->Region[0].Y);
3352
3353 return true;
3354 }
3355
3356 return false;
3357}
3358
3359void DB2Manager::Map2ZoneCoordinates(uint32 areaId, float& x, float& y) const
3360{
3361 DBCPosition2D zoneCoords;
3362 if (!GetUiMapPosition(x, y, 0.0f, -1, areaId, 0, 0, UI_MAP_SYSTEM_WORLD, true, nullptr, &zoneCoords))
3363 return;
3364
3365 x = zoneCoords.Y * 100.0f;
3366 y = zoneCoords.X * 100.0f;
3367}
3368
3369bool DB2Manager::IsUiMapPhase(uint32 phaseId) const
3370{
3371 return _uiMapPhases.find(phaseId) != _uiMapPhases.end();
3372}
3373
3374WMOAreaTableEntry const* DB2Manager::GetWMOAreaTable(int32 rootId, int32 adtId, int32 groupId) const
3375{
3376 return Trinity::Containers::MapGetValuePtr(_wmoAreaTableLookup, WMOAreaTableKey(int16(rootId), int8(adtId), groupId));
3377}
3378
3379std::unordered_set<uint32> const* DB2Manager::GetPVPStatIDsForMap(uint32 mapId) const
3380{
3381 return Trinity::Containers::MapGetValuePtr(_pvpStatIdsByMap, mapId);
3382}
3383
3384bool ChrClassesXPowerTypesEntryComparator::Compare(ChrClassesXPowerTypesEntry const* left, ChrClassesXPowerTypesEntry const* right)
3385{
3386 if (left->ClassID != right->ClassID)
3387 return left->ClassID < right->ClassID;
3388 return left->PowerType < right->PowerType;
3389}
3390
3391TaxiMask::TaxiMask()
3392{
3393 if (sTaxiNodesStore.GetNumRows())
3394 {
3395 _data.resize(((sTaxiNodesStore.GetNumRows() - 1) / (sizeof(value_type) * 64) + 1) * 8, 0);
3396 ASSERT((_data.size() % 8) == 0, "TaxiMask size must be aligned to a multiple of uint64");
3397 }
3398}
3399
3400bool DB2Manager::FriendshipRepReactionEntryComparator::Compare(FriendshipRepReactionEntry const* left, FriendshipRepReactionEntry const* right)
3401{
3402 return left->ReactionThreshold < right->ReactionThreshold;
3403}
3404
3405bool DB2Manager::MountTypeXCapabilityEntryComparator::Compare(MountTypeXCapabilityEntry const* left, MountTypeXCapabilityEntry const* right)
3406{
3407 if (left->MountTypeID == right->MountTypeID)
3408 return left->OrderIndex < right->OrderIndex;
3409 return left->MountTypeID < right->MountTypeID;
3410}
localeNames
char const * localeNames[TOTAL_LOCALES]
Definition: Common.cpp:20
GetLocaleByName
LocaleConstant GetLocaleByName(std::string_view name)
Definition: Common.cpp:36
WowLocaleToCascLocaleBit
CascLocaleBit WowLocaleToCascLocaleBit[TOTAL_LOCALES]
Definition: Common.cpp:45
LocaleConstant
LocaleConstant
Definition: Common.h:48
LOCALE_none
@ LOCALE_none
Definition: Common.h:58
TOTAL_LOCALES
@ TOTAL_LOCALES
Definition: Common.h:62
LOCALE_enUS
@ LOCALE_enUS
Definition: Common.h:49
LOCALE_koKR
@ LOCALE_koKR
Definition: Common.h:50
IsValidLocale
constexpr bool IsValidLocale(LocaleConstant locale)
Definition: Common.h:95
CascLocaleBit
CascLocaleBit
Definition: Common.h:69
DEFAULT_LOCALE
#define DEFAULT_LOCALE
Definition: Common.h:66
M_PI
#define M_PI
Definition: Common.h:115
sUISplashScreenStore
DB2Storage< UISplashScreenEntry > sUISplashScreenStore("UISplashScreen.db2", &UiSplashScreenLoadInfo::Instance)
sLightStore
DB2Storage< LightEntry > sLightStore("Light.db2", &LightLoadInfo::Instance)
sAzeritePowerSetMemberStore
DB2Storage< AzeritePowerSetMemberEntry > sAzeritePowerSetMemberStore("AzeritePowerSetMember.db2", &AzeritePowerSetMemberLoadInfo::Instance)
sQuestFactionRewardStore
DB2Storage< QuestFactionRewardEntry > sQuestFactionRewardStore("QuestFactionReward.db2", &QuestFactionRewardLoadInfo::Instance)
sPhaseStore
DB2Storage< PhaseEntry > sPhaseStore("Phase.db2", &PhaseLoadInfo::Instance)
sArtifactAppearanceStore
DB2Storage< ArtifactAppearanceEntry > sArtifactAppearanceStore("ArtifactAppearance.db2", &ArtifactAppearanceLoadInfo::Instance)
sBankBagSlotPricesStore
DB2Storage< BankBagSlotPricesEntry > sBankBagSlotPricesStore("BankBagSlotPrices.db2", &BankBagSlotPricesLoadInfo::Instance)
sSkillRaceClassInfoStore
DB2Storage< SkillRaceClassInfoEntry > sSkillRaceClassInfoStore("SkillRaceClassInfo.db2", &SkillRaceClassInfoLoadInfo::Instance)
sItemNameDescriptionStore
DB2Storage< ItemNameDescriptionEntry > sItemNameDescriptionStore("ItemNameDescription.db2", &ItemNameDescriptionLoadInfo::Instance)
sChrRaceXChrModelStore
DB2Storage< ChrRaceXChrModelEntry > sChrRaceXChrModelStore("ChrRaceXChrModel.db2", &ChrRaceXChrModelLoadInfo::Instance)
sItemLimitCategoryStore
DB2Storage< ItemLimitCategoryEntry > sItemLimitCategoryStore("ItemLimitCategory.db2", &ItemLimitCategoryLoadInfo::Instance)
sDifficultyStore
DB2Storage< DifficultyEntry > sDifficultyStore("Difficulty.db2", &DifficultyLoadInfo::Instance)
sWorldMapOverlayStore
DB2Storage< WorldMapOverlayEntry > sWorldMapOverlayStore("WorldMapOverlay.db2", &WorldMapOverlayLoadInfo::Instance)
ChrSpecializationByIndexContainer
ChrSpecializationEntry const * ChrSpecializationByIndexContainer[MAX_CLASSES+1][MAX_SPECIALIZATIONS]
Definition: DB2Stores.cpp:392
sItemModifiedAppearanceExtraStore
DB2Storage< ItemModifiedAppearanceExtraEntry > sItemModifiedAppearanceExtraStore("ItemModifiedAppearanceExtra.db2", &ItemModifiedAppearanceExtraLoadInfo::Instance)
sItemDamageTwoHandCasterStore
DB2Storage< ItemDamageTwoHandCasterEntry > sItemDamageTwoHandCasterStore("ItemDamageTwoHandCaster.db2", &ItemDamageTwoHandCasterLoadInfo::Instance)
sItemLevelSelectorStore
DB2Storage< ItemLevelSelectorEntry > sItemLevelSelectorStore("ItemLevelSelector.db2", &ItemLevelSelectorLoadInfo::Instance)
sNamesReservedStore
DB2Storage< NamesReservedEntry > sNamesReservedStore("NamesReserved.db2", &NamesReservedLoadInfo::Instance)
sGameObjectDisplayInfoStore
DB2Storage< GameObjectDisplayInfoEntry > sGameObjectDisplayInfoStore("GameObjectDisplayInfo.db2", &GameobjectDisplayInfoLoadInfo::Instance)
sSceneScriptStore
DB2Storage< SceneScriptEntry > sSceneScriptStore("SceneScript.db2", &SceneScriptLoadInfo::Instance)
sCharacterLoadoutStore
DB2Storage< CharacterLoadoutEntry > sCharacterLoadoutStore("CharacterLoadout.db2", &CharacterLoadoutLoadInfo::Instance)
sSpellVisualStore
DB2Storage< SpellVisualEntry > sSpellVisualStore("SpellVisual.db2", &SpellVisualLoadInfo::Instance)
sPVPItemStore
DB2Storage< PVPItemEntry > sPVPItemStore("PVPItem.db2", &PvpItemLoadInfo::Instance)
sItemStore
DB2Storage< ItemEntry > sItemStore("Item.db2", &ItemLoadInfo::Instance)
sAchievementCategoryStore
DB2Storage< Achievement_CategoryEntry > sAchievementCategoryStore("Achievement_Category.db2", &AchievementCategoryLoadInfo::Instance)
sItemSearchNameStore
DB2Storage< ItemSearchNameEntry > sItemSearchNameStore("ItemSearchName.db2", &ItemSearchNameLoadInfo::Instance)
sPhaseXPhaseGroupStore
DB2Storage< PhaseXPhaseGroupEntry > sPhaseXPhaseGroupStore("PhaseXPhaseGroup.db2", &PhaseXPhaseGroupLoadInfo::Instance)
MapDifficultyContainer
std::unordered_map< uint32, std::unordered_map< uint32, MapDifficultyEntry const * > > MapDifficultyContainer
Definition: DB2Stores.cpp:405
sBattlemasterListStore
DB2Storage< BattlemasterListEntry > sBattlemasterListStore("BattlemasterList.db2", &BattlemasterListLoadInfo::Instance)
sAllianceTaxiNodesMask
TaxiMask sAllianceTaxiNodesMask
Definition: DB2Stores.cpp:382
CurvePointsContainer
std::unordered_map< uint32, std::vector< DBCPosition2D > > CurvePointsContainer
Definition: DB2Stores.cpp:393
sAzeriteEssencePowerStore
DB2Storage< AzeriteEssencePowerEntry > sAzeriteEssencePowerStore("AzeriteEssencePower.db2", &AzeriteEssencePowerLoadInfo::Instance)
sSpellInterruptsStore
DB2Storage< SpellInterruptsEntry > sSpellInterruptsStore("SpellInterrupts.db2", &SpellInterruptsLoadInfo::Instance)
sTraitCurrencySourceStore
DB2Storage< TraitCurrencySourceEntry > sTraitCurrencySourceStore("TraitCurrencySource.db2", &TraitCurrencySourceLoadInfo::Instance)
sSkillLineStore
DB2Storage< SkillLineEntry > sSkillLineStore("SkillLine.db2", &SkillLineLoadInfo::Instance)
sTraitTreeXTraitCostStore
DB2Storage< TraitTreeXTraitCostEntry > sTraitTreeXTraitCostStore("TraitTreeXTraitCost.db2", &TraitTreeXTraitCostLoadInfo::Instance)
sOverrideSpellDataStore
DB2Storage< OverrideSpellDataEntry > sOverrideSpellDataStore("OverrideSpellData.db2", &OverrideSpellDataLoadInfo::Instance)
sAnimationDataStore
DB2Storage< AnimationDataEntry > sAnimationDataStore("AnimationData.db2", &AnimationDataLoadInfo::Instance)
sFriendshipReputationStore
DB2Storage< FriendshipReputationEntry > sFriendshipReputationStore("FriendshipReputation.db2", &FriendshipReputationLoadInfo::Instance)
sBattlePetBreedQualityStore
DB2Storage< BattlePetBreedQualityEntry > sBattlePetBreedQualityStore("BattlePetBreedQuality.db2", &BattlePetBreedQualityLoadInfo::Instance)
sEmotesTextStore
DB2Storage< EmotesTextEntry > sEmotesTextStore("EmotesText.db2", &EmotesTextLoadInfo::Instance)
sArtifactStore
DB2Storage< ArtifactEntry > sArtifactStore("Artifact.db2", &ArtifactLoadInfo::Instance)
sArtifactPowerPickerStore
DB2Storage< ArtifactPowerPickerEntry > sArtifactPowerPickerStore("ArtifactPowerPicker.db2", &ArtifactPowerPickerLoadInfo::Instance)
sTraitNodeGroupXTraitCondStore
DB2Storage< TraitNodeGroupXTraitCondEntry > sTraitNodeGroupXTraitCondStore("TraitNodeGroupXTraitCond.db2", &TraitNodeGroupXTraitCondLoadInfo::Instance)
HeirloomItemsContainer
std::unordered_map< uint32, HeirloomEntry const * > HeirloomItemsContainer
Definition: DB2Stores.cpp:396
sArtifactQuestXPStore
DB2Storage< ArtifactQuestXPEntry > sArtifactQuestXPStore("ArtifactQuestXP.db2", &ArtifactQuestXpLoadInfo::Instance)
sJournalEncounterSectionStore
DB2Storage< JournalEncounterSectionEntry > sJournalEncounterSectionStore("JournalEncounterSection.db2", &JournalEncounterSectionLoadInfo::Instance)
sBattlePetBreedStateStore
DB2Storage< BattlePetBreedStateEntry > sBattlePetBreedStateStore("BattlePetBreedState.db2", &BattlePetBreedStateLoadInfo::Instance)
sPVPStatStore
DB2Storage< PVPStatEntry > sPVPStatStore("PVPStat.db2", &PvpStatLoadInfo::Instance)
ItemChildEquipmentContainer
std::unordered_map< uint32, ItemChildEquipmentEntry const * > ItemChildEquipmentContainer
Definition: DB2Stores.cpp:399
sPvpTalentCategoryStore
DB2Storage< PvpTalentCategoryEntry > sPvpTalentCategoryStore("PvpTalentCategory.db2", &PvpTalentCategoryLoadInfo::Instance)
sItemBonusTreeStore
DB2Storage< ItemBonusTreeEntry > sItemBonusTreeStore("ItemBonusTree.db2", &ItemBonusTreeLoadInfo::Instance)
sRandPropPointsStore
DB2Storage< RandPropPointsEntry > sRandPropPointsStore("RandPropPoints.db2", &RandPropPointsLoadInfo::Instance)
sItemBagFamilyStore
DB2Storage< ItemBagFamilyEntry > sItemBagFamilyStore("ItemBagFamily.db2", &ItemBagFamilyLoadInfo::Instance)
sGameObjectsStore
DB2Storage< GameObjectsEntry > sGameObjectsStore("GameObjects.db2", &GameobjectsLoadInfo::Instance)
sSpellAuraOptionsStore
DB2Storage< SpellAuraOptionsEntry > sSpellAuraOptionsStore("SpellAuraOptions.db2", &SpellAuraOptionsLoadInfo::Instance)
SpellPowerDifficultyContainer
std::unordered_map< uint32, std::unordered_map< uint32, std::vector< SpellPowerEntry const * > > > SpellPowerDifficultyContainer
Definition: DB2Stores.cpp:416
sTraitNodeGroupXTraitNodeStore
DB2Storage< TraitNodeGroupXTraitNodeEntry > sTraitNodeGroupXTraitNodeStore("TraitNodeGroupXTraitNode.db2", &TraitNodeGroupXTraitNodeLoadInfo::Instance)
sSpellCategoryStore
DB2Storage< SpellCategoryEntry > sSpellCategoryStore("SpellCategory.db2", &SpellCategoryLoadInfo::Instance)
sAchievementStore
DB2Storage< AchievementEntry > sAchievementStore("Achievement.db2", &AchievementLoadInfo::Instance)
sImportPriceWeaponStore
DB2Storage< ImportPriceWeaponEntry > sImportPriceWeaponStore("ImportPriceWeapon.db2", &ImportPriceWeaponLoadInfo::Instance)
sFriendshipRepReactionStore
DB2Storage< FriendshipRepReactionEntry > sFriendshipRepReactionStore("FriendshipRepReaction.db2", &FriendshipRepReactionLoadInfo::Instance)
sGarrMissionStore
DB2Storage< GarrMissionEntry > sGarrMissionStore("GarrMission.db2", &GarrMissionLoadInfo::Instance)
ItemClassByOldEnumContainer
std::array< ItemClassEntry const *, 20 > ItemClassByOldEnumContainer
Definition: DB2Stores.cpp:400
sSpellNameStore
DB2Storage< SpellNameEntry > sSpellNameStore("SpellName.db2", &SpellNameLoadInfo::Instance)
sCurveStore
DB2Storage< CurveEntry > sCurveStore("Curve.db2", &CurveLoadInfo::Instance)
sPvpSeasonStore
DB2Storage< PvpSeasonEntry > sPvpSeasonStore("PvpSeason.db2", &PvpSeasonLoadInfo::Instance)
sMapStore
DB2Storage< MapEntry > sMapStore("Map.db2", &MapLoadInfo::Instance)
sTraitNodeStore
DB2Storage< TraitNodeEntry > sTraitNodeStore("TraitNode.db2", &TraitNodeLoadInfo::Instance)
sTaxiNodesStore
DB2Storage< TaxiNodesEntry > sTaxiNodesStore("TaxiNodes.db2", &TaxiNodesLoadInfo::Instance)
ItemModifiedAppearanceByItemContainer
std::unordered_map< uint32, ItemModifiedAppearanceEntry const * > ItemModifiedAppearanceByItemContainer
Definition: DB2Stores.cpp:402
sCreatureModelDataStore
DB2Storage< CreatureModelDataEntry > sCreatureModelDataStore("CreatureModelData.db2", &CreatureModelDataLoadInfo::Instance)
sLiquidTypeStore
DB2Storage< LiquidTypeEntry > sLiquidTypeStore("LiquidType.db2", &LiquidTypeLoadInfo::Instance)
sConditionalChrModelStore
DB2Storage< ConditionalChrModelEntry > sConditionalChrModelStore("ConditionalChrModel.db2", &ConditionalChrModelLoadInfo::Instance)
sCreatureFamilyStore
DB2Storage< CreatureFamilyEntry > sCreatureFamilyStore("CreatureFamily.db2", &CreatureFamilyLoadInfo::Instance)
StorageMap
std::map< uint32, DB2StorageBase * > StorageMap
Definition: DB2Stores.cpp:387
sCurvePointStore
DB2Storage< CurvePointEntry > sCurvePointStore("CurvePoint.db2", &CurvePointLoadInfo::Instance)
sSpellXSpellVisualStore
DB2Storage< SpellXSpellVisualEntry > sSpellXSpellVisualStore("SpellXSpellVisual.db2", &SpellXSpellVisualLoadInfo::Instance)
sCharacterLoadoutItemStore
DB2Storage< CharacterLoadoutItemEntry > sCharacterLoadoutItemStore("CharacterLoadoutItem.db2", &CharacterLoadoutItemLoadInfo::Instance)
sAnimKitStore
DB2Storage< AnimKitEntry > sAnimKitStore("AnimKit.db2", &AnimKitLoadInfo::Instance)
sMapDifficultyStore
DB2Storage< MapDifficultyEntry > sMapDifficultyStore("MapDifficulty.db2", &MapDifficultyLoadInfo::Instance)
sSpellEquippedItemsStore
DB2Storage< SpellEquippedItemsEntry > sSpellEquippedItemsStore("SpellEquippedItems.db2", &SpellEquippedItemsLoadInfo::Instance)
sItemBonusStore
DB2Storage< ItemBonusEntry > sItemBonusStore("ItemBonus.db2", &ItemBonusLoadInfo::Instance)
sUiMapLinkStore
DB2Storage< UiMapLinkEntry > sUiMapLinkStore("UiMapLink.db2", &UiMapLinkLoadInfo::Instance)
FindNearestMapAssignment
static UiMapAssignmentEntry const * FindNearestMapAssignment(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapSystem system)
Definition: DB2Stores.cpp:3238
CheckUiMapAssignmentStatus
static bool CheckUiMapAssignmentStatus(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapAssignmentEntry const *uiMapAssignment, UiMapAssignmentStatus *status)
Definition: DB2Stores.cpp:3116
sUnitPowerBarStore
DB2Storage< UnitPowerBarEntry > sUnitPowerBarStore("UnitPowerBar.db2", &UnitPowerBarLoadInfo::Instance)
sTaxiNodesMask
TaxiMask sTaxiNodesMask
Definition: DB2Stores.cpp:379
sSpellReagentsStore
DB2Storage< SpellReagentsEntry > sSpellReagentsStore("SpellReagents.db2", &SpellReagentsLoadInfo::Instance)
sLanguageWordsStore
DB2Storage< LanguageWordsEntry > sLanguageWordsStore("LanguageWords.db2", &LanguageWordsLoadInfo::Instance)
sSkillLineXTraitTreeStore
DB2Storage< SkillLineXTraitTreeEntry > sSkillLineXTraitTreeStore("SkillLineXTraitTree.db2", &SkillLineXTraitTreeLoadInfo::Instance)
ArtifactPowerLinksContainer
std::unordered_map< uint32, std::vector< uint32 > > ArtifactPowerLinksContainer
Definition: DB2Stores.cpp:390
sTraitCostStore
DB2Storage< TraitCostEntry > sTraitCostStore("TraitCost.db2", &TraitCostLoadInfo::Instance)
sArtifactCategoryStore
DB2Storage< ArtifactCategoryEntry > sArtifactCategoryStore("ArtifactCategory.db2", &ArtifactCategoryLoadInfo::Instance)
sServerMessagesStore
DB2Storage< ServerMessagesEntry > sServerMessagesStore("ServerMessages.db2", &ServerMessagesLoadInfo::Instance)
sItemChildEquipmentStore
DB2Storage< ItemChildEquipmentEntry > sItemChildEquipmentStore("ItemChildEquipment.db2", &ItemChildEquipmentLoadInfo::Instance)
sSpecSetMemberStore
DB2Storage< SpecSetMemberEntry > sSpecSetMemberStore("SpecSetMember.db2", &SpecSetMemberLoadInfo::Instance)
sGarrBuildingPlotInstStore
DB2Storage< GarrBuildingPlotInstEntry > sGarrBuildingPlotInstStore("GarrBuildingPlotInst.db2", &GarrBuildingPlotInstLoadInfo::Instance)
sItemBonusTreeNodeStore
DB2Storage< ItemBonusTreeNodeEntry > sItemBonusTreeNodeStore("ItemBonusTreeNode.db2", &ItemBonusTreeNodeLoadInfo::Instance)
sChrCustomizationOptionStore
DB2Storage< ChrCustomizationOptionEntry > sChrCustomizationOptionStore("ChrCustomizationOption.db2", &ChrCustomizationOptionLoadInfo::Instance)
sItemSpecOverrideStore
DB2Storage< ItemSpecOverrideEntry > sItemSpecOverrideStore("ItemSpecOverride.db2", &ItemSpecOverrideLoadInfo::Instance)
sCreatureTypeStore
DB2Storage< CreatureTypeEntry > sCreatureTypeStore("CreatureType.db2", &CreatureTypeLoadInfo::Instance)
sDurabilityQualityStore
DB2Storage< DurabilityQualityEntry > sDurabilityQualityStore("DurabilityQuality.db2", &DurabilityQualityLoadInfo::Instance)
sChrCustomizationElementStore
DB2Storage< ChrCustomizationElementEntry > sChrCustomizationElementStore("ChrCustomizationElement.db2", &ChrCustomizationElementLoadInfo::Instance)
sSpellPowerDifficultyStore
DB2Storage< SpellPowerDifficultyEntry > sSpellPowerDifficultyStore("SpellPowerDifficulty.db2", &SpellPowerDifficultyLoadInfo::Instance)
sArtifactPowerStore
DB2Storage< ArtifactPowerEntry > sArtifactPowerStore("ArtifactPower.db2", &ArtifactPowerLoadInfo::Instance)
sTraitTreeLoadoutStore
DB2Storage< TraitTreeLoadoutEntry > sTraitTreeLoadoutStore("TraitTreeLoadout.db2", &TraitTreeLoadoutLoadInfo::Instance)
sCriteriaStore
DB2Storage< CriteriaEntry > sCriteriaStore("Criteria.db2", &CriteriaLoadInfo::Instance)
sTaxiPathNodesByPath
TaxiPathNodesByPath sTaxiPathNodesByPath
Definition: DB2Stores.cpp:383
sChallengeModeItemBonusOverrideStore
DB2Storage< ChallengeModeItemBonusOverrideEntry > sChallengeModeItemBonusOverrideStore("ChallengeModeItemBonusOverride.db2", &ChallengeModeItemBonusOverrideLoadInfo::Instance)
sAzeriteItemMilestonePowerStore
DB2Storage< AzeriteItemMilestonePowerEntry > sAzeriteItemMilestonePowerStore("AzeriteItemMilestonePower.db2", &AzeriteItemMilestonePowerLoadInfo::Instance)
HotfixBlobKey
std::pair< uint32, int32 > HotfixBlobKey
Definition: DB2Stores.cpp:422
sQuestMoneyRewardStore
DB2Storage< QuestMoneyRewardEntry > sQuestMoneyRewardStore("QuestMoneyReward.db2", &QuestMoneyRewardLoadInfo::Instance)
sItemXItemEffectStore
DB2Storage< ItemXItemEffectEntry > sItemXItemEffectStore("ItemXItemEffect.db2", &ItemXItemEffectLoadInfo::Instance)
sScenarioStore
DB2Storage< ScenarioEntry > sScenarioStore("Scenario.db2", &ScenarioLoadInfo::Instance)
sTraitNodeXTraitNodeEntryStore
DB2Storage< TraitNodeXTraitNodeEntryEntry > sTraitNodeXTraitNodeEntryStore("TraitNodeXTraitNodeEntry.db2", &TraitNodeXTraitNodeEntryLoadInfo::Instance)
GlyphRequiredSpecsContainer
std::unordered_map< uint32, std::vector< ChrSpecialization > > GlyphRequiredSpecsContainer
Definition: DB2Stores.cpp:398
sJournalInstanceStore
DB2Storage< JournalInstanceEntry > sJournalInstanceStore("JournalInstance.db2", &JournalInstanceLoadInfo::Instance)
sItemDamageOneHandStore
DB2Storage< ItemDamageOneHandEntry > sItemDamageOneHandStore("ItemDamageOneHand.db2", &ItemDamageOneHandLoadInfo::Instance)
sTransmogIllusionStore
DB2Storage< TransmogIllusionEntry > sTransmogIllusionStore("TransmogIllusion.db2", &TransmogIllusionLoadInfo::Instance)
ItemSpecOverridesContainer
std::unordered_map< uint32, std::vector< ItemSpecOverrideEntry const * > > ItemSpecOverridesContainer
Definition: DB2Stores.cpp:404
DetermineCurveType
static CurveInterpolationMode DetermineCurveType(CurveEntry const *curve, std::vector< DBCPosition2D > const &points)
Definition: DB2Stores.cpp:2189
sTransmogSetStore
DB2Storage< TransmogSetEntry > sTransmogSetStore("TransmogSet.db2", &TransmogSetLoadInfo::Instance)
sGuildColorEmblemStore
DB2Storage< GuildColorEmblemEntry > sGuildColorEmblemStore("GuildColorEmblem.db2", &GuildColorEmblemLoadInfo::Instance)
sGarrBuildingStore
DB2Storage< GarrBuildingEntry > sGarrBuildingStore("GarrBuilding.db2", &GarrBuildingLoadInfo::Instance)
sTraitNodeGroupXTraitCostStore
DB2Storage< TraitNodeGroupXTraitCostEntry > sTraitNodeGroupXTraitCostStore("TraitNodeGroupXTraitCost.db2", &TraitNodeGroupXTraitCostLoadInfo::Instance)
sAzeriteKnowledgeMultiplierStore
DB2Storage< AzeriteKnowledgeMultiplierEntry > sAzeriteKnowledgeMultiplierStore("AzeriteKnowledgeMultiplier.db2", &AzeriteKnowledgeMultiplierLoadInfo::Instance)
sSpecializationSpellsStore
DB2Storage< SpecializationSpellsEntry > sSpecializationSpellsStore("SpecializationSpells.db2", &SpecializationSpellsLoadInfo::Instance)
WMOAreaTableLookupContainer
std::map< WMOAreaTableKey, WMOAreaTableEntry const * > WMOAreaTableLookupContainer
Definition: DB2Stores.cpp:421
MountCapabilitiesByTypeContainer
std::unordered_map< uint32, DB2Manager::MountTypeXCapabilitySet > MountCapabilitiesByTypeContainer
Definition: DB2Stores.cpp:406
sGarrFollowerXAbilityStore
DB2Storage< GarrFollowerXAbilityEntry > sGarrFollowerXAbilityStore("GarrFollowerXAbility.db2", &GarrFollowerXAbilityLoadInfo::Instance)
sQuestInfoStore
DB2Storage< QuestInfoEntry > sQuestInfoStore("QuestInfo.db2", &QuestInfoLoadInfo::Instance)
sItemArmorTotalStore
DB2Storage< ItemArmorTotalEntry > sItemArmorTotalStore("ItemArmorTotal.db2", &ItemArmorTotalLoadInfo::Instance)
sChrModelStore
DB2Storage< ChrModelEntry > sChrModelStore("ChrModel.db2", &ChrModelLoadInfo::Instance)
SpecializationSpellsContainer
std::unordered_map< uint32, std::vector< SpecializationSpellsEntry const * > > SpecializationSpellsContainer
Definition: DB2Stores.cpp:414
sTraitTreeStore
DB2Storage< TraitTreeEntry > sTraitTreeStore("TraitTree.db2", &TraitTreeLoadInfo::Instance)
sGarrTalentTreeStore
DB2Storage< GarrTalentTreeEntry > sGarrTalentTreeStore("GarrTalentTree.db2", &GarrTalentTreeLoadInfo::Instance)
sTransportRotationStore
DB2Storage< TransportRotationEntry > sTransportRotationStore("TransportRotation.db2", &TransportRotationLoadInfo::Instance)
sSpellRangeStore
DB2Storage< SpellRangeEntry > sSpellRangeStore("SpellRange.db2", &SpellRangeLoadInfo::Instance)
sItemLevelSelectorQualityStore
DB2Storage< ItemLevelSelectorQualityEntry > sItemLevelSelectorQualityStore("ItemLevelSelectorQuality.db2", &ItemLevelSelectorQualityLoadInfo::Instance)
sRewardPackXItemStore
DB2Storage< RewardPackXItemEntry > sRewardPackXItemStore("RewardPackXItem.db2", &RewardPackXItemLoadInfo::Instance)
sEmotesTextSoundStore
DB2Storage< EmotesTextSoundEntry > sEmotesTextSoundStore("EmotesTextSound.db2", &EmotesTextSoundLoadInfo::Instance)
PowerTypesContainer
std::array< PowerTypeEntry const *, MAX_POWERS > PowerTypesContainer
Definition: DB2Stores.cpp:411
ValidateBroadcastTextTactKeyOptionalData
bool ValidateBroadcastTextTactKeyOptionalData(std::vector< uint8 > const &data)
Definition: DB2Stores.cpp:1773
sChrClassesStore
DB2Storage< ChrClassesEntry > sChrClassesStore("ChrClasses.db2", &ChrClassesLoadInfo::Instance)
sSpellShapeshiftFormStore
DB2Storage< SpellShapeshiftFormEntry > sSpellShapeshiftFormStore("SpellShapeshiftForm.db2", &SpellShapeshiftFormLoadInfo::Instance)
sItemPriceBaseStore
DB2Storage< ItemPriceBaseEntry > sItemPriceBaseStore("ItemPriceBase.db2", &ItemPriceBaseLoadInfo::Instance)
sGlobalCurveStore
DB2Storage< GlobalCurveEntry > sGlobalCurveStore("GlobalCurve.db2", &GlobalCurveLoadInfo::Instance)
sModifierTreeStore
DB2Storage< ModifierTreeEntry > sModifierTreeStore("ModifierTree.db2", &ModifierTreeLoadInfo::Instance)
FactionTeamContainer
std::unordered_map< uint32, std::vector< uint32 > > FactionTeamContainer
Definition: DB2Stores.cpp:395
sSpellAuraRestrictionsStore
DB2Storage< SpellAuraRestrictionsEntry > sSpellAuraRestrictionsStore("SpellAuraRestrictions.db2", &SpellAuraRestrictionsLoadInfo::Instance)
sMountStore
DB2Storage< MountEntry > sMountStore("Mount.db2", &MountLoadInfo::Instance)
sVehicleSeatStore
DB2Storage< VehicleSeatEntry > sVehicleSeatStore("VehicleSeat.db2", &VehicleSeatLoadInfo::Instance)
sChrCustomizationDisplayInfoStore
DB2Storage< ChrCustomizationDisplayInfoEntry > sChrCustomizationDisplayInfoStore("ChrCustomizationDisplayInfo.db2", &ChrCustomizationDisplayInfoLoadInfo::Instance)
SpellProcsPerMinuteModContainer
std::unordered_map< uint32, std::vector< SpellProcsPerMinuteModEntry const * > > SpellProcsPerMinuteModContainer
Definition: DB2Stores.cpp:417
sArtifactPowerRankStore
DB2Storage< ArtifactPowerRankEntry > sArtifactPowerRankStore("ArtifactPowerRank.db2", &ArtifactPowerRankLoadInfo::Instance)
sDestructibleModelDataStore
DB2Storage< DestructibleModelDataEntry > sDestructibleModelDataStore("DestructibleModelData.db2", &DestructibleModelDataLoadInfo::Instance)
sSpellShapeshiftStore
DB2Storage< SpellShapeshiftEntry > sSpellShapeshiftStore("SpellShapeshift.db2", &SpellShapeshiftLoadInfo::Instance)
sGarrSiteLevelPlotInstStore
DB2Storage< GarrSiteLevelPlotInstEntry > sGarrSiteLevelPlotInstStore("GarrSiteLevelPlotInst.db2", &GarrSiteLevelPlotInstLoadInfo::Instance)
sOldContinentsNodesMask
TaxiMask sOldContinentsNodesMask
Definition: DB2Stores.cpp:380
sSpellVisualEffectNameStore
DB2Storage< SpellVisualEffectNameEntry > sSpellVisualEffectNameStore("SpellVisualEffectName.db2", &SpellVisualEffectNameLoadInfo::Instance)
sSpellMiscStore
DB2Storage< SpellMiscEntry > sSpellMiscStore("SpellMisc.db2", &SpellMiscLoadInfo::Instance)
sWorldStateExpressionStore
DB2Storage< WorldStateExpressionEntry > sWorldStateExpressionStore("WorldStateExpression.db2", &WorldStateExpressionLoadInfo::Instance)
sGarrPlotInstanceStore
DB2Storage< GarrPlotInstanceEntry > sGarrPlotInstanceStore("GarrPlotInstance.db2", &GarrPlotInstanceLoadInfo::Instance)
sLockStore
DB2Storage< LockEntry > sLockStore("Lock.db2", &LockLoadInfo::Instance)
sNamesProfanityStore
DB2Storage< NamesProfanityEntry > sNamesProfanityStore("NamesProfanity.db2", &NamesProfanityLoadInfo::Instance)
sCharTitlesStore
DB2Storage< CharTitlesEntry > sCharTitlesStore("CharTitles.db2", &CharTitlesLoadInfo::Instance)
sGlyphRequiredSpecStore
DB2Storage< GlyphRequiredSpecEntry > sGlyphRequiredSpecStore("GlyphRequiredSpec.db2", &GlyphRequiredSpecLoadInfo::Instance)
sExpectedStatStore
DB2Storage< ExpectedStatEntry > sExpectedStatStore("ExpectedStat.db2", &ExpectedStatLoadInfo::Instance)
sBattlePetSpeciesStateStore
DB2Storage< BattlePetSpeciesStateEntry > sBattlePetSpeciesStateStore("BattlePetSpeciesState.db2", &BattlePetSpeciesStateLoadInfo::Instance)
sNumTalentsAtLevelStore
DB2Storage< NumTalentsAtLevelEntry > sNumTalentsAtLevelStore("NumTalentsAtLevel.db2", &NumTalentsAtLevelLoadInfo::Instance)
EmotesTextSoundContainer
std::map< std::tuple< uint32, uint8, uint8, uint8 >, EmotesTextSoundEntry const * > EmotesTextSoundContainer
Definition: DB2Stores.cpp:394
sArtifactUnlockStore
DB2Storage< ArtifactUnlockEntry > sArtifactUnlockStore("ArtifactUnlock.db2", &ArtifactUnlockLoadInfo::Instance)
sQuestLineXQuestStore
DB2Storage< QuestLineXQuestEntry > sQuestLineXQuestStore("QuestLineXQuest.db2", &QuestLineXQuestLoadInfo::Instance)
sTraitCondStore
DB2Storage< TraitCondEntry > sTraitCondStore("TraitCond.db2", &TraitCondLoadInfo::Instance)
sTransportAnimationStore
DB2Storage< TransportAnimationEntry > sTransportAnimationStore("TransportAnimation.db2", &TransportAnimationLoadInfo::Instance)
TalentsByPosition
std::vector< TalentEntry const * > TalentsByPosition[MAX_CLASSES][MAX_TALENT_TIERS][MAX_TALENT_COLUMNS]
Definition: DB2Stores.cpp:418
sContentTuningXExpectedStore
DB2Storage< ContentTuningXExpectedEntry > sContentTuningXExpectedStore("ContentTuningXExpected.db2", &ContentTuningXExpectedLoadInfo::Instance)
sConditionalContentTuningStore
DB2Storage< ConditionalContentTuningEntry > sConditionalContentTuningStore("ConditionalContentTuning.db2", &ConditionalContentTuningLoadInfo::Instance)
sWMOAreaTableStore
DB2Storage< WMOAreaTableEntry > sWMOAreaTableStore("WMOAreaTable.db2", &WmoAreaTableLoadInfo::Instance)
sTraitTreeXTraitCurrencyStore
DB2Storage< TraitTreeXTraitCurrencyEntry > sTraitTreeXTraitCurrencyStore("TraitTreeXTraitCurrency.db2", &TraitTreeXTraitCurrencyLoadInfo::Instance)
sItemXBonusTreeStore
DB2Storage< ItemXBonusTreeEntry > sItemXBonusTreeStore("ItemXBonusTree.db2", &ItemXBonusTreeLoadInfo::Instance)
sChrSpecializationStore
DB2Storage< ChrSpecializationEntry > sChrSpecializationStore("ChrSpecialization.db2", &ChrSpecializationLoadInfo::Instance)
sCfgCategoriesStore
DB2Storage< Cfg_CategoriesEntry > sCfgCategoriesStore("Cfg_Categories.db2", &CfgCategoriesLoadInfo::Instance)
sExpectedStatModStore
DB2Storage< ExpectedStatModEntry > sExpectedStatModStore("ExpectedStatMod.db2", &ExpectedStatModLoadInfo::Instance)
sPrestigeLevelInfoStore
DB2Storage< PrestigeLevelInfoEntry > sPrestigeLevelInfoStore("PrestigeLevelInfo.db2", &PrestigeLevelInfoLoadInfo::Instance)
sChrClassesXPowerTypesStore
DB2Storage< ChrClassesXPowerTypesEntry > sChrClassesXPowerTypesStore("ChrClassesXPowerTypes.db2", &ChrClassesXPowerTypesLoadInfo::Instance)
sGarrPlotBuildingStore
DB2Storage< GarrPlotBuildingEntry > sGarrPlotBuildingStore("GarrPlotBuilding.db2", &GarrPlotBuildingLoadInfo::Instance)
sSceneScriptTextStore
DB2Storage< SceneScriptTextEntry > sSceneScriptTextStore("SceneScriptText.db2", &SceneScriptTextLoadInfo::Instance)
sChrCustomizationReqChoiceStore
DB2Storage< ChrCustomizationReqChoiceEntry > sChrCustomizationReqChoiceStore("ChrCustomizationReqChoice.db2", &ChrCustomizationReqChoiceLoadInfo::Instance)
sGossipNPCOptionStore
DB2Storage< GossipNPCOptionEntry > sGossipNPCOptionStore("GossipNPCOption.db2", &GossipNpcOptionLoadInfo::Instance)
sPowerTypeStore
DB2Storage< PowerTypeEntry > sPowerTypeStore("PowerType.db2", &PowerTypeLoadInfo::Instance)
sItemSetStore
DB2Storage< ItemSetEntry > sItemSetStore("ItemSet.db2", &ItemSetLoadInfo::Instance)
sTraitNodeEntryStore
DB2Storage< TraitNodeEntryEntry > sTraitNodeEntryStore("TraitNodeEntry.db2", &TraitNodeEntryLoadInfo::Instance)
sQuestSortStore
DB2Storage< QuestSortEntry > sQuestSortStore("QuestSort.db2", &QuestSortLoadInfo::Instance)
sGarrSiteLevelStore
DB2Storage< GarrSiteLevelEntry > sGarrSiteLevelStore("GarrSiteLevel.db2", &GarrSiteLevelLoadInfo::Instance)
sSceneScriptPackageStore
DB2Storage< SceneScriptPackageEntry > sSceneScriptPackageStore("SceneScriptPackage.db2", &SceneScriptPackageLoadInfo::Instance)
sCreatureDisplayInfoExtraStore
DB2Storage< CreatureDisplayInfoExtraEntry > sCreatureDisplayInfoExtraStore("CreatureDisplayInfoExtra.db2", &CreatureDisplayInfoExtraLoadInfo::Instance)
sTotemCategoryStore
DB2Storage< TotemCategoryEntry > sTotemCategoryStore("TotemCategory.db2", &TotemCategoryLoadInfo::Instance)
sSpellLevelsStore
DB2Storage< SpellLevelsEntry > sSpellLevelsStore("SpellLevels.db2", &SpellLevelsLoadInfo::Instance)
sSpellVisualKitStore
DB2Storage< SpellVisualKitEntry > sSpellVisualKitStore("SpellVisualKit.db2", &SpellVisualKitLoadInfo::Instance)
sAdventureMapPOIStore
DB2Storage< AdventureMapPOIEntry > sAdventureMapPOIStore("AdventureMapPOI.db2", &AdventureMapPoiLoadInfo::Instance)
sPvpTalentStore
DB2Storage< PvpTalentEntry > sPvpTalentStore("PvpTalent.db2", &PvpTalentLoadInfo::Instance)
sScenarioStepStore
DB2Storage< ScenarioStepEntry > sScenarioStepStore("ScenarioStep.db2", &ScenarioStepLoadInfo::Instance)
sJournalTierStore
DB2Storage< JournalTierEntry > sJournalTierStore("JournalTier.db2", &JournalTierLoadInfo::Instance)
sBattlePetAbilityStore
DB2Storage< BattlePetAbilityEntry > sBattlePetAbilityStore("BattlePetAbility.db2", &BattlePetAbilityLoadInfo::Instance)
sSpellVisualMissileStore
DB2Storage< SpellVisualMissileEntry > sSpellVisualMissileStore("SpellVisualMissile.db2", &SpellVisualMissileLoadInfo::Instance)
sItemEffectStore
DB2Storage< ItemEffectEntry > sItemEffectStore("ItemEffect.db2", &ItemEffectLoadInfo::Instance)
ArtifactPowersContainer
std::unordered_map< uint32, std::vector< ArtifactPowerEntry const * > > ArtifactPowersContainer
Definition: DB2Stores.cpp:389
sBarberShopStyleStore
DB2Storage< BarberShopStyleEntry > sBarberShopStyleStore("BarberShopStyle.db2", &BarberShopStyleLoadInfo::Instance)
SkillRaceClassInfoContainer
std::unordered_multimap< uint32, SkillRaceClassInfoEntry const * > SkillRaceClassInfoContainer
Definition: DB2Stores.cpp:413
sChatChannelsStore
DB2Storage< ChatChannelsEntry > sChatChannelsStore("ChatChannels.db2", &ChatChannelsLoadInfo::Instance)
AllowedHotfixOptionalData
std::pair< uint32, bool(*)(std::vector< uint8 > const &data) > AllowedHotfixOptionalData
Definition: DB2Stores.cpp:424
sMawPowerStore
DB2Storage< MawPowerEntry > sMawPowerStore("MawPower.db2", &MawPowerLoadInfo::Instance)
sToyStore
DB2Storage< ToyEntry > sToyStore("Toy.db2", &ToyLoadInfo::Instance)
sCriteriaTreeStore
DB2Storage< CriteriaTreeEntry > sCriteriaTreeStore("CriteriaTree.db2", &CriteriaTreeLoadInfo::Instance)
sChrClassUIDisplayStore
DB2Storage< ChrClassUIDisplayEntry > sChrClassUIDisplayStore("ChrClassUIDisplay.db2", &ChrClassUiDisplayLoadInfo::Instance)
sTraitDefinitionEffectPointsStore
DB2Storage< TraitDefinitionEffectPointsEntry > sTraitDefinitionEffectPointsStore("TraitDefinitionEffectPoints.db2", &TraitDefinitionEffectPointsLoadInfo::Instance)
sCorruptionEffectsStore
DB2Storage< CorruptionEffectsEntry > sCorruptionEffectsStore("CorruptionEffects.db2", &CorruptionEffectsLoadInfo::Instance)
sImportPriceShieldStore
DB2Storage< ImportPriceShieldEntry > sImportPriceShieldStore("ImportPriceShield.db2", &ImportPriceShieldLoadInfo::Instance)
sBattlePetSpeciesStore
DB2Storage< BattlePetSpeciesEntry > sBattlePetSpeciesStore("BattlePetSpecies.db2", &BattlePetSpeciesLoadInfo::Instance)
sItemArmorShieldStore
DB2Storage< ItemArmorShieldEntry > sItemArmorShieldStore("ItemArmorShield.db2", &ItemArmorShieldLoadInfo::Instance)
sAreaTriggerStore
DB2Storage< AreaTriggerEntry > sAreaTriggerStore("AreaTrigger.db2", &AreaTriggerLoadInfo::Instance)
sSpellDurationStore
DB2Storage< SpellDurationEntry > sSpellDurationStore("SpellDuration.db2", &SpellDurationLoadInfo::Instance)
sSpellLearnSpellStore
DB2Storage< SpellLearnSpellEntry > sSpellLearnSpellStore("SpellLearnSpell.db2", &SpellLearnSpellLoadInfo::Instance)
sConversationLineStore
DB2Storage< ConversationLineEntry > sConversationLineStore("ConversationLine.db2", &ConversationLineLoadInfo::Instance)
sSpellCooldownsStore
DB2Storage< SpellCooldownsEntry > sSpellCooldownsStore("SpellCooldowns.db2", &SpellCooldownsLoadInfo::Instance)
sMountTypeXCapabilityStore
DB2Storage< MountTypeXCapabilityEntry > sMountTypeXCapabilityStore("MountTypeXCapability.db2", &MountTypeXCapabilityLoadInfo::Instance)
sAdventureJournalStore
DB2Storage< AdventureJournalEntry > sAdventureJournalStore("AdventureJournal.db2", &AdventureJournalLoadInfo::Instance)
LoadDB2
void LoadDB2(std::bitset< TOTAL_LOCALES > &availableDb2Locales, std::vector< std::string > &errlist, StorageMap &stores, DB2StorageBase *storage, std::string const &db2Path, LocaleConstant defaultLocale, std::size_t cppRecordSize)
Definition: DB2Stores.cpp:523
sMapDifficultyXConditionStore
DB2Storage< MapDifficultyXConditionEntry > sMapDifficultyXConditionStore("MapDifficultyXCondition.db2", &MapDifficultyXConditionLoadInfo::Instance)
sBannedAddonsStore
DB2Storage< BannedAddonsEntry > sBannedAddonsStore("BannedAddons.db2", &BannedAddonsLoadInfo::Instance)
WMOAreaTableKey
std::tuple< uint16, uint8, int32 > WMOAreaTableKey
Definition: DB2Stores.cpp:420
sItemArmorQualityStore
DB2Storage< ItemArmorQualityEntry > sItemArmorQualityStore("ItemArmorQuality.db2", &ItemArmorQualityLoadInfo::Instance)
sUnitConditionStore
DB2Storage< UnitConditionEntry > sUnitConditionStore("UnitCondition.db2", &UnitConditionLoadInfo::Instance)
AreaGroupMemberContainer
std::unordered_map< uint32, std::vector< uint32 > > AreaGroupMemberContainer
Definition: DB2Stores.cpp:388
sItemDamageAmmoStore
DB2Storage< ItemDamageAmmoEntry > sItemDamageAmmoStore("ItemDamageAmmo.db2", &ItemDamageAmmoLoadInfo::Instance)
sArtifactTierStore
DB2Storage< ArtifactTierEntry > sArtifactTierStore("ArtifactTier.db2", &ArtifactTierLoadInfo::Instance)
GlyphBindableSpellsContainer
std::unordered_map< uint32, std::vector< uint32 > > GlyphBindableSpellsContainer
Definition: DB2Stores.cpp:397
sItemModifiedAppearanceStore
DB2Storage< ItemModifiedAppearanceEntry > sItemModifiedAppearanceStore("ItemModifiedAppearance.db2", &ItemModifiedAppearanceLoadInfo::Instance)
sMailTemplateStore
DB2Storage< MailTemplateEntry > sMailTemplateStore("MailTemplate.db2", &MailTemplateLoadInfo::Instance)
sEmotesStore
DB2Storage< EmotesEntry > sEmotesStore("Emotes.db2", &EmotesLoadInfo::Instance)
ItemSetSpellContainer
std::unordered_map< uint32, std::vector< ItemSetSpellEntry const * > > ItemSetSpellContainer
Definition: DB2Stores.cpp:403
sItemSetSpellStore
DB2Storage< ItemSetSpellEntry > sItemSetSpellStore("ItemSetSpell.db2", &ItemSetSpellLoadInfo::Instance)
sCfgRegionsStore
DB2Storage< Cfg_RegionsEntry > sCfgRegionsStore("Cfg_Regions.db2", &CfgRegionsLoadInfo::Instance)
sUiMapStore
DB2Storage< UiMapEntry > sUiMapStore("UiMap.db2", &UiMapLoadInfo::Instance)
sSkillLineAbilityStore
DB2Storage< SkillLineAbilityEntry > sSkillLineAbilityStore("SkillLineAbility.db2", &SkillLineAbilityLoadInfo::Instance)
sCurrencyContainerStore
DB2Storage< CurrencyContainerEntry > sCurrencyContainerStore("CurrencyContainer.db2", &CurrencyContainerLoadInfo::Instance)
sItemDisenchantLootStore
DB2Storage< ItemDisenchantLootEntry > sItemDisenchantLootStore("ItemDisenchantLoot.db2", &ItemDisenchantLootLoadInfo::Instance)
sKeychainStore
DB2Storage< KeychainEntry > sKeychainStore("Keychain.db2", &KeychainLoadInfo::Instance)
QuestPackageItemContainer
std::unordered_map< uint32, std::pair< std::vector< QuestPackageItemEntry const * >, std::vector< QuestPackageItemEntry const * > > > QuestPackageItemContainer
Definition: DB2Stores.cpp:412
sTraitEdgeStore
DB2Storage< TraitEdgeEntry > sTraitEdgeStore("TraitEdge.db2", &TraitEdgeLoadInfo::Instance)
sAzeriteUnlockMappingStore
DB2Storage< AzeriteUnlockMappingEntry > sAzeriteUnlockMappingStore("AzeriteUnlockMapping.db2", &AzeriteUnlockMappingLoadInfo::Instance)
sAzeriteTierUnlockStore
DB2Storage< AzeriteTierUnlockEntry > sAzeriteTierUnlockStore("AzeriteTierUnlock.db2", &AzeriteTierUnlockLoadInfo::Instance)
sSummonPropertiesStore
DB2Storage< SummonPropertiesEntry > sSummonPropertiesStore("SummonProperties.db2", &SummonPropertiesLoadInfo::Instance)
sSpellReagentsCurrencyStore
DB2Storage< SpellReagentsCurrencyEntry > sSpellReagentsCurrencyStore("SpellReagentsCurrency.db2", &SpellReagentsCurrencyLoadInfo::Instance)
sGuildPerkSpellsStore
DB2Storage< GuildPerkSpellsEntry > sGuildPerkSpellsStore("GuildPerkSpells.db2", &GuildPerkSpellsLoadInfo::Instance)
sTraitDefinitionStore
DB2Storage< TraitDefinitionEntry > sTraitDefinitionStore("TraitDefinition.db2", &TraitDefinitionLoadInfo::Instance)
sAzeriteLevelInfoStore
DB2Storage< AzeriteLevelInfoEntry > sAzeriteLevelInfoStore("AzeriteLevelInfo.db2", &AzeriteLevelInfoLoadInfo::Instance)
sLFGDungeonsStore
DB2Storage< LFGDungeonsEntry > sLFGDungeonsStore("LFGDungeons.db2", &LfgDungeonsLoadInfo::Instance)
sTaxiPathNodeStore
DB2Storage< TaxiPathNodeEntry > sTaxiPathNodeStore("TaxiPathNode.db2", &TaxiPathNodeLoadInfo::Instance)
sSpellFocusObjectStore
DB2Storage< SpellFocusObjectEntry > sSpellFocusObjectStore("SpellFocusObject.db2", &SpellFocusObjectLoadInfo::Instance)
sTactKeyStore
DB2Storage< TactKeyEntry > sTactKeyStore("TactKey.db2", &TactKeyLoadInfo::Instance)
sNamesReservedLocaleStore
DB2Storage< NamesReservedLocaleEntry > sNamesReservedLocaleStore("NamesReservedLocale.db2", &NamesReservedLocaleLoadInfo::Instance)
sImportPriceQualityStore
DB2Storage< ImportPriceQualityEntry > sImportPriceQualityStore("ImportPriceQuality.db2", &ImportPriceQualityLoadInfo::Instance)
sPvpTierStore
DB2Storage< PvpTierEntry > sPvpTierStore("PvpTier.db2", &PvpTierLoadInfo::Instance)
sItemContextPickerEntryStore
DB2Storage< ItemContextPickerEntryEntry > sItemContextPickerEntryStore("ItemContextPickerEntry.db2", &ItemContextPickerEntryLoadInfo::Instance)
sMountXDisplayStore
DB2Storage< MountXDisplayEntry > sMountXDisplayStore("MountXDisplay.db2", &MountXDisplayLoadInfo::Instance)
sNameGenStore
DB2Storage< NameGenEntry > sNameGenStore("NameGen.db2", &NameGenLoadInfo::Instance)
sBroadcastTextStore
DB2Storage< BroadcastTextEntry > sBroadcastTextStore("BroadcastText.db2", &BroadcastTextLoadInfo::Instance)
sSpellCastingRequirementsStore
DB2Storage< SpellCastingRequirementsEntry > sSpellCastingRequirementsStore("SpellCastingRequirements.db2", &SpellCastingRequirementsLoadInfo::Instance)
ItemLimitCategoryConditionContainer
std::unordered_map< uint32, std::vector< ItemLimitCategoryConditionEntry const * > > ItemLimitCategoryConditionContainer
Definition: DB2Stores.cpp:401
sMythicPlusSeasonStore
DB2Storage< MythicPlusSeasonEntry > sMythicPlusSeasonStore("MythicPlusSeason.db2", &MythicPlusSeasonLoadInfo::Instance)
sGameObjectArtKitStore
DB2Storage< GameObjectArtKitEntry > sGameObjectArtKitStore("GameObjectArtKit.db2", &GameobjectArtKitLoadInfo::Instance)
sItemLimitCategoryConditionStore
DB2Storage< ItemLimitCategoryConditionEntry > sItemLimitCategoryConditionStore("ItemLimitCategoryCondition.db2", &ItemLimitCategoryConditionLoadInfo::Instance)
sItemExtendedCostStore
DB2Storage< ItemExtendedCostEntry > sItemExtendedCostStore("ItemExtendedCost.db2", &ItemExtendedCostLoadInfo::Instance)
sSpellEffectStore
DB2Storage< SpellEffectEntry > sSpellEffectStore("SpellEffect.db2", &SpellEffectLoadInfo::Instance)
sContentTuningXLabelStore
DB2Storage< ContentTuningXLabelEntry > sContentTuningXLabelStore("ContentTuningXLabel.db2", &ContentTuningXLabelLoadInfo::Instance)
NameValidationRegexContainer
std::array< std::vector< Trinity::wregex >, TOTAL_LOCALES+1 > NameValidationRegexContainer
Definition: DB2Stores.cpp:409
sGuildColorBackgroundStore
DB2Storage< GuildColorBackgroundEntry > sGuildColorBackgroundStore("GuildColorBackground.db2", &GuildColorBackgroundLoadInfo::Instance)
sPVPDifficultyStore
DB2Storage< PVPDifficultyEntry > sPVPDifficultyStore("PVPDifficulty.db2", &PvpDifficultyLoadInfo::Instance)
HotfixBlobMap
std::map< HotfixBlobKey, std::vector< uint8 > > HotfixBlobMap
Definition: DB2Stores.cpp:423
sTraitNodeEntryXTraitCondStore
DB2Storage< TraitNodeEntryXTraitCondEntry > sTraitNodeEntryXTraitCondStore("TraitNodeEntryXTraitCond.db2", &TraitNodeEntryXTraitCondLoadInfo::Instance)
sQuestV2Store
DB2Storage< QuestV2Entry > sQuestV2Store("QuestV2.db2", &QuestV2LoadInfo::Instance)
sAzeriteEmpoweredItemStore
DB2Storage< AzeriteEmpoweredItemEntry > sAzeriteEmpoweredItemStore("AzeriteEmpoweredItem.db2", &AzeriteEmpoweredItemLoadInfo::Instance)
sVignetteStore
DB2Storage< VignetteEntry > sVignetteStore("Vignette.db2", &VignetteLoadInfo::Instance)
sCurrencyTypesStore
DB2Storage< CurrencyTypesEntry > sCurrencyTypesStore("CurrencyTypes.db2", &CurrencyTypesLoadInfo::Instance)
sLanguagesStore
DB2Storage< LanguagesEntry > sLanguagesStore("Languages.db2", &LanguagesLoadInfo::Instance)
sMapChallengeModeStore
DB2Storage< MapChallengeModeEntry > sMapChallengeModeStore("MapChallengeMode.db2", &MapChallengeModeLoadInfo::Instance)
sSpellRadiusStore
DB2Storage< SpellRadiusEntry > sSpellRadiusStore("SpellRadius.db2", &SpellRadiusLoadInfo::Instance)
sTraitCurrencyStore
DB2Storage< TraitCurrencyEntry > sTraitCurrencyStore("TraitCurrency.db2", &TraitCurrencyLoadInfo::Instance)
sAzeriteTierUnlockSetStore
DB2Storage< AzeriteTierUnlockSetEntry > sAzeriteTierUnlockSetStore("AzeriteTierUnlockSet.db2", &AzeriteTierUnlockSetLoadInfo::Instance)
sGemPropertiesStore
DB2Storage< GemPropertiesEntry > sGemPropertiesStore("GemProperties.db2", &GemPropertiesLoadInfo::Instance)
sItemBonusListLevelDeltaStore
DB2Storage< ItemBonusListLevelDeltaEntry > sItemBonusListLevelDeltaStore("ItemBonusListLevelDelta.db2", &ItemBonusListLevelDeltaLoadInfo::Instance)
sItemBonusListGroupEntryStore
DB2Storage< ItemBonusListGroupEntryEntry > sItemBonusListGroupEntryStore("ItemBonusListGroupEntry.db2", &ItemBonusListGroupEntryLoadInfo::Instance)
sHeirloomStore
DB2Storage< HeirloomEntry > sHeirloomStore("Heirloom.db2", &HeirloomLoadInfo::Instance)
sQuestXPStore
DB2Storage< QuestXPEntry > sQuestXPStore("QuestXP.db2", &QuestXpLoadInfo::Instance)
sUiMapXMapArtStore
DB2Storage< UiMapXMapArtEntry > sUiMapXMapArtStore("UiMapXMapArt.db2", &UiMapXMapArtLoadInfo::Instance)
sGlyphPropertiesStore
DB2Storage< GlyphPropertiesEntry > sGlyphPropertiesStore("GlyphProperties.db2", &GlyphPropertiesLoadInfo::Instance)
sWorldEffectStore
DB2Storage< WorldEffectEntry > sWorldEffectStore("WorldEffect.db2", &WorldEffectLoadInfo::Instance)
PhaseGroupContainer
std::unordered_map< uint32, std::vector< uint32 > > PhaseGroupContainer
Definition: DB2Stores.cpp:410
sDungeonEncounterStore
DB2Storage< DungeonEncounterEntry > sDungeonEncounterStore("DungeonEncounter.db2", &DungeonEncounterLoadInfo::Instance)
sPvpTalentSlotUnlockStore
DB2Storage< PvpTalentSlotUnlockEntry > sPvpTalentSlotUnlockStore("PvpTalentSlotUnlock.db2", &PvpTalentSlotUnlockLoadInfo::Instance)
sSpellTargetRestrictionsStore
DB2Storage< SpellTargetRestrictionsEntry > sSpellTargetRestrictionsStore("SpellTargetRestrictions.db2", &SpellTargetRestrictionsLoadInfo::Instance)
sChrRacesStore
DB2Storage< ChrRacesEntry > sChrRacesStore("ChrRaces.db2", &ChrRacesLoadInfo::Instance)
sTraitNodeXTraitCostStore
DB2Storage< TraitNodeXTraitCostEntry > sTraitNodeXTraitCostStore("TraitNodeXTraitCost.db2", &TraitNodeXTraitCostLoadInfo::Instance)
sParagonReputationStore
DB2Storage< ParagonReputationEntry > sParagonReputationStore("ParagonReputation.db2", &ParagonReputationLoadInfo::Instance)
sQuestPackageItemStore
DB2Storage< QuestPackageItemEntry > sQuestPackageItemStore("QuestPackageItem.db2", &QuestPackageItemLoadInfo::Instance)
ArtifactPowerRanksContainer
std::unordered_map< std::pair< uint32, uint8 >, ArtifactPowerRankEntry const * > ArtifactPowerRanksContainer
Definition: DB2Stores.cpp:391
sPlayerConditionStore
DB2Storage< PlayerConditionEntry > sPlayerConditionStore("PlayerCondition.db2", &PlayerConditionLoadInfo::Instance)
sGlyphBindableSpellStore
DB2Storage< GlyphBindableSpellEntry > sGlyphBindableSpellStore("GlyphBindableSpell.db2", &GlyphBindableSpellLoadInfo::Instance)
sTransmogSetItemStore
DB2Storage< TransmogSetItemEntry > sTransmogSetItemStore("TransmogSetItem.db2", &TransmogSetItemLoadInfo::Instance)
sRewardPackXCurrencyTypeStore
DB2Storage< RewardPackXCurrencyTypeEntry > sRewardPackXCurrencyTypeStore("RewardPackXCurrencyType.db2", &RewardPackXCurrencyTypeLoadInfo::Instance)
SpellPowerContainer
std::unordered_map< uint32, std::vector< SpellPowerEntry const * > > SpellPowerContainer
Definition: DB2Stores.cpp:415
sArtifactPowerLinkStore
DB2Storage< ArtifactPowerLinkEntry > sArtifactPowerLinkStore("ArtifactPowerLink.db2", &ArtifactPowerLinkLoadInfo::Instance)
sChrCustomizationReqStore
DB2Storage< ChrCustomizationReqEntry > sChrCustomizationReqStore("ChrCustomizationReq.db2", &ChrCustomizationReqLoadInfo::Instance)
sImportPriceArmorStore
DB2Storage< ImportPriceArmorEntry > sImportPriceArmorStore("ImportPriceArmor.db2", &ImportPriceArmorLoadInfo::Instance)
sCreatureDisplayInfoStore
DB2Storage< CreatureDisplayInfoEntry > sCreatureDisplayInfoStore("CreatureDisplayInfo.db2", &CreatureDisplayInfoLoadInfo::Instance)
sContentTuningStore
DB2Storage< ContentTuningEntry > sContentTuningStore("ContentTuning.db2", &ContentTuningLoadInfo::Instance)
sItemLevelSelectorQualitySetStore
DB2Storage< ItemLevelSelectorQualitySetEntry > sItemLevelSelectorQualitySetStore("ItemLevelSelectorQualitySet.db2", &ItemLevelSelectorQualitySetLoadInfo::Instance)
sTraitNodeXTraitCondStore
DB2Storage< TraitNodeXTraitCondEntry > sTraitNodeXTraitCondStore("TraitNodeXTraitCond.db2", &TraitNodeXTraitCondLoadInfo::Instance)
sSpellItemEnchantmentStore
DB2Storage< SpellItemEnchantmentEntry > sSpellItemEnchantmentStore("SpellItemEnchantment.db2", &SpellItemEnchantmentLoadInfo::Instance)
sSpellClassOptionsStore
DB2Storage< SpellClassOptionsEntry > sSpellClassOptionsStore("SpellClassOptions.db2", &SpellClassOptionsLoadInfo::Instance)
sAzeritePowerStore
DB2Storage< AzeritePowerEntry > sAzeritePowerStore("AzeritePower.db2", &AzeritePowerLoadInfo::Instance)
sPowerDisplayStore
DB2Storage< PowerDisplayEntry > sPowerDisplayStore("PowerDisplay.db2", &PowerDisplayLoadInfo::Instance)
sKeystoneAffixStore
DB2Storage< KeystoneAffixEntry > sKeystoneAffixStore("KeystoneAffix.db2", &KeystoneAffixLoadInfo::Instance)
sSoulbindConduitRankStore
DB2Storage< SoulbindConduitRankEntry > sSoulbindConduitRankStore("SoulbindConduitRank.db2", &SoulbindConduitRankLoadInfo::Instance)
sHolidaysStore
DB2Storage< HolidaysEntry > sHolidaysStore("Holidays.db2", &HolidaysLoadInfo::Instance)
sArmorLocationStore
DB2Storage< ArmorLocationEntry > sArmorLocationStore("ArmorLocation.db2", &ArmorLocationLoadInfo::Instance)
sTransmogHolidayStore
DB2Storage< TransmogHolidayEntry > sTransmogHolidayStore("TransmogHoliday.db2", &TransmogHolidayLoadInfo::Instance)
sTalentStore
DB2Storage< TalentEntry > sTalentStore("Talent.db2", &TalentLoadInfo::Instance)
sMovieStore
DB2Storage< MovieEntry > sMovieStore("Movie.db2", &MovieLoadInfo::Instance)
sItemCurrencyCostStore
DB2Storage< ItemCurrencyCostEntry > sItemCurrencyCostStore("ItemCurrencyCost.db2", &ItemCurrencyCostLoadInfo::Instance)
NameGenContainer
std::unordered_map< uint32, std::array< std::vector< NameGenEntry const * >, 2 > > NameGenContainer
Definition: DB2Stores.cpp:408
sItemAppearanceStore
DB2Storage< ItemAppearanceEntry > sItemAppearanceStore("ItemAppearance.db2", &ItemAppearanceLoadInfo::Instance)
sTransmogSetGroupStore
DB2Storage< TransmogSetGroupEntry > sTransmogSetGroupStore("TransmogSetGroup.db2", &TransmogSetGroupLoadInfo::Instance)
sItemSparseStore
DB2Storage< ItemSparseEntry > sItemSparseStore("ItemSparse.db2", &ItemSparseLoadInfo::Instance)
sTraitNodeGroupStore
DB2Storage< TraitNodeGroupEntry > sTraitNodeGroupStore("TraitNodeGroup.db2", &TraitNodeGroupLoadInfo::Instance)
sFactionTemplateStore
DB2Storage< FactionTemplateEntry > sFactionTemplateStore("FactionTemplate.db2", &FactionTemplateLoadInfo::Instance)
sItemDamageTwoHandStore
DB2Storage< ItemDamageTwoHandEntry > sItemDamageTwoHandStore("ItemDamageTwoHand.db2", &ItemDamageTwoHandLoadInfo::Instance)
sAuctionHouseStore
DB2Storage< AuctionHouseEntry > sAuctionHouseStore("AuctionHouse.db2", &AuctionHouseLoadInfo::Instance)
sSpellProcsPerMinuteModStore
DB2Storage< SpellProcsPerMinuteModEntry > sSpellProcsPerMinuteModStore("SpellProcsPerMinuteMod.db2", &SpellProcsPerMinuteModLoadInfo::Instance)
sMountCapabilityStore
DB2Storage< MountCapabilityEntry > sMountCapabilityStore("MountCapability.db2", &MountCapabilityLoadInfo::Instance)
sSoundKitStore
DB2Storage< SoundKitEntry > sSoundKitStore("SoundKit.db2", &SoundKitLoadInfo::Instance)
sChrCustomizationChoiceStore
DB2Storage< ChrCustomizationChoiceEntry > sChrCustomizationChoiceStore("ChrCustomizationChoice.db2", &ChrCustomizationChoiceLoadInfo::Instance)
sAzeriteItemStore
DB2Storage< AzeriteItemEntry > sAzeriteItemStore("AzeriteItem.db2", &AzeriteItemLoadInfo::Instance)
sItemClassStore
DB2Storage< ItemClassEntry > sItemClassStore("ItemClass.db2", &ItemClassLoadInfo::Instance)
sTraitNodeEntryXTraitCostStore
DB2Storage< TraitNodeEntryXTraitCostEntry > sTraitNodeEntryXTraitCostStore("TraitNodeEntryXTraitCost.db2", &TraitNodeEntryXTraitCostLoadInfo::Instance)
sItemSpecStore
DB2Storage< ItemSpecEntry > sItemSpecStore("ItemSpec.db2", &ItemSpecLoadInfo::Instance)
sAzeriteEssenceStore
DB2Storage< AzeriteEssenceEntry > sAzeriteEssenceStore("AzeriteEssence.db2", &AzeriteEssenceLoadInfo::Instance)
sItemDamageOneHandCasterStore
DB2Storage< ItemDamageOneHandCasterEntry > sItemDamageOneHandCasterStore("ItemDamageOneHandCaster.db2", &ItemDamageOneHandCasterLoadInfo::Instance)
sSpellKeyboundOverrideStore
DB2Storage< SpellKeyboundOverrideEntry > sSpellKeyboundOverrideStore("SpellKeyboundOverride.db2", &SpellKeyboundOverrideLoadInfo::Instance)
MountDisplaysCointainer
std::unordered_map< uint32, DB2Manager::MountXDisplayContainer > MountDisplaysCointainer
Definition: DB2Stores.cpp:407
sSpellTotemsStore
DB2Storage< SpellTotemsEntry > sSpellTotemsStore("SpellTotems.db2", &SpellTotemsLoadInfo::Instance)
sTraitTreeLoadoutEntryStore
DB2Storage< TraitTreeLoadoutEntryEntry > sTraitTreeLoadoutEntryStore("TraitTreeLoadoutEntry.db2", &TraitTreeLoadoutEntryLoadInfo::Instance)
sGarrClassSpecStore
DB2Storage< GarrClassSpecEntry > sGarrClassSpecStore("GarrClassSpec.db2", &GarrClassSpecLoadInfo::Instance)
sSpellCategoriesStore
DB2Storage< SpellCategoriesEntry > sSpellCategoriesStore("SpellCategories.db2", &SpellCategoriesLoadInfo::Instance)
sBroadcastTextDurationStore
DB2Storage< BroadcastTextDurationEntry > sBroadcastTextDurationStore("BroadcastTextDuration.db2", &BroadcastTextDurationLoadInfo::Instance)
sAreaGroupMemberStore
DB2Storage< AreaGroupMemberEntry > sAreaGroupMemberStore("AreaGroupMember.db2", &AreaGroupMemberLoadInfo::Instance)
sSceneScriptGlobalTextStore
DB2Storage< SceneScriptGlobalTextEntry > sSceneScriptGlobalTextStore("SceneScriptGlobalText.db2", &SceneScriptGlobalTextLoadInfo::Instance)
sSpellLabelStore
DB2Storage< SpellLabelEntry > sSpellLabelStore("SpellLabel.db2", &SpellLabelLoadInfo::Instance)
sAreaTableStore
DB2Storage< AreaTableEntry > sAreaTableStore("AreaTable.db2", &AreaTableLoadInfo::Instance)
sSpellProcsPerMinuteStore
DB2Storage< SpellProcsPerMinuteEntry > sSpellProcsPerMinuteStore("SpellProcsPerMinute.db2", &SpellProcsPerMinuteLoadInfo::Instance)
sTaxiPathStore
DB2Storage< TaxiPathEntry > sTaxiPathStore("TaxiPath.db2", &TaxiPathLoadInfo::Instance)
operator<
static bool operator<(UiMapAssignmentStatus const &left, UiMapAssignmentStatus const &right)
Definition: DB2Stores.cpp:3061
ToyItemIdsContainer
std::unordered_set< uint32 > ToyItemIdsContainer
Definition: DB2Stores.cpp:419
sSpellPowerStore
DB2Storage< SpellPowerEntry > sSpellPowerStore("SpellPower.db2", &SpellPowerLoadInfo::Instance)
sGarrFollowerStore
DB2Storage< GarrFollowerEntry > sGarrFollowerStore("GarrFollower.db2", &GarrFollowerLoadInfo::Instance)
sArtifactAppearanceSetStore
DB2Storage< ArtifactAppearanceSetEntry > sArtifactAppearanceSetStore("ArtifactAppearanceSet.db2", &ArtifactAppearanceSetLoadInfo::Instance)
sUiMapAssignmentStore
DB2Storage< UiMapAssignmentEntry > sUiMapAssignmentStore("UiMapAssignment.db2", &UiMapAssignmentLoadInfo::Instance)
sRewardPackStore
DB2Storage< RewardPackEntry > sRewardPackStore("RewardPack.db2", &RewardPackLoadInfo::Instance)
sFactionStore
DB2Storage< FactionEntry > sFactionStore("Faction.db2", &FactionLoadInfo::Instance)
sDurabilityCostsStore
DB2Storage< DurabilityCostsEntry > sDurabilityCostsStore("DurabilityCosts.db2", &DurabilityCostsLoadInfo::Instance)
sVehicleStore
DB2Storage< VehicleEntry > sVehicleStore("Vehicle.db2", &VehicleLoadInfo::Instance)
sCinematicSequencesStore
DB2Storage< CinematicSequencesEntry > sCinematicSequencesStore("CinematicSequences.db2", &CinematicSequencesLoadInfo::Instance)
sHordeTaxiNodesMask
TaxiMask sHordeTaxiNodesMask
Definition: DB2Stores.cpp:381
sGuildColorBorderStore
DB2Storage< GuildColorBorderEntry > sGuildColorBorderStore("GuildColorBorder.db2", &GuildColorBorderLoadInfo::Instance)
sSpellItemEnchantmentConditionStore
DB2Storage< SpellItemEnchantmentConditionEntry > sSpellItemEnchantmentConditionStore("SpellItemEnchantmentCondition.db2", &SpellItemEnchantmentConditionLoadInfo::Instance)
sCinematicCameraStore
DB2Storage< CinematicCameraEntry > sCinematicCameraStore("CinematicCamera.db2", &CinematicCameraLoadInfo::Instance)
sSpellCastTimesStore
DB2Storage< SpellCastTimesEntry > sSpellCastTimesStore("SpellCastTimes.db2", &SpellCastTimesLoadInfo::Instance)
sGarrAbilityStore
DB2Storage< GarrAbilityEntry > sGarrAbilityStore("GarrAbility.db2", &GarrAbilityLoadInfo::Instance)
sGarrPlotStore
DB2Storage< GarrPlotEntry > sGarrPlotStore("GarrPlot.db2", &GarrPlotLoadInfo::Instance)
sSpellScalingStore
DB2Storage< SpellScalingEntry > sSpellScalingStore("SpellScaling.db2", &SpellScalingLoadInfo::Instance)
sJournalEncounterStore
DB2Storage< JournalEncounterEntry > sJournalEncounterStore("JournalEncounter.db2", &JournalEncounterLoadInfo::Instance)
CalculateGlobalUiMapPosition
static DBCPosition2D CalculateGlobalUiMapPosition(int32 uiMapID, DBCPosition2D uiPosition)
Definition: DB2Stores.cpp:3274
TaxiPathNodesByPath
std::vector< TaxiPathNodeList > TaxiPathNodesByPath
Definition: DB2Stores.h:333
DEFINE_DB2_SET_COMPARATOR
#define DEFINE_DB2_SET_COMPARATOR(structure)
Definition: DB2Stores.h:341
CurveInterpolationMode
CurveInterpolationMode
Definition: DBCEnums.h:862
AZERITE_TIER_UNLOCK_SET_FLAG_DEFAULT
@ AZERITE_TIER_UNLOCK_SET_FLAG_DEFAULT
Definition: DBCEnums.h:214
UiMapSystem
UiMapSystem
Definition: DBCEnums.h:2278
UI_MAP_SYSTEM_ADVENTURE
@ UI_MAP_SYSTEM_ADVENTURE
Definition: DBCEnums.h:2281
MAX_UI_MAP_SYSTEM
@ MAX_UI_MAP_SYSTEM
Definition: DBCEnums.h:2283
UI_MAP_SYSTEM_WORLD
@ UI_MAP_SYSTEM_WORLD
Definition: DBCEnums.h:2279
UI_MAP_SYSTEM_TAXI
@ UI_MAP_SYSTEM_TAXI
Definition: DBCEnums.h:2280
MAX_AZERITE_EMPOWERED_TIER
#define MAX_AZERITE_EMPOWERED_TIER
Definition: DBCEnums.h:200
MAX_LEVEL
@ MAX_LEVEL
Definition: DBCEnums.h:51
UI_MAP_TYPE_CONTINENT
@ UI_MAP_TYPE_CONTINENT
Definition: DBCEnums.h:2290
Difficulty
Difficulty
Definition: DBCEnums.h:873
AzeriteItemMilestoneType
AzeriteItemMilestoneType
Definition: DBCEnums.h:206
GlobalCurve
GlobalCurve
Definition: DBCEnums.h:968
DIFFICULTY_FLAG_DEFAULT
@ DIFFICULTY_FLAG_DEFAULT
Definition: DBCEnums.h:917
UiMapFlag::NoWorldPositions
@ NoWorldPositions
ItemContext
ItemContext
Definition: DBCEnums.h:1063
PLAYER_EXPLORED_ZONES_SIZE
constexpr size_t PLAYER_EXPLORED_ZONES_SIZE
Definition: DBCEnums.h:166
MAX_PVP_TALENT_SLOTS
#define MAX_PVP_TALENT_SLOTS
Definition: DBCEnums.h:2134
MAX_TALENT_TIERS
#define MAX_TALENT_TIERS
Definition: DBCEnums.h:2132
ContentTuningCalcType
ContentTuningCalcType
Definition: DBCEnums.h:401
ChrSpecialization
ChrSpecialization
Definition: DBCEnums.h:357
ExpectedStatType
ExpectedStatType
Definition: DBCEnums.h:927
MAX_TALENT_COLUMNS
#define MAX_TALENT_COLUMNS
Definition: DBCEnums.h:2133
BattlegroundBracketId
BattlegroundBracketId
Definition: DBCEnums.h:59
MAX_BATTLEGROUND_BRACKETS
@ MAX_BATTLEGROUND_BRACKETS
Definition: DBCEnums.h:64
MAX_AZERITE_ESSENCE_SLOT
#define MAX_AZERITE_ESSENCE_SLOT
Definition: DBCEnums.h:202
QUEST_PACKAGE_FILTER_UNMATCHED
@ QUEST_PACKAGE_FILTER_UNMATCHED
Definition: DBCEnums.h:1861
QueryResult
std::shared_ptr< ResultSet > QueryResult
Definition: DatabaseEnvFwd.h:28
HotfixDatabase
DatabaseWorkerPool< HotfixDatabaseConnection > HotfixDatabase
Accessor to the hotfix database.
Definition: DatabaseEnv.cpp:23
uint8
uint8_t uint8
Definition: Define.h:144
int16
int16_t int16
Definition: Define.h:139
int8
int8_t int8
Definition: Define.h:140
int32
int32_t int32
Definition: Define.h:138
uint16
uint16_t uint16
Definition: Define.h:143
FT_INT
@ FT_INT
Definition: Define.h:151
uint32
uint32_t uint32
Definition: Define.h:142
SZFMTD
#define SZFMTD
Definition: Define.h:132
ASSERT
#define ASSERT
Definition: Errors.h:68
TC_LOG_ERROR
#define TC_LOG_ERROR(filterType__,...)
Definition: Log.h:165
sLog
#define sLog
Definition: Log.h:130
TC_LOG_INFO
#define TC_LOG_INFO(filterType__,...)
Definition: Log.h:159
Optional
std::optional< T > Optional
Optional helper class to wrap optional values within.
Definition: Optional.h:25
rand32
uint32 rand32()
Definition: Random.cpp:70
if
if(posix_memalign(&__mallocedMemory, __align, __size)) return NULL
Classes
Classes
Definition: SharedDefines.h:148
CLASS_WARRIOR
@ CLASS_WARRIOR
Definition: SharedDefines.h:150
CLASS_MAGE
@ CLASS_MAGE
Definition: SharedDefines.h:157
CLASS_DEATH_KNIGHT
@ CLASS_DEATH_KNIGHT
Definition: SharedDefines.h:155
CLASS_DEMON_HUNTER
@ CLASS_DEMON_HUNTER
Definition: SharedDefines.h:161
CLASS_PALADIN
@ CLASS_PALADIN
Definition: SharedDefines.h:151
CLASS_ROGUE
@ CLASS_ROGUE
Definition: SharedDefines.h:153
GetMaxLevelForExpansion
constexpr uint32 GetMaxLevelForExpansion(uint32 expansion)
Definition: SharedDefines.h:107
GENDER_FEMALE
@ GENDER_FEMALE
Definition: SharedDefines.h:141
GENDER_NONE
@ GENDER_NONE
Definition: SharedDefines.h:142
ResponseCodes
ResponseCodes
Definition: SharedDefines.h:6156
CHAR_NAME_RESERVED
@ CHAR_NAME_RESERVED
Definition: SharedDefines.h:6264
CHAR_NAME_PROFANE
@ CHAR_NAME_PROFANE
Definition: SharedDefines.h:6263
CHAR_NAME_SUCCESS
@ CHAR_NAME_SUCCESS
Definition: SharedDefines.h:6256
MAX_SPECIALIZATIONS
#define MAX_SPECIALIZATIONS
Definition: SharedDefines.h:982
PET_SPEC_OVERRIDE_CLASS_INDEX
#define PET_SPEC_OVERRIDE_CLASS_INDEX
Definition: SharedDefines.h:983
Powers
Powers
Definition: SharedDefines.h:285
MAX_POWERS
@ MAX_POWERS
Definition: SharedDefines.h:313
MAX_CLASSES
#define MAX_CLASSES
Definition: SharedDefines.h:167
SpellFamilyNames
SpellFamilyNames
Definition: SharedDefines.h:6459
INITIAL_SPECIALIZATION_INDEX
#define INITIAL_SPECIALIZATION_INDEX
Definition: SharedDefines.h:984
GetMSTimeDiffToNow
uint32 GetMSTimeDiffToNow(uint32 oldMSTime)
Definition: Timer.h:57
getMSTime
uint32 getMSTime()
Definition: Timer.h:33
strToLower
void strToLower(std::string &str)
Definition: Util.cpp:482
Utf8toWStr
bool Utf8toWStr(char const *utf8str, size_t csize, wchar_t *wstr, size_t &wsize)
Definition: Util.cpp:383
DB2Manager::GetAzeriteEssencePower
AzeriteEssencePowerEntry const * GetAzeriteEssencePower(uint32 azeriteEssenceId, uint32 rank) const
Definition: DB2Stores.cpp:1970
DB2Manager::GetRewardPackCurrencyTypesByRewardID
std::vector< RewardPackXCurrencyTypeEntry const * > const * GetRewardPackCurrencyTypesByRewardID(uint32 rewardPackID) const
Definition: DB2Stores.cpp:2897
DB2Manager::GetSoulbindConduitRank
SoulbindConduitRankEntry const * GetSoulbindConduitRank(int32 soulbindConduitId, int32 rank) const
Definition: DB2Stores.cpp:2946
DB2Manager::GetItemSetSpells
std::vector< ItemSetSpellEntry const * > const * GetItemSetSpells(uint32 itemSetId) const
Definition: DB2Stores.cpp:2574
DB2Manager::GetChrModel
ChrModelEntry const * GetChrModel(uint8 race, uint8 gender) const
Definition: DB2Stores.cpp:2067
DB2Manager::EvaluateExpectedStat
float EvaluateExpectedStat(ExpectedStatType stat, uint32 level, int32 expansion, uint32 contentTuningId, Classes unitClass, int32 mythicPlusMilestoneSeason) const
Definition: DB2Stores.cpp:2376
DB2Manager::GetContentTuningForArea
static ContentTuningEntry const * GetContentTuningForArea(AreaTableEntry const *areaEntry)
Definition: DB2Stores.cpp:1924
DB2Manager::GetArtifactPowerLinks
std::vector< uint32 > const * GetArtifactPowerLinks(uint32 artifactPowerId) const
Definition: DB2Stores.cpp:1949
DB2Manager::GetSkillRaceClassInfo
SkillRaceClassInfoEntry const * GetSkillRaceClassInfo(uint32 skill, uint8 race, uint8 class_) const
Definition: DB2Stores.cpp:2922
DB2Manager::GetBroadcastTextValue
static char const * GetBroadcastTextValue(BroadcastTextEntry const *broadcastText, LocaleConstant locale=DEFAULT_LOCALE, uint8 gender=GENDER_MALE, bool forceGender=false)
Definition: DB2Stores.cpp:2008
DB2Manager::GetFriendshipRepReactions
FriendshipRepReactionSet const * GetFriendshipRepReactions(uint32 friendshipRepID) const
Definition: DB2Stores.cpp:2494
DB2Manager::GetQuestsForQuestLine
std::vector< QuestLineXQuestEntry const * > const * GetQuestsForQuestLine(uint32 questLineId) const
Definition: DB2Stores.cpp:2828
DB2Manager::GetFactionTeamList
std::vector< uint32 > const * GetFactionTeamList(uint32 faction) const
Definition: DB2Stores.cpp:2489
DB2Manager::IsSpecSetMember
bool IsSpecSetMember(int32 specSetId, uint32 specId) const
Definition: DB2Stores.cpp:2956
DB2Manager::GetRequiredAzeriteLevelForAzeritePowerTier
uint32 GetRequiredAzeriteLevelForAzeritePowerTier(uint32 azeriteUnlockSetId, ItemContext context, uint32 tier) const
Definition: DB2Stores.cpp:1994
DB2Manager::GetSpellVisualMissiles
std::vector< SpellVisualMissileEntry const * > const * GetSpellVisualMissiles(int32 spellVisualMissileSetId) const
Definition: DB2Stores.cpp:2975
DB2Manager::GetMountById
MountEntry const * GetMountById(uint32 id) const
Definition: DB2Stores.cpp:2699
DB2Manager::GetDefaultItemModifiedAppearance
ItemModifiedAppearanceEntry const * GetDefaultItemModifiedAppearance(uint32 itemId) const
Definition: DB2Stores.cpp:2569
DB2Manager::GetItemClassByOldEnum
ItemClassEntry const * GetItemClassByOldEnum(uint32 itemClass) const
Definition: DB2Stores.cpp:2528
DB2Manager::GetTransmogSetItems
std::vector< TransmogSetItemEntry const * > const * GetTransmogSetItems(uint32 transmogSetId) const
Definition: DB2Stores.cpp:3026
DB2Manager::GetSkillLinesForParentSkill
std::vector< SkillLineEntry const * > const * GetSkillLinesForParentSkill(uint32 parentSkillId) const
Definition: DB2Stores.cpp:2912
DB2Manager::GetMapDifficultyData
MapDifficultyEntry const * GetMapDifficultyData(uint32 mapId, Difficulty difficulty) const
Definition: DB2Stores.cpp:2653
DB2Manager::GetItemLimitCategoryConditions
std::vector< ItemLimitCategoryConditionEntry const * > const * GetItemLimitCategoryConditions(uint32 categoryId) const
Definition: DB2Stores.cpp:2538
DB2Manager::IsTotemCategoryCompatibleWith
static bool IsTotemCategoryCompatibleWith(uint32 itemTotemCategoryId, uint32 requiredTotemCategoryId, bool requireAllTotems=true)
Definition: DB2Stores.cpp:2990
DB2Manager::GetWMOAreaTable
WMOAreaTableEntry const * GetWMOAreaTable(int32 rootId, int32 adtId, int32 groupId) const
Definition: DB2Stores.cpp:3374
DB2Manager::GetPowerIndexByClass
uint32 GetPowerIndexByClass(Powers power, uint32 classId) const
Definition: DB2Stores.cpp:2047
DB2Manager::GetItemChildEquipment
ItemChildEquipmentEntry const * GetItemChildEquipment(uint32 itemId) const
Definition: DB2Stores.cpp:2523
DB2Manager::GetAzeriteItemMilestonePowers
std::vector< AzeriteItemMilestonePowerEntry const * > const & GetAzeriteItemMilestonePowers() const
Definition: DB2Stores.cpp:1975
DB2Manager::Instance
static DB2Manager & Instance()
Definition: DB2Stores.cpp:608
DB2Manager::GetPvpItemLevelBonus
uint8 GetPvpItemLevelBonus(uint32 itemId) const
Definition: DB2Stores.cpp:2888
DB2Manager::GetRequiredLevelForPvpTalentSlot
uint32 GetRequiredLevelForPvpTalentSlot(uint8 slot, Classes class_) const
Definition: DB2Stores.cpp:2798
DB2Manager::MapDifficultyConditionsContainer
std::vector< std::pair< uint32, PlayerConditionEntry const * > > MapDifficultyConditionsContainer
Definition: DB2Stores.h:407
DB2Manager::GetEmptyAnimStateID
uint32 GetEmptyAnimStateID() const
Definition: DB2Stores.cpp:1879
DB2Manager::GetMapDifficultyConditions
MapDifficultyConditionsContainer const * GetMapDifficultyConditions(uint32 mapDifficultyId) const
Definition: DB2Stores.cpp:2689
DB2Manager::GetGlyphRequiredSpecs
std::vector< ChrSpecialization > const * GetGlyphRequiredSpecs(uint32 glyphPropertiesId) const
Definition: DB2Stores.cpp:2513
DB2Manager::GetBattlegroundBracketById
static PVPDifficultyEntry const * GetBattlegroundBracketById(uint32 mapid, BattlegroundBracketId id)
Definition: DB2Stores.cpp:2789
DB2Manager::GetChrSpecializationByIndex
ChrSpecializationEntry const * GetChrSpecializationByIndex(uint32 class_, uint32 index) const
Definition: DB2Stores.cpp:2089
DB2Manager::GetQuestUniqueBitFlag
uint32 GetQuestUniqueBitFlag(uint32 questId)
Definition: DB2Stores.cpp:2851
DB2Manager::GetPhasesForGroup
std::vector< uint32 > const * GetPhasesForGroup(uint32 group) const
Definition: DB2Stores.cpp:2860
DB2Manager::GetMountDisplays
MountXDisplayContainer const * GetMountDisplays(uint32 mountId) const
Definition: DB2Stores.cpp:2709
DB2Manager::GetStorage
DB2StorageBase const * GetStorage(uint32 type) const
Definition: DB2Stores.cpp:1647
DB2Manager::GetLfgDungeon
static LFGDungeonsEntry const * GetLfgDungeon(uint32 mapId, Difficulty difficulty)
Definition: DB2Stores.cpp:2591
DB2Manager::Map2ZoneCoordinates
void Map2ZoneCoordinates(uint32 areaId, float &x, float &y) const
Definition: DB2Stores.cpp:3359
DB2Manager::_maxHotfixId
int32 _maxHotfixId
Definition: DB2Stores.h:535
DB2Manager::GetHotfixData
HotfixContainer const & GetHotfixData() const
Definition: DB2Stores.cpp:1860
DB2Manager::GetLiquidFlags
static uint32 GetLiquidFlags(uint32 liquidType)
Definition: DB2Stores.cpp:2615
DB2Manager::GetChrRaceName
static char const * GetChrRaceName(uint8 race, LocaleConstant locale=DEFAULT_LOCALE)
Definition: DB2Stores.cpp:2077
DB2Manager::HotfixContainer
std::map< int32, HotfixPush > HotfixContainer
Definition: DB2Stores.h:404
DB2Manager::GetTaxiPath
TaxiPathEntry const * GetTaxiPath(uint32 from, uint32 to) const
Definition: DB2Stores.cpp:2985
DB2Manager::GetRewardPackItemsByRewardID
std::vector< RewardPackXItemEntry const * > const * GetRewardPackItemsByRewardID(uint32 rewardPackID) const
Definition: DB2Stores.cpp:2902
DB2Manager::GetPowerTypeByName
PowerTypeEntry const * GetPowerTypeByName(std::string const &name) const
Definition: DB2Stores.cpp:2871
DB2Manager::GetTransmogSetsForItemModifiedAppearance
std::vector< TransmogSetEntry const * > const * GetTransmogSetsForItemModifiedAppearance(uint32 itemModifiedAppearanceId) const
Definition: DB2Stores.cpp:3021
DB2Manager::Zone2MapCoordinates
bool Zone2MapCoordinates(uint32 areaId, float &x, float &y) const
Definition: DB2Stores.cpp:3337
DB2Manager::GetUiDisplayForClass
ChrClassUIDisplayEntry const * GetUiDisplayForClass(Classes unitClass) const
Definition: DB2Stores.cpp:2029
DB2Manager::GetDefaultMapDifficulty
MapDifficultyEntry const * GetDefaultMapDifficulty(uint32 mapId, Difficulty *difficulty=nullptr) const
Definition: DB2Stores.cpp:2623
DB2Manager::GetAzeriteEmpoweredItem
AzeriteEmpoweredItemEntry const * GetAzeriteEmpoweredItem(uint32 itemId) const
Definition: DB2Stores.cpp:1959
DB2Manager::GetGlyphBindableSpells
std::vector< uint32 > const * GetGlyphBindableSpells(uint32 glyphPropertiesId) const
Definition: DB2Stores.cpp:2508
DB2Manager::GetJournalTier
JournalTierEntry const * GetJournalTier(uint32 index) const
Definition: DB2Stores.cpp:2584
DB2Manager::GetBroadcastTextDuration
int32 const * GetBroadcastTextDuration(int32 broadcastTextId, LocaleConstant locale=DEFAULT_LOCALE) const
Definition: DB2Stores.cpp:2024
DB2Manager::GetItemSpecOverrides
std::vector< ItemSpecOverrideEntry const * > const * GetItemSpecOverrides(uint32 itemId) const
Definition: DB2Stores.cpp:2579
DB2Manager::GetDefaultChrSpecializationForClass
ChrSpecializationEntry const * GetDefaultChrSpecializationForClass(uint32 class_) const
Definition: DB2Stores.cpp:2094
DB2Manager::GetMountCapabilities
MountTypeXCapabilitySet const * GetMountCapabilities(uint32 mountType) const
Definition: DB2Stores.cpp:2704
DB2Manager::HasItemCurrencyCost
bool HasItemCurrencyCost(uint32 itemId) const
Definition: DB2Stores.cpp:2533
DB2Manager::GetHotfixOptionalData
std::vector< HotfixOptionalData > const * GetHotfixOptionalData(uint32 tableHash, int32 recordId, LocaleConstant locale) const
Definition: DB2Stores.cpp:1872
DB2Manager::GetCurrencyContainerForCurrencyQuantity
CurrencyContainerEntry const * GetCurrencyContainerForCurrencyQuantity(uint32 currencyId, int32 quantity) const
Definition: DB2Stores.cpp:2172
DB2Manager::GetUiMapPosition
static bool GetUiMapPosition(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapSystem system, bool local, int32 *uiMapId=nullptr, DBCPosition2D *newPos=nullptr)
Definition: DB2Stores.cpp:3295
DB2Manager::GetCustomiztionChoices
std::vector< ChrCustomizationChoiceEntry const * > const * GetCustomiztionChoices(uint32 chrCustomizationOptionId) const
Definition: DB2Stores.cpp:2052
DB2Manager::GetShapeshiftFormModelData
ShapeshiftFormModelData const * GetShapeshiftFormModelData(uint8 race, uint8 gender, uint8 form) const
Definition: DB2Stores.cpp:2907
DB2Manager::GetNumTalentsAtLevel
static int32 GetNumTalentsAtLevel(uint32 level, Classes playerClass)
Definition: DB2Stores.cpp:2741
DB2Manager::GetRequiredCustomizationChoices
std::vector< std::pair< uint32, std::vector< uint32 > > > const * GetRequiredCustomizationChoices(uint32 chrCustomizationReqId) const
Definition: DB2Stores.cpp:2062
DB2Manager::InsertNewHotfix
void InsertNewHotfix(uint32 tableHash, uint32 recordId)
Definition: DB2Stores.cpp:1884
DB2Manager::GetParagonReputation
ParagonReputationEntry const * GetParagonReputation(uint32 factionId) const
Definition: DB2Stores.cpp:2763
DB2Manager::GetGlobalCurveId
uint32 GetGlobalCurveId(GlobalCurve globalCurveType) const
Definition: DB2Stores.cpp:2499
DB2Manager::IsInArea
static bool IsInArea(uint32 objectAreaId, uint32 areaId)
Definition: DB2Stores.cpp:1907
DB2Manager::GetItemModifiedAppearance
ItemModifiedAppearanceEntry const * GetItemModifiedAppearance(uint32 itemId, uint32 appearanceModId) const
Definition: DB2Stores.cpp:2552
DB2Manager::IsAzeriteItem
bool IsAzeriteItem(uint32 itemId) const
Definition: DB2Stores.cpp:1964
DB2Manager::GetItemDisplayId
uint32 GetItemDisplayId(uint32 itemId, uint32 appearanceModId) const
Definition: DB2Stores.cpp:2543
DB2Manager::GetSpellProcsPerMinuteMods
std::vector< SpellProcsPerMinuteModEntry const * > GetSpellProcsPerMinuteMods(uint32 spellprocsPerMinuteId) const
Definition: DB2Stores.cpp:2966
DB2Manager::GetAzeriteItemMilestonePower
AzeriteItemMilestonePowerEntry const * GetAzeriteItemMilestonePower(uint8 slot) const
Definition: DB2Stores.cpp:1980
DB2Manager::GetBattlegroundBracketByLevel
static PVPDifficultyEntry const * GetBattlegroundBracketByLevel(uint32 mapid, uint32 level)
Definition: DB2Stores.cpp:2768
DB2Manager::IsValidSpellFamiliyName
static bool IsValidSpellFamiliyName(SpellFamilyNames family)
Definition: DB2Stores.cpp:2961
DB2Manager::GetHeirloomByItemId
HeirloomEntry const * GetHeirloomByItemId(uint32 itemId) const
Definition: DB2Stores.cpp:2518
DB2Manager::GetNameGenEntry
std::string GetNameGenEntry(uint8 race, uint8 gender) const
Definition: DB2Stores.cpp:2714
DB2Manager::IsToyItem
bool IsToyItem(uint32 toy) const
Definition: DB2Stores.cpp:3011
DB2Manager::GetTalentsByPosition
std::vector< TalentEntry const * > const & GetTalentsByPosition(uint32 class_, uint32 tier, uint32 column) const
Definition: DB2Stores.cpp:2980
DB2Manager::LoadHotfixBlob
void LoadHotfixBlob(uint32 localeMask)
Definition: DB2Stores.cpp:1726
DB2Manager::GetTextSoundEmoteFor
EmotesTextSoundEntry const * GetTextSoundEmoteFor(uint32 emote, uint8 race, uint8 gender, uint8 class_) const
Definition: DB2Stores.cpp:2339
DB2Manager::GetArtifactPowerRank
ArtifactPowerRankEntry const * GetArtifactPowerRank(uint32 artifactPowerId, uint8 rank) const
Definition: DB2Stores.cpp:1954
DB2Manager::GetConditionalChrModel
static ConditionalChrModelEntry const * GetConditionalChrModel(int32 chrModelId)
Definition: DB2Stores.cpp:2072
DB2Manager::GetCurveValueAt
float GetCurveValueAt(uint32 curveId, float x) const
Definition: DB2Stores.cpp:2221
DB2Manager::MountXDisplayContainer
std::vector< MountXDisplayEntry const * > MountXDisplayContainer
Definition: DB2Stores.h:409
DB2Manager::GetAzeritePowers
std::vector< AzeritePowerSetMemberEntry const * > const * GetAzeritePowers(uint32 itemId) const
Definition: DB2Stores.cpp:1986
DB2Manager::GetRedirectedContentTuningId
uint32 GetRedirectedContentTuningId(uint32 contentTuningId, uint32 redirectFlag) const
Definition: DB2Stores.cpp:2099
DB2Manager::GetClassName
static char const * GetClassName(uint8 class_, LocaleConstant locale=DEFAULT_LOCALE)
Definition: DB2Stores.cpp:2035
DB2Manager::LoadHotfixOptionalData
void LoadHotfixOptionalData(uint32 localeMask)
Definition: DB2Stores.cpp:1778
DB2Manager::GetContentTuningData
Optional< ContentTuningLevels > GetContentTuningData(uint32 contentTuningId, uint32 redirectFlag, bool forItem=false) const
Definition: DB2Stores.cpp:2108
DB2Manager::GetSpecializationSpells
std::vector< SpecializationSpellsEntry const * > const * GetSpecializationSpells(uint32 specId) const
Definition: DB2Stores.cpp:2951
DB2Manager::HasContentTuningLabel
bool HasContentTuningLabel(uint32 contentTuningId, int32 label) const
Definition: DB2Stores.cpp:2155
DB2Manager::GetMount
MountEntry const * GetMount(uint32 spellId) const
Definition: DB2Stores.cpp:2694
DB2Manager::GetDefaultMapLight
static uint32 GetDefaultMapLight(uint32 mapId)
Definition: DB2Stores.cpp:2600
DB2Manager::GetQuestPackageItems
std::vector< QuestPackageItemEntry const * > const * GetQuestPackageItems(uint32 questPackageID) const
Definition: DB2Stores.cpp:2833
DB2Manager::GetAreasForGroup
std::vector< uint32 > GetAreasForGroup(uint32 areaGroupId) const
Definition: DB2Stores.cpp:1898
DB2Manager::GetHotfixBlobData
std::vector< uint8 > const * GetHotfixBlobData(uint32 tableHash, int32 recordId, LocaleConstant locale) const
Definition: DB2Stores.cpp:1865
DB2Manager::GetHotfixCount
uint32 GetHotfixCount() const
Definition: DB2Stores.cpp:1855
DB2Manager::GetPVPStatIDsForMap
std::unordered_set< uint32 > const * GetPVPStatIDsForMap(uint32 mapId) const
Definition: DB2Stores.cpp:3379
DB2Manager::GetArtifactPowers
std::vector< ArtifactPowerEntry const * > GetArtifactPowers(uint8 artifactId) const
Definition: DB2Stores.cpp:1940
DB2Manager::ValidateName
ResponseCodes ValidateName(std::wstring const &name, LocaleConstant locale) const
Definition: DB2Stores.cpp:2727
DB2Manager::GetDownscaledMapDifficultyData
MapDifficultyEntry const * GetDownscaledMapDifficultyData(uint32 mapId, Difficulty &difficulty) const
Definition: DB2Stores.cpp:2666
DB2Manager::MountTypeXCapabilitySet
std::set< MountTypeXCapabilityEntry const *, MountTypeXCapabilityEntryComparator > MountTypeXCapabilitySet
Definition: DB2Stores.h:408
DB2Manager::IsUiMapPhase
bool IsUiMapPhase(uint32 phaseId) const
Definition: DB2Stores.cpp:3369
DB2Manager::GetPowerTypeEntry
PowerTypeEntry const * GetPowerTypeEntry(Powers power) const
Definition: DB2Stores.cpp:2865
DB2Manager::LoadStores
uint32 LoadStores(std::string const &dataPath, LocaleConstant defaultLocale)
Definition: DB2Stores.cpp:614
DB2Manager::GetQuestPackageItemsFallback
std::vector< QuestPackageItemEntry const * > const * GetQuestPackageItemsFallback(uint32 questPackageID) const
Definition: DB2Stores.cpp:2842
DB2Manager::FriendshipRepReactionSet
std::set< FriendshipRepReactionEntry const *, FriendshipRepReactionEntryComparator > FriendshipRepReactionSet
Definition: DB2Stores.h:406
DB2Manager::GetCustomiztionOptions
std::vector< ChrCustomizationOptionEntry const * > const * GetCustomiztionOptions(uint8 race, uint8 gender) const
Definition: DB2Stores.cpp:2057
DB2Manager::GetCreatureFamilyPetName
static char const * GetCreatureFamilyPetName(uint32 petfamily, LocaleConstant locale)
Definition: DB2Stores.cpp:2160
DB2Manager::GetSkillLineAbilitiesBySkill
std::vector< SkillLineAbilityEntry const * > const * GetSkillLineAbilitiesBySkill(uint32 skillId) const
Definition: DB2Stores.cpp:2917
DB2Manager::LoadHotfixData
void LoadHotfixData(uint32 localeMask)
Definition: DB2Stores.cpp:1656
DB2Manager::GetPvpTalentNumSlotsAtLevel
int32 GetPvpTalentNumSlotsAtLevel(uint32 level, Classes class_) const
Definition: DB2Stores.cpp:2818
DB2Manager::GetCurveXAxisRange
std::pair< float, float > GetCurveXAxisRange(uint32 curveId) const
Definition: DB2Stores.cpp:2181
DB2Manager::GetTransmogIllusionForEnchantment
TransmogIllusionEntry const * GetTransmogIllusionForEnchantment(uint32 spellItemEnchantmentId) const
Definition: DB2Stores.cpp:3016
DB2StorageBase
Interface class for common access.
Definition: DB2Store.h:31
DB2StorageBase::GetTableHash
uint32 GetTableHash() const
Definition: DB2Store.h:40
DB2StorageBase::GetFileName
std::string const & GetFileName() const
Definition: DB2Store.h:47
DB2StorageBase::LoadStringsFromDB
void LoadStringsFromDB(LocaleConstant locale)
Definition: DB2Store.cpp:136
DB2StorageBase::GetLoadInfo
DB2LoadInfo const * GetLoadInfo() const
Definition: DB2Store.h:49
DB2StorageBase::LoadFromDB
void LoadFromDB()
Definition: DB2Store.cpp:127
DB2StorageBase::Load
void Load(std::string const &path, LocaleConstant locale)
Definition: DB2Store.cpp:88
DB2StorageBase::LoadStringsFrom
void LoadStringsFrom(std::string const &path, LocaleConstant locale)
Definition: DB2Store.cpp:110
Field
Class used to access individual fields of database query result.
Definition: Field.h:90
Field::GetUInt8
uint8 GetUInt8() const
Definition: Field.cpp:30
Field::GetString
std::string GetString() const
Definition: Field.cpp:118
Field::GetBinary
std::vector< uint8 > GetBinary() const
Definition: Field.cpp:142
Field::GetUInt32
uint32 GetUInt32() const
Definition: Field.cpp:62
Field::GetInt32
int32 GetInt32() const
Definition: Field.cpp:70
TaxiMask::value_type
uint8 value_type
Definition: DBCEnums.h:2028
TaxiMask::_data
std::vector< value_type > _data
Definition: DBCEnums.h:2042
sWorld
#define sWorld
Definition: World.h:931
CONFIG_EXPANSION
@ CONFIG_EXPANSION
Definition: World.h:308
Trinity::Containers::MapEqualRange
auto MapEqualRange(M &map, typename M::key_type const &key)
Definition: IteratorPair.h:60
Trinity::Containers::SelectRandomContainerElement
auto SelectRandomContainerElement(C const &container) -> typename std::add_const< decltype(*std::begin(container))>::type &
Definition: Containers.h:109
Trinity::Containers::MapGetValuePtr
auto MapGetValuePtr(M &map, typename M::key_type const &key)
Definition: MapUtils.h:29
Trinity::regex
TC_REGEX_NAMESPACE ::regex regex
Definition: Regex.h:28
Trinity::wregex
TC_REGEX_NAMESPACE ::wregex wregex
Definition: Regex.h:29
Trinity::StringFormat
std::string StringFormat(FormatString< Args... > fmt, Args &&... args)
Default TC string format function.
Definition: StringFormat.h:38
std
STL namespace.
AchievementCategoryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:63
AchievementLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:50
AdventureJournalLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:97
AdventureMapPoiLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:120
AnimKitLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:148
AnimationDataLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:135
AreaGroupMemberLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:160
AreaTableEntry::ParentAreaID
uint16 ParentAreaID
Definition: DB2Structure.h:131
AreaTableEntry::ContinentID
uint16 ContinentID
Definition: DB2Structure.h:130
AreaTableEntry::ContentTuningID
int32 ContentTuningID
Definition: DB2Structure.h:148
AreaTableLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:197
AreaTriggerLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:223
ArmorLocationLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:238
ArtifactAppearanceLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:283
ArtifactAppearanceSetLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:301
ArtifactCategoryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:313
ArtifactLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:258
ArtifactPowerLinkLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:342
ArtifactPowerLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:330
ArtifactPowerPickerLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:353
ArtifactPowerRankLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:368
ArtifactQuestXpLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:388
ArtifactTierLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:403
ArtifactUnlockLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:418
AuctionHouseLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:432
AzeriteEmpoweredItemLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:445
AzeriteEssenceLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:458
AzeriteEssencePowerLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:476
AzeriteItemLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:487
AzeriteItemMilestonePowerLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:501
AzeriteKnowledgeMultiplierLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:512
AzeriteLevelInfoLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:525
AzeritePowerLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:539
AzeritePowerSetMemberLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:554
AzeriteTierUnlockLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:568
AzeriteTierUnlockSetLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:579
AzeriteUnlockMappingLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:594
BankBagSlotPricesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:605
BannedAddonsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:618
BarberShopStyleLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:635
BattlePetAbilityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:652
BattlePetBreedQualityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:665
BattlePetBreedStateLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:678
BattlePetSpeciesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:699
BattlePetSpeciesStateLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:712
BattlemasterListLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:754
BroadcastTextDurationLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:793
BroadcastTextEntry::Text
LocalizedString Text
Definition: DB2Structure.h:526
BroadcastTextEntry::Text1
LocalizedString Text1
Definition: DB2Structure.h:527
BroadcastTextLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:780
CfgCategoriesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:809
CfgRegionsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:824
ChallengeModeItemBonusOverrideLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:841
CharTitlesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:855
CharacterLoadoutItemLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:881
CharacterLoadoutLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:869
ChatChannelsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:896
ChrClassUiDisplayLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:909
ChrClassesEntry::Name
LocalizedString Name
Definition: DB2Structure.h:635
ChrClassesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:957
ChrClassesXPowerTypesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:969
ChrCustomizationChoiceLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:990
ChrCustomizationDisplayInfoLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1005
ChrCustomizationElementLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1028
ChrCustomizationOptionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1050
ChrCustomizationReqChoiceLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1080
ChrCustomizationReqLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1068
ChrModelLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1110
ChrRaceXChrModelLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1124
ChrRacesEntry::Name
LocalizedString Name
Definition: DB2Structure.h:800
ChrRacesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1196
ChrSpecializationLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1219
CinematicCameraLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1236
CinematicSequencesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1255
ConditionalChrModelLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1270
ConditionalContentTuningLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1284
ContentTuningEntry::GetFlags
EnumFlag< ContentTuningFlag > GetFlags() const
Definition: DB2Structure.h:933
ContentTuningLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1306
ContentTuningXExpectedLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1320
ContentTuningXLabelLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1332
ConversationLineLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1351
CorruptionEffectsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1365
CreatureDisplayInfoExtraLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1418
CreatureDisplayInfoLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1402
CreatureFamilyEntry::Name
LocalizedString Name
Definition: DB2Structure.h:1041
CreatureFamilyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1438
CreatureModelDataLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1487
CreatureTypeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1499
CriteriaLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1520
CriteriaTreeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1537
CurrencyContainerLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1555
CurrencyTypesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1583
CurveLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1595
CurvePointLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1611
DB2FieldMeta::Type
DBCFormer Type
Definition: DB2FileLoader.h:76
DB2FileLoadInfo::Meta
DB2Meta const * Meta
Definition: DB2FileLoader.h:91
DB2FileLoadInfo::Fields
DB2FieldMeta const * Fields
Definition: DB2FileLoader.h:89
DB2Manager::HotfixOptionalData::Data
std::vector< uint8 > Data
Definition: DB2Stores.h:395
DB2Manager::HotfixPush::Records
std::vector< HotfixRecord > Records
Definition: DB2Stores.h:400
DB2MetaField::ArraySize
uint8 ArraySize
Definition: DB2Meta.h:26
DB2MetaField::Type
DBCFormer Type
Definition: DB2Meta.h:25
DB2Meta::FileFieldCount
uint32 FileFieldCount
Definition: DB2Meta.h:58
DB2Meta::Fields
DB2MetaField const * Fields
Definition: DB2Meta.h:60
DB2Meta::GetRecordSize
uint32 GetRecordSize() const
Definition: DB2Meta.cpp:32
DB2Meta::HasIndexFieldInData
bool HasIndexFieldInData() const
Definition: DB2Meta.cpp:22
DB2Meta::FieldCount
uint32 FieldCount
Definition: DB2Meta.h:57
DB2Meta::ParentIndexField
int32 ParentIndexField
Definition: DB2Meta.h:56
DestructibleModelDataLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1643
DifficultyEntry::FallbackDifficultyID
uint8 FallbackDifficultyID
Definition: DB2Structure.h:1467
DifficultyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1666
DungeonEncounterLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1685
DurabilityCostsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1724
DurabilityQualityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1735
EmotesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1754
EmotesTextLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1766
EmotesTextSoundLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1781
ExpectedStatLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1802
ExpectedStatModLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1821
ExpectedStatModReducer::ExpectedStatModReducer
ExpectedStatModReducer(int32 mythicPlusMilestoneSeason)
Definition: DB2Stores.cpp:2353
ExpectedStatModReducer::operator()
float operator()(float mod, ContentTuningXExpectedEntry const *contentTuningXExpected) const
Definition: DB2Stores.cpp:2355
FactionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1865
FactionTemplateLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1896
FriendshipRepReactionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1910
FriendshipReputationLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1926
GameobjectArtKitLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1940
GameobjectDisplayInfoLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1963
GameobjectsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:1996
GarrAbilityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2013
GarrBuildingLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2047
GarrBuildingPlotInstLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2062
GarrClassSpecLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2079
GarrFollowerLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2122
GarrFollowerXAbilityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2136
GarrMissionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2179
GarrPlotBuildingLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2209
GarrPlotInstanceLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2221
GarrPlotLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2197
GarrSiteLevelLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2241
GarrSiteLevelPlotInstLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2256
GarrTalentTreeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2278
GemPropertiesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2290
GlobalCurveLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2302
GlyphBindableSpellLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2314
GlyphPropertiesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2328
GlyphRequiredSpecLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2340
GossipNpcOptionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2365
GuildColorBackgroundLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2378
GuildColorBorderLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2391
GuildColorEmblemLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2404
GuildPerkSpellsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2415
HeirloomLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2444
HolidaysLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2510
ImportPriceArmorLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2524
ImportPriceQualityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2535
ImportPriceShieldLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2546
ImportPriceWeaponLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2557
ItemAppearanceLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2593
ItemArmorQualityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2610
ItemArmorShieldLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2628
ItemArmorTotalLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2643
ItemBagFamilyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2654
ItemBonusListGroupEntryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2689
ItemBonusListLevelDeltaLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2700
ItemBonusLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2671
ItemBonusTreeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2712
ItemBonusTreeNodeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2731
ItemChildEquipmentLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2744
ItemClassLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2758
ItemContextPickerEntryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2775
ItemCurrencyCostLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2786
ItemDamageAmmoLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2804
ItemDamageOneHandCasterLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2840
ItemDamageOneHandLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2822
ItemDamageTwoHandCasterLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2876
ItemDamageTwoHandLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2858
ItemDisenchantLootLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2893
ItemEffectLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2911
ItemExtendedCostLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2947
ItemLevelSelectorLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2960
ItemLevelSelectorQualityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2973
ItemLevelSelectorQualitySetLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2985
ItemLimitCategoryConditionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3011
ItemLimitCategoryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2998
ItemLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:2578
ItemModifiedAppearanceExtraLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3041
ItemModifiedAppearanceLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3026
ItemNameDescriptionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3053
ItemPriceBaseLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3066
ItemSearchNameLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3092
ItemSetLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3123
ItemSetSpellLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3137
ItemSparseLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3244
ItemSpecLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3260
ItemSpecOverrideLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3272
ItemXBonusTreeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3284
ItemXItemEffectLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3296
JournalEncounterLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3318
JournalEncounterSectionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3343
JournalInstanceLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3362
JournalTierLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3374
KeychainLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3416
KeystoneAffixLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3429
LanguageWordsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3441
LanguagesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3456
LfgDungeonsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3496
LightEntry::GameCoords
DBCPosition3D GameCoords
Definition: DB2Structure.h:2638
LightEntry::ContinentID
int16 ContinentID
Definition: DB2Structure.h:2641
LightLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3520
LiquidTypeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3585
LockLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3628
MailTemplateLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3639
MapChallengeModeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3694
MapDifficultyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3714
MapDifficultyXConditionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3728
MapLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3676
MawPowerLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3740
ModifierTreeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3757
MountCapabilityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3798
MountLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3779
MountTypeXCapabilityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3811
MountXDisplayLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3824
MovieLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3839
MythicPlusSeasonLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3852
NameGenLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3865
NamesProfanityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3877
NamesReservedLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3888
NamesReservedLocaleLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3900
NumTalentsAtLevelLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3913
OverrideSpellDataLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3935
ParagonReputationLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3948
PhaseLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3959
PhaseXPhaseGroupLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:3971
PlayerConditionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4140
PowerDisplayLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4155
PowerTypeEntry::NameGlobalStringTag
char const * NameGlobalStringTag
Definition: DB2Structure.h:3085
PowerTypeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4177
PrestigeLevelInfoLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4192
PvpDifficultyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4206
PvpItemLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4218
PvpSeasonLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4243
PvpStatLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4230
PvpTalentCategoryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4273
PvpTalentLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4262
PvpTalentSlotUnlockLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4287
PvpTierLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4305
QuestFactionRewardLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4325
QuestInfoLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4339
QuestLineXQuestLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4353
QuestMoneyRewardLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4373
QuestPackageItemLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4387
QuestSortLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4399
QuestV2LoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4411
QuestXpLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4431
RandPropPointsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4475
RewardPackLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4491
RewardPackXCurrencyTypeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4504
RewardPackXItemLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4517
ScenarioLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4532
ScenarioStepLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4553
SceneScriptGlobalTextLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4578
SceneScriptLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4566
SceneScriptPackageLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4590
SceneScriptTextLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4602
ServerMessagesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4613
ShapeshiftFormModelData::Displays
std::vector< ChrCustomizationDisplayInfoEntry const * > Displays
Definition: DB2Stores.h:320
ShapeshiftFormModelData::Choices
std::vector< ChrCustomizationChoiceEntry const * > const * Choices
Definition: DB2Stores.h:319
SkillLineAbilityLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4663
SkillLineLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4637
SkillLineXTraitTreeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4676
SkillRaceClassInfoLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4693
SoulbindConduitRankLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4707
SoundKitLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4733
SpecSetMemberLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4760
SpecializationSpellsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4748
SpellAuraOptionsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4779
SpellAuraRestrictionsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4803
SpellCastTimesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4815
SpellCastingRequirementsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4832
SpellCategoriesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4851
SpellCategoryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4867
SpellClassOptionsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4884
SpellCooldownsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4900
SpellDurationLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4912
SpellEffectLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4957
SpellEquippedItemsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4971
SpellFocusObjectLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4982
SpellInterruptsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:4999
SpellItemEnchantmentConditionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5080
SpellItemEnchantmentLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5040
SpellKeyboundOverrideLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5094
SpellLabelLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5106
SpellLearnSpellLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5119
SpellLevelsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5135
SpellMiscLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5175
SpellNameLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5186
SpellPowerDifficultyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5222
SpellPowerLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5210
SpellProcsPerMinuteLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5234
SpellProcsPerMinuteModLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5248
SpellRadiusLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5262
SpellRangeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5279
SpellReagentsCurrencyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5335
SpellReagentsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5322
SpellScalingLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5349
SpellShapeshiftFormLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5392
SpellShapeshiftLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5365
SpellTargetRestrictionsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5410
SpellTotemsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5425
SpellVisualEffectNameLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5480
SpellVisualKitLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5527
SpellVisualLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5455
SpellVisualMissileLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5511
SpellXSpellVisualLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5549
SummonPropertiesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5565
TactKeyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5591
TalentLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5611
TaxiNodesLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5640
TaxiPathLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5653
TaxiPathNodeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5673
TotemCategoryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5686
ToyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5700
TraitCondLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5735
TraitCostLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5748
TraitCurrencyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5762
TraitCurrencySourceLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5780
TraitDefinitionEffectPointsLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5811
TraitDefinitionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5797
TraitEdgeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5825
TraitNodeEntryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5853
TraitNodeEntryXTraitCondLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5865
TraitNodeEntryXTraitCostLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5877
TraitNodeGroupLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5889
TraitNodeGroupXTraitCondLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5901
TraitNodeGroupXTraitCostLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5913
TraitNodeGroupXTraitNodeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5926
TraitNodeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5840
TraitNodeXTraitCondLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5938
TraitNodeXTraitCostLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5950
TraitNodeXTraitNodeEntryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5963
TraitTreeLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5980
TraitTreeLoadoutEntryLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6007
TraitTreeLoadoutLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5992
TraitTreeXTraitCostLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6019
TraitTreeXTraitCurrencyLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6032
TransmogHolidayLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:5711
TransmogIllusionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6046
TransmogSetGroupLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6079
TransmogSetItemLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6092
TransmogSetLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6068
TransportAnimationLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6108
TransportRotationLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6124
UiMapAssignmentEntry::UiMax
DBCPosition2D UiMax
Definition: DB2Structure.h:4384
UiMapAssignmentEntry::Region
std::array< DBCPosition3D, 2 > Region
Definition: DB2Structure.h:4385
UiMapAssignmentEntry::UiMin
DBCPosition2D UiMin
Definition: DB2Structure.h:4383
UiMapAssignmentLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6173
UiMapAssignmentStatus::Inside
struct UiMapAssignmentStatus::@197 Inside
UiMapAssignmentStatus::UiMapAssignment
UiMapAssignmentEntry const * UiMapAssignment
Definition: DB2Stores.cpp:3033
UiMapAssignmentStatus::IsInside
bool IsInside() const
Definition: DB2Stores.cpp:3053
UiMapAssignmentStatus::DistanceToRegionCenterSquared
float DistanceToRegionCenterSquared
Definition: DB2Stores.cpp:3037
UiMapAssignmentStatus::Outside
struct UiMapAssignmentStatus::@198 Outside
UiMapEntry::ParentUiMapID
int32 ParentUiMapID
Definition: DB2Structure.h:4365
UiMapLinkLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6194
UiMapLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6147
UiMapXMapArtLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6207
UiSplashScreenLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6232
UnitConditionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6267
UnitPowerBarLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6303
VehicleLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6340
VehicleSeatLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6415
VignetteLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6435
WmoAreaTableLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6459
WorldEffectLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6475
WorldMapOverlayLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6500
WorldStateExpressionLoadInfo::Instance
static constexpr DB2LoadInfo Instance
Definition: DB2LoadInfo.h:6511