Merge branch 'master' into Playerbot

src/server/game/AI/SmartScripts/SmartScript.cpp

@@ -2696,7 +2696,7 @@ void SmartScript::ProcessAction(SmartScriptHolder& e, Unit* unit, uint32 var0, u
         }
         case SMART_ACTION_PLAYER_TALK:
         {
-            char const* text = sObjectMgr->GetAcoreString(e.action.playerTalk.textId, DEFAULT_LOCALE);
+            std::string text = sObjectMgr->GetAcoreString(e.action.playerTalk.textId, DEFAULT_LOCALE);
 
             if (!targets.empty())
                 for (WorldObject* target : targets)
@@ -3282,6 +3282,16 @@ void SmartScript::ProcessAction(SmartScriptHolder& e, Unit* unit, uint32 var0, u
             sWorldState->HandleExternalEvent(static_cast<WorldStateEvent>(e.action.worldStateScript.eventId), e.action.worldStateScript.param);
             break;
         }
+        case SMART_ACTION_DISABLE_REWARD:
+        {
+            for (WorldObject* target : targets)
+                if (IsCreature(target))
+                {
+                    target->ToCreature()->SetReputationRewardDisabled(static_cast<bool>(e.action.reward.reputation));
+                    target->ToCreature()->SetLootRewardDisabled(static_cast<bool>(e.action.reward.loot));
+                }
+            break;
+        }
         default:
             LOG_ERROR("sql.sql", "SmartScript::ProcessAction: Entry {} SourceType {}, Event {}, Unhandled Action type {}", e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType());
             break;

src/server/game/AI/SmartScripts/SmartScriptMgr.cpp

@@ -860,6 +860,7 @@ bool SmartAIMgr::CheckUnusedActionParams(SmartScriptHolder const& e)
             case SMART_ACTION_MOVEMENT_PAUSE: return sizeof(SmartAction::move);
             case SMART_ACTION_MOVEMENT_RESUME: return sizeof(SmartAction::move);
             case SMART_ACTION_WORLD_SCRIPT: return sizeof(SmartAction::worldStateScript);
+            case SMART_ACTION_DISABLE_REWARD: return sizeof(SmartAction::reward);
             default:
                 LOG_WARN("sql.sql", "SmartAIMgr: entryorguid {} source_type {} id {} action_type {} is using an action with no unused params specified in SmartAIMgr::CheckUnusedActionParams(), please report this.",
                             e.entryOrGuid, e.GetScriptType(), e.event_id, e.GetActionType());
@@ -1894,6 +1895,9 @@ bool SmartAIMgr::IsEventValid(SmartScriptHolder& e)
             return IsSAIBoolValid(e, e.action.setHealthRegen.regenHealth);
         case SMART_ACTION_CALL_TIMED_ACTIONLIST:
             return IsSAIBoolValid(e, e.action.timedActionList.allowOverride);
+        case SMART_ACTION_DISABLE_REWARD:
+            return IsSAIBoolValid(e, e.action.reward.reputation) &&
+                   IsSAIBoolValid(e, e.action.reward.loot);
         case SMART_ACTION_FLEE_FOR_ASSIST:
         case SMART_ACTION_MOVE_TO_POS:
         case SMART_ACTION_EVADE:

src/server/game/AI/SmartScripts/SmartScriptMgr.h

@@ -738,8 +738,9 @@ enum SMART_ACTION
     SMART_ACTION_MOVEMENT_PAUSE                     = 235,    // timer
     SMART_ACTION_MOVEMENT_RESUME                    = 236,    // timerOverride
     SMART_ACTION_WORLD_SCRIPT                       = 237,    // eventId, param
+    SMART_ACTION_DISABLE_REWARD                     = 238,    // reputation 0/1, loot 0/1
 
-    SMART_ACTION_AC_END                             = 238,    // placeholder
+    SMART_ACTION_AC_END                             = 239,    // placeholder
 };
 
 enum class SmartActionSummonCreatureFlags
@@ -1501,6 +1502,12 @@ struct SmartAction
             uint32 param5;
             uint32 param6;
         } raw;
+
+        struct
+        {
+            SAIBool reputation;
+            SAIBool loot;
+        } reward;
     };
 };
 

src/server/game/Achievements/AchievementMgr.cpp

@@ -2438,7 +2438,7 @@ bool AchievementMgr::HasAchieved(uint32 achievementId) const
 
 bool AchievementMgr::CanUpdateCriteria(AchievementCriteriaEntry const* criteria, AchievementEntry const* achievement)
 {
-    if (DisableMgr::IsDisabledFor(DISABLE_TYPE_ACHIEVEMENT_CRITERIA, criteria->ID, nullptr))
+    if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_ACHIEVEMENT_CRITERIA, criteria->ID, nullptr))
         return false;
 
     if (achievement->mapID != -1 && GetPlayer()->GetMapId() != uint32(achievement->mapID))
@@ -2917,7 +2917,7 @@ void AchievementGlobalMgr::LoadAchievementCriteriaData()
                 continue;
         }
 
-        if (!GetCriteriaDataSet(criteria) && !DisableMgr::IsDisabledFor(DISABLE_TYPE_ACHIEVEMENT_CRITERIA, entryId, nullptr))
+        if (!GetCriteriaDataSet(criteria) && !sDisableMgr->IsDisabledFor(DISABLE_TYPE_ACHIEVEMENT_CRITERIA, entryId, nullptr))
             LOG_ERROR("sql.sql", "Table `achievement_criteria_data` does not have expected data for criteria (Entry: {} Type: {}) for achievement {}.", criteria->ID, criteria->requiredType, criteria->referredAchievement);
     }
 

src/server/game/Battlegrounds/Battleground.cpp

@@ -58,7 +58,8 @@ namespace Acore
 
         void operator()(WorldPacket& data, LocaleConstant loc_idx)
         {
-            char const* text = sObjectMgr->GetAcoreString(_textId, loc_idx);
+            std::string strtext = sObjectMgr->GetAcoreString(_textId, loc_idx);
+            char const* text = strtext.c_str();
             if (_args)
             {
                 // we need copy va_list before use or original va_list will corrupted
@@ -95,9 +96,12 @@ namespace Acore
 
         void operator()(WorldPacket& data, LocaleConstant loc_idx)
         {
-            char const* text = sObjectMgr->GetAcoreString(_textId, loc_idx);
-            char const* arg1str = _arg1 ? sObjectMgr->GetAcoreString(_arg1, loc_idx) : "";
-            char const* arg2str = _arg2 ? sObjectMgr->GetAcoreString(_arg2, loc_idx) : "";
+            std::string strtext = sObjectMgr->GetAcoreString(_textId, loc_idx);
+            char const* text = strtext.c_str();
+            std::string stragr1str = sObjectMgr->GetAcoreString(_arg1, loc_idx);
+            char const* arg1str = _arg1 ? stragr1str.c_str() : "";
+            std::string strarg2str = sObjectMgr->GetAcoreString(_arg2, loc_idx);
+            char const* arg2str = _arg2 ? strarg2str.c_str() : "";
 
             char str[2048];
             snprintf(str, 2048, text, arg1str, arg2str);
@@ -1659,13 +1663,6 @@ void Battleground::EndNow()
     SetEndTime(0);
 }
 
-// To be removed
-char const* Battleground::GetAcoreString(int32 entry)
-{
-    // FIXME: now we have different DBC locales and need localized message for each target client
-    return sObjectMgr->GetAcoreStringForDBCLocale(entry);
-}
-
 void Battleground::HandleTriggerBuff(GameObject* gameObject)
 {
     // Xinef: crash fix?

src/server/game/Battlegrounds/Battleground.h

@@ -559,8 +559,6 @@ public:
 
     void DoorOpen(uint32 type);
     void DoorClose(uint32 type);
-    //to be removed
-    const char* GetAcoreString(int32 entry);
 
     virtual bool HandlePlayerUnderMap(Player* /*player*/) { return false; }
 

src/server/game/Battlegrounds/BattlegroundMgr.cpp

@@ -467,7 +467,7 @@ void BattlegroundMgr::LoadBattlegroundTemplates()
 
         BattlegroundTypeId bgTypeId = static_cast<BattlegroundTypeId>(fields[0].Get<uint32>());
 
-        if (DisableMgr::IsDisabledFor(DISABLE_TYPE_BATTLEGROUND, bgTypeId, nullptr))
+        if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_BATTLEGROUND, bgTypeId, nullptr))
             continue;
 
         // can be overwrite by values from DB

src/server/game/Chat/Chat.cpp

@@ -37,7 +37,7 @@ Player* ChatHandler::GetPlayer() const
     return m_session ? m_session->GetPlayer() : nullptr;
 }
 
-char const* ChatHandler::GetAcoreString(uint32 entry) const
+std::string ChatHandler::GetAcoreString(uint32 entry) const
 {
     return m_session->GetAcoreString(entry);
 }
@@ -953,7 +953,7 @@ std::string ChatHandler::GetNameLink(Player* chr) const
     return playerLink(chr->GetName());
 }
 
-char const* CliHandler::GetAcoreString(uint32 entry) const
+std::string CliHandler::GetAcoreString(uint32 entry) const
 {
     return sObjectMgr->GetAcoreStringForDBCLocale(entry);
 }

src/server/game/Chat/Chat.h

@@ -148,7 +148,7 @@ public:
     }
 
     // function with different implementation for chat/console
-    virtual char const* GetAcoreString(uint32 entry) const;
+    virtual std::string GetAcoreString(uint32 entry) const;
     virtual void SendSysMessage(std::string_view str, bool escapeCharacters = false);
 
     void SendSysMessage(uint32 entry);
@@ -276,7 +276,7 @@ public:
     explicit CliHandler(void* callbackArg, Print* zprint) : m_callbackArg(callbackArg), m_print(zprint) { }
 
     // overwrite functions
-    char const* GetAcoreString(uint32 entry) const override;
+    std::string GetAcoreString(uint32 entry) const override;
     void SendSysMessage(std::string_view, bool escapeCharacters) override;
     bool ParseCommands(std::string_view str) override;
     std::string GetNameLink() const override;

src/server/game/Chat/ChatCommands/ChatCommandHelpers.cpp

@@ -24,7 +24,7 @@ void Acore::Impl::ChatCommands::SendErrorMessageToHandler(ChatHandler* handler,
     handler->SetSentErrorMessage(true);
 }
 
-char const* Acore::Impl::ChatCommands::GetAcoreString(ChatHandler const* handler, AcoreStrings which)
+std::string Acore::Impl::ChatCommands::GetAcoreString(ChatHandler const* handler, AcoreStrings which)
 {
     return handler->GetAcoreString(which);
 }

src/server/game/Chat/ChatCommands/ChatCommandHelpers.h

@@ -120,7 +120,7 @@ namespace Acore::Impl::ChatCommands
     };
 
     AC_GAME_API void SendErrorMessageToHandler(ChatHandler* handler, std::string_view str);
-    AC_GAME_API char const* GetAcoreString(ChatHandler const* handler, AcoreStrings which);
+    AC_GAME_API std::string GetAcoreString(ChatHandler const* handler, AcoreStrings which);
     template <typename... Ts>
     std::string FormatAcoreString(ChatHandler const* handler, AcoreStrings which, Ts&&... args)
     {

src/server/game/Conditions/DisableMgr.cpp

@@ -28,393 +28,418 @@
 #include "VMapMgr2.h"
 #include "World.h"
 
-namespace DisableMgr
+std::map<DisableType, std::map<uint32, DisableData>> DisableMgr::m_DisableMap;
+
+DisableMgr::DisableMgr() {}
+DisableMgr::~DisableMgr() {}
+
+DisableMgr* DisableMgr::instance()
 {
-    namespace
+    static DisableMgr instance;
+    return &instance;
+}
+
+void DisableMgr::LoadDisables()
+{
+    uint32 oldMSTime = getMSTime();
+
+    // reload case
+    for (DisableMap::iterator itr = m_DisableMap.begin(); itr != m_DisableMap.end(); ++itr)
+        itr->second.clear();
+
+    m_DisableMap.clear();
+
+    QueryResult result = WorldDatabase.Query("SELECT sourceType, entry, flags, params_0, params_1 FROM disables");
+
+    uint32 total_count = 0;
+
+    if (!result)
     {
-        struct DisableData
-        {
-            uint8 flags;
-            std::set<uint32> params[2];                             // params0, params1
-        };
-
-        // single disables here with optional data
-        typedef std::map<uint32, DisableData> DisableTypeMap;
-        // global disable map by source
-        typedef std::map<DisableType, DisableTypeMap> DisableMap;
-
-        DisableMap m_DisableMap;
-
-        uint8 MAX_DISABLE_TYPES = 11;
-    }
-
-    void LoadDisables()
-    {
-        uint32 oldMSTime = getMSTime();
-
-        // reload case
-        for (DisableMap::iterator itr = m_DisableMap.begin(); itr != m_DisableMap.end(); ++itr)
-            itr->second.clear();
-
-        m_DisableMap.clear();
-
-        QueryResult result = WorldDatabase.Query("SELECT sourceType, entry, flags, params_0, params_1 FROM disables");
-
-        uint32 total_count = 0;
-
-        if (!result)
-        {
-            LOG_WARN("server.loading", ">> Loaded 0 disables. DB table `disables` is empty!");
-            LOG_INFO("server.loading", " ");
-            return;
-        }
-
-        Field* fields;
-        do
-        {
-            fields = result->Fetch();
-            DisableType type = DisableType(fields[0].Get<uint32>());
-            if (type >= MAX_DISABLE_TYPES)
-            {
-                LOG_ERROR("sql.sql", "Invalid type {} specified in `disables` table, skipped.", type);
-                continue;
-            }
-
-            uint32 entry = fields[1].Get<uint32>();
-            uint8 flags = fields[2].Get<uint8>();
-            std::string params_0 = fields[3].Get<std::string>();
-            std::string params_1 = fields[4].Get<std::string>();
-
-            DisableData data;
-            data.flags = flags;
-
-            switch (type)
-            {
-                case DISABLE_TYPE_GO_LOS:
-                    if (!sObjectMgr->GetGameObjectTemplate(entry))
-                    {
-                        LOG_ERROR("sql.sql", "Gameobject entry {} from `disables` doesn't exist in dbc, skipped.", entry);
-                        continue;
-                    }
-                    if (flags)
-                        LOG_ERROR("sql.sql", "Disable flags specified for gameobject {}, useless data.", entry);
-                    break;
-                case DISABLE_TYPE_SPELL:
-                    if (!(sSpellMgr->GetSpellInfo(entry) || flags & SPELL_DISABLE_DEPRECATED_SPELL))
-                    {
-                        LOG_ERROR("sql.sql", "Spell entry {} from `disables` doesn't exist in dbc, skipped.", entry);
-                        continue;
-                    }
-
-                    if (!flags || flags > MAX_SPELL_DISABLE_TYPE)
-                    {
-                        LOG_ERROR("sql.sql", "Disable flags for spell {} are invalid, skipped.", entry);
-                        continue;
-                    }
-
-                    if (flags & SPELL_DISABLE_MAP)
-                    {
-                        for (std::string_view mapStr : Acore::Tokenize(params_0, ',', true))
-                        {
-                            if (Optional<uint32> mapId = Acore::StringTo<uint32>(mapStr))
-                                data.params[0].insert(*mapId);
-                            else
-                                LOG_ERROR("sql.sql", "Disable map '{}' for spell {} is invalid, skipped.", mapStr, entry);
-                        }
-                    }
-
-                    if (flags & SPELL_DISABLE_AREA)
-                    {
-                        for (std::string_view areaStr : Acore::Tokenize(params_1, ',', true))
-                        {
-                            if (Optional<uint32> areaId = Acore::StringTo<uint32>(areaStr))
-                                data.params[1].insert(*areaId);
-                            else
-                                LOG_ERROR("sql.sql", "Disable area '{}' for spell {} is invalid, skipped.", areaStr, entry);
-                        }
-                    }
-
-                    // xinef: if spell has disabled los, add flag
-                    if (flags & SPELL_DISABLE_LOS)
-                    {
-                        SpellInfo* spellInfo = const_cast<SpellInfo*>(sSpellMgr->GetSpellInfo(entry));
-                        spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
-                    }
-
-                    break;
-                // checked later
-                case DISABLE_TYPE_QUEST:
-                    break;
-                case DISABLE_TYPE_MAP:
-                case DISABLE_TYPE_LFG_MAP:
-                    {
-                        MapEntry const* mapEntry = sMapStore.LookupEntry(entry);
-                        if (!mapEntry)
-                        {
-                            LOG_ERROR("sql.sql", "Map entry {} from `disables` doesn't exist in dbc, skipped.", entry);
-                            continue;
-                        }
-                        bool isFlagInvalid = false;
-                        switch (mapEntry->map_type)
-                        {
-                            case MAP_COMMON:
-                                if (flags)
-                                    isFlagInvalid = true;
-                                break;
-                            case MAP_INSTANCE:
-                            case MAP_RAID:
-                                if (flags & DUNGEON_STATUSFLAG_HEROIC && !GetMapDifficultyData(entry, DUNGEON_DIFFICULTY_HEROIC))
-                                    isFlagInvalid = true;
-                                else if (flags & RAID_STATUSFLAG_10MAN_HEROIC && !GetMapDifficultyData(entry, RAID_DIFFICULTY_10MAN_HEROIC))
-                                    isFlagInvalid = true;
-                                else if (flags & RAID_STATUSFLAG_25MAN_HEROIC && !GetMapDifficultyData(entry, RAID_DIFFICULTY_25MAN_HEROIC))
-                                    isFlagInvalid = true;
-                                break;
-                            case MAP_BATTLEGROUND:
-                            case MAP_ARENA:
-                                LOG_ERROR("sql.sql", "Battleground map {} specified to be disabled in map case, skipped.", entry);
-                                continue;
-                        }
-                        if (isFlagInvalid)
-                        {
-                            LOG_ERROR("sql.sql", "Disable flags for map {} are invalid, skipped.", entry);
-                            continue;
-                        }
-                        break;
-                    }
-                case DISABLE_TYPE_BATTLEGROUND:
-                    if (!sBattlemasterListStore.LookupEntry(entry))
-                    {
-                        LOG_ERROR("sql.sql", "Battleground entry {} from `disables` doesn't exist in dbc, skipped.", entry);
-                        continue;
-                    }
-                    if (flags)
-                        LOG_ERROR("sql.sql", "Disable flags specified for battleground {}, useless data.", entry);
-                    break;
-                case DISABLE_TYPE_OUTDOORPVP:
-                    if (entry > MAX_OUTDOORPVP_TYPES)
-                    {
-                        LOG_ERROR("sql.sql", "OutdoorPvPTypes value {} from `disables` is invalid, skipped.", entry);
-                        continue;
-                    }
-                    if (flags)
-                        LOG_ERROR("sql.sql", "Disable flags specified for outdoor PvP {}, useless data.", entry);
-                    break;
-                case DISABLE_TYPE_ACHIEVEMENT_CRITERIA:
-                    if (!sAchievementCriteriaStore.LookupEntry(entry))
-                    {
-                        LOG_ERROR("sql.sql", "Achievement Criteria entry {} from `disables` doesn't exist in dbc, skipped.", entry);
-                        continue;
-                    }
-                    if (flags)
-                        LOG_ERROR("sql.sql", "Disable flags specified for Achievement Criteria {}, useless data.", entry);
-                    break;
-                case DISABLE_TYPE_VMAP:
-                    {
-                        MapEntry const* mapEntry = sMapStore.LookupEntry(entry);
-                        if (!mapEntry)
-                        {
-                            LOG_ERROR("sql.sql", "Map entry {} from `disables` doesn't exist in dbc, skipped.", entry);
-                            continue;
-                        }
-                        switch (mapEntry->map_type)
-                        {
-                            case MAP_COMMON:
-                                if (flags & VMAP::VMAP_DISABLE_AREAFLAG)
-                                    LOG_INFO("disable", "Areaflag disabled for world map {}.", entry);
-                                if (flags & VMAP::VMAP_DISABLE_LIQUIDSTATUS)
-                                    LOG_INFO("disable", "Liquid status disabled for world map {}.", entry);
-                                break;
-                            case MAP_INSTANCE:
-                            case MAP_RAID:
-                                if (flags & VMAP::VMAP_DISABLE_HEIGHT)
-                                    LOG_INFO("disable", "Height disabled for instance map {}.", entry);
-                                if (flags & VMAP::VMAP_DISABLE_LOS)
-                                    LOG_INFO("disable", "LoS disabled for instance map {}.", entry);
-                                break;
-                            case MAP_BATTLEGROUND:
-                                if (flags & VMAP::VMAP_DISABLE_HEIGHT)
-                                    LOG_INFO("disable", "Height disabled for battleground map {}.", entry);
-                                if (flags & VMAP::VMAP_DISABLE_LOS)
-                                    LOG_INFO("disable", "LoS disabled for battleground map {}.", entry);
-                                break;
-                            case MAP_ARENA:
-                                if (flags & VMAP::VMAP_DISABLE_HEIGHT)
-                                    LOG_INFO("disable", "Height disabled for arena map {}.", entry);
-                                if (flags & VMAP::VMAP_DISABLE_LOS)
-                                    LOG_INFO("disable", "LoS disabled for arena map {}.", entry);
-                                break;
-                            default:
-                                break;
-                        }
-                        break;
-                    }
-                    case DISABLE_TYPE_GAME_EVENT:
-                    {
-                        GameEventMgr::ActiveEvents const& activeEvents = sGameEventMgr->GetActiveEventList();
-                        if (activeEvents.find(entry) != activeEvents.end())
-                        {
-                            sGameEventMgr->StopEvent(entry);
-                            LOG_INFO("disable", "Event entry {} was stopped because it has been disabled.", entry);
-                        }
-                        break;
-                    }
-                    case DISABLE_TYPE_LOOT:
-                        break;
-                default:
-                    break;
-            }
-
-            m_DisableMap[type].insert(DisableTypeMap::value_type(entry, data));
-            ++total_count;
-        } while (result->NextRow());
-
-        LOG_INFO("server.loading", ">> Loaded {} Disables in {} ms", total_count, GetMSTimeDiffToNow(oldMSTime));
+        LOG_WARN("server.loading", ">> Loaded 0 disables. DB table `disables` is empty!");
         LOG_INFO("server.loading", " ");
+        return;
     }
 
-    void CheckQuestDisables()
+    Field* fields;
+    do
     {
-        uint32 oldMSTime = getMSTime();
-
-        uint32 count = m_DisableMap[DISABLE_TYPE_QUEST].size();
-        if (!count)
+        fields = result->Fetch();
+        DisableType type = DisableType(fields[0].Get<uint32>());
+        if (type >= MAX_DISABLE_TYPES)
         {
-            LOG_INFO("server.loading", ">> Checked 0 quest disables.");
-            LOG_INFO("server.loading", " ");
-            return;
+            LOG_ERROR("sql.sql", "Invalid type {} specified in `disables` table, skipped.", type);
+            continue;
         }
 
-        // check only quests, rest already done at startup
-        for (DisableTypeMap::iterator itr = m_DisableMap[DISABLE_TYPE_QUEST].begin(); itr != m_DisableMap[DISABLE_TYPE_QUEST].end();)
+        uint32 entry = fields[1].Get<uint32>();
+        uint8 flags = fields[2].Get<uint8>();
+        std::string params_0 = fields[3].Get<std::string>();
+        std::string params_1 = fields[4].Get<std::string>();
+
+        DisableData data;
+        data.flags = flags;
+
+        if (!HandleDisableType(type, entry, flags, params_0, params_1, data))
+            continue;
+
+        m_DisableMap[type].insert(DisableTypeMap::value_type(entry, data));
+        ++total_count;
+    } while (result->NextRow());
+
+    LOG_INFO("server.loading", ">> Loaded {} Disables in {} ms", total_count, GetMSTimeDiffToNow(oldMSTime));
+    LOG_INFO("server.loading", " ");
+}
+
+/**
+* @brief Allow to add disables without adding it to the database. Useful for modules.
+*
+* @param type Disable type
+* @param entry Entry of Spell/Quest/Map/BG/Achievement/Map/GameEvent/Item
+* @param flags Flag depending on Type
+* @param param0 MapId if DISABLE_TYPE_SPELL used, 0 for all maps.
+* @param param1 AreaId if DISABLE_TYPE_SPELL used, 0 for all areas.
+*/
+void DisableMgr::AddDisable(DisableType type, uint32 entry, uint8 flags, std::string param0, std::string param1)
+{
+    if (type >= MAX_DISABLE_TYPES)
+    {
+        LOG_ERROR("disables", "AddDisable: Invalid type {} specified for entry {}, skipped.", type);
+        return;
+    }
+
+    DisableData data;
+    data.flags = flags;
+
+    if (!HandleDisableType(type, entry, flags, param0, param1, data))
+        return;
+
+    m_DisableMap[type].insert(DisableTypeMap::value_type(entry, data));
+}
+
+bool DisableMgr::HandleDisableType(DisableType type, uint32 entry, uint8 flags, std::string const& params_0, std::string const& params_1, DisableData& data)
+{
+    switch (type)
+    {
+    case DISABLE_TYPE_GO_LOS:
+        if (!sObjectMgr->GetGameObjectTemplate(entry))
         {
-            const uint32 entry = itr->first;
-            if (!sObjectMgr->GetQuestTemplate(entry))
+            LOG_ERROR("sql.sql", "Gameobject entry {} from `disables` doesn't exist in dbc, skipped.", entry);
+            return false;
+        }
+        if (flags)
+            LOG_ERROR("sql.sql", "Disable flags specified for gameobject {}, useless data.", entry);
+        break;
+    case DISABLE_TYPE_SPELL:
+        if (!(sSpellMgr->GetSpellInfo(entry) || flags & SPELL_DISABLE_DEPRECATED_SPELL))
+        {
+            LOG_ERROR("sql.sql", "Spell entry {} from `disables` doesn't exist in dbc, skipped.", entry);
+            return false;
+        }
+
+        if (!flags || flags > MAX_SPELL_DISABLE_TYPE)
+        {
+            LOG_ERROR("sql.sql", "Disable flags for spell {} are invalid, skipped.", entry);
+            return false;
+        }
+
+        if (flags & SPELL_DISABLE_MAP)
+        {
+            for (std::string_view mapStr : Acore::Tokenize(params_0, ',', true))
             {
-                LOG_ERROR("sql.sql", "Quest entry {} from `disables` doesn't exist, skipped.", entry);
-                m_DisableMap[DISABLE_TYPE_QUEST].erase(itr++);
-                continue;
+                if (Optional<uint32> mapId = Acore::StringTo<uint32>(mapStr))
+                    data.params[0].insert(*mapId);
+                else
+                    LOG_ERROR("sql.sql", "Disable map '{}' for spell {} is invalid, skipped.", mapStr, entry);
             }
-            if (itr->second.flags)
-                LOG_ERROR("sql.sql", "Disable flags specified for quest {}, useless data.", entry);
-            ++itr;
         }
 
-        LOG_INFO("server.loading", ">> Checked {} Quest Disables in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
+        if (flags & SPELL_DISABLE_AREA)
+        {
+            for (std::string_view areaStr : Acore::Tokenize(params_1, ',', true))
+            {
+                if (Optional<uint32> areaId = Acore::StringTo<uint32>(areaStr))
+                    data.params[1].insert(*areaId);
+                else
+                    LOG_ERROR("sql.sql", "Disable area '{}' for spell {} is invalid, skipped.", areaStr, entry);
+            }
+        }
+
+        // xinef: if spell has disabled los, add flag
+        if (flags & SPELL_DISABLE_LOS)
+        {
+            SpellInfo* spellInfo = const_cast<SpellInfo*>(sSpellMgr->GetSpellInfo(entry));
+            spellInfo->AttributesEx2 |= SPELL_ATTR2_IGNORE_LINE_OF_SIGHT;
+        }
+
+        break;
+        // checked later
+    case DISABLE_TYPE_QUEST:
+        break;
+    case DISABLE_TYPE_MAP:
+    case DISABLE_TYPE_LFG_MAP:
+    {
+        MapEntry const* mapEntry = sMapStore.LookupEntry(entry);
+        if (!mapEntry)
+        {
+            LOG_ERROR("sql.sql", "Map entry {} from `disables` doesn't exist in dbc, skipped.", entry);
+            return false;
+        }
+        bool isFlagInvalid = false;
+        switch (mapEntry->map_type)
+        {
+        case MAP_COMMON:
+            if (flags)
+                isFlagInvalid = true;
+            break;
+        case MAP_INSTANCE:
+        case MAP_RAID:
+            if (flags & DUNGEON_STATUSFLAG_HEROIC && !GetMapDifficultyData(entry, DUNGEON_DIFFICULTY_HEROIC))
+                isFlagInvalid = true;
+            else if (flags & RAID_STATUSFLAG_10MAN_HEROIC && !GetMapDifficultyData(entry, RAID_DIFFICULTY_10MAN_HEROIC))
+                isFlagInvalid = true;
+            else if (flags & RAID_STATUSFLAG_25MAN_HEROIC && !GetMapDifficultyData(entry, RAID_DIFFICULTY_25MAN_HEROIC))
+                isFlagInvalid = true;
+            break;
+        case MAP_BATTLEGROUND:
+        case MAP_ARENA:
+            LOG_ERROR("sql.sql", "Battleground map {} specified to be disabled in map case, skipped.", entry);
+            return false;
+        }
+        if (isFlagInvalid)
+        {
+            LOG_ERROR("sql.sql", "Disable flags for map {} are invalid, skipped.", entry);
+            return false;
+        }
+        break;
+    }
+    case DISABLE_TYPE_BATTLEGROUND:
+        if (!sBattlemasterListStore.LookupEntry(entry))
+        {
+            LOG_ERROR("sql.sql", "Battleground entry {} from `disables` doesn't exist in dbc, skipped.", entry);
+            return false;
+        }
+        if (flags)
+            LOG_ERROR("sql.sql", "Disable flags specified for battleground {}, useless data.", entry);
+        break;
+    case DISABLE_TYPE_OUTDOORPVP:
+        if (entry > MAX_OUTDOORPVP_TYPES)
+        {
+            LOG_ERROR("sql.sql", "OutdoorPvPTypes value {} from `disables` is invalid, skipped.", entry);
+            return false;
+        }
+        if (flags)
+            LOG_ERROR("sql.sql", "Disable flags specified for outdoor PvP {}, useless data.", entry);
+        break;
+    case DISABLE_TYPE_ACHIEVEMENT_CRITERIA:
+        if (!sAchievementCriteriaStore.LookupEntry(entry))
+        {
+            LOG_ERROR("sql.sql", "Achievement Criteria entry {} from `disables` doesn't exist in dbc, skipped.", entry);
+            return false;
+        }
+        if (flags)
+            LOG_ERROR("sql.sql", "Disable flags specified for Achievement Criteria {}, useless data.", entry);
+        break;
+    case DISABLE_TYPE_VMAP:
+    {
+        MapEntry const* mapEntry = sMapStore.LookupEntry(entry);
+        if (!mapEntry)
+        {
+            LOG_ERROR("sql.sql", "Map entry {} from `disables` doesn't exist in dbc, skipped.", entry);
+            return false;
+        }
+        switch (mapEntry->map_type)
+        {
+        case MAP_COMMON:
+            if (flags & VMAP::VMAP_DISABLE_AREAFLAG)
+                LOG_INFO("disable", "Areaflag disabled for world map {}.", entry);
+            if (flags & VMAP::VMAP_DISABLE_LIQUIDSTATUS)
+                LOG_INFO("disable", "Liquid status disabled for world map {}.", entry);
+            break;
+        case MAP_INSTANCE:
+        case MAP_RAID:
+            if (flags & VMAP::VMAP_DISABLE_HEIGHT)
+                LOG_INFO("disable", "Height disabled for instance map {}.", entry);
+            if (flags & VMAP::VMAP_DISABLE_LOS)
+                LOG_INFO("disable", "LoS disabled for instance map {}.", entry);
+            break;
+        case MAP_BATTLEGROUND:
+            if (flags & VMAP::VMAP_DISABLE_HEIGHT)
+                LOG_INFO("disable", "Height disabled for battleground map {}.", entry);
+            if (flags & VMAP::VMAP_DISABLE_LOS)
+                LOG_INFO("disable", "LoS disabled for battleground map {}.", entry);
+            break;
+        case MAP_ARENA:
+            if (flags & VMAP::VMAP_DISABLE_HEIGHT)
+                LOG_INFO("disable", "Height disabled for arena map {}.", entry);
+            if (flags & VMAP::VMAP_DISABLE_LOS)
+                LOG_INFO("disable", "LoS disabled for arena map {}.", entry);
+            break;
+        default:
+            break;
+        }
+        break;
+    }
+    case DISABLE_TYPE_GAME_EVENT:
+    {
+        GameEventMgr::ActiveEvents const& activeEvents = sGameEventMgr->GetActiveEventList();
+        if (activeEvents.find(entry) != activeEvents.end())
+        {
+            sGameEventMgr->StopEvent(entry);
+            LOG_INFO("disable", "Event entry {} was stopped because it has been disabled.", entry);
+        }
+        break;
+    }
+    case DISABLE_TYPE_LOOT:
+        break;
+    case MAX_DISABLE_TYPES:
+    {
+        LOG_ERROR("disable", "SourceType out of range for entry {}, skipped", entry);
+        return false;
+    }
+    default:
+        return false;
+    }
+    return true;
+}
+
+void DisableMgr::CheckQuestDisables()
+{
+    uint32 oldMSTime = getMSTime();
+
+    uint32 count = m_DisableMap[DISABLE_TYPE_QUEST].size();
+    if (!count)
+    {
+        LOG_INFO("server.loading", ">> Checked 0 quest disables.");
         LOG_INFO("server.loading", " ");
+        return;
     }
 
-    bool IsDisabledFor(DisableType type, uint32 entry, Unit const* unit, uint8 flags)
+    // check only quests, rest already done at startup
+    for (DisableTypeMap::iterator itr = m_DisableMap[DISABLE_TYPE_QUEST].begin(); itr != m_DisableMap[DISABLE_TYPE_QUEST].end();)
     {
-        if (type > MAX_DISABLE_TYPES)
+        const uint32 entry = itr->first;
+        if (!sObjectMgr->GetQuestTemplate(entry))
         {
-            LOG_ERROR("server", "Disables::IsDisabledFor() called with unknown disable type {}!  (entry {}, flags {}).", type, entry, flags);
-            return false;
+            LOG_ERROR("sql.sql", "Quest entry {} from `disables` doesn't exist, skipped.", entry);
+            m_DisableMap[DISABLE_TYPE_QUEST].erase(itr++);
+            continue;
         }
+        if (itr->second.flags)
+            LOG_ERROR("sql.sql", "Disable flags specified for quest {}, useless data.", entry);
+        ++itr;
+    }
 
-        if (m_DisableMap[type].empty())
-            return false;
-
-        DisableTypeMap::iterator itr = m_DisableMap[type].find(entry);
-        if (itr == m_DisableMap[type].end())    // not disabled
-            return false;
-
-        switch (type)
-        {
-            case DISABLE_TYPE_SPELL:
-                {
-                    uint8 spellFlags = itr->second.flags;
-                    if (unit)
-                    {
-                        if ((spellFlags & SPELL_DISABLE_PLAYER && unit->IsPlayer()) ||
-                                (unit->IsCreature() && ((unit->IsPet() && spellFlags & SPELL_DISABLE_PET) || spellFlags & SPELL_DISABLE_CREATURE)))
-                        {
-                            if (spellFlags & SPELL_DISABLE_MAP)
-                            {
-                                std::set<uint32> const& mapIds = itr->second.params[0];
-                                if (mapIds.find(unit->GetMapId()) != mapIds.end())
-                                    return true;                                        // Spell is disabled on current map
-
-                                if (!(spellFlags & SPELL_DISABLE_AREA))
-                                    return false;                                       // Spell is disabled on another map, but not this one, return false
-
-                                // Spell is disabled in an area, but not explicitly our current mapId. Continue processing.
-                            }
-
-                            if (spellFlags & SPELL_DISABLE_AREA)
-                            {
-                                std::set<uint32> const& areaIds = itr->second.params[1];
-                                if (areaIds.find(unit->GetAreaId()) != areaIds.end())
-                                    return true;                                        // Spell is disabled in this area
-                                return false;                                           // Spell is disabled in another area, but not this one, return false
-                            }
-                            else
-                                return true;                                            // Spell disabled for all maps
-                        }
-
-                        return false;
-                    }
-                    else if (spellFlags & SPELL_DISABLE_DEPRECATED_SPELL)    // call not from spellcast
-                        return true;
-
-                    break;
-                }
-            case DISABLE_TYPE_MAP:
-            case DISABLE_TYPE_LFG_MAP:
-                if (Player const* player = unit->ToPlayer())
-                {
-                    MapEntry const* mapEntry = sMapStore.LookupEntry(entry);
-                    if (mapEntry->IsDungeon())
-                    {
-                        uint8 disabledModes = itr->second.flags;
-                        Difficulty targetDifficulty = player->GetDifficulty(mapEntry->IsRaid());
-                        GetDownscaledMapDifficultyData(entry, targetDifficulty);
-                        switch (targetDifficulty)
-                        {
-                            case DUNGEON_DIFFICULTY_NORMAL:
-                                return disabledModes & DUNGEON_STATUSFLAG_NORMAL;
-                            case DUNGEON_DIFFICULTY_HEROIC:
-                                return disabledModes & DUNGEON_STATUSFLAG_HEROIC;
-                            case RAID_DIFFICULTY_10MAN_HEROIC:
-                                return disabledModes & RAID_STATUSFLAG_10MAN_HEROIC;
-                            case RAID_DIFFICULTY_25MAN_HEROIC:
-                                return disabledModes & RAID_STATUSFLAG_25MAN_HEROIC;
-                        }
-                    }
-                    else if (mapEntry->map_type == MAP_COMMON)
-                        return true;
-                }
-                return false;
-            case DISABLE_TYPE_QUEST:
-                return true;
-            case DISABLE_TYPE_BATTLEGROUND:
-            case DISABLE_TYPE_OUTDOORPVP:
-            case DISABLE_TYPE_ACHIEVEMENT_CRITERIA:
-                return true;
-            case DISABLE_TYPE_VMAP:
-                return flags & itr->second.flags;
-            case DISABLE_TYPE_GO_LOS:
-                return true;
-            case DISABLE_TYPE_GAME_EVENT:
-                return true;
-            case DISABLE_TYPE_LOOT:
-                return true;
-        }
+    LOG_INFO("server.loading", ">> Checked {} Quest Disables in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
+    LOG_INFO("server.loading", " ");
+}
 
+bool DisableMgr::IsDisabledFor(DisableType type, uint32 entry, Unit const* unit, uint8 flags)
+{
+    if (type >= MAX_DISABLE_TYPES)
+    {
+        LOG_ERROR("server", "Disables::IsDisabledFor() called with unknown disable type {}!  (entry {}, flags {}).", type, entry, flags);
         return false;
     }
 
-    bool IsVMAPDisabledFor(uint32 entry, uint8 flags)
-    {
-        return IsDisabledFor(DISABLE_TYPE_VMAP, entry, nullptr, flags);
-    }
+    if (m_DisableMap[type].empty())
+        return false;
 
-    bool IsPathfindingEnabled(const Map* map)
+    DisableTypeMap::iterator itr = m_DisableMap[type].find(entry);
+    if (itr == m_DisableMap[type].end())    // not disabled
+        return false;
+
+    switch (type)
     {
-        if (!map)
+        case DISABLE_TYPE_SPELL:
+            {
+                uint8 spellFlags = itr->second.flags;
+                if (unit)
+                {
+                    if ((spellFlags & SPELL_DISABLE_PLAYER && unit->IsPlayer()) ||
+                            (unit->IsCreature() && ((unit->IsPet() && spellFlags & SPELL_DISABLE_PET) || spellFlags & SPELL_DISABLE_CREATURE)))
+                    {
+                        if (spellFlags & SPELL_DISABLE_MAP)
+                        {
+                            std::set<uint32> const& mapIds = itr->second.params[0];
+                            if (mapIds.find(unit->GetMapId()) != mapIds.end())
+                                return true;                                        // Spell is disabled on current map
+
+                            if (!(spellFlags & SPELL_DISABLE_AREA))
+                                return false;                                       // Spell is disabled on another map, but not this one, return false
+
+                            // Spell is disabled in an area, but not explicitly our current mapId. Continue processing.
+                        }
+
+                        if (spellFlags & SPELL_DISABLE_AREA)
+                        {
+                            std::set<uint32> const& areaIds = itr->second.params[1];
+                            if (areaIds.find(unit->GetAreaId()) != areaIds.end())
+                                return true;                                        // Spell is disabled in this area
+                            return false;                                           // Spell is disabled in another area, but not this one, return false
+                        }
+                        else
+                            return true;                                            // Spell disabled for all maps
+                    }
+
+                    return false;
+                }
+                else if (spellFlags & SPELL_DISABLE_DEPRECATED_SPELL)    // call not from spellcast
+                    return true;
+
+                break;
+            }
+        case DISABLE_TYPE_MAP:
+        case DISABLE_TYPE_LFG_MAP:
+            if (Player const* player = unit->ToPlayer())
+            {
+                MapEntry const* mapEntry = sMapStore.LookupEntry(entry);
+                if (mapEntry->IsDungeon())
+                {
+                    uint8 disabledModes = itr->second.flags;
+                    Difficulty targetDifficulty = player->GetDifficulty(mapEntry->IsRaid());
+                    GetDownscaledMapDifficultyData(entry, targetDifficulty);
+                    switch (targetDifficulty)
+                    {
+                        case DUNGEON_DIFFICULTY_NORMAL:
+                            return disabledModes & DUNGEON_STATUSFLAG_NORMAL;
+                        case DUNGEON_DIFFICULTY_HEROIC:
+                            return disabledModes & DUNGEON_STATUSFLAG_HEROIC;
+                        case RAID_DIFFICULTY_10MAN_HEROIC:
+                            return disabledModes & RAID_STATUSFLAG_10MAN_HEROIC;
+                        case RAID_DIFFICULTY_25MAN_HEROIC:
+                            return disabledModes & RAID_STATUSFLAG_25MAN_HEROIC;
+                    }
+                }
+                else if (mapEntry->map_type == MAP_COMMON)
+                    return true;
+            }
             return false;
-
-        return !MMAP::MMapFactory::forbiddenMaps[map->GetId()] && (sWorld->getBoolConfig(CONFIG_ENABLE_MMAPS) ? true : map->IsBattlegroundOrArena());
+        case DISABLE_TYPE_VMAP:
+            return flags & itr->second.flags;
+        case DISABLE_TYPE_QUEST:
+        case DISABLE_TYPE_BATTLEGROUND:
+        case DISABLE_TYPE_OUTDOORPVP:
+        case DISABLE_TYPE_ACHIEVEMENT_CRITERIA:
+        case DISABLE_TYPE_GO_LOS:
+        case DISABLE_TYPE_GAME_EVENT:
+        case DISABLE_TYPE_LOOT:
+            return true;
+        default:
+            break;
     }
 
-} // Namespace
+    return false;
+}
+
+bool DisableMgr::IsVMAPDisabledFor(uint32 entry, uint8 flags)
+{
+    return IsDisabledFor(DISABLE_TYPE_VMAP, entry, nullptr, flags);
+}
+
+bool DisableMgr::IsPathfindingEnabled(Map const* map)
+{
+    if (!map)
+        return false;
+
+    return !MMAP::MMapFactory::forbiddenMaps[map->GetId()] && (sWorld->getBoolConfig(CONFIG_ENABLE_MMAPS) ? true : map->IsBattlegroundOrArena());
+}

src/server/game/Conditions/DisableMgr.h

@@ -15,8 +15,8 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef ACORE_DISABLEMGR_H
-#define ACORE_DISABLEMGR_H
+#ifndef _DISABLEMGR_H
+#define _DISABLEMGR_H
 
 #include "Define.h"
 #include "Map.h"
@@ -34,7 +34,8 @@ enum DisableType
     DISABLE_TYPE_GO_LOS                 = 7,
     DISABLE_TYPE_LFG_MAP                = 8,
     DISABLE_TYPE_GAME_EVENT             = 9,
-    DISABLE_TYPE_LOOT                   = 10
+    DISABLE_TYPE_LOOT                   = 10,
+    MAX_DISABLE_TYPES
 };
 
 enum SpellDisableTypes
@@ -46,18 +47,43 @@ enum SpellDisableTypes
     SPELL_DISABLE_MAP               = 0x10,
     SPELL_DISABLE_AREA              = 0x20,
     SPELL_DISABLE_LOS               = 0x40,
-    MAX_SPELL_DISABLE_TYPE = (  SPELL_DISABLE_PLAYER | SPELL_DISABLE_CREATURE | SPELL_DISABLE_PET |
-                                SPELL_DISABLE_DEPRECATED_SPELL | SPELL_DISABLE_MAP | SPELL_DISABLE_AREA |
-                                SPELL_DISABLE_LOS)
+    MAX_SPELL_DISABLE_TYPE          = (SPELL_DISABLE_PLAYER | SPELL_DISABLE_CREATURE | SPELL_DISABLE_PET |
+                                       SPELL_DISABLE_DEPRECATED_SPELL | SPELL_DISABLE_MAP | SPELL_DISABLE_AREA |
+                                       SPELL_DISABLE_LOS)
 };
 
-namespace DisableMgr
+struct DisableData
 {
-    void LoadDisables();
-    bool IsDisabledFor(DisableType type, uint32 entry, Unit const* unit, uint8 flags = 0);
-    void CheckQuestDisables();
-    bool IsVMAPDisabledFor(uint32 entry, uint8 flags);
-    bool IsPathfindingEnabled(const Map* map);
-}
+    uint8 flags;
+    std::set<uint32> params[2];                             // params0, params1
+};
 
-#endif //ACORE_DISABLEMGR_H
+class DisableMgr
+{
+private:
+    DisableMgr();
+    ~DisableMgr();
+
+public:
+    static DisableMgr* instance();
+
+    void LoadDisables();
+    void AddDisable(DisableType type, uint32 entry, uint8 flags, std::string param0, std::string param1);
+    bool HandleDisableType(DisableType type, uint32 entry, uint8 flags, std::string const& params_0, std::string const& params_1, DisableData& data);
+    static bool IsDisabledFor(DisableType type, uint32 entry, Unit const* unit, uint8 flags = 0);
+    void CheckQuestDisables();
+    static bool IsVMAPDisabledFor(uint32 entry, uint8 flags);
+    static bool IsPathfindingEnabled(Map const* map);
+
+private:
+    // single disables here with optional data
+    typedef std::map<uint32, DisableData> DisableTypeMap;
+    // global disable map by source
+    typedef std::map<DisableType, DisableTypeMap> DisableMap;
+
+    static DisableMap m_DisableMap;
+};
+
+#define sDisableMgr DisableMgr::instance()
+
+#endif //_DISABLEMGR_H

src/server/game/DungeonFinding/LFGMgr.cpp

@@ -410,9 +410,9 @@ namespace lfg
             uint32 lockData = 0;
             if (dungeon->expansion > expansion || (onlySeasonalBosses && !dungeon->seasonal))
                 lockData = LFG_LOCKSTATUS_INSUFFICIENT_EXPANSION;
-            else if (DisableMgr::IsDisabledFor(DISABLE_TYPE_MAP, dungeon->map, player))
+            else if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_MAP, dungeon->map, player))
                 lockData = LFG_LOCKSTATUS_RAID_LOCKED;
-            else if (DisableMgr::IsDisabledFor(DISABLE_TYPE_LFG_MAP, dungeon->map, player))
+            else if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_LFG_MAP, dungeon->map, player))
                 lockData = LFG_LOCKSTATUS_RAID_LOCKED;
             else if (dungeon->difficulty > DUNGEON_DIFFICULTY_NORMAL && (!mapEntry || !mapEntry->IsRaid()) && sInstanceSaveMgr->PlayerIsPermBoundToInstance(player->GetGUID(), dungeon->map, Difficulty(dungeon->difficulty)))
                 lockData = LFG_LOCKSTATUS_RAID_LOCKED;

src/server/game/Entities/Creature/Creature.cpp

@@ -286,7 +286,9 @@ Creature::Creature(bool isWorldObject): Unit(isWorldObject), MovableMapObject(),
         m_ProhibitSchoolTime[i] = 0;
 
     m_CreatureSpellCooldowns.clear();
-    DisableReputationGain = false;
+
+    DisableReputationReward = false;
+    DisableLootReward = false;
 
     m_SightDistance = sWorld->getFloatConfig(CONFIG_SIGHT_MONSTER);
     m_CombatDistance = 0.0f;

src/server/game/Entities/Creature/Creature.h

@@ -359,8 +359,10 @@ public:
 
     Unit* SelectVictim();
 
-    void SetDisableReputationGain(bool disable) { DisableReputationGain = disable; }
-    [[nodiscard]] bool IsReputationGainDisabled() const { return DisableReputationGain; }
+    void SetReputationRewardDisabled(bool disable) { DisableReputationReward = disable; }
+    [[nodiscard]] bool IsReputationRewardDisabled() const { return DisableReputationReward; }
+    void SetLootRewardDisabled(bool disable) { DisableLootReward = disable; }
+    [[nodiscard]] bool IsLootRewardDisabled() const { return DisableLootReward; }
     [[nodiscard]] bool IsDamageEnoughForLootingAndReward() const;
     void LowerPlayerDamageReq(uint32 unDamage, bool damagedByPlayer = true);
     void ResetPlayerDamageReq();
@@ -478,7 +480,8 @@ protected:
     Position m_homePosition;
     Position m_transportHomePosition;
 
-    bool DisableReputationGain;
+    bool DisableReputationReward;
+    bool DisableLootReward;
 
     CreatureTemplate const* m_creatureInfo;   // in difficulty mode > 0 can different from sObjectMgr->GetCreatureTemplate(GetEntry())
     CreatureData const* m_creatureData;

src/server/game/Entities/GameObject/GameObject.cpp

@@ -2594,7 +2594,7 @@ void GameObject::EnableCollision(bool enable)
         GetMap()->InsertGameObjectModel(*m_model);*/
 
     uint32 phaseMask = 0;
-    if (enable && !DisableMgr::IsDisabledFor(DISABLE_TYPE_GO_LOS, GetEntry(), nullptr))
+    if (enable && !sDisableMgr->IsDisabledFor(DISABLE_TYPE_GO_LOS, GetEntry(), nullptr))
         phaseMask = GetPhaseMask();
 
     m_model->enable(phaseMask);

src/server/game/Entities/Player/Player.cpp

@@ -1340,7 +1340,7 @@ bool Player::TeleportTo(uint32 mapid, float x, float y, float z, float orientati
         return false;
     }
 
-    if (AccountMgr::IsPlayerAccount(GetSession()->GetSecurity()) && DisableMgr::IsDisabledFor(DISABLE_TYPE_MAP, mapid, this))
+    if (AccountMgr::IsPlayerAccount(GetSession()->GetSecurity()) && sDisableMgr->IsDisabledFor(DISABLE_TYPE_MAP, mapid, this))
     {
         LOG_ERROR("entities.player", "Player ({}, name: {}) tried to enter a forbidden map {}", GetGUID().ToString(), GetName(), mapid);
         SendTransferAborted(mapid, TRANSFER_ABORT_MAP_NOT_ALLOWED);
@@ -4493,6 +4493,9 @@ void Player::BuildPlayerRepop()
 
 void Player::ResurrectPlayer(float restore_percent, bool applySickness)
 {
+    if (!sScriptMgr->CanPlayerResurrect(this))
+        return;
+
     WorldPacket data(SMSG_DEATH_RELEASE_LOC, 4 * 4);        // remove spirit healer position
     data << uint32(-1);
     data << float(0);
@@ -5993,7 +5996,7 @@ void Player::RewardReputation(Unit* victim)
     if (!victim || victim->IsPlayer())
         return;
 
-    if (victim->ToCreature()->IsReputationGainDisabled())
+    if (victim->ToCreature()->IsReputationRewardDisabled())
         return;
 
     ReputationOnKillEntry const* Rep = sObjectMgr->GetReputationOnKilEntry(victim->ToCreature()->GetCreatureTemplate()->Entry);
@@ -8858,6 +8861,8 @@ void Player::SendInitWorldStates(uint32 zoneid, uint32 areaid)
         }
     }
 
+    sWorldState->FillInitialWorldStates(data, zoneid, areaid);
+
     uint16 length = (data.wpos() - countPos) / 8;
     data.put<uint16>(countPos, length);
 

src/server/game/Entities/Player/Player.h

@@ -1728,6 +1728,10 @@ public:
     [[nodiscard]] bool HasTalent(uint32 spell_id, uint8 spec) const;
 
     [[nodiscard]] uint32 CalculateTalentsPoints() const;
+    void SetBonusTalentCount(uint32 count) { m_extraBonusTalentCount = count; };
+    uint32 GetBonusTalentCount() { return m_extraBonusTalentCount; };
+    void AddBonusTalent(uint32 count) { m_extraBonusTalentCount += count; };
+    void RemoveBonusTalent(uint32 count) { m_extraBonusTalentCount -= count; };
 
     // Dual Spec
     void UpdateSpecCount(uint8 count);

src/server/game/Entities/Player/PlayerQuest.cpp

@@ -236,7 +236,7 @@ Quest const* Player::GetNextQuest(ObjectGuid guid, Quest const* quest)
 
 bool Player::CanSeeStartQuest(Quest const* quest)
 {
-    if (!DisableMgr::IsDisabledFor(DISABLE_TYPE_QUEST, quest->GetQuestId(), this) && SatisfyQuestClass(quest, false) && SatisfyQuestRace(quest, false) &&
+    if (!sDisableMgr->IsDisabledFor(DISABLE_TYPE_QUEST, quest->GetQuestId(), this) && SatisfyQuestClass(quest, false) && SatisfyQuestRace(quest, false) &&
         SatisfyQuestSkill(quest, false) && SatisfyQuestExclusiveGroup(quest, false) && SatisfyQuestReputation(quest, false) &&
         SatisfyQuestPreviousQuest(quest, false) && SatisfyQuestNextChain(quest, false) &&
         SatisfyQuestPrevChain(quest, false) && SatisfyQuestDay(quest, false) && SatisfyQuestWeek(quest, false) &&
@@ -250,7 +250,7 @@ bool Player::CanSeeStartQuest(Quest const* quest)
 
 bool Player::CanTakeQuest(Quest const* quest, bool msg)
 {
-    return !DisableMgr::IsDisabledFor(DISABLE_TYPE_QUEST, quest->GetQuestId(), this)
+    return !sDisableMgr->IsDisabledFor(DISABLE_TYPE_QUEST, quest->GetQuestId(), this)
            && SatisfyQuestStatus(quest, msg) && SatisfyQuestExclusiveGroup(quest, msg)
            && SatisfyQuestClass(quest, msg) && SatisfyQuestRace(quest, msg) && SatisfyQuestLevel(quest, msg)
            && SatisfyQuestSkill(quest, msg) && SatisfyQuestReputation(quest, msg)

src/server/game/Entities/Player/PlayerStorage.cpp

@@ -5619,7 +5619,7 @@ bool Player::LoadFromDB(ObjectGuid playerGuid, CharacterDatabaseQueryHolder cons
 
 bool Player::isAllowedToLoot(Creature const* creature)
 {
-    if (!creature->isDead() || !creature->IsDamageEnoughForLootingAndReward())
+    if (!creature->isDead() || !creature->IsDamageEnoughForLootingAndReward() || creature->IsLootRewardDisabled())
         return false;
 
     if (HasPendingBind())
@@ -6722,7 +6722,7 @@ bool Player::Satisfy(DungeonProgressionRequirements const* ar, uint32 target_map
                 LevelMax = ar->levelMax;
         }
 
-        if (DisableMgr::IsDisabledFor(DISABLE_TYPE_MAP, target_map, this))
+        if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_MAP, target_map, this))
         {
             GetSession()->SendAreaTriggerMessage("{}", GetSession()->GetAcoreString(LANG_INSTANCE_CLOSED));
             return false;

src/server/game/Entities/Player/PlayerUpdates.cpp

@@ -555,7 +555,7 @@ void Player::UpdateLocalChannels(uint32 newZone)
 
                     if (channel->flags & CHANNEL_DBC_FLAG_CITY_ONLY)
                         currentNameExt = sObjectMgr->GetAcoreStringForDBCLocale(
-                            LANG_CHANNEL_CITY);
+                            LANG_CHANNEL_CITY).c_str();
                     else
                         currentNameExt = current_zone_name.c_str();
 

src/server/game/Entities/Unit/Unit.cpp

@@ -17798,7 +17798,7 @@ void Unit::Kill(Unit* killer, Unit* victim, bool durabilityLoss, WeaponAttackTyp
     bool isRewardAllowed = true;
     if (creature)
     {
-        isRewardAllowed = creature->IsDamageEnoughForLootingAndReward();
+        isRewardAllowed = (creature->IsDamageEnoughForLootingAndReward() && !creature->IsLootRewardDisabled());
         if (!isRewardAllowed)
             creature->SetLootRecipient(nullptr);
     }
@@ -20444,7 +20444,7 @@ void Unit::PetSpellFail(SpellInfo const* spellInfo, Unit* target, uint32 result)
     if (!charmInfo || !IsCreature())
         return;
 
-    if ((DisableMgr::IsPathfindingEnabled(GetMap()) || result != SPELL_FAILED_LINE_OF_SIGHT) && target)
+    if ((sDisableMgr->IsPathfindingEnabled(GetMap()) || result != SPELL_FAILED_LINE_OF_SIGHT) && target)
     {
         if ((result == SPELL_FAILED_LINE_OF_SIGHT || result == SPELL_FAILED_OUT_OF_RANGE) || !ToCreature()->HasReactState(REACT_PASSIVE))
             if (Unit* owner = GetOwner())
@@ -21355,6 +21355,12 @@ bool Unit::CanRestoreMana(SpellInfo const* spellInfo) const
     return false;
 }
 
+void Unit::SetShapeshiftForm(ShapeshiftForm form)
+{
+    SetByteValue(UNIT_FIELD_BYTES_2, 3, form);
+    sScriptMgr->OnUnitSetShapeshiftForm((Unit*)this, form);
+}
+
 bool Unit::IsInDisallowedMountForm() const
 {
     if (SpellInfo const* transformSpellInfo = sSpellMgr->GetSpellInfo(getTransForm()))

src/server/game/Entities/Unit/Unit.h

@@ -1869,10 +1869,7 @@ public:
 
     // ShapeShitForm (use by druid)
     [[nodiscard]] ShapeshiftForm GetShapeshiftForm() const { return ShapeshiftForm(GetByteValue(UNIT_FIELD_BYTES_2, 3)); }
-    void SetShapeshiftForm(ShapeshiftForm form)
-    {
-        SetByteValue(UNIT_FIELD_BYTES_2, 3, form);
-    }
+    void SetShapeshiftForm(ShapeshiftForm form);
     bool IsAttackSpeedOverridenShapeShift() const;
     [[nodiscard]] bool IsInFeralForm() const
     {

src/server/game/Events/GameEventMgr.cpp

@@ -133,7 +133,7 @@ void GameEventMgr::StartInternalEvent(uint16 event_id)
 
 bool GameEventMgr::StartEvent(uint16 event_id, bool overwrite)
 {
-    if (DisableMgr::IsDisabledFor(DISABLE_TYPE_GAME_EVENT, event_id, nullptr) && !overwrite)
+    if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_GAME_EVENT, event_id, nullptr) && !overwrite)
     {
         return false;
     }

src/server/game/Globals/ObjectMgr.cpp

@@ -3072,7 +3072,7 @@ void ObjectMgr::LoadItemTemplates()
             else if (itemTemplate.Spells[1].SpellId != -1)
             {
                 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itemTemplate.Spells[1].SpellId);
-                if (!spellInfo && !DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, itemTemplate.Spells[1].SpellId, nullptr))
+                if (!spellInfo && !sDisableMgr->IsDisabledFor(DISABLE_TYPE_SPELL, itemTemplate.Spells[1].SpellId, nullptr))
                 {
                     LOG_ERROR("sql.sql", "Item (Entry: {}) has wrong (not existing) spell in spellid_{} ({})", entry, 1 + 1, itemTemplate.Spells[1].SpellId);
                     itemTemplate.Spells[0].SpellId = 0;
@@ -3120,7 +3120,7 @@ void ObjectMgr::LoadItemTemplates()
                 if (itemTemplate.Spells[j].SpellId && itemTemplate.Spells[j].SpellId != -1)
                 {
                     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itemTemplate.Spells[j].SpellId);
-                    if (!spellInfo && !DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, itemTemplate.Spells[j].SpellId, nullptr))
+                    if (!spellInfo && !sDisableMgr->IsDisabledFor(DISABLE_TYPE_SPELL, itemTemplate.Spells[j].SpellId, nullptr))
                     {
                         LOG_ERROR("sql.sql", "Item (Entry: {}) has wrong (not existing) spell in spellid_{} ({})", entry, j + 1, itemTemplate.Spells[j].SpellId);
                         itemTemplate.Spells[j].SpellId = 0;
@@ -4616,7 +4616,7 @@ void ObjectMgr::LoadQuests()
     for (QuestMap::iterator iter = _questTemplates.begin(); iter != _questTemplates.end(); ++iter)
     {
         // skip post-loading checks for disabled quests
-        if (DisableMgr::IsDisabledFor(DISABLE_TYPE_QUEST, iter->first, nullptr))
+        if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_QUEST, iter->first, nullptr))
             continue;
 
         Quest* qinfo = iter->second;
@@ -8770,19 +8770,20 @@ bool ObjectMgr::LoadAcoreStrings()
     return true;
 }
 
-char const* ObjectMgr::GetAcoreString(uint32 entry, LocaleConstant locale) const
+std::string ObjectMgr::GetAcoreString(uint32 entry, LocaleConstant locale) const
 {
-    if (AcoreString const* ts = GetAcoreString(entry))
+    AcoreString const* as = GetAcoreString(entry);
+    if (as && !as->Content.empty())
     {
-        if (ts->Content.size() > std::size_t(locale) && !ts->Content[locale].empty())
-            return ts->Content[locale].c_str();
+        if (as->Content.size() > std::size_t(locale) && !as->Content[locale].empty())
+            return as->Content[locale];
 
-        return ts->Content[DEFAULT_LOCALE].c_str();
+        return as->Content[DEFAULT_LOCALE];
     }
 
-    LOG_ERROR("sql.sql", "Acore string entry {} not found in DB.", entry);
-
-    return "<error>";
+    std::string msg = Acore::StringFormat("No entry for acore_string ({}) in DB.", entry);
+    LOG_ERROR("sql.sql", msg);
+    return msg;
 }
 
 void ObjectMgr::LoadFishingBaseSkillLevel()

src/server/game/Globals/ObjectMgr.h

@@ -1315,8 +1315,8 @@ public:
 
         return &itr->second;
     }
-    [[nodiscard]] char const* GetAcoreString(uint32 entry, LocaleConstant locale) const;
-    [[nodiscard]] char const* GetAcoreStringForDBCLocale(uint32 entry) const { return GetAcoreString(entry, DBCLocaleIndex); }
+    [[nodiscard]] std::string GetAcoreString(uint32 entry, LocaleConstant locale) const;
+    [[nodiscard]] std::string GetAcoreStringForDBCLocale(uint32 entry) const { return GetAcoreString(entry, DBCLocaleIndex); }
     [[nodiscard]] LocaleConstant GetDBCLocaleIndex() const { return DBCLocaleIndex; }
     void SetDBCLocaleIndex(LocaleConstant locale) { DBCLocaleIndex = locale; }
 

src/server/game/Handlers/BattleGroundHandler.cpp

@@ -90,7 +90,7 @@ void WorldSession::HandleBattlemasterJoinOpcode(WorldPacket& recvData)
     }
 
     // chosen battleground type is disabled
-    if (DisableMgr::IsDisabledFor(DISABLE_TYPE_BATTLEGROUND, bgTypeId_, nullptr))
+    if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_BATTLEGROUND, bgTypeId_, nullptr))
     {
         ChatHandler(this).PSendSysMessage(LANG_BG_DISABLED);
         return;
@@ -721,7 +721,7 @@ void WorldSession::HandleBattlemasterJoinArena(WorldPacket& recvData)
     }
 
     // arenas disabled
-    if (DisableMgr::IsDisabledFor(DISABLE_TYPE_BATTLEGROUND, BATTLEGROUND_AA, nullptr))
+    if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_BATTLEGROUND, BATTLEGROUND_AA, nullptr))
     {
         ChatHandler(this).PSendSysMessage(LANG_ARENA_DISABLED);
         return;

src/server/game/Handlers/CalendarHandler.cpp

@@ -158,7 +158,7 @@ void WorldSession::HandleCalendarGetCalendar(WorldPacket& /*recvData*/)
     {
         HolidaysEntry const* holiday = sHolidaysStore.LookupEntry(entry);
 
-        if (DisableMgr::IsDisabledFor(DISABLE_TYPE_GAME_EVENT, sGameEventMgr->GetHolidayEventId(holiday->Id), nullptr))
+        if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_GAME_EVENT, sGameEventMgr->GetHolidayEventId(holiday->Id), nullptr))
         {
             continue;
         }

src/server/game/Handlers/PetHandler.cpp

@@ -232,7 +232,7 @@ void WorldSession::HandlePetActionHelper(Unit* pet, ObjectGuid guid1, uint32 spe
                                     return;
 
                         // Not let attack through obstructions
-                        bool checkLos = !DisableMgr::IsPathfindingEnabled(pet->GetMap()) ||
+                        bool checkLos = !sDisableMgr->IsPathfindingEnabled(pet->GetMap()) ||
                                         (TargetUnit->IsCreature() && (TargetUnit->ToCreature()->isWorldBoss() || TargetUnit->ToCreature()->IsDungeonBoss()));
 
                         if (checkLos && !pet->IsWithinLOSInMap(TargetUnit))

src/server/game/Loot/LootMgr.cpp

@@ -421,7 +421,7 @@ bool LootItem::AllowedForPlayer(Player const* player, ObjectGuid source) const
         return false;
     }
 
-    if (DisableMgr::IsDisabledFor(DISABLE_TYPE_LOOT, itemid, nullptr))
+    if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_LOOT, itemid, nullptr))
     {
         return false;
     }

src/server/game/Maps/Map.cpp

@@ -145,7 +145,7 @@ bool Map::ExistVMap(uint32 mapid, int gx, int gy)
 
 void Map::LoadMMap(int gx, int gy)
 {
-    if (!DisableMgr::IsPathfindingEnabled(this)) // pussywizard
+    if (!sDisableMgr->IsPathfindingEnabled(this)) // pussywizard
         return;
 
     int mmapLoadResult = MMAP::MMapFactory::createOrGetMMapMgr()->loadMap(GetId(), gx, gy);

src/server/game/Miscellaneous/Language.h

@@ -1169,8 +1169,7 @@ enum AcoreStrings
 
     LANG_GM_SILENCE                      = 6616,              // "Silence is ON for %s" - Spell 1852
 
-    // Used for .string command
-    LANG_NO_ACORE_STRING_FOUND           = 6617,
+    // Free strings 6617-7522
 
     LANG_WORLD_CLOSED                    = 7523,
     LANG_WORLD_OPENED                    = 7524,

src/server/game/Movement/MovementGenerators/HomeMovementGenerator.cpp

@@ -63,7 +63,7 @@ void HomeMovementGenerator<Creature>::_setTargetLocation(Creature* owner)
     }
 
     owner->UpdateAllowedPositionZ(x, y, z);
-    init.MoveTo(x, y, z, DisableMgr::IsPathfindingEnabled(owner->FindMap()), true);
+    init.MoveTo(x, y, z, sDisableMgr->IsPathfindingEnabled(owner->FindMap()), true);
     init.SetWalk(_walk);
     init.Launch();
 

src/server/game/Movement/MovementGenerators/PathGenerator.cpp

@@ -35,7 +35,7 @@ PathGenerator::PathGenerator(WorldObject const* owner) :
     memset(_pathPolyRefs, 0, sizeof(_pathPolyRefs));
 
     uint32 mapId = _source->GetMapId();
-    //if (DisableMgr::IsPathfindingEnabled(_sourceUnit->FindMap()))
+    //if (sDisableMgr->IsPathfindingEnabled(_sourceUnit->FindMap()))
     {
         MMAP::MMapMgr* mmap = MMAP::MMapFactory::createOrGetMMapMgr();
         _navMesh = mmap->GetNavMesh(mapId);

src/server/game/OutdoorPvP/OutdoorPvPMgr.cpp

@@ -60,7 +60,7 @@ void OutdoorPvPMgr::InitOutdoorPvP()
     {
         typeId = fields[0].Get<uint8>();
 
-        if (DisableMgr::IsDisabledFor(DISABLE_TYPE_OUTDOORPVP, typeId, nullptr))
+        if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_OUTDOORPVP, typeId, nullptr))
             continue;
 
         if (typeId >= MAX_OUTDOORPVP_TYPES)

src/server/game/Scripting/ScriptDefines/PlayerScript.cpp

@@ -903,6 +903,11 @@ bool ScriptMgr::AnticheatCheckMovementInfo(Player* player, MovementInfo const& m
     CALL_ENABLED_BOOLEAN_HOOKS(PlayerScript, PLAYERHOOK_ANTICHEAT_CHECK_MOVEMENT_INFO, !script->AnticheatCheckMovementInfo(player, movementInfo, mover, jump));
 }
 
+bool ScriptMgr::CanPlayerResurrect(Player* player)
+{
+    CALL_ENABLED_BOOLEAN_HOOKS(PlayerScript, PLAYERHOOK_CAN_RESURRECT, !script->CanPlayerResurrect(player));
+}
+
 PlayerScript::PlayerScript(const char* name, std::vector<uint16> enabledHooks)
     : ScriptObject(name, PLAYERHOOK_END)
 {

src/server/game/Scripting/ScriptDefines/PlayerScript.h

@@ -204,6 +204,7 @@ enum PlayerHook
     PLAYERHOOK_CAN_SEND_ERROR_ALREADY_LOOTED,
     PLAYERHOOK_ON_AFTER_CREATURE_LOOT,
     PLAYERHOOK_ON_AFTER_CREATURE_LOOT_MONEY,
+    PLAYERHOOK_CAN_RESURRECT,
     PLAYERHOOK_END
 };
 
@@ -766,6 +767,15 @@ public:
      * @param player Contains information about the Player
      */
     virtual void OnAfterCreatureLootMoney(Player* /*player*/) { }
+
+    /**
+     * @brief This hook is called, to avoid player resurrect
+     *
+     * @param player Contains information about the Player
+     *
+     * @return true if player is authorized to resurect
+     */
+    virtual bool CanPlayerResurrect(Player* /*player*/) { return true; }
 };
 
 #endif

src/server/game/Scripting/ScriptDefines/UnitScript.cpp

@@ -148,6 +148,11 @@ void ScriptMgr::OnUnitDeath(Unit* unit, Unit* killer)
     CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_UNIT_DEATH, script->OnUnitDeath(unit, killer));
 }
 
+void ScriptMgr::OnUnitSetShapeshiftForm(Unit* unit, uint8 form)
+{
+    CALL_ENABLED_HOOKS(UnitScript, UNITHOOK_ON_UNIT_SET_SHAPESHIFT_FORM, script->OnUnitSetShapeshiftForm(unit, form));
+}
+
 UnitScript::UnitScript(const char* name, bool addToScripts, std::vector<uint16> enabledHooks)
     : ScriptObject(name, UNITHOOK_END)
 {

src/server/game/Scripting/ScriptDefines/UnitScript.h

@@ -45,6 +45,7 @@ enum UnitHook
     UNITHOOK_ON_UNIT_ENTER_EVADE_MODE,
     UNITHOOK_ON_UNIT_ENTER_COMBAT,
     UNITHOOK_ON_UNIT_DEATH,
+    UNITHOOK_ON_UNIT_SET_SHAPESHIFT_FORM,
     UNITHOOK_END
 };
 
@@ -115,6 +116,7 @@ public:
     virtual void OnUnitEnterEvadeMode(Unit* /*unit*/, uint8 /*evadeReason*/) { }
     virtual void OnUnitEnterCombat(Unit* /*unit*/, Unit* /*victim*/) { }
     virtual void OnUnitDeath(Unit* /*unit*/, Unit* /*killer*/) { }
+    virtual void OnUnitSetShapeshiftForm(Unit* /*unit*/, uint8 /*form*/) { }
 };
 
 #endif

src/server/game/Scripting/ScriptMgr.h

@@ -492,6 +492,7 @@ public: /* PlayerScript */
     void OnAfterCreatureLoot(Player* player);
     void OnAfterCreatureLootMoney(Player* player);
     bool OnCanPlayerFlyInZone(Player* player, uint32 mapId, uint32 zoneId, SpellInfo const* bySpell);
+    bool CanPlayerResurrect(Player* player);
 
     // Anti cheat
     void AnticheatSetCanFlybyServer(Player* player, bool apply);
@@ -589,6 +590,7 @@ public: /* UnitScript */
     void OnUnitEnterEvadeMode(Unit* unit, uint8 why);
     void OnUnitEnterCombat(Unit* unit, Unit* victim);
     void OnUnitDeath(Unit* unit, Unit* killer);
+    void OnUnitSetShapeshiftForm(Unit* unit, uint8 form);
 
 public: /* MovementHandlerScript */
     void OnPlayerMove(Player* player, MovementInfo movementInfo, uint32 opcode);

src/server/game/Server/WorldSession.cpp

@@ -830,7 +830,7 @@ bool WorldSession::DisallowHyperlinksAndMaybeKick(std::string_view str)
     return false;
 }
 
-char const* WorldSession::GetAcoreString(uint32 entry) const
+std::string WorldSession::GetAcoreString(uint32 entry) const
 {
     return sObjectMgr->GetAcoreString(entry, GetSessionDbLocaleIndex());
 }

src/server/game/Server/WorldSession.h

@@ -372,7 +372,7 @@ public:
     void SendAreaTriggerMessage(std::string_view str);
 
     template<typename... Args>
-    void SendAreaTriggerMessage(char const* fmt, Args&&... args)
+    void SendAreaTriggerMessage(std::string fmt, Args&&... args)
     {
         if (!m_playerLoading)
             SendAreaTriggerMessage(Acore::StringFormat(fmt, std::forward<Args>(args)...));
@@ -528,9 +528,9 @@ public:
     time_t m_muteTime;
 
     // Locales
-    LocaleConstant GetSessionDbcLocale() const { return /*_isBot? LOCALE_enUS : */m_sessionDbcLocale; }
-    LocaleConstant GetSessionDbLocaleIndex() const { return /*_isBot? LOCALE_enUS : */m_sessionDbLocaleIndex; }
-    char const* GetAcoreString(uint32 entry) const;
+    LocaleConstant GetSessionDbcLocale() const { return m_sessionDbcLocale; }
+    LocaleConstant GetSessionDbLocaleIndex() const { return m_sessionDbLocaleIndex; }
+    std::string GetAcoreString(uint32 entry) const;
     std::string const* GetModuleString(std::string module, uint32 id) const;
 
     uint32 GetLatency() const { return m_latency; }

src/server/game/Spells/Spell.cpp

@@ -3530,7 +3530,7 @@ SpellCastResult Spell::prepare(SpellCastTargets const* targets, AuraEffect const
     _spellEvent = new SpellEvent(this);
     m_caster->m_Events.AddEvent(_spellEvent, m_caster->m_Events.CalculateTime(1));
 
-    if (DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, m_caster))
+    if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_SPELL, m_spellInfo->Id, m_caster))
     {
         SendCastResult(SPELL_FAILED_SPELL_UNAVAILABLE);
         finish(false);
@@ -6247,7 +6247,7 @@ SpellCastResult Spell::CheckCast(bool strict)
                                 return SPELL_FAILED_BAD_TARGETS;
                     // Xinef: Pass only explicit unit target spells
                     // pussywizard:
-                    if (DisableMgr::IsPathfindingEnabled(m_caster->FindMap()) && m_spellInfo->NeedsExplicitUnitTarget())
+                    if (sDisableMgr->IsPathfindingEnabled(m_caster->FindMap()) && m_spellInfo->NeedsExplicitUnitTarget())
                     {
                         Unit* target = m_targets.GetUnitTarget();
                         if (!target)
@@ -7960,7 +7960,7 @@ bool Spell::CheckEffectTarget(Unit const* target, uint32 eff) const
 
      // if spell is triggered, need to check for LOS disable on the aura triggering it and inherit that behaviour
     if (IsTriggered() && m_triggeredByAuraSpell && (m_triggeredByAuraSpell.spellInfo->HasAttribute(SPELL_ATTR2_IGNORE_LINE_OF_SIGHT) ||
-        DisableMgr::IsDisabledFor(DISABLE_TYPE_SPELL, m_triggeredByAuraSpell.spellInfo->Id, nullptr, SPELL_DISABLE_LOS)))
+        sDisableMgr->IsDisabledFor(DISABLE_TYPE_SPELL, m_triggeredByAuraSpell.spellInfo->Id, nullptr, SPELL_DISABLE_LOS)))
     {
         return true;
     }

src/server/game/Spells/SpellInfoCorrections.cpp

@@ -1602,6 +1602,7 @@ void SpellMgr::LoadSpellInfoCorrections()
     ApplySpellFix({ 44335 }, [](SpellInfo* spellInfo)
     {
         spellInfo->AuraInterruptFlags |= AURA_INTERRUPT_FLAG_CHANGE_MAP;
+        spellInfo->AttributesCu |= SPELL_ATTR0_CU_SINGLE_AURA_STACK;
     });
 
     ApplySpellFix({

src/server/game/Texts/ChatTextBuilder.cpp

@@ -39,7 +39,8 @@ void Acore::CustomChatTextBuilder::operator()(WorldPacket& data, LocaleConstant
 
 void Acore::AcoreStringChatBuilder::operator()(WorldPacket& data, LocaleConstant locale) const
 {
-    char const* text = sObjectMgr->GetAcoreString(_textId, locale);
+    std::string strtext = sObjectMgr->GetAcoreString(_textId, locale);
+    char const* text = strtext.c_str();
 
     if (_args)
     {

src/server/game/World/IWorld.h

@@ -422,6 +422,7 @@ enum WorldIntConfigs
     CONFIG_DAILY_RBG_MIN_LEVEL_AP_REWARD,
     CONFIG_AUCTIONHOUSE_WORKERTHREADS,
     CONFIG_SPELL_QUEUE_WINDOW,
+    CONFIG_SUNSREACH_COUNTER_MAX,
     INT_CONFIG_VALUE_COUNT
 };
 
@@ -572,7 +573,7 @@ public:
     virtual void SendGlobalMessage(WorldPacket const* packet, WorldSession* self = nullptr, TeamId teamId = TEAM_NEUTRAL) = 0;
     virtual void SendGlobalGMMessage(WorldPacket const* packet, WorldSession* self = nullptr, TeamId teamId = TEAM_NEUTRAL) = 0;
     virtual bool SendZoneMessage(uint32 zone, WorldPacket const* packet, WorldSession* self = nullptr, TeamId teamId = TEAM_NEUTRAL) = 0;
-    virtual void SendZoneText(uint32 zone, const char* text, WorldSession* self = nullptr, TeamId teamId = TEAM_NEUTRAL) = 0;
+    virtual void SendZoneText(uint32 zone, std::string text, WorldSession* self = nullptr, TeamId teamId = TEAM_NEUTRAL) = 0;
     virtual void SendServerMessage(ServerMessageType messageID, std::string stringParam = "", Player* player = nullptr) = 0;
     [[nodiscard]] virtual bool IsShuttingDown() const = 0;
     [[nodiscard]] virtual uint32 GetShutDownTimeLeft() const = 0;

src/server/game/World/World.cpp

@@ -1499,6 +1499,8 @@ void World::LoadConfigSettings(bool reload)
     _bool_configs[CONFIG_SPELL_QUEUE_ENABLED] = sConfigMgr->GetOption<bool>("SpellQueue.Enabled", true);
     _int_configs[CONFIG_SPELL_QUEUE_WINDOW] = sConfigMgr->GetOption<uint32>("SpellQueue.Window", 400);
 
+    _int_configs[CONFIG_SUNSREACH_COUNTER_MAX] = sConfigMgr->GetOption<uint32>("Sunsreach.CounterMax", 10000);
+
     // call ScriptMgr if we're reloading the configuration
     sScriptMgr->OnAfterConfigLoad(reload);
 }
@@ -1720,7 +1722,7 @@ void World::SetInitialWorldSettings()
     LoadRandomEnchantmentsTable();
 
     LOG_INFO("server.loading", "Loading Disables");
-    DisableMgr::LoadDisables();                                  // must be before loading quests and items
+    sDisableMgr->LoadDisables();                                  // must be before loading quests and items
 
     LOG_INFO("server.loading", "Loading Items...");                         // must be after LoadRandomEnchantmentsTable and LoadPageTexts
     sObjectMgr->LoadItemTemplates();
@@ -1801,7 +1803,7 @@ void World::SetInitialWorldSettings()
     sObjectMgr->LoadQuests();                                    // must be loaded after DBCs, creature_template, item_template, gameobject tables
 
     LOG_INFO("server.loading", "Checking Quest Disables");
-    DisableMgr::CheckQuestDisables();                           // must be after loading quests
+    sDisableMgr->CheckQuestDisables();                           // must be after loading quests
 
     LOG_INFO("server.loading", "Loading Quest POI");
     sObjectMgr->LoadQuestPOI();
@@ -2126,6 +2128,9 @@ void World::SetInitialWorldSettings()
     LOG_INFO("server.loading", " ");
     sGameEventMgr->StartArenaSeason();
 
+    LOG_INFO("server.loading", "Loading WorldState...");
+    sWorldState->Load();
+
     sTicketMgr->Initialize();
 
     ///- Initialize Battlegrounds
@@ -2571,7 +2576,8 @@ namespace Acore
         explicit WorldWorldTextBuilder(uint32 textId, va_list* args = nullptr) : i_textId(textId), i_args(args) {}
         void operator()(WorldPacketList& data_list, LocaleConstant loc_idx)
         {
-            char const* text = sObjectMgr->GetAcoreString(i_textId, loc_idx);
+            std::string strtext = sObjectMgr->GetAcoreString(i_textId, loc_idx);
+            char const* text = strtext.c_str();
 
             if (i_args)
             {
@@ -2630,10 +2636,10 @@ bool World::SendZoneMessage(uint32 zone, WorldPacket const* packet, WorldSession
 }
 
 /// Send a System Message to all players in the zone (except self if mentioned)
-void World::SendZoneText(uint32 zone, const char* text, WorldSession* self, TeamId teamId)
+void World::SendZoneText(uint32 zone, std::string text, WorldSession* self, TeamId teamId)
 {
     WorldPacket data;
-    ChatHandler::BuildChatPacket(data, CHAT_MSG_SYSTEM, LANG_UNIVERSAL, nullptr, nullptr, text);
+    ChatHandler::BuildChatPacket(data, CHAT_MSG_SYSTEM, LANG_UNIVERSAL, nullptr, nullptr, text.c_str());
     SendZoneMessage(zone, &data, self, teamId);
 }
 

src/server/game/World/World.h

@@ -239,7 +239,7 @@ public:
     void SendGlobalMessage(WorldPacket const* packet, WorldSession* self = nullptr, TeamId teamId = TEAM_NEUTRAL) override;
     void SendGlobalGMMessage(WorldPacket const* packet, WorldSession* self = nullptr, TeamId teamId = TEAM_NEUTRAL) override;
     bool SendZoneMessage(uint32 zone, WorldPacket const* packet, WorldSession* self = nullptr, TeamId teamId = TEAM_NEUTRAL) override;
-    void SendZoneText(uint32 zone, const char* text, WorldSession* self = nullptr, TeamId teamId = TEAM_NEUTRAL) override;
+    void SendZoneText(uint32 zone, std::string text, WorldSession* self = nullptr, TeamId teamId = TEAM_NEUTRAL) override;
     void SendServerMessage(ServerMessageType messageID, std::string stringParam = "", Player* player = nullptr) override;
 
     /// Are we in the middle of a shutdown?

src/server/game/World/WorldState.cpp

@@ -15,9 +15,11 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "GameEventMgr.h"
 #include "MapMgr.h"
 #include "Player.h"
 #include "SharedDefines.h"
+#include "Weather.h"
 #include "WorldState.h"
 
 WorldState* WorldState::instance()
@@ -37,6 +39,82 @@ WorldState::~WorldState()
 {
 }
 
+void WorldState::Load()
+{
+    QueryResult result = CharacterDatabase.Query("SELECT Id, Data FROM world_state");
+    if (result)
+    {
+        do
+        {
+            Field* fields = result->Fetch();
+            uint32 id = fields[0].Get<uint32>();
+            std::string data = fields[1].Get<std::string>();
+            std::istringstream loadStream(data);
+
+            switch (id)
+            {
+                case SAVE_ID_QUEL_DANAS:
+                {
+                    if (data.size())
+                    {
+                        try
+                        {
+                            loadStream >> m_sunsReachData.m_phase >> m_sunsReachData.m_subphaseMask;
+                            for (uint32 i = 0; i < COUNTERS_MAX; ++i)
+                                loadStream >> m_sunsReachData.m_sunsReachReclamationCounters[i];
+                            loadStream >> m_sunsReachData.m_gate;
+                            for (uint32 i = 0; i < COUNTERS_MAX_GATES; ++i)
+                                loadStream >> m_sunsReachData.m_gateCounters[i];
+                        }
+                        catch (std::exception& e)
+                        {
+                            LOG_ERROR("scripts", "WorldState::Load: Exception reading SunsReach data {}", e.what());
+                            m_sunsReachData.m_phase = 0;
+                            m_sunsReachData.m_subphaseMask = 0;
+                            memset(m_sunsReachData.m_sunsReachReclamationCounters, 0, sizeof(m_sunsReachData.m_sunsReachReclamationCounters));
+                            m_sunsReachData.m_gate = SUNWELL_ALL_GATES_CLOSED;
+                            memset(m_sunsReachData.m_gateCounters, 0, sizeof(m_sunsReachData.m_gateCounters));
+                        }
+                    }
+                    else
+                    {
+                        m_sunsReachData.m_phase = 0;
+                        m_sunsReachData.m_subphaseMask = 0;
+                        memset(m_sunsReachData.m_sunsReachReclamationCounters, 0, sizeof(m_sunsReachData.m_sunsReachReclamationCounters));
+                        m_sunsReachData.m_gate = SUNWELL_ALL_GATES_CLOSED;
+                        memset(m_sunsReachData.m_gateCounters, 0, sizeof(m_sunsReachData.m_gateCounters));
+                    }
+                    break;
+                }
+            }
+        } while (result->NextRow());
+    }
+    StartSunsReachPhase(true);
+    StartSunwellGatePhase();
+    HandleSunsReachSubPhaseTransition(m_sunsReachData.m_subphaseMask, true);
+}
+
+void WorldState::Save(WorldStateSaveIds saveId)
+{
+    switch (saveId)
+    {
+        case SAVE_ID_QUEL_DANAS:
+        {
+            std::string expansionData = m_sunsReachData.GetData();
+            SaveHelper(expansionData, SAVE_ID_QUEL_DANAS);
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+void WorldState::SaveHelper(std::string& stringToSave, WorldStateSaveIds saveId)
+{
+    CharacterDatabase.Execute("DELETE FROM world_state WHERE Id='{}'", saveId);
+    CharacterDatabase.Execute("INSERT INTO world_state(Id,Data) VALUES('{}','{}')", saveId, stringToSave.data());
+}
+
 bool WorldState::IsConditionFulfilled(WorldStateCondition conditionId, WorldStateConditionState state) const
 {
     switch (conditionId)
@@ -140,6 +218,16 @@ void WorldState::HandlePlayerEnterZone(Player* player, WorldStateZoneId zoneId)
             else if (_isMagtheridonHeadSpawnedHorde && player->GetTeamId() == TEAM_HORDE)
                 player->CastSpell(player, SPELL_NAZGRELS_FAVOR, true);
             break;
+        case ZONEID_ISLE_OF_QUEL_DANAS:
+        case ZONEID_MAGISTERS_TERRACE:
+        case ZONEID_SUNWELL_PLATEAU:
+        {
+            std::lock_guard<std::mutex> guard(m_sunsReachData.m_sunsReachReclamationMutex);
+            m_sunsReachData.m_sunsReachReclamationPlayers.push_back(player->GetGUID());
+            if (m_sunsReachData.m_subphaseMask == SUBPHASE_ALL)
+                player->CastSpell(player, SPELL_KIRU_SONG_OF_VICTORY, true);
+            break;
+        }
         default:
             break;
     }
@@ -167,6 +255,17 @@ void WorldState::HandlePlayerLeaveZone(Player* player, WorldStateZoneId zoneId)
             else if (player->GetTeamId() == TEAM_HORDE)
                 player->RemoveAurasDueToSpell(SPELL_NAZGRELS_FAVOR);
             break;
+        case ZONEID_ISLE_OF_QUEL_DANAS:
+        case ZONEID_MAGISTERS_TERRACE:
+        case ZONEID_SUNWELL_PLATEAU:
+        {
+            std::lock_guard<std::mutex> guard(m_sunsReachData.m_sunsReachReclamationMutex);
+            player->RemoveAurasDueToSpell(SPELL_KIRU_SONG_OF_VICTORY);
+            auto position = std::find(m_sunsReachData.m_sunsReachReclamationPlayers.begin(), m_sunsReachData.m_sunsReachReclamationPlayers.end(), player->GetGUID());
+            if (position != m_sunsReachData.m_sunsReachReclamationPlayers.end())
+                m_sunsReachData.m_sunsReachReclamationPlayers.erase(position);
+            break;
+        }
         default:
             break;
     }
@@ -291,3 +390,699 @@ void WorldState::DispelAdalsSongOfBattle()
         }
     });
 }
+
+void WorldState::SendWorldstateUpdate(std::mutex& mutex, GuidVector const& guids, uint32 value, uint32 worldStateId)
+{
+    std::lock_guard<std::mutex> guard(mutex);
+    for (ObjectGuid const& guid : guids)
+        if (Player* player = ObjectAccessor::FindPlayer(guid))
+            player->SendUpdateWorldState(worldStateId, value);
+}
+
+enum WorldStateSunsReachQuests
+{
+    QUEST_ERRATIC_BEHAVIOR                  = 11524,
+    QUEST_SANCTUM_WARDS                     = 11496,
+    QUEST_BATTLE_FOR_THE_SUNS_REACH_ARMORY  = 11538,
+    QUEST_DISTRACTION_AT_THE_DEAD_SCAR      = 11532,
+    QUEST_INTERCEPTING_THE_MANA_CELLS       = 11513,
+    QUEST_INTERCEPT_THE_REINFORCEMENTS      = 11542,
+    QUEST_TAKING_THE_HARBOR                 = 11539,
+    QUEST_MAKING_READY                      = 11535,
+    QUEST_DISCOVERING_YOUR_ROOTS            = 11520,
+    QUEST_A_CHARITABLE_DONATION             = 11545,
+    QUEST_A_MAGNANIMOUS_BENEFACTOR          = 11549,
+    COUNTER_MAX_VAL_REQ                     = 10000,
+};
+
+void WorldState::AddSunsReachProgress(uint32 questId)
+{
+    uint32 counter = 0;
+    int32 otherCounter = -1;
+    int32 worldState = 0;
+    uint32 subPhaseMask = 0;
+    uint32 addedValue = 1;
+    switch (questId)
+    {
+        case QUEST_ERRATIC_BEHAVIOR:
+            counter = COUNTER_ERRATIC_BEHAVIOR;
+            otherCounter = COUNTER_SANCTUM_WARDS;
+            worldState = WORLD_STATE_QUEL_DANAS_SANCTUM;
+            break;
+        case QUEST_SANCTUM_WARDS:
+            counter = COUNTER_SANCTUM_WARDS;
+            otherCounter = COUNTER_SANCTUM_WARDS;
+            worldState = WORLD_STATE_QUEL_DANAS_SANCTUM;
+            break;
+        case QUEST_BATTLE_FOR_THE_SUNS_REACH_ARMORY:
+            counter = COUNTER_BATTLE_FOR_THE_SUNS_REACH_ARMORY;
+            otherCounter = COUNTER_DISTRACTION_AT_THE_DEAD_SCAR;
+            worldState = WORLD_STATE_QUEL_DANAS_ARMORY;
+            break;
+        case QUEST_DISTRACTION_AT_THE_DEAD_SCAR:
+            counter = COUNTER_DISTRACTION_AT_THE_DEAD_SCAR;
+            otherCounter = COUNTER_BATTLE_FOR_THE_SUNS_REACH_ARMORY;
+            worldState = WORLD_STATE_QUEL_DANAS_ARMORY;
+            break;
+        case QUEST_INTERCEPTING_THE_MANA_CELLS:
+            counter = COUNTER_INTERCEPTING_THE_MANA_CELLS;
+            subPhaseMask = SUBPHASE_PORTAL;
+            worldState = WORLD_STATE_QUEL_DANAS_PORTAL;
+            break;
+        case QUEST_INTERCEPT_THE_REINFORCEMENTS:
+            counter = COUNTER_INTERCEPT_THE_REINFORCEMENTS;
+            otherCounter = COUNTER_TAKING_THE_HARBOR;
+            worldState = WORLD_STATE_QUEL_DANAS_HARBOR;
+            break;
+        case QUEST_TAKING_THE_HARBOR:
+            counter = COUNTER_TAKING_THE_HARBOR;
+            otherCounter = COUNTER_INTERCEPT_THE_REINFORCEMENTS;
+            worldState = WORLD_STATE_QUEL_DANAS_HARBOR;
+            break;
+        case QUEST_MAKING_READY:
+            counter = COUNTER_MAKING_READY;
+            subPhaseMask = SUBPHASE_ANVIL;
+            worldState = WORLD_STATE_QUEL_DANAS_ANVIL;
+            break;
+        case QUEST_DISCOVERING_YOUR_ROOTS:
+            counter = COUNTER_DISCOVERING_YOUR_ROOTS;
+            subPhaseMask = SUBPHASE_ALCHEMY_LAB;
+            worldState = WORLD_STATE_QUEL_DANAS_ALCHEMY_LAB;
+            break;
+        case QUEST_A_CHARITABLE_DONATION:
+            counter = COUNTER_A_CHARITABLE_DONATION;
+            subPhaseMask = SUBPHASE_MONUMENT;
+            worldState = WORLD_STATE_QUEL_DANAS_MONUMENT;
+            break;
+        case QUEST_A_MAGNANIMOUS_BENEFACTOR:
+            counter = COUNTER_A_CHARITABLE_DONATION;
+            subPhaseMask = SUBPHASE_MONUMENT;
+            worldState = WORLD_STATE_QUEL_DANAS_MONUMENT;
+            addedValue = 150;
+            break;
+        default:
+            return;
+    }
+
+    uint32 previousValue = 0;
+    uint32 newValue = 0;
+
+    if (!subPhaseMask)
+        previousValue = m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase);
+    else
+        previousValue = m_sunsReachData.GetSubPhasePercentage(subPhaseMask);
+    m_sunsReachData.m_sunsReachReclamationCounters[counter] += addedValue;
+    if (!subPhaseMask)
+        newValue = m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase);
+    else
+        newValue = m_sunsReachData.GetSubPhasePercentage(subPhaseMask);
+    if (previousValue != newValue)
+        SendWorldstateUpdate(m_sunsReachData.m_sunsReachReclamationMutex, m_sunsReachData.m_sunsReachReclamationPlayers, newValue, worldState);
+
+    bool save = true;
+    uint32 counterValue = m_sunsReachData.m_sunsReachReclamationCounters[counter];
+    uint32 modifier = 1;
+    if (otherCounter != -1)
+    {
+        modifier = 2;
+        counterValue += m_sunsReachData.m_sunsReachReclamationCounters[otherCounter];
+    }
+    if (counterValue >= sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX) * modifier)
+    {
+        save = false;
+        switch (questId)
+        {
+            case QUEST_ERRATIC_BEHAVIOR:
+            case QUEST_SANCTUM_WARDS:
+            {
+                if (m_sunsReachData.m_phase == SUNS_REACH_PHASE_1_STAGING_AREA)
+                    HandleSunsReachPhaseTransition(SUNS_REACH_PHASE_2_SANCTUM);
+                break;
+            }
+            case QUEST_BATTLE_FOR_THE_SUNS_REACH_ARMORY:
+            case QUEST_DISTRACTION_AT_THE_DEAD_SCAR:
+            {
+                if (m_sunsReachData.m_phase == SUNS_REACH_PHASE_2_SANCTUM)
+                    HandleSunsReachPhaseTransition(SUNS_REACH_PHASE_3_ARMORY);
+                break;
+            }
+            case QUEST_INTERCEPTING_THE_MANA_CELLS:
+            {
+                if ((m_sunsReachData.m_subphaseMask & SUBPHASE_PORTAL) == 0)
+                    HandleSunsReachSubPhaseTransition(SUBPHASE_PORTAL);
+                break;
+            }
+            case QUEST_INTERCEPT_THE_REINFORCEMENTS:
+            case QUEST_TAKING_THE_HARBOR:
+            {
+                if (m_sunsReachData.m_phase == SUNS_REACH_PHASE_3_ARMORY)
+                    HandleSunsReachPhaseTransition(SUNS_REACH_PHASE_4_HARBOR);
+                break;
+            }
+            case QUEST_MAKING_READY:
+            {
+                if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ANVIL) == 0)
+                    HandleSunsReachSubPhaseTransition(SUBPHASE_ANVIL);
+                break;
+            }
+            case QUEST_DISCOVERING_YOUR_ROOTS:
+            {
+                if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALCHEMY_LAB) == 0)
+                    HandleSunsReachSubPhaseTransition(SUBPHASE_ALCHEMY_LAB);
+                break;
+            }
+            case QUEST_A_CHARITABLE_DONATION:
+            case QUEST_A_MAGNANIMOUS_BENEFACTOR:
+            {
+                if ((m_sunsReachData.m_subphaseMask & SUBPHASE_MONUMENT) == 0)
+                    HandleSunsReachSubPhaseTransition(SUBPHASE_MONUMENT);
+                break;
+            }
+        }
+    }
+    if (save)
+        Save(SAVE_ID_QUEL_DANAS);
+}
+
+void WorldState::HandleSunsReachPhaseTransition(uint32 newPhase)
+{
+    if (newPhase < m_sunsReachData.m_phase)
+    {
+        while (newPhase != m_sunsReachData.m_phase)
+        {
+            StopSunsReachPhase(newPhase > m_sunsReachData.m_phase);
+            --m_sunsReachData.m_phase;
+        }
+        StartSunsReachPhase();
+    }
+    else
+    {
+        StopSunsReachPhase(newPhase > m_sunsReachData.m_phase);
+        bool moreThanOne = newPhase > m_sunsReachData.m_phase + 1; // custom command case
+        m_sunsReachData.m_phase = newPhase;
+        StartSunsReachPhase(moreThanOne);
+    }
+    switch (m_sunsReachData.m_phase)
+    {
+        case SUNS_REACH_PHASE_2_SANCTUM: if ((m_sunsReachData.m_subphaseMask & SUBPHASE_PORTAL) == 0) sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_NO_PORTAL); break;
+        case SUNS_REACH_PHASE_3_ARMORY: if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ANVIL) == 0) sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_NO_ANVIL); break;
+        case SUNS_REACH_PHASE_4_HARBOR:
+            if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALCHEMY_LAB) == 0) sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_NO_MONUMENT);
+            if ((m_sunsReachData.m_subphaseMask & SUBPHASE_MONUMENT) == 0) sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_NO_ALCHEMY_LAB);
+            break;
+        default: break;
+    }
+    SendWorldstateUpdate(m_sunsReachData.m_sunsReachReclamationMutex, m_sunsReachData.m_sunsReachReclamationPlayers, m_sunsReachData.m_phase, WORLD_STATE_QUEL_DANAS_MUSIC);
+    Save(SAVE_ID_QUEL_DANAS);
+}
+
+void WorldState::HandleSunsReachSubPhaseTransition(int32 subPhaseMask, bool initial)
+{
+    bool start = true;
+    if (subPhaseMask < 0)
+    {
+        start = false;
+        subPhaseMask = -subPhaseMask;
+    }
+    bool all = false;
+    if (start)
+    {
+        m_sunsReachData.m_subphaseMask |= subPhaseMask;
+        if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALL) == SUBPHASE_ALL)
+            all = true;
+    }
+    else
+    {
+        if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALL) == SUBPHASE_ALL)
+            all = true;
+        m_sunsReachData.m_subphaseMask &= ~subPhaseMask;
+    }
+    if (initial)
+    {
+        if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_2_SANCTUM)
+            if ((subPhaseMask & SUBPHASE_PORTAL) == 0)
+                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_NO_PORTAL);
+        if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_3_ARMORY)
+            if ((subPhaseMask & SUBPHASE_ANVIL) == 0)
+                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_NO_ANVIL);
+        if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_4_HARBOR)
+        {
+            if ((subPhaseMask & SUBPHASE_ALCHEMY_LAB) == 0)
+                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_NO_ALCHEMY_LAB);
+            if ((subPhaseMask & SUBPHASE_MONUMENT) == 0)
+                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_NO_MONUMENT);
+        }
+    }
+    if ((subPhaseMask & SUBPHASE_PORTAL))
+    {
+        uint32 first = GAME_EVENT_QUEL_DANAS_PHASE_2_NO_PORTAL;
+        uint32 second = GAME_EVENT_QUEL_DANAS_PHASE_2_PORTAL;
+        if (start)
+        {
+            sGameEventMgr->StopEvent(first);
+            sGameEventMgr->StartEvent(second);
+        }
+        else
+        {
+            sGameEventMgr->StopEvent(second);
+            sGameEventMgr->StartEvent(first);
+        }
+    }
+    if ((subPhaseMask & SUBPHASE_ANVIL))
+    {
+        uint32 first = GAME_EVENT_QUEL_DANAS_PHASE_3_NO_ANVIL;
+        uint32 second = GAME_EVENT_QUEL_DANAS_PHASE_3_ANVIL;
+        if (start)
+        {
+            sGameEventMgr->StopEvent(first);
+            sGameEventMgr->StartEvent(second);
+        }
+        else
+        {
+            sGameEventMgr->StopEvent(second);
+            sGameEventMgr->StartEvent(first);
+        }
+    }
+    if ((subPhaseMask & SUBPHASE_ALCHEMY_LAB))
+    {
+        uint32 first = GAME_EVENT_QUEL_DANAS_PHASE_4_NO_ALCHEMY_LAB;
+        uint32 second = GAME_EVENT_QUEL_DANAS_PHASE_4_ALCHEMY_LAB;
+        if (start)
+        {
+            sGameEventMgr->StopEvent(first);
+            sGameEventMgr->StartEvent(second);
+        }
+        else
+        {
+            sGameEventMgr->StopEvent(second);
+            sGameEventMgr->StartEvent(first);
+        }
+    }
+    if ((subPhaseMask & SUBPHASE_MONUMENT))
+    {
+        uint32 first = GAME_EVENT_QUEL_DANAS_PHASE_4_NO_MONUMENT;
+        uint32 second = GAME_EVENT_QUEL_DANAS_PHASE_4_MONUMENT;
+        if (start)
+        {
+            sGameEventMgr->StopEvent(first);
+            sGameEventMgr->StartEvent(second);
+        }
+        else
+        {
+            sGameEventMgr->StopEvent(second);
+            sGameEventMgr->StartEvent(first);
+        }
+    }
+    if (all)
+    {
+        if (start)
+            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_KIRU);
+        else
+            sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_KIRU);
+
+        if (!initial)
+        {
+            std::lock_guard<std::mutex> guard(m_sunsReachData.m_sunsReachReclamationMutex);
+            for (ObjectGuid& guid : m_sunsReachData.m_sunsReachReclamationPlayers)
+                if (Player* player = ObjectAccessor::FindPlayer(guid))
+                {
+                    if (start)
+                        player->CastSpell(player, SPELL_KIRU_SONG_OF_VICTORY, true);
+                    else
+                        player->RemoveAurasDueToSpell(SPELL_KIRU_SONG_OF_VICTORY);
+                }
+        }
+    }
+    if (!initial)
+        Save(SAVE_ID_QUEL_DANAS);
+}
+
+void WorldState::HandleSunwellGateTransition(uint32 newGate)
+{
+    if (newGate < m_sunsReachData.m_gate)
+    {
+        while (newGate != m_sunsReachData.m_gate)
+        {
+            StopSunwellGatePhase();
+            --m_sunsReachData.m_gate;
+        }
+        StartSunwellGatePhase();
+    }
+    else
+    {
+        StopSunwellGatePhase();
+        m_sunsReachData.m_gate = newGate;
+        StartSunwellGatePhase();
+    }
+    int32 worldState = 0;
+    switch (newGate)
+    {
+        case SUNWELL_AGAMATH_GATE1_OPEN: worldState = WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH; break;
+        case SUNWELL_ROHENDOR_GATE2_OPEN: worldState = WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH; break;
+        case SUNWELL_ARCHONISUS_GATE3_OPEN: worldState = WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH; break;
+    }
+    if (worldState)
+        SendWorldstateUpdate(m_sunsReachData.m_sunsReachReclamationMutex, m_sunsReachData.m_sunsReachReclamationPlayers, m_sunsReachData.m_gate, worldState);
+
+    Save(SAVE_ID_QUEL_DANAS);
+}
+
+void WorldState::SetSunsReachCounter(SunsReachCounters index, uint32 value)
+{
+    m_sunsReachData.m_sunsReachReclamationCounters[index] = value;
+}
+
+void WorldState::StopSunsReachPhase(bool forward)
+{
+    switch (m_sunsReachData.m_phase)
+    {
+        case SUNS_REACH_PHASE_1_STAGING_AREA: sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_1); break;
+        case SUNS_REACH_PHASE_2_SANCTUM: sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_ONLY); if (!forward) sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT); break;
+        case SUNS_REACH_PHASE_3_ARMORY: sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_ONLY); if (!forward) sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_PERMANENT); break;
+        case SUNS_REACH_PHASE_4_HARBOR: sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_4); break;
+        default: break;
+    }
+}
+
+void WorldState::StartSunsReachPhase(bool initial)
+{
+    switch (m_sunsReachData.m_phase)
+    {
+        case SUNS_REACH_PHASE_1_STAGING_AREA:
+            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_1);
+            if (Map* map = sMapMgr->FindBaseNonInstanceMap(530))
+                map->SetZoneWeather(ZONEID_ISLE_OF_QUEL_DANAS, WEATHER_STATE_MEDIUM_RAIN, 0.75f);
+            break;
+        case SUNS_REACH_PHASE_2_SANCTUM:
+            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_ONLY);
+            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT);
+            if (Map* map = sMapMgr->FindBaseNonInstanceMap(530))
+                map->SetZoneWeather(ZONEID_ISLE_OF_QUEL_DANAS, WEATHER_STATE_LIGHT_RAIN, 0.5f);
+            break;
+        case SUNS_REACH_PHASE_3_ARMORY:
+            if (initial)
+                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT);
+            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_ONLY); sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_PERMANENT);
+            // TODO: Should be id 2 0.25f?
+            if (Map* map = sMapMgr->FindBaseNonInstanceMap(530))
+                map->SetZoneWeather(ZONEID_ISLE_OF_QUEL_DANAS, WEATHER_STATE_LIGHT_RAIN, 0.25f);
+            break;
+        case SUNS_REACH_PHASE_4_HARBOR:
+            if (initial)
+            {
+                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT);
+                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_PERMANENT);
+            }
+            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4);
+            if (Map* map = sMapMgr->FindBaseNonInstanceMap(530))
+                map->SetZoneWeather(ZONEID_ISLE_OF_QUEL_DANAS, WEATHER_STATE_FINE, 0.0f);
+            break;
+        default: break;
+    }
+}
+
+std::string WorldState::GetSunsReachPrintout()
+{
+    auto formatPhase = [this]() -> std::string {
+        std::string name;
+        switch (m_sunsReachData.m_phase)
+        {
+            case SUNS_REACH_PHASE_1_STAGING_AREA: name = "Phase 1: Staging Area"; break;
+            case SUNS_REACH_PHASE_2_SANCTUM: name = "Phase 2: Sanctum"; break;
+            case SUNS_REACH_PHASE_3_ARMORY: name = "Phase 3: Armory"; break;
+            case SUNS_REACH_PHASE_4_HARBOR: name = "Phase 4: Harbor"; break;
+            default: name = "Unknown"; break;
+        }
+        return "Phase: " + std::to_string(m_sunsReachData.m_phase) + " (" + name + ") " + std::to_string(m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase)) + "%\n";
+    };
+
+    auto formatSubPhase = [this](uint32 subPhase) -> std::string {
+        std::string name;
+        switch (subPhase)
+        {
+            case SUBPHASE_PORTAL: name = "Portal"; break;
+            case SUBPHASE_ANVIL: name = "Anvil"; break;
+            case SUBPHASE_ALCHEMY_LAB: name = "Alchemy Lab"; break;
+            case SUBPHASE_MONUMENT: name = "Monument"; break;
+            default: name = "Unknown"; break;
+        }
+        return name + ": " + (m_sunsReachData.m_subphaseMask & subPhase ? "100%" : std::to_string(m_sunsReachData.GetSubPhasePercentage(subPhase)) + "%");
+    };
+
+    auto formatCounter = [](uint32 counter, uint32 value) -> std::string {
+        switch (counter)
+        {
+            case COUNTER_ERRATIC_BEHAVIOR:
+                return "Erratic Behavior: " + std::to_string(value) + " (counts towards Phase 2: Sanctum)";
+            case COUNTER_SANCTUM_WARDS:
+                return "Sanctum Wards: " + std::to_string(value) + " (counts towards Phase 2: Sanctum)";
+            case COUNTER_BATTLE_FOR_THE_SUNS_REACH_ARMORY:
+                return "Battle for the Sun's Reach Armory: " + std::to_string(value) + " (counts towards Phase 3: Armory)";
+            case COUNTER_DISTRACTION_AT_THE_DEAD_SCAR:
+                return "Distraction at the Dead Scar: " + std::to_string(value) + " (counts towards Phase 3: Armory)";
+            case COUNTER_INTERCEPTING_THE_MANA_CELLS:
+                return "Intercepting the Mana Cells: " + std::to_string(value) + " (counts towards Subphase: Portal)";
+            case COUNTER_INTERCEPT_THE_REINFORCEMENTS:
+                return "Intercept the Reinforcements: " + std::to_string(value) + " (counts towards Phase 4: Harbor)";
+            case COUNTER_TAKING_THE_HARBOR:
+                return "Taking the Harbor: " + std::to_string(value) + " (counts towards Phase 4: Harbor)";
+            case COUNTER_MAKING_READY:
+                return "Making Ready: " + std::to_string(value) + " (counts towards Subphase: Anvil)";
+            case COUNTER_DISCOVERING_YOUR_ROOTS:
+                return "Discovering Your Roots: " + std::to_string(value) + " (counts towards Subphase: Alchemy Lab)";
+            case COUNTER_A_CHARITABLE_DONATION:
+                return "A Charitable Donation: " + std::to_string(value) + " (counts towards Subphase: Monument)";
+            default:
+                return "Unknown: " + std::to_string(value) + " (Unknown goal)";
+        }
+    };
+
+    std::string output = formatPhase();
+    output += "Subphase mask: " + std::to_string(m_sunsReachData.m_subphaseMask) + "\n";
+    for (uint32 i = 0; i < 4; ++i)
+    {
+        uint32 subPhaseMask = 1 << i;
+        output += "  " + formatSubPhase(subPhaseMask) + "\n";
+    }
+    output += "Counters:\n";
+    output += "  Sunsreach.CounterMax = " + std::to_string(sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX)) + "\n";
+    for (uint32 i = 0; i < COUNTERS_MAX; ++i)
+        output += "  " + std::to_string(i) + ". " + formatCounter(i, m_sunsReachData.m_sunsReachReclamationCounters[i]) + "\n";
+
+    // Sunwell Gates
+    auto formatGatePhase = [](uint32 gate) -> std::string {
+        switch (gate)
+        {
+            case SUNWELL_ALL_GATES_CLOSED: return "All Gates Closed"; break;
+            case SUNWELL_AGAMATH_GATE1_OPEN: return "Gate 1 Agamath Open"; break;
+            case SUNWELL_ROHENDOR_GATE2_OPEN: return "Gate 2 Rohendar Open"; break;
+            case SUNWELL_ARCHONISUS_GATE3_OPEN: return "Gate 3 Archonisus Open"; break;
+            default: return "Unknown"; break;
+        }
+    };
+    output += "Sunwell Plateau Gate Phase " + std::to_string(m_sunsReachData.m_gate) + " (" + formatGatePhase(m_sunsReachData.m_gate) + ")" + ":\n";
+    output += "  0. Gate 1 (Agamath): " + std::string(m_sunsReachData.m_gate >= SUNWELL_AGAMATH_GATE1_OPEN ? "Open " : "Closed ") + std::to_string(m_sunsReachData.m_sunsReachReclamationCounters[COUNTER_AGAMATH_THE_FIRST_GATE]) + " (" + std::to_string(m_sunsReachData.GetSunwellGatePercentage(SUNWELL_ALL_GATES_CLOSED)) + "%)\n";
+    output += "  1. Gate 2 (Rohendor): " + std::string(m_sunsReachData.m_gate >= SUNWELL_ROHENDOR_GATE2_OPEN ? "Open " : "Closed ") + std::to_string(m_sunsReachData.m_sunsReachReclamationCounters[COUNTER_ROHENDOR_THE_SECOND_GATE]) +  " (" + std::to_string(m_sunsReachData.GetSunwellGatePercentage(SUNWELL_AGAMATH_GATE1_OPEN)) + "%)\n";
+    output += "  2. Gate 3 (Archonisus): " + std::string(m_sunsReachData.m_gate >= SUNWELL_ARCHONISUS_GATE3_OPEN ? "Open " : "Closed ") + std::to_string(m_sunsReachData.m_sunsReachReclamationCounters[COUNTER_ARCHONISUS_THE_FINAL_GATE]) + " (" + std::to_string(m_sunsReachData.GetSunwellGatePercentage(SUNWELL_ROHENDOR_GATE2_OPEN)) + "%)\n";
+    return output;
+}
+
+std::string SunsReachReclamationData::GetData()
+{
+    std::string output = std::to_string(m_phase) + " " + std::to_string(m_subphaseMask);
+    for (uint32 value : m_sunsReachReclamationCounters)
+        output += " " + std::to_string(value);
+    output += " " + std::to_string(m_gate);
+    for (uint32 value : m_gateCounters)
+        output += " " + std::to_string(value);
+    return output;
+}
+
+uint32 SunsReachReclamationData::GetPhasePercentage(uint32 phase)
+{
+    switch (phase)
+    {
+        case SUNS_REACH_PHASE_1_STAGING_AREA: return uint32((m_sunsReachReclamationCounters[COUNTER_ERRATIC_BEHAVIOR] + m_sunsReachReclamationCounters[COUNTER_SANCTUM_WARDS]) * 100 / (2 * sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX)));
+        case SUNS_REACH_PHASE_2_SANCTUM: return uint32((m_sunsReachReclamationCounters[COUNTER_BATTLE_FOR_THE_SUNS_REACH_ARMORY] + m_sunsReachReclamationCounters[COUNTER_DISTRACTION_AT_THE_DEAD_SCAR]) * 100 / (2 * sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX)));
+        case SUNS_REACH_PHASE_3_ARMORY: return uint32((m_sunsReachReclamationCounters[COUNTER_INTERCEPT_THE_REINFORCEMENTS] + m_sunsReachReclamationCounters[COUNTER_TAKING_THE_HARBOR]) * 100 / (2 * sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX)));
+        default: return 0;
+    }
+}
+
+uint32 SunsReachReclamationData::GetSubPhasePercentage(uint32 subPhase)
+{
+    switch (subPhase)
+    {
+        case SUBPHASE_PORTAL: return uint32(m_sunsReachReclamationCounters[COUNTER_INTERCEPTING_THE_MANA_CELLS] * 100 / sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX));
+        case SUBPHASE_ANVIL: return uint32(m_sunsReachReclamationCounters[COUNTER_MAKING_READY] * 100 / sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX));
+        case SUBPHASE_ALCHEMY_LAB: return uint32(m_sunsReachReclamationCounters[COUNTER_DISCOVERING_YOUR_ROOTS] * 100 / sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX));
+        case SUBPHASE_MONUMENT: return uint32(m_sunsReachReclamationCounters[COUNTER_A_CHARITABLE_DONATION] * 100 / sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX));
+        default: return 0;
+    }
+}
+
+enum WorldStateSunwellGateQuests
+{
+    // Sunwell Plateau PTR progressive release gates
+    QUEST_AGAMATH_THE_FIRST_GATE            = 11551,
+    QUEST_ROHENDOR_THE_SECOND_GATE          = 11552,
+    QUEST_ARCHONISUS_THE_FINAL_GATE         = 11553,
+    COUNTER_MAX_VAL_REQ_SWP_GATES           = 80,
+};
+
+void WorldState::AddSunwellGateProgress(uint32 questId)
+{
+    uint32 counter = 0;
+    int32 worldState = 0;
+    uint32 addedValue = 1;
+    switch (questId)
+    {
+        case QUEST_AGAMATH_THE_FIRST_GATE:
+        case QUEST_ROHENDOR_THE_SECOND_GATE:
+        case QUEST_ARCHONISUS_THE_FINAL_GATE:
+            break;
+        default: return;
+    }
+    switch (m_sunsReachData.m_gate)
+    {
+        case SUNWELL_ALL_GATES_CLOSED: counter = COUNTER_AGAMATH_THE_FIRST_GATE; worldState = WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH; break;
+        case SUNWELL_AGAMATH_GATE1_OPEN: counter = COUNTER_ROHENDOR_THE_SECOND_GATE; worldState = WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH; break;
+        case SUNWELL_ROHENDOR_GATE2_OPEN: counter = COUNTER_ARCHONISUS_THE_FINAL_GATE; worldState = WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH; break;
+        default: return;
+    }
+    uint32 previousValue = m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate);
+    uint32 newValue = 0;
+    m_sunsReachData.m_gateCounters[counter] += addedValue;
+    newValue = m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate);
+    if (previousValue != newValue)
+        SendWorldstateUpdate(m_sunsReachData.m_sunsReachReclamationMutex, m_sunsReachData.m_sunsReachReclamationPlayers, newValue, worldState);
+    bool save = true;
+    if (m_sunsReachData.m_gateCounters[counter] >= COUNTER_MAX_VAL_REQ_SWP_GATES)
+    {
+        save = false;
+        switch (questId)
+        {
+            case QUEST_AGAMATH_THE_FIRST_GATE:
+            {
+                if (m_sunsReachData.m_gate == SUNWELL_ALL_GATES_CLOSED)
+                    HandleSunwellGateTransition(SUNWELL_AGAMATH_GATE1_OPEN);
+                break;
+            }
+            case QUEST_ROHENDOR_THE_SECOND_GATE:
+            {
+                if (m_sunsReachData.m_gate == SUNWELL_AGAMATH_GATE1_OPEN)
+                    HandleSunwellGateTransition(SUNWELL_ROHENDOR_GATE2_OPEN);
+                break;
+            }
+            case QUEST_ARCHONISUS_THE_FINAL_GATE:
+            {
+                if (m_sunsReachData.m_gate == SUNWELL_ROHENDOR_GATE2_OPEN)
+                    HandleSunwellGateTransition(SUNWELL_ARCHONISUS_GATE3_OPEN);
+                break;
+            }
+        }
+    }
+    if (save)
+        Save(SAVE_ID_QUEL_DANAS);
+}
+
+void WorldState::SetSunwellGateCounter(SunwellGateCounters index, uint32 value)
+{
+    m_sunsReachData.m_gateCounters[index] = value;
+}
+
+void WorldState::StartSunwellGatePhase()
+{
+    switch (m_sunsReachData.m_gate)
+    {
+        case SUNWELL_ALL_GATES_CLOSED: sGameEventMgr->StartEvent(GAME_EVENT_SWP_GATES_PHASE_0); break;
+        case SUNWELL_AGAMATH_GATE1_OPEN: sGameEventMgr->StartEvent(GAME_EVENT_SWP_GATES_PHASE_1); break;
+        case SUNWELL_ROHENDOR_GATE2_OPEN: sGameEventMgr->StartEvent(GAME_EVENT_SWP_GATES_PHASE_2); break;
+        case SUNWELL_ARCHONISUS_GATE3_OPEN: sGameEventMgr->StartEvent(GAME_EVENT_SWP_GATES_PHASE_3); break;
+        default: break;
+    }
+}
+
+void WorldState::StopSunwellGatePhase()
+{
+    switch (m_sunsReachData.m_gate)
+    {
+        case SUNWELL_ALL_GATES_CLOSED: sGameEventMgr->StopEvent(GAME_EVENT_SWP_GATES_PHASE_0); break;
+        case SUNWELL_AGAMATH_GATE1_OPEN: sGameEventMgr->StopEvent(GAME_EVENT_SWP_GATES_PHASE_1); break;
+        case SUNWELL_ROHENDOR_GATE2_OPEN: sGameEventMgr->StopEvent(GAME_EVENT_SWP_GATES_PHASE_2); break;
+        case SUNWELL_ARCHONISUS_GATE3_OPEN: sGameEventMgr->StopEvent(GAME_EVENT_SWP_GATES_PHASE_3); break;
+        default: break;
+    }
+}
+
+uint32 SunsReachReclamationData::GetSunwellGatePercentage(uint32 gate)
+{
+    int32 percentage = 0;
+    switch (gate)
+    {
+        case SUNWELL_ALL_GATES_CLOSED:
+            percentage = 100 - int32(m_gateCounters[COUNTER_AGAMATH_THE_FIRST_GATE] * 100 / COUNTER_MAX_VAL_REQ_SWP_GATES);
+            break;
+        case SUNWELL_AGAMATH_GATE1_OPEN:
+            percentage = 100 - int32(m_gateCounters[COUNTER_ROHENDOR_THE_SECOND_GATE] * 100 / COUNTER_MAX_VAL_REQ_SWP_GATES);
+            break;
+        case SUNWELL_ROHENDOR_GATE2_OPEN:
+            percentage = 100 - int32(m_gateCounters[COUNTER_ARCHONISUS_THE_FINAL_GATE] * 100 / COUNTER_MAX_VAL_REQ_SWP_GATES);
+            break;
+        default:
+            return 0;
+    }
+    return percentage < 0 ? 0 : uint32(percentage);
+}
+
+void WorldState::FillInitialWorldStates(ByteBuffer& data, uint32 zoneId, uint32 /*areaId*/)
+{
+    switch (zoneId)
+    {
+        case ZONEID_ISLE_OF_QUEL_DANAS:
+        case ZONEID_MAGISTERS_TERRACE:
+        case ZONEID_SUNWELL_PLATEAU:
+        case ZONEID_SHATTRATH:
+        {
+            // Sunwell Reclamation
+            switch (m_sunsReachData.m_phase)
+            {
+                case SUNS_REACH_PHASE_1_STAGING_AREA:
+                    data << WORLD_STATE_QUEL_DANAS_SANCTUM << m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase);
+                    break;
+                case SUNS_REACH_PHASE_2_SANCTUM:
+                    data << WORLD_STATE_QUEL_DANAS_ARMORY << m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase);
+                    break;
+                case SUNS_REACH_PHASE_3_ARMORY:
+                    data << WORLD_STATE_QUEL_DANAS_HARBOR << m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase);
+                    break;
+                case SUNS_REACH_PHASE_4_HARBOR:
+                    if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALCHEMY_LAB) == 0)
+                        data << WORLD_STATE_QUEL_DANAS_ALCHEMY_LAB << m_sunsReachData.GetSubPhasePercentage(SUBPHASE_ALCHEMY_LAB);
+                    if ((m_sunsReachData.m_subphaseMask & SUBPHASE_MONUMENT) == 0)
+                        data << WORLD_STATE_QUEL_DANAS_MONUMENT << m_sunsReachData.GetSubPhasePercentage(SUBPHASE_MONUMENT);
+                    break;
+            }
+            if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_2_SANCTUM && (m_sunsReachData.m_subphaseMask & SUBPHASE_PORTAL) == 0)
+                data << WORLD_STATE_QUEL_DANAS_PORTAL << m_sunsReachData.GetSubPhasePercentage(SUBPHASE_PORTAL);
+            if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_3_ARMORY && (m_sunsReachData.m_subphaseMask & SUBPHASE_ANVIL) == 0)
+                data << WORLD_STATE_QUEL_DANAS_ANVIL << m_sunsReachData.GetSubPhasePercentage(SUBPHASE_ANVIL);
+            data << WORLD_STATE_QUEL_DANAS_MUSIC << m_sunsReachData.m_phase;
+
+            // Sunwell Gates
+            switch (m_sunsReachData.m_gate)
+            {
+                case SUNWELL_ALL_GATES_CLOSED:
+                    data << WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH << m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate);
+                    break;
+                case SUNWELL_AGAMATH_GATE1_OPEN:
+                    data << WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH << m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate);
+                    break;
+                case SUNWELL_ROHENDOR_GATE2_OPEN:
+                    data << WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH << m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate);
+                    break;
+            }
+            break;
+        }
+    }
+}

src/server/game/World/WorldState.h

@@ -21,6 +21,24 @@
 #include "Player.h"
 #include <atomic>
 
+// TODO: Move these to WorldStateDefines.h
+enum WorldStateWorldStates
+{
+    // Sun's Reach Reclamation
+    WORLD_STATE_QUEL_DANAS_MUSIC                    = 3426,
+    WORLD_STATE_QUEL_DANAS_HARBOR                   = 3238,
+    WORLD_STATE_QUEL_DANAS_ALCHEMY_LAB              = 3223,
+    WORLD_STATE_QUEL_DANAS_ARMORY                   = 3233,
+    WORLD_STATE_QUEL_DANAS_SANCTUM                  = 3244,
+    WORLD_STATE_QUEL_DANAS_PORTAL                   = 3269,
+    WORLD_STATE_QUEL_DANAS_ANVIL                    = 3228,
+    WORLD_STATE_QUEL_DANAS_MONUMENT                 = 3275,
+    // Sunwell Gate
+    WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH       = 3253, // guessed, potentially wrong
+    WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH     = 3255,
+    WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH    = 3257,
+};
+
 enum WorldStateCondition
 {
     WORLD_STATE_CONDITION_TROLLBANES_COMMAND  = 39911,
@@ -56,6 +74,10 @@ enum WorldStateZoneId
     ZONEID_BLOOD_FURNACE        = 3713,
     ZONEID_SHATTERED_HALLS      = 3714,
     ZONEID_MAGTHERIDON_LAIR     = 3836,
+
+    ZONEID_ISLE_OF_QUEL_DANAS   = 4080,
+    ZONEID_MAGISTERS_TERRACE    = 4131,
+    ZONEID_SUNWELL_PLATEAU      = 4075,
 };
 
 enum WorldStateSpells
@@ -64,6 +86,105 @@ enum WorldStateSpells
 
     SPELL_TROLLBANES_COMMAND    = 39911,
     SPELL_NAZGRELS_FAVOR        = 39913,
+
+    SPELL_KIRU_SONG_OF_VICTORY  = 46302,
+};
+
+enum WorldStateSaveIds
+{
+    SAVE_ID_QUEL_DANAS = 20,
+};
+
+enum WorldStateGameEvents
+{
+   // Isle phases
+    GAME_EVENT_QUEL_DANAS_PHASE_1               = 101,
+    GAME_EVENT_QUEL_DANAS_PHASE_2_ONLY          = 102,
+    GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT     = 103,
+    GAME_EVENT_QUEL_DANAS_PHASE_2_NO_PORTAL     = 104,
+    GAME_EVENT_QUEL_DANAS_PHASE_2_PORTAL        = 105,
+    GAME_EVENT_QUEL_DANAS_PHASE_3_ONLY          = 106,
+    GAME_EVENT_QUEL_DANAS_PHASE_3_PERMANENT     = 107,
+    GAME_EVENT_QUEL_DANAS_PHASE_3_NO_ANVIL      = 108,
+    GAME_EVENT_QUEL_DANAS_PHASE_3_ANVIL         = 109,
+    GAME_EVENT_QUEL_DANAS_PHASE_4               = 110,
+    GAME_EVENT_QUEL_DANAS_PHASE_4_NO_MONUMENT   = 111,
+    GAME_EVENT_QUEL_DANAS_PHASE_4_MONUMENT      = 112,
+    GAME_EVENT_QUEL_DANAS_PHASE_4_NO_ALCHEMY_LAB= 113,
+    GAME_EVENT_QUEL_DANAS_PHASE_4_ALCHEMY_LAB   = 114,
+    GAME_EVENT_QUEL_DANAS_PHASE_4_KIRU          = 115,
+    // SWP Phases
+    GAME_EVENT_SWP_GATES_PHASE_0                = 116, // All Gates Closed
+    GAME_EVENT_SWP_GATES_PHASE_1                = 117, // First Gate Open
+    GAME_EVENT_SWP_GATES_PHASE_2                = 118, // Second Gate Open
+    GAME_EVENT_SWP_GATES_PHASE_3                = 119, // All Gates Open
+};
+
+enum SunsReachPhases
+{
+    SUNS_REACH_PHASE_1_STAGING_AREA,
+    SUNS_REACH_PHASE_2_SANCTUM,
+    SUNS_REACH_PHASE_3_ARMORY,
+    SUNS_REACH_PHASE_4_HARBOR,
+};
+
+enum SunsReachSubPhases
+{
+    SUBPHASE_PORTAL         = 0x01,
+    SUBPHASE_ANVIL          = 0x02,
+    SUBPHASE_ALCHEMY_LAB    = 0x04,
+    SUBPHASE_MONUMENT       = 0x08,
+    SUBPHASE_ALL = SUBPHASE_PORTAL | SUBPHASE_ANVIL | SUBPHASE_ALCHEMY_LAB | SUBPHASE_MONUMENT,
+};
+
+enum SunsReachCounters
+{
+    COUNTER_ERRATIC_BEHAVIOR,
+    COUNTER_SANCTUM_WARDS,
+    COUNTER_BATTLE_FOR_THE_SUNS_REACH_ARMORY,
+    COUNTER_DISTRACTION_AT_THE_DEAD_SCAR,
+    COUNTER_INTERCEPTING_THE_MANA_CELLS,
+    COUNTER_INTERCEPT_THE_REINFORCEMENTS,
+    COUNTER_TAKING_THE_HARBOR,
+    COUNTER_MAKING_READY,
+    COUNTER_DISCOVERING_YOUR_ROOTS,
+    COUNTER_A_CHARITABLE_DONATION,
+    COUNTERS_MAX,
+};
+
+enum SunwellGates
+{
+    SUNWELL_ALL_GATES_CLOSED,
+    SUNWELL_AGAMATH_GATE1_OPEN,
+    SUNWELL_ROHENDOR_GATE2_OPEN,
+    SUNWELL_ARCHONISUS_GATE3_OPEN,
+};
+enum SunwellGateCounters
+{
+    COUNTER_AGAMATH_THE_FIRST_GATE,
+    COUNTER_ROHENDOR_THE_SECOND_GATE,
+    COUNTER_ARCHONISUS_THE_FINAL_GATE,
+    COUNTERS_MAX_GATES,
+};
+
+struct SunsReachReclamationData
+{
+    uint32 m_phase;
+    uint32 m_subphaseMask;
+    uint32 m_sunsReachReclamationCounters[COUNTERS_MAX];
+    GuidVector m_sunsReachReclamationPlayers;
+    std::mutex m_sunsReachReclamationMutex;
+    uint32 m_gate;
+    uint32 m_gateCounters[COUNTERS_MAX_GATES];
+    SunsReachReclamationData() : m_phase(SUNS_REACH_PHASE_1_STAGING_AREA), m_subphaseMask(0), m_gate(SUNWELL_ALL_GATES_CLOSED)
+    {
+        memset(m_sunsReachReclamationCounters, 0, sizeof(m_sunsReachReclamationCounters));
+        memset(m_gateCounters, 0, sizeof(m_gateCounters));
+    }
+    std::string GetData();
+    uint32 GetPhasePercentage(uint32 phase);
+    uint32 GetSubPhasePercentage(uint32 subPhase);
+    uint32 GetSunwellGatePercentage(uint32 gate);
 };
 
 // Intended for implementing server wide scripts, note: all behaviour must be safeguarded towards multithreading
@@ -73,13 +194,30 @@ class WorldState
         WorldState();
         virtual ~WorldState();
         static WorldState* instance();
+        void Load();
+        void Save(WorldStateSaveIds saveId);
+        void SaveHelper(std::string& stringToSave, WorldStateSaveIds saveId);
         void HandlePlayerEnterZone(Player* player, WorldStateZoneId zoneId);
         void HandlePlayerLeaveZone(Player* player, WorldStateZoneId zoneId);
         bool IsConditionFulfilled(WorldStateCondition conditionId, WorldStateConditionState state = WORLD_STATE_CONDITION_STATE_NONE) const;
         void HandleConditionStateChange(WorldStateCondition conditionId, WorldStateConditionState state);
         void HandleExternalEvent(WorldStateEvent eventId, uint32 param);
         void Update(uint32 diff);
+        void AddSunwellGateProgress(uint32 questId);
+        void AddSunsReachProgress(uint32 questId);
+        std::string GetSunsReachPrintout();
+        void FillInitialWorldStates(ByteBuffer& data, uint32 zoneId, uint32 areaId);
+        void HandleSunsReachPhaseTransition(uint32 newPhase);
+        void HandleSunsReachSubPhaseTransition(int32 subPhaseMask, bool initial = false);
+        void SetSunsReachCounter(SunsReachCounters index, uint32 value);
+        void HandleSunwellGateTransition(uint32 newGate);
+        void SetSunwellGateCounter(SunwellGateCounters index, uint32 value);
     private:
+        void SendWorldstateUpdate(std::mutex& mutex, GuidVector const& guids, uint32 value, uint32 worldStateId);
+        void StopSunsReachPhase(bool forward);
+        void StartSunsReachPhase(bool initial = false);
+        void StartSunwellGatePhase();
+        void StopSunwellGatePhase();
         void BuffAdalsSongOfBattle();
         void DispelAdalsSongOfBattle();
         uint32 _adalSongOfBattleTimer;
@@ -87,6 +225,7 @@ class WorldState
         void DispelMagtheridonTeam(TeamId team);
         bool _isMagtheridonHeadSpawnedHorde;
         bool _isMagtheridonHeadSpawnedAlliance;
+        SunsReachReclamationData m_sunsReachData;
         std::map<WorldStateCondition, std::atomic<WorldStateConditionState>> _transportStates; // atomic to avoid having to lock
         std::mutex _mutex; // all World State operations are threat unsafe
 };