mirror of
https://github.com/liyunfan1223/mod-playerbots.git
synced 2026-06-20 15:39:25 +02:00
## Pull Request Description
These changes I originally made for myself because as a person who
really likes to raid with bots, I felt like the current group buff
system is fundamentally broken, and I needed something more consistent
and optimal. I debated a lot whether to PR this because it's such an
extensive overhaul that was almost entirely reliant on AI, and I know
that wishmaster still has a PR open regarding the greater blessings. I
decided to after a couple of conversations so at least people can look
at it and see if it's something that they want.
The tl;dr version is that this PR overhauls buff handling in two related
areas:
1. It adds a dedicated greater blessing assignment system.
2. It generalizes party/raid reagent-buff handling for Paladins, Druids,
Mages, and Priests.
Under this PR, greater blessings are determined by assignments for the
current group, and those assignments are determined based on:
1. a hardcoded priority list of blessings for each spec;
2. the number of Paladins in the group; and
3. whether any Paladins have talents for Blessing of Sanctuary, Improved
Blessing of Might, or Improved Blessing of Wisdom.
Assignment determinations are cached in a value to avoid constant
reevaluation.
The exact priority list is:
- All casters: Kings, Wisdom, Sanctuary, Might
- Physical-only DPS (Rogues, Warriors, DKs): Might, Kings, Sanctuary,
N/A
- Hybrid DPS (Enh, Ret, Hunters, Cats): Might, Kings, Wisdom, Sanctuary
- Druid tanks: Kings, Might, Sanctuary, Wisdom
- Warrior and DK tanks: Kings, Might, Sanctuary, N/A
- Paladin tank: Sanctuary, Might, Wisdom, Kings
Note that Sanctuary is preferred over Kings for Paladin tanks because of
the mana regen component but deprioritized for other tanks because Kings
provides Agility. The extra 3% damage reduction from Sanctuary does not
stack with Disc Priests’ Renewed Hope, which will have 100% uptime.
For group buffs, logic is centralized so that class triggers use the
same gating and upgrade rules for Gift of the Wild, Arcane Brilliance,
Prayer of Fortitude, Prayer of Spirit, and Prayer of Shadow Protection.
Also, Shadow Protection is now a default strategy for Priests (rshadow,
which existed before but wasn’t added by default).
I’ve added a config setting for the greater blessing system and adjusted
the current config setting for group buffs. In each case, you can pick
whether to disable the feature entirely, use it in all groups, or use it
only in raid groups. The default is raid only for greater blessings and
all groups for group buffs. Note that for group buffs, even if the
config is enabled, they will be used only if at least 3 group/raid
members on the same map are missing the buff family. This is mainly to
stop group buff spamming during wipe recovery as bots are revived
one-by-one.
I renamed the Paladin buff strategies to align them with the actual
blessing names:
- `bhealth` -> `bsanc`
- `bmana` -> `bwisdom`
- `bdps` -> `bmight`
- `bstats` -> `bkings`
This is an intentional breaking change for saved strategy strings. Bots
will need a one-time strategy reset after update.
I removed bots telling you when they are out of reagents for greater
blessings. If people like that though, I can add it back.
A small cleanup is also included in TankPaladinStrategy: Holy Shield was
subject to three overlapping health triggers with the same priority; I
removed the two lower health thresholds which have no purpose.
## Feature Evaluation
- Describe the **minimum logic** required to achieve the intended
behavior.
I’m going to let the AI answer this one.
> The minimum logic is:
> - a shared config-gated check for whether group/raid buff variants are
allowed
> - a shared way to treat single and group variants as equivalent aura
families
> - a shared upgrade path from single-target buff to group buff when the
group variant is appropriate
> - a Paladin-only cached assignment model that decides which blessing
family each Paladin should cover for the current group
> - trigger/action wiring that only attempts casts when a group member
is actually missing the assigned buff
>
> This avoids scattering separate per-class heuristics across many
triggers and actions.
- Describe the **processing cost** when this logic executes across many
bots.
Processing cost should be minimal but non-zero. The general party buff
changes are limited to existing buff trigger paths and mostly replace
duplicated checks with shared helpers. They do not add expensive default
per-tick behavior outside those existing trigger evaluations.
The Paladin greater blessing logic does add extra decision-making, but
it is limited to Paladins, gated by config and group eligibility,
subject to a delayed trigger evaluation of only once per 4s, and cached
per group assignment set instead of recomputing the full assignment
model on every action attempt.
This PR also increases the throttle duration for group buff triggers to
limit performance impact; I’m open to adjustments to these durations:
- Mark of the Wild triggers were increased from 4s to 8s
- Arcane Intellect triggers were increased from 4s to 8s
- Priest buff triggers were increased to 8s (previously, Fortitude was
6s, Spirit was 4s, and Shadow Protection had no throttle)
- There is now a 5s delay on buffing (greater blessings and group buffs)
after bots log in—I was getting bots spamming buffs as soon as they
logged in even when it was not necessary
I’ve tested with pmon, and the impact is minimal—these are very cheap
triggers even compared to standard bot rotational ability triggers.
## How to Test the Changes
1. Try different config settings to confirm that they work to
enable/disable greater blessings/group buffs in the configured scenarios
2. For greater blessing changes:
- test with one Paladin in a party/raid
- test with multiple Paladins in a party/raid
- confirm the Paladins divide blessing coverage instead of repeatedly
overwriting each other
- include at least one Paladin with Improved Blessing of Might and make
sure it casts Might over Paladins without the talent; check the same
with a Paladin with Improved Blessing of Wisdom
- do not include a Paladin that knows Sanctuary, confirm any Paladin
tank receives Kings instead (you’ll need a low-level Paladin for this
since Sanctuary is a prot talent)
- confirm bots cast blessings only when a member is actually missing the
relevant blessing family
- confirm there is a 5s delay on buffing when bots log in
3. For group buff changes:
- confirm there is a 5s delay on buffing when bots log in
- confirm that single buffs are used when there aren’t at least three
unbuffed members in the same map, even if group buffs are enabled in the
config
4. For all buffs, test with reagents missing to confirm fallback to
single-target buffs and single blessings
5. Confirm the Paladin buff strategy names are changed after resetting
AI
## Impact Assessment
- Does this change increase per-bot/per-tick processing or risk scaling
poorly with thousands of bots?
- - [ ] No, not at all
- - [x] Minimal impact (**explain below**)
- - [ ] Moderate impact (**explain below**)
Discussed above in processing costs.
- Does this change modify default bot behavior?
- - [ ] No
- - [x] Yes (**explain why**)
Yes—that is the purpose of this PR, to change default buffing behavior.
- Does this change add new decision branches or increase maintenance
complexity?
- - [ ] No
- - [x] Yes (**explain below**)
Yes, but I think it’s inevitable to add complexity to get greater
blessings to function consistently, given the challenges brought by
their mechanic of applying across each class.
## AI Assistance
Was AI assistance used while working on this change?
- - [ ] No
- - [x] Yes (**explain below**)
I used GPT-5.4 extensively for this overhaul. It’s much more complicated
than I could handle on my own. I’ve done a lot of testing and have
reviewed the code and provided plenty of revisions, but I cannot say I
can perfectly explain each addition and how it works, not even close.
## Final Checklist
- - [x] Stability is not compromised.
- - [x] Performance impact is understood, tested, and acceptable.
- - [x] Added logic complexity is justified and explained.
- - [x] Any new bot dialogue lines are translated.
- - [x] Documentation updated if needed (Conf comments, WiKi commands).
## Notes for Reviewers
---------
Co-authored-by: Keleborn <22352763+Celandriel@users.noreply.github.com>
Co-authored-by: bash <hermensb@gmail.com>
Co-authored-by: Revision <tkn963@gmail.com>
Co-authored-by: kadeshar <kadeshar@gmail.com>
122 lines
3.5 KiB
C++
122 lines
3.5 KiB
C++
/*
|
|
* 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_PALADINBUFFSTRATEGIES_H
|
|
#define _PLAYERBOT_PALADINBUFFSTRATEGIES_H
|
|
|
|
#include "Strategy.h"
|
|
|
|
class PlayerbotAI;
|
|
|
|
class PaladinBuffManaStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinBuffManaStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "bwisdom"; }
|
|
};
|
|
|
|
class PaladinBuffHealthStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinBuffHealthStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "bsanc"; }
|
|
};
|
|
|
|
class PaladinBuffDpsStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinBuffDpsStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "bmight"; }
|
|
};
|
|
|
|
class PaladinBuffArmorStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinBuffArmorStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "barmor"; }
|
|
};
|
|
|
|
class PaladinBuffAoeStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinBuffAoeStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "baoe"; }
|
|
};
|
|
|
|
class PaladinBuffCastStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinBuffCastStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "bcast"; }
|
|
};
|
|
|
|
class PaladinBuffSpeedStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinBuffSpeedStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "bspeed"; }
|
|
};
|
|
|
|
class PaladinBuffThreatStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinBuffThreatStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "bthreat"; }
|
|
};
|
|
|
|
class PaladinBuffStatsStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinBuffStatsStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "bkings"; }
|
|
};
|
|
|
|
class PaladinShadowResistanceStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinShadowResistanceStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "rshadow"; }
|
|
};
|
|
|
|
class PaladinFrostResistanceStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinFrostResistanceStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "rfrost"; }
|
|
};
|
|
|
|
class PaladinFireResistanceStrategy : public Strategy
|
|
{
|
|
public:
|
|
PaladinFireResistanceStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
|
|
|
|
void InitTriggers(std::vector<TriggerNode*>& triggers) override;
|
|
std::string const getName() override { return "rfire"; }
|
|
};
|
|
|
|
#endif
|