#include "BattlegroundAB.h"

Inheritance diagram for BattlegroundAB:

Classes
struct	CapturePointInfo

Public Member Functions
	BattlegroundAB ()

	~BattlegroundAB () override

void	AddPlayer (Player *player) override

void	StartingEventCloseDoors () override

void	StartingEventOpenDoors () override

void	RemovePlayer (Player *player) override

void	HandleAreaTrigger (Player *player, uint32 trigger) override

bool	SetupBattleground () override

void	Init () override

void	EndBattleground (TeamId winnerTeamId) override

GraveyardStruct const *	GetClosestGraveyard (Player *player) override

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

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

void	EventPlayerClickedOnFlag (Player source, GameObject gameObject) override

bool	AllNodesConrolledByTeam (TeamId teamId) const override

bool	IsTeamScores500Disadvantage (TeamId teamId) const

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	HandleKillPlayer (Player player, Player killer)

virtual void	HandleKillUnit (Creature , Player )

virtual void	EventPlayerDroppedFlag (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)

virtual ObjectGuid	GetFlagPickerGUID (TeamId=TEAM_NEUTRAL) const

virtual void	SetDroppedFlagGUID (ObjectGuid, TeamId=TEAM_NEUTRAL)

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	DeleteBanner (uint8 node)

void	CreateBanner (uint8 node, bool delay)

void	SendNodeUpdate (uint8 node)

void	NodeOccupied (uint8 node)

void	NodeDeoccupied (uint8 node)

void	ApplyPhaseMask ()

Private Attributes
CapturePointInfo	_capturePointInfo [BG_AB_DYNAMIC_NODES_COUNT]

EventMap	_bgEvents

uint32	_honorTics

uint32	_reputationTics

uint8	_controlledPoints [PVP_TEAMS_COUNT] {}

bool	_teamScores500Disadvantage [PVP_TEAMS_COUNT] {}

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

◆ BattlegroundAB()

BattlegroundAB::BattlegroundAB ( )

{
    m_BuffChange = true;
    BgObjects.resize(BG_AB_OBJECT_MAX);
    BgCreatures.resize(BG_AB_ALL_NODES_COUNT + BG_AB_DYNAMIC_NODES_COUNT); // xinef: +BG_AB_DYNAMIC_NODES_COUNT buff triggers
 
    _controlledPoints[TEAM_ALLIANCE] = 0;
    _controlledPoints[TEAM_HORDE] = 0;
    _teamScores500Disadvantage[TEAM_ALLIANCE] = false;
    _teamScores500Disadvantage[TEAM_HORDE] = false;
    _honorTics = 0;
    _reputationTics = 0;
}

References _controlledPoints, _honorTics, _reputationTics, _teamScores500Disadvantage, BG_AB_ALL_NODES_COUNT, BG_AB_DYNAMIC_NODES_COUNT, BG_AB_OBJECT_MAX, Battleground::BgCreatures, Battleground::BgObjects, Battleground::m_BuffChange, TEAM_ALLIANCE, and TEAM_HORDE.

◆ ~BattlegroundAB()

BattlegroundAB::~BattlegroundAB ( )

overridedefault

Member Function Documentation

◆ AddPlayer()

void BattlegroundAB::AddPlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

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

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

◆ AllNodesConrolledByTeam()

bool BattlegroundAB::AllNodesConrolledByTeam ( TeamId teamId ) const

overridevirtual

Reimplemented from Battleground.

{
    return _controlledPoints[teamId] == BG_AB_DYNAMIC_NODES_COUNT;
}

References _controlledPoints, and BG_AB_DYNAMIC_NODES_COUNT.

◆ ApplyPhaseMask()

void BattlegroundAB::ApplyPhaseMask ( )

private

{
    uint32 phaseMask = 1;
    for (uint32 i = BG_AB_NODE_STABLES; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
        if (_capturePointInfo[i]._ownerTeamId != TEAM_NEUTRAL)
            phaseMask |= 1 << (i * 2 + 1 + _capturePointInfo[i]._ownerTeamId);
 
    const BattlegroundPlayerMap& bgPlayerMap = GetPlayers();
 
    for (auto const& itr : bgPlayerMap)
    {
        itr.second->SetPhaseMask(phaseMask, false);
        itr.second->UpdateObjectVisibility(true, false);
    }
}

References _capturePointInfo, BattlegroundAB::CapturePointInfo::_ownerTeamId, BG_AB_DYNAMIC_NODES_COUNT, BG_AB_NODE_STABLES, Battleground::GetPlayers(), and TEAM_NEUTRAL.

Referenced by EventPlayerClickedOnFlag(), and NodeOccupied().

◆ CreateBanner()

void BattlegroundAB::CreateBanner	(	uint8	node,
		bool	delay
	)

private

{
    // Just put it into the queue
    if (delay)
    {
        _bgEvents.RescheduleEvent(BG_AB_EVENT_UPDATE_BANNER_STABLE + node, BG_AB_BANNER_UPDATE_TIME);
        return;
    }
 
    SpawnBGObject(node * BG_AB_OBJECTS_PER_NODE + _capturePointInfo[node]._state, RESPAWN_IMMEDIATELY);
    SpawnBGObject(node * BG_AB_OBJECTS_PER_NODE + BG_AB_OBJECT_AURA_ALLY + _capturePointInfo[node]._ownerTeamId, RESPAWN_IMMEDIATELY);
}

References _bgEvents, _capturePointInfo, BG_AB_BANNER_UPDATE_TIME, BG_AB_EVENT_UPDATE_BANNER_STABLE, BG_AB_OBJECT_AURA_ALLY, BG_AB_OBJECTS_PER_NODE, EventMap::RescheduleEvent(), RESPAWN_IMMEDIATELY, and Battleground::SpawnBGObject().

Referenced by EventPlayerClickedOnFlag(), and PostUpdateImpl().

◆ DeleteBanner()

void BattlegroundAB::DeleteBanner ( uint8 node )

private

{
    SpawnBGObject(node * BG_AB_OBJECTS_PER_NODE + _capturePointInfo[node]._state, RESPAWN_ONE_DAY);
    SpawnBGObject(node * BG_AB_OBJECTS_PER_NODE + BG_AB_OBJECT_AURA_ALLY + _capturePointInfo[node]._ownerTeamId, RESPAWN_ONE_DAY);
}

References _capturePointInfo, BG_AB_OBJECT_AURA_ALLY, BG_AB_OBJECTS_PER_NODE, RESPAWN_ONE_DAY, and Battleground::SpawnBGObject().

Referenced by EventPlayerClickedOnFlag(), and PostUpdateImpl().

◆ EndBattleground()

void BattlegroundAB::EndBattleground ( TeamId winnerTeamId )

overridevirtual

Deprecated:: need delete

Reimplemented from Battleground.

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

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

Referenced by PostUpdateImpl().

◆ EventPlayerClickedOnFlag()

void BattlegroundAB::EventPlayerClickedOnFlag	(	Player *	source,
		GameObject *	gameObject
	)

overridevirtual

Reimplemented from Battleground.

{
    if (GetStatus() != STATUS_IN_PROGRESS || !player->IsWithinDistInMap(gameObject, 10.0f))
        return;
 
    uint8 node = BG_AB_NODE_STABLES;
    for (; node < BG_AB_DYNAMIC_NODES_COUNT; ++node)
        if (player->GetDistance2d(BG_AB_NodePositions[node][0], BG_AB_NodePositions[node][1]) < 10.0f)
            break;
 
    if (node == BG_AB_DYNAMIC_NODES_COUNT || _capturePointInfo[node]._ownerTeamId == player->GetTeamId() ||
            (_capturePointInfo[node]._state == BG_AB_NODE_STATE_ALLY_CONTESTED && player->GetTeamId() == TEAM_ALLIANCE) ||
            (_capturePointInfo[node]._state == BG_AB_NODE_STATE_HORDE_CONTESTED && player->GetTeamId() == TEAM_HORDE))
        return;
 
    player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 
    uint32 sound = 0;
    TeamId teamid = player->GetTeamId();
 
    DeleteBanner(node);
    CreateBanner(node, true);
 
    if (_capturePointInfo[node]._state == BG_AB_NODE_STATE_NEUTRAL)
    {
        player->KilledMonsterCredit(BG_AB_QUEST_CREDIT_BASE + node);
        UpdatePlayerScore(player, SCORE_BASES_ASSAULTED, 1);
        _capturePointInfo[node]._state = static_cast<uint8>(BG_AB_NODE_STATE_ALLY_CONTESTED) + player->GetTeamId();
        _capturePointInfo[node]._ownerTeamId = TEAM_NEUTRAL;
        _bgEvents.RescheduleEvent(BG_AB_EVENT_CAPTURE_STABLE + node, BG_AB_FLAG_CAPTURING_TIME);
        sound = BG_AB_SOUND_NODE_CLAIMED;
 
        if (teamid == TEAM_ALLIANCE)
        {
            SendBroadcastText(ABNodes[node].TextAllianceClaims, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
        }
        else
        {
            SendBroadcastText(ABNodes[node].TextHordeClaims, CHAT_MSG_BG_SYSTEM_HORDE, player);
        }
    }
    else if (_capturePointInfo[node]._state == BG_AB_NODE_STATE_ALLY_CONTESTED || _capturePointInfo[node]._state == BG_AB_NODE_STATE_HORDE_CONTESTED)
    {
        if (!_capturePointInfo[node]._captured)
        {
            player->KilledMonsterCredit(BG_AB_QUEST_CREDIT_BASE + node);
            UpdatePlayerScore(player, SCORE_BASES_ASSAULTED, 1);
            _capturePointInfo[node]._state = static_cast<uint8>(BG_AB_NODE_STATE_ALLY_CONTESTED) + player->GetTeamId();
            _capturePointInfo[node]._ownerTeamId = TEAM_NEUTRAL;
            _bgEvents.RescheduleEvent(BG_AB_EVENT_CAPTURE_STABLE + node, BG_AB_FLAG_CAPTURING_TIME);
 
            if (teamid == TEAM_ALLIANCE)
            {
                SendBroadcastText(ABNodes[node].TextAllianceAssaulted, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
            }
            else
            {
                SendBroadcastText(ABNodes[node].TextHordeAssaulted, CHAT_MSG_BG_SYSTEM_HORDE, player);
            }
        }
        else
        {
            UpdatePlayerScore(player, SCORE_BASES_DEFENDED, 1);
            _capturePointInfo[node]._state = static_cast<uint8>(BG_AB_NODE_STATE_ALLY_OCCUPIED) + player->GetTeamId();
            _capturePointInfo[node]._ownerTeamId = player->GetTeamId();
            _bgEvents.CancelEvent(BG_AB_EVENT_CAPTURE_STABLE + node);
            NodeOccupied(node); // after setting team owner
 
            if (teamid == TEAM_ALLIANCE)
            {
                SendBroadcastText(ABNodes[node].TextAllianceDefended, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
            }
            else
            {
                SendBroadcastText(ABNodes[node].TextHordeDefended, CHAT_MSG_BG_SYSTEM_HORDE, player);
            }
        }
 
        sound = player->GetTeamId() == TEAM_ALLIANCE ? BG_AB_SOUND_NODE_ASSAULTED_ALLIANCE : BG_AB_SOUND_NODE_ASSAULTED_HORDE;
    }
    else
    {
        player->KilledMonsterCredit(BG_AB_QUEST_CREDIT_BASE + node);
        UpdatePlayerScore(player, SCORE_BASES_ASSAULTED, 1);
        NodeDeoccupied(node); // before setting team owner to neutral
 
        _capturePointInfo[node]._state = static_cast<uint8>(BG_AB_NODE_STATE_ALLY_CONTESTED) + player->GetTeamId();
 
        ApplyPhaseMask();
        _bgEvents.RescheduleEvent(BG_AB_EVENT_CAPTURE_STABLE + node, BG_AB_FLAG_CAPTURING_TIME);
        sound = player->GetTeamId() == TEAM_ALLIANCE ? BG_AB_SOUND_NODE_ASSAULTED_ALLIANCE : BG_AB_SOUND_NODE_ASSAULTED_HORDE;
 
        if (teamid == TEAM_ALLIANCE)
        {
            SendBroadcastText(ABNodes[node].TextAllianceAssaulted, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
        }
        else
        {
            SendBroadcastText(ABNodes[node].TextHordeAssaulted, CHAT_MSG_BG_SYSTEM_HORDE, player);
        }
    }
 
    SendNodeUpdate(node);
    PlaySoundToAll(sound);
}

References _bgEvents, _capturePointInfo, BattlegroundAB::CapturePointInfo::_ownerTeamId, BattlegroundAB::CapturePointInfo::_state, ABNodes, ApplyPhaseMask(), AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT, BG_AB_DYNAMIC_NODES_COUNT, BG_AB_EVENT_CAPTURE_STABLE, BG_AB_FLAG_CAPTURING_TIME, BG_AB_NODE_STABLES, BG_AB_NODE_STATE_ALLY_CONTESTED, BG_AB_NODE_STATE_ALLY_OCCUPIED, BG_AB_NODE_STATE_HORDE_CONTESTED, BG_AB_NODE_STATE_NEUTRAL, BG_AB_NodePositions, BG_AB_QUEST_CREDIT_BASE, BG_AB_SOUND_NODE_ASSAULTED_ALLIANCE, BG_AB_SOUND_NODE_ASSAULTED_HORDE, BG_AB_SOUND_NODE_CLAIMED, EventMap::CancelEvent(), CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, CreateBanner(), DeleteBanner(), WorldObject::GetDistance2d(), Battleground::GetStatus(), Player::GetTeamId(), WorldObject::IsWithinDistInMap(), Player::KilledMonsterCredit(), NodeDeoccupied(), NodeOccupied(), Battleground::PlaySoundToAll(), Unit::RemoveAurasWithInterruptFlags(), EventMap::RescheduleEvent(), SCORE_BASES_ASSAULTED, SCORE_BASES_DEFENDED, Battleground::SendBroadcastText(), SendNodeUpdate(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, and UpdatePlayerScore().

◆ FillInitialWorldStates()

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

overridevirtual

Reimplemented from Battleground.

{
    packet.Worldstates.reserve(BG_AB_DYNAMIC_NODES_COUNT+7);
    for (auto& node : _capturePointInfo)
    {
        if (node._state == BG_AB_NODE_STATE_NEUTRAL)
            packet.Worldstates.emplace_back(node._iconNone, 1);
 
        for (uint8 i = BG_AB_NODE_STATE_ALLY_OCCUPIED; i <= BG_AB_NODE_STATE_HORDE_CONTESTED; ++i)
            packet.Worldstates.emplace_back(node._iconCapture + i - 1, node._state == i ? 1 : 0);
    }
 
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AB_OCCUPIED_BASES_ALLIANCE, _controlledPoints[TEAM_ALLIANCE]);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AB_OCCUPIED_BASES_HORDE, _controlledPoints[TEAM_HORDE]);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AB_RESOURCES_MAX, _configurableMaxTeamScore);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AB_RESOURCES_WARNING, BG_AB_WARNING_NEAR_VICTORY_SCORE);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AB_RESOURCES_ALLIANCE, m_TeamScores[TEAM_ALLIANCE]);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AB_RESOURCES_HORDE, m_TeamScores[TEAM_HORDE]);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AB_UNK, 2);
}

References _capturePointInfo, _configurableMaxTeamScore, _controlledPoints, BG_AB_DYNAMIC_NODES_COUNT, BG_AB_NODE_STATE_ALLY_OCCUPIED, BG_AB_NODE_STATE_HORDE_CONTESTED, BG_AB_NODE_STATE_NEUTRAL, BG_AB_WARNING_NEAR_VICTORY_SCORE, Battleground::m_TeamScores, TEAM_ALLIANCE, TEAM_HORDE, WORLD_STATE_BATTLEGROUND_AB_OCCUPIED_BASES_ALLIANCE, WORLD_STATE_BATTLEGROUND_AB_OCCUPIED_BASES_HORDE, WORLD_STATE_BATTLEGROUND_AB_RESOURCES_ALLIANCE, WORLD_STATE_BATTLEGROUND_AB_RESOURCES_HORDE, WORLD_STATE_BATTLEGROUND_AB_RESOURCES_MAX, WORLD_STATE_BATTLEGROUND_AB_RESOURCES_WARNING, WORLD_STATE_BATTLEGROUND_AB_UNK, and WorldPackets::WorldState::InitWorldStates::Worldstates.

◆ GetClosestGraveyard()

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

overridevirtual

Reimplemented from Battleground.

{
    GraveyardStruct const* entry = sGraveyard->GetGraveyard(BG_AB_GraveyardIds[static_cast<uint8>(BG_AB_SPIRIT_ALIANCE) + player->GetTeamId()]);
    GraveyardStruct const* nearestEntry = entry;
 
    float pX = player->GetPositionX();
    float pY = player->GetPositionY();
    float dist = (entry->x - pX) * (entry->x - pX) + (entry->y - pY) * (entry->y - pY);
    float minDist = dist;
 
    for (uint8 i = BG_AB_NODE_STABLES; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
        if (_capturePointInfo[i]._ownerTeamId == player->GetTeamId())
        {
            entry = sGraveyard->GetGraveyard(BG_AB_GraveyardIds[i]);
            dist = (entry->x - pX) * (entry->x - pX) + (entry->y - pY) * (entry->y - pY);
            if (dist < minDist)
            {
                minDist = dist;
                nearestEntry = entry;
            }
        }
 
    return nearestEntry;
}

References _capturePointInfo, BG_AB_DYNAMIC_NODES_COUNT, BG_AB_GraveyardIds, BG_AB_NODE_STABLES, BG_AB_SPIRIT_ALIANCE, Position::GetPositionX(), Position::GetPositionY(), Player::GetTeamId(), sGraveyard, GraveyardStruct::x, and GraveyardStruct::y.

◆ GetPrematureWinner()

TeamId BattlegroundAB::GetPrematureWinner ( )

overridevirtual

Reimplemented from Battleground.

{
    if (_controlledPoints[TEAM_ALLIANCE] > _controlledPoints[TEAM_HORDE])
        return TEAM_ALLIANCE;
    return _controlledPoints[TEAM_HORDE] > _controlledPoints[TEAM_ALLIANCE] ? TEAM_HORDE : Battleground::GetPrematureWinner();
}

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

◆ HandleAreaTrigger()

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

overridevirtual

Reimplemented from Battleground.

{
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
    switch (trigger)
    {
        case 3948:                                          // Arathi Basin Alliance Exit.
            if (player->GetTeamId() != TEAM_ALLIANCE)
                player->GetSession()->SendAreaTriggerMessage("Only The Alliance can use that portal");
            else
                player->LeaveBattleground();
            break;
        case 3949:                                          // Arathi Basin Horde Exit.
            if (player->GetTeamId() != TEAM_HORDE)
                player->GetSession()->SendAreaTriggerMessage("Only The Horde can use that portal");
            else
                player->LeaveBattleground();
            break;
        case 3866:                                          // Stables
        case 3869:                                          // Gold Mine
        case 3867:                                          // Farm
        case 3868:                                          // Lumber Mill
        case 3870:                                          // Black Smith
        case 4020:                                          // Unk1
        case 4021:                                          // Unk2
            break;
        default:
            break;
    }
}

References Player::GetSession(), Battleground::GetStatus(), Player::GetTeamId(), Player::LeaveBattleground(), WorldSession::SendAreaTriggerMessage(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, and TEAM_HORDE.

◆ Init()

void BattlegroundAB::Init ( )

overridevirtual

Reimplemented from Battleground.

{
    //call parent's class reset
    Battleground::Init();
 
    _bgEvents.Reset();
 
    _honorTics = BattlegroundMgr::IsBGWeekend(GetBgTypeID(true)) ? BG_AB_HONOR_TICK_WEEKEND : BG_AB_HONOR_TICK_NORMAL;
    _reputationTics = BattlegroundMgr::IsBGWeekend(GetBgTypeID(true)) ? BG_AB_REP_TICK_WEEKEND : BG_AB_REP_TICK_NORMAL;
 
    _capturePointInfo[BG_AB_NODE_STABLES]._iconNone = WORLD_STATE_BATTLEGROUND_AB_STABLE_ICON;
    _capturePointInfo[BG_AB_NODE_FARM]._iconNone = WORLD_STATE_BATTLEGROUND_AB_FARM_ICON;
    _capturePointInfo[BG_AB_NODE_BLACKSMITH]._iconNone = WORLD_STATE_BATTLEGROUND_AB_BLACKSMITH_ICON;
    _capturePointInfo[BG_AB_NODE_LUMBER_MILL]._iconNone = WORLD_STATE_BATTLEGROUND_AB_LUMBERMILL_ICON;
    _capturePointInfo[BG_AB_NODE_GOLD_MINE]._iconNone = WORLD_STATE_BATTLEGROUND_AB_GOLDMINE_ICON;
    _capturePointInfo[BG_AB_NODE_STABLES]._iconCapture = WORLD_STATE_BATTLEGROUND_AB_STABLE_STATE_ALLIANCE;
    _capturePointInfo[BG_AB_NODE_FARM]._iconCapture = WORLD_STATE_BATTLEGROUND_AB_FARM_STATE_ALLIANCE;
    _capturePointInfo[BG_AB_NODE_BLACKSMITH]._iconCapture = WORLD_STATE_BATTLEGROUND_AB_BLACKSMITH_STATE_ALLIANCE;
    _capturePointInfo[BG_AB_NODE_LUMBER_MILL]._iconCapture = WORLD_STATE_BATTLEGROUND_AB_LUMBERMILL_STATE_ALLIANCE;
    _capturePointInfo[BG_AB_NODE_GOLD_MINE]._iconCapture = WORLD_STATE_BATTLEGROUND_AB_GOLDMINE_STATE_ALLIANCE;
 
    uint32 bgArathiCapturePointsConfig = sWorld->getIntConfig(CONFIG_BATTLEGROUND_ARATHI_CAPTUREPOINTS);
    _configurableMaxTeamScore = bgArathiCapturePointsConfig > 0
        ? bgArathiCapturePointsConfig
        : static_cast<uint32>(BG_AB_MAX_TEAM_SCORE);
}

◆ IsTeamScores500Disadvantage()

bool BattlegroundAB::IsTeamScores500Disadvantage ( TeamId teamId ) const

inline

271{ return _teamScores500Disadvantage[teamId]; }

Referenced by achievement_resilient_victory::OnCheck().

◆ NodeDeoccupied()

void BattlegroundAB::NodeDeoccupied ( uint8 node )

private

{
    --_controlledPoints[_capturePointInfo[node]._ownerTeamId];
 
    _capturePointInfo[node]._ownerTeamId = TEAM_NEUTRAL;
 
    _reviveEvents.AddEventAtOffset([this, node]()
    {
        RelocateDeadPlayers(BgCreatures[node]);
        DelCreature(node); // Delete spirit healer
    }, 500ms);
 
    DelCreature(BG_AB_ALL_NODES_COUNT + node); // Delete aura trigger
}

References _capturePointInfo, _controlledPoints, BattlegroundAB::CapturePointInfo::_ownerTeamId, Battleground::_reviveEvents, EventProcessor::AddEventAtOffset(), BG_AB_ALL_NODES_COUNT, Battleground::BgCreatures, Battleground::DelCreature(), Battleground::RelocateDeadPlayers(), and TEAM_NEUTRAL.

Referenced by EventPlayerClickedOnFlag().

◆ NodeOccupied()

void BattlegroundAB::NodeOccupied ( uint8 node )

private

{
    ApplyPhaseMask();
    AddSpiritGuide(node, BG_AB_SpiritGuidePos[node][0], BG_AB_SpiritGuidePos[node][1], BG_AB_SpiritGuidePos[node][2], BG_AB_SpiritGuidePos[node][3], _capturePointInfo[node]._ownerTeamId);
 
    ++_controlledPoints[_capturePointInfo[node]._ownerTeamId];
    if (_controlledPoints[_capturePointInfo[node]._ownerTeamId] >= 5)
        CastSpellOnTeam(SPELL_AB_QUEST_REWARD_5_BASES, _capturePointInfo[node]._ownerTeamId);
    if (_controlledPoints[_capturePointInfo[node]._ownerTeamId] >= 4)
        CastSpellOnTeam(SPELL_AB_QUEST_REWARD_4_BASES, _capturePointInfo[node]._ownerTeamId);
 
    Creature* trigger = GetBgMap()->GetCreature(BgCreatures[BG_AB_ALL_NODES_COUNT + node]);
    if (!trigger)
        trigger = AddCreature(WORLD_TRIGGER, BG_AB_ALL_NODES_COUNT + node, BG_AB_NodePositions[node][0], BG_AB_NodePositions[node][1], BG_AB_NodePositions[node][2], BG_AB_NodePositions[node][3]);
 
    if (trigger)
    {
        trigger->SetFaction(_capturePointInfo[node]._ownerTeamId == TEAM_ALLIANCE ? FACTION_ALLIANCE_GENERIC : FACTION_HORDE_GENERIC);
        trigger->CastSpell(trigger, SPELL_HONORABLE_DEFENDER_25Y, false);
    }
}

References _capturePointInfo, _controlledPoints, BattlegroundAB::CapturePointInfo::_ownerTeamId, Battleground::AddCreature(), Battleground::AddSpiritGuide(), ApplyPhaseMask(), BG_AB_ALL_NODES_COUNT, BG_AB_NodePositions, BG_AB_SpiritGuidePos, Battleground::BgCreatures, Unit::CastSpell(), Battleground::CastSpellOnTeam(), FACTION_ALLIANCE_GENERIC, FACTION_HORDE_GENERIC, Battleground::GetBgMap(), Map::GetCreature(), Unit::SetFaction(), SPELL_AB_QUEST_REWARD_4_BASES, SPELL_AB_QUEST_REWARD_5_BASES, SPELL_HONORABLE_DEFENDER_25Y, TEAM_ALLIANCE, and WORLD_TRIGGER.

Referenced by EventPlayerClickedOnFlag(), and PostUpdateImpl().

◆ PostUpdateImpl()

void BattlegroundAB::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_AB_EVENT_UPDATE_BANNER_STABLE:
                case BG_AB_EVENT_UPDATE_BANNER_FARM:
                case BG_AB_EVENT_UPDATE_BANNER_BLACKSMITH:
                case BG_AB_EVENT_UPDATE_BANNER_LUMBERMILL:
                case BG_AB_EVENT_UPDATE_BANNER_GOLDMINE:
                    CreateBanner(eventId - BG_AB_EVENT_UPDATE_BANNER_STABLE, false);
                    break;
                case BG_AB_EVENT_CAPTURE_STABLE:
                case BG_AB_EVENT_CAPTURE_FARM:
                case BG_AB_EVENT_CAPTURE_BLACKSMITH:
                case BG_AB_EVENT_CAPTURE_LUMBERMILL:
                case BG_AB_EVENT_CAPTURE_GOLDMINE:
                    {
                        uint8 node = eventId - BG_AB_EVENT_CAPTURE_STABLE;
                        TeamId teamId = _capturePointInfo[node]._state == BG_AB_NODE_STATE_ALLY_CONTESTED ? TEAM_ALLIANCE : TEAM_HORDE;
                        DeleteBanner(node);
                        _capturePointInfo[node]._ownerTeamId = teamId;
                        _capturePointInfo[node]._state = teamId == TEAM_ALLIANCE ? BG_AB_NODE_STATE_ALLY_OCCUPIED : BG_AB_NODE_STATE_HORDE_OCCUPIED;
                        _capturePointInfo[node]._captured = true;
 
                        CreateBanner(node, false);
                        NodeOccupied(node);
                        SendNodeUpdate(node);
 
                        if (teamId == TEAM_ALLIANCE)
                        {
                            SendBroadcastText(ABNodes[node].TextAllianceTaken, CHAT_MSG_BG_SYSTEM_ALLIANCE);
                            PlaySoundToAll(BG_AB_SOUND_NODE_CAPTURED_ALLIANCE);
                        }
                        else
                        {
                            SendBroadcastText(ABNodes[node].TextHordeTaken, CHAT_MSG_BG_SYSTEM_HORDE);
                            PlaySoundToAll(BG_AB_SOUND_NODE_CAPTURED_HORDE);
                        }
 
                        break;
                    }
                case BG_AB_EVENT_ALLIANCE_TICK:
                case BG_AB_EVENT_HORDE_TICK:
                    {
                        auto teamId = TeamId(eventId - BG_AB_EVENT_ALLIANCE_TICK);
                        uint8 controlledPoints = _controlledPoints[teamId];
                        if (controlledPoints == 0)
                        {
                            _bgEvents.ScheduleEvent(eventId, 3000);
                            break;
                        }
 
                        auto honorRewards = uint8(m_TeamScores[teamId] / _honorTics);
                        auto reputationRewards = uint8(m_TeamScores[teamId] / _reputationTics);
                        auto information = uint8(m_TeamScores[teamId] / BG_AB_WARNING_NEAR_VICTORY_SCORE);
                        m_TeamScores[teamId] += BG_AB_TickPoints[controlledPoints];
                        if (m_TeamScores[teamId] > static_cast<int32>(_configurableMaxTeamScore))
                            m_TeamScores[teamId] = _configurableMaxTeamScore;
 
                        if (honorRewards < uint8(m_TeamScores[teamId] / _honorTics))
                            RewardHonorToTeam(GetBonusHonorFromKill(1), teamId);
                        if (reputationRewards < uint8(m_TeamScores[teamId] / _reputationTics))
                            RewardReputationToTeam(teamId == TEAM_ALLIANCE ? 509 : 510, 10, teamId);
                        if (information < uint8(m_TeamScores[teamId] / BG_AB_WARNING_NEAR_VICTORY_SCORE))
                        {
                            if (teamId == TEAM_ALLIANCE)
                            {
                                SendBroadcastText(BG_AB_TEXT_ALLIANCE_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);
                                PlaySoundToAll(BG_AB_SOUND_NEAR_VICTORY_ALLIANCE);
                            }
                            else
                            {
                                SendBroadcastText(BG_AB_TEXT_HORDE_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);
                                PlaySoundToAll(BG_AB_SOUND_NEAR_VICTORY_HORDE);
                            }
                        }
 
                        UpdateWorldState(teamId == TEAM_ALLIANCE ? WORLD_STATE_BATTLEGROUND_AB_RESOURCES_ALLIANCE : WORLD_STATE_BATTLEGROUND_AB_RESOURCES_HORDE, m_TeamScores[teamId]);
                        if (m_TeamScores[teamId] > m_TeamScores[GetOtherTeamId(teamId)] + 500)
                            _teamScores500Disadvantage[GetOtherTeamId(teamId)] = true;
                        if (m_TeamScores[teamId] >= static_cast<int32>(_configurableMaxTeamScore))
                            EndBattleground(teamId);
 
                        _bgEvents.ScheduleEvent(eventId, BG_AB_TickIntervals[controlledPoints]);
                        break;
                    }
                default:
                    break;
            }
    }
}

References _bgEvents, BattlegroundAB::CapturePointInfo::_captured, _capturePointInfo, _configurableMaxTeamScore, _controlledPoints, _honorTics, BattlegroundAB::CapturePointInfo::_ownerTeamId, _reputationTics, BattlegroundAB::CapturePointInfo::_state, _teamScores500Disadvantage, ABNodes, BG_AB_EVENT_ALLIANCE_TICK, BG_AB_EVENT_CAPTURE_BLACKSMITH, BG_AB_EVENT_CAPTURE_FARM, BG_AB_EVENT_CAPTURE_GOLDMINE, BG_AB_EVENT_CAPTURE_LUMBERMILL, BG_AB_EVENT_CAPTURE_STABLE, BG_AB_EVENT_HORDE_TICK, BG_AB_EVENT_UPDATE_BANNER_BLACKSMITH, BG_AB_EVENT_UPDATE_BANNER_FARM, BG_AB_EVENT_UPDATE_BANNER_GOLDMINE, BG_AB_EVENT_UPDATE_BANNER_LUMBERMILL, BG_AB_EVENT_UPDATE_BANNER_STABLE, BG_AB_NODE_STATE_ALLY_CONTESTED, BG_AB_NODE_STATE_ALLY_OCCUPIED, BG_AB_NODE_STATE_HORDE_OCCUPIED, BG_AB_SOUND_NEAR_VICTORY_ALLIANCE, BG_AB_SOUND_NEAR_VICTORY_HORDE, BG_AB_SOUND_NODE_CAPTURED_ALLIANCE, BG_AB_SOUND_NODE_CAPTURED_HORDE, BG_AB_TEXT_ALLIANCE_NEAR_VICTORY, BG_AB_TEXT_HORDE_NEAR_VICTORY, BG_AB_TickIntervals, BG_AB_TickPoints, BG_AB_WARNING_NEAR_VICTORY_SCORE, CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, CHAT_MSG_BG_SYSTEM_NEUTRAL, CreateBanner(), DeleteBanner(), EndBattleground(), EventMap::ExecuteEvent(), Battleground::GetBonusHonorFromKill(), Battleground::GetOtherTeamId(), Battleground::GetStatus(), Battleground::m_TeamScores, NodeOccupied(), Battleground::PlaySoundToAll(), Battleground::RewardHonorToTeam(), Battleground::RewardReputationToTeam(), EventMap::ScheduleEvent(), Battleground::SendBroadcastText(), SendNodeUpdate(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, EventMap::Update(), Battleground::UpdateWorldState(), WORLD_STATE_BATTLEGROUND_AB_RESOURCES_ALLIANCE, and WORLD_STATE_BATTLEGROUND_AB_RESOURCES_HORDE.

◆ RemovePlayer()

void BattlegroundAB::RemovePlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

{
    player->SetPhaseMask(1, false);
}

References Unit::SetPhaseMask().

◆ SendNodeUpdate()

void BattlegroundAB::SendNodeUpdate ( uint8 node )

private

{
    UpdateWorldState(_capturePointInfo[node]._iconNone, 0);
    for (uint8 i = BG_AB_NODE_STATE_ALLY_OCCUPIED; i <= BG_AB_NODE_STATE_HORDE_CONTESTED; ++i)
        UpdateWorldState(_capturePointInfo[node]._iconCapture + i - 1, _capturePointInfo[node]._state == i);
 
    UpdateWorldState(WORLD_STATE_BATTLEGROUND_AB_OCCUPIED_BASES_ALLIANCE, _controlledPoints[TEAM_ALLIANCE]);
    UpdateWorldState(WORLD_STATE_BATTLEGROUND_AB_OCCUPIED_BASES_HORDE, _controlledPoints[TEAM_HORDE]);
}

References _capturePointInfo, _controlledPoints, BG_AB_NODE_STATE_ALLY_OCCUPIED, BG_AB_NODE_STATE_HORDE_CONTESTED, TEAM_ALLIANCE, TEAM_HORDE, Battleground::UpdateWorldState(), WORLD_STATE_BATTLEGROUND_AB_OCCUPIED_BASES_ALLIANCE, and WORLD_STATE_BATTLEGROUND_AB_OCCUPIED_BASES_HORDE.

Referenced by EventPlayerClickedOnFlag(), and PostUpdateImpl().

◆ SetupBattleground()

bool BattlegroundAB::SetupBattleground ( )

overridevirtual

Reimplemented from Battleground.

{
    for (uint32 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
    {
        AddObject(BG_AB_OBJECT_BANNER_NEUTRAL + BG_AB_OBJECTS_PER_NODE * i, BG_AB_OBJECTID_NODE_BANNER_0 + i, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, std::sin(BG_AB_NodePositions[i][3] / 2), cos(BG_AB_NodePositions[i][3] / 2), RESPAWN_ONE_DAY);
        AddObject(BG_AB_OBJECT_BANNER_ALLY + BG_AB_OBJECTS_PER_NODE * i, BG_AB_OBJECTID_BANNER_A, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, std::sin(BG_AB_NodePositions[i][3] / 2), cos(BG_AB_NodePositions[i][3] / 2), RESPAWN_ONE_DAY);
        AddObject(BG_AB_OBJECT_BANNER_HORDE + BG_AB_OBJECTS_PER_NODE * i, BG_AB_OBJECTID_BANNER_H, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, std::sin(BG_AB_NodePositions[i][3] / 2), cos(BG_AB_NodePositions[i][3] / 2), RESPAWN_ONE_DAY);
        AddObject(BG_AB_OBJECT_BANNER_CONT_A + BG_AB_OBJECTS_PER_NODE * i, BG_AB_OBJECTID_BANNER_CONT_A, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, std::sin(BG_AB_NodePositions[i][3] / 2), cos(BG_AB_NodePositions[i][3] / 2), RESPAWN_ONE_DAY);
        AddObject(BG_AB_OBJECT_BANNER_CONT_H + BG_AB_OBJECTS_PER_NODE * i, BG_AB_OBJECTID_BANNER_CONT_H, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, std::sin(BG_AB_NodePositions[i][3] / 2), cos(BG_AB_NodePositions[i][3] / 2), RESPAWN_ONE_DAY);
        AddObject(BG_AB_OBJECT_AURA_ALLY + BG_AB_OBJECTS_PER_NODE * i, BG_AB_OBJECTID_AURA_A, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, std::sin(BG_AB_NodePositions[i][3] / 2), cos(BG_AB_NodePositions[i][3] / 2), RESPAWN_ONE_DAY);
        AddObject(BG_AB_OBJECT_AURA_HORDE + BG_AB_OBJECTS_PER_NODE * i, BG_AB_OBJECTID_AURA_H, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, std::sin(BG_AB_NodePositions[i][3] / 2), cos(BG_AB_NodePositions[i][3] / 2), RESPAWN_ONE_DAY);
        AddObject(BG_AB_OBJECT_AURA_CONTESTED + BG_AB_OBJECTS_PER_NODE * i, BG_AB_OBJECTID_AURA_C, BG_AB_NodePositions[i][0], BG_AB_NodePositions[i][1], BG_AB_NodePositions[i][2], BG_AB_NodePositions[i][3], 0, 0, std::sin(BG_AB_NodePositions[i][3] / 2), cos(BG_AB_NodePositions[i][3] / 2), RESPAWN_ONE_DAY);
    }
 
    AddObject(BG_AB_OBJECT_GATE_A, BG_AB_OBJECTID_GATE_A, BG_AB_DoorPositions[0][0], BG_AB_DoorPositions[0][1], BG_AB_DoorPositions[0][2], BG_AB_DoorPositions[0][3], BG_AB_DoorPositions[0][4], BG_AB_DoorPositions[0][5], BG_AB_DoorPositions[0][6], BG_AB_DoorPositions[0][7], RESPAWN_IMMEDIATELY);
    AddObject(BG_AB_OBJECT_GATE_H, BG_AB_OBJECTID_GATE_H, BG_AB_DoorPositions[1][0], BG_AB_DoorPositions[1][1], BG_AB_DoorPositions[1][2], BG_AB_DoorPositions[1][3], BG_AB_DoorPositions[1][4], BG_AB_DoorPositions[1][5], BG_AB_DoorPositions[1][6], BG_AB_DoorPositions[1][7], RESPAWN_IMMEDIATELY);
 
    for (uint32 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
    {
        AddObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + 3 * i, Buff_Entries[0], BG_AB_BuffPositions[i][0], BG_AB_BuffPositions[i][1], BG_AB_BuffPositions[i][2], BG_AB_BuffPositions[i][3], 0, 0, std::sin(BG_AB_BuffPositions[i][3] / 2), cos(BG_AB_BuffPositions[i][3] / 2), RESPAWN_ONE_DAY);
        AddObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + 3 * i + 1, Buff_Entries[1], BG_AB_BuffPositions[i][0], BG_AB_BuffPositions[i][1], BG_AB_BuffPositions[i][2], BG_AB_BuffPositions[i][3], 0, 0, std::sin(BG_AB_BuffPositions[i][3] / 2), cos(BG_AB_BuffPositions[i][3] / 2), RESPAWN_ONE_DAY);
        AddObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + 3 * i + 2, Buff_Entries[2], BG_AB_BuffPositions[i][0], BG_AB_BuffPositions[i][1], BG_AB_BuffPositions[i][2], BG_AB_BuffPositions[i][3], 0, 0, std::sin(BG_AB_BuffPositions[i][3] / 2), cos(BG_AB_BuffPositions[i][3] / 2), RESPAWN_ONE_DAY);
    }
 
    AddSpiritGuide(BG_AB_SPIRIT_ALIANCE, BG_AB_SpiritGuidePos[BG_AB_SPIRIT_ALIANCE][0], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_ALIANCE][1], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_ALIANCE][2], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_ALIANCE][3], TEAM_ALLIANCE);
    AddSpiritGuide(BG_AB_SPIRIT_HORDE, BG_AB_SpiritGuidePos[BG_AB_SPIRIT_HORDE][0], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_HORDE][1], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_HORDE][2], BG_AB_SpiritGuidePos[BG_AB_SPIRIT_HORDE][3], TEAM_HORDE);
 
    for (uint32 i = BG_AB_OBJECT_BANNER_NEUTRAL; i < BG_AB_OBJECT_MAX; ++i)
        if (!BgObjects[i])
        {
            LOG_ERROR("sql.sql", "BatteGroundAB: Failed to spawn some object Battleground not created!");
            return false;
        }
 
    for (uint32 i = BG_AB_SPIRIT_ALIANCE; i <= BG_AB_SPIRIT_HORDE; ++i)
        if (!BgCreatures[i])
        {
            LOG_ERROR("sql.sql", "BatteGroundAB: Failed to spawn spirit guides Battleground not created!");
            return false;
        }
 
    return true;
}

References Battleground::AddObject(), Battleground::AddSpiritGuide(), BG_AB_BuffPositions, BG_AB_DoorPositions, BG_AB_DYNAMIC_NODES_COUNT, BG_AB_NodePositions, BG_AB_OBJECT_AURA_ALLY, BG_AB_OBJECT_AURA_CONTESTED, BG_AB_OBJECT_AURA_HORDE, BG_AB_OBJECT_BANNER_ALLY, BG_AB_OBJECT_BANNER_CONT_A, BG_AB_OBJECT_BANNER_CONT_H, BG_AB_OBJECT_BANNER_HORDE, BG_AB_OBJECT_BANNER_NEUTRAL, BG_AB_OBJECT_GATE_A, BG_AB_OBJECT_GATE_H, BG_AB_OBJECT_MAX, BG_AB_OBJECT_SPEEDBUFF_STABLES, BG_AB_OBJECTID_AURA_A, BG_AB_OBJECTID_AURA_C, BG_AB_OBJECTID_AURA_H, BG_AB_OBJECTID_BANNER_A, BG_AB_OBJECTID_BANNER_CONT_A, BG_AB_OBJECTID_BANNER_CONT_H, BG_AB_OBJECTID_BANNER_H, BG_AB_OBJECTID_GATE_A, BG_AB_OBJECTID_GATE_H, BG_AB_OBJECTID_NODE_BANNER_0, BG_AB_OBJECTS_PER_NODE, BG_AB_SPIRIT_ALIANCE, BG_AB_SPIRIT_HORDE, BG_AB_SpiritGuidePos, Battleground::BgCreatures, Battleground::BgObjects, Buff_Entries, LOG_ERROR, RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, TEAM_ALLIANCE, and TEAM_HORDE.

◆ StartingEventCloseDoors()

void BattlegroundAB::StartingEventCloseDoors ( )

overridevirtual

Reimplemented from Battleground.

{
    for (uint32 obj = BG_AB_OBJECT_BANNER_NEUTRAL; obj < static_cast<uint8>(BG_AB_DYNAMIC_NODES_COUNT) * BG_AB_OBJECTS_PER_NODE; ++obj)
        SpawnBGObject(obj, RESPAWN_ONE_DAY);
    for (uint32 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT * 3; ++i)
        SpawnBGObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + i, RESPAWN_ONE_DAY);
 
    // Starting doors
    SpawnBGObject(BG_AB_OBJECT_GATE_A, RESPAWN_IMMEDIATELY);
    SpawnBGObject(BG_AB_OBJECT_GATE_H, RESPAWN_IMMEDIATELY);
    DoorClose(BG_AB_OBJECT_GATE_A);
    DoorClose(BG_AB_OBJECT_GATE_H);
}

References BG_AB_DYNAMIC_NODES_COUNT, BG_AB_OBJECT_BANNER_NEUTRAL, BG_AB_OBJECT_GATE_A, BG_AB_OBJECT_GATE_H, BG_AB_OBJECT_SPEEDBUFF_STABLES, BG_AB_OBJECTS_PER_NODE, Battleground::DoorClose(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, and Battleground::SpawnBGObject().

◆ StartingEventOpenDoors()

void BattlegroundAB::StartingEventOpenDoors ( )

overridevirtual

Reimplemented from Battleground.

{
    for (uint32 banner = BG_AB_OBJECT_BANNER_NEUTRAL, i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; banner += BG_AB_OBJECTS_PER_NODE, ++i)
        SpawnBGObject(banner, RESPAWN_IMMEDIATELY);
 
    for (uint32 i = 0; i < BG_AB_DYNAMIC_NODES_COUNT; ++i)
        SpawnBGObject(BG_AB_OBJECT_SPEEDBUFF_STABLES + urand(0, 2) + i * 3, RESPAWN_IMMEDIATELY);
 
    DoorOpen(BG_AB_OBJECT_GATE_A);
    DoorOpen(BG_AB_OBJECT_GATE_H);
    StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, BG_AB_EVENT_START_BATTLE);
    _bgEvents.ScheduleEvent(BG_AB_EVENT_ALLIANCE_TICK, 3000);
    _bgEvents.ScheduleEvent(BG_AB_EVENT_HORDE_TICK, 3000);
}

References _bgEvents, ACHIEVEMENT_TIMED_TYPE_EVENT, BG_AB_DYNAMIC_NODES_COUNT, BG_AB_EVENT_ALLIANCE_TICK, BG_AB_EVENT_HORDE_TICK, BG_AB_EVENT_START_BATTLE, BG_AB_OBJECT_BANNER_NEUTRAL, BG_AB_OBJECT_GATE_A, BG_AB_OBJECT_GATE_H, BG_AB_OBJECT_SPEEDBUFF_STABLES, BG_AB_OBJECTS_PER_NODE, Battleground::DoorOpen(), RESPAWN_IMMEDIATELY, EventMap::ScheduleEvent(), Battleground::SpawnBGObject(), Battleground::StartTimedAchievement(), and urand().

◆ UpdatePlayerScore()

bool BattlegroundAB::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_BASES_ASSAULTED:
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, BG_AB_OBJECTIVE_ASSAULT_BASE);
            break;
        case SCORE_BASES_DEFENDED:
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, BG_AB_OBJECTIVE_DEFEND_BASE);
            break;
        default:
            break;
    }
 
    return true;
}

References ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, BG_AB_OBJECTIVE_ASSAULT_BASE, BG_AB_OBJECTIVE_DEFEND_BASE, SCORE_BASES_ASSAULTED, SCORE_BASES_DEFENDED, Player::UpdateAchievementCriteria(), and Battleground::UpdatePlayerScore().

Referenced by EventPlayerClickedOnFlag().

Member Data Documentation

◆ _bgEvents

EventMap BattlegroundAB::_bgEvents

private

Referenced by CreateBanner(), EndBattleground(), EventPlayerClickedOnFlag(), Init(), PostUpdateImpl(), and StartingEventOpenDoors().

◆ _capturePointInfo

CapturePointInfo BattlegroundAB::_capturePointInfo[BG_AB_DYNAMIC_NODES_COUNT]

private

Referenced by ApplyPhaseMask(), CreateBanner(), DeleteBanner(), EventPlayerClickedOnFlag(), FillInitialWorldStates(), GetClosestGraveyard(), Init(), NodeDeoccupied(), NodeOccupied(), PostUpdateImpl(), and SendNodeUpdate().

◆ _configurableMaxTeamScore

uint32 BattlegroundAB::_configurableMaxTeamScore

private

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

◆ _controlledPoints

uint8 BattlegroundAB::_controlledPoints[PVP_TEAMS_COUNT] {}

private

302{};

Referenced by AllNodesConrolledByTeam(), BattlegroundAB(), FillInitialWorldStates(), GetPrematureWinner(), NodeDeoccupied(), NodeOccupied(), PostUpdateImpl(), and SendNodeUpdate().

◆ _honorTics

uint32 BattlegroundAB::_honorTics

private

Referenced by BattlegroundAB(), Init(), and PostUpdateImpl().

◆ _reputationTics

uint32 BattlegroundAB::_reputationTics

private

Referenced by BattlegroundAB(), Init(), and PostUpdateImpl().

◆ _teamScores500Disadvantage

bool BattlegroundAB::_teamScores500Disadvantage[PVP_TEAMS_COUNT] {}

private

303{};

Referenced by BattlegroundAB(), and PostUpdateImpl().

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

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BattlegroundAB()

◆ ~BattlegroundAB()

Member Function Documentation

◆ AddPlayer()

◆ AllNodesConrolledByTeam()

◆ ApplyPhaseMask()

◆ CreateBanner()

◆ DeleteBanner()

◆ EndBattleground()

◆ EventPlayerClickedOnFlag()

◆ FillInitialWorldStates()

◆ GetClosestGraveyard()

◆ GetPrematureWinner()

◆ HandleAreaTrigger()

◆ Init()

◆ IsTeamScores500Disadvantage()

◆ NodeDeoccupied()

◆ NodeOccupied()

◆ PostUpdateImpl()

◆ RemovePlayer()

◆ SendNodeUpdate()

◆ SetupBattleground()

◆ StartingEventCloseDoors()

◆ StartingEventOpenDoors()

◆ UpdatePlayerScore()

Member Data Documentation

◆ _bgEvents

◆ _capturePointInfo

◆ _configurableMaxTeamScore

◆ _controlledPoints

◆ _honorTics

◆ _reputationTics

◆ _teamScores500Disadvantage