src/game/BattleGroundEY.cpp

   1 /*
   2  * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Object.h"
  20 #include "Player.h"
  21 #include "BattleGround.h"
  22 #include "BattleGroundEY.h"
  23 #include "Creature.h"
  24 #include "ObjectMgr.h"
  25 #include "BattleGroundMgr.h"
  26 #include "Language.h"
  27 #include "WorldPacket.h"
  28 #include "Util.h"
  29 #include "MapManager.h"
  30
  31 BattleGroundEY::BattleGroundEY()
  32 {
  33     m_BuffChange = true;
  34     m_BgObjects.resize(BG_EY_OBJECT_MAX);
  35
  36     m_Points_Trigger[FEL_REALVER] = TR_FEL_REALVER_BUFF;
  37     m_Points_Trigger[BLOOD_ELF] = TR_BLOOD_ELF_BUFF;
  38     m_Points_Trigger[DRAENEI_RUINS] = TR_DRAENEI_RUINS_BUFF;
  39     m_Points_Trigger[MAGE_TOWER] = TR_MAGE_TOWER_BUFF;
  40
  41     m_StartMessageIds[BG_STARTING_EVENT_FIRST]  = 0;
  42     m_StartMessageIds[BG_STARTING_EVENT_SECOND] = LANG_BG_EY_START_ONE_MINUTE;
  43     m_StartMessageIds[BG_STARTING_EVENT_THIRD]  = LANG_BG_EY_START_HALF_MINUTE;
  44     m_StartMessageIds[BG_STARTING_EVENT_FOURTH] = LANG_BG_EY_HAS_BEGUN;
  45 }
  46
  47 BattleGroundEY::~BattleGroundEY()
  48 {
  49 }
  50
  51 void BattleGroundEY::Update(uint32 diff)
  52 {
  53     BattleGround::Update(diff);
  54
  55     if (GetStatus() == STATUS_IN_PROGRESS)
  56     {
  57         m_PointAddingTimer -= diff;
  58         if (m_PointAddingTimer <= 0)
  59         {
  60             m_PointAddingTimer = BG_EY_FPOINTS_TICK_TIME;
  61             if (m_TeamPointsCount[BG_TEAM_ALLIANCE] > 0)
  62                 AddPoints(ALLIANCE, BG_EY_TickPoints[m_TeamPointsCount[BG_TEAM_ALLIANCE] - 1]);
  63             if (m_TeamPointsCount[BG_TEAM_HORDE] > 0)
  64                 AddPoints(HORDE, BG_EY_TickPoints[m_TeamPointsCount[BG_TEAM_HORDE] - 1]);
  65         }
  66
  67         if (m_FlagState == BG_EY_FLAG_STATE_WAIT_RESPAWN || m_FlagState == BG_EY_FLAG_STATE_ON_GROUND)
  68         {
  69             m_FlagsTimer -= diff;
  70
  71             if (m_FlagsTimer < 0)
  72             {
  73                 m_FlagsTimer = 0;
  74                 if (m_FlagState == BG_EY_FLAG_STATE_WAIT_RESPAWN)
  75                     RespawnFlag(true);
  76                 else
  77                     RespawnFlagAfterDrop();
  78             }
  79         }
  80
  81         m_TowerCapCheckTimer -= diff;
  82         if (m_TowerCapCheckTimer <= 0)
  83         {
  84             //check if player joined point
  85             /*I used this order of calls, because although we will check if one player is in gameobject's distance 2 times
  86               but we can count of players on current point in CheckSomeoneLeftPoint
  87             */
  88             CheckSomeoneJoinedPoint();
  89             //check if player left point
  90             CheckSomeoneLeftPoint();
  91             UpdatePointStatuses();
  92             m_TowerCapCheckTimer = BG_EY_FPOINTS_TICK_TIME;
  93         }
  94     }
  95 }
  96
  97 void BattleGroundEY::StartingEventCloseDoors()
  98 {
  99 }
 100
 101 void BattleGroundEY::StartingEventOpenDoors()
 102 {
 103     // eye-doors are despawned, not opened
 104     SpawnEvent(BG_EVENT_DOOR, 0, false);
 105
 106     for(uint32 i = 0; i < BG_EY_NODES_MAX; ++i)
 107     {
 108         //randomly spawn buff
 109         uint8 buff = urand(0, 2);
 110         SpawnBGObject(m_BgObjects[BG_EY_OBJECT_SPEEDBUFF_FEL_REALVER + buff + i * 3], RESPAWN_IMMEDIATELY);
 111     }
 112 }
 113
 114 void BattleGroundEY::AddPoints(uint32 Team, uint32 Points)
 115 {
 116     BattleGroundTeamId team_index = GetTeamIndexByTeamId(Team);
 117     m_TeamScores[team_index] += Points;
 118     m_HonorScoreTics[team_index] += Points;
 119     if (m_HonorScoreTics[team_index] >= m_HonorTics )
 120     {
 121         RewardHonorToTeam(GetBonusHonorFromKill(1), Team);
 122         m_HonorScoreTics[team_index] -= m_HonorTics;
 123     }
 124     UpdateTeamScore(Team);
 125 }
 126
 127 void BattleGroundEY::CheckSomeoneJoinedPoint()
 128 {
 129     for (uint8 i = 0; i < BG_EY_NODES_MAX; ++i)
 130     {
 131         uint8 j = 0;
 132         while (j < m_PlayersNearPoint[BG_EY_NODES_MAX].size())
 133         {
 134             Player *plr = sObjectMgr.GetPlayer(m_PlayersNearPoint[BG_EY_NODES_MAX][j]);
 135             if (!plr)
 136             {
 137                 sLog.outError("BattleGroundEY:CheckSomeoneJoinedPoint: Player (GUID: %u) not found!", GUID_LOPART(m_PlayersNearPoint[BG_EY_NODES_MAX][j]));
 138                 ++j;
 139                 continue;
 140             }
 141             if (plr->CanCaptureTowerPoint() &&
 142                 plr->IsWithinDist3d(BG_EY_NodePositions[i][0], BG_EY_NodePositions[i][1], BG_EY_NodePositions[i][2], BG_EY_POINT_RADIUS))
 143             {
 144                 //player joined point!
 145                 //show progress bar
 146                 UpdateWorldStateForPlayer(PROGRESS_BAR_PERCENT_GREY, BG_EY_PROGRESS_BAR_PERCENT_GREY, plr);
 147                 UpdateWorldStateForPlayer(PROGRESS_BAR_STATUS, m_PointBarStatus[i], plr);
 148                 UpdateWorldStateForPlayer(PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_SHOW, plr);
 149                 //add player to point
 150                 m_PlayersNearPoint[i].push_back(m_PlayersNearPoint[BG_EY_NODES_MAX][j]);
 151                 //remove player from "free space"
 152                 m_PlayersNearPoint[BG_EY_NODES_MAX].erase(m_PlayersNearPoint[BG_EY_NODES_MAX].begin() + j);
 153             }
 154             else
 155                 ++j;
 156         }
 157     }
 158 }
 159
 160 void BattleGroundEY::CheckSomeoneLeftPoint()
 161 {
 162     //reset current point counts
 163     for (uint8 i = 0; i < 2*BG_EY_NODES_MAX; ++i)
 164         m_CurrentPointPlayersCount[i] = 0;
 165     for(uint8 i = 0; i < BG_EY_NODES_MAX; ++i)
 166     {
 167         uint8 j = 0;
 168         while (j < m_PlayersNearPoint[i].size())
 169         {
 170             Player *plr = sObjectMgr.GetPlayer(m_PlayersNearPoint[i][j]);
 171             if (!plr)
 172             {
 173                 sLog.outError("BattleGroundEY:CheckSomeoneLeftPoint Player (GUID: %u) not found!", GUID_LOPART(m_PlayersNearPoint[i][j]));
 174                 //move not existed player to "free space" - this will cause many error showing in log, but it is a very important bug
 175                 m_PlayersNearPoint[BG_EY_NODES_MAX].push_back(m_PlayersNearPoint[i][j]);
 176                 m_PlayersNearPoint[i].erase(m_PlayersNearPoint[i].begin() + j);
 177                 ++j;
 178                 continue;
 179             }
 180             if (!plr->CanCaptureTowerPoint() ||
 181                 !plr->IsWithinDist3d(BG_EY_NodePositions[i][0], BG_EY_NodePositions[i][1], BG_EY_NodePositions[i][2], BG_EY_POINT_RADIUS))
 182                 //move player out of point (add him to players that are out of points
 183             {
 184                 m_PlayersNearPoint[BG_EY_NODES_MAX].push_back(m_PlayersNearPoint[i][j]);
 185                 m_PlayersNearPoint[i].erase(m_PlayersNearPoint[i].begin() + j);
 186                 UpdateWorldStateForPlayer(PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_DONT_SHOW, plr);
 187             }
 188             else
 189             {
 190                 //player is neat flag, so update count:
 191                 m_CurrentPointPlayersCount[2 * i + GetTeamIndexByTeamId(plr->GetTeam())]++;
 192                 ++j;
 193             }
 194         }
 195     }
 196 }
 197
 198 void BattleGroundEY::UpdatePointStatuses()
 199 {
 200     for(uint8 point = 0; point < BG_EY_NODES_MAX; ++point)
 201     {
 202         if (m_PlayersNearPoint[point].empty())
 203             continue;
 204         //count new point bar status:
 205         m_PointBarStatus[point] += (m_CurrentPointPlayersCount[2 * point] - m_CurrentPointPlayersCount[2 * point + 1] < BG_EY_POINT_MAX_CAPTURERS_COUNT) ? m_CurrentPointPlayersCount[2 * point] - m_CurrentPointPlayersCount[2 * point + 1] : BG_EY_POINT_MAX_CAPTURERS_COUNT;
 206
 207         if (m_PointBarStatus[point] > BG_EY_PROGRESS_BAR_ALI_CONTROLLED)
 208             //point is fully alliance's
 209             m_PointBarStatus[point] = BG_EY_PROGRESS_BAR_ALI_CONTROLLED;
 210         if (m_PointBarStatus[point] < BG_EY_PROGRESS_BAR_HORDE_CONTROLLED)
 211             //point is fully horde's
 212             m_PointBarStatus[point] = BG_EY_PROGRESS_BAR_HORDE_CONTROLLED;
 213
 214         uint32 pointOwnerTeamId = 0;
 215         //find which team should own this point
 216         if (m_PointBarStatus[point] <= BG_EY_PROGRESS_BAR_NEUTRAL_LOW)
 217             pointOwnerTeamId = HORDE;
 218         else if (m_PointBarStatus[point] >= BG_EY_PROGRESS_BAR_NEUTRAL_HIGH)
 219             pointOwnerTeamId = ALLIANCE;
 220         else
 221             pointOwnerTeamId = EY_POINT_NO_OWNER;
 222
 223         for (uint8 i = 0; i < m_PlayersNearPoint[point].size(); ++i)
 224         {
 225             Player *plr = sObjectMgr.GetPlayer(m_PlayersNearPoint[point][i]);
 226             if (plr)
 227             {
 228                 UpdateWorldStateForPlayer(PROGRESS_BAR_STATUS, m_PointBarStatus[point], plr);
 229                                                             //if point owner changed we must evoke event!
 230                 if (pointOwnerTeamId != m_PointOwnedByTeam[point])
 231                 {
 232                     //point was uncontrolled and player is from team which captured point
 233                     if (m_PointState[point] == EY_POINT_STATE_UNCONTROLLED && plr->GetTeam() == pointOwnerTeamId)
 234                         EventTeamCapturedPoint(plr, point);
 235
 236                     //point was under control and player isn't from team which controlled it
 237                     if (m_PointState[point] == EY_POINT_UNDER_CONTROL && plr->GetTeam() != m_PointOwnedByTeam[point])
 238                         EventTeamLostPoint(plr, point);
 239                 }
 240             }
 241         }
 242     }
 243 }
 244
 245 void BattleGroundEY::UpdateTeamScore(uint32 Team)
 246 {
 247     uint32 score = GetTeamScore(Team);
 248
 249     if (score >= BG_EY_MAX_TEAM_SCORE)
 250     {
 251         score = BG_EY_MAX_TEAM_SCORE;
 252         EndBattleGround(Team);
 253     }
 254
 255     if (Team == ALLIANCE)
 256         UpdateWorldState(EY_ALLIANCE_RESOURCES, score);
 257     else
 258         UpdateWorldState(EY_HORDE_RESOURCES, score);
 259 }
 260
 261 void BattleGroundEY::EndBattleGround(uint32 winner)
 262 {
 263     //win reward
 264     if (winner == ALLIANCE)
 265         RewardHonorToTeam(GetBonusHonorFromKill(1), ALLIANCE);
 266     if (winner == HORDE)
 267         RewardHonorToTeam(GetBonusHonorFromKill(1), HORDE);
 268     //complete map reward
 269     RewardHonorToTeam(GetBonusHonorFromKill(1), ALLIANCE);
 270     RewardHonorToTeam(GetBonusHonorFromKill(1), HORDE);
 271
 272     BattleGround::EndBattleGround(winner);
 273 }
 274
 275 void BattleGroundEY::UpdatePointsCount(uint32 Team)
 276 {
 277     if (Team == ALLIANCE)
 278         UpdateWorldState(EY_ALLIANCE_BASE, m_TeamPointsCount[BG_TEAM_ALLIANCE]);
 279     else
 280         UpdateWorldState(EY_HORDE_BASE, m_TeamPointsCount[BG_TEAM_HORDE]);
 281 }
 282
 283 void BattleGroundEY::UpdatePointsIcons(uint32 Team, uint32 Point)
 284 {
 285     //we MUST firstly send 0, after that we can send 1!!!
 286     if (m_PointState[Point] == EY_POINT_UNDER_CONTROL)
 287     {
 288         UpdateWorldState(PointsIconStruct[Point].WorldStateControlIndex, 0);
 289         if (Team == ALLIANCE)
 290             UpdateWorldState(PointsIconStruct[Point].WorldStateAllianceControlledIndex, 1);
 291         else
 292             UpdateWorldState(PointsIconStruct[Point].WorldStateHordeControlledIndex, 1);
 293     }
 294     else
 295     {
 296         if (Team == ALLIANCE)
 297             UpdateWorldState(PointsIconStruct[Point].WorldStateAllianceControlledIndex, 0);
 298         else
 299             UpdateWorldState(PointsIconStruct[Point].WorldStateHordeControlledIndex, 0);
 300         UpdateWorldState(PointsIconStruct[Point].WorldStateControlIndex, 1);
 301     }
 302 }
 303
 304 void BattleGroundEY::AddPlayer(Player *plr)
 305 {
 306     BattleGround::AddPlayer(plr);
 307     //create score and add it to map
 308     BattleGroundEYScore* sc = new BattleGroundEYScore;
 309
 310     m_PlayersNearPoint[BG_EY_NODES_MAX].push_back(plr->GetGUID());
 311
 312     m_PlayerScores[plr->GetGUID()] = sc;
 313 }
 314
 315 void BattleGroundEY::RemovePlayer(Player *plr, uint64 guid)
 316 {
 317     // sometimes flag aura not removed :(
 318     for (int j = BG_EY_NODES_MAX; j >= 0; --j)
 319     {
 320         for(size_t i = 0; i < m_PlayersNearPoint[j].size(); ++i)
 321             if (m_PlayersNearPoint[j][i] == guid)
 322                 m_PlayersNearPoint[j].erase(m_PlayersNearPoint[j].begin() + i);
 323     }
 324     if (IsFlagPickedup())
 325     {
 326         if (m_FlagKeeper == guid)
 327         {
 328             if (plr)
 329                 EventPlayerDroppedFlag(plr);
 330             else
 331             {
 332                 SetFlagPicker(0);
 333                 RespawnFlag(true);
 334             }
 335         }
 336     }
 337 }
 338
 339 void BattleGroundEY::HandleAreaTrigger(Player *Source, uint32 Trigger)
 340 {
 341     if (GetStatus() != STATUS_IN_PROGRESS)
 342         return;
 343
 344     if(!Source->isAlive())                                  //hack code, must be removed later
 345         return;
 346
 347     switch(Trigger)
 348     {
 349         case TR_BLOOD_ELF_POINT:
 350             if (m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[BLOOD_ELF] == Source->GetTeam())
 351                 if (m_FlagState && GetFlagPickerGUID() == Source->GetGUID())
 352                     EventPlayerCapturedFlag(Source, BG_EY_NODE_BLOOD_ELF);
 353             break;
 354         case TR_FEL_REALVER_POINT:
 355             if (m_PointState[FEL_REALVER] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[FEL_REALVER] == Source->GetTeam())
 356                 if (m_FlagState && GetFlagPickerGUID() == Source->GetGUID())
 357                     EventPlayerCapturedFlag(Source, BG_EY_NODE_FEL_REALVER);
 358             break;
 359         case TR_MAGE_TOWER_POINT:
 360             if (m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[MAGE_TOWER] == Source->GetTeam())
 361                 if (m_FlagState && GetFlagPickerGUID() == Source->GetGUID())
 362                     EventPlayerCapturedFlag(Source, BG_EY_NODE_MAGE_TOWER);
 363             break;
 364         case TR_DRAENEI_RUINS_POINT:
 365             if (m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[DRAENEI_RUINS] == Source->GetTeam())
 366                 if (m_FlagState && GetFlagPickerGUID() == Source->GetGUID())
 367                     EventPlayerCapturedFlag(Source, BG_EY_NODE_DRAENEI_RUINS);
 368             break;
 369         case 4512:
 370         case 4515:
 371         case 4517:
 372         case 4519:
 373         case 4530:
 374         case 4531:
 375         case 4568:
 376         case 4569:
 377         case 4570:
 378         case 4571:
 379             break;
 380         default:
 381             sLog.outError("WARNING: Unhandled AreaTrigger in Battleground: %u", Trigger);
 382             Source->GetSession()->SendAreaTriggerMessage("Warning: Unhandled AreaTrigger in Battleground: %u", Trigger);
 383             break;
 384     }
 385 }
 386
 387 bool BattleGroundEY::SetupBattleGround()
 388 {
 389     //buffs
 390     for (int i = 0; i < BG_EY_NODES_MAX; ++i)
 391     {
 392         AreaTriggerEntry const* at = sAreaTriggerStore.LookupEntry(m_Points_Trigger[i]);
 393         if (!at)
 394         {
 395             sLog.outError("BattleGroundEY: Unknown trigger: %u", m_Points_Trigger[i]);
 396             continue;
 397         }
 398         if (!AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REALVER + i * 3, Buff_Entries[0], at->x, at->y, at->z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY)
 399             || !AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REALVER + i * 3 + 1, Buff_Entries[1], at->x, at->y, at->z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY)
 400             || !AddObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REALVER + i * 3 + 2, Buff_Entries[2], at->x, at->y, at->z, 0.907571f, 0, 0, 0.438371f, 0.898794f, RESPAWN_ONE_DAY)
 401             )
 402             sLog.outError("BattleGroundEY: Cannot spawn buff");
 403     }
 404
 405     return true;
 406 }
 407
 408 void BattleGroundEY::Reset()
 409 {
 410     //call parent's class reset
 411     BattleGround::Reset();
 412
 413     m_TeamScores[BG_TEAM_ALLIANCE] = 0;
 414     m_TeamScores[BG_TEAM_HORDE] = 0;
 415     m_TeamPointsCount[BG_TEAM_ALLIANCE] = 0;
 416     m_TeamPointsCount[BG_TEAM_HORDE] = 0;
 417     m_HonorScoreTics[BG_TEAM_ALLIANCE] = 0;
 418     m_HonorScoreTics[BG_TEAM_HORDE] = 0;
 419     m_FlagState = BG_EY_FLAG_STATE_ON_BASE;
 420     m_FlagKeeper = 0;
 421     m_DroppedFlagGUID = 0;
 422     m_PointAddingTimer = 0;
 423     m_TowerCapCheckTimer = 0;
 424     bool isBGWeekend = BattleGroundMgr::IsBGWeekend(GetTypeID());
 425     m_HonorTics = (isBGWeekend) ? BG_EY_EYWeekendHonorTicks : BG_EY_NotEYWeekendHonorTicks;
 426
 427     for(uint8 i = 0; i < BG_EY_NODES_MAX; ++i)
 428     {
 429         m_PointOwnedByTeam[i] = EY_POINT_NO_OWNER;
 430         m_PointState[i] = EY_POINT_STATE_UNCONTROLLED;
 431         m_PointBarStatus[i] = BG_EY_PROGRESS_BAR_STATE_MIDDLE;
 432         m_PlayersNearPoint[i].clear();
 433         m_PlayersNearPoint[i].reserve(15);                  //tip size
 434         m_ActiveEvents[i] = BG_EYE_NEUTRAL_TEAM;            // neutral team owns every node
 435     }
 436     // the flag in the middle is spawned at beginning
 437     m_ActiveEvents[BG_EY_EVENT_CAPTURE_FLAG] = BG_EY_EVENT2_FLAG_CENTER;
 438
 439     m_PlayersNearPoint[EY_PLAYERS_OUT_OF_POINTS].clear();
 440     m_PlayersNearPoint[EY_PLAYERS_OUT_OF_POINTS].reserve(30);
 441 }
 442
 443 void BattleGroundEY::RespawnFlag(bool send_message)
 444 {
 445     m_FlagState = BG_EY_FLAG_STATE_ON_BASE;
 446     // will despawn captured flags at the node and spawn in center
 447     SpawnEvent(BG_EY_EVENT_CAPTURE_FLAG, BG_EY_EVENT2_FLAG_CENTER, true);
 448
 449     if (send_message)
 450     {
 451         SendMessageToAll(LANG_BG_EY_RESETED_FLAG, CHAT_MSG_BG_SYSTEM_NEUTRAL);
 452         PlaySoundToAll(BG_EY_SOUND_FLAG_RESET);             // flags respawned sound...
 453     }
 454
 455     UpdateWorldState(NETHERSTORM_FLAG, 1);
 456 }
 457
 458 void BattleGroundEY::RespawnFlagAfterDrop()
 459 {
 460     RespawnFlag(true);
 461
 462     GameObject *obj = GetBgMap()->GetGameObject(GetDroppedFlagGUID());
 463     if (obj)
 464         obj->Delete();
 465     else
 466         sLog.outError("BattleGroundEY: Unknown dropped flag guid: %u",GUID_LOPART(GetDroppedFlagGUID()));
 467
 468     SetDroppedFlagGUID(0);
 469 }
 470
 471 void BattleGroundEY::HandleKillPlayer(Player *player, Player *killer)
 472 {
 473     if (GetStatus() != STATUS_IN_PROGRESS)
 474         return;
 475
 476     BattleGround::HandleKillPlayer(player, killer);
 477     EventPlayerDroppedFlag(player);
 478 }
 479
 480 void BattleGroundEY::EventPlayerDroppedFlag(Player *Source)
 481 {
 482     if (GetStatus() != STATUS_IN_PROGRESS)
 483     {
 484         // if not running, do not cast things at the dropper player, neither send unnecessary messages
 485         // just take off the aura
 486         if (IsFlagPickedup() && GetFlagPickerGUID() == Source->GetGUID())
 487         {
 488             SetFlagPicker(0);
 489             Source->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
 490         }
 491         return;
 492     }
 493
 494     if (!IsFlagPickedup())
 495         return;
 496
 497     if (GetFlagPickerGUID() != Source->GetGUID())
 498         return;
 499
 500     SetFlagPicker(0);
 501     Source->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
 502     m_FlagState = BG_EY_FLAG_STATE_ON_GROUND;
 503     m_FlagsTimer = BG_EY_FLAG_RESPAWN_TIME;
 504     Source->CastSpell(Source, SPELL_RECENTLY_DROPPED_FLAG, true);
 505     Source->CastSpell(Source, BG_EY_PLAYER_DROPPED_FLAG_SPELL, true);
 506     //this does not work correctly :( (it should remove flag carrier name)
 507     UpdateWorldState(NETHERSTORM_FLAG_STATE_HORDE, BG_EY_FLAG_STATE_WAIT_RESPAWN);
 508     UpdateWorldState(NETHERSTORM_FLAG_STATE_ALLIANCE, BG_EY_FLAG_STATE_WAIT_RESPAWN);
 509
 510     if (Source->GetTeam() == ALLIANCE)
 511         SendMessageToAll(LANG_BG_EY_DROPPED_FLAG, CHAT_MSG_BG_SYSTEM_ALLIANCE, NULL);
 512     else
 513         SendMessageToAll(LANG_BG_EY_DROPPED_FLAG, CHAT_MSG_BG_SYSTEM_HORDE, NULL);
 514 }
 515
 516 void BattleGroundEY::EventPlayerClickedOnFlag(Player *Source, GameObject* target_obj)
 517 {
 518     if (GetStatus() != STATUS_IN_PROGRESS || IsFlagPickedup() || !Source->IsWithinDistInMap(target_obj, 10))
 519         return;
 520
 521     if (Source->GetTeam() == ALLIANCE)
 522     {
 523         UpdateWorldState(NETHERSTORM_FLAG_STATE_ALLIANCE, BG_EY_FLAG_STATE_ON_PLAYER);
 524         PlaySoundToAll(BG_EY_SOUND_FLAG_PICKED_UP_ALLIANCE);
 525     }
 526     else
 527     {
 528         UpdateWorldState(NETHERSTORM_FLAG_STATE_HORDE, BG_EY_FLAG_STATE_ON_PLAYER);
 529         PlaySoundToAll(BG_EY_SOUND_FLAG_PICKED_UP_HORDE);
 530     }
 531
 532     if (m_FlagState == BG_EY_FLAG_STATE_ON_BASE)
 533         UpdateWorldState(NETHERSTORM_FLAG, 0);
 534     m_FlagState = BG_EY_FLAG_STATE_ON_PLAYER;
 535
 536     // despawn center-flag
 537     SpawnEvent(BG_EY_EVENT_CAPTURE_FLAG, BG_EY_EVENT2_FLAG_CENTER, false);
 538
 539     SetFlagPicker(Source->GetGUID());
 540     //get flag aura on player
 541     Source->CastSpell(Source, BG_EY_NETHERSTORM_FLAG_SPELL, true);
 542     Source->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 543
 544     if (Source->GetTeam() == ALLIANCE)
 545         PSendMessageToAll(LANG_BG_EY_HAS_TAKEN_FLAG, CHAT_MSG_BG_SYSTEM_ALLIANCE, NULL, Source->GetName());
 546     else
 547         PSendMessageToAll(LANG_BG_EY_HAS_TAKEN_FLAG, CHAT_MSG_BG_SYSTEM_HORDE, NULL, Source->GetName());
 548 }
 549
 550 void BattleGroundEY::EventTeamLostPoint(Player *Source, uint32 Point)
 551 {
 552     if (GetStatus() != STATUS_IN_PROGRESS)
 553         return;
 554
 555     // neutral node
 556     uint32 Team = m_PointOwnedByTeam[Point];
 557
 558     if (!Team)
 559         return;
 560
 561     if (Team == ALLIANCE)
 562         m_TeamPointsCount[BG_TEAM_ALLIANCE]--;
 563     else
 564         m_TeamPointsCount[BG_TEAM_HORDE]--;
 565
 566     // it's important to set the OwnedBy before despawning spiritguides, else
 567     // player won't get teleported away
 568     m_PointOwnedByTeam[Point] = EY_POINT_NO_OWNER;
 569     m_PointState[Point] = EY_POINT_NO_OWNER;
 570
 571     SpawnEvent(Point, BG_EYE_NEUTRAL_TEAM, true);           // will despawn alliance/horde
 572
 573     //buff isn't despawned
 574
 575     if (Team == ALLIANCE)
 576         SendMessageToAll(LoosingPointTypes[Point].MessageIdAlliance,CHAT_MSG_BG_SYSTEM_ALLIANCE, Source);
 577     else
 578         SendMessageToAll(LoosingPointTypes[Point].MessageIdHorde,CHAT_MSG_BG_SYSTEM_HORDE, Source);
 579
 580     UpdatePointsIcons(Team, Point);
 581     UpdatePointsCount(Team);
 582 }
 583
 584 void BattleGroundEY::EventTeamCapturedPoint(Player *Source, uint32 Point)
 585 {
 586     if (GetStatus() != STATUS_IN_PROGRESS)
 587         return;
 588
 589     uint32 Team = Source->GetTeam();
 590
 591     m_TeamPointsCount[GetTeamIndexByTeamId(Team)]++;
 592     SpawnEvent(Point, GetTeamIndexByTeamId(Team), true);
 593
 594     //buff isn't respawned
 595
 596     m_PointOwnedByTeam[Point] = Team;
 597     m_PointState[Point] = EY_POINT_UNDER_CONTROL;
 598
 599     if (Team == ALLIANCE)
 600         SendMessageToAll(CapturingPointTypes[Point].MessageIdAlliance,CHAT_MSG_BG_SYSTEM_ALLIANCE, Source);
 601     else
 602         SendMessageToAll(CapturingPointTypes[Point].MessageIdHorde,CHAT_MSG_BG_SYSTEM_HORDE, Source);
 603
 604     UpdatePointsIcons(Team, Point);
 605     UpdatePointsCount(Team);
 606 }
 607
 608 void BattleGroundEY::EventPlayerCapturedFlag(Player *Source, BG_EY_Nodes node)
 609 {
 610     if (GetStatus() != STATUS_IN_PROGRESS || GetFlagPickerGUID() != Source->GetGUID())
 611         return;
 612
 613     SetFlagPicker(0);
 614     m_FlagState = BG_EY_FLAG_STATE_WAIT_RESPAWN;
 615     Source->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
 616
 617     Source->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 618
 619     if (Source->GetTeam() == ALLIANCE)
 620         PlaySoundToAll(BG_EY_SOUND_FLAG_CAPTURED_ALLIANCE);
 621     else
 622         PlaySoundToAll(BG_EY_SOUND_FLAG_CAPTURED_HORDE);
 623
 624     SpawnEvent(BG_EY_EVENT_CAPTURE_FLAG, node, true);
 625
 626     m_FlagsTimer = BG_EY_FLAG_RESPAWN_TIME;
 627
 628     uint8 team_id = 0;
 629     if (Source->GetTeam() == ALLIANCE)
 630     {
 631         team_id = BG_TEAM_ALLIANCE;
 632         SendMessageToAll(LANG_BG_EY_CAPTURED_FLAG_A, CHAT_MSG_BG_SYSTEM_ALLIANCE, Source);
 633     }
 634     else
 635     {
 636         team_id = BG_TEAM_HORDE;
 637         SendMessageToAll(LANG_BG_EY_CAPTURED_FLAG_H, CHAT_MSG_BG_SYSTEM_HORDE, Source);
 638     }
 639
 640     if (m_TeamPointsCount[team_id] > 0)
 641         AddPoints(Source->GetTeam(), BG_EY_FlagPoints[m_TeamPointsCount[team_id] - 1]);
 642
 643     UpdatePlayerScore(Source, SCORE_FLAG_CAPTURES, 1);
 644 }
 645
 646 void BattleGroundEY::UpdatePlayerScore(Player *Source, uint32 type, uint32 value)
 647 {
 648     BattleGroundScoreMap::iterator itr = m_PlayerScores.find(Source->GetGUID());
 649     if(itr == m_PlayerScores.end())                         // player not found
 650         return;
 651
 652     switch(type)
 653     {
 654         case SCORE_FLAG_CAPTURES:                           // flags captured
 655             ((BattleGroundEYScore*)itr->second)->FlagCaptures += value;
 656             break;
 657         default:
 658             BattleGround::UpdatePlayerScore(Source, type, value);
 659             break;
 660     }
 661 }
 662
 663 void BattleGroundEY::FillInitialWorldStates(WorldPacket& data)
 664 {
 665     data << uint32(EY_HORDE_BASE) << uint32(m_TeamPointsCount[BG_TEAM_HORDE]);
 666     data << uint32(EY_ALLIANCE_BASE) << uint32(m_TeamPointsCount[BG_TEAM_ALLIANCE]);
 667     data << uint32(0xab6) << uint32(0x0);
 668     data << uint32(0xab5) << uint32(0x0);
 669     data << uint32(0xab4) << uint32(0x0);
 670     data << uint32(0xab3) << uint32(0x0);
 671     data << uint32(0xab2) << uint32(0x0);
 672     data << uint32(0xab1) << uint32(0x0);
 673     data << uint32(0xab0) << uint32(0x0);
 674     data << uint32(0xaaf) << uint32(0x0);
 675
 676     data << uint32(DRAENEI_RUINS_HORDE_CONTROL)     << uint32(m_PointOwnedByTeam[DRAENEI_RUINS] == HORDE && m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL);
 677
 678     data << uint32(DRAENEI_RUINS_ALLIANCE_CONTROL)  << uint32(m_PointOwnedByTeam[DRAENEI_RUINS] == ALLIANCE && m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL);
 679
 680     data << uint32(DRAENEI_RUINS_UNCONTROL)         << uint32(m_PointState[DRAENEI_RUINS] != EY_POINT_UNDER_CONTROL);
 681
 682     data << uint32(MAGE_TOWER_ALLIANCE_CONTROL)     << uint32(m_PointOwnedByTeam[MAGE_TOWER] == ALLIANCE && m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL);
 683
 684     data << uint32(MAGE_TOWER_HORDE_CONTROL)        << uint32(m_PointOwnedByTeam[MAGE_TOWER] == HORDE && m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL);
 685
 686     data << uint32(MAGE_TOWER_UNCONTROL)            << uint32(m_PointState[MAGE_TOWER] != EY_POINT_UNDER_CONTROL);
 687
 688     data << uint32(FEL_REAVER_HORDE_CONTROL)        << uint32(m_PointOwnedByTeam[FEL_REALVER] == HORDE && m_PointState[FEL_REALVER] == EY_POINT_UNDER_CONTROL);
 689
 690     data << uint32(FEL_REAVER_ALLIANCE_CONTROL)     << uint32(m_PointOwnedByTeam[FEL_REALVER] == ALLIANCE && m_PointState[FEL_REALVER] == EY_POINT_UNDER_CONTROL);
 691
 692     data << uint32(FEL_REAVER_UNCONTROL)            << uint32(m_PointState[FEL_REALVER] != EY_POINT_UNDER_CONTROL);
 693
 694     data << uint32(BLOOD_ELF_HORDE_CONTROL)         << uint32(m_PointOwnedByTeam[BLOOD_ELF] == HORDE && m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL);
 695
 696     data << uint32(BLOOD_ELF_ALLIANCE_CONTROL)      << uint32(m_PointOwnedByTeam[BLOOD_ELF] == ALLIANCE && m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL);
 697
 698     data << uint32(BLOOD_ELF_UNCONTROL)             << uint32(m_PointState[BLOOD_ELF] != EY_POINT_UNDER_CONTROL);
 699
 700     data << uint32(NETHERSTORM_FLAG)                << uint32(m_FlagState == BG_EY_FLAG_STATE_ON_BASE);
 701
 702     data << uint32(0xad2) << uint32(0x1);
 703     data << uint32(0xad1) << uint32(0x1);
 704     data << uint32(0xabe) << uint32(GetTeamScore(HORDE));
 705     data << uint32(0xabd) << uint32(GetTeamScore(ALLIANCE));
 706     data << uint32(0xa05) << uint32(0x8e);
 707     data << uint32(0xaa0) << uint32(0x0);
 708     data << uint32(0xa9f) << uint32(0x0);
 709     data << uint32(0xa9e) << uint32(0x0);
 710     data << uint32(0xc0d) << uint32(0x17b);
 711 }
 712
 713 WorldSafeLocsEntry const *BattleGroundEY::GetClosestGraveYard(Player* player)
 714 {
 715     uint32 g_id = 0;
 716
 717     switch(player->GetTeam())
 718     {
 719         case ALLIANCE: g_id = EY_GRAVEYARD_MAIN_ALLIANCE; break;
 720         case HORDE:    g_id = EY_GRAVEYARD_MAIN_HORDE;    break;
 721         default:       return NULL;
 722     }
 723
 724     float distance, nearestDistance;
 725
 726     WorldSafeLocsEntry const* entry = NULL;
 727     WorldSafeLocsEntry const* nearestEntry = NULL;
 728     entry = sWorldSafeLocsStore.LookupEntry(g_id);
 729     nearestEntry = entry;
 730
 731     if (!entry)
 732     {
 733         sLog.outError("BattleGroundEY: Not found the main team graveyard. Graveyard system isn't working!");
 734         return NULL;
 735     }
 736
 737     float plr_x = player->GetPositionX();
 738     float plr_y = player->GetPositionY();
 739     float plr_z = player->GetPositionZ();
 740
 741
 742     distance = (entry->x - plr_x)*(entry->x - plr_x) + (entry->y - plr_y)*(entry->y - plr_y) + (entry->z - plr_z)*(entry->z - plr_z);
 743     nearestDistance = distance;
 744
 745     for(uint8 i = 0; i < BG_EY_NODES_MAX; ++i)
 746     {
 747         if (m_PointOwnedByTeam[i]==player->GetTeam() && m_PointState[i]==EY_POINT_UNDER_CONTROL)
 748         {
 749             entry = sWorldSafeLocsStore.LookupEntry(CapturingPointTypes[i].GraveYardId);
 750             if (!entry)
 751                 sLog.outError("BattleGroundEY: Not found graveyard: %u",CapturingPointTypes[i].GraveYardId);
 752             else
 753             {
 754                 distance = (entry->x - plr_x)*(entry->x - plr_x) + (entry->y - plr_y)*(entry->y - plr_y) + (entry->z - plr_z)*(entry->z - plr_z);
 755                 if (distance < nearestDistance)
 756                 {
 757                     nearestDistance = distance;
 758                     nearestEntry = entry;
 759                 }
 760             }
 761         }
 762     }
 763
 764     return nearestEntry;
 765 }
 766
 767 bool BattleGroundEY::IsAllNodesConrolledByTeam(uint32 team) const
 768 {
 769     uint32 count = 0;
 770     for(int i = 0; i < BG_EY_NODES_MAX; ++i)
 771         if (m_PointOwnedByTeam[i] == team && m_PointState[i] == EY_POINT_UNDER_CONTROL)
 772             ++count;
 773
 774     return count == BG_EY_NODES_MAX;
 775 }