OPvPCapturePointEP_EWT Class Reference

#include "OutdoorPvPEP.h"

Inheritance diagram for OPvPCapturePointEP_EWT:

Public Member Functions
	OPvPCapturePointEP_EWT (OutdoorPvP *pvp)
void	ChangeState () override
void	SendChangePhase () override
void	FillInitialWorldStates (WorldPacket &data) override
bool	HandlePlayerEnter (Player *player) override
void	HandlePlayerLeave (Player *player) override
Public Member Functions inherited from OPvPCapturePoint
	OPvPCapturePoint (OutdoorPvP *pvp)
virtual	~OPvPCapturePoint ()
virtual void	FillInitialWorldStates (WorldPacket &)
void	SendUpdateWorldState (uint32 field, uint32 value)
void	SendObjectiveComplete (uint32 id, ObjectGuid guid=ObjectGuid::Empty)
virtual bool	HandlePlayerEnter (Player *player)
virtual void	HandlePlayerLeave (Player *player)
bool	IsInsideObjective (Player *player) const
virtual bool	HandleCustomSpell (Player *player, uint32 spellId, GameObject *go)
virtual int32	HandleOpenGo (Player *player, GameObject *go)
virtual bool	Update (uint32 diff)
virtual void	ChangeState ()=0
virtual void	ChangeTeam (TeamId)
virtual void	SendChangePhase ()
virtual bool	HandleGossipOption (Player *player, Creature *creature, uint32 gossipid)
virtual bool	CanTalkTo (Player *player, Creature *c, GossipMenuItems const &gso)
virtual bool	HandleDropFlag (Player *player, uint32 spellId)
virtual void	DeleteSpawns ()
void	AddGO (uint32 type, ObjectGuid::LowType guid, uint32 entry=0)
void	AddCre (uint32 type, ObjectGuid::LowType guid, uint32 entry=0)
bool	SetCapturePointData (uint32 entry, uint32 map, float x, float y, float z, float o=0, float rotation0=0, float rotation1=0, float rotation2=0, float rotation3=0)
void	SetSlider (float slider)
float	GetSlider ()

Protected Member Functions
void	SummonSupportUnitAtNorthpassTower (TeamId teamId)
void	UpdateTowerState ()
Protected Member Functions inherited from OPvPCapturePoint
bool	AddObject (uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3)
bool	AddCreature (uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay=0)
bool	DelCreature (uint32 type)
bool	DelObject (uint32 type)
bool	DelCapturePoint ()

Protected Attributes
uint32	m_TowerState
TeamId	m_UnitsSummonedSideId
Protected Attributes inherited from OPvPCapturePoint
PlayerSet	m_activePlayers [2]
float	m_maxValue
float	m_minValue
float	m_maxSpeed
float	m_value
TeamId	m_team
ObjectiveStates	m_OldState
ObjectiveStates	m_State
uint32	m_neutralValuePct
OutdoorPvP *	m_PvP
std::map< uint32, ObjectGuid::LowType >	m_Objects
std::map< uint32, ObjectGuid::LowType >	m_Creatures
std::map< ObjectGuid::LowType, uint32 >	m_ObjectTypes
std::map< ObjectGuid::LowType, uint32 >	m_CreatureTypes

Additional Inherited Members
Public Attributes inherited from OPvPCapturePoint
ObjectGuid::LowType	m_capturePointSpawnId
GameObject *	m_capturePoint

Detailed Description

Constructor & Destructor Documentation

OPvPCapturePointEP_EWT()

OPvPCapturePointEP_EWT::OPvPCapturePointEP_EWT

(

OutdoorPvP *

pvp

)

    : OPvPCapturePoint(pvp), m_TowerState(EP_TS_N), m_UnitsSummonedSideId(TEAM_NEUTRAL)
{
    SetCapturePointData(EPCapturePoints[EP_EWT].entry, EPCapturePoints[EP_EWT].map, EPCapturePoints[EP_EWT].x, EPCapturePoints[EP_EWT].y, EPCapturePoints[EP_EWT].z, EPCapturePoints[EP_EWT].o, EPCapturePoints[EP_EWT].rot0, EPCapturePoints[EP_EWT].rot1, EPCapturePoints[EP_EWT].rot2, EPCapturePoints[EP_EWT].rot3);
    AddObject(EP_EWT_FLAGS, EPTowerFlags[EP_EWT].entry, EPTowerFlags[EP_EWT].map, EPTowerFlags[EP_EWT].x, EPTowerFlags[EP_EWT].y, EPTowerFlags[EP_EWT].z, EPTowerFlags[EP_EWT].o, EPTowerFlags[EP_EWT].rot0, EPTowerFlags[EP_EWT].rot1, EPTowerFlags[EP_EWT].rot2, EPTowerFlags[EP_EWT].rot3);
}

References OPvPCapturePoint::AddObject(), EP_EWT, EP_EWT_FLAGS, EPCapturePoints, EPTowerFlags, and OPvPCapturePoint::SetCapturePointData().

Member Function Documentation

ChangeState()

void OPvPCapturePointEP_EWT::ChangeState ( )

overridevirtual

Implements OPvPCapturePoint.

{
    // if changing from controlling alliance to horde or vice versa
    if ( m_OldState == OBJECTIVESTATE_ALLIANCE && m_OldState != m_State )
    {
        sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_EWT_A));
        ((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_EWT, TEAM_NEUTRAL);
    }
    else if ( m_OldState == OBJECTIVESTATE_HORDE && m_OldState != m_State )
    {
        sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_LOSE_EWT_H));
        ((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_EWT, TEAM_NEUTRAL);
    }
 
    uint32 artkit = 21;
 
    switch (m_State)
    {
        case OBJECTIVESTATE_ALLIANCE:
            m_TowerState = EP_TS_A;
            artkit = 2;
            SummonSupportUnitAtNorthpassTower(TEAM_ALLIANCE);
            ((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_EWT, TEAM_ALLIANCE);
            if (m_OldState != m_State) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_A));
            break;
        case OBJECTIVESTATE_HORDE:
            m_TowerState = EP_TS_H;
            artkit = 1;
            SummonSupportUnitAtNorthpassTower(TEAM_HORDE);
            ((OutdoorPvPEP*)m_PvP)->SetControlledState(EP_EWT, TEAM_HORDE);
            if (m_OldState != m_State) sWorld->SendZoneText(EP_GraveYardZone, sObjectMgr->GetAcoreStringForDBCLocale(LANG_OPVP_EP_CAPTURE_EWT_H));
            break;
        case OBJECTIVESTATE_NEUTRAL:
            m_TowerState = EP_TS_N;
            break;
        case OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE:
        case OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE:
            m_TowerState = EP_TS_N_A;
            break;
        case OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE:
        case OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE:
            m_TowerState = EP_TS_N_H;
            break;
    }
 
    Map* map = sMapMgr->FindMap(0, 0);
    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_Objects[EP_EWT_FLAGS]);
    for (auto itr = bounds.first; itr != bounds.second; ++itr)
        itr->second->SetGoArtKit(artkit);
 
    UpdateTowerState();
 
    // complete quest objective
    if (m_TowerState == EP_TS_A || m_TowerState == EP_TS_H)
        SendObjectiveComplete(EP_EWT_CM);
}

References EP_EWT, EP_EWT_CM, EP_EWT_FLAGS, EP_GraveYardZone, EP_TS_A, EP_TS_H, EP_TS_N, EP_TS_N_A, EP_TS_N_H, Map::GetGameObjectBySpawnIdStore(), LANG_OPVP_EP_CAPTURE_EWT_A, LANG_OPVP_EP_CAPTURE_EWT_H, LANG_OPVP_EP_LOSE_EWT_A, LANG_OPVP_EP_LOSE_EWT_H, OPvPCapturePoint::m_capturePointSpawnId, OPvPCapturePoint::m_Objects, OPvPCapturePoint::m_OldState, OPvPCapturePoint::m_PvP, OPvPCapturePoint::m_State, m_TowerState, OBJECTIVESTATE_ALLIANCE, OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE, OBJECTIVESTATE_HORDE, OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE, OBJECTIVESTATE_NEUTRAL, OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE, OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE, OPvPCapturePoint::SendObjectiveComplete(), sMapMgr, sObjectMgr, SummonSupportUnitAtNorthpassTower(), sWorld, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, and UpdateTowerState().

FillInitialWorldStates()

void OPvPCapturePointEP_EWT::FillInitialWorldStates ( WorldPacket &  data )

overridevirtual

Reimplemented from OPvPCapturePoint.

{
    data << EP_EWT_A << uint32(bool(m_TowerState & EP_TS_A));
    data << EP_EWT_H << uint32(bool(m_TowerState & EP_TS_H));
    data << EP_EWT_N_A << uint32(bool(m_TowerState & EP_TS_N_A));
    data << EP_EWT_N_H << uint32(bool(m_TowerState & EP_TS_N_H));
    data << EP_EWT_N << uint32(bool(m_TowerState & EP_TS_N));
}

References EP_EWT_A, EP_EWT_H, EP_EWT_N, EP_EWT_N_A, EP_EWT_N_H, EP_TS_A, EP_TS_H, EP_TS_N, EP_TS_N_A, EP_TS_N_H, and m_TowerState.

HandlePlayerEnter()

bool OPvPCapturePointEP_EWT::HandlePlayerEnter ( Player *  player )

overridevirtual

Reimplemented from OPvPCapturePoint.

{
    if (OPvPCapturePoint::HandlePlayerEnter(player))
    {
        player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
        uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f);
        player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
        player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_neutralValuePct);
        return true;
    }
    return false;
}

References EP_UI_TOWER_SLIDER_DISPLAY, EP_UI_TOWER_SLIDER_N, EP_UI_TOWER_SLIDER_POS, OPvPCapturePoint::HandlePlayerEnter(), OPvPCapturePoint::m_maxValue, OPvPCapturePoint::m_neutralValuePct, OPvPCapturePoint::m_value, and Player::SendUpdateWorldState().

HandlePlayerLeave()

void OPvPCapturePointEP_EWT::HandlePlayerLeave ( Player *  player )

overridevirtual

Reimplemented from OPvPCapturePoint.

{
    player->SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 0);
    OPvPCapturePoint::HandlePlayerLeave(player);
}

References EP_UI_TOWER_SLIDER_DISPLAY, OPvPCapturePoint::HandlePlayerLeave(), and Player::SendUpdateWorldState().

SendChangePhase()

void OPvPCapturePointEP_EWT::SendChangePhase ( )

overridevirtual

Reimplemented from OPvPCapturePoint.

{
    // send this too, sometimes the slider disappears, dunno why :(
    SendUpdateWorldState(EP_UI_TOWER_SLIDER_DISPLAY, 1);
    // send these updates to only the ones in this objective
    uint32 phase = (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f);
    SendUpdateWorldState(EP_UI_TOWER_SLIDER_POS, phase);
    // send this too, sometimes it resets :S
    SendUpdateWorldState(EP_UI_TOWER_SLIDER_N, m_neutralValuePct);
}

References EP_UI_TOWER_SLIDER_DISPLAY, EP_UI_TOWER_SLIDER_N, EP_UI_TOWER_SLIDER_POS, OPvPCapturePoint::m_maxValue, OPvPCapturePoint::m_neutralValuePct, OPvPCapturePoint::m_value, and OPvPCapturePoint::SendUpdateWorldState().

SummonSupportUnitAtNorthpassTower()

void OPvPCapturePointEP_EWT::SummonSupportUnitAtNorthpassTower ( TeamId  teamId )

protected

{
    if (m_UnitsSummonedSideId != teamId)
    {
        m_UnitsSummonedSideId = teamId;
        const creature_type* ct = teamId == TEAM_ALLIANCE ? EP_EWT_Summons_A : EP_EWT_Summons_H;
 
        for (uint8 i = 0; i < EP_EWT_NUM_CREATURES; ++i)
        {
            DelCreature(i);
            AddCreature(i, ct[i].entry, ct[i].map, ct[i].x, ct[i].y, ct[i].z, ct[i].o, 1000000);
        }
    }
}

References OPvPCapturePoint::AddCreature(), OPvPCapturePoint::DelCreature(), EP_EWT_NUM_CREATURES, EP_EWT_Summons_A, EP_EWT_Summons_H, m_UnitsSummonedSideId, and TEAM_ALLIANCE.

Referenced by ChangeState().

UpdateTowerState()

void OPvPCapturePointEP_EWT::UpdateTowerState ( )

protected

{
    m_PvP->SendUpdateWorldState(EP_EWT_A, bool(m_TowerState & EP_TS_A));
    m_PvP->SendUpdateWorldState(EP_EWT_H, bool(m_TowerState & EP_TS_H));
    m_PvP->SendUpdateWorldState(EP_EWT_N_A, bool(m_TowerState & EP_TS_N_A));
    m_PvP->SendUpdateWorldState(EP_EWT_N_H, bool(m_TowerState & EP_TS_N_H));
    m_PvP->SendUpdateWorldState(EP_EWT_N, bool(m_TowerState & EP_TS_N));
}

References EP_EWT_A, EP_EWT_H, EP_EWT_N, EP_EWT_N_A, EP_EWT_N_H, EP_TS_A, EP_TS_H, EP_TS_N, EP_TS_N_A, EP_TS_N_H, OPvPCapturePoint::m_PvP, m_TowerState, and OutdoorPvP::SendUpdateWorldState().

Referenced by ChangeState().

Member Data Documentation

m_TowerState

uint32 OPvPCapturePointEP_EWT::m_TowerState

protected

Referenced by ChangeState(), FillInitialWorldStates(), and UpdateTowerState().

m_UnitsSummonedSideId

TeamId OPvPCapturePointEP_EWT::m_UnitsSummonedSideId

protected

Referenced by SummonSupportUnitAtNorthpassTower().