nchebrov/azerothcore-wotlk
1
0
Fork 0
mirror of https://github.com/mod-playerbots/azerothcore-wotlk.git synced 2026-01-19 03:45:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(Core/WorldState): Initial addition of world state definition file. (#21875)

Browse Source 
Many world states had their enums from script's header and hardcoded values to their respective header file (WorldStateDefines.h)
Co-authored-by: Jelle Meeus <sogladev@gmail.com>
This commit is contained in:
Benjamin Jackson
2025-04-26 14:31:30 -04:00
committed by GitHub
parent d23e61b721
commit da55f05cfc
73 changed files with 1828 additions and 1789 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
src/server/scripts/OutdoorPvP/OutdoorPvPEP.cpp
View File

@@ -28,6 +28,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSessionMgr.h"
#include "WorldStateDefines.h"
#include "WorldStatePackets.h"
OPvPCapturePointEP_EWT::OPvPCapturePointEP_EWT(OutdoorPvP* pvp)
@@ -101,41 +102,41 @@ void OPvPCapturePointEP_EWT::ChangeState()
void OPvPCapturePointEP_EWT::SendChangePhase()
{
// send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes it resets :S
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_N, _neutralValuePct);
}
void OPvPCapturePointEP_EWT::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(5);
packet.Worldstates.emplace_back(EP_EWT_A, (m_TowerState & EP_TS_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_EWT_H, (m_TowerState & EP_TS_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_EWT_N_A, (m_TowerState & EP_TS_N_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_EWT_N_H, (m_TowerState & EP_TS_N_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_EWT_N, (m_TowerState & EP_TS_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_EASTWALLTOWER_A, (m_TowerState & EP_TS_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_EASTWALLTOWER_H, (m_TowerState & EP_TS_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_EASTWALLTOWER_N_A, (m_TowerState & EP_TS_N_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_EASTWALLTOWER_N_H, (m_TowerState & EP_TS_N_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_EASTWALLTOWER_N, (m_TowerState & EP_TS_N) != 0 ? 1 : 0);
}
void OPvPCapturePointEP_EWT::UpdateTowerState()
{
_pvp->SendUpdateWorldState(EP_EWT_A, bool(m_TowerState & EP_TS_A));
_pvp->SendUpdateWorldState(EP_EWT_H, bool(m_TowerState & EP_TS_H));
_pvp->SendUpdateWorldState(EP_EWT_N_A, bool(m_TowerState & EP_TS_N_A));
_pvp->SendUpdateWorldState(EP_EWT_N_H, bool(m_TowerState & EP_TS_N_H));
_pvp->SendUpdateWorldState(EP_EWT_N, bool(m_TowerState & EP_TS_N));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_EASTWALLTOWER_A, bool(m_TowerState & EP_TS_A));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_EASTWALLTOWER_H, bool(m_TowerState & EP_TS_H));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_EASTWALLTOWER_N_A, bool(m_TowerState & EP_TS_N_A));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_EASTWALLTOWER_N_H, bool(m_TowerState & EP_TS_N_H));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_EASTWALLTOWER_N, bool(m_TowerState & EP_TS_N));
}
bool OPvPCapturePointEP_EWT::HandlePlayerEnter(Player* player)
{
if (OPvPCapturePoint::HandlePlayerEnter(player))
{
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_N, _neutralValuePct);
return true;
}
return false;
@@ -143,7 +144,7 @@ bool OPvPCapturePointEP_EWT::HandlePlayerEnter(Player* player)
void OPvPCapturePointEP_EWT::HandlePlayerLeave(Player* player)
{
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 0);
OPvPCapturePoint::HandlePlayerLeave(player);
}
@@ -244,41 +245,41 @@ void OPvPCapturePointEP_NPT::ChangeState()
void OPvPCapturePointEP_NPT::SendChangePhase()
{
// send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes it resets :S
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_N, _neutralValuePct);
}
void OPvPCapturePointEP_NPT::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(5);
packet.Worldstates.emplace_back(EP_NPT_A, (m_TowerState & EP_TS_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_NPT_H, (m_TowerState & EP_TS_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_NPT_N_A, (m_TowerState & EP_TS_N_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_NPT_N_H, (m_TowerState & EP_TS_N_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_NPT_N, (m_TowerState & EP_TS_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_A, (m_TowerState & EP_TS_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_H, (m_TowerState & EP_TS_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_N_A, (m_TowerState & EP_TS_N_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_N_H, (m_TowerState & EP_TS_N_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_N, (m_TowerState & EP_TS_N) != 0 ? 1 : 0);
}
void OPvPCapturePointEP_NPT::UpdateTowerState()
{
_pvp->SendUpdateWorldState(EP_NPT_A, bool(m_TowerState & EP_TS_A));
_pvp->SendUpdateWorldState(EP_NPT_H, bool(m_TowerState & EP_TS_H));
_pvp->SendUpdateWorldState(EP_NPT_N_A, bool(m_TowerState & EP_TS_N_A));
_pvp->SendUpdateWorldState(EP_NPT_N_H, bool(m_TowerState & EP_TS_N_H));
_pvp->SendUpdateWorldState(EP_NPT_N, bool(m_TowerState & EP_TS_N));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_A, bool(m_TowerState & EP_TS_A));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_H, bool(m_TowerState & EP_TS_H));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_N_A, bool(m_TowerState & EP_TS_N_A));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_N_H, bool(m_TowerState & EP_TS_N_H));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_N, bool(m_TowerState & EP_TS_N));
}
bool OPvPCapturePointEP_NPT::HandlePlayerEnter(Player* player)
{
if (OPvPCapturePoint::HandlePlayerEnter(player))
{
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_N, _neutralValuePct);
return true;
}
return false;
@@ -286,7 +287,7 @@ bool OPvPCapturePointEP_NPT::HandlePlayerEnter(Player* player)
void OPvPCapturePointEP_NPT::HandlePlayerLeave(Player* player)
{
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 0);
OPvPCapturePoint::HandlePlayerLeave(player);
}
@@ -377,41 +378,41 @@ void OPvPCapturePointEP_CGT::ChangeState()
void OPvPCapturePointEP_CGT::SendChangePhase()
{
// send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes it resets :S
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_N, _neutralValuePct);
}
void OPvPCapturePointEP_CGT::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(5);
packet.Worldstates.emplace_back(EP_CGT_A, (m_TowerState & EP_TS_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_CGT_H, (m_TowerState & EP_TS_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_CGT_N_A, (m_TowerState & EP_TS_N_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_CGT_N_H, (m_TowerState & EP_TS_N_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_CGT_N, (m_TowerState & EP_TS_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_A, (m_TowerState & EP_TS_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_H, (m_TowerState & EP_TS_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_N_A, (m_TowerState & EP_TS_N_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_N_H, (m_TowerState & EP_TS_N_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_N, (m_TowerState & EP_TS_N) != 0 ? 1 : 0);
}
void OPvPCapturePointEP_CGT::UpdateTowerState()
{
_pvp->SendUpdateWorldState(EP_CGT_A, bool(m_TowerState & EP_TS_A));
_pvp->SendUpdateWorldState(EP_CGT_H, bool(m_TowerState & EP_TS_H));
_pvp->SendUpdateWorldState(EP_CGT_N_A, bool(m_TowerState & EP_TS_N_A));
_pvp->SendUpdateWorldState(EP_CGT_N_H, bool(m_TowerState & EP_TS_N_H));
_pvp->SendUpdateWorldState(EP_CGT_N, bool(m_TowerState & EP_TS_N));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_A, bool(m_TowerState & EP_TS_A));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_H, bool(m_TowerState & EP_TS_H));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_N_A, bool(m_TowerState & EP_TS_N_A));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_N_H, bool(m_TowerState & EP_TS_N_H));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_N, bool(m_TowerState & EP_TS_N));
}
bool OPvPCapturePointEP_CGT::HandlePlayerEnter(Player* player)
{
if (OPvPCapturePoint::HandlePlayerEnter(player))
{
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_N, _neutralValuePct);
return true;
}
return false;
@@ -419,7 +420,7 @@ bool OPvPCapturePointEP_CGT::HandlePlayerEnter(Player* player)
void OPvPCapturePointEP_CGT::HandlePlayerLeave(Player* player)
{
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 0);
OPvPCapturePoint::HandlePlayerLeave(player);
}
@@ -515,41 +516,41 @@ void OPvPCapturePointEP_PWT::ChangeState()
void OPvPCapturePointEP_PWT::SendChangePhase()
{
// send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes it resets :S
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_N, _neutralValuePct);
}
void OPvPCapturePointEP_PWT::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(5);
packet.Worldstates.emplace_back(EP_PWT_A, (m_TowerState & EP_TS_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_PWT_H, (m_TowerState & EP_TS_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_PWT_N_A, (m_TowerState & EP_TS_N_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_PWT_N_H, (m_TowerState & EP_TS_N_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(EP_PWT_N, (m_TowerState & EP_TS_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_A, (m_TowerState & EP_TS_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_H, (m_TowerState & EP_TS_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_N_A, (m_TowerState & EP_TS_N_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_N_H, (m_TowerState & EP_TS_N_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_N, (m_TowerState & EP_TS_N) != 0 ? 1 : 0);
}
void OPvPCapturePointEP_PWT::UpdateTowerState()
{
_pvp->SendUpdateWorldState(EP_PWT_A, bool(m_TowerState & EP_TS_A));
_pvp->SendUpdateWorldState(EP_PWT_H, bool(m_TowerState & EP_TS_H));
_pvp->SendUpdateWorldState(EP_PWT_N_A, bool(m_TowerState & EP_TS_N_A));
_pvp->SendUpdateWorldState(EP_PWT_N_H, bool(m_TowerState & EP_TS_N_H));
_pvp->SendUpdateWorldState(EP_PWT_N, bool(m_TowerState & EP_TS_N));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_A, bool(m_TowerState & EP_TS_A));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_H, bool(m_TowerState & EP_TS_H));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_N_A, bool(m_TowerState & EP_TS_N_A));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_N_H, bool(m_TowerState & EP_TS_N_H));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_N, bool(m_TowerState & EP_TS_N));
}
bool OPvPCapturePointEP_PWT::HandlePlayerEnter(Player* player)
{
if (OPvPCapturePoint::HandlePlayerEnter(player))
{
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_N, _neutralValuePct);
return true;
}
return false;
@@ -557,7 +558,7 @@ bool OPvPCapturePointEP_PWT::HandlePlayerEnter(Player* player)
void OPvPCapturePointEP_PWT::HandlePlayerLeave(Player* player)
{
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 0);
OPvPCapturePoint::HandlePlayerLeave(player);
}
@@ -647,8 +648,8 @@ bool OutdoorPvPEP::Update(uint32 diff)
++m_AllianceTowersControlled;
else if (EP_ControlsId[i] == TEAM_HORDE)
++m_HordeTowersControlled;
SendUpdateWorldState(EP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SendUpdateWorldState(EP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
BuffTeams();
}
return true;
@@ -720,11 +721,11 @@ void OutdoorPvPEP::SetControlledState(uint32 index, TeamId teamId)
void OutdoorPvPEP::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(5);
packet.Worldstates.emplace_back(EP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
packet.Worldstates.emplace_back(EP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
packet.Worldstates.emplace_back(EP_UI_TOWER_SLIDER_DISPLAY, 0);
packet.Worldstates.emplace_back(EP_UI_TOWER_SLIDER_POS, 50);
packet.Worldstates.emplace_back(EP_UI_TOWER_SLIDER_N, 100);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_POS, 50);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_N, 100);
for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{
@@ -734,35 +735,35 @@ void OutdoorPvPEP::FillInitialWorldStates(WorldPackets::WorldState::InitWorldSta
void OutdoorPvPEP::SendRemoveWorldStates(Player* player)
{
player->SendUpdateWorldState(EP_UI_TOWER_COUNT_A, 0);
player->SendUpdateWorldState(EP_UI_TOWER_COUNT_H, 0);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, 0);
player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_COUNT_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_COUNT_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_POS, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_UI_TOWER_SLIDER_N, 0);
player->SendUpdateWorldState(EP_EWT_A, 0);
player->SendUpdateWorldState(EP_EWT_H, 0);
player->SendUpdateWorldState(EP_EWT_N, 0);
player->SendUpdateWorldState(EP_EWT_N_A, 0);
player->SendUpdateWorldState(EP_EWT_N_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_EASTWALLTOWER_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_EASTWALLTOWER_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_EASTWALLTOWER_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_EASTWALLTOWER_N_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_EASTWALLTOWER_N_H, 0);
player->SendUpdateWorldState(EP_PWT_A, 0);
player->SendUpdateWorldState(EP_PWT_H, 0);
player->SendUpdateWorldState(EP_PWT_N, 0);
player->SendUpdateWorldState(EP_PWT_N_A, 0);
player->SendUpdateWorldState(EP_PWT_N_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_N_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_PLAGUEWOODTOWER_N_H, 0);
player->SendUpdateWorldState(EP_NPT_A, 0);
player->SendUpdateWorldState(EP_NPT_H, 0);
player->SendUpdateWorldState(EP_NPT_N, 0);
player->SendUpdateWorldState(EP_NPT_N_A, 0);
player->SendUpdateWorldState(EP_NPT_N_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_N_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_NORTHPASSTOWER_N_H, 0);
player->SendUpdateWorldState(EP_CGT_A, 0);
player->SendUpdateWorldState(EP_CGT_H, 0);
player->SendUpdateWorldState(EP_CGT_N, 0);
player->SendUpdateWorldState(EP_CGT_N_A, 0);
player->SendUpdateWorldState(EP_CGT_N_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_N_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_EP_CROWNGUARDTOWER_N_H, 0);
}
class OutdoorPvP_eastern_plaguelands : public OutdoorPvPScript

46
src/server/scripts/OutdoorPvP/OutdoorPvPEP.h
View File

@@ -46,52 +46,6 @@ const uint32 EPBuffZones[EPBuffZonesNum] = {139, 2017, 2057};
// EP_PWT_Taxi = 84
//};
enum EP_EastwallTowerWorldStates
{
EP_EWT_A = 2354,
EP_EWT_H = 2356,
EP_EWT_N_A = 2359, // ally conquested
EP_EWT_N_H = 2360,
EP_EWT_N = 2361
};
enum EP_NorthpassTowerWorldStates
{
EP_NPT_N = 2352,
EP_NPT_N_A = 2362,
EP_NPT_N_H = 2363,
EP_NPT_A = 2372,
EP_NPT_H = 2373
};
enum EP_PlagewoodTowerWorldStates
{
EP_PWT_N_A = 2366,
EP_PWT_N_H = 2353, //2367 not present! use neutral!
EP_PWT_A = 2370,
EP_PWT_H = 2371,
EP_PWT_N = 2353
};
enum EP_CrownGuardTowerWorldStates
{
EP_CGT_N_A = 2374,
EP_CGT_N_H = 2375,
EP_CGT_A = 2378,
EP_CGT_H = 2379,
EP_CGT_N = 2355
};
enum EP_WorldStates
{
EP_UI_TOWER_SLIDER_DISPLAY = 2426,
EP_UI_TOWER_SLIDER_POS = 2427,
EP_UI_TOWER_SLIDER_N = 2428,
EP_UI_TOWER_COUNT_A = 2327,
EP_UI_TOWER_COUNT_H = 2328
};
enum EP_Summons
{
EP_EWT_COMMANDER = 0,

27
src/server/scripts/OutdoorPvP/OutdoorPvPGH.cpp
View File

@@ -22,6 +22,7 @@
#include "OutdoorPvPScript.h"
#include "Player.h"
#include "WorldPacket.h"
#include "WorldStateDefines.h"
OutdoorPvPGH::OutdoorPvPGH()
{
@@ -39,9 +40,9 @@ bool OutdoorPvPGH::SetupOutdoorPvP()
void OutdoorPvPGH::SendRemoveWorldStates(Player* player)
{
player->SendUpdateWorldState(GH_UI_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(GH_UI_SLIDER_POS, 0);
player->SendUpdateWorldState(GH_UI_SLIDER_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_GH_UI_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_GH_UI_SLIDER_POS, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_GH_UI_SLIDER_N, 0);
}
OPvPCapturePointGH::OPvPCapturePointGH(OutdoorPvP* pvp) : OPvPCapturePoint(pvp)
@@ -52,29 +53,29 @@ OPvPCapturePointGH::OPvPCapturePointGH(OutdoorPvP* pvp) : OPvPCapturePoint(pvp)
void OPvPCapturePointGH::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(3);
packet.Worldstates.emplace_back(GH_UI_SLIDER_DISPLAY, 0);
packet.Worldstates.emplace_back(GH_UI_SLIDER_POS, 50);
packet.Worldstates.emplace_back(GH_UI_SLIDER_N, 20);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_GH_UI_SLIDER_DISPLAY, 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_GH_UI_SLIDER_POS, 50);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_GH_UI_SLIDER_N, 20);
}
void OPvPCapturePointGH::SendChangePhase()
{
// send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(GH_UI_SLIDER_DISPLAY, 1);
SendUpdateWorldState(WORLD_STATE_OPVP_GH_UI_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(GH_UI_SLIDER_POS, phase);
SendUpdateWorldState(GH_UI_SLIDER_N, _neutralValuePct);
SendUpdateWorldState(WORLD_STATE_OPVP_GH_UI_SLIDER_POS, phase);
SendUpdateWorldState(WORLD_STATE_OPVP_GH_UI_SLIDER_N, _neutralValuePct);
}
bool OPvPCapturePointGH::HandlePlayerEnter(Player* player)
{
if (OPvPCapturePoint::HandlePlayerEnter(player))
{
player->SendUpdateWorldState(GH_UI_SLIDER_DISPLAY, 1);
player->SendUpdateWorldState(WORLD_STATE_OPVP_GH_UI_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(GH_UI_SLIDER_POS, phase);
player->SendUpdateWorldState(GH_UI_SLIDER_N, _neutralValuePct);
player->SendUpdateWorldState(WORLD_STATE_OPVP_GH_UI_SLIDER_POS, phase);
player->SendUpdateWorldState(WORLD_STATE_OPVP_GH_UI_SLIDER_N, _neutralValuePct);
return true;
}
return false;
@@ -82,7 +83,7 @@ bool OPvPCapturePointGH::HandlePlayerEnter(Player* player)
void OPvPCapturePointGH::HandlePlayerLeave(Player* player)
{
player->SendUpdateWorldState(GH_UI_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_GH_UI_SLIDER_DISPLAY, 0);
OPvPCapturePoint::HandlePlayerLeave(player);
}

4
src/server/scripts/OutdoorPvP/OutdoorPvPGH.h
View File

@@ -26,10 +26,6 @@ enum OutdoorPvPGHenum
GH_HORDE_DEFENSE_EVENT = 66,
GH_ZONE = 394,
GH_UI_SLIDER_DISPLAY = 3466,
GH_UI_SLIDER_POS = 3467,
GH_UI_SLIDER_N = 3468,
};
class Unit;

48
src/server/scripts/OutdoorPvP/OutdoorPvPHP.cpp
View File

@@ -131,21 +131,21 @@ bool OutdoorPvPHP::Update(uint32 diff)
TeamCastSpell(TEAM_ALLIANCE, -AllianceBuff);
TeamCastSpell(TEAM_HORDE, -HordeBuff);
}
SendUpdateWorldState(HP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SendUpdateWorldState(HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
}
return changed;
}
void OutdoorPvPHP::SendRemoveWorldStates(Player* player)
{
player->SendUpdateWorldState(HP_UI_TOWER_DISPLAY_A, 0);
player->SendUpdateWorldState(HP_UI_TOWER_DISPLAY_H, 0);
player->SendUpdateWorldState(HP_UI_TOWER_COUNT_H, 0);
player->SendUpdateWorldState(HP_UI_TOWER_COUNT_A, 0);
player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, 0);
player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, 0);
player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_DISPLAY_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_DISPLAY_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_COUNT_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_COUNT_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_POS, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_DISPLAY, 0);
for (int i = 0; i < HP_TOWER_NUM; ++i)
{
player->SendUpdateWorldState(HP_MAP_N[i], 0);
@@ -157,15 +157,15 @@ void OutdoorPvPHP::SendRemoveWorldStates(Player* player)
void OutdoorPvPHP::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(8);
packet.Worldstates.emplace_back(HP_UI_TOWER_DISPLAY_A, 1);
packet.Worldstates.emplace_back(HP_UI_TOWER_DISPLAY_H, 1);
packet.Worldstates.emplace_back(HP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
packet.Worldstates.emplace_back(HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_HP_UI_TOWER_DISPLAY_A, 1);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_HP_UI_TOWER_DISPLAY_H, 1);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_HP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
packet.Worldstates.emplace_back(HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
packet.Worldstates.emplace_back(HP_UI_TOWER_SLIDER_DISPLAY, 0);
packet.Worldstates.emplace_back(HP_UI_TOWER_SLIDER_POS, 50);
packet.Worldstates.emplace_back(HP_UI_TOWER_SLIDER_N, 100);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_DISPLAY, 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_POS, 50);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_N, 100);
for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{
itr->second->FillInitialWorldStates(packet);
@@ -269,12 +269,12 @@ void OPvPCapturePointHP::ChangeState()
void OPvPCapturePointHP::SendChangePhase()
{
SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, _neutralValuePct);
SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_N, _neutralValuePct);
// send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, phase);
SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1);
SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_DISPLAY, 1);
}
void OPvPCapturePointHP::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
@@ -311,10 +311,10 @@ bool OPvPCapturePointHP::HandlePlayerEnter(Player* player)
{
if (OPvPCapturePoint::HandlePlayerEnter(player))
{
player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_N, _neutralValuePct);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_N, _neutralValuePct);
return true;
}
return false;
@@ -322,7 +322,7 @@ bool OPvPCapturePointHP::HandlePlayerEnter(Player* player)
void OPvPCapturePointHP::HandlePlayerLeave(Player* player)
{
player->SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_HP_UI_TOWER_SLIDER_DISPLAY, 0);
OPvPCapturePoint::HandlePlayerLeave(player);
}

20
src/server/scripts/OutdoorPvP/OutdoorPvPHP.h
View File

@@ -19,6 +19,7 @@
#define OUTDOOR_PVP_HP_
#include "OutdoorPvP.h"
#include "WorldStateDefines.h"
#define OutdoorPvPHPBuffZonesNum 6
// HP, citadel, ramparts, blood furnace, shattered halls, mag's lair
@@ -46,24 +47,11 @@ const uint32 HP_CREDITMARKER[HP_TOWER_NUM] = {19032, 19028, 19029};
//const uint32 HP_CapturePointEvent_Leave[HP_TOWER_NUM] = {11403, 11395, 11387};
enum OutdoorPvPHPWorldStates
{
HP_UI_TOWER_DISPLAY_A = 0x9ba,
HP_UI_TOWER_DISPLAY_H = 0x9b9,
const uint32 HP_MAP_N[HP_TOWER_NUM] = {WORLD_STATE_OPVP_HP_BROKENHILL_N, WORLD_STATE_OPVP_HP_OVERLOOK_N, WORLD_STATE_OPVP_HP_STADIUM_N };
HP_UI_TOWER_COUNT_H = 0x9ae,
HP_UI_TOWER_COUNT_A = 0x9ac,
const uint32 HP_MAP_A[HP_TOWER_NUM] = {WORLD_STATE_OPVP_HP_BROKENHILL_A, WORLD_STATE_OPVP_HP_OVERLOOK_A, WORLD_STATE_OPVP_HP_STADIUM_A };
HP_UI_TOWER_SLIDER_N = 2475,
HP_UI_TOWER_SLIDER_POS = 2474,
HP_UI_TOWER_SLIDER_DISPLAY = 2473
};
const uint32 HP_MAP_N[HP_TOWER_NUM] = {0x9b5, 0x9b2, 0x9a8};
const uint32 HP_MAP_A[HP_TOWER_NUM] = {0x9b3, 0x9b0, 0x9a7};
const uint32 HP_MAP_H[HP_TOWER_NUM] = {0x9b4, 0x9b1, 0x9a6};
const uint32 HP_MAP_H[HP_TOWER_NUM] = {WORLD_STATE_OPVP_HP_BROKENHILL_H, WORLD_STATE_OPVP_HP_OVERLOOK_H, WORLD_STATE_OPVP_HP_STADIUM_H };
const uint32 HP_TowerArtKit_A[HP_TOWER_NUM] = {65, 62, 67};

187
src/server/scripts/OutdoorPvP/OutdoorPvPNA.cpp
View File

@@ -29,6 +29,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSessionMgr.h"
#include "WorldStateDefines.h"
#include "WorldStatePackets.h"
OutdoorPvPNA::OutdoorPvPNA()
@@ -216,9 +217,9 @@ void OPvPCapturePointNA::FactionTakeOver(TeamId teamId)
m_WyvernStateEast = WYVERN_NEU_HORDE;
m_WyvernStateWest = WYVERN_NEU_HORDE;
_pvp->TeamApplyBuff(TEAM_ALLIANCE, NA_CAPTURE_BUFF);
_pvp->SendUpdateWorldState(NA_UI_HORDE_GUARDS_SHOW, 0);
_pvp->SendUpdateWorldState(NA_UI_ALLIANCE_GUARDS_SHOW, 1);
_pvp->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive);
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_HORDE_GUARDS_SHOW, 0);
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_ALLIANCE_GUARDS_SHOW, 1);
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_GUARDS_LEFT, m_GuardsAlive);
sWorldSessionMgr->SendZoneText(NA_HALAA_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_NA_CAPTURE_A));
}
else
@@ -228,9 +229,9 @@ void OPvPCapturePointNA::FactionTakeOver(TeamId teamId)
m_WyvernStateEast = WYVERN_NEU_ALLIANCE;
m_WyvernStateWest = WYVERN_NEU_ALLIANCE;
_pvp->TeamApplyBuff(TEAM_HORDE, NA_CAPTURE_BUFF);
_pvp->SendUpdateWorldState(NA_UI_HORDE_GUARDS_SHOW, 1);
_pvp->SendUpdateWorldState(NA_UI_ALLIANCE_GUARDS_SHOW, 0);
_pvp->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive);
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_HORDE_GUARDS_SHOW, 1);
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_ALLIANCE_GUARDS_SHOW, 0);
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_GUARDS_LEFT, m_GuardsAlive);
sWorldSessionMgr->SendZoneText(NA_HALAA_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_NA_CAPTURE_H));
}
UpdateWyvernRoostWorldState(NA_ROOST_S);
@@ -243,10 +244,10 @@ bool OPvPCapturePointNA::HandlePlayerEnter(Player* player)
{
if (OPvPCapturePoint::HandlePlayerEnter(player))
{
player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 1);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_N, _neutralValuePct);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_SLIDER_N, _neutralValuePct);
return true;
}
return false;
@@ -254,7 +255,7 @@ bool OPvPCapturePointNA::HandlePlayerEnter(Player* player)
void OPvPCapturePointNA::HandlePlayerLeave(Player* player)
{
player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_TOWER_SLIDER_DISPLAY, 0);
OPvPCapturePoint::HandlePlayerLeave(player);
}
@@ -311,75 +312,75 @@ void OPvPCapturePointNA::FillInitialWorldStates(WorldPackets::WorldState::InitWo
packet.Worldstates.reserve(25);
if (m_ControllingFaction == TEAM_ALLIANCE)
{
packet.Worldstates.emplace_back(NA_UI_HORDE_GUARDS_SHOW, 0);
packet.Worldstates.emplace_back(NA_UI_ALLIANCE_GUARDS_SHOW, 1);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_UI_HORDE_GUARDS_SHOW, 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_UI_ALLIANCE_GUARDS_SHOW, 1);
}
else if (m_ControllingFaction == TEAM_HORDE)
{
packet.Worldstates.emplace_back(NA_UI_HORDE_GUARDS_SHOW, 1);
packet.Worldstates.emplace_back(NA_UI_ALLIANCE_GUARDS_SHOW, 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_UI_HORDE_GUARDS_SHOW, 1);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_UI_ALLIANCE_GUARDS_SHOW, 0);
}
else
{
packet.Worldstates.emplace_back(NA_UI_HORDE_GUARDS_SHOW, 0);
packet.Worldstates.emplace_back(NA_UI_ALLIANCE_GUARDS_SHOW, 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_UI_HORDE_GUARDS_SHOW, 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_UI_ALLIANCE_GUARDS_SHOW, 0);
}
packet.Worldstates.emplace_back(NA_UI_GUARDS_MAX, NA_GUARDS_MAX);
packet.Worldstates.emplace_back(NA_UI_GUARDS_LEFT, m_GuardsAlive);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_NORTH_NEU_H, (m_WyvernStateNorth & WYVERN_NEU_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_NORTH_NEU_A, (m_WyvernStateNorth & WYVERN_NEU_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_NORTH_H, (m_WyvernStateNorth & WYVERN_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_NORTH_A, (m_WyvernStateNorth & WYVERN_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_SOUTH_NEU_H, (m_WyvernStateSouth & WYVERN_NEU_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_SOUTH_NEU_A, (m_WyvernStateSouth & WYVERN_NEU_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_SOUTH_H, (m_WyvernStateSouth & WYVERN_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_SOUTH_A, (m_WyvernStateSouth & WYVERN_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_WEST_NEU_H, (m_WyvernStateWest & WYVERN_NEU_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_WEST_NEU_A, (m_WyvernStateWest & WYVERN_NEU_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_WEST_H, (m_WyvernStateWest & WYVERN_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_WEST_A, (m_WyvernStateWest & WYVERN_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_EAST_NEU_H, (m_WyvernStateEast & WYVERN_NEU_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_EAST_NEU_A, (m_WyvernStateEast & WYVERN_NEU_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_EAST_H, (m_WyvernStateEast & WYVERN_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_WYVERN_EAST_A, (m_WyvernStateEast & WYVERN_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_HALAA_NEUTRAL, (m_HalaaState & HALAA_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_HALAA_NEU_A, (m_HalaaState & HALAA_N_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_HALAA_NEU_H, (m_HalaaState & HALAA_N_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_HALAA_HORDE, (m_HalaaState & HALAA_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(NA_MAP_HALAA_ALLIANCE, (m_HalaaState & HALAA_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_UI_GUARDS_MAX, NA_GUARDS_MAX);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_UI_GUARDS_LEFT, m_GuardsAlive);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_NEU_H, (m_WyvernStateNorth & WYVERN_NEU_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_NEU_A, (m_WyvernStateNorth & WYVERN_NEU_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_H, (m_WyvernStateNorth & WYVERN_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_A, (m_WyvernStateNorth & WYVERN_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_NEU_H, (m_WyvernStateSouth & WYVERN_NEU_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_NEU_A, (m_WyvernStateSouth & WYVERN_NEU_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_H, (m_WyvernStateSouth & WYVERN_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_A, (m_WyvernStateSouth & WYVERN_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_NEU_H, (m_WyvernStateWest & WYVERN_NEU_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_NEU_A, (m_WyvernStateWest & WYVERN_NEU_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_H, (m_WyvernStateWest & WYVERN_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_A, (m_WyvernStateWest & WYVERN_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_NEU_H, (m_WyvernStateEast & WYVERN_NEU_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_NEU_A, (m_WyvernStateEast & WYVERN_NEU_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_H, (m_WyvernStateEast & WYVERN_HORDE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_A, (m_WyvernStateEast & WYVERN_ALLIANCE) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_HALAA_NEUTRAL, (m_HalaaState & HALAA_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_HALAA_NEU_A, (m_HalaaState & HALAA_N_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_HALAA_NEU_H, (m_HalaaState & HALAA_N_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_HALAA_HORDE, (m_HalaaState & HALAA_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_NA_MAP_HALAA_ALLIANCE, (m_HalaaState & HALAA_A) != 0 ? 1 : 0);
}
void OutdoorPvPNA::SendRemoveWorldStates(Player* player)
{
player->SendUpdateWorldState(NA_UI_HORDE_GUARDS_SHOW, 0);
player->SendUpdateWorldState(NA_UI_ALLIANCE_GUARDS_SHOW, 0);
player->SendUpdateWorldState(NA_UI_GUARDS_MAX, 0);
player->SendUpdateWorldState(NA_UI_GUARDS_LEFT, 0);
player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_POS, 0);
player->SendUpdateWorldState(NA_UI_TOWER_SLIDER_N, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_NEU_H, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_NEU_A, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_H, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_A, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_NEU_H, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_NEU_A, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_H, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_A, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_WEST_NEU_H, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_WEST_NEU_A, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_WEST_H, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_WEST_A, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_EAST_NEU_H, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_EAST_NEU_A, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_EAST_H, 0);
player->SendUpdateWorldState(NA_MAP_WYVERN_EAST_A, 0);
player->SendUpdateWorldState(NA_MAP_HALAA_NEUTRAL, 0);
player->SendUpdateWorldState(NA_MAP_HALAA_NEU_A, 0);
player->SendUpdateWorldState(NA_MAP_HALAA_NEU_H, 0);
player->SendUpdateWorldState(NA_MAP_HALAA_HORDE, 0);
player->SendUpdateWorldState(NA_MAP_HALAA_ALLIANCE, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_HORDE_GUARDS_SHOW, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_ALLIANCE_GUARDS_SHOW, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_GUARDS_MAX, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_GUARDS_LEFT, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_TOWER_SLIDER_POS, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_SLIDER_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_NEU_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_NEU_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_NEU_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_NEU_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_NEU_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_NEU_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_NEU_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_NEU_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_HALAA_NEUTRAL, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_HALAA_NEU_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_HALAA_NEU_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_HALAA_HORDE, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_HALAA_ALLIANCE, 0);
}
bool OutdoorPvPNA::Update(uint32 diff)
@@ -640,7 +641,7 @@ bool OPvPCapturePointNA::Update(uint32 diff)
else
m_capturable = false;
// update the guard count for the players in zone
_pvp->SendUpdateWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive);
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_GUARDS_LEFT, m_GuardsAlive);
}
}
else m_GuardCheckTimer -= diff;
@@ -774,7 +775,7 @@ bool OPvPCapturePointNA::Update(uint32 diff)
}
}
else
SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 0); //Point is not capturable so we hide the slider
SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_TOWER_SLIDER_DISPLAY, 0); //Point is not capturable so we hide the slider
return false;
}
@@ -824,20 +825,20 @@ void OPvPCapturePointNA::ChangeState()
void OPvPCapturePointNA::SendChangePhase()
{
// send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(NA_UI_TOWER_SLIDER_DISPLAY, 1);
SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(NA_UI_TOWER_SLIDER_POS, phase);
SendUpdateWorldState(NA_UI_TOWER_SLIDER_N, _neutralValuePct);
SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_TOWER_SLIDER_POS, phase);
SendUpdateWorldState(WORLD_STATE_OPVP_NA_UI_SLIDER_N, _neutralValuePct);
}
void OPvPCapturePointNA::UpdateHalaaWorldState()
{
_pvp->SendUpdateWorldState(NA_MAP_HALAA_NEUTRAL, uint32(bool(m_HalaaState & HALAA_N)));
_pvp->SendUpdateWorldState(NA_MAP_HALAA_NEU_A, uint32(bool(m_HalaaState & HALAA_N_A)));
_pvp->SendUpdateWorldState(NA_MAP_HALAA_NEU_H, uint32(bool(m_HalaaState & HALAA_N_H)));
_pvp->SendUpdateWorldState(NA_MAP_HALAA_HORDE, uint32(bool(m_HalaaState & HALAA_H)));
_pvp->SendUpdateWorldState(NA_MAP_HALAA_ALLIANCE, uint32(bool(m_HalaaState & HALAA_A)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_HALAA_NEUTRAL, uint32(bool(m_HalaaState & HALAA_N)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_HALAA_NEU_A, uint32(bool(m_HalaaState & HALAA_N_A)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_HALAA_NEU_H, uint32(bool(m_HalaaState & HALAA_N_H)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_HALAA_HORDE, uint32(bool(m_HalaaState & HALAA_H)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_HALAA_ALLIANCE, uint32(bool(m_HalaaState & HALAA_A)));
}
void OPvPCapturePointNA::UpdateWyvernRoostWorldState(uint32 roost)
@@ -845,28 +846,28 @@ void OPvPCapturePointNA::UpdateWyvernRoostWorldState(uint32 roost)
switch (roost)
{
case NA_ROOST_S:
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_NEU_H, uint32(bool(m_WyvernStateSouth & WYVERN_NEU_HORDE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_NEU_A, uint32(bool(m_WyvernStateSouth & WYVERN_NEU_ALLIANCE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_H, uint32(bool(m_WyvernStateSouth & WYVERN_HORDE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_SOUTH_A, uint32(bool(m_WyvernStateSouth & WYVERN_ALLIANCE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_NEU_H, uint32(bool(m_WyvernStateSouth & WYVERN_NEU_HORDE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_NEU_A, uint32(bool(m_WyvernStateSouth & WYVERN_NEU_ALLIANCE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_H, uint32(bool(m_WyvernStateSouth & WYVERN_HORDE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_SOUTH_A, uint32(bool(m_WyvernStateSouth & WYVERN_ALLIANCE)));
break;
case NA_ROOST_N:
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_NEU_H, uint32(bool(m_WyvernStateNorth & WYVERN_NEU_HORDE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_NEU_A, uint32(bool(m_WyvernStateNorth & WYVERN_NEU_ALLIANCE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_H, uint32(bool(m_WyvernStateNorth & WYVERN_HORDE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_NORTH_A, uint32(bool(m_WyvernStateNorth & WYVERN_ALLIANCE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_NEU_H, uint32(bool(m_WyvernStateNorth & WYVERN_NEU_HORDE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_NEU_A, uint32(bool(m_WyvernStateNorth & WYVERN_NEU_ALLIANCE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_H, uint32(bool(m_WyvernStateNorth & WYVERN_HORDE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_NORTH_A, uint32(bool(m_WyvernStateNorth & WYVERN_ALLIANCE)));
break;
case NA_ROOST_W:
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_WEST_NEU_H, uint32(bool(m_WyvernStateWest & WYVERN_NEU_HORDE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_WEST_NEU_A, uint32(bool(m_WyvernStateWest & WYVERN_NEU_ALLIANCE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_WEST_H, uint32(bool(m_WyvernStateWest & WYVERN_HORDE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_WEST_A, uint32(bool(m_WyvernStateWest & WYVERN_ALLIANCE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_NEU_H, uint32(bool(m_WyvernStateWest & WYVERN_NEU_HORDE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_NEU_A, uint32(bool(m_WyvernStateWest & WYVERN_NEU_ALLIANCE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_H, uint32(bool(m_WyvernStateWest & WYVERN_HORDE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_WEST_A, uint32(bool(m_WyvernStateWest & WYVERN_ALLIANCE)));
break;
case NA_ROOST_E:
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_EAST_NEU_H, uint32(bool(m_WyvernStateEast & WYVERN_NEU_HORDE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_EAST_NEU_A, uint32(bool(m_WyvernStateEast & WYVERN_NEU_ALLIANCE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_EAST_H, uint32(bool(m_WyvernStateEast & WYVERN_HORDE)));
_pvp->SendUpdateWorldState(NA_MAP_WYVERN_EAST_A, uint32(bool(m_WyvernStateEast & WYVERN_ALLIANCE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_NEU_H, uint32(bool(m_WyvernStateEast & WYVERN_NEU_HORDE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_NEU_A, uint32(bool(m_WyvernStateEast & WYVERN_NEU_ALLIANCE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_H, uint32(bool(m_WyvernStateEast & WYVERN_HORDE)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_NA_MAP_WYVERN_EAST_A, uint32(bool(m_WyvernStateEast & WYVERN_ALLIANCE)));
break;
}
}

38
src/server/scripts/OutdoorPvP/OutdoorPvPNA.h
View File

@@ -48,44 +48,6 @@ const uint32 NA_GUARD_CHECK_TIME = 500; // every half second
const uint32 NA_HALAA_BOMB = 24538; // Item id Bomb throwed in Halaa
enum OutdoorPvPNAWorldStates
{
NA_UI_HORDE_GUARDS_SHOW = 2503,
NA_UI_ALLIANCE_GUARDS_SHOW = 2502,
NA_UI_GUARDS_MAX = 2493,
NA_UI_GUARDS_LEFT = 2491,
NA_UI_TOWER_SLIDER_DISPLAY = 2495,
NA_UI_TOWER_SLIDER_POS = 2494,
NA_UI_TOWER_SLIDER_N = 2497,
NA_MAP_WYVERN_NORTH_NEU_H = 2762,
NA_MAP_WYVERN_NORTH_NEU_A = 2662,
NA_MAP_WYVERN_NORTH_H = 2663,
NA_MAP_WYVERN_NORTH_A = 2664,
NA_MAP_WYVERN_SOUTH_NEU_H = 2760,
NA_MAP_WYVERN_SOUTH_NEU_A = 2670,
NA_MAP_WYVERN_SOUTH_H = 2668,
NA_MAP_WYVERN_SOUTH_A = 2669,
NA_MAP_WYVERN_WEST_NEU_H = 2761,
NA_MAP_WYVERN_WEST_NEU_A = 2667,
NA_MAP_WYVERN_WEST_H = 2665,
NA_MAP_WYVERN_WEST_A = 2666,
NA_MAP_WYVERN_EAST_NEU_H = 2763,
NA_MAP_WYVERN_EAST_NEU_A = 2659,
NA_MAP_WYVERN_EAST_H = 2660,
NA_MAP_WYVERN_EAST_A = 2661,
NA_MAP_HALAA_NEUTRAL = 2671,
NA_MAP_HALAA_NEU_A = 2676,
NA_MAP_HALAA_NEU_H = 2677,
NA_MAP_HALAA_HORDE = 2672,
NA_MAP_HALAA_ALLIANCE = 2673
};
const uint32 FLIGHT_NODES_NUM = 4;
// used to access the elements of Horde/AllyControlGOs

19
src/server/scripts/OutdoorPvP/OutdoorPvPSI.cpp
View File

@@ -29,6 +29,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSessionMgr.h"
#include "WorldStateDefines.h"
#include "WorldStatePackets.h"
OutdoorPvPSI::OutdoorPvPSI()
@@ -42,23 +43,23 @@ OutdoorPvPSI::OutdoorPvPSI()
void OutdoorPvPSI::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(3);
packet.Worldstates.emplace_back(SI_GATHERED_A, m_Gathered_A);
packet.Worldstates.emplace_back(SI_GATHERED_H, m_Gathered_H);
packet.Worldstates.emplace_back(SI_SILITHYST_MAX, SI_MAX_RESOURCES);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_SI_GATHERED_A, m_Gathered_A);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_SI_GATHERED_H, m_Gathered_H);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_SI_SILITHYST_MAX, SI_MAX_RESOURCES);
}
void OutdoorPvPSI::SendRemoveWorldStates(Player* player)
{
player->SendUpdateWorldState(SI_GATHERED_A, 0);
player->SendUpdateWorldState(SI_GATHERED_H, 0);
player->SendUpdateWorldState(SI_SILITHYST_MAX, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_SI_GATHERED_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_SI_GATHERED_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_SI_SILITHYST_MAX, 0);
}
void OutdoorPvPSI::UpdateWorldState()
{
SendUpdateWorldState(SI_GATHERED_A, m_Gathered_A);
SendUpdateWorldState(SI_GATHERED_H, m_Gathered_H);
SendUpdateWorldState(SI_SILITHYST_MAX, SI_MAX_RESOURCES);
SendUpdateWorldState(WORLD_STATE_OPVP_SI_GATHERED_A, m_Gathered_A);
SendUpdateWorldState(WORLD_STATE_OPVP_SI_GATHERED_H, m_Gathered_H);
SendUpdateWorldState(WORLD_STATE_OPVP_SI_SILITHYST_MAX, SI_MAX_RESOURCES);
}
bool OutdoorPvPSI::SetupOutdoorPvP()

7
src/server/scripts/OutdoorPvP/OutdoorPvPSI.h
View File

@@ -44,13 +44,6 @@ const uint32 SI_TURNIN_QUEST_CM_H = 18199;
const uint32 SI_SILITHYST_MOUND = 181597;
enum SI_WorldStates
{
SI_GATHERED_A = 2313,
SI_GATHERED_H = 2314,
SI_SILITHYST_MAX = 2317
};
class OutdoorPvPSI : public OutdoorPvP
{
public:

116
src/server/scripts/OutdoorPvP/OutdoorPvPTF.cpp
View File

@@ -63,19 +63,19 @@ void OPvPCapturePointTF::FillInitialWorldStates(WorldPackets::WorldState::InitWo
void OutdoorPvPTF::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(12);
packet.Worldstates.emplace_back(TF_UI_TOWER_SLIDER_POS, 50);
packet.Worldstates.emplace_back(TF_UI_TOWER_SLIDER_N, 100);
packet.Worldstates.emplace_back(TF_UI_TOWER_SLIDER_DISPLAY, 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_POS, 50);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_N, 100);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_DISPLAY, 0);
packet.Worldstates.emplace_back(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
packet.Worldstates.emplace_back(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
packet.Worldstates.emplace_back(TF_UI_TOWERS_CONTROLLED_DISPLAY, !m_IsLocked);
packet.Worldstates.emplace_back(TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, first_digit);
packet.Worldstates.emplace_back(TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, second_digit);
packet.Worldstates.emplace_back(TF_UI_LOCKED_TIME_HOURS, hours_left);
packet.Worldstates.emplace_back(TF_UI_LOCKED_DISPLAY_NEUTRAL, (m_IsLocked && !m_HordeTowersControlled && !m_AllianceTowersControlled) ? 1 : 0);
packet.Worldstates.emplace_back(TF_UI_LOCKED_DISPLAY_HORDE, (m_IsLocked && (m_HordeTowersControlled > m_AllianceTowersControlled)) ? 1 : 0);
packet.Worldstates.emplace_back(TF_UI_LOCKED_DISPLAY_ALLIANCE, (m_IsLocked && (m_HordeTowersControlled < m_AllianceTowersControlled)) ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY, !m_IsLocked);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, first_digit);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, second_digit);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_HOURS, hours_left);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_NEUTRAL, (m_IsLocked && !m_HordeTowersControlled && !m_AllianceTowersControlled) ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_HORDE, (m_IsLocked && (m_HordeTowersControlled > m_AllianceTowersControlled)) ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_ALLIANCE, (m_IsLocked && (m_HordeTowersControlled < m_AllianceTowersControlled)) ? 1 : 0);
for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{
@@ -85,21 +85,21 @@ void OutdoorPvPTF::FillInitialWorldStates(WorldPackets::WorldState::InitWorldSta
void OutdoorPvPTF::SendRemoveWorldStates(Player* player)
{
player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, uint32(0));
player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_N, uint32(0));
player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_POS, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_N, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_DISPLAY, uint32(0));
player->SendUpdateWorldState(TF_UI_TOWER_COUNT_H, uint32(0));
player->SendUpdateWorldState(TF_UI_TOWER_COUNT_A, uint32(0));
player->SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_H, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_A, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
player->SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, uint32(0));
player->SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, uint32(0));
player->SendUpdateWorldState(TF_UI_LOCKED_TIME_HOURS, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_HOURS, uint32(0));
player->SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
player->SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
player->SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
for (int i = 0; i < TF_TOWER_NUM; ++i)
{
@@ -111,14 +111,14 @@ void OutdoorPvPTF::SendRemoveWorldStates(Player* player)
void OutdoorPvPTF::SaveRequiredWorldStates() const
{
sWorld->setWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
sWorld->setWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
sWorld->setWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
sWorld->setWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
sWorld->setWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, m_IsLocked);
sWorld->setWorldState(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY, m_IsLocked);
// Save expiry as unix
uint32 const lockExpireTime = GameTime::GetGameTime().count() + (m_LockTimer / IN_MILLISECONDS);
sWorld->setWorldState(TF_UI_LOCKED_TIME_HOURS, lockExpireTime);
sWorld->setWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_HOURS, lockExpireTime);
}
void OutdoorPvPTF::ResetZoneToTeamControlled(TeamId team)
@@ -144,8 +144,8 @@ void OutdoorPvPTF::ResetZoneToTeamControlled(TeamId team)
dynamic_cast<OPvPCapturePointTF*>(tower)->ResetToTeamControlled(team);
}
SendUpdateWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
SendUpdateWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
}
void OPvPCapturePointTF::ResetToTeamControlled(TeamId team)
@@ -185,10 +185,10 @@ bool OPvPCapturePointTF::HandlePlayerEnter(Player* player)
{
if (OPvPCapturePoint::HandlePlayerEnter(player))
{
player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 1);
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_DISPLAY, 1);
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_N, _neutralValuePct);
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_POS, phase);
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_N, _neutralValuePct);
return true;
}
return false;
@@ -196,7 +196,7 @@ bool OPvPCapturePointTF::HandlePlayerEnter(Player* player)
void OPvPCapturePointTF::HandlePlayerLeave(Player* player)
{
player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_DISPLAY, 0);
OPvPCapturePoint::HandlePlayerLeave(player);
}
@@ -211,20 +211,20 @@ bool OutdoorPvPTF::Update(uint32 diff)
TeamApplyBuff(TEAM_ALLIANCE, TF_CAPTURE_BUFF);
m_IsLocked = true;
m_JustLocked = true;
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(1));
SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(1));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
}
else if (m_HordeTowersControlled == TF_TOWER_NUM)
{
TeamApplyBuff(TEAM_HORDE, TF_CAPTURE_BUFF);
m_IsLocked = true;
m_JustLocked = true;
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(1));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_HORDE, uint32(1));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
}
else
{
@@ -232,8 +232,8 @@ bool OutdoorPvPTF::Update(uint32 diff)
TeamCastSpell(TEAM_HORDE, -TF_CAPTURE_BUFF);
}
SendUpdateWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SendUpdateWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
}
if (m_IsLocked)
@@ -254,10 +254,10 @@ bool OutdoorPvPTF::Update(uint32 diff)
ResetZoneToTeamControlled(TEAM_NEUTRAL);
SaveRequiredWorldStates();
SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(1));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(1));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
}
else
{
@@ -267,9 +267,9 @@ bool OutdoorPvPTF::Update(uint32 diff)
m_LockTimerUpdate = TF_LOCK_TIME_UPDATE;
RecalculateClientUILockTime();
SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, first_digit);
SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, second_digit);
SendUpdateWorldState(TF_UI_LOCKED_TIME_HOURS, hours_left);
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, first_digit);
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, second_digit);
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_HOURS, hours_left);
}
else
{
@@ -335,7 +335,7 @@ bool OutdoorPvPTF::SetupOutdoorPvP()
m_AllianceTowersControlled = 0;
m_HordeTowersControlled = 0;
m_IsLocked = bool(sWorld->getWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY));
m_IsLocked = bool(sWorld->getWorldState(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY));
m_JustLocked = false;
m_LockTimer = TF_LOCK_TIME;
m_LockTimerUpdate = 0;
@@ -359,14 +359,14 @@ bool OutdoorPvPTF::SetupOutdoorPvP()
{
// Core shutdown while locked -- init from latest known data in WorldState
// Convert from unix
int32 const lockRemainingTime = int32((sWorld->getWorldState(TF_UI_LOCKED_TIME_HOURS) - GameTime::GetGameTime().count()) * IN_MILLISECONDS);
int32 const lockRemainingTime = int32((sWorld->getWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_HOURS) - GameTime::GetGameTime().count()) * IN_MILLISECONDS);
if (lockRemainingTime > 0)
{
m_LockTimer = lockRemainingTime;
RecalculateClientUILockTime();
uint32 const hordeTowers = uint32(sWorld->getWorldState(TF_UI_TOWER_COUNT_H));
uint32 const allianceTowers = uint32(sWorld->getWorldState(TF_UI_TOWER_COUNT_A));
uint32 const hordeTowers = uint32(sWorld->getWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_H));
uint32 const allianceTowers = uint32(sWorld->getWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_A));
TeamId const controllingTeam = hordeTowers > allianceTowers ? TEAM_HORDE : TEAM_ALLIANCE;
ResetZoneToTeamControlled(controllingTeam);
@@ -462,12 +462,12 @@ void OPvPCapturePointTF::ChangeState()
void OPvPCapturePointTF::SendChangePhase()
{
// send this too, sometimes the slider disappears, dunno why :(
SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, 1);
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_DISPLAY, 1);
// send these updates to only the ones in this objective
uint32 phase = (uint32)ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f);
SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, phase);
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_POS, phase);
// send this too, sometimes it resets :S
SendUpdateWorldState(TF_UI_TOWER_SLIDER_N, _neutralValuePct);
SendUpdateWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_SLIDER_N, _neutralValuePct);
}
class OutdoorPvP_terokkar_forest : public OutdoorPvPScript

29
src/server/scripts/OutdoorPvP/OutdoorPvPTF.h
View File

@@ -19,6 +19,7 @@
#define OUTDOOR_PVP_TF_
#include "OutdoorPvP.h"
#include "WorldStateDefines.h"
const uint8 OutdoorPvPTFBuffZonesNum = 5;
@@ -71,11 +72,11 @@ struct tf_tower_world_state
const tf_tower_world_state TFTowerWorldStates[TF_TOWER_NUM] =
{
{0xa79, 0xa7a, 0xa7b},
{0xa7e, 0xa7d, 0xa7c},
{0xa82, 0xa81, 0xa80},
{0xa88, 0xa87, 0xa86},
{0xa85, 0xa84, 0xa83}
{WORLD_STATE_OPVP_TF_TOWER_NUM_00, WORLD_STATE_OPVP_TF_TOWER_NUM_01, WORLD_STATE_OPVP_TF_TOWER_NUM_02},
{WORLD_STATE_OPVP_TF_TOWER_NUM_05, WORLD_STATE_OPVP_TF_TOWER_NUM_04, WORLD_STATE_OPVP_TF_TOWER_NUM_03},
{WORLD_STATE_OPVP_TF_TOWER_NUM_08, WORLD_STATE_OPVP_TF_TOWER_NUM_07, WORLD_STATE_OPVP_TF_TOWER_NUM_06},
{WORLD_STATE_OPVP_TF_TOWER_NUM_14, WORLD_STATE_OPVP_TF_TOWER_NUM_13, WORLD_STATE_OPVP_TF_TOWER_NUM_12},
{WORLD_STATE_OPVP_TF_TOWER_NUM_11, WORLD_STATE_OPVP_TF_TOWER_NUM_10, WORLD_STATE_OPVP_TF_TOWER_NUM_09}
};
//const uint32 TFTowerPlayerEnterEvents[TF_TOWER_NUM] =
@@ -96,24 +97,6 @@ const tf_tower_world_state TFTowerWorldStates[TF_TOWER_NUM] =
// 12500
//};
enum TFWorldStates
{
TF_UI_TOWER_SLIDER_POS = 0xa41,
TF_UI_TOWER_SLIDER_N = 0xa40,
TF_UI_TOWER_SLIDER_DISPLAY = 0xa3f,
TF_UI_TOWER_COUNT_H = 0xa3e,
TF_UI_TOWER_COUNT_A = 0xa3d,
TF_UI_TOWERS_CONTROLLED_DISPLAY = 0xa3c,
TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT = 0x9d0,
TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT = 0x9ce,
TF_UI_LOCKED_TIME_HOURS = 0x9cd,
TF_UI_LOCKED_DISPLAY_NEUTRAL = 0x9cc,
TF_UI_LOCKED_DISPLAY_HORDE = 0xad0,
TF_UI_LOCKED_DISPLAY_ALLIANCE = 0xacf
};
enum TFTowerStates
{
TF_TOWERSTATE_N = 1,

83
src/server/scripts/OutdoorPvP/OutdoorPvPZM.cpp
View File

@@ -26,6 +26,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSessionMgr.h"
#include "WorldStateDefines.h"
#include "WorldStatePackets.h"
OPvPCapturePointZM_Beacon::OPvPCapturePointZM_Beacon(OutdoorPvP* pvp, ZM_BeaconType type)
@@ -269,26 +270,26 @@ OPvPCapturePointZM_Graveyard::OPvPCapturePointZM_Graveyard(OutdoorPvP* pvp)
void OPvPCapturePointZM_Graveyard::UpdateTowerState()
{
_pvp->SendUpdateWorldState(ZM_MAP_GRAVEYARD_N, uint32(bool(m_GraveyardState & ZM_GRAVEYARD_N)));
_pvp->SendUpdateWorldState(ZM_MAP_GRAVEYARD_H, uint32(bool(m_GraveyardState & ZM_GRAVEYARD_H)));
_pvp->SendUpdateWorldState(ZM_MAP_GRAVEYARD_A, uint32(bool(m_GraveyardState & ZM_GRAVEYARD_A)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_GRAVEYARD_N, uint32(bool(m_GraveyardState & ZM_GRAVEYARD_N)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_GRAVEYARD_H, uint32(bool(m_GraveyardState & ZM_GRAVEYARD_H)));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_GRAVEYARD_A, uint32(bool(m_GraveyardState & ZM_GRAVEYARD_A)));
_pvp->SendUpdateWorldState(ZM_MAP_ALLIANCE_FLAG_READY, uint32(m_BothControllingFactionId == TEAM_ALLIANCE));
_pvp->SendUpdateWorldState(ZM_MAP_ALLIANCE_FLAG_NOT_READY, uint32(m_BothControllingFactionId != TEAM_ALLIANCE));
_pvp->SendUpdateWorldState(ZM_MAP_HORDE_FLAG_READY, uint32(m_BothControllingFactionId == TEAM_HORDE));
_pvp->SendUpdateWorldState(ZM_MAP_HORDE_FLAG_NOT_READY, uint32(m_BothControllingFactionId != TEAM_HORDE));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_ALLIANCE_FLAG_READY, uint32(m_BothControllingFactionId == TEAM_ALLIANCE));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_ALLIANCE_FLAG_NOT_READY, uint32(m_BothControllingFactionId != TEAM_ALLIANCE));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_HORDE_FLAG_READY, uint32(m_BothControllingFactionId == TEAM_HORDE));
_pvp->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_HORDE_FLAG_NOT_READY, uint32(m_BothControllingFactionId != TEAM_HORDE));
}
void OPvPCapturePointZM_Graveyard::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(7);
packet.Worldstates.emplace_back(ZM_MAP_GRAVEYARD_N, (m_GraveyardState & ZM_GRAVEYARD_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(ZM_MAP_GRAVEYARD_H, (m_GraveyardState & ZM_GRAVEYARD_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(ZM_MAP_GRAVEYARD_A, (m_GraveyardState & ZM_GRAVEYARD_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(ZM_MAP_ALLIANCE_FLAG_READY, m_BothControllingFactionId == TEAM_ALLIANCE ? 1 : 0);
packet.Worldstates.emplace_back(ZM_MAP_ALLIANCE_FLAG_NOT_READY, m_BothControllingFactionId != TEAM_ALLIANCE ? 1 : 0);
packet.Worldstates.emplace_back(ZM_MAP_HORDE_FLAG_READY, m_BothControllingFactionId == TEAM_HORDE ? 1 : 0);
packet.Worldstates.emplace_back(ZM_MAP_HORDE_FLAG_NOT_READY, m_BothControllingFactionId != TEAM_HORDE ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_ZM_MAP_GRAVEYARD_N, (m_GraveyardState & ZM_GRAVEYARD_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_ZM_MAP_GRAVEYARD_H, (m_GraveyardState & ZM_GRAVEYARD_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_ZM_MAP_GRAVEYARD_A, (m_GraveyardState & ZM_GRAVEYARD_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_ZM_MAP_ALLIANCE_FLAG_READY, m_BothControllingFactionId == TEAM_ALLIANCE ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_ZM_MAP_ALLIANCE_FLAG_NOT_READY, m_BothControllingFactionId != TEAM_ALLIANCE ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_ZM_MAP_HORDE_FLAG_READY, m_BothControllingFactionId == TEAM_HORDE ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_ZM_MAP_HORDE_FLAG_NOT_READY, m_BothControllingFactionId != TEAM_HORDE ? 1 : 0);
}
void OPvPCapturePointZM_Graveyard::SetBeaconState(TeamId controlling_factionId)
@@ -417,7 +418,7 @@ void OutdoorPvPZM::SetHordeTowersControlled(uint32 count)
void OutdoorPvPZM::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.emplace_back(ZM_WORLDSTATE_UNK_1, 1);
packet.Worldstates.emplace_back(WORLD_STATE_OPVP_ZM_UNK, 1);
for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{
itr->second->FillInitialWorldStates(packet);
@@ -426,32 +427,32 @@ void OutdoorPvPZM::FillInitialWorldStates(WorldPackets::WorldState::InitWorldSta
void OutdoorPvPZM::SendRemoveWorldStates(Player* player)
{
player->SendUpdateWorldState(ZM_UI_TOWER_SLIDER_N_W, 0);
player->SendUpdateWorldState(ZM_UI_TOWER_SLIDER_POS_W, 0);
player->SendUpdateWorldState(ZM_UI_TOWER_SLIDER_DISPLAY_W, 0);
player->SendUpdateWorldState(ZM_UI_TOWER_SLIDER_N_E, 0);
player->SendUpdateWorldState(ZM_UI_TOWER_SLIDER_POS_E, 0);
player->SendUpdateWorldState(ZM_UI_TOWER_SLIDER_DISPLAY_E, 0);
player->SendUpdateWorldState(ZM_WORLDSTATE_UNK_1, 1);
player->SendUpdateWorldState(ZM_UI_TOWER_EAST_N, 0);
player->SendUpdateWorldState(ZM_UI_TOWER_EAST_H, 0);
player->SendUpdateWorldState(ZM_UI_TOWER_EAST_A, 0);
player->SendUpdateWorldState(ZM_UI_TOWER_WEST_N, 0);
player->SendUpdateWorldState(ZM_UI_TOWER_WEST_H, 0);
player->SendUpdateWorldState(ZM_UI_TOWER_WEST_A, 0);
player->SendUpdateWorldState(ZM_MAP_TOWER_EAST_N, 0);
player->SendUpdateWorldState(ZM_MAP_TOWER_EAST_H, 0);
player->SendUpdateWorldState(ZM_MAP_TOWER_EAST_A, 0);
player->SendUpdateWorldState(ZM_MAP_GRAVEYARD_H, 0);
player->SendUpdateWorldState(ZM_MAP_GRAVEYARD_A, 0);
player->SendUpdateWorldState(ZM_MAP_GRAVEYARD_N, 0);
player->SendUpdateWorldState(ZM_MAP_TOWER_WEST_N, 0);
player->SendUpdateWorldState(ZM_MAP_TOWER_WEST_H, 0);
player->SendUpdateWorldState(ZM_MAP_TOWER_WEST_A, 0);
player->SendUpdateWorldState(ZM_MAP_HORDE_FLAG_READY, 0);
player->SendUpdateWorldState(ZM_MAP_HORDE_FLAG_NOT_READY, 0);
player->SendUpdateWorldState(ZM_MAP_ALLIANCE_FLAG_NOT_READY, 0);
player->SendUpdateWorldState(ZM_MAP_ALLIANCE_FLAG_READY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_SLIDER_N_W, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_SLIDER_POS_W, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_SLIDER_DISPLAY_W, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_SLIDER_N_E, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_SLIDER_POS_E, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_SLIDER_DISPLAY_E, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UNK, 1);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_EAST_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_EAST_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_EAST_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_WEST_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_WEST_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_UI_TOWER_WEST_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_TOWER_EAST_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_TOWER_EAST_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_TOWER_EAST_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_GRAVEYARD_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_GRAVEYARD_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_GRAVEYARD_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_TOWER_WEST_N, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_TOWER_WEST_H, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_TOWER_WEST_A, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_HORDE_FLAG_READY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_HORDE_FLAG_NOT_READY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_ALLIANCE_FLAG_NOT_READY, 0);
player->SendUpdateWorldState(WORLD_STATE_OPVP_ZM_MAP_ALLIANCE_FLAG_READY, 0);
}
class OutdoorPvP_zangarmarsh : public OutdoorPvPScript

35
src/server/scripts/OutdoorPvP/OutdoorPvPZM.h
View File

@@ -122,41 +122,6 @@ const go_type ZMCapturePoints[ZM_NUM_BEACONS] =
{182522, 530, 336.466f, 7340.26f, 41.4984f, -1.58825f, 0.0f, 0.0f, 0.71325f, -0.700909f}
};
enum OutdoorPvPZMWorldStates
{
ZM_UI_TOWER_SLIDER_N_W = 2529,
ZM_UI_TOWER_SLIDER_POS_W = 2528,
ZM_UI_TOWER_SLIDER_DISPLAY_W = 2527,
ZM_UI_TOWER_SLIDER_N_E = 2535,
ZM_UI_TOWER_SLIDER_POS_E = 2534,
ZM_UI_TOWER_SLIDER_DISPLAY_E = 2533,
ZM_WORLDSTATE_UNK_1 = 2653,
ZM_UI_TOWER_EAST_N = 2560,
ZM_UI_TOWER_EAST_H = 2559,
ZM_UI_TOWER_EAST_A = 2558,
ZM_UI_TOWER_WEST_N = 2557,
ZM_UI_TOWER_WEST_H = 2556,
ZM_UI_TOWER_WEST_A = 2555,
ZM_MAP_TOWER_EAST_N = 2652,
ZM_MAP_TOWER_EAST_H = 2651,
ZM_MAP_TOWER_EAST_A = 2650,
ZM_MAP_GRAVEYARD_H = 2649,
ZM_MAP_GRAVEYARD_A = 2648,
ZM_MAP_GRAVEYARD_N = 2647,
ZM_MAP_TOWER_WEST_N = 2646,
ZM_MAP_TOWER_WEST_H = 2645,
ZM_MAP_TOWER_WEST_A = 2644,
ZM_MAP_HORDE_FLAG_READY = 2658,
ZM_MAP_HORDE_FLAG_NOT_READY = 2657,
ZM_MAP_ALLIANCE_FLAG_NOT_READY = 2656,
ZM_MAP_ALLIANCE_FLAG_READY = 2655
};
enum ZM_TowerStateMask
{
ZM_TOWERSTATE_N = 1,