#include <BattlegroundEY.h>

Public Member Functions
	BattlegroundEY ()

	~BattlegroundEY ()

void	AddPlayer (Player *player) override

void	StartingEventCloseDoors () override

void	StartingEventOpenDoors () override

ObjectGuid	GetFlagPickerGUID (int32=-1) const override

void	SetFlagPicker (ObjectGuid guid)

bool	IsFlagPickedup () const

uint8	GetFlagState () const

void	RespawnFlag (bool send_message)

void	RespawnFlagAfterDrop ()

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

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

void	HandleKillPlayer (Player player, Player killer) override

WorldSafeLocsEntry const *	GetClosestGraveYard (Player *player) override

bool	SetupBattleground () override

void	Reset () override

void	UpdateTeamScore (uint32 Team)

void	EndBattleground (uint32 winner) override

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

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

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

ObjectGuid	GetDroppedFlagGUID () const

void	EventPlayerClickedOnFlag (Player Source, GameObject target_obj) override

void	EventPlayerDroppedFlag (Player *Source) override

bool	IsAllNodesControlledByTeam (uint32 team) const override

uint32	GetPrematureWinner () override

Public Member Functions inherited from Battleground
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual void	ResetBGSubclass ()

virtual void	DestroyGate (Player , GameObject )

void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)

virtual bool	CheckAchievementCriteriaMeet (uint32, Player const , Unit const =NULL, uint32=0)

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

void	EventPlayerCapturedFlag (Player *Source, uint32 BgObjectType)

void	EventTeamCapturedPoint (Player *Source, uint32 Point)

void	EventTeamLostPoint (Player *Source, uint32 Point)

void	UpdatePointsCount (uint32 Team)

void	UpdatePointsIcons (uint32 Team, uint32 Point)

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 Member Functions
void	CheckSomeoneLeftPoint ()

void	CheckSomeoneJoinedPoint ()

void	UpdatePointStatuses ()

void	AddPoints (uint32 Team, uint32 Points)

void	RemovePoint (uint32 TeamID, uint32 Points=1)

void	SetTeamPoint (uint32 TeamID, uint32 Points=0)

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

BattlegroundEY::BattlegroundEY ( )

 {
  m_BuffChange = true;
  BgObjects.resize(BG_EY_OBJECT_MAX);
  BgCreatures.resize(BG_EY_CREATURES_MAX);
  m_Points_Trigger[FEL_REAVER] = TR_FEL_REAVER_BUFF;
  m_Points_Trigger[BLOOD_ELF] = TR_BLOOD_ELF_BUFF;
  m_Points_Trigger[DRAENEI_RUINS] = TR_DRAENEI_RUINS_BUFF;
  m_Points_Trigger[MAGE_TOWER] = TR_MAGE_TOWER_BUFF;
  m_HonorScoreTics[TEAM_ALLIANCE] = 0;
  m_HonorScoreTics[TEAM_HORDE] = 0;
  m_TeamPointsCount[TEAM_ALLIANCE] = 0;
  m_TeamPointsCount[TEAM_HORDE] = 0;
  m_FlagKeeper.Clear();
  m_DroppedFlagGUID.Clear();
  m_FlagCapturedBgObjectType = 0;
  m_FlagState = BG_EY_FLAG_STATE_ON_BASE;
  m_FlagsTimer = 0;
  m_TowerCapCheckTimer = 0;
  m_PointAddingTimer = 0;
  m_HonorTics = 0;
 
  for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
  {
  m_PointOwnedByTeam[i] = EY_POINT_NO_OWNER;
  m_PointState[i] = EY_POINT_STATE_UNCONTROLLED;
  m_PointBarStatus[i] = BG_EY_PROGRESS_BAR_STATE_MIDDLE;
  }
 
  for (uint8 i = 0; i < 2 * EY_POINTS_MAX; ++i)
  m_CurrentPointPlayersCount[i] = 0;
 
  StartMessageIds[BG_STARTING_EVENT_FIRST] = LANG_BG_EY_START_TWO_MINUTES;
  StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_BG_EY_START_ONE_MINUTE;
  StartMessageIds[BG_STARTING_EVENT_THIRD] = LANG_BG_EY_START_HALF_MINUTE;
  StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_BG_EY_HAS_BEGUN;
 }

Here is the call graph for this function:

BattlegroundEY::~BattlegroundEY ( )

72 { }

Member Function Documentation

void BattlegroundEY::AddPlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

 {
  Battleground::AddPlayer(player);
  PlayerScores[player->GetGUID()] = new BattlegroundEYScore(player->GetGUID(), player->GetBGTeam());
 
  m_PlayersNearPoint[EY_POINTS_MAX].push_back(player->GetGUID());
 }

Here is the call graph for this function:

void BattlegroundEY::AddPoints	(	uint32	Team,
		uint32	Points
	)

private

 {
  TeamId team_index = GetTeamIndexByTeamId(Team);
  m_TeamScores[team_index] += Points;
  m_HonorScoreTics[team_index] += Points;
  if (m_HonorScoreTics[team_index] >= m_HonorTics)
  {
  RewardHonorToTeam(GetBonusHonorFromKill(1), Team);
  m_HonorScoreTics[team_index] -= m_HonorTics;
  }
  UpdateTeamScore(team_index);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::CheckSomeoneJoinedPoint ( )

private

 {
  GameObject* obj = NULL;
  for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
  {
  obj = GetBgMap()->GetGameObject(BgObjects[BG_EY_OBJECT_TOWER_CAP_FEL_REAVER + i]);
  if (obj)
  {
  uint8 j = 0;
  while (j < m_PlayersNearPoint[EY_POINTS_MAX].size())
  {
  Player* player = ObjectAccessor::FindPlayer(m_PlayersNearPoint[EY_POINTS_MAX][j]);
  if (!player)
  {
  TC_LOG_ERROR("bg.battleground", "BattlegroundEY:CheckSomeoneJoinedPoint: Player (%s) not found!", m_PlayersNearPoint[EY_POINTS_MAX][j].ToString().c_str());
  ++j;
  continue;
  }
  if (player->CanCaptureTowerPoint() && player->IsWithinDistInMap(obj, BG_EY_POINT_RADIUS))
  {
  //player joined point!
  //show progress bar
  player->SendUpdateWorldState(PROGRESS_BAR_PERCENT_GREY, BG_EY_PROGRESS_BAR_PERCENT_GREY);
  player->SendUpdateWorldState(PROGRESS_BAR_STATUS, m_PointBarStatus[i]);
  player->SendUpdateWorldState(PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_SHOW);
  //add player to point
  m_PlayersNearPoint[i].push_back(m_PlayersNearPoint[EY_POINTS_MAX][j]);
  //remove player from "free space"
  m_PlayersNearPoint[EY_POINTS_MAX].erase(m_PlayersNearPoint[EY_POINTS_MAX].begin() + j);
  }
  else
  ++j;
  }
  }
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::CheckSomeoneLeftPoint ( )

private

 {
  //reset current point counts
  for (uint8 i = 0; i < 2*EY_POINTS_MAX; ++i)
  m_CurrentPointPlayersCount[i] = 0;
  GameObject* obj = NULL;
  for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
  {
  obj = GetBgMap()->GetGameObject(BgObjects[BG_EY_OBJECT_TOWER_CAP_FEL_REAVER + i]);
  if (obj)
  {
  uint8 j = 0;
  while (j < m_PlayersNearPoint[i].size())
  {
  Player* player = ObjectAccessor::FindPlayer(m_PlayersNearPoint[i][j]);
  if (!player)
  {
  TC_LOG_ERROR("bg.battleground", "BattlegroundEY:CheckSomeoneLeftPoint Player (%s) not found!", m_PlayersNearPoint[i][j].ToString().c_str());
  //move not existed player to "free space" - this will cause many error showing in log, but it is a very important bug
  m_PlayersNearPoint[EY_POINTS_MAX].push_back(m_PlayersNearPoint[i][j]);
  m_PlayersNearPoint[i].erase(m_PlayersNearPoint[i].begin() + j);
  continue;
  }
  if (!player->CanCaptureTowerPoint() || !player->IsWithinDistInMap(obj, BG_EY_POINT_RADIUS))
  //move player out of point (add him to players that are out of points
  {
  m_PlayersNearPoint[EY_POINTS_MAX].push_back(m_PlayersNearPoint[i][j]);
  m_PlayersNearPoint[i].erase(m_PlayersNearPoint[i].begin() + j);
  player->SendUpdateWorldState(PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_DONT_SHOW);
  }
  else
  {
  //player is neat flag, so update count:
  m_CurrentPointPlayersCount[2 * i + GetTeamIndexByTeamId(player->GetTeam())]++;
  ++j;
  }
  }
  }
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::EndBattleground ( uint32 winner )

overridevirtual

Reimplemented from Battleground.

 {
  // Win reward
  if (winner == ALLIANCE)
  RewardHonorToTeam(GetBonusHonorFromKill(1), ALLIANCE);
  if (winner == HORDE)
  RewardHonorToTeam(GetBonusHonorFromKill(1), HORDE);
  // Complete map reward
  RewardHonorToTeam(GetBonusHonorFromKill(1), ALLIANCE);
  RewardHonorToTeam(GetBonusHonorFromKill(1), HORDE);
 
  Battleground::EndBattleground(winner);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::EventPlayerCapturedFlag	(	Player *	Source,
		uint32	BgObjectType
	)

protected

 {
  if (GetStatus() != STATUS_IN_PROGRESS || GetFlagPickerGUID() != player->GetGUID())
  return;
 
  SetFlagPicker(ObjectGuid::Empty);
  m_FlagState = BG_EY_FLAG_STATE_WAIT_RESPAWN;
  player->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
 
  player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 
  if (player->GetTeam() == ALLIANCE)
  PlaySoundToAll(BG_EY_SOUND_FLAG_CAPTURED_ALLIANCE);
  else
  PlaySoundToAll(BG_EY_SOUND_FLAG_CAPTURED_HORDE);
 
  SpawnBGObject(BgObjectType, RESPAWN_IMMEDIATELY);
 
  m_FlagsTimer = BG_EY_FLAG_RESPAWN_TIME;
  m_FlagCapturedBgObjectType = BgObjectType;
 
  uint8 team_id = 0;
  if (player->GetTeam() == ALLIANCE)
  {
  team_id = TEAM_ALLIANCE;
  SendMessageToAll(LANG_BG_EY_CAPTURED_FLAG_A, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
  }
  else
  {
  team_id = TEAM_HORDE;
  SendMessageToAll(LANG_BG_EY_CAPTURED_FLAG_H, CHAT_MSG_BG_SYSTEM_HORDE, player);
  }
 
  if (m_TeamPointsCount[team_id] > 0)
  AddPoints(player->GetTeam(), BG_EY_FlagPoints[m_TeamPointsCount[team_id] - 1]);
 
  UpdatePlayerScore(player, SCORE_FLAG_CAPTURES, 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::EventPlayerClickedOnFlag	(	Player *	Source,
		GameObject *	target_obj
	)

overridevirtual

Reimplemented from Battleground.

 {
  if (GetStatus() != STATUS_IN_PROGRESS || IsFlagPickedup() || !player->IsWithinDistInMap(target_obj, 10))
  return;
 
  if (player->GetTeam() == ALLIANCE)
  {
  UpdateWorldState(NETHERSTORM_FLAG_STATE_ALLIANCE, BG_EY_FLAG_STATE_ON_PLAYER);
  PlaySoundToAll(BG_EY_SOUND_FLAG_PICKED_UP_ALLIANCE);
  }
  else
  {
  UpdateWorldState(NETHERSTORM_FLAG_STATE_HORDE, BG_EY_FLAG_STATE_ON_PLAYER);
  PlaySoundToAll(BG_EY_SOUND_FLAG_PICKED_UP_HORDE);
  }
 
  if (m_FlagState == BG_EY_FLAG_STATE_ON_BASE)
  UpdateWorldState(NETHERSTORM_FLAG, 0);
  m_FlagState = BG_EY_FLAG_STATE_ON_PLAYER;
 
  SpawnBGObject(BG_EY_OBJECT_FLAG_NETHERSTORM, RESPAWN_ONE_DAY);
  SetFlagPicker(player->GetGUID());
  //get flag aura on player
  player->CastSpell(player, BG_EY_NETHERSTORM_FLAG_SPELL, true);
  player->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 
  if (player->GetTeam() == ALLIANCE)
  PSendMessageToAll(LANG_BG_EY_HAS_TAKEN_FLAG, CHAT_MSG_BG_SYSTEM_ALLIANCE, NULL, player->GetName().c_str());
  else
  PSendMessageToAll(LANG_BG_EY_HAS_TAKEN_FLAG, CHAT_MSG_BG_SYSTEM_HORDE, NULL, player->GetName().c_str());
 }

Here is the call graph for this function:

void BattlegroundEY::EventPlayerDroppedFlag ( Player * Source )

overridevirtual

Reimplemented from Battleground.

 {
  if (GetStatus() != STATUS_IN_PROGRESS)
  {
  // if not running, do not cast things at the dropper player, neither send unnecessary messages
  // just take off the aura
  if (IsFlagPickedup() && GetFlagPickerGUID() == player->GetGUID())
  {
  SetFlagPicker(ObjectGuid::Empty);
  player->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
  }
  return;
  }
 
  if (!IsFlagPickedup())
  return;
 
  if (GetFlagPickerGUID() != player->GetGUID())
  return;
 
  SetFlagPicker(ObjectGuid::Empty);
  player->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
  m_FlagState = BG_EY_FLAG_STATE_ON_GROUND;
  m_FlagsTimer = BG_EY_FLAG_RESPAWN_TIME;
  player->CastSpell(player, SPELL_RECENTLY_DROPPED_FLAG, true);
  player->CastSpell(player, BG_EY_PLAYER_DROPPED_FLAG_SPELL, true);
  //this does not work correctly :((it should remove flag carrier name)
  UpdateWorldState(NETHERSTORM_FLAG_STATE_HORDE, BG_EY_FLAG_STATE_WAIT_RESPAWN);
  UpdateWorldState(NETHERSTORM_FLAG_STATE_ALLIANCE, BG_EY_FLAG_STATE_WAIT_RESPAWN);
 
  if (player->GetTeam() == ALLIANCE)
  SendMessageToAll(LANG_BG_EY_DROPPED_FLAG, CHAT_MSG_BG_SYSTEM_ALLIANCE, NULL);
  else
  SendMessageToAll(LANG_BG_EY_DROPPED_FLAG, CHAT_MSG_BG_SYSTEM_HORDE, NULL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::EventTeamCapturedPoint	(	Player *	Source,
		uint32	Point
	)

protected

 {
  if (GetStatus() != STATUS_IN_PROGRESS)
  return;
 
  uint32 Team = player->GetTeam();
 
  SpawnBGObject(m_CapturingPointTypes[Point].DespawnNeutralObjectType, RESPAWN_ONE_DAY);
     SpawnBGObject(m_CapturingPointTypes[Point].DespawnNeutralObjectType + 1, RESPAWN_ONE_DAY);
     SpawnBGObject(m_CapturingPointTypes[Point].DespawnNeutralObjectType + 2, RESPAWN_ONE_DAY);
 
     if (Team == ALLIANCE)
     {
         m_TeamPointsCount[TEAM_ALLIANCE]++;
         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeAlliance, RESPAWN_IMMEDIATELY);
         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeAlliance + 1, RESPAWN_IMMEDIATELY);
         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeAlliance + 2, RESPAWN_IMMEDIATELY);
     }
     else
     {
         m_TeamPointsCount[TEAM_HORDE]++;
         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeHorde, RESPAWN_IMMEDIATELY);
         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeHorde + 1, RESPAWN_IMMEDIATELY);
         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeHorde + 2, RESPAWN_IMMEDIATELY);
     }
 
     //buff isn't respawned
 
     m_PointOwnedByTeam[Point] = Team;
     m_PointState[Point] = EY_POINT_UNDER_CONTROL;
 
     if (Team == ALLIANCE)
         SendMessageToAll(m_CapturingPointTypes[Point].MessageIdAlliance, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
     else
         SendMessageToAll(m_CapturingPointTypes[Point].MessageIdHorde, CHAT_MSG_BG_SYSTEM_HORDE, player);
 
     if (!BgCreatures[Point].IsEmpty())
         DelCreature(Point);
 
     WorldSafeLocsEntry const* sg = NULL;
     sg = sWorldSafeLocsStore.LookupEntry(m_CapturingPointTypes[Point].GraveYardId);
     if (!sg || !AddSpiritGuide(Point, sg->Loc.X, sg->Loc.Y, sg->Loc.Z, 3.124139f, GetTeamIndexByTeamId(Team)))
         TC_LOG_ERROR("bg.battleground", "BatteGroundEY: Failed to spawn spirit guide! point: %u, team: %u, graveyard_id: %u",
             Point, Team, m_CapturingPointTypes[Point].GraveYardId);
 
 //    SpawnBGCreature(Point, RESPAWN_IMMEDIATELY);
 
     UpdatePointsIcons(Team, Point);
     UpdatePointsCount(Team);
 
     if (Point >= EY_POINTS_MAX)
         return;
 
     Creature* trigger = GetBGCreature(Point + 6, false);//0-5 spirit guides
     if (!trigger)
         trigger = AddCreature(WORLD_TRIGGER, Point+6, BG_EY_TriggerPositions[Point], GetTeamIndexByTeamId(Team));
 
     //add bonus honor aura trigger creature when node is accupied
     //cast bonus aura (+50% honor in 25yards)
     //aura should only apply to players who have accupied the node, set correct faction for trigger
     if (trigger)
     {
         trigger->setFaction(Team == ALLIANCE ? 84 : 83);
         trigger->CastSpell(trigger, SPELL_HONORABLE_DEFENDER_25Y, false);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::EventTeamLostPoint	(	Player *	Source,
		uint32	Point
	)

protected

 {
     if (GetStatus() != STATUS_IN_PROGRESS)
         return;
 
     //Natural point
     uint32 Team = m_PointOwnedByTeam[Point];
 
     if (!Team)
         return;
 
     if (Team == ALLIANCE)
     {
         m_TeamPointsCount[TEAM_ALLIANCE]--;
         SpawnBGObject(m_LosingPointTypes[Point].DespawnObjectTypeAlliance, RESPAWN_ONE_DAY);
         SpawnBGObject(m_LosingPointTypes[Point].DespawnObjectTypeAlliance + 1, RESPAWN_ONE_DAY);
         SpawnBGObject(m_LosingPointTypes[Point].DespawnObjectTypeAlliance + 2, RESPAWN_ONE_DAY);
     }
     else
     {
         m_TeamPointsCount[TEAM_HORDE]--;
         SpawnBGObject(m_LosingPointTypes[Point].DespawnObjectTypeHorde, RESPAWN_ONE_DAY);
         SpawnBGObject(m_LosingPointTypes[Point].DespawnObjectTypeHorde + 1, RESPAWN_ONE_DAY);
         SpawnBGObject(m_LosingPointTypes[Point].DespawnObjectTypeHorde + 2, RESPAWN_ONE_DAY);
     }
 
     SpawnBGObject(m_LosingPointTypes[Point].SpawnNeutralObjectType, RESPAWN_IMMEDIATELY);
     SpawnBGObject(m_LosingPointTypes[Point].SpawnNeutralObjectType + 1, RESPAWN_IMMEDIATELY);
     SpawnBGObject(m_LosingPointTypes[Point].SpawnNeutralObjectType + 2, RESPAWN_IMMEDIATELY);
 
     //buff isn't despawned
 
     m_PointOwnedByTeam[Point] = EY_POINT_NO_OWNER;
     m_PointState[Point] = EY_POINT_NO_OWNER;
 
     if (Team == ALLIANCE)
         SendMessageToAll(m_LosingPointTypes[Point].MessageIdAlliance, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
     else
         SendMessageToAll(m_LosingPointTypes[Point].MessageIdHorde, CHAT_MSG_BG_SYSTEM_HORDE, player);
 
     UpdatePointsIcons(Team, Point);
     UpdatePointsCount(Team);
 
     //remove bonus honor aura trigger creature when node is lost
      if (Point < EY_POINTS_MAX)
          DelCreature(Point + 6);//NULL checks are in DelCreature! 0-5 spirit guides
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
     packet.Worldstates.emplace_back(uint32(EY_HORDE_BASE), int32(m_TeamPointsCount[TEAM_HORDE]));
     packet.Worldstates.emplace_back(uint32(EY_ALLIANCE_BASE), int32(m_TeamPointsCount[TEAM_ALLIANCE]));
     packet.Worldstates.emplace_back(0xAB6, 0x0);
     packet.Worldstates.emplace_back(0xAB5, 0x0);
     packet.Worldstates.emplace_back(0xAB4, 0x0);
     packet.Worldstates.emplace_back(0xAB3, 0x0);
     packet.Worldstates.emplace_back(0xAB2, 0x0);
     packet.Worldstates.emplace_back(0xAB1, 0x0);
     packet.Worldstates.emplace_back(0xAB0, 0x0);
     packet.Worldstates.emplace_back(0xAAF, 0x0);
 
     packet.Worldstates.emplace_back(uint32(DRAENEI_RUINS_HORDE_CONTROL), int32(m_PointOwnedByTeam[DRAENEI_RUINS] == HORDE && m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(DRAENEI_RUINS_ALLIANCE_CONTROL), int32(m_PointOwnedByTeam[DRAENEI_RUINS] == ALLIANCE && m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(DRAENEI_RUINS_UNCONTROL), int32(m_PointState[DRAENEI_RUINS] != EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(MAGE_TOWER_ALLIANCE_CONTROL), int32(m_PointOwnedByTeam[MAGE_TOWER] == ALLIANCE && m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(MAGE_TOWER_HORDE_CONTROL), int32(m_PointOwnedByTeam[MAGE_TOWER] == HORDE && m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(MAGE_TOWER_UNCONTROL), int32(m_PointState[MAGE_TOWER] != EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(FEL_REAVER_HORDE_CONTROL), int32(m_PointOwnedByTeam[FEL_REAVER] == HORDE && m_PointState[FEL_REAVER] == EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(FEL_REAVER_ALLIANCE_CONTROL), int32(m_PointOwnedByTeam[FEL_REAVER] == ALLIANCE && m_PointState[FEL_REAVER] == EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(FEL_REAVER_UNCONTROL), int32(m_PointState[FEL_REAVER] != EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(BLOOD_ELF_HORDE_CONTROL), int32(m_PointOwnedByTeam[BLOOD_ELF] == HORDE && m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(BLOOD_ELF_ALLIANCE_CONTROL), int32(m_PointOwnedByTeam[BLOOD_ELF] == ALLIANCE && m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(BLOOD_ELF_UNCONTROL), int32(m_PointState[BLOOD_ELF] != EY_POINT_UNDER_CONTROL));
     packet.Worldstates.emplace_back(uint32(NETHERSTORM_FLAG), int32(m_FlagState == BG_EY_FLAG_STATE_ON_BASE));
 
     packet.Worldstates.emplace_back(0xAD2, 0x1);
     packet.Worldstates.emplace_back(0xAD1, 0x1);
 
     packet.Worldstates.emplace_back(0xABE, int32(GetTeamScore(TEAM_HORDE)));
     packet.Worldstates.emplace_back(0xABD, int32(GetTeamScore(TEAM_ALLIANCE)));
 
     packet.Worldstates.emplace_back(0xA05, 0x8E);
     packet.Worldstates.emplace_back(0xAA0, 0x0);
     packet.Worldstates.emplace_back(0xA9F, 0x0);
     packet.Worldstates.emplace_back(0xA9E, 0x0);
     packet.Worldstates.emplace_back(0xC0D, 0x17B);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
     uint32 g_id = 0;
 
     switch (player->GetTeam())
     {
         case ALLIANCE: g_id = EY_GRAVEYARD_MAIN_ALLIANCE; break;
         case HORDE:    g_id = EY_GRAVEYARD_MAIN_HORDE;    break;
         default:       return NULL;
     }
 
     float distance, nearestDistance;
 
     WorldSafeLocsEntry const* entry = NULL;
     WorldSafeLocsEntry const* nearestEntry = NULL;
     entry = sWorldSafeLocsStore.LookupEntry(g_id);
     nearestEntry = entry;
 
     if (!entry)
     {
         TC_LOG_ERROR("bg.battleground", "BattlegroundEY: Not found the main team graveyard. Graveyard system isn't working!");
         return NULL;
     }
 
     float plr_x = player->GetPositionX();
     float plr_y = player->GetPositionY();
     float plr_z = player->GetPositionZ();
 
     distance = (entry->Loc.X - plr_x)*(entry->Loc.X - plr_x) + (entry->Loc.Y - plr_y)*(entry->Loc.Y - plr_y) + (entry->Loc.Z - plr_z)*(entry->Loc.Z - plr_z);
     nearestDistance = distance;
 
     for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
     {
         if (m_PointOwnedByTeam[i] == player->GetTeam() && m_PointState[i] == EY_POINT_UNDER_CONTROL)
         {
             entry = sWorldSafeLocsStore.LookupEntry(m_CapturingPointTypes[i].GraveYardId);
             if (!entry)
                 TC_LOG_ERROR("bg.battleground", "BattlegroundEY: Not found graveyard: %u", m_CapturingPointTypes[i].GraveYardId);
             else
             {
                 distance = (entry->Loc.X - plr_x)*(entry->Loc.X - plr_x) + (entry->Loc.Y - plr_y)*(entry->Loc.Y - plr_y) + (entry->Loc.Z - plr_z)*(entry->Loc.Z - plr_z);
                 if (distance < nearestDistance)
                 {
                     nearestDistance = distance;
                     nearestEntry = entry;
                 }
             }
         }
     }
 
     return nearestEntry;
 }

Here is the call graph for this function:

ObjectGuid BattlegroundEY::GetDroppedFlagGUID ( ) const

inline

386 { return m_DroppedFlagGUID; }

BattlegroundEY::m_DroppedFlagGUID

ObjectGuid m_DroppedFlagGUID

Definition: BattlegroundEY.h:424

Here is the caller graph for this function:

ObjectGuid BattlegroundEY::GetFlagPickerGUID ( int32 = -1 ) const

inlineoverridevirtual

Reimplemented from Battleground.

368 { return m_FlagKeeper; }

BattlegroundEY::m_FlagKeeper

ObjectGuid m_FlagKeeper

Definition: BattlegroundEY.h:423

Here is the caller graph for this function:

uint8 BattlegroundEY::GetFlagState ( ) const

inline

371 { return m_FlagState; }

BattlegroundEY::m_FlagState

uint8 m_FlagState

Definition: BattlegroundEY.h:426

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

overrideprotectedvirtual

Reimplemented from Battleground.

 {
     if (Player* player = ObjectAccessor::GetPlayer(GetBgMap(), m_FlagKeeper))
     {
         WorldPackets::Battleground::BattlegroundPlayerPosition position;
         position.Guid = player->GetGUID();
         position.Pos.x = player->GetPositionX();
         position.Pos.y = player->GetPositionY();
         position.IconID = player->GetTeam() == ALLIANCE ? PLAYER_POSITION_ICON_ALLIANCE_FLAG : 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 BattlegroundEY::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 BattlegroundEY::HandleAreaTrigger	(	Player *	source,
		uint32	trigger,
		bool	entered
	)

overridevirtual

Reimplemented from Battleground.

 {
     if (GetStatus() != STATUS_IN_PROGRESS)
         return;
 
     if (!player->IsAlive())                                  //hack code, must be removed later
         return;
 
     switch (trigger)
     {
         case TR_BLOOD_ELF_POINT:
             if (m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[BLOOD_ELF] == player->GetTeam())
                 if (m_FlagState && GetFlagPickerGUID() == player->GetGUID())
                     EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_BLOOD_ELF);
             break;
         case TR_FEL_REAVER_POINT:
             if (m_PointState[FEL_REAVER] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[FEL_REAVER] == player->GetTeam())
                 if (m_FlagState && GetFlagPickerGUID() == player->GetGUID())
                     EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_FEL_REAVER);
             break;
         case TR_MAGE_TOWER_POINT:
             if (m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[MAGE_TOWER] == player->GetTeam())
                 if (m_FlagState && GetFlagPickerGUID() == player->GetGUID())
                     EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_MAGE_TOWER);
             break;
         case TR_DRAENEI_RUINS_POINT:
             if (m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[DRAENEI_RUINS] == player->GetTeam())
                 if (m_FlagState && GetFlagPickerGUID() == player->GetGUID())
                     EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_DRAENEI_RUINS);
             break;
         case 4512:
         case 4515:
         case 4517:
         case 4519:
         case 4530:
         case 4531:
         case 4568:
         case 4569:
         case 4570:
         case 4571:
         case 5866:
             break;
         default:
             Battleground::HandleAreaTrigger(player, trigger, entered);
             break;
     }
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

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

Here is the call graph for this function:

bool BattlegroundEY::IsAllNodesControlledByTeam ( uint32 team ) const

overridevirtual

Reimplemented from Battleground.

 {
     uint32 count = 0;
     for (int i = 0; i < EY_POINTS_MAX; ++i)
         if (m_PointOwnedByTeam[i] == team && m_PointState[i] == EY_POINT_UNDER_CONTROL)
             ++count;
 
     return count == EY_POINTS_MAX;
 }

bool BattlegroundEY::IsFlagPickedup ( ) const

inline

370 { return !m_FlagKeeper.IsEmpty(); }

BattlegroundEY::m_FlagKeeper

ObjectGuid m_FlagKeeper

Definition: BattlegroundEY.h:423

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 BattlegroundEY::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)
     {
         m_PointAddingTimer -= diff;
         if (m_PointAddingTimer <= 0)
         {
             m_PointAddingTimer = BG_EY_FPOINTS_TICK_TIME;
             if (m_TeamPointsCount[TEAM_ALLIANCE] > 0)
                 AddPoints(ALLIANCE, BG_EY_TickPoints[m_TeamPointsCount[TEAM_ALLIANCE] - 1]);
             if (m_TeamPointsCount[TEAM_HORDE] > 0)
                 AddPoints(HORDE, BG_EY_TickPoints[m_TeamPointsCount[TEAM_HORDE] - 1]);
         }
 
         if (m_FlagState == BG_EY_FLAG_STATE_WAIT_RESPAWN || m_FlagState == BG_EY_FLAG_STATE_ON_GROUND)
         {
             m_FlagsTimer -= diff;
 
             if (m_FlagsTimer < 0)
             {
                 m_FlagsTimer = 0;
                 if (m_FlagState == BG_EY_FLAG_STATE_WAIT_RESPAWN)
                     RespawnFlag(true);
                 else
                     RespawnFlagAfterDrop();
             }
         }
 
         m_TowerCapCheckTimer -= diff;
         if (m_TowerCapCheckTimer <= 0)
         {
             //check if player joined point
             /*I used this order of calls, because although we will check if one player is in gameobject's distance 2 times
               but we can count of players on current point in CheckSomeoneLeftPoint
             */
             this->CheckSomeoneJoinedPoint();
             //check if player left point
             this->CheckSomeoneLeftPoint();
             this->UpdatePointStatuses();
             m_TowerCapCheckTimer = BG_EY_FPOINTS_TICK_TIME;
         }
     }
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
     // sometimes flag aura not removed :(
     for (int j = EY_POINTS_MAX; j >= 0; --j)
     {
         for (size_t i = 0; i < m_PlayersNearPoint[j].size(); ++i)
             if (m_PlayersNearPoint[j][i] == guid)
                 m_PlayersNearPoint[j].erase(m_PlayersNearPoint[j].begin() + i);
     }
     if (IsFlagPickedup())
     {
         if (m_FlagKeeper == guid)
         {
             if (player)
                 EventPlayerDroppedFlag(player);
             else
             {
                 SetFlagPicker(ObjectGuid::Empty);
                 RespawnFlag(true);
             }
         }
     }
 }

Here is the call graph for this function:

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

inlineprivate

415 { 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 BattlegroundEY::Reset ( )

overridevirtual

Reimplemented from Battleground.

 {
     //call parent's class reset
     Battleground::Reset();
 
     m_TeamScores[TEAM_ALLIANCE] = 0;
     m_TeamScores[TEAM_HORDE] = 0;
     m_TeamPointsCount[TEAM_ALLIANCE] = 0;
     m_TeamPointsCount[TEAM_HORDE] = 0;
     m_HonorScoreTics[TEAM_ALLIANCE] = 0;
     m_HonorScoreTics[TEAM_HORDE] = 0;
     m_FlagState = BG_EY_FLAG_STATE_ON_BASE;
     m_FlagCapturedBgObjectType = 0;
     m_FlagKeeper.Clear();
     m_DroppedFlagGUID.Clear();
     m_PointAddingTimer = 0;
     m_TowerCapCheckTimer = 0;
     bool isBGWeekend = sBattlegroundMgr->IsBGWeekend(GetTypeID());
     m_HonorTics = (isBGWeekend) ? BG_EY_EYWeekendHonorTicks : BG_EY_NotEYWeekendHonorTicks;
 
     for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
     {
         m_PointOwnedByTeam[i] = EY_POINT_NO_OWNER;
         m_PointState[i] = EY_POINT_STATE_UNCONTROLLED;
         m_PointBarStatus[i] = BG_EY_PROGRESS_BAR_STATE_MIDDLE;
         m_PlayersNearPoint[i].clear();
         m_PlayersNearPoint[i].reserve(15);                  //tip size
     }
     m_PlayersNearPoint[EY_PLAYERS_OUT_OF_POINTS].clear();
     m_PlayersNearPoint[EY_PLAYERS_OUT_OF_POINTS].reserve(30);
 }

Here is the call graph for this function:

void BattlegroundEY::RespawnFlag ( bool send_message )

 {
     if (m_FlagCapturedBgObjectType > 0)
         SpawnBGObject(m_FlagCapturedBgObjectType, RESPAWN_ONE_DAY);
 
     m_FlagCapturedBgObjectType = 0;
     m_FlagState = BG_EY_FLAG_STATE_ON_BASE;
     SpawnBGObject(BG_EY_OBJECT_FLAG_NETHERSTORM, RESPAWN_IMMEDIATELY);
 
     if (send_message)
     {
         SendMessageToAll(LANG_BG_EY_RESETED_FLAG, CHAT_MSG_BG_SYSTEM_NEUTRAL);
         PlaySoundToAll(BG_EY_SOUND_FLAG_RESET);             // flags respawned sound...
     }
 
     UpdateWorldState(NETHERSTORM_FLAG, 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::RespawnFlagAfterDrop ( )

 {
     RespawnFlag(true);
 
     GameObject* obj = GetBgMap()->GetGameObject(GetDroppedFlagGUID());
     if (obj)
         obj->Delete();
     else
         TC_LOG_ERROR("bg.battleground", "BattlegroundEY: Unknown dropped flag (%s)", GetDroppedFlagGUID().ToString().c_str());
 
     SetDroppedFlagGUID(ObjectGuid::Empty);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineoverridevirtual

Reimplemented from Battleground.

385 { m_DroppedFlagGUID = guid; }

BattlegroundEY::m_DroppedFlagGUID

ObjectGuid m_DroppedFlagGUID

Definition: BattlegroundEY.h:424

Here is the caller graph for this function:

void BattlegroundEY::SetFlagPicker ( ObjectGuid guid )

inline

369 { m_FlagKeeper = guid; }

BattlegroundEY::m_FlagKeeper

ObjectGuid m_FlagKeeper

Definition: BattlegroundEY.h:423

Here is the caller graph for this function:

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

inlineprivate

416 { 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 BattlegroundEY::SetupBattleground ( )

overridevirtual

Reimplemented from Battleground.

 {
         // doors
     if (!AddObject(BG_EY_OBJECT_DOOR_A, BG_OBJECT_A_DOOR_EY_ENTRY, 2527.6f, 1596.91f, 1262.13f, -3.12414f, -0.173642f, -0.001515f, 0.98477f, -0.008594f, RESPAWN_IMMEDIATELY)
         || !AddObject(BG_EY_OBJECT_DOOR_H, BG_OBJECT_H_DOOR_EY_ENTRY, 1803.21f, 1539.49f, 1261.09f, 3.14159f, 0.173648f, 0, 0.984808f, 0, RESPAWN_IMMEDIATELY)
         // banners (alliance)
         || !AddObject(BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_FEL_REAVER_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_FEL_REAVER_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY)
         // banners (horde)
         || !AddObject(BG_EY_OBJECT_H_BANNER_FEL_REAVER_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_FEL_REAVER_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_FEL_REAVER_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY)
         // banners (natural)
         || !AddObject(BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_FEL_REAVER_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_FEL_REAVER_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY)
         // flags
         || !AddObject(BG_EY_OBJECT_FLAG_NETHERSTORM, BG_OBJECT_FLAG2_EY_ENTRY, 2174.782227f, 1569.054688f, 1160.361938f, -1.448624f, 0, 0, 0.662620f, -0.748956f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_FLAG_FEL_REAVER, BG_OBJECT_FLAG1_EY_ENTRY, 2044.28f, 1729.68f, 1189.96f, -0.017453f, 0, 0, 0.008727f, -0.999962f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_FLAG_BLOOD_ELF, BG_OBJECT_FLAG1_EY_ENTRY, 2048.83f, 1393.65f, 1194.49f, 0.20944f, 0, 0, 0.104528f, 0.994522f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_FLAG_DRAENEI_RUINS, BG_OBJECT_FLAG1_EY_ENTRY, 2286.56f, 1402.36f, 1197.11f, 3.72381f, 0, 0, 0.957926f, -0.287016f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_FLAG_MAGE_TOWER, BG_OBJECT_FLAG1_EY_ENTRY, 2284.48f, 1731.23f, 1189.99f, 2.89725f, 0, 0, 0.992546f, 0.121869f, RESPAWN_ONE_DAY)
         // tower cap
         || !AddObject(BG_EY_OBJECT_TOWER_CAP_FEL_REAVER, BG_OBJECT_FR_TOWER_CAP_EY_ENTRY, 2024.600708f, 1742.819580f, 1195.157715f, 2.443461f, 0, 0, 0.939693f, 0.342020f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_TOWER_CAP_BLOOD_ELF, BG_OBJECT_BE_TOWER_CAP_EY_ENTRY, 2050.493164f, 1372.235962f, 1194.563477f, 1.710423f, 0, 0, 0.754710f, 0.656059f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_TOWER_CAP_DRAENEI_RUINS, BG_OBJECT_DR_TOWER_CAP_EY_ENTRY, 2301.010498f, 1386.931641f, 1197.183472f, 1.570796f, 0, 0, 0.707107f, 0.707107f, RESPAWN_ONE_DAY)
         || !AddObject(BG_EY_OBJECT_TOWER_CAP_MAGE_TOWER, BG_OBJECT_HU_TOWER_CAP_EY_ENTRY, 2282.121582f, 1760.006958f, 1189.707153f, 1.919862f, 0, 0, 0.819152f, 0.573576f, RESPAWN_ONE_DAY)
 )
     {
         TC_LOG_ERROR("sql.sql", "BatteGroundEY: Failed to spawn some object Battleground not created!");
         return false;
     }
 
     //buffs
     for (int i = 0; i < EY_POINTS_MAX; ++i)
     {
         AreaTriggerEntry const* at = sAreaTriggerStore.LookupEntry(m_Points_Trigger[i]);
         if (!at)
         {
             TC_LOG_ERROR("bg.battleground", "BattlegroundEY: Unknown trigger: %u", m_Points_Trigger[i]);
             continue;
         }
         if (!AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i * 3, Buff_Entries[0], at->Pos.X, at->Pos.Y, at->Pos.Z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY)
             || !AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i * 3 + 1, Buff_Entries[1], at->Pos.X, at->Pos.Y, at->Pos.Z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY)
             || !AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + i * 3 + 2, Buff_Entries[2], at->Pos.X, at->Pos.Y, at->Pos.Z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY)
 )
             TC_LOG_ERROR("bg.battleground", "BattlegroundEY: Cannot spawn buff");
     }
 
     WorldSafeLocsEntry const* sg = NULL;
     sg = sWorldSafeLocsStore.LookupEntry(EY_GRAVEYARD_MAIN_ALLIANCE);
     if (!sg || !AddSpiritGuide(EY_SPIRIT_MAIN_ALLIANCE, sg->Loc.X, sg->Loc.Y, sg->Loc.Z, 3.124139f, TEAM_ALLIANCE))
     {
         TC_LOG_ERROR("sql.sql", "BatteGroundEY: Failed to spawn spirit guide! Battleground not created!");
         return false;
     }
 
     sg = sWorldSafeLocsStore.LookupEntry(EY_GRAVEYARD_MAIN_HORDE);
     if (!sg || !AddSpiritGuide(EY_SPIRIT_MAIN_HORDE, sg->Loc.X, sg->Loc.Y, sg->Loc.Z, 3.193953f, TEAM_HORDE))
     {
         TC_LOG_ERROR("sql.sql", "BatteGroundEY: Failed to spawn spirit guide! Battleground not created!");
         return false;
     }
 
     return true;
 }

Here is the call graph for this function:

void BattlegroundEY::StartingEventCloseDoors ( )

overridevirtual

Reimplemented from Battleground.

 {
     SpawnBGObject(BG_EY_OBJECT_DOOR_A, RESPAWN_IMMEDIATELY);
     SpawnBGObject(BG_EY_OBJECT_DOOR_H, RESPAWN_IMMEDIATELY);
 
     for (uint32 i = BG_EY_OBJECT_A_BANNER_FEL_REAVER_CENTER; i < BG_EY_OBJECT_MAX; ++i)
         SpawnBGObject(i, RESPAWN_ONE_DAY);
 }

Here is the call graph for this function:

void BattlegroundEY::StartingEventOpenDoors ( )

overridevirtual

Reimplemented from Battleground.

 {
     SpawnBGObject(BG_EY_OBJECT_DOOR_A, RESPAWN_ONE_DAY);
     SpawnBGObject(BG_EY_OBJECT_DOOR_H, RESPAWN_ONE_DAY);
 
     for (uint32 i = BG_EY_OBJECT_N_BANNER_FEL_REAVER_CENTER; i <= BG_EY_OBJECT_FLAG_NETHERSTORM; ++i)
         SpawnBGObject(i, RESPAWN_IMMEDIATELY);
     for (uint32 i = 0; i < EY_POINTS_MAX; ++i)
     {
         //randomly spawn buff
         uint8 buff = urand(0, 2);
         SpawnBGObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REAVER + buff + i * 3, RESPAWN_IMMEDIATELY);
     }
 
     // Achievement: Flurry
     StartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, BG_EY_EVENT_START_BATTLE);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
     if (!Battleground::UpdatePlayerScore(player, type, value, doAddHonor))
         return false;
 
     switch (type)
     {
         case SCORE_FLAG_CAPTURES:
             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, EY_OBJECTIVE_CAPTURE_FLAG);
             break;
         default:
             break;
     }
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::UpdatePointsCount ( uint32 Team )

protected

 {
     if (Team == ALLIANCE)
         UpdateWorldState(EY_ALLIANCE_BASE, m_TeamPointsCount[TEAM_ALLIANCE]);
     else
         UpdateWorldState(EY_HORDE_BASE, m_TeamPointsCount[TEAM_HORDE]);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::UpdatePointsIcons	(	uint32	Team,
		uint32	Point
	)

protected

 {
     //we MUST firstly send 0, after that we can send 1!!!
     if (m_PointState[Point] == EY_POINT_UNDER_CONTROL)
     {
         UpdateWorldState(m_PointsIconStruct[Point].WorldStateControlIndex, 0);
         if (Team == ALLIANCE)
             UpdateWorldState(m_PointsIconStruct[Point].WorldStateAllianceControlledIndex, 1);
         else
             UpdateWorldState(m_PointsIconStruct[Point].WorldStateHordeControlledIndex, 1);
     }
     else
     {
         if (Team == ALLIANCE)
             UpdateWorldState(m_PointsIconStruct[Point].WorldStateAllianceControlledIndex, 0);
         else
             UpdateWorldState(m_PointsIconStruct[Point].WorldStateHordeControlledIndex, 0);
         UpdateWorldState(m_PointsIconStruct[Point].WorldStateControlIndex, 1);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::UpdatePointStatuses ( )

private

The original AreaTrigger is covered by a bigger one and not triggered on client side.

 {
     for (uint8 point = 0; point < EY_POINTS_MAX; ++point)
     {
         if (m_PlayersNearPoint[point].empty())
             continue;
         //count new point bar status:
         m_PointBarStatus[point] += (m_CurrentPointPlayersCount[2 * point] - m_CurrentPointPlayersCount[2 * point + 1] < BG_EY_POINT_MAX_CAPTURERS_COUNT) ? m_CurrentPointPlayersCount[2 * point] - m_CurrentPointPlayersCount[2 * point + 1] : BG_EY_POINT_MAX_CAPTURERS_COUNT;
 
         if (m_PointBarStatus[point] > BG_EY_PROGRESS_BAR_ALI_CONTROLLED)
             //point is fully alliance's
             m_PointBarStatus[point] = BG_EY_PROGRESS_BAR_ALI_CONTROLLED;
         if (m_PointBarStatus[point] < BG_EY_PROGRESS_BAR_HORDE_CONTROLLED)
             //point is fully horde's
             m_PointBarStatus[point] = BG_EY_PROGRESS_BAR_HORDE_CONTROLLED;
 
         uint32 pointOwnerTeamId = 0;
         //find which team should own this point
         if (m_PointBarStatus[point] <= BG_EY_PROGRESS_BAR_NEUTRAL_LOW)
             pointOwnerTeamId = HORDE;
         else if (m_PointBarStatus[point] >= BG_EY_PROGRESS_BAR_NEUTRAL_HIGH)
             pointOwnerTeamId = ALLIANCE;
         else
             pointOwnerTeamId = EY_POINT_NO_OWNER;
 
         for (uint8 i = 0; i < m_PlayersNearPoint[point].size(); ++i)
         {
             Player* player = ObjectAccessor::FindPlayer(m_PlayersNearPoint[point][i]);
             if (player)
             {
                 player->SendUpdateWorldState(PROGRESS_BAR_STATUS, m_PointBarStatus[point]);
                 //if point owner changed we must evoke event!
                 if (pointOwnerTeamId != m_PointOwnedByTeam[point])
                 {
                     //point was uncontrolled and player is from team which captured point
                     if (m_PointState[point] == EY_POINT_STATE_UNCONTROLLED && player->GetTeam() == pointOwnerTeamId)
                         this->EventTeamCapturedPoint(player, point);
 
                     //point was under control and player isn't from team which controlled it
                     if (m_PointState[point] == EY_POINT_UNDER_CONTROL && player->GetTeam() != m_PointOwnedByTeam[point])
                         this->EventTeamLostPoint(player, point);
                 }
 
                 if (point == FEL_REAVER && m_PointOwnedByTeam[point] == player->GetTeam())
                     if (m_FlagState && GetFlagPickerGUID() == player->GetGUID())
                         if (player->GetDistance(2044.0f, 1729.729f, 1190.03f) < 3.0f)
                             EventPlayerCapturedFlag(player, BG_EY_OBJECT_FLAG_FEL_REAVER);
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundEY::UpdateTeamScore ( uint32 Team )

Todo:: there should be some sound played when one team is near victory!! - and define variables

 {
     uint32 score = GetTeamScore(Team);
     /*if (!m_IsInformedNearVictory && score >= BG_EY_WARNING_NEAR_VICTORY_SCORE)
     {
         if (Team == ALLIANCE)
             SendMessageToAll(LANG_BG_EY_A_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);
         else
             SendMessageToAll(LANG_BG_EY_H_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);
         PlaySoundToAll(BG_EY_SOUND_NEAR_VICTORY);
         m_IsInformedNearVictory = true;
     }*/
 
     if (score >= BG_EY_MAX_TEAM_SCORE)
     {
         score = BG_EY_MAX_TEAM_SCORE;
         if (Team == TEAM_ALLIANCE)
             EndBattleground(ALLIANCE);
         else
             EndBattleground(HORDE);
     }
 
     if (Team == TEAM_ALLIANCE)
         UpdateWorldState(EY_ALLIANCE_RESOURCES, score);
     else
         UpdateWorldState(EY_HORDE_RESOURCES, score);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

uint8 BattlegroundEY::m_CurrentPointPlayersCount[2 *EY_POINTS_MAX]

private

ObjectGuid BattlegroundEY::m_DroppedFlagGUID

private

uint32 BattlegroundEY::m_FlagCapturedBgObjectType

private

ObjectGuid BattlegroundEY::m_FlagKeeper

private

uint8 BattlegroundEY::m_FlagState

private

int32 BattlegroundEY::m_FlagsTimer

private

uint32 BattlegroundEY::m_HonorScoreTics[2]

private

uint32 BattlegroundEY::m_HonorTics

private

GuidVector BattlegroundEY::m_PlayersNearPoint[EY_POINTS_MAX+1]

private

int32 BattlegroundEY::m_PointAddingTimer

private

int32 BattlegroundEY::m_PointBarStatus[EY_POINTS_MAX]

private

uint32 BattlegroundEY::m_PointOwnedByTeam[EY_POINTS_MAX]

private

uint32 BattlegroundEY::m_Points_Trigger[EY_POINTS_MAX]

private

uint8 BattlegroundEY::m_PointState[EY_POINTS_MAX]

private

uint32 BattlegroundEY::m_TeamPointsCount[2]

private

int32 BattlegroundEY::m_TowerCapCheckTimer

private

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

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

Private Attributes
uint32	m_HonorScoreTics [2]

uint32	m_TeamPointsCount [2]

uint32	m_Points_Trigger [EY_POINTS_MAX]

ObjectGuid	m_FlagKeeper

ObjectGuid	m_DroppedFlagGUID

uint32	m_FlagCapturedBgObjectType

uint8	m_FlagState

int32	m_FlagsTimer

int32	m_TowerCapCheckTimer

uint32	m_PointOwnedByTeam [EY_POINTS_MAX]

uint8	m_PointState [EY_POINTS_MAX]

int32	m_PointBarStatus [EY_POINTS_MAX]

GuidVector	m_PlayersNearPoint [EY_POINTS_MAX+1]

uint8	m_CurrentPointPlayersCount [2 *EY_POINTS_MAX]

int32	m_PointAddingTimer

uint32	m_HonorTics

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation