BfWGGameObjectBuilding Struct Reference

#include <BattlefieldWG.h>

Public Member Functions
	BfWGGameObjectBuilding (BattlefieldWG *wg, WintergraspGameObjectBuildingType type, uint32 worldState)
void	Init (GameObject *go)
ObjectGuid const &	GetGUID () const
void	Rebuild ()
void	Damaged ()
void	Destroyed ()
void	UpdateCreatureAndGo ()
void	UpdateTurretAttack (bool disable)
void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &packet)
void	Save ()

Private Attributes
BattlefieldWG *	_wg
ObjectGuid	_buildGUID
TeamId	_teamControl
WintergraspGameObjectBuildingType	_type
uint32	_worldState
WintergraspGameObjectState	_state
StaticWintergraspTowerInfo const *	_staticTowerInfo
GuidSet	m_GameObjectList [BG_TEAMS_COUNT]
GuidSet	m_CreatureBottomList [BG_TEAMS_COUNT]
GuidSet	m_CreatureTopList [BG_TEAMS_COUNT]
GuidSet	m_TowerCannonBottomList
GuidSet	m_TurretTopList

Constructor & Destructor Documentation

BfWGGameObjectBuilding::BfWGGameObjectBuilding	(	BattlefieldWG *	wg,
		WintergraspGameObjectBuildingType	type,
		uint32	worldState
	)

{
 ASSERT(wg);

 _wg = wg;
 _teamControl = TEAM_NEUTRAL;
 _type = type;
 _worldState = worldState;
 _state = BATTLEFIELD_WG_OBJECTSTATE_NONE;
 _staticTowerInfo = nullptr;
}

Member Function Documentation

void BfWGGameObjectBuilding::Damaged

(

)

{
 // Update worldstate
 _state = WintergraspGameObjectState(BATTLEFIELD_WG_OBJECTSTATE_ALLIANCE_DAMAGE - (_teamControl * 3));
 _wg->SendUpdateWorldState(_worldState, _state);

 // Send warning message
 if (_staticTowerInfo)
 _wg->SendWarning(_staticTowerInfo->TextIds.Damaged);

 for (ObjectGuid guid : m_CreatureTopList[_wg->GetAttackerTeam()])
 if (Creature* creature = _wg->GetCreature(guid))
 _wg->HideNpc(creature);

 for (ObjectGuid guid : m_TurretTopList)
 if (Creature* creature = _wg->GetCreature(guid))
 _wg->HideNpc(creature);

 if (_type == BATTLEFIELD_WG_OBJECTTYPE_KEEP_TOWER)
 _wg->UpdateDamagedTowerCount(_wg->GetDefenderTeam());
 else if (_type == BATTLEFIELD_WG_OBJECTTYPE_TOWER)
 _wg->UpdateDamagedTowerCount(_wg->GetAttackerTeam());
}

Here is the call graph for this function:

void BfWGGameObjectBuilding::Destroyed

(

)

{
 // Update worldstate
 _state = WintergraspGameObjectState(BATTLEFIELD_WG_OBJECTSTATE_ALLIANCE_DESTROY - (_teamControl * 3));
 _wg->SendUpdateWorldState(_worldState, _state);

 // Warn players
 if (_staticTowerInfo)
 _wg->SendWarning(_staticTowerInfo->TextIds.Destroyed);

 switch (_type)
 {
 // Inform the global wintergrasp script of the destruction of this object
 case BATTLEFIELD_WG_OBJECTTYPE_TOWER:
 case BATTLEFIELD_WG_OBJECTTYPE_KEEP_TOWER:
 _wg->UpdatedDestroyedTowerCount(_teamControl);
 break;
 case BATTLEFIELD_WG_OBJECTTYPE_DOOR_LAST:
 if (GameObject* build = _wg->GetGameObject(_buildGUID))
 if (GameObject* go = build->FindNearestGameObject(GO_WINTERGRASP_KEEP_COLLISION_WALL, 50.0f))
 go->SetGoState(GO_STATE_ACTIVE);
 _wg->SetRelicInteractible(true);
 if (_wg->GetRelic())
 _wg->GetRelic()->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_IN_USE);
 else
 TC_LOG_ERROR("bg.battlefield.wg", "Titan Relic not found.");
 break;
 default:
 break;
 }

 _wg->BrokenWallOrTower(_teamControl);
}

Here is the call graph for this function:

void BfWGGameObjectBuilding::FillInitialWorldStates

(

WorldPackets::WorldState::InitWorldStates &

packet

)

{
 packet.Worldstates.emplace_back(uint32(_worldState), int32(_state));
}

ObjectGuid const& BfWGGameObjectBuilding::GetGUID ( ) const

inline

{ return _buildGUID; }

void BfWGGameObjectBuilding::Init

(

GameObject *

go

)

{
 if (!go)
 return;

 // GameObject associated to object
 _buildGUID = go->GetGUID();

 switch (_type)
 {
 case BATTLEFIELD_WG_OBJECTTYPE_KEEP_TOWER:
 case BATTLEFIELD_WG_OBJECTTYPE_DOOR_LAST:
 case BATTLEFIELD_WG_OBJECTTYPE_DOOR:
 case BATTLEFIELD_WG_OBJECTTYPE_WALL:
 _teamControl = _wg->GetDefenderTeam(); // Objects that are part of the keep should be the defender's
 break;
 case BATTLEFIELD_WG_OBJECTTYPE_TOWER:
 _teamControl = _wg->GetAttackerTeam(); // The towers in the south should be the attacker's
 break;
 default:
 _teamControl = TEAM_NEUTRAL;
 break;
 }

 _state = WintergraspGameObjectState(sWorld->getWorldState(_worldState));
 switch (_state)
 {
 case BATTLEFIELD_WG_OBJECTSTATE_NEUTRAL_INTACT:
 case BATTLEFIELD_WG_OBJECTSTATE_ALLIANCE_INTACT:
 case BATTLEFIELD_WG_OBJECTSTATE_HORDE_INTACT:
 go->SetDestructibleState(GO_DESTRUCTIBLE_REBUILDING, NULL, true);
 break;
 case BATTLEFIELD_WG_OBJECTSTATE_NEUTRAL_DESTROY:
 case BATTLEFIELD_WG_OBJECTSTATE_ALLIANCE_DESTROY:
 case BATTLEFIELD_WG_OBJECTSTATE_HORDE_DESTROY:
 go->SetDestructibleState(GO_DESTRUCTIBLE_DESTROYED);
 break;
 case BATTLEFIELD_WG_OBJECTSTATE_NEUTRAL_DAMAGE:
 case BATTLEFIELD_WG_OBJECTSTATE_ALLIANCE_DAMAGE:
 case BATTLEFIELD_WG_OBJECTSTATE_HORDE_DAMAGE:
 go->SetDestructibleState(GO_DESTRUCTIBLE_DAMAGED);
 break;
 default:
 break;
 }

 int32 towerId = -1;
 switch (go->GetEntry())
 {
 case GO_WINTERGRASP_FORTRESS_TOWER_1:
 towerId = BATTLEFIELD_WG_TOWER_FORTRESS_NW;
 break;
 case GO_WINTERGRASP_FORTRESS_TOWER_2:
 towerId = BATTLEFIELD_WG_TOWER_FORTRESS_SW;
 break;
 case GO_WINTERGRASP_FORTRESS_TOWER_3:
 towerId = BATTLEFIELD_WG_TOWER_FORTRESS_SE;
 break;
 case GO_WINTERGRASP_FORTRESS_TOWER_4:
 towerId = BATTLEFIELD_WG_TOWER_FORTRESS_NE;
 break;
 case GO_WINTERGRASP_SHADOWSIGHT_TOWER:
 towerId = BATTLEFIELD_WG_TOWER_SHADOWSIGHT;
 break;
 case GO_WINTERGRASP_WINTER_S_EDGE_TOWER:
 towerId = BATTLEFIELD_WG_TOWER_WINTER_S_EDGE;
 break;
 case GO_WINTERGRASP_FLAMEWATCH_TOWER:
 towerId = BATTLEFIELD_WG_TOWER_FLAMEWATCH;
 break;
 }

 if (towerId > 3) // Attacker towers
 {
 // Spawn associate gameobjects
 for (uint8 i = 0; i < AttackTowers[towerId - 4].nbObject; i++)
 {
 WintergraspObjectPositionData const& gobData = AttackTowers[towerId - 4].GameObject[i];
 if (GameObject* goHorde = _wg->SpawnGameObject(gobData.entryHorde, gobData.x, gobData.y, gobData.z, gobData.o))
 m_GameObjectList[TEAM_HORDE].insert(goHorde->GetGUID());
 if (GameObject* goAlliance = _wg->SpawnGameObject(gobData.entryAlliance, gobData.x, gobData.y, gobData.z, gobData.o))
 m_GameObjectList[TEAM_ALLIANCE].insert(goAlliance->GetGUID());
 }

 // Spawn associate npc bottom
 for (uint8 i = 0; i < AttackTowers[towerId - 4].nbCreatureBottom; i++)
 {
 WintergraspObjectPositionData const& creatureData = AttackTowers[towerId - 4].CreatureBottom[i];
 if (Creature* creature = _wg->SpawnCreature(creatureData.entryHorde, creatureData.x, creatureData.y, creatureData.z, creatureData.o, TEAM_HORDE))
 m_CreatureBottomList[TEAM_HORDE].insert(creature->GetGUID());
 if (Creature* creature = _wg->SpawnCreature(creatureData.entryAlliance, creatureData.x, creatureData.y, creatureData.z, creatureData.o, TEAM_ALLIANCE))
 m_CreatureBottomList[TEAM_ALLIANCE].insert(creature->GetGUID());
 }

 // Spawn associate npc top
 for (uint8 i = 0; i < AttackTowers[towerId - 4].nbCreatureTop; i++)
 {
 WintergraspObjectPositionData const& creatureData = AttackTowers[towerId - 4].CreatureTop[i];
 if (Creature* creature = _wg->SpawnCreature(creatureData.entryHorde, creatureData.x, creatureData.y, creatureData.z, creatureData.o, TEAM_HORDE))
 m_CreatureTopList[TEAM_HORDE].insert(creature->GetGUID());
 if (Creature* creature = _wg->SpawnCreature(creatureData.entryAlliance, creatureData.x, creatureData.y, creatureData.z, creatureData.o, TEAM_ALLIANCE))
 m_CreatureTopList[TEAM_ALLIANCE].insert(creature->GetGUID());
 }
 }

 if (towerId >= 0)
 {
 ASSERT(towerId < WG_MAX_TOWER);
 _staticTowerInfo = &TowerData[towerId];

 // Spawn Turret bottom
 for (uint8 i = 0; i < TowerCannon[towerId].nbTowerCannonBottom; i++)
 {
 Position const& turretPos = TowerCannon[towerId].TowerCannonBottom[i];
 if (Creature* turret = _wg->SpawnCreature(NPC_WINTERGRASP_TOWER_CANNON, turretPos, TEAM_ALLIANCE))
 {
 m_TowerCannonBottomList.insert(turret->GetGUID());
 switch (go->GetEntry())
 {
 case GO_WINTERGRASP_FORTRESS_TOWER_1:
 case GO_WINTERGRASP_FORTRESS_TOWER_2:
 case GO_WINTERGRASP_FORTRESS_TOWER_3:
 case GO_WINTERGRASP_FORTRESS_TOWER_4:
 turret->setFaction(WintergraspFaction[_wg->GetDefenderTeam()]);
 break;
 case GO_WINTERGRASP_SHADOWSIGHT_TOWER:
 case GO_WINTERGRASP_WINTER_S_EDGE_TOWER:
 case GO_WINTERGRASP_FLAMEWATCH_TOWER:
 turret->setFaction(WintergraspFaction[_wg->GetAttackerTeam()]);
 break;
 }
 _wg->HideNpc(turret);
 }
 }

 // Spawn Turret top
 for (uint8 i = 0; i < TowerCannon[towerId].nbTurretTop; i++)
 {
 Position const& towerCannonPos = TowerCannon[towerId].TurretTop[i];
 if (Creature* turret = _wg->SpawnCreature(NPC_WINTERGRASP_TOWER_CANNON, towerCannonPos, TeamId(0)))
 {
 m_TurretTopList.insert(turret->GetGUID());
 switch (go->GetEntry())
 {
 case GO_WINTERGRASP_FORTRESS_TOWER_1:
 case GO_WINTERGRASP_FORTRESS_TOWER_2:
 case GO_WINTERGRASP_FORTRESS_TOWER_3:
 case GO_WINTERGRASP_FORTRESS_TOWER_4:
 turret->setFaction(WintergraspFaction[_wg->GetDefenderTeam()]);
 break;
 case GO_WINTERGRASP_SHADOWSIGHT_TOWER:
 case GO_WINTERGRASP_WINTER_S_EDGE_TOWER:
 case GO_WINTERGRASP_FLAMEWATCH_TOWER:
 turret->setFaction(WintergraspFaction[_wg->GetAttackerTeam()]);
 break;
 }
 _wg->HideNpc(turret);
 }
 }
 UpdateCreatureAndGo();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BfWGGameObjectBuilding::Rebuild

(

)

{
 switch (_type)
 {
 case BATTLEFIELD_WG_OBJECTTYPE_KEEP_TOWER:
 case BATTLEFIELD_WG_OBJECTTYPE_DOOR_LAST:
 case BATTLEFIELD_WG_OBJECTTYPE_DOOR:
 case BATTLEFIELD_WG_OBJECTTYPE_WALL:
 _teamControl = _wg->GetDefenderTeam(); // Objects that are part of the keep should be the defender's
 break;
 case BATTLEFIELD_WG_OBJECTTYPE_TOWER:
 _teamControl = _wg->GetAttackerTeam(); // The towers in the south should be the attacker's
 break;
 default:
 _teamControl = TEAM_NEUTRAL;
 break;
 }

 if (GameObject* build = _wg->GetGameObject(_buildGUID))
 {
 // Rebuild gameobject
 if (build->IsDestructibleBuilding())
 {
 build->SetDestructibleState(GO_DESTRUCTIBLE_REBUILDING, NULL, true);
 if (build->GetEntry() == GO_WINTERGRASP_VAULT_GATE)
 if (GameObject* go = build->FindNearestGameObject(GO_WINTERGRASP_KEEP_COLLISION_WALL, 50.0f))
 go->SetGoState(GO_STATE_READY);

 // Update worldstate
 _state = WintergraspGameObjectState(BATTLEFIELD_WG_OBJECTSTATE_ALLIANCE_INTACT - (_teamControl * 3));
 _wg->SendUpdateWorldState(_worldState, _state);
 }
 UpdateCreatureAndGo();
 build->SetFaction(WintergraspFaction[_teamControl]);
 }
}

Here is the call graph for this function:

void BfWGGameObjectBuilding::Save

(

)

{
 sWorld->setWorldState(_worldState, _state);
}

void BfWGGameObjectBuilding::UpdateCreatureAndGo

(

)

{
 for (ObjectGuid guid : m_CreatureTopList[_wg->GetDefenderTeam()])
 if (Creature* creature = _wg->GetCreature(guid))
 _wg->HideNpc(creature);

 for (ObjectGuid guid : m_CreatureTopList[_wg->GetAttackerTeam()])
 if (Creature* creature = _wg->GetCreature(guid))
 _wg->ShowNpc(creature, true);

 for (ObjectGuid guid : m_CreatureBottomList[_wg->GetDefenderTeam()])
 if (Creature* creature = _wg->GetCreature(guid))
 _wg->HideNpc(creature);

 for (ObjectGuid guid : m_CreatureBottomList[_wg->GetAttackerTeam()])
 if (Creature* creature = _wg->GetCreature(guid))
 _wg->ShowNpc(creature, true);

 for (ObjectGuid guid : m_GameObjectList[_wg->GetDefenderTeam()])
 if (GameObject* go = _wg->GetGameObject(guid))
 go->SetRespawnTime(RESPAWN_ONE_DAY);

 for (ObjectGuid guid : m_GameObjectList[_wg->GetAttackerTeam()])
 if (GameObject* go = _wg->GetGameObject(guid))
 go->SetRespawnTime(RESPAWN_IMMEDIATELY);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BfWGGameObjectBuilding::UpdateTurretAttack

(

bool

disable

)

{
 for (ObjectGuid guid : m_TowerCannonBottomList)
 {
 if (Creature* creature = _wg->GetCreature(guid))
 {
 if (disable)
 _wg->HideNpc(creature);
 else
 _wg->ShowNpc(creature, true);

 switch (_buildGUID.GetEntry())
 {
 case GO_WINTERGRASP_FORTRESS_TOWER_1:
 case GO_WINTERGRASP_FORTRESS_TOWER_2:
 case GO_WINTERGRASP_FORTRESS_TOWER_3:
 case GO_WINTERGRASP_FORTRESS_TOWER_4:
 {
 creature->setFaction(WintergraspFaction[_wg->GetDefenderTeam()]);
 break;
 }
 case GO_WINTERGRASP_SHADOWSIGHT_TOWER:
 case GO_WINTERGRASP_WINTER_S_EDGE_TOWER:
 case GO_WINTERGRASP_FLAMEWATCH_TOWER:
 {
 creature->setFaction(WintergraspFaction[_wg->GetAttackerTeam()]);
 break;
 }
 }
 }
 }

 for (ObjectGuid guid : m_TurretTopList)
 {
 if (Creature* creature = _wg->GetCreature(guid))
 {
 if (disable)
 _wg->HideNpc(creature);
 else
 _wg->ShowNpc(creature, true);

 switch (_buildGUID.GetEntry())
 {
 case GO_WINTERGRASP_FORTRESS_TOWER_1:
 case GO_WINTERGRASP_FORTRESS_TOWER_2:
 case GO_WINTERGRASP_FORTRESS_TOWER_3:
 case GO_WINTERGRASP_FORTRESS_TOWER_4:
 {
 creature->setFaction(WintergraspFaction[_wg->GetDefenderTeam()]);
 break;
 }
 case GO_WINTERGRASP_SHADOWSIGHT_TOWER:
 case GO_WINTERGRASP_WINTER_S_EDGE_TOWER:
 case GO_WINTERGRASP_FLAMEWATCH_TOWER:
 {
 creature->setFaction(WintergraspFaction[_wg->GetAttackerTeam()]);
 break;
 }
 }
 }
 }
}

Here is the call graph for this function:

Member Data Documentation

ObjectGuid BfWGGameObjectBuilding::_buildGUID

private

WintergraspGameObjectState BfWGGameObjectBuilding::_state

private

StaticWintergraspTowerInfo const* BfWGGameObjectBuilding::_staticTowerInfo

private

TeamId BfWGGameObjectBuilding::_teamControl

private

WintergraspGameObjectBuildingType BfWGGameObjectBuilding::_type

private

BattlefieldWG* BfWGGameObjectBuilding::_wg

private

uint32 BfWGGameObjectBuilding::_worldState

private

GuidSet BfWGGameObjectBuilding::m_CreatureBottomList[BG_TEAMS_COUNT]

private

GuidSet BfWGGameObjectBuilding::m_CreatureTopList[BG_TEAMS_COUNT]

private

GuidSet BfWGGameObjectBuilding::m_GameObjectList[BG_TEAMS_COUNT]

private

GuidSet BfWGGameObjectBuilding::m_TowerCannonBottomList

private

GuidSet BfWGGameObjectBuilding::m_TurretTopList

private

---

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

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