bool OutdoorPvPSI::HandleAreaTrigger(Player *plr, uint32 trigger)
{
switch(trigger)
{
case SI_AREATRIGGER_A:
if(plr->GetTeam() == ALLIANCE && plr->HasAura(SI_SILITHYST_FLAG,0))
{
// remove aura
plr->RemoveAurasDueToSpell(SI_SILITHYST_FLAG);
++ m_Gathered_A;
if(m_Gathered_A >= SI_MAX_RESOURCES)
{
BuffTeam(ALLIANCE);
sWorld.SendZoneText(OutdoorPvPSIBuffZones[0],objmgr.GetMangosString(LANG_OPVP_SI_CAPTURE_A,-1));
m_LastController = ALLIANCE;
m_Gathered_A = 0;
m_Gathered_H = 0;
}
UpdateWorldState();
// reward player
plr->CastSpell(plr,SI_TRACES_OF_SILITHYST,true);
// add 19 honor
plr->RewardHonor(NULL,1,19);
// add 20 cenarion circle repus
plr->GetReputationMgr().ModifyReputation(sFactionStore.LookupEntry(609), 20);
// complete quest
plr->KilledMonster(SI_TURNIN_QUEST_CM_A,0);
}
return true;
case SI_AREATRIGGER_H:
if(plr->GetTeam() == HORDE && plr->HasAura(SI_SILITHYST_FLAG,0))
{
// remove aura
plr->RemoveAurasDueToSpell(SI_SILITHYST_FLAG);
++ m_Gathered_H;
if(m_Gathered_H >= SI_MAX_RESOURCES)
{
BuffTeam(HORDE);
sWorld.SendZoneText(OutdoorPvPSIBuffZones[0],objmgr.GetMangosString(LANG_OPVP_SI_CAPTURE_H,-1));
m_LastController = HORDE;
m_Gathered_A = 0;
m_Gathered_H = 0;
}
UpdateWorldState();
// reward player
plr->CastSpell(plr,SI_TRACES_OF_SILITHYST,true);
// add 19 honor
plr->RewardHonor(NULL,1,19);
// add 20 cenarion circle repu
plr->GetReputationMgr().ModifyReputation(sFactionStore.LookupEntry(609), 20);
// complete quest
plr->KilledMonster(SI_TURNIN_QUEST_CM_H,0);
}
return true;
}
return false;
}
bool OutdoorPvPHP::Update(uint32 diff)
{
bool changed = false;
if(changed = OutdoorPvP::Update(diff))
{
if(m_AllianceTowersControlled == 3)
BuffTeam(ALLIANCE);
else if(m_HordeTowersControlled == 3)
BuffTeam(HORDE);
else
BuffTeam(NULL);
SendUpdateWorldState(HP_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SendUpdateWorldState(HP_UI_TOWER_COUNT_H, m_HordeTowersControlled);
}
return changed;
}
void OutdoorPvPTF::ProcessCaptureEvent(GameObject* pGo, uint32 uiTowerId, Team team, uint32 uiNewWorldState)
{
if (team != TEAM_NONE)
{
if (team == ALLIANCE)
{
SetBannerVisual(pGo, CAPTURE_ARTKIT_ALLIANCE, CAPTURE_ANIM_ALLIANCE);
++m_uiTowersAlliance;
}
else
{
SetBannerVisual(pGo, CAPTURE_ARTKIT_HORDE, CAPTURE_ANIM_HORDE);
++m_uiTowersHorde;
}
// if all towers are captured then process event
if (m_uiTowersAlliance == MAX_TF_TOWERS || m_uiTowersHorde == MAX_TF_TOWERS)
{
SendUpdateWorldState(m_uiZoneWorldState, WORLD_STATE_REMOVE);
m_uiZoneWorldState = team == ALLIANCE ? WORLD_STATE_TF_LOCKED_ALLIANCE : WORLD_STATE_TF_LOCKED_HORDE;
SendUpdateWorldState(m_uiZoneWorldState, WORLD_STATE_ADD);
m_uiZoneLockTimer = TIMER_TF_LOCK_TIME;
UpdateTimerWorldState();
m_zoneOwner = team;
BuffTeam(team, SPELL_AUCHINDOUN_BLESSING);
// lock the towers
LockTowers(pGo);
}
}
else
{
SetBannerVisual(pGo, CAPTURE_ARTKIT_NEUTRAL, CAPTURE_ANIM_NEUTRAL);
if (m_capturePointOwner[uiTowerId] == ALLIANCE)
--m_uiTowersAlliance;
else
--m_uiTowersHorde;
}
// update tower state
SendUpdateWorldState(m_uiTowerWorldState[uiTowerId], WORLD_STATE_REMOVE);
m_uiTowerWorldState[uiTowerId] = uiNewWorldState;
SendUpdateWorldState(m_uiTowerWorldState[uiTowerId], WORLD_STATE_ADD);
// update tower count
SendUpdateWorldState(WORLD_STATE_TF_TOWER_COUNT_A, m_uiTowersAlliance);
SendUpdateWorldState(WORLD_STATE_TF_TOWER_COUNT_H, m_uiTowersHorde);
// update capture point owner
m_capturePointOwner[uiTowerId] = team;
}
void OutdoorPvPTF::Update(uint32 diff)
{
if (m_uiZoneLockTimer)
{
if (m_uiZoneLockTimer < diff)
{
// remove buffs
BuffTeam(m_zoneOwner, SPELL_AUCHINDOUN_BLESSING, true);
// reset world states and towers
UpdateWorldState(WORLD_STATE_REMOVE);
m_zoneOwner = TEAM_NONE;
m_uiZoneWorldState = WORLD_STATE_TF_TOWERS_CONTROLLED;
m_uiTowersAlliance = 0;
m_uiTowersHorde = 0;
m_uiTowerWorldState[0] = WORLD_STATE_TOWER_1_NEUTRAL;
m_uiTowerWorldState[1] = WORLD_STATE_TOWER_2_NEUTRAL;
m_uiTowerWorldState[2] = WORLD_STATE_TOWER_3_NEUTRAL;
m_uiTowerWorldState[3] = WORLD_STATE_TOWER_4_NEUTRAL;
m_uiTowerWorldState[4] = WORLD_STATE_TOWER_5_NEUTRAL;
UpdateWorldState(WORLD_STATE_ADD);
// update tower count
SendUpdateWorldState(WORLD_STATE_TF_TOWER_COUNT_A, m_uiTowersAlliance);
SendUpdateWorldState(WORLD_STATE_TF_TOWER_COUNT_H, m_uiTowersHorde);
for (PlayerSet::iterator itr = m_sZonePlayers.begin(); itr != m_sZonePlayers.end(); ++itr)
{
if ((*itr) && (*itr)->isAlive())
{
ResetTowers((*itr));
break;
}
}
m_uiZoneLockTimer = 0;
}
else
{
if (m_uiZoneUpdateTimer < diff)
{
// update timer
UpdateTimerWorldState();
m_uiZoneUpdateTimer = TIMER_TF_UPDATE_TIME;
}
else
m_uiZoneUpdateTimer -= diff;
m_uiZoneLockTimer -= diff;
}
}
}
void OutdoorPvPNA::ProcessCaptureEvent(GameObject* go, Team team)
{
BuffTeam(m_zoneOwner, SPELL_STRENGTH_HALAANI, true);
// update capture point owner
m_zoneOwner = team;
LockHalaa(go);
m_guardsLeft = MAX_NA_GUARDS;
m_isUnderSiege = false;
m_soldiersRespawnTimer = 0;
UpdateWorldState(WORLD_STATE_REMOVE);
DespawnVendors(go);
sObjectMgr.SetGraveYardLinkTeam(GRAVEYARD_ID_HALAA, GRAVEYARD_ZONE_ID_HALAA, m_zoneOwner);
if (m_zoneOwner == ALLIANCE)
{
m_zoneWorldState = WORLD_STATE_NA_GUARDS_ALLIANCE;
m_zoneMapState = WORLD_STATE_NA_HALAA_ALLIANCE;
}
else
{
m_zoneWorldState = WORLD_STATE_NA_GUARDS_HORDE;
m_zoneMapState = WORLD_STATE_NA_HALAA_HORDE;
}
HandleFactionObjects(go);
UpdateWorldState(WORLD_STATE_ADD);
SendUpdateWorldState(WORLD_STATE_NA_GUARDS_LEFT, m_guardsLeft);
BuffTeam(m_zoneOwner, SPELL_STRENGTH_HALAANI);
sWorld.SendDefenseMessage(ZONE_ID_NAGRAND, m_zoneOwner == ALLIANCE ? LANG_OPVP_NA_CAPTURE_A : LANG_OPVP_NA_CAPTURE_H);
}
// Handle the zone reset when the timer expires
void OutdoorPvPTF::UnlockZone()
{
// remove buffs
BuffTeam(m_zoneOwner, SPELL_AUCHINDOUN_BLESSING, true);
m_zoneOwner = TEAM_NONE;
// reset world states and towers
SendUpdateWorldState(m_zoneWorldState, WORLD_STATE_REMOVE);
m_zoneWorldState = WORLD_STATE_TF_TOWERS_CONTROLLED;
SendUpdateWorldState(m_zoneWorldState, WORLD_STATE_ADD);
// reset tower states
m_towerWorldState[0] = WORLD_STATE_TF_WEST_TOWER_NEUTRAL;
m_towerWorldState[1] = WORLD_STATE_TF_NORTH_TOWER_NEUTRAL;
m_towerWorldState[2] = WORLD_STATE_TF_EAST_TOWER_NEUTRAL;
m_towerWorldState[3] = WORLD_STATE_TF_SOUTH_EAST_TOWER_NEUTRAL;
m_towerWorldState[4] = WORLD_STATE_TF_SOUTH_TOWER_NEUTRAL;
for (uint8 i = 0; i < MAX_TF_TOWERS; ++i)
SendUpdateWorldState(m_towerWorldState[i], WORLD_STATE_ADD);
// update tower count
m_towersAlliance = 0;
m_towersHorde = 0;
SendUpdateWorldState(WORLD_STATE_TF_TOWER_COUNT_A, m_towersAlliance);
SendUpdateWorldState(WORLD_STATE_TF_TOWER_COUNT_H, m_towersHorde);
for (GuidZoneMap::iterator itr = m_zonePlayers.begin(); itr != m_zonePlayers.end(); ++itr)
{
// Find player who is in main zone (Terokkar Forest) to get correct map reference
if (!itr->second)
continue;
if (Player* player = sObjectMgr.GetPlayer(itr->first))
{
ResetTowers(player);
break;
}
}
}
// Handle the zone lock when the timer is activated
void OutdoorPvPTF::LockZone(GameObject* go, uint32 towerId, Team team, uint32 newWorldState)
{
SendUpdateWorldState(m_zoneWorldState, WORLD_STATE_REMOVE);
m_zoneWorldState = team == ALLIANCE ? WORLD_STATE_TF_LOCKED_ALLIANCE : WORLD_STATE_TF_LOCKED_HORDE;
SendUpdateWorldState(m_zoneWorldState, WORLD_STATE_ADD);
m_zoneLockTimer = TIMER_TF_LOCK_TIME;
UpdateTimerWorldState();
m_zoneOwner = team;
BuffTeam(team, SPELL_AUCHINDOUN_BLESSING);
// lock the towers
LockTowers(go);
sWorld.SendDefenseMessage(ZONE_ID_TEROKKAR_FOREST, team == ALLIANCE ? LANG_OPVP_TF_CAPTURE_ALL_TOWERS_A : LANG_OPVP_TF_CAPTURE_ALL_TOWERS_H);
// remove tower states when zone has been captured and locked
for (uint8 i = 0; i < MAX_TF_TOWERS; ++i)
SendUpdateWorldState(m_towerWorldState[i], WORLD_STATE_REMOVE);
m_towerWorldState[towerId] = newWorldState;
}
// Handle case when player returns a silithyst
bool OutdoorPvPSI::HandleAreaTrigger(Player* player, uint32 triggerId)
{
if (player->isGameMaster() || player->isDead())
return false;
switch (triggerId)
{
case AREATRIGGER_SILITHUS_ALLIANCE:
if (player->GetTeam() != ALLIANCE || !player->HasAura(SPELL_SILITHYST))
return false;
// update counter
++ m_resourcesAlliance;
SendUpdateWorldState(WORLD_STATE_SI_GATHERED_A, m_resourcesAlliance);
// handle the case when the faction has reached maximum resources allowed
if (m_resourcesAlliance == MAX_SILITHYST)
{
// NOTE: On retail it would not reset until server restart but we do not support weekly restart :)
m_zoneOwner = ALLIANCE;
m_resourcesAlliance = 0;
m_resourcesHorde = 0;
// also update the horde counter if resources were reset
SendUpdateWorldState(WORLD_STATE_SI_GATHERED_H, m_resourcesHorde);
// apply buff to owner team
BuffTeam(ALLIANCE, SPELL_CENARION_FAVOR);
// Send defense message
sWorld.SendDefenseMessage(ZONE_ID_SILITHUS, LANG_OPVP_SI_CAPTURE_A);
}
// give quest credit if necessary
if (player->GetQuestStatus(QUEST_SCOURING_DESERT_ALLIANCE) == QUEST_STATUS_INCOMPLETE)
player->KilledMonsterCredit(NPC_SILITHUS_DUST_QUEST_ALLIANCE);
break;
case AREATRIGGER_SILITHUS_HORDE:
if (player->GetTeam() != HORDE || !player->HasAura(SPELL_SILITHYST))
return false;
// update counter
++ m_resourcesHorde;
SendUpdateWorldState(WORLD_STATE_SI_GATHERED_H, m_resourcesHorde);
// handle the case when the faction has reached maximum resources allowed
if (m_resourcesHorde == MAX_SILITHYST)
{
// NOTE: On retail it would not reset until server restart but we do not support weekly restart :)
m_zoneOwner = HORDE;
m_resourcesAlliance = 0;
m_resourcesHorde = 0;
// also update the alliance counter if resources were reset
SendUpdateWorldState(WORLD_STATE_SI_GATHERED_A, m_resourcesAlliance);
// apply buff to owner team
BuffTeam(HORDE, SPELL_CENARION_FAVOR);
// Send defense message
sWorld.SendDefenseMessage(ZONE_ID_SILITHUS, LANG_OPVP_SI_CAPTURE_H);
}
// give quest credit if necessary
if (player->GetQuestStatus(QUEST_SCOURING_DESERT_HORDE) == QUEST_STATUS_INCOMPLETE)
player->KilledMonsterCredit(NPC_SILITHUS_DUST_QUEST_HORDE);
break;
default:
return false;
}
// remove silithyst aura
player->RemoveAurasDueToSpell(SPELL_SILITHYST);
// reward the player
player->CastSpell(player, SPELL_TRACES_OF_SILITHYST, true);
player->RewardHonor(NULL, 1, HONOR_REWARD_SILITHYST);
player->GetReputationMgr().ModifyReputation(sFactionStore.LookupEntry(FACTION_CENARION_CIRCLE), REPUTATION_REWARD_SILITHYST);
return true;
}
// 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;
}
bool OutdoorPvPHP::ProcessCaptureEvent(GameObject* go, uint32 towerId, Team team, uint32 newWorldState, uint32 towerArtKit, uint32 towerAnim)
{
// set artkits and process buffs
if (team == ALLIANCE)
{
SetBannerVisual(go, CAPTURE_ARTKIT_ALLIANCE, CAPTURE_ANIM_ALLIANCE);
// update counter state
++m_towersAlliance;
SendUpdateWorldState(WORLD_STATE_HP_TOWER_COUNT_ALLIANCE, m_towersAlliance);
if (m_towersAlliance == MAX_HP_TOWERS)
BuffTeam(ALLIANCE, SPELL_HELLFIRE_SUPERIORITY_ALLIANCE);
}
else if (team == HORDE)
{
SetBannerVisual(go, CAPTURE_ARTKIT_HORDE, CAPTURE_ANIM_HORDE);
// update counter
++m_towersHorde;
SendUpdateWorldState(WORLD_STATE_HP_TOWER_COUNT_HORDE, m_towersHorde);
if (m_towersHorde == MAX_HP_TOWERS)
BuffTeam(HORDE, SPELL_HELLFIRE_SUPERIORITY_HORDE);
}
else
{
SetBannerVisual(go, CAPTURE_ARTKIT_NEUTRAL, CAPTURE_ANIM_NEUTRAL);
if (m_towerOwner[towerId] == ALLIANCE)
{
if (m_towersAlliance == MAX_HP_TOWERS)
BuffTeam(ALLIANCE, SPELL_HELLFIRE_SUPERIORITY_ALLIANCE, true);
// update counter
--m_towersAlliance;
SendUpdateWorldState(WORLD_STATE_HP_TOWER_COUNT_ALLIANCE, m_towersAlliance);
}
else
{
if (m_towersHorde == MAX_HP_TOWERS)
BuffTeam(HORDE, SPELL_HELLFIRE_SUPERIORITY_HORDE, true);
// update counter
--m_towersHorde;
SendUpdateWorldState(WORLD_STATE_HP_TOWER_COUNT_HORDE, m_towersHorde);
}
}
SetBannerVisual(go, m_banners[towerId], towerArtKit, towerAnim);
// update tower state
SendUpdateWorldState(m_towerWorldState[towerId], WORLD_STATE_REMOVE);
m_towerWorldState[towerId] = newWorldState;
SendUpdateWorldState(m_towerWorldState[towerId], WORLD_STATE_ADD);
// update capture point owner
m_towerOwner[towerId] = team;
// the are no DB exceptions in this case
return true;
}
bool OutdoorPvPEP::ProcessCaptureEvent(GameObject* go, uint32 towerId, Team team, uint32 newWorldState)
{
if (team == ALLIANCE)
{
// update banner
for (GuidList::const_iterator itr = m_towerBanners[towerId].begin(); itr != m_towerBanners[towerId].end(); ++itr)
SetBannerVisual(go, (*itr), CAPTURE_ARTKIT_ALLIANCE, CAPTURE_ANIM_ALLIANCE);
// update counter
++m_towersAlliance;
SendUpdateWorldState(WORLD_STATE_EP_TOWER_COUNT_ALLIANCE, m_towersAlliance);
// buff players
BuffTeam(ALLIANCE, plaguelandsTowerBuffs[m_towersAlliance - 1].spellIdAlliance);
}
else if (team == HORDE)
{
// update banner
for (GuidList::const_iterator itr = m_towerBanners[towerId].begin(); itr != m_towerBanners[towerId].end(); ++itr)
SetBannerVisual(go, (*itr), CAPTURE_ARTKIT_HORDE, CAPTURE_ANIM_HORDE);
// update counter
++m_towersHorde;
SendUpdateWorldState(WORLD_STATE_EP_TOWER_COUNT_HORDE, m_towersHorde);
// buff players
BuffTeam(HORDE, plaguelandsTowerBuffs[m_towersHorde - 1].spellIdHorde);
}
else
{
// update banner
for (GuidList::const_iterator itr = m_towerBanners[towerId].begin(); itr != m_towerBanners[towerId].end(); ++itr)
SetBannerVisual(go, (*itr), CAPTURE_ARTKIT_NEUTRAL, CAPTURE_ANIM_NEUTRAL);
if (m_towerOwner[towerId] == ALLIANCE)
{
// update counter
--m_towersAlliance;
SendUpdateWorldState(WORLD_STATE_EP_TOWER_COUNT_ALLIANCE, m_towersAlliance);
if (m_towersAlliance == 0)
BuffTeam(ALLIANCE, plaguelandsTowerBuffs[0].spellIdAlliance, true);
}
else
{
// update counter
--m_towersHorde;
SendUpdateWorldState(WORLD_STATE_EP_TOWER_COUNT_HORDE, m_towersHorde);
if (m_towersHorde == 0)
BuffTeam(HORDE, plaguelandsTowerBuffs[0].spellIdHorde, true);
}
}
bool eventHandled = true;
if (team != TEAM_NONE)
{
// update capture point owner before rewards are applied
m_towerOwner[towerId] = team;
// apply rewards of changed tower
switch (towerId)
{
case TOWER_ID_NORTHPASS:
RespawnGO(go, team == ALLIANCE ? m_lordaeronShrineAlliance : m_lordaeronShrineHorde, true);
break;
case TOWER_ID_CROWNGUARD:
sObjectMgr.SetGraveYardLinkTeam(GRAVEYARD_ID_EASTERN_PLAGUE, GRAVEYARD_ZONE_EASTERN_PLAGUE, team);
break;
case TOWER_ID_EASTWALL:
// Return false - allow the DB to handle summons
if (m_towerOwner[TOWER_ID_NORTHPASS] != team)
eventHandled = false;
break;
case TOWER_ID_PLAGUEWOOD:
// Return false - allow the DB to handle summons
eventHandled = false;
break;
}
}
else
{
// remove rewards of changed tower
switch (towerId)
{
case TOWER_ID_NORTHPASS:
RespawnGO(go, m_towerOwner[TOWER_ID_NORTHPASS] == ALLIANCE ? m_lordaeronShrineAlliance : m_lordaeronShrineHorde, false);
break;
case TOWER_ID_CROWNGUARD:
sObjectMgr.SetGraveYardLinkTeam(GRAVEYARD_ID_EASTERN_PLAGUE, GRAVEYARD_ZONE_EASTERN_PLAGUE, TEAM_INVALID);
break;
case TOWER_ID_EASTWALL:
UnsummonSoldiers(go);
break;
case TOWER_ID_PLAGUEWOOD:
UnsummonFlightMaster(go);
break;
}
// update capture point owner after rewards have been removed
m_towerOwner[towerId] = team;
}
// update tower state
SendUpdateWorldState(m_towerWorldState[towerId], WORLD_STATE_REMOVE);
m_towerWorldState[towerId] = newWorldState;
SendUpdateWorldState(m_towerWorldState[towerId], WORLD_STATE_ADD);
// there are some events which required further DB script
return eventHandled;
}
bool OutdoorPvPTF::Update(uint32 diff)
{
bool changed = false;
if(changed = OutdoorPvP::Update(diff))
{
if(m_AllianceTowersControlled == TF_TOWER_NUM)
{
BuffTeam(ALLIANCE);
m_IsLocked = true;
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL,uint32(0));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE,uint32(0));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE,uint32(1));
SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
}
else if(m_HordeTowersControlled == TF_TOWER_NUM)
{
BuffTeam(HORDE);
m_IsLocked = true;
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL,uint32(0));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE,uint32(1));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE,uint32(0));
SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
}
else
BuffTeam(NULL);
SendUpdateWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
SendUpdateWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
}
if(m_IsLocked)
{
// lock timer is down, release lock
if(m_LockTimer < diff)
{
m_LockTimer = TF_LOCK_TIME;
m_LockTimerUpdate = 0;
m_IsLocked = false;
SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(1));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL,uint32(0));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE,uint32(0));
SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE,uint32(0));
}
else
{
// worldstateui update timer is down, update ui with new time data
if(m_LockTimerUpdate < diff)
{
m_LockTimerUpdate = TF_LOCK_TIME_UPDATE;
uint32 minutes_left = m_LockTimer / 60000;
hours_left = minutes_left / 60;
minutes_left -= hours_left * 60;
second_digit = minutes_left % 10;
first_digit = minutes_left / 10;
SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT,first_digit);
SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT,second_digit);
SendUpdateWorldState(TF_UI_LOCKED_TIME_HOURS,hours_left);
} else m_LockTimerUpdate -= diff;
m_LockTimer -= diff;
}
}
return changed;
}
// Handle case when player returns a silithyst
bool OutdoorPvPSI::HandleAreaTrigger(Player* pPlayer, uint32 uiTriggerId)
{
if (pPlayer->isGameMaster() || pPlayer->isDead())
return false;
if (uiTriggerId == AREATRIGGER_SILITHUS_ALLIANCE)
{
if (pPlayer->GetTeam() == ALLIANCE && pPlayer->HasAura(SPELL_SILITHYST))
{
// remove aura
pPlayer->RemoveAurasDueToSpell(SPELL_SILITHYST);
++m_uiResourcesAlliance;
if (m_uiResourcesAlliance == MAX_SILITHYST)
{
// apply buff to owner team
BuffTeam(ALLIANCE, SPELL_CENARION_FAVOR);
//send zone text and reset stats
sWorld.SendZoneText(ZONE_ID_SILITHUS, sObjectMgr.GetMangosStringForDBCLocale(LANG_OPVP_SI_CAPTURE_A));
m_zoneOwner = ALLIANCE;
m_uiResourcesAlliance = 0;
m_uiResourcesHorde = 0;
}
// update the world states
UpdateWorldState();
// reward the player
pPlayer->CastSpell(pPlayer, SPELL_TRACES_OF_SILITHYST, true);
pPlayer->RewardHonor(NULL, 1, HONOR_REWARD_SILITHYST);
pPlayer->GetReputationMgr().ModifyReputation(sFactionStore.LookupEntry(FACTION_CENARION_CIRCLE), REPUTATION_REWARD_SILITHYST);
// complete quest
if (pPlayer->GetQuestStatus(QUEST_SCOURING_DESERT_ALLIANCE) == QUEST_STATUS_INCOMPLETE)
pPlayer->KilledMonsterCredit(NPC_SILITHUS_DUST_QUEST_ALLIANCE);
return true;
}
}
else if (uiTriggerId == AREATRIGGER_SILITHUS_HORDE)
{
if (pPlayer->GetTeam() == HORDE && pPlayer->HasAura(SPELL_SILITHYST))
{
// remove aura
pPlayer->RemoveAurasDueToSpell(SPELL_SILITHYST);
++ m_uiResourcesHorde;
if (m_uiResourcesHorde == MAX_SILITHYST)
{
// apply buff to owner team
BuffTeam(HORDE, SPELL_CENARION_FAVOR);
//send zone text and reset stats
sWorld.SendZoneText(ZONE_ID_SILITHUS, sObjectMgr.GetMangosStringForDBCLocale(LANG_OPVP_SI_CAPTURE_H));
m_zoneOwner = HORDE;
m_uiResourcesAlliance = 0;
m_uiResourcesHorde = 0;
}
// update world states
UpdateWorldState();
// reward the player
pPlayer->CastSpell(pPlayer, SPELL_TRACES_OF_SILITHYST, true);
pPlayer->RewardHonor(NULL, 1, HONOR_REWARD_SILITHYST);
pPlayer->GetReputationMgr().ModifyReputation(sFactionStore.LookupEntry(FACTION_CENARION_CIRCLE), REPUTATION_REWARD_SILITHYST);
// complete quest
if (pPlayer->GetQuestStatus(QUEST_SCOURING_DESERT_HORDE) == QUEST_STATUS_INCOMPLETE)
pPlayer->KilledMonsterCredit(NPC_SILITHUS_DUST_QUEST_HORDE);
return true;
}
}
return false;
}
void OutdoorPvPEP::ProcessCaptureEvent(GameObject* pGo, uint32 uiTowerId, Team team, uint32 uiNewWorldState)
{
if (team == ALLIANCE)
{
for (std::list<ObjectGuid>::iterator itr = m_lTowerBanners[uiTowerId].begin(); itr != m_lTowerBanners[uiTowerId].end(); ++itr)
SetBannerVisual(pGo, (*itr), CAPTURE_ARTKIT_ALLIANCE, CAPTURE_ANIM_ALLIANCE);
++m_uiTowersAlliance;
BuffTeam(ALLIANCE, m_aPlaguelandsTowerBuffs[m_uiTowersAlliance - 1].uiSpellIdAlliance);
}
else if (team == HORDE)
{
for (std::list<ObjectGuid>::iterator itr = m_lTowerBanners[uiTowerId].begin(); itr != m_lTowerBanners[uiTowerId].end(); ++itr)
SetBannerVisual(pGo, (*itr), CAPTURE_ARTKIT_HORDE, CAPTURE_ANIM_HORDE);
++m_uiTowersHorde;
BuffTeam(HORDE, m_aPlaguelandsTowerBuffs[m_uiTowersHorde - 1].uiSpellIdHorde);
}
else
{
for (std::list<ObjectGuid>::iterator itr = m_lTowerBanners[uiTowerId].begin(); itr != m_lTowerBanners[uiTowerId].end(); ++itr)
SetBannerVisual(pGo, (*itr), CAPTURE_ARTKIT_NEUTRAL, CAPTURE_ANIM_NEUTRAL);
if (m_capturePointOwner[uiTowerId] == ALLIANCE)
{
if (--m_uiTowersAlliance == 0)
BuffTeam(ALLIANCE, m_aPlaguelandsTowerBuffs[0].uiSpellIdAlliance, true);
}
else
{
if (--m_uiTowersHorde == 0)
BuffTeam(HORDE, m_aPlaguelandsTowerBuffs[0].uiSpellIdHorde, true);
}
}
// handle rewards of each tower
if (team != TEAM_NONE)
{
// update capture point owner
m_capturePointOwner[uiTowerId] = team;
switch (uiTowerId)
{
case TOWER_ID_NORTHPASS:
UpdateShrine(pGo);
break;
case TOWER_ID_CROWNGUARD:
SetGraveyard();
break;
case TOWER_ID_EASTWALL:
if (m_capturePointOwner[TOWER_ID_NORTHPASS] != team)
SummonSoldiers(pGo);
break;
case TOWER_ID_PLAGUEWOOD:
SummonFlightMaster(pGo);
break;
}
}
else
{
switch (uiTowerId)
{
case TOWER_ID_NORTHPASS:
UpdateShrine(pGo, true);
break;
case TOWER_ID_CROWNGUARD:
SetGraveyard(true);
break;
case TOWER_ID_EASTWALL:
UnsummonSoldiers(pGo);
break;
case TOWER_ID_PLAGUEWOOD:
UnsummonFlightMaster(pGo);
break;
}
// update capture point owner
m_capturePointOwner[uiTowerId] = team;
}
// update tower state
SendUpdateWorldState(m_uiTowerWorldState[uiTowerId], WORLD_STATE_REMOVE);
m_uiTowerWorldState[uiTowerId] = uiNewWorldState;
SendUpdateWorldState(m_uiTowerWorldState[uiTowerId], WORLD_STATE_ADD);
// update counter state
UpdateWorldState();
}
