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

src/Ai/Class/Dk/Strategy/BloodDKStrategy.cpp

@@ -0,0 +1,165 @@
+/*
+ * 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 "BloodDKStrategy.h"
+
+#include "Playerbots.h"
+
+class BloodDKStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    BloodDKStrategyActionNodeFactory()
+    {
+        creators["rune strike"] = &rune_strike;
+        creators["heart strike"] = &heart_strike;
+        creators["death strike"] = &death_strike;
+        creators["icy touch"] = &icy_touch;
+        creators["dark command"] = &dark_command;
+        creators["taunt spell"] = &dark_command;
+    }
+
+private:
+    static ActionNode* rune_strike([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "rune strike",
+            {
+                NextAction("frost presence")
+            },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+    static ActionNode* icy_touch([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "icy touch",
+            {
+                NextAction("frost presence")
+            },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+    static ActionNode* heart_strike([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "heart strike",
+            {
+                NextAction("frost presence")
+            },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* death_strike([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "death strike",
+            {
+                NextAction("frost presence")
+            },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+    static ActionNode* dark_command([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "dark command",
+            {
+                NextAction("frost presence")
+            },
+            /*A*/ {
+                NextAction("death grip")
+            },
+            /*C*/ {}
+        );
+    }
+};
+
+BloodDKStrategy::BloodDKStrategy(PlayerbotAI* botAI) : GenericDKStrategy(botAI)
+{
+    actionNodeFactories.Add(new BloodDKStrategyActionNodeFactory());
+}
+
+std::vector<NextAction> BloodDKStrategy::getDefaultActions()
+{
+    return {
+        NextAction("rune strike", ACTION_DEFAULT + 0.8f),
+        NextAction("icy touch", ACTION_DEFAULT + 0.7f),
+        NextAction("heart strike", ACTION_DEFAULT + 0.6f),
+        NextAction("blood strike", ACTION_DEFAULT + 0.5f),
+        NextAction("dancing rune weapon", ACTION_DEFAULT + 0.4f),
+        NextAction("death coil", ACTION_DEFAULT + 0.3f),
+        NextAction("plague strike", ACTION_DEFAULT + 0.2f),
+        NextAction("horn of winter", ACTION_DEFAULT + 0.1f),
+        NextAction("melee", ACTION_DEFAULT)
+    };
+}
+
+void BloodDKStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    GenericDKStrategy::InitTriggers(triggers);
+
+    triggers.push_back(
+        new TriggerNode(
+            "rune strike",
+            {
+                NextAction("rune strike", ACTION_NORMAL + 3)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "blood tap",
+            {
+                NextAction("blood tap", ACTION_HIGH + 5)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "lose aggro",
+            {
+                NextAction("dark command", ACTION_HIGH + 3)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "low health",
+            {
+                NextAction("army of the dead", ACTION_HIGH + 4),
+                NextAction("death strike", ACTION_HIGH + 3)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "critical health",
+            {
+                NextAction("vampiric blood", ACTION_HIGH + 5)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "icy touch",
+            {
+                NextAction("icy touch", ACTION_HIGH + 2)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "plague strike",
+            {
+                NextAction("plague strike", ACTION_HIGH + 2)
+            }
+        )
+    );
+}

src/Ai/Class/Dk/Strategy/BloodDKStrategy.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_BLOODDKSTRATEGY_H
+#define _PLAYERBOT_BLOODDKSTRATEGY_H
+
+#include "GenericDKStrategy.h"
+
+class PlayerbotAI;
+
+class BloodDKStrategy : public GenericDKStrategy
+{
+public:
+    BloodDKStrategy(PlayerbotAI* botAI);
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "blood"; }
+    std::vector<NextAction> getDefaultActions() override;
+    uint32 GetType() const override { return STRATEGY_TYPE_TANK | STRATEGY_TYPE_MELEE; }
+};
+
+#endif

src/Ai/Class/Dk/Strategy/FrostDKStrategy.cpp

@@ -0,0 +1,169 @@
+/*
+ * 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 "FrostDKStrategy.h"
+
+#include "Playerbots.h"
+
+class FrostDKStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    FrostDKStrategyActionNodeFactory()
+    {
+        creators["icy touch"] = &icy_touch;
+        creators["obliterate"] = &obliterate;
+        creators["howling blast"] = &howling_blast;
+        creators["frost strike"] = &frost_strike;
+        creators["rune strike"] = &rune_strike;
+        creators["unbreakable armor"] = &unbreakable_armor;
+    }
+
+private:
+    static ActionNode* icy_touch([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "icy touch",
+            /*P*/ { NextAction("blood presence") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* obliterate([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "obliterate",
+            /*P*/ { NextAction("blood presence") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* rune_strike([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "rune strike",
+            /*P*/ { NextAction("blood presence") },
+            /*A*/ { NextAction("melee") },
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* frost_strike([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "frost strike",
+            /*P*/ { NextAction("blood presence") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* howling_blast([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "howling blast",
+            /*P*/ { NextAction("blood presence") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+    static ActionNode* unbreakable_armor([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "unbreakable armor",
+            /*P*/ { NextAction("blood tap") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+};
+
+FrostDKStrategy::FrostDKStrategy(PlayerbotAI* botAI) : GenericDKStrategy(botAI)
+{
+    actionNodeFactories.Add(new FrostDKStrategyActionNodeFactory());
+}
+
+std::vector<NextAction> FrostDKStrategy::getDefaultActions()
+{
+    return {
+        NextAction("obliterate", ACTION_DEFAULT + 0.7f),
+        NextAction("frost strike", ACTION_DEFAULT + 0.4f),
+        NextAction("empower rune weapon", ACTION_DEFAULT + 0.3f),
+        NextAction("horn of winter", ACTION_DEFAULT + 0.1f),
+        NextAction("melee", ACTION_DEFAULT)
+    };
+}
+
+void FrostDKStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    GenericDKStrategy::InitTriggers(triggers);
+
+    triggers.push_back(
+        new TriggerNode(
+            "unbreakable armor",
+            {
+                NextAction("unbreakable armor", ACTION_DEFAULT + 0.6f)
+            }
+        )
+    );
+
+    triggers.push_back(
+        new TriggerNode(
+            "freezing fog",
+            {
+                NextAction("howling blast", ACTION_DEFAULT + 0.5f)
+            }
+        )
+    );
+
+    triggers.push_back(
+        new TriggerNode(
+            "high blood rune",
+            {
+                NextAction("blood strike", ACTION_DEFAULT + 0.2f)
+            }
+        )
+    );
+
+    triggers.push_back(
+        new TriggerNode(
+            "army of the dead",
+            {
+                NextAction("army of the dead", ACTION_HIGH + 6)
+            }
+        )
+    );
+
+    triggers.push_back(
+        new TriggerNode(
+            "icy touch",
+            {
+                NextAction("icy touch", ACTION_HIGH + 2)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "plague strike",
+            {
+                NextAction("plague strike", ACTION_HIGH + 2)
+            }
+        )
+    );
+
+}
+
+void FrostDKAoeStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(
+        new TriggerNode(
+            "medium aoe",
+            {
+                NextAction("howling blast", ACTION_HIGH + 4)
+            }
+        )
+    );
+}

src/Ai/Class/Dk/Strategy/FrostDKStrategy.h

@@ -0,0 +1,33 @@
+/*
+ * 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_FROSTDKSTRATEGY_H
+#define _PLAYERBOT_FROSTDKSTRATEGY_H
+
+#include "GenericDKStrategy.h"
+
+class PlayerbotAI;
+
+class FrostDKStrategy : public GenericDKStrategy
+{
+public:
+    FrostDKStrategy(PlayerbotAI* botAI);
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "frost"; }
+    std::vector<NextAction> getDefaultActions() override;
+    uint32 GetType() const override { return STRATEGY_TYPE_COMBAT | STRATEGY_TYPE_DPS | STRATEGY_TYPE_MELEE; }
+};
+
+class FrostDKAoeStrategy : public CombatStrategy
+{
+public:
+    FrostDKAoeStrategy(PlayerbotAI* botAI) : CombatStrategy(botAI) {}
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "frost aoe"; }
+};
+
+#endif

src/Ai/Class/Dk/Strategy/GenericDKNonCombatStrategy.cpp

@@ -0,0 +1,61 @@
+/*
+ * 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 "GenericDKNonCombatStrategy.h"
+
+#include "Playerbots.h"
+
+class GenericDKNonCombatStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    GenericDKNonCombatStrategyActionNodeFactory()
+    {
+        creators["bone shield"] = &bone_shield;
+        creators["horn of winter"] = &horn_of_winter;
+    }
+
+private:
+    static ActionNode* bone_shield([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("bone shield",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* horn_of_winter([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("horn of winter",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+};
+
+GenericDKNonCombatStrategy::GenericDKNonCombatStrategy(PlayerbotAI* botAI) : NonCombatStrategy(botAI)
+{
+    actionNodeFactories.Add(new GenericDKNonCombatStrategyActionNodeFactory());
+}
+
+void GenericDKNonCombatStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    NonCombatStrategy::InitTriggers(triggers);
+
+    triggers.push_back(
+        new TriggerNode("no pet", { NextAction("raise dead", ACTION_NORMAL + 1) }));
+    triggers.push_back(
+        new TriggerNode("horn of winter", { NextAction("horn of winter", 21.0f) }));
+    triggers.push_back(
+        new TriggerNode("bone shield", { NextAction("bone shield", 21.0f) }));
+    triggers.push_back(
+        new TriggerNode("has pet", { NextAction("toggle pet spell", 60.0f) }));
+    triggers.push_back(
+        new TriggerNode("new pet", { NextAction("set pet stance", 60.0f) }));
+}
+
+void DKBuffDpsStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+
+}

src/Ai/Class/Dk/Strategy/GenericDKNonCombatStrategy.h

@@ -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.
+ */
+
+#ifndef _PLAYERBOT_GENERICDKNONCOMBATSTRATEGY_H
+#define _PLAYERBOT_GENERICDKNONCOMBATSTRATEGY_H
+
+#include "GenericDKStrategy.h"
+#include "NonCombatStrategy.h"
+
+class PlayerbotAI;
+
+class GenericDKNonCombatStrategy : public NonCombatStrategy
+{
+public:
+    GenericDKNonCombatStrategy(PlayerbotAI* botAI);
+
+    std::string const getName() override { return "nc"; }
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+class DKBuffDpsStrategy : public Strategy
+{
+public:
+    DKBuffDpsStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "bdps"; }
+};
+
+#endif

src/Ai/Class/Dk/Strategy/GenericDKStrategy.cpp

@@ -0,0 +1,193 @@
+#/*
+ * 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 "GenericDKStrategy.h"
+
+#include "DKAiObjectContext.h"
+#include "Playerbots.h"
+
+class GenericDKStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    GenericDKStrategyActionNodeFactory()
+    {
+        // blood
+        // creators["rune tap"] = &rune_tap; cd
+        // creators["vampiric blood"] = &vampiric_blood;
+        // creators["death pact"] = &death_pact;
+        // creators["hysteria"] = &hysteria; boost party
+        // creators["dancing rune weapon"] = &dancing_rune_weapon; //cd
+        // creators["dark command"] = &dark_command; taunt
+
+        // frost
+        // creators["chains of ice"] = &chains_of_ice;
+        // creators["icy clutch"] = &icy_clutch;
+        creators["horn of winter"] = &horn_of_winter;
+        creators["killing machine"] = &killing_machine;  // buff
+        // creators["deathchill"] = &deathchill;        //boost
+        creators["icebound fortitude"] = &icebound_fortitude;
+        // creators["mind freeze"] = &mind_freeze; interrupt
+        // creators["empower rune weapon"] = &empower_rune_weapon; boost
+        // creators["hungering cold"] = &hungering_cold; snare
+        // creators["unbreakable armor"] = &unbreakable_armor; boost +cd
+        // creators["improved icy talons"] = &improved_icy_talons; boost party
+
+        // unholy
+        creators["death and decay"] = &death_and_decay;
+        // creators["raise dead"] = &raise_dead;
+        // creators["army of the dead"] = &army of the dead;
+        // creators["summon gargoyle"] = &army of the dead;
+        // creators["anti magic shell"] = &anti_magic_shell; cd
+        creators["anti magic zone"] = &anti_magic_zone;
+        // creators["ghoul frenzy"] = &ghoul_frenzy;
+        creators["corpse explosion"] = &corpse_explosion;
+        creators["bone shield"] = &bone_shield;
+        creators["heart strike"] = &heart_strike;
+        creators["death grip"] = &death_grip;
+        creators["plague strike"] = &plague_strike;
+        creators["pestilence"] = &pestilence;
+        creators["icy touch"] = &icy_touch;
+    }
+
+private:
+    static ActionNode* death_coil([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("death coil",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* death_grip([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("death grip",
+                              /*P*/ {},
+                              /*A*/ { NextAction("icy touch") },
+                              /*C*/ {});
+    }
+
+    static ActionNode* plague_strike([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("plague strike",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* icy_touch([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("icy touch",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* heart_strike([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("heart strike",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* pestilence([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("pestilence",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* horn_of_winter([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("horn of winter",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* bone_shield([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("bone shield",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* killing_machine([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("killing machine",
+                              /*P*/ {},
+                              /*A*/ { NextAction("improved icy talons") },
+                              /*C*/ {});
+    }
+
+    static ActionNode* corpse_explosion([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("corpse explosion",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* death_and_decay([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("death and decay",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+
+    static ActionNode* anti_magic_zone([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("anti magic zone",
+                              /*P*/ {},
+                              /*A*/ { NextAction("anti magic shell") },
+                              /*C*/ {});
+    }
+
+    static ActionNode* icebound_fortitude([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode("icebound fortitude",
+                              /*P*/ {},
+                              /*A*/ {},
+                              /*C*/ {});
+    }
+};
+
+GenericDKStrategy::GenericDKStrategy(PlayerbotAI* botAI) : MeleeCombatStrategy(botAI)
+{
+    actionNodeFactories.Add(new GenericDKStrategyActionNodeFactory());
+}
+
+void GenericDKStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    MeleeCombatStrategy::InitTriggers(triggers);
+
+    triggers.push_back(
+        new TriggerNode("no pet", { NextAction("raise dead", ACTION_NORMAL + 5) }));
+    triggers.push_back(
+        new TriggerNode("has pet", { NextAction("toggle pet spell", 60.0f) }));
+    triggers.push_back(
+        new TriggerNode("new pet", { NextAction("set pet stance", 60.0f) }));
+    triggers.push_back(
+        new TriggerNode("mind freeze", { NextAction("mind freeze", ACTION_HIGH + 1) }));
+    triggers.push_back(
+        new TriggerNode("mind freeze on enemy healer",
+                        { NextAction("mind freeze on enemy healer", ACTION_HIGH + 1) }));
+    triggers.push_back(new TriggerNode(
+        "horn of winter", { NextAction("horn of winter", ACTION_NORMAL + 1) }));
+    triggers.push_back(new TriggerNode("critical health",
+                                       { NextAction("death pact", ACTION_HIGH + 5) }));
+
+    triggers.push_back(
+        new TriggerNode("low health", { NextAction("icebound fortitude", ACTION_HIGH + 5),
+                                                        NextAction("rune tap", ACTION_HIGH + 4) }));
+    triggers.push_back(
+        new TriggerNode("medium aoe", { NextAction("death and decay", ACTION_HIGH + 9),
+                                                        NextAction("pestilence", ACTION_NORMAL + 4),
+                                                        NextAction("blood boil", ACTION_NORMAL + 3) }));
+    triggers.push_back(
+        new TriggerNode("pestilence glyph", { NextAction("pestilence", ACTION_HIGH + 9) }));
+}

src/Ai/Class/Dk/Strategy/GenericDKStrategy.h

@@ -0,0 +1,22 @@
+/*
+ * 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_GENERICDKSTRATEGY_H
+#define _PLAYERBOT_GENERICDKSTRATEGY_H
+
+#include "MeleeCombatStrategy.h"
+
+class PlayerbotAI;
+
+class GenericDKStrategy : public MeleeCombatStrategy
+{
+public:
+    GenericDKStrategy(PlayerbotAI* botAI);
+
+    std::string const getName() override { return "DK"; }
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+};
+
+#endif

src/Ai/Class/Dk/Strategy/UnholyDKStrategy.cpp

@@ -0,0 +1,192 @@
+/*
+ * 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 "UnholyDKStrategy.h"
+
+#include "Playerbots.h"
+
+class UnholyDKStrategyActionNodeFactory : public NamedObjectFactory<ActionNode>
+{
+public:
+    UnholyDKStrategyActionNodeFactory()
+    {
+        creators["death strike"] = &death_strike;
+        creators["scourge strike"] = &scourge_strike;
+        creators["ghoul frenzy"] = &ghoul_frenzy;
+        creators["corpse explosion"] = &corpse_explosion;
+        creators["icy touch"] = &icy_touch;
+    }
+
+private:
+    static ActionNode* death_strike([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "death strike",
+            /*P*/ { NextAction("blood presence") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+    static ActionNode* ghoul_frenzy([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "ghoul frenzy",
+            /*P*/ { NextAction("blood presence") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+    static ActionNode* corpse_explosion([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "corpse explosion",
+            /*P*/ { NextAction("blood presence") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+
+    static ActionNode* scourge_strike([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "scourge strike",
+            /*P*/ { NextAction("blood presence") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+    static ActionNode* icy_touch([[maybe_unused]] PlayerbotAI* botAI)
+    {
+        return new ActionNode(
+            "icy touch",
+            /*P*/ { NextAction("blood presence") },
+            /*A*/ {},
+            /*C*/ {}
+        );
+    }
+};
+
+UnholyDKStrategy::UnholyDKStrategy(PlayerbotAI* botAI) : GenericDKStrategy(botAI)
+{
+    actionNodeFactories.Add(new UnholyDKStrategyActionNodeFactory());
+}
+
+std::vector<NextAction> UnholyDKStrategy::getDefaultActions()
+{
+    return {
+        NextAction("death and decay", ACTION_HIGH + 5),
+        NextAction("summon gargoyle", ACTION_DEFAULT + 0.4f),
+        NextAction("horn of winter", ACTION_DEFAULT + 0.2f),
+        NextAction("death coil", ACTION_DEFAULT + 0.1f),
+        NextAction("melee", ACTION_DEFAULT)
+    };
+}
+
+void UnholyDKStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    GenericDKStrategy::InitTriggers(triggers);
+
+    triggers.push_back(
+        new TriggerNode(
+            "death and decay cooldown",
+            {
+                NextAction("ghoul frenzy", ACTION_DEFAULT + 0.9f),
+                NextAction("scourge strike", ACTION_DEFAULT + 0.8f),
+                NextAction("icy touch", ACTION_DEFAULT + 0.7f),
+                NextAction("blood strike", ACTION_DEFAULT + 0.6f),
+                NextAction("plague strike", ACTION_DEFAULT + 0.5f),
+            }
+        )
+    );
+
+    triggers.push_back(
+        new TriggerNode(
+            "dd cd and no desolation",
+            {
+                NextAction("blood strike", ACTION_DEFAULT + 0.75f)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "high frost rune",
+            {
+                NextAction("icy touch", ACTION_NORMAL + 3)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "high blood rune",
+            {
+                NextAction("blood strike", ACTION_NORMAL + 2)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "high unholy rune",
+            {
+                NextAction("plague strike", ACTION_NORMAL + 1)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode("dd cd and plague strike 3s",
+            {
+                NextAction("plague strike", ACTION_HIGH + 1)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode("dd cd and icy touch 3s",
+            {
+                NextAction("icy touch", ACTION_HIGH + 2)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode("no rune",
+            {
+                NextAction("empower rune weapon", ACTION_HIGH + 1)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "army of the dead",
+            {
+                NextAction("army of the dead", ACTION_HIGH + 6)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode("bone shield",
+            {
+                NextAction("bone shield", ACTION_HIGH + 3)
+            }
+        )
+    );
+}
+
+void UnholyDKAoeStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    triggers.push_back(
+        new TriggerNode(
+            "loot available",
+            {
+                NextAction("corpse explosion", ACTION_NORMAL + 1)
+            }
+        )
+    );
+    triggers.push_back(
+        new TriggerNode(
+            "medium aoe",
+            {
+                NextAction("death and decay", ACTION_NORMAL + 3),
+                NextAction("corpse explosion", ACTION_NORMAL + 3)
+            }
+        )
+    );
+}

src/Ai/Class/Dk/Strategy/UnholyDKStrategy.h

@@ -0,0 +1,33 @@
+/*
+ * 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_UNHOLYDKSTRATEGY_H
+#define _PLAYERBOT_UNHOLYDKSTRATEGY_H
+
+#include "GenericDKStrategy.h"
+
+class PlayerbotAI;
+
+class UnholyDKStrategy : public GenericDKStrategy
+{
+public:
+    UnholyDKStrategy(PlayerbotAI* botAI);
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "unholy"; }
+    std::vector<NextAction> getDefaultActions() override;
+    uint32 GetType() const override { return STRATEGY_TYPE_COMBAT | STRATEGY_TYPE_DPS | STRATEGY_TYPE_MELEE; }
+};
+
+class UnholyDKAoeStrategy : public CombatStrategy
+{
+public:
+    UnholyDKAoeStrategy(PlayerbotAI* botAI) : CombatStrategy(botAI) {}
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    std::string const getName() override { return "unholy aoe"; }
+};
+
+#endif