Fix Hunter Aspect Switching + Trigger Cleanups (#2203)

# Pull Request

Note: When I reference Aspect of the Hawk below, it also means Aspect of
the Dragonhawk (the code will use Dragonhawk if the Hunter has it, Hawk
if not, they share actions, triggers, and strategies).

Hunter Aspects are currently bugged. All Hunters, regardless of spec or
strategy, are hardcoded to use Aspect of the Hawk when mana is at 70%+
and Aspect of the Viper when mana drops to "lowMana" from the config
(default is 15%), divided by 2.

This means the following:

- Hawk (bdps) and Viper (bmana) strategies are useless
- Pack (bspeed) and Wild (rnature) strategies are applied, but bots will
rapidly switch back and forth between Pack/Wild and Hawk/Viper,
depending on strategy and mana level.

This PR addresses the issues by doing the following:

- Global Hawk strategy is removed. Now you need to set bdps for Hunters
to use Hawk, but bdps remains the default Aspect strategy for all
Hunters.
- Dedicated Viper strategy is removed, leaving the global strategy.
However, Viper will be used (when lowMana/2) ONLY if the bot is set to
bdps. If the bot has the Wild or Pack strategy, they will not switch to
Viper at all. I did this because I am assuming if you are using Wild or
Pack, you need them for reasons other than to pump DPS.
- The threshold to switch back to Hawk is lowered from 70% to 60%. The
gap between lowMana/2 and 60% is now filled--if bdps is on, Hunters will
switch to Hawk whenever above the Viper threshold, _except_ for when
they have the Viper aura, in which case they will not switch to Hawk
until 60% mana. This lets the Hunter build back mana before swapping
back to Hawk (more like general player behavior) while still letting
them swap from other Aspects to Hawk without needing to be all the way
at 60% mana.
- Gets rid of a weird condition in the Hawk trigger that would make it
so that Hunters would switch to Hawk when at exactly 0 mana. I'm not
sure what the point of that is.

Also, I refactored the triggers a bit because I noticed there was some
dead code in there. I didn't do a comprehensive refactor, but there was
a lot of stuff that clearly didn't make sense even to my eyes, like
back-to-back returns. I think there's more unnecessary code even just in
the triggers, but I didn't want to get too into the weeds with this PR.

---

## 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?

I don't expect there to be any impact on costs, and if anything this PR
removes some unneeded checks from triggers.

---

## 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

The easiest way is to go shoot a dummy with Volley until low on mana and
then toggle on selfbot. You can do this with various Aspects active to
test.

## Complexity & Impact

Does this change add new decision branches?
- - [X] No
- - [ ] Yes (**explain below**)

Does this change increase per-bot or per-tick processing?
- - [X] No
- - [ ] Yes (**describe and justify impact**)

Could this logic scale poorly under load?
- - [X] No
- - [ ] Yes (**explain why**)
---

## Defaults & Configuration

Does this change modify default bot behavior?
- - [ ] No
- - [X] Yes (**explain why**)

Described above. Default behavior is broken.

If this introduces more advanced or AI-heavy logic:
- - [X] 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
- - [X] Yes (**explain below**)

I asked Claude some questions about the triggers to make sure I didn't
screw anything up.

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

- - [X] Stability is not compromised
- - [X] Performance impact is understood, tested, and acceptable
- - [X] Added logic complexity is justified and explained
- - [X] 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.

---------

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>

src/Ai/Class/Hunter/Action/HunterActions.cpp

@@ -16,18 +16,15 @@ bool CastViperStingAction::isUseful()
            AI_VALUE2(uint8, "mana", "current target") >= 30;
 }
 
-bool CastAspectOfTheCheetahAction::isUseful()
-{
-    return !botAI->HasAnyAuraOf(GetTarget(), "aspect of the cheetah", "aspect of the pack", nullptr);
-}
-
 bool CastAspectOfTheHawkAction::isUseful()
 {
     Unit* target = GetTarget();
     if (!target)
         return false;
+
     if (bot->HasSpell(61846) || bot->HasSpell(61847))  // Aspect of the Dragonhawk spell IDs
         return false;
+
     return true;
 }
 
@@ -36,11 +33,14 @@ bool CastArcaneShotAction::isUseful()
     Unit* target = GetTarget();
     if (!target)
         return false;
-    if (bot->HasSpell(53301) || bot->HasSpell(60051) || bot->HasSpell(60052) || bot->HasSpell(60053))  // Explosive Shot spell IDs
+
+    if (bot->HasSpell(53301) || bot->HasSpell(60051) ||
+        bot->HasSpell(60052) || bot->HasSpell(60053))  // Explosive Shot spell IDs
         return false;
 
     // Armor Penetration rating check - will not cast Arcane Shot above 435 ArP
-    int32 armorPenRating = bot->GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1) + bot->GetUInt32Value(CR_ARMOR_PENETRATION);
+    int32 armorPenRating =
+        bot->GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1) + bot->GetUInt32Value(CR_ARMOR_PENETRATION);
     if (armorPenRating > 435)
         return false;
 
@@ -52,18 +52,26 @@ bool CastImmolationTrapAction::isUseful()
     Unit* target = GetTarget();
     if (!target)
         return false;
-    if (bot->HasSpell(13813) || bot->HasSpell(14316) || bot->HasSpell(14317) || bot->HasSpell(27025) || bot->HasSpell(49066) || bot->HasSpell(49067)) // Explosive Trap spell IDs
+
+    if (bot->HasSpell(13813) || bot->HasSpell(14316) || bot->HasSpell(14317) || bot->HasSpell(27025) ||
+        bot->HasSpell(49066) || bot->HasSpell(49067)) // Explosive Trap spell IDs
         return false;
+
     return true;
 }
 
-Value<Unit*>* CastFreezingTrap::GetTargetValue() { return context->GetValue<Unit*>("cc target", "freezing trap"); }
+Value<Unit*>* CastFreezingTrap::GetTargetValue()
+{
+    return context->GetValue<Unit*>("cc target", "freezing trap");
+}
 
 bool FeedPetAction::Execute(Event /*event*/)
 {
-    if (Pet* pet = bot->GetPet())
+    if (Pet* pet = bot->GetPet(); pet && pet->getPetType() == HUNTER_PET &&
-        if (pet->getPetType() == HUNTER_PET && pet->GetHappinessState() != HAPPY)
+        pet->GetHappinessState() != HAPPY)
-            pet->SetPower(POWER_HAPPINESS, pet->GetMaxPower(Powers(POWER_HAPPINESS)));
+    {
+        pet->SetPower(POWER_HAPPINESS, pet->GetMaxPower(Powers(POWER_HAPPINESS)));
+    }
 
     return true;
 }
@@ -79,6 +87,7 @@ bool CastAutoShotAction::isUseful()
     {
         return false;
     }
+
     return AI_VALUE(uint32, "active spell") != AI_VALUE2(uint32, "spell id", getName());
 }
 
@@ -87,6 +96,7 @@ bool CastDisengageAction::Execute(Event event)
     Unit* target = AI_VALUE(Unit*, "current target");
     if (!target)
         return false;
+
     // can cast spell check passed in isUseful()
     bot->SetOrientation(bot->GetAngle(target));
     return CastSpellAction::Execute(event);
@@ -97,11 +107,20 @@ bool CastDisengageAction::isUseful()
     return !botAI->HasStrategy("trap weave", BOT_STATE_COMBAT);
 }
 
-Value<Unit*>* CastScareBeastCcAction::GetTargetValue() { return context->GetValue<Unit*>("cc target", "scare beast"); }
+Value<Unit*>* CastScareBeastCcAction::GetTargetValue()
+{
+    return context->GetValue<Unit*>("cc target", "scare beast");
+}
 
-bool CastScareBeastCcAction::Execute(Event /*event*/) { return botAI->CastSpell("scare beast", GetTarget()); }
+bool CastScareBeastCcAction::Execute(Event /*event*/)
+{
+    return botAI->CastSpell("scare beast", GetTarget());
+}
 
-bool CastWingClipAction::isUseful() { return CastSpellAction::isUseful() && !botAI->HasAura(spell, GetTarget()); }
+bool CastWingClipAction::isUseful()
+{
+    return CastSpellAction::isUseful() && !botAI->HasAura(spell, GetTarget());
+}
 
 std::vector<NextAction> CastWingClipAction::getPrerequisites()
 {

src/Ai/Class/Hunter/Action/HunterActions.h

@@ -19,52 +19,58 @@ class Unit;
 class CastTrueshotAuraAction : public CastBuffSpellAction
 {
 public:
-    CastTrueshotAuraAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "trueshot aura") {}
+    CastTrueshotAuraAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "trueshot aura") {}
+};
+
+class CastAspectOfTheDragonhawkAction : public CastBuffSpellAction
+{
+public:
+    CastAspectOfTheDragonhawkAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "aspect of the dragonhawk") {}
 };
 
 class CastAspectOfTheHawkAction : public CastBuffSpellAction
 {
 public:
-    CastAspectOfTheHawkAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "aspect of the hawk") {}
+    CastAspectOfTheHawkAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "aspect of the hawk") {}
     bool isUseful() override;
 };
 
 class CastAspectOfTheMonkeyAction : public CastBuffSpellAction
 {
 public:
-    CastAspectOfTheMonkeyAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "aspect of the monkey") {}
+    CastAspectOfTheMonkeyAction(PlayerbotAI* botAI) :
-};
+        CastBuffSpellAction(botAI, "aspect of the monkey") {}
-
-class CastAspectOfTheDragonhawkAction : public CastBuffSpellAction
-{
-public:
-    CastAspectOfTheDragonhawkAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "aspect of the dragonhawk") {}
 };
 
 class CastAspectOfTheWildAction : public CastBuffSpellAction
 {
 public:
-    CastAspectOfTheWildAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "aspect of the wild") {}
+    CastAspectOfTheWildAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "aspect of the wild") {}
 };
 
 class CastAspectOfTheCheetahAction : public CastBuffSpellAction
 {
 public:
-    CastAspectOfTheCheetahAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "aspect of the cheetah") {}
+    CastAspectOfTheCheetahAction(PlayerbotAI* botAI) :
-
+        CastBuffSpellAction(botAI, "aspect of the cheetah") {}
-    bool isUseful() override;
 };
 
 class CastAspectOfThePackAction : public CastBuffSpellAction
 {
 public:
-    CastAspectOfThePackAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "aspect of the pack") {}
+    CastAspectOfThePackAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "aspect of the pack") {}
 };
 
 class CastAspectOfTheViperAction : public CastBuffSpellAction
 {
 public:
-    CastAspectOfTheViperAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "aspect of the viper") {}
+    CastAspectOfTheViperAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "aspect of the viper") {}
 };
 
 // Cooldown Spells
@@ -72,26 +78,28 @@ public:
 class CastRapidFireAction : public CastBuffSpellAction
 {
 public:
-    CastRapidFireAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "rapid fire") {}
+    CastRapidFireAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "rapid fire") {}
 };
 
 class CastDeterrenceAction : public CastBuffSpellAction
 {
 public:
-    CastDeterrenceAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "deterrence") {}
+    CastDeterrenceAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "deterrence") {}
 };
 
 class CastReadinessAction : public CastBuffSpellAction
 {
 public:
-    CastReadinessAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "readiness") {}
+    CastReadinessAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "readiness") {}
 };
 
 class CastDisengageAction : public CastSpellAction
 {
 public:
     CastDisengageAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "disengage") {}
-
     bool Execute(Event event) override;
     bool isUseful() override;
 };
@@ -101,14 +109,15 @@ public:
 class CastScareBeastAction : public CastSpellAction
 {
 public:
-    CastScareBeastAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "scare beast") {}
+    CastScareBeastAction(PlayerbotAI* botAI) :
+        CastSpellAction(botAI, "scare beast") {}
 };
 
 class CastScareBeastCcAction : public CastSpellAction
 {
 public:
-    CastScareBeastCcAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "scare beast on cc") {}
+    CastScareBeastCcAction(PlayerbotAI* botAI) :
-
+        CastSpellAction(botAI, "scare beast on cc") {}
     Value<Unit*>* GetTargetValue() override;
     bool Execute(Event event) override;
 };
@@ -116,34 +125,41 @@ public:
 class CastFreezingTrap : public CastDebuffSpellAction
 {
 public:
-    CastFreezingTrap(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "freezing trap") {}
+    CastFreezingTrap(PlayerbotAI* botAI) :
-
+        CastDebuffSpellAction(botAI, "freezing trap") {}
     Value<Unit*>* GetTargetValue() override;
 };
 
 class CastWyvernStingAction : public CastDebuffSpellAction
 {
 public:
-    CastWyvernStingAction(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "wyvern sting", true) {}
+    CastWyvernStingAction(PlayerbotAI* botAI) :
+        CastDebuffSpellAction(botAI, "wyvern sting", true) {}
 };
 
 class CastSilencingShotAction : public CastSpellAction
 {
 public:
-    CastSilencingShotAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "silencing shot") {}
+    CastSilencingShotAction(PlayerbotAI* botAI) :
+        CastSpellAction(botAI, "silencing shot") {}
 };
 
 class CastConcussiveShotAction : public CastSnareSpellAction
 {
 public:
-    CastConcussiveShotAction(PlayerbotAI* botAI) : CastSnareSpellAction(botAI, "concussive shot") {}
+    CastConcussiveShotAction(PlayerbotAI* botAI) :
+        CastSnareSpellAction(botAI, "concussive shot") {}
 };
 
 class CastIntimidationAction : public CastBuffSpellAction
 {
 public:
-    CastIntimidationAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "intimidation", false, 5000) {}
+    CastIntimidationAction(PlayerbotAI* botAI) :
-    std::string const GetTargetName() override { return "pet target"; }
+        CastBuffSpellAction(botAI, "intimidation", false, 5000) {}
+    std::string const GetTargetName() override
+    {
+        return "pet target";
+    }
 };
 
 // Threat Spells
@@ -151,19 +167,22 @@ public:
 class CastDistractingShotAction : public CastSpellAction
 {
 public:
-    CastDistractingShotAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "distracting shot") {}
+    CastDistractingShotAction(PlayerbotAI* botAI) :
+        CastSpellAction(botAI, "distracting shot") {}
 };
 
 class CastMisdirectionOnMainTankAction : public BuffOnMainTankAction
 {
 public:
-    CastMisdirectionOnMainTankAction(PlayerbotAI* ai) : BuffOnMainTankAction(ai, "misdirection", true) {}
+    CastMisdirectionOnMainTankAction(PlayerbotAI* botAI) :
+        BuffOnMainTankAction(botAI, "misdirection", true) {}
 };
 
 class CastFeignDeathAction : public CastBuffSpellAction
 {
 public:
-    CastFeignDeathAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "feign death") {}
+    CastFeignDeathAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "feign death") {}
 };
 
 // Pet Spells
@@ -172,7 +191,6 @@ class FeedPetAction : public Action
 {
 public:
     FeedPetAction(PlayerbotAI* botAI) : Action(botAI, "feed pet") {}
-
     bool Execute(Event event) override;
 };
 
@@ -186,27 +204,39 @@ class CastMendPetAction : public CastAuraSpellAction
 {
 public:
     CastMendPetAction(PlayerbotAI* botAI) : CastAuraSpellAction(botAI, "mend pet") {}
-    std::string const GetTargetName() override { return "pet target"; }
+    std::string const GetTargetName() override
+    {
+        return "pet target";
+    }
 };
 
 class CastRevivePetAction : public CastBuffSpellAction
 {
 public:
-    CastRevivePetAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "revive pet") {}
+    CastRevivePetAction(PlayerbotAI* botAI) :
+        CastBuffSpellAction(botAI, "revive pet") {}
 };
 
 class CastKillCommandAction : public CastBuffSpellAction
 {
 public:
-    CastKillCommandAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "kill command", false, 5000) {}
+    CastKillCommandAction(PlayerbotAI* botAI) :
-    std::string const GetTargetName() override { return "pet target"; }
+        CastBuffSpellAction(botAI, "kill command", false, 5000) {}
+    std::string const GetTargetName() override
+    {
+        return "pet target";
+    }
 };
 
 class CastBestialWrathAction : public CastBuffSpellAction
 {
 public:
-    CastBestialWrathAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "bestial wrath", false, 5000) {}
+    CastBestialWrathAction(PlayerbotAI* botAI) :
-    std::string const GetTargetName() override { return "pet target"; }
+        CastBuffSpellAction(botAI, "bestial wrath", false, 5000) {}
+    std::string const GetTargetName() override
+    {
+        return "pet target";
+    }
 };
 
 // Direct Damage Spells
@@ -215,14 +245,18 @@ class CastAutoShotAction : public CastSpellAction
 {
 public:
     CastAutoShotAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "auto shot") {}
-    ActionThreatType getThreatType() override { return ActionThreatType::None; }
+    ActionThreatType getThreatType() override
+    {
+        return ActionThreatType::None;
+    }
     bool isUseful() override;
 };
 
 class CastArcaneShotAction : public CastSpellAction
 {
 public:
-    CastArcaneShotAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "arcane shot") {}
+    CastArcaneShotAction(PlayerbotAI* botAI) :
+        CastSpellAction(botAI, "arcane shot") {}
     bool isUseful() override;
 };
 
@@ -235,7 +269,8 @@ public:
 class CastChimeraShotAction : public CastSpellAction
 {
 public:
-    CastChimeraShotAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "chimera shot") {}
+    CastChimeraShotAction(PlayerbotAI* botAI) :
+        CastSpellAction(botAI, "chimera shot") {}
 };
 
 class CastSteadyShotAction : public CastSpellAction
@@ -255,7 +290,8 @@ public:
 class CastHuntersMarkAction : public CastDebuffSpellAction
 {
 public:
-    CastHuntersMarkAction(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "hunter's mark") {}
+    CastHuntersMarkAction(PlayerbotAI* botAI) :
+        CastDebuffSpellAction(botAI, "hunter's mark") {}
     bool isUseful() override
     {
         // Bypass TTL check
@@ -266,20 +302,23 @@ public:
 class CastTranquilizingShotAction : public CastSpellAction
 {
 public:
-    CastTranquilizingShotAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "tranquilizing shot") {}
+    CastTranquilizingShotAction(PlayerbotAI* botAI) :
+        CastSpellAction(botAI, "tranquilizing shot") {}
 };
 
 class CastViperStingAction : public CastDebuffSpellAction
 {
 public:
-    CastViperStingAction(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "viper sting", true) {}
+    CastViperStingAction(PlayerbotAI* botAI) :
+        CastDebuffSpellAction(botAI, "viper sting", true) {}
     bool isUseful() override;
 };
 
 class CastSerpentStingAction : public CastDebuffSpellAction
 {
 public:
-    CastSerpentStingAction(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "serpent sting", true) {}
+    CastSerpentStingAction(PlayerbotAI* botAI) :
+        CastDebuffSpellAction(botAI, "serpent sting", true) {}
     bool isUseful() override
     {
         // Bypass TTL check
@@ -290,7 +329,8 @@ public:
 class CastScorpidStingAction : public CastDebuffSpellAction
 {
 public:
-    CastScorpidStingAction(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "scorpid sting", true) {}
+    CastScorpidStingAction(PlayerbotAI* botAI) :
+        CastDebuffSpellAction(botAI, "scorpid sting", true) {}
     bool isUseful() override
     {
         // Bypass TTL check
@@ -301,7 +341,8 @@ public:
 class CastSerpentStingOnAttackerAction : public CastDebuffSpellOnAttackerAction
 {
 public:
-    CastSerpentStingOnAttackerAction(PlayerbotAI* botAI) : CastDebuffSpellOnAttackerAction(botAI, "serpent sting", true) {}
+    CastSerpentStingOnAttackerAction(PlayerbotAI* botAI)
+        : CastDebuffSpellOnAttackerAction(botAI, "serpent sting", true) {}
     bool isUseful() override
     {
         // Bypass TTL check
@@ -312,20 +353,23 @@ public:
 class CastImmolationTrapAction : public CastSpellAction
 {
 public:
-    CastImmolationTrapAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "immolation trap") {}
+    CastImmolationTrapAction(PlayerbotAI* botAI) :
+        CastSpellAction(botAI, "immolation trap") {}
     bool isUseful() override;
 };
 
 class CastExplosiveTrapAction : public CastSpellAction
 {
 public:
-    CastExplosiveTrapAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "explosive trap") {}
+    CastExplosiveTrapAction(PlayerbotAI* botAI) :
+        CastSpellAction(botAI, "explosive trap") {}
 };
 
-class CastBlackArrow : public CastDebuffSpellAction
+class CastBlackArrowAction : public CastDebuffSpellAction
 {
 public:
-    CastBlackArrow(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "black arrow", true) {}
+    CastBlackArrowAction(PlayerbotAI* botAI) :
+        CastDebuffSpellAction(botAI, "black arrow", true) {}
     bool isUseful() override
     {
         if (botAI->HasStrategy("trap weave", BOT_STATE_COMBAT))
@@ -335,77 +379,89 @@ public:
     }
 };
 
-class CastExplosiveShotAction : public CastDebuffSpellAction
+class CastExplosiveShotBaseAction : public CastDebuffSpellAction
 {
 public:
-    CastExplosiveShotAction(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "explosive shot", true, 0.0f) {}
+    CastExplosiveShotBaseAction(PlayerbotAI* botAI)
-    bool isUseful() override
+        : CastDebuffSpellAction(botAI, "explosive shot", true, 0.0f) {}
-    {
-        // Bypass TTL check
-        return CastAuraSpellAction::isUseful();
-    }
 };
 
 // Rank 4
-class CastExplosiveShotRank4Action : public CastDebuffSpellAction
+class CastExplosiveShotRank4Action : public CastExplosiveShotBaseAction
 {
 public:
-    CastExplosiveShotRank4Action(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "explosive shot", true, 0.0f) {}
+    CastExplosiveShotRank4Action(PlayerbotAI* botAI) :
-
+        CastExplosiveShotBaseAction(botAI) {}
-    bool Execute(Event event) override { return botAI->CastSpell(60053, GetTarget()); }
+    bool Execute(Event event) override
+    {
+        return botAI->CastSpell(60053, GetTarget());
+    }
     bool isUseful() override
     {
         Unit* target = GetTarget();
         if (!target)
             return false;
+
         return !target->HasAura(60053);
     }
 };
 
 // Rank 3
-class CastExplosiveShotRank3Action : public CastDebuffSpellAction
+class CastExplosiveShotRank3Action : public CastExplosiveShotBaseAction
 {
 public:
-    CastExplosiveShotRank3Action(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "explosive shot", true, 0.0f) {}
+    CastExplosiveShotRank3Action(PlayerbotAI* botAI) :
-
+        CastExplosiveShotBaseAction(botAI) {}
-    bool Execute(Event event) override { return botAI->CastSpell(60052, GetTarget()); }
+    bool Execute(Event event) override
+    {
+        return botAI->CastSpell(60052, GetTarget());
+    }
     bool isUseful() override
     {
         Unit* target = GetTarget();
         if (!target)
             return false;
+
         return !target->HasAura(60052);
     }
 };
 
 // Rank 2
-class CastExplosiveShotRank2Action : public CastDebuffSpellAction
+class CastExplosiveShotRank2Action : public CastExplosiveShotBaseAction
 {
 public:
-    CastExplosiveShotRank2Action(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "explosive shot", true, 0.0f) {}
+    CastExplosiveShotRank2Action(PlayerbotAI* botAI) :
-
+        CastExplosiveShotBaseAction(botAI) {}
-    bool Execute(Event event) override { return botAI->CastSpell(60051, GetTarget()); }
+    bool Execute(Event event) override
+    {
+        return botAI->CastSpell(60051, GetTarget());
+    }
     bool isUseful() override
     {
         Unit* target = GetTarget();
         if (!target)
             return false;
+
         return !target->HasAura(60051);
     }
 };
 
 // Rank 1
-class CastExplosiveShotRank1Action : public CastDebuffSpellAction
+class CastExplosiveShotRank1Action : public CastExplosiveShotBaseAction
 {
 public:
-    CastExplosiveShotRank1Action(PlayerbotAI* botAI) : CastDebuffSpellAction(botAI, "explosive shot", true, 0.0f) {}
+    CastExplosiveShotRank1Action(PlayerbotAI* botAI) :
-
+        CastExplosiveShotBaseAction(botAI) {}
-    bool Execute(Event event) override { return botAI->CastSpell(53301, GetTarget()); }
+    bool Execute(Event event) override
+    {
+        return botAI->CastSpell(53301, GetTarget());
+    }
     bool isUseful() override
     {
         Unit* target = GetTarget();
         if (!target)
             return false;
+
         return !target->HasAura(53301);
     }
 };
@@ -415,8 +471,8 @@ public:
 class CastWingClipAction : public CastSpellAction
 {
 public:
-    CastWingClipAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "wing clip") {}
+    CastWingClipAction(PlayerbotAI* botAI) :
-
+        CastSpellAction(botAI, "wing clip") {}
     bool isUseful() override;
     std::vector<NextAction> getPrerequisites() override;
 };
@@ -424,13 +480,15 @@ public:
 class CastRaptorStrikeAction : public CastSpellAction
 {
 public:
-    CastRaptorStrikeAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "raptor strike") {}
+    CastRaptorStrikeAction(PlayerbotAI* botAI) :
+        CastSpellAction(botAI, "raptor strike") {}
 };
 
 class CastMongooseBiteAction : public CastSpellAction
 {
 public:
-    CastMongooseBiteAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "mongoose bite") {}
+    CastMongooseBiteAction(PlayerbotAI* botAI) :
+        CastSpellAction(botAI, "mongoose bite") {}
 };
 
 // AoE Spells
@@ -445,7 +503,10 @@ class CastVolleyAction : public CastSpellAction
 {
 public:
     CastVolleyAction(PlayerbotAI* botAI) : CastSpellAction(botAI, "volley") {}
-    ActionThreatType getThreatType() override { return ActionThreatType::Aoe; }
+    ActionThreatType getThreatType() override
+    {
+        return ActionThreatType::Aoe;
+    }
 };
 
 #endif

src/Ai/Class/Hunter/HunterAiObjectContext.cpp

@@ -22,7 +22,6 @@ public:
     HunterStrategyFactoryInternal()
     {
         creators["nc"] = &HunterStrategyFactoryInternal::nc;
-        creators["boost"] = &HunterStrategyFactoryInternal::boost;
         creators["pet"] = &HunterStrategyFactoryInternal::pet;
         creators["cc"] = &HunterStrategyFactoryInternal::cc;
         creators["trap weave"] = &HunterStrategyFactoryInternal::trap_weave;
@@ -34,7 +33,6 @@ public:
 
 private:
     static Strategy* nc(PlayerbotAI* botAI) { return new GenericHunterNonCombatStrategy(botAI); }
-    static Strategy* boost(PlayerbotAI* botAI) { return new HunterBoostStrategy(botAI); }
     static Strategy* pet(PlayerbotAI* botAI) { return new HunterPetStrategy(botAI); }
     static Strategy* cc(PlayerbotAI* botAI) { return new HunterCcStrategy(botAI); }
     static Strategy* trap_weave(PlayerbotAI* botAI) { return new HunterTrapWeaveStrategy(botAI); }
@@ -51,14 +49,12 @@ public:
     {
         creators["bspeed"] = &HunterBuffStrategyFactoryInternal::bspeed;
         creators["bdps"] = &HunterBuffStrategyFactoryInternal::bdps;
-        creators["bmana"] = &HunterBuffStrategyFactoryInternal::bmana;
         creators["rnature"] = &HunterBuffStrategyFactoryInternal::rnature;
     }
 
 private:
     static Strategy* bspeed(PlayerbotAI* botAI) { return new HunterBuffSpeedStrategy(botAI); }
     static Strategy* bdps(PlayerbotAI* botAI) { return new HunterBuffDpsStrategy(botAI); }
-    static Strategy* bmana(PlayerbotAI* botAI) { return new HunterBuffManaStrategy(botAI); }
     static Strategy* rnature(PlayerbotAI* botAI) { return new HunterNatureResistanceStrategy(botAI); }
 };
 
@@ -67,7 +63,6 @@ class HunterTriggerFactoryInternal : public NamedObjectContext<Trigger>
 public:
     HunterTriggerFactoryInternal()
     {
-        creators["aspect of the viper"] = &HunterTriggerFactoryInternal::aspect_of_the_viper;
         creators["black arrow"] = &HunterTriggerFactoryInternal::black_arrow;
         creators["no stings"] = &HunterTriggerFactoryInternal::NoStings;
         creators["hunters pet dead"] = &HunterTriggerFactoryInternal::hunters_pet_dead;
@@ -75,10 +70,9 @@ public:
         creators["hunters pet medium health"] = &HunterTriggerFactoryInternal::hunters_pet_medium_health;
         creators["hunter's mark"] = &HunterTriggerFactoryInternal::hunters_mark;
         creators["freezing trap"] = &HunterTriggerFactoryInternal::freezing_trap;
-        creators["aspect of the pack"] = &HunterTriggerFactoryInternal::aspect_of_the_pack;
         creators["rapid fire"] = &HunterTriggerFactoryInternal::rapid_fire;
-        creators["aspect of the hawk"] = &HunterTriggerFactoryInternal::aspect_of_the_hawk;
+        creators["aspect of the pack"] = &HunterTriggerFactoryInternal::aspect_of_the_pack;
-        creators["aspect of the monkey"] = &HunterTriggerFactoryInternal::aspect_of_the_monkey;
+        creators["aspect of the dragonhawk"] = &HunterTriggerFactoryInternal::aspect_of_the_dragonhawk;
         creators["aspect of the wild"] = &HunterTriggerFactoryInternal::aspect_of_the_wild;
         creators["aspect of the viper"] = &HunterTriggerFactoryInternal::aspect_of_the_viper;
         creators["trueshot aura"] = &HunterTriggerFactoryInternal::trueshot_aura;
@@ -107,10 +101,8 @@ public:
 private:
     static Trigger* auto_shot(PlayerbotAI* botAI) { return new AutoShotTrigger(botAI); }
     static Trigger* scare_beast(PlayerbotAI* botAI) { return new ScareBeastTrigger(botAI); }
-    static Trigger* concussive_shot_on_snare_target(PlayerbotAI* botAI)
+    static Trigger* concussive_shot_on_snare_target(PlayerbotAI* botAI) {
-    {
+        return new ConcussiveShotOnSnareTargetTrigger(botAI); }
-        return new ConsussiveShotSnareTrigger(botAI);
-    }
     static Trigger* pet_not_happy(PlayerbotAI* botAI) { return new HunterPetNotHappy(botAI); }
     static Trigger* serpent_sting_on_attacker(PlayerbotAI* botAI) { return new SerpentStingOnAttackerTrigger(botAI); }
     static Trigger* trueshot_aura(PlayerbotAI* botAI) { return new TrueshotAuraTrigger(botAI); }
@@ -125,18 +117,17 @@ private:
     static Trigger* freezing_trap(PlayerbotAI* botAI) { return new FreezingTrapTrigger(botAI); }
     static Trigger* aspect_of_the_pack(PlayerbotAI* botAI) { return new HunterAspectOfThePackTrigger(botAI); }
     static Trigger* rapid_fire(PlayerbotAI* botAI) { return new RapidFireTrigger(botAI); }
-    static Trigger* aspect_of_the_hawk(PlayerbotAI* botAI) { return new HunterAspectOfTheHawkTrigger(botAI); }
+    static Trigger* aspect_of_the_dragonhawk(PlayerbotAI* botAI) { return new HunterAspectOfTheDragonhawkTrigger(botAI); }
-    static Trigger* aspect_of_the_monkey(PlayerbotAI* botAI) { return new HunterAspectOfTheMonkeyTrigger(botAI); }
     static Trigger* aspect_of_the_wild(PlayerbotAI* botAI) { return new HunterAspectOfTheWildTrigger(botAI); }
     static Trigger* low_ammo(PlayerbotAI* botAI) { return new HunterLowAmmoTrigger(botAI); }
     static Trigger* no_ammo(PlayerbotAI* botAI) { return new HunterNoAmmoTrigger(botAI); }
     static Trigger* has_ammo(PlayerbotAI* botAI) { return new HunterHasAmmoTrigger(botAI); }
     static Trigger* switch_to_melee(PlayerbotAI* botAI) { return new SwitchToMeleeTrigger(botAI); }
     static Trigger* switch_to_ranged(PlayerbotAI* botAI) { return new SwitchToRangedTrigger(botAI); }
-    static Trigger* misdirection_on_main_tank(PlayerbotAI* ai) { return new MisdirectionOnMainTankTrigger(ai); }
+    static Trigger* misdirection_on_main_tank(PlayerbotAI* botAI) { return new MisdirectionOnMainTankTrigger(botAI); }
-    static Trigger* remove_enrage(PlayerbotAI* ai) { return new TargetRemoveEnrageTrigger(ai); }
+    static Trigger* remove_enrage(PlayerbotAI* botAI) { return new TargetRemoveEnrageTrigger(botAI); }
-    static Trigger* remove_magic(PlayerbotAI* ai) { return new TargetRemoveMagicTrigger(ai); }
+    static Trigger* remove_magic(PlayerbotAI* botAI) { return new TargetRemoveMagicTrigger(botAI); }
-    static Trigger* immolation_trap_no_cd(PlayerbotAI* ai) { return new ImmolationTrapNoCdTrigger(ai); }
+    static Trigger* immolation_trap_no_cd(PlayerbotAI* botAI) { return new ImmolationTrapNoCdTrigger(botAI); }
     static Trigger* kill_command(PlayerbotAI* botAI) { return new KillCommandTrigger(botAI); }
     static Trigger* explosive_shot(PlayerbotAI* botAI) { return new ExplosiveShotTrigger(botAI); }
     static Trigger* lock_and_load(PlayerbotAI* botAI) { return new LockAndLoadTrigger(botAI); }
@@ -153,7 +144,6 @@ public:
         creators["auto shot"] = &HunterAiObjectContextInternal::auto_shot;
         creators["aimed shot"] = &HunterAiObjectContextInternal::aimed_shot;
         creators["chimera shot"] = &HunterAiObjectContextInternal::chimera_shot;
-        creators["explosive shot"] = &HunterAiObjectContextInternal::explosive_shot;
         creators["arcane shot"] = &HunterAiObjectContextInternal::arcane_shot;
         creators["concussive shot"] = &HunterAiObjectContextInternal::concussive_shot;
         creators["distracting shot"] = &HunterAiObjectContextInternal::distracting_shot;
@@ -176,6 +166,7 @@ public:
         creators["deterrence"] = &HunterAiObjectContextInternal::deterrence;
         creators["readiness"] = &HunterAiObjectContextInternal::readiness;
         creators["aspect of the hawk"] = &HunterAiObjectContextInternal::aspect_of_the_hawk;
+        creators["aspect of the dragonhawk"] = &HunterAiObjectContextInternal::aspect_of_the_dragonhawk;
         creators["aspect of the monkey"] = &HunterAiObjectContextInternal::aspect_of_the_monkey;
         creators["aspect of the wild"] = &HunterAiObjectContextInternal::aspect_of_the_wild;
         creators["aspect of the viper"] = &HunterAiObjectContextInternal::aspect_of_the_viper;
@@ -191,7 +182,6 @@ public:
         creators["bestial wrath"] = &HunterAiObjectContextInternal::bestial_wrath;
         creators["scare beast"] = &HunterAiObjectContextInternal::scare_beast;
         creators["scare beast on cc"] = &HunterAiObjectContextInternal::scare_beast_on_cc;
-        creators["aspect of the dragonhawk"] = &HunterAiObjectContextInternal::aspect_of_the_dragonhawk;
         creators["tranquilizing shot"] = &HunterAiObjectContextInternal::tranquilizing_shot;
         creators["steady shot"] = &HunterAiObjectContextInternal::steady_shot;
         creators["kill shot"] = &HunterAiObjectContextInternal::kill_shot;
@@ -200,6 +190,7 @@ public:
         creators["disengage"] = &HunterAiObjectContextInternal::disengage;
         creators["immolation trap"] = &HunterAiObjectContextInternal::immolation_trap;
         creators["explosive trap"] = &HunterAiObjectContextInternal::explosive_trap;
+        creators["explosive shot base"] = &HunterAiObjectContextInternal::explosive_shot_base;
         creators["explosive shot rank 4"] = &HunterAiObjectContextInternal::explosive_shot_rank_4;
         creators["explosive shot rank 3"] = &HunterAiObjectContextInternal::explosive_shot_rank_3;
         creators["explosive shot rank 2"] = &HunterAiObjectContextInternal::explosive_shot_rank_2;
@@ -218,7 +209,6 @@ private:
     static Action* auto_shot(PlayerbotAI* botAI) { return new CastAutoShotAction(botAI); }
     static Action* aimed_shot(PlayerbotAI* botAI) { return new CastAimedShotAction(botAI); }
     static Action* chimera_shot(PlayerbotAI* botAI) { return new CastChimeraShotAction(botAI); }
-    static Action* explosive_shot(PlayerbotAI* botAI) { return new CastExplosiveShotAction(botAI); }
     static Action* arcane_shot(PlayerbotAI* botAI) { return new CastArcaneShotAction(botAI); }
     static Action* concussive_shot(PlayerbotAI* botAI) { return new CastConcussiveShotAction(botAI); }
     static Action* distracting_shot(PlayerbotAI* botAI) { return new CastDistractingShotAction(botAI); }
@@ -234,12 +224,13 @@ private:
     static Action* kill_command(PlayerbotAI* botAI) { return new CastKillCommandAction(botAI); }
     static Action* revive_pet(PlayerbotAI* botAI) { return new CastRevivePetAction(botAI); }
     static Action* call_pet(PlayerbotAI* botAI) { return new CastCallPetAction(botAI); }
-    static Action* black_arrow(PlayerbotAI* botAI) { return new CastBlackArrow(botAI); }
+    static Action* black_arrow(PlayerbotAI* botAI) { return new CastBlackArrowAction(botAI); }
     static Action* freezing_trap(PlayerbotAI* botAI) { return new CastFreezingTrap(botAI); }
     static Action* rapid_fire(PlayerbotAI* botAI) { return new CastRapidFireAction(botAI); }
     static Action* deterrence(PlayerbotAI* botAI) { return new CastDeterrenceAction(botAI); }
     static Action* readiness(PlayerbotAI* botAI) { return new CastReadinessAction(botAI); }
     static Action* aspect_of_the_hawk(PlayerbotAI* botAI) { return new CastAspectOfTheHawkAction(botAI); }
+    static Action* aspect_of_the_dragonhawk(PlayerbotAI* botAI) { return new CastAspectOfTheDragonhawkAction(botAI); }
     static Action* aspect_of_the_monkey(PlayerbotAI* botAI) { return new CastAspectOfTheMonkeyAction(botAI); }
     static Action* aspect_of_the_wild(PlayerbotAI* botAI) { return new CastAspectOfTheWildAction(botAI); }
     static Action* aspect_of_the_viper(PlayerbotAI* botAI) { return new CastAspectOfTheViperAction(botAI); }
@@ -248,20 +239,20 @@ private:
     static Action* wing_clip(PlayerbotAI* botAI) { return new CastWingClipAction(botAI); }
     static Action* raptor_strike(PlayerbotAI* botAI) { return new CastRaptorStrikeAction(botAI); }
     static Action* mongoose_bite(PlayerbotAI* botAI) { return new CastMongooseBiteAction(botAI); }
-    static Action* aspect_of_the_dragonhawk(PlayerbotAI* ai) { return new CastAspectOfTheDragonhawkAction(ai); }
+    static Action* tranquilizing_shot(PlayerbotAI* botAI) { return new CastTranquilizingShotAction(botAI); }
-    static Action* tranquilizing_shot(PlayerbotAI* ai) { return new CastTranquilizingShotAction(ai); }
+    static Action* steady_shot(PlayerbotAI* botAI) { return new CastSteadyShotAction(botAI); }
-    static Action* steady_shot(PlayerbotAI* ai) { return new CastSteadyShotAction(ai); }
+    static Action* kill_shot(PlayerbotAI* botAI) { return new CastKillShotAction(botAI); }
-    static Action* kill_shot(PlayerbotAI* ai) { return new CastKillShotAction(ai); }
+    static Action* misdirection_on_main_tank(PlayerbotAI* botAI) { return new CastMisdirectionOnMainTankAction(botAI); }
-    static Action* misdirection_on_main_tank(PlayerbotAI* ai) { return new CastMisdirectionOnMainTankAction(ai); }
+    static Action* silencing_shot(PlayerbotAI* botAI) { return new CastSilencingShotAction(botAI); }
-    static Action* silencing_shot(PlayerbotAI* ai) { return new CastSilencingShotAction(ai); }
+    static Action* disengage(PlayerbotAI* botAI) { return new CastDisengageAction(botAI); }
-    static Action* disengage(PlayerbotAI* ai) { return new CastDisengageAction(ai); }
+    static Action* immolation_trap(PlayerbotAI* botAI) { return new CastImmolationTrapAction(botAI); }
-    static Action* immolation_trap(PlayerbotAI* ai) { return new CastImmolationTrapAction(ai); }
+    static Action* explosive_trap(PlayerbotAI* botAI) { return new CastExplosiveTrapAction(botAI); }
-    static Action* explosive_trap(PlayerbotAI* ai) { return new CastExplosiveTrapAction(ai); }
+    static Action* explosive_shot_base(PlayerbotAI* botAI) { return new CastExplosiveShotBaseAction(botAI); }
-    static Action* explosive_shot_rank_4(PlayerbotAI* ai) { return new CastExplosiveShotRank4Action(ai); }
+    static Action* explosive_shot_rank_4(PlayerbotAI* botAI) { return new CastExplosiveShotRank4Action(botAI); }
-    static Action* explosive_shot_rank_3(PlayerbotAI* ai) { return new CastExplosiveShotRank3Action(ai); }
+    static Action* explosive_shot_rank_3(PlayerbotAI* botAI) { return new CastExplosiveShotRank3Action(botAI); }
-    static Action* explosive_shot_rank_2(PlayerbotAI* ai) { return new CastExplosiveShotRank2Action(ai); }
+    static Action* explosive_shot_rank_2(PlayerbotAI* botAI) { return new CastExplosiveShotRank2Action(botAI); }
-    static Action* explosive_shot_rank_1(PlayerbotAI* ai) { return new CastExplosiveShotRank1Action(ai); }
+    static Action* explosive_shot_rank_1(PlayerbotAI* botAI) { return new CastExplosiveShotRank1Action(botAI); }
-    static Action* intimidation(PlayerbotAI* ai) { return new CastIntimidationAction(ai); }
+    static Action* intimidation(PlayerbotAI* botAI) { return new CastIntimidationAction(botAI); }
 };
 
 SharedNamedObjectContextList<Strategy> HunterAiObjectContext::sharedStrategyContexts;

src/Ai/Class/Hunter/Strategy/BeastMasteryHunterStrategy.cpp

@@ -6,41 +6,9 @@
 #include "BeastMasteryHunterStrategy.h"
 #include "Playerbots.h"
 
-// ===== Action Node Factory =====
-class BeastMasteryHunterStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
-{
-public:
-    BeastMasteryHunterStrategyActionNodeFactory()
-    {
-        creators["auto shot"] = &auto_shot;
-        creators["kill command"] = &kill_command;
-        creators["kill shot"] = &kill_shot;
-        creators["viper sting"] = &viper_sting;
-        creators["serpent sting"] = serpent_sting;
-        creators["aimed shot"] = &aimed_shot;
-        creators["arcane shot"] = &arcane_shot;
-        creators["steady shot"] = &steady_shot;
-        creators["multi-shot"] = &multi_shot;
-        creators["volley"] = &volley;
-    }
-
-private:
-    static ActionNode* auto_shot(PlayerbotAI*) { return new ActionNode("auto shot", {}, {}, {}); }
-    static ActionNode* kill_command(PlayerbotAI*) { return new ActionNode("kill command", {}, {}, {}); }
-    static ActionNode* kill_shot(PlayerbotAI*) { return new ActionNode("kill shot", {}, {}, {}); }
-    static ActionNode* viper_sting(PlayerbotAI*) { return new ActionNode("viper sting", {}, {}, {}); }
-    static ActionNode* serpent_sting(PlayerbotAI*) { return new ActionNode("serpent sting", {}, {}, {}); }
-    static ActionNode* aimed_shot(PlayerbotAI*) { return new ActionNode("aimed shot", {}, {}, {}); }
-    static ActionNode* arcane_shot(PlayerbotAI*) { return new ActionNode("arcane shot", {}, {}, {}); }
-    static ActionNode* steady_shot(PlayerbotAI*) { return new ActionNode("steady shot", {}, {}, {}); }
-    static ActionNode* multi_shot(PlayerbotAI*) { return new ActionNode("multi shot", {}, {}, {}); }
-    static ActionNode* volley(PlayerbotAI*) { return new ActionNode("volley", {}, {}, {}); }
-};
-
-// ===== Single Target Strategy =====
 BeastMasteryHunterStrategy::BeastMasteryHunterStrategy(PlayerbotAI* botAI) : GenericHunterStrategy(botAI)
 {
-    actionNodeFactories.Add(new BeastMasteryHunterStrategyActionNodeFactory());
+    // No custom ActionNodeFactory needed
 }
 
 // ===== Default Actions =====

src/Ai/Class/Hunter/Strategy/GenericHunterNonCombatStrategy.cpp

@@ -4,62 +4,31 @@
  */
 
 #include "GenericHunterNonCombatStrategy.h"
-
 #include "Playerbots.h"
 
-class GenericHunterNonCombatStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
-{
-public:
-    GenericHunterNonCombatStrategyActionNodeFactory()
-    {
-        creators["rapid fire"] = &rapid_fire;
-        creators["boost"] = &rapid_fire;
-        creators["aspect of the pack"] = &aspect_of_the_pack;
-    }
-
-private:
-    static ActionNode* rapid_fire([[maybe_unused]] PlayerbotAI* botAI)
-    {
-        return new ActionNode("rapid fire",
-                              /*P*/ {},
-                              /*A*/ { NextAction("readiness")},
-                              /*C*/ {});
-    }
-
-    static ActionNode* aspect_of_the_pack([[maybe_unused]] PlayerbotAI* botAI)
-    {
-        return new ActionNode("aspect of the pack",
-                              /*P*/ {},
-                              /*A*/ { NextAction("aspect of the cheetah")},
-                              /*C*/ {});
-    }
-};
-
 GenericHunterNonCombatStrategy::GenericHunterNonCombatStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI)
 {
-    actionNodeFactories.Add(new GenericHunterNonCombatStrategyActionNodeFactory());
+    // No custom ActionNodeFactory needed
 }
 
 void GenericHunterNonCombatStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
 {
     NonCombatStrategy::InitTriggers(triggers);
 
-    triggers.push_back(new TriggerNode("trueshot aura", { NextAction("trueshot aura", 2.0f)}));
+    triggers.push_back(new TriggerNode("trueshot aura", { NextAction("trueshot aura", 2.0f) }));
-    triggers.push_back(new TriggerNode("often", {
+    triggers.push_back(new TriggerNode("often", { NextAction("apply stone", 1.0f),
-                       NextAction("apply stone", 1.0f),
+                                                  NextAction("apply oil", 1.0f) }));
-                       NextAction("apply oil", 1.0f),
+    triggers.push_back(new TriggerNode("low ammo", { NextAction("say::low ammo", ACTION_NORMAL) }));
-                       }));
+    triggers.push_back(new TriggerNode("no track", { NextAction("track humanoids", ACTION_NORMAL) }));
-    triggers.push_back(new TriggerNode("low ammo", { NextAction("say::low ammo", ACTION_NORMAL)}));
+    triggers.push_back(new TriggerNode("no ammo", { NextAction("equip upgrades packet action", ACTION_HIGH + 1) }));
-    triggers.push_back(new TriggerNode("no track", { NextAction("track humanoids", ACTION_NORMAL)}));
-    triggers.push_back(new TriggerNode("no ammo", { NextAction("equip upgrades packet action", ACTION_HIGH + 1)}));
 }
 
 void HunterPetStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
 {
-    triggers.push_back(new TriggerNode("no pet", { NextAction("call pet", 60.0f)}));
+    triggers.push_back(new TriggerNode("no pet", { NextAction("call pet", 60.0f) }));
-    triggers.push_back(new TriggerNode("has pet", { NextAction("toggle pet spell", 60.0f)}));
+    triggers.push_back(new TriggerNode("has pet", { NextAction("toggle pet spell", 60.0f) }));
-    triggers.push_back(new TriggerNode("new pet", { NextAction("set pet stance", 60.0f)}));
+    triggers.push_back(new TriggerNode("new pet", { NextAction("set pet stance", 60.0f) }));
-    triggers.push_back(new TriggerNode("pet not happy", { NextAction("feed pet", 60.0f)}));
+    triggers.push_back(new TriggerNode("pet not happy", { NextAction("feed pet", 60.0f) }));
-    triggers.push_back(new TriggerNode("hunters pet medium health", { NextAction("mend pet", 60.0f)}));
+    triggers.push_back(new TriggerNode("hunters pet medium health", { NextAction("mend pet", 60.0f) }));
-    triggers.push_back(new TriggerNode("hunters pet dead", { NextAction("revive pet", 60.0f)}));
+    triggers.push_back(new TriggerNode("hunters pet dead", { NextAction("revive pet", 60.0f) }));
 }

src/Ai/Class/Hunter/Strategy/GenericHunterStrategy.cpp

@@ -11,11 +11,6 @@ public:
     GenericHunterStrategyActionNodeFactory()
     {
         creators["rapid fire"] = &rapid_fire;
-        creators["boost"] = &rapid_fire;
-        creators["aspect of the pack"] = &aspect_of_the_pack;
-        creators["aspect of the dragonhawk"] = &aspect_of_the_dragonhawk;
-        creators["feign death"] = &feign_death;
-        creators["wing clip"] = &wing_clip;
         creators["mongoose bite"] = &mongoose_bite;
         creators["raptor strike"] = &raptor_strike;
         creators["explosive trap"] = &explosive_trap;
@@ -29,40 +24,6 @@ private:
                               /*A*/ { NextAction("readiness") },
                               /*C*/ {});
     }
-
-    static ActionNode* aspect_of_the_pack([[maybe_unused]] PlayerbotAI* botAI)
-    {
-        return new ActionNode("aspect of the pack",
-                              /*P*/ {},
-                              /*A*/ { NextAction("aspect of the cheetah") },
-                              /*C*/ {});
-    }
-
-    static ActionNode* aspect_of_the_dragonhawk([[maybe_unused]] PlayerbotAI* botAI)
-    {
-        return new ActionNode("aspect of the dragonhawk",
-                              /*P*/ {},
-                              /*A*/ { NextAction("aspect of the hawk") },
-                              /*C*/ {});
-    }
-
-    static ActionNode* feign_death([[maybe_unused]] PlayerbotAI* botAI)
-    {
-        return new ActionNode("feign death",
-                              /*P*/ {},
-                              /*A*/ {},
-                              /*C*/ {});
-    }
-
-    static ActionNode* wing_clip([[maybe_unused]] PlayerbotAI* botAI)
-    {
-        return new ActionNode("wing clip",
-                              /*P*/ {},
-                              // /*A*/ { NextAction("mongoose bite") },
-                              {},
-                              /*C*/ {});
-    }
-
     static ActionNode* mongoose_bite([[maybe_unused]] PlayerbotAI* botAI)
     {
         return new ActionNode("mongoose bite",
@@ -70,7 +31,6 @@ private:
                               /*A*/ { NextAction("raptor strike") },
                               /*C*/ {});
     }
-
     static ActionNode* raptor_strike([[maybe_unused]] PlayerbotAI* botAI)
     {
         return new ActionNode("raptor strike",
@@ -78,7 +38,6 @@ private:
                               /*A*/ {},
                               /*C*/ {});
     }
-
     static ActionNode* explosive_trap([[maybe_unused]] PlayerbotAI* botAI)
     {
         return new ActionNode("explosive trap",
@@ -102,7 +61,6 @@ void GenericHunterStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
     triggers.push_back(new TriggerNode("hunter's mark", { NextAction("hunter's mark", 29.5f) }));
     triggers.push_back(new TriggerNode("rapid fire", { NextAction("rapid fire", 29.0f) }));
     triggers.push_back(new TriggerNode("aspect of the viper", { NextAction("aspect of the viper", 28.0f) }));
-    triggers.push_back(new TriggerNode("aspect of the hawk", { NextAction("aspect of the dragonhawk", 27.5f) }));
 
     // Aggro/Threat/Defensive Triggers
     triggers.push_back(new TriggerNode("has aggro", { NextAction("concussive shot", 20.0f) }));
@@ -118,14 +76,12 @@ void GenericHunterStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
     triggers.push_back(new TriggerNode("tranquilizing shot magic", { NextAction("tranquilizing shot", 61.0f) }));
 
     // Ranged-based Triggers
-    triggers.push_back(new TriggerNode("enemy within melee", {
+    triggers.push_back(new TriggerNode("enemy within melee", { NextAction("explosive trap", 37.0f),
-                                                         NextAction("explosive trap", 37.0f),
+                                                               NextAction("mongoose bite", 22.0f),
-                                                         NextAction("mongoose bite", 22.0f),
+                                                               NextAction("wing clip", 21.0f) }));
-                                                         NextAction("wing clip", 21.0f) }));
 
-    triggers.push_back(new TriggerNode("enemy too close for auto shot", {
+    triggers.push_back(new TriggerNode("enemy too close for auto shot", { NextAction("disengage", 35.0f),
-                                                                    NextAction("disengage", 35.0f),
+                                                                          NextAction("flee", 34.0f) }));
-                                                                    NextAction("flee", 34.0f) }));
 }
 
 // ===== AoE Strategy, 2/3+ enemies =====
@@ -138,10 +94,6 @@ void AoEHunterStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
     triggers.push_back(new TriggerNode("light aoe", { NextAction("multi-shot", 21.0f) }));
 }
 
-void HunterBoostStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
-{
-}
-
 void HunterCcStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
 {
     triggers.push_back(new TriggerNode("scare beast", { NextAction("scare beast on cc", 23.0f) }));

src/Ai/Class/Hunter/Strategy/GenericHunterStrategy.h

@@ -30,15 +30,6 @@ public:
     std::string const getName() override { return "aoe"; }
 };
 
-class HunterBoostStrategy : public Strategy
-{
-public:
-    HunterBoostStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
-
-    std::string const getName() override { return "boost"; }
-    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
-};
-
 class HunterCcStrategy : public Strategy
 {
 public:

src/Ai/Class/Hunter/Strategy/HunterBuffStrategies.cpp

@@ -10,9 +10,21 @@
 class BuffHunterStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
 {
 public:
-    BuffHunterStrategyActionNodeFactory() { creators["aspect of the hawk"] = &aspect_of_the_hawk; }
+    BuffHunterStrategyActionNodeFactory()
+    {
+        creators["aspect of the dragonhawk"] = &aspect_of_the_dragonhawk;
+        creators["aspect of the hawk"] = &aspect_of_the_hawk;
+        creators["aspect of the pack"] = &aspect_of_the_pack;
+    }
 
 private:
+    static ActionNode* aspect_of_the_dragonhawk([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("aspect of the dragonhawk",
+                              /*P*/ {},
+                              /*A*/ { NextAction("aspect of the hawk") },
+                              /*C*/ {});
+    }
     static ActionNode* aspect_of_the_hawk([[maybe_unused]] PlayerbotAI* botAI)
     {
         return new ActionNode("aspect of the hawk",
@@ -20,9 +32,16 @@ private:
                               /*A*/ { NextAction("aspect of the monkey") },
                               /*C*/ {});
     }
+    static ActionNode* aspect_of_the_pack([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("aspect of the pack",
+                              /*P*/ {},
+                              /*A*/ { NextAction("aspect of the cheetah") },
+                              /*C*/ {});
+    }
 };
 
-HunterBuffDpsStrategy::HunterBuffDpsStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI)
+HunterBuffDpsStrategy::HunterBuffDpsStrategy(PlayerbotAI* botAI) : Strategy(botAI)
 {
     actionNodeFactories.Add(new BuffHunterStrategyActionNodeFactory());
 }
@@ -30,24 +49,35 @@ HunterBuffDpsStrategy::HunterBuffDpsStrategy(PlayerbotAI* botAI) : NonCombatStra
 void HunterBuffDpsStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
 {
     triggers.push_back(
-        new TriggerNode("aspect of the hawk", { NextAction("aspect of the dragonhawk", 20.1f),
+        new TriggerNode(
-                                                                NextAction("aspect of the hawk", 20.0f) }));
+            "aspect of the dragonhawk",
+            {
+                NextAction("aspect of the dragonhawk", ACTION_HIGH)
+            }
+        )
+    );
 }
 
 void HunterNatureResistanceStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
 {
-    triggers.push_back(new TriggerNode("aspect of the wild",
+    triggers.push_back(
-                                       { NextAction("aspect of the wild", 20.0f) }));
+        new TriggerNode(
+            "aspect of the wild",
+            {
+                NextAction("aspect of the wild", ACTION_HIGH)
+            }
+        )
+    );
 }
 
 void HunterBuffSpeedStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
 {
-    triggers.push_back(new TriggerNode("aspect of the pack",
+    triggers.push_back(
-                                       { NextAction("aspect of the pack", 20.0f) }));
+        new TriggerNode(
-}
+            "aspect of the pack",
-
+            {
-void HunterBuffManaStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+                NextAction("aspect of the pack", ACTION_HIGH)
-{
+            }
-    triggers.push_back(new TriggerNode("aspect of the viper",
+        )
-                                       { NextAction("aspect of the viper", 20.0f) }));
+    );
 }

src/Ai/Class/Hunter/Strategy/HunterBuffStrategies.h

@@ -6,44 +6,35 @@
 #ifndef _PLAYERBOT_HUNTERBUFFSTRATEGIES_H
 #define _PLAYERBOT_HUNTERBUFFSTRATEGIES_H
 
-#include "NonCombatStrategy.h"
+#include "Strategy.h"
 
 class PlayerbotAI;
 
-class HunterBuffSpeedStrategy : public NonCombatStrategy
+class HunterBuffSpeedStrategy : public Strategy
 {
 public:
-    HunterBuffSpeedStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI) {}
+    HunterBuffSpeedStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
 
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
     std::string const getName() override { return "bspeed"; }
-    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
 };
 
-class HunterBuffManaStrategy : public NonCombatStrategy
+class HunterBuffDpsStrategy : public Strategy
-{
-public:
-    HunterBuffManaStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI) {}
-
-    std::string const getName() override { return "bmana"; }
-    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
-};
-
-class HunterBuffDpsStrategy : public NonCombatStrategy
 {
 public:
     HunterBuffDpsStrategy(PlayerbotAI* botAI);
 
-    std::string const getName() override { return "bdps"; }
     void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "bdps"; }
 };
 
-class HunterNatureResistanceStrategy : public NonCombatStrategy
+class HunterNatureResistanceStrategy : public Strategy
 {
 public:
-    HunterNatureResistanceStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI) {}
+    HunterNatureResistanceStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
 
-    std::string const getName() override { return "rnature"; }
     void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "rnature"; }
 };
 
 #endif

src/Ai/Class/Hunter/Strategy/MarksmanshipHunterStrategy.cpp

@@ -6,45 +6,9 @@
 #include "MarksmanshipHunterStrategy.h"
 #include "Playerbots.h"
 
-// ===== Action Node Factory =====
-class MarksmanshipHunterStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
-{
-public:
-    MarksmanshipHunterStrategyActionNodeFactory()
-    {
-        creators["auto shot"] = &auto_shot;
-        creators["silencing shot"] = &silencing_shot;
-        creators["kill command"] = &kill_command;
-        creators["kill shot"] = &kill_shot;
-        creators["viper sting"] = &viper_sting;
-        creators["serpent sting"] = serpent_sting;
-        creators["chimera shot"] = &chimera_shot;
-        creators["aimed shot"] = &aimed_shot;
-        creators["arcane shot"] = &arcane_shot;
-        creators["steady shot"] = &steady_shot;
-        creators["multi-shot"] = &multi_shot;
-        creators["volley"] = &volley;
-    }
-
-private:
-    static ActionNode* auto_shot(PlayerbotAI*) { return new ActionNode("auto shot", {}, {}, {}); }
-    static ActionNode* silencing_shot(PlayerbotAI*) { return new ActionNode("silencing shot", {}, {}, {}); }
-    static ActionNode* kill_command(PlayerbotAI*) { return new ActionNode("kill command", {}, {}, {}); }
-    static ActionNode* kill_shot(PlayerbotAI*) { return new ActionNode("kill shot", {}, {}, {}); }
-    static ActionNode* viper_sting(PlayerbotAI*) { return new ActionNode("viper sting", {}, {}, {}); }
-    static ActionNode* serpent_sting(PlayerbotAI*) { return new ActionNode("serpent sting", {}, {}, {}); }
-    static ActionNode* chimera_shot(PlayerbotAI*) { return new ActionNode("chimera shot", {}, {}, {}); }
-    static ActionNode* aimed_shot(PlayerbotAI*) { return new ActionNode("aimed shot", {}, {}, {}); }
-    static ActionNode* arcane_shot(PlayerbotAI*) { return new ActionNode("arcane shot", {}, {}, {}); }
-    static ActionNode* steady_shot(PlayerbotAI*) { return new ActionNode("steady shot", {}, {}, {}); }
-    static ActionNode* multi_shot(PlayerbotAI*) { return new ActionNode("multi shot", {}, {}, {}); }
-    static ActionNode* volley(PlayerbotAI*) { return new ActionNode("volley", {}, {}, {}); }
-};
-
-// ===== Single Target Strategy =====
 MarksmanshipHunterStrategy::MarksmanshipHunterStrategy(PlayerbotAI* botAI) : GenericHunterStrategy(botAI)
 {
-    actionNodeFactories.Add(new MarksmanshipHunterStrategyActionNodeFactory());
+    // No custom ActionNodeFactory needed
 }
 
 // ===== Default Actions =====

src/Ai/Class/Hunter/Strategy/SurvivalHunterStrategy.cpp

@@ -12,36 +12,35 @@ class SurvivalHunterStrategyActionNodeFactory : public NamedObjectFactory<Action
 public:
     SurvivalHunterStrategyActionNodeFactory()
     {
-        creators["auto shot"] = &auto_shot;
+        creators["explosive shot rank 4"] = &explosive_shot_rank_4;
-        creators["kill command"] = &kill_command;
+        creators["explosive shot rank 3"] = &explosive_shot_rank_3;
-        creators["kill shot"] = &kill_shot;
+        creators["explosive shot rank 2"] = &explosive_shot_rank_2;
-        creators["explosive shot"] = &explosive_shot;
-        creators["black arrow"] = &black_arrow;
-        creators["viper sting"] = &viper_sting;
-        creators["serpent sting"] = serpent_sting;
-        creators["aimed shot"] = &aimed_shot;
-        creators["arcane shot"] = &arcane_shot;
-        creators["steady shot"] = &steady_shot;
-        creators["multi-shot"] = &multi_shot;
-        creators["volley"] = &volley;
     }
 
 private:
-    static ActionNode* auto_shot(PlayerbotAI*) { return new ActionNode("auto shot", {}, {}, {}); }
+    static ActionNode* explosive_shot_rank_4([[maybe_unused]] PlayerbotAI* botAI)
-    static ActionNode* kill_command(PlayerbotAI*) { return new ActionNode("kill command", {}, {}, {}); }
+    {
-    static ActionNode* kill_shot(PlayerbotAI*) { return new ActionNode("kill shot", {}, {}, {}); }
+        return new ActionNode("explosive shot rank 4",
-    static ActionNode* explosive_shot(PlayerbotAI*) { return new ActionNode("explosive shot", {}, {}, {}); }
+                              /*P*/ {},
-    static ActionNode* black_arrow(PlayerbotAI*) { return new ActionNode("black arrow", {}, {}, {}); }
+                              /*A*/ { NextAction("explosive shot rank 3") },
-    static ActionNode* viper_sting(PlayerbotAI*) { return new ActionNode("viper sting", {}, {}, {}); }
+                              /*C*/ {});
-    static ActionNode* serpent_sting(PlayerbotAI*) { return new ActionNode("serpent sting", {}, {}, {}); }
+    }
-    static ActionNode* aimed_shot(PlayerbotAI*) { return new ActionNode("aimed shot", {}, {}, {}); }
+    static ActionNode* explosive_shot_rank_3([[maybe_unused]] PlayerbotAI* botAI)
-    static ActionNode* arcane_shot(PlayerbotAI*) { return new ActionNode("arcane shot", {}, {}, {}); }
+    {
-    static ActionNode* steady_shot(PlayerbotAI*) { return new ActionNode("steady shot", {}, {}, {}); }
+        return new ActionNode("explosive shot rank 3",
-    static ActionNode* multi_shot(PlayerbotAI*) { return new ActionNode("multi shot", {}, {}, {}); }
+                              /*P*/ {},
-    static ActionNode* volley(PlayerbotAI*) { return new ActionNode("volley", {}, {}, {}); }
+                              /*A*/ { NextAction("explosive shot rank 2") },
+                              /*C*/ {});
+    }
+    static ActionNode* explosive_shot_rank_2([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("explosive shot rank 2",
+                              /*P*/ {},
+                              /*A*/ { NextAction("explosive shot rank 1") },
+                              /*C*/ {});
+    }
 };
 
-// ===== Single Target Strategy =====
 SurvivalHunterStrategy::SurvivalHunterStrategy(PlayerbotAI* botAI) : GenericHunterStrategy(botAI)
 {
     actionNodeFactories.Add(new SurvivalHunterStrategyActionNodeFactory());
@@ -76,30 +75,6 @@ void SurvivalHunterStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
             }
         )
     );
-    triggers.push_back(
-        new TriggerNode(
-            "lock and load",
-            {
-                NextAction("explosive shot rank 3", 27.5f)
-            }
-        )
-    );
-    triggers.push_back(
-        new TriggerNode(
-            "lock and load",
-            {
-                NextAction("explosive shot rank 2", 27.0f)
-            }
-        )
-    );
-    triggers.push_back(
-        new TriggerNode(
-            "lock and load",
-            {
-                NextAction("explosive shot rank 1", 26.5f)
-            }
-        )
-    );
     triggers.push_back(
         new TriggerNode(
             "kill command",

src/Ai/Class/Hunter/Trigger/HunterTriggers.cpp

@@ -16,8 +16,7 @@
 
 bool KillCommandTrigger::IsActive()
 {
-    Unit* target = GetTarget();
+    return !botAI->HasAura("kill command", GetTarget());
-    return !botAI->HasAura("kill command", target);
 }
 
 bool BlackArrowTrigger::IsActive()
@@ -26,36 +25,46 @@ bool BlackArrowTrigger::IsActive()
         return false;
 
     return DebuffTrigger::IsActive();
-    return BuffTrigger::IsActive();
 }
 
-bool HunterAspectOfTheHawkTrigger::IsActive()
+bool HunterAspectOfTheDragonhawkTrigger::IsActive()
 {
     Unit* target = GetTarget();
-    return SpellTrigger::IsActive() && !botAI->HasAura("aspect of the hawk", target) &&
+    if (!target)
-           !botAI->HasAura("aspect of the dragonhawk", target) &&
+        return false;
-           (!AI_VALUE2(bool, "has mana", "self target") || AI_VALUE2(uint8, "mana", "self target") > 70);
+
+    if (!SpellTrigger::IsActive())
+        return false;
+
+    if (botAI->HasAura("aspect of the hawk", target) ||
+        botAI->HasAura("aspect of the dragonhawk", target))
+        return false;
+
+    if (botAI->HasAura("aspect of the viper", target))
+        return AI_VALUE2(uint8, "mana", "self target") >= 60;
+
+    return true;
 }
 
 bool HunterNoStingsActiveTrigger::IsActive()
 {
     Unit* target = AI_VALUE(Unit*, "current target");
-    return DebuffTrigger::IsActive() && target && !botAI->HasAura("serpent sting", target, false, true) &&
+    return DebuffTrigger::IsActive() && target &&
-           !botAI->HasAura("scorpid sting", target, false, true) && !botAI->HasAura("viper sting", target, false, true);
+           !botAI->HasAura("serpent sting", target, false, true) &&
-    return BuffTrigger::IsActive();
+           !botAI->HasAura("scorpid sting", target, false, true) &&
+           !botAI->HasAura("viper sting", target, false, true);
 }
 
 bool HuntersPetDeadTrigger::IsActive()
 {
-    // Unit* pet = AI_VALUE(Unit*, "pet target");
-    // return pet && AI_VALUE2(bool, "dead", "pet target") && !AI_VALUE2(bool, "mounted", "self target");
     return AI_VALUE(bool, "pet dead") && !AI_VALUE2(bool, "mounted", "self target");
 }
 
 bool HuntersPetLowHealthTrigger::IsActive()
 {
     Unit* pet = AI_VALUE(Unit*, "pet target");
-    return pet && AI_VALUE2(uint8, "health", "pet target") < 40 && !AI_VALUE2(bool, "dead", "pet target") &&
+    return pet && AI_VALUE2(uint8, "health", "pet target") < 40 &&
+           !AI_VALUE2(bool, "dead", "pet target") &&
            !AI_VALUE2(bool, "mounted", "self target");
 }
 
@@ -73,9 +82,14 @@ bool HunterPetNotHappy::IsActive()
 
 bool HunterAspectOfTheViperTrigger::IsActive()
 {
-    return SpellTrigger::IsActive() && !botAI->HasAura(spell, GetTarget()) &&
+    if (botAI->HasStrategy("rnature", BotState::BOT_STATE_COMBAT) ||
+        botAI->HasStrategy("rnature", BotState::BOT_STATE_NON_COMBAT) ||
+        botAI->HasStrategy("bspeed", BotState::BOT_STATE_COMBAT) ||
+        botAI->HasStrategy("bspeed", BotState::BOT_STATE_NON_COMBAT))
+        return false;
+
+    return BuffTrigger::IsActive() &&
            AI_VALUE2(uint8, "mana", "self target") < (sPlayerbotAIConfig.lowMana / 2);
-    ;
 }
 
 bool HunterAspectOfThePackTrigger::IsActive()
@@ -85,11 +99,14 @@ bool HunterAspectOfThePackTrigger::IsActive()
 
 bool HunterLowAmmoTrigger::IsActive()
 {
-    return bot->GetGroup() && (AI_VALUE2(uint32, "item count", "ammo") < 100) &&
+    uint32 ammoCount = AI_VALUE2(uint32, "item count", "ammo");
-           (AI_VALUE2(uint32, "item count", "ammo") > 0);
+    return bot->GetGroup() && ammoCount > 0 && ammoCount < 100;
 }
 
-bool HunterHasAmmoTrigger::IsActive() { return !AmmoCountTrigger::IsActive(); }
+bool HunterHasAmmoTrigger::IsActive()
+{
+    return !AmmoCountTrigger::IsActive();
+}
 
 bool SwitchToRangedTrigger::IsActive()
 {
@@ -131,6 +148,7 @@ bool NoTrackTrigger::IsActive()
         if (botAI->HasAura(track, bot))
             return false;
     }
+
     return true;
 }
 
@@ -138,17 +156,17 @@ bool SerpentStingOnAttackerTrigger::IsActive()
 {
     if (!DebuffOnAttackerTrigger::IsActive())
         return false;
+
     Unit* target = GetTarget();
     if (!target)
-    {
         return false;
-    }
+
     return !botAI->HasAura("scorpid sting", target, false, true) &&
            !botAI->HasAura("viper sting", target, false, true);
-    return BuffTrigger::IsActive();
 }
 
-const std::set<uint32> VolleyChannelCheckTrigger::VOLLEY_SPELL_IDS = {
+const std::set<uint32> VolleyChannelCheckTrigger::VOLLEY_SPELL_IDS =
+{
     1510,   // Volley Rank 1
     14294,  // Volley Rank 2
     14295,  // Volley Rank 3
@@ -159,19 +177,12 @@ const std::set<uint32> VolleyChannelCheckTrigger::VOLLEY_SPELL_IDS = {
 
 bool VolleyChannelCheckTrigger::IsActive()
 {
-    Player* bot = botAI->GetBot();
+    if (Spell* spell = bot->GetCurrentSpell(CURRENT_CHANNELED_SPELL);
-
+        spell && VOLLEY_SPELL_IDS.count(spell->m_spellInfo->Id))
-    // Check if the bot is channeling a spell
-    if (Spell* spell = bot->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
     {
-        // Only trigger if the spell being channeled is Volley
+        uint8 attackerCount = AI_VALUE(uint8, "attacker count");
-        if (VOLLEY_SPELL_IDS.count(spell->m_spellInfo->Id))
+        return attackerCount < minEnemies;
-        {
-            uint8 attackerCount = AI_VALUE(uint8, "attacker count");
-            return attackerCount < minEnemies;
-        }
     }
 
-    // Not channeling Volley
     return false;
 }

src/Ai/Class/Hunter/Trigger/HunterTriggers.h

@@ -16,16 +16,10 @@ class PlayerbotAI;
 
 // Buff and Out of Combat Triggers
 
-class HunterAspectOfTheMonkeyTrigger : public BuffTrigger
+class HunterAspectOfTheDragonhawkTrigger : public BuffTrigger
 {
 public:
-    HunterAspectOfTheMonkeyTrigger(PlayerbotAI* botAI) : BuffTrigger(botAI, "aspect of the monkey") {}
+    HunterAspectOfTheDragonhawkTrigger(PlayerbotAI* botAI) : BuffTrigger(botAI, "aspect of the dragonhawk") {}
-};
-
-class HunterAspectOfTheHawkTrigger : public BuffTrigger
-{
-public:
-    HunterAspectOfTheHawkTrigger(PlayerbotAI* botAI) : BuffTrigger(botAI, "aspect of the hawk") {}
     bool IsActive() override;
 };
 
@@ -130,10 +124,10 @@ public:
     FreezingTrapTrigger(PlayerbotAI* botAI) : HasCcTargetTrigger(botAI, "freezing trap") {}
 };
 
-class ConsussiveShotSnareTrigger : public SnareTargetTrigger
+class ConcussiveShotOnSnareTargetTrigger : public SnareTargetTrigger
 {
 public:
-    ConsussiveShotSnareTrigger(PlayerbotAI* botAI) : SnareTargetTrigger(botAI, "concussive shot") {}
+    ConcussiveShotOnSnareTargetTrigger(PlayerbotAI* botAI) : SnareTargetTrigger(botAI, "concussive shot") {}
 };
 
 class ScareBeastTrigger : public HasCcTargetTrigger
@@ -212,25 +206,25 @@ public:
 class MisdirectionOnMainTankTrigger : public BuffOnMainTankTrigger
 {
 public:
-    MisdirectionOnMainTankTrigger(PlayerbotAI* ai) : BuffOnMainTankTrigger(ai, "misdirection", true) {}
+    MisdirectionOnMainTankTrigger(PlayerbotAI* botAI) : BuffOnMainTankTrigger(botAI, "misdirection", true) {}
 };
 
 class TargetRemoveEnrageTrigger : public TargetAuraDispelTrigger
 {
 public:
-    TargetRemoveEnrageTrigger(PlayerbotAI* ai) : TargetAuraDispelTrigger(ai, "tranquilizing shot", DISPEL_ENRAGE) {}
+    TargetRemoveEnrageTrigger(PlayerbotAI* botAI) : TargetAuraDispelTrigger(botAI, "tranquilizing shot", DISPEL_ENRAGE) {}
 };
 
 class TargetRemoveMagicTrigger : public TargetAuraDispelTrigger
 {
 public:
-    TargetRemoveMagicTrigger(PlayerbotAI* ai) : TargetAuraDispelTrigger(ai, "tranquilizing shot", DISPEL_MAGIC) {}
+    TargetRemoveMagicTrigger(PlayerbotAI* botAI) : TargetAuraDispelTrigger(botAI, "tranquilizing shot", DISPEL_MAGIC) {}
 };
 
 class ImmolationTrapNoCdTrigger : public SpellNoCooldownTrigger
 {
 public:
-    ImmolationTrapNoCdTrigger(PlayerbotAI* ai) : SpellNoCooldownTrigger(ai, "immolation trap") {}
+    ImmolationTrapNoCdTrigger(PlayerbotAI* botAI) : SpellNoCooldownTrigger(botAI, "immolation trap") {}
 };
 
 BEGIN_TRIGGER(HuntersPetDeadTrigger, Trigger)

src/Ai/Raid/Icecrown/Multiplier/RaidIccMultipliers.cpp

@@ -647,7 +647,7 @@ float IccSindragosaMultiplier::GetValue(Action* action)
             dynamic_cast<CastWhirlwindAction*>(action) || dynamic_cast<CastMindSearAction*>(action) ||
             dynamic_cast<CastMagmaTotemAction*>(action) || dynamic_cast<CastConsecrationAction*>(action) ||
             dynamic_cast<CastFlamestrikeAction*>(action) || dynamic_cast<CastExplosiveTrapAction*>(action) ||
-            dynamic_cast<CastExplosiveShotAction*>(action))
+            dynamic_cast<CastExplosiveShotBaseAction*>(action))
             return 0.0f;
     }
 
@@ -774,7 +774,7 @@ float IccLichKingAddsMultiplier::GetValue(Action* action)
             dynamic_cast<CastStarfallAction*>(action) || dynamic_cast<FanOfKnivesAction*>(action) ||
             dynamic_cast<CastWhirlwindAction*>(action) || dynamic_cast<CastMindSearAction*>(action) ||
             dynamic_cast<CastMagmaTotemAction*>(action) || dynamic_cast<CastFlamestrikeAction*>(action) ||
-            dynamic_cast<CastExplosiveTrapAction*>(action) || dynamic_cast<CastExplosiveShotAction*>(action))
+            dynamic_cast<CastExplosiveTrapAction*>(action) || dynamic_cast<CastExplosiveShotBaseAction*>(action))
             return 0.0f;
     }
 

src/Bot/Factory/AiFactory.cpp

@@ -363,7 +363,7 @@ void AiFactory::AddDefaultCombatStrategies(Player* player, PlayerbotAI* const fa
             else
                 engine->addStrategiesNoInit("surv", nullptr);
 
-            engine->addStrategiesNoInit("cc", "dps assist", "aoe", nullptr);
+            engine->addStrategiesNoInit("cc", "dps assist", "aoe", "bdps", nullptr);
             break;
         case CLASS_ROGUE:
             if (tab == ROGUE_TAB_ASSASSINATION || tab == ROGUE_TAB_SUBTLETY)

src/Bot/Factory/PlayerbotFactory.cpp

@@ -3307,7 +3307,7 @@ void PlayerbotFactory::InitReagents()
             break;
         case CLASS_PALADIN:
             if (level >= 52)
-                items.push_back({21177, 80});   // Symbol of Kings
+                items.push_back({21177, 100});   // Symbol of Kings
             break;
         case CLASS_PRIEST:
             if (level >= 48 && level < 56)