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