*Update OutdoorPvP functions. No longer need creature triggers for capture points.

--HG--
branch : trunk

27 files changed, 434 insertions, 727 deletions

diff --git a/src/bindings/scripts/scripts/zone/wintergrasp/wintergrasp.cpp b/src/bindings/scripts/scripts/zone/wintergrasp/wintergrasp.cpp
index 374e511ad63..57cd2c92d77 100644
--- a/src/bindings/scripts/scripts/zone/wintergrasp/wintergrasp.cpp
+++ b/src/bindings/scripts/scripts/zone/wintergrasp/wintergrasp.cpp
@@ -42,7 +42,7 @@ bool GossipSelect_npc_demolisher_engineerer(Player* player, Creature* me, uint32
     {
         case 0: player->CastSpell(player, 56663, false); break;
         case 1: player->CastSpell(player, 56575, false); break;
-        case 2: player->CastSpell(player, TEAM_ID(player->GetTeam()) ? 61408 : 56661, false); break;
+        case 2: player->CastSpell(player, player->GetTeamId() ? 61408 : 56661, false); break;
     }
 
     return true;
diff --git a/src/game/CreatureAIRegistry.cpp b/src/game/CreatureAIRegistry.cpp
index 162ebd9b47c..d4b30508563 100644
--- a/src/game/CreatureAIRegistry.cpp
+++ b/src/game/CreatureAIRegistry.cpp
@@ -24,7 +24,6 @@
 #include "GuardAI.h"
 #include "PetAI.h"
 #include "TotemAI.h"
-#include "OutdoorPvPObjectiveAI.h"
 #include "CreatureEventAI.h"
 #include "RandomMovementGenerator.h"
 #include "MovementGeneratorImpl.h"
@@ -45,7 +44,6 @@ namespace AIRegistry
         (new CreatureAIFactory<GuardAI>("GuardAI"))->RegisterSelf();
         (new CreatureAIFactory<PetAI>("PetAI"))->RegisterSelf();
         (new CreatureAIFactory<TotemAI>("TotemAI"))->RegisterSelf();
-        (new CreatureAIFactory<OutdoorPvPObjectiveAI>("OutdoorPvPObjectiveAI"))->RegisterSelf();
         (new CreatureAIFactory<SpellAI>("SpellAI"))->RegisterSelf();
         (new CreatureAIFactory<CreatureEventAI>("EventAI"))->RegisterSelf();
 
diff --git a/src/game/GameObject.cpp b/src/game/GameObject.cpp
index 4729185d5ea..bb1103e2262 100644
--- a/src/game/GameObject.cpp
+++ b/src/game/GameObject.cpp
@@ -40,7 +40,7 @@
 #include "OutdoorPvPMgr.h"
 #include "BattleGroundAV.h"
 
-GameObject::GameObject() : WorldObject()
+GameObject::GameObject() : WorldObject(), m_goValue(new GameObjectValue)
 {
     m_objectType |= TYPEMASK_GAMEOBJECT;
     m_objectTypeId = TYPEID_GAMEOBJECT;
@@ -96,6 +96,14 @@ void GameObject::RemoveFromWorld()
         if(Map *map = FindMap())
             if(map->IsDungeon() && ((InstanceMap*)map)->GetInstanceData())
                 ((InstanceMap*)map)->GetInstanceData()->OnObjectCreate(this, false);
+
+        switch(m_goInfo->type)
+        {
+            case GAMEOBJECT_TYPE_CAPTURE_POINT:
+                sOutdoorPvPMgr.OnGameObjectCreate(this, false);
+                break;
+        }
+
         // Possible crash at access to deleted GO in Unit::m_gameobj
         if(uint64 owner_guid = GetOwnerGUID())
         {
@@ -165,11 +173,18 @@ bool GameObject::Create(uint32 guidlow, uint32 name_id, Map *map, uint32 phaseMa
 
     SetByteValue(GAMEOBJECT_BYTES_1, 2, ArtKit);
 
-    // Spell charges for GAMEOBJECT_TYPE_SPELLCASTER (22)
-    if (goinfo->type == GAMEOBJECT_TYPE_SPELLCASTER)
-        m_charges = goinfo->spellcaster.charges;
-    else if(goinfo->type == GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING)
-        m_health = goinfo->destructibleBuilding.damagedHealth;
+    switch(goinfo->type)
+    {
+        case GAMEOBJECT_TYPE_SPELLCASTER:
+            m_charges = goinfo->spellcaster.charges;
+            break;
+        case GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING:
+            m_goValue->destructibleBuilding.health = goinfo->destructibleBuilding.damagedHealth;
+            break;
+        case GAMEOBJECT_TYPE_CAPTURE_POINT:
+            sOutdoorPvPMgr.OnGameObjectCreate(this, true);
+            break;
+    }
 
     //Notify the map's instance data.
     //Only works if you create the object in it, not if it is moves to that map.
@@ -1426,23 +1441,23 @@ bool GameObject::IsInRange(float x, float y, float z, float radius) const
 
 void GameObject::TakenDamage(uint32 damage)
 {
-    if(!m_health)
+    if(!m_goValue->destructibleBuilding.health)
         return;
 
-    if(m_health > damage)
+    if(m_goValue->destructibleBuilding.health > damage)
     {
-        m_health -= damage;
+        m_goValue->destructibleBuilding.health -= damage;
         return;
     }
 
-    m_health = 0;
+    m_goValue->destructibleBuilding.health = 0;
 
     if(HasFlag(GAMEOBJECT_FLAGS, GO_FLAG_DAMAGED)) // from damaged to destroyed
     {
         RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_DAMAGED);
         SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_DESTROYED);
         SetUInt32Value(GAMEOBJECT_DISPLAYID, m_goInfo->destructibleBuilding.destroyedDisplayId);
-        m_health = 0;
+        m_goValue->destructibleBuilding.health = 0;
     }
     else // from undamaged to damaged
     {
@@ -1450,12 +1465,12 @@ void GameObject::TakenDamage(uint32 damage)
         SetUInt32Value(GAMEOBJECT_DISPLAYID, m_goInfo->destructibleBuilding.damagedDisplayId);
         if(m_goInfo->destructibleBuilding.destroyedDisplayId)
         {
-            m_health = m_goInfo->destructibleBuilding.destroyedHealth;
-            if(!m_health)
-                m_health = 1;
+            m_goValue->destructibleBuilding.health = m_goInfo->destructibleBuilding.destroyedHealth;
+            if(!m_goValue->destructibleBuilding.health)
+                m_goValue->destructibleBuilding.health = 1;
         }
         else
-            m_health = 0;
+            m_goValue->destructibleBuilding.health = 0;
     }
 }
 
@@ -1463,7 +1478,7 @@ void GameObject::Rebuild()
 {
     RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_DAMAGED + GO_FLAG_DESTROYED);
     SetUInt32Value(GAMEOBJECT_DISPLAYID, m_goInfo->displayId);
-    m_health = m_goInfo->destructibleBuilding.damagedHealth;
+    m_goValue->destructibleBuilding.health = m_goInfo->destructibleBuilding.damagedHealth;
 }
 
 // overwrite WorldObject function for proper name localization
diff --git a/src/game/GameObject.h b/src/game/GameObject.h
index befe9c23a8b..0b0245cecd7 100644
--- a/src/game/GameObject.h
+++ b/src/game/GameObject.h
@@ -375,6 +375,22 @@ struct GameObjectInfo
     uint32 ScriptId;
 };
 
+class OPvPCapturePoint;
+
+union GameObjectValue
+{
+    //29 GAMEOBJECT_TYPE_CAPTURE_POINT
+    struct
+    {
+        OPvPCapturePoint *OPvPObj;
+    }capturePoint;
+    //33 GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING
+    struct
+    {
+        uint32 health;
+    }destructibleBuilding;
+};
+
 // GCC have alternative #pragma pack() syntax and old gcc version not support pack(pop), also any gcc version not support it at some platform
 #if defined( __GNUC__ )
 #pragma pack()
@@ -632,7 +648,6 @@ class TRINITY_DLL_SPEC GameObject : public WorldObject
         LootState   m_lootState;
         bool        m_spawnedByDefault;
         time_t      m_cooldownTime;                         // used as internal reaction delay time store (not state change reaction).
-        uint32      m_health;
                                                             // For traps this: spell casting cooldown, for doors/buttons: reset time.
         std::list<uint32> m_SkillupList;
 
@@ -641,6 +656,7 @@ class TRINITY_DLL_SPEC GameObject : public WorldObject
 
         uint32 m_DBTableGuid;                               ///< For new or temporary gameobjects is 0 for saved it is lowguid
         GameObjectInfo const* m_goInfo;
+        GameObjectValue * const m_goValue;
     private:
         void SwitchDoorOrButton(bool activate, bool alternative = false);
 
diff --git a/src/game/GridNotifiers.h b/src/game/GridNotifiers.h
index 87b0a11a226..7eb5c326142 100644
--- a/src/game/GridNotifiers.h
+++ b/src/game/GridNotifiers.h
@@ -460,6 +460,21 @@ namespace Trinity
         template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
     };
 
+    template<class Check>
+        struct TRINITY_DLL_DECL PlayerListSearcher
+    {
+        uint32 i_phaseMask;
+        std::list<Player*> &i_objects;
+        Check& i_check;
+
+        PlayerListSearcher(WorldObject const* searcher, std::list<Player*> &objects, Check & check)
+            : i_phaseMask(searcher->GetPhaseMask()), i_objects(objects),i_check(check) {}
+
+        void Visit(PlayerMapType &m);
+
+        template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
+    };
+
     template<class Do>
     struct TRINITY_DLL_DECL PlayerWorker
     {
diff --git a/src/game/GridNotifiersImpl.h b/src/game/GridNotifiersImpl.h
index d4413b9f777..6502c2ea7c8 100644
--- a/src/game/GridNotifiersImpl.h
+++ b/src/game/GridNotifiersImpl.h
@@ -554,6 +554,15 @@ void Trinity::CreatureListSearcher<Check>::Visit(CreatureMapType &m)
 }
 
 template<class Check>
+void Trinity::PlayerListSearcher<Check>::Visit(PlayerMapType &m)
+{
+    for(PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
+        if(itr->getSource()->InSamePhase(i_phaseMask))
+            if( i_check(itr->getSource()))
+                i_objects.push_back(itr->getSource());
+}
+
+template<class Check>
 void Trinity::PlayerSearcher<Check>::Visit(PlayerMapType &m)
 {
     // already found
diff --git a/src/game/MiscHandler.cpp b/src/game/MiscHandler.cpp
index f7c53e536c4..9ccae7798bd 100644
--- a/src/game/MiscHandler.cpp
+++ b/src/game/MiscHandler.cpp
@@ -458,10 +458,8 @@ void WorldSession::HandleTogglePvP( WorldPacket & recv_data )
             GetPlayer()->pvpInfo.endTimer = time(NULL);     // start toggle-off
     }
 
-    if(OutdoorPvP * pvp = _player->GetOutdoorPvP())
-    {
-        pvp->HandlePlayerActivityChanged(_player);
-    }
+    //if(OutdoorPvP * pvp = _player->GetOutdoorPvP())
+    //    pvp->HandlePlayerActivityChanged(_player);
 }
 
 void WorldSession::HandleZoneUpdateOpcode( WorldPacket & recv_data )
diff --git a/src/game/OutdoorPvP.cpp b/src/game/OutdoorPvP.cpp
index e75641307b8..fe604dc8ac9 100644
--- a/src/game/OutdoorPvP.cpp
+++ b/src/game/OutdoorPvP.cpp
@@ -23,45 +23,32 @@
 #include "ObjectMgr.h"
 #include "Map.h"
 #include "MapManager.h"
-#include "OutdoorPvPObjectiveAI.h"
 #include "Group.h"
 #include "WorldPacket.h"
+#include "GridNotifiers.h"
+#include "GridNotifiersImpl.h"
+#include "GridNotifiers.h"
+#include "GridNotifiersImpl.h"
+#include "CellImpl.h"
 
-OutdoorPvPObjective::OutdoorPvPObjective(OutdoorPvP * pvp)
+OPvPCapturePoint::OPvPCapturePoint(OutdoorPvP * pvp)
 : m_PvP(pvp), m_ShiftPhase(0), m_ShiftMaxPhase(0), m_OldPhase(0),
-m_State(0), m_OldState(0), m_CapturePoint(0), m_NeutralValue(0),
-m_ShiftMaxCaptureSpeed(0), m_CapturePointCreature(0)
+m_State(0), m_OldState(0), m_CapturePointGUID(0), m_NeutralValue(0),
+m_ShiftMaxCaptureSpeed(0), m_capturePoint(NULL)
 {
 }
 
-bool OutdoorPvPObjective::HandlePlayerEnter(Player * plr)
+bool OPvPCapturePoint::HandlePlayerEnter(Player * plr)
 {
-    uint32 team = (plr->GetTeam() == HORDE) ? 1 : 0;
-    // only called if really entered, so no use in the return value anymore
-    // player distance and activity state was checked already in the AI
-    std::pair<std::set<uint64>::iterator,bool> newinsert = m_ActivePlayerGuids[team].insert(plr->GetGUID());
-    if(newinsert.second)
-        sLog.outDebug("player %u entered an outdoorpvpobjective", plr->GetGUIDLow());
-    return true;
+    return m_activePlayers[plr->GetTeamId()].insert(plr).second;
 }
 
-void OutdoorPvPObjective::HandlePlayerLeave(Player * plr)
+void OPvPCapturePoint::HandlePlayerLeave(Player * plr)
 {
-    uint32 team = (plr->GetTeam() == HORDE) ? 1 : 0;
-    // only decrease the count if the player is in the active list
-    if(m_ActivePlayerGuids[team].erase(plr->GetGUID()) > 0)
-        sLog.outDebug("player %u left an outdoorpvpobjective", plr->GetGUIDLow());
+    m_activePlayers[plr->GetTeamId()].erase(plr);
 }
 
-void OutdoorPvPObjective::HandlePlayerActivityChanged(Player * plr)
-{
-    if(m_CapturePointCreature)
-        if(Creature * c = HashMapHolder<Creature>::Find(m_CapturePointCreature))
-            if(c->IsAIEnabled)
-                c->AI()->MoveInLineOfSight(plr);
-}
-
-bool OutdoorPvPObjective::AddObject(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3)
+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)
 {
     GameObjectInfo const* goinfo = objmgr.GetGameObjectInfo(entry);
     if (!goinfo)
@@ -110,7 +97,7 @@ bool OutdoorPvPObjective::AddObject(uint32 type, uint32 entry, uint32 map, float
     return true;
 }
 
-bool OutdoorPvPObjective::AddCreature(uint32 type, uint32 entry, uint32 teamval, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay)
+bool OPvPCapturePoint::AddCreature(uint32 type, uint32 entry, uint32 teamval, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay)
 {
     CreatureInfo const *cinfo = objmgr.GetCreatureTemplate(entry);
     if(!cinfo)
@@ -181,51 +168,26 @@ bool OutdoorPvPObjective::AddCreature(uint32 type, uint32 entry, uint32 teamval,
     return true;
 }
 
-bool OutdoorPvPObjective::AddCapturePoint(uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3)
+bool OPvPCapturePoint::AddCapturePoint(uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3)
 {
-    sLog.outDebug("creating capture point %u and capture point creature",entry);
+    sLog.outDebug("Creating capture point %u", entry);
 
     // check info existence
     GameObjectInfo const* goinfo = objmgr.GetGameObjectInfo(entry);
-    if (!goinfo)
-        return false;
-
-    CreatureInfo const *cinfo = objmgr.GetCreatureTemplate(OPVP_TRIGGER_CREATURE_ENTRY);
-    if(!cinfo)
+    if(!goinfo || goinfo->type != GAMEOBJECT_TYPE_CAPTURE_POINT)
+    {
+        sLog.outError("OutdoorPvP: GO %u is not capture point!", goinfo->id);
         return false;
-
-    // create capture point creature
-    uint32 displayId = objmgr.ChooseDisplayId(0, cinfo, NULL);
-
-    uint32 creature_guid = objmgr.GenerateLowGuid(HIGHGUID_UNIT);
-
-    CreatureData& cdata = objmgr.NewOrExistCreatureData(creature_guid);
-
-    cdata.id = OPVP_TRIGGER_CREATURE_ENTRY;
-    cdata.mapid = map;
-    cdata.displayid = displayId;
-    cdata.equipmentId = cinfo->equipmentId;
-    cdata.posX = x;
-    cdata.posY = y;
-    cdata.posZ = z;
-    cdata.orientation = o;
-    cdata.spawntimesecs = 1;
-    cdata.spawndist = 0;
-    cdata.currentwaypoint = 0;
-    cdata.curhealth = cinfo->maxhealth;
-    cdata.curmana = cinfo->maxmana;
-    cdata.is_dead = false;
-    cdata.movementType = cinfo->MovementType;
-    cdata.spawnMask = 1;
-    cdata.phaseMask = PHASEMASK_NORMAL;
-
-    objmgr.AddCreatureToGrid(creature_guid, &cdata);
-    m_CapturePointCreature = MAKE_NEW_GUID(creature_guid, OPVP_TRIGGER_CREATURE_ENTRY, HIGHGUID_UNIT);
+    }
 
     // create capture point go
-    uint32 guid = objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT);
+    m_CapturePointGUID = objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT);
+    // get the needed values from goinfo
+    m_ShiftMaxPhase = goinfo->capturePoint.maxTime;
+    m_ShiftMaxCaptureSpeed = m_ShiftMaxPhase / float(goinfo->capturePoint.minTime);
+    m_NeutralValue = goinfo->capturePoint.neutralPercent;
 
-    GameObjectData& data = objmgr.NewGOData(guid);
+    GameObjectData& data = objmgr.NewGOData(m_CapturePointGUID);
 
     data.id             = entry;
     data.mapid          = map;
@@ -243,60 +205,12 @@ bool OutdoorPvPObjective::AddCapturePoint(uint32 entry, uint32 map, float x, flo
     data.go_state       = GO_STATE_READY;
     data.phaseMask      = PHASEMASK_NORMAL;
 
-    objmgr.AddGameobjectToGrid(guid, &data);
-
-    m_CapturePoint = MAKE_NEW_GUID(guid, entry, HIGHGUID_GAMEOBJECT);
-
-    if(goinfo->type != GAMEOBJECT_TYPE_CAPTURE_POINT)
-        sLog.outError("OutdoorPvP: GO %u is not capture point!", goinfo->id);
-
-    // get the needed values from goinfo
-    m_ShiftMaxPhase = goinfo->capturePoint.maxTime;
-    m_ShiftMaxCaptureSpeed = m_ShiftMaxPhase / float(goinfo->capturePoint.minTime);
-    m_NeutralValue = goinfo->capturePoint.neutralPercent;
-
-    // add to map if map is already loaded
-    Map * pMap = MapManager::Instance().FindMap(map);
-    if(!pMap)
-        return true;
-    // add GO...
-    GameObject * go = new GameObject;
-    if(!go->Create(guid,entry, pMap,PHASEMASK_NORMAL,x,y,z,o,rotation0,rotation1,rotation2,rotation3,100,GO_STATE_READY))
-    {
-        sLog.outError("Gameobject template %u not found in database.", entry);
-        delete go;
-    }
-    else
-    {
-        go->SetRespawnTime(0);
-        objmgr.SaveGORespawnTime(go->GetDBTableGUIDLow(), 0, 0);
-        pMap->Add(go);
-    }
-    // add creature...
-    Creature* pCreature = new Creature;
-    if (!pCreature->Create(creature_guid, pMap, PHASEMASK_NORMAL, OPVP_TRIGGER_CREATURE_ENTRY, 0))
-    {
-        sLog.outError("Can't create creature entry: %u",entry);
-        delete pCreature;
-        return false;
-    }
-    else
-    {
-        pCreature->Relocate(x, y, z, o);
-
-        if(!pCreature->IsPositionValid())
-        {
-            sLog.outError("ERROR: Creature (guidlow %d, entry %d) not added to opvp. Suggested coordinates isn't valid (X: %f Y: %f)",pCreature->GetGUIDLow(),pCreature->GetEntry(),pCreature->GetPositionX(),pCreature->GetPositionY());
-            delete pCreature;
-            return false;
-        }
+    objmgr.AddGameobjectToGrid(m_CapturePointGUID, &data);
 
-        pMap->Add(pCreature);
-    }
     return true;
 }
 
-bool OutdoorPvPObjective::DelCreature(uint32 type)
+bool OPvPCapturePoint::DelCreature(uint32 type)
 {
     if(!m_Creatures[type])
     {
@@ -331,7 +245,7 @@ bool OutdoorPvPObjective::DelCreature(uint32 type)
     return true;
 }
 
-bool OutdoorPvPObjective::DelObject(uint32 type)
+bool OPvPCapturePoint::DelObject(uint32 type)
 {
     if(!m_Objects[type])
         return false;
@@ -351,46 +265,21 @@ bool OutdoorPvPObjective::DelObject(uint32 type)
     return true;
 }
 
-bool OutdoorPvPObjective::DelCapturePoint()
+bool OPvPCapturePoint::DelCapturePoint()
 {
-    if(m_CapturePoint)
-    {
-        GameObject *obj = HashMapHolder<GameObject>::Find(m_CapturePoint);
-        if(obj)
-        {
-            uint32 guid = obj->GetDBTableGUIDLow();
-            obj->SetRespawnTime(0);                                 // not save respawn time
-            obj->Delete();
-            objmgr.DeleteGOData(guid);
-        }
-        m_CapturePoint = 0;
-    }
-    if(m_CapturePointCreature)
+    objmgr.DeleteGOData(m_CapturePointGUID);
+    m_CapturePointGUID = 0;
+
+    if(m_capturePoint)
     {
-        Creature *cr = HashMapHolder<Creature>::Find(m_CapturePointCreature);
-        if(cr)
-        {
-            uint32 guid = cr->GetDBTableGUIDLow();
-            // Don't save respawn time
-            cr->SetRespawnTime(0);
-            cr->RemoveCorpse();
-            cr->CleanupsBeforeDelete();
-            // explicit removal from map
-            // beats me why this is needed, but with the recent removal "cleanup" some creatures stay in the map if "properly" deleted
-            // so this is a big fat workaround, if AddObjectToRemoveList and DoDelayedMovesAndRemoves worked correctly, this wouldn't be needed
-            //if(Map * map = MapManager::Instance().FindMap(cr->GetMapId()))
-            //    map->Remove(cr,false);
-            // delete respawn time for this creature
-            WorldDatabase.PExecute("DELETE FROM creature_respawn WHERE guid = '%u'", guid);
-            cr->AddObjectToRemoveList();
-            objmgr.DeleteCreatureData(guid);
-        }
-        m_CapturePointCreature = 0;
+        m_capturePoint->SetRespawnTime(0);                                 // not save respawn time
+        m_capturePoint->Delete();
     }
+
     return true;
 }
 
-void OutdoorPvPObjective::DeleteSpawns()
+void OPvPCapturePoint::DeleteSpawns()
 {
     for(std::map<uint32,uint64>::iterator i = m_Objects.begin(); i != m_Objects.end(); ++i)
         DelObject(i->first);
@@ -401,7 +290,7 @@ void OutdoorPvPObjective::DeleteSpawns()
 
 void OutdoorPvP::DeleteSpawns()
 {
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
         (*itr)->DeleteSpawns();
 }
 
@@ -416,145 +305,133 @@ OutdoorPvP::~OutdoorPvP()
 
 void OutdoorPvP::HandlePlayerEnterZone(Player * plr, uint32 zone)
 {
-    m_players[TEAM_ID(plr->GetTeam())].insert(plr);
+    m_players[plr->GetTeamId()].insert(plr);
 }
 
 void OutdoorPvP::HandlePlayerLeaveZone(Player * plr, uint32 zone)
 {
     // inform the objectives of the leaving
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
         (*itr)->HandlePlayerLeave(plr);
     // remove the world state information from the player (we can't keep everyone up to date, so leave out those who are not in the concerning zones)
     if(!plr->GetSession()->PlayerLogout())
         SendRemoveWorldStates(plr);
-    m_players[TEAM_ID(plr->GetTeam())].erase(plr);
+    m_players[plr->GetTeamId()].erase(plr);
     sLog.outDebug("Player %s left an outdoorpvp zone");
 }
 
 bool OutdoorPvP::Update(uint32 diff)
 {
     bool objective_changed = false;
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
         objective_changed |= (*itr)->Update(diff);
     return objective_changed;
 }
 
-void OutdoorPvPObjective::UpdateActivePlayerProximityCheck()
+bool OPvPCapturePoint::Update(uint32 diff)
 {
-    if(GameObject *cp = HashMapHolder<GameObject>::Find(m_CapturePoint))
+    if(!m_capturePoint)
+        return false;
+
+    float radius = m_capturePoint->GetGOInfo()->capturePoint.radius;
+
+    for(uint32 team = 0; team < 2; ++team)
     {
-        for(int team = 0; team < 2; ++team)
+        for(PlayerSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end();)
         {
-            std::set<uint64>::iterator itr, next;
-            for(itr = m_ActivePlayerGuids[team].begin(); itr != m_ActivePlayerGuids[team].end(); itr = next)
-            {
-                next = itr;
-                ++next;
-                // if the player is online
-                if(Player * pl = objmgr.GetPlayer(*itr))
-                {
-                    if(!cp->IsWithinDistInMap(pl,cp->GetGOInfo()->raw.data[0]))
-                        HandleCapturePointEvent(pl, cp->GetGOInfo()->raw.data[9]); //i_objective->HandlePlayerLeave((Player*)u);
-                }
-                else
-                {
-                    sLog.outError("Player ("I64FMTD") offline, bit still in outdoor pvp, this should never happen.",(*itr));
-                }
-            }
+            Player *player = *itr;
+            ++itr;
+            if(!m_capturePoint->IsWithinDistInMap(player, radius) || !player->IsOutdoorPvPActive())
+                HandlePlayerLeave(player);
         }
     }
-}
 
-bool OutdoorPvPObjective::Update(uint32 diff)
-{
-    UpdateActivePlayerProximityCheck();
-
-    uint32 Challenger = 0;
+    std::list<Player*> players;
+    Trinity::AnyPlayerInObjectRangeCheck checker(m_capturePoint, radius);
+    Trinity::PlayerListSearcher<Trinity::AnyPlayerInObjectRangeCheck> searcher(m_capturePoint, players, checker);
+    m_capturePoint->VisitNearbyWorldObject(radius, searcher);
 
-        // get the difference of numbers
-        float fact_diff = ((float)m_ActivePlayerGuids[0].size() - (float)m_ActivePlayerGuids[1].size());
-
-        if(fact_diff<0)
-        {
-            if(fact_diff < - m_ShiftMaxCaptureSpeed)
-                fact_diff = - m_ShiftMaxCaptureSpeed;
-            Challenger = HORDE;
-            // horde is in majority, but it's already horde-controlled -> no change
-            if(m_State == OBJECTIVESTATE_HORDE && m_ShiftPhase == - m_ShiftMaxPhase)
-                return false;
-        }
-        else if(fact_diff>0)
+    for(std::list<Player*>::iterator itr = players.begin(); itr != players.end(); ++itr)
+    {
+        if((*itr)->IsOutdoorPvPActive())
         {
-            if(fact_diff > m_ShiftMaxCaptureSpeed)
-                fact_diff = m_ShiftMaxCaptureSpeed;
-            Challenger = ALLIANCE;
-            // ally is in majority, but it's already ally-controlled -> no change
-            if(m_State == OBJECTIVESTATE_ALLIANCE && m_ShiftPhase == m_ShiftMaxPhase)
-                return false;
+            if(m_activePlayers[(*itr)->GetTeamId()].insert(*itr).second)
+                HandlePlayerEnter(*itr);
         }
-        else /*if(fact_diff==0)*/ // no change
+    }
+
+    // get the difference of numbers
+    float fact_diff = (float)m_activePlayers[0].size() - (float)m_activePlayers[1].size();
+    if(!fact_diff)
+        return false;
+
+    uint32 Challenger = 0;
+
+    if(fact_diff < 0)
+    {
+        // horde is in majority, but it's already horde-controlled -> no change
+        if(m_State == OBJECTIVESTATE_HORDE && m_ShiftPhase <= -m_ShiftMaxPhase)
             return false;
 
-        m_OldPhase = m_ShiftPhase;
+        if(fact_diff < - m_ShiftMaxCaptureSpeed)
+            fact_diff = - m_ShiftMaxCaptureSpeed;
 
-        m_OldState = m_State;
+        Challenger = HORDE;
+    }
+    else
+    {
+        // ally is in majority, but it's already ally-controlled -> no change
+        if(m_State == OBJECTIVESTATE_ALLIANCE && m_ShiftPhase >= m_ShiftMaxPhase)
+            return false;
 
-        m_ShiftPhase += fact_diff;
+        if(fact_diff > m_ShiftMaxCaptureSpeed)
+            fact_diff = m_ShiftMaxCaptureSpeed;
 
-        // check limits, these are over the grey part
-        if(m_ShiftPhase <= - m_ShiftMaxPhase * (float)(m_NeutralValue) / 100.0f)
-        {
-            if(m_ShiftPhase <= - m_ShiftMaxPhase)
-                m_ShiftPhase = - m_ShiftMaxPhase;
-            m_State = OBJECTIVESTATE_HORDE;
-            return true;
-        }
-        else if(m_ShiftPhase >= m_ShiftMaxPhase * (float)(m_NeutralValue) / 100.0f)
-        {
-            if(m_ShiftPhase >= m_ShiftMaxPhase)
-                m_ShiftPhase = m_ShiftMaxPhase;
-            m_State = OBJECTIVESTATE_ALLIANCE;
-            return true;
-        }
+        Challenger = ALLIANCE;
+    }
 
-        if(m_OldPhase*m_ShiftPhase <=0)
-        {
-            // gone through neutral
-            // if challenger is ally, then n->a challenge
-            if(Challenger == ALLIANCE)
-                m_State = OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE;
-            // if challenger is horde, then n->h challenge
-            else if(Challenger == HORDE)
-                m_State = OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE;
-        }
-        else
-        {
-            // old phase and current are on the same side, so one team challenges the other
-            if(Challenger == ALLIANCE && (m_OldState == OBJECTIVESTATE_HORDE || m_OldState == OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE))
-                m_State = OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE;
-            else if(Challenger == HORDE && (m_OldState == OBJECTIVESTATE_ALLIANCE || m_OldState == OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE))
-                m_State = OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE;
-        }
+    m_OldPhase = m_ShiftPhase;
 
-        return true;
-}
+    m_OldState = m_State;
 
-bool OutdoorPvPObjective::HandleCaptureCreaturePlayerMoveInLos(Player * p, Creature * c)
-{
-    // check if guid matches
-    if(c->GetGUID() != m_CapturePointCreature)
-        return false;
+    m_ShiftPhase += fact_diff;
 
-    // check if capture point go is spawned
-    GameObject * cp = HashMapHolder<GameObject>::Find(m_CapturePoint);
-    if(!cp)
-        return false;
+    // check limits, these are over the grey part
+    if(m_ShiftPhase <= -m_ShiftMaxPhase * (float)(m_NeutralValue) / 100.0f)
+    {
+        if(m_ShiftPhase <= -m_ShiftMaxPhase)
+            m_ShiftPhase = -m_ShiftMaxPhase;
+        m_State = OBJECTIVESTATE_HORDE;
+        return true;
+    }
+    else if(m_ShiftPhase >= m_ShiftMaxPhase * (float)(m_NeutralValue) / 100.0f)
+    {
+        if(m_ShiftPhase >= m_ShiftMaxPhase)
+            m_ShiftPhase = m_ShiftMaxPhase;
+        m_State = OBJECTIVESTATE_ALLIANCE;
+        return true;
+    }
 
-    // check range and activity
-    if(cp->IsWithinDistInMap(p,cp->GetGOInfo()->capturePoint.radius) && p->IsOutdoorPvPActive())
-        return HandleCapturePointEvent(p, cp->GetGOInfo()->capturePoint.progressEventID1); //i_objective->HandlePlayerEnter((Player*)u);
+    if(m_OldPhase*m_ShiftPhase <=0)
+    {
+        // gone through neutral
+        // if challenger is ally, then n->a challenge
+        if(Challenger == ALLIANCE)
+            m_State = OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE;
+        // if challenger is horde, then n->h challenge
+        else if(Challenger == HORDE)
+            m_State = OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE;
+    }
     else
-        return HandleCapturePointEvent(p, cp->GetGOInfo()->capturePoint.progressEventID2); //i_objective->HandlePlayerLeave((Player*)u);
+    {
+        // old phase and current are on the same side, so one team challenges the other
+        if(Challenger == ALLIANCE && (m_OldState == OBJECTIVESTATE_HORDE || m_OldState == OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE))
+            m_State = OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE;
+        else if(Challenger == HORDE && (m_OldState == OBJECTIVESTATE_ALLIANCE || m_OldState == OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE))
+            m_State = OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE;
+    }
+
+    return true;
 }
 
 void OutdoorPvP::SendUpdateWorldState(uint32 field, uint32 value)
@@ -568,23 +445,19 @@ void OutdoorPvP::SendUpdateWorldState(uint32 field, uint32 value)
     }
 }
 
-void OutdoorPvPObjective::SendUpdateWorldState(uint32 field, uint32 value)
+void OPvPCapturePoint::SendUpdateWorldState(uint32 field, uint32 value)
 {
     for(uint32 team = 0; team < 2; ++team)
     {
         // send to all players present in the area
-        for(std::set<uint64>::iterator itr = m_ActivePlayerGuids[team].begin(); itr != m_ActivePlayerGuids[team].end(); ++itr)
+        for(PlayerSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr)
         {
-            Player * plr = objmgr.GetPlayer(*itr);
-            if(plr)
-            {
-                plr->SendUpdateWorldState(field,value);
-            }
+            (*itr)->SendUpdateWorldState(field,value);
         }
     }
 }
 
-void OutdoorPvPObjective::SendObjectiveComplete(uint32 id,uint64 guid)
+void OPvPCapturePoint::SendObjectiveComplete(uint32 id,uint64 guid)
 {
     uint32 team;
     switch(m_State)
@@ -597,24 +470,11 @@ void OutdoorPvPObjective::SendObjectiveComplete(uint32 id,uint64 guid)
         break;
     default:
         return;
-        break;
     }
 
     // send to all players present in the area
-    for(std::set<uint64>::iterator itr = m_ActivePlayerGuids[team].begin(); itr != m_ActivePlayerGuids[team].end(); ++itr)
-    {
-        Player * plr = objmgr.GetPlayer(*itr);
-        if(plr)
-        {
-            plr->KilledMonster(id,guid);
-        }
-    }
-}
-
-void OutdoorPvP::HandlePlayerActivityChanged(Player * plr)
-{
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
-        (*itr)->HandlePlayerActivityChanged(plr);
+    for(PlayerSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr)
+        (*itr)->KilledMonster(id, guid);
 }
 
 void OutdoorPvP::HandleKill(Player *killer, Unit * killed)
@@ -650,26 +510,23 @@ void OutdoorPvP::HandleKill(Player *killer, Unit * killed)
     }
 }
 
-bool OutdoorPvP::IsInsideObjective(Player *plr)
+bool OutdoorPvP::IsInsideObjective(Player *plr) const
 {
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
-    {
+    for(OPvPCapturePointMap::const_iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
         if((*itr)->IsInsideObjective(plr))
             return true;
-    }
+
     return false;
 }
 
-bool OutdoorPvPObjective::IsInsideObjective(Player *plr)
+bool OPvPCapturePoint::IsInsideObjective(Player *plr) const
 {
-    uint32 team = (plr->GetTeam() == HORDE) ? 1 : 0;
-    std::set<uint64>::iterator itr = m_ActivePlayerGuids[team].find(plr->GetGUID());
-    return itr != m_ActivePlayerGuids[team].end();
+    return m_activePlayers[plr->GetTeamId()].find(plr) != m_activePlayers[plr->GetTeamId()].end();
 }
 
 bool OutdoorPvP::HandleCustomSpell(Player *plr, uint32 spellId, GameObject * go)
 {
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
     {
         if((*itr)->HandleCustomSpell(plr,spellId,go))
             return true;
@@ -677,7 +534,7 @@ bool OutdoorPvP::HandleCustomSpell(Player *plr, uint32 spellId, GameObject * go)
     return false;
 }
 
-bool OutdoorPvPObjective::HandleCustomSpell(Player *plr, uint32 spellId, GameObject * go)
+bool OPvPCapturePoint::HandleCustomSpell(Player *plr, uint32 spellId, GameObject * go)
 {
     if(!plr->IsOutdoorPvPActive())
         return false;
@@ -686,7 +543,7 @@ bool OutdoorPvPObjective::HandleCustomSpell(Player *plr, uint32 spellId, GameObj
 
 bool OutdoorPvP::HandleOpenGo(Player *plr, uint64 guid)
 {
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
     {
         if((*itr)->HandleOpenGo(plr,guid) >= 0)
             return true;
@@ -694,19 +551,9 @@ bool OutdoorPvP::HandleOpenGo(Player *plr, uint64 guid)
     return false;
 }
 
-bool OutdoorPvP::HandleCaptureCreaturePlayerMoveInLos(Player * p, Creature * c)
-{
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
-    {
-        if((*itr)->HandleCaptureCreaturePlayerMoveInLos(p, c))
-            return true;
-    }
-    return false;
-}
-
 bool OutdoorPvP::HandleGossipOption(Player * plr, uint64 guid, uint32 id)
 {
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
     {
         if((*itr)->HandleGossipOption(plr, guid, id))
             return true;
@@ -716,7 +563,7 @@ bool OutdoorPvP::HandleGossipOption(Player * plr, uint64 guid, uint32 id)
 
 bool OutdoorPvP::CanTalkTo(Player * plr, Creature * c, GossipOption &gso)
 {
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
     {
         if((*itr)->CanTalkTo(plr, c, gso))
             return true;
@@ -726,7 +573,7 @@ bool OutdoorPvP::CanTalkTo(Player * plr, Creature * c, GossipOption &gso)
 
 bool OutdoorPvP::HandleDropFlag(Player * plr, uint32 id)
 {
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
     {
         if((*itr)->HandleDropFlag(plr, id))
             return true;
@@ -734,22 +581,22 @@ bool OutdoorPvP::HandleDropFlag(Player * plr, uint32 id)
     return false;
 }
 
-bool OutdoorPvPObjective::HandleGossipOption(Player * plr, uint64 guid, uint32 id)
+bool OPvPCapturePoint::HandleGossipOption(Player * plr, uint64 guid, uint32 id)
 {
     return false;
 }
 
-bool OutdoorPvPObjective::CanTalkTo(Player * plr, Creature * c, GossipOption &gso)
+bool OPvPCapturePoint::CanTalkTo(Player * plr, Creature * c, GossipOption &gso)
 {
     return false;
 }
 
-bool OutdoorPvPObjective::HandleDropFlag(Player * plr, uint32 id)
+bool OPvPCapturePoint::HandleDropFlag(Player * plr, uint32 id)
 {
     return false;
 }
 
-int32 OutdoorPvPObjective::HandleOpenGo(Player *plr, uint64 guid)
+int32 OPvPCapturePoint::HandleOpenGo(Player *plr, uint64 guid)
 {
     std::map<uint64,uint32>::iterator itr = m_ObjectTypes.find(guid);
     if(itr != m_ObjectTypes.end())
@@ -771,7 +618,7 @@ void OutdoorPvP::RegisterZone(uint32 zoneId)
 
 bool OutdoorPvP::HasPlayer(Player *plr) const
 {
-    return m_players[TEAM_ID(plr->GetTeam())].find(plr) != m_players[TEAM_ID(plr->GetTeam())].end();
+    return m_players[plr->GetTeamId()].find(plr) != m_players[plr->GetTeamId()].end();
 }
 
 void OutdoorPvP::TeamCastSpell(TeamId team, int32 spellId)
diff --git a/src/game/OutdoorPvP.h b/src/game/OutdoorPvP.h
index e82873c951c..ad526701795 100644
--- a/src/game/OutdoorPvP.h
+++ b/src/game/OutdoorPvP.h
@@ -24,14 +24,7 @@
 #include <map>
 #include <set>
 
-#define OPVP_TRIGGER_CREATURE_ENTRY 12999
-
-enum TeamId
-{
-    TEAM_ALLIANCE = 0,
-    TEAM_HORDE,
-    TEAM_NEUTRAL,
-};
+class GameObject;
 
 enum OutdoorPvPTypes
 {
@@ -77,11 +70,13 @@ class Creature;
 class Unit;
 struct GossipOption;
 
+typedef std::set<Player*> PlayerSet;
+
 class OutdoorPvP;
-class OutdoorPvPObjective
+class OPvPCapturePoint
 {
 public:
-    OutdoorPvPObjective(OutdoorPvP * pvp);
+    OPvPCapturePoint(OutdoorPvP * pvp);
 
     virtual void FillInitialWorldStates(WorldPacket & data) {}
 
@@ -93,10 +88,10 @@ public:
     // used when player is activated/inactivated in the area
     virtual bool HandlePlayerEnter(Player * plr);
     virtual void HandlePlayerLeave(Player * plr);
-    virtual void HandlePlayerActivityChanged(Player * plr);
+    //virtual void HandlePlayerActivityChanged(Player * plr);
 
     // checks if player is in range of a capture credit marker
-    virtual bool IsInsideObjective(Player * plr);
+    bool IsInsideObjective(Player * plr) const;
 
     virtual bool HandleCustomSpell(Player *plr, uint32 spellId, GameObject * go);
     virtual int32 HandleOpenGo(Player *plr, uint64 guid);
@@ -104,10 +99,6 @@ 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 bool HandleCapturePointEvent(Player * plr, uint32 eventId) { return false; }
-
-    virtual bool HandleCaptureCreaturePlayerMoveInLos(Player * p, Creature * c);
-
     virtual bool HandleGossipOption(Player *plr, uint64 guid, uint32 gossipid);
 
     virtual bool CanTalkTo(Player * plr, Creature * c, GossipOption &gso);
@@ -115,6 +106,10 @@ public:
     virtual bool HandleDropFlag(Player * plr, uint32 spellId);
 
     virtual void DeleteSpawns();
+
+    uint32 m_CapturePointGUID;
+    GameObject *m_capturePoint;
+
 protected:
 
     virtual bool AddCapturePoint(uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3);
@@ -125,11 +120,9 @@ protected:
     virtual bool DelObject(uint32 type);
     virtual bool DelCapturePoint();
 
-    virtual void UpdateActivePlayerProximityCheck();
-
 protected:
     // active players in the area of the objective, 0 - alliance, 1 - horde
-    std::set<uint64> m_ActivePlayerGuids[2];
+    PlayerSet m_activePlayers[2];
     // total shift needed to capture the objective
     float m_ShiftMaxPhase;
     // maximum speed of capture
@@ -153,8 +146,6 @@ protected:
     std::map<uint32,uint64> m_Creatures;
     std::map<uint64,uint32> m_ObjectTypes;
     std::map<uint64,uint32> m_CreatureTypes;
-    uint64 m_CapturePoint;
-    uint64 m_CapturePointCreature;
 };
 
 // base class for specific outdoor pvp handlers
@@ -169,18 +160,15 @@ public:
     // deletes all gos/creatures spawned by the pvp
     void DeleteSpawns();
 
-    typedef std::vector<OutdoorPvPObjective *> OutdoorPvPObjectiveSet;
+    typedef std::vector<OPvPCapturePoint*> OPvPCapturePointMap;
 
     virtual void FillInitialWorldStates(WorldPacket & data) {}
-    virtual void HandlePlayerActivityChanged(Player * plr);
     // called when a player triggers an areatrigger
     virtual bool HandleAreaTrigger(Player * plr, uint32 trigger);
     // called on custom spell
     virtual bool HandleCustomSpell(Player *plr, uint32 spellId, GameObject * go);
     // called on go use
     virtual bool HandleOpenGo(Player *plr, uint64 guid);
-    // called from moveinlineofsight
-    virtual bool HandleCaptureCreaturePlayerMoveInLos(Player * p, Creature * c);
 
     // setup stuff
     virtual bool SetupOutdoorPvP() {return true;}
@@ -196,7 +184,7 @@ public:
     virtual void HandleKillImpl(Player * killer, Unit * killed) {}
 
     // checks if player is in range of a capture credit marker
-    virtual bool IsInsideObjective(Player * plr);
+    bool IsInsideObjective(Player * plr) const;
 
     // awards rewards for player kill
     virtual void AwardKillBonus(Player * plr) {}
@@ -212,9 +200,8 @@ public:
     void TeamApplyBuff(TeamId team, uint32 spellId, uint32 spellId2 = 0);
 protected:
     // the map of the objectives belonging to this outdoorpvp
-    OutdoorPvPObjectiveSet m_OutdoorPvPObjectives;
+    OPvPCapturePointMap m_capturePoints;
 
-    typedef std::set<Player*> PlayerSet;
     PlayerSet m_players[2];
     uint32 m_TypeId;
 
diff --git a/src/game/OutdoorPvPEP.cpp b/src/game/OutdoorPvPEP.cpp
index 4d94ef07b62..70054761582 100644
--- a/src/game/OutdoorPvPEP.cpp
+++ b/src/game/OutdoorPvPEP.cpp
@@ -28,16 +28,16 @@
 #include "World.h"
 #include "GossipDef.h"
 
-OutdoorPvPObjectiveEP_EWT::OutdoorPvPObjectiveEP_EWT(OutdoorPvP *pvp)
-: OutdoorPvPObjective(pvp), m_TowerState(EP_TS_N), m_UnitsSummonedSide(0)
+OPvPCapturePointEP_EWT::OPvPCapturePointEP_EWT(OutdoorPvP *pvp)
+: OPvPCapturePoint(pvp), m_TowerState(EP_TS_N), m_UnitsSummonedSide(0)
 {
     AddCapturePoint(EPCapturePoints[EP_EWT].entry,EPCapturePoints[EP_EWT].map,EPCapturePoints[EP_EWT].x,EPCapturePoints[EP_EWT].y,EPCapturePoints[EP_EWT].z,EPCapturePoints[EP_EWT].o,EPCapturePoints[EP_EWT].rot0,EPCapturePoints[EP_EWT].rot1,EPCapturePoints[EP_EWT].rot2,EPCapturePoints[EP_EWT].rot3);
     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 OutdoorPvPObjectiveEP_EWT::Update(uint32 diff)
+bool OPvPCapturePointEP_EWT::Update(uint32 diff)
 {
-    if(OutdoorPvPObjective::Update(diff))
+    if(OPvPCapturePoint::Update(diff))
     {
         if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
         {
@@ -90,7 +90,7 @@ bool OutdoorPvPObjectiveEP_EWT::Update(uint32 diff)
                 break;
             }
 
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
+            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
             GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_EWT_FLAGS]);
             if(flag)
             {
@@ -126,7 +126,7 @@ bool OutdoorPvPObjectiveEP_EWT::Update(uint32 diff)
     return false;
 }
 
-void OutdoorPvPObjectiveEP_EWT::FillInitialWorldStates(WorldPacket &data)
+void OPvPCapturePointEP_EWT::FillInitialWorldStates(WorldPacket &data)
 {
     data << EP_EWT_A << uint32(bool(m_TowerState & EP_TS_A));
     data << EP_EWT_H << uint32(bool(m_TowerState & EP_TS_H));
@@ -137,7 +137,7 @@ void OutdoorPvPObjectiveEP_EWT::FillInitialWorldStates(WorldPacket &data)
     data << EP_EWT_N << uint32(bool(m_TowerState & EP_TS_N));
 }
 
-void OutdoorPvPObjectiveEP_EWT::UpdateTowerState()
+void OPvPCapturePointEP_EWT::UpdateTowerState()
 {
     m_PvP->SendUpdateWorldState(EP_EWT_A , bool(m_TowerState & EP_TS_A));
     m_PvP->SendUpdateWorldState(EP_EWT_H , bool(m_TowerState & EP_TS_H));
@@ -148,9 +148,9 @@ void OutdoorPvPObjectiveEP_EWT::UpdateTowerState()
     m_PvP->SendUpdateWorldState(EP_EWT_N , bool(m_TowerState & EP_TS_N));
 }
 
-bool OutdoorPvPObjectiveEP_EWT::HandlePlayerEnter(Player *plr)
+bool OPvPCapturePointEP_EWT::HandlePlayerEnter(Player *plr)
 {
-    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
+    if(OPvPCapturePoint::HandlePlayerEnter(plr))
     {
         plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
         uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
@@ -161,28 +161,13 @@ bool OutdoorPvPObjectiveEP_EWT::HandlePlayerEnter(Player *plr)
     return false;
 }
 
-void OutdoorPvPObjectiveEP_EWT::HandlePlayerLeave(Player *plr)
+void OPvPCapturePointEP_EWT::HandlePlayerLeave(Player *plr)
 {
     plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
-    OutdoorPvPObjective::HandlePlayerLeave(plr);
+    OPvPCapturePoint::HandlePlayerLeave(plr);
 }
 
-bool OutdoorPvPObjectiveEP_EWT::HandleCapturePointEvent(Player *plr, uint32 eventId)
-{
-    if(eventId == EPTowerPlayerEnterEvents[EP_EWT])
-    {
-        this->HandlePlayerEnter(plr);
-        return true;
-    }
-    else if (eventId == EPTowerPlayerLeaveEvents[EP_EWT])
-    {
-        this->HandlePlayerLeave(plr);
-        return true;
-    }
-    return false;
-}
-
-void OutdoorPvPObjectiveEP_EWT::SummonSupportUnitAtNorthpassTower(uint32 team)
+void OPvPCapturePointEP_EWT::SummonSupportUnitAtNorthpassTower(uint32 team)
 {
     if(m_UnitsSummonedSide != team)
     {
@@ -202,16 +187,16 @@ void OutdoorPvPObjectiveEP_EWT::SummonSupportUnitAtNorthpassTower(uint32 team)
 }
 
 // NPT
-OutdoorPvPObjectiveEP_NPT::OutdoorPvPObjectiveEP_NPT(OutdoorPvP *pvp)
-: OutdoorPvPObjective(pvp), m_TowerState(EP_TS_N), m_SummonedGOSide(0)
+OPvPCapturePointEP_NPT::OPvPCapturePointEP_NPT(OutdoorPvP *pvp)
+: OPvPCapturePoint(pvp), m_TowerState(EP_TS_N), m_SummonedGOSide(0)
 {
     AddCapturePoint(EPCapturePoints[EP_NPT].entry,EPCapturePoints[EP_NPT].map,EPCapturePoints[EP_NPT].x,EPCapturePoints[EP_NPT].y,EPCapturePoints[EP_NPT].z,EPCapturePoints[EP_NPT].o,EPCapturePoints[EP_NPT].rot0,EPCapturePoints[EP_NPT].rot1,EPCapturePoints[EP_NPT].rot2,EPCapturePoints[EP_NPT].rot3);
     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 OutdoorPvPObjectiveEP_NPT::Update(uint32 diff)
+bool OPvPCapturePointEP_NPT::Update(uint32 diff)
 {
-    if(OutdoorPvPObjective::Update(diff))
+    if(OPvPCapturePoint::Update(diff))
     {
         if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
         {
@@ -266,7 +251,7 @@ bool OutdoorPvPObjectiveEP_NPT::Update(uint32 diff)
                 break;
             }
 
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
+            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
             GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_NPT_FLAGS]);
             if(flag)
             {
@@ -301,7 +286,7 @@ bool OutdoorPvPObjectiveEP_NPT::Update(uint32 diff)
     return false;
 }
 
-void OutdoorPvPObjectiveEP_NPT::FillInitialWorldStates(WorldPacket &data)
+void OPvPCapturePointEP_NPT::FillInitialWorldStates(WorldPacket &data)
 {
     data << EP_NPT_A << uint32(bool(m_TowerState & EP_TS_A));
     data << EP_NPT_H << uint32(bool(m_TowerState & EP_TS_H));
@@ -312,7 +297,7 @@ void OutdoorPvPObjectiveEP_NPT::FillInitialWorldStates(WorldPacket &data)
     data << EP_NPT_N << uint32(bool(m_TowerState & EP_TS_N));
 }
 
-void OutdoorPvPObjectiveEP_NPT::UpdateTowerState()
+void OPvPCapturePointEP_NPT::UpdateTowerState()
 {
     m_PvP->SendUpdateWorldState(EP_NPT_A , bool(m_TowerState & EP_TS_A));
     m_PvP->SendUpdateWorldState(EP_NPT_H , bool(m_TowerState & EP_TS_H));
@@ -323,9 +308,9 @@ void OutdoorPvPObjectiveEP_NPT::UpdateTowerState()
     m_PvP->SendUpdateWorldState(EP_NPT_N , bool(m_TowerState & EP_TS_N));
 }
 
-bool OutdoorPvPObjectiveEP_NPT::HandlePlayerEnter(Player *plr)
+bool OPvPCapturePointEP_NPT::HandlePlayerEnter(Player *plr)
 {
-    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
+    if(OPvPCapturePoint::HandlePlayerEnter(plr))
     {
         plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
         uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
@@ -336,28 +321,13 @@ bool OutdoorPvPObjectiveEP_NPT::HandlePlayerEnter(Player *plr)
     return false;
 }
 
-void OutdoorPvPObjectiveEP_NPT::HandlePlayerLeave(Player *plr)
+void OPvPCapturePointEP_NPT::HandlePlayerLeave(Player *plr)
 {
     plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
-    OutdoorPvPObjective::HandlePlayerLeave(plr);
-}
-
-bool OutdoorPvPObjectiveEP_NPT::HandleCapturePointEvent(Player *plr, uint32 eventId)
-{
-    if(eventId == EPTowerPlayerEnterEvents[EP_NPT])
-    {
-        this->HandlePlayerEnter(plr);
-        return true;
-    }
-    else if (eventId == EPTowerPlayerLeaveEvents[EP_NPT])
-    {
-        this->HandlePlayerLeave(plr);
-        return true;
-    }
-    return false;
+    OPvPCapturePoint::HandlePlayerLeave(plr);
 }
 
-void OutdoorPvPObjectiveEP_NPT::SummonGO(uint32 team)
+void OPvPCapturePointEP_NPT::SummonGO(uint32 team)
 {
     if(m_SummonedGOSide != team)
     {
@@ -371,16 +341,16 @@ void OutdoorPvPObjectiveEP_NPT::SummonGO(uint32 team)
 }
 
 // CGT
-OutdoorPvPObjectiveEP_CGT::OutdoorPvPObjectiveEP_CGT(OutdoorPvP *pvp)
-: OutdoorPvPObjective(pvp), m_TowerState(EP_TS_N), m_GraveyardSide(0)
+OPvPCapturePointEP_CGT::OPvPCapturePointEP_CGT(OutdoorPvP *pvp)
+: OPvPCapturePoint(pvp), m_TowerState(EP_TS_N), m_GraveyardSide(0)
 {
     AddCapturePoint(EPCapturePoints[EP_CGT].entry,EPCapturePoints[EP_CGT].map,EPCapturePoints[EP_CGT].x,EPCapturePoints[EP_CGT].y,EPCapturePoints[EP_CGT].z,EPCapturePoints[EP_CGT].o,EPCapturePoints[EP_CGT].rot0,EPCapturePoints[EP_CGT].rot1,EPCapturePoints[EP_CGT].rot2,EPCapturePoints[EP_CGT].rot3);
     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 OutdoorPvPObjectiveEP_CGT::Update(uint32 diff)
+bool OPvPCapturePointEP_CGT::Update(uint32 diff)
 {
-    if(OutdoorPvPObjective::Update(diff))
+    if(OPvPCapturePoint::Update(diff))
     {
         if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
         {
@@ -433,7 +403,7 @@ bool OutdoorPvPObjectiveEP_CGT::Update(uint32 diff)
                 break;
             }
 
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
+            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
             GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_CGT_FLAGS]);
             if(flag)
             {
@@ -468,7 +438,7 @@ bool OutdoorPvPObjectiveEP_CGT::Update(uint32 diff)
     return false;
 }
 
-void OutdoorPvPObjectiveEP_CGT::FillInitialWorldStates(WorldPacket &data)
+void OPvPCapturePointEP_CGT::FillInitialWorldStates(WorldPacket &data)
 {
     data << EP_CGT_A << uint32(bool(m_TowerState & EP_TS_A));
     data << EP_CGT_H << uint32(bool(m_TowerState & EP_TS_H));
@@ -479,7 +449,7 @@ void OutdoorPvPObjectiveEP_CGT::FillInitialWorldStates(WorldPacket &data)
     data << EP_CGT_N << uint32(bool(m_TowerState & EP_TS_N));
 }
 
-void OutdoorPvPObjectiveEP_CGT::UpdateTowerState()
+void OPvPCapturePointEP_CGT::UpdateTowerState()
 {
     m_PvP->SendUpdateWorldState(EP_CGT_A , bool(m_TowerState & EP_TS_A));
     m_PvP->SendUpdateWorldState(EP_CGT_H , bool(m_TowerState & EP_TS_H));
@@ -490,9 +460,9 @@ void OutdoorPvPObjectiveEP_CGT::UpdateTowerState()
     m_PvP->SendUpdateWorldState(EP_CGT_N , bool(m_TowerState & EP_TS_N));
 }
 
-bool OutdoorPvPObjectiveEP_CGT::HandlePlayerEnter(Player *plr)
+bool OPvPCapturePointEP_CGT::HandlePlayerEnter(Player *plr)
 {
-    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
+    if(OPvPCapturePoint::HandlePlayerEnter(plr))
     {
         plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
         uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
@@ -503,28 +473,13 @@ bool OutdoorPvPObjectiveEP_CGT::HandlePlayerEnter(Player *plr)
     return false;
 }
 
-void OutdoorPvPObjectiveEP_CGT::HandlePlayerLeave(Player *plr)
+void OPvPCapturePointEP_CGT::HandlePlayerLeave(Player *plr)
 {
     plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
-    OutdoorPvPObjective::HandlePlayerLeave(plr);
+    OPvPCapturePoint::HandlePlayerLeave(plr);
 }
 
-bool OutdoorPvPObjectiveEP_CGT::HandleCapturePointEvent(Player *plr, uint32 eventId)
-{
-    if(eventId == EPTowerPlayerEnterEvents[EP_CGT])
-    {
-        this->HandlePlayerEnter(plr);
-        return true;
-    }
-    else if (eventId == EPTowerPlayerLeaveEvents[EP_CGT])
-    {
-        this->HandlePlayerLeave(plr);
-        return true;
-    }
-    return false;
-}
-
-void OutdoorPvPObjectiveEP_CGT::LinkGraveYard(uint32 team)
+void OPvPCapturePointEP_CGT::LinkGraveYard(uint32 team)
 {
     if(m_GraveyardSide != team)
     {
@@ -535,16 +490,16 @@ void OutdoorPvPObjectiveEP_CGT::LinkGraveYard(uint32 team)
 }
 
 // PWT
-OutdoorPvPObjectiveEP_PWT::OutdoorPvPObjectiveEP_PWT(OutdoorPvP *pvp)
-: OutdoorPvPObjective(pvp), m_TowerState(EP_TS_N), m_FlightMasterSpawned(0)
+OPvPCapturePointEP_PWT::OPvPCapturePointEP_PWT(OutdoorPvP *pvp)
+: OPvPCapturePoint(pvp), m_TowerState(EP_TS_N), m_FlightMasterSpawned(0)
 {
     AddCapturePoint(EPCapturePoints[EP_PWT].entry,EPCapturePoints[EP_PWT].map,EPCapturePoints[EP_PWT].x,EPCapturePoints[EP_PWT].y,EPCapturePoints[EP_PWT].z,EPCapturePoints[EP_PWT].o,EPCapturePoints[EP_PWT].rot0,EPCapturePoints[EP_PWT].rot1,EPCapturePoints[EP_PWT].rot2,EPCapturePoints[EP_PWT].rot3);
     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 OutdoorPvPObjectiveEP_PWT::Update(uint32 diff)
+bool OPvPCapturePointEP_PWT::Update(uint32 diff)
 {
-    if(OutdoorPvPObjective::Update(diff))
+    if(OPvPCapturePoint::Update(diff))
     {
         if(m_OldState != m_State || fabs(m_ShiftPhase) == m_ShiftMaxPhase)  // state won't change, only phase when maxed out!
         {
@@ -599,7 +554,7 @@ bool OutdoorPvPObjectiveEP_PWT::Update(uint32 diff)
                 break;
             }
 
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
+            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
             GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[EP_PWT_FLAGS]);
             if(flag)
             {
@@ -634,7 +589,7 @@ bool OutdoorPvPObjectiveEP_PWT::Update(uint32 diff)
     return false;
 }
 
-void OutdoorPvPObjectiveEP_PWT::FillInitialWorldStates(WorldPacket &data)
+void OPvPCapturePointEP_PWT::FillInitialWorldStates(WorldPacket &data)
 {
     data << EP_PWT_A << uint32(bool(m_TowerState & EP_TS_A));
     data << EP_PWT_H << uint32(bool(m_TowerState & EP_TS_H));
@@ -645,7 +600,7 @@ void OutdoorPvPObjectiveEP_PWT::FillInitialWorldStates(WorldPacket &data)
     data << EP_PWT_N << uint32(bool(m_TowerState & EP_TS_N));
 }
 
-void OutdoorPvPObjectiveEP_PWT::UpdateTowerState()
+void OPvPCapturePointEP_PWT::UpdateTowerState()
 {
     m_PvP->SendUpdateWorldState(EP_PWT_A , bool(m_TowerState & EP_TS_A));
     m_PvP->SendUpdateWorldState(EP_PWT_H , bool(m_TowerState & EP_TS_H));
@@ -656,9 +611,9 @@ void OutdoorPvPObjectiveEP_PWT::UpdateTowerState()
     m_PvP->SendUpdateWorldState(EP_PWT_N , bool(m_TowerState & EP_TS_N));
 }
 
-bool OutdoorPvPObjectiveEP_PWT::HandlePlayerEnter(Player *plr)
+bool OPvPCapturePointEP_PWT::HandlePlayerEnter(Player *plr)
 {
-    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
+    if(OPvPCapturePoint::HandlePlayerEnter(plr))
     {
         plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
         uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
@@ -669,28 +624,13 @@ bool OutdoorPvPObjectiveEP_PWT::HandlePlayerEnter(Player *plr)
     return false;
 }
 
-void OutdoorPvPObjectiveEP_PWT::HandlePlayerLeave(Player *plr)
+void OPvPCapturePointEP_PWT::HandlePlayerLeave(Player *plr)
 {
     plr->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
-    OutdoorPvPObjective::HandlePlayerLeave(plr);
-}
-
-bool OutdoorPvPObjectiveEP_PWT::HandleCapturePointEvent(Player *plr, uint32 eventId)
-{
-    if(eventId == EPTowerPlayerEnterEvents[EP_PWT])
-    {
-        this->HandlePlayerEnter(plr);
-        return true;
-    }
-    else if (eventId == EPTowerPlayerLeaveEvents[EP_PWT])
-    {
-        this->HandlePlayerLeave(plr);
-        return true;
-    }
-    return false;
+    OPvPCapturePoint::HandlePlayerLeave(plr);
 }
 
-void OutdoorPvPObjectiveEP_PWT::SummonFlightMaster(uint32 team)
+void OPvPCapturePointEP_PWT::SummonFlightMaster(uint32 team)
 {
     if(m_FlightMasterSpawned != team)
     {
@@ -728,7 +668,7 @@ void OutdoorPvPObjectiveEP_PWT::SummonFlightMaster(uint32 team)
     }
 }
 
-bool OutdoorPvPObjectiveEP_PWT::CanTalkTo(Player * p, Creature * c, GossipOption &gso)
+bool OPvPCapturePointEP_PWT::CanTalkTo(Player * p, Creature * c, GossipOption &gso)
 {
     if( p->GetTeam() == m_FlightMasterSpawned &&
         c->GetGUID() == m_Creatures[EP_PWT_FLIGHTMASTER] &&
@@ -737,7 +677,7 @@ bool OutdoorPvPObjectiveEP_PWT::CanTalkTo(Player * p, Creature * c, GossipOption
     return false;
 }
 
-bool OutdoorPvPObjectiveEP_PWT::HandleGossipOption(Player *plr, uint64 guid, uint32 gossipid)
+bool OPvPCapturePointEP_PWT::HandleGossipOption(Player *plr, uint64 guid, uint32 gossipid)
 {
     std::map<uint64,uint32>::iterator itr = m_CreatureTypes.find(guid);
     if(itr != m_CreatureTypes.end())
@@ -791,10 +731,10 @@ bool OutdoorPvPEP::SetupOutdoorPvP()
     for(int i = 0; i < EPBuffZonesNum; ++i)
         RegisterZone(EPBuffZones[i]);
 
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveEP_EWT(this));
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveEP_PWT(this));
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveEP_CGT(this));
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveEP_NPT(this));
+    m_capturePoints.push_back(new OPvPCapturePointEP_EWT(this));
+    m_capturePoints.push_back(new OPvPCapturePointEP_PWT(this));
+    m_capturePoints.push_back(new OPvPCapturePointEP_CGT(this));
+    m_capturePoints.push_back(new OPvPCapturePointEP_NPT(this));
     return true;
 }
 
@@ -882,7 +822,7 @@ void OutdoorPvPEP::FillInitialWorldStates(WorldPacket & data)
     data << EP_UI_TOWER_SLIDER_DISPLAY << uint32(0);
     data << EP_UI_TOWER_SLIDER_POS << uint32(50);
     data << EP_UI_TOWER_SLIDER_N << uint32(100);
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
     {
         (*itr)->FillInitialWorldStates(data);
     }
diff --git a/src/game/OutdoorPvPEP.h b/src/game/OutdoorPvPEP.h
index f6199ac5a3b..abf3da9e945 100644
--- a/src/game/OutdoorPvPEP.h
+++ b/src/game/OutdoorPvPEP.h
@@ -178,18 +178,17 @@ const go_type EP_NPT_LordaeronShrine = {181682,0,3167.72,-4355.91,138.785,1.6929
 
 class OutdoorPvPEP;
 
-class OutdoorPvPObjectiveEP_EWT : public OutdoorPvPObjective
+class OPvPCapturePointEP_EWT : public OPvPCapturePoint
 {
 friend class OutdoorPvPEP;
 public:
-    OutdoorPvPObjectiveEP_EWT(OutdoorPvP * pvp);
+    OPvPCapturePointEP_EWT(OutdoorPvP * pvp);
     bool Update(uint32 diff);
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);
     void HandlePlayerLeave(Player * plr);
 protected:
-    bool HandleCapturePointEvent(Player * plr, uint32 eventId);
     void SummonSupportUnitAtNorthpassTower(uint32 team);
     void UpdateTowerState();
 protected:
@@ -197,18 +196,17 @@ protected:
     uint32 m_UnitsSummonedSide;
 };
 
-class OutdoorPvPObjectiveEP_NPT : public OutdoorPvPObjective
+class OPvPCapturePointEP_NPT : public OPvPCapturePoint
 {
 friend class OutdoorPvPEP;
 public:
-    OutdoorPvPObjectiveEP_NPT(OutdoorPvP * pvp);
+    OPvPCapturePointEP_NPT(OutdoorPvP * pvp);
     bool Update(uint32 diff);
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);
     void HandlePlayerLeave(Player * plr);
 protected:
-    bool HandleCapturePointEvent(Player * plr, uint32 eventId);
     void SummonGO(uint32 team);
     void UpdateTowerState();
 protected:
@@ -216,18 +214,17 @@ protected:
     uint32 m_SummonedGOSide;
 };
 
-class OutdoorPvPObjectiveEP_CGT : public OutdoorPvPObjective
+class OPvPCapturePointEP_CGT : public OPvPCapturePoint
 {
 friend class OutdoorPvPEP;
 public:
-    OutdoorPvPObjectiveEP_CGT(OutdoorPvP * pvp);
+    OPvPCapturePointEP_CGT(OutdoorPvP * pvp);
     bool Update(uint32 diff);
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);
     void HandlePlayerLeave(Player * plr);
 protected:
-    bool HandleCapturePointEvent(Player * plr, uint32 eventId);
     void LinkGraveYard(uint32 team);
     void UpdateTowerState();
 protected:
@@ -235,11 +232,11 @@ protected:
     uint32 m_GraveyardSide;
 };
 
-class OutdoorPvPObjectiveEP_PWT : public OutdoorPvPObjective
+class OPvPCapturePointEP_PWT : public OPvPCapturePoint
 {
 friend class OutdoorPvPEP;
 public:
-    OutdoorPvPObjectiveEP_PWT(OutdoorPvP * pvp);
+    OPvPCapturePointEP_PWT(OutdoorPvP * pvp);
     bool Update(uint32 diff);
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
@@ -248,7 +245,6 @@ public:
     bool HandleGossipOption(Player *plr, uint64 guid, uint32 gossipid);
     bool CanTalkTo(Player * plr, Creature * c, GossipOption &gso);
 protected:
-    bool HandleCapturePointEvent(Player * plr, uint32 eventId);
     void SummonFlightMaster(uint32 team);
     void UpdateTowerState();
 protected:
@@ -258,10 +254,10 @@ protected:
 
 class OutdoorPvPEP : public OutdoorPvP
 {
-friend class OutdoorPvPObjectiveEP_EWT;
-friend class OutdoorPvPObjectiveEP_NPT;
-friend class OutdoorPvPObjectiveEP_PWT;
-friend class OutdoorPvPObjectiveEP_CGT;
+friend class OPvPCapturePointEP_EWT;
+friend class OPvPCapturePointEP_NPT;
+friend class OPvPCapturePointEP_PWT;
+friend class OPvPCapturePointEP_CGT;
 public:
     OutdoorPvPEP();
     bool SetupOutdoorPvP();
diff --git a/src/game/OutdoorPvPHP.cpp b/src/game/OutdoorPvPHP.cpp
index c3855b4f90a..23236c31aa7 100644
--- a/src/game/OutdoorPvPHP.cpp
+++ b/src/game/OutdoorPvPHP.cpp
@@ -33,8 +33,8 @@ const uint32 HP_LANG_CAPTURE_A[HP_TOWER_NUM] = {LANG_OPVP_HP_CAPTURE_BROKENHILL_
 
 const uint32 HP_LANG_CAPTURE_H[HP_TOWER_NUM] = {LANG_OPVP_HP_CAPTURE_BROKENHILL_H,LANG_OPVP_HP_CAPTURE_OVERLOOK_H,LANG_OPVP_HP_CAPTURE_STADIUM_H};
 
-OutdoorPvPObjectiveHP::OutdoorPvPObjectiveHP(OutdoorPvP *pvp,OutdoorPvPHPTowerType type)
-: OutdoorPvPObjective(pvp), m_TowerType(type)
+OPvPCapturePointHP::OPvPCapturePointHP(OutdoorPvP *pvp,OutdoorPvPHPTowerType type)
+: OPvPCapturePoint(pvp), m_TowerType(type)
 {
     AddCapturePoint(HPCapturePoints[type].entry,
         HPCapturePoints[type].map,
@@ -72,11 +72,11 @@ bool OutdoorPvPHP::SetupOutdoorPvP()
     for(int i = 0; i < OutdoorPvPHPBuffZonesNum; ++i)
         RegisterZone(OutdoorPvPHPBuffZones[i]);
 
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveHP(this,HP_TOWER_BROKEN_HILL));
+    m_capturePoints.push_back(new OPvPCapturePointHP(this,HP_TOWER_BROKEN_HILL));
 
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveHP(this,HP_TOWER_OVERLOOK));
+    m_capturePoints.push_back(new OPvPCapturePointHP(this,HP_TOWER_OVERLOOK));
 
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveHP(this,HP_TOWER_STADIUM));
+    m_capturePoints.push_back(new OPvPCapturePointHP(this,HP_TOWER_STADIUM));
 
     return true;
 }
@@ -157,16 +157,16 @@ void OutdoorPvPHP::FillInitialWorldStates(WorldPacket &data)
     data << uint32(HP_UI_TOWER_SLIDER_DISPLAY) << uint32(0);
     data << uint32(HP_UI_TOWER_SLIDER_POS) << uint32(50);
     data << uint32(HP_UI_TOWER_SLIDER_N) << uint32(100);
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
     {
         (*itr)->FillInitialWorldStates(data);
     }
 }
 
-bool OutdoorPvPObjectiveHP::Update(uint32 diff)
+bool OPvPCapturePointHP::Update(uint32 diff)
 {
     // if status changed:
-    if(OutdoorPvPObjective::Update(diff))
+    if(OPvPCapturePoint::Update(diff))
     {
         if(m_OldState != m_State)
         {
@@ -249,7 +249,7 @@ bool OutdoorPvPObjectiveHP::Update(uint32 diff)
                 break;
             }
 
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
+            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
             GameObject* flag2 = HashMapHolder<GameObject>::Find(m_Objects[m_TowerType]);
             if(flag)
             {
@@ -285,7 +285,7 @@ bool OutdoorPvPObjectiveHP::Update(uint32 diff)
     return false;
 }
 
-void OutdoorPvPObjectiveHP::FillInitialWorldStates(WorldPacket &data)
+void OPvPCapturePointHP::FillInitialWorldStates(WorldPacket &data)
 {
     switch(m_State)
     {
@@ -312,9 +312,9 @@ void OutdoorPvPObjectiveHP::FillInitialWorldStates(WorldPacket &data)
     }
 }
 
-bool OutdoorPvPObjectiveHP::HandlePlayerEnter(Player *plr)
+bool OPvPCapturePointHP::HandlePlayerEnter(Player *plr)
 {
-    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
+    if(OPvPCapturePoint::HandlePlayerEnter(plr))
     {
         plr->SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1);
         uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
@@ -325,10 +325,10 @@ bool OutdoorPvPObjectiveHP::HandlePlayerEnter(Player *plr)
     return false;
 }
 
-void OutdoorPvPObjectiveHP::HandlePlayerLeave(Player *plr)
+void OPvPCapturePointHP::HandlePlayerLeave(Player *plr)
 {
     plr->SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 0);
-    OutdoorPvPObjective::HandlePlayerLeave(plr);
+    OPvPCapturePoint::HandlePlayerLeave(plr);
 }
 
 void OutdoorPvPHP::HandleKillImpl(Player *plr, Unit * killed)
@@ -341,19 +341,3 @@ void OutdoorPvPHP::HandleKillImpl(Player *plr, Unit * killed)
     else if(plr->GetTeam() == HORDE && ((Player*)killed)->GetTeam() != HORDE)
         plr->CastSpell(plr,HordePlayerKillReward,true);
 }
-
-bool OutdoorPvPObjectiveHP::HandleCapturePointEvent(Player *plr, uint32 eventId)
-{
-    if(eventId == HP_CapturePointEvent_Enter[m_TowerType])
-    {
-        this->HandlePlayerEnter(plr);
-        return true;
-    }
-    else if(eventId == HP_CapturePointEvent_Leave[m_TowerType])
-    {
-        this->HandlePlayerLeave(plr);
-        return true;
-    }
-    return false;
-}
-
diff --git a/src/game/OutdoorPvPHP.h b/src/game/OutdoorPvPHP.h
index 7d00b0a536d..99b4c97ebf8 100644
--- a/src/game/OutdoorPvPHP.h
+++ b/src/game/OutdoorPvPHP.h
@@ -82,23 +82,22 @@ const go_type HPTowerFlags[HP_TOWER_NUM] = {
     {183515,530,-289.610,3696.83,75.9447,3.12414,0,0,0.999962,0.008727} // 2 stadium
 };
 
-class OutdoorPvPObjectiveHP : public OutdoorPvPObjective
+class OPvPCapturePointHP : public OPvPCapturePoint
 {
 public:
-    OutdoorPvPObjectiveHP(OutdoorPvP * pvp, OutdoorPvPHPTowerType type);
+    OPvPCapturePointHP(OutdoorPvP * pvp, OutdoorPvPHPTowerType type);
     bool Update(uint32 diff);
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
     bool HandlePlayerEnter(Player * plr);
     void HandlePlayerLeave(Player * plr);
-    bool HandleCapturePointEvent(Player * plr, uint32 eventId);
 private:
     OutdoorPvPHPTowerType m_TowerType;
 };
 
 class OutdoorPvPHP : public OutdoorPvP
 {
-friend class OutdoorPvPObjectiveHP;
+friend class OPvPCapturePointHP;
 public:
     OutdoorPvPHP();
     bool SetupOutdoorPvP();
diff --git a/src/game/OutdoorPvPImpl.h b/src/game/OutdoorPvPImpl.h
index 1bbd29435c5..fdb0ea64c9c 100644
--- a/src/game/OutdoorPvPImpl.h
+++ b/src/game/OutdoorPvPImpl.h
@@ -22,7 +22,6 @@
 #include "OutdoorPvP.h"
 #include "Player.h"
 
-#define TEAM_ID(a) (a == ALLIANCE ? TEAM_ALLIANCE : TEAM_HORDE)
 #define OTHER_TEAM(a) (a == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE)
 
 enum ObjectiveStates
diff --git a/src/game/OutdoorPvPMgr.cpp b/src/game/OutdoorPvPMgr.cpp
index ff0d1269447..7d367392764 100644
--- a/src/game/OutdoorPvPMgr.cpp
+++ b/src/game/OutdoorPvPMgr.cpp
@@ -207,21 +207,22 @@ bool OutdoorPvPMgr::HandleCustomSpell(Player *plr, uint32 spellId, GameObject *
     return false;
 }
 
-bool OutdoorPvPMgr::HandleOpenGo(Player *plr, uint64 guid)
+void OutdoorPvPMgr::OnGameObjectCreate(GameObject *go, bool add)
 {
+    if(go->GetGoType() != GAMEOBJECT_TYPE_CAPTURE_POINT)
+        return;
+
     for(OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
-    {
-        if((*itr)->HandleOpenGo(plr,guid))
-            return true;
-    }
-    return false;
+        for(OutdoorPvP::OPvPCapturePointMap::iterator itr2 = (*itr)->m_capturePoints.begin(); itr2 != (*itr)->m_capturePoints.end(); ++itr2)
+            if((*itr2)->m_CapturePointGUID == go->GetDBTableGUIDLow())
+                (*itr2)->m_capturePoint = add ? go : NULL;
 }
 
-bool OutdoorPvPMgr::HandleCaptureCreaturePlayerMoveInLos(Player * plr, Creature * c)
+bool OutdoorPvPMgr::HandleOpenGo(Player *plr, uint64 guid)
 {
     for(OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
     {
-        if((*itr)->HandleCaptureCreaturePlayerMoveInLos(plr,c))
+        if((*itr)->HandleOpenGo(plr,guid))
             return true;
     }
     return false;
@@ -254,4 +255,3 @@ void OutdoorPvPMgr::HandleDropFlag(Player *plr, uint32 spellId)
             return;
     }
 }
-
diff --git a/src/game/OutdoorPvPMgr.h b/src/game/OutdoorPvPMgr.h
index 28b01c586b7..22083ecd5ee 100644
--- a/src/game/OutdoorPvPMgr.h
+++ b/src/game/OutdoorPvPMgr.h
@@ -50,13 +50,13 @@ public:
     bool HandleCustomSpell(Player * plr, uint32 spellId, GameObject* go);
     // handle custom go if registered
     bool HandleOpenGo(Player * plr, uint64 guid);
+    
+    void OnGameObjectCreate(GameObject *go, bool add);
 
     void AddZone(uint32 zoneid, OutdoorPvP * handle);
 
     void Update(uint32 diff);
 
-    bool HandleCaptureCreaturePlayerMoveInLos(Player * plr, Creature * c);
-
     void HandleGossipOption(Player * player, uint64 guid, uint32 gossipid);
 
     bool CanTalkTo(Player * player, Creature * creature, GossipOption & gso);
diff --git a/src/game/OutdoorPvPNA.cpp b/src/game/OutdoorPvPNA.cpp
index ef7e6b97e51..53bf1a3c770 100644
--- a/src/game/OutdoorPvPNA.cpp
+++ b/src/game/OutdoorPvPNA.cpp
@@ -41,7 +41,7 @@ void OutdoorPvPNA::HandleKillImpl(Player *plr, Unit * killed)
     }
 }
 
-uint32 OutdoorPvPObjectiveNA::GetAliveGuardsCount()
+uint32 OPvPCapturePointNA::GetAliveGuardsCount()
 {
     uint32 cnt = 0;
     for(std::map<uint32, uint64>::iterator itr = m_Creatures.begin(); itr != m_Creatures.end(); ++itr)
@@ -83,7 +83,7 @@ uint32 OutdoorPvPObjectiveNA::GetAliveGuardsCount()
     return cnt;
 }
 
-void OutdoorPvPObjectiveNA::SpawnNPCsForTeam(uint32 team)
+void OPvPCapturePointNA::SpawnNPCsForTeam(uint32 team)
 {
     const creature_type * creatures = NULL;
     if(team == ALLIANCE)
@@ -96,13 +96,13 @@ void OutdoorPvPObjectiveNA::SpawnNPCsForTeam(uint32 team)
         AddCreature(i,creatures[i].entry,creatures[i].teamval,creatures[i].map,creatures[i].x,creatures[i].y,creatures[i].z,creatures[i].o,1000000);
 }
 
-void OutdoorPvPObjectiveNA::DeSpawnNPCs()
+void OPvPCapturePointNA::DeSpawnNPCs()
 {
     for(int i = 0; i < NA_CONTROL_NPC_NUM; ++i)
         DelCreature(i);
 }
 
-void OutdoorPvPObjectiveNA::SpawnGOsForTeam(uint32 team)
+void OPvPCapturePointNA::SpawnGOsForTeam(uint32 team)
 {
     const go_type * gos = NULL;
     if(team == ALLIANCE)
@@ -126,7 +126,7 @@ void OutdoorPvPObjectiveNA::SpawnGOsForTeam(uint32 team)
     }
 }
 
-void OutdoorPvPObjectiveNA::DeSpawnGOs()
+void OPvPCapturePointNA::DeSpawnGOs()
 {
     for(int i = 0; i < NA_CONTROL_GO_NUM; ++i)
     {
@@ -134,7 +134,7 @@ void OutdoorPvPObjectiveNA::DeSpawnGOs()
     }
 }
 
-void OutdoorPvPObjectiveNA::FactionTakeOver(uint32 team)
+void OPvPCapturePointNA::FactionTakeOver(uint32 team)
 {
     if(m_ControllingFaction)
         objmgr.RemoveGraveYardLink(NA_HALAA_GRAVEYARD,NA_HALAA_GRAVEYARD_ZONE,m_ControllingFaction,false);
@@ -159,6 +159,7 @@ void OutdoorPvPObjectiveNA::FactionTakeOver(uint32 team)
         m_WyvernStateNorth = WYVERN_NEU_HORDE;
         m_WyvernStateEast = WYVERN_NEU_HORDE;
         m_WyvernStateWest = WYVERN_NEU_HORDE;
+        m_PvP->TeamApplyBuff(TEAM_ALLIANCE, NA_CAPTURE_BUFF);
         m_PvP->SendUpdateWorldState(NA_UI_HORDE_GUARDS_SHOW, 0);
         m_PvP->SendUpdateWorldState(NA_UI_ALLIANCE_GUARDS_SHOW, 1);
         m_PvP->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive);
@@ -170,21 +171,21 @@ void OutdoorPvPObjectiveNA::FactionTakeOver(uint32 team)
         m_WyvernStateNorth = WYVERN_NEU_ALLIANCE;
         m_WyvernStateEast = WYVERN_NEU_ALLIANCE;
         m_WyvernStateWest = WYVERN_NEU_ALLIANCE;
+        m_PvP->TeamApplyBuff(TEAM_HORDE, NA_CAPTURE_BUFF);
         m_PvP->SendUpdateWorldState(NA_UI_HORDE_GUARDS_SHOW, 1);
         m_PvP->SendUpdateWorldState(NA_UI_ALLIANCE_GUARDS_SHOW, 0);
         m_PvP->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive);
         sWorld.SendZoneText(NA_HALAA_GRAVEYARD_ZONE,objmgr.GetTrinityStringForDBCLocale(LANG_OPVP_NA_CAPTURE_H));
     }
-    this->UpdateWyvernRoostWorldState(NA_ROOST_S);
-    this->UpdateWyvernRoostWorldState(NA_ROOST_N);
-    this->UpdateWyvernRoostWorldState(NA_ROOST_W);
-    this->UpdateWyvernRoostWorldState(NA_ROOST_E);
-    m_PvP->TeamApplyBuff(TEAM_ID(team), NA_CAPTURE_BUFF);
+    UpdateWyvernRoostWorldState(NA_ROOST_S);
+    UpdateWyvernRoostWorldState(NA_ROOST_N);
+    UpdateWyvernRoostWorldState(NA_ROOST_W);
+    UpdateWyvernRoostWorldState(NA_ROOST_E);
 }
 
-bool OutdoorPvPObjectiveNA::HandlePlayerEnter(Player *plr)
+bool OPvPCapturePointNA::HandlePlayerEnter(Player *plr)
 {
-    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
+    if(OPvPCapturePoint::HandlePlayerEnter(plr))
     {
         plr->SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 1);
         uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
@@ -195,14 +196,14 @@ bool OutdoorPvPObjectiveNA::HandlePlayerEnter(Player *plr)
     return false;
 }
 
-void OutdoorPvPObjectiveNA::HandlePlayerLeave(Player *plr)
+void OPvPCapturePointNA::HandlePlayerLeave(Player *plr)
 {
     plr->SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 0);
-    OutdoorPvPObjective::HandlePlayerLeave(plr);
+    OPvPCapturePoint::HandlePlayerLeave(plr);
 }
 
-OutdoorPvPObjectiveNA::OutdoorPvPObjectiveNA(OutdoorPvP *pvp) :
-OutdoorPvPObjective(pvp), m_capturable(true), m_GuardsAlive(0), m_ControllingFaction(0),
+OPvPCapturePointNA::OPvPCapturePointNA(OutdoorPvP *pvp) :
+OPvPCapturePoint(pvp), m_capturable(true), m_GuardsAlive(0), m_ControllingFaction(0),
 m_HalaaState(HALAA_N), m_WyvernStateSouth(0), m_WyvernStateNorth(0), m_WyvernStateWest(0),
 m_WyvernStateEast(0), m_RespawnTimer(NA_RESPAWN_TIME), m_GuardCheckTimer(NA_GUARD_CHECK_TIME)
 {
@@ -216,10 +217,10 @@ bool OutdoorPvPNA::SetupOutdoorPvP()
     RegisterZone(NA_BUFF_ZONE);
 
     // halaa
-    m_obj = new OutdoorPvPObjectiveNA(this);
+    m_obj = new OPvPCapturePointNA(this);
     if(!m_obj)
         return false;
-    m_OutdoorPvPObjectives.push_back(m_obj);
+    m_capturePoints.push_back(m_obj);
 
     return true;
 }
@@ -244,7 +245,7 @@ void OutdoorPvPNA::FillInitialWorldStates(WorldPacket &data)
     m_obj->FillInitialWorldStates(data);
 }
 
-void OutdoorPvPObjectiveNA::FillInitialWorldStates(WorldPacket &data)
+void OPvPCapturePointNA::FillInitialWorldStates(WorldPacket &data)
 {
     if(m_ControllingFaction == ALLIANCE)
     {
@@ -333,7 +334,7 @@ bool OutdoorPvPNA::Update(uint32 diff)
     return m_obj->Update(diff);
 }
 
-bool OutdoorPvPObjectiveNA::HandleCustomSpell(Player * plr, uint32 spellId, GameObject * go)
+bool OPvPCapturePointNA::HandleCustomSpell(Player * plr, uint32 spellId, GameObject * go)
 {
     std::vector<uint32> nodes;
     nodes.resize(2);
@@ -408,9 +409,9 @@ bool OutdoorPvPObjectiveNA::HandleCustomSpell(Player * plr, uint32 spellId, Game
     return false;
 }
 
-int32 OutdoorPvPObjectiveNA::HandleOpenGo(Player *plr, uint64 guid)
+int32 OPvPCapturePointNA::HandleOpenGo(Player *plr, uint64 guid)
 {
-    uint32 retval = OutdoorPvPObjective::HandleOpenGo(plr, guid);
+    uint32 retval = OPvPCapturePoint::HandleOpenGo(plr, guid);
     if(retval>=0)
     {
         const go_type * gos = NULL;
@@ -530,13 +531,13 @@ int32 OutdoorPvPObjectiveNA::HandleOpenGo(Player *plr, uint64 guid)
     return -1;
 }
 
-bool OutdoorPvPObjectiveNA::Update(uint32 diff)
+bool OPvPCapturePointNA::Update(uint32 diff)
 {
     // let the controlling faction advance in phase
     bool capturable = false;
-    if(m_ControllingFaction == ALLIANCE && m_ActivePlayerGuids[0].size() > m_ActivePlayerGuids[1].size())
+    if(m_ControllingFaction == ALLIANCE && m_activePlayers[0].size() > m_activePlayers[1].size())
         capturable = true;
-    else if(m_ControllingFaction == HORDE && m_ActivePlayerGuids[0].size() < m_ActivePlayerGuids[1].size())
+    else if(m_ControllingFaction == HORDE && m_activePlayers[0].size() < m_activePlayers[1].size())
         capturable = true;
 
     if(m_GuardCheckTimer < diff)
@@ -553,7 +554,7 @@ bool OutdoorPvPObjectiveNA::Update(uint32 diff)
         }
     } else m_GuardCheckTimer -= diff;
 
-    if((m_capturable || capturable) && OutdoorPvPObjective::Update(diff))
+    if((m_capturable || capturable) && OPvPCapturePoint::Update(diff))
     {
         if(m_RespawnTimer < diff)
         {
@@ -598,7 +599,7 @@ bool OutdoorPvPObjectiveNA::Update(uint32 diff)
                 break;
             }
 
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
+            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
             if(flag)
             {
                 flag->SetGoArtKit(artkit);
@@ -622,7 +623,7 @@ bool OutdoorPvPObjectiveNA::Update(uint32 diff)
     return false;
 }
 
-void OutdoorPvPObjectiveNA::UpdateHalaaWorldState()
+void OPvPCapturePointNA::UpdateHalaaWorldState()
 {
     m_PvP->SendUpdateWorldState( NA_MAP_HALAA_NEUTRAL ,uint32(bool(m_HalaaState & HALAA_N)));
     m_PvP->SendUpdateWorldState( NA_MAP_HALAA_NEU_A ,uint32(bool(m_HalaaState & HALAA_N_A)));
@@ -631,7 +632,7 @@ void OutdoorPvPObjectiveNA::UpdateHalaaWorldState()
     m_PvP->SendUpdateWorldState( NA_MAP_HALAA_ALLIANCE ,uint32(bool(m_HalaaState & HALAA_A)));
 }
 
-void OutdoorPvPObjectiveNA::UpdateWyvernRoostWorldState(uint32 roost)
+void OPvPCapturePointNA::UpdateWyvernRoostWorldState(uint32 roost)
 {
     switch(roost)
     {
@@ -661,22 +662,3 @@ void OutdoorPvPObjectiveNA::UpdateWyvernRoostWorldState(uint32 roost)
         break;
     }
 }
-
-bool OutdoorPvPObjectiveNA::HandleCapturePointEvent(Player *plr, uint32 eventId)
-{
-    switch(eventId)
-    {
-    case 11821:
-        this->HandlePlayerEnter(plr);
-        return true;
-        break;
-    case 11822:
-        this->HandlePlayerLeave(plr);
-        return true;
-        break;
-    default:
-        break;
-    }
-    return false;
-}
-
diff --git a/src/game/OutdoorPvPNA.h b/src/game/OutdoorPvPNA.h
index a9500eb5e27..a3d2ab874a1 100644
--- a/src/game/OutdoorPvPNA.h
+++ b/src/game/OutdoorPvPNA.h
@@ -238,11 +238,11 @@ enum HalaaStates{
 class Unit;
 class Creature;
 class OutdoorPvPNA;
-class OutdoorPvPObjectiveNA : public OutdoorPvPObjective
+class OPvPCapturePointNA : public OPvPCapturePoint
 {
 friend class OutdoorPvPNA;
 public:
-    OutdoorPvPObjectiveNA(OutdoorPvP * pvp);
+    OPvPCapturePointNA(OutdoorPvP * pvp);
     bool Update(uint32 diff);
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
@@ -263,7 +263,6 @@ protected:
     void UpdateWyvernRoostWorldState(uint32 roost);
     void UpdateHalaaWorldState();
 
-    bool HandleCapturePointEvent(Player * plr, uint32 eventId);
 private:
     bool m_capturable;
     uint32 m_GuardsAlive;
@@ -279,7 +278,7 @@ private:
 
 class OutdoorPvPNA : public OutdoorPvP
 {
-friend class OutdoorPvPObjectiveNA;
+friend class OPvPCapturePointNA;
 public:
     OutdoorPvPNA();
     bool SetupOutdoorPvP();
@@ -290,7 +289,7 @@ public:
     void SendRemoveWorldStates(Player * plr);
     void HandleKillImpl(Player * plr, Unit * killed);
 private:
-    OutdoorPvPObjectiveNA * m_obj;
+    OPvPCapturePointNA * m_obj;
 };
 
 #endif
diff --git a/src/game/OutdoorPvPObjectiveAI.cpp b/src/game/OutdoorPvPObjectiveAI.cpp
index 35247d81210..0fe57fcaa87 100644
--- a/src/game/OutdoorPvPObjectiveAI.cpp
+++ b/src/game/OutdoorPvPObjectiveAI.cpp
@@ -15,35 +15,3 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
-
-#include "OutdoorPvPObjectiveAI.h"
-#include "Creature.h"
-#include "Player.h"
-#include "Unit.h"
-#include "OutdoorPvPMgr.h"
-#include "OutdoorPvPImpl.h"
-#include "World.h"
-
-#define MAX_OUTDOOR_PVP_DISTANCE 200 // the max value in capture point type go data0 is 100 currently, so use twice that much to handle leaving as well
-
-OutdoorPvPObjectiveAI::OutdoorPvPObjectiveAI(Creature *c) : NullCreatureAI(c)
-{
-    sLog.outDebug("OutdoorPvP objective AI assigned to creature guid %u", me->GetGUIDLow());
-    me->SetReactState(REACT_AGGRESSIVE);
-}
-
-void OutdoorPvPObjectiveAI::MoveInLineOfSight(Unit *u)
-{
-    // IsVisible only passes for players in range, so no need to check again
-    // leaving/entering distance will be checked based on go range data
-    if((u->GetTypeId() == TYPEID_PLAYER) && me->IsWithinDistInMap(u, MAX_OUTDOOR_PVP_DISTANCE))
-        sOutdoorPvPMgr.HandleCaptureCreaturePlayerMoveInLos(((Player*)u), me);
-}
-
-int OutdoorPvPObjectiveAI::Permissible(const Creature * c)
-{
-    // only assigned through AI name, never by permissibility check
-    return PERMIT_BASE_NO;
-}
-
-
diff --git a/src/game/OutdoorPvPObjectiveAI.h b/src/game/OutdoorPvPObjectiveAI.h
index dffd8885243..0fe57fcaa87 100644
--- a/src/game/OutdoorPvPObjectiveAI.h
+++ b/src/game/OutdoorPvPObjectiveAI.h
@@ -15,22 +15,3 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
-
-#ifndef TRINITY_OUTDOORPVPOBJECTIVEAI_H
-#define TRINITY_OUTDOORPVPOBJECTIVEAI_H
-
-#include "NullCreatureAI.h"
-
-class Creature;
-
-class TRINITY_DLL_DECL OutdoorPvPObjectiveAI : public NullCreatureAI
-{
-    public:
-        explicit OutdoorPvPObjectiveAI(Creature *c);
-
-        void MoveInLineOfSight(Unit *);
-
-        static int Permissible(const Creature *);
-};
-#endif
-
diff --git a/src/game/OutdoorPvPTF.cpp b/src/game/OutdoorPvPTF.cpp
index 2031dbc7521..1b2a16f0c1d 100644
--- a/src/game/OutdoorPvPTF.cpp
+++ b/src/game/OutdoorPvPTF.cpp
@@ -29,13 +29,13 @@ OutdoorPvPTF::OutdoorPvPTF()
     m_TypeId = OUTDOOR_PVP_TF;
 }
 
-OutdoorPvPObjectiveTF::OutdoorPvPObjectiveTF(OutdoorPvP *pvp, OutdoorPvPTF_TowerType type)
-: OutdoorPvPObjective(pvp), m_TowerType(type), m_TowerState(TF_TOWERSTATE_N)
+OPvPCapturePointTF::OPvPCapturePointTF(OutdoorPvP *pvp, OutdoorPvPTF_TowerType type)
+: OPvPCapturePoint(pvp), m_TowerType(type), m_TowerState(TF_TOWERSTATE_N)
 {
     AddCapturePoint(TFCapturePoints[type].entry,TFCapturePoints[type].map,TFCapturePoints[type].x,TFCapturePoints[type].y,TFCapturePoints[type].z,TFCapturePoints[type].o,TFCapturePoints[type].rot0,TFCapturePoints[type].rot1,TFCapturePoints[type].rot2,TFCapturePoints[type].rot3);
 }
 
-void OutdoorPvPObjectiveTF::FillInitialWorldStates(WorldPacket &data)
+void OPvPCapturePointTF::FillInitialWorldStates(WorldPacket &data)
 {
     data << uint32(TFTowerWorldStates[m_TowerType].n) << uint32(bool(m_TowerState & TF_TOWERSTATE_N));
     data << uint32(TFTowerWorldStates[m_TowerType].h) << uint32(bool(m_TowerState & TF_TOWERSTATE_H));
@@ -60,7 +60,7 @@ void OutdoorPvPTF::FillInitialWorldStates(WorldPacket &data)
     data << TF_UI_LOCKED_DISPLAY_HORDE << uint32(m_IsLocked && (m_HordeTowersControlled > m_AllianceTowersControlled));
     data << TF_UI_LOCKED_DISPLAY_ALLIANCE << uint32(m_IsLocked && (m_HordeTowersControlled < m_AllianceTowersControlled));
 
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
     {
         (*itr)->FillInitialWorldStates(data);
     }
@@ -92,16 +92,16 @@ void OutdoorPvPTF::SendRemoveWorldStates(Player * plr)
     }
 }
 
-void OutdoorPvPObjectiveTF::UpdateTowerState()
+void OPvPCapturePointTF::UpdateTowerState()
 {
     m_PvP->SendUpdateWorldState(uint32(TFTowerWorldStates[m_TowerType].n),uint32(bool(m_TowerState & TF_TOWERSTATE_N)));
     m_PvP->SendUpdateWorldState(uint32(TFTowerWorldStates[m_TowerType].h),uint32(bool(m_TowerState & TF_TOWERSTATE_H)));
     m_PvP->SendUpdateWorldState(uint32(TFTowerWorldStates[m_TowerType].a),uint32(bool(m_TowerState & TF_TOWERSTATE_A)));
 }
 
-bool OutdoorPvPObjectiveTF::HandlePlayerEnter(Player *plr)
+bool OPvPCapturePointTF::HandlePlayerEnter(Player *plr)
 {
-    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
+    if(OPvPCapturePoint::HandlePlayerEnter(plr))
     {
         plr->SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 1);
         uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
@@ -112,25 +112,10 @@ bool OutdoorPvPObjectiveTF::HandlePlayerEnter(Player *plr)
     return false;
 }
 
-void OutdoorPvPObjectiveTF::HandlePlayerLeave(Player *plr)
+void OPvPCapturePointTF::HandlePlayerLeave(Player *plr)
 {
     plr->SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 0);
-    OutdoorPvPObjective::HandlePlayerLeave(plr);
-}
-
-bool OutdoorPvPObjectiveTF::HandleCapturePointEvent(Player *plr, uint32 eventId)
-{
-    if(eventId == TFTowerPlayerEnterEvents[m_TowerType])
-    {
-        this->HandlePlayerEnter(plr);
-        return true;
-    }
-    else if (eventId == TFTowerPlayerLeaveEvents[m_TowerType])
-    {
-        this->HandlePlayerLeave(plr);
-        return true;
-    }
-    return false;
+    OPvPCapturePoint::HandlePlayerLeave(plr);
 }
 
 bool OutdoorPvPTF::Update(uint32 diff)
@@ -238,23 +223,23 @@ bool OutdoorPvPTF::SetupOutdoorPvP()
     for(int i = 0; i < OutdoorPvPTFBuffZonesNum; ++i)
         RegisterZone(OutdoorPvPTFBuffZones[i]);
 
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveTF(this,TF_TOWER_NW));
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveTF(this,TF_TOWER_N));
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveTF(this,TF_TOWER_NE));
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveTF(this,TF_TOWER_SE));
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveTF(this,TF_TOWER_S));
+    m_capturePoints.push_back(new OPvPCapturePointTF(this,TF_TOWER_NW));
+    m_capturePoints.push_back(new OPvPCapturePointTF(this,TF_TOWER_N));
+    m_capturePoints.push_back(new OPvPCapturePointTF(this,TF_TOWER_NE));
+    m_capturePoints.push_back(new OPvPCapturePointTF(this,TF_TOWER_SE));
+    m_capturePoints.push_back(new OPvPCapturePointTF(this,TF_TOWER_S));
 
     return true;
 }
 
-bool OutdoorPvPObjectiveTF::Update(uint32 diff)
+bool OPvPCapturePointTF::Update(uint32 diff)
 {
     // can update even in locked state if gathers the controlling faction
-    bool canupdate = ((((OutdoorPvPTF*)m_PvP)->m_AllianceTowersControlled > 0) && this->m_ActivePlayerGuids[0].size() > this->m_ActivePlayerGuids[1].size()) ||
-            ((((OutdoorPvPTF*)m_PvP)->m_HordeTowersControlled > 0) && this->m_ActivePlayerGuids[0].size() < this->m_ActivePlayerGuids[1].size());
+    bool canupdate = ((((OutdoorPvPTF*)m_PvP)->m_AllianceTowersControlled > 0) && m_activePlayers[0].size() > m_activePlayers[1].size()) ||
+            ((((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 && OutdoorPvPObjective::Update(diff))
+    if(canupdate && OPvPCapturePoint::Update(diff))
     {
         if(m_OldState != m_State)
         {
@@ -300,7 +285,7 @@ bool OutdoorPvPObjectiveTF::Update(uint32 diff)
                 break;
             }
 
-            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePoint);
+            GameObject* flag = HashMapHolder<GameObject>::Find(m_CapturePointGUID);
             if(flag)
             {
                 flag->SetGoArtKit(artkit);
diff --git a/src/game/OutdoorPvPTF.h b/src/game/OutdoorPvPTF.h
index c45a31e3d22..ca719f88fba 100644
--- a/src/game/OutdoorPvPTF.h
+++ b/src/game/OutdoorPvPTF.h
@@ -76,10 +76,10 @@ enum TFTowerStates {
     TF_TOWERSTATE_A = 4
 };
 
-class OutdoorPvPObjectiveTF : public OutdoorPvPObjective
+class OPvPCapturePointTF : public OPvPCapturePoint
 {
 public:
-    OutdoorPvPObjectiveTF(OutdoorPvP * pvp, OutdoorPvPTF_TowerType type);
+    OPvPCapturePointTF(OutdoorPvP * pvp, OutdoorPvPTF_TowerType type);
     bool Update(uint32 diff);
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
@@ -87,15 +87,13 @@ public:
     void HandlePlayerLeave(Player * plr);
     void UpdateTowerState();
 protected:
-    virtual bool HandleCapturePointEvent(Player * plr, uint32 eventId);
-protected:
     OutdoorPvPTF_TowerType m_TowerType;
     uint32 m_TowerState;
 };
 
 class OutdoorPvPTF : public OutdoorPvP
 {
-friend class OutdoorPvPObjectiveTF;
+friend class OPvPCapturePointTF;
 public:
     OutdoorPvPTF();
     bool SetupOutdoorPvP();
diff --git a/src/game/OutdoorPvPZM.cpp b/src/game/OutdoorPvPZM.cpp
index 340c12c3ca6..1fdbfc93abf 100644
--- a/src/game/OutdoorPvPZM.cpp
+++ b/src/game/OutdoorPvPZM.cpp
@@ -26,13 +26,13 @@
 #include "GossipDef.h"
 #include "World.h"
 
-OutdoorPvPObjectiveZM_Beacon::OutdoorPvPObjectiveZM_Beacon(OutdoorPvP *pvp, ZM_BeaconType type)
-: OutdoorPvPObjective(pvp), m_TowerType(type), m_TowerState(ZM_TOWERSTATE_N)
+OPvPCapturePointZM_Beacon::OPvPCapturePointZM_Beacon(OutdoorPvP *pvp, ZM_BeaconType type)
+: OPvPCapturePoint(pvp), m_TowerType(type), m_TowerState(ZM_TOWERSTATE_N)
 {
     AddCapturePoint(ZMCapturePoints[type].entry,ZMCapturePoints[type].map,ZMCapturePoints[type].x,ZMCapturePoints[type].y,ZMCapturePoints[type].z,ZMCapturePoints[type].o,ZMCapturePoints[type].rot0,ZMCapturePoints[type].rot1,ZMCapturePoints[type].rot2,ZMCapturePoints[type].rot3);
 }
 
-void OutdoorPvPObjectiveZM_Beacon::FillInitialWorldStates(WorldPacket &data)
+void OPvPCapturePointZM_Beacon::FillInitialWorldStates(WorldPacket &data)
 {
     data << uint32(ZMBeaconInfo[m_TowerType].ui_tower_n) << uint32(bool(m_TowerState & ZM_TOWERSTATE_N));
     data << uint32(ZMBeaconInfo[m_TowerType].map_tower_n) << uint32(bool(m_TowerState & ZM_TOWERSTATE_N));
@@ -42,7 +42,7 @@ void OutdoorPvPObjectiveZM_Beacon::FillInitialWorldStates(WorldPacket &data)
     data << uint32(ZMBeaconInfo[m_TowerType].map_tower_h) << uint32(bool(m_TowerState & ZM_TOWERSTATE_H));
 }
 
-void OutdoorPvPObjectiveZM_Beacon::UpdateTowerState()
+void OPvPCapturePointZM_Beacon::UpdateTowerState()
 {
     m_PvP->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].ui_tower_n),uint32(bool(m_TowerState & ZM_TOWERSTATE_N)));
     m_PvP->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].map_tower_n),uint32(bool(m_TowerState & ZM_TOWERSTATE_N)));
@@ -52,9 +52,9 @@ void OutdoorPvPObjectiveZM_Beacon::UpdateTowerState()
     m_PvP->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].map_tower_h),uint32(bool(m_TowerState & ZM_TOWERSTATE_H)));
 }
 
-bool OutdoorPvPObjectiveZM_Beacon::HandlePlayerEnter(Player *plr)
+bool OPvPCapturePointZM_Beacon::HandlePlayerEnter(Player *plr)
 {
-    if(OutdoorPvPObjective::HandlePlayerEnter(plr))
+    if(OPvPCapturePoint::HandlePlayerEnter(plr))
     {
         plr->SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_disp, 1);
         uint32 phase = (uint32)ceil(( m_ShiftPhase + m_ShiftMaxPhase) / ( 2 * m_ShiftMaxPhase ) * 100.0f);
@@ -65,30 +65,15 @@ bool OutdoorPvPObjectiveZM_Beacon::HandlePlayerEnter(Player *plr)
     return false;
 }
 
-void OutdoorPvPObjectiveZM_Beacon::HandlePlayerLeave(Player *plr)
+void OPvPCapturePointZM_Beacon::HandlePlayerLeave(Player *plr)
 {
     plr->SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_disp, 0);
-    OutdoorPvPObjective::HandlePlayerLeave(plr);
+    OPvPCapturePoint::HandlePlayerLeave(plr);
 }
 
-bool OutdoorPvPObjectiveZM_Beacon::HandleCapturePointEvent(Player *plr, uint32 eventId)
+bool OPvPCapturePointZM_Beacon::Update(uint32 diff)
 {
-    if(eventId == ZMBeaconInfo[m_TowerType].event_enter)
-    {
-        this->HandlePlayerEnter(plr);
-        return true;
-    }
-    else if (eventId == ZMBeaconInfo[m_TowerType].event_leave)
-    {
-        this->HandlePlayerLeave(plr);
-        return true;
-    }
-    return false;
-}
-
-bool OutdoorPvPObjectiveZM_Beacon::Update(uint32 diff)
-{
-    if(OutdoorPvPObjective::Update(diff))
+    if(OPvPCapturePoint::Update(diff))
     {
         if(m_OldState != m_State)
         {
@@ -205,10 +190,10 @@ bool OutdoorPvPZM::SetupOutdoorPvP()
     for(int i = 0; i < OutdoorPvPZMBuffZonesNum; ++i)
         RegisterZone(OutdoorPvPZMBuffZones[i]);
 
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveZM_Beacon(this,ZM_BEACON_WEST));
-    m_OutdoorPvPObjectives.push_back(new OutdoorPvPObjectiveZM_Beacon(this,ZM_BEACON_EAST));
-    m_GraveYard = new OutdoorPvPObjectiveZM_GraveYard(this);
-    m_OutdoorPvPObjectives.push_back(m_GraveYard); // though the update function isn't used, the handleusego is!
+    m_capturePoints.push_back(new OPvPCapturePointZM_Beacon(this,ZM_BEACON_WEST));
+    m_capturePoints.push_back(new OPvPCapturePointZM_Beacon(this,ZM_BEACON_EAST));
+    m_GraveYard = new OPvPCapturePointZM_GraveYard(this);
+    m_capturePoints.push_back(m_GraveYard); // though the update function isn't used, the handleusego is!
 
     return true;
 }
@@ -224,16 +209,16 @@ void OutdoorPvPZM::HandleKillImpl(Player *plr, Unit * killed)
         plr->CastSpell(plr,ZM_HordePlayerKillReward,true);
 }
 
-bool OutdoorPvPObjectiveZM_GraveYard::Update(uint32 diff)
+bool OPvPCapturePointZM_GraveYard::Update(uint32 diff)
 {
     bool retval = m_State != m_OldState;
     m_State = m_OldState;
     return retval;
 }
 
-int32 OutdoorPvPObjectiveZM_GraveYard::HandleOpenGo(Player *plr, uint64 guid)
+int32 OPvPCapturePointZM_GraveYard::HandleOpenGo(Player *plr, uint64 guid)
 {
-    uint32 retval = OutdoorPvPObjective::HandleOpenGo(plr, guid);
+    uint32 retval = OPvPCapturePoint::HandleOpenGo(plr, guid);
     if(retval>=0)
     {
         if(plr->HasAura(ZM_BATTLE_STANDARD_A) && m_GraveYardState != ZM_GRAVEYARD_A)
@@ -267,8 +252,8 @@ int32 OutdoorPvPObjectiveZM_GraveYard::HandleOpenGo(Player *plr, uint64 guid)
     return retval;
 }
 
-OutdoorPvPObjectiveZM_GraveYard::OutdoorPvPObjectiveZM_GraveYard(OutdoorPvP *pvp)
-: OutdoorPvPObjective(pvp)
+OPvPCapturePointZM_GraveYard::OPvPCapturePointZM_GraveYard(OutdoorPvP *pvp)
+: OPvPCapturePoint(pvp)
 {
     m_BothControllingFaction = 0;
     m_GraveYardState = ZM_GRAVEYARD_N;
@@ -280,7 +265,7 @@ OutdoorPvPObjectiveZM_GraveYard::OutdoorPvPObjectiveZM_GraveYard(OutdoorPvP *pvp
     AddObject(0,ZM_Banner_N.entry,ZM_Banner_N.map,ZM_Banner_N.x,ZM_Banner_N.y,ZM_Banner_N.z,ZM_Banner_N.o,ZM_Banner_N.rot0,ZM_Banner_N.rot1,ZM_Banner_N.rot2,ZM_Banner_N.rot3);
 }
 
-void OutdoorPvPObjectiveZM_GraveYard::UpdateTowerState()
+void OPvPCapturePointZM_GraveYard::UpdateTowerState()
 {
     m_PvP->SendUpdateWorldState(ZM_MAP_GRAVEYARD_N,uint32(bool(m_GraveYardState & ZM_GRAVEYARD_N)));
     m_PvP->SendUpdateWorldState(ZM_MAP_GRAVEYARD_H,uint32(bool(m_GraveYardState & ZM_GRAVEYARD_H)));
@@ -292,7 +277,7 @@ void OutdoorPvPObjectiveZM_GraveYard::UpdateTowerState()
     m_PvP->SendUpdateWorldState(ZM_MAP_HORDE_FLAG_NOT_READY,uint32(m_BothControllingFaction != HORDE));
 }
 
-void OutdoorPvPObjectiveZM_GraveYard::FillInitialWorldStates(WorldPacket &data)
+void OPvPCapturePointZM_GraveYard::FillInitialWorldStates(WorldPacket &data)
 {
     data << ZM_MAP_GRAVEYARD_N  << uint32(bool(m_GraveYardState & ZM_GRAVEYARD_N));
     data << ZM_MAP_GRAVEYARD_H  << uint32(bool(m_GraveYardState & ZM_GRAVEYARD_H));
@@ -304,7 +289,7 @@ void OutdoorPvPObjectiveZM_GraveYard::FillInitialWorldStates(WorldPacket &data)
     data << ZM_MAP_HORDE_FLAG_NOT_READY  << uint32(m_BothControllingFaction != HORDE);
 }
 
-void OutdoorPvPObjectiveZM_GraveYard::SetBeaconState(uint32 controlling_faction)
+void OPvPCapturePointZM_GraveYard::SetBeaconState(uint32 controlling_faction)
 {
     // nothing to do here
     if(m_BothControllingFaction == controlling_faction)
@@ -349,7 +334,7 @@ void OutdoorPvPObjectiveZM_GraveYard::SetBeaconState(uint32 controlling_faction)
     UpdateTowerState();
 }
 
-bool OutdoorPvPObjectiveZM_GraveYard::CanTalkTo(Player * plr, Creature * c, GossipOption & gso)
+bool OPvPCapturePointZM_GraveYard::CanTalkTo(Player * plr, Creature * c, GossipOption & gso)
 {
     uint64 guid = c->GetGUID();
     std::map<uint64,uint32>::iterator itr = m_CreatureTypes.find(guid);
@@ -369,7 +354,7 @@ bool OutdoorPvPObjectiveZM_GraveYard::CanTalkTo(Player * plr, Creature * c, Goss
     return false;
 }
 
-bool OutdoorPvPObjectiveZM_GraveYard::HandleGossipOption(Player *plr, uint64 guid, uint32 gossipid)
+bool OPvPCapturePointZM_GraveYard::HandleGossipOption(Player *plr, uint64 guid, uint32 gossipid)
 {
     std::map<uint64,uint32>::iterator itr = m_CreatureTypes.find(guid);
     if(itr != m_CreatureTypes.end())
@@ -397,7 +382,7 @@ bool OutdoorPvPObjectiveZM_GraveYard::HandleGossipOption(Player *plr, uint64 gui
     return false;
 }
 
-bool OutdoorPvPObjectiveZM_GraveYard::HandleDropFlag(Player * plr, uint32 spellId)
+bool OPvPCapturePointZM_GraveYard::HandleDropFlag(Player * plr, uint32 spellId)
 {
     switch(spellId)
     {
@@ -414,7 +399,7 @@ bool OutdoorPvPObjectiveZM_GraveYard::HandleDropFlag(Player * plr, uint32 spellI
 void OutdoorPvPZM::FillInitialWorldStates(WorldPacket &data)
 {
     data << ZM_WORLDSTATE_UNK_1 << uint32(1);
-    for(OutdoorPvPObjectiveSet::iterator itr = m_OutdoorPvPObjectives.begin(); itr != m_OutdoorPvPObjectives.end(); ++itr)
+    for(OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
     {
         (*itr)->FillInitialWorldStates(data);
     }
diff --git a/src/game/OutdoorPvPZM.h b/src/game/OutdoorPvPZM.h
index 33e42209f41..e0199329ef2 100644
--- a/src/game/OutdoorPvPZM.h
+++ b/src/game/OutdoorPvPZM.h
@@ -148,11 +148,11 @@ enum ZM_TowerStateMask{
 };
 
 class OutdoorPvPZM;
-class OutdoorPvPObjectiveZM_Beacon : public OutdoorPvPObjective
+class OPvPCapturePointZM_Beacon : public OPvPCapturePoint
 {
 friend class OutdoorPvPZM;
 public:
-    OutdoorPvPObjectiveZM_Beacon(OutdoorPvP * pvp, ZM_BeaconType type);
+    OPvPCapturePointZM_Beacon(OutdoorPvP * pvp, ZM_BeaconType type);
     bool Update(uint32 diff);
     void FillInitialWorldStates(WorldPacket & data);
     // used when player is activated/inactivated in the area
@@ -160,8 +160,6 @@ public:
     void HandlePlayerLeave(Player * plr);
     void UpdateTowerState();
 protected:
-    bool HandleCapturePointEvent(Player * plr, uint32 eventId);
-protected:
     ZM_BeaconType m_TowerType;
     uint32 m_TowerState;
 };
@@ -172,11 +170,11 @@ enum ZM_GraveYardState{
     ZM_GRAVEYARD_H = 4
 };
 
-class OutdoorPvPObjectiveZM_GraveYard : public OutdoorPvPObjective
+class OPvPCapturePointZM_GraveYard : public OPvPCapturePoint
 {
 friend class OutdoorPvPZM;
 public:
-    OutdoorPvPObjectiveZM_GraveYard(OutdoorPvP * pvp);
+    OPvPCapturePointZM_GraveYard(OutdoorPvP * pvp);
     bool Update(uint32 diff);
     void FillInitialWorldStates(WorldPacket & data);
     void UpdateTowerState();
@@ -194,7 +192,7 @@ protected:
 
 class OutdoorPvPZM : public OutdoorPvP
 {
-friend class OutdoorPvPObjectiveZM_Beacon;
+friend class OPvPCapturePointZM_Beacon;
 public:
     OutdoorPvPZM();
     bool SetupOutdoorPvP();
@@ -205,7 +203,7 @@ public:
     void SendRemoveWorldStates(Player * plr);
     void HandleKillImpl(Player * plr, Unit * killed);
 private:
-    OutdoorPvPObjectiveZM_GraveYard * m_GraveYard;
+    OPvPCapturePointZM_GraveYard * m_GraveYard;
     uint32 m_AllianceTowersControlled;
     uint32 m_HordeTowersControlled;
 };
diff --git a/src/game/Player.h b/src/game/Player.h
index 0d7d3068d92..33693842154 100644
--- a/src/game/Player.h
+++ b/src/game/Player.h
@@ -1650,6 +1650,7 @@ class TRINITY_DLL_SPEC Player : public Unit
 
         static uint32 TeamForRace(uint8 race);
         uint32 GetTeam() const { return m_team; }
+        TeamId GetTeamId() const { return m_team == ALLIANCE ? TEAM_ALLIANCE : TEAM_HORDE; }
         static uint32 getFactionForRace(uint8 race);
         void setFactionForRace(uint8 race);
 
diff --git a/src/game/SharedDefines.h b/src/game/SharedDefines.h
index 23f32601df7..8ccc820fa58 100644
--- a/src/game/SharedDefines.h
+++ b/src/game/SharedDefines.h
@@ -512,6 +512,13 @@ enum Language
 
 #define LANGUAGES_COUNT   19
 
+enum TeamId
+{
+    TEAM_ALLIANCE = 0,
+    TEAM_HORDE,
+    TEAM_NEUTRAL,
+};
+
 enum Team
 {
     HORDE               = 67,
diff --git a/src/game/Unit.cpp b/src/game/Unit.cpp
index cc143c0add3..41293837a1b 100644
--- a/src/game/Unit.cpp
+++ b/src/game/Unit.cpp
@@ -13277,9 +13277,9 @@ void Unit::Kill(Unit *pVictim, bool durabilityLoss)
         if(OutdoorPvP * pvp = player->GetOutdoorPvP())
             pvp->HandleKill(player, pVictim);
 
-    if(pVictim->GetTypeId() == TYPEID_PLAYER)
-        if(OutdoorPvP * pvp = ((Player*)pVictim)->GetOutdoorPvP())
-            pvp->HandlePlayerActivityChanged((Player*)pVictim);
+    //if(pVictim->GetTypeId() == TYPEID_PLAYER)
+    //    if(OutdoorPvP * pvp = ((Player*)pVictim)->GetOutdoorPvP())
+    //        pvp->HandlePlayerActivityChanged((Player*)pVictim);
 
     // battleground things (do this at the end, so the death state flag will be properly set to handle in the bg->handlekill)
     if(player && player->InBattleGround())