Rogue combat strategy fixes

Author: bozimmerman

src/modules/Bots/playerbot/strategy/rogue/DpsRogueStrategy.cpp

@@ -85,9 +85,17 @@ void DpsRogueStrategy::InitTriggers(std::list<TriggerNode*> &triggers)
     MeleeCombatStrategy::InitTriggers(triggers);
 
     triggers.push_back(new TriggerNode(
-        "combo points available",
+        "slice and dice",
+        NextAction::array(0, new NextAction("slice and dice", ACTION_HIGH + 3), NULL)));
+
+    triggers.push_back(new TriggerNode(
+        "combo points for target available",
         NextAction::array(0, new NextAction("rupture", ACTION_HIGH + 2), NULL)));
 
+    triggers.push_back(new TriggerNode(
+        "expose armor",
+        NextAction::array(0, new NextAction("expose armor", ACTION_HIGH + 1), NULL)));
+
     triggers.push_back(new TriggerNode(
         "medium threat",
         NextAction::array(0, new NextAction("vanish", ACTION_HIGH), NULL)));

src/modules/Bots/playerbot/strategy/rogue/GenericRogueNonCombatStrategy.cpp

@@ -11,4 +11,7 @@ void GenericRogueNonCombatStrategy::InitTriggers(std::list<TriggerNode*> &trigge
 {
     NonCombatStrategy::InitTriggers(triggers);
 
+    triggers.push_back(new TriggerNode(
+        "stealth",
+        NextAction::array(0, new NextAction("stealth", ACTION_NORMAL), NULL)));
 }

src/modules/Bots/playerbot/strategy/rogue/RogueActions.h

@@ -60,4 +60,10 @@ namespace ai
     public:
         CastKickOnEnemyHealerAction(PlayerbotAI* ai) : CastSpellOnEnemyHealerAction(ai, "kick") {}
     };
+
+    class CastStealthAction : public CastBuffSpellAction
+    {
+    public:
+        CastStealthAction(PlayerbotAI* ai) : CastBuffSpellAction(ai, "stealth") {}
+    };
 }

src/modules/Bots/playerbot/strategy/rogue/RogueAiObjectContext.cpp

@@ -5,7 +5,7 @@
 #include "RogueAiObjectContext.h"
 #include "DpsRogueStrategy.h"
 #include "GenericRogueNonCombatStrategy.h"
-#include "../generic/PullStrategy.h"
+#include "RogueAmbushStrategy.h"
 #include "../NamedObjectContext.h"
 
 using namespace ai;
@@ -30,7 +30,7 @@ namespace ai
         private:
             static Strategy* dps(PlayerbotAI* ai) { return new DpsRogueStrategy(ai); }
             static Strategy* nc(PlayerbotAI* ai) { return new GenericRogueNonCombatStrategy(ai); }
-            static Strategy* pull(PlayerbotAI* ai) { return new PullStrategy(ai, "shoot"); }
+            static Strategy* pull(PlayerbotAI* ai) { return new RogueAmbushStrategy(ai); }
         };
     };
 };
@@ -51,6 +51,8 @@ namespace ai
                 creators["slice and dice"] = &TriggerFactoryInternal::slice_and_dice;
                 creators["expose armor"] = &TriggerFactoryInternal::expose_armor;
                 creators["kick on enemy healer"] = &TriggerFactoryInternal::kick_on_enemy_healer;
+                creators["combo points for target available"] = &TriggerFactoryInternal::combo_points_for_target_available;
+                creators["stealth"] = &TriggerFactoryInternal::stealth;
 
             }
 
@@ -60,6 +62,8 @@ namespace ai
             static Trigger* slice_and_dice(PlayerbotAI* ai) { return new SliceAndDiceTrigger(ai); }
             static Trigger* expose_armor(PlayerbotAI* ai) { return new ExposeArmorTrigger(ai); }
             static Trigger* kick_on_enemy_healer(PlayerbotAI* ai) { return new KickInterruptEnemyHealerSpellTrigger(ai); }
+            static Trigger* combo_points_for_target_available(PlayerbotAI* ai) { return new ComboPointsForTargetAvailableTrigger(ai); }
+            static Trigger* stealth(PlayerbotAI* ai) { return new StealthTrigger(ai); }
         };
     };
 };
@@ -90,6 +94,10 @@ namespace ai
                 creators["backstab"] = &AiObjectContextInternal::backstab;
                 creators["expose armor"] = &AiObjectContextInternal::expose_armor;
                 creators["kick on enemy healer"] = &AiObjectContextInternal::kick_on_enemy_healer;
+                creators["sap"] = &AiObjectContextInternal::sap;
+                creators["garrote"] = &AiObjectContextInternal::garrote;
+                creators["cheap shot"] = &AiObjectContextInternal::cheap_shot;
+                creators["stealth"] = &AiObjectContextInternal::stealth;
             }
 
         private:
@@ -107,6 +115,10 @@ namespace ai
             static Action* backstab(PlayerbotAI* ai) { return new CastBackstabAction(ai); }
             static Action* expose_armor(PlayerbotAI* ai) { return new CastExposeArmorAction(ai); }
             static Action* kick_on_enemy_healer(PlayerbotAI* ai) { return new CastKickOnEnemyHealerAction(ai); }
+            static Action* sap(PlayerbotAI* ai) { return new CastSapAction(ai); }
+            static Action* garrote(PlayerbotAI* ai) { return new CastGarroteAction(ai); }
+            static Action* cheap_shot(PlayerbotAI* ai) { return new CastCheapShotAction(ai); }
+            static Action* stealth(PlayerbotAI* ai) { return new CastStealthAction(ai); }
         };
     };
 };

src/modules/Bots/playerbot/strategy/rogue/RogueAmbushStrategy.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "../Strategy.h"
+
+namespace ai
+{
+    class RogueAmbushStrategy : public Strategy
+    {
+    public:
+        RogueAmbushStrategy(PlayerbotAI* ai) : Strategy(ai) {}
+        virtual string getName() { return "pull"; }
+
+        virtual NextAction** getDefaultActions()
+        {
+            // Stealth first; once stealthed, cheap shot moves to target (via reach melee
+            // prerequisite) and opens. End pull fires once combat begins.
+            return NextAction::array(0,
+                new NextAction("stealth", 105.0f),
+                new NextAction("cheap shot", 104.0f),
+                new NextAction("end pull", 103.0f),
+                new NextAction("sinister strike", 100.0f),
+                NULL);
+        }
+    };
+}

src/modules/Bots/playerbot/strategy/rogue/RogueComboActions.h

@@ -9,7 +9,7 @@ namespace ai
 
         virtual bool isUseful()
         {
-            return CastMeleeSpellAction::isUseful() && AI_VALUE2(uint8, "combo", "self target") < 5;
+            return CastMeleeSpellAction::isUseful() && AI_VALUE2(uint8, "combo", "current target") < 5;
         }
     };
 

src/modules/Bots/playerbot/strategy/rogue/RogueFinishingActions.h

@@ -2,34 +2,45 @@
 
 namespace ai
 {
-    class CastEviscerateAction : public CastMeleeSpellAction
+    class CastFinishingMoveAction : public CastMeleeSpellAction
     {
     public:
-        CastEviscerateAction(PlayerbotAI* ai) : CastMeleeSpellAction(ai, "eviscerate") {}
+        CastFinishingMoveAction(PlayerbotAI* ai, string name) : CastMeleeSpellAction(ai, name) {}
+
+        virtual bool isUseful()
+        {
+            return CastMeleeSpellAction::isUseful() && AI_VALUE2(uint8, "combo", "current target") >= 1;
+        }
+    };
+
+    class CastEviscerateAction : public CastFinishingMoveAction
+    {
+    public:
+        CastEviscerateAction(PlayerbotAI* ai) : CastFinishingMoveAction(ai, "eviscerate") {}
     };
 
-    class CastSliceAndDiceAction : public CastMeleeSpellAction
+    class CastSliceAndDiceAction : public CastFinishingMoveAction
     {
     public:
-        CastSliceAndDiceAction(PlayerbotAI* ai) : CastMeleeSpellAction(ai, "slice and dice") {}
+        CastSliceAndDiceAction(PlayerbotAI* ai) : CastFinishingMoveAction(ai, "slice and dice") {}
     };
 
-    class CastExposeArmorAction : public CastMeleeSpellAction
+    class CastExposeArmorAction : public CastFinishingMoveAction
     {
     public:
-        CastExposeArmorAction(PlayerbotAI* ai) : CastMeleeSpellAction(ai, "expose armor") {}
+        CastExposeArmorAction(PlayerbotAI* ai) : CastFinishingMoveAction(ai, "expose armor") {}
     };
 
-    class CastRuptureAction : public CastMeleeSpellAction
+    class CastRuptureAction : public CastFinishingMoveAction
     {
     public:
-        CastRuptureAction(PlayerbotAI* ai) : CastMeleeSpellAction(ai, "rupture") {}
+        CastRuptureAction(PlayerbotAI* ai) : CastFinishingMoveAction(ai, "rupture") {}
     };
 
-    class CastKidneyShotAction : public CastMeleeSpellAction
+    class CastKidneyShotAction : public CastFinishingMoveAction
     {
     public:
-        CastKidneyShotAction(PlayerbotAI* ai) : CastMeleeSpellAction(ai, "kidney shot") {}
+        CastKidneyShotAction(PlayerbotAI* ai) : CastFinishingMoveAction(ai, "kidney shot") {}
     };
 
 }

src/modules/Bots/playerbot/strategy/rogue/RogueOpeningActions.h

@@ -2,23 +2,38 @@
 
 namespace ai
 {
-    class CastSapAction : public CastMeleeSpellAction
+    class CastStealthedOpeningAction : public CastMeleeSpellAction
     {
     public:
-        CastSapAction(PlayerbotAI* ai) : CastMeleeSpellAction(ai, "sap") {}
+        CastStealthedOpeningAction(PlayerbotAI* ai, string name) : CastMeleeSpellAction(ai, name) {}
+
+        virtual bool isUseful()
+        {
+            return CastMeleeSpellAction::isUseful() && ai->HasAura("stealth", ai->GetBot());
+        }
     };
 
-    class CastGarroteAction : public CastMeleeSpellAction
+    class CastSapAction : public CastStealthedOpeningAction
     {
     public:
-        CastGarroteAction(PlayerbotAI* ai) : CastMeleeSpellAction(ai, "garrote") {}
+        CastSapAction(PlayerbotAI* ai) : CastStealthedOpeningAction(ai, "sap") {}
     };
 
+    class CastGarroteAction : public CastStealthedOpeningAction
+    {
+    public:
+        CastGarroteAction(PlayerbotAI* ai) : CastStealthedOpeningAction(ai, "garrote") {}
+
+        virtual bool isUseful()
+        {
+            return CastStealthedOpeningAction::isUseful() && AI_VALUE2(bool, "behind", "current target");
+        }
+    };
 
-    class CastCheapShotAction : public CastMeleeSpellAction
+    class CastCheapShotAction : public CastStealthedOpeningAction
     {
     public:
-        CastCheapShotAction(PlayerbotAI* ai) : CastMeleeSpellAction(ai, "cheap shot") {}
+        CastCheapShotAction(PlayerbotAI* ai) : CastStealthedOpeningAction(ai, "cheap shot") {}
     };
 
 }

src/modules/Bots/playerbot/strategy/rogue/RogueTriggers.h

@@ -33,4 +33,61 @@ namespace ai
     public:
         KickInterruptEnemyHealerSpellTrigger(PlayerbotAI* ai) : InterruptEnemyHealerTrigger(ai, "kick") {}
     };
+
+    class StealthTrigger : public Trigger
+    {
+    public:
+        StealthTrigger(PlayerbotAI* ai) : Trigger(ai, "stealth") {}
+
+        virtual bool IsActive()
+        {
+            Unit* target = AI_VALUE(Unit*, "current target");
+            if (!target && !bot->IsInCombat() && ai->HasAura("stealth", bot))
+                bot->RemoveSpellsCausingAura(SPELL_AURA_MOD_STEALTH);
+            return target && !ai->HasAura("stealth", bot);
+        }
+    };
+
+    class ComboPointsForTargetAvailableTrigger : public Trigger
+    {
+    public:
+        ComboPointsForTargetAvailableTrigger(PlayerbotAI* ai)
+            : Trigger(ai, "combo points for target available"), m_threshold(2) {}
+
+        virtual bool IsActive()
+        {
+            Unit* target = AI_VALUE(Unit*, "current target");
+            if (!target)
+                return false;
+
+            ObjectGuid guid = target->GetObjectGuid();
+            if (guid != m_lastTargetGuid)
+            {
+                m_lastTargetGuid = guid;
+                m_threshold = 2;
+            }
+
+            uint8 combo = AI_VALUE2(uint8, "combo", "current target");
+            if (combo >= m_threshold)
+            {
+                m_threshold = nextThreshold(target);
+                return true;
+            }
+            return false;
+        }
+
+    private:
+        uint8 m_threshold;
+        ObjectGuid m_lastTargetGuid;
+
+        uint8 nextThreshold(Unit* target)
+        {
+            Creature* creature = dynamic_cast<Creature*>(target);
+            if (creature && creature->GetCreatureInfo() &&
+                creature->GetCreatureInfo()->Rank > CREATURE_ELITE_NORMAL)
+                return 3 + urand(0, 2);  // 3, 4, or 5
+            else
+                return 1 + urand(0, 1);  // 1 or 2
+        }
+    };
 }