Dont wait to travel when in combat.

Prevents bot adding a travel delay when in combat

src/PlayerbotAI.cpp

@@ -4214,19 +4214,6 @@ bool PlayerbotAI::AllowActive(ActivityType activityType)
         }
     }
 
-    // only keep updating till initializing time has completed,
-    // which prevents unneeded expensive GameTime calls.
-    if (_isBotInitializing)
-    {
-        _isBotInitializing = GameTime::GetUptime().count() < sPlayerbotAIConfig->maxRandomBots * 0.11;
-
-        // no activity allowed during bot initialization
-        if (_isBotInitializing)
-        {
-            return false;
-        }
-    }
-
     // General exceptions
     if (activityType == PACKET_ACTIVITY)
     {

src/PlayerbotAI.h

@@ -611,7 +611,6 @@ private:
     Item* FindItemInInventory(std::function<bool(ItemTemplate const*)> checkItem) const;
     void HandleCommands();
     void HandleCommand(uint32 type, const std::string& text, Player& fromPlayer, const uint32 lang = LANG_UNIVERSAL);
-    bool _isBotInitializing = false;
 
 protected:
     Player* bot;

src/PlayerbotMgr.cpp

@@ -529,6 +529,9 @@ void PlayerbotHolder::OnBotLogin(Player* const bot)
     {
         botAI->ResetStrategies(!sRandomPlayerbotMgr->IsRandomBot(bot));
     }
+
+    botAI->Reset(true);  // Reset transient states (incl. LFG "proposal") to avoid the "one or more players are not eligible" error after reconnect.
+
     sPlayerbotDbStore->Load(botAI);
 
     if (master && !master->HasUnitState(UNIT_STATE_IN_FLIGHT))
@@ -548,16 +551,21 @@ void PlayerbotHolder::OnBotLogin(Player* const bot)
     if (master && master->GetGroup() && !group)
     {
         Group* mgroup = master->GetGroup();
-        if (mgroup->GetMembersCount() >= 5)
+        // if (mgroup->GetMembersCount() >= 5)
+        if (mgroup->GetMembersCount() + 1 > 5)  // only convert in raid if the add of THIS bot make group > 5
         {
             if (!mgroup->isRaidGroup() && !mgroup->isLFGGroup() && !mgroup->isBGGroup() && !mgroup->isBFGroup())
             {
                 mgroup->ConvertToRaid();
             }
-            if (mgroup->isRaidGroup())
-            {
-                mgroup->AddMember(bot);
-            }
+            //if (mgroup->isRaidGroup())
+            //{
+                //mgroup->AddMember(bot);
+            //}
+            mgroup->AddMember(bot);
+
+            LOG_DEBUG("playerbots", "[GROUP] after add: members={}, isRaid={}, isLFG={}",
+                      (int)mgroup->GetMembersCount(), mgroup->isRaidGroup() ? 1 : 0, mgroup->isLFGGroup() ? 1 : 0);
         }
         else
         {

src/Playerbots.cpp

@@ -30,6 +30,7 @@
 #include "cs_playerbots.h"
 #include "cmath"
 #include "BattleGroundTactics.h"
+#include "ObjectAccessor.h"
 
 class PlayerbotsDatabaseScript : public DatabaseScript
 {
@@ -108,7 +109,7 @@ public:
                     "|cffcccccchttps://github.com/liyunfan1223/mod-playerbots|r");
             }
 
-            if (sPlayerbotAIConfig->enabled || sPlayerbotAIConfig->randomBotAutologin)
+            /*if (sPlayerbotAIConfig->enabled || sPlayerbotAIConfig->randomBotAutologin)
             {
                 std::string roundedTime =
                     std::to_string(std::ceil((sPlayerbotAIConfig->maxRandomBots * 0.11 / 60) * 10) / 10.0);
@@ -117,7 +118,7 @@ public:
                 ChatHandler(player->GetSession()).SendSysMessage(
                     "|cff00ff00Playerbots:|r bot initialization at server startup takes about '" 
                     + roundedTime + "' minutes.");
-            }
+            }*/
         }
     }
 
@@ -311,7 +312,7 @@ class PlayerbotsScript : public PlayerbotScript
 public:
     PlayerbotsScript() : PlayerbotScript("PlayerbotsScript") {}
 
-    bool OnPlayerbotCheckLFGQueue(lfg::Lfg5Guids const& guidsList) override
+    /*bool OnPlayerbotCheckLFGQueue(lfg::Lfg5Guids const& guidsList) override
     {
         bool nonBotFound = false;
         for (ObjectGuid const& guid : guidsList.guids)
@@ -325,7 +326,137 @@ public:
         }
 
         return nonBotFound;
+    }*/
+
+    // New LFG Function
+    bool OnPlayerbotCheckLFGQueue(lfg::Lfg5Guids const& guidsList)
+    {
+        const size_t totalSlots = guidsList.guids.size();
+        size_t ignoredEmpty = 0, ignoredNonPlayer = 0;
+        size_t offlinePlayers = 0, botPlayers = 0, realPlayers = 0;
+        bool groupGuidSeen = false;
+
+        LOG_DEBUG("playerbots", "[LFG] check start: slots={}", totalSlots);
+
+        for (size_t i = 0; i < totalSlots; ++i)
+        {
+            ObjectGuid const& guid = guidsList.guids[i];
+
+            // 1) Placeholders to ignore
+            if (guid.IsEmpty())
+            {
+                ++ignoredEmpty;
+                LOG_DEBUG("playerbots", "[LFG] slot {}: <empty> -> ignored", i);
+                continue;
+            }
+
+            // Group GUID: in the original implementation this counted as "non-bot found"
+            if (guid.IsGroup())
+            {
+                groupGuidSeen = true;
+                LOG_DEBUG("playerbots", "[LFG] slot {}: <GROUP GUID> -> counts as having a real player (compat)", i);
+                continue;
+            }
+
+            // Other non-Player GUIDs: various placeholders, ignore them
+            if (!guid.IsPlayer())
+            {
+                ++ignoredNonPlayer;
+                LOG_DEBUG("playerbots", "[LFG] slot {}: guid={} (non-player/high={}) -> ignored", i,
+                          static_cast<uint64>(guid.GetRawValue()), (unsigned)guid.GetHigh());
+                continue;
+            }
+
+            // 2) Player present?
+            Player* player = ObjectAccessor::FindPlayer(guid);
+            if (!player)
+            {
+                ++offlinePlayers;
+                LOG_DEBUG("playerbots", "[LFG] slot {}: player guid={} is offline/not in world", i,
+                          static_cast<uint64>(guid.GetRawValue()));
+                continue;
+            }
+
+            // 3) Bot or real player?
+            if (GET_PLAYERBOT_AI(player) != nullptr)
+            {
+                ++botPlayers;
+                LOG_DEBUG("playerbots", "[LFG] slot {}: BOT {} (lvl {}, class {})", i, player->GetName().c_str(),
+                          player->GetLevel(), player->getClass());
+            }
+            else
+            {
+                ++realPlayers;
+                LOG_DEBUG("playerbots", "[LFG] slot {}: REAL {} (lvl {}, class {})", i, player->GetName().c_str(),
+                          player->GetLevel(), player->getClass());
+            }
+        }
+
+        // "Ultra-early phase" detection: only placeholders => DO NOT VETO
+        const bool onlyPlaceholders = (realPlayers + botPlayers + (groupGuidSeen ? 1 : 0)) == 0 &&
+                                      (ignoredEmpty + ignoredNonPlayer) == totalSlots;
+
+        // "Soft" LFG preflight if we actually see players AND at least one offline
+        if (!onlyPlaceholders && offlinePlayers > 0)
+        {
+            // Find a plausible leader: prefer a real online player, otherwise any online player
+            Player* leader = nullptr;
+
+            for (ObjectGuid const& guid : guidsList.guids)
+                if (guid.IsPlayer())
+                    if (Player* p = ObjectAccessor::FindPlayer(guid))
+                        if (GET_PLAYERBOT_AI(p) == nullptr)
+                        {
+                            leader = p;
+                            break;
+                        }
+
+            if (!leader)
+                for (ObjectGuid const& guid : guidsList.guids)
+                    if (guid.IsPlayer())
+                        if (Player* p = ObjectAccessor::FindPlayer(guid))
+                        {
+                            leader = p;
+                            break;
+                        }
+
+            if (leader)
+            {
+                Group* g = leader->GetGroup();
+                if (g)
+                {
+                    LOG_DEBUG("playerbots", "[LFG-RESET] group members={}, isRaid={}, isLFGGroup={}",
+                              (int)g->GetMembersCount(), g->isRaidGroup() ? 1 : 0, g->isLFGGroup() ? 1 : 0);
+
+                    // "Soft" reset of LFG states on the bots' AI side (proposal/role-check, etc.)
+                    for (GroupReference* ref = g->GetFirstMember(); ref; ref = ref->next())
+                    {
+                        Player* member = ref->GetSource();
+                        if (!member)
+                            continue;
+
+                        if (PlayerbotAI* ai = GET_PLAYERBOT_AI(member))
+                            ai->Reset(true);
+                    }
+                }
+            }
+
+            LOG_DEBUG("playerbots", "[LFG] preflight soft-reset triggered (offline detected) -> allowQueue=no (retry)");
+            return false;  // ask the client to retry right after the reset
+        }
+
+        // "Hybrid" policy: permissive if only placeholders; otherwise original logic
+        bool allowQueue = onlyPlaceholders ? true : ((offlinePlayers == 0) && (realPlayers >= 1 || groupGuidSeen));
+
+        LOG_DEBUG("playerbots",
+                  "[LFG] summary: slots={}, real={}, bots={}, offline={}, ignored(empty+nonPlayer)={}, "
+                  "groupGuidSeen={} -> allowQueue={}",
+                  totalSlots, realPlayers, botPlayers, offlinePlayers, (ignoredEmpty + ignoredNonPlayer),
+                  (groupGuidSeen ? "yes" : "no"), (allowQueue ? "yes" : "no"));
+
+        return allowQueue;
     }
+    // End LFG
 
     void OnPlayerbotCheckKillTask(Player* player, Unit* victim) override
     {

src/factory/PlayerbotFactory.cpp

@@ -164,15 +164,16 @@ void PlayerbotFactory::Init()
         {
             continue;
         }
+        
         ItemTemplate const* proto = sObjectMgr->GetItemTemplate(gemId);
+        if (proto) {
+            if (proto->ItemLevel < 60)
+                continue;
 
-        if (proto->ItemLevel < 60)
-            continue;
-
-        if (proto->Flags & ITEM_FLAG_UNIQUE_EQUIPPABLE)
-        {
-            continue;
+            if (proto->Flags & ITEM_FLAG_UNIQUE_EQUIPPABLE)
+               continue;
         }
+        
         if (sRandomItemMgr->IsTestItem(gemId))
             continue;
 
@@ -180,9 +181,11 @@ void PlayerbotFactory::Init()
         {
             continue;
         }
+        
         // LOG_INFO("playerbots", "Add {} to enchantment gems", gemId);
         enchantGemIdCache.push_back(gemId);
     }
+    
     LOG_INFO("playerbots", "Loading {} enchantment gems", enchantGemIdCache.size());
 }
 
@@ -1017,14 +1020,16 @@ void PlayerbotFactory::ClearSkills()
     }
     bot->SetUInt32Value(PLAYER_SKILL_INDEX(0), 0);
     bot->SetUInt32Value(PLAYER_SKILL_INDEX(1), 0);
+
     // unlearn default race/class skills
-    PlayerInfo const* info = sObjectMgr->GetPlayerInfo(bot->getRace(), bot->getClass());
-    for (PlayerCreateInfoSkills::const_iterator itr = info->skills.begin(); itr != info->skills.end(); ++itr)
-    {
-        uint32 skillId = itr->SkillId;
-        if (!bot->HasSkill(skillId))
-            continue;
-        bot->SetSkill(skillId, 0, 0, 0);
+    if (PlayerInfo const* info = sObjectMgr->GetPlayerInfo(bot->getRace(), bot->getClass())) {
+        for (PlayerCreateInfoSkills::const_iterator itr = info->skills.begin(); itr != info->skills.end(); ++itr)
+        {
+            uint32 skillId = itr->SkillId;
+            if (!bot->HasSkill(skillId))
+                continue;
+            bot->SetSkill(skillId, 0, 0, 0);
+        }
     }
 }