fang139842/azerothcore-wotlk2
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor(Core/Packet): use WorldPackets::WorldState::InitWorldStates definition (#20475)

Browse Source 
Co-authored-by: ccrs <ccrs@users.noreply.github.com>
This commit is contained in:
Jelle Meeus 2025-02-19 11:55:09 +01:00 committed by GitHub
parent bc17d068cd
commit 4c4b04f07b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
55 changed files with 1006 additions and 947 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/server/game/Battlefield/Battlefield.h
View File

@ -81,7 +81,7 @@ public:
virtual ~BfCapturePoint() { }
virtual void FillInitialWorldStates(WorldPacket& /*data*/) {}
virtual void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& /*packet*/) { }
// Send world state update to all players present
void SendUpdateWorldState(uint32 field, uint32 value);
@ -334,7 +334,7 @@ public:
/// Send all worldstate data to all player in zone.
virtual void SendInitWorldStatesToAll() = 0;
virtual void FillInitialWorldStates(WorldPacket& /*data*/) = 0;
virtual void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& /*packet*/) = 0;
/// Return if we can use mount in battlefield
bool CanFlyIn() { return !m_isActive; }

61
src/server/game/Battlefield/Zones/BattlefieldWG.cpp
View File

@ -29,6 +29,7 @@
#include "TemporarySummon.h"
#include "Vehicle.h"
#include "WorldSession.h"
#include "WorldStatePackets.h"
BattlefieldWG::~BattlefieldWG()
{
@ -74,7 +75,7 @@ bool BattlefieldWG::SetupBattlefield()
m_saveTimer = 60000;
// Init GraveYards
// Init Graveyards
SetGraveyardNumber(BATTLEFIELD_WG_GRAVEYARD_MAX);
// Load from db
@ -102,12 +103,12 @@ bool BattlefieldWG::SetupBattlefield()
BfGraveyardWG* graveyard = new BfGraveyardWG(this);
// When between games, the graveyard is controlled by the defending team
if (WGGraveYard[i].startcontrol == TEAM_NEUTRAL)
graveyard->Initialize(WGGraveYard[i].gyid == BATTLEFIELD_WG_GY_WORKSHOP_SE || WGGraveYard[i].gyid == BATTLEFIELD_WG_GY_WORKSHOP_SW ? GetAttackerTeam() : m_DefenderTeam, WGGraveYard[i].gyid);
if (WGGraveyard[i].startcontrol == TEAM_NEUTRAL)
graveyard->Initialize(WGGraveyard[i].gyid == BATTLEFIELD_WG_GY_WORKSHOP_SE || WGGraveyard[i].gyid == BATTLEFIELD_WG_GY_WORKSHOP_SW ? GetAttackerTeam() : m_DefenderTeam, WGGraveyard[i].gyid);
else
graveyard->Initialize(WGGraveYard[i].startcontrol, WGGraveYard[i].gyid);
graveyard->Initialize(WGGraveyard[i].startcontrol, WGGraveyard[i].gyid);
graveyard->SetTextId(WGGraveYard[i].textid);
graveyard->SetTextId(WGGraveyard[i].textid);
m_GraveyardList[i] = graveyard;
}
@ -933,46 +934,46 @@ uint32 BattlefieldWG::GetData(uint32 data) const
return Battlefield::GetData(data);
}
void BattlefieldWG::FillInitialWorldStates(WorldPacket& data)
void BattlefieldWG::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(BATTLEFIELD_WG_WORLD_STATE_ATTACKER) << uint32(GetAttackerTeam());
data << uint32(BATTLEFIELD_WG_WORLD_STATE_DEFENDER) << uint32(GetDefenderTeam());
data << uint32(BATTLEFIELD_WG_WORLD_STATE_ACTIVE) << uint32(IsWarTime() ? 0 : 1); // Note: cleanup these two, their names look awkward
data << uint32(BATTLEFIELD_WG_WORLD_STATE_SHOW_WORLDSTATE) << uint32(IsWarTime() ? 1 : 0);
packet.Worldstates.reserve(4+2+WG_MAX_OBJ+WG_MAX_WORKSHOP);
packet.Worldstates.emplace_back(BATTLEFIELD_WG_WORLD_STATE_ATTACKER, GetAttackerTeam());
packet.Worldstates.emplace_back(BATTLEFIELD_WG_WORLD_STATE_DEFENDER, GetDefenderTeam());
// Note: cleanup these two, their names look awkward
packet.Worldstates.emplace_back(BATTLEFIELD_WG_WORLD_STATE_ACTIVE, IsWarTime() ? 0 : 1);
packet.Worldstates.emplace_back(BATTLEFIELD_WG_WORLD_STATE_SHOW_WORLDSTATE, IsWarTime() ? 1 : 0);
for (uint32 i = 0; i < 2; ++i)
data << ClockWorldState[i] << uint32(GameTime::GetGameTime().count() + (m_Timer / 1000));
packet.Worldstates.emplace_back(ClockWorldState[i], GameTime::GetGameTime().count() + (m_Timer / 1000));
data << uint32(BATTLEFIELD_WG_WORLD_STATE_VEHICLE_H) << uint32(GetData(BATTLEFIELD_WG_DATA_VEHICLE_H));
data << uint32(BATTLEFIELD_WG_WORLD_STATE_MAX_VEHICLE_H) << GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_H);
data << uint32(BATTLEFIELD_WG_WORLD_STATE_VEHICLE_A) << uint32(GetData(BATTLEFIELD_WG_DATA_VEHICLE_A));
data << uint32(BATTLEFIELD_WG_WORLD_STATE_MAX_VEHICLE_A) << GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A);
packet.Worldstates.emplace_back(BATTLEFIELD_WG_WORLD_STATE_VEHICLE_H, GetData(BATTLEFIELD_WG_DATA_VEHICLE_H));
packet.Worldstates.emplace_back(BATTLEFIELD_WG_WORLD_STATE_MAX_VEHICLE_H, GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_H));
packet.Worldstates.emplace_back(BATTLEFIELD_WG_WORLD_STATE_VEHICLE_A, GetData(BATTLEFIELD_WG_DATA_VEHICLE_A));
packet.Worldstates.emplace_back(BATTLEFIELD_WG_WORLD_STATE_MAX_VEHICLE_A, GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A));
data << uint32(WORLDSTATE_HORDE_KEEP_CAPTURED) << uint32(sWorld->getWorldState(WORLDSTATE_HORDE_KEEP_CAPTURED));
data << uint32(WORLDSTATE_HORDE_KEEP_DEFENDED) << uint32(sWorld->getWorldState(WORLDSTATE_HORDE_KEEP_DEFENDED));
data << uint32(WORLDSTATE_ALLIANCE_KEEP_CAPTURED) << uint32(sWorld->getWorldState(WORLDSTATE_ALLIANCE_KEEP_CAPTURED));
data << uint32(WORLDSTATE_ALLIANCE_KEEP_DEFENDED) << uint32(sWorld->getWorldState(WORLDSTATE_ALLIANCE_KEEP_DEFENDED));
packet.Worldstates.emplace_back(WORLDSTATE_ALLIANCE_KEEP_DEFENDED, uint32(sWorld->getWorldState(WORLDSTATE_ALLIANCE_KEEP_DEFENDED)));
packet.Worldstates.emplace_back(WORLDSTATE_HORDE_KEEP_CAPTURED, uint32(sWorld->getWorldState(WORLDSTATE_HORDE_KEEP_CAPTURED)));
packet.Worldstates.emplace_back(WORLDSTATE_HORDE_KEEP_DEFENDED, uint32(sWorld->getWorldState(WORLDSTATE_HORDE_KEEP_DEFENDED)));
packet.Worldstates.emplace_back(WORLDSTATE_ALLIANCE_KEEP_CAPTURED, uint32(sWorld->getWorldState(WORLDSTATE_ALLIANCE_KEEP_CAPTURED)));
for (GameObjectBuilding::const_iterator itr = BuildingsInZone.begin(); itr != BuildingsInZone.end(); ++itr)
data << (*itr)->m_WorldState << (*itr)->m_State;
packet.Worldstates.emplace_back((*itr)->m_WorldState, (*itr)->m_State);
for (Workshop::const_iterator itr = WorkshopsList.begin(); itr != WorkshopsList.end(); ++itr)
if (*itr)
data << WorkshopsData[(*itr)->workshopId].worldstate << (*itr)->state;
packet.Worldstates.emplace_back(WorkshopsData[(*itr)->workshopId].worldstate, (*itr)->state);
}
void BattlefieldWG::SendInitWorldStatesTo(Player* player)
{
WorldPacket data(SMSG_INIT_WORLD_STATES, (4 + 4 + 4 + 2 + (BuildingsInZone.size() * 8) + (WorkshopsList.size() * 8)));
WorldPackets::WorldState::InitWorldStates packet;
packet.MapID = m_MapId;
packet.ZoneID = m_ZoneId;
packet.AreaID = player->GetAreaId();
FillInitialWorldStates(packet);
data << uint32(m_MapId);
data << uint32(m_ZoneId);
data << uint32(0);
data << uint16(14 + BuildingsInZone.size() + WorkshopsList.size()); // Number of fields
FillInitialWorldStates(data);
player->GetSession()->SendPacket(&data);
player->SendDirectMessage(packet.Write());
}
void BattlefieldWG::SendInitWorldStatesToAll()

5
src/server/game/Battlefield/Zones/BattlefieldWG.h
View File

@ -21,6 +21,7 @@
#include "Battlefield.h"
#include "Log.h"
#include "World.h"
#include "WorldStatePackets.h"
class Group;
class BattlefieldWG;
@ -238,7 +239,7 @@ const uint32 WGQuest[2][6] =
{ 13185, 13183, 13223, 13539, 13178, 13180 },
};
// 7 in sql, 7 in header
const BfWGCoordGY WGGraveYard[BATTLEFIELD_WG_GRAVEYARD_MAX] =
const BfWGCoordGY WGGraveyard[BATTLEFIELD_WG_GRAVEYARD_MAX] =
{
{ 5104.750f, 2300.940f, 368.579f, 0.733038f, 1329, BATTLEFIELD_WG_GY_WORKSHOP_NE, BATTLEFIELD_WG_GOSSIPTEXT_GY_NE, TEAM_NEUTRAL },
{ 5099.120f, 3466.036f, 368.484f, 5.317802f, 1330, BATTLEFIELD_WG_GY_WORKSHOP_NW, BATTLEFIELD_WG_GOSSIPTEXT_GY_NW, TEAM_NEUTRAL },
@ -403,7 +404,7 @@ public:
void SendInitWorldStatesTo(Player* player);
void SendInitWorldStatesToAll() override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void HandleKill(Player* killer, Unit* victim) override;
void OnUnitDeath(Unit* unit) override;

9
src/server/game/Battlegrounds/Arena.cpp
View File

@ -26,7 +26,7 @@
#include "World.h"
#include "WorldSession.h"
#include "WorldSessionMgr.h"
//#include "WorldStatePackets.h"
#include "WorldStatePackets.h"
void ArenaScore::AppendToPacket(WorldPacket& data)
{
@ -147,10 +147,11 @@ void Arena::RemovePlayer(Player* /*player*/)
CheckWinConditions();
}
void Arena::FillInitialWorldStates(WorldPacket& data)
void Arena::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(ARENA_WORLD_STATE_ALIVE_PLAYERS_GREEN) << uint32(GetAlivePlayersCountByTeam(TEAM_HORDE));
data << uint32(ARENA_WORLD_STATE_ALIVE_PLAYERS_GOLD) << uint32(GetAlivePlayersCountByTeam(TEAM_ALLIANCE));
packet.Worldstates.reserve(2);
packet.Worldstates.emplace_back(ARENA_WORLD_STATE_ALIVE_PLAYERS_GREEN, GetAlivePlayersCountByTeam(TEAM_HORDE));
packet.Worldstates.emplace_back(ARENA_WORLD_STATE_ALIVE_PLAYERS_GOLD, GetAlivePlayersCountByTeam(TEAM_ALLIANCE));
}
void Arena::UpdateArenaWorldState()

2
src/server/game/Battlegrounds/Arena.h
View File

@ -52,7 +52,7 @@ protected:
void AddPlayer(Player* player) override;
void RemovePlayer(Player* /*player*/) override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void UpdateArenaWorldState();
void HandleKillPlayer(Player* player, Player* killer) override;

3
src/server/game/Battlegrounds/Battleground.h
View File

@ -24,6 +24,7 @@
#include "GameObject.h"
#include "SharedDefines.h"
#include "World.h"
#include "WorldStatePackets.h"
class Creature;
class GameObject;
@ -457,7 +458,7 @@ public:
// Packet Transfer
// method that should fill worldpacket with actual world states (not yet implemented for all battlegrounds!)
virtual void FillInitialWorldStates(WorldPacket& /*data*/) { }
virtual void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& /*packet*/) { }
void SendPacketToTeam(TeamId teamId, WorldPacket const* packet, Player* sender = nullptr, bool self = true);
void SendPacketToAll(WorldPacket const* packet);
void YellToAll(Creature* creature, const char* text, uint32 language);

23
src/server/game/Battlegrounds/Zones/BattlegroundAB.cpp
View File

@ -23,6 +23,7 @@
#include "Util.h"
#include "WorldPacket.h"
#include "WorldSession.h"
#include "WorldStatePackets.h"
void BattlegroundABScore::BuildObjectivesBlock(WorldPacket& data)
{
@ -234,24 +235,26 @@ void BattlegroundAB::DeleteBanner(uint8 node)
SpawnBGObject(node * BG_AB_OBJECTS_PER_NODE + BG_AB_OBJECT_AURA_ALLY + _capturePointInfo[node]._ownerTeamId, RESPAWN_ONE_DAY);
}
void BattlegroundAB::FillInitialWorldStates(WorldPacket& data)
void BattlegroundAB::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(BG_AB_DYNAMIC_NODES_COUNT+7);
for (auto& node : _capturePointInfo)
{
if (node._state == BG_AB_NODE_STATE_NEUTRAL)
data << uint32(node._iconNone) << uint32(1);
packet.Worldstates.emplace_back(node._iconNone, 1);
for (uint8 i = BG_AB_NODE_STATE_ALLY_OCCUPIED; i <= BG_AB_NODE_STATE_HORDE_CONTESTED; ++i)
data << uint32(node._iconCapture + i - 1) << uint32(node._state == i);
packet.Worldstates.emplace_back(node._iconCapture + i - 1, node._state == i ? 1 : 0);
}
data << uint32(BG_AB_OP_OCCUPIED_BASES_ALLY) << uint32(_controlledPoints[TEAM_ALLIANCE]);
data << uint32(BG_AB_OP_OCCUPIED_BASES_HORDE) << uint32(_controlledPoints[TEAM_HORDE]);
data << uint32(BG_AB_OP_RESOURCES_MAX) << uint32(BG_AB_MAX_TEAM_SCORE);
data << uint32(BG_AB_OP_RESOURCES_WARNING) << uint32(BG_AB_WARNING_NEAR_VICTORY_SCORE);
data << uint32(BG_AB_OP_RESOURCES_ALLY) << uint32(m_TeamScores[TEAM_ALLIANCE]);
data << uint32(BG_AB_OP_RESOURCES_HORDE) << uint32(m_TeamScores[TEAM_HORDE]);
data << uint32(0x745) << uint32(0x2); // 37 1861 unk
packet.Worldstates.emplace_back(BG_AB_OP_OCCUPIED_BASES_ALLY, _controlledPoints[TEAM_ALLIANCE]);
packet.Worldstates.emplace_back(BG_AB_OP_OCCUPIED_BASES_HORDE, _controlledPoints[TEAM_HORDE]);
packet.Worldstates.emplace_back(BG_AB_OP_RESOURCES_MAX, BG_AB_MAX_TEAM_SCORE);
packet.Worldstates.emplace_back(BG_AB_OP_RESOURCES_WARNING, BG_AB_WARNING_NEAR_VICTORY_SCORE);
packet.Worldstates.emplace_back(BG_AB_OP_RESOURCES_ALLY, m_TeamScores[TEAM_ALLIANCE]);
packet.Worldstates.emplace_back(BG_AB_OP_RESOURCES_HORDE, m_TeamScores[TEAM_HORDE]);
packet.Worldstates.emplace_back(0x745, 2);
}
void BattlegroundAB::SendNodeUpdate(uint8 node)

2
src/server/game/Battlegrounds/Zones/BattlegroundAB.h
View File

@ -304,7 +304,7 @@ public:
GraveyardStruct const* GetClosestGraveyard(Player* player) override;
bool UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true) override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void EventPlayerClickedOnFlag(Player* source, GameObject* gameObject) override;
bool AllNodesConrolledByTeam(TeamId teamId) const override;

30
src/server/game/Battlegrounds/Zones/BattlegroundAV.cpp
View File

@ -25,6 +25,7 @@
#include "Player.h"
#include "SpellAuras.h"
#include "WorldPacket.h"
#include "WorldStatePackets.h"
void BattlegroundAVScore::BuildObjectivesBlock(WorldPacket& data)
{
@ -1084,9 +1085,10 @@ void BattlegroundAV::EventPlayerAssaultsPoint(Player* player, uint32 object)
player->KilledMonsterCredit((IsTower(node)) ? BG_AV_QUEST_CREDIT_TOWER : BG_AV_QUEST_CREDIT_GRAVEYARD);
}
void BattlegroundAV::FillInitialWorldStates(WorldPacket& data)
void BattlegroundAV::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
bool stateok;
packet.Worldstates.reserve(7*2*2 + 8*2*2 + 5);
//graveyards
for (uint8 i = BG_AV_NODES_FIRSTAID_STATION; i <= BG_AV_NODES_FROSTWOLF_HUT; i++)
{
@ -1094,8 +1096,8 @@ void BattlegroundAV::FillInitialWorldStates(WorldPacket& data)
{
//j=1=assaulted j=3=controled
stateok = (m_Nodes[i].State == j);
data << uint32(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_ALLIANCE)]) << uint32((m_Nodes[i].OwnerId == TEAM_ALLIANCE && stateok) ? 1 : 0);
data << uint32(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_HORDE)]) << uint32((m_Nodes[i].OwnerId == TEAM_HORDE && stateok) ? 1 : 0);
packet.Worldstates.emplace_back(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_ALLIANCE)], (m_Nodes[i].OwnerId == TEAM_ALLIANCE && stateok) ? 1 : 0);
packet.Worldstates.emplace_back(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_HORDE)], (m_Nodes[i].OwnerId == TEAM_HORDE && stateok) ? 1 : 0);
}
}
@ -1105,23 +1107,19 @@ void BattlegroundAV::FillInitialWorldStates(WorldPacket& data)
{
//j=1=assaulted j=3=controled //i dont have j=2=destroyed cause destroyed is the same like enemy-team controll
stateok = (m_Nodes[i].State == j || (m_Nodes[i].State == POINT_DESTROYED && j == 3));
data << uint32(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_ALLIANCE)]) << uint32((m_Nodes[i].OwnerId == TEAM_ALLIANCE && stateok) ? 1 : 0);
data << uint32(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_HORDE)]) << uint32((m_Nodes[i].OwnerId == TEAM_HORDE && stateok) ? 1 : 0);
packet.Worldstates.emplace_back(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_ALLIANCE)], (m_Nodes[i].OwnerId == TEAM_ALLIANCE && stateok) ? 1 : 0);
packet.Worldstates.emplace_back(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_HORDE)], (m_Nodes[i].OwnerId == TEAM_HORDE && stateok) ? 1 : 0);
}
if (m_Nodes[BG_AV_NODES_SNOWFALL_GRAVE].OwnerId == TEAM_NEUTRAL) //cause neutral teams aren't handled generic
data << uint32(AV_SNOWFALL_N) << uint32(1);
data << uint32(AV_Alliance_Score) << uint32(m_Team_Scores[0]);
data << uint32(AV_Horde_Score) << uint32(m_Team_Scores[1]);
if (GetStatus() == STATUS_IN_PROGRESS) //only if game started the teamscores are displayed
{
data << uint32(AV_SHOW_A_SCORE) << uint32(1);
data << uint32(AV_SHOW_H_SCORE) << uint32(1);
}
else
{
data << uint32(AV_SHOW_A_SCORE) << uint32(0);
data << uint32(AV_SHOW_H_SCORE) << uint32(0);
packet.Worldstates.emplace_back(AV_SNOWFALL_N, 1);
}
packet.Worldstates.emplace_back(AV_Alliance_Score, m_Team_Scores[0]);
packet.Worldstates.emplace_back(AV_Horde_Score, m_Team_Scores[1]);
packet.Worldstates.emplace_back(AV_SHOW_A_SCORE, GetStatus() == STATUS_IN_PROGRESS ? 1 : 0);
packet.Worldstates.emplace_back(AV_SHOW_H_SCORE, GetStatus() == STATUS_IN_PROGRESS ? 1 : 0);
SendMineWorldStates(AV_NORTH_MINE);
SendMineWorldStates(AV_SOUTH_MINE);
}

2
src/server/game/Battlegrounds/Zones/BattlegroundAV.h
View File

@ -1936,7 +1936,7 @@ private:
void ChangeMineOwner(uint8 mine, TeamId teamId, bool initial = false);
/*worldstates*/
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
uint8 GetWorldStateType(uint8 state, TeamId teamId);
void SendMineWorldStates(uint32 mine);
void UpdateNodeWorldState(BG_AV_Nodes node);

7
src/server/game/Battlegrounds/Zones/BattlegroundBE.cpp
View File

@ -19,6 +19,7 @@
#include "Log.h"
#include "Player.h"
#include "WorldPacket.h"
#include "WorldStatePackets.h"
BattlegroundBE::BattlegroundBE()
{
@ -87,10 +88,10 @@ void BattlegroundBE::HandleAreaTrigger(Player* player, uint32 trigger)
}
}
void BattlegroundBE::FillInitialWorldStates(WorldPacket& data)
void BattlegroundBE::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(0x9f3) << uint32(1); // 9
Arena::FillInitialWorldStates(data);
packet.Worldstates.emplace_back(0x9f3, 1); // BATTLEGROUND_BLADES_EDGE_ARENA_SHOW
Arena::FillInitialWorldStates(packet);
}
bool BattlegroundBE::SetupBattleground()

2
src/server/game/Battlegrounds/Zones/BattlegroundBE.h
View File

@ -54,7 +54,7 @@ public:
void HandleAreaTrigger(Player* player, uint32 trigger) override;
bool SetupBattleground() override;
void FillInitialWorldStates(WorldPacket& d) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
bool HandlePlayerUnderMap(Player* player) override;
};

7
src/server/game/Battlegrounds/Zones/BattlegroundDS.cpp
View File

@ -22,6 +22,7 @@
#include "ObjectAccessor.h"
#include "Player.h"
#include "WorldPacket.h"
#include "WorldStatePackets.h"
BattlegroundDS::BattlegroundDS()
{
@ -173,10 +174,10 @@ bool BattlegroundDS::HandlePlayerUnderMap(Player* player)
return true;
}
void BattlegroundDS::FillInitialWorldStates(WorldPacket& data)
void BattlegroundDS::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(3610) << uint32(1); // 9 show
Arena::FillInitialWorldStates(data);
packet.Worldstates.emplace_back(0xe1a, 1); // ARENA_WORLD_STATE_ALIVE_PLAYERS_SHOW
Arena::FillInitialWorldStates(packet);
}
bool BattlegroundDS::SetupBattleground()

2
src/server/game/Battlegrounds/Zones/BattlegroundDS.h
View File

@ -101,7 +101,7 @@ public:
void HandleAreaTrigger(Player* player, uint32 trigger) override;
bool SetupBattleground() override;
void FillInitialWorldStates(WorldPacket& d) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
bool HandlePlayerUnderMap(Player* player) override;
private:

52
src/server/game/Battlegrounds/Zones/BattlegroundEY.cpp
View File

@ -26,6 +26,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSession.h"
#include "WorldStatePackets.h"
void BattlegroundEYScore::BuildObjectivesBlock(WorldPacket& data)
{
@ -506,7 +507,7 @@ void BattlegroundEY::EventTeamCapturedPoint(Player* player, TeamId teamId, uint3
_capturePointInfo[point]._ownerTeamId = teamId;
GraveyardStruct const* sg = sGraveyard->GetGraveyard(m_CapturingPointTypes[point].GraveYardId);
GraveyardStruct const* sg = sGraveyard->GetGraveyard(m_CapturingPointTypes[point].GraveyardId);
AddSpiritGuide(point, sg->x, sg->y, sg->z, 3.124139f, teamId);
UpdatePointsIcons(point);
@ -568,30 +569,31 @@ bool BattlegroundEY::UpdatePlayerScore(Player* player, uint32 type, uint32 value
return true;
}
void BattlegroundEY::FillInitialWorldStates(WorldPacket& data)
void BattlegroundEY::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(EY_HORDE_BASE) << uint32(_ownedPointsCount[TEAM_HORDE]);
data << uint32(EY_ALLIANCE_BASE) << uint32(_ownedPointsCount[TEAM_ALLIANCE]);
data << uint32(DRAENEI_RUINS_HORDE_CONTROL) << uint32(_capturePointInfo[POINT_DRAENEI_RUINS].IsUnderControl(TEAM_HORDE));
data << uint32(DRAENEI_RUINS_ALLIANCE_CONTROL) << uint32(_capturePointInfo[POINT_DRAENEI_RUINS].IsUnderControl(TEAM_ALLIANCE));
data << uint32(DRAENEI_RUINS_UNCONTROL) << uint32(_capturePointInfo[POINT_DRAENEI_RUINS].IsUncontrolled());
data << uint32(MAGE_TOWER_ALLIANCE_CONTROL) << uint32(_capturePointInfo[POINT_MAGE_TOWER].IsUnderControl(TEAM_HORDE));
data << uint32(MAGE_TOWER_HORDE_CONTROL) << uint32(_capturePointInfo[POINT_MAGE_TOWER].IsUnderControl(TEAM_ALLIANCE));
data << uint32(MAGE_TOWER_UNCONTROL) << uint32(_capturePointInfo[POINT_MAGE_TOWER].IsUncontrolled());
data << uint32(FEL_REAVER_HORDE_CONTROL) << uint32(_capturePointInfo[POINT_FEL_REAVER].IsUnderControl(TEAM_HORDE));
data << uint32(FEL_REAVER_ALLIANCE_CONTROL) << uint32(_capturePointInfo[POINT_FEL_REAVER].IsUnderControl(TEAM_ALLIANCE));
data << uint32(FEL_REAVER_UNCONTROL) << uint32(_capturePointInfo[POINT_FEL_REAVER].IsUncontrolled());
data << uint32(BLOOD_ELF_HORDE_CONTROL) << uint32(_capturePointInfo[POINT_BLOOD_ELF].IsUnderControl(TEAM_HORDE));
data << uint32(BLOOD_ELF_ALLIANCE_CONTROL) << uint32(_capturePointInfo[POINT_BLOOD_ELF].IsUnderControl(TEAM_ALLIANCE));
data << uint32(BLOOD_ELF_UNCONTROL) << uint32(_capturePointInfo[POINT_BLOOD_ELF].IsUncontrolled());
data << uint32(NETHERSTORM_FLAG) << uint32(_flagState == BG_EY_FLAG_STATE_ON_BASE);
data << uint32(NETHERSTORM_FLAG_STATE_HORDE) << uint32(1);
data << uint32(NETHERSTORM_FLAG_STATE_ALLIANCE) << uint32(1);
data << uint32(EY_HORDE_RESOURCES) << uint32(GetTeamScore(TEAM_HORDE));
data << uint32(EY_ALLIANCE_RESOURCES) << uint32(GetTeamScore(TEAM_ALLIANCE));
data << uint32(PROGRESS_BAR_SHOW) << uint32(0);
data << uint32(PROGRESS_BAR_PERCENT_GREY) << uint32(0);
data << uint32(PROGRESS_BAR_STATUS) << uint32(0);
packet.Worldstates.reserve(22);
packet.Worldstates.emplace_back(EY_HORDE_BASE, _ownedPointsCount[TEAM_HORDE]);
packet.Worldstates.emplace_back(EY_ALLIANCE_BASE, _ownedPointsCount[TEAM_ALLIANCE]);
packet.Worldstates.emplace_back(DRAENEI_RUINS_HORDE_CONTROL, _capturePointInfo[POINT_DRAENEI_RUINS].IsUnderControl(TEAM_HORDE));
packet.Worldstates.emplace_back(DRAENEI_RUINS_ALLIANCE_CONTROL, _capturePointInfo[POINT_DRAENEI_RUINS].IsUnderControl(TEAM_ALLIANCE));
packet.Worldstates.emplace_back(DRAENEI_RUINS_UNCONTROL, _capturePointInfo[POINT_DRAENEI_RUINS].IsUncontrolled());
packet.Worldstates.emplace_back(MAGE_TOWER_ALLIANCE_CONTROL, _capturePointInfo[POINT_MAGE_TOWER].IsUnderControl(TEAM_HORDE));
packet.Worldstates.emplace_back(MAGE_TOWER_HORDE_CONTROL, _capturePointInfo[POINT_MAGE_TOWER].IsUnderControl(TEAM_ALLIANCE));
packet.Worldstates.emplace_back(MAGE_TOWER_UNCONTROL, _capturePointInfo[POINT_MAGE_TOWER].IsUncontrolled());
packet.Worldstates.emplace_back(FEL_REAVER_HORDE_CONTROL, _capturePointInfo[POINT_FEL_REAVER].IsUnderControl(TEAM_HORDE));
packet.Worldstates.emplace_back(FEL_REAVER_ALLIANCE_CONTROL, _capturePointInfo[POINT_FEL_REAVER].IsUnderControl(TEAM_ALLIANCE));
packet.Worldstates.emplace_back(FEL_REAVER_UNCONTROL, _capturePointInfo[POINT_FEL_REAVER].IsUncontrolled());
packet.Worldstates.emplace_back(BLOOD_ELF_HORDE_CONTROL, _capturePointInfo[POINT_BLOOD_ELF].IsUnderControl(TEAM_HORDE));
packet.Worldstates.emplace_back(BLOOD_ELF_ALLIANCE_CONTROL, _capturePointInfo[POINT_BLOOD_ELF].IsUnderControl(TEAM_ALLIANCE));
packet.Worldstates.emplace_back(BLOOD_ELF_UNCONTROL, _capturePointInfo[POINT_BLOOD_ELF].IsUncontrolled());
packet.Worldstates.emplace_back(NETHERSTORM_FLAG, _flagState == BG_EY_FLAG_STATE_ON_BASE);
packet.Worldstates.emplace_back(NETHERSTORM_FLAG_STATE_HORDE, 1);
packet.Worldstates.emplace_back(NETHERSTORM_FLAG_STATE_ALLIANCE, 1);
packet.Worldstates.emplace_back(EY_HORDE_RESOURCES, GetTeamScore(TEAM_HORDE));
packet.Worldstates.emplace_back(EY_ALLIANCE_RESOURCES, GetTeamScore(TEAM_ALLIANCE));
packet.Worldstates.emplace_back(PROGRESS_BAR_SHOW, 0);
packet.Worldstates.emplace_back(PROGRESS_BAR_PERCENT_GREY, 0);
packet.Worldstates.emplace_back(PROGRESS_BAR_STATUS, 0);
}
GraveyardStruct const* BattlegroundEY::GetClosestGraveyard(Player* player)
@ -608,7 +610,7 @@ GraveyardStruct const* BattlegroundEY::GetClosestGraveyard(Player* player)
for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
if (_capturePointInfo[i].IsUnderControl(player->GetTeamId()))
{
entry = sGraveyard->GetGraveyard(m_CapturingPointTypes[i].GraveYardId);
entry = sGraveyard->GetGraveyard(m_CapturingPointTypes[i].GraveyardId);
dist = (entry->x - pX) * (entry->x - pX) + (entry->y - pY) * (entry->y - pY) + (entry->z - pZ) * (entry->z - pZ);
if (dist < minDist)
{

8
src/server/game/Battlegrounds/Zones/BattlegroundEY.h
View File

@ -305,11 +305,11 @@ struct BattlegroundEYLosingPointStruct
struct BattlegroundEYCapturingPointStruct
{
BattlegroundEYCapturingPointStruct(uint32 _DespawnNeutralObjectType, uint32 _SpawnObjectTypeAlliance, uint32 _MessageIdAlliance, uint32 _SpawnObjectTypeHorde, uint32 _MessageIdHorde, uint32 _GraveYardId)
BattlegroundEYCapturingPointStruct(uint32 _DespawnNeutralObjectType, uint32 _SpawnObjectTypeAlliance, uint32 _MessageIdAlliance, uint32 _SpawnObjectTypeHorde, uint32 _MessageIdHorde, uint32 _GraveyardId)
: DespawnNeutralObjectType(_DespawnNeutralObjectType),
SpawnObjectTypeAlliance(_SpawnObjectTypeAlliance), MessageIdAlliance(_MessageIdAlliance),
SpawnObjectTypeHorde(_SpawnObjectTypeHorde), MessageIdHorde(_MessageIdHorde),
GraveYardId(_GraveYardId)
GraveyardId(_GraveyardId)
{}
uint32 DespawnNeutralObjectType;
@ -317,7 +317,7 @@ struct BattlegroundEYCapturingPointStruct
uint32 MessageIdAlliance;
uint32 SpawnObjectTypeHorde;
uint32 MessageIdHorde;
uint32 GraveYardId;
uint32 GraveyardId;
};
const uint32 BG_EY_TickPoints[EY_POINTS_MAX] = {1, 2, 5, 10};
@ -402,7 +402,7 @@ public:
void Init() override;
void EndBattleground(TeamId winnerTeamId) override;
bool UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true) override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void SetDroppedFlagGUID(ObjectGuid guid, TeamId /*teamId*/ = TEAM_NEUTRAL) override { _droppedFlagGUID = guid; }
ObjectGuid GetDroppedFlagGUID() const { return _droppedFlagGUID; }

18
src/server/game/Battlegrounds/Zones/BattlegroundIC.cpp
View File

@ -26,6 +26,7 @@
#include "Transport.h"
#include "Vehicle.h"
#include "WorldPacket.h"
#include "WorldStatePackets.h"
void BattlegroundICScore::BuildObjectivesBlock(WorldPacket& data)
{
@ -381,21 +382,24 @@ bool BattlegroundIC::UpdatePlayerScore(Player* player, uint32 type, uint32 value
return true;
}
void BattlegroundIC::FillInitialWorldStates(WorldPacket& data)
void BattlegroundIC::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(BG_IC_ALLIANCE_RENFORT_SET) << uint32(1);
data << uint32(BG_IC_HORDE_RENFORT_SET) << uint32(1);
data << uint32(BG_IC_ALLIANCE_RENFORT) << uint32(factionReinforcements[TEAM_ALLIANCE]);
data << uint32(BG_IC_HORDE_RENFORT) << uint32(factionReinforcements[TEAM_HORDE]);
packet.Worldstates.reserve(4+MAX_FORTRESS_GATES_SPAWNS+MAX_NODE_TYPES+1);
packet.Worldstates.emplace_back(BG_IC_ALLIANCE_RENFORT_SET, 1);
packet.Worldstates.emplace_back(BG_IC_HORDE_RENFORT_SET, 1);
packet.Worldstates.emplace_back(BG_IC_ALLIANCE_RENFORT, factionReinforcements[TEAM_ALLIANCE]);
packet.Worldstates.emplace_back(BG_IC_HORDE_RENFORT, factionReinforcements[TEAM_HORDE]);
for (uint8 i = 0; i < MAX_FORTRESS_GATES_SPAWNS; ++i)
{
uint32 uws = GetWorldStateFromGateEntry(BG_IC_ObjSpawnlocs[i].entry, (GateStatus[GetGateIDFromEntry(BG_IC_ObjSpawnlocs[i].entry)] == BG_IC_GATE_DESTROYED));
data << uint32(uws) << uint32(1);
packet.Worldstates.emplace_back(uws, 1);
}
for (uint8 i = 0; i < MAX_NODE_TYPES; ++i)
data << uint32(nodePoint[i].worldStates[nodePoint[i].nodeState]) << uint32(1);
packet.Worldstates.emplace_back(nodePoint[i].worldStates[nodePoint[i].nodeState], 1);
packet.Worldstates.emplace_back(BG_IC_HORDE_RENFORT_SET, 1);
}
bool BattlegroundIC::SetupBattleground()

2
src/server/game/Battlegrounds/Zones/BattlegroundIC.h
View File

@ -974,7 +974,7 @@ public:
/* Scorekeeping */
bool UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true) override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void HandlePlayerResurrect(Player* player) override;

6
src/server/game/Battlegrounds/Zones/BattlegroundNA.cpp
View File

@ -64,10 +64,10 @@ void BattlegroundNA::HandleAreaTrigger(Player* player, uint32 trigger)
}
}
void BattlegroundNA::FillInitialWorldStates(WorldPacket& data)
void BattlegroundNA::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(0xa11) << uint32(1); // 9
Arena::FillInitialWorldStates(data);
packet.Worldstates.emplace_back(0xa11, 1); // BATTLEGROUND_NAGRAND_ARENA_SHOW
Arena::FillInitialWorldStates(packet);
}
bool BattlegroundNA::SetupBattleground()

3
src/server/game/Battlegrounds/Zones/BattlegroundNA.h
View File

@ -54,7 +54,8 @@ public:
void HandleAreaTrigger(Player* player, uint32 trigger) override;
bool SetupBattleground() override;
void FillInitialWorldStates(WorldPacket& d) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
bool HandlePlayerUnderMap(Player* player) override;
};

6
src/server/game/Battlegrounds/Zones/BattlegroundRL.cpp
View File

@ -91,10 +91,10 @@ void BattlegroundRL::HandleAreaTrigger(Player* player, uint32 trigger)
}
}
void BattlegroundRL::FillInitialWorldStates(WorldPacket& data)
void BattlegroundRL::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(0xbba) << uint32(1); // 9
Arena::FillInitialWorldStates(data);
packet.Worldstates.emplace_back(0xbba, 1); // BATTELGROUND_RUINS_OF_LORDAERNON_SHOW
Arena::FillInitialWorldStates(packet);
}
bool BattlegroundRL::SetupBattleground()

2
src/server/game/Battlegrounds/Zones/BattlegroundRL.h
View File

@ -45,7 +45,7 @@ public:
BattlegroundRL();
/* inherited from BattlegroundClass */
void FillInitialWorldStates(WorldPacket& d) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void StartingEventCloseDoors() override;
void StartingEventOpenDoors() override;

6
src/server/game/Battlegrounds/Zones/BattlegroundRV.cpp
View File

@ -204,10 +204,10 @@ void BattlegroundRV::HandleAreaTrigger(Player* player, uint32 trigger)
}
}
void BattlegroundRV::FillInitialWorldStates(WorldPacket& data)
void BattlegroundRV::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(BG_RV_WORLD_STATE) << uint32(1);
Arena::FillInitialWorldStates(data);
packet.Worldstates.emplace_back(BG_RV_WORLD_STATE, 1);
Arena::FillInitialWorldStates(packet);
}
void BattlegroundRV::Init()

2
src/server/game/Battlegrounds/Zones/BattlegroundRV.h
View File

@ -90,7 +90,7 @@ public:
/* inherited from BattlegroundClass */
void StartingEventOpenDoors() override;
void Init() override;
void FillInitialWorldStates(WorldPacket& d) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void HandleAreaTrigger(Player* player, uint32 trigger) override;
bool SetupBattleground() override;
bool HandlePlayerUnderMap(Player* player) override;

58
src/server/game/Battlegrounds/Zones/BattlegroundSA.cpp
View File

@ -467,44 +467,46 @@ void BattlegroundSA::StartingEventOpenDoors()
{
}
void BattlegroundSA::FillInitialWorldStates(WorldPacket& data)
void BattlegroundSA::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
uint32 ally_attacks = uint32(Attackers == TEAM_ALLIANCE ? 1 : 0);
uint32 horde_attacks = uint32(Attackers == TEAM_HORDE ? 1 : 0);
bool const ally_attacks = Attackers == TEAM_ALLIANCE;
bool const horde_attacks = Attackers == TEAM_HORDE;
data << uint32(BG_SA_ANCIENT_GATEWS) << uint32(GateStatus[BG_SA_ANCIENT_GATE]);
data << uint32(BG_SA_YELLOW_GATEWS) << uint32(GateStatus[BG_SA_YELLOW_GATE]);
data << uint32(BG_SA_GREEN_GATEWS) << uint32(GateStatus[BG_SA_GREEN_GATE]);
data << uint32(BG_SA_BLUE_GATEWS) << uint32(GateStatus[BG_SA_BLUE_GATE]);
data << uint32(BG_SA_RED_GATEWS) << uint32(GateStatus[BG_SA_RED_GATE]);
data << uint32(BG_SA_PURPLE_GATEWS) << uint32(GateStatus[BG_SA_PURPLE_GATE]);
packet.Worldstates.reserve(25);
packet.Worldstates.emplace_back(BG_SA_ANCIENT_GATEWS, GateStatus[BG_SA_ANCIENT_GATE]);
packet.Worldstates.emplace_back(BG_SA_YELLOW_GATEWS, GateStatus[BG_SA_YELLOW_GATE]);
packet.Worldstates.emplace_back(BG_SA_GREEN_GATEWS, GateStatus[BG_SA_GREEN_GATE]);
packet.Worldstates.emplace_back(BG_SA_BLUE_GATEWS, GateStatus[BG_SA_BLUE_GATE]);
packet.Worldstates.emplace_back(BG_SA_RED_GATEWS, GateStatus[BG_SA_RED_GATE]);
packet.Worldstates.emplace_back(BG_SA_PURPLE_GATEWS, GateStatus[BG_SA_PURPLE_GATE]);
data << uint32(BG_SA_BONUS_TIMER) << uint32(0);
packet.Worldstates.emplace_back(BG_SA_BONUS_TIMER, 0);
data << uint32(BG_SA_HORDE_ATTACKS) << horde_attacks;
data << uint32(BG_SA_ALLY_ATTACKS) << ally_attacks;
packet.Worldstates.emplace_back(BG_SA_HORDE_ATTACKS, horde_attacks);
packet.Worldstates.emplace_back(BG_SA_ALLY_ATTACKS, ally_attacks);
//Time will be sent on first update...
data << uint32(BG_SA_ENABLE_TIMER) << ((TimerEnabled) ? uint32(1) : uint32(0));
data << uint32(BG_SA_TIMER_MINS) << uint32(0);
data << uint32(BG_SA_TIMER_SEC_TENS) << uint32(0);
data << uint32(BG_SA_TIMER_SEC_DECS) << uint32(0);
packet.Worldstates.emplace_back(BG_SA_ENABLE_TIMER, TimerEnabled ? 1 : 0);
data << uint32(BG_SA_RIGHT_GY_HORDE) << uint32(GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
data << uint32(BG_SA_LEFT_GY_HORDE) << uint32(GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
data << uint32(BG_SA_CENTER_GY_HORDE) << uint32(GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
packet.Worldstates.emplace_back(BG_SA_TIMER_MINS, 0);
packet.Worldstates.emplace_back(BG_SA_TIMER_SEC_TENS, 0);
packet.Worldstates.emplace_back(BG_SA_TIMER_SEC_DECS, 0);
data << uint32(BG_SA_RIGHT_GY_ALLIANCE) << uint32(GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
data << uint32(BG_SA_LEFT_GY_ALLIANCE) << uint32(GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
data << uint32(BG_SA_CENTER_GY_ALLIANCE) << uint32(GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
packet.Worldstates.emplace_back(BG_SA_RIGHT_GY_HORDE, GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
packet.Worldstates.emplace_back(BG_SA_LEFT_GY_HORDE, GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
packet.Worldstates.emplace_back(BG_SA_CENTER_GY_HORDE, GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
data << uint32(BG_SA_HORDE_DEFENCE_TOKEN) << ally_attacks;
data << uint32(BG_SA_ALLIANCE_DEFENCE_TOKEN) << horde_attacks;
packet.Worldstates.emplace_back(BG_SA_RIGHT_GY_ALLIANCE, GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
packet.Worldstates.emplace_back(BG_SA_LEFT_GY_ALLIANCE, GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
packet.Worldstates.emplace_back(BG_SA_CENTER_GY_ALLIANCE, GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
data << uint32(BG_SA_LEFT_ATT_TOKEN_HRD) << horde_attacks;
data << uint32(BG_SA_RIGHT_ATT_TOKEN_HRD) << horde_attacks;
data << uint32(BG_SA_RIGHT_ATT_TOKEN_ALL) << ally_attacks;
data << uint32(BG_SA_LEFT_ATT_TOKEN_ALL) << ally_attacks;
packet.Worldstates.emplace_back(BG_SA_HORDE_DEFENCE_TOKEN, ally_attacks);
packet.Worldstates.emplace_back(BG_SA_ALLIANCE_DEFENCE_TOKEN, horde_attacks);
packet.Worldstates.emplace_back(BG_SA_LEFT_ATT_TOKEN_HRD, horde_attacks);
packet.Worldstates.emplace_back(BG_SA_RIGHT_ATT_TOKEN_HRD, horde_attacks);
packet.Worldstates.emplace_back(BG_SA_RIGHT_ATT_TOKEN_ALL, ally_attacks);
packet.Worldstates.emplace_back(BG_SA_LEFT_ATT_TOKEN_ALL, ally_attacks);
}
void BattlegroundSA::AddPlayer(Player* player)

2
src/server/game/Battlegrounds/Zones/BattlegroundSA.h
View File

@ -475,7 +475,7 @@ public:
bool SetupBattleground() override;
void Init() override;
/// Called for generate packet contain worldstate data
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
/// Called when a player deal damage to building (door)
void EventPlayerDamagedGO(Player* player, GameObject* go, uint32 eventType) override;
/// Called when a player kill a unit in bg

17
src/server/game/Battlegrounds/Zones/BattlegroundWS.cpp
View File

@ -546,17 +546,18 @@ GraveyardStruct const* BattlegroundWS::GetClosestGraveyard(Player* player)
return sGraveyard->GetGraveyard(player->GetTeamId() == TEAM_ALLIANCE ? WS_GRAVEYARD_FLAGROOM_ALLIANCE : WS_GRAVEYARD_FLAGROOM_HORDE);
}
void BattlegroundWS::FillInitialWorldStates(WorldPacket& data)
void BattlegroundWS::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(BG_WS_FLAG_CAPTURES_ALLIANCE) << uint32(GetTeamScore(TEAM_ALLIANCE));
data << uint32(BG_WS_FLAG_CAPTURES_HORDE) << uint32(GetTeamScore(TEAM_HORDE));
data << uint32(BG_WS_FLAG_CAPTURES_MAX) << uint32(BG_WS_MAX_TEAM_SCORE);
packet.Worldstates.reserve(7);
packet.Worldstates.emplace_back(BG_WS_FLAG_CAPTURES_ALLIANCE, GetTeamScore(TEAM_ALLIANCE));
packet.Worldstates.emplace_back(BG_WS_FLAG_CAPTURES_HORDE, GetTeamScore(TEAM_HORDE));
packet.Worldstates.emplace_back(BG_WS_FLAG_CAPTURES_MAX, BG_WS_MAX_TEAM_SCORE);
data << uint32(BG_WS_STATE_TIMER_ACTIVE) << uint32(GetStatus() == STATUS_IN_PROGRESS);
data << uint32(BG_WS_STATE_TIMER) << uint32(GetMatchTime());
packet.Worldstates.emplace_back(BG_WS_STATE_TIMER_ACTIVE, GetStatus() == STATUS_IN_PROGRESS ? 1 : 0);
packet.Worldstates.emplace_back(BG_WS_STATE_TIMER, GetMatchTime());
data << uint32(BG_WS_FLAG_STATE_HORDE) << uint32(GetFlagState(TEAM_HORDE));
data << uint32(BG_WS_FLAG_STATE_ALLIANCE) << uint32(GetFlagState(TEAM_ALLIANCE));
packet.Worldstates.emplace_back(BG_WS_FLAG_STATE_HORDE, GetFlagState(TEAM_HORDE));
packet.Worldstates.emplace_back(BG_WS_FLAG_STATE_ALLIANCE, GetFlagState(TEAM_ALLIANCE));
}
TeamId BattlegroundWS::GetPrematureWinner()

2
src/server/game/Battlegrounds/Zones/BattlegroundWS.h
View File

@ -252,7 +252,7 @@ public:
bool UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true) override;
void SetDroppedFlagGUID(ObjectGuid guid, TeamId teamId) override { _droppedFlagGUID[teamId] = guid; }
ObjectGuid GetDroppedFlagGUID(TeamId teamId) const { return _droppedFlagGUID[teamId];}
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
/* Scorekeeping */
void AddPoints(TeamId teamId, uint32 points) { m_TeamScores[teamId] += points; }

1075
src/server/game/Entities/Player/Player.cpp
View File

File diff suppressed because it is too large Load Diff

4
src/server/game/Entities/Player/Player.h
View File

@ -65,7 +65,7 @@ class SpellCastTargets;
class UpdateMask;
typedef std::deque<Mail*> PlayerMails;
typedef void(*bgZoneRef)(Battleground*, WorldPacket&);
typedef void(*bgZoneRef)(Battleground*, WorldPackets::WorldState::InitWorldStates&);
#define PLAYER_MAX_SKILLS 127
#define PLAYER_MAX_DAILY_QUESTS 25
@ -2236,7 +2236,7 @@ public:
void SetEquipmentSet(uint32 index, EquipmentSet eqset);
void DeleteEquipmentSet(uint64 setGuid);
void SendInitWorldStates(uint32 zone, uint32 area);
void SendInitWorldStates(uint32 zoneId, uint32 areaId);
void SendUpdateWorldState(uint32 variable, uint32 value) const;
void SendDirectMessage(WorldPacket const* data) const;
void SendBGWeekendWorldStates();

3
src/server/game/Instances/InstanceScript.h
View File

@ -23,6 +23,7 @@
#include "TaskScheduler.h"
#include "World.h"
#include "ZoneScript.h"
#include "WorldStatePackets.h"
#include <set>
#define OUT_SAVE_INST_DATA LOG_DEBUG("scripts.ai", "Saving Instance Data for Instance {} (Map {}, Instance Id {})", instance->GetMapName(), instance->GetId(), instance->GetInstanceId())
@ -260,7 +261,7 @@ public:
void SendEncounterUnit(uint32 type, Unit* unit = nullptr, uint8 param1 = 0, uint8 param2 = 0);
virtual void FillInitialWorldStates(WorldPacket& /*data*/) {}
virtual void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& /*packet*/) { }
uint32 GetEncounterCount() const { return bosses.size(); }

5
src/server/game/OutdoorPvP/OutdoorPvP.h
View File

@ -20,6 +20,7 @@
#include "SharedDefines.h"
#include "ZoneScript.h"
#include "WorldStatePackets.h"
#include <array>
class GameObject;
@ -92,7 +93,7 @@ public:
explicit OPvPCapturePoint(OutdoorPvP* pvp);
virtual ~OPvPCapturePoint() = default;
virtual void FillInitialWorldStates(WorldPacket& /*data*/) {}
virtual void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& /*packet*/) { }
// send world state update to all players present
void SendUpdateWorldState(uint32 field, uint32 value);
@ -199,7 +200,7 @@ public:
typedef std::pair<ObjectGuid::LowType, GameObject*> GoScriptPair;
typedef std::pair<ObjectGuid::LowType, Creature*> CreatureScriptPair;
virtual void FillInitialWorldStates(WorldPacket& /*data*/) {}
virtual void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& /*packet*/) {}
// called when a player triggers an area trigger
virtual bool HandleAreaTrigger(Player* player, uint32 trigger);

2
src/server/game/Server/WorldSession.cpp
View File

@ -681,7 +681,7 @@ void WorldSession::LogoutPlayer(bool save)
if (!_player->IsBeingTeleportedFar() && !_player->m_InstanceValid && !_player->IsGameMaster())
_player->RepopAtGraveyard();
// Repop at GraveYard or other player far teleport will prevent saving player because of not present map
// Repop at Graveyard or other player far teleport will prevent saving player because of not present map
// Teleport player immediately for correct player save
while (_player && _player->IsBeingTeleportedFar())
HandleMoveWorldportAck();

24
src/server/game/World/WorldState.cpp
View File

@ -1035,7 +1035,7 @@ uint32 SunsReachReclamationData::GetSunwellGatePercentage(uint32 gate)
return percentage < 0 ? 0 : uint32(percentage);
}
void WorldState::FillInitialWorldStates(ByteBuffer& data, uint32 zoneId, uint32 /*areaId*/)
void WorldState::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet, uint32 zoneId, uint32 /*areaId*/)
{
switch (zoneId)
{
@ -1048,38 +1048,38 @@ void WorldState::FillInitialWorldStates(ByteBuffer& data, uint32 zoneId, uint32
switch (m_sunsReachData.m_phase)
{
case SUNS_REACH_PHASE_1_STAGING_AREA:
data << WORLD_STATE_QUEL_DANAS_SANCTUM << m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase);
packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_SANCTUM, m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase));
break;
case SUNS_REACH_PHASE_2_SANCTUM:
data << WORLD_STATE_QUEL_DANAS_ARMORY << m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase);
packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_ARMORY, m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase));
break;
case SUNS_REACH_PHASE_3_ARMORY:
data << WORLD_STATE_QUEL_DANAS_HARBOR << m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase);
packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_HARBOR, m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase));
break;
case SUNS_REACH_PHASE_4_HARBOR:
if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALCHEMY_LAB) == 0)
data << WORLD_STATE_QUEL_DANAS_ALCHEMY_LAB << m_sunsReachData.GetSubPhasePercentage(SUBPHASE_ALCHEMY_LAB);
packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_ALCHEMY_LAB, m_sunsReachData.GetSubPhasePercentage(SUBPHASE_ALCHEMY_LAB));
if ((m_sunsReachData.m_subphaseMask & SUBPHASE_MONUMENT) == 0)
data << WORLD_STATE_QUEL_DANAS_MONUMENT << m_sunsReachData.GetSubPhasePercentage(SUBPHASE_MONUMENT);
packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_MONUMENT, m_sunsReachData.GetSubPhasePercentage(SUBPHASE_MONUMENT));
break;
}
if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_2_SANCTUM && (m_sunsReachData.m_subphaseMask & SUBPHASE_PORTAL) == 0)
data << WORLD_STATE_QUEL_DANAS_PORTAL << m_sunsReachData.GetSubPhasePercentage(SUBPHASE_PORTAL);
packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_PORTAL, m_sunsReachData.GetSubPhasePercentage(SUBPHASE_PORTAL));
if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_3_ARMORY && (m_sunsReachData.m_subphaseMask & SUBPHASE_ANVIL) == 0)
data << WORLD_STATE_QUEL_DANAS_ANVIL << m_sunsReachData.GetSubPhasePercentage(SUBPHASE_ANVIL);
data << WORLD_STATE_QUEL_DANAS_MUSIC << m_sunsReachData.m_phase;
packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_ANVIL, m_sunsReachData.GetSubPhasePercentage(SUBPHASE_ANVIL));
packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_MUSIC, m_sunsReachData.m_phase);
// Sunwell Gates
switch (m_sunsReachData.m_gate)
{
case SUNWELL_ALL_GATES_CLOSED:
data << WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH << m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate);
packet.Worldstates.emplace_back(WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH, m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate));
break;
case SUNWELL_AGAMATH_GATE1_OPEN:
data << WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH << m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate);
packet.Worldstates.emplace_back(WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH, m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate));
break;
case SUNWELL_ROHENDOR_GATE2_OPEN:
data << WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH << m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate);
packet.Worldstates.emplace_back(WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH, m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate));
break;
}
break;

2
src/server/game/World/WorldState.h
View File

@ -206,7 +206,7 @@ class WorldState
void AddSunwellGateProgress(uint32 questId);
void AddSunsReachProgress(uint32 questId);
std::string GetSunsReachPrintout();
void FillInitialWorldStates(ByteBuffer& data, uint32 zoneId, uint32 areaId);
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet, uint32 zoneId, uint32 /*areaId*/);
void HandleSunsReachPhaseTransition(uint32 newPhase);
void HandleSunsReachSubPhaseTransition(int32 subPhaseMask, bool initial = false);
void SetSunsReachCounter(SunsReachCounters index, uint32 value);

14
src/server/scripts/Kalimdor/CavernsOfTime/CullingOfStratholme/instance_culling_of_stratholme.cpp
View File

@ -22,6 +22,7 @@
#include "ScriptedCreature.h"
#include "SpellInfo.h"
#include "TemporarySummon.h"
#include "WorldStatePackets.h"
#include "culling_of_stratholme.h"
class instance_culling_of_stratholme : public InstanceMapScript
@ -53,13 +54,14 @@ public:
return false;
}
void FillInitialWorldStates(WorldPacket& data) override
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override
{
data << uint32(WORLDSTATE_SHOW_CRATES) << uint32(0);
data << uint32(WORLDSTATE_CRATES_REVEALED) << uint32(_crateCount);
data << uint32(WORLDSTATE_WAVE_COUNT) << uint32(0);
data << uint32(WORLDSTATE_TIME_GUARDIAN) << uint32(25);
data << uint32(WORLDSTATE_TIME_GUARDIAN_SHOW) << uint32(0);
packet.Worldstates.reserve(5);
packet.Worldstates.emplace_back(WORLDSTATE_SHOW_CRATES, 0);
packet.Worldstates.emplace_back(WORLDSTATE_CRATES_REVEALED, _crateCount);
packet.Worldstates.emplace_back(WORLDSTATE_WAVE_COUNT, 0);
packet.Worldstates.emplace_back(WORLDSTATE_TIME_GUARDIAN, 25);
packet.Worldstates.emplace_back(WORLDSTATE_TIME_GUARDIAN_SHOW, 0);
}
void OnPlayerEnter(Player* plr) override

12
src/server/scripts/Northrend/ChamberOfAspects/RubySanctum/instance_ruby_sanctum.cpp
View File

@ -19,10 +19,11 @@
#include "InstanceMapScript.h"
#include "InstanceScript.h"
#include "Player.h"
#include "SpellScript.h"
#include "SpellScriptLoader.h"
#include "WorldPacket.h"
#include "WorldStatePackets.h"
#include "ruby_sanctum.h"
#include "SpellScript.h"
BossBoundaryData const boundaries =
{
@ -217,11 +218,12 @@ public:
return true;
}
void FillInitialWorldStates(WorldPacket& data) override
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override
{
data << uint32(WORLDSTATE_CORPOREALITY_MATERIAL) << uint32(50);
data << uint32(WORLDSTATE_CORPOREALITY_TWILIGHT) << uint32(50);
data << uint32(WORLDSTATE_CORPOREALITY_TOGGLE) << uint32(0);
packet.Worldstates.reserve(3);
packet.Worldstates.emplace_back(WORLDSTATE_CORPOREALITY_MATERIAL, 50);
packet.Worldstates.emplace_back(WORLDSTATE_CORPOREALITY_TWILIGHT, 50);
packet.Worldstates.emplace_back(WORLDSTATE_CORPOREALITY_TOGGLE, 0);
}
protected:

4
src/server/scripts/Northrend/FrozenHalls/HallsOfReflection/instance_halls_of_reflection.cpp
View File

@ -15,12 +15,12 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Group.h"
#include "InstanceMapScript.h"
#include "InstanceScript.h"
#include "MapMgr.h"
#include "Transport.h"
#include "halls_of_reflection.h"
#include "InstanceScript.h"
#include "Group.h"
class UtherBatteredHiltEvent : public BasicEvent
{

16
src/server/scripts/Northrend/IcecrownCitadel/instance_icecrown_citadel.cpp
View File

@ -230,16 +230,14 @@ public:
IsSindragosaIntroDone = false;
}
void FillInitialWorldStates(WorldPacket& data) override
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override
{
if (instance->IsHeroic())
{
data << uint32(WORLDSTATE_SHOW_TIMER) << uint32(BloodQuickeningState == IN_PROGRESS);
data << uint32(WORLDSTATE_EXECUTION_TIME) << uint32(BloodQuickeningMinutes);
data << uint32(WORLDSTATE_SHOW_ATTEMPTS) << uint32(1);
data << uint32(WORLDSTATE_ATTEMPTS_REMAINING) << uint32(HeroicAttempts);
data << uint32(WORLDSTATE_ATTEMPTS_MAX) << uint32(MaxHeroicAttempts);
}
packet.Worldstates.reserve(5);
packet.Worldstates.emplace_back(WORLDSTATE_SHOW_TIMER, BloodQuickeningState == IN_PROGRESS ? 1 : 0);
packet.Worldstates.emplace_back(WORLDSTATE_EXECUTION_TIME, BloodQuickeningMinutes);
packet.Worldstates.emplace_back(WORLDSTATE_SHOW_ATTEMPTS, 1); // instance->IsHeroic() ? 1 : 0
packet.Worldstates.emplace_back(WORLDSTATE_ATTEMPTS_REMAINING, HeroicAttempts);
packet.Worldstates.emplace_back(WORLDSTATE_ATTEMPTS_MAX, MaxHeroicAttempts);
}
void OnPlayerAreaUpdate(Player* player, uint32 /*oldArea*/, uint32 newArea) override

1
src/server/scripts/Northrend/Nexus/Oculus/instance_oculus.cpp
View File

@ -20,6 +20,7 @@
#include "LFGMgr.h"
#include "Player.h"
#include "ScriptedCreature.h"
#include "WorldStatePackets.h"
#include "oculus.h"
class instance_oculus : public InstanceMapScript

8
src/server/scripts/Northrend/Ulduar/Ulduar/instance_ulduar.cpp
View File

@ -22,6 +22,7 @@
#include "ScriptedCreature.h"
#include "Transport.h"
#include "WorldPacket.h"
#include "WorldStatePackets.h"
#include "ulduar.h"
class instance_ulduar : public InstanceMapScript
@ -169,10 +170,11 @@ public:
m_mimironTramUsed = false;
}
void FillInitialWorldStates(WorldPacket& packet) override
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override
{
packet << uint32(WORLD_STATE_ALGALON_TIMER_ENABLED) << uint32(m_algalonTimer && m_algalonTimer <= 60);
packet << uint32(WORLD_STATE_ALGALON_DESPAWN_TIMER) << uint32(std::min<uint32>(m_algalonTimer, 60));
packet.Worldstates.reserve(2);
packet.Worldstates.emplace_back(WORLD_STATE_ALGALON_TIMER_ENABLED, (m_algalonTimer && m_algalonTimer <= 60) ? 1 : 0);
packet.Worldstates.emplace_back(WORLD_STATE_ALGALON_DESPAWN_TIMER, std::min<int32>(m_algalonTimer, 60));
}
void OnPlayerEnter(Player* player) override

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

@ -28,6 +28,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSessionMgr.h"
#include "WorldStatePackets.h"
OPvPCapturePointEP_EWT::OPvPCapturePointEP_EWT(OutdoorPvP* pvp)
: OPvPCapturePoint(pvp), m_TowerState(EP_TS_N), m_UnitsSummonedSideId(TEAM_NEUTRAL)
@ -41,12 +42,12 @@ void OPvPCapturePointEP_EWT::ChangeState()
// if changing from controlling alliance to horde or vice versa
if (_oldState == OBJECTIVESTATE_ALLIANCE && _oldState != _state)
{
sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_EWT_A));
sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_EWT_A));
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_EWT, TEAM_NEUTRAL);
}
else if (_oldState == OBJECTIVESTATE_HORDE && _oldState != _state)
{
sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_EWT_H));
sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_EWT_H));
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_EWT, TEAM_NEUTRAL);
}
@ -59,14 +60,14 @@ void OPvPCapturePointEP_EWT::ChangeState()
artkit = 2;
SummonSupportUnitAtNorthpassTower(TEAM_ALLIANCE);
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_EWT, TEAM_ALLIANCE);
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_A));
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_A));
break;
case OBJECTIVESTATE_HORDE:
m_TowerState = EP_TS_H;
artkit = 1;
SummonSupportUnitAtNorthpassTower(TEAM_HORDE);
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_EWT, TEAM_HORDE);
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_H));
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_H));
break;
case OBJECTIVESTATE_NEUTRAL:
m_TowerState = EP_TS_N;
@ -108,13 +109,14 @@ void OPvPCapturePointEP_EWT::SendChangePhase()
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
}
void OPvPCapturePointEP_EWT::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointEP_EWT::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << EP_EWT_A << uint32(bool(m_TowerState & EP_TS_A));
data << EP_EWT_H << uint32(bool(m_TowerState & EP_TS_H));
data << EP_EWT_N_A << uint32(bool(m_TowerState & EP_TS_N_A));
data << EP_EWT_N_H << uint32(bool(m_TowerState & EP_TS_N_H));
data << EP_EWT_N << uint32(bool(m_TowerState & EP_TS_N));
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);
}
void OPvPCapturePointEP_EWT::UpdateTowerState()
@ -173,12 +175,12 @@ void OPvPCapturePointEP_NPT::ChangeState()
// if changing from controlling alliance to horde or vice versa
if (_oldState == OBJECTIVESTATE_ALLIANCE && _oldState != _state)
{
sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_NPT_A));
sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_NPT_A));
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_NPT, TEAM_NEUTRAL);
}
else if (_oldState == OBJECTIVESTATE_HORDE && _oldState != _state)
{
sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_NPT_H));
sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_NPT_H));
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_NPT, TEAM_NEUTRAL);
}
@ -191,14 +193,14 @@ void OPvPCapturePointEP_NPT::ChangeState()
artkit = 2;
SummonGO(TEAM_ALLIANCE);
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_NPT, TEAM_ALLIANCE);
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_A));
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_A));
break;
case OBJECTIVESTATE_HORDE:
m_TowerState = EP_TS_H;
artkit = 1;
SummonGO(TEAM_HORDE);
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_NPT, TEAM_HORDE);
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_H));
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_NPT_H));
break;
case OBJECTIVESTATE_NEUTRAL:
m_TowerState = EP_TS_N;
@ -250,13 +252,14 @@ void OPvPCapturePointEP_NPT::SendChangePhase()
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
}
void OPvPCapturePointEP_NPT::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointEP_NPT::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << EP_NPT_A << uint32(bool(m_TowerState & EP_TS_A));
data << EP_NPT_H << uint32(bool(m_TowerState & EP_TS_H));
data << EP_NPT_N_A << uint32(bool(m_TowerState & EP_TS_N_A));
data << EP_NPT_N_H << uint32(bool(m_TowerState & EP_TS_N_H));
data << EP_NPT_N << uint32(bool(m_TowerState & EP_TS_N));
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);
}
void OPvPCapturePointEP_NPT::UpdateTowerState()
@ -315,12 +318,12 @@ void OPvPCapturePointEP_CGT::ChangeState()
// if changing from controlling alliance to horde or vice versa
if (_oldState == OBJECTIVESTATE_ALLIANCE && _oldState != _state)
{
sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_CGT_A));
sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_CGT_A));
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_CGT, TEAM_NEUTRAL);
}
else if (_oldState == OBJECTIVESTATE_HORDE && _oldState != _state)
{
sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_CGT_H));
sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_CGT_H));
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_CGT, TEAM_NEUTRAL);
}
@ -333,14 +336,14 @@ void OPvPCapturePointEP_CGT::ChangeState()
artkit = 2;
LinkGraveyard(TEAM_ALLIANCE);
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_CGT, TEAM_ALLIANCE);
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_A));
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_A));
break;
case OBJECTIVESTATE_HORDE:
m_TowerState = EP_TS_H;
artkit = 1;
LinkGraveyard(TEAM_HORDE);
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_CGT, TEAM_HORDE);
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_H));
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_CGT_H));
break;
case OBJECTIVESTATE_NEUTRAL:
m_TowerState = EP_TS_N;
@ -382,13 +385,14 @@ void OPvPCapturePointEP_CGT::SendChangePhase()
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
}
void OPvPCapturePointEP_CGT::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointEP_CGT::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << EP_CGT_A << uint32(bool(m_TowerState & EP_TS_A));
data << EP_CGT_H << uint32(bool(m_TowerState & EP_TS_H));
data << EP_CGT_N_A << uint32(bool(m_TowerState & EP_TS_N_A));
data << EP_CGT_N_H << uint32(bool(m_TowerState & EP_TS_N_H));
data << EP_CGT_N << uint32(bool(m_TowerState & EP_TS_N));
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);
}
void OPvPCapturePointEP_CGT::UpdateTowerState()
@ -423,8 +427,8 @@ void OPvPCapturePointEP_CGT::LinkGraveyard(TeamId teamId)
{
if (m_GraveyardSide != teamId)
{
sGraveyard->RemoveGraveyardLink(EP_GraveYardId, EP_GraveYardZone, m_GraveyardSide, false);
sGraveyard->AddGraveyardLink(EP_GraveYardId, EP_GraveYardZone, teamId, false);
sGraveyard->RemoveGraveyardLink(EP_GraveyardId, EP_GraveyardZone, m_GraveyardSide, false);
sGraveyard->AddGraveyardLink(EP_GraveyardId, EP_GraveyardZone, teamId, false);
m_GraveyardSide = teamId;
}
}
@ -442,12 +446,12 @@ void OPvPCapturePointEP_PWT::ChangeState()
// if changing from controlling alliance to horde or vice versa
if (_oldState == OBJECTIVESTATE_ALLIANCE && _oldState != _state)
{
sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_PWT_A));
sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_PWT_A));
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_PWT, TEAM_NEUTRAL);
}
else if (_oldState == OBJECTIVESTATE_HORDE && _oldState != _state)
{
sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_PWT_H));
sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_PWT_H));
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_PWT, TEAM_NEUTRAL);
}
@ -460,14 +464,14 @@ void OPvPCapturePointEP_PWT::ChangeState()
SummonFlightMaster(TEAM_ALLIANCE);
artkit = 2;
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_PWT, TEAM_ALLIANCE);
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_A));
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_A));
break;
case OBJECTIVESTATE_HORDE:
m_TowerState = EP_TS_H;
SummonFlightMaster(TEAM_HORDE);
artkit = 1;
((OutdoorPvPEP*)_pvp)->SetControlledState(EP_PWT, TEAM_HORDE);
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_H));
if (_oldState != _state) sWorldSessionMgr->SendZoneText(EP_GraveyardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_PWT_H));
break;
case OBJECTIVESTATE_NEUTRAL:
m_TowerState = EP_TS_N;
@ -519,13 +523,14 @@ void OPvPCapturePointEP_PWT::SendChangePhase()
SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, _neutralValuePct);
}
void OPvPCapturePointEP_PWT::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointEP_PWT::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << EP_PWT_A << uint32(bool(m_TowerState & EP_TS_A));
data << EP_PWT_H << uint32(bool(m_TowerState & EP_TS_H));
data << EP_PWT_N_A << uint32(bool(m_TowerState & EP_TS_N_A));
data << EP_PWT_N_H << uint32(bool(m_TowerState & EP_TS_N_H));
data << EP_PWT_N << uint32(bool(m_TowerState & EP_TS_N));
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);
}
void OPvPCapturePointEP_PWT::UpdateTowerState()
@ -712,16 +717,18 @@ void OutdoorPvPEP::SetControlledState(uint32 index, TeamId teamId)
EP_ControlsId[index] = teamId;
}
void OutdoorPvPEP::FillInitialWorldStates(WorldPacket& data)
void OutdoorPvPEP::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << EP_UI_TOWER_COUNT_A << m_AllianceTowersControlled;
data << EP_UI_TOWER_COUNT_H << m_HordeTowersControlled;
data << EP_UI_TOWER_SLIDER_DISPLAY << uint32(0);
data << EP_UI_TOWER_SLIDER_POS << uint32(50);
data << EP_UI_TOWER_SLIDER_N << uint32(100);
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);
for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{
itr->second->FillInitialWorldStates(data);
itr->second->FillInitialWorldStates(packet);
}
}

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

@ -25,9 +25,9 @@ const uint32 EP_AllianceBuffs[4] = {11413, 11414, 11415, 1386};
const uint32 EP_HordeBuffs[4] = {30880, 30683, 30682, 29520};
const uint32 EP_GraveYardZone = 139;
const uint32 EP_GraveyardZone = 139;
const uint32 EP_GraveYardId = 927;
const uint32 EP_GraveyardId = 927;
const uint8 EPBuffZonesNum = 3;
@ -191,7 +191,7 @@ public:
void SendChangePhase() override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
// used when player is activated/inactivated in the area
bool HandlePlayerEnter(Player* player) override;
@ -217,7 +217,7 @@ public:
void SendChangePhase() override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
// used when player is activated/inactivated in the area
bool HandlePlayerEnter(Player* player) override;
@ -243,7 +243,7 @@ public:
void SendChangePhase() override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
// used when player is activated/inactivated in the area
bool HandlePlayerEnter(Player* player) override;
@ -269,7 +269,7 @@ public:
void SendChangePhase() override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
// used when player is activated/inactivated in the area
bool HandlePlayerEnter(Player* player) override;
@ -298,7 +298,7 @@ public:
bool Update(uint32 diff) override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void SendRemoveWorldStates(Player* player) override;

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

@ -49,11 +49,12 @@ OPvPCapturePointGH::OPvPCapturePointGH(OutdoorPvP* pvp) : OPvPCapturePoint(pvp)
SetCapturePointData(189310, 571, 2483.68f, -1873.6f, 10.6877f, -0.104719f, 0.0f, 0.0f, 0.0f, 1.0f);
}
void OPvPCapturePointGH::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointGH::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << GH_UI_SLIDER_DISPLAY << uint32(0);
data << GH_UI_SLIDER_POS << uint32(50);
data << GH_UI_SLIDER_N << uint32(20);
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);
}
void OPvPCapturePointGH::SendChangePhase()

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

@ -52,7 +52,7 @@ public:
void ChangeState() override;
void SendChangePhase() override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
bool HandlePlayerEnter(Player* player) override;
void HandlePlayerLeave(Player* player) override;

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

@ -154,18 +154,21 @@ void OutdoorPvPHP::SendRemoveWorldStates(Player* player)
}
}
void OutdoorPvPHP::FillInitialWorldStates(WorldPacket& data)
void OutdoorPvPHP::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(HP_UI_TOWER_DISPLAY_A) << uint32(1);
data << uint32(HP_UI_TOWER_DISPLAY_H) << uint32(1);
data << uint32(HP_UI_TOWER_COUNT_A) << uint32(m_AllianceTowersControlled);
data << uint32(HP_UI_TOWER_COUNT_H) << uint32(m_HordeTowersControlled);
data << uint32(HP_UI_TOWER_SLIDER_DISPLAY) << uint32(0);
data << uint32(HP_UI_TOWER_SLIDER_POS) << uint32(50);
data << uint32(HP_UI_TOWER_SLIDER_N) << uint32(100);
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(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);
for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{
itr->second->FillInitialWorldStates(data);
itr->second->FillInitialWorldStates(packet);
}
}
@ -274,29 +277,32 @@ void OPvPCapturePointHP::SendChangePhase()
SendUpdateWorldState(HP_UI_TOWER_SLIDER_DISPLAY, 1);
}
void OPvPCapturePointHP::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointHP::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
switch (_state)
{
case OBJECTIVESTATE_ALLIANCE:
case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
data << uint32(HP_MAP_N[m_TowerType]) << uint32(0);
data << uint32(HP_MAP_A[m_TowerType]) << uint32(1);
data << uint32(HP_MAP_H[m_TowerType]) << uint32(0);
packet.Worldstates.reserve(3);
packet.Worldstates.emplace_back(HP_MAP_N[m_TowerType], 0);
packet.Worldstates.emplace_back(HP_MAP_A[m_TowerType], 1);
packet.Worldstates.emplace_back(HP_MAP_H[m_TowerType], 0);
break;
case OBJECTIVESTATE_HORDE:
case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
data << uint32(HP_MAP_N[m_TowerType]) << uint32(0);
data << uint32(HP_MAP_A[m_TowerType]) << uint32(0);
data << uint32(HP_MAP_H[m_TowerType]) << uint32(1);
packet.Worldstates.reserve(3);
packet.Worldstates.emplace_back(HP_MAP_N[m_TowerType], 0);
packet.Worldstates.emplace_back(HP_MAP_A[m_TowerType], 0);
packet.Worldstates.emplace_back(HP_MAP_H[m_TowerType], 1);
break;
case OBJECTIVESTATE_NEUTRAL:
case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
default:
data << uint32(HP_MAP_N[m_TowerType]) << uint32(1);
data << uint32(HP_MAP_A[m_TowerType]) << uint32(0);
data << uint32(HP_MAP_H[m_TowerType]) << uint32(0);
packet.Worldstates.reserve(3);
packet.Worldstates.emplace_back(HP_MAP_N[m_TowerType], 1);
packet.Worldstates.emplace_back(HP_MAP_A[m_TowerType], 0);
packet.Worldstates.emplace_back(HP_MAP_H[m_TowerType], 0);
break;
}
}

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

@ -94,7 +94,7 @@ public:
void SendChangePhase() override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
// used when player is activated/inactivated in the area
bool HandlePlayerEnter(Player* player) override;
@ -116,7 +116,7 @@ public:
bool Update(uint32 diff) override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void SendRemoveWorldStates(Player* player) override;

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

@ -29,6 +29,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSessionMgr.h"
#include "WorldStatePackets.h"
OutdoorPvPNA::OutdoorPvPNA()
{
@ -300,61 +301,53 @@ void OutdoorPvPNA::HandlePlayerLeaveZone(Player* player, uint32 zone)
OutdoorPvP::HandlePlayerLeaveZone(player, zone);
}
void OutdoorPvPNA::FillInitialWorldStates(WorldPacket& data)
void OutdoorPvPNA::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
m_obj->FillInitialWorldStates(data);
m_obj->FillInitialWorldStates(packet);
}
void OPvPCapturePointNA::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointNA::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
packet.Worldstates.reserve(25);
if (m_ControllingFaction == TEAM_ALLIANCE)
{
data << NA_UI_HORDE_GUARDS_SHOW << uint32(0);
data << NA_UI_ALLIANCE_GUARDS_SHOW << uint32(1);
packet.Worldstates.emplace_back(NA_UI_HORDE_GUARDS_SHOW, 0);
packet.Worldstates.emplace_back(NA_UI_ALLIANCE_GUARDS_SHOW, 1);
}
else if (m_ControllingFaction == TEAM_HORDE)
{
data << NA_UI_HORDE_GUARDS_SHOW << uint32(1);
data << NA_UI_ALLIANCE_GUARDS_SHOW << uint32(0);
packet.Worldstates.emplace_back(NA_UI_HORDE_GUARDS_SHOW, 1);
packet.Worldstates.emplace_back(NA_UI_ALLIANCE_GUARDS_SHOW, 0);
}
else
{
data << NA_UI_HORDE_GUARDS_SHOW << uint32(0);
data << NA_UI_ALLIANCE_GUARDS_SHOW << uint32(0);
packet.Worldstates.emplace_back(NA_UI_HORDE_GUARDS_SHOW, 0);
packet.Worldstates.emplace_back(NA_UI_ALLIANCE_GUARDS_SHOW, 0);
}
data << NA_UI_GUARDS_MAX << NA_GUARDS_MAX;
data << NA_UI_GUARDS_LEFT << uint32(m_GuardsAlive);
data << NA_UI_TOWER_SLIDER_DISPLAY << uint32(0);
data << NA_UI_TOWER_SLIDER_POS << uint32(50);
data << NA_UI_TOWER_SLIDER_N << uint32(100);
data << NA_MAP_WYVERN_NORTH_NEU_H << uint32(bool(m_WyvernStateNorth & WYVERN_NEU_HORDE));
data << NA_MAP_WYVERN_NORTH_NEU_A << uint32(bool(m_WyvernStateNorth & WYVERN_NEU_ALLIANCE));
data << NA_MAP_WYVERN_NORTH_H << uint32(bool(m_WyvernStateNorth & WYVERN_HORDE));
data << NA_MAP_WYVERN_NORTH_A << uint32(bool(m_WyvernStateNorth & WYVERN_ALLIANCE));
data << NA_MAP_WYVERN_SOUTH_NEU_H << uint32(bool(m_WyvernStateSouth & WYVERN_NEU_HORDE));
data << NA_MAP_WYVERN_SOUTH_NEU_A << uint32(bool(m_WyvernStateSouth & WYVERN_NEU_ALLIANCE));
data << NA_MAP_WYVERN_SOUTH_H << uint32(bool(m_WyvernStateSouth & WYVERN_HORDE));
data << NA_MAP_WYVERN_SOUTH_A << uint32(bool(m_WyvernStateSouth & WYVERN_ALLIANCE));
data << NA_MAP_WYVERN_WEST_NEU_H << uint32(bool(m_WyvernStateWest & WYVERN_NEU_HORDE));
data << NA_MAP_WYVERN_WEST_NEU_A << uint32(bool(m_WyvernStateWest & WYVERN_NEU_ALLIANCE));
data << NA_MAP_WYVERN_WEST_H << uint32(bool(m_WyvernStateWest & WYVERN_HORDE));
data << NA_MAP_WYVERN_WEST_A << uint32(bool(m_WyvernStateWest & WYVERN_ALLIANCE));
data << NA_MAP_WYVERN_EAST_NEU_H << uint32(bool(m_WyvernStateEast & WYVERN_NEU_HORDE));
data << NA_MAP_WYVERN_EAST_NEU_A << uint32(bool(m_WyvernStateEast & WYVERN_NEU_ALLIANCE));
data << NA_MAP_WYVERN_EAST_H << uint32(bool(m_WyvernStateEast & WYVERN_HORDE));
data << NA_MAP_WYVERN_EAST_A << uint32(bool(m_WyvernStateEast & WYVERN_ALLIANCE));
data << NA_MAP_HALAA_NEUTRAL << uint32(bool(m_HalaaState & HALAA_N));
data << NA_MAP_HALAA_NEU_A << uint32(bool(m_HalaaState & HALAA_N_A));
data << NA_MAP_HALAA_NEU_H << uint32(bool(m_HalaaState & HALAA_N_H));
data << NA_MAP_HALAA_HORDE << uint32(bool(m_HalaaState & HALAA_H));
data << NA_MAP_HALAA_ALLIANCE << uint32(bool(m_HalaaState & HALAA_A));
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);
}
void OutdoorPvPNA::SendRemoveWorldStates(Player* player)

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

@ -229,7 +229,7 @@ public:
void SendChangePhase() override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
// used when player is activated/inactivated in the area
bool HandlePlayerEnter(Player* player) override;
@ -287,7 +287,7 @@ public:
bool Update(uint32 diff) override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void SendRemoveWorldStates(Player* player) override;

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

@ -29,6 +29,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSessionMgr.h"
#include "WorldStatePackets.h"
OutdoorPvPSI::OutdoorPvPSI()
{
@ -38,11 +39,12 @@ OutdoorPvPSI::OutdoorPvPSI()
m_LastController = TEAM_NEUTRAL;
}
void OutdoorPvPSI::FillInitialWorldStates(WorldPacket& data)
void OutdoorPvPSI::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << SI_GATHERED_A << m_Gathered_A;
data << SI_GATHERED_H << m_Gathered_H;
data << SI_SILITHYST_MAX << SI_MAX_RESOURCES;
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);
}
void OutdoorPvPSI::SendRemoveWorldStates(Player* player)

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

@ -63,7 +63,7 @@ public:
bool Update(uint32 diff) override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void SendRemoveWorldStates(Player* player) override;
@ -78,7 +78,6 @@ public:
private:
uint32 m_Gathered_A;
uint32 m_Gathered_H;
TeamId m_LastController;
};

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

@ -27,6 +27,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSessionMgr.h"
#include "WorldStatePackets.h"
OutdoorPvPTF::OutdoorPvPTF()
{
@ -51,34 +52,34 @@ OPvPCapturePointTF::OPvPCapturePointTF(OutdoorPvP* pvp, OutdoorPvPTF_TowerType t
SetCapturePointData(TFCapturePoints[type].entry, TFCapturePoints[type].map, TFCapturePoints[type].x, TFCapturePoints[type].y, TFCapturePoints[type].z, TFCapturePoints[type].o, TFCapturePoints[type].rot0, TFCapturePoints[type].rot1, TFCapturePoints[type].rot2, TFCapturePoints[type].rot3);
}
void OPvPCapturePointTF::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointTF::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(TFTowerWorldStates[m_TowerType].n) << uint32(bool(m_TowerState & TF_TOWERSTATE_N));
data << uint32(TFTowerWorldStates[m_TowerType].h) << uint32(bool(m_TowerState & TF_TOWERSTATE_H));
data << uint32(TFTowerWorldStates[m_TowerType].a) << uint32(bool(m_TowerState & TF_TOWERSTATE_A));
packet.Worldstates.reserve(3);
packet.Worldstates.emplace_back(TFTowerWorldStates[m_TowerType].n, (m_TowerState & TF_TOWERSTATE_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(TFTowerWorldStates[m_TowerType].h, (m_TowerState & TF_TOWERSTATE_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(TFTowerWorldStates[m_TowerType].a, (m_TowerState & TF_TOWERSTATE_A) != 0 ? 1 : 0);
}
void OutdoorPvPTF::FillInitialWorldStates(WorldPacket& data)
void OutdoorPvPTF::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << TF_UI_TOWER_SLIDER_POS << uint32(50);
data << TF_UI_TOWER_SLIDER_N << uint32(100);
data << TF_UI_TOWER_SLIDER_DISPLAY << uint32(0);
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);
data << TF_UI_TOWER_COUNT_H << m_HordeTowersControlled;
data << TF_UI_TOWER_COUNT_A << m_AllianceTowersControlled;
data << TF_UI_TOWERS_CONTROLLED_DISPLAY << uint32(!m_IsLocked);
data << TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT << first_digit;
data << TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT << second_digit;
data << TF_UI_LOCKED_TIME_HOURS << hours_left;
data << TF_UI_LOCKED_DISPLAY_NEUTRAL << 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));
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);
for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{
itr->second->FillInitialWorldStates(data);
itr->second->FillInitialWorldStates(packet);
}
}

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

@ -132,7 +132,7 @@ public:
void SendChangePhase() override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
// used when player is activated/inactivated in the area
bool HandlePlayerEnter(Player* player) override;
@ -144,7 +144,6 @@ public:
protected:
OutdoorPvPTF_TowerType m_TowerType;
uint32 m_TowerState;
};
@ -160,7 +159,7 @@ public:
bool Update(uint32 diff) override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void SendRemoveWorldStates(Player* player) override;

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

@ -26,6 +26,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSessionMgr.h"
#include "WorldStatePackets.h"
OPvPCapturePointZM_Beacon::OPvPCapturePointZM_Beacon(OutdoorPvP* pvp, ZM_BeaconType type)
: OPvPCapturePoint(pvp), m_TowerType(type), m_TowerState(ZM_TOWERSTATE_N)
@ -33,14 +34,15 @@ OPvPCapturePointZM_Beacon::OPvPCapturePointZM_Beacon(OutdoorPvP* pvp, ZM_BeaconT
SetCapturePointData(ZMCapturePoints[type].entry, ZMCapturePoints[type].map, ZMCapturePoints[type].x, ZMCapturePoints[type].y, ZMCapturePoints[type].z, ZMCapturePoints[type].o, ZMCapturePoints[type].rot0, ZMCapturePoints[type].rot1, ZMCapturePoints[type].rot2, ZMCapturePoints[type].rot3);
}
void OPvPCapturePointZM_Beacon::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointZM_Beacon::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << uint32(ZMBeaconInfo[m_TowerType].ui_tower_n) << uint32(bool(m_TowerState & ZM_TOWERSTATE_N));
data << uint32(ZMBeaconInfo[m_TowerType].map_tower_n) << uint32(bool(m_TowerState & ZM_TOWERSTATE_N));
data << uint32(ZMBeaconInfo[m_TowerType].ui_tower_a) << uint32(bool(m_TowerState & ZM_TOWERSTATE_A));
data << uint32(ZMBeaconInfo[m_TowerType].map_tower_a) << uint32(bool(m_TowerState & ZM_TOWERSTATE_A));
data << uint32(ZMBeaconInfo[m_TowerType].ui_tower_h) << uint32(bool(m_TowerState & ZM_TOWERSTATE_H));
data << uint32(ZMBeaconInfo[m_TowerType].map_tower_h) << uint32(bool(m_TowerState & ZM_TOWERSTATE_H));
packet.Worldstates.reserve(6);
packet.Worldstates.emplace_back(ZMBeaconInfo[m_TowerType].ui_tower_n, (m_TowerState & ZM_TOWERSTATE_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(ZMBeaconInfo[m_TowerType].map_tower_n, (m_TowerState & ZM_TOWERSTATE_N) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(ZMBeaconInfo[m_TowerType].ui_tower_a, (m_TowerState & ZM_TOWERSTATE_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(ZMBeaconInfo[m_TowerType].map_tower_a, (m_TowerState & ZM_TOWERSTATE_A) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(ZMBeaconInfo[m_TowerType].ui_tower_h, (m_TowerState & ZM_TOWERSTATE_H) != 0 ? 1 : 0);
packet.Worldstates.emplace_back(ZMBeaconInfo[m_TowerType].map_tower_h, (m_TowerState & ZM_TOWERSTATE_H) != 0 ? 1 : 0);
}
void OPvPCapturePointZM_Beacon::UpdateTowerState()
@ -137,11 +139,11 @@ bool OutdoorPvPZM::Update(uint32 diff)
if (changed)
{
if (m_AllianceTowersControlled == ZM_NUM_BEACONS)
m_GraveYard->SetBeaconState(TEAM_ALLIANCE);
m_Graveyard->SetBeaconState(TEAM_ALLIANCE);
else if (m_HordeTowersControlled == ZM_NUM_BEACONS)
m_GraveYard->SetBeaconState(TEAM_HORDE);
m_Graveyard->SetBeaconState(TEAM_HORDE);
else
m_GraveYard->SetBeaconState(TEAM_NEUTRAL);
m_Graveyard->SetBeaconState(TEAM_NEUTRAL);
}
return changed;
}
@ -150,12 +152,12 @@ void OutdoorPvPZM::HandlePlayerEnterZone(Player* player, uint32 zone)
{
if (player->GetTeamId() == TEAM_ALLIANCE)
{
if (m_GraveYard->GetGraveYardState() & ZM_GRAVEYARD_A)
if (m_Graveyard->GetGraveyardState() & ZM_GRAVEYARD_A)
player->CastSpell(player, ZM_CAPTURE_BUFF, true);
}
else
{
if (m_GraveYard->GetGraveYardState() & ZM_GRAVEYARD_H)
if (m_Graveyard->GetGraveyardState() & ZM_GRAVEYARD_H)
player->CastSpell(player, ZM_CAPTURE_BUFF, true);
}
OutdoorPvP::HandlePlayerEnterZone(player, zone);
@ -174,7 +176,7 @@ void OutdoorPvPZM::HandlePlayerLeaveZone(Player* player, uint32 zone)
OutdoorPvPZM::OutdoorPvPZM()
{
_typeId = OUTDOOR_PVP_ZM;
m_GraveYard = nullptr;
m_Graveyard = nullptr;
m_AllianceTowersControlled = 0;
m_HordeTowersControlled = 0;
}
@ -192,8 +194,8 @@ bool OutdoorPvPZM::SetupOutdoorPvP()
AddCapturePoint(new OPvPCapturePointZM_Beacon(this, ZM_BEACON_WEST));
AddCapturePoint(new OPvPCapturePointZM_Beacon(this, ZM_BEACON_EAST));
m_GraveYard = new OPvPCapturePointZM_GraveYard(this);
AddCapturePoint(m_GraveYard); // though the update function isn't used, the handleusego is!
m_Graveyard = new OPvPCapturePointZM_Graveyard(this);
AddCapturePoint(m_Graveyard); // though the update function isn't used, the handleusego is!
return true;
}
@ -209,23 +211,23 @@ void OutdoorPvPZM::HandleKillImpl(Player* player, Unit* killed)
player->CastSpell(player, ZM_HordePlayerKillReward, true);
}
bool OPvPCapturePointZM_GraveYard::Update(uint32 /*diff*/)
bool OPvPCapturePointZM_Graveyard::Update(uint32 /*diff*/)
{
bool retval = _state != _oldState;
_state = _oldState;
return retval;
}
int32 OPvPCapturePointZM_GraveYard::HandleOpenGo(Player* player, GameObject* go)
int32 OPvPCapturePointZM_Graveyard::HandleOpenGo(Player* player, GameObject* go)
{
int32 retval = OPvPCapturePoint::HandleOpenGo(player, go);
if (retval >= 0)
{
if (player->HasAura(ZM_BATTLE_STANDARD_A) && m_GraveYardState != ZM_GRAVEYARD_A)
if (player->HasAura(ZM_BATTLE_STANDARD_A) && m_GraveyardState != ZM_GRAVEYARD_A)
{
if (m_GraveYardState == ZM_GRAVEYARD_H)
if (m_GraveyardState == ZM_GRAVEYARD_H)
sWorldSessionMgr->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_ZM_LOSE_GY_H));
m_GraveYardState = ZM_GRAVEYARD_A;
m_GraveyardState = ZM_GRAVEYARD_A;
DelObject(0); // only one gotype is used in the whole outdoor pvp, no need to call it a constant
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
@ -234,11 +236,11 @@ int32 OPvPCapturePointZM_GraveYard::HandleOpenGo(Player* player, GameObject* go)
player->RemoveAurasDueToSpell(ZM_BATTLE_STANDARD_A);
sWorldSessionMgr->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_ZM_CAPTURE_GY_A));
}
else if (player->HasAura(ZM_BATTLE_STANDARD_H) && m_GraveYardState != ZM_GRAVEYARD_H)
else if (player->HasAura(ZM_BATTLE_STANDARD_H) && m_GraveyardState != ZM_GRAVEYARD_H)
{
if (m_GraveYardState == ZM_GRAVEYARD_A)
if (m_GraveyardState == ZM_GRAVEYARD_A)
sWorldSessionMgr->SendZoneText(ZM_GRAVEYARD_ZONE, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_ZM_LOSE_GY_A));
m_GraveYardState = ZM_GRAVEYARD_H;
m_GraveyardState = ZM_GRAVEYARD_H;
DelObject(0); // only one gotype is used in the whole outdoor pvp, no need to call it a constant
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
@ -252,11 +254,11 @@ int32 OPvPCapturePointZM_GraveYard::HandleOpenGo(Player* player, GameObject* go)
return retval;
}
OPvPCapturePointZM_GraveYard::OPvPCapturePointZM_GraveYard(OutdoorPvP* pvp)
OPvPCapturePointZM_Graveyard::OPvPCapturePointZM_Graveyard(OutdoorPvP* pvp)
: OPvPCapturePoint(pvp)
{
m_BothControllingFactionId = TEAM_NEUTRAL;
m_GraveYardState = ZM_GRAVEYARD_N;
m_GraveyardState = ZM_GRAVEYARD_N;
m_FlagCarrierGUID.Clear();
// add field scouts here
AddCreature(ZM_ALLIANCE_FIELD_SCOUT, ZM_AllianceFieldScout.entry, ZM_AllianceFieldScout.map, ZM_AllianceFieldScout.x, ZM_AllianceFieldScout.y, ZM_AllianceFieldScout.z, ZM_AllianceFieldScout.o);
@ -265,11 +267,11 @@ OPvPCapturePointZM_GraveYard::OPvPCapturePointZM_GraveYard(OutdoorPvP* pvp)
AddObject(0, ZM_Banner_N.entry, ZM_Banner_N.map, ZM_Banner_N.x, ZM_Banner_N.y, ZM_Banner_N.z, ZM_Banner_N.o, ZM_Banner_N.rot0, ZM_Banner_N.rot1, ZM_Banner_N.rot2, ZM_Banner_N.rot3);
}
void OPvPCapturePointZM_GraveYard::UpdateTowerState()
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(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(ZM_MAP_ALLIANCE_FLAG_READY, uint32(m_BothControllingFactionId == TEAM_ALLIANCE));
_pvp->SendUpdateWorldState(ZM_MAP_ALLIANCE_FLAG_NOT_READY, uint32(m_BothControllingFactionId != TEAM_ALLIANCE));
@ -277,19 +279,19 @@ void OPvPCapturePointZM_GraveYard::UpdateTowerState()
_pvp->SendUpdateWorldState(ZM_MAP_HORDE_FLAG_NOT_READY, uint32(m_BothControllingFactionId != TEAM_HORDE));
}
void OPvPCapturePointZM_GraveYard::FillInitialWorldStates(WorldPacket& data)
void OPvPCapturePointZM_Graveyard::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << ZM_MAP_GRAVEYARD_N << uint32(bool(m_GraveYardState & ZM_GRAVEYARD_N));
data << ZM_MAP_GRAVEYARD_H << uint32(bool(m_GraveYardState & ZM_GRAVEYARD_H));
data << ZM_MAP_GRAVEYARD_A << uint32(bool(m_GraveYardState & ZM_GRAVEYARD_A));
data << ZM_MAP_ALLIANCE_FLAG_READY << uint32(m_BothControllingFactionId == TEAM_ALLIANCE);
data << ZM_MAP_ALLIANCE_FLAG_NOT_READY << uint32(m_BothControllingFactionId != TEAM_ALLIANCE);
data << ZM_MAP_HORDE_FLAG_READY << uint32(m_BothControllingFactionId == TEAM_HORDE);
data << ZM_MAP_HORDE_FLAG_NOT_READY << uint32(m_BothControllingFactionId != TEAM_HORDE);
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);
}
void OPvPCapturePointZM_GraveYard::SetBeaconState(TeamId controlling_factionId)
void OPvPCapturePointZM_Graveyard::SetBeaconState(TeamId controlling_factionId)
{
// nothing to do here
if (m_BothControllingFactionId == controlling_factionId)
@ -300,20 +302,20 @@ void OPvPCapturePointZM_GraveYard::SetBeaconState(TeamId controlling_factionId)
{
case TEAM_ALLIANCE:
// if ally already controls the gy and taken back both beacons, return, nothing to do for us
if (m_GraveYardState & ZM_GRAVEYARD_A)
if (m_GraveyardState & ZM_GRAVEYARD_A)
return;
// ally doesn't control the gy, but controls the side beacons -> add gossip option, add neutral banner
break;
case TEAM_HORDE:
// if horde already controls the gy and taken back both beacons, return, nothing to do for us
if (m_GraveYardState & ZM_GRAVEYARD_H)
if (m_GraveyardState & ZM_GRAVEYARD_H)
return;
// horde doesn't control the gy, but controls the side beacons -> add gossip option, add neutral banner
break;
default:
// if the graveyard is not neutral, then leave it that way
// if the graveyard is neutral, then we have to dispel the buff from the flag carrier
if (m_GraveYardState & ZM_GRAVEYARD_N)
if (m_GraveyardState & ZM_GRAVEYARD_N)
{
// gy was neutral, thus neutral banner was spawned, it is possible that someone was taking the flag to the gy
if (m_FlagCarrierGUID)
@ -334,21 +336,21 @@ void OPvPCapturePointZM_GraveYard::SetBeaconState(TeamId controlling_factionId)
UpdateTowerState();
}
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();
auto itr = _creatureTypes.find(guid.GetCounter());
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;
else if (itr->second == ZM_HORDE_FIELD_SCOUT && player->GetTeamId() == TEAM_HORDE && m_BothControllingFactionId == TEAM_HORDE && !m_FlagCarrierGUID && m_GraveYardState != ZM_GRAVEYARD_H)
else if (itr->second == ZM_HORDE_FIELD_SCOUT && player->GetTeamId() == TEAM_HORDE && m_BothControllingFactionId == TEAM_HORDE && !m_FlagCarrierGUID && m_GraveyardState != ZM_GRAVEYARD_H)
return true;
}
return false;
}
bool OPvPCapturePointZM_GraveYard::HandleGossipOption(Player* player, Creature* creature, uint32 /*gossipid*/)
bool OPvPCapturePointZM_Graveyard::HandleGossipOption(Player* player, Creature* creature, uint32 /*gossipid*/)
{
auto itr = _creatureTypes.find(creature->GetSpawnId());
if (itr != _creatureTypes.end())
@ -375,7 +377,7 @@ bool OPvPCapturePointZM_GraveYard::HandleGossipOption(Player* player, Creature*
return false;
}
bool OPvPCapturePointZM_GraveYard::HandleDropFlag(Player* /*player*/, uint32 spellId)
bool OPvPCapturePointZM_Graveyard::HandleDropFlag(Player* /*player*/, uint32 spellId)
{
switch (spellId)
{
@ -389,9 +391,9 @@ bool OPvPCapturePointZM_GraveYard::HandleDropFlag(Player* /*player*/, uint32 spe
return false;
}
uint32 OPvPCapturePointZM_GraveYard::GetGraveYardState() const
uint32 OPvPCapturePointZM_Graveyard::GetGraveyardState() const
{
return m_GraveYardState;
return m_GraveyardState;
}
uint32 OutdoorPvPZM::GetAllianceTowersControlled() const
@ -414,12 +416,12 @@ void OutdoorPvPZM::SetHordeTowersControlled(uint32 count)
m_HordeTowersControlled = count;
}
void OutdoorPvPZM::FillInitialWorldStates(WorldPacket& data)
void OutdoorPvPZM::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet)
{
data << ZM_WORLDSTATE_UNK_1 << uint32(1);
packet.Worldstates.emplace_back(ZM_WORLDSTATE_UNK_1, 1);
for (OPvPCapturePointMap::iterator itr = _capturePoints.begin(); itr != _capturePoints.end(); ++itr)
{
itr->second->FillInitialWorldStates(data);
itr->second->FillInitialWorldStates(packet);
}
}

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

@ -175,7 +175,7 @@ public:
void SendChangePhase() override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
// used when player is activated/inactivated in the area
bool HandlePlayerEnter(Player* player) override;
@ -188,23 +188,23 @@ protected:
uint32 m_TowerState;
};
enum ZM_GraveYardState
enum Zm_GraveyardState
{
ZM_GRAVEYARD_N = 1,
ZM_GRAVEYARD_A = 2,
ZM_GRAVEYARD_H = 4
};
class OPvPCapturePointZM_GraveYard : public OPvPCapturePoint
class OPvPCapturePointZM_Graveyard : public OPvPCapturePoint
{
public:
OPvPCapturePointZM_GraveYard(OutdoorPvP* pvp);
OPvPCapturePointZM_Graveyard(OutdoorPvP* pvp);
bool Update(uint32 diff) override;
void ChangeState() override {}
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void UpdateTowerState();
@ -218,10 +218,10 @@ public:
bool CanTalkTo(Player* player, Creature* creature, GossipMenuItems const& gso) override;
uint32 GetGraveYardState() const;
uint32 GetGraveyardState() const;
private:
uint32 m_GraveYardState;
uint32 m_GraveyardState;
protected:
TeamId m_BothControllingFactionId;
@ -240,7 +240,7 @@ public:
bool Update(uint32 diff) override;
void FillInitialWorldStates(WorldPacket& data) override;
void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet) override;
void SendRemoveWorldStates(Player* player) override;
@ -253,7 +253,7 @@ public:
void SetHordeTowersControlled(uint32 count);
private:
OPvPCapturePointZM_GraveYard* m_GraveYard;
OPvPCapturePointZM_Graveyard* m_Graveyard;
uint32 m_AllianceTowersControlled;
uint32 m_HordeTowersControlled;