#include "BattlegroundAV.h"

Inheritance diagram for BattlegroundAV:

Public Member Functions
	BattlegroundAV ()

	~BattlegroundAV () override=default

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	ResetBGSubclass () override

void	UpdateScore (TeamId teamId, int16 points)

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

void	EventPlayerClickedOnFlag (Player source, GameObject gameObject) override

void	HandleKillPlayer (Player player, Player killer) override

void	HandleKillUnit (Creature unit, Player killer) override

void	HandleQuestComplete (uint32 questid, Player *player)

bool	PlayerCanDoMineQuest (int32 GOId, TeamId teamId)

void	EndBattleground (TeamId winnerTeamId) override

GraveyardStruct const *	GetClosestGraveyard (Player *player) override

bool	IsBothMinesControlledByTeam (TeamId teamId) const

bool	IsAllTowersControlledAndCaptainAlive (TeamId teamId) const

TeamId	GetPrematureWinner () override

Public Member Functions inherited from Battleground
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual void	Init ()

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	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	EventPlayerAssaultsPoint (Player *player, uint32 object)

void	EventPlayerDefendsPoint (Player *player, uint32 object)

void	EventPlayerDestroyedPoint (BG_AV_Nodes node)

void	AssaultNode (BG_AV_Nodes node, TeamId teamId)

void	DestroyNode (BG_AV_Nodes node)

void	InitNode (BG_AV_Nodes node, TeamId teamId, bool tower)

void	DefendNode (BG_AV_Nodes node, TeamId teamId)

void	PopulateNode (BG_AV_Nodes node)

void	DePopulateNode (BG_AV_Nodes node, bool ignoreSpiritGuid=false)

BG_AV_Nodes	GetNodeThroughObject (uint32 object)

uint32	GetObjectThroughNode (BG_AV_Nodes node)

bool	IsTower (BG_AV_Nodes node)

uint8	GetAttackString (BG_AV_Nodes node, TeamId teamId)

uint8	GetDefendString (BG_AV_Nodes node, TeamId teamId)

uint8	GetMineString (uint8 mine, TeamId teamId)

void	ChangeMineOwner (uint8 mine, TeamId teamId, bool initial=false)

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

uint8	GetWorldStateType (uint8 state, TeamId teamId)

void	SendMineWorldStates (uint32 mine)

void	UpdateNodeWorldState (BG_AV_Nodes node)

Creature *	AddAVCreature (uint16 cinfoid, uint16 type)

Private Attributes
int32	m_Team_Scores [2] {}

uint32	m_Team_QuestStatus [2][9] {}

BG_AV_NodeInfo	m_Nodes [BG_AV_NODES_MAX] {}

TeamId	m_Mine_Owner [2] {}

int32	m_Mine_Timer

uint32	m_Mine_Reclaim_Timer [2] {}

uint32	m_CaptainBuffTimer [2] {}

bool	m_CaptainAlive [2] {}

bool	m_IsInformedNearVictory [2] {}

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

◆ BattlegroundAV()

BattlegroundAV::BattlegroundAV ( )

{
    BgObjects.resize(BG_AV_OBJECT_MAX);
    BgCreatures.resize(static_cast<uint16>(AV_CPLACE_MAX) + AV_STATICCPLACE_MAX);
 
    for (uint8 i = 0; i < 2; i++)
    {
        for (uint8 j = 0; j < 9; j++)
            m_Team_QuestStatus[i][j] = 0;
        m_Team_Scores[i] = 0;
        m_IsInformedNearVictory[i] = false;
        m_CaptainAlive[i] = true;
        m_CaptainBuffTimer[i] = 0;
        m_Mine_Owner[i] = TEAM_NEUTRAL;
        m_Mine_Reclaim_Timer[i] = 0;
    }
 
    m_Mine_Timer = 0;
 
    for (BG_AV_Nodes i = BG_AV_NODES_FIRSTAID_STATION; i < BG_AV_NODES_MAX; ++i)
        InitNode(i, TEAM_NEUTRAL, false);
 
    StartMessageIds[BG_STARTING_EVENT_SECOND] = BG_AV_TEXT_START_ONE_MINUTE;
    StartMessageIds[BG_STARTING_EVENT_THIRD] = BG_AV_TEXT_START_HALF_MINUTE;
    StartMessageIds[BG_STARTING_EVENT_FOURTH] = BG_AV_TEXT_BATTLE_HAS_BEGUN;
}

References AV_CPLACE_MAX, AV_STATICCPLACE_MAX, BG_AV_NODES_FIRSTAID_STATION, BG_AV_NODES_MAX, BG_AV_OBJECT_MAX, BG_AV_TEXT_BATTLE_HAS_BEGUN, BG_AV_TEXT_START_HALF_MINUTE, BG_AV_TEXT_START_ONE_MINUTE, BG_STARTING_EVENT_FOURTH, BG_STARTING_EVENT_SECOND, BG_STARTING_EVENT_THIRD, Battleground::BgCreatures, Battleground::BgObjects, InitNode(), m_CaptainAlive, m_CaptainBuffTimer, m_IsInformedNearVictory, m_Mine_Owner, m_Mine_Reclaim_Timer, m_Mine_Timer, m_Team_QuestStatus, m_Team_Scores, Battleground::StartMessageIds, and TEAM_NEUTRAL.

◆ ~BattlegroundAV()

BattlegroundAV::~BattlegroundAV ( )

overridedefault

Member Function Documentation

◆ AddAVCreature()

Creature * BattlegroundAV::AddAVCreature	(	uint16	cinfoid,
		uint16	type
	)

private

Todo:: : look if this can be done by database + also add this for the wingcommanders

{
    bool isStatic = false;
    Creature* creature = nullptr;
    ASSERT(type <= static_cast<uint16>(AV_CPLACE_MAX) + AV_STATICCPLACE_MAX);
    if (type >= AV_CPLACE_MAX) //static
    {
        type -= AV_CPLACE_MAX;
        cinfoid = uint16(BG_AV_StaticCreaturePos[type][4]);
        creature = AddCreature(BG_AV_StaticCreatureInfo[cinfoid],
                               type + AV_CPLACE_MAX,
                               BG_AV_StaticCreaturePos[type][0],
                               BG_AV_StaticCreaturePos[type][1],
                               BG_AV_StaticCreaturePos[type][2],
                               BG_AV_StaticCreaturePos[type][3]);
        isStatic = true;
    }
    else
    {
        creature = AddCreature(BG_AV_CreatureInfo[cinfoid],
                               type,
                               BG_AV_CreaturePos[type][0],
                               BG_AV_CreaturePos[type][1],
                               BG_AV_CreaturePos[type][2],
                               BG_AV_CreaturePos[type][3]);
    }
    if (!creature)
        return nullptr;
    if (creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_A_CAPTAIN] || creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_H_CAPTAIN])
        creature->SetRespawnDelay(RESPAWN_ONE_DAY); 
 
    if (creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_A_TOWERDEFENSE] || creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_H_TOWERDEFENSE])
        creature->SetUnitFlag(UNIT_FLAG_DISABLE_MOVE);
 
    if ((isStatic && cinfoid >= 10 && cinfoid <= 14) || (!isStatic && ((cinfoid >= AV_NPC_A_GRAVEDEFENSE0 && cinfoid <= AV_NPC_A_GRAVEDEFENSE3) ||
            (cinfoid >= AV_NPC_H_GRAVEDEFENSE0 && cinfoid <= AV_NPC_H_GRAVEDEFENSE3))))
    {
        if (!isStatic && ((cinfoid >= AV_NPC_A_GRAVEDEFENSE0 && cinfoid <= AV_NPC_A_GRAVEDEFENSE3)
                          || (cinfoid >= AV_NPC_H_GRAVEDEFENSE0 && cinfoid <= AV_NPC_H_GRAVEDEFENSE3)))
        {
            CreatureData& data = sObjectMgr->NewOrExistCreatureData(creature->GetSpawnId());
            data.wander_distance = 5;
        }
        //else wander_distance will be 15, so creatures move maximum=10
        //creature->SetDefaultMovementType(RANDOM_MOTION_TYPE);
        creature->GetMotionMaster()->Initialize();
        creature->setDeathState(DeathState::JustDied);
        creature->Respawn();
        //TODO: find a way to add a motionmaster without killing the creature (i
        //just copied this code from a gm-command
    }
 
    uint32 triggerSpawnID = 0;
    uint32 newFaction = 0;
    if (creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_A_CAPTAIN])
    {
        triggerSpawnID = AV_CPLACE_TRIGGER16;
        newFaction = 84;
    }
    else if (creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_A_BOSS])
    {
        triggerSpawnID = AV_CPLACE_TRIGGER17;
        newFaction = 84;
    }
    else if (creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_H_CAPTAIN])
    {
        triggerSpawnID = AV_CPLACE_TRIGGER18;
        newFaction = 83;
    }
    else if (creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_H_BOSS])
    {
        triggerSpawnID = AV_CPLACE_TRIGGER19;
        newFaction = 83;
    }
    if (triggerSpawnID && newFaction)
    {
        if (Creature* trigger = AddCreature(WORLD_TRIGGER,
                                            triggerSpawnID,
                                            BG_AV_CreaturePos[triggerSpawnID][0],
                                            BG_AV_CreaturePos[triggerSpawnID][1],
                                            BG_AV_CreaturePos[triggerSpawnID][2],
                                            BG_AV_CreaturePos[triggerSpawnID][3]))
        {
            trigger->SetFaction(newFaction);
            trigger->CastSpell(trigger, SPELL_HONORABLE_DEFENDER_25Y, false);
        }
    }
 
    return creature;
}

References Battleground::AddCreature(), ASSERT, AV_CPLACE_MAX, AV_CPLACE_TRIGGER16, AV_CPLACE_TRIGGER17, AV_CPLACE_TRIGGER18, AV_CPLACE_TRIGGER19, AV_NPC_A_BOSS, AV_NPC_A_CAPTAIN, AV_NPC_A_GRAVEDEFENSE0, AV_NPC_A_GRAVEDEFENSE3, AV_NPC_A_TOWERDEFENSE, AV_NPC_H_BOSS, AV_NPC_H_CAPTAIN, AV_NPC_H_GRAVEDEFENSE0, AV_NPC_H_GRAVEDEFENSE3, AV_NPC_H_TOWERDEFENSE, AV_STATICCPLACE_MAX, BG_AV_CreatureInfo, BG_AV_CreaturePos, BG_AV_StaticCreatureInfo, BG_AV_StaticCreaturePos, Object::GetEntry(), Unit::GetMotionMaster(), Creature::GetSpawnId(), MotionMaster::Initialize(), isStatic(), JustDied, Creature::Respawn(), RESPAWN_ONE_DAY, Creature::setDeathState(), Creature::SetRespawnDelay(), Unit::SetUnitFlag(), sObjectMgr, SPELL_HONORABLE_DEFENDER_25Y, UNIT_FLAG_DISABLE_MOVE, CreatureData::wander_distance, and WORLD_TRIGGER.

Referenced by ChangeMineOwner(), PopulateNode(), and SetupBattleground().

◆ AddPlayer()

void BattlegroundAV::AddPlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

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

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

◆ AssaultNode()

void BattlegroundAV::AssaultNode	(	BG_AV_Nodes	node,
		TeamId	teamId
	)

private

{
    if (m_Nodes[node].TotalOwnerId == teamId)
    {
        LOG_FATAL("bg.battleground", "Assaulting team is TotalOwner of node");
        ABORT();
    }
    if (m_Nodes[node].OwnerId == teamId)
    {
        LOG_FATAL("bg.battleground", "Assaulting team is owner of node");
        ABORT();
    }
    if (m_Nodes[node].State == POINT_DESTROYED)
    {
        LOG_FATAL("bg.battleground", "Destroyed node is being assaulted");
        ABORT();
    }
    if (m_Nodes[node].State == POINT_ASSAULTED && m_Nodes[node].TotalOwnerId != TEAM_NEUTRAL) //only assault an assaulted node if no totalowner exists
    {
        LOG_FATAL("bg.battleground", "Assault on an not assaulted node with total owner");
        ABORT();
    }
    //the timer gets another time, if the previous owner was 0 == Neutral
    m_Nodes[node].Timer      = (m_Nodes[node].PrevOwnerId != TEAM_NEUTRAL) ? BG_AV_CAPTIME : BG_AV_SNOWFALL_FIRSTCAP;
    m_Nodes[node].PrevOwnerId = m_Nodes[node].OwnerId;
    m_Nodes[node].OwnerId    = teamId;
    m_Nodes[node].PrevState  = m_Nodes[node].State;
    m_Nodes[node].State      = POINT_ASSAULTED;
}

References ABORT, BG_AV_CAPTIME, BG_AV_SNOWFALL_FIRSTCAP, LOG_FATAL, m_Nodes, BG_AV_NodeInfo::OwnerId, POINT_ASSAULTED, POINT_DESTROYED, BG_AV_NodeInfo::PrevOwnerId, BG_AV_NodeInfo::PrevState, BG_AV_NodeInfo::State, TEAM_NEUTRAL, and BG_AV_NodeInfo::Timer.

Referenced by EventPlayerAssaultsPoint().

◆ ChangeMineOwner()

void BattlegroundAV::ChangeMineOwner	(	uint8	mine,
		TeamId	teamId,
		bool	initial = `false`
	)

private

{
    // mine=0 northmine mine=1 southmin
    // changing the owner results in setting respawntim to infinite for current creatures,
    // spawning new mine owners creatures and changing the chest-objects so that the current owning team can use them
 
    ASSERT(mine == AV_NORTH_MINE || mine == AV_SOUTH_MINE);
    if (teamId == TEAM_ALLIANCE || teamId == TEAM_HORDE)
        PlaySoundToAll((teamId == TEAM_ALLIANCE) ? AV_SOUND_ALLIANCE_GOOD : AV_SOUND_HORDE_GOOD);
 
    if (m_Mine_Owner[mine] == teamId && !initial)
        return;
    m_Mine_Owner[mine] = teamId;
 
    if (!initial)
    {
        LOG_DEBUG("bg.battleground", "bg_av depopulating mine {} (0=north, 1=south)", mine);
        if (mine == AV_SOUTH_MINE)
            for (uint16 i = AV_CPLACE_MINE_S_S_MIN; i <= AV_CPLACE_MINE_S_S_MAX; i++)
                if (BgCreatures[i])
                    DelCreature(i); //TODO just set the respawntime to 999999
        for (uint16 i = ((mine == AV_NORTH_MINE) ? AV_CPLACE_MINE_N_1_MIN : AV_CPLACE_MINE_S_1_MIN); i <= ((mine == AV_NORTH_MINE) ? AV_CPLACE_MINE_N_3 : AV_CPLACE_MINE_S_3); i++)
            if (BgCreatures[i])
                DelCreature(i); //TODO here also
    }
    SendMineWorldStates(mine);
 
    LOG_DEBUG("bg.battleground", "bg_av populating mine {} (0=north, 1=south)", mine);
    uint16 miner;
    //also neutral team exists.. after a big time, the neutral team tries to conquer the mine
    if (mine == AV_NORTH_MINE)
    {
        if (teamId == TEAM_ALLIANCE)
            miner = AV_NPC_N_MINE_A_1;
        else if (teamId == TEAM_HORDE)
            miner = AV_NPC_N_MINE_H_1;
        else
            miner = AV_NPC_N_MINE_N_1;
    }
    else
    {
        uint16 cinfo;
        if (teamId == TEAM_ALLIANCE)
            miner = AV_NPC_S_MINE_A_1;
        else if (teamId == TEAM_HORDE)
            miner = AV_NPC_S_MINE_H_1;
        else
            miner = AV_NPC_S_MINE_N_1;
        //vermin
        LOG_DEBUG("bg.battleground", "spawning vermin");
        if (teamId == TEAM_ALLIANCE)
            cinfo = AV_NPC_S_MINE_A_3;
        else if (teamId == TEAM_HORDE)
            cinfo = AV_NPC_S_MINE_H_3;
        else
            cinfo = AV_NPC_S_MINE_N_S;
        for (uint16 i = AV_CPLACE_MINE_S_S_MIN; i <= AV_CPLACE_MINE_S_S_MAX; i++)
            AddAVCreature(cinfo, i);
    }
    for (uint16 i = ((mine == AV_NORTH_MINE) ? AV_CPLACE_MINE_N_1_MIN : AV_CPLACE_MINE_S_1_MIN); i <= ((mine == AV_NORTH_MINE) ? AV_CPLACE_MINE_N_1_MAX : AV_CPLACE_MINE_S_1_MAX); i++)
        AddAVCreature(miner, i);
    //the next chooses randomly between 2 cretures
    for (uint16 i = ((mine == AV_NORTH_MINE) ? AV_CPLACE_MINE_N_2_MIN : AV_CPLACE_MINE_S_2_MIN); i <= ((mine == AV_NORTH_MINE) ? AV_CPLACE_MINE_N_2_MAX : AV_CPLACE_MINE_S_2_MAX); i++)
        AddAVCreature(miner + (urand(1, 2)), i);
    AddAVCreature(miner + 3, (mine == AV_NORTH_MINE) ? AV_CPLACE_MINE_N_3 : AV_CPLACE_MINE_S_3);
 
    if (teamId == TEAM_ALLIANCE || teamId == TEAM_HORDE)
    {
        m_Mine_Reclaim_Timer[mine] = AV_MINE_RECLAIM_TIMER;
        if (Creature* creature = GetBGCreature(AV_CPLACE_HERALD))
            creature->AI()->Talk(GetMineString(mine, teamId));
    }
    else
    {
        if (mine == AV_SOUTH_MINE) //i think this gets called all the time
        {
            if (Creature* creature = GetBGCreature(AV_CPLACE_MINE_S_3))
            {
                std::string creatureText = sCreatureTextMgr->GetLocalizedChatString(creature->GetEntry(), creature->getGender(), 0, 0, DEFAULT_LOCALE);
                YellToAll(creature, creatureText.c_str(), LANG_UNIVERSAL);
            }
        }
    }
}

References AddAVCreature(), Creature::AI(), ASSERT, AV_CPLACE_HERALD, AV_CPLACE_MINE_N_1_MAX, AV_CPLACE_MINE_N_1_MIN, AV_CPLACE_MINE_N_2_MAX, AV_CPLACE_MINE_N_2_MIN, AV_CPLACE_MINE_N_3, AV_CPLACE_MINE_S_1_MAX, AV_CPLACE_MINE_S_1_MIN, AV_CPLACE_MINE_S_2_MAX, AV_CPLACE_MINE_S_2_MIN, AV_CPLACE_MINE_S_3, AV_CPLACE_MINE_S_S_MAX, AV_CPLACE_MINE_S_S_MIN, AV_MINE_RECLAIM_TIMER, AV_NORTH_MINE, AV_NPC_N_MINE_A_1, AV_NPC_N_MINE_H_1, AV_NPC_N_MINE_N_1, AV_NPC_S_MINE_A_1, AV_NPC_S_MINE_A_3, AV_NPC_S_MINE_H_1, AV_NPC_S_MINE_H_3, AV_NPC_S_MINE_N_1, AV_NPC_S_MINE_N_S, AV_SOUND_ALLIANCE_GOOD, AV_SOUND_HORDE_GOOD, AV_SOUTH_MINE, Battleground::BgCreatures, DEFAULT_LOCALE, Battleground::DelCreature(), Battleground::GetBGCreature(), GetMineString(), LANG_UNIVERSAL, LOG_DEBUG, m_Mine_Owner, m_Mine_Reclaim_Timer, Battleground::PlaySoundToAll(), sCreatureTextMgr, SendMineWorldStates(), CreatureAI::Talk(), TEAM_ALLIANCE, TEAM_HORDE, urand(), and Battleground::YellToAll().

Referenced by HandleKillUnit(), PostUpdateImpl(), and StartingEventOpenDoors().

◆ DefendNode()

void BattlegroundAV::DefendNode	(	BG_AV_Nodes	node,
		TeamId	teamId
	)

private

{
    ASSERT(m_Nodes[node].TotalOwnerId == teamId);
    ASSERT(m_Nodes[node].OwnerId != teamId);
    ASSERT(m_Nodes[node].State != POINT_CONTROLED && m_Nodes[node].State != POINT_DESTROYED);
    m_Nodes[node].PrevOwnerId = m_Nodes[node].OwnerId;
    m_Nodes[node].OwnerId    = teamId;
    m_Nodes[node].PrevState  = m_Nodes[node].State;
    m_Nodes[node].State      = POINT_CONTROLED;
    m_Nodes[node].Timer      = 0;
}

References ASSERT, m_Nodes, BG_AV_NodeInfo::OwnerId, POINT_CONTROLED, POINT_DESTROYED, BG_AV_NodeInfo::PrevOwnerId, BG_AV_NodeInfo::PrevState, BG_AV_NodeInfo::State, and BG_AV_NodeInfo::Timer.

Referenced by EventPlayerDefendsPoint().

◆ DePopulateNode()

void BattlegroundAV::DePopulateNode	(	BG_AV_Nodes	node,
		bool	ignoreSpiritGuid = `false`
	)

private

{
    uint32 c_place = AV_CPLACE_DEFENSE_STORM_AID + (4 * node);
    for (uint8 i = 0; i < 4; i++)
    {
        if (BgCreatures[c_place + i])
        {
            DelCreature(c_place + i);
        }
    }
 
    //spiritguide
    if (!ignoreSpiritGuide && !IsTower(node))
    {
        DelCreature(node);
    }
 
    //remove bonus honor aura trigger creature when node is lost
    if (node < BG_AV_NODES_MAX)//fail safe
        DelCreature(node + 302);//nullptr checks are in DelCreature! 0-302 spirit guides
}

References AV_CPLACE_DEFENSE_STORM_AID, BG_AV_NODES_MAX, Battleground::BgCreatures, Battleground::DelCreature(), and IsTower().

Referenced by EventPlayerAssaultsPoint(), and HandleQuestComplete().

◆ DestroyNode()

void BattlegroundAV::DestroyNode ( BG_AV_Nodes node )

private

{
    ASSERT(m_Nodes[node].State == POINT_ASSAULTED);
 
    m_Nodes[node].TotalOwnerId = m_Nodes[node].OwnerId;
    m_Nodes[node].PrevOwnerId  = m_Nodes[node].OwnerId;
    m_Nodes[node].PrevState  = m_Nodes[node].State;
    m_Nodes[node].State      = (m_Nodes[node].Tower) ? POINT_DESTROYED : POINT_CONTROLED;
    m_Nodes[node].Timer      = 0;
}

References ASSERT, m_Nodes, BG_AV_NodeInfo::OwnerId, POINT_ASSAULTED, POINT_CONTROLED, POINT_DESTROYED, BG_AV_NodeInfo::PrevOwnerId, BG_AV_NodeInfo::PrevState, BG_AV_NodeInfo::State, BG_AV_NodeInfo::Timer, BG_AV_NodeInfo::TotalOwnerId, and BG_AV_NodeInfo::Tower.

Referenced by EventPlayerDestroyedPoint().

◆ EndBattleground()

void BattlegroundAV::EndBattleground ( TeamId winnerTeamId )

overridevirtual

Deprecated:: need delete

Reimplemented from Battleground.

{
    //calculate bonuskills for both teams:
    //first towers:
    uint8 kills[2] = {0, 0}; // 0 = Alliance 1 = Horde
    uint8 rep[2] = {0, 0};   // 0 = Alliance 1 = Horde
    for (BG_AV_Nodes i = BG_AV_NODES_DUNBALDAR_SOUTH; i <= BG_AV_NODES_FROSTWOLF_WTOWER; ++i)
    {
        if (m_Nodes[i].State == POINT_CONTROLED)
        {
            if (m_Nodes[i].OwnerId == TEAM_ALLIANCE)
            {
                rep[0]   += BG_AV_REP_SURVIVING_TOWER;
                kills[0] += BG_AV_KILL_SURVIVING_TOWER;
            }
            else
            {
                rep[0]   += BG_AV_KILL_SURVIVING_TOWER;
                kills[1] += BG_AV_KILL_SURVIVING_TOWER;
            }
        }
    }
 
    for (TeamId iTeamId = TEAM_ALLIANCE; iTeamId <= TEAM_HORDE; iTeamId = TeamId(iTeamId + 1))
    {
        if (m_CaptainAlive[iTeamId])
        {
            kills[iTeamId] += BG_AV_KILL_SURVIVING_CAPTAIN;
            rep[iTeamId]   += BG_AV_REP_SURVIVING_CAPTAIN;
        }
        if (rep[iTeamId] != 0)
            RewardReputationToTeam(iTeamId == TEAM_ALLIANCE ? 730 : 729, rep[iTeamId], iTeamId);
        if (kills[iTeamId] != 0)
            RewardHonorToTeam(GetBonusHonorFromKill(kills[iTeamId]), iTeamId);
    }
 
    //TODO add enterevademode for all attacking creatures
    Battleground::EndBattleground(winnerTeamId);
}

References BG_AV_KILL_SURVIVING_CAPTAIN, BG_AV_KILL_SURVIVING_TOWER, BG_AV_NODES_DUNBALDAR_SOUTH, BG_AV_NODES_FROSTWOLF_WTOWER, BG_AV_REP_SURVIVING_CAPTAIN, BG_AV_REP_SURVIVING_TOWER, Battleground::EndBattleground(), Battleground::GetBonusHonorFromKill(), m_CaptainAlive, m_Nodes, POINT_CONTROLED, Battleground::RewardHonorToTeam(), Battleground::RewardReputationToTeam(), TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by HandleKillUnit(), and UpdateScore().

◆ EventPlayerAssaultsPoint()

void BattlegroundAV::EventPlayerAssaultsPoint	(	Player *	player,
		uint32	object
	)

private

{
    ASSERT(GetStatus() == STATUS_IN_PROGRESS);
 
    BG_AV_Nodes node = GetNodeThroughObject(object);
    TeamId prevOwnerId = m_Nodes[node].OwnerId;
    TeamId teamId  = player->GetTeamId();
    LOG_DEBUG("bg.battleground", "bg_av: player assaults point object {} node {}", object, node);
    if (prevOwnerId == teamId || teamId == m_Nodes[node].TotalOwnerId)
        return; //surely a gm used this object
 
    if (node == BG_AV_NODES_SNOWFALL_GRAVE) //snowfall is a bit special in capping + it gets eyecandy stuff
    {
        if (object == BG_AV_OBJECT_FLAG_N_SNOWFALL_GRAVE) //initial capping
        {
            if (!(prevOwnerId == TEAM_NEUTRAL && m_Nodes[node].TotalOwnerId == TEAM_NEUTRAL))
                return;
 
            if (teamId == TEAM_ALLIANCE)
                SpawnBGObject(BG_AV_OBJECT_FLAG_C_A_SNOWFALL_GRAVE, RESPAWN_IMMEDIATELY);
            else
                SpawnBGObject(BG_AV_OBJECT_FLAG_C_H_SNOWFALL_GRAVE, RESPAWN_IMMEDIATELY);
            SpawnBGObject(BG_AV_OBJECT_AURA_N_FIRSTAID_STATION + 3 * node, RESPAWN_IMMEDIATELY); //neutral aura spawn
        }
        else if (m_Nodes[node].TotalOwnerId == TEAM_NEUTRAL) //recapping, when no team owns this node realy
        {
            if (!(m_Nodes[node].State != POINT_CONTROLED))
                return;
 
            if (teamId == TEAM_ALLIANCE)
                SpawnBGObject(object - 11, RESPAWN_IMMEDIATELY);
            else
                SpawnBGObject(object + 11, RESPAWN_IMMEDIATELY);
        }
        //eyecandy
        uint32 spawn, despawn;
        if (teamId == TEAM_ALLIANCE)
        {
            despawn = (m_Nodes[node].State == POINT_ASSAULTED) ? BG_AV_OBJECT_SNOW_EYECANDY_PH : BG_AV_OBJECT_SNOW_EYECANDY_H;
            spawn = BG_AV_OBJECT_SNOW_EYECANDY_PA;
        }
        else
        {
            despawn = (m_Nodes[node].State == POINT_ASSAULTED) ? BG_AV_OBJECT_SNOW_EYECANDY_PA : BG_AV_OBJECT_SNOW_EYECANDY_A;
            spawn = BG_AV_OBJECT_SNOW_EYECANDY_PH;
        }
        for (uint8 i = 0; i < 4; i++)
        {
            SpawnBGObject(despawn + i, RESPAWN_ONE_DAY);
            SpawnBGObject(spawn + i, RESPAWN_IMMEDIATELY);
        }
    }
 
    // xinef: moved here, assure that no call to m_Nodes is used in IF statement bellow as it is modified
    AssaultNode(node, teamId);
 
    //if snowfall gots capped it can be handled like all other graveyards
    if (m_Nodes[node].TotalOwnerId != TEAM_NEUTRAL)
    {
        ASSERT(prevOwnerId != TEAM_NEUTRAL);
        if (teamId == TEAM_ALLIANCE)
            SpawnBGObject(object - 22, RESPAWN_IMMEDIATELY);
        else
            SpawnBGObject(object + 22, RESPAWN_IMMEDIATELY);
 
        bool ignoreSpiritGuide = false;
        if (IsTower(node))
        {
            //spawning/despawning of bigflag+aura
            SpawnBGObject(BG_AV_OBJECT_TAURA_A_DUNBALDAR_SOUTH + (2 * (node - BG_AV_NODES_DUNBALDAR_SOUTH)), (teamId == TEAM_ALLIANCE) ? RESPAWN_IMMEDIATELY : RESPAWN_ONE_DAY);
            SpawnBGObject(BG_AV_OBJECT_TAURA_H_DUNBALDAR_SOUTH + (2 * (node - BG_AV_NODES_DUNBALDAR_SOUTH)), (teamId == TEAM_HORDE) ? RESPAWN_IMMEDIATELY : RESPAWN_ONE_DAY);
            SpawnBGObject(BG_AV_OBJECT_TFLAG_A_DUNBALDAR_SOUTH + (2 * (node - BG_AV_NODES_DUNBALDAR_SOUTH)), (teamId == TEAM_ALLIANCE) ? RESPAWN_IMMEDIATELY : RESPAWN_ONE_DAY);
            SpawnBGObject(BG_AV_OBJECT_TFLAG_H_DUNBALDAR_SOUTH + (2 * (node - BG_AV_NODES_DUNBALDAR_SOUTH)), (teamId == TEAM_HORDE) ? RESPAWN_IMMEDIATELY : RESPAWN_ONE_DAY);
        }
        else
        {
            //spawning/despawning of aura
            SpawnBGObject(BG_AV_OBJECT_AURA_N_FIRSTAID_STATION + 3 * node, RESPAWN_IMMEDIATELY); //neutral aura spawn
            SpawnBGObject(static_cast<uint8>(BG_AV_OBJECT_AURA_A_FIRSTAID_STATION) + prevOwnerId + 3 * node, RESPAWN_ONE_DAY); //teeamaura despawn
 
            ignoreSpiritGuide = true;
 
            _reviveEvents.AddEventAtOffset([this, node]()
            {
                RelocateDeadPlayers(BgCreatures[node]);
 
                if (!IsTower(node))
                    DelCreature(node); // Delete spirit healer
            }, 500ms);
        }
 
        DePopulateNode(node, ignoreSpiritGuide);
    }
 
    SpawnBGObject(object, RESPAWN_ONE_DAY); //delete old banner
    // xinef: change here is too late, AssaultNode(node, team);
    UpdateNodeWorldState(node);
 
    if (Creature* creature = GetBGCreature(AV_CPLACE_HERALD))
        creature->AI()->Talk(GetAttackString(node, teamId));
 
    //update the statistic for the assaulting player
    UpdatePlayerScore(player, (IsTower(node)) ? SCORE_TOWERS_ASSAULTED : SCORE_GRAVEYARDS_ASSAULTED, 1);
 
    player->KilledMonsterCredit((IsTower(node)) ? BG_AV_QUEST_CREDIT_TOWER : BG_AV_QUEST_CREDIT_GRAVEYARD);
}

References Battleground::_reviveEvents, EventProcessor::AddEventAtOffset(), AssaultNode(), ASSERT, AV_CPLACE_HERALD, BG_AV_NODES_DUNBALDAR_SOUTH, BG_AV_NODES_SNOWFALL_GRAVE, BG_AV_OBJECT_AURA_A_FIRSTAID_STATION, BG_AV_OBJECT_AURA_N_FIRSTAID_STATION, BG_AV_OBJECT_FLAG_C_A_SNOWFALL_GRAVE, BG_AV_OBJECT_FLAG_C_H_SNOWFALL_GRAVE, BG_AV_OBJECT_FLAG_N_SNOWFALL_GRAVE, BG_AV_OBJECT_SNOW_EYECANDY_A, BG_AV_OBJECT_SNOW_EYECANDY_H, BG_AV_OBJECT_SNOW_EYECANDY_PA, BG_AV_OBJECT_SNOW_EYECANDY_PH, BG_AV_OBJECT_TAURA_A_DUNBALDAR_SOUTH, BG_AV_OBJECT_TAURA_H_DUNBALDAR_SOUTH, BG_AV_OBJECT_TFLAG_A_DUNBALDAR_SOUTH, BG_AV_OBJECT_TFLAG_H_DUNBALDAR_SOUTH, BG_AV_QUEST_CREDIT_GRAVEYARD, BG_AV_QUEST_CREDIT_TOWER, Battleground::BgCreatures, Battleground::DelCreature(), DePopulateNode(), GetAttackString(), Battleground::GetBGCreature(), GetNodeThroughObject(), Battleground::GetStatus(), Player::GetTeamId(), IsTower(), Player::KilledMonsterCredit(), LOG_DEBUG, m_Nodes, BG_AV_NodeInfo::OwnerId, POINT_ASSAULTED, POINT_CONTROLED, Battleground::RelocateDeadPlayers(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, SCORE_GRAVEYARDS_ASSAULTED, SCORE_TOWERS_ASSAULTED, Battleground::SpawnBGObject(), BG_AV_NodeInfo::State, STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, UpdateNodeWorldState(), and UpdatePlayerScore().

Referenced by EventPlayerClickedOnFlag(), and EventPlayerDefendsPoint().

◆ EventPlayerClickedOnFlag()

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

overridevirtual

Reimplemented from Battleground.

{
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
    int32 object = GetObjectType(gameObject->GetGUID());
    if (object < 0)
        return;
    switch (gameObject->GetEntry())
    {
        case BG_AV_OBJECTID_BANNER_A:
        case BG_AV_OBJECTID_BANNER_A_B:
        case BG_AV_OBJECTID_BANNER_H:
        case BG_AV_OBJECTID_BANNER_H_B:
        case BG_AV_OBJECTID_BANNER_SNOWFALL_N:
            EventPlayerAssaultsPoint(source, object);
            break;
        case BG_AV_OBJECTID_BANNER_CONT_A:
        case BG_AV_OBJECTID_BANNER_CONT_A_B:
        case BG_AV_OBJECTID_BANNER_CONT_H:
        case BG_AV_OBJECTID_BANNER_CONT_H_B:
            EventPlayerDefendsPoint(source, object);
            break;
        default:
            break;
    }
}

References BG_AV_OBJECTID_BANNER_A, BG_AV_OBJECTID_BANNER_A_B, BG_AV_OBJECTID_BANNER_CONT_A, BG_AV_OBJECTID_BANNER_CONT_A_B, BG_AV_OBJECTID_BANNER_CONT_H, BG_AV_OBJECTID_BANNER_CONT_H_B, BG_AV_OBJECTID_BANNER_H, BG_AV_OBJECTID_BANNER_H_B, BG_AV_OBJECTID_BANNER_SNOWFALL_N, EventPlayerAssaultsPoint(), EventPlayerDefendsPoint(), Object::GetEntry(), Object::GetGUID(), Battleground::GetObjectType(), Battleground::GetStatus(), and STATUS_IN_PROGRESS.

◆ EventPlayerDefendsPoint()

void BattlegroundAV::EventPlayerDefendsPoint	(	Player *	player,
		uint32	object
	)

private

{
    ASSERT(GetStatus() == STATUS_IN_PROGRESS);
    BG_AV_Nodes node = GetNodeThroughObject(object);
 
    TeamId ownerId = m_Nodes[node].OwnerId; //maybe should name it prevowner
    TeamId teamId = player->GetTeamId();
 
    if (ownerId == player->GetTeamId() || m_Nodes[node].State != POINT_ASSAULTED)
        return;
    if (m_Nodes[node].TotalOwnerId == TEAM_NEUTRAL)
    {
        //until snowfall doesn't belong to anyone it is better handled in assault-code
        ASSERT(node == BG_AV_NODES_SNOWFALL_GRAVE); //currently the only neutral grave
        EventPlayerAssaultsPoint(player, object);
        return;
    }
    LOG_DEBUG("bg.battleground", "player defends point object: {} node: {}", object, node);
    if (m_Nodes[node].PrevOwnerId != teamId)
    {
        LOG_ERROR("bg.battleground", "BG_AV: player defends point which doesn't belong to his team {}", node);
        return;
    }
 
    //spawn new go :)
    if (m_Nodes[node].OwnerId == TEAM_ALLIANCE)
        SpawnBGObject(object + 22, RESPAWN_IMMEDIATELY); //spawn horde banner
    else
        SpawnBGObject(object - 22, RESPAWN_IMMEDIATELY); //spawn alliance banner
 
    if (!IsTower(node))
    {
        SpawnBGObject(BG_AV_OBJECT_AURA_N_FIRSTAID_STATION + 3 * node, RESPAWN_ONE_DAY);
        SpawnBGObject(static_cast<uint8>(BG_AV_OBJECT_AURA_A_FIRSTAID_STATION) + teamId + 3 * node, RESPAWN_IMMEDIATELY);
    }
    // despawn old go
    SpawnBGObject(object, RESPAWN_ONE_DAY);
 
    DefendNode(node, teamId);
    PopulateNode(node);
    UpdateNodeWorldState(node);
 
    if (IsTower(node))
    {
        //spawn big flag+aura on top of tower
        SpawnBGObject(BG_AV_OBJECT_TAURA_A_DUNBALDAR_SOUTH + (2 * (node - BG_AV_NODES_DUNBALDAR_SOUTH)), (teamId == TEAM_ALLIANCE) ? RESPAWN_IMMEDIATELY : RESPAWN_ONE_DAY);
        SpawnBGObject(BG_AV_OBJECT_TAURA_H_DUNBALDAR_SOUTH + (2 * (node - BG_AV_NODES_DUNBALDAR_SOUTH)), (teamId == TEAM_HORDE) ? RESPAWN_IMMEDIATELY : RESPAWN_ONE_DAY);
        SpawnBGObject(BG_AV_OBJECT_TFLAG_A_DUNBALDAR_SOUTH + (2 * (node - BG_AV_NODES_DUNBALDAR_SOUTH)), (teamId == TEAM_ALLIANCE) ? RESPAWN_IMMEDIATELY : RESPAWN_ONE_DAY);
        SpawnBGObject(BG_AV_OBJECT_TFLAG_H_DUNBALDAR_SOUTH + (2 * (node - BG_AV_NODES_DUNBALDAR_SOUTH)), (teamId == TEAM_HORDE) ? RESPAWN_IMMEDIATELY : RESPAWN_ONE_DAY);
    }
    else if (node == BG_AV_NODES_SNOWFALL_GRAVE) //snowfall eyecandy
    {
        for (uint8 i = 0; i < 4; i++)
        {
            SpawnBGObject(((ownerId == TEAM_ALLIANCE) ? BG_AV_OBJECT_SNOW_EYECANDY_PA : BG_AV_OBJECT_SNOW_EYECANDY_PH) + i, RESPAWN_ONE_DAY);
            SpawnBGObject(((teamId == TEAM_ALLIANCE) ? BG_AV_OBJECT_SNOW_EYECANDY_A : BG_AV_OBJECT_SNOW_EYECANDY_H) + i, RESPAWN_IMMEDIATELY);
        }
    }
 
    if (Creature* creature = GetBGCreature(AV_CPLACE_HERALD))
        creature->AI()->Talk(GetDefendString(node, teamId));
 
    //update the statistic for the defending player
    UpdatePlayerScore(player, (IsTower(node)) ? SCORE_TOWERS_DEFENDED : SCORE_GRAVEYARDS_DEFENDED, 1);
}

References ASSERT, AV_CPLACE_HERALD, BG_AV_NODES_DUNBALDAR_SOUTH, BG_AV_NODES_SNOWFALL_GRAVE, BG_AV_OBJECT_AURA_A_FIRSTAID_STATION, BG_AV_OBJECT_AURA_N_FIRSTAID_STATION, BG_AV_OBJECT_SNOW_EYECANDY_A, BG_AV_OBJECT_SNOW_EYECANDY_H, BG_AV_OBJECT_SNOW_EYECANDY_PA, BG_AV_OBJECT_SNOW_EYECANDY_PH, BG_AV_OBJECT_TAURA_A_DUNBALDAR_SOUTH, BG_AV_OBJECT_TAURA_H_DUNBALDAR_SOUTH, BG_AV_OBJECT_TFLAG_A_DUNBALDAR_SOUTH, BG_AV_OBJECT_TFLAG_H_DUNBALDAR_SOUTH, DefendNode(), EventPlayerAssaultsPoint(), Battleground::GetBGCreature(), GetDefendString(), GetNodeThroughObject(), Battleground::GetStatus(), Player::GetTeamId(), IsTower(), LOG_DEBUG, LOG_ERROR, m_Nodes, BG_AV_NodeInfo::OwnerId, POINT_ASSAULTED, PopulateNode(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, SCORE_GRAVEYARDS_DEFENDED, SCORE_TOWERS_DEFENDED, Battleground::SpawnBGObject(), BG_AV_NodeInfo::State, STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, UpdateNodeWorldState(), and UpdatePlayerScore().

Referenced by EventPlayerClickedOnFlag().

◆ EventPlayerDestroyedPoint()

void BattlegroundAV::EventPlayerDestroyedPoint ( BG_AV_Nodes node )

private

{
    uint32 object = GetObjectThroughNode(node);
    LOG_DEBUG("bg.battleground", "bg_av: player destroyed point node {} object {}", node, object);
 
    //despawn banner
    SpawnBGObject(object, RESPAWN_ONE_DAY);
    DestroyNode(node);
    UpdateNodeWorldState(node);
 
    TeamId ownerId = m_Nodes[node].OwnerId;
    if (IsTower(node))
    {
        uint8 tmp = node - BG_AV_NODES_DUNBALDAR_SOUTH;
        //despawn marshal
        if (BgCreatures[AV_CPLACE_A_MARSHAL_SOUTH + tmp])
            DelCreature(AV_CPLACE_A_MARSHAL_SOUTH + tmp);
        else
            LOG_ERROR("bg.battleground", "BG_AV: playerdestroyedpoint: marshal {} doesn't exist", AV_CPLACE_A_MARSHAL_SOUTH + tmp);
        //spawn destroyed aura
        for (uint8 i = 0; i <= 9; i++)
            SpawnBGObject(BG_AV_OBJECT_BURN_DUNBALDAR_SOUTH + i + (tmp * 10), RESPAWN_IMMEDIATELY);
 
        UpdateScore((ownerId == TEAM_ALLIANCE) ? TEAM_HORDE : TEAM_ALLIANCE, -1 * BG_AV_RES_TOWER);
        RewardReputationToTeam(ownerId == TEAM_ALLIANCE ? 730 : 729, BG_AV_REP_TOWER, ownerId);
        RewardHonorToTeam(GetBonusHonorFromKill(BG_AV_KILL_TOWER), ownerId);
 
        SpawnBGObject(static_cast<uint8>(BG_AV_OBJECT_TAURA_A_DUNBALDAR_SOUTH) + ownerId + (2 * tmp), RESPAWN_ONE_DAY);
        SpawnBGObject(static_cast<uint8>(BG_AV_OBJECT_TFLAG_A_DUNBALDAR_SOUTH) + ownerId + (2 * tmp), RESPAWN_ONE_DAY);
    }
    else
    {
        if (ownerId == TEAM_ALLIANCE)
            SpawnBGObject(object - 11, RESPAWN_IMMEDIATELY);
        else
            SpawnBGObject(object + 11, RESPAWN_IMMEDIATELY);
        SpawnBGObject(BG_AV_OBJECT_AURA_N_FIRSTAID_STATION + 3 * node, RESPAWN_ONE_DAY);
        SpawnBGObject(static_cast<uint8>(BG_AV_OBJECT_AURA_A_FIRSTAID_STATION) + ownerId + 3 * node, RESPAWN_IMMEDIATELY);
        PopulateNode(node);
        if (node == BG_AV_NODES_SNOWFALL_GRAVE) //snowfall eyecandy
        {
            for (uint8 i = 0; i < 4; i++)
            {
                SpawnBGObject(((ownerId == TEAM_ALLIANCE) ? BG_AV_OBJECT_SNOW_EYECANDY_PA : BG_AV_OBJECT_SNOW_EYECANDY_PH) + i, RESPAWN_ONE_DAY);
                SpawnBGObject(((ownerId == TEAM_ALLIANCE) ? BG_AV_OBJECT_SNOW_EYECANDY_A  : BG_AV_OBJECT_SNOW_EYECANDY_H) + i, RESPAWN_IMMEDIATELY);
            }
        }
    }
 
    if (Creature* creature = GetBGCreature(AV_CPLACE_HERALD))
        creature->AI()->Talk(GetDefendString(node, ownerId));
}

References AV_CPLACE_A_MARSHAL_SOUTH, AV_CPLACE_HERALD, BG_AV_KILL_TOWER, BG_AV_NODES_DUNBALDAR_SOUTH, BG_AV_NODES_SNOWFALL_GRAVE, BG_AV_OBJECT_AURA_A_FIRSTAID_STATION, BG_AV_OBJECT_AURA_N_FIRSTAID_STATION, BG_AV_OBJECT_BURN_DUNBALDAR_SOUTH, BG_AV_OBJECT_SNOW_EYECANDY_A, BG_AV_OBJECT_SNOW_EYECANDY_H, BG_AV_OBJECT_SNOW_EYECANDY_PA, BG_AV_OBJECT_SNOW_EYECANDY_PH, BG_AV_OBJECT_TAURA_A_DUNBALDAR_SOUTH, BG_AV_OBJECT_TFLAG_A_DUNBALDAR_SOUTH, BG_AV_REP_TOWER, BG_AV_RES_TOWER, Battleground::BgCreatures, Battleground::DelCreature(), DestroyNode(), Battleground::GetBGCreature(), Battleground::GetBonusHonorFromKill(), GetDefendString(), GetObjectThroughNode(), IsTower(), LOG_DEBUG, LOG_ERROR, m_Nodes, BG_AV_NodeInfo::OwnerId, PopulateNode(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, Battleground::RewardHonorToTeam(), Battleground::RewardReputationToTeam(), Battleground::SpawnBGObject(), TEAM_ALLIANCE, TEAM_HORDE, UpdateNodeWorldState(), and UpdateScore().

Referenced by PostUpdateImpl().

◆ FillInitialWorldStates()

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

overrideprivatevirtual

Reimplemented from Battleground.

{
    bool stateok;
    packet.Worldstates.reserve(7*2*2 + 8*2*2 + 5);
    //graveyards
    for (uint8 i = BG_AV_NODES_FIRSTAID_STATION; i <= BG_AV_NODES_FROSTWOLF_HUT; i++)
    {
        for (uint8 j = 1; j <= 3; j += 2)
        {
            //j=1=assaulted j=3=controled
            stateok = (m_Nodes[i].State == j);
            packet.Worldstates.emplace_back(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_ALLIANCE)], (m_Nodes[i].OwnerId == TEAM_ALLIANCE && stateok) ? 1 : 0);
            packet.Worldstates.emplace_back(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_HORDE)], (m_Nodes[i].OwnerId == TEAM_HORDE && stateok) ? 1 : 0);
        }
    }
 
    //towers
    for (uint8 i = BG_AV_NODES_DUNBALDAR_SOUTH; i < BG_AV_NODES_MAX; ++i)
        for (uint8 j = 1; j <= 3; j += 2)
        {
            //j=1=assaulted j=3=controled //i dont have j=2=destroyed cause destroyed is the same like enemy-team controll
            stateok = (m_Nodes[i].State == j || (m_Nodes[i].State == POINT_DESTROYED && j == 3));
            packet.Worldstates.emplace_back(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_ALLIANCE)], (m_Nodes[i].OwnerId == TEAM_ALLIANCE && stateok) ? 1 : 0);
            packet.Worldstates.emplace_back(BG_AV_NodeWorldStates[i][GetWorldStateType(j, TEAM_HORDE)], (m_Nodes[i].OwnerId == TEAM_HORDE && stateok) ? 1 : 0);
        }
    if (m_Nodes[BG_AV_NODES_SNOWFALL_GRAVE].OwnerId == TEAM_NEUTRAL) //cause neutral teams aren't handled generic
    {
        packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AV_SNOWFALL_N, 1);
    }
 
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AV_ALLIANCE_SCORE, m_Team_Scores[0]);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AV_HORDE_SCORE, m_Team_Scores[1]);
 
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AV_SHOW_ALLIANCE_SCORE, GetStatus() == STATUS_IN_PROGRESS && BG_AV_SCORE_INITIAL_POINTS > 0 ? 1 : 0);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_AV_SHOW_HORDE_SCORE, GetStatus() == STATUS_IN_PROGRESS && BG_AV_SCORE_INITIAL_POINTS > 0 ? 1 : 0);
 
    SendMineWorldStates(AV_NORTH_MINE);
    SendMineWorldStates(AV_SOUTH_MINE);
}

References AV_NORTH_MINE, AV_SOUTH_MINE, BG_AV_NODES_DUNBALDAR_SOUTH, BG_AV_NODES_FIRSTAID_STATION, BG_AV_NODES_FROSTWOLF_HUT, BG_AV_NODES_MAX, BG_AV_NODES_SNOWFALL_GRAVE, BG_AV_NodeWorldStates, BG_AV_SCORE_INITIAL_POINTS, Battleground::GetStatus(), GetWorldStateType(), m_Nodes, m_Team_Scores, BG_AV_NodeInfo::OwnerId, POINT_DESTROYED, SendMineWorldStates(), BG_AV_NodeInfo::State, STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, WORLD_STATE_BATTLEGROUND_AV_ALLIANCE_SCORE, WORLD_STATE_BATTLEGROUND_AV_HORDE_SCORE, WORLD_STATE_BATTLEGROUND_AV_SHOW_ALLIANCE_SCORE, WORLD_STATE_BATTLEGROUND_AV_SHOW_HORDE_SCORE, WORLD_STATE_BATTLEGROUND_AV_SNOWFALL_N, and WorldPackets::WorldState::InitWorldStates::Worldstates.

◆ GetAttackString()

uint8 BattlegroundAV::GetAttackString	(	BG_AV_Nodes	node,
		TeamId	teamId
	)

private

{
    uint8 strId = 0;
    switch (node)
    {
    case BG_AV_NODES_FIRSTAID_STATION:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_STORMPIKE_AID_STATION_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_STORMPIKE_AID_STATION_ATTACK;
        break;
    case BG_AV_NODES_DUNBALDAR_SOUTH:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_DUN_BALDAR_SOUTH_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_DUN_BALDAR_SOUTH_ATTACK;
        break;
    case BG_AV_NODES_DUNBALDAR_NORTH:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_DUN_BALDAR_NORTH_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_DUN_BALDAR_NORTH_ATTACK;
        break;
    case BG_AV_NODES_STORMPIKE_GRAVE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_STORMPIKE_GRAVEYARD_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_STORMPIKE_GRAVEYARD_ATTACK;
        break;
    case BG_AV_NODES_ICEWING_BUNKER:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_ICEWING_BUNKER_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_ICEWING_BUNKER_ATTACK;
        break;
    case BG_AV_NODES_STONEHEART_GRAVE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_STONEHEARTH_GRAVEYARD_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_STONEHEARTH_GRAVEYARD_ATTACK;
        break;
    case BG_AV_NODES_STONEHEART_BUNKER:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_STONEHEARTH_BUNKER_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_STONEHEARTH_BUNKER_ATTACK;
        break;
    case BG_AV_NODES_SNOWFALL_GRAVE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_SNOWFALL_GRAVEYARD_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_SNOWFALL_GRAVEYARD_ATTACK;
        break;
    case BG_AV_NODES_ICEBLOOD_TOWER:
        strId = AV_TEXT_A_HERALD_ICEBLOOD_TOWER_ATTACK;
        break;
    case BG_AV_NODES_ICEBLOOD_GRAVE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_ICEBLOOD_GRAVEYARD_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_ICEBLOOD_GRAVEYARD_ATTACK;
        break;
    case BG_AV_NODES_TOWER_POINT:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_TOWER_POINT_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_TOWER_POINT_ATTACK;
        break;
    case BG_AV_NODES_FROSTWOLF_GRAVE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_FROSTWOLF_GRAVEYARD_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_FROSTWOLF_GRAVEYARD_ATTACK;
        break;
    case BG_AV_NODES_FROSTWOLF_ETOWER:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_EAST_FROSTWOLF_TOWER_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_EAST_FROSTWOLF_TOWER_ATTACK;
        break;
    case BG_AV_NODES_FROSTWOLF_WTOWER:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_WEST_FROSTWOLF_TOWER_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_WEST_FROSTWOLF_TOWER_ATTACK;
        break;
    case BG_AV_NODES_FROSTWOLF_HUT:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_FROSTWOLF_RELIEF_HUT_ATTACK;
        else
            strId = AV_TEXT_H_HERALD_FROSTWOLF_RELIEF_HUT_ATTACK;
        break;
    default:
        break;
    }
 
    return strId;
}

Referenced by EventPlayerAssaultsPoint().

◆ GetClosestGraveyard()

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

overridevirtual

Reimplemented from Battleground.

{
    GraveyardStruct const* entry = nullptr;
    float dist = 0;
    float minDist = 0;
    float x, y;
 
    player->GetPosition(x, y);
 
    GraveyardStruct const* pGraveyard = sGraveyard->GetGraveyard(BG_AV_GraveyardIds[player->GetTeamId() + 7]);
    minDist = (pGraveyard->x - x) * (pGraveyard->x - x) + (pGraveyard->y - y) * (pGraveyard->y - y);
 
    for (uint8 i = BG_AV_NODES_FIRSTAID_STATION; i <= BG_AV_NODES_FROSTWOLF_HUT; ++i)
        if (m_Nodes[i].OwnerId == player->GetTeamId() && m_Nodes[i].State == POINT_CONTROLED)
        {
            entry = sGraveyard->GetGraveyard(BG_AV_GraveyardIds[i]);
            if (entry)
            {
                dist = (entry->x - x) * (entry->x - x) + (entry->y - y) * (entry->y - y);
                if (dist < minDist)
                {
                    minDist = dist;
                    pGraveyard = entry;
                }
            }
        }
    return pGraveyard;
}

References BG_AV_GraveyardIds, BG_AV_NODES_FIRSTAID_STATION, BG_AV_NODES_FROSTWOLF_HUT, Position::GetPosition(), Player::GetTeamId(), m_Nodes, POINT_CONTROLED, sGraveyard, BG_AV_NodeInfo::State, GraveyardStruct::x, and GraveyardStruct::y.

◆ GetDefendString()

uint8 BattlegroundAV::GetDefendString	(	BG_AV_Nodes	node,
		TeamId	teamId
	)

private

{
    uint8 strId = 0;
    switch (node)
    {
    case BG_AV_NODES_FIRSTAID_STATION:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_STORMPIKE_AID_STATION_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_STORMPIKE_AID_STATION_TAKEN;
        break;
    case BG_AV_NODES_DUNBALDAR_SOUTH:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_DUN_BALDAR_SOUTH_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_DUN_BALDAR_SOUTH_TAKEN;
        break;
    case BG_AV_NODES_DUNBALDAR_NORTH:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_DUN_BALDAR_NORTH_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_DUN_BALDAR_NORTH_TAKEN;
        break;
    case BG_AV_NODES_STORMPIKE_GRAVE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_STORMPIKE_GRAVEYARD_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_STORMPIKE_GRAVEYARD_TAKEN;
        break;
    case BG_AV_NODES_ICEWING_BUNKER:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_ICEWING_BUNKER_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_ICEWING_BUNKER_TAKEN;
        break;
    case BG_AV_NODES_STONEHEART_GRAVE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_STONEHEARTH_GRAVEYARD_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_STONEHEARTH_GRAVEYARD_TAKEN;
        break;
    case BG_AV_NODES_STONEHEART_BUNKER:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_STONEHEARTH_BUNKER_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_STONEHEARTH_BUNKER_TAKEN;
        break;
    case BG_AV_NODES_SNOWFALL_GRAVE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_SNOWFALL_GRAVEYARD_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_SNOWFALL_GRAVEYARD_TAKEN;
        break;
    case BG_AV_NODES_ICEBLOOD_TOWER:
        strId = AV_TEXT_A_HERALD_ICEBLOOD_TOWER_TAKEN;
        break;
    case BG_AV_NODES_ICEBLOOD_GRAVE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_ICEBLOOD_GRAVEYARD_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_ICEBLOOD_GRAVEYARD_TAKEN;
        break;
    case BG_AV_NODES_TOWER_POINT:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_TOWER_POINT_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_TOWER_POINT_TAKEN;
        break;
    case BG_AV_NODES_FROSTWOLF_GRAVE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_FROSTWOLF_GRAVEYARD_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_FROSTWOLF_GRAVEYARD_TAKEN;
        break;
    case BG_AV_NODES_FROSTWOLF_ETOWER:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_EAST_FROSTWOLF_TOWER_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_EAST_FROSTWOLF_TOWER_TAKEN;
        break;
    case BG_AV_NODES_FROSTWOLF_WTOWER:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_WEST_FROSTWOLF_TOWER_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_WEST_FROSTWOLF_TOWER_TAKEN;
        break;
    case BG_AV_NODES_FROSTWOLF_HUT:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_FROSTWOLF_RELIEF_HUT_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_FROSTWOLF_RELIEF_HUT_TAKEN;
        break;
    default:
        break;
    }
 
    return strId;
}

Referenced by EventPlayerDefendsPoint(), and EventPlayerDestroyedPoint().

◆ GetMineString()

uint8 BattlegroundAV::GetMineString	(	uint8	mine,
		TeamId	teamId
	)

private

{
    uint8 strId = 0;
    switch (mineId)
    {
    case AV_NORTH_MINE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_IRONDEEP_MINE_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_IRONDEEP_MINE_TAKEN;
        break;
    case AV_SOUTH_MINE:
        if (teamId == TEAM_ALLIANCE)
            strId = AV_TEXT_A_HERALD_COLDTOOTH_MINE_TAKEN;
        else
            strId = AV_TEXT_H_HERALD_COLDTOOTH_MINE_TAKEN;
        break;
    default:
        break;
    }
 
    return strId;
}

References AV_NORTH_MINE, AV_SOUTH_MINE, AV_TEXT_A_HERALD_COLDTOOTH_MINE_TAKEN, AV_TEXT_A_HERALD_IRONDEEP_MINE_TAKEN, AV_TEXT_H_HERALD_COLDTOOTH_MINE_TAKEN, AV_TEXT_H_HERALD_IRONDEEP_MINE_TAKEN, and TEAM_ALLIANCE.

Referenced by ChangeMineOwner().

◆ GetNodeThroughObject()

BG_AV_Nodes BattlegroundAV::GetNodeThroughObject ( uint32 object )

private

{
    LOG_DEBUG("bg.battleground", "bg_AV getnodethroughobject {}", object);
    if (object <= BG_AV_OBJECT_FLAG_A_STONEHEART_BUNKER)
        return BG_AV_Nodes(object);
    if (object <= BG_AV_OBJECT_FLAG_C_A_FROSTWOLF_HUT)
        return BG_AV_Nodes(object - 11);
    if (object <= BG_AV_OBJECT_FLAG_C_A_FROSTWOLF_WTOWER)
        return BG_AV_Nodes(object - 7);
    if (object <= BG_AV_OBJECT_FLAG_C_H_STONEHEART_BUNKER)
        return BG_AV_Nodes(object - 22);
    if (object <= BG_AV_OBJECT_FLAG_H_FROSTWOLF_HUT)
        return BG_AV_Nodes(object - 33);
    if (object <= BG_AV_OBJECT_FLAG_H_FROSTWOLF_WTOWER)
        return BG_AV_Nodes(object - 29);
    if (object == BG_AV_OBJECT_FLAG_N_SNOWFALL_GRAVE)
        return BG_AV_NODES_SNOWFALL_GRAVE;
    LOG_ERROR("bg.battleground", "BattlegroundAV: ERROR! GetPlace got a wrong object :(");
    ABORT();
    return BG_AV_Nodes(0);
}

References ABORT, BG_AV_NODES_SNOWFALL_GRAVE, BG_AV_OBJECT_FLAG_A_STONEHEART_BUNKER, BG_AV_OBJECT_FLAG_C_A_FROSTWOLF_HUT, BG_AV_OBJECT_FLAG_C_A_FROSTWOLF_WTOWER, BG_AV_OBJECT_FLAG_C_H_STONEHEART_BUNKER, BG_AV_OBJECT_FLAG_H_FROSTWOLF_HUT, BG_AV_OBJECT_FLAG_H_FROSTWOLF_WTOWER, BG_AV_OBJECT_FLAG_N_SNOWFALL_GRAVE, LOG_DEBUG, and LOG_ERROR.

Referenced by EventPlayerAssaultsPoint(), EventPlayerDefendsPoint(), and SetupBattleground().

◆ GetObjectThroughNode()

uint32 BattlegroundAV::GetObjectThroughNode ( BG_AV_Nodes node )

private

{
    //this function is the counterpart to GetNodeThroughObject()
    LOG_DEBUG("bg.battleground", "bg_AV GetObjectThroughNode {}", node);
    if (m_Nodes[node].OwnerId == TEAM_ALLIANCE)
    {
        if (m_Nodes[node].State == POINT_ASSAULTED)
        {
            if (node <= BG_AV_NODES_FROSTWOLF_HUT)
                return node + 11;
            if (node >= BG_AV_NODES_ICEBLOOD_TOWER && node <= BG_AV_NODES_FROSTWOLF_WTOWER)
                return node + 7;
        }
        else if (m_Nodes[node].State == POINT_CONTROLED)
            if (node <= BG_AV_NODES_STONEHEART_BUNKER)
                return node;
    }
    else if (m_Nodes[node].OwnerId == TEAM_HORDE)
    {
        if (m_Nodes[node].State == POINT_ASSAULTED)
        {
            if (node <= BG_AV_NODES_STONEHEART_BUNKER)
                return node + 22;
        }
        else if (m_Nodes[node].State == POINT_CONTROLED)
        {
            if (node <= BG_AV_NODES_FROSTWOLF_HUT)
                return node + 33;
            if (node >= BG_AV_NODES_ICEBLOOD_TOWER && node <= BG_AV_NODES_FROSTWOLF_WTOWER)
                return node + 29;
        }
    }
    else if (m_Nodes[node].OwnerId == TEAM_NEUTRAL)
        return BG_AV_OBJECT_FLAG_N_SNOWFALL_GRAVE;
    LOG_ERROR("bg.battleground", "BattlegroundAV: Error! GetPlaceNode couldn't resolve node {}", node);
    ABORT();
    return 0;
}

References ABORT, BG_AV_NODES_FROSTWOLF_HUT, BG_AV_NODES_FROSTWOLF_WTOWER, BG_AV_NODES_ICEBLOOD_TOWER, BG_AV_NODES_STONEHEART_BUNKER, BG_AV_OBJECT_FLAG_N_SNOWFALL_GRAVE, LOG_DEBUG, LOG_ERROR, m_Nodes, POINT_ASSAULTED, POINT_CONTROLED, TEAM_ALLIANCE, TEAM_HORDE, and TEAM_NEUTRAL.

Referenced by EventPlayerDestroyedPoint().

◆ GetPrematureWinner()

TeamId BattlegroundAV::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.

◆ GetWorldStateType()

uint8 BattlegroundAV::GetWorldStateType	(	uint8	state,
		TeamId	teamId
	)

private

{
    //neutral stuff cant get handled (currently its only snowfall)
    ASSERT(teamId != TEAM_NEUTRAL);
    //a_c a_a h_c h_a the positions in worldstate-array
    if (teamId == TEAM_ALLIANCE)
    {
        if (state == POINT_CONTROLED || state == POINT_DESTROYED)
            return 0;
        if (state == POINT_ASSAULTED)
            return 1;
    }
    if (teamId == TEAM_HORDE)
    {
        if (state == POINT_DESTROYED || state == POINT_CONTROLED)
            return 2;
        if (state == POINT_ASSAULTED)
            return 3;
    }
    LOG_ERROR("bg.battleground", "BG_AV: should update a strange worldstate state:{} team:{}", state, teamId);
    return 5; //this will crash the game, but i want to know if something is wrong here
}

References ASSERT, LOG_ERROR, POINT_ASSAULTED, POINT_CONTROLED, POINT_DESTROYED, TEAM_ALLIANCE, TEAM_HORDE, and TEAM_NEUTRAL.

Referenced by FillInitialWorldStates(), and UpdateNodeWorldState().

◆ HandleAreaTrigger()

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

overridevirtual

Reimplemented from Battleground.

{
    // this is wrong way to implement these things. On official it done by gameobject spell cast.
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
    switch (trigger)
    {
        case 95:
        case 2608:
            if (player->GetTeamId() != TEAM_ALLIANCE)
                player->GetSession()->SendAreaTriggerMessage("Only The Alliance can use that portal");
            else
                player->LeaveBattleground();
            break;
        case 2606:
            if (player->GetTeamId() != TEAM_HORDE)
                player->GetSession()->SendAreaTriggerMessage("Only The Horde can use that portal");
            else
                player->LeaveBattleground();
            break;
        case 3326:
        case 3327:
        case 3328:
        case 3329:
        case 3330:
        case 3331:
            //player->Unmount();
            break;
        default:
            break;
    }
}

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

◆ HandleKillPlayer()

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

overridevirtual

Reimplemented from Battleground.

{
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
    Battleground::HandleKillPlayer(player, killer);
    UpdateScore(player->GetTeamId(), -1);
}

References Battleground::GetStatus(), Player::GetTeamId(), Battleground::HandleKillPlayer(), STATUS_IN_PROGRESS, and UpdateScore().

◆ HandleKillUnit()

void BattlegroundAV::HandleKillUnit	(	Creature *	unit,
		Player *	killer
	)

overridevirtual

Reimplemented from Battleground.

{
    LOG_DEBUG("bg.battleground", "bg_av HandleKillUnit {}", unit->GetEntry());
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
    uint32 entry = unit->GetEntry();
    /*
    uint32 triggerSpawnID = 0;
    if (creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_A_CAPTAIN])
        triggerSpawnID = AV_CPLACE_TRIGGER16;
    else if (creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_A_BOSS])
        triggerSpawnID = AV_CPLACE_TRIGGER17;
    else if (creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_H_CAPTAIN])
        triggerSpawnID = AV_CPLACE_TRIGGER18;
    else if (creature->GetEntry() == BG_AV_CreatureInfo[AV_NPC_H_BOSS])
        triggerSpawnID = AV_CPLACE_TRIGGER19;
    */
    if (entry == BG_AV_CreatureInfo[AV_NPC_A_BOSS])
    {
        CastSpellOnTeam(23658, TEAM_HORDE); //this is a spell which finishes a quest where a player has to kill the boss
        RewardReputationToTeam(729, BG_AV_REP_BOSS, TEAM_HORDE);
        RewardHonorToTeam(GetBonusHonorFromKill(BG_AV_KILL_BOSS), TEAM_HORDE);
        EndBattleground(TEAM_HORDE);
        DelCreature(AV_CPLACE_TRIGGER17);
    }
    else if (entry == BG_AV_CreatureInfo[AV_NPC_H_BOSS])
    {
        CastSpellOnTeam(23658, TEAM_ALLIANCE); //this is a spell which finishes a quest where a player has to kill the boss
        RewardReputationToTeam(730, BG_AV_REP_BOSS, TEAM_ALLIANCE);
        RewardHonorToTeam(GetBonusHonorFromKill(BG_AV_KILL_BOSS), TEAM_ALLIANCE);
        EndBattleground(TEAM_ALLIANCE);
        DelCreature(AV_CPLACE_TRIGGER19);
    }
    else if (entry == BG_AV_CreatureInfo[AV_NPC_A_CAPTAIN])
    {
        if (!m_CaptainAlive[0])
        {
            LOG_ERROR("bg.battleground", "Killed a Captain twice, please report this bug, if you haven't done \".respawn\"");
            return;
        }
        m_CaptainAlive[0] = false;
        RewardReputationToTeam(729, BG_AV_REP_CAPTAIN, TEAM_HORDE);
        RewardHonorToTeam(GetBonusHonorFromKill(BG_AV_KILL_CAPTAIN), TEAM_HORDE);
        UpdateScore(TEAM_ALLIANCE, (-1)*BG_AV_RES_CAPTAIN);
        //spawn destroyed aura
        for (uint8 i = 0; i <= 9; i++)
            SpawnBGObject(BG_AV_OBJECT_BURN_BUILDING_ALLIANCE + i, RESPAWN_IMMEDIATELY);
        if (Creature* creature = GetBGCreature(AV_CPLACE_HERALD))
            creature->AI()->Talk(AV_TEXT_HERALD_STORMPIKE_GENERAL_DEAD);
        DelCreature(AV_CPLACE_TRIGGER16);
    }
    else if (entry == BG_AV_CreatureInfo[AV_NPC_H_CAPTAIN])
    {
        if (!m_CaptainAlive[1])
        {
            LOG_ERROR("bg.battleground", "Killed a Captain twice, please report this bug, if you haven't done \".respawn\"");
            return;
        }
        m_CaptainAlive[1] = false;
        RewardReputationToTeam(730, BG_AV_REP_CAPTAIN, TEAM_ALLIANCE);
        RewardHonorToTeam(GetBonusHonorFromKill(BG_AV_KILL_CAPTAIN), TEAM_ALLIANCE);
        UpdateScore(TEAM_HORDE, (-1)*BG_AV_RES_CAPTAIN);
        //spawn destroyed aura
        for (uint8 i = 0; i <= 9; i++)
            SpawnBGObject(BG_AV_OBJECT_BURN_BUILDING_HORDE + i, RESPAWN_IMMEDIATELY);
        if (Creature* creature = GetBGCreature(AV_CPLACE_HERALD))
            creature->AI()->Talk(AV_TEXT_HERALD_FROSTWOLF_GENERAL_DEAD);
        DelCreature(AV_CPLACE_TRIGGER18);
    }
    else if (entry == BG_AV_CreatureInfo[AV_NPC_N_MINE_N_4] || entry == BG_AV_CreatureInfo[AV_NPC_N_MINE_A_4] || entry == BG_AV_CreatureInfo[AV_NPC_N_MINE_H_4])
    {
        ChangeMineOwner(AV_NORTH_MINE, killer->GetTeamId());
        UpdatePlayerScore(killer, SCORE_MINES_CAPTURED, 1);
        killer->KilledMonsterCredit(BG_AV_QUEST_CREDIT_MINE);
    }
    else if (entry == BG_AV_CreatureInfo[AV_NPC_S_MINE_N_4] || entry == BG_AV_CreatureInfo[AV_NPC_S_MINE_A_4] || entry == BG_AV_CreatureInfo[AV_NPC_S_MINE_H_4])
    {
        ChangeMineOwner(AV_SOUTH_MINE, killer->GetTeamId());
        UpdatePlayerScore(killer, SCORE_MINES_CAPTURED, 1);
        killer->KilledMonsterCredit(BG_AV_QUEST_CREDIT_MINE);
    }
}

References AV_CPLACE_HERALD, AV_CPLACE_TRIGGER16, AV_CPLACE_TRIGGER17, AV_CPLACE_TRIGGER18, AV_CPLACE_TRIGGER19, AV_NORTH_MINE, AV_NPC_A_BOSS, AV_NPC_A_CAPTAIN, AV_NPC_H_BOSS, AV_NPC_H_CAPTAIN, AV_NPC_N_MINE_A_4, AV_NPC_N_MINE_H_4, AV_NPC_N_MINE_N_4, AV_NPC_S_MINE_A_4, AV_NPC_S_MINE_H_4, AV_NPC_S_MINE_N_4, AV_SOUTH_MINE, AV_TEXT_HERALD_FROSTWOLF_GENERAL_DEAD, AV_TEXT_HERALD_STORMPIKE_GENERAL_DEAD, BG_AV_CreatureInfo, BG_AV_KILL_BOSS, BG_AV_KILL_CAPTAIN, BG_AV_OBJECT_BURN_BUILDING_ALLIANCE, BG_AV_OBJECT_BURN_BUILDING_HORDE, BG_AV_QUEST_CREDIT_MINE, BG_AV_REP_BOSS, BG_AV_REP_CAPTAIN, BG_AV_RES_CAPTAIN, Battleground::CastSpellOnTeam(), ChangeMineOwner(), Battleground::DelCreature(), EndBattleground(), Battleground::GetBGCreature(), Battleground::GetBonusHonorFromKill(), Object::GetEntry(), Battleground::GetStatus(), Player::GetTeamId(), Player::KilledMonsterCredit(), LOG_DEBUG, LOG_ERROR, m_CaptainAlive, RESPAWN_IMMEDIATELY, Battleground::RewardHonorToTeam(), Battleground::RewardReputationToTeam(), SCORE_MINES_CAPTURED, Battleground::SpawnBGObject(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, UpdatePlayerScore(), and UpdateScore().

◆ HandleQuestComplete()

void BattlegroundAV::HandleQuestComplete	(	uint32	questid,
		Player *	player
	)

{
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;//maybe we should log this, cause this must be a cheater or a big bug
    TeamId teamId = player->GetTeamId();
    //TODO add reputation, events (including quest not available anymore, next quest availabe, go/npc de/spawning)and maybe honor
    LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed", questid);
    switch (questid)
    {
        case AV_QUEST_A_SCRAPS1:
        case AV_QUEST_A_SCRAPS2:
        case AV_QUEST_H_SCRAPS1:
        case AV_QUEST_H_SCRAPS2:
            m_Team_QuestStatus[teamId][0] += 20;
            if (m_Team_QuestStatus[teamId][0] == 500 || m_Team_QuestStatus[teamId][0] == 1000 || m_Team_QuestStatus[teamId][0] == 1500) //25, 50, 75 turn ins
            {
                LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed starting with unit upgrading..", questid);
                for (BG_AV_Nodes i = BG_AV_NODES_FIRSTAID_STATION; i <= BG_AV_NODES_FROSTWOLF_HUT; ++i)
                    if (m_Nodes[i].OwnerId == player->GetTeamId() && m_Nodes[i].State == POINT_CONTROLED)
                    {
                        DePopulateNode(i);
                        PopulateNode(i);
                        //maybe this is bad, because it will instantly respawn all creatures on every grave..
                    }
            }
            break;
        case AV_QUEST_A_COMMANDER1:
        case AV_QUEST_H_COMMANDER1:
            m_Team_QuestStatus[teamId][1]++;
            RewardReputationToTeam(teamId, 1, teamId);
            if (m_Team_QuestStatus[teamId][1] == 30)
                LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here", questid);
            break;
        case AV_QUEST_A_COMMANDER2:
        case AV_QUEST_H_COMMANDER2:
            m_Team_QuestStatus[teamId][2]++;
            RewardReputationToTeam(teamId, 1, teamId);
            if (m_Team_QuestStatus[teamId][2] == 60)
                LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here", questid);
            break;
        case AV_QUEST_A_COMMANDER3:
        case AV_QUEST_H_COMMANDER3:
            m_Team_QuestStatus[teamId][3]++;
            RewardReputationToTeam(teamId, 1, teamId);
            if (m_Team_QuestStatus[teamId][3] == 120)
                LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here", questid);
            break;
        case AV_QUEST_A_BOSS1:
        case AV_QUEST_H_BOSS1:
            m_Team_QuestStatus[teamId][4] += 9; //you can turn in 10 or 1 item..
            [[fallthrough]];
        case AV_QUEST_A_BOSS2:
        case AV_QUEST_H_BOSS2:
            m_Team_QuestStatus[teamId][4]++;
            if (m_Team_QuestStatus[teamId][4] >= 200)
                LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here", questid);
            break;
        case AV_QUEST_A_NEAR_MINE:
        case AV_QUEST_H_NEAR_MINE:
            m_Team_QuestStatus[teamId][5]++;
            if (m_Team_QuestStatus[teamId][5] == 28)
            {
                LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here", questid);
 
                if (m_Team_QuestStatus[teamId][6] == 7)
                    LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here - ground assault ready", questid);
            }
            break;
        case AV_QUEST_A_OTHER_MINE:
        case AV_QUEST_H_OTHER_MINE:
            m_Team_QuestStatus[teamId][6]++;
            if (m_Team_QuestStatus[teamId][6] == 7)
            {
                LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here", questid);
 
                if (m_Team_QuestStatus[teamId][5] == 20)
                    LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here - ground assault ready", questid);
            }
            break;
        case AV_QUEST_A_RIDER_HIDE:
        case AV_QUEST_H_RIDER_HIDE:
            m_Team_QuestStatus[teamId][7]++;
            if (m_Team_QuestStatus[teamId][7] == 25)
            {
                LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here", questid);
 
                if (m_Team_QuestStatus[teamId][8] == 25)
                    LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here - rider assault ready", questid);
            }
            break;
        case AV_QUEST_A_RIDER_TAME:
        case AV_QUEST_H_RIDER_TAME:
            m_Team_QuestStatus[teamId][8]++;
            if (m_Team_QuestStatus[teamId][8] == 25)
            {
                LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here", questid);
 
                if (m_Team_QuestStatus[teamId][7] == 25)
                    LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed (need to implement some events here - rider assault ready", questid);
            }
            break;
        default:
            LOG_DEBUG("bg.battleground", "BG_AV Quest {} completed but is not interesting at all", questid);
            return; //was no interesting quest at all
            break;
    }
}

References AV_QUEST_A_BOSS1, AV_QUEST_A_BOSS2, AV_QUEST_A_COMMANDER1, AV_QUEST_A_COMMANDER2, AV_QUEST_A_COMMANDER3, AV_QUEST_A_NEAR_MINE, AV_QUEST_A_OTHER_MINE, AV_QUEST_A_RIDER_HIDE, AV_QUEST_A_RIDER_TAME, AV_QUEST_A_SCRAPS1, AV_QUEST_A_SCRAPS2, AV_QUEST_H_BOSS1, AV_QUEST_H_BOSS2, AV_QUEST_H_COMMANDER1, AV_QUEST_H_COMMANDER2, AV_QUEST_H_COMMANDER3, AV_QUEST_H_NEAR_MINE, AV_QUEST_H_OTHER_MINE, AV_QUEST_H_RIDER_HIDE, AV_QUEST_H_RIDER_TAME, AV_QUEST_H_SCRAPS1, AV_QUEST_H_SCRAPS2, BG_AV_NODES_FIRSTAID_STATION, BG_AV_NODES_FROSTWOLF_HUT, DePopulateNode(), Battleground::GetStatus(), Player::GetTeamId(), LOG_DEBUG, m_Nodes, m_Team_QuestStatus, POINT_CONTROLED, PopulateNode(), Battleground::RewardReputationToTeam(), BG_AV_NodeInfo::State, and STATUS_IN_PROGRESS.

◆ InitNode()

void BattlegroundAV::InitNode	(	BG_AV_Nodes	node,
		TeamId	teamId,
		bool	tower
	)

private

{
    m_Nodes[node].TotalOwnerId = teamId;
    m_Nodes[node].OwnerId      = teamId;
    m_Nodes[node].PrevOwnerId  = TEAM_NEUTRAL;
    m_Nodes[node].State      = POINT_CONTROLED;
    m_Nodes[node].PrevState  = m_Nodes[node].State;
    m_Nodes[node].Timer      = 0;
    m_Nodes[node].Tower      = tower;
}

References m_Nodes, BG_AV_NodeInfo::OwnerId, POINT_CONTROLED, BG_AV_NodeInfo::PrevOwnerId, BG_AV_NodeInfo::PrevState, BG_AV_NodeInfo::State, TEAM_NEUTRAL, BG_AV_NodeInfo::Timer, BG_AV_NodeInfo::TotalOwnerId, and BG_AV_NodeInfo::Tower.

Referenced by BattlegroundAV(), and ResetBGSubclass().

◆ IsAllTowersControlledAndCaptainAlive()

bool BattlegroundAV::IsAllTowersControlledAndCaptainAlive ( TeamId teamId ) const

{
    if (teamId == TEAM_ALLIANCE)
    {
        for (BG_AV_Nodes i = BG_AV_NODES_DUNBALDAR_SOUTH; i <= BG_AV_NODES_STONEHEART_BUNKER; ++i) // alliance towers controlled
        {
            if (m_Nodes[i].State == POINT_CONTROLED)
            {
                if (m_Nodes[i].OwnerId != TEAM_ALLIANCE)
                    return false;
            }
            else
                return false;
        }
 
        for (BG_AV_Nodes i = BG_AV_NODES_ICEBLOOD_TOWER; i <= BG_AV_NODES_FROSTWOLF_WTOWER; ++i) // horde towers destroyed
            if (m_Nodes[i].State != POINT_DESTROYED)
                return false;
 
        return m_CaptainAlive[0];
    }
    else if (teamId == TEAM_HORDE)
    {
        for (BG_AV_Nodes i = BG_AV_NODES_ICEBLOOD_TOWER; i <= BG_AV_NODES_FROSTWOLF_WTOWER; ++i) // horde towers controlled
        {
            if (m_Nodes[i].State == POINT_CONTROLED)
            {
                if (m_Nodes[i].OwnerId != TEAM_HORDE)
                    return false;
            }
            else
                return false;
        }
 
        for (BG_AV_Nodes i = BG_AV_NODES_DUNBALDAR_SOUTH; i <= BG_AV_NODES_STONEHEART_BUNKER; ++i) // alliance towers destroyed
            if (m_Nodes[i].State != POINT_DESTROYED)
                return false;
 
        return m_CaptainAlive[1];
    }
 
    return false;
}

References BG_AV_NODES_DUNBALDAR_SOUTH, BG_AV_NODES_FROSTWOLF_WTOWER, BG_AV_NODES_ICEBLOOD_TOWER, BG_AV_NODES_STONEHEART_BUNKER, m_CaptainAlive, m_Nodes, POINT_CONTROLED, POINT_DESTROYED, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by achievement_bg_av_perfection::OnCheck().

◆ IsBothMinesControlledByTeam()

bool BattlegroundAV::IsBothMinesControlledByTeam ( TeamId teamId ) const

{
    for (auto& mine : m_Mine_Owner)
        if (mine != teamId)
            return false;
 
    return true;
}

References m_Mine_Owner.

Referenced by achievement_everything_counts::OnCheck().

◆ IsTower()

bool BattlegroundAV::IsTower ( BG_AV_Nodes node )

inlineprivate

1817{ return m_Nodes[node].Tower; }

Referenced by DePopulateNode(), EventPlayerAssaultsPoint(), EventPlayerDefendsPoint(), EventPlayerDestroyedPoint(), and PopulateNode().

◆ PlayerCanDoMineQuest()

bool BattlegroundAV::PlayerCanDoMineQuest	(	int32	GOId,
		TeamId	teamId
	)

{
    if (GOId == BG_AV_OBJECTID_MINE_N)
        return (m_Mine_Owner[AV_NORTH_MINE] == teamId);
    if (GOId == BG_AV_OBJECTID_MINE_S)
        return (m_Mine_Owner[AV_SOUTH_MINE] == teamId);
    return true; //cause it's no mine'object it is ok if this is true
}

References AV_NORTH_MINE, AV_SOUTH_MINE, BG_AV_OBJECTID_MINE_N, BG_AV_OBJECTID_MINE_S, and m_Mine_Owner.

◆ PopulateNode()

void BattlegroundAV::PopulateNode ( BG_AV_Nodes node )

private

{
    TeamId ownerId = m_Nodes[node].OwnerId;
 
    uint32 c_place = AV_CPLACE_DEFENSE_STORM_AID + (4 * node);
    uint32 creatureid;
    if (IsTower(node))
        creatureid = (ownerId == TEAM_ALLIANCE) ? AV_NPC_A_TOWERDEFENSE : AV_NPC_H_TOWERDEFENSE;
    else
    {
        if (m_Team_QuestStatus[ownerId][0] < 500)
            creatureid = (ownerId == TEAM_ALLIANCE) ? AV_NPC_A_GRAVEDEFENSE0 : AV_NPC_H_GRAVEDEFENSE0;
        else if (m_Team_QuestStatus[ownerId][0] < 1000)
            creatureid = (ownerId == TEAM_ALLIANCE) ? AV_NPC_A_GRAVEDEFENSE1 : AV_NPC_H_GRAVEDEFENSE1;
        else if (m_Team_QuestStatus[ownerId][0] < 1500)
            creatureid = (ownerId == TEAM_ALLIANCE) ? AV_NPC_A_GRAVEDEFENSE2 : AV_NPC_H_GRAVEDEFENSE2;
        else
            creatureid = (ownerId == TEAM_ALLIANCE) ? AV_NPC_A_GRAVEDEFENSE3 : AV_NPC_H_GRAVEDEFENSE3;
        //spiritguide
        if (BgCreatures[node])
            DelCreature(node);
        if (!AddSpiritGuide(node, BG_AV_CreaturePos[node][0], BG_AV_CreaturePos[node][1], BG_AV_CreaturePos[node][2], BG_AV_CreaturePos[node][3], ownerId))
            LOG_ERROR("bg.battleground", "AV: couldn't spawn spiritguide at node {}", node);
    }
    for (uint8 i = 0; i < 4; i++)
        AddAVCreature(creatureid, c_place + i);
 
    if (node >= BG_AV_NODES_MAX)//fail safe
        return;
    Creature* trigger = GetBgMap()->GetCreature(BgCreatures[node + 302]);//0-302 other creatures
    if (!trigger)
    {
        trigger = AddCreature(WORLD_TRIGGER,
                              node + 302,
                              BG_AV_CreaturePos[node + 302][0],
                              BG_AV_CreaturePos[node + 302][1],
                              BG_AV_CreaturePos[node + 302][2],
                              BG_AV_CreaturePos[node + 302][3]);
    }
 
    //add bonus honor aura trigger creature when node is accupied
    //cast bonus aura (+50% honor in 25yards)
    //aura should only apply to players who have accupied the node, set correct faction for trigger
    if (trigger)
    {
        if (ownerId != TEAM_ALLIANCE && ownerId != TEAM_HORDE)//node can be neutral, remove trigger
        {
            DelCreature(node + 302);
            return;
        }
        trigger->SetFaction(ownerId == TEAM_ALLIANCE ? FACTION_ALLIANCE_GENERIC : FACTION_HORDE_GENERIC);
        trigger->CastSpell(trigger, SPELL_HONORABLE_DEFENDER_25Y, false);
    }
}

References AddAVCreature(), Battleground::AddCreature(), Battleground::AddSpiritGuide(), AV_CPLACE_DEFENSE_STORM_AID, AV_NPC_A_GRAVEDEFENSE0, AV_NPC_A_GRAVEDEFENSE1, AV_NPC_A_GRAVEDEFENSE2, AV_NPC_A_GRAVEDEFENSE3, AV_NPC_A_TOWERDEFENSE, AV_NPC_H_GRAVEDEFENSE0, AV_NPC_H_GRAVEDEFENSE1, AV_NPC_H_GRAVEDEFENSE2, AV_NPC_H_GRAVEDEFENSE3, AV_NPC_H_TOWERDEFENSE, BG_AV_CreaturePos, BG_AV_NODES_MAX, Battleground::BgCreatures, Unit::CastSpell(), Battleground::DelCreature(), FACTION_ALLIANCE_GENERIC, FACTION_HORDE_GENERIC, Battleground::GetBgMap(), Map::GetCreature(), IsTower(), LOG_ERROR, m_Nodes, m_Team_QuestStatus, BG_AV_NodeInfo::OwnerId, Unit::SetFaction(), SPELL_HONORABLE_DEFENDER_25Y, TEAM_ALLIANCE, TEAM_HORDE, and WORLD_TRIGGER.

Referenced by EventPlayerDefendsPoint(), EventPlayerDestroyedPoint(), HandleQuestComplete(), and SetupBattleground().

◆ PostUpdateImpl()

void BattlegroundAV::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)
    {
        for (uint8 i = 0; i <= 1; i++) //0=alliance, 1=horde
        {
            if (!m_CaptainAlive[i])
            {
                continue;
            }
            if (m_CaptainBuffTimer[i] > diff)
            {
                m_CaptainBuffTimer[i] -= diff;
            }
            else
            {
                if (i == 0)
                {
                    CastSpellOnTeam(AV_BUFF_A_CAPTAIN, TEAM_ALLIANCE);
                    Creature* creature = GetBGCreature(AV_CPLACE_MAX + 61);
                    if (creature)
                    {
                        std::string creatureText = sCreatureTextMgr->GetLocalizedChatString(creature->GetEntry(), creature->getGender(), 0, 0, DEFAULT_LOCALE);
                        YellToAll(creature, creatureText.c_str(), LANG_COMMON);
                    }
                }
                else
                {
                    CastSpellOnTeam(AV_BUFF_H_CAPTAIN, TEAM_HORDE);
                    Creature* creature = GetBGCreature(AV_CPLACE_MAX + 59); //TODO: make the captains a dynamic creature
                    if (creature)
                    {
                        std::string creatureText = sCreatureTextMgr->GetLocalizedChatString(creature->GetEntry(), creature->getGender(), 2, 0, DEFAULT_LOCALE);
                        YellToAll(creature, creatureText.c_str(), LANG_ORCISH);
                    }
                }
                m_CaptainBuffTimer[i] = 120000 + urand(0, 4) * 60000; //as far as i could see, the buff is randomly so i make 2minutes (thats the duration of the buff itself) + 0-4minutes TODO get the right times
            }
        }
        //add points from mine owning, and look if he neutral team wanrts to reclaim the mine
        m_Mine_Timer -= diff;
        for (uint8 mine = 0; mine < 2; mine++)
        {
            if (m_Mine_Owner[mine] == TEAM_ALLIANCE || m_Mine_Owner[mine] == TEAM_HORDE)
            {
                if (m_Mine_Timer <= 0)
                    UpdateScore(m_Mine_Owner[mine], 1);
 
                if (m_Mine_Reclaim_Timer[mine] > diff)
                    m_Mine_Reclaim_Timer[mine] -= diff;
                else  //we don't need to set this timer to 0 cause this codepart wont get called when this thing is 0
                {
                    ChangeMineOwner(mine, TEAM_NEUTRAL);
                }
            }
        }
        if (m_Mine_Timer <= 0)
            m_Mine_Timer = AV_MINE_TICK_TIMER; //this is at the end, cause we need to update both mines
 
        //looks for all timers of the nodes and destroy the building (for graveyards the building wont get destroyed, it goes just to the other team
        for (BG_AV_Nodes i = BG_AV_NODES_FIRSTAID_STATION; i < BG_AV_NODES_MAX; ++i)
            if (m_Nodes[i].State == POINT_ASSAULTED) //maybe remove this
            {
                if (m_Nodes[i].Timer > diff)
                    m_Nodes[i].Timer -= diff;
                else
                    EventPlayerDestroyedPoint(i);
            }
    }
}

References AV_BUFF_A_CAPTAIN, AV_BUFF_H_CAPTAIN, AV_CPLACE_MAX, AV_MINE_TICK_TIMER, BG_AV_NODES_FIRSTAID_STATION, BG_AV_NODES_MAX, Battleground::CastSpellOnTeam(), ChangeMineOwner(), DEFAULT_LOCALE, EventPlayerDestroyedPoint(), Battleground::GetBGCreature(), Object::GetEntry(), Unit::getGender(), Battleground::GetStatus(), LANG_COMMON, LANG_ORCISH, m_CaptainAlive, m_CaptainBuffTimer, m_Mine_Owner, m_Mine_Reclaim_Timer, m_Mine_Timer, m_Nodes, POINT_ASSAULTED, sCreatureTextMgr, STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, BG_AV_NodeInfo::Timer, UpdateScore(), urand(), and Battleground::YellToAll().

◆ RemovePlayer()

void BattlegroundAV::RemovePlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

{
    //TODO search more buffs
    player->RemoveAurasDueToSpell(AV_BUFF_ARMOR);
    player->RemoveAurasDueToSpell(AV_BUFF_A_CAPTAIN);
    player->RemoveAurasDueToSpell(AV_BUFF_H_CAPTAIN);
}

References AV_BUFF_A_CAPTAIN, AV_BUFF_ARMOR, AV_BUFF_H_CAPTAIN, and Unit::RemoveAurasDueToSpell().

◆ ResetBGSubclass()

void BattlegroundAV::ResetBGSubclass ( )

overridevirtual

Reimplemented from Battleground.

{
    for (uint8 i = 0; i < 2; i++) //forloop for both teams (it just make 0 == alliance and 1 == horde also for both mines 0=north 1=south
    {
        for (uint8 j = 0; j < 9; j++)
            m_Team_QuestStatus[i][j] = 0;
        m_Team_Scores[i] = BG_AV_SCORE_INITIAL_POINTS;
        m_IsInformedNearVictory[i] = false;
        m_CaptainAlive[i] = true;
        m_CaptainBuffTimer[i] = 120000 + urand(0, 4) * 60; //as far as i could see, the buff is randomly so i make 2minutes (thats the duration of the buff itself) + 0-4minutes TODO get the right times
        m_Mine_Owner[i] = TEAM_NEUTRAL;
    }
    for (BG_AV_Nodes i = BG_AV_NODES_FIRSTAID_STATION; i <= BG_AV_NODES_STONEHEART_GRAVE; ++i) //alliance graves
        InitNode(i, TEAM_ALLIANCE, false);
    for (BG_AV_Nodes i = BG_AV_NODES_DUNBALDAR_SOUTH; i <= BG_AV_NODES_STONEHEART_BUNKER; ++i) //alliance towers
        InitNode(i, TEAM_ALLIANCE, true);
    for (BG_AV_Nodes i = BG_AV_NODES_ICEBLOOD_GRAVE; i <= BG_AV_NODES_FROSTWOLF_HUT; ++i) //horde graves
        InitNode(i, TEAM_HORDE, false);
    for (BG_AV_Nodes i = BG_AV_NODES_ICEBLOOD_TOWER; i <= BG_AV_NODES_FROSTWOLF_WTOWER; ++i) //horde towers
        InitNode(i, TEAM_HORDE, true);
    InitNode(BG_AV_NODES_SNOWFALL_GRAVE, TEAM_NEUTRAL, false); //give snowfall neutral owner
 
    m_Mine_Timer = AV_MINE_TICK_TIMER;
    for (uint16 i = 0; i < static_cast<uint16>(AV_CPLACE_MAX) + AV_STATICCPLACE_MAX; i++)
        if (BgCreatures[i])
            DelCreature(i);
}

References AV_CPLACE_MAX, AV_MINE_TICK_TIMER, AV_STATICCPLACE_MAX, BG_AV_NODES_DUNBALDAR_SOUTH, BG_AV_NODES_FIRSTAID_STATION, BG_AV_NODES_FROSTWOLF_HUT, BG_AV_NODES_FROSTWOLF_WTOWER, BG_AV_NODES_ICEBLOOD_GRAVE, BG_AV_NODES_ICEBLOOD_TOWER, BG_AV_NODES_SNOWFALL_GRAVE, BG_AV_NODES_STONEHEART_BUNKER, BG_AV_NODES_STONEHEART_GRAVE, BG_AV_SCORE_INITIAL_POINTS, Battleground::BgCreatures, Battleground::DelCreature(), InitNode(), m_CaptainAlive, m_CaptainBuffTimer, m_IsInformedNearVictory, m_Mine_Owner, m_Mine_Timer, m_Team_QuestStatus, m_Team_Scores, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, and urand().

◆ SendMineWorldStates()

void BattlegroundAV::SendMineWorldStates ( uint32 mine )

private

{
    ASSERT(mine == AV_NORTH_MINE || mine == AV_SOUTH_MINE);
 
    uint8 owner = 1;
 
    if (m_Mine_Owner[mine] == TEAM_ALLIANCE)
        owner = 0;
    else if (m_Mine_Owner[mine] == TEAM_HORDE)
        owner = 2;
 
    for (uint8 i = 0; i < 3; ++i)
        UpdateWorldState(BG_AV_MineWorldStates[mine][i], 0); // Xinef: Clear data for consistency and buglessness
 
    UpdateWorldState(BG_AV_MineWorldStates[mine][owner], 1);
}

References ASSERT, AV_NORTH_MINE, AV_SOUTH_MINE, BG_AV_MineWorldStates, m_Mine_Owner, TEAM_ALLIANCE, TEAM_HORDE, and Battleground::UpdateWorldState().

Referenced by ChangeMineOwner(), and FillInitialWorldStates().

◆ SetupBattleground()

bool BattlegroundAV::SetupBattleground ( )

overridevirtual

Reimplemented from Battleground.

{
    // Create starting objects
 
    //spawn node-objects
    for (uint8 i = BG_AV_NODES_FIRSTAID_STATION; i < BG_AV_NODES_MAX; ++i)
    {
        if (i <= BG_AV_NODES_FROSTWOLF_HUT)
        {
            if (!AddObject(i, BG_AV_OBJECTID_BANNER_A_B, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY)
                    || !AddObject(i + 11, BG_AV_OBJECTID_BANNER_CONT_A_B, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY)
                    || !AddObject(i + 33, BG_AV_OBJECTID_BANNER_H_B, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY)
                    || !AddObject(i + 22, BG_AV_OBJECTID_BANNER_CONT_H_B, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY)
                    //aura
                    || !AddObject(BG_AV_OBJECT_AURA_N_FIRSTAID_STATION + i * 3, BG_AV_OBJECTID_AURA_N, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY)
                    || !AddObject(BG_AV_OBJECT_AURA_A_FIRSTAID_STATION + i * 3, BG_AV_OBJECTID_AURA_A, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY)
                    || !AddObject(BG_AV_OBJECT_AURA_H_FIRSTAID_STATION + i * 3, BG_AV_OBJECTID_AURA_H, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY))
            {
                LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!2");
                return false;
            }
        }
        else //towers
        {
            if (i <= BG_AV_NODES_STONEHEART_BUNKER) //alliance towers
            {
                if (!AddObject(i, BG_AV_OBJECTID_BANNER_A, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY)
                        || !AddObject(i + 22, BG_AV_OBJECTID_BANNER_CONT_H, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY)
                        || !AddObject(BG_AV_OBJECT_TAURA_A_DUNBALDAR_SOUTH + (2 * (i - BG_AV_NODES_DUNBALDAR_SOUTH)), BG_AV_OBJECTID_AURA_A, BG_AV_ObjectPos[i + 8][0], BG_AV_ObjectPos[i + 8][1], BG_AV_ObjectPos[i + 8][2], BG_AV_ObjectPos[i + 8][3], 0, 0, std::sin(BG_AV_ObjectPos[i + 8][3] / 2), cos(BG_AV_ObjectPos[i + 8][3] / 2), RESPAWN_ONE_DAY)
                        || !AddObject(BG_AV_OBJECT_TAURA_H_DUNBALDAR_SOUTH + (2 * (i - BG_AV_NODES_DUNBALDAR_SOUTH)), BG_AV_OBJECTID_AURA_N, BG_AV_ObjectPos[i + 8][0], BG_AV_ObjectPos[i + 8][1], BG_AV_ObjectPos[i + 8][2], BG_AV_ObjectPos[i + 8][3], 0, 0, std::sin(BG_AV_ObjectPos[i + 8][3] / 2), cos(BG_AV_ObjectPos[i + 8][3] / 2), RESPAWN_ONE_DAY)
                        || !AddObject(BG_AV_OBJECT_TFLAG_A_DUNBALDAR_SOUTH + (2 * (i - BG_AV_NODES_DUNBALDAR_SOUTH)), BG_AV_OBJECTID_TOWER_BANNER_A, BG_AV_ObjectPos[i + 8][0], BG_AV_ObjectPos[i + 8][1], BG_AV_ObjectPos[i + 8][2], BG_AV_ObjectPos[i + 8][3], 0, 0, std::sin(BG_AV_ObjectPos[i + 8][3] / 2), cos(BG_AV_ObjectPos[i + 8][3] / 2), RESPAWN_ONE_DAY)
                        || !AddObject(BG_AV_OBJECT_TFLAG_H_DUNBALDAR_SOUTH + (2 * (i - BG_AV_NODES_DUNBALDAR_SOUTH)), BG_AV_OBJECTID_TOWER_BANNER_PH, BG_AV_ObjectPos[i + 8][0], BG_AV_ObjectPos[i + 8][1], BG_AV_ObjectPos[i + 8][2], BG_AV_ObjectPos[i + 8][3], 0, 0, std::sin(BG_AV_ObjectPos[i + 8][3] / 2), cos(BG_AV_ObjectPos[i + 8][3] / 2), RESPAWN_ONE_DAY))
                {
                    LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!3");
                    return false;
                }
            }
            else //horde towers
            {
                if (!AddObject(i + 7, BG_AV_OBJECTID_BANNER_CONT_A, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY)
                        || !AddObject(i + 29, BG_AV_OBJECTID_BANNER_H, BG_AV_ObjectPos[i][0], BG_AV_ObjectPos[i][1], BG_AV_ObjectPos[i][2], BG_AV_ObjectPos[i][3], 0, 0, std::sin(BG_AV_ObjectPos[i][3] / 2), cos(BG_AV_ObjectPos[i][3] / 2), RESPAWN_ONE_DAY)
                        || !AddObject(BG_AV_OBJECT_TAURA_A_DUNBALDAR_SOUTH + (2 * (i - BG_AV_NODES_DUNBALDAR_SOUTH)), BG_AV_OBJECTID_AURA_N, BG_AV_ObjectPos[i + 8][0], BG_AV_ObjectPos[i + 8][1], BG_AV_ObjectPos[i + 8][2], BG_AV_ObjectPos[i + 8][3], 0, 0, std::sin(BG_AV_ObjectPos[i + 8][3] / 2), cos(BG_AV_ObjectPos[i + 8][3] / 2), RESPAWN_ONE_DAY)
                        || !AddObject(BG_AV_OBJECT_TAURA_H_DUNBALDAR_SOUTH + (2 * (i - BG_AV_NODES_DUNBALDAR_SOUTH)), BG_AV_OBJECTID_AURA_H, BG_AV_ObjectPos[i + 8][0], BG_AV_ObjectPos[i + 8][1], BG_AV_ObjectPos[i + 8][2], BG_AV_ObjectPos[i + 8][3], 0, 0, std::sin(BG_AV_ObjectPos[i + 8][3] / 2), cos(BG_AV_ObjectPos[i + 8][3] / 2), RESPAWN_ONE_DAY)
                        || !AddObject(BG_AV_OBJECT_TFLAG_A_DUNBALDAR_SOUTH + (2 * (i - BG_AV_NODES_DUNBALDAR_SOUTH)), BG_AV_OBJECTID_TOWER_BANNER_PA, BG_AV_ObjectPos[i + 8][0], BG_AV_ObjectPos[i + 8][1], BG_AV_ObjectPos[i + 8][2], BG_AV_ObjectPos[i + 8][3], 0, 0, std::sin(BG_AV_ObjectPos[i + 8][3] / 2), cos(BG_AV_ObjectPos[i + 8][3] / 2), RESPAWN_ONE_DAY)
                        || !AddObject(BG_AV_OBJECT_TFLAG_H_DUNBALDAR_SOUTH + (2 * (i - BG_AV_NODES_DUNBALDAR_SOUTH)), BG_AV_OBJECTID_TOWER_BANNER_H, BG_AV_ObjectPos[i + 8][0], BG_AV_ObjectPos[i + 8][1], BG_AV_ObjectPos[i + 8][2], BG_AV_ObjectPos[i + 8][3], 0, 0, std::sin(BG_AV_ObjectPos[i + 8][3] / 2), cos(BG_AV_ObjectPos[i + 8][3] / 2), RESPAWN_ONE_DAY))
                {
                    LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!4");
                    return false;
                }
            }
            for (uint8 j = 0; j <= 9; j++) //burning aura
            {
                if (!AddObject(BG_AV_OBJECT_BURN_DUNBALDAR_SOUTH + ((i - BG_AV_NODES_DUNBALDAR_SOUTH) * 10) + j, BG_AV_OBJECTID_FIRE, BG_AV_ObjectPos[AV_OPLACE_BURN_DUNBALDAR_SOUTH + ((i - BG_AV_NODES_DUNBALDAR_SOUTH) * 10) + j][0], BG_AV_ObjectPos[AV_OPLACE_BURN_DUNBALDAR_SOUTH + ((i - BG_AV_NODES_DUNBALDAR_SOUTH) * 10) + j][1], BG_AV_ObjectPos[AV_OPLACE_BURN_DUNBALDAR_SOUTH + ((i - BG_AV_NODES_DUNBALDAR_SOUTH) * 10) + j][2], BG_AV_ObjectPos[AV_OPLACE_BURN_DUNBALDAR_SOUTH + ((i - BG_AV_NODES_DUNBALDAR_SOUTH) * 10) + j][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_BURN_DUNBALDAR_SOUTH + ((i - BG_AV_NODES_DUNBALDAR_SOUTH) * 10) + j][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_BURN_DUNBALDAR_SOUTH + ((i - BG_AV_NODES_DUNBALDAR_SOUTH) * 10) + j][3] / 2), RESPAWN_ONE_DAY))
                {
                    LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!5.{}", i);
                    return false;
                }
            }
        }
    }
    for (uint8 i = 0; i < 2; i++) //burning aura for buildings
    {
        for (uint8 j = 0; j <= 9; j++)
        {
            if (j < 5)
            {
                if (!AddObject(BG_AV_OBJECT_BURN_BUILDING_ALLIANCE + (i * 10) + j, BG_AV_OBJECTID_SMOKE, BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][0], BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][1], BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][2], BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][3] / 2), RESPAWN_ONE_DAY))
                {
                    LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!6.{}", i);
                    return false;
                }
            }
            else
            {
                if (!AddObject(BG_AV_OBJECT_BURN_BUILDING_ALLIANCE + (i * 10) + j, BG_AV_OBJECTID_FIRE, BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][0], BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][1], BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][2], BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_BURN_BUILDING_A + (i * 10) + j][3] / 2), RESPAWN_ONE_DAY))
                {
                    LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!7.{}", i);
                    return false;
                }
            }
        }
    }
    for (uint16 i = 0; i <= (BG_AV_OBJECT_MINE_SUPPLY_N_MAX - BG_AV_OBJECT_MINE_SUPPLY_N_MIN); i++)
    {
        if (!AddObject(BG_AV_OBJECT_MINE_SUPPLY_N_MIN + i, BG_AV_OBJECTID_MINE_N, BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_N_MIN + i][0], BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_N_MIN + i][1], BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_N_MIN + i][2], BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_N_MIN + i][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_N_MIN + i][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_N_MIN + i][3] / 2), RESPAWN_ONE_DAY))
        {
            LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some mine supplies Battleground not created!7.5.{}", i);
            return false;
        }
    }
    for (uint16 i = 0; i <= (BG_AV_OBJECT_MINE_SUPPLY_S_MAX - BG_AV_OBJECT_MINE_SUPPLY_S_MIN); i++)
    {
        if (!AddObject(BG_AV_OBJECT_MINE_SUPPLY_S_MIN + i, BG_AV_OBJECTID_MINE_S, BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_S_MIN + i][0], BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_S_MIN + i][1], BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_S_MIN + i][2], BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_S_MIN + i][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_S_MIN + i][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_MINE_SUPPLY_S_MIN + i][3] / 2), RESPAWN_ONE_DAY))
        {
            LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some mine supplies Battleground not created!7.6.{}", i);
            return false;
        }
    }
 
    if (!AddObject(BG_AV_OBJECT_FLAG_N_SNOWFALL_GRAVE, BG_AV_OBJECTID_BANNER_SNOWFALL_N, BG_AV_ObjectPos[BG_AV_NODES_SNOWFALL_GRAVE][0], BG_AV_ObjectPos[BG_AV_NODES_SNOWFALL_GRAVE][1], BG_AV_ObjectPos[BG_AV_NODES_SNOWFALL_GRAVE][2], BG_AV_ObjectPos[BG_AV_NODES_SNOWFALL_GRAVE][3], 0, 0, std::sin(BG_AV_ObjectPos[BG_AV_NODES_SNOWFALL_GRAVE][3] / 2), cos(BG_AV_ObjectPos[BG_AV_NODES_SNOWFALL_GRAVE][3] / 2), RESPAWN_ONE_DAY))
    {
        LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!8");
        return false;
    }
    for (uint8 i = 0; i < 4; i++)
    {
        if (!AddObject(BG_AV_OBJECT_SNOW_EYECANDY_A + i, BG_AV_OBJECTID_SNOWFALL_CANDY_A, BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][0], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][1], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][2], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3] / 2), RESPAWN_ONE_DAY)
                || !AddObject(BG_AV_OBJECT_SNOW_EYECANDY_PA + i, BG_AV_OBJECTID_SNOWFALL_CANDY_PA, BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][0], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][1], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][2], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3] / 2), RESPAWN_ONE_DAY)
                || !AddObject(BG_AV_OBJECT_SNOW_EYECANDY_H + i, BG_AV_OBJECTID_SNOWFALL_CANDY_H, BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][0], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][1], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][2], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3] / 2), RESPAWN_ONE_DAY)
                || !AddObject(BG_AV_OBJECT_SNOW_EYECANDY_PH + i, BG_AV_OBJECTID_SNOWFALL_CANDY_PH, BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][0], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][1], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][2], BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_SNOW_1 + i][3] / 2), RESPAWN_ONE_DAY))
        {
            LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!9.{}", i);
            return false;
        }
    }
 
    // Handpacked snowdrift, only during holiday
    if (IsHolidayActive(HOLIDAY_FEAST_OF_WINTER_VEIL))
        for (uint16 i = 0 ; i <= (BG_AV_OBJECT_HANDPACKED_SNOWDRIFT_MAX - BG_AV_OBJECT_HANDPACKED_SNOWDRIFT_MIN); i++)
        {
            if (!AddObject(BG_AV_OBJECT_HANDPACKED_SNOWDRIFT_MIN + i, BG_AV_OBJECTID_HARDPACKED_SNOWDRIFT, BG_AV_ObjectPos[AV_OPLACE_HANDPACKED_SNOWDRIFT_MIN + i][0], BG_AV_ObjectPos[AV_OPLACE_HANDPACKED_SNOWDRIFT_MIN + i][1], BG_AV_ObjectPos[AV_OPLACE_HANDPACKED_SNOWDRIFT_MIN + i][2], BG_AV_ObjectPos[AV_OPLACE_HANDPACKED_SNOWDRIFT_MIN + i][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_HANDPACKED_SNOWDRIFT_MIN + i][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_HANDPACKED_SNOWDRIFT_MIN + i][3] / 2), RESPAWN_ONE_DAY))
                return false;
        }
 
    // Hallow's End decorations
    if (IsHolidayActive(HOLIDAY_HALLOWS_END))
        for (uint16 i = 0; i <= (BG_AV_OBJECT_HALLOWS_END_MAX - BG_AV_OBJECT_HALLOWS_END_MIN); i++)
        {
            if (!AddObject(BG_AV_OBJECT_HALLOWS_END_MIN + i,
                std::get<0>(BG_AV_HallowsEndObjectPos[i]),
                std::get<1>(BG_AV_HallowsEndObjectPos[i]).GetPositionX(),
                std::get<1>(BG_AV_HallowsEndObjectPos[i]).GetPositionY(),
                std::get<1>(BG_AV_HallowsEndObjectPos[i]).GetPositionZ(),
                std::get<1>(BG_AV_HallowsEndObjectPos[i]).GetOrientation(),
                std::get<2>(BG_AV_HallowsEndObjectPos[i])[0],
                std::get<2>(BG_AV_HallowsEndObjectPos[i])[1],
                std::get<2>(BG_AV_HallowsEndObjectPos[i])[2],
                std::get<2>(BG_AV_HallowsEndObjectPos[i])[3],
                RESPAWN_ONE_DAY))
            {
                LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!11.{}", i);
                return false;
            }
        }
 
    // Generic gameobjects
    for (uint16 i = 0; i <= (BG_AV_OBJECT_GENERIC_MAX - BG_AV_OBJECT_GENERIC_MIN); i++)
    {
        if (!AddObject(BG_AV_OBJECT_GENERIC_MIN + i,
            std::get<0>(BG_AV_GenericObjectPos[i]),
            std::get<1>(BG_AV_GenericObjectPos[i]).GetPositionX(),
            std::get<1>(BG_AV_GenericObjectPos[i]).GetPositionY(),
            std::get<1>(BG_AV_GenericObjectPos[i]).GetPositionZ(),
            std::get<1>(BG_AV_GenericObjectPos[i]).GetOrientation(),
            std::get<2>(BG_AV_GenericObjectPos[i])[0],
            std::get<2>(BG_AV_GenericObjectPos[i])[1],
            std::get<2>(BG_AV_GenericObjectPos[i])[2],
            std::get<2>(BG_AV_GenericObjectPos[i])[3],
            RESPAWN_ONE_DAY))
        {
            LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!10.{}", i);
            return false;
        }
    }
 
    // Quest banners
    if (!AddObject(BG_AV_OBJECT_FROSTWOLF_BANNER, BG_AV_OBJECTID_FROSTWOLF_BANNER, BG_AV_ObjectPos[AV_OPLACE_FROSTWOLF_BANNER][0], BG_AV_ObjectPos[AV_OPLACE_FROSTWOLF_BANNER][1], BG_AV_ObjectPos[AV_OPLACE_FROSTWOLF_BANNER][2], BG_AV_ObjectPos[AV_OPLACE_FROSTWOLF_BANNER][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_FROSTWOLF_BANNER][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_FROSTWOLF_BANNER][3] / 2), RESPAWN_ONE_DAY))
    {
        LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!8");
        return false;
    }
    if (!AddObject(BG_AV_OBJECT_STORMPIKE_BANNER, BG_AV_OBJECTID_STORMPIKE_BANNER, BG_AV_ObjectPos[AV_OPLACE_STORMPIKE_BANNER][0], BG_AV_ObjectPos[AV_OPLACE_STORMPIKE_BANNER][1], BG_AV_ObjectPos[AV_OPLACE_STORMPIKE_BANNER][2], BG_AV_ObjectPos[AV_OPLACE_STORMPIKE_BANNER][3], 0, 0, std::sin(BG_AV_ObjectPos[AV_OPLACE_STORMPIKE_BANNER][3] / 2), cos(BG_AV_ObjectPos[AV_OPLACE_STORMPIKE_BANNER][3] / 2), RESPAWN_ONE_DAY))
    {
        LOG_ERROR("bg.battleground", "BatteGroundAV: Failed to spawn some object Battleground not created!8");
        return false;
    }
 
    uint16 i;
    LOG_DEBUG("bg.battleground", "Alterac Valley: entering state STATUS_WAIT_JOIN ...");
    // Initial Nodes
    for (i = 0; i < BG_AV_OBJECT_MAX; i++)
        SpawnBGObject(i, RESPAWN_ONE_DAY);
 
    for (i = BG_AV_OBJECT_FLAG_A_FIRSTAID_STATION; i <= BG_AV_OBJECT_FLAG_A_STONEHEART_GRAVE; i++)
    {
        SpawnBGObject(BG_AV_OBJECT_AURA_A_FIRSTAID_STATION + 3 * i, RESPAWN_IMMEDIATELY);
        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
    }
 
    for (i = BG_AV_OBJECT_FLAG_A_DUNBALDAR_SOUTH; i <= BG_AV_OBJECT_FLAG_A_STONEHEART_BUNKER; i++)
        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
 
    for (i = BG_AV_OBJECT_FLAG_H_ICEBLOOD_GRAVE; i <= BG_AV_OBJECT_FLAG_H_FROSTWOLF_WTOWER; i++)
    {
        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
        if (i <= BG_AV_OBJECT_FLAG_H_FROSTWOLF_HUT)
            SpawnBGObject(BG_AV_OBJECT_AURA_H_FIRSTAID_STATION + 3 * GetNodeThroughObject(i), RESPAWN_IMMEDIATELY);
    }
 
    for (i = BG_AV_OBJECT_TFLAG_A_DUNBALDAR_SOUTH; i <= BG_AV_OBJECT_TFLAG_A_STONEHEART_BUNKER; i += 2)
    {
        SpawnBGObject(i, RESPAWN_IMMEDIATELY); //flag
        SpawnBGObject(i + 16, RESPAWN_IMMEDIATELY); //aura
    }
 
    for (i = BG_AV_OBJECT_TFLAG_H_ICEBLOOD_TOWER; i <= BG_AV_OBJECT_TFLAG_H_FROSTWOLF_WTOWER; i += 2)
    {
        SpawnBGObject(i, RESPAWN_IMMEDIATELY); //flag
        SpawnBGObject(i + 16, RESPAWN_IMMEDIATELY); //aura
    }
 
    //snowfall and the doors
    SpawnBGObject(BG_AV_OBJECT_FLAG_N_SNOWFALL_GRAVE, RESPAWN_IMMEDIATELY);
    SpawnBGObject(BG_AV_OBJECT_AURA_N_SNOWFALL_GRAVE, RESPAWN_IMMEDIATELY);
 
    // Handpacked snowdrift, only during holiday
    if (IsHolidayActive(HOLIDAY_FEAST_OF_WINTER_VEIL))
        for (i = BG_AV_OBJECT_HANDPACKED_SNOWDRIFT_MIN ; i <= BG_AV_OBJECT_HANDPACKED_SNOWDRIFT_MAX; i++)
            SpawnBGObject(i, RESPAWN_IMMEDIATELY);
 
    // Hallow's End decorations
    if (IsHolidayActive(HOLIDAY_HALLOWS_END))
        for (uint16 i = BG_AV_OBJECT_HALLOWS_END_MIN; i <= BG_AV_OBJECT_HALLOWS_END_MAX; i++)
            SpawnBGObject(i, RESPAWN_IMMEDIATELY);
 
    // Generic gameobjects
    for (uint16 i = BG_AV_OBJECT_GENERIC_MIN; i <= BG_AV_OBJECT_GENERIC_MAX; i++)
        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
 
    // Quest banners
    SpawnBGObject(BG_AV_OBJECT_FROSTWOLF_BANNER, RESPAWN_IMMEDIATELY);
    SpawnBGObject(BG_AV_OBJECT_STORMPIKE_BANNER, RESPAWN_IMMEDIATELY);
 
    //creatures
    LOG_DEBUG("bg.battleground", "BG_AV start poputlating nodes");
    for (i = BG_AV_NODES_FIRSTAID_STATION; i < BG_AV_NODES_MAX; ++i)
    {
        if (m_Nodes[i].OwnerId != TEAM_NEUTRAL)
            PopulateNode(BG_AV_Nodes(i));
    }
    //all creatures which don't get despawned through the script are static
    LOG_DEBUG("bg.battleground", "BG_AV: start spawning static creatures");
    for (i = 0; i < AV_STATICCPLACE_MAX; i++)
        AddAVCreature(0, i + AV_CPLACE_MAX);
    //mainspiritguides:
    LOG_DEBUG("bg.battleground", "BG_AV: start spawning spiritguides creatures");
    AddSpiritGuide(7, BG_AV_CreaturePos[7][0], BG_AV_CreaturePos[7][1], BG_AV_CreaturePos[7][2], BG_AV_CreaturePos[7][3], TEAM_ALLIANCE);
    AddSpiritGuide(8, BG_AV_CreaturePos[8][0], BG_AV_CreaturePos[8][1], BG_AV_CreaturePos[8][2], BG_AV_CreaturePos[8][3], TEAM_HORDE);
    //spawn the marshals (those who get deleted, if a tower gets destroyed)
    LOG_DEBUG("bg.battleground", "BG_AV: start spawning marshal creatures");
    for (i = AV_NPC_A_MARSHAL_SOUTH; i <= AV_NPC_H_MARSHAL_WTOWER; i++)
        AddAVCreature(i, AV_CPLACE_A_MARSHAL_SOUTH + (i - AV_NPC_A_MARSHAL_SOUTH));
    AddAVCreature(AV_NPC_HERALD, AV_CPLACE_HERALD);
 
    if (
        // alliance gates
        !AddObject(BG_AV_OBJECT_DOOR_A, BG_AV_OBJECTID_GATE_A, BG_AV_DoorPositons[0][0], BG_AV_DoorPositons[0][1], BG_AV_DoorPositons[0][2], BG_AV_DoorPositons[0][3], 0, 0, std::sin(BG_AV_DoorPositons[0][3] / 2), cos(BG_AV_DoorPositons[0][3] / 2), RESPAWN_IMMEDIATELY)
        // horde gates
        || !AddObject(BG_AV_OBJECT_DOOR_H, BG_AV_OBJECTID_GATE_H, BG_AV_DoorPositons[1][0], BG_AV_DoorPositons[1][1], BG_AV_DoorPositons[1][2], BG_AV_DoorPositons[1][3], 0, 0, std::sin(BG_AV_DoorPositons[1][3] / 2), cos(BG_AV_DoorPositons[1][3] / 2), RESPAWN_IMMEDIATELY))
    {
        LOG_ERROR("sql.sql", "BatteGroundAV: Failed to spawn some object Battleground not created!1");
        return false;
    }
 
    return true;
}

◆ StartingEventCloseDoors()

void BattlegroundAV::StartingEventCloseDoors ( )

overridevirtual

Reimplemented from Battleground.

{
    SpawnBGObject(BG_AV_OBJECT_DOOR_A, RESPAWN_IMMEDIATELY);
    SpawnBGObject(BG_AV_OBJECT_DOOR_H, RESPAWN_IMMEDIATELY);
 
    DoorClose(BG_AV_OBJECT_DOOR_A);
    DoorClose(BG_AV_OBJECT_DOOR_H);
}

References BG_AV_OBJECT_DOOR_A, BG_AV_OBJECT_DOOR_H, Battleground::DoorClose(), RESPAWN_IMMEDIATELY, and Battleground::SpawnBGObject().

◆ StartingEventOpenDoors()

void BattlegroundAV::StartingEventOpenDoors ( )

overridevirtual

Reimplemented from Battleground.

{
    LOG_DEBUG("bg.battleground", "BG_AV: start spawning mine stuff");
    for (uint16 i = BG_AV_OBJECT_MINE_SUPPLY_N_MIN; i <= BG_AV_OBJECT_MINE_SUPPLY_N_MAX; i++)
        SpawnBGObject(i, RESPAWN_IMMEDIATELY, 5 * MINUTE);
    for (uint16 i = BG_AV_OBJECT_MINE_SUPPLY_S_MIN; i <= BG_AV_OBJECT_MINE_SUPPLY_S_MAX; i++)
        SpawnBGObject(i, RESPAWN_IMMEDIATELY, 5 * MINUTE);
    for (uint8 mine = AV_NORTH_MINE; mine <= AV_SOUTH_MINE; mine++) //mine population
        ChangeMineOwner(mine, TEAM_NEUTRAL, true);
 
    if (BG_AV_SCORE_INITIAL_POINTS > 0) // display teamscores on top only if reinforcements are enabled
    {
        UpdateWorldState(WORLD_STATE_BATTLEGROUND_AV_SHOW_HORDE_SCORE, 1);
        UpdateWorldState(WORLD_STATE_BATTLEGROUND_AV_SHOW_ALLIANCE_SCORE, 1);
    }
 
    DoorOpen(BG_AV_OBJECT_DOOR_H);
    DoorOpen(BG_AV_OBJECT_DOOR_A);
 
    // Achievement: The Alterac Blitz
    StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, AV_EVENT_START_BATTLE);
}

References ACHIEVEMENT_TIMED_TYPE_EVENT, AV_EVENT_START_BATTLE, AV_NORTH_MINE, AV_SOUTH_MINE, BG_AV_OBJECT_DOOR_A, BG_AV_OBJECT_DOOR_H, BG_AV_OBJECT_MINE_SUPPLY_N_MAX, BG_AV_OBJECT_MINE_SUPPLY_N_MIN, BG_AV_OBJECT_MINE_SUPPLY_S_MAX, BG_AV_OBJECT_MINE_SUPPLY_S_MIN, BG_AV_SCORE_INITIAL_POINTS, ChangeMineOwner(), Battleground::DoorOpen(), LOG_DEBUG, MINUTE, RESPAWN_IMMEDIATELY, Battleground::SpawnBGObject(), Battleground::StartTimedAchievement(), TEAM_NEUTRAL, Battleground::UpdateWorldState(), WORLD_STATE_BATTLEGROUND_AV_SHOW_ALLIANCE_SCORE, and WORLD_STATE_BATTLEGROUND_AV_SHOW_HORDE_SCORE.

◆ UpdateNodeWorldState()

void BattlegroundAV::UpdateNodeWorldState ( BG_AV_Nodes node )

private

{
    UpdateWorldState(BG_AV_NodeWorldStates[node][GetWorldStateType(m_Nodes[node].State, m_Nodes[node].OwnerId)], 1);
    if (m_Nodes[node].PrevOwnerId == TEAM_NEUTRAL) //currently only snowfall is supported as neutral node (i don't want to make an extra row (neutral states) in worldstatesarray just for one node
        UpdateWorldState(WORLD_STATE_BATTLEGROUND_AV_SNOWFALL_N, 0);
    else
        UpdateWorldState(BG_AV_NodeWorldStates[node][GetWorldStateType(m_Nodes[node].PrevState, m_Nodes[node].PrevOwnerId)], 0);
}

References BG_AV_NodeWorldStates, GetWorldStateType(), m_Nodes, TEAM_NEUTRAL, Battleground::UpdateWorldState(), and WORLD_STATE_BATTLEGROUND_AV_SNOWFALL_N.

Referenced by EventPlayerAssaultsPoint(), EventPlayerDefendsPoint(), and EventPlayerDestroyedPoint().

◆ UpdatePlayerScore()

bool BattlegroundAV::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_GRAVEYARDS_ASSAULTED:
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, AV_OBJECTIVE_ASSAULT_GRAVEYARD);
            break;
        case SCORE_GRAVEYARDS_DEFENDED:
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, AV_OBJECTIVE_DEFEND_GRAVEYARD);
            break;
        case SCORE_TOWERS_ASSAULTED:
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, AV_OBJECTIVE_ASSAULT_TOWER);
            break;
        case SCORE_TOWERS_DEFENDED:
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, AV_OBJECTIVE_DEFEND_TOWER);
            break;
        default:
            break;
    }
 
    return true;
}

References ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, AV_OBJECTIVE_ASSAULT_GRAVEYARD, AV_OBJECTIVE_ASSAULT_TOWER, AV_OBJECTIVE_DEFEND_GRAVEYARD, AV_OBJECTIVE_DEFEND_TOWER, SCORE_GRAVEYARDS_ASSAULTED, SCORE_GRAVEYARDS_DEFENDED, SCORE_TOWERS_ASSAULTED, SCORE_TOWERS_DEFENDED, Player::UpdateAchievementCriteria(), and Battleground::UpdatePlayerScore().

Referenced by EventPlayerAssaultsPoint(), EventPlayerDefendsPoint(), and HandleKillUnit().

◆ UpdateScore()

void BattlegroundAV::UpdateScore	(	TeamId	teamId,
		int16	points
	)

{
    if (BG_AV_SCORE_INITIAL_POINTS == 0)
        return; // don't update teamscores if reinforcements are disabled
 
    //note: to remove reinforcementpoints points must be negative, for adding reinforcements points must be positive
    m_Team_Scores[teamId] += points;
 
    UpdateWorldState(((teamId == TEAM_HORDE) ? WORLD_STATE_BATTLEGROUND_AV_HORDE_SCORE : WORLD_STATE_BATTLEGROUND_AV_ALLIANCE_SCORE), m_Team_Scores[teamId]);
    if (points < 0)
    {
        if (m_Team_Scores[teamId] < 1)
        {
            m_Team_Scores[teamId] = 0;
            EndBattleground(GetOtherTeamId(teamId));
        }
        else if (!m_IsInformedNearVictory[teamId] && m_Team_Scores[teamId] < SEND_MSG_NEAR_LOSE)
        {
            if (teamId == TEAM_ALLIANCE)
            {
                SendBroadcastText(BG_AV_TEXT_ALLIANCE_NEAR_LOSE, CHAT_MSG_BG_SYSTEM_ALLIANCE);
            }
            else
            {
                SendBroadcastText(BG_AV_TEXT_HORDE_NEAR_LOSE, CHAT_MSG_BG_SYSTEM_HORDE);
            }
 
            PlaySoundToAll(AV_SOUND_NEAR_VICTORY);
            m_IsInformedNearVictory[teamId] = true;
        }
    }
}

References AV_SOUND_NEAR_VICTORY, BG_AV_SCORE_INITIAL_POINTS, BG_AV_TEXT_ALLIANCE_NEAR_LOSE, BG_AV_TEXT_HORDE_NEAR_LOSE, CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, EndBattleground(), Battleground::GetOtherTeamId(), m_IsInformedNearVictory, m_Team_Scores, Battleground::PlaySoundToAll(), SEND_MSG_NEAR_LOSE, Battleground::SendBroadcastText(), TEAM_ALLIANCE, TEAM_HORDE, Battleground::UpdateWorldState(), WORLD_STATE_BATTLEGROUND_AV_ALLIANCE_SCORE, and WORLD_STATE_BATTLEGROUND_AV_HORDE_SCORE.

Referenced by EventPlayerDestroyedPoint(), HandleKillPlayer(), HandleKillUnit(), and PostUpdateImpl().

Member Data Documentation

◆ m_CaptainAlive

bool BattlegroundAV::m_CaptainAlive[2] {}

private

1845{};

Referenced by BattlegroundAV(), EndBattleground(), HandleKillUnit(), IsAllTowersControlledAndCaptainAlive(), PostUpdateImpl(), and ResetBGSubclass().

◆ m_CaptainBuffTimer

uint32 BattlegroundAV::m_CaptainBuffTimer[2] {}

private

1844{};

Referenced by BattlegroundAV(), PostUpdateImpl(), and ResetBGSubclass().

◆ m_IsInformedNearVictory

bool BattlegroundAV::m_IsInformedNearVictory[2] {}

private

1847{};

Referenced by BattlegroundAV(), ResetBGSubclass(), and UpdateScore().

◆ m_Mine_Owner

TeamId BattlegroundAV::m_Mine_Owner[2] {}

private

1841{};

Referenced by BattlegroundAV(), ChangeMineOwner(), IsBothMinesControlledByTeam(), PlayerCanDoMineQuest(), PostUpdateImpl(), ResetBGSubclass(), and SendMineWorldStates().

◆ m_Mine_Reclaim_Timer

uint32 BattlegroundAV::m_Mine_Reclaim_Timer[2] {}

private

1843{};

Referenced by BattlegroundAV(), ChangeMineOwner(), and PostUpdateImpl().

◆ m_Mine_Timer

int32 BattlegroundAV::m_Mine_Timer

private

Referenced by BattlegroundAV(), PostUpdateImpl(), and ResetBGSubclass().

◆ m_Nodes

BG_AV_NodeInfo BattlegroundAV::m_Nodes[BG_AV_NODES_MAX] {}

private

1839{};

Referenced by AssaultNode(), DefendNode(), DestroyNode(), EndBattleground(), EventPlayerAssaultsPoint(), EventPlayerDefendsPoint(), EventPlayerDestroyedPoint(), FillInitialWorldStates(), GetClosestGraveyard(), GetObjectThroughNode(), HandleQuestComplete(), InitNode(), IsAllTowersControlledAndCaptainAlive(), PopulateNode(), PostUpdateImpl(), SetupBattleground(), and UpdateNodeWorldState().

◆ m_Team_QuestStatus

uint32 BattlegroundAV::m_Team_QuestStatus[2][9] {}

private

1837{}; //[x][y] x=team y=questcounter

Referenced by BattlegroundAV(), HandleQuestComplete(), PopulateNode(), and ResetBGSubclass().

◆ m_Team_Scores

int32 BattlegroundAV::m_Team_Scores[2] {}

private

1836{};

Referenced by BattlegroundAV(), FillInitialWorldStates(), ResetBGSubclass(), and UpdateScore().

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

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BattlegroundAV()

◆ ~BattlegroundAV()

Member Function Documentation

◆ AddAVCreature()

◆ AddPlayer()

◆ AssaultNode()

◆ ChangeMineOwner()

◆ DefendNode()

◆ DePopulateNode()

◆ DestroyNode()

◆ EndBattleground()

◆ EventPlayerAssaultsPoint()

◆ EventPlayerClickedOnFlag()

◆ EventPlayerDefendsPoint()

◆ EventPlayerDestroyedPoint()

◆ FillInitialWorldStates()

◆ GetAttackString()

◆ GetClosestGraveyard()

◆ GetDefendString()

◆ GetMineString()

◆ GetNodeThroughObject()

◆ GetObjectThroughNode()

◆ GetPrematureWinner()

◆ GetWorldStateType()

◆ HandleAreaTrigger()

◆ HandleKillPlayer()

◆ HandleKillUnit()

◆ HandleQuestComplete()

◆ InitNode()

◆ IsAllTowersControlledAndCaptainAlive()

◆ IsBothMinesControlledByTeam()

◆ IsTower()

◆ PlayerCanDoMineQuest()

◆ PopulateNode()

◆ PostUpdateImpl()

◆ RemovePlayer()

◆ ResetBGSubclass()

◆ SendMineWorldStates()

◆ SetupBattleground()

◆ StartingEventCloseDoors()

◆ StartingEventOpenDoors()

◆ UpdateNodeWorldState()

◆ UpdatePlayerScore()

◆ UpdateScore()

Member Data Documentation

◆ m_CaptainAlive

◆ m_CaptainBuffTimer

◆ m_IsInformedNearVictory

◆ m_Mine_Owner

◆ m_Mine_Reclaim_Timer

◆ m_Mine_Timer

◆ m_Nodes

◆ m_Team_QuestStatus

◆ m_Team_Scores