OutdoorPvPMgr Class Reference

#include "OutdoorPvPMgr.h"

Public Member Functions
void	InitOutdoorPvP ()
void	Die ()
void	HandlePlayerEnterZone (Player *player, uint32 areaflag)
void	HandlePlayerLeaveZone (Player *player, uint32 areaflag)
void	HandlePlayerResurrects (Player *player, uint32 areaflag)
OutdoorPvP *	GetOutdoorPvPToZoneId (uint32 zoneid)
bool	HandleCustomSpell (Player *player, uint32 spellId, GameObject *go)
bool	HandleOpenGo (Player *player, GameObject *go)
ZoneScript *	GetZoneScript (uint32 zoneId)
void	AddZone (uint32 zoneid, OutdoorPvP *handle)
void	Update (uint32 diff)
void	HandleGossipOption (Player *player, Creature *creatured, uint32 gossipid)
bool	CanTalkTo (Player *player, Creature *creature, GossipMenuItems const &gso)
void	HandleDropFlag (Player *player, uint32 spellId)

Static Public Member Functions
static OutdoorPvPMgr *	instance ()

Public Attributes
std::mutex	_lock

Private Member Functions
	OutdoorPvPMgr ()
	~OutdoorPvPMgr ()=default

Private Attributes
std::vector< std::unique_ptr< OutdoorPvP > >	m_OutdoorPvPSet
std::map< uint32, OutdoorPvP * >	m_OutdoorPvPMap
std::map< OutdoorPvPTypes, std::unique_ptr< OutdoorPvPData > >	m_OutdoorPvPDatas
uint32	m_UpdateTimer

Detailed Description

Constructor & Destructor Documentation

OutdoorPvPMgr()

OutdoorPvPMgr::OutdoorPvPMgr ( )

private

{
    m_UpdateTimer = 0;
    //LOG_DEBUG("outdoorpvp", "Instantiating OutdoorPvPMgr");
}

References m_UpdateTimer.

~OutdoorPvPMgr()

OutdoorPvPMgr::~OutdoorPvPMgr ( )

privatedefault

Member Function Documentation

AddZone()

void OutdoorPvPMgr::AddZone	(	uint32	zoneid,
		OutdoorPvP *	handle
	)

{
    m_OutdoorPvPMap[zoneid] = handle;
}

References m_OutdoorPvPMap.

CanTalkTo()

bool OutdoorPvPMgr::CanTalkTo	(	Player *	player,
		Creature *	creature,
		GossipMenuItems const &	gso
	)

{
    for (auto& itr : m_OutdoorPvPSet)
    {
        if (itr->CanTalkTo(player, creature, gso))
        {
            return true;
        }
    }
 
    return false;
}

References m_OutdoorPvPSet.

Die()

void OutdoorPvPMgr::Die

(

)

{
    m_OutdoorPvPSet.clear();
    m_OutdoorPvPDatas.clear();
}

References m_OutdoorPvPDatas, and m_OutdoorPvPSet.

GetOutdoorPvPToZoneId()

OutdoorPvP * OutdoorPvPMgr::GetOutdoorPvPToZoneId

(

uint32

zoneid

)

{
    auto itr = m_OutdoorPvPMap.find(zoneid);
    if (itr == m_OutdoorPvPMap.end())
    {
        // no handle for this zone, return
        return nullptr;
    }
 
    return itr->second;
}

References m_OutdoorPvPMap.

GetZoneScript()

ZoneScript * OutdoorPvPMgr::GetZoneScript

(

uint32

zoneId

)

{
    auto itr = m_OutdoorPvPMap.find(zoneId);
    if (itr != m_OutdoorPvPMap.end())
    {
        return itr->second;
    }
 
    return nullptr;
}

References m_OutdoorPvPMap.

HandleCustomSpell()

bool OutdoorPvPMgr::HandleCustomSpell	(	Player *	player,
		uint32	spellId,
		GameObject *	go
	)

{
    // pussywizard: no mutex because not affecting other players
    for (auto& itr : m_OutdoorPvPSet)
    {
        if (itr->HandleCustomSpell(player, spellId, go))
        {
            return true;
        }
    }
 
    return false;
}

References m_OutdoorPvPSet.

HandleDropFlag()

void OutdoorPvPMgr::HandleDropFlag	(	Player *	player,
		uint32	spellId
	)

{
    // pussywizard: no mutex because not affecting other players
    for (auto& itr : m_OutdoorPvPSet)
    {
        if (itr->HandleDropFlag(player, spellId))
        {
            return;
        }
    }
}

References m_OutdoorPvPSet.

HandleGossipOption()

void OutdoorPvPMgr::HandleGossipOption	(	Player *	player,
		Creature *	creatured,
		uint32	gossipid
	)

{
    std::lock_guard<std::mutex> guard(_lock); // pussywizard
 
    for (auto& itr : m_OutdoorPvPSet)
    {
        if (itr->HandleGossipOption(player, creature, gossipid))
        {
            return;
        }
    }
}

References _lock, and m_OutdoorPvPSet.

HandleOpenGo()

bool OutdoorPvPMgr::HandleOpenGo	(	Player *	player,
		GameObject *	go
	)

{
    std::lock_guard<std::mutex> guard(_lock); // pussywizard
 
    for (auto& itr : m_OutdoorPvPSet)
    {
        if (itr->HandleOpenGo(player, go))
        {
            return true;
        }
    }
 
    return false;
}

References _lock, and m_OutdoorPvPSet.

HandlePlayerEnterZone()

void OutdoorPvPMgr::HandlePlayerEnterZone	(	Player *	player,
		uint32	areaflag
	)

{
    auto itr = m_OutdoorPvPMap.find(zoneid);
    if (itr == m_OutdoorPvPMap.end())
        return;
 
    std::lock_guard<std::mutex> guard(_lock); // pussywizard
 
    if (itr->second->HasPlayer(player))
        return;
 
    itr->second->HandlePlayerEnterZone(player, zoneid);
    LOG_DEBUG("outdoorpvp", "Player {} entered outdoorpvp id {}", player->GetGUID().ToString(), itr->second->GetTypeId());
}

References _lock, Object::GetGUID(), LOG_DEBUG, m_OutdoorPvPMap, and ObjectGuid::ToString().

HandlePlayerLeaveZone()

void OutdoorPvPMgr::HandlePlayerLeaveZone	(	Player *	player,
		uint32	areaflag
	)

{
    auto itr = m_OutdoorPvPMap.find(zoneid);
    if (itr == m_OutdoorPvPMap.end())
        return;
 
    std::lock_guard<std::mutex> guard(_lock); // pussywizard
 
    // teleport: remove once in removefromworld, once in updatezone
    if (!itr->second->HasPlayer(player))
        return;
 
    itr->second->HandlePlayerLeaveZone(player, zoneid);
    LOG_DEBUG("outdoorpvp", "Player {} left outdoorpvp id {}", player->GetGUID().ToString(), itr->second->GetTypeId());
}

References _lock, Object::GetGUID(), LOG_DEBUG, m_OutdoorPvPMap, and ObjectGuid::ToString().

HandlePlayerResurrects()

void OutdoorPvPMgr::HandlePlayerResurrects	(	Player *	player,
		uint32	areaflag
	)

{
    auto itr = m_OutdoorPvPMap.find(zoneid);
    if (itr == m_OutdoorPvPMap.end())
        return;
 
    // pussywizard: no mutex because not affecting other players
 
    if (itr->second->HasPlayer(player))
    {
        itr->second->HandlePlayerResurrects(player, zoneid);
    }
}

References m_OutdoorPvPMap.

InitOutdoorPvP()

void OutdoorPvPMgr::InitOutdoorPvP

(

)

{
    uint32 oldMSTime = getMSTime();
 
    //                                                 0       1
    QueryResult result = WorldDatabase.Query("SELECT TypeId, ScriptName FROM outdoorpvp_template");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 outdoor PvP definitions. DB table `outdoorpvp_template` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    uint32 typeId = 0;
 
    for (auto const& fields : *result)
    {
        typeId = fields[0].Get<uint8>();
 
        if (DisableMgr::IsDisabledFor(DISABLE_TYPE_OUTDOORPVP, typeId, nullptr))
            continue;
 
        if (typeId >= MAX_OUTDOORPVP_TYPES)
        {
            LOG_ERROR("sql.sql", "Invalid OutdoorPvPTypes value {} in outdoorpvp_template; skipped.", typeId);
            continue;
        }
 
        auto data = std::make_unique<OutdoorPvPData>();
        auto realTypeId = OutdoorPvPTypes(typeId);
        data->TypeId = realTypeId;
        data->ScriptId = sObjectMgr->GetScriptId(fields[1].Get<std::string>());
        m_OutdoorPvPDatas[realTypeId] = std::move(data);
 
        ++count;
    }
 
    for (uint8 i = 1; i < MAX_OUTDOORPVP_TYPES; ++i)
    {
        auto iter = m_OutdoorPvPDatas.find(OutdoorPvPTypes(i));
        if (iter == m_OutdoorPvPDatas.end())
        {
            LOG_ERROR("sql.sql", "Could not initialize OutdoorPvP object for type ID {}; no entry in database.", uint32(i));
            continue;
        }
 
        auto pvp = std::unique_ptr<OutdoorPvP>(sScriptMgr->CreateOutdoorPvP(iter->second.get()));
        if (!pvp)
        {
            LOG_ERROR("outdoorpvp", "Could not initialize OutdoorPvP object for type ID {}; got nullptr pointer from script.", uint32(i));
            continue;
        }
 
        if (!pvp->SetupOutdoorPvP())
        {
            LOG_ERROR("outdoorpvp", "Could not initialize OutdoorPvP object for type ID {}; SetupOutdoorPvP failed.", uint32(i));
            continue;
        }
 
        m_OutdoorPvPSet.emplace_back(std::move(pvp));
    }
 
    LOG_INFO("server.loading", ">> Loaded {} outdoor PvP definitions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References DISABLE_TYPE_OUTDOORPVP, getMSTime(), GetMSTimeDiffToNow(), DisableMgr::IsDisabledFor(), LOG_ERROR, LOG_INFO, LOG_WARN, m_OutdoorPvPDatas, m_OutdoorPvPSet, MAX_OUTDOORPVP_TYPES, sObjectMgr, sScriptMgr, and WorldDatabase.

instance()

OutdoorPvPMgr * OutdoorPvPMgr::instance ( )

static

{
    static OutdoorPvPMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

Update()

void OutdoorPvPMgr::Update

(

uint32

diff

)

{
    m_UpdateTimer += diff;
 
    if (m_UpdateTimer > OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL)
    {
        for (auto const& itr : m_OutdoorPvPSet)
        {
            itr->Update(m_UpdateTimer);
        }
 
        m_UpdateTimer = 0;
    }
}

References m_OutdoorPvPSet, m_UpdateTimer, and OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL.

Member Data Documentation

_lock

std::mutex OutdoorPvPMgr::_lock

Referenced by HandleGossipOption(), HandleOpenGo(), HandlePlayerEnterZone(), and HandlePlayerLeaveZone().

m_OutdoorPvPDatas

std::map<OutdoorPvPTypes, std::unique_ptr<OutdoorPvPData> > OutdoorPvPMgr::m_OutdoorPvPDatas

private

Referenced by Die(), and InitOutdoorPvP().

m_OutdoorPvPMap

std::map<uint32, OutdoorPvP*> OutdoorPvPMgr::m_OutdoorPvPMap

private

Referenced by AddZone(), GetOutdoorPvPToZoneId(), GetZoneScript(), HandlePlayerEnterZone(), HandlePlayerLeaveZone(), and HandlePlayerResurrects().

m_OutdoorPvPSet

std::vector<std::unique_ptr<OutdoorPvP> > OutdoorPvPMgr::m_OutdoorPvPSet

private

Referenced by CanTalkTo(), Die(), HandleCustomSpell(), HandleDropFlag(), HandleGossipOption(), HandleOpenGo(), InitOutdoorPvP(), and Update().

m_UpdateTimer

uint32 OutdoorPvPMgr::m_UpdateTimer

private

Referenced by OutdoorPvPMgr(), and Update().