#include <BattlefieldWG.h>

Public Member Functions
	~BattlefieldWG ()

void	OnBattleStart () override
	Called when the battle start. More...

void	OnBattleEnd (bool endByTimer) override
	Called when battle end. More...

void	OnStartGrouping () override
	Called when grouping starts (15 minutes before battlestart) More...

void	OnPlayerJoinWar (Player *player) override
	Called when player accept invite to join battle. More...

void	OnPlayerLeaveWar (Player *player) override
	Called when player left the battle. More...

void	OnPlayerLeaveZone (Player *player) override
	Called when player left the WG zone. More...

void	OnPlayerEnterZone (Player *player) override
	Called when player enters in WG zone. More...

bool	Update (uint32 diff) override
	Called for update battlefield data. More...

void	OnCreatureCreate (Creature *creature) override
	Called when a creature is created. More...

void	OnCreatureRemove (Creature *creature) override
	Called when a creature is removed. More...

void	OnGameObjectCreate (GameObject *go) override
	Called when a gameobject is created. More...

void	BrokenWallOrTower (TeamId team)
	Called when a wall/tower is broken. More...

void	UpdateDamagedTowerCount (TeamId team)
	Called when a tower is damaged. More...

void	UpdatedDestroyedTowerCount (TeamId team)
	Called when tower is broken. More...

void	DoCompleteOrIncrementAchievement (uint32 achievement, Player *player, uint8 incrementNumber=1) override

void	RemoveAurasFromPlayer (Player *player)

bool	SetupBattlefield () override
	Called when battlefield is setup, at server start. More...

GameObject *	GetRelic ()
	Return pointer to relic object. More...

void	SetRelic (ObjectGuid relicGUID)
	Define relic object. More...

bool	CanInteractWithRelic ()
	Check if players can interact with the relic (Only if the last door has been broken) More...

void	SetRelicInteractible (bool allow)
	Define if player can interact with the relic. More...

void	UpdateVehicleCountWG ()

void	UpdateCounterVehicle (bool init)

void	SendInitWorldStatesTo (Player *player)

void	SendInitWorldStatesToAll () override
	Send all worldstate data to all player in zone. More...

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

void	HandleKill (Player killer, Unit victim) override
	Called when a Unit is kill in battlefield zone. More...

void	OnUnitDeath (Unit *unit) override

void	PromotePlayer (Player *killer)

void	UpdateTenacity ()

void	ProcessEvent (WorldObject *obj, uint32 eventId) override

bool	FindAndRemoveVehicleFromList (Unit *vehicle)

uint8	GetSpiritGraveyardId (uint32 areaId) const

uint32	GetData (uint32 data) const override

Public Member Functions inherited from Battlefield
	Battlefield ()
	Constructor. More...

virtual	~Battlefield ()
	Destructor. More...

void	SendUpdateWorldState (uint32 variable, uint32 value, bool hidden=false)
	Update data of a worldstate to all players present in zone. More...

void	InvitePlayersInZoneToQueue ()
	Invite all players in zone to join the queue, called x minutes before battle start in Update() More...

void	InvitePlayersInQueueToWar ()
	Invite all players in queue to join battle on battle start. More...

void	InvitePlayersInZoneToWar ()
	Invite all players in zone to join battle on battle start. More...

uint32	GetTypeId () const

uint32	GetZoneId () const

uint64	GetQueueId () const

void	TeamApplyBuff (TeamId team, uint32 spellId, uint32 spellId2=0)

bool	IsWarTime () const
	Return true if battle is start, false if battle is not started. More...

int8	GetState () const

void	ToggleBattlefield (bool enable)
	Enable or Disable battlefield. More...

bool	IsEnabled () const
	Return if battlefield is enable. More...

void	KickPlayerFromBattlefield (ObjectGuid guid)
	Kick player from battlefield and teleport him to kick-point location. More...

void	HandlePlayerEnterZone (Player *player, uint32 zone)
	Called when player (player) enter in zone. More...

void	HandlePlayerLeaveZone (Player *player, uint32 zone)
	Called when player (player) leave the zone. More...

virtual uint64	GetData64 (uint32 dataId) const override

virtual void	SetData64 (uint32 dataId, uint64 value) override

virtual void	SetData (uint32 dataId, uint32 value) override

virtual void	UpdateData (uint32 index, int32 pad)

TeamId	GetDefenderTeam () const

TeamId	GetAttackerTeam () const

TeamId	GetOtherTeam (TeamId team) const

void	SetDefenderTeam (TeamId team)

Group *	GetFreeBfRaid (TeamId TeamId)
	Find a not full battlefield group, if there is no, create one. More...

Group *	GetGroupPlayer (ObjectGuid guid, TeamId TeamId)
	Return battlefield group where player is. More...

bool	AddOrSetPlayerToCorrectBfGroup (Player *player)
	Force player to join a battlefield group. More...

WorldSafeLocsEntry const *	GetClosestGraveYard (Player *player)

virtual void	AddPlayerToResurrectQueue (ObjectGuid npc_guid, ObjectGuid player_guid)

void	RemovePlayerFromResurrectQueue (ObjectGuid player_guid)

void	SetGraveyardNumber (uint32 number)

BfGraveyard *	GetGraveyardById (uint32 id) const

virtual Creature *	SpawnCreature (uint32 entry, float x, float y, float z, float o, TeamId)

Creature *	SpawnCreature (uint32 entry, Position const &pos, TeamId)

GameObject *	SpawnGameObject (uint32 entry, float x, float y, float z, float o)

Creature *	GetCreature (ObjectGuid guid)

GameObject *	GetGameObject (ObjectGuid guid)

void	SendWarning (uint8 id, WorldObject const *target=nullptr)

void	PlayerAcceptInviteToQueue (Player *player)

void	PlayerAcceptInviteToWar (Player *player)

uint32	GetBattleId () const

void	AskToLeaveQueue (Player *player)

bool	CanFlyIn ()
	Return if we can use mount in battlefield. More...

void	SendAreaSpiritHealerQueryOpcode (Player *player, ObjectGuid const &guid)

void	StartBattle ()

void	EndBattle (bool endByTimer)

void	HideNpc (Creature *creature)

void	ShowNpc (Creature *creature, bool aggressive)

GraveyardVect	GetGraveyardVector () const

uint32	GetTimer () const

void	SetTimer (uint32 timer)

void	DoPlaySoundToAll (uint32 SoundID)

void	InvitePlayerToQueue (Player *player)

void	InvitePlayerToWar (Player *player)

void	InitStalker (uint32 entry, Position const &pos)

Public Member Functions inherited from ZoneScript
	ZoneScript ()

virtual	~ZoneScript ()

virtual uint32	GetCreatureEntry (ObjectGuid::LowType, CreatureData const *data)

virtual uint32	GetGameObjectEntry (ObjectGuid::LowType, uint32 entry)

virtual void	OnGameObjectRemove (GameObject *)

virtual ObjectGuid	GetGuidData (uint32) const

virtual void	SetGuidData (uint32, ObjectGuid)

Protected Attributes
bool	m_isRelicInteractible

WorkshopSet	Workshops

GuidSet	DefenderPortalList

GuidSet	m_KeepGameObject [BG_TEAMS_COUNT]

GameObjectBuildingSet	BuildingsInZone

GuidSet	m_vehicles [BG_TEAMS_COUNT]

GuidSet	CanonList

GuidSet	KeepCreature [BG_TEAMS_COUNT]

GuidSet	OutsideCreature [BG_TEAMS_COUNT]

uint32	m_tenacityStack

uint32	m_saveTimer

ObjectGuid	m_titansRelicGUID

Protected Attributes inherited from Battlefield
ObjectGuid	StalkerGuid

uint32	m_Timer

bool	m_IsEnabled

bool	m_isActive

TeamId	m_DefenderTeam

BfCapturePointMap	m_capturePoints

GuidSet	m_players [BG_TEAMS_COUNT]

GuidSet	m_PlayersInQueue [BG_TEAMS_COUNT]

GuidSet	m_PlayersInWar [BG_TEAMS_COUNT]

PlayerTimerMap	m_InvitedPlayers [BG_TEAMS_COUNT]

PlayerTimerMap	m_PlayersWillBeKick [BG_TEAMS_COUNT]

uint32	m_TypeId

uint32	m_BattleId

uint32	m_ZoneId

uint32	m_MapId

Map *	m_Map

uint32	m_MaxPlayer

uint32	m_MinPlayer

uint32	m_MinLevel

uint32	m_BattleTime

uint32	m_NoWarBattleTime

uint32	m_RestartAfterCrash

uint32	m_TimeForAcceptInvite

uint32	m_uiKickDontAcceptTimer

WorldLocation	KickPosition

uint32	m_uiKickAfkPlayersTimer

GraveyardVect	m_GraveyardList

uint32	m_LastResurrectTimer

uint32	m_StartGroupingTimer

bool	m_StartGrouping

GuidSet	m_Groups [BG_TEAMS_COUNT]

std::vector< uint64 >	m_Data64

std::vector< uint32 >	m_Data32

Additional Inherited Members
Public Types inherited from Battlefield
typedef std::map< uint32, BfCapturePoint * >	BfCapturePointMap
	typedef of map witch store capturepoint and the associate gameobject entry More...

Protected Member Functions inherited from Battlefield
void	KickAfkPlayers ()

virtual void	SendRemoveWorldStates (Player *)

void	BroadcastPacketToZone (WorldPacket const *data) const

void	BroadcastPacketToQueue (WorldPacket const *data) const

void	BroadcastPacketToWar (WorldPacket const *data) const

void	AddCapturePoint (BfCapturePoint *cp)

BfCapturePoint *	GetCapturePoint (uint32 entry) const

void	RegisterZone (uint32 zoneid)

bool	HasPlayer (Player *player) const

void	TeamCastSpell (TeamId team, int32 spellId)

Constructor & Destructor Documentation

BattlefieldWG::~BattlefieldWG ( )

Todo:

Implement proper support for vehicle+player teleportation

Use spell victory/defeat in wg instead of RewardMarkOfHonor() && RewardHonor

Add proper implement of achievement

 {
  for (WintergraspWorkshop* workshop : Workshops)
  delete workshop;
 
  for (BfWGGameObjectBuilding* building : BuildingsInZone)
  delete building;
 }

Member Function Documentation

void BattlefieldWG::BrokenWallOrTower ( TeamId team )

Called when a wall/tower is broken.

Update quest

 {
 // might be some use for this in the future. old code commented out below. KL
 /* if (team == GetDefenderTeam())
  {
  for (GuidSet::const_iterator itr = m_PlayersInWar[GetAttackerTeam()].begin(); itr != m_PlayersInWar[GetAttackerTeam()].end(); ++itr)
  {
  if (Player* player = ObjectAccessor::FindPlayer(*itr))
  IncrementQuest(player, WGQuest[player->GetTeamId()][2], true);
  }
  }*/
 }

Here is the caller graph for this function:

bool BattlefieldWG::CanInteractWithRelic ( )

inline

Check if players can interact with the relic (Only if the last door has been broken)

389 { return m_isRelicInteractible; }

BattlefieldWG::m_isRelicInteractible

bool m_isRelicInteractible

Definition: BattlefieldWG.h:416

Here is the caller graph for this function:

void BattlefieldWG::DoCompleteOrIncrementAchievement	(	uint32	achievement,
		Player *	player,
		uint8	incrementNumber = `1`
	)

overridevirtual

Reimplemented from Battlefield.

 {
  AchievementEntry const* achievementEntry = sAchievementMgr->GetAchievement(achievement);
 
  if (!achievementEntry)
  return;
 
  switch (achievement)
  {
  case ACHIEVEMENTS_WIN_WG_100:
  {
  // player->UpdateAchievementCriteria();
  }
  default:
  {
  if (player)
  player->CompletedAchievement(achievementEntry);
  break;
  }
  }
 
 }

Here is the caller graph for this function:

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

overridevirtual

Implements Battlefield.

 {
  packet.Worldstates.emplace_back(uint32(BATTLEFIELD_WG_WORLD_STATE_ATTACKER), int32(GetAttackerTeam()));
  packet.Worldstates.emplace_back(uint32(BATTLEFIELD_WG_WORLD_STATE_DEFENDER), int32(GetDefenderTeam()));
  // Note: cleanup these two, their names look awkward
  packet.Worldstates.emplace_back(uint32(BATTLEFIELD_WG_WORLD_STATE_ACTIVE), int32(IsWarTime() ? 0 : 1));
  packet.Worldstates.emplace_back(uint32(BATTLEFIELD_WG_WORLD_STATE_SHOW_WORLDSTATE), int32(IsWarTime() ? 1 : 0));
 
  for (uint32 i = 0; i < 2; ++i)
  packet.Worldstates.emplace_back(ClockWorldState[i], int32(time(NULL) + (m_Timer / 1000)));
 
  packet.Worldstates.emplace_back(uint32(BATTLEFIELD_WG_WORLD_STATE_VEHICLE_H), int32(GetData(BATTLEFIELD_WG_DATA_VEHICLE_H)));
  packet.Worldstates.emplace_back(uint32(BATTLEFIELD_WG_WORLD_STATE_MAX_VEHICLE_H), int32(GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_H)));
  packet.Worldstates.emplace_back(uint32(BATTLEFIELD_WG_WORLD_STATE_VEHICLE_A), int32(GetData(BATTLEFIELD_WG_DATA_VEHICLE_A)));
  packet.Worldstates.emplace_back(uint32(BATTLEFIELD_WG_WORLD_STATE_MAX_VEHICLE_A), int32(GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A)));
 
  for (BfWGGameObjectBuilding* building : BuildingsInZone)
  building->FillInitialWorldStates(packet);
 
  for (WintergraspWorkshop* workshop : Workshops)
  workshop->FillInitialWorldStates(packet);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool BattlefieldWG::FindAndRemoveVehicleFromList ( Unit * vehicle )

 {
  for (uint32 itr = 0; itr < 2; ++itr)
  {
  if (m_vehicles[itr].find(vehicle->GetGUID()) != m_vehicles[itr].end())
  {
  m_vehicles[itr].erase(vehicle->GetGUID());
  if (itr == TEAM_HORDE)
  UpdateData(BATTLEFIELD_WG_DATA_VEHICLE_H, -1);
  else
  UpdateData(BATTLEFIELD_WG_DATA_VEHICLE_A, -1);
  return true;
  }
  }
  return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 BattlefieldWG::GetData ( uint32 data ) const

overridevirtual

Reimplemented from Battlefield.

 {
  switch (data)
  {
  // Used to determine when the phasing spells must be cast
  // See: SpellArea::IsFitToRequirements
  case AREA_THE_SUNKEN_RING:
  case AREA_THE_BROKEN_TEMPLATE:
  case AREA_WESTPARK_WORKSHOP:
  case AREA_EASTPARK_WORKSHOP:
  // Graveyards and Workshops are controlled by the same team.
  if (BfGraveyard const* graveyard = GetGraveyardById(GetSpiritGraveyardId(data)))
  return graveyard->GetControlTeamId();
  break;
  default:
  break;
  }
 
  return Battlefield::GetData(data);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

GameObject* BattlefieldWG::GetRelic ( )

inline

Return pointer to relic object.

383 { return GetGameObject(m_titansRelicGUID); }

BattlefieldWG::m_titansRelicGUID

ObjectGuid m_titansRelicGUID

Definition: BattlefieldWG.h:432

Battlefield::GetGameObject

GameObject * GetGameObject(ObjectGuid guid)

Definition: Battlefield.cpp:852

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 BattlefieldWG::GetSpiritGraveyardId ( uint32 areaId ) const

 {
  switch (areaId)
  {
  case AREA_WINTERGRASP_FORTRESS:
  return BATTLEFIELD_WG_GY_KEEP;
  case AREA_THE_SUNKEN_RING:
  return BATTLEFIELD_WG_GY_WORKSHOP_NE;
  case AREA_THE_BROKEN_TEMPLATE:
  return BATTLEFIELD_WG_GY_WORKSHOP_NW;
  case AREA_WESTPARK_WORKSHOP:
  return BATTLEFIELD_WG_GY_WORKSHOP_SW;
  case AREA_EASTPARK_WORKSHOP:
  return BATTLEFIELD_WG_GY_WORKSHOP_SE;
  case AREA_WINTERGRASP:
  return BATTLEFIELD_WG_GY_ALLIANCE;
  case AREA_THE_CHILLED_QUAGMIRE:
  return BATTLEFIELD_WG_GY_HORDE;
  default:
  TC_LOG_ERROR("bg.battlefield", "BattlefieldWG::GetSpiritGraveyardId: Unexpected Area Id %u", areaId);
  break;
  }
 
  return 0;
 }

Here is the caller graph for this function:

void BattlefieldWG::HandleKill	(	Player *	,
		Unit *
	)

overridevirtual

Called when a Unit is kill in battlefield zone.

PvP activity worldstate

Reimplemented from Battlefield.

 {
  if (killer == victim)
  return;
 
  bool again = false;
  TeamId killerTeam = killer->GetTeamId();
 
  if (victim->GetTypeId() == TYPEID_PLAYER)
  {
  for (GuidSet::const_iterator itr = m_PlayersInWar[killerTeam].begin(); itr != m_PlayersInWar[killerTeam].end(); ++itr)
  if (Player* player = ObjectAccessor::FindPlayer(*itr))
  if (player->GetDistance2d(killer) < 40)
  PromotePlayer(player);
  return;
  }
 
  for (GuidSet::const_iterator itr = KeepCreature[GetOtherTeam(killerTeam)].begin();
  itr != KeepCreature[GetOtherTeam(killerTeam)].end(); ++itr)
  {
  if (Creature* creature = GetCreature(*itr))
  {
  if (victim->GetEntry() == creature->GetEntry() && !again)
  {
  again = true;
  for (GuidSet::const_iterator iter = m_PlayersInWar[killerTeam].begin(); iter != m_PlayersInWar[killerTeam].end(); ++iter)
  if (Player* player = ObjectAccessor::FindPlayer(*iter))
  if (player->GetDistance2d(killer) < 40.0f)
  PromotePlayer(player);
  }
  }
  }
 }

Here is the call graph for this function:

void BattlefieldWG::OnBattleEnd ( bool endByTimer )

overridevirtual

Called when battle end.

Remove relic and turret
Change banner/npc in keep if it needed
Saving battlestate
Reward honor/mark to player
Remove vehicle
Parameters

endByTimer : true if battle ended when timer is at 00:00, false if battle ended by clicking on relic

Reimplemented from Battlefield.

 {
  // Remove relic
  if (!m_titansRelicGUID.IsEmpty())
  if (GameObject* relic = GetGameObject(m_titansRelicGUID))
  relic->RemoveFromWorld();
  m_titansRelicGUID.Clear();
 
  // Remove turret
  for (GuidSet::const_iterator itr = CanonList.begin(); itr != CanonList.end(); ++itr)
  {
  if (Creature* creature = GetCreature(*itr))
  {
  if (!endByTimer)
  creature->setFaction(WintergraspFaction[GetDefenderTeam()]);
  HideNpc(creature);
  }
  }
 
  if (!endByTimer) // One player triggered the relic
  {
  // Change all npc in keep
  for (GuidSet::const_iterator itr = KeepCreature[GetAttackerTeam()].begin(); itr != KeepCreature[GetAttackerTeam()].end(); ++itr)
  if (Creature* creature = GetCreature(*itr))
  HideNpc(creature);
 
  for (GuidSet::const_iterator itr = KeepCreature[GetDefenderTeam()].begin(); itr != KeepCreature[GetDefenderTeam()].end(); ++itr)
  if (Creature* creature = GetCreature(*itr))
  ShowNpc(creature, true);
 
  // Change all npc out of keep
  for (GuidSet::const_iterator itr = OutsideCreature[GetDefenderTeam()].begin(); itr != OutsideCreature[GetDefenderTeam()].end(); ++itr)
  if (Creature* creature = GetCreature(*itr))
  HideNpc(creature);
 
  for (GuidSet::const_iterator itr = OutsideCreature[GetAttackerTeam()].begin(); itr != OutsideCreature[GetAttackerTeam()].end(); ++itr)
  if (Creature* creature = GetCreature(*itr))
  ShowNpc(creature, true);
  }
 
  // Update all graveyard, control is to defender when no wartime
  for (uint8 i = 0; i < BATTLEFIELD_WG_GY_HORDE; i++)
  if (BfGraveyard* graveyard = GetGraveyardById(i))
  graveyard->GiveControlTo(GetDefenderTeam());
 
  for (GuidSet::const_iterator itr = m_KeepGameObject[GetDefenderTeam()].begin(); itr != m_KeepGameObject[GetDefenderTeam()].end(); ++itr)
  if (GameObject* object = GetGameObject(*itr))
  object->SetRespawnTime(RESPAWN_IMMEDIATELY);
 
  for (GuidSet::const_iterator itr = m_KeepGameObject[GetAttackerTeam()].begin(); itr != m_KeepGameObject[GetAttackerTeam()].end(); ++itr)
  if (GameObject* object = GetGameObject(*itr))
  object->SetRespawnTime(RESPAWN_ONE_DAY);
 
  // Update portal defender faction
  for (GuidSet::const_iterator itr = DefenderPortalList.begin(); itr != DefenderPortalList.end(); ++itr)
  if (GameObject* portal = GetGameObject(*itr))
  portal->SetFaction(WintergraspFaction[GetDefenderTeam()]);
 
  // Saving data
  for (BfWGGameObjectBuilding* building : BuildingsInZone)
  building->Save();
 
  for (WintergraspWorkshop* workshop : Workshops)
  workshop->Save();
 
  for (GuidSet::const_iterator itr = m_PlayersInWar[GetDefenderTeam()].begin(); itr != m_PlayersInWar[GetDefenderTeam()].end(); ++itr)
  {
  if (Player* player = ObjectAccessor::FindPlayer(*itr))
  {
  player->CastSpell(player, SPELL_ESSENCE_OF_WINTERGRASP, true);
  player->CastSpell(player, SPELL_VICTORY_REWARD, true);
  // Send Wintergrasp victory achievement
  DoCompleteOrIncrementAchievement(ACHIEVEMENTS_WIN_WG, player);
  // Award achievement for succeeding in Wintergrasp in 10 minutes or less
  if (!endByTimer && GetTimer() <= 10000)
  DoCompleteOrIncrementAchievement(ACHIEVEMENTS_WIN_WG_TIMER_10, player);
  }
  }
 
  for (GuidSet::const_iterator itr = m_PlayersInWar[GetAttackerTeam()].begin(); itr != m_PlayersInWar[GetAttackerTeam()].end(); ++itr)
  if (Player* player = ObjectAccessor::FindPlayer(*itr))
  player->CastSpell(player, SPELL_DEFEAT_REWARD, true);
 
  for (uint8 team = 0; team < 2; ++team)
  {
  for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
  if (Player* player = ObjectAccessor::FindPlayer(*itr))
  RemoveAurasFromPlayer(player);
 
  m_PlayersInWar[team].clear();
 
  for (GuidSet::const_iterator itr = m_vehicles[team].begin(); itr != m_vehicles[team].end(); ++itr)
  if (Creature* creature = GetCreature(*itr))
  if (creature->IsVehicle())
  creature->DespawnOrUnsummon();
 
  m_vehicles[team].clear();
  }
 
  if (!endByTimer)
  {
  for (uint8 team = 0; team < 2; ++team)
  {
  for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
  {
  if (Player* player = ObjectAccessor::FindPlayer(*itr))
  {
  player->RemoveAurasDueToSpell(m_DefenderTeam == TEAM_ALLIANCE ? SPELL_HORDE_CONTROL_PHASE_SHIFT : SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, player->GetGUID());
  player->AddAura(m_DefenderTeam == TEAM_HORDE ? SPELL_HORDE_CONTROL_PHASE_SHIFT : SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, player);
  }
  }
  }
  }
 
  if (!endByTimer) // win alli/horde
  SendWarning(GetDefenderTeam() == TEAM_ALLIANCE ? BATTLEFIELD_WG_TEXT_FORTRESS_CAPTURE_ALLIANCE : BATTLEFIELD_WG_TEXT_FORTRESS_CAPTURE_HORDE);
  else // defend alli/horde
  SendWarning(GetDefenderTeam() == TEAM_ALLIANCE ? BATTLEFIELD_WG_TEXT_FORTRESS_DEFEND_ALLIANCE : BATTLEFIELD_WG_TEXT_FORTRESS_DEFEND_HORDE);
 }

Here is the call graph for this function:

void BattlefieldWG::OnBattleStart ( )

overridevirtual

Called when the battle start.

Spawn relic and turret
Rebuild tower and wall
Invite player to war

Reimplemented from Battlefield.

 {
  // Spawn titan relic
  if (GameObject* relic = SpawnGameObject(GO_WINTERGRASP_TITAN_S_RELIC, 5440.0f, 2840.8f, 430.43f, 0))
  {
  // Update faction of relic, only attacker can click on
  relic->SetFaction(WintergraspFaction[GetAttackerTeam()]);
  // Set in use (not allow to click on before last door is broken)
  relic->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_IN_USE);
  m_titansRelicGUID = relic->GetGUID();
  }
  else
  TC_LOG_ERROR("bg.battlefield", "WG: Failed to spawn titan relic.");
 
 
  // Update tower visibility and update faction
  for (GuidSet::const_iterator itr = CanonList.begin(); itr != CanonList.end(); ++itr)
  {
  if (Creature* creature = GetCreature(*itr))
  {
  ShowNpc(creature, true);
  creature->setFaction(WintergraspFaction[GetDefenderTeam()]);
  }
  }
 
  // Rebuild all wall
  for (BfWGGameObjectBuilding* building : BuildingsInZone)
  {
  building->Rebuild();
  building->UpdateTurretAttack(false);
  }
 
  SetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT, 0);
  SetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_DEF, 0);
  SetData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT, 0);
  SetData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_DEF, 0);
 
  // Update graveyard (in no war time all graveyard is to deffender, in war time, depend of base)
  for (WintergraspWorkshop* workshop : Workshops)
  workshop->UpdateGraveyardAndWorkshop();
 
  for (uint8 team = 0; team < 2; ++team)
  for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
  {
  // Kick player in orb room, TODO: offline player ?
  if (Player* player = ObjectAccessor::FindPlayer(*itr))
  {
  float x, y, z;
  player->GetPosition(x, y, z);
  if (5500 > x && x > 5392 && y < 2880 && y > 2800 && z < 480)
  player->TeleportTo(571, 5349.8686f, 2838.481f, 409.240f, 0.046328f);
  SendInitWorldStatesTo(player);
  }
  }
  // Initialize vehicle counter
  UpdateCounterVehicle(true);
  // Send start warning to all players
  SendWarning(BATTLEFIELD_WG_TEXT_START_BATTLE);
 }

Here is the call graph for this function:

void BattlefieldWG::OnCreatureCreate ( Creature * creature )

overridevirtual

Called when a creature is created.

Update vehicle count

Reimplemented from ZoneScript.

 {
  // Accessing to db spawned creatures
  switch (creature->GetEntry())
  {
  case NPC_DWARVEN_SPIRIT_GUIDE:
  case NPC_TAUNKA_SPIRIT_GUIDE:
  {
  TeamId teamId = (creature->GetEntry() == NPC_DWARVEN_SPIRIT_GUIDE ? TEAM_ALLIANCE : TEAM_HORDE);
  uint8 graveyardId = GetSpiritGraveyardId(creature->GetAreaId());
  if (m_GraveyardList[graveyardId])
  m_GraveyardList[graveyardId]->SetSpirit(creature, teamId);
  break;
  }
  }
 
  // untested code - not sure if it is valid.
  if (IsWarTime())
  {
  switch (creature->GetEntry())
  {
  case NPC_WINTERGRASP_SIEGE_ENGINE_ALLIANCE:
  case NPC_WINTERGRASP_SIEGE_ENGINE_HORDE:
  case NPC_WINTERGRASP_CATAPULT:
  case NPC_WINTERGRASP_DEMOLISHER:
  {
  if (!creature->ToTempSummon() || !creature->ToTempSummon()->GetSummonerGUID() || !ObjectAccessor::FindPlayer(creature->ToTempSummon()->GetSummonerGUID()))
  {
  creature->DespawnOrUnsummon();
  return;
  }
 
  Player* creator = ObjectAccessor::FindPlayer(creature->ToTempSummon()->GetSummonerGUID());
  TeamId team = creator->GetTeamId();
 
  if (team == TEAM_HORDE)
  {
  if (GetData(BATTLEFIELD_WG_DATA_VEHICLE_H) < GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_H))
  {
  UpdateData(BATTLEFIELD_WG_DATA_VEHICLE_H, 1);
  creature->AddAura(SPELL_HORDE_FLAG, creature);
  m_vehicles[team].insert(creature->GetGUID());
  UpdateVehicleCountWG();
  }
  else
  {
  creature->DespawnOrUnsummon();
  return;
  }
  }
  else
  {
  if (GetData(BATTLEFIELD_WG_DATA_VEHICLE_A) < GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A))
  {
  UpdateData(BATTLEFIELD_WG_DATA_VEHICLE_A, 1);
  creature->AddAura(SPELL_ALLIANCE_FLAG, creature);
  m_vehicles[team].insert(creature->GetGUID());
  UpdateVehicleCountWG();
  }
  else
  {
  creature->DespawnOrUnsummon();
  return;
  }
  }
 
  creature->CastSpell(creator, SPELL_GRAB_PASSENGER, true);
  break;
  }
  }
  }
 }

Here is the call graph for this function:

void BattlefieldWG::OnCreatureRemove ( Creature * creature )

overridevirtual

Called when a creature is removed.

Update vehicle count

Reimplemented from ZoneScript.

 {
 /* possibly can be used later
  if (IsWarTime())
  {
  switch (creature->GetEntry())
  {
  case NPC_WINTERGRASP_SIEGE_ENGINE_ALLIANCE:
  case NPC_WINTERGRASP_SIEGE_ENGINE_HORDE:
  case NPC_WINTERGRASP_CATAPULT:
  case NPC_WINTERGRASP_DEMOLISHER:
  {
  uint8 team;
  if (creature->getFaction() == WintergraspFaction[TEAM_ALLIANCE])
  team = TEAM_ALLIANCE;
  else if (creature->getFaction() == WintergraspFaction[TEAM_HORDE])
  team = TEAM_HORDE;
  else
  return;
 
  m_vehicles[team].erase(creature->GetGUID());
  if (team == TEAM_HORDE)
  UpdateData(BATTLEFIELD_WG_DATA_VEHICLE_H, -1);
  else
  UpdateData(BATTLEFIELD_WG_DATA_VEHICLE_A, -1);
  UpdateVehicleCountWG();
 
  break;
  }
  }
  }*/
 }

void BattlefieldWG::OnGameObjectCreate ( GameObject * go )

overridevirtual

Called when a gameobject is created.

Reimplemented from ZoneScript.

 {
  uint8 workshopId = 0;
 
  switch (go->GetEntry())
  {
  case GO_WINTERGRASP_FACTORY_BANNER_NE:
  workshopId = BATTLEFIELD_WG_WORKSHOP_NE;
  break;
  case GO_WINTERGRASP_FACTORY_BANNER_NW:
  workshopId = BATTLEFIELD_WG_WORKSHOP_NW;
  break;
  case GO_WINTERGRASP_FACTORY_BANNER_SE:
  workshopId = BATTLEFIELD_WG_WORKSHOP_SE;
  break;
  case GO_WINTERGRASP_FACTORY_BANNER_SW:
  workshopId = BATTLEFIELD_WG_WORKSHOP_SW;
  break;
  default:
  return;
  }
 
  for (WintergraspWorkshop* workshop : Workshops)
  {
  if (workshop->GetId() == workshopId)
  {
  WintergraspCapturePoint* capturePoint = new WintergraspCapturePoint(this, GetAttackerTeam());
 
  capturePoint->SetCapturePointData(go);
  capturePoint->LinkToWorkshop(workshop);
  AddCapturePoint(capturePoint);
  break;
  }
  }
 }

Here is the call graph for this function:

void BattlefieldWG::OnPlayerEnterZone ( Player * player )

overridevirtual

Called when player enters in WG zone.

Update aura
Update worldstate
Parameters

player : Player who enters the zone

Reimplemented from Battlefield.

 {
  if (!m_isActive)
  RemoveAurasFromPlayer(player);
 
  player->AddAura(m_DefenderTeam == TEAM_HORDE ? SPELL_HORDE_CONTROL_PHASE_SHIFT : SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, player);
  // Send worldstate to player
  SendInitWorldStatesTo(player);
 }

Here is the call graph for this function:

void BattlefieldWG::OnPlayerJoinWar ( Player * player )

overridevirtual

Called when player accept invite to join battle.

Update aura
Teleport if it needed
Update worldstate
Update tenacity
Parameters

player Player who accepted invite

Reimplemented from Battlefield.

 {
     RemoveAurasFromPlayer(player);
 
     player->CastSpell(player, SPELL_RECRUIT, true);
 
     if (player->GetZoneId() != m_ZoneId)
     {
         if (player->GetTeamId() == GetDefenderTeam())
             player->TeleportTo(571, 5345, 2842, 410, 3.14f);
         else
         {
             if (player->GetTeamId() == TEAM_HORDE)
                 player->TeleportTo(571, 5025.857422f, 3674.628906f, 362.737122f, 4.135169f);
             else
                 player->TeleportTo(571, 5101.284f, 2186.564f, 373.549f, 3.812f);
         }
     }
 
     UpdateTenacity();
 
     if (player->GetTeamId() == GetAttackerTeam())
     {
         if (GetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT) < 3)
             player->SetAuraStack(SPELL_TOWER_CONTROL, player, 3 - GetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT));
     }
     else
     {
         if (GetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT) > 0)
            player->SetAuraStack(SPELL_TOWER_CONTROL, player, GetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT));
     }
     SendInitWorldStatesTo(player);
 }

Here is the call graph for this function:

void BattlefieldWG::OnPlayerLeaveWar ( Player * player )

overridevirtual

Called when player left the battle.

Update player aura
Parameters

player : Player who left the battle

Reimplemented from Battlefield.

 {
     // Remove all aura from WG /// @todo false we can go out of this zone on retail and keep Rank buff, remove on end of WG
     if (!player->GetSession()->PlayerLogout())
     {
         if (Creature* vehicle = player->GetVehicleCreatureBase())   // Remove vehicle of player if he go out.
             vehicle->DespawnOrUnsummon();
 
         RemoveAurasFromPlayer(player);
     }
 
     player->RemoveAurasDueToSpell(SPELL_HORDE_CONTROLS_FACTORY_PHASE_SHIFT);
     player->RemoveAurasDueToSpell(SPELL_ALLIANCE_CONTROLS_FACTORY_PHASE_SHIFT);
     player->RemoveAurasDueToSpell(SPELL_HORDE_CONTROL_PHASE_SHIFT);
     player->RemoveAurasDueToSpell(SPELL_ALLIANCE_CONTROL_PHASE_SHIFT);
 }

Here is the call graph for this function:

void BattlefieldWG::OnPlayerLeaveZone ( Player * player )

overridevirtual

Called when player left the WG zone.

Parameters

player : Player who left the zone

Reimplemented from Battlefield.

 {
     if (!m_isActive)
         RemoveAurasFromPlayer(player);
 
     player->RemoveAurasDueToSpell(SPELL_HORDE_CONTROLS_FACTORY_PHASE_SHIFT);
     player->RemoveAurasDueToSpell(SPELL_ALLIANCE_CONTROLS_FACTORY_PHASE_SHIFT);
     player->RemoveAurasDueToSpell(SPELL_HORDE_CONTROL_PHASE_SHIFT);
     player->RemoveAurasDueToSpell(SPELL_ALLIANCE_CONTROL_PHASE_SHIFT);
 }

Here is the call graph for this function:

void BattlefieldWG::OnStartGrouping ( )

overridevirtual

Called when grouping starts (15 minutes before battlestart)

Invite all player in zone to join queue

Reimplemented from Battlefield.

 {
     SendWarning(BATTLEFIELD_WG_TEXT_START_GROUPING);
 }

Here is the call graph for this function:

void BattlefieldWG::OnUnitDeath ( Unit * unit )

overridevirtual

Reimplemented from ZoneScript.

 {
     if (IsWarTime())
         if (unit->IsVehicle())
             if (FindAndRemoveVehicleFromList(unit))
                 UpdateVehicleCountWG();
 }

Here is the call graph for this function:

void BattlefieldWG::ProcessEvent	(	WorldObject *	obj,
		uint32	eventId
	)

overridevirtual

Reimplemented from ZoneScript.

 {
     if (!obj || !IsWarTime())
         return;
 
     // We handle only gameobjects here
     GameObject* go = obj->ToGameObject();
     if (!go)
         return;
 
     // On click on titan relic
     if (go->GetEntry() == GO_WINTERGRASP_TITAN_S_RELIC)
     {
         if (CanInteractWithRelic())
             EndBattle(false);
         else if (GameObject* relic = GetRelic())
             relic->SetRespawnTime(RESPAWN_IMMEDIATELY);
     }
 
     // if destroy or damage event, search the wall/tower and update worldstate/send warning message
     for (BfWGGameObjectBuilding* building : BuildingsInZone)
     {
         if (go->GetGUID() == building->GetGUID())
         {
             if (GameObject* buildingGo = GetGameObject(building->GetGUID()))
             {
                 if (buildingGo->GetGOInfo()->destructibleBuilding.DamagedEvent == eventId)
                     building->Damaged();
                 else if (buildingGo->GetGOInfo()->destructibleBuilding.DestroyedEvent == eventId)
                     building->Destroyed();
                 break;
             }
         }
     }
 }

Here is the call graph for this function:

void BattlefieldWG::PromotePlayer ( Player * killer )

 {
     if (!m_isActive)
         return;
     // Updating rank of player
     if (Aura* auraRecruit = killer->GetAura(SPELL_RECRUIT))
     {
         if (auraRecruit->GetStackAmount() >= 5)
         {
             killer->RemoveAura(SPELL_RECRUIT);
             killer->CastSpell(killer, SPELL_CORPORAL, true);
             if (Creature* stalker = GetCreature(StalkerGuid))
                 sCreatureTextMgr->SendChat(stalker, BATTLEFIELD_WG_TEXT_RANK_CORPORAL, killer, CHAT_MSG_ADDON, LANG_ADDON, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, killer);
         }
         else
             killer->CastSpell(killer, SPELL_RECRUIT, true);
     }
     else if (Aura* auraCorporal = killer->GetAura(SPELL_CORPORAL))
     {
         if (auraCorporal->GetStackAmount() >= 5)
         {
             killer->RemoveAura(SPELL_CORPORAL);
             killer->CastSpell(killer, SPELL_LIEUTENANT, true);
             if (Creature* stalker = GetCreature(StalkerGuid))
                 sCreatureTextMgr->SendChat(stalker, BATTLEFIELD_WG_TEXT_RANK_FIRST_LIEUTENANT, killer, CHAT_MSG_ADDON, LANG_ADDON, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, killer);
         }
         else
             killer->CastSpell(killer, SPELL_CORPORAL, true);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlefieldWG::RemoveAurasFromPlayer ( Player * player )

 {
     player->RemoveAurasDueToSpell(SPELL_RECRUIT);
     player->RemoveAurasDueToSpell(SPELL_CORPORAL);
     player->RemoveAurasDueToSpell(SPELL_LIEUTENANT);
     player->RemoveAurasDueToSpell(SPELL_TOWER_CONTROL);
     player->RemoveAurasDueToSpell(SPELL_SPIRITUAL_IMMUNITY);
     player->RemoveAurasDueToSpell(SPELL_TENACITY);
     player->RemoveAurasDueToSpell(SPELL_ESSENCE_OF_WINTERGRASP);
     player->RemoveAurasDueToSpell(SPELL_WINTERGRASP_RESTRICTED_FLIGHT_AREA);
 }

Here is the caller graph for this function:

void BattlefieldWG::SendInitWorldStatesTo ( Player * player )

 {
     WorldPackets::WorldState::InitWorldStates packet;
     packet.AreaID = m_ZoneId;
     packet.MapID = m_MapId;
     packet.SubareaID = 0;
 
     FillInitialWorldStates(packet);
 
     player->SendDirectMessage(packet.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlefieldWG::SendInitWorldStatesToAll ( )

overridevirtual

Send all worldstate data to all player in zone.

Implements Battlefield.

 {
     for (uint8 team = 0; team < 2; team++)
         for (GuidSet::iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
             if (Player* player = ObjectAccessor::FindPlayer(*itr))
                 SendInitWorldStatesTo(player);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlefieldWG::SetRelic ( ObjectGuid relicGUID )

inline

Define relic object.

386 { m_titansRelicGUID = relicGUID; }

BattlefieldWG::m_titansRelicGUID

ObjectGuid m_titansRelicGUID

Definition: BattlefieldWG.h:432

void BattlefieldWG::SetRelicInteractible ( bool allow )

inline

Define if player can interact with the relic.

392 { m_isRelicInteractible = allow; }

BattlefieldWG::m_isRelicInteractible

bool m_isRelicInteractible

Definition: BattlefieldWG.h:416

Here is the caller graph for this function:

bool BattlefieldWG::SetupBattlefield ( )

overridevirtual

Called when battlefield is setup, at server start.

Reimplemented from Battlefield.

 {
     m_TypeId = BATTLEFIELD_WG;                              // See enum BattlefieldTypes
     m_BattleId = BATTLEFIELD_BATTLEID_WG;
     m_ZoneId = BATTLEFIELD_WG_ZONEID;
     m_MapId = BATTLEFIELD_WG_MAPID;
     m_Map = sMapMgr->FindMap(m_MapId, 0);
 
     InitStalker(BATTLEFIELD_WG_NPC_STALKER, WintergraspStalkerPos);
 
     m_MaxPlayer = sWorld->getIntConfig(CONFIG_WINTERGRASP_PLR_MAX);
     m_IsEnabled = sWorld->getBoolConfig(CONFIG_WINTERGRASP_ENABLE);
     m_MinPlayer = sWorld->getIntConfig(CONFIG_WINTERGRASP_PLR_MIN);
     m_MinLevel = sWorld->getIntConfig(CONFIG_WINTERGRASP_PLR_MIN_LVL);
     m_BattleTime = sWorld->getIntConfig(CONFIG_WINTERGRASP_BATTLETIME) * MINUTE * IN_MILLISECONDS;
     m_NoWarBattleTime = sWorld->getIntConfig(CONFIG_WINTERGRASP_NOBATTLETIME) * MINUTE * IN_MILLISECONDS;
     m_RestartAfterCrash = sWorld->getIntConfig(CONFIG_WINTERGRASP_RESTART_AFTER_CRASH) * MINUTE * IN_MILLISECONDS;
 
     m_TimeForAcceptInvite = 20;
     m_StartGroupingTimer = 15 * MINUTE * IN_MILLISECONDS;
     m_StartGrouping = false;
 
     m_tenacityStack = 0;
 
     KickPosition.Relocate(5728.117f, 2714.346f, 697.733f, 0);
     KickPosition.m_mapId = m_MapId;
 
     RegisterZone(m_ZoneId);
 
     m_Data32.resize(BATTLEFIELD_WG_DATA_MAX);
 
     m_saveTimer = 60000;
 
     // Init GraveYards
     SetGraveyardNumber(BATTLEFIELD_WG_GRAVEYARD_MAX);
 
     // Load from db
     if ((sWorld->getWorldState(BATTLEFIELD_WG_WORLD_STATE_ACTIVE) == 0) && (sWorld->getWorldState(BATTLEFIELD_WG_WORLD_STATE_DEFENDER) == 0)
             && (sWorld->getWorldState(ClockWorldState[0]) == 0))
     {
         sWorld->setWorldState(BATTLEFIELD_WG_WORLD_STATE_ACTIVE, uint64(false));
         sWorld->setWorldState(BATTLEFIELD_WG_WORLD_STATE_DEFENDER, uint64(urand(0, 1)));
         sWorld->setWorldState(ClockWorldState[0], uint64(m_NoWarBattleTime));
     }
 
     m_isActive = sWorld->getWorldState(BATTLEFIELD_WG_WORLD_STATE_ACTIVE) != 0;
     m_DefenderTeam = TeamId(sWorld->getWorldState(BATTLEFIELD_WG_WORLD_STATE_DEFENDER));
 
     m_Timer = sWorld->getWorldState(ClockWorldState[0]);
     if (m_isActive)
     {
         m_isActive = false;
         m_Timer = m_RestartAfterCrash;
     }
 
     for (uint8 i = 0; i < BATTLEFIELD_WG_GRAVEYARD_MAX; i++)
     {
         BfGraveyardWG* graveyard = new BfGraveyardWG(this);
 
         // When between games, the graveyard is controlled by the defending team
         if (WGGraveYard[i].startcontrol == TEAM_NEUTRAL)
             graveyard->Initialize(m_DefenderTeam, WGGraveYard[i].gyid);
         else
             graveyard->Initialize(WGGraveYard[i].startcontrol, WGGraveYard[i].gyid);
 
         graveyard->SetTextId(WGGraveYard[i].textid);
         m_GraveyardList[i] = graveyard;
     }
 
 
     // Spawn workshop creatures and gameobjects
     for (uint8 i = 0; i < WG_MAX_WORKSHOP; i++)
     {
         WintergraspWorkshop* workshop = new WintergraspWorkshop(this, i);
         if (i < BATTLEFIELD_WG_WORKSHOP_KEEP_WEST)
             workshop->GiveControlTo(GetAttackerTeam(), true);
         else
             workshop->GiveControlTo(GetDefenderTeam(), true);
 
         // Note: Capture point is added once the gameobject is created.
         Workshops.insert(workshop);
     }
 
     // Spawn NPCs in the defender's keep, both Horde and Alliance
     for (uint8 i = 0; i < WG_MAX_KEEP_NPC; i++)
     {
         // Horde npc
         if (Creature* creature = SpawnCreature(WGKeepNPC[i].entryHorde, WGKeepNPC[i].x, WGKeepNPC[i].y, WGKeepNPC[i].z, WGKeepNPC[i].o, TEAM_HORDE))
             KeepCreature[TEAM_HORDE].insert(creature->GetGUID());
         // Alliance npc
         if (Creature* creature = SpawnCreature(WGKeepNPC[i].entryAlliance, WGKeepNPC[i].x, WGKeepNPC[i].y, WGKeepNPC[i].z, WGKeepNPC[i].o, TEAM_ALLIANCE))
             KeepCreature[TEAM_ALLIANCE].insert(creature->GetGUID());
     }
 
     // Hide NPCs from the Attacker's team in the keep
     for (GuidSet::const_iterator itr = KeepCreature[GetAttackerTeam()].begin(); itr != KeepCreature[GetAttackerTeam()].end(); ++itr)
         if (Creature* creature = GetCreature(*itr))
             HideNpc(creature);
 
     // Spawn Horde NPCs outside the keep
     for (uint8 i = 0; i < WG_OUTSIDE_ALLIANCE_NPC; i++)
         if (Creature* creature = SpawnCreature(WGOutsideNPC[i].entryHorde, WGOutsideNPC[i].x, WGOutsideNPC[i].y, WGOutsideNPC[i].z, WGOutsideNPC[i].o, TEAM_HORDE))
             OutsideCreature[TEAM_HORDE].insert(creature->GetGUID());
 
     // Spawn Alliance NPCs outside the keep
     for (uint8 i = WG_OUTSIDE_ALLIANCE_NPC; i < WG_MAX_OUTSIDE_NPC; i++)
         if (Creature* creature = SpawnCreature(WGOutsideNPC[i].entryAlliance, WGOutsideNPC[i].x, WGOutsideNPC[i].y, WGOutsideNPC[i].z, WGOutsideNPC[i].o, TEAM_ALLIANCE))
             OutsideCreature[TEAM_ALLIANCE].insert(creature->GetGUID());
 
     // Hide units outside the keep that are defenders
     for (GuidSet::const_iterator itr = OutsideCreature[GetDefenderTeam()].begin(); itr != OutsideCreature[GetDefenderTeam()].end(); ++itr)
         if (Creature* creature = GetCreature(*itr))
             HideNpc(creature);
 
     // Spawn turrets and hide them per default
     for (uint8 i = 0; i < WG_MAX_TURRET; i++)
     {
         Position towerCannonPos = WGTurret[i].GetPosition();
         if (Creature* creature = SpawnCreature(NPC_WINTERGRASP_TOWER_CANNON, towerCannonPos, TEAM_ALLIANCE))
         {
             CanonList.insert(creature->GetGUID());
             HideNpc(creature);
         }
     }
 
     // Spawn all gameobjects
     for (uint8 i = 0; i < WG_MAX_OBJ; i++)
     {
         if (GameObject* go = SpawnGameObject(WGGameObjectBuilding[i].entry, WGGameObjectBuilding[i].x, WGGameObjectBuilding[i].y, WGGameObjectBuilding[i].z, WGGameObjectBuilding[i].o))
         {
             BfWGGameObjectBuilding* b = new BfWGGameObjectBuilding(this, WGGameObjectBuilding[i].type, WGGameObjectBuilding[i].WorldState);
             b->Init(go);
             if (!IsEnabled() && go->GetEntry() == GO_WINTERGRASP_VAULT_GATE)
                 go->SetDestructibleState(GO_DESTRUCTIBLE_DESTROYED);
             BuildingsInZone.insert(b);
         }
     }
 
     // Spawning portal defender
     for (uint8 i = 0; i < WG_MAX_TELEPORTER; i++)
     {
         if (GameObject* go = SpawnGameObject(WGPortalDefenderData[i].entry, WGPortalDefenderData[i].x, WGPortalDefenderData[i].y, WGPortalDefenderData[i].z, WGPortalDefenderData[i].o))
         {
             DefenderPortalList.insert(go->GetGUID());
             go->SetFaction(WintergraspFaction[GetDefenderTeam()]);
         }
     }
 
     UpdateCounterVehicle(true);
     return true;
 }

Here is the call graph for this function:

bool BattlefieldWG::Update ( uint32 diff )

overridevirtual

Called for update battlefield data.

Save battle timer in database every minutes
Update imunity aura from graveyard
Parameters

diff : time elapsed since the last call (in ms)

Reimplemented from Battlefield.

 {
     bool m_return = Battlefield::Update(diff);
     if (m_saveTimer <= diff)
     {
         sWorld->setWorldState(BATTLEFIELD_WG_WORLD_STATE_ACTIVE, m_isActive);
         sWorld->setWorldState(BATTLEFIELD_WG_WORLD_STATE_DEFENDER, m_DefenderTeam);
         sWorld->setWorldState(ClockWorldState[0], m_Timer);
         m_saveTimer = 60 * IN_MILLISECONDS;
     }
     else
         m_saveTimer -= diff;
 
     return m_return;
 }

Here is the call graph for this function:

void BattlefieldWG::UpdateCounterVehicle ( bool init )

 {
     if (init)
     {
         SetData(BATTLEFIELD_WG_DATA_VEHICLE_H, 0);
         SetData(BATTLEFIELD_WG_DATA_VEHICLE_A, 0);
     }
     SetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_H, 0);
     SetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A, 0);
 
     for (WintergraspWorkshop* workshop : Workshops)
     {
         if (workshop->GetTeamControl() == TEAM_ALLIANCE)
             UpdateData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A, 4);
         else if (workshop->GetTeamControl() == TEAM_HORDE)
             UpdateData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_H, 4);
     }
 
     UpdateVehicleCountWG();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlefieldWG::UpdateDamagedTowerCount ( TeamId team )

Called when a tower is damaged.

Update tower count (for reward calcul)

 {
     if (team == GetAttackerTeam())
         UpdateData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT, 1);
     else
         UpdateData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_DEF, 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlefieldWG::UpdatedDestroyedTowerCount ( TeamId team )

Called when tower is broken.

Update tower buff
check if three south tower is down for remove 10 minutes to wg

 {
     // Destroy an attack tower
     if (team == GetAttackerTeam())
     {
         // Update counter
         UpdateData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT, -1);
         UpdateData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT, 1);
 
         // Remove buff stack on attackers
         for (GuidSet::const_iterator itr = m_PlayersInWar[GetAttackerTeam()].begin(); itr != m_PlayersInWar[GetAttackerTeam()].end(); ++itr)
             if (Player* player = ObjectAccessor::FindPlayer(*itr))
                 player->RemoveAuraFromStack(SPELL_TOWER_CONTROL);
 
         // Add buff stack to defenders
         for (GuidSet::const_iterator itr = m_PlayersInWar[GetDefenderTeam()].begin(); itr != m_PlayersInWar[GetDefenderTeam()].end(); ++itr)
             if (Player* player = ObjectAccessor::FindPlayer(*itr))
             {
                 player->CastSpell(player, SPELL_TOWER_CONTROL, true);
                 DoCompleteOrIncrementAchievement(ACHIEVEMENTS_WG_TOWER_DESTROY, player);
             }
 
         // If all three south towers are destroyed (ie. all attack towers), remove ten minutes from battle time
         if (GetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT) == 3)
         {
             if (int32(m_Timer - 600000) < 0)
                 m_Timer = 0;
             else
                 m_Timer -= 600000;
             SendInitWorldStatesToAll();
         }
     }
     else
     {
         UpdateData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_DEF, -1);
         UpdateData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_DEF, 1);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlefieldWG::UpdateTenacity ( )

 {
     TeamId team = TEAM_NEUTRAL;
     uint32 alliancePlayers = m_PlayersInWar[TEAM_ALLIANCE].size();
     uint32 hordePlayers = m_PlayersInWar[TEAM_HORDE].size();
     int32 newStack = 0;
 
     if (alliancePlayers && hordePlayers)
     {
         if (alliancePlayers < hordePlayers)
             newStack = int32((float(hordePlayers / alliancePlayers) - 1) * 4);  // positive, should cast on alliance
         else if (alliancePlayers > hordePlayers)
             newStack = int32((1 - float(alliancePlayers / hordePlayers)) * 4);  // negative, should cast on horde
     }
 
     if (newStack == int32(m_tenacityStack))
         return;
 
     if (m_tenacityStack > 0 && newStack <= 0)               // old buff was on alliance
         team = TEAM_ALLIANCE;
     else if (newStack >= 0)                                 // old buff was on horde
         team = TEAM_HORDE;
 
     m_tenacityStack = newStack;
     // Remove old buff
     if (team != TEAM_NEUTRAL)
     {
         for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
             if (Player* player = ObjectAccessor::FindPlayer(*itr))
                 if (player->getLevel() >= m_MinLevel)
                     player->RemoveAurasDueToSpell(SPELL_TENACITY);
 
         for (GuidSet::const_iterator itr = m_vehicles[team].begin(); itr != m_vehicles[team].end(); ++itr)
             if (Creature* creature = GetCreature(*itr))
                 creature->RemoveAurasDueToSpell(SPELL_TENACITY_VEHICLE);
     }
 
     // Apply new buff
     if (newStack)
     {
         team = newStack > 0 ? TEAM_ALLIANCE : TEAM_HORDE;
 
         if (newStack < 0)
             newStack = -newStack;
         if (newStack > 20)
             newStack = 20;
 
         uint32 buff_honor = SPELL_GREATEST_HONOR;
         if (newStack < 15)
             buff_honor = SPELL_GREATER_HONOR;
         if (newStack < 10)
             buff_honor = SPELL_GREAT_HONOR;
         if (newStack < 5)
             buff_honor = 0;
 
         for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
             if (Player* player = ObjectAccessor::FindPlayer(*itr))
                 player->SetAuraStack(SPELL_TENACITY, player, newStack);
 
         for (GuidSet::const_iterator itr = m_vehicles[team].begin(); itr != m_vehicles[team].end(); ++itr)
             if (Creature* creature = GetCreature(*itr))
                 creature->SetAuraStack(SPELL_TENACITY_VEHICLE, creature, newStack);
 
         if (buff_honor != 0)
         {
             for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
                 if (Player* player = ObjectAccessor::FindPlayer(*itr))
                     player->CastSpell(player, buff_honor, true);
             for (GuidSet::const_iterator itr = m_vehicles[team].begin(); itr != m_vehicles[team].end(); ++itr)
                 if (Creature* creature = GetCreature(*itr))
                     creature->CastSpell(creature, buff_honor, true);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlefieldWG::UpdateVehicleCountWG ( )

 {
     SendUpdateWorldState(BATTLEFIELD_WG_WORLD_STATE_VEHICLE_H,     GetData(BATTLEFIELD_WG_DATA_VEHICLE_H));
     SendUpdateWorldState(BATTLEFIELD_WG_WORLD_STATE_MAX_VEHICLE_H, GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_H));
     SendUpdateWorldState(BATTLEFIELD_WG_WORLD_STATE_VEHICLE_A,     GetData(BATTLEFIELD_WG_DATA_VEHICLE_A));
     SendUpdateWorldState(BATTLEFIELD_WG_WORLD_STATE_MAX_VEHICLE_A, GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

GameObjectBuildingSet BattlefieldWG::BuildingsInZone

protected

GuidSet BattlefieldWG::CanonList

protected

GuidSet BattlefieldWG::DefenderPortalList

protected

GuidSet BattlefieldWG::KeepCreature[BG_TEAMS_COUNT]

protected

bool BattlefieldWG::m_isRelicInteractible

protected

GuidSet BattlefieldWG::m_KeepGameObject[BG_TEAMS_COUNT]

protected

uint32 BattlefieldWG::m_saveTimer

protected

uint32 BattlefieldWG::m_tenacityStack

protected

ObjectGuid BattlefieldWG::m_titansRelicGUID

protected

GuidSet BattlefieldWG::m_vehicles[BG_TEAMS_COUNT]

protected

GuidSet BattlefieldWG::OutsideCreature[BG_TEAMS_COUNT]

protected

WorkshopSet BattlefieldWG::Workshops

protected

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

src/server/game/Battlefield/Zones/BattlefieldWG.h
src/server/game/Battlefield/Zones/BattlefieldWG.cpp

Public Member Functions

Protected Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation