src/game/BattleGroundHandler.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 "Common.h"
  20 #include "WorldPacket.h"
  21 #include "Opcodes.h"
  22 #include "Log.h"
  23 #include "Player.h"
  24 #include "ObjectMgr.h"
  25 #include "WorldSession.h"
  26 #include "MapManager.h"
  27 #include "ObjectAccessor.h"
  28 #include "Object.h"
  29 #include "Chat.h"
  30 #include "BattleGroundMgr.h"
  31 #include "BattleGroundWS.h"
  32 #include "BattleGround.h"
  33 #include "ArenaTeam.h"
  34 #include "Language.h"
  35
  36 void WorldSession::HandleBattleGroundHelloOpcode( WorldPacket & recv_data )
  37 {
  38     CHECK_PACKET_SIZE(recv_data, 8);
  39
  40     uint64 guid;
  41     recv_data >> guid;
  42     sLog.outDebug( "WORLD: Recvd CMSG_BATTLEMASTER_HELLO Message from: " I64FMT, guid);
  43
  44     Creature *unit = ObjectAccessor::GetCreature(*_player, guid);
  45     if(!unit)
  46         return;
  47
  48     if(!unit->isBattleMaster())                             // it's not battlemaster
  49         return;
  50
  51     // Stop the npc if moving
  52     unit->StopMoving();
  53
  54     BattleGroundTypeId bgTypeId = sBattleGroundMgr.GetBattleMasterBG(unit->GetEntry());
  55
  56     if(!_player->GetBGAccessByLevel(bgTypeId))
  57     {
  58                                                             // temp, must be gossip message...
  59         SendNotification(LANG_YOUR_BG_LEVEL_REQ_ERROR);
  60         return;
  61     }
  62
  63     SendBattlegGroundList(guid, bgTypeId);
  64 }
  65
  66 void WorldSession::SendBattlegGroundList( uint64 guid, BattleGroundTypeId bgTypeId )
  67 {
  68     WorldPacket data;
  69     sBattleGroundMgr.BuildBattleGroundListPacket(&data, guid, _player, bgTypeId);
  70     SendPacket( &data );
  71 }
  72
  73 void WorldSession::HandleBattleGroundJoinOpcode( WorldPacket & recv_data )
  74 {
  75     CHECK_PACKET_SIZE(recv_data, 8+4+4+1);
  76
  77     uint64 guid;
  78     uint32 bgTypeId_;
  79     uint32 instanceId;
  80     uint8 joinAsGroup;
  81     Group * grp;
  82
  83     recv_data >> guid;                                      // battlemaster guid
  84     recv_data >> bgTypeId_;                                 // battleground type id (DBC id)
  85     recv_data >> instanceId;                                // instance id, 0 if First Available selected
  86     recv_data >> joinAsGroup;                               // join as group
  87
  88     if(!sBattlemasterListStore.LookupEntry(bgTypeId_))
  89     {
  90         sLog.outError("Battleground: invalid bgtype (%u) received. possible cheater? player guid %u",bgTypeId_,_player->GetGUIDLow());
  91         return;
  92     }
  93
  94     BattleGroundTypeId bgTypeId = BattleGroundTypeId(bgTypeId_);
  95
  96     sLog.outDebug( "WORLD: Recvd CMSG_BATTLEMASTER_JOIN Message from: " I64FMT, guid);
  97
  98     // can do this, since it's battleground, not arena
  99     BattleGroundQueueTypeId bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(bgTypeId, 0);
 100
 101     // ignore if player is already in BG
 102     if(_player->InBattleGround())
 103         return;
 104
 105     Creature *unit = ObjectAccessor::GetCreature(*_player, guid);
 106     if(!unit)
 107         return;
 108
 109     if(!unit->isBattleMaster())                             // it's not battlemaster
 110         return;
 111
 112     // get bg instance or bg template if instance not found
 113     BattleGround * bg = 0;
 114     if(instanceId)
 115         BattleGround *bg = sBattleGroundMgr.GetBattleGround(instanceId);
 116
 117     if(!bg && !(bg = sBattleGroundMgr.GetBattleGroundTemplate(bgTypeId)))
 118     {
 119         sLog.outError("Battleground: no available bg / template found");
 120         return;
 121     }
 122
 123     // check queueing conditions
 124     if(!joinAsGroup)
 125     {
 126         // check Deserter debuff
 127         if( !_player->CanJoinToBattleground() )
 128         {
 129             WorldPacket data(SMSG_GROUP_JOINED_BATTLEGROUND, 4);
 130             data << (uint32) 0xFFFFFFFE;
 131             _player->GetSession()->SendPacket(&data);
 132             return;
 133         }
 134         // check if already in queue
 135         if (_player->GetBattleGroundQueueIndex(bgQueueTypeId) < PLAYER_MAX_BATTLEGROUND_QUEUES)
 136             //player is already in this queue
 137             return;
 138         // check if has free queue slots
 139         if(!_player->HasFreeBattleGroundQueueId())
 140             return;
 141     }
 142     else
 143     {
 144         grp = _player->GetGroup();
 145         // no group found, error
 146         if(!grp)
 147             return;
 148         uint32 err = grp->CanJoinBattleGroundQueue(bgTypeId, bgQueueTypeId, 0, bg->GetMaxPlayersPerTeam(), false, 0);
 149         if (err != BG_JOIN_ERR_OK)
 150         {
 151             SendBattleGroundOrArenaJoinError(err);
 152             return;
 153         }
 154     }
 155     // if we're here, then the conditions to join a bg are met. We can proceed in joining.
 156
 157     // _player->GetGroup() was already checked, grp is already initialized
 158     if(joinAsGroup /* && _player->GetGroup()*/)
 159     {
 160         sLog.outDebug("Battleground: the following players are joining as group:");
 161         GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, 0, false, 0);
 162         for(GroupReference *itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
 163         {
 164             Player *member = itr->getSource();
 165             if(!member) continue;   // this should never happen
 166
 167             uint32 queueSlot = member->AddBattleGroundQueueId(bgQueueTypeId);           // add to queue
 168
 169             // store entry point coords (same as leader entry point)
 170             member->SetBattleGroundEntryPoint(_player->GetMapId(),_player->GetPositionX(),_player->GetPositionY(),_player->GetPositionZ(),_player->GetOrientation());
 171
 172             WorldPacket data;
 173                                                             // send status packet (in queue)
 174             sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, member->GetTeam(), queueSlot, STATUS_WAIT_QUEUE, 0, 0);
 175             member->GetSession()->SendPacket(&data);
 176             sBattleGroundMgr.BuildGroupJoinedBattlegroundPacket(&data, bgTypeId);
 177             member->GetSession()->SendPacket(&data);
 178             sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddPlayer(member, ginfo);
 179             sLog.outDebug("Battleground: player joined queue for bg queue type %u bg type %u: GUID %u, NAME %s",bgQueueTypeId,bgTypeId,member->GetGUIDLow(), member->GetName());
 180         }
 181         sLog.outDebug("Battleground: group end");
 182         sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].Update(bgTypeId, _player->GetBattleGroundQueueIdFromLevel(bgTypeId));
 183         if(!ginfo->IsInvitedToBGInstanceGUID)
 184             sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AnnounceWorld(ginfo, _player->GetGUID(), true);
 185     }
 186     else
 187     {
 188         // already checked if queueSlot is valid, now just get it
 189         uint32 queueSlot = _player->AddBattleGroundQueueId(bgQueueTypeId);
 190         // store entry point coords
 191         _player->SetBattleGroundEntryPoint(_player->GetMapId(),_player->GetPositionX(),_player->GetPositionY(),_player->GetPositionZ(),_player->GetOrientation());
 192
 193         WorldPacket data;
 194                                                             // send status packet (in queue)
 195         sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, _player->GetTeam(), queueSlot, STATUS_WAIT_QUEUE, 0, 0);
 196         SendPacket(&data);
 197
 198         GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, 0, false, 0);
 199         sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddPlayer(_player, ginfo);
 200         sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].Update(bgTypeId, _player->GetBattleGroundQueueIdFromLevel(bgTypeId));
 201         if(!ginfo->IsInvitedToBGInstanceGUID)
 202             sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AnnounceWorld(ginfo, _player->GetGUID(), true);
 203         sLog.outDebug("Battleground: player joined queue for bg queue type %u bg type %u: GUID %u, NAME %s",bgQueueTypeId,bgTypeId,_player->GetGUIDLow(), _player->GetName());
 204     }
 205 }
 206
 207 void WorldSession::HandleBattleGroundPlayerPositionsOpcode( WorldPacket & /*recv_data*/ )
 208 {
 209                                                             // empty opcode
 210     sLog.outDebug("WORLD: Recvd MSG_BATTLEGROUND_PLAYER_POSITIONS Message");
 211
 212     BattleGround *bg = _player->GetBattleGround();
 213     if(!bg)                                                 // can't be received if player not in battleground
 214         return;
 215
 216     if(bg->GetTypeID() == BATTLEGROUND_WS)
 217     {
 218         uint32 count1 = 0;
 219         uint32 count2 = 0;
 220
 221         Player *ap = objmgr.GetPlayer(((BattleGroundWS*)bg)->GetAllianceFlagPickerGUID());
 222         if(ap) ++count2;
 223
 224         Player *hp = objmgr.GetPlayer(((BattleGroundWS*)bg)->GetHordeFlagPickerGUID());
 225         if(hp) ++count2;
 226
 227         WorldPacket data(MSG_BATTLEGROUND_PLAYER_POSITIONS, (4+4+16*count1+16*count2));
 228         data << count1;                                     // alliance flag holders count
 229         /*for(uint8 i = 0; i < count1; i++)
 230         {
 231             data << uint64(0);                              // guid
 232             data << (float)0;                               // x
 233             data << (float)0;                               // y
 234         }*/
 235         data << count2;                                     // horde flag holders count
 236         if(ap)
 237         {
 238             data << (uint64)ap->GetGUID();
 239             data << (float)ap->GetPositionX();
 240             data << (float)ap->GetPositionY();
 241         }
 242         if(hp)
 243         {
 244             data << (uint64)hp->GetGUID();
 245             data << (float)hp->GetPositionX();
 246             data << (float)hp->GetPositionY();
 247         }
 248
 249         SendPacket(&data);
 250     }
 251 }
 252
 253 void WorldSession::HandleBattleGroundPVPlogdataOpcode( WorldPacket & /*recv_data*/ )
 254 {
 255     sLog.outDebug( "WORLD: Recvd MSG_PVP_LOG_DATA Message");
 256
 257     BattleGround *bg = _player->GetBattleGround();
 258     if(!bg)
 259         return;
 260
 261     WorldPacket data;
 262     sBattleGroundMgr.BuildPvpLogDataPacket(&data, bg);
 263     SendPacket(&data);
 264
 265     sLog.outDebug( "WORLD: Sent MSG_PVP_LOG_DATA Message");
 266 }
 267
 268 void WorldSession::HandleBattleGroundListOpcode( WorldPacket &recv_data )
 269 {
 270     CHECK_PACKET_SIZE(recv_data, 4);
 271
 272     sLog.outDebug( "WORLD: Recvd CMSG_BATTLEFIELD_LIST Message");
 273
 274     uint32 bgTypeId;
 275     recv_data >> bgTypeId;                                  // id from DBC
 276
 277     BattlemasterListEntry const* bl = sBattlemasterListStore.LookupEntry(bgTypeId);
 278     if(!bl)
 279     {
 280         sLog.outError("Battleground: invalid bgtype received.");
 281         return;
 282     }
 283
 284     WorldPacket data;
 285     sBattleGroundMgr.BuildBattleGroundListPacket(&data, _player->GetGUID(), _player, BattleGroundTypeId(bgTypeId));
 286     SendPacket( &data );
 287 }
 288
 289 void WorldSession::HandleBattleGroundPlayerPortOpcode( WorldPacket &recv_data )
 290 {
 291     CHECK_PACKET_SIZE(recv_data, 1+1+4+2+1);
 292
 293     sLog.outDebug( "WORLD: Recvd CMSG_BATTLEFIELD_PORT Message");
 294
 295     uint8 type;                                             // arenatype if arena
 296     uint8 unk2;                                             // unk, can be 0x0 (may be if was invited?) and 0x1
 297     uint32 instanceId;
 298     uint32 bgTypeId_;                                       // type id from dbc
 299     uint16 unk;                                             // 0x1F90 constant?
 300     uint8 action;                                           // enter battle 0x1, leave queue 0x0
 301
 302     recv_data >> type >> unk2 >> bgTypeId_ >> unk >> action;
 303
 304     if(!sBattlemasterListStore.LookupEntry(bgTypeId_))
 305     {
 306         sLog.outError("Battleground: invalid bgtype (%u) received.",bgTypeId_);
 307         // update battleground slots for the player to fix his UI and sent data.
 308         // this is a HACK, I don't know why the client starts sending invalid packets in the first place.
 309         // it usually happens with extremely high latency (if debugging / stepping in the code for example)
 310         if(_player->InBattleGroundQueue())
 311         {
 312             // update all queues, send invitation info if player is invited, queue info if queued
 313             for (uint32 i = 0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
 314             {
 315                 BattleGroundQueueTypeId bgQueueTypeId = _player->GetBattleGroundQueueTypeId(i);
 316                 if(!bgQueueTypeId)
 317                     continue;
 318                 BattleGroundTypeId bgTypeId = BattleGroundMgr::BGTemplateId(bgQueueTypeId);
 319                 uint32 queue_id = _player->GetBattleGroundQueueIdFromLevel(bgTypeId);
 320                 BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers[queue_id];
 321                 BattleGroundQueue::QueuedPlayersMap::iterator itrPlayerStatus = qpMap.find(_player->GetGUID());
 322                 // if the player is not in queue, continue
 323                 if(itrPlayerStatus == qpMap.end())
 324                     continue;
 325
 326                 // no group information, this should never happen
 327                 if(!itrPlayerStatus->second.GroupInfo)
 328                     continue;
 329
 330                 BattleGround * bg = NULL;
 331
 332                 // get possibly needed data from groupinfo
 333                 uint8 arenatype = itrPlayerStatus->second.GroupInfo->ArenaType;
 334                 uint8 israted = itrPlayerStatus->second.GroupInfo->IsRated;
 335                 uint8 status = 0;
 336
 337
 338                 if(!itrPlayerStatus->second.GroupInfo->IsInvitedToBGInstanceGUID)
 339                 {
 340                     // not invited to bg, get template
 341                     bg = sBattleGroundMgr.GetBattleGroundTemplate(bgTypeId);
 342                     status = STATUS_WAIT_QUEUE;
 343                 }
 344                 else
 345                 {
 346                     // get the bg we're invited to
 347                     BattleGround * bg = sBattleGroundMgr.GetBattleGround(itrPlayerStatus->second.GroupInfo->IsInvitedToBGInstanceGUID);
 348                     status = STATUS_WAIT_JOIN;
 349                 }
 350
 351                 // if bg not found, then continue
 352                 if(!bg)
 353                     continue;
 354
 355                 // don't invite if already in the instance
 356                 if(_player->InBattleGround() && _player->GetBattleGround() && _player->GetBattleGround()->GetInstanceID() == bg->GetInstanceID())
 357                     continue;
 358
 359                 // re - invite player with proper data
 360                 WorldPacket data;
 361                 sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, itrPlayerStatus->second.GroupInfo->Team?itrPlayerStatus->second.GroupInfo->Team:_player->GetTeam(), i, status, INVITE_ACCEPT_WAIT_TIME, 0, arenatype, israted);
 362                 SendPacket(&data);
 363             }
 364         }
 365         return;
 366     }
 367
 368     BattleGroundTypeId bgTypeId = BattleGroundTypeId(bgTypeId_);
 369
 370     BattleGroundQueueTypeId bgQueueTypeId = BATTLEGROUND_QUEUE_NONE;
 371     // get the bg what we were invited to
 372     bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(bgTypeId,type);
 373     BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers[_player->GetBattleGroundQueueIdFromLevel(bgTypeId)];
 374     BattleGroundQueue::QueuedPlayersMap::iterator itrPlayerStatus = qpMap.find(_player->GetGUID());
 375     if(itrPlayerStatus == qpMap.end())
 376     {
 377         sLog.outError("Battleground: itrplayerstatus not found.");
 378         return;
 379     }
 380     instanceId = itrPlayerStatus->second.GroupInfo->IsInvitedToBGInstanceGUID;
 381
 382     // if action == 1, then instanceId is _required_
 383     if(!instanceId && action == 1)
 384     {
 385         sLog.outError("Battleground: instance not found.");
 386         return;
 387     }
 388
 389     BattleGround *bg = sBattleGroundMgr.GetBattleGround(instanceId);
 390
 391     // bg template might and must be used in case of leaving queue, when instance is not created yet
 392     if(!bg && action == 0)
 393         bg = sBattleGroundMgr.GetBattleGroundTemplate(bgTypeId);
 394
 395     if(!bg)
 396     {
 397         sLog.outError("Battleground: bg not found for type id %u.",bgTypeId);
 398         return;
 399     }
 400
 401     bgTypeId = bg->GetTypeID();
 402
 403     if(_player->InBattleGroundQueue())
 404     {
 405         uint32 queueSlot = 0;
 406         uint32 team = 0;
 407         uint32 arenatype = 0;
 408         uint32 israted = 0;
 409         uint32 rating = 0;
 410         uint32 opponentsRating = 0;
 411         // get the team info from the queue
 412
 413         BattleGroundQueue::QueuedPlayersMap& qpMap2 = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers[_player->GetBattleGroundQueueIdFromLevel(bgTypeId)];
 414         BattleGroundQueue::QueuedPlayersMap::iterator pitr = qpMap2.find(_player->GetGUID());
 415         if (pitr !=qpMap2.end() && pitr->second.GroupInfo)
 416         {
 417             team = pitr->second.GroupInfo->Team;
 418             arenatype = pitr->second.GroupInfo->ArenaType;
 419             israted = pitr->second.GroupInfo->IsRated;
 420             rating = pitr->second.GroupInfo->ArenaTeamRating;
 421             opponentsRating = pitr->second.GroupInfo->OpponentsTeamRating;
 422         }
 423         else
 424         {
 425             sLog.outError("Battleground: Invalid player queue info!");
 426             return;
 427         }
 428         WorldPacket data;
 429         switch(action)
 430         {
 431             case 1:                                     // port to battleground
 432                 if(!_player->IsInvitedForBattleGroundQueueType(bgQueueTypeId))
 433                     return;                                     // cheating?
 434                 // resurrect the player
 435                 if(!_player->isAlive())
 436                 {
 437                     _player->ResurrectPlayer(1.0f);
 438                     _player->SpawnCorpseBones();
 439                 }
 440                 // stop taxi flight at port
 441                 if(_player->isInFlight())
 442                 {
 443                     _player->GetMotionMaster()->MovementExpired();
 444                     _player->m_taxi.ClearTaxiDestinations();
 445                 }
 446                 _player->RemoveFromGroup();
 447                 queueSlot = _player->GetBattleGroundQueueIndex(bgQueueTypeId);
 448                 sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, _player->GetTeam(), queueSlot, STATUS_IN_PROGRESS, 0, bg->GetStartTime());
 449                 _player->GetSession()->SendPacket(&data);
 450                 // remove battleground queue status from BGmgr
 451                 sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].RemovePlayer(_player->GetGUID(), false);
 452                 // this is still needed here if battleground "jumping" shouldn't add deserter debuff
 453                 // also this required to prevent stuck at old battleground after SetBattleGroundId set to new
 454                 if( BattleGround *currentBg = _player->GetBattleGround() )
 455                     currentBg->RemovePlayerAtLeave(_player->GetGUID(), false, true);
 456
 457                 // set the destination instance id
 458                 _player->SetBattleGroundId(bg->GetInstanceID());
 459                 // set the destination team
 460                 _player->SetBGTeam(team);
 461                 // bg->HandleBeforeTeleportToBattleGround(_player);
 462                 sBattleGroundMgr.SendToBattleGround(_player, instanceId);
 463                 // add only in HandleMoveWorldPortAck()
 464                 // bg->AddPlayer(_player,team);
 465                 sLog.outDebug("Battleground: player %s (%u) joined battle for bg %u, bgtype %u, queue type %u.",_player->GetName(),_player->GetGUIDLow(),bg->GetInstanceID(),bg->GetTypeID(),bgQueueTypeId);
 466                 break;
 467             case 0:                                         // leave queue
 468                 queueSlot = _player->GetBattleGroundQueueIndex(bgQueueTypeId);
 469                 /*
 470                 if player leaves rated arena match before match start, it is counted as he played but he lost
 471                 */
 472                 if (israted)
 473                 {
 474                     ArenaTeam * at = objmgr.GetArenaTeamById(team);
 475                     if (at)
 476                     {
 477                         sLog.outDebug("UPDATING memberLost's personal arena rating for %u by opponents rating: %u, because he has left queue!", GUID_LOPART(_player->GetGUID()), opponentsRating);
 478                         at->MemberLost(_player, opponentsRating);
 479                         at->SaveToDB();
 480                     }
 481                 }
 482                 _player->RemoveBattleGroundQueueId(bgQueueTypeId); // must be called this way, because if you move this call to queue->removeplayer, it causes bugs
 483                 sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, _player->GetTeam(), queueSlot, STATUS_NONE, 0, 0);
 484                 sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].RemovePlayer(_player->GetGUID(), true);
 485                 // player left queue, we should update it, maybe now his group fits in
 486                 sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].Update(bgTypeId,_player->GetBattleGroundQueueIdFromLevel(bgTypeId),arenatype,israted,rating);
 487                 SendPacket(&data);
 488                 sLog.outDebug("Battleground: player %s (%u) left queue for bgtype %u, queue type %u.",_player->GetName(),_player->GetGUIDLow(),bg->GetTypeID(),bgQueueTypeId);
 489                 break;
 490             default:
 491                 sLog.outError("Battleground port: unknown action %u", action);
 492                 break;
 493         }
 494     }
 495 }
 496
 497 void WorldSession::HandleBattleGroundLeaveOpcode( WorldPacket & /*recv_data*/ )
 498 {
 499     //CHECK_PACKET_SIZE(recv_data, 1+1+4+2);
 500
 501     sLog.outDebug( "WORLD: Recvd CMSG_LEAVE_BATTLEFIELD Message");
 502
 503     //uint8 unk1, unk2;
 504     //uint32 bgTypeId;                                        // id from DBC
 505     //uint16 unk3;
 506
 507     //recv_data >> unk1 >> unk2 >> bgTypeId >> unk3; - no used currently
 508
 509     //if(bgTypeId >= MAX_BATTLEGROUND_TYPES)                  // cheating? but not important in this case
 510     //    return;
 511
 512     // not allow leave battleground in combat
 513     if(_player->isInCombat())
 514         if(BattleGround* bg = _player->GetBattleGround())
 515             if(bg->GetStatus() != STATUS_WAIT_LEAVE)
 516                 return;
 517
 518     _player->LeaveBattleground();
 519 }
 520
 521 void WorldSession::HandleBattlefieldStatusOpcode( WorldPacket & /*recv_data*/ )
 522 {
 523     // empty opcode
 524     sLog.outDebug( "WORLD: Battleground status" );
 525
 526     WorldPacket data;
 527
 528     // TODO: we must put player back to battleground in case disconnect (< 5 minutes offline time) or teleport player on login(!) from battleground map to entry point
 529     if(_player->InBattleGround())
 530     {
 531         BattleGround *bg = _player->GetBattleGround();
 532         if(bg)
 533         {
 534             BattleGroundQueueTypeId bgQueueTypeId_tmp = BattleGroundMgr::BGQueueTypeId(bg->GetTypeID(), bg->GetArenaType());
 535             uint32 queueSlot = _player->GetBattleGroundQueueIndex(bgQueueTypeId_tmp);
 536             if((bg->GetStatus() <= STATUS_IN_PROGRESS))
 537             {
 538                 sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, _player->GetTeam(), queueSlot, STATUS_IN_PROGRESS, 0, bg->GetStartTime());
 539                 SendPacket(&data);
 540             }
 541             for (uint32 i = 0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
 542             {
 543                 BattleGroundQueueTypeId bgQueueTypeId = _player->GetBattleGroundQueueTypeId(i);
 544                 if (i == queueSlot || !bgQueueTypeId)
 545                     continue;
 546                 BattleGroundTypeId bgTypeId = BattleGroundMgr::BGTemplateId(bgQueueTypeId);
 547                 uint8 arenatype = BattleGroundMgr::BGArenaType(bgQueueTypeId);
 548                 uint8 isRated = 0;
 549                 uint32 queue_id = _player->GetBattleGroundQueueIdFromLevel(bgTypeId);
 550                 BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers[queue_id];
 551                 BattleGroundQueue::QueuedPlayersMap::iterator itrPlayerStatus = qpMap.find(_player->GetGUID());
 552                 if(itrPlayerStatus == qpMap.end())
 553                     continue;
 554                 if(itrPlayerStatus->second.GroupInfo)
 555                 {
 556                     arenatype = itrPlayerStatus->second.GroupInfo->ArenaType;
 557                     isRated = itrPlayerStatus->second.GroupInfo->IsRated;
 558                 }
 559                 BattleGround *bg2 = sBattleGroundMgr.GetBattleGroundTemplate(bgTypeId);
 560                 if(bg2)
 561                 {
 562                     //in this call is small bug, this call should be filled by player's waiting time in queue
 563                     //this call nulls all timers for client :
 564                     sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg2, _player->GetTeam(), i, STATUS_WAIT_QUEUE, 0, 0,arenatype,isRated);
 565                     SendPacket(&data);
 566                 }
 567             }
 568         }
 569     }
 570     else
 571     {
 572         // we should update all queues? .. i'm not sure if this code is correct
 573         for (uint32 i = 0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
 574         {
 575             BattleGroundQueueTypeId bgQueueTypeId = _player->GetBattleGroundQueueTypeId(i);
 576             if(!bgQueueTypeId)
 577                 continue;
 578             BattleGroundTypeId bgTypeId = BattleGroundMgr::BGTemplateId(bgQueueTypeId);
 579             uint8 arenatype = BattleGroundMgr::BGArenaType(bgQueueTypeId);
 580             uint8 isRated = 0;
 581             uint32 queue_id = _player->GetBattleGroundQueueIdFromLevel(bgTypeId);
 582             BattleGround *bg = sBattleGroundMgr.GetBattleGroundTemplate(bgTypeId);
 583             BattleGroundQueue::QueuedPlayersMap& qpMap = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].m_QueuedPlayers[queue_id];
 584             BattleGroundQueue::QueuedPlayersMap::iterator itrPlayerStatus = qpMap.find(_player->GetGUID());
 585             if(itrPlayerStatus == qpMap.end())
 586                 continue;
 587             if(itrPlayerStatus->second.GroupInfo)
 588             {
 589                 arenatype = itrPlayerStatus->second.GroupInfo->ArenaType;
 590                 isRated = itrPlayerStatus->second.GroupInfo->IsRated;
 591             }
 592             if(bg)
 593             {
 594                 sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, _player->GetTeam(), i, STATUS_WAIT_QUEUE, 0, 0, arenatype, isRated);
 595                 SendPacket(&data);
 596             }
 597         }
 598     }
 599 /*    else              // not sure if it needed...
 600     {
 601         for (uint32 i = 0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; i++)
 602         {
 603             sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, NULL, _player->GetTeam(),i , STATUS_NONE, 0, 0);
 604             SendPacket(&data);
 605         }
 606     }*/
 607 }
 608
 609 void WorldSession::HandleAreaSpiritHealerQueryOpcode( WorldPacket & recv_data )
 610 {
 611     sLog.outDebug("WORLD: CMSG_AREA_SPIRIT_HEALER_QUERY");
 612
 613     CHECK_PACKET_SIZE(recv_data, 8);
 614
 615     BattleGround *bg = _player->GetBattleGround();
 616     if(!bg)
 617         return;
 618
 619     uint64 guid;
 620     recv_data >> guid;
 621
 622     Creature *unit = ObjectAccessor::GetCreature(*_player, guid);
 623     if(!unit)
 624         return;
 625
 626     if(!unit->isSpiritService())                            // it's not spirit service
 627         return;
 628
 629     sBattleGroundMgr.SendAreaSpiritHealerQueryOpcode(_player, bg, guid);
 630 }
 631
 632 void WorldSession::HandleAreaSpiritHealerQueueOpcode( WorldPacket & recv_data )
 633 {
 634     sLog.outDebug("WORLD: CMSG_AREA_SPIRIT_HEALER_QUEUE");
 635
 636     CHECK_PACKET_SIZE(recv_data, 8);
 637
 638     BattleGround *bg = _player->GetBattleGround();
 639     if(!bg)
 640         return;
 641
 642     uint64 guid;
 643     recv_data >> guid;
 644
 645     Creature *unit = ObjectAccessor::GetCreature(*_player, guid);
 646     if(!unit)
 647         return;
 648
 649     if(!unit->isSpiritService())                            // it's not spirit service
 650         return;
 651
 652     bg->AddPlayerToResurrectQueue(guid, _player->GetGUID());
 653 }
 654
 655 void WorldSession::HandleBattleGroundArenaJoin( WorldPacket & recv_data )
 656 {
 657     CHECK_PACKET_SIZE(recv_data, 8+1+1+1);
 658
 659     sLog.outDebug("WORLD: CMSG_BATTLEMASTER_JOIN_ARENA");
 660     recv_data.hexlike();
 661
 662     // ignore if we already in BG or BG queue
 663     if(_player->InBattleGround())
 664         return;
 665
 666     uint64 guid;                                            // arena Battlemaster guid
 667     uint8 arenaslot;                                        // 2v2, 3v3 or 5v5
 668     uint8 asGroup;                                          // asGroup
 669     uint8 isRated;                                          // isRated
 670     Group * grp;
 671
 672     recv_data >> guid >> arenaslot >> asGroup >> isRated;
 673
 674     Creature *unit = ObjectAccessor::GetCreature(*_player, guid);
 675     if(!unit)
 676         return;
 677
 678     if(!unit->isBattleMaster())                             // it's not battle master
 679         return;
 680
 681     uint8 arenatype = 0;
 682     uint32 arenaRating = 0;
 683
 684     switch(arenaslot)
 685     {
 686         case 0:
 687             arenatype = ARENA_TYPE_2v2;
 688             break;
 689         case 1:
 690             arenatype = ARENA_TYPE_3v3;
 691             break;
 692         case 2:
 693             arenatype = ARENA_TYPE_5v5;
 694             break;
 695         default:
 696             sLog.outError("Unknown arena slot %u at HandleBattleGroundArenaJoin()", arenaslot);
 697             return;
 698     }
 699
 700     //check existance
 701     BattleGround* bg = NULL;
 702     if( !(bg = sBattleGroundMgr.GetBattleGroundTemplate(BATTLEGROUND_AA)) )
 703     {
 704         sLog.outError("Battleground: template bg (all arenas) not found");
 705         return;
 706     }
 707
 708     BattleGroundTypeId bgTypeId = bg->GetTypeID();
 709     BattleGroundQueueTypeId bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(bgTypeId, arenatype);
 710
 711     // check queueing conditions
 712     if(!asGroup)
 713     {
 714         // check if already in queue
 715         if (_player->GetBattleGroundQueueIndex(bgQueueTypeId) < PLAYER_MAX_BATTLEGROUND_QUEUES)
 716             //player is already in this queue
 717             return;
 718         // check if has free queue slots
 719         if(!_player->HasFreeBattleGroundQueueId())
 720             return;
 721     }
 722     else
 723     {
 724         grp = _player->GetGroup();
 725         // no group found, error
 726         if(!grp)
 727             return;
 728         uint32 err = grp->CanJoinBattleGroundQueue(bgTypeId, bgQueueTypeId, arenatype, arenatype, (bool)isRated, arenaslot);
 729         if (err != BG_JOIN_ERR_OK)
 730         {
 731             SendBattleGroundOrArenaJoinError(err);
 732             return;
 733         }
 734     }
 735
 736     uint32 ateamId = 0;
 737
 738     if(isRated)
 739     {
 740         ateamId = _player->GetArenaTeamId(arenaslot);
 741         // check real arenateam existence only here (if it was moved to group->CanJoin .. () then we would ahve to get it twice)
 742         ArenaTeam * at = objmgr.GetArenaTeamById(ateamId);
 743         if(!at)
 744         {
 745             _player->GetSession()->SendNotInArenaTeamPacket(arenatype);
 746             return;
 747         }
 748         // get the team rating for queueing
 749         arenaRating = at->GetRating();
 750         // the arenateam id must match for everyone in the group
 751         // get the personal ratings for queueing
 752         uint32 avg_pers_rating = 0;
 753         for(GroupReference *itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
 754         {
 755             Player *member = itr->getSource();
 756
 757             // calc avg personal rating
 758             avg_pers_rating += member->GetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (arenaslot*6) + 5);
 759         }
 760
 761         if( arenatype )
 762             avg_pers_rating /= arenatype;
 763
 764         // if avg personal rating is more than 150 points below the teams rating, the team will be queued against an opponent matching or similar to the average personal rating
 765         if(avg_pers_rating + 150 < arenaRating)
 766             arenaRating = avg_pers_rating;
 767     }
 768
 769     if(asGroup)
 770     {
 771         GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, arenatype, isRated, arenaRating, ateamId);
 772         sLog.outDebug("Battleground: arena join as group start");
 773         if(isRated)
 774             sLog.outDebug("Battleground: arena team id %u, leader %s queued with rating %u for type %u",_player->GetArenaTeamId(arenaslot),_player->GetName(),arenaRating,arenatype);
 775         for(GroupReference *itr = grp->GetFirstMember(); itr != NULL; itr = itr->next())
 776         {
 777             Player *member = itr->getSource();
 778             if(!member) continue;
 779
 780             uint32 queueSlot = member->AddBattleGroundQueueId(bgQueueTypeId);// add to queue
 781
 782             // store entry point coords (same as leader entry point)
 783             member->SetBattleGroundEntryPoint(_player->GetMapId(),_player->GetPositionX(),_player->GetPositionY(),_player->GetPositionZ(),_player->GetOrientation());
 784
 785             WorldPacket data;
 786             // send status packet (in queue)
 787             sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, member->GetTeam(), queueSlot, STATUS_WAIT_QUEUE, 0, 0, arenatype, isRated);
 788             member->GetSession()->SendPacket(&data);
 789             sBattleGroundMgr.BuildGroupJoinedBattlegroundPacket(&data, bgTypeId);
 790             member->GetSession()->SendPacket(&data);
 791             sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddPlayer(member, ginfo);
 792             sLog.outDebug("Battleground: player joined queue for arena as group bg queue type %u bg type %u: GUID %u, NAME %s",bgQueueTypeId,bgTypeId,member->GetGUIDLow(), member->GetName());
 793         }
 794         sLog.outDebug("Battleground: arena join as group end");
 795         sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].Update(bgTypeId, _player->GetBattleGroundQueueIdFromLevel(bgTypeId), arenatype, isRated, arenaRating);
 796         if(isRated)
 797             sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AnnounceWorld(ginfo, _player->GetGUID(), true);
 798     }
 799     else
 800     {
 801         uint32 queueSlot = _player->AddBattleGroundQueueId(bgQueueTypeId);
 802
 803         // store entry point coords
 804         _player->SetBattleGroundEntryPoint(_player->GetMapId(),_player->GetPositionX(),_player->GetPositionY(),_player->GetPositionZ(),_player->GetOrientation());
 805
 806         WorldPacket data;
 807         // send status packet (in queue)
 808         sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, bg, _player->GetTeam(), queueSlot, STATUS_WAIT_QUEUE, 0, 0, arenatype, isRated);
 809         SendPacket(&data);
 810         GroupQueueInfo * ginfo = sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddGroup(_player, bgTypeId, arenatype, isRated, arenaRating);
 811         sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].AddPlayer(_player, ginfo);
 812         sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].Update(bgTypeId, _player->GetBattleGroundQueueIdFromLevel(bgTypeId), arenatype, isRated, arenaRating);
 813         sLog.outDebug("Battleground: player joined queue for arena, skirmish, bg queue type %u bg type %u: GUID %u, NAME %s",bgQueueTypeId,bgTypeId,_player->GetGUIDLow(), _player->GetName());
 814     }
 815 }
 816
 817 void WorldSession::HandleBattleGroundReportAFK( WorldPacket & recv_data )
 818 {
 819     CHECK_PACKET_SIZE(recv_data, 8);
 820
 821     uint64 playerGuid;
 822     recv_data >> playerGuid;
 823     Player *reportedPlayer = objmgr.GetPlayer(playerGuid);
 824
 825     if(!reportedPlayer)
 826     {
 827         sLog.outDebug("WorldSession::HandleBattleGroundReportAFK: player not found");
 828         return;
 829     }
 830
 831     sLog.outDebug("WorldSession::HandleBattleGroundReportAFK: %s reported %s", _player->GetName(), reportedPlayer->GetName());
 832
 833     reportedPlayer->ReportedAfkBy(_player);
 834 }
 835
 836 void WorldSession::SendBattleGroundOrArenaJoinError(uint8 err)
 837 {
 838     WorldPacket data;
 839     int32 msg;
 840     switch (err)
 841     {
 842         case BG_JOIN_ERR_OFFLINE_MEMBER:
 843             msg = LANG_BG_GROUP_OFFLINE_MEMBER;
 844             break;
 845         case BG_JOIN_ERR_GROUP_TOO_MANY:
 846             msg = LANG_BG_GROUP_TOO_LARGE;
 847             break;
 848         case BG_JOIN_ERR_MIXED_FACTION:
 849             msg = LANG_BG_GROUP_MIXED_FACTION;
 850             break;
 851         case BG_JOIN_ERR_MIXED_LEVELS:
 852             msg = LANG_BG_GROUP_MIXED_LEVELS;
 853             break;
 854         case BG_JOIN_ERR_GROUP_MEMBER_ALREADY_IN_QUEUE:
 855             msg = LANG_BG_GROUP_MEMBER_ALREADY_IN_QUEUE;
 856             break;
 857         case BG_JOIN_ERR_GROUP_DESERTER:
 858             msg = LANG_BG_GROUP_MEMBER_DESERTER;
 859             break;
 860         case BG_JOIN_ERR_ALL_QUEUES_USED:
 861             msg = LANG_BG_GROUP_MEMBER_NO_FREE_QUEUE_SLOTS;
 862             break;
 863         case BG_JOIN_ERR_GROUP_NOT_ENOUGH:
 864         case BG_JOIN_ERR_MIXED_ARENATEAM:
 865         default:
 866             return;
 867             break;
 868     }
 869     ChatHandler::FillMessageData(&data, NULL, CHAT_MSG_BG_SYSTEM_NEUTRAL, LANG_UNIVERSAL, NULL, 0, GetMangosString(msg), NULL);
 870     SendPacket(&data);
 871     return;
 872 }