*Some update of opvp (no real change)

--HG--
branch : trunk

src/game/ObjectMgr.cpp

@@ -1386,7 +1386,7 @@ void ObjectMgr::RemoveCreatureFromGrid(uint32 guid, CreatureData const* data)
     }
 }
 
-uint32 ObjectMgr::AddGameObject(uint32 entry, uint32 mapId, float x, float y, float z, float o, uint32 spawntimedelay, float rotation0, float rotation1, float rotation2, float rotation3)
+uint32 ObjectMgr::AddGOData(uint32 entry, uint32 mapId, float x, float y, float z, float o, uint32 spawntimedelay, float rotation0, float rotation1, float rotation2, float rotation3)
 {
     GameObjectInfo const* goinfo = GetGameObjectInfo(entry);
     if (!goinfo)
@@ -1433,7 +1433,7 @@ uint32 ObjectMgr::AddGameObject(uint32 entry, uint32 mapId, float x, float y, fl
     return guid;
 }
 
-uint32 ObjectMgr::AddCreature(uint32 entry, uint32 team, uint32 mapId, float x, float y, float z, float o, uint32 spawntimedelay)
+uint32 ObjectMgr::AddCreData(uint32 entry, uint32 team, uint32 mapId, float x, float y, float z, float o, uint32 spawntimedelay)
 {
     CreatureInfo const *cInfo = GetCreatureTemplate(entry);
     if(!cInfo)

src/game/ObjectMgr.h

@@ -754,8 +754,8 @@ class ObjectMgr
         void RemoveCreatureFromGrid(uint32 guid, CreatureData const* data);
         void AddGameobjectToGrid(uint32 guid, GameObjectData const* data);
         void RemoveGameobjectFromGrid(uint32 guid, GameObjectData const* data);
-        uint32 AddGameObject(uint32 entry, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay = 0, float rotation0 = 0, float rotation1 = 0, float rotation2 = 0, float rotation3 = 0);
+        uint32 AddGOData(uint32 entry, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay = 0, float rotation0 = 0, float rotation1 = 0, float rotation2 = 0, float rotation3 = 0);
-        uint32 AddCreature(uint32 entry, uint32 team, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay = 0);
+        uint32 AddCreData(uint32 entry, uint32 team, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay = 0);
 
         // reserved names
         void LoadReservedPlayersNames();

src/game/OutdoorPvP.cpp

@@ -48,28 +48,52 @@ void OPvPCapturePoint::HandlePlayerLeave(Player * plr)
     m_activePlayers[plr->GetTeamId()].erase(plr);
 }
 
-bool OPvPCapturePoint::AddObject(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3)
+void OPvPCapturePoint::AddGO(uint32 type, uint32 guid, uint32 entry)
 {
-    uint32 guid = objmgr.AddGameObject(entry, map, x, y, z, o, 0, rotation0, rotation1, rotation2, rotation3);
+    if(!entry)
-    if(!guid)
+    {
-        return false;
+        const GameObjectData *data = objmgr.GetGOData(guid);
-
+        if(!data)
-    // 2 way registering
+            return;
+        entry = data->id;
+    }
     m_Objects[type] = MAKE_NEW_GUID(guid, entry, HIGHGUID_GAMEOBJECT);
     m_ObjectTypes[m_Objects[type]]=type;
+}
 
-    return true;
+void OPvPCapturePoint::AddCre(uint32 type, uint32 guid, uint32 entry)
+{
+    if(!entry)
+    {
+        const CreatureData *data = objmgr.GetCreatureData(guid);
+        if(!data)
+            return;
+        entry = data->id;
+    }
+    m_Creatures[type] = MAKE_NEW_GUID(guid, entry, HIGHGUID_UNIT);
+    m_CreatureTypes[m_Creatures[type]] = type;
+}
+
+bool OPvPCapturePoint::AddObject(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3)
+{
+    if(uint32 guid = objmgr.AddGOData(entry, map, x, y, z, o, 0, rotation0, rotation1, rotation2, rotation3))
+    {
+        AddGO(type, guid, entry);
+        return true;
+    }
+
+    return false;
 }
 
 bool OPvPCapturePoint::AddCreature(uint32 type, uint32 entry, uint32 team, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay)
 {
-    uint32 guid = objmgr.AddCreature(entry, team, map, x, y, z, o, spawntimedelay);
+    if(uint32 guid = objmgr.AddCreData(entry, team, map, x, y, z, o, spawntimedelay))
-    if(!guid)
+    {
-        return false;
+        AddCre(type, guid, entry);
+        return true;
+    }
 
-    m_Creatures[type] = MAKE_NEW_GUID(guid, entry, HIGHGUID_UNIT);
+    return false;
-    m_CreatureTypes[m_Creatures[type]] = type;
-    return true;
 }
 
 bool OPvPCapturePoint::AddCapturePoint(uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3)
@@ -84,7 +108,7 @@ bool OPvPCapturePoint::AddCapturePoint(uint32 entry, uint32 map, float x, float
         return false;
     }
 
-    m_CapturePointGUID = objmgr.AddGameObject(entry, map, x, y, z, o, 0, rotation0, rotation1, rotation2, rotation3);
+    m_CapturePointGUID = objmgr.AddGOData(entry, map, x, y, z, o, 0, rotation0, rotation1, rotation2, rotation3);
     if(!m_CapturePointGUID)
         return false;
 
@@ -209,7 +233,13 @@ bool OutdoorPvP::Update(uint32 diff)
 {
     bool objective_changed = false;
     for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
-        objective_changed |= (*itr)->Update(diff);
+    {
+        if((*itr)->Update(diff))
+        {
+            (*itr)->ChangeState();
+            objective_changed = true;
+        }
+    }
     return objective_changed;
 }
 
@@ -316,7 +346,10 @@ bool OPvPCapturePoint::Update(uint32 diff)
             m_State = OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE;
     }
 
-    return true;
+    if(m_ShiftPhase != m_OldPhase)
+        SendChangePhase();
+
+    return m_OldState != m_State;
 }
 
 void OutdoorPvP::SendUpdateWorldState(uint32 field, uint32 value)

src/game/OutdoorPvP.h

@@ -97,6 +97,8 @@ public:
 
     // returns true if the state of the objective has changed, in this case, the OutdoorPvP must send a world state ui update.
     virtual bool Update(uint32 diff);
+    virtual void ChangeState() = 0;
+    virtual void SendChangePhase() {} 
 
     virtual bool HandleGossipOption(Player *plr, uint64 guid, uint32 gossipid);
 
@@ -109,15 +111,18 @@ public:
     uint32 m_CapturePointGUID;
     GameObject *m_capturePoint;
 
+    void AddGO(uint32 type, uint32 guid, uint32 entry = 0);
+    void AddCre(uint32 type, uint32 guid, uint32 entry = 0);
+    bool AddCapturePoint(uint32 entry, uint32 map, float x, float y, float z, float o = 0, float rotation0 = 0, float rotation1 = 0, float rotation2 = 0, float rotation3 = 0);
+
 protected:
 
-    virtual bool AddCapturePoint(uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3);
+    bool AddObject(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3);
-    virtual bool AddObject(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3);
+    bool AddCreature(uint32 type, uint32 entry, uint32 teamval, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay = 0);
-    virtual bool AddCreature(uint32 type, uint32 entry, uint32 teamval, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay = 0);
 
-    virtual bool DelCreature(uint32 type);
+    bool DelCreature(uint32 type);
-    virtual bool DelObject(uint32 type);
+    bool DelObject(uint32 type);
-    virtual bool DelCapturePoint();
+    bool DelCapturePoint();
 
 protected:
     // active players in the area of the objective, 0 - alliance, 1 - horde

src/game/OutdoorPvPEP.cpp

@@ -35,95 +35,90 @@ OPvPCapturePointEP_EWT::OPvPCapturePointEP_EWT(OutdoorPvP *pvp)
     AddObject(EP_EWT_FLAGS,EPTowerFlags[EP_EWT].entry,EPTowerFlags[EP_EWT].map,EPTowerFlags[EP_EWT].x,EPTowerFlags[EP_EWT].y,EPTowerFlags[EP_EWT].z,EPTowerFlags[EP_EWT].o,EPTowerFlags[EP_EWT].rot0,EPTowerFlags[EP_EWT].rot1,EPTowerFlags[EP_EWT].rot2,EPTowerFlags[EP_EWT].rot3);
 }
 
-bool OPvPCapturePointEP_EWT::Update(uint32 diff)
+void OPvPCapturePointEP_EWT::ChangeState()
 {
-    if(OPvPCapturePoint::Update(diff))
+    if(fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
     {
-        if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
+        // if changing from controlling alliance to horde or vice versa
+        if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
         {
-            // if changing from controlling alliance to horde or vice versa
+            sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_EWT_A));
-            if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = 0;
-            {
+        }
-                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_EWT_A));
+        else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = 0;
+        {
-            }
+            sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_EWT_H));
-            else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = 0;
-            {
-                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_EWT_H));
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = 0;
-            }
-
-            uint32 artkit = 21;
-
-            switch(m_State)
-            {
-            case OBJECTIVESTATE_ALLIANCE:
-                if(m_ShiftPhase == m_ShiftMaxPhase)
-                    m_TowerState = EP_TS_A;
-                else
-                    m_TowerState = EP_TS_A_P;
-                artkit = 2;
-                SummonSupportUnitAtNorthpassTower(ALLIANCE);
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = ALLIANCE;
-                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_A));
-                break;
-            case OBJECTIVESTATE_HORDE:
-                if(m_ShiftPhase == -m_ShiftMaxPhase)
-                    m_TowerState = EP_TS_H;
-                else
-                    m_TowerState = EP_TS_H_P;
-                artkit = 1;
-                SummonSupportUnitAtNorthpassTower(HORDE);
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = HORDE;
-                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_H));
-                break;
-            case OBJECTIVESTATE_NEUTRAL:
-                m_TowerState = EP_TS_N;
-                break;
-            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-                m_TowerState = EP_TS_N_A;
-                break;
-            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-                m_TowerState = EP_TS_N_H;
-                break;
-            }
-
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
-            GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_EWT_FLAGS]);
-            if(flag)
-            {
-                flag->SetGoArtKit(artkit);
-                flag->SendUpdateObjectToAllExcept(NULL);
-            }
-            if(flag2)
-            {
-                flag2->SetGoArtKit(artkit);
-                flag2->SendUpdateObjectToAllExcept(NULL);
-            }
-
-
-            UpdateTowerState();
-
-            // complete quest objective
-            if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
-                SendObjectiveComplete(EP_EWT_CM, 0);
         }
 
-        if(m_ShiftPhase != m_OldPhase)
+        uint32 artkit = 21;
+
+        switch(m_State)
         {
-            // send this too, sometimes the slider disappears, dunno why :(
+        case OBJECTIVESTATE_ALLIANCE:
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
+            if(m_ShiftPhase == m_ShiftMaxPhase)
-            // send these updates to only the ones in this objective
+                m_TowerState = EP_TS_A;
-            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+            else
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
+                m_TowerState = EP_TS_A_P;
-            // send this too, sometimes it resets :S
+            artkit = 2;
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
+            SummonSupportUnitAtNorthpassTower(ALLIANCE);
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = ALLIANCE;
+            if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_A));
+            break;
+        case OBJECTIVESTATE_HORDE:
+            if(m_ShiftPhase == -m_ShiftMaxPhase)
+                m_TowerState = EP_TS_H;
+            else
+                m_TowerState = EP_TS_H_P;
+            artkit = 1;
+            SummonSupportUnitAtNorthpassTower(HORDE);
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_EWT] = HORDE;
+            if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_H));
+            break;
+        case OBJECTIVESTATE_NEUTRAL:
+            m_TowerState = EP_TS_N;
+            break;
+        case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
+        case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
+            m_TowerState = EP_TS_N_A;
+            break;
+        case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
+        case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
+            m_TowerState = EP_TS_N_H;
+            break;
         }
-        return m_OldState != m_State;
+
+        GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
+        GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_EWT_FLAGS]);
+        if(flag)
+        {
+            flag->SetGoArtKit(artkit);
+            flag->SendUpdateObjectToAllExcept(NULL);
+        }
+        if(flag2)
+        {
+            flag2->SetGoArtKit(artkit);
+            flag2->SendUpdateObjectToAllExcept(NULL);
+        }
+
+
+        UpdateTowerState();
+
+        // complete quest objective
+        if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
+            SendObjectiveComplete(EP_EWT_CM, 0);
     }
-    return false;
+}
+
+void OPvPCapturePointEP_EWT::SendChangePhase()
+{
+    // send this too, sometimes the slider disappears, dunno why :(
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
+    // send these updates to only the ones in this objective
+    uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
+    // send this too, sometimes it resets :S
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
 }
 
 void OPvPCapturePointEP_EWT::FillInitialWorldStates(WorldPacket &data)
@@ -194,96 +189,91 @@ OPvPCapturePointEP_NPT::OPvPCapturePointEP_NPT(OutdoorPvP *pvp)
     AddObject(EP_NPT_FLAGS,EPTowerFlags[EP_NPT].entry,EPTowerFlags[EP_NPT].map,EPTowerFlags[EP_NPT].x,EPTowerFlags[EP_NPT].y,EPTowerFlags[EP_NPT].z,EPTowerFlags[EP_NPT].o,EPTowerFlags[EP_NPT].rot0,EPTowerFlags[EP_NPT].rot1,EPTowerFlags[EP_NPT].rot2,EPTowerFlags[EP_NPT].rot3);
 }
 
-bool OPvPCapturePointEP_NPT::Update(uint32 diff)
+void OPvPCapturePointEP_NPT::ChangeState()
 {
-    if(OPvPCapturePoint::Update(diff))
+    if(fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
     {
-        if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
+        // if changing from controlling alliance to horde or vice versa
+        if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
         {
-            // if changing from controlling alliance to horde or vice versa
+            sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_NPT_A));
-            if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = 0;
-            {
+        }
-                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_NPT_A));
+        else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = 0;
+        {
-            }
+            sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_NPT_H));
-            else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = 0;
-            {
-                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_NPT_H));
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = 0;
-            }
-
-            uint32 artkit = 21;
-
-            switch(m_State)
-            {
-            case OBJECTIVESTATE_ALLIANCE:
-                if(m_ShiftPhase == m_ShiftMaxPhase)
-                    m_TowerState = EP_TS_A;
-                else
-                    m_TowerState = EP_TS_A_P;
-                artkit = 2;
-                SummonGO(ALLIANCE);
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = ALLIANCE;
-                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_A));
-                break;
-            case OBJECTIVESTATE_HORDE:
-                if(m_ShiftPhase == -m_ShiftMaxPhase)
-                    m_TowerState = EP_TS_H;
-                else
-                    m_TowerState = EP_TS_H_P;
-                artkit = 1;
-                SummonGO(HORDE);
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = HORDE;
-                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_H));
-                break;
-            case OBJECTIVESTATE_NEUTRAL:
-                m_TowerState = EP_TS_N;
-                m_SummonedGOSide = 0;
-                DelObject(EP_NPT_BUFF);
-                break;
-            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-                m_TowerState = EP_TS_N_A;
-                break;
-            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-                m_TowerState = EP_TS_N_H;
-                break;
-            }
-
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
-            GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_NPT_FLAGS]);
-            if(flag)
-            {
-                flag->SetGoArtKit(artkit);
-                flag->SendUpdateObjectToAllExcept(NULL);
-            }
-            if(flag2)
-            {
-                flag2->SetGoArtKit(artkit);
-                flag2->SendUpdateObjectToAllExcept(NULL);
-            }
-
-            UpdateTowerState();
-
-            // complete quest objective
-            if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
-                SendObjectiveComplete(EP_NPT_CM, 0);
         }
 
-        if(m_ShiftPhase != m_OldPhase)
+        uint32 artkit = 21;
+
+        switch(m_State)
         {
-            // send this too, sometimes the slider disappears, dunno why :(
+        case OBJECTIVESTATE_ALLIANCE:
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
+            if(m_ShiftPhase == m_ShiftMaxPhase)
-            // send these updates to only the ones in this objective
+                m_TowerState = EP_TS_A;
-            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+            else
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
+                m_TowerState = EP_TS_A_P;
-            // send this too, sometimes it resets :S
+            artkit = 2;
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
+            SummonGO(ALLIANCE);
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = ALLIANCE;
+            if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_A));
+            break;
+        case OBJECTIVESTATE_HORDE:
+            if(m_ShiftPhase == -m_ShiftMaxPhase)
+                m_TowerState = EP_TS_H;
+            else
+                m_TowerState = EP_TS_H_P;
+            artkit = 1;
+            SummonGO(HORDE);
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_NPT] = HORDE;
+            if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_H));
+            break;
+        case OBJECTIVESTATE_NEUTRAL:
+            m_TowerState = EP_TS_N;
+            m_SummonedGOSide = 0;
+            DelObject(EP_NPT_BUFF);
+            break;
+        case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
+        case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
+            m_TowerState = EP_TS_N_A;
+            break;
+        case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
+        case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
+            m_TowerState = EP_TS_N_H;
+            break;
         }
-        return m_OldState != m_State;
+
+        GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
+        GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_NPT_FLAGS]);
+        if(flag)
+        {
+            flag->SetGoArtKit(artkit);
+            flag->SendUpdateObjectToAllExcept(NULL);
+        }
+        if(flag2)
+        {
+            flag2->SetGoArtKit(artkit);
+            flag2->SendUpdateObjectToAllExcept(NULL);
+        }
+
+        UpdateTowerState();
+
+        // complete quest objective
+        if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
+            SendObjectiveComplete(EP_NPT_CM, 0);
     }
-    return false;
+}
+
+void OPvPCapturePointEP_NPT::SendChangePhase()
+{
+    // send this too, sometimes the slider disappears, dunno why :(
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
+    // send these updates to only the ones in this objective
+    uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
+    // send this too, sometimes it resets :S
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
 }
 
 void OPvPCapturePointEP_NPT::FillInitialWorldStates(WorldPacket &data)
@@ -348,94 +338,89 @@ OPvPCapturePointEP_CGT::OPvPCapturePointEP_CGT(OutdoorPvP *pvp)
     AddObject(EP_CGT_FLAGS,EPTowerFlags[EP_CGT].entry,EPTowerFlags[EP_CGT].map,EPTowerFlags[EP_CGT].x,EPTowerFlags[EP_CGT].y,EPTowerFlags[EP_CGT].z,EPTowerFlags[EP_CGT].o,EPTowerFlags[EP_CGT].rot0,EPTowerFlags[EP_CGT].rot1,EPTowerFlags[EP_CGT].rot2,EPTowerFlags[EP_CGT].rot3);
 }
 
-bool OPvPCapturePointEP_CGT::Update(uint32 diff)
+void OPvPCapturePointEP_CGT::ChangeState()
 {
-    if(OPvPCapturePoint::Update(diff))
+    if(fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
     {
-        if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
+        // if changing from controlling alliance to horde or vice versa
+        if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
         {
-            // if changing from controlling alliance to horde or vice versa
+            sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_CGT_A));
-            if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = 0;
-            {
+        }
-                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_CGT_A));
+        else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = 0;
+        {
-            }
+            sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_CGT_H));
-            else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = 0;
-            {
-                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_CGT_H));
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = 0;
-            }
-
-            uint32 artkit = 21;
-
-            switch(m_State)
-            {
-            case OBJECTIVESTATE_ALLIANCE:
-                if(m_ShiftPhase == m_ShiftMaxPhase)
-                    m_TowerState = EP_TS_A;
-                else
-                    m_TowerState = EP_TS_A_P;
-                artkit = 2;
-                LinkGraveYard(ALLIANCE);
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = ALLIANCE;
-                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_A));
-                break;
-            case OBJECTIVESTATE_HORDE:
-                if(m_ShiftPhase == -m_ShiftMaxPhase)
-                    m_TowerState = EP_TS_H;
-                else
-                    m_TowerState = EP_TS_H_P;
-                artkit = 1;
-                LinkGraveYard(HORDE);
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = HORDE;
-                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_H));
-                break;
-            case OBJECTIVESTATE_NEUTRAL:
-                m_TowerState = EP_TS_N;
-                break;
-            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-                m_TowerState = EP_TS_N_A;
-                break;
-            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-                m_TowerState = EP_TS_N_H;
-                break;
-            }
-
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
-            GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_CGT_FLAGS]);
-            if(flag)
-            {
-                flag->SetGoArtKit(artkit);
-                flag->SendUpdateObjectToAllExcept(NULL);
-            }
-            if(flag2)
-            {
-                flag2->SetGoArtKit(artkit);
-                flag2->SendUpdateObjectToAllExcept(NULL);
-            }
-
-            UpdateTowerState();
-
-            // complete quest objective
-            if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
-                SendObjectiveComplete(EP_CGT_CM, 0);
         }
 
-        if(m_ShiftPhase != m_OldPhase)
+        uint32 artkit = 21;
+
+        switch(m_State)
         {
-            // send this too, sometimes the slider disappears, dunno why :(
+        case OBJECTIVESTATE_ALLIANCE:
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
+            if(m_ShiftPhase == m_ShiftMaxPhase)
-            // send these updates to only the ones in this objective
+                m_TowerState = EP_TS_A;
-            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+            else
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
+                m_TowerState = EP_TS_A_P;
-            // send this too, sometimes it resets :S
+            artkit = 2;
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
+            LinkGraveYard(ALLIANCE);
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = ALLIANCE;
+            if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_A));
+            break;
+        case OBJECTIVESTATE_HORDE:
+            if(m_ShiftPhase == -m_ShiftMaxPhase)
+                m_TowerState = EP_TS_H;
+            else
+                m_TowerState = EP_TS_H_P;
+            artkit = 1;
+            LinkGraveYard(HORDE);
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_CGT] = HORDE;
+            if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_H));
+            break;
+        case OBJECTIVESTATE_NEUTRAL:
+            m_TowerState = EP_TS_N;
+            break;
+        case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
+        case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
+            m_TowerState = EP_TS_N_A;
+            break;
+        case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
+        case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
+            m_TowerState = EP_TS_N_H;
+            break;
         }
-        return m_OldState != m_State;
+
+        GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
+        GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_CGT_FLAGS]);
+        if(flag)
+        {
+            flag->SetGoArtKit(artkit);
+            flag->SendUpdateObjectToAllExcept(NULL);
+        }
+        if(flag2)
+        {
+            flag2->SetGoArtKit(artkit);
+            flag2->SendUpdateObjectToAllExcept(NULL);
+        }
+
+        UpdateTowerState();
+
+        // complete quest objective
+        if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
+            SendObjectiveComplete(EP_CGT_CM, 0);
     }
-    return false;
+}
+
+void OPvPCapturePointEP_CGT::SendChangePhase()
+{
+    // send this too, sometimes the slider disappears, dunno why :(
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
+    // send these updates to only the ones in this objective
+    uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
+    // send this too, sometimes it resets :S
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
 }
 
 void OPvPCapturePointEP_CGT::FillInitialWorldStates(WorldPacket &data)
@@ -497,96 +482,91 @@ OPvPCapturePointEP_PWT::OPvPCapturePointEP_PWT(OutdoorPvP *pvp)
     AddObject(EP_PWT_FLAGS,EPTowerFlags[EP_PWT].entry,EPTowerFlags[EP_PWT].map,EPTowerFlags[EP_PWT].x,EPTowerFlags[EP_PWT].y,EPTowerFlags[EP_PWT].z,EPTowerFlags[EP_PWT].o,EPTowerFlags[EP_PWT].rot0,EPTowerFlags[EP_PWT].rot1,EPTowerFlags[EP_PWT].rot2,EPTowerFlags[EP_PWT].rot3);
 }
 
-bool OPvPCapturePointEP_PWT::Update(uint32 diff)
+void OPvPCapturePointEP_PWT::ChangeState()
 {
-    if(OPvPCapturePoint::Update(diff))
+    if(fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
     {
-        if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
+        // if changing from controlling alliance to horde or vice versa
+        if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
         {
-            // if changing from controlling alliance to horde or vice versa
+            sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_PWT_A));
-            if( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = 0;
-            {
+        }
-                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_PWT_A));
+        else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = 0;
+        {
-            }
+            sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_PWT_H));
-            else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = 0;
-            {
-                sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_LOOSE_PWT_H));
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = 0;
-            }
-
-            uint32 artkit = 21;
-
-            switch(m_State)
-            {
-            case OBJECTIVESTATE_ALLIANCE:
-                if(m_ShiftPhase == m_ShiftMaxPhase)
-                    m_TowerState = EP_TS_A;
-                else
-                    m_TowerState = EP_TS_A_P;
-                SummonFlightMaster(ALLIANCE);
-                artkit = 2;
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = ALLIANCE;
-                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_A));
-                break;
-            case OBJECTIVESTATE_HORDE:
-                if(m_ShiftPhase == -m_ShiftMaxPhase)
-                    m_TowerState = EP_TS_H;
-                else
-                    m_TowerState = EP_TS_H_P;
-                SummonFlightMaster(HORDE);
-                artkit = 1;
-                ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = HORDE;
-                if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_H));
-                break;
-            case OBJECTIVESTATE_NEUTRAL:
-                m_TowerState = EP_TS_N;
-                DelCreature(EP_PWT_FLIGHTMASTER);
-                m_FlightMasterSpawned = 0;
-                break;
-            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-                m_TowerState = EP_TS_N_A;
-                break;
-            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-                m_TowerState = EP_TS_N_H;
-                break;
-            }
-
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
-            GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_PWT_FLAGS]);
-            if(flag)
-            {
-                flag->SetGoArtKit(artkit);
-                flag->SendUpdateObjectToAllExcept(NULL);
-            }
-            if(flag2)
-            {
-                flag2->SetGoArtKit(artkit);
-                flag2->SendUpdateObjectToAllExcept(NULL);
-            }
-
-            UpdateTowerState();
-
-            // complete quest objective
-            if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
-                SendObjectiveComplete(EP_PWT_CM, 0);
         }
 
-        if(m_ShiftPhase != m_OldPhase)
+        uint32 artkit = 21;
+
+        switch(m_State)
         {
-            // send this too, sometimes the slider disappears, dunno why :(
+        case OBJECTIVESTATE_ALLIANCE:
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
+            if(m_ShiftPhase == m_ShiftMaxPhase)
-            // send these updates to only the ones in this objective
+                m_TowerState = EP_TS_A;
-            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+            else
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
+                m_TowerState = EP_TS_A_P;
-            // send this too, sometimes it resets :S
+            SummonFlightMaster(ALLIANCE);
-            SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
+            artkit = 2;
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = ALLIANCE;
+            if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_A));
+            break;
+        case OBJECTIVESTATE_HORDE:
+            if(m_ShiftPhase == -m_ShiftMaxPhase)
+                m_TowerState = EP_TS_H;
+            else
+                m_TowerState = EP_TS_H_P;
+            SummonFlightMaster(HORDE);
+            artkit = 1;
+            ((OutdoorPvPEP*)m_PvP)->EP_Controls[EP_PWT] = HORDE;
+            if(m_OldState != m_State) sWorld.SendZoneText(EP_GraveYardZone,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_H));
+            break;
+        case OBJECTIVESTATE_NEUTRAL:
+            m_TowerState = EP_TS_N;
+            DelCreature(EP_PWT_FLIGHTMASTER);
+            m_FlightMasterSpawned = 0;
+            break;
+        case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
+        case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
+            m_TowerState = EP_TS_N_A;
+            break;
+        case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
+        case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
+            m_TowerState = EP_TS_N_H;
+            break;
         }
-        return m_OldState != m_State;
+
+        GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
+        GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_PWT_FLAGS]);
+        if(flag)
+        {
+            flag->SetGoArtKit(artkit);
+            flag->SendUpdateObjectToAllExcept(NULL);
+        }
+        if(flag2)
+        {
+            flag2->SetGoArtKit(artkit);
+            flag2->SendUpdateObjectToAllExcept(NULL);
+        }
+
+        UpdateTowerState();
+
+        // complete quest objective
+        if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
+            SendObjectiveComplete(EP_PWT_CM, 0);
     }
-    return false;
+}
+
+void OPvPCapturePointEP_PWT::SendChangePhase()
+{
+    // send this too, sometimes the slider disappears, dunno why :(
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
+    // send these updates to only the ones in this objective
+    uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
+    // send this too, sometimes it resets :S
+    SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
 }
 
 void OPvPCapturePointEP_PWT::FillInitialWorldStates(WorldPacket &data)

src/game/OutdoorPvPEP.h

@@ -183,7 +183,8 @@ class OPvPCapturePointEP_EWT : public OPvPCapturePoint
 friend class OutdoorPvPEP;
 public:
     OPvPCapturePointEP_EWT(OutdoorPvP * pvp);
-    bool Update(uint32 diff);
+    void ChangeState();
+    void SendChangePhase();
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);
@@ -201,7 +202,8 @@ class OPvPCapturePointEP_NPT : public OPvPCapturePoint
 friend class OutdoorPvPEP;
 public:
     OPvPCapturePointEP_NPT(OutdoorPvP * pvp);
-    bool Update(uint32 diff);
+    void ChangeState();
+    void SendChangePhase();
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);
@@ -219,7 +221,8 @@ class OPvPCapturePointEP_CGT : public OPvPCapturePoint
 friend class OutdoorPvPEP;
 public:
     OPvPCapturePointEP_CGT(OutdoorPvP * pvp);
-    bool Update(uint32 diff);
+    void ChangeState();
+    void SendChangePhase();
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);
@@ -237,7 +240,8 @@ class OPvPCapturePointEP_PWT : public OPvPCapturePoint
 friend class OutdoorPvPEP;
 public:
     OPvPCapturePointEP_PWT(OutdoorPvP * pvp);
-    bool Update(uint32 diff);
+    void ChangeState();
+    void SendChangePhase();
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);

src/game/OutdoorPvPHP.cpp

@@ -163,126 +163,117 @@ void OutdoorPvPHP::FillInitialWorldStates(WorldPacket &data)
     }
 }
 
-bool OPvPCapturePointHP::Update(uint32 diff)
+void OPvPCapturePointHP::ChangeState()
 {
-    // if status changed:
+    uint32 field = 0;
-    if(OPvPCapturePoint::Update(diff))
+    switch(m_OldState)
     {
-        if(m_OldState != m_State)
+    case OBJECTIVESTATE_NEUTRAL:
-        {
+        field = HP_MAP_N[m_TowerType];
-            uint32 field = 0;
+        break;
-            switch(m_OldState)
+    case OBJECTIVESTATE_ALLIANCE:
-            {
+        field = HP_MAP_A[m_TowerType];
-            case OBJECTIVESTATE_NEUTRAL:
+        if(((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled)
-                field = HP_MAP_N[m_TowerType];
+            ((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled--;
-                break;
+        sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_LOOSE_A[m_TowerType]));
-            case OBJECTIVESTATE_ALLIANCE:
+        break;
-                field = HP_MAP_A[m_TowerType];
+    case OBJECTIVESTATE_HORDE:
-                if(((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled)
+        field = HP_MAP_H[m_TowerType];
-                    ((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled--;
+        if(((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled)
-                sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_LOOSE_A[m_TowerType]));
+            ((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled--;
-                break;
+        sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_LOOSE_H[m_TowerType]));
-            case OBJECTIVESTATE_HORDE:
+        break;
-                field = HP_MAP_H[m_TowerType];
+    case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-                if(((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled)
+        field = HP_MAP_N[m_TowerType];
-                    ((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled--;
+        break;
-                sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_LOOSE_H[m_TowerType]));
+    case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-                break;
+        field = HP_MAP_N[m_TowerType];
-            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
+        break;
-                field = HP_MAP_N[m_TowerType];
+    case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-                break;
+        field = HP_MAP_A[m_TowerType];
-            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
+        break;
-                field = HP_MAP_N[m_TowerType];
+    case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-                break;
+        field = HP_MAP_H[m_TowerType];
-            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
+        break;
-                field = HP_MAP_A[m_TowerType];
-                break;
-            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-                field = HP_MAP_H[m_TowerType];
-                break;
-            }
-
-            // send world state update
-            if(field)
-            {
-                m_PvP->SendUpdateWorldState(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];
-                if(((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled<3)
-                    ((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled++;
-                sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_CAPTURE_A[m_TowerType]));
-                break;
-            case OBJECTIVESTATE_HORDE:
-                field = HP_MAP_H[m_TowerType];
-                artkit = 1;
-                artkit2 = HP_TowerArtKit_H[m_TowerType];
-                if(((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled<3)
-                    ((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled++;
-                sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_CAPTURE_H[m_TowerType]));
-                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];
-                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;
-            }
-
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
-            GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[m_TowerType]);
-            if(flag)
-            {
-                flag->SetGoArtKit(artkit);
-                flag->SendUpdateObjectToAllExcept(NULL);
-            }
-            if(flag2)
-            {
-                flag2->SetGoArtKit(artkit2);
-                flag2->SendUpdateObjectToAllExcept(NULL);
-            }
-
-            // send world state update
-            if(field)
-                m_PvP->SendUpdateWorldState(field, 1);
-
-            // complete quest objective
-            if(m_State == OBJECTIVESTATE_ALLIANCE || m_State == OBJECTIVESTATE_HORDE)
-                SendObjectiveComplete(HP_CREDITMARKER[m_TowerType], 0);
-        }
-
-        if(m_ShiftPhase != m_OldPhase)
-        {
-            SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, m_NeutralValue);
-            // send these updates to only the ones in this objective
-            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
-            SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, phase);
-            // send this too, sometimes the slider disappears, dunno why :(
-            SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1);
-        }
-        return m_OldState != m_State;
     }
-    return false;
+
+    // send world state update
+    if(field)
+    {
+        m_PvP->SendUpdateWorldState(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];
+        if(((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled<3)
+            ((OutdoorPvPHP*)m_PvP)->m_AllianceTowersControlled++;
+        sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_CAPTURE_A[m_TowerType]));
+        break;
+    case OBJECTIVESTATE_HORDE:
+        field = HP_MAP_H[m_TowerType];
+        artkit = 1;
+        artkit2 = HP_TowerArtKit_H[m_TowerType];
+        if(((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled<3)
+            ((OutdoorPvPHP*)m_PvP)->m_HordeTowersControlled++;
+        sWorld.SendZoneText(OutdoorPvPHPBuffZones[0],objmgr.GetTrinityStringForDBCLocale(HP_LANG_CAPTURE_H[m_TowerType]));
+        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];
+        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;
+    }
+
+    GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
+    GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[m_TowerType]);
+    if(flag)
+    {
+        flag->SetGoArtKit(artkit);
+        flag->SendUpdateObjectToAllExcept(NULL);
+    }
+    if(flag2)
+    {
+        flag2->SetGoArtKit(artkit2);
+        flag2->SendUpdateObjectToAllExcept(NULL);
+    }
+
+    // send world state update
+    if(field)
+        m_PvP->SendUpdateWorldState(field, 1);
+
+    // complete quest objective
+    if(m_State == OBJECTIVESTATE_ALLIANCE || m_State == OBJECTIVESTATE_HORDE)
+        SendObjectiveComplete(HP_CREDITMARKER[m_TowerType], 0);
+}
+
+void OPvPCapturePointHP::SendChangePhase()
+{
+    SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, m_NeutralValue);
+    // send these updates to only the ones in this objective
+    uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+    SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, phase);
+    // send this too, sometimes the slider disappears, dunno why :(
+    SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1);
 }
 
 void OPvPCapturePointHP::FillInitialWorldStates(WorldPacket &data)

src/game/OutdoorPvPHP.h

@@ -86,7 +86,8 @@ class OPvPCapturePointHP : public OPvPCapturePoint
 {
 public:
     OPvPCapturePointHP(OutdoorPvP * pvp, OutdoorPvPHPTowerType type);
-    bool Update(uint32 diff);
+    void ChangeState();
+    void SendChangePhase();
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);

src/game/OutdoorPvPNA.cpp

@@ -554,7 +554,7 @@ bool OPvPCapturePointNA::Update(uint32 diff)
         }
     } else m_GuardCheckTimer -= diff;
 
-    if((m_capturable || capturable) && OPvPCapturePoint::Update(diff))
+    if(m_capturable || capturable)
     {
         if(m_RespawnTimer < diff)
         {
@@ -565,64 +565,65 @@ bool OPvPCapturePointNA::Update(uint32 diff)
             m_RespawnTimer = NA_RESPAWN_TIME;
         } else m_RespawnTimer -= diff;
 
-        if(m_OldState != m_State)
+        return OPvPCapturePoint::Update(diff);
-        {
-            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;
-            }
-
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
-            if(flag)
-            {
-                flag->SetGoArtKit(artkit);
-                flag->SendUpdateObjectToAllExcept(NULL);
-            }
-
-            UpdateHalaaWorldState();
-        }
-
-        if(m_ShiftPhase != m_OldPhase)
-        {
-            // send this too, sometimes the slider disappears, dunno why :(
-            SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 1);
-            // send these updates to only the ones in this objective
-            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
-            SendUpdateWorldState(NA_UI_TOWER_SLIDER_POS, phase);
-            SendUpdateWorldState(NA_UI_TOWER_SLIDER_N, m_NeutralValue);
-        }
-        return m_OldState != m_State;
     }
     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;
+    }
+
+    GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
+    if(flag)
+    {
+        flag->SetGoArtKit(artkit);
+        flag->SendUpdateObjectToAllExcept(NULL);
+    }
+
+    UpdateHalaaWorldState();
+}
+
+void OPvPCapturePointNA::SendChangePhase()
+{
+    // send this too, sometimes the slider disappears, dunno why :(
+    SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 1);
+    // send these updates to only the ones in this objective
+    uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+    SendUpdateWorldState(NA_UI_TOWER_SLIDER_POS, phase);
+    SendUpdateWorldState(NA_UI_TOWER_SLIDER_N, m_NeutralValue);
+}
+
 void OPvPCapturePointNA::UpdateHalaaWorldState()
 {
     m_PvP->SendUpdateWorldState( NA_MAP_HALAA_NEUTRAL ,uint32(bool(m_HalaaState & HALAA_N)));

src/game/OutdoorPvPNA.h

@@ -244,6 +244,8 @@ friend class OutdoorPvPNA;
 public:
     OPvPCapturePointNA(OutdoorPvP * pvp);
     bool Update(uint32 diff);
+    void ChangeState();
+    void SendChangePhase();
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);

src/game/OutdoorPvPTF.cpp

@@ -239,74 +239,71 @@ bool OPvPCapturePointTF::Update(uint32 diff)
             ((((OutdoorPvPTF*)m_PvP)->m_HordeTowersControlled > 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)->m_IsLocked;
-    if(canupdate && OPvPCapturePoint::Update(diff))
+    return canupdate && OPvPCapturePoint::Update(diff);
-    {
+}
-        if(m_OldState != m_State)
+
-        {
+void OPvPCapturePointTF::ChangeState()
-            // if changing from controlling alliance to horde
+{
-            if( m_OldState == OBJECTIVESTATE_ALLIANCE )
+    // if changing from controlling alliance to horde
-            {
+    if( m_OldState == OBJECTIVESTATE_ALLIANCE )
-                if(((OutdoorPvPTF*)m_PvP)->m_AllianceTowersControlled)
+    {
-                    ((OutdoorPvPTF*)m_PvP)->m_AllianceTowersControlled--;
+        if(((OutdoorPvPTF*)m_PvP)->m_AllianceTowersControlled)
-                sWorld.SendZoneText(OutdoorPvPTFBuffZones[0],objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_TF_LOOSE_A));
+            ((OutdoorPvPTF*)m_PvP)->m_AllianceTowersControlled--;
-            }
+        sWorld.SendZoneText(OutdoorPvPTFBuffZones[0],objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_TF_LOOSE_A));
-            // if changing from controlling horde to alliance
+    }
-            else if ( m_OldState == OBJECTIVESTATE_HORDE )
+    // if changing from controlling horde to alliance
-            {
+    else if ( m_OldState == OBJECTIVESTATE_HORDE )
-                if(((OutdoorPvPTF*)m_PvP)->m_HordeTowersControlled)
+    {
-                    ((OutdoorPvPTF*)m_PvP)->m_HordeTowersControlled--;
+        if(((OutdoorPvPTF*)m_PvP)->m_HordeTowersControlled)
-                sWorld.SendZoneText(OutdoorPvPTFBuffZones[0],objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_TF_LOOSE_H));
+            ((OutdoorPvPTF*)m_PvP)->m_HordeTowersControlled--;
-            }
+        sWorld.SendZoneText(OutdoorPvPTFBuffZones[0],objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_TF_LOOSE_H));
-
+    }
-            uint32 artkit = 21;
+
-
+    uint32 artkit = 21;
-            switch(m_State)
+
-            {
+    switch(m_State)
-            case OBJECTIVESTATE_ALLIANCE:
+    {
-                m_TowerState = TF_TOWERSTATE_A;
+    case OBJECTIVESTATE_ALLIANCE:
-                artkit = 2;
+        m_TowerState = TF_TOWERSTATE_A;
-                if(((OutdoorPvPTF*)m_PvP)->m_AllianceTowersControlled<TF_TOWER_NUM)
+        artkit = 2;
-                    ((OutdoorPvPTF*)m_PvP)->m_AllianceTowersControlled++;
+        if(((OutdoorPvPTF*)m_PvP)->m_AllianceTowersControlled<TF_TOWER_NUM)
-                sWorld.SendZoneText(OutdoorPvPTFBuffZones[0],objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_TF_CAPTURE_A));
+            ((OutdoorPvPTF*)m_PvP)->m_AllianceTowersControlled++;
-                break;
+        sWorld.SendZoneText(OutdoorPvPTFBuffZones[0],objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_TF_CAPTURE_A));
-            case OBJECTIVESTATE_HORDE:
+        break;
-                m_TowerState = TF_TOWERSTATE_H;
+    case OBJECTIVESTATE_HORDE:
-                artkit = 1;
+        m_TowerState = TF_TOWERSTATE_H;
-                if(((OutdoorPvPTF*)m_PvP)->m_HordeTowersControlled<TF_TOWER_NUM)
+        artkit = 1;
-                    ((OutdoorPvPTF*)m_PvP)->m_HordeTowersControlled++;
+        if(((OutdoorPvPTF*)m_PvP)->m_HordeTowersControlled<TF_TOWER_NUM)
-                sWorld.SendZoneText(OutdoorPvPTFBuffZones[0],objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_TF_CAPTURE_H));
+            ((OutdoorPvPTF*)m_PvP)->m_HordeTowersControlled++;
-                break;
+        sWorld.SendZoneText(OutdoorPvPTFBuffZones[0],objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_TF_CAPTURE_H));
-            case OBJECTIVESTATE_NEUTRAL:
+        break;
-            case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
+    case OBJECTIVESTATE_NEUTRAL:
-            case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
+    case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
-            case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
+    case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
-            case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
+    case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
-                m_TowerState = TF_TOWERSTATE_N;
+    case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
-                break;
+        m_TowerState = TF_TOWERSTATE_N;
-            }
+        break;
-
+    }
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
+
-            if(flag)
+    GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
-            {
+    if(flag)
-                flag->SetGoArtKit(artkit);
+    {
-                flag->SendUpdateObjectToAllExcept(NULL);
+        flag->SetGoArtKit(artkit);
-            }
+        flag->SendUpdateObjectToAllExcept(NULL);
-
+    }
-            UpdateTowerState();
+
-        }
+    UpdateTowerState();
-
+}
-        if(m_ShiftPhase != m_OldPhase)
+
-        {
+void OPvPCapturePointTF::SendChangePhase()
-            // send this too, sometimes the slider disappears, dunno why :(
+{
-            SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 1);
+    // send this too, sometimes the slider disappears, dunno why :(
-            // send these updates to only the ones in this objective
+    SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 1);
-            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+    // send these updates to only the ones in this objective
-            SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, phase);
+    uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
-            // send this too, sometimes it resets :S
+    SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, phase);
-            SendUpdateWorldState(TF_UI_TOWER_SLIDER_N, m_NeutralValue);
+    // send this too, sometimes it resets :S
-        }
+    SendUpdateWorldState(TF_UI_TOWER_SLIDER_N, m_NeutralValue);
-        return m_OldState != m_State;
-    }
-    return false;
 }
 

src/game/OutdoorPvPTF.h

@@ -81,6 +81,8 @@ class OPvPCapturePointTF : public OPvPCapturePoint
 public:
     OPvPCapturePointTF(OutdoorPvP * pvp, OutdoorPvPTF_TowerType type);
     bool Update(uint32 diff);
+    void ChangeState();
+    void SendChangePhase();
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);

src/game/OutdoorPvPZM.cpp

@@ -71,65 +71,57 @@ void OPvPCapturePointZM_Beacon::HandlePlayerLeave(Player *plr)
     OPvPCapturePoint::HandlePlayerLeave(plr);
 }
 
-bool OPvPCapturePointZM_Beacon::Update(uint32 diff)
+void OPvPCapturePointZM_Beacon::ChangeState()
 {
-    if(OPvPCapturePoint::Update(diff))
+    // if changing from controlling alliance to horde
+    if( m_OldState == OBJECTIVESTATE_ALLIANCE )
     {
-        if(m_OldState != m_State)
+        if(((OutdoorPvPZM*)m_PvP)->m_AllianceTowersControlled)
-        {
+            ((OutdoorPvPZM*)m_PvP)->m_AllianceTowersControlled--;
-            // if changing from controlling alliance to horde
+        sWorld.SendZoneText(ZM_GRAVEYARD_ZONE,objmgr.GetTrinityStringForDBCLocale(ZMBeaconLooseA[m_TowerType]));
-            if( m_OldState == OBJECTIVESTATE_ALLIANCE )
-            {
-                if(((OutdoorPvPZM*)m_PvP)->m_AllianceTowersControlled)
-                    ((OutdoorPvPZM*)m_PvP)->m_AllianceTowersControlled--;
-                sWorld.SendZoneText(ZM_GRAVEYARD_ZONE,objmgr.GetTrinityStringForDBCLocale(ZMBeaconLooseA[m_TowerType]));
-            }
-            // if changing from controlling horde to alliance
-            else if ( m_OldState == OBJECTIVESTATE_HORDE )
-            {
-                if(((OutdoorPvPZM*)m_PvP)->m_HordeTowersControlled)
-                    ((OutdoorPvPZM*)m_PvP)->m_HordeTowersControlled--;
-                sWorld.SendZoneText(ZM_GRAVEYARD_ZONE,objmgr.GetTrinityStringForDBCLocale(ZMBeaconLooseH[m_TowerType]));
-            }
-
-            switch(m_State)
-            {
-            case OBJECTIVESTATE_ALLIANCE:
-                m_TowerState = ZM_TOWERSTATE_A;
-                if(((OutdoorPvPZM*)m_PvP)->m_AllianceTowersControlled<ZM_NUM_BEACONS)
-                    ((OutdoorPvPZM*)m_PvP)->m_AllianceTowersControlled++;
-                sWorld.SendZoneText(ZM_GRAVEYARD_ZONE,objmgr.GetTrinityStringForDBCLocale(ZMBeaconCaptureA[m_TowerType]));
-                break;
-            case OBJECTIVESTATE_HORDE:
-                m_TowerState = ZM_TOWERSTATE_H;
-                if(((OutdoorPvPZM*)m_PvP)->m_HordeTowersControlled<ZM_NUM_BEACONS)
-                    ((OutdoorPvPZM*)m_PvP)->m_HordeTowersControlled++;
-                sWorld.SendZoneText(ZM_GRAVEYARD_ZONE,objmgr.GetTrinityStringForDBCLocale(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;
-            }
-
-            UpdateTowerState();
-        }
-
-        if(m_ShiftPhase != m_OldPhase)
-        {
-            // send this too, sometimes the slider disappears, dunno why :(
-            SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_disp, 1);
-            // send these updates to only the ones in this objective
-            uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
-            SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_pos, phase);
-            SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_n, m_NeutralValue);
-        }
-        return m_OldState != m_State;
     }
-    return false;
+    // if changing from controlling horde to alliance
+    else if ( m_OldState == OBJECTIVESTATE_HORDE )
+    {
+        if(((OutdoorPvPZM*)m_PvP)->m_HordeTowersControlled)
+            ((OutdoorPvPZM*)m_PvP)->m_HordeTowersControlled--;
+        sWorld.SendZoneText(ZM_GRAVEYARD_ZONE,objmgr.GetTrinityStringForDBCLocale(ZMBeaconLooseH[m_TowerType]));
+    }
+
+    switch(m_State)
+    {
+        case OBJECTIVESTATE_ALLIANCE:
+            m_TowerState = ZM_TOWERSTATE_A;
+            if(((OutdoorPvPZM*)m_PvP)->m_AllianceTowersControlled<ZM_NUM_BEACONS)
+                ((OutdoorPvPZM*)m_PvP)->m_AllianceTowersControlled++;
+            sWorld.SendZoneText(ZM_GRAVEYARD_ZONE,objmgr.GetTrinityStringForDBCLocale(ZMBeaconCaptureA[m_TowerType]));
+            break;
+        case OBJECTIVESTATE_HORDE:
+            m_TowerState = ZM_TOWERSTATE_H;
+            if(((OutdoorPvPZM*)m_PvP)->m_HordeTowersControlled<ZM_NUM_BEACONS)
+                ((OutdoorPvPZM*)m_PvP)->m_HordeTowersControlled++;
+            sWorld.SendZoneText(ZM_GRAVEYARD_ZONE,objmgr.GetTrinityStringForDBCLocale(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;
+    }
+
+    UpdateTowerState();
+}
+
+void OPvPCapturePointZM_Beacon::SendChangePhase()
+{
+    // send this too, sometimes the slider disappears, dunno why :(
+    SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_disp, 1);
+    // send these updates to only the ones in this objective
+    uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
+    SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_pos, phase);
+    SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_n, m_NeutralValue);
 }
 
 bool OutdoorPvPZM::Update(uint32 diff)

src/game/OutdoorPvPZM.h

@@ -153,7 +153,8 @@ class OPvPCapturePointZM_Beacon : public OPvPCapturePoint
 friend class OutdoorPvPZM;
 public:
     OPvPCapturePointZM_Beacon(OutdoorPvP * pvp, ZM_BeaconType type);
-    bool Update(uint32 diff);
+    void ChangeState();
+    void SendChangePhase();
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);
@@ -176,6 +177,7 @@ friend class OutdoorPvPZM;
 public:
     OPvPCapturePointZM_GraveYard(OutdoorPvP * pvp);
     bool Update(uint32 diff);
+    void ChangeState() {}
     void FillInitialWorldStates(WorldPacket & data);
     void UpdateTowerState();
     int32 HandleOpenGo(Player *plr, uint64 guid);

src/game/Wintergrasp.cpp

@@ -54,10 +54,46 @@ void LoadTeamPair(TeamPairMap &pairMap, const TeamPair *pair)
 
 typedef std::list<const AreaPOIEntry *> AreaPOIList;
 
+SiegeWorkshop::SiegeWorkshop(OPvPWintergrasp *opvp, BuildingState *state)
+: OPvPCapturePoint(opvp), m_buildingState(state), m_wintergrasp(opvp)
+, m_vehNum(0)
+{
+}
+
+void SiegeWorkshop::ChangeState()
+{
+    Creature *creature = ObjectAccessor::GetObjectInWorld(m_Creatures[0], (Creature*)NULL);
+    if(!creature)
+        return;
+
+    uint32 entry = 0;
+    if(m_State == OBJECTIVESTATE_ALLIANCE)
+    {
+        m_buildingState->team = TEAM_ALLIANCE;
+        entry = 30499;
+    }
+    else if(m_State == OBJECTIVESTATE_HORDE)
+    {
+        m_buildingState->team = TEAM_HORDE;
+        entry = 30400;
+    }
+    else
+        return;
+
+    m_wintergrasp->BroadcastStateChange(m_buildingState);
+
+    if(entry != creature->GetEntry())
+    {
+        creature->SetOriginalEntry(entry);
+        creature->Respawn(true);
+    }
+    else if(!creature->isAlive())
+        creature->Respawn(true);
+}
+
 bool OPvPWintergrasp::SetupOutdoorPvP()
 {
     m_defender = TeamId(rand()%2);
-    //m_defender = TEAM_ALLIANCE;
 
     // Load buildings
     AreaPOIList areaPOIs;
@@ -76,10 +112,13 @@ bool OPvPWintergrasp::SetupOutdoorPvP()
     }
     minX -= 20; minY -= 20; maxX += 20; maxY += 20;
 
-    QueryResult *result = WorldDatabase.PQuery("SELECT `guid`,`position_x`,`position_y` FROM `gameobject`,`gameobject_template` WHERE `gameobject`.`map`=571"
+    QueryResult *result = WorldDatabase.PQuery("SELECT `guid` FROM `gameobject`,`gameobject_template`"
+        " WHERE `gameobject`.`map`=571"
         " AND `gameobject`.`position_x`>%f AND `gameobject`.`position_y`>%f"
         " AND `gameobject`.`position_x`<%f AND `gameobject`.`position_y`<%f"
-        " AND `gameobject_template`.`type`=33 AND `gameobject`.`id`=`gameobject_template`.`entry`", minX, minY, maxX, maxY);
+        " AND `gameobject_template`.`type`=33"
+        " AND `gameobject`.`id`=`gameobject_template`.`entry`",
+        minX, minY, maxX, maxY);
     if(!result)
         return false;
 
@@ -88,9 +127,11 @@ bool OPvPWintergrasp::SetupOutdoorPvP()
         Field *fields = result->Fetch();
         
         uint32 guid = fields[0].GetUInt32();
-        float x = fields[1].GetFloat();
+        GameObjectData const * goData = objmgr.GetGOData(guid);
-        float y = fields[2].GetFloat();
+        if(!goData) // this should not happen
+            continue;
 
+        float x = goData->posX, y = goData->posY;
         float minDist = 100;
         AreaPOIList::iterator poi = areaPOIs.end();
         for(AreaPOIList::iterator itr = areaPOIs.begin(); itr != areaPOIs.end(); ++itr)
@@ -106,12 +147,86 @@ bool OPvPWintergrasp::SetupOutdoorPvP()
             }
         }
 
-        if(poi != areaPOIs.end())
+        if(poi == areaPOIs.end())
+            continue;
+
+        // add building to the list
+        TeamId teamId = x > POS_X_CENTER ? m_defender : OTHER_TEAM(m_defender);
+        m_buildingStates[guid] = new BuildingState((*poi)->worldState, teamId, m_defender != TEAM_ALLIANCE);
+        areaPOIs.erase(poi);
+
+        //disable for now
+        continue;
+
+        // add capture point
+        uint32 capturePointEntry = 0;
+
+        //192028 192029
+        //192030 192031
+        //192032 192033
+
+        //190475 190487 not sure
+        //192626 192627
+        //194959 194960
+
+        switch(goData->id)
         {
-            m_buildingStates[guid] = new BuildingState((*poi)->worldState
+            case 192028: capturePointEntry = 190475; break;
-                , x > POS_X_CENTER ? m_defender : OTHER_TEAM(m_defender)
+            case 192029: capturePointEntry = 190487; break;
-                , m_defender != TEAM_ALLIANCE);
+            case 192030: capturePointEntry = 190475; break;
-            areaPOIs.erase(poi);
+            case 192031: capturePointEntry = 190487; break;
+            case 192032: capturePointEntry = 190475; break;
+            case 192033: capturePointEntry = 190487; break;
+        }
+        if(capturePointEntry)
+        {
+            uint32 engGuid = 0;
+
+            QueryResult *result = WorldDatabase.PQuery("SELECT `guid` FROM `creature`"
+                " WHERE `creature`.`map`=571"
+                " AND `creature`.`id` IN (30400, 30499);");
+
+            if(!result)
+            {
+                sLog.outError("Cannot find siege workshop master in creature!"); 
+                continue;
+            }
+
+            float minDist = 100;
+            do
+            {
+                Field *fields = result->Fetch();
+                uint32 guid = fields[0].GetUInt32();
+                const CreatureData *creData = objmgr.GetCreatureData(guid);
+                if(!creData)
+                    continue;
+
+                float dist = (abs(creData->posX - x) + abs(creData->posY - y));
+                if(minDist > dist)
+                {
+                    minDist = dist;
+                    engGuid = guid;
+                }
+            }while(result->NextRow());
+            delete result;
+
+            if(!engGuid)
+            {
+                sLog.outError("Cannot find nearby siege workshop master!");
+                continue;
+            }
+
+            SiegeWorkshop *workshop = new SiegeWorkshop(this, m_buildingStates[guid]);
+            if(!workshop->AddCapturePoint(capturePointEntry, goData->id, goData->posX, goData->posY, goData->posZ))
+            {
+                delete workshop;
+                sLog.outError("Cannot add capture point!");
+                continue;
+            }
+            workshop->AddGO(0, guid, goData->id);
+            workshop->AddCre(0, engGuid);
+            m_capturePoints.push_back(workshop);
+            workshop->ChangeState();
         }
     }while(result->NextRow());
     delete result;
@@ -122,7 +237,7 @@ bool OPvPWintergrasp::SetupOutdoorPvP()
     //gameeventmgr.StartInternalEvent(GameEventWintergraspDefender[m_defender]);
 
     //Titan Relic eventid = 19982
-    objmgr.AddGameObject(192829, 571, 5440, 2840.8, 420.43, 0);
+    objmgr.AddGOData(192829, 571, 5440, 2840.8, 420.43, 0);
 
     LoadTeamPair(m_goDisplayPair, GODisplayPair);
     LoadTeamPair(m_creEntryPair, CreatureEntryPair);
@@ -150,9 +265,7 @@ void OPvPWintergrasp::ProcessEvent(GameObject *obj, uint32 eventId)
                 itr->second->damageState = DAMAGE_DAMAGED;
             else
                 itr->second->damageState = DAMAGE_DESTROYED;
-            for(uint32 team = 0; team < 2; ++team)
+            BroadcastStateChange(itr->second);
-                for(PlayerSet::iterator p_itr = m_players[team].begin(); p_itr != m_players[team].end(); ++p_itr)
-                    itr->second->SendUpdate(*p_itr);
         }
     }
 }
@@ -291,6 +404,13 @@ void OPvPWintergrasp::SendInitWorldStatesTo(Player *player)
         BroadcastPacket(data);
 }
 
+void OPvPWintergrasp::BroadcastStateChange(BuildingState *state)
+{
+    for(uint32 team = 0; team < 2; ++team)
+        for(PlayerSet::iterator p_itr = m_players[team].begin(); p_itr != m_players[team].end(); ++p_itr)
+            state->SendUpdate(*p_itr);
+}
+
 bool OPvPWintergrasp::UpdateCreatureInfo(Creature *creature)
 {
     TeamPairMap::const_iterator itr = m_creEntryPair.find(creature->GetCreatureData()->id);
@@ -302,6 +422,8 @@ bool OPvPWintergrasp::UpdateCreatureInfo(Creature *creature)
             creature->SetOriginalEntry(entry);
             creature->Respawn(true);
         }
+        else if(!creature->isAlive())
+            creature->Respawn(true);
     }
 
     return false;

src/game/Wintergrasp.h

@@ -40,6 +40,8 @@ const uint32 WintergraspFaction[2] = {1732, 1735};
 
 #define SPELL_SHUTDOWN_VEHICLE  21247
 
+#define MAX_VEHICLE_PER_WORKSHOP    4
+
 const uint32 WG_KEEP_CM = 0; //Need data
 const uint32 WG_RULERS_BUFF   = 52108;
 //some cosmetics :D
@@ -125,9 +127,9 @@ class OPvPWintergrasp : public OutdoorPvP
         void HandlePlayerLeaveZone(Player *plr, uint32 zone);
         void HandleKill(Player *killer, Unit *victim);
 
-        void SendInitWorldStatesTo(Player *player = NULL);
-
         bool Update(uint32 diff);
+
+        void BroadcastStateChange(BuildingState *state);
     protected:
         TeamId m_defender;
         int32 m_tenacityStack;
@@ -156,6 +158,19 @@ class OPvPWintergrasp : public OutdoorPvP
         void GiveReward();
 
         void VehicleCastSpell(TeamId team, int32 spellId);
+
+        void SendInitWorldStatesTo(Player *player = NULL);
+};
+
+class SiegeWorkshop : public OPvPCapturePoint
+{
+    public:
+        explicit SiegeWorkshop(OPvPWintergrasp *opvp, BuildingState *state);
+        void ChangeState();
+    protected:
+        BuildingState *m_buildingState;
+        OPvPWintergrasp *m_wintergrasp;
+        uint32 m_vehNum;
 };
 
 #endif