sindoring/moonwell-core
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore(Core/OutdoorPvP): cleanup ptr's, rename private fields (#17778)

Browse Source 
chore(Game/OutdoorPvP): cleanup ptr's, private fields
This commit is contained in:
Winfidonarleyan
2023-11-18 23:51:02 +07:00
committed by GitHub
parent 164dfb27a8
commit 18d3940145
11 changed files with 565 additions and 511 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/server/game/OutdoorPvP/OutdoorPvP.cpp
+237 -165
View File
@@ -26,41 +26,46 @@
#include "OutdoorPvPMgr.h" #include "OutdoorPvPMgr.h"
#include "WorldPacket.h" #include "WorldPacket.h"
OPvPCapturePoint::OPvPCapturePoint(OutdoorPvP* pvp): OPvPCapturePoint::OPvPCapturePoint(OutdoorPvP* pvp) :
m_capturePointSpawnId(0), m_capturePoint(nullptr), m_maxValue(0.0f), m_minValue(0.0f), m_maxSpeed(0), _pvp(pvp)
m_value(0), m_team(TEAM_NEUTRAL), m_OldState(OBJECTIVESTATE_NEUTRAL), {
m_State(OBJECTIVESTATE_NEUTRAL), m_neutralValuePct(0), m_PvP(pvp) }
{ }
bool OPvPCapturePoint::HandlePlayerEnter(Player* player) bool OPvPCapturePoint::HandlePlayerEnter(Player* player)
{ {
if (m_capturePoint) if (_capturePoint)
{ {
player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldState1, 1); player->SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldState1, 1);
player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate2, (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f)); player->SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldstate2, (uint32)std::ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f));
player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate3, m_neutralValuePct); player->SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldstate3, _neutralValuePct);
} }
return m_activePlayers[player->GetTeamId()].insert(player->GetGUID()).second;
return _activePlayers[player->GetTeamId()].insert(player->GetGUID()).second;
} }
void OPvPCapturePoint::HandlePlayerLeave(Player* player) void OPvPCapturePoint::HandlePlayerLeave(Player* player)
{ {
if (m_capturePoint) if (_capturePoint)
player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldState1, 0); {
m_activePlayers[player->GetTeamId()].erase(player->GetGUID()); player->SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldState1, 0);
}
_activePlayers[player->GetTeamId()].erase(player->GetGUID());
} }
void OPvPCapturePoint::SendChangePhase() void OPvPCapturePoint::SendChangePhase()
{ {
if (!m_capturePoint) if (!_capturePoint)
return; return;
// send this too, sometimes the slider disappears, dunno why :( // send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldState1, 1); SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldState1, 1);
// send these updates to only the ones in this objective // send these updates to only the ones in this objective
SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate2, (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f)); SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldstate2, (uint32)std::ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f));
// send this too, sometimes it resets :S // send this too, sometimes it resets :S
SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate3, m_neutralValuePct); SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldstate3, _neutralValuePct);
} }
void OPvPCapturePoint::AddGO(uint32 type, ObjectGuid::LowType guid, uint32 entry) void OPvPCapturePoint::AddGO(uint32 type, ObjectGuid::LowType guid, uint32 entry)
@@ -69,11 +74,15 @@ void OPvPCapturePoint::AddGO(uint32 type, ObjectGuid::LowType guid, uint32 entry
{ {
const GameObjectData* data = sObjectMgr->GetGameObjectData(guid); const GameObjectData* data = sObjectMgr->GetGameObjectData(guid);
if (!data) if (!data)
{
return; return;
}
entry = data->id; entry = data->id;
} }
m_Objects[type] = guid;
m_ObjectTypes[m_Objects[type]] = type; _objects[type] = guid;
_objectTypes[_objects[type]] = type;
} }
void OPvPCapturePoint::AddCre(uint32 type, ObjectGuid::LowType guid, uint32 entry) void OPvPCapturePoint::AddCre(uint32 type, ObjectGuid::LowType guid, uint32 entry)
@@ -82,11 +91,15 @@ void OPvPCapturePoint::AddCre(uint32 type, ObjectGuid::LowType guid, uint32 entr
{ {
const CreatureData* data = sObjectMgr->GetCreatureData(guid); const CreatureData* data = sObjectMgr->GetCreatureData(guid);
if (!data) if (!data)
{
return; return;
}
entry = data->id1; entry = data->id1;
} }
m_Creatures[type] = guid;
m_CreatureTypes[m_Creatures[type]] = type; _creatures[type] = guid;
_creatureTypes[_creatures[type]] = type;
} }
bool OPvPCapturePoint::AddObject(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3) 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)
@@ -100,9 +113,9 @@ bool OPvPCapturePoint::AddObject(uint32 type, uint32 entry, uint32 map, float x,
return false; return false;
} }
bool OPvPCapturePoint::AddCreature(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay) bool OPvPCapturePoint::AddCreature(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, uint32 spawntimeDelay)
{ {
if (ObjectGuid::LowType guid = sObjectMgr->AddCreData(entry, map, x, y, z, o, spawntimedelay)) if (ObjectGuid::LowType guid = sObjectMgr->AddCreData(entry, map, x, y, z, o, spawntimeDelay))
{ {
AddCre(type, guid, entry); AddCre(type, guid, entry);
return true; return true;
@@ -128,34 +141,37 @@ bool OPvPCapturePoint::SetCapturePointData(uint32 entry, uint32 map, float x, fl
return false; return false;
// get the needed values from goinfo // get the needed values from goinfo
m_maxValue = (float)goinfo->capturePoint.maxTime; _maxValue = (float)goinfo->capturePoint.maxTime;
m_maxSpeed = m_maxValue / (goinfo->capturePoint.minTime ? goinfo->capturePoint.minTime : 60); _maxSpeed = _maxValue / float(goinfo->capturePoint.minTime ? goinfo->capturePoint.minTime : 60);
m_neutralValuePct = goinfo->capturePoint.neutralPercent; _neutralValuePct = goinfo->capturePoint.neutralPercent;
m_minValue = CalculatePct(m_maxValue, m_neutralValuePct); _minValue = CalculatePct(_maxValue, _neutralValuePct);
return true; return true;
} }
bool OPvPCapturePoint::DelCreature(uint32 type) bool OPvPCapturePoint::DelCreature(uint32 type)
{ {
ObjectGuid::LowType spawnId = m_Creatures[type]; ObjectGuid::LowType spawnId = _creatures[type];
if (!spawnId) if (!spawnId)
{ {
LOG_DEBUG("outdoorpvp", "opvp creature type {} was already deleted", type); LOG_DEBUG("outdoorpvp", "OutdoorPvP: Creature type {} was already deleted", type);
return false; return false;
} }
auto bounds = m_PvP->GetMap()->GetCreatureBySpawnIdStore().equal_range(spawnId); auto bounds = _pvp->GetMap()->GetCreatureBySpawnIdStore().equal_range(spawnId);
for (auto itr = bounds.first; itr != bounds.second;) for (auto itr = bounds.first; itr != bounds.second;)
{ {
// can happen when closing the core // can happen when closing the core
Creature* c = itr->second; Creature* c = itr->second;
++itr; ++itr;
// Don't save respawn time // Don't save respawn time
c->SetRespawnTime(0); c->SetRespawnTime(0);
c->RemoveCorpse(); c->RemoveCorpse();
c->AddObjectToRemoveList(); c->AddObjectToRemoveList();
} }
LOG_DEBUG("outdoorpvp", "deleting opvp creature type {}", type);
LOG_DEBUG("outdoorpvp", "OutdoorPvP: Deleting creature type {}", type);
// explicit removal from map // 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 // 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 // so this is a big fat workaround, if AddObjectToRemoveList and DoDelayedMovesAndRemoves worked correctly, this wouldn't be needed
@@ -164,23 +180,23 @@ bool OPvPCapturePoint::DelCreature(uint32 type)
// delete respawn time for this creature // delete respawn time for this creature
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CREATURE_RESPAWN); CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CREATURE_RESPAWN);
stmt->SetData(0, spawnId); stmt->SetData(0, spawnId);
stmt->SetData(1, m_PvP->GetMap()->GetId()); stmt->SetData(1, _pvp->GetMap()->GetId());
stmt->SetData(2, 0); // instance id, always 0 for world maps stmt->SetData(2, 0); // instance id, always 0 for world maps
CharacterDatabase.Execute(stmt); CharacterDatabase.Execute(stmt);
sObjectMgr->DeleteCreatureData(spawnId); sObjectMgr->DeleteCreatureData(spawnId);
m_CreatureTypes[m_Creatures[type]] = 0; _creatureTypes[_creatures[type]] = 0;
m_Creatures[type] = 0; _creatures[type] = 0;
return true; return true;
} }
bool OPvPCapturePoint::DelObject(uint32 type) bool OPvPCapturePoint::DelObject(uint32 type)
{ {
ObjectGuid::LowType spawnId = m_Objects[type]; ObjectGuid::LowType spawnId = _objects[type];
if (!spawnId) if (!spawnId)
return false; return false;
auto bounds = m_PvP->GetMap()->GetGameObjectBySpawnIdStore().equal_range(spawnId); auto bounds = _pvp->GetMap()->GetGameObjectBySpawnIdStore().equal_range(spawnId);
for (auto itr = bounds.first; itr != bounds.second;) for (auto itr = bounds.first; itr != bounds.second;)
{ {
GameObject* go = itr->second; GameObject* go = itr->second;
@@ -191,8 +207,8 @@ bool OPvPCapturePoint::DelObject(uint32 type)
} }
sObjectMgr->DeleteGOData(spawnId); sObjectMgr->DeleteGOData(spawnId);
m_ObjectTypes[m_Objects[type]] = 0; _objectTypes[_objects[type]] = 0;
m_Objects[type] = 0; _objects[type] = 0;
return true; return true;
} }
@@ -201,10 +217,10 @@ bool OPvPCapturePoint::DelCapturePoint()
sObjectMgr->DeleteGOData(m_capturePointSpawnId); sObjectMgr->DeleteGOData(m_capturePointSpawnId);
m_capturePointSpawnId = 0; m_capturePointSpawnId = 0;
if (m_capturePoint) if (_capturePoint)
{ {
m_capturePoint->SetRespawnTime(0); // not save respawn time _capturePoint->SetRespawnTime(0); // not save respawn time
m_capturePoint->Delete(); _capturePoint->Delete();
} }
return true; return true;
@@ -212,39 +228,46 @@ bool OPvPCapturePoint::DelCapturePoint()
void OPvPCapturePoint::DeleteSpawns() void OPvPCapturePoint::DeleteSpawns()
{ {
for (std::map<uint32, ObjectGuid::LowType>::iterator i = m_Objects.begin(); i != m_Objects.end(); ++i) for (auto const& [type, guid] : _objects)
DelObject(i->first); {
for (std::map<uint32, ObjectGuid::LowType>::iterator i = m_Creatures.begin(); i != m_Creatures.end(); ++i) DelObject(type);
DelCreature(i->first); }
for (auto const& [type, guid] : _creatures)
{
DelCreature(type);
}
DelCapturePoint(); DelCapturePoint();
} }
void OutdoorPvP::DeleteSpawns() void OutdoorPvP::DeleteSpawns()
{ {
// Remove script from any registered gameobjects/creatures // Remove script from any registered gameobjects/creatures
for (auto itr = m_GoScriptStore.begin(); itr != m_GoScriptStore.end(); ++itr) for (auto& itr : _goScriptStore)
{ {
if (GameObject* go = itr->second) if (GameObject* go = itr.second)
go->ClearZoneScript(); go->ClearZoneScript();
} }
m_GoScriptStore.clear();
for (auto itr = m_CreatureScriptStore.begin(); itr != m_CreatureScriptStore.end(); ++itr) _goScriptStore.clear();
for (auto& itr : _creatureScriptStore)
{ {
if (Creature* creature = itr->second) if (Creature* creature = itr.second)
creature->ClearZoneScript(); creature->ClearZoneScript();
} }
m_CreatureScriptStore.clear();
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) _creatureScriptStore.clear();
for (auto& capturePoint : _capturePoints)
{ {
itr->second->DeleteSpawns(); capturePoint.second->DeleteSpawns();
delete itr->second; delete capturePoint.second;
} }
m_capturePoints.clear();
}
OutdoorPvP::OutdoorPvP() : m_TypeId(0), m_sendUpdate(true), m_map(nullptr) { } _capturePoints.clear();
}
OutdoorPvP::~OutdoorPvP() OutdoorPvP::~OutdoorPvP()
{ {
@@ -253,149 +276,173 @@ OutdoorPvP::~OutdoorPvP()
void OutdoorPvP::HandlePlayerEnterZone(Player* player, uint32 /*zone*/) void OutdoorPvP::HandlePlayerEnterZone(Player* player, uint32 /*zone*/)
{ {
m_players[player->GetTeamId()].insert(player->GetGUID()); _players[player->GetTeamId()].insert(player->GetGUID());
} }
void OutdoorPvP::HandlePlayerLeaveZone(Player* player, uint32 /*zone*/) void OutdoorPvP::HandlePlayerLeaveZone(Player* player, uint32 /*zone*/)
{ {
// inform the objectives of the leaving // inform the objectives of the leaving
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (auto& _capturePoint : _capturePoints)
itr->second->HandlePlayerLeave(player); {
_capturePoint.second->HandlePlayerLeave(player);
}
// 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) // 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 (!player->GetSession()->PlayerLogout()) if (!player->GetSession()->PlayerLogout())
{
SendRemoveWorldStates(player); SendRemoveWorldStates(player);
m_players[player->GetTeamId()].erase(player->GetGUID()); }
LOG_DEBUG("outdoorpvp", "Player {} left an outdoorpvp zone", player->GetName());
_players[player->GetTeamId()].erase(player->GetGUID());
LOG_DEBUG("outdoorpvp", "OutdoorPvP: Player {} left an outdoorpvp zone", player->GetName());
} }
void OutdoorPvP::HandlePlayerResurrects(Player* /*player*/, uint32 /*zone*/) void OutdoorPvP::HandlePlayerResurrects(Player* /*player*/, uint32 /*zone*/)
{ {
} }
bool OutdoorPvP::Update(uint32 diff) bool OutdoorPvP::Update(uint32 diff)
{ {
bool objective_changed = false; bool objective_changed = false;
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (auto& capturePoint : _capturePoints)
{ {
if (itr->second->Update(diff)) if (capturePoint.second->Update(diff))
objective_changed = true; objective_changed = true;
} }
return objective_changed; return objective_changed;
} }
bool OPvPCapturePoint::Update(uint32 diff) bool OPvPCapturePoint::Update(uint32 diff)
{ {
if (!m_capturePoint) if (!_capturePoint)
return false; return false;
float radius = (float)m_capturePoint->GetGOInfo()->capturePoint.radius; auto radius = (float)_capturePoint->GetGOInfo()->capturePoint.radius;
for (uint32 team = 0; team < 2; ++team) for (auto const& activePlayer : _activePlayers)
{ {
for (PlayerSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end();) for (auto itr = activePlayer.begin(); itr != activePlayer.end();)
{ {
ObjectGuid playerGuid = *itr; ObjectGuid playerGuid = *itr;
++itr; ++itr;
if (Player* player = ObjectAccessor::FindPlayer(playerGuid)) if (Player* player = ObjectAccessor::FindPlayer(playerGuid))
if (!m_capturePoint->IsWithinDistInMap(player, radius) || !player->IsOutdoorPvPActive()) if (!_capturePoint->IsWithinDistInMap(player, radius) || !player->IsOutdoorPvPActive())
HandlePlayerLeave(player); HandlePlayerLeave(player);
} }
} }
std::list<Player*> players; std::list<Player*> players;
Acore::AnyPlayerInObjectRangeCheck checker(m_capturePoint, radius); Acore::AnyPlayerInObjectRangeCheck checker(_capturePoint, radius);
Acore::PlayerListSearcher<Acore::AnyPlayerInObjectRangeCheck> searcher(m_capturePoint, players, checker); Acore::PlayerListSearcher<Acore::AnyPlayerInObjectRangeCheck> searcher(_capturePoint, players, checker);
Cell::VisitWorldObjects(m_capturePoint, searcher, radius); Cell::VisitWorldObjects(_capturePoint, searcher, radius);
for (std::list<Player*>::iterator itr = players.begin(); itr != players.end(); ++itr) for (auto& itr : players)
{ {
Player* const player = *itr; Player* const player = itr;
if (player->IsOutdoorPvPActive()) if (player->IsOutdoorPvPActive())
{ {
if (m_activePlayers[player->GetTeamId()].insert(player->GetGUID()).second) if (_activePlayers[player->GetTeamId()].insert(player->GetGUID()).second)
HandlePlayerEnter(*itr); HandlePlayerEnter(itr);
} }
} }
// get the difference of numbers // get the difference of numbers
float fact_diff = ((float)m_activePlayers[0].size() - (float)m_activePlayers[1].size()) * diff / OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL; float factDiff = ((float)_activePlayers[0].size() - (float)_activePlayers[1].size()) * float(diff) / OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL;
if (!fact_diff) if (factDiff == 0.f)
return false; return false;
TeamId ChallengerId = TEAM_NEUTRAL; TeamId ChallengerId = TEAM_NEUTRAL;
float maxDiff = m_maxSpeed * diff; float maxDiff = _maxSpeed * float(diff);
if (fact_diff < 0) if (factDiff < 0.f)
{ {
// horde is in majority, but it's already horde-controlled -> no change // horde is in majority, but it's already horde-controlled -> no change
if (m_State == OBJECTIVESTATE_HORDE && m_value <= -m_maxValue) if (_state == OBJECTIVESTATE_HORDE && _value <= -_maxValue)
return false; return false;
if (fact_diff < -maxDiff) if (factDiff < -maxDiff)
fact_diff = -maxDiff; factDiff = -maxDiff;
ChallengerId = TEAM_HORDE; ChallengerId = TEAM_HORDE;
} }
else else
{ {
// ally is in majority, but it's already ally-controlled -> no change // ally is in majority, but it's already ally-controlled -> no change
if (m_State == OBJECTIVESTATE_ALLIANCE && m_value >= m_maxValue) if (_state == OBJECTIVESTATE_ALLIANCE && _value >= _maxValue)
return false; return false;
if (fact_diff > maxDiff) if (factDiff > maxDiff)
fact_diff = maxDiff; factDiff = maxDiff;
ChallengerId = TEAM_ALLIANCE; ChallengerId = TEAM_ALLIANCE;
} }
float oldValue = m_value; float oldValue = _value;
TeamId oldTeam = m_team; TeamId oldTeam = _team;
m_OldState = m_State; _oldState = _state;
_value += factDiff;
m_value += fact_diff; if (_value < -_minValue) // red
if (m_value < -m_minValue) // red
{ {
if (m_value < -m_maxValue) if (_value < -_maxValue)
m_value = -m_maxValue; {
m_State = OBJECTIVESTATE_HORDE; _value = -_maxValue;
m_team = TEAM_HORDE; }
_state = OBJECTIVESTATE_HORDE;
_team = TEAM_HORDE;
} }
else if (m_value > m_minValue) // blue else if (_value > _minValue) // blue
{ {
if (m_value > m_maxValue) if (_value > _maxValue)
m_value = m_maxValue; {
m_State = OBJECTIVESTATE_ALLIANCE; _value = _maxValue;
m_team = TEAM_ALLIANCE; }
_state = OBJECTIVESTATE_ALLIANCE;
_team = TEAM_ALLIANCE;
} }
else if (oldValue * m_value <= 0) // grey, go through mid point else if (oldValue * _value <= 0) // grey, go through mid-point
{ {
// if challenger is ally, then n->a challenge // if challenger is ally, then n->a challenge
if (ChallengerId == TEAM_ALLIANCE) if (ChallengerId == TEAM_ALLIANCE)
m_State = OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE; {
// if challenger is horde, then n->h challenge _state = OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE;
else if (ChallengerId == TEAM_HORDE) }
m_State = OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE; else if (ChallengerId == TEAM_HORDE) // if challenger is horde, then n->h challenge
m_team = TEAM_NEUTRAL; {
_state = OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE;
}
_team = TEAM_NEUTRAL;
} }
else // grey, did not go through mid point else // grey, did not go through mid-point
{ {
// old phase and current are on the same side, so one team challenges the other // old phase and current are on the same side, so one team challenges the other
if (ChallengerId == TEAM_ALLIANCE && (m_OldState == OBJECTIVESTATE_HORDE || m_OldState == OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE)) if (ChallengerId == TEAM_ALLIANCE && (_oldState == OBJECTIVESTATE_HORDE || _oldState == OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE))
m_State = OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE; {
else if (ChallengerId == TEAM_HORDE && (m_OldState == OBJECTIVESTATE_ALLIANCE || m_OldState == OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE)) _state = OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE;
m_State = OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE; }
m_team = TEAM_NEUTRAL; else if (ChallengerId == TEAM_HORDE && (_oldState == OBJECTIVESTATE_ALLIANCE || _oldState == OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE))
{
_state = OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE;
}
_team = TEAM_NEUTRAL;
} }
if (m_value != oldValue) if (_value != oldValue)
SendChangePhase();
if (m_OldState != m_State)
{ {
if (oldTeam != m_team) SendChangePhase();
}
if (_oldState != _state)
{
if (oldTeam != _team)
{ {
ChangeTeam(oldTeam); ChangeTeam(oldTeam);
} }
@@ -409,20 +456,20 @@ bool OPvPCapturePoint::Update(uint32 diff)
void OutdoorPvP::SendUpdateWorldState(uint32 field, uint32 value) void OutdoorPvP::SendUpdateWorldState(uint32 field, uint32 value)
{ {
if (m_sendUpdate) if (_sendUpdate)
for (int i = 0; i < 2; ++i) for (auto const& _player : _players)
for (PlayerSet::iterator itr = m_players[i].begin(); itr != m_players[i].end(); ++itr) for (auto itr : _player)
if (Player* const player = ObjectAccessor::FindPlayer(*itr)) if (Player* const player = ObjectAccessor::FindPlayer(itr))
player->SendUpdateWorldState(field, value); player->SendUpdateWorldState(field, value);
} }
void OPvPCapturePoint::SendUpdateWorldState(uint32 field, uint32 value) void OPvPCapturePoint::SendUpdateWorldState(uint32 field, uint32 value)
{ {
for (uint32 team = 0; team < 2; ++team) for (auto const& activePlayer : _activePlayers)
{ {
// send to all players present in the area // send to all players present in the area
for (PlayerSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr) for (auto itr : activePlayer)
if (Player* const player = ObjectAccessor::FindPlayer(*itr)) if (Player* const player = ObjectAccessor::FindPlayer(itr))
player->SendUpdateWorldState(field, value); player->SendUpdateWorldState(field, value);
} }
} }
@@ -430,7 +477,7 @@ void OPvPCapturePoint::SendUpdateWorldState(uint32 field, uint32 value)
void OPvPCapturePoint::SendObjectiveComplete(uint32 id, ObjectGuid guid) void OPvPCapturePoint::SendObjectiveComplete(uint32 id, ObjectGuid guid)
{ {
uint32 team; uint32 team;
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_ALLIANCE: case OBJECTIVESTATE_ALLIANCE:
team = 0; team = 0;
@@ -443,19 +490,20 @@ void OPvPCapturePoint::SendObjectiveComplete(uint32 id, ObjectGuid guid)
} }
// send to all players present in the area // send to all players present in the area
for (PlayerSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr) for (auto itr : _activePlayers[team])
if (Player* const player = ObjectAccessor::FindPlayer(*itr)) if (Player* const player = ObjectAccessor::FindPlayer(itr))
player->KilledMonsterCredit(id, guid); player->KilledMonsterCredit(id, guid);
} }
void OutdoorPvP::HandleKill(Player* killer, Unit* killed) void OutdoorPvP::HandleKill(Player* killer, Unit* killed)
{ {
ASSERT(killer);
if (Group* group = killer->GetGroup()) if (Group* group = killer->GetGroup())
{ {
for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next()) for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
{ {
Player* groupGuy = itr->GetSource(); Player* groupGuy = itr->GetSource();
if (!groupGuy) if (!groupGuy)
continue; continue;
@@ -474,7 +522,7 @@ void OutdoorPvP::HandleKill(Player* killer, Unit* killed)
else else
{ {
// creature kills must be notified, even if not inside objective / not outdoor pvp active // creature kills must be notified, even if not inside objective / not outdoor pvp active
if (killer && ((killer->IsOutdoorPvPActive() && IsInsideObjective(killer)) || killed->GetTypeId() == TYPEID_UNIT)) if ((killer->IsOutdoorPvPActive() && IsInsideObjective(killer)) || killed->GetTypeId() == TYPEID_UNIT)
{ {
HandleKillImpl(killer, killed); HandleKillImpl(killer, killed);
} }
@@ -483,8 +531,8 @@ void OutdoorPvP::HandleKill(Player* killer, Unit* killed)
bool OutdoorPvP::IsInsideObjective(Player* player) const bool OutdoorPvP::IsInsideObjective(Player* player) const
{ {
for (OPvPCapturePointMap::const_iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (auto& capturePoint : _capturePoints)
if (itr->second->IsInsideObjective(player)) if (capturePoint.second->IsInsideObjective(player))
return true; return true;
return false; return false;
@@ -492,14 +540,14 @@ bool OutdoorPvP::IsInsideObjective(Player* player) const
bool OPvPCapturePoint::IsInsideObjective(Player* player) const bool OPvPCapturePoint::IsInsideObjective(Player* player) const
{ {
PlayerSet const& plSet = m_activePlayers[player->GetTeamId()]; PlayerSet const& plSet = _activePlayers[player->GetTeamId()];
return plSet.find(player->GetGUID()) != plSet.end(); return plSet.find(player->GetGUID()) != plSet.end();
} }
bool OutdoorPvP::HandleCustomSpell(Player* player, uint32 spellId, GameObject* go) bool OutdoorPvP::HandleCustomSpell(Player* player, uint32 spellId, GameObject* go)
{ {
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (auto& capturePoint : _capturePoints)
if (itr->second->HandleCustomSpell(player, spellId, go)) if (capturePoint.second->HandleCustomSpell(player, spellId, go))
return true; return true;
return false; return false;
@@ -507,15 +555,13 @@ bool OutdoorPvP::HandleCustomSpell(Player* player, uint32 spellId, GameObject* g
bool OPvPCapturePoint::HandleCustomSpell(Player* player, uint32 /*spellId*/, GameObject* /*go*/) bool OPvPCapturePoint::HandleCustomSpell(Player* player, uint32 /*spellId*/, GameObject* /*go*/)
{ {
if (!player->IsOutdoorPvPActive()) return player->IsOutdoorPvPActive();
return false;
return false;
} }
bool OutdoorPvP::HandleOpenGo(Player* player, GameObject* go) bool OutdoorPvP::HandleOpenGo(Player* player, GameObject* go)
{ {
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (auto& capturePoint : _capturePoints)
if (itr->second->HandleOpenGo(player, go) >= 0) if (capturePoint.second->HandleOpenGo(player, go) >= 0)
return true; return true;
return false; return false;
@@ -523,8 +569,8 @@ bool OutdoorPvP::HandleOpenGo(Player* player, GameObject* go)
bool OutdoorPvP::HandleGossipOption(Player* player, Creature* creature, uint32 id) bool OutdoorPvP::HandleGossipOption(Player* player, Creature* creature, uint32 id)
{ {
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (auto& capturePoint : _capturePoints)
if (itr->second->HandleGossipOption(player, creature, id)) if (capturePoint.second->HandleGossipOption(player, creature, id))
return true; return true;
return false; return false;
@@ -532,8 +578,8 @@ bool OutdoorPvP::HandleGossipOption(Player* player, Creature* creature, uint32 i
bool OutdoorPvP::CanTalkTo(Player* player, Creature* c, GossipMenuItems const& gso) bool OutdoorPvP::CanTalkTo(Player* player, Creature* c, GossipMenuItems const& gso)
{ {
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (auto& capturePoint : _capturePoints)
if (itr->second->CanTalkTo(player, c, gso)) if (capturePoint.second->CanTalkTo(player, c, gso))
return true; return true;
return false; return false;
@@ -541,8 +587,8 @@ bool OutdoorPvP::CanTalkTo(Player* player, Creature* c, GossipMenuItems const& g
bool OutdoorPvP::HandleDropFlag(Player* player, uint32 id) bool OutdoorPvP::HandleDropFlag(Player* player, uint32 id)
{ {
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (auto& capturePoint : _capturePoints)
if (itr->second->HandleDropFlag(player, id)) if (capturePoint.second->HandleDropFlag(player, id))
return true; return true;
return false; return false;
@@ -565,14 +611,20 @@ bool OPvPCapturePoint::HandleDropFlag(Player* /*player*/, uint32 /*id*/)
int32 OPvPCapturePoint::HandleOpenGo(Player* /*player*/, GameObject* go) int32 OPvPCapturePoint::HandleOpenGo(Player* /*player*/, GameObject* go)
{ {
std::map<ObjectGuid::LowType, uint32>::iterator itr = m_ObjectTypes.find(go->GetSpawnId()); auto const itr = _objectTypes.find(go->GetSpawnId());
if (itr != m_ObjectTypes.end()) if (itr != _objectTypes.end())
{ {
return itr->second; return (int32)itr->second;
} }
return -1; return -1;
} }
void OPvPCapturePoint::SetSlider(float slider)
{
_value = std::clamp<float>(slider, -_maxValue, _maxValue);
}
bool OutdoorPvP::HandleAreaTrigger(Player* /*player*/, uint32 /*trigger*/) bool OutdoorPvP::HandleAreaTrigger(Player* /*player*/, uint32 /*trigger*/)
{ {
return false; return false;
@@ -581,9 +633,9 @@ bool OutdoorPvP::HandleAreaTrigger(Player* /*player*/, uint32 /*trigger*/)
void OutdoorPvP::BroadcastPacket(WorldPacket& data) const void OutdoorPvP::BroadcastPacket(WorldPacket& data) const
{ {
// This is faster than sWorld->SendZoneMessage // This is faster than sWorld->SendZoneMessage
for (uint32 team = 0; team < 2; ++team) for (auto const& playerSet : _players)
for (PlayerSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr) for (auto itr : playerSet)
if (Player* const player = ObjectAccessor::FindPlayer(*itr)) if (Player* const player = ObjectAccessor::FindPlayer(itr))
player->GetSession()->SendPacket(&data); player->GetSession()->SendPacket(&data);
} }
@@ -594,7 +646,7 @@ void OutdoorPvP::RegisterZone(uint32 zoneId)
bool OutdoorPvP::HasPlayer(Player const* player) const bool OutdoorPvP::HasPlayer(Player const* player) const
{ {
PlayerSet const& plSet = m_players[player->GetTeamId()]; PlayerSet const& plSet = _players[player->GetTeamId()];
return plSet.find(player->GetGUID()) != plSet.end(); return plSet.find(player->GetGUID()) != plSet.end();
} }
@@ -602,15 +654,15 @@ void OutdoorPvP::TeamCastSpell(TeamId team, int32 spellId, Player* sameMapPlr)
{ {
if (spellId > 0) if (spellId > 0)
{ {
for (PlayerSet::iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr) for (auto itr : _players[team])
if (Player* const player = ObjectAccessor::FindPlayer(*itr)) if (Player* const player = ObjectAccessor::FindPlayer(itr))
if (!sameMapPlr || sameMapPlr->FindMap() == player->FindMap()) if (!sameMapPlr || sameMapPlr->FindMap() == player->FindMap())
player->CastSpell(player, (uint32)spellId, true); player->CastSpell(player, (uint32)spellId, true);
} }
else else
{ {
for (PlayerSet::iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr) for (auto itr : _players[team])
if (Player* const player = ObjectAccessor::FindPlayer(*itr)) if (Player* const player = ObjectAccessor::FindPlayer(itr))
if (!sameMapPlr || sameMapPlr->FindMap() == player->FindMap()) if (!sameMapPlr || sameMapPlr->FindMap() == player->FindMap())
player->RemoveAura((uint32) - spellId); // by stack? player->RemoveAura((uint32) - spellId); // by stack?
} }
@@ -618,49 +670,69 @@ void OutdoorPvP::TeamCastSpell(TeamId team, int32 spellId, Player* sameMapPlr)
void OutdoorPvP::TeamApplyBuff(TeamId teamId, uint32 spellId, uint32 spellId2, Player* sameMapPlr) void OutdoorPvP::TeamApplyBuff(TeamId teamId, uint32 spellId, uint32 spellId2, Player* sameMapPlr)
{ {
TeamCastSpell(teamId, spellId, sameMapPlr); TeamCastSpell(teamId, (int32)spellId, sameMapPlr);
TeamCastSpell(teamId == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE, spellId2 ? -(int32)spellId2 : -(int32)spellId, sameMapPlr); TeamCastSpell(teamId == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE, spellId2 ? -(int32)spellId2 : -(int32)spellId, sameMapPlr);
} }
void OutdoorPvP::OnGameObjectCreate(GameObject* go) void OutdoorPvP::OnGameObjectCreate(GameObject* go)
{ {
GoScriptPair sp(go->GetGUID().GetCounter(), go); GoScriptPair sp(go->GetGUID().GetCounter(), go);
m_GoScriptStore.insert(sp); _goScriptStore.insert(sp);
if (go->GetGoType() != GAMEOBJECT_TYPE_CAPTURE_POINT) if (go->GetGoType() != GAMEOBJECT_TYPE_CAPTURE_POINT)
{
return; return;
}
if (OPvPCapturePoint* cp = GetCapturePoint(go->GetSpawnId())) if (OPvPCapturePoint* cp = GetCapturePoint(go->GetSpawnId()))
cp->m_capturePoint = go; {
cp->_capturePoint = go;
}
} }
void OutdoorPvP::OnGameObjectRemove(GameObject* go) void OutdoorPvP::OnGameObjectRemove(GameObject* go)
{ {
m_GoScriptStore.erase(go->GetGUID().GetCounter()); _goScriptStore.erase(go->GetGUID().GetCounter());
if (go->GetGoType() != GAMEOBJECT_TYPE_CAPTURE_POINT) if (go->GetGoType() != GAMEOBJECT_TYPE_CAPTURE_POINT)
{
return; return;
}
if (OPvPCapturePoint* cp = GetCapturePoint(go->GetSpawnId())) if (OPvPCapturePoint* cp = GetCapturePoint(go->GetSpawnId()))
cp->m_capturePoint = nullptr; {
cp->_capturePoint = nullptr;
}
} }
void OutdoorPvP::OnCreatureCreate(Creature* creature) void OutdoorPvP::OnCreatureCreate(Creature* creature)
{ {
CreatureScriptPair sp(creature->GetGUID().GetCounter(), creature); CreatureScriptPair sp(creature->GetGUID().GetCounter(), creature);
m_CreatureScriptStore.insert(sp); _creatureScriptStore.insert(sp);
} }
void OutdoorPvP::OnCreatureRemove(Creature* creature) void OutdoorPvP::OnCreatureRemove(Creature* creature)
{ {
m_CreatureScriptStore.erase(creature->GetGUID().GetCounter()); _creatureScriptStore.erase(creature->GetGUID().GetCounter());
} }
void OutdoorPvP::SetMapFromZone(uint32 zone) void OutdoorPvP::SetMapFromZone(uint32 zone)
{ {
AreaTableEntry const* areaTable = sAreaTableStore.LookupEntry(zone); AreaTableEntry const* areaTable = sAreaTableStore.LookupEntry(zone);
ASSERT(areaTable); ASSERT(areaTable);
Map* map = sMapMgr->CreateBaseMap(areaTable->mapid); Map* map = sMapMgr->CreateBaseMap(areaTable->mapid);
ASSERT(!map->Instanceable()); ASSERT(!map->Instanceable());
m_map = map; _map = map;
}
OPvPCapturePoint* OutdoorPvP::GetCapturePoint(ObjectGuid::LowType spawnId) const
{
auto const itr = _capturePoints.find(spawnId);
if (itr != _capturePoints.end())
{
return itr->second;
}
return nullptr;
} }
src/server/game/OutdoorPvP/OutdoorPvP.h
+44 -75
View File
@@ -21,6 +21,7 @@
#include "SharedDefines.h" #include "SharedDefines.h"
#include "Util.h" #include "Util.h"
#include "ZoneScript.h" #include "ZoneScript.h"
#include <array>
class GameObject; class GameObject;
@@ -80,17 +81,17 @@ class GameObject;
class WorldPacket; class WorldPacket;
class Creature; class Creature;
class Unit; class Unit;
struct GossipMenuItems;
class OutdoorPvP; class OutdoorPvP;
struct GossipMenuItems;
typedef GuidSet PlayerSet; typedef GuidSet PlayerSet;
class OPvPCapturePoint class OPvPCapturePoint
{ {
public: public:
OPvPCapturePoint(OutdoorPvP* pvp); explicit OPvPCapturePoint(OutdoorPvP* pvp);
virtual ~OPvPCapturePoint() = default;
virtual ~OPvPCapturePoint() {}
virtual void FillInitialWorldStates(WorldPacket& /*data*/) {} virtual void FillInitialWorldStates(WorldPacket& /*data*/) {}
@@ -113,24 +114,16 @@ public:
// returns true if the state of the objective has changed, in this case, the OutdoorPvP must send a world state ui update. // 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 Update(uint32 diff);
virtual void ChangeState() = 0; virtual void ChangeState() = 0;
virtual void ChangeTeam(TeamId /*oldTeam*/) {} virtual void ChangeTeam(TeamId /*oldTeam*/) {}
virtual void SendChangePhase(); virtual void SendChangePhase();
virtual bool HandleGossipOption(Player* player, Creature* creature, uint32 gossipId);
virtual bool HandleGossipOption(Player* player, Creature* creature, uint32 gossipid);
virtual bool CanTalkTo(Player* player, Creature* c, GossipMenuItems const& gso); virtual bool CanTalkTo(Player* player, Creature* c, GossipMenuItems const& gso);
virtual bool HandleDropFlag(Player* player, uint32 spellId); virtual bool HandleDropFlag(Player* player, uint32 spellId);
virtual void DeleteSpawns(); virtual void DeleteSpawns();
ObjectGuid::LowType m_capturePointSpawnId; ObjectGuid::LowType m_capturePointSpawnId{};
GameObject* _capturePoint{};
GameObject* m_capturePoint;
void AddGO(uint32 type, ObjectGuid::LowType guid, uint32 entry = 0); void AddGO(uint32 type, ObjectGuid::LowType guid, uint32 entry = 0);
void AddCre(uint32 type, ObjectGuid::LowType guid, uint32 entry = 0); void AddCre(uint32 type, ObjectGuid::LowType guid, uint32 entry = 0);
@@ -138,58 +131,54 @@ public:
bool SetCapturePointData(uint32 entry, uint32 map, float x, float y, float z, float o = 0, bool SetCapturePointData(uint32 entry, uint32 map, float x, float y, float z, float o = 0,
float rotation0 = 0, float rotation1 = 0, float rotation2 = 0, float rotation3 = 0); float rotation0 = 0, float rotation1 = 0, float rotation2 = 0, float rotation3 = 0);
void SetSlider(float slider) void SetSlider(float slider);
{
m_value = std::clamp<float>(slider, -m_maxValue, m_maxValue);
}
float GetSlider() [[nodiscard]] float GetSlider() const
{ {
return m_value; return _value;
} }
protected: protected:
bool AddObject(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, bool AddObject(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o,
float rotation0, float rotation1, float rotation2, float rotation3); float rotation0, float rotation1, float rotation2, float rotation3);
bool AddCreature(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay = 0); bool AddCreature(uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, uint32 spawntimeDelay = 0);
bool DelCreature(uint32 type); bool DelCreature(uint32 type);
bool DelObject(uint32 type); bool DelObject(uint32 type);
bool DelCapturePoint(); bool DelCapturePoint();
protected: protected:
// active players in the area of the objective, 0 - alliance, 1 - horde // active players in the area of the objective, 0 - alliance, 1 - horde
PlayerSet m_activePlayers[2]; std::array<PlayerSet, 2> _activePlayers;
// total shift needed to capture the objective // total shift needed to capture the objective
float m_maxValue; float _maxValue{};
float m_minValue; float _minValue{};
// maximum speed of capture // maximum speed of capture
float m_maxSpeed; float _maxSpeed{};
// the status of the objective // the status of the objective
float m_value; float _value{};
TeamId m_team; TeamId _team{ TEAM_NEUTRAL };
// objective states // objective states
ObjectiveStates m_OldState; ObjectiveStates _oldState{ OBJECTIVESTATE_NEUTRAL };
ObjectiveStates m_State; ObjectiveStates _state{ OBJECTIVESTATE_NEUTRAL };
// neutral value on capture bar // neutral value on capture bar
uint32 m_neutralValuePct; uint32 _neutralValuePct{};
// pointer to the OutdoorPvP this objective belongs to // pointer to the OutdoorPvP this objective belongs to
OutdoorPvP* m_PvP; OutdoorPvP* _pvp{};
// map to store the various gameobjects and creatures spawned by the objective // map to store the various game objects and creatures
// spawned by the objective
// type, guid // type, guid
std::map<uint32, ObjectGuid::LowType> m_Objects; std::unordered_map<uint32, ObjectGuid::LowType> _objects;
std::map<uint32, ObjectGuid::LowType> m_Creatures; std::unordered_map<uint32, ObjectGuid::LowType> _creatures;
std::map<ObjectGuid::LowType, uint32> m_ObjectTypes; std::unordered_map<ObjectGuid::LowType, uint32> _objectTypes;
std::map<ObjectGuid::LowType, uint32> m_CreatureTypes; std::unordered_map<ObjectGuid::LowType, uint32> _creatureTypes;
}; };
// base class for specific outdoor pvp handlers // base class for specific outdoor pvp handlers
@@ -199,7 +188,7 @@ class OutdoorPvP : public ZoneScript
public: public:
// ctor // ctor
OutdoorPvP(); OutdoorPvP() = default;
// dtor // dtor
~OutdoorPvP() override; ~OutdoorPvP() override;
@@ -213,7 +202,7 @@ public:
virtual void FillInitialWorldStates(WorldPacket& /*data*/) {} virtual void FillInitialWorldStates(WorldPacket& /*data*/) {}
// called when a player triggers an areatrigger // called when a player triggers an area trigger
virtual bool HandleAreaTrigger(Player* player, uint32 trigger); virtual bool HandleAreaTrigger(Player* player, uint32 trigger);
// called on custom spell // called on custom spell
@@ -246,63 +235,43 @@ public:
// awards rewards for player kill // awards rewards for player kill
virtual void AwardKillBonus(Player* /*player*/) {} virtual void AwardKillBonus(Player* /*player*/) {}
uint32 GetTypeId() {return m_TypeId;} uint32 GetTypeId() const { return _typeId; }
virtual bool HandleDropFlag(Player* player, uint32 spellId); virtual bool HandleDropFlag(Player* player, uint32 spellId);
virtual bool HandleGossipOption(Player* player, Creature* creature, uint32 gossipId);
virtual bool HandleGossipOption(Player* player, Creature* creature, uint32 gossipid);
virtual bool CanTalkTo(Player* player, Creature* c, GossipMenuItems const& gso); virtual bool CanTalkTo(Player* player, Creature* c, GossipMenuItems const& gso);
void TeamApplyBuff(TeamId teamId, uint32 spellId, uint32 spellId2 = 0, Player* sameMapPlr = nullptr); void TeamApplyBuff(TeamId teamId, uint32 spellId, uint32 spellId2 = 0, Player* sameMapPlr = nullptr);
Map* GetMap() const { return m_map; } Map* GetMap() const { return _map; }
protected: protected:
// the map of the objectives belonging to this outdoorpvp
OPvPCapturePointMap m_capturePoints;
PlayerSet m_players[2];
uint32 m_TypeId;
bool m_sendUpdate;
// world state stuff
virtual void SendRemoveWorldStates(Player* /*player*/) {}
void BroadcastPacket(WorldPacket& data) const; void BroadcastPacket(WorldPacket& data) const;
virtual void SendRemoveWorldStates(Player* /*player*/) {} // world state stuff
virtual void HandlePlayerEnterZone(Player* player, uint32 zone); virtual void HandlePlayerEnterZone(Player* player, uint32 zone);
virtual void HandlePlayerLeaveZone(Player* player, uint32 zone); virtual void HandlePlayerLeaveZone(Player* player, uint32 zone);
virtual void HandlePlayerResurrects(Player* player, uint32 zone); virtual void HandlePlayerResurrects(Player* player, uint32 zone);
void AddCapturePoint(OPvPCapturePoint* cp) void AddCapturePoint(OPvPCapturePoint* cp)
{ {
m_capturePoints[cp->m_capturePointSpawnId] = cp; _capturePoints[cp->m_capturePointSpawnId] = cp;
}
OPvPCapturePoint* GetCapturePoint(ObjectGuid::LowType spawnId) const
{
OutdoorPvP::OPvPCapturePointMap::const_iterator itr = m_capturePoints.find(spawnId);
if (itr != m_capturePoints.end())
return itr->second;
return nullptr;
} }
OPvPCapturePoint* GetCapturePoint(ObjectGuid::LowType spawnId) const;
void RegisterZone(uint32 zoneid); void RegisterZone(uint32 zoneid);
bool HasPlayer(Player const* player) const; bool HasPlayer(Player const* player) const;
void TeamCastSpell(TeamId team, int32 spellId, Player* sameMapPlr = nullptr); void TeamCastSpell(TeamId team, int32 spellId, Player* sameMapPlr = nullptr);
// Hack to store map // Hack to store map
void SetMapFromZone(uint32 zone); void SetMapFromZone(uint32 zone);
std::map<ObjectGuid::LowType, GameObject*> m_GoScriptStore;
std::map<ObjectGuid::LowType, Creature*> m_CreatureScriptStore;
Map* m_map; // the map of the objectives belonging to this outdoor pvp
OPvPCapturePointMap _capturePoints;
std::array<PlayerSet, 2> _players;
uint32 _typeId{};
bool _sendUpdate{ true };
Map* _map{};
std::unordered_map<ObjectGuid::LowType, GameObject*> _goScriptStore;
std::unordered_map<ObjectGuid::LowType, Creature*> _creatureScriptStore;
}; };
#endif /*OUTDOOR_PVP_H_*/ #endif /*OUTDOOR_PVP_H_*/
src/server/game/OutdoorPvP/OutdoorPvPMgr.cpp
+53 -37
View File
@@ -35,12 +35,8 @@ OutdoorPvPMgr* OutdoorPvPMgr::instance()
void OutdoorPvPMgr::Die() void OutdoorPvPMgr::Die()
{ {
//LOG_DEBUG("outdoorpvp", "Deleting OutdoorPvPMgr"); m_OutdoorPvPSet.clear();
for (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr) m_OutdoorPvPDatas.clear();
delete *itr;
for (OutdoorPvPDataMap::iterator itr = m_OutdoorPvPDatas.begin(); itr != m_OutdoorPvPDatas.end(); ++itr)
delete itr->second;
} }
void OutdoorPvPMgr::InitOutdoorPvP() void OutdoorPvPMgr::InitOutdoorPvP()
@@ -60,10 +56,8 @@ void OutdoorPvPMgr::InitOutdoorPvP()
uint32 count = 0; uint32 count = 0;
uint32 typeId = 0; uint32 typeId = 0;
do for (auto const& fields : *result)
{ {
Field* fields = result->Fetch();
typeId = fields[0].Get<uint8>(); typeId = fields[0].Get<uint8>();
if (DisableMgr::IsDisabledFor(DISABLE_TYPE_OUTDOORPVP, typeId, nullptr)) if (DisableMgr::IsDisabledFor(DISABLE_TYPE_OUTDOORPVP, typeId, nullptr))
@@ -75,26 +69,25 @@ void OutdoorPvPMgr::InitOutdoorPvP()
continue; continue;
} }
OutdoorPvPData* data = new OutdoorPvPData(); auto data = std::make_unique<OutdoorPvPData>();
OutdoorPvPTypes realTypeId = OutdoorPvPTypes(typeId); auto realTypeId = OutdoorPvPTypes(typeId);
data->TypeId = realTypeId; data->TypeId = realTypeId;
data->ScriptId = sObjectMgr->GetScriptId(fields[1].Get<std::string>()); data->ScriptId = sObjectMgr->GetScriptId(fields[1].Get<std::string>());
m_OutdoorPvPDatas[realTypeId] = data; m_OutdoorPvPDatas[realTypeId] = std::move(data);
++count; ++count;
} while (result->NextRow()); }
OutdoorPvP* pvp;
for (uint8 i = 1; i < MAX_OUTDOORPVP_TYPES; ++i) for (uint8 i = 1; i < MAX_OUTDOORPVP_TYPES; ++i)
{ {
OutdoorPvPDataMap::iterator iter = m_OutdoorPvPDatas.find(OutdoorPvPTypes(i)); auto iter = m_OutdoorPvPDatas.find(OutdoorPvPTypes(i));
if (iter == m_OutdoorPvPDatas.end()) if (iter == m_OutdoorPvPDatas.end())
{ {
LOG_ERROR("sql.sql", "Could not initialize OutdoorPvP object for type ID {}; no entry in database.", uint32(i)); LOG_ERROR("sql.sql", "Could not initialize OutdoorPvP object for type ID {}; no entry in database.", uint32(i));
continue; continue;
} }
pvp = sScriptMgr->CreateOutdoorPvP(iter->second); auto pvp = std::unique_ptr<OutdoorPvP>(sScriptMgr->CreateOutdoorPvP(iter->second.get()));
if (!pvp) if (!pvp)
{ {
LOG_ERROR("outdoorpvp", "Could not initialize OutdoorPvP object for type ID {}; got nullptr pointer from script.", uint32(i)); LOG_ERROR("outdoorpvp", "Could not initialize OutdoorPvP object for type ID {}; got nullptr pointer from script.", uint32(i));
@@ -104,11 +97,10 @@ void OutdoorPvPMgr::InitOutdoorPvP()
if (!pvp->SetupOutdoorPvP()) if (!pvp->SetupOutdoorPvP())
{ {
LOG_ERROR("outdoorpvp", "Could not initialize OutdoorPvP object for type ID {}; SetupOutdoorPvP failed.", uint32(i)); LOG_ERROR("outdoorpvp", "Could not initialize OutdoorPvP object for type ID {}; SetupOutdoorPvP failed.", uint32(i));
delete pvp;
continue; continue;
} }
m_OutdoorPvPSet.push_back(pvp); m_OutdoorPvPSet.emplace_back(std::move(pvp));
} }
LOG_INFO("server.loading", ">> Loaded {} outdoor PvP definitions in {} ms", count, GetMSTimeDiffToNow(oldMSTime)); LOG_INFO("server.loading", ">> Loaded {} outdoor PvP definitions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
@@ -122,7 +114,7 @@ void OutdoorPvPMgr::AddZone(uint32 zoneid, OutdoorPvP* handle)
void OutdoorPvPMgr::HandlePlayerEnterZone(Player* player, uint32 zoneid) void OutdoorPvPMgr::HandlePlayerEnterZone(Player* player, uint32 zoneid)
{ {
OutdoorPvPMap::iterator itr = m_OutdoorPvPMap.find(zoneid); auto itr = m_OutdoorPvPMap.find(zoneid);
if (itr == m_OutdoorPvPMap.end()) if (itr == m_OutdoorPvPMap.end())
return; return;
@@ -137,7 +129,7 @@ void OutdoorPvPMgr::HandlePlayerEnterZone(Player* player, uint32 zoneid)
void OutdoorPvPMgr::HandlePlayerLeaveZone(Player* player, uint32 zoneid) void OutdoorPvPMgr::HandlePlayerLeaveZone(Player* player, uint32 zoneid)
{ {
OutdoorPvPMap::iterator itr = m_OutdoorPvPMap.find(zoneid); auto itr = m_OutdoorPvPMap.find(zoneid);
if (itr == m_OutdoorPvPMap.end()) if (itr == m_OutdoorPvPMap.end())
return; return;
@@ -153,22 +145,27 @@ void OutdoorPvPMgr::HandlePlayerLeaveZone(Player* player, uint32 zoneid)
OutdoorPvP* OutdoorPvPMgr::GetOutdoorPvPToZoneId(uint32 zoneid) OutdoorPvP* OutdoorPvPMgr::GetOutdoorPvPToZoneId(uint32 zoneid)
{ {
OutdoorPvPMap::iterator itr = m_OutdoorPvPMap.find(zoneid); auto itr = m_OutdoorPvPMap.find(zoneid);
if (itr == m_OutdoorPvPMap.end()) if (itr == m_OutdoorPvPMap.end())
{ {
// no handle for this zone, return // no handle for this zone, return
return nullptr; return nullptr;
} }
return itr->second; return itr->second;
} }
void OutdoorPvPMgr::Update(uint32 diff) void OutdoorPvPMgr::Update(uint32 diff)
{ {
m_UpdateTimer += diff; m_UpdateTimer += diff;
if (m_UpdateTimer > OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL) if (m_UpdateTimer > OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL)
{ {
for (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr) for (auto const& itr : m_OutdoorPvPSet)
(*itr)->Update(m_UpdateTimer); {
itr->Update(m_UpdateTimer);
}
m_UpdateTimer = 0; m_UpdateTimer = 0;
} }
} }
@@ -176,72 +173,91 @@ void OutdoorPvPMgr::Update(uint32 diff)
bool OutdoorPvPMgr::HandleCustomSpell(Player* player, uint32 spellId, GameObject* go) bool OutdoorPvPMgr::HandleCustomSpell(Player* player, uint32 spellId, GameObject* go)
{ {
// pussywizard: no mutex because not affecting other players // pussywizard: no mutex because not affecting other players
for (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr) for (auto& itr : m_OutdoorPvPSet)
{ {
if ((*itr)->HandleCustomSpell(player, spellId, go)) if (itr->HandleCustomSpell(player, spellId, go))
{
return true; return true;
}
} }
return false; return false;
} }
ZoneScript* OutdoorPvPMgr::GetZoneScript(uint32 zoneId) ZoneScript* OutdoorPvPMgr::GetZoneScript(uint32 zoneId)
{ {
OutdoorPvPMap::iterator itr = m_OutdoorPvPMap.find(zoneId); auto itr = m_OutdoorPvPMap.find(zoneId);
if (itr != m_OutdoorPvPMap.end()) if (itr != m_OutdoorPvPMap.end())
{
return itr->second; return itr->second;
else }
return nullptr;
return nullptr;
} }
bool OutdoorPvPMgr::HandleOpenGo(Player* player, GameObject* go) bool OutdoorPvPMgr::HandleOpenGo(Player* player, GameObject* go)
{ {
std::lock_guard<std::mutex> guard(_lock); // pussywizard std::lock_guard<std::mutex> guard(_lock); // pussywizard
for (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
for (auto& itr : m_OutdoorPvPSet)
{ {
if ((*itr)->HandleOpenGo(player, go)) if (itr->HandleOpenGo(player, go))
{
return true; return true;
}
} }
return false; return false;
} }
void OutdoorPvPMgr::HandleGossipOption(Player* player, Creature* creature, uint32 gossipid) void OutdoorPvPMgr::HandleGossipOption(Player* player, Creature* creature, uint32 gossipid)
{ {
std::lock_guard<std::mutex> guard(_lock); // pussywizard std::lock_guard<std::mutex> guard(_lock); // pussywizard
for (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
for (auto& itr : m_OutdoorPvPSet)
{ {
if ((*itr)->HandleGossipOption(player, creature, gossipid)) if (itr->HandleGossipOption(player, creature, gossipid))
{
return; return;
}
} }
} }
bool OutdoorPvPMgr::CanTalkTo(Player* player, Creature* creature, GossipMenuItems const& gso) bool OutdoorPvPMgr::CanTalkTo(Player* player, Creature* creature, GossipMenuItems const& gso)
{ {
for (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr) for (auto& itr : m_OutdoorPvPSet)
{ {
if ((*itr)->CanTalkTo(player, creature, gso)) if (itr->CanTalkTo(player, creature, gso))
{
return true; return true;
}
} }
return false; return false;
} }
void OutdoorPvPMgr::HandleDropFlag(Player* player, uint32 spellId) void OutdoorPvPMgr::HandleDropFlag(Player* player, uint32 spellId)
{ {
// pussywizard: no mutex because not affecting other players // pussywizard: no mutex because not affecting other players
for (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr) for (auto& itr : m_OutdoorPvPSet)
{ {
if ((*itr)->HandleDropFlag(player, spellId)) if (itr->HandleDropFlag(player, spellId))
{
return; return;
}
} }
} }
void OutdoorPvPMgr::HandlePlayerResurrects(Player* player, uint32 zoneid) void OutdoorPvPMgr::HandlePlayerResurrects(Player* player, uint32 zoneid)
{ {
OutdoorPvPMap::iterator itr = m_OutdoorPvPMap.find(zoneid); auto itr = m_OutdoorPvPMap.find(zoneid);
if (itr == m_OutdoorPvPMap.end()) if (itr == m_OutdoorPvPMap.end())
return; return;
// pussywizard: no mutex because not affecting other players // pussywizard: no mutex because not affecting other players
if (itr->second->HasPlayer(player)) if (itr->second->HasPlayer(player))
{
itr->second->HandlePlayerResurrects(player, zoneid); itr->second->HandlePlayerResurrects(player, zoneid);
}
} }
src/server/game/OutdoorPvP/OutdoorPvPMgr.h
+6 -9
View File
@@ -21,6 +21,7 @@
#define OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL 1000 #define OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL 1000
#include "OutdoorPvP.h" #include "OutdoorPvP.h"
#include <memory>
class Player; class Player;
class GameObject; class GameObject;
@@ -39,7 +40,7 @@ class OutdoorPvPMgr
{ {
private: private:
OutdoorPvPMgr(); OutdoorPvPMgr();
~OutdoorPvPMgr() {}; ~OutdoorPvPMgr() = default;
public: public:
static OutdoorPvPMgr* instance(); static OutdoorPvPMgr* instance();
@@ -80,24 +81,20 @@ public:
void HandleDropFlag(Player* player, uint32 spellId); void HandleDropFlag(Player* player, uint32 spellId);
// pussywizard: lock required because different functions affect m_players // pussywizard: lock required because different functions affect _players
std::mutex _lock; std::mutex _lock;
private: private:
typedef std::vector<OutdoorPvP*> OutdoorPvPSet;
typedef std::map<uint32 /* zoneid */, OutdoorPvP*> OutdoorPvPMap;
typedef std::map<OutdoorPvPTypes, OutdoorPvPData*> OutdoorPvPDataMap;
// contains all initiated outdoor pvp events // contains all initiated outdoor pvp events
// used when initing / cleaning up // used when initing / cleaning up
OutdoorPvPSet m_OutdoorPvPSet; std::vector<std::unique_ptr<OutdoorPvP>> m_OutdoorPvPSet;
// maps the zone ids to an outdoor pvp event // maps the zone ids to an outdoor pvp event
// used in player event handling // used in player event handling
OutdoorPvPMap m_OutdoorPvPMap; std::map<uint32/*zoneid*/, OutdoorPvP*> m_OutdoorPvPMap;
// Holds the outdoor PvP templates // Holds the outdoor PvP templates
OutdoorPvPDataMap m_OutdoorPvPDatas; std::map<OutdoorPvPTypes, std::unique_ptr<OutdoorPvPData>> m_OutdoorPvPDatas;
// update interval // update interval
uint32 m_UpdateTimer; uint32 m_UpdateTimer;
src/server/scripts/OutdoorPvP/OutdoorPvPEP.cpp
+82 -82
View File
@@ -38,34 +38,34 @@ OPvPCapturePointEP_EWT::OPvPCapturePointEP_EWT(OutdoorPvP* pvp)
void OPvPCapturePointEP_EWT::ChangeState() void OPvPCapturePointEP_EWT::ChangeState()
{ {
// if changing from controlling alliance to horde or vice versa // if changing from controlling alliance to horde or vice versa
if ( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State ) if ( _oldState == OBJECTIVESTATE_ALLIANCE && _oldState != _state )
{ {
sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_EWT_A)); sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_EWT_A));
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_EWT, TEAM_NEUTRAL); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_EWT, TEAM_NEUTRAL);
} }
else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State ) else if ( _oldState == OBJECTIVESTATE_HORDE && _oldState != _state )
{ {
sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_EWT_H)); sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_EWT_H));
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_EWT, TEAM_NEUTRAL); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_EWT, TEAM_NEUTRAL);
} }
uint32 artkit = 21; uint32 artkit = 21;
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_ALLIANCE: case OBJECTIVESTATE_ALLIANCE:
m_TowerState = EP_TS_A; m_TowerState = EP_TS_A;
artkit = 2; artkit = 2;
SummonSupportUnitAtNorthpassTower(TEAM_ALLIANCE); SummonSupportUnitAtNorthpassTower(TEAM_ALLIANCE);
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_EWT, TEAM_ALLIANCE); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_EWT, TEAM_ALLIANCE);
if (m_OldState != m_State) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_A)); if (_oldState != _state) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_A));
break; break;
case OBJECTIVESTATE_HORDE: case OBJECTIVESTATE_HORDE:
m_TowerState = EP_TS_H; m_TowerState = EP_TS_H;
artkit = 1; artkit = 1;
SummonSupportUnitAtNorthpassTower(TEAM_HORDE); SummonSupportUnitAtNorthpassTower(TEAM_HORDE);
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_EWT, TEAM_HORDE); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_EWT, TEAM_HORDE);
if (m_OldState != m_State) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_H)); if (_oldState != _state) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_H));
break; break;
case OBJECTIVESTATE_NEUTRAL: case OBJECTIVESTATE_NEUTRAL:
m_TowerState = EP_TS_N; m_TowerState = EP_TS_N;
@@ -85,7 +85,7 @@ void OPvPCapturePointEP_EWT::ChangeState()
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit); itr->second->SetGoArtKit(artkit);
bounds = map->GetGameObjectBySpawnIdStore().equal_range(m_Objects[EP_EWT_FLAGS]); bounds = map->GetGameObjectBySpawnIdStore().equal_range(_objects[EP_EWT_FLAGS]);
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit); itr->second->SetGoArtKit(artkit);
@@ -101,10 +101,10 @@ void OPvPCapturePointEP_EWT::SendChangePhase()
// send this too, sometimes the slider disappears, dunno why :( // send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1); SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective // send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase); SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes it resets :S // send this too, sometimes it resets :S
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_neutralValuePct); SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
} }
void OPvPCapturePointEP_EWT::FillInitialWorldStates(WorldPacket& data) void OPvPCapturePointEP_EWT::FillInitialWorldStates(WorldPacket& data)
@@ -118,11 +118,11 @@ void OPvPCapturePointEP_EWT::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointEP_EWT::UpdateTowerState() void OPvPCapturePointEP_EWT::UpdateTowerState()
{ {
m_PvP->SendUpdateWorldState(EP_EWT_A, bool(m_TowerState & EP_TS_A)); _pvp->SendUpdateWorldState(EP_EWT_A, bool(m_TowerState & EP_TS_A));
m_PvP->SendUpdateWorldState(EP_EWT_H, bool(m_TowerState & EP_TS_H)); _pvp->SendUpdateWorldState(EP_EWT_H, bool(m_TowerState & EP_TS_H));
m_PvP->SendUpdateWorldState(EP_EWT_N_A, bool(m_TowerState & EP_TS_N_A)); _pvp->SendUpdateWorldState(EP_EWT_N_A, bool(m_TowerState & EP_TS_N_A));
m_PvP->SendUpdateWorldState(EP_EWT_N_H, bool(m_TowerState & EP_TS_N_H)); _pvp->SendUpdateWorldState(EP_EWT_N_H, bool(m_TowerState & EP_TS_N_H));
m_PvP->SendUpdateWorldState(EP_EWT_N, bool(m_TowerState & EP_TS_N)); _pvp->SendUpdateWorldState(EP_EWT_N, bool(m_TowerState & EP_TS_N));
} }
bool OPvPCapturePointEP_EWT::HandlePlayerEnter(Player* player) bool OPvPCapturePointEP_EWT::HandlePlayerEnter(Player* player)
@@ -130,9 +130,9 @@ bool OPvPCapturePointEP_EWT::HandlePlayerEnter(Player* player)
if (OPvPCapturePoint::HandlePlayerEnter(player)) if (OPvPCapturePoint::HandlePlayerEnter(player))
{ {
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_neutralValuePct); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
return true; return true;
} }
return false; return false;
@@ -170,34 +170,34 @@ OPvPCapturePointEP_NPT::OPvPCapturePointEP_NPT(OutdoorPvP* pvp)
void OPvPCapturePointEP_NPT::ChangeState() void OPvPCapturePointEP_NPT::ChangeState()
{ {
// if changing from controlling alliance to horde or vice versa // if changing from controlling alliance to horde or vice versa
if ( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State ) if ( _oldState == OBJECTIVESTATE_ALLIANCE && _oldState != _state )
{ {
sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_NPT_A)); sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_NPT_A));
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_NPT, TEAM_NEUTRAL); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_NPT, TEAM_NEUTRAL);
} }
else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State ) else if ( _oldState == OBJECTIVESTATE_HORDE && _oldState != _state )
{ {
sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_NPT_H)); sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_NPT_H));
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_NPT, TEAM_NEUTRAL); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_NPT, TEAM_NEUTRAL);
} }
uint32 artkit = 21; uint32 artkit = 21;
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_ALLIANCE: case OBJECTIVESTATE_ALLIANCE:
m_TowerState = EP_TS_A; m_TowerState = EP_TS_A;
artkit = 2; artkit = 2;
SummonGO(TEAM_ALLIANCE); SummonGO(TEAM_ALLIANCE);
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_NPT, TEAM_ALLIANCE); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_NPT, TEAM_ALLIANCE);
if (m_OldState != m_State) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_A)); if (_oldState != _state) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_A));
break; break;
case OBJECTIVESTATE_HORDE: case OBJECTIVESTATE_HORDE:
m_TowerState = EP_TS_H; m_TowerState = EP_TS_H;
artkit = 1; artkit = 1;
SummonGO(TEAM_HORDE); SummonGO(TEAM_HORDE);
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_NPT, TEAM_HORDE); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_NPT, TEAM_HORDE);
if (m_OldState != m_State) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_H)); if (_oldState != _state) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_H));
break; break;
case OBJECTIVESTATE_NEUTRAL: case OBJECTIVESTATE_NEUTRAL:
m_TowerState = EP_TS_N; m_TowerState = EP_TS_N;
@@ -227,7 +227,7 @@ void OPvPCapturePointEP_NPT::ChangeState()
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit); itr->second->SetGoArtKit(artkit);
bounds = map->GetGameObjectBySpawnIdStore().equal_range(m_Objects[EP_NPT_FLAGS]); bounds = map->GetGameObjectBySpawnIdStore().equal_range(_objects[EP_NPT_FLAGS]);
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit); itr->second->SetGoArtKit(artkit);
@@ -243,10 +243,10 @@ void OPvPCapturePointEP_NPT::SendChangePhase()
// send this too, sometimes the slider disappears, dunno why :( // send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1); SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective // send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase); SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes it resets :S // send this too, sometimes it resets :S
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_neutralValuePct); SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
} }
void OPvPCapturePointEP_NPT::FillInitialWorldStates(WorldPacket& data) void OPvPCapturePointEP_NPT::FillInitialWorldStates(WorldPacket& data)
@@ -260,11 +260,11 @@ void OPvPCapturePointEP_NPT::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointEP_NPT::UpdateTowerState() void OPvPCapturePointEP_NPT::UpdateTowerState()
{ {
m_PvP->SendUpdateWorldState(EP_NPT_A, bool(m_TowerState & EP_TS_A)); _pvp->SendUpdateWorldState(EP_NPT_A, bool(m_TowerState & EP_TS_A));
m_PvP->SendUpdateWorldState(EP_NPT_H, bool(m_TowerState & EP_TS_H)); _pvp->SendUpdateWorldState(EP_NPT_H, bool(m_TowerState & EP_TS_H));
m_PvP->SendUpdateWorldState(EP_NPT_N_A, bool(m_TowerState & EP_TS_N_A)); _pvp->SendUpdateWorldState(EP_NPT_N_A, bool(m_TowerState & EP_TS_N_A));
m_PvP->SendUpdateWorldState(EP_NPT_N_H, bool(m_TowerState & EP_TS_N_H)); _pvp->SendUpdateWorldState(EP_NPT_N_H, bool(m_TowerState & EP_TS_N_H));
m_PvP->SendUpdateWorldState(EP_NPT_N, bool(m_TowerState & EP_TS_N)); _pvp->SendUpdateWorldState(EP_NPT_N, bool(m_TowerState & EP_TS_N));
} }
bool OPvPCapturePointEP_NPT::HandlePlayerEnter(Player* player) bool OPvPCapturePointEP_NPT::HandlePlayerEnter(Player* player)
@@ -272,9 +272,9 @@ bool OPvPCapturePointEP_NPT::HandlePlayerEnter(Player* player)
if (OPvPCapturePoint::HandlePlayerEnter(player)) if (OPvPCapturePoint::HandlePlayerEnter(player))
{ {
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_neutralValuePct); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
return true; return true;
} }
return false; return false;
@@ -294,7 +294,7 @@ void OPvPCapturePointEP_NPT::SummonGO(TeamId teamId)
DelObject(EP_NPT_BUFF); DelObject(EP_NPT_BUFF);
AddObject(EP_NPT_BUFF, EP_NPT_LordaeronShrine.entry, EP_NPT_LordaeronShrine.map, EP_NPT_LordaeronShrine.x, EP_NPT_LordaeronShrine.y, EP_NPT_LordaeronShrine.z, EP_NPT_LordaeronShrine.o, EP_NPT_LordaeronShrine.rot0, EP_NPT_LordaeronShrine.rot1, EP_NPT_LordaeronShrine.rot2, EP_NPT_LordaeronShrine.rot3); AddObject(EP_NPT_BUFF, EP_NPT_LordaeronShrine.entry, EP_NPT_LordaeronShrine.map, EP_NPT_LordaeronShrine.x, EP_NPT_LordaeronShrine.y, EP_NPT_LordaeronShrine.z, EP_NPT_LordaeronShrine.o, EP_NPT_LordaeronShrine.rot0, EP_NPT_LordaeronShrine.rot1, EP_NPT_LordaeronShrine.rot2, EP_NPT_LordaeronShrine.rot3);
Map* map = sMapMgr->FindMap(0, 0); Map* map = sMapMgr->FindMap(0, 0);
auto bounds = map->GetGameObjectBySpawnIdStore().equal_range(m_Objects[EP_NPT_BUFF]); auto bounds = map->GetGameObjectBySpawnIdStore().equal_range(_objects[EP_NPT_BUFF]);
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
if (GameObject* go = itr->second) if (GameObject* go = itr->second)
go->SetUInt32Value(GAMEOBJECT_FACTION, (teamId == TEAM_ALLIANCE ? 84 : 83)); go->SetUInt32Value(GAMEOBJECT_FACTION, (teamId == TEAM_ALLIANCE ? 84 : 83));
@@ -312,34 +312,34 @@ OPvPCapturePointEP_CGT::OPvPCapturePointEP_CGT(OutdoorPvP* pvp)
void OPvPCapturePointEP_CGT::ChangeState() void OPvPCapturePointEP_CGT::ChangeState()
{ {
// if changing from controlling alliance to horde or vice versa // if changing from controlling alliance to horde or vice versa
if ( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State ) if ( _oldState == OBJECTIVESTATE_ALLIANCE && _oldState != _state )
{ {
sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_CGT_A)); sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_CGT_A));
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_CGT, TEAM_NEUTRAL); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_CGT, TEAM_NEUTRAL);
} }
else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State ) else if ( _oldState == OBJECTIVESTATE_HORDE && _oldState != _state )
{ {
sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_CGT_H)); sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_CGT_H));
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_CGT, TEAM_NEUTRAL); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_CGT, TEAM_NEUTRAL);
} }
uint32 artkit = 21; uint32 artkit = 21;
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_ALLIANCE: case OBJECTIVESTATE_ALLIANCE:
m_TowerState = EP_TS_A; m_TowerState = EP_TS_A;
artkit = 2; artkit = 2;
LinkGraveyard(TEAM_ALLIANCE); LinkGraveyard(TEAM_ALLIANCE);
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_CGT, TEAM_ALLIANCE); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_CGT, TEAM_ALLIANCE);
if (m_OldState != m_State) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_A)); if (_oldState != _state) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_A));
break; break;
case OBJECTIVESTATE_HORDE: case OBJECTIVESTATE_HORDE:
m_TowerState = EP_TS_H; m_TowerState = EP_TS_H;
artkit = 1; artkit = 1;
LinkGraveyard(TEAM_HORDE); LinkGraveyard(TEAM_HORDE);
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_CGT, TEAM_HORDE); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_CGT, TEAM_HORDE);
if (m_OldState != m_State) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_H)); if (_oldState != _state) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_H));
break; break;
case OBJECTIVESTATE_NEUTRAL: case OBJECTIVESTATE_NEUTRAL:
m_TowerState = EP_TS_N; m_TowerState = EP_TS_N;
@@ -359,7 +359,7 @@ void OPvPCapturePointEP_CGT::ChangeState()
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit); itr->second->SetGoArtKit(artkit);
bounds = map->GetGameObjectBySpawnIdStore().equal_range(m_Objects[EP_CGT_FLAGS]); bounds = map->GetGameObjectBySpawnIdStore().equal_range(_objects[EP_CGT_FLAGS]);
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit); itr->second->SetGoArtKit(artkit);
@@ -375,10 +375,10 @@ void OPvPCapturePointEP_CGT::SendChangePhase()
// send this too, sometimes the slider disappears, dunno why :( // send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1); SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective // send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase); SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes it resets :S // send this too, sometimes it resets :S
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_neutralValuePct); SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
} }
void OPvPCapturePointEP_CGT::FillInitialWorldStates(WorldPacket& data) void OPvPCapturePointEP_CGT::FillInitialWorldStates(WorldPacket& data)
@@ -392,11 +392,11 @@ void OPvPCapturePointEP_CGT::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointEP_CGT::UpdateTowerState() void OPvPCapturePointEP_CGT::UpdateTowerState()
{ {
m_PvP->SendUpdateWorldState(EP_CGT_A, bool(m_TowerState & EP_TS_A)); _pvp->SendUpdateWorldState(EP_CGT_A, bool(m_TowerState & EP_TS_A));
m_PvP->SendUpdateWorldState(EP_CGT_H, bool(m_TowerState & EP_TS_H)); _pvp->SendUpdateWorldState(EP_CGT_H, bool(m_TowerState & EP_TS_H));
m_PvP->SendUpdateWorldState(EP_CGT_N_A, bool(m_TowerState & EP_TS_N_A)); _pvp->SendUpdateWorldState(EP_CGT_N_A, bool(m_TowerState & EP_TS_N_A));
m_PvP->SendUpdateWorldState(EP_CGT_N_H, bool(m_TowerState & EP_TS_N_H)); _pvp->SendUpdateWorldState(EP_CGT_N_H, bool(m_TowerState & EP_TS_N_H));
m_PvP->SendUpdateWorldState(EP_CGT_N, bool(m_TowerState & EP_TS_N)); _pvp->SendUpdateWorldState(EP_CGT_N, bool(m_TowerState & EP_TS_N));
} }
bool OPvPCapturePointEP_CGT::HandlePlayerEnter(Player* player) bool OPvPCapturePointEP_CGT::HandlePlayerEnter(Player* player)
@@ -404,9 +404,9 @@ bool OPvPCapturePointEP_CGT::HandlePlayerEnter(Player* player)
if (OPvPCapturePoint::HandlePlayerEnter(player)) if (OPvPCapturePoint::HandlePlayerEnter(player))
{ {
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_neutralValuePct); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
return true; return true;
} }
return false; return false;
@@ -439,34 +439,34 @@ OPvPCapturePointEP_PWT::OPvPCapturePointEP_PWT(OutdoorPvP* pvp)
void OPvPCapturePointEP_PWT::ChangeState() void OPvPCapturePointEP_PWT::ChangeState()
{ {
// if changing from controlling alliance to horde or vice versa // if changing from controlling alliance to horde or vice versa
if ( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State ) if ( _oldState == OBJECTIVESTATE_ALLIANCE && _oldState != _state )
{ {
sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_PWT_A)); sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_PWT_A));
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_PWT, TEAM_NEUTRAL); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_PWT, TEAM_NEUTRAL);
} }
else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State ) else if ( _oldState == OBJECTIVESTATE_HORDE && _oldState != _state )
{ {
sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_PWT_H)); sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_PWT_H));
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_PWT, TEAM_NEUTRAL); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_PWT, TEAM_NEUTRAL);
} }
uint32 artkit = 21; uint32 artkit = 21;
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_ALLIANCE: case OBJECTIVESTATE_ALLIANCE:
m_TowerState = EP_TS_A; m_TowerState = EP_TS_A;
SummonFlightMaster(TEAM_ALLIANCE); SummonFlightMaster(TEAM_ALLIANCE);
artkit = 2; artkit = 2;
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_PWT, TEAM_ALLIANCE); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_PWT, TEAM_ALLIANCE);
if (m_OldState != m_State) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_A)); if (_oldState != _state) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_A));
break; break;
case OBJECTIVESTATE_HORDE: case OBJECTIVESTATE_HORDE:
m_TowerState = EP_TS_H; m_TowerState = EP_TS_H;
SummonFlightMaster(TEAM_HORDE); SummonFlightMaster(TEAM_HORDE);
artkit = 1; artkit = 1;
((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_PWT, TEAM_HORDE); ((OutdoorPvPEP*)_pvp)->SetControlledState(EP_PWT, TEAM_HORDE);
if (m_OldState != m_State) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_H)); if (_oldState != _state) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_H));
break; break;
case OBJECTIVESTATE_NEUTRAL: case OBJECTIVESTATE_NEUTRAL:
m_TowerState = EP_TS_N; m_TowerState = EP_TS_N;
@@ -496,7 +496,7 @@ void OPvPCapturePointEP_PWT::ChangeState()
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit); itr->second->SetGoArtKit(artkit);
bounds = map->GetGameObjectBySpawnIdStore().equal_range(m_Objects[EP_PWT_FLAGS]); bounds = map->GetGameObjectBySpawnIdStore().equal_range(_objects[EP_PWT_FLAGS]);
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit); itr->second->SetGoArtKit(artkit);
@@ -512,10 +512,10 @@ void OPvPCapturePointEP_PWT::SendChangePhase()
// send this too, sometimes the slider disappears, dunno why :( // send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1); SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective // send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase); SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes it resets :S // send this too, sometimes it resets :S
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_neutralValuePct); SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
} }
void OPvPCapturePointEP_PWT::FillInitialWorldStates(WorldPacket& data) void OPvPCapturePointEP_PWT::FillInitialWorldStates(WorldPacket& data)
@@ -529,11 +529,11 @@ void OPvPCapturePointEP_PWT::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointEP_PWT::UpdateTowerState() void OPvPCapturePointEP_PWT::UpdateTowerState()
{ {
m_PvP->SendUpdateWorldState(EP_PWT_A, bool(m_TowerState & EP_TS_A)); _pvp->SendUpdateWorldState(EP_PWT_A, bool(m_TowerState & EP_TS_A));
m_PvP->SendUpdateWorldState(EP_PWT_H, bool(m_TowerState & EP_TS_H)); _pvp->SendUpdateWorldState(EP_PWT_H, bool(m_TowerState & EP_TS_H));
m_PvP->SendUpdateWorldState(EP_PWT_N_A, bool(m_TowerState & EP_TS_N_A)); _pvp->SendUpdateWorldState(EP_PWT_N_A, bool(m_TowerState & EP_TS_N_A));
m_PvP->SendUpdateWorldState(EP_PWT_N_H, bool(m_TowerState & EP_TS_N_H)); _pvp->SendUpdateWorldState(EP_PWT_N_H, bool(m_TowerState & EP_TS_N_H));
m_PvP->SendUpdateWorldState(EP_PWT_N, bool(m_TowerState & EP_TS_N)); _pvp->SendUpdateWorldState(EP_PWT_N, bool(m_TowerState & EP_TS_N));
} }
bool OPvPCapturePointEP_PWT::HandlePlayerEnter(Player* player) bool OPvPCapturePointEP_PWT::HandlePlayerEnter(Player* player)
@@ -541,9 +541,9 @@ bool OPvPCapturePointEP_PWT::HandlePlayerEnter(Player* player)
if (OPvPCapturePoint::HandlePlayerEnter(player)) if (OPvPCapturePoint::HandlePlayerEnter(player))
{ {
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_neutralValuePct); player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
return true; return true;
} }
return false; return false;
@@ -565,7 +565,7 @@ void OPvPCapturePointEP_PWT::SummonFlightMaster(TeamId teamId)
/* /*
// sky - we need update gso code // sky - we need update gso code
Creature* c = HashMapHolder<Creature>::Find(m_Creatures[EP_PWT_FLIGHTMASTER]); Creature* c = HashMapHolder<Creature>::Find(_creatures[EP_PWT_FLIGHTMASTER]);
//Spawn flight master as friendly to capturing team //Spawn flight master as friendly to capturing team
c->SetUInt32Value(GAMEOBJECT_FACTION, (teamId == TEAM_ALLIANCE ? 55 : 68)); c->SetUInt32Value(GAMEOBJECT_FACTION, (teamId == TEAM_ALLIANCE ? 55 : 68));
if (c) if (c)
@@ -608,7 +608,7 @@ void OPvPCapturePointEP_PWT::SummonFlightMaster(TeamId teamId)
// ep // ep
OutdoorPvPEP::OutdoorPvPEP() OutdoorPvPEP::OutdoorPvPEP()
{ {
m_TypeId = OUTDOOR_PVP_EP; _typeId = OUTDOOR_PVP_EP;
memset(EP_ControlsId, TEAM_NEUTRAL, sizeof(EP_ControlsId)); memset(EP_ControlsId, TEAM_NEUTRAL, sizeof(EP_ControlsId));
m_AllianceTowersControlled = 0; m_AllianceTowersControlled = 0;
m_HordeTowersControlled = 0; m_HordeTowersControlled = 0;
@@ -684,7 +684,7 @@ void OutdoorPvPEP::HandlePlayerLeaveZone(Player* player, uint32 zone)
void OutdoorPvPEP::BuffTeams() void OutdoorPvPEP::BuffTeams()
{ {
for (PlayerSet::iterator itr = m_players[0].begin(); itr != m_players[0].end(); ++itr) for (PlayerSet::iterator itr = _players[0].begin(); itr != _players[0].end(); ++itr)
{ {
if (Player* player = ObjectAccessor::FindPlayer(*itr)) if (Player* player = ObjectAccessor::FindPlayer(*itr))
{ {
@@ -694,7 +694,7 @@ void OutdoorPvPEP::BuffTeams()
player->CastSpell(player, EP_AllianceBuffs[m_AllianceTowersControlled - 1], true); player->CastSpell(player, EP_AllianceBuffs[m_AllianceTowersControlled - 1], true);
} }
} }
for (PlayerSet::iterator itr = m_players[1].begin(); itr != m_players[1].end(); ++itr) for (PlayerSet::iterator itr = _players[1].begin(); itr != _players[1].end(); ++itr)
{ {
if (Player* player = ObjectAccessor::FindPlayer(*itr)) if (Player* player = ObjectAccessor::FindPlayer(*itr))
{ {
@@ -718,7 +718,7 @@ void OutdoorPvPEP::FillInitialWorldStates(WorldPacket& data)
data << EP_UI_TOWER_SLIDER_DISPLAY << uint32(0); data << EP_UI_TOWER_SLIDER_DISPLAY << uint32(0);
data << EP_UI_TOWER_SLIDER_POS << uint32(50); data << EP_UI_TOWER_SLIDER_POS << uint32(50);
data << EP_UI_TOWER_SLIDER_N << uint32(100); data << EP_UI_TOWER_SLIDER_N << uint32(100);
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{ {
itr->second->FillInitialWorldStates(data); itr->second->FillInitialWorldStates(data);
} }
src/server/scripts/OutdoorPvP/OutdoorPvPGH.cpp
+6 -6
View File
@@ -25,7 +25,7 @@
OutdoorPvPGH::OutdoorPvPGH() OutdoorPvPGH::OutdoorPvPGH()
{ {
m_TypeId = OUTDOOR_PVP_GH; _typeId = OUTDOOR_PVP_GH;
} }
bool OutdoorPvPGH::SetupOutdoorPvP() bool OutdoorPvPGH::SetupOutdoorPvP()
@@ -61,9 +61,9 @@ void OPvPCapturePointGH::SendChangePhase()
// send this too, sometimes the slider disappears, dunno why :( // send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(GH_UI_SLIDER_DISPLAY, 1); SendUpdateWorldState(GH_UI_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective // send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(GH_UI_SLIDER_POS, phase); SendUpdateWorldState(GH_UI_SLIDER_POS, phase);
SendUpdateWorldState(GH_UI_SLIDER_N, m_neutralValuePct); SendUpdateWorldState(GH_UI_SLIDER_N, _neutralValuePct);
} }
bool OPvPCapturePointGH::HandlePlayerEnter(Player* player) bool OPvPCapturePointGH::HandlePlayerEnter(Player* player)
@@ -71,9 +71,9 @@ bool OPvPCapturePointGH::HandlePlayerEnter(Player* player)
if (OPvPCapturePoint::HandlePlayerEnter(player)) if (OPvPCapturePoint::HandlePlayerEnter(player))
{ {
player->SendUpdateWorldState(GH_UI_SLIDER_DISPLAY, 1); player->SendUpdateWorldState(GH_UI_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(GH_UI_SLIDER_POS, phase); player->SendUpdateWorldState(GH_UI_SLIDER_POS, phase);
player->SendUpdateWorldState(GH_UI_SLIDER_N, m_neutralValuePct); player->SendUpdateWorldState(GH_UI_SLIDER_N, _neutralValuePct);
return true; return true;
} }
return false; return false;
@@ -88,7 +88,7 @@ void OPvPCapturePointGH::HandlePlayerLeave(Player* player)
void OPvPCapturePointGH::ChangeState() void OPvPCapturePointGH::ChangeState()
{ {
uint32 artkit = 21; uint32 artkit = 21;
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_ALLIANCE: case OBJECTIVESTATE_ALLIANCE:
sGameEventMgr->StopEvent(GH_ALLIANCE_DEFENSE_EVENT); sGameEventMgr->StopEvent(GH_ALLIANCE_DEFENSE_EVENT);
src/server/scripts/OutdoorPvP/OutdoorPvPHP.cpp
+21 -21
View File
@@ -62,7 +62,7 @@ OPvPCapturePointHP::OPvPCapturePointHP(OutdoorPvP* pvp, OutdoorPvPHPTowerType ty
OutdoorPvPHP::OutdoorPvPHP() OutdoorPvPHP::OutdoorPvPHP()
{ {
m_TypeId = OUTDOOR_PVP_HP; _typeId = OUTDOOR_PVP_HP;
m_AllianceTowersControlled = 0; m_AllianceTowersControlled = 0;
m_HordeTowersControlled = 0; m_HordeTowersControlled = 0;
} }
@@ -162,7 +162,7 @@ void OutdoorPvPHP::FillInitialWorldStates(WorldPacket& data)
data << uint32(HP_UI_TOWER_SLIDER_DISPLAY) << uint32(0); data << uint32(HP_UI_TOWER_SLIDER_DISPLAY) << uint32(0);
data << uint32(HP_UI_TOWER_SLIDER_POS) << uint32(50); data << uint32(HP_UI_TOWER_SLIDER_POS) << uint32(50);
data << uint32(HP_UI_TOWER_SLIDER_N) << uint32(100); data << uint32(HP_UI_TOWER_SLIDER_N) << uint32(100);
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{ {
itr->second->FillInitialWorldStates(data); itr->second->FillInitialWorldStates(data);
} }
@@ -171,21 +171,21 @@ void OutdoorPvPHP::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointHP::ChangeState() void OPvPCapturePointHP::ChangeState()
{ {
uint32 field = 0; uint32 field = 0;
switch (m_OldState) switch (_oldState)
{ {
case OBJECTIVESTATE_NEUTRAL: case OBJECTIVESTATE_NEUTRAL:
field = HP_MAP_N[m_TowerType]; field = HP_MAP_N[m_TowerType];
break; break;
case OBJECTIVESTATE_ALLIANCE: case OBJECTIVESTATE_ALLIANCE:
field = HP_MAP_A[m_TowerType]; field = HP_MAP_A[m_TowerType];
if (uint32 alliance_towers = ((OutdoorPvPHP*)m_PvP)->GetAllianceTowersControlled()) if (uint32 alliance_towers = ((OutdoorPvPHP*)_pvp)->GetAllianceTowersControlled())
((OutdoorPvPHP*)m_PvP)->SetAllianceTowersControlled(--alliance_towers); ((OutdoorPvPHP*)_pvp)->SetAllianceTowersControlled(--alliance_towers);
sWorld->SendZoneText(OutdoorPvPHPBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(HP_LANG_LOSE_A[m_TowerType])); sWorld->SendZoneText(OutdoorPvPHPBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(HP_LANG_LOSE_A[m_TowerType]));
break; break;
case OBJECTIVESTATE_HORDE: case OBJECTIVESTATE_HORDE:
field = HP_MAP_H[m_TowerType]; field = HP_MAP_H[m_TowerType];
if (uint32 horde_towers = ((OutdoorPvPHP*)m_PvP)->GetHordeTowersControlled()) if (uint32 horde_towers = ((OutdoorPvPHP*)_pvp)->GetHordeTowersControlled())
((OutdoorPvPHP*)m_PvP)->SetHordeTowersControlled(--horde_towers); ((OutdoorPvPHP*)_pvp)->SetHordeTowersControlled(--horde_towers);
sWorld->SendZoneText(OutdoorPvPHPBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(HP_LANG_LOSE_H[m_TowerType])); sWorld->SendZoneText(OutdoorPvPHPBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(HP_LANG_LOSE_H[m_TowerType]));
break; break;
case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE: case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
@@ -205,12 +205,12 @@ void OPvPCapturePointHP::ChangeState()
// send world state update // send world state update
if (field) if (field)
{ {
m_PvP->SendUpdateWorldState(field, 0); _pvp->SendUpdateWorldState(field, 0);
field = 0; field = 0;
} }
uint32 artkit = 21; uint32 artkit = 21;
uint32 artkit2 = HP_TowerArtKit_N[m_TowerType]; uint32 artkit2 = HP_TowerArtKit_N[m_TowerType];
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_NEUTRAL: case OBJECTIVESTATE_NEUTRAL:
field = HP_MAP_N[m_TowerType]; field = HP_MAP_N[m_TowerType];
@@ -220,9 +220,9 @@ void OPvPCapturePointHP::ChangeState()
field = HP_MAP_A[m_TowerType]; field = HP_MAP_A[m_TowerType];
artkit = 2; artkit = 2;
artkit2 = HP_TowerArtKit_A[m_TowerType]; artkit2 = HP_TowerArtKit_A[m_TowerType];
uint32 alliance_towers = ((OutdoorPvPHP*)m_PvP)->GetAllianceTowersControlled(); uint32 alliance_towers = ((OutdoorPvPHP*)_pvp)->GetAllianceTowersControlled();
if (alliance_towers < 3) if (alliance_towers < 3)
((OutdoorPvPHP*)m_PvP)->SetAllianceTowersControlled(++alliance_towers); ((OutdoorPvPHP*)_pvp)->SetAllianceTowersControlled(++alliance_towers);
sWorld->SendZoneText(OutdoorPvPHPBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(HP_LANG_CAPTURE_A[m_TowerType])); sWorld->SendZoneText(OutdoorPvPHPBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(HP_LANG_CAPTURE_A[m_TowerType]));
break; break;
} }
@@ -231,9 +231,9 @@ void OPvPCapturePointHP::ChangeState()
field = HP_MAP_H[m_TowerType]; field = HP_MAP_H[m_TowerType];
artkit = 1; artkit = 1;
artkit2 = HP_TowerArtKit_H[m_TowerType]; artkit2 = HP_TowerArtKit_H[m_TowerType];
uint32 horde_towers = ((OutdoorPvPHP*)m_PvP)->GetHordeTowersControlled(); uint32 horde_towers = ((OutdoorPvPHP*)_pvp)->GetHordeTowersControlled();
if (horde_towers < 3) if (horde_towers < 3)
((OutdoorPvPHP*)m_PvP)->SetHordeTowersControlled(++horde_towers); ((OutdoorPvPHP*)_pvp)->SetHordeTowersControlled(++horde_towers);
sWorld->SendZoneText(OutdoorPvPHPBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(HP_LANG_CAPTURE_H[m_TowerType])); sWorld->SendZoneText(OutdoorPvPHPBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(HP_LANG_CAPTURE_H[m_TowerType]));
break; break;
} }
@@ -250,24 +250,24 @@ void OPvPCapturePointHP::ChangeState()
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit); itr->second->SetGoArtKit(artkit);
bounds = map->GetGameObjectBySpawnIdStore().equal_range(m_Objects[m_TowerType]); bounds = map->GetGameObjectBySpawnIdStore().equal_range(_objects[m_TowerType]);
for (auto itr = bounds.first; itr != bounds.second; ++itr) for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit2); itr->second->SetGoArtKit(artkit2);
// send world state update // send world state update
if (field) if (field)
m_PvP->SendUpdateWorldState(field, 1); _pvp->SendUpdateWorldState(field, 1);
// complete quest objective // complete quest objective
if (m_State == OBJECTIVESTATE_ALLIANCE || m_State == OBJECTIVESTATE_HORDE) if (_state == OBJECTIVESTATE_ALLIANCE || _state == OBJECTIVESTATE_HORDE)
SendObjectiveComplete(HP_CREDITMARKER[m_TowerType]); SendObjectiveComplete(HP_CREDITMARKER[m_TowerType]);
} }
void OPvPCapturePointHP::SendChangePhase() void OPvPCapturePointHP::SendChangePhase()
{ {
SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, m_neutralValuePct); SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, _neutralValuePct);
// send these updates to only the ones in this objective // send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, phase); SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes the slider disappears, dunno why :( // send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1); SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1);
@@ -275,7 +275,7 @@ void OPvPCapturePointHP::SendChangePhase()
void OPvPCapturePointHP::FillInitialWorldStates(WorldPacket& data) void OPvPCapturePointHP::FillInitialWorldStates(WorldPacket& data)
{ {
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_ALLIANCE: case OBJECTIVESTATE_ALLIANCE:
case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE: case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
@@ -305,9 +305,9 @@ bool OPvPCapturePointHP::HandlePlayerEnter(Player* player)
if (OPvPCapturePoint::HandlePlayerEnter(player)) if (OPvPCapturePoint::HandlePlayerEnter(player))
{ {
player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1); player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, phase); player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, m_neutralValuePct); player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, _neutralValuePct);
return true; return true;
} }
return false; return false;
src/server/scripts/OutdoorPvP/OutdoorPvPNA.cpp
+41 -41
View File
@@ -28,7 +28,7 @@
OutdoorPvPNA::OutdoorPvPNA() OutdoorPvPNA::OutdoorPvPNA()
{ {
m_TypeId = OUTDOOR_PVP_NA; _typeId = OUTDOOR_PVP_NA;
m_obj = nullptr; m_obj = nullptr;
} }
@@ -44,7 +44,7 @@ void OutdoorPvPNA::HandleKillImpl(Player* player, Unit* killed)
uint32 OPvPCapturePointNA::GetAliveGuardsCount() uint32 OPvPCapturePointNA::GetAliveGuardsCount()
{ {
uint32 cnt = 0; uint32 cnt = 0;
for (std::map<uint32, ObjectGuid::LowType>::iterator itr = m_Creatures.begin(); itr != m_Creatures.end(); ++itr) for (auto itr = _creatures.begin(); itr != _creatures.end(); ++itr)
{ {
switch (itr->first) switch (itr->first)
{ {
@@ -64,7 +64,7 @@ uint32 OPvPCapturePointNA::GetAliveGuardsCount()
case NA_NPC_GUARD_14: case NA_NPC_GUARD_14:
case NA_NPC_GUARD_15: case NA_NPC_GUARD_15:
{ {
auto bounds = m_PvP->GetMap()->GetCreatureBySpawnIdStore().equal_range(itr->second); auto bounds = _pvp->GetMap()->GetCreatureBySpawnIdStore().equal_range(itr->second);
for (auto itr2 = bounds.first; itr2 != bounds.second; ++itr2) for (auto itr2 = bounds.first; itr2 != bounds.second; ++itr2)
if (itr2->second->IsAlive()) if (itr2->second->IsAlive())
++cnt; ++cnt;
@@ -158,10 +158,10 @@ void OPvPCapturePointNA::FactionTakeOver(TeamId teamId)
m_WyvernStateNorth = WYVERN_NEU_HORDE; m_WyvernStateNorth = WYVERN_NEU_HORDE;
m_WyvernStateEast = WYVERN_NEU_HORDE; m_WyvernStateEast = WYVERN_NEU_HORDE;
m_WyvernStateWest = WYVERN_NEU_HORDE; m_WyvernStateWest = WYVERN_NEU_HORDE;
m_PvP->TeamApplyBuff(TEAM_ALLIANCE, NA_CAPTURE_BUFF); _pvp->TeamApplyBuff(TEAM_ALLIANCE, NA_CAPTURE_BUFF);
m_PvP->SendUpdateWorldState(NA_UI_HORDE_GUARDS_SHOW, 0); _pvp->SendUpdateWorldState(NA_UI_HORDE_GUARDS_SHOW, 0);
m_PvP->SendUpdateWorldState(NA_UI_ALLIANCE_GUARDS_SHOW, 1); _pvp->SendUpdateWorldState(NA_UI_ALLIANCE_GUARDS_SHOW, 1);
m_PvP->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive); _pvp->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive);
sWorld->SendZoneText(NA_HALAA_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_NA_CAPTURE_A)); sWorld->SendZoneText(NA_HALAA_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_NA_CAPTURE_A));
} }
else else
@@ -170,10 +170,10 @@ void OPvPCapturePointNA::FactionTakeOver(TeamId teamId)
m_WyvernStateNorth = WYVERN_NEU_ALLIANCE; m_WyvernStateNorth = WYVERN_NEU_ALLIANCE;
m_WyvernStateEast = WYVERN_NEU_ALLIANCE; m_WyvernStateEast = WYVERN_NEU_ALLIANCE;
m_WyvernStateWest = WYVERN_NEU_ALLIANCE; m_WyvernStateWest = WYVERN_NEU_ALLIANCE;
m_PvP->TeamApplyBuff(TEAM_HORDE, NA_CAPTURE_BUFF); _pvp->TeamApplyBuff(TEAM_HORDE, NA_CAPTURE_BUFF);
m_PvP->SendUpdateWorldState(NA_UI_HORDE_GUARDS_SHOW, 1); _pvp->SendUpdateWorldState(NA_UI_HORDE_GUARDS_SHOW, 1);
m_PvP->SendUpdateWorldState(NA_UI_ALLIANCE_GUARDS_SHOW, 0); _pvp->SendUpdateWorldState(NA_UI_ALLIANCE_GUARDS_SHOW, 0);
m_PvP->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive); _pvp->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive);
sWorld->SendZoneText(NA_HALAA_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_NA_CAPTURE_H)); sWorld->SendZoneText(NA_HALAA_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_NA_CAPTURE_H));
} }
UpdateWyvernRoostWorldState(NA_ROOST_S); UpdateWyvernRoostWorldState(NA_ROOST_S);
@@ -187,9 +187,9 @@ bool OPvPCapturePointNA::HandlePlayerEnter(Player* player)
if (OPvPCapturePoint::HandlePlayerEnter(player)) if (OPvPCapturePoint::HandlePlayerEnter(player))
{ {
player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 1); player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_POS, phase); player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_N, m_neutralValuePct); player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_N, _neutralValuePct);
return true; return true;
} }
return false; return false;
@@ -211,7 +211,7 @@ OPvPCapturePointNA::OPvPCapturePointNA(OutdoorPvP* pvp) :
bool OutdoorPvPNA::SetupOutdoorPvP() bool OutdoorPvPNA::SetupOutdoorPvP()
{ {
// m_TypeId = OUTDOOR_PVP_NA; _MUST_ be set in ctor, because of spawns cleanup // _typeId = OUTDOOR_PVP_NA; _MUST_ be set in ctor, because of spawns cleanup
// add the zones affected by the pvp buff // add the zones affected by the pvp buff
RegisterZone(NA_BUFF_ZONE); RegisterZone(NA_BUFF_ZONE);
SetMapFromZone(NA_BUFF_ZONE); SetMapFromZone(NA_BUFF_ZONE);
@@ -535,9 +535,9 @@ bool OPvPCapturePointNA::Update(uint32 diff)
{ {
// let the controlling faction advance in phase // let the controlling faction advance in phase
bool capturable = false; bool capturable = false;
if (m_ControllingFaction == TEAM_ALLIANCE && m_activePlayers[0].size() > m_activePlayers[1].size()) if (m_ControllingFaction == TEAM_ALLIANCE && _activePlayers[0].size() > _activePlayers[1].size())
capturable = true; capturable = true;
else if (m_ControllingFaction == TEAM_HORDE && m_activePlayers[0].size() < m_activePlayers[1].size()) else if (m_ControllingFaction == TEAM_HORDE && _activePlayers[0].size() < _activePlayers[1].size())
capturable = true; capturable = true;
if (m_GuardCheckTimer < diff) if (m_GuardCheckTimer < diff)
@@ -550,7 +550,7 @@ bool OPvPCapturePointNA::Update(uint32 diff)
if (m_GuardsAlive == 0) if (m_GuardsAlive == 0)
m_capturable = true; m_capturable = true;
// update the guard count for the players in zone // update the guard count for the players in zone
m_PvP->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive); _pvp->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive);
} }
} }
else m_GuardCheckTimer -= diff; else m_GuardCheckTimer -= diff;
@@ -573,7 +573,7 @@ bool OPvPCapturePointNA::Update(uint32 diff)
void OPvPCapturePointNA::ChangeState() void OPvPCapturePointNA::ChangeState()
{ {
uint32 artkit = 21; uint32 artkit = 21;
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_NEUTRAL: case OBJECTIVESTATE_NEUTRAL:
m_HalaaState = HALAA_N; m_HalaaState = HALAA_N;
@@ -616,18 +616,18 @@ void OPvPCapturePointNA::SendChangePhase()
// send this too, sometimes the slider disappears, dunno why :( // send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 1); SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective // send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(NA_UI_TOWER_SLIDER_POS, phase); SendUpdateWorldState(NA_UI_TOWER_SLIDER_POS, phase);
SendUpdateWorldState(NA_UI_TOWER_SLIDER_N, m_neutralValuePct); SendUpdateWorldState(NA_UI_TOWER_SLIDER_N, _neutralValuePct);
} }
void OPvPCapturePointNA::UpdateHalaaWorldState() void OPvPCapturePointNA::UpdateHalaaWorldState()
{ {
m_PvP->SendUpdateWorldState(NA_MAP_HALAA_NEUTRAL, uint32(bool(m_HalaaState & HALAA_N))); _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))); _pvp->SendUpdateWorldState(NA_MAP_HALAA_NEU_A, uint32(bool(m_HalaaState & HALAA_N_A)));
m_PvP->SendUpdateWorldState(NA_MAP_HALAA_NEU_H, uint32(bool(m_HalaaState & HALAA_N_H))); _pvp->SendUpdateWorldState(NA_MAP_HALAA_NEU_H, uint32(bool(m_HalaaState & HALAA_N_H)));
m_PvP->SendUpdateWorldState(NA_MAP_HALAA_HORDE, uint32(bool(m_HalaaState & HALAA_H))); _pvp->SendUpdateWorldState(NA_MAP_HALAA_HORDE, uint32(bool(m_HalaaState & HALAA_H)));
m_PvP->SendUpdateWorldState(NA_MAP_HALAA_ALLIANCE, uint32(bool(m_HalaaState & HALAA_A))); _pvp->SendUpdateWorldState(NA_MAP_HALAA_ALLIANCE, uint32(bool(m_HalaaState & HALAA_A)));
} }
void OPvPCapturePointNA::UpdateWyvernRoostWorldState(uint32 roost) void OPvPCapturePointNA::UpdateWyvernRoostWorldState(uint32 roost)
@@ -635,28 +635,28 @@ void OPvPCapturePointNA::UpdateWyvernRoostWorldState(uint32 roost)
switch (roost) switch (roost)
{ {
case NA_ROOST_S: case NA_ROOST_S:
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_NEU_H, uint32(bool(m_WyvernStateSouth & WYVERN_NEU_HORDE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_NEU_H, uint32(bool(m_WyvernStateSouth & WYVERN_NEU_HORDE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_NEU_A, uint32(bool(m_WyvernStateSouth & WYVERN_NEU_ALLIANCE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_NEU_A, uint32(bool(m_WyvernStateSouth & WYVERN_NEU_ALLIANCE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_H, uint32(bool(m_WyvernStateSouth & WYVERN_HORDE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_H, uint32(bool(m_WyvernStateSouth & WYVERN_HORDE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_A, uint32(bool(m_WyvernStateSouth & WYVERN_ALLIANCE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_A, uint32(bool(m_WyvernStateSouth & WYVERN_ALLIANCE)));
break; break;
case NA_ROOST_N: case NA_ROOST_N:
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_NEU_H, uint32(bool(m_WyvernStateNorth & WYVERN_NEU_HORDE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_NEU_H, uint32(bool(m_WyvernStateNorth & WYVERN_NEU_HORDE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_NEU_A, uint32(bool(m_WyvernStateNorth & WYVERN_NEU_ALLIANCE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_NEU_A, uint32(bool(m_WyvernStateNorth & WYVERN_NEU_ALLIANCE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_H, uint32(bool(m_WyvernStateNorth & WYVERN_HORDE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_H, uint32(bool(m_WyvernStateNorth & WYVERN_HORDE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_A, uint32(bool(m_WyvernStateNorth & WYVERN_ALLIANCE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_A, uint32(bool(m_WyvernStateNorth & WYVERN_ALLIANCE)));
break; break;
case NA_ROOST_W: case NA_ROOST_W:
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_WEST_NEU_H, uint32(bool(m_WyvernStateWest & WYVERN_NEU_HORDE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_WEST_NEU_H, uint32(bool(m_WyvernStateWest & WYVERN_NEU_HORDE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_WEST_NEU_A, uint32(bool(m_WyvernStateWest & WYVERN_NEU_ALLIANCE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_WEST_NEU_A, uint32(bool(m_WyvernStateWest & WYVERN_NEU_ALLIANCE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_WEST_H, uint32(bool(m_WyvernStateWest & WYVERN_HORDE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_WEST_H, uint32(bool(m_WyvernStateWest & WYVERN_HORDE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_WEST_A, uint32(bool(m_WyvernStateWest & WYVERN_ALLIANCE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_WEST_A, uint32(bool(m_WyvernStateWest & WYVERN_ALLIANCE)));
break; break;
case NA_ROOST_E: case NA_ROOST_E:
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_EAST_NEU_H, uint32(bool(m_WyvernStateEast & WYVERN_NEU_HORDE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_EAST_NEU_H, uint32(bool(m_WyvernStateEast & WYVERN_NEU_HORDE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_EAST_NEU_A, uint32(bool(m_WyvernStateEast & WYVERN_NEU_ALLIANCE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_EAST_NEU_A, uint32(bool(m_WyvernStateEast & WYVERN_NEU_ALLIANCE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_EAST_H, uint32(bool(m_WyvernStateEast & WYVERN_HORDE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_EAST_H, uint32(bool(m_WyvernStateEast & WYVERN_HORDE)));
m_PvP->SendUpdateWorldState(NA_MAP_WYVERN_EAST_A, uint32(bool(m_WyvernStateEast & WYVERN_ALLIANCE))); _pvp->SendUpdateWorldState(NA_MAP_WYVERN_EAST_A, uint32(bool(m_WyvernStateEast & WYVERN_ALLIANCE)));
break; break;
} }
} }
src/server/scripts/OutdoorPvP/OutdoorPvPSI.cpp
+1 -1
View File
@@ -30,7 +30,7 @@
OutdoorPvPSI::OutdoorPvPSI() OutdoorPvPSI::OutdoorPvPSI()
{ {
m_TypeId = OUTDOOR_PVP_SI; _typeId = OUTDOOR_PVP_SI;
m_Gathered_A = 0; m_Gathered_A = 0;
m_Gathered_H = 0; m_Gathered_H = 0;
m_LastController = TEAM_NEUTRAL; m_LastController = TEAM_NEUTRAL;
src/server/scripts/OutdoorPvP/OutdoorPvPTF.cpp
+36 -36
View File
@@ -28,7 +28,7 @@
OutdoorPvPTF::OutdoorPvPTF() OutdoorPvPTF::OutdoorPvPTF()
{ {
m_TypeId = OUTDOOR_PVP_TF; _typeId = OUTDOOR_PVP_TF;
m_IsLocked = false; m_IsLocked = false;
m_JustLocked = false; m_JustLocked = false;
@@ -74,7 +74,7 @@ void OutdoorPvPTF::FillInitialWorldStates(WorldPacket& data)
data << TF_UI_LOCKED_DISPLAY_HORDE << uint32(m_IsLocked && (m_HordeTowersControlled > m_AllianceTowersControlled)); 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)); data << TF_UI_LOCKED_DISPLAY_ALLIANCE << uint32(m_IsLocked && (m_HordeTowersControlled < m_AllianceTowersControlled));
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{ {
itr->second->FillInitialWorldStates(data); itr->second->FillInitialWorldStates(data);
} }
@@ -136,7 +136,7 @@ void OutdoorPvPTF::ResetZoneToTeamControlled(TeamId team)
break; break;
} }
for (auto& [guid, tower] : m_capturePoints) for (auto& [guid, tower] : _capturePoints)
{ {
dynamic_cast<OPvPCapturePointTF*>(tower)->ResetToTeamControlled(team); dynamic_cast<OPvPCapturePointTF*>(tower)->ResetToTeamControlled(team);
} }
@@ -150,32 +150,32 @@ void OPvPCapturePointTF::ResetToTeamControlled(TeamId team)
switch (team) switch (team)
{ {
case TEAM_HORDE: case TEAM_HORDE:
m_State = OBJECTIVESTATE_HORDE; _state = OBJECTIVESTATE_HORDE;
m_OldState = OBJECTIVESTATE_HORDE; _oldState = OBJECTIVESTATE_HORDE;
m_team = TEAM_HORDE; _team = TEAM_HORDE;
break; break;
case TEAM_ALLIANCE: case TEAM_ALLIANCE:
m_State = OBJECTIVESTATE_ALLIANCE; _state = OBJECTIVESTATE_ALLIANCE;
m_OldState = OBJECTIVESTATE_ALLIANCE; _oldState = OBJECTIVESTATE_ALLIANCE;
m_team = TEAM_ALLIANCE; _team = TEAM_ALLIANCE;
break; break;
case TEAM_NEUTRAL: case TEAM_NEUTRAL:
m_State = OBJECTIVESTATE_NEUTRAL; _state = OBJECTIVESTATE_NEUTRAL;
m_OldState = OBJECTIVESTATE_NEUTRAL; _oldState = OBJECTIVESTATE_NEUTRAL;
m_team = TEAM_NEUTRAL; _team = TEAM_NEUTRAL;
break; break;
} }
m_value = 0.0f; _value = 0.0f;
ChangeState(); ChangeState();
SendChangePhase(); SendChangePhase();
} }
void OPvPCapturePointTF::UpdateTowerState() void OPvPCapturePointTF::UpdateTowerState()
{ {
m_PvP->SendUpdateWorldState(uint32(TFTowerWorldStates[m_TowerType].n), uint32(bool(m_TowerState & TF_TOWERSTATE_N))); _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))); _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))); _pvp->SendUpdateWorldState(uint32(TFTowerWorldStates[m_TowerType].a), uint32(bool(m_TowerState & TF_TOWERSTATE_A)));
} }
bool OPvPCapturePointTF::HandlePlayerEnter(Player* player) bool OPvPCapturePointTF::HandlePlayerEnter(Player* player)
@@ -183,9 +183,9 @@ bool OPvPCapturePointTF::HandlePlayerEnter(Player* player)
if (OPvPCapturePoint::HandlePlayerEnter(player)) if (OPvPCapturePoint::HandlePlayerEnter(player))
{ {
player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 1); player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, phase); player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_N, m_neutralValuePct); player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_N, _neutralValuePct);
return true; return true;
} }
return false; return false;
@@ -382,45 +382,45 @@ bool OutdoorPvPTF::SetupOutdoorPvP()
bool OPvPCapturePointTF::Update(uint32 diff) bool OPvPCapturePointTF::Update(uint32 diff)
{ {
// can update even in locked state if gathers the controlling faction // can update even in locked state if gathers the controlling faction
bool canupdate = ((((OutdoorPvPTF*)m_PvP)->GetAllianceTowersControlled() > 0) && m_activePlayers[0].size() > m_activePlayers[1].size()) || bool canupdate = ((((OutdoorPvPTF*)_pvp)->GetAllianceTowersControlled() > 0) && _activePlayers[0].size() > _activePlayers[1].size()) ||
((((OutdoorPvPTF*)m_PvP)->GetHordeTowersControlled() > 0) && m_activePlayers[0].size() < m_activePlayers[1].size()); ((((OutdoorPvPTF*)_pvp)->GetHordeTowersControlled() > 0) && _activePlayers[0].size() < _activePlayers[1].size());
// if gathers the other faction, then only update if the pvp is unlocked // if gathers the other faction, then only update if the pvp is unlocked
canupdate = canupdate || !((OutdoorPvPTF*)m_PvP)->IsLocked(); canupdate = canupdate || !((OutdoorPvPTF*)_pvp)->IsLocked();
return canupdate && OPvPCapturePoint::Update(diff); return canupdate && OPvPCapturePoint::Update(diff);
} }
void OPvPCapturePointTF::ChangeState() void OPvPCapturePointTF::ChangeState()
{ {
// if changing from controlling alliance to horde // if changing from controlling alliance to horde
if (m_OldState == OBJECTIVESTATE_ALLIANCE) if (_oldState == OBJECTIVESTATE_ALLIANCE)
{ {
if (uint32 alliance_towers = ((OutdoorPvPTF*)m_PvP)->GetAllianceTowersControlled()) if (uint32 alliance_towers = ((OutdoorPvPTF*)_pvp)->GetAllianceTowersControlled())
((OutdoorPvPTF*)m_PvP)->SetAllianceTowersControlled(--alliance_towers); ((OutdoorPvPTF*)_pvp)->SetAllianceTowersControlled(--alliance_towers);
sWorld->SendZoneText(OutdoorPvPTFBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_TF_LOSE_A)); sWorld->SendZoneText(OutdoorPvPTFBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_TF_LOSE_A));
} }
// if changing from controlling horde to alliance // if changing from controlling horde to alliance
else if (m_OldState == OBJECTIVESTATE_HORDE) else if (_oldState == OBJECTIVESTATE_HORDE)
{ {
if (uint32 horde_towers = ((OutdoorPvPTF*)m_PvP)->GetHordeTowersControlled()) if (uint32 horde_towers = ((OutdoorPvPTF*)_pvp)->GetHordeTowersControlled())
((OutdoorPvPTF*)m_PvP)->SetHordeTowersControlled(--horde_towers); ((OutdoorPvPTF*)_pvp)->SetHordeTowersControlled(--horde_towers);
sWorld->SendZoneText(OutdoorPvPTFBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_TF_LOSE_H)); sWorld->SendZoneText(OutdoorPvPTFBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_TF_LOSE_H));
} }
uint32 artkit = 21; uint32 artkit = 21;
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_ALLIANCE: case OBJECTIVESTATE_ALLIANCE:
{ {
m_TowerState = TF_TOWERSTATE_A; m_TowerState = TF_TOWERSTATE_A;
artkit = 2; artkit = 2;
uint32 alliance_towers = ((OutdoorPvPTF*)m_PvP)->GetAllianceTowersControlled(); uint32 alliance_towers = ((OutdoorPvPTF*)_pvp)->GetAllianceTowersControlled();
if (alliance_towers < TF_TOWER_NUM) if (alliance_towers < TF_TOWER_NUM)
((OutdoorPvPTF*)m_PvP)->SetAllianceTowersControlled(++alliance_towers); ((OutdoorPvPTF*)_pvp)->SetAllianceTowersControlled(++alliance_towers);
sWorld->SendZoneText(OutdoorPvPTFBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_TF_CAPTURE_A)); sWorld->SendZoneText(OutdoorPvPTFBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_TF_CAPTURE_A));
for (PlayerSet::iterator itr = m_activePlayers[0].begin(); itr != m_activePlayers[0].end(); ++itr) for (PlayerSet::iterator itr = _activePlayers[0].begin(); itr != _activePlayers[0].end(); ++itr)
if (Player* player = ObjectAccessor::FindPlayer(*itr)) if (Player* player = ObjectAccessor::FindPlayer(*itr))
player->AreaExploredOrEventHappens(TF_ALLY_QUEST); player->AreaExploredOrEventHappens(TF_ALLY_QUEST);
break; break;
@@ -429,13 +429,13 @@ void OPvPCapturePointTF::ChangeState()
{ {
m_TowerState = TF_TOWERSTATE_H; m_TowerState = TF_TOWERSTATE_H;
artkit = 1; artkit = 1;
uint32 horde_towers = ((OutdoorPvPTF*)m_PvP)->GetHordeTowersControlled(); uint32 horde_towers = ((OutdoorPvPTF*)_pvp)->GetHordeTowersControlled();
if (horde_towers < TF_TOWER_NUM) if (horde_towers < TF_TOWER_NUM)
((OutdoorPvPTF*)m_PvP)->SetHordeTowersControlled(++horde_towers); ((OutdoorPvPTF*)_pvp)->SetHordeTowersControlled(++horde_towers);
sWorld->SendZoneText(OutdoorPvPTFBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_TF_CAPTURE_H)); sWorld->SendZoneText(OutdoorPvPTFBuffZones[0], sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_TF_CAPTURE_H));
for (PlayerSet::iterator itr = m_activePlayers[1].begin(); itr != m_activePlayers[1].end(); ++itr) for (PlayerSet::iterator itr = _activePlayers[1].begin(); itr != _activePlayers[1].end(); ++itr)
if (Player* player = ObjectAccessor::FindPlayer(*itr)) if (Player* player = ObjectAccessor::FindPlayer(*itr))
player->AreaExploredOrEventHappens(TF_HORDE_QUEST); player->AreaExploredOrEventHappens(TF_HORDE_QUEST);
break; break;
@@ -461,10 +461,10 @@ void OPvPCapturePointTF::SendChangePhase()
// send this too, sometimes the slider disappears, dunno why :( // send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 1); SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective // send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, phase); SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes it resets :S // send this too, sometimes it resets :S
SendUpdateWorldState(TF_UI_TOWER_SLIDER_N, m_neutralValuePct); SendUpdateWorldState(TF_UI_TOWER_SLIDER_N, _neutralValuePct);
} }
class OutdoorPvP_terokkar_forest : public OutdoorPvPScript class OutdoorPvP_terokkar_forest : public OutdoorPvPScript
src/server/scripts/OutdoorPvP/OutdoorPvPZM.cpp
+38 -38
View File
@@ -44,12 +44,12 @@ void OPvPCapturePointZM_Beacon::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointZM_Beacon::UpdateTowerState() void OPvPCapturePointZM_Beacon::UpdateTowerState()
{ {
m_PvP->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].ui_tower_n), uint32(bool(m_TowerState & ZM_TOWERSTATE_N))); _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))); _pvp->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].map_tower_n), uint32(bool(m_TowerState & ZM_TOWERSTATE_N)));
m_PvP->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].ui_tower_a), uint32(bool(m_TowerState & ZM_TOWERSTATE_A))); _pvp->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].ui_tower_a), uint32(bool(m_TowerState & ZM_TOWERSTATE_A)));
m_PvP->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].map_tower_a), uint32(bool(m_TowerState & ZM_TOWERSTATE_A))); _pvp->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].map_tower_a), uint32(bool(m_TowerState & ZM_TOWERSTATE_A)));
m_PvP->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].ui_tower_h), uint32(bool(m_TowerState & ZM_TOWERSTATE_H))); _pvp->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].ui_tower_h), uint32(bool(m_TowerState & ZM_TOWERSTATE_H)));
m_PvP->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].map_tower_h), uint32(bool(m_TowerState & ZM_TOWERSTATE_H))); _pvp->SendUpdateWorldState(uint32(ZMBeaconInfo[m_TowerType].map_tower_h), uint32(bool(m_TowerState & ZM_TOWERSTATE_H)));
} }
bool OPvPCapturePointZM_Beacon::HandlePlayerEnter(Player* player) bool OPvPCapturePointZM_Beacon::HandlePlayerEnter(Player* player)
@@ -57,9 +57,9 @@ bool OPvPCapturePointZM_Beacon::HandlePlayerEnter(Player* player)
if (OPvPCapturePoint::HandlePlayerEnter(player)) if (OPvPCapturePoint::HandlePlayerEnter(player))
{ {
player->SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_disp, 1); player->SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_disp, 1);
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_pos, phase); player->SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_pos, phase);
player->SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_n, m_neutralValuePct); player->SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_n, _neutralValuePct);
return true; return true;
} }
return false; return false;
@@ -74,37 +74,37 @@ void OPvPCapturePointZM_Beacon::HandlePlayerLeave(Player* player)
void OPvPCapturePointZM_Beacon::ChangeState() void OPvPCapturePointZM_Beacon::ChangeState()
{ {
// if changing from controlling alliance to horde // if changing from controlling alliance to horde
if (m_OldState == OBJECTIVESTATE_ALLIANCE) if (_oldState == OBJECTIVESTATE_ALLIANCE)
{ {
if (uint32 alliance_towers = ((OutdoorPvPZM*)m_PvP)->GetAllianceTowersControlled()) if (uint32 alliance_towers = ((OutdoorPvPZM*)_pvp)->GetAllianceTowersControlled())
((OutdoorPvPZM*)m_PvP)->SetAllianceTowersControlled(--alliance_towers); ((OutdoorPvPZM*)_pvp)->SetAllianceTowersControlled(--alliance_towers);
sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(ZMBeaconLoseA[m_TowerType])); sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(ZMBeaconLoseA[m_TowerType]));
} }
// if changing from controlling horde to alliance // if changing from controlling horde to alliance
else if (m_OldState == OBJECTIVESTATE_HORDE) else if (_oldState == OBJECTIVESTATE_HORDE)
{ {
if (uint32 horde_towers = ((OutdoorPvPZM*)m_PvP)->GetHordeTowersControlled()) if (uint32 horde_towers = ((OutdoorPvPZM*)_pvp)->GetHordeTowersControlled())
((OutdoorPvPZM*)m_PvP)->SetHordeTowersControlled(--horde_towers); ((OutdoorPvPZM*)_pvp)->SetHordeTowersControlled(--horde_towers);
sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(ZMBeaconLoseH[m_TowerType])); sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(ZMBeaconLoseH[m_TowerType]));
} }
switch (m_State) switch (_state)
{ {
case OBJECTIVESTATE_ALLIANCE: case OBJECTIVESTATE_ALLIANCE:
{ {
m_TowerState = ZM_TOWERSTATE_A; m_TowerState = ZM_TOWERSTATE_A;
uint32 alliance_towers = ((OutdoorPvPZM*)m_PvP)->GetAllianceTowersControlled(); uint32 alliance_towers = ((OutdoorPvPZM*)_pvp)->GetAllianceTowersControlled();
if (alliance_towers < ZM_NUM_BEACONS) if (alliance_towers < ZM_NUM_BEACONS)
((OutdoorPvPZM*)m_PvP)->SetAllianceTowersControlled(++alliance_towers); ((OutdoorPvPZM*)_pvp)->SetAllianceTowersControlled(++alliance_towers);
sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(ZMBeaconCaptureA[m_TowerType])); sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(ZMBeaconCaptureA[m_TowerType]));
break; break;
} }
case OBJECTIVESTATE_HORDE: case OBJECTIVESTATE_HORDE:
{ {
m_TowerState = ZM_TOWERSTATE_H; m_TowerState = ZM_TOWERSTATE_H;
uint32 horde_towers = ((OutdoorPvPZM*)m_PvP)->GetHordeTowersControlled(); uint32 horde_towers = ((OutdoorPvPZM*)_pvp)->GetHordeTowersControlled();
if (horde_towers < ZM_NUM_BEACONS) if (horde_towers < ZM_NUM_BEACONS)
((OutdoorPvPZM*)m_PvP)->SetHordeTowersControlled(++horde_towers); ((OutdoorPvPZM*)_pvp)->SetHordeTowersControlled(++horde_towers);
sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(ZMBeaconCaptureH[m_TowerType])); sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(ZMBeaconCaptureH[m_TowerType]));
break; break;
} }
@@ -125,9 +125,9 @@ void OPvPCapturePointZM_Beacon::SendChangePhase()
// send this too, sometimes the slider disappears, dunno why :( // send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_disp, 1); SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_disp, 1);
// send these updates to only the ones in this objective // send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f); uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_pos, phase); SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_pos, phase);
SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_n, m_neutralValuePct); SendUpdateWorldState(ZMBeaconInfo[m_TowerType].slider_n, _neutralValuePct);
} }
bool OutdoorPvPZM::Update(uint32 diff) bool OutdoorPvPZM::Update(uint32 diff)
@@ -172,7 +172,7 @@ void OutdoorPvPZM::HandlePlayerLeaveZone(Player* player, uint32 zone)
OutdoorPvPZM::OutdoorPvPZM() OutdoorPvPZM::OutdoorPvPZM()
{ {
m_TypeId = OUTDOOR_PVP_ZM; _typeId = OUTDOOR_PVP_ZM;
m_GraveYard = nullptr; m_GraveYard = nullptr;
m_AllianceTowersControlled = 0; m_AllianceTowersControlled = 0;
m_HordeTowersControlled = 0; m_HordeTowersControlled = 0;
@@ -210,8 +210,8 @@ void OutdoorPvPZM::HandleKillImpl(Player* player, Unit* killed)
bool OPvPCapturePointZM_GraveYard::Update(uint32 /*diff*/) bool OPvPCapturePointZM_GraveYard::Update(uint32 /*diff*/)
{ {
bool retval = m_State != m_OldState; bool retval = _state != _oldState;
m_State = m_OldState; _state = _oldState;
return retval; return retval;
} }
@@ -229,7 +229,7 @@ int32 OPvPCapturePointZM_GraveYard::HandleOpenGo(Player* player, GameObject* go)
AddObject(0, ZM_Banner_A.entry, ZM_Banner_A.map, ZM_Banner_A.x, ZM_Banner_A.y, ZM_Banner_A.z, ZM_Banner_A.o, ZM_Banner_A.rot0, ZM_Banner_A.rot1, ZM_Banner_A.rot2, ZM_Banner_A.rot3); AddObject(0, ZM_Banner_A.entry, ZM_Banner_A.map, ZM_Banner_A.x, ZM_Banner_A.y, ZM_Banner_A.z, ZM_Banner_A.o, ZM_Banner_A.rot0, ZM_Banner_A.rot1, ZM_Banner_A.rot2, ZM_Banner_A.rot3);
sGraveyard->RemoveGraveyardLink(ZM_GRAVEYARD_ID, ZM_GRAVEYARD_ZONE, TEAM_HORDE); // rem gy sGraveyard->RemoveGraveyardLink(ZM_GRAVEYARD_ID, ZM_GRAVEYARD_ZONE, TEAM_HORDE); // rem gy
sGraveyard->AddGraveyardLink(ZM_GRAVEYARD_ID, ZM_GRAVEYARD_ZONE, TEAM_ALLIANCE, false); // add gy sGraveyard->AddGraveyardLink(ZM_GRAVEYARD_ID, ZM_GRAVEYARD_ZONE, TEAM_ALLIANCE, false); // add gy
m_PvP->TeamApplyBuff(TEAM_ALLIANCE, ZM_CAPTURE_BUFF, 0, player); _pvp->TeamApplyBuff(TEAM_ALLIANCE, ZM_CAPTURE_BUFF, 0, player);
player->RemoveAurasDueToSpell(ZM_BATTLE_STANDARD_A); player->RemoveAurasDueToSpell(ZM_BATTLE_STANDARD_A);
sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_ZM_CAPTURE_GY_A)); sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_ZM_CAPTURE_GY_A));
} }
@@ -242,7 +242,7 @@ int32 OPvPCapturePointZM_GraveYard::HandleOpenGo(Player* player, GameObject* go)
AddObject(0, ZM_Banner_H.entry, ZM_Banner_H.map, ZM_Banner_H.x, ZM_Banner_H.y, ZM_Banner_H.z, ZM_Banner_H.o, ZM_Banner_H.rot0, ZM_Banner_H.rot1, ZM_Banner_H.rot2, ZM_Banner_H.rot3); AddObject(0, ZM_Banner_H.entry, ZM_Banner_H.map, ZM_Banner_H.x, ZM_Banner_H.y, ZM_Banner_H.z, ZM_Banner_H.o, ZM_Banner_H.rot0, ZM_Banner_H.rot1, ZM_Banner_H.rot2, ZM_Banner_H.rot3);
sGraveyard->RemoveGraveyardLink(ZM_GRAVEYARD_ID, ZM_GRAVEYARD_ZONE, TEAM_ALLIANCE); // rem gy sGraveyard->RemoveGraveyardLink(ZM_GRAVEYARD_ID, ZM_GRAVEYARD_ZONE, TEAM_ALLIANCE); // rem gy
sGraveyard->AddGraveyardLink(ZM_GRAVEYARD_ID, ZM_GRAVEYARD_ZONE, TEAM_HORDE, false); // add gy sGraveyard->AddGraveyardLink(ZM_GRAVEYARD_ID, ZM_GRAVEYARD_ZONE, TEAM_HORDE, false); // add gy
m_PvP->TeamApplyBuff(TEAM_HORDE, ZM_CAPTURE_BUFF, 0, player); _pvp->TeamApplyBuff(TEAM_HORDE, ZM_CAPTURE_BUFF, 0, player);
player->RemoveAurasDueToSpell(ZM_BATTLE_STANDARD_H); player->RemoveAurasDueToSpell(ZM_BATTLE_STANDARD_H);
sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_ZM_CAPTURE_GY_H)); sWorld->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_ZM_CAPTURE_GY_H));
} }
@@ -266,14 +266,14 @@ OPvPCapturePointZM_GraveYard::OPvPCapturePointZM_GraveYard(OutdoorPvP* pvp)
void OPvPCapturePointZM_GraveYard::UpdateTowerState() void OPvPCapturePointZM_GraveYard::UpdateTowerState()
{ {
m_PvP->SendUpdateWorldState(ZM_MAP_GRAVEYARD_N, uint32(bool(m_GraveYardState & ZM_GRAVEYARD_N))); _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))); _pvp->SendUpdateWorldState(ZM_MAP_GRAVEYARD_H, uint32(bool(m_GraveYardState & ZM_GRAVEYARD_H)));
m_PvP->SendUpdateWorldState(ZM_MAP_GRAVEYARD_A, uint32(bool(m_GraveYardState & ZM_GRAVEYARD_A))); _pvp->SendUpdateWorldState(ZM_MAP_GRAVEYARD_A, uint32(bool(m_GraveYardState & ZM_GRAVEYARD_A)));
m_PvP->SendUpdateWorldState(ZM_MAP_ALLIANCE_FLAG_READY, uint32(m_BothControllingFactionId == TEAM_ALLIANCE)); _pvp->SendUpdateWorldState(ZM_MAP_ALLIANCE_FLAG_READY, uint32(m_BothControllingFactionId == TEAM_ALLIANCE));
m_PvP->SendUpdateWorldState(ZM_MAP_ALLIANCE_FLAG_NOT_READY, uint32(m_BothControllingFactionId != TEAM_ALLIANCE)); _pvp->SendUpdateWorldState(ZM_MAP_ALLIANCE_FLAG_NOT_READY, uint32(m_BothControllingFactionId != TEAM_ALLIANCE));
m_PvP->SendUpdateWorldState(ZM_MAP_HORDE_FLAG_READY, uint32(m_BothControllingFactionId == TEAM_HORDE)); _pvp->SendUpdateWorldState(ZM_MAP_HORDE_FLAG_READY, uint32(m_BothControllingFactionId == TEAM_HORDE));
m_PvP->SendUpdateWorldState(ZM_MAP_HORDE_FLAG_NOT_READY, uint32(m_BothControllingFactionId != TEAM_HORDE)); _pvp->SendUpdateWorldState(ZM_MAP_HORDE_FLAG_NOT_READY, uint32(m_BothControllingFactionId != TEAM_HORDE));
} }
void OPvPCapturePointZM_GraveYard::FillInitialWorldStates(WorldPacket& data) void OPvPCapturePointZM_GraveYard::FillInitialWorldStates(WorldPacket& data)
@@ -336,8 +336,8 @@ void OPvPCapturePointZM_GraveYard::SetBeaconState(TeamId controlling_factionId)
bool OPvPCapturePointZM_GraveYard::CanTalkTo(Player* player, Creature* c, GossipMenuItems const& /*gso*/) bool OPvPCapturePointZM_GraveYard::CanTalkTo(Player* player, Creature* c, GossipMenuItems const& /*gso*/)
{ {
ObjectGuid guid = c->GetGUID(); ObjectGuid guid = c->GetGUID();
std::map<ObjectGuid::LowType, uint32>::iterator itr = m_CreatureTypes.find(guid.GetCounter()); auto itr = _creatureTypes.find(guid.GetCounter());
if (itr != m_CreatureTypes.end()) if (itr != _creatureTypes.end())
{ {
if (itr->second == ZM_ALLIANCE_FIELD_SCOUT && player->GetTeamId() == TEAM_ALLIANCE && m_BothControllingFactionId == TEAM_ALLIANCE && !m_FlagCarrierGUID && m_GraveYardState != ZM_GRAVEYARD_A) if (itr->second == ZM_ALLIANCE_FIELD_SCOUT && player->GetTeamId() == TEAM_ALLIANCE && m_BothControllingFactionId == TEAM_ALLIANCE && !m_FlagCarrierGUID && m_GraveYardState != ZM_GRAVEYARD_A)
return true; return true;
@@ -349,8 +349,8 @@ bool OPvPCapturePointZM_GraveYard::CanTalkTo(Player* player, Creature* c, Gossip
bool OPvPCapturePointZM_GraveYard::HandleGossipOption(Player* player, Creature* creature, uint32 /*gossipid*/) bool OPvPCapturePointZM_GraveYard::HandleGossipOption(Player* player, Creature* creature, uint32 /*gossipid*/)
{ {
std::map<ObjectGuid::LowType, uint32>::iterator itr = m_CreatureTypes.find(creature->GetSpawnId()); auto itr = _creatureTypes.find(creature->GetSpawnId());
if (itr != m_CreatureTypes.end()) if (itr != _creatureTypes.end())
{ {
// if the flag is already taken, then return // if the flag is already taken, then return
if (m_FlagCarrierGUID) if (m_FlagCarrierGUID)
@@ -416,7 +416,7 @@ void OutdoorPvPZM::SetHordeTowersControlled(uint32 count)
void OutdoorPvPZM::FillInitialWorldStates(WorldPacket& data) void OutdoorPvPZM::FillInitialWorldStates(WorldPacket& data)
{ {
data << ZM_WORLDSTATE_UNK_1 << uint32(1); data << ZM_WORLDSTATE_UNK_1 << uint32(1);
for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{ {
itr->second->FillInitialWorldStates(data); itr->second->FillInitialWorldStates(data);
} }