#include <BattlegroundIC.h>

Public Member Functions
	BattlegroundIC ()

	~BattlegroundIC ()

void	AddPlayer (Player *player) override

void	StartingEventCloseDoors () override

void	StartingEventOpenDoors () override

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

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

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

bool	SetupBattleground () override

void	SpawnLeader (uint32 teamid)

void	HandleKillUnit (Creature unit, Player killer) override

void	HandleKillPlayer (Player player, Player killer) override

void	EndBattleground (uint32 winner) override

void	EventPlayerClickedOnFlag (Player source, GameObject ) override

void	DestroyGate (Player player, GameObject go) override

WorldSafeLocsEntry const *	GetClosestGraveYard (Player *player) override

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

void	HandlePlayerResurrect (Player *player) override

uint32	GetNodeState (uint8 nodeType) const

bool	IsAllNodesControlledByTeam (uint32 team) const override

bool	IsSpellAllowed (uint32 spellId, Player const *player) const override

Public Member Functions inherited from Battleground
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual void	Reset ()

virtual void	ResetBGSubclass ()

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)

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

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	EventPlayerDroppedFlag (Player *)

void	EventPlayerLoggedIn (Player *player)

void	EventPlayerLoggedOut (Player *player)

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

virtual void	DoAction (uint32, ObjectGuid)

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 ObjectGuid	GetFlagPickerGUID (int32=-1) const

virtual void	SetDroppedFlagGUID (ObjectGuid, int32=-1)

virtual void	HandleQuestComplete (uint32, Player *)

virtual bool	CanActivateGO (int32, uint32) const

uint32	GetTeamScore (uint32 TeamID) const

virtual uint32	GetPrematureWinner ()

uint8	GetUniqueBracketId () const

Private Member Functions
uint32	GetNextBanner (ICNodePoint *node, uint32 team, bool returnDefinitve)

uint32	GetGateIDFromEntry (uint32 id)

uint32	GetWorldStateFromGateEntry (uint32 id, bool open)

void	UpdateNodeWorldState (ICNodePoint *node)

void	HandleCapturedNodes (ICNodePoint *node, bool recapture)

void	HandleContestedNodes (ICNodePoint *node)

Private Attributes
uint32	closeFortressDoorsTimer

bool	doorsClosed

uint32	docksTimer

uint32	resourceTimer

uint32	siegeEngineWorkshopTimer

uint16	factionReinforcements [2]

BG_IC_GateState	GateStatus [6]

ICNodePoint	nodePoint [7]

Transport *	gunshipAlliance

Transport *	gunshipHorde

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

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

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

BattlegroundIC::BattlegroundIC ( )

 {
  BgObjects.resize(MAX_NORMAL_GAMEOBJECTS_SPAWNS + MAX_AIRSHIPS_SPAWNS + MAX_HANGAR_TELEPORTERS_SPAWNS + MAX_FORTRESS_TELEPORTERS_SPAWNS + MAX_HANGAR_TELEPORTER_EFFECTS_SPAWNS + MAX_FORTRESS_TELEPORTER_EFFECTS_SPAWNS);
  BgCreatures.resize(MAX_NORMAL_NPCS_SPAWNS + MAX_WORKSHOP_SPAWNS + MAX_DOCKS_SPAWNS + MAX_SPIRIT_GUIDES_SPAWNS + MAX_HANGAR_NPCS_SPAWNS);
 
  StartMessageIds[BG_STARTING_EVENT_FIRST] = LANG_BG_IC_START_TWO_MINUTES;
  StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_BG_IC_START_ONE_MINUTE;
  StartMessageIds[BG_STARTING_EVENT_THIRD] = LANG_BG_IC_START_HALF_MINUTE;
  StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_BG_IC_HAS_BEGUN;
 
  for (uint8 i = 0; i < 2; ++i)
  factionReinforcements[i] = MAX_REINFORCEMENTS;
 
  for (uint8 i = 0; i < BG_IC_MAXDOOR; ++i)
  GateStatus[i] = BG_IC_GATE_OK;
 
  closeFortressDoorsTimer = CLOSE_DOORS_TIME; // the doors are closed again... in a special way
  doorsClosed = false;
  docksTimer = DOCKS_UPDATE_TIME;
  resourceTimer = IC_RESOURCE_TIME;
 
  for (uint8 i = NODE_TYPE_REFINERY; i < MAX_NODE_TYPES; ++i)
  nodePoint[i] = nodePointInitial[i];
 
  siegeEngineWorkshopTimer = WORKSHOP_UPDATE_TIME;
 
  gunshipHorde = NULL;
  gunshipAlliance = NULL;
 }

BattlegroundIC::~BattlegroundIC ( )

60 { }

Member Function Documentation

void BattlegroundIC::AddPlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

 {
  Battleground::AddPlayer(player);
  PlayerScores[player->GetGUID()] = new BattlegroundICScore(player->GetGUID(), player->GetBGTeam());
 
  if (nodePoint[NODE_TYPE_QUARRY].nodeState == (player->GetTeamId() == TEAM_ALLIANCE ? NODE_STATE_CONTROLLED_A : NODE_STATE_CONTROLLED_H))
  player->CastSpell(player, SPELL_QUARRY, true);
 
  if (nodePoint[NODE_TYPE_REFINERY].nodeState == (player->GetTeamId() == TEAM_ALLIANCE ? NODE_STATE_CONTROLLED_A : NODE_STATE_CONTROLLED_H))
  player->CastSpell(player, SPELL_OIL_REFINERY, true);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
  GateStatus[GetGateIDFromEntry(go->GetEntry())] = BG_IC_GATE_DESTROYED;
  uint32 uws_open = GetWorldStateFromGateEntry(go->GetEntry(), true);
  uint32 uws_close = GetWorldStateFromGateEntry(go->GetEntry(), false);
  if (uws_open)
  {
  UpdateWorldState(uws_close, 0);
  UpdateWorldState(uws_open, 1);
  }
  if (player->GetTeamId() == TEAM_ALLIANCE)
  {
  DoorOpen(BG_IC_GO_HORDE_KEEP_PORTCULLIS);
  GetBGObject(BG_IC_GO_HORDE_BANNER)->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
  }
  else
  {
  DoorOpen(BG_IC_GO_DOODAD_PORTCULLISACTIVE02);
  GetBGObject(BG_IC_GO_ALLIANCE_BANNER)->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
  }
 
  uint32 lang_entry = 0;
 
  switch (go->GetEntry())
  {
  case GO_HORDE_GATE_1:
  lang_entry = LANG_BG_IC_NORTH_GATE_DESTROYED;
  break;
  case GO_HORDE_GATE_2:
  case GO_ALLIANCE_GATE_1:
  lang_entry = LANG_BG_IC_WEST_GATE_DESTROYED;
  break;
  case GO_HORDE_GATE_3:
  case GO_ALLIANCE_GATE_2:
  lang_entry = LANG_BG_IC_EAST_GATE_DESTROYED;
  break;
  case GO_ALLIANCE_GATE_3:
  lang_entry = LANG_BG_IC_SOUTH_GATE_DESTROYED;
  break;
  default:
  break;
  }
 
  if (go->GetEntry() == GO_HORDE_GATE_1 || go->GetEntry() == GO_HORDE_GATE_2 || go->GetEntry() == GO_HORDE_GATE_3)
  {
  if (!GetBgMap()->GetCreature(BgCreatures[BG_IC_NpcSpawnlocs[BG_IC_NPC_OVERLORD_AGMAR].type]) && !AddCreature(BG_IC_NpcSpawnlocs[BG_IC_NPC_OVERLORD_AGMAR].entry, BG_IC_NpcSpawnlocs[BG_IC_NPC_OVERLORD_AGMAR].type, BG_IC_NpcSpawnlocs[BG_IC_NPC_OVERLORD_AGMAR].x, BG_IC_NpcSpawnlocs[BG_IC_NPC_OVERLORD_AGMAR].y, BG_IC_NpcSpawnlocs[BG_IC_NPC_OVERLORD_AGMAR].z, BG_IC_NpcSpawnlocs[BG_IC_NPC_OVERLORD_AGMAR].o, BG_IC_NpcSpawnlocs[BG_IC_NPC_OVERLORD_AGMAR].team, RESPAWN_ONE_DAY))
  TC_LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning creature %u", BG_IC_NpcSpawnlocs[BG_IC_NPC_OVERLORD_AGMAR].entry);
  }
  else if (go->GetEntry() == GO_ALLIANCE_GATE_1 || go->GetEntry() == GO_ALLIANCE_GATE_2 || go->GetEntry() == GO_ALLIANCE_GATE_3)
  {
  if (!GetBgMap()->GetCreature(BgCreatures[BG_IC_NpcSpawnlocs[BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE].type]) && !AddCreature(BG_IC_NpcSpawnlocs[BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE].entry, BG_IC_NpcSpawnlocs[BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE].type, BG_IC_NpcSpawnlocs[BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE].x, BG_IC_NpcSpawnlocs[BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE].y, BG_IC_NpcSpawnlocs[BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE].z, BG_IC_NpcSpawnlocs[BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE].o, BG_IC_NpcSpawnlocs[BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE].team, RESPAWN_ONE_DAY))
  TC_LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning creature %u", BG_IC_NpcSpawnlocs[BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE].entry);
  }
 
  SendMessage2ToAll(lang_entry, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL, (player->GetTeamId() == TEAM_ALLIANCE ? LANG_BG_IC_HORDE_KEEP : LANG_BG_IC_ALLIANCE_KEEP));
 }

Here is the call graph for this function:

void BattlegroundIC::EndBattleground ( uint32 winner )

overridevirtual

Reimplemented from Battleground.

 {
  SendMessage2ToAll(LANG_BG_IC_TEAM_WINS, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL, (winner == ALLIANCE ? LANG_BG_IC_ALLIANCE : LANG_BG_IC_HORDE));
 
  Battleground::EndBattleground(winner);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundIC::EventPlayerClickedOnFlag	(	Player *	source,
		GameObject *	target_obj
	)

overridevirtual

Reimplemented from Battleground.

 {
  if (GetStatus() != STATUS_IN_PROGRESS)
  return;
 
  // All the node points are iterated to find the clicked one
  for (uint8 i = 0; i < MAX_NODE_TYPES; ++i)
  {
  if (nodePoint[i].gameobject_entry == target_obj->GetEntry())
  {
  // THIS SHOULD NEEVEER HAPPEN
  if (nodePoint[i].faction == player->GetTeamId())
  return;
 
  uint32 nextBanner = GetNextBanner(&nodePoint[i], player->GetTeamId(), false);
 
  // we set the new settings of the nodePoint
  nodePoint[i].faction = player->GetTeamId();
  nodePoint[i].last_entry = nodePoint[i].gameobject_entry;
  nodePoint[i].gameobject_entry = nextBanner;
 
  // this is just needed if the next banner is grey
  if (nodePoint[i].banners[BANNER_A_CONTESTED] == nextBanner || nodePoint[i].banners[BANNER_H_CONTESTED] == nextBanner)
  {
  nodePoint[i].timer = BANNER_STATE_CHANGE_TIME; // 1 minute for last change (real faction banner)
  nodePoint[i].needChange = true;
 
  RelocateDeadPlayers(BgCreatures[BG_IC_NPC_SPIRIT_GUIDE_1 + nodePoint[i].nodeType - 2]);
 
  // if we are here means that the point has been lost, or it is the first capture
 
  if (nodePoint[i].nodeType != NODE_TYPE_REFINERY && nodePoint[i].nodeType != NODE_TYPE_QUARRY)
  if (!BgCreatures[BG_IC_NPC_SPIRIT_GUIDE_1 + (nodePoint[i].nodeType) - 2].IsEmpty())
  DelCreature(BG_IC_NPC_SPIRIT_GUIDE_1 + (nodePoint[i].nodeType) - 2);
 
  UpdatePlayerScore(player, SCORE_BASES_ASSAULTED, 1);
 
  SendMessage2ToAll(LANG_BG_IC_TEAM_ASSAULTED_NODE_1, CHAT_MSG_BG_SYSTEM_NEUTRAL, player, nodePoint[i].string);
  SendMessage2ToAll(LANG_BG_IC_TEAM_ASSAULTED_NODE_2, CHAT_MSG_BG_SYSTEM_NEUTRAL, player, nodePoint[i].string, (player->GetTeamId() == TEAM_ALLIANCE ? LANG_BG_IC_ALLIANCE : LANG_BG_IC_HORDE));
  HandleContestedNodes(&nodePoint[i]);
  }
  else if (nextBanner == nodePoint[i].banners[BANNER_A_CONTROLLED] || nextBanner == nodePoint[i].banners[BANNER_H_CONTROLLED]) // if we are going to spawn the definitve faction banner, we dont need the timer anymore
  {
  nodePoint[i].timer = BANNER_STATE_CHANGE_TIME;
  nodePoint[i].needChange = false;
  SendMessage2ToAll(LANG_BG_IC_TEAM_DEFENDED_NODE, CHAT_MSG_BG_SYSTEM_NEUTRAL, player, nodePoint[i].string);
  HandleCapturedNodes(&nodePoint[i], true);
  UpdatePlayerScore(player, SCORE_BASES_DEFENDED, 1);
  }
 
  GameObject* banner = GetBGObject(nodePoint[i].gameobject_type);
 
  if (!banner) // this should never happen
  return;
 
  float cords[4] = {banner->GetPositionX(), banner->GetPositionY(), banner->GetPositionZ(), banner->GetOrientation() };
 
  DelObject(nodePoint[i].gameobject_type);
  if (!AddObject(nodePoint[i].gameobject_type, nodePoint[i].gameobject_entry, cords[0], cords[1], cords[2], cords[3], 0, 0, 0, 0, RESPAWN_ONE_DAY))
  {
  TC_LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning a banner (type: %u, entry: %u). Isle of Conquest BG cancelled.", nodePoint[i].gameobject_type, nodePoint[i].gameobject_entry);
  EndBattleground(0);
  }
 
  GetBGObject(nodePoint[i].gameobject_type)->SetUInt32Value(GAMEOBJECT_FACTION, nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_Factions[1] : BG_IC_Factions[0]);
 
  UpdateNodeWorldState(&nodePoint[i]);
  // we dont need iterating if we are here
  // If the needChange bool was set true, we will handle the rest in the Update Map function.
  return;
  }
  }
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
  packet.Worldstates.emplace_back(uint32(BG_IC_ALLIANCE_RENFORT_SET), 1);
  packet.Worldstates.emplace_back(uint32(BG_IC_HORDE_RENFORT_SET), 1);
  packet.Worldstates.emplace_back(uint32(BG_IC_ALLIANCE_RENFORT), int32(factionReinforcements[TEAM_ALLIANCE]));
  packet.Worldstates.emplace_back(uint32(BG_IC_HORDE_RENFORT), int32(factionReinforcements[TEAM_HORDE]));
 
  for (uint8 i = 0; i < MAX_FORTRESS_GATES_SPAWNS; ++i)
  {
  uint32 uws = GetWorldStateFromGateEntry(BG_IC_ObjSpawnlocs[i].entry, (GateStatus[GetGateIDFromEntry(BG_IC_ObjSpawnlocs[i].entry)] == BG_IC_GATE_DESTROYED ? true : false));
  packet.Worldstates.emplace_back(uint32(uws), 1);
  }
 
  for (uint8 i = 0; i < MAX_NODE_TYPES; ++i)
  packet.Worldstates.emplace_back(uint32(nodePoint[i].worldStates[nodePoint[i].nodeState]), 1);
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
  TeamId teamIndex = GetTeamIndexByTeamId(player->GetTeam());
 
  // Is there any occupied node for this team?
  std::vector<uint8> nodes;
  for (uint8 i = 0; i < MAX_NODE_TYPES; ++i)
  if (nodePoint[i].faction == player->GetTeamId())
  nodes.push_back(i);
 
  WorldSafeLocsEntry const* good_entry = NULL;
  // If so, select the closest node to place ghost on
  if (!nodes.empty())
  {
  float player_x = player->GetPositionX();
  float player_y = player->GetPositionY();
 
  float mindist = 999999.0f;
  for (uint8 i = 0; i < nodes.size(); ++i)
  {
  WorldSafeLocsEntry const*entry = sWorldSafeLocsStore.LookupEntry(BG_IC_GraveyardIds[nodes[i]]);
  if (!entry)
  continue;
  float dist = (entry->Loc.X - player_x)*(entry->Loc.X - player_x)+(entry->Loc.Y - player_y)*(entry->Loc.Y - player_y);
  if (mindist > dist)
  {
  mindist = dist;
  good_entry = entry;
  }
  }
  nodes.clear();
  }
  // If not, place ghost on starting location
  if (!good_entry)
  good_entry = sWorldSafeLocsStore.LookupEntry(BG_IC_GraveyardIds[teamIndex+MAX_NODE_TYPES]);
 
  return good_entry;
 }

Here is the call graph for this function:

uint32 BattlegroundIC::GetGateIDFromEntry ( uint32 id )

inlineprivate

  {
  uint32 i = 0;
  switch (id)
  {
  case GO_HORDE_GATE_1: i = BG_IC_H_FRONT ;break;
  case GO_HORDE_GATE_2: i = BG_IC_H_WEST ;break;
  case GO_HORDE_GATE_3: i = BG_IC_H_EAST ;break;
  case GO_ALLIANCE_GATE_3: i = BG_IC_A_FRONT ;break;
  case GO_ALLIANCE_GATE_1: i = BG_IC_A_WEST ;break;
  case GO_ALLIANCE_GATE_2: i = BG_IC_A_EAST ;break;
  }
  return i;
  }

Here is the caller graph for this function:

uint32 BattlegroundIC::GetNextBanner	(	ICNodePoint *	node,
		uint32	team,
		bool	returnDefinitve
	)

private

 {
  // this is only used in the update map function
  if (returnDefinitve)
  // here is a special case, here we must return the definitve faction banner after the grey banner was spawned 1 minute
  return node->banners[(team == TEAM_ALLIANCE ? BANNER_A_CONTROLLED : BANNER_H_CONTROLLED)];
 
  // there were no changes, this point has never been captured by any faction or at least clicked
  if (node->last_entry == 0)
  // 1 returns the CONTESTED ALLIANCE BANNER, 3 returns the HORDE one
  return node->banners[(team == TEAM_ALLIANCE ? BANNER_A_CONTESTED : BANNER_H_CONTESTED)];
 
  // If the actual banner is the definitive faction banner, we must return the grey banner of the player's faction
  if (node->gameobject_entry == node->banners[BANNER_A_CONTROLLED] || node->gameobject_entry == node->banners[BANNER_H_CONTROLLED])
  return node->banners[(team == TEAM_ALLIANCE ? BANNER_A_CONTESTED : BANNER_H_CONTESTED)];
 
  // If the actual banner is the grey faction banner, we must return the previous banner
  if (node->gameobject_entry == node->banners[BANNER_A_CONTESTED] || node->banners[BANNER_H_CONTESTED])
  return node->last_entry;
 
  // we should never be here...
  TC_LOG_ERROR("bg.battleground", "Isle Of Conquest: Unexpected return in GetNextBanner function");
  return 0;
 }

Here is the caller graph for this function:

uint32 BattlegroundIC::GetNodeState ( uint8 nodeType ) const

inline

949 { return (uint8)nodePoint[nodeType].nodeState; }

ICNodePoint::nodeState

ICNodeState nodeState

Definition: BattlegroundIC.h:862

BattlegroundIC::nodePoint

ICNodePoint nodePoint[7]

Definition: BattlegroundIC.h:963

uint8

uint8_t uint8

Definition: Define.h:152

Here is the caller graph for this function:

uint32 BattlegroundIC::GetWorldStateFromGateEntry	(	uint32	id,
		bool	open
	)

inlineprivate

         {
             uint32 uws = 0;
 
             switch (id)
             {
                 case GO_HORDE_GATE_1:
                     uws = (open ? BG_IC_GATE_FRONT_H_WS_OPEN : BG_IC_GATE_FRONT_H_WS_CLOSED);
                     break;
                 case GO_HORDE_GATE_2:
                     uws = (open ? BG_IC_GATE_WEST_H_WS_OPEN : BG_IC_GATE_WEST_H_WS_CLOSED);
                     break;
                 case GO_HORDE_GATE_3:
                     uws = (open ? BG_IC_GATE_EAST_H_WS_OPEN : BG_IC_GATE_EAST_H_WS_CLOSED);
                     break;
                 case GO_ALLIANCE_GATE_3:
                     uws = (open ? BG_IC_GATE_FRONT_A_WS_OPEN : BG_IC_GATE_FRONT_A_WS_CLOSED);
                     break;
                 case GO_ALLIANCE_GATE_1:
                     uws = (open ? BG_IC_GATE_WEST_A_WS_OPEN : BG_IC_GATE_WEST_A_WS_CLOSED);
                     break;
                 case GO_ALLIANCE_GATE_2:
                     uws = (open ? BG_IC_GATE_EAST_A_WS_OPEN : BG_IC_GATE_EAST_A_WS_CLOSED);
                     break;
             }
             return uws;
         }

Here is the caller graph for this function:

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

overridevirtual

: this spell should be cast by npc 22515 (World Trigger) and not by the player

Reimplemented from Battleground.

 {
     // this is wrong way to implement these things. On official it done by gameobject spell cast.
     if (GetStatus() != STATUS_IN_PROGRESS)
         return;
 
     if (trigger == 5555 && player->GetTeamId() == TEAM_HORDE)
     {
         if (GateStatus[BG_IC_A_FRONT] != BG_IC_GATE_DESTROYED
             && GateStatus[BG_IC_A_WEST] != BG_IC_GATE_DESTROYED
             && GateStatus[BG_IC_A_EAST] != BG_IC_GATE_DESTROYED)
         player->CastSpell(player, SPELL_BACK_DOOR_JOB_ACHIEVEMENT, true);
     }
     else if (trigger == 5535 && player->GetTeamId() == TEAM_ALLIANCE)
     {
         if (GateStatus[BG_IC_H_FRONT] != BG_IC_GATE_DESTROYED
             && GateStatus[BG_IC_H_WEST] != BG_IC_GATE_DESTROYED
             && GateStatus[BG_IC_H_EAST] != BG_IC_GATE_DESTROYED)
         player->CastSpell(player, SPELL_BACK_DOOR_JOB_ACHIEVEMENT, true);
     }
 }

Here is the call graph for this function:

void BattlegroundIC::HandleCapturedNodes	(	ICNodePoint *	node,
		bool	recapture
	)

private

 {
     if (node->nodeType != NODE_TYPE_REFINERY && node->nodeType != NODE_TYPE_QUARRY)
     {
         if (!AddSpiritGuide(BG_IC_NPC_SPIRIT_GUIDE_1+node->nodeType-2, BG_IC_SpiritGuidePos[node->nodeType], node->faction))
             TC_LOG_ERROR("bg.battleground", "Isle of Conquest: Failed to spawn spirit guide! point: %u, team: %u, ", node->nodeType, node->faction);
     }
 
     switch (node->gameobject_type)
     {
         case BG_IC_GO_HANGAR_BANNER:
             {
                 if (!gunshipAlliance || !gunshipHorde)
                     break;
 
                 std::list<Creature*> cannons;
                 if (node->faction == TEAM_ALLIANCE)
                     gunshipAlliance->GetCreatureListWithEntryInGrid(cannons, NPC_ALLIANCE_GUNSHIP_CANNON, 150.0f);
                 else
                     gunshipHorde->GetCreatureListWithEntryInGrid(cannons, NPC_HORDE_GUNSHIP_CANNON, 150.0f);
 
                 for (Creature* cannon : cannons)
                     cannon->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
 
                 for (uint8 u = 0; u < MAX_HANGAR_TELEPORTERS_SPAWNS; ++u)
                 {
                     uint8 type = BG_IC_GO_HANGAR_TELEPORTER_1 + u;
                     if (!AddObject(type, (node->faction == TEAM_ALLIANCE ? GO_ALLIANCE_GUNSHIP_PORTAL : GO_HORDE_GUNSHIP_PORTAL), BG_IC_HangarTeleporters[u], 0, 0, 0, 0, RESPAWN_ONE_DAY))
                         TC_LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning a gunship portal. Type: %u", BG_IC_GO_HANGAR_TELEPORTER_1 + u);
                 }
 
                 for (uint8 u = 0; u < MAX_HANGAR_TELEPORTER_EFFECTS_SPAWNS; ++u)
                 {
                     uint8 type = BG_IC_GO_HANGAR_TELEPORTER_EFFECT_1 + u;
                     if (!AddObject(type, (node->faction == TEAM_ALLIANCE ? GO_ALLIANCE_GUNSHIP_PORTAL_EFFECTS : GO_HORDE_GUNSHIP_PORTAL_EFFECTS), BG_IC_HangarTeleporterEffects[u], 0, 0, 0, 0, RESPAWN_ONE_DAY, GO_STATE_ACTIVE))
                         TC_LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning a gunship portal effects. Type: %u", BG_IC_GO_HANGAR_TELEPORTER_1 + u);
                 }
 
                 for (uint8 u = 0; u < MAX_TRIGGER_SPAWNS_PER_FACTION; ++u)
                 {
                     if (!AddCreature(NPC_WORLD_TRIGGER_NOT_FLOATING, BG_IC_NPC_WORLD_TRIGGER_NOT_FLOATING, BG_IC_HangarTrigger[node->faction], node->faction, RESPAWN_ONE_DAY, node->faction == TEAM_ALLIANCE ? gunshipAlliance : gunshipHorde))
                         TC_LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning a world trigger. Type: %u", BG_IC_NPC_WORLD_TRIGGER_NOT_FLOATING);
                 }
 
                 for (uint8 u = 0; u < MAX_CAPTAIN_SPAWNS_PER_FACTION; ++u)
                 {
                     uint8 type = BG_IC_NPC_GUNSHIP_CAPTAIN_1 + u;
 
                     if (type == BG_IC_NPC_GUNSHIP_CAPTAIN_1)
                         if (AddCreature(node->faction == TEAM_ALLIANCE ? NPC_ALLIANCE_GUNSHIP_CAPTAIN : NPC_HORDE_GUNSHIP_CAPTAIN, type, BG_IC_HangarCaptains[node->faction == TEAM_ALLIANCE ? 2 : 0], node->faction, RESPAWN_ONE_DAY))
                             GetBGCreature(BG_IC_NPC_GUNSHIP_CAPTAIN_1)->GetAI()->DoAction(ACTION_GUNSHIP_READY);
 
                     if (type == BG_IC_NPC_GUNSHIP_CAPTAIN_2)
                         if (!AddCreature(node->faction == TEAM_ALLIANCE ? NPC_ALLIANCE_GUNSHIP_CAPTAIN : NPC_HORDE_GUNSHIP_CAPTAIN, type, BG_IC_HangarCaptains[node->faction == TEAM_ALLIANCE ? 3 : 1], node->faction, RESPAWN_ONE_DAY, node->faction == TEAM_ALLIANCE ? gunshipAlliance : gunshipHorde))
                             TC_LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning a world trigger. Type: %u", BG_IC_NPC_GUNSHIP_CAPTAIN_2);
                 }
 
                 (node->faction == TEAM_ALLIANCE ? gunshipAlliance : gunshipHorde)->EnableMovement(true);
                 break;
             }
         case BG_IC_GO_QUARRY_BANNER:
             RemoveAuraOnTeam(SPELL_QUARRY, (node->faction == TEAM_ALLIANCE ? HORDE : ALLIANCE));
             CastSpellOnTeam(SPELL_QUARRY, (node->faction == TEAM_ALLIANCE ? ALLIANCE : HORDE));
             break;
         case BG_IC_GO_REFINERY_BANNER:
             RemoveAuraOnTeam(SPELL_OIL_REFINERY, (node->faction == TEAM_ALLIANCE ? HORDE : ALLIANCE));
             CastSpellOnTeam(SPELL_OIL_REFINERY, (node->faction == TEAM_ALLIANCE ? ALLIANCE : HORDE));
             break;
         case BG_IC_GO_DOCKS_BANNER:
             if (recapture)
                 break;
 
             if (docksTimer < DOCKS_UPDATE_TIME)
                 docksTimer = DOCKS_UPDATE_TIME;
 
             // we must del opposing faction vehicles when the node is captured (unused ones)
             for (uint8 i = (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_GLAIVE_THROWER_1_H : BG_IC_NPC_GLAIVE_THROWER_1_A); i < (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_GLAIVE_THROWER_2_H : BG_IC_NPC_GLAIVE_THROWER_2_A); ++i)
             {
                 if (Creature* glaiveThrower = GetBGCreature(i, false))
                 {
                     if (Vehicle* vehicleGlaive = glaiveThrower->GetVehicleKit())
                     {
                         if (!vehicleGlaive->GetPassenger(0))
                             DelCreature(i);
                     }
                 }
             }
 
             for (uint8 i = (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_CATAPULT_1_H : BG_IC_NPC_CATAPULT_1_A); i < (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_CATAPULT_4_H  : BG_IC_NPC_CATAPULT_4_A); ++i)
             {
                 if (Creature* catapult = GetBGCreature(i, false))
                 {
                     if (Vehicle* vehicleGlaive = catapult->GetVehicleKit())
                     {
                         if (!vehicleGlaive->GetPassenger(0))
                             DelCreature(i);
                     }
                 }
             }
 
             // spawning glaive throwers
             for (uint8 i = 0; i < MAX_GLAIVE_THROWERS_SPAWNS_PER_FACTION; ++i)
             {
                 uint8 type = (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_GLAIVE_THROWER_1_A : BG_IC_NPC_GLAIVE_THROWER_1_H)+i;
 
                 if (GetBGCreature(type, false) && GetBGCreature(type)->IsAlive())
                     continue;
 
                 if (AddCreature(node->faction == TEAM_ALLIANCE ? NPC_GLAIVE_THROWER_A : NPC_GLAIVE_THROWER_H, type, BG_IC_DocksVehiclesGlaives[i], node->faction, RESPAWN_ONE_DAY))
                     GetBGCreature(type)->setFaction(BG_IC_Factions[(node->faction == TEAM_ALLIANCE ? 0 : 1)]);
             }
 
             // spawning catapults
             for (uint8 i = 0; i < MAX_CATAPULTS_SPAWNS_PER_FACTION; ++i)
             {
                 uint8 type = (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_CATAPULT_1_A : BG_IC_NPC_CATAPULT_1_H)+i;
 
                 if (GetBGCreature(type, false) && GetBGCreature(type)->IsAlive())
                     continue;
 
                 if (AddCreature(NPC_CATAPULT, type, BG_IC_DocksVehiclesCatapults[i], node->faction, RESPAWN_ONE_DAY))
                     GetBGCreature(type)->setFaction(BG_IC_Factions[(node->faction == TEAM_ALLIANCE ? 0 : 1)]);
             }
             break;
         case BG_IC_GO_WORKSHOP_BANNER:
             {
                 if (siegeEngineWorkshopTimer < WORKSHOP_UPDATE_TIME)
                     siegeEngineWorkshopTimer = WORKSHOP_UPDATE_TIME;
 
                 if (!recapture)
                 {
                     // we must del opposing faction vehicles when the node is captured (unused ones)
                     for (uint8 i = (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_DEMOLISHER_1_H : BG_IC_NPC_DEMOLISHER_1_A); i < (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_DEMOLISHER_4_H : BG_IC_NPC_DEMOLISHER_4_A); ++i)
                     {
                         if (Creature* demolisher = GetBGCreature(i, false))
                         {
                             if (Vehicle* vehicleDemolisher = demolisher->GetVehicleKit())
                             {
                                 // is IsVehicleInUse working as expected?
                                 if (!vehicleDemolisher->IsVehicleInUse())
                                     DelCreature(i);
                             }
                         }
                     }
 
                     for (uint8 i = 0; i < MAX_DEMOLISHERS_SPAWNS_PER_FACTION; ++i)
                     {
                         uint8 type = (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_DEMOLISHER_1_A : BG_IC_NPC_DEMOLISHER_1_H)+i;
 
                         if (GetBGCreature(type, false) && GetBGCreature(type)->IsAlive())
                             continue;
 
                         if (AddCreature(NPC_DEMOLISHER, type, BG_IC_WorkshopVehicles[i], node->faction, RESPAWN_ONE_DAY))
                             GetBGCreature(type)->setFaction(BG_IC_Factions[(node->faction == TEAM_ALLIANCE ? 0 : 1)]);
                     }
 
                     // we check if the opossing siege engine is in use
                     int8 enemySiege = (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_SIEGE_ENGINE_H : BG_IC_NPC_SIEGE_ENGINE_A);
 
                     if (Creature* siegeEngine = GetBGCreature(enemySiege, false))
                     {
                         if (Vehicle* vehicleSiege = siegeEngine->GetVehicleKit())
                         {
                             // is VehicleInUse working as expected ?
                             if (!vehicleSiege->IsVehicleInUse())
                                 DelCreature(enemySiege);
                         }
                     }
 
                     uint8 siegeType = (node->faction == TEAM_ALLIANCE ? BG_IC_NPC_SIEGE_ENGINE_A : BG_IC_NPC_SIEGE_ENGINE_H);
                     if (!GetBGCreature(siegeType, false) || !GetBGCreature(siegeType)->IsAlive())
                     {
                         AddCreature((node->faction == TEAM_ALLIANCE ? NPC_SIEGE_ENGINE_A : NPC_SIEGE_ENGINE_H), siegeType,
                             BG_IC_WorkshopVehicles[4], node->faction, RESPAWN_ONE_DAY);
 
                         if (Creature* siegeEngine = GetBGCreature(siegeType))
                         {
                             siegeEngine->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_UNK_14|UNIT_FLAG_IMMUNE_TO_PC);
                             siegeEngine->setFaction(BG_IC_Factions[(node->faction == TEAM_ALLIANCE ? 0 : 1)]);
                         }
                     }
                 }
 
                 for (uint8 i = 0; i < MAX_WORKSHOP_BOMBS_SPAWNS_PER_FACTION; ++i)
                 {
                     AddObject(BG_IC_GO_SEAFORIUM_BOMBS_1+i, GO_SEAFORIUM_BOMBS,
                     workshopBombs[i].GetPositionX(), workshopBombs[i].GetPositionY(),
                     workshopBombs[i].GetPositionZ(), workshopBombs[i].GetOrientation(),
                     0, 0, 0, 0, 10);
 
                     if (GameObject* seaforiumBombs = GetBGObject(BG_IC_GO_SEAFORIUM_BOMBS_1+i))
                     {
                         seaforiumBombs->SetRespawnTime(10);
                         seaforiumBombs->SetFaction(BG_IC_Factions[(node->faction == TEAM_ALLIANCE ? 0 : 1)]);
                     }
                 }
                 break;
             }
         default:
             break;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void BattlegroundIC::HandleContestedNodes ( ICNodePoint * node )

private

 {
     if (node->nodeType == NODE_TYPE_HANGAR)
     {
         if (gunshipAlliance && gunshipHorde)
             (node->faction == TEAM_ALLIANCE ? gunshipHorde : gunshipAlliance)->EnableMovement(false);
 
         for (uint8 u = BG_IC_GO_HANGAR_TELEPORTER_1; u <= BG_IC_GO_HANGAR_TELEPORTER_3; ++u)
             DelObject(u);
 
         for (uint8 u = BG_IC_GO_HANGAR_TELEPORTER_EFFECT_1; u <= BG_IC_GO_HANGAR_TELEPORTER_EFFECT_3; ++u)
             DelObject(u);
 
         DelCreature(BG_IC_NPC_WORLD_TRIGGER_NOT_FLOATING);
 
         for (uint8 u = 0; u < MAX_CAPTAIN_SPAWNS_PER_FACTION; ++u)
         {
             uint8 type = BG_IC_NPC_GUNSHIP_CAPTAIN_1 + u;
             DelCreature(type);
         }
 
         std::list<Creature*> cannons;
         if (node->faction == TEAM_HORDE)
             gunshipAlliance->GetCreatureListWithEntryInGrid(cannons, NPC_ALLIANCE_GUNSHIP_CANNON, 150.0f);
         else
             gunshipHorde->GetCreatureListWithEntryInGrid(cannons, NPC_HORDE_GUNSHIP_CANNON, 150.0f);
 
         for (Creature* cannon : cannons)
         {
             cannon->GetVehicleKit()->RemoveAllPassengers();
             cannon->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
         }
     }
     else if (node->nodeType == NODE_TYPE_WORKSHOP)
     {
         DelObject(BG_IC_GO_SEAFORIUM_BOMBS_1);
         DelObject(BG_IC_GO_SEAFORIUM_BOMBS_2);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
     if (GetStatus() != STATUS_IN_PROGRESS)
         return;
 
     Battleground::HandleKillPlayer(player, killer);
 
     factionReinforcements[player->GetTeamId()] -= 1;
 
     UpdateWorldState((player->GetTeamId() == TEAM_ALLIANCE ? BG_IC_ALLIANCE_RENFORT : BG_IC_HORDE_RENFORT), factionReinforcements[player->GetTeamId()]);
 
     // we must end the battleground
     if (factionReinforcements[player->GetTeamId()] < 1)
         EndBattleground(killer->GetTeam());
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
     if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
     uint32 entry = unit->GetEntry();
     if (entry == NPC_HIGH_COMMANDER_HALFORD_WYRMBANE)
     {
         RewardHonorToTeam(WINNER_HONOR_AMOUNT, HORDE);
         EndBattleground(HORDE);
     }
     else if (entry == NPC_OVERLORD_AGMAR)
     {
         RewardHonorToTeam(WINNER_HONOR_AMOUNT, ALLIANCE);
         EndBattleground(ALLIANCE);
     }
 
     //Achievement Mowed Down
     // TO-DO: This should be done on the script of each vehicle of the BG.
     if (unit->IsVehicle())
         killer->CastSpell(killer, SPELL_DESTROYED_VEHICLE_ACHIEVEMENT, true);
 }

Here is the call graph for this function:

void BattlegroundIC::HandlePlayerResurrect ( Player * player )

overridevirtual

Reimplemented from Battleground.

 {
     if (nodePoint[NODE_TYPE_QUARRY].nodeState == (player->GetTeamId() == TEAM_ALLIANCE ? NODE_STATE_CONTROLLED_A : NODE_STATE_CONTROLLED_H))
         player->CastSpell(player, SPELL_QUARRY, true);
 
     if (nodePoint[NODE_TYPE_REFINERY].nodeState == (player->GetTeamId() == TEAM_ALLIANCE ? NODE_STATE_CONTROLLED_A : NODE_STATE_CONTROLLED_H))
         player->CastSpell(player, SPELL_OIL_REFINERY, true);
 }

bool BattlegroundIC::IsAllNodesControlledByTeam ( uint32 team ) const

overridevirtual

Reimplemented from Battleground.

 {
     uint32 count = 0;
     ICNodeState controlledState = team == ALLIANCE ? NODE_STATE_CONTROLLED_A : NODE_STATE_CONTROLLED_H;
     for (int i = 0; i < NODE_TYPE_WORKSHOP; ++i)
     {
         if (nodePoint[i].nodeState == controlledState)
             ++count;
     }
 
     return count == NODE_TYPE_WORKSHOP;
 }

bool BattlegroundIC::IsSpellAllowed	(	uint32	spellId,
		Player const *	player
	)		const

overridevirtual

Reimplemented from Battleground.

 {
     switch (spellId)
     {
         case SPELL_OIL_REFINERY:
         case SPELL_QUARRY:
         {
             uint32 team = player->GetTeamId();
             uint8 nodeType = spellId == SPELL_OIL_REFINERY ? NODE_TYPE_REFINERY : NODE_TYPE_QUARRY;
             uint8 nodeState = team == TEAM_ALLIANCE ? NODE_STATE_CONTROLLED_A : NODE_STATE_CONTROLLED_H;
             return GetNodeState(nodeType) == nodeState;
         }
         default:
            break;
     }
 
     return true;
 }

Here is the call graph for this function:

void BattlegroundIC::PostUpdateImpl ( uint32 )

overridevirtual

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)
         return;
 
     if (!doorsClosed)
     {
         if (closeFortressDoorsTimer <= diff)
         {
             GetBGObject(BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR01)->RemoveFromWorld();
             GetBGObject(BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR01)->RemoveFromWorld();
             GetBGObject(BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR02)->RemoveFromWorld();
             GetBGObject(BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR02)->RemoveFromWorld();
             GetBGObject(BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR03)->RemoveFromWorld();
             GetBGObject(BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR03)->RemoveFromWorld();
 
             GetBGObject(BG_IC_GO_ALLIANCE_GATE_1)->SetDestructibleState(GO_DESTRUCTIBLE_DAMAGED);
             GetBGObject(BG_IC_GO_HORDE_GATE_1)->SetDestructibleState(GO_DESTRUCTIBLE_DAMAGED);
             GetBGObject(BG_IC_GO_ALLIANCE_GATE_2)->SetDestructibleState(GO_DESTRUCTIBLE_DAMAGED);
             GetBGObject(BG_IC_GO_HORDE_GATE_2)->SetDestructibleState(GO_DESTRUCTIBLE_DAMAGED);
             GetBGObject(BG_IC_GO_ALLIANCE_GATE_3)->SetDestructibleState(GO_DESTRUCTIBLE_DAMAGED);
             GetBGObject(BG_IC_GO_HORDE_GATE_3)->SetDestructibleState(GO_DESTRUCTIBLE_DAMAGED);
 
             doorsClosed = true;
         } else closeFortressDoorsTimer -= diff;
     }
 
     for (uint8 i = NODE_TYPE_REFINERY; i < MAX_NODE_TYPES; ++i)
     {
         if (nodePoint[i].nodeType == NODE_TYPE_DOCKS)
         {
             if (nodePoint[i].nodeState == NODE_STATE_CONTROLLED_A ||
                 nodePoint[i].nodeState == NODE_STATE_CONTROLLED_H)
             {
                 if (docksTimer <= diff)
                 {
                     // we need to confirm this, i am not sure if this every 3 minutes
                     for (uint8 u = (nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_NPC_CATAPULT_1_A : BG_IC_NPC_CATAPULT_1_H); u < (nodePoint[i].faction  == TEAM_ALLIANCE ? BG_IC_NPC_CATAPULT_4_A : BG_IC_NPC_CATAPULT_4_H); ++u)
                     {
                         if (Creature* catapult = GetBGCreature(u))
                         {
                             if (!catapult->IsAlive())
                                 catapult->Respawn(true);
                         }
                     }
 
                     // we need to confirm this is blizzlike, not sure if it is every 3 minutes
                     for (uint8 u = (nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_NPC_GLAIVE_THROWER_1_A : BG_IC_NPC_GLAIVE_THROWER_1_H); u < (nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_NPC_GLAIVE_THROWER_2_A : BG_IC_NPC_GLAIVE_THROWER_2_H); ++u)
                     {
                         if (Creature* glaiveThrower = GetBGCreature(u))
                         {
                             if (!glaiveThrower->IsAlive())
                                 glaiveThrower->Respawn(true);
                         }
                     }
 
                     docksTimer = DOCKS_UPDATE_TIME;
                 } else docksTimer -= diff;
             }
         }
 
         if (nodePoint[i].nodeType == NODE_TYPE_WORKSHOP)
         {
             if (nodePoint[i].nodeState == NODE_STATE_CONTROLLED_A ||
                 nodePoint[i].nodeState == NODE_STATE_CONTROLLED_H)
             {
                 if (siegeEngineWorkshopTimer <= diff)
                 {
                     uint8 siegeType = (nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_NPC_SIEGE_ENGINE_A : BG_IC_NPC_SIEGE_ENGINE_H);
 
                     if (Creature* siege = GetBGCreature(siegeType)) // this always should be true
                     {
                         if (siege->IsAlive())
                         {
                             if (siege->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_UNK_14|UNIT_FLAG_IMMUNE_TO_PC))
                                 // following sniffs the vehicle always has UNIT_FLAG_UNK_14
                                 siege->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_IMMUNE_TO_PC);
                             else
                                 siege->SetHealth(siege->GetMaxHealth());
                         }
                         else
                             siege->Respawn(true);
                     }
 
                     // we need to confirm if it is every 3 minutes
                     for (uint8 u = (nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_NPC_DEMOLISHER_1_A : BG_IC_NPC_DEMOLISHER_1_H); u < (nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_NPC_DEMOLISHER_4_A : BG_IC_NPC_DEMOLISHER_4_H); ++u)
                     {
                         if (Creature* demolisher = GetBGCreature(u))
                         {
                             if (!demolisher->IsAlive())
                                 demolisher->Respawn(true);
                         }
                     }
                     siegeEngineWorkshopTimer = WORKSHOP_UPDATE_TIME;
                 } else siegeEngineWorkshopTimer -= diff;
             }
         }
 
         // the point is waiting for a change on its banner
         if (nodePoint[i].needChange)
         {
             if (nodePoint[i].timer <= diff)
             {
                 uint32 nextBanner = GetNextBanner(&nodePoint[i], nodePoint[i].faction, true);
 
                 nodePoint[i].last_entry = nodePoint[i].gameobject_entry;
                 nodePoint[i].gameobject_entry = nextBanner;
                 // nodePoint[i].faction = the faction should be the same one...
 
                 GameObject* banner = GetBGObject(nodePoint[i].gameobject_type);
 
                 if (!banner) // this should never happen
                     return;
 
                 float cords[4] = {banner->GetPositionX(), banner->GetPositionY(), banner->GetPositionZ(), banner->GetOrientation() };
 
                 DelObject(nodePoint[i].gameobject_type);
                 AddObject(nodePoint[i].gameobject_type, nodePoint[i].gameobject_entry, cords[0], cords[1], cords[2], cords[3], 0, 0, 0, 0, RESPAWN_ONE_DAY);
 
                 GetBGObject(nodePoint[i].gameobject_type)->SetUInt32Value(GAMEOBJECT_FACTION, nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_Factions[1] : BG_IC_Factions[0]);
 
                 UpdateNodeWorldState(&nodePoint[i]);
                 HandleCapturedNodes(&nodePoint[i], false);
 
                 SendMessage2ToAll(LANG_BG_IC_TEAM_HAS_TAKEN_NODE, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL, (nodePoint[i].faction == TEAM_ALLIANCE ? LANG_BG_IC_ALLIANCE : LANG_BG_IC_HORDE), nodePoint[i].string);
 
                 nodePoint[i].needChange = false;
                 nodePoint[i].timer = BANNER_STATE_CHANGE_TIME;
             } else nodePoint[i].timer -= diff;
         }
     }
 
     if (resourceTimer <= diff)
     {
         for (uint8 i = 0; i < NODE_TYPE_DOCKS; ++i)
         {
             if (nodePoint[i].nodeState == NODE_STATE_CONTROLLED_A ||
                 nodePoint[i].nodeState == NODE_STATE_CONTROLLED_H)
             {
                 factionReinforcements[nodePoint[i].faction] += 1;
                 RewardHonorToTeam(RESOURCE_HONOR_AMOUNT, nodePoint[i].faction == TEAM_ALLIANCE ? ALLIANCE : HORDE);
                 UpdateWorldState((nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_ALLIANCE_RENFORT : BG_IC_HORDE_RENFORT), factionReinforcements[nodePoint[i].faction]);
             }
         }
         resourceTimer = IC_RESOURCE_TIME;
     } else resourceTimer -= diff;
 }

Here is the call graph for this function:

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

overridevirtual

Reimplemented from Battleground.

 {
     if (player)
     {
         player->RemoveAura(SPELL_QUARRY);
         player->RemoveAura(SPELL_OIL_REFINERY);
     }
 }

bool BattlegroundIC::SetupBattleground ( )

overridevirtual

Reimplemented from Battleground.

 {
     for (uint8 i = 0; i < MAX_NORMAL_GAMEOBJECTS_SPAWNS; ++i)
     {
         if (!AddObject(BG_IC_ObjSpawnlocs[i].type, BG_IC_ObjSpawnlocs[i].entry, BG_IC_ObjSpawnlocs[i].x, BG_IC_ObjSpawnlocs[i].y, BG_IC_ObjSpawnlocs[i].z, BG_IC_ObjSpawnlocs[i].o, 0, 0, 0, 0, RESPAWN_ONE_DAY))
         {
             TC_LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning gameobject %u", BG_IC_ObjSpawnlocs[i].entry);
             return false;
         }
     }
 
     for (uint8 i = 0; i < MAX_FORTRESS_TELEPORTERS_SPAWNS; ++i)
     {
         if (!AddObject(BG_IC_Teleporters[i].type, BG_IC_Teleporters[i].entry, BG_IC_Teleporters[i].x, BG_IC_Teleporters[i].y, BG_IC_Teleporters[i].z, BG_IC_Teleporters[i].o, 0, 0, 0, 0, RESPAWN_ONE_DAY))
         {
             TC_LOG_ERROR("bg.battleground", "Isle of Conquest | Starting Event Open Doors: There was an error spawning gameobject %u", BG_IC_Teleporters[i].entry);
             return false;
         }
     }
 
     for (uint8 i = 0; i < MAX_FORTRESS_TELEPORTER_EFFECTS_SPAWNS; ++i)
     {
         if (!AddObject(BG_IC_TeleporterEffects[i].type, BG_IC_TeleporterEffects[i].entry, BG_IC_TeleporterEffects[i].x, BG_IC_TeleporterEffects[i].y, BG_IC_TeleporterEffects[i].z, BG_IC_TeleporterEffects[i].o, 0, 0, 0, 0, RESPAWN_ONE_DAY))
         {
             TC_LOG_ERROR("bg.battleground", "Isle of Conquest | Starting Event Open Doors: There was an error spawning gameobject %u", BG_IC_Teleporters[i].entry);
             return false;
         }
     }
 
     for (uint8 i = 2; i < MAX_NORMAL_NPCS_SPAWNS; ++i)
     {
         if (!AddCreature(BG_IC_NpcSpawnlocs[i].entry, BG_IC_NpcSpawnlocs[i].type, BG_IC_NpcSpawnlocs[i].x, BG_IC_NpcSpawnlocs[i].y, BG_IC_NpcSpawnlocs[i].z, BG_IC_NpcSpawnlocs[i].o, BG_IC_NpcSpawnlocs[i].team, RESPAWN_ONE_DAY))
         {
             TC_LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning creature %u", BG_IC_NpcSpawnlocs[i].entry);
             return false;
         }
     }
 
     if (!AddSpiritGuide(BG_IC_NPC_SPIRIT_GUIDE_1+3, BG_IC_SpiritGuidePos[5], TEAM_ALLIANCE)
         || !AddSpiritGuide(BG_IC_NPC_SPIRIT_GUIDE_1+4, BG_IC_SpiritGuidePos[6], TEAM_HORDE)
         || !AddSpiritGuide(BG_IC_NPC_SPIRIT_GUIDE_1+5, BG_IC_SpiritGuidePos[7], TEAM_ALLIANCE)
         || !AddSpiritGuide(BG_IC_NPC_SPIRIT_GUIDE_1+6, BG_IC_SpiritGuidePos[8], TEAM_HORDE))
     {
         TC_LOG_ERROR("bg.battleground", "Isle of Conquest: Failed to spawn initial spirit guide!");
         return false;
     }
 
     gunshipHorde = sTransportMgr->CreateTransport(GO_HORDE_GUNSHIP, UI64LIT(0), GetBgMap());
     gunshipAlliance = sTransportMgr->CreateTransport(GO_ALLIANCE_GUNSHIP, UI64LIT(0), GetBgMap());
 
     if (!gunshipAlliance || !gunshipHorde)
     {
         TC_LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error creating gunships!");
         return false;
     }
 
     gunshipHorde->EnableMovement(false);
     gunshipAlliance->EnableMovement(false);
 
     // setting correct factions for Keep Cannons
     for (uint8 i = BG_IC_NPC_KEEP_CANNON_1; i <= BG_IC_NPC_KEEP_CANNON_12; ++i)
         GetBGCreature(i)->setFaction(BG_IC_Factions[0]);
     for (uint8 i = BG_IC_NPC_KEEP_CANNON_13; i <= BG_IC_NPC_KEEP_CANNON_24; ++i)
         GetBGCreature(i)->setFaction(BG_IC_Factions[1]);
 
     // correcting spawn time for keeps bombs
     for (uint8 i = BG_IC_GO_HUGE_SEAFORIUM_BOMBS_A_1; i < BG_IC_GO_HUGE_SEAFORIUM_BOMBS_H_4; ++i)
         GetBGObject(i)->SetRespawnTime(10);
 
     return true;
 }

Here is the call graph for this function:

void BattlegroundIC::SpawnLeader ( uint32 teamid )

void BattlegroundIC::StartingEventCloseDoors ( )

overridevirtual

Reimplemented from Battleground.

220 {

221 }

void BattlegroundIC::StartingEventOpenDoors ( )

overridevirtual

Reimplemented from Battleground.

 {
     //after 20 seconds they should be despawned
     DoorOpen(BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR01);
     DoorOpen(BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR01);
     DoorOpen(BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR02);
     DoorOpen(BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR02);
     DoorOpen(BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR03);
     DoorOpen(BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR03);
 
     DoorOpen(BG_IC_GO_DOODAD_HU_PORTCULLIS01_1);
     DoorOpen(BG_IC_GO_DOODAD_HU_PORTCULLIS01_2);
     DoorOpen(BG_IC_GO_DOODAD_VR_PORTCULLIS01_1);
     DoorOpen(BG_IC_GO_DOODAD_VR_PORTCULLIS01_2);
 
     for (uint8 i = 0; i < MAX_FORTRESS_TELEPORTERS_SPAWNS; ++i)
         GetBGObject(BG_IC_Teleporters[i].type)->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
 
     for (uint8 i = 0; i < MAX_FORTRESS_TELEPORTER_EFFECTS_SPAWNS; ++i)
         GetBGObject(BG_IC_TeleporterEffects[i].type)->SetGoState(GO_STATE_ACTIVE);
 }

Here is the call graph for this function:

void BattlegroundIC::UpdateNodeWorldState ( ICNodePoint * node )

private

 {
     //updating worldstate
     if (node->gameobject_entry == node->banners[BANNER_A_CONTROLLED])
         node->nodeState = NODE_STATE_CONTROLLED_A;
     else if (node->gameobject_entry == node->banners[BANNER_A_CONTESTED])
         node->nodeState = NODE_STATE_CONFLICT_A;
     else if (node->gameobject_entry == node->banners[BANNER_H_CONTROLLED])
         node->nodeState = NODE_STATE_CONTROLLED_H;
     else if (node->gameobject_entry == node->banners[BANNER_H_CONTESTED])
         node->nodeState = NODE_STATE_CONFLICT_H;
 
     uint32 worldstate = node->worldStates[node->nodeState];
 
     // with this we are sure we dont bug the client
     for (uint8 i = 0; i < 5; ++i)
     {
         if (node->worldStates[i] == worldstate)
             continue;
         UpdateWorldState(node->worldStates[i], 0);
     }
 
     UpdateWorldState(worldstate, 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

uint32 BattlegroundIC::closeFortressDoorsTimer

private

uint32 BattlegroundIC::docksTimer

private

bool BattlegroundIC::doorsClosed

private

uint16 BattlegroundIC::factionReinforcements[2]

private

BG_IC_GateState BattlegroundIC::GateStatus[6]

private

Transport* BattlegroundIC::gunshipAlliance

private

Transport* BattlegroundIC::gunshipHorde

private

ICNodePoint BattlegroundIC::nodePoint[7]

private

uint32 BattlegroundIC::resourceTimer

private

uint32 BattlegroundIC::siegeEngineWorkshopTimer

private

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

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation