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 Types
typedef std::vector< OutdoorPvP * >	OutdoorPvPSet
typedef std::map< uint32, OutdoorPvP * >	OutdoorPvPMap
typedef std::map< OutdoorPvPTypes, OutdoorPvPData * >	OutdoorPvPDataMap

Private Member Functions
	OutdoorPvPMgr ()
	~OutdoorPvPMgr ()

Private Attributes
OutdoorPvPSet	m_OutdoorPvPSet
OutdoorPvPMap	m_OutdoorPvPMap
OutdoorPvPDataMap	m_OutdoorPvPDatas
uint32	m_UpdateTimer

Detailed Description

Member Typedef Documentation

OutdoorPvPDataMap

typedef std::map<OutdoorPvPTypes, OutdoorPvPData*> OutdoorPvPMgr::OutdoorPvPDataMap

private

OutdoorPvPMap

typedef std::map<uint32 , OutdoorPvP*> OutdoorPvPMgr::OutdoorPvPMap

private

OutdoorPvPSet

typedef std::vector<OutdoorPvP*> OutdoorPvPMgr::OutdoorPvPSet

private

Constructor & Destructor Documentation

OutdoorPvPMgr()

OutdoorPvPMgr::OutdoorPvPMgr ( )

private

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

References m_UpdateTimer.

~OutdoorPvPMgr()

OutdoorPvPMgr::~OutdoorPvPMgr ( )

inlineprivate

{};

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 (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
    {
        if ((*itr)->CanTalkTo(player, creature, gso))
            return true;
    }
    return false;
}

References m_OutdoorPvPSet.

Die()

void OutdoorPvPMgr::Die

(

)

{
    //LOG_DEBUG("outdoorpvp", "Deleting OutdoorPvPMgr");
    for (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
        delete *itr;
 
    for (OutdoorPvPDataMap::iterator itr = m_OutdoorPvPDatas.begin(); itr != m_OutdoorPvPDatas.end(); ++itr)
        delete itr->second;
}

References m_OutdoorPvPDatas, and m_OutdoorPvPSet.

GetOutdoorPvPToZoneId()

OutdoorPvP * OutdoorPvPMgr::GetOutdoorPvPToZoneId

(

uint32

zoneid

)

{
    OutdoorPvPMap::iterator 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

)

{
    OutdoorPvPMap::iterator itr = m_OutdoorPvPMap.find(zoneId);
    if (itr != m_OutdoorPvPMap.end())
        return itr->second;
    else
        return nullptr;
}

References m_OutdoorPvPMap.

HandleCustomSpell()

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

{
    // pussywizard: no mutex because not affecting other players
    for (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
    {
        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 (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
    {
        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 (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
    {
        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 (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
    {
        if ((*itr)->HandleOpenGo(player, go))
            return true;
    }
    return false;
}

References _lock, and m_OutdoorPvPSet.

HandlePlayerEnterZone()

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

{
    OutdoorPvPMap::iterator 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
	)

{
    OutdoorPvPMap::iterator 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
	)

{
    OutdoorPvPMap::iterator 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;
 
    do
    {
        Field* fields = result->Fetch();
 
        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;
        }
 
        OutdoorPvPData* data = new OutdoorPvPData();
        OutdoorPvPTypes realTypeId = OutdoorPvPTypes(typeId);
        data->TypeId = realTypeId;
        data->ScriptId = sObjectMgr->GetScriptId(fields[1].Get<std::string>());
        m_OutdoorPvPDatas[realTypeId] = data;
 
        ++count;
    } while (result->NextRow());
 
    OutdoorPvP* pvp;
    for (uint8 i = 1; i < MAX_OUTDOORPVP_TYPES; ++i)
    {
        OutdoorPvPDataMap::iterator 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;
        }
 
        pvp = sScriptMgr->CreateOutdoorPvP(iter->second);
        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));
            delete pvp;
            continue;
        }
 
        m_OutdoorPvPSet.push_back(pvp);
    }
 
    LOG_INFO("server.loading", ">> Loaded {} outdoor PvP definitions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References DISABLE_TYPE_OUTDOORPVP, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), DisableMgr::IsDisabledFor(), LOG_ERROR, LOG_INFO, LOG_WARN, m_OutdoorPvPDatas, m_OutdoorPvPSet, MAX_OUTDOORPVP_TYPES, OutdoorPvPData::ScriptId, OutdoorPvP::SetupOutdoorPvP(), sObjectMgr, sScriptMgr, OutdoorPvPData::TypeId, 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 (OutdoorPvPSet::iterator itr = m_OutdoorPvPSet.begin(); itr != m_OutdoorPvPSet.end(); ++itr)
            (*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

OutdoorPvPDataMap OutdoorPvPMgr::m_OutdoorPvPDatas

private

Referenced by Die(), and InitOutdoorPvP().

m_OutdoorPvPMap

OutdoorPvPMap OutdoorPvPMgr::m_OutdoorPvPMap

private

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

m_OutdoorPvPSet

OutdoorPvPSet 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().