Update PULL_REQUEST_TEMPLATE.md

IsHealAssistantOfIndex() and IsRangedDpsAssistantOfIndex() are supposed
to iterate through the group and first return members with the
applicable role that have the assistant flag, and then iterate through
non-assistants only if there are not enough assistants for the
designated index. They are not written properly and actually completely
ignore the assistant flag.

I rely on these functions for significant roles in SSC and TK (which I
have decided I'll PR in the same way as SSC, as a long-term draft). I
have them fixed on my own fork, but it is problematic for testers if
these functions do not work.

So I've done three things here:
1. Fixed the functions to prefer members with the assistant flag.
2. Added a third parameter for ignoreDeadPlayers, like
IsAssistTankOfIndex() has. Note that the parameter is by default false
for IsAssistTankOfIndex(), meaning dead players are _not_ ignored. This
is not my preferred design choice--I think the default should be to
ignore dead players, but I have not changed the default and have made
the default the same for IsAssistHealOfIndex() and
IsAssistRangedDpsOfIndex(), since I don't know the intent of the
pre-existing boss strats that use the functions.
3. Changed the names to IsAssistHealOfIndex() and
IsAssistRangedDpsOfIndex() so they parallel IsAssistTankOfIndex(), and
made corresponding changes in the few boss strats that use the
functions.

Also, note that the functions _do _not_ exclude real players. I think
there are arguments for and against excluding real players. A fourth
parameter for this could be useful, but I've not made any change in that
regard.

.github/workflows/windows_build.yml

@@ -25,21 +25,25 @@ jobs:
         with:
           repository: 'mod-playerbots/azerothcore-wotlk'
           ref: 'Playerbot'
+          path: 'ac'
       - name: Checkout Playerbot Module
         uses: actions/checkout@v3
         with:
           repository: 'mod-playerbots/mod-playerbots'
-          path: 'modules/mod-playerbots'
+          #path: 'modules/mod-playerbots'
+          path: ac/modules/mod-playerbots
       - name: ccache
         uses: hendrikmuhs/ccache-action@v1.2.13
       - name: Configure OS
         shell: bash
+        working-directory: ac
         env:
           CONTINUOUS_INTEGRATION: true
         run: |
           ./acore.sh install-deps
       - name: Build
         shell: bash
+        working-directory: ac
         run: |
           export CTOOLS_BUILD=all
           ./acore.sh compiler build

PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,126 @@
+# Pull Request
+
+Describe what this change does and why it is needed...
+
+---
+
+## Design Philosophy
+
+We prioritize **stability, performance, and predictability** over behavioral realism.  
+Complex player-mimicking logic is intentionally limited due to its negative impact on scalability, maintainability, and
+long-term robustness.
+
+Excessive processing overhead can lead to server hiccups, increased CPU usage, and degraded performance for all
+participants. Because every action and
+decision tree is executed **per bot and per trigger**, even small increases in logic complexity can scale poorly and
+negatively affect both players and
+world (random) bots. Bots are not expected to behave perfectly, and perfect simulation of human decision-making is not a
+project goal. Increased behavioral
+realism often introduces disproportionate cost, reduced predictability, and significantly higher maintenance overhead.
+
+Every additional branch of logic increases long-term responsibility. All decision paths must be tested, validated, and
+maintained continuously as the system evolves.
+If advanced or AI-intensive behavior is introduced, the **default configuration must remain the lightweight decision
+model**. More complex behavior should only be
+available as an **explicit opt-in option**, clearly documented as having a measurable performance cost.
+
+Principles:
+
+- **Stability before intelligence**  
+  A stable system is always preferred over a smarter one.
+
+- **Performance is a shared resource**  
+  Any increase in bot cost affects all players and all bots.
+
+- **Simple logic scales better than smart logic**  
+  Predictable behavior under load is more valuable than perfect decisions.
+
+- **Complexity must justify itself**  
+  If a feature cannot clearly explain its cost, it should not exist.
+
+- **Defaults must be cheap**  
+  Expensive behavior must always be optional and clearly communicated.
+
+- **Bots should look reasonable, not perfect**  
+  The goal is believable behavior, not human simulation.
+
+Before submitting, confirm that this change aligns with those principles.
+
+---
+
+## Feature Evaluation
+
+Please answer the following:
+
+- Describe the **minimum logic** required to achieve the intended behavior?
+- Describe the **cheapest implementation** that produces an acceptable result?
+- Describe the **runtime cost** when this logic executes across many bots?
+
+---
+
+## How to Test the Changes
+
+- Step-by-step instructions to test the change
+- Any required setup (e.g. multiple players, bots, specific configuration)
+- Expected behavior and how to verify it
+
+## Complexity & Impact
+
+- Does this change add new decision branches?
+    - [ ] No
+    - [ ] Yes (**explain below**)
+
+- Does this change increase per-bot or per-tick processing?
+    - [ ] No
+    - [ ] Yes (**describe and justify impact**)
+
+- Could this logic scale poorly under load?
+    - [ ] No
+    - [ ] Yes (**explain why**)
+
+---
+
+## Defaults & Configuration
+
+- Does this change modify default bot behavior?
+    - [ ] No
+    - [ ] Yes (**explain why**)
+
+If this introduces more advanced or AI-heavy logic:
+
+- [ ] Lightweight mode remains the default
+- [ ] More complex behavior is optional and thereby configurable
+
+---
+
+## AI Assistance
+
+- Was AI assistance (e.g. ChatGPT or similar tools) used while working on this change?
+    - [ ] No
+    - [ ] Yes (**explain below**)
+
+If yes, please specify:
+
+- AI tool or model used (e.g. ChatGPT, GPT-4, Claude, etc.)
+- Purpose of usage (e.g. brainstorming, refactoring, documentation, code generation)
+- Which parts of the change were influenced or generated
+- Whether the result was manually reviewed and adapted
+
+AI assistance is allowed, but all submitted code must be fully understood, reviewed, and owned by the contributor.
+Any AI-influenced changes must be verified against existing CORE and PB logic. We expect contributors to be honest
+about what they do and do not understand.
+---
+
+## Final Checklist
+
+- [ ] Stability is not compromised
+- [ ] Performance impact is understood, tested, and acceptable
+- [ ] Added logic complexity is justified and explained
+- [ ] Documentation updated if needed
+
+---
+
+## Notes for Reviewers
+
+Anything that significantly improves realism at the cost of stability or performance should be carefully discussed
+before merging.

conf/playerbots.conf.dist

@@ -3,8 +3,9 @@
 ##################################################
 
 # Overview
-# "Randombot": randomly generated bots that log in separately from players and populate the world. Depending on settings, randombots may automatically grind, quest, and upgrade equipment and can be invited to groups and given commands.
-# "Altbot": characters created on player accounts, which may be logged in by the player and invited to groups and given commands like randombots. Depending on settings, altbots can be limited to characters on the active player's account or in the active player's guild.
+# "Randombot": randomly generated bots that log in separately from players and populate the world. Randombots may automatically grind, quest, level up, and upgrade equipment and can be invited to groups and given commands.
+# "AddClass bot": bots from the AddClassAccountPoolSize accounts. They are used for quickly adding a leveled and geared bot of any class to your party. They are recommended for a quick formation of a party.
+# "Altbot": characters created on player accounts, which may be logged in by the player and invited to groups and given commands like randombots. They are best suited for long-progression playthroughs.
 # Information about commands to control bots and set their strategies can be found on the wiki at https://github.com/mod-playerbots/mod-playerbots/wiki/Playerbot-Commands.
 
 ####################################################################################################
@@ -269,7 +270,7 @@ AiPlayerbot.UseFastFlyMountAtMinLevel = 70
 AiPlayerbot.RandomBotShowHelmet = 1
 AiPlayerbot.RandomBotShowCloak = 1
 
-# Randombots and altbots automatically equip any items in their inventory that are sufficient upgrades
+# Toggles whether altbots will automatically equip items in their inventory that are sufficient upgrades
 # Default: 1 (enabled)
 AiPlayerbot.AutoEquipUpgradeLoot = 1
 
@@ -669,7 +670,7 @@ AiPlayerbot.DisableDeathKnightLogin = 0
 # Default: 0 (disabled)
 AiPlayerbot.LimitTalentsExpansion = 0
 
-# Configure randombots and addClass bot trading (0: Disabled, 1: Enabled, 2: Only Buy, 3: Only Sell)
+# Configure randombot trading (0: Disabled, 1: Enabled, 2: Only Buy, 3: Only Sell)
 # Default: 1 (enabled)
 AiPlayerbot.EnableRandomBotTrading = 1
 

src/Ai/Base/Actions/AcceptInvitationAction.cpp

@@ -49,7 +49,7 @@ bool AcceptInvitationAction::Execute(Event event)
     if (sRandomPlayerbotMgr->IsRandomBot(bot))
         botAI->SetMaster(inviter);
     // else
-    // sPlayerbotDbStore->Save(botAI);
+    // sPlayerbotRepository->Save(botAI);
 
     botAI->ResetStrategies();
     botAI->ChangeStrategy("+follow,-lfg,-bg", BOT_STATE_NON_COMBAT);

src/Ai/Base/Actions/AutoMaintenanceOnLevelupAction.cpp

@@ -75,36 +75,79 @@ void AutoMaintenanceOnLevelupAction::LearnSpells(std::ostringstream* out)
 void AutoMaintenanceOnLevelupAction::LearnTrainerSpells(std::ostringstream* out)
 {
     PlayerbotFactory factory(bot, bot->GetLevel());
+    factory.InitSkills();
     factory.InitClassSpells();
     factory.InitAvailableSpells();
-    factory.InitSkills();
     factory.InitPet();
 }
 
 void AutoMaintenanceOnLevelupAction::LearnQuestSpells(std::ostringstream* out)
 {
-    // CreatureTemplate const* co = sCreatureStorage.LookupEntry<CreatureTemplate>(id);
     ObjectMgr::QuestMap const& questTemplates = sObjectMgr->GetQuestTemplates();
     for (ObjectMgr::QuestMap::const_iterator i = questTemplates.begin(); i != questTemplates.end(); ++i)
     {
-        //uint32 questId = i->first; //not used, line marked for removal.
         Quest const* quest = i->second;
 
-        if (!quest->GetRequiredClasses() || quest->IsRepeatable() || quest->GetMinLevel() < 10)
+        // only process class-specific quests to learn class-related spells, cuz
+        // we don't want all these bunch of entries to be handled!
+        if (!quest->GetRequiredClasses())
             continue;
 
-        if (!bot->SatisfyQuestClass(quest, false) || quest->GetMinLevel() > bot->GetLevel() ||
-            !bot->SatisfyQuestRace(quest, false))
+        // skip quests that are repeatable, too low level, or above bots' level
+        if (quest->IsRepeatable() || quest->GetMinLevel() < 10 || quest->GetMinLevel() > bot->GetLevel())
             continue;
 
-        if (quest->GetRewSpellCast() > 0)
+        // skip if bot doesnt satisfy class, race, or skill requirements
+        if (!bot->SatisfyQuestClass(quest, false) || !bot->SatisfyQuestRace(quest, false) ||
+            !bot->SatisfyQuestSkill(quest, false))
+            continue;
+
+        // use the same logic and impl from Player::learnQuestRewardedSpells
+
+        int32 spellId = quest->GetRewSpellCast();
+        if (!spellId)
+            continue;
+
+        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
+        if (!spellInfo)
+            continue;
+
+        // xinef: find effect with learn spell and check if we have this spell
+        bool found = false;
+        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
         {
-            LearnSpell(quest->GetRewSpellCast(), out);
+            if (spellInfo->Effects[i].Effect == SPELL_EFFECT_LEARN_SPELL && spellInfo->Effects[i].TriggerSpell &&
+                !bot->HasSpell(spellInfo->Effects[i].TriggerSpell))
+            {
+                // pusywizard: don't re-add profession specialties!
+                if (SpellInfo const* triggeredInfo = sSpellMgr->GetSpellInfo(spellInfo->Effects[i].TriggerSpell))
+                    if (triggeredInfo->Effects[0].Effect == SPELL_EFFECT_TRADE_SKILL)
+                        break; // pussywizard: break and not cast the spell (found is false)
+
+                found = true;
+                break;
+            }
         }
-        else if (quest->GetRewSpell() > 0)
+
+        // xinef: we know the spell, continue
+        if (!found)
+            continue;
+
+        bot->CastSpell(bot, spellId, true);
+
+        // Check if RewardDisplaySpell is set to output the proper spell learned
+        // after processing quests. Output the original RewardSpell otherwise.
+        uint32 rewSpellId = quest->GetRewSpell();
+        if (rewSpellId)
         {
-            LearnSpell(quest->GetRewSpell(), out);
+            if (SpellInfo const* rewSpellInfo = sSpellMgr->GetSpellInfo(rewSpellId))
+            {
+                *out << FormatSpell(rewSpellInfo) << ", ";
+                continue;
+            }
         }
+
+        *out << FormatSpell(spellInfo) << ", ";
     }
 }
 
@@ -121,39 +164,6 @@ std::string const AutoMaintenanceOnLevelupAction::FormatSpell(SpellInfo const* s
     return out.str();
 }
 
-void AutoMaintenanceOnLevelupAction::LearnSpell(uint32 spellId, std::ostringstream* out)
-{
-    SpellInfo const* proto = sSpellMgr->GetSpellInfo(spellId);
-    if (!proto)
-        return;
-
-    bool learned = false;
-    for (uint8 j = 0; j < 3; ++j)
-    {
-        if (proto->Effects[j].Effect == SPELL_EFFECT_LEARN_SPELL)
-        {
-            uint32 learnedSpell = proto->Effects[j].TriggerSpell;
-
-            if (!bot->HasSpell(learnedSpell))
-            {
-                bot->learnSpell(learnedSpell);
-                *out << FormatSpell(sSpellMgr->GetSpellInfo(learnedSpell)) << ", ";
-            }
-
-            learned = true;
-        }
-    }
-
-    if (!learned)
-    {
-        if (!bot->HasSpell(spellId))
-        {
-            bot->learnSpell(spellId);
-            *out << FormatSpell(proto) << ", ";
-        }
-    }
-}
-
 void AutoMaintenanceOnLevelupAction::AutoUpgradeEquip()
 {
     if (!sPlayerbotAIConfig->autoUpgradeEquip || !sRandomPlayerbotMgr->IsRandomBot(bot))

src/Ai/Base/Actions/AutoMaintenanceOnLevelupAction.h

@@ -28,7 +28,6 @@ protected:
     void LearnSpells(std::ostringstream* out);
     void LearnTrainerSpells(std::ostringstream* out);
     void LearnQuestSpells(std::ostringstream* out);
-    void LearnSpell(uint32 spellId, std::ostringstream* out);
     std::string const FormatSpell(SpellInfo const* sInfo);
 };
 

src/Ai/Base/Actions/ChangeStrategyAction.cpp

@@ -6,7 +6,7 @@
 #include "ChangeStrategyAction.h"
 
 #include "Event.h"
-#include "PlayerbotDbStore.h"
+#include "PlayerbotRepository.h"
 #include "Playerbots.h"
 
 bool ChangeCombatStrategyAction::Execute(Event event)
@@ -24,7 +24,7 @@ bool ChangeCombatStrategyAction::Execute(Event event)
                 case '+':
                 case '-':
                 case '~':
-                    sPlayerbotDbStore->Save(botAI);
+                    sPlayerbotRepository->Save(botAI);
                     break;
                 case '?':
                     break;
@@ -62,7 +62,7 @@ bool ChangeNonCombatStrategyAction::Execute(Event event)
                 case '+':
                 case '-':
                 case '~':
-                    sPlayerbotDbStore->Save(botAI);
+                    sPlayerbotRepository->Save(botAI);
                     break;
                 case '?':
                     break;

src/Ai/Base/Actions/FishingAction.cpp

@@ -261,7 +261,9 @@ bool MoveNearWaterAction::isUseful()
         return false;
     FishingSpotValue* fishingSpotValueObject = (FishingSpotValue*)context->GetValue<WorldPosition>("fishing spot");
     WorldPosition pos = fishingSpotValueObject->Get();
-    return !pos.IsValid() || fishingSpotValueObject->IsStale(FISHING_LOCATION_TIMEOUT) || pos != bot->GetPosition();
+    return !pos.IsValid() || fishingSpotValueObject->IsStale(FISHING_LOCATION_TIMEOUT) ||
+           bot->GetExactDist(&pos) < 0.1f;
+
 }
 
 bool MoveNearWaterAction::isPossible()
@@ -299,6 +301,17 @@ bool MoveNearWaterAction::isPossible()
             }
         }
     }
+    // Can the bot fish from current position?
+    WorldPosition waterAtCurrentPos =
+        FindWaterRadial(bot, bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(), bot->GetMap(),
+                        bot->GetPhaseMask(), MIN_DISTANCE_TO_WATER, MAX_DISTANCE_TO_WATER, SEARCH_INCREMENT, true);
+    if (waterAtCurrentPos.IsValid())
+    {
+        SET_AI_VALUE(WorldPosition, "fishing spot",
+                     WorldPosition(WorldPosition(bot->GetMapId(), bot->GetPositionX(), bot->GetPositionY(),
+                                                 bot->GetPositionZ())));
+        return false;
+    }
     // Lets find some water where we can fish.
     WorldPosition water = FindWaterRadial(
         bot, bot->GetPositionX(), bot->GetPositionY(), bot->GetPositionZ(),
@@ -435,10 +448,14 @@ bool FishingAction::isUseful()
 {
     if (!AI_VALUE(bool, "can fish"))
         return false;
+
     FishingSpotValue* fishingSpotValueObject = (FishingSpotValue*)context->GetValue<WorldPosition>("fishing spot");
     WorldPosition pos = fishingSpotValueObject->Get();
 
-    return pos.IsValid() && !fishingSpotValueObject->IsStale(FISHING_LOCATION_TIMEOUT) && pos == bot->GetPosition();
+    if (!pos.IsValid() || fishingSpotValueObject->IsStale(FISHING_LOCATION_TIMEOUT))
+        return false;
+
+    return bot->GetExactDist(&pos) < 0.1f;
 }
 
 bool UseBobberAction::isUseful()