src/game/BattleGroundEY.cpp

   1 /*
   2  * Copyright (C) 2005-2009 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 "Chat.h"
  25 #include "ObjectMgr.h"
  26 #include "MapManager.h"
  27 #include "Language.h"
  28 #include "WorldPacket.h"
  29 #include "Util.h"
  30
  31 BattleGroundEY::BattleGroundEY()
  32 {
  33     m_BuffChange = true;
  34     m_BgObjects.resize(BG_EY_OBJECT_MAX);
  35     m_BgCreatures.resize(BG_EY_CREATURES_MAX);
  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
  42 BattleGroundEY::~BattleGroundEY()
  43 {
  44 }
  45
  46 void BattleGroundEY::Update(uint32 diff)
  47 {
  48     BattleGround::Update(diff);
  49     // after bg start we get there (once)
  50     if (GetStatus() == STATUS_WAIT_JOIN && GetPlayersSize())
  51     {
  52         ModifyStartDelayTime(diff);
  53
  54         if(!(m_Events & 0x01))
  55         {
  56             m_Events |= 0x01;
  57
  58             // setup here, only when at least one player has ported to the map
  59             if(!SetupBattleGround())
  60             {
  61                 EndNow();
  62                 return;
  63             }
  64
  65             SpawnBGObject(BG_EY_OBJECT_DOOR_A, RESPAWN_IMMEDIATELY);
  66             SpawnBGObject(BG_EY_OBJECT_DOOR_H, RESPAWN_IMMEDIATELY);
  67
  68 //            SpawnBGCreature(EY_SPIRIT_MAIN_ALLIANCE, RESPAWN_IMMEDIATELY);
  69 //            SpawnBGCreature(EY_SPIRIT_MAIN_HORDE, RESPAWN_IMMEDIATELY);
  70             for(uint32 i = BG_EY_OBJECT_A_BANNER_FEL_REALVER_CENTER; i < BG_EY_OBJECT_MAX; ++i)
  71                 SpawnBGObject(i, RESPAWN_ONE_DAY);
  72
  73             SetStartDelayTime(START_DELAY0);
  74         }
  75         // After 1 minute, warning is signalled
  76         else if(GetStartDelayTime() <= START_DELAY1 && !(m_Events & 0x04))
  77         {
  78             m_Events |= 0x04;
  79             SendMessageToAll(GetMangosString(LANG_BG_EY_ONE_MINUTE));
  80         }
  81         // After 1,5 minute, warning is signalled
  82         else if(GetStartDelayTime() <= START_DELAY2 && !(m_Events & 0x08))
  83         {
  84             m_Events |= 0x08;
  85             SendMessageToAll(GetMangosString(LANG_BG_EY_HALF_MINUTE));
  86         }
  87         // After 2 minutes, gates OPEN ! x)
  88         else if(GetStartDelayTime() < 0 && !(m_Events & 0x10))
  89         {
  90             m_Events |= 0x10;
  91             SpawnBGObject(BG_EY_OBJECT_DOOR_A, RESPAWN_ONE_DAY);
  92             SpawnBGObject(BG_EY_OBJECT_DOOR_H, RESPAWN_ONE_DAY);
  93
  94             for(uint32 i = BG_EY_OBJECT_N_BANNER_FEL_REALVER_CENTER; i <= BG_EY_OBJECT_FLAG_NETHERSTORM; ++i)
  95                 SpawnBGObject(i, RESPAWN_IMMEDIATELY);
  96             for(uint32 i = 0; i < EY_POINTS_MAX; ++i)
  97             {
  98                 //randomly spawn buff
  99                 uint8 buff = urand(0, 2);
 100                 SpawnBGObject(BG_EY_OBJECT_SPEEDBUFF_FEL_REALVER + buff + i * 3, RESPAWN_IMMEDIATELY);
 101             }
 102
 103             SendMessageToAll(GetMangosString(LANG_BG_EY_BEGIN));
 104
 105             PlaySoundToAll(SOUND_BG_START);
 106             SetStatus(STATUS_IN_PROGRESS);
 107
 108             for(BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
 109                 if(Player *plr = objmgr.GetPlayer(itr->first))
 110                     plr->RemoveAurasDueToSpell(SPELL_PREPARATION);
 111         }
 112     }
 113     else if(GetStatus() == STATUS_IN_PROGRESS)
 114     {
 115         m_PointAddingTimer -= diff;
 116         if(m_PointAddingTimer <= 0)
 117         {
 118             m_PointAddingTimer = BG_EY_FPOINTS_TICK_TIME;
 119             if (m_TeamPointsCount[BG_TEAM_ALLIANCE] > 0)
 120                 AddPoints(ALLIANCE, BG_EY_TickPoints[m_TeamPointsCount[BG_TEAM_ALLIANCE] - 1]);
 121             if (m_TeamPointsCount[BG_TEAM_HORDE] > 0)
 122                 AddPoints(HORDE, BG_EY_TickPoints[m_TeamPointsCount[BG_TEAM_HORDE] - 1]);
 123         }
 124
 125         if(m_FlagState == BG_EY_FLAG_STATE_WAIT_RESPAWN || m_FlagState == BG_EY_FLAG_STATE_ON_GROUND)
 126         {
 127             m_FlagsTimer -= diff;
 128
 129             if(m_FlagsTimer < 0)
 130             {
 131                 m_FlagsTimer = 0;
 132                 if (m_FlagState == BG_EY_FLAG_STATE_WAIT_RESPAWN)
 133                     RespawnFlag(true);
 134                 else
 135                     RespawnFlagAfterDrop();
 136             }
 137         }
 138
 139         m_TowerCapCheckTimer -= diff;
 140         if(m_TowerCapCheckTimer <= 0)
 141         {
 142             //check if player joined point
 143             /*I used this order of calls, because although we will check if one player is in gameobject's distance 2 times
 144               but we can count of players on current point in CheckSomeoneLeftPoint
 145             */
 146             CheckSomeoneJoinedPoint();
 147             //check if player left point
 148             CheckSomeoneLeftPoint();
 149             UpdatePointStatuses();
 150             m_TowerCapCheckTimer = BG_EY_FPOINTS_TICK_TIME;
 151         }
 152     }
 153 }
 154
 155 void BattleGroundEY::AddPoints(uint32 Team, uint32 Points)
 156 {
 157     uint8 team_index = GetTeamIndexByTeamId(Team);
 158     m_TeamScores[team_index] += Points;
 159     m_HonorScoreTics[team_index] += Points;
 160     if (m_HonorScoreTics[team_index] >= BG_HONOR_SCORE_TICKS)
 161     {
 162         RewardHonorToTeam(20, Team);
 163         m_HonorScoreTics[team_index] -= BG_HONOR_SCORE_TICKS;
 164     }
 165     UpdateTeamScore(Team);
 166 }
 167
 168 void BattleGroundEY::CheckSomeoneJoinedPoint()
 169 {
 170     GameObject *obj = NULL;
 171     for (uint8 i = 0; i < EY_POINTS_MAX; ++i)
 172     {
 173         obj = HashMapHolder<GameObject>::Find(m_BgObjects[BG_EY_OBJECT_TOWER_CAP_FEL_REALVER + i]);
 174         if (obj)
 175         {
 176             uint8 j = 0;
 177             while (j < m_PlayersNearPoint[EY_POINTS_MAX].size())
 178             {
 179                 Player *plr = objmgr.GetPlayer(m_PlayersNearPoint[EY_POINTS_MAX][j]);
 180                 if(!plr)
 181                 {
 182                     sLog.outError("BattleGroundEY: Player " I64FMTD " not found!", m_PlayersNearPoint[EY_POINTS_MAX][j]);
 183                     ++j;
 184                     continue;
 185                 }
 186                 if (plr->isAllowUseBattleGroundObject() && plr->IsWithinDistInMap(obj, BG_EY_POINT_RADIUS))
 187                 {
 188                     //player joined point!
 189                     //show progress bar
 190                     UpdateWorldStateForPlayer(PROGRESS_BAR_PERCENT_GREY, BG_EY_PROGRESS_BAR_PERCENT_GREY, plr);
 191                     UpdateWorldStateForPlayer(PROGRESS_BAR_STATUS, m_PointBarStatus[i], plr);
 192                     UpdateWorldStateForPlayer(PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_SHOW, plr);
 193                     //add player to point
 194                     m_PlayersNearPoint[i].push_back(m_PlayersNearPoint[EY_POINTS_MAX][j]);
 195                     //remove player from "free space"
 196                     m_PlayersNearPoint[EY_POINTS_MAX].erase(m_PlayersNearPoint[EY_POINTS_MAX].begin() + j);
 197                 }
 198                 else
 199                     ++j;
 200             }
 201         }
 202     }
 203 }
 204
 205 void BattleGroundEY::CheckSomeoneLeftPoint()
 206 {
 207     //reset current point counts
 208     for (uint8 i = 0; i < 2*EY_POINTS_MAX; ++i)
 209         m_CurrentPointPlayersCount[i] = 0;
 210     GameObject *obj = NULL;
 211     for(uint8 i = 0; i < EY_POINTS_MAX; ++i)
 212     {
 213         obj = HashMapHolder<GameObject>::Find(m_BgObjects[BG_EY_OBJECT_TOWER_CAP_FEL_REALVER + i]);
 214         if(obj)
 215         {
 216             uint8 j = 0;
 217             while (j < m_PlayersNearPoint[i].size())
 218             {
 219                 Player *plr = objmgr.GetPlayer(m_PlayersNearPoint[i][j]);
 220                 if (!plr)
 221                 {
 222                     sLog.outError("BattleGroundEY: Player " I64FMTD " not found!", m_PlayersNearPoint[i][j]);
 223                     //move not existed player to "free space" - this will cause many error showing in log, but it is a very important bug
 224                     m_PlayersNearPoint[EY_POINTS_MAX].push_back(m_PlayersNearPoint[i][j]);
 225                     m_PlayersNearPoint[i].erase(m_PlayersNearPoint[i].begin() + j);
 226                     ++j;
 227                     continue;
 228                 }
 229                 if (!plr->isAllowUseBattleGroundObject() || !plr->IsWithinDistInMap(obj, BG_EY_POINT_RADIUS))
 230                     //move player out of point (add him to players that are out of points
 231                 {
 232                     m_PlayersNearPoint[EY_POINTS_MAX].push_back(m_PlayersNearPoint[i][j]);
 233                     m_PlayersNearPoint[i].erase(m_PlayersNearPoint[i].begin() + j);
 234                     UpdateWorldStateForPlayer(PROGRESS_BAR_SHOW, BG_EY_PROGRESS_BAR_DONT_SHOW, plr);
 235                 }
 236                 else
 237                 {
 238                     //player is neat flag, so update count:
 239                     m_CurrentPointPlayersCount[2 * i + GetTeamIndexByTeamId(plr->GetTeam())]++;
 240                     ++j;
 241                 }
 242             }
 243         }
 244     }
 245 }
 246
 247 void BattleGroundEY::UpdatePointStatuses()
 248 {
 249     for(uint8 point = 0; point < EY_POINTS_MAX; ++point)
 250     {
 251         if (m_PlayersNearPoint[point].empty())
 252             continue;
 253         //count new point bar status:
 254         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;
 255
 256         if (m_PointBarStatus[point] > BG_EY_PROGRESS_BAR_ALI_CONTROLLED)
 257             //point is fully alliance's
 258             m_PointBarStatus[point] = BG_EY_PROGRESS_BAR_ALI_CONTROLLED;
 259         if (m_PointBarStatus[point] < BG_EY_PROGRESS_BAR_HORDE_CONTROLLED)
 260             //point is fully horde's
 261             m_PointBarStatus[point] = BG_EY_PROGRESS_BAR_HORDE_CONTROLLED;
 262
 263         uint32 pointOwnerTeamId = 0;
 264         //find which team should own this point
 265         if (m_PointBarStatus[point] <= BG_EY_PROGRESS_BAR_NEUTRAL_LOW)
 266             pointOwnerTeamId = HORDE;
 267         else if (m_PointBarStatus[point] >= BG_EY_PROGRESS_BAR_NEUTRAL_HIGH)
 268             pointOwnerTeamId = ALLIANCE;
 269         else
 270             pointOwnerTeamId = EY_POINT_NO_OWNER;
 271
 272         for (uint8 i = 0; i < m_PlayersNearPoint[point].size(); ++i)
 273         {
 274             Player *plr = objmgr.GetPlayer(m_PlayersNearPoint[point][i]);
 275             if (plr)
 276             {
 277                 UpdateWorldStateForPlayer(PROGRESS_BAR_STATUS, m_PointBarStatus[point], plr);
 278                                                             //if point owner changed we must evoke event!
 279                 if (pointOwnerTeamId != m_PointOwnedByTeam[point])
 280                 {
 281                     //point was uncontrolled and player is from team which captured point
 282                     if (m_PointState[point] == EY_POINT_STATE_UNCONTROLLED && plr->GetTeam() == pointOwnerTeamId)
 283                         EventTeamCapturedPoint(plr, point);
 284
 285                     //point was under control and player isn't from team which controlled it
 286                     if (m_PointState[point] == EY_POINT_UNDER_CONTROL && plr->GetTeam() != m_PointOwnedByTeam[point])
 287                         EventTeamLostPoint(plr, point);
 288                 }
 289             }
 290         }
 291     }
 292 }
 293
 294 void BattleGroundEY::UpdateTeamScore(uint32 Team)
 295 {
 296     uint32 score = GetTeamScore(Team);
 297     if(score >= EY_MAX_TEAM_SCORE)
 298     {
 299         score = EY_MAX_TEAM_SCORE;
 300         EndBattleGround(Team);
 301     }
 302
 303     if(Team == ALLIANCE)
 304         UpdateWorldState(EY_ALLIANCE_RESOURCES, score);
 305     else
 306         UpdateWorldState(EY_HORDE_RESOURCES, score);
 307 }
 308
 309 void BattleGroundEY::UpdatePointsCount(uint32 Team)
 310 {
 311     if(Team == ALLIANCE)
 312         UpdateWorldState(EY_ALLIANCE_BASE, m_TeamPointsCount[BG_TEAM_ALLIANCE]);
 313     else
 314         UpdateWorldState(EY_HORDE_BASE, m_TeamPointsCount[BG_TEAM_HORDE]);
 315 }
 316
 317 void BattleGroundEY::UpdatePointsIcons(uint32 Team, uint32 Point)
 318 {
 319     //we MUST firstly send 0, after that we can send 1!!!
 320     if (m_PointState[Point] == EY_POINT_UNDER_CONTROL)
 321     {
 322         UpdateWorldState(m_PointsIconStruct[Point].WorldStateControlIndex, 0);
 323         if(Team == ALLIANCE)
 324             UpdateWorldState(m_PointsIconStruct[Point].WorldStateAllianceControlledIndex, 1);
 325         else
 326             UpdateWorldState(m_PointsIconStruct[Point].WorldStateHordeControlledIndex, 1);
 327     }
 328     else
 329     {
 330         if(Team == ALLIANCE)
 331             UpdateWorldState(m_PointsIconStruct[Point].WorldStateAllianceControlledIndex, 0);
 332         else
 333             UpdateWorldState(m_PointsIconStruct[Point].WorldStateHordeControlledIndex, 0);
 334         UpdateWorldState(m_PointsIconStruct[Point].WorldStateControlIndex, 1);
 335     }
 336 }
 337
 338 void BattleGroundEY::AddPlayer(Player *plr)
 339 {
 340     BattleGround::AddPlayer(plr);
 341     //create score and add it to map
 342     BattleGroundEYScore* sc = new BattleGroundEYScore;
 343
 344     m_PlayersNearPoint[EY_POINTS_MAX].push_back(plr->GetGUID());
 345
 346     m_PlayerScores[plr->GetGUID()] = sc;
 347 }
 348
 349 void BattleGroundEY::RemovePlayer(Player *plr, uint64 guid)
 350 {
 351     // sometimes flag aura not removed :(
 352     for (int j = EY_POINTS_MAX; j >= 0; --j)
 353     {
 354         for(int i = 0; i < m_PlayersNearPoint[j].size(); ++i)
 355             if(m_PlayersNearPoint[j][i] == guid)
 356                 m_PlayersNearPoint[j].erase(m_PlayersNearPoint[j].begin() + i);
 357     }
 358     if(IsFlagPickedup())
 359     {
 360         if(m_FlagKeeper == guid)
 361         {
 362             if(plr)
 363                 EventPlayerDroppedFlag(plr);
 364             else
 365             {
 366                 SetFlagPicker(0);
 367                 RespawnFlag(true);
 368             }
 369         }
 370     }
 371 }
 372
 373 void BattleGroundEY::HandleAreaTrigger(Player *Source, uint32 Trigger)
 374 {
 375     if(GetStatus() != STATUS_IN_PROGRESS)
 376         return;
 377
 378     if(!Source->isAlive())                                  //hack code, must be removed later
 379         return;
 380
 381     switch(Trigger)
 382     {
 383         case TR_BLOOD_ELF_POINT:
 384             if(m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[BLOOD_ELF] == Source->GetTeam())
 385                 if(m_FlagState && GetFlagPickerGUID() == Source->GetGUID())
 386                     EventPlayerCapturedFlag(Source, BG_EY_OBJECT_FLAG_BLOOD_ELF);
 387             break;
 388         case TR_FEL_REALVER_POINT:
 389             if(m_PointState[FEL_REALVER] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[FEL_REALVER] == Source->GetTeam())
 390                 if(m_FlagState && GetFlagPickerGUID() == Source->GetGUID())
 391                     EventPlayerCapturedFlag(Source, BG_EY_OBJECT_FLAG_FEL_REALVER);
 392             break;
 393         case TR_MAGE_TOWER_POINT:
 394             if(m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[MAGE_TOWER] == Source->GetTeam())
 395                 if(m_FlagState && GetFlagPickerGUID() == Source->GetGUID())
 396                     EventPlayerCapturedFlag(Source, BG_EY_OBJECT_FLAG_MAGE_TOWER);
 397             break;
 398         case TR_DRAENEI_RUINS_POINT:
 399             if(m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL && m_PointOwnedByTeam[DRAENEI_RUINS] == Source->GetTeam())
 400                 if(m_FlagState && GetFlagPickerGUID() == Source->GetGUID())
 401                     EventPlayerCapturedFlag(Source, BG_EY_OBJECT_FLAG_DRAENEI_RUINS);
 402             break;
 403         case 4512:
 404         case 4515:
 405         case 4517:
 406         case 4519:
 407         case 4530:
 408         case 4531:
 409         case 4568:
 410         case 4569:
 411         case 4570:
 412         case 4571:
 413             break;
 414         default:
 415             sLog.outError("WARNING: Unhandled AreaTrigger in Battleground: %u", Trigger);
 416             Source->GetSession()->SendAreaTriggerMessage("Warning: Unhandled AreaTrigger in Battleground: %u", Trigger);
 417             break;
 418     }
 419 }
 420
 421 bool BattleGroundEY::SetupBattleGround()
 422 {
 423         // doors
 424     if(    !AddObject(BG_EY_OBJECT_DOOR_A, BG_OBJECT_A_DOOR_EY_ENTRY, 2527.6f, 1596.91f, 1262.13f, -3.12414f, -0.173642f, -0.001515f, 0.98477f, -0.008594f, RESPAWN_IMMEDIATELY)
 425         || !AddObject(BG_EY_OBJECT_DOOR_H, BG_OBJECT_H_DOOR_EY_ENTRY, 1803.21f, 1539.49f, 1261.09f, 3.14159f, 0.173648f, 0, 0.984808f, 0, RESPAWN_IMMEDIATELY)
 426         // banners (alliance)
 427         || !AddObject(BG_EY_OBJECT_A_BANNER_FEL_REALVER_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY)
 428         || !AddObject(BG_EY_OBJECT_A_BANNER_FEL_REALVER_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY)
 429         || !AddObject(BG_EY_OBJECT_A_BANNER_FEL_REALVER_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY)
 430         || !AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY)
 431         || !AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY)
 432         || !AddObject(BG_EY_OBJECT_A_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY)
 433         || !AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY)
 434         || !AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY)
 435         || !AddObject(BG_EY_OBJECT_A_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY)
 436         || !AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_A_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY)
 437         || !AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_A_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY)
 438         || !AddObject(BG_EY_OBJECT_A_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_A_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY)
 439         // banners (horde)
 440         || !AddObject(BG_EY_OBJECT_H_BANNER_FEL_REALVER_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY)
 441         || !AddObject(BG_EY_OBJECT_H_BANNER_FEL_REALVER_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY)
 442         || !AddObject(BG_EY_OBJECT_H_BANNER_FEL_REALVER_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY)
 443         || !AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY)
 444         || !AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY)
 445         || !AddObject(BG_EY_OBJECT_H_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY)
 446         || !AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY)
 447         || !AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY)
 448         || !AddObject(BG_EY_OBJECT_H_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY)
 449         || !AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_H_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY)
 450         || !AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_H_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY)
 451         || !AddObject(BG_EY_OBJECT_H_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_H_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY)
 452         // banners (natural)
 453         || !AddObject(BG_EY_OBJECT_N_BANNER_FEL_REALVER_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2057.46f, 1735.07f, 1187.91f, -0.925024f, 0, 0, 0.446198f, -0.894934f, RESPAWN_ONE_DAY)
 454         || !AddObject(BG_EY_OBJECT_N_BANNER_FEL_REALVER_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2032.25f, 1729.53f, 1190.33f, 1.8675f, 0, 0, 0.803857f, 0.594823f, RESPAWN_ONE_DAY)
 455         || !AddObject(BG_EY_OBJECT_N_BANNER_FEL_REALVER_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2092.35f, 1775.46f, 1187.08f, -0.401426f, 0, 0, 0.199368f, -0.979925f, RESPAWN_ONE_DAY)
 456         || !AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2047.19f, 1349.19f, 1189.0f, -1.62316f, 0, 0, 0.725374f, -0.688354f, RESPAWN_ONE_DAY)
 457         || !AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2074.32f, 1385.78f, 1194.72f, 0.488692f, 0, 0, 0.241922f, 0.970296f, RESPAWN_ONE_DAY)
 458         || !AddObject(BG_EY_OBJECT_N_BANNER_BLOOD_ELF_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2025.13f, 1386.12f, 1192.74f, 2.3911f, 0, 0, 0.930418f, 0.366501f, RESPAWN_ONE_DAY)
 459         || !AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2276.8f, 1400.41f, 1196.33f, 2.44346f, 0, 0, 0.939693f, 0.34202f, RESPAWN_ONE_DAY)
 460         || !AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2305.78f, 1404.56f, 1199.38f, 1.74533f, 0, 0, 0.766044f, 0.642788f, RESPAWN_ONE_DAY)
 461         || !AddObject(BG_EY_OBJECT_N_BANNER_DRAENEI_RUINS_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2245.4f, 1366.41f, 1195.28f, 2.21657f, 0, 0, 0.894934f, 0.446198f, RESPAWN_ONE_DAY)
 462         || !AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_CENTER, BG_OBJECT_N_BANNER_EY_ENTRY, 2270.84f, 1784.08f, 1186.76f, 2.42601f, 0, 0, 0.936672f, 0.350207f, RESPAWN_ONE_DAY)
 463         || !AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_LEFT, BG_OBJECT_N_BANNER_EY_ENTRY, 2269.13f, 1737.7f, 1186.66f, 0.994838f, 0, 0, 0.477159f, 0.878817f, RESPAWN_ONE_DAY)
 464         || !AddObject(BG_EY_OBJECT_N_BANNER_MAGE_TOWER_RIGHT, BG_OBJECT_N_BANNER_EY_ENTRY, 2300.86f, 1741.25f, 1187.7f, -0.785398f, 0, 0, 0.382683f, -0.92388f, RESPAWN_ONE_DAY)
 465         // flags
 466         || !AddObject(BG_EY_OBJECT_FLAG_NETHERSTORM, BG_OBJECT_FLAG2_EY_ENTRY, 2174.782227f, 1569.054688f, 1160.361938f, -1.448624f, 0, 0, 0.662620f, -0.748956f, RESPAWN_ONE_DAY)
 467         || !AddObject(BG_EY_OBJECT_FLAG_FEL_REALVER, BG_OBJECT_FLAG1_EY_ENTRY, 2044.28f, 1729.68f, 1189.96f, -0.017453f, 0, 0, 0.008727f, -0.999962f, RESPAWN_ONE_DAY)
 468         || !AddObject(BG_EY_OBJECT_FLAG_BLOOD_ELF, BG_OBJECT_FLAG1_EY_ENTRY, 2048.83f, 1393.65f, 1194.49f, 0.20944f, 0, 0, 0.104528f, 0.994522f, RESPAWN_ONE_DAY)
 469         || !AddObject(BG_EY_OBJECT_FLAG_DRAENEI_RUINS, BG_OBJECT_FLAG1_EY_ENTRY, 2286.56f, 1402.36f, 1197.11f, 3.72381f, 0, 0, 0.957926f, -0.287016f, RESPAWN_ONE_DAY)
 470         || !AddObject(BG_EY_OBJECT_FLAG_MAGE_TOWER, BG_OBJECT_FLAG1_EY_ENTRY, 2284.48f, 1731.23f, 1189.99f, 2.89725f, 0, 0, 0.992546f, 0.121869f, RESPAWN_ONE_DAY)
 471         // tower cap
 472         || !AddObject(BG_EY_OBJECT_TOWER_CAP_FEL_REALVER, BG_OBJECT_FR_TOWER_CAP_EY_ENTRY, 2024.600708f, 1742.819580f, 1195.157715f, 2.443461f, 0, 0, 0.939693f, 0.342020f, RESPAWN_ONE_DAY)
 473         || !AddObject(BG_EY_OBJECT_TOWER_CAP_BLOOD_ELF, BG_OBJECT_BE_TOWER_CAP_EY_ENTRY, 2050.493164f, 1372.235962f, 1194.563477f, 1.710423f, 0, 0, 0.754710f, 0.656059f, RESPAWN_ONE_DAY)
 474         || !AddObject(BG_EY_OBJECT_TOWER_CAP_DRAENEI_RUINS, BG_OBJECT_DR_TOWER_CAP_EY_ENTRY, 2301.010498f, 1386.931641f, 1197.183472f, 1.570796f, 0, 0, 0.707107f, 0.707107f, RESPAWN_ONE_DAY)
 475         || !AddObject(BG_EY_OBJECT_TOWER_CAP_MAGE_TOWER, BG_OBJECT_HU_TOWER_CAP_EY_ENTRY, 2282.121582f, 1760.006958f, 1189.707153f, 1.919862f, 0, 0, 0.819152f, 0.573576f, RESPAWN_ONE_DAY)
 476         )
 477     {
 478         sLog.outErrorDb("BatteGroundEY: Failed to spawn some object BattleGround not created!");
 479         return false;
 480     }
 481
 482     //buffs
 483     for (int i = 0; i < EY_POINTS_MAX; ++i)
 484     {
 485         AreaTriggerEntry const* at = sAreaTriggerStore.LookupEntry(m_Points_Trigger[i]);
 486         if( !at )
 487         {
 488             sLog.outError("BattleGroundEY: Unknown trigger: %u", m_Points_Trigger[i]);
 489             continue;
 490         }
 491         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)
 492             || !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)
 493             || !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)
 494             )
 495             sLog.outError("BattleGroundEY: Cannot spawn buff");
 496     }
 497
 498     WorldSafeLocsEntry const *sg = NULL;
 499     sg = sWorldSafeLocsStore.LookupEntry(EY_GRAVEYARD_MAIN_ALLIANCE);
 500     if( !sg || !AddSpiritGuide(EY_SPIRIT_MAIN_ALLIANCE, sg->x, sg->y, sg->z, 3.124139f, ALLIANCE) )
 501     {
 502         sLog.outErrorDb("BatteGroundEY: Failed to spawn spirit guide! BattleGround not created!");
 503         return false;
 504     }
 505
 506     sg = sWorldSafeLocsStore.LookupEntry(EY_GRAVEYARD_MAIN_HORDE);
 507     if( !sg || !AddSpiritGuide(EY_SPIRIT_MAIN_HORDE, sg->x, sg->y, sg->z, 3.193953f, HORDE) )
 508     {
 509         sLog.outErrorDb("BatteGroundEY: Failed to spawn spirit guide! BattleGround not created!");
 510         return false;
 511     }
 512
 513     return true;
 514 }
 515
 516 void BattleGroundEY::Reset()
 517 {
 518     //call parent's class reset
 519     BattleGround::Reset();
 520
 521     m_TeamScores[BG_TEAM_ALLIANCE] = 0;
 522     m_TeamScores[BG_TEAM_HORDE] = 0;
 523     m_TeamPointsCount[BG_TEAM_ALLIANCE] = 0;
 524     m_TeamPointsCount[BG_TEAM_HORDE] = 0;
 525     m_HonorScoreTics[BG_TEAM_ALLIANCE] = 0;
 526     m_HonorScoreTics[BG_TEAM_HORDE] = 0;
 527     m_FlagState = BG_EY_FLAG_STATE_ON_BASE;
 528     m_FlagCapturedBgObjectType = 0;
 529     m_FlagKeeper = 0;
 530     m_DroppedFlagGUID = 0;
 531     m_PointAddingTimer = 0;
 532     m_TowerCapCheckTimer = 0;
 533
 534     for(uint8 i = 0; i < EY_POINTS_MAX; ++i)
 535     {
 536         m_PointOwnedByTeam[i] = EY_POINT_NO_OWNER;
 537         m_PointState[i] = EY_POINT_STATE_UNCONTROLLED;
 538         m_PointBarStatus[i] = BG_EY_PROGRESS_BAR_STATE_MIDDLE;
 539         m_PlayersNearPoint[i].clear();
 540         m_PlayersNearPoint[i].reserve(15);                  //tip size
 541     }
 542     m_PlayersNearPoint[EY_PLAYERS_OUT_OF_POINTS].clear();
 543     m_PlayersNearPoint[EY_PLAYERS_OUT_OF_POINTS].reserve(30);
 544 }
 545
 546 void BattleGroundEY::RespawnFlag(bool send_message)
 547 {
 548     if (m_FlagCapturedBgObjectType > 0)
 549         SpawnBGObject(m_FlagCapturedBgObjectType, RESPAWN_ONE_DAY);
 550
 551     m_FlagCapturedBgObjectType = 0;
 552     m_FlagState = BG_EY_FLAG_STATE_ON_BASE;
 553     SpawnBGObject(BG_EY_OBJECT_FLAG_NETHERSTORM, RESPAWN_IMMEDIATELY);
 554
 555     if(send_message)
 556     {
 557         SendMessageToAll(GetMangosString(LANG_BG_EY_RESETED_FLAG));
 558         PlaySoundToAll(BG_EY_SOUND_FLAG_RESET);             // flags respawned sound...
 559     }
 560
 561     UpdateWorldState(NETHERSTORM_FLAG, 1);
 562 }
 563
 564 void BattleGroundEY::RespawnFlagAfterDrop()
 565 {
 566     RespawnFlag(true);
 567
 568     GameObject *obj = HashMapHolder<GameObject>::Find(GetDroppedFlagGUID());
 569     if(obj)
 570         obj->Delete();
 571     else
 572         sLog.outError("BattleGroundEY: Unknown dropped flag guid: %u",GUID_LOPART(GetDroppedFlagGUID()));
 573
 574     SetDroppedFlagGUID(0);
 575 }
 576
 577 void BattleGroundEY::HandleKillPlayer(Player *player, Player *killer)
 578 {
 579     if(GetStatus() != STATUS_IN_PROGRESS)
 580         return;
 581
 582     BattleGround::HandleKillPlayer(player, killer);
 583     EventPlayerDroppedFlag(player);
 584 }
 585
 586 void BattleGroundEY::EventPlayerDroppedFlag(Player *Source)
 587 {
 588     if(GetStatus() != STATUS_IN_PROGRESS)
 589     {
 590         // if not running, do not cast things at the dropper player, neither send unnecessary messages
 591         // just take off the aura
 592         if(IsFlagPickedup() && GetFlagPickerGUID() == Source->GetGUID())
 593         {
 594             SetFlagPicker(0);
 595             Source->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
 596         }
 597         return;
 598     }
 599
 600     if(!IsFlagPickedup())
 601         return;
 602
 603     if(GetFlagPickerGUID() != Source->GetGUID())
 604         return;
 605
 606     const char *message = "";
 607     uint8 type = 0;
 608
 609     SetFlagPicker(0);
 610     Source->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
 611     m_FlagState = BG_EY_FLAG_STATE_ON_GROUND;
 612     m_FlagsTimer = BG_EY_FLAG_RESPAWN_TIME;
 613     Source->CastSpell(Source, SPELL_RECENTLY_DROPPED_FLAG, true);
 614     Source->CastSpell(Source, BG_EY_PLAYER_DROPPED_FLAG_SPELL, true);
 615     if(Source->GetTeam() == ALLIANCE)
 616     {
 617         message = GetMangosString(LANG_BG_EY_DROPPED_FLAG);
 618         type = CHAT_MSG_BG_SYSTEM_ALLIANCE;
 619     }
 620     else
 621     {
 622         message = GetMangosString(LANG_BG_EY_DROPPED_FLAG);
 623         type = CHAT_MSG_BG_SYSTEM_HORDE;
 624     }
 625     //this does not work correctly :( (it should remove flag carrier name)
 626     UpdateWorldState(NETHERSTORM_FLAG_STATE_HORDE, BG_EY_FLAG_STATE_WAIT_RESPAWN);
 627     UpdateWorldState(NETHERSTORM_FLAG_STATE_ALLIANCE, BG_EY_FLAG_STATE_WAIT_RESPAWN);
 628
 629     WorldPacket data;
 630     ChatHandler::FillMessageData(&data, Source->GetSession(), type, LANG_UNIVERSAL, NULL, Source->GetGUID(), message, NULL);
 631     SendPacketToAll(&data);
 632 }
 633
 634 void BattleGroundEY::EventPlayerClickedOnFlag(Player *Source, GameObject* target_obj)
 635 {
 636     if(GetStatus() != STATUS_IN_PROGRESS || IsFlagPickedup() || !Source->IsWithinDistInMap(target_obj, 10))
 637         return;
 638
 639     const char *message;
 640     uint8 type = 0;
 641     message = GetMangosString(LANG_BG_EY_HAS_TAKEN_FLAG);
 642
 643     if(Source->GetTeam() == ALLIANCE)
 644     {
 645         UpdateWorldState(NETHERSTORM_FLAG_STATE_ALLIANCE, BG_EY_FLAG_STATE_ON_PLAYER);
 646         type = CHAT_MSG_BG_SYSTEM_ALLIANCE;
 647         PlaySoundToAll(BG_EY_SOUND_FLAG_PICKED_UP_ALLIANCE);
 648     }
 649     else
 650     {
 651         UpdateWorldState(NETHERSTORM_FLAG_STATE_HORDE, BG_EY_FLAG_STATE_ON_PLAYER);
 652         type = CHAT_MSG_BG_SYSTEM_HORDE;
 653         PlaySoundToAll(BG_EY_SOUND_FLAG_PICKED_UP_HORDE);
 654     }
 655
 656     if (m_FlagState == BG_EY_FLAG_STATE_ON_BASE)
 657         UpdateWorldState(NETHERSTORM_FLAG, 0);
 658     m_FlagState = BG_EY_FLAG_STATE_ON_PLAYER;
 659
 660     SpawnBGObject(BG_EY_OBJECT_FLAG_NETHERSTORM, RESPAWN_ONE_DAY);
 661     SetFlagPicker(Source->GetGUID());
 662     //get flag aura on player
 663     Source->CastSpell(Source, BG_EY_NETHERSTORM_FLAG_SPELL, true);
 664     Source->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 665
 666     WorldPacket data;
 667     ChatHandler::FillMessageData(&data, Source->GetSession(), type, LANG_UNIVERSAL, NULL, Source->GetGUID(), message, NULL);
 668     SendPacketToAll(&data);
 669 }
 670
 671 void BattleGroundEY::EventTeamLostPoint(Player *Source, uint32 Point)
 672 {
 673     if(GetStatus() != STATUS_IN_PROGRESS)
 674         return;
 675
 676     //Natural point
 677     uint8 message_type = 0;
 678     const char *message = "";
 679     uint32 Team = m_PointOwnedByTeam[Point];
 680
 681     if(!Team)
 682         return;
 683
 684     if (Team == ALLIANCE)
 685     {
 686         m_TeamPointsCount[BG_TEAM_ALLIANCE]--;
 687         message_type = CHAT_MSG_BG_SYSTEM_ALLIANCE;
 688         message = GetMangosString(m_LoosingPointTypes[Point].MessageIdAlliance);
 689         SpawnBGObject(m_LoosingPointTypes[Point].DespawnObjectTypeAlliance, RESPAWN_ONE_DAY);
 690         SpawnBGObject(m_LoosingPointTypes[Point].DespawnObjectTypeAlliance + 1, RESPAWN_ONE_DAY);
 691         SpawnBGObject(m_LoosingPointTypes[Point].DespawnObjectTypeAlliance + 2, RESPAWN_ONE_DAY);
 692     }
 693     else
 694     {
 695         m_TeamPointsCount[BG_TEAM_HORDE]--;
 696         message_type = CHAT_MSG_BG_SYSTEM_HORDE;
 697         message = GetMangosString(m_LoosingPointTypes[Point].MessageIdHorde);
 698         SpawnBGObject(m_LoosingPointTypes[Point].DespawnObjectTypeHorde, RESPAWN_ONE_DAY);
 699         SpawnBGObject(m_LoosingPointTypes[Point].DespawnObjectTypeHorde + 1, RESPAWN_ONE_DAY);
 700         SpawnBGObject(m_LoosingPointTypes[Point].DespawnObjectTypeHorde + 2, RESPAWN_ONE_DAY);
 701     }
 702
 703     SpawnBGObject(m_LoosingPointTypes[Point].SpawnNeutralObjectType, RESPAWN_IMMEDIATELY);
 704     SpawnBGObject(m_LoosingPointTypes[Point].SpawnNeutralObjectType + 1, RESPAWN_IMMEDIATELY);
 705     SpawnBGObject(m_LoosingPointTypes[Point].SpawnNeutralObjectType + 2, RESPAWN_IMMEDIATELY);
 706
 707     //buff isn't despawned
 708
 709     m_PointOwnedByTeam[Point] = EY_POINT_NO_OWNER;
 710     m_PointState[Point] = EY_POINT_NO_OWNER;
 711
 712     WorldPacket data;
 713     ChatHandler::FillMessageData(&data, Source->GetSession(), message_type, LANG_UNIVERSAL, NULL, Source->GetGUID(), message, NULL);
 714     SendPacketToAll(&data);
 715
 716     UpdatePointsIcons(Team, Point);
 717     UpdatePointsCount(Team);
 718 }
 719
 720 void BattleGroundEY::EventTeamCapturedPoint(Player *Source, uint32 Point)
 721 {
 722     if(GetStatus() != STATUS_IN_PROGRESS)
 723         return;
 724
 725     uint8 type = 0;
 726     const char *message = "";
 727     uint32 Team = Source->GetTeam();
 728
 729     SpawnBGObject(m_CapturingPointTypes[Point].DespawnNeutralObjectType, RESPAWN_ONE_DAY);
 730     SpawnBGObject(m_CapturingPointTypes[Point].DespawnNeutralObjectType + 1, RESPAWN_ONE_DAY);
 731     SpawnBGObject(m_CapturingPointTypes[Point].DespawnNeutralObjectType + 2, RESPAWN_ONE_DAY);
 732
 733     if (Team == ALLIANCE)
 734     {
 735         m_TeamPointsCount[BG_TEAM_ALLIANCE]++;
 736         type = CHAT_MSG_BG_SYSTEM_ALLIANCE;
 737         message = GetMangosString(m_CapturingPointTypes[Point].MessageIdAlliance);
 738         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeAlliance, RESPAWN_IMMEDIATELY);
 739         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeAlliance + 1, RESPAWN_IMMEDIATELY);
 740         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeAlliance + 2, RESPAWN_IMMEDIATELY);
 741     }
 742     else
 743     {
 744         m_TeamPointsCount[BG_TEAM_HORDE]++;
 745         type = CHAT_MSG_BG_SYSTEM_HORDE;
 746         message = GetMangosString(m_CapturingPointTypes[Point].MessageIdHorde);
 747         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeHorde, RESPAWN_IMMEDIATELY);
 748         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeHorde + 1, RESPAWN_IMMEDIATELY);
 749         SpawnBGObject(m_CapturingPointTypes[Point].SpawnObjectTypeHorde + 2, RESPAWN_IMMEDIATELY);
 750     }
 751
 752     //buff isn't respawned
 753
 754     m_PointOwnedByTeam[Point] = Team;
 755     m_PointState[Point] = EY_POINT_UNDER_CONTROL;
 756
 757     WorldPacket data;
 758     ChatHandler::FillMessageData(&data, Source->GetSession(), type, LANG_UNIVERSAL, NULL, Source->GetGUID(), message, NULL);
 759     SendPacketToAll(&data);
 760
 761     if(m_BgCreatures[Point])
 762         DelCreature(Point);
 763
 764     WorldSafeLocsEntry const *sg = NULL;
 765     sg = sWorldSafeLocsStore.LookupEntry(m_CapturingPointTypes[Point].GraveYardId);
 766     if(!sg || !AddSpiritGuide(Point, sg->x, sg->y, sg->z, 3.124139f, Team))
 767         sLog.outError("BatteGroundEY: Failed to spawn spirit guide! point: %u, team: %u, graveyard_id: %u",
 768             Point, Team, m_CapturingPointTypes[Point].GraveYardId);
 769
 770 //    SpawnBGCreature(Point,RESPAWN_IMMEDIATELY);
 771
 772     UpdatePointsIcons(Team, Point);
 773     UpdatePointsCount(Team);
 774 }
 775
 776 void BattleGroundEY::EventPlayerCapturedFlag(Player *Source, uint32 BgObjectType)
 777 {
 778     if(GetStatus() != STATUS_IN_PROGRESS || GetFlagPickerGUID() != Source->GetGUID())
 779         return;
 780
 781     uint8 type = 0;
 782     uint8 team_id = 0;
 783     const char *message = "";
 784
 785     SetFlagPicker(0);
 786     m_FlagState = BG_EY_FLAG_STATE_WAIT_RESPAWN;
 787     Source->RemoveAurasDueToSpell(BG_EY_NETHERSTORM_FLAG_SPELL);
 788
 789     Source->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);
 790     if(Source->GetTeam() == ALLIANCE)
 791     {
 792         PlaySoundToAll(BG_EY_SOUND_FLAG_CAPTURED_ALLIANCE);
 793         team_id = BG_TEAM_ALLIANCE;
 794         message = GetMangosString(LANG_BG_EY_CAPTURED_FLAG_A);
 795         type = CHAT_MSG_BG_SYSTEM_ALLIANCE;
 796     }
 797     else
 798     {
 799         PlaySoundToAll(BG_EY_SOUND_FLAG_CAPTURED_HORDE);
 800         team_id = BG_TEAM_HORDE;
 801         message = GetMangosString(LANG_BG_EY_CAPTURED_FLAG_H);
 802         type = CHAT_MSG_BG_SYSTEM_HORDE;
 803     }
 804
 805     SpawnBGObject(BgObjectType, RESPAWN_IMMEDIATELY);
 806
 807     m_FlagsTimer = BG_EY_FLAG_RESPAWN_TIME;
 808     m_FlagCapturedBgObjectType = BgObjectType;
 809
 810     WorldPacket data;
 811     ChatHandler::FillMessageData(&data, Source->GetSession(), type, LANG_UNIVERSAL, NULL, Source->GetGUID(), message, NULL);
 812     SendPacketToAll(&data);
 813
 814     if(m_TeamPointsCount[team_id] > 0)
 815         AddPoints(Source->GetTeam(), BG_EY_FlagPoints[m_TeamPointsCount[team_id] - 1]);
 816
 817     UpdatePlayerScore(Source, SCORE_FLAG_CAPTURES, 1);
 818 }
 819
 820 void BattleGroundEY::UpdatePlayerScore(Player *Source, uint32 type, uint32 value)
 821 {
 822     std::map<uint64, BattleGroundScore*>::iterator itr = m_PlayerScores.find(Source->GetGUID());
 823
 824     if(itr == m_PlayerScores.end())                         // player not found
 825         return;
 826
 827     switch(type)
 828     {
 829         case SCORE_FLAG_CAPTURES:                           // flags captured
 830             ((BattleGroundEYScore*)itr->second)->FlagCaptures += value;
 831             break;
 832         default:
 833             BattleGround::UpdatePlayerScore(Source, type, value);
 834             break;
 835     }
 836 }
 837
 838 void BattleGroundEY::FillInitialWorldStates(WorldPacket& data)
 839 {
 840     data << uint32(EY_HORDE_BASE) << uint32(m_TeamPointsCount[BG_TEAM_HORDE]);
 841     data << uint32(EY_ALLIANCE_BASE) << uint32(m_TeamPointsCount[BG_TEAM_ALLIANCE]);
 842     data << uint32(0xab6) << uint32(0x0);
 843     data << uint32(0xab5) << uint32(0x0);
 844     data << uint32(0xab4) << uint32(0x0);
 845     data << uint32(0xab3) << uint32(0x0);
 846     data << uint32(0xab2) << uint32(0x0);
 847     data << uint32(0xab1) << uint32(0x0);
 848     data << uint32(0xab0) << uint32(0x0);
 849     data << uint32(0xaaf) << uint32(0x0);
 850
 851     data << uint32(DRAENEI_RUINS_HORDE_CONTROL)     << uint32(m_PointOwnedByTeam[DRAENEI_RUINS] == HORDE && m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL);
 852
 853     data << uint32(DRAENEI_RUINS_ALLIANCE_CONTROL)  << uint32(m_PointOwnedByTeam[DRAENEI_RUINS] == ALLIANCE && m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL);
 854
 855     data << uint32(DRAENEI_RUINS_UNCONTROL)         << uint32(m_PointState[DRAENEI_RUINS] != EY_POINT_UNDER_CONTROL);
 856
 857     data << uint32(MAGE_TOWER_ALLIANCE_CONTROL)     << uint32(m_PointOwnedByTeam[MAGE_TOWER] == ALLIANCE && m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL);
 858
 859     data << uint32(MAGE_TOWER_HORDE_CONTROL)        << uint32(m_PointOwnedByTeam[MAGE_TOWER] == HORDE && m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL);
 860
 861     data << uint32(MAGE_TOWER_UNCONTROL)            << uint32(m_PointState[MAGE_TOWER] != EY_POINT_UNDER_CONTROL);
 862
 863     data << uint32(FEL_REAVER_HORDE_CONTROL)        << uint32(m_PointOwnedByTeam[FEL_REALVER] == HORDE && m_PointState[FEL_REALVER] == EY_POINT_UNDER_CONTROL);
 864
 865     data << uint32(FEL_REAVER_ALLIANCE_CONTROL)     << uint32(m_PointOwnedByTeam[FEL_REALVER] == ALLIANCE && m_PointState[FEL_REALVER] == EY_POINT_UNDER_CONTROL);
 866
 867     data << uint32(FEL_REAVER_UNCONTROL)            << uint32(m_PointState[FEL_REALVER] != EY_POINT_UNDER_CONTROL);
 868
 869     data << uint32(BLOOD_ELF_HORDE_CONTROL)         << uint32(m_PointOwnedByTeam[BLOOD_ELF] == HORDE && m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL);
 870
 871     data << uint32(BLOOD_ELF_ALLIANCE_CONTROL)      << uint32(m_PointOwnedByTeam[BLOOD_ELF] == ALLIANCE && m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL);
 872
 873     data << uint32(BLOOD_ELF_UNCONTROL)             << uint32(m_PointState[BLOOD_ELF] != EY_POINT_UNDER_CONTROL);
 874
 875     data << uint32(NETHERSTORM_FLAG)                << uint32(m_FlagState == BG_EY_FLAG_STATE_ON_BASE);
 876
 877     data << uint32(0xad2) << uint32(0x1);
 878     data << uint32(0xad1) << uint32(0x1);
 879     data << uint32(0xabe) << uint32(GetTeamScore(HORDE));
 880     data << uint32(0xabd) << uint32(GetTeamScore(ALLIANCE));
 881     data << uint32(0xa05) << uint32(0x8e);
 882     data << uint32(0xaa0) << uint32(0x0);
 883     data << uint32(0xa9f) << uint32(0x0);
 884     data << uint32(0xa9e) << uint32(0x0);
 885     data << uint32(0xc0d) << uint32(0x17b);
 886 }
 887
 888 WorldSafeLocsEntry const *BattleGroundEY::GetClosestGraveYard(float x, float y, float z, uint32 team)
 889 {
 890     uint32 g_id = 0;
 891
 892     if(team == ALLIANCE)
 893         g_id = EY_GRAVEYARD_MAIN_ALLIANCE;
 894     else if(team == HORDE)
 895         g_id = EY_GRAVEYARD_MAIN_HORDE;
 896     else
 897         return NULL;
 898
 899     float distance, nearestDistance;
 900
 901     WorldSafeLocsEntry const* entry = NULL;
 902     WorldSafeLocsEntry const* nearestEntry = NULL;
 903     entry = sWorldSafeLocsStore.LookupEntry(g_id);
 904     nearestEntry = entry;
 905
 906     if(!entry)
 907     {
 908         sLog.outError("BattleGroundEY: Not found the main team graveyard. Graveyard system isn't working!");
 909         return NULL;
 910     }
 911
 912     distance = (entry->x - x)*(entry->x - x) + (entry->y - y)*(entry->y - y) + (entry->z - z)*(entry->z - z);
 913     nearestDistance = distance;
 914
 915     for(uint8 i = 0; i < EY_POINTS_MAX; ++i)
 916     {
 917         if(m_PointOwnedByTeam[i]==team && m_PointState[i]==EY_POINT_UNDER_CONTROL)
 918         {
 919             entry = sWorldSafeLocsStore.LookupEntry(m_CapturingPointTypes[i].GraveYardId);
 920             if(!entry)
 921                 sLog.outError("BattleGroundEY: Not found graveyard: %u",m_CapturingPointTypes[i].GraveYardId);
 922             else
 923             {
 924                 distance = (entry->x - x)*(entry->x - x) + (entry->y - y)*(entry->y - y) + (entry->z - z)*(entry->z - z);
 925                 if(distance < nearestDistance)
 926                 {
 927                     nearestDistance = distance;
 928                     nearestEntry = entry;
 929                 }
 930             }
 931         }
 932     }
 933
 934     return nearestEntry;
 935 }