josh/TCPlayerbotCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
--HG--
branch : trunk
This commit is contained in:
megamage
2009-05-29 00:18:41 -05:00
parent 1288761fb7
commit bc32144310
27 changed files with 443 additions and 736 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/game/CreatureAIRegistry.cpp
-2
View File
@@ -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();
src/game/GameObject.cpp
+31 -16
View File
@@ -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
src/game/GameObject.h
+17 -1
View File
@@ -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);
src/game/GridNotifiers.h
+15
View File
@@ -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
{
src/game/GridNotifiersImpl.h
+9
View File
@@ -553,6 +553,15 @@ void Trinity::CreatureListSearcher<Check>::Visit(CreatureMapType &m)
i_objects.push_back(itr->getSource());
}
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)
{
src/game/MiscHandler.cpp
+2 -4
View File
@@ -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 )
src/game/OutdoorPvP.cpp
+156 -309
View File
@@ -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)
if(!goinfo || goinfo->type != GAMEOBJECT_TYPE_CAPTURE_POINT)
{
sLog.outError("OutdoorPvP: GO %u is not capture point!", goinfo->id);
return false;
CreatureInfo const *cinfo = objmgr.GetCreatureTemplate(OPVP_TRIGGER_CREATURE_ENTRY);
if(!cinfo)
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);
objmgr.AddGameobjectToGrid(m_CapturePointGUID, &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;
}
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)
objmgr.DeleteGOData(m_CapturePointGUID);
m_CapturePointGUID = 0;
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)
{
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();
std::list<Player*> players;
Trinity::AnyPlayerInObjectRangeCheck checker(m_capturePoint, radius);
Trinity::PlayerListSearcher<Trinity::AnyPlayerInObjectRangeCheck> searcher(m_capturePoint, players, checker);
m_capturePoint->VisitNearbyWorldObject(radius, searcher);
for(std::list<Player*>::iterator itr = players.begin(); itr != players.end(); ++itr)
{
if((*itr)->IsOutdoorPvPActive())
{
if(m_activePlayers[(*itr)->GetTeamId()].insert(*itr).second)
HandlePlayerEnter(*itr);
}
}
// 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;
// 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)
{
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;
}
else /*if(fact_diff==0)*/ // no change
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;
m_ShiftPhase += fact_diff;
// 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;
}
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;
}
return true;
}
bool OutdoorPvPObjective::HandleCaptureCreaturePlayerMoveInLos(Player * p, Creature * c)
{
// check if guid matches
if(c->GetGUID() != m_CapturePointCreature)
return false;
// check if capture point go is spawned
GameObject * cp = HashMapHolder<GameObject>::Find(m_CapturePoint);
if(!cp)
return false;
// 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);
Challenger = HORDE;
}
else
return HandleCapturePointEvent(p, cp->GetGOInfo()->capturePoint.progressEventID2); //i_objective->HandlePlayerLeave((Player*)u);
{
// ally is in majority, but it's already ally-controlled -> no change
if(m_State == OBJECTIVESTATE_ALLIANCE && m_ShiftPhase >= m_ShiftMaxPhase)
return false;
if(fact_diff > m_ShiftMaxCaptureSpeed)
fact_diff = m_ShiftMaxCaptureSpeed;
Challenger = ALLIANCE;
}
m_OldPhase = m_ShiftPhase;
m_OldState = m_State;
m_ShiftPhase += fact_diff;
// 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;
}
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;
}
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)
src/game/OutdoorPvP.h
+15 -28
View File
@@ -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;
src/game/OutdoorPvPEP.cpp
+55 -115
View File
@@ -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);
OPvPCapturePoint::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;
}
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);
OPvPCapturePoint::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;
}
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);
}
src/game/OutdoorPvPEP.h
+12 -16
View File
@@ -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();
src/game/OutdoorPvPHP.cpp
+14 -30
View File
@@ -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;
}
src/game/OutdoorPvPHP.h
+3 -4
View File
@@ -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();
src/game/OutdoorPvPImpl.h
-1
View File
@@ -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
src/game/OutdoorPvPMgr.cpp
+11 -11
View File
@@ -207,6 +207,17 @@ bool OutdoorPvPMgr::HandleCustomSpell(Player *plr, uint32 spellId, GameObject *
return false;
}
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)
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::HandleOpenGo(Player *plr, uint64 guid)
{
for(OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
@@ -217,16 +228,6 @@ bool OutdoorPvPMgr::HandleOpenGo(Player *plr, uint64 guid)
return false;
}
bool OutdoorPvPMgr::HandleCaptureCreaturePlayerMoveInLos(Player * plr, Creature * c)
{
for(OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
{
if((*itr)->HandleCaptureCreaturePlayerMoveInLos(plr,c))
return true;
}
return false;
}
void OutdoorPvPMgr::HandleGossipOption(Player *plr, uint64 guid, uint32 gossipid)
{
for(OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
@@ -254,4 +255,3 @@ void OutdoorPvPMgr::HandleDropFlag(Player *plr, uint32 spellId)
return;
}
}
src/game/OutdoorPvPMgr.h
+2 -2
View File
@@ -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);
src/game/OutdoorPvPNA.cpp
+31 -49
View File
@@ -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;
}
src/game/OutdoorPvPNA.h
+4 -5
View File
@@ -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
src/game/OutdoorPvPObjectiveAI.cpp
-32
View File
@@ -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;
}
src/game/OutdoorPvPObjectiveAI.h
-19
View File
@@ -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
src/game/OutdoorPvPTF.cpp
+19 -34
View File
@@ -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);
src/game/OutdoorPvPTF.h
+3 -5
View File
@@ -76,18 +76,16 @@ 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
bool HandlePlayerEnter(Player * plr);
void HandlePlayerLeave(Player * plr);
void UpdateTowerState();
protected:
virtual bool HandleCapturePointEvent(Player * plr, uint32 eventId);
protected:
OutdoorPvPTF_TowerType m_TowerType;
uint32 m_TowerState;
@@ -95,7 +93,7 @@ protected:
class OutdoorPvPTF : public OutdoorPvP
{
friend class OutdoorPvPObjectiveTF;
friend class OPvPCapturePointTF;
public:
OutdoorPvPTF();
bool SetupOutdoorPvP();
src/game/OutdoorPvPZM.cpp
+26 -41
View File
@@ -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);
}
src/game/OutdoorPvPZM.h
+6 -8
View File
@@ -148,19 +148,17 @@ 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
bool HandlePlayerEnter(Player * plr);
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;
};
src/game/Player.h
+1
View File
@@ -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);
src/game/SharedDefines.h
+7
View File
@@ -512,6 +512,13 @@ enum Language
#define LANGUAGES_COUNT 19
enum TeamId
{
TEAM_ALLIANCE = 0,
TEAM_HORDE,
TEAM_NEUTRAL,
};
enum Team
{
HORDE = 67,
src/game/Unit.cpp
+3 -3
View File
@@ -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())