OutdoorPvPTF Class Reference

#include "OutdoorPvPTF.h"

Inheritance diagram for OutdoorPvPTF:

Public Member Functions
	OutdoorPvPTF ()
bool	SetupOutdoorPvP () override
void	HandlePlayerEnterZone (Player *player, uint32 zone) override
void	HandlePlayerLeaveZone (Player *player, uint32 zone) override
bool	Update (uint32 diff) override
void	FillInitialWorldStates (WorldPacket &data) override
void	SendRemoveWorldStates (Player *player) override
void	SaveRequiredWorldStates () const
void	ResetZoneToTeamControlled (TeamId team)
void	RecalculateClientUILockTime ()
uint32	GetAllianceTowersControlled () const
void	SetAllianceTowersControlled (uint32 count)
uint32	GetHordeTowersControlled () const
void	SetHordeTowersControlled (uint32 count)
bool	IsLocked () const
Public Member Functions inherited from OutdoorPvP
	OutdoorPvP ()
	~OutdoorPvP () override
void	DeleteSpawns ()
virtual void	FillInitialWorldStates (WorldPacket &)
virtual bool	HandleAreaTrigger (Player *player, uint32 trigger)
virtual bool	HandleCustomSpell (Player *player, uint32 spellId, GameObject *go)
virtual bool	HandleOpenGo (Player *player, GameObject *go)
virtual bool	SetupOutdoorPvP ()
void	OnGameObjectCreate (GameObject *go) override
void	OnGameObjectRemove (GameObject *go) override
void	OnCreatureCreate (Creature *creature) override
void	OnCreatureRemove (Creature *creature) override
void	SendUpdateWorldState (uint32 field, uint32 value)
virtual bool	Update (uint32 diff)
virtual void	HandleKill (Player *killer, Unit *killed)
virtual void	HandleKillImpl (Player *, Unit *)
bool	IsInsideObjective (Player *player) const
virtual void	AwardKillBonus (Player *)
uint32	GetTypeId ()
virtual bool	HandleDropFlag (Player *player, uint32 spellId)
virtual bool	HandleGossipOption (Player *player, Creature *creature, uint32 gossipid)
virtual bool	CanTalkTo (Player *player, Creature *c, GossipMenuItems const &gso)
void	TeamApplyBuff (TeamId teamId, uint32 spellId, uint32 spellId2=0, Player *sameMapPlr=nullptr)
Map *	GetMap () const
Public Member Functions inherited from ZoneScript
	ZoneScript ()
virtual	~ZoneScript ()
virtual uint32	GetCreatureEntry (ObjectGuid::LowType, CreatureData const *data)
virtual uint32	GetGameObjectEntry (ObjectGuid::LowType, uint32 entry)
virtual void	OnCreatureCreate (Creature *)
virtual void	OnCreatureRemove (Creature *)
virtual void	OnGameObjectCreate (GameObject *)
virtual void	OnGameObjectRemove (GameObject *)
virtual void	OnUnitDeath (Unit *)
virtual void	OnCreatureEvade (Creature *)
virtual ObjectGuid	GetGuidData (uint32) const
virtual void	SetGuidData (uint32, ObjectGuid)
virtual uint64	GetData64 (uint32) const
virtual void	SetData64 (uint32, uint64)
virtual uint32	GetData (uint32) const
virtual void	SetData (uint32, uint32)
virtual void	ProcessEvent (WorldObject *, uint32)

Private Attributes
bool	m_IsLocked
bool	m_JustLocked
uint32	m_LockTimer
uint32	m_LockTimerUpdate
uint32	m_AllianceTowersControlled
uint32	m_HordeTowersControlled
uint32	hours_left
uint32	second_digit
uint32	first_digit

Additional Inherited Members
Public Types inherited from OutdoorPvP
typedef std::map< ObjectGuid::LowType, OPvPCapturePoint * >	OPvPCapturePointMap
typedef std::pair< ObjectGuid::LowType, GameObject * >	GoScriptPair
typedef std::pair< ObjectGuid::LowType, Creature * >	CreatureScriptPair
Protected Member Functions inherited from OutdoorPvP
virtual void	SendRemoveWorldStates (Player *)
void	BroadcastPacket (WorldPacket &data) const
virtual void	HandlePlayerEnterZone (Player *player, uint32 zone)
virtual void	HandlePlayerLeaveZone (Player *player, uint32 zone)
virtual void	HandlePlayerResurrects (Player *player, uint32 zone)
void	AddCapturePoint (OPvPCapturePoint *cp)
OPvPCapturePoint *	GetCapturePoint (ObjectGuid::LowType spawnId) const
void	RegisterZone (uint32 zoneid)
bool	HasPlayer (Player const *player) const
void	TeamCastSpell (TeamId team, int32 spellId, Player *sameMapPlr=nullptr)
void	SetMapFromZone (uint32 zone)
Protected Attributes inherited from OutdoorPvP
OPvPCapturePointMap	m_capturePoints
PlayerSet	m_players [2]
uint32	m_TypeId
bool	m_sendUpdate
std::map< ObjectGuid::LowType, GameObject * >	m_GoScriptStore
std::map< ObjectGuid::LowType, Creature * >	m_CreatureScriptStore
Map *	m_map

Detailed Description

Constructor & Destructor Documentation

OutdoorPvPTF()

OutdoorPvPTF::OutdoorPvPTF

(

)

{
    m_TypeId = OUTDOOR_PVP_TF;
 
    m_IsLocked = false;
    m_JustLocked = false;
    m_LockTimer = TF_LOCK_TIME;
    m_LockTimerUpdate = 0;
 
    m_AllianceTowersControlled = 0;
    m_HordeTowersControlled = 0;
 
    hours_left = 6;
    second_digit = 0;
    first_digit = 0;
}

References first_digit, hours_left, m_AllianceTowersControlled, m_HordeTowersControlled, m_IsLocked, m_JustLocked, m_LockTimer, m_LockTimerUpdate, OutdoorPvP::m_TypeId, OUTDOOR_PVP_TF, second_digit, and TF_LOCK_TIME.

Member Function Documentation

FillInitialWorldStates()

void OutdoorPvPTF::FillInitialWorldStates ( WorldPacket &  data )

overridevirtual

Reimplemented from OutdoorPvP.

{
    data << TF_UI_TOWER_SLIDER_POS << uint32(50);
    data << TF_UI_TOWER_SLIDER_N << uint32(100);
    data << TF_UI_TOWER_SLIDER_DISPLAY << uint32(0);
 
    data << TF_UI_TOWER_COUNT_H << m_HordeTowersControlled;
    data << TF_UI_TOWER_COUNT_A << m_AllianceTowersControlled;
    data << TF_UI_TOWERS_CONTROLLED_DISPLAY << uint32(!m_IsLocked);
 
    data << TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT << first_digit;
    data << TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT << second_digit;
    data << TF_UI_LOCKED_TIME_HOURS << hours_left;
 
    data << TF_UI_LOCKED_DISPLAY_NEUTRAL << uint32(m_IsLocked && !m_HordeTowersControlled && !m_AllianceTowersControlled);
    data << TF_UI_LOCKED_DISPLAY_HORDE << uint32(m_IsLocked && (m_HordeTowersControlled > m_AllianceTowersControlled));
    data << TF_UI_LOCKED_DISPLAY_ALLIANCE << uint32(m_IsLocked && (m_HordeTowersControlled < m_AllianceTowersControlled));
 
    for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
    {
        itr->second->FillInitialWorldStates(data);
    }
}

References first_digit, hours_left, m_AllianceTowersControlled, OutdoorPvP::m_capturePoints, m_HordeTowersControlled, m_IsLocked, second_digit, TF_UI_LOCKED_DISPLAY_ALLIANCE, TF_UI_LOCKED_DISPLAY_HORDE, TF_UI_LOCKED_DISPLAY_NEUTRAL, TF_UI_LOCKED_TIME_HOURS, TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, TF_UI_TOWER_COUNT_A, TF_UI_TOWER_COUNT_H, TF_UI_TOWER_SLIDER_DISPLAY, TF_UI_TOWER_SLIDER_N, TF_UI_TOWER_SLIDER_POS, and TF_UI_TOWERS_CONTROLLED_DISPLAY.

GetAllianceTowersControlled()

uint32 OutdoorPvPTF::GetAllianceTowersControlled

(

)

const

{
    return m_AllianceTowersControlled;
}

References m_AllianceTowersControlled.

GetHordeTowersControlled()

uint32 OutdoorPvPTF::GetHordeTowersControlled

(

)

const

{
    return m_HordeTowersControlled;
}

References m_HordeTowersControlled.

HandlePlayerEnterZone()

void OutdoorPvPTF::HandlePlayerEnterZone ( Player *  player, uint32  zone  )

overridevirtual

Reimplemented from OutdoorPvP.

{
    if (player->GetTeamId() == TEAM_ALLIANCE)
    {
        if (m_AllianceTowersControlled >= TF_TOWER_NUM)
            player->CastSpell(player, TF_CAPTURE_BUFF, true);
    }
    else
    {
        if (m_HordeTowersControlled >= TF_TOWER_NUM)
            player->CastSpell(player, TF_CAPTURE_BUFF, true);
    }
    OutdoorPvP::HandlePlayerEnterZone(player, zone);
}

References Unit::CastSpell(), Player::GetTeamId(), OutdoorPvP::HandlePlayerEnterZone(), m_AllianceTowersControlled, m_HordeTowersControlled, TEAM_ALLIANCE, TF_CAPTURE_BUFF, and TF_TOWER_NUM.

HandlePlayerLeaveZone()

void OutdoorPvPTF::HandlePlayerLeaveZone ( Player *  player, uint32  zone  )

overridevirtual

Reimplemented from OutdoorPvP.

{
    // remove buffs
    player->RemoveAurasDueToSpell(TF_CAPTURE_BUFF);
    OutdoorPvP::HandlePlayerLeaveZone(player, zone);
}

References OutdoorPvP::HandlePlayerLeaveZone(), Unit::RemoveAurasDueToSpell(), and TF_CAPTURE_BUFF.

IsLocked()

bool OutdoorPvPTF::IsLocked

(

)

const

{
    return m_IsLocked;
}

References m_IsLocked.

RecalculateClientUILockTime()

void OutdoorPvPTF::RecalculateClientUILockTime ( )

inline

    {
        uint32 minutes_left = m_LockTimer / 60000;
        hours_left = minutes_left / 60;
        minutes_left -= hours_left * 60;
        second_digit = minutes_left % 10;
        first_digit = minutes_left / 10;
    }

References first_digit, hours_left, m_LockTimer, and second_digit.

Referenced by SetupOutdoorPvP(), and Update().

ResetZoneToTeamControlled()

void OutdoorPvPTF::ResetZoneToTeamControlled

(

TeamId

team

)

{
    switch (team)
    {
    case TEAM_HORDE:
        m_HordeTowersControlled = TF_TOWER_NUM;
        m_AllianceTowersControlled = 0;
        break;
    case TEAM_ALLIANCE:
        m_HordeTowersControlled = 0;
        m_AllianceTowersControlled = TF_TOWER_NUM;
        break;
    case TEAM_NEUTRAL:
        m_HordeTowersControlled = 0;
        m_AllianceTowersControlled = 0;
        break;
    }
 
    for (auto& [guid, tower] : m_capturePoints)
    {
        dynamic_cast<OPvPCapturePointTF*>(tower)->ResetToTeamControlled(team);
    }
 
    SendUpdateWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
    SendUpdateWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
}

References m_AllianceTowersControlled, OutdoorPvP::m_capturePoints, m_HordeTowersControlled, OutdoorPvP::SendUpdateWorldState(), TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, TF_TOWER_NUM, TF_UI_TOWER_COUNT_A, and TF_UI_TOWER_COUNT_H.

Referenced by SetupOutdoorPvP(), and Update().

SaveRequiredWorldStates()

void OutdoorPvPTF::SaveRequiredWorldStates

(

)

const

{
    sWorld->setWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
    sWorld->setWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
 
    sWorld->setWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, m_IsLocked);
 
    // Save expiry as unix
    uint32 const lockExpireTime = GameTime::GetGameTime().count() + (m_LockTimer / IN_MILLISECONDS);
    sWorld->setWorldState(TF_UI_LOCKED_TIME_HOURS, lockExpireTime);
}

References GameTime::GetGameTime(), IN_MILLISECONDS, m_AllianceTowersControlled, m_HordeTowersControlled, m_IsLocked, m_LockTimer, sWorld, TF_UI_LOCKED_TIME_HOURS, TF_UI_TOWER_COUNT_A, TF_UI_TOWER_COUNT_H, and TF_UI_TOWERS_CONTROLLED_DISPLAY.

Referenced by SetupOutdoorPvP(), and Update().

SendRemoveWorldStates()

void OutdoorPvPTF::SendRemoveWorldStates ( Player *  player )

overridevirtual

Reimplemented from OutdoorPvP.

{
    player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_POS, uint32(0));
    player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_N, uint32(0));
    player->SendUpdateWorldState(TF_UI_TOWER_SLIDER_DISPLAY, uint32(0));
 
    player->SendUpdateWorldState(TF_UI_TOWER_COUNT_H, uint32(0));
    player->SendUpdateWorldState(TF_UI_TOWER_COUNT_A, uint32(0));
    player->SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
 
    player->SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, uint32(0));
    player->SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, uint32(0));
    player->SendUpdateWorldState(TF_UI_LOCKED_TIME_HOURS, uint32(0));
 
    player->SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
    player->SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
    player->SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
 
    for (int i = 0; i < TF_TOWER_NUM; ++i)
    {
        player->SendUpdateWorldState(uint32(TFTowerWorldStates[i].n), uint32(0));
        player->SendUpdateWorldState(uint32(TFTowerWorldStates[i].h), uint32(0));
        player->SendUpdateWorldState(uint32(TFTowerWorldStates[i].a), uint32(0));
    }
}

References Player::SendUpdateWorldState(), TF_TOWER_NUM, TF_UI_LOCKED_DISPLAY_ALLIANCE, TF_UI_LOCKED_DISPLAY_HORDE, TF_UI_LOCKED_DISPLAY_NEUTRAL, TF_UI_LOCKED_TIME_HOURS, TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, TF_UI_TOWER_COUNT_A, TF_UI_TOWER_COUNT_H, TF_UI_TOWER_SLIDER_DISPLAY, TF_UI_TOWER_SLIDER_N, TF_UI_TOWER_SLIDER_POS, TF_UI_TOWERS_CONTROLLED_DISPLAY, and TFTowerWorldStates.

SetAllianceTowersControlled()

void OutdoorPvPTF::SetAllianceTowersControlled

(

uint32

count

)

{
    m_AllianceTowersControlled = count;
}

References m_AllianceTowersControlled.

SetHordeTowersControlled()

void OutdoorPvPTF::SetHordeTowersControlled

(

uint32

count

)

{
    m_HordeTowersControlled = count;
}

References m_HordeTowersControlled.

SetupOutdoorPvP()

bool OutdoorPvPTF::SetupOutdoorPvP ( )

overridevirtual

Reimplemented from OutdoorPvP.

{
    m_AllianceTowersControlled = 0;
    m_HordeTowersControlled = 0;
 
    m_IsLocked = bool(sWorld->getWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY));
    m_JustLocked = false;
    m_LockTimer = TF_LOCK_TIME;
    m_LockTimerUpdate = 0;
    hours_left = 6;
    second_digit = 0;
    first_digit = 0;
 
    // add the zones affected by the pvp buff
    for (uint8 i = 0; i < OutdoorPvPTFBuffZonesNum; ++i)
        RegisterZone(OutdoorPvPTFBuffZones[i]);
 
    SetMapFromZone(OutdoorPvPTFBuffZones[0]);
 
    AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_NW));
    AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_N));
    AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_NE));
    AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_SE));
    AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_S));
 
    if (m_IsLocked)
    {
        // Core shutdown while locked -- init from latest known data in WorldState
        // Convert from unix
        int32 const lockRemainingTime = int32((sWorld->getWorldState(TF_UI_LOCKED_TIME_HOURS) - GameTime::GetGameTime().count()) * IN_MILLISECONDS);
        if (lockRemainingTime > 0)
        {
            m_LockTimer = lockRemainingTime;
            RecalculateClientUILockTime();
 
            uint32 const hordeTowers = uint32(sWorld->getWorldState(TF_UI_TOWER_COUNT_H));
            uint32 const allianceTowers = uint32(sWorld->getWorldState(TF_UI_TOWER_COUNT_A));
            TeamId const controllingTeam = hordeTowers > allianceTowers ? TEAM_HORDE : TEAM_ALLIANCE;
 
            ResetZoneToTeamControlled(controllingTeam);
        }
        else
        {
            // Lock expired while core was offline
            m_IsLocked = false;
            SaveRequiredWorldStates();
        }
    }
 
    return true;
}

References OutdoorPvP::AddCapturePoint(), first_digit, GameTime::GetGameTime(), hours_left, IN_MILLISECONDS, m_AllianceTowersControlled, m_HordeTowersControlled, m_IsLocked, m_JustLocked, m_LockTimer, m_LockTimerUpdate, OutdoorPvPTFBuffZones, OutdoorPvPTFBuffZonesNum, RecalculateClientUILockTime(), OutdoorPvP::RegisterZone(), ResetZoneToTeamControlled(), SaveRequiredWorldStates(), second_digit, OutdoorPvP::SetMapFromZone(), sWorld, TEAM_ALLIANCE, TEAM_HORDE, TF_LOCK_TIME, TF_TOWER_N, TF_TOWER_NE, TF_TOWER_NW, TF_TOWER_S, TF_TOWER_SE, TF_UI_LOCKED_TIME_HOURS, TF_UI_TOWER_COUNT_A, TF_UI_TOWER_COUNT_H, and TF_UI_TOWERS_CONTROLLED_DISPLAY.

Update()

bool OutdoorPvPTF::Update ( uint32  diff )

overridevirtual

Reimplemented from OutdoorPvP.

{
    bool changed = OutdoorPvP::Update(diff);
 
    if (changed)
    {
        if (m_AllianceTowersControlled == TF_TOWER_NUM)
        {
            TeamApplyBuff(TEAM_ALLIANCE, TF_CAPTURE_BUFF);
            m_IsLocked = true;
            m_JustLocked = true;
            SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
            SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
            SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(1));
            SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
        }
        else if (m_HordeTowersControlled == TF_TOWER_NUM)
        {
            TeamApplyBuff(TEAM_HORDE, TF_CAPTURE_BUFF);
            m_IsLocked = true;
            m_JustLocked = true;
            SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
            SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(1));
            SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
            SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
        }
        else
        {
            TeamCastSpell(TEAM_ALLIANCE, -TF_CAPTURE_BUFF);
            TeamCastSpell(TEAM_HORDE, -TF_CAPTURE_BUFF);
        }
 
        SendUpdateWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
        SendUpdateWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
    }
 
    if (m_IsLocked)
    {
        if (m_JustLocked)
        {
            m_JustLocked = false;
            SaveRequiredWorldStates();
        }
 
        // lock timer is down, release lock
        if (m_LockTimer < diff)
        {
            m_LockTimer = TF_LOCK_TIME;
            m_LockTimerUpdate = 0;
            m_IsLocked = false;
 
            ResetZoneToTeamControlled(TEAM_NEUTRAL);
            SaveRequiredWorldStates();
 
            SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(1));
            SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
            SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
            SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
        }
        else
        {
            // worldstateui update timer is down, update ui with new time data
            if (m_LockTimerUpdate < diff)
            {
                m_LockTimerUpdate = TF_LOCK_TIME_UPDATE;
                RecalculateClientUILockTime();
 
                SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, first_digit);
                SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, second_digit);
                SendUpdateWorldState(TF_UI_LOCKED_TIME_HOURS, hours_left);
            }
            else
            {
                m_LockTimerUpdate -= diff;
            }
 
            m_LockTimer -= diff;
        }
    }
 
    return changed;
}

References first_digit, hours_left, m_AllianceTowersControlled, m_HordeTowersControlled, m_IsLocked, m_JustLocked, m_LockTimer, m_LockTimerUpdate, RecalculateClientUILockTime(), ResetZoneToTeamControlled(), SaveRequiredWorldStates(), second_digit, OutdoorPvP::SendUpdateWorldState(), TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, OutdoorPvP::TeamApplyBuff(), OutdoorPvP::TeamCastSpell(), TF_CAPTURE_BUFF, TF_LOCK_TIME, TF_LOCK_TIME_UPDATE, TF_TOWER_NUM, TF_UI_LOCKED_DISPLAY_ALLIANCE, TF_UI_LOCKED_DISPLAY_HORDE, TF_UI_LOCKED_DISPLAY_NEUTRAL, TF_UI_LOCKED_TIME_HOURS, TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, TF_UI_TOWER_COUNT_A, TF_UI_TOWER_COUNT_H, TF_UI_TOWERS_CONTROLLED_DISPLAY, and OutdoorPvP::Update().

Member Data Documentation

first_digit

uint32 OutdoorPvPTF::first_digit

private

Referenced by FillInitialWorldStates(), OutdoorPvPTF(), RecalculateClientUILockTime(), SetupOutdoorPvP(), and Update().

hours_left

uint32 OutdoorPvPTF::hours_left

private

Referenced by FillInitialWorldStates(), OutdoorPvPTF(), RecalculateClientUILockTime(), SetupOutdoorPvP(), and Update().

m_AllianceTowersControlled

uint32 OutdoorPvPTF::m_AllianceTowersControlled

private

Referenced by FillInitialWorldStates(), GetAllianceTowersControlled(), HandlePlayerEnterZone(), OutdoorPvPTF(), ResetZoneToTeamControlled(), SaveRequiredWorldStates(), SetAllianceTowersControlled(), SetupOutdoorPvP(), and Update().

m_HordeTowersControlled

uint32 OutdoorPvPTF::m_HordeTowersControlled

private

Referenced by FillInitialWorldStates(), GetHordeTowersControlled(), HandlePlayerEnterZone(), OutdoorPvPTF(), ResetZoneToTeamControlled(), SaveRequiredWorldStates(), SetHordeTowersControlled(), SetupOutdoorPvP(), and Update().

m_IsLocked

bool OutdoorPvPTF::m_IsLocked

private

Referenced by FillInitialWorldStates(), IsLocked(), OutdoorPvPTF(), SaveRequiredWorldStates(), SetupOutdoorPvP(), and Update().

m_JustLocked

bool OutdoorPvPTF::m_JustLocked

private

Referenced by OutdoorPvPTF(), SetupOutdoorPvP(), and Update().

m_LockTimer

uint32 OutdoorPvPTF::m_LockTimer

private

Referenced by OutdoorPvPTF(), RecalculateClientUILockTime(), SaveRequiredWorldStates(), SetupOutdoorPvP(), and Update().

m_LockTimerUpdate

uint32 OutdoorPvPTF::m_LockTimerUpdate

private

Referenced by OutdoorPvPTF(), SetupOutdoorPvP(), and Update().

second_digit

uint32 OutdoorPvPTF::second_digit

private

Referenced by FillInitialWorldStates(), OutdoorPvPTF(), RecalculateClientUILockTime(), SetupOutdoorPvP(), and Update().