#include "BattlegroundIC.h"

Inheritance diagram for BattlegroundIC:

Public Member Functions
	BattlegroundIC ()

void	AddPlayer (Player *player) override

void	StartingEventCloseDoors () override

void	StartingEventOpenDoors () override

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

void	RemovePlayer (Player *player) override

void	HandleAreaTrigger (Player *player, uint32 trigger) override

bool	SetupBattleground () override

void	HandleKillUnit (Creature unit, Player killer) override

void	HandleKillPlayer (Player player, Player killer) override

void	EventPlayerClickedOnFlag (Player source, GameObject ) override

void	EventPlayerDamagedGO (Player , GameObject , uint32) override

void	DestroyGate (Player player, GameObject go) override

GraveyardStruct const *	GetClosestGraveyard (Player *player) override

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

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

void	HandlePlayerResurrect (Player *player) override

uint32	GetNodeState (uint8 nodeType) const

bool	AllNodesConrolledByTeam (TeamId teamId) const override

bool	IsResourceGlutAllowed (TeamId teamId) const

void	DoAction (uint32 action, ObjectGuid guid) override

Public Member Functions inherited from Battleground
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual void	Init ()

virtual void	ResetBGSubclass ()

void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)

std::string	GetName () const

BattlegroundTypeId	GetBgTypeID (bool GetRandom=false) const

BattlegroundBracketId	GetBracketId () const

uint32	GetInstanceID () const

BattlegroundStatus	GetStatus () const

uint32	GetClientInstanceID () const

uint32	GetStartTime () const

uint32	GetEndTime () const

uint32	GetLastResurrectTime () const

uint32	GetMinLevel () const

uint32	GetMaxLevel () const

bool	isTemplate () const

bool	isMaxLevel () const

uint32	GetMaxPlayersPerTeam () const

uint32	GetMinPlayersPerTeam () const

int32	GetStartDelayTime () const

uint8	GetArenaType () const

PvPTeamId	GetWinner () const

uint32	GetScriptId () const

uint32	GetBonusHonorFromKill (uint32 kills) const

void	SpiritOfCompetitionEvent (PvPTeamId winnerTeamId) const

bool	IsRandom ()

void	SetName (std::string_view name)

void	SetBgTypeID (BattlegroundTypeId TypeID)

void	SetRandomTypeID (BattlegroundTypeId TypeID)

void	SetBracket (PvPDifficultyEntry const *bracketEntry)

void	SetInstanceID (uint32 InstanceID)

void	SetStatus (BattlegroundStatus Status)

void	SetClientInstanceID (uint32 InstanceID)

void	SetStartTime (uint32 Time)

void	SetEndTime (uint32 Time)

void	SetLastResurrectTime (uint32 Time)

void	SetLevelRange (uint32 min, uint32 max)

void	SetRated (bool state)

void	SetArenaType (uint8 type)

void	SetArenaorBGType (bool _isArena)

void	SetWinner (PvPTeamId winner)

void	SetScriptId (uint32 scriptId)

void	SetRandom (bool isRandom)

void	ModifyStartDelayTime (int32 diff)

void	SetStartDelayTime (int32 Time)

void	SetMaxPlayersPerTeam (uint32 MaxPlayers)

void	SetMinPlayersPerTeam (uint32 MinPlayers)

void	AddToBGFreeSlotQueue ()

void	RemoveFromBGFreeSlotQueue ()

void	DecreaseInvitedCount (TeamId teamId)

void	IncreaseInvitedCount (TeamId teamId)

uint32	GetInvitedCount (TeamId teamId) const

bool	HasFreeSlots () const

uint32	GetFreeSlotsForTeam (TeamId teamId) const

uint32	GetMaxFreeSlots () const

void	AddSpectator (Player *p)

void	RemoveSpectator (Player *p)

bool	HaveSpectators ()

const SpectatorList &	GetSpectators () const

void	AddToBeTeleported (ObjectGuid spectator, ObjectGuid participant)

void	RemoveToBeTeleported (ObjectGuid spectator)

void	SpectatorsSendPacket (WorldPacket &data)

bool	isArena () const

bool	isBattleground () const

bool	isRated () const

BattlegroundPlayerMap const &	GetPlayers () const

uint32	GetPlayersSize () const

void	ReadyMarkerClicked (Player *p)

BattlegroundScoreMap const *	GetPlayerScores () const

std::size_t	GetPlayerScoresSize () const

uint32	GetReviveQueueSize () const

void	AddPlayerToResurrectQueue (ObjectGuid npc_guid, ObjectGuid player_guid)

void	RemovePlayerFromResurrectQueue (Player *player)

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

void	StartBattleground ()

GameObject *	GetBGObject (uint32 type)

Creature *	GetBGCreature (uint32 type)

void	SetMapId (uint32 MapID)

uint32	GetMapId () const

void	SetBgMap (BattlegroundMap *map)

BattlegroundMap *	GetBgMap () const

BattlegroundMap *	FindBgMap () const

void	SetTeamStartPosition (TeamId teamId, Position const &pos)

Position const *	GetTeamStartPosition (TeamId teamId) const

void	SetStartMaxDist (float startMaxDist)

float	GetStartMaxDist () const

void	SendPacketToTeam (TeamId teamId, WorldPacket const packet, Player sender=nullptr, bool self=true)

void	SendPacketToAll (WorldPacket const *packet)

void	YellToAll (Creature creature, const char text, uint32 language)

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

void	SendBroadcastText (uint32 id, ChatMsg msgType, WorldObject const *target=nullptr)

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

void	PlaySoundToAll (uint32 soundId)

void	CastSpellOnTeam (uint32 spellId, TeamId teamId)

void	RemoveAuraOnTeam (uint32 spellId, TeamId teamId)

void	RewardHonorToTeam (uint32 honor, TeamId teamId)

void	RewardReputationToTeam (uint32 factionId, uint32 reputation, TeamId teamId)

uint32	GetRealRepFactionForPlayer (uint32 factionId, Player *player)

void	UpdateWorldState (uint32 variable, uint32 value)

void	EndBattleground (PvPTeamId winnerTeamId)

virtual void	EndBattleground (TeamId winnerTeamId)

void	BlockMovement (Player *player)

Group *	GetBgRaid (TeamId teamId) const

void	SetBgRaid (TeamId teamId, Group *bg_raid)

void	BuildPvPLogDataPacket (WorldPacket &data)

uint32	GetPlayersCountByTeam (TeamId teamId) const

uint32	GetAlivePlayersCountByTeam (TeamId teamId) const

void	UpdatePlayersCountByTeam (TeamId teamId, bool remove)

virtual void	CheckWinConditions ()

void	SetArenaTeamIdForTeam (TeamId teamId, uint32 ArenaTeamId)

uint32	GetArenaTeamIdForTeam (TeamId teamId) const

void	SetArenaMatchmakerRating (TeamId teamId, uint32 MMR)

uint32	GetArenaMatchmakerRating (TeamId teamId) const

virtual void	EventPlayerDroppedFlag (Player *)

virtual void	EventPlayerUsedGO (Player , GameObject )

void	AddOrSetPlayerToCorrectBgGroup (Player *player, TeamId teamId)

virtual void	RemovePlayerAtLeave (Player *player)

void	HandleTriggerBuff (GameObject *gameObject)

void	SetHoliday (bool is_holiday)

void	SpawnBGObject (uint32 type, uint32 respawntime, uint32 forceRespawnDelay=0)

bool	AddObject (uint32 type, uint32 entry, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime=0, GOState goState=GO_STATE_READY)

Creature *	AddCreature (uint32 entry, uint32 type, float x, float y, float z, float o, uint32 respawntime=0, MotionTransport *transport=nullptr)

bool	DelCreature (uint32 type)

bool	DelObject (uint32 type)

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

int32	GetObjectType (ObjectGuid guid)

void	DoorOpen (uint32 type)

void	DoorClose (uint32 type)

virtual bool	HandlePlayerUnderMap (Player *)

bool	IsPlayerInBattleground (ObjectGuid guid) const

bool	ToBeDeleted () const

void	RewardXPAtKill (Player killer, Player victim)

virtual ObjectGuid	GetFlagPickerGUID (TeamId=TEAM_NEUTRAL) const

virtual void	SetDroppedFlagGUID (ObjectGuid, TeamId=TEAM_NEUTRAL)

uint32	GetTeamScore (TeamId teamId) const

virtual TeamId	GetPrematureWinner ()

uint8	GetUniqueBracketId () const

BattlegroundAV *	ToBattlegroundAV ()

BattlegroundAV const *	ToBattlegroundAV () const

BattlegroundWS *	ToBattlegroundWS ()

BattlegroundWS const *	ToBattlegroundWS () const

BattlegroundAB *	ToBattlegroundAB ()

BattlegroundAB const *	ToBattlegroundAB () const

BattlegroundNA *	ToBattlegroundNA ()

BattlegroundNA const *	ToBattlegroundNA () const

BattlegroundBE *	ToBattlegroundBE ()

BattlegroundBE const *	ToBattlegroundBE () const

BattlegroundEY *	ToBattlegroundEY ()

BattlegroundEY const *	ToBattlegroundEY () const

BattlegroundRL *	ToBattlegroundRL ()

BattlegroundRL const *	ToBattlegroundRL () const

BattlegroundSA *	ToBattlegroundSA ()

BattlegroundSA const *	ToBattlegroundSA () const

BattlegroundDS *	ToBattlegroundDS ()

BattlegroundDS const *	ToBattlegroundDS () const

BattlegroundRV *	ToBattlegroundRV ()

BattlegroundRV const *	ToBattlegroundRV () const

BattlegroundIC *	ToBattlegroundIC ()

BattlegroundIC const *	ToBattlegroundIC () const

Private Types
typedef std::map< ObjectGuid, uint32 >	RespawnMap

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

uint32	GetGateIDFromEntry (uint32 id)

uint32	GetWorldStateFromGateEntry (uint32 id, bool open)

void	UpdateNodeWorldState (ICNodePoint *nodePoint)

void	HandleCapturedNodes (ICNodePoint *nodePoint, bool recapture)

void	HandleContestedNodes (ICNodePoint *nodePoint)

void	TurnBosses (bool on)

Private Attributes
uint32	closeFortressDoorsTimer

bool	doorsClosed

uint32	docksTimer

uint32	resourceTimer

uint32	siegeEngineWorkshopTimer

uint16	factionReinforcements [2]

BG_IC_GateState	GateStatus [6]

ICNodePoint	nodePoint [7]

RespawnMap	respawnMap

MotionTransport *	gunshipAlliance

MotionTransport *	gunshipHorde

Additional Inherited Members
Public Types inherited from Battleground
typedef std::set< Player * >	SpectatorList

typedef std::map< ObjectGuid, ObjectGuid >	ToBeTeleportedMap

typedef std::map< ObjectGuid, Player * >	BattlegroundPlayerMap

typedef std::unordered_map< ObjectGuid::LowType, BattlegroundScore * >	BattlegroundScoreMap

typedef std::unordered_map< ObjectGuid, ArenaLogEntryData >	ArenaLogEntryDataMap

typedef GuidVector	BGObjects

typedef GuidVector	BGCreatures

Static Public Member Functions inherited from Battleground
static TeamId	GetOtherTeamId (TeamId teamId)

Public Attributes inherited from Battleground
GuidSet	readyMarkerClickedSet

ArenaLogEntryDataMap	ArenaLogEntries

BGObjects	BgObjects

BGCreatures	BgCreatures

Protected Member Functions inherited from Battleground
void	EndNow ()

void	PlayerAddedToBGCheckIfBGIsRunning (Player *player)

void	_ProcessResurrect (uint32 diff)

void	_ProcessProgress (uint32 diff)

void	_ProcessLeave (uint32 diff)

void	_ProcessJoin (uint32 diff)

void	_CheckSafePositions (uint32 diff)

Protected Attributes inherited from Battleground
bool	m_SetupCompleted

BattlegroundScoreMap	PlayerScores

BattlegroundPlayerMap	m_Players

std::map< ObjectGuid, GuidVector >	m_ReviveQueue

uint8	m_Events

BattlegroundStartTimeIntervals	StartDelayTimes [BG_STARTING_EVENT_COUNT]

uint32	StartMessageIds [BG_STARTING_EVENT_COUNT]

bool	m_BuffChange

bool	m_IsRandom

BGHonorMode	m_HonorMode

int32	m_TeamScores [PVP_TEAMS_COUNT]

ArenaTeamScore	_arenaTeamScores [PVP_TEAMS_COUNT]

uint32	m_UpdateTimer

EventProcessor	_reviveEvents

Detailed Description

Member Typedef Documentation

◆ RespawnMap

typedef std::map<ObjectGuid, uint32> BattlegroundIC::RespawnMap

private

Constructor & Destructor Documentation

◆ BattlegroundIC()

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);
 
    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 = nullptr;
    gunshipAlliance = nullptr;
    respawnMap.clear();
}

References BG_IC_GATE_OK, BG_IC_MAXDOOR, Battleground::BgCreatures, Battleground::BgObjects, CLOSE_DOORS_TIME, closeFortressDoorsTimer, DOCKS_UPDATE_TIME, docksTimer, doorsClosed, factionReinforcements, GateStatus, gunshipAlliance, gunshipHorde, IC_RESOURCE_TIME, MAX_AIRSHIPS_SPAWNS, MAX_DOCKS_SPAWNS, MAX_FORTRESS_TELEPORTER_EFFECTS_SPAWNS, MAX_FORTRESS_TELEPORTERS_SPAWNS, MAX_HANGAR_NPCS_SPAWNS, MAX_HANGAR_TELEPORTER_EFFECTS_SPAWNS, MAX_HANGAR_TELEPORTERS_SPAWNS, MAX_NODE_TYPES, MAX_NORMAL_GAMEOBJECTS_SPAWNS, MAX_NORMAL_NPCS_SPAWNS, MAX_REINFORCEMENTS, MAX_SPIRIT_GUIDES_SPAWNS, MAX_WORKSHOP_SPAWNS, NODE_TYPE_REFINERY, nodePoint, nodePointInitial, resourceTimer, respawnMap, siegeEngineWorkshopTimer, and WORKSHOP_UPDATE_TIME.

Member Function Documentation

◆ AddPlayer()

void BattlegroundIC::AddPlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

{
    Battleground::AddPlayer(player);
    PlayerScores.emplace(player->GetGUID().GetCounter(), new BattlegroundICScore(player->GetGUID()));
 
    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);
}

References Battleground::AddPlayer(), Unit::CastSpell(), ObjectGuid::GetCounter(), Object::GetGUID(), Player::GetTeamId(), NODE_STATE_CONTROLLED_A, NODE_STATE_CONTROLLED_H, NODE_TYPE_QUARRY, NODE_TYPE_REFINERY, nodePoint, Battleground::PlayerScores, SPELL_OIL_REFINERY, SPELL_QUARRY, and TEAM_ALLIANCE.

◆ AllNodesConrolledByTeam()

bool BattlegroundIC::AllNodesConrolledByTeam ( TeamId teamId ) const

overridevirtual

Reimplemented from Battleground.

{
    uint32 count = 0;
    ICNodeState controlledState = teamId == 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;
}

References NODE_STATE_CONTROLLED_A, NODE_STATE_CONTROLLED_H, NODE_TYPE_WORKSHOP, nodePoint, and TEAM_ALLIANCE.

◆ DestroyGate()

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);
    }
 
    uint32 textId;
    ChatMsg msgType;
    TeamId teamId = TEAM_ALLIANCE;
 
    switch (go->GetEntry())
    {
        case GO_HORDE_GATE_1:
            textId = BG_IC_TEXT_FRONT_GATE_HORDE_DESTROYED;
            msgType = CHAT_MSG_BG_SYSTEM_ALLIANCE;
            break;
        case GO_HORDE_GATE_2:
            textId = BG_IC_TEXT_WEST_GATE_HORDE_DESTROYED;
            msgType = CHAT_MSG_BG_SYSTEM_ALLIANCE;
            break;
        case GO_HORDE_GATE_3:
            textId = BG_IC_TEXT_EAST_GATE_HORDE_DESTROYED;
            msgType = CHAT_MSG_BG_SYSTEM_ALLIANCE;
            break;
        case GO_ALLIANCE_GATE_1:
            textId = BG_IC_TEXT_WEST_GATE_ALLIANCE_DESTROYED;
            msgType = CHAT_MSG_BG_SYSTEM_HORDE;
            teamId = TEAM_HORDE;
            break;
        case GO_ALLIANCE_GATE_2:
            textId = BG_IC_TEXT_EAST_GATE_ALLIANCE_DESTROYED;
            msgType = CHAT_MSG_BG_SYSTEM_HORDE;
            teamId = TEAM_HORDE;
            break;
        case GO_ALLIANCE_GATE_3:
            textId = BG_IC_TEXT_FRONT_GATE_ALLIANCE_DESTROYED;
            msgType = CHAT_MSG_BG_SYSTEM_HORDE;
            teamId = TEAM_HORDE;
            break;
        default:
            return;
    }
 
    if (teamId == 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);
    }
 
    TurnBosses(true);
    SendBroadcastText(textId, msgType);
}

References BG_IC_GATE_DESTROYED, BG_IC_GO_ALLIANCE_BANNER, BG_IC_GO_DOODAD_PORTCULLISACTIVE02, BG_IC_GO_HORDE_BANNER, BG_IC_GO_HORDE_KEEP_PORTCULLIS, BG_IC_TEXT_EAST_GATE_ALLIANCE_DESTROYED, BG_IC_TEXT_EAST_GATE_HORDE_DESTROYED, BG_IC_TEXT_FRONT_GATE_ALLIANCE_DESTROYED, BG_IC_TEXT_FRONT_GATE_HORDE_DESTROYED, BG_IC_TEXT_WEST_GATE_ALLIANCE_DESTROYED, BG_IC_TEXT_WEST_GATE_HORDE_DESTROYED, CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, Battleground::DoorOpen(), GAMEOBJECT_FLAGS, GateStatus, Battleground::GetBGObject(), Object::GetEntry(), GetGateIDFromEntry(), GetWorldStateFromGateEntry(), GO_ALLIANCE_GATE_1, GO_ALLIANCE_GATE_2, GO_ALLIANCE_GATE_3, GO_FLAG_NOT_SELECTABLE, GO_HORDE_GATE_1, GO_HORDE_GATE_2, GO_HORDE_GATE_3, Object::RemoveFlag(), Battleground::SendBroadcastText(), TEAM_ALLIANCE, TEAM_HORDE, TurnBosses(), and Battleground::UpdateWorldState().

◆ DoAction()

void BattlegroundIC::DoAction	(	uint32	action,
		ObjectGuid	guid
	)

overridevirtual

Reimplemented from Battleground.

{
    if (action != ACTION_TELEPORT_PLAYER_TO_TRANSPORT)
        return;
 
    if (!gunshipAlliance || !gunshipHorde)
        return;
 
    Player* player = ObjectAccessor::GetPlayer(*gunshipAlliance, guid);
    if (!player)
        return;
 
    MotionTransport* transport = player->GetTeamId() == TEAM_ALLIANCE ? gunshipAlliance : gunshipHorde;
    float x = BG_IC_HangarTrigger[player->GetTeamId()].GetPositionX();
    float y = BG_IC_HangarTrigger[player->GetTeamId()].GetPositionY();
    float z = BG_IC_HangarTrigger[player->GetTeamId()].GetPositionZ();
    transport->CalculatePassengerPosition(x, y, z);
 
    player->TeleportTo(GetMapId(), x, y, z, player->GetOrientation(), TELE_TO_NOT_LEAVE_TRANSPORT);
}

References ACTION_TELEPORT_PLAYER_TO_TRANSPORT, BG_IC_HangarTrigger, Transport::CalculatePassengerPosition(), Battleground::GetMapId(), Position::GetOrientation(), ObjectAccessor::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Player::GetTeamId(), gunshipAlliance, gunshipHorde, TEAM_ALLIANCE, TELE_TO_NOT_LEAVE_TRANSPORT, and Player::TeleportTo().

◆ EventPlayerClickedOnFlag()

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

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)
    {
        ICNodePoint& point = nodePoint[i];
        if (point.gameobject_entry == gameObject->GetEntry())
        {
            // THIS SHOULD NEEVEER HAPPEN
            if (point.faction == player->GetTeamId())
            {
                return;
            }
 
            // Prevent capturing of keep if none of gates was destroyed
            if (point.gameobject_entry == GO_ALLIANCE_BANNER)
            {
                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)
                {
                    return;
                }
            }
            else if (point.gameobject_entry == GO_HORDE_BANNER)
            {
                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)
                {
                    return;
                }
            }
 
            uint32 nextBanner = GetNextBanner(&point, player->GetTeamId(), false);
 
            // we set the new settings of the nodePoint
            point.faction = player->GetTeamId();
            point.last_entry = point.gameobject_entry;
            point.gameobject_entry = nextBanner;
 
            // this is just needed if the next banner is grey
            if (point.banners[BANNER_A_CONTESTED] == nextBanner || point.banners[BANNER_H_CONTESTED] == nextBanner)
            {
                point.timer = BANNER_STATE_CHANGE_TIME; // 1 minute for last change (real faction banner)
                point.needChange = true;
 
                _reviveEvents.AddEventAtOffset([this, point]()
                {
                    RelocateDeadPlayers(BgCreatures[static_cast<uint16>(BG_IC_NPC_SPIRIT_GUIDE_1) + point.nodeType - 2]);
 
                    // if we are here means that the point has been lost, or it is the first capture
                    if (point.nodeType != NODE_TYPE_REFINERY && point.nodeType != NODE_TYPE_QUARRY)
                    {
                        if (BgCreatures[static_cast<uint16>(BG_IC_NPC_SPIRIT_GUIDE_1) + (point.nodeType) - 2])
                        {
                            DelCreature(static_cast<uint16>(BG_IC_NPC_SPIRIT_GUIDE_1) + (point.nodeType) - 2);
                        }
                    }
                }, 500ms);
 
                UpdatePlayerScore(player, SCORE_BASES_ASSAULTED, 1);
 
                if (nodePoint[i].faction == TEAM_ALLIANCE)
                {
                    SendBroadcastText(ICNodes[i].TextAssaulted, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
                }
                else
                {
                    SendBroadcastText(ICNodes[i].TextAssaulted, CHAT_MSG_BG_SYSTEM_HORDE, player);
                }
 
                HandleContestedNodes(&point);
            }
            else if (nextBanner == point.banners[BANNER_A_CONTROLLED] || nextBanner == point.banners[BANNER_H_CONTROLLED])
                // if we are going to spawn the definitve faction banner, we dont need the timer anymore
            {
                point.timer = BANNER_STATE_CHANGE_TIME;
                point.needChange = false;
 
                if (nodePoint[i].faction == TEAM_ALLIANCE)
                {
                    SendBroadcastText(ICNodes[i].TextDefended, CHAT_MSG_BG_SYSTEM_ALLIANCE, player);
                }
                else
                {
                    SendBroadcastText(ICNodes[i].TextDefended, CHAT_MSG_BG_SYSTEM_HORDE, player);
                }
 
                HandleCapturedNodes(&point, true);
                UpdatePlayerScore(player, SCORE_BASES_DEFENDED, 1);
            }
 
            GameObject* banner = GetBGObject(point.gameobject_type);
 
            if (!banner) // this should never happen
            {
                return;
            }
 
            float cords[4] = {banner->GetPositionX(), banner->GetPositionY(), banner->GetPositionZ(), banner->GetOrientation() };
 
            DelObject(point.gameobject_type);
            AddObject(point.gameobject_type, point.gameobject_entry, cords[0], cords[1], cords[2], cords[3], 0, 0, 0, 0, RESPAWN_ONE_DAY);
 
            GetBGObject(point.gameobject_type)->SetUInt32Value(GAMEOBJECT_FACTION, point.faction == TEAM_ALLIANCE ? BG_IC_Factions[1] : BG_IC_Factions[0]);
 
            UpdateNodeWorldState(&point);
            // 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;
        }
    }
}

References Battleground::_reviveEvents, EventProcessor::AddEventAtOffset(), Battleground::AddObject(), BANNER_A_CONTESTED, BANNER_A_CONTROLLED, BANNER_H_CONTESTED, BANNER_H_CONTROLLED, BANNER_STATE_CHANGE_TIME, ICNodePoint::banners, BG_IC_A_EAST, BG_IC_A_FRONT, BG_IC_A_WEST, BG_IC_Factions, BG_IC_GATE_DESTROYED, BG_IC_H_EAST, BG_IC_H_FRONT, BG_IC_H_WEST, BG_IC_NPC_SPIRIT_GUIDE_1, Battleground::BgCreatures, CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, cords, Battleground::DelCreature(), Battleground::DelObject(), ICNodePoint::faction, ICNodePoint::gameobject_entry, GAMEOBJECT_FACTION, ICNodePoint::gameobject_type, GateStatus, Battleground::GetBGObject(), Object::GetEntry(), GetNextBanner(), Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Battleground::GetStatus(), Player::GetTeamId(), GO_ALLIANCE_BANNER, GO_HORDE_BANNER, HandleCapturedNodes(), HandleContestedNodes(), ICNodes, ICNodePoint::last_entry, MAX_NODE_TYPES, ICNodePoint::needChange, NODE_TYPE_QUARRY, NODE_TYPE_REFINERY, nodePoint, ICNodePoint::nodeType, Battleground::RelocateDeadPlayers(), RESPAWN_ONE_DAY, SCORE_BASES_ASSAULTED, SCORE_BASES_DEFENDED, Battleground::SendBroadcastText(), Object::SetUInt32Value(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, ICNodePoint::timer, UpdateNodeWorldState(), and UpdatePlayerScore().

◆ EventPlayerDamagedGO()

void BattlegroundIC::EventPlayerDamagedGO	(	Player *	,
		GameObject *	,
		uint32
	)

inlineoverridevirtual

Reimplemented from Battleground.

908{ }

◆ FillInitialWorldStates()

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

overridevirtual

Reimplemented from Battleground.

{
    packet.Worldstates.reserve(4+MAX_FORTRESS_GATES_SPAWNS+MAX_NODE_TYPES+1);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_IC_ALLIANCE_REINFORCEMENT_SET, 1);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_IC_HORDE_REINFORCEMENT_SET, 1);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_IC_ALLIANCE_REINFORCEMENT, factionReinforcements[TEAM_ALLIANCE]);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_IC_HORDE_REINFORCEMENT, 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));
        packet.Worldstates.emplace_back(uws, 1);
    }
 
    for (uint8 i = 0; i < MAX_NODE_TYPES; ++i)
        packet.Worldstates.emplace_back(nodePoint[i].worldStates[nodePoint[i].nodeState], 1);
 
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEGROUND_IC_HORDE_REINFORCEMENT_SET, 1);
}

References BG_IC_GATE_DESTROYED, BG_IC_ObjSpawnlocs, factionReinforcements, GateStatus, GetGateIDFromEntry(), GetWorldStateFromGateEntry(), MAX_FORTRESS_GATES_SPAWNS, MAX_NODE_TYPES, nodePoint, ICNodePoint::nodeState, TEAM_ALLIANCE, TEAM_HORDE, WORLD_STATE_BATTLEGROUND_IC_ALLIANCE_REINFORCEMENT, WORLD_STATE_BATTLEGROUND_IC_ALLIANCE_REINFORCEMENT_SET, WORLD_STATE_BATTLEGROUND_IC_HORDE_REINFORCEMENT, WORLD_STATE_BATTLEGROUND_IC_HORDE_REINFORCEMENT_SET, ICNodePoint::worldStates, and WorldPackets::WorldState::InitWorldStates::Worldstates.

◆ GetClosestGraveyard()

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

overridevirtual

Reimplemented from Battleground.

{
    // 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() && !nodePoint[i].needChange) // xinef: controlled by faction and not contested!
            nodes.push_back(i);
 
    GraveyardStruct const* good_entry = nullptr;
    // If so, select the closest node to place ghost on
    if (!nodes.empty())
    {
        float plr_x = player->GetPositionX();
        float plr_y = player->GetPositionY();
 
        float mindist = 999999.0f;
        for (uint8 i = 0; i < nodes.size(); ++i)
        {
            GraveyardStruct const* entry = sGraveyard->GetGraveyard(BG_IC_GraveyardIds[nodes[i]]);
            if (!entry)
                continue;
            float dist = (entry->x - plr_x) * (entry->x - plr_x) + (entry->y - plr_y) * (entry->y - plr_y);
            if (mindist > dist)
            {
                mindist = dist;
                good_entry = entry;
            }
        }
        nodes.clear();
    }
    // If not, place ghost on starting location
    if (!good_entry)
        good_entry = sGraveyard->GetGraveyard(BG_IC_GraveyardIds[player->GetTeamId() + static_cast<uint16>(MAX_NODE_TYPES)]);
 
    return good_entry;
}

References BG_IC_GraveyardIds, Position::GetPositionX(), Position::GetPositionY(), Player::GetTeamId(), MAX_NODE_TYPES, ICNodePoint::needChange, nodePoint, sGraveyard, GraveyardStruct::x, and GraveyardStruct::y.

◆ GetGateIDFromEntry()

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_EAST;
                break;
            case GO_HORDE_GATE_3:
                i = BG_IC_H_WEST;
                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;
    }

References BG_IC_A_EAST, BG_IC_A_FRONT, BG_IC_A_WEST, BG_IC_H_EAST, BG_IC_H_FRONT, BG_IC_H_WEST, GO_ALLIANCE_GATE_1, GO_ALLIANCE_GATE_2, GO_ALLIANCE_GATE_3, GO_HORDE_GATE_1, GO_HORDE_GATE_2, and GO_HORDE_GATE_3.

Referenced by DestroyGate(), and FillInitialWorldStates().

◆ GetNextBanner()

uint32 BattlegroundIC::GetNextBanner	(	ICNodePoint *	nodePoint,
		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 nodePoint->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 (nodePoint->last_entry == 0)
        // 1 returns the CONTESTED ALLIANCE BANNER, 3 returns the HORDE one
        return nodePoint->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 (nodePoint->gameobject_entry == nodePoint->banners[BANNER_A_CONTROLLED] || nodePoint->gameobject_entry == nodePoint->banners[BANNER_H_CONTROLLED])
        return nodePoint->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 (nodePoint->gameobject_entry == nodePoint->banners[BANNER_A_CONTESTED] || nodePoint->banners[BANNER_H_CONTESTED])
        return nodePoint->last_entry;
 
    // we should never be here...
    LOG_ERROR("bg.battleground", "Isle Of Conquest: Unexpected return in GetNextBanner function");
    return 0;
}

References BANNER_A_CONTESTED, BANNER_A_CONTROLLED, BANNER_H_CONTESTED, BANNER_H_CONTROLLED, ICNodePoint::banners, ICNodePoint::gameobject_entry, ICNodePoint::last_entry, LOG_ERROR, nodePoint, and TEAM_ALLIANCE.

Referenced by EventPlayerClickedOnFlag(), and PostUpdateImpl().

◆ GetNodeState()

uint32 BattlegroundIC::GetNodeState ( uint8 nodeType ) const

inline

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

Referenced by SpellArea::IsFitToRequirements().

◆ GetWorldStateFromGateEntry()

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

inlineprivate

    {
        uint32 uws = 0;
 
        switch (id)
        {
            case GO_HORDE_GATE_1:
                uws = (open ? WORLD_STATE_BATTLEGROUND_IC_GATE_FRONT_H_WS_OPEN : WORLD_STATE_BATTLEGROUND_IC_GATE_FRONT_H_WS_CLOSED);
                break;
            case GO_HORDE_GATE_2:
                uws = (open ? WORLD_STATE_BATTLEGROUND_IC_GATE_EAST_H_WS_OPEN : WORLD_STATE_BATTLEGROUND_IC_GATE_EAST_H_WS_CLOSED);
                break;
            case GO_HORDE_GATE_3:
                uws = (open ? WORLD_STATE_BATTLEGROUND_IC_GATE_WEST_H_WS_OPEN : WORLD_STATE_BATTLEGROUND_IC_GATE_WEST_H_WS_CLOSED);
                break;
            case GO_ALLIANCE_GATE_3:
                uws = (open ? WORLD_STATE_BATTLEGROUND_IC_GATE_FRONT_A_WS_OPEN : WORLD_STATE_BATTLEGROUND_IC_GATE_FRONT_A_WS_CLOSED);
                break;
            case GO_ALLIANCE_GATE_1:
                uws = (open ? WORLD_STATE_BATTLEGROUND_IC_GATE_WEST_A_WS_OPEN : WORLD_STATE_BATTLEGROUND_IC_GATE_WEST_A_WS_CLOSED);
                break;
            case GO_ALLIANCE_GATE_2:
                uws = (open ? WORLD_STATE_BATTLEGROUND_IC_GATE_EAST_A_WS_OPEN : WORLD_STATE_BATTLEGROUND_IC_GATE_EAST_A_WS_CLOSED);
                break;
        }
        return uws;
    }

Referenced by DestroyGate(), and FillInitialWorldStates().

◆ HandleAreaTrigger()

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

overridevirtual

Reimplemented from Battleground.

{
    // this is wrong way to implement these things. On official it done by gameobject spell cast.
    if (GetStatus() != STATUS_IN_PROGRESS)
        return;
 
    switch (trigger)
    {
        case AREA_TRIGGER_HORDE_KEEP:
            if (player->GetTeamId() != TEAM_ALLIANCE)
                return;
            for (uint8 i = BG_IC_H_FRONT; i < BG_IC_A_FRONT; ++i)
                if (GateStatus[i] == BG_IC_GATE_DESTROYED)
                    return;
            if (!player->HasAchieved(3854)) // ACHIEVEMENT_BACK_DOOR_JOB
                player->CastSpell(player, SPELL_BACK_DOOR_JOB, true);
            break;
        case AREA_TRIGGER_ALLIANCE_KEEP:
            if (player->GetTeamId() != TEAM_HORDE)
                return;
            for (uint8 i = BG_IC_A_FRONT; i < BG_IC_MAXDOOR; ++i)
                if (GateStatus[i] == BG_IC_GATE_DESTROYED)
                    return;
            if (!player->HasAchieved(3854)) // ACHIEVEMENT_BACK_DOOR_JOB
                player->CastSpell(player, SPELL_BACK_DOOR_JOB, true);
            break;
    }
}

References AREA_TRIGGER_ALLIANCE_KEEP, AREA_TRIGGER_HORDE_KEEP, BG_IC_A_FRONT, BG_IC_GATE_DESTROYED, BG_IC_H_FRONT, BG_IC_MAXDOOR, Unit::CastSpell(), GateStatus, Battleground::GetStatus(), Player::GetTeamId(), Player::HasAchieved(), SPELL_BACK_DOOR_JOB, STATUS_IN_PROGRESS, TEAM_ALLIANCE, and TEAM_HORDE.

◆ HandleCapturedNodes()

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

private

{
    if (nodePoint->nodeType != NODE_TYPE_REFINERY && nodePoint->nodeType != NODE_TYPE_QUARRY)
    {
        if (!AddSpiritGuide(static_cast<uint16>(BG_IC_NPC_SPIRIT_GUIDE_1) + nodePoint->nodeType - 2,
                            BG_IC_SpiritGuidePos[nodePoint->nodeType][0], BG_IC_SpiritGuidePos[nodePoint->nodeType][1],
                            BG_IC_SpiritGuidePos[nodePoint->nodeType][2], BG_IC_SpiritGuidePos[nodePoint->nodeType][3],
                            nodePoint->faction))
            LOG_ERROR("bg.battleground", "Isle of Conquest: Failed to spawn spirit guide! point: {}, team: {}, ", nodePoint->nodeType, nodePoint->faction);
    }
 
    switch (nodePoint->gameobject_type)
    {
        case BG_IC_GO_HANGAR_BANNER:
            {
                if (!gunshipAlliance || !gunshipHorde)
                    break;
 
                std::list<Creature*> cannons;
                if (nodePoint->faction == TEAM_ALLIANCE)
                    gunshipAlliance->GetCreatureListWithEntryInGrid(cannons, NPC_ALLIANCE_GUNSHIP_CANNON, 150.0f);
                else
                    gunshipHorde->GetCreatureListWithEntryInGrid(cannons, NPC_HORDE_GUNSHIP_CANNON, 150.0f);
 
                for (std::list<Creature*>::const_iterator itr = cannons.begin(); itr != cannons.end(); ++itr)
                    (*itr)->RemoveUnitFlag(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, (nodePoint->faction == TEAM_ALLIANCE ? GO_ALLIANCE_GUNSHIP_PORTAL : GO_HORDE_GUNSHIP_PORTAL), BG_IC_HangarTeleporters[u].GetPositionX(), BG_IC_HangarTeleporters[u].GetPositionY(), BG_IC_HangarTeleporters[u].GetPositionZ(), BG_IC_HangarTeleporters[u].GetOrientation(), 0, 0, 0, 0, RESPAWN_ONE_DAY))
                        LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning a gunship portal. Type: {}", 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, (nodePoint->faction == TEAM_ALLIANCE ? GO_ALLIANCE_GUNSHIP_PORTAL_EFFECTS : GO_HORDE_GUNSHIP_PORTAL_EFFECTS), BG_IC_HangarTeleporterEffects[u].GetPositionX(), BG_IC_HangarTeleporterEffects[u].GetPositionY(), BG_IC_HangarTeleporterEffects[u].GetPositionZ(), BG_IC_HangarTeleporterEffects[u].GetOrientation(), 0, 0, 0, 0, RESPAWN_ONE_DAY, GO_STATE_ACTIVE))
                        LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning a gunship portal effects. Type: {}", 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[nodePoint->faction].GetPositionX(), BG_IC_HangarTrigger[nodePoint->faction].GetPositionY(), BG_IC_HangarTrigger[nodePoint->faction].GetPositionZ(), BG_IC_HangarTrigger[nodePoint->faction].GetOrientation(), RESPAWN_ONE_DAY, nodePoint->faction == TEAM_ALLIANCE ? gunshipAlliance : gunshipHorde))
                        LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning a world trigger. Type: {}", 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(nodePoint->faction == TEAM_ALLIANCE ? NPC_ALLIANCE_GUNSHIP_CAPTAIN : NPC_HORDE_GUNSHIP_CAPTAIN, type, BG_IC_HangarCaptains[nodePoint->faction == TEAM_ALLIANCE ? 2 : 0].GetPositionX(), BG_IC_HangarCaptains[nodePoint->faction == TEAM_ALLIANCE ? 2 : 0].GetPositionY(), BG_IC_HangarCaptains[nodePoint->faction == TEAM_ALLIANCE ? 2 : 0].GetPositionZ(), BG_IC_HangarCaptains[nodePoint->faction == TEAM_ALLIANCE ? 2 : 0].GetOrientation(), 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(nodePoint->faction == TEAM_ALLIANCE ? NPC_ALLIANCE_GUNSHIP_CAPTAIN : NPC_HORDE_GUNSHIP_CAPTAIN, type, BG_IC_HangarCaptains[nodePoint->faction == TEAM_ALLIANCE ? 3 : 1].GetPositionX(), BG_IC_HangarCaptains[nodePoint->faction == TEAM_ALLIANCE ? 3 : 1].GetPositionY(), BG_IC_HangarCaptains[nodePoint->faction == TEAM_ALLIANCE ? 3 : 1].GetPositionZ(), BG_IC_HangarCaptains[nodePoint->faction == TEAM_ALLIANCE ? 3 : 1].GetOrientation(), RESPAWN_ONE_DAY, nodePoint->faction == TEAM_ALLIANCE ? gunshipAlliance : gunshipHorde))
                            LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning a world trigger. Type: {}", BG_IC_NPC_GUNSHIP_CAPTAIN_2);
                }
 
                (nodePoint->faction == TEAM_ALLIANCE ? gunshipAlliance : gunshipHorde)->EnableMovement(true);
                break;
            }
        case BG_IC_GO_QUARRY_BANNER:
            RemoveAuraOnTeam(SPELL_QUARRY, GetOtherTeamId(nodePoint->faction));
            CastSpellOnTeam(SPELL_QUARRY, nodePoint->faction);
            break;
        case BG_IC_GO_REFINERY_BANNER:
            RemoveAuraOnTeam(SPELL_OIL_REFINERY, GetOtherTeamId(nodePoint->faction));
            CastSpellOnTeam(SPELL_OIL_REFINERY, nodePoint->faction);
            break;
        case BG_IC_GO_DOCKS_BANNER:
            if (recapture)
                break;
 
            if (docksTimer < DOCKS_UPDATE_TIME)
                docksTimer = DOCKS_UPDATE_TIME;
 
            // spawning glaive throwers
            for (uint8 i = 0; i < MAX_GLAIVE_THROWERS_SPAWNS_PER_FACTION; ++i)
            {
                uint8 type = (nodePoint->faction == TEAM_ALLIANCE ? BG_IC_NPC_GLAIVE_THROWER_1_A : BG_IC_NPC_GLAIVE_THROWER_1_H) + i;
 
                if (GetBgMap()->GetCreature(BgCreatures[type]))
                    continue;
 
                if (AddCreature(nodePoint->faction == TEAM_ALLIANCE ? NPC_GLAIVE_THROWER_A : NPC_GLAIVE_THROWER_H, type,
                                BG_IC_DocksVehiclesGlaives[i].GetPositionX(), BG_IC_DocksVehiclesGlaives[i].GetPositionY(),
                                BG_IC_DocksVehiclesGlaives[i].GetPositionZ(), BG_IC_DocksVehiclesGlaives[i].GetOrientation(),
                                RESPAWN_ONE_DAY))
                    GetBGCreature(type)->SetFaction(BG_IC_Factions[nodePoint->faction]);
            }
 
            // spawning catapults
            for (uint8 i = 0; i < MAX_CATAPULTS_SPAWNS_PER_FACTION; ++i)
            {
                uint8 type = (nodePoint->faction == TEAM_ALLIANCE ? BG_IC_NPC_CATAPULT_1_A : BG_IC_NPC_CATAPULT_1_H) + i;
 
                if (GetBgMap()->GetCreature(BgCreatures[type]))
                    continue;
 
                if (AddCreature(NPC_CATAPULT, type,
                                BG_IC_DocksVehiclesCatapults[i].GetPositionX(), BG_IC_DocksVehiclesCatapults[i].GetPositionY(),
                                BG_IC_DocksVehiclesCatapults[i].GetPositionZ(), BG_IC_DocksVehiclesCatapults[i].GetOrientation(),
                                RESPAWN_ONE_DAY))
                    GetBGCreature(type)->SetFaction(BG_IC_Factions[(nodePoint->faction == TEAM_ALLIANCE ? TEAM_ALLIANCE : TEAM_HORDE)]);
            }
            break;
        case BG_IC_GO_WORKSHOP_BANNER:
            {
                if (siegeEngineWorkshopTimer < WORKSHOP_UPDATE_TIME)
                    siegeEngineWorkshopTimer = WORKSHOP_UPDATE_TIME;
 
                for (uint8 i = 0; i < MAX_DEMOLISHERS_SPAWNS_PER_FACTION; ++i)
                {
                    uint8 type = (nodePoint->faction == TEAM_ALLIANCE ? BG_IC_NPC_DEMOLISHER_1_A : BG_IC_NPC_DEMOLISHER_1_H) + i;
 
                    if (GetBgMap()->GetCreature(BgCreatures[type]))
                        continue;
 
                    if (AddCreature(NPC_DEMOLISHER, type,
                                    BG_IC_WorkshopVehicles[i].GetPositionX(), BG_IC_WorkshopVehicles[i].GetPositionY(),
                                    BG_IC_WorkshopVehicles[i].GetPositionZ(), BG_IC_WorkshopVehicles[i].GetOrientation(),
                                    RESPAWN_ONE_DAY))
                        GetBGCreature(type)->SetFaction(BG_IC_Factions[(nodePoint->faction == TEAM_ALLIANCE ? TEAM_ALLIANCE : TEAM_HORDE)]);
                }
 
                uint8 siegeType = (nodePoint->faction == TEAM_ALLIANCE ? BG_IC_NPC_SIEGE_ENGINE_A : BG_IC_NPC_SIEGE_ENGINE_H);
                uint8 oppositeSiegeType = (nodePoint->faction == TEAM_ALLIANCE ? BG_IC_NPC_SIEGE_ENGINE_H : BG_IC_NPC_SIEGE_ENGINE_A);
 
                if (Creature* oppositeSiege = GetBgMap()->GetCreature(BgCreatures[oppositeSiegeType]))
                {
                    if (oppositeSiege->IsAlive())
                        if (Vehicle* siegeVehicle = oppositeSiege->GetVehicleKit())
                            if (!siegeVehicle->IsVehicleInUse())
                                Unit::Kill(oppositeSiege, oppositeSiege);
                }
 
                if (!GetBgMap()->GetCreature(BgCreatures[siegeType]))
                {
                    AddCreature((nodePoint->faction == TEAM_ALLIANCE ? NPC_SIEGE_ENGINE_A : NPC_SIEGE_ENGINE_H), siegeType,
                                BG_IC_WorkshopVehicles[4].GetPositionX(), BG_IC_WorkshopVehicles[4].GetPositionY(),
                                BG_IC_WorkshopVehicles[4].GetPositionZ(), BG_IC_WorkshopVehicles[4].GetOrientation(),
                                RESPAWN_ONE_DAY);
                }
 
                if (Creature* siegeEngine = GetBgMap()->GetCreature(BgCreatures[siegeType]))
                {
                    siegeEngine->SetFaction(BG_IC_Factions[(nodePoint->faction == TEAM_ALLIANCE ? TEAM_ALLIANCE : TEAM_HORDE)]);
                    siegeEngine->SetCorpseDelay(5 * MINUTE);
 
                    respawnMap[siegeEngine->GetGUID()] = GameTime::GetGameTime().count() + VEHICLE_RESPAWN_TIME;
                }
 
                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->SetUInt32Value(GAMEOBJECT_FACTION, BG_IC_Factions[(nodePoint->faction == TEAM_ALLIANCE ? 0 : 1)]);
                    }
                }
                break;
            }
        default:
            break;
    }
}

References ACTION_GUNSHIP_READY, Battleground::AddCreature(), Battleground::AddObject(), Battleground::AddSpiritGuide(), BG_IC_DocksVehiclesCatapults, BG_IC_DocksVehiclesGlaives, BG_IC_Factions, BG_IC_GO_DOCKS_BANNER, BG_IC_GO_HANGAR_BANNER, BG_IC_GO_HANGAR_TELEPORTER_1, BG_IC_GO_HANGAR_TELEPORTER_EFFECT_1, BG_IC_GO_QUARRY_BANNER, BG_IC_GO_REFINERY_BANNER, BG_IC_GO_SEAFORIUM_BOMBS_1, BG_IC_GO_WORKSHOP_BANNER, BG_IC_HangarCaptains, BG_IC_HangarTeleporterEffects, BG_IC_HangarTeleporters, BG_IC_HangarTrigger, BG_IC_NPC_CATAPULT_1_A, BG_IC_NPC_CATAPULT_1_H, BG_IC_NPC_DEMOLISHER_1_A, BG_IC_NPC_DEMOLISHER_1_H, BG_IC_NPC_GLAIVE_THROWER_1_A, BG_IC_NPC_GLAIVE_THROWER_1_H, BG_IC_NPC_GUNSHIP_CAPTAIN_1, BG_IC_NPC_GUNSHIP_CAPTAIN_2, BG_IC_NPC_SIEGE_ENGINE_A, BG_IC_NPC_SIEGE_ENGINE_H, BG_IC_NPC_SPIRIT_GUIDE_1, BG_IC_NPC_WORLD_TRIGGER_NOT_FLOATING, BG_IC_SpiritGuidePos, BG_IC_WorkshopVehicles, Battleground::BgCreatures, Battleground::CastSpellOnTeam(), UnitAI::DoAction(), DOCKS_UPDATE_TIME, docksTimer, ICNodePoint::faction, GAMEOBJECT_FACTION, ICNodePoint::gameobject_type, Unit::GetAI(), Battleground::GetBGCreature(), Battleground::GetBgMap(), Battleground::GetBGObject(), Map::GetCreature(), WorldObject::GetCreatureListWithEntryInGrid(), GameTime::GetGameTime(), Position::GetOrientation(), Battleground::GetOtherTeamId(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), GO_ALLIANCE_GUNSHIP_PORTAL, GO_ALLIANCE_GUNSHIP_PORTAL_EFFECTS, GO_HORDE_GUNSHIP_PORTAL, GO_HORDE_GUNSHIP_PORTAL_EFFECTS, GO_SEAFORIUM_BOMBS, GO_STATE_ACTIVE, gunshipAlliance, gunshipHorde, Unit::Kill(), LOG_ERROR, MAX_CAPTAIN_SPAWNS_PER_FACTION, MAX_CATAPULTS_SPAWNS_PER_FACTION, MAX_DEMOLISHERS_SPAWNS_PER_FACTION, MAX_GLAIVE_THROWERS_SPAWNS_PER_FACTION, MAX_HANGAR_TELEPORTER_EFFECTS_SPAWNS, MAX_HANGAR_TELEPORTERS_SPAWNS, MAX_TRIGGER_SPAWNS_PER_FACTION, MAX_WORKSHOP_BOMBS_SPAWNS_PER_FACTION, MINUTE, NODE_TYPE_QUARRY, NODE_TYPE_REFINERY, nodePoint, ICNodePoint::nodeType, NPC_ALLIANCE_GUNSHIP_CANNON, NPC_ALLIANCE_GUNSHIP_CAPTAIN, NPC_CATAPULT, NPC_DEMOLISHER, NPC_GLAIVE_THROWER_A, NPC_GLAIVE_THROWER_H, NPC_HORDE_GUNSHIP_CANNON, NPC_HORDE_GUNSHIP_CAPTAIN, NPC_SIEGE_ENGINE_A, NPC_SIEGE_ENGINE_H, NPC_WORLD_TRIGGER_NOT_FLOATING, Battleground::RemoveAuraOnTeam(), RESPAWN_ONE_DAY, respawnMap, Unit::SetFaction(), siegeEngineWorkshopTimer, SPELL_OIL_REFINERY, SPELL_QUARRY, TEAM_ALLIANCE, TEAM_HORDE, UNIT_FLAG_NOT_SELECTABLE, VEHICLE_RESPAWN_TIME, WORKSHOP_UPDATE_TIME, and workshopBombs.

Referenced by EventPlayerClickedOnFlag(), and PostUpdateImpl().

◆ HandleContestedNodes()

void BattlegroundIC::HandleContestedNodes ( ICNodePoint * nodePoint )

private

{
    if (nodePoint->nodeType == NODE_TYPE_HANGAR)
    {
        if (gunshipAlliance && gunshipHorde)
            (nodePoint->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 (nodePoint->faction == TEAM_HORDE)
            gunshipAlliance->GetCreatureListWithEntryInGrid(cannons, NPC_ALLIANCE_GUNSHIP_CANNON, 150.0f);
        else
            gunshipHorde->GetCreatureListWithEntryInGrid(cannons, NPC_HORDE_GUNSHIP_CANNON, 150.0f);
 
        for (std::list<Creature*>::const_iterator itr = cannons.begin(); itr != cannons.end(); ++itr)
        {
            (*itr)->GetVehicleKit()->RemoveAllPassengers();
            (*itr)->SetUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
        }
    }
    else if (nodePoint->nodeType == NODE_TYPE_DOCKS)
    {
        auto removeUnusedVehicles = [&](uint8 baseType, uint8 count)
        {
            for (uint8 i = 0; i < count; ++i)
            {
                uint8 type = baseType + i;
                if (Creature* vehicle = GetBgMap()->GetCreature(BgCreatures[type]))
                {
                    if (Vehicle* veh = vehicle->GetVehicleKit())
                        if (!veh->IsVehicleInUse())
                        {
                            respawnMap.erase(vehicle->GetGUID());
                            DelCreature(type);
                        }
                }
            }
        };
 
        uint8 glaiveBase = (nodePoint->faction == TEAM_ALLIANCE ? BG_IC_NPC_GLAIVE_THROWER_1_H : BG_IC_NPC_GLAIVE_THROWER_1_A);
        removeUnusedVehicles(glaiveBase, MAX_GLAIVE_THROWERS_SPAWNS_PER_FACTION);
 
        uint8 catapultBase = (nodePoint->faction == TEAM_ALLIANCE ? BG_IC_NPC_CATAPULT_1_H : BG_IC_NPC_CATAPULT_1_A);
        removeUnusedVehicles(catapultBase, MAX_CATAPULTS_SPAWNS_PER_FACTION);
    }
    else if (nodePoint->nodeType == NODE_TYPE_REFINERY || nodePoint->nodeType == NODE_TYPE_QUARRY)
    {
        // nodePoint->faction is the assaulting team (set before this call);
        // remove the siege damage buff from the team that previously controlled the node.
        uint32 auraSpellId = (nodePoint->nodeType == NODE_TYPE_REFINERY) ? SPELL_OIL_REFINERY : SPELL_QUARRY;
        RemoveAuraOnTeam(auraSpellId, GetOtherTeamId(nodePoint->faction));
    }
    else if (nodePoint->nodeType == NODE_TYPE_WORKSHOP)
    {
        DelObject(BG_IC_GO_SEAFORIUM_BOMBS_1);
        DelObject(BG_IC_GO_SEAFORIUM_BOMBS_2);
 
        for (uint8 i = 0; i < MAX_DEMOLISHERS_SPAWNS_PER_FACTION; ++i)
        {
            uint8 type = (nodePoint->faction == TEAM_ALLIANCE ? BG_IC_NPC_DEMOLISHER_1_H : BG_IC_NPC_DEMOLISHER_1_A) + i;
            if (BgCreatures[type] && GetBgMap()->GetCreature(BgCreatures[type]))
            {
                if (Creature* demolisher = GetBgMap()->GetCreature(BgCreatures[type]))
                {
                    if (Vehicle* veh = demolisher->GetVehicleKit())
                        if (!veh->IsVehicleInUse())
                        {
                            respawnMap.erase(demolisher->GetGUID());
                            DelCreature(type);
                        }
                }
            }
        }
 
        uint8 siegeType = (nodePoint->faction == TEAM_ALLIANCE ? BG_IC_NPC_SIEGE_ENGINE_H : BG_IC_NPC_SIEGE_ENGINE_A);
        if (BgCreatures[siegeType] && GetBgMap()->GetCreature(BgCreatures[siegeType]))
        {
            if (Creature* siege = GetBgMap()->GetCreature(BgCreatures[siegeType]))
            {
                if (Vehicle* veh = siege->GetVehicleKit())
                    if (!veh->IsVehicleInUse())
                    {
                        respawnMap.erase(siege->GetGUID());
                        DelCreature(siegeType);
                    }
            }
        }
    }
}

References BG_IC_GO_HANGAR_TELEPORTER_1, BG_IC_GO_HANGAR_TELEPORTER_3, BG_IC_GO_HANGAR_TELEPORTER_EFFECT_1, BG_IC_GO_HANGAR_TELEPORTER_EFFECT_3, BG_IC_GO_SEAFORIUM_BOMBS_1, BG_IC_GO_SEAFORIUM_BOMBS_2, BG_IC_NPC_CATAPULT_1_A, BG_IC_NPC_CATAPULT_1_H, BG_IC_NPC_DEMOLISHER_1_A, BG_IC_NPC_DEMOLISHER_1_H, BG_IC_NPC_GLAIVE_THROWER_1_A, BG_IC_NPC_GLAIVE_THROWER_1_H, BG_IC_NPC_GUNSHIP_CAPTAIN_1, BG_IC_NPC_SIEGE_ENGINE_A, BG_IC_NPC_SIEGE_ENGINE_H, BG_IC_NPC_WORLD_TRIGGER_NOT_FLOATING, Battleground::BgCreatures, Battleground::DelCreature(), Battleground::DelObject(), ICNodePoint::faction, Battleground::GetBgMap(), Map::GetCreature(), WorldObject::GetCreatureListWithEntryInGrid(), Battleground::GetOtherTeamId(), gunshipAlliance, gunshipHorde, MAX_CAPTAIN_SPAWNS_PER_FACTION, MAX_CATAPULTS_SPAWNS_PER_FACTION, MAX_DEMOLISHERS_SPAWNS_PER_FACTION, MAX_GLAIVE_THROWERS_SPAWNS_PER_FACTION, NODE_TYPE_DOCKS, NODE_TYPE_HANGAR, NODE_TYPE_QUARRY, NODE_TYPE_REFINERY, NODE_TYPE_WORKSHOP, nodePoint, ICNodePoint::nodeType, NPC_ALLIANCE_GUNSHIP_CANNON, NPC_HORDE_GUNSHIP_CANNON, Battleground::RemoveAuraOnTeam(), respawnMap, SPELL_OIL_REFINERY, SPELL_QUARRY, TEAM_ALLIANCE, TEAM_HORDE, and UNIT_FLAG_NOT_SELECTABLE.

Referenced by EventPlayerClickedOnFlag().

◆ HandleKillPlayer()

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 ? WORLD_STATE_BATTLEGROUND_IC_ALLIANCE_REINFORCEMENT : WORLD_STATE_BATTLEGROUND_IC_HORDE_REINFORCEMENT), factionReinforcements[player->GetTeamId()]);
 
    // we must end the battleground
    if (factionReinforcements[player->GetTeamId()] < 1)
        EndBattleground(killer->GetTeamId());
}

References Battleground::EndBattleground(), factionReinforcements, Battleground::GetStatus(), Player::GetTeamId(), Battleground::HandleKillPlayer(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, Battleground::UpdateWorldState(), WORLD_STATE_BATTLEGROUND_IC_ALLIANCE_REINFORCEMENT, and WORLD_STATE_BATTLEGROUND_IC_HORDE_REINFORCEMENT.

◆ HandleKillUnit()

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, TEAM_HORDE);
        EndBattleground(TEAM_HORDE);
    }
    else if (entry == NPC_OVERLORD_AGMAR)
    {
        RewardHonorToTeam(WINNER_HONOR_AMOUNT, TEAM_ALLIANCE);
        EndBattleground(TEAM_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);
 
        // Xinef: Add to respawn list
        if (entry == NPC_DEMOLISHER || entry == NPC_SIEGE_ENGINE_H || entry == NPC_SIEGE_ENGINE_A ||
                entry == NPC_GLAIVE_THROWER_A || entry == NPC_GLAIVE_THROWER_H || entry == NPC_CATAPULT)
            respawnMap[unit->GetGUID()] = GameTime::GetGameTime().count() + VEHICLE_RESPAWN_TIME;
    }
}

References Unit::CastSpell(), Battleground::EndBattleground(), Object::GetEntry(), GameTime::GetGameTime(), Object::GetGUID(), Battleground::GetStatus(), Unit::IsVehicle(), NPC_CATAPULT, NPC_DEMOLISHER, NPC_GLAIVE_THROWER_A, NPC_GLAIVE_THROWER_H, NPC_HIGH_COMMANDER_HALFORD_WYRMBANE, NPC_OVERLORD_AGMAR, NPC_SIEGE_ENGINE_A, NPC_SIEGE_ENGINE_H, respawnMap, Battleground::RewardHonorToTeam(), SPELL_DESTROYED_VEHICLE_ACHIEVEMENT, STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, VEHICLE_RESPAWN_TIME, and WINNER_HONOR_AMOUNT.

◆ HandlePlayerResurrect()

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

References Unit::CastSpell(), Player::GetTeamId(), NODE_STATE_CONTROLLED_A, NODE_STATE_CONTROLLED_H, NODE_TYPE_QUARRY, NODE_TYPE_REFINERY, nodePoint, SPELL_OIL_REFINERY, SPELL_QUARRY, and TEAM_ALLIANCE.

◆ IsResourceGlutAllowed()

bool BattlegroundIC::IsResourceGlutAllowed ( TeamId teamId ) const

{
    ICNodeState controlledState = teamId == TEAM_ALLIANCE ? NODE_STATE_CONTROLLED_A : NODE_STATE_CONTROLLED_H;
    return nodePoint[NODE_TYPE_QUARRY].nodeState == controlledState && nodePoint[NODE_TYPE_REFINERY].nodeState == controlledState;
}

References NODE_STATE_CONTROLLED_A, NODE_STATE_CONTROLLED_H, NODE_TYPE_QUARRY, NODE_TYPE_REFINERY, nodePoint, ICNodePoint::nodeState, and TEAM_ALLIANCE.

Referenced by achievement_bg_ic_resource_glut::OnCheck().

◆ PostUpdateImpl()

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 (nodePoint[i].timer <= diff)
                {
                    // we need to confirm this, i am not sure if this every 3 minutes
                    for (uint8 j = 0; j < MAX_CATAPULTS_SPAWNS_PER_FACTION; ++j)
                    {
                        uint8 type = (nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_NPC_CATAPULT_1_A : BG_IC_NPC_CATAPULT_1_H) + j;
                        if (Creature* catapult = GetBgMap()->GetCreature(BgCreatures[type]))
                            if (!catapult->IsAlive())
                            {
                                // Check if creature respawn time is properly saved
                                RespawnMap::iterator itr = respawnMap.find(catapult->GetGUID());
                                if (itr == respawnMap.end() || GameTime::GetGameTime().count() < itr->second)
                                    continue;
 
                                catapult->Relocate(BG_IC_DocksVehiclesCatapults[j].GetPositionX(), BG_IC_DocksVehiclesCatapults[j].GetPositionY(), BG_IC_DocksVehiclesCatapults[j].GetPositionZ(), BG_IC_DocksVehiclesCatapults[j].GetOrientation());
                                catapult->Respawn(true);
                                respawnMap.erase(itr);
                            }
                    }
 
                    // we need to confirm this is blizzlike, not sure if it is every 3 minutes
                    for (uint8 j = 0; j < MAX_GLAIVE_THROWERS_SPAWNS_PER_FACTION; ++j)
                    {
                        uint8 type = (nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_NPC_GLAIVE_THROWER_1_A : BG_IC_NPC_GLAIVE_THROWER_1_H) + j;
                        if (Creature* glaiveThrower = GetBgMap()->GetCreature(BgCreatures[type]))
                            if (!glaiveThrower->IsAlive())
                            {
                                // Check if creature respawn time is properly saved
                                RespawnMap::iterator itr = respawnMap.find(glaiveThrower->GetGUID());
                                if (itr == respawnMap.end() || GameTime::GetGameTime().count() < itr->second)
                                    continue;
 
                                glaiveThrower->Relocate(BG_IC_DocksVehiclesGlaives[j].GetPositionX(), BG_IC_DocksVehiclesGlaives[j].GetPositionY(), BG_IC_DocksVehiclesGlaives[j].GetPositionZ(), BG_IC_DocksVehiclesGlaives[j].GetOrientation());
                                glaiveThrower->Respawn(true);
                                respawnMap.erase(itr);
                            }
                    }
 
                    docksTimer = DOCKS_UPDATE_TIME;
                }
                else
                    nodePoint[i].timer -= 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 = GetBgMap()->GetCreature(BgCreatures[siegeType]))
                        if (!siege->IsAlive())
                        {
                            // Check if creature respawn time is properly saved
                            RespawnMap::iterator itr = respawnMap.find(siege->GetGUID());
                            if (itr == respawnMap.end() || GameTime::GetGameTime().count() < itr->second)
                                continue;
 
                            siege->Relocate(BG_IC_WorkshopVehicles[4].GetPositionX(), BG_IC_WorkshopVehicles[4].GetPositionY(), BG_IC_WorkshopVehicles[4].GetPositionZ(), BG_IC_WorkshopVehicles[4].GetOrientation());
                            siege->Respawn(true);
                            respawnMap.erase(itr);
                        }
 
                    // we need to confirm this, i am not sure if this every 3 minutes
                    for (uint8 u = 0; u < MAX_DEMOLISHERS_SPAWNS_PER_FACTION; ++u)
                    {
                        uint8 type = (nodePoint[i].faction == TEAM_ALLIANCE ? BG_IC_NPC_DEMOLISHER_1_A : BG_IC_NPC_DEMOLISHER_1_H) + u;
                        if (Creature* demolisher = GetBgMap()->GetCreature(BgCreatures[type]))
                            if (!demolisher->IsAlive())
                            {
                                // Check if creature respawn time is properly saved
                                RespawnMap::iterator itr = respawnMap.find(demolisher->GetGUID());
                                if (itr == respawnMap.end() || GameTime::GetGameTime().count() < itr->second)
                                    continue;
 
                                demolisher->Relocate(BG_IC_WorkshopVehicles[u].GetPositionX(), BG_IC_WorkshopVehicles[u].GetPositionY(), BG_IC_WorkshopVehicles[u].GetPositionZ(), BG_IC_WorkshopVehicles[u].GetOrientation());
                                demolisher->Respawn(true);
                                respawnMap.erase(itr);
                            }
                    }
 
                    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);
 
                if (nodePoint[i].faction == TEAM_ALLIANCE)
                {
                    SendBroadcastText(ICNodes[i].TextAllianceTaken, CHAT_MSG_BG_SYSTEM_ALLIANCE);
                }
                else
                {
                    SendBroadcastText(ICNodes[i].TextHordeTaken, CHAT_MSG_BG_SYSTEM_HORDE);
                }
 
                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);
                UpdateWorldState((nodePoint[i].faction == TEAM_ALLIANCE ? WORLD_STATE_BATTLEGROUND_IC_ALLIANCE_REINFORCEMENT : WORLD_STATE_BATTLEGROUND_IC_HORDE_REINFORCEMENT), factionReinforcements[nodePoint[i].faction]);
            }
        }
        resourceTimer = IC_RESOURCE_TIME;
    }
    else resourceTimer -= diff;
}

References Battleground::AddObject(), BANNER_STATE_CHANGE_TIME, BG_IC_DocksVehiclesCatapults, BG_IC_DocksVehiclesGlaives, BG_IC_Factions, BG_IC_GO_ALLIANCE_GATE_1, BG_IC_GO_ALLIANCE_GATE_2, BG_IC_GO_ALLIANCE_GATE_3, BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR01, BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR02, BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR03, BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR01, BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR02, BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR03, BG_IC_GO_HORDE_GATE_1, BG_IC_GO_HORDE_GATE_2, BG_IC_GO_HORDE_GATE_3, BG_IC_NPC_CATAPULT_1_A, BG_IC_NPC_CATAPULT_1_H, BG_IC_NPC_DEMOLISHER_1_A, BG_IC_NPC_DEMOLISHER_1_H, BG_IC_NPC_GLAIVE_THROWER_1_A, BG_IC_NPC_GLAIVE_THROWER_1_H, BG_IC_NPC_SIEGE_ENGINE_A, BG_IC_NPC_SIEGE_ENGINE_H, BG_IC_WorkshopVehicles, Battleground::BgCreatures, CHAT_MSG_BG_SYSTEM_ALLIANCE, CHAT_MSG_BG_SYSTEM_HORDE, closeFortressDoorsTimer, cords, Battleground::DelObject(), DOCKS_UPDATE_TIME, docksTimer, doorsClosed, ICNodePoint::faction, factionReinforcements, ICNodePoint::gameobject_entry, GAMEOBJECT_FACTION, Battleground::GetBgMap(), Battleground::GetBGObject(), Map::GetCreature(), GameTime::GetGameTime(), GetNextBanner(), Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Battleground::GetStatus(), GO_DESTRUCTIBLE_DAMAGED, HandleCapturedNodes(), IC_RESOURCE_TIME, ICNodes, ICNodePoint::last_entry, MAX_CATAPULTS_SPAWNS_PER_FACTION, MAX_DEMOLISHERS_SPAWNS_PER_FACTION, MAX_GLAIVE_THROWERS_SPAWNS_PER_FACTION, MAX_NODE_TYPES, ICNodePoint::needChange, NODE_STATE_CONTROLLED_A, NODE_STATE_CONTROLLED_H, NODE_TYPE_DOCKS, NODE_TYPE_REFINERY, NODE_TYPE_WORKSHOP, nodePoint, GameObject::RemoveFromWorld(), RESOURCE_HONOR_AMOUNT, resourceTimer, RESPAWN_ONE_DAY, respawnMap, Battleground::RewardHonorToTeam(), Battleground::SendBroadcastText(), GameObject::SetDestructibleState(), Object::SetUInt32Value(), siegeEngineWorkshopTimer, STATUS_IN_PROGRESS, TEAM_ALLIANCE, ICNodePoint::timer, UpdateNodeWorldState(), Battleground::UpdateWorldState(), WORKSHOP_UPDATE_TIME, WORLD_STATE_BATTLEGROUND_IC_ALLIANCE_REINFORCEMENT, and WORLD_STATE_BATTLEGROUND_IC_HORDE_REINFORCEMENT.

◆ RemovePlayer()

void BattlegroundIC::RemovePlayer ( Player * player )

overridevirtual

Reimplemented from Battleground.

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

References Unit::RemoveAura(), SPELL_OIL_REFINERY, and SPELL_QUARRY.

◆ SetupBattleground()

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))
        {
            LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning gameobject {}", BG_IC_ObjSpawnlocs[i].entry);
            return false;
        }
 
        // Horde / Alliance gates, set active
        if (i < 6)
            GetBGObject(BG_IC_ObjSpawnlocs[i].type)->setActive(true);
    }
 
    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))
        {
            LOG_ERROR("bg.battleground", "Isle of Conquest | Starting Event Open Doors: There was an error spawning gameobject {}", 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))
        {
            LOG_ERROR("bg.battleground", "Isle of Conquest | Starting Event Open Doors: There was an error spawning gameobject {}", BG_IC_Teleporters[i].entry);
            return false;
        }
    }
 
    for (uint8 i = 0; 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, RESPAWN_ONE_DAY))
        {
            LOG_ERROR("bg.battleground", "Isle of Conquest: There was an error spawning creature {}", BG_IC_NpcSpawnlocs[i].entry);
            return false;
        }
    }
 
    if (!AddSpiritGuide(BG_IC_NPC_SPIRIT_GUIDE_1 + 3, BG_IC_SpiritGuidePos[5][0], BG_IC_SpiritGuidePos[5][1], BG_IC_SpiritGuidePos[5][2], BG_IC_SpiritGuidePos[5][3], TEAM_ALLIANCE)
            || !AddSpiritGuide(BG_IC_NPC_SPIRIT_GUIDE_1 + 4, BG_IC_SpiritGuidePos[6][0], BG_IC_SpiritGuidePos[6][1], BG_IC_SpiritGuidePos[6][2], BG_IC_SpiritGuidePos[6][3], TEAM_HORDE)
            || !AddSpiritGuide(BG_IC_NPC_SPIRIT_GUIDE_1 + 5, BG_IC_SpiritGuidePos[7][0], BG_IC_SpiritGuidePos[7][1], BG_IC_SpiritGuidePos[7][2], BG_IC_SpiritGuidePos[7][3], TEAM_ALLIANCE)
            || !AddSpiritGuide(BG_IC_NPC_SPIRIT_GUIDE_1 + 6, BG_IC_SpiritGuidePos[8][0], BG_IC_SpiritGuidePos[8][1], BG_IC_SpiritGuidePos[8][2], BG_IC_SpiritGuidePos[8][3], TEAM_HORDE))
    {
        LOG_ERROR("bg.battleground", "Isle of Conquest: Failed to spawn initial spirit guide!");
        return false;
    }
 
    gunshipHorde = sTransportMgr->CreateTransport(GO_HORDE_GUNSHIP, 0, GetBgMap());
    gunshipAlliance = sTransportMgr->CreateTransport(GO_ALLIANCE_GUNSHIP, 0, GetBgMap());
 
    if (!gunshipAlliance || !gunshipHorde)
    {
        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_25; ++i)
        GetBGCreature(i)->SetFaction(BG_IC_Factions[1]);
    // Flags
    if (GameObject* go = GetBGObject(BG_IC_GO_ALLIANCE_BANNER))
    {
        go->SetUInt32Value(GAMEOBJECT_FACTION, BG_IC_Factions[1]);
        go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
    }
    if (GameObject* go = GetBGObject(BG_IC_GO_HORDE_BANNER))
    {
        go->SetUInt32Value(GAMEOBJECT_FACTION, BG_IC_Factions[0]);
        go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
    }
 
    // 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);
 
    TurnBosses(false);
    return true;
}

References Battleground::AddCreature(), Battleground::AddObject(), Battleground::AddSpiritGuide(), BG_IC_Factions, BG_IC_GO_ALLIANCE_BANNER, BG_IC_GO_HORDE_BANNER, BG_IC_GO_HUGE_SEAFORIUM_BOMBS_A_1, BG_IC_GO_HUGE_SEAFORIUM_BOMBS_H_4, BG_IC_NPC_KEEP_CANNON_1, BG_IC_NPC_KEEP_CANNON_12, BG_IC_NPC_KEEP_CANNON_13, BG_IC_NPC_KEEP_CANNON_25, BG_IC_NPC_SPIRIT_GUIDE_1, BG_IC_NpcSpawnlocs, BG_IC_ObjSpawnlocs, BG_IC_SpiritGuidePos, BG_IC_TeleporterEffects, BG_IC_Teleporters, MotionTransport::EnableMovement(), GAMEOBJECT_FACTION, GAMEOBJECT_FLAGS, Battleground::GetBGCreature(), Battleground::GetBgMap(), Battleground::GetBGObject(), GO_ALLIANCE_GUNSHIP, GO_FLAG_NOT_SELECTABLE, GO_HORDE_GUNSHIP, gunshipAlliance, gunshipHorde, LOG_ERROR, MAX_FORTRESS_TELEPORTER_EFFECTS_SPAWNS, MAX_FORTRESS_TELEPORTERS_SPAWNS, MAX_NORMAL_GAMEOBJECTS_SPAWNS, MAX_NORMAL_NPCS_SPAWNS, RESPAWN_ONE_DAY, WorldObject::setActive(), Unit::SetFaction(), GameObject::SetRespawnTime(), sTransportMgr, TEAM_ALLIANCE, TEAM_HORDE, and TurnBosses().

◆ StartingEventCloseDoors()

void BattlegroundIC::StartingEventCloseDoors ( )

inlineoverridevirtual

Reimplemented from Battleground.

897{ }

◆ StartingEventOpenDoors()

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)->RemoveGameObjectFlag(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);
}

References BG_IC_GO_DOODAD_HU_PORTCULLIS01_1, BG_IC_GO_DOODAD_HU_PORTCULLIS01_2, BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR01, BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR02, BG_IC_GO_DOODAD_ND_HUMAN_GATE_CLOSEDFX_DOOR03, BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR01, BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR02, BG_IC_GO_DOODAD_ND_WINTERORC_WALL_GATEFX_DOOR03, BG_IC_GO_DOODAD_VR_PORTCULLIS01_1, BG_IC_GO_DOODAD_VR_PORTCULLIS01_2, BG_IC_TeleporterEffects, BG_IC_Teleporters, Battleground::DoorOpen(), Battleground::GetBGObject(), GO_FLAG_NOT_SELECTABLE, GO_STATE_ACTIVE, MAX_FORTRESS_TELEPORTER_EFFECTS_SPAWNS, MAX_FORTRESS_TELEPORTERS_SPAWNS, GameObject::RemoveGameObjectFlag(), and GameObject::SetGoState().

◆ TurnBosses()

void BattlegroundIC::TurnBosses ( bool on )

private

{
    // Make Bosses invisible and passive
    // or visible and active
    if (Creature* boss = GetBGCreature(BG_IC_NPC_OVERLORD_AGMAR))
    {
        boss->SetVisible(on);
        boss->SetReactState(on ? REACT_AGGRESSIVE : REACT_PASSIVE);
    }
    if (Creature* boss = GetBGCreature(BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE))
    {
        boss->SetVisible(on);
        boss->SetReactState(on ? REACT_AGGRESSIVE : REACT_PASSIVE);
    }
}

References BG_IC_NPC_HIGH_COMMANDER_HALFORD_WYRMBANE, BG_IC_NPC_OVERLORD_AGMAR, Battleground::GetBGCreature(), REACT_AGGRESSIVE, and REACT_PASSIVE.

Referenced by DestroyGate(), and SetupBattleground().

◆ UpdateNodeWorldState()

void BattlegroundIC::UpdateNodeWorldState ( ICNodePoint * nodePoint )

private

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

References BANNER_A_CONTESTED, BANNER_A_CONTROLLED, BANNER_H_CONTESTED, BANNER_H_CONTROLLED, ICNodePoint::banners, ICNodePoint::gameobject_entry, NODE_STATE_CONFLICT_A, NODE_STATE_CONFLICT_H, NODE_STATE_CONTROLLED_A, NODE_STATE_CONTROLLED_H, nodePoint, ICNodePoint::nodeState, Battleground::UpdateWorldState(), and ICNodePoint::worldStates.

Referenced by EventPlayerClickedOnFlag(), and PostUpdateImpl().

◆ UpdatePlayerScore()

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

overridevirtual

Reimplemented from Battleground.

{
    if (!Battleground::UpdatePlayerScore(player, type, value, doAddHonor))
        return false;
 
    switch (type)
    {
        case SCORE_BASES_ASSAULTED:
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, IC_OBJECTIVE_ASSAULT_BASE);
            break;
        case SCORE_BASES_DEFENDED:
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, IC_OBJECTIVE_DEFEND_BASE);
            break;
    }
 
    return true;
}

References ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE, IC_OBJECTIVE_ASSAULT_BASE, IC_OBJECTIVE_DEFEND_BASE, SCORE_BASES_ASSAULTED, SCORE_BASES_DEFENDED, Player::UpdateAchievementCriteria(), and Battleground::UpdatePlayerScore().

Referenced by EventPlayerClickedOnFlag().

Member Data Documentation

◆ closeFortressDoorsTimer

uint32 BattlegroundIC::closeFortressDoorsTimer

private

Referenced by BattlegroundIC(), and PostUpdateImpl().

◆ docksTimer

uint32 BattlegroundIC::docksTimer

private

Referenced by BattlegroundIC(), HandleCapturedNodes(), and PostUpdateImpl().

◆ doorsClosed

bool BattlegroundIC::doorsClosed

private

Referenced by BattlegroundIC(), and PostUpdateImpl().

◆ factionReinforcements

uint16 BattlegroundIC::factionReinforcements[2]

private

Referenced by BattlegroundIC(), FillInitialWorldStates(), HandleKillPlayer(), and PostUpdateImpl().

◆ GateStatus

BG_IC_GateState BattlegroundIC::GateStatus[6]

private

Referenced by BattlegroundIC(), DestroyGate(), EventPlayerClickedOnFlag(), FillInitialWorldStates(), and HandleAreaTrigger().

◆ gunshipAlliance

MotionTransport* BattlegroundIC::gunshipAlliance

private

Referenced by BattlegroundIC(), DoAction(), HandleCapturedNodes(), HandleContestedNodes(), and SetupBattleground().

◆ gunshipHorde

MotionTransport* BattlegroundIC::gunshipHorde

private

Referenced by BattlegroundIC(), DoAction(), HandleCapturedNodes(), HandleContestedNodes(), and SetupBattleground().

◆ nodePoint

ICNodePoint BattlegroundIC::nodePoint[7]

private

Referenced by AddPlayer(), AllNodesConrolledByTeam(), BattlegroundIC(), EventPlayerClickedOnFlag(), FillInitialWorldStates(), GetClosestGraveyard(), GetNextBanner(), HandleCapturedNodes(), HandleContestedNodes(), HandlePlayerResurrect(), IsResourceGlutAllowed(), PostUpdateImpl(), and UpdateNodeWorldState().

◆ resourceTimer

uint32 BattlegroundIC::resourceTimer

private

Referenced by BattlegroundIC(), and PostUpdateImpl().

◆ respawnMap

RespawnMap BattlegroundIC::respawnMap

private

Referenced by BattlegroundIC(), HandleCapturedNodes(), HandleContestedNodes(), HandleKillUnit(), and PostUpdateImpl().

◆ siegeEngineWorkshopTimer

uint32 BattlegroundIC::siegeEngineWorkshopTimer

private

Referenced by BattlegroundIC(), HandleCapturedNodes(), and PostUpdateImpl().

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

azerothcore-wotlk/src/server/game/Battlegrounds/Zones/BattlegroundIC.h
azerothcore-wotlk/src/server/game/Battlegrounds/Zones/BattlegroundIC.cpp

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ RespawnMap

Constructor & Destructor Documentation

◆ BattlegroundIC()

Member Function Documentation

◆ AddPlayer()

◆ AllNodesConrolledByTeam()

◆ DestroyGate()

◆ DoAction()

◆ EventPlayerClickedOnFlag()

◆ EventPlayerDamagedGO()

◆ FillInitialWorldStates()

◆ GetClosestGraveyard()

◆ GetGateIDFromEntry()

◆ GetNextBanner()

◆ GetNodeState()

◆ GetWorldStateFromGateEntry()

◆ HandleAreaTrigger()

◆ HandleCapturedNodes()

◆ HandleContestedNodes()

◆ HandleKillPlayer()

◆ HandleKillUnit()

◆ HandlePlayerResurrect()

◆ IsResourceGlutAllowed()

◆ PostUpdateImpl()

◆ RemovePlayer()

◆ SetupBattleground()

◆ StartingEventCloseDoors()

◆ StartingEventOpenDoors()

◆ TurnBosses()

◆ UpdateNodeWorldState()

◆ UpdatePlayerScore()

Member Data Documentation

◆ closeFortressDoorsTimer

◆ docksTimer

◆ doorsClosed

◆ factionReinforcements

◆ GateStatus

◆ gunshipAlliance

◆ gunshipHorde

◆ nodePoint

◆ resourceTimer

◆ respawnMap

◆ siegeEngineWorkshopTimer