Core/GameObject: Implement ControlZone gameobject type (#29320)

14 files changed, 874 insertions, 659 deletions

diff --git a/src/server/scripts/Battlefield/BattlefieldTB.cpp b/src/server/scripts/Battlefield/BattlefieldTB.cpp
index 9d9902adbe2..05222f50052 100644
--- a/src/server/scripts/Battlefield/BattlefieldTB.cpp
+++ b/src/server/scripts/Battlefield/BattlefieldTB.cpp
@@ -100,15 +100,25 @@ bool BattlefieldTB::SetupBattlefield()
     // Create capture points
     for (uint8 i = 0; i < TB_BASE_COUNT; i++)
     {
-        TolBaradCapturePoint* capturePoint = new TolBaradCapturePoint(this, GetDefenderTeam());
-
         //Spawn flag pole
         if (GameObject* go = SpawnGameObject(TBCapturePoints[i].entryFlagPole[GetDefenderTeam()], TBCapturePoints[i].pos, QuaternionData::fromEulerAnglesZYX(TBCapturePoints[i].pos.GetOrientation(), 0.0f, 0.0f)))
         {
-            go->SetGoArtKit(GetDefenderTeam() == TEAM_ALLIANCE ? TB_GO_ARTKIT_FLAG_ALLIANCE : TB_GO_ARTKIT_FLAG_HORDE);
-            capturePoint->SetCapturePointData(go);
+            std::unique_ptr<TolBaradCapturePoint> controlZone = std::make_unique<TolBaradCapturePoint>(this, TBCapturePoints[i]);
+            if (GetDefenderTeam() == TEAM_ALLIANCE)
+            {
+                sWorldStateMgr->SetValue(controlZone->GetWorldStateAllianceControlled(), 1, false, GetMap());
+                go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(100));
+                go->SetGoArtKit(TB_GO_ARTKIT_FLAG_ALLIANCE);
+            }
+            else if (GetDefenderTeam() == TEAM_HORDE)
+            {
+                sWorldStateMgr->SetValue(controlZone->GetWorldStateHordeControlled(), 1, false, GetMap());
+                go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(0));
+                go->SetGoArtKit(TB_GO_ARTKIT_FLAG_HORDE);
+            }
+
+            ControlZoneHandlers[go->GetEntry()] = std::move(controlZone);
         }
-        AddCapturePoint(capturePoint);
     }
 
     // Spawn towers
@@ -379,23 +389,29 @@ void BattlefieldTB::UpdateNPCsAndGameObjects()
     if (GetState() == BATTLEFIELD_INACTIVE)
     {
         // Delete capture points
-        for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
-            itr->second->DelCapturePoint();
-        m_capturePoints.clear();
+        ControlZoneHandlers.clear();
 
         // Create capture points
         for (uint8 i = 0; i < TB_BASE_COUNT; i++)
         {
-            TolBaradCapturePoint* capturePoint = new TolBaradCapturePoint(this, GetDefenderTeam());
-
-            //Spawn flag pole
             if (GameObject* go = SpawnGameObject(TBCapturePoints[i].entryFlagPole[GetDefenderTeam()], TBCapturePoints[i].pos, QuaternionData::fromEulerAnglesZYX(TBCapturePoints[i].pos.GetOrientation(), 0.0f, 0.0f)))
             {
-                go->SetGoArtKit(GetDefenderTeam() == TEAM_ALLIANCE ? TB_GO_ARTKIT_FLAG_ALLIANCE : TB_GO_ARTKIT_FLAG_HORDE);
-                capturePoint->SetCapturePointData(go);
+                std::unique_ptr<TolBaradCapturePoint> controlZone = std::make_unique<TolBaradCapturePoint>(this, TBCapturePoints[i]);
+                if (GetDefenderTeam() == TEAM_ALLIANCE)
+                {
+                    sWorldStateMgr->SetValue(controlZone->GetWorldStateAllianceControlled(), 1, false, GetMap());
+                    go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(100));
+                    go->SetGoArtKit(TB_GO_ARTKIT_FLAG_ALLIANCE);
+                }
+                else if (GetDefenderTeam() == TEAM_HORDE)
+                {
+                    sWorldStateMgr->SetValue(controlZone->GetWorldStateHordeControlled(), 1, false, GetMap());
+                    go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(0));
+                    go->SetGoArtKit(TB_GO_ARTKIT_FLAG_HORDE);
+                }
+
+                ControlZoneHandlers[go->GetEntry()] = std::move(controlZone);
             }
-
-            AddCapturePoint(capturePoint);
         }
 
         for (ObjectGuid guid : BattleInactiveNPCs)
@@ -558,8 +574,9 @@ void BattlefieldTB::OnGameObjectCreate(GameObject* go)
     }
 }
 
-void BattlefieldTB::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* /*invoker*/)
+void BattlefieldTB::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* invoker)
 {
+    Battlefield::ProcessEvent(obj, eventId, invoker);
     if (!IsWarTime())
         return;
 
@@ -644,9 +661,19 @@ void BattlefieldTB::UpdateCapturedBaseCount()
 {
     uint32 numCapturedBases = 0; // How many bases attacker has captured
 
-    for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
-        if (itr->second->GetTeamId() == GetAttackerTeam())
-            numCapturedBases += 1;
+    // these world states are either 0 or 1
+    if (GetAttackerTeam() == TEAM_ALLIANCE)
+    {
+        numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_GARRISON_ALLIANCE_CONTROLLED, GetMap());
+        numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_VIGIL_ALLIANCE_CONTROLLED, GetMap());
+        numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_SLAGWORKS_ALLIANCE_CONTROLLED, GetMap());
+    }
+    else if (GetAttackerTeam() == TEAM_HORDE)
+    {
+        numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_GARRISON_HORDE_CONTROLLED, GetMap());
+        numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_VIGIL_HORDE_CONTROLLED, GetMap());
+        numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_SLAGWORKS_HORDE_CONTROLLED, GetMap());
+    }
 
     sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_BUILDINGS_CAPTURED, numCapturedBases, false, m_Map);
 
@@ -676,76 +703,65 @@ void BattlefieldTB::PromotePlayer(Player* killer)
     killer->CastSpell(killer, SPELL_TB_VETERAN, true);
 }
 
-TolBaradCapturePoint::TolBaradCapturePoint(BattlefieldTB* battlefield, TeamId teamInControl) : BfCapturePoint(battlefield)
+TolBaradCapturePoint::TolBaradCapturePoint(BattlefieldTB* battlefield, TBCapturePointSpawnData const& data) : BattlefieldControlZoneHandler(battlefield),
+    _textIdHordeCaptured(data.textGained[TEAM_HORDE]), _textIdAllianceCaptured(data.textGained[TEAM_ALLIANCE]),
+    _textIdHordeLost(data.textLost[TEAM_HORDE]), _textIdAllianceLost(data.textLost[TEAM_ALLIANCE]),
+    _worldstateHordeControlled(data.wsControlled[TEAM_HORDE]), _worldstateAllianceControlled(data.wsControlled[TEAM_ALLIANCE]),
+    _worldstateHordeCapturing(data.wsCapturing[TEAM_HORDE]), _worldstateAllianceCapturing(data.wsCapturing[TEAM_ALLIANCE]),
+    _worldstateNeutral(data.wsNeutral)
 {
-    m_Bf = battlefield;
-    m_team = teamInControl;
-    m_value = teamInControl == TEAM_ALLIANCE ? m_maxValue : -m_maxValue;
-    m_State = teamInControl == TEAM_ALLIANCE ? BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE : BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE;
 }
 
-void TolBaradCapturePoint::SendChangePhase()
+void TolBaradCapturePoint::HandleContestedEventHorde(GameObject* controlZone)
 {
-    if (m_OldState == m_State)
-        return;
+    BattlefieldControlZoneHandler::HandleContestedEventHorde(controlZone);
+}
 
-    // Find out index
-    uint8 iBase = TB_BASE_COUNT;
-    for (uint8 i = 0; i < TB_BASE_COUNT; i++)
-        if (GetCapturePointEntry() == TBCapturePoints[i].entryFlagPole[m_Bf->GetDefenderTeam()])
-            iBase = i;
+void TolBaradCapturePoint::HandleContestedEventAlliance(GameObject* controlZone)
+{
+    BattlefieldControlZoneHandler::HandleContestedEventAlliance(controlZone);
+}
 
-    if (iBase == TB_BASE_COUNT)
-        return;
+void TolBaradCapturePoint::HandleProgressEventHorde(GameObject* controlZone)
+{
+    BattlefieldControlZoneHandler::HandleProgressEventHorde(controlZone);
+    GetBattlefield()->SendWarning(_textIdHordeCaptured);
+    controlZone->SetGoArtKit(TB_GO_ARTKIT_FLAG_HORDE);
+    sWorldStateMgr->SetValue(_worldstateHordeControlled, 1, false, controlZone->GetMap());
+    sWorldStateMgr->SetValue(_worldstateHordeCapturing, 0, false, controlZone->GetMap());
+    GetBattlefield()->ProcessEvent(nullptr, EVENT_COUNT_CAPTURED_BASE, nullptr);
+}
 
-    // Turn off previous world state icon
-    switch (m_OldState)
-    {
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE:
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE:
-            sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsControlled[GetTeamId()], 0, false, m_Bf->GetMap());
-            break;
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-            sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_ALLIANCE], 0, false, m_Bf->GetMap());
-            break;
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-            sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_HORDE], 0, false, m_Bf->GetMap());
-            break;
-        default:
-            break;
-    }
+void TolBaradCapturePoint::HandleProgressEventAlliance(GameObject* controlZone)
+{
+    BattlefieldControlZoneHandler::HandleProgressEventAlliance(controlZone);
+    GetBattlefield()->SendWarning(_textIdAllianceCaptured);
+    controlZone->SetGoArtKit(TB_GO_ARTKIT_FLAG_ALLIANCE);
+    sWorldStateMgr->SetValue(_worldstateAllianceControlled, 1, false, controlZone->GetMap());
+    sWorldStateMgr->SetValue(_worldstateAllianceCapturing, 0, false, controlZone->GetMap());
+    GetBattlefield()->ProcessEvent(nullptr, EVENT_COUNT_CAPTURED_BASE, nullptr);
+}
 
-    // Turn on new world state icon and send warning
-    switch (m_State)
-    {
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE:
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE:
-            m_Bf->SendWarning(TBCapturePoints[iBase].textGained[GetTeamId()]);
-            sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsControlled[GetTeamId()], 1, false, m_Bf->GetMap());
-            GetCapturePointGo()->SetGoArtKit(GetTeamId() == TEAM_ALLIANCE ? TB_GO_ARTKIT_FLAG_ALLIANCE : TB_GO_ARTKIT_FLAG_HORDE);
-            break;
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-            m_Bf->SendWarning(TBCapturePoints[iBase].textLost[TEAM_HORDE]);
-            [[fallthrough]];
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-            sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_ALLIANCE], 1, false, m_Bf->GetMap());
-            GetCapturePointGo()->SetGoArtKit(TB_GO_ARTKIT_FLAG_NONE);
-            break;
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-            m_Bf->SendWarning(TBCapturePoints[iBase].textLost[TEAM_ALLIANCE]);
-            [[fallthrough]];
-        case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-            sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_HORDE], 1, false, m_Bf->GetMap());
-            GetCapturePointGo()->SetGoArtKit(TB_GO_ARTKIT_FLAG_NONE);
-            break;
-        default:
-            break;
-    }
+void TolBaradCapturePoint::HandleNeutralEventHorde(GameObject* controlZone)
+{
+    GetBattlefield()->SendWarning(_textIdHordeLost);
+    sWorldStateMgr->SetValue(_worldstateHordeControlled, 0, false, controlZone->GetMap());
+    sWorldStateMgr->SetValue(_worldstateAllianceCapturing, 1, false, controlZone->GetMap());
+    BattlefieldControlZoneHandler::HandleNeutralEventHorde(controlZone);
+}
 
-    // Update counter
-    m_Bf->ProcessEvent(nullptr, EVENT_COUNT_CAPTURED_BASE, nullptr);
+void TolBaradCapturePoint::HandleNeutralEventAlliance(GameObject* controlZone)
+{
+    GetBattlefield()->SendWarning(_textIdAllianceLost);
+    sWorldStateMgr->SetValue(_worldstateAllianceControlled, 0, false, controlZone->GetMap());
+    sWorldStateMgr->SetValue(_worldstateHordeCapturing, 1, false, controlZone->GetMap());
+    BattlefieldControlZoneHandler::HandleNeutralEventAlliance(controlZone);
+}
+
+void TolBaradCapturePoint::HandleNeutralEvent(GameObject* controlZone)
+{
+    BattlefieldControlZoneHandler::HandleNeutralEvent(controlZone);
+    controlZone->SetGoArtKit(TB_GO_ARTKIT_FLAG_NONE);
 }
 
 class Battlefield_tol_barad : public BattlefieldScript
diff --git a/src/server/scripts/Battlefield/BattlefieldTB.h b/src/server/scripts/Battlefield/BattlefieldTB.h
index f39e39d690c..5abc463fed0 100644
--- a/src/server/scripts/Battlefield/BattlefieldTB.h
+++ b/src/server/scripts/Battlefield/BattlefieldTB.h
@@ -533,12 +533,32 @@ TBGraveyardInfo const TBGraveyards[BATTLEFIELD_TB_GRAVEYARD_MAX] =
  * Tol Barad capture point *
  * ####################### */
 
-class TolBaradCapturePoint : public BfCapturePoint
+class TolBaradCapturePoint : public BattlefieldControlZoneHandler
 {
     public:
-        TolBaradCapturePoint(BattlefieldTB* battlefield, TeamId teamInControl);
-
-        void SendChangePhase() override;
+        TolBaradCapturePoint(BattlefieldTB* battlefield, TBCapturePointSpawnData const& data);
+
+        void HandleContestedEventHorde([[maybe_unused]] GameObject* controlZone) override;
+        void HandleContestedEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+        void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
+        void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+        void HandleNeutralEventHorde([[maybe_unused]] GameObject* controlZone) override;
+        void HandleNeutralEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+        void HandleNeutralEvent([[maybe_unused]] GameObject* controlZone) override;
+
+        uint32 GetWorldStateHordeControlled() const { return _worldstateHordeControlled; }
+        uint32 GetWorldStateAllianceControlled() const { return _worldstateAllianceControlled; }
+
+    private:
+        uint32 _textIdHordeCaptured;
+        uint32 _textIdAllianceCaptured;
+        uint32 _textIdHordeLost;
+        uint32 _textIdAllianceLost;
+        uint32 _worldstateHordeControlled;
+        uint32 _worldstateAllianceControlled;
+        uint32 _worldstateHordeCapturing;
+        uint32 _worldstateAllianceCapturing;
+        uint32 _worldstateNeutral;
 };
 
 /* ##################### *
diff --git a/src/server/scripts/Battlefield/BattlefieldWG.cpp b/src/server/scripts/Battlefield/BattlefieldWG.cpp
index f5ee13db181..a44916c10ec 100644
--- a/src/server/scripts/Battlefield/BattlefieldWG.cpp
+++ b/src/server/scripts/Battlefield/BattlefieldWG.cpp
@@ -928,11 +928,18 @@ void BattlefieldWG::OnGameObjectCreate(GameObject* go)
     {
         if (workshop->GetId() == workshopId)
         {
-            WintergraspCapturePoint* capturePoint = new WintergraspCapturePoint(this, GetAttackerTeam());
+            ControlZoneHandlers[go->GetEntry()] = std::make_unique<WintergraspCapturePoint>(this, workshop);
+            if (GetAttackerTeam() == TEAM_ALLIANCE)
+            {
+                //go->SetGoArtKit(); // todo set art kit
+                go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(100));
+            }
+            else if (GetAttackerTeam() == TEAM_HORDE)
+            {
+                //go->SetGoArtKit(); // todo set art kit
+                go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(0));
+            }
 
-            capturePoint->SetCapturePointData(go);
-            capturePoint->LinkToWorkshop(workshop);
-            AddCapturePoint(capturePoint);
             break;
         }
     }
@@ -1185,8 +1192,9 @@ void BattlefieldWG::UpdatedDestroyedTowerCount(TeamId team)
     }
 }
 
-void BattlefieldWG::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* /*invoker*/)
+void BattlefieldWG::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* invoker)
 {
+    Battlefield::ProcessEvent(obj, eventId, invoker);
     if (!obj || !IsWarTime())
         return;
 
@@ -1311,17 +1319,34 @@ void BattlefieldWG::UpdateTenacity()
         m_tenacityTeam = TEAM_NEUTRAL;
 }
 
-WintergraspCapturePoint::WintergraspCapturePoint(BattlefieldWG* battlefield, TeamId teamInControl) : BfCapturePoint(battlefield)
+WintergraspCapturePoint::WintergraspCapturePoint(BattlefieldWG* battlefield, WintergraspWorkshop* workshop) : BattlefieldControlZoneHandler(battlefield), m_Workshop(workshop)
 {
-    m_Bf = battlefield;
-    m_team = teamInControl;
-    m_Workshop = nullptr;
 }
 
-void WintergraspCapturePoint::ChangeTeam(TeamId /*oldTeam*/)
+void WintergraspCapturePoint::HandleContestedEventHorde(GameObject* controlZone)
+{
+    ASSERT(m_Workshop);
+    BattlefieldControlZoneHandler::HandleContestedEventHorde(controlZone);
+    m_Workshop->GiveControlTo(TEAM_NEUTRAL);
+}
+
+void WintergraspCapturePoint::HandleContestedEventAlliance(GameObject* controlZone)
+{
+    ASSERT(m_Workshop);
+    BattlefieldControlZoneHandler::HandleContestedEventAlliance(controlZone);
+    m_Workshop->GiveControlTo(TEAM_NEUTRAL);
+}
+
+void WintergraspCapturePoint::HandleProgressEventHorde(GameObject* /*controlZone*/)
+{
+    ASSERT(m_Workshop);
+    m_Workshop->GiveControlTo(TEAM_HORDE);
+}
+
+void WintergraspCapturePoint::HandleProgressEventAlliance(GameObject* /*controlZone*/)
 {
     ASSERT(m_Workshop);
-    m_Workshop->GiveControlTo(m_team);
+    m_Workshop->GiveControlTo(TEAM_ALLIANCE);
 }
 
 BfGraveyardWG::BfGraveyardWG(BattlefieldWG* battlefield) : BfGraveyard(battlefield)
diff --git a/src/server/scripts/Battlefield/BattlefieldWG.h b/src/server/scripts/Battlefield/BattlefieldWG.h
index 3f10861fe58..001c8f1a07a 100644
--- a/src/server/scripts/Battlefield/BattlefieldWG.h
+++ b/src/server/scripts/Battlefield/BattlefieldWG.h
@@ -179,15 +179,15 @@ enum WintergraspNpcs
  *  WintergraspCapturePoint  *
  * ######################### */
 
-class WintergraspCapturePoint : public BfCapturePoint
+class WintergraspCapturePoint : public BattlefieldControlZoneHandler
 {
     public:
-        WintergraspCapturePoint(BattlefieldWG* battlefield, TeamId teamInControl);
+        WintergraspCapturePoint(BattlefieldWG* battlefield, WintergraspWorkshop* workshop);
 
-        void LinkToWorkshop(WintergraspWorkshop* workshop) { m_Workshop = workshop; }
-
-        void ChangeTeam(TeamId oldteam) override;
-        TeamId GetTeam() const { return m_team; }
+        void HandleContestedEventHorde([[maybe_unused]] GameObject* controlZone) override;
+        void HandleContestedEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+        void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
+        void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
 
     protected:
         WintergraspWorkshop* m_Workshop;
diff --git a/src/server/scripts/OutdoorPvP/OutdoorPvPHP.cpp b/src/server/scripts/OutdoorPvP/OutdoorPvPHP.cpp
index 1a880c0748e..311ea43f84d 100644
--- a/src/server/scripts/OutdoorPvP/OutdoorPvPHP.cpp
+++ b/src/server/scripts/OutdoorPvP/OutdoorPvPHP.cpp
@@ -18,38 +18,52 @@
 #include "OutdoorPvPHP.h"
 #include "GameObject.h"
 #include "Map.h"
+#include "ObjectAccessor.h"
 #include "Player.h"
 #include "ScriptMgr.h"
 #include "WorldStatePackets.h"
 
 uint32 const OutdoorPvPHPBuffZonesNum = 6;
 uint32 const OutdoorPvPHPBuffZones[OutdoorPvPHPBuffZonesNum] = { 3483, 3563, 3562, 3713, 3714, 3836 }; //  HP, citadel, ramparts, blood furnace, shattered halls, mag's lair
-uint32 const HP_CREDITMARKER[HP_TOWER_NUM] = { 19032, 19028, 19029 };
-//uint32 const HP_CapturePointEvent_Enter[HP_TOWER_NUM] = { 11404, 11396, 11388 };
-//uint32 const HP_CapturePointEvent_Leave[HP_TOWER_NUM] = { 11403, 11395, 11387 };
-uint32 const HP_MAP_N[HP_TOWER_NUM] = { 2485, 2482, 2472 };
-uint32 const HP_MAP_A[HP_TOWER_NUM] = { 2483, 2480, 2471 };
-uint32 const HP_MAP_H[HP_TOWER_NUM] = { 2484, 2481, 2470 };
-uint32 const HP_TowerArtKit_A[HP_TOWER_NUM] = { 65, 62, 67 };
-uint32 const HP_TowerArtKit_H[HP_TOWER_NUM] = { 64, 61, 68 };
-uint32 const HP_TowerArtKit_N[HP_TOWER_NUM] = { 66, 63, 69 };
-
-uint32 const HP_LANG_CAPTURE_A[HP_TOWER_NUM] = { TEXT_BROKEN_HILL_TAKEN_ALLIANCE, TEXT_OVERLOOK_TAKEN_ALLIANCE, TEXT_STADIUM_TAKEN_ALLIANCE };
-uint32 const HP_LANG_CAPTURE_H[HP_TOWER_NUM] = { TEXT_BROKEN_HILL_TAKEN_HORDE, TEXT_OVERLOOK_TAKEN_HORDE, TEXT_STADIUM_TAKEN_HORDE };
-
-OPvPCapturePointHP::OPvPCapturePointHP(OutdoorPvP* pvp, OutdoorPvPHPTowerType type, GameObject* go, ObjectGuid::LowType const& flagSpawnId)
-    : OPvPCapturePoint(pvp), m_TowerType(type), m_flagSpawnId(flagSpawnId)
-{
-    m_capturePointSpawnId = go->GetSpawnId();
-    m_capturePoint = go;
-    SetCapturePointData(go->GetEntry());
-}
 
-OutdoorPvPHP::OutdoorPvPHP(Map* map) : OutdoorPvP(map), m_towerFlagSpawnIds()
+OutdoorPvPHP::OutdoorPvPHP(Map* map) : OutdoorPvP(map)
 {
     m_TypeId = OUTDOOR_PVP_HP;
     m_AllianceTowersControlled = 0;
     m_HordeTowersControlled = 0;
+
+    ControlZoneHandlers[HP_GO_ENTRY_TOWER_S] = std::make_unique<HPControlZoneHandler>(this);
+    GetControlZoneTowerSouthHandler().SetFlagArtKitAlliance(65);
+    GetControlZoneTowerSouthHandler().SetFlagArtKitHorde(64);
+    GetControlZoneTowerSouthHandler().SetFlagArtKitNeutral(66);
+    GetControlZoneTowerSouthHandler().SetTextCaptureAlliance(TEXT_BROKEN_HILL_TAKEN_ALLIANCE);
+    GetControlZoneTowerSouthHandler().SetTextCaptureHorde(TEXT_BROKEN_HILL_TAKEN_HORDE);
+    GetControlZoneTowerSouthHandler().SetWorldstateAlliance(HP_UI_TOWER_S_A);
+    GetControlZoneTowerSouthHandler().SetWorldstateHorde(HP_UI_TOWER_S_H);
+    GetControlZoneTowerSouthHandler().SetWorldstateNeutral(HP_UI_TOWER_S_N);
+    GetControlZoneTowerSouthHandler().SetKillCredit(HP_KILL_CREDIT_TOWER_S);
+
+    ControlZoneHandlers[HP_GO_ENTRY_TOWER_N] = std::make_unique<HPControlZoneHandler>(this);
+    GetControlZoneTowerNorthHandler().SetFlagArtKitAlliance(62);
+    GetControlZoneTowerNorthHandler().SetFlagArtKitHorde(61);
+    GetControlZoneTowerNorthHandler().SetFlagArtKitNeutral(63);
+    GetControlZoneTowerNorthHandler().SetTextCaptureAlliance(TEXT_OVERLOOK_TAKEN_ALLIANCE);
+    GetControlZoneTowerNorthHandler().SetTextCaptureHorde(TEXT_OVERLOOK_TAKEN_HORDE);
+    GetControlZoneTowerNorthHandler().SetWorldstateAlliance(HP_UI_TOWER_N_A);
+    GetControlZoneTowerNorthHandler().SetWorldstateHorde(HP_UI_TOWER_N_H);
+    GetControlZoneTowerNorthHandler().SetWorldstateNeutral(HP_UI_TOWER_N_N);
+    GetControlZoneTowerNorthHandler().SetKillCredit(HP_KILL_CREDIT_TOWER_N);
+
+    ControlZoneHandlers[HP_GO_ENTRY_TOWER_W] = std::make_unique<HPControlZoneHandler>(this);
+    GetControlZoneTowerWestHandler().SetFlagArtKitAlliance(67);
+    GetControlZoneTowerWestHandler().SetFlagArtKitHorde(68);
+    GetControlZoneTowerWestHandler().SetFlagArtKitNeutral(69);
+    GetControlZoneTowerWestHandler().SetTextCaptureAlliance(TEXT_STADIUM_TAKEN_ALLIANCE);
+    GetControlZoneTowerWestHandler().SetTextCaptureHorde(TEXT_STADIUM_TAKEN_HORDE);
+    GetControlZoneTowerWestHandler().SetWorldstateAlliance(HP_UI_TOWER_W_A);
+    GetControlZoneTowerWestHandler().SetWorldstateHorde(HP_UI_TOWER_W_H);
+    GetControlZoneTowerWestHandler().SetWorldstateNeutral(HP_UI_TOWER_W_N);
+    GetControlZoneTowerWestHandler().SetKillCredit(HP_KILL_CREDIT_TOWER_W);
 }
 
 bool OutdoorPvPHP::SetupOutdoorPvP()
@@ -66,25 +80,19 @@ bool OutdoorPvPHP::SetupOutdoorPvP()
 
 void OutdoorPvPHP::OnGameObjectCreate(GameObject* go)
 {
+    if (go->GetGoType() == GAMEOBJECT_TYPE_CONTROL_ZONE)
+        _controlZoneGUIDs.insert(go->GetGUID());
+
     switch (go->GetEntry())
     {
-        case 182175:
-            AddCapturePoint(new OPvPCapturePointHP(this, HP_TOWER_BROKEN_HILL, go, m_towerFlagSpawnIds[HP_TOWER_BROKEN_HILL]));
-            break;
-        case 182174:
-            AddCapturePoint(new OPvPCapturePointHP(this, HP_TOWER_OVERLOOK, go, m_towerFlagSpawnIds[HP_TOWER_OVERLOOK]));
-            break;
-        case 182173:
-            AddCapturePoint(new OPvPCapturePointHP(this, HP_TOWER_STADIUM, go, m_towerFlagSpawnIds[HP_TOWER_STADIUM]));
-            break;
         case 183514:
-            m_towerFlagSpawnIds[HP_TOWER_BROKEN_HILL] = go->GetSpawnId();
+            GetControlZoneTowerSouthHandler().SetFlagGuid(go->GetGUID());
             break;
         case 182525:
-            m_towerFlagSpawnIds[HP_TOWER_OVERLOOK] = go->GetSpawnId();
+            GetControlZoneTowerNorthHandler().SetFlagGuid(go->GetGUID());
             break;
         case 183515:
-            m_towerFlagSpawnIds[HP_TOWER_STADIUM] = go->GetSpawnId();
+            GetControlZoneTowerWestHandler().SetFlagGuid(go->GetGUID());
             break;
         default:
             break;
@@ -123,24 +131,20 @@ void OutdoorPvPHP::HandlePlayerLeaveZone(Player* player, uint32 zone)
     OutdoorPvP::HandlePlayerLeaveZone(player, zone);
 }
 
-bool OutdoorPvPHP::Update(uint32 diff)
+void OutdoorPvPHP::Update(uint32 diff)
 {
-    bool changed = OutdoorPvP::Update(diff);
-    if (changed)
+    OutdoorPvP::Update(diff);
+    if (m_AllianceTowersControlled == 3)
+        TeamApplyBuff(TEAM_ALLIANCE, AllianceBuff, HordeBuff);
+    else if (m_HordeTowersControlled == 3)
+        TeamApplyBuff(TEAM_HORDE, HordeBuff, AllianceBuff);
+    else
     {
-        if (m_AllianceTowersControlled == 3)
-            TeamApplyBuff(TEAM_ALLIANCE, AllianceBuff, HordeBuff);
-        else if (m_HordeTowersControlled == 3)
-            TeamApplyBuff(TEAM_HORDE, HordeBuff, AllianceBuff);
-        else
-        {
-            TeamCastSpell(TEAM_ALLIANCE, -AllianceBuff);
-            TeamCastSpell(TEAM_HORDE, -HordeBuff);
-        }
-        SetWorldState(HP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
-        SetWorldState(HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
+        TeamCastSpell(TEAM_ALLIANCE, -AllianceBuff);
+        TeamCastSpell(TEAM_HORDE, -HordeBuff);
     }
-    return changed;
+    SetWorldState(HP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
+    SetWorldState(HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
 }
 
 void OutdoorPvPHP::SendRemoveWorldStates(Player* player)
@@ -154,128 +158,46 @@ void OutdoorPvPHP::SendRemoveWorldStates(Player* player)
     initWorldStates.Worldstates.emplace_back(HP_UI_TOWER_COUNT_H, 0);
     initWorldStates.Worldstates.emplace_back(HP_UI_TOWER_COUNT_A, 0);
 
-    for (size_t i = 0; i < HP_TOWER_NUM; ++i)
+    for (auto& itr : ControlZoneHandlers)
     {
-        initWorldStates.Worldstates.emplace_back(HP_MAP_N[i], 0);
-        initWorldStates.Worldstates.emplace_back(HP_MAP_A[i], 0);
-        initWorldStates.Worldstates.emplace_back(HP_MAP_H[i], 0);
+        HPControlZoneHandler* handler = static_cast<HPControlZoneHandler*>(itr.second.get());
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateNeutral(), 0);
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateHorde(), 0);
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateAlliance(), 0);
     }
 
     player->SendDirectMessage(initWorldStates.Write());
 }
 
-void OPvPCapturePointHP::ChangeState()
+void OutdoorPvPHP::HandleKillImpl(Player* player, Unit* killed)
 {
-    uint32 field = 0;
-    switch (m_OldState)
-    {
-    case OBJECTIVESTATE_NEUTRAL:
-        field = HP_MAP_N[m_TowerType];
-        break;
-    case OBJECTIVESTATE_ALLIANCE:
-        field = HP_MAP_A[m_TowerType];
-        if (uint32 alliance_towers = ((OutdoorPvPHP*)m_PvP)->GetAllianceTowersControlled())
-            ((OutdoorPvPHP*)m_PvP)->SetAllianceTowersControlled(--alliance_towers);
-        break;
-    case OBJECTIVESTATE_HORDE:
-        field = HP_MAP_H[m_TowerType];
-        if (uint32 horde_towers = ((OutdoorPvPHP*)m_PvP)->GetHordeTowersControlled())
-            ((OutdoorPvPHP*)m_PvP)->SetHordeTowersControlled(--horde_towers);
-        break;
-    case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-        field = HP_MAP_N[m_TowerType];
-        break;
-    case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-        field = HP_MAP_N[m_TowerType];
-        break;
-    case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-        field = HP_MAP_A[m_TowerType];
-        break;
-    case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-        field = HP_MAP_H[m_TowerType];
-        break;
-    }
+    if (killed->GetTypeId() != TYPEID_PLAYER)
+        return;
 
-    // send world state update
-    if (field)
+    // need to check if player is inside an capture zone
+    bool isInsideCaptureZone = false;
+    for (ObjectGuid const& guid : _controlZoneGUIDs)
     {
-        m_PvP->SetWorldState(field, 0);
-        field = 0;
-    }
-    uint32 artkit = 21;
-    uint32 artkit2 = HP_TowerArtKit_N[m_TowerType];
-    switch (m_State)
-    {
-    case OBJECTIVESTATE_NEUTRAL:
-        field = HP_MAP_N[m_TowerType];
-        break;
-    case OBJECTIVESTATE_ALLIANCE:
-    {
-        field = HP_MAP_A[m_TowerType];
-        artkit = 2;
-        artkit2 = HP_TowerArtKit_A[m_TowerType];
-        uint32 alliance_towers = ((OutdoorPvPHP*)m_PvP)->GetAllianceTowersControlled();
-        if (alliance_towers < 3)
-            ((OutdoorPvPHP*)m_PvP)->SetAllianceTowersControlled(++alliance_towers);
-        m_PvP->SendDefenseMessage(OutdoorPvPHPBuffZones[0], HP_LANG_CAPTURE_A[m_TowerType]);
-        break;
+        if (GameObject* gameObject = GetMap()->GetGameObject(guid))
+        {
+            if (GuidUnorderedSet const* insidePlayerGuids = gameObject->GetInsidePlayers())
+            {
+                if (insidePlayerGuids->contains(player->GetGUID()))
+                {
+                    isInsideCaptureZone = true;
+                    break;
+                }
+            }
+        }
     }
-    case OBJECTIVESTATE_HORDE:
+
+    if (isInsideCaptureZone)
     {
-        field = HP_MAP_H[m_TowerType];
-        artkit = 1;
-        artkit2 = HP_TowerArtKit_H[m_TowerType];
-        uint32 horde_towers = ((OutdoorPvPHP*)m_PvP)->GetHordeTowersControlled();
-        if (horde_towers < 3)
-            ((OutdoorPvPHP*)m_PvP)->SetHordeTowersControlled(++horde_towers);
-        m_PvP->SendDefenseMessage(OutdoorPvPHPBuffZones[0], HP_LANG_CAPTURE_H[m_TowerType]);
-        break;
+        if (player->GetTeam() == ALLIANCE && killed->ToPlayer()->GetTeam() != ALLIANCE)
+            player->CastSpell(player, AlliancePlayerKillReward, true);
+        else if (player->GetTeam() == HORDE && killed->ToPlayer()->GetTeam() != HORDE)
+            player->CastSpell(player, HordePlayerKillReward, true);
     }
-    case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-        field = HP_MAP_N[m_TowerType];
-        break;
-    case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-        field = HP_MAP_N[m_TowerType];
-        break;
-    case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-        field = HP_MAP_A[m_TowerType];
-        artkit = 2;
-        artkit2 = HP_TowerArtKit_A[m_TowerType];
-        break;
-    case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-        field = HP_MAP_H[m_TowerType];
-        artkit = 1;
-        artkit2 = HP_TowerArtKit_H[m_TowerType];
-        break;
-    }
-
-    Map* map = m_PvP->GetMap();
-    auto bounds = map->GetGameObjectBySpawnIdStore().equal_range(m_capturePointSpawnId);
-    for (auto itr = bounds.first; itr != bounds.second; ++itr)
-        itr->second->SetGoArtKit(artkit);
-
-    bounds = map->GetGameObjectBySpawnIdStore().equal_range(m_flagSpawnId);
-    for (auto itr = bounds.first; itr != bounds.second; ++itr)
-        itr->second->SetGoArtKit(artkit2);
-
-    // send world state update
-    if (field)
-        m_PvP->SetWorldState(field, 1);
-
-    // complete quest objective
-    if (m_State == OBJECTIVESTATE_ALLIANCE || m_State == OBJECTIVESTATE_HORDE)
-        SendObjectiveComplete(HP_CREDITMARKER[m_TowerType], ObjectGuid::Empty);
-}
-
-void OutdoorPvPHP::HandleKillImpl(Player* player, Unit* killed)
-{
-    if (killed->GetTypeId() != TYPEID_PLAYER)
-        return;
-
-    if (player->GetTeam() == ALLIANCE && killed->ToPlayer()->GetTeam() != ALLIANCE)
-        player->CastSpell(player, AlliancePlayerKillReward, true);
-    else if (player->GetTeam() == HORDE && killed->ToPlayer()->GetTeam() != HORDE)
-        player->CastSpell(player, HordePlayerKillReward, true);
 }
 
 uint32 OutdoorPvPHP::GetAllianceTowersControlled() const
@@ -298,6 +220,88 @@ void OutdoorPvPHP::SetHordeTowersControlled(uint32 count)
     m_HordeTowersControlled = count;
 }
 
+HPControlZoneHandler::HPControlZoneHandler(OutdoorPvPHP* pvp) : OutdoorPvPControlZoneHandler(pvp),
+    _flagGuid(ObjectGuid::Empty), _textCaptureAlliance(0), _textCaptureHorde(0),
+    _flagArtKitNeutral(0), _flagArtKitHorde(0), _flagArtKitAlliance(0),
+    _worldstateNeutral(0), _worldstateHorde(0), _worldstateAlliance(0),
+    _killCredit(0)
+{
+}
+
+void HPControlZoneHandler::HandleProgressEventHorde(GameObject* controlZone)
+{
+    ControlZoneHandler::HandleProgressEventHorde(controlZone);
+
+    controlZone->SetGoArtKit(1);
+    controlZone->SendCustomAnim(0);
+    if (GameObject* flag = controlZone->GetMap()->GetGameObject(_flagGuid))
+        flag->SetGoArtKit(_flagArtKitHorde);
+
+    controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 1, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 0, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 0, false);
+
+    GetOutdoorPvPHP()->SendDefenseMessage(OutdoorPvPHPBuffZones[0], _textCaptureHorde);
+
+    if (GuidUnorderedSet const* guidSet = controlZone->GetInsidePlayers())
+        for (ObjectGuid const& guid : *guidSet)
+            if (Player* player = ObjectAccessor::GetPlayer(*controlZone, guid))
+                if (player->GetTeam() == TEAM_HORDE)
+                    player->KilledMonsterCredit(_killCredit);
+}
+
+void HPControlZoneHandler::HandleProgressEventAlliance(GameObject* controlZone)
+{
+    ControlZoneHandler::HandleProgressEventAlliance(controlZone);
+
+    controlZone->SetGoArtKit(2);
+    controlZone->SendCustomAnim(1);
+    if (GameObject* flag = controlZone->GetMap()->GetGameObject(_flagGuid))
+        flag->SetGoArtKit(_flagArtKitAlliance);
+
+    controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 0, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 1, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 0, false);
+
+    GetOutdoorPvPHP()->SendDefenseMessage(OutdoorPvPHPBuffZones[0], _textCaptureAlliance);
+
+    if (GuidUnorderedSet const* guidSet = controlZone->GetInsidePlayers())
+        for (ObjectGuid const& guid : *guidSet)
+            if (Player* player = ObjectAccessor::GetPlayer(*controlZone, guid))
+                if (player->GetTeam() == TEAM_ALLIANCE)
+                    player->KilledMonsterCredit(_killCredit);
+}
+
+void HPControlZoneHandler::HandleNeutralEventHorde(GameObject* controlZone)
+{
+    ControlZoneHandler::HandleNeutralEventHorde(controlZone);
+    GetOutdoorPvPHP()->SetHordeTowersControlled(GetOutdoorPvPHP()->GetHordeTowersControlled() - 1);
+}
+
+void HPControlZoneHandler::HandleNeutralEventAlliance(GameObject* controlZone)
+{
+    ControlZoneHandler::HandleNeutralEventAlliance(controlZone);
+    GetOutdoorPvPHP()->SetAllianceTowersControlled(GetOutdoorPvPHP()->GetAllianceTowersControlled() - 1);
+}
+
+void HPControlZoneHandler::HandleNeutralEvent(GameObject* controlZone)
+{
+    ControlZoneHandler::HandleNeutralEvent(controlZone);
+    controlZone->SetGoArtKit(21);
+    controlZone->SendCustomAnim(2);
+    if (GameObject* flag = controlZone->GetMap()->GetGameObject(_flagGuid))
+        flag->SetGoArtKit(_flagArtKitNeutral);
+
+    controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 0, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 0, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 1, false);
+}
+
+OutdoorPvPHP* HPControlZoneHandler::GetOutdoorPvPHP() const
+{
+    return static_cast<OutdoorPvPHP*>(OutdoorPvPControlZoneHandler::GetOutdoorPvP());
+}
+
 class OutdoorPvP_hellfire_peninsula : public OutdoorPvPScript
 {
     public:
diff --git a/src/server/scripts/OutdoorPvP/OutdoorPvPHP.h b/src/server/scripts/OutdoorPvP/OutdoorPvPHP.h
index 69b847c1107..416223e5e2d 100644
--- a/src/server/scripts/OutdoorPvP/OutdoorPvPHP.h
+++ b/src/server/scripts/OutdoorPvP/OutdoorPvPHP.h
@@ -53,19 +53,94 @@ enum OutdoorPvPHPWorldStates
     HP_UI_TOWER_DISPLAY_H = 0x9b9,
 
     HP_UI_TOWER_COUNT_H = 0x9ae,
-    HP_UI_TOWER_COUNT_A = 0x9ac
+    HP_UI_TOWER_COUNT_A = 0x9ac,
+
+    HP_UI_TOWER_S_A = 2483,
+    HP_UI_TOWER_S_H = 2484,
+    HP_UI_TOWER_S_N = 2485,
+
+    HP_UI_TOWER_N_A = 2480,
+    HP_UI_TOWER_N_H = 2481,
+    HP_UI_TOWER_N_N = 2482,
+
+    HP_UI_TOWER_W_A = 2471,
+    HP_UI_TOWER_W_H = 2470,
+    HP_UI_TOWER_W_N = 2472
 };
 
-class OPvPCapturePointHP : public OPvPCapturePoint
+enum OutdoorPvPHPEvents
 {
-    public:
-        OPvPCapturePointHP(OutdoorPvP* pvp, OutdoorPvPHPTowerType type, GameObject* go, ObjectGuid::LowType const& flagSpawnId);
+    HP_EVENT_TOWER_W_PROGRESS_HORDE = 11383,
+    HP_EVENT_TOWER_W_PROGRESS_ALLIANCE = 11387,
+    HP_EVENT_TOWER_W_NEUTRAL_HORDE = 11386,
+    HP_EVENT_TOWER_W_NEUTRAL_ALLIANCE = 11385,
+
+    HP_EVENT_TOWER_N_PROGRESS_HORDE = 11396,
+    HP_EVENT_TOWER_N_PROGRESS_ALLIANCE = 11395,
+    HP_EVENT_TOWER_N_NEUTRAL_HORDE = 11394,
+    HP_EVENT_TOWER_N_NEUTRAL_ALLIANCE = 11393,
+
+    HP_EVENT_TOWER_S_PROGRESS_HORDE = 11404,
+    HP_EVENT_TOWER_S_PROGRESS_ALLIANCE = 11403,
+    HP_EVENT_TOWER_S_NEUTRAL_HORDE = 11402,
+    HP_EVENT_TOWER_S_NEUTRAL_ALLIANCE = 11401
+};
 
-        void ChangeState() override;
+enum OutdoorPvPHPGameObjectEntries
+{
+    HP_GO_ENTRY_TOWER_W = 182173,
+    HP_GO_ENTRY_TOWER_N = 182174,
+    HP_GO_ENTRY_TOWER_S = 182175
+};
 
-    private:
-        OutdoorPvPHPTowerType m_TowerType;
-        ObjectGuid::LowType const& m_flagSpawnId;
+enum OutdoorPvPHPCredit
+{
+    HP_KILL_CREDIT_TOWER_S = 19032,
+    HP_KILL_CREDIT_TOWER_N = 19028,
+    HP_KILL_CREDIT_TOWER_W = 19029
+};
+
+class OutdoorPvPHP;
+
+class HPControlZoneHandler : public OutdoorPvPControlZoneHandler
+{
+public:
+    explicit HPControlZoneHandler(OutdoorPvPHP* pvp);
+
+    void SetFlagGuid(ObjectGuid const& guid) { _flagGuid = guid; }
+    void SetTextCaptureHorde(uint32 text) { _textCaptureHorde = text; }
+    void SetTextCaptureAlliance(uint32 text) { _textCaptureAlliance = text; }
+    void SetFlagArtKitNeutral(uint32 artKit) { _flagArtKitNeutral = artKit; }
+    void SetFlagArtKitHorde(uint32 artKit) { _flagArtKitHorde = artKit; }
+    void SetFlagArtKitAlliance(uint32 artKit) { _flagArtKitAlliance = artKit; }
+    void SetWorldstateNeutral(uint32 id) { _worldstateNeutral = id; }
+    void SetWorldstateHorde(uint32 id) { _worldstateHorde = id; }
+    void SetWorldstateAlliance(uint32 id) { _worldstateAlliance = id; }
+    void SetKillCredit(uint32 credit) { _killCredit = credit; }
+
+    void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
+    void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEventHorde([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEvent([[maybe_unused]] GameObject* controlZone) override;
+
+    uint32 GetWorldStateNeutral() { return _worldstateNeutral; }
+    uint32 GetWorldStateHorde() { return _worldstateHorde; }
+    uint32 GetWorldStateAlliance() { return _worldstateAlliance; }
+
+    OutdoorPvPHP* GetOutdoorPvPHP() const;
+
+private:
+    ObjectGuid _flagGuid;
+    uint32 _textCaptureAlliance;
+    uint32 _textCaptureHorde;
+    uint32 _flagArtKitNeutral;
+    uint32 _flagArtKitHorde;
+    uint32 _flagArtKitAlliance;
+    uint32 _worldstateNeutral;
+    uint32 _worldstateHorde;
+    uint32 _worldstateAlliance;
+    uint32 _killCredit;
 };
 
 class OutdoorPvPHP : public OutdoorPvP
@@ -80,7 +155,7 @@ class OutdoorPvPHP : public OutdoorPvP
         void HandlePlayerEnterZone(Player* player, uint32 zone) override;
         void HandlePlayerLeaveZone(Player* player, uint32 zone) override;
 
-        bool Update(uint32 diff) override;
+        void Update(uint32 diff) override;
         void SendRemoveWorldStates(Player* player) override;
         void HandleKillImpl(Player* player, Unit* killed) override;
 
@@ -92,7 +167,12 @@ class OutdoorPvPHP : public OutdoorPvP
     private:
         uint32 m_AllianceTowersControlled; // how many towers are controlled
         uint32 m_HordeTowersControlled;
-        std::array<ObjectGuid::LowType, HP_TOWER_NUM> m_towerFlagSpawnIds;
+
+        GuidUnorderedSet _controlZoneGUIDs;
+
+        HPControlZoneHandler& GetControlZoneTowerNorthHandler() { return *static_cast<HPControlZoneHandler*>(ControlZoneHandlers[HP_GO_ENTRY_TOWER_N].get()); }
+        HPControlZoneHandler& GetControlZoneTowerSouthHandler() { return *static_cast<HPControlZoneHandler*>(ControlZoneHandlers[HP_GO_ENTRY_TOWER_S].get()); }
+        HPControlZoneHandler& GetControlZoneTowerWestHandler() { return *static_cast<HPControlZoneHandler*>(ControlZoneHandlers[HP_GO_ENTRY_TOWER_W].get()); }
 };
 
 #endif
diff --git a/src/server/scripts/OutdoorPvP/OutdoorPvPNA.cpp b/src/server/scripts/OutdoorPvP/OutdoorPvPNA.cpp
index 06691aa8a0e..4453d9435cf 100644
--- a/src/server/scripts/OutdoorPvP/OutdoorPvPNA.cpp
+++ b/src/server/scripts/OutdoorPvP/OutdoorPvPNA.cpp
@@ -40,6 +40,7 @@ OutdoorPvPNA::OutdoorPvPNA(Map* map) : OutdoorPvP(map)
 {
     m_TypeId = OUTDOOR_PVP_NA;
     m_obj = nullptr;
+    ControlZoneHandlers[182210] = std::make_unique<NAControlZoneHandler>(this);
 }
 
 void OutdoorPvPNA::OnGameObjectCreate(GameObject* go)
@@ -47,8 +48,7 @@ void OutdoorPvPNA::OnGameObjectCreate(GameObject* go)
     switch (go->GetEntry())
     {
         case 182210:
-            m_obj->m_capturePointSpawnId = go->GetSpawnId();
-            AddCapturePoint(m_obj);
+            m_obj->SetControlZoneGUID(go->GetGUID());
             break;
     }
 
@@ -67,6 +67,91 @@ void OutdoorPvPNA::HandleKillImpl(Player* player, Unit* killed)
     }
 }
 
+NAControlZoneHandler::NAControlZoneHandler(OutdoorPvPNA* pvp) : OutdoorPvPControlZoneHandler(pvp)
+{
+}
+
+void NAControlZoneHandler::HandleCaptureEventHorde(GameObject* controlZone)
+{
+    OutdoorPvPControlZoneHandler::HandleCaptureEventHorde(controlZone);
+
+    if (GetOutdoorPvPNA()->GetCapturePoint()->GetControllingFaction() != HORDE)
+    {
+        GetOutdoorPvPNA()->SendMapWorldStates(0, 0, 0, 1, 0);
+        GetOutdoorPvPNA()->GetCapturePoint()->FactionTakeOver(HORDE);
+    }
+}
+
+void NAControlZoneHandler::HandleCaptureEventAlliance(GameObject* controlZone)
+{
+    OutdoorPvPControlZoneHandler::HandleCaptureEventAlliance(controlZone);
+
+    if (GetOutdoorPvPNA()->GetCapturePoint()->GetControllingFaction() != ALLIANCE)
+    {
+        GetOutdoorPvPNA()->SendMapWorldStates(0, 0, 0, 0, 1);
+        GetOutdoorPvPNA()->GetCapturePoint()->FactionTakeOver(ALLIANCE);
+    }
+}
+
+void NAControlZoneHandler::HandleContestedEventHorde(GameObject* controlZone)
+{
+    OutdoorPvPControlZoneHandler::HandleContestedEventHorde(controlZone);
+
+    GetOutdoorPvPNA()->SendMapWorldStates(0, 1, 0, 0, 0);
+}
+
+void NAControlZoneHandler::HandleContestedEventAlliance(GameObject* controlZone)
+{
+    OutdoorPvPControlZoneHandler::HandleContestedEventAlliance(controlZone);
+
+    GetOutdoorPvPNA()->SendMapWorldStates(0, 0, 1, 0, 0);
+}
+
+void NAControlZoneHandler::HandleProgressEventHorde(GameObject* controlZone)
+{
+    OutdoorPvPControlZoneHandler::HandleProgressEventHorde(controlZone);
+
+    controlZone->SetGoArtKit(1);
+    GetOutdoorPvPNA()->SendMapWorldStates(0, 1, 0, 0, 0);
+}
+
+void NAControlZoneHandler::HandleProgressEventAlliance(GameObject* controlZone)
+{
+    OutdoorPvPControlZoneHandler::HandleProgressEventAlliance(controlZone);
+
+    controlZone->SetGoArtKit(2);
+    GetOutdoorPvPNA()->SendMapWorldStates(0, 0, 1, 0, 0);
+}
+
+void NAControlZoneHandler::HandleNeutralEventHorde(GameObject* controlZone)
+{
+    OutdoorPvPControlZoneHandler::HandleNeutralEventHorde(controlZone);
+}
+
+void NAControlZoneHandler::HandleNeutralEventAlliance(GameObject* controlZone)
+{
+    OutdoorPvPControlZoneHandler::HandleNeutralEventAlliance(controlZone);
+}
+
+void NAControlZoneHandler::HandleNeutralEvent(GameObject* controlZone)
+{
+    OutdoorPvPControlZoneHandler::HandleNeutralEvent(controlZone);
+}
+
+OutdoorPvPNA* NAControlZoneHandler::GetOutdoorPvPNA() const
+{
+    return static_cast<OutdoorPvPNA*>(OutdoorPvPControlZoneHandler::GetOutdoorPvP());
+}
+
+void OutdoorPvPNA::SendMapWorldStates(int32 neutral, int32 progressHorde, int32 progressAlliance, int32 capturedHorde, int32 captureAlliance)
+{
+    SetWorldState(NA_MAP_HALAA_NEUTRAL, neutral);
+    SetWorldState(NA_MAP_HALAA_NEU_H, progressHorde);
+    SetWorldState(NA_MAP_HALAA_NEU_A, progressAlliance);
+    SetWorldState(NA_MAP_HALAA_HORDE, capturedHorde);
+    SetWorldState(NA_MAP_HALAA_ALLIANCE, captureAlliance);
+}
+
 uint32 OPvPCapturePointNA::GetAliveGuardsCount() const
 {
     Position searchCenter = { -1572.57f, 7945.3f, -22.475f, 2.05949f };
@@ -89,7 +174,9 @@ void OPvPCapturePointNA::FactionTakeOver(uint32 team)
     m_ControllingFaction = team;
     m_GuardsAlive = NA_GUARDS_MAX;
     m_capturable = false;
-    UpdateHalaaWorldState();
+    if (GameObject* gameObject = m_PvP->GetMap()->GetGameObject(_controlZoneGUID))
+        gameObject->ActivateObject(GameObjectActions::MakeInert, 0);
+
     if (team == ALLIANCE)
     {
         m_WyvernStateSouth = WYVERN_NEU_HORDE;
@@ -121,9 +208,9 @@ void OPvPCapturePointNA::FactionTakeOver(uint32 team)
 }
 
 OPvPCapturePointNA::OPvPCapturePointNA(OutdoorPvP* pvp) : OPvPCapturePoint(pvp), m_capturable(true), m_GuardsAlive(0), m_ControllingFaction(0), m_WyvernStateNorth(0), m_WyvernStateSouth(0), m_WyvernStateEast(0),
-    m_WyvernStateWest(0), m_HalaaState(HALAA_N), m_RespawnTimer(NA_RESPAWN_TIME), m_GuardCheckTimer(NA_GUARD_CHECK_TIME)
+    m_WyvernStateWest(0), m_RespawnTimer(NA_RESPAWN_TIME), m_GuardCheckTimer(NA_GUARD_CHECK_TIME)
 {
-    SetCapturePointData(182210);
+
 }
 
 bool OutdoorPvPNA::SetupOutdoorPvP()
@@ -187,9 +274,9 @@ void OutdoorPvPNA::SendRemoveWorldStates(Player* player)
     player->SendDirectMessage(initWorldStates.Write());
 }
 
-bool OutdoorPvPNA::Update(uint32 diff)
+void OutdoorPvPNA::Update(uint32 diff)
 {
-    return m_obj->Update(diff);
+    m_obj->Update(diff);
 }
 
 bool OPvPCapturePointNA::HandleCustomSpell(Player* player, uint32 spellId, GameObject* /*go*/)
@@ -342,15 +429,8 @@ int32 OPvPCapturePointNA::HandleOpenGo(Player* player, GameObject* go)
     return 0;
 }
 
-bool OPvPCapturePointNA::Update(uint32 diff)
+void OPvPCapturePointNA::Update(uint32 diff)
 {
-    // let the controlling faction advance in phase
-    bool capturable = false;
-    if (m_ControllingFaction == ALLIANCE && m_activePlayers[0].size() > m_activePlayers[1].size())
-        capturable = true;
-    else if (m_ControllingFaction == HORDE && m_activePlayers[0].size() < m_activePlayers[1].size())
-        capturable = true;
-
     if (m_GuardCheckTimer < diff)
     {
         m_GuardCheckTimer = NA_GUARD_CHECK_TIME;
@@ -359,7 +439,11 @@ bool OPvPCapturePointNA::Update(uint32 diff)
         {
             m_capturable = true;
             m_RespawnTimer = NA_RESPAWN_TIME;
+            if (GameObject* gameObject = m_PvP->GetMap()->GetGameObject(_controlZoneGUID))
+                gameObject->ActivateObject(GameObjectActions::MakeActive, 0);
         }
+        else if (GameObject* gameObject = m_PvP->GetMap()->GetGameObject(_controlZoneGUID))
+            gameObject->ActivateObject(GameObjectActions::MakeInert, 0);
         // update the guard count for the players in zone
         m_PvP->SetWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive);
     }
@@ -382,60 +466,8 @@ bool OPvPCapturePointNA::Update(uint32 diff)
             m_RespawnTimer -= diff;
     }
 
-    if (m_capturable || capturable)
-        return OPvPCapturePoint::Update(diff);
-
-    return false;
-}
-
-void OPvPCapturePointNA::ChangeState()
-{
-    uint32 artkit = 21;
-    switch (m_State)
-    {
-        case OBJECTIVESTATE_NEUTRAL:
-            m_HalaaState = HALAA_N;
-            break;
-        case OBJECTIVESTATE_ALLIANCE:
-            m_HalaaState = HALAA_A;
-            FactionTakeOver(ALLIANCE);
-            artkit = 2;
-            break;
-        case OBJECTIVESTATE_HORDE:
-            m_HalaaState = HALAA_H;
-            FactionTakeOver(HORDE);
-            artkit = 1;
-            break;
-        case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-            m_HalaaState = HALAA_N_A;
-            break;
-        case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-            m_HalaaState = HALAA_N_H;
-            break;
-        case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-            m_HalaaState = HALAA_N_A;
-            artkit = 2;
-            break;
-        case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-            m_HalaaState = HALAA_N_H;
-            artkit = 1;
-        break;
-    }
-
-    auto bounds = m_PvP->GetMap()->GetGameObjectBySpawnIdStore().equal_range(m_capturePointSpawnId);
-    for (auto itr = bounds.first; itr != bounds.second; ++itr)
-        itr->second->SetGoArtKit(artkit);
-
-    UpdateHalaaWorldState();
-}
-
-void OPvPCapturePointNA::UpdateHalaaWorldState()
-{
-    m_PvP->SetWorldState(NA_MAP_HALAA_NEUTRAL, uint32((m_HalaaState & HALAA_N) != 0));
-    m_PvP->SetWorldState(NA_MAP_HALAA_NEU_A, uint32((m_HalaaState & HALAA_N_A) != 0));
-    m_PvP->SetWorldState(NA_MAP_HALAA_NEU_H, uint32((m_HalaaState & HALAA_N_H) != 0));
-    m_PvP->SetWorldState(NA_MAP_HALAA_HORDE, uint32((m_HalaaState & HALAA_H) != 0));
-    m_PvP->SetWorldState(NA_MAP_HALAA_ALLIANCE, uint32((m_HalaaState & HALAA_A) != 0));
+    if (m_capturable)
+        OPvPCapturePoint::Update(diff);
 }
 
 void OPvPCapturePointNA::UpdateWyvernRoostWorldState(uint32 roost)
diff --git a/src/server/scripts/OutdoorPvP/OutdoorPvPNA.h b/src/server/scripts/OutdoorPvP/OutdoorPvPNA.h
index aff8e4c88fa..60c3e1f1c16 100644
--- a/src/server/scripts/OutdoorPvP/OutdoorPvPNA.h
+++ b/src/server/scripts/OutdoorPvP/OutdoorPvPNA.h
@@ -113,16 +113,47 @@ enum HalaaStates
     HALAA_H = 16
 };
 
+enum HalaaEvents
+{
+    HALAA_EVENT_CAPTURE_HORDE       = 11504,
+    HALAA_EVENT_CAPTURE_ALLIANCE    = 11503,
+    HALAA_EVENT_CONTESTED_HORDE     = 11559,
+    HALAA_EVENT_CONTESTED_ALLIANCE  = 11558,
+    HALAA_EVENT_PROGRESS_HORDE      = 11821,
+    HALAA_EVENT_PROGRESS_ALLIANCE   = 11822
+};
+
 class Unit;
 class Creature;
+class WorldObject;
+
+class OutdoorPvPNA;
+
+class NAControlZoneHandler : public OutdoorPvPControlZoneHandler
+{
+public:
+    explicit NAControlZoneHandler(OutdoorPvPNA* pvp);
+
+    void HandleCaptureEventHorde([[maybe_unused]] GameObject* controlZone) override;
+    void HandleCaptureEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+    void HandleContestedEventHorde([[maybe_unused]] GameObject* controlZone) override;
+    void HandleContestedEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+    void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
+    void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEventHorde([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEvent([[maybe_unused]] GameObject* controlZone) override;
+
+    OutdoorPvPNA* GetOutdoorPvPNA() const;
+};
 
 class OPvPCapturePointNA : public OPvPCapturePoint
 {
     public:
         OPvPCapturePointNA(OutdoorPvP* pvp);
 
-        bool Update(uint32 diff) override;
-        void ChangeState() override;
+        void Update(uint32 diff) override;
+        void ChangeState() override { } // todo remove?
         bool HandleCustomSpell(Player* player, uint32 spellId, GameObject* go) override;
         int32 HandleOpenGo(Player* player, GameObject* go) override;
 
@@ -130,8 +161,8 @@ class OPvPCapturePointNA : public OPvPCapturePoint
         uint32 GetControllingFaction() const;
         void FactionTakeOver(uint32 team); // called when a faction takes control
         void UpdateWyvernRoostWorldState(uint32 roost);
-        void UpdateHalaaWorldState();
 
+        void SetControlZoneGUID(ObjectGuid guid) { _controlZoneGUID = guid; }
     private:
         bool m_capturable;
         uint32 m_GuardsAlive;
@@ -140,9 +171,9 @@ class OPvPCapturePointNA : public OPvPCapturePoint
         uint32 m_WyvernStateSouth;
         uint32 m_WyvernStateEast;
         uint32 m_WyvernStateWest;
-        uint32 m_HalaaState;
         uint32 m_RespawnTimer;
         uint32 m_GuardCheckTimer;
+        ObjectGuid _controlZoneGUID;
 };
 
 class OutdoorPvPNA : public OutdoorPvP
@@ -155,10 +186,11 @@ class OutdoorPvPNA : public OutdoorPvP
         bool SetupOutdoorPvP() override;
         void HandlePlayerEnterZone(Player* player, uint32 zone) override;
         void HandlePlayerLeaveZone(Player* player, uint32 zone) override;
-        bool Update(uint32 diff) override;
+        void Update(uint32 diff) override;
         void SendRemoveWorldStates(Player* player) override;
         void HandleKillImpl(Player* player, Unit* killed) override;
-
+        void SendMapWorldStates(int32 neutral, int32 progressHorde, int32 progressAlliance, int32 capturedHorde, int32 captureAlliance);
+        OPvPCapturePointNA* GetCapturePoint() const { return m_obj; }
     private:
         OPvPCapturePointNA* m_obj;
 };
diff --git a/src/server/scripts/OutdoorPvP/OutdoorPvPSI.cpp b/src/server/scripts/OutdoorPvP/OutdoorPvPSI.cpp
index f625cc8dd88..d652f9f8689 100644
--- a/src/server/scripts/OutdoorPvP/OutdoorPvPSI.cpp
+++ b/src/server/scripts/OutdoorPvP/OutdoorPvPSI.cpp
@@ -66,9 +66,8 @@ bool OutdoorPvPSI::SetupOutdoorPvP()
     return true;
 }
 
-bool OutdoorPvPSI::Update(uint32 /*diff*/)
+void OutdoorPvPSI::Update(uint32 /*diff*/)
 {
-    return false;
 }
 
 void OutdoorPvPSI::HandlePlayerEnterZone(Player* player, uint32 zone)
diff --git a/src/server/scripts/OutdoorPvP/OutdoorPvPSI.h b/src/server/scripts/OutdoorPvP/OutdoorPvPSI.h
index 71debd9012b..1c3630e42f5 100644
--- a/src/server/scripts/OutdoorPvP/OutdoorPvPSI.h
+++ b/src/server/scripts/OutdoorPvP/OutdoorPvPSI.h
@@ -43,7 +43,7 @@ class OutdoorPvPSI : public OutdoorPvP
         bool SetupOutdoorPvP() override;
         void HandlePlayerEnterZone(Player* player, uint32 zone) override;
         void HandlePlayerLeaveZone(Player* player, uint32 zone) override;
-        bool Update(uint32 diff) override;
+        void Update(uint32 diff) override;
         void SendRemoveWorldStates(Player* player) override;
         bool HandleAreaTrigger(Player* player, uint32 trigger, bool entered) override;
         bool HandleDropFlag(Player* player, uint32 spellId) override;
diff --git a/src/server/scripts/OutdoorPvP/OutdoorPvPTF.cpp b/src/server/scripts/OutdoorPvP/OutdoorPvPTF.cpp
index 9ef73f70db8..dcc918ebc31 100644
--- a/src/server/scripts/OutdoorPvP/OutdoorPvPTF.cpp
+++ b/src/server/scripts/OutdoorPvP/OutdoorPvPTF.cpp
@@ -45,42 +45,6 @@ int32 const TF_CAPTURE_BUFF = 33377;
 uint32 const TF_ALLY_QUEST = 11505;
 uint32 const TF_HORDE_QUEST = 11506;
 
-struct tf_tower_world_state
-{
-    int32 n;
-    int32 h;
-    int32 a;
-};
-
-tf_tower_world_state const TFTowerWorldStates[TF_TOWER_NUM] =
-{
-    { 2681, 2682, 2683 },
-    { 2686, 2685, 2684 },
-    { 2690, 2689, 2688 },
-    { 2696, 2695, 2694 },
-    { 2693, 2692, 2691 }
-};
-
-/*
-uint32 const TFTowerPlayerEnterEvents[TF_TOWER_NUM] =
-{
-    12226,
-    12497,
-    12486,
-    12499,
-    12501
-};
-
-uint32 const TFTowerPlayerLeaveEvents[TF_TOWER_NUM] =
-{
-    12225,
-    12496,
-    12487,
-    12498,
-    12500
-};
-*/
-
 OutdoorPvPTF::OutdoorPvPTF(Map* map) : OutdoorPvP(map)
 {
     m_TypeId = OUTDOOR_PVP_TF;
@@ -92,13 +56,12 @@ OutdoorPvPTF::OutdoorPvPTF(Map* map) : OutdoorPvP(map)
     hours_left = 6;
     second_digit = 0;
     first_digit = 0;
-}
 
-OPvPCapturePointTF::OPvPCapturePointTF(OutdoorPvP* pvp, OutdoorPvPTF_TowerType type, GameObject* go) : OPvPCapturePoint(pvp), m_TowerType(type), m_TowerState(TF_TOWERSTATE_N)
-{
-    m_capturePointSpawnId = go->GetSpawnId();
-    m_capturePoint = go;
-    SetCapturePointData(go->GetEntry());
+    ControlZoneHandlers[TF_ENTRY_TOWER_NW] = std::make_unique<TFControlZoneHandler>(this, 2682, 2683, 2681);
+    ControlZoneHandlers[TF_ENTRY_TOWER_N] = std::make_unique<TFControlZoneHandler>(this, 2685, 2684, 2686);
+    ControlZoneHandlers[TF_ENTRY_TOWER_NE] = std::make_unique<TFControlZoneHandler>(this, 2689, 2688, 2690);
+    ControlZoneHandlers[TF_ENTRY_TOWER_SE] = std::make_unique<TFControlZoneHandler>(this, 2695, 2694, 2696);
+    ControlZoneHandlers[TF_ENTRY_TOWER_S] = std::make_unique<TFControlZoneHandler>(this, 2692, 2691, 2693);
 }
 
 void OutdoorPvPTF::SendRemoveWorldStates(Player* player)
@@ -119,55 +82,21 @@ void OutdoorPvPTF::SendRemoveWorldStates(Player* player)
     initWorldStates.Worldstates.emplace_back(TF_UI_LOCKED_DISPLAY_HORDE, 0);
     initWorldStates.Worldstates.emplace_back(TF_UI_LOCKED_DISPLAY_ALLIANCE, 0);
 
-    for (tf_tower_world_state const& towerWorldStates : TFTowerWorldStates)
+    for (auto& itr : ControlZoneHandlers)
     {
-        initWorldStates.Worldstates.emplace_back(towerWorldStates.n, 0);
-        initWorldStates.Worldstates.emplace_back(towerWorldStates.h, 0);
-        initWorldStates.Worldstates.emplace_back(towerWorldStates.a, 0);
+        TFControlZoneHandler* handler = static_cast<TFControlZoneHandler*>(itr.second.get());
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateNeutral(), 0);
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateHorde(), 0);
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateAlliance(), 0);
     }
 
     player->SendDirectMessage(initWorldStates.Write());
 }
 
-void OPvPCapturePointTF::UpdateTowerState()
+void OutdoorPvPTF::Update(uint32 diff)
 {
-    m_PvP->SetWorldState(TFTowerWorldStates[m_TowerType].n, int32((m_TowerState & TF_TOWERSTATE_N) != 0));
-    m_PvP->SetWorldState(TFTowerWorldStates[m_TowerType].h, int32((m_TowerState & TF_TOWERSTATE_H) != 0));
-    m_PvP->SetWorldState(TFTowerWorldStates[m_TowerType].a, int32((m_TowerState & TF_TOWERSTATE_A) != 0));
-}
-
-bool OutdoorPvPTF::Update(uint32 diff)
-{
-    bool changed = OutdoorPvP::Update(diff);
+    OutdoorPvP::Update(diff);
 
-    if (changed)
-    {
-        if (m_AllianceTowersControlled == TF_TOWER_NUM)
-        {
-            TeamApplyBuff(TEAM_ALLIANCE, TF_CAPTURE_BUFF);
-            m_IsLocked = true;
-            SetWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, 0);
-            SetWorldState(TF_UI_LOCKED_DISPLAY_HORDE, 0);
-            SetWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, 1);
-            SetWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, 0);
-        }
-        else if (m_HordeTowersControlled == TF_TOWER_NUM)
-        {
-            TeamApplyBuff(TEAM_HORDE, TF_CAPTURE_BUFF);
-            m_IsLocked = true;
-            SetWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, 0);
-            SetWorldState(TF_UI_LOCKED_DISPLAY_HORDE, 1);
-            SetWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, 0);
-            SetWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, 0);
-        }
-        else
-        {
-            TeamCastSpell(TEAM_ALLIANCE, -TF_CAPTURE_BUFF);
-            TeamCastSpell(TEAM_HORDE, -TF_CAPTURE_BUFF);
-        }
-        SetWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
-        SetWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
-    }
     if (m_IsLocked)
     {
         // lock timer is down, release lock
@@ -176,6 +105,16 @@ bool OutdoorPvPTF::Update(uint32 diff)
             m_LockTimer = TF_LOCK_TIME;
             m_LockTimerUpdate = 0;
             m_IsLocked = false;
+
+            for (ObjectGuid const& controlZoneGUID : _controlZoneGUIDs)
+            {
+                if (GameObject* gameObject = GetMap()->GetGameObject(controlZoneGUID))
+                {
+                    gameObject->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue());
+                    gameObject->ActivateObject(GameObjectActions::MakeActive, 0);
+                }
+            }
+
             SetWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, 1);
             SetWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, 0);
             SetWorldState(TF_UI_LOCKED_DISPLAY_HORDE, 0);
@@ -200,7 +139,6 @@ bool OutdoorPvPTF::Update(uint32 diff)
             m_LockTimer -= diff;
         }
     }
-    return changed;
 }
 
 void OutdoorPvPTF::HandlePlayerEnterZone(Player* player, uint32 zone)
@@ -250,6 +188,40 @@ bool OutdoorPvPTF::IsLocked() const
     return m_IsLocked;
 }
 
+void OutdoorPvPTF::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* invoker)
+{
+    OutdoorPvP::ProcessEvent(obj, eventId, invoker);
+
+    SetWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
+    SetWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
+
+    // now check if everything is capped
+    if (m_HordeTowersControlled == TF_TOWER_NUM)
+        HandleCapture(TEAM_HORDE);
+    else if (m_AllianceTowersControlled == TF_TOWER_NUM)
+        HandleCapture(TEAM_ALLIANCE);
+    else
+    {
+        TeamCastSpell(TEAM_ALLIANCE, -TF_CAPTURE_BUFF);
+        TeamCastSpell(TEAM_HORDE, -TF_CAPTURE_BUFF);
+    }
+}
+
+void OutdoorPvPTF::HandleCapture(TeamId team)
+{
+    m_IsLocked = true;
+
+    for (ObjectGuid const& controlZoneGUID : _controlZoneGUIDs)
+        if (GameObject* gameObject = GetMap()->GetGameObject(controlZoneGUID))
+            gameObject->ActivateObject(GameObjectActions::MakeInert, 0);
+
+    TeamApplyBuff(team, TF_CAPTURE_BUFF);
+    SetWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, 0);
+    SetWorldState(TF_UI_LOCKED_DISPLAY_HORDE, team == TEAM_HORDE ? 1 : 0);
+    SetWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, team == TEAM_ALLIANCE ? 1 : 0);
+    SetWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, 0);
+}
+
 bool OutdoorPvPTF::SetupOutdoorPvP()
 {
     m_AllianceTowersControlled = 0;
@@ -273,20 +245,12 @@ void OutdoorPvPTF::OnGameObjectCreate(GameObject* go)
 {
     switch (go->GetEntry())
     {
-        case 183104:
-            AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_NW, go));
-            break;
-        case 183411:
-            AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_N, go));
-            break;
-        case 183412:
-            AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_NE, go));
-            break;
-        case 183413:
-            AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_SE, go));
-            break;
-        case 183414:
-            AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_S, go));
+        case TF_ENTRY_TOWER_NW:
+        case TF_ENTRY_TOWER_N:
+        case TF_ENTRY_TOWER_NE:
+        case TF_ENTRY_TOWER_SE:
+        case TF_ENTRY_TOWER_S:
+            _controlZoneGUIDs.insert(go->GetGUID());
             break;
         default:
             break;
@@ -295,81 +259,73 @@ void OutdoorPvPTF::OnGameObjectCreate(GameObject* go)
     OutdoorPvP::OnGameObjectCreate(go);
 }
 
-bool OPvPCapturePointTF::Update(uint32 diff)
+TFControlZoneHandler::TFControlZoneHandler(OutdoorPvPTF* pvp, uint32 worldstateHorde, uint32 worldstateAlliance, uint32 worldstateNeutral) : OutdoorPvPControlZoneHandler(pvp),
+_worldstateHorde(worldstateHorde), _worldstateAlliance(worldstateAlliance), _worldstateNeutral(worldstateNeutral)
 {
-    // can update even in locked state if gathers the controlling faction
-    bool canupdate = ((((OutdoorPvPTF*)m_PvP)->GetAllianceTowersControlled() > 0) && m_activePlayers[0].size() > m_activePlayers[1].size()) ||
-            ((((OutdoorPvPTF*)m_PvP)->GetHordeTowersControlled() > 0) && m_activePlayers[0].size() < m_activePlayers[1].size());
-    // if gathers the other faction, then only update if the pvp is unlocked
-    canupdate = canupdate || !((OutdoorPvPTF*)m_PvP)->IsLocked();
-    return canupdate && OPvPCapturePoint::Update(diff);
 }
 
-void OPvPCapturePointTF::ChangeState()
+void TFControlZoneHandler::HandleProgressEventHorde(GameObject* controlZone)
 {
-    // if changing from controlling alliance to horde
-    if (m_OldState == OBJECTIVESTATE_ALLIANCE)
-    {
-        if (uint32 alliance_towers = ((OutdoorPvPTF*)m_PvP)->GetAllianceTowersControlled())
-            ((OutdoorPvPTF*)m_PvP)->SetAllianceTowersControlled(--alliance_towers);
-        m_PvP->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_LOSE_ALLIANCE);
-    }
-    // if changing from controlling horde to alliance
-    else if (m_OldState == OBJECTIVESTATE_HORDE)
-    {
-        if (uint32 horde_towers = ((OutdoorPvPTF*)m_PvP)->GetHordeTowersControlled())
-            ((OutdoorPvPTF*)m_PvP)->SetHordeTowersControlled(--horde_towers);
-        m_PvP->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_LOSE_HORDE);
-    }
-
-    uint32 artkit = 21;
-
-    switch (m_State)
-    {
-        case OBJECTIVESTATE_ALLIANCE:
-        {
-            m_TowerState = TF_TOWERSTATE_A;
-            artkit = 2;
-            uint32 alliance_towers = ((OutdoorPvPTF*)m_PvP)->GetAllianceTowersControlled();
-            if (alliance_towers < TF_TOWER_NUM)
-                ((OutdoorPvPTF*)m_PvP)->SetAllianceTowersControlled(++alliance_towers);
+    controlZone->SetGoArtKit(1);
+    GetOutdoorPvPTF()->SetHordeTowersControlled(GetOutdoorPvPTF()->GetHordeTowersControlled() + 1);
+    GetOutdoorPvP()->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_TAKEN_HORDE);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 1, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 0, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 0, false);
+
+    if (GuidUnorderedSet const* guidSet = controlZone->GetInsidePlayers())
+        for (ObjectGuid const& guid : *guidSet)
+            if (Player* player = ObjectAccessor::GetPlayer(*controlZone, guid))
+                if (player->GetTeam() == TEAM_HORDE)
+                    player->AreaExploredOrEventHappens(TF_HORDE_QUEST);
 
-            m_PvP->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_TAKEN_ALLIANCE);
+    OutdoorPvPControlZoneHandler::HandleProgressEventHorde(controlZone);
+}
 
-            for (GuidSet::iterator itr = m_activePlayers[0].begin(); itr != m_activePlayers[0].end(); ++itr)
-                if (Player* player = ObjectAccessor::FindPlayer(*itr))
+void TFControlZoneHandler::HandleProgressEventAlliance(GameObject* controlZone)
+{
+    controlZone->SetGoArtKit(2);
+    GetOutdoorPvPTF()->SetAllianceTowersControlled(GetOutdoorPvPTF()->GetAllianceTowersControlled() + 1);
+    GetOutdoorPvP()->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_TAKEN_ALLIANCE);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 0, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 1, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 0, false);
+
+    if (GuidUnorderedSet const* guidSet = controlZone->GetInsidePlayers())
+        for (ObjectGuid const& guid : *guidSet)
+            if (Player* player = ObjectAccessor::GetPlayer(*controlZone, guid))
+                if (player->GetTeam() == TEAM_ALLIANCE)
                     player->AreaExploredOrEventHappens(TF_ALLY_QUEST);
-            break;
-        }
-        case OBJECTIVESTATE_HORDE:
-        {
-            m_TowerState = TF_TOWERSTATE_H;
-            artkit = 1;
-            uint32 horde_towers = ((OutdoorPvPTF*)m_PvP)->GetHordeTowersControlled();
-            if (horde_towers < TF_TOWER_NUM)
-                ((OutdoorPvPTF*)m_PvP)->SetHordeTowersControlled(++horde_towers);
 
-            m_PvP->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_TAKEN_HORDE);
+    OutdoorPvPControlZoneHandler::HandleProgressEventAlliance(controlZone);
+}
 
-            for (GuidSet::iterator itr = m_activePlayers[1].begin(); itr != m_activePlayers[1].end(); ++itr)
-                if (Player* player = ObjectAccessor::FindPlayer(*itr))
-                    player->AreaExploredOrEventHappens(TF_HORDE_QUEST);
-            break;
-        }
-        case OBJECTIVESTATE_NEUTRAL:
-        case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-        case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-        case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-        case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-            m_TowerState = TF_TOWERSTATE_N;
-            break;
-    }
+void TFControlZoneHandler::HandleNeutralEventHorde(GameObject* controlZone)
+{
+    GetOutdoorPvPTF()->SetHordeTowersControlled(GetOutdoorPvPTF()->GetHordeTowersControlled() - 1);
+    GetOutdoorPvP()->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_LOSE_HORDE);
+    OutdoorPvPControlZoneHandler::HandleNeutralEventHorde(controlZone);
+}
 
-    auto bounds = m_PvP->GetMap()->GetGameObjectBySpawnIdStore().equal_range(m_capturePointSpawnId);
-    for (auto itr = bounds.first; itr != bounds.second; ++itr)
-        itr->second->SetGoArtKit(artkit);
+void TFControlZoneHandler::HandleNeutralEventAlliance(GameObject* controlZone)
+{
+    GetOutdoorPvPTF()->SetAllianceTowersControlled(GetOutdoorPvPTF()->GetAllianceTowersControlled() - 1);
+    GetOutdoorPvP()->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_LOSE_ALLIANCE);
+    OutdoorPvPControlZoneHandler::HandleNeutralEventAlliance(controlZone);
+}
 
-    UpdateTowerState();
+void TFControlZoneHandler::HandleNeutralEvent(GameObject* controlZone)
+{
+    controlZone->SetGoArtKit(21);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 0, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 0, false);
+    controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 1, false);
+    OutdoorPvPControlZoneHandler::HandleNeutralEvent(controlZone);
+}
+
+OutdoorPvPTF* TFControlZoneHandler::GetOutdoorPvPTF() const
+{
+    return static_cast<OutdoorPvPTF*>(OutdoorPvPControlZoneHandler::GetOutdoorPvP());
 }
 
 class OutdoorPvP_terokkar_forest : public OutdoorPvPScript
diff --git a/src/server/scripts/OutdoorPvP/OutdoorPvPTF.h b/src/server/scripts/OutdoorPvP/OutdoorPvPTF.h
index e938877dc16..3dff1df2508 100644
--- a/src/server/scripts/OutdoorPvP/OutdoorPvPTF.h
+++ b/src/server/scripts/OutdoorPvP/OutdoorPvPTF.h
@@ -54,26 +54,66 @@ enum TFWorldStates
     TF_UI_LOCKED_DISPLAY_ALLIANCE = 2767
 };
 
-enum TFTowerStates
+enum TFGameEvents
 {
-    TF_TOWERSTATE_N = 1,
-    TF_TOWERSTATE_H = 2,
-    TF_TOWERSTATE_A = 4
+    TF_EVENT_TOWER_NW_ALLIANCE_PROGRESS  = 12225,
+    TF_EVENT_TOWER_NW_HORDE_PROGRESS     = 12226,
+    TF_EVENT_TOWER_NW_NEUTRAL_ALLIANCE   = 12227,
+    TF_EVENT_TOWER_NW_NEUTRAL_HORDE      = 12228,
+
+    TF_EVENT_TOWER_NE_HORDE_PROGRESS     = 12486,
+    TF_EVENT_TOWER_NE_ALLIANCE_PROGRESS  = 12487,
+    TF_EVENT_TOWER_NE_NEUTRAL_HORDE      = 12488,
+    TF_EVENT_TOWER_NE_NEUTRAL_ALLIANCE   = 12489,
+
+    TF_EVENT_TOWER_N_NEUTRAL_HORDE       = 12490,
+    TF_EVENT_TOWER_N_NEUTRAL_ALLIANCE    = 12491,
+    TF_EVENT_TOWER_N_ALLIANCE_PROGRESS   = 12496,
+    TF_EVENT_TOWER_N_HORDE_PROGRESS      = 12497,
+
+    TF_EVENT_TOWER_SE_NEUTRAL_HORDE      = 12492,
+    TF_EVENT_TOWER_SE_NEUTRAL_ALLIANCE   = 12493,
+    TF_EVENT_TOWER_SE_ALLIANCE_PROGRESS  = 12498,
+    TF_EVENT_TOWER_SE_HORDE_PROGRESS     = 12499,
+
+    TF_EVENT_TOWER_S_NEUTRAL_HORDE       = 12494,
+    TF_EVENT_TOWER_S_NEUTRAL_ALLIANCE    = 12495,
+    TF_EVENT_TOWER_S_ALLIANCE_PROGRESS   = 12500,
+    TF_EVENT_TOWER_S_HORDE_PROGRESS      = 12501
 };
 
-class OPvPCapturePointTF : public OPvPCapturePoint
+enum TFGameObjects
 {
-    public:
-        OPvPCapturePointTF(OutdoorPvP* pvp, OutdoorPvPTF_TowerType type, GameObject* go);
+    TF_ENTRY_TOWER_NW   = 183104,
+    TF_ENTRY_TOWER_N    = 183411,
+    TF_ENTRY_TOWER_NE   = 183412,
+    TF_ENTRY_TOWER_SE   = 183413,
+    TF_ENTRY_TOWER_S    = 183414
+};
+
+class OutdoorPvPTF;
+
+class TFControlZoneHandler : public OutdoorPvPControlZoneHandler
+{
+public:
+    explicit TFControlZoneHandler(OutdoorPvPTF* pvp, uint32 worldstateHorde, uint32 worldstateAlliance, uint32 worldstateNeutral);
+
+    void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
+    void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEventHorde([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEvent([[maybe_unused]] GameObject* controlZone) override;
 
-        bool Update(uint32 diff) override;
-        void ChangeState() override;
+    uint32 GetWorldStateHorde() { return _worldstateHorde; }
+    uint32 GetWorldStateAlliance() { return _worldstateAlliance; }
+    uint32 GetWorldStateNeutral() { return _worldstateNeutral; }
 
-        void UpdateTowerState();
+    OutdoorPvPTF* GetOutdoorPvPTF() const;
 
-    protected:
-        OutdoorPvPTF_TowerType m_TowerType;
-        uint32 m_TowerState;
+private:
+    uint32 _worldstateHorde;
+    uint32 _worldstateAlliance;
+    uint32 _worldstateNeutral;
 };
 
 class OutdoorPvPTF : public OutdoorPvP
@@ -85,7 +125,7 @@ class OutdoorPvPTF : public OutdoorPvP
         void OnGameObjectCreate(GameObject* go) override;
         void HandlePlayerEnterZone(Player* player, uint32 zone) override;
         void HandlePlayerLeaveZone(Player* player, uint32 zone) override;
-        bool Update(uint32 diff) override;
+        void Update(uint32 diff) override;
         void SendRemoveWorldStates(Player* player) override;
 
         uint32 GetAllianceTowersControlled() const;
@@ -94,6 +134,8 @@ class OutdoorPvPTF : public OutdoorPvP
         void SetHordeTowersControlled(uint32 count);
         bool IsLocked() const;
 
+        void ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* invoker) override;
+        void HandleCapture(TeamId team);
     private:
         bool m_IsLocked;
         uint32 m_LockTimer;
@@ -101,6 +143,8 @@ class OutdoorPvPTF : public OutdoorPvP
         uint32 m_AllianceTowersControlled;
         uint32 m_HordeTowersControlled;
         uint32 hours_left, second_digit, first_digit;
+        GuidUnorderedSet _controlZoneGUIDs;
+        std::unordered_map<uint32 /*control zone entry*/, std::unique_ptr<TFControlZoneHandler>> _controlZoneHandlers;
 };
 
 #endif
diff --git a/src/server/scripts/OutdoorPvP/OutdoorPvPZM.cpp b/src/server/scripts/OutdoorPvP/OutdoorPvPZM.cpp
index 1c8c7c1ae87..8937cddddbd 100644
--- a/src/server/scripts/OutdoorPvP/OutdoorPvPZM.cpp
+++ b/src/server/scripts/OutdoorPvP/OutdoorPvPZM.cpp
@@ -36,113 +36,80 @@ uint32 const OutdoorPvPZMBuffZones[OutdoorPvPZMBuffZonesNum] = { 3521, 3607, 371
 // linked when the central tower is controlled
 uint32 const ZM_GRAVEYARD_ZONE = 3521;
 
-struct zm_beacon
+ZMControlZoneHandler::ZMControlZoneHandler(OutdoorPvPZM* pvp, uint32 textBeaconTakenHorde, uint32 textBeaconTakenAlliance, uint32 worldstateNeutralUi, uint32 worldstateNeutralMap, uint32 worldstateHordeUi, uint32 worldstateHordeMap, uint32 worldstateAllianceUi, uint32 worldstateAllianceMap)
+    : OutdoorPvPControlZoneHandler(pvp), _textBeaconTakenHorde(textBeaconTakenHorde), _textBeaconTakenAlliance(textBeaconTakenAlliance), _worldstateNeutralUi(worldstateNeutralUi), _worldstateNeutralMap(worldstateNeutralMap),
+    _worldstateHordeUi(worldstateHordeUi), _worldstateHordeMap(worldstateHordeMap), _worldstateAllianceUi(worldstateAllianceUi), _worldstateAllianceMap(worldstateAllianceMap)
 {
-    int32 ui_tower_n;
-    int32 ui_tower_h;
-    int32 ui_tower_a;
-    int32 map_tower_n;
-    int32 map_tower_h;
-    int32 map_tower_a;
-    uint32 event_enter;
-    uint32 event_leave;
-};
+}
 
-zm_beacon const ZMBeaconInfo[ZM_NUM_BEACONS] =
+void ZMControlZoneHandler::HandleProgressEventHorde(GameObject* controlZone)
 {
-    { ZM_UI_TOWER_EAST_N, ZM_UI_TOWER_EAST_H, ZM_UI_TOWER_EAST_A, ZM_MAP_TOWER_EAST_N, ZM_MAP_TOWER_EAST_H, ZM_MAP_TOWER_EAST_A, 11807, 11806 },
-    { ZM_UI_TOWER_WEST_N, ZM_UI_TOWER_WEST_H, ZM_UI_TOWER_WEST_A, ZM_MAP_TOWER_WEST_N, ZM_MAP_TOWER_WEST_H, ZM_MAP_TOWER_WEST_A, 11805, 11804 }
-};
+    OutdoorPvPControlZoneHandler::HandleProgressEventHorde(controlZone);
+    GetOutdoorPvpZM()->SetHordeTowersControlled(GetOutdoorPvpZM()->GetHordeTowersControlled() + 1);
+    GetOutdoorPvpZM()->SendDefenseMessage(ZM_GRAVEYARD_ZONE, _textBeaconTakenHorde);
+
+    GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceMap, 0);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceUi, 0);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralMap, 0);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralUi, 0);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateHordeMap, 1);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateHordeUi, 1);
+}
 
-uint32 const ZMBeaconCaptureA[ZM_NUM_BEACONS] =
+void ZMControlZoneHandler::HandleProgressEventAlliance(GameObject* controlZone)
 {
-    TEXT_EAST_BEACON_TAKEN_ALLIANCE,
-    TEXT_WEST_BEACON_TAKEN_ALLIANCE
-};
+    OutdoorPvPControlZoneHandler::HandleProgressEventAlliance(controlZone);
+    GetOutdoorPvpZM()->SetAllianceTowersControlled(GetOutdoorPvpZM()->GetAllianceTowersControlled() + 1);
+    GetOutdoorPvpZM()->SendDefenseMessage(ZM_GRAVEYARD_ZONE, _textBeaconTakenAlliance);
+
+    GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceMap, 1);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceUi, 1);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralMap, 0);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralUi, 0);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateHordeMap, 0);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateHordeUi, 0);
+}
 
-uint32 const ZMBeaconCaptureH[ZM_NUM_BEACONS] =
+void ZMControlZoneHandler::HandleNeutralEventHorde(GameObject* controlZone)
 {
-    TEXT_EAST_BEACON_TAKEN_HORDE,
-    TEXT_WEST_BEACON_TAKEN_HORDE
-};
+    GetOutdoorPvpZM()->SetHordeTowersControlled(GetOutdoorPvpZM()->GetHordeTowersControlled() - 1);
 
-OPvPCapturePointZM_Beacon::OPvPCapturePointZM_Beacon(OutdoorPvP* pvp, ZM_BeaconType type, GameObject* go) : OPvPCapturePoint(pvp), m_TowerType(type), m_TowerState(ZM_TOWERSTATE_N)
-{
-    m_capturePointSpawnId = go->GetSpawnId();
-    m_capturePoint = go;
-    SetCapturePointData(go->GetEntry());
+    OutdoorPvPControlZoneHandler::HandleNeutralEventHorde(controlZone);
 }
 
-void OPvPCapturePointZM_Beacon::UpdateTowerState()
+void ZMControlZoneHandler::HandleNeutralEventAlliance(GameObject* controlZone)
 {
-    m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].ui_tower_n, int32((m_TowerState & ZM_TOWERSTATE_N) != 0));
-    m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].map_tower_n, int32((m_TowerState & ZM_TOWERSTATE_N) != 0));
-    m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].ui_tower_a, int32((m_TowerState & ZM_TOWERSTATE_A) != 0));
-    m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].map_tower_a, int32((m_TowerState & ZM_TOWERSTATE_A) != 0));
-    m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].ui_tower_h, int32((m_TowerState & ZM_TOWERSTATE_H) != 0));
-    m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].map_tower_h, int32((m_TowerState & ZM_TOWERSTATE_H) != 0));
+    GetOutdoorPvpZM()->SetAllianceTowersControlled(GetOutdoorPvpZM()->GetAllianceTowersControlled() - 1);
+
+    OutdoorPvPControlZoneHandler::HandleNeutralEventAlliance(controlZone);
 }
 
-void OPvPCapturePointZM_Beacon::ChangeState()
+void ZMControlZoneHandler::HandleNeutralEvent(GameObject* controlZone)
 {
-    // if changing from controlling alliance to horde
-    if (m_OldState == OBJECTIVESTATE_ALLIANCE)
-    {
-        if (uint32 alliance_towers = ((OutdoorPvPZM*)m_PvP)->GetAllianceTowersControlled())
-            ((OutdoorPvPZM*)m_PvP)->SetAllianceTowersControlled(--alliance_towers);
-    }
-    // if changing from controlling horde to alliance
-    else if (m_OldState == OBJECTIVESTATE_HORDE)
-    {
-        if (uint32 horde_towers = ((OutdoorPvPZM*)m_PvP)->GetHordeTowersControlled())
-            ((OutdoorPvPZM*)m_PvP)->SetHordeTowersControlled(--horde_towers);
-    }
-
-    switch (m_State)
-    {
-        case OBJECTIVESTATE_ALLIANCE:
-        {
-            m_TowerState = ZM_TOWERSTATE_A;
-            uint32 alliance_towers = ((OutdoorPvPZM*)m_PvP)->GetAllianceTowersControlled();
-            if (alliance_towers < ZM_NUM_BEACONS)
-                ((OutdoorPvPZM*)m_PvP)->SetAllianceTowersControlled(++alliance_towers);
-            m_PvP->SendDefenseMessage(ZM_GRAVEYARD_ZONE, ZMBeaconCaptureA[m_TowerType]);
-            break;
-        }
-        case OBJECTIVESTATE_HORDE:
-        {
-            m_TowerState = ZM_TOWERSTATE_H;
-            uint32 horde_towers = ((OutdoorPvPZM*)m_PvP)->GetHordeTowersControlled();
-            if (horde_towers < ZM_NUM_BEACONS)
-                ((OutdoorPvPZM*)m_PvP)->SetHordeTowersControlled(++horde_towers);
-            m_PvP->SendDefenseMessage(ZM_GRAVEYARD_ZONE, ZMBeaconCaptureH[m_TowerType]);
-            break;
-        }
-        case OBJECTIVESTATE_NEUTRAL:
-        case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-        case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-        case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-        case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-            m_TowerState = ZM_TOWERSTATE_N;
-            break;
-    }
+    OutdoorPvPControlZoneHandler::HandleNeutralEvent(controlZone);
+
+    GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceMap, 0);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceUi, 0);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralMap, 1);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralUi, 1);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateHordeMap, 0);
+    GetOutdoorPvpZM()->SetWorldState(_worldstateHordeUi, 0);
+}
 
-    UpdateTowerState();
+OutdoorPvPZM* ZMControlZoneHandler::GetOutdoorPvpZM()
+{
+    return static_cast<OutdoorPvPZM*>(OutdoorPvPControlZoneHandler::GetOutdoorPvP());
 }
 
-bool OutdoorPvPZM::Update(uint32 diff)
+void OutdoorPvPZM::Update(uint32 diff)
 {
-    bool changed = OutdoorPvP::Update(diff);
-    if (changed)
-    {
-        if (m_AllianceTowersControlled == ZM_NUM_BEACONS)
-            m_Graveyard->SetBeaconState(ALLIANCE);
-        else if (m_HordeTowersControlled == ZM_NUM_BEACONS)
-            m_Graveyard->SetBeaconState(HORDE);
-        else
-            m_Graveyard->SetBeaconState(0);
-    }
-    return changed;
+    OutdoorPvP::Update(diff);
+    if (m_AllianceTowersControlled == ZM_NUM_BEACONS)
+        m_Graveyard->SetBeaconState(ALLIANCE);
+    else if (m_HordeTowersControlled == ZM_NUM_BEACONS)
+        m_Graveyard->SetBeaconState(HORDE);
+    else
+        m_Graveyard->SetBeaconState(0);
 }
 
 void OutdoorPvPZM::HandlePlayerEnterZone(Player* player, uint32 zone)
@@ -176,6 +143,30 @@ OutdoorPvPZM::OutdoorPvPZM(Map* map) : OutdoorPvP(map)
     m_Graveyard = nullptr;
     m_AllianceTowersControlled = 0;
     m_HordeTowersControlled = 0;
+
+    ControlZoneHandlers[ZM_GO_ENTRY_BEACON_EAST] = std::make_unique<ZMControlZoneHandler>(
+        this,
+        TEXT_EAST_BEACON_TAKEN_HORDE,
+        TEXT_EAST_BEACON_TAKEN_ALLIANCE,
+        ZM_UI_TOWER_EAST_N,
+        ZM_MAP_TOWER_EAST_N,
+        ZM_UI_TOWER_EAST_H,
+        ZM_MAP_TOWER_EAST_H,
+        ZM_UI_TOWER_EAST_A,
+        ZM_MAP_TOWER_EAST_A
+    );
+
+    ControlZoneHandlers[ZM_GO_ENTRY_BEACON_WEST] = std::make_unique<ZMControlZoneHandler>(
+        this,
+        TEXT_WEST_BEACON_TAKEN_HORDE,
+        TEXT_WEST_BEACON_TAKEN_ALLIANCE,
+        ZM_UI_TOWER_WEST_N,
+        ZM_MAP_TOWER_WEST_N,
+        ZM_UI_TOWER_WEST_H,
+        ZM_MAP_TOWER_WEST_H,
+        ZM_UI_TOWER_WEST_A,
+        ZM_MAP_TOWER_WEST_A
+    );
 }
 
 bool OutdoorPvPZM::SetupOutdoorPvP()
@@ -188,28 +179,10 @@ bool OutdoorPvPZM::SetupOutdoorPvP()
         RegisterZone(OutdoorPvPZMBuffZones[i]);
 
     m_Graveyard = new OPvPCapturePointZM_Graveyard(this);
-    AddCapturePoint(m_Graveyard); // though the update function isn't used, the handleusego is!
 
     return true;
 }
 
-void OutdoorPvPZM::OnGameObjectCreate(GameObject* go)
-{
-    switch (go->GetEntry())
-    {
-        case 182523:
-            AddCapturePoint(new OPvPCapturePointZM_Beacon(this, ZM_BEACON_EAST, go));
-            break;
-        case 182522:
-            AddCapturePoint(new OPvPCapturePointZM_Beacon(this, ZM_BEACON_WEST, go));
-            break;
-        default:
-            break;
-    }
-
-    OutdoorPvP::OnGameObjectCreate(go);
-}
-
 void OutdoorPvPZM::HandleKillImpl(Player* player, Unit* killed)
 {
     if (killed->GetTypeId() != TYPEID_PLAYER)
@@ -221,11 +194,9 @@ void OutdoorPvPZM::HandleKillImpl(Player* player, Unit* killed)
         player->CastSpell(player, ZM_HordePlayerKillReward, true);
 }
 
-bool OPvPCapturePointZM_Graveyard::Update(uint32 /*diff*/)
+void OPvPCapturePointZM_Graveyard::Update(uint32 /*diff*/)
 {
-    bool retval = m_State != m_OldState;
     m_State = m_OldState;
-    return retval;
 }
 
 int32 OPvPCapturePointZM_Graveyard::HandleOpenGo(Player* player, GameObject* go)
@@ -368,21 +339,20 @@ void OutdoorPvPZM::SendRemoveWorldStates(Player* player)
     initWorldStates.MapID = player->GetMapId();
     initWorldStates.AreaID = player->GetZoneId();
     initWorldStates.SubareaID = player->GetAreaId();
-    initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_EAST_N, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_EAST_H, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_EAST_A, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_WEST_N, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_WEST_H, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_WEST_A, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_EAST_N, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_EAST_H, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_EAST_A, 0);
+
+    for (auto& itr : ControlZoneHandlers)
+    {
+        ZMControlZoneHandler* handler = static_cast<ZMControlZoneHandler*>(itr.second.get());
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateNeutralUI(), 0);
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateNeutralMap(), 0);
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateHordeUI(), 0);
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateHordeMap(), 0);
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateAllianceUI(), 0);
+        initWorldStates.Worldstates.emplace_back(handler->GetWorldStateAllianceMap(), 0);
+    }
     initWorldStates.Worldstates.emplace_back(ZM_MAP_GRAVEYARD_H, 0);
     initWorldStates.Worldstates.emplace_back(ZM_MAP_GRAVEYARD_A, 0);
     initWorldStates.Worldstates.emplace_back(ZM_MAP_GRAVEYARD_N, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_WEST_N, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_WEST_H, 0);
-    initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_WEST_A, 0);
     initWorldStates.Worldstates.emplace_back(ZM_MAP_HORDE_FLAG_READY, 0);
     initWorldStates.Worldstates.emplace_back(ZM_MAP_HORDE_FLAG_NOT_READY, 0);
     initWorldStates.Worldstates.emplace_back(ZM_MAP_ALLIANCE_FLAG_NOT_READY, 0);
diff --git a/src/server/scripts/OutdoorPvP/OutdoorPvPZM.h b/src/server/scripts/OutdoorPvP/OutdoorPvPZM.h
index a8d22f1a784..d29f3d63369 100644
--- a/src/server/scripts/OutdoorPvP/OutdoorPvPZM.h
+++ b/src/server/scripts/OutdoorPvP/OutdoorPvPZM.h
@@ -93,18 +93,17 @@ enum ZM_TowerStateMask
     ZM_TOWERSTATE_H = 4
 };
 
-class OPvPCapturePointZM_Beacon : public OPvPCapturePoint
+enum ZM_WorldEvents
 {
-    public:
-        OPvPCapturePointZM_Beacon(OutdoorPvP* pvp, ZM_BeaconType type, GameObject* go);
-
-        void ChangeState() override;
-
-        void UpdateTowerState();
-
-    protected:
-        ZM_BeaconType m_TowerType;
-        uint32 m_TowerState;
+    ZM_EVENT_BEACON_EAST_PROGRESS_HORDE     = 11807,
+    ZM_EVENT_BEACON_EAST_PROGRESS_ALLIANCE  = 11806,
+    ZM_EVENT_BEACON_EAST_NEUTRAL_HORDE      = 11814,
+    ZM_EVENT_BEACON_EAST_NEUTRAL_ALLIANCE   = 11815,
+
+    ZM_EVENT_BEACON_WEST_PROGRESS_HORDE     = 11805,
+    ZM_EVENT_BEACON_WEST_PROGRESS_ALLIANCE  = 11804,
+    ZM_EVENT_BEACON_WEST_NEUTRAL_HORDE      = 11808,
+    ZM_EVENT_BEACON_WEST_NEUTRAL_ALLIANCE   = 11809
 };
 
 enum ZM_GraveyardState
@@ -114,12 +113,51 @@ enum ZM_GraveyardState
     ZM_GRAVEYARD_H = 4
 };
 
+enum ZM_GameObjectEntries
+{
+    ZM_GO_ENTRY_BEACON_WEST = 182522,
+    ZM_GO_ENTRY_BEACON_EAST = 182523
+};
+
+class OutdoorPvPZM;
+
+class ZMControlZoneHandler : public OutdoorPvPControlZoneHandler
+{
+public:
+    ZMControlZoneHandler(OutdoorPvPZM* pvp, uint32 textBeaconTakenHorde, uint32 textBeaconTakenAlliance, uint32 worldstateNeutralUi, uint32 worldstateNeutralMap, uint32 worldstateHordeUi, uint32 worldstateHordeMap, uint32 worldstateAllianceUi, uint32 worldstateAllianceMap);
+
+    void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
+    void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEventHorde([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEventAlliance([[maybe_unused]] GameObject* controlZone) override;
+    void HandleNeutralEvent([[maybe_unused]] GameObject* controlZone) override;
+
+    uint32 GetWorldStateNeutralUI() { return _worldstateNeutralUi; }
+    uint32 GetWorldStateNeutralMap() { return _worldstateNeutralMap; }
+    uint32 GetWorldStateHordeUI() { return _worldstateHordeUi; }
+    uint32 GetWorldStateHordeMap() { return _worldstateHordeMap; }
+    uint32 GetWorldStateAllianceUI() { return _worldstateAllianceUi; }
+    uint32 GetWorldStateAllianceMap() { return _worldstateAllianceMap; }
+
+    OutdoorPvPZM* GetOutdoorPvpZM();
+
+private:
+    uint32 _textBeaconTakenHorde;
+    uint32 _textBeaconTakenAlliance;
+    uint32 _worldstateNeutralUi;
+    uint32 _worldstateNeutralMap;
+    uint32 _worldstateHordeUi;
+    uint32 _worldstateHordeMap;
+    uint32 _worldstateAllianceUi;
+    uint32 _worldstateAllianceMap;
+};
+
 class OPvPCapturePointZM_Graveyard : public OPvPCapturePoint
 {
     public:
         OPvPCapturePointZM_Graveyard(OutdoorPvP* pvp);
 
-        bool Update(uint32 diff) override;
+        void Update(uint32 diff) override;
         void ChangeState() override { }
         int32 HandleOpenGo(Player* player, GameObject* go) override;
         bool HandleDropFlag(Player* player, uint32 spellId) override;
@@ -144,10 +182,9 @@ class OutdoorPvPZM : public OutdoorPvP
         OutdoorPvPZM(Map* map);
 
         bool SetupOutdoorPvP() override;
-        void OnGameObjectCreate(GameObject* go) override;
         void HandlePlayerEnterZone(Player* player, uint32 zone) override;
         void HandlePlayerLeaveZone(Player* player, uint32 zone) override;
-        bool Update(uint32 diff) override;
+        void Update(uint32 diff) override;
         void SendRemoveWorldStates(Player* player) override;
         void HandleKillImpl(Player* player, Unit* killed) override;