[HOT FIX] MS build issues regarding folder / command lenght usage or rc.exe (#2038)

src/Ai/Class/Druid/Strategy/BearTankDruidStrategy.cpp

@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#include "BearTankDruidStrategy.h"
+
+#include "Playerbots.h"
+
+class BearTankDruidStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    BearTankDruidStrategyActionNodeFactory()
+    {
+        creators["melee"] = &melee;
+        creators["feral charge - bear"] = &feral_charge_bear;
+        creators["swipe (bear)"] = &swipe_bear;
+        creators["faerie fire (feral)"] = &faerie_fire_feral;
+        creators["bear form"] = &bear_form;
+        creators["dire bear form"] = &dire_bear_form;
+        creators["mangle (bear)"] = &mangle_bear;
+        creators["maul"] = &maul;
+        creators["bash"] = &bash;
+        creators["swipe"] = &swipe;
+        creators["lacerate"] = &lacerate;
+        creators["demoralizing roar"] = &demoralizing_roar;
+        creators["taunt spell"] = &growl;
+    }
+
+private:
+    static ActionNode* melee([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "melee",
+            /*P*/ { NextAction("feral charge - bear") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* feral_charge_bear([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "feral charge - bear",
+            /*P*/ {},
+            /*A*/ { NextAction("reach melee") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* swipe_bear([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "swipe (bear)",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* faerie_fire_feral([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "faerie fire (feral)",
+            /*P*/ { NextAction("feral charge - bear") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* bear_form([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "bear form",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* dire_bear_form([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "dire bear form",
+            /*P*/ { NextAction("caster form") },
+            /*A*/ { NextAction("bear form") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* mangle_bear([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "mangle (bear)",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* maul([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "maul",
+            /*P*/ {},
+            /*A*/ { NextAction("melee") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* bash([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "bash",
+            /*P*/ {},
+            /*A*/ { NextAction("melee") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* swipe([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "swipe",
+            /*P*/ {},
+            /*A*/ { NextAction("melee") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* lacerate([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "lacerate",
+            /*P*/ {},
+            /*A*/ { NextAction("maul") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* growl([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "growl",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* demoralizing_roar([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "demoralizing roar",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+};
+
+BearTankDruidStrategy::BearTankDruidStrategy(PlayerbotAI* botAI) : FeralDruidStrategy(botAI)
+{
+    actionNodeFactories.Add(new BearTankDruidStrategyActionNodeFactory());
+}
+
+std::vector<NextAction> BearTankDruidStrategy::getDefaultActions()
+{
+    return {
+        NextAction("mangle (bear)", ACTION_DEFAULT + 0.5f),
+        NextAction("faerie fire (feral)", ACTION_DEFAULT + 0.4f),
+        NextAction("lacerate", ACTION_DEFAULT + 0.3f),
+        NextAction("maul", ACTION_DEFAULT + 0.2f),
+        NextAction("enrage", ACTION_DEFAULT + 0.1f),
+        NextAction("melee", ACTION_DEFAULT)
+    };
+}
+
+void BearTankDruidStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    FeralDruidStrategy::InitTriggers(triggers);
+
+    triggers.push_back(
+        new TriggerNode(
+            "enemy out of melee",
+            {
+                NextAction("feral charge - bear", ACTION_NORMAL + 8)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "bear form",
+            {
+                NextAction("dire bear form", ACTION_HIGH + 8)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "low health",
+            {
+                NextAction("frenzied regeneration", ACTION_HIGH + 7)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "faerie fire (feral)",
+            {
+                NextAction("faerie fire (feral)", ACTION_HIGH + 7)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "lose aggro",
+            {
+                NextAction("growl", ACTION_HIGH + 8)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "medium aoe",
+            {
+                NextAction("demoralizing roar", ACTION_HIGH + 6),
+                NextAction("swipe (bear)", ACTION_HIGH + 6)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "light aoe",
+            {
+                NextAction("swipe (bear)", ACTION_HIGH + 5)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "bash",
+            {
+                NextAction("bash", ACTION_INTERRUPT + 2)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "bash on enemy healer",
+            {
+                NextAction("bash on enemy healer", ACTION_INTERRUPT + 1)
+            }
+        )
+    );
+}

src/Ai/Class/Druid/Strategy/BearTankDruidStrategy.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_BEARTANKDRUIDSTRATEGY_H
+#define _PLAYERBOT_BEARTANKDRUIDSTRATEGY_H
+
+#include "FeralDruidStrategy.h"
+
+class PlayerbotAI;
+
+class BearTankDruidStrategy : public FeralDruidStrategy
+{
+public:
+    BearTankDruidStrategy(PlayerbotAI* botAI);
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "bear"; }
+    std::vector<NextAction> getDefaultActions() override;
+    uint32 GetType() const override { return STRATEGY_TYPE_TANK | STRATEGY_TYPE_MELEE; }
+};
+
+#endif

src/Ai/Class/Druid/Strategy/CasterDruidStrategy.cpp

@@ -0,0 +1,254 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#include "CasterDruidStrategy.h"
+
+#include "AiObjectContext.h"
+#include "FeralDruidStrategy.h"
+
+class CasterDruidStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    CasterDruidStrategyActionNodeFactory()
+    {
+        creators["faerie fire"] = &faerie_fire;
+        creators["hibernate"] = &hibernate;
+        creators["entangling roots"] = &entangling_roots;
+        creators["entangling roots on cc"] = &entangling_roots_on_cc;
+        creators["wrath"] = &wrath;
+        creators["starfall"] = &starfall;
+        creators["insect swarm"] = &insect_swarm;
+        creators["moonfire"] = &moonfire;
+        creators["starfire"] = &starfire;
+        creators["moonkin form"] = &moonkin_form;
+    }
+
+private:
+    static ActionNode* faerie_fire([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "faerie fire",
+            /*P*/ { NextAction("moonkin form") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* hibernate([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "hibernate",
+            /*P*/ { NextAction("moonkin form") },
+            /*A*/ { NextAction("entangling roots") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* entangling_roots([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "entangling roots",
+            /*P*/ { NextAction("moonkin form") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* entangling_roots_on_cc([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "entangling roots on cc",
+            /*P*/ { NextAction("moonkin form") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* wrath([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "wrath",
+            /*P*/ { NextAction("moonkin form") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* starfall([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "starfall",
+            /*P*/ { NextAction("moonkin form") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* insect_swarm([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "insect swarm",
+            /*P*/ { NextAction("moonkin form") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* moonfire([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "moonfire",
+            /*P*/ { NextAction("moonkin form") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* starfire([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "starfire",
+            /*P*/ { NextAction("moonkin form") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* moonkin_form([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "moonkin form",
+            /*P*/ { NextAction("caster form") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+};
+
+CasterDruidStrategy::CasterDruidStrategy(PlayerbotAI* botAI) : GenericDruidStrategy(botAI)
+{
+    actionNodeFactories.Add(new CasterDruidStrategyActionNodeFactory());
+    actionNodeFactories.Add(new ShapeshiftDruidStrategyActionNodeFactory());
+}
+
+std::vector<NextAction> CasterDruidStrategy::getDefaultActions()
+{
+    return {
+        NextAction("starfall", ACTION_HIGH + 1.0f),
+        NextAction("force of nature", ACTION_DEFAULT + 1.0f),
+        NextAction("wrath", ACTION_DEFAULT + 0.1f),
+    };
+}
+
+void CasterDruidStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    GenericDruidStrategy::InitTriggers(triggers);
+
+    triggers.push_back(
+        new TriggerNode(
+            "eclipse (lunar) cooldown",
+            {
+                NextAction("starfire", ACTION_DEFAULT + 0.2f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "eclipse (solar) cooldown",
+            {
+                NextAction("wrath", ACTION_DEFAULT + 0.2f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "insect swarm",
+            {
+                NextAction("insect swarm", ACTION_NORMAL + 5)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "moonfire",
+            {
+                NextAction("moonfire", ACTION_NORMAL + 4)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "eclipse (solar)",
+            {
+                NextAction("wrath", ACTION_NORMAL + 6)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "eclipse (lunar)",
+            {
+                NextAction("starfire", ACTION_NORMAL + 6)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "medium mana",
+            {
+                NextAction("innervate", ACTION_HIGH + 9)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "enemy too close for spell",
+            {
+                NextAction("flee", ACTION_MOVE + 9)
+            }
+        )
+    );
+}
+
+void CasterDruidAoeStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(
+        new TriggerNode(
+            "hurricane channel check",
+            {
+                NextAction("cancel channel", ACTION_HIGH + 2)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "medium aoe",
+            {
+                NextAction("hurricane", ACTION_HIGH + 1)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "light aoe",
+            {
+                NextAction("insect swarm on attacker", ACTION_NORMAL + 3),
+                NextAction("moonfire on attacker", ACTION_NORMAL + 3)
+            }
+        )
+    );
+}
+
+void CasterDruidDebuffStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(
+        new TriggerNode(
+            "faerie fire",
+            {
+                NextAction("faerie fire", ACTION_HIGH)
+            }
+        )
+    );
+}

src/Ai/Class/Druid/Strategy/CasterDruidStrategy.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_CASTERDRUIDSTRATEGY_H
+#define _PLAYERBOT_CASTERDRUIDSTRATEGY_H
+
+#include "GenericDruidStrategy.h"
+
+class PlayerbotAI;
+
+class CasterDruidStrategy : public GenericDruidStrategy
+{
+public:
+    CasterDruidStrategy(PlayerbotAI* botAI);
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "caster"; }
+    std::vector<NextAction> getDefaultActions() override;
+    uint32 GetType() const override { return STRATEGY_TYPE_COMBAT | STRATEGY_TYPE_DPS | STRATEGY_TYPE_RANGED; }
+};
+
+class CasterDruidAoeStrategy : public CombatStrategy
+{
+public:
+    CasterDruidAoeStrategy(PlayerbotAI* botAI) : CombatStrategy(botAI) {}
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "caster aoe"; }
+};
+
+class CasterDruidDebuffStrategy : public CombatStrategy
+{
+public:
+    CasterDruidDebuffStrategy(PlayerbotAI* botAI) : CombatStrategy(botAI) {}
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "caster debuff"; }
+};
+
+#endif

src/Ai/Class/Druid/Strategy/CatDpsDruidStrategy.cpp

@@ -0,0 +1,314 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#include "CatDpsDruidStrategy.h"
+
+#include "AiObjectContext.h"
+
+class CatDpsDruidStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    CatDpsDruidStrategyActionNodeFactory()
+    {
+        creators["faerie fire (feral)"] = &faerie_fire_feral;
+        creators["melee"] = &melee;
+        creators["feral charge - cat"] = &feral_charge_cat;
+        creators["cat form"] = &cat_form;
+        creators["claw"] = &claw;
+        creators["mangle (cat)"] = &mangle_cat;
+        creators["rake"] = &rake;
+        creators["ferocious bite"] = &ferocious_bite;
+        creators["rip"] = &rip;
+        creators["pounce"] = &pounce;
+        creators["ravage"] = &ravage;
+    }
+
+private:
+    static ActionNode* faerie_fire_feral([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "faerie fire (feral)",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* melee([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "melee",
+            /*P*/ { NextAction("feral charge - cat") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* feral_charge_cat([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "feral charge - cat",
+            /*P*/ {},
+            /*A*/ { NextAction("reach melee") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* cat_form([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "cat form",
+            /*P*/ { NextAction("caster form") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* claw([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "claw",
+            /*P*/ {},
+            /*A*/ { NextAction("melee") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* mangle_cat([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "mangle (cat)",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* rake([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "rake",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* ferocious_bite([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "ferocious bite",
+            /*P*/ {},
+            /*A*/ { NextAction("rip") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* rip([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "rip",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* pounce([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "pounce",
+            /*P*/ {},
+            /*A*/ { NextAction("ravage") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* ravage([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "ravage",
+            /*P*/ {},
+            /*A*/ { NextAction("shred") },
+            /*C*/ {}
+        );
+    }
+};
+
+CatDpsDruidStrategy::CatDpsDruidStrategy(PlayerbotAI* botAI) : FeralDruidStrategy(botAI)
+{
+    actionNodeFactories.Add(new CatDpsDruidStrategyActionNodeFactory());
+}
+
+std::vector<NextAction> CatDpsDruidStrategy::getDefaultActions()
+{
+    return {
+        NextAction("tiger's fury", ACTION_DEFAULT + 0.1f)
+    };
+}
+
+void CatDpsDruidStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    FeralDruidStrategy::InitTriggers(triggers);
+
+    // Default priority
+    triggers.push_back(
+        new TriggerNode(
+            "almost full energy available",
+            {
+                NextAction("shred", ACTION_DEFAULT + 0.4f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "combo points not full",
+            {
+                NextAction("shred", ACTION_DEFAULT + 0.4f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "almost full energy available",
+            {
+                NextAction("mangle (cat)", ACTION_DEFAULT + 0.3f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "combo points not full and high energy",
+            {
+                NextAction("mangle (cat)", ACTION_DEFAULT + 0.3f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "almost full energy available",
+            {
+                NextAction("claw", ACTION_DEFAULT + 0.2f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "combo points not full and high energy",
+            {
+                NextAction("claw", ACTION_DEFAULT + 0.2f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "faerie fire (feral)",
+            {
+                NextAction("faerie fire (feral)", ACTION_DEFAULT + 0.0f)
+            }
+        )
+    );
+
+    // Main spell
+    triggers.push_back(
+        new TriggerNode(
+            "cat form", {
+                NextAction("cat form", ACTION_HIGH + 8)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "savage roar", {
+                NextAction("savage roar", ACTION_HIGH + 7)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "combo points available",
+            {
+                NextAction("rip", ACTION_HIGH + 6)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "ferocious bite time",
+            {
+                NextAction("ferocious bite", ACTION_HIGH + 5)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "target with combo points almost dead",
+            {
+                NextAction("ferocious bite", ACTION_HIGH + 4)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "mangle (cat)",
+            {
+                NextAction("mangle (cat)", ACTION_HIGH + 3)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "rake",
+            {
+                NextAction("rake", ACTION_HIGH + 2)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "medium threat",
+            {
+                NextAction("cower", ACTION_HIGH + 1)
+            }
+        )
+    );
+
+    // AOE
+    triggers.push_back(
+        new TriggerNode(
+            "medium aoe",
+            {
+                NextAction("swipe (cat)", ACTION_HIGH + 3)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "light aoe",
+            {
+                NextAction("rake on attacker", ACTION_HIGH + 2)
+            }
+        )
+    );
+    // Reach target
+    triggers.push_back(
+        new TriggerNode(
+            "enemy out of melee",
+            {
+                NextAction("feral charge - cat", ACTION_HIGH + 9)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "enemy out of melee",
+            {
+                NextAction("dash", ACTION_HIGH + 8)
+            }
+        )
+    );
+}
+
+void CatAoeDruidStrategy::InitTriggers(std::vector<TriggerNode*>& triggers) {}

src/Ai/Class/Druid/Strategy/CatDpsDruidStrategy.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_CATDPSDRUIDSTRATEGY_H
+#define _PLAYERBOT_CATDPSDRUIDSTRATEGY_H
+
+#include "FeralDruidStrategy.h"
+
+class PlayerbotAI;
+
+class CatDpsDruidStrategy : public FeralDruidStrategy
+{
+public:
+    CatDpsDruidStrategy(PlayerbotAI* botAI);
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "cat"; }
+    std::vector<NextAction> getDefaultActions() override;
+    uint32 GetType() const override { return STRATEGY_TYPE_COMBAT | STRATEGY_TYPE_MELEE; }
+};
+
+class CatAoeDruidStrategy : public CombatStrategy
+{
+public:
+    CatAoeDruidStrategy(PlayerbotAI* botAI) : CombatStrategy(botAI) {}
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "cat aoe"; }
+};
+
+#endif

src/Ai/Class/Druid/Strategy/FeralDruidStrategy.cpp

@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#include "FeralDruidStrategy.h"
+
+#include "Playerbots.h"
+
+class FeralDruidStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    FeralDruidStrategyActionNodeFactory()
+    {
+        creators["survival instincts"] = &survival_instincts;
+        creators["thorns"] = &thorns;
+        creators["omen of clarity"] = &omen_of_clarity;
+        creators["cure poison"] = &cure_poison;
+        creators["cure poison on party"] = &cure_poison_on_party;
+        creators["abolish poison"] = &abolish_poison;
+        creators["abolish poison on party"] = &abolish_poison_on_party;
+        creators["prowl"] = &prowl;
+    }
+
+private:
+    static ActionNode* survival_instincts([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("survival instincts",
+                              /*P*/ {},
+                              /*A*/ { NextAction("barkskin") },
+                              /*C*/ {});
+    }
+
+    static ActionNode* thorns([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("thorns",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* omen_of_clarity([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("omen of clarity",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* cure_poison([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("cure poison",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* cure_poison_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("cure poison on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* abolish_poison([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("abolish poison",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* abolish_poison_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("abolish poison on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* prowl([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("prowl",
+                              /*P*/ { NextAction("cat form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+};
+
+FeralDruidStrategy::FeralDruidStrategy(PlayerbotAI* botAI) : GenericDruidStrategy(botAI)
+{
+    actionNodeFactories.Add(new FeralDruidStrategyActionNodeFactory());
+    actionNodeFactories.Add(new ShapeshiftDruidStrategyActionNodeFactory());
+}
+
+void FeralDruidStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    GenericDruidStrategy::InitTriggers(triggers);
+
+    triggers.push_back(new TriggerNode(
+        "enemy out of melee", { NextAction("reach melee", ACTION_HIGH + 1) }));
+    triggers.push_back(new TriggerNode(
+        "critical health", { NextAction("survival instincts", ACTION_EMERGENCY + 1) }));
+    triggers.push_back(new TriggerNode(
+        "omen of clarity", { NextAction("omen of clarity", ACTION_HIGH + 9) }));
+    triggers.push_back(new TriggerNode("player has flag",
+                                       { NextAction("dash", ACTION_EMERGENCY + 2) }));
+    triggers.push_back(new TriggerNode("enemy flagcarrier near",
+                                       { NextAction("dash", ACTION_EMERGENCY + 2) }));
+    triggers.push_back(
+        new TriggerNode("berserk", { NextAction("berserk", ACTION_HIGH + 6) }));
+}

src/Ai/Class/Druid/Strategy/FeralDruidStrategy.h

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_FERALRUIDSTRATEGY_H
+#define _PLAYERBOT_FERALRUIDSTRATEGY_H
+
+#include "GenericDruidStrategy.h"
+
+class PlayerbotAI;
+
+class ShapeshiftDruidStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    ShapeshiftDruidStrategyActionNodeFactory()
+    {
+        creators["rejuvenation"] = &rejuvenation;
+        creators["regrowth"] = &regrowth;
+        creators["healing touch"] = &healing_touch;
+        creators["rejuvenation on party"] = &rejuvenation_on_party;
+        creators["regrowth on party"] = &regrowth_on_party;
+        creators["healing touch on party"] = &healing_touch_on_party;
+    }
+
+private:
+    static ActionNode* regrowth([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("regrowth",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ { NextAction("healing touch") },
+                              /*C*/ { NextAction("melee", 10.0f) });
+    }
+
+    static ActionNode* rejuvenation([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("rejuvenation",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* healing_touch([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("healing touch",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* regrowth_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("regrowth on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ { NextAction("healing touch on party") },
+                              /*C*/ { NextAction("melee", 10.0f) });
+    }
+
+    static ActionNode* rejuvenation_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("rejuvenation on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* healing_touch_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("healing touch on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+};
+
+class FeralDruidStrategy : public GenericDruidStrategy
+{
+protected:
+    FeralDruidStrategy(PlayerbotAI* botAI);
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    uint32 GetType() const override { return STRATEGY_TYPE_COMBAT | STRATEGY_TYPE_MELEE; }
+};
+
+#endif

src/Ai/Class/Druid/Strategy/GenericDruidNonCombatStrategy.cpp

@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#include "GenericDruidNonCombatStrategy.h"
+
+#include "Playerbots.h"
+#include "AiFactory.h"
+
+class GenericDruidNonCombatStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    GenericDruidNonCombatStrategyActionNodeFactory()
+    {
+        creators["thorns"] = &thorns;
+        creators["thorns on party"] = &thorns_on_party;
+        creators["mark of the wild"] = &mark_of_the_wild;
+        creators["mark of the wild on party"] = &mark_of_the_wild_on_party;
+        // creators["innervate"] = &innervate;
+        creators["regrowth_on_party"] = &regrowth_on_party;
+        creators["rejuvenation on party"] = &rejuvenation_on_party;
+        creators["remove curse on party"] = &remove_curse_on_party;
+        creators["abolish poison on party"] = &abolish_poison_on_party;
+        creators["revive"] = &revive;
+    }
+
+private:
+    static ActionNode* thorns([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("thorns",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* thorns_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("thorns on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* mark_of_the_wild([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("mark of the wild",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* mark_of_the_wild_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("mark of the wild on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+    static ActionNode* regrowth_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("regrowth on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+    static ActionNode* rejuvenation_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("rejuvenation on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+    static ActionNode* remove_curse_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("remove curse on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+    static ActionNode* abolish_poison_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("abolish poison on party",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+    static ActionNode* revive([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("revive",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+};
+
+GenericDruidNonCombatStrategy::GenericDruidNonCombatStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI)
+{
+    actionNodeFactories.Add(new GenericDruidNonCombatStrategyActionNodeFactory());
+}
+
+void GenericDruidNonCombatStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    NonCombatStrategy::InitTriggers(triggers);
+
+    triggers.push_back(new TriggerNode("mark of the wild", { NextAction("mark of the wild", 14.0f) }));
+    triggers.push_back(new TriggerNode("party member cure poison", { NextAction("abolish poison on party", 20.0f) }));
+    triggers.push_back(new TriggerNode("party member dead", { NextAction("revive", ACTION_CRITICAL_HEAL + 10) }));
+
+    triggers.push_back(new TriggerNode("often", { NextAction("apply oil", 1.0f) }));
+
+    triggers.push_back(
+        new TriggerNode("party member critical health",
+                        {
+                                          NextAction("wild growth on party", ACTION_MEDIUM_HEAL + 7),
+                                          NextAction("regrowth on party", ACTION_MEDIUM_HEAL + 6),
+                                          NextAction("rejuvenation on party", ACTION_MEDIUM_HEAL + 5),
+                                          }));
+
+    triggers.push_back(
+        new TriggerNode("party member low health",
+                        {
+                                          NextAction("wild growth on party", ACTION_MEDIUM_HEAL + 5),
+                                          NextAction("regrowth on party", ACTION_MEDIUM_HEAL + 4),
+                                          NextAction("rejuvenation on party", ACTION_MEDIUM_HEAL + 3),
+                                          }));
+
+    triggers.push_back(
+        new TriggerNode("party member medium health",
+                        { NextAction("wild growth on party", ACTION_MEDIUM_HEAL + 3),
+                                          NextAction("regrowth on party", ACTION_MEDIUM_HEAL + 2),
+                                          NextAction("rejuvenation on party", ACTION_MEDIUM_HEAL + 1),
+                                          }));
+
+    triggers.push_back(
+        new TriggerNode("party member almost full health",
+                        { NextAction("wild growth on party", ACTION_LIGHT_HEAL + 3), NextAction("rejuvenation on party", ACTION_LIGHT_HEAL + 2) }));
+
+    triggers.push_back(
+        new TriggerNode("party member remove curse",
+                        { NextAction("remove curse on party", ACTION_DISPEL + 7) }));
+    triggers.push_back(
+        new TriggerNode("new pet", { NextAction("set pet stance", 60.0f) }));
+
+    triggers.push_back(new TriggerNode("party member critical health", {
+                       NextAction("wild growth on party", ACTION_MEDIUM_HEAL + 7),
+                       NextAction("regrowth on party", ACTION_MEDIUM_HEAL + 6),
+                       NextAction("rejuvenation on party", ACTION_MEDIUM_HEAL + 5),
+                       }));
+    triggers.push_back(new TriggerNode("party member low health", {
+                       NextAction("wild growth on party", ACTION_MEDIUM_HEAL + 5),
+                       NextAction("regrowth on party", ACTION_MEDIUM_HEAL + 4),
+                       NextAction("rejuvenation on party", ACTION_MEDIUM_HEAL + 3),
+                       }));
+    triggers.push_back(new TriggerNode("party member medium health", {
+                       NextAction("wild growth on party", ACTION_MEDIUM_HEAL + 3),
+                       NextAction("regrowth on party", ACTION_MEDIUM_HEAL + 2),
+                       NextAction("rejuvenation on party", ACTION_MEDIUM_HEAL + 1),
+                       }));
+    triggers.push_back(new TriggerNode("party member almost full health", {
+                       NextAction("wild growth on party", ACTION_LIGHT_HEAL + 3),
+                       NextAction("rejuvenation on party", ACTION_LIGHT_HEAL + 2),
+                       }));
+    triggers.push_back(new TriggerNode("party member remove curse", {
+                       NextAction("remove curse on party", ACTION_DISPEL + 7),
+                       }));
+
+    int specTab = AiFactory::GetPlayerSpecTab(botAI->GetBot());
+    if (specTab == 0 || specTab == 2) // Balance or Restoration
+        triggers.push_back(new TriggerNode("often", { NextAction("apply oil", 1.0f) }));
+    if (specTab == 1) // Feral
+        triggers.push_back(new TriggerNode("often", { NextAction("apply stone", 1.0f) }));
+
+}
+
+GenericDruidBuffStrategy::GenericDruidBuffStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI)
+{
+    actionNodeFactories.Add(new GenericDruidNonCombatStrategyActionNodeFactory());
+}
+
+void GenericDruidBuffStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    NonCombatStrategy::InitTriggers(triggers);
+
+    triggers.push_back(new TriggerNode("mark of the wild on party", {
+                       NextAction("mark of the wild on party", 13.0f),
+                       }));
+    triggers.push_back(new TriggerNode("thorns on main tank", {
+                       NextAction("thorns on main tank", 11.0f),
+                       }));
+    triggers.push_back(new TriggerNode("thorns", {
+                       NextAction("thorns", 10.0f),
+                       }));
+}

src/Ai/Class/Druid/Strategy/GenericDruidNonCombatStrategy.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_GENERICDRUIDNONCOMBATSTRATEGY_H
+#define _PLAYERBOT_GENERICDRUIDNONCOMBATSTRATEGY_H
+
+#include "NonCombatStrategy.h"
+
+class PlayerbotAI;
+
+class GenericDruidNonCombatStrategy : public NonCombatStrategy
+{
+public:
+    GenericDruidNonCombatStrategy(PlayerbotAI* botAI);
+
+    std::string const getName() override { return "nc"; }
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+class GenericDruidBuffStrategy : public NonCombatStrategy
+{
+public:
+    GenericDruidBuffStrategy(PlayerbotAI* botAI);
+
+    std::string const getName() override { return "buff"; }
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+#endif

src/Ai/Class/Druid/Strategy/GenericDruidStrategy.cpp

@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#include "GenericDruidStrategy.h"
+
+#include "Playerbots.h"
+
+class GenericDruidStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    GenericDruidStrategyActionNodeFactory()
+    {
+        creators["melee"] = &melee;
+        creators["caster form"] = &caster_form;
+        creators["cure poison"] = &cure_poison;
+        creators["cure poison on party"] = &cure_poison_on_party;
+        creators["abolish poison"] = &abolish_poison;
+        creators["abolish poison on party"] = &abolish_poison_on_party;
+        creators["rebirth"] = &rebirth;
+        creators["entangling roots on cc"] = &entangling_roots_on_cc;
+        creators["innervate"] = &innervate;
+    }
+
+private:
+    static ActionNode* melee([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("melee",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* caster_form([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("caster form",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* cure_poison([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("cure poison",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* cure_poison_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("cure poison on party",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* abolish_poison([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("abolish poison",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* abolish_poison_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("abolish poison on party",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* rebirth([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("rebirth",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* entangling_roots_on_cc([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("entangling roots on cc",
+                              /*P*/ { NextAction("caster form") },
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* innervate([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("innervate",
+                              /*P*/ {},
+                              /*A*/ { NextAction("mana potion") },
+                              /*C*/ {});
+    }
+};
+
+GenericDruidStrategy::GenericDruidStrategy(PlayerbotAI* botAI) : CombatStrategy(botAI)
+{
+    actionNodeFactories.Add(new GenericDruidStrategyActionNodeFactory());
+}
+
+void GenericDruidStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    CombatStrategy::InitTriggers(triggers);
+
+    triggers.push_back(
+        new TriggerNode("low health", { NextAction("barkskin", ACTION_HIGH + 7) }));
+
+    triggers.push_back(new TriggerNode("combat party member dead",
+                                       { NextAction("rebirth", ACTION_HIGH + 9) }));
+    triggers.push_back(new TriggerNode("being attacked",
+                                       { NextAction("nature's grasp", ACTION_HIGH + 1) }));
+    triggers.push_back(new TriggerNode("new pet", { NextAction("set pet stance", 60.0f) }));
+}
+
+void DruidCureStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(
+        new TriggerNode("party member cure poison",
+                        { NextAction("abolish poison on party", ACTION_DISPEL + 1) }));
+
+    triggers.push_back(
+        new TriggerNode("party member remove curse",
+                        { NextAction("remove curse on party", ACTION_DISPEL + 7) }));
+
+}
+
+void DruidBoostStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(new TriggerNode(
+        "nature's swiftness", { NextAction("nature's swiftness", ACTION_HIGH + 9) }));
+}
+
+void DruidCcStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(new TriggerNode(
+        "entangling roots", { NextAction("entangling roots on cc", ACTION_HIGH + 2) }));
+    triggers.push_back(new TriggerNode(
+        "entangling roots kite", { NextAction("entangling roots", ACTION_HIGH + 2) }));
+    triggers.push_back(new TriggerNode(
+        "hibernate", { NextAction("hibernate on cc", ACTION_HIGH + 3) }));
+}
+
+void DruidHealerDpsStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(
+        new TriggerNode("healer should attack",
+                        {
+                            NextAction("cancel tree form", ACTION_DEFAULT + 0.3f),
+                            NextAction("moonfire", ACTION_DEFAULT + 0.2f),
+                            NextAction("wrath", ACTION_DEFAULT + 0.1f),
+                            NextAction("starfire", ACTION_DEFAULT),
+}));
+
+}

src/Ai/Class/Druid/Strategy/GenericDruidStrategy.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_GENERICDRUIDSTRATEGY_H
+#define _PLAYERBOT_GENERICDRUIDSTRATEGY_H
+
+#include "CombatStrategy.h"
+
+class PlayerbotAI;
+
+class GenericDruidStrategy : public CombatStrategy
+{
+protected:
+    GenericDruidStrategy(PlayerbotAI* botAI);
+
+public:
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+class DruidCureStrategy : public Strategy
+{
+public:
+    DruidCureStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "cure"; }
+};
+
+class DruidBoostStrategy : public Strategy
+{
+public:
+    DruidBoostStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "boost"; }
+};
+
+class DruidCcStrategy : public Strategy
+{
+public:
+    DruidCcStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "cc"; }
+};
+
+class DruidHealerDpsStrategy : public Strategy
+{
+public:
+    DruidHealerDpsStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "healer dps"; }
+};
+
+#endif

src/Ai/Class/Druid/Strategy/HealDruidStrategy.cpp

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#include "HealDruidStrategy.h"
+
+#include "Playerbots.h"
+
+class HealDruidStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    HealDruidStrategyActionNodeFactory() {
+        creators["nourish on party"] = &nourtish_on_party;
+    }
+
+private:
+    static ActionNode* nourtish_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("nourish on party",
+                              /*P*/ {},
+                              /*A*/ { NextAction("healing touch on party") },
+                              /*C*/ {});
+    }
+};
+
+HealDruidStrategy::HealDruidStrategy(PlayerbotAI* botAI) : GenericDruidStrategy(botAI)
+{
+    actionNodeFactories.Add(new HealDruidStrategyActionNodeFactory());
+}
+
+void HealDruidStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    GenericDruidStrategy::InitTriggers(triggers);
+
+    triggers.push_back(new TriggerNode(
+        "party member to heal out of spell range",
+        { NextAction("reach party member to heal", ACTION_CRITICAL_HEAL + 9) }));
+
+    // CRITICAL
+    triggers.push_back(
+        new TriggerNode("party member critical health",
+                        {
+                                          NextAction("tree form", ACTION_CRITICAL_HEAL + 4.1f),
+                                          NextAction("swiftmend on party", ACTION_CRITICAL_HEAL + 4),
+                                          NextAction("regrowth on party", ACTION_CRITICAL_HEAL + 3),
+                                          NextAction("wild growth on party", ACTION_CRITICAL_HEAL + 2),
+                                          NextAction("nourish on party", ACTION_CRITICAL_HEAL + 1),
+                                          }));
+
+    triggers.push_back(
+        new TriggerNode("party member critical health",
+                        { NextAction("nature's swiftness", ACTION_CRITICAL_HEAL + 4) }));
+
+    triggers.push_back(new TriggerNode(
+        "group heal setting",
+        {
+                          NextAction("tree form", ACTION_MEDIUM_HEAL + 2.3f),
+                          NextAction("wild growth on party", ACTION_MEDIUM_HEAL + 2.2f),
+                          NextAction("rejuvenation on not full", ACTION_MEDIUM_HEAL + 2.1f),
+                          }));
+
+    triggers.push_back(
+        new TriggerNode("medium group heal setting",
+                        {
+                        NextAction("tree form", ACTION_CRITICAL_HEAL + 0.6f),
+                        NextAction("tranquility", ACTION_CRITICAL_HEAL + 0.5f) }));
+
+    // LOW
+    triggers.push_back(
+        new TriggerNode("party member low health",
+                        { NextAction("tree form", ACTION_MEDIUM_HEAL + 1.5f),
+                                          NextAction("wild growth on party", ACTION_MEDIUM_HEAL + 1.4f),
+                                          NextAction("regrowth on party", ACTION_MEDIUM_HEAL + 1.3f),
+                                          NextAction("swiftmend on party", ACTION_MEDIUM_HEAL + 1.2),
+                                          NextAction("nourish on party", ACTION_MEDIUM_HEAL + 1.1f),
+                                          }));
+
+    // MEDIUM
+    triggers.push_back(
+        new TriggerNode("party member medium health",
+                        {
+                                          NextAction("tree form", ACTION_MEDIUM_HEAL + 0.5f),
+                                          NextAction("wild growth on party", ACTION_MEDIUM_HEAL + 0.4f),
+                                          NextAction("rejuvenation on party", ACTION_MEDIUM_HEAL + 0.3f),
+                                          NextAction("regrowth on party", ACTION_MEDIUM_HEAL + 0.2f),
+                                          NextAction("nourish on party", ACTION_MEDIUM_HEAL + 0.1f) }));
+
+    // almost full
+    triggers.push_back(
+        new TriggerNode("party member almost full health",
+                        { NextAction("wild growth on party", ACTION_LIGHT_HEAL + 0.3f),
+                                          NextAction("rejuvenation on party", ACTION_LIGHT_HEAL + 0.2f),
+                                          NextAction("regrowth on party", ACTION_LIGHT_HEAL + 0.1f) }));
+
+    triggers.push_back(
+        new TriggerNode("medium mana", { NextAction("innervate", ACTION_HIGH + 5) }));
+
+    triggers.push_back(new TriggerNode("enemy too close for spell",
+                                       { NextAction("flee", ACTION_MOVE + 9) }));
+}

src/Ai/Class/Druid/Strategy/HealDruidStrategy.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_HEALDRUIDSTRATEGY_H
+#define _PLAYERBOT_HEALDRUIDSTRATEGY_H
+
+#include "GenericDruidStrategy.h"
+#include "Strategy.h"
+
+class PlayerbotAI;
+
+class HealDruidStrategy : public GenericDruidStrategy
+{
+public:
+    HealDruidStrategy(PlayerbotAI* botAI);
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "heal"; }
+    uint32 GetType() const override { return STRATEGY_TYPE_RANGED | STRATEGY_TYPE_HEAL; }
+};
+
+#endif

src/Ai/Class/Druid/Strategy/MeleeDruidStrategy.cpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#include "MeleeDruidStrategy.h"
+
+#include "Playerbots.h"
+
+MeleeDruidStrategy::MeleeDruidStrategy(PlayerbotAI* botAI) : CombatStrategy(botAI) {}
+
+std::vector<NextAction> MeleeDruidStrategy::getDefaultActions()
+{
+    return {
+        NextAction("faerie fire", ACTION_DEFAULT + 0.1f),
+        NextAction("melee", ACTION_DEFAULT)
+    };
+}
+
+void MeleeDruidStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(
+        new TriggerNode(
+            "omen of clarity",
+            {
+                NextAction("omen of clarity", ACTION_HIGH + 9)
+            }
+        )
+    );
+
+    CombatStrategy::InitTriggers(triggers);
+}

src/Ai/Class/Druid/Strategy/MeleeDruidStrategy.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+#ifndef _PLAYERBOT_MELEEDRUIDSTRATEGY_H
+#define _PLAYERBOT_MELEEDRUIDSTRATEGY_H
+
+#include "CombatStrategy.h"
+
+class MeleeDruidStrategy : public CombatStrategy
+{
+public:
+    MeleeDruidStrategy(PlayerbotAI* botAI);
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "melee"; }
+    std::vector<NextAction> getDefaultActions() override;
+};
+
+#endif

src/Ai/Class/Druid/Strategy/OffhealDruidCatStrategy.cpp

@@ -0,0 +1,307 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+ #include "OffhealDruidCatStrategy.h"
+
+ #include "Playerbots.h"
+ #include "Strategy.h"
+
+ class OffhealDruidCatStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    OffhealDruidCatStrategyActionNodeFactory()
+    {
+        creators["cat form"] = &cat_form;
+        creators["mangle (cat)"] = &mangle_cat;
+        creators["shred"] = &shred;
+        creators["rake"] = &rake;
+        creators["rip"] = &rip;
+        creators["ferocious bite"] = &ferocious_bite;
+        creators["savage roar"] = &savage_roar;
+        creators["faerie fire (feral)"] = &faerie_fire_feral;
+        creators["healing touch on party"] = &healing_touch_on_party;
+        creators["regrowth on party"] = &regrowth_on_party;
+        creators["rejuvenation on party"] = &rejuvenation_on_party;
+    }
+
+private:
+    static ActionNode* cat_form([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "cat form",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* mangle_cat([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "mangle (cat)",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* shred([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "shred",
+            /*P*/ {},
+            /*A*/ { NextAction("claw") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* rake([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "rake",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* rip([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "rip",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* ferocious_bite([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "ferocious bite",
+            /*P*/ {},
+            /*A*/ { NextAction("rip") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* savage_roar([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "savage roar",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* faerie_fire_feral([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "faerie fire (feral)",
+            /*P*/ {},
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* healing_touch_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "healing touch on party",
+            /*P*/ { NextAction("caster form") },
+            /*A*/ {},
+            /*C*/ { NextAction("cat form") }
+        );
+    }
+
+    static ActionNode* regrowth_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "regrowth on party",
+            /*P*/ { NextAction("caster form") },
+            /*A*/ {},
+            /*C*/ { NextAction("cat form") }
+        );
+    }
+
+    static ActionNode* rejuvenation_on_party([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "rejuvenation on party",
+            /*P*/ { NextAction("caster form") },
+            /*A*/ {},
+            /*C*/ { NextAction("cat form") }
+        );
+    }
+};
+
+OffhealDruidCatStrategy::OffhealDruidCatStrategy(PlayerbotAI* botAI) : FeralDruidStrategy(botAI)
+{
+    actionNodeFactories.Add(new OffhealDruidCatStrategyActionNodeFactory());
+}
+
+std::vector<NextAction> OffhealDruidCatStrategy::getDefaultActions()
+{
+    return {
+        NextAction("mangle (cat)", ACTION_DEFAULT + 0.5f),
+        NextAction("shred", ACTION_DEFAULT + 0.4f),
+        NextAction("rake", ACTION_DEFAULT + 0.3f),
+        NextAction("melee", ACTION_DEFAULT),
+        NextAction("cat form", ACTION_DEFAULT - 0.1f)
+    };
+}
+
+void OffhealDruidCatStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    FeralDruidStrategy::InitTriggers(triggers);
+
+    triggers.push_back(
+        new TriggerNode(
+            "cat form",
+            {
+                NextAction("cat form", ACTION_HIGH + 8)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "savage roar",
+            {
+                NextAction("savage roar", ACTION_HIGH + 7)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "combo points available",
+            {
+                NextAction("rip", ACTION_HIGH + 6)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "ferocious bite time",
+            {
+                NextAction("ferocious bite", ACTION_HIGH + 5)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "target with combo points almost dead",
+            {
+                NextAction("ferocious bite", ACTION_HIGH + 4)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "mangle (cat)",
+            {
+                NextAction("mangle (cat)", ACTION_HIGH + 3)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "rake",
+            {
+                NextAction("rake", ACTION_HIGH + 2)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "almost full energy available",
+            {
+                NextAction("shred", ACTION_DEFAULT + 0.4f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "combo points not full",
+            {
+                NextAction("shred", ACTION_DEFAULT + 0.4f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "faerie fire (feral)",
+            {
+                NextAction("faerie fire (feral)", ACTION_NORMAL)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "enemy out of melee",
+            {
+                NextAction("feral charge - cat", ACTION_HIGH + 9),
+                NextAction("dash", ACTION_HIGH + 8)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "medium aoe",
+            {
+                NextAction("swipe (cat)", ACTION_HIGH + 3)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "low energy",
+            {
+                NextAction("tiger's fury", ACTION_NORMAL + 1)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "party member critical health",
+            {
+                NextAction("regrowth on party", ACTION_CRITICAL_HEAL + 6),
+                NextAction("healing touch on party", ACTION_CRITICAL_HEAL + 5)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "party member low health",
+            {
+                NextAction("healing touch on party", ACTION_MEDIUM_HEAL + 5)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "party member medium health",
+            {
+                NextAction("rejuvenation on party", ACTION_LIGHT_HEAL + 8)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "party member to heal out of spell range",
+            {
+                NextAction("reach party member to heal", ACTION_EMERGENCY + 3)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "low mana",
+            {
+                NextAction("innervate", ACTION_HIGH + 4)
+            }
+        )
+    );
+}

src/Ai/Class/Druid/Strategy/OffhealDruidCatStrategy.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license, you may redistribute it
+ * and/or modify it under version 3 of the License, or (at your option), any later version.
+ */
+
+ #ifndef _PLAYERBOT_OFFHEALDRUIDCATSTRATEGY_H
+ #define _PLAYERBOT_OFFHEALDRUIDCATSTRATEGY_H
+
+ #include "FeralDruidStrategy.h"
+
+ class PlayerbotAI;
+
+ class OffhealDruidCatStrategy : public FeralDruidStrategy
+ {
+ public:
+    OffhealDruidCatStrategy(PlayerbotAI* botAI);
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "offheal"; }
+    std::vector<NextAction> getDefaultActions() override;
+    uint32 GetType() const override
+    {
+        return STRATEGY_TYPE_COMBAT | STRATEGY_TYPE_DPS | STRATEGY_TYPE_HEAL | STRATEGY_TYPE_MELEE;
+    }
+ };
+
+ #endif