diff --git a/src/game/OutdoorPvP/OutdoorPvPMgr.cpp b/src/game/OutdoorPvP/OutdoorPvPMgr.cpp index 6c640cbb6..ee5a7fa65 100644 --- a/src/game/OutdoorPvP/OutdoorPvPMgr.cpp +++ b/src/game/OutdoorPvP/OutdoorPvPMgr.cpp @@ -52,6 +52,7 @@ void OutdoorPvPMgr::InitOutdoorPvP() m_scripts[OPVP_ID_SI] = new OutdoorPvPSI(); m_scripts[OPVP_ID_EP] = new OutdoorPvPEP(); m_scripts[OPVP_ID_HP] = new OutdoorPvPHP(); + m_scripts[OPVP_ID_ZM] = new OutdoorPvPZM(); sLog.outString(); sLog.outString(">> Loaded %u Outdoor PvP zones", MAX_OPVP_ID); diff --git a/src/game/OutdoorPvP/OutdoorPvPZM.cpp b/src/game/OutdoorPvP/OutdoorPvPZM.cpp index b166faf81..354676de4 100644 --- a/src/game/OutdoorPvP/OutdoorPvPZM.cpp +++ b/src/game/OutdoorPvP/OutdoorPvPZM.cpp @@ -15,3 +15,389 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "OutdoorPvPZM.h" +#include "WorldPacket.h" +#include "../World.h" +#include "../ObjectMgr.h" +#include "../Object.h" +#include "../Creature.h" +#include "../GameObject.h" +#include "../Player.h" + +OutdoorPvPZM::OutdoorPvPZM() : OutdoorPvP(), + m_graveyardOwner(TEAM_NONE), + m_graveyardWorldState(WORLD_STATE_ZM_GRAVEYARD_NEUTRAL), + m_scoutWorldStateAlliance(WORLD_STATE_ZM_FLAG_NOT_READY_ALLIANCE), + m_scoutWorldStateHorde(WORLD_STATE_ZM_FLAG_NOT_READY_HORDE), + m_towersAlliance(0), + m_towersHorde(0) +{ + // init world states + m_towerWorldState[0] = WORLD_STATE_ZM_BEACON_EAST_UI_NEUTRAL; + m_towerWorldState[1] = WORLD_STATE_ZM_BEACON_WEST_UI_NEUTRAL; + m_towerMapState[0] = WORLD_STATE_ZM_BEACON_EAST_NEUTRAL; + m_towerMapState[1] = WORLD_STATE_ZM_BEACON_WEST_NEUTRAL; + + for (uint8 i = 0; i < MAX_ZM_TOWERS; ++i) + m_towerOwner[i] = TEAM_NONE; + + // initially set graveyard owner to neither faction + sObjectMgr.SetGraveYardLinkTeam(GRAVEYARD_ID_TWIN_SPIRE, GRAVEYARD_ZONE_TWIN_SPIRE, TEAM_INVALID); +} + +void OutdoorPvPZM::FillInitialWorldStates(WorldPacket& data, uint32& count) +{ + FillInitialWorldState(data, count, m_scoutWorldStateAlliance, WORLD_STATE_ADD); + FillInitialWorldState(data, count, m_scoutWorldStateHorde, WORLD_STATE_ADD); + FillInitialWorldState(data, count, m_graveyardWorldState, WORLD_STATE_ADD); + + for (uint8 i = 0; i < MAX_ZM_TOWERS; ++i) + { + FillInitialWorldState(data, count, m_towerWorldState[i], WORLD_STATE_ADD); + FillInitialWorldState(data, count, m_towerMapState[i], WORLD_STATE_ADD); + } +} + +void OutdoorPvPZM::SendRemoveWorldStates(Player* player) +{ + player->SendUpdateWorldState(m_scoutWorldStateAlliance, WORLD_STATE_REMOVE); + player->SendUpdateWorldState(m_scoutWorldStateHorde, WORLD_STATE_REMOVE); + player->SendUpdateWorldState(m_graveyardWorldState, WORLD_STATE_REMOVE); + + for (uint8 i = 0; i < MAX_ZM_TOWERS; ++i) + { + player->SendUpdateWorldState(m_towerWorldState[i], WORLD_STATE_REMOVE); + player->SendUpdateWorldState(m_towerMapState[i], WORLD_STATE_REMOVE); + } +} + +void OutdoorPvPZM::HandlePlayerEnterZone(Player* player, bool isMainZone) +{ + OutdoorPvP::HandlePlayerEnterZone(player, isMainZone); + + // remove the buff from the player first; Sometimes on relog players still have the aura + player->RemoveAurasDueToSpell(SPELL_TWIN_SPIRE_BLESSING); + + // cast buff the the player which enters the zone + if (player->GetTeam() == m_graveyardOwner) + player->CastSpell(player, SPELL_TWIN_SPIRE_BLESSING, true); +} + +void OutdoorPvPZM::HandlePlayerLeaveZone(Player* player, bool isMainZone) +{ + // remove the buff from the player + player->RemoveAurasDueToSpell(SPELL_TWIN_SPIRE_BLESSING); + + OutdoorPvP::HandlePlayerLeaveZone(player, isMainZone); +} + +void OutdoorPvPZM::HandleCreatureCreate(Creature* creature) +{ + switch (creature->GetEntry()) + { + case NPC_PVP_BEAM_RED: + if (creature->GetPositionY() < 7000.0f) // East Beam + m_beamTowerRed[0] = creature->GetObjectGuid(); + else if (creature->GetPositionY() < 7300.0f) // Center Beam + m_beamGraveyardRed = creature->GetObjectGuid(); + else // West Beam + m_beamTowerRed[1] = creature->GetObjectGuid(); + break; + case NPC_PVP_BEAM_BLUE: + if (creature->GetPositionY() < 7000.0f) // East Beam + m_beamTowerBlue[0] = creature->GetObjectGuid(); + else if (creature->GetPositionY() < 7300.0f) // Center Beam + m_beamGraveyardBlue = creature->GetObjectGuid(); + else // West Beam + m_beamTowerBlue[1] = creature->GetObjectGuid(); + break; + } +} + +void OutdoorPvPZM::HandleGameObjectCreate(GameObject* go) +{ + switch (go->GetEntry()) + { + case GO_ZANGA_BANNER_EAST: + m_towerBanners[0] = go->GetObjectGuid(); + break; + case GO_ZANGA_BANNER_WEST: + m_towerBanners[1] = go->GetObjectGuid(); + break; + case GO_ZANGA_BANNER_CENTER_ALLIANCE: + m_graveyardBannerAlliance = go->GetObjectGuid(); + break; + case GO_ZANGA_BANNER_CENTER_HORDE: + m_graveyardBannerHorde = go->GetObjectGuid(); + break; + case GO_ZANGA_BANNER_CENTER_NEUTRAL: + m_graveyardBannerNeutral = go->GetObjectGuid(); + break; + } +} + +// Cast player spell on opponent kill +void OutdoorPvPZM::HandlePlayerKillInsideArea(Player* player, Unit* /*victim*/) +{ + for (uint8 i = 0; i < MAX_ZM_TOWERS; ++i) + { + if (GameObject* capturePoint = player->GetMap()->GetGameObject(m_towerBanners[i])) + { + // check capture point range + GameObjectInfo const* info = capturePoint->GetGOInfo(); + if (info && player->IsWithinDistInMap(capturePoint, info->capturePoint.radius)) + { + // check capture point team + if (player->GetTeam() == m_towerOwner[i]) + player->CastSpell(player, player->GetTeam() == ALLIANCE ? SPELL_ZANGA_TOWER_TOKEN_ALLIANCE : SPELL_ZANGA_TOWER_TOKEN_HORDE, true); + + return; + } + } + } +} + +// process the capture events +bool OutdoorPvPZM::HandleEvent(uint32 eventId, GameObject* go) +{ + for (uint8 i = 0; i < MAX_ZM_TOWERS; ++i) + { + if (zangarmarshTowers[i] == go->GetEntry()) + { + for (uint8 j = 0; j < 4; ++j) + { + if (zangarmarshTowerEvents[i][j].eventEntry == eventId) + { + // prevent processing if the owner did not change (happens if progress event is called after contest event) + if (zangarmarshTowerEvents[i][j].team != m_towerOwner[i]) + { + if (zangarmarshTowerEvents[i][j].defenseMessage) + sWorld.SendDefenseMessage(ZONE_ID_ZANGARMARSH, zangarmarshTowerEvents[i][j].defenseMessage); + + return ProcessCaptureEvent(go, i, zangarmarshTowerEvents[i][j].team, zangarmarshTowerEvents[i][j].worldState, zangarmarshTowerEvents[i][j].mapState); + } + // no need to iterate other events or towers + return false; + } + } + // no need to iterate other towers + return false; + } + } + + return false; +} + +bool OutdoorPvPZM::ProcessCaptureEvent(GameObject* go, uint32 towerId, Team team, uint32 newWorldState, uint32 newMapState) +{ + if (team == ALLIANCE) + { + // update counter + SetBeaconArtKit(go, m_beamTowerBlue[towerId], SPELL_BEAM_BLUE); + ++m_towersAlliance; + + if (m_towersAlliance == MAX_ZM_TOWERS) + { + // Send this defense message before updating scout state as this sends another + sWorld.SendDefenseMessage(ZONE_ID_ZANGARMARSH, LANG_OPVP_ZM_CAPTURE_BOTH_BEACONS_A); + + // only add flag to scouts if team does not have captured graveyard already + if (m_graveyardOwner != ALLIANCE) + UpdateScoutState(ALLIANCE, true); + } + } + else if (team == HORDE) + { + // update counter + SetBeaconArtKit(go, m_beamTowerRed[towerId], SPELL_BEAM_RED); + ++m_towersHorde; + + if (m_towersHorde == MAX_ZM_TOWERS) + { + // Send this defense message before updating scout state as this sends another + sWorld.SendDefenseMessage(ZONE_ID_ZANGARMARSH, LANG_OPVP_ZM_CAPTURE_BOTH_BEACONS_H); + + // only add flag to scouts if team does not already have captured graveyard + if (m_graveyardOwner != HORDE) + UpdateScoutState(HORDE, true); + } + } + else + { + if (m_towerOwner[towerId] == ALLIANCE) + { + SetBeaconArtKit(go, m_beamTowerBlue[towerId], 0); + + // only remove flag from scouts if team does not already have captured graveyard + if (m_towersAlliance == MAX_ZM_TOWERS && m_graveyardOwner != ALLIANCE) + UpdateScoutState(ALLIANCE, false); + + // update counter + --m_towersAlliance; + } + else + { + SetBeaconArtKit(go, m_beamTowerRed[towerId], 0); + + // only remove flag from scouts if team does not already have captured graveyard + if (m_towersHorde == MAX_ZM_TOWERS && m_graveyardOwner != HORDE) + UpdateScoutState(HORDE, false); + + // update counter + --m_towersHorde; + } + } + + // update tower state + SendUpdateWorldState(m_towerWorldState[towerId], WORLD_STATE_REMOVE); + m_towerWorldState[towerId] = newWorldState; + SendUpdateWorldState(m_towerWorldState[towerId], WORLD_STATE_ADD); + + SendUpdateWorldState(m_towerMapState[towerId], WORLD_STATE_REMOVE); + m_towerMapState[towerId] = newMapState; + SendUpdateWorldState(m_towerMapState[towerId], WORLD_STATE_ADD);; + + // update capture point owner + m_towerOwner[towerId] = team; + + // the are no DB exceptions in this case + return true; +} + +// Handle scout activation, when both beacons are captured +void OutdoorPvPZM::UpdateScoutState(Team team, bool spawned) +{ + if (team == ALLIANCE) + { + SendUpdateWorldState(m_scoutWorldStateAlliance, WORLD_STATE_REMOVE); + m_scoutWorldStateAlliance = spawned ? WORLD_STATE_ZM_FLAG_READY_ALLIANCE : WORLD_STATE_ZM_FLAG_NOT_READY_ALLIANCE; + SendUpdateWorldState(m_scoutWorldStateAlliance, WORLD_STATE_ADD); + + if (spawned) + sWorld.SendDefenseMessage(ZONE_ID_ZANGARMARSH, LANG_OPVP_ZM_SPAWN_FIELD_SCOUT_A); + } + else + { + SendUpdateWorldState(m_scoutWorldStateHorde, WORLD_STATE_REMOVE); + m_scoutWorldStateHorde = spawned ? WORLD_STATE_ZM_FLAG_READY_HORDE : WORLD_STATE_ZM_FLAG_NOT_READY_HORDE; + SendUpdateWorldState(m_scoutWorldStateHorde, WORLD_STATE_ADD); + + if (spawned) + sWorld.SendDefenseMessage(ZONE_ID_ZANGARMARSH, LANG_OPVP_ZM_SPAWN_FIELD_SCOUT_H); + } +} + +// Handle the graveyard banner use +bool OutdoorPvPZM::HandleGameObjectUse(Player* player, GameObject* go) +{ + Team team = player->GetTeam(); + + switch (go->GetEntry()) + { + case GO_ZANGA_BANNER_CENTER_NEUTRAL: + break; + case GO_ZANGA_BANNER_CENTER_ALLIANCE: + if (team == ALLIANCE || !player->HasAura(SPELL_BATTLE_STANDARD_HORDE)) + return false; + break; + case GO_ZANGA_BANNER_CENTER_HORDE: + if (team == HORDE || !player->HasAura(SPELL_BATTLE_STANDARD_ALLIANCE)) + return false; + break; + default: + return false; + } + + // disable old banners - note the alliance and horde banners can despawn by self + if (m_graveyardOwner == ALLIANCE) + { + //RespawnGO(go, m_graveyardBannerAlliance, false); + SetBeaconArtKit(go, m_beamGraveyardBlue, 0); + } + else if (m_graveyardOwner == HORDE) + { + //RespawnGO(go, m_graveyardBannerHorde, false); + SetBeaconArtKit(go, m_beamGraveyardRed, 0); + } + else + RespawnGO(go, m_graveyardBannerNeutral, false); + + if (team == ALLIANCE) + { + // change banners + RespawnGO(go, m_graveyardBannerAlliance, true); + SetBeaconArtKit(go, m_beamGraveyardBlue, SPELL_BEAM_BLUE); + + // update world state + SendUpdateWorldState(m_graveyardWorldState, WORLD_STATE_REMOVE); + m_graveyardWorldState = WORLD_STATE_ZM_GRAVEYARD_ALLIANCE; + SendUpdateWorldState(m_graveyardWorldState, WORLD_STATE_ADD); + + // remove player flag aura + player->RemoveAurasDueToSpell(SPELL_BATTLE_STANDARD_ALLIANCE); + + // send defense message + sWorld.SendDefenseMessage(ZONE_ID_ZANGARMARSH, LANG_OPVP_ZM_CAPTURE_GRAVEYARD_A); + } + else + { + // change banners + RespawnGO(go, m_graveyardBannerHorde, true); + SetBeaconArtKit(go, m_beamGraveyardRed, SPELL_BEAM_RED); + + // update world state + SendUpdateWorldState(m_graveyardWorldState, WORLD_STATE_REMOVE); + m_graveyardWorldState = WORLD_STATE_ZM_GRAVEYARD_HORDE; + SendUpdateWorldState(m_graveyardWorldState, WORLD_STATE_ADD); + + // remove player flag aura + player->RemoveAurasDueToSpell(SPELL_BATTLE_STANDARD_HORDE); + + // send defense message + sWorld.SendDefenseMessage(ZONE_ID_ZANGARMARSH, LANG_OPVP_ZM_CAPTURE_GRAVEYARD_H); + } + + // change the graveyard link + sObjectMgr.SetGraveYardLinkTeam(GRAVEYARD_ID_TWIN_SPIRE, GRAVEYARD_ZONE_TWIN_SPIRE, team); + + // apply zone buff + if (m_graveyardOwner != TEAM_NONE) + BuffTeam(m_graveyardOwner, SPELL_TWIN_SPIRE_BLESSING, true); + BuffTeam(team, SPELL_TWIN_SPIRE_BLESSING); + + // reset scout so that team cannot take flag + UpdateScoutState(team, false); + + // update graveyard owner + m_graveyardOwner = team; + + return false; +} + +// ToDo: Handle the case when the player drops the flag +//bool OutdoorPvPZM::HandleDropFlag(Player* player, uint32 spellId) +//{ +// if (spellId == SPELL_BATTLE_STANDARD_HORDE || spellId == SPELL_BATTLE_STANDARD_ALLIANCE) +// { +// // ToDo: implement this when the scout DB conditions are implemented +// // The scouts gossip options should check a DB condition if the gossip is pvp available +// // The idea is to set the Outdoor PvP condition to false on flag take - this will allow only one player to use the flag +// // on flag drop the condition can be set back to true if necessary, so the players can retake the flag +// return true; +// } +// +// return false; +//} + +// Handle the ZM beacons - this is done by npcs which have certain auras +void OutdoorPvPZM::SetBeaconArtKit(const WorldObject* objRef, ObjectGuid creatureGuid, uint32 auraId) +{ + if (Creature* beam = objRef->GetMap()->GetCreature(creatureGuid)) + { + if (auraId) + beam->CastSpell(beam, auraId, true); + else + beam->RemoveAllAuras(); + } +} diff --git a/src/game/OutdoorPvP/OutdoorPvPZM.h b/src/game/OutdoorPvP/OutdoorPvPZM.h index f5aac6eda..d0e970ade 100644 --- a/src/game/OutdoorPvP/OutdoorPvPZM.h +++ b/src/game/OutdoorPvP/OutdoorPvPZM.h @@ -19,4 +19,165 @@ #ifndef WORLD_PVP_ZM #define WORLD_PVP_ZM +#include "Common.h" +#include "OutdoorPvP.h" +#include "../Language.h" + +enum +{ + MAX_ZM_TOWERS = 2, + + // npcs + //NPC_ALLIANCE_FIELD_SCOUT = 18581, + //NPC_HORDE_FIELD_SCOUT = 18564, + + // these 2 npcs act as an artkit + NPC_PVP_BEAM_RED = 18757, + NPC_PVP_BEAM_BLUE = 18759, + + // gameobjects + GO_ZANGA_BANNER_WEST = 182522, + GO_ZANGA_BANNER_EAST = 182523, + GO_ZANGA_BANNER_CENTER_ALLIANCE = 182527, + GO_ZANGA_BANNER_CENTER_HORDE = 182528, + GO_ZANGA_BANNER_CENTER_NEUTRAL = 182529, + + // spells + SPELL_TWIN_SPIRE_BLESSING = 33779, + SPELL_BATTLE_STANDARD_ALLIANCE = 32430, + SPELL_BATTLE_STANDARD_HORDE = 32431, + + SPELL_ZANGA_TOWER_TOKEN_ALLIANCE = 32155, + SPELL_ZANGA_TOWER_TOKEN_HORDE = 32158, + + SPELL_BEAM_RED = 32839, + SPELL_BEAM_BLUE = 32840, + + // misc + GRAVEYARD_ID_TWIN_SPIRE = 969, + GRAVEYARD_ZONE_TWIN_SPIRE = 3521, + + // events + //EVENT_EAST_BEACON_CONTEST_ALLIANCE = 11816, + //EVENT_EAST_BEACON_CONTEST_HORDE = 11817, + EVENT_EAST_BEACON_PROGRESS_ALLIANCE = 11807, + EVENT_EAST_BEACON_PROGRESS_HORDE = 11806, + EVENT_EAST_BEACON_NEUTRAL_ALLIANCE = 11814, + EVENT_EAST_BEACON_NEUTRAL_HORDE = 11815, + + //EVENT_WEST_BEACON_CONTEST_ALLIANCE = 11813, + //EVENT_WEST_BEACON_CONTEST_HORDE = 11812, + EVENT_WEST_BEACON_PROGRESS_ALLIANCE = 11805, + EVENT_WEST_BEACON_PROGRESS_HORDE = 11804, + EVENT_WEST_BEACON_NEUTRAL_ALLIANCE = 11808, + EVENT_WEST_BEACON_NEUTRAL_HORDE = 11809, + + // world states + WORLD_STATE_ZM_BEACON_EAST_UI_ALLIANCE = 2558, + WORLD_STATE_ZM_BEACON_EAST_UI_HORDE = 2559, + WORLD_STATE_ZM_BEACON_EAST_UI_NEUTRAL = 2560, + + WORLD_STATE_ZM_BEACON_WEST_UI_ALLIANCE = 2555, + WORLD_STATE_ZM_BEACON_WEST_UI_HORDE = 2556, + WORLD_STATE_ZM_BEACON_WEST_UI_NEUTRAL = 2557, + + WORLD_STATE_ZM_BEACON_EAST_ALLIANCE = 2650, + WORLD_STATE_ZM_BEACON_EAST_HORDE = 2651, + WORLD_STATE_ZM_BEACON_EAST_NEUTRAL = 2652, + + WORLD_STATE_ZM_BEACON_WEST_ALLIANCE = 2644, + WORLD_STATE_ZM_BEACON_WEST_HORDE = 2645, + WORLD_STATE_ZM_BEACON_WEST_NEUTRAL = 2646, + + WORLD_STATE_ZM_GRAVEYARD_ALLIANCE = 2648, + WORLD_STATE_ZM_GRAVEYARD_HORDE = 2649, + WORLD_STATE_ZM_GRAVEYARD_NEUTRAL = 2647, + + WORLD_STATE_ZM_FLAG_READY_HORDE = 2658, + WORLD_STATE_ZM_FLAG_NOT_READY_HORDE = 2657, + WORLD_STATE_ZM_FLAG_READY_ALLIANCE = 2655, + WORLD_STATE_ZM_FLAG_NOT_READY_ALLIANCE = 2656 + + //WORLD_STATE_ZM_UNK = 2653 +}; + +struct ZangarmarshTowerEvent +{ + uint32 eventEntry; + Team team; + uint32 defenseMessage; + uint32 worldState; + uint32 mapState; +}; + +static const ZangarmarshTowerEvent zangarmarshTowerEvents[MAX_ZM_TOWERS][4] = +{ + { + {EVENT_EAST_BEACON_PROGRESS_ALLIANCE, ALLIANCE, LANG_OPVP_ZM_CAPTURE_EAST_BEACON_A, WORLD_STATE_ZM_BEACON_EAST_UI_ALLIANCE, WORLD_STATE_ZM_BEACON_EAST_ALLIANCE}, + {EVENT_EAST_BEACON_PROGRESS_HORDE, HORDE, LANG_OPVP_ZM_CAPTURE_EAST_BEACON_H, WORLD_STATE_ZM_BEACON_EAST_UI_HORDE, WORLD_STATE_ZM_BEACON_EAST_HORDE}, + {EVENT_EAST_BEACON_NEUTRAL_HORDE, TEAM_NONE, 0, WORLD_STATE_ZM_BEACON_EAST_UI_NEUTRAL, WORLD_STATE_ZM_BEACON_EAST_NEUTRAL}, + {EVENT_EAST_BEACON_NEUTRAL_ALLIANCE, TEAM_NONE, 0, WORLD_STATE_ZM_BEACON_EAST_UI_NEUTRAL, WORLD_STATE_ZM_BEACON_EAST_NEUTRAL}, + }, + { + {EVENT_WEST_BEACON_PROGRESS_ALLIANCE, ALLIANCE, LANG_OPVP_ZM_CAPTURE_WEST_BEACON_A, WORLD_STATE_ZM_BEACON_WEST_UI_ALLIANCE, WORLD_STATE_ZM_BEACON_WEST_ALLIANCE}, + {EVENT_WEST_BEACON_PROGRESS_HORDE, HORDE, LANG_OPVP_ZM_CAPTURE_WEST_BEACON_H, WORLD_STATE_ZM_BEACON_WEST_UI_HORDE, WORLD_STATE_ZM_BEACON_WEST_HORDE}, + {EVENT_WEST_BEACON_NEUTRAL_HORDE, TEAM_NONE, 0, WORLD_STATE_ZM_BEACON_WEST_UI_NEUTRAL, WORLD_STATE_ZM_BEACON_WEST_NEUTRAL}, + {EVENT_WEST_BEACON_NEUTRAL_ALLIANCE, TEAM_NONE, 0, WORLD_STATE_ZM_BEACON_WEST_UI_NEUTRAL, WORLD_STATE_ZM_BEACON_WEST_NEUTRAL}, + }, +}; + +static const uint32 zangarmarshTowers[MAX_ZM_TOWERS] = {GO_ZANGA_BANNER_EAST, GO_ZANGA_BANNER_WEST}; + +class OutdoorPvPZM : public OutdoorPvP +{ + public: + OutdoorPvPZM(); + + void HandlePlayerEnterZone(Player* player, bool isMainZone) override; + void HandlePlayerLeaveZone(Player* player, bool isMainZone) override; + void FillInitialWorldStates(WorldPacket& data, uint32& count) override; + void SendRemoveWorldStates(Player* player) override; + + bool HandleEvent(uint32 eventId, GameObject* go) override; + + void HandleCreatureCreate(Creature* creature) override; + void HandleGameObjectCreate(GameObject* go) override; + + void HandlePlayerKillInsideArea(Player* player, Unit* victim) override; + bool HandleGameObjectUse(Player* player, GameObject* go) override; + //bool HandleDropFlag(Player* player, uint32 spellId) override; + + private: + // process capture events + bool ProcessCaptureEvent(GameObject* go, uint32 towerId, Team team, uint32 newWorldState, uint32 newMapState); + + // handles scout world states + void UpdateScoutState(Team team, bool spawned); + + // respawn npcs which act as an artkit visual + void SetBeaconArtKit(const WorldObject* objRef, ObjectGuid creatureGuid, uint32 auraId); + + uint32 m_towerWorldState[MAX_ZM_TOWERS]; + uint32 m_towerMapState[MAX_ZM_TOWERS]; + + Team m_towerOwner[MAX_ZM_TOWERS]; + Team m_graveyardOwner; + + uint32 m_graveyardWorldState; + uint32 m_scoutWorldStateAlliance; + uint32 m_scoutWorldStateHorde; + uint8 m_towersAlliance; + uint8 m_towersHorde; + + ObjectGuid m_towerBanners[MAX_ZM_TOWERS]; + ObjectGuid m_graveyardBannerAlliance; + ObjectGuid m_graveyardBannerHorde; + ObjectGuid m_graveyardBannerNeutral; + + ObjectGuid m_beamTowerBlue[MAX_ZM_TOWERS]; + ObjectGuid m_beamTowerRed[MAX_ZM_TOWERS]; + ObjectGuid m_beamGraveyardBlue; + ObjectGuid m_beamGraveyardRed; +}; + #endif