#include "BattlegroundWS.h"

Inheritance diagram for BattlegroundWS:

Public Member Functions
	BattlegroundWS ()

	~BattlegroundWS () override

void	AddPlayer (Player *player) override

void	StartingEventCloseDoors () override

void	StartingEventOpenDoors () override

ObjectGuid	GetFlagPickerGUID (TeamId teamId) const override

void	SetFlagPicker (ObjectGuid guid, TeamId teamId)

void	RespawnFlagAfterDrop (TeamId teamId)

uint8	GetFlagState (TeamId teamId) const

void	CheckFlagKeeperInArea (TeamId teamId)

void	EventPlayerDroppedFlag (Player *player) override

void	EventPlayerClickedOnFlag (Player player, GameObject gameObject) override

void	EventPlayerCapturedFlag (Player *player)

void	RemovePlayer (Player *player) override

void	HandleAreaTrigger (Player *player, uint32 trigger) override

void	HandleKillPlayer (Player player, Player killer) override

bool	SetupBattleground () override

void	Init () override

void	EndBattleground (TeamId winnerTeamId) override

GraveyardStruct const *	GetClosestGraveyard (Player *player) override

void	UpdateFlagState (TeamId teamId, uint32 value)

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

void	SetDroppedFlagGUID (ObjectGuid guid, TeamId teamId) override

ObjectGuid	GetDroppedFlagGUID (TeamId teamId) const

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

void	AddPoints (TeamId teamId, uint32 points)

TeamId	GetPrematureWinner () override

uint32	GetMatchTime () const

uint32	GetAssaultSpellId () const

void	RemoveAssaultAuras ()

Public Member Functions inherited from Battleground
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual void	ResetBGSubclass ()

virtual void	DestroyGate (Player , GameObject )

virtual bool	AllNodesConrolledByTeam (TeamId) const

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.

Private Attributes
EventMap	_bgEvents

ObjectGuid	_flagKeepers [2]

ObjectGuid	_droppedFlagGUID [2]

uint8	_flagState [2]

TeamId	_lastFlagCaptureTeam

uint32	_reputationCapture

uint32	_honorWinKills

uint32	_honorEndKills

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

◆ BattlegroundWS()

BattlegroundWS::BattlegroundWS ( )

{
    BgObjects.resize(BG_WS_OBJECT_MAX);
    BgCreatures.resize(BG_CREATURES_MAX_WS);
 
    StartMessageIds[BG_STARTING_EVENT_SECOND] = BG_WS_TEXT_START_ONE_MINUTE;
    StartMessageIds[BG_STARTING_EVENT_THIRD] = BG_WS_TEXT_START_HALF_MINUTE;
    StartMessageIds[BG_STARTING_EVENT_FOURTH] = BG_WS_TEXT_BATTLE_HAS_BEGUN;
 
    _flagState[TEAM_ALLIANCE] = BG_WS_FLAG_STATE_ON_BASE;
    _flagState[TEAM_HORDE] = BG_WS_FLAG_STATE_ON_BASE;
    _lastFlagCaptureTeam = TEAM_NEUTRAL;
    _reputationCapture = 0;
    _honorWinKills = 0;
    _honorEndKills = 0;
}

References _flagState, _honorEndKills, _honorWinKills, _lastFlagCaptureTeam, _reputationCapture, BG_CREATURES_MAX_WS, BG_STARTING_EVENT_FOURTH, BG_STARTING_EVENT_SECOND, BG_STARTING_EVENT_THIRD, BG_WS_FLAG_STATE_ON_BASE, BG_WS_OBJECT_MAX, BG_WS_TEXT_BATTLE_HAS_BEGUN, BG_WS_TEXT_START_HALF_MINUTE, BG_WS_TEXT_START_ONE_MINUTE, Battleground::BgCreatures, Battleground::BgObjects, Battleground::StartMessageIds, TEAM_ALLIANCE, TEAM_HORDE, and TEAM_NEUTRAL.

◆ ~BattlegroundWS()

BattlegroundWS::~BattlegroundWS ( )

override

54{

55}

Member Function Documentation

◆ AddPlayer()

void BattlegroundWS::AddPlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

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

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

◆ AddPoints()

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

inline

247{ m_TeamScores[teamId] += points; }

Battleground::m_TeamScores

int32 m_TeamScores[PVP_TEAMS_COUNT]

Definition Battleground.h:647

Referenced by EventPlayerCapturedFlag().

◆ CheckFlagKeeperInArea()

void BattlegroundWS::CheckFlagKeeperInArea ( TeamId teamId )

{
    if (GetStatus() != STATUS_IN_PROGRESS || GetFlagState(teamId) != BG_WS_FLAG_STATE_ON_PLAYER)
    {
        return;
    }
 
    uint32 triggerId = teamId == TEAM_ALLIANCE ? BG_WS_TRIGGER_HORDE_FLAG_SPAWN : BG_WS_TRIGGER_ALLIANCE_FLAG_SPAWN;
    AreaTrigger const* areaTrigger = sObjectMgr->GetAreaTrigger(triggerId);
    if (Player* player = ObjectAccessor::GetPlayer(FindBgMap(), GetFlagPickerGUID(teamId)))
    {
        if (areaTrigger && player->IsInAreaTriggerRadius(areaTrigger))
        {
            HandleAreaTrigger(player, triggerId);
        }
    }
}

References BG_WS_FLAG_STATE_ON_PLAYER, BG_WS_TRIGGER_ALLIANCE_FLAG_SPAWN, BG_WS_TRIGGER_HORDE_FLAG_SPAWN, Battleground::FindBgMap(), GetFlagPickerGUID(), GetFlagState(), ObjectAccessor::GetPlayer(), Battleground::GetStatus(), HandleAreaTrigger(), sObjectMgr, STATUS_IN_PROGRESS, and TEAM_ALLIANCE.

Referenced by EventPlayerClickedOnFlag(), and RespawnFlagAfterDrop().

◆ EndBattleground()

void BattlegroundWS::EndBattleground ( TeamId winnerTeamId )

overridevirtual

Deprecated:: need delete

Reimplemented from Battleground.

{
    // Win reward
    RewardHonorToTeam(GetBonusHonorFromKill(_honorWinKills), winnerTeamId);
 
    // Complete map_end rewards (even if no team wins)
    RewardHonorToTeam(GetBonusHonorFromKill(_honorEndKills), TEAM_ALLIANCE);
    RewardHonorToTeam(GetBonusHonorFromKill(_honorEndKills), TEAM_HORDE);
 
    Battleground::EndBattleground(winnerTeamId);
}

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

Referenced by EventPlayerCapturedFlag(), and PostUpdateImpl().

◆ EventPlayerCapturedFlag()

void BattlegroundWS::EventPlayerCapturedFlag ( Player * player )

{
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
    player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
    RemoveAssaultAuras();
 
    AddPoints(player->GetTeamId(), 1);
    SetFlagPicker(ObjectGuid::Empty, GetOtherTeamId(player->GetTeamId()));
    UpdateFlagState(GetOtherTeamId(player->GetTeamId()), BG_WS_FLAG_STATE_ON_BASE);
 
    if (player->GetTeamId() == TEAM_ALLIANCE)
    {
        player->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);
        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_ALLIANCE);
        SendBroadcastText(BG_WS_TEXT_CAPTURED_HORDE_FLAG, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
        RewardReputationToTeam(890, _reputationCapture, TEAM_ALLIANCE);
    }
    else
    {
        player->RemoveAurasDueToSpell(BG_WS_SPELL_SILVERWING_FLAG);
        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_HORDE);
        SendBroadcastText(BG_WS_TEXT_CAPTURED_ALLIANCE_FLAG, CHAT_MSG_BG_SYSTEM_HORDE, player);
        RewardReputationToTeam(889, _reputationCapture, TEAM_HORDE);
    }
 
    SpawnBGObject(BG_WS_OBJECT_H_FLAG, BG_WS_FLAG_RESPAWN_TIME);
    SpawnBGObject(BG_WS_OBJECT_A_FLAG, BG_WS_FLAG_RESPAWN_TIME);
 
    UpdateWorldState(player->GetTeamId() == TEAM_ALLIANCE ? WORLD_STATE_BATTLEGROUND_WS_FLAG_CAPTURES_ALLIANCE : WORLD_STATE_BATTLEGROUND_WS_FLAG_CAPTURES_HORDE, GetTeamScore(player->GetTeamId()));
    UpdatePlayerScore(player, SCORE_FLAG_CAPTURES, 1);      // +1 flag captures
    _lastFlagCaptureTeam = player->GetTeamId();
 
    RewardHonorToTeam(GetBonusHonorFromKill(2), player->GetTeamId());
 
    if (GetTeamScore(TEAM_ALLIANCE) == _configurableMaxTeamScore || GetTeamScore(TEAM_HORDE) == _configurableMaxTeamScore)
    {
        UpdateWorldState(WORLD_STATE_BATTLEGROUND_WS_STATE_TIMER_ACTIVE, 0);
        EndBattleground(GetTeamScore(TEAM_HORDE) == _configurableMaxTeamScore ? TEAM_HORDE : TEAM_ALLIANCE);
    }
    else
        _bgEvents.ScheduleEvent(BG_WS_EVENT_RESPAWN_BOTH_FLAGS, BG_WS_FLAG_RESPAWN_TIME);
 
    _bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10);
    _bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15);
}

References _bgEvents, _configurableMaxTeamScore, _lastFlagCaptureTeam, _reputationCapture, AddPoints(), AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT, BG_WS_EVENT_BOTH_FLAGS_KEPT10, BG_WS_EVENT_BOTH_FLAGS_KEPT15, BG_WS_EVENT_RESPAWN_BOTH_FLAGS, BG_WS_FLAG_RESPAWN_TIME, BG_WS_FLAG_STATE_ON_BASE, BG_WS_OBJECT_A_FLAG, BG_WS_OBJECT_H_FLAG, BG_WS_SOUND_FLAG_CAPTURED_ALLIANCE, BG_WS_SOUND_FLAG_CAPTURED_HORDE, BG_WS_SPELL_SILVERWING_FLAG, BG_WS_SPELL_WARSONG_FLAG, BG_WS_TEXT_CAPTURED_ALLIANCE_FLAG, BG_WS_TEXT_CAPTURED_HORDE_FLAG, EventMap::CancelEvent(), CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, ObjectGuid::Empty, EndBattleground(), Battleground::GetBonusHonorFromKill(), Battleground::GetOtherTeamId(), Battleground::GetStatus(), Player::GetTeamId(), Battleground::GetTeamScore(), Battleground::PlaySoundToAll(), RemoveAssaultAuras(), Unit::RemoveAurasDueToSpell(), Unit::RemoveAurasWithInterruptFlags(), Battleground::RewardHonorToTeam(), Battleground::RewardReputationToTeam(), EventMap::ScheduleEvent(), SCORE_FLAG_CAPTURES, Battleground::SendBroadcastText(), SetFlagPicker(), Battleground::SpawnBGObject(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, UpdateFlagState(), UpdatePlayerScore(), Battleground::UpdateWorldState(), WORLD_STATE_BATTLEGROUND_WS_FLAG_CAPTURES_ALLIANCE, WORLD_STATE_BATTLEGROUND_WS_FLAG_CAPTURES_HORDE, and WORLD_STATE_BATTLEGROUND_WS_STATE_TIMER_ACTIVE.

Referenced by HandleAreaTrigger().

◆ EventPlayerClickedOnFlag()

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

overridevirtual

Reimplemented from Battleground.

{
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
    player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 
    // Alliance Flag picked up from base
    if (player->GetTeamId() == TEAM_HORDE && GetFlagState(TEAM_ALLIANCE) == BG_WS_FLAG_STATE_ON_BASE && BgObjects[BG_WS_OBJECT_A_FLAG] == gameObject->GetGUID())
    {
        SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_ONE_DAY);
        SetFlagPicker(player->GetGUID(), TEAM_ALLIANCE);
        UpdateFlagState(TEAM_ALLIANCE, BG_WS_FLAG_STATE_ON_PLAYER);
        player->CastSpell(player, BG_WS_SPELL_SILVERWING_FLAG, true);
        player->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, BG_WS_SPELL_SILVERWING_FLAG_PICKED);
 
        PlaySoundToAll(BG_WS_SOUND_ALLIANCE_FLAG_PICKED_UP);
        SendBroadcastText(BG_WS_TEXT_ALLIANCE_FLAG_PICKED_UP, CHAT_MSG_BG_SYSTEM_HORDE, player);
 
        if (GetFlagState(TEAM_HORDE) != BG_WS_FLAG_STATE_ON_BASE)
        {
            _bgEvents.RescheduleEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10, BG_WS_SPELL_FORCE_TIME);
            _bgEvents.RescheduleEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15, BG_WS_SPELL_BRUTAL_TIME);
        }
        return;
    }
 
    // Horde Flag picked up from base
    if (player->GetTeamId() == TEAM_ALLIANCE && GetFlagState(TEAM_HORDE) == BG_WS_FLAG_STATE_ON_BASE && BgObjects[BG_WS_OBJECT_H_FLAG] == gameObject->GetGUID())
    {
        SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_ONE_DAY);
        SetFlagPicker(player->GetGUID(), TEAM_HORDE);
        UpdateFlagState(TEAM_HORDE, BG_WS_FLAG_STATE_ON_PLAYER);
        player->CastSpell(player, BG_WS_SPELL_WARSONG_FLAG, true);
        player->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, BG_WS_SPELL_WARSONG_FLAG_PICKED);
 
        PlaySoundToAll(BG_WS_SOUND_HORDE_FLAG_PICKED_UP);
        SendBroadcastText(BG_WS_TEXT_HORDE_FLAG_PICKED_UP, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
 
        if (GetFlagState(TEAM_ALLIANCE) != BG_WS_FLAG_STATE_ON_BASE)
        {
            _bgEvents.RescheduleEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10, BG_WS_SPELL_FORCE_TIME);
            _bgEvents.RescheduleEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15, BG_WS_SPELL_BRUTAL_TIME);
        }
        return;
    }
    if (player->IsMounted())
    {
        player->Dismount();
        player->RemoveAurasByType(SPELL_AURA_MOUNTED);
    }
    // Alliance Flag on ground
    if (GetFlagState(TEAM_ALLIANCE) == BG_WS_FLAG_STATE_ON_GROUND && player->IsWithinDistInMap(gameObject, 10.0f) && gameObject->GetEntry() == BG_OBJECT_A_FLAG_GROUND_WS_ENTRY)
    {
        SetDroppedFlagGUID(ObjectGuid::Empty, TEAM_ALLIANCE);
        if (player->GetTeamId() == TEAM_ALLIANCE)
        {
            UpdateFlagState(TEAM_ALLIANCE, BG_WS_FLAG_STATE_ON_BASE);
            SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_IMMEDIATELY);
            UpdatePlayerScore(player, SCORE_FLAG_RETURNS, 1);
 
            PlaySoundToAll(BG_WS_SOUND_FLAG_RETURNED);
            SendBroadcastText(BG_WS_TEXT_ALLIANCE_FLAG_RETURNED, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
            _bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10);
            _bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15);
            RemoveAssaultAuras();
 
            CheckFlagKeeperInArea(TEAM_HORDE);
            return;
        }
        else
        {
            SetFlagPicker(player->GetGUID(), TEAM_ALLIANCE);
            UpdateFlagState(TEAM_ALLIANCE, BG_WS_FLAG_STATE_ON_PLAYER);
            player->CastSpell(player, BG_WS_SPELL_SILVERWING_FLAG, true);
            if (uint32 assaultSpellId = GetAssaultSpellId())
                player->CastSpell(player, assaultSpellId, true);
 
            PlaySoundToAll(BG_WS_SOUND_ALLIANCE_FLAG_PICKED_UP);
            SendBroadcastText(BG_WS_TEXT_ALLIANCE_FLAG_PICKED_UP, CHAT_MSG_BG_SYSTEM_HORDE, player);
            return;
        }
    }
 
    // Horde Flag on ground
    if (GetFlagState(TEAM_HORDE) == BG_WS_FLAG_STATE_ON_GROUND && player->IsWithinDistInMap(gameObject, 10.0f) && gameObject->GetEntry() == BG_OBJECT_H_FLAG_GROUND_WS_ENTRY)
    {
        SetDroppedFlagGUID(ObjectGuid::Empty, TEAM_HORDE);
        if (player->GetTeamId() == TEAM_HORDE)
        {
            UpdateFlagState(TEAM_HORDE, BG_WS_FLAG_STATE_ON_BASE);
            SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_IMMEDIATELY);
            UpdatePlayerScore(player, SCORE_FLAG_RETURNS, 1);
 
            PlaySoundToAll(BG_WS_SOUND_FLAG_RETURNED);
            SendBroadcastText(BG_WS_TEXT_HORDE_FLAG_RETURNED, CHAT_MSG_BG_SYSTEM_HORDE, player);
            _bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10);
            _bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15);
            RemoveAssaultAuras();
 
            CheckFlagKeeperInArea(TEAM_ALLIANCE);
            return;
        }
        else
        {
            SetFlagPicker(player->GetGUID(), TEAM_HORDE);
            UpdateFlagState(TEAM_HORDE, BG_WS_FLAG_STATE_ON_PLAYER);
            player->CastSpell(player, BG_WS_SPELL_WARSONG_FLAG, true);
            if (uint32 assaultSpellId = GetAssaultSpellId())
                player->CastSpell(player, assaultSpellId, true);
 
            PlaySoundToAll(BG_WS_SOUND_HORDE_FLAG_PICKED_UP);
            SendBroadcastText(BG_WS_TEXT_HORDE_FLAG_PICKED_UP, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
            return;
        }
    }
}

References _bgEvents, ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT, BG_OBJECT_A_FLAG_GROUND_WS_ENTRY, BG_OBJECT_H_FLAG_GROUND_WS_ENTRY, BG_WS_EVENT_BOTH_FLAGS_KEPT10, BG_WS_EVENT_BOTH_FLAGS_KEPT15, BG_WS_FLAG_STATE_ON_BASE, BG_WS_FLAG_STATE_ON_GROUND, BG_WS_FLAG_STATE_ON_PLAYER, BG_WS_OBJECT_A_FLAG, BG_WS_OBJECT_H_FLAG, BG_WS_SOUND_ALLIANCE_FLAG_PICKED_UP, BG_WS_SOUND_FLAG_RETURNED, BG_WS_SOUND_HORDE_FLAG_PICKED_UP, BG_WS_SPELL_BRUTAL_TIME, BG_WS_SPELL_FORCE_TIME, BG_WS_SPELL_SILVERWING_FLAG, BG_WS_SPELL_SILVERWING_FLAG_PICKED, BG_WS_SPELL_WARSONG_FLAG, BG_WS_SPELL_WARSONG_FLAG_PICKED, BG_WS_TEXT_ALLIANCE_FLAG_PICKED_UP, BG_WS_TEXT_ALLIANCE_FLAG_RETURNED, BG_WS_TEXT_HORDE_FLAG_PICKED_UP, BG_WS_TEXT_HORDE_FLAG_RETURNED, Battleground::BgObjects, EventMap::CancelEvent(), Unit::CastSpell(), CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, CheckFlagKeeperInArea(), Unit::Dismount(), ObjectGuid::Empty, GetAssaultSpellId(), Object::GetEntry(), GetFlagState(), Object::GetGUID(), Battleground::GetStatus(), Player::GetTeamId(), Unit::IsMounted(), WorldObject::IsWithinDistInMap(), Battleground::PlaySoundToAll(), RemoveAssaultAuras(), Unit::RemoveAurasByType(), Unit::RemoveAurasWithInterruptFlags(), EventMap::RescheduleEvent(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, SCORE_FLAG_RETURNS, Battleground::SendBroadcastText(), SetDroppedFlagGUID(), SetFlagPicker(), Battleground::SpawnBGObject(), SPELL_AURA_MOUNTED, Player::StartTimedAchievement(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, UpdateFlagState(), and UpdatePlayerScore().

◆ EventPlayerDroppedFlag()

void BattlegroundWS::EventPlayerDroppedFlag ( Player * player )

overridevirtual

Reimplemented from Battleground.

{
    if (GetFlagPickerGUID(TEAM_HORDE) != player->GetGUID() && GetFlagPickerGUID(TEAM_ALLIANCE) != player->GetGUID())
        return;
 
    SetFlagPicker(ObjectGuid::Empty, GetOtherTeamId(player->GetTeamId()));
    player->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);
    player->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);
    player->RemoveAurasDueToSpell(BG_WS_SPELL_BRUTAL_ASSAULT);
 
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
    player->CastSpell(player, SPELL_RECENTLY_DROPPED_FLAG, true);
    if (player->GetTeamId() == TEAM_ALLIANCE)
    {
        UpdateFlagState(TEAM_HORDE, BG_WS_FLAG_STATE_ON_GROUND);
        player->CastSpell(player, BG_WS_SPELL_WARSONG_FLAG_DROPPED, true);
        SendBroadcastText(BG_WS_TEXT_HORDE_FLAG_DROPPED, CHAT_MSG_BG_SYSTEM_HORDE, player);
        _bgEvents.RescheduleEvent(BG_WS_EVENT_HORDE_DROP_FLAG, BG_WS_FLAG_DROP_TIME);
    }
    else
    {
        UpdateFlagState(TEAM_ALLIANCE, BG_WS_FLAG_STATE_ON_GROUND);
        player->CastSpell(player, BG_WS_SPELL_SILVERWING_FLAG_DROPPED, true);
        SendBroadcastText(BG_WS_TEXT_ALLIANCE_FLAG_DROPPED, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
        _bgEvents.RescheduleEvent(BG_WS_EVENT_ALLIANCE_DROP_FLAG, BG_WS_FLAG_DROP_TIME);
    }
}

References _bgEvents, BG_WS_EVENT_ALLIANCE_DROP_FLAG, BG_WS_EVENT_HORDE_DROP_FLAG, BG_WS_FLAG_DROP_TIME, BG_WS_FLAG_STATE_ON_GROUND, BG_WS_SPELL_BRUTAL_ASSAULT, BG_WS_SPELL_FOCUSED_ASSAULT, BG_WS_SPELL_SILVERWING_FLAG_DROPPED, BG_WS_SPELL_WARSONG_FLAG, BG_WS_SPELL_WARSONG_FLAG_DROPPED, BG_WS_TEXT_ALLIANCE_FLAG_DROPPED, BG_WS_TEXT_HORDE_FLAG_DROPPED, Unit::CastSpell(), CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, ObjectGuid::Empty, GetFlagPickerGUID(), Object::GetGUID(), Battleground::GetOtherTeamId(), Battleground::GetStatus(), Player::GetTeamId(), Unit::RemoveAurasDueToSpell(), EventMap::RescheduleEvent(), Battleground::SendBroadcastText(), SetFlagPicker(), SPELL_RECENTLY_DROPPED_FLAG, STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, and UpdateFlagState().

Referenced by HandleKillPlayer(), and RemovePlayer().

◆ FillInitialWorldStates()

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

overridevirtual

Reimplemented from Battleground.

{
    packet.Worldstates.reserve(7);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_WS_FLAG_CAPTURES_ALLIANCE, GetTeamScore(TEAM_ALLIANCE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_WS_FLAG_CAPTURES_HORDE, GetTeamScore(TEAM_HORDE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_WS_FLAG_CAPTURES_MAX, _configurableMaxTeamScore);
 
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_WS_STATE_TIMER_ACTIVE, GetStatus() == STATUS_IN_PROGRESS ? 1 : 0);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_WS_STATE_TIMER, GetMatchTime());
 
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_WS_FLAG_STATE_HORDE, GetFlagState(TEAM_HORDE));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_WS_FLAG_STATE_ALLIANCE, GetFlagState(TEAM_ALLIANCE));
}

References _configurableMaxTeamScore, GetFlagState(), GetMatchTime(), Battleground::GetStatus(), Battleground::GetTeamScore(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, WORLD_STATE_BATTLEGROUND_WS_FLAG_CAPTURES_ALLIANCE, WORLD_STATE_BATTLEGROUND_WS_FLAG_CAPTURES_HORDE, WORLD_STATE_BATTLEGROUND_WS_FLAG_CAPTURES_MAX, WORLD_STATE_BATTLEGROUND_WS_FLAG_STATE_ALLIANCE, WORLD_STATE_BATTLEGROUND_WS_FLAG_STATE_HORDE, WORLD_STATE_BATTLEGROUND_WS_STATE_TIMER, WORLD_STATE_BATTLEGROUND_WS_STATE_TIMER_ACTIVE, and WorldPackets::WorldState::InitWorldStates::Worldstates.

◆ GetAssaultSpellId()

uint32 BattlegroundWS::GetAssaultSpellId ( ) const

{
    if ((!GetFlagPickerGUID(TEAM_ALLIANCE) && GetFlagState(TEAM_ALLIANCE) != BG_WS_FLAG_STATE_ON_GROUND) ||
            (!GetFlagPickerGUID(TEAM_HORDE) && GetFlagState(TEAM_HORDE) != BG_WS_FLAG_STATE_ON_GROUND) ||
            _bgEvents.GetNextEventTime(BG_WS_EVENT_BOTH_FLAGS_KEPT10) > 0)
        return 0;
 
    return _bgEvents.GetNextEventTime(BG_WS_EVENT_BOTH_FLAGS_KEPT15) > 0 ? BG_WS_SPELL_FOCUSED_ASSAULT : BG_WS_SPELL_BRUTAL_ASSAULT;
}

References _bgEvents, BG_WS_EVENT_BOTH_FLAGS_KEPT10, BG_WS_EVENT_BOTH_FLAGS_KEPT15, BG_WS_FLAG_STATE_ON_GROUND, BG_WS_SPELL_BRUTAL_ASSAULT, BG_WS_SPELL_FOCUSED_ASSAULT, GetFlagPickerGUID(), GetFlagState(), EventMap::GetNextEventTime(), TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by EventPlayerClickedOnFlag().

◆ GetClosestGraveyard()

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

overridevirtual

Reimplemented from Battleground.

{
    if (GetStatus() == STATUS_IN_PROGRESS)
        return sGraveyard->GetGraveyard(player->GetTeamId() == TEAM_ALLIANCE ? WS_GRAVEYARD_MAIN_ALLIANCE : WS_GRAVEYARD_MAIN_HORDE);
    else
        return sGraveyard->GetGraveyard(player->GetTeamId() == TEAM_ALLIANCE ? WS_GRAVEYARD_FLAGROOM_ALLIANCE : WS_GRAVEYARD_FLAGROOM_HORDE);
}

References Battleground::GetStatus(), Player::GetTeamId(), sGraveyard, STATUS_IN_PROGRESS, TEAM_ALLIANCE, WS_GRAVEYARD_FLAGROOM_ALLIANCE, WS_GRAVEYARD_FLAGROOM_HORDE, WS_GRAVEYARD_MAIN_ALLIANCE, and WS_GRAVEYARD_MAIN_HORDE.

◆ GetDroppedFlagGUID()

ObjectGuid BattlegroundWS::GetDroppedFlagGUID ( TeamId teamId ) const

inline

243{ return _droppedFlagGUID[teamId];}

BattlegroundWS::_droppedFlagGUID

ObjectGuid _droppedFlagGUID[2]

Definition BattlegroundWS.h:258

Referenced by RespawnFlagAfterDrop().

◆ GetFlagPickerGUID()

ObjectGuid BattlegroundWS::GetFlagPickerGUID ( TeamId teamId ) const

inlineoverridevirtual

Reimplemented from Battleground.

221{ return _flagKeepers[teamId]; }

BattlegroundWS::_flagKeepers

ObjectGuid _flagKeepers[2]

Definition BattlegroundWS.h:257

Referenced by CheckFlagKeeperInArea(), EventPlayerDroppedFlag(), GetAssaultSpellId(), HandleAreaTrigger(), PostUpdateImpl(), RemoveAssaultAuras(), and RemovePlayer().

◆ GetFlagState()

uint8 BattlegroundWS::GetFlagState ( TeamId teamId ) const

inline

224{ return _flagState[teamId]; }

Referenced by CheckFlagKeeperInArea(), EventPlayerClickedOnFlag(), FillInitialWorldStates(), GetAssaultSpellId(), HandleAreaTrigger(), achievement_save_the_day::OnCheck(), and RespawnFlagAfterDrop().

◆ GetMatchTime()

uint32 BattlegroundWS::GetMatchTime ( ) const

inline

250{ return 1 + (BG_WS_TOTAL_GAME_TIME - GetStartTime()) / (MINUTE * IN_MILLISECONDS); }

BG_WS_TOTAL_GAME_TIME

@ BG_WS_TOTAL_GAME_TIME

Definition BattlegroundWS.h:41

IN_MILLISECONDS

constexpr auto IN_MILLISECONDS

Definition Common.h:53

MINUTE

constexpr auto MINUTE

Definition Common.h:47

Battleground::GetStartTime

uint32 GetStartTime() const

Definition Battleground.h:335

References BG_WS_TOTAL_GAME_TIME, Battleground::GetStartTime(), IN_MILLISECONDS, and MINUTE.

Referenced by FillInitialWorldStates(), and PostUpdateImpl().

◆ GetPrematureWinner()

TeamId BattlegroundWS::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 BattlegroundWS::HandleAreaTrigger	(	Player *	player,
		uint32	trigger
	)

overridevirtual

Reimplemented from Battleground.

{
    if (GetStatus() != STATUS_IN_PROGRESS || !player->IsAlive())
        return;
 
    switch (trigger)
    {
        case BG_WS_TRIGGER_ALLIANCE_FLAG_SPAWN: // Alliance Flag spawn
            if (GetFlagState(TEAM_ALLIANCE) == BG_WS_FLAG_STATE_ON_BASE && GetFlagPickerGUID(TEAM_HORDE) == player->GetGUID())
                EventPlayerCapturedFlag(player);
            break;
        case BG_WS_TRIGGER_HORDE_FLAG_SPAWN: // Horde Flag spawn
            if (GetFlagState(TEAM_HORDE) == BG_WS_FLAG_STATE_ON_BASE && GetFlagPickerGUID(TEAM_ALLIANCE) == player->GetGUID())
                EventPlayerCapturedFlag(player);
            break;
        case 3649: // Not used
        case 3688: // Not used
        case 4628: // Not used
        case 4629: // Not used
        case BG_WS_TRIGGER_ALLIANCE_ELIXIR_SPEED_SPAWN: // Alliance elixir of speed spawn
        case BG_WS_TRIGGER_HORDE_ELIXIR_SPEED_SPAWN: // Horde elixir of speed spawn
        case BG_WS_TRIGGER_ALLIANCE_ELIXIR_REGEN_SPAWN: // Alliance elixir of regeneration spawn
        case BG_WS_TRIGGER_HORDE_ELIXIR_REGEN_SPAWN: // Horde elixir of regeneration spawn
        case BG_WS_TRIGGER_ALLIANCE_ELIXIR_BERSERK_SPAWN: // Alliance elixir of berserk spawn
        case BG_WS_TRIGGER_HORDE_ELIXIR_BERSERK_SPAWN: // Horde elixir of berserk spawn
            break;
    }
}

References BG_WS_FLAG_STATE_ON_BASE, BG_WS_TRIGGER_ALLIANCE_ELIXIR_BERSERK_SPAWN, BG_WS_TRIGGER_ALLIANCE_ELIXIR_REGEN_SPAWN, BG_WS_TRIGGER_ALLIANCE_ELIXIR_SPEED_SPAWN, BG_WS_TRIGGER_ALLIANCE_FLAG_SPAWN, BG_WS_TRIGGER_HORDE_ELIXIR_BERSERK_SPAWN, BG_WS_TRIGGER_HORDE_ELIXIR_REGEN_SPAWN, BG_WS_TRIGGER_HORDE_ELIXIR_SPEED_SPAWN, BG_WS_TRIGGER_HORDE_FLAG_SPAWN, EventPlayerCapturedFlag(), GetFlagPickerGUID(), GetFlagState(), Object::GetGUID(), Battleground::GetStatus(), Unit::IsAlive(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by CheckFlagKeeperInArea().

◆ HandleKillPlayer()

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

overridevirtual

Reimplemented from Battleground.

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

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

◆ Init()

void BattlegroundWS::Init ( )

overridevirtual

Reimplemented from Battleground.

{
    //call parent's class reset
    Battleground::Init();
 
    _bgEvents.Reset();
    _flagKeepers[TEAM_ALLIANCE].Clear();
    _flagKeepers[TEAM_HORDE].Clear();
    _droppedFlagGUID[TEAM_ALLIANCE].Clear();
    _droppedFlagGUID[TEAM_HORDE].Clear();
    _flagState[TEAM_ALLIANCE]       = BG_WS_FLAG_STATE_ON_BASE;
    _flagState[TEAM_HORDE]          = BG_WS_FLAG_STATE_ON_BASE;
    _lastFlagCaptureTeam            = TEAM_NEUTRAL;
 
    if (sBattlegroundMgr->IsBGWeekend(GetBgTypeID(true)))
    {
        _reputationCapture = 45;
        _honorWinKills = 3;
        _honorEndKills = 4;
    }
    else
    {
        _reputationCapture = 35;
        _honorWinKills = 1;
        _honorEndKills = 2;
    }
 
    uint32 bgWarsongFlagsConfig = sWorld->getIntConfig(CONFIG_BATTLEGROUND_WARSONG_FLAGS);
    _configurableMaxTeamScore = bgWarsongFlagsConfig > 0
        ? bgWarsongFlagsConfig
        : static_cast<uint32>(BG_WS_MAX_TEAM_SCORE);
}

References _bgEvents, _configurableMaxTeamScore, _droppedFlagGUID, _flagKeepers, _flagState, _honorEndKills, _honorWinKills, _lastFlagCaptureTeam, _reputationCapture, BG_WS_FLAG_STATE_ON_BASE, BG_WS_MAX_TEAM_SCORE, ObjectGuid::Clear(), CONFIG_BATTLEGROUND_WARSONG_FLAGS, Battleground::GetBgTypeID(), Battleground::Init(), EventMap::Reset(), sBattlegroundMgr, sWorld, TEAM_ALLIANCE, TEAM_HORDE, and TEAM_NEUTRAL.

◆ PostUpdateImpl()

void BattlegroundWS::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);
        switch (_bgEvents.ExecuteEvent())
        {
            case BG_WS_EVENT_UPDATE_GAME_TIME:
                UpdateWorldState(WORLD_STATE_BATTLEGROUND_WS_STATE_TIMER, GetMatchTime());
                _bgEvents.ScheduleEvent(BG_WS_EVENT_UPDATE_GAME_TIME, ((BG_WS_TOTAL_GAME_TIME - GetStartTime()) % (MINUTE * IN_MILLISECONDS)) + 1);
                break;
            case BG_WS_EVENT_NO_TIME_LEFT:
                if (GetTeamScore(TEAM_ALLIANCE) == GetTeamScore(TEAM_HORDE))
                    EndBattleground(_lastFlagCaptureTeam);
                else
                    EndBattleground(GetTeamScore(TEAM_HORDE) > GetTeamScore(TEAM_ALLIANCE) ? TEAM_HORDE : TEAM_ALLIANCE);
                break;
            case BG_WS_EVENT_RESPAWN_BOTH_FLAGS:
                SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_IMMEDIATELY);
                SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_IMMEDIATELY);
                SendBroadcastText(BG_WS_TEXT_FLAGS_PLACED, CHAT_MSG_BG_SYSTEM_NEUTRAL);
                PlaySoundToAll(BG_WS_SOUND_FLAGS_RESPAWNED);
                break;
            case BG_WS_EVENT_ALLIANCE_DROP_FLAG:
                RespawnFlagAfterDrop(TEAM_ALLIANCE);
                break;
            case BG_WS_EVENT_HORDE_DROP_FLAG:
                RespawnFlagAfterDrop(TEAM_HORDE);
                break;
            case BG_WS_EVENT_BOTH_FLAGS_KEPT10:
                if (Player* player = ObjectAccessor::GetPlayer(FindBgMap(), GetFlagPickerGUID(TEAM_ALLIANCE)))
                    player->CastSpell(player, BG_WS_SPELL_FOCUSED_ASSAULT, true);
                if (Player* player = ObjectAccessor::GetPlayer(FindBgMap(), GetFlagPickerGUID(TEAM_HORDE)))
                    player->CastSpell(player, BG_WS_SPELL_FOCUSED_ASSAULT, true);
                break;
            case BG_WS_EVENT_BOTH_FLAGS_KEPT15:
                if (Player* player = ObjectAccessor::GetPlayer(FindBgMap(), GetFlagPickerGUID(TEAM_ALLIANCE)))
                {
                    player->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);
                    player->CastSpell(player, BG_WS_SPELL_BRUTAL_ASSAULT, true);
                }
                if (Player* player = ObjectAccessor::GetPlayer(FindBgMap(), GetFlagPickerGUID(TEAM_HORDE)))
                {
                    player->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);
                    player->CastSpell(player, BG_WS_SPELL_BRUTAL_ASSAULT, true);
                }
                break;
            case BG_WS_EVENT_DESPAWN_DOORS:
                SpawnBGObject(BG_WS_OBJECT_DOOR_H_1, RESPAWN_ONE_DAY);
                SpawnBGObject(BG_WS_OBJECT_DOOR_H_2, RESPAWN_ONE_DAY);
                break;
        }
    }
}

References _bgEvents, _lastFlagCaptureTeam, BG_WS_EVENT_ALLIANCE_DROP_FLAG, BG_WS_EVENT_BOTH_FLAGS_KEPT10, BG_WS_EVENT_BOTH_FLAGS_KEPT15, BG_WS_EVENT_DESPAWN_DOORS, BG_WS_EVENT_HORDE_DROP_FLAG, BG_WS_EVENT_NO_TIME_LEFT, BG_WS_EVENT_RESPAWN_BOTH_FLAGS, BG_WS_EVENT_UPDATE_GAME_TIME, BG_WS_OBJECT_A_FLAG, BG_WS_OBJECT_DOOR_H_1, BG_WS_OBJECT_DOOR_H_2, BG_WS_OBJECT_H_FLAG, BG_WS_SOUND_FLAGS_RESPAWNED, BG_WS_SPELL_BRUTAL_ASSAULT, BG_WS_SPELL_FOCUSED_ASSAULT, BG_WS_TEXT_FLAGS_PLACED, BG_WS_TOTAL_GAME_TIME, CHAT_MSG_BG_SYSTEM_NEUTRAL, EndBattleground(), EventMap::ExecuteEvent(), Battleground::FindBgMap(), GetFlagPickerGUID(), GetMatchTime(), ObjectAccessor::GetPlayer(), Battleground::GetStartTime(), Battleground::GetStatus(), Battleground::GetTeamScore(), IN_MILLISECONDS, MINUTE, Battleground::PlaySoundToAll(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, RespawnFlagAfterDrop(), EventMap::ScheduleEvent(), Battleground::SendBroadcastText(), Battleground::SpawnBGObject(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, EventMap::Update(), Battleground::UpdateWorldState(), and WORLD_STATE_BATTLEGROUND_WS_STATE_TIMER.

◆ RemoveAssaultAuras()

void BattlegroundWS::RemoveAssaultAuras ( )

{
    if (Player* player = ObjectAccessor::GetPlayer(FindBgMap(), GetFlagPickerGUID(TEAM_ALLIANCE)))
    {
        player->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);
        player->RemoveAurasDueToSpell(BG_WS_SPELL_BRUTAL_ASSAULT);
    }
    if (Player* player = ObjectAccessor::GetPlayer(FindBgMap(), GetFlagPickerGUID(TEAM_HORDE)))
    {
        player->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);
        player->RemoveAurasDueToSpell(BG_WS_SPELL_BRUTAL_ASSAULT);
    }
}

References BG_WS_SPELL_BRUTAL_ASSAULT, BG_WS_SPELL_FOCUSED_ASSAULT, Battleground::FindBgMap(), GetFlagPickerGUID(), ObjectAccessor::GetPlayer(), TEAM_ALLIANCE, and TEAM_HORDE.

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

◆ RemovePlayer()

void BattlegroundWS::RemovePlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

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

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

◆ RespawnFlagAfterDrop()

void BattlegroundWS::RespawnFlagAfterDrop ( TeamId teamId )

{
    if (GetStatus() != STATUS_IN_PROGRESS || GetFlagState(teamId) != BG_WS_FLAG_STATE_ON_GROUND)
        return;
 
    UpdateFlagState(teamId, BG_WS_FLAG_STATE_ON_BASE);
    SpawnBGObject(teamId == TEAM_ALLIANCE ? BG_WS_OBJECT_A_FLAG : BG_WS_OBJECT_H_FLAG, RESPAWN_IMMEDIATELY);
    SendBroadcastText(BG_WS_TEXT_FLAGS_PLACED, CHAT_MSG_BG_SYSTEM_NEUTRAL);
    PlaySoundToAll(BG_WS_SOUND_FLAGS_RESPAWNED);
 
    if (GameObject* flag = GetBgMap()->GetGameObject(GetDroppedFlagGUID(teamId)))
        flag->Delete();
 
    SetDroppedFlagGUID(ObjectGuid::Empty, teamId);
    _bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT10);
    _bgEvents.CancelEvent(BG_WS_EVENT_BOTH_FLAGS_KEPT15);
    RemoveAssaultAuras();
 
    CheckFlagKeeperInArea(teamId == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE);
}

References _bgEvents, BG_WS_EVENT_BOTH_FLAGS_KEPT10, BG_WS_EVENT_BOTH_FLAGS_KEPT15, BG_WS_FLAG_STATE_ON_BASE, BG_WS_FLAG_STATE_ON_GROUND, BG_WS_OBJECT_A_FLAG, BG_WS_OBJECT_H_FLAG, BG_WS_SOUND_FLAGS_RESPAWNED, BG_WS_TEXT_FLAGS_PLACED, EventMap::CancelEvent(), CHAT_MSG_BG_SYSTEM_NEUTRAL, CheckFlagKeeperInArea(), ObjectGuid::Empty, Battleground::GetBgMap(), GetDroppedFlagGUID(), GetFlagState(), Battleground::GetStatus(), Battleground::PlaySoundToAll(), RemoveAssaultAuras(), RESPAWN_IMMEDIATELY, Battleground::SendBroadcastText(), SetDroppedFlagGUID(), Battleground::SpawnBGObject(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, and UpdateFlagState().

Referenced by PostUpdateImpl().

◆ SetDroppedFlagGUID()

void BattlegroundWS::SetDroppedFlagGUID	(	ObjectGuid	guid,
		TeamId	teamId
	)

inlineoverridevirtual

Reimplemented from Battleground.

242{ _droppedFlagGUID[teamId] = guid; }

Referenced by EventPlayerClickedOnFlag(), and RespawnFlagAfterDrop().

◆ SetFlagPicker()

void BattlegroundWS::SetFlagPicker	(	ObjectGuid	guid,
		TeamId	teamId
	)

inline

222{ _flagKeepers[teamId] = guid; }

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

◆ SetupBattleground()

bool BattlegroundWS::SetupBattleground ( )

overridevirtual

Reimplemented from Battleground.

{
    // flags
    AddObject(BG_WS_OBJECT_A_FLAG, BG_OBJECT_A_FLAG_WS_ENTRY, 1540.423f, 1481.325f, 351.8284f, 3.089233f, 0, 0, 0.9996573f, 0.02617699f, RESPAWN_IMMEDIATELY);
    AddObject(BG_WS_OBJECT_H_FLAG, BG_OBJECT_H_FLAG_WS_ENTRY, 916.0226f, 1434.405f, 345.413f, 0.01745329f, 0, 0, 0.008726535f, 0.9999619f, RESPAWN_IMMEDIATELY);
    // buffs
    AddObject(BG_WS_OBJECT_SPEEDBUFF_1, BG_OBJECTID_SPEEDBUFF_ENTRY, 1449.93f, 1470.71f, 342.6346f, -1.64061f, 0, 0, 0.7313537f, -0.6819983f, SPEED_BUFF_RESPAWN_TIME);
    AddObject(BG_WS_OBJECT_SPEEDBUFF_2, BG_OBJECTID_SPEEDBUFF_ENTRY, 1005.171f, 1447.946f, 335.9032f, 1.64061f, 0, 0, 0.7313537f, 0.6819984f, SPEED_BUFF_RESPAWN_TIME);
    AddObject(BG_WS_OBJECT_REGENBUFF_1, BG_OBJECTID_REGENBUFF_ENTRY, 1317.506f, 1550.851f, 313.2344f, -0.2617996f, 0, 0, 0.1305263f, -0.9914448f, RESTORATION_BUFF_RESPAWN_TIME);
    AddObject(BG_WS_OBJECT_REGENBUFF_2, BG_OBJECTID_REGENBUFF_ENTRY, 1110.451f, 1353.656f, 316.5181f, -0.6806787f, 0, 0, 0.333807f, -0.9426414f, RESTORATION_BUFF_RESPAWN_TIME);
    AddObject(BG_WS_OBJECT_BERSERKBUFF_1, BG_OBJECTID_BERSERKERBUFF_ENTRY, 1320.09f, 1378.79f, 314.7532f, 1.186824f, 0, 0, 0.5591929f, 0.8290376f, BERSERKING_BUFF_RESPAWN_TIME);
    AddObject(BG_WS_OBJECT_BERSERKBUFF_2, BG_OBJECTID_BERSERKERBUFF_ENTRY, 1139.688f, 1560.288f, 306.8432f, -2.443461f, 0, 0, 0.9396926f, -0.3420201f, BERSERKING_BUFF_RESPAWN_TIME);
    // alliance gates
    AddObject(BG_WS_OBJECT_DOOR_A_1, BG_OBJECT_DOOR_A_1_WS_ENTRY, 1503.335f, 1493.466f, 352.1888f, 3.115414f, 0, 0, 0.9999143f, 0.01308903f, RESPAWN_IMMEDIATELY);
    AddObject(BG_WS_OBJECT_DOOR_A_2, BG_OBJECT_DOOR_A_2_WS_ENTRY, 1492.478f, 1457.912f, 342.9689f, 3.115414f, 0, 0, 0.9999143f, 0.01308903f, RESPAWN_IMMEDIATELY);
    AddObject(BG_WS_OBJECT_DOOR_A_3, BG_OBJECT_DOOR_A_3_WS_ENTRY, 1468.503f, 1494.357f, 351.8618f, 3.115414f, 0, 0, 0.9999143f, 0.01308903f, RESPAWN_IMMEDIATELY);
    AddObject(BG_WS_OBJECT_DOOR_A_4, BG_OBJECT_DOOR_A_4_WS_ENTRY, 1471.555f, 1458.778f, 362.6332f, 3.115414f, 0, 0, 0.9999143f, 0.01308903f, RESPAWN_IMMEDIATELY);
    AddObject(BG_WS_OBJECT_DOOR_A_5, BG_OBJECT_DOOR_A_5_WS_ENTRY, 1492.347f, 1458.34f, 342.3712f, -0.03490669f, 0, 0, 0.01745246f, -0.9998477f, RESPAWN_IMMEDIATELY);
    AddObject(BG_WS_OBJECT_DOOR_A_6, BG_OBJECT_DOOR_A_6_WS_ENTRY, 1503.466f, 1493.367f, 351.7352f, -0.03490669f, 0, 0, 0.01745246f, -0.9998477f, RESPAWN_IMMEDIATELY);
    // horde gates
    AddObject(BG_WS_OBJECT_DOOR_H_1, BG_OBJECT_DOOR_H_1_WS_ENTRY, 949.1663f, 1423.772f, 345.6241f, -0.5756807f, -0.01673368f, -0.004956111f, -0.2839723f, 0.9586737f, RESPAWN_IMMEDIATELY);
    AddObject(BG_WS_OBJECT_DOOR_H_2, BG_OBJECT_DOOR_H_2_WS_ENTRY, 953.0507f, 1459.842f, 340.6526f, -1.99662f, -0.1971825f, 0.1575096f, -0.8239487f, 0.5073641f, RESPAWN_IMMEDIATELY);
    AddObject(BG_WS_OBJECT_DOOR_H_3, BG_OBJECT_DOOR_H_3_WS_ENTRY, 949.9523f, 1422.751f, 344.9273f, 0.0f, 0, 0, 0, 1, RESPAWN_IMMEDIATELY);
    AddObject(BG_WS_OBJECT_DOOR_H_4, BG_OBJECT_DOOR_H_4_WS_ENTRY, 950.7952f, 1459.583f, 342.1523f, 0.05235988f, 0, 0, 0.02617695f, 0.9996573f, RESPAWN_IMMEDIATELY);
 
    GraveyardStruct const* sg = sGraveyard->GetGraveyard(WS_GRAVEYARD_MAIN_ALLIANCE);
    AddSpiritGuide(WS_SPIRIT_MAIN_ALLIANCE, sg->x, sg->y, sg->z, 3.124139f, TEAM_ALLIANCE);
 
    sg = sGraveyard->GetGraveyard(WS_GRAVEYARD_MAIN_HORDE);
    AddSpiritGuide(WS_SPIRIT_MAIN_HORDE, sg->x, sg->y, sg->z, 3.193953f, TEAM_HORDE);
 
    for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i < BG_WS_OBJECT_MAX; ++i)
        if (!BgObjects[i])
        {
            LOG_ERROR("sql.sql", "BatteGroundWS: Failed to spawn some object Battleground not created!");
            return false;
        }
 
    for (uint32 i = WS_SPIRIT_MAIN_ALLIANCE; i < BG_CREATURES_MAX_WS; ++i)
        if (!BgCreatures[i])
        {
            LOG_ERROR("sql.sql", "BatteGroundWS: Failed to spawn spirit guides Battleground not created!");
            return false;
        }
 
    return true;
}

◆ StartingEventCloseDoors()

void BattlegroundWS::StartingEventCloseDoors ( )

overridevirtual

Reimplemented from Battleground.

{
    for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i <= BG_WS_OBJECT_DOOR_H_4; ++i)
    {
        DoorClose(i);
        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
    }
    for (uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; ++i)
        SpawnBGObject(i, RESPAWN_ONE_DAY);
}

References BG_WS_OBJECT_A_FLAG, BG_WS_OBJECT_BERSERKBUFF_2, BG_WS_OBJECT_DOOR_A_1, BG_WS_OBJECT_DOOR_H_4, Battleground::DoorClose(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, and Battleground::SpawnBGObject().

◆ StartingEventOpenDoors()

void BattlegroundWS::StartingEventOpenDoors ( )

overridevirtual

Reimplemented from Battleground.

{
    for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i <= BG_WS_OBJECT_DOOR_A_6; ++i)
        DoorOpen(i);
    for (uint32 i = BG_WS_OBJECT_DOOR_H_1; i <= BG_WS_OBJECT_DOOR_H_4; ++i)
        DoorOpen(i);
 
    for (uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; ++i)
        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
 
    SpawnBGObject(BG_WS_OBJECT_DOOR_A_5, RESPAWN_ONE_DAY);
    SpawnBGObject(BG_WS_OBJECT_DOOR_A_6, RESPAWN_ONE_DAY);
    SpawnBGObject(BG_WS_OBJECT_DOOR_H_3, RESPAWN_ONE_DAY);
    SpawnBGObject(BG_WS_OBJECT_DOOR_H_4, RESPAWN_ONE_DAY);
 
    StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, WS_EVENT_START_BATTLE);
    UpdateWorldState(WORLD_STATE_BATTLEGROUND_WS_STATE_TIMER_ACTIVE, 1);
    _bgEvents.ScheduleEvent(BG_WS_EVENT_UPDATE_GAME_TIME, 0);
    _bgEvents.ScheduleEvent(BG_WS_EVENT_NO_TIME_LEFT, BG_WS_TOTAL_GAME_TIME - 2 * MINUTE * IN_MILLISECONDS); // 27 - 2 = 25 minutes
    _bgEvents.ScheduleEvent(BG_WS_EVENT_DESPAWN_DOORS, BG_WS_DOOR_DESPAWN_TIME);
}

References _bgEvents, ACHIEVEMENT_TIMED_TYPE_EVENT, BG_WS_DOOR_DESPAWN_TIME, BG_WS_EVENT_DESPAWN_DOORS, BG_WS_EVENT_NO_TIME_LEFT, BG_WS_EVENT_UPDATE_GAME_TIME, BG_WS_OBJECT_A_FLAG, BG_WS_OBJECT_BERSERKBUFF_2, BG_WS_OBJECT_DOOR_A_1, BG_WS_OBJECT_DOOR_A_5, BG_WS_OBJECT_DOOR_A_6, BG_WS_OBJECT_DOOR_H_1, BG_WS_OBJECT_DOOR_H_3, BG_WS_OBJECT_DOOR_H_4, BG_WS_TOTAL_GAME_TIME, Battleground::DoorOpen(), IN_MILLISECONDS, MINUTE, RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, EventMap::ScheduleEvent(), Battleground::SpawnBGObject(), Battleground::StartTimedAchievement(), Battleground::UpdateWorldState(), WORLD_STATE_BATTLEGROUND_WS_STATE_TIMER_ACTIVE, and WS_EVENT_START_BATTLE.

◆ UpdateFlagState()

void BattlegroundWS::UpdateFlagState	(	TeamId	teamId,
		uint32	value
	)

{
    _flagState[teamId] = value;
    UpdateWorldState(teamId == TEAM_ALLIANCE ? WORLD_STATE_BATTLEGROUND_WS_FLAG_STATE_HORDE : WORLD_STATE_BATTLEGROUND_WS_FLAG_STATE_ALLIANCE, value);
}

References _flagState, TEAM_ALLIANCE, Battleground::UpdateWorldState(), WORLD_STATE_BATTLEGROUND_WS_FLAG_STATE_ALLIANCE, and WORLD_STATE_BATTLEGROUND_WS_FLAG_STATE_HORDE.

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

◆ UpdatePlayerScore()

bool BattlegroundWS::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, WS_OBJECTIVE_CAPTURE_FLAG);
            break;
        case SCORE_FLAG_RETURNS:
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, WS_OBJECTIVE_RETURN_FLAG);
            break;
    }
 
    return true;
}

References ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, SCORE_FLAG_CAPTURES, SCORE_FLAG_RETURNS, Player::UpdateAchievementCriteria(), Battleground::UpdatePlayerScore(), WS_OBJECTIVE_CAPTURE_FLAG, and WS_OBJECTIVE_RETURN_FLAG.

Referenced by EventPlayerCapturedFlag(), and EventPlayerClickedOnFlag().

Member Data Documentation

◆ _bgEvents

EventMap BattlegroundWS::_bgEvents

private

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

◆ _configurableMaxTeamScore

uint32 BattlegroundWS::_configurableMaxTeamScore

private

Referenced by EventPlayerCapturedFlag(), FillInitialWorldStates(), and Init().

◆ _droppedFlagGUID

ObjectGuid BattlegroundWS::_droppedFlagGUID[2]

private

Referenced by Init().

◆ _flagKeepers

ObjectGuid BattlegroundWS::_flagKeepers[2]

private

Referenced by Init().

◆ _flagState

uint8 BattlegroundWS::_flagState[2]

private

Referenced by BattlegroundWS(), Init(), and UpdateFlagState().

◆ _honorEndKills

uint32 BattlegroundWS::_honorEndKills

private

Referenced by BattlegroundWS(), EndBattleground(), and Init().

◆ _honorWinKills

uint32 BattlegroundWS::_honorWinKills

private

Referenced by BattlegroundWS(), EndBattleground(), and Init().

◆ _lastFlagCaptureTeam

TeamId BattlegroundWS::_lastFlagCaptureTeam

private

Referenced by BattlegroundWS(), EventPlayerCapturedFlag(), Init(), and PostUpdateImpl().

◆ _reputationCapture

uint32 BattlegroundWS::_reputationCapture

private

Referenced by BattlegroundWS(), EventPlayerCapturedFlag(), and Init().

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

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BattlegroundWS()

◆ ~BattlegroundWS()

Member Function Documentation

◆ AddPlayer()

◆ AddPoints()

◆ CheckFlagKeeperInArea()

◆ EndBattleground()

◆ EventPlayerCapturedFlag()

◆ EventPlayerClickedOnFlag()

◆ EventPlayerDroppedFlag()

◆ FillInitialWorldStates()

◆ GetAssaultSpellId()

◆ GetClosestGraveyard()

◆ GetDroppedFlagGUID()

◆ GetFlagPickerGUID()

◆ GetFlagState()

◆ GetMatchTime()

◆ GetPrematureWinner()

◆ HandleAreaTrigger()

◆ HandleKillPlayer()

◆ Init()

◆ PostUpdateImpl()

◆ RemoveAssaultAuras()

◆ RemovePlayer()

◆ RespawnFlagAfterDrop()

◆ SetDroppedFlagGUID()

◆ SetFlagPicker()

◆ SetupBattleground()

◆ StartingEventCloseDoors()

◆ StartingEventOpenDoors()

◆ UpdateFlagState()

◆ UpdatePlayerScore()

Member Data Documentation

◆ _bgEvents

◆ _configurableMaxTeamScore

◆ _droppedFlagGUID

◆ _flagKeepers

◆ _flagState

◆ _honorEndKills

◆ _honorWinKills

◆ _lastFlagCaptureTeam

◆ _reputationCapture