Implement Zul'Aman Strategies (#2186)

# Pull Request

_Implement strategies for all bosses in Zul'Aman. See next post for
overview of implemented strategies._

---

## Design Philosophy

We prioritize **stability, performance, and predictability** over
behavioral realism.
Complex player-mimicking logic is intentionally limited due to its
negative impact on scalability, maintainability, and
long-term robustness.

Excessive processing overhead can lead to server hiccups, increased CPU
usage, and degraded performance for all
participants. Because every action and
decision tree is executed **per bot and per trigger**, even small
increases in logic complexity can scale poorly and
negatively affect both players and
world (random) bots. Bots are not expected to behave perfectly, and
perfect simulation of human decision-making is not a
project goal. Increased behavioral
realism often introduces disproportionate cost, reduced predictability,
and significantly higher maintenance overhead.

Every additional branch of logic increases long-term responsibility. All
decision paths must be tested, validated, and
maintained continuously as the system evolves.
If advanced or AI-intensive behavior is introduced, the **default
configuration must remain the lightweight decision
model**. More complex behavior should only be
available as an **explicit opt-in option**, clearly documented as having
a measurable performance cost.

Principles:

- **Stability before intelligence**  
  A stable system is always preferred over a smarter one.

- **Performance is a shared resource**  
  Any increase in bot cost affects all players and all bots.

- **Simple logic scales better than smart logic**  
Predictable behavior under load is more valuable than perfect decisions.

- **Complexity must justify itself**  
  If a feature cannot clearly explain its cost, it should not exist.

- **Defaults must be cheap**  
  Expensive behavior must always be optional and clearly communicated.

- **Bots should look reasonable, not perfect**  
  The goal is believable behavior, not human simulation.

Before submitting, confirm that this change aligns with those
principles.

---

## Feature Evaluation

Please answer the following:

- Describe the **minimum logic** required to achieve the intended
behavior?
- Describe the **cheapest implementation** that produces an acceptable
result?
- Describe the **runtime cost** when this logic executes across many
bots?

_I have attempted to order checks while taking into account cost and
likelihood and have opted to find lower-cost methods where possible. I
have also not gone as in depth as I have with other strategies,
partially because it is not necessary to complete encounters but also to
try to limit the performance impact. From my observation, including with
pmon, none of the methods should be overly taxing._

---

## How to Test the Changes

- Step-by-step instructions to test the change
- Any required setup (e.g. multiple players, bots, specific
configuration)
- Expected behavior and how to verify it

_Run Zul'Aman. See next post for strategies to test._

## Complexity & Impact

Does this change add new decision branches?
- - [ ] No
- - [x] Yes (**explain below**)

_Only in the context of raid strategies, with new methods to consider
and new multipliers to evaluate when bots perform actions with the
instance strategy active._

Does this change increase per-bot or per-tick processing?
- - [ ] No
- - [x] Yes (**describe and justify impact**)

_The impact is only with the "zulaman" strategy active, which will be
applied only in the instance. There is currently a PR open to also
remove instance strategies when leaving the map to get rid of the
residual performance impact._

Could this logic scale poorly under load?
- - [ ] No
- - [x] Yes (**explain why**)

_Technically yes, but I think it is unlikely to have an appreciable
difference unless there are many groups running the instance at the same
time on a large server._

## Defaults & Configuration

Does this change modify default bot behavior?
- - [ ] No
- - [x] Yes (**explain why**)

_Only in the instance. It is a necessary trade-off to consider with raid
strategies that I always keep in mind (degree of automation vs. player
choice)._

If this introduces more advanced or AI-heavy logic:
- - [x] Lightweight mode remains the default
- - [ ] More complex behavior is optional and thereby configurable

_Not exactly sure how to address this question in the context of this
PR, but there aren't any techniques or methods for this strategy that I
have not tried before (or something very similar)._

## AI Assistance

Was AI assistance (e.g. ChatGPT or similar tools) used while working on
this change?
- - [ ] No
- - [x] Yes (**explain below**)

If yes, please specify:

- AI tool or model used (e.g. ChatGPT, GPT-4, Claude, etc.)
- Purpose of usage (e.g. brainstorming, refactoring, documentation, code
generation)
- Which parts of the change were influenced or generated
- Whether the result was manually reviewed and adapted

_Gemini and GPT for some questions about the codebase and C++ and
assistance with drafting a few things like containers that I find more
tedious to do myself._

AI assistance is allowed, but all submitted code must be fully
understood, reviewed, and owned by the contributor.
Any AI-influenced changes must be verified against existing CORE and PB
logic. We expect contributors to be honest
about what they do and do not understand.

---

## Final Checklist

- - [x] Stability is not compromised
- - [x] Performance impact is understood, tested, and acceptable
- - [x] Added logic complexity is justified and explained
- - [x] Documentation updated if needed

---

## Notes for Reviewers

Anything that significantly improves realism at the cost of stability or
performance should be carefully discussed
before merging.

---------

Co-authored-by: Keleborn <22352763+Celandriel@users.noreply.github.com>
Co-authored-by: bash <hermensb@gmail.com>
Co-authored-by: Revision <tkn963@gmail.com>
Co-authored-by: kadeshar <kadeshar@gmail.com>

src/Ai/Raid/RaidStrategyContext.h

@@ -11,6 +11,7 @@
 #include "RaidNaxxStrategy.h"
 #include "RaidSSCStrategy.h"
 #include "RaidTempestKeepStrategy.h"
+#include "RaidZulAmanStrategy.h"
 #include "RaidOsStrategy.h"
 #include "RaidEoEStrategy.h"
 #include "RaidVoAStrategy.h"
@@ -32,6 +33,7 @@ public:
         creators["naxx"] = &RaidStrategyContext::naxx;
         creators["ssc"] = &RaidStrategyContext::ssc;
         creators["tempestkeep"] = &RaidStrategyContext::tempestkeep;
+        creators["zulaman"] = &RaidStrategyContext::zulaman;
         creators["wotlk-os"] = &RaidStrategyContext::wotlk_os;
         creators["wotlk-eoe"] = &RaidStrategyContext::wotlk_eoe;
         creators["voa"] = &RaidStrategyContext::voa;
@@ -50,6 +52,7 @@ private:
     static Strategy* naxx(PlayerbotAI* botAI) { return new RaidNaxxStrategy(botAI); }
     static Strategy* ssc(PlayerbotAI* botAI) { return new RaidSSCStrategy(botAI); }
     static Strategy* tempestkeep(PlayerbotAI* botAI) { return new RaidTempestKeepStrategy(botAI); }
+    static Strategy* zulaman(PlayerbotAI* botAI) { return new RaidZulAmanStrategy(botAI); }
     static Strategy* wotlk_os(PlayerbotAI* botAI) { return new RaidOsStrategy(botAI); }
     static Strategy* wotlk_eoe(PlayerbotAI* botAI) { return new RaidEoEStrategy(botAI); }
     static Strategy* voa(PlayerbotAI* botAI) { return new RaidVoAStrategy(botAI); }

src/Ai/Raid/TempestKeep/RaidTempestKeepActionContext.h

@@ -116,8 +116,8 @@ public:
         creators["kael'thas sunstrider assign legendary weapon dps priority"] =
             &RaidTempestKeepActionContext::kaelthas_sunstrider_assign_legendary_weapon_dps_priority;
 
-        creators["kael'thas sunstrider main tank move devastation away"] =
+        creators["kael'thas sunstrider move devastation away"] =
-            &RaidTempestKeepActionContext::kaelthas_sunstrider_main_tank_move_devastation_away;
+            &RaidTempestKeepActionContext::kaelthas_sunstrider_move_devastation_away;
 
         creators["kael'thas sunstrider loot legendary weapons"] =
             &RaidTempestKeepActionContext::kaelthas_sunstrider_loot_legendary_weapons;
@@ -255,7 +255,7 @@ private:
     static Action* kaelthas_sunstrider_assign_legendary_weapon_dps_priority(
         PlayerbotAI* botAI) { return new KaelthasSunstriderAssignLegendaryWeaponDpsPriorityAction(botAI); }
 
-    static Action* kaelthas_sunstrider_main_tank_move_devastation_away(
+    static Action* kaelthas_sunstrider_move_devastation_away(
         PlayerbotAI* botAI) { return new KaelthasSunstriderMoveDevastationAwayAction(botAI); }
 
     static Action* kaelthas_sunstrider_loot_legendary_weapons(

src/Ai/Raid/TempestKeep/Strategy/RaidTempestKeepStrategy.cpp

@@ -105,7 +105,7 @@ void RaidTempestKeepStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
         NextAction("kael'thas sunstrider assign legendary weapon dps priority", ACTION_RAID + 1) }));
 
     triggers.push_back(new TriggerNode("kael'thas sunstrider legendary axe casts whirlwind", {
-        NextAction("kael'thas sunstrider main tank move devastation away", ACTION_EMERGENCY + 1) }));
+        NextAction("kael'thas sunstrider move devastation away", ACTION_EMERGENCY + 1) }));
 
     triggers.push_back(new TriggerNode("kael'thas sunstrider legendary weapons are dead and lootable", {
         NextAction("kael'thas sunstrider loot legendary weapons", ACTION_RAID) }));

src/Ai/Raid/ZulAman/Action/RaidZulAmanActions.cpp

@@ -0,0 +1,745 @@
+/*
+ * 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 "RaidZulAmanActions.h"
+#include "RaidZulAmanHelpers.h"
+#include "Playerbots.h"
+#include "RaidBossHelpers.h"
+
+using namespace ZulAmanHelpers;
+
+// Trash
+
+bool AmanishiMedicineManMarkWardAction::Execute(Event /*event*/)
+{
+    if (Unit* protectiveWard = GetFirstAliveUnitByEntry(
+            botAI, static_cast<uint32>(ZulAmanNPCs::NPC_AMANI_PROTECTIVE_WARD)))
+    {
+        MarkTargetWithSkull(bot, protectiveWard);
+    }
+    else if (Unit* healingWard = GetFirstAliveUnitByEntry(
+                botAI, static_cast<uint32>(ZulAmanNPCs::NPC_AMANI_HEALING_WARD)))
+    {
+        MarkTargetWithSkull(bot, healingWard);
+    }
+
+    return false;
+}
+
+// Akil'zon <Eagle Avatar>
+
+bool AkilzonMisdirectBossToMainTankAction::Execute(Event /*event*/)
+{
+    Unit* akilzon = AI_VALUE2(Unit*, "find target", "akil'zon");
+    if (!akilzon)
+        return false;
+
+    Player* mainTank = GetGroupMainTank(botAI, bot);
+    if (!mainTank)
+        return false;
+
+    if (botAI->CanCastSpell("misdirection", mainTank))
+        return botAI->CastSpell("misdirection", mainTank);
+
+    if (bot->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_MISDIRECTION)) &&
+        botAI->CanCastSpell("steady shot", akilzon))
+        return botAI->CastSpell("steady shot", akilzon);
+
+    return false;
+}
+
+bool AkilzonTanksPositionBossAction::Execute(Event /*event*/)
+{
+    Unit* akilzon = AI_VALUE2(Unit*, "find target", "akil'zon");
+    if (!akilzon)
+        return false;
+
+    if (bot->GetVictim() != akilzon)
+        return Attack(akilzon);
+
+    if (akilzon->GetVictim() == bot)
+    {
+        const Position& position = AKILZON_TANK_POSITION;
+        float distToPosition =
+            bot->GetExactDist2d(position.GetPositionX(), position.GetPositionY());
+
+        if (distToPosition > 2.0f)
+        {
+            float dX = position.GetPositionX() - bot->GetPositionX();
+            float dY = position.GetPositionY() - bot->GetPositionY();
+            float moveDist = std::min(10.0f, distToPosition);
+            float moveX = bot->GetPositionX() + (dX / distToPosition) * moveDist;
+            float moveY = bot->GetPositionY() + (dY / distToPosition) * moveDist;
+
+            return MoveTo(ZULAMAN_MAP_ID, moveX, moveY, bot->GetPositionZ(), false, false,
+                          false, false, MovementPriority::MOVEMENT_COMBAT, true, false);
+        }
+    }
+
+    return false;
+}
+
+bool AkilzonSpreadRangedAction::Execute(Event /*event*/)
+{
+    constexpr float minDistance = 13.0f;
+    constexpr uint32 minInterval = 1000;
+    if (Unit* nearestPlayer = GetNearestPlayerInRadius(bot, minDistance))
+        return FleePosition(nearestPlayer->GetPosition(), minDistance, minInterval);
+
+    return false;
+}
+
+bool AkilzonMoveToEyeOfTheStormAction::Execute(Event /*event*/)
+{
+    Player* target = GetElectricalStormTarget(bot);
+    if (!target && !botAI->IsMainTank(bot))
+        target = GetGroupMainTank(botAI, bot);
+
+    if (target && bot->GetExactDist2d(target) > 2.0f)
+    {
+        botAI->Reset();
+        return MoveTo(ZULAMAN_MAP_ID, target->GetPositionX(), target->GetPositionY(),
+                      bot->GetPositionZ(), false, false, false, false,
+                      MovementPriority::MOVEMENT_FORCED, true, false);
+    }
+
+    return false;
+}
+
+bool AkilzonManageElectricalStormTimerAction::Execute(Event /*event*/)
+{
+    const time_t now = std::time(nullptr);
+    const uint32 instanceId = bot->GetMap()->GetInstanceId();
+
+    Unit* akilzon = AI_VALUE2(Unit*, "find target", "akil'zon");
+    if (akilzon)
+    {
+        auto [it, inserted] = akilzonStormTimer.try_emplace(instanceId, now);
+        return inserted;
+    }
+    else if (!bot->IsInCombat() && !akilzon && akilzonStormTimer.erase(instanceId) > 0)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+// Nalorakk <Bear Avatar>
+
+bool NalorakkMisdirectBossToMainTankAction::Execute(Event /*event*/)
+{
+    Unit* nalorakk = AI_VALUE2(Unit*, "find target", "nalorakk");
+    if (!nalorakk)
+        return false;
+
+    Player* mainTank = GetGroupMainTank(botAI, bot);
+    if (!mainTank)
+        return false;
+
+    if (botAI->CanCastSpell("misdirection", mainTank))
+        return botAI->CastSpell("misdirection", mainTank);
+
+    if (bot->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_MISDIRECTION)) &&
+        botAI->CanCastSpell("steady shot", nalorakk))
+        return botAI->CastSpell("steady shot", nalorakk);
+
+    return false;
+}
+
+bool NalorakkTanksPositionBossAction::Execute(Event /*event*/)
+{
+    if (!botAI->IsMainTank(bot) && !botAI->IsAssistTankOfIndex(bot, 0, true))
+        return false;
+
+    Unit* nalorakk = AI_VALUE2(Unit*, "find target", "nalorakk");
+    if (!nalorakk)
+        return false;
+
+    if (botAI->IsMainTank(bot))
+        return MainTankPositionTrollForm(nalorakk);
+    else
+        return FirstAssistTankPositionBearForm(nalorakk);
+}
+
+bool NalorakkTanksPositionBossAction::MainTankPositionTrollForm(Unit* nalorakk)
+{
+    if (!nalorakk->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_BEARFORM)))
+    {
+        if (bot->GetVictim() != nalorakk)
+            return Attack(nalorakk);
+
+        if (nalorakk->GetVictim() != bot)
+            return botAI->DoSpecificAction("taunt spell", Event(), true);
+    }
+
+    const Position& position = NALORAKK_TANK_POSITION;
+    float distToPosition =
+        bot->GetExactDist2d(position.GetPositionX(), position.GetPositionY());
+
+    if (distToPosition > 2.0f)
+    {
+        float dX = position.GetPositionX() - bot->GetPositionX();
+        float dY = position.GetPositionY() - bot->GetPositionY();
+        float moveDist = std::min(10.0f, distToPosition);
+        float moveX = bot->GetPositionX() + (dX / distToPosition) * moveDist;
+        float moveY = bot->GetPositionY() + (dY / distToPosition) * moveDist;
+
+        return MoveTo(ZULAMAN_MAP_ID, moveX, moveY, bot->GetPositionZ(), false, false,
+                        false, false, MovementPriority::MOVEMENT_COMBAT, true, false);
+    }
+
+    return false;
+}
+
+bool NalorakkTanksPositionBossAction::FirstAssistTankPositionBearForm(Unit* nalorakk)
+{
+    if (nalorakk->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_BEARFORM)))
+    {
+        if (bot->GetVictim() != nalorakk)
+            return Attack(nalorakk);
+
+        if (nalorakk->GetVictim() != bot)
+            return botAI->DoSpecificAction("taunt spell", Event(), true);
+    }
+
+    const Position& position = NALORAKK_TANK_POSITION;
+    float distToPosition =
+        bot->GetExactDist2d(position.GetPositionX(), position.GetPositionY());
+
+    if (distToPosition > 2.0f)
+    {
+        float dX = position.GetPositionX() - bot->GetPositionX();
+        float dY = position.GetPositionY() - bot->GetPositionY();
+        float moveDist = std::min(10.0f, distToPosition);
+        float moveX = bot->GetPositionX() + (dX / distToPosition) * moveDist;
+        float moveY = bot->GetPositionY() + (dY / distToPosition) * moveDist;
+
+        return MoveTo(ZULAMAN_MAP_ID, moveX, moveY, bot->GetPositionZ(), false, false,
+                        false, false, MovementPriority::MOVEMENT_COMBAT, true, false);
+    }
+
+    return false;
+}
+
+bool NalorakkSpreadRangedAction::Execute(Event /*event*/)
+{
+    constexpr float minDistance = 11.0f;
+    constexpr uint32 minInterval = 1000;
+    if (Unit* nearestPlayer = GetNearestPlayerInRadius(bot, minDistance))
+        return FleePosition(nearestPlayer->GetPosition(), minDistance, minInterval);
+
+    return false;
+}
+
+// Jan'alai <Dragonhawk Avatar>
+
+bool JanalaiMisdirectBossToMainTankAction::Execute(Event /*event*/)
+{
+    Unit* janalai = AI_VALUE2(Unit*, "find target", "jan'alai");
+    if (!janalai)
+        return false;
+
+    Player* mainTank = GetGroupMainTank(botAI, bot);
+    if (!mainTank)
+        return false;
+
+    if (botAI->CanCastSpell("misdirection", mainTank))
+        return botAI->CastSpell("misdirection", mainTank);
+
+    if (bot->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_MISDIRECTION)) &&
+        botAI->CanCastSpell("steady shot", janalai))
+        return botAI->CastSpell("steady shot", janalai);
+
+    return false;
+}
+
+bool JanalaiTanksPositionBossAction::Execute(Event /*event*/)
+{
+    Unit* janalai = AI_VALUE2(Unit*, "find target", "jan'alai");
+    if (!janalai)
+        return false;
+
+    if (bot->GetVictim() != janalai)
+        return Attack(janalai);
+
+    if (janalai->GetVictim() == bot)
+    {
+        const Position& position = JANALAI_TANK_POSITION;
+        float distToPosition =
+            bot->GetExactDist2d(position.GetPositionX(), position.GetPositionY());
+
+        if (distToPosition > 2.0f)
+        {
+            float dX = position.GetPositionX() - bot->GetPositionX();
+            float dY = position.GetPositionY() - bot->GetPositionY();
+            float moveDist = std::min(10.0f, distToPosition);
+            float moveX = bot->GetPositionX() + (dX / distToPosition) * moveDist;
+            float moveY = bot->GetPositionY() + (dY / distToPosition) * moveDist;
+
+            return MoveTo(ZULAMAN_MAP_ID, moveX, moveY, bot->GetPositionZ(), false, false,
+                          false, false, MovementPriority::MOVEMENT_COMBAT, true, false);
+        }
+    }
+
+    return false;
+}
+
+bool JanalaiSpreadRangedInCircleAction::Execute(Event /*event*/)
+{
+    Group* group = bot->GetGroup();
+    if (!group)
+        return false;
+
+    std::vector<Player*> rangedMembers;
+    for (GroupReference* ref = group->GetFirstMember(); ref; ref = ref->next())
+    {
+        Player* member = ref->GetSource();
+        if (!member || !botAI->IsRanged(member))
+            continue;
+
+        rangedMembers.push_back(member);
+    }
+
+    if (rangedMembers.empty())
+        return false;
+
+    auto findIt = std::find(rangedMembers.begin(), rangedMembers.end(), bot);
+    size_t botIndex =
+        (findIt != rangedMembers.end()) ? std::distance(rangedMembers.begin(), findIt) : 0;
+    size_t count = rangedMembers.size();
+    if (count == 0)
+        return false;
+
+    constexpr float radius = 15.0f;
+    float angle = (count == 1) ? 0.0f :
+            (2.0f * M_PI * static_cast<float>(botIndex) / static_cast<float>(count));
+
+    float targetX = JANALAI_TANK_POSITION.GetPositionX() + radius * std::cos(angle);
+    float targetY = JANALAI_TANK_POSITION.GetPositionY() + radius * std::sin(angle);
+
+    if (bot->GetExactDist2d(targetX, targetY) > 2.0f)
+    {
+        return MoveTo(ZULAMAN_MAP_ID, targetX, targetY, bot->GetPositionZ(), false, false,
+                      false, false, MovementPriority::MOVEMENT_COMBAT, true, false);
+    }
+
+    return false;
+}
+
+bool JanalaiAvoidFireBombsAction::Execute(Event /*event*/)
+{
+    auto const& bombs = GetAllHazardTriggers(
+        bot, static_cast<uint32>(ZulAmanNPCs::NPC_FIRE_BOMB), 50.0f);
+
+    if (bombs.empty())
+        return false;
+
+    constexpr float hazardRadius = 5.0f;
+    bool inDanger = false;
+    for (Unit* bomb : bombs)
+    {
+        if (bot->GetDistance2d(bomb) < hazardRadius)
+        {
+            inDanger = true;
+            break;
+        }
+    }
+
+    if (!inDanger)
+        return false;
+
+    const Position& janalaiCenter = JANALAI_TANK_POSITION;
+    constexpr float safeZoneRadius = 17.0f;
+
+    Position safestPos =
+        FindSafestNearbyPosition(bot, bombs, janalaiCenter, safeZoneRadius, hazardRadius, false);
+
+    bot->AttackStop();
+    bot->InterruptNonMeleeSpells(true);
+    return MoveTo(ZULAMAN_MAP_ID, safestPos.GetPositionX(), safestPos.GetPositionY(),
+                  bot->GetPositionZ(), false, false, false, false,
+                  MovementPriority::MOVEMENT_FORCED, true, false);
+}
+
+bool JanalaiMarkAmanishiHatchersAction::Execute(Event /*event*/)
+{
+    auto [hatcherLow, hatcherHigh] = GetAmanishiHatcherPair(botAI);
+
+    if (hatcherLow && hatcherHigh && hatcherHigh != hatcherLow)
+    {
+        MarkTargetWithSkull(bot, hatcherLow);
+        MarkTargetWithMoon(bot, hatcherHigh);
+        SetRtiTarget(botAI, "skull", hatcherLow);
+    }
+
+    return false;
+}
+
+// Halazzi <Lynx Avatar>
+
+bool HalazziMisdirectBossToMainTankAction::Execute(Event /*event*/)
+{
+    Unit* halazzi = AI_VALUE2(Unit*, "find target", "halazzi");
+    if (!halazzi)
+        return false;
+
+    Player* mainTank = GetGroupMainTank(botAI, bot);
+    if (!mainTank)
+        return false;
+
+    if (botAI->CanCastSpell("misdirection", mainTank))
+        return botAI->CastSpell("misdirection", mainTank);
+
+    if (bot->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_MISDIRECTION)) &&
+        botAI->CanCastSpell("steady shot", halazzi))
+        return botAI->CastSpell("steady shot", halazzi);
+
+    return false;
+}
+
+bool HalazziMainTankPositionBossAction::Execute(Event /*event*/)
+{
+    Unit* halazzi = AI_VALUE2(Unit*, "find target", "halazzi");
+    if (!halazzi)
+        return false;
+
+    MarkTargetWithStar(bot, halazzi);
+    SetRtiTarget(botAI, "star", halazzi);
+
+    if (bot->GetVictim() != halazzi)
+        return Attack(halazzi);
+
+    if (halazzi->GetVictim() == bot)
+    {
+        const Position& position = HALAZZI_TANK_POSITION;
+        float distToPosition =
+            bot->GetExactDist2d(position.GetPositionX(), position.GetPositionY());
+
+        if (distToPosition > 2.0f)
+        {
+            float dX = position.GetPositionX() - bot->GetPositionX();
+            float dY = position.GetPositionY() - bot->GetPositionY();
+            float moveDist = std::min(10.0f, distToPosition);
+            float moveX = bot->GetPositionX() + (dX / distToPosition) * moveDist;
+            float moveY = bot->GetPositionY() + (dY / distToPosition) * moveDist;
+
+            return MoveTo(ZULAMAN_MAP_ID, moveX, moveY, bot->GetPositionZ(), false, false,
+                          false, false, MovementPriority::MOVEMENT_COMBAT, true, false);
+        }
+    }
+
+    return false;
+}
+
+bool HalazziFirstAssistTankAttackSpiritLynxAction::Execute(Event /*event*/)
+{
+    bool targetFound = false;
+
+    if (Unit* lynx = AI_VALUE2(Unit*, "find target", "spirit of the lynx"))
+    {
+        MarkTargetWithCircle(bot, lynx);
+        SetRtiTarget(botAI, "circle", lynx);
+
+        if (bot->GetVictim() != lynx)
+            return Attack(lynx);
+
+        if (lynx->GetVictim() != bot)
+            return botAI->DoSpecificAction("taunt spell", Event(), true);
+
+        targetFound = true;
+    }
+    else if (Unit* halazzi = AI_VALUE2(Unit*, "find target", "halazzi"))
+    {
+        SetRtiTarget(botAI, "star", halazzi);
+
+        if (bot->GetVictim() != halazzi)
+            return Attack(halazzi);
+
+        targetFound = true;
+    }
+
+    if (!targetFound)
+        return false;
+
+    const Position& position = HALAZZI_TANK_POSITION;
+    float distToPosition =
+        bot->GetExactDist2d(position.GetPositionX(), position.GetPositionY());
+
+    if (distToPosition > 2.0f)
+    {
+        float dX = position.GetPositionX() - bot->GetPositionX();
+        float dY = position.GetPositionY() - bot->GetPositionY();
+        float moveDist = std::min(10.0f, distToPosition);
+        float moveX = bot->GetPositionX() + (dX / distToPosition) * moveDist;
+        float moveY = bot->GetPositionY() + (dY / distToPosition) * moveDist;
+
+        return MoveTo(ZULAMAN_MAP_ID, moveX, moveY, bot->GetPositionZ(), false, false,
+                      false, false, MovementPriority::MOVEMENT_COMBAT, true, false);
+    }
+
+    return false;
+}
+
+bool HalazziAssignDpsPriorityAction::Execute(Event /*event*/)
+{
+    // Target priority 1: Corrupted Lightning Totems
+    if (Unit* totem = GetFirstAliveUnitByEntry(
+            botAI, static_cast<uint32>(ZulAmanNPCs::NPC_CORRUPTED_LIGHTNING_TOTEM)))
+    {
+        MarkTargetWithSkull(bot, totem);
+        SetRtiTarget(botAI, "skull", totem);
+
+        if (bot->GetTarget() != totem->GetGUID())
+            return Attack(totem);
+
+        return false;
+    }
+
+    // Target priority 2: Halazzi
+    if (Unit* halazzi = AI_VALUE2(Unit*, "find target", "halazzi"))
+    {
+        SetRtiTarget(botAI, "star", halazzi);
+
+        if (bot->GetTarget() != halazzi->GetGUID())
+            return Attack(halazzi);
+    }
+
+    // Don't attack the Lynx
+    return false;
+}
+
+// Hex Lord Malacrass
+
+bool HexLordMalacrassMisdirectBossToMainTankAction::Execute(Event /*event*/)
+{
+    Unit* malacrass = AI_VALUE2(Unit*, "find target", "hex lord malacrass");
+    if (!malacrass)
+        return false;
+
+    Player* mainTank = GetGroupMainTank(botAI, bot);
+    if (!mainTank)
+        return false;
+
+    if (botAI->CanCastSpell("misdirection", mainTank))
+        return botAI->CastSpell("misdirection", mainTank);
+
+    if (bot->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_MISDIRECTION)) &&
+        botAI->CanCastSpell("steady shot", malacrass))
+        return botAI->CastSpell("steady shot", malacrass);
+
+    return false;
+}
+
+bool HexLordMalacrassAssignDpsPriorityAction::Execute(Event /*event*/)
+{
+    static constexpr uint32 priorityEntries[] =
+    {
+        static_cast<uint32>(ZulAmanNPCs::NPC_LORD_RAADAN),
+        static_cast<uint32>(ZulAmanNPCs::NPC_ALYSON_ANTILLE),
+        static_cast<uint32>(ZulAmanNPCs::NPC_KORAGG),
+        static_cast<uint32>(ZulAmanNPCs::NPC_DARKHEART),
+        static_cast<uint32>(ZulAmanNPCs::NPC_FENSTALKER),
+        static_cast<uint32>(ZulAmanNPCs::NPC_GAZAKROTH),
+        static_cast<uint32>(ZulAmanNPCs::NPC_THURG),
+        static_cast<uint32>(ZulAmanNPCs::NPC_SLITHER),
+        static_cast<uint32>(ZulAmanNPCs::NPC_HEX_LORD_MALACRASS)
+    };
+
+    auto const& targets =
+        botAI->GetAiObjectContext()->GetValue<GuidVector>("possible targets no los")->Get();
+
+    Unit* priorityTarget = nullptr;
+
+    for (uint32 entry : priorityEntries)
+    {
+        for (auto const& guid : targets)
+        {
+            Unit* unit = botAI->GetUnit(guid);
+            if (unit && unit->IsAlive() && unit->GetEntry() == entry)
+            {
+                priorityTarget = unit;
+                break;
+            }
+        }
+
+        if (priorityTarget)
+            break;
+    }
+
+    if (priorityTarget)
+    {
+        MarkTargetWithSkull(bot, priorityTarget);
+        SetRtiTarget(botAI, "skull", priorityTarget);
+    }
+
+    return false;
+}
+
+bool HexLordMalacrassRunAwayFromWhirlwindAction::Execute(Event /*event*/)
+{
+    if (Unit* malacrass = AI_VALUE2(Unit*, "find target", "hex lord malacrass"))
+    {
+        float currentDistance = bot->GetDistance2d(malacrass);
+        constexpr float safeDistance = 9.0f;
+        if (currentDistance < safeDistance)
+        {
+            bot->AttackStop();
+            bot->InterruptNonMeleeSpells(true);
+            return MoveAway(malacrass, safeDistance - currentDistance);
+        }
+    }
+
+    return false;
+}
+
+bool HexLordMalacrassCastersStopAttackingAction::Execute(Event /*event*/)
+{
+    Unit* malacrass = AI_VALUE2(Unit*, "find target", "hex lord malacrass");
+    if (!malacrass ||
+        !malacrass->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_HEX_LORD_SPELL_REFLECTION)))
+        return false;
+
+    if (bot->GetVictim() == malacrass)
+    {
+        bot->AttackStop();
+        bot->InterruptNonMeleeSpells(true);
+        return true;
+    }
+
+    return false;
+}
+
+bool HexLordMalacrassMoveAwayFromFreezingTrapAction::Execute(Event /*event*/)
+{
+    GameObject* trapGo = bot->FindNearestGameObject(
+        static_cast<uint32>(ZulAmanObjects::GO_FREEZING_TRAP), 20.0f, true);
+
+    if (!trapGo)
+        return false;
+
+    float currentDistance = bot->GetDistance2d(trapGo);
+    constexpr float safeDistance = 6.0f;
+    constexpr uint32 minInterval = 0;
+    if (currentDistance < safeDistance)
+        return FleePosition(trapGo->GetPosition(), safeDistance, minInterval);
+
+    return false;
+}
+
+// Zul'jin
+
+bool ZuljinMisdirectBossToMainTankAction::Execute(Event /*event*/)
+{
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    if (!zuljin)
+        return false;
+
+    Player* mainTank = GetGroupMainTank(botAI, bot);
+    if (!mainTank)
+        return false;
+
+    if (botAI->CanCastSpell("misdirection", mainTank))
+        return botAI->CastSpell("misdirection", mainTank);
+
+    if (bot->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_MISDIRECTION)) &&
+        botAI->CanCastSpell("steady shot", zuljin))
+        return botAI->CastSpell("steady shot", zuljin);
+
+    return false;
+}
+
+bool ZuljinTanksPositionBossAction::Execute(Event /*event*/)
+{
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    if (!zuljin)
+        return false;
+
+    if (bot->GetVictim() != zuljin)
+        return Attack(zuljin);
+
+    if (zuljin->GetVictim() == bot)
+    {
+        const Position& position = ZULJIN_TANK_POSITION;
+        float distToPosition =
+            bot->GetExactDist2d(position.GetPositionX(), position.GetPositionY());
+
+        if (distToPosition > 2.0f)
+        {
+            float dX = position.GetPositionX() - bot->GetPositionX();
+            float dY = position.GetPositionY() - bot->GetPositionY();
+            float moveDist = std::min(10.0f, distToPosition);
+            float moveX = bot->GetPositionX() + (dX / distToPosition) * moveDist;
+            float moveY = bot->GetPositionY() + (dY / distToPosition) * moveDist;
+
+            return MoveTo(ZULAMAN_MAP_ID, moveX, moveY, bot->GetPositionZ(), false, false,
+                          false, false, MovementPriority::MOVEMENT_COMBAT, true, true);
+        }
+    }
+
+    return false;
+}
+
+bool ZuljinRunAwayFromWhirlwindAction::Execute(Event /*event*/)
+{
+    if (Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin"))
+    {
+        float currentDistance = bot->GetExactDist2d(zuljin);
+        constexpr float safeDistance = 10.0f;
+        if (currentDistance < safeDistance)
+        {
+            bot->AttackStop();
+            bot->InterruptNonMeleeSpells(true);
+            return MoveAway(zuljin, safeDistance - currentDistance);
+        }
+    }
+
+    return false;
+}
+
+bool ZuljinAvoidCyclonesAction::Execute(Event /*event*/)
+{
+    auto const& cyclones = GetAllHazardTriggers(
+        bot, static_cast<uint32>(ZulAmanNPCs::NPC_FEATHER_VORTEX), 50.0f);
+
+    if (cyclones.empty())
+        return false;
+
+    constexpr float hazardRadius = 6.0f;
+    bool inDanger = false;
+    for (Unit* cyclone : cyclones)
+    {
+        if (bot->GetDistance2d(cyclone) < hazardRadius)
+        {
+            inDanger = true;
+            break;
+        }
+    }
+
+    if (!inDanger)
+        return false;
+
+    const Position& zuljinCenter = ZULJIN_TANK_POSITION;
+    constexpr float safeZoneRadius = 30.0f;
+
+    Position safestPos =
+        FindSafestNearbyPosition(bot, cyclones, zuljinCenter, safeZoneRadius, hazardRadius, true);
+
+    bot->AttackStop();
+    bot->InterruptNonMeleeSpells(true);
+    return MoveTo(ZULAMAN_MAP_ID, safestPos.GetPositionX(), safestPos.GetPositionY(),
+                  bot->GetPositionZ(), false, false, false, false,
+                  MovementPriority::MOVEMENT_FORCED, true, false);
+}
+
+bool ZuljinSpreadRangedAction::Execute(Event /*event*/)
+{
+    constexpr float minDistance = 6.0f;
+    constexpr uint32 minInterval = 1000;
+    if (Unit* nearestPlayer = GetNearestPlayerInRadius(bot, minDistance))
+        return FleePosition(nearestPlayer->GetPosition(), minDistance, minInterval);
+
+    return false;
+}

src/Ai/Raid/ZulAman/Action/RaidZulAmanActions.h

@@ -0,0 +1,253 @@
+/*
+ * 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_RAIDZULAMANACTIONS_H
+#define _PLAYERBOT_RAIDZULAMANACTIONS_H
+
+#include "Action.h"
+#include "AttackAction.h"
+#include "MovementActions.h"
+
+// Trash
+
+class AmanishiMedicineManMarkWardAction : public Action
+{
+public:
+    AmanishiMedicineManMarkWardAction(
+        PlayerbotAI* botAI, std::string const name = "amani'shi medicine man mark ward") : Action(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+// Akil'zon <Eagle Avatar>
+
+class AkilzonMisdirectBossToMainTankAction : public AttackAction
+{
+public:
+    AkilzonMisdirectBossToMainTankAction(
+        PlayerbotAI* botAI, std::string const name = "akil'zon misdirect boss to main tank") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class AkilzonTanksPositionBossAction : public AttackAction
+{
+public:
+    AkilzonTanksPositionBossAction(
+        PlayerbotAI* botAI, std::string const name = "akil'zon tanks position boss") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class AkilzonSpreadRangedAction : public MovementAction
+{
+public:
+    AkilzonSpreadRangedAction(
+        PlayerbotAI* botAI, std::string const name = "akil'zon spread ranged") : MovementAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class AkilzonMoveToEyeOfTheStormAction : public MovementAction
+{
+public:
+    AkilzonMoveToEyeOfTheStormAction(
+        PlayerbotAI* botAI, std::string const name = "akil'zon move to eye of the storm") : MovementAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class AkilzonManageElectricalStormTimerAction : public Action
+{
+public:
+    AkilzonManageElectricalStormTimerAction(
+        PlayerbotAI* botAI, std::string const name = "akil'zon manage electrical storm timer") : Action(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+// Nalorakk <Bear Avatar>
+
+class NalorakkMisdirectBossToMainTankAction : public AttackAction
+{
+public:
+    NalorakkMisdirectBossToMainTankAction(
+        PlayerbotAI* botAI, std::string const name = "nalorakk misdirect boss to main tank") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class NalorakkTanksPositionBossAction : public AttackAction
+{
+public:
+    NalorakkTanksPositionBossAction(
+        PlayerbotAI* botAI, std::string const name = "nalorakk tanks position boss") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+
+private:
+    bool MainTankPositionTrollForm(Unit* nalorakk);
+    bool FirstAssistTankPositionBearForm(Unit* nalorakk);
+};
+
+class NalorakkSpreadRangedAction : public MovementAction
+{
+public:
+    NalorakkSpreadRangedAction(
+        PlayerbotAI* botAI, std::string const name = "nalorakk spread ranged") : MovementAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+// Jan'alai <Dragonhawk Avatar>
+
+class JanalaiMisdirectBossToMainTankAction : public AttackAction
+{
+public:
+    JanalaiMisdirectBossToMainTankAction(
+        PlayerbotAI* botAI, std::string const name = "jan'alai misdirect boss to main tank") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class JanalaiTanksPositionBossAction : public AttackAction
+{
+public:
+    JanalaiTanksPositionBossAction(
+        PlayerbotAI* botAI, std::string const name = "jan'alai tanks position boss") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class JanalaiSpreadRangedInCircleAction : public MovementAction
+{
+public:
+    JanalaiSpreadRangedInCircleAction(
+        PlayerbotAI* botAI, std::string const name = "jan'alai spread ranged in circle") : MovementAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class JanalaiAvoidFireBombsAction : public MovementAction
+{
+public:
+    JanalaiAvoidFireBombsAction(PlayerbotAI* botAI, std::string const name = "jan'alai avoid fire bombs") : MovementAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class JanalaiMarkAmanishiHatchersAction : public Action
+{
+public:
+    JanalaiMarkAmanishiHatchersAction(
+        PlayerbotAI* botAI, std::string const name = "jan'alai mark amani'shi hatchers") : Action(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+// Halazzi <Lynx Avatar>
+
+class HalazziMisdirectBossToMainTankAction : public AttackAction
+{
+public:
+    HalazziMisdirectBossToMainTankAction(
+        PlayerbotAI* botAI, std::string const name = "halazzi misdirect boss to main tank") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class HalazziMainTankPositionBossAction : public AttackAction
+{
+public:
+    HalazziMainTankPositionBossAction(
+        PlayerbotAI* botAI, std::string const name = "halazzi main tank position boss") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class HalazziFirstAssistTankAttackSpiritLynxAction : public AttackAction
+{
+public:
+    HalazziFirstAssistTankAttackSpiritLynxAction(
+        PlayerbotAI* botAI, std::string const name = "halazzi first assist tank attack spirit lynx") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class HalazziAssignDpsPriorityAction : public AttackAction
+{
+public:
+    HalazziAssignDpsPriorityAction(
+        PlayerbotAI* botAI, std::string const name = "halazzi assign dps priority") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+// Hex Lord Malacrass
+
+class HexLordMalacrassMisdirectBossToMainTankAction : public AttackAction
+{
+public:
+    HexLordMalacrassMisdirectBossToMainTankAction(
+        PlayerbotAI* botAI, std::string const name = "hex lord malacrass misdirect boss to main tank") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class HexLordMalacrassAssignDpsPriorityAction : public AttackAction
+{
+public:
+    HexLordMalacrassAssignDpsPriorityAction(
+        PlayerbotAI* botAI, std::string const name = "hex lord malacrass assign dps priority") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class HexLordMalacrassRunAwayFromWhirlwindAction : public MovementAction
+{
+public:
+    HexLordMalacrassRunAwayFromWhirlwindAction(
+        PlayerbotAI* botAI, std::string const name = "hex lord malacrass run away from whirlwind") : MovementAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class HexLordMalacrassCastersStopAttackingAction : public Action
+{
+public:
+    HexLordMalacrassCastersStopAttackingAction(
+        PlayerbotAI* botAI, std::string const name = "hex lord malacrass casters stop attacking") : Action(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class HexLordMalacrassMoveAwayFromFreezingTrapAction : public MovementAction
+{
+public:
+    HexLordMalacrassMoveAwayFromFreezingTrapAction(
+        PlayerbotAI* botAI, std::string const name = "hex lord malacrass move away from freezing trap") : MovementAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+// Zul'jin
+
+class ZuljinMisdirectBossToMainTankAction : public AttackAction
+{
+public:
+    ZuljinMisdirectBossToMainTankAction(
+        PlayerbotAI* botAI, std::string const name = "zul'jin misdirect boss to main tank") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class ZuljinTanksPositionBossAction : public AttackAction
+{
+public:
+    ZuljinTanksPositionBossAction(
+        PlayerbotAI* botAI, std::string const name = "zul'jin tanks position boss") : AttackAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class ZuljinRunAwayFromWhirlwindAction : public MovementAction
+{
+public:
+    ZuljinRunAwayFromWhirlwindAction(
+        PlayerbotAI* botAI, std::string const name = "zul'jin run away from whirlwind") : MovementAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class ZuljinAvoidCyclonesAction : public MovementAction
+{
+public:
+    ZuljinAvoidCyclonesAction(PlayerbotAI* botAI, std::string const name = "zul'jin avoid cyclones") : MovementAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+class ZuljinSpreadRangedAction : public MovementAction
+{
+public:
+    ZuljinSpreadRangedAction(
+        PlayerbotAI* botAI, std::string const name = "zul'jin spread ranged") : MovementAction(botAI, name) {}
+    bool Execute(Event event) override;
+};
+
+#endif

src/Ai/Raid/ZulAman/Multiplier/RaidZulAmanMultipliers.cpp

@@ -0,0 +1,382 @@
+/*
+ * 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 "RaidZulAmanMultipliers.h"
+#include "RaidZulAmanActions.h"
+#include "RaidZulAmanHelpers.h"
+#include "ChooseTargetActions.h"
+#include "DKActions.h"
+#include "DruidBearActions.h"
+#include "FollowActions.h"
+#include "GenericSpellActions.h"
+#include "HunterActions.h"
+#include "MageActions.h"
+#include "PaladinActions.h"
+#include "Playerbots.h"
+#include "PriestActions.h"
+#include "RaidBossHelpers.h"
+#include "ReachTargetActions.h"
+#include "RogueActions.h"
+#include "ShamanActions.h"
+#include "WarlockActions.h"
+#include "WarriorActions.h"
+
+using namespace ZulAmanHelpers;
+
+// Akil'zon <Eagle Avatar>
+
+float AkilzonDisableCombatFormationMoveMultiplier::GetValue(Action* action)
+{
+    if (!AI_VALUE2(Unit*, "find target", "akil'zon"))
+        return 1.0f;
+
+    if (dynamic_cast<CombatFormationMoveAction*>(action) &&
+        !dynamic_cast<SetBehindTargetAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float AkilzonStayInEyeOfTheStormMultiplier::GetValue(Action* action)
+{
+    if (!AI_VALUE2(Unit*, "find target", "akil'zon") /* ||
+        !GetElectricalStormTarget(bot)*/)
+        return 1.0f;
+
+    auto it = akilzonStormTimer.find(bot->GetMap()->GetInstanceId());
+    if (it == akilzonStormTimer.end() ||
+        !IsInStormWindow(it->second, std::time(nullptr)))
+        return 1.0f;
+
+    if (dynamic_cast<CastReachTargetSpellAction*>(action) ||
+        dynamic_cast<CastKillingSpreeAction*>(action) ||
+        dynamic_cast<CastBlinkBackAction*>(action) ||
+        dynamic_cast<CastDisengageAction*>(action) ||
+        dynamic_cast<SetBehindTargetAction*>(action) ||
+        dynamic_cast<FleeAction*>(action) ||
+        dynamic_cast<FollowAction*>(action) ||
+        dynamic_cast<ReachTargetAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+// Nalorakk <Bear Avatar>
+
+float NalorakkDisableTankActionsMultiplier::GetValue(Action* action)
+{
+    if (!botAI->IsTank(bot))
+        return 1.0f;
+
+    Unit* nalorakk = AI_VALUE2(Unit*, "find target", "nalorakk");
+    if (!nalorakk)
+        return 1.0f;
+
+    if (dynamic_cast<TankFaceAction*>(action))
+        return 0.0f;
+
+    if (bot->GetVictim() == nullptr)
+        return 1.0f;
+
+    bool shouldTankBoss = false;
+
+    if (botAI->IsMainTank(bot) &&
+        !nalorakk->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_BEARFORM)))
+        shouldTankBoss = true;
+
+    if (botAI->IsAssistTankOfIndex(bot, 0, true) &&
+        nalorakk->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_BEARFORM)))
+        shouldTankBoss = true;
+
+    if (!shouldTankBoss &&
+        (dynamic_cast<TankAssistAction*>(action) ||
+         dynamic_cast<CastTauntAction*>(action) ||
+         dynamic_cast<CastGrowlAction*>(action) ||
+         dynamic_cast<CastHandOfReckoningAction*>(action) ||
+         dynamic_cast<CastDarkCommandAction*>(action)))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float NalorakkControlMisdirectionMultiplier::GetValue(Action* action)
+{
+    if (bot->getClass() != CLASS_HUNTER ||
+        !AI_VALUE2(Unit*, "find target", "nalorakk"))
+        return 1.0f;
+
+    if (dynamic_cast<CastMisdirectionOnMainTankAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+// Jan'alai <Dragonhawk Avatar>
+
+float JanalaiDisableTankActionsMultiplier::GetValue(Action* action)
+{
+    if (!botAI->IsTank(bot) ||
+        !AI_VALUE2(Unit*, "find target", "jan'alai"))
+        return 1.0f;
+
+    if (dynamic_cast<TankFaceAction*>(action))
+        return 0.0f;
+
+    if (bot->GetVictim() == nullptr)
+        return 1.0f;
+
+    if (botAI->IsMainTank(bot) &&
+        dynamic_cast<TankAssistAction*>(action))
+        return 0.0f;
+
+    if (botAI->IsAssistTank(bot) &&
+        !GetFirstAliveUnitByEntry(
+            botAI, static_cast<uint32>(ZulAmanNPCs::NPC_AMANI_DRAGONHAWK_HATCHLING)) &&
+        dynamic_cast<TankAssistAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float JanalaiDisableCombatFormationMoveMultiplier::GetValue(Action* action)
+{
+    if (!AI_VALUE2(Unit*, "find target", "jan'alai"))
+        return 1.0f;
+
+    if (dynamic_cast<CombatFormationMoveAction*>(action) &&
+        !dynamic_cast<SetBehindTargetAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float JanalaiStayAwayFromFireBombsMultiplier::GetValue(Action* action)
+{
+    if (!AI_VALUE2(Unit*, "find target", "jan'alai"))
+        return 1.0f;
+
+    if (!HasFireBombNearby(botAI, bot))
+        return 1.0f;
+
+    if (dynamic_cast<CastReachTargetSpellAction*>(action) ||
+        dynamic_cast<CastKillingSpreeAction*>(action) ||
+        dynamic_cast<CastBlinkBackAction*>(action) ||
+        dynamic_cast<CastDisengageAction*>(action) ||
+        dynamic_cast<FleeAction*>(action) ||
+        dynamic_cast<FollowAction*>(action) ||
+        dynamic_cast<ReachTargetAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float JanalaiDoNotCrowdControlHatchersMultiplier::GetValue(Action* action)
+{
+    if (!AI_VALUE2(Unit*, "find target", "amani'shi hatcher"))
+        return 1.0f;
+
+    if (dynamic_cast<CastCrowdControlSpellAction*>(action) ||
+        dynamic_cast<CastPolymorphAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float JanalaiDelayBloodlustAndHeroismMultiplier::GetValue(Action* action)
+{
+    if (bot->getClass() != CLASS_SHAMAN)
+        return 1.0f;
+
+    if (!AI_VALUE2(Unit*, "find target", "jan'alai"))
+        return 1.0f;
+
+    if (AI_VALUE2(Unit*, "find target", "amani dragonhawk hatchling"))
+        return 1.0f;
+
+    if (dynamic_cast<CastBloodlustAction*>(action) ||
+        dynamic_cast<CastHeroismAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+// Halazzi <Lynx Avatar>
+
+float HalazziDisableTankActionsMultiplier::GetValue(Action* action)
+{
+    if (!botAI->IsTank(bot) ||
+        !AI_VALUE2(Unit*, "find target", "halazzi"))
+        return 1.0f;
+
+    if (dynamic_cast<TankFaceAction*>(action))
+        return 0.0f;
+
+    if (bot->GetVictim() != nullptr &&
+        dynamic_cast<TankAssistAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float HalazziControlMisdirectionMultiplier::GetValue(Action* action)
+{
+    if (bot->getClass() != CLASS_HUNTER ||
+        !AI_VALUE2(Unit*, "find target", "halazzi"))
+        return 1.0f;
+
+    if (dynamic_cast<CastMisdirectionOnMainTankAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+// Hex Lord Malacrass
+
+float HexLordMalacrassAvoidWhirlwindMultiplier::GetValue(Action* action)
+{
+    if (botAI->IsMainTank(bot))
+        return 1.0f;
+
+    Unit* malacrass = AI_VALUE2(Unit*, "find target", "hex lord malacrass");
+    if (!malacrass ||
+        !malacrass->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_HEX_LORD_WHIRLWIND)))
+        return 1.0f;
+
+    if (dynamic_cast<CastReachTargetSpellAction*>(action) ||
+        dynamic_cast<CastKillingSpreeAction*>(action) ||
+        dynamic_cast<ReachTargetAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float HexLordMalacrassStopAttackingDuringSpellReflectionMultiplier::GetValue(Action* action)
+{
+    if (!botAI->IsCaster(bot))
+        return 1.0f;
+
+    Unit* malacrass = AI_VALUE2(Unit*, "find target", "hex lord malacrass");
+    if (!malacrass ||
+        !malacrass->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_HEX_LORD_SPELL_REFLECTION)))
+        return 1.0f;
+
+    auto castSpellAction = dynamic_cast<CastSpellAction*>(action);
+    if (!castSpellAction)
+        return 1.0f;
+
+    if (castSpellAction->getThreatType() == Action::ActionThreatType::Aoe ||
+        (bot->GetVictim() == malacrass &&
+         castSpellAction->getThreatType() == Action::ActionThreatType::Single))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float HexLordMalacrassDoNotDispelUnstableAfflictionMultiplier::GetValue(Action* action)
+{
+    if (bot->getClass() != CLASS_PRIEST &&
+        bot->getClass() != CLASS_PALADIN &&
+        bot->getClass() != CLASS_WARLOCK)
+        return 1.0f;
+
+    if (!AI_VALUE2(Unit*, "find target", "hex lord malacrass"))
+        return 1.0f;
+
+    Group* group = bot->GetGroup();
+    if (!group)
+        return 1.0f;
+
+    bool hasUnstableAffliction = false;
+    for (GroupReference* ref = bot->GetGroup()->GetFirstMember(); ref != nullptr; ref = ref->next())
+    {
+        Player* member = ref->GetSource();
+        if (!member || !member->IsAlive())
+            continue;
+
+        if (member->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_UNSTABLE_AFFLICTION)))
+        {
+            hasUnstableAffliction = true;
+            break;
+        }
+    }
+
+    if (!hasUnstableAffliction)
+        return 1.0f;
+
+    if (dynamic_cast<CastDevourMagicCleanseAction*>(action) ||
+        dynamic_cast<CastDispelMagicAction*>(action) ||
+        dynamic_cast<CastDispelMagicOnPartyAction*>(action) ||
+        dynamic_cast<CastMassDispelAction*>(action) ||
+        dynamic_cast<CastPurgeAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+// Zul'jin
+
+float ZuljinDisableTankFaceMultiplier::GetValue(Action* action)
+{
+    if (!botAI->IsTank(bot))
+        return 1.0f;
+
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    if (!zuljin ||
+        zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_SHAPE_OF_THE_DRAGONHAWK)))
+        return 1.0f;
+
+    if (dynamic_cast<TankFaceAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float ZuljinAvoidWhirlwindMultiplier::GetValue(Action* action)
+{
+    if (botAI->IsMainTank(bot))
+        return 1.0f;
+
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    if (!zuljin ||
+        !zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_ZULJIN_WHIRLWIND)))
+        return 1.0f;
+
+    if (dynamic_cast<CastReachTargetSpellAction*>(action) ||
+        dynamic_cast<CastKillingSpreeAction*>(action) ||
+        dynamic_cast<ReachTargetAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float ZuljinDisableAvoidAoeMultiplier::GetValue(Action* action)
+{
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    if (!zuljin ||
+        !zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_SHAPE_OF_THE_EAGLE)))
+        return 1.0f;
+
+    if (dynamic_cast<AvoidAoeAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}
+
+float ZuljinDelayBloodlustAndHeroismMultiplier::GetValue(Action* action)
+{
+    if (bot->getClass() != CLASS_SHAMAN)
+        return 1.0f;
+
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    if (!zuljin ||
+        zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_SHAPE_OF_THE_EAGLE)))
+        return 1.0f;
+
+    if (dynamic_cast<CastBloodlustAction*>(action) ||
+        dynamic_cast<CastHeroismAction*>(action))
+        return 0.0f;
+
+    return 1.0f;
+}

src/Ai/Raid/ZulAman/Multiplier/RaidZulAmanMultipliers.h

@@ -0,0 +1,167 @@
+/*
+ * 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_RAIDZULAMANMULTIPLIERS_H
+#define _PLAYERBOT_RAIDZULAMANMULTIPLIERS_H
+
+#include "Multiplier.h"
+
+// Akil'zon <Eagle Avatar>
+
+class AkilzonDisableCombatFormationMoveMultiplier : public Multiplier
+{
+public:
+    AkilzonDisableCombatFormationMoveMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "akil'zon disable combat formation move") {}
+    virtual float GetValue(Action* action);
+};
+
+class AkilzonStayInEyeOfTheStormMultiplier : public Multiplier
+{
+public:
+    AkilzonStayInEyeOfTheStormMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "akil'zon stay in eye of the storm") {}
+    virtual float GetValue(Action* action);
+};
+
+// Nalorakk <Bear Avatar>
+
+class NalorakkDisableTankActionsMultiplier : public Multiplier
+{
+public:
+    NalorakkDisableTankActionsMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "nalorakk disable tank actions") {}
+    virtual float GetValue(Action* action);
+};
+
+class NalorakkControlMisdirectionMultiplier : public Multiplier
+{
+public:
+    NalorakkControlMisdirectionMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "nalorakk control misdirection") {}
+    virtual float GetValue(Action* action);
+};
+
+// Jan'alai <Dragonhawk Avatar>
+
+class JanalaiDisableTankActionsMultiplier : public Multiplier
+{
+public:
+    JanalaiDisableTankActionsMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "jan'alai disable tank actions") {}
+    virtual float GetValue(Action* action);
+};
+
+class JanalaiDisableCombatFormationMoveMultiplier : public Multiplier
+{
+public:
+    JanalaiDisableCombatFormationMoveMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "jan'alai disable combat formation move") {}
+    virtual float GetValue(Action* action);
+};
+
+class JanalaiStayAwayFromFireBombsMultiplier : public Multiplier
+{
+public:
+    JanalaiStayAwayFromFireBombsMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "jan'alai stay away from fire bombs") {}
+    virtual float GetValue(Action* action);
+};
+
+class JanalaiDoNotCrowdControlHatchersMultiplier : public Multiplier
+{
+public:
+    JanalaiDoNotCrowdControlHatchersMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "jan'alai do not crowd control hatchers") {}
+    virtual float GetValue(Action* action);
+};
+
+class JanalaiDelayBloodlustAndHeroismMultiplier : public Multiplier
+{
+public:
+    JanalaiDelayBloodlustAndHeroismMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "jan'alai delay bloodlust and heroism") {}
+    virtual float GetValue(Action* action);
+};
+
+// Halazzi <Lynx Avatar>
+
+class HalazziDisableTankActionsMultiplier : public Multiplier
+{
+public:
+    HalazziDisableTankActionsMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "halazzi disable tank actions") {}
+    virtual float GetValue(Action* action);
+};
+
+class HalazziControlMisdirectionMultiplier : public Multiplier
+{
+public:
+    HalazziControlMisdirectionMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "halazzi control misdirection") {}
+    virtual float GetValue(Action* action);
+};
+
+// Hex Lord Malacrass
+
+class HexLordMalacrassAvoidWhirlwindMultiplier : public Multiplier
+{
+public:
+    HexLordMalacrassAvoidWhirlwindMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "hex lord malacrass avoid whirlwind") {}
+    virtual float GetValue(Action* action);
+};
+
+class HexLordMalacrassDoNotDispelUnstableAfflictionMultiplier : public Multiplier
+{
+public:
+    HexLordMalacrassDoNotDispelUnstableAfflictionMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "hex lord malacrass do not dispel unstable affliction") {}
+    virtual float GetValue(Action* action);
+};
+
+class HexLordMalacrassStopAttackingDuringSpellReflectionMultiplier : public Multiplier
+{
+public:
+    HexLordMalacrassStopAttackingDuringSpellReflectionMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "hex lord malacrass stop attacking during spell reflection") {}
+    virtual float GetValue(Action* action);
+};
+
+// Zul'jin
+
+class ZuljinDisableTankFaceMultiplier : public Multiplier
+{
+public:
+    ZuljinDisableTankFaceMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "zul'jin disable tank face") {}
+    virtual float GetValue(Action* action);
+};
+
+class ZuljinAvoidWhirlwindMultiplier : public Multiplier
+{
+public:
+    ZuljinAvoidWhirlwindMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "zul'jin avoid whirlwind") {}
+    virtual float GetValue(Action* action);
+};
+
+class ZuljinDisableAvoidAoeMultiplier : public Multiplier
+{
+public:
+    ZuljinDisableAvoidAoeMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "zul'jin disable avoid aoe") {}
+    virtual float GetValue(Action* action);
+};
+
+class ZuljinDelayBloodlustAndHeroismMultiplier : public Multiplier
+{
+public:
+    ZuljinDelayBloodlustAndHeroismMultiplier(PlayerbotAI* botAI) : Multiplier(
+        botAI, "zul'jin delay bloodlust and heroism") {}
+    virtual float GetValue(Action* action);
+};
+
+#endif

src/Ai/Raid/ZulAman/RaidZulAmanActionContext.h

@@ -0,0 +1,202 @@
+/*
+ * 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_RAIDZULAMANACTIONCONTEXT_H
+#define _PLAYERBOT_RAIDZULAMANACTIONCONTEXT_H
+
+#include "RaidZulAmanActions.h"
+#include "NamedObjectContext.h"
+
+class RaidZulAmanActionContext : public NamedObjectContext<Action>
+{
+public:
+    RaidZulAmanActionContext()
+    {
+        // Trash
+        creators["amani'shi medicine man mark ward"] =
+            &RaidZulAmanActionContext::amanishi_medicine_man_mark_ward;
+
+        // Akil'zon <Eagle Avatar>
+        creators["akil'zon misdirect boss to main tank"] =
+            &RaidZulAmanActionContext::akilzon_misdirect_boss_to_main_tank;
+
+        creators["akil'zon tanks position boss"] =
+            &RaidZulAmanActionContext::akilzon_tanks_position_boss;
+
+        creators["akil'zon spread ranged"] =
+            &RaidZulAmanActionContext::akilzon_spread_ranged;
+
+        creators["akil'zon move to eye of the storm"] =
+            &RaidZulAmanActionContext::akilzon_move_to_eye_of_the_storm;
+
+        creators["akil'zon manage electrical storm timer"] =
+            &RaidZulAmanActionContext::akilzon_manage_electrical_storm_timer;
+
+        // Nalorakk <Bear Avatar>
+        creators["nalorakk misdirect boss to main tank"] =
+            &RaidZulAmanActionContext::nalorakk_misdirect_boss_to_main_tank;
+
+        creators["nalorakk tanks position boss"] =
+            &RaidZulAmanActionContext::nalorakk_tanks_position_boss;
+
+        creators["nalorakk spread ranged"] =
+            &RaidZulAmanActionContext::nalorakk_spread_ranged;
+
+        // Jan'alai <Dragonhawk Avatar>
+        creators["jan'alai misdirect boss to main tank"] =
+            &RaidZulAmanActionContext::janalai_misdirect_boss_to_main_tank;
+
+        creators["jan'alai tanks position boss"] =
+            &RaidZulAmanActionContext::janalai_tanks_position_boss;
+
+        creators["jan'alai spread ranged in circle"] =
+            &RaidZulAmanActionContext::janalai_spread_ranged_in_circle;
+
+        creators["jan'alai avoid fire bombs"] =
+            &RaidZulAmanActionContext::janalai_avoid_fire_bombs;
+
+        creators["jan'alai mark amani'shi hatchers"] =
+            &RaidZulAmanActionContext::janalai_mark_amanishi_hatchers;
+
+        // Halazzi <Lynx Avatar>
+        creators["halazzi misdirect boss to main tank"] =
+            &RaidZulAmanActionContext::halazzi_misdirect_boss_to_main_tank;
+
+        creators["halazzi main tank position boss"] =
+            &RaidZulAmanActionContext::halazzi_main_tank_position_boss;
+
+        creators["halazzi first assist tank attack spirit lynx"] =
+            &RaidZulAmanActionContext::halazzi_first_assist_tank_attack_spirit_lynx;
+
+        creators["halazzi assign dps priority"] =
+            &RaidZulAmanActionContext::halazzi_assign_dps_priority;
+
+        // Hex Lord Malacrass
+        creators["hex lord malacrass misdirect boss to main tank"] =
+            &RaidZulAmanActionContext::hex_lord_malacrass_misdirect_boss_to_main_tank;
+
+        creators["hex lord malacrass assign dps priority"] =
+            &RaidZulAmanActionContext::hex_lord_malacrass_assign_dps_priority;
+
+        creators["hex lord malacrass run away from whirlwind"] =
+            &RaidZulAmanActionContext::hex_lord_malacrass_run_away_from_whirlwind;
+
+        creators["hex lord malacrass casters stop attacking"] =
+            &RaidZulAmanActionContext::hex_lord_malacrass_casters_stop_attacking;
+
+        creators["hex lord malacrass move away from freezing trap"] =
+            &RaidZulAmanActionContext::hex_lord_malacrass_move_away_from_freezing_trap;
+
+        // Zul'jin
+        creators["zul'jin misdirect boss to main tank"] =
+            &RaidZulAmanActionContext::zuljin_misdirect_boss_to_main_tank;
+
+        creators["zul'jin tanks position boss"] =
+            &RaidZulAmanActionContext::zuljin_tanks_position_boss;
+
+        creators["zul'jin run away from whirlwind"] =
+            &RaidZulAmanActionContext::zuljin_run_away_from_whirlwind;
+
+        creators["zul'jin avoid cyclones"] =
+            &RaidZulAmanActionContext::zuljin_avoid_cyclones;
+
+        creators["zul'jin spread ranged"] =
+            &RaidZulAmanActionContext::zuljin_spread_ranged;
+    }
+
+private:
+    // Trash
+    static Action* amanishi_medicine_man_mark_ward(
+        PlayerbotAI* botAI) { return new AmanishiMedicineManMarkWardAction(botAI); }
+
+    // Akil'zon <Eagle Avatar>
+    static Action* akilzon_misdirect_boss_to_main_tank(
+        PlayerbotAI* botAI) { return new AkilzonMisdirectBossToMainTankAction(botAI); }
+
+    static Action* akilzon_tanks_position_boss(
+        PlayerbotAI* botAI) { return new AkilzonTanksPositionBossAction(botAI); }
+
+    static Action* akilzon_spread_ranged(
+        PlayerbotAI* botAI) { return new AkilzonSpreadRangedAction(botAI); }
+
+    static Action* akilzon_move_to_eye_of_the_storm(
+        PlayerbotAI* botAI) { return new AkilzonMoveToEyeOfTheStormAction(botAI); }
+
+    static Action* akilzon_manage_electrical_storm_timer(
+        PlayerbotAI* botAI) { return new AkilzonManageElectricalStormTimerAction(botAI); }
+
+    // Nalorakk <Bear Avatar>
+    static Action* nalorakk_misdirect_boss_to_main_tank(
+        PlayerbotAI* botAI) { return new NalorakkMisdirectBossToMainTankAction(botAI); }
+
+    static Action* nalorakk_tanks_position_boss(
+        PlayerbotAI* botAI) { return new NalorakkTanksPositionBossAction(botAI); }
+
+    static Action* nalorakk_spread_ranged(
+        PlayerbotAI* botAI) { return new NalorakkSpreadRangedAction(botAI); }
+
+    // Jan'alai <Dragonhawk Avatar>
+    static Action* janalai_misdirect_boss_to_main_tank(
+        PlayerbotAI* botAI) { return new JanalaiMisdirectBossToMainTankAction(botAI); }
+
+    static Action* janalai_tanks_position_boss(
+        PlayerbotAI* botAI) { return new JanalaiTanksPositionBossAction(botAI); }
+
+    static Action* janalai_spread_ranged_in_circle(
+        PlayerbotAI* botAI) { return new JanalaiSpreadRangedInCircleAction(botAI); }
+
+    static Action* janalai_avoid_fire_bombs(
+        PlayerbotAI* botAI) { return new JanalaiAvoidFireBombsAction(botAI); }
+
+    static Action* janalai_mark_amanishi_hatchers(
+        PlayerbotAI* botAI) { return new JanalaiMarkAmanishiHatchersAction(botAI); }
+
+    // Halazzi <Lynx Avatar>
+    static Action* halazzi_misdirect_boss_to_main_tank(
+        PlayerbotAI* botAI) { return new HalazziMisdirectBossToMainTankAction(botAI); }
+
+    static Action* halazzi_main_tank_position_boss(
+        PlayerbotAI* botAI) { return new HalazziMainTankPositionBossAction(botAI); }
+
+    static Action* halazzi_first_assist_tank_attack_spirit_lynx(
+        PlayerbotAI* botAI) { return new HalazziFirstAssistTankAttackSpiritLynxAction(botAI); }
+
+    static Action* halazzi_assign_dps_priority(
+        PlayerbotAI* botAI) { return new HalazziAssignDpsPriorityAction(botAI); }
+
+    // Hex Lord Malacrass
+    static Action* hex_lord_malacrass_misdirect_boss_to_main_tank(
+        PlayerbotAI* botAI) { return new HexLordMalacrassMisdirectBossToMainTankAction(botAI); }
+
+    static Action* hex_lord_malacrass_assign_dps_priority(
+        PlayerbotAI* botAI) { return new HexLordMalacrassAssignDpsPriorityAction(botAI); }
+
+    static Action* hex_lord_malacrass_run_away_from_whirlwind(
+        PlayerbotAI* botAI) { return new HexLordMalacrassRunAwayFromWhirlwindAction(botAI); }
+
+    static Action* hex_lord_malacrass_casters_stop_attacking(
+        PlayerbotAI* botAI) { return new HexLordMalacrassCastersStopAttackingAction(botAI); }
+
+    static Action* hex_lord_malacrass_move_away_from_freezing_trap(
+        PlayerbotAI* botAI) { return new HexLordMalacrassMoveAwayFromFreezingTrapAction(botAI); }
+
+    // Zul'jin
+    static Action* zuljin_misdirect_boss_to_main_tank(
+        PlayerbotAI* botAI) { return new ZuljinMisdirectBossToMainTankAction(botAI); }
+
+    static Action* zuljin_tanks_position_boss(
+        PlayerbotAI* botAI) { return new ZuljinTanksPositionBossAction(botAI); }
+
+    static Action* zuljin_run_away_from_whirlwind(
+        PlayerbotAI* botAI) { return new ZuljinRunAwayFromWhirlwindAction(botAI); }
+
+    static Action* zuljin_avoid_cyclones(
+        PlayerbotAI* botAI) { return new ZuljinAvoidCyclonesAction(botAI); }
+
+    static Action* zuljin_spread_ranged(
+        PlayerbotAI* botAI) { return new ZuljinSpreadRangedAction(botAI); }
+};
+
+#endif

src/Ai/Raid/ZulAman/RaidZulAmanTriggerContext.h

@@ -0,0 +1,206 @@
+/*
+ * 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_RAIDZULAMANTRIGGERCONTEXT_H
+#define _PLAYERBOT_RAIDZULAMANTRIGGERCONTEXT_H
+
+#include "RaidZulAmanTriggers.h"
+#include "AiObjectContext.h"
+
+class RaidZulAmanTriggerContext : public NamedObjectContext<Trigger>
+{
+public:
+    RaidZulAmanTriggerContext()
+    {
+        // Trash
+        creators["amani'shi medicine man summoned ward"] =
+            &RaidZulAmanTriggerContext::amanishi_medicine_man_summoned_ward;
+
+        // Akil'zon <Eagle Avatar>
+        creators["akil'zon pulling boss"] =
+            &RaidZulAmanTriggerContext::akilzon_pulling_boss;
+
+        creators["akil'zon boss engaged by tanks"] =
+            &RaidZulAmanTriggerContext::akilzon_boss_engaged_by_tanks;
+
+        creators["akil'zon boss casts static disruption"] =
+            &RaidZulAmanTriggerContext::akilzon_boss_casts_static_disruption;
+
+        creators["akil'zon electrical storm incoming"] =
+            &RaidZulAmanTriggerContext::akilzon_electrical_storm_incoming;
+
+        creators["akil'zon bots need to prepare for electrical storm"] =
+            &RaidZulAmanTriggerContext::akilzon_bots_need_to_prepare_for_electrical_storm;
+
+        // Nalorakk <Bear Avatar>
+        creators["nalorakk pulling boss"] =
+            &RaidZulAmanTriggerContext::nalorakk_pulling_boss;
+
+        creators["nalorakk boss casts surge"] =
+            &RaidZulAmanTriggerContext::nalorakk_boss_casts_surge;
+
+        creators["nalorakk boss switches forms"] =
+            &RaidZulAmanTriggerContext::nalorakk_boss_switches_forms;
+
+        // Jan'alai <Dragonhawk Avatar>
+        creators["jan'alai pulling boss"] =
+            &RaidZulAmanTriggerContext::janalai_pulling_boss;
+
+        creators["jan'alai boss engaged by tanks"] =
+            &RaidZulAmanTriggerContext::janalai_boss_engaged_by_tanks;
+
+        creators["jan'alai boss casts flame breath"] =
+            &RaidZulAmanTriggerContext::janalai_boss_casts_flame_breath;
+
+        creators["jan'alai boss summoning fire bombs"] =
+            &RaidZulAmanTriggerContext::janalai_boss_summoning_fire_bombs;
+
+        creators["jan'alai amani'shi hatchers spawned"] =
+            &RaidZulAmanTriggerContext::janalai_amanishi_hatchers_spawned;
+
+        // Halazzi <Lynx Avatar>
+        creators["halazzi pulling boss"] =
+            &RaidZulAmanTriggerContext::halazzi_pulling_boss;
+
+        creators["halazzi boss engaged by main tank"] =
+            &RaidZulAmanTriggerContext::halazzi_boss_engaged_by_main_tank;
+
+        creators["halazzi boss summons spirit lynx"] =
+            &RaidZulAmanTriggerContext::halazzi_boss_summons_spirit_lynx;
+
+        creators["halazzi determining dps target"] =
+            &RaidZulAmanTriggerContext::halazzi_determining_dps_target;
+
+        // Hex Lord Malacrass
+
+        creators["hex lord malacrass pulling boss"] =
+            &RaidZulAmanTriggerContext::hex_lord_malacrass_pulling_boss;
+
+        creators["hex lord malacrass determining kill order"] =
+            &RaidZulAmanTriggerContext::hex_lord_malacrass_determining_kill_order;
+
+        creators["hex lord malacrass boss is channeling whirlwind"] =
+            &RaidZulAmanTriggerContext::hex_lord_malacrass_boss_is_channeling_whirlwind;
+
+        creators["hex lord malacrass boss has spell reflection"] =
+            &RaidZulAmanTriggerContext::hex_lord_malacrass_boss_has_spell_reflection;
+
+        creators["hex lord malacrass boss placed freezing trap"] =
+            &RaidZulAmanTriggerContext::hex_lord_malacrass_boss_placed_freezing_trap;
+
+        // Zul'jin
+
+        creators["zul'jin main tank needs aggro upon pull or phase change"] =
+            &RaidZulAmanTriggerContext::zuljin_main_tank_needs_aggro_upon_pull_or_phase_change;
+
+        creators["zul'jin boss engaged by tanks"] =
+            &RaidZulAmanTriggerContext::zuljin_boss_engaged_by_tanks;
+
+        creators["zul'jin boss is channeling whirlwind in troll form"] =
+            &RaidZulAmanTriggerContext::zuljin_boss_is_channeling_whirlwind_in_troll_form;
+
+        creators["zul'jin boss is summoning cyclones in eagle form"] =
+            &RaidZulAmanTriggerContext::zuljin_boss_is_summoning_cyclones_in_eagle_form;
+
+        creators["zul'jin boss casts aoe abilities in dragonhawk form"] =
+            &RaidZulAmanTriggerContext::zuljin_boss_casts_aoe_abilities_in_dragonhawk_form;
+    }
+
+private:
+    // Trash
+    static Trigger* amanishi_medicine_man_summoned_ward(
+        PlayerbotAI* botAI) { return new AmanishiMedicineManSummonedWardTrigger(botAI); }
+
+    // Akil'zon <Eagle Avatar>
+    static Trigger* akilzon_pulling_boss(
+        PlayerbotAI* botAI) { return new AkilzonPullingBossTrigger(botAI); }
+
+    static Trigger* akilzon_boss_engaged_by_tanks(
+        PlayerbotAI* botAI) { return new AkilzonBossEngagedByTanksTrigger(botAI); }
+
+    static Trigger* akilzon_boss_casts_static_disruption(
+        PlayerbotAI* botAI) { return new AkilzonBossCastsStaticDisruptionTrigger(botAI); }
+
+    static Trigger* akilzon_electrical_storm_incoming(
+        PlayerbotAI* botAI) { return new AkilzonElectricalStormIncomingTrigger(botAI); }
+
+    static Trigger* akilzon_bots_need_to_prepare_for_electrical_storm(
+        PlayerbotAI* botAI) { return new AkilzonBotsNeedToPrepareForElectricalStormTrigger(botAI); }
+
+    // Nalorakk <Bear Avatar>
+    static Trigger* nalorakk_pulling_boss(
+        PlayerbotAI* botAI) { return new NalorakkPullingBossTrigger(botAI); }
+
+    static Trigger* nalorakk_boss_casts_surge(
+        PlayerbotAI* botAI) { return new NalorakkBossCastsSurgeTrigger(botAI); }
+
+    static Trigger* nalorakk_boss_switches_forms(
+        PlayerbotAI* botAI) { return new NalorakkBossSwitchesFormsTrigger(botAI); }
+
+    // Jan'alai <Dragonhawk Avatar>
+    static Trigger* janalai_pulling_boss(
+        PlayerbotAI* botAI) { return new JanalaiPullingBossTrigger(botAI); }
+
+    static Trigger* janalai_boss_engaged_by_tanks(
+        PlayerbotAI* botAI) { return new JanalaiBossEngagedByTanksTrigger(botAI); }
+
+    static Trigger* janalai_boss_casts_flame_breath(
+        PlayerbotAI* botAI) { return new JanalaiBossCastsFlameBreathTrigger(botAI); }
+
+    static Trigger* janalai_boss_summoning_fire_bombs(
+        PlayerbotAI* botAI) { return new JanalaiBossSummoningFireBombsTrigger(botAI); }
+
+    static Trigger* janalai_amanishi_hatchers_spawned(
+        PlayerbotAI* botAI) { return new JanalaiAmanishiHatchersSpawnedTrigger(botAI); }
+
+    // Halazzi <Lynx Avatar>
+    static Trigger* halazzi_pulling_boss(
+        PlayerbotAI* botAI) { return new HalazziPullingBossTrigger(botAI); }
+
+    static Trigger* halazzi_boss_engaged_by_main_tank(
+        PlayerbotAI* botAI) { return new HalazziBossEngagedByMainTankTrigger(botAI); }
+
+    static Trigger* halazzi_boss_summons_spirit_lynx(
+        PlayerbotAI* botAI) { return new HalazziBossSummonsSpiritLynxTrigger(botAI); }
+
+    static Trigger* halazzi_determining_dps_target(
+        PlayerbotAI* botAI) { return new HalazziDeterminingDpsTargetTrigger(botAI); }
+
+    // Hex Lord Malacrass
+
+    static Trigger* hex_lord_malacrass_pulling_boss(
+        PlayerbotAI* botAI) { return new HexLordMalacrassPullingBossTrigger(botAI); }
+
+    static Trigger* hex_lord_malacrass_determining_kill_order(
+        PlayerbotAI* botAI) { return new HexLordMalacrassDeterminingKillOrderTrigger(botAI); }
+
+    static Trigger* hex_lord_malacrass_boss_is_channeling_whirlwind(
+        PlayerbotAI* botAI) { return new HexLordMalacrassBossIsChannelingWhirlwindTrigger(botAI); }
+
+    static Trigger* hex_lord_malacrass_boss_has_spell_reflection(
+        PlayerbotAI* botAI) { return new HexLordMalacrassBossHasSpellReflectionTrigger(botAI); }
+
+    static Trigger* hex_lord_malacrass_boss_placed_freezing_trap(
+        PlayerbotAI* botAI) { return new HexLordMalacrassBossPlacedFreezingTrapTrigger(botAI); }
+
+    // Zul'jin
+
+    static Trigger* zuljin_boss_engaged_by_tanks(
+        PlayerbotAI* botAI) { return new ZuljinBossEngagedByTanksTrigger(botAI); }
+
+    static Trigger* zuljin_main_tank_needs_aggro_upon_pull_or_phase_change(
+        PlayerbotAI* botAI) { return new ZuljinMainTankNeedsAggroUponPullOrPhaseChangeTrigger(botAI); }
+
+    static Trigger* zuljin_boss_is_channeling_whirlwind_in_troll_form(
+        PlayerbotAI* botAI) { return new ZuljinBossIsChannelingWhirlwindInTrollFormTrigger(botAI); }
+
+    static Trigger* zuljin_boss_is_summoning_cyclones_in_eagle_form(
+        PlayerbotAI* botAI) { return new ZuljinBossIsSummoningCyclonesInEagleFormTrigger(botAI); }
+
+    static Trigger* zuljin_boss_casts_aoe_abilities_in_dragonhawk_form(
+        PlayerbotAI* botAI) { return new ZuljinBossCastsAoeAbilitiesInDragonhawkFormTrigger(botAI); }
+};
+
+#endif

src/Ai/Raid/ZulAman/Strategy/RaidZulAmanStrategy.cpp

@@ -0,0 +1,134 @@
+/*
+ * 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 "RaidZulAmanStrategy.h"
+#include "RaidZulAmanMultipliers.h"
+
+void RaidZulAmanStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
+{
+    // Trash
+    triggers.push_back(new TriggerNode("amani'shi medicine man summoned ward", {
+        NextAction("amani'shi medicine man mark ward", ACTION_RAID + 1) }));
+
+    // Akil'zon <Eagle Avatar>
+    triggers.push_back(new TriggerNode("akil'zon pulling boss", {
+        NextAction("akil'zon misdirect boss to main tank", ACTION_RAID + 2) }));
+
+    triggers.push_back(new TriggerNode("akil'zon boss engaged by main tank", {
+        NextAction("akil'zon main tank position boss", ACTION_RAID + 1) }));
+
+    triggers.push_back(new TriggerNode("akil'zon boss casts static disruption", {
+        NextAction("akil'zon spread ranged", ACTION_RAID + 1) }));
+
+    triggers.push_back(new TriggerNode("akil'zon electrical storm incoming", {
+        NextAction("akil'zon move to eye of the storm", ACTION_EMERGENCY + 6) }));
+
+    triggers.push_back(new TriggerNode("akil'zon bots need to prepare for electrical storm", {
+        NextAction("akil'zon manage electrical storm timer", ACTION_EMERGENCY + 10) }));
+
+    // Nalorakk <Bear Avatar>
+    triggers.push_back(new TriggerNode("nalorakk pulling boss", {
+        NextAction("nalorakk misdirect boss to main tank", ACTION_RAID + 1) }));
+
+    triggers.push_back(new TriggerNode("nalorakk boss switches forms", {
+        NextAction("nalorakk tanks position boss", ACTION_EMERGENCY + 1) }));
+
+    triggers.push_back(new TriggerNode("nalorakk boss casts surge", {
+        NextAction("nalorakk spread ranged", ACTION_RAID + 1) }));
+
+    // Jan'alai <Dragonhawk Avatar>
+    triggers.push_back(new TriggerNode("jan'alai pulling boss", {
+        NextAction("jan'alai misdirect boss to main tank", ACTION_RAID + 2) }));
+
+    triggers.push_back(new TriggerNode("jan'alai boss engaged by main tank", {
+        NextAction("jan'alai main tank position boss", ACTION_RAID + 1) }));
+
+    triggers.push_back(new TriggerNode("jan'alai boss casts flame breath", {
+        NextAction("jan'alai spread ranged in circle", ACTION_RAID + 1) }));
+
+    triggers.push_back(new TriggerNode("jan'alai boss summoning fire bombs", {
+        NextAction("jan'alai avoid fire bombs", ACTION_EMERGENCY + 6) }));
+
+    triggers.push_back(new TriggerNode("jan'alai amani'shi hatchers spawned", {
+        NextAction("jan'alai mark amani'shi hatchers", ACTION_RAID + 2) }));
+
+    // Halazzi <Lynx Avatar>
+    triggers.push_back(new TriggerNode("halazzi pulling boss", {
+        NextAction("halazzi misdirect boss to main tank", ACTION_RAID + 2) }));
+
+    triggers.push_back(new TriggerNode("halazzi boss engaged by main tank", {
+        NextAction("halazzi main tank position boss", ACTION_RAID + 1) }));
+
+    triggers.push_back(new TriggerNode("halazzi boss summons spirit lynx", {
+        NextAction("halazzi first assist tank attack spirit lynx", ACTION_RAID + 1) }));
+
+    triggers.push_back(new TriggerNode("halazzi determining dps target", {
+        NextAction("halazzi assign dps priority", ACTION_RAID + 1) }));
+
+    // Hex Lord Malacrass
+    triggers.push_back(new TriggerNode("hex lord malacrass pulling boss", {
+        NextAction("hex lord malacrass misdirect boss to main tank", ACTION_RAID + 2) }));
+
+    triggers.push_back(new TriggerNode("hex lord malacrass determining kill order", {
+        NextAction("hex lord malacrass assign dps priority", ACTION_RAID + 1) }));
+
+    triggers.push_back(new TriggerNode("hex lord malacrass boss is channeling whirlwind", {
+        NextAction("hex lord malacrass run away from whirlwind", ACTION_EMERGENCY + 6) }));
+
+    triggers.push_back(new TriggerNode("hex lord malacrass boss has spell reflection", {
+        NextAction("hex lord malacrass casters stop attacking", ACTION_EMERGENCY + 6) }));
+
+    triggers.push_back(new TriggerNode("hex lord malacrass boss placed freezing trap", {
+        NextAction("hex lord malacrass move away from freezing trap", ACTION_EMERGENCY + 1) }));
+
+    // Zul'jin
+    triggers.push_back(new TriggerNode("zul'jin main tank needs aggro upon pull or phase change", {
+        NextAction("zul'jin misdirect boss to main tank", ACTION_RAID + 2) }));
+
+    triggers.push_back(new TriggerNode("zul'jin boss engaged by main tank", {
+        NextAction("zul'jin main tank position boss", ACTION_RAID + 1) }));
+
+    triggers.push_back(new TriggerNode("zul'jin boss is channeling whirlwind in troll form", {
+        NextAction("zul'jin run away from whirlwind", ACTION_EMERGENCY + 6) }));
+
+    triggers.push_back(new TriggerNode("zul'jin boss is summoning cyclones in eagle form", {
+        NextAction("zul'jin avoid cyclones", ACTION_EMERGENCY + 1) }));
+
+    triggers.push_back(new TriggerNode("zul'jin boss casts aoe abilities in dragonhawk form", {
+        NextAction("zul'jin spread ranged", ACTION_RAID + 1) }));
+}
+
+void RaidZulAmanStrategy::InitMultipliers(std::vector<Multiplier*>& multipliers)
+{
+    // Akil'zon <Eagle Avatar>
+    multipliers.push_back(new AkilzonDisableCombatFormationMoveMultiplier(botAI));
+    multipliers.push_back(new AkilzonStayInEyeOfTheStormMultiplier(botAI));
+
+    // Nalorakk <Bear Avatar>
+    multipliers.push_back(new NalorakkDisableTankActionsMultiplier(botAI));
+    multipliers.push_back(new NalorakkControlMisdirectionMultiplier(botAI));
+
+    // Jan'alai <Dragonhawk Avatar>
+    multipliers.push_back(new JanalaiDisableTankActionsMultiplier(botAI));
+    multipliers.push_back(new JanalaiDisableCombatFormationMoveMultiplier(botAI));
+    multipliers.push_back(new JanalaiStayAwayFromFireBombsMultiplier(botAI));
+    multipliers.push_back(new JanalaiDoNotCrowdControlHatchersMultiplier(botAI));
+    multipliers.push_back(new JanalaiDelayBloodlustAndHeroismMultiplier(botAI));
+
+    // Halazzi <Lynx Avatar>
+    multipliers.push_back(new HalazziDisableTankActionsMultiplier(botAI));
+    multipliers.push_back(new HalazziControlMisdirectionMultiplier(botAI));
+
+    // Hex Lord Malacrass
+    multipliers.push_back(new HexLordMalacrassAvoidWhirlwindMultiplier(botAI));
+    multipliers.push_back(new HexLordMalacrassStopAttackingDuringSpellReflectionMultiplier(botAI));
+    multipliers.push_back(new HexLordMalacrassDoNotDispelUnstableAfflictionMultiplier(botAI));
+
+    // Zul'jin
+    multipliers.push_back(new ZuljinDisableTankFaceMultiplier(botAI));
+    multipliers.push_back(new ZuljinAvoidWhirlwindMultiplier(botAI));
+    multipliers.push_back(new ZuljinDisableAvoidAoeMultiplier(botAI));
+    multipliers.push_back(new ZuljinDelayBloodlustAndHeroismMultiplier(botAI));
+}

src/Ai/Raid/ZulAman/Strategy/RaidZulAmanStrategy.h

@@ -0,0 +1,23 @@
+/*
+ * 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_RAIDZULAMANSTRATEGY_H_
+#define _PLAYERBOT_RAIDZULAMANSTRATEGY_H_
+
+#include "Strategy.h"
+#include "Multiplier.h"
+
+class RaidZulAmanStrategy : public Strategy
+{
+public:
+    RaidZulAmanStrategy(PlayerbotAI* botAI) : Strategy(botAI) {}
+
+    std::string const getName() override { return "zulaman"; }
+
+    void InitTriggers(std::vector<TriggerNode*>& triggers) override;
+    void InitMultipliers(std::vector<Multiplier*>& multipliers) override;
+};
+
+#endif

src/Ai/Raid/ZulAman/Trigger/RaidZulAmanTriggers.cpp

@@ -0,0 +1,271 @@
+/*
+ * 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 "RaidZulAmanTriggers.h"
+#include "RaidZulAmanHelpers.h"
+#include "RaidZulAmanActions.h"
+#include "Playerbots.h"
+#include "RaidBossHelpers.h"
+
+using namespace ZulAmanHelpers;
+
+// Trash
+
+bool AmanishiMedicineManSummonedWardTrigger::IsActive()
+{
+    return AI_VALUE2(Unit*, "find target", "amani'shi medicine man");
+}
+
+// Akil'zon <Eagle Avatar>
+
+bool AkilzonPullingBossTrigger::IsActive()
+{
+    if (bot->getClass() != CLASS_HUNTER)
+        return false;
+
+    Unit* akilzon = AI_VALUE2(Unit*, "find target", "akil'zon");
+    return akilzon && akilzon->GetHealthPct() > 95.0f;
+}
+
+bool AkilzonBossEngagedByTanksTrigger::IsActive()
+{
+    if (!botAI->IsTank(bot) ||
+        !AI_VALUE2(Unit*, "find target", "akil'zon"))
+        return false;
+
+    return !GetElectricalStormTarget(bot);
+}
+
+bool AkilzonBossCastsStaticDisruptionTrigger::IsActive()
+{
+    if (!botAI->IsRanged(bot) ||
+        !AI_VALUE2(Unit*, "find target", "akil'zon"))
+        return false;
+
+    auto it = akilzonStormTimer.find(bot->GetMap()->GetInstanceId());
+    if (it == akilzonStormTimer.end())
+        return true;
+
+    return !IsInStormWindow(it->second, std::time(nullptr));
+}
+
+bool AkilzonElectricalStormIncomingTrigger::IsActive()
+{
+    if (!AI_VALUE2(Unit*, "find target", "akil'zon"))
+        return false;
+
+    auto it = akilzonStormTimer.find(bot->GetMap()->GetInstanceId());
+    if (it == akilzonStormTimer.end())
+        return false;
+
+    return IsInStormWindow(it->second, std::time(nullptr));
+}
+
+bool AkilzonBotsNeedToPrepareForElectricalStormTrigger::IsActive()
+{
+    return IsMechanicTrackerBot(botAI, bot, ZULAMAN_MAP_ID);
+}
+
+// Nalorakk <Bear Avatar>
+
+bool NalorakkPullingBossTrigger::IsActive()
+{
+    if (bot->getClass() != CLASS_HUNTER)
+        return false;
+
+    Unit* nalorakk = AI_VALUE2(Unit*, "find target", "nalorakk");
+    return nalorakk && nalorakk->GetHealthPct() > 95.0f;
+}
+
+bool NalorakkBossSwitchesFormsTrigger::IsActive()
+{
+    return (botAI->IsMainTank(bot) || botAI->IsAssistTankOfIndex(bot, 0, true)) &&
+           AI_VALUE2(Unit*, "find target", "nalorakk");
+}
+
+bool NalorakkBossCastsSurgeTrigger::IsActive()
+{
+    return botAI->IsRanged(bot) &&
+           AI_VALUE2(Unit*, "find target", "nalorakk");
+}
+
+// Jan'alai <Dragonhawk Avatar>
+
+bool JanalaiPullingBossTrigger::IsActive()
+{
+    if (bot->getClass() != CLASS_HUNTER)
+        return false;
+
+    Unit* janalai = AI_VALUE2(Unit*, "find target", "jan'alai");
+    return janalai && janalai->GetHealthPct() > 95.0f;
+}
+
+bool JanalaiBossEngagedByTanksTrigger::IsActive()
+{
+    if (!botAI->IsTank(bot) ||
+        !AI_VALUE2(Unit*, "find target", "jan'alai"))
+        return false;
+
+    return !HasFireBombNearby(botAI, bot);
+}
+
+bool JanalaiBossCastsFlameBreathTrigger::IsActive()
+{
+    if (!botAI->IsRanged(bot) ||
+        !AI_VALUE2(Unit*, "find target", "jan'alai") ||
+        AI_VALUE2(Unit*, "find target", "amani dragonhawk hatchling"))
+        return false;
+
+    return !HasFireBombNearby(botAI, bot);
+}
+
+bool JanalaiBossSummoningFireBombsTrigger::IsActive()
+{
+    return AI_VALUE2(Unit*, "find target", "jan'alai") &&
+           HasFireBombNearby(botAI, bot);
+}
+
+bool JanalaiAmanishiHatchersSpawnedTrigger::IsActive()
+{
+    if (!botAI->IsRangedDps(bot) ||
+        !AI_VALUE2(Unit*, "find target", "jan'alai"))
+        return false;
+
+    return bot->FindNearestCreature(
+               static_cast<uint32>(ZulAmanNPCs::NPC_AMANISHI_HATCHER), 40.0f);
+}
+
+// Halazzi <Lynx Avatar>
+
+bool HalazziPullingBossTrigger::IsActive()
+{
+    if (bot->getClass() != CLASS_HUNTER)
+        return false;
+
+    Unit* halazzi = AI_VALUE2(Unit*, "find target", "halazzi");
+    return halazzi && halazzi->GetHealthPct() > 95.0f;
+}
+
+bool HalazziBossEngagedByMainTankTrigger::IsActive()
+{
+    return botAI->IsMainTank(bot) &&
+           AI_VALUE2(Unit*, "find target", "halazzi");
+}
+
+bool HalazziBossSummonsSpiritLynxTrigger::IsActive()
+{
+    return botAI->IsAssistTankOfIndex(bot, 0, true) &&
+           AI_VALUE2(Unit*, "find target", "halazzi");
+}
+
+bool HalazziDeterminingDpsTargetTrigger::IsActive()
+{
+    return botAI->IsDps(bot) &&
+           AI_VALUE2(Unit*, "find target", "halazzi");
+}
+
+// Hex Lord Malacrass
+
+bool HexLordMalacrassPullingBossTrigger::IsActive()
+{
+    if (bot->getClass() != CLASS_HUNTER)
+        return false;
+
+    Unit* malacrass = AI_VALUE2(Unit*, "find target", "hex lord malacrass");
+    return malacrass && malacrass->GetHealthPct() > 95.0f;
+}
+
+bool HexLordMalacrassDeterminingKillOrderTrigger::IsActive()
+{
+    return botAI->IsDps(bot) &&
+           AI_VALUE2(Unit*, "find target", "hex lord malacrass");
+}
+
+bool HexLordMalacrassBossIsChannelingWhirlwindTrigger::IsActive()
+{
+    Unit* malacrass = AI_VALUE2(Unit*, "find target", "hex lord malacrass");
+    if (!malacrass ||
+        !malacrass->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_HEX_LORD_WHIRLWIND)))
+        return false;
+
+    return !(botAI->IsTank(bot) && malacrass->GetVictim() == bot);
+}
+
+bool HexLordMalacrassBossHasSpellReflectionTrigger::IsActive()
+{
+    if (!botAI->IsCaster(bot))
+        return false;
+
+    Unit* malacrass = AI_VALUE2(Unit*, "find target", "hex lord malacrass");
+    return malacrass &&
+           malacrass->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_HEX_LORD_SPELL_REFLECTION));
+}
+
+bool HexLordMalacrassBossPlacedFreezingTrapTrigger::IsActive()
+{
+    return AI_VALUE2(Unit*, "find target", "hex lord malacrass") &&
+           bot->FindNearestGameObject(
+               static_cast<uint32>(ZulAmanObjects::GO_FREEZING_TRAP), 20.0f, true);
+}
+
+// Zul'jin
+
+bool ZuljinMainTankNeedsAggroUponPullOrPhaseChangeTrigger::IsActive()
+{
+    if (bot->getClass() != CLASS_HUNTER)
+        return false;
+
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    if (!zuljin)
+        return false;
+
+    float hp = zuljin->GetHealthPct();
+
+    return (hp <= 100.0f && hp > 95.0f) ||
+           (hp <= 80.0f && hp > 75.0f &&
+            zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_SHAPE_OF_THE_BEAR))) ||
+           (hp <= 40.0f && hp > 35.0f &&
+            zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_SHAPE_OF_THE_LYNX))) ||
+           (hp <= 20.0f && hp > 15.0f &&
+            zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_SHAPE_OF_THE_DRAGONHAWK)));
+}
+
+bool ZuljinBossEngagedByTanksTrigger::IsActive()
+{
+    if (!botAI->IsTank(bot))
+        return false;
+
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    return zuljin &&
+           !zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_SHAPE_OF_THE_EAGLE)) &&
+           !zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_SHAPE_OF_THE_DRAGONHAWK));
+}
+
+bool ZuljinBossIsChannelingWhirlwindInTrollFormTrigger::IsActive()
+{
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    if (!zuljin ||
+        !zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_ZULJIN_WHIRLWIND)))
+        return false;
+
+    return !(botAI->IsTank(bot) && zuljin->GetVictim() == bot);
+}
+
+bool ZuljinBossIsSummoningCyclonesInEagleFormTrigger::IsActive()
+{
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    return zuljin &&
+           zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_SHAPE_OF_THE_EAGLE));
+}
+
+bool ZuljinBossCastsAoeAbilitiesInDragonhawkFormTrigger::IsActive()
+{
+    if (!botAI->IsRanged(bot))
+        return false;
+
+    Unit* zuljin = AI_VALUE2(Unit*, "find target", "zul'jin");
+    return zuljin &&
+           zuljin->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_SHAPE_OF_THE_DRAGONHAWK));
+}

src/Ai/Raid/ZulAman/Trigger/RaidZulAmanTriggers.h

@@ -0,0 +1,249 @@
+/*
+ * 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_RAIDZULAMANTRIGGERS_H
+#define _PLAYERBOT_RAIDZULAMANTRIGGERS_H
+
+#include "Trigger.h"
+
+// Trash
+
+class AmanishiMedicineManSummonedWardTrigger : public Trigger
+{
+public:
+    AmanishiMedicineManSummonedWardTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "amani'shi medicine man summoned ward") {}
+    bool IsActive() override;
+};
+
+// Akil'zon <Eagle Avatar>
+
+class AkilzonPullingBossTrigger : public Trigger
+{
+public:
+    AkilzonPullingBossTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "akil'zon pulling boss") {}
+    bool IsActive() override;
+};
+
+class AkilzonBossEngagedByTanksTrigger : public Trigger
+{
+public:
+    AkilzonBossEngagedByTanksTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "akil'zon boss engaged by tanks") {}
+    bool IsActive() override;
+};
+
+class AkilzonBossCastsStaticDisruptionTrigger : public Trigger
+{
+public:
+    AkilzonBossCastsStaticDisruptionTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "akil'zon boss casts static disruption") {}
+    bool IsActive() override;
+};
+
+class AkilzonElectricalStormIncomingTrigger : public Trigger
+{
+public:
+    AkilzonElectricalStormIncomingTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "akil'zon electrical storm incoming") {}
+    bool IsActive() override;
+};
+
+class AkilzonBotsNeedToPrepareForElectricalStormTrigger : public Trigger
+{
+public:
+    AkilzonBotsNeedToPrepareForElectricalStormTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "akil'zon bots need to prepare for electrical storm") {}
+    bool IsActive() override;
+};
+
+// Nalorakk <Bear Avatar>
+
+class NalorakkPullingBossTrigger : public Trigger
+{
+public:
+    NalorakkPullingBossTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "nalorakk pulling boss") {}
+    bool IsActive() override;
+};
+
+class NalorakkBossSwitchesFormsTrigger : public Trigger
+{
+public:
+    NalorakkBossSwitchesFormsTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "nalorakk boss switches forms") {}
+    bool IsActive() override;
+};
+
+class NalorakkBossCastsSurgeTrigger : public Trigger
+{
+public:
+    NalorakkBossCastsSurgeTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "nalorakk boss casts surge") {}
+    bool IsActive() override;
+};
+
+// Jan'alai <Dragonhawk Avatar>
+
+class JanalaiPullingBossTrigger : public Trigger
+{
+public:
+    JanalaiPullingBossTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "jan'alai pulling boss") {}
+    bool IsActive() override;
+};
+
+class JanalaiBossEngagedByTanksTrigger : public Trigger
+{
+public:
+    JanalaiBossEngagedByTanksTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "jan'alai boss engaged by tanks") {}
+    bool IsActive() override;
+};
+
+class JanalaiBossCastsFlameBreathTrigger : public Trigger
+{
+public:
+    JanalaiBossCastsFlameBreathTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "jan'alai boss casts flame breath") {}
+    bool IsActive() override;
+};
+
+class JanalaiBossSummoningFireBombsTrigger : public Trigger
+{
+public:
+    JanalaiBossSummoningFireBombsTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "jan'alai boss summoning fire bombs") {}
+    bool IsActive() override;
+};
+
+class JanalaiAmanishiHatchersSpawnedTrigger : public Trigger
+{
+public:
+    JanalaiAmanishiHatchersSpawnedTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "jan'alai amani'shi hatchers spawned") {}
+    bool IsActive() override;
+};
+
+// Halazzi <Lynx Avatar>
+
+class HalazziPullingBossTrigger : public Trigger
+{
+public:
+    HalazziPullingBossTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "halazzi pulling boss") {}
+    bool IsActive() override;
+};
+
+class HalazziBossEngagedByMainTankTrigger : public Trigger
+{
+public:
+    HalazziBossEngagedByMainTankTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "halazzi boss engaged by main tank") {}
+    bool IsActive() override;
+};
+
+class HalazziBossSummonsSpiritLynxTrigger : public Trigger
+{
+public:
+    HalazziBossSummonsSpiritLynxTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "halazzi boss summons spirit lynx") {}
+    bool IsActive() override;
+};
+
+class HalazziDeterminingDpsTargetTrigger : public Trigger
+{
+public:
+    HalazziDeterminingDpsTargetTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "halazzi determining dps target") {}
+    bool IsActive() override;
+};
+
+// Hex Lord Malacrass
+
+class HexLordMalacrassPullingBossTrigger : public Trigger
+{
+public:
+    HexLordMalacrassPullingBossTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "hex lord malacrass pulling boss") {}
+    bool IsActive() override;
+};
+
+class HexLordMalacrassDeterminingKillOrderTrigger : public Trigger
+{
+public:
+    HexLordMalacrassDeterminingKillOrderTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "hex lord malacrass determining kill order") {}
+    bool IsActive() override;
+};
+
+class HexLordMalacrassBossIsChannelingWhirlwindTrigger : public Trigger
+{
+public:
+    HexLordMalacrassBossIsChannelingWhirlwindTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "hex lord malacrass boss is channeling whirlwind") {}
+    bool IsActive() override;
+};
+
+class HexLordMalacrassBossHasSpellReflectionTrigger : public Trigger
+{
+public:
+    HexLordMalacrassBossHasSpellReflectionTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "hex lord malacrass boss has spell reflection") {}
+    bool IsActive() override;
+};
+
+class HexLordMalacrassBossPlacedFreezingTrapTrigger : public Trigger
+{
+public:
+    HexLordMalacrassBossPlacedFreezingTrapTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "hex lord malacrass boss placed freezing trap") {}
+    bool IsActive() override;
+};
+
+// Zul'jin
+
+class ZuljinMainTankNeedsAggroUponPullOrPhaseChangeTrigger : public Trigger
+{
+public:
+    ZuljinMainTankNeedsAggroUponPullOrPhaseChangeTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "zul'jin main tank needs aggro upon pull or phase change") {}
+    bool IsActive() override;
+};
+
+class ZuljinBossEngagedByTanksTrigger : public Trigger
+{
+public:
+    ZuljinBossEngagedByTanksTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "zul'jin boss engaged by tanks") {}
+    bool IsActive() override;
+};
+
+class ZuljinBossIsChannelingWhirlwindInTrollFormTrigger : public Trigger
+{
+public:
+    ZuljinBossIsChannelingWhirlwindInTrollFormTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "zul'jin boss is channeling whirlwind in troll form") {}
+    bool IsActive() override;
+};
+
+class ZuljinBossIsSummoningCyclonesInEagleFormTrigger : public Trigger
+{
+public:
+    ZuljinBossIsSummoningCyclonesInEagleFormTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "zul'jin boss is summoning cyclones in eagle form") {}
+    bool IsActive() override;
+};
+
+class ZuljinBossCastsAoeAbilitiesInDragonhawkFormTrigger : public Trigger
+{
+public:
+ZuljinBossCastsAoeAbilitiesInDragonhawkFormTrigger(
+        PlayerbotAI* botAI) : Trigger(botAI, "zul'jin boss casts aoe abilities in dragonhawk form") {}
+    bool IsActive() override;
+};
+
+#endif

src/Ai/Raid/ZulAman/Util/RaidZulAmanHelpers.cpp

@@ -0,0 +1,190 @@
+/*
+ * 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 "RaidZulAmanHelpers.h"
+#include "Group.h"
+#include "Playerbots.h"
+
+namespace ZulAmanHelpers
+{
+    // General
+    Position FindSafestNearbyPosition(Player* bot,
+        const std::vector<Unit*>& hazards, const Position& safeZoneCenter,
+        float safeZoneRadius, float hazardRadius, bool requireSafePath)
+    {
+        constexpr float searchStep = M_PI / 8.0f;
+        constexpr float distanceStep = 1.0f;
+
+        Position bestPos;
+        float minMoveDistance = std::numeric_limits<float>::max();
+        bool foundSafe = false;
+
+        for (float distance = 0.0f;
+             distance <= safeZoneRadius; distance += distanceStep)
+        {
+            for (float angle = 0.0f; angle < 2 * M_PI; angle += searchStep)
+            {
+                float x = bot->GetPositionX() + distance * std::cos(angle);
+                float y = bot->GetPositionY() + distance * std::sin(angle);
+
+                if (safeZoneCenter.GetExactDist2d(x, y) > safeZoneRadius)
+                    continue;
+
+                if (!IsPositionSafeFromHazards(x, y, hazards, hazardRadius))
+                    continue;
+
+                Position testPos(x, y, bot->GetPositionZ());
+
+                bool pathSafe = true;
+                if (requireSafePath)
+                {
+                    pathSafe =
+                        IsPathSafeFromHazards(bot->GetPosition(), testPos, hazards, hazardRadius);
+                    if (!pathSafe)
+                        continue;
+                }
+
+                float moveDistance = bot->GetExactDist2d(x, y);
+                if (!foundSafe || moveDistance < minMoveDistance)
+                {
+                    bestPos = testPos;
+                    minMoveDistance = moveDistance;
+                    foundSafe = pathSafe;
+                }
+            }
+
+            if (foundSafe)
+                break;
+        }
+
+        return bestPos;
+    }
+
+    bool IsPathSafeFromHazards(const Position& start, const Position& end,
+        const std::vector<Unit*>& hazards, float hazardRadius)
+    {
+        constexpr uint8 numChecks = 10;
+        float dx = end.GetPositionX() - start.GetPositionX();
+        float dy = end.GetPositionY() - start.GetPositionY();
+
+        for (uint8 i = 1; i <= numChecks; ++i)
+        {
+            float ratio = static_cast<float>(i) / numChecks;
+            float checkX = start.GetPositionX() + dx * ratio;
+            float checkY = start.GetPositionY() + dy * ratio;
+
+            if (!IsPositionSafeFromHazards(checkX, checkY, hazards, hazardRadius))
+                return false;
+        }
+
+        return true;
+    }
+
+    bool IsPositionSafeFromHazards(
+        float x, float y, const std::vector<Unit*>& hazards, float hazardRadius)
+    {
+        for (Unit* hazard : hazards)
+        {
+            if (hazard->GetDistance2d(x, y) < hazardRadius)
+                return false;
+        }
+
+        return true;
+    }
+
+    std::vector<Unit*> GetAllHazardTriggers(Player* bot, uint32 entry, float searchRadius)
+    {
+        std::vector<Unit*> triggers;
+        std::list<Creature*> creatureList;
+        bot->GetCreatureListWithEntryInGrid(creatureList, entry, searchRadius);
+
+        for (Creature* creature : creatureList)
+        {
+            if (creature && creature->IsAlive())
+                triggers.push_back(creature);
+        }
+
+        return triggers;
+    }
+
+    // Akil'zon <Eagle Avatar>
+    const Position AKILZON_TANK_POSITION = { 378.369f, 1407.718f, 74.797f };
+    std::unordered_map<uint32, time_t> akilzonStormTimer;
+
+    bool IsInStormWindow(time_t start, time_t now)
+    {
+        time_t elapsed = now - start;
+        uint32 seconds = elapsed % 60;
+        return elapsed >= 55 && (seconds >= 55 || seconds < 10);
+    }
+
+    Player* GetElectricalStormTarget(Player* bot)
+    {
+        Group* group = bot->GetGroup();
+        if (!group)
+            return nullptr;
+
+        for (GroupReference* ref = group->GetFirstMember(); ref; ref = ref->next())
+        {
+            Player* member = ref->GetSource();
+            if (member &&
+                member->HasAura(static_cast<uint32>(ZulAmanSpells::SPELL_ELECTRICAL_STORM)))
+                return member;
+        }
+
+        return nullptr;
+    }
+
+    // Nalorakk <Bear Avatar>
+    const Position NALORAKK_TANK_POSITION = { -80.208f, 1324.530f, 40.942f };
+
+    // Jan'alai <Dragonhawk Avatar>
+    const Position JANALAI_TANK_POSITION = { -33.873f, 1149.571f, 19.146f };
+
+    bool HasFireBombNearby(PlayerbotAI* botAI, Player* bot)
+    {
+        constexpr float searchRadius = 30.0f;
+        std::list<Creature*> creatureList;
+        bot->GetCreatureListWithEntryInGrid(
+            creatureList, static_cast<uint32>(ZulAmanNPCs::NPC_FIRE_BOMB), searchRadius);
+
+        for (Creature* creature : creatureList)
+        {
+            if (creature && creature->IsAlive())
+                return true;
+        }
+
+        return false;
+    }
+
+    std::pair<Unit*, Unit*> GetAmanishiHatcherPair(PlayerbotAI* botAI)
+    {
+        Unit* lowest = nullptr;
+        Unit* highest = nullptr;
+
+        for (auto const& guid :
+             botAI->GetAiObjectContext()->GetValue<GuidVector>("possible targets no los")->Get())
+        {
+            Unit* unit = botAI->GetUnit(guid);
+            if (unit &&
+                unit->GetEntry() == static_cast<uint32>(ZulAmanNPCs::NPC_AMANISHI_HATCHER))
+            {
+                if (!lowest || unit->GetGUID().GetCounter() < lowest->GetGUID().GetCounter())
+                    lowest = unit;
+
+                if (!highest || unit->GetGUID().GetCounter() > highest->GetGUID().GetCounter())
+                    highest = unit;
+            }
+        }
+
+        return {lowest, highest};
+    }
+
+    // Halazzi <Lynx Avatar>
+    const Position HALAZZI_TANK_POSITION = { 370.733f, 1131.202f, 6.516f };
+
+    // Zul'jin
+    const Position ZULJIN_TANK_POSITION = { 120.210f, 705.564f, 45.111f };
+}

src/Ai/Raid/ZulAman/Util/RaidZulAmanHelpers.h

@@ -0,0 +1,110 @@
+/*
+ * 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_RAIDZULAMANHELPERS_H_
+#define _PLAYERBOT_RAIDZULAMANHELPERS_H_
+
+#include <unordered_map>
+
+#include "AiObject.h"
+#include "Position.h"
+#include "Unit.h"
+
+namespace ZulAmanHelpers
+{
+    enum class ZulAmanSpells : uint32
+    {
+        // Akil'zon <Eagle Avatar>
+        SPELL_ELECTRICAL_STORM          = 43648,
+
+        // Nalorakk <Bear Avatar>
+        SPELL_BEARFORM                  = 42377,
+
+        // Hex Lord Malacrass
+        SPELL_HEX_LORD_WHIRLWIND        = 43442,
+        SPELL_HEX_LORD_SPELL_REFLECTION = 43443,
+        SPELL_UNSTABLE_AFFLICTION       = 43522,
+
+        // Zul'jin
+        SPELL_ZULJIN_WHIRLWIND          = 17207,
+        SPELL_SHAPE_OF_THE_BEAR         = 42594,
+        SPELL_SHAPE_OF_THE_EAGLE        = 42606,
+        SPELL_SHAPE_OF_THE_LYNX         = 42607,
+        SPELL_SHAPE_OF_THE_DRAGONHAWK   = 42608,
+        // SPELL_CLAW_RAGE              = 43149, // Would require getting Zul'jin's bossai
+
+        // Hunter
+        SPELL_MISDIRECTION              = 35079,
+    };
+
+    enum class ZulAmanNPCs : uint32
+    {
+        // Trash
+        NPC_AMANI_HEALING_WARD          = 23757,
+        NPC_AMANI_PROTECTIVE_WARD       = 23822,
+
+        // Jan'alai <Dragonhawk Avatar>
+        NPC_AMANI_DRAGONHAWK_HATCHLING  = 23598,
+        NPC_AMANISHI_HATCHER            = 23818,
+        NPC_FIRE_BOMB                   = 23920,
+
+        // Halazzi <Lynx Avatar>
+        NPC_CORRUPTED_LIGHTNING_TOTEM   = 24224,
+
+        // Hex Lord Malacrass
+        NPC_HEX_LORD_MALACRASS          = 24239,
+        NPC_ALYSON_ANTILLE              = 24240,
+        NPC_THURG                       = 24241,
+        NPC_SLITHER                     = 24242,
+        NPC_LORD_RAADAN                 = 24243,
+        NPC_GAZAKROTH                   = 24244,
+        NPC_FENSTALKER                  = 24245,
+        NPC_DARKHEART                   = 24246,
+        NPC_KORAGG                      = 24247,
+
+        // Zul'jin
+        NPC_FEATHER_VORTEX              = 24136,
+    };
+
+    enum class ZulAmanObjects : uint32
+    {
+        GO_FREEZING_TRAP                = 186669,
+    };
+
+    // General
+    constexpr uint32 ZULAMAN_MAP_ID = 568;
+    Position FindSafestNearbyPosition(
+        Player* bot, const std::vector<Unit*>& hazards, const Position& center,
+        float safeZoneRadius, float hazardRadius, bool requireSafePath);
+    bool IsPathSafeFromHazards(
+        const Position& start, const Position& end,
+        const std::vector<Unit*>& hazards, float hazardRadius);
+    bool IsPositionSafeFromHazards(
+        float x, float y, const std::vector<Unit*>& hazards, float hazardRadius);
+    std::vector<Unit*> GetAllHazardTriggers(
+        Player* bot, uint32 entry, float searchRadius);
+
+    // Akil'zon <Eagle Avatar>
+    extern const Position AKILZON_TANK_POSITION;
+    extern std::unordered_map<uint32, time_t> akilzonStormTimer;
+    bool IsInStormWindow(time_t start, time_t now);
+    Player* GetElectricalStormTarget(Player* bot);
+
+    // Nalorakk <Bear Avatar>
+    extern const Position NALORAKK_TANK_POSITION;
+
+    // Jan'alai <Dragonhawk Avatar>
+    extern const Position JANALAI_TANK_POSITION;
+    bool HasFireBombNearby(PlayerbotAI* botAI, Player* bot);
+    std::pair<Unit*, Unit*> GetAmanishiHatcherPair(PlayerbotAI* botAI);
+
+    // Halazzi <Lynx Avatar>
+    extern const Position HALAZZI_TANK_POSITION;
+
+    // Zul'jin
+    extern const Position ZULJIN_TANK_POSITION;
+}
+
+#endif

src/Bot/Engine/BuildSharedActionContexts.cpp

@@ -11,6 +11,7 @@
 #include "Ai/Raid/Magtheridon/RaidMagtheridonActionContext.h"
 #include "Ai/Raid/SerpentshrineCavern/RaidSSCActionContext.h"
 #include "Ai/Raid/TempestKeep/RaidTempestKeepActionContext.h"
+#include "Ai/Raid/ZulAman/RaidZulAmanActionContext.h"
 #include "Ai/Raid/ObsidianSanctum/RaidOsActionContext.h"
 #include "Ai/Raid/EyeOfEternity/RaidEoEActionContext.h"
 #include "Ai/Raid/VaultOfArchavon/RaidVoAActionContext.h"
@@ -32,6 +33,7 @@ void AiObjectContext::BuildSharedActionContexts(SharedNamedObjectContextList<Act
     actionContexts.Add(new RaidMagtheridonActionContext());
     actionContexts.Add(new RaidSSCActionContext());
     actionContexts.Add(new RaidTempestKeepActionContext());
+    actionContexts.Add(new RaidZulAmanActionContext());
     actionContexts.Add(new RaidNaxxActionContext());
     actionContexts.Add(new RaidOsActionContext());
     actionContexts.Add(new RaidEoEActionContext());

src/Bot/Engine/BuildSharedTriggerContexts.cpp

@@ -11,6 +11,7 @@
 #include "Ai/Raid/Naxxramas/RaidNaxxTriggerContext.h"
 #include "Ai/Raid/SerpentshrineCavern/RaidSSCTriggerContext.h"
 #include "Ai/Raid/TempestKeep/RaidTempestKeepTriggerContext.h"
+#include "Ai/Raid/ZulAman/RaidZulAmanTriggerContext.h"
 #include "Ai/Raid/ObsidianSanctum/RaidOsTriggerContext.h"
 #include "Ai/Raid/EyeOfEternity/RaidEoETriggerContext.h"
 #include "Ai/Raid/VaultOfArchavon/RaidVoATriggerContext.h"
@@ -33,6 +34,7 @@ void AiObjectContext::BuildSharedTriggerContexts(SharedNamedObjectContextList<Tr
     triggerContexts.Add(new RaidNaxxTriggerContext());
     triggerContexts.Add(new RaidSSCTriggerContext());
     triggerContexts.Add(new RaidTempestKeepTriggerContext());
+    triggerContexts.Add(new RaidZulAmanTriggerContext());
     triggerContexts.Add(new RaidOsTriggerContext());
     triggerContexts.Add(new RaidEoETriggerContext());
     triggerContexts.Add(new RaidVoATriggerContext());

src/Bot/PlayerbotAI.cpp

@@ -1562,7 +1562,7 @@ void PlayerbotAI::ApplyInstanceStrategies(uint32 mapId, bool tellMaster)
         "naxx", "onyxia", "ssc", "tempestkeep", "ulduar", "voa", "wotlk-an", "wotlk-cos",
         "wotlk-dtk", "wotlk-eoe", "wotlk-fos", "wotlk-gd", "wotlk-hol", "wotlk-hor",
         "wotlk-hos", "wotlk-nex", "wotlk-occ", "wotlk-ok", "wotlk-os", "wotlk-pos",
-        "wotlk-toc", "wotlk-uk", "wotlk-up", "wotlk-vh"
+        "wotlk-toc", "wotlk-uk", "wotlk-up", "wotlk-vh", "zulaman"
     };
 
     for (const std::string& strat : allInstanceStrategies)
@@ -1604,6 +1604,9 @@ void PlayerbotAI::ApplyInstanceStrategies(uint32 mapId, bool tellMaster)
         case 565:
             strategyName = "gruulslair";  // Gruul's Lair
             break;
+        case 568:
+            strategyName = "zulaman";  // Zul'Aman
+            break;
         case 574:
             strategyName = "wotlk-uk";  // Utgarde Keep
             break;