#include "BattlefieldWG.h"

Inheritance diagram for BattlefieldWG:

Public Member Functions
	~BattlefieldWG () override

void	OnBattleStart () override
	Called when the battle start.

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

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

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

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

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

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

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

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

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

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

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

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

void	UpdatedDestroyedTowerCount (TeamId team, GameObject *go)
	Called when tower is broken.

void	RemoveAurasFromPlayer (Player *player)

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

GameObject *	GetRelic ()
	Return pointer to relic object.

bool	CanInteractWithRelic ()
	Define relic object.

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

void	UpdateCounterVehicle (bool init)
	Vehicle world states update.

void	UpdateVehicleCountWG ()

void	CapturePointTaken (uint32 areaId)

void	SendInitWorldStatesTo (Player *player)

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

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

void	SendUpdateWorldStates (Player *player=nullptr) override

void	SendUpdateWorldStateMessage (uint32 variable, uint32 value, Player *player=nullptr)

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

void	OnUnitDeath (Unit *unit) override

void	PromotePlayer (Player *killer)

uint32	GetHonorBuff (int32 stack) const

void	UpdateTenacity ()

void	AddUpdateTenacity (Player *player)

void	RemoveUpdateTenacity (Player *player)

void	ProcessEvent (WorldObject *obj, uint32 eventId) override

bool	FindAndRemoveVehicleFromList (Unit *vehicle)

uint8	GetSpiritGraveyardId (uint32 areaId) const

uint32	GetAreaByGraveyardId (uint8 gId) const

void	RelocateDeadPlayers (uint8 graveyardId, TeamId newOwner)

uint32	GetData (uint32 data) const override

bool	IsLastBattleAttackerVictory () const

bool	IsKeepNpc (uint32 entry)

Public Member Functions inherited from Battlefield
	Battlefield ()
	Constructor.

	~Battlefield () override
	Destructor.

void	SendUpdateWorldState (uint32 field, uint32 value)
	Update data of a worldstate to all players present in zone.

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

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

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

uint32	GetTypeId () const

uint32	GetZoneId () const

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

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

void	ToggleBattlefield (bool enable)
	Enable or Disable battlefield.

bool	IsEnabled () const
	Return if battlefield is enabled.

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

void	HandlePlayerEnterZone (Player *player, uint32 zone)
	Called when player (player) enters the zone.

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

uint64	GetData64 (uint32 dataId) const override

void	SetData64 (uint32 dataId, uint64 value) override

void	SetData (uint32 dataId, uint32 value) override

virtual void	UpdateData (uint32 index, int32 pad)

TeamId	GetDefenderTeam () const

TeamId	GetAttackerTeam () const

TeamId	GetOtherTeam (TeamId team) const

void	SetDefenderTeam (TeamId team)

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

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

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

void	TryRejoinAfterLogout (Player *player)

GraveyardStruct const *	GetClosestGraveyard (Player *player)

virtual void	AddPlayerToResurrectQueue (ObjectGuid npcGuid, ObjectGuid playerGuid)

void	RemovePlayerFromResurrectQueue (ObjectGuid playerGuid)

void	SetGraveyardNumber (uint32 number)

BfGraveyard *	GetGraveyardById (uint32 id) const

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

Creature *	SpawnCreature (uint32 entry, Position pos, TeamId teamId)

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

Creature *	GetCreature (ObjectGuid const &guid)

GameObject *	GetGameObject (ObjectGuid const &guid)

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

void	PlayerAcceptInviteToQueue (Player *player)

void	PlayerAcceptInviteToWar (Player *player)

uint32	GetBattleId () const

void	AskToLeaveQueue (Player *player)

void	PlayerAskToLeave (Player *player)

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

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

void	StartBattle ()

void	EndBattle (bool endByTimer)

void	HideNpc (Creature *creature)

void	ShowNpc (Creature *creature, bool aggressive)

GraveyardVect const &	GetGraveyardVector () const

uint32	GetTimer () const

void	SetTimer (uint32 timer)

uint32	GetPlayersInWarCount (TeamId teamId) const

uint32	GetPlayersInZoneCount (TeamId teamId) const

uint32	GetMaxPlayersPerTeam () const

bool	HasWarVacancy (TeamId teamId) const
	Returns true if there is still room for another player on the given team in the active war.

GuidUnorderedSet const &	GetPlayersQueueSet (TeamId teamId) const
	Returns the set of players waiting in the pre-battle queue (per team, read-only).

PlayerTimerMap const &	GetInvitedPlayersMap (TeamId teamId) const

GuidUnorderedSet const &	GetPlayersInWarSet (TeamId teamId) const
	Returns the set of players actively fighting in the war (per team, read-only).

bool	IsPlayerInBattlefield (ObjectGuid guid) const

void	DoPlaySoundToAll (uint32 soundId)

void	InvitePlayerToQueue (Player *player)

void	InvitePlayerToWar (Player *player)

void	InitStalker (uint32 entry, float x, float y, float z, float o)

Public Member Functions inherited from ZoneScript
	ZoneScript ()

virtual	~ZoneScript ()

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

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

virtual void	OnGameObjectRemove (GameObject *)

virtual void	OnCreatureEvade (Creature *)

virtual ObjectGuid	GetGuidData (uint32) const

virtual void	SetGuidData (uint32, ObjectGuid)

Protected Attributes
bool	IsRelicInteractible

Workshop	WorkshopsList

GameObjectSet	DefenderPortalList

GameObjectSet	KeepGameObject [2]

GameObjectBuilding	BuildingsInZone

GuidUnorderedSet	Vehicles [2]

GuidUnorderedSet	CanonList

GuidUnorderedSet	KeepCreature [2]

GuidUnorderedSet	OutsideCreature [2]

GuidUnorderedSet	UpdateTenacityList

int32	TenacityStack

ObjectGuid	TitansRelic

bool	LastBattleAttackerVictory {false}

Protected Attributes inherited from Battlefield
ObjectGuid	StalkerGuid

uint32	Timer

bool	Enabled

bool	Active

TeamId	DefenderTeam

BfCapturePointVector	CapturePoints

GuidUnorderedSet	Players [PVP_TEAMS_COUNT]

GuidUnorderedSet	PlayersInQueue [PVP_TEAMS_COUNT]

GuidUnorderedSet	PlayersInWar [PVP_TEAMS_COUNT]

PlayerTimerMap	InvitedPlayers [PVP_TEAMS_COUNT]

PlayerTimerMap	PlayersWillBeKick [PVP_TEAMS_COUNT]

PlayerTimerMap	LogoutGracePlayers [PVP_TEAMS_COUNT]

uint32	TypeId

uint32	BattleId

uint32	ZoneId

uint32	MapId

Map *	BfMap

uint32	MaxPlayer

uint32	MinPlayer

uint32	MinLevel

uint32	BattleTime

uint32	NoWarBattleTime

uint32	RestartAfterCrash

uint32	TimeForAcceptInvite

WorldLocation	KickPosition

GraveyardVect	GraveyardList

uint32	StartGroupingTimer

bool	StartGrouping

TaskScheduler	_scheduler

GuidUnorderedSet	Groups [PVP_TEAMS_COUNT]

std::vector< uint64 >	Data64

std::vector< uint32 >	Data32

Additional Inherited Members
Public Types inherited from Battlefield
using	BfCapturePointVector = std::vector< BfCapturePoint * >
	Vector of capture points belonging to this battlefield.

Protected Member Functions inherited from Battlefield
void	KickAfkPlayers ()

virtual void	SendRemoveWorldStates (Player *)

void	BroadcastPacketToZone (WorldPacket const *data) const

void	BroadcastPacketToQueue (WorldPacket const *data) const

void	BroadcastPacketToWar (WorldPacket const *data) const

void	AddCapturePoint (BfCapturePoint *cp)

void	RegisterZone (uint32 zoneId)

bool	HasPlayer (Player *player) const

void	TeamCastSpell (TeamId team, int32 spellId)

bool	IsPlayerInWarOrInvited (Player *player) const
	Returns true if the player is already tracked as actively in the war or invited to join it.

void	RemovePlayerFromTracking (ObjectGuid playerGuid, bool removeFromQueue=true)

template<typename Func >
void	ForEachPlayerInZone (Func &&fn) const

template<typename Func >
void	ForEachPlayerInQueue (Func &&fn) const

template<typename Func >
void	ForEachPlayerInWar (Func &&fn) const

template<typename Func >
void	ForEachPlayerInWar (TeamId team, Func &&fn) const

Static Protected Attributes inherited from Battlefield
static constexpr uint32	LOGOUT_GRACE_SECONDS = 120

Detailed Description

Constructor & Destructor Documentation

◆ ~BattlefieldWG()

BattlefieldWG::~BattlefieldWG ( )

override

Todo:

: Implement proper support for vehicle+player teleportation

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

: Add proper implement of achievement

{
    for (WGWorkshop* workshop : WorkshopsList)
        delete workshop;
 
    for (BfWGGameObjectBuilding* building : BuildingsInZone)
        delete building;
}

References BuildingsInZone, and WorkshopsList.

Member Function Documentation

◆ AddUpdateTenacity()

void BattlefieldWG::AddUpdateTenacity ( Player * player )

{
    UpdateTenacityList.insert(player->GetGUID());
}

References Object::GetGUID(), and UpdateTenacityList.

Referenced by OnPlayerJoinWar().

◆ BrokenWallOrTower()

void BattlefieldWG::BrokenWallOrTower ( TeamId team )

Called when a wall/tower is broken.

Update quest

{
    // might be some use for this in the future. old code commented out below. KL
    /*    if (team == GetDefenderTeam())
        {
            for (ObjectGuid const& guid : PlayersInWar[GetAttackerTeam()])
            {
                if (Player* player = ObjectAccessor::FindPlayer(guid))
                    IncrementQuest(player, WGQuest[player->GetTeamId()][2], true);
            }
        }*/
}

Referenced by BfWGGameObjectBuilding::Destroyed().

◆ CanInteractWithRelic()

bool BattlefieldWG::CanInteractWithRelic ( )

inline

Define relic object.

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

371{ return IsRelicInteractible; }

BattlefieldWG::IsRelicInteractible

bool IsRelicInteractible

Definition BattlefieldWG.h:442

References IsRelicInteractible.

Referenced by ProcessEvent().

◆ CapturePointTaken()

void BattlefieldWG::CapturePointTaken ( uint32 areaId )

{
    for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
        for (ObjectGuid const& guid : Players[i])
            if (Player* player = ObjectAccessor::FindPlayer(guid))
                if (player->GetAreaId() == areaId)
                    player->UpdateAreaDependentAuras(areaId);
}

References ObjectAccessor::FindPlayer(), Battlefield::Players, and PVP_TEAMS_COUNT.

Referenced by WGWorkshop::GiveControlTo().

◆ FillInitialWorldStates()

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

overridevirtual

Implements Battlefield.

{
    uint32 timer = GetTimer() / 1000;
    bool iconActive = timer < 15 * MINUTE || IsWarTime();
 
    packet.Worldstates.reserve(4+4+WG_MAX_OBJ+WG_MAX_WORKSHOP);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_ATTACKER, GetAttackerTeam());
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_DEFENDER, GetDefenderTeam());
 
    // Note: cleanup these two, their names look awkward
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_ACTIVE, IsWarTime() ? 0 : 1);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_SHOW, IsWarTime() ? 1 : 0);
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_CONTROL, DefenderTeam == TEAM_ALLIANCE ? 2 : 1); // Alliance 2, Hord 1
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_ICON_ACTIVE, iconActive ? 1 : 0);
 
    for (uint32 i = 0; i < 2; ++i)
        packet.Worldstates.emplace_back(ClockWorldState[i], GameTime::GetGameTime().count() + timer);
 
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_VEHICLE_H, GetData(BATTLEFIELD_WG_DATA_VEHICLE_H));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_MAX_VEHICLE_H, GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_H));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_VEHICLE_A, GetData(BATTLEFIELD_WG_DATA_VEHICLE_A));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_MAX_VEHICLE_A, GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A));
 
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_DEFENDED, uint32(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_DEFENDED)));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_CAPTURED, uint32(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_CAPTURED)));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_DEFENDED, uint32(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_DEFENDED)));
    packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_CAPTURED, uint32(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_CAPTURED)));
 
    for (BfWGGameObjectBuilding* building : BuildingsInZone)
        packet.Worldstates.emplace_back(building->m_WorldState, building->m_State);
 
    for (WGWorkshop* workshop : WorkshopsList)
        if (workshop)
            packet.Worldstates.emplace_back(WorkshopsData[workshop->workshopId].worldstate, workshop->state);
}

Referenced by SendInitWorldStatesTo().

◆ FindAndRemoveVehicleFromList()

bool BattlefieldWG::FindAndRemoveVehicleFromList ( Unit * vehicle )

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

References BATTLEFIELD_WG_DATA_VEHICLE_A, BATTLEFIELD_WG_DATA_VEHICLE_H, Object::GetGUID(), TEAM_HORDE, and Vehicles.

Referenced by OnUnitDeath().

◆ GetAreaByGraveyardId()

uint32 BattlefieldWG::GetAreaByGraveyardId ( uint8 gId ) const

{
    switch (gId)
    {
        case BATTLEFIELD_WG_GY_WORKSHOP_NE:
            return AREA_THE_SUNKEN_RING;
        case BATTLEFIELD_WG_GY_WORKSHOP_NW:
            return AREA_THE_BROKEN_TEMPLE;
        case BATTLEFIELD_WG_GY_WORKSHOP_SW:
            return AREA_WESTSPARK_WORKSHOP;
        case BATTLEFIELD_WG_GY_WORKSHOP_SE:
            return AREA_EASTSPARK_WORKSHOP;
    }
 
    return 0;
}

References AREA_EASTSPARK_WORKSHOP, AREA_THE_BROKEN_TEMPLE, AREA_THE_SUNKEN_RING, AREA_WESTSPARK_WORKSHOP, BATTLEFIELD_WG_GY_WORKSHOP_NE, BATTLEFIELD_WG_GY_WORKSHOP_NW, BATTLEFIELD_WG_GY_WORKSHOP_SE, and BATTLEFIELD_WG_GY_WORKSHOP_SW.

Referenced by WGWorkshop::GiveControlTo().

◆ GetData()

uint32 BattlefieldWG::GetData ( uint32 data ) const

overridevirtual

Reimplemented from Battlefield.

{
    // xinef: little hack, same area for default horde graveyard
    // this graveyard is the one of broken temple!
    if (data == AREA_THE_CHILLED_QUAGMIRE)
        data = AREA_THE_BROKEN_TEMPLE;
 
    switch (data)
    {
        // Used to determine when the phasing spells must be casted
        // See: SpellArea::IsFitToRequirements
        case AREA_THE_SUNKEN_RING:
        case AREA_THE_BROKEN_TEMPLE:
        case AREA_WESTSPARK_WORKSHOP:
        case AREA_EASTSPARK_WORKSHOP:
            // Graveyards and Workshops are controlled by the same team.
            if (BfGraveyard const* graveyard = GetGraveyardById(GetSpiritGraveyardId(data)))
                return graveyard->GetControlTeamId();
    }
 
    return Battlefield::GetData(data);
}

References AREA_EASTSPARK_WORKSHOP, AREA_THE_BROKEN_TEMPLE, AREA_THE_CHILLED_QUAGMIRE, AREA_THE_SUNKEN_RING, AREA_WESTSPARK_WORKSHOP, Battlefield::GetData(), Battlefield::GetGraveyardById(), and GetSpiritGraveyardId().

Referenced by FillInitialWorldStates(), OnBattleEnd(), OnCreatureCreate(), OnPlayerJoinWar(), UpdatedDestroyedTowerCount(), and UpdateVehicleCountWG().

◆ GetHonorBuff()

uint32 BattlefieldWG::GetHonorBuff ( int32 stack ) const

{
    if (stack < 5)
        return 0;
    if (stack < 10)
        return SPELL_GREAT_HONOR;
    if (stack < 15)
        return SPELL_GREATER_HONOR;
    return SPELL_GREATEST_HONOR;
}

References SPELL_GREAT_HONOR, SPELL_GREATER_HONOR, and SPELL_GREATEST_HONOR.

Referenced by UpdateTenacity().

◆ GetRelic()

GameObject * BattlefieldWG::GetRelic ( )

inline

Return pointer to relic object.

365{ return GetGameObject(TitansRelic); }

BattlefieldWG::TitansRelic

ObjectGuid TitansRelic

Definition BattlefieldWG.h:458

Battlefield::GetGameObject

GameObject * GetGameObject(ObjectGuid const &guid)

Definition Battlefield.cpp:853

References Battlefield::GetGameObject(), and TitansRelic.

Referenced by BfWGGameObjectBuilding::Destroyed(), OnBattleEnd(), and ProcessEvent().

◆ GetSpiritGraveyardId()

uint8 BattlefieldWG::GetSpiritGraveyardId ( uint32 areaId ) const

{
    switch (areaId)
    {
        case AREA_WINTERGRASP_FORTRESS:
            return BATTLEFIELD_WG_GY_KEEP;
        case AREA_THE_SUNKEN_RING:
            return BATTLEFIELD_WG_GY_WORKSHOP_NE;
        case AREA_THE_BROKEN_TEMPLE:
            return BATTLEFIELD_WG_GY_WORKSHOP_NW;
        case AREA_WESTSPARK_WORKSHOP:
            return BATTLEFIELD_WG_GY_WORKSHOP_SW;
        case AREA_EASTSPARK_WORKSHOP:
            return BATTLEFIELD_WG_GY_WORKSHOP_SE;
        case AREA_WINTERGRASP:
            return BATTLEFIELD_WG_GY_ALLIANCE;
        case AREA_THE_CHILLED_QUAGMIRE:
            return BATTLEFIELD_WG_GY_HORDE;
        default:
            LOG_ERROR("bg.battlefield", "BattlefieldWG::GetSpiritGraveyardId: Unexpected Area Id {}", areaId);
            break;
    }
 
    return 0;
}

References AREA_EASTSPARK_WORKSHOP, AREA_THE_BROKEN_TEMPLE, AREA_THE_CHILLED_QUAGMIRE, AREA_THE_SUNKEN_RING, AREA_WESTSPARK_WORKSHOP, AREA_WINTERGRASP, AREA_WINTERGRASP_FORTRESS, BATTLEFIELD_WG_GY_ALLIANCE, BATTLEFIELD_WG_GY_HORDE, BATTLEFIELD_WG_GY_KEEP, BATTLEFIELD_WG_GY_WORKSHOP_NE, BATTLEFIELD_WG_GY_WORKSHOP_NW, BATTLEFIELD_WG_GY_WORKSHOP_SE, BATTLEFIELD_WG_GY_WORKSHOP_SW, and LOG_ERROR.

Referenced by GetData(), and OnCreatureCreate().

◆ HandleKill()

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

overridevirtual

Called when a Unit is killed in battlefield zone.

Reimplemented from Battlefield.

{
    if (killer == victim)
    {
        return;
    }
 
    TeamId killerTeam = killer->GetTeamId();
 
    // xinef: tower cannons also grant rank
    if (victim->IsPlayer() || IsKeepNpc(victim->GetEntry()) || victim->GetEntry() == NPC_WINTERGRASP_TOWER_CANNON)
    {
        if (Player* victimPlayer = victim->ToPlayer())
        {
            sScriptMgr->OnBattlefieldPlayerKill(this, killer, victimPlayer);
 
            if (victimPlayer->HasAura(SPELL_LIEUTENANT))
            {
                // Quest - Wintergrasp - PvP Kill - Horde/Alliance
                for (ObjectGuid const& playerGuid : PlayersInWar[killerTeam])
                {
                    if (Player* player = ObjectAccessor::FindPlayer(playerGuid))
                    {
                        if (player->GetDistance2d(killer) < 40)
                            player->KilledMonsterCredit(killerTeam == TEAM_HORDE ? NPC_QUEST_PVP_KILL_ALLIANCE : NPC_QUEST_PVP_KILL_HORDE);
                    }
                }
            }
        }
 
        for (ObjectGuid const& playerGuid : PlayersInWar[killerTeam])
        {
            if (Player* player = ObjectAccessor::FindPlayer(playerGuid))
            {
                if (player->GetDistance2d(killer) < 40)
                {
                    PromotePlayer(player);
                }
            }
        }
 
        // Xinef: Allow to Skin non-released corpse
        if (victim->IsPlayer())
        {
            victim->SetUnitFlag(UNIT_FLAG_SKINNABLE);
        }
    }
    else if (victim->IsVehicle() && !killer->IsFriendlyTo(victim))
    {
        // Quest - Wintergrasp - PvP Kill - Vehicle
        for (ObjectGuid const& playerGuid : PlayersInWar[killerTeam])
        {
            if (Player* player = ObjectAccessor::FindPlayer(playerGuid))
            {
                if (player->GetDistance2d(killer) < 40)
                {
                    player->KilledMonsterCredit(NPC_QUEST_PVP_KILL_VEHICLE);
                }
            }
        }
    }
}

References ObjectAccessor::FindPlayer(), Object::GetEntry(), Player::GetTeamId(), Unit::IsFriendlyTo(), IsKeepNpc(), Object::IsPlayer(), Unit::IsVehicle(), NPC_QUEST_PVP_KILL_ALLIANCE, NPC_QUEST_PVP_KILL_HORDE, NPC_QUEST_PVP_KILL_VEHICLE, NPC_WINTERGRASP_TOWER_CANNON, Battlefield::PlayersInWar, PromotePlayer(), Unit::SetUnitFlag(), SPELL_LIEUTENANT, sScriptMgr, TEAM_HORDE, Object::ToPlayer(), and UNIT_FLAG_SKINNABLE.

◆ IsKeepNpc()

bool BattlefieldWG::IsKeepNpc ( uint32 entry )

inline

    {
        switch (entry)
        {
            case BATTLEFIELD_WG_NPC_GUARD_H:
            case BATTLEFIELD_WG_NPC_GUARD_A:
            case BATTLEFIELD_WG_NPC_VIERON_BLAZEFEATHER:
            case BATTLEFIELD_WG_NPC_BOWYER_RANDOLPH:
            case BATTLEFIELD_WG_NPC_STONE_GUARD_MUKAR:
            case BATTLEFIELD_WG_NPC_KNIGHT_DAMERON:
            case BATTLEFIELD_WG_NPC_HOODOO_MASTER_FU_JIN:
            case BATTLEFIELD_WG_NPC_SORCERESS_KAYLANA:
            case BATTLEFIELD_WG_NPC_CHAMPION_ROS_SLAI:
            case BATTLEFIELD_WG_NPC_MARSHAL_MAGRUDER:
            case BATTLEFIELD_WG_NPC_COMMANDER_DARDOSH:
            case BATTLEFIELD_WG_NPC_COMMANDER_ZANNETH:
            case BATTLEFIELD_WG_NPC_TACTICAL_OFFICER_KILRATH:
            case BATTLEFIELD_WG_NPC_TACTICAL_OFFICER_AHBRAMIS:
            case BATTLEFIELD_WG_NPC_HORDE_WARBRINGER:
            case BATTLEFIELD_WG_NPC_BRIGADIER_GENERAL:
            case BATTLEFIELD_WG_NPC_SIEGESMITH_STRONGHOOF:
            case BATTLEFIELD_WG_NPC_SIEGE_MASTER_STOUTHANDLE:
            case BATTLEFIELD_WG_NPC_PRIMALIST_MULFORT:
            case BATTLEFIELD_WG_NPC_ANCHORITE_TESSA:
            case BATTLEFIELD_WG_NPC_LIEUTENANT_MURP:
            case BATTLEFIELD_WG_NPC_SENIOR_DEMOLITIONIST_LEGOSO:
                return true;
        }
        return false;
    }

Referenced by HandleKill().

◆ IsLastBattleAttackerVictory()

bool BattlefieldWG::IsLastBattleAttackerVictory ( ) const

inline

409{ return LastBattleAttackerVictory; }

BattlefieldWG::LastBattleAttackerVictory

bool LastBattleAttackerVictory

Definition BattlefieldWG.h:460

References LastBattleAttackerVictory.

◆ OnBattleEnd()

void BattlefieldWG::OnBattleEnd ( bool endByTimer )

overridevirtual

Called when battle end.

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

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

Reimplemented from Battlefield.

{
    // Must be set before SPELL_VICTORY_REWARD so the 1755 criterion can gate on it.
    LastBattleAttackerVictory = !endByTimer;
 
    // Remove relic
    if (GameObject* go = GetRelic())
        go->RemoveFromWorld();
 
    TitansRelic.Clear();
 
    // Remove turret
    for (ObjectGuid const& guid : CanonList)
    {
        if (Creature* creature = GetCreature(guid))
        {
            if (!endByTimer)
                creature->SetFaction(WintergraspFaction[GetDefenderTeam()]);
            HideNpc(creature);
        }
    }
 
    // Change all npc in keep
    for (ObjectGuid const& guid : KeepCreature[GetAttackerTeam()])
        if (Creature* creature = GetCreature(guid))
            HideNpc(creature);
 
    for (ObjectGuid const& guid : KeepCreature[GetDefenderTeam()])
        if (Creature* creature = GetCreature(guid))
            ShowNpc(creature, true);
 
    // Change all npc out of keep
    for (ObjectGuid const& guid : OutsideCreature[GetDefenderTeam()])
        if (Creature* creature = GetCreature(guid))
            HideNpc(creature);
 
    for (ObjectGuid const& guid : OutsideCreature[GetAttackerTeam()])
        if (Creature* creature = GetCreature(guid))
            ShowNpc(creature, true);
 
    // Update all graveyard, control is to defender when no wartime
    for (uint8 i = 0; i < BATTLEFIELD_WG_GY_HORDE; i++)
        if (BfGraveyard* graveyard = GetGraveyardById(i))
            graveyard->GiveControlTo(i == BATTLEFIELD_WG_GY_WORKSHOP_SE || i == BATTLEFIELD_WG_GY_WORKSHOP_SW ? GetAttackerTeam() : GetDefenderTeam());
 
    for (GameObject* go : KeepGameObject[GetDefenderTeam()])
        go->SetRespawnTime(RESPAWN_IMMEDIATELY);
 
    for (GameObject* go : KeepGameObject[GetAttackerTeam()])
        go->SetRespawnTime(RESPAWN_ONE_DAY);
 
    // Update portal defender faction
    for (GameObject* go : DefenderPortalList)
        go->SetUInt32Value(GAMEOBJECT_FACTION, WintergraspFaction[GetDefenderTeam()]);
 
    // Saving data
    for (BfWGGameObjectBuilding* building : BuildingsInZone)
    {
        building->Rebuild();
        building->Save();
        building->UpdateTurretAttack(true);
    }
 
    for (WGWorkshop* workshop : WorkshopsList)
    {
        workshop->GiveControlTo(workshop->workshopId == BATTLEFIELD_WG_WORKSHOP_SE || workshop->workshopId == BATTLEFIELD_WG_WORKSHOP_SW ? GetAttackerTeam() : GetDefenderTeam(), true);
        workshop->Save();
    }
 
    for (uint8 team = 0; team < 2; ++team)
    {
        for (ObjectGuid const& guid : Vehicles[team])
            if (Creature* creature = GetCreature(guid))
                creature->DespawnOrUnsummon(1ms);
 
        Vehicles[team].clear();
    }
 
    uint8 damagedTowersDef = GetData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT);
    uint8 brokenTowersDef = GetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT);
    uint8 damagedTowersAtt = GetData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT);
    uint8 brokenTowersAtt = GetData(BATTLEFIELD_WG_DATA_INTACT_TOWER_ATT);
    uint32 spellDamagedDef = SPELL_DAMAGED_TOWER;
    uint32 spellFullDef = SPELL_DESTROYED_TOWER;
    uint32 spellDamagedAtt = SPELL_DAMAGED_BUILDING;
    uint32 spellFullAtt = SPELL_INTACT_BUILDING;
 
    if (!endByTimer)
    {
        brokenTowersDef = GetData(BATTLEFIELD_WG_DATA_INTACT_TOWER_ATT);
        brokenTowersAtt = GetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT);
        spellDamagedDef = SPELL_DAMAGED_BUILDING;
        spellFullDef = SPELL_INTACT_BUILDING;
        spellDamagedAtt = SPELL_DAMAGED_TOWER;
        spellFullAtt = SPELL_DESTROYED_TOWER;
    }
 
    for (ObjectGuid const& guid : PlayersInWar[GetDefenderTeam()])
    {
        if (Player* player = ObjectAccessor::FindPlayer(guid))
        {
            // Victory in Wintergrasp
            player->AreaExploredOrEventHappens(GetDefenderTeam() ? 13183 : 13181); // HORDE / ALLY win wg quest id
 
            player->CastSpell(player, SPELL_ESSENCE_OF_WINTERGRASP, true);
            player->CastSpell(player, SPELL_VICTORY_REWARD, true);
            RemoveAurasFromPlayer(player);
 
            for (uint8 i = 0; i < damagedTowersDef; ++i)
                player->CastSpell(player, spellDamagedDef, true);
            for (uint8 i = 0; i < brokenTowersDef; ++i)
                player->CastSpell(player, spellFullDef, true);
        }
    }
 
    bool const grantEssenceToAttackers = sWorld->getBoolConfig(CONFIG_WINTERGRASP_ESSENCE_BOTH_FACTIONS);
 
    for (ObjectGuid const& guid : PlayersInWar[GetAttackerTeam()])
        if (Player* player = ObjectAccessor::FindPlayer(guid))
        {
            player->CastSpell(player, SPELL_DEFEAT_REWARD, true);
            RemoveAurasFromPlayer(player);
 
            if (grantEssenceToAttackers)
                player->CastSpell(player, SPELL_ESSENCE_OF_WINTERGRASP, true);
 
            for (uint8 i = 0; i < damagedTowersAtt; ++i)
                player->CastSpell(player, spellDamagedAtt, true);
            for (uint8 i = 0; i < brokenTowersAtt; ++i)
                player->CastSpell(player, spellFullAtt, true);
        }
 
    if (!endByTimer)
    {
        for (uint8 team = 0; team < 2; ++team)
        {
            for (ObjectGuid const& guid : Players[team])
            {
                if (Player* player = ObjectAccessor::FindPlayer(guid))
                {
                    player->RemoveAurasDueToSpell(DefenderTeam == TEAM_ALLIANCE ? SPELL_HORDE_CONTROL_PHASE_SHIFT : SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, player->GetGUID());
                    player->AddAura(DefenderTeam == TEAM_HORDE ? SPELL_HORDE_CONTROL_PHASE_SHIFT : SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, player);
                }
            }
        }
    }
 
    // Clear players in war list at the end.
    PlayersInWar[TEAM_ALLIANCE].clear();
    PlayersInWar[TEAM_HORDE].clear();
 
    if (!endByTimer) // win alli/horde
    {
        uint32 const worldStateId = GetDefenderTeam() == TEAM_ALLIANCE ? WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_CAPTURED : WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_CAPTURED;
        sWorldState->setWorldState(worldStateId, sWorldState->getWorldState(worldStateId) + 1);
 
        SendWarning((GetDefenderTeam() == TEAM_ALLIANCE) ? BATTLEFIELD_WG_TEXT_WIN_KEEP : (BATTLEFIELD_WG_TEXT_WIN_KEEP + 2));
    }
    else // defend alli/horde
    {
        uint32 const worldStateId = GetDefenderTeam() == TEAM_ALLIANCE ? WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_DEFENDED : WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_DEFENDED;
        sWorldState->setWorldState(worldStateId, sWorldState->getWorldState(worldStateId) + 1);
 
        SendWarning((GetDefenderTeam() == TEAM_ALLIANCE) ? BATTLEFIELD_WG_TEXT_DEFEND_KEEP : (BATTLEFIELD_WG_TEXT_DEFEND_KEEP + 2));
    }
}

References BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT, BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT, BATTLEFIELD_WG_DATA_INTACT_TOWER_ATT, BATTLEFIELD_WG_GY_HORDE, BATTLEFIELD_WG_GY_WORKSHOP_SE, BATTLEFIELD_WG_GY_WORKSHOP_SW, BATTLEFIELD_WG_TEXT_DEFEND_KEEP, BATTLEFIELD_WG_TEXT_WIN_KEEP, BATTLEFIELD_WG_WORKSHOP_SE, BATTLEFIELD_WG_WORKSHOP_SW, BuildingsInZone, CanonList, ObjectGuid::Clear(), CONFIG_WINTERGRASP_ESSENCE_BOTH_FACTIONS, DefenderPortalList, Battlefield::DefenderTeam, ObjectAccessor::FindPlayer(), GAMEOBJECT_FACTION, Battlefield::GetAttackerTeam(), Battlefield::GetCreature(), GetData(), Battlefield::GetDefenderTeam(), Battlefield::GetGraveyardById(), GetRelic(), Battlefield::HideNpc(), KeepCreature, KeepGameObject, LastBattleAttackerVictory, OutsideCreature, Battlefield::Players, Battlefield::PlayersInWar, RemoveAurasFromPlayer(), RESPAWN_IMMEDIATELY, RESPAWN_ONE_DAY, Battlefield::SendWarning(), Battlefield::ShowNpc(), SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, SPELL_DAMAGED_BUILDING, SPELL_DAMAGED_TOWER, SPELL_DEFEAT_REWARD, SPELL_DESTROYED_TOWER, SPELL_ESSENCE_OF_WINTERGRASP, SPELL_HORDE_CONTROL_PHASE_SHIFT, SPELL_INTACT_BUILDING, SPELL_VICTORY_REWARD, sWorld, sWorldState, TEAM_ALLIANCE, TEAM_HORDE, TitansRelic, Vehicles, WintergraspFaction, WorkshopsList, WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_CAPTURED, WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_DEFENDED, WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_CAPTURED, and WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_DEFENDED.

◆ OnBattleStart()

void BattlefieldWG::OnBattleStart ( )

overridevirtual

Called when the battle start.

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

Reimplemented from Battlefield.

{
    // Spawn titan relic
    GameObject* go = SpawnGameObject(GO_WINTERGRASP_TITAN_S_RELIC, 5440.37890625f, 2840.493408203125f, 430.2816162109375, 4.45059061050415039f); // VerifiedBuild 51943
    if (go)
    {
        // Update faction of relic, only attacker can click on
        go->SetUInt32Value(GAMEOBJECT_FACTION, WintergraspFaction[GetAttackerTeam()]);
        // Set in use (not allow to click on before last door is broken)
        go->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
 
        // save guid
        TitansRelic = go->GetGUID();
    }
    else
        LOG_ERROR("bg.battlefield", "WG: Failed to spawn titan relic.");
 
    // Update tower visibility and update faction
    for (ObjectGuid const& guid : CanonList)
    {
        if (Creature* creature = GetCreature(guid))
        {
            ShowNpc(creature, true);
            creature->SetFaction(WintergraspFaction[GetDefenderTeam()]);
        }
    }
 
    // Rebuild all wall
    for (BfWGGameObjectBuilding* building : BuildingsInZone)
    {
        if (building)
        {
            building->Rebuild();
            building->UpdateTurretAttack(false);
        }
    }
 
    SetData(BATTLEFIELD_WG_DATA_INTACT_TOWER_ATT, WG_MAX_ATTACKTOWERS);
    SetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT, 0);
    SetData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT, 0);
 
    // Update graveyard (in no war time all graveyard is to deffender, in war time, depend of base)
    for (WGWorkshop* workshop : WorkshopsList)
        if (workshop)
            workshop->UpdateGraveyardAndWorkshop();
 
    // Set Sliders capture points data to his owners when battle start
    for (BfCapturePoint* capturePoint : CapturePoints)
        capturePoint->SetCapturePointData(capturePoint->GetCapturePointGo(),
            capturePoint->GetCapturePointGo()->GetEntry() == GO_WINTERGRASP_FACTORY_BANNER_SE || capturePoint->GetCapturePointGo()->GetEntry() == GO_WINTERGRASP_FACTORY_BANNER_SW ? GetAttackerTeam() : GetDefenderTeam());
 
    SendInitWorldStatesToAll();
    // Initialize vehicle counter
    UpdateCounterVehicle(true);
    // Send start warning to all players
    SendWarning(BATTLEFIELD_WG_TEXT_START);
 
    // Xinef: reset tenacity counter
    TenacityStack = 0;
 
    _scheduler.Schedule(20s, BATTLEFIELD_TIMER_GROUP_WAR, [this](TaskContext context)
    {
        if (!UpdateTenacityList.empty())
            UpdateTenacity();
        UpdateTenacityList.clear();
        context.Repeat(10s);
    });
 
    if (sWorld->getBoolConfig(CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE))
        ChatHandler(nullptr).SendWorldText(BATTLEFIELD_WG_WORLD_START_MESSAGE);
}

References Battlefield::_scheduler, BATTLEFIELD_TIMER_GROUP_WAR, BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT, BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT, BATTLEFIELD_WG_DATA_INTACT_TOWER_ATT, BATTLEFIELD_WG_TEXT_START, BATTLEFIELD_WG_WORLD_START_MESSAGE, BuildingsInZone, CanonList, Battlefield::CapturePoints, CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE, GAMEOBJECT_FACTION, Battlefield::GetAttackerTeam(), Battlefield::GetCreature(), Battlefield::GetDefenderTeam(), Object::GetGUID(), GO_FLAG_NOT_SELECTABLE, GO_WINTERGRASP_FACTORY_BANNER_SE, GO_WINTERGRASP_FACTORY_BANNER_SW, GO_WINTERGRASP_TITAN_S_RELIC, LOG_ERROR, TaskContext::Repeat(), TaskScheduler::Schedule(), SendInitWorldStatesToAll(), Battlefield::SendWarning(), ChatHandler::SendWorldText(), Battlefield::SetData(), GameObject::SetGameObjectFlag(), Object::SetUInt32Value(), Battlefield::ShowNpc(), Battlefield::SpawnGameObject(), sWorld, TenacityStack, TitansRelic, UpdateCounterVehicle(), UpdateTenacity(), UpdateTenacityList, WG_MAX_ATTACKTOWERS, WintergraspFaction, and WorkshopsList.

◆ OnCreatureCreate()

void BattlefieldWG::OnCreatureCreate ( Creature * creature )

overridevirtual

Called when a creature is created.

Update vehicle count

Reimplemented from ZoneScript.

{
    // Accessing to db spawned creatures
    switch (creature->GetEntry())
    {
        case NPC_DWARVEN_SPIRIT_GUIDE:
        case NPC_TAUNKA_SPIRIT_GUIDE:
            {
                TeamId teamId = (creature->GetEntry() == NPC_DWARVEN_SPIRIT_GUIDE ? TEAM_ALLIANCE : TEAM_HORDE);
                uint8 graveyardId = GetSpiritGraveyardId(creature->GetAreaId());
                // xinef: little workaround, there are 2 spirit guides in same area
                if (creature->IsWithinDist2d(5103.0f, 3461.5f, 5.0f))
                    graveyardId = BATTLEFIELD_WG_GY_WORKSHOP_NW;
 
                if (GraveyardList[graveyardId])
                    GraveyardList[graveyardId]->SetSpirit(creature, teamId);
                break;
            }
    }
 
    // untested code - not sure if it is valid.
    if (IsWarTime())
    {
        switch (creature->GetEntry())
        {
            case NPC_WINTERGRASP_SIEGE_ENGINE_ALLIANCE:
            case NPC_WINTERGRASP_SIEGE_ENGINE_HORDE:
            case NPC_WINTERGRASP_CATAPULT:
            case NPC_WINTERGRASP_DEMOLISHER:
                {
                    if (!creature->IsSummon() || !creature->ToTempSummon()->GetSummonerGUID())
                        return;
 
                    Player* creator = ObjectAccessor::FindPlayer(creature->ToTempSummon()->GetSummonerGUID());
                    if (!creator)
                        return;
                    TeamId team = creator->GetTeamId();
 
                    if (team == TEAM_HORDE)
                    {
                        if (GetData(BATTLEFIELD_WG_DATA_VEHICLE_H) < GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_H))
                        {
                            UpdateData(BATTLEFIELD_WG_DATA_VEHICLE_H, 1);
                            creature->CastSpell(creature, SPELL_HORDE_FLAG, true);
                            Vehicles[team].insert(creature->GetGUID());
                            UpdateVehicleCountWG();
                        }
                        else
                        {
                            creature->DespawnOrUnsummon();
                            return;
                        }
                    }
                    else
                    {
                        if (GetData(BATTLEFIELD_WG_DATA_VEHICLE_A) < GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A))
                        {
                            UpdateData(BATTLEFIELD_WG_DATA_VEHICLE_A, 1);
                            creature->CastSpell(creature, SPELL_ALLIANCE_FLAG, true);
                            Vehicles[team].insert(creature->GetGUID());
                            UpdateVehicleCountWG();
                        }
                        else
                        {
                            creature->DespawnOrUnsummon();
                            return;
                        }
                    }
                    break;
                }
            case NPC_WINTERGRASP_SIEGE_ENGINE_TURRET_HORDE:
            case NPC_WINTERGRASP_SIEGE_ENGINE_TURRET_ALLIANCE:
                {
                    if (!creature->IsSummon() || !creature->ToTempSummon()->GetSummonerGUID())
                        return;
 
                    if (Unit* owner = creature->ToTempSummon()->GetSummonerUnit())
                        creature->SetFaction(owner->GetFaction());
                    break;
                }
        }
    }
}

References BATTLEFIELD_WG_DATA_MAX_VEHICLE_A, BATTLEFIELD_WG_DATA_MAX_VEHICLE_H, BATTLEFIELD_WG_DATA_VEHICLE_A, BATTLEFIELD_WG_DATA_VEHICLE_H, BATTLEFIELD_WG_GY_WORKSHOP_NW, Unit::CastSpell(), Creature::DespawnOrUnsummon(), ObjectAccessor::FindPlayer(), WorldObject::GetAreaId(), GetData(), Object::GetEntry(), Object::GetGUID(), GetSpiritGraveyardId(), TempSummon::GetSummonerGUID(), TempSummon::GetSummonerUnit(), Player::GetTeamId(), Battlefield::GraveyardList, Unit::IsSummon(), Battlefield::IsWarTime(), WorldObject::IsWithinDist2d(), NPC_DWARVEN_SPIRIT_GUIDE, NPC_TAUNKA_SPIRIT_GUIDE, NPC_WINTERGRASP_CATAPULT, NPC_WINTERGRASP_DEMOLISHER, NPC_WINTERGRASP_SIEGE_ENGINE_ALLIANCE, NPC_WINTERGRASP_SIEGE_ENGINE_HORDE, NPC_WINTERGRASP_SIEGE_ENGINE_TURRET_ALLIANCE, NPC_WINTERGRASP_SIEGE_ENGINE_TURRET_HORDE, Unit::SetFaction(), SPELL_ALLIANCE_FLAG, SPELL_HORDE_FLAG, TEAM_ALLIANCE, TEAM_HORDE, Unit::ToTempSummon(), UpdateVehicleCountWG(), and Vehicles.

◆ OnCreatureRemove()

void BattlefieldWG::OnCreatureRemove ( Creature * creature )

overridevirtual

Called when a creature is removed.

Update vehicle count

Reimplemented from ZoneScript.

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

◆ OnGameObjectCreate()

void BattlefieldWG::OnGameObjectCreate ( GameObject * go )

overridevirtual

Called when a gameobject is created.

Reimplemented from ZoneScript.

{
    uint8 workshopId = 0;
 
    switch (go->GetEntry())
    {
        case GO_WINTERGRASP_FACTORY_BANNER_NE:
            workshopId = BATTLEFIELD_WG_WORKSHOP_NE;
            break;
        case GO_WINTERGRASP_FACTORY_BANNER_NW:
            workshopId = BATTLEFIELD_WG_WORKSHOP_NW;
            break;
        case GO_WINTERGRASP_FACTORY_BANNER_SE:
            workshopId = BATTLEFIELD_WG_WORKSHOP_SE;
            break;
        case GO_WINTERGRASP_FACTORY_BANNER_SW:
            workshopId = BATTLEFIELD_WG_WORKSHOP_SW;
            break;
        default:
            return;
    }
 
    for (WGWorkshop* workshop : WorkshopsList)
    {
        if (workshop)
        {
            if (workshop->workshopId == workshopId)
            {
                WintergraspCapturePoint* capturePoint = new WintergraspCapturePoint(this, workshop->teamControl);
                //Sending neutral team at start to set normal capture points by workshop->teamControl, TEAM_NEUTRAL is ignored at first call
                capturePoint->SetCapturePointData(go, TEAM_NEUTRAL);
                capturePoint->LinkToWorkshop(workshop);
                AddCapturePoint(capturePoint);
                break;
            }
        }
    }
}

References Battlefield::AddCapturePoint(), BATTLEFIELD_WG_WORKSHOP_NE, BATTLEFIELD_WG_WORKSHOP_NW, BATTLEFIELD_WG_WORKSHOP_SE, BATTLEFIELD_WG_WORKSHOP_SW, Object::GetEntry(), GO_WINTERGRASP_FACTORY_BANNER_NE, GO_WINTERGRASP_FACTORY_BANNER_NW, GO_WINTERGRASP_FACTORY_BANNER_SE, GO_WINTERGRASP_FACTORY_BANNER_SW, WintergraspCapturePoint::LinkToWorkshop(), BfCapturePoint::SetCapturePointData(), TEAM_NEUTRAL, and WorkshopsList.

◆ OnPlayerEnterZone()

void BattlefieldWG::OnPlayerEnterZone ( Player * player )

overridevirtual

Called when player enters in WG zone.

Update aura
Update worldstate
Parameters

player : Player who enters the zone

Reimplemented from Battlefield.

{
    if (!Active)
        RemoveAurasFromPlayer(player);
 
    player->AddAura(DefenderTeam == TEAM_HORDE ? SPELL_HORDE_CONTROL_PHASE_SHIFT : SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, player);
    // Send worldstate to player
    SendInitWorldStatesTo(player);
 
    // xinef: Attacker, if hidden in relic room kick him out (only during wartime)
    if (IsWarTime() && player->GetTeamId() == GetAttackerTeam())
        if (player->GetPositionX() > 5400.0f && player->GetPositionX() < 5490.0f && player->GetPositionY() > 2803.0f && player->GetPositionY() < 2878.0f)
            KickPlayerFromBattlefield(player->GetGUID());
}

References Battlefield::Active, Unit::AddAura(), Battlefield::DefenderTeam, Battlefield::GetAttackerTeam(), Object::GetGUID(), Position::GetPositionX(), Position::GetPositionY(), Player::GetTeamId(), Battlefield::IsWarTime(), Battlefield::KickPlayerFromBattlefield(), RemoveAurasFromPlayer(), SendInitWorldStatesTo(), SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, SPELL_HORDE_CONTROL_PHASE_SHIFT, and TEAM_HORDE.

◆ OnPlayerJoinWar()

void BattlefieldWG::OnPlayerJoinWar ( Player * player )

overridevirtual

Called when player accept invite to join battle.

Update aura
Teleport if it needed
Update worldstate
Update tenacity
Parameters

player Player who accepted invite

Reimplemented from Battlefield.

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

References AddUpdateTenacity(), BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT, Unit::CastSpell(), Battlefield::GetAttackerTeam(), GetData(), Battlefield::GetDefenderTeam(), Player::GetTeamId(), MAP_NORTHREND, RemoveAurasFromPlayer(), SendInitWorldStatesTo(), Unit::SetAuraStack(), SPELL_RECRUIT, SPELL_TOWER_CONTROL, TEAM_HORDE, and Player::TeleportTo().

◆ OnPlayerLeaveWar()

void BattlefieldWG::OnPlayerLeaveWar ( Player * player )

overridevirtual

Called when player left the battle.

Update player aura
Parameters

player : Player who left the battle

Reimplemented from Battlefield.

{
    // Remove all aura from WG /// @todo: false we can go out of this zone on retail and keep Rank buff, remove on end of WG
    if (!player->GetSession()->PlayerLogout())
    {
        if (player->GetVehicle())                              // Remove vehicle of player if he go out.
            player->GetVehicle()->Dismiss();
        RemoveAurasFromPlayer(player);
    }
 
    RemoveUpdateTenacity(player);
}

References Vehicle::Dismiss(), Player::GetSession(), Unit::GetVehicle(), WorldSession::PlayerLogout(), RemoveAurasFromPlayer(), and RemoveUpdateTenacity().

◆ OnPlayerLeaveZone()

void BattlefieldWG::OnPlayerLeaveZone ( Player * player )

overridevirtual

Called when player left the WG zone.

Parameters

player : Player who left the zone

Reimplemented from Battlefield.

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

References Battlefield::Active, Unit::RemoveAurasDueToSpell(), RemoveAurasFromPlayer(), SPELL_ALLIANCE_CONTROL_PHASE_SHIFT, SPELL_ALLIANCE_CONTROLS_FACTORY_PHASE_SHIFT, SPELL_HORDE_CONTROL_PHASE_SHIFT, and SPELL_HORDE_CONTROLS_FACTORY_PHASE_SHIFT.

◆ OnStartGrouping()

void BattlefieldWG::OnStartGrouping ( )

overridevirtual

Called when grouping starts (15 minutes before battlestart)

Invite all player in zone to join queue

Reimplemented from Battlefield.

{
    if (!IsWarTime())
        SendWarning(BATTLEFIELD_WG_TEXT_WILL_START);
}

References BATTLEFIELD_WG_TEXT_WILL_START, Battlefield::IsWarTime(), and Battlefield::SendWarning().

◆ OnUnitDeath()

void BattlefieldWG::OnUnitDeath ( Unit * unit )

overridevirtual

Reimplemented from ZoneScript.

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

References FindAndRemoveVehicleFromList(), Unit::IsVehicle(), Battlefield::IsWarTime(), and UpdateVehicleCountWG().

◆ ProcessEvent()

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

overridevirtual

Reimplemented from ZoneScript.

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

References BuildingsInZone, CanInteractWithRelic(), Battlefield::EndBattle(), Object::GetEntry(), ObjectAccessor::GetGameObject(), GetRelic(), GO_WINTERGRASP_TITAN_S_RELIC, Battlefield::IsWarTime(), RESPAWN_IMMEDIATELY, and Object::ToGameObject().

◆ PromotePlayer()

void BattlefieldWG::PromotePlayer ( Player * killer )

{
    if (!Active)
        return;
    // Updating rank of player
    if (Aura* recruitAura = killer->GetAura(SPELL_RECRUIT))
    {
        if (recruitAura->GetStackAmount() >= 5)
        {
            killer->RemoveAura(SPELL_RECRUIT);
            killer->CastSpell(killer, SPELL_CORPORAL, true);
            SendWarning(BATTLEFIELD_WG_TEXT_FIRSTRANK, killer);
        }
        else
        {
            killer->CastSpell(killer, SPELL_RECRUIT, true);
        }
    }
    else if (Aura* corporalAura = killer->GetAura(SPELL_CORPORAL))
    {
        if (corporalAura->GetStackAmount() >= 5)
        {
            killer->RemoveAura(SPELL_CORPORAL);
            killer->CastSpell(killer, SPELL_LIEUTENANT, true);
            SendWarning(BATTLEFIELD_WG_TEXT_SECONDRANK, killer);
        }
        else
        {
            killer->CastSpell(killer, SPELL_CORPORAL, true);
        }
    }
}

References Battlefield::Active, BATTLEFIELD_WG_TEXT_FIRSTRANK, BATTLEFIELD_WG_TEXT_SECONDRANK, Unit::CastSpell(), Unit::GetAura(), Unit::RemoveAura(), Battlefield::SendWarning(), SPELL_CORPORAL, SPELL_LIEUTENANT, and SPELL_RECRUIT.

Referenced by HandleKill().

◆ RelocateDeadPlayers()

void BattlefieldWG::RelocateDeadPlayers	(	uint8	graveyardId,
		TeamId	newOwner
	)

{
    BfGraveyard const* graveyard = GetGraveyardById(graveyardId);
    if (!graveyard)
        return;
 
    GraveyardStruct const* capturedLoc = sGraveyard->GetGraveyard(graveyard->GetGraveyardId());
    if (!capturedLoc)
        return;
 
    ForEachPlayerInZone([this, capturedLoc, newOwner](Player* player)
    {
        // Only players of the losing team waiting to resurrect; they would otherwise be
        // revived in place on the now-inaccessible captured platform.
        if (player->GetTeamId() == newOwner || !player->HasAura(SPELL_WAITING_FOR_RESURRECT))
            return;
 
        // Restrict to ghosts actually waiting at the captured graveyard, not elsewhere in the zone.
        if (player->GetDistance2d(capturedLoc->x, capturedLoc->y) > 50.0f)
            return;
 
        if (GraveyardStruct const* safeLoc = GetClosestGraveyard(player))
            player->TeleportTo(safeLoc->Map, safeLoc->x, safeLoc->y, safeLoc->z, player->GetOrientation());
    });
}

References Battlefield::ForEachPlayerInZone(), Battlefield::GetClosestGraveyard(), WorldObject::GetDistance2d(), Battlefield::GetGraveyardById(), BfGraveyard::GetGraveyardId(), Position::GetOrientation(), Player::GetTeamId(), Unit::HasAura(), sGraveyard, SPELL_WAITING_FOR_RESURRECT, Player::TeleportTo(), GraveyardStruct::x, and GraveyardStruct::y.

Referenced by WGWorkshop::GiveControlTo().

◆ RemoveAurasFromPlayer()

void BattlefieldWG::RemoveAurasFromPlayer ( Player * player )

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

References Unit::RemoveAurasDueToSpell(), SPELL_CORPORAL, SPELL_ESSENCE_OF_WINTERGRASP, SPELL_LIEUTENANT, SPELL_RECRUIT, SPELL_SPIRITUAL_IMMUNITY, SPELL_TENACITY, SPELL_TOWER_CONTROL, and SPELL_WINTERGRASP_RESTRICTED_FLIGHT_AREA.

Referenced by OnBattleEnd(), OnPlayerEnterZone(), OnPlayerJoinWar(), OnPlayerLeaveWar(), and OnPlayerLeaveZone().

◆ RemoveUpdateTenacity()

void BattlefieldWG::RemoveUpdateTenacity ( Player * player )

{
    UpdateTenacityList.erase(player->GetGUID());
    UpdateTenacityList.insert(ObjectGuid::Empty);
}

References ObjectGuid::Empty, Object::GetGUID(), and UpdateTenacityList.

Referenced by OnPlayerLeaveWar().

◆ SendInitWorldStatesTo()

void BattlefieldWG::SendInitWorldStatesTo ( Player * player )

{
    WorldPackets::WorldState::InitWorldStates packet;
    packet.MapID = MapId;
    packet.ZoneID = ZoneId;
    packet.AreaID = player->GetAreaId();
    FillInitialWorldStates(packet);
 
    player->SendDirectMessage(packet.Write());
}

References WorldPackets::WorldState::InitWorldStates::AreaID, FillInitialWorldStates(), WorldObject::GetAreaId(), Battlefield::MapId, WorldPackets::WorldState::InitWorldStates::MapID, Player::SendDirectMessage(), WorldPackets::WorldState::InitWorldStates::Write(), Battlefield::ZoneId, and WorldPackets::WorldState::InitWorldStates::ZoneID.

Referenced by OnPlayerEnterZone(), OnPlayerJoinWar(), and SendInitWorldStatesToAll().

◆ SendInitWorldStatesToAll()

void BattlefieldWG::SendInitWorldStatesToAll ( )

overridevirtual

Send all worldstate data to all players in zone.

Implements Battlefield.

{
    for (uint8 team = 0; team < 2; team++)
        for (ObjectGuid const& guid : Players[team])
            if (Player* player = ObjectAccessor::FindPlayer(guid))
                SendInitWorldStatesTo(player);
}

References ObjectAccessor::FindPlayer(), Battlefield::Players, and SendInitWorldStatesTo().

Referenced by OnBattleStart(), and UpdatedDestroyedTowerCount().

◆ SendUpdateWorldStateMessage()

void BattlefieldWG::SendUpdateWorldStateMessage	(	uint32	variable,
		uint32	value,
		Player *	player = `nullptr`
	)

{
    WorldPackets::WorldState::UpdateWorldState worldState;
    worldState.VariableID = variable;
    worldState.Value = value;
 
    if (player)
        player->SendDirectMessage(worldState.Write());
    else
        sWorldSessionMgr->SendGlobalMessage(worldState.Write());
}

References Player::SendDirectMessage(), sWorldSessionMgr, WorldPackets::WorldState::UpdateWorldState::Value, WorldPackets::WorldState::UpdateWorldState::VariableID, and WorldPackets::WorldState::UpdateWorldState::Write().

Referenced by SendUpdateWorldStates().

◆ SendUpdateWorldStates()

void BattlefieldWG::SendUpdateWorldStates ( Player * player = nullptr )

overridevirtual

Implements Battlefield.

{
    uint32 timer = GetTimer() / 1000;
    bool iconActive = timer < 15 * MINUTE || IsWarTime();
 
    SendUpdateWorldStateMessage(WORLD_STATE_BATTLEFIELD_WG_ATTACKER, GetAttackerTeam(), player);
    SendUpdateWorldStateMessage(WORLD_STATE_BATTLEFIELD_WG_DEFENDER, GetDefenderTeam(), player);
    SendUpdateWorldStateMessage(WORLD_STATE_BATTLEFIELD_WG_ACTIVE, IsWarTime() ? 0 : 1, player);
    SendUpdateWorldStateMessage(WORLD_STATE_BATTLEFIELD_WG_SHOW, IsWarTime() ? 1 : 0, player);
    SendUpdateWorldStateMessage(WORLD_STATE_BATTLEFIELD_WG_CONTROL, GetDefenderTeam() == TEAM_ALLIANCE ? 2 : 1, player);
    SendUpdateWorldStateMessage(WORLD_STATE_BATTLEFIELD_WG_ICON_ACTIVE, iconActive ? 1 : 0, player);
 
    for (uint32 i = 0; i < 2; ++i)
        SendUpdateWorldStateMessage(ClockWorldState[i], uint32(GameTime::GetGameTime().count() + timer), player);
}

References ClockWorldState, Battlefield::GetAttackerTeam(), Battlefield::GetDefenderTeam(), GameTime::GetGameTime(), Battlefield::GetTimer(), Battlefield::IsWarTime(), MINUTE, SendUpdateWorldStateMessage(), TEAM_ALLIANCE, WORLD_STATE_BATTLEFIELD_WG_ACTIVE, WORLD_STATE_BATTLEFIELD_WG_ATTACKER, WORLD_STATE_BATTLEFIELD_WG_CONTROL, WORLD_STATE_BATTLEFIELD_WG_DEFENDER, WORLD_STATE_BATTLEFIELD_WG_ICON_ACTIVE, and WORLD_STATE_BATTLEFIELD_WG_SHOW.

◆ SetRelicInteractible()

void BattlefieldWG::SetRelicInteractible ( bool allow )

inline

Define if player can interact with the relic.

374{ IsRelicInteractible = allow; }

References IsRelicInteractible.

Referenced by BfWGGameObjectBuilding::Destroyed().

◆ SetupBattlefield()

bool BattlefieldWG::SetupBattlefield ( )

overridevirtual

Called when battlefield is setup, at server start.

Reimplemented from Battlefield.

{
    TypeId = BATTLEFIELD_WG;                              // See enum BattlefieldTypes
    BattleId = BATTLEFIELD_BATTLEID_WG;
    ZoneId = AREA_WINTERGRASP;
    MapId = MAP_NORTHREND;
    BfMap = sMapMgr->FindMap(MapId, 0);
 
    // init stalker AFTER setting map id... we spawn it at map=random memory value?...
    InitStalker(BATTLEFIELD_WG_NPC_STALKER, WintergraspStalkerPos[0], WintergraspStalkerPos[1], WintergraspStalkerPos[2], WintergraspStalkerPos[3]);
 
    MaxPlayer = sWorld->getIntConfig(CONFIG_WINTERGRASP_PLR_MAX);
    Enabled = sWorld->getIntConfig(CONFIG_WINTERGRASP_ENABLE) == 1;
    MinPlayer = sWorld->getIntConfig(CONFIG_WINTERGRASP_PLR_MIN);
    MinLevel = sWorld->getIntConfig(CONFIG_WINTERGRASP_PLR_MIN_LVL);
    BattleTime = sWorld->getIntConfig(CONFIG_WINTERGRASP_BATTLETIME) * MINUTE * IN_MILLISECONDS;
    NoWarBattleTime = sWorld->getIntConfig(CONFIG_WINTERGRASP_NOBATTLETIME) * MINUTE * IN_MILLISECONDS;
    RestartAfterCrash = sWorld->getIntConfig(CONFIG_WINTERGRASP_RESTART_AFTER_CRASH) * MINUTE * IN_MILLISECONDS;
 
    TimeForAcceptInvite = 20;
    StartGroupingTimer = 15 * MINUTE * IN_MILLISECONDS;
    StartGrouping = false;
 
    TenacityStack = 0;
    TitansRelic.Clear();
    IsRelicInteractible = false;
 
    KickPosition.Relocate(5728.117f, 2714.346f, 697.733f, 0);
    KickPosition.m_mapId = MapId;
 
    RegisterZone(ZoneId);
 
    Data32.resize(BATTLEFIELD_WG_DATA_MAX);
 
    // Init Graveyards
    SetGraveyardNumber(BATTLEFIELD_WG_GRAVEYARD_MAX);
 
    // Load from db
    if (!sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE) &&
        !sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER) &&
        !sWorldState->getWorldState(ClockWorldState[0]))
    {
        sWorldState->setWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE, uint64(false));
        sWorldState->setWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER, uint64(urand(0, 1)));
        sWorldState->setWorldState(ClockWorldState[0], uint64(NoWarBattleTime));
    }
 
    Active = bool(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE));
    DefenderTeam = TeamId(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER));
 
    Timer = sWorldState->getWorldState(ClockWorldState[0]);
    if (Active)
    {
        Active = false;
        Timer = RestartAfterCrash;
    }
 
    for (uint8 i = 0; i < BATTLEFIELD_WG_GRAVEYARD_MAX; i++)
    {
        BfGraveyardWG* graveyard = new BfGraveyardWG(this);
 
        // When between games, the graveyard is controlled by the defending team
        if (WGGraveyard[i].startcontrol == TEAM_NEUTRAL)
            graveyard->Initialize(WGGraveyard[i].gyid == BATTLEFIELD_WG_GY_WORKSHOP_SE || WGGraveyard[i].gyid == BATTLEFIELD_WG_GY_WORKSHOP_SW ? GetAttackerTeam() : DefenderTeam, WGGraveyard[i].gyid);
        else
            graveyard->Initialize(WGGraveyard[i].startcontrol, WGGraveyard[i].gyid);
 
        graveyard->SetTextId(WGGraveyard[i].textid);
        GraveyardList[i] = graveyard;
    }
 
    // Spawn workshop creatures and gameobjects
    for (uint8 i = 0; i < WG_MAX_WORKSHOP; i++)
    {
        WGWorkshop* workshop = new WGWorkshop(this, i);
        if (i == BATTLEFIELD_WG_WORKSHOP_SE || i == BATTLEFIELD_WG_WORKSHOP_SW)
            workshop->GiveControlTo(GetAttackerTeam(), true);
        else
            workshop->GiveControlTo(GetDefenderTeam(), true);
 
        // Note: Capture point is added once the gameobject is created.
        WorkshopsList.insert(workshop);
    }
 
    // Spawn NPCs in the defender's keep, both Horde and Alliance
    for (uint8 i = 0; i < WG_MAX_KEEP_NPC; i++)
    {
        // Horde npc
        if (Creature* creature = SpawnCreature(WGKeepNPC[i].entryHorde, WGKeepNPC[i].x, WGKeepNPC[i].y, WGKeepNPC[i].z, WGKeepNPC[i].o, TEAM_HORDE))
            KeepCreature[TEAM_HORDE].insert(creature->GetGUID());
        // Alliance npc
        if (Creature* creature = SpawnCreature(WGKeepNPC[i].entryAlliance, WGKeepNPC[i].x, WGKeepNPC[i].y, WGKeepNPC[i].z, WGKeepNPC[i].o, TEAM_ALLIANCE))
            KeepCreature[TEAM_ALLIANCE].insert(creature->GetGUID());
    }
 
    // Hide NPCs from the Attacker's team in the keep
    for (ObjectGuid const& guid : KeepCreature[GetAttackerTeam()])
        if (Creature* creature = GetCreature(guid))
            HideNpc(creature);
 
    // Spawn Horde NPCs outside the keep
    for (uint8 i = 0; i < WG_OUTSIDE_ALLIANCE_NPC; i++)
        if (Creature* creature = SpawnCreature(WGOutsideNPC[i].entryHorde, WGOutsideNPC[i].x, WGOutsideNPC[i].y, WGOutsideNPC[i].z, WGOutsideNPC[i].o, TEAM_HORDE))
            OutsideCreature[TEAM_HORDE].insert(creature->GetGUID());
 
    // Spawn Alliance NPCs outside the keep
    for (uint8 i = WG_OUTSIDE_ALLIANCE_NPC; i < WG_MAX_OUTSIDE_NPC; i++)
        if (Creature* creature = SpawnCreature(WGOutsideNPC[i].entryAlliance, WGOutsideNPC[i].x, WGOutsideNPC[i].y, WGOutsideNPC[i].z, WGOutsideNPC[i].o, TEAM_ALLIANCE))
            OutsideCreature[TEAM_ALLIANCE].insert(creature->GetGUID());
 
    // Hide units outside the keep that are defenders
    for (ObjectGuid const& guid : OutsideCreature[GetDefenderTeam()])
        if (Creature* creature = GetCreature(guid))
            HideNpc(creature);
 
    // Spawn turrets and hide them per default
    for (uint8 i = 0; i < WG_MAX_TURRET; i++)
    {
        Position towerCannonPos = WGTurret[i].GetPosition();
        if (Creature* creature = SpawnCreature(NPC_WINTERGRASP_TOWER_CANNON, towerCannonPos, TEAM_ALLIANCE))
        {
            CanonList.insert(creature->GetGUID());
            HideNpc(creature);
        }
    }
 
    // Spawn all gameobjects
    for (uint8 i = 0; i < WG_MAX_OBJ; i++)
    {
        GameObject* go = SpawnGameObject(WGGameObjectBuilding[i].entry, WGGameObjectBuilding[i].x, WGGameObjectBuilding[i].y, WGGameObjectBuilding[i].z, WGGameObjectBuilding[i].o);
        BfWGGameObjectBuilding* b = new BfWGGameObjectBuilding(this);
        b->Init(go, WGGameObjectBuilding[i].type, WGGameObjectBuilding[i].WorldState, WGGameObjectBuilding[i].damageText, WGGameObjectBuilding[i].destroyText);
        BuildingsInZone.insert(b);
    }
 
    // Spawning portal defender
    for (uint8 i = 0; i < WG_MAX_TELEPORTER; i++)
    {
        GameObject* go = SpawnGameObject(WGPortalDefenderData[i].entry, WGPortalDefenderData[i].x, WGPortalDefenderData[i].y, WGPortalDefenderData[i].z, WGPortalDefenderData[i].o);
        DefenderPortalList.insert(go);
        go->SetUInt32Value(GAMEOBJECT_FACTION, WintergraspFaction[GetDefenderTeam()]);
    }
 
    UpdateCounterVehicle(true);
 
    // Schedule always-running periodic timers
    _scheduler.Schedule(Milliseconds(RESURRECTION_INTERVAL),
        BATTLEFIELD_TIMER_GROUP_RESURRECT, [this](TaskContext context)
    {
        ForEachPlayerInZone([this](Player* player)
        {
            if (!player->HasAura(SPELL_WAITING_FOR_RESURRECT))
                return;
 
            TeamId team = player->GetTeamId();
            Unit* closestSpirit = nullptr;
            float closestDist = -1.0f;
            for (BfGraveyard* gy : GraveyardList)
            {
                if (!gy)
                    continue;
                Unit* spirit = ObjectAccessor::GetCreature(*player, gy->GetSpiritGuide(team));
                if (!spirit)
                    continue;
                float dist = player->GetDistance(spirit);
                if (closestDist < 0.0f || dist < closestDist)
                {
                    closestDist = dist;
                    closestSpirit = spirit;
                }
            }
 
            if (closestSpirit)
                closestSpirit->CastSpell(closestSpirit, SPELL_SPIRIT_HEAL, true);
 
            player->CastSpell(player, SPELL_RESURRECTION_VISUAL, true);
            player->ResurrectPlayer(1.0f);
            player->CastSpell(player, 6962, true);
            player->CastSpell(player, SPELL_SPIRIT_HEAL_MANA, true);
            player->SpawnCorpseBones(false);
            player->RemoveAurasDueToSpell(SPELL_WAITING_FOR_RESURRECT);
        });
        context.Repeat();
    });
 
    _scheduler.Schedule(60s, BATTLEFIELD_TIMER_GROUP_SAVE, [this](TaskContext context)
    {
        sWorldState->setWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE, Active);
        sWorldState->setWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER, DefenderTeam);
        sWorldState->setWorldState(ClockWorldState[0], Timer);
        context.Repeat();
    });
 
    return true;
}

References Battlefield::_scheduler, Battlefield::Active, AREA_WINTERGRASP, BATTLEFIELD_BATTLEID_WG, BATTLEFIELD_TIMER_GROUP_RESURRECT, BATTLEFIELD_TIMER_GROUP_SAVE, BATTLEFIELD_WG, BATTLEFIELD_WG_DATA_MAX, BATTLEFIELD_WG_GRAVEYARD_MAX, BATTLEFIELD_WG_GY_WORKSHOP_SE, BATTLEFIELD_WG_GY_WORKSHOP_SW, BATTLEFIELD_WG_NPC_STALKER, BATTLEFIELD_WG_WORKSHOP_SE, BATTLEFIELD_WG_WORKSHOP_SW, Battlefield::BattleId, Battlefield::BattleTime, Battlefield::BfMap, BuildingsInZone, CanonList, Unit::CastSpell(), ObjectGuid::Clear(), ClockWorldState, CONFIG_WINTERGRASP_BATTLETIME, CONFIG_WINTERGRASP_ENABLE, CONFIG_WINTERGRASP_NOBATTLETIME, CONFIG_WINTERGRASP_PLR_MAX, CONFIG_WINTERGRASP_PLR_MIN, CONFIG_WINTERGRASP_PLR_MIN_LVL, CONFIG_WINTERGRASP_RESTART_AFTER_CRASH, Battlefield::Data32, DefenderPortalList, Battlefield::DefenderTeam, Battlefield::Enabled, Battlefield::ForEachPlayerInZone(), GAMEOBJECT_FACTION, Battlefield::GetAttackerTeam(), Battlefield::GetCreature(), ObjectAccessor::GetCreature(), Battlefield::GetDefenderTeam(), WorldObject::GetDistance(), Position::GetPosition(), Player::GetTeamId(), WGWorkshop::GiveControlTo(), Battlefield::GraveyardList, BfWGCoordGY::gyid, Unit::HasAura(), Battlefield::HideNpc(), IN_MILLISECONDS, BfWGGameObjectBuilding::Init(), BfGraveyard::Initialize(), Battlefield::InitStalker(), IsRelicInteractible, KeepCreature, Battlefield::KickPosition, WorldLocation::m_mapId, MAP_NORTHREND, Battlefield::MapId, Battlefield::MaxPlayer, Battlefield::MinLevel, Battlefield::MinPlayer, MINUTE, Battlefield::NoWarBattleTime, NPC_WINTERGRASP_TOWER_CANNON, OutsideCreature, Battlefield::RegisterZone(), Position::Relocate(), Unit::RemoveAurasDueToSpell(), TaskContext::Repeat(), Battlefield::RestartAfterCrash, RESURRECTION_INTERVAL, Player::ResurrectPlayer(), TaskScheduler::Schedule(), Battlefield::SetGraveyardNumber(), BfGraveyardWG::SetTextId(), Object::SetUInt32Value(), sMapMgr, Player::SpawnCorpseBones(), Battlefield::SpawnCreature(), Battlefield::SpawnGameObject(), SPELL_RESURRECTION_VISUAL, SPELL_SPIRIT_HEAL, SPELL_SPIRIT_HEAL_MANA, SPELL_WAITING_FOR_RESURRECT, Battlefield::StartGrouping, Battlefield::StartGroupingTimer, sWorld, sWorldState, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, TenacityStack, Battlefield::TimeForAcceptInvite, TitansRelic, Battlefield::TypeId, UpdateCounterVehicle(), urand(), WG_MAX_KEEP_NPC, WG_MAX_OBJ, WG_MAX_OUTSIDE_NPC, WG_MAX_TELEPORTER, WG_MAX_TURRET, WG_MAX_WORKSHOP, WG_OUTSIDE_ALLIANCE_NPC, WGGameObjectBuilding, WGGraveyard, WGKeepNPC, WGOutsideNPC, WGPortalDefenderData, WGTurret, WintergraspFaction, WintergraspStalkerPos, WorkshopsList, WORLD_STATE_BATTLEFIELD_WG_ACTIVE, WORLD_STATE_BATTLEFIELD_WG_DEFENDER, and Battlefield::ZoneId.

◆ Update()

bool BattlefieldWG::Update ( uint32 diff )

overridevirtual

Called for update battlefield data.

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

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

Reimplemented from Battlefield.

{
    return Battlefield::Update(diff);
}

References Battlefield::Update().

Referenced by BattlefieldMgr::Update().

◆ UpdateCounterVehicle()

void BattlefieldWG::UpdateCounterVehicle ( bool init )

Vehicle world states update.

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

References BATTLEFIELD_WG_DATA_MAX_VEHICLE_A, BATTLEFIELD_WG_DATA_MAX_VEHICLE_H, BATTLEFIELD_WG_DATA_VEHICLE_A, BATTLEFIELD_WG_DATA_VEHICLE_H, Battlefield::SetData(), TEAM_ALLIANCE, TEAM_HORDE, UpdateVehicleCountWG(), and WorkshopsList.

Referenced by WGWorkshop::GiveControlTo(), OnBattleStart(), and SetupBattlefield().

◆ UpdateDamagedTowerCount()

void BattlefieldWG::UpdateDamagedTowerCount ( TeamId team )

Called when a tower is damaged.

Update tower count (for reward calcul)

{
    if (team == GetAttackerTeam())
    {
        UpdateData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT, 1);
        UpdateData(BATTLEFIELD_WG_DATA_INTACT_TOWER_ATT, -1);
    }
}

References BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT, BATTLEFIELD_WG_DATA_INTACT_TOWER_ATT, and Battlefield::GetAttackerTeam().

Referenced by BfWGGameObjectBuilding::Damaged().

◆ UpdatedDestroyedTowerCount()

void BattlefieldWG::UpdatedDestroyedTowerCount	(	TeamId	team,
		GameObject *	go
	)

Called when tower is broken.

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

{
    // Destroy an attack tower
    if (team == GetAttackerTeam())
    {
        // Update counter
        UpdateData(BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT, -1);
        UpdateData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT, 1);
 
        // Remove buff stack on attackers
        for (ObjectGuid const& guid : PlayersInWar[GetAttackerTeam()])
            if (Player* player = ObjectAccessor::FindPlayer(guid))
                player->RemoveAuraFromStack(SPELL_TOWER_CONTROL);
 
        // Add buff stack to defenders
        for (ObjectGuid const& guid : PlayersInWar[GetDefenderTeam()])
            if (Player* player = ObjectAccessor::FindPlayer(guid))
            {
                // Quest - Wintergrasp - Southern Tower Kill
                if (go && player->GetDistance2d(go) < 200.0f)
                    player->KilledMonsterCredit(NPC_QUEST_SOUTHERN_TOWER_KILL);
 
                player->CastSpell(player, SPELL_TOWER_CONTROL, true);
                player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, SPELL_LEANING_TOWER_ACHIEVEMENT, 0, 0);
            }
 
        // If all three south towers are destroyed (ie. all attack towers), remove ten minutes from battle time
        if (GetData(BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT) == 3)
        {
            if (int32(Timer - 600000) < 0)
                Timer = 0;
            else
                Timer -= 600000;
            SendInitWorldStatesToAll();
        }
    }
    else
    {
        // Xinef: rest of structures, quest credit
        for (ObjectGuid const& guid : PlayersInWar[GetAttackerTeam()])
            if (Player* player = ObjectAccessor::FindPlayer(guid))
            {
                // Quest - Wintergrasp - Vehicle Protected
                if (go && player->GetDistance2d(go) < 100.0f)
                    player->KilledMonsterCredit(NPC_QUEST_VEHICLE_PROTECTED);
            }
    }
}

References ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, BATTLEFIELD_WG_DATA_BROKEN_TOWER_ATT, BATTLEFIELD_WG_DATA_DAMAGED_TOWER_ATT, ObjectAccessor::FindPlayer(), Battlefield::GetAttackerTeam(), GetData(), Battlefield::GetDefenderTeam(), WorldObject::GetDistance2d(), NPC_QUEST_SOUTHERN_TOWER_KILL, NPC_QUEST_VEHICLE_PROTECTED, Battlefield::PlayersInWar, SendInitWorldStatesToAll(), SPELL_LEANING_TOWER_ACHIEVEMENT, and SPELL_TOWER_CONTROL.

Referenced by BfWGGameObjectBuilding::Destroyed().

◆ UpdateTenacity()

void BattlefieldWG::UpdateTenacity ( )

{
    TeamId team = TEAM_NEUTRAL;
    uint32 alliancePlayers = PlayersInWar[TEAM_ALLIANCE].size();
    uint32 hordePlayers = PlayersInWar[TEAM_HORDE].size();
    int32 newStack = 0;
 
    if (alliancePlayers && hordePlayers)
    {
        if (alliancePlayers < hordePlayers)
            newStack = int32((((float)hordePlayers / alliancePlayers) - 1.0f) * 4.0f);  // positive, should cast on alliance
        else if (alliancePlayers > hordePlayers)
            newStack = int32((1.0f - ((float)alliancePlayers / hordePlayers)) * 4.0f);  // negative, should cast on horde
    }
 
    // Return if no change in stack and apply tenacity to new player
    if (newStack == TenacityStack)
    {
        for (ObjectGuid const& guid : UpdateTenacityList)
            if (Player* newPlayer = ObjectAccessor::FindPlayer(guid))
                if ((newPlayer->GetTeamId() == TEAM_ALLIANCE && TenacityStack > 0) || (newPlayer->GetTeamId() == TEAM_HORDE && TenacityStack < 0))
                {
                    newStack = std::min(std::abs(newStack), 20);
                    uint32 buff_honor = GetHonorBuff(newStack);
                    newPlayer->SetAuraStack(SPELL_TENACITY, newPlayer, newStack);
                    if (buff_honor)
                        newPlayer->CastSpell(newPlayer, buff_honor, true);
                }
        return;
    }
 
    if (TenacityStack != 0)
    {
        if (TenacityStack > 0 && newStack <= 0)               // old buff was on alliance
            team = TEAM_ALLIANCE;
        else if (TenacityStack < 0 && newStack >= 0)          // old buff was on horde
            team = TEAM_HORDE;
    }
 
    TenacityStack = newStack;
    // Remove old buff
    if (team != TEAM_NEUTRAL)
    {
        for (ObjectGuid const& guid : PlayersInWar[team])
            if (Player* player = ObjectAccessor::FindPlayer(guid))
                player->RemoveAurasDueToSpell(SPELL_TENACITY);
 
        for (ObjectGuid const& guid : Vehicles[team])
            if (Creature* creature = GetCreature(guid))
                creature->RemoveAurasDueToSpell(SPELL_TENACITY_VEHICLE);
    }
 
    // Apply new buff
    if (newStack)
    {
        team = newStack > 0 ? TEAM_ALLIANCE : TEAM_HORDE;
        newStack = std::min(std::abs(newStack), 20);
        uint32 buff_honor = GetHonorBuff(newStack);
 
        for (ObjectGuid const& guid : PlayersInWar[team])
            if (Player* player = ObjectAccessor::FindPlayer(guid))
            {
                player->SetAuraStack(SPELL_TENACITY, player, newStack);
                if (buff_honor)
                    player->CastSpell(player, buff_honor, true);
            }
 
        for (ObjectGuid const& guid : Vehicles[team])
            if (Creature* creature = GetCreature(guid))
            {
                creature->SetAuraStack(SPELL_TENACITY_VEHICLE, creature, newStack);
                if (buff_honor)
                    creature->CastSpell(creature, buff_honor, true);
            }
    }
}

References ObjectAccessor::FindPlayer(), Battlefield::GetCreature(), GetHonorBuff(), Battlefield::PlayersInWar, SPELL_TENACITY, SPELL_TENACITY_VEHICLE, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, TenacityStack, UpdateTenacityList, and Vehicles.

Referenced by OnBattleStart().

◆ UpdateVehicleCountWG()

void BattlefieldWG::UpdateVehicleCountWG ( )

{
    for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
        for (ObjectGuid const& guid : Players[i])
            if (Player* player = ObjectAccessor::FindPlayer(guid))
            {
                player->SendUpdateWorldState(WORLD_STATE_BATTLEFIELD_WG_VEHICLE_H,     GetData(BATTLEFIELD_WG_DATA_VEHICLE_H));
                player->SendUpdateWorldState(WORLD_STATE_BATTLEFIELD_WG_MAX_VEHICLE_H, GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_H));
                player->SendUpdateWorldState(WORLD_STATE_BATTLEFIELD_WG_VEHICLE_A,     GetData(BATTLEFIELD_WG_DATA_VEHICLE_A));
                player->SendUpdateWorldState(WORLD_STATE_BATTLEFIELD_WG_MAX_VEHICLE_A, GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A));
            }
}

References BATTLEFIELD_WG_DATA_MAX_VEHICLE_A, BATTLEFIELD_WG_DATA_MAX_VEHICLE_H, BATTLEFIELD_WG_DATA_VEHICLE_A, BATTLEFIELD_WG_DATA_VEHICLE_H, ObjectAccessor::FindPlayer(), GetData(), Battlefield::Players, PVP_TEAMS_COUNT, WORLD_STATE_BATTLEFIELD_WG_MAX_VEHICLE_A, WORLD_STATE_BATTLEFIELD_WG_MAX_VEHICLE_H, WORLD_STATE_BATTLEFIELD_WG_VEHICLE_A, and WORLD_STATE_BATTLEFIELD_WG_VEHICLE_H.

Referenced by OnCreatureCreate(), OnUnitDeath(), and UpdateCounterVehicle().

Member Data Documentation

◆ BuildingsInZone

GameObjectBuilding BattlefieldWG::BuildingsInZone

protected

Referenced by FillInitialWorldStates(), OnBattleEnd(), OnBattleStart(), ProcessEvent(), SetupBattlefield(), and ~BattlefieldWG().

◆ CanonList

GuidUnorderedSet BattlefieldWG::CanonList

protected

Referenced by OnBattleEnd(), OnBattleStart(), and SetupBattlefield().

◆ DefenderPortalList

GameObjectSet BattlefieldWG::DefenderPortalList

protected

Referenced by OnBattleEnd(), and SetupBattlefield().

◆ IsRelicInteractible

bool BattlefieldWG::IsRelicInteractible

protected

Referenced by CanInteractWithRelic(), SetRelicInteractible(), and SetupBattlefield().

◆ KeepCreature

GuidUnorderedSet BattlefieldWG::KeepCreature[2]

protected

Referenced by OnBattleEnd(), and SetupBattlefield().

◆ KeepGameObject

GameObjectSet BattlefieldWG::KeepGameObject[2]

protected

Referenced by OnBattleEnd().

◆ LastBattleAttackerVictory

bool BattlefieldWG::LastBattleAttackerVictory {false}

protected

460{false};

Referenced by IsLastBattleAttackerVictory(), and OnBattleEnd().

◆ OutsideCreature

GuidUnorderedSet BattlefieldWG::OutsideCreature[2]

protected

Referenced by OnBattleEnd(), and SetupBattlefield().

◆ TenacityStack

int32 BattlefieldWG::TenacityStack

protected

Referenced by OnBattleStart(), SetupBattlefield(), and UpdateTenacity().

◆ TitansRelic

ObjectGuid BattlefieldWG::TitansRelic

protected

Referenced by GetRelic(), OnBattleEnd(), OnBattleStart(), and SetupBattlefield().

◆ UpdateTenacityList

GuidUnorderedSet BattlefieldWG::UpdateTenacityList

protected

Referenced by AddUpdateTenacity(), OnBattleStart(), RemoveUpdateTenacity(), and UpdateTenacity().

◆ Vehicles

GuidUnorderedSet BattlefieldWG::Vehicles[2]

protected

Referenced by FindAndRemoveVehicleFromList(), OnBattleEnd(), OnCreatureCreate(), and UpdateTenacity().

◆ WorkshopsList

Workshop BattlefieldWG::WorkshopsList

protected

Referenced by FillInitialWorldStates(), OnBattleEnd(), OnBattleStart(), OnGameObjectCreate(), SetupBattlefield(), UpdateCounterVehicle(), and ~BattlefieldWG().

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

azerothcore-wotlk/src/server/game/Battlefield/Zones/BattlefieldWG.h
azerothcore-wotlk/src/server/game/Battlefield/Zones/BattlefieldWG.cpp

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~BattlefieldWG()

Member Function Documentation

◆ AddUpdateTenacity()

◆ BrokenWallOrTower()

◆ CanInteractWithRelic()

◆ CapturePointTaken()

◆ FillInitialWorldStates()

◆ FindAndRemoveVehicleFromList()

◆ GetAreaByGraveyardId()

◆ GetData()

◆ GetHonorBuff()

◆ GetRelic()

◆ GetSpiritGraveyardId()

◆ HandleKill()

◆ IsKeepNpc()

◆ IsLastBattleAttackerVictory()

◆ OnBattleEnd()

◆ OnBattleStart()

◆ OnCreatureCreate()

◆ OnCreatureRemove()

◆ OnGameObjectCreate()

◆ OnPlayerEnterZone()

◆ OnPlayerJoinWar()

◆ OnPlayerLeaveWar()

◆ OnPlayerLeaveZone()

◆ OnStartGrouping()

◆ OnUnitDeath()

◆ ProcessEvent()

◆ PromotePlayer()

◆ RelocateDeadPlayers()

◆ RemoveAurasFromPlayer()

◆ RemoveUpdateTenacity()

◆ SendInitWorldStatesTo()

◆ SendInitWorldStatesToAll()

◆ SendUpdateWorldStateMessage()

◆ SendUpdateWorldStates()

◆ SetRelicInteractible()

◆ SetupBattlefield()

◆ Update()

◆ UpdateCounterVehicle()

◆ UpdateDamagedTowerCount()

◆ UpdatedDestroyedTowerCount()

◆ UpdateTenacity()

◆ UpdateVehicleCountWG()

Member Data Documentation

◆ BuildingsInZone

◆ CanonList

◆ DefenderPortalList

◆ IsRelicInteractible

◆ KeepCreature

◆ KeepGameObject

◆ LastBattleAttackerVictory

◆ OutsideCreature

◆ TenacityStack

◆ TitansRelic

◆ UpdateTenacityList

◆ Vehicles

◆ WorkshopsList