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