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