OutdoorPvP.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "OutdoorPvP.h"
#include "CellImpl.h"
#include "ChatPackets.h"
#include "DatabaseEnv.h"
#include "GridNotifiersImpl.h"
#include "Group.h"
#include "Log.h"
#include "Map.h"
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "OutdoorPvPMgr.h"
#include "WorldPacket.h"
#include "WorldSession.h"
#include "WorldStateMgr.h"
 
class DefenseMessageBuilder
{
 public:
 DefenseMessageBuilder(uint32 zoneId, uint32 id)
 : _zoneId(zoneId), _id(id) { }
 
 Trinity::PacketSenderOwning<WorldPackets::Chat::DefenseMessage>* operator()(LocaleConstant locale) const
 {
 std::string text = sOutdoorPvPMgr->GetDefenseMessage(_zoneId, _id, locale);
 
 Trinity::PacketSenderOwning<WorldPackets::Chat::DefenseMessage>* defenseMessage = new Trinity::PacketSenderOwning<WorldPackets::Chat::DefenseMessage>();
 defenseMessage->Data.ZoneID = _zoneId;
 defenseMessage->Data.MessageText = text;
 defenseMessage->Data.Write();
 return defenseMessage;
 }
 
 private:
 uint32 _zoneId; 
 uint32 _id; 
};
 
OPvPCapturePoint::OPvPCapturePoint(OutdoorPvP* pvp):
 m_team(TEAM_NEUTRAL), m_OldState(OBJECTIVESTATE_NEUTRAL),
 m_State(OBJECTIVESTATE_NEUTRAL), m_PvP(pvp)
{ }
 
OutdoorPvP::OutdoorPvP(Map* map) : m_TypeId(0), m_map(map) { }
 
OutdoorPvP::~OutdoorPvP() = default;
 
void OutdoorPvP::HandlePlayerEnterZone(Player* player, uint32 /*zone*/)
{
 m_players[player->GetTeamId()].insert(player->GetGUID());
}
 
void OutdoorPvP::HandlePlayerLeaveZone(Player* player, uint32 /*zone*/)
{
 // remove the world state information from the player (we can't keep everyone up to date, so leave out those who are not in the concerning zones)
 if (!player->GetSession()->PlayerLogout())
 SendRemoveWorldStates(player);
 m_players[player->GetTeamId()].erase(player->GetGUID());
 TC_LOG_DEBUG("outdoorpvp", "Player {} left an outdoorpvp zone", player->GetName());
}
 
void OutdoorPvP::HandlePlayerResurrects(Player* /*player*/, uint32 /*zone*/) { }
 
void OutdoorPvP::Update(uint32 diff)
{
 for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
 itr->second->Update(diff);
}
 
int32 OutdoorPvP::GetWorldState(int32 worldStateId) const
{
 return sWorldStateMgr->GetValue(worldStateId, m_map);
}
 
void OutdoorPvP::SetWorldState(int32 worldStateId, int32 value)
{
 sWorldStateMgr->SetValue(worldStateId, value, false, m_map);
}
 
void OutdoorPvP::HandleKill(Player* killer, Unit* killed)
{
 if (Group* group = killer->GetGroup())
 {
 for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
 {
 Player* groupGuy = itr->GetSource();
 
 if (!groupGuy)
 continue;
 
 // skip if too far away
 if (!groupGuy->IsAtGroupRewardDistance(killed))
 continue;
 
 // creature kills must be notified, even if not inside objective / not outdoor pvp active
 // player kills only count if active and inside objective
 if ((groupGuy->IsOutdoorPvPActive()) || killed->GetTypeId() == TYPEID_UNIT)
 HandleKillImpl(groupGuy, killed);
 }
 }
 else
 {
 // creature kills must be notified, even if not inside objective / not outdoor pvp active
 if ((killer->IsOutdoorPvPActive()) || killed->GetTypeId() == TYPEID_UNIT)
 HandleKillImpl(killer, killed);
 }
}
 
bool OutdoorPvP::HandleCustomSpell(Player* player, uint32 spellId, GameObject* go)
{
 for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
 if (itr->second->HandleCustomSpell(player, spellId, go))
 return true;
 
 return false;
}
 
bool OPvPCapturePoint::HandleCustomSpell(Player* player, uint32 /*spellId*/, GameObject* /*go*/)
{
 if (!player->IsOutdoorPvPActive())
 return false;
 return true;
}
 
bool OutdoorPvP::HandleOpenGo(Player* player, GameObject* go)
{
 for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
 if (itr->second->HandleOpenGo(player, go) >= 0)
 return true;
 
 return false;
}
 
bool OutdoorPvP::HandleDropFlag(Player* player, uint32 id)
{
 for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
 if (itr->second->HandleDropFlag(player, id))
 return true;
 
 return false;
}
 
int32 OPvPCapturePoint::HandleOpenGo(Player* /*player*/, GameObject* /*go*/)
{
 return -1;
}
 
void OutdoorPvP::BroadcastPacket(WorldPacket const* data) const
{
 // This is faster than sWorld->SendZoneMessage
 for (uint32 team = 0; team < PVP_TEAMS_COUNT; ++team)
 for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
 if (Player* const player = ObjectAccessor::FindPlayer(*itr))
 player->SendDirectMessage(data);
}
 
void OutdoorPvP::RegisterZone(uint32 zoneId)
{
 sOutdoorPvPMgr->AddZone(zoneId, this);
}
 
bool OutdoorPvP::HasPlayer(Player const* player) const
{
 GuidSet const& plSet = m_players[player->GetTeamId()];
 return plSet.find(player->GetGUID()) != plSet.end();
}
 
void OutdoorPvP::TeamCastSpell(TeamId team, int32 spellId)
{
 if (spellId > 0)
 {
 for (GuidSet::iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
 if (Player* const player = ObjectAccessor::FindPlayer(*itr))
 player->CastSpell(player, (uint32)spellId, true);
 }
 else
 {
 for (GuidSet::iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
 if (Player* const player = ObjectAccessor::FindPlayer(*itr))
 player->RemoveAura((uint32)-spellId); // by stack?
 }
}
 
void OutdoorPvP::TeamApplyBuff(TeamId team, uint32 spellId, uint32 spellId2)
{
 TeamCastSpell(team, spellId);
 TeamCastSpell(OTHER_TEAM(team), spellId2 ? -(int32)spellId2 : -(int32)spellId);
}
 
void OutdoorPvP::SendDefenseMessage(uint32 zoneId, uint32 id)
{
 DefenseMessageBuilder builder(zoneId, id);
 Trinity::LocalizedDo<DefenseMessageBuilder> localizer(builder);
 BroadcastWorker(localizer, zoneId);
}
 
void OutdoorPvP::ProcessEvent([[maybe_unused]] WorldObject * target, [[maybe_unused]] uint32 eventId, [[maybe_unused]] WorldObject * invoker)
{
 if (invoker)
 {
 if (GameObject* gameobject = invoker->ToGameObject())
 {
 if (gameobject->GetGoType() == GAMEOBJECT_TYPE_CONTROL_ZONE)
 {
 if (!ControlZoneHandlers.contains(gameobject->GetEntry()))
 return;
 
 auto controlzone = gameobject->GetGOInfo()->controlZone;
 OutdoorPvPControlZoneHandler& handler = *ControlZoneHandlers[invoker->GetEntry()];
 if (eventId == controlzone.CaptureEventAlliance)
 handler.HandleCaptureEventAlliance(gameobject);
 else if (eventId == controlzone.CaptureEventHorde)
 handler.HandleCaptureEventHorde(gameobject);
 else if (eventId == controlzone.ContestedEventAlliance)
 handler.HandleContestedEventAlliance(gameobject);
 else if (eventId == controlzone.ContestedEventHorde)
 handler.HandleContestedEventHorde(gameobject);
 else if (eventId == controlzone.NeutralEventAlliance)
 handler.HandleNeutralEventAlliance(gameobject);
 else if (eventId == controlzone.NeutralEventHorde)
 handler.HandleNeutralEventHorde(gameobject);
 else if (eventId == controlzone.ProgressEventAlliance)
 handler.HandleProgressEventAlliance(gameobject);
 else if (eventId == controlzone.ProgressEventHorde)
 handler.HandleProgressEventHorde(gameobject);
 }
 }
 }
}
 
template<class Worker>
void OutdoorPvP::BroadcastWorker(Worker& _worker, uint32 zoneId)
{
 for (uint32 i = 0; i < PVP_TEAMS_COUNT; ++i)
 for (GuidSet::iterator itr = m_players[i].begin(); itr != m_players[i].end(); ++itr)
 if (Player* player = ObjectAccessor::FindPlayer(*itr))
 if (player->GetZoneId() == zoneId)
 _worker(player);
}