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