warlock and dk strategy port

2026-02-07 20:51:09 +00:00 · 2023-06-03 14:01:20 +08:00
parent a44b310c0a
commit 0f483047e5
27 changed files with 562 additions and 88 deletions
--- a/src/strategy/warlock/DpsWarlockStrategy.cpp
+++ b/src/strategy/warlock/DpsWarlockStrategy.cpp
@@ -11,6 +11,8 @@ class DpsWarlockStrategyActionNodeFactory : public NamedObjectFactory<ActionNode
        DpsWarlockStrategyActionNodeFactory()
        {
            creators["shadow bolt"] = &shadow_bolt;
+            creators["unstable affliction"] = &unstable_affliction;
+            creators["unstable affliction on attacker"] = &unstable_affliction_on_attacker;
        }

    private:
@@ -21,6 +23,20 @@ class DpsWarlockStrategyActionNodeFactory : public NamedObjectFactory<ActionNode
                /*A*/ NextAction::array(0, new NextAction("shoot"), nullptr),
                /*C*/ nullptr);
        }
+        static ActionNode* unstable_affliction(PlayerbotAI* ai)
+        {
+            return new ActionNode ("unstable affliction",
+                /*P*/ NULL,
+                /*A*/ NextAction::array(0, new NextAction("immolate"), NULL),
+                /*C*/ NULL);
+        }
+        static ActionNode* unstable_affliction_on_attacker(PlayerbotAI* ai)
+        {
+            return new ActionNode ("unstable affliction on attacker",
+                /*P*/ NULL,
+                /*A*/ NextAction::array(0, new NextAction("immolate on attacker"), NULL),
+                /*C*/ NULL);
+        }
 };

 DpsWarlockStrategy::DpsWarlockStrategy(PlayerbotAI* botAI) : GenericWarlockStrategy(botAI)
@@ -30,7 +46,11 @@ DpsWarlockStrategy::DpsWarlockStrategy(PlayerbotAI* botAI) : GenericWarlockStrat

 NextAction** DpsWarlockStrategy::getDefaultActions()
 {
-    return NextAction::array(0, new NextAction("incinirate", 10.0f), new NextAction("shadow bolt", 10.0f), nullptr);
+    return NextAction::array(0, 
+        new NextAction("haunt", 14.0f), 
+        new NextAction("demonic empowerment", 13.0f),
+		new NextAction("shadow bolt", 10.0f), 
+        nullptr);
 }

 void DpsWarlockStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
@@ -38,19 +58,39 @@ void DpsWarlockStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
    GenericWarlockStrategy::InitTriggers(triggers);

 	triggers.push_back(new TriggerNode("backlash", NextAction::array(0, new NextAction("shadow bolt", 20.0f), nullptr)));
+
+    triggers.push_back(new TriggerNode(
+		"haunt",
+		NextAction::array(0, new NextAction("haunt", 26.0f), NULL)));
+
+	triggers.push_back(new TriggerNode(
+		"shadow trance",
+		NextAction::array(0, new NextAction("shadow bolt", 15.0f), NULL)));
+
+	triggers.push_back(new TriggerNode(
+		"backlash",
+		NextAction::array(0, new NextAction("shadow bolt", 15.0f), NULL)));
+
+    triggers.push_back(new TriggerNode(
+		"molten core",
+		NextAction::array(0, new NextAction("incinerate", 15.0f), NULL)));
+
+    triggers.push_back(new TriggerNode(
+		"decimation",
+		NextAction::array(0, new NextAction("soul fire", 16.0f), NULL)));
 }

 void DpsAoeWarlockStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
 {
    triggers.push_back(new TriggerNode("medium aoe", NextAction::array(0, new NextAction("rain of fire", 37.0f), nullptr)));
    triggers.push_back(new TriggerNode("corruption on attacker", NextAction::array(0, new NextAction("corruption on attacker", 27.0f), nullptr)));
-    triggers.push_back(new TriggerNode("curse of agony on attacker", NextAction::array(0, new NextAction("curse of agony on attacker", 28.0f), nullptr)));
-    triggers.push_back(new TriggerNode("siphon life on attacker", NextAction::array(0, new NextAction("siphon life on attacker", 29.0f), nullptr)));
+    // triggers.push_back(new TriggerNode("curse of agony on attacker", NextAction::array(0, new NextAction("curse of agony on attacker", 28.0f), nullptr)));
+    triggers.push_back(new TriggerNode("unstable affliction on attacker", NextAction::array(0, new NextAction("unstable affliction on attacker", 22.0f), NULL)));
 }

 void DpsWarlockDebuffStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
 {
    triggers.push_back(new TriggerNode("corruption", NextAction::array(0, new NextAction("corruption", 22.0f), nullptr)));
-    triggers.push_back(new TriggerNode("curse of agony", NextAction::array(0, new NextAction("curse of agony", 21.0f), nullptr)));
-    triggers.push_back(new TriggerNode("siphon life", NextAction::array(0, new NextAction("siphon life", 23.0f), nullptr)));
+    triggers.push_back(new TriggerNode("curse of agony", NextAction::array(0, new NextAction("curse of agony", 20.0f), nullptr)));
+    triggers.push_back(new TriggerNode("unstable affliction", NextAction::array(0, new NextAction("unstable affliction", 21.0f), NULL)));
 }
--- a/src/strategy/warlock/GenericWarlockNonCombatStrategy.cpp
+++ b/src/strategy/warlock/GenericWarlockNonCombatStrategy.cpp
@@ -15,6 +15,7 @@ class GenericWarlockNonCombatStrategyActionNodeFactory : public NamedObjectFacto
            creators["summon voidwalker"] = &summon_voidwalker;
            creators["summon felguard"] = &summon_felguard;
            creators["summon succubus"] = &summon_succubus;
+            creators["summon felhunter"] = &summon_felhunter;
        }

    private:
@@ -57,6 +58,14 @@ class GenericWarlockNonCombatStrategyActionNodeFactory : public NamedObjectFacto
                /*A*/ NextAction::array(0, new NextAction("summon voidwalker"), nullptr),
                /*C*/ nullptr);
        }
+
+        static ActionNode* summon_felhunter([[maybe_unused]] PlayerbotAI* botAI)
+        {
+            return new ActionNode("summon felhunter",
+                /*P*/ nullptr,
+                /*A*/ NextAction::array(0, new NextAction("summon imp"), nullptr),
+                /*C*/ nullptr);
+        }
 };

 GenericWarlockNonCombatStrategy::GenericWarlockNonCombatStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI)
@@ -69,12 +78,38 @@ void GenericWarlockNonCombatStrategy::InitTriggers(std::vector<TriggerNode*>& tr
    NonCombatStrategy::InitTriggers(triggers);

    triggers.push_back(new TriggerNode("demon armor", NextAction::array(0, new NextAction("fel armor", 21.0f), nullptr)));
+    triggers.push_back(new TriggerNode("often", NextAction::array(0, new NextAction("apply oil", 1.0f), nullptr)));
 }

 void WarlockPetStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
 {
    triggers.push_back(new TriggerNode("no pet", NextAction::array(0, new NextAction("summon felguard", 60.0f), nullptr)));
    // TODO Warlock pets
-
-    triggers.push_back(new TriggerNode("often", NextAction::array(0, new NextAction("apply oil", 1.0f), nullptr)));
 }
+
+SummonImpStrategy::SummonImpStrategy(PlayerbotAI* ai): NonCombatStrategy(ai) {}
+
+void SummonImpStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(new TriggerNode(
+        "no pet",
+        NextAction::array(0, new NextAction("summon imp", 11.0f), NULL)));
+}
+
+SummonFelguardStrategy::SummonFelguardStrategy(PlayerbotAI* ai): NonCombatStrategy(ai) {}
+
+void SummonFelguardStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(new TriggerNode(
+        "no pet",
+        NextAction::array(0, new NextAction("summon felguard", 11.0f), NULL)));
+}
+
+SummonFelhunterStrategy::SummonFelhunterStrategy(PlayerbotAI* ai): NonCombatStrategy(ai) {}
+
+void SummonFelhunterStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(new TriggerNode(
+        "no pet",
+        NextAction::array(0, new NextAction("summon felhunter", 11.0f), NULL)));
+}
--- a/src/strategy/warlock/GenericWarlockNonCombatStrategy.h
+++ b/src/strategy/warlock/GenericWarlockNonCombatStrategy.h
@@ -27,4 +27,31 @@ class WarlockPetStrategy : public Strategy
        void InitTriggers(std::vector<TriggerNode*>& triggers) override;
 };

+class SummonImpStrategy : public NonCombatStrategy
+{
+    public:
+        SummonImpStrategy(PlayerbotAI* ai);
+        virtual std::string const getName() override { return "bhealth"; }
+    public:
+        void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+class SummonFelguardStrategy : public NonCombatStrategy
+{
+    public:
+        SummonFelguardStrategy(PlayerbotAI* ai);
+        virtual std::string const getName() override { return "bdps"; }
+    public:
+        void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+class SummonFelhunterStrategy : public NonCombatStrategy
+{
+    public:
+        SummonFelhunterStrategy(PlayerbotAI* ai);
+        virtual std::string const getName() override { return "bmana"; }
+    public:
+        void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
 #endif
--- a/src/strategy/warlock/GenericWarlockStrategy.cpp
+++ b/src/strategy/warlock/GenericWarlockStrategy.cpp
@@ -45,11 +45,12 @@ void GenericWarlockStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
 {
    CombatStrategy::InitTriggers(triggers);

-    triggers.push_back(new TriggerNode("shadow trance", NextAction::array(0, new NextAction("shadow bolt", 20.0f), nullptr)));
-    triggers.push_back(new TriggerNode("low health", NextAction::array(0, new NextAction("drain life", 40.0f), nullptr)));
-    triggers.push_back(new TriggerNode("medium mana", NextAction::array(0, new NextAction("life tap", ACTION_EMERGENCY + 5), nullptr)));
+    // triggers.push_back(new TriggerNode("shadow trance", NextAction::array(0, new NextAction("shadow bolt", 20.0f), nullptr)));
+    // triggers.push_back(new TriggerNode("low health", NextAction::array(0, new NextAction("drain life", 40.0f), nullptr)));
+    triggers.push_back(new TriggerNode("low mana", NextAction::array(0, new NextAction("life tap", ACTION_EMERGENCY + 5), nullptr)));
 	triggers.push_back(new TriggerNode("target critical health", NextAction::array(0, new NextAction("drain soul", 30.0f), nullptr)));
-    triggers.push_back(new TriggerNode("immolate", NextAction::array(0, new NextAction("immolate", 13.0f), new NextAction("conflagrate", 13.0f), nullptr)));
+    // triggers.push_back(new TriggerNode("immolate", NextAction::array(0, new NextAction("immolate", 13.0f), new NextAction("conflagrate", 13.0f), nullptr)));
+    triggers.push_back(new TriggerNode("enemy too close for spell", NextAction::array(0, new NextAction("flee", 49.0f), NULL)));
 }

 void WarlockBoostStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
--- a/src/strategy/warlock/TankWarlockStrategy.cpp
+++ b/src/strategy/warlock/TankWarlockStrategy.cpp
@@ -13,6 +13,7 @@ class GenericWarlockStrategyActionNodeFactory : public NamedObjectFactory<Action
            creators["summon voidwalker"] = &summon_voidwalker;
            creators["summon felguard"] = &summon_felguard;
            creators["summon succubus"] = &summon_succubus;
+            creators["summon felhunter"] = &summon_felhunter;
        }

    private:
@@ -39,6 +40,14 @@ class GenericWarlockStrategyActionNodeFactory : public NamedObjectFactory<Action
                /*A*/ NextAction::array(0, new NextAction("summon voidwalker"), nullptr),
                /*C*/ nullptr);
        }
+
+        static ActionNode* summon_felhunter([[maybe_unused]] PlayerbotAI* botAI)
+        {
+            return new ActionNode("summon felhunter",
+                /*P*/ nullptr,
+                /*A*/ NextAction::array(0, new NextAction("summon imp"), nullptr),
+                /*C*/ nullptr);
+        }
 };

 TankWarlockStrategy::TankWarlockStrategy(PlayerbotAI* botAI) : GenericWarlockStrategy(botAI)
--- a/src/strategy/warlock/WarlockActions.cpp
+++ b/src/strategy/warlock/WarlockActions.cpp
@@ -8,7 +8,7 @@

 bool CastDrainSoulAction::isUseful()
 {
-    return AI_VALUE2(uint32, "item count", "soul shard") < uint32(AI_VALUE(uint8, "bag space") * 0.2);
+    return AI_VALUE2(uint32, "item count", "soul shard") < 10;
 }

 Value<Unit*>* CastBanishAction::GetTargetValue()
--- a/src/strategy/warlock/WarlockActions.h
+++ b/src/strategy/warlock/WarlockActions.h
@@ -93,6 +93,12 @@ class CastSummonFelguardAction : public CastBuffSpellAction
 		CastSummonFelguardAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "summon felguard") { }
 };

+class CastSummonFelhunterAction : public CastBuffSpellAction
+{
+	public:
+		CastSummonFelhunterAction(PlayerbotAI* botAI) : CastBuffSpellAction(botAI, "summon felhunter") { }
+};
+
 class CastSummonImpAction : public CastBuffSpellAction
 {
 	public:
@@ -218,4 +224,45 @@ class CastSiphonLifeOnAttackerAction : public CastDebuffSpellOnAttackerAction
        CastSiphonLifeOnAttackerAction(PlayerbotAI* botAI) : CastDebuffSpellOnAttackerAction(botAI, "siphon life") { }
 };

+class CastUnstableAfflictionAction: public CastDebuffSpellAction
+{
+    public:
+        CastUnstableAfflictionAction(PlayerbotAI* ai) : CastDebuffSpellAction(ai, "unstable affliction", true) {}
+};
+
+class CastHauntAction: public CastSpellAction
+{
+    public:
+        CastHauntAction(PlayerbotAI* ai) : CastSpellAction(ai, "haunt") {}
+};
+
+class CastDemonicEmpowermentAction : public CastBuffSpellAction
+{
+    public:
+        CastDemonicEmpowermentAction(PlayerbotAI* ai) : CastBuffSpellAction(ai, "demonic empowerment") {}
+};
+
+class CastMetamorphosisAction : public CastBuffSpellAction
+{
+    public:
+        CastMetamorphosisAction(PlayerbotAI* ai) : CastBuffSpellAction(ai, "metamorphosis") {}
+};
+
+class CastUnstableAfflictionOnAttackerAction : public CastDebuffSpellOnAttackerAction
+{
+    public:
+        CastUnstableAfflictionOnAttackerAction(PlayerbotAI* ai) : CastDebuffSpellOnAttackerAction(ai, "unstable affliction", true) {}
+};
+
+class CastSoulFireAction : public CastSpellAction
+{
+    public:
+        CastSoulFireAction(PlayerbotAI* ai) : CastSpellAction(ai, "soul fire") {}
+};
+
+class CastIncinerateAction : public CastSpellAction
+{
+    public:
+        CastIncinerateAction(PlayerbotAI* ai) : CastSpellAction(ai, "incinerate") {}
+};
 #endif
--- a/src/strategy/warlock/WarlockAiObjectContext.cpp
+++ b/src/strategy/warlock/WarlockAiObjectContext.cpp
@@ -5,6 +5,7 @@
 #include "WarlockAiObjectContext.h"
 #include "DpsWarlockStrategy.h"
 #include "GenericWarlockNonCombatStrategy.h"
+#include "Strategy.h"
 #include "TankWarlockStrategy.h"
 #include "WarlockActions.h"
 #include "WarlockTriggers.h"
@@ -51,6 +52,21 @@ class WarlockCombatStrategyFactoryInternal : public NamedObjectContext<Strategy>
        static Strategy* dps(PlayerbotAI* botAI) { return new DpsWarlockStrategy(botAI); }
 };

+class NonCombatBuffStrategyFactoryInternal : public NamedObjectContext<Strategy>
+{
+public:
+    NonCombatBuffStrategyFactoryInternal() : NamedObjectContext<Strategy>(false, true)
+    {
+        creators["bdps"] = &NonCombatBuffStrategyFactoryInternal::felguard;
+        creators["bmana"] = &NonCombatBuffStrategyFactoryInternal::felhunter;
+        creators["bhealth"] = &NonCombatBuffStrategyFactoryInternal::imp;
+    }
+private:
+    static Strategy* imp(PlayerbotAI* ai) { return new SummonImpStrategy(ai); }
+    static Strategy* felhunter(PlayerbotAI* ai) { return new SummonFelhunterStrategy(ai); }
+    static Strategy* felguard(PlayerbotAI* ai) { return new SummonFelguardStrategy(ai); }
+}; 
+
 class WarlockTriggerFactoryInternal : public NamedObjectContext<Trigger>
 {
    public:
@@ -73,6 +89,15 @@ class WarlockTriggerFactoryInternal : public NamedObjectContext<Trigger>
            creators["amplify curse"] = &WarlockTriggerFactoryInternal::amplify_curse;
            creators["siphon life"] = &WarlockTriggerFactoryInternal::siphon_life;
            creators["siphon life on attacker"] = &WarlockTriggerFactoryInternal::siphon_life_on_attacker;
+
+            creators["immolate on attacker"] = &WarlockTriggerFactoryInternal::immolate_on_attacker;
+            creators["unstable affliction"] = &WarlockTriggerFactoryInternal::unstable_affliction;
+            creators["unstable affliction on attacker"] = &WarlockTriggerFactoryInternal::unstable_affliction_on_attacker;
+            creators["haunt"] = &WarlockTriggerFactoryInternal::haunt;
+            creators["decimation"] = &WarlockTriggerFactoryInternal::decimation;
+            creators["molten core"] = &WarlockTriggerFactoryInternal::molten_core;
+            creators["metamorphosis"] = &WarlockTriggerFactoryInternal::metamorphosis;
+            
        }

    private:
@@ -93,6 +118,13 @@ class WarlockTriggerFactoryInternal : public NamedObjectContext<Trigger>
        static Trigger* backlash(PlayerbotAI* botAI) { return new BacklashTrigger(botAI); }
        static Trigger* fear(PlayerbotAI* botAI) { return new FearTrigger(botAI); }
        static Trigger* immolate(PlayerbotAI* botAI) { return new ImmolateTrigger(botAI); }
+        static Trigger* immolate_on_attacker(PlayerbotAI* ai) { return new ImmolateOnAttackerTrigger(ai); }
+        static Trigger* unstable_affliction(PlayerbotAI* ai) { return new UnstableAfflictionTrigger(ai); }
+        static Trigger* unstable_affliction_on_attacker(PlayerbotAI* ai) { return new UnstableAfflictionOnAttackerTrigger(ai); }
+        static Trigger* haunt(PlayerbotAI* ai) { return new HauntTrigger(ai); }
+        static Trigger* decimation(PlayerbotAI* ai) { return new DecimationTrigger(ai); }
+        static Trigger* molten_core(PlayerbotAI* ai) { return new MoltenCoreTrigger(ai); }
+        static Trigger* metamorphosis(PlayerbotAI* ai) { return new MetamorphosisTrigger(ai); }
 };

 class WarlockAiObjectContextInternal : public NamedObjectContext<Action>
@@ -109,6 +141,7 @@ class WarlockAiObjectContextInternal : public NamedObjectContext<Action>
            creators["spellstone"] = &WarlockAiObjectContextInternal::spellstone;
            creators["summon voidwalker"] = &WarlockAiObjectContextInternal::summon_voidwalker;
            creators["summon felguard"] = &WarlockAiObjectContextInternal::summon_felguard;
+            creators["summon felhunter"] = &WarlockAiObjectContextInternal::summon_felhunter;
            creators["summon succubus"] = &WarlockAiObjectContextInternal::summon_succubus;
            creators["summon imp"] = &WarlockAiObjectContextInternal::summon_imp;
            creators["immolate"] = &WarlockAiObjectContextInternal::immolate;
@@ -133,6 +166,14 @@ class WarlockAiObjectContextInternal : public NamedObjectContext<Action>
            creators["incinirate"] = &WarlockAiObjectContextInternal::incinirate;
            creators["conflagrate"] = &WarlockAiObjectContextInternal::conflagrate;
            creators["amplify curse"] = &WarlockAiObjectContextInternal::amplify_curse;
+
+            creators["unstable affliction"] = &WarlockAiObjectContextInternal::unstable_affliction;
+            creators["unstable affliction on attacker"] = &WarlockAiObjectContextInternal::unstable_affliction_on_attacker;
+            creators["haunt"] = &WarlockAiObjectContextInternal::haunt;
+            creators["demonic empowerment"] = &WarlockAiObjectContextInternal::demonic_empowerment;
+            creators["metamorphosis"] = &WarlockAiObjectContextInternal::metamorphosis;
+            creators["soul fire"] = &WarlockAiObjectContextInternal::soul_fire;
+            creators["incinerate"] = &WarlockAiObjectContextInternal::incinerate;
        }

    private:
@@ -153,6 +194,7 @@ class WarlockAiObjectContextInternal : public NamedObjectContext<Action>
        static Action* spellstone(PlayerbotAI* botAI) { return new UseSpellItemAction(botAI, "spellstone", true); }
        static Action* summon_voidwalker(PlayerbotAI* botAI) { return new CastSummonVoidwalkerAction(botAI); }
        static Action* summon_felguard(PlayerbotAI* botAI) { return new CastSummonFelguardAction(botAI); }
+        static Action* summon_felhunter(PlayerbotAI* botAI) { return new CastSummonFelhunterAction(botAI); }
        static Action* corruption(PlayerbotAI* botAI) { return new CastCorruptionAction(botAI); }
        static Action* corruption_on_attacker(PlayerbotAI* botAI) { return new CastCorruptionOnAttackerAction(botAI); }
        static Action* siphon_life(PlayerbotAI* botAI) { return new CastSiphonLifeAction(botAI); }
@@ -169,12 +211,20 @@ class WarlockAiObjectContextInternal : public NamedObjectContext<Action>
        static Action* rain_of_fire(PlayerbotAI* botAI) { return new CastRainOfFireAction(botAI); }
        static Action* shadowfury(PlayerbotAI* botAI) { return new CastShadowfuryAction(botAI); }
        static Action* life_tap(PlayerbotAI* botAI) { return new CastLifeTapAction(botAI); }
+        static Action* unstable_affliction(PlayerbotAI* ai) { return new CastUnstableAfflictionAction(ai); }
+        static Action* unstable_affliction_on_attacker(PlayerbotAI* ai) { return new CastUnstableAfflictionOnAttackerAction(ai); }
+        static Action* haunt(PlayerbotAI* ai) { return new CastHauntAction(ai); }
+        static Action* demonic_empowerment(PlayerbotAI* ai) { return new CastDemonicEmpowermentAction(ai); }
+        static Action* metamorphosis(PlayerbotAI* ai) { return new CastMetamorphosisAction(ai); }
+        static Action* soul_fire(PlayerbotAI* ai) { return new CastSoulFireAction(ai); }
+        static Action* incinerate(PlayerbotAI* ai) { return new CastIncinerateAction(ai); }
 };

 WarlockAiObjectContext::WarlockAiObjectContext(PlayerbotAI* botAI) : AiObjectContext(botAI)
 {
    strategyContexts.Add(new WarlockStrategyFactoryInternal());
    strategyContexts.Add(new WarlockCombatStrategyFactoryInternal());
+    strategyContexts.Add(new NonCombatBuffStrategyFactoryInternal());
    actionContexts.Add(new WarlockAiObjectContextInternal());
    triggerContexts.Add(new WarlockTriggerFactoryInternal());
 }
--- a/src/strategy/warlock/WarlockTriggers.cpp
+++ b/src/strategy/warlock/WarlockTriggers.cpp
@@ -20,3 +20,25 @@ bool WarlockConjuredItemTrigger::IsActive()
 {
    return ItemCountTrigger::IsActive() && AI_VALUE2(uint32, "item count", "soul shard") > 0;
 }
+
+bool ImmolateOnAttackerTrigger::IsActive()
+{
+    return DebuffOnAttackerTrigger::IsActive() && 
+        // !botAI->HasAura("immolate", GetTarget(), false, true) && 
+        !botAI->HasAura("unstable affliction", GetTarget(), false, true);
+}
+
+bool UnstableAfflictionTrigger::IsActive()
+{
+    return DebuffTrigger::IsActive() && 
+        !botAI->HasAura("immolate", GetTarget(), false, true);
+        // !botAI->HasAura("unstable affliction", GetTarget(), false, true);
+}
+
+bool UnstableAfflictionOnAttackerTrigger::IsActive()
+{
+    return DebuffOnAttackerTrigger::IsActive() && 
+        !botAI->HasAura("immolate", GetTarget(), false, true);
+        // !botAI->HasAura("unstable affliction", GetTarget(), false, true);
+}
+
--- a/src/strategy/warlock/WarlockTriggers.h
+++ b/src/strategy/warlock/WarlockTriggers.h
@@ -32,7 +32,7 @@ DEBUFF_CHECKISOWNER_TRIGGER(SiphonLifeTrigger, "siphon life");
 class CorruptionOnAttackerTrigger : public DebuffOnAttackerTrigger
 {
    public:
-        CorruptionOnAttackerTrigger(PlayerbotAI* botAI) : DebuffOnAttackerTrigger(botAI, "corruption") { }
+        CorruptionOnAttackerTrigger(PlayerbotAI* botAI) : DebuffOnAttackerTrigger(botAI, "corruption", true) { }
 };

 class CastCurseOfAgonyOnAttackerTrigger : public DebuffOnAttackerTrigger
@@ -49,6 +49,13 @@ class SiphonLifeOnAttackerTrigger : public DebuffOnAttackerTrigger

 DEBUFF_CHECKISOWNER_TRIGGER(ImmolateTrigger, "immolate");

+class ImmolateOnAttackerTrigger : public DebuffOnAttackerTrigger
+{
+public:
+    ImmolateOnAttackerTrigger(PlayerbotAI* ai) : DebuffOnAttackerTrigger(ai, "immolate") {}
+    virtual bool IsActive();
+};
+
 class ShadowTranceTrigger : public HasAuraTrigger
 {
    public:
@@ -105,4 +112,41 @@ class AmplifyCurseTrigger : public BuffTrigger
        AmplifyCurseTrigger(PlayerbotAI* botAI) : BuffTrigger(botAI, "amplify curse") { }
 };

+class UnstableAfflictionTrigger : public DebuffTrigger // SpellTrigger
+{
+    public:
+        UnstableAfflictionTrigger(PlayerbotAI* ai) : DebuffTrigger(ai, "unstable affliction", 1, true) {}
+        bool IsActive() override;
+};
+
+class UnstableAfflictionOnAttackerTrigger : public DebuffOnAttackerTrigger
+{
+    public:
+        UnstableAfflictionOnAttackerTrigger(PlayerbotAI* ai) : DebuffOnAttackerTrigger(ai, "unstable affliction", true) {}
+        bool IsActive() override;
+};
+
+class HauntTrigger : public DebuffTrigger
+{
+    public:
+        HauntTrigger(PlayerbotAI* ai) : DebuffTrigger(ai, "haunt", 1, true, 0) {}
+};
+
+class DecimationTrigger : public HasAuraTrigger
+{
+    public:
+        DecimationTrigger(PlayerbotAI* ai) : HasAuraTrigger(ai, "decimation") {}
+};
+
+class MoltenCoreTrigger : public HasAuraTrigger
+{
+    public:
+        MoltenCoreTrigger(PlayerbotAI* ai) : HasAuraTrigger(ai, "molten core") {}
+};
+
+class MetamorphosisTrigger : public BoostTrigger
+{
+    public:
+        MetamorphosisTrigger(PlayerbotAI* ai) : BoostTrigger(ai, "metamorphosis") {}
+};
 #endif