Add missing break in ApplyInstanceStrategies (#1887 )

Well, I hope nobody has tried Magtheridon lately. It looks like this got inadvertently deleted during the merge.
Hotfix: prevent server crash when whisper 'logout' (#1874 )
2025-11-29 15:58:20 +08:00 · 2025-11-28 19:00:12 +01:00 · 2025-11-24 21:49:55 +01:00 · 2025-11-23 20:45:31 +01:00 · 2025-11-23 10:06:19 +01:00 · 2025-11-21 21:55:55 +01:00
24 changed files with 1356 additions and 276 deletions
--- a/.github/workflows/codestyle_cpp.yml
+++ b/.github/workflows/codestyle_cpp.yml
@@ -5,11 +5,16 @@ on:
      - opened
      - reopened
      - synchronize
+      - ready_for_review
    paths:
      - src/**
      - "!README.md"
      - "!docs/**"

+concurrency:
+  group: "codestyle-cppcheck-${{ github.event.pull_request.number }}"
+  cancel-in-progress: true
+
 jobs:
  triage:
    runs-on: ubuntu-latest
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ We also have a **[Discord server](https://discord.gg/NQm5QShwf9)** where you can

 Supported platforms are Ubuntu, Windows, and macOS. Other Linux distributions may work, but may not receive support. 

-**All `mod-playerbots` installations require a custom branch of AzerothCore: [mod-playerbots/azerothcore-wotlk/tree/Playerbot](https://github.com/mod-playerbots/azerothcore-wotlk/tree/Playerbot).** This branch allows the playerbots module to build and function. Updates from the upstream are implemneted regularly to this branch. Instructions for installing this required branch and this module are provided below.
+**All `mod-playerbots` installations require a custom branch of AzerothCore: [mod-playerbots/azerothcore-wotlk/tree/Playerbot](https://github.com/mod-playerbots/azerothcore-wotlk/tree/Playerbot).** This branch allows the `mod-playerbots` module to build and function. Updates from the upstream are implemented regularly to this branch. Instructions for installing this required branch and this module are provided below.

 ### Cloning the Repositories

@@ -50,7 +50,7 @@ For more information, refer to the [AzerothCore Installation Guide](https://www.

 ### Docker Installation

-Docker installations are considered experimental (unofficial with limited support), and previous Docker experience is recommended. To install the `mod-playerbots` on Docker, first clone the required branch of AzerothCore and this module:
+Docker installations are considered experimental (unofficial with limited support), and previous Docker experience is recommended. To install `mod-playerbots` on Docker, first clone the required branch of AzerothCore and this module:

 ```bash
 git clone https://github.com/mod-playerbots/azerothcore-wotlk.git --branch=Playerbot
@@ -103,7 +103,7 @@ Please click on the "⭐" button to stay up to date and help us gain more visibi

 ## Acknowledgements

-`mod-playerbots` is is based off [ZhengPeiRu21/mod-playerbots](https://github.com/ZhengPeiRu21/mod-playerbots) and [celguar/mangosbot-bots](https://github.com/celguar/mangosbot-bots). We extend our gratitude to [@ZhengPeiRu21](https://github.com/ZhengPeiRu21) and [@celguar](https://github.com/celguar) for the continued efforts in maintaining the module.
+`mod-playerbots` is based on [ZhengPeiRu21/mod-playerbots](https://github.com/ZhengPeiRu21/mod-playerbots) and [celguar/mangosbot-bots](https://github.com/celguar/mangosbot-bots). We extend our gratitude to [@ZhengPeiRu21](https://github.com/ZhengPeiRu21) and [@celguar](https://github.com/celguar) for their continued efforts in maintaining the module.

 Also, a thank you to the many contributors who've helped build this project:

--- a/src/PlayerbotAI.cpp
+++ b/src/PlayerbotAI.cpp
@@ -1477,6 +1477,7 @@ void PlayerbotAI::ApplyInstanceStrategies(uint32 mapId, bool tellMaster)
            break;
        case 544:
            strategyName = "magtheridon";  // Magtheridon's Lair
+            break;
        case 565:
            strategyName = "gruulslair";  // Gruul's Lair
            break;
--- a/src/PlayerbotAIConfig.cpp
+++ b/src/PlayerbotAIConfig.cpp
@@ -725,8 +725,8 @@ std::string const PlayerbotAIConfig::GetTimestampStr()
    //       HH     hour (2 digits 00-23)
    //       MM     minutes (2 digits 00-59)
    //       SS     seconds (2 digits 00-59)
-    char buf[20];
-    snprintf(buf, 20, "%04d-%02d-%02d %02d-%02d-%02d", aTm->tm_year + 1900, aTm->tm_mon + 1, aTm->tm_mday, aTm->tm_hour,
+    char buf[32];
+    snprintf(buf, sizeof(buf), "%04d-%02d-%02d %02d-%02d-%02d", aTm->tm_year + 1900, aTm->tm_mon + 1, aTm->tm_mday, aTm->tm_hour,
             aTm->tm_min, aTm->tm_sec);
    return std::string(buf);
 }
--- a/src/PlayerbotMgr.cpp
+++ b/src/PlayerbotMgr.cpp
@@ -27,7 +27,9 @@
 #include "PlayerbotAIConfig.h"
 #include "PlayerbotDbStore.h"
 #include "PlayerbotFactory.h"
+#include "PlayerbotOperations.h"
 #include "PlayerbotSecurity.h"
+#include "PlayerbotWorldThreadProcessor.h"
 #include "Playerbots.h"
 #include "RandomPlayerbotMgr.h"
 #include "SharedDefines.h"
@@ -85,7 +87,6 @@ public:

 void PlayerbotHolder::AddPlayerBot(ObjectGuid playerGuid, uint32 masterAccountId)
 {
-    // bot is loading
    if (botLoading.find(playerGuid) != botLoading.end())
        return;

@@ -195,7 +196,9 @@ void PlayerbotHolder::HandlePlayerBotLoginCallback(PlayerbotLoginQueryHolder con
    }

    sRandomPlayerbotMgr->OnPlayerLogin(bot);
-    OnBotLogin(bot);
+
+    auto op = std::make_unique<OnBotLoginOperation>(bot->GetGUID(), this);
+    sPlayerbotWorldProcessor->QueueOperation(std::move(op));

    botLoading.erase(holder.GetGuid());
 }
@@ -316,11 +319,9 @@ void PlayerbotHolder::LogoutPlayerBot(ObjectGuid guid)
        if (!botAI)
            return;

-        Group* group = bot->GetGroup();
-        if (group && !bot->InBattleground() && !bot->InBattlegroundQueue() && botAI->HasActivePlayerMaster())
-        {
-            sPlayerbotDbStore->Save(botAI);
-        }
+        // Queue group cleanup operation for world thread
+        auto cleanupOp = std::make_unique<BotLogoutGroupCleanupOperation>(guid);
+        sPlayerbotWorldProcessor->QueueOperation(std::move(cleanupOp));

        LOG_DEBUG("playerbots", "Bot {} logging out", bot->GetName().c_str());
        bot->SaveToDB(false, false);
@@ -549,6 +550,7 @@ void PlayerbotHolder::OnBotLogin(Player* const bot)

    botAI->TellMaster("Hello!", PLAYERBOT_SECURITY_TALK);

+    // Queue group operations for world thread
    if (master && master->GetGroup() && !group)
    {
        Group* mgroup = master->GetGroup();
@@ -556,24 +558,29 @@ void PlayerbotHolder::OnBotLogin(Player* const bot)
        {
            if (!mgroup->isRaidGroup() && !mgroup->isLFGGroup() && !mgroup->isBGGroup() && !mgroup->isBFGroup())
            {
-                mgroup->ConvertToRaid();
+                // Queue ConvertToRaid operation
+                auto convertOp = std::make_unique<GroupConvertToRaidOperation>(master->GetGUID());
+                sPlayerbotWorldProcessor->QueueOperation(std::move(convertOp));
            }
            if (mgroup->isRaidGroup())
            {
-                mgroup->AddMember(bot);
+                // Queue AddMember operation
+                auto addOp = std::make_unique<GroupInviteOperation>(master->GetGUID(), bot->GetGUID());
+                sPlayerbotWorldProcessor->QueueOperation(std::move(addOp));
            }
        }
        else
        {
-            mgroup->AddMember(bot);
+            // Queue AddMember operation
+            auto addOp = std::make_unique<GroupInviteOperation>(master->GetGUID(), bot->GetGUID());
+            sPlayerbotWorldProcessor->QueueOperation(std::move(addOp));
        }
    }
    else if (master && !group)
    {
-        Group* newGroup = new Group();
-        newGroup->Create(master);
-        sGroupMgr->AddGroup(newGroup);
-        newGroup->AddMember(bot);
+        // Queue group creation and AddMember operation
+        auto inviteOp = std::make_unique<GroupInviteOperation>(master->GetGUID(), bot->GetGUID());
+        sPlayerbotWorldProcessor->QueueOperation(std::move(inviteOp));
    }
    // if (master)
    // {
@@ -1602,8 +1609,26 @@ void PlayerbotMgr::OnBotLoginInternal(Player* const bot)

 void PlayerbotMgr::OnPlayerLogin(Player* player)
 {
+    if (!player)
+        return;
+
+    WorldSession* session = player->GetSession();
+    if (!session)
+    {
+        LOG_WARN("playerbots", "Unable to register locale priority for player {} because the session is missing", player->GetName());
+        return;
+    }
+
+    // DB locale (source of bot text translation)
+    LocaleConstant const databaseLocale = session->GetSessionDbLocaleIndex();
+
+    // For bot texts (DB-driven), prefer the database locale with a safe fallback.
+    LocaleConstant usedLocale = databaseLocale;
+    if (usedLocale >= MAX_LOCALES)
+        usedLocale = LOCALE_enUS; // fallback
+
    // set locale priority for bot texts
-    sPlayerbotTextMgr->AddLocalePriority(player->GetSession()->GetSessionDbcLocale());
+    sPlayerbotTextMgr->AddLocalePriority(usedLocale);

    if (sPlayerbotAIConfig->selfBotLevel > 2)
        HandlePlayerbotCommand("self", player);
@@ -1611,7 +1636,7 @@ void PlayerbotMgr::OnPlayerLogin(Player* player)
    if (!sPlayerbotAIConfig->botAutologin)
        return;

-    uint32 accountId = player->GetSession()->GetAccountId();
+    uint32 accountId = session->GetAccountId();
    QueryResult results = CharacterDatabase.Query("SELECT name FROM characters WHERE account = {}", accountId);
    if (results)
    {
--- a/src/PlayerbotOperation.h
+++ b/src/PlayerbotOperation.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_OPERATION_H
+#define _PLAYERBOT_OPERATION_H
+
+#include "Common.h"
+#include "ObjectGuid.h"
+#include <memory>
+
+/**
+ * @brief Base class for thread-unsafe operations that must be executed in the world thread
+ *
+ * PlayerbotOperation represents an operation that needs to be deferred from a map thread
+ * to the world thread for safe execution. Examples include group modifications, LFG operations,
+ * guild operations, etc.
+ *
+ * Thread Safety:
+ * - The constructor and data members must be thread-safe (use copies, not pointers)
+ * - Execute() is called in the world thread and can safely perform thread-unsafe operations
+ * - Subclasses must not store raw pointers to (core/world thread) game object (use ObjectGuid instead)
+ */
+class PlayerbotOperation
+{
+public:
+    virtual ~PlayerbotOperation() = default;
+
+    /**
+     * @brief Execute this operation in the world thread
+     *
+     * This method is called by PlayerbotWorldThreadProcessor::Update() which runs in the world thread.
+     * It's safe to perform any thread-unsafe operation here (Group, LFG, Guild, etc.)
+     *
+     * @return true if operation succeeded, false if it failed
+     */
+    virtual bool Execute() = 0;
+
+    /**
+     * @brief Get the bot GUID this operation is for (optional)
+     *
+     * Used for logging and debugging purposes.
+     *
+     * @return ObjectGuid of the bot, or ObjectGuid::Empty if not applicable
+     */
+    virtual ObjectGuid GetBotGuid() const { return ObjectGuid::Empty; }
+
+    /**
+     * @brief Get the operation priority (higher = more urgent)
+     *
+     * Priority levels:
+     * - 100: Critical (crash prevention, cleanup operations)
+     * - 50: High (player-facing operations like group invites)
+     * - 10: Normal (background operations)
+     * - 0: Low (statistics, logging)
+     *
+     * @return Priority value (0-100)
+     */
+    virtual uint32 GetPriority() const { return 10; }
+
+    /**
+     * @brief Get a human-readable name for this operation
+     *
+     * Used for logging and debugging.
+     *
+     * @return Operation name
+     */
+    virtual std::string GetName() const { return "Unknown Operation"; }
+
+    /**
+     * @brief Check if this operation is still valid
+     *
+     * Called before Execute() to check if the operation should still be executed.
+     * For example, if a bot logged out, group invite operations for that bot can be skipped.
+     *
+     * @return true if operation should be executed, false to skip
+     */
+    virtual bool IsValid() const { return true; }
+};
+
+/**
+ * @brief Comparison operator for priority queue (higher priority first)
+ */
+struct PlayerbotOperationComparator
+{
+    bool operator()(const std::unique_ptr<PlayerbotOperation>& a, const std::unique_ptr<PlayerbotOperation>& b) const
+    {
+        return a->GetPriority() < b->GetPriority();  // Lower priority goes to back of queue
+    }
+};
+
+#endif
--- a/src/PlayerbotOperations.h
+++ b/src/PlayerbotOperations.h
@@ -0,0 +1,500 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_OPERATIONS_H
+#define _PLAYERBOT_OPERATIONS_H
+
+#include "Group.h"
+#include "GroupMgr.h"
+#include "GuildMgr.h"
+#include "ObjectAccessor.h"
+#include "PlayerbotOperation.h"
+#include "Player.h"
+#include "PlayerbotAI.h"
+#include "PlayerbotMgr.h"
+#include "PlayerbotDbStore.h"
+#include "RandomPlayerbotMgr.h"
+
+// Group invite operation
+class GroupInviteOperation : public PlayerbotOperation
+{
+public:
+    GroupInviteOperation(ObjectGuid botGuid, ObjectGuid targetGuid)
+        : m_botGuid(botGuid), m_targetGuid(targetGuid)
+    {
+    }
+
+    bool Execute() override
+    {
+        Player* bot = ObjectAccessor::FindPlayer(m_botGuid);
+        Player* target = ObjectAccessor::FindPlayer(m_targetGuid);
+
+        if (!bot || !target)
+        {
+            LOG_DEBUG("playerbots", "GroupInviteOperation: Bot or target not found");
+            return false;
+        }
+
+        // Check if target is already in a group
+        if (target->GetGroup())
+        {
+            LOG_DEBUG("playerbots", "GroupInviteOperation: Target {} is already in a group", target->GetName());
+            return false;
+        }
+
+        Group* group = bot->GetGroup();
+
+        // Create group if bot doesn't have one
+        if (!group)
+        {
+            group = new Group;
+            if (!group->Create(bot))
+            {
+                delete group;
+                LOG_ERROR("playerbots", "GroupInviteOperation: Failed to create group for bot {}", bot->GetName());
+                return false;
+            }
+            sGroupMgr->AddGroup(group);
+            LOG_DEBUG("playerbots", "GroupInviteOperation: Created new group for bot {}", bot->GetName());
+        }
+
+        // Convert to raid if needed (more than 5 members)
+        if (!group->isRaidGroup() && group->GetMembersCount() >= 5)
+        {
+            group->ConvertToRaid();
+            LOG_DEBUG("playerbots", "GroupInviteOperation: Converted group to raid");
+        }
+
+        // Add member to group
+        if (group->AddMember(target))
+        {
+            LOG_DEBUG("playerbots", "GroupInviteOperation: Successfully added {} to group", target->GetName());
+            return true;
+        }
+        else
+        {
+            LOG_ERROR("playerbots", "GroupInviteOperation: Failed to add {} to group", target->GetName());
+            return false;
+        }
+    }
+
+    ObjectGuid GetBotGuid() const override { return m_botGuid; }
+
+    uint32 GetPriority() const override { return 50; }  // High priority (player-facing)
+
+    std::string GetName() const override { return "GroupInvite"; }
+
+    bool IsValid() const override
+    {
+        // Check if bot still exists and is online
+        Player* bot = ObjectAccessor::FindPlayer(m_botGuid);
+        Player* target = ObjectAccessor::FindPlayer(m_targetGuid);
+        return bot && target;
+    }
+
+private:
+    ObjectGuid m_botGuid;
+    ObjectGuid m_targetGuid;
+};
+
+// Remove member from group
+class GroupRemoveMemberOperation : public PlayerbotOperation
+{
+public:
+    GroupRemoveMemberOperation(ObjectGuid botGuid, ObjectGuid targetGuid)
+        : m_botGuid(botGuid), m_targetGuid(targetGuid)
+    {
+    }
+
+    bool Execute() override
+    {
+        Player* bot = ObjectAccessor::FindPlayer(m_botGuid);
+        Player* target = ObjectAccessor::FindPlayer(m_targetGuid);
+
+        if (!bot || !target)
+            return false;
+
+        Group* group = bot->GetGroup();
+        if (!group)
+        {
+            LOG_DEBUG("playerbots", "GroupRemoveMemberOperation: Bot is not in a group");
+            return false;
+        }
+
+        if (!group->IsMember(target->GetGUID()))
+        {
+            LOG_DEBUG("playerbots", "GroupRemoveMemberOperation: Target is not in bot's group");
+            return false;
+        }
+
+        group->RemoveMember(target->GetGUID());
+        LOG_DEBUG("playerbots", "GroupRemoveMemberOperation: Removed {} from group", target->GetName());
+        return true;
+    }
+
+    ObjectGuid GetBotGuid() const override { return m_botGuid; }
+
+    uint32 GetPriority() const override { return 50; }
+
+    std::string GetName() const override { return "GroupRemoveMember"; }
+
+    bool IsValid() const override
+    {
+        Player* bot = ObjectAccessor::FindPlayer(m_botGuid);
+        return bot != nullptr;
+    }
+
+private:
+    ObjectGuid m_botGuid;
+    ObjectGuid m_targetGuid;
+};
+
+// Convert group to raid
+class GroupConvertToRaidOperation : public PlayerbotOperation
+{
+public:
+    GroupConvertToRaidOperation(ObjectGuid botGuid) : m_botGuid(botGuid) {}
+
+    bool Execute() override
+    {
+        Player* bot = ObjectAccessor::FindPlayer(m_botGuid);
+        if (!bot)
+            return false;
+
+        Group* group = bot->GetGroup();
+        if (!group)
+        {
+            LOG_DEBUG("playerbots", "GroupConvertToRaidOperation: Bot is not in a group");
+            return false;
+        }
+
+        if (group->isRaidGroup())
+        {
+            LOG_DEBUG("playerbots", "GroupConvertToRaidOperation: Group is already a raid");
+            return true;  // Success - already in desired state
+        }
+
+        group->ConvertToRaid();
+        LOG_DEBUG("playerbots", "GroupConvertToRaidOperation: Converted group to raid");
+        return true;
+    }
+
+    ObjectGuid GetBotGuid() const override { return m_botGuid; }
+
+    uint32 GetPriority() const override { return 50; }
+
+    std::string GetName() const override { return "GroupConvertToRaid"; }
+
+    bool IsValid() const override
+    {
+        Player* bot = ObjectAccessor::FindPlayer(m_botGuid);
+        return bot != nullptr;
+    }
+
+private:
+    ObjectGuid m_botGuid;
+};
+
+// Set group leader
+class GroupSetLeaderOperation : public PlayerbotOperation
+{
+public:
+    GroupSetLeaderOperation(ObjectGuid botGuid, ObjectGuid newLeaderGuid)
+        : m_botGuid(botGuid), m_newLeaderGuid(newLeaderGuid)
+    {
+    }
+
+    bool Execute() override
+    {
+        Player* bot = ObjectAccessor::FindPlayer(m_botGuid);
+        Player* newLeader = ObjectAccessor::FindPlayer(m_newLeaderGuid);
+
+        if (!bot || !newLeader)
+            return false;
+
+        Group* group = bot->GetGroup();
+        if (!group)
+        {
+            LOG_DEBUG("playerbots", "GroupSetLeaderOperation: Bot is not in a group");
+            return false;
+        }
+
+        if (!group->IsMember(newLeader->GetGUID()))
+        {
+            LOG_DEBUG("playerbots", "GroupSetLeaderOperation: New leader is not in the group");
+            return false;
+        }
+
+        group->ChangeLeader(newLeader->GetGUID());
+        LOG_DEBUG("playerbots", "GroupSetLeaderOperation: Changed leader to {}", newLeader->GetName());
+        return true;
+    }
+
+    ObjectGuid GetBotGuid() const override { return m_botGuid; }
+
+    uint32 GetPriority() const override { return 50; }
+
+    std::string GetName() const override { return "GroupSetLeader"; }
+
+    bool IsValid() const override
+    {
+        Player* bot = ObjectAccessor::FindPlayer(m_botGuid);
+        Player* newLeader = ObjectAccessor::FindPlayer(m_newLeaderGuid);
+        return bot && newLeader;
+    }
+
+private:
+    ObjectGuid m_botGuid;
+    ObjectGuid m_newLeaderGuid;
+};
+
+// Form arena group
+class ArenaGroupFormationOperation : public PlayerbotOperation
+{
+public:
+    ArenaGroupFormationOperation(ObjectGuid leaderGuid, std::vector<ObjectGuid> memberGuids,
+                                 uint32 requiredSize, uint32 arenaTeamId, std::string arenaTeamName)
+        : m_leaderGuid(leaderGuid), m_memberGuids(memberGuids),
+          m_requiredSize(requiredSize), m_arenaTeamId(arenaTeamId), m_arenaTeamName(arenaTeamName)
+    {
+    }
+
+    bool Execute() override
+    {
+        Player* leader = ObjectAccessor::FindPlayer(m_leaderGuid);
+        if (!leader)
+        {
+            LOG_ERROR("playerbots", "ArenaGroupFormationOperation: Leader not found");
+            return false;
+        }
+
+        // Step 1: Remove all members from their existing groups
+        for (const ObjectGuid& memberGuid : m_memberGuids)
+        {
+            Player* member = ObjectAccessor::FindPlayer(memberGuid);
+            if (!member)
+                continue;
+
+            Group* memberGroup = member->GetGroup();
+            if (memberGroup)
+            {
+                memberGroup->RemoveMember(memberGuid);
+                LOG_DEBUG("playerbots", "ArenaGroupFormationOperation: Removed {} from their existing group",
+                         member->GetName());
+            }
+        }
+
+        // Step 2: Disband leader's existing group
+        Group* leaderGroup = leader->GetGroup();
+        if (leaderGroup)
+        {
+            leaderGroup->Disband(true);
+            LOG_DEBUG("playerbots", "ArenaGroupFormationOperation: Disbanded leader's existing group");
+        }
+
+        // Step 3: Create new group with leader
+        Group* newGroup = new Group();
+        if (!newGroup->Create(leader))
+        {
+            delete newGroup;
+            LOG_ERROR("playerbots", "ArenaGroupFormationOperation: Failed to create arena group for leader {}",
+                     leader->GetName());
+            return false;
+        }
+
+        sGroupMgr->AddGroup(newGroup);
+        LOG_DEBUG("playerbots", "ArenaGroupFormationOperation: Created new arena group with leader {}",
+                 leader->GetName());
+
+        // Step 4: Add members to the new group
+        uint32 addedMembers = 0;
+        for (const ObjectGuid& memberGuid : m_memberGuids)
+        {
+            Player* member = ObjectAccessor::FindPlayer(memberGuid);
+            if (!member)
+            {
+                LOG_DEBUG("playerbots", "ArenaGroupFormationOperation: Member {} not found, skipping",
+                         memberGuid.ToString());
+                continue;
+            }
+
+            if (member->GetLevel() < 70)
+            {
+                LOG_DEBUG("playerbots", "ArenaGroupFormationOperation: Member {} is below level 70, skipping",
+                         member->GetName());
+                continue;
+            }
+
+            if (newGroup->AddMember(member))
+            {
+                addedMembers++;
+                LOG_DEBUG("playerbots", "ArenaGroupFormationOperation: Added {} to arena group",
+                         member->GetName());
+            }
+            else
+                LOG_ERROR("playerbots", "ArenaGroupFormationOperation: Failed to add {} to arena group",
+                         member->GetName());
+        }
+
+        if (addedMembers == 0)
+        {
+            LOG_ERROR("playerbots", "ArenaGroupFormationOperation: No members were added to the arena group");
+            newGroup->Disband();
+            return false;
+        }
+
+        // Step 5: Teleport members to leader and reset AI
+        for (const ObjectGuid& memberGuid : m_memberGuids)
+        {
+            Player* member = ObjectAccessor::FindPlayer(memberGuid);
+            if (!member || !newGroup->IsMember(memberGuid))
+                continue;
+
+            PlayerbotAI* memberBotAI = sPlayerbotsMgr->GetPlayerbotAI(member);
+            if (memberBotAI)
+                memberBotAI->Reset();
+
+            member->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_TELEPORTED | AURA_INTERRUPT_FLAG_CHANGE_MAP);
+            member->TeleportTo(leader->GetMapId(), leader->GetPositionX(), leader->GetPositionY(),
+                              leader->GetPositionZ(), 0);
+
+            LOG_DEBUG("playerbots", "ArenaGroupFormationOperation: Teleported {} to leader", member->GetName());
+        }
+
+        // Check if we have enough members
+        if (newGroup->GetMembersCount() < m_requiredSize)
+        {
+            LOG_INFO("playerbots", "Team #{} <{}> Group is not ready for match (not enough members: {}/{})",
+                    m_arenaTeamId, m_arenaTeamName, newGroup->GetMembersCount(), m_requiredSize);
+            newGroup->Disband();
+            return false;
+        }
+
+        LOG_INFO("playerbots", "Team #{} <{}> Group is ready for match with {} members",
+                m_arenaTeamId, m_arenaTeamName, newGroup->GetMembersCount());
+        return true;
+    }
+
+    ObjectGuid GetBotGuid() const override { return m_leaderGuid; }
+
+    uint32 GetPriority() const override { return 60; }  // Very high priority (arena/BG operations)
+
+    std::string GetName() const override { return "ArenaGroupFormation"; }
+
+    bool IsValid() const override
+    {
+        Player* leader = ObjectAccessor::FindPlayer(m_leaderGuid);
+        return leader != nullptr;
+    }
+
+private:
+    ObjectGuid m_leaderGuid;
+    std::vector<ObjectGuid> m_memberGuids;
+    uint32 m_requiredSize;
+    uint32 m_arenaTeamId;
+    std::string m_arenaTeamName;
+};
+
+// Bot logout group cleanup operation
+class BotLogoutGroupCleanupOperation : public PlayerbotOperation
+{
+public:
+    BotLogoutGroupCleanupOperation(ObjectGuid botGuid) : m_botGuid(botGuid) {}
+
+    bool Execute() override
+    {
+        Player* bot = ObjectAccessor::FindPlayer(m_botGuid);
+        if (!bot)
+            return false;
+
+        PlayerbotAI* botAI = sPlayerbotsMgr->GetPlayerbotAI(bot);
+        if (!botAI)
+            return false;
+
+        Group* group = bot->GetGroup();
+        if (group && !bot->InBattleground() && !bot->InBattlegroundQueue() && botAI->HasActivePlayerMaster())
+            sPlayerbotDbStore->Save(botAI);
+
+        return true;
+    }
+
+    ObjectGuid GetBotGuid() const override { return m_botGuid; }
+    uint32 GetPriority() const override { return 70; }
+    std::string GetName() const override { return "BotLogoutGroupCleanup"; }
+
+    bool IsValid() const override
+    {
+        Player* bot = ObjectAccessor::FindPlayer(m_botGuid);
+        return bot != nullptr;
+    }
+
+private:
+    ObjectGuid m_botGuid;
+};
+
+// Add player bot operation (for logging in bots from map threads)
+class AddPlayerBotOperation : public PlayerbotOperation
+{
+public:
+    AddPlayerBotOperation(ObjectGuid botGuid, uint32 masterAccountId)
+        : m_botGuid(botGuid), m_masterAccountId(masterAccountId)
+    {
+    }
+
+    bool Execute() override
+    {
+        sRandomPlayerbotMgr->AddPlayerBot(m_botGuid, m_masterAccountId);
+        return true;
+    }
+
+    ObjectGuid GetBotGuid() const override { return m_botGuid; }
+
+    uint32 GetPriority() const override { return 50; }  // High priority
+
+    std::string GetName() const override { return "AddPlayerBot"; }
+
+    bool IsValid() const override
+    {
+        return !ObjectAccessor::FindConnectedPlayer(m_botGuid);
+    }
+
+private:
+    ObjectGuid m_botGuid;
+    uint32 m_masterAccountId;
+};
+
+class OnBotLoginOperation : public PlayerbotOperation
+{
+public:
+    OnBotLoginOperation(ObjectGuid botGuid, PlayerbotHolder* holder)
+        : m_botGuid(botGuid), m_holder(holder)
+    {
+    }
+
+    bool Execute() override
+    {
+        Player* bot = ObjectAccessor::FindConnectedPlayer(m_botGuid);
+        if (!bot || !m_holder)
+            return false;
+
+        m_holder->OnBotLogin(bot);
+        return true;
+    }
+
+    ObjectGuid GetBotGuid() const override { return m_botGuid; }
+    uint32 GetPriority() const override { return 100; }
+    std::string GetName() const override { return "OnBotLogin"; }
+
+    bool IsValid() const override
+    {
+        return ObjectAccessor::FindConnectedPlayer(m_botGuid) != nullptr;
+    }
+
+private:
+    ObjectGuid m_botGuid;
+    PlayerbotHolder* m_holder;
+};
+
+#endif
--- a/src/PlayerbotTextMgr.cpp
+++ b/src/PlayerbotTextMgr.cpp
@@ -190,26 +190,29 @@ bool PlayerbotTextMgr::GetBotText(std::string name, std::string& text, std::map<

 void PlayerbotTextMgr::AddLocalePriority(uint32 locale)
 {
-    if (!locale)
+    if (locale >= MAX_LOCALES)
+    {
+        LOG_WARN("playerbots", "Ignoring locale {} for bot texts because it exceeds MAX_LOCALES ({})", locale, MAX_LOCALES - 1);
        return;
+    }

    botTextLocalePriority[locale]++;
 }

 uint32 PlayerbotTextMgr::GetLocalePriority()
 {
-    uint32 topLocale = 0;
-
    // if no real players online, reset top locale
-    if (!sWorldSessionMgr->GetActiveSessionCount())
+    uint32 const activeSessions = sWorldSessionMgr->GetActiveSessionCount();
+    if (!activeSessions)
    {
        ResetLocalePriority();
        return 0;
    }

+    uint32 topLocale = 0;
    for (uint8 i = 0; i < MAX_LOCALES; ++i)
    {
-        if (botTextLocalePriority[i] > topLocale)
+        if (botTextLocalePriority[i] > botTextLocalePriority[topLocale])
            topLocale = i;
    }

--- a/src/PlayerbotWorldThreadProcessor.cpp
+++ b/src/PlayerbotWorldThreadProcessor.cpp
@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#include "PlayerbotWorldThreadProcessor.h"
+
+#include "Log.h"
+#include "PlayerbotAIConfig.h"
+
+#include <algorithm>
+
+PlayerbotWorldThreadProcessor::PlayerbotWorldThreadProcessor()
+    : m_enabled(true), m_maxQueueSize(10000), m_batchSize(100), m_queueWarningThreshold(80),
+      m_timeSinceLastUpdate(0), m_updateInterval(50)  // Process at least every 50ms
+{
+    LOG_INFO("playerbots", "PlayerbotWorldThreadProcessor initialized");
+}
+
+PlayerbotWorldThreadProcessor::~PlayerbotWorldThreadProcessor() { ClearQueue(); }
+
+PlayerbotWorldThreadProcessor* PlayerbotWorldThreadProcessor::instance()
+{
+    static PlayerbotWorldThreadProcessor instance;
+    return &instance;
+}
+
+void PlayerbotWorldThreadProcessor::Update(uint32 diff)
+{
+    if (!m_enabled)
+        return;
+
+    // Accumulate time
+    m_timeSinceLastUpdate += diff;
+
+    // Don't process too frequently to reduce overhead
+    if (m_timeSinceLastUpdate < m_updateInterval)
+        return;
+
+    m_timeSinceLastUpdate = 0;
+
+    // Check queue health (warn if getting full)
+    CheckQueueHealth();
+
+    // Process a batch of operations
+    ProcessBatch();
+}
+
+bool PlayerbotWorldThreadProcessor::QueueOperation(std::unique_ptr<PlayerbotOperation> operation)
+{
+    if (!operation)
+    {
+        LOG_ERROR("playerbots", "Attempted to queue null operation");
+        return false;
+    }
+
+    std::lock_guard<std::mutex> lock(m_queueMutex);
+
+    // Check if queue is full
+    if (m_operationQueue.size() >= m_maxQueueSize)
+    {
+        LOG_ERROR("playerbots",
+                  "PlayerbotWorldThreadProcessor queue is full ({} operations). Dropping operation: {}",
+                  m_maxQueueSize, operation->GetName());
+
+        std::lock_guard<std::mutex> statsLock(m_statsMutex);
+        m_stats.totalOperationsSkipped++;
+        return false;
+    }
+
+    // Queue the operation
+    m_operationQueue.push(std::move(operation));
+
+    // Update statistics
+    {
+        std::lock_guard<std::mutex> statsLock(m_statsMutex);
+        m_stats.currentQueueSize = static_cast<uint32>(m_operationQueue.size());
+        m_stats.maxQueueSize = std::max(m_stats.maxQueueSize, m_stats.currentQueueSize);
+    }
+
+    return true;
+}
+
+void PlayerbotWorldThreadProcessor::ProcessBatch()
+{
+    // Extract a batch of operations from the queue
+    std::vector<std::unique_ptr<PlayerbotOperation>> batch;
+    batch.reserve(m_batchSize);
+
+    {
+        std::lock_guard<std::mutex> lock(m_queueMutex);
+
+        // Extract up to batchSize operations
+        while (!m_operationQueue.empty() && batch.size() < m_batchSize)
+        {
+            batch.push_back(std::move(m_operationQueue.front()));
+            m_operationQueue.pop();
+        }
+
+        // Update current queue size stat
+        std::lock_guard<std::mutex> statsLock(m_statsMutex);
+        m_stats.currentQueueSize = static_cast<uint32>(m_operationQueue.size());
+    }
+
+    // Execute operations outside of lock to avoid blocking queue
+    uint32 totalExecutionTime = 0;
+    for (auto& operation : batch)
+    {
+        if (!operation)
+            continue;
+
+        try
+        {
+            // Check if operation is still valid
+            if (!operation->IsValid())
+            {
+                LOG_DEBUG("playerbots", "Skipping invalid operation: {}", operation->GetName());
+
+                std::lock_guard<std::mutex> statsLock(m_statsMutex);
+                m_stats.totalOperationsSkipped++;
+                continue;
+            }
+
+            // Time the execution
+            uint32 startTime = getMSTime();
+
+            // Execute the operation
+            bool success = operation->Execute();
+
+            uint32 executionTime = GetMSTimeDiffToNow(startTime);
+            totalExecutionTime += executionTime;
+
+            // Log slow operations
+            if (executionTime > 100)
+                LOG_WARN("playerbots", "Slow operation: {} took {}ms", operation->GetName(), executionTime);
+
+            // Update statistics
+            std::lock_guard<std::mutex> statsLock(m_statsMutex);
+            if (success)
+                m_stats.totalOperationsProcessed++;
+            else
+            {
+                m_stats.totalOperationsFailed++;
+                LOG_DEBUG("playerbots", "Operation failed: {}", operation->GetName());
+            }
+        }
+        catch (std::exception const& e)
+        {
+            LOG_ERROR("playerbots", "Exception in operation {}: {}", operation->GetName(), e.what());
+
+            std::lock_guard<std::mutex> statsLock(m_statsMutex);
+            m_stats.totalOperationsFailed++;
+        }
+        catch (...)
+        {
+            LOG_ERROR("playerbots", "Unknown exception in operation {}", operation->GetName());
+
+            std::lock_guard<std::mutex> statsLock(m_statsMutex);
+            m_stats.totalOperationsFailed++;
+        }
+    }
+
+    // Update average execution time
+    if (!batch.empty())
+    {
+        std::lock_guard<std::mutex> statsLock(m_statsMutex);
+        uint32 avgTime = totalExecutionTime / static_cast<uint32>(batch.size());
+        // Exponential moving average
+        m_stats.averageExecutionTimeMs =
+            (m_stats.averageExecutionTimeMs * 9 + avgTime) / 10;  // 90% old, 10% new
+    }
+}
+
+void PlayerbotWorldThreadProcessor::CheckQueueHealth()
+{
+    uint32 queueSize = GetQueueSize();
+    uint32 threshold = (m_maxQueueSize * m_queueWarningThreshold) / 100;
+
+    if (queueSize >= threshold)
+    {
+        LOG_WARN("playerbots",
+                 "PlayerbotWorldThreadProcessor queue is {}% full ({}/{}). "
+                 "Consider increasing update frequency or batch size.",
+                 (queueSize * 100) / m_maxQueueSize, queueSize, m_maxQueueSize);
+    }
+}
+
+uint32 PlayerbotWorldThreadProcessor::GetQueueSize() const
+{
+    std::lock_guard<std::mutex> lock(m_queueMutex);
+    return static_cast<uint32>(m_operationQueue.size());
+}
+
+void PlayerbotWorldThreadProcessor::ClearQueue()
+{
+    std::lock_guard<std::mutex> lock(m_queueMutex);
+
+    uint32 cleared = static_cast<uint32>(m_operationQueue.size());
+    if (cleared > 0)
+        LOG_INFO("playerbots", "Clearing {} queued operations", cleared);
+
+    // Clear the queue
+    while (!m_operationQueue.empty())
+    {
+        m_operationQueue.pop();
+    }
+
+    // Reset queue size stat
+    std::lock_guard<std::mutex> statsLock(m_statsMutex);
+    m_stats.currentQueueSize = 0;
+}
+
+PlayerbotWorldThreadProcessor::Statistics PlayerbotWorldThreadProcessor::GetStatistics() const
+{
+    std::lock_guard<std::mutex> statsLock(m_statsMutex);
+    return m_stats;  // Return a copy
+}
--- a/src/PlayerbotWorldThreadProcessor.h
+++ b/src/PlayerbotWorldThreadProcessor.h
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_WORLD_THREAD_PROCESSOR_H
+#define _PLAYERBOT_WORLD_THREAD_PROCESSOR_H
+
+#include "Common.h"
+#include "PlayerbotOperation.h"
+
+#include <memory>
+#include <mutex>
+#include <queue>
+
+/**
+ * @brief Processes thread-unsafe bot operations in the world thread
+ *
+ * The PlayerbotWorldThreadProcessor manages a queue of operations that must be executed
+ * in the world thread rather than map threads. This ensures thread safety for operations
+ * like group modifications, LFG, guilds, battlegrounds, etc.
+ *
+ * Architecture:
+ * - Map threads queue operations via QueueOperation()
+ * - World thread processes operations via Update() (called from WorldScript::OnUpdate)
+ * - Operations are processed in priority order
+ * - Thread-safe queue protected by mutex
+ *
+ * Usage:
+ *   auto op = std::make_unique<MyOperation>(botGuid, params);
+ *   sPlayerbotWorldProcessor->QueueOperation(std::move(op));
+ */
+class PlayerbotWorldThreadProcessor
+{
+public:
+    PlayerbotWorldThreadProcessor();
+    ~PlayerbotWorldThreadProcessor();
+
+    static PlayerbotWorldThreadProcessor* instance();
+
+    /**
+     * @brief Update and process queued operations (called from world thread)
+     *
+     * This method should be called from WorldScript::OnUpdate hook, which runs in the world thread.
+     * It processes a batch of queued operations.
+     *
+     * @param diff Time since last update in milliseconds
+     */
+    void Update(uint32 diff);
+
+    /**
+     * @brief Queue an operation for execution in the world thread
+     *
+     * Thread-safe method that can be called from any thread (typically map threads).
+     * The operation will be executed later during Update().
+     *
+     * @param operation Unique pointer to the operation (ownership is transferred)
+     * @return true if operation was queued, false if queue is full
+     */
+    bool QueueOperation(std::unique_ptr<PlayerbotOperation> operation);
+
+    /**
+     * @brief Get current queue size
+     *
+     * Thread-safe method for monitoring queue size.
+     *
+     * @return Number of operations waiting to be processed
+     */
+    uint32 GetQueueSize() const;
+
+    /**
+     * @brief Clear all queued operations
+     *
+     * Used during shutdown or emergency situations.
+     */
+    void ClearQueue();
+
+    /**
+     * @brief Get statistics about operation processing
+     */
+    struct Statistics
+    {
+        uint64 totalOperationsProcessed = 0;
+        uint64 totalOperationsFailed = 0;
+        uint64 totalOperationsSkipped = 0;
+        uint32 currentQueueSize = 0;
+        uint32 maxQueueSize = 0;
+        uint32 averageExecutionTimeMs = 0;
+    };
+
+    Statistics GetStatistics() const;
+
+    /**
+     * @brief Enable/disable operation processing
+     *
+     * When disabled, operations are still queued but not processed.
+     * Useful for testing or temporary suspension.
+     *
+     * @param enabled true to enable processing, false to disable
+     */
+    void SetEnabled(bool enabled) { m_enabled = enabled; }
+
+    bool IsEnabled() const { return m_enabled; }
+
+private:
+    /**
+     * @brief Process a single batch of operations
+     *
+     * Extracts operations from queue and executes them.
+     * Called internally by Update().
+     */
+    void ProcessBatch();
+
+    /**
+     * @brief Check if queue is approaching capacity
+     *
+     * Logs warning if queue is getting full.
+     */
+    void CheckQueueHealth();
+
+    // Thread-safe queue
+    mutable std::mutex m_queueMutex;
+    std::queue<std::unique_ptr<PlayerbotOperation>> m_operationQueue;
+
+    // Configuration
+    bool m_enabled;
+    uint32 m_maxQueueSize;           // Maximum operations in queue
+    uint32 m_batchSize;              // Operations to process per Update()
+    uint32 m_queueWarningThreshold;  // Warn when queue reaches this percentage
+
+    // Statistics
+    mutable std::mutex m_statsMutex;
+    Statistics m_stats;
+
+    // Timing
+    uint32 m_timeSinceLastUpdate;
+    uint32 m_updateInterval;  // Minimum ms between updates
+};
+
+#define sPlayerbotWorldProcessor PlayerbotWorldThreadProcessor::instance()
+
+#endif
--- a/src/Playerbots.cpp
+++ b/src/Playerbots.cpp
@@ -25,6 +25,7 @@
 #include "Metric.h"
 #include "PlayerScript.h"
 #include "PlayerbotAIConfig.h"
+#include "PlayerbotWorldThreadProcessor.h"
 #include "RandomPlayerbotMgr.h"
 #include "ScriptMgr.h"
 #include "cs_playerbots.h"
@@ -81,12 +82,12 @@ public:
    PlayerbotsPlayerScript() : PlayerScript("PlayerbotsPlayerScript", {
        PLAYERHOOK_ON_LOGIN,
        PLAYERHOOK_ON_AFTER_UPDATE,
-        PLAYERHOOK_ON_CHAT,
-        PLAYERHOOK_ON_CHAT_WITH_CHANNEL,
-        PLAYERHOOK_ON_CHAT_WITH_GROUP,
        PLAYERHOOK_ON_BEFORE_CRITERIA_PROGRESS,
        PLAYERHOOK_ON_BEFORE_ACHI_COMPLETE,
        PLAYERHOOK_CAN_PLAYER_USE_PRIVATE_CHAT,
+        PLAYERHOOK_CAN_PLAYER_USE_GROUP_CHAT,
+        PLAYERHOOK_CAN_PLAYER_USE_GUILD_CHAT,
+        PLAYERHOOK_CAN_PLAYER_USE_CHANNEL_CHAT,
        PLAYERHOOK_ON_GIVE_EXP,
        PLAYERHOOK_ON_BEFORE_TELEPORT
    }) {}
@@ -163,14 +164,17 @@ public:
            {
                botAI->HandleCommand(type, msg, player);

-                return false;
+                // hotfix; otherwise the server will crash when whispering logout
+                // https://github.com/mod-playerbots/mod-playerbots/pull/1838
+                // TODO: find the root cause and solve it. (does not happen in party chat)
+                if (msg == "logout")
+                    return false;
            }
        }
-
        return true;
    }

-    void OnPlayerChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Group* group) override
+    bool OnPlayerCanUseChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Group* group) override
    {
        for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
        {
@@ -182,9 +186,10 @@ public:
                }
            }
        }
+        return true;
    }

-    void OnPlayerChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg) override
+    bool OnPlayerCanUseChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Guild* guild) override
    {
        if (type == CHAT_MSG_GUILD)
        {
@@ -203,9 +208,10 @@ public:
                }
            }
        }
+        return true;
    }

-    void OnPlayerChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Channel* channel) override
+    bool OnPlayerCanUseChat(Player* player, uint32 type, uint32 /*lang*/, std::string& msg, Channel* channel) override
    {
        if (PlayerbotMgr* playerbotMgr = GET_PLAYERBOT_MGR(player))
        {
@@ -216,6 +222,7 @@ public:
        }

        sRandomPlayerbotMgr->HandleCommand(type, msg, player);
+        return true;
    }

    bool OnPlayerBeforeAchievementComplete(Player* player, AchievementEntry const* achievement) override
@@ -300,7 +307,8 @@ class PlayerbotsWorldScript : public WorldScript
 {
 public:
    PlayerbotsWorldScript() : WorldScript("PlayerbotsWorldScript", {
-        WORLDHOOK_ON_BEFORE_WORLD_INITIALIZED
+        WORLDHOOK_ON_BEFORE_WORLD_INITIALIZED,
+        WORLDHOOK_ON_UPDATE
    }) {}

    void OnBeforeWorldInitialized() override
@@ -329,6 +337,13 @@ public:

        LOG_INFO("server.loading", ">> Loaded playerbots config in {} ms", GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
+        LOG_INFO("server.loading", "Playerbots World Thread Processor initialized");
+    }
+
+    void OnUpdate(uint32 diff) override
+    {
+        sPlayerbotWorldProcessor->Update(diff);
+        sRandomPlayerbotMgr->UpdateAI(diff);  // World thread only
    }
 };

@@ -390,8 +405,7 @@ public:

    void OnPlayerbotUpdate(uint32 diff) override
    {
-        sRandomPlayerbotMgr->UpdateAI(diff);
-        sRandomPlayerbotMgr->UpdateSessions();
+        sRandomPlayerbotMgr->UpdateSessions();  // Per-bot updates only
    }

    void OnPlayerbotUpdateSessions(Player* player) override
--- a/src/strategy/actions/AreaTriggerAction.cpp
+++ b/src/strategy/actions/AreaTriggerAction.cpp
@@ -40,7 +40,14 @@ bool ReachAreaTriggerAction::Execute(Event event)
        return true;
    }

-    bot->GetMotionMaster()->MovePoint(at->map, at->x, at->y, at->z);
+    bot->GetMotionMaster()->MovePoint(
+        /*id*/ at->map,
+        /*coords*/ at->x, at->y, at->z,
+        /*forcedMovement*/ FORCED_MOVEMENT_NONE,
+        /*speed*/ 0.0f,             // default speed (not handled here)
+        /*orientation*/ 0.0f,       // keep current orientation of bot
+        /*generatePath*/ true,      // true => terrain path (2d mmap); false => straight spline (3d vmap)
+        /*forceDestination*/ false);

    float distance = bot->GetDistance(at->x, at->y, at->z);
    float delay = 1000.0f * distance / bot->GetSpeed(MOVE_RUN) + sPlayerbotAIConfig->reactDelay;
--- a/src/strategy/actions/CheckMountStateAction.cpp
+++ b/src/strategy/actions/CheckMountStateAction.cpp
@@ -81,7 +81,7 @@ bool CheckMountStateAction::isUseful()
    // to mostly be an issue in tunnels of WSG and AV)
    float posZ = bot->GetPositionZ();
    float groundLevel = bot->GetMapWaterOrGroundLevel(bot->GetPositionX(), bot->GetPositionY(), posZ);
-    if (!bot->IsMounted() && posZ < groundLevel)
+    if (!bot->IsMounted() && !bot->HasWaterWalkAura() && posZ < groundLevel)
        return false;

    // Not useful when bot does not have mount strat and is not currently mounted
--- a/src/strategy/actions/GuildManagementActions.cpp
+++ b/src/strategy/actions/GuildManagementActions.cpp
@@ -58,6 +58,14 @@ Player* GuidManageAction::GetPlayer(Event event)
    return nullptr;
 }

+void GuidManageAction::SendPacket(WorldPacket const& packet)
+{
+    // make a heap copy because QueuePacket takes ownership
+    WorldPacket* data = new WorldPacket(packet);
+
+    bot->GetSession()->QueuePacket(data);
+}
+
 bool GuidManageAction::Execute(Event event)
 {
    Player* player = GetPlayer(event);
@@ -84,12 +92,6 @@ bool GuildInviteAction::isUseful()
    return bot->GetGuildId() && sGuildMgr->GetGuildById(bot->GetGuildId())->HasRankRight(bot, GR_RIGHT_INVITE);
 }

-void GuildInviteAction::SendPacket(WorldPacket packet)
-{
-    WorldPackets::Guild::GuildInviteByName data = WorldPacket(packet);
-    bot->GetSession()->HandleGuildInviteOpcode(data);
-}
-
 bool GuildInviteAction::PlayerIsValid(Player* member)
 {
    return !member->GetGuildId() && (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) ||
@@ -101,12 +103,6 @@ bool GuildPromoteAction::isUseful()
    return bot->GetGuildId() && sGuildMgr->GetGuildById(bot->GetGuildId())->HasRankRight(bot, GR_RIGHT_PROMOTE);
 }

-void GuildPromoteAction::SendPacket(WorldPacket packet)
-{
-    WorldPackets::Guild::GuildPromoteMember data = WorldPacket(packet);
-    bot->GetSession()->HandleGuildPromoteOpcode(data);
-}
-
 bool GuildPromoteAction::PlayerIsValid(Player* member)
 {
    return member->GetGuildId() == bot->GetGuildId() && GetRankId(bot) < GetRankId(member) - 1;
@@ -117,12 +113,6 @@ bool GuildDemoteAction::isUseful()
    return bot->GetGuildId() && sGuildMgr->GetGuildById(bot->GetGuildId())->HasRankRight(bot, GR_RIGHT_DEMOTE);
 }

-void GuildDemoteAction::SendPacket(WorldPacket packet)
-{
-    WorldPackets::Guild::GuildDemoteMember data = WorldPacket(packet);
-    bot->GetSession()->HandleGuildDemoteOpcode(data);
-}
-
 bool GuildDemoteAction::PlayerIsValid(Player* member)
 {
    return member->GetGuildId() == bot->GetGuildId() && GetRankId(bot) < GetRankId(member);
@@ -133,12 +123,6 @@ bool GuildRemoveAction::isUseful()
    return bot->GetGuildId() && sGuildMgr->GetGuildById(bot->GetGuildId())->HasRankRight(bot, GR_RIGHT_REMOVE);
 }

-void GuildRemoveAction::SendPacket(WorldPacket packet)
-{
-    WorldPackets::Guild::GuildOfficerRemoveMember data = WorldPacket(packet);
-    bot->GetSession()->HandleGuildRemoveOpcode(data);
-}
-
 bool GuildRemoveAction::PlayerIsValid(Player* member)
 {
    return member->GetGuildId() == bot->GetGuildId() && GetRankId(bot) < GetRankId(member);
--- a/src/strategy/actions/GuildManagementActions.h
+++ b/src/strategy/actions/GuildManagementActions.h
@@ -25,7 +25,7 @@ public:
    bool isUseful() override { return false; }

 protected:
-    virtual void SendPacket(WorldPacket data){};
+    virtual void SendPacket(WorldPacket const& packet);
    virtual Player* GetPlayer(Event event);
    virtual bool PlayerIsValid(Player* member);
    virtual uint8 GetRankId(Player* member);
@@ -44,7 +44,6 @@ public:
    bool isUseful() override;

 protected:
-    void SendPacket(WorldPacket data) override;
    bool PlayerIsValid(Player* member) override;
 };

@@ -59,7 +58,6 @@ public:
    bool isUseful() override;

 protected:
-    void SendPacket(WorldPacket data) override;
    bool PlayerIsValid(Player* member) override;
 };

@@ -74,7 +72,6 @@ public:
    bool isUseful() override;

 protected:
-    void SendPacket(WorldPacket data) override;
    bool PlayerIsValid(Player* member) override;
 };

@@ -89,7 +86,6 @@ public:
    bool isUseful() override;

 protected:
-    void SendPacket(WorldPacket data) override;
    bool PlayerIsValid(Player* member) override;
 };

--- a/src/strategy/actions/InviteToGroupAction.cpp
+++ b/src/strategy/actions/InviteToGroupAction.cpp
@@ -9,7 +9,9 @@
 #include "Event.h"
 #include "GuildMgr.h"
 #include "Log.h"
+#include "PlayerbotOperations.h"
 #include "Playerbots.h"
+#include "PlayerbotWorldThreadProcessor.h"
 #include "ServerFacade.h"

 bool InviteToGroupAction::Invite(Player* inviter, Player* player)
@@ -27,7 +29,10 @@ bool InviteToGroupAction::Invite(Player* inviter, Player* player)
    {
        if (GET_PLAYERBOT_AI(player) && !GET_PLAYERBOT_AI(player)->IsRealPlayer())
            if (!group->isRaidGroup() && group->GetMembersCount() > 4)
-                group->ConvertToRaid();
+            {
+                auto convertOp = std::make_unique<GroupConvertToRaidOperation>(inviter->GetGUID());
+                sPlayerbotWorldProcessor->QueueOperation(std::move(convertOp));
+            }
    }

    WorldPacket p;
@@ -89,7 +94,10 @@ bool InviteNearbyToGroupAction::Execute(Event event)
        // When inviting the 5th member of the group convert to raid for future invites.
        if (group && botAI->GetGrouperType() > GrouperType::LEADER_5 && !group->isRaidGroup() &&
            bot->GetGroup()->GetMembersCount() > 3)
-            group->ConvertToRaid();
+        {
+            auto convertOp = std::make_unique<GroupConvertToRaidOperation>(bot->GetGUID());
+            sPlayerbotWorldProcessor->QueueOperation(std::move(convertOp));
+        }

        if (sPlayerbotAIConfig->inviteChat && sRandomPlayerbotMgr->IsRandomBot(bot))
        {
@@ -221,7 +229,8 @@ bool InviteGuildToGroupAction::Execute(Event event)
        if (group && botAI->GetGrouperType() > GrouperType::LEADER_5 && !group->isRaidGroup() &&
            bot->GetGroup()->GetMembersCount() > 3)
        {
-            group->ConvertToRaid();
+            auto convertOp = std::make_unique<GroupConvertToRaidOperation>(bot->GetGUID());
+            sPlayerbotWorldProcessor->QueueOperation(std::move(convertOp));
        }

        if (sPlayerbotAIConfig->inviteChat &&
@@ -362,7 +371,10 @@ bool LfgAction::Execute(Event event)
            if (param.empty() || param == "5" || group->isRaidGroup())
                return false;  // Group or raid is full so stop trying.
            else
-                group->ConvertToRaid();  // We want a raid but are in a group so convert and continue.
+            {
+                auto convertOp = std::make_unique<GroupConvertToRaidOperation>(requester->GetGUID());
+                sPlayerbotWorldProcessor->QueueOperation(std::move(convertOp));
+            }
        }

        Group::MemberSlotList const& groupSlot = group->GetMemberSlots();
--- a/src/strategy/actions/MovementActions.cpp
+++ b/src/strategy/actions/MovementActions.cpp
@@ -10,6 +10,7 @@
 #include <iomanip>
 #include <string>

+#include "Corpse.h"
 #include "Event.h"
 #include "FleeManager.h"
 #include "G3D/Vector3.h"
@@ -41,7 +42,6 @@
 #include "Unit.h"
 #include "Vehicle.h"
 #include "WaypointMovementGenerator.h"
-#include "Corpse.h"

 MovementAction::MovementAction(PlayerbotAI* botAI, std::string const name) : Action(botAI, name)
 {
@@ -192,14 +192,15 @@ bool MovementAction::MoveTo(uint32 mapId, float x, float y, float z, bool idle,
    {
        return false;
    }
+
    bool generatePath = !bot->IsFlying() && !bot->isSwimming();
-    bool disableMoveSplinePath = sPlayerbotAIConfig->disableMoveSplinePath >= 2 ||
-                                 (sPlayerbotAIConfig->disableMoveSplinePath == 1 && bot->InBattleground());
+    bool disableMoveSplinePath =
+        sPlayerbotAIConfig->disableMoveSplinePath >= 2 ||
+        (sPlayerbotAIConfig->disableMoveSplinePath == 1 && bot->InBattleground());
    if (Vehicle* vehicle = bot->GetVehicle())
    {
        VehicleSeatEntry const* seat = vehicle->GetSeatForPassenger(bot);
        Unit* vehicleBase = vehicle->GetBase();
-        // If the mover (vehicle) can fly, we DO NOT want an mmaps path (2D ground) => disable pathfinding
        generatePath = !vehicleBase || !vehicleBase->CanFly();
        if (!vehicleBase || !seat || !seat->CanControl())  // is passenger and cant move anyway
            return false;
@@ -207,22 +208,7 @@ bool MovementAction::MoveTo(uint32 mapId, float x, float y, float z, bool idle,
        float distance = vehicleBase->GetExactDist(x, y, z);  // use vehicle distance, not bot
        if (distance > 0.01f)
        {
-            MotionMaster& mm = *vehicleBase->GetMotionMaster();  // need to move vehicle, not bot
-            // Disable ground pathing if the bot/master/vehicle are flying
-            auto isFlying = [](Unit* u){ return u && (u->HasUnitMovementFlag(MOVEMENTFLAG_FLYING) || u->IsInFlight()); };
-            bool allowPathVeh = generatePath;
-            Unit* masterVeh = botAI ? botAI->GetMaster() : nullptr;
-            if (isFlying(vehicleBase) || isFlying(bot) || isFlying(masterVeh))
-                allowPathVeh = false;
-            mm.Clear();
-            if (!backwards)
-            {
-                mm.MovePoint(0, x, y, z, FORCED_MOVEMENT_NONE, 0.0f, 0.0f, allowPathVeh);
-            }
-            else
-            {
-                mm.MovePointBackwards(0, x, y, z, allowPathVeh);
-            }
+            DoMovePoint(vehicleBase, x, y, z, generatePath, backwards);
            float speed = backwards ? vehicleBase->GetSpeed(MOVE_RUN_BACK) : vehicleBase->GetSpeed(MOVE_RUN);
            float delay = 1000.0f * (distance / speed);
            if (lessDelay)
@@ -248,23 +234,7 @@ bool MovementAction::MoveTo(uint32 mapId, float x, float y, float z, bool idle,
            //     bot->CastStop();
            //     botAI->InterruptSpell();
            // }
-
-            MotionMaster& mm = *bot->GetMotionMaster();
-            // No ground pathfinding if the bot/master are flying => allow true 3D (Z) movement
-            auto isFlying = [](Unit* u){ return u && (u->HasUnitMovementFlag(MOVEMENTFLAG_FLYING) || u->IsInFlight()); };
-            bool allowPath = generatePath;
-            Unit* master = botAI ? botAI->GetMaster() : nullptr;
-            if (isFlying(bot) || isFlying(master))
-                allowPath = false;
-            mm.Clear();
-            if (!backwards)
-            {
-                mm.MovePoint(0, x, y, z, FORCED_MOVEMENT_NONE, 0.0f, 0.0f, allowPath);
-            }
-            else
-            {
-                mm.MovePointBackwards(0, x, y, z, allowPath);
-            }
+            DoMovePoint(bot, x, y, z, generatePath, backwards);
            float delay = 1000.0f * MoveDelay(distance, backwards);
            if (lessDelay)
            {
@@ -282,9 +252,7 @@ bool MovementAction::MoveTo(uint32 mapId, float x, float y, float z, bool idle,
        Movement::PointsArray path =
            SearchForBestPath(x, y, z, modifiedZ, sPlayerbotAIConfig->maxMovementSearchTime, normal_only);
        if (modifiedZ == INVALID_HEIGHT)
-        {
            return false;
-        }
        float distance = bot->GetExactDist(x, y, modifiedZ);
        if (distance > 0.01f)
        {
@@ -296,24 +264,8 @@ bool MovementAction::MoveTo(uint32 mapId, float x, float y, float z, bool idle,
            //     bot->CastStop();
            //     botAI->InterruptSpell();
            // }
-
-            MotionMaster& mm = *bot->GetMotionMaster();
            G3D::Vector3 endP = path.back();
-            // No ground pathfinding if the bot/master are flying => allow true 3D (Z) movement
-            auto isFlying = [](Unit* u){ return u && (u->HasUnitMovementFlag(MOVEMENTFLAG_FLYING) || u->IsInFlight()); };
-            bool allowPath = generatePath;
-            Unit* master = botAI ? botAI->GetMaster() : nullptr;
-            if (isFlying(bot) || isFlying(master))
-                allowPath = false;
-            mm.Clear();
-            if (!backwards)
-            {
-                mm.MovePoint(0, x, y, z, FORCED_MOVEMENT_NONE, 0.0f, 0.0f, allowPath);
-            }
-            else
-            {
-                mm.MovePointBackwards(0, x, y, z, allowPath);
-            }
+            DoMovePoint(bot, x, y, z, generatePath, backwards);
            float delay = 1000.0f * MoveDelay(distance, backwards);
            if (lessDelay)
            {
@@ -581,9 +533,7 @@ bool MovementAction::MoveTo(uint32 mapId, float x, float y, float z, bool idle,
    //             bool goTaxi = bot->ActivateTaxiPathTo({ tEntry->from, tEntry->to }, unit, 1);

    //             if (botAI->HasCheat(BotCheatMask::gold))
-    //             {
    //                 bot->SetMoney(botMoney);
-    //             }
    //             LOG_DEBUG("playerbots", "goTaxi");
    //             return goTaxi;
    //         }
@@ -874,7 +824,7 @@ bool MovementAction::ReachCombatTo(Unit* target, float distance)

    float deltaAngle = Position::NormalizeOrientation(targetOrientation - target->GetAngle(bot));
    if (deltaAngle > M_PI)
-        deltaAngle -= 2.0f * M_PI; // -PI..PI
+        deltaAngle -= 2.0f * M_PI;  // -PI..PI
    // if target is moving forward and moving far away, predict the position
    bool behind = fabs(deltaAngle) > M_PI_2;
    if (target->HasUnitMovementFlag(MOVEMENTFLAG_FORWARD) && behind)
@@ -882,8 +832,8 @@ bool MovementAction::ReachCombatTo(Unit* target, float distance)
        float predictDis = std::min(3.0f, target->GetObjectSize() * 2);
        tx += cos(target->GetOrientation()) * predictDis;
        ty += sin(target->GetOrientation()) * predictDis;
-        if (!target->GetMap()->CheckCollisionAndGetValidCoords(target, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(),
-        tx, ty, tz))
+        if (!target->GetMap()->CheckCollisionAndGetValidCoords(target, target->GetPositionX(), target->GetPositionY(),
+                                                               target->GetPositionZ(), tx, ty, tz))
        {
            tx = target->GetPositionX();
            ty = target->GetPositionY();
@@ -1001,9 +951,8 @@ bool MovementAction::IsMovingAllowed()
        return false;

    if (bot->isFrozen() || bot->IsPolymorphed() || (bot->isDead() && !bot->HasPlayerFlag(PLAYER_FLAGS_GHOST)) ||
-        bot->IsBeingTeleported() || bot->HasRootAura() || bot->HasSpiritOfRedemptionAura() ||
-        bot->HasConfuseAura() || bot->IsCharmed() || bot->HasStunAura() ||
-        bot->IsInFlight() || bot->HasUnitState(UNIT_STATE_LOST_CONTROL))
+        bot->IsBeingTeleported() || bot->HasRootAura() || bot->HasSpiritOfRedemptionAura() || bot->HasConfuseAura() ||
+        bot->IsCharmed() || bot->HasStunAura() || bot->IsInFlight() || bot->HasUnitState(UNIT_STATE_LOST_CONTROL))
        return false;

    if (bot->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_CONTROLLED) != NULL_MOTION_TYPE)
@@ -1022,78 +971,86 @@ bool MovementAction::Follow(Unit* target, float distance) { return Follow(target

 void MovementAction::UpdateMovementState()
 {
-    int8 botInLiquidState = bot->GetLiquidData().Status;
+    const bool isCurrentlyRestricted = // see if the bot is currently slowed, rooted, or otherwise unable to move
+        bot->isFrozen() ||
+        bot->IsPolymorphed() ||
+        bot->HasRootAura() ||
+        bot->HasStunAura() ||
+        bot->HasConfuseAura() ||
+        bot->HasUnitState(UNIT_STATE_LOST_CONTROL);

-    if (botInLiquidState == LIQUID_MAP_IN_WATER || botInLiquidState == LIQUID_MAP_UNDER_WATER)
+    // no update movement flags while movement is current restricted.
+    if (!isCurrentlyRestricted && bot->IsAlive())
    {
-        bot->SetSwim(true);
-    }
-    else
-    {
-        bot->SetSwim(false);
-    }
+        // state flags
+        const auto master = botAI ? botAI->GetMaster() : nullptr; // real player or not
+        const bool masterIsFlying = master ? master->HasUnitMovementFlag(MOVEMENTFLAG_FLYING) : true;
+        const bool masterIsSwimming = master ? master->HasUnitMovementFlag(MOVEMENTFLAG_SWIMMING) : true;
+        const auto liquidState = bot->GetLiquidData().Status; // default LIQUID_MAP_NO_WATER
+        const float gZ = bot->GetMapWaterOrGroundLevel(bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ());
+        const bool wantsToFly = bot->HasIncreaseMountedFlightSpeedAura() || bot->HasFlyAura();
+        const bool isFlying = bot->HasUnitMovementFlag(MOVEMENTFLAG_FLYING);
+        const bool isWaterArea = liquidState != LIQUID_MAP_NO_WATER;
+        const bool isUnderWater = liquidState == LIQUID_MAP_UNDER_WATER;
+        const bool isInWater = liquidState == LIQUID_MAP_IN_WATER;
+        const bool isWaterWalking = bot->HasUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
+        const bool isSwimming = bot->HasUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
+        const bool wantsToWaterWalk = bot->HasWaterWalkAura();
+        const bool wantsToSwim = isInWater || isUnderWater;
+        const bool onGroundZ = (bot->GetPositionZ() < gZ + 1.f) && !isWaterArea;
+        bool movementFlagsUpdated = false;

-    bool onGround = bot->GetPositionZ() <
-                    bot->GetMapWaterOrGroundLevel(bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ()) + 1.0f;
+        // handle water state
+        if (isWaterArea && !isFlying)
+        {
+            // water walking
+            if (wantsToWaterWalk && !isWaterWalking && !masterIsSwimming)
+            {
+                bot->RemoveUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
+                bot->AddUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
+                movementFlagsUpdated = true;
+            }
+            // swimming
+            else if (wantsToSwim && !isSwimming && masterIsSwimming)
+            {
+                bot->RemoveUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
+                bot->AddUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
+                movementFlagsUpdated = true;
+            }
+        }
+        else if (isSwimming || isWaterWalking)
+        {
+            // reset water flags
+            bot->RemoveUnitMovementFlag(MOVEMENTFLAG_SWIMMING);
+            bot->RemoveUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
+            movementFlagsUpdated = true;
+        }

-    // Keep bot->SendMovementFlagUpdate() withing the if statements to not intefere with bot behavior on ground/(shallow) waters
-
-    bool hasFlightAura = bot->HasAuraType(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED) || bot->HasAuraType(SPELL_AURA_FLY);
-    if (hasFlightAura)
-    {
-        bool changed = false;
-        if (!bot->HasUnitMovementFlag(MOVEMENTFLAG_CAN_FLY))
+        // handle flying state
+        if (wantsToFly && !isFlying && masterIsFlying)
        {
            bot->AddUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
-            changed = true;
-        }
-        if (!bot->HasUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY))
-        {
            bot->AddUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
-            changed = true;
-        }
-        if (!bot->HasUnitMovementFlag(MOVEMENTFLAG_FLYING))
-        {
            bot->AddUnitMovementFlag(MOVEMENTFLAG_FLYING);
-            changed = true;
+            movementFlagsUpdated = true;
        }
-        if (changed)
-            bot->SendMovementFlagUpdate();
-    }
-    else if (!hasFlightAura)
-    {
-        bool changed = false;
-        if (bot->HasUnitMovementFlag(MOVEMENTFLAG_FLYING))
-        {
-            bot->RemoveUnitMovementFlag(MOVEMENTFLAG_FLYING);
-            changed = true;
-        }
-        if (bot->HasUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY))
-        {
-            bot->RemoveUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
-            changed = true;
-        }
-        if (bot->HasUnitMovementFlag(MOVEMENTFLAG_CAN_FLY))
+        else if ((!wantsToFly || onGroundZ) && isFlying)
        {
            bot->RemoveUnitMovementFlag(MOVEMENTFLAG_CAN_FLY);
-            changed = true;
+            bot->RemoveUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
+            bot->RemoveUnitMovementFlag(MOVEMENTFLAG_FLYING);
+            movementFlagsUpdated = true;
        }
-        if (changed)
+
+        // detect if movement restrictions have been lifted, CC just ended.
+        if (wasMovementRestricted)
+            movementFlagsUpdated = true; // refresh movement state to ensure animations play correctly
+
+        if (movementFlagsUpdated)
            bot->SendMovementFlagUpdate();
    }

-    // See if the bot is currently slowed, rooted, or otherwise unable to move
-    bool isCurrentlyRestricted = bot->isFrozen() || bot->IsPolymorphed() || bot->HasRootAura() || bot->HasStunAura() ||
-                                 bot->HasConfuseAura() || bot->HasUnitState(UNIT_STATE_LOST_CONTROL);
-
-    // Detect if movement restrictions have been lifted
-    if (wasMovementRestricted && !isCurrentlyRestricted && bot->IsAlive())
-    {
-        // CC just ended - refresh movement state to ensure animations play correctly
-        bot->SendMovementFlagUpdate();
-    }
-
-    // Save current state for the next check
+     // Save current state for the next check
    wasMovementRestricted = isCurrentlyRestricted;

    // Temporary speed increase in group
@@ -1180,6 +1137,13 @@ bool MovementAction::Follow(Unit* target, float distance, float angle)
    if (!target)
        return false;

+    if (!bot->InBattleground() && sServerFacade->IsDistanceLessOrEqualThan(sServerFacade->GetDistance2d(bot, target),
+                                                                           sPlayerbotAIConfig->followDistance))
+    {
+        // botAI->TellError("No need to follow");
+        return false;
+    }
+
    /*
    if (!bot->InBattleground()
        && sServerFacade->IsDistanceLessOrEqualThan(sServerFacade->GetDistance2d(bot, target->GetPositionX(),
@@ -1297,17 +1261,21 @@ bool MovementAction::Follow(Unit* target, float distance, float angle)
            return MoveTo(target, sPlayerbotAIConfig->followDistance);
    }

+    if (sServerFacade->IsDistanceLessOrEqualThan(sServerFacade->GetDistance2d(bot, target),
+                                                 sPlayerbotAIConfig->followDistance))
+    {
+        // botAI->TellError("No need to follow");
+        return false;
+    }
+
    if (target->IsFriendlyTo(bot) && bot->IsMounted() && AI_VALUE(GuidVector, "all targets").empty())
        distance += angle;

-    // Do not cancel follow if the 2D distance is short but the Z still differs (e.g., master above).
-    float dz1 = fabs(bot->GetPositionZ() - target->GetPositionZ());
-    if (!bot->InBattleground()
-        && sServerFacade->IsDistanceLessOrEqualThan(sServerFacade->GetDistance2d(bot, target), sPlayerbotAIConfig->followDistance)
-        && dz1 < sPlayerbotAIConfig->contactDistance)
+    if (!bot->InBattleground() && sServerFacade->IsDistanceLessOrEqualThan(sServerFacade->GetDistance2d(bot, target),
+                                                                           sPlayerbotAIConfig->followDistance))
    {
        // botAI->TellError("No need to follow");
-        return false; // truly in range (2D and Z) => no need to move
+        return false;
    }

    bot->HandleEmoteCommand(0);
@@ -1388,7 +1356,7 @@ float MovementAction::MoveDelay(float distance, bool backwards)
    }
    else
    {
-        speed = backwards ? bot->GetSpeed(MOVE_RUN_BACK) :bot->GetSpeed(MOVE_RUN);
+        speed = backwards ? bot->GetSpeed(MOVE_RUN_BACK) : bot->GetSpeed(MOVE_RUN);
    }
    float delay = distance / speed;
    return delay;
@@ -1418,8 +1386,7 @@ void MovementAction::SetNextMovementDelay(float delayMillis)
 {
    AI_VALUE(LastMovement&, "last movement")
        .Set(bot->GetMapId(), bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(), bot->GetOrientation(),
-             delayMillis,
-             MovementPriority::MOVEMENT_FORCED);
+             delayMillis, MovementPriority::MOVEMENT_FORCED);
 }

 bool MovementAction::Flee(Unit* target)
@@ -1633,7 +1600,8 @@ bool MovementAction::MoveAway(Unit* target, float distance, bool backwards)
            dz = bot->GetPositionZ();
            exact = false;
        }
-        if (MoveTo(target->GetMapId(), dx, dy, dz, false, false, true, exact, MovementPriority::MOVEMENT_COMBAT, false, backwards))
+        if (MoveTo(target->GetMapId(), dx, dy, dz, false, false, true, exact, MovementPriority::MOVEMENT_COMBAT, false,
+                   backwards))
        {
            return true;
        }
@@ -1655,7 +1623,8 @@ bool MovementAction::MoveAway(Unit* target, float distance, bool backwards)
            dz = bot->GetPositionZ();
            exact = false;
        }
-        if (MoveTo(target->GetMapId(), dx, dy, dz, false, false, true, exact, MovementPriority::MOVEMENT_COMBAT, false, backwards))
+        if (MoveTo(target->GetMapId(), dx, dy, dz, false, false, true, exact, MovementPriority::MOVEMENT_COMBAT, false,
+                   backwards))
        {
            return true;
        }
@@ -1704,7 +1673,7 @@ bool MovementAction::Move(float angle, float distance)
    float x = bot->GetPositionX() + cos(angle) * distance;
    float y = bot->GetPositionY() + sin(angle) * distance;

-    //TODO do we need GetMapWaterOrGroundLevel() if we're using CheckCollisionAndGetValidCoords() ?
+    // TODO do we need GetMapWaterOrGroundLevel() if we're using CheckCollisionAndGetValidCoords() ?
    float z = bot->GetMapWaterOrGroundLevel(x, y, bot->GetPositionZ());
    if (z == -100000.0f || z == -200000.0f)
        z = bot->GetPositionZ();
@@ -1758,9 +1727,7 @@ bool MovementAction::MoveInside(uint32 mapId, float x, float y, float z, float d
 //             min_length = gen.getPathLength();
 //             current_z = modified_z;
 //             if (abs(current_z - z) < 0.5f)
-//             {
 //                 return current_z;
-//             }
 //         }
 //     }
 //     for (delta = range / 2 + step; delta <= range; delta += 2) {
@@ -1857,6 +1824,46 @@ const Movement::PointsArray MovementAction::SearchForBestPath(float x, float y,
    return result;
 }

+void MovementAction::DoMovePoint(Unit* unit, float x, float y, float z, bool generatePath, bool backwards)
+{
+    if (!unit)
+        return;
+
+    MotionMaster* mm = unit->GetMotionMaster();
+    if (!mm)
+        return;
+
+    // enable water walking
+    if (unit->HasUnitMovementFlag(MOVEMENTFLAG_WATERWALKING))
+    {
+        float gZ = unit->GetMapWaterOrGroundLevel(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ());
+        unit->UpdatePosition(unit->GetPositionX(), unit->GetPositionY(), gZ, false);
+        // z = gZ; no overwrite Z axe otherwise you cant steer the bots into swimming when water walking.
+    }
+
+    mm->Clear();
+    if (backwards)
+    {
+        mm->MovePointBackwards(
+            /*id*/ 0,
+            /*coords*/ x, y, z,
+            /*generatePath*/ generatePath,
+            /*forceDestination*/ false);
+        return;
+    }
+    else
+    {
+        mm->MovePoint(
+            /*id*/ 0,
+            /*coords*/ x, y, z,
+            /*forcedMovement*/ FORCED_MOVEMENT_NONE,
+            /*speed*/ 0.f,
+            /*orientation*/ 0.f,
+            /*generatePath*/ generatePath,  // true => terrain path (2d mmap); false => straight spline (3d vmap)
+            /*forceDestination*/ false);
+    }
+}
+
 bool FleeAction::Execute(Event event)
 {
    return MoveAway(AI_VALUE(Unit*, "current target"), sPlayerbotAIConfig->fleeDistance, true);
@@ -1937,7 +1944,8 @@ bool AvoidAoeAction::AvoidAuraWithDynamicObj()
    {
        return false;
    }
-    if (sPlayerbotAIConfig->aoeAvoidSpellWhitelist.find(spellInfo->Id) != sPlayerbotAIConfig->aoeAvoidSpellWhitelist.end())
+    if (sPlayerbotAIConfig->aoeAvoidSpellWhitelist.find(spellInfo->Id) !=
+        sPlayerbotAIConfig->aoeAvoidSpellWhitelist.end())
        return false;

    DynamicObject* dynOwner = aura->GetDynobjOwner();
@@ -2002,7 +2010,8 @@ bool AvoidAoeAction::AvoidGameObjectWithDamage()
            continue;
        }

-        if (sPlayerbotAIConfig->aoeAvoidSpellWhitelist.find(spellId) != sPlayerbotAIConfig->aoeAvoidSpellWhitelist.end())
+        if (sPlayerbotAIConfig->aoeAvoidSpellWhitelist.find(spellId) !=
+            sPlayerbotAIConfig->aoeAvoidSpellWhitelist.end())
            continue;

        const SpellInfo* spellInfo = sSpellMgr->GetSpellInfo(spellId);
@@ -2028,7 +2037,8 @@ bool AvoidAoeAction::AvoidGameObjectWithDamage()
                lastTellTimer = time(NULL);
                lastMoveTimer = getMSTime();
                std::ostringstream out;
-                out << "I'm avoiding " << name.str() << " (" << spellInfo->Id << ")" << " Radius " << radius << " - [Trap]";
+                out << "I'm avoiding " << name.str() << " (" << spellInfo->Id << ")" << " Radius " << radius
+                    << " - [Trap]";
                bot->Say(out.str(), LANG_UNIVERSAL);
            }
            return true;
@@ -2071,7 +2081,8 @@ bool AvoidAoeAction::AvoidUnitWithDamageAura()
                    sSpellMgr->GetSpellInfo(spellInfo->Effects[aurEff->GetEffIndex()].TriggerSpell);
                if (!triggerSpellInfo)
                    continue;
-                if (sPlayerbotAIConfig->aoeAvoidSpellWhitelist.find(triggerSpellInfo->Id) != sPlayerbotAIConfig->aoeAvoidSpellWhitelist.end())
+                if (sPlayerbotAIConfig->aoeAvoidSpellWhitelist.find(triggerSpellInfo->Id) !=
+                    sPlayerbotAIConfig->aoeAvoidSpellWhitelist.end())
                    return false;
                for (int j = 0; j < MAX_SPELL_EFFECTS; j++)
                {
@@ -2093,7 +2104,8 @@ bool AvoidAoeAction::AvoidUnitWithDamageAura()
                                lastTellTimer = time(NULL);
                                lastMoveTimer = getMSTime();
                                std::ostringstream out;
-                                out << "I'm avoiding " << name.str() << " (" << triggerSpellInfo->Id << ")" << " Radius " << radius << " - [Unit Trigger]";
+                                out << "I'm avoiding " << name.str() << " (" << triggerSpellInfo->Id << ")"
+                                    << " Radius " << radius << " - [Unit Trigger]";
                                bot->Say(out.str(), LANG_UNIVERSAL);
                            }
                        }
@@ -2112,7 +2124,8 @@ Position MovementAction::BestPositionForMeleeToFlee(Position pos, float radius)
    if (currentTarget)
    {
        // Normally, move to left or right is the best position
-        bool isTanking = (!currentTarget->isFrozen() && !currentTarget->HasRootAura()) && (currentTarget->GetVictim() == bot);
+        bool isTanking = (!currentTarget->isFrozen()
+            && !currentTarget->HasRootAura()) && (currentTarget->GetVictim() == bot);
        float angle = bot->GetAngle(currentTarget);
        float angleLeft = angle + (float)M_PI / 2;
        float angleRight = angle - (float)M_PI / 2;
@@ -2327,8 +2340,7 @@ bool CombatFormationMoveAction::isUseful()
 bool CombatFormationMoveAction::Execute(Event event)
 {
    float dis = AI_VALUE(float, "disperse distance");
-    if (dis <= 0.0f ||
-        (!bot->IsInCombat() && botAI->HasStrategy("stay", BotState::BOT_STATE_NON_COMBAT)) ||
+    if (dis <= 0.0f || (!bot->IsInCombat() && botAI->HasStrategy("stay", BotState::BOT_STATE_NON_COMBAT)) ||
        (bot->IsInCombat() && botAI->HasStrategy("stay", BotState::BOT_STATE_COMBAT)))
        return false;
    Player* playerToLeave = NearestGroupMember(dis);
@@ -2478,7 +2490,7 @@ bool TankFaceAction::Execute(Event event)

    float deltaAngle = Position::NormalizeOrientation(averageAngle - target->GetAngle(bot));
    if (deltaAngle > M_PI)
-        deltaAngle -= 2.0f * M_PI; // -PI..PI
+        deltaAngle -= 2.0f * M_PI;  // -PI..PI

    float tolerable = M_PI_2;

@@ -2489,12 +2501,13 @@ bool TankFaceAction::Execute(Event event)
    float goodAngle2 = Position::NormalizeOrientation(averageAngle - M_PI * 3 / 5);

    // if dist < bot->GetMeleeRange(target) / 2, target will move backward
-    float dist = std::max(bot->GetExactDist(target), bot->GetMeleeRange(target) / 2) - bot->GetCombatReach() - target->GetCombatReach();
+    float dist = std::max(bot->GetExactDist(target), bot->GetMeleeRange(target) / 2) - bot->GetCombatReach() -
+                 target->GetCombatReach();
    std::vector<Position> availablePos;
    float x, y, z;
    target->GetNearPoint(bot, x, y, z, 0.0f, dist, goodAngle1);
-    if (bot->GetMap()->CheckCollisionAndGetValidCoords(bot, bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(),
-        x, y, z))
+    if (bot->GetMap()->CheckCollisionAndGetValidCoords(bot, bot->GetPositionX(), bot->GetPositionY(),
+                                                       bot->GetPositionZ(), x, y, z))
    {
        /// @todo: movement control now is a mess, prepare to rewrite
        std::list<FleeInfo>& infoList = AI_VALUE(std::list<FleeInfo>&, "recently flee info");
@@ -2506,8 +2519,8 @@ bool TankFaceAction::Execute(Event event)
        }
    }
    target->GetNearPoint(bot, x, y, z, 0.0f, dist, goodAngle2);
-    if (bot->GetMap()->CheckCollisionAndGetValidCoords(bot, bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(),
-        x, y, z))
+    if (bot->GetMap()->CheckCollisionAndGetValidCoords(bot, bot->GetPositionX(), bot->GetPositionY(),
+                                                       bot->GetPositionZ(), x, y, z))
    {
        std::list<FleeInfo>& infoList = AI_VALUE(std::list<FleeInfo>&, "recently flee info");
        Position pos(x, y, z);
@@ -2520,13 +2533,15 @@ bool TankFaceAction::Execute(Event event)
    if (availablePos.empty())
        return false;
    Position nearest = GetNearestPosition(availablePos);
-    return MoveTo(bot->GetMapId(), nearest.GetPositionX(), nearest.GetPositionY(), nearest.GetPositionZ(), false, false, false, true, MovementPriority::MOVEMENT_COMBAT);
+    return MoveTo(bot->GetMapId(), nearest.GetPositionX(), nearest.GetPositionY(), nearest.GetPositionZ(), false, false,
+                  false, true, MovementPriority::MOVEMENT_COMBAT);
 }

 bool RearFlankAction::isUseful()
 {
    Unit* target = AI_VALUE(Unit*, "current target");
-    if (!target) { return false; }
+    if (!target)
+        return false;

    // Need to double the front angle check to account for mirrored angle.
    bool inFront = target->HasInArc(2.f * minAngle, bot);
@@ -2540,7 +2555,8 @@ bool RearFlankAction::isUseful()
 bool RearFlankAction::Execute(Event event)
 {
    Unit* target = AI_VALUE(Unit*, "current target");
-    if (!target) { return false; }
+    if (!target)
+        return false;

    float angle = frand(minAngle, maxAngle);
    float baseDistance = bot->GetMeleeRange(target) * 0.5f;
@@ -2559,8 +2575,8 @@ bool RearFlankAction::Execute(Event event)
        destination = &rightFlank;
    }

-    return MoveTo(bot->GetMapId(), destination->GetPositionX(), destination->GetPositionY(), destination->GetPositionZ(),
-                  false, false, false, true, MovementPriority::MOVEMENT_COMBAT);
+    return MoveTo(bot->GetMapId(), destination->GetPositionX(), destination->GetPositionY(),
+                  destination->GetPositionZ(), false, false, false, true, MovementPriority::MOVEMENT_COMBAT);
 }

 bool DisperseSetAction::Execute(Event event)
@@ -2688,9 +2704,8 @@ bool SetFacingTargetAction::isUseful() { return !AI_VALUE2(bool, "facing", "curr
 bool SetFacingTargetAction::isPossible()
 {
    if (bot->isFrozen() || bot->IsPolymorphed() || (bot->isDead() && !bot->HasPlayerFlag(PLAYER_FLAGS_GHOST)) ||
-        bot->IsBeingTeleported() || bot->HasConfuseAura() || bot->IsCharmed() ||
-        bot->HasStunAura() || bot->IsInFlight() ||
-        bot->HasUnitState(UNIT_STATE_LOST_CONTROL))
+        bot->IsBeingTeleported() || bot->HasConfuseAura() || bot->IsCharmed() || bot->HasStunAura() ||
+        bot->IsInFlight() || bot->HasUnitState(UNIT_STATE_LOST_CONTROL))
        return false;

    return true;
@@ -2710,7 +2725,7 @@ bool SetBehindTargetAction::Execute(Event event)

    float deltaAngle = Position::NormalizeOrientation(target->GetOrientation() - target->GetAngle(bot));
    if (deltaAngle > M_PI)
-        deltaAngle -= 2.0f * M_PI; // -PI..PI
+        deltaAngle -= 2.0f * M_PI;  // -PI..PI

    float tolerable = M_PI_2;

@@ -2720,12 +2735,13 @@ bool SetBehindTargetAction::Execute(Event event)
    float goodAngle1 = Position::NormalizeOrientation(target->GetOrientation() + M_PI * 3 / 5);
    float goodAngle2 = Position::NormalizeOrientation(target->GetOrientation() - M_PI * 3 / 5);

-    float dist = std::max(bot->GetExactDist(target), bot->GetMeleeRange(target) / 2) - bot->GetCombatReach() - target->GetCombatReach();
+    float dist = std::max(bot->GetExactDist(target), bot->GetMeleeRange(target) / 2) - bot->GetCombatReach() -
+                 target->GetCombatReach();
    std::vector<Position> availablePos;
    float x, y, z;
    target->GetNearPoint(bot, x, y, z, 0.0f, dist, goodAngle1);
-    if (bot->GetMap()->CheckCollisionAndGetValidCoords(bot, bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(),
-        x, y, z))
+    if (bot->GetMap()->CheckCollisionAndGetValidCoords(bot, bot->GetPositionX(), bot->GetPositionY(),
+                                                       bot->GetPositionZ(), x, y, z))
    {
        /// @todo: movement control now is a mess, prepare to rewrite
        std::list<FleeInfo>& infoList = AI_VALUE(std::list<FleeInfo>&, "recently flee info");
@@ -2737,8 +2753,8 @@ bool SetBehindTargetAction::Execute(Event event)
        }
    }
    target->GetNearPoint(bot, x, y, z, 0.0f, dist, goodAngle2);
-    if (bot->GetMap()->CheckCollisionAndGetValidCoords(bot, bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(),
-        x, y, z))
+    if (bot->GetMap()->CheckCollisionAndGetValidCoords(bot, bot->GetPositionX(), bot->GetPositionY(),
+                                                       bot->GetPositionZ(), x, y, z))
    {
        std::list<FleeInfo>& infoList = AI_VALUE(std::list<FleeInfo>&, "recently flee info");
        Position pos(x, y, z);
@@ -2751,7 +2767,8 @@ bool SetBehindTargetAction::Execute(Event event)
    if (availablePos.empty())
        return false;
    Position nearest = GetNearestPosition(availablePos);
-    return MoveTo(bot->GetMapId(), nearest.GetPositionX(), nearest.GetPositionY(), nearest.GetPositionZ(), false, false, false, true, MovementPriority::MOVEMENT_COMBAT);
+    return MoveTo(bot->GetMapId(), nearest.GetPositionX(), nearest.GetPositionY(), nearest.GetPositionZ(), false, false,
+                  false, true, MovementPriority::MOVEMENT_COMBAT);
 }

 bool MoveOutOfCollisionAction::Execute(Event event)
@@ -2822,7 +2839,7 @@ bool MoveFromGroupAction::Execute(Event event)
 {
    float distance = atoi(event.getParam().c_str());
    if (!distance)
-        distance = 20.0f; // flee distance from config is too small for this
+        distance = 20.0f;  // flee distance from config is too small for this
    return MoveFromGroup(distance);
 }

@@ -2905,10 +2922,7 @@ bool MoveAwayFromCreatureAction::Execute(Event event)
    return false;
 }

-bool MoveAwayFromCreatureAction::isPossible()
-{
-    return bot->CanFreeMove();
-}
+bool MoveAwayFromCreatureAction::isPossible() { return bot->CanFreeMove(); }

 bool MoveAwayFromPlayerWithDebuffAction::Execute(Event event)
 {
@@ -2995,7 +3009,4 @@ bool MoveAwayFromPlayerWithDebuffAction::Execute(Event event)
    return false;
 }

-bool MoveAwayFromPlayerWithDebuffAction::isPossible()
-{
-    return bot->CanFreeMove();
-}
+bool MoveAwayFromPlayerWithDebuffAction::isPossible() { return bot->CanFreeMove(); }
--- a/src/strategy/actions/MovementActions.h
+++ b/src/strategy/actions/MovementActions.h
@@ -29,12 +29,17 @@ public:

 protected:
    bool JumpTo(uint32 mapId, float x, float y, float z, MovementPriority priority = MovementPriority::MOVEMENT_NORMAL);
-    bool MoveNear(uint32 mapId, float x, float y, float z, float distance = sPlayerbotAIConfig->contactDistance, MovementPriority priority = MovementPriority::MOVEMENT_NORMAL);
+    bool MoveNear(uint32 mapId, float x, float y, float z, float distance = sPlayerbotAIConfig->contactDistance,
+                  MovementPriority priority = MovementPriority::MOVEMENT_NORMAL);
    bool MoveToLOS(WorldObject* target, bool ranged = false);
    bool MoveTo(uint32 mapId, float x, float y, float z, bool idle = false, bool react = false,
-                bool normal_only = false, bool exact_waypoint = false, MovementPriority priority = MovementPriority::MOVEMENT_NORMAL, bool lessDelay = false, bool backwards = false);
-    bool MoveTo(WorldObject* target, float distance = 0.0f, MovementPriority priority = MovementPriority::MOVEMENT_NORMAL);
-    bool MoveNear(WorldObject* target, float distance = sPlayerbotAIConfig->contactDistance, MovementPriority priority = MovementPriority::MOVEMENT_NORMAL);
+                bool normal_only = false, bool exact_waypoint = false,
+                MovementPriority priority = MovementPriority::MOVEMENT_NORMAL, bool lessDelay = false,
+                bool backwards = false);
+    bool MoveTo(WorldObject* target, float distance = 0.0f,
+                MovementPriority priority = MovementPriority::MOVEMENT_NORMAL);
+    bool MoveNear(WorldObject* target, float distance = sPlayerbotAIConfig->contactDistance,
+                  MovementPriority priority = MovementPriority::MOVEMENT_NORMAL);
    float GetFollowAngle();
    bool Follow(Unit* target, float distance = sPlayerbotAIConfig->followDistance);
    bool Follow(Unit* target, float distance, float angle);
@@ -51,10 +56,11 @@ protected:
    bool Flee(Unit* target);
    void ClearIdleState();
    void UpdateMovementState();
-    bool MoveAway(Unit* target, float distance = sPlayerbotAIConfig -> fleeDistance, bool backwards = false);
+    bool MoveAway(Unit* target, float distance = sPlayerbotAIConfig->fleeDistance, bool backwards = false);
    bool MoveFromGroup(float distance);
    bool Move(float angle, float distance);
-    bool MoveInside(uint32 mapId, float x, float y, float z, float distance = sPlayerbotAIConfig->followDistance, MovementPriority priority = MovementPriority::MOVEMENT_NORMAL);
+    bool MoveInside(uint32 mapId, float x, float y, float z, float distance = sPlayerbotAIConfig->followDistance,
+                    MovementPriority priority = MovementPriority::MOVEMENT_NORMAL);
    void CreateWp(Player* wpOwner, float x, float y, float z, float o, uint32 entry, bool important = false);
    Position BestPositionForMeleeToFlee(Position pos, float radius);
    Position BestPositionForRangedToFlee(Position pos, float radius);
@@ -74,6 +80,7 @@ private:
    const Movement::PointsArray SearchForBestPath(float x, float y, float z, float& modified_z, int maxSearchCount = 5,
                                                  bool normal_only = false, float step = 8.0f);
    bool wasMovementRestricted = false;
+    void DoMovePoint(Unit* unit, float x, float y, float z, bool generatePath, bool backwards);
 };

 class FleeAction : public MovementAction
@@ -149,17 +156,18 @@ public:

 class RearFlankAction : public MovementAction
 {
-// 90 degree minimum angle prevents any frontal cleaves/breaths and avoids parry-hasting the boss.
-// 120 degree maximum angle leaves a 120 degree symmetrical cone at the tail end which is usually enough to avoid tail swipes.
-// Some dragons or mobs may have different danger zone angles, override if needed.
+    // 90 degree minimum angle prevents any frontal cleaves/breaths and avoids parry-hasting the boss.
+    // 120 degree maximum angle leaves a 120 degree symmetrical cone at the tail end which is usually enough to avoid
+    // tail swipes. Some dragons or mobs may have different danger zone angles, override if needed.
 public:
-    RearFlankAction(PlayerbotAI* botAI, float distance = 0.0f, float minAngle = ANGLE_90_DEG, float maxAngle = ANGLE_120_DEG)
+    RearFlankAction(PlayerbotAI* botAI, float distance = 0.0f, float minAngle = ANGLE_90_DEG,
+                    float maxAngle = ANGLE_120_DEG)
        : MovementAction(botAI, "rear flank")
-        {
-            this->distance = distance;
-            this->minAngle = minAngle;
-            this->maxAngle = maxAngle;
-        }
+    {
+        this->distance = distance;
+        this->minAngle = minAngle;
+        this->maxAngle = maxAngle;
+    }

    bool Execute(Event event) override;
    bool isUseful() override;
@@ -297,7 +305,9 @@ class MoveAwayFromCreatureAction : public MovementAction
 {
 public:
    MoveAwayFromCreatureAction(PlayerbotAI* botAI, std::string name, uint32 creatureId, float range, bool alive = true)
-        : MovementAction(botAI, name), creatureId(creatureId), range(range), alive(alive) {}
+        : MovementAction(botAI, name), creatureId(creatureId), range(range), alive(alive)
+    {
+    }

    bool Execute(Event event) override;
    bool isPossible() override;
@@ -312,7 +322,9 @@ class MoveAwayFromPlayerWithDebuffAction : public MovementAction
 {
 public:
    MoveAwayFromPlayerWithDebuffAction(PlayerbotAI* botAI, std::string name, uint32 spellId, float range)
-        : MovementAction(botAI, name), spellId(spellId), range(range) {}
+        : MovementAction(botAI, name), spellId(spellId), range(range)
+    {
+    }

    bool Execute(Event event) override;
    bool isPossible() override;
--- a/src/strategy/actions/PassLeadershipToMasterAction.cpp
+++ b/src/strategy/actions/PassLeadershipToMasterAction.cpp
@@ -6,16 +6,17 @@
 #include "PassLeadershipToMasterAction.h"

 #include "Event.h"
+#include "PlayerbotOperations.h"
 #include "Playerbots.h"
+#include "PlayerbotWorldThreadProcessor.h"

 bool PassLeadershipToMasterAction::Execute(Event event)
 {
    if (Player* master = GetMaster())
        if (master && master != bot && bot->GetGroup() && bot->GetGroup()->IsMember(master->GetGUID()))
        {
-            WorldPacket p(SMSG_GROUP_SET_LEADER, 8);
-            p << master->GetGUID();
-            bot->GetSession()->HandleGroupSetLeaderOpcode(p);
+            auto setLeaderOp = std::make_unique<GroupSetLeaderOperation>(bot->GetGUID(), master->GetGUID());
+            sPlayerbotWorldProcessor->QueueOperation(std::move(setLeaderOp));

            if (!message.empty())
                botAI->TellMasterNoFacing(message);
--- a/src/strategy/actions/SeeSpellAction.cpp
+++ b/src/strategy/actions/SeeSpellAction.cpp
@@ -12,6 +12,7 @@
 #include "RTSCValues.h"
 #include "RtscAction.h"
 #include "PositionValue.h"
+#include "ByteBuffer.h"

 Creature* SeeSpellAction::CreateWps(Player* wpOwner, float x, float y, float z, float o, uint32 entry, Creature* lastWp,
                                    bool important)
@@ -31,27 +32,52 @@ Creature* SeeSpellAction::CreateWps(Player* wpOwner, float x, float y, float z,

 bool SeeSpellAction::Execute(Event event)
 {
-    WorldPacket p(event.getPacket());  //
+    // RTSC packet data
+    WorldPacket p(event.getPacket());
+    uint8 castCount;
    uint32 spellId;
-    uint8 castCount, castFlags;
+    uint8 castFlags;
+
+    // check RTSC header size = castCount (uint8) + spellId (uint32) + castFlags (uint8)
+    uint32 const rtscHeaderSize = sizeof(uint8) + sizeof(uint32) + sizeof(uint8);
+    if (p.size() < rtscHeaderSize)
+    {
+        LOG_WARN("playerbots", "SeeSpellAction: Corrupt RTSC packet size={}, expected>={}", p.size(), rtscHeaderSize);
+        return false;
+    }
+
    Player* master = botAI->GetMaster();
-
-    p.rpos(0);
-    p >> castCount >> spellId >> castFlags;
-
    if (!master)
        return false;

+    // read RTSC packet data
+    p.rpos(0); // set read position to start
+    p >> castCount >> spellId >> castFlags;
+
    // if (!botAI->HasStrategy("RTSC", botAI->GetState()))
    //     return false;

    if (spellId != RTSC_MOVE_SPELL)
        return false;

-    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
-
+    // should not throw exception,just defensive measure to prevent any crashes when core function breaks.
    SpellCastTargets targets;
-    targets.Read(p, botAI->GetMaster());
+    try
+    {
+        targets.Read(p, master);
+        if (!targets.GetDst())
+        {
+            // do not dereference a null destination; ignore malformed RTSC packets instead of crashing
+            LOG_WARN("playerbots", "SeeSpellAction: (malformed) RTSC payload does not contain full targets data");
+            return false;
+        }
+    }
+    catch (ByteBufferException const&)
+    {
+        // ignore malformed RTSC packets instead of crashing
+        LOG_WARN("playerbots", "SeeSpellAction: Failed deserialization (malformed) RTSC payload");
+        return false;
+    }

    WorldPosition spellPosition(master->GetMapId(), targets.GetDst()->_position);
    SET_AI_VALUE(WorldPosition, "see spell location", spellPosition);
--- a/src/strategy/druid/DruidActions.cpp
+++ b/src/strategy/druid/DruidActions.cpp
@@ -7,6 +7,9 @@

 #include "Event.h"
 #include "Playerbots.h"
+#include "ServerFacade.h"
+#include "AoeValues.h"
+#include "TargetValue.h"

 NextAction** CastAbolishPoisonAction::getAlternatives()
 {
@@ -30,6 +33,32 @@ bool CastEntanglingRootsCcAction::Execute(Event event) { return botAI->CastSpell
 Value<Unit*>* CastHibernateCcAction::GetTargetValue() { return context->GetValue<Unit*>("cc target", "hibernate"); }

 bool CastHibernateCcAction::Execute(Event event) { return botAI->CastSpell("hibernate", GetTarget()); }
+bool CastStarfallAction::isUseful()
+{
+    if (!CastSpellAction::isUseful())
+        return false;
+
+    // Avoid breaking CC
+    WorldLocation aoePos = *context->GetValue<WorldLocation>("aoe position");
+    Unit* ccTarget = context->GetValue<Unit*>("current cc target")->Get();
+    if (ccTarget && ccTarget->IsAlive())
+    {
+        float dist2d = sServerFacade->GetDistance2d(ccTarget, aoePos.GetPositionX(), aoePos.GetPositionY());
+        if (sServerFacade->IsDistanceLessOrEqualThan(dist2d, sPlayerbotAIConfig->aoeRadius))
+            return false;
+    }
+
+    // Avoid single-target usage on initial pull
+    uint8 aoeCount = *context->GetValue<uint8>("aoe count");
+    if (aoeCount < 2)
+    {
+        Unit* target = context->GetValue<Unit*>("current target")->Get();
+        if (!target || (!botAI->HasAura("moonfire", target) && !botAI->HasAura("insect swarm", target)))
+            return false;
+    }
+
+    return true;
+}

 NextAction** CastReviveAction::getPrerequisites()
 {
--- a/src/strategy/druid/DruidActions.h
+++ b/src/strategy/druid/DruidActions.h
@@ -144,6 +144,8 @@ class CastStarfallAction : public CastSpellAction
 {
 public:
    CastStarfallAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "starfall") {}
+
+    bool isUseful() override;
 };

 class CastHurricaneAction : public CastSpellAction
--- a/src/strategy/raids/gruulslair/RaidGruulsLairHelpers.h
+++ b/src/strategy/raids/gruulslair/RaidGruulsLairHelpers.h
@@ -15,7 +15,7 @@ namespace GruulsLairHelpers
        SPELL_SPELL_SHIELD = 33054,

        // Hunter
-        SPELL_MISDIRECTION = 34477,
+        SPELL_MISDIRECTION = 35079,

        // Warlock
        SPELL_BANISH = 18647, // Rank 2
--- a/src/strategy/raids/magtheridon/RaidMagtheridonHelpers.h
+++ b/src/strategy/raids/magtheridon/RaidMagtheridonHelpers.h
@@ -24,7 +24,7 @@ namespace MagtheridonHelpers
        SPELL_FEAR          =  6215,

        // Hunter
-        SPELL_MISDIRECTION  = 34477,
+        SPELL_MISDIRECTION  = 35079,
    };

    enum MagtheridonNPCs
Author	SHA1	Message	Date
Crow	38e2d8584b	Add missing break in ApplyInstanceStrategies (#1887 ) Well, I hope nobody has tried Magtheridon lately. It looks like this got inadvertently deleted during the merge.	2025-11-28 19:00:12 +01:00
Keleborn	d5dbc4ddd7	Hotfix: prevent server crash when whisper 'logout' (#1874 ) Temp Hotfix to resolve #1870.	2025-11-24 21:49:55 +01:00
Keleborn	2424f73bc4	Core Merge PR - Replace OnPlayerChat with OnPlayerCanUseChat (#1838 ) First stab at getting this working. Im not sure if Im missing something, but it seemed to be a pretty simple change overall. Based on testing the bots do respond to commands via whisper and group. Edit: Relevant PR this addresses. `50f8f145d2 (diff-baadebd8cd1117ca48225f316a5ab3fd5fd55b20963394d302341147183db067)`	2025-11-23 20:45:31 +01:00
Crow	cf743a186a	Fix Wrong Misdirection Spell ID for Gruul's Lair and Magtheridon Strategies (#1867 ) Lol oops. Confirmed with logs/in-game that the prior one was wrong (and thus always returning false) and current one is correct.	2025-11-23 10:06:19 +01:00
blinkysc	10213d8381	Add thread safety for group operations (#1816 ) Fixes crashes and race conditions when bots perform group/guild/arena operations by moving thread-unsafe code to world thread. Potentially fixes #1124 ## Changes - Added operation queue system that runs in world thread - Group operations (invite, remove, convert to raid, set leader) now queued - Arena formation refactored to use queue - Guild operations changed to use packet queueing ## Testing Set `MapUpdate.Threads` > 1 in worldserver.conf to enable multiple map threads, then test: - Group formation and disbanding - Arena team formation - Guild operations (invite, promote, demote, remove) - Run with TSAN cmake ../ \ -DCMAKE_CXX_FLAGS="-fsanitize=thread -g -O1" \ -DCMAKE_C_FLAGS="-fsanitize=thread -g -O1" \ -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=thread" \ -DCMAKE_INSTALL_PREFIX=/path/to/install \ -DCMAKE_BUILD_TYPE=RelWithDebInfo build export TSAN_OPTIONS="log_path=tsan_report:halt_on_error=0:second_deadlock_stack=1" ./worldserver The crashes/race conditions should no longer occur with concurrent map threads. ## New Files - `PlayerbotOperation.h` - Base class defining the operation interface (Execute, IsValid, GetPriority) - `PlayerbotOperations.h` - Concrete implementations: GroupInviteOperation, GroupRemoveMemberOperation, GroupConvertToRaidOperation, GroupSetLeaderOperation, ArenaGroupFormationOperation - `PlayerbotWorldThreadProcessor.h/cpp` - Singleton processor with mutex-protected queue, processes operations in WorldScript::OnUpdate hook, handles batch processing and validation --------- Co-authored-by: blinkysc <blinkysc@users.noreply.github.com> Co-authored-by: SaW <swerkhoven@outlook.com> Co-authored-by: bash <hermensb@gmail.com>	2025-11-21 21:55:55 +01:00
bashermens	d97870facd	fix: warning updating movement flags while rooted (#1858 ) fixes https://github.com/mod-playerbots/mod-playerbots/issues/1854 ----- Also includes fixes for: ----- * Bots swimming with waterWalk kept switching between swimming and walking, as result jittering effect swimming under water when water walking active * Bots flying close above water they would land on water and start walking, now they stay flying unless on solid ground they will land and start walking by design ----- Moved all flag setting to updateMovementState: * So all movement flag are handled in updateMovementState which also contains the restricted movement logic. * Handle restricted movement logic and preventing SendMovementFlagUpdate while being restricted. ----- Known issue when flying the following bots feel a bit jittering, wont touch for now at least till core movement changes quirks has been dealt with. The current code is the extended version of what is originally was before core merge with refactored movements. Once the core movement refactors are settled a bit more i would like to revisit this code; as i would expect more imperative code and less manual flag setting e.g. bot->SetWaterWalking, SetGravitiy..SetCanFly etc.	2025-11-21 20:45:23 +01:00
Alex Dcnh	0c1700c117	CORE - Improved language detection for bots (#1784 ) I've had this problem for a long time, my bots only speak English even though I'm playing on a French client. I suppose this must be the case for some other people who do not have a large number of players with the same local client. If we use French DBCs, the bots bug because they only recognize US DBCs. From what I understand, the language is chosen as follows: On load, the module reads the entire `ai_playerbot_texts` table and stores each text variant in a dictionary indexed by the locale ID: the `text` column remains the default value (English), and the `text_loc1` to `text_loc8` columns fill slots 1 through 8. Whenever a real player connects, the module increments a counter for that player's DBC locale using `AddLocalePriority(player->GetSession()->GetSessionDbcLocale())`. When a bot needs a text, `GetLocalePriority()` returns the most frequently used locale index among currently connected players. The corresponding string is then retrieved. if the box is empty, we fall back to the English version (text[0]). ### This PR improve language detection. Summary - log both the client DBC locale and the account database locale when a player logs in - fall back to the account locale when the client reports enUS but the account is configured for another locale - keep the existing vote-based selection so bots always speak the majority language among connected players Therefore, the original behavior is maintained. Bots still choose the most represented language among connected players (the counter is simply more efficient by prioritizing the account's locale when it differs from the client's English). For example, if more English-speaking players are connected, the language will revert to English, as the bots always share the majority locale.	2025-11-21 15:56:03 +01:00
Alex Dcnh	0b1b0eaecc	Core - Fix RTSC SeeSpellAction crash on malformed WorldPacket (#1841 ) ## Summary This PR fixes the Crash 1 Source from Issue [#1840](https://github.com/mod-playerbots/mod-playerbots/issues/1840) posted in a @Regrad posted logs, in `SeeSpellAction::Execute` when an RTSC "see spell" event arrives with an empty or malformed `WorldPacket`. In that case the code used to read from the packet without any validation, causing a `ByteBufferException` and a crash in the map thread. ## Fix - Reset the packet read position and check that the RTSC header (castCount + spellId + castFlags) fits into the packet before reading. - Wrap `SpellCastTargets::Read` in a `try { } catch (ByteBufferException const&) { }` block so truncated RTSC payloads are handled gracefully. - Check that `targets.GetDst()` is not `nullptr` before accessing its position. For valid RTSC packets the behavior is unchanged; malformed packets are now safely ignored instead of crashing the server. ## Testing - Sent bots to multiple locations using RTSC and verified they still move as before. - Reproduced the previous crash scenario with malformed RTSC packets: the worldserver no longer crashes and the event is simply ignored. --------- Co-authored-by: bash <hermensb@gmail.com> Co-authored-by: bashermens <31279994+hermensbas@users.noreply.github.com>	2025-11-21 13:18:14 +01:00
Gonzalo	8e03371147	Balance-Druid-improve-Starfall-usage-and-add-CC-safety (#1713 ) - Move Starfall from default actions to AOE strategy only - Require 2+ enemies for Starfall usage (prevents single-target casting) - Add CC safety: avoid casting Starfall near current CC targets - Prioritize Starfall over Hurricane in medium AOE situations - Remove Starfall from pull/opener rotation to prevent early single-target usage This prevents Balance druids from wasting Starfall on single targets and breaking crowd control effects in group content.	2025-11-19 21:00:59 +01:00
SaW	27311b734d	Revert "feat: Improve bot mount behavior to faster close distance between bot and master" (#1855 ) Reverts mod-playerbots/mod-playerbots#1760 This, as it is causing issues in BG, where bots just don't dismount and just stand there instead. <img width="2336" height="1374" alt="image" src="https://github.com/user-attachments/assets/b61d7a77-1561-4f05-a438-edbb9321e113" />	2025-11-18 20:06:24 +01:00
SaW	bb5ed37cd3	Update codestyle_cpp.yml for review events and concurrency (#1836 ) Include ready_for_review type, to run when draft is converted to ready. Include concurrency; cancels obsolete tasks on new commits.	2025-11-18 18:48:52 +01:00
Jay	e88c1b779b	Minor README.md corrections (#1849 ) - Removed double "is" in acknowledgements - Made the acknowledgements section more grammatical by using "based on" instead of "based off" - Corrected misspelling of "implemented" - Standardized instances of "Playerbots" to `mod-playerbots` or properly capitalized `Playerbots` - Minor change of "for the continued contributions" to "for their continued contributions" in the Acknowledgements section	2025-11-18 18:08:16 +01:00
Tecc	05057ae9b5	feat: Improve bot mount behavior to faster close distance between bot and master (#1760 ) # Fix bot mount behavior when master dismounts ## Summary Improves bot mount/dismount logic to ensure better coordination with the master player. The bot now remains mounted when closing distance to a recently dismounted master and mounts up to assist the master in combat. The changes have been tested using the testcases described in the second half of the PR description, which provide some directions on how this PR can be tested and verified. Closes: #1660 ## Changes - Add masterInCombat variable to track master combat state - Modify target-based logic to consider master combat state - Change mount priority when bot is not in combat to favor master-following - Remove combatReach from distance calculations (duplicate) ## Implementation Added two methods: - `StayMountedToCloseDistance()` - prevents premature dismounting when the master dismounts - `ShouldMountToCloseDistance()` - determines when to mount for master assistance, even if master is not mounted at this time Modified Execute() method: - Target-based shouldMount/shouldDismount considers the master's combat state - Combat assistance logic separated from general following - Mount when master in combat, but the bot is not Distance logic: - Combat: dismount at CalculateDismountDistance() (18-25 yards) - Non-combat: dismount at 10 yards - Mount threshold: 21+ yards ## Result - Bots mount to assist masters in combat - Bots stay mounted longer during travel - Different dismount distances based on context - Existing mount selection logic unchanged # Mount Behavior Testing ## Prerequisites 1. Add a test bot: `.playerbots bot add <charactername>` or `.playerbots bot addclass <class>` 2. Test in a level-appropriate outdoor area (mobs should not die with one hit, as this makes testing combat assistance impossible) 3. Both master and bot must have mounts available ## Test 1: Combat Assistance Mounting Objective: Verify bot mounts to assist the master in combat Detailed Steps: 1. Position both master and bot dismounted 2. Command bot to stay: `/w <botname> stay` 3. Move master 35+ yards away from bot 4. Target a nearby mob and attack the mob 5. Command bot to assist: `/w <botname> follow` Expected Results: - Bot immediately mounts up (within 1-2 seconds cast time) - Bot rides toward master while mounted - Bot dismounts at ~18-25 yards from master/mob - Bot engages in combat to assist Failure Indicators: - Bot runs dismounted (old behavior) - Bot never mounts despite distance - Bot mounts but doesn't dismount at proper assist range ## Test 2: Non-Combat Dismount Distance Objective: Verify bot stays mounted longer during peaceful travel Detailed Steps: 1. Both master and bot start dismounted 2. Mount up: use any mount 3. Verify bot also mounts: `/w <botname> follow` 4. Travel together for 10+ seconds to establish following 5. While moving, dismount master but continue running 6. Observe bot behavior as you move away Expected Results: - Bot stays mounted while master runs dismounted - Bot only dismounts when within ~10 yards of master ## Test 3: Target Interference Prevention Objective: Verify target selection doesn't prevent mounting when master needs help Detailed Steps: 1. Position bot 35+ yards from master: `/w <botname> stay` then move away 2. Find a mob visible to both master and bot 3. Target the mob (do not attack): click on mob to select it 4. Verify bot can see the target: `/w <botname> attack` (bot should respond about target) 5. Cancel bot attack: `/w <botname> follow` 6. Now attack the mob yourself (master enters combat) 7. Observe bot behavior immediately after master engages Expected Results: - Bot mounts up despite having the same target selected - Bot rides toward combat area while mounted - Bot dismounts at assist range (~18-25 yards) - Target selection does not prevent proper mount behavior Failure Indicators: - Bot runs dismounted toward target (target interference) - Bot doesn't mount because it's "focused on target" ## Test 4: Basic Mount Following Objective: Verify fundamental mount matching still works Detailed Steps: 1. Start both master and bot dismounted 2. Ensure bot is following: `/w <botname> follow` 3. Mount up on any available mount 4. Wait 2-3 seconds and observe bot 5. Test different mount speeds if available (60%, 100%, 280% speed) 6. Test dismounting and remounting Expected Results: - Bot mounts within 2-3 seconds of master mounting - Bot uses appropriate mount speed to match master - Bot dismounts when master dismounts (basic following) - No regression in basic mount following behavior ## Test 5: Distance-Based Mounting Threshold Objective: Verify bot mounts at efficient distance threshold (21+ yards) Detailed Steps: 1. Both master and bot start dismounted in safe area (no mobs) 2. Command bot to stay: `/w <botname> stay` 3. Record starting position: `.gps` 4. Walk exactly 15 yards away (short distance) 5. Command bot to follow: `/w <botname> follow` 6. Observe: bot should run dismounted (distance too short) 7. Command bot to stay again: `/w <botname> stay` 8. Walk to 25+ yards away from bot 9. Record new position: `.gps` 10. Command bot to follow: `/w <botname> follow` Expected Results: - At 15 yards: Bot runs dismounted (inefficient to mount) - At 25+ yards: Bot mounts up immediately (efficient distance) - Distance threshold should be ~21 yards based on mount cast time efficiency Distance Calculation: Use coordinates from `.gps` to verify exact distances ## Test 6: Druid Form Integration (Druid Master Required) Objective: Verify druid form compatibility with mount system Detailed Steps: 1. Master must be druid with travel form available 2. Start both dismounted: `/w <botname> follow` 3. Shift master to travel form 4. Observe bot response (should mount or shift if druid) 5. Travel together for 10+ seconds 6. Shift master to normal form while moving 7. Observe bot dismount behavior 8. If available, test flight form in appropriate zones Expected Results: - Druid bot: matches master's form (travel form) - Non-druid bot: uses equivalent mount speed - Form changes trigger appropriate bot responses - Speed matching works between forms and mounts ## Test 7: Battleground Mount Behavior Objective: Verify mount behavior works in PvP environments Detailed Steps: 1. Queue for battleground with bot in party 2. Enter battleground together 3. Test basic mount following in BG 4. Test flag-carrying restrictions (WSG/EotS) 5. Test mounting during BG combat scenarios Expected Results: - Bot mounts appropriately in battlegrounds - Flag carrying prevents mounting - Combat assistance mounting still works in PvP	2025-11-16 22:49:12 +01:00
bashermens	610a032379	Bots fly/follow (movePoint core refactor), water walking fixes (#1825 ) Closer the original solution, i dont wanna drift to much away without really good reason. At this point i still see NPC and bots moving through the levels or even falling out the levels here and there. I verified whether the MovePoint signature changes and related params itself in playerbots has anything todo with it, even when params are hardcoded the behavior remains. It could be deeper problem, but for now it seems core problem. Therefore i dont wanna change to much until the dust has settled a bit in core itself. I havent implemented moveTakeOff or moveLand which are basically responsible for the transitions phases between ground and air visa versa. I have version where i use takeOff for the animation, which means moving vertical. For now i am gonna leave for what it is. PS: also includes additional movement fix for AreaTriggerAction which we missed first time after the core update on movements. @Wishmaster117 Been testing and trying a lot in the background on find solutions and causes. The general solutions remains removed some tweaks, altered code here and there. With the general idea to keep closer to the original code for now at least. Testing: - Class abilities: Slow fall (priest), Flight Form (druid) : Green - BG: Green - Swimming and walking shallow waters: Green - Takeoff and land when following master: Green - Boat and zeppelins: Green - Flymount and ground walking: Green - Water Walking (shaman), Path of Frost (DK): Green - Water Walking (shaman), Path of Frost (DK) transisions; flying, swimming, water walking: Green Skipping pets when group water walking, path of frost, once core pathing changes has settled more i will add it. Which is easy but i dont wanna add more edge cases and code branches for now.	2025-11-16 22:39:46 +01:00