diff --git a/src/AiFactory.cpp b/src/AiFactory.cpp
index 9589a8f2..adf53668 100644
--- a/src/AiFactory.cpp
+++ b/src/AiFactory.cpp
@@ -594,6 +594,18 @@ void AiFactory::AddDefaultNonCombatStrategies(Player* player, PlayerbotAI* const
                 nonCombatEngine->addStrategy("dps assist", false);
             break;
         case CLASS_WARLOCK:
+            if (tab == WARLOCK_TAB_AFFLICATION)
+            {
+                nonCombatEngine->addStrategiesNoInit("felhunter", nullptr);
+            }
+            else if (tab == WARLOCK_TAB_DEMONOLOGY)
+            {
+                nonCombatEngine->addStrategiesNoInit("felguard", nullptr);
+            }
+            else if (tab == WARLOCK_TAB_DESTRUCTION)
+            {
+                nonCombatEngine->addStrategiesNoInit("imp", nullptr);
+            }
             nonCombatEngine->addStrategiesNoInit("dps assist", nullptr);
             break;
         case CLASS_DEATH_KNIGHT:
diff --git a/src/strategy/warlock/GenericWarlockNonCombatStrategy.cpp b/src/strategy/warlock/GenericWarlockNonCombatStrategy.cpp
index d5baa276..f99c06c5 100644
--- a/src/strategy/warlock/GenericWarlockNonCombatStrategy.cpp
+++ b/src/strategy/warlock/GenericWarlockNonCombatStrategy.cpp
@@ -101,19 +101,61 @@ void GenericWarlockNonCombatStrategy::InitTriggers(std::vector<TriggerNode*>& tr
         triggers.push_back(new TriggerNode("spellstone", NextAction::array(0, new NextAction("spellstone", 24.0f), nullptr)));
     }
 
-    // Pet-summoning triggers based on spec
-    if (tab == 0)  // Affliction
-    {
-        triggers.push_back(new TriggerNode("no pet", NextAction::array(0, new NextAction("summon felhunter", 29.0f), nullptr)));
-    }
-    else if (tab == 1)  // Demonology
-    {
-        triggers.push_back(new TriggerNode("no pet", NextAction::array(0, new NextAction("summon felguard", 29.0f), nullptr)));
-    }
-    else if (tab == 2)  // Destruction
-    {
-        triggers.push_back(new TriggerNode("no pet", NextAction::array(0, new NextAction("summon imp", 29.0f), nullptr)));
-    }
+}
+
+// Non-combat strategy for summoning a Imp
+// Enabled by default for the Destruction spec
+// To enable, type "nc +imp"
+// To disable, type "nc -imp"
+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", 29.0f), NULL)));
+}
+
+// Non-combat strategy for summoning a Voidwalker
+// Disabled by default
+// To enable, type "nc +voidwalker"
+// To disable, type "nc -voidwalker"
+SummonVoidwalkerStrategy::SummonVoidwalkerStrategy(PlayerbotAI* ai) : NonCombatStrategy(ai) {}
+
+void SummonVoidwalkerStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(new TriggerNode("no pet", NextAction::array(0, new NextAction("summon voidwalker", 29.0f), NULL)));
+}
+
+// Non-combat strategy for summoning a Succubus
+// Disabled by default
+// To enable, type "nc +succubus"
+// To disable, type "nc -succubus"
+SummonSuccubusStrategy::SummonSuccubusStrategy(PlayerbotAI* ai) : NonCombatStrategy(ai) {}
+
+void SummonSuccubusStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(new TriggerNode("no pet", NextAction::array(0, new NextAction("summon succubus", 29.0f), NULL)));
+}
+
+// Non-combat strategy for summoning a Felhunter
+// Enabled by default for the Affliction spec
+// To enable, type "nc +felhunter"
+// To disable, type "nc -felhunter"
+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", 29.0f), NULL)));
+}
+
+// Non-combat strategy for summoning a Felguard
+// Enabled by default for the Demonology spec
+// To enable, type "nc +felguard"
+// To disable, type "nc -felguard"
+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", 29.0f), NULL)));
 }
 
 // Non-combat strategy for selecting themselves to receive soulstone
diff --git a/src/strategy/warlock/GenericWarlockNonCombatStrategy.h b/src/strategy/warlock/GenericWarlockNonCombatStrategy.h
index 19277dfd..ef226c50 100644
--- a/src/strategy/warlock/GenericWarlockNonCombatStrategy.h
+++ b/src/strategy/warlock/GenericWarlockNonCombatStrategy.h
@@ -19,6 +19,56 @@ public:
     void InitTriggers(std::vector<TriggerNode*>& triggers) override;
 };
 
+class SummonImpStrategy : public NonCombatStrategy
+{
+public:
+    SummonImpStrategy(PlayerbotAI* ai);
+    virtual std::string const getName() override { return "imp"; }
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+class SummonVoidwalkerStrategy : public NonCombatStrategy
+{
+public:
+    SummonVoidwalkerStrategy(PlayerbotAI* ai);
+    virtual std::string const getName() override { return "voidwalker"; }
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+class SummonSuccubusStrategy : public NonCombatStrategy
+{
+public:
+    SummonSuccubusStrategy(PlayerbotAI* ai);
+    virtual std::string const getName() override { return "succubus"; }
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+class SummonFelhunterStrategy : public NonCombatStrategy
+{
+public:
+    SummonFelhunterStrategy(PlayerbotAI* ai);
+    virtual std::string const getName() override { return "felhunter"; }
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+class SummonFelguardStrategy : public NonCombatStrategy
+{
+public:
+    SummonFelguardStrategy(PlayerbotAI* ai);
+    virtual std::string const getName() override { return "felguard"; }
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
 class SoulstoneSelfStrategy : public NonCombatStrategy
 {
 public:
diff --git a/src/strategy/warlock/WarlockAiObjectContext.cpp b/src/strategy/warlock/WarlockAiObjectContext.cpp
index e8463fe8..cd56398a 100644
--- a/src/strategy/warlock/WarlockAiObjectContext.cpp
+++ b/src/strategy/warlock/WarlockAiObjectContext.cpp
@@ -33,6 +33,11 @@ public:
         creators["destro aoe"] = &WarlockStrategyFactoryInternal::destruction_aoe;
         creators["meta melee"] = &WarlockStrategyFactoryInternal::meta_melee_aoe;
         creators["curse of elements"] = &WarlockStrategyFactoryInternal::curse_of_elements;
+        creators["imp"] = &WarlockStrategyFactoryInternal::imp;
+        creators["voidwalker"] = &WarlockStrategyFactoryInternal::voidwalker;
+        creators["succubus"] = &WarlockStrategyFactoryInternal::succubus;
+        creators["felhunter"] = &WarlockStrategyFactoryInternal::felhunter;
+        creators["felguard"] = &WarlockStrategyFactoryInternal::felguard;
     }
 
 private:
@@ -46,6 +51,11 @@ private:
     static Strategy* destruction_aoe(PlayerbotAI* botAI) { return new DestructionWarlockAoeStrategy(botAI); }
     static Strategy* meta_melee_aoe(PlayerbotAI* botAI) { return new MetaMeleeAoeStrategy(botAI); }
     static Strategy* curse_of_elements(PlayerbotAI* botAI) { return new WarlockCurseOfTheElementsStrategy(botAI); }
+    static Strategy* imp(PlayerbotAI* ai) { return new SummonImpStrategy(ai); }
+    static Strategy* voidwalker(PlayerbotAI* ai) { return new SummonVoidwalkerStrategy(ai); }
+    static Strategy* succubus(PlayerbotAI* ai) { return new SummonSuccubusStrategy(ai); }
+    static Strategy* felhunter(PlayerbotAI* ai) { return new SummonFelhunterStrategy(ai); }
+    static Strategy* felguard(PlayerbotAI* ai) { return new SummonFelguardStrategy(ai); }
 };
 
 class WarlockCombatStrategyFactoryInternal : public NamedObjectContext<Strategy>