#include <BattlegroundWS.h>

Public Member Functions
	BattlegroundWS ()

	~BattlegroundWS ()

void	AddPlayer (Player *player) override

void	StartingEventCloseDoors () override

void	StartingEventOpenDoors () override

ObjectGuid	GetFlagPickerGUID (int32 team) const override

void	SetAllianceFlagPicker (ObjectGuid guid)

void	SetHordeFlagPicker (ObjectGuid guid)

bool	IsAllianceFlagPickedup () const

bool	IsHordeFlagPickedup () const

void	RespawnFlag (uint32 Team, bool captured)

void	RespawnFlagAfterDrop (uint32 Team)

uint8	GetFlagState (uint32 team)

void	EventPlayerDroppedFlag (Player *player) override

void	EventPlayerClickedOnFlag (Player player, GameObject target_obj) override

void	EventPlayerCapturedFlag (Player *player)

void	RemovePlayer (Player *player, ObjectGuid guid, uint32 team) override

void	HandleAreaTrigger (Player *player, uint32 trigger, bool entered) override

void	HandleKillPlayer (Player player, Player killer) override

bool	SetupBattleground () override

void	Reset () override

void	EndBattleground (uint32 winner) override

WorldSafeLocsEntry const *	GetClosestGraveYard (Player *player) override

void	UpdateFlagState (uint32 team, uint32 value)

void	SetLastFlagCapture (uint32 team)

void	UpdateTeamScore (uint32 team)

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

void	SetDroppedFlagGUID (ObjectGuid guid, int32 team=-1) override

ObjectGuid	GetDroppedFlagGUID (uint32 TeamID)

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

void	AddPoint (uint32 TeamID, uint32 Points=1)

void	SetTeamPoint (uint32 TeamID, uint32 Points=0)

void	RemovePoint (uint32 TeamID, uint32 Points=1)

uint32	GetPrematureWinner () override

bool	CheckAchievementCriteriaMeet (uint32 criteriaId, Player const source, Unit const target=nullptr, uint32 miscvalue1=0) override

Public Member Functions inherited from Battleground
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual void	ResetBGSubclass ()

virtual void	DestroyGate (Player , GameObject )

virtual bool	IsAllNodesControlledByTeam (uint32) const

void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)

std::string const &	GetName () const

uint64	GetQueueId () const

BattlegroundTypeId	GetTypeID (bool GetRandom=false) const

BattlegroundBracketId	GetBracketId () const

uint32	GetInstanceID () const

BattlegroundStatus	GetStatus () const

uint32	GetClientInstanceID () const

uint32	GetElapsedTime () const

uint32	GetRemainingTime () const

uint32	GetLastResurrectTime () const

uint32	GetMaxPlayers () const

uint32	GetMinPlayers () const

uint32	GetMinLevel () const

uint32	GetMaxLevel () const

uint32	GetMaxPlayersPerTeam () const

uint32	GetMinPlayersPerTeam () const

int32	GetStartDelayTime () const

uint8	GetArenaType () const

BattlegroundTeamId	GetWinner () const

uint32	GetScriptId () const

uint32	GetBonusHonorFromKill (uint32 kills) const

bool	IsRandom () const

void	SetQueueId (uint64 queueId)

void	SetName (std::string const &name)

void	SetTypeID (BattlegroundTypeId TypeID)

void	SetRandomTypeID (BattlegroundTypeId TypeID)

void	SetBracket (PvPDifficultyEntry const *bracketEntry)

void	SetInstanceID (uint32 InstanceID)

void	SetStatus (BattlegroundStatus Status)

void	SetClientInstanceID (uint32 InstanceID)

void	SetElapsedTime (uint32 Time)

void	SetRemainingTime (uint32 Time)

void	SetLastResurrectTime (uint32 Time)

void	SetMaxPlayers (uint32 MaxPlayers)

void	SetMinPlayers (uint32 MinPlayers)

void	SetLevelRange (uint32 min, uint32 max)

void	SetRated (bool state)

void	SetArenaType (uint8 type)

void	SetArenaorBGType (bool _isArena)

void	SetWinner (BattlegroundTeamId winnerTeamId)

void	SetScriptId (uint32 scriptId)

void	ModifyStartDelayTime (int diff)

void	SetStartDelayTime (int Time)

void	SetMaxPlayersPerTeam (uint32 MaxPlayers)

void	SetMinPlayersPerTeam (uint32 MinPlayers)

void	AddToBGFreeSlotQueue ()

void	RemoveFromBGFreeSlotQueue ()

void	DecreaseInvitedCount (uint32 team)

void	IncreaseInvitedCount (uint32 team)

void	SetRandom (bool isRandom)

uint32	GetInvitedCount (uint32 team) const

bool	HasFreeSlots () const

uint32	GetFreeSlotsForTeam (uint32 Team) const

bool	isArena () const

bool	isBattleground () const

bool	isRated () const

BattlegroundPlayerMap const &	GetPlayers () const

uint32	GetPlayersSize () const

uint32	GetPlayerScoresSize () const

uint32	GetReviveQueueSize () const

void	AddPlayerToResurrectQueue (ObjectGuid npc_guid, ObjectGuid player_guid)

void	RemovePlayerFromResurrectQueue (ObjectGuid player_guid)

void	RelocateDeadPlayers (ObjectGuid guideGuid)
	Relocate all players in ReviveQueue to the closest graveyard. More...

void	StartBattleground ()

GameObject *	GetBGObject (uint32 type, bool logError=true)

Creature *	GetBGCreature (uint32 type, bool logError=true)

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 (uint32 TeamID, WorldPacket const packet, Player sender=NULL, bool self=true) const

void	SendPacketToAll (WorldPacket const *packet) const

void	SendChatMessage (Creature source, uint8 textId, WorldObject target=NULL)

template<class Do >
void	BroadcastWorker (Do &_do)

void	PlaySoundToTeam (uint32 SoundID, uint32 TeamID)

void	PlaySoundToAll (uint32 SoundID)

void	CastSpellOnTeam (uint32 SpellID, uint32 TeamID)

void	RemoveAuraOnTeam (uint32 SpellID, uint32 TeamID)

void	RewardHonorToTeam (uint32 Honor, uint32 TeamID)

void	RewardReputationToTeam (uint32 faction_id, uint32 Reputation, uint32 TeamID)

void	UpdateWorldState (uint32 variable, uint32 value, bool hidden=false)

void	BlockMovement (Player *player)

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

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 (uint32 TeamID) const

void	SetBgRaid (uint32 TeamID, Group *bg_raid)

void	BuildPvPLogDataPacket (WorldPackets::Battleground::PVPLogData &pvpLogData)

uint32	GetPlayersCountByTeam (uint32 Team) const

uint32	GetAlivePlayersCountByTeam (uint32 Team) const

void	UpdatePlayersCountByTeam (uint32 Team, bool remove)

virtual void	CheckWinConditions ()

void	SetArenaTeamIdForTeam (uint32 Team, uint32 ArenaTeamId)

uint32	GetArenaTeamIdForTeam (uint32 Team) const

uint32	GetArenaTeamIdByIndex (uint32 index) const

void	SetArenaMatchmakerRating (uint32 Team, uint32 MMR)

uint32	GetArenaMatchmakerRating (uint32 Team) const

virtual void	HandleKillUnit (Creature , Player )

void	EventPlayerLoggedIn (Player *player)

void	EventPlayerLoggedOut (Player *player)

virtual void	ProcessEvent (WorldObject , uint32, WorldObject =NULL)

virtual void	DoAction (uint32, ObjectGuid)

virtual void	HandlePlayerResurrect (Player *)

void	AddOrSetPlayerToCorrectBgGroup (Player *player, uint32 team)

virtual void	RemovePlayerAtLeave (ObjectGuid guid, bool Transport, bool SendPacket)

void	HandleTriggerBuff (ObjectGuid go_guid)

void	SetHoliday (bool is_holiday)

void	SpawnBGObject (uint32 type, uint32 respawntime)

virtual 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)

bool	AddObject (uint32 type, uint32 entry, Position const &pos, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime=0, GOState goState=GO_STATE_READY)

virtual Creature *	AddCreature (uint32 entry, uint32 type, float x, float y, float z, float o, TeamId teamId=TEAM_NEUTRAL, uint32 respawntime=0, Transport *transport=NULL)

Creature *	AddCreature (uint32 entry, uint32 type, Position const &pos, TeamId teamId=TEAM_NEUTRAL, uint32 respawntime=0, Transport *transport=NULL)

bool	DelCreature (uint32 type)

bool	DelObject (uint32 type)

virtual bool	AddSpiritGuide (uint32 type, float x, float y, float z, float o, TeamId teamId=TEAM_NEUTRAL)

bool	AddSpiritGuide (uint32 type, Position const &pos, TeamId teamId=TEAM_NEUTRAL)

int32	GetObjectType (ObjectGuid guid)

void	DoorOpen (uint32 type)

void	DoorClose (uint32 type)

virtual bool	HandlePlayerUnderMap (Player *)

uint32	GetPlayerTeam (ObjectGuid guid) const

uint32	GetOtherTeam (uint32 teamId) const

bool	IsPlayerInBattleground (ObjectGuid guid) const

bool	ToBeDeleted () const

void	SetDeleteThis ()

void	RewardXPAtKill (Player killer, Player victim)

bool	CanAwardArenaPoints () const

virtual void	HandleQuestComplete (uint32, Player *)

virtual bool	CanActivateGO (int32, uint32) const

virtual bool	IsSpellAllowed (uint32, Player const *) const

uint32	GetTeamScore (uint32 TeamID) const

uint8	GetUniqueBracketId () const

Protected Member Functions
void	PostUpdateImpl (uint32 diff) override
	Post-update hook. More...

void	GetPlayerPositionData (std::vector< WorldPackets::Battleground::BattlegroundPlayerPosition > *positions) const override

Protected Member Functions inherited from Battleground
void	EndNow ()

void	PlayerAddedToBGCheckIfBGIsRunning (Player *player)

Player *	_GetPlayer (ObjectGuid guid, bool offlineRemove, const char *context) const

Player *	_GetPlayer (BattlegroundPlayerMap::iterator itr, const char *context)

Player *	_GetPlayer (BattlegroundPlayerMap::const_iterator itr, const char *context) const

Player *	_GetPlayerForTeam (uint32 teamId, BattlegroundPlayerMap::const_iterator itr, const char *context) const

virtual bool	PreUpdateImpl (uint32)
	Pre-update hook. More...

void	_ProcessOfflineQueue ()

void	_ProcessResurrect (uint32 diff)

void	_ProcessProgress (uint32 diff)

void	_ProcessLeave (uint32 diff)

void	_ProcessJoin (uint32 diff)

void	_CheckSafePositions (uint32 diff)

void	_ProcessPlayerPositionBroadcast (uint32 diff)

Private Attributes
ObjectGuid	m_FlagKeepers [2]

ObjectGuid	m_DroppedFlagGUID [2]

uint8	_flagState [2]

int32	_flagsTimer [2]

int32	_flagsDropTimer [2]

uint32	_lastFlagCaptureTeam

uint32	m_ReputationCapture

uint32	m_HonorWinKills

uint32	m_HonorEndKills

int32	_flagSpellForceTimer

bool	_bothFlagsKept

uint8	_flagDebuffState

uint8	_minutesElapsed

Additional Inherited Members
Public Types inherited from Battleground
typedef std::map< ObjectGuid, BattlegroundPlayer >	BattlegroundPlayerMap

typedef std::map< ObjectGuid, BattlegroundScore * >	BattlegroundScoreMap

Static Public Member Functions inherited from Battleground
static TeamId	GetTeamIndexByTeamId (uint32 Team)

Public Attributes inherited from Battleground
GuidVector	BgObjects

GuidVector	BgCreatures

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 [BG_TEAMS_COUNT]

ArenaTeamScore	_arenaTeamScores [BG_TEAMS_COUNT]

Constructor & Destructor Documentation

BattlegroundWS::BattlegroundWS ( )

 {
  BgObjects.resize(BG_WS_OBJECT_MAX);
  BgCreatures.resize(BG_CREATURES_MAX_WS);
 
  StartMessageIds[BG_STARTING_EVENT_FIRST] = LANG_BG_WS_START_TWO_MINUTES;
  StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_BG_WS_START_ONE_MINUTE;
  StartMessageIds[BG_STARTING_EVENT_THIRD] = LANG_BG_WS_START_HALF_MINUTE;
  StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_BG_WS_HAS_BEGUN;
  _flagSpellForceTimer = 0;
  _bothFlagsKept = false;
  _flagDebuffState = 0;
  m_FlagKeepers[TEAM_ALLIANCE].Clear();
  m_FlagKeepers[TEAM_HORDE].Clear();
  m_DroppedFlagGUID[TEAM_ALLIANCE].Clear();
  m_DroppedFlagGUID[TEAM_HORDE].Clear();
  _flagState[TEAM_ALLIANCE] = BG_WS_FLAG_STATE_ON_BASE;
  _flagState[TEAM_HORDE] = BG_WS_FLAG_STATE_ON_BASE;
  _flagsTimer[TEAM_ALLIANCE] = 0;
  _flagsTimer[TEAM_HORDE] = 0;
  _flagsDropTimer[TEAM_ALLIANCE] = 0;
  _flagsDropTimer[TEAM_HORDE] = 0;
  _lastFlagCaptureTeam = 0;
  m_ReputationCapture = 0;
  m_HonorWinKills = 0;
  m_HonorEndKills = 0;
  _minutesElapsed = 0;
 }

Here is the call graph for this function:

BattlegroundWS::~BattlegroundWS ( )

71 { }

Member Function Documentation

void BattlegroundWS::AddPlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

 {
  Battleground::AddPlayer(player);
  PlayerScores[player->GetGUID()] = new BattlegroundWGScore(player->GetGUID(), player->GetBGTeam());
 }

Here is the call graph for this function:

void BattlegroundWS::AddPoint	(	uint32	TeamID,
		uint32	Points = `1`
	)

inline

240 { m_TeamScores[GetTeamIndexByTeamId(TeamID)] += Points; }

Battleground::m_TeamScores

int32 m_TeamScores[BG_TEAMS_COUNT]

Definition: Battleground.h:562

Points

Definition: ScriptedEscortAI.cpp:31

Battleground::GetTeamIndexByTeamId

static TeamId GetTeamIndexByTeamId(uint32 Team)

Definition: Battleground.h:399

Here is the call graph for this function:

Here is the caller graph for this function:

bool BattlegroundWS::CheckAchievementCriteriaMeet	(	uint32	criteriaId,
		Player const *	source,
		Unit const *	target = `nullptr`,
		uint32	miscvalue1 = `0`
	)

overridevirtual

Reimplemented from Battleground.

 {
  switch (criteriaId)
  {
  case BG_CRITERIA_CHECK_SAVE_THE_DAY:
  if (target)
  if (Player const* playerTarget = target->ToPlayer())
  return GetFlagState(playerTarget->GetTeam()) == BG_WS_FLAG_STATE_ON_BASE;
  return false;
  }
 
  return Battleground::CheckAchievementCriteriaMeet(criteriaId, player, target, miscValue);
 }

Here is the call graph for this function:

void BattlegroundWS::EndBattleground ( uint32 winner )

overridevirtual

Reimplemented from Battleground.

 {
  // Win reward
  if (winner == ALLIANCE)
  RewardHonorToTeam(GetBonusHonorFromKill(m_HonorWinKills), ALLIANCE);
  if (winner == HORDE)
  RewardHonorToTeam(GetBonusHonorFromKill(m_HonorWinKills), HORDE);
  // Complete map_end rewards (even if no team wins)
  RewardHonorToTeam(GetBonusHonorFromKill(m_HonorEndKills), ALLIANCE);
  RewardHonorToTeam(GetBonusHonorFromKill(m_HonorEndKills), HORDE);
 
  Battleground::EndBattleground(winner);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundWS::EventPlayerCapturedFlag ( Player * player )

 {
  if (GetStatus() != STATUS_IN_PROGRESS)
  return;
 
  uint32 winner = 0;
 
  player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
  if (player->GetTeam() == ALLIANCE)
  {
  if (!IsHordeFlagPickedup())
  return;
  SetHordeFlagPicker(ObjectGuid::Empty); // must be before aura remove to prevent 2 events (drop+capture) at the same time
  // horde flag in base (but not respawned yet)
  _flagState[TEAM_HORDE] = BG_WS_FLAG_STATE_WAIT_RESPAWN;
  // Drop Horde Flag from Player
  player->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);
  if (_flagDebuffState == 1)
  player->RemoveAurasDueToSpell(WS_SPELL_FOCUSED_ASSAULT);
  else if (_flagDebuffState == 2)
  player->RemoveAurasDueToSpell(WS_SPELL_BRUTAL_ASSAULT);
 
  if (GetTeamScore(TEAM_ALLIANCE) < BG_WS_MAX_TEAM_SCORE)
  AddPoint(ALLIANCE, 1);
  PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_ALLIANCE);
  RewardReputationToTeam(890, m_ReputationCapture, ALLIANCE);
  }
  else
  {
  if (!IsAllianceFlagPickedup())
  return;
  SetAllianceFlagPicker(ObjectGuid::Empty); // must be before aura remove to prevent 2 events (drop+capture) at the same time
  // alliance flag in base (but not respawned yet)
  _flagState[TEAM_ALLIANCE] = BG_WS_FLAG_STATE_WAIT_RESPAWN;
  // Drop Alliance Flag from Player
  player->RemoveAurasDueToSpell(BG_WS_SPELL_SILVERWING_FLAG);
  if (_flagDebuffState == 1)
  player->RemoveAurasDueToSpell(WS_SPELL_FOCUSED_ASSAULT);
  else if (_flagDebuffState == 2)
  player->RemoveAurasDueToSpell(WS_SPELL_BRUTAL_ASSAULT);
 
  if (GetTeamScore(TEAM_HORDE) < BG_WS_MAX_TEAM_SCORE)
  AddPoint(HORDE, 1);
  PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_HORDE);
  RewardReputationToTeam(889, m_ReputationCapture, HORDE);
  }
  //for flag capture is reward 2 honorable kills
  RewardHonorToTeam(GetBonusHonorFromKill(2), player->GetTeam());
 
  SpawnBGObject(BG_WS_OBJECT_H_FLAG, BG_WS_FLAG_RESPAWN_TIME);
  SpawnBGObject(BG_WS_OBJECT_A_FLAG, BG_WS_FLAG_RESPAWN_TIME);
 
  if (player->GetTeam() == ALLIANCE)
  SendMessageToAll(LANG_BG_WS_CAPTURED_HF, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
  else
  SendMessageToAll(LANG_BG_WS_CAPTURED_AF, CHAT_MSG_BG_SYSTEM_HORDE, player);
 
  UpdateFlagState(player->GetTeam(), 1); // flag state none
  UpdateTeamScore(player->GetTeamId());
  // only flag capture should be updated
  UpdatePlayerScore(player, SCORE_FLAG_CAPTURES, 1); // +1 flag captures
 
  // update last flag capture to be used if teamscore is equal
  SetLastFlagCapture(player->GetTeam());
 
  if (GetTeamScore(TEAM_ALLIANCE) == BG_WS_MAX_TEAM_SCORE)
  winner = ALLIANCE;
 
  if (GetTeamScore(TEAM_HORDE) == BG_WS_MAX_TEAM_SCORE)
  winner = HORDE;
 
  if (winner)
  {
  UpdateWorldState(BG_WS_FLAG_UNK_ALLIANCE, 0);
  UpdateWorldState(BG_WS_FLAG_UNK_HORDE, 0);
  UpdateWorldState(BG_WS_FLAG_STATE_ALLIANCE, 1);
  UpdateWorldState(BG_WS_FLAG_STATE_HORDE, 1);
  UpdateWorldState(BG_WS_STATE_TIMER_ACTIVE, 0);
 
  RewardHonorToTeam(BG_WSG_Honor[m_HonorMode][BG_WSG_WIN], winner);
  EndBattleground(winner);
  }
  else
  {
  _flagsTimer[GetTeamIndexByTeamId(player->GetTeam()) ? 0 : 1] = BG_WS_FLAG_RESPAWN_TIME;
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
  if (GetStatus() != STATUS_IN_PROGRESS)
  return;
 
  int32 message_id = 0;
  ChatMsg type = CHAT_MSG_BG_SYSTEM_NEUTRAL;
 
  //alliance flag picked up from base
  if (player->GetTeam() == HORDE && GetFlagState(ALLIANCE) == BG_WS_FLAG_STATE_ON_BASE
  && BgObjects[BG_WS_OBJECT_A_FLAG] == target_obj->GetGUID())
  {
  message_id = LANG_BG_WS_PICKEDUP_AF;
  type = CHAT_MSG_BG_SYSTEM_HORDE;
  PlaySoundToAll(BG_WS_SOUND_ALLIANCE_FLAG_PICKED_UP);
  SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_ONE_DAY);
  SetAllianceFlagPicker(player->GetGUID());
  _flagState[TEAM_ALLIANCE] = BG_WS_FLAG_STATE_ON_PLAYER;
  //update world state to show correct flag carrier
  UpdateFlagState(HORDE, BG_WS_FLAG_STATE_ON_PLAYER);
  UpdateWorldState(BG_WS_FLAG_UNK_ALLIANCE, 1);
  player->CastSpell(player, BG_WS_SPELL_SILVERWING_FLAG, true);
  player->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, BG_WS_SPELL_SILVERWING_FLAG_PICKED);
  if (_flagState[1] == BG_WS_FLAG_STATE_ON_PLAYER)
  _bothFlagsKept = true;
  }
 
  //horde flag picked up from base
  if (player->GetTeam() == ALLIANCE && GetFlagState(HORDE) == BG_WS_FLAG_STATE_ON_BASE
  && BgObjects[BG_WS_OBJECT_H_FLAG] == target_obj->GetGUID())
  {
  message_id = LANG_BG_WS_PICKEDUP_HF;
  type = CHAT_MSG_BG_SYSTEM_ALLIANCE;
  PlaySoundToAll(BG_WS_SOUND_HORDE_FLAG_PICKED_UP);
  SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_ONE_DAY);
  SetHordeFlagPicker(player->GetGUID());
  _flagState[TEAM_HORDE] = BG_WS_FLAG_STATE_ON_PLAYER;
  //update world state to show correct flag carrier
  UpdateFlagState(ALLIANCE, BG_WS_FLAG_STATE_ON_PLAYER);
  UpdateWorldState(BG_WS_FLAG_UNK_HORDE, 1);
  player->CastSpell(player, BG_WS_SPELL_WARSONG_FLAG, true);
  player->StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, BG_WS_SPELL_WARSONG_FLAG_PICKED);
  if (_flagState[0] == BG_WS_FLAG_STATE_ON_PLAYER)
  _bothFlagsKept = true;
  }
 
  //Alliance flag on ground(not in base) (returned or picked up again from ground!)
  if (GetFlagState(ALLIANCE) == BG_WS_FLAG_STATE_ON_GROUND && player->IsWithinDistInMap(target_obj, 10)
  && target_obj->GetGOInfo()->entry == BG_OBJECT_A_FLAG_GROUND_WS_ENTRY)
  {
  if (player->GetTeam() == ALLIANCE)
  {
  message_id = LANG_BG_WS_RETURNED_AF;
  type = CHAT_MSG_BG_SYSTEM_ALLIANCE;
  UpdateFlagState(HORDE, BG_WS_FLAG_STATE_WAIT_RESPAWN);
  RespawnFlag(ALLIANCE, false);
  SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_IMMEDIATELY);
  PlaySoundToAll(BG_WS_SOUND_FLAG_RETURNED);
  UpdatePlayerScore(player, SCORE_FLAG_RETURNS, 1);
  _bothFlagsKept = false;
  }
  else
  {
  message_id = LANG_BG_WS_PICKEDUP_AF;
  type = CHAT_MSG_BG_SYSTEM_HORDE;
  PlaySoundToAll(BG_WS_SOUND_ALLIANCE_FLAG_PICKED_UP);
  SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_ONE_DAY);
  SetAllianceFlagPicker(player->GetGUID());
  player->CastSpell(player, BG_WS_SPELL_SILVERWING_FLAG, true);
  _flagState[TEAM_ALLIANCE] = BG_WS_FLAG_STATE_ON_PLAYER;
  UpdateFlagState(HORDE, BG_WS_FLAG_STATE_ON_PLAYER);
  if (_flagDebuffState == 1)
  player->CastSpell(player, WS_SPELL_FOCUSED_ASSAULT, true);
  else if (_flagDebuffState == 2)
  player->CastSpell(player, WS_SPELL_BRUTAL_ASSAULT, true);
  UpdateWorldState(BG_WS_FLAG_UNK_ALLIANCE, 1);
  }
  //called in HandleGameObjectUseOpcode:
  //target_obj->Delete();
  }
 
  //Horde flag on ground(not in base) (returned or picked up again)
  if (GetFlagState(HORDE) == BG_WS_FLAG_STATE_ON_GROUND && player->IsWithinDistInMap(target_obj, 10)
  && target_obj->GetGOInfo()->entry == BG_OBJECT_H_FLAG_GROUND_WS_ENTRY)
  {
  if (player->GetTeam() == HORDE)
  {
  message_id = LANG_BG_WS_RETURNED_HF;
  type = CHAT_MSG_BG_SYSTEM_HORDE;
  UpdateFlagState(ALLIANCE, BG_WS_FLAG_STATE_WAIT_RESPAWN);
  RespawnFlag(HORDE, false);
  SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_IMMEDIATELY);
  PlaySoundToAll(BG_WS_SOUND_FLAG_RETURNED);
  UpdatePlayerScore(player, SCORE_FLAG_RETURNS, 1);
  _bothFlagsKept = false;
  }
  else
  {
  message_id = LANG_BG_WS_PICKEDUP_HF;
  type = CHAT_MSG_BG_SYSTEM_ALLIANCE;
  PlaySoundToAll(BG_WS_SOUND_HORDE_FLAG_PICKED_UP);
  SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_ONE_DAY);
  SetHordeFlagPicker(player->GetGUID());
  player->CastSpell(player, BG_WS_SPELL_WARSONG_FLAG, true);
  _flagState[TEAM_HORDE] = BG_WS_FLAG_STATE_ON_PLAYER;
  UpdateFlagState(ALLIANCE, BG_WS_FLAG_STATE_ON_PLAYER);
  if (_flagDebuffState == 1)
  player->CastSpell(player, WS_SPELL_FOCUSED_ASSAULT, true);
  else if (_flagDebuffState == 2)
  player->CastSpell(player, WS_SPELL_BRUTAL_ASSAULT, true);
  UpdateWorldState(BG_WS_FLAG_UNK_HORDE, 1);
  }
  //called in HandleGameObjectUseOpcode:
  //target_obj->Delete();
  }
 
  if (!message_id)
  return;
 
  SendMessageToAll(message_id, type, player);
  player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 }

Here is the call graph for this function:

void BattlegroundWS::EventPlayerDroppedFlag ( Player * player )

overridevirtual

Reimplemented from Battleground.

 {
  if (GetStatus() != STATUS_IN_PROGRESS)
  {
  // if not running, do not cast things at the dropper player (prevent spawning the "dropped" flag), neither send unnecessary messages
  // just take off the aura
  if (player->GetTeam() == ALLIANCE)
  {
  if (!IsHordeFlagPickedup())
  return;
 
  if (GetFlagPickerGUID(TEAM_HORDE) == player->GetGUID())
  {
  SetHordeFlagPicker(ObjectGuid::Empty);
  player->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);
  }
  }
  else
  {
  if (!IsAllianceFlagPickedup())
  return;
 
  if (GetFlagPickerGUID(TEAM_ALLIANCE) == player->GetGUID())
  {
  SetAllianceFlagPicker(ObjectGuid::Empty);
  player->RemoveAurasDueToSpell(BG_WS_SPELL_SILVERWING_FLAG);
  }
  }
  return;
  }
 
  bool set = false;
 
  if (player->GetTeam() == ALLIANCE)
  {
  if (!IsHordeFlagPickedup())
  return;
  if (GetFlagPickerGUID(TEAM_HORDE) == player->GetGUID())
  {
  SetHordeFlagPicker(ObjectGuid::Empty);
  player->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);
  if (_flagDebuffState == 1)
  player->RemoveAurasDueToSpell(WS_SPELL_FOCUSED_ASSAULT);
  else if (_flagDebuffState == 2)
  player->RemoveAurasDueToSpell(WS_SPELL_BRUTAL_ASSAULT);
  _flagState[TEAM_HORDE] = BG_WS_FLAG_STATE_ON_GROUND;
  player->CastSpell(player, BG_WS_SPELL_WARSONG_FLAG_DROPPED, true);
  set = true;
  }
  }
  else
  {
  if (!IsAllianceFlagPickedup())
  return;
  if (GetFlagPickerGUID(TEAM_ALLIANCE) == player->GetGUID())
  {
  SetAllianceFlagPicker(ObjectGuid::Empty);
  player->RemoveAurasDueToSpell(BG_WS_SPELL_SILVERWING_FLAG);
  if (_flagDebuffState == 1)
  player->RemoveAurasDueToSpell(WS_SPELL_FOCUSED_ASSAULT);
  else if (_flagDebuffState == 2)
  player->RemoveAurasDueToSpell(WS_SPELL_BRUTAL_ASSAULT);
  _flagState[TEAM_ALLIANCE] = BG_WS_FLAG_STATE_ON_GROUND;
  player->CastSpell(player, BG_WS_SPELL_SILVERWING_FLAG_DROPPED, true);
  set = true;
  }
  }
 
  if (set)
  {
  player->CastSpell(player, SPELL_RECENTLY_DROPPED_FLAG, true);
  UpdateFlagState(player->GetTeam(), 1);
 
  if (player->GetTeam() == ALLIANCE)
  {
  SendMessageToAll(LANG_BG_WS_DROPPED_HF, CHAT_MSG_BG_SYSTEM_HORDE, player);
  UpdateWorldState(BG_WS_FLAG_UNK_HORDE, uint32(-1));
  }
  else
  {
  SendMessageToAll(LANG_BG_WS_DROPPED_AF, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
  UpdateWorldState(BG_WS_FLAG_UNK_ALLIANCE, uint32(-1));
  }
 
  _flagsDropTimer[GetTeamIndexByTeamId(player->GetTeam()) ? 0 : 1] = BG_WS_FLAG_DROP_TIME;
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
     packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_CAPTURES_ALLIANCE), int32(GetTeamScore(TEAM_ALLIANCE)));
     packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_CAPTURES_HORDE), int32(GetTeamScore(TEAM_HORDE)));
 
     if (_flagState[TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_GROUND)
         packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_ALLIANCE), -1);
     else if (_flagState[TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_PLAYER)
         packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_ALLIANCE), 1);
     else
         packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_ALLIANCE), 0);
 
     if (_flagState[TEAM_HORDE] == BG_WS_FLAG_STATE_ON_GROUND)
         packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_HORDE), -1);
     else if (_flagState[TEAM_HORDE] == BG_WS_FLAG_STATE_ON_PLAYER)
         packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_HORDE), 1);
     else
         packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_HORDE), 0);
 
     packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_CAPTURES_MAX), int32(BG_WS_MAX_TEAM_SCORE));
 
     if (GetStatus() == STATUS_IN_PROGRESS)
     {
         packet.Worldstates.emplace_back(uint32(BG_WS_STATE_TIMER_ACTIVE), 1);
         packet.Worldstates.emplace_back(uint32(BG_WS_STATE_TIMER), int32(25 - _minutesElapsed));
     }
     else
         packet.Worldstates.emplace_back(uint32(BG_WS_STATE_TIMER_ACTIVE), 0);
 
     if (_flagState[TEAM_HORDE] == BG_WS_FLAG_STATE_ON_PLAYER)
         packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_STATE_HORDE), 2);
     else
         packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_STATE_HORDE), 1);
 
     if (_flagState[TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_PLAYER)
         packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_STATE_ALLIANCE), 2);
     else
         packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_STATE_ALLIANCE), 1);
 }

Here is the call graph for this function:

WorldSafeLocsEntry const * BattlegroundWS::GetClosestGraveYard ( Player * player )

overridevirtual

Reimplemented from Battleground.

 {
     //if status in progress, it returns main graveyards with spiritguides
     //else it will return the graveyard in the flagroom - this is especially good
     //if a player dies in preparation phase - then the player can't cheat
     //and teleport to the graveyard outside the flagroom
     //and start running around, while the doors are still closed
     if (player->GetTeam() == ALLIANCE)
     {
         if (GetStatus() == STATUS_IN_PROGRESS)
             return sWorldSafeLocsStore.LookupEntry(WS_GRAVEYARD_MAIN_ALLIANCE);
         else
             return sWorldSafeLocsStore.LookupEntry(WS_GRAVEYARD_FLAGROOM_ALLIANCE);
     }
     else
     {
         if (GetStatus() == STATUS_IN_PROGRESS)
             return sWorldSafeLocsStore.LookupEntry(WS_GRAVEYARD_MAIN_HORDE);
         else
             return sWorldSafeLocsStore.LookupEntry(WS_GRAVEYARD_FLAGROOM_HORDE);
     }
 }

Here is the call graph for this function:

ObjectGuid BattlegroundWS::GetDroppedFlagGUID ( uint32 TeamID )

inline

236 { return m_DroppedFlagGUID[GetTeamIndexByTeamId(TeamID)]; }

BattlegroundWS::m_DroppedFlagGUID

ObjectGuid m_DroppedFlagGUID[2]

Definition: BattlegroundWS.h:255

Battleground::GetTeamIndexByTeamId

static TeamId GetTeamIndexByTeamId(uint32 Team)

Definition: Battleground.h:399

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid BattlegroundWS::GetFlagPickerGUID ( int32 team ) const

inlineoverridevirtual

Reimplemented from Battleground.

         {
             if (team == TEAM_ALLIANCE || team == TEAM_HORDE)
                 return m_FlagKeepers[team];
             return ObjectGuid::Empty;
         }

Here is the caller graph for this function:

uint8 BattlegroundWS::GetFlagState ( uint32 team )

inline

211 { return _flagState[GetTeamIndexByTeamId(team)]; }

Battleground::GetTeamIndexByTeamId

static TeamId GetTeamIndexByTeamId(uint32 Team)

Definition: Battleground.h:399

BattlegroundWS::_flagState

uint8 _flagState[2]

Definition: BattlegroundWS.h:256

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundWS::GetPlayerPositionData ( std::vector< WorldPackets::Battleground::BattlegroundPlayerPosition > * positions ) const

overrideprotectedvirtual

Reimplemented from Battleground.

 {
     if (Player* player = ObjectAccessor::GetPlayer(GetBgMap(), m_FlagKeepers[TEAM_ALLIANCE]))
     {
         WorldPackets::Battleground::BattlegroundPlayerPosition position;
         position.Guid = player->GetGUID();
         position.Pos.x = player->GetPositionX();
         position.Pos.y = player->GetPositionY();
         position.IconID = PLAYER_POSITION_ICON_ALLIANCE_FLAG;
         position.ArenaSlot = PLAYER_POSITION_ARENA_SLOT_NONE;
         positions->push_back(position);
     }
 
     if (Player* player = ObjectAccessor::GetPlayer(GetBgMap(), m_FlagKeepers[TEAM_HORDE]))
     {
         WorldPackets::Battleground::BattlegroundPlayerPosition position;
         position.Guid = player->GetGUID();
         position.Pos.x = player->GetPositionX();
         position.Pos.y = player->GetPositionY();
         position.IconID = PLAYER_POSITION_ICON_HORDE_FLAG;
         position.ArenaSlot = PLAYER_POSITION_ARENA_SLOT_NONE;
         positions->push_back(position);
     }
 }

Here is the call graph for this function:

uint32 BattlegroundWS::GetPrematureWinner ( )

overridevirtual

Reimplemented from Battleground.

 {
     if (GetTeamScore(TEAM_ALLIANCE) > GetTeamScore(TEAM_HORDE))
         return ALLIANCE;
     else if (GetTeamScore(TEAM_HORDE) > GetTeamScore(TEAM_ALLIANCE))
         return HORDE;
 
     return Battleground::GetPrematureWinner();
 }

Here is the call graph for this function:

void BattlegroundWS::HandleAreaTrigger	(	Player *	player,
		uint32	trigger,
		bool	entered
	)

overridevirtual

Reimplemented from Battleground.

 {
     if (GetStatus() != STATUS_IN_PROGRESS)
         return;
 
     //uint32 SpellId = 0;
     //uint64 buff_guid = 0;
     switch (trigger)
     {
         case 3686:                                          // Alliance elixir of speed spawn. Trigger not working, because located inside other areatrigger, can be replaced by IsWithinDist(object, dist) in Battleground::Update().
             //buff_guid = BgObjects[BG_WS_OBJECT_SPEEDBUFF_1];
             break;
         case 3687:                                          // Horde elixir of speed spawn. Trigger not working, because located inside other areatrigger, can be replaced by IsWithinDist(object, dist) in Battleground::Update().
             //buff_guid = BgObjects[BG_WS_OBJECT_SPEEDBUFF_2];
             break;
         case 3706:                                          // Alliance elixir of regeneration spawn
             //buff_guid = BgObjects[BG_WS_OBJECT_REGENBUFF_1];
             break;
         case 3708:                                          // Horde elixir of regeneration spawn
             //buff_guid = BgObjects[BG_WS_OBJECT_REGENBUFF_2];
             break;
         case 3707:                                          // Alliance elixir of berserk spawn
             //buff_guid = BgObjects[BG_WS_OBJECT_BERSERKBUFF_1];
             break;
         case 3709:                                          // Horde elixir of berserk spawn
             //buff_guid = BgObjects[BG_WS_OBJECT_BERSERKBUFF_2];
             break;
         case 3646:                                          // Alliance Flag spawn
             if (_flagState[TEAM_HORDE] && !_flagState[TEAM_ALLIANCE])
                 if (GetFlagPickerGUID(TEAM_HORDE) == player->GetGUID())
                     EventPlayerCapturedFlag(player);
             break;
         case 3647:                                          // Horde Flag spawn
             if (_flagState[TEAM_ALLIANCE] && !_flagState[TEAM_HORDE])
                 if (GetFlagPickerGUID(TEAM_ALLIANCE) == player->GetGUID())
                     EventPlayerCapturedFlag(player);
             break;
         case 3649:                                          // unk1
         case 3688:                                          // unk2
         case 4628:                                          // unk3
         case 4629:                                          // unk4
             break;
         default:
             Battleground::HandleAreaTrigger(player, trigger, entered);
             break;
     }
 
     //if (buff_guid)
     //    HandleTriggerBuff(buff_guid, player);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

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

Here is the call graph for this function:

bool BattlegroundWS::IsAllianceFlagPickedup ( ) const

inline

207 { return !m_FlagKeepers[TEAM_ALLIANCE].IsEmpty(); }

TEAM_ALLIANCE

Definition: SharedDefines.h:992

BattlegroundWS::m_FlagKeepers

ObjectGuid m_FlagKeepers[2]

Definition: BattlegroundWS.h:254

ObjectGuid::IsEmpty

bool IsEmpty() const

Definition: ObjectGuid.h:242

Here is the call graph for this function:

Here is the caller graph for this function:

bool BattlegroundWS::IsHordeFlagPickedup ( ) const

inline

208 { return !m_FlagKeepers[TEAM_HORDE].IsEmpty(); }

BattlegroundWS::m_FlagKeepers

ObjectGuid m_FlagKeepers[2]

Definition: BattlegroundWS.h:254

TEAM_HORDE

Definition: SharedDefines.h:993

ObjectGuid::IsEmpty

bool IsEmpty() const

Definition: ObjectGuid.h:242

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundWS::PostUpdateImpl ( uint32 )

overrideprotectedvirtual

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)
     {
         if (GetElapsedTime() >= 27*MINUTE*IN_MILLISECONDS)
         {
             if (GetTeamScore(TEAM_ALLIANCE) == 0)
             {
                 if (GetTeamScore(TEAM_HORDE) == 0)        // No one scored - result is tie
                     EndBattleground(0);
                 else                                 // Horde has more points and thus wins
                     EndBattleground(HORDE);
             }
             else if (GetTeamScore(TEAM_HORDE) == 0)
                 EndBattleground(ALLIANCE);           // Alliance has > 0, Horde has 0, alliance wins
             else if (GetTeamScore(TEAM_HORDE) == GetTeamScore(TEAM_ALLIANCE)) // Team score equal, winner is team that scored the last flag
                 EndBattleground(_lastFlagCaptureTeam);
             else if (GetTeamScore(TEAM_HORDE) > GetTeamScore(TEAM_ALLIANCE))  // Last but not least, check who has the higher score
                 EndBattleground(HORDE);
             else
                 EndBattleground(ALLIANCE);
         }
         // first update needed after 1 minute of game already in progress
         else if (GetElapsedTime() > uint32(_minutesElapsed * MINUTE * IN_MILLISECONDS) +  3 * MINUTE * IN_MILLISECONDS)
         {
             ++_minutesElapsed;
             UpdateWorldState(BG_WS_STATE_TIMER, 25 - _minutesElapsed);
         }
 
         if (_flagState[TEAM_ALLIANCE] == BG_WS_FLAG_STATE_WAIT_RESPAWN)
         {
             _flagsTimer[TEAM_ALLIANCE] -= diff;
 
             if (_flagsTimer[TEAM_ALLIANCE] < 0)
             {
                 _flagsTimer[TEAM_ALLIANCE] = 0;
                 RespawnFlag(ALLIANCE, true);
             }
         }
 
         if (_flagState[TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_GROUND)
         {
             _flagsDropTimer[TEAM_ALLIANCE] -= diff;
 
             if (_flagsDropTimer[TEAM_ALLIANCE] < 0)
             {
                 _flagsDropTimer[TEAM_ALLIANCE] = 0;
                 RespawnFlagAfterDrop(ALLIANCE);
                 _bothFlagsKept = false;
             }
         }
 
         if (_flagState[TEAM_HORDE] == BG_WS_FLAG_STATE_WAIT_RESPAWN)
         {
             _flagsTimer[TEAM_HORDE] -= diff;
 
             if (_flagsTimer[TEAM_HORDE] < 0)
             {
                 _flagsTimer[TEAM_HORDE] = 0;
                 RespawnFlag(HORDE, true);
             }
         }
 
         if (_flagState[TEAM_HORDE] == BG_WS_FLAG_STATE_ON_GROUND)
         {
             _flagsDropTimer[TEAM_HORDE] -= diff;
 
             if (_flagsDropTimer[TEAM_HORDE] < 0)
             {
                 _flagsDropTimer[TEAM_HORDE] = 0;
                 RespawnFlagAfterDrop(HORDE);
                 _bothFlagsKept = false;
             }
         }
 
         if (_bothFlagsKept)
         {
             _flagSpellForceTimer += diff;
             if (_flagDebuffState == 0 && _flagSpellForceTimer >= 10*MINUTE*IN_MILLISECONDS)  //10 minutes
             {
                 if (Player* player = ObjectAccessor::FindPlayer(m_FlagKeepers[0]))
                     player->CastSpell(player, WS_SPELL_FOCUSED_ASSAULT, true);
                 if (Player* player = ObjectAccessor::FindPlayer(m_FlagKeepers[1]))
                     player->CastSpell(player, WS_SPELL_FOCUSED_ASSAULT, true);
                 _flagDebuffState = 1;
             }
             else if (_flagDebuffState == 1 && _flagSpellForceTimer >= 15*MINUTE*IN_MILLISECONDS) //15 minutes
             {
                 if (Player* player = ObjectAccessor::FindPlayer(m_FlagKeepers[0]))
                 {
                     player->RemoveAurasDueToSpell(WS_SPELL_FOCUSED_ASSAULT);
                     player->CastSpell(player, WS_SPELL_BRUTAL_ASSAULT, true);
                 }
                 if (Player* player = ObjectAccessor::FindPlayer(m_FlagKeepers[1]))
                 {
                     player->RemoveAurasDueToSpell(WS_SPELL_FOCUSED_ASSAULT);
                     player->CastSpell(player, WS_SPELL_BRUTAL_ASSAULT, true);
                 }
                 _flagDebuffState = 2;
             }
         }
         else
         {
             if (Player* player = ObjectAccessor::FindPlayer(m_FlagKeepers[0]))
             {
                 player->RemoveAurasDueToSpell(WS_SPELL_FOCUSED_ASSAULT);
                 player->RemoveAurasDueToSpell(WS_SPELL_BRUTAL_ASSAULT);
             }
             if (Player* player = ObjectAccessor::FindPlayer(m_FlagKeepers[1]))
             {
                 player->RemoveAurasDueToSpell(WS_SPELL_FOCUSED_ASSAULT);
                 player->RemoveAurasDueToSpell(WS_SPELL_BRUTAL_ASSAULT);
             }
 
             _flagSpellForceTimer = 0; //reset timer.
             _flagDebuffState = 0;
         }
     }
 }

Here is the call graph for this function:

void BattlegroundWS::RemovePlayer	(	Player *	player,
		ObjectGuid	guid,
		uint32	team
	)

overridevirtual

Reimplemented from Battleground.

 {
     // sometimes flag aura not removed :(
     if (IsAllianceFlagPickedup() && m_FlagKeepers[TEAM_ALLIANCE] == guid)
     {
         if (!player)
         {
             TC_LOG_ERROR("bg.battleground", "BattlegroundWS: Removing offline player who has the FLAG!!");
             SetAllianceFlagPicker(ObjectGuid::Empty);
             RespawnFlag(ALLIANCE, false);
         }
         else
             EventPlayerDroppedFlag(player);
     }
     if (IsHordeFlagPickedup() && m_FlagKeepers[TEAM_HORDE] == guid)
     {
         if (!player)
         {
             TC_LOG_ERROR("bg.battleground", "BattlegroundWS: Removing offline player who has the FLAG!!");
             SetHordeFlagPicker(ObjectGuid::Empty);
             RespawnFlag(HORDE, false);
         }
         else
             EventPlayerDroppedFlag(player);
     }
 }

Here is the call graph for this function:

void BattlegroundWS::RemovePoint	(	uint32	TeamID,
		uint32	Points = `1`
	)

inline

242 { m_TeamScores[GetTeamIndexByTeamId(TeamID)] -= Points; }

Battleground::m_TeamScores

int32 m_TeamScores[BG_TEAMS_COUNT]

Definition: Battleground.h:562

Points

Definition: ScriptedEscortAI.cpp:31

Battleground::GetTeamIndexByTeamId

static TeamId GetTeamIndexByTeamId(uint32 Team)

Definition: Battleground.h:399

Here is the call graph for this function:

void BattlegroundWS::Reset ( )

overridevirtual

Reimplemented from Battleground.

 {
     //call parent's class reset
     Battleground::Reset();
 
     m_FlagKeepers[TEAM_ALLIANCE].Clear();
     m_FlagKeepers[TEAM_HORDE].Clear();
     m_DroppedFlagGUID[TEAM_ALLIANCE].Clear();
     m_DroppedFlagGUID[TEAM_HORDE].Clear();
     _flagState[TEAM_ALLIANCE]        = BG_WS_FLAG_STATE_ON_BASE;
     _flagState[TEAM_HORDE]           = BG_WS_FLAG_STATE_ON_BASE;
     m_TeamScores[TEAM_ALLIANCE]      = 0;
     m_TeamScores[TEAM_HORDE]         = 0;
 
     if (sBattlegroundMgr->IsBGWeekend(GetTypeID()))
     {
         m_ReputationCapture = 45;
         m_HonorWinKills = 3;
         m_HonorEndKills = 4;
     }
     else
     {
         m_ReputationCapture = 35;
         m_HonorWinKills = 1;
         m_HonorEndKills = 2;
     }
     _minutesElapsed                  = 0;
     _lastFlagCaptureTeam             = 0;
     _bothFlagsKept                   = false;
     _flagDebuffState                 = 0;
     _flagSpellForceTimer             = 0;
     _flagsDropTimer[TEAM_ALLIANCE]   = 0;
     _flagsDropTimer[TEAM_HORDE]      = 0;
     _flagsTimer[TEAM_ALLIANCE]       = 0;
     _flagsTimer[TEAM_HORDE]          = 0;
 }

Here is the call graph for this function:

void BattlegroundWS::RespawnFlag	(	uint32	Team,
		bool	captured
	)

 {
     if (Team == ALLIANCE)
     {
         TC_LOG_DEBUG("bg.battleground", "Respawn Alliance flag");
         _flagState[TEAM_ALLIANCE] = BG_WS_FLAG_STATE_ON_BASE;
     }
     else
     {
         TC_LOG_DEBUG("bg.battleground", "Respawn Horde flag");
         _flagState[TEAM_HORDE] = BG_WS_FLAG_STATE_ON_BASE;
     }
 
     if (captured)
     {
         //when map_update will be allowed for battlegrounds this code will be useless
         SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_IMMEDIATELY);
         SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_IMMEDIATELY);
         SendMessageToAll(LANG_BG_WS_F_PLACED, CHAT_MSG_BG_SYSTEM_NEUTRAL);
         PlaySoundToAll(BG_WS_SOUND_FLAGS_RESPAWNED);        // flag respawned sound...
     }
     _bothFlagsKept = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundWS::RespawnFlagAfterDrop ( uint32 Team )

 {
     if (GetStatus() != STATUS_IN_PROGRESS)
         return;
 
     RespawnFlag(team, false);
     if (team == ALLIANCE)
     {
         SpawnBGObject(BG_WS_OBJECT_A_FLAG, RESPAWN_IMMEDIATELY);
         SendMessageToAll(LANG_BG_WS_ALLIANCE_FLAG_RESPAWNED, CHAT_MSG_BG_SYSTEM_NEUTRAL);
     }
     else
     {
         SpawnBGObject(BG_WS_OBJECT_H_FLAG, RESPAWN_IMMEDIATELY);
         SendMessageToAll(LANG_BG_WS_HORDE_FLAG_RESPAWNED, CHAT_MSG_BG_SYSTEM_NEUTRAL);
     }
 
     PlaySoundToAll(BG_WS_SOUND_FLAGS_RESPAWNED);
 
     if (GameObject* obj = GetBgMap()->GetGameObject(GetDroppedFlagGUID(team)))
         obj->Delete();
     else
         TC_LOG_ERROR("bg.battleground", "unknown dropped flag (%s)", GetDroppedFlagGUID(team).ToString().c_str());
 
     SetDroppedFlagGUID(ObjectGuid::Empty, GetTeamIndexByTeamId(team));
     _bothFlagsKept = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundWS::SetAllianceFlagPicker ( ObjectGuid guid )

inline

205 { m_FlagKeepers[TEAM_ALLIANCE] = guid; }

TEAM_ALLIANCE

Definition: SharedDefines.h:992

BattlegroundWS::m_FlagKeepers

ObjectGuid m_FlagKeepers[2]

Definition: BattlegroundWS.h:254

Here is the caller graph for this function:

void BattlegroundWS::SetDroppedFlagGUID	(	ObjectGuid	guid,
		int32	team = `-1`
	)

inlineoverridevirtual

Reimplemented from Battleground.

         {
             if (team == TEAM_ALLIANCE || team == TEAM_HORDE)
                 m_DroppedFlagGUID[team] = guid;
         }

Here is the caller graph for this function:

void BattlegroundWS::SetHordeFlagPicker ( ObjectGuid guid )

inline

206 { m_FlagKeepers[TEAM_HORDE] = guid; }

BattlegroundWS::m_FlagKeepers

ObjectGuid m_FlagKeepers[2]

Definition: BattlegroundWS.h:254

TEAM_HORDE

Definition: SharedDefines.h:993

Here is the caller graph for this function:

void BattlegroundWS::SetLastFlagCapture ( uint32 team )

inline

227 { _lastFlagCaptureTeam = team; }

BattlegroundWS::_lastFlagCaptureTeam

uint32 _lastFlagCaptureTeam

Definition: BattlegroundWS.h:259

Here is the caller graph for this function:

void BattlegroundWS::SetTeamPoint	(	uint32	TeamID,
		uint32	Points = `0`
	)

inline

241 { m_TeamScores[GetTeamIndexByTeamId(TeamID)] = Points; }

Battleground::m_TeamScores

int32 m_TeamScores[BG_TEAMS_COUNT]

Definition: Battleground.h:562

Points

Definition: ScriptedEscortAI.cpp:31

Battleground::GetTeamIndexByTeamId

static TeamId GetTeamIndexByTeamId(uint32 Team)

Definition: Battleground.h:399

Here is the call graph for this function:

bool BattlegroundWS::SetupBattleground ( )

overridevirtual

Reimplemented from Battleground.

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

Here is the call graph for this function:

void BattlegroundWS::StartingEventCloseDoors ( )

overridevirtual

Reimplemented from Battleground.

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

Here is the call graph for this function:

void BattlegroundWS::StartingEventOpenDoors ( )

overridevirtual

Reimplemented from Battleground.

 {
     for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i <= BG_WS_OBJECT_DOOR_A_6; ++i)
         DoorOpen(i);
     for (uint32 i = BG_WS_OBJECT_DOOR_H_1; i <= BG_WS_OBJECT_DOOR_H_4; ++i)
         DoorOpen(i);
 
     for (uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; ++i)
         SpawnBGObject(i, RESPAWN_IMMEDIATELY);
 
     SpawnBGObject(BG_WS_OBJECT_DOOR_A_5, RESPAWN_ONE_DAY);
     SpawnBGObject(BG_WS_OBJECT_DOOR_A_6, RESPAWN_ONE_DAY);
     SpawnBGObject(BG_WS_OBJECT_DOOR_H_3, RESPAWN_ONE_DAY);
     SpawnBGObject(BG_WS_OBJECT_DOOR_H_4, RESPAWN_ONE_DAY);
 
     // players joining later are not eligibles
     StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, WS_EVENT_START_BATTLE);
 }

Here is the call graph for this function:

void BattlegroundWS::UpdateFlagState	(	uint32	team,
		uint32	value
	)

 {
     if (team == ALLIANCE)
         UpdateWorldState(BG_WS_FLAG_STATE_ALLIANCE, value);
     else
         UpdateWorldState(BG_WS_FLAG_STATE_HORDE, value);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
     if (!Battleground::UpdatePlayerScore(player, type, value, doAddHonor))
         return false;
 
     switch (type)
     {
         case SCORE_FLAG_CAPTURES:                           // flags captured
             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, WS_OBJECTIVE_CAPTURE_FLAG);
             break;
         case SCORE_FLAG_RETURNS:                            // flags returned
             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, WS_OBJECTIVE_RETURN_FLAG);
             break;
         default:
             break;
     }
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundWS::UpdateTeamScore ( uint32 team )

 {
     if (team == TEAM_ALLIANCE)
         UpdateWorldState(BG_WS_FLAG_CAPTURES_ALLIANCE, GetTeamScore(team));
     else
         UpdateWorldState(BG_WS_FLAG_CAPTURES_HORDE, GetTeamScore(team));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bool BattlegroundWS::_bothFlagsKept

private

uint8 BattlegroundWS::_flagDebuffState

private

int32 BattlegroundWS::_flagsDropTimer[2]

private

int32 BattlegroundWS::_flagSpellForceTimer

private

uint8 BattlegroundWS::_flagState[2]

private

int32 BattlegroundWS::_flagsTimer[2]

private

uint32 BattlegroundWS::_lastFlagCaptureTeam

private

uint8 BattlegroundWS::_minutesElapsed

private

ObjectGuid BattlegroundWS::m_DroppedFlagGUID[2]

private

ObjectGuid BattlegroundWS::m_FlagKeepers[2]

private

uint32 BattlegroundWS::m_HonorEndKills

private

uint32 BattlegroundWS::m_HonorWinKills

private

uint32 BattlegroundWS::m_ReputationCapture

private

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

src/server/game/Battlegrounds/Zones/BattlegroundWS.h
src/server/game/Battlegrounds/Zones/BattlegroundWS.cpp

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation