/* * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or (at your * option) any later version. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along * with this program. If not, see . */ // TO-DO: // - Implement proper support for vehicles (Player::VehicleSpellInitialize()) // - Siege Engine Turret (45564) crashing server (Auras: Unknown Shapeshift Type: 24) // - Graveyard spirit phasing, ressurection, Spiritual Immunity aura for players nearby // - Warn and teleport players out of the Baradin Hold instance (need sniffs; spell 94964?) // - Not sure, but players should probably be able to ressurect from guide spirits when there's no battle // - Check and script achievements #include "BattlefieldTB.h" #include "Battleground.h" #include "Creature.h" #include "GameObject.h" #include "GameTime.h" #include "MapManager.h" #include "ObjectAccessor.h" #include "Player.h" #include "Random.h" #include "ScriptMgr.h" #include "World.h" #include "WorldStateMgr.h" const uint32 TBFactions[BG_TEAMS_COUNT] = { 1610, 1732 }; // Stalker Position const TolBaradDebugAnnouncerPos = { -1234.25f, 961.903f, 159.4913f, 0.0f }; uint32 const TB_QUEST_INFANTRY[BG_TEAMS_COUNT][4] = { { NPC_HORDE_DRUID_INFANTRY, NPC_HORDE_MAGE_INFANTRY, NPC_HORDE_ROGUE_INFANTRY, NPC_HORDE_SHAMAN_INFANTRY }, { NPC_ALLIANCE_WARRIOR_INFANTRY, NPC_ALLIANCE_PALADIN_INFANTRY, NPC_ALLIANCE_HUNTER_INFANTRY, NPC_ALLIANCE_MAGE_INFANTRY }, }; uint8 const TB_QUEST_INFANTRY_MAX = 37; Position const TBQuestInfantrySpawnData[TB_QUEST_INFANTRY_MAX] = { { -930.4685f, 1020.178f, 121.5658f, 0.1537642f }, { -831.5157f, 975.816f, 121.5255f, 5.022717f }, { -837.0773f, 943.9008f, 121.5055f, 5.461119f }, { -839.1646f, 1024.046f, 121.5505f, 4.782219f }, { -881.283f, 1033.25f, 121.5243f, 0.0f }, { -883.038f, 924.955f, 121.5243f, 0.0f }, { -883.913f, 978.059f, 121.5243f, 3.388291f }, { -883.6224f, 950.8459f, 121.5122f, 0.8307042f }, { -895.181f, 1015.2f, 121.5505f, 2.652318f }, { -943.4023f, 961.7462f, 121.5658f, 5.258394f }, { -958.649f, 926.877f, 121.5243f, 0.0f }, { -959.743f, 1029.09f, 121.5243f, 0.0f }, { -964.6652f, 978.5373f, 121.5257f, 0.02025719f }, { -1407.14f, 721.42f, 123.5033f, 0.0f }, { -1414.46f, 671.66f, 123.5043f, 0.0f }, { -1431.7f, 623.073f, 123.5043f, 0.0f }, { -1434.162f, 655.8566f, 123.5051f, 4.84886f }, { -1445.19f, 739.729f, 123.5457f, 5.767949f }, { -1460.954f, 718.418f, 123.6453f, 5.178094f }, { -1462.48f, 694.378f, 123.5463f, 0.3441857f }, { -1372.23f, 683.707f, 123.5043f, 0.0f }, { -1479.46f, 635.799f, 123.5043f, 0.0f }, { -1491.259f, 734.5692f, 123.4525f, 1.529741f }, { -1509.024f, 688.8625f, 123.5463f, 6.243045f }, { -1419.311f, 1310.25f, 133.8389f, 0.0f }, { -1444.24f, 1266.439f, 133.8229f, 0.0f }, { -1450.569f, 1337.351f, 133.914f, 0.0f }, { -1479.819f, 1331.34f, 153.2f, 0.0f }, { -1497.62f, 1276.429f, 133.6676f, 3.147845f }, { -1498.37f, 1379.689f, 133.827f, 0.0f }, { -1499.97f, 1232.87f, 133.8239f, 0.0f }, { -1505.7f, 1261.99f, 133.7089f, 0.6167698f }, { -1531.84f, 1316.569f, 153.2f, 0.0f }, { -1533.141f, 1267.66f, 133.836f, 0.0f }, { -1547.59f, 1300.21f, 133.7094f, 1.908187f }, { -1563.3f, 1325.79f, 133.6673f, 0.0f }, }; uint8 const TB_GUARDS_MAX = 8; Position const GuardNPCSpawns[TB_GUARDS_MAX] = { // { -837.3768f, 1196.082f, 114.2994f, 3.036873f }, // { -762.118f, 1195.259f, 107.2007f, 3.036873f }, // { -837.809f, 1179.842f, 114.1356f, 3.159046f }, // { -762.5504f, 1179.019f, 107.2137f, 3.159046f }, { -1272.951f, 964.8854f, 119.5782f, 3.193953f }, { -1274.394f, 997.6511f, 119.5743f, 3.193953f }, { -1248.226f, 1018.476f, 119.8113f, 1.605703f }, { -1218.948f, 943.5695f, 119.5994f, 4.625123f }, { -1195.417f, 965.5364f, 119.8113f, 0.0f }, { -1220.832f, 1018.497f, 119.8113f, 1.605703f }, { -1196.151f, 999.5121f, 119.5966f, 0.0f }, { -1249.304f, 942.9063f, 119.5782f, 4.625123f }, }; struct TBFactionNPCInfo { Position pos; uint32 entryAlliance; uint32 entryHorde; }; uint8 const TB_FACTION_NPC_MAX = 4; TBFactionNPCInfo const FactionNPCSpawns[TB_FACTION_NPC_MAX] = { { { -1259.356f, 1057.108f, 107.0786f, 4.956735f }, NPC_BARADIN_GUARD_1, NPC_BARADIN_GRUNT_1 }, { { -1254.174f, 1061.094f, 107.0772f, 5.445427f }, NPC_BARADIN_GUARD_2, NPC_BARADIN_GRUNT_2 }, { { -1256.365f, 1058.47f, 107.0776f, 2.216568f }, NPC_MAVEN_ZARA, NPC_RHAGHA }, { { -1231.38f, 985.681f, 121.2403f, 0.6108652f }, NPC_SERGEANT_PARKER, NPC_COMMANDER_ZANOTH }, }; Position const RandomQuestgiverPos = { -1228.93f, 975.038f, 121.7153f, 5.969026f }; struct TBQuestAreaInfo { uint32 entry; uint32 teleportSpell; }; TBQuestAreaInfo const TBQuestAreas[CELLBLOCK_MAX] = { { AREA_THE_HOLE, SPELL_TB_THE_HOLE_TELEPORT }, { AREA_D_BLOCK, SPELL_TB_D_BLOCK_TELEPORT }, { AREA_CURSED_DEPTHS, SPELL_TB_CURSED_DEPTHS_TELEPORT }, }; uint32 const RandomQuestgivers[BG_TEAMS_COUNT][CELLBLOCK_MAX] = { { NPC_MARSHAL_FALLOWS, NPC_2ND_LIEUTENANT_WANSWORTH, NPC_COMMANDER_STEVENS }, { NPC_DRILLMASTER_RAZGOTH, NPC_STAFF_SERGEANT_LAZGAR, NPC_PRIVATE_GARNOTH }, }; struct TBCapturePointSpawnData { Position pos; QuaternionData rot; TBCapturePointId id; uint32 entryFlagPole[2]; uint32 wsControlled[2]; uint32 wsCapturing[2]; uint32 wsNeutral; uint32 textGained[2]; uint32 textLost[2]; }; TBCapturePointSpawnData const TBCapturePoints[TB_BASE_COUNT] = { { { -896.96f, 979.497f, 121.441f, 3.124123f }, { 0.f, 0.f, 0.99996185f, 0.00873472f },TB_BASE_IRONCLAD_GARRISON, { GO_CAPTURE_POINT_NORTH_A_DEFENDING, GO_CAPTURE_POINT_NORTH_H_DEFENDING }, { WS_BATTLEFIELD_TB_GARRISON_ALLIANCE_CONTROLLED, WS_BATTLEFIELD_TB_GARRISON_HORDE_CONTROLLED }, { WS_BATTLEFIELD_TB_GARRISON_ALLIANCE_CAPTURING, WS_BATTLEFIELD_TB_GARRISON_HORDE_CAPTURING }, WS_BATTLEFIELD_TB_GARRISON_NEUTRAL, { TB_TEXT_GARRISON_ALLIANCE_GAINED, TB_TEXT_GARRISON_HORDE_GAINED }, { TB_TEXT_GARRISON_ALLIANCE_LOST, TB_TEXT_GARRISON_HORDE_LOST } }, { { -1492.34f, 1309.87f, 152.961f, 5.462882f }, { 0.f, 0.f, 0.39874841f, -0.91706036f }, TB_BASE_WARDENS_VIGIL, { GO_CAPTURE_POINT_WEST_A_DEFENDING, GO_CAPTURE_POINT_WEST_H_DEFENDING }, { WS_BATTLEFIELD_TB_VIGIL_ALLIANCE_CONTROLLED, WS_BATTLEFIELD_TB_VIGIL_HORDE_CONTROLLED }, { WS_BATTLEFIELD_TB_VIGIL_ALLIANCE_CAPTURING, WS_BATTLEFIELD_TB_VIGIL_HORDE_CAPTURING }, WS_BATTLEFIELD_TB_VIGIL_NEUTRAL, { TB_TEXT_VIGIL_ALLIANCE_GAINED, TB_TEXT_VIGIL_HORDE_GAINED }, { TB_TEXT_VIGIL_ALLIANCE_LOST, TB_TEXT_VIGIL_HORDE_LOST } }, { { -1437.f, 685.556f, 123.421f, 0.802851f }, { 0.f, 0.f, 0.39073092f, 0.92050494f },TB_BASE_SLAGWORKS, { GO_CAPTURE_POINT_EAST_A_DEFENDING, GO_CAPTURE_POINT_EAST_H_DEFENDING }, { WS_BATTLEFIELD_TB_SLAGWORKS_ALLIANCE_CONTROLLED, WS_BATTLEFIELD_TB_SLAGWORKS_HORDE_CONTROLLED }, { WS_BATTLEFIELD_TB_SLAGWORKS_ALLIANCE_CAPTURING, WS_BATTLEFIELD_TB_SLAGWORKS_HORDE_CAPTURING }, WS_BATTLEFIELD_TB_SLAGWORKS_NEUTRAL, { TB_TEXT_SLAGWORKS_ALLIANCE_GAINED, TB_TEXT_SLAGWORKS_HORDE_GAINED }, { TB_TEXT_SLAGWORKS_ALLIANCE_LOST, TB_TEXT_SLAGWORKS_HORDE_LOST } }, }; struct TBTowerInfo { Position pos; QuaternionData rot; uint32 entry; uint32 textDamaged; uint32 textDestroyed; uint32 wsIntact[BG_TEAMS_COUNT]; uint32 wsDamaged[BG_TEAMS_COUNT]; uint32 wsDestroyed; }; TBTowerInfo const TBTowers[TB_TOWERS_COUNT] = { { { -1013.279f, 529.5382f, 146.427f, 1.97222f }, { 0.f, 0.f, 0.83388526f, 0.55193784f }, GO_EAST_SPIRE, TB_TEXT_EAST_SPIRE_DAMAGED, TB_TEXT_EAST_SPIRE_DESTROYED, { WS_BATTLEFIELD_TB_EAST_INTACT_ALLIANCE, WS_BATTLEFIELD_TB_EAST_INTACT_HORDE }, { WS_BATTLEFIELD_TB_EAST_DAMAGED_ALLIANCE, WS_BATTLEFIELD_TB_EAST_DAMAGED_HORDE }, WS_BATTLEFIELD_TB_EAST_DESTROYED_NEUTRAL }, { { -1618.91f, 954.5417f, 168.601f, 0.06981169f }, { 0.f, 0.f, 0.03489876f, 0.99939085f }, GO_SOUTH_SPIRE, TB_TEXT_SOUTH_SPIRE_DAMAGED, TB_TEXT_SOUTH_SPIRE_DESTROYED, { WS_BATTLEFIELD_TB_SOUTH_INTACT_ALLIANCE, WS_BATTLEFIELD_TB_SOUTH_INTACT_HORDE }, { WS_BATTLEFIELD_TB_SOUTH_DAMAGED_ALLIANCE, WS_BATTLEFIELD_TB_SOUTH_DAMAGED_HORDE }, WS_BATTLEFIELD_TB_SOUTH_DESTROYED_NEUTRAL }, { { -950.4097f, 1469.101f, 176.596f, 4.180066f }, { 0.f, 0.f, 0.86819821f, -0.49621756f }, GO_WEST_SPIRE, TB_TEXT_WEST_SPIRE_DAMAGED, TB_TEXT_WEST_SPIRE_DESTROYED, { WS_BATTLEFIELD_TB_WEST_INTACT_ALLIANCE, WS_BATTLEFIELD_TB_WEST_INTACT_HORDE }, { WS_BATTLEFIELD_TB_WEST_DAMAGED_ALLIANCE, WS_BATTLEFIELD_TB_WEST_DAMAGED_HORDE }, WS_BATTLEFIELD_TB_WEST_DESTROYED_NEUTRAL }, }; int8 const TB_ABANDONED_SIEGE_ENGINE_COUNT = 6; Position const TBAbandonedSiegeEngineSpawnData[TB_ABANDONED_SIEGE_ENGINE_COUNT] = { { -1106.57f, 1196.34f, 121.8023f, 0.4014257f }, { -1108.52f, 1111.33f, 121.2783f, 1.37881f }, { -1213.01f, 782.236f, 121.4473f, 1.675516f }, { -1258.26f, 780.497f, 122.4413f, 1.48353f }, { -1438.3f, 1095.24f, 121.1363f, 5.288348f }, { -1442.3f, 1141.07f, 123.6323f, 4.24115f }, }; uint32 const TBBannerEntry[BG_TEAMS_COUNT] = { GO_BARADINS_WARDEN_BANNER, GO_HELLSCREAM_REACH_BANNER }; struct TBBannerData { Position pos; QuaternionData rot; }; uint8 const TB_BANNER_MAX = 23; TBBannerData const TBBanners[TB_BANNER_MAX] = { { { -987.6129f, 963.9861f, 121.4506f, 2.617989f }, { 0.f, 0.f, 0.96592520f, 0.25882140f } }, { { -988.118f, 993.0087f, 121.6746f, 3.612838f }, { 0.f, 0.f, 0.97236917f, -0.23344850f } }, { { -1195.941f, 964.342f, 119.728f, 0.8901166f }, { 0.f, 0.f, 0.43051050f, 0.90258557f } }, { { -1196.892f, 1000.957f, 119.8211f, 5.445428f }, { 0.f, 0.f, 0.40673631f, -0.91354561f } }, { { -1198.236f, 1081.898f, 120.2007f, 1.06465f }, { 0.f, 0.f, 0.50753800f, 0.86162937f } }, { { -1089.337f, 1157.161f, 120.2749f, 3.036838f }, { 0.f, 0.f, 0.99862862f, 0.05235338f } }, { { -1090.033f, 1143.476f, 120.2656f, 3.036838f }, { 0.f, 0.f, 0.99862862f, 0.05235338f } }, { { -1217.495f, 944.0261f, 119.4949f, 1.989672f }, { 0.f, 0.f, 0.83866966f, 0.54464044f } }, { { -1219.226f, 1018.168f, 119.728f, 2.251473f }, { 0.f, 0.f, 0.90258491f, 0.43051188f } }, { { -1210.319f, 1081.885f, 120.2396f, 2.007128f }, { 0.f, 0.f, 0.84339127f, 0.53729988f } }, { { -1226.903f, 786.7656f, 119.4592f, 1.553341f }, { 0.f, 0.f, 0.70090854f, 0.71325116f } }, { { -1228.464f, 979.7379f, 119.3814f, 0.03490625f }, { 0.f, 0.f, 0.01745224f, 0.99984770f } }, { { -1239.668f, 786.7899f, 119.4271f, 1.553341f }, { 0.f, 0.f, 0.70090854f, 0.71325116f } }, { { -1250.262f, 1017.887f, 119.728f, 0.8377575f }, { 0.f, 0.f, 0.40673640f, 0.91354557f } }, { { -1250.693f, 943.4496f, 119.4949f, 5.305802f }, { 0.f, 0.f, 0.46947109f, -0.88294784f } }, { { -1272.29f, 963.5208f, 119.4949f, 2.617989f }, { 0.f, 0.f, 0.96592520f, 0.25882140f } }, { { -1273.997f, 998.7934f, 119.4884f, 3.665196f }, { 0.f, 0.f, 0.96592523f, -0.25882125f } }, { { -1378.363f, 725.0087f, 124.2978f, 1.326448f }, { 0.f, 0.f, 0.61566060f, 0.78801144f } }, { { -1401.97f, 747.0972f, 123.2302f, 0.2443456f }, { 0.f, 0.f, 0.12186910f, 0.99254618f } }, { { -1421.953f, 1263.559f, 133.6141f, 5.009095f }, { 0.f, 0.f, 0.59482277f, -0.80385687f } }, { { -1446.497f, 1238.964f, 133.7601f, 5.969027f }, { 0.f, 0.f, 0.15643399f, -0.98768842f } }, { { -1488.908f, 1118.747f, 124.9255f, 6.248279f }, { 0.f, 0.f, 0.01745227f, -0.99984770f } }, { { -1488.533f, 1131.608f, 124.6363f, 6.248279f }, { 0.f, 0.f, 0.01745227f, -0.99984770f } }, }; uint32 const TBPortalEntry[BG_TEAMS_COUNT] = { TB_PORTAL_ALLIANCE, TB_PORTAL_HORDE }; struct TBPortalData { Position pos; QuaternionData rot; }; uint8 const TB_PORTAL_MAX = 2; TBPortalData const TBPortals[TB_PORTAL_MAX] = { { { -598.7656f, 1377.974f, 21.91898f, 0.0f }, { 0.f, 0.f, 0.00000000f, 1.00000000f } }, { { -1257.729f, 1060.365f, 106.9938f, 5.462882f }, { 0.f, 0.f, 0.39874841f, -0.91706036f } }, }; struct TBGraveyardInfo { Position pos; uint32 phaseId; uint32 gyid; uint32 spiritEntry[BG_TEAMS_COUNT]; bool defenderControls; }; TBGraveyardInfo const TBGraveyards[BATTLEFIELD_TB_GRAVEYARD_MAX] = { { { -1247.42f, 981.25f, 155.35f, 6.28f }, 128, TB_GY_BARADIN_HOLD, { NPC_TB_GY_SPIRIT_BARADIN_HOLD_A, NPC_TB_GY_SPIRIT_BARADIN_HOLD_H }, true }, { { -974.28f, 1089.47f, 132.99f, 5.90f }, 64, TB_GY_IRONCLAD_GARRISON, { NPC_TB_GY_SPIRIT_IRONCLAD_GARRISON_A, NPC_TB_GY_SPIRIT_IRONCLAD_GARRISON_H }, false }, { { -1570.44f, 1167.57f, 159.50f, 2.20f }, 64, TB_GY_WARDENS_VIGIL, { NPC_TB_GY_SPIRIT_WARDENS_VIGIL_A, NPC_TB_GY_SPIRIT_WARDENS_VIGIL_H }, false }, { { -1343.32f, 565.24f, 139.04f, 1.66f }, 64, TB_GY_SLAGWORKS, { NPC_TB_GY_SPIRIT_SLAGWORKS_A, NPC_TB_GY_SPIRIT_SLAGWORKS_H }, false }, { { -1052.02f, 1494.05f, 191.41f, 4.13f }, 64, TB_GY_WEST_SPIRE, { NPC_TB_GY_SPIRIT_WEST_SPIRE_A, NPC_TB_GY_SPIRIT_WEST_SPIRE_H }, false }, { { -1603.34f, 874.29f, 193.69f, 5.27f }, 64, TB_GY_SOUTH_SPIRE, { NPC_TB_GY_SPIRIT_SOUTH_SPIRE_A, NPC_TB_GY_SPIRIT_SOUTH_SPIRE_H }, false }, { { -943.66f, 572.36f, 157.54f, 1.74f }, 64, TB_GY_EAST_SPIRE, { NPC_TB_GY_SPIRIT_EAST_SPIRE_A, NPC_TB_GY_SPIRIT_EAST_SPIRE_H }, false }, }; BattlefieldTB::~BattlefieldTB() { } bool BattlefieldTB::SetupBattlefield() { m_TypeId = BATTLEFIELD_TB; // See enum BattlefieldTypes m_BattleId = BATTLEFIELD_BATTLEID_TB; m_ZoneId = BATTLEFIELD_TB_ZONEID; m_MapId = BATTLEFIELD_TB_MAPID; m_Map = sMapMgr->CreateBaseMap(m_MapId); InitStalker(NPC_DEBUG_ANNOUNCER, TolBaradDebugAnnouncerPos); m_MaxPlayer = sWorld->getIntConfig(CONFIG_TOLBARAD_PLR_MAX); m_IsEnabled = sWorld->getBoolConfig(CONFIG_TOLBARAD_ENABLE); m_MinPlayer = sWorld->getIntConfig(CONFIG_TOLBARAD_PLR_MIN); m_MinLevel = sWorld->getIntConfig(CONFIG_TOLBARAD_PLR_MIN_LVL); m_BattleTime = sWorld->getIntConfig(CONFIG_TOLBARAD_BATTLETIME) * MINUTE * IN_MILLISECONDS; m_BonusTime = sWorld->getIntConfig(CONFIG_TOLBARAD_BONUSTIME) * MINUTE * IN_MILLISECONDS; m_NoWarBattleTime = sWorld->getIntConfig(CONFIG_TOLBARAD_NOBATTLETIME) * MINUTE * IN_MILLISECONDS; m_RestartAfterCrash = sWorld->getIntConfig(CONFIG_TOLBARAD_RESTART_AFTER_CRASH) * MINUTE * IN_MILLISECONDS; m_TimeForAcceptInvite = 20; m_StartGroupingTimer = 15 * MINUTE * IN_MILLISECONDS; m_StartGrouping = false; m_isActive = false; KickPosition.Relocate(-605.5f, 1181.31f, 95.96f, 6.177155f); KickPosition.m_mapId = m_MapId; RegisterZone(m_ZoneId); m_Data32.resize(BATTLEFIELD_TB_DATA_MAX); m_saveTimer = 5 * MINUTE * IN_MILLISECONDS; updatedNPCAndObjects = true; m_updateObjectsTimer = 0; // Was there a battle going on or time isn't set yet? Then use m_RestartAfterCrash if (sWorld->getWorldState(WS_BATTLEFIELD_TB_STATE_BATTLE) == 1 || sWorld->getWorldState(WS_BATTLEFIELD_TB_TIME_NEXT_BATTLE) == 0) sWorld->setWorldState(WS_BATTLEFIELD_TB_TIME_NEXT_BATTLE, m_RestartAfterCrash); // Set timer m_Timer = sWorld->getWorldState(WS_BATTLEFIELD_TB_TIME_NEXT_BATTLE); // Defending team isn't set yet? Choose randomly. if (sWorld->getWorldState(WS_BATTLEFIELD_TB_FACTION_CONTROLLING) == 0) sWorld->setWorldState(WS_BATTLEFIELD_TB_FACTION_CONTROLLING, uint32(urand(1, 2))); // Set defender team SetDefenderTeam(TeamId(sWorld->getWorldState(WS_BATTLEFIELD_TB_FACTION_CONTROLLING) - 1)); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_NEXT_BATTLE_SHOW, 1, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_NEXT_BATTLE, GameTime::GetGameTime() + m_Timer / IN_MILLISECONDS, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_FACTION_CONTROLLING, GetDefenderTeam() + 1, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_ALLIANCE_CONTROLS_SHOW, GetDefenderTeam() == TEAM_ALLIANCE ? 1 : 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_HORDE_CONTROLS_SHOW, GetDefenderTeam() == TEAM_HORDE ? 1 : 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_KEEP_ALLIANCE, GetDefenderTeam() == TEAM_ALLIANCE ? 1 : 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_KEEP_HORDE, GetDefenderTeam() == TEAM_HORDE ? 1 : 0, m_Map); SaveWorldStateValues(); // Create capture points for (uint8 i = 0; i < TB_BASE_COUNT; i++) { TolBaradCapturePoint* capturePoint = new TolBaradCapturePoint(this, GetDefenderTeam()); //Spawn flag pole if (GameObject* go = SpawnGameObject(TBCapturePoints[i].entryFlagPole[GetDefenderTeam()], TBCapturePoints[i].pos, TBCapturePoints[i].rot)) { go->SetGoArtKit(GetDefenderTeam() == TEAM_ALLIANCE ? TB_GO_ARTKIT_FLAG_ALLIANCE : TB_GO_ARTKIT_FLAG_HORDE); capturePoint->SetCapturePointData(go); } AddCapturePoint(capturePoint); } // Spawn towers for (uint8 i = 0; i < TB_TOWERS_COUNT; i++) if (GameObject* go = SpawnGameObject(TBTowers[i].entry, TBTowers[i].pos, TBTowers[i].rot)) Towers.insert(go->GetGUID()); // Init Graveyards SetGraveyardNumber(BATTLEFIELD_TB_GRAVEYARD_MAX); // Graveyards for (uint8 i = 0; i < BATTLEFIELD_TB_GRAVEYARD_MAX; i++) { BfGraveyard* graveyard = new BfGraveyard(this); // When between games, the graveyard is controlled by the defending team graveyard->Initialize(GetDefenderTeam(), TBGraveyards[i].gyid); // Spawn spirits for (uint8 team = 0; team < 2; team++) if (Creature* creature = SpawnCreature(TBGraveyards[i].spiritEntry[team], TBGraveyards[i].pos)) graveyard->SetSpirit(creature, TeamId(team)); m_GraveyardList[i] = graveyard; } // Time warning vars warnedFiveMinutes = false; warnedTwoMinutes = false; warnedOneMinute = false; UpdateNPCsAndGameObjects(); return true; } bool BattlefieldTB::Update(uint32 diff) { bool m_return = Battlefield::Update(diff); // Minutes till battle preparation warnings if (GetState() == BATTLEFIELD_INACTIVE) { if (m_Timer <= 5 * MINUTE * IN_MILLISECONDS + m_StartGroupingTimer && !warnedFiveMinutes) { warnedFiveMinutes = true; SendWarning(TB_TEXT_PREPARATIONS_IN_5_MIN); } if (m_Timer <= 2 * MINUTE * IN_MILLISECONDS + m_StartGroupingTimer && !warnedTwoMinutes) { warnedTwoMinutes = true; SendWarning(TB_TEXT_PREPARATIONS_IN_2_MIN); } if (m_Timer <= 1 * MINUTE * IN_MILLISECONDS + m_StartGroupingTimer && !warnedOneMinute) { warnedOneMinute = true; SendWarning(TB_TEXT_PREPARATIONS_IN_1_MIN); } } if (!updatedNPCAndObjects) { if (m_updateObjectsTimer <= diff) { UpdateNPCsAndGameObjects(); updatedNPCAndObjects = true; } else m_updateObjectsTimer -= diff; } if (m_saveTimer <= diff) { SaveWorldStateValues(); m_saveTimer = 60 * IN_MILLISECONDS; } else m_saveTimer -= diff; return m_return; } void BattlefieldTB::OnPlayerEnterZone(Player* player) { if (!m_isActive) RemoveAurasFromPlayer(player); } void BattlefieldTB::OnPlayerLeaveZone(Player* player) { if (!m_isActive) RemoveAurasFromPlayer(player); } void BattlefieldTB::OnPlayerJoinWar(Player* player) { RemoveAurasFromPlayer(player); player->SetPvP(true); // Bonus damage buff for attackers if (player->GetTeamId() == GetAttackerTeam()) { int32 towersDestroyed = sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_TOWERS_DESTROYED, m_Map); if (towersDestroyed > 0) player->CastSpell(player, SPELL_TOWER_ATTACK_BONUS, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellMod(SPELLVALUE_AURA_STACK, towersDestroyed)); } } void BattlefieldTB::OnPlayerLeaveWar(Player* player) { RemoveAurasFromPlayer(player); } void BattlefieldTB::RemoveAurasFromPlayer(Player* player) { player->RemoveAurasDueToSpell(SPELL_TB_SLOW_FALL); player->RemoveAurasDueToSpell(SPELL_TB_VETERAN); player->RemoveAurasDueToSpell(SPELL_TOWER_ATTACK_BONUS); player->RemoveAurasDueToSpell(SPELL_TB_SPIRITUAL_IMMUNITY); } void BattlefieldTB::SaveWorldStateValues() { sWorld->setWorldState(WS_BATTLEFIELD_TB_FACTION_CONTROLLING, uint32(GetDefenderTeam())); sWorld->setWorldState(WS_BATTLEFIELD_TB_STATE_BATTLE, uint32(IsWarTime() ? 1 : 0)); sWorld->setWorldState(WS_BATTLEFIELD_TB_TIME_NEXT_BATTLE, uint32(!IsWarTime() ? m_Timer : 0)); } void BattlefieldTB::OnStartGrouping() { UpdateNPCsAndGameObjects(); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_STATE_PREPARATIONS, 1, m_Map); // Teleport players out of questing area for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team) for (auto itr = m_players[team].begin(); itr != m_players[team].end(); ++itr) if (Player* player = ObjectAccessor::FindPlayer(*itr)) if (player->GetAreaId() == TBQuestAreas[m_iCellblockRandom].entry) player->CastSpell(player, TBQuestAreas[m_iCellblockRandom].teleportSpell, true); // Should we also teleport players out of Baradin Hold underground area? } void BattlefieldTB::OnBattleStart() { SetData(BATTLEFIELD_TB_DATA_TOWERS_INTACT, uint32(3)); UpdateNPCsAndGameObjects(); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_BATTLE_END_SHOW, 1, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_BATTLE_END, GameTime::GetGameTime() + m_Timer / IN_MILLISECONDS, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_NEXT_BATTLE_SHOW, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_NEXT_BATTLE, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_ALLIANCE_ATTACKING_SHOW, GetAttackerTeam() == TEAM_ALLIANCE ? 1 : 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_HORDE_ATTACKING_SHOW, GetAttackerTeam() == TEAM_HORDE ? 1 : 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_ALLIANCE_CONTROLS_SHOW, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_HORDE_CONTROLS_SHOW, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_BUILDINGS_CAPTURED_SHOW, 1, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_BUILDINGS_CAPTURED, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TOWERS_DESTROYED_SHOW, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TOWERS_DESTROYED, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_STATE_PREPARATIONS, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_STATE_BATTLE, 1, m_Map); // Towers/spires for (uint8 i = 0; i < TB_TOWERS_COUNT; i++) { sWorldStateMgr->SetValue(TBTowers[i].wsIntact[GetDefenderTeam()], 1, m_Map); sWorldStateMgr->SetValue(TBTowers[i].wsDamaged[GetDefenderTeam()], 0, m_Map); sWorldStateMgr->SetValue(TBTowers[i].wsDestroyed, 0, m_Map); sWorldStateMgr->SetValue(TBTowers[i].wsDamaged[GetAttackerTeam()], 0, m_Map); sWorldStateMgr->SetValue(TBTowers[i].wsIntact[GetAttackerTeam()], 0, m_Map); } } void BattlefieldTB::OnBattleEnd(bool endByTimer) { if (!endByTimer) // Attackers win (but now they are defenders already) SendWarning(GetDefenderTeam() == TEAM_ALLIANCE ? TB_TEXT_FORTRESS_CAPTURE_ALLIANCE : TB_TEXT_FORTRESS_CAPTURE_HORDE); else // Defenders win SendWarning(GetDefenderTeam() == TEAM_ALLIANCE ? TB_TEXT_FORTRESS_DEFEND_ALLIANCE : TB_TEXT_FORTRESS_DEFEND_HORDE); // UpdateNPCsAndGameObjects() must be called 1 minute after battle ends m_updateObjectsTimer = 1 * MINUTE * IN_MILLISECONDS; updatedNPCAndObjects = false; // Complete quest TeamCastSpell(GetDefenderTeam(), GetDefenderTeam() == TEAM_ALLIANCE ? SPELL_VICTORY_ALLIANCE : SPELL_VICTORY_HORDE); // Rewards TeamCastSpell(GetDefenderTeam(), GetDefenderTeam() == TEAM_ALLIANCE ? SPELL_REWARD_VICTORY_ALLIANCE : SPELL_REWARD_VICTORY_HORDE); for (uint32 i = 0; i < GetData(BATTLEFIELD_TB_DATA_TOWERS_INTACT); i++) // Unsure, for each intact tower or only once for having any tower intact? TeamCastSpell(GetDefenderTeam(), SPELL_REWARD_TOWER_INTACT); TeamCastSpell(GetAttackerTeam(), SPELL_REWARD_DEFEAT); for (uint8 team = 0; team < 2; ++team) { for (auto itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr) if (Player* player = ObjectAccessor::FindPlayer(*itr)) RemoveAurasFromPlayer(player); m_PlayersInWar[team].clear(); } // Reset time warning vars warnedFiveMinutes = false; warnedTwoMinutes = false; warnedOneMinute = false; sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_BATTLE_END_SHOW, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_BATTLE_END, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_NEXT_BATTLE_SHOW, 1, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_NEXT_BATTLE, GameTime::GetGameTime() + m_NoWarBattleTime / IN_MILLISECONDS, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_ALLIANCE_ATTACKING_SHOW, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_HORDE_ATTACKING_SHOW, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_FACTION_CONTROLLING, GetDefenderTeam() + 1, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_ALLIANCE_CONTROLS_SHOW, GetDefenderTeam() == TEAM_ALLIANCE ? 1 : 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_HORDE_CONTROLS_SHOW, GetDefenderTeam() == TEAM_HORDE ? 1 : 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_KEEP_ALLIANCE, GetDefenderTeam() == TEAM_ALLIANCE ? 1 : 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_KEEP_HORDE, GetDefenderTeam() == TEAM_HORDE ? 1 : 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_BUILDINGS_CAPTURED_SHOW, 0, m_Map); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_STATE_BATTLE, 0, m_Map); } void BattlefieldTB::UpdateNPCsAndGameObjects() { for (ObjectGuid guid : BattleInactiveNPCs) if (Creature* creature = GetCreature(guid)) HideNpc(creature); for (ObjectGuid guid : BattleInactiveGOs) if (GameObject* gameobject = GetGameObject(guid)) gameobject->SetRespawnTime(RESPAWN_ONE_DAY); for (ObjectGuid guid : TemporaryNPCs) if (Creature* creature = GetCreature(guid)) creature->RemoveFromWorld(); TemporaryNPCs.clear(); for (ObjectGuid guid : TemporaryGOs) if (GameObject* gameobject = GetGameObject(guid)) gameobject->Delete(); TemporaryGOs.clear(); // Tol Barad gates - closed during warmup if (GameObject* gates = GetGameObject(TBGatesGUID)) gates->SetGoState(GetState() == BATTLEFIELD_WARMUP ? GO_STATE_READY : GO_STATE_ACTIVE); // Baradin Hold door - open when inactive if (GameObject* door = GetGameObject(TBDoorGUID)) door->SetGoState(GetState() == BATTLEFIELD_INACTIVE ? GO_STATE_ACTIVE : GO_STATE_READY); // Decide which cellblock and questgiver will be active. m_iCellblockRandom = GetState() == BATTLEFIELD_INACTIVE ? urand(0, CELLBLOCK_MAX - 1) : CELLBLOCK_NONE; // To The Hole gate if (GameObject* door = GetGameObject(m_gateToTheHoleGUID)) door->SetGoState(m_iCellblockRandom == CELLBLOCK_THE_HOLE ? GO_STATE_ACTIVE : GO_STATE_READY); // D-Block gate if (GameObject* door = GetGameObject(m_gateDBlockGUID)) door->SetGoState(m_iCellblockRandom == CELLBLOCK_D_BLOCK ? GO_STATE_ACTIVE : GO_STATE_READY); // Cursed Depths gate if (GameObject* door = GetGameObject(m_gateCursedDepthsGUID)) door->SetGoState(m_iCellblockRandom == CELLBLOCK_CURSED_DEPTHS ? GO_STATE_ACTIVE : GO_STATE_READY); if (GetState() == BATTLEFIELD_INACTIVE) { // Delete capture points for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) itr->second->DelCapturePoint(); m_capturePoints.clear(); // Create capture points for (uint8 i = 0; i < TB_BASE_COUNT; i++) { TolBaradCapturePoint* capturePoint = new TolBaradCapturePoint(this, GetDefenderTeam()); //Spawn flag pole if (GameObject* go = SpawnGameObject(TBCapturePoints[i].entryFlagPole[GetDefenderTeam()], TBCapturePoints[i].pos, TBCapturePoints[i].rot)) { go->SetGoArtKit(GetDefenderTeam() == TEAM_ALLIANCE ? TB_GO_ARTKIT_FLAG_ALLIANCE : TB_GO_ARTKIT_FLAG_HORDE); capturePoint->SetCapturePointData(go); } AddCapturePoint(capturePoint); } for (ObjectGuid guid : BattleInactiveNPCs) if (Creature* creature = GetCreature(guid)) ShowNpc(creature, true); for (ObjectGuid guid : BattleInactiveGOs) if (GameObject* gameobject = GetGameObject(guid)) gameobject->SetRespawnTime(RESPAWN_IMMEDIATELY); for (uint8 i = 0; i < TB_QUEST_INFANTRY_MAX; i++) { uint32 entry = TB_QUEST_INFANTRY[GetDefenderTeam()][urand(0,3)]; if (Creature* creature = SpawnCreature(entry, TBQuestInfantrySpawnData[i])) TemporaryNPCs.insert(creature->GetGUID()); } for (uint8 i = 0; i < TB_GUARDS_MAX; i++) if (Creature* creature = SpawnCreature(GetDefenderTeam() == TEAM_ALLIANCE ? NPC_BARADIN_GUARD : NPC_HELLSCREAMS_SENTRY, GuardNPCSpawns[i])) TemporaryNPCs.insert(creature->GetGUID()); for (uint8 i = 0; i < TB_FACTION_NPC_MAX; i++) if (Creature* creature = SpawnCreature(GetDefenderTeam() == TEAM_ALLIANCE ? FactionNPCSpawns[i].entryAlliance : FactionNPCSpawns[i].entryHorde, FactionNPCSpawns[i].pos)) TemporaryNPCs.insert(creature->GetGUID()); if (Creature* creature = SpawnCreature(RandomQuestgivers[GetDefenderTeam()][m_iCellblockRandom], RandomQuestgiverPos)) TemporaryNPCs.insert(creature->GetGUID()); // Spawn portals for (uint8 i = 0; i < TB_PORTAL_MAX; i++) if (GameObject* go = SpawnGameObject(TBPortalEntry[GetDefenderTeam()], TBPortals[i].pos, TBPortals[i].rot)) TemporaryGOs.insert(go->GetGUID()); // Update towers for (ObjectGuid guid : Towers) if (GameObject* go = GetGameObject(guid)) go->SetDestructibleState(GO_DESTRUCTIBLE_REBUILDING); } else if (GetState() == BATTLEFIELD_IN_PROGRESS) { for (uint8 i = 0; i < TB_ABANDONED_SIEGE_ENGINE_COUNT; i++) if (Creature* creature = SpawnCreature(NPC_ABANDONED_SIEGE_ENGINE, TBAbandonedSiegeEngineSpawnData[i])) TemporaryNPCs.insert(creature->GetGUID()); for (ObjectGuid guid : Towers) { if (GameObject* go = GetGameObject(guid)) { go->SetDestructibleState(GO_DESTRUCTIBLE_INTACT); go->ModifyHealth(go->GetGOValue()->Building.MaxHealth); } } } // Spawn banners for (uint8 i = 0; i < TB_BANNER_MAX; i++) if (GameObject* go = SpawnGameObject(TBBannerEntry[GetDefenderTeam()], TBBanners[i].pos, TBBanners[i].rot)) TemporaryGOs.insert(go->GetGUID()); // Set graveyard controls for (uint8 i = 0; i < BATTLEFIELD_TB_GRAVEYARD_MAX; i++) if (BfGraveyard* graveyard = GetGraveyardById(i)) graveyard->GiveControlTo(!IsWarTime() || TBGraveyards[i].defenderControls ? GetDefenderTeam() : GetAttackerTeam()); } void BattlefieldTB::OnCreatureCreate(Creature* creature) { switch (creature->GetEntry()) { // Store NPCs that need visibility toggling case NPC_TOLBARAD_CAPTIVE_SPIRIT: case NPC_TOLBARAD_CELLBLOCK_OOZE: case NPC_TOLBARAD_ARCHMAGE_GALUS: case NPC_TOLBARAD_GHASTLY_CONVICT: case NPC_TOLBARAD_SHIVARRA_DESTROYER: case NPC_TOLBARAD_CELL_WATCHER: case NPC_TOLBARAD_SVARNOS: case NPC_TOLBARAD_JAILED_WRATHGUARD: case NPC_TOLBARAD_IMPRISONED_IMP: case NPC_TOLBARAD_WARDEN_SILVA: case NPC_TOLBARAD_WARDEN_GUARD: case NPC_TOLBARAD_IMPRISONED_WORKER: case NPC_TOLBARAD_EXILED_MAGE: case NPC_CROCOLISK: case NPC_PROBLIM: BattleInactiveNPCs.insert(creature->GetGUID()); if (GetState() == BATTLEFIELD_WARMUP) // If battle is about to start, we must hide these. HideNpc(creature); break; case NPC_ABANDONED_SIEGE_ENGINE: creature->SetFaction(TBFactions[GetDefenderTeam()]); creature->CastSpell(creature, SPELL_THICK_LAYER_OF_RUST, true); break; case NPC_SIEGE_ENGINE_TURRET: if (Unit* vehiclebase = creature->GetCharmerOrOwner()->GetVehicleBase()) creature->EnterVehicle(vehiclebase); break; case NPC_TOWER_RANGE_FINDER: creature->CastSpell(creature, SPELL_TOWER_RANGE_FINDER_PERIODIC, true); break; case NPC_TB_GY_SPIRIT_BARADIN_HOLD_A: case NPC_TB_GY_SPIRIT_BARADIN_HOLD_H: case NPC_TB_GY_SPIRIT_IRONCLAD_GARRISON_A: case NPC_TB_GY_SPIRIT_WARDENS_VIGIL_A: case NPC_TB_GY_SPIRIT_EAST_SPIRE_A: case NPC_TB_GY_SPIRIT_SOUTH_SPIRE_A: case NPC_TB_GY_SPIRIT_WEST_SPIRE_A: case NPC_TB_GY_SPIRIT_SLAGWORKS_A: case NPC_TB_GY_SPIRIT_IRONCLAD_GARRISON_H: case NPC_TB_GY_SPIRIT_WARDENS_VIGIL_H: case NPC_TB_GY_SPIRIT_SLAGWORKS_H: case NPC_TB_GY_SPIRIT_WEST_SPIRE_H: case NPC_TB_GY_SPIRIT_EAST_SPIRE_H: case NPC_TB_GY_SPIRIT_SOUTH_SPIRE_H: creature->CastSpell(creature, SPELL_TB_SPIRITUAL_IMMUNITY, true); creature->CastSpell(creature, SPELL_TB_SPIRIT_HEAL_CHANNEL, true); break; default: break; } } void BattlefieldTB::OnGameObjectCreate(GameObject* go) { switch (go->GetEntry()) { case GO_TOLBARAD_GATES: TBGatesGUID = go->GetGUID(); go->SetGoState(GetState() == BATTLEFIELD_WARMUP ? GO_STATE_READY : GO_STATE_ACTIVE); break; case GO_TOLBARAD_DOOR: TBDoorGUID = go->GetGUID(); go->SetGoState(GetState() == BATTLEFIELD_INACTIVE ? GO_STATE_ACTIVE : GO_STATE_READY); break; case GO_GATE_TO_THE_HOLE: m_gateToTheHoleGUID = go->GetGUID(); go->SetGoState(m_iCellblockRandom == CELLBLOCK_THE_HOLE ? GO_STATE_ACTIVE : GO_STATE_READY); break; case GO_GATE_D_BLOCK: m_gateDBlockGUID = go->GetGUID(); go->SetGoState(m_iCellblockRandom == CELLBLOCK_D_BLOCK ? GO_STATE_ACTIVE : GO_STATE_READY); break; case GO_CURSED_DEPTHS_GATE: m_gateCursedDepthsGUID = go->GetGUID(); go->SetGoState(m_iCellblockRandom == CELLBLOCK_CURSED_DEPTHS ? GO_STATE_ACTIVE : GO_STATE_READY); break; case GO_CRATE_OF_CELLBLOCK_RATIONS: case GO_CURSED_SHACKLES: case GO_DUSTY_PRISON_JOURNAL: case GO_TB_MEETING_STONE: case GO_TB_INSTANCE_VISUAL_1: case GO_TB_INSTANCE_VISUAL_2: case GO_TB_INSTANCE_VISUAL_3: case GO_TB_INSTANCE_VISUAL_4: BattleInactiveGOs.insert(go->GetGUID()); if (GetState() == BATTLEFIELD_WARMUP) // If battle is about to start, we must hide these. go->SetRespawnTime(RESPAWN_ONE_DAY); break; default: break; } } void BattlefieldTB::ProcessEvent(WorldObject* obj, uint32 eventId, WorldObject* /*invoker*/) { if (!IsWarTime()) return; if (eventId == EVENT_COUNT_CAPTURED_BASE) { UpdateCapturedBaseCount(); return; } if (!obj) return; GameObject* go = obj->ToGameObject(); if (!go) return; TBTowerId towerId; switch (go->GetEntry()) { case GO_WEST_SPIRE: towerId = TB_TOWER_WEST_SPIRE; break; case GO_EAST_SPIRE: towerId = TB_TOWER_EAST_SPIRE; break; case GO_SOUTH_SPIRE: towerId = TB_TOWER_SOUTH_SPIRE; break; default: return; } if (go->GetDestructibleState() == GO_DESTRUCTIBLE_DAMAGED) TowerDamaged(towerId); else if (go->GetDestructibleState() == GO_DESTRUCTIBLE_DESTROYED) TowerDestroyed(towerId); } void BattlefieldTB::TowerDamaged(TBTowerId tbTowerId) { if (!IsWarTime()) return; SendWarning(TBTowers[tbTowerId].textDamaged); SetData(BATTLEFIELD_TB_DATA_TOWERS_INTACT, GetData(BATTLEFIELD_TB_DATA_TOWERS_INTACT) - 1); sWorldStateMgr->SetValue(TBTowers[tbTowerId].wsIntact[GetDefenderTeam()], 0, m_Map); sWorldStateMgr->SetValue(TBTowers[tbTowerId].wsDamaged[GetDefenderTeam()], 1, m_Map); TeamCastSpell(GetAttackerTeam(), SPELL_REWARD_TOWER_DAMAGED); } void BattlefieldTB::TowerDestroyed(TBTowerId tbTowerId) { if (!IsWarTime()) return; // Add 5 minute bonus time m_Timer += m_BonusTime; sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TIME_BATTLE_END, GameTime::GetGameTime() + m_Timer / IN_MILLISECONDS, m_Map); SendWarning(TBTowers[tbTowerId].textDestroyed); sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TOWERS_DESTROYED_SHOW, 1, m_Map); int32 towersDestroyed = sWorldStateMgr->GetValue(WS_BATTLEFIELD_TB_TOWERS_DESTROYED, m_Map) + 1; sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_TOWERS_DESTROYED, towersDestroyed, m_Map); sWorldStateMgr->SetValue(TBTowers[tbTowerId].wsDamaged[GetDefenderTeam()], 0, m_Map); sWorldStateMgr->SetValue(TBTowers[tbTowerId].wsDestroyed, 1, m_Map); // Attack bonus buff for (ObjectGuid const& guid : m_PlayersInWar[GetAttackerTeam()]) if (Player* player = ObjectAccessor::FindPlayer(guid)) player->CastSpell(player, SPELL_TOWER_ATTACK_BONUS, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellMod(SPELLVALUE_AURA_STACK, towersDestroyed)); // Honor reward TeamCastSpell(GetAttackerTeam(), SPELL_REWARD_TOWER_DESTROYED); } void BattlefieldTB::UpdateCapturedBaseCount() { uint32 numCapturedBases = 0; // How many bases attacker has captured for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr) if (itr->second->GetTeamId() == GetAttackerTeam()) numCapturedBases += 1; sWorldStateMgr->SetValue(WS_BATTLEFIELD_TB_BUILDINGS_CAPTURED, numCapturedBases, m_Map); // Check if attackers won if (numCapturedBases == TB_BASE_COUNT) EndBattle(false); } // Called when player kill a unit in wg zone void BattlefieldTB::HandleKill(Player* killer, Unit* victim) { if (killer == victim || victim->GetTypeId() != TYPEID_PLAYER) return; TeamId killerTeam = killer->GetTeamId(); for (auto itr = m_PlayersInWar[killerTeam].begin(); itr != m_PlayersInWar[killerTeam].end(); ++itr) if (Player* player = ObjectAccessor::FindPlayer(*itr)) if (player->GetDistance2d(killer) < 40.0f) PromotePlayer(player); } void BattlefieldTB::PromotePlayer(Player* killer) { if (!m_isActive || killer->HasAura(SPELL_TB_VETERAN)) return; killer->CastSpell(killer, SPELL_TB_VETERAN, true); } TolBaradCapturePoint::TolBaradCapturePoint(BattlefieldTB* battlefield, TeamId teamInControl) : BfCapturePoint(battlefield) { m_Bf = battlefield; m_team = teamInControl; m_value = teamInControl == TEAM_ALLIANCE ? m_maxValue : -m_maxValue; m_State = teamInControl == TEAM_ALLIANCE ? BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE : BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE; } void TolBaradCapturePoint::SendChangePhase() { if (m_OldState == m_State) return; // Find out index uint8 iBase = TB_BASE_COUNT; for (uint8 i = 0; i < TB_BASE_COUNT; i++) if (GetCapturePointEntry() == TBCapturePoints[i].entryFlagPole[m_Bf->GetDefenderTeam()]) iBase = i; if (iBase == TB_BASE_COUNT) return; // Turn off previous world state icon switch (m_OldState) { case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE: case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE: sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsControlled[GetTeamId()], 0, m_Bf->GetMap()); break; case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE: case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE: sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_ALLIANCE], 0, m_Bf->GetMap()); break; case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE: case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE: sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_HORDE], 0, m_Bf->GetMap()); break; default: break; } // Turn on new world state icon and send warning switch (m_State) { case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE: case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE: m_Bf->SendWarning(TBCapturePoints[iBase].textGained[GetTeamId()]); sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsControlled[GetTeamId()], 1, m_Bf->GetMap()); GetCapturePointGo()->SetGoArtKit(GetTeamId() == TEAM_ALLIANCE ? TB_GO_ARTKIT_FLAG_ALLIANCE : TB_GO_ARTKIT_FLAG_HORDE); break; case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE: m_Bf->SendWarning(TBCapturePoints[iBase].textLost[TEAM_HORDE]); [[fallthrough]]; case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE: sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_ALLIANCE], 1, m_Bf->GetMap()); GetCapturePointGo()->SetGoArtKit(TB_GO_ARTKIT_FLAG_NONE); break; case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE: m_Bf->SendWarning(TBCapturePoints[iBase].textLost[TEAM_ALLIANCE]); [[fallthrough]]; case BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE: sWorldStateMgr->SetValue(TBCapturePoints[iBase].wsCapturing[TEAM_HORDE], 1, m_Bf->GetMap()); GetCapturePointGo()->SetGoArtKit(TB_GO_ARTKIT_FLAG_NONE); break; default: break; } // Update counter m_Bf->ProcessEvent(nullptr, EVENT_COUNT_CAPTURED_BASE, nullptr); } class Battlefield_tol_barad : public BattlefieldScript { public: Battlefield_tol_barad() : BattlefieldScript("battlefield_tb") { } Battlefield* GetBattlefield() const override { return new BattlefieldTB(); } }; void AddSC_BF_tol_barad() { new Battlefield_tol_barad(); }