Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-29 13:22:48 +01:00
Code Issues Packages Projects Releases Wiki Activity

Core/GameObject: Implement ControlZone gameobject type (#29320)

Browse Source
This commit is contained in:
Jeremy
2023-10-03 15:55:24 +02:00
committed by GitHub
parent 4537b37738
commit f96f041c3e
23 changed files with 1418 additions and 1572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

176
src/server/scripts/Battlefield/BattlefieldTB.cpp
View File

@@ -100,15 +100,25 @@ bool BattlefieldTB::SetupBattlefield()
// Create capture points
for (uint8 i = 0; i < TB_BASE_COUNT; i++)
{
TolBaradCapturePoint* capturePoint = new TolBaradCapturePoint(this, GetDefenderTeam());
//Spawn flag pole
if (GameObject* go = SpawnGameObject(TBCapturePoints[i].entryFlagPole[GetDefenderTeam()], TBCapturePoints[i].pos, QuaternionData::fromEulerAnglesZYX(TBCapturePoints[i].pos.GetOrientation(), 0.0f, 0.0f)))
{
go->SetGoArtKit(GetDefenderTeam() == TEAM_ALLIANCE ? TB_GO_ARTKIT_FLAG_ALLIANCE : TB_GO_ARTKIT_FLAG_HORDE);
capturePoint->SetCapturePointData(go);
std::unique_ptr<TolBaradCapturePoint> controlZone = std::make_unique<TolBaradCapturePoint>(this, TBCapturePoints[i]);
if (GetDefenderTeam() == TEAM_ALLIANCE)
{
sWorldStateMgr->SetValue(controlZone->GetWorldStateAllianceControlled(), 1, false, GetMap());
go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(100));
go->SetGoArtKit(TB_GO_ARTKIT_FLAG_ALLIANCE);
}
else if (GetDefenderTeam() == TEAM_HORDE)
{
sWorldStateMgr->SetValue(controlZone->GetWorldStateHordeControlled(), 1, false, GetMap());
go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(0));
go->SetGoArtKit(TB_GO_ARTKIT_FLAG_HORDE);
}
ControlZoneHandlers[go->GetEntry()] = std::move(controlZone);
}
AddCapturePoint(capturePoint);
}
// Spawn towers
@@ -379,23 +389,29 @@ void BattlefieldTB::UpdateNPCsAndGameObjects()
if (GetState() == BATTLEFIELD_INACTIVE)
{
// Delete capture points
for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
itr->second->DelCapturePoint();
m_capturePoints.clear();
ControlZoneHandlers.clear();
// Create capture points
for (uint8 i = 0; i < TB_BASE_COUNT; i++)
{
TolBaradCapturePoint* capturePoint = new TolBaradCapturePoint(this, GetDefenderTeam());
//Spawn flag pole
if (GameObject* go = SpawnGameObject(TBCapturePoints[i].entryFlagPole[GetDefenderTeam()], TBCapturePoints[i].pos, QuaternionData::fromEulerAnglesZYX(TBCapturePoints[i].pos.GetOrientation(), 0.0f, 0.0f)))
{
go->SetGoArtKit(GetDefenderTeam() == TEAM_ALLIANCE ? TB_GO_ARTKIT_FLAG_ALLIANCE : TB_GO_ARTKIT_FLAG_HORDE);
capturePoint->SetCapturePointData(go);
}
std::unique_ptr<TolBaradCapturePoint> controlZone = std::make_unique<TolBaradCapturePoint>(this, TBCapturePoints[i]);
if (GetDefenderTeam() == TEAM_ALLIANCE)
{
sWorldStateMgr->SetValue(controlZone->GetWorldStateAllianceControlled(), 1, false, GetMap());
go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(100));
go->SetGoArtKit(TB_GO_ARTKIT_FLAG_ALLIANCE);
}
else if (GetDefenderTeam() == TEAM_HORDE)
{
sWorldStateMgr->SetValue(controlZone->GetWorldStateHordeControlled(), 1, false, GetMap());
go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(0));
go->SetGoArtKit(TB_GO_ARTKIT_FLAG_HORDE);
}
AddCapturePoint(capturePoint);
ControlZoneHandlers[go->GetEntry()] = std::move(controlZone);
}
}
for (ObjectGuid guid : BattleInactiveNPCs)
@@ -558,8 +574,9 @@ void BattlefieldTB::OnGameObjectCreate(GameObject* go)
}
}
void BattlefieldTB::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* /*invoker*/)
void BattlefieldTB::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* invoker)
{
Battlefield::ProcessEvent(obj, eventId, invoker);
if (!IsWarTime())
return;
@@ -644,9 +661,19 @@ void BattlefieldTB::UpdateCapturedBaseCount()
{
uint32 numCapturedBases = 0; // How many bases attacker has captured
for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
if (itr->second->GetTeamId() == GetAttackerTeam())
numCapturedBases += 1;
// these world states are either 0 or 1
if (GetAttackerTeam() == TEAM_ALLIANCE)
{
numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_GARRISON_ALLIANCE_CONTROLLED, GetMap());
numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_VIGIL_ALLIANCE_CONTROLLED, GetMap());
numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_SLAGWORKS_ALLIANCE_CONTROLLED, GetMap());
}
else if (GetAttackerTeam() == TEAM_HORDE)
{
numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_GARRISON_HORDE_CONTROLLED, GetMap());
numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_VIGIL_HORDE_CONTROLLED, GetMap());
numCapturedBases += sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_SLAGWORKS_HORDE_CONTROLLED, GetMap());
}
sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_BUILDINGS_CAPTURED, numCapturedBases, false, m_Map);
@@ -676,76 +703,65 @@ void BattlefieldTB::PromotePlayer(Player* killer)
killer->CastSpell(killer, SPELL_TB_VETERAN, true);
}
TolBaradCapturePoint::TolBaradCapturePoint(BattlefieldTB* battlefield, TeamId teamInControl) : BfCapturePoint(battlefield)
TolBaradCapturePoint::TolBaradCapturePoint(BattlefieldTB* battlefield, TBCapturePointSpawnData const& data) : BattlefieldControlZoneHandler(battlefield),
_textIdHordeCaptured(data.textGained[TEAM_HORDE]), _textIdAllianceCaptured(data.textGained[TEAM_ALLIANCE]),
_textIdHordeLost(data.textLost[TEAM_HORDE]), _textIdAllianceLost(data.textLost[TEAM_ALLIANCE]),
_worldstateHordeControlled(data.wsControlled[TEAM_HORDE]), _worldstateAllianceControlled(data.wsControlled[TEAM_ALLIANCE]),
_worldstateHordeCapturing(data.wsCapturing[TEAM_HORDE]), _worldstateAllianceCapturing(data.wsCapturing[TEAM_ALLIANCE]),
_worldstateNeutral(data.wsNeutral)
{
m_Bf = battlefield;
m_team = teamInControl;
m_value = teamInControl == TEAM_ALLIANCE ? m_maxValue : -m_maxValue;
m_State = teamInControl == TEAM_ALLIANCE ? BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE : BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE;
}
void TolBaradCapturePoint::SendChangePhase()
void TolBaradCapturePoint::HandleContestedEventHorde(GameObject* controlZone)
{
if (m_OldState == m_State)
return;
BattlefieldControlZoneHandler::HandleContestedEventHorde(controlZone);
}
// Find out index
uint8 iBase = TB_BASE_COUNT;
for (uint8 i = 0; i < TB_BASE_COUNT; i++)
if (GetCapturePointEntry() == TBCapturePoints[i].entryFlagPole[m_Bf->GetDefenderTeam()])
iBase = i;
void TolBaradCapturePoint::HandleContestedEventAlliance(GameObject* controlZone)
{
BattlefieldControlZoneHandler::HandleContestedEventAlliance(controlZone);
}
if (iBase == TB_BASE_COUNT)
return;
void TolBaradCapturePoint::HandleProgressEventHorde(GameObject* controlZone)
{
BattlefieldControlZoneHandler::HandleProgressEventHorde(controlZone);
GetBattlefield()->SendWarning(_textIdHordeCaptured);
controlZone->SetGoArtKit(TB_GO_ARTKIT_FLAG_HORDE);
sWorldStateMgr->SetValue(_worldstateHordeControlled, 1, false, controlZone->GetMap());
sWorldStateMgr->SetValue(_worldstateHordeCapturing, 0, false, controlZone->GetMap());
GetBattlefield()->ProcessEvent(nullptr, EVENT_COUNT_CAPTURED_BASE, nullptr);
}
// Turn off previous world state icon
switch (m_OldState)
{
case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE:
case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE:
sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsControlled[GetTeamId()], 0, false, m_Bf->GetMap());
break;
case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_ALLIANCE], 0, false, m_Bf->GetMap());
break;
case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_HORDE], 0, false, m_Bf->GetMap());
break;
default:
break;
}
void TolBaradCapturePoint::HandleProgressEventAlliance(GameObject* controlZone)
{
BattlefieldControlZoneHandler::HandleProgressEventAlliance(controlZone);
GetBattlefield()->SendWarning(_textIdAllianceCaptured);
controlZone->SetGoArtKit(TB_GO_ARTKIT_FLAG_ALLIANCE);
sWorldStateMgr->SetValue(_worldstateAllianceControlled, 1, false, controlZone->GetMap());
sWorldStateMgr->SetValue(_worldstateAllianceCapturing, 0, false, controlZone->GetMap());
GetBattlefield()->ProcessEvent(nullptr, EVENT_COUNT_CAPTURED_BASE, nullptr);
}
// Turn on new world state icon and send warning
switch (m_State)
{
case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE:
case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE:
m_Bf->SendWarning(TBCapturePoints[iBase].textGained[GetTeamId()]);
sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsControlled[GetTeamId()], 1, false, m_Bf->GetMap());
GetCapturePointGo()->SetGoArtKit(GetTeamId() == TEAM_ALLIANCE ? TB_GO_ARTKIT_FLAG_ALLIANCE : TB_GO_ARTKIT_FLAG_HORDE);
break;
case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
m_Bf->SendWarning(TBCapturePoints[iBase].textLost[TEAM_HORDE]);
[[fallthrough]];
case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_ALLIANCE], 1, false, m_Bf->GetMap());
GetCapturePointGo()->SetGoArtKit(TB_GO_ARTKIT_FLAG_NONE);
break;
case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
m_Bf->SendWarning(TBCapturePoints[iBase].textLost[TEAM_ALLIANCE]);
[[fallthrough]];
case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_HORDE], 1, false, m_Bf->GetMap());
GetCapturePointGo()->SetGoArtKit(TB_GO_ARTKIT_FLAG_NONE);
break;
default:
break;
}
void TolBaradCapturePoint::HandleNeutralEventHorde(GameObject* controlZone)
{
GetBattlefield()->SendWarning(_textIdHordeLost);
sWorldStateMgr->SetValue(_worldstateHordeControlled, 0, false, controlZone->GetMap());
sWorldStateMgr->SetValue(_worldstateAllianceCapturing, 1, false, controlZone->GetMap());
BattlefieldControlZoneHandler::HandleNeutralEventHorde(controlZone);
}
// Update counter
m_Bf->ProcessEvent(nullptr, EVENT_COUNT_CAPTURED_BASE, nullptr);
void TolBaradCapturePoint::HandleNeutralEventAlliance(GameObject* controlZone)
{
GetBattlefield()->SendWarning(_textIdAllianceLost);
sWorldStateMgr->SetValue(_worldstateAllianceControlled, 0, false, controlZone->GetMap());
sWorldStateMgr->SetValue(_worldstateHordeCapturing, 1, false, controlZone->GetMap());
BattlefieldControlZoneHandler::HandleNeutralEventAlliance(controlZone);
}
void TolBaradCapturePoint::HandleNeutralEvent(GameObject* controlZone)
{
BattlefieldControlZoneHandler::HandleNeutralEvent(controlZone);
controlZone->SetGoArtKit(TB_GO_ARTKIT_FLAG_NONE);
}
class Battlefield_tol_barad : public BattlefieldScript

26
src/server/scripts/Battlefield/BattlefieldTB.h
View File

@@ -533,12 +533,32 @@ TBGraveyardInfo const TBGraveyards[BATTLEFIELD_TB_GRAVEYARD_MAX] =
* Tol Barad capture point *
* ####################### */
class TolBaradCapturePoint : public BfCapturePoint
class TolBaradCapturePoint : public BattlefieldControlZoneHandler
{
public:
TolBaradCapturePoint(BattlefieldTB* battlefield, TeamId teamInControl);
TolBaradCapturePoint(BattlefieldTB* battlefield, TBCapturePointSpawnData const& data);
void SendChangePhase() override;
void HandleContestedEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleContestedEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEvent([[maybe_unused]] GameObject* controlZone) override;
uint32 GetWorldStateHordeControlled() const { return _worldstateHordeControlled; }
uint32 GetWorldStateAllianceControlled() const { return _worldstateAllianceControlled; }
private:
uint32 _textIdHordeCaptured;
uint32 _textIdAllianceCaptured;
uint32 _textIdHordeLost;
uint32 _textIdAllianceLost;
uint32 _worldstateHordeControlled;
uint32 _worldstateAllianceControlled;
uint32 _worldstateHordeCapturing;
uint32 _worldstateAllianceCapturing;
uint32 _worldstateNeutral;
};
/* ##################### *

47
src/server/scripts/Battlefield/BattlefieldWG.cpp
View File

@@ -928,11 +928,18 @@ void BattlefieldWG::OnGameObjectCreate(GameObject* go)
{
if (workshop->GetId() == workshopId)
{
WintergraspCapturePoint* capturePoint = new WintergraspCapturePoint(this, GetAttackerTeam());
ControlZoneHandlers[go->GetEntry()] = std::make_unique<WintergraspCapturePoint>(this, workshop);
if (GetAttackerTeam() == TEAM_ALLIANCE)
{
//go->SetGoArtKit(); // todo set art kit
go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(100));
}
else if (GetAttackerTeam() == TEAM_HORDE)
{
//go->SetGoArtKit(); // todo set art kit
go->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue(0));
}
capturePoint->SetCapturePointData(go);
capturePoint->LinkToWorkshop(workshop);
AddCapturePoint(capturePoint);
break;
}
}
@@ -1185,8 +1192,9 @@ void BattlefieldWG::UpdatedDestroyedTowerCount(TeamId team)
}
}
void BattlefieldWG::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* /*invoker*/)
void BattlefieldWG::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* invoker)
{
Battlefield::ProcessEvent(obj, eventId, invoker);
if (!obj || !IsWarTime())
return;
@@ -1311,17 +1319,34 @@ void BattlefieldWG::UpdateTenacity()
m_tenacityTeam = TEAM_NEUTRAL;
}
WintergraspCapturePoint::WintergraspCapturePoint(BattlefieldWG* battlefield, TeamId teamInControl) : BfCapturePoint(battlefield)
WintergraspCapturePoint::WintergraspCapturePoint(BattlefieldWG* battlefield, WintergraspWorkshop* workshop) : BattlefieldControlZoneHandler(battlefield), m_Workshop(workshop)
{
m_Bf = battlefield;
m_team = teamInControl;
m_Workshop = nullptr;
}
void WintergraspCapturePoint::ChangeTeam(TeamId /*oldTeam*/)
void WintergraspCapturePoint::HandleContestedEventHorde(GameObject* controlZone)
{
ASSERT(m_Workshop);
m_Workshop->GiveControlTo(m_team);
BattlefieldControlZoneHandler::HandleContestedEventHorde(controlZone);
m_Workshop->GiveControlTo(TEAM_NEUTRAL);
}
void WintergraspCapturePoint::HandleContestedEventAlliance(GameObject* controlZone)
{
ASSERT(m_Workshop);
BattlefieldControlZoneHandler::HandleContestedEventAlliance(controlZone);
m_Workshop->GiveControlTo(TEAM_NEUTRAL);
}
void WintergraspCapturePoint::HandleProgressEventHorde(GameObject* /*controlZone*/)
{
ASSERT(m_Workshop);
m_Workshop->GiveControlTo(TEAM_HORDE);
}
void WintergraspCapturePoint::HandleProgressEventAlliance(GameObject* /*controlZone*/)
{
ASSERT(m_Workshop);
m_Workshop->GiveControlTo(TEAM_ALLIANCE);
}
BfGraveyardWG::BfGraveyardWG(BattlefieldWG* battlefield) : BfGraveyard(battlefield)

12
src/server/scripts/Battlefield/BattlefieldWG.h
View File

@@ -179,15 +179,15 @@ enum WintergraspNpcs
* WintergraspCapturePoint *
* ######################### */
class WintergraspCapturePoint : public BfCapturePoint
class WintergraspCapturePoint : public BattlefieldControlZoneHandler
{
public:
WintergraspCapturePoint(BattlefieldWG* battlefield, TeamId teamInControl);
WintergraspCapturePoint(BattlefieldWG* battlefield, WintergraspWorkshop* workshop);
void LinkToWorkshop(WintergraspWorkshop* workshop) { m_Workshop = workshop; }
void ChangeTeam(TeamId oldteam) override;
TeamId GetTeam() const { return m_team; }
void HandleContestedEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleContestedEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
protected:
WintergraspWorkshop* m_Workshop;

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

@@ -18,38 +18,52 @@
#include "OutdoorPvPHP.h"
#include "GameObject.h"
#include "Map.h"
#include "ObjectAccessor.h"
#include "Player.h"
#include "ScriptMgr.h"
#include "WorldStatePackets.h"
uint32 const OutdoorPvPHPBuffZonesNum = 6;
uint32 const OutdoorPvPHPBuffZones[OutdoorPvPHPBuffZonesNum] = { 3483, 3563, 3562, 3713, 3714, 3836 }; // HP, citadel, ramparts, blood furnace, shattered halls, mag's lair
uint32 const HP_CREDITMARKER[HP_TOWER_NUM] = { 19032, 19028, 19029 };
//uint32 const HP_CapturePointEvent_Enter[HP_TOWER_NUM] = { 11404, 11396, 11388 };
//uint32 const HP_CapturePointEvent_Leave[HP_TOWER_NUM] = { 11403, 11395, 11387 };
uint32 const HP_MAP_N[HP_TOWER_NUM] = { 2485, 2482, 2472 };
uint32 const HP_MAP_A[HP_TOWER_NUM] = { 2483, 2480, 2471 };
uint32 const HP_MAP_H[HP_TOWER_NUM] = { 2484, 2481, 2470 };
uint32 const HP_TowerArtKit_A[HP_TOWER_NUM] = { 65, 62, 67 };
uint32 const HP_TowerArtKit_H[HP_TOWER_NUM] = { 64, 61, 68 };
uint32 const HP_TowerArtKit_N[HP_TOWER_NUM] = { 66, 63, 69 };
uint32 const HP_LANG_CAPTURE_A[HP_TOWER_NUM] = { TEXT_BROKEN_HILL_TAKEN_ALLIANCE, TEXT_OVERLOOK_TAKEN_ALLIANCE, TEXT_STADIUM_TAKEN_ALLIANCE };
uint32 const HP_LANG_CAPTURE_H[HP_TOWER_NUM] = { TEXT_BROKEN_HILL_TAKEN_HORDE, TEXT_OVERLOOK_TAKEN_HORDE, TEXT_STADIUM_TAKEN_HORDE };
OPvPCapturePointHP::OPvPCapturePointHP(OutdoorPvP* pvp, OutdoorPvPHPTowerType type, GameObject* go, ObjectGuid::LowType const& flagSpawnId)
: OPvPCapturePoint(pvp), m_TowerType(type), m_flagSpawnId(flagSpawnId)
{
m_capturePointSpawnId = go->GetSpawnId();
m_capturePoint = go;
SetCapturePointData(go->GetEntry());
}
OutdoorPvPHP::OutdoorPvPHP(Map* map) : OutdoorPvP(map), m_towerFlagSpawnIds()
OutdoorPvPHP::OutdoorPvPHP(Map* map) : OutdoorPvP(map)
{
m_TypeId = OUTDOOR_PVP_HP;
m_AllianceTowersControlled = 0;
m_HordeTowersControlled = 0;
ControlZoneHandlers[HP_GO_ENTRY_TOWER_S] = std::make_unique<HPControlZoneHandler>(this);
GetControlZoneTowerSouthHandler().SetFlagArtKitAlliance(65);
GetControlZoneTowerSouthHandler().SetFlagArtKitHorde(64);
GetControlZoneTowerSouthHandler().SetFlagArtKitNeutral(66);
GetControlZoneTowerSouthHandler().SetTextCaptureAlliance(TEXT_BROKEN_HILL_TAKEN_ALLIANCE);
GetControlZoneTowerSouthHandler().SetTextCaptureHorde(TEXT_BROKEN_HILL_TAKEN_HORDE);
GetControlZoneTowerSouthHandler().SetWorldstateAlliance(HP_UI_TOWER_S_A);
GetControlZoneTowerSouthHandler().SetWorldstateHorde(HP_UI_TOWER_S_H);
GetControlZoneTowerSouthHandler().SetWorldstateNeutral(HP_UI_TOWER_S_N);
GetControlZoneTowerSouthHandler().SetKillCredit(HP_KILL_CREDIT_TOWER_S);
ControlZoneHandlers[HP_GO_ENTRY_TOWER_N] = std::make_unique<HPControlZoneHandler>(this);
GetControlZoneTowerNorthHandler().SetFlagArtKitAlliance(62);
GetControlZoneTowerNorthHandler().SetFlagArtKitHorde(61);
GetControlZoneTowerNorthHandler().SetFlagArtKitNeutral(63);
GetControlZoneTowerNorthHandler().SetTextCaptureAlliance(TEXT_OVERLOOK_TAKEN_ALLIANCE);
GetControlZoneTowerNorthHandler().SetTextCaptureHorde(TEXT_OVERLOOK_TAKEN_HORDE);
GetControlZoneTowerNorthHandler().SetWorldstateAlliance(HP_UI_TOWER_N_A);
GetControlZoneTowerNorthHandler().SetWorldstateHorde(HP_UI_TOWER_N_H);
GetControlZoneTowerNorthHandler().SetWorldstateNeutral(HP_UI_TOWER_N_N);
GetControlZoneTowerNorthHandler().SetKillCredit(HP_KILL_CREDIT_TOWER_N);
ControlZoneHandlers[HP_GO_ENTRY_TOWER_W] = std::make_unique<HPControlZoneHandler>(this);
GetControlZoneTowerWestHandler().SetFlagArtKitAlliance(67);
GetControlZoneTowerWestHandler().SetFlagArtKitHorde(68);
GetControlZoneTowerWestHandler().SetFlagArtKitNeutral(69);
GetControlZoneTowerWestHandler().SetTextCaptureAlliance(TEXT_STADIUM_TAKEN_ALLIANCE);
GetControlZoneTowerWestHandler().SetTextCaptureHorde(TEXT_STADIUM_TAKEN_HORDE);
GetControlZoneTowerWestHandler().SetWorldstateAlliance(HP_UI_TOWER_W_A);
GetControlZoneTowerWestHandler().SetWorldstateHorde(HP_UI_TOWER_W_H);
GetControlZoneTowerWestHandler().SetWorldstateNeutral(HP_UI_TOWER_W_N);
GetControlZoneTowerWestHandler().SetKillCredit(HP_KILL_CREDIT_TOWER_W);
}
bool OutdoorPvPHP::SetupOutdoorPvP()
@@ -66,25 +80,19 @@ bool OutdoorPvPHP::SetupOutdoorPvP()
void OutdoorPvPHP::OnGameObjectCreate(GameObject* go)
{
if (go->GetGoType() == GAMEOBJECT_TYPE_CONTROL_ZONE)
_controlZoneGUIDs.insert(go->GetGUID());
switch (go->GetEntry())
{
case 182175:
AddCapturePoint(new OPvPCapturePointHP(this, HP_TOWER_BROKEN_HILL, go, m_towerFlagSpawnIds[HP_TOWER_BROKEN_HILL]));
break;
case 182174:
AddCapturePoint(new OPvPCapturePointHP(this, HP_TOWER_OVERLOOK, go, m_towerFlagSpawnIds[HP_TOWER_OVERLOOK]));
break;
case 182173:
AddCapturePoint(new OPvPCapturePointHP(this, HP_TOWER_STADIUM, go, m_towerFlagSpawnIds[HP_TOWER_STADIUM]));
break;
case 183514:
m_towerFlagSpawnIds[HP_TOWER_BROKEN_HILL] = go->GetSpawnId();
GetControlZoneTowerSouthHandler().SetFlagGuid(go->GetGUID());
break;
case 182525:
m_towerFlagSpawnIds[HP_TOWER_OVERLOOK] = go->GetSpawnId();
GetControlZoneTowerNorthHandler().SetFlagGuid(go->GetGUID());
break;
case 183515:
m_towerFlagSpawnIds[HP_TOWER_STADIUM] = go->GetSpawnId();
GetControlZoneTowerWestHandler().SetFlagGuid(go->GetGUID());
break;
default:
break;
@@ -123,24 +131,20 @@ void OutdoorPvPHP::HandlePlayerLeaveZone(Player* player, uint32 zone)
OutdoorPvP::HandlePlayerLeaveZone(player, zone);
}
bool OutdoorPvPHP::Update(uint32 diff)
void OutdoorPvPHP::Update(uint32 diff)
{
bool changed = OutdoorPvP::Update(diff);
if (changed)
OutdoorPvP::Update(diff);
if (m_AllianceTowersControlled == 3)
TeamApplyBuff(TEAM_ALLIANCE, AllianceBuff, HordeBuff);
else if (m_HordeTowersControlled == 3)
TeamApplyBuff(TEAM_HORDE, HordeBuff, AllianceBuff);
else
{
if (m_AllianceTowersControlled == 3)
TeamApplyBuff(TEAM_ALLIANCE, AllianceBuff, HordeBuff);
else if (m_HordeTowersControlled == 3)
TeamApplyBuff(TEAM_HORDE, HordeBuff, AllianceBuff);
else
{
TeamCastSpell(TEAM_ALLIANCE, -AllianceBuff);
TeamCastSpell(TEAM_HORDE, -HordeBuff);
}
SetWorldState(HP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SetWorldState(HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
TeamCastSpell(TEAM_ALLIANCE, -AllianceBuff);
TeamCastSpell(TEAM_HORDE, -HordeBuff);
}
return changed;
SetWorldState(HP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SetWorldState(HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
}
void OutdoorPvPHP::SendRemoveWorldStates(Player* player)
@@ -154,128 +158,46 @@ void OutdoorPvPHP::SendRemoveWorldStates(Player* player)
initWorldStates.Worldstates.emplace_back(HP_UI_TOWER_COUNT_H, 0);
initWorldStates.Worldstates.emplace_back(HP_UI_TOWER_COUNT_A, 0);
for (size_t i = 0; i < HP_TOWER_NUM; ++i)
for (auto& itr : ControlZoneHandlers)
{
initWorldStates.Worldstates.emplace_back(HP_MAP_N[i], 0);
initWorldStates.Worldstates.emplace_back(HP_MAP_A[i], 0);
initWorldStates.Worldstates.emplace_back(HP_MAP_H[i], 0);
HPControlZoneHandler* handler = static_cast<HPControlZoneHandler*>(itr.second.get());
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateNeutral(), 0);
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateHorde(), 0);
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateAlliance(), 0);
}
player->SendDirectMessage(initWorldStates.Write());
}
void OPvPCapturePointHP::ChangeState()
{
uint32 field = 0;
switch (m_OldState)
{
case OBJECTIVESTATE_NEUTRAL:
field = HP_MAP_N[m_TowerType];
break;
case OBJECTIVESTATE_ALLIANCE:
field = HP_MAP_A[m_TowerType];
if (uint32 alliance_towers = ((OutdoorPvPHP*)m_PvP)->GetAllianceTowersControlled())
((OutdoorPvPHP*)m_PvP)->SetAllianceTowersControlled(--alliance_towers);
break;
case OBJECTIVESTATE_HORDE:
field = HP_MAP_H[m_TowerType];
if (uint32 horde_towers = ((OutdoorPvPHP*)m_PvP)->GetHordeTowersControlled())
((OutdoorPvPHP*)m_PvP)->SetHordeTowersControlled(--horde_towers);
break;
case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
field = HP_MAP_N[m_TowerType];
break;
case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
field = HP_MAP_N[m_TowerType];
break;
case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
field = HP_MAP_A[m_TowerType];
break;
case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
field = HP_MAP_H[m_TowerType];
break;
}
// send world state update
if (field)
{
m_PvP->SetWorldState(field, 0);
field = 0;
}
uint32 artkit = 21;
uint32 artkit2 = HP_TowerArtKit_N[m_TowerType];
switch (m_State)
{
case OBJECTIVESTATE_NEUTRAL:
field = HP_MAP_N[m_TowerType];
break;
case OBJECTIVESTATE_ALLIANCE:
{
field = HP_MAP_A[m_TowerType];
artkit = 2;
artkit2 = HP_TowerArtKit_A[m_TowerType];
uint32 alliance_towers = ((OutdoorPvPHP*)m_PvP)->GetAllianceTowersControlled();
if (alliance_towers < 3)
((OutdoorPvPHP*)m_PvP)->SetAllianceTowersControlled(++alliance_towers);
m_PvP->SendDefenseMessage(OutdoorPvPHPBuffZones[0], HP_LANG_CAPTURE_A[m_TowerType]);
break;
}
case OBJECTIVESTATE_HORDE:
{
field = HP_MAP_H[m_TowerType];
artkit = 1;
artkit2 = HP_TowerArtKit_H[m_TowerType];
uint32 horde_towers = ((OutdoorPvPHP*)m_PvP)->GetHordeTowersControlled();
if (horde_towers < 3)
((OutdoorPvPHP*)m_PvP)->SetHordeTowersControlled(++horde_towers);
m_PvP->SendDefenseMessage(OutdoorPvPHPBuffZones[0], HP_LANG_CAPTURE_H[m_TowerType]);
break;
}
case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
field = HP_MAP_N[m_TowerType];
break;
case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
field = HP_MAP_N[m_TowerType];
break;
case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
field = HP_MAP_A[m_TowerType];
artkit = 2;
artkit2 = HP_TowerArtKit_A[m_TowerType];
break;
case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
field = HP_MAP_H[m_TowerType];
artkit = 1;
artkit2 = HP_TowerArtKit_H[m_TowerType];
break;
}
Map* map = m_PvP->GetMap();
auto bounds = map->GetGameObjectBySpawnIdStore().equal_range(m_capturePointSpawnId);
for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit);
bounds = map->GetGameObjectBySpawnIdStore().equal_range(m_flagSpawnId);
for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit2);
// send world state update
if (field)
m_PvP->SetWorldState(field, 1);
// complete quest objective
if (m_State == OBJECTIVESTATE_ALLIANCE || m_State == OBJECTIVESTATE_HORDE)
SendObjectiveComplete(HP_CREDITMARKER[m_TowerType], ObjectGuid::Empty);
}
void OutdoorPvPHP::HandleKillImpl(Player* player, Unit* killed)
{
if (killed->GetTypeId() != TYPEID_PLAYER)
return;
if (player->GetTeam() == ALLIANCE && killed->ToPlayer()->GetTeam() != ALLIANCE)
player->CastSpell(player, AlliancePlayerKillReward, true);
else if (player->GetTeam() == HORDE && killed->ToPlayer()->GetTeam() != HORDE)
player->CastSpell(player, HordePlayerKillReward, true);
// need to check if player is inside an capture zone
bool isInsideCaptureZone = false;
for (ObjectGuid const& guid : _controlZoneGUIDs)
{
if (GameObject* gameObject = GetMap()->GetGameObject(guid))
{
if (GuidUnorderedSet const* insidePlayerGuids = gameObject->GetInsidePlayers())
{
if (insidePlayerGuids->contains(player->GetGUID()))
{
isInsideCaptureZone = true;
break;
}
}
}
}
if (isInsideCaptureZone)
{
if (player->GetTeam() == ALLIANCE && killed->ToPlayer()->GetTeam() != ALLIANCE)
player->CastSpell(player, AlliancePlayerKillReward, true);
else if (player->GetTeam() == HORDE && killed->ToPlayer()->GetTeam() != HORDE)
player->CastSpell(player, HordePlayerKillReward, true);
}
}
uint32 OutdoorPvPHP::GetAllianceTowersControlled() const
@@ -298,6 +220,88 @@ void OutdoorPvPHP::SetHordeTowersControlled(uint32 count)
m_HordeTowersControlled = count;
}
HPControlZoneHandler::HPControlZoneHandler(OutdoorPvPHP* pvp) : OutdoorPvPControlZoneHandler(pvp),
_flagGuid(ObjectGuid::Empty), _textCaptureAlliance(0), _textCaptureHorde(0),
_flagArtKitNeutral(0), _flagArtKitHorde(0), _flagArtKitAlliance(0),
_worldstateNeutral(0), _worldstateHorde(0), _worldstateAlliance(0),
_killCredit(0)
{
}
void HPControlZoneHandler::HandleProgressEventHorde(GameObject* controlZone)
{
ControlZoneHandler::HandleProgressEventHorde(controlZone);
controlZone->SetGoArtKit(1);
controlZone->SendCustomAnim(0);
if (GameObject* flag = controlZone->GetMap()->GetGameObject(_flagGuid))
flag->SetGoArtKit(_flagArtKitHorde);
controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 1, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 0, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 0, false);
GetOutdoorPvPHP()->SendDefenseMessage(OutdoorPvPHPBuffZones[0], _textCaptureHorde);
if (GuidUnorderedSet const* guidSet = controlZone->GetInsidePlayers())
for (ObjectGuid const& guid : *guidSet)
if (Player* player = ObjectAccessor::GetPlayer(*controlZone, guid))
if (player->GetTeam() == TEAM_HORDE)
player->KilledMonsterCredit(_killCredit);
}
void HPControlZoneHandler::HandleProgressEventAlliance(GameObject* controlZone)
{
ControlZoneHandler::HandleProgressEventAlliance(controlZone);
controlZone->SetGoArtKit(2);
controlZone->SendCustomAnim(1);
if (GameObject* flag = controlZone->GetMap()->GetGameObject(_flagGuid))
flag->SetGoArtKit(_flagArtKitAlliance);
controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 0, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 1, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 0, false);
GetOutdoorPvPHP()->SendDefenseMessage(OutdoorPvPHPBuffZones[0], _textCaptureAlliance);
if (GuidUnorderedSet const* guidSet = controlZone->GetInsidePlayers())
for (ObjectGuid const& guid : *guidSet)
if (Player* player = ObjectAccessor::GetPlayer(*controlZone, guid))
if (player->GetTeam() == TEAM_ALLIANCE)
player->KilledMonsterCredit(_killCredit);
}
void HPControlZoneHandler::HandleNeutralEventHorde(GameObject* controlZone)
{
ControlZoneHandler::HandleNeutralEventHorde(controlZone);
GetOutdoorPvPHP()->SetHordeTowersControlled(GetOutdoorPvPHP()->GetHordeTowersControlled() - 1);
}
void HPControlZoneHandler::HandleNeutralEventAlliance(GameObject* controlZone)
{
ControlZoneHandler::HandleNeutralEventAlliance(controlZone);
GetOutdoorPvPHP()->SetAllianceTowersControlled(GetOutdoorPvPHP()->GetAllianceTowersControlled() - 1);
}
void HPControlZoneHandler::HandleNeutralEvent(GameObject* controlZone)
{
ControlZoneHandler::HandleNeutralEvent(controlZone);
controlZone->SetGoArtKit(21);
controlZone->SendCustomAnim(2);
if (GameObject* flag = controlZone->GetMap()->GetGameObject(_flagGuid))
flag->SetGoArtKit(_flagArtKitNeutral);
controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 0, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 0, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 1, false);
}
OutdoorPvPHP* HPControlZoneHandler::GetOutdoorPvPHP() const
{
return static_cast<OutdoorPvPHP*>(OutdoorPvPControlZoneHandler::GetOutdoorPvP());
}
class OutdoorPvP_hellfire_peninsula : public OutdoorPvPScript
{
public:

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

@@ -53,19 +53,94 @@ enum OutdoorPvPHPWorldStates
HP_UI_TOWER_DISPLAY_H = 0x9b9,
HP_UI_TOWER_COUNT_H = 0x9ae,
HP_UI_TOWER_COUNT_A = 0x9ac
HP_UI_TOWER_COUNT_A = 0x9ac,
HP_UI_TOWER_S_A = 2483,
HP_UI_TOWER_S_H = 2484,
HP_UI_TOWER_S_N = 2485,
HP_UI_TOWER_N_A = 2480,
HP_UI_TOWER_N_H = 2481,
HP_UI_TOWER_N_N = 2482,
HP_UI_TOWER_W_A = 2471,
HP_UI_TOWER_W_H = 2470,
HP_UI_TOWER_W_N = 2472
};
class OPvPCapturePointHP : public OPvPCapturePoint
enum OutdoorPvPHPEvents
{
public:
OPvPCapturePointHP(OutdoorPvP* pvp, OutdoorPvPHPTowerType type, GameObject* go, ObjectGuid::LowType const& flagSpawnId);
HP_EVENT_TOWER_W_PROGRESS_HORDE = 11383,
HP_EVENT_TOWER_W_PROGRESS_ALLIANCE = 11387,
HP_EVENT_TOWER_W_NEUTRAL_HORDE = 11386,
HP_EVENT_TOWER_W_NEUTRAL_ALLIANCE = 11385,
void ChangeState() override;
HP_EVENT_TOWER_N_PROGRESS_HORDE = 11396,
HP_EVENT_TOWER_N_PROGRESS_ALLIANCE = 11395,
HP_EVENT_TOWER_N_NEUTRAL_HORDE = 11394,
HP_EVENT_TOWER_N_NEUTRAL_ALLIANCE = 11393,
private:
OutdoorPvPHPTowerType m_TowerType;
ObjectGuid::LowType const& m_flagSpawnId;
HP_EVENT_TOWER_S_PROGRESS_HORDE = 11404,
HP_EVENT_TOWER_S_PROGRESS_ALLIANCE = 11403,
HP_EVENT_TOWER_S_NEUTRAL_HORDE = 11402,
HP_EVENT_TOWER_S_NEUTRAL_ALLIANCE = 11401
};
enum OutdoorPvPHPGameObjectEntries
{
HP_GO_ENTRY_TOWER_W = 182173,
HP_GO_ENTRY_TOWER_N = 182174,
HP_GO_ENTRY_TOWER_S = 182175
};
enum OutdoorPvPHPCredit
{
HP_KILL_CREDIT_TOWER_S = 19032,
HP_KILL_CREDIT_TOWER_N = 19028,
HP_KILL_CREDIT_TOWER_W = 19029
};
class OutdoorPvPHP;
class HPControlZoneHandler : public OutdoorPvPControlZoneHandler
{
public:
explicit HPControlZoneHandler(OutdoorPvPHP* pvp);
void SetFlagGuid(ObjectGuid const& guid) { _flagGuid = guid; }
void SetTextCaptureHorde(uint32 text) { _textCaptureHorde = text; }
void SetTextCaptureAlliance(uint32 text) { _textCaptureAlliance = text; }
void SetFlagArtKitNeutral(uint32 artKit) { _flagArtKitNeutral = artKit; }
void SetFlagArtKitHorde(uint32 artKit) { _flagArtKitHorde = artKit; }
void SetFlagArtKitAlliance(uint32 artKit) { _flagArtKitAlliance = artKit; }
void SetWorldstateNeutral(uint32 id) { _worldstateNeutral = id; }
void SetWorldstateHorde(uint32 id) { _worldstateHorde = id; }
void SetWorldstateAlliance(uint32 id) { _worldstateAlliance = id; }
void SetKillCredit(uint32 credit) { _killCredit = credit; }
void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEvent([[maybe_unused]] GameObject* controlZone) override;
uint32 GetWorldStateNeutral() { return _worldstateNeutral; }
uint32 GetWorldStateHorde() { return _worldstateHorde; }
uint32 GetWorldStateAlliance() { return _worldstateAlliance; }
OutdoorPvPHP* GetOutdoorPvPHP() const;
private:
ObjectGuid _flagGuid;
uint32 _textCaptureAlliance;
uint32 _textCaptureHorde;
uint32 _flagArtKitNeutral;
uint32 _flagArtKitHorde;
uint32 _flagArtKitAlliance;
uint32 _worldstateNeutral;
uint32 _worldstateHorde;
uint32 _worldstateAlliance;
uint32 _killCredit;
};
class OutdoorPvPHP : public OutdoorPvP
@@ -80,7 +155,7 @@ class OutdoorPvPHP : public OutdoorPvP
void HandlePlayerEnterZone(Player* player, uint32 zone) override;
void HandlePlayerLeaveZone(Player* player, uint32 zone) override;
bool Update(uint32 diff) override;
void Update(uint32 diff) override;
void SendRemoveWorldStates(Player* player) override;
void HandleKillImpl(Player* player, Unit* killed) override;
@@ -92,7 +167,12 @@ class OutdoorPvPHP : public OutdoorPvP
private:
uint32 m_AllianceTowersControlled; // how many towers are controlled
uint32 m_HordeTowersControlled;
std::array<ObjectGuid::LowType, HP_TOWER_NUM> m_towerFlagSpawnIds;
GuidUnorderedSet _controlZoneGUIDs;
HPControlZoneHandler& GetControlZoneTowerNorthHandler() { return *static_cast<HPControlZoneHandler*>(ControlZoneHandlers[HP_GO_ENTRY_TOWER_N].get()); }
HPControlZoneHandler& GetControlZoneTowerSouthHandler() { return *static_cast<HPControlZoneHandler*>(ControlZoneHandlers[HP_GO_ENTRY_TOWER_S].get()); }
HPControlZoneHandler& GetControlZoneTowerWestHandler() { return *static_cast<HPControlZoneHandler*>(ControlZoneHandlers[HP_GO_ENTRY_TOWER_W].get()); }
};
#endif

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

@@ -40,6 +40,7 @@ OutdoorPvPNA::OutdoorPvPNA(Map* map) : OutdoorPvP(map)
{
m_TypeId = OUTDOOR_PVP_NA;
m_obj = nullptr;
ControlZoneHandlers[182210] = std::make_unique<NAControlZoneHandler>(this);
}
void OutdoorPvPNA::OnGameObjectCreate(GameObject* go)
@@ -47,8 +48,7 @@ void OutdoorPvPNA::OnGameObjectCreate(GameObject* go)
switch (go->GetEntry())
{
case 182210:
m_obj->m_capturePointSpawnId = go->GetSpawnId();
AddCapturePoint(m_obj);
m_obj->SetControlZoneGUID(go->GetGUID());
break;
}
@@ -67,6 +67,91 @@ void OutdoorPvPNA::HandleKillImpl(Player* player, Unit* killed)
}
}
NAControlZoneHandler::NAControlZoneHandler(OutdoorPvPNA* pvp) : OutdoorPvPControlZoneHandler(pvp)
{
}
void NAControlZoneHandler::HandleCaptureEventHorde(GameObject* controlZone)
{
OutdoorPvPControlZoneHandler::HandleCaptureEventHorde(controlZone);
if (GetOutdoorPvPNA()->GetCapturePoint()->GetControllingFaction() != HORDE)
{
GetOutdoorPvPNA()->SendMapWorldStates(0, 0, 0, 1, 0);
GetOutdoorPvPNA()->GetCapturePoint()->FactionTakeOver(HORDE);
}
}
void NAControlZoneHandler::HandleCaptureEventAlliance(GameObject* controlZone)
{
OutdoorPvPControlZoneHandler::HandleCaptureEventAlliance(controlZone);
if (GetOutdoorPvPNA()->GetCapturePoint()->GetControllingFaction() != ALLIANCE)
{
GetOutdoorPvPNA()->SendMapWorldStates(0, 0, 0, 0, 1);
GetOutdoorPvPNA()->GetCapturePoint()->FactionTakeOver(ALLIANCE);
}
}
void NAControlZoneHandler::HandleContestedEventHorde(GameObject* controlZone)
{
OutdoorPvPControlZoneHandler::HandleContestedEventHorde(controlZone);
GetOutdoorPvPNA()->SendMapWorldStates(0, 1, 0, 0, 0);
}
void NAControlZoneHandler::HandleContestedEventAlliance(GameObject* controlZone)
{
OutdoorPvPControlZoneHandler::HandleContestedEventAlliance(controlZone);
GetOutdoorPvPNA()->SendMapWorldStates(0, 0, 1, 0, 0);
}
void NAControlZoneHandler::HandleProgressEventHorde(GameObject* controlZone)
{
OutdoorPvPControlZoneHandler::HandleProgressEventHorde(controlZone);
controlZone->SetGoArtKit(1);
GetOutdoorPvPNA()->SendMapWorldStates(0, 1, 0, 0, 0);
}
void NAControlZoneHandler::HandleProgressEventAlliance(GameObject* controlZone)
{
OutdoorPvPControlZoneHandler::HandleProgressEventAlliance(controlZone);
controlZone->SetGoArtKit(2);
GetOutdoorPvPNA()->SendMapWorldStates(0, 0, 1, 0, 0);
}
void NAControlZoneHandler::HandleNeutralEventHorde(GameObject* controlZone)
{
OutdoorPvPControlZoneHandler::HandleNeutralEventHorde(controlZone);
}
void NAControlZoneHandler::HandleNeutralEventAlliance(GameObject* controlZone)
{
OutdoorPvPControlZoneHandler::HandleNeutralEventAlliance(controlZone);
}
void NAControlZoneHandler::HandleNeutralEvent(GameObject* controlZone)
{
OutdoorPvPControlZoneHandler::HandleNeutralEvent(controlZone);
}
OutdoorPvPNA* NAControlZoneHandler::GetOutdoorPvPNA() const
{
return static_cast<OutdoorPvPNA*>(OutdoorPvPControlZoneHandler::GetOutdoorPvP());
}
void OutdoorPvPNA::SendMapWorldStates(int32 neutral, int32 progressHorde, int32 progressAlliance, int32 capturedHorde, int32 captureAlliance)
{
SetWorldState(NA_MAP_HALAA_NEUTRAL, neutral);
SetWorldState(NA_MAP_HALAA_NEU_H, progressHorde);
SetWorldState(NA_MAP_HALAA_NEU_A, progressAlliance);
SetWorldState(NA_MAP_HALAA_HORDE, capturedHorde);
SetWorldState(NA_MAP_HALAA_ALLIANCE, captureAlliance);
}
uint32 OPvPCapturePointNA::GetAliveGuardsCount() const
{
Position searchCenter = { -1572.57f, 7945.3f, -22.475f, 2.05949f };
@@ -89,7 +174,9 @@ void OPvPCapturePointNA::FactionTakeOver(uint32 team)
m_ControllingFaction = team;
m_GuardsAlive = NA_GUARDS_MAX;
m_capturable = false;
UpdateHalaaWorldState();
if (GameObject* gameObject = m_PvP->GetMap()->GetGameObject(_controlZoneGUID))
gameObject->ActivateObject(GameObjectActions::MakeInert, 0);
if (team == ALLIANCE)
{
m_WyvernStateSouth = WYVERN_NEU_HORDE;
@@ -121,9 +208,9 @@ void OPvPCapturePointNA::FactionTakeOver(uint32 team)
}
OPvPCapturePointNA::OPvPCapturePointNA(OutdoorPvP* pvp) : OPvPCapturePoint(pvp), m_capturable(true), m_GuardsAlive(0), m_ControllingFaction(0), m_WyvernStateNorth(0), m_WyvernStateSouth(0), m_WyvernStateEast(0),
m_WyvernStateWest(0), m_HalaaState(HALAA_N), m_RespawnTimer(NA_RESPAWN_TIME), m_GuardCheckTimer(NA_GUARD_CHECK_TIME)
m_WyvernStateWest(0), m_RespawnTimer(NA_RESPAWN_TIME), m_GuardCheckTimer(NA_GUARD_CHECK_TIME)
{
SetCapturePointData(182210);
}
bool OutdoorPvPNA::SetupOutdoorPvP()
@@ -187,9 +274,9 @@ void OutdoorPvPNA::SendRemoveWorldStates(Player* player)
player->SendDirectMessage(initWorldStates.Write());
}
bool OutdoorPvPNA::Update(uint32 diff)
void OutdoorPvPNA::Update(uint32 diff)
{
return m_obj->Update(diff);
m_obj->Update(diff);
}
bool OPvPCapturePointNA::HandleCustomSpell(Player* player, uint32 spellId, GameObject* /*go*/)
@@ -342,15 +429,8 @@ int32 OPvPCapturePointNA::HandleOpenGo(Player* player, GameObject* go)
return 0;
}
bool OPvPCapturePointNA::Update(uint32 diff)
void OPvPCapturePointNA::Update(uint32 diff)
{
// let the controlling faction advance in phase
bool capturable = false;
if (m_ControllingFaction == ALLIANCE && m_activePlayers[0].size() > m_activePlayers[1].size())
capturable = true;
else if (m_ControllingFaction == HORDE && m_activePlayers[0].size() < m_activePlayers[1].size())
capturable = true;
if (m_GuardCheckTimer < diff)
{
m_GuardCheckTimer = NA_GUARD_CHECK_TIME;
@@ -359,7 +439,11 @@ bool OPvPCapturePointNA::Update(uint32 diff)
{
m_capturable = true;
m_RespawnTimer = NA_RESPAWN_TIME;
if (GameObject* gameObject = m_PvP->GetMap()->GetGameObject(_controlZoneGUID))
gameObject->ActivateObject(GameObjectActions::MakeActive, 0);
}
else if (GameObject* gameObject = m_PvP->GetMap()->GetGameObject(_controlZoneGUID))
gameObject->ActivateObject(GameObjectActions::MakeInert, 0);
// update the guard count for the players in zone
m_PvP->SetWorldState(NA_UI_GUARDS_LEFT, m_GuardsAlive);
}
@@ -382,60 +466,8 @@ bool OPvPCapturePointNA::Update(uint32 diff)
m_RespawnTimer -= diff;
}
if (m_capturable || capturable)
return OPvPCapturePoint::Update(diff);
return false;
}
void OPvPCapturePointNA::ChangeState()
{
uint32 artkit = 21;
switch (m_State)
{
case OBJECTIVESTATE_NEUTRAL:
m_HalaaState = HALAA_N;
break;
case OBJECTIVESTATE_ALLIANCE:
m_HalaaState = HALAA_A;
FactionTakeOver(ALLIANCE);
artkit = 2;
break;
case OBJECTIVESTATE_HORDE:
m_HalaaState = HALAA_H;
FactionTakeOver(HORDE);
artkit = 1;
break;
case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
m_HalaaState = HALAA_N_A;
break;
case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
m_HalaaState = HALAA_N_H;
break;
case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
m_HalaaState = HALAA_N_A;
artkit = 2;
break;
case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
m_HalaaState = HALAA_N_H;
artkit = 1;
break;
}
auto bounds = m_PvP->GetMap()->GetGameObjectBySpawnIdStore().equal_range(m_capturePointSpawnId);
for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit);
UpdateHalaaWorldState();
}
void OPvPCapturePointNA::UpdateHalaaWorldState()
{
m_PvP->SetWorldState(NA_MAP_HALAA_NEUTRAL, uint32((m_HalaaState & HALAA_N) != 0));
m_PvP->SetWorldState(NA_MAP_HALAA_NEU_A, uint32((m_HalaaState & HALAA_N_A) != 0));
m_PvP->SetWorldState(NA_MAP_HALAA_NEU_H, uint32((m_HalaaState & HALAA_N_H) != 0));
m_PvP->SetWorldState(NA_MAP_HALAA_HORDE, uint32((m_HalaaState & HALAA_H) != 0));
m_PvP->SetWorldState(NA_MAP_HALAA_ALLIANCE, uint32((m_HalaaState & HALAA_A) != 0));
if (m_capturable)
OPvPCapturePoint::Update(diff);
}
void OPvPCapturePointNA::UpdateWyvernRoostWorldState(uint32 roost)

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

@@ -113,16 +113,47 @@ enum HalaaStates
HALAA_H = 16
};
enum HalaaEvents
{
HALAA_EVENT_CAPTURE_HORDE = 11504,
HALAA_EVENT_CAPTURE_ALLIANCE = 11503,
HALAA_EVENT_CONTESTED_HORDE = 11559,
HALAA_EVENT_CONTESTED_ALLIANCE = 11558,
HALAA_EVENT_PROGRESS_HORDE = 11821,
HALAA_EVENT_PROGRESS_ALLIANCE = 11822
};
class Unit;
class Creature;
class WorldObject;
class OutdoorPvPNA;
class NAControlZoneHandler : public OutdoorPvPControlZoneHandler
{
public:
explicit NAControlZoneHandler(OutdoorPvPNA* pvp);
void HandleCaptureEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleCaptureEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleContestedEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleContestedEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEvent([[maybe_unused]] GameObject* controlZone) override;
OutdoorPvPNA* GetOutdoorPvPNA() const;
};
class OPvPCapturePointNA : public OPvPCapturePoint
{
public:
OPvPCapturePointNA(OutdoorPvP* pvp);
bool Update(uint32 diff) override;
void ChangeState() override;
void Update(uint32 diff) override;
void ChangeState() override { } // todo remove?
bool HandleCustomSpell(Player* player, uint32 spellId, GameObject* go) override;
int32 HandleOpenGo(Player* player, GameObject* go) override;
@@ -130,8 +161,8 @@ class OPvPCapturePointNA : public OPvPCapturePoint
uint32 GetControllingFaction() const;
void FactionTakeOver(uint32 team); // called when a faction takes control
void UpdateWyvernRoostWorldState(uint32 roost);
void UpdateHalaaWorldState();
void SetControlZoneGUID(ObjectGuid guid) { _controlZoneGUID = guid; }
private:
bool m_capturable;
uint32 m_GuardsAlive;
@@ -140,9 +171,9 @@ class OPvPCapturePointNA : public OPvPCapturePoint
uint32 m_WyvernStateSouth;
uint32 m_WyvernStateEast;
uint32 m_WyvernStateWest;
uint32 m_HalaaState;
uint32 m_RespawnTimer;
uint32 m_GuardCheckTimer;
ObjectGuid _controlZoneGUID;
};
class OutdoorPvPNA : public OutdoorPvP
@@ -155,10 +186,11 @@ class OutdoorPvPNA : public OutdoorPvP
bool SetupOutdoorPvP() override;
void HandlePlayerEnterZone(Player* player, uint32 zone) override;
void HandlePlayerLeaveZone(Player* player, uint32 zone) override;
bool Update(uint32 diff) override;
void Update(uint32 diff) override;
void SendRemoveWorldStates(Player* player) override;
void HandleKillImpl(Player* player, Unit* killed) override;
void SendMapWorldStates(int32 neutral, int32 progressHorde, int32 progressAlliance, int32 capturedHorde, int32 captureAlliance);
OPvPCapturePointNA* GetCapturePoint() const { return m_obj; }
private:
OPvPCapturePointNA* m_obj;
};

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

@@ -66,9 +66,8 @@ bool OutdoorPvPSI::SetupOutdoorPvP()
return true;
}
bool OutdoorPvPSI::Update(uint32 /*diff*/)
void OutdoorPvPSI::Update(uint32 /*diff*/)
{
return false;
}
void OutdoorPvPSI::HandlePlayerEnterZone(Player* player, uint32 zone)

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

@@ -43,7 +43,7 @@ class OutdoorPvPSI : public OutdoorPvP
bool SetupOutdoorPvP() override;
void HandlePlayerEnterZone(Player* player, uint32 zone) override;
void HandlePlayerLeaveZone(Player* player, uint32 zone) override;
bool Update(uint32 diff) override;
void Update(uint32 diff) override;
void SendRemoveWorldStates(Player* player) override;
bool HandleAreaTrigger(Player* player, uint32 trigger, bool entered) override;
bool HandleDropFlag(Player* player, uint32 spellId) override;

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

@@ -45,42 +45,6 @@ int32 const TF_CAPTURE_BUFF = 33377;
uint32 const TF_ALLY_QUEST = 11505;
uint32 const TF_HORDE_QUEST = 11506;
struct tf_tower_world_state
{
int32 n;
int32 h;
int32 a;
};
tf_tower_world_state const TFTowerWorldStates[TF_TOWER_NUM] =
{
{ 2681, 2682, 2683 },
{ 2686, 2685, 2684 },
{ 2690, 2689, 2688 },
{ 2696, 2695, 2694 },
{ 2693, 2692, 2691 }
};
/*
uint32 const TFTowerPlayerEnterEvents[TF_TOWER_NUM] =
{
12226,
12497,
12486,
12499,
12501
};
uint32 const TFTowerPlayerLeaveEvents[TF_TOWER_NUM] =
{
12225,
12496,
12487,
12498,
12500
};
*/
OutdoorPvPTF::OutdoorPvPTF(Map* map) : OutdoorPvP(map)
{
m_TypeId = OUTDOOR_PVP_TF;
@@ -92,13 +56,12 @@ OutdoorPvPTF::OutdoorPvPTF(Map* map) : OutdoorPvP(map)
hours_left = 6;
second_digit = 0;
first_digit = 0;
}
OPvPCapturePointTF::OPvPCapturePointTF(OutdoorPvP* pvp, OutdoorPvPTF_TowerType type, GameObject* go) : OPvPCapturePoint(pvp), m_TowerType(type), m_TowerState(TF_TOWERSTATE_N)
{
m_capturePointSpawnId = go->GetSpawnId();
m_capturePoint = go;
SetCapturePointData(go->GetEntry());
ControlZoneHandlers[TF_ENTRY_TOWER_NW] = std::make_unique<TFControlZoneHandler>(this, 2682, 2683, 2681);
ControlZoneHandlers[TF_ENTRY_TOWER_N] = std::make_unique<TFControlZoneHandler>(this, 2685, 2684, 2686);
ControlZoneHandlers[TF_ENTRY_TOWER_NE] = std::make_unique<TFControlZoneHandler>(this, 2689, 2688, 2690);
ControlZoneHandlers[TF_ENTRY_TOWER_SE] = std::make_unique<TFControlZoneHandler>(this, 2695, 2694, 2696);
ControlZoneHandlers[TF_ENTRY_TOWER_S] = std::make_unique<TFControlZoneHandler>(this, 2692, 2691, 2693);
}
void OutdoorPvPTF::SendRemoveWorldStates(Player* player)
@@ -119,55 +82,21 @@ void OutdoorPvPTF::SendRemoveWorldStates(Player* player)
initWorldStates.Worldstates.emplace_back(TF_UI_LOCKED_DISPLAY_HORDE, 0);
initWorldStates.Worldstates.emplace_back(TF_UI_LOCKED_DISPLAY_ALLIANCE, 0);
for (tf_tower_world_state const& towerWorldStates : TFTowerWorldStates)
for (auto& itr : ControlZoneHandlers)
{
initWorldStates.Worldstates.emplace_back(towerWorldStates.n, 0);
initWorldStates.Worldstates.emplace_back(towerWorldStates.h, 0);
initWorldStates.Worldstates.emplace_back(towerWorldStates.a, 0);
TFControlZoneHandler* handler = static_cast<TFControlZoneHandler*>(itr.second.get());
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateNeutral(), 0);
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateHorde(), 0);
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateAlliance(), 0);
}
player->SendDirectMessage(initWorldStates.Write());
}
void OPvPCapturePointTF::UpdateTowerState()
void OutdoorPvPTF::Update(uint32 diff)
{
m_PvP->SetWorldState(TFTowerWorldStates[m_TowerType].n, int32((m_TowerState & TF_TOWERSTATE_N) != 0));
m_PvP->SetWorldState(TFTowerWorldStates[m_TowerType].h, int32((m_TowerState & TF_TOWERSTATE_H) != 0));
m_PvP->SetWorldState(TFTowerWorldStates[m_TowerType].a, int32((m_TowerState & TF_TOWERSTATE_A) != 0));
}
OutdoorPvP::Update(diff);
bool OutdoorPvPTF::Update(uint32 diff)
{
bool changed = OutdoorPvP::Update(diff);
if (changed)
{
if (m_AllianceTowersControlled == TF_TOWER_NUM)
{
TeamApplyBuff(TEAM_ALLIANCE, TF_CAPTURE_BUFF);
m_IsLocked = true;
SetWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, 0);
SetWorldState(TF_UI_LOCKED_DISPLAY_HORDE, 0);
SetWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, 1);
SetWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, 0);
}
else if (m_HordeTowersControlled == TF_TOWER_NUM)
{
TeamApplyBuff(TEAM_HORDE, TF_CAPTURE_BUFF);
m_IsLocked = true;
SetWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, 0);
SetWorldState(TF_UI_LOCKED_DISPLAY_HORDE, 1);
SetWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, 0);
SetWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, 0);
}
else
{
TeamCastSpell(TEAM_ALLIANCE, -TF_CAPTURE_BUFF);
TeamCastSpell(TEAM_HORDE, -TF_CAPTURE_BUFF);
}
SetWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SetWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
}
if (m_IsLocked)
{
// lock timer is down, release lock
@@ -176,6 +105,16 @@ bool OutdoorPvPTF::Update(uint32 diff)
m_LockTimer = TF_LOCK_TIME;
m_LockTimerUpdate = 0;
m_IsLocked = false;
for (ObjectGuid const& controlZoneGUID : _controlZoneGUIDs)
{
if (GameObject* gameObject = GetMap()->GetGameObject(controlZoneGUID))
{
gameObject->HandleCustomTypeCommand(GameObjectType::SetControlZoneValue());
gameObject->ActivateObject(GameObjectActions::MakeActive, 0);
}
}
SetWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, 1);
SetWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, 0);
SetWorldState(TF_UI_LOCKED_DISPLAY_HORDE, 0);
@@ -200,7 +139,6 @@ bool OutdoorPvPTF::Update(uint32 diff)
m_LockTimer -= diff;
}
}
return changed;
}
void OutdoorPvPTF::HandlePlayerEnterZone(Player* player, uint32 zone)
@@ -250,6 +188,40 @@ bool OutdoorPvPTF::IsLocked() const
return m_IsLocked;
}
void OutdoorPvPTF::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* invoker)
{
OutdoorPvP::ProcessEvent(obj, eventId, invoker);
SetWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SetWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
// now check if everything is capped
if (m_HordeTowersControlled == TF_TOWER_NUM)
HandleCapture(TEAM_HORDE);
else if (m_AllianceTowersControlled == TF_TOWER_NUM)
HandleCapture(TEAM_ALLIANCE);
else
{
TeamCastSpell(TEAM_ALLIANCE, -TF_CAPTURE_BUFF);
TeamCastSpell(TEAM_HORDE, -TF_CAPTURE_BUFF);
}
}
void OutdoorPvPTF::HandleCapture(TeamId team)
{
m_IsLocked = true;
for (ObjectGuid const& controlZoneGUID : _controlZoneGUIDs)
if (GameObject* gameObject = GetMap()->GetGameObject(controlZoneGUID))
gameObject->ActivateObject(GameObjectActions::MakeInert, 0);
TeamApplyBuff(team, TF_CAPTURE_BUFF);
SetWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, 0);
SetWorldState(TF_UI_LOCKED_DISPLAY_HORDE, team == TEAM_HORDE ? 1 : 0);
SetWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, team == TEAM_ALLIANCE ? 1 : 0);
SetWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, 0);
}
bool OutdoorPvPTF::SetupOutdoorPvP()
{
m_AllianceTowersControlled = 0;
@@ -273,20 +245,12 @@ void OutdoorPvPTF::OnGameObjectCreate(GameObject* go)
{
switch (go->GetEntry())
{
case 183104:
AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_NW, go));
break;
case 183411:
AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_N, go));
break;
case 183412:
AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_NE, go));
break;
case 183413:
AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_SE, go));
break;
case 183414:
AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_S, go));
case TF_ENTRY_TOWER_NW:
case TF_ENTRY_TOWER_N:
case TF_ENTRY_TOWER_NE:
case TF_ENTRY_TOWER_SE:
case TF_ENTRY_TOWER_S:
_controlZoneGUIDs.insert(go->GetGUID());
break;
default:
break;
@@ -295,81 +259,73 @@ void OutdoorPvPTF::OnGameObjectCreate(GameObject* go)
OutdoorPvP::OnGameObjectCreate(go);
}
bool OPvPCapturePointTF::Update(uint32 diff)
TFControlZoneHandler::TFControlZoneHandler(OutdoorPvPTF* pvp, uint32 worldstateHorde, uint32 worldstateAlliance, uint32 worldstateNeutral) : OutdoorPvPControlZoneHandler(pvp),
_worldstateHorde(worldstateHorde), _worldstateAlliance(worldstateAlliance), _worldstateNeutral(worldstateNeutral)
{
// can update even in locked state if gathers the controlling faction
bool canupdate = ((((OutdoorPvPTF*)m_PvP)->GetAllianceTowersControlled() > 0) && m_activePlayers[0].size() > m_activePlayers[1].size()) ||
((((OutdoorPvPTF*)m_PvP)->GetHordeTowersControlled() > 0) && m_activePlayers[0].size() < m_activePlayers[1].size());
// if gathers the other faction, then only update if the pvp is unlocked
canupdate = canupdate || !((OutdoorPvPTF*)m_PvP)->IsLocked();
return canupdate && OPvPCapturePoint::Update(diff);
}
void OPvPCapturePointTF::ChangeState()
void TFControlZoneHandler::HandleProgressEventHorde(GameObject* controlZone)
{
// if changing from controlling alliance to horde
if (m_OldState == OBJECTIVESTATE_ALLIANCE)
{
if (uint32 alliance_towers = ((OutdoorPvPTF*)m_PvP)->GetAllianceTowersControlled())
((OutdoorPvPTF*)m_PvP)->SetAllianceTowersControlled(--alliance_towers);
m_PvP->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_LOSE_ALLIANCE);
}
// if changing from controlling horde to alliance
else if (m_OldState == OBJECTIVESTATE_HORDE)
{
if (uint32 horde_towers = ((OutdoorPvPTF*)m_PvP)->GetHordeTowersControlled())
((OutdoorPvPTF*)m_PvP)->SetHordeTowersControlled(--horde_towers);
m_PvP->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_LOSE_HORDE);
}
controlZone->SetGoArtKit(1);
GetOutdoorPvPTF()->SetHordeTowersControlled(GetOutdoorPvPTF()->GetHordeTowersControlled() + 1);
GetOutdoorPvP()->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_TAKEN_HORDE);
controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 1, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 0, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 0, false);
uint32 artkit = 21;
switch (m_State)
{
case OBJECTIVESTATE_ALLIANCE:
{
m_TowerState = TF_TOWERSTATE_A;
artkit = 2;
uint32 alliance_towers = ((OutdoorPvPTF*)m_PvP)->GetAllianceTowersControlled();
if (alliance_towers < TF_TOWER_NUM)
((OutdoorPvPTF*)m_PvP)->SetAllianceTowersControlled(++alliance_towers);
m_PvP->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_TAKEN_ALLIANCE);
for (GuidSet::iterator itr = m_activePlayers[0].begin(); itr != m_activePlayers[0].end(); ++itr)
if (Player* player = ObjectAccessor::FindPlayer(*itr))
player->AreaExploredOrEventHappens(TF_ALLY_QUEST);
break;
}
case OBJECTIVESTATE_HORDE:
{
m_TowerState = TF_TOWERSTATE_H;
artkit = 1;
uint32 horde_towers = ((OutdoorPvPTF*)m_PvP)->GetHordeTowersControlled();
if (horde_towers < TF_TOWER_NUM)
((OutdoorPvPTF*)m_PvP)->SetHordeTowersControlled(++horde_towers);
m_PvP->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_TAKEN_HORDE);
for (GuidSet::iterator itr = m_activePlayers[1].begin(); itr != m_activePlayers[1].end(); ++itr)
if (Player* player = ObjectAccessor::FindPlayer(*itr))
if (GuidUnorderedSet const* guidSet = controlZone->GetInsidePlayers())
for (ObjectGuid const& guid : *guidSet)
if (Player* player = ObjectAccessor::GetPlayer(*controlZone, guid))
if (player->GetTeam() == TEAM_HORDE)
player->AreaExploredOrEventHappens(TF_HORDE_QUEST);
break;
}
case OBJECTIVESTATE_NEUTRAL:
case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
m_TowerState = TF_TOWERSTATE_N;
break;
}
auto bounds = m_PvP->GetMap()->GetGameObjectBySpawnIdStore().equal_range(m_capturePointSpawnId);
for (auto itr = bounds.first; itr != bounds.second; ++itr)
itr->second->SetGoArtKit(artkit);
OutdoorPvPControlZoneHandler::HandleProgressEventHorde(controlZone);
}
UpdateTowerState();
void TFControlZoneHandler::HandleProgressEventAlliance(GameObject* controlZone)
{
controlZone->SetGoArtKit(2);
GetOutdoorPvPTF()->SetAllianceTowersControlled(GetOutdoorPvPTF()->GetAllianceTowersControlled() + 1);
GetOutdoorPvP()->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_TAKEN_ALLIANCE);
controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 0, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 1, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 0, false);
if (GuidUnorderedSet const* guidSet = controlZone->GetInsidePlayers())
for (ObjectGuid const& guid : *guidSet)
if (Player* player = ObjectAccessor::GetPlayer(*controlZone, guid))
if (player->GetTeam() == TEAM_ALLIANCE)
player->AreaExploredOrEventHappens(TF_ALLY_QUEST);
OutdoorPvPControlZoneHandler::HandleProgressEventAlliance(controlZone);
}
void TFControlZoneHandler::HandleNeutralEventHorde(GameObject* controlZone)
{
GetOutdoorPvPTF()->SetHordeTowersControlled(GetOutdoorPvPTF()->GetHordeTowersControlled() - 1);
GetOutdoorPvP()->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_LOSE_HORDE);
OutdoorPvPControlZoneHandler::HandleNeutralEventHorde(controlZone);
}
void TFControlZoneHandler::HandleNeutralEventAlliance(GameObject* controlZone)
{
GetOutdoorPvPTF()->SetAllianceTowersControlled(GetOutdoorPvPTF()->GetAllianceTowersControlled() - 1);
GetOutdoorPvP()->SendDefenseMessage(OutdoorPvPTFBuffZones[0], TEXT_SPIRIT_TOWER_LOSE_ALLIANCE);
OutdoorPvPControlZoneHandler::HandleNeutralEventAlliance(controlZone);
}
void TFControlZoneHandler::HandleNeutralEvent(GameObject* controlZone)
{
controlZone->SetGoArtKit(21);
controlZone->GetMap()->SetWorldStateValue(_worldstateHorde, 0, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateAlliance, 0, false);
controlZone->GetMap()->SetWorldStateValue(_worldstateNeutral, 1, false);
OutdoorPvPControlZoneHandler::HandleNeutralEvent(controlZone);
}
OutdoorPvPTF* TFControlZoneHandler::GetOutdoorPvPTF() const
{
return static_cast<OutdoorPvPTF*>(OutdoorPvPControlZoneHandler::GetOutdoorPvP());
}
class OutdoorPvP_terokkar_forest : public OutdoorPvPScript

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

@@ -54,26 +54,66 @@ enum TFWorldStates
TF_UI_LOCKED_DISPLAY_ALLIANCE = 2767
};
enum TFTowerStates
enum TFGameEvents
{
TF_TOWERSTATE_N = 1,
TF_TOWERSTATE_H = 2,
TF_TOWERSTATE_A = 4
TF_EVENT_TOWER_NW_ALLIANCE_PROGRESS = 12225,
TF_EVENT_TOWER_NW_HORDE_PROGRESS = 12226,
TF_EVENT_TOWER_NW_NEUTRAL_ALLIANCE = 12227,
TF_EVENT_TOWER_NW_NEUTRAL_HORDE = 12228,
TF_EVENT_TOWER_NE_HORDE_PROGRESS = 12486,
TF_EVENT_TOWER_NE_ALLIANCE_PROGRESS = 12487,
TF_EVENT_TOWER_NE_NEUTRAL_HORDE = 12488,
TF_EVENT_TOWER_NE_NEUTRAL_ALLIANCE = 12489,
TF_EVENT_TOWER_N_NEUTRAL_HORDE = 12490,
TF_EVENT_TOWER_N_NEUTRAL_ALLIANCE = 12491,
TF_EVENT_TOWER_N_ALLIANCE_PROGRESS = 12496,
TF_EVENT_TOWER_N_HORDE_PROGRESS = 12497,
TF_EVENT_TOWER_SE_NEUTRAL_HORDE = 12492,
TF_EVENT_TOWER_SE_NEUTRAL_ALLIANCE = 12493,
TF_EVENT_TOWER_SE_ALLIANCE_PROGRESS = 12498,
TF_EVENT_TOWER_SE_HORDE_PROGRESS = 12499,
TF_EVENT_TOWER_S_NEUTRAL_HORDE = 12494,
TF_EVENT_TOWER_S_NEUTRAL_ALLIANCE = 12495,
TF_EVENT_TOWER_S_ALLIANCE_PROGRESS = 12500,
TF_EVENT_TOWER_S_HORDE_PROGRESS = 12501
};
class OPvPCapturePointTF : public OPvPCapturePoint
enum TFGameObjects
{
public:
OPvPCapturePointTF(OutdoorPvP* pvp, OutdoorPvPTF_TowerType type, GameObject* go);
TF_ENTRY_TOWER_NW = 183104,
TF_ENTRY_TOWER_N = 183411,
TF_ENTRY_TOWER_NE = 183412,
TF_ENTRY_TOWER_SE = 183413,
TF_ENTRY_TOWER_S = 183414
};
bool Update(uint32 diff) override;
void ChangeState() override;
class OutdoorPvPTF;
void UpdateTowerState();
class TFControlZoneHandler : public OutdoorPvPControlZoneHandler
{
public:
explicit TFControlZoneHandler(OutdoorPvPTF* pvp, uint32 worldstateHorde, uint32 worldstateAlliance, uint32 worldstateNeutral);
protected:
OutdoorPvPTF_TowerType m_TowerType;
uint32 m_TowerState;
void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEvent([[maybe_unused]] GameObject* controlZone) override;
uint32 GetWorldStateHorde() { return _worldstateHorde; }
uint32 GetWorldStateAlliance() { return _worldstateAlliance; }
uint32 GetWorldStateNeutral() { return _worldstateNeutral; }
OutdoorPvPTF* GetOutdoorPvPTF() const;
private:
uint32 _worldstateHorde;
uint32 _worldstateAlliance;
uint32 _worldstateNeutral;
};
class OutdoorPvPTF : public OutdoorPvP
@@ -85,7 +125,7 @@ class OutdoorPvPTF : public OutdoorPvP
void OnGameObjectCreate(GameObject* go) override;
void HandlePlayerEnterZone(Player* player, uint32 zone) override;
void HandlePlayerLeaveZone(Player* player, uint32 zone) override;
bool Update(uint32 diff) override;
void Update(uint32 diff) override;
void SendRemoveWorldStates(Player* player) override;
uint32 GetAllianceTowersControlled() const;
@@ -94,6 +134,8 @@ class OutdoorPvPTF : public OutdoorPvP
void SetHordeTowersControlled(uint32 count);
bool IsLocked() const;
void ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* invoker) override;
void HandleCapture(TeamId team);
private:
bool m_IsLocked;
uint32 m_LockTimer;
@@ -101,6 +143,8 @@ class OutdoorPvPTF : public OutdoorPvP
uint32 m_AllianceTowersControlled;
uint32 m_HordeTowersControlled;
uint32 hours_left, second_digit, first_digit;
GuidUnorderedSet _controlZoneGUIDs;
std::unordered_map<uint32 /*control zone entry*/, std::unique_ptr<TFControlZoneHandler>> _controlZoneHandlers;
};
#endif

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

@@ -36,113 +36,80 @@ uint32 const OutdoorPvPZMBuffZones[OutdoorPvPZMBuffZonesNum] = { 3521, 3607, 371
// linked when the central tower is controlled
uint32 const ZM_GRAVEYARD_ZONE = 3521;
struct zm_beacon
ZMControlZoneHandler::ZMControlZoneHandler(OutdoorPvPZM* pvp, uint32 textBeaconTakenHorde, uint32 textBeaconTakenAlliance, uint32 worldstateNeutralUi, uint32 worldstateNeutralMap, uint32 worldstateHordeUi, uint32 worldstateHordeMap, uint32 worldstateAllianceUi, uint32 worldstateAllianceMap)
: OutdoorPvPControlZoneHandler(pvp), _textBeaconTakenHorde(textBeaconTakenHorde), _textBeaconTakenAlliance(textBeaconTakenAlliance), _worldstateNeutralUi(worldstateNeutralUi), _worldstateNeutralMap(worldstateNeutralMap),
_worldstateHordeUi(worldstateHordeUi), _worldstateHordeMap(worldstateHordeMap), _worldstateAllianceUi(worldstateAllianceUi), _worldstateAllianceMap(worldstateAllianceMap)
{
int32 ui_tower_n;
int32 ui_tower_h;
int32 ui_tower_a;
int32 map_tower_n;
int32 map_tower_h;
int32 map_tower_a;
uint32 event_enter;
uint32 event_leave;
};
zm_beacon const ZMBeaconInfo[ZM_NUM_BEACONS] =
{
{ ZM_UI_TOWER_EAST_N, ZM_UI_TOWER_EAST_H, ZM_UI_TOWER_EAST_A, ZM_MAP_TOWER_EAST_N, ZM_MAP_TOWER_EAST_H, ZM_MAP_TOWER_EAST_A, 11807, 11806 },
{ ZM_UI_TOWER_WEST_N, ZM_UI_TOWER_WEST_H, ZM_UI_TOWER_WEST_A, ZM_MAP_TOWER_WEST_N, ZM_MAP_TOWER_WEST_H, ZM_MAP_TOWER_WEST_A, 11805, 11804 }
};
uint32 const ZMBeaconCaptureA[ZM_NUM_BEACONS] =
{
TEXT_EAST_BEACON_TAKEN_ALLIANCE,
TEXT_WEST_BEACON_TAKEN_ALLIANCE
};
uint32 const ZMBeaconCaptureH[ZM_NUM_BEACONS] =
{
TEXT_EAST_BEACON_TAKEN_HORDE,
TEXT_WEST_BEACON_TAKEN_HORDE
};
OPvPCapturePointZM_Beacon::OPvPCapturePointZM_Beacon(OutdoorPvP* pvp, ZM_BeaconType type, GameObject* go) : OPvPCapturePoint(pvp), m_TowerType(type), m_TowerState(ZM_TOWERSTATE_N)
{
m_capturePointSpawnId = go->GetSpawnId();
m_capturePoint = go;
SetCapturePointData(go->GetEntry());
}
void OPvPCapturePointZM_Beacon::UpdateTowerState()
void ZMControlZoneHandler::HandleProgressEventHorde(GameObject* controlZone)
{
m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].ui_tower_n, int32((m_TowerState & ZM_TOWERSTATE_N) != 0));
m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].map_tower_n, int32((m_TowerState & ZM_TOWERSTATE_N) != 0));
m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].ui_tower_a, int32((m_TowerState & ZM_TOWERSTATE_A) != 0));
m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].map_tower_a, int32((m_TowerState & ZM_TOWERSTATE_A) != 0));
m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].ui_tower_h, int32((m_TowerState & ZM_TOWERSTATE_H) != 0));
m_PvP->SetWorldState(ZMBeaconInfo[m_TowerType].map_tower_h, int32((m_TowerState & ZM_TOWERSTATE_H) != 0));
OutdoorPvPControlZoneHandler::HandleProgressEventHorde(controlZone);
GetOutdoorPvpZM()->SetHordeTowersControlled(GetOutdoorPvpZM()->GetHordeTowersControlled() + 1);
GetOutdoorPvpZM()->SendDefenseMessage(ZM_GRAVEYARD_ZONE, _textBeaconTakenHorde);
GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceMap, 0);
GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceUi, 0);
GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralMap, 0);
GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralUi, 0);
GetOutdoorPvpZM()->SetWorldState(_worldstateHordeMap, 1);
GetOutdoorPvpZM()->SetWorldState(_worldstateHordeUi, 1);
}
void OPvPCapturePointZM_Beacon::ChangeState()
void ZMControlZoneHandler::HandleProgressEventAlliance(GameObject* controlZone)
{
// if changing from controlling alliance to horde
if (m_OldState == OBJECTIVESTATE_ALLIANCE)
{
if (uint32 alliance_towers = ((OutdoorPvPZM*)m_PvP)->GetAllianceTowersControlled())
((OutdoorPvPZM*)m_PvP)->SetAllianceTowersControlled(--alliance_towers);
}
// if changing from controlling horde to alliance
else if (m_OldState == OBJECTIVESTATE_HORDE)
{
if (uint32 horde_towers = ((OutdoorPvPZM*)m_PvP)->GetHordeTowersControlled())
((OutdoorPvPZM*)m_PvP)->SetHordeTowersControlled(--horde_towers);
}
OutdoorPvPControlZoneHandler::HandleProgressEventAlliance(controlZone);
GetOutdoorPvpZM()->SetAllianceTowersControlled(GetOutdoorPvpZM()->GetAllianceTowersControlled() + 1);
GetOutdoorPvpZM()->SendDefenseMessage(ZM_GRAVEYARD_ZONE, _textBeaconTakenAlliance);
switch (m_State)
{
case OBJECTIVESTATE_ALLIANCE:
{
m_TowerState = ZM_TOWERSTATE_A;
uint32 alliance_towers = ((OutdoorPvPZM*)m_PvP)->GetAllianceTowersControlled();
if (alliance_towers < ZM_NUM_BEACONS)
((OutdoorPvPZM*)m_PvP)->SetAllianceTowersControlled(++alliance_towers);
m_PvP->SendDefenseMessage(ZM_GRAVEYARD_ZONE, ZMBeaconCaptureA[m_TowerType]);
break;
}
case OBJECTIVESTATE_HORDE:
{
m_TowerState = ZM_TOWERSTATE_H;
uint32 horde_towers = ((OutdoorPvPZM*)m_PvP)->GetHordeTowersControlled();
if (horde_towers < ZM_NUM_BEACONS)
((OutdoorPvPZM*)m_PvP)->SetHordeTowersControlled(++horde_towers);
m_PvP->SendDefenseMessage(ZM_GRAVEYARD_ZONE, ZMBeaconCaptureH[m_TowerType]);
break;
}
case OBJECTIVESTATE_NEUTRAL:
case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
m_TowerState = ZM_TOWERSTATE_N;
break;
}
UpdateTowerState();
GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceMap, 1);
GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceUi, 1);
GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralMap, 0);
GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralUi, 0);
GetOutdoorPvpZM()->SetWorldState(_worldstateHordeMap, 0);
GetOutdoorPvpZM()->SetWorldState(_worldstateHordeUi, 0);
}
bool OutdoorPvPZM::Update(uint32 diff)
void ZMControlZoneHandler::HandleNeutralEventHorde(GameObject* controlZone)
{
bool changed = OutdoorPvP::Update(diff);
if (changed)
{
if (m_AllianceTowersControlled == ZM_NUM_BEACONS)
m_Graveyard->SetBeaconState(ALLIANCE);
else if (m_HordeTowersControlled == ZM_NUM_BEACONS)
m_Graveyard->SetBeaconState(HORDE);
else
m_Graveyard->SetBeaconState(0);
}
return changed;
GetOutdoorPvpZM()->SetHordeTowersControlled(GetOutdoorPvpZM()->GetHordeTowersControlled() - 1);
OutdoorPvPControlZoneHandler::HandleNeutralEventHorde(controlZone);
}
void ZMControlZoneHandler::HandleNeutralEventAlliance(GameObject* controlZone)
{
GetOutdoorPvpZM()->SetAllianceTowersControlled(GetOutdoorPvpZM()->GetAllianceTowersControlled() - 1);
OutdoorPvPControlZoneHandler::HandleNeutralEventAlliance(controlZone);
}
void ZMControlZoneHandler::HandleNeutralEvent(GameObject* controlZone)
{
OutdoorPvPControlZoneHandler::HandleNeutralEvent(controlZone);
GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceMap, 0);
GetOutdoorPvpZM()->SetWorldState(_worldstateAllianceUi, 0);
GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralMap, 1);
GetOutdoorPvpZM()->SetWorldState(_worldstateNeutralUi, 1);
GetOutdoorPvpZM()->SetWorldState(_worldstateHordeMap, 0);
GetOutdoorPvpZM()->SetWorldState(_worldstateHordeUi, 0);
}
OutdoorPvPZM* ZMControlZoneHandler::GetOutdoorPvpZM()
{
return static_cast<OutdoorPvPZM*>(OutdoorPvPControlZoneHandler::GetOutdoorPvP());
}
void OutdoorPvPZM::Update(uint32 diff)
{
OutdoorPvP::Update(diff);
if (m_AllianceTowersControlled == ZM_NUM_BEACONS)
m_Graveyard->SetBeaconState(ALLIANCE);
else if (m_HordeTowersControlled == ZM_NUM_BEACONS)
m_Graveyard->SetBeaconState(HORDE);
else
m_Graveyard->SetBeaconState(0);
}
void OutdoorPvPZM::HandlePlayerEnterZone(Player* player, uint32 zone)
@@ -176,6 +143,30 @@ OutdoorPvPZM::OutdoorPvPZM(Map* map) : OutdoorPvP(map)
m_Graveyard = nullptr;
m_AllianceTowersControlled = 0;
m_HordeTowersControlled = 0;
ControlZoneHandlers[ZM_GO_ENTRY_BEACON_EAST] = std::make_unique<ZMControlZoneHandler>(
this,
TEXT_EAST_BEACON_TAKEN_HORDE,
TEXT_EAST_BEACON_TAKEN_ALLIANCE,
ZM_UI_TOWER_EAST_N,
ZM_MAP_TOWER_EAST_N,
ZM_UI_TOWER_EAST_H,
ZM_MAP_TOWER_EAST_H,
ZM_UI_TOWER_EAST_A,
ZM_MAP_TOWER_EAST_A
);
ControlZoneHandlers[ZM_GO_ENTRY_BEACON_WEST] = std::make_unique<ZMControlZoneHandler>(
this,
TEXT_WEST_BEACON_TAKEN_HORDE,
TEXT_WEST_BEACON_TAKEN_ALLIANCE,
ZM_UI_TOWER_WEST_N,
ZM_MAP_TOWER_WEST_N,
ZM_UI_TOWER_WEST_H,
ZM_MAP_TOWER_WEST_H,
ZM_UI_TOWER_WEST_A,
ZM_MAP_TOWER_WEST_A
);
}
bool OutdoorPvPZM::SetupOutdoorPvP()
@@ -188,28 +179,10 @@ bool OutdoorPvPZM::SetupOutdoorPvP()
RegisterZone(OutdoorPvPZMBuffZones[i]);
m_Graveyard = new OPvPCapturePointZM_Graveyard(this);
AddCapturePoint(m_Graveyard); // though the update function isn't used, the handleusego is!
return true;
}
void OutdoorPvPZM::OnGameObjectCreate(GameObject* go)
{
switch (go->GetEntry())
{
case 182523:
AddCapturePoint(new OPvPCapturePointZM_Beacon(this, ZM_BEACON_EAST, go));
break;
case 182522:
AddCapturePoint(new OPvPCapturePointZM_Beacon(this, ZM_BEACON_WEST, go));
break;
default:
break;
}
OutdoorPvP::OnGameObjectCreate(go);
}
void OutdoorPvPZM::HandleKillImpl(Player* player, Unit* killed)
{
if (killed->GetTypeId() != TYPEID_PLAYER)
@@ -221,11 +194,9 @@ void OutdoorPvPZM::HandleKillImpl(Player* player, Unit* killed)
player->CastSpell(player, ZM_HordePlayerKillReward, true);
}
bool OPvPCapturePointZM_Graveyard::Update(uint32 /*diff*/)
void OPvPCapturePointZM_Graveyard::Update(uint32 /*diff*/)
{
bool retval = m_State != m_OldState;
m_State = m_OldState;
return retval;
}
int32 OPvPCapturePointZM_Graveyard::HandleOpenGo(Player* player, GameObject* go)
@@ -368,21 +339,20 @@ void OutdoorPvPZM::SendRemoveWorldStates(Player* player)
initWorldStates.MapID = player->GetMapId();
initWorldStates.AreaID = player->GetZoneId();
initWorldStates.SubareaID = player->GetAreaId();
initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_EAST_N, 0);
initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_EAST_H, 0);
initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_EAST_A, 0);
initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_WEST_N, 0);
initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_WEST_H, 0);
initWorldStates.Worldstates.emplace_back(ZM_UI_TOWER_WEST_A, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_EAST_N, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_EAST_H, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_EAST_A, 0);
for (auto& itr : ControlZoneHandlers)
{
ZMControlZoneHandler* handler = static_cast<ZMControlZoneHandler*>(itr.second.get());
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateNeutralUI(), 0);
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateNeutralMap(), 0);
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateHordeUI(), 0);
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateHordeMap(), 0);
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateAllianceUI(), 0);
initWorldStates.Worldstates.emplace_back(handler->GetWorldStateAllianceMap(), 0);
}
initWorldStates.Worldstates.emplace_back(ZM_MAP_GRAVEYARD_H, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_GRAVEYARD_A, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_GRAVEYARD_N, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_WEST_N, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_WEST_H, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_TOWER_WEST_A, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_HORDE_FLAG_READY, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_HORDE_FLAG_NOT_READY, 0);
initWorldStates.Worldstates.emplace_back(ZM_MAP_ALLIANCE_FLAG_NOT_READY, 0);

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

@@ -93,18 +93,17 @@ enum ZM_TowerStateMask
ZM_TOWERSTATE_H = 4
};
class OPvPCapturePointZM_Beacon : public OPvPCapturePoint
enum ZM_WorldEvents
{
public:
OPvPCapturePointZM_Beacon(OutdoorPvP* pvp, ZM_BeaconType type, GameObject* go);
ZM_EVENT_BEACON_EAST_PROGRESS_HORDE = 11807,
ZM_EVENT_BEACON_EAST_PROGRESS_ALLIANCE = 11806,
ZM_EVENT_BEACON_EAST_NEUTRAL_HORDE = 11814,
ZM_EVENT_BEACON_EAST_NEUTRAL_ALLIANCE = 11815,
void ChangeState() override;
void UpdateTowerState();
protected:
ZM_BeaconType m_TowerType;
uint32 m_TowerState;
ZM_EVENT_BEACON_WEST_PROGRESS_HORDE = 11805,
ZM_EVENT_BEACON_WEST_PROGRESS_ALLIANCE = 11804,
ZM_EVENT_BEACON_WEST_NEUTRAL_HORDE = 11808,
ZM_EVENT_BEACON_WEST_NEUTRAL_ALLIANCE = 11809
};
enum ZM_GraveyardState
@@ -114,12 +113,51 @@ enum ZM_GraveyardState
ZM_GRAVEYARD_H = 4
};
enum ZM_GameObjectEntries
{
ZM_GO_ENTRY_BEACON_WEST = 182522,
ZM_GO_ENTRY_BEACON_EAST = 182523
};
class OutdoorPvPZM;
class ZMControlZoneHandler : public OutdoorPvPControlZoneHandler
{
public:
ZMControlZoneHandler(OutdoorPvPZM* pvp, uint32 textBeaconTakenHorde, uint32 textBeaconTakenAlliance, uint32 worldstateNeutralUi, uint32 worldstateNeutralMap, uint32 worldstateHordeUi, uint32 worldstateHordeMap, uint32 worldstateAllianceUi, uint32 worldstateAllianceMap);
void HandleProgressEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleProgressEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEventHorde([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEventAlliance([[maybe_unused]] GameObject* controlZone) override;
void HandleNeutralEvent([[maybe_unused]] GameObject* controlZone) override;
uint32 GetWorldStateNeutralUI() { return _worldstateNeutralUi; }
uint32 GetWorldStateNeutralMap() { return _worldstateNeutralMap; }
uint32 GetWorldStateHordeUI() { return _worldstateHordeUi; }
uint32 GetWorldStateHordeMap() { return _worldstateHordeMap; }
uint32 GetWorldStateAllianceUI() { return _worldstateAllianceUi; }
uint32 GetWorldStateAllianceMap() { return _worldstateAllianceMap; }
OutdoorPvPZM* GetOutdoorPvpZM();
private:
uint32 _textBeaconTakenHorde;
uint32 _textBeaconTakenAlliance;
uint32 _worldstateNeutralUi;
uint32 _worldstateNeutralMap;
uint32 _worldstateHordeUi;
uint32 _worldstateHordeMap;
uint32 _worldstateAllianceUi;
uint32 _worldstateAllianceMap;
};
class OPvPCapturePointZM_Graveyard : public OPvPCapturePoint
{
public:
OPvPCapturePointZM_Graveyard(OutdoorPvP* pvp);
bool Update(uint32 diff) override;
void Update(uint32 diff) override;
void ChangeState() override { }
int32 HandleOpenGo(Player* player, GameObject* go) override;
bool HandleDropFlag(Player* player, uint32 spellId) override;
@@ -144,10 +182,9 @@ class OutdoorPvPZM : public OutdoorPvP
OutdoorPvPZM(Map* map);
bool SetupOutdoorPvP() override;
void OnGameObjectCreate(GameObject* go) override;
void HandlePlayerEnterZone(Player* player, uint32 zone) override;
void HandlePlayerLeaveZone(Player* player, uint32 zone) override;
bool Update(uint32 diff) override;
void Update(uint32 diff) override;
void SendRemoveWorldStates(Player* player) override;
void HandleKillImpl(Player* player, Unit* killed) override;