*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;
+}
 
+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);
-
-    m_Creatures[type] = MAKE_NEW_GUID(guid, entry, HIGHGUID_UNIT);
-    m_CreatureTypes[m_Creatures[type]] = type;
         return true;
+    }
+
+    return false;
 }
 
 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,11 +35,9 @@ 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 )
@@ -110,9 +108,10 @@ bool OPvPCapturePointEP_EWT::Update(uint32 diff)
         if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
             SendObjectiveComplete(EP_EWT_CM, 0);
     }
+}
 
-        if(m_ShiftPhase != m_OldPhase)
+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
@@ -120,10 +119,6 @@ bool OPvPCapturePointEP_EWT::Update(uint32 diff)
     SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
     // send this too, sometimes it resets :S
     SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
-        }
-        return m_OldState != m_State;
-    }
-    return false;
 }
 
 void OPvPCapturePointEP_EWT::FillInitialWorldStates(WorldPacket &data)
@@ -194,11 +189,9 @@ 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 )
@@ -270,9 +263,10 @@ bool OPvPCapturePointEP_NPT::Update(uint32 diff)
         if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
             SendObjectiveComplete(EP_NPT_CM, 0);
     }
+}
 
-        if(m_ShiftPhase != m_OldPhase)
+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
@@ -280,10 +274,6 @@ bool OPvPCapturePointEP_NPT::Update(uint32 diff)
     SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
     // send this too, sometimes it resets :S
     SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
-        }
-        return m_OldState != m_State;
-    }
-    return false;
 }
 
 void OPvPCapturePointEP_NPT::FillInitialWorldStates(WorldPacket &data)
@@ -348,11 +338,9 @@ 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 )
@@ -422,9 +410,10 @@ bool OPvPCapturePointEP_CGT::Update(uint32 diff)
         if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
             SendObjectiveComplete(EP_CGT_CM, 0);
     }
+}
 
-        if(m_ShiftPhase != m_OldPhase)
+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
@@ -432,10 +421,6 @@ bool OPvPCapturePointEP_CGT::Update(uint32 diff)
     SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
     // send this too, sometimes it resets :S
     SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
-        }
-        return m_OldState != m_State;
-    }
-    return false;
 }
 
 void OPvPCapturePointEP_CGT::FillInitialWorldStates(WorldPacket &data)
@@ -497,11 +482,9 @@ 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 )
@@ -573,9 +556,10 @@ bool OPvPCapturePointEP_PWT::Update(uint32 diff)
         if(m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
             SendObjectiveComplete(EP_PWT_CM, 0);
     }
+}
 
-        if(m_ShiftPhase != m_OldPhase)
+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
@@ -583,10 +567,6 @@ bool OPvPCapturePointEP_PWT::Update(uint32 diff)
     SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
     // send this too, sometimes it resets :S
     SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_NeutralValue);
-        }
-        return m_OldState != m_State;
-    }
-    return false;
 }
 
 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,13 +163,8 @@ void OutdoorPvPHP::FillInitialWorldStates(WorldPacket &data)
     }
 }
 
-bool OPvPCapturePointHP::Update(uint32 diff)
+void OPvPCapturePointHP::ChangeState()
 {
-    // if status changed:
-    if(OPvPCapturePoint::Update(diff))
-    {
-        if(m_OldState != m_State)
-        {
     uint32 field = 0;
     switch(m_OldState)
     {
@@ -269,20 +264,16 @@ bool OPvPCapturePointHP::Update(uint32 diff)
     // complete quest objective
     if(m_State == OBJECTIVESTATE_ALLIANCE || m_State == OBJECTIVESTATE_HORDE)
         SendObjectiveComplete(HP_CREDITMARKER[m_TowerType], 0);
-        }
+}
 
-        if(m_ShiftPhase != m_OldPhase)
+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);
-        }
-        return m_OldState != m_State;
-    }
-    return false;
 }
 
 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,8 +565,13 @@ bool OPvPCapturePointNA::Update(uint32 diff)
             m_RespawnTimer = NA_RESPAWN_TIME;
         } else m_RespawnTimer -= diff;
 
-        if(m_OldState != m_State)
+        return OPvPCapturePoint::Update(diff);
-        {
+    }
+    return false;
+}
+
+void OPvPCapturePointNA::ChangeState()
+{
     uint32 artkit = 21;
     switch(m_State)
     {
@@ -607,20 +612,16 @@ bool OPvPCapturePointNA::Update(uint32 diff)
     }
 
     UpdateHalaaWorldState();
-        }
+}
 
-        if(m_ShiftPhase != m_OldPhase)
+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);
-        }
-        return m_OldState != m_State;
-    }
-    return false;
 }
 
 void OPvPCapturePointNA::UpdateHalaaWorldState()

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,10 +239,11 @@ 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 )
     {
@@ -293,10 +294,10 @@ bool OPvPCapturePointTF::Update(uint32 diff)
     }
 
     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 these updates to only the ones in this objective
@@ -304,9 +305,5 @@ bool OPvPCapturePointTF::Update(uint32 diff)
     SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, phase);
     // 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,12 +71,8 @@ void OPvPCapturePointZM_Beacon::HandlePlayerLeave(Player *plr)
     OPvPCapturePoint::HandlePlayerLeave(plr);
 }
 
-bool OPvPCapturePointZM_Beacon::Update(uint32 diff)
+void OPvPCapturePointZM_Beacon::ChangeState()
 {
-    if(OPvPCapturePoint::Update(diff))
-    {
-        if(m_OldState != m_State)
-        {
     // if changing from controlling alliance to horde
     if( m_OldState == OBJECTIVESTATE_ALLIANCE )
     {
@@ -116,20 +112,16 @@ bool OPvPCapturePointZM_Beacon::Update(uint32 diff)
     }
 
     UpdateTowerState();
-        }
+}
 
-        if(m_ShiftPhase != m_OldPhase)
+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);
-        }
-        return m_OldState != m_State;
-    }
-    return false;
 }
 
 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;
-            m_buildingStates[guid] = new BuildingState((*poi)->worldState
+
-                , x > POS_X_CENTER ? m_defender : OTHER_TEAM(m_defender)
+        // add building to the list
-                , m_defender != TEAM_ALLIANCE);
+        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)
+        {
+            case 192028: capturePointEntry = 190475; break;
+            case 192029: capturePointEntry = 190487; break;
+            case 192030: capturePointEntry = 190475; break;
+            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