Class for manage Strand of Ancient battleground. More...

#include "BattlegroundSA.h"

Inheritance diagram for BattlegroundSA:

Public Member Functions
	BattlegroundSA ()

	~BattlegroundSA () override

void	PostUpdateImpl (uint32 diff) override
	Called every time for update battle data -Update timer -Round switch.

void	AddPlayer (Player *player) override
	Called when a player join battle.

void	StartingEventCloseDoors () override
	Called when battle start.

void	StartingEventOpenDoors () override

bool	SetupBattleground () override
	Called for ini battleground, after that the first player be entered.

void	Init () override

void	FillInitialWorldStates (WorldPacket &data) override
	Called for generate packet contain worldstate data.

void	EventPlayerDamagedGO (Player player, GameObject go, uint32 eventType) override
	Called when a player deal damage to building (door)

void	HandleKillUnit (Creature creature, Player killer) override
	Called when a player kill a unit in bg.

GraveyardStruct const *	GetClosestGraveyard (Player *player) override
	Return the nearest graveyard where player can respawn.

void	EventPlayerClickedOnFlag (Player Source, GameObject gameObject) override
	Called when a player click on flag (graveyard flag)

void	EventPlayerUsedGO (Player Source, GameObject object) override
	Called when a player use a gamobject (relic)

uint32	GetWorldStateFromGateID (uint32 id)
	Return worldstate id, according to door id.

void	EndBattleground (TeamId winnerTeamId) override
	Called on battleground ending.

void	RemovePlayer (Player *player) override
	CAlled when a player leave battleground.

void	HandleAreaTrigger (Player *player, uint32 trigger) override

void	DefendersPortalTeleport (GameObject portal, Player plr)

bool	AllowDefenseOfTheAncients (Player *source)

bool	notEvenAScratch (TeamId teamId) const

Public Member Functions inherited from Battleground
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual bool	SetupBattleground ()

virtual void	Init ()

virtual void	StartingEventCloseDoors ()

virtual void	StartingEventOpenDoors ()

virtual void	ResetBGSubclass ()

virtual void	DestroyGate (Player , GameObject )

virtual bool	AllNodesConrolledByTeam (TeamId) const

void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)

std::string	GetName () const

BattlegroundTypeId	GetBgTypeID (bool GetRandom=false) const

BattlegroundBracketId	GetBracketId () const

uint32	GetInstanceID () const

BattlegroundStatus	GetStatus () const

uint32	GetClientInstanceID () const

uint32	GetStartTime () const

uint32	GetEndTime () const

uint32	GetLastResurrectTime () const

uint32	GetMinLevel () const

uint32	GetMaxLevel () const

uint32	GetMaxPlayersPerTeam () const

uint32	GetMinPlayersPerTeam () const

int32	GetStartDelayTime () const

uint8	GetArenaType () const

PvPTeamId	GetWinner () const

uint32	GetScriptId () const

uint32	GetBonusHonorFromKill (uint32 kills) const

bool	SpiritofCompetitionEvent (PvPTeamId winnerTeamId)

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

virtual void	FillInitialWorldStates (WorldPacket &)

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)

virtual void	EndBattleground (TeamId winnerTeamId)

void	BlockMovement (Player *player)

void	SendWarningToAll (uint32 entry,...)

void	SendMessageToAll (uint32 entry, ChatMsg type, Player const *source=nullptr)

void	PSendMessageToAll (uint32 entry, ChatMsg type, Player const *source,...)

void	SendMessage2ToAll (uint32 entry, ChatMsg type, Player const *source, uint32 strId1=0, uint32 strId2=0)

Group *	GetBgRaid (TeamId teamId) const

void	SetBgRaid (TeamId teamId, Group *bg_raid)

void	BuildPvPLogDataPacket (WorldPacket &data)

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

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	HandleAreaTrigger (Player *, uint32)

virtual void	HandleKillPlayer (Player player, Player killer)

virtual void	HandleKillUnit (Creature , Player )

virtual void	EventPlayerDroppedFlag (Player *)

virtual void	EventPlayerClickedOnFlag (Player , GameObject )

virtual void	EventPlayerDamagedGO (Player , GameObject , uint32)

virtual void	EventPlayerUsedGO (Player , GameObject )

virtual void	DoAction (uint32, ObjectGuid)

virtual void	HandlePlayerResurrect (Player *)

virtual GraveyardStruct const *	GetClosestGraveyard (Player *player)

virtual void	AddPlayer (Player *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)

const char *	GetAcoreString (int32 entry)

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

virtual TeamId	GetPrematureWinner ()

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
uint32	GetGateIDFromEntry (uint32 id)
	Return gate id, relative to bg data, according to gameobject id.

bool	ResetObjs ()
	Called on setup and between the two round -Delete all gameobject / creature -Respawn all gameobject / creature to have good faction.

void	StartShips ()
	Called for start ship movement.

void	TeleportPlayers ()
	Called between the two round -Teleport all players to good location.

void	TeleportToEntrancePosition (Player *player)

void	OverrideGunFaction ()
	Called on start and between the two round -Update faction of all vehicle.

void	DemolisherStartState (bool start)
	Set selectable or not demolisher, called on battle start, when boats arrive to dock.

bool	CanInteractWithObject (uint32 objectId)
	Checks if a player can interact with the given object.

void	UpdateObjectInteractionFlags (uint32 objectId)
	Updates interaction flags of specific objects.

void	UpdateObjectInteractionFlags ()

void	DestroyGate (Player player, GameObject go) override
	Called when a gate is destroy -Give honor to player witch destroy it -Update worldstate -Delete gameobject in front of door (lighting object, with different colours for each door)

void	SendTime ()
	Update timer worldstate.

void	CaptureGraveyard (BG_SA_Graveyards i, Player *Source)
	Called when a graveyard is capture -Update spiritguide -Update gameobject (flag) -Update Worldstate -Send warning for announce this.

void	ToggleTimer ()
	Switch on/off timer worldstate.

void	UpdateDemolisherSpawns ()
	Respawn dead demolisher.

void	SendTransportInit (Player *player)
	Send packet to player for create boats (client part)

void	SendTransportsRemove (Player *player)
	Send packet to player for destroy boats (client part)

Private Attributes
TeamId	Attackers
	Id of attacker team.

Milliseconds	TotalTime
	Totale elapsed time of current round.

Milliseconds	EndRoundTimer
	Max time of round.

bool	ShipsStarted
	For know if boats has start moving or not yet.

BG_SA_GateState	GateStatus [6]
	Status of each gate (Destroy/Damage/Intact)

BG_SA_Status	Status
	Statu of battle (Start or not, and what round)

TeamId	GraveyardStatus [BG_SA_MAX_GY]
	Team witch conntrol each graveyard.

BG_SA_RoundScore	RoundScores [2]
	Score of each round.

bool	TimerEnabled
	used for know we are in timer phase or not (used for worldstate update)

uint32	UpdateWaitTimer
	5secs before starting the 1min countdown for second round

bool	SignaledRoundTwo
	for know if warning about second round start has been sent

bool	SignaledRoundTwoHalfMin
	for know if warning about second round start has been sent

bool	InitSecondRound
	for know if second round has been init

std::map< uint32, uint32 >	DemoliserRespawnList

bool	_relicClicked

bool	_notEvenAScratch [PVP_TEAMS_COUNT]

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)

virtual void	RemovePlayer (Player *)

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

Class for manage Strand of Ancient battleground.

Constructor & Destructor Documentation

◆ BattlegroundSA()

BattlegroundSA::BattlegroundSA ( )

This is here to prevent an uninitialised variable warning The warning only occurs when SetUpBattleGround fails though. In the future this function should be called BEFORE sending initial worldstates.

{
    StartMessageIds[BG_STARTING_EVENT_FOURTH] = 0;
    BgObjects.resize(BG_SA_MAXOBJ);
    BgCreatures.resize(static_cast<uint16>(BG_SA_MAXNPC) + BG_SA_MAX_GY);
    TimerEnabled = false;
    UpdateWaitTimer = 0;
    SignaledRoundTwo = false;
    SignaledRoundTwoHalfMin = false;
    InitSecondRound = false;
    Attackers = TEAM_ALLIANCE;
    TotalTime = 0s;
    EndRoundTimer = 0s;
    ShipsStarted = false;
    Status = BG_SA_NOTSTARTED;
 
    for (uint8 i = 0; i < 6; i++)
        GateStatus[i] = BG_SA_GATE_OK;
 
    for (uint8 i = 0; i < 2; i++)
    {
        RoundScores[i].winner = TEAM_ALLIANCE;
        RoundScores[i].time = 0s;
    }
 
    memset(&GraveyardStatus, 0, sizeof(GraveyardStatus));
}

References Attackers, BG_SA_GATE_OK, BG_SA_MAX_GY, BG_SA_MAXNPC, BG_SA_MAXOBJ, BG_SA_NOTSTARTED, BG_STARTING_EVENT_FOURTH, Battleground::BgCreatures, Battleground::BgObjects, EndRoundTimer, GateStatus, GraveyardStatus, InitSecondRound, RoundScores, ShipsStarted, SignaledRoundTwo, SignaledRoundTwoHalfMin, Battleground::StartMessageIds, Status, TEAM_ALLIANCE, BG_SA_RoundScore::time, TimerEnabled, TotalTime, UpdateWaitTimer, and BG_SA_RoundScore::winner.

◆ ~BattlegroundSA()

BattlegroundSA::~BattlegroundSA ( )

override

71{

72}

Member Function Documentation

◆ AddPlayer()

void BattlegroundSA::AddPlayer ( Player * player )

overridevirtual

Called when a player join battle.

Reimplemented from Battleground.

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

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

◆ AllowDefenseOfTheAncients()

bool BattlegroundSA::AllowDefenseOfTheAncients ( Player * source )

{
    if (source->GetTeamId() == Attackers)
        return false;
 
    for (uint8 i = 0; i <= 5; i++)
    {
        if (GateStatus[i] == BG_SA_GATE_DESTROYED)
            return false;
    }
 
    return true;
}

References Attackers, BG_SA_GATE_DESTROYED, GateStatus, and Player::GetTeamId().

Referenced by achievement_sa_defense_of_the_ancients::OnCheck().

◆ CanInteractWithObject()

bool BattlegroundSA::CanInteractWithObject ( uint32 objectId )

private

Checks if a player can interact with the given object.

{
    switch (objectId)
    {
        case BG_SA_TITAN_RELIC:
            if (GateStatus[BG_SA_ANCIENT_GATE] != BG_SA_GATE_DESTROYED || GateStatus[BG_SA_YELLOW_GATE] != BG_SA_GATE_DESTROYED)
            {
                return false;
            }
            [[fallthrough]];
        case BG_SA_CENTRAL_FLAG:
            if (GateStatus[BG_SA_RED_GATE] != BG_SA_GATE_DESTROYED && GateStatus[BG_SA_PURPLE_GATE] != BG_SA_GATE_DESTROYED)
            {
                return false;
            }
            [[fallthrough]];
        case BG_SA_LEFT_FLAG:
        case BG_SA_RIGHT_FLAG:
            if (GateStatus[BG_SA_GREEN_GATE] != BG_SA_GATE_DESTROYED && GateStatus[BG_SA_BLUE_GATE] != BG_SA_GATE_DESTROYED)
            {
                return false;
            }
            break;
        default:
            ABORT();
            break;
    }
 
    return true;
}

References ABORT, BG_SA_ANCIENT_GATE, BG_SA_BLUE_GATE, BG_SA_CENTRAL_FLAG, BG_SA_GATE_DESTROYED, BG_SA_GREEN_GATE, BG_SA_LEFT_FLAG, BG_SA_PURPLE_GATE, BG_SA_RED_GATE, BG_SA_RIGHT_FLAG, BG_SA_TITAN_RELIC, BG_SA_YELLOW_GATE, and GateStatus.

Referenced by EventPlayerClickedOnFlag(), EventPlayerUsedGO(), and UpdateObjectInteractionFlags().

◆ CaptureGraveyard()

void BattlegroundSA::CaptureGraveyard	(	BG_SA_Graveyards	i,
		Player *	Source
	)

private

Called when a graveyard is capture -Update spiritguide -Update gameobject (flag) -Update Worldstate -Send warning for announce this.

Parameters

i	: id of graveyard
Source	: Player who capture gy

{
    if (GraveyardStatus[i] == Attackers || Source->GetTeamId() != Attackers)
        return;
 
    GraveyardStatus[i] = Source->GetTeamId();
    // Those who are waiting to resurrect at this node are taken to the closest own node's graveyard
    GuidVector& ghost_list = m_ReviveQueue[BgCreatures[static_cast<uint16>(BG_SA_MAXNPC) + i]];
    if (!ghost_list.empty())
    {
        GraveyardStruct const* ClosestGrave = nullptr;
        for (ObjectGuid const& guid : ghost_list)
        {
            Player* player = ObjectAccessor::FindPlayer(guid);
            if (!player)
                continue;
 
            if (!ClosestGrave)                              // cache
                ClosestGrave = GetClosestGraveyard(player);
 
            if (ClosestGrave)
                player->TeleportTo(GetMapId(), ClosestGrave->x, ClosestGrave->y, ClosestGrave->z, player->GetOrientation());
        }
 
        // xinef: clear resurrect queue for this creature
        ghost_list.clear();
    }
 
    DelCreature(static_cast<uint16>(BG_SA_MAXNPC) + i);
 
    GraveyardStruct const* sg = sGraveyard->GetGraveyard(BG_SA_GYEntries[i]);
    if (!sg)
    {
        LOG_ERROR("bg.battleground", "BattlegroundSA::CaptureGraveyard: non-existant GY entry: {}", BG_SA_GYEntries[i]);
        return;
    }
 
    AddSpiritGuide(i + static_cast<uint16>(BG_SA_MAXNPC), sg->x, sg->y, sg->z, BG_SA_GYOrientation[i], GraveyardStatus[i]);
    uint32 npc = 0;
    uint32 flag = 0;
 
    switch(i)
    {
        case BG_SA_LEFT_CAPTURABLE_GY:
            flag = BG_SA_LEFT_FLAG;
            DelObject(flag);
            AddObject(flag, (BG_SA_ObjEntries[flag] - (Source->GetTeamId() == TEAM_ALLIANCE ? 0 : 1)),
                      BG_SA_ObjSpawnlocs[flag][0], BG_SA_ObjSpawnlocs[flag][1],
                      BG_SA_ObjSpawnlocs[flag][2], BG_SA_ObjSpawnlocs[flag][3], 0, 0, 0, 0, RESPAWN_ONE_DAY);
 
            npc = BG_SA_NPC_RIGSPARK;
            AddCreature(BG_SA_NpcEntries[npc], npc, Attackers,
                        BG_SA_NpcSpawnlocs[npc][0], BG_SA_NpcSpawnlocs[npc][1],
                        BG_SA_NpcSpawnlocs[npc][2], BG_SA_NpcSpawnlocs[npc][3]);
 
            for (uint8 j = BG_SA_DEMOLISHER_7; j <= BG_SA_DEMOLISHER_8; j++)
            {
                AddCreature(BG_SA_NpcEntries[j], j,
                            BG_SA_NpcSpawnlocs[j][0], BG_SA_NpcSpawnlocs[j][1],
                            BG_SA_NpcSpawnlocs[j][2], BG_SA_NpcSpawnlocs[j][3], 600);
 
                if (Creature* dem = GetBGCreature(j))
                    dem->SetFaction(BG_SA_Factions[Attackers]);
            }
 
            UpdateWorldState(BG_SA_LEFT_GY_ALLIANCE, (GraveyardStatus[i] == TEAM_ALLIANCE ? 1 : 0));
            UpdateWorldState(BG_SA_LEFT_GY_HORDE, (GraveyardStatus[i] == TEAM_ALLIANCE ? 0 : 1));
            if (Source->GetTeamId() == TEAM_ALLIANCE)
                SendWarningToAll(LANG_BG_SA_A_GY_WEST);
            else
                SendWarningToAll(LANG_BG_SA_H_GY_WEST);
            break;
        case BG_SA_RIGHT_CAPTURABLE_GY:
            flag = BG_SA_RIGHT_FLAG;
            DelObject(flag);
            AddObject(flag, (BG_SA_ObjEntries[flag] - (Source->GetTeamId() == TEAM_ALLIANCE ? 0 : 1)),
                      BG_SA_ObjSpawnlocs[flag][0], BG_SA_ObjSpawnlocs[flag][1],
                      BG_SA_ObjSpawnlocs[flag][2], BG_SA_ObjSpawnlocs[flag][3], 0, 0, 0, 0, RESPAWN_ONE_DAY);
 
            npc = BG_SA_NPC_SPARKLIGHT;
            AddCreature(BG_SA_NpcEntries[npc], npc,
                        BG_SA_NpcSpawnlocs[npc][0], BG_SA_NpcSpawnlocs[npc][1],
                        BG_SA_NpcSpawnlocs[npc][2], BG_SA_NpcSpawnlocs[npc][3]);
 
            for (uint8 j = BG_SA_DEMOLISHER_5; j <= BG_SA_DEMOLISHER_6; j++)
            {
                AddCreature(BG_SA_NpcEntries[j], j, BG_SA_NpcSpawnlocs[j][0], BG_SA_NpcSpawnlocs[j][1],
                            BG_SA_NpcSpawnlocs[j][2], BG_SA_NpcSpawnlocs[j][3], 600);
 
                if (Creature* dem = GetBGCreature(j))
                    dem->SetFaction(BG_SA_Factions[Attackers]);
            }
 
            UpdateWorldState(BG_SA_RIGHT_GY_ALLIANCE, (GraveyardStatus[i] == TEAM_ALLIANCE ? 1 : 0));
            UpdateWorldState(BG_SA_RIGHT_GY_HORDE, (GraveyardStatus[i] == TEAM_ALLIANCE ? 0 : 1));
            if (Source->GetTeamId() == TEAM_ALLIANCE)
                SendWarningToAll(LANG_BG_SA_A_GY_EAST);
            else
                SendWarningToAll(LANG_BG_SA_H_GY_EAST);
            break;
        case BG_SA_CENTRAL_CAPTURABLE_GY:
            flag = BG_SA_CENTRAL_FLAG;
            DelObject(flag);
            AddObject(flag, (BG_SA_ObjEntries[flag] - (Source->GetTeamId() == TEAM_ALLIANCE ? 0 : 1)),
                      BG_SA_ObjSpawnlocs[flag][0], BG_SA_ObjSpawnlocs[flag][1],
                      BG_SA_ObjSpawnlocs[flag][2], BG_SA_ObjSpawnlocs[flag][3], 0, 0, 0, 0, RESPAWN_ONE_DAY);
 
            UpdateWorldState(BG_SA_CENTER_GY_ALLIANCE, (GraveyardStatus[i] == TEAM_ALLIANCE ? 1 : 0));
            UpdateWorldState(BG_SA_CENTER_GY_HORDE, (GraveyardStatus[i] == TEAM_ALLIANCE ? 0 : 1));
            if (Source->GetTeamId() == TEAM_ALLIANCE)
                SendWarningToAll(LANG_BG_SA_A_GY_SOUTH);
            else
                SendWarningToAll(LANG_BG_SA_H_GY_SOUTH);
            break;
        default:
            ABORT();
            break;
    }
}

References ABORT, Battleground::AddCreature(), Battleground::AddObject(), Battleground::AddSpiritGuide(), Attackers, BG_SA_CENTER_GY_ALLIANCE, BG_SA_CENTER_GY_HORDE, BG_SA_CENTRAL_CAPTURABLE_GY, BG_SA_CENTRAL_FLAG, BG_SA_DEMOLISHER_5, BG_SA_DEMOLISHER_6, BG_SA_DEMOLISHER_7, BG_SA_DEMOLISHER_8, BG_SA_Factions, BG_SA_GYEntries, BG_SA_GYOrientation, BG_SA_LEFT_CAPTURABLE_GY, BG_SA_LEFT_FLAG, BG_SA_LEFT_GY_ALLIANCE, BG_SA_LEFT_GY_HORDE, BG_SA_MAXNPC, BG_SA_NPC_RIGSPARK, BG_SA_NPC_SPARKLIGHT, BG_SA_NpcEntries, BG_SA_NpcSpawnlocs, BG_SA_ObjEntries, BG_SA_ObjSpawnlocs, BG_SA_RIGHT_CAPTURABLE_GY, BG_SA_RIGHT_FLAG, BG_SA_RIGHT_GY_ALLIANCE, BG_SA_RIGHT_GY_HORDE, Battleground::BgCreatures, Battleground::DelCreature(), Battleground::DelObject(), ObjectAccessor::FindPlayer(), Battleground::GetBGCreature(), GetClosestGraveyard(), Battleground::GetMapId(), Position::GetOrientation(), Player::GetTeamId(), GraveyardStatus, LANG_BG_SA_A_GY_EAST, LANG_BG_SA_A_GY_SOUTH, LANG_BG_SA_A_GY_WEST, LANG_BG_SA_H_GY_EAST, LANG_BG_SA_H_GY_SOUTH, LANG_BG_SA_H_GY_WEST, LOG_ERROR, Battleground::m_ReviveQueue, RESPAWN_ONE_DAY, Battleground::SendWarningToAll(), sGraveyard, TEAM_ALLIANCE, Player::TeleportTo(), Battleground::UpdateWorldState(), GraveyardStruct::x, GraveyardStruct::y, and GraveyardStruct::z.

Referenced by EventPlayerClickedOnFlag().

◆ DefendersPortalTeleport()

void BattlegroundSA::DefendersPortalTeleport	(	GameObject *	portal,
		Player *	plr
	)

{
    if (plr->GetTeamId() == Attackers)
        return;
 
    uint32 portal_num = 0;
    //get it via X
    switch( (uint32)portal->GetPositionX() )
    {
        case 1394:
            portal_num = 0;
            break;
        case 1065:
            portal_num = 1;
            break;
        case 1468:
            portal_num = 2;
            break;
        case 1255:
            portal_num = 3;
            break;
        case 1216:
            portal_num = 4;
            break;
    }
 
    plr->TeleportTo( plr->GetMapId(), SOTADefPortalDest[portal_num][0], SOTADefPortalDest[portal_num][1], SOTADefPortalDest[portal_num][2], SOTADefPortalDest[portal_num][3], TELE_TO_SPELL );
}

References Attackers, WorldLocation::GetMapId(), Position::GetPositionX(), Player::GetTeamId(), SOTADefPortalDest, TELE_TO_SPELL, and Player::TeleportTo().

Referenced by Spell::EffectScriptEffect().

◆ DemolisherStartState()

void BattlegroundSA::DemolisherStartState ( bool start )

private

Set selectable or not demolisher, called on battle start, when boats arrive to dock.

{
    if (!BgCreatures[0])
        return;
 
    for (uint8 i = BG_SA_DEMOLISHER_1; i <= BG_SA_DEMOLISHER_4; i++)
        if (Creature* dem = GetBGCreature(i))
        {
            if (start)
                dem->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
            else
                dem->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
        }
 
    for (uint8 i = BG_SA_GUN_1; i <= BG_SA_GUN_10; i++)
        if (Creature* gun = GetBGCreature(i))
        {
            if (start)
                gun->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
            else
                gun->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
        }
 
    // xinef: enable first gates damaging at start
    if (!start)
    {
        if (GameObject* go = GetBGObject(BG_SA_GREEN_GATE))
            go->SetDestructibleBuildingModifyState(true);
        if (GameObject* go = GetBGObject(BG_SA_BLUE_GATE))
            go->SetDestructibleBuildingModifyState(true);
    }
}

References BG_SA_BLUE_GATE, BG_SA_DEMOLISHER_1, BG_SA_DEMOLISHER_4, BG_SA_GREEN_GATE, BG_SA_GUN_1, BG_SA_GUN_10, Battleground::BgCreatures, Battleground::GetBGCreature(), Battleground::GetBGObject(), UNIT_FLAG_NON_ATTACKABLE, and UNIT_FLAG_NOT_SELECTABLE.

Referenced by PostUpdateImpl(), and ResetObjs().

◆ DestroyGate()

void BattlegroundSA::DestroyGate	(	Player *	player,
		GameObject *	go
	)

overrideprivatevirtual

Called when a gate is destroy -Give honor to player witch destroy it -Update worldstate -Delete gameobject in front of door (lighting object, with different colours for each door)

Reimplemented from Battleground.

{
    uint32 i = GetGateIDFromEntry(go->GetEntry());
    if (!GateStatus[i])
        return;
 
    if (GameObject* g = GetBGObject(i))
    {
        if (g->GetGOValue()->Building.Health == 0)
        {
            GateStatus[i] = BG_SA_GATE_DESTROYED;
            if (uint32 uws = GetWorldStateFromGateID(i))
                UpdateWorldState(uws, GateStatus[i]);
 
            bool rewardHonor = true;
            switch (i)
            {
                case BG_SA_GREEN_GATE:
                    if (GateStatus[BG_SA_BLUE_GATE] == BG_SA_GATE_DESTROYED)
                        rewardHonor = false;
                    break;
                case BG_SA_BLUE_GATE:
                    if (GateStatus[BG_SA_GREEN_GATE] == BG_SA_GATE_DESTROYED)
                        rewardHonor = false;
                    break;
                case BG_SA_RED_GATE:
                    if (GateStatus[BG_SA_PURPLE_GATE] == BG_SA_GATE_DESTROYED)
                        rewardHonor = false;
                    break;
                case BG_SA_PURPLE_GATE:
                    if (GateStatus[BG_SA_RED_GATE] == BG_SA_GATE_DESTROYED)
                        rewardHonor = false;
                    break;
            }
 
            UpdateObjectInteractionFlags();
 
            if (i < 5)
                DelObject(i + 9);
 
            if (player)
            {
                UpdatePlayerScore(player, SCORE_DESTROYED_WALL, 1);
                if (rewardHonor)
                    UpdatePlayerScore(player, SCORE_BONUS_HONOR, GetBonusHonorFromKill(1));
            }
        }
    }
}

References BG_SA_BLUE_GATE, BG_SA_GATE_DESTROYED, BG_SA_GREEN_GATE, BG_SA_PURPLE_GATE, BG_SA_RED_GATE, Battleground::DelObject(), GateStatus, Battleground::GetBGObject(), Battleground::GetBonusHonorFromKill(), Object::GetEntry(), GetGateIDFromEntry(), GetWorldStateFromGateID(), SCORE_BONUS_HONOR, SCORE_DESTROYED_WALL, UpdateObjectInteractionFlags(), Battleground::UpdatePlayerScore(), and Battleground::UpdateWorldState().

◆ EndBattleground()

void BattlegroundSA::EndBattleground ( TeamId winnerTeamId )

overridevirtual

Called on battleground ending.

Reimplemented from Battleground.

{
    //honor reward for winning
    RewardHonorToTeam(GetBonusHonorFromKill(1), winnerTeamId);
 
    //complete map_end rewards (even if no team wins)
    RewardHonorToTeam(GetBonusHonorFromKill(2), TEAM_ALLIANCE);
    RewardHonorToTeam(GetBonusHonorFromKill(2), TEAM_HORDE);
 
    Battleground::EndBattleground(winnerTeamId);
}

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

Referenced by EventPlayerUsedGO(), and PostUpdateImpl().

◆ EventPlayerClickedOnFlag()

void BattlegroundSA::EventPlayerClickedOnFlag	(	Player *	Source,
		GameObject *	gameObject
	)

overridevirtual

Called when a player click on flag (graveyard flag)

Reimplemented from Battleground.

{
    switch (gameObject->GetEntry())
    {
        case 191307:
        case 191308:
            if (CanInteractWithObject(BG_SA_LEFT_FLAG))
                CaptureGraveyard(BG_SA_LEFT_CAPTURABLE_GY, Source);
            break;
        case 191305:
        case 191306:
            if (CanInteractWithObject(BG_SA_RIGHT_FLAG))
                CaptureGraveyard(BG_SA_RIGHT_CAPTURABLE_GY, Source);
            break;
        case 191310:
        case 191309:
            if (CanInteractWithObject(BG_SA_CENTRAL_FLAG))
                CaptureGraveyard(BG_SA_CENTRAL_CAPTURABLE_GY, Source);
            break;
        default:
            return;
    }
}

References BG_SA_CENTRAL_CAPTURABLE_GY, BG_SA_CENTRAL_FLAG, BG_SA_LEFT_CAPTURABLE_GY, BG_SA_LEFT_FLAG, BG_SA_RIGHT_CAPTURABLE_GY, BG_SA_RIGHT_FLAG, CanInteractWithObject(), CaptureGraveyard(), and Object::GetEntry().

◆ EventPlayerDamagedGO()

void BattlegroundSA::EventPlayerDamagedGO	(	Player *	player,
		GameObject *	go,
		uint32	eventType
	)

overridevirtual

Called when a player deal damage to building (door)

Reimplemented from Battleground.

{
    if (!go || !go->GetGOInfo())
        return;
 
    if (eventType == go->GetGOInfo()->building.damagedEvent)
    {
        uint32 i = GetGateIDFromEntry(go->GetEntry());
        GateStatus[i] = BG_SA_GATE_DAMAGED;
        uint32 uws = GetWorldStateFromGateID(i);
        if (uws)
            UpdateWorldState(uws, GateStatus[i]);
    }
 
    if (eventType == go->GetGOInfo()->building.destroyedEvent)
    {
        if (go->GetGOInfo()->building.destroyedEvent == 19837)
            SendWarningToAll(LANG_BG_SA_CHAMBER_BREACHED);
        else
            SendWarningToAll(LANG_BG_SA_WAS_DESTROYED, go->GetGOInfo()->name.c_str());
 
        uint32 i = GetGateIDFromEntry(go->GetEntry());
        switch (i)
        {
            case BG_SA_BLUE_GATE:
            case BG_SA_GREEN_GATE:
                {
                    if (auto redGate = GetBGObject(BG_SA_RED_GATE))
                    {
                        redGate->SetDestructibleBuildingModifyState(true);
                    }
                    if (auto purpleGate = GetBGObject(BG_SA_PURPLE_GATE))
                    {
                        purpleGate->SetDestructibleBuildingModifyState(true);
                    }
                    break;
                }
            case BG_SA_RED_GATE:
            case BG_SA_PURPLE_GATE:
                if (auto yellowGate = GetBGObject(BG_SA_YELLOW_GATE))
                {
                    yellowGate->SetDestructibleBuildingModifyState(true);
                }
                break;
            case BG_SA_YELLOW_GATE:
                if (auto ancientGate = GetBGObject(BG_SA_ANCIENT_GATE))
                {
                    ancientGate->SetDestructibleBuildingModifyState(true);
                }
                break;
        }
    }
 
    if (eventType == go->GetGOInfo()->building.damageEvent)
        SendWarningToAll(LANG_BG_SA_IS_UNDER_ATTACK, go->GetGOInfo()->name.c_str());
}

References BG_SA_ANCIENT_GATE, BG_SA_BLUE_GATE, BG_SA_GATE_DAMAGED, BG_SA_GREEN_GATE, BG_SA_PURPLE_GATE, BG_SA_RED_GATE, BG_SA_YELLOW_GATE, GameObjectTemplate::building, GameObjectTemplate::damagedEvent, GameObjectTemplate::damageEvent, GameObjectTemplate::destroyedEvent, GateStatus, Battleground::GetBGObject(), Object::GetEntry(), GetGateIDFromEntry(), GameObject::GetGOInfo(), GetWorldStateFromGateID(), LANG_BG_SA_CHAMBER_BREACHED, LANG_BG_SA_IS_UNDER_ATTACK, LANG_BG_SA_WAS_DESTROYED, GameObjectTemplate::name, Battleground::SendWarningToAll(), and Battleground::UpdateWorldState().

◆ EventPlayerUsedGO()

void BattlegroundSA::EventPlayerUsedGO	(	Player *	Source,
		GameObject *	object
	)

overridevirtual

Called when a player use a gamobject (relic)

Reimplemented from Battleground.

{
    if (object->GetEntry() == BG_SA_ObjEntries[BG_SA_TITAN_RELIC] && CanInteractWithObject(BG_SA_TITAN_RELIC))
    {
        if (Source->GetTeamId() == Attackers)
        {
            if (Source->GetTeamId() == TEAM_ALLIANCE)
                SendMessageToAll(LANG_BG_SA_ALLIANCE_CAPTURED_RELIC, CHAT_MSG_BG_SYSTEM_NEUTRAL);
            else SendMessageToAll(LANG_BG_SA_HORDE_CAPTURED_RELIC, CHAT_MSG_BG_SYSTEM_NEUTRAL);
 
            if (Status == BG_SA_ROUND_ONE)
            {
                _relicClicked = true;
            }
            else if (Status == BG_SA_ROUND_TWO)
            {
                RoundScores[1].winner = Attackers;
                RoundScores[1].time = TotalTime;
                ToggleTimer();
                //Achievement Storm the Beach (1310)
                for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
                    if (itr->second->GetTeamId() == Attackers && RoundScores[1].winner == Attackers)
                        itr->second->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, 65246);
 
                if (RoundScores[0].time == RoundScores[1].time)
                    EndBattleground(TEAM_NEUTRAL);
                else if (RoundScores[0].time < RoundScores[1].time)
                    EndBattleground(RoundScores[0].winner);
                else
                    EndBattleground(RoundScores[1].winner);
            }
        }
    }
}

References _relicClicked, ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, Attackers, BG_SA_ObjEntries, BG_SA_ROUND_ONE, BG_SA_ROUND_TWO, BG_SA_TITAN_RELIC, CanInteractWithObject(), CHAT_MSG_BG_SYSTEM_NEUTRAL, EndBattleground(), Object::GetEntry(), Battleground::GetPlayers(), Player::GetTeamId(), LANG_BG_SA_ALLIANCE_CAPTURED_RELIC, LANG_BG_SA_HORDE_CAPTURED_RELIC, RoundScores, Battleground::SendMessageToAll(), Status, TEAM_ALLIANCE, TEAM_NEUTRAL, BG_SA_RoundScore::time, ToggleTimer(), TotalTime, and BG_SA_RoundScore::winner.

◆ FillInitialWorldStates()

void BattlegroundSA::FillInitialWorldStates ( WorldPacket & data )

overridevirtual

Called for generate packet contain worldstate data.

Reimplemented from Battleground.

{
    uint32 ally_attacks = uint32(Attackers == TEAM_ALLIANCE ? 1 : 0);
    uint32 horde_attacks = uint32(Attackers == TEAM_HORDE ? 1 : 0);
 
    data << uint32(BG_SA_ANCIENT_GATEWS) << uint32(GateStatus[BG_SA_ANCIENT_GATE]);
    data << uint32(BG_SA_YELLOW_GATEWS) << uint32(GateStatus[BG_SA_YELLOW_GATE]);
    data << uint32(BG_SA_GREEN_GATEWS) << uint32(GateStatus[BG_SA_GREEN_GATE]);
    data << uint32(BG_SA_BLUE_GATEWS) << uint32(GateStatus[BG_SA_BLUE_GATE]);
    data << uint32(BG_SA_RED_GATEWS) << uint32(GateStatus[BG_SA_RED_GATE]);
    data << uint32(BG_SA_PURPLE_GATEWS) << uint32(GateStatus[BG_SA_PURPLE_GATE]);
 
    data << uint32(BG_SA_BONUS_TIMER) << uint32(0);
 
    data << uint32(BG_SA_HORDE_ATTACKS) << horde_attacks;
    data << uint32(BG_SA_ALLY_ATTACKS) << ally_attacks;
 
    //Time will be sent on first update...
    data << uint32(BG_SA_ENABLE_TIMER) << ((TimerEnabled) ? uint32(1) : uint32(0));
    data << uint32(BG_SA_TIMER_MINS) << uint32(0);
    data << uint32(BG_SA_TIMER_SEC_TENS) << uint32(0);
    data << uint32(BG_SA_TIMER_SEC_DECS) << uint32(0);
 
    data << uint32(BG_SA_RIGHT_GY_HORDE) << uint32(GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
    data << uint32(BG_SA_LEFT_GY_HORDE) << uint32(GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
    data << uint32(BG_SA_CENTER_GY_HORDE) << uint32(GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
 
    data << uint32(BG_SA_RIGHT_GY_ALLIANCE) << uint32(GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
    data << uint32(BG_SA_LEFT_GY_ALLIANCE) << uint32(GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
    data << uint32(BG_SA_CENTER_GY_ALLIANCE) << uint32(GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
 
    data << uint32(BG_SA_HORDE_DEFENCE_TOKEN) << ally_attacks;
    data << uint32(BG_SA_ALLIANCE_DEFENCE_TOKEN) << horde_attacks;
 
    data << uint32(BG_SA_LEFT_ATT_TOKEN_HRD) << horde_attacks;
    data << uint32(BG_SA_RIGHT_ATT_TOKEN_HRD) << horde_attacks;
    data << uint32(BG_SA_RIGHT_ATT_TOKEN_ALL) <<  ally_attacks;
    data << uint32(BG_SA_LEFT_ATT_TOKEN_ALL) <<  ally_attacks;
}

References Attackers, BG_SA_ALLIANCE_DEFENCE_TOKEN, BG_SA_ALLY_ATTACKS, BG_SA_ANCIENT_GATE, BG_SA_ANCIENT_GATEWS, BG_SA_BLUE_GATE, BG_SA_BLUE_GATEWS, BG_SA_BONUS_TIMER, BG_SA_CENTER_GY_ALLIANCE, BG_SA_CENTER_GY_HORDE, BG_SA_CENTRAL_CAPTURABLE_GY, BG_SA_ENABLE_TIMER, BG_SA_GREEN_GATE, BG_SA_GREEN_GATEWS, BG_SA_HORDE_ATTACKS, BG_SA_HORDE_DEFENCE_TOKEN, BG_SA_LEFT_ATT_TOKEN_ALL, BG_SA_LEFT_ATT_TOKEN_HRD, BG_SA_LEFT_CAPTURABLE_GY, BG_SA_LEFT_GY_ALLIANCE, BG_SA_LEFT_GY_HORDE, BG_SA_PURPLE_GATE, BG_SA_PURPLE_GATEWS, BG_SA_RED_GATE, BG_SA_RED_GATEWS, BG_SA_RIGHT_ATT_TOKEN_ALL, BG_SA_RIGHT_ATT_TOKEN_HRD, BG_SA_RIGHT_CAPTURABLE_GY, BG_SA_RIGHT_GY_ALLIANCE, BG_SA_RIGHT_GY_HORDE, BG_SA_TIMER_MINS, BG_SA_TIMER_SEC_DECS, BG_SA_TIMER_SEC_TENS, BG_SA_YELLOW_GATE, BG_SA_YELLOW_GATEWS, GateStatus, GraveyardStatus, TEAM_ALLIANCE, TEAM_HORDE, and TimerEnabled.

◆ GetClosestGraveyard()

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

overridevirtual

Return the nearest graveyard where player can respawn.

Reimplemented from Battleground.

{
    GraveyardStruct const* closest = nullptr;
    float mindist = 999999.0f;
    float x, y;
 
    player->GetPosition(x, y);
 
    for (uint8 i = BG_SA_BEACH_GY; i < BG_SA_MAX_GY; i++)
    {
        if (GraveyardStatus[i] != player->GetTeamId())
            continue;
 
        GraveyardStruct const* ret = sGraveyard->GetGraveyard(BG_SA_GYEntries[i]);
 
        // if on beach
        if (i == BG_SA_BEACH_GY)
        {
            if (x > 1400)
                return ret;
            continue;
        }
 
        float dist = std::sqrt(pow(ret->x - x, 2) * pow(ret->y - y, 2));
        if (dist < mindist)
        {
            mindist = dist;
            closest = ret;
        }
    }
    if (!closest && GraveyardStatus[BG_SA_BEACH_GY] == player->GetTeamId())
        return sGraveyard->GetGraveyard(BG_SA_GYEntries[BG_SA_BEACH_GY]);
 
    return closest;
}

References BG_SA_BEACH_GY, BG_SA_GYEntries, BG_SA_MAX_GY, Position::GetPosition(), Player::GetTeamId(), GraveyardStatus, sGraveyard, GraveyardStruct::x, and GraveyardStruct::y.

Referenced by CaptureGraveyard().

◆ GetGateIDFromEntry()

uint32 BattlegroundSA::GetGateIDFromEntry ( uint32 id )

inlineprivate

Return gate id, relative to bg data, according to gameobject id.

    {
        uint32 i = 0;
        switch(id)
        {
            case 190722:
                i = BG_SA_GREEN_GATE;
                break; //Green gate destroyed
            case 190724:
                i = BG_SA_BLUE_GATE;
                break; //blue gate
            case 190726:
                i = BG_SA_RED_GATE;
                break; //red gate
            case 190723:
                i = BG_SA_PURPLE_GATE;
                break; //purple gate
            case 190727:
                i = BG_SA_YELLOW_GATE;
                break; //yellow gate
            case 192549:
                i = BG_SA_ANCIENT_GATE;
                break; //ancient gate
        }
        return i;
    }

References BG_SA_ANCIENT_GATE, BG_SA_BLUE_GATE, BG_SA_GREEN_GATE, BG_SA_PURPLE_GATE, BG_SA_RED_GATE, and BG_SA_YELLOW_GATE.

Referenced by DestroyGate(), and EventPlayerDamagedGO().

◆ GetWorldStateFromGateID()

uint32 BattlegroundSA::GetWorldStateFromGateID ( uint32 id )

inline

Return worldstate id, according to door id.

    {
        uint32 uws = 0;
        switch (id)
        {
            case BG_SA_GREEN_GATE:
                uws = BG_SA_GREEN_GATEWS;
                break;
            case BG_SA_YELLOW_GATE:
                uws = BG_SA_YELLOW_GATEWS;
                break;
            case BG_SA_BLUE_GATE:
                uws = BG_SA_BLUE_GATEWS;
                break;
            case BG_SA_RED_GATE:
                uws = BG_SA_RED_GATEWS;
                break;
            case BG_SA_PURPLE_GATE:
                uws = BG_SA_PURPLE_GATEWS;
                break;
            case BG_SA_ANCIENT_GATE:
                uws = BG_SA_ANCIENT_GATEWS;
                break;
        }
        return uws;
    }

References BG_SA_ANCIENT_GATE, BG_SA_ANCIENT_GATEWS, BG_SA_BLUE_GATE, BG_SA_BLUE_GATEWS, BG_SA_GREEN_GATE, BG_SA_GREEN_GATEWS, BG_SA_PURPLE_GATE, BG_SA_PURPLE_GATEWS, BG_SA_RED_GATE, BG_SA_RED_GATEWS, BG_SA_YELLOW_GATE, and BG_SA_YELLOW_GATEWS.

Referenced by DestroyGate(), and EventPlayerDamagedGO().

◆ HandleAreaTrigger()

void BattlegroundSA::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;
}

References Battleground::GetStatus(), and STATUS_IN_PROGRESS.

◆ HandleKillUnit()

void BattlegroundSA::HandleKillUnit	(	Creature *	creature,
		Player *	killer
	)

overridevirtual

Called when a player kill a unit in bg.

Reimplemented from Battleground.

{
    if (creature->GetEntry() == NPC_DEMOLISHER_SA)
    {
        UpdatePlayerScore(killer, SCORE_DESTROYED_DEMOLISHER, 1);
        _notEvenAScratch[Attackers] = false;
        creature->SetVisible(false);
    }
}

References _notEvenAScratch, Attackers, Object::GetEntry(), NPC_DEMOLISHER_SA, SCORE_DESTROYED_DEMOLISHER, Unit::SetVisible(), and Battleground::UpdatePlayerScore().

◆ Init()

void BattlegroundSA::Init ( )

overridevirtual

Reimplemented from Battleground.

{
    Battleground::Init();
 
    TotalTime = 0s;
    Attackers = ((urand(0, 1)) ? TEAM_ALLIANCE : TEAM_HORDE);
    for (uint8 i = 0; i <= 5; i++)
        GateStatus[i] = BG_SA_GATE_OK;
    ShipsStarted = false;
    _notEvenAScratch[TEAM_ALLIANCE] = true;
    _notEvenAScratch[TEAM_HORDE] = true;
    Status = BG_SA_WARMUP;
    _relicClicked = false;
}

References _notEvenAScratch, _relicClicked, Attackers, BG_SA_GATE_OK, BG_SA_WARMUP, GateStatus, Battleground::Init(), ShipsStarted, Status, TEAM_ALLIANCE, TEAM_HORDE, TotalTime, and urand().

◆ notEvenAScratch()

bool BattlegroundSA::notEvenAScratch ( TeamId teamId ) const

inline

532{ return _notEvenAScratch[teamId]; }

Referenced by achievement_not_even_a_scratch::OnCheck().

◆ OverrideGunFaction()

void BattlegroundSA::OverrideGunFaction ( )

private

Called on start and between the two round -Update faction of all vehicle.

{
    if (!BgCreatures[0])
        return;
 
    for (uint8 i = BG_SA_GUN_1; i <= BG_SA_GUN_10; i++)
    {
        if (Creature* gun = GetBGCreature(i))
            gun->SetFaction(BG_SA_Factions[Attackers ? TEAM_ALLIANCE : TEAM_HORDE]);
    }
 
    for (uint8 i = BG_SA_DEMOLISHER_1; i <= BG_SA_DEMOLISHER_4; i++)
    {
        if (Creature* dem = GetBGCreature(i))
            dem->SetFaction(BG_SA_Factions[Attackers]);
    }
}

References Attackers, BG_SA_DEMOLISHER_1, BG_SA_DEMOLISHER_4, BG_SA_Factions, BG_SA_GUN_1, BG_SA_GUN_10, Battleground::BgCreatures, Battleground::GetBGCreature(), TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by ResetObjs().

◆ PostUpdateImpl()

void BattlegroundSA::PostUpdateImpl ( uint32 diff )

overridevirtual

Called every time for update battle data -Update timer -Round switch.

Reimplemented from Battleground.

{
    if (InitSecondRound)
    {
        if (UpdateWaitTimer < diff)
        {
            if (!SignaledRoundTwo)
            {
                SignaledRoundTwo = true;
                InitSecondRound = false;
                SendBroadcastText(BG_SA_TEXT_ROUND_TWO_START_ONE_MINUTE, CHAT_MSG_BG_SYSTEM_NEUTRAL);
            }
        }
        else
        {
            UpdateWaitTimer -= diff;
            return;
        }
    }
    TotalTime += Milliseconds(diff);
 
    if (Status == BG_SA_WARMUP)
    {
        EndRoundTimer = BG_SA_ROUNDLENGTH;
        if (TotalTime >= BG_SA_WARMUPLENGTH)
        {
            TotalTime = 0s;
            ToggleTimer();
            DemolisherStartState(false);
            Status = BG_SA_ROUND_ONE;
            StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, (Attackers == TEAM_ALLIANCE) ? 23748 : 21702);
        }
        if (TotalTime >= BG_SA_BOAT_START)
            StartShips();
        return;
    }
    else if (Status == BG_SA_SECOND_WARMUP)
    {
        if (RoundScores[0].time < BG_SA_ROUNDLENGTH)
            EndRoundTimer = RoundScores[0].time;
        else
            EndRoundTimer = BG_SA_ROUNDLENGTH;
 
        if (TotalTime >= 1min)
        {
            SendWarningToAll(LANG_BG_SA_HAS_BEGUN);
            TotalTime = 0s;
            ToggleTimer();
            DemolisherStartState(false);
            Status = BG_SA_ROUND_TWO;
            StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, (Attackers == TEAM_ALLIANCE) ? 23748 : 21702);
 
            // status was set to STATUS_WAIT_JOIN manually for Preparation, set it back now
            SetStatus(STATUS_IN_PROGRESS);
            for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
                itr->second->RemoveAurasDueToSpell(SPELL_PREPARATION);
        }
        if (TotalTime >= 30s)
        {
            if (!SignaledRoundTwoHalfMin)
            {
                SignaledRoundTwoHalfMin = true;
                SendBroadcastText(BG_SA_TEXT_ROUND_TWO_START_HALF_MINUTE, CHAT_MSG_BG_SYSTEM_NEUTRAL);
            }
        }
        StartShips();
        return;
    }
    else if (GetStatus() == STATUS_IN_PROGRESS)
    {
        if (Status == BG_SA_ROUND_ONE)
        {
            if (TotalTime >= BG_SA_ROUNDLENGTH || _relicClicked)
            {
                if (_relicClicked)
                {
                    RoundScores[0].winner = Attackers;
                    RoundScores[0].time = TotalTime;
                    //Achievement Storm the Beach (1310)
                    for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
                        if (itr->second->GetTeamId() == Attackers)
                            itr->second->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, 65246);
                }
                else
                {
                    // cast this before Attackers variable is switched
                    // cast this spell only upon timer end, no other ability for defenders to win :)
                    for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
                        itr->second->CastSpell(itr->second, SPELL_SA_END_OF_ROUND, true);
 
                    RoundScores[0].winner = Attackers;
                    RoundScores[0].time = BG_SA_ROUNDLENGTH;
                }
 
                _relicClicked = false;
                Attackers = (Attackers == TEAM_ALLIANCE) ? TEAM_HORDE : TEAM_ALLIANCE;
                Status = BG_SA_SECOND_WARMUP;
                TotalTime = 0s;
                ToggleTimer();
                SendWarningToAll(LANG_BG_SA_ROUND_ONE_END);
                UpdateWaitTimer = 5000;
                SignaledRoundTwo = false;
                SignaledRoundTwoHalfMin = false;
                InitSecondRound = true;
                ResetObjs();
 
                return;
            }
        }
        else if (Status == BG_SA_ROUND_TWO)
        {
            if (TotalTime >= EndRoundTimer)
            {
                // cast this spell only upon timer end, no other ability for defenders to win :)
                for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
                    itr->second->CastSpell(itr->second, SPELL_SA_END_OF_ROUND, true);
 
                RoundScores[1].time = BG_SA_ROUNDLENGTH;
                RoundScores[1].winner = GetOtherTeamId(Attackers);
 
                if (RoundScores[0].time == RoundScores[1].time)
                    EndBattleground(TEAM_NEUTRAL);
                else if (RoundScores[0].time < RoundScores[1].time)
                    EndBattleground(RoundScores[0].winner);
                else
                    EndBattleground(RoundScores[1].winner);
                return;
            }
        }
        if (Status == BG_SA_ROUND_ONE || Status == BG_SA_ROUND_TWO)
        {
            SendTime();
            UpdateDemolisherSpawns();
        }
    }
}

References _relicClicked, ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, ACHIEVEMENT_TIMED_TYPE_EVENT, Attackers, BG_SA_BOAT_START, BG_SA_ROUND_ONE, BG_SA_ROUND_TWO, BG_SA_ROUNDLENGTH, BG_SA_SECOND_WARMUP, BG_SA_TEXT_ROUND_TWO_START_HALF_MINUTE, BG_SA_TEXT_ROUND_TWO_START_ONE_MINUTE, BG_SA_WARMUP, BG_SA_WARMUPLENGTH, CHAT_MSG_BG_SYSTEM_NEUTRAL, DemolisherStartState(), EndBattleground(), EndRoundTimer, Battleground::GetOtherTeamId(), Battleground::GetPlayers(), Battleground::GetStatus(), InitSecondRound, LANG_BG_SA_HAS_BEGUN, LANG_BG_SA_ROUND_ONE_END, ResetObjs(), RoundScores, Battleground::SendBroadcastText(), SendTime(), Battleground::SendWarningToAll(), Battleground::SetStatus(), SignaledRoundTwo, SignaledRoundTwoHalfMin, SPELL_PREPARATION, SPELL_SA_END_OF_ROUND, StartShips(), Battleground::StartTimedAchievement(), Status, STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, BG_SA_RoundScore::time, ToggleTimer(), TotalTime, UpdateDemolisherSpawns(), UpdateWaitTimer, and BG_SA_RoundScore::winner.

◆ RemovePlayer()

void BattlegroundSA::RemovePlayer ( Player * player )

overridevirtual

CAlled when a player leave battleground.

Reimplemented from Battleground.

510{

511}

◆ ResetObjs()

bool BattlegroundSA::ResetObjs ( )

private

Called on setup and between the two round -Delete all gameobject / creature -Respawn all gameobject / creature to have good faction.

{
    for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
        SendTransportsRemove(itr->second);
 
    uint32 atF = BG_SA_Factions[Attackers];
    uint32 defF = BG_SA_Factions[Attackers ? TEAM_ALLIANCE : TEAM_HORDE];
 
    for (uint8 i = 0; i < BG_SA_MAXOBJ; i++)
        DelObject(i);
 
    for (uint8 i = 0; i < BG_SA_MAXNPC; i++)
        DelCreature(i);
 
    for (uint8 i = BG_SA_MAXNPC; i < static_cast<uint16>(BG_SA_MAXNPC) + BG_SA_MAX_GY; i++)
        DelCreature(i);
 
    for (uint8 i = 0; i < 6; ++i)
        GateStatus[i] = BG_SA_GATE_OK;
 
    for (uint8 i = 0; i < BG_SA_BOAT_ONE; i++)
    {
        if (!AddObject(i, BG_SA_ObjEntries[i], BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1], BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3], 0, 0, 0, 0, RESPAWN_ONE_DAY))
            return false;
    }
 
    for (uint8 i = BG_SA_BOAT_ONE; i < BG_SA_SIGIL_1; i++)
    {
        uint32 boatid = 0;
        switch (i)
        {
            case BG_SA_BOAT_ONE:
                boatid = Attackers ? BG_SA_BOAT_ONE_H : BG_SA_BOAT_ONE_A;
                break;
            case BG_SA_BOAT_TWO:
                boatid = Attackers ? BG_SA_BOAT_TWO_H : BG_SA_BOAT_TWO_A;
                break;
        }
        if (!AddObject(i, boatid, BG_SA_ObjSpawnlocs[i][0],
                       BG_SA_ObjSpawnlocs[i][1],
                       BG_SA_ObjSpawnlocs[i][2] + (Attackers ? -3.750f : 0),
                       BG_SA_ObjSpawnlocs[i][3], 0, 0, 0, 0, RESPAWN_ONE_DAY))
            return false;
    }
 
    for (uint8 i = BG_SA_SIGIL_1; i < BG_SA_CENTRAL_FLAG; i++)
    {
        if (!AddObject(i, BG_SA_ObjEntries[i],
                       BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1],
                       BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3],
                       0, 0, 0, 0, RESPAWN_ONE_DAY))
            return false;
    }
 
    // MAD props for Kiper for discovering those values - 4 hours of his work.
    GetBGObject(BG_SA_BOAT_ONE)->SetTransportPathRotation(0.0f, 0.0f, 1.0f, 0.0002f);
    GetBGObject(BG_SA_BOAT_TWO)->SetTransportPathRotation(0.0f, 0.0f, 1.0f, 0.00001f);
    SpawnBGObject(BG_SA_BOAT_ONE, RESPAWN_IMMEDIATELY);
    SpawnBGObject(BG_SA_BOAT_TWO, RESPAWN_IMMEDIATELY);
 
    //Cannons and demolishers - NPCs are spawned
    //By capturing GYs.
    for (uint8 i = 0; i < BG_SA_DEMOLISHER_5; i++)
    {
        if (!AddCreature(BG_SA_NpcEntries[i], i,
                         BG_SA_NpcSpawnlocs[i][0], BG_SA_NpcSpawnlocs[i][1],
                         BG_SA_NpcSpawnlocs[i][2], BG_SA_NpcSpawnlocs[i][3], 600))
            return false;
    }
 
    OverrideGunFaction();
    DemolisherStartState(true);
 
    for (uint8 i = BG_SA_GREEN_GATE; i <= BG_SA_TITAN_RELIC; i++)
    {
        SpawnBGObject(i, RESPAWN_IMMEDIATELY);
        if (GameObject* go = GetBGObject(i))
        {
            go->setActive(true);
            go->SetUInt32Value(GAMEOBJECT_FACTION, defF);
            go->SetDestructibleBuildingModifyState(false);
        }
    }
 
    GetBGObject(BG_SA_TITAN_RELIC)->SetUInt32Value(GAMEOBJECT_FACTION, atF);
    GetBGObject(BG_SA_TITAN_RELIC)->Refresh();
 
    TotalTime = 0s;
    ShipsStarted = false;
 
    //Graveyards!
    for (uint8 i = 0; i < BG_SA_MAX_GY; i++)
    {
        GraveyardStruct const* sg = nullptr;
        sg = sGraveyard->GetGraveyard(BG_SA_GYEntries[i]);
 
        if (!sg)
        {
            LOG_ERROR("bg.battleground", "SOTA: Can't find GY entry {}", BG_SA_GYEntries[i]);
            return false;
        }
 
        if (i == BG_SA_BEACH_GY)
        {
            GraveyardStatus[i] = Attackers;
            AddSpiritGuide(i + BG_SA_MAXNPC, sg->x, sg->y, sg->z, BG_SA_GYOrientation[i], Attackers);
        }
        else
        {
            GraveyardStatus[i] = GetOtherTeamId(Attackers);
            if (!AddSpiritGuide(i + BG_SA_MAXNPC, sg->x, sg->y, sg->z, BG_SA_GYOrientation[i], GetOtherTeamId(Attackers)))
                LOG_ERROR("bg.battleground", "SOTA: couldn't spawn GY: {}", i);
        }
    }
 
    //GY capture points
    for (uint8 i = BG_SA_CENTRAL_FLAG; i < BG_SA_PORTAL_DEFFENDER_BLUE; i++)
    {
        AddObject(i, (BG_SA_ObjEntries[i] - (Attackers == TEAM_ALLIANCE ? 1 : 0)),
                  BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1],
                  BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3],
                  0, 0, 0, 0, RESPAWN_ONE_DAY);
        GetBGObject(i)->SetUInt32Value(GAMEOBJECT_FACTION, atF);
    }
 
    for (uint8 i = BG_SA_PORTAL_DEFFENDER_BLUE; i < BG_SA_BOMB; i++)
    {
        AddObject(i, BG_SA_ObjEntries[i],
                  BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1],
                  BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3],
                  0, 0, 0, 0, RESPAWN_ONE_DAY);
        GetBGObject(i)->SetUInt32Value(GAMEOBJECT_FACTION, defF);
    }
 
    UpdateObjectInteractionFlags();
 
    for (uint8 i = BG_SA_BOMB; i < BG_SA_MAXOBJ; i++)
    {
        AddObject(i, BG_SA_ObjEntries[BG_SA_BOMB],
                  BG_SA_ObjSpawnlocs[i][0], BG_SA_ObjSpawnlocs[i][1],
                  BG_SA_ObjSpawnlocs[i][2], BG_SA_ObjSpawnlocs[i][3],
                  0, 0, 0, 0, RESPAWN_ONE_DAY);
        GetBGObject(i)->SetUInt32Value(GAMEOBJECT_FACTION, atF);
    }
 
    //Player may enter BEFORE we set up bG - lets update his worldstates anyway...
    UpdateWorldState(BG_SA_RIGHT_GY_HORDE, GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
    UpdateWorldState(BG_SA_LEFT_GY_HORDE, GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
    UpdateWorldState(BG_SA_CENTER_GY_HORDE, GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_HORDE ? 1 : 0);
 
    UpdateWorldState(BG_SA_RIGHT_GY_ALLIANCE, GraveyardStatus[BG_SA_RIGHT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
    UpdateWorldState(BG_SA_LEFT_GY_ALLIANCE, GraveyardStatus[BG_SA_LEFT_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
    UpdateWorldState(BG_SA_CENTER_GY_ALLIANCE, GraveyardStatus[BG_SA_CENTRAL_CAPTURABLE_GY] == TEAM_ALLIANCE ? 1 : 0);
 
    if (Attackers == TEAM_ALLIANCE)
    {
        UpdateWorldState(BG_SA_ALLY_ATTACKS, 1);
        UpdateWorldState(BG_SA_HORDE_ATTACKS, 0);
 
        UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_ALL, 1);
        UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_ALL, 1);
        UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_HRD, 0);
        UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_HRD, 0);
 
        UpdateWorldState(BG_SA_HORDE_DEFENCE_TOKEN, 1);
        UpdateWorldState(BG_SA_ALLIANCE_DEFENCE_TOKEN, 0);
    }
    else
    {
        UpdateWorldState(BG_SA_HORDE_ATTACKS, 1);
        UpdateWorldState(BG_SA_ALLY_ATTACKS, 0);
 
        UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_ALL, 0);
        UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_ALL, 0);
        UpdateWorldState(BG_SA_RIGHT_ATT_TOKEN_HRD, 1);
        UpdateWorldState(BG_SA_LEFT_ATT_TOKEN_HRD, 1);
 
        UpdateWorldState(BG_SA_HORDE_DEFENCE_TOKEN, 0);
        UpdateWorldState(BG_SA_ALLIANCE_DEFENCE_TOKEN, 1);
    }
 
    UpdateWorldState(BG_SA_PURPLE_GATEWS, 1);
    UpdateWorldState(BG_SA_RED_GATEWS, 1);
    UpdateWorldState(BG_SA_BLUE_GATEWS, 1);
    UpdateWorldState(BG_SA_GREEN_GATEWS, 1);
    UpdateWorldState(BG_SA_YELLOW_GATEWS, 1);
    UpdateWorldState(BG_SA_ANCIENT_GATEWS, 1);
 
    for (int i = BG_SA_BOAT_ONE; i <= BG_SA_BOAT_TWO; i++)
        for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
            SendTransportInit(itr->second);
 
    // set status manually so preparation is cast correctly in 2nd round too
    SetStatus(STATUS_WAIT_JOIN);
 
    TeleportPlayers();
    return true;
}

References Battleground::AddCreature(), Battleground::AddObject(), Battleground::AddSpiritGuide(), Attackers, BG_SA_ALLIANCE_DEFENCE_TOKEN, BG_SA_ALLY_ATTACKS, BG_SA_ANCIENT_GATEWS, BG_SA_BEACH_GY, BG_SA_BLUE_GATEWS, BG_SA_BOAT_ONE, BG_SA_BOAT_ONE_A, BG_SA_BOAT_ONE_H, BG_SA_BOAT_TWO, BG_SA_BOAT_TWO_A, BG_SA_BOAT_TWO_H, BG_SA_BOMB, BG_SA_CENTER_GY_ALLIANCE, BG_SA_CENTER_GY_HORDE, BG_SA_CENTRAL_CAPTURABLE_GY, BG_SA_CENTRAL_FLAG, BG_SA_DEMOLISHER_5, BG_SA_Factions, BG_SA_GATE_OK, BG_SA_GREEN_GATE, BG_SA_GREEN_GATEWS, BG_SA_GYEntries, BG_SA_GYOrientation, BG_SA_HORDE_ATTACKS, BG_SA_HORDE_DEFENCE_TOKEN, BG_SA_LEFT_ATT_TOKEN_ALL, BG_SA_LEFT_ATT_TOKEN_HRD, BG_SA_LEFT_CAPTURABLE_GY, BG_SA_LEFT_GY_ALLIANCE, BG_SA_LEFT_GY_HORDE, BG_SA_MAX_GY, BG_SA_MAXNPC, BG_SA_MAXOBJ, BG_SA_NpcEntries, BG_SA_NpcSpawnlocs, BG_SA_ObjEntries, BG_SA_ObjSpawnlocs, BG_SA_PORTAL_DEFFENDER_BLUE, BG_SA_PURPLE_GATEWS, BG_SA_RED_GATEWS, BG_SA_RIGHT_ATT_TOKEN_ALL, BG_SA_RIGHT_ATT_TOKEN_HRD, BG_SA_RIGHT_CAPTURABLE_GY, BG_SA_RIGHT_GY_ALLIANCE, BG_SA_RIGHT_GY_HORDE, BG_SA_SIGIL_1, BG_SA_TITAN_RELIC, BG_SA_YELLOW_GATEWS, Battleground::DelCreature(), Battleground::DelObject(), DemolisherStartState(), GAMEOBJECT_FACTION, GateStatus, Battleground::GetBGObject(), Battleground::GetOtherTeamId(), Battleground::GetPlayers(), GraveyardStatus, LOG_ERROR, OverrideGunFaction(), GameObject::Refresh(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, SendTransportInit(), SendTransportsRemove(), Battleground::SetStatus(), GameObject::SetTransportPathRotation(), Object::SetUInt32Value(), sGraveyard, ShipsStarted, Battleground::SpawnBGObject(), STATUS_WAIT_JOIN, TEAM_ALLIANCE, TEAM_HORDE, TeleportPlayers(), TotalTime, UpdateObjectInteractionFlags(), Battleground::UpdateWorldState(), GraveyardStruct::x, GraveyardStruct::y, and GraveyardStruct::z.

Referenced by PostUpdateImpl(), and SetupBattleground().

◆ SendTime()

void BattlegroundSA::SendTime ( )

private

Update timer worldstate.

{
    Milliseconds end_of_round = (EndRoundTimer - TotalTime);
    UpdateWorldState(BG_SA_TIMER_MINS, end_of_round / 1min);
    UpdateWorldState(BG_SA_TIMER_SEC_TENS, (end_of_round % 1min) / 10s);
    UpdateWorldState(BG_SA_TIMER_SEC_DECS, ((end_of_round % 1min) % 10s) / 1s);
}

References BG_SA_TIMER_MINS, BG_SA_TIMER_SEC_DECS, BG_SA_TIMER_SEC_TENS, EndRoundTimer, TotalTime, and Battleground::UpdateWorldState().

Referenced by PostUpdateImpl().

◆ SendTransportInit()

void BattlegroundSA::SendTransportInit ( Player * player )

private

Send packet to player for create boats (client part)

{
    if (BgObjects[BG_SA_BOAT_ONE] ||  BgObjects[BG_SA_BOAT_TWO])
    {
        UpdateData transData;
        if (BgObjects[BG_SA_BOAT_ONE])
            GetBGObject(BG_SA_BOAT_ONE)->BuildCreateUpdateBlockForPlayer(&transData, player);
        if (BgObjects[BG_SA_BOAT_TWO])
            GetBGObject(BG_SA_BOAT_TWO)->BuildCreateUpdateBlockForPlayer(&transData, player);
        WorldPacket packet;
        transData.BuildPacket(&packet);
        player->GetSession()->SendPacket(&packet);
    }
}

References BG_SA_BOAT_ONE, BG_SA_BOAT_TWO, Battleground::BgObjects, Object::BuildCreateUpdateBlockForPlayer(), UpdateData::BuildPacket(), Battleground::GetBGObject(), Player::GetSession(), and WorldSession::SendPacket().

Referenced by AddPlayer(), and ResetObjs().

◆ SendTransportsRemove()

void BattlegroundSA::SendTransportsRemove ( Player * player )

private

Send packet to player for destroy boats (client part)

{
    if (BgObjects[BG_SA_BOAT_ONE] ||  BgObjects[BG_SA_BOAT_TWO])
    {
        UpdateData transData;
        if (BgObjects[BG_SA_BOAT_ONE])
            GetBGObject(BG_SA_BOAT_ONE)->BuildOutOfRangeUpdateBlock(&transData);
        if (BgObjects[BG_SA_BOAT_TWO])
            GetBGObject(BG_SA_BOAT_TWO)->BuildOutOfRangeUpdateBlock(&transData);
        WorldPacket packet;
        transData.BuildPacket(&packet);
        player->GetSession()->SendPacket(&packet);
    }
}

References BG_SA_BOAT_ONE, BG_SA_BOAT_TWO, Battleground::BgObjects, Object::BuildOutOfRangeUpdateBlock(), UpdateData::BuildPacket(), Battleground::GetBGObject(), Player::GetSession(), and WorldSession::SendPacket().

Referenced by ResetObjs().

◆ SetupBattleground()

bool BattlegroundSA::SetupBattleground ( )

overridevirtual

Called for ini battleground, after that the first player be entered.

Reimplemented from Battleground.

{
    return ResetObjs();
}

References ResetObjs().

◆ StartingEventCloseDoors()

void BattlegroundSA::StartingEventCloseDoors ( )

overridevirtual

Called when battle start.

Reimplemented from Battleground.

453{

454}

◆ StartingEventOpenDoors()

void BattlegroundSA::StartingEventOpenDoors ( )

overridevirtual

Reimplemented from Battleground.

457{

458}

◆ StartShips()

void BattlegroundSA::StartShips ( )

private

Called for start ship movement.

{
    if (ShipsStarted)
        return;
 
    DoorOpen(BG_SA_BOAT_ONE);
    DoorOpen(BG_SA_BOAT_TWO);
 
    for (int i = BG_SA_BOAT_ONE; i <= BG_SA_BOAT_TWO; i++)
    {
        for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
        {
            UpdateData data;
            WorldPacket pkt;
            GetBGObject(i)->BuildValuesUpdateBlockForPlayer(&data, itr->second);
            data.BuildPacket(&pkt);
            itr->second->GetSession()->SendPacket(&pkt);
        }
    }
    ShipsStarted = true;
}

References BG_SA_BOAT_ONE, BG_SA_BOAT_TWO, UpdateData::BuildPacket(), Object::BuildValuesUpdateBlockForPlayer(), Battleground::DoorOpen(), Battleground::GetBGObject(), Battleground::GetPlayers(), and ShipsStarted.

Referenced by PostUpdateImpl().

◆ TeleportPlayers()

void BattlegroundSA::TeleportPlayers ( )

private

Called between the two round -Teleport all players to good location.

{
    for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
    {
        if (Player* player = itr->second)
        {
            // should remove spirit of redemption
            if (player->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))
                player->RemoveAurasByType(SPELL_AURA_MOD_SHAPESHIFT);
 
            if (!player->IsAlive())
            {
                player->ResurrectPlayer(1.0f);
                player->SpawnCorpseBones();
            }
 
            if (Status == BG_SA_SECOND_WARMUP)
            {
                player->CastSpell(player, SPELL_PREPARATION, true);
                player->GetMotionMaster()->MovementExpired();
            }
 
            player->ResetAllPowers();
            player->CombatStopWithPets(true);
 
            TeleportToEntrancePosition(player);
 
            // xinef: one more time, just to be sure
            if (Status == BG_SA_SECOND_WARMUP)
                player->GetMotionMaster()->Clear(false);
        }
    }
}

References BG_SA_SECOND_WARMUP, Battleground::GetPlayers(), SPELL_AURA_MOD_SHAPESHIFT, SPELL_AURA_SPIRIT_OF_REDEMPTION, SPELL_PREPARATION, Status, and TeleportToEntrancePosition().

Referenced by ResetObjs().

◆ TeleportToEntrancePosition()

void BattlegroundSA::TeleportToEntrancePosition ( Player * player )

private

{
    if (player->GetTeamId() != Attackers)
    {
        player->TeleportTo(607, 1209.7f, -65.16f, 70.1f, 0.0f, 0);
    }
    else
    {
        if (!ShipsStarted)
        {
            player->CastSpell(player, 12438, true);//Without this player falls before boat loads...
            if (urand(0, 1))
                player->TeleportTo(607, 2682.936f, -830.368f, 15.0f, 2.895f, 0);
            else
                player->TeleportTo(607, 2577.003f, 980.261f, 15.0f, 0.807f, 0);
        }
        else
            player->TeleportTo(607, 1600.381f, -106.263f, 8.8745f, 3.78f, 0);
    }
}

References Attackers, Unit::CastSpell(), Player::GetTeamId(), ShipsStarted, Player::TeleportTo(), and urand().

Referenced by AddPlayer(), and TeleportPlayers().

◆ ToggleTimer()

void BattlegroundSA::ToggleTimer ( )

private

Switch on/off timer worldstate.

{
    TimerEnabled = !TimerEnabled;
    UpdateWorldState(BG_SA_ENABLE_TIMER, (TimerEnabled) ? 1 : 0);
}

References BG_SA_ENABLE_TIMER, TimerEnabled, and Battleground::UpdateWorldState().

Referenced by EventPlayerUsedGO(), and PostUpdateImpl().

◆ UpdateDemolisherSpawns()

void BattlegroundSA::UpdateDemolisherSpawns ( )

private

Respawn dead demolisher.

{
    for (uint8 i = BG_SA_DEMOLISHER_1; i <= BG_SA_DEMOLISHER_8; i++)
    {
        if (BgCreatures[i])
        {
            if (Creature* Demolisher = GetBGCreature(i))
            {
                if (Demolisher->isDead())
                {
                    // Demolisher is not in list
                    if (DemoliserRespawnList.find(i) == DemoliserRespawnList.end())
                    {
                        DemoliserRespawnList[i] = GameTime::GetGameTimeMS().count() + 30000;
                    }
                    else
                    {
                        if (DemoliserRespawnList[i] < GameTime::GetGameTimeMS().count())
                        {
                            Demolisher->Relocate(BG_SA_NpcSpawnlocs[i][0], BG_SA_NpcSpawnlocs[i][1],
                                                 BG_SA_NpcSpawnlocs[i][2], BG_SA_NpcSpawnlocs[i][3]);
 
                            Demolisher->SetVisible(true);
                            Demolisher->Respawn();
                            DemoliserRespawnList.erase(i);
                        }
                    }
                }
            }
        }
    }
}

References BG_SA_DEMOLISHER_1, BG_SA_DEMOLISHER_8, BG_SA_NpcSpawnlocs, Battleground::BgCreatures, DemoliserRespawnList, Battleground::GetBGCreature(), and GameTime::GetGameTimeMS().

Referenced by PostUpdateImpl().

◆ UpdateObjectInteractionFlags() [1/2]

void BattlegroundSA::UpdateObjectInteractionFlags ( )

private

{
    for (uint8 i = BG_SA_CENTRAL_FLAG; i <= BG_SA_LEFT_FLAG; ++i)
        UpdateObjectInteractionFlags(i);
    UpdateObjectInteractionFlags(BG_SA_TITAN_RELIC);
}

References BG_SA_CENTRAL_FLAG, BG_SA_LEFT_FLAG, BG_SA_TITAN_RELIC, and UpdateObjectInteractionFlags().

Referenced by DestroyGate(), ResetObjs(), and UpdateObjectInteractionFlags().

◆ UpdateObjectInteractionFlags() [2/2]

void BattlegroundSA::UpdateObjectInteractionFlags ( uint32 objectId )

private

Updates interaction flags of specific objects.

{
    if (GameObject* go = GetBGObject(objectId))
    {
        if (CanInteractWithObject(objectId))
            go->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE | GO_FLAG_INTERACT_COND | GO_FLAG_IN_USE);
        else
            go->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
    }
}

References CanInteractWithObject(), Battleground::GetBGObject(), GO_FLAG_IN_USE, GO_FLAG_INTERACT_COND, and GO_FLAG_NOT_SELECTABLE.

Member Data Documentation

◆ _notEvenAScratch

bool BattlegroundSA::_notEvenAScratch[PVP_TEAMS_COUNT]

private

Referenced by HandleKillUnit(), and Init().

◆ _relicClicked

bool BattlegroundSA::_relicClicked

private

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

◆ Attackers

TeamId BattlegroundSA::Attackers

private

Id of attacker team.

Referenced by AllowDefenseOfTheAncients(), BattlegroundSA(), CaptureGraveyard(), DefendersPortalTeleport(), EventPlayerUsedGO(), FillInitialWorldStates(), HandleKillUnit(), Init(), OverrideGunFaction(), PostUpdateImpl(), ResetObjs(), and TeleportToEntrancePosition().

◆ DemoliserRespawnList

std::map<uint32, uint32> BattlegroundSA::DemoliserRespawnList

private

Referenced by UpdateDemolisherSpawns().

◆ EndRoundTimer

Milliseconds BattlegroundSA::EndRoundTimer

private

Max time of round.

Referenced by BattlegroundSA(), PostUpdateImpl(), and SendTime().

◆ GateStatus

BG_SA_GateState BattlegroundSA::GateStatus[6]

private

Status of each gate (Destroy/Damage/Intact)

Referenced by AllowDefenseOfTheAncients(), BattlegroundSA(), CanInteractWithObject(), DestroyGate(), EventPlayerDamagedGO(), FillInitialWorldStates(), Init(), and ResetObjs().

◆ GraveyardStatus

TeamId BattlegroundSA::GraveyardStatus[BG_SA_MAX_GY]

private

Team witch conntrol each graveyard.

Referenced by BattlegroundSA(), CaptureGraveyard(), FillInitialWorldStates(), GetClosestGraveyard(), and ResetObjs().

◆ InitSecondRound

bool BattlegroundSA::InitSecondRound

private

for know if second round has been init

Referenced by BattlegroundSA(), and PostUpdateImpl().

◆ RoundScores

BG_SA_RoundScore BattlegroundSA::RoundScores[2]

private

Score of each round.

Referenced by BattlegroundSA(), EventPlayerUsedGO(), and PostUpdateImpl().

◆ ShipsStarted

bool BattlegroundSA::ShipsStarted

private

For know if boats has start moving or not yet.

Referenced by BattlegroundSA(), Init(), ResetObjs(), StartShips(), and TeleportToEntrancePosition().

◆ SignaledRoundTwo

bool BattlegroundSA::SignaledRoundTwo

private

for know if warning about second round start has been sent

Referenced by BattlegroundSA(), and PostUpdateImpl().

◆ SignaledRoundTwoHalfMin

bool BattlegroundSA::SignaledRoundTwoHalfMin

private

for know if warning about second round start has been sent

Referenced by BattlegroundSA(), and PostUpdateImpl().

◆ Status

BG_SA_Status BattlegroundSA::Status

private

Statu of battle (Start or not, and what round)

Referenced by BattlegroundSA(), EventPlayerUsedGO(), Init(), PostUpdateImpl(), and TeleportPlayers().

◆ TimerEnabled

bool BattlegroundSA::TimerEnabled

private

used for know we are in timer phase or not (used for worldstate update)

Referenced by BattlegroundSA(), FillInitialWorldStates(), and ToggleTimer().

◆ TotalTime

Milliseconds BattlegroundSA::TotalTime

private

Totale elapsed time of current round.

Referenced by BattlegroundSA(), EventPlayerUsedGO(), Init(), PostUpdateImpl(), ResetObjs(), and SendTime().

◆ UpdateWaitTimer

uint32 BattlegroundSA::UpdateWaitTimer

private

5secs before starting the 1min countdown for second round

Referenced by BattlegroundSA(), and PostUpdateImpl().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BattlegroundSA()

◆ ~BattlegroundSA()

Member Function Documentation

◆ AddPlayer()

◆ AllowDefenseOfTheAncients()

◆ CanInteractWithObject()

◆ CaptureGraveyard()

◆ DefendersPortalTeleport()

◆ DemolisherStartState()

◆ DestroyGate()

◆ EndBattleground()

◆ EventPlayerClickedOnFlag()

◆ EventPlayerDamagedGO()

◆ EventPlayerUsedGO()

◆ FillInitialWorldStates()

◆ GetClosestGraveyard()

◆ GetGateIDFromEntry()

◆ GetWorldStateFromGateID()

◆ HandleAreaTrigger()

◆ HandleKillUnit()

◆ Init()

◆ notEvenAScratch()

◆ OverrideGunFaction()

◆ PostUpdateImpl()

◆ RemovePlayer()

◆ ResetObjs()

◆ SendTime()

◆ SendTransportInit()

◆ SendTransportsRemove()

◆ SetupBattleground()

◆ StartingEventCloseDoors()

◆ StartingEventOpenDoors()

◆ StartShips()

◆ TeleportPlayers()

◆ TeleportToEntrancePosition()

◆ ToggleTimer()

◆ UpdateDemolisherSpawns()

◆ UpdateObjectInteractionFlags() [1/2]

◆ UpdateObjectInteractionFlags() [2/2]

Member Data Documentation

◆ _notEvenAScratch

◆ _relicClicked

◆ Attackers

◆ DemoliserRespawnList

◆ EndRoundTimer

◆ GateStatus

◆ GraveyardStatus

◆ InitSecondRound

◆ RoundScores

◆ ShipsStarted

◆ SignaledRoundTwo

◆ SignaledRoundTwoHalfMin

◆ Status

◆ TimerEnabled

◆ TotalTime

◆ UpdateWaitTimer