BattlegroundEY Class Reference

#include "BattlegroundEY.h"

Inheritance diagram for BattlegroundEY:

Classes
struct	CapturePointInfo

Public Member Functions
	BattlegroundEY ()
	~BattlegroundEY () override
void	AddPlayer (Player *player) override
void	StartingEventCloseDoors () override
void	StartingEventOpenDoors () override
ObjectGuid	GetFlagPickerGUID (TeamId=TEAM_NEUTRAL) const override
void	SetFlagPicker (ObjectGuid guid)
uint8	GetFlagState () const
void	RespawnFlag ()
void	RespawnFlagAfterDrop ()
void	RemovePlayer (Player *player) override
void	HandleBuffUse (ObjectGuid buff_guid)
void	HandleAreaTrigger (Player *player, uint32 trigger) override
void	HandleKillPlayer (Player *player, Player *killer) override
GraveyardStruct const *	GetClosestGraveyard (Player *player) override
bool	SetupBattleground () override
void	Init () override
void	EndBattleground (TeamId winnerTeamId) override
bool	UpdatePlayerScore (Player *player, uint32 type, uint32 value, bool doAddHonor=true) override
void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &packet) override
void	SetDroppedFlagGUID (ObjectGuid guid, TeamId=TEAM_NEUTRAL) override
ObjectGuid	GetDroppedFlagGUID () const
void	EventPlayerClickedOnFlag (Player *player, GameObject *gameObject) override
void	EventPlayerDroppedFlag (Player *player) override
bool	AllNodesConrolledByTeam (TeamId teamId) const override
TeamId	GetPrematureWinner () override
Public Member Functions inherited from Battleground
	Battleground ()
virtual	~Battleground ()
void	Update (uint32 diff)
virtual void	ResetBGSubclass ()
virtual void	DestroyGate (Player *, GameObject *)
void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)
std::string	GetName () const
BattlegroundTypeId	GetBgTypeID (bool GetRandom=false) const
BattlegroundBracketId	GetBracketId () const
uint32	GetInstanceID () const
BattlegroundStatus	GetStatus () const
uint32	GetClientInstanceID () const
uint32	GetStartTime () const
uint32	GetEndTime () const
uint32	GetLastResurrectTime () const
uint32	GetMinLevel () const
uint32	GetMaxLevel () const
bool	isTemplate () const
bool	isMaxLevel () const
uint32	GetMaxPlayersPerTeam () const
uint32	GetMinPlayersPerTeam () const
int32	GetStartDelayTime () const
uint8	GetArenaType () const
PvPTeamId	GetWinner () const
uint32	GetScriptId () const
uint32	GetBonusHonorFromKill (uint32 kills) const
void	SpiritOfCompetitionEvent (PvPTeamId winnerTeamId) const
bool	IsRandom ()
void	SetName (std::string_view name)
void	SetBgTypeID (BattlegroundTypeId TypeID)
void	SetRandomTypeID (BattlegroundTypeId TypeID)
void	SetBracket (PvPDifficultyEntry const *bracketEntry)
void	SetInstanceID (uint32 InstanceID)
void	SetStatus (BattlegroundStatus Status)
void	SetClientInstanceID (uint32 InstanceID)
void	SetStartTime (uint32 Time)
void	SetEndTime (uint32 Time)
void	SetLastResurrectTime (uint32 Time)
void	SetLevelRange (uint32 min, uint32 max)
void	SetRated (bool state)
void	SetArenaType (uint8 type)
void	SetArenaorBGType (bool _isArena)
void	SetWinner (PvPTeamId winner)
void	SetScriptId (uint32 scriptId)
void	SetRandom (bool isRandom)
void	ModifyStartDelayTime (int32 diff)
void	SetStartDelayTime (int32 Time)
void	SetMaxPlayersPerTeam (uint32 MaxPlayers)
void	SetMinPlayersPerTeam (uint32 MinPlayers)
void	AddToBGFreeSlotQueue ()
void	RemoveFromBGFreeSlotQueue ()
void	DecreaseInvitedCount (TeamId teamId)
void	IncreaseInvitedCount (TeamId teamId)
uint32	GetInvitedCount (TeamId teamId) const
bool	HasFreeSlots () const
uint32	GetFreeSlotsForTeam (TeamId teamId) const
uint32	GetMaxFreeSlots () const
void	AddSpectator (Player *p)
void	RemoveSpectator (Player *p)
bool	HaveSpectators ()
const SpectatorList &	GetSpectators () const
void	AddToBeTeleported (ObjectGuid spectator, ObjectGuid participant)
void	RemoveToBeTeleported (ObjectGuid spectator)
void	SpectatorsSendPacket (WorldPacket &data)
bool	isArena () const
bool	isBattleground () const
bool	isRated () const
BattlegroundPlayerMap const &	GetPlayers () const
uint32	GetPlayersSize () const
void	ReadyMarkerClicked (Player *p)
BattlegroundScoreMap const *	GetPlayerScores () const
std::size_t	GetPlayerScoresSize () const
uint32	GetReviveQueueSize () const
void	AddPlayerToResurrectQueue (ObjectGuid npc_guid, ObjectGuid player_guid)
void	RemovePlayerFromResurrectQueue (Player *player)
void	RelocateDeadPlayers (ObjectGuid queueIndex)
	Relocate all players in ReviveQueue to the closest graveyard.
void	StartBattleground ()
GameObject *	GetBGObject (uint32 type)
Creature *	GetBGCreature (uint32 type)
void	SetMapId (uint32 MapID)
uint32	GetMapId () const
void	SetBgMap (BattlegroundMap *map)
BattlegroundMap *	GetBgMap () const
BattlegroundMap *	FindBgMap () const
void	SetTeamStartPosition (TeamId teamId, Position const &pos)
Position const *	GetTeamStartPosition (TeamId teamId) const
void	SetStartMaxDist (float startMaxDist)
float	GetStartMaxDist () const
void	SendPacketToTeam (TeamId teamId, WorldPacket const *packet, Player *sender=nullptr, bool self=true)
void	SendPacketToAll (WorldPacket const *packet)
void	YellToAll (Creature *creature, const char *text, uint32 language)
void	SendChatMessage (Creature *source, uint8 textId, WorldObject *target=nullptr)
void	SendBroadcastText (uint32 id, ChatMsg msgType, WorldObject const *target=nullptr)
template<class Do >
void	BroadcastWorker (Do &_do)
void	PlaySoundToAll (uint32 soundId)
void	CastSpellOnTeam (uint32 spellId, TeamId teamId)
void	RemoveAuraOnTeam (uint32 spellId, TeamId teamId)
void	RewardHonorToTeam (uint32 honor, TeamId teamId)
void	RewardReputationToTeam (uint32 factionId, uint32 reputation, TeamId teamId)
uint32	GetRealRepFactionForPlayer (uint32 factionId, Player *player)
void	UpdateWorldState (uint32 variable, uint32 value)
void	EndBattleground (PvPTeamId winnerTeamId)
void	BlockMovement (Player *player)
Group *	GetBgRaid (TeamId teamId) const
void	SetBgRaid (TeamId teamId, Group *bg_raid)
void	BuildPvPLogDataPacket (WorldPacket &data)
uint32	GetPlayersCountByTeam (TeamId teamId) const
uint32	GetAlivePlayersCountByTeam (TeamId teamId) const
void	UpdatePlayersCountByTeam (TeamId teamId, bool remove)
virtual void	CheckWinConditions ()
void	SetArenaTeamIdForTeam (TeamId teamId, uint32 ArenaTeamId)
uint32	GetArenaTeamIdForTeam (TeamId teamId) const
void	SetArenaMatchmakerRating (TeamId teamId, uint32 MMR)
uint32	GetArenaMatchmakerRating (TeamId teamId) const
virtual void	HandleKillUnit (Creature *, Player *)
virtual void	EventPlayerDamagedGO (Player *, GameObject *, uint32)
virtual void	EventPlayerUsedGO (Player *, GameObject *)
virtual void	DoAction (uint32, ObjectGuid)
virtual void	HandlePlayerResurrect (Player *)
void	AddOrSetPlayerToCorrectBgGroup (Player *player, TeamId teamId)
virtual void	RemovePlayerAtLeave (Player *player)
void	HandleTriggerBuff (GameObject *gameObject)
void	SetHoliday (bool is_holiday)
void	SpawnBGObject (uint32 type, uint32 respawntime, uint32 forceRespawnDelay=0)
bool	AddObject (uint32 type, uint32 entry, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime=0, GOState goState=GO_STATE_READY)
Creature *	AddCreature (uint32 entry, uint32 type, float x, float y, float z, float o, uint32 respawntime=0, MotionTransport *transport=nullptr)
bool	DelCreature (uint32 type)
bool	DelObject (uint32 type)
bool	AddSpiritGuide (uint32 type, float x, float y, float z, float o, TeamId teamId)
int32	GetObjectType (ObjectGuid guid)
void	DoorOpen (uint32 type)
void	DoorClose (uint32 type)
virtual bool	HandlePlayerUnderMap (Player *)
bool	IsPlayerInBattleground (ObjectGuid guid) const
bool	ToBeDeleted () const
void	RewardXPAtKill (Player *killer, Player *victim)
uint32	GetTeamScore (TeamId teamId) const
uint8	GetUniqueBracketId () const
BattlegroundAV *	ToBattlegroundAV ()
BattlegroundAV const *	ToBattlegroundAV () const
BattlegroundWS *	ToBattlegroundWS ()
BattlegroundWS const *	ToBattlegroundWS () const
BattlegroundAB *	ToBattlegroundAB ()
BattlegroundAB const *	ToBattlegroundAB () const
BattlegroundNA *	ToBattlegroundNA ()
BattlegroundNA const *	ToBattlegroundNA () const
BattlegroundBE *	ToBattlegroundBE ()
BattlegroundBE const *	ToBattlegroundBE () const
BattlegroundEY *	ToBattlegroundEY ()
BattlegroundEY const *	ToBattlegroundEY () const
BattlegroundRL *	ToBattlegroundRL ()
BattlegroundRL const *	ToBattlegroundRL () const
BattlegroundSA *	ToBattlegroundSA ()
BattlegroundSA const *	ToBattlegroundSA () const
BattlegroundDS *	ToBattlegroundDS ()
BattlegroundDS const *	ToBattlegroundDS () const
BattlegroundRV *	ToBattlegroundRV ()
BattlegroundRV const *	ToBattlegroundRV () const
BattlegroundIC *	ToBattlegroundIC ()
BattlegroundIC const *	ToBattlegroundIC () const

Private Member Functions
void	PostUpdateImpl (uint32 diff) override
	Post-update hook.
void	EventPlayerCapturedFlag (Player *Source, uint32 BgObjectType)
void	EventTeamLostPoint (Player *player, uint32 point)
void	EventTeamCapturedPoint (Player *player, TeamId teamId, uint32 point)
void	UpdatePointsCount ()
void	UpdatePointsIcons (uint32 point)
void	UpdatePointsState ()
void	AddPoints (TeamId teamId, uint32 points)

Private Attributes
CapturePointInfo	_capturePointInfo [EY_POINTS_MAX]
EventMap	_bgEvents
uint32	_honorTics
uint8	_ownedPointsCount [PVP_TEAMS_COUNT]
ObjectGuid	_flagKeeperGUID
ObjectGuid	_droppedFlagGUID
uint8	_flagState
uint32	_flagCapturedObject
uint32	_configurableMaxTeamScore

Additional Inherited Members
Public Types inherited from Battleground
typedef std::set< Player * >	SpectatorList
typedef std::map< ObjectGuid, ObjectGuid >	ToBeTeleportedMap
typedef std::map< ObjectGuid, Player * >	BattlegroundPlayerMap
typedef std::unordered_map< ObjectGuid::LowType, BattlegroundScore * >	BattlegroundScoreMap
typedef std::unordered_map< ObjectGuid, ArenaLogEntryData >	ArenaLogEntryDataMap
typedef GuidVector	BGObjects
typedef GuidVector	BGCreatures
Static Public Member Functions inherited from Battleground
static TeamId	GetOtherTeamId (TeamId teamId)
Public Attributes inherited from Battleground
GuidSet	readyMarkerClickedSet
ArenaLogEntryDataMap	ArenaLogEntries
BGObjects	BgObjects
BGCreatures	BgCreatures
Protected Member Functions inherited from Battleground
void	EndNow ()
void	PlayerAddedToBGCheckIfBGIsRunning (Player *player)
void	_ProcessResurrect (uint32 diff)
void	_ProcessProgress (uint32 diff)
void	_ProcessLeave (uint32 diff)
void	_ProcessJoin (uint32 diff)
void	_CheckSafePositions (uint32 diff)
Protected Attributes inherited from Battleground
BattlegroundScoreMap	PlayerScores
BattlegroundPlayerMap	m_Players
std::map< ObjectGuid, GuidVector >	m_ReviveQueue
uint8	m_Events
BattlegroundStartTimeIntervals	StartDelayTimes [BG_STARTING_EVENT_COUNT]
uint32	StartMessageIds [BG_STARTING_EVENT_COUNT]
bool	m_BuffChange
bool	m_IsRandom
BGHonorMode	m_HonorMode
int32	m_TeamScores [PVP_TEAMS_COUNT]
ArenaTeamScore	_arenaTeamScores [PVP_TEAMS_COUNT]
uint32	m_UpdateTimer
EventProcessor	_reviveEvents

Detailed Description

Constructor & Destructor Documentation

BattlegroundEY()

BattlegroundEY::BattlegroundEY

(

)

{
    m_BuffChange = true;
    BgObjects.resize(BG_EY_OBJECT_MAX);
    BgCreatures.resize(BG_EY_CREATURES_MAX);
 
    _capturePointInfo[POINT_FEL_REAVER]._areaTrigger = AT_FEL_REAVER_BUFF;
    _capturePointInfo[POINT_BLOOD_ELF]._areaTrigger = AT_BLOOD_ELF_BUFF;
    _capturePointInfo[POINT_DRAENEI_RUINS]._areaTrigger = AT_DRAENEI_RUINS_BUFF;
    _capturePointInfo[POINT_MAGE_TOWER]._areaTrigger = AT_MAGE_TOWER_BUFF;
    _honorTics = 0;
    _ownedPointsCount[TEAM_ALLIANCE] = 0;
    _ownedPointsCount[TEAM_HORDE] = 0;
    _flagState = BG_EY_FLAG_STATE_ON_BASE;
    _flagCapturedObject = 0;
}

References BattlegroundEY::CapturePointInfo::_areaTrigger, _capturePointInfo, _flagCapturedObject, _flagState, _honorTics, _ownedPointsCount, AT_BLOOD_ELF_BUFF, AT_DRAENEI_RUINS_BUFF, AT_FEL_REAVER_BUFF, AT_MAGE_TOWER_BUFF, BG_EY_CREATURES_MAX, BG_EY_FLAG_STATE_ON_BASE, BG_EY_OBJECT_MAX, Battleground::BgCreatures, Battleground::BgObjects, Battleground::m_BuffChange, POINT_BLOOD_ELF, POINT_DRAENEI_RUINS, POINT_FEL_REAVER, POINT_MAGE_TOWER, TEAM_ALLIANCE, and TEAM_HORDE.

~BattlegroundEY()

BattlegroundEY::~BattlegroundEY ( )

override

{
}

Member Function Documentation

AddPlayer()

void BattlegroundEY::AddPlayer ( Player *  player )

overridevirtual

Reimplemented from Battleground.

{
    Battleground::AddPlayer(player);
    PlayerScores.emplace(player->GetGUID().GetCounter(), new BattlegroundEYScore(player->GetGUID()));
}

References Battleground::AddPlayer(), ObjectGuid::GetCounter(), Object::GetGUID(), and Battleground::PlayerScores.

AddPoints()

void BattlegroundEY::AddPoints ( TeamId  teamId, uint32  points  )

private

{
    uint8 honorRewards = uint8(m_TeamScores[teamId] / _honorTics);
    m_TeamScores[teamId] += points;
    if (m_TeamScores[teamId] > static_cast<int32>(_configurableMaxTeamScore))
        m_TeamScores[teamId] = _configurableMaxTeamScore;
 
    for (; honorRewards < uint8(m_TeamScores[teamId] / _honorTics); ++honorRewards)
        RewardHonorToTeam(GetBonusHonorFromKill(1), teamId);
 
    UpdateWorldState(teamId == TEAM_ALLIANCE ? WORLD_STATE_BATTLEGROUND_EY_ALLIANCE_RESOURCES : WORLD_STATE_BATTLEGROUND_EY_HORDE_RESOURCES, std::min<uint32>(m_TeamScores[teamId], _configurableMaxTeamScore));
    if (m_TeamScores[teamId] >= static_cast<int32>(_configurableMaxTeamScore))
        EndBattleground(teamId);
}

References _configurableMaxTeamScore, _honorTics, EndBattleground(), Battleground::GetBonusHonorFromKill(), Battleground::m_TeamScores, Battleground::RewardHonorToTeam(), TEAM_ALLIANCE, Battleground::UpdateWorldState(), WORLD_STATE_BATTLEGROUND_EY_ALLIANCE_RESOURCES, and WORLD_STATE_BATTLEGROUND_EY_HORDE_RESOURCES.

Referenced by EventPlayerCapturedFlag(), and PostUpdateImpl().

AllNodesConrolledByTeam()

bool BattlegroundEY::AllNodesConrolledByTeam ( TeamId  teamId ) const

overridevirtual

Reimplemented from Battleground.

{
    uint32 count = 0;
    for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
        if (_capturePointInfo[i].IsUnderControl(teamId))
            ++count;
 
    return count == EY_POINTS_MAX;
}

References _capturePointInfo, and EY_POINTS_MAX.

EndBattleground()

void BattlegroundEY::EndBattleground ( TeamId  winnerTeamId )

overridevirtual

Deprecated:

need delete

Reimplemented from Battleground.

{
    RewardHonorToTeam(GetBonusHonorFromKill(1), winnerTeamId);
    RewardHonorToTeam(GetBonusHonorFromKill(1), TEAM_ALLIANCE);
    RewardHonorToTeam(GetBonusHonorFromKill(1), TEAM_HORDE);
    Battleground::EndBattleground(winnerTeamId);
}

References Battleground::EndBattleground(), Battleground::GetBonusHonorFromKill(), Battleground::RewardHonorToTeam(), TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by AddPoints().

EventPlayerCapturedFlag()

void BattlegroundEY::EventPlayerCapturedFlag ( Player *  Source, uint32  BgObjectType  )

private

{
    SetFlagPicker(ObjectGuid::Empty);
    _flagState = BG_EY_FLAG_STATE_ON_BASE;
    player->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
    player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 
    SpawnBGObject(BgObjectType, RESPAWN_IMMEDIATELY);
    _bgEvents.RescheduleEvent(BG_EY_EVENT_RESPAWN_FLAG, BG_EY_FLAG_RESPAWN_TIME);
    _flagCapturedObject = BgObjectType;
 
    if (player->GetTeamId() == TEAM_ALLIANCE)
    {
        PlaySoundToAll(BG_EY_SOUND_FLAG_CAPTURED_ALLIANCE);
        SendBroadcastText(BG_EY_TEXT_ALLIANCE_CAPTURED_FLAG, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
    }
    else
    {
        PlaySoundToAll(BG_EY_SOUND_FLAG_CAPTURED_HORDE);
        SendBroadcastText(BG_EY_TEXT_HORDE_CAPTURED_FLAG, CHAT_MSG_BG_SYSTEM_HORDE, player);
    }
 
    UpdatePlayerScore(player, SCORE_FLAG_CAPTURES, 1);
    if (_ownedPointsCount[player->GetTeamId()] > 0)
        AddPoints(player->GetTeamId(), BG_EY_FlagPoints[_ownedPointsCount[player->GetTeamId()] - 1]);
}

References _bgEvents, _flagCapturedObject, _flagState, _ownedPointsCount, AddPoints(), AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT, BG_EY_EVENT_RESPAWN_FLAG, BG_EY_FLAG_RESPAWN_TIME, BG_EY_FLAG_STATE_ON_BASE, BG_EY_FlagPoints, BG_EY_NETHERSTORM_FLAG_SPELL, BG_EY_SOUND_FLAG_CAPTURED_ALLIANCE, BG_EY_SOUND_FLAG_CAPTURED_HORDE, BG_EY_TEXT_ALLIANCE_CAPTURED_FLAG, BG_EY_TEXT_HORDE_CAPTURED_FLAG, CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, ObjectGuid::Empty, Player::GetTeamId(), Battleground::PlaySoundToAll(), Unit::RemoveAurasDueToSpell(), Unit::RemoveAurasWithInterruptFlags(), EventMap::RescheduleEvent(), RESPAWN_IMMEDIATELY, SCORE_FLAG_CAPTURES, Battleground::SendBroadcastText(), SetFlagPicker(), Battleground::SpawnBGObject(), TEAM_ALLIANCE, and UpdatePlayerScore().

Referenced by HandleAreaTrigger().

EventPlayerClickedOnFlag()

void BattlegroundEY::EventPlayerClickedOnFlag ( Player *  player, GameObject *  gameObject  )

overridevirtual

Reimplemented from Battleground.

{
    if (GetStatus() != STATUS_IN_PROGRESS || GetFlagPickerGUID() || !player->IsWithinDistInMap(gameObject, 10.0f))
        return;
 
    _flagState = BG_EY_FLAG_STATE_ON_PLAYER;
    SpawnBGObject(BG_EY_OBJECT_FLAG_NETHERSTORM, RESPAWN_ONE_DAY);
    SetFlagPicker(player->GetGUID());
    SetDroppedFlagGUID(ObjectGuid::Empty);
 
    player->CastSpell(player, BG_EY_NETHERSTORM_FLAG_SPELL, true);
    player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 
    PlaySoundToAll(player->GetTeamId() == TEAM_ALLIANCE ? BG_EY_SOUND_FLAG_PICKED_UP_ALLIANCE : BG_EY_SOUND_FLAG_PICKED_UP_HORDE);
    UpdateWorldState(WORLD_STATE_BATTLEGROUND_EY_FLAG, 0);
 
    if (player->GetTeamId() == TEAM_ALLIANCE)
        SendBroadcastText(BG_EY_TEXT_TAKEN_FLAG, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
    else
        SendBroadcastText(BG_EY_TEXT_TAKEN_FLAG, CHAT_MSG_BG_SYSTEM_HORDE, player);
}

References _flagState, AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT, BG_EY_FLAG_STATE_ON_PLAYER, BG_EY_NETHERSTORM_FLAG_SPELL, BG_EY_OBJECT_FLAG_NETHERSTORM, BG_EY_SOUND_FLAG_PICKED_UP_ALLIANCE, BG_EY_SOUND_FLAG_PICKED_UP_HORDE, BG_EY_TEXT_TAKEN_FLAG, Unit::CastSpell(), CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, ObjectGuid::Empty, GetFlagPickerGUID(), Object::GetGUID(), Battleground::GetStatus(), Player::GetTeamId(), WorldObject::IsWithinDistInMap(), Battleground::PlaySoundToAll(), Unit::RemoveAurasWithInterruptFlags(), RESPAWN_ONE_DAY, Battleground::SendBroadcastText(), SetDroppedFlagGUID(), SetFlagPicker(), Battleground::SpawnBGObject(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, Battleground::UpdateWorldState(), and WORLD_STATE_BATTLEGROUND_EY_FLAG.

EventPlayerDroppedFlag()

void BattlegroundEY::EventPlayerDroppedFlag ( Player *  player )

overridevirtual

Reimplemented from Battleground.

{
    if (GetFlagPickerGUID() != player->GetGUID())
        return;
 
    SetFlagPicker(ObjectGuid::Empty);
    player->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
    _flagState = BG_EY_FLAG_STATE_ON_GROUND;
    _bgEvents.RescheduleEvent(BG_EY_EVENT_FLAG_ON_GROUND, BG_EY_FLAG_ON_GROUND_TIME);
 
    player->CastSpell(player, SPELL_RECENTLY_DROPPED_FLAG, true);
    player->CastSpell(player, BG_EY_PLAYER_DROPPED_FLAG_SPELL, true);
 
    if (player->GetTeamId() == TEAM_ALLIANCE)
        SendBroadcastText(BG_EY_TEXT_FLAG_DROPPED, CHAT_MSG_BG_SYSTEM_ALLIANCE);
    else
        SendBroadcastText(BG_EY_TEXT_FLAG_DROPPED, CHAT_MSG_BG_SYSTEM_HORDE);
}

References _bgEvents, _flagState, BG_EY_EVENT_FLAG_ON_GROUND, BG_EY_FLAG_ON_GROUND_TIME, BG_EY_FLAG_STATE_ON_GROUND, BG_EY_NETHERSTORM_FLAG_SPELL, BG_EY_PLAYER_DROPPED_FLAG_SPELL, BG_EY_TEXT_FLAG_DROPPED, Unit::CastSpell(), CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, ObjectGuid::Empty, GetFlagPickerGUID(), Object::GetGUID(), Battleground::GetStatus(), Player::GetTeamId(), Unit::RemoveAurasDueToSpell(), EventMap::RescheduleEvent(), Battleground::SendBroadcastText(), SetFlagPicker(), SPELL_RECENTLY_DROPPED_FLAG, STATUS_IN_PROGRESS, and TEAM_ALLIANCE.

Referenced by HandleKillPlayer(), and RemovePlayer().

EventTeamCapturedPoint()

void BattlegroundEY::EventTeamCapturedPoint ( Player *  player, TeamId  teamId, uint32  point  )

private

{
    SpawnBGObject(m_CapturingPointTypes[point].DespawnNeutralObjectType, RESPAWN_ONE_DAY);
    SpawnBGObject(m_CapturingPointTypes[point].DespawnNeutralObjectType + 1, RESPAWN_ONE_DAY);
    SpawnBGObject(m_CapturingPointTypes[point].DespawnNeutralObjectType + 2, RESPAWN_ONE_DAY);
 
    if (teamId == TEAM_ALLIANCE)
    {
        _ownedPointsCount[TEAM_ALLIANCE]++;
        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeAlliance, RESPAWN_IMMEDIATELY);
        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeAlliance + 1, RESPAWN_IMMEDIATELY);
        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeAlliance + 2, RESPAWN_IMMEDIATELY);
        SendBroadcastText(m_CapturingPointTypes[point].MessageIdAlliance, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
    }
    else
    {
        _ownedPointsCount[TEAM_HORDE]++;
        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeHorde, RESPAWN_IMMEDIATELY);
        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeHorde + 1, RESPAWN_IMMEDIATELY);
        SpawnBGObject(m_CapturingPointTypes[point].SpawnObjectTypeHorde + 2, RESPAWN_IMMEDIATELY);
        SendBroadcastText(m_CapturingPointTypes[point].MessageIdHorde, CHAT_MSG_BG_SYSTEM_HORDE, player);
    }
 
    _capturePointInfo[point]._ownerTeamId = teamId;
 
    GraveyardStruct const* sg = sGraveyard->GetGraveyard(m_CapturingPointTypes[point].GraveyardId);
    AddSpiritGuide(point, sg->x, sg->y, sg->z, 3.124139f, teamId);
 
    UpdatePointsIcons(point);
    UpdatePointsCount();
 
    // Xinef: done this way to avoid errors in console
    Creature* trigger = GetBgMap()->GetCreature(BgCreatures[BG_EY_TRIGGER_FEL_REAVER + point]);
    if (!trigger)
        trigger = AddCreature(WORLD_TRIGGER, BG_EY_TRIGGER_FEL_REAVER + point, BG_EY_TriggerPositions[point][0], BG_EY_TriggerPositions[point][1], BG_EY_TriggerPositions[point][2], BG_EY_TriggerPositions[point][3]);
 
    if (trigger)
    {
        trigger->SetFaction(teamId == TEAM_ALLIANCE ? FACTION_ALLIANCE_GENERIC : FACTION_HORDE_GENERIC);
        trigger->CastSpell(trigger, SPELL_HONORABLE_DEFENDER_25Y, true);
    }
}

References _capturePointInfo, _ownedPointsCount, BattlegroundEY::CapturePointInfo::_ownerTeamId, Battleground::AddCreature(), Battleground::AddSpiritGuide(), BG_EY_TRIGGER_FEL_REAVER, BG_EY_TriggerPositions, Battleground::BgCreatures, Unit::CastSpell(), CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, FACTION_ALLIANCE_GENERIC, FACTION_HORDE_GENERIC, Battleground::GetBgMap(), Map::GetCreature(), m_CapturingPointTypes, RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, Battleground::SendBroadcastText(), Unit::SetFaction(), sGraveyard, Battleground::SpawnBGObject(), SPELL_HONORABLE_DEFENDER_25Y, TEAM_ALLIANCE, TEAM_HORDE, UpdatePointsCount(), UpdatePointsIcons(), WORLD_TRIGGER, GraveyardStruct::x, GraveyardStruct::y, and GraveyardStruct::z.

Referenced by UpdatePointsState().

EventTeamLostPoint()

void BattlegroundEY::EventTeamLostPoint ( Player *  player, uint32  point  )

private

{
    TeamId oldTeamId = _capturePointInfo[point]._ownerTeamId;
    if (oldTeamId == TEAM_ALLIANCE)
    {
        _ownedPointsCount[TEAM_ALLIANCE]--;
        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeAlliance, RESPAWN_ONE_DAY);
        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeAlliance + 1, RESPAWN_ONE_DAY);
        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeAlliance + 2, RESPAWN_ONE_DAY);
        SendBroadcastText(m_LosingPointTypes[point].MessageIdAlliance, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
    }
    else
    {
        _ownedPointsCount[TEAM_HORDE]--;
        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeHorde, RESPAWN_ONE_DAY);
        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeHorde + 1, RESPAWN_ONE_DAY);
        SpawnBGObject(m_LosingPointTypes[point].DespawnObjectTypeHorde + 2, RESPAWN_ONE_DAY);
        SendBroadcastText(m_LosingPointTypes[point].MessageIdHorde, CHAT_MSG_BG_SYSTEM_HORDE, player);
    }
 
    SpawnBGObject(m_LosingPointTypes[point].SpawnNeutralObjectType, RESPAWN_IMMEDIATELY);
    SpawnBGObject(m_LosingPointTypes[point].SpawnNeutralObjectType + 1, RESPAWN_IMMEDIATELY);
    SpawnBGObject(m_LosingPointTypes[point].SpawnNeutralObjectType + 2, RESPAWN_IMMEDIATELY);
 
    _capturePointInfo[point]._ownerTeamId = TEAM_NEUTRAL;
 
    UpdatePointsIcons(point);
    UpdatePointsCount();
    DelCreature(BG_EY_TRIGGER_FEL_REAVER + point);
 
    _reviveEvents.AddEventAtOffset([this, point]()
    {
        RelocateDeadPlayers(BgCreatures[point]);
        DelCreature(point);
    }, 500ms);
}

References _capturePointInfo, _ownedPointsCount, BattlegroundEY::CapturePointInfo::_ownerTeamId, Battleground::_reviveEvents, EventProcessor::AddEventAtOffset(), BG_EY_TRIGGER_FEL_REAVER, Battleground::BgCreatures, CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, Battleground::DelCreature(), m_LosingPointTypes, Battleground::RelocateDeadPlayers(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, Battleground::SendBroadcastText(), Battleground::SpawnBGObject(), TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, UpdatePointsCount(), and UpdatePointsIcons().

Referenced by UpdatePointsState().

FillInitialWorldStates()

void BattlegroundEY::FillInitialWorldStates ( WorldPackets::WorldState::InitWorldStates &  packet )

overridevirtual

Reimplemented from Battleground.

{
    packet.Worldstates.reserve(22);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_HORDE_BASE, _ownedPointsCount[TEAM_HORDE]);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_ALLIANCE_BASE, _ownedPointsCount[TEAM_ALLIANCE]);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_DRAENEI_RUINS_HORDE_CONTROL, _capturePointInfo[POINT_DRAENEI_RUINS].IsUnderControl(TEAM_HORDE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_DRAENEI_RUINS_ALLIANCE_CONTROL, _capturePointInfo[POINT_DRAENEI_RUINS].IsUnderControl(TEAM_ALLIANCE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_DRAENEI_RUINS_UNCONTROL, _capturePointInfo[POINT_DRAENEI_RUINS].IsUncontrolled());
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_MAGE_TOWER_ALLIANCE_CONTROL, _capturePointInfo[POINT_MAGE_TOWER].IsUnderControl(TEAM_HORDE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_MAGE_TOWER_HORDE_CONTROL, _capturePointInfo[POINT_MAGE_TOWER].IsUnderControl(TEAM_ALLIANCE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_MAGE_TOWER_UNCONTROL, _capturePointInfo[POINT_MAGE_TOWER].IsUncontrolled());
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_FEL_REAVER_HORDE_CONTROL, _capturePointInfo[POINT_FEL_REAVER].IsUnderControl(TEAM_HORDE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_FEL_REAVER_ALLIANCE_CONTROL, _capturePointInfo[POINT_FEL_REAVER].IsUnderControl(TEAM_ALLIANCE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_FEL_REAVER_UNCONTROL, _capturePointInfo[POINT_FEL_REAVER].IsUncontrolled());
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_BLOOD_ELF_HORDE_CONTROL, _capturePointInfo[POINT_BLOOD_ELF].IsUnderControl(TEAM_HORDE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_BLOOD_ELF_ALLIANCE_CONTROL, _capturePointInfo[POINT_BLOOD_ELF].IsUnderControl(TEAM_ALLIANCE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_BLOOD_ELF_UNCONTROL, _capturePointInfo[POINT_BLOOD_ELF].IsUncontrolled());
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_FLAG, _flagState == BG_EY_FLAG_STATE_ON_BASE);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_FLAG_STATE_HORDE, 1);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_FLAG_STATE_ALLIANCE, 1);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_HORDE_RESOURCES, GetTeamScore(TEAM_HORDE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_ALLIANCE_RESOURCES, GetTeamScore(TEAM_ALLIANCE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_SHOW, 0);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_PERCENT_GREY, 0);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_STATUS, 0);
}

References _capturePointInfo, _flagState, _ownedPointsCount, BG_EY_FLAG_STATE_ON_BASE, Battleground::GetTeamScore(), POINT_BLOOD_ELF, POINT_DRAENEI_RUINS, POINT_FEL_REAVER, POINT_MAGE_TOWER, TEAM_ALLIANCE, TEAM_HORDE, WORLD_STATE_BATTLEGROUND_EY_ALLIANCE_BASE, WORLD_STATE_BATTLEGROUND_EY_ALLIANCE_RESOURCES, WORLD_STATE_BATTLEGROUND_EY_BLOOD_ELF_ALLIANCE_CONTROL, WORLD_STATE_BATTLEGROUND_EY_BLOOD_ELF_HORDE_CONTROL, WORLD_STATE_BATTLEGROUND_EY_BLOOD_ELF_UNCONTROL, WORLD_STATE_BATTLEGROUND_EY_DRAENEI_RUINS_ALLIANCE_CONTROL, WORLD_STATE_BATTLEGROUND_EY_DRAENEI_RUINS_HORDE_CONTROL, WORLD_STATE_BATTLEGROUND_EY_DRAENEI_RUINS_UNCONTROL, WORLD_STATE_BATTLEGROUND_EY_FEL_REAVER_ALLIANCE_CONTROL, WORLD_STATE_BATTLEGROUND_EY_FEL_REAVER_HORDE_CONTROL, WORLD_STATE_BATTLEGROUND_EY_FEL_REAVER_UNCONTROL, WORLD_STATE_BATTLEGROUND_EY_FLAG, WORLD_STATE_BATTLEGROUND_EY_FLAG_STATE_ALLIANCE, WORLD_STATE_BATTLEGROUND_EY_FLAG_STATE_HORDE, WORLD_STATE_BATTLEGROUND_EY_HORDE_BASE, WORLD_STATE_BATTLEGROUND_EY_HORDE_RESOURCES, WORLD_STATE_BATTLEGROUND_EY_MAGE_TOWER_ALLIANCE_CONTROL, WORLD_STATE_BATTLEGROUND_EY_MAGE_TOWER_HORDE_CONTROL, WORLD_STATE_BATTLEGROUND_EY_MAGE_TOWER_UNCONTROL, WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_PERCENT_GREY, WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_SHOW, WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_STATUS, and WorldPackets::WorldState::InitWorldStates::Worldstates.

GetClosestGraveyard()

GraveyardStruct const * BattlegroundEY::GetClosestGraveyard ( Player *  player )

overridevirtual

Reimplemented from Battleground.

{
    GraveyardStruct const* entry = sGraveyard->GetGraveyard(static_cast<uint16>(BG_EY_GRAVEYARD_MAIN_ALLIANCE) + player->GetTeamId());
    GraveyardStruct const* nearestEntry = entry;
 
    float pX = player->GetPositionX();
    float pY = player->GetPositionY();
    float pZ = player->GetPositionZ();
    float dist = (entry->x - pX) * (entry->x - pX) + (entry->y - pY) * (entry->y - pY) + (entry->z - pZ) * (entry->z - pZ);
    float minDist = dist;
 
    for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
        if (_capturePointInfo[i].IsUnderControl(player->GetTeamId()))
        {
            entry = sGraveyard->GetGraveyard(m_CapturingPointTypes[i].GraveyardId);
            dist = (entry->x - pX) * (entry->x - pX) + (entry->y - pY) * (entry->y - pY) + (entry->z - pZ) * (entry->z - pZ);
            if (dist < minDist)
            {
                minDist = dist;
                nearestEntry = entry;
            }
        }
 
    return nearestEntry;
}

References _capturePointInfo, BG_EY_GRAVEYARD_MAIN_ALLIANCE, EY_POINTS_MAX, Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Player::GetTeamId(), m_CapturingPointTypes, sGraveyard, GraveyardStruct::x, GraveyardStruct::y, and GraveyardStruct::z.

GetDroppedFlagGUID()

ObjectGuid BattlegroundEY::GetDroppedFlagGUID ( ) const

inline

{ return _droppedFlagGUID; }

Referenced by RespawnFlagAfterDrop().

GetFlagPickerGUID()

ObjectGuid BattlegroundEY::GetFlagPickerGUID ( TeamId  = TEAM_NEUTRAL ) const

inlineoverridevirtual

Reimplemented from Battleground.

{ return _flagKeeperGUID; }

Referenced by EventPlayerClickedOnFlag(), EventPlayerDroppedFlag(), HandleAreaTrigger(), and RemovePlayer().

GetFlagState()

uint8 BattlegroundEY::GetFlagState ( ) const

inline

{ return _flagState; }

GetPrematureWinner()

TeamId BattlegroundEY::GetPrematureWinner ( )

overridevirtual

Reimplemented from Battleground.

{
    if (GetTeamScore(TEAM_ALLIANCE) > GetTeamScore(TEAM_HORDE))
        return TEAM_ALLIANCE;
 
    return GetTeamScore(TEAM_HORDE) > GetTeamScore(TEAM_ALLIANCE) ? TEAM_HORDE : Battleground::GetPrematureWinner();
}

References Battleground::GetPrematureWinner(), Battleground::GetTeamScore(), TEAM_ALLIANCE, and TEAM_HORDE.

HandleAreaTrigger()

void BattlegroundEY::HandleAreaTrigger ( Player *  player, uint32  trigger  )

overridevirtual

Reimplemented from Battleground.

{
    if (GetStatus() != STATUS_IN_PROGRESS || !player->IsAlive())
        return;
 
    switch (trigger)
    {
        case AT_BLOOD_ELF_POINT:
            if (_capturePointInfo[POINT_BLOOD_ELF].IsUnderControl(player->GetTeamId()))
                if (_flagState == BG_EY_FLAG_STATE_ON_PLAYER && GetFlagPickerGUID() == player->GetGUID())
                    EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_BLOOD_ELF);
            break;
        case AT_FEL_REAVER_POINT:
            if (_capturePointInfo[POINT_FEL_REAVER].IsUnderControl(player->GetTeamId()))
                if (_flagState == BG_EY_FLAG_STATE_ON_PLAYER && GetFlagPickerGUID() == player->GetGUID())
                    EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_FEL_REAVER);
            break;
        case AT_MAGE_TOWER_POINT:
            if (_capturePointInfo[POINT_MAGE_TOWER].IsUnderControl(player->GetTeamId()))
                if (_flagState == BG_EY_FLAG_STATE_ON_PLAYER && GetFlagPickerGUID() == player->GetGUID())
                    EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_MAGE_TOWER);
            break;
        case AT_DRAENEI_RUINS_POINT:
            if (_capturePointInfo[POINT_DRAENEI_RUINS].IsUnderControl(player->GetTeamId()))
                if (_flagState == BG_EY_FLAG_STATE_ON_PLAYER && GetFlagPickerGUID() == player->GetGUID())
                    EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_DRAENEI_RUINS);
            break;
        case 4512:
        case 4515:
        case 4517:
        case 4519:
        case 4530:
        case 4531:
        case 5866:
        case AT_BLOOD_ELF_BUFF:
        case AT_FEL_REAVER_BUFF:
        case AT_MAGE_TOWER_BUFF:
        case AT_DRAENEI_RUINS_BUFF:
            break;
    }
}

References _capturePointInfo, _flagState, AT_BLOOD_ELF_BUFF, AT_BLOOD_ELF_POINT, AT_DRAENEI_RUINS_BUFF, AT_DRAENEI_RUINS_POINT, AT_FEL_REAVER_BUFF, AT_FEL_REAVER_POINT, AT_MAGE_TOWER_BUFF, AT_MAGE_TOWER_POINT, BG_EY_FLAG_STATE_ON_PLAYER, BG_EY_OBJECT_FLAG_BLOOD_ELF, BG_EY_OBJECT_FLAG_DRAENEI_RUINS, BG_EY_OBJECT_FLAG_FEL_REAVER, BG_EY_OBJECT_FLAG_MAGE_TOWER, EventPlayerCapturedFlag(), GetFlagPickerGUID(), Object::GetGUID(), Battleground::GetStatus(), Player::GetTeamId(), Unit::IsAlive(), POINT_BLOOD_ELF, POINT_DRAENEI_RUINS, POINT_FEL_REAVER, POINT_MAGE_TOWER, and STATUS_IN_PROGRESS.

Referenced by UpdatePointsState().

HandleBuffUse()

void BattlegroundEY::HandleBuffUse

(

ObjectGuid

buff_guid

)

HandleKillPlayer()

void BattlegroundEY::HandleKillPlayer ( Player *  player, Player *  killer  )

overridevirtual

Reimplemented from Battleground.

{
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
    Battleground::HandleKillPlayer(player, killer);
    EventPlayerDroppedFlag(player);
}

References EventPlayerDroppedFlag(), Battleground::GetStatus(), Battleground::HandleKillPlayer(), and STATUS_IN_PROGRESS.

Init()

void BattlegroundEY::Init ( )

overridevirtual

Reimplemented from Battleground.

{
    //call parent's class reset
    Battleground::Init();
 
    _bgEvents.Reset();
    _honorTics = BattlegroundMgr::IsBGWeekend(GetBgTypeID(true)) ? BG_EY_HONOR_TICK_WEEKEND : BG_EY_HONOR_TICK_NORMAL;
    _ownedPointsCount[TEAM_ALLIANCE] = 0;
    _ownedPointsCount[TEAM_HORDE] = 0;
    _flagKeeperGUID.Clear();
    _droppedFlagGUID.Clear();
    _flagState = BG_EY_FLAG_STATE_ON_BASE;
    _flagCapturedObject = 0;
 
    uint32 bgEyCapturePointsConfig = sWorld->getIntConfig(CONFIG_BATTLEGROUND_EYEOFTHESTORM_CAPTUREPOINTS);
    _configurableMaxTeamScore = bgEyCapturePointsConfig > 0
        ? bgEyCapturePointsConfig
        : static_cast<uint32>(BG_EY_MAX_TEAM_SCORE);
}

References _bgEvents, _configurableMaxTeamScore, _droppedFlagGUID, _flagCapturedObject, _flagKeeperGUID, _flagState, _honorTics, _ownedPointsCount, BG_EY_FLAG_STATE_ON_BASE, BG_EY_HONOR_TICK_NORMAL, BG_EY_HONOR_TICK_WEEKEND, BG_EY_MAX_TEAM_SCORE, ObjectGuid::Clear(), CONFIG_BATTLEGROUND_EYEOFTHESTORM_CAPTUREPOINTS, Battleground::GetBgTypeID(), Battleground::Init(), BattlegroundMgr::IsBGWeekend(), EventMap::Reset(), sWorld, TEAM_ALLIANCE, and TEAM_HORDE.

PostUpdateImpl()

void BattlegroundEY::PostUpdateImpl ( uint32  )

overrideprivatevirtual

Post-update hook.

Will be called after battleground update has passed. May be used to implement custom update effects in subclasses.

Parameters

diff	a time difference between two worldserver update loops in milliseconds.

See also

Update(), PreUpdateImpl().

Reimplemented from Battleground.

{
    if (GetStatus() == STATUS_IN_PROGRESS)
    {
        _bgEvents.Update(diff);
        while (uint32 eventId = _bgEvents.ExecuteEvent())
            switch (eventId)
            {
                case BG_EY_EVENT_ADD_POINTS:
                    if (_ownedPointsCount[TEAM_ALLIANCE] > 0)
                        AddPoints(TEAM_ALLIANCE, BG_EY_TickPoints[_ownedPointsCount[TEAM_ALLIANCE] - 1]);
                    if (_ownedPointsCount[TEAM_HORDE] > 0)
                        AddPoints(TEAM_HORDE, BG_EY_TickPoints[_ownedPointsCount[TEAM_HORDE] - 1]);
                    _bgEvents.ScheduleEvent(BG_EY_EVENT_ADD_POINTS, BG_EY_FPOINTS_TICK_TIME - (GameTime::GetGameTimeMS().count() % BG_EY_FPOINTS_TICK_TIME));
                    break;
                case BG_EY_EVENT_FLAG_ON_GROUND:
                    RespawnFlagAfterDrop();
                    break;
                case BG_EY_EVENT_RESPAWN_FLAG:
                    RespawnFlag();
                    break;
                case BG_EY_EVENT_CHECK_CPOINTS:
                    UpdatePointsState();
                    _bgEvents.ScheduleEvent(BG_EY_EVENT_CHECK_CPOINTS, BG_EY_FPOINTS_CHECK_TIME - (GameTime::GetGameTimeMS().count() % BG_EY_FPOINTS_CHECK_TIME));
                    break;
            }
    }
}

References _bgEvents, _ownedPointsCount, AddPoints(), BG_EY_EVENT_ADD_POINTS, BG_EY_EVENT_CHECK_CPOINTS, BG_EY_EVENT_FLAG_ON_GROUND, BG_EY_EVENT_RESPAWN_FLAG, BG_EY_FPOINTS_CHECK_TIME, BG_EY_FPOINTS_TICK_TIME, BG_EY_TickPoints, EventMap::ExecuteEvent(), GameTime::GetGameTimeMS(), Battleground::GetStatus(), RespawnFlag(), RespawnFlagAfterDrop(), EventMap::ScheduleEvent(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, EventMap::Update(), and UpdatePointsState().

RemovePlayer()

void BattlegroundEY::RemovePlayer ( Player *  player )

overridevirtual

Reimplemented from Battleground.

{
    if (GetFlagPickerGUID() == player->GetGUID())
        EventPlayerDroppedFlag(player);
}

References EventPlayerDroppedFlag(), GetFlagPickerGUID(), and Object::GetGUID().

RespawnFlag()

void BattlegroundEY::RespawnFlag

(

)

{
    if (_flagState != BG_EY_FLAG_STATE_ON_BASE)
        return;
 
    if (_flagCapturedObject > 0)
        SpawnBGObject(_flagCapturedObject, RESPAWN_ONE_DAY);
 
    _flagCapturedObject = 0;
    SpawnBGObject(BG_EY_OBJECT_FLAG_NETHERSTORM, RESPAWN_IMMEDIATELY);
 
    SendBroadcastText(BG_EY_TEXT_FLAG_RESET, CHAT_MSG_BG_SYSTEM_NEUTRAL);
    PlaySoundToAll(BG_EY_SOUND_FLAG_RESET);
    UpdateWorldState(WORLD_STATE_BATTLEGROUND_EY_FLAG, 1);
}

References _flagCapturedObject, _flagState, BG_EY_FLAG_STATE_ON_BASE, BG_EY_OBJECT_FLAG_NETHERSTORM, BG_EY_SOUND_FLAG_RESET, BG_EY_TEXT_FLAG_RESET, CHAT_MSG_BG_SYSTEM_NEUTRAL, Battleground::PlaySoundToAll(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, Battleground::SendBroadcastText(), Battleground::SpawnBGObject(), Battleground::UpdateWorldState(), and WORLD_STATE_BATTLEGROUND_EY_FLAG.

Referenced by PostUpdateImpl(), and RespawnFlagAfterDrop().

RespawnFlagAfterDrop()

void BattlegroundEY::RespawnFlagAfterDrop

(

)

{
    if (_flagState != BG_EY_FLAG_STATE_ON_GROUND)
        return;
 
    _flagState = BG_EY_FLAG_STATE_ON_BASE;
    RespawnFlag();
    if (GameObject* flag = FindBgMap()->GetGameObject(GetDroppedFlagGUID()))
        flag->Delete();
    SetDroppedFlagGUID(ObjectGuid::Empty);
}

References _flagState, BG_EY_FLAG_STATE_ON_BASE, BG_EY_FLAG_STATE_ON_GROUND, ObjectGuid::Empty, Battleground::FindBgMap(), GetDroppedFlagGUID(), RespawnFlag(), and SetDroppedFlagGUID().

Referenced by PostUpdateImpl().

SetDroppedFlagGUID()

void BattlegroundEY::SetDroppedFlagGUID ( ObjectGuid  guid, TeamId  = TEAM_NEUTRAL  )

inlineoverridevirtual

Reimplemented from Battleground.

{ _droppedFlagGUID = guid; }

Referenced by EventPlayerClickedOnFlag(), and RespawnFlagAfterDrop().

SetFlagPicker()

void BattlegroundEY::SetFlagPicker ( ObjectGuid  guid )

inline

{ _flagKeeperGUID = guid; }

Referenced by EventPlayerCapturedFlag(), EventPlayerClickedOnFlag(), and EventPlayerDroppedFlag().

SetupBattleground()

bool BattlegroundEY::SetupBattleground ( )

overridevirtual

Reimplemented from Battleground.

{
    // doors
    AddObject(BG_EY_OBJECT_DOOR_A, BG_OBJECT_A_DOOR_EY_ENTRY, 2527.6f, 1596.91f, 1262.13f, -3.12414f, -0.173642f, -0.001515f, 0.98477f, -0.008594f, RESPAWN_IMMEDIATELY);
    AddObject(BG_EY_OBJECT_DOOR_H, BG_OBJECT_H_DOOR_EY_ENTRY, 1803.21f, 1539.49f, 1261.09f, 3.14159f, 0.173648f, 0, 0.984808f, 0, RESPAWN_IMMEDIATELY);
    // banners (alliance)
    AddObject(BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_FEL_REAVER_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_FEL_REAVER_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY);
    // banners (horde)
    AddObject(BG_EY_OBJECT_H_BANNER_FEL_REAVER_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_FEL_REAVER_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_FEL_REAVER_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY);
    // banners (natural)
    AddObject(BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_FEL_REAVER_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_FEL_REAVER_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY);
    // flags
    AddObject(BG_EY_OBJECT_FLAG_NETHERSTORM, BG_OBJECT_FLAG2_EY_ENTRY, 2174.782227f, 1569.054688f, 1160.361938f, -1.448624f, 0, 0, 0.662620f, -0.748956f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_FLAG_FEL_REAVER, BG_OBJECT_FLAG1_EY_ENTRY, 2044.28f, 1729.68f, 1189.96f, -0.017453f, 0, 0, 0.008727f, -0.999962f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_FLAG_BLOOD_ELF, BG_OBJECT_FLAG1_EY_ENTRY, 2048.83f, 1393.65f, 1194.49f, 0.20944f, 0, 0, 0.104528f, 0.994522f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_FLAG_DRAENEI_RUINS, BG_OBJECT_FLAG1_EY_ENTRY, 2286.56f, 1402.36f, 1197.11f, 3.72381f, 0, 0, 0.957926f, -0.287016f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_FLAG_MAGE_TOWER, BG_OBJECT_FLAG1_EY_ENTRY, 2284.48f, 1731.23f, 1189.99f, 2.89725f, 0, 0, 0.992546f, 0.121869f, RESPAWN_ONE_DAY);
    // tower cap
    AddObject(BG_EY_OBJECT_TOWER_CAP_FEL_REAVER, BG_OBJECT_FR_TOWER_CAP_EY_ENTRY, 2024.600708f, 1742.819580f, 1195.157715f, 2.443461f, 0, 0, 0.939693f, 0.342020f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_TOWER_CAP_BLOOD_ELF, BG_OBJECT_BE_TOWER_CAP_EY_ENTRY, 2050.493164f, 1372.235962f, 1194.563477f, 1.710423f, 0, 0, 0.754710f, 0.656059f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_TOWER_CAP_DRAENEI_RUINS, BG_OBJECT_DR_TOWER_CAP_EY_ENTRY, 2301.010498f, 1386.931641f, 1197.183472f, 1.570796f, 0, 0, 0.707107f, 0.707107f, RESPAWN_ONE_DAY);
    AddObject(BG_EY_OBJECT_TOWER_CAP_MAGE_TOWER, BG_OBJECT_HU_TOWER_CAP_EY_ENTRY, 2282.121582f, 1760.006958f, 1189.707153f, 1.919862f, 0, 0, 0.819152f, 0.573576f, RESPAWN_ONE_DAY);
 
    for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
    {
        AreaTrigger const* at = sObjectMgr->GetAreaTrigger(_capturePointInfo[i]._areaTrigger);
        AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i * 3 + 0, Buff_Entries[0], at->x, at->y, at->z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY);
        AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i * 3 + 1, Buff_Entries[1], at->x, at->y, at->z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY);
        AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i * 3 + 2, Buff_Entries[2], at->x, at->y, at->z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY);
    }
 
    GraveyardStruct const* sg = nullptr;
    sg = sGraveyard->GetGraveyard(BG_EY_GRAVEYARD_MAIN_ALLIANCE);
    AddSpiritGuide(BG_EY_SPIRIT_MAIN_ALLIANCE, sg->x, sg->y, sg->z, 3.124139f, TEAM_ALLIANCE);
 
    sg = sGraveyard->GetGraveyard(BG_EY_GRAVEYARD_MAIN_HORDE);
    AddSpiritGuide(BG_EY_SPIRIT_MAIN_HORDE, sg->x, sg->y, sg->z, 3.193953f, TEAM_HORDE);
 
    for (uint32 i = BG_EY_OBJECT_DOOR_A; i < BG_EY_OBJECT_MAX; ++i)
        if (!BgObjects[i])
        {
            LOG_ERROR("sql.sql", "BatteGroundEY: Failed to spawn some object Battleground not created!");
            return false;
        }
 
    for (uint32 i = BG_EY_SPIRIT_MAIN_ALLIANCE; i <= BG_EY_SPIRIT_MAIN_HORDE; ++i)
        if (!BgCreatures[i])
        {
            LOG_ERROR("sql.sql", "BatteGroundEY: Failed to spawn spirit guides Battleground not created!");
            return false;
        }
 
    return true;
}

References _capturePointInfo, Battleground::AddObject(), Battleground::AddSpiritGuide(), BG_EY_GRAVEYARD_MAIN_ALLIANCE, BG_EY_GRAVEYARD_MAIN_HORDE, BG_EY_OBJECT_A_BANNER_BLOOD_ELF_CENTER, BG_EY_OBJECT_A_BANNER_BLOOD_ELF_LEFT, BG_EY_OBJECT_A_BANNER_BLOOD_ELF_RIGHT, BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_CENTER, BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_LEFT, BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_RIGHT, BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER, BG_EY_OBJECT_A_BANNER_FEL_REAVER_LEFT, BG_EY_OBJECT_A_BANNER_FEL_REAVER_RIGHT, BG_EY_OBJECT_A_BANNER_MAGE_TOWER_CENTER, BG_EY_OBJECT_A_BANNER_MAGE_TOWER_LEFT, BG_EY_OBJECT_A_BANNER_MAGE_TOWER_RIGHT, BG_EY_OBJECT_DOOR_A, BG_EY_OBJECT_DOOR_H, BG_EY_OBJECT_FLAG_BLOOD_ELF, BG_EY_OBJECT_FLAG_DRAENEI_RUINS, BG_EY_OBJECT_FLAG_FEL_REAVER, BG_EY_OBJECT_FLAG_MAGE_TOWER, BG_EY_OBJECT_FLAG_NETHERSTORM, BG_EY_OBJECT_H_BANNER_BLOOD_ELF_CENTER, BG_EY_OBJECT_H_BANNER_BLOOD_ELF_LEFT, BG_EY_OBJECT_H_BANNER_BLOOD_ELF_RIGHT, BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_CENTER, BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_LEFT, BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_RIGHT, BG_EY_OBJECT_H_BANNER_FEL_REAVER_CENTER, BG_EY_OBJECT_H_BANNER_FEL_REAVER_LEFT, BG_EY_OBJECT_H_BANNER_FEL_REAVER_RIGHT, BG_EY_OBJECT_H_BANNER_MAGE_TOWER_CENTER, BG_EY_OBJECT_H_BANNER_MAGE_TOWER_LEFT, BG_EY_OBJECT_H_BANNER_MAGE_TOWER_RIGHT, BG_EY_OBJECT_MAX, BG_EY_OBJECT_N_BANNER_BLOOD_ELF_CENTER, BG_EY_OBJECT_N_BANNER_BLOOD_ELF_LEFT, BG_EY_OBJECT_N_BANNER_BLOOD_ELF_RIGHT, BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_CENTER, BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_LEFT, BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_RIGHT, BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER, BG_EY_OBJECT_N_BANNER_FEL_REAVER_LEFT, BG_EY_OBJECT_N_BANNER_FEL_REAVER_RIGHT, BG_EY_OBJECT_N_BANNER_MAGE_TOWER_CENTER, BG_EY_OBJECT_N_BANNER_MAGE_TOWER_LEFT, BG_EY_OBJECT_N_BANNER_MAGE_TOWER_RIGHT, BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER, BG_EY_OBJECT_TOWER_CAP_BLOOD_ELF, BG_EY_OBJECT_TOWER_CAP_DRAENEI_RUINS, BG_EY_OBJECT_TOWER_CAP_FEL_REAVER, BG_EY_OBJECT_TOWER_CAP_MAGE_TOWER, BG_EY_SPIRIT_MAIN_ALLIANCE, BG_EY_SPIRIT_MAIN_HORDE, BG_OBJECT_A_BANNER_EY_ENTRY, BG_OBJECT_A_DOOR_EY_ENTRY, BG_OBJECT_BE_TOWER_CAP_EY_ENTRY, BG_OBJECT_DR_TOWER_CAP_EY_ENTRY, BG_OBJECT_FLAG1_EY_ENTRY, BG_OBJECT_FLAG2_EY_ENTRY, BG_OBJECT_FR_TOWER_CAP_EY_ENTRY, BG_OBJECT_H_BANNER_EY_ENTRY, BG_OBJECT_H_DOOR_EY_ENTRY, BG_OBJECT_HU_TOWER_CAP_EY_ENTRY, BG_OBJECT_N_BANNER_EY_ENTRY, Battleground::BgCreatures, Battleground::BgObjects, Buff_Entries, EY_POINTS_MAX, LOG_ERROR, RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, sGraveyard, sObjectMgr, TEAM_ALLIANCE, TEAM_HORDE, AreaTrigger::x, GraveyardStruct::x, AreaTrigger::y, GraveyardStruct::y, AreaTrigger::z, and GraveyardStruct::z.

StartingEventCloseDoors()

void BattlegroundEY::StartingEventCloseDoors ( )

overridevirtual

Reimplemented from Battleground.

{
    SpawnBGObject(BG_EY_OBJECT_DOOR_A, RESPAWN_IMMEDIATELY);
    SpawnBGObject(BG_EY_OBJECT_DOOR_H, RESPAWN_IMMEDIATELY);
 
    for (uint32 i = BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER; i < BG_EY_OBJECT_MAX; ++i)
        SpawnBGObject(i, RESPAWN_ONE_DAY);
}

References BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER, BG_EY_OBJECT_DOOR_A, BG_EY_OBJECT_DOOR_H, BG_EY_OBJECT_MAX, RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, and Battleground::SpawnBGObject().

StartingEventOpenDoors()

void BattlegroundEY::StartingEventOpenDoors ( )

overridevirtual

Reimplemented from Battleground.

{
    SpawnBGObject(BG_EY_OBJECT_DOOR_A, RESPAWN_ONE_DAY);
    SpawnBGObject(BG_EY_OBJECT_DOOR_H, RESPAWN_ONE_DAY);
 
    for (uint32 i = BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER; i <= BG_EY_OBJECT_FLAG_NETHERSTORM; ++i)
        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
 
    for (uint32 i = 0; i < EY_POINTS_MAX; ++i)
        SpawnBGObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i * 3 + urand(0, 2), RESPAWN_IMMEDIATELY);
 
    // Achievement: Flurry
    StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, BG_EY_EVENT_START_BATTLE);
    _bgEvents.ScheduleEvent(BG_EY_EVENT_ADD_POINTS, 0);
    _bgEvents.ScheduleEvent(BG_EY_EVENT_CHECK_CPOINTS, 0);
}

References _bgEvents, ACHIEVEMENT_TIMED_TYPE_EVENT, BG_EY_EVENT_ADD_POINTS, BG_EY_EVENT_CHECK_CPOINTS, BG_EY_EVENT_START_BATTLE, BG_EY_OBJECT_DOOR_A, BG_EY_OBJECT_DOOR_H, BG_EY_OBJECT_FLAG_NETHERSTORM, BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER, BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER, EY_POINTS_MAX, RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, EventMap::ScheduleEvent(), Battleground::SpawnBGObject(), Battleground::StartTimedAchievement(), and urand().

UpdatePlayerScore()

bool BattlegroundEY::UpdatePlayerScore ( Player *  player, uint32  type, uint32  value, bool  doAddHonor = true  )

overridevirtual

Reimplemented from Battleground.

{
    if (!Battleground::UpdatePlayerScore(player, type, value, doAddHonor))
        return false;
 
    switch (type)
    {
        case SCORE_FLAG_CAPTURES:
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, BG_EY_OBJECTIVE_CAPTURE_FLAG);
            break;
        default:
            break;
    }
 
    return true;
}

References ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, BG_EY_OBJECTIVE_CAPTURE_FLAG, SCORE_FLAG_CAPTURES, Player::UpdateAchievementCriteria(), and Battleground::UpdatePlayerScore().

Referenced by EventPlayerCapturedFlag().

UpdatePointsCount()

void BattlegroundEY::UpdatePointsCount ( )

private

{
    UpdateWorldState(WORLD_STATE_BATTLEGROUND_EY_ALLIANCE_BASE, _ownedPointsCount[TEAM_ALLIANCE]);
    UpdateWorldState(WORLD_STATE_BATTLEGROUND_EY_HORDE_BASE, _ownedPointsCount[TEAM_HORDE]);
}

References _ownedPointsCount, TEAM_ALLIANCE, TEAM_HORDE, Battleground::UpdateWorldState(), WORLD_STATE_BATTLEGROUND_EY_ALLIANCE_BASE, and WORLD_STATE_BATTLEGROUND_EY_HORDE_BASE.

Referenced by EventTeamCapturedPoint(), and EventTeamLostPoint().

UpdatePointsIcons()

void BattlegroundEY::UpdatePointsIcons ( uint32  point )

private

{
    if (_capturePointInfo[point].IsUnderControl())
    {
        UpdateWorldState(m_PointsIconStruct[point].WorldStateControlIndex, 0);
        UpdateWorldState(m_PointsIconStruct[point].WorldStateAllianceControlledIndex, _capturePointInfo[point].IsUnderControl(TEAM_ALLIANCE));
        UpdateWorldState(m_PointsIconStruct[point].WorldStateHordeControlledIndex, _capturePointInfo[point].IsUnderControl(TEAM_HORDE));
    }
    else
    {
        UpdateWorldState(m_PointsIconStruct[point].WorldStateAllianceControlledIndex, 0);
        UpdateWorldState(m_PointsIconStruct[point].WorldStateHordeControlledIndex, 0);
        UpdateWorldState(m_PointsIconStruct[point].WorldStateControlIndex, 1);
    }
}

References _capturePointInfo, m_PointsIconStruct, TEAM_ALLIANCE, TEAM_HORDE, and Battleground::UpdateWorldState().

Referenced by EventTeamCapturedPoint(), and EventTeamLostPoint().

UpdatePointsState()

void BattlegroundEY::UpdatePointsState ( )

private

{
    std::vector<GameObject*> pointsVec;
    for (uint8 point = 0; point < EY_POINTS_MAX; ++point)
    {
        pointsVec.push_back(GetBGObject(BG_EY_OBJECT_TOWER_CAP_FEL_REAVER + point));
        _capturePointInfo[point]._playersCount[TEAM_ALLIANCE] = 0;
        _capturePointInfo[point]._playersCount[TEAM_HORDE] = 0;
    }
 
    const BattlegroundPlayerMap& bgPlayerMap = GetPlayers();
    for (BattlegroundPlayerMap::const_iterator itr = bgPlayerMap.begin(); itr != bgPlayerMap.end(); ++itr)
    {
        itr->second->SendUpdateWorldState(WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_DONT_SHOW);
        for (uint8 point = 0; point < EY_POINTS_MAX; ++point)
            if (GameObject* pointObject = pointsVec[point])
                if (itr->second->CanCaptureTowerPoint() && itr->second->IsWithinDistInMap(pointObject, BG_EY_POINT_RADIUS))
                {
                    itr->second->SendUpdateWorldState(WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_SHOW);
                    itr->second->SendUpdateWorldState(WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_PERCENT_GREY, BG_EY_PROGRESS_BAR_PERCENT_GREY);
                    itr->second->SendUpdateWorldState(WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_STATUS, _capturePointInfo[point]._barStatus);
                    ++_capturePointInfo[point]._playersCount[itr->second->GetTeamId()];
                    _capturePointInfo[point].player = itr->second;
 
                    // Xinef: ugly hax... area trigger is no longer called by client...
                    if (pointObject->GetEntry() == BG_OBJECT_FR_TOWER_CAP_EY_ENTRY && itr->second->GetDistance2d(2043.96f, 1729.68f) < 3.0f)
                        HandleAreaTrigger(itr->second, AT_FEL_REAVER_POINT);
                }
    }
 
    for (uint8 point = 0; point < EY_POINTS_MAX; ++point)
    {
        _capturePointInfo[point]._barStatus += std::max<int8>(std::min<int8>(_capturePointInfo[point]._playersCount[TEAM_ALLIANCE] - _capturePointInfo[point]._playersCount[TEAM_HORDE], BG_EY_POINT_MAX_CAPTURERS_COUNT), -BG_EY_POINT_MAX_CAPTURERS_COUNT);
        _capturePointInfo[point]._barStatus = std::max<int8>(std::min<int8>(_capturePointInfo[point]._barStatus, BG_EY_PROGRESS_BAR_ALI_CONTROLLED), BG_EY_PROGRESS_BAR_HORDE_CONTROLLED);
 
        TeamId pointOwnerTeamId = TEAM_NEUTRAL;
        if (_capturePointInfo[point]._barStatus <= BG_EY_PROGRESS_BAR_NEUTRAL_LOW)
            pointOwnerTeamId = TEAM_HORDE;
        else if (_capturePointInfo[point]._barStatus >= BG_EY_PROGRESS_BAR_NEUTRAL_HIGH)
            pointOwnerTeamId = TEAM_ALLIANCE;
 
        if (pointOwnerTeamId != _capturePointInfo[point]._ownerTeamId)
        {
            if (_capturePointInfo[point].IsUncontrolled())
                EventTeamCapturedPoint(_capturePointInfo[point].player, pointOwnerTeamId, point);
 
            if (pointOwnerTeamId == TEAM_NEUTRAL && _capturePointInfo[point].IsUnderControl())
                EventTeamLostPoint(_capturePointInfo[point].player, point);
        }
    }
}

References BattlegroundEY::CapturePointInfo::_barStatus, _capturePointInfo, BattlegroundEY::CapturePointInfo::_playersCount, AT_FEL_REAVER_POINT, BG_EY_OBJECT_TOWER_CAP_FEL_REAVER, BG_EY_POINT_MAX_CAPTURERS_COUNT, BG_EY_POINT_RADIUS, BG_EY_PROGRESS_BAR_ALI_CONTROLLED, BG_EY_PROGRESS_BAR_DONT_SHOW, BG_EY_PROGRESS_BAR_HORDE_CONTROLLED, BG_EY_PROGRESS_BAR_NEUTRAL_HIGH, BG_EY_PROGRESS_BAR_NEUTRAL_LOW, BG_EY_PROGRESS_BAR_PERCENT_GREY, BG_EY_PROGRESS_BAR_SHOW, BG_OBJECT_FR_TOWER_CAP_EY_ENTRY, EventTeamCapturedPoint(), EventTeamLostPoint(), EY_POINTS_MAX, Battleground::GetBGObject(), Battleground::GetPlayers(), HandleAreaTrigger(), BattlegroundEY::CapturePointInfo::player, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_PERCENT_GREY, WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_SHOW, and WORLD_STATE_BATTLEGROUND_EY_PROGRESS_BAR_STATUS.

Referenced by PostUpdateImpl().

Member Data Documentation

_bgEvents

EventMap BattlegroundEY::_bgEvents

private

Referenced by EventPlayerCapturedFlag(), EventPlayerDroppedFlag(), Init(), PostUpdateImpl(), and StartingEventOpenDoors().

_capturePointInfo

CapturePointInfo BattlegroundEY::_capturePointInfo[EY_POINTS_MAX]

private

Referenced by AllNodesConrolledByTeam(), BattlegroundEY(), EventTeamCapturedPoint(), EventTeamLostPoint(), FillInitialWorldStates(), GetClosestGraveyard(), HandleAreaTrigger(), SetupBattleground(), UpdatePointsIcons(), and UpdatePointsState().

_configurableMaxTeamScore

uint32 BattlegroundEY::_configurableMaxTeamScore

private

Referenced by AddPoints(), and Init().

_droppedFlagGUID

ObjectGuid BattlegroundEY::_droppedFlagGUID

private

Referenced by Init().

_flagCapturedObject

uint32 BattlegroundEY::_flagCapturedObject

private

Referenced by BattlegroundEY(), EventPlayerCapturedFlag(), Init(), and RespawnFlag().

_flagKeeperGUID

ObjectGuid BattlegroundEY::_flagKeeperGUID

private

Referenced by Init().

_flagState

uint8 BattlegroundEY::_flagState

private

Referenced by BattlegroundEY(), EventPlayerCapturedFlag(), EventPlayerClickedOnFlag(), EventPlayerDroppedFlag(), FillInitialWorldStates(), HandleAreaTrigger(), Init(), RespawnFlag(), and RespawnFlagAfterDrop().

_honorTics

uint32 BattlegroundEY::_honorTics

private

Referenced by AddPoints(), BattlegroundEY(), and Init().

_ownedPointsCount

uint8 BattlegroundEY::_ownedPointsCount[PVP_TEAMS_COUNT]

private

Referenced by BattlegroundEY(), EventPlayerCapturedFlag(), EventTeamCapturedPoint(), EventTeamLostPoint(), FillInitialWorldStates(), Init(), PostUpdateImpl(), and UpdatePointsCount().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Battlegrounds/Zones/BattlegroundEY.h
• azerothcore-wotlk/src/server/game/Battlegrounds/Zones/BattlegroundEY.cpp