src/game/GroupHandler.cpp

   1 /*
   2  * Copyright (C) 2005-2008 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 "Database/DatabaseEnv.h"
  21 #include "Opcodes.h"
  22 #include "Log.h"
  23 #include "WorldPacket.h"
  24 #include "WorldSession.h"
  25 #include "World.h"
  26 #include "ObjectMgr.h"
  27 #include "Player.h"
  28 #include "Group.h"
  29 #include "ObjectAccessor.h"
  30 #include "MapManager.h"
  31 #include "SocialMgr.h"
  32 #include "Util.h"
  33
  34 /* differeces from off:
  35     -you can uninvite yourself - is is useful
  36     -you can accept invitation even if leader went offline
  37 */
  38 /* todo:
  39     -group_destroyed msg is sent but not shown
  40     -reduce xp gaining when in raid group
  41     -quest sharing has to be corrected
  42     -FIX sending PartyMemberStats
  43 */
  44
  45 void WorldSession::SendPartyResult(PartyOperation operation, const std::string& member, PartyResult res)
  46 {
  47     WorldPacket data(SMSG_PARTY_COMMAND_RESULT, (8+member.size()+1));
  48     data << (uint32)operation;
  49     data << member;
  50     data << (uint32)res;
  51
  52     SendPacket( &data );
  53 }
  54
  55 void WorldSession::HandleGroupInviteOpcode( WorldPacket & recv_data )
  56 {
  57     std::string membername;
  58     recv_data >> membername;
  59
  60     if(_player->InBattleGround())
  61     {
  62         SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_INVITE_RESTRICTED);
  63         return;
  64     }
  65
  66     // attempt add selected player
  67
  68     // cheating
  69     if(!normalizePlayerName(membername))
  70     {
  71         SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_CANT_FIND_TARGET);
  72         return;
  73     }
  74
  75     Player *player = objmgr.GetPlayer(membername.c_str());
  76
  77     // no player
  78     if(!player)
  79     {
  80         SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_CANT_FIND_TARGET);
  81         return;
  82     }
  83
  84     // can't group with
  85     if(!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP) && GetPlayer()->GetTeam() != player->GetTeam())
  86     {
  87         SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_TARGET_UNFRIENDLY);
  88         return;
  89     }
  90     if(GetPlayer()->GetInstanceId() != 0 && player->GetInstanceId() != 0 && GetPlayer()->GetInstanceId() != player->GetInstanceId() && GetPlayer()->GetMapId() == player->GetMapId())
  91     {
  92         SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_NOT_IN_YOUR_INSTANCE);
  93         return;
  94     }
  95     // just ignore us
  96     if(player->GetSocial()->HasIgnore(GetPlayer()->GetGUIDLow()))
  97     {
  98         SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_TARGET_IGNORE_YOU);
  99         return;
 100     }
 101
 102     // player already in another group or invited
 103     if(player->GetGroup() || player->GetGroupInvite() )
 104     {
 105         SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_ALREADY_IN_GROUP);
 106         return;
 107     }
 108
 109     Group *group = GetPlayer()->GetGroup();
 110
 111     if(group)
 112     {
 113         // not have permissions for invite
 114         if(!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
 115         {
 116             SendPartyResult(PARTY_OP_INVITE, "", PARTY_RESULT_YOU_NOT_LEADER);
 117             return;
 118         }
 119
 120         // not have place
 121         if(group->IsFull())
 122         {
 123             SendPartyResult(PARTY_OP_INVITE, "", PARTY_RESULT_PARTY_FULL);
 124             return;
 125         }
 126     }
 127
 128     // ok, but group not exist, start a new group
 129     // but don't create and save the group to the DB until
 130     // at least one person joins
 131     if(!group)
 132     {
 133         group = new Group;
 134         // new group: if can't add then delete
 135         if(!group->AddLeaderInvite(GetPlayer()))
 136         {
 137             delete group;
 138             return;
 139         }
 140         if(!group->AddInvite(player))
 141         {
 142             delete group;
 143             return;
 144         }
 145     }
 146     else
 147     {
 148         // already existed group: if can't add then just leave
 149         if(!group->AddInvite(player))
 150         {
 151             return;
 152         }
 153     }
 154
 155     // ok, we do it
 156     WorldPacket data(SMSG_GROUP_INVITE, 10);                // guess size
 157     data << GetPlayer()->GetName();
 158     player->GetSession()->SendPacket(&data);
 159
 160     SendPartyResult(PARTY_OP_INVITE, membername, PARTY_RESULT_OK);
 161 }
 162
 163 void WorldSession::HandleGroupAcceptOpcode( WorldPacket & /*recv_data*/ )
 164 {
 165     Group *group = GetPlayer()->GetGroupInvite();
 166     if (!group) return;
 167
 168     if(group->GetLeaderGUID() == GetPlayer()->GetGUID())
 169     {
 170         sLog.outError("HandleGroupAcceptOpcode: player %s(%d) tried to accept an invite to his own group", GetPlayer()->GetName(), GetPlayer()->GetGUIDLow());
 171         return;
 172     }
 173
 174     // remove in from ivites in any case
 175     group->RemoveInvite(GetPlayer());
 176
 177     /** error handling **/
 178     /********************/
 179
 180     // not have place
 181     if(group->IsFull())
 182     {
 183         SendPartyResult(PARTY_OP_INVITE, "", PARTY_RESULT_PARTY_FULL);
 184         return;
 185     }
 186
 187     Player* leader = objmgr.GetPlayer(group->GetLeaderGUID());
 188
 189     if(leader && leader->InBattleGround())
 190     {
 191         SendPartyResult(PARTY_OP_INVITE, "", PARTY_RESULT_INVITE_RESTRICTED);
 192         return;
 193     }
 194
 195     // forming a new group, create it
 196     if(!group->IsCreated())
 197     {
 198         if(leader) group->RemoveInvite(leader);
 199         group->Create(group->GetLeaderGUID(), group->GetLeaderName());
 200         objmgr.AddGroup(group);
 201     }
 202
 203     // everything's fine, do it
 204     if(!group->AddMember(GetPlayer()->GetGUID(), GetPlayer()->GetName()))
 205         return;
 206
 207     uint8 subgroup = group->GetMemberGroup(GetPlayer()->GetGUID());
 208
 209     GetPlayer()->SetGroup(group, subgroup);
 210 }
 211
 212 void WorldSession::HandleGroupDeclineOpcode( WorldPacket & /*recv_data*/ )
 213 {
 214     Group  *group  = GetPlayer()->GetGroupInvite();
 215     if (!group) return;
 216
 217     Player *leader = objmgr.GetPlayer(group->GetLeaderGUID());
 218
 219     /** error handling **/
 220     if(!leader || !leader->GetSession())
 221         return;
 222     /********************/
 223
 224     // everything's fine, do it
 225     if(!group->IsCreated())
 226     {
 227         // note: this means that if you invite more than one person
 228         // and one of them declines before the first one accepts
 229         // all invites will be cleared
 230         // fixme: is that ok ?
 231         group->RemoveAllInvites();
 232         delete group;
 233     }
 234
 235     GetPlayer()->SetGroupInvite(NULL);
 236
 237     WorldPacket data( SMSG_GROUP_DECLINE, 10 );             // guess size
 238     data << GetPlayer()->GetName();
 239     leader->GetSession()->SendPacket( &data );
 240 }
 241
 242 void WorldSession::HandleGroupUninviteGuidOpcode(WorldPacket & recv_data)
 243 {
 244     CHECK_PACKET_SIZE(recv_data,8);
 245
 246     uint64 guid;
 247     recv_data >> guid;
 248
 249     //can't uninvite yourself
 250     if(guid == GetPlayer()->GetGUID())
 251     {
 252         sLog.outError("WorldSession::HandleGroupUninviteGuidOpcode: leader %s(%d) tried to uninvite himself from the group.", GetPlayer()->GetName(), GetPlayer()->GetGUIDLow());
 253         return;
 254     }
 255
 256     PartyResult res = GetPlayer()->CanUninviteFromGroup();
 257     if(res != PARTY_RESULT_OK)
 258     {
 259         SendPartyResult(PARTY_OP_LEAVE, "", res);
 260         return;
 261     }
 262
 263     Group* grp = GetPlayer()->GetGroup();
 264     if(!grp)
 265         return;
 266
 267     if(grp->IsMember(guid))
 268     {
 269         Player::RemoveFromGroup(grp,guid);
 270         return;
 271     }
 272
 273     if(Player* plr = grp->GetInvited(guid))
 274     {
 275         plr->UninviteFromGroup();
 276         return;
 277     }
 278
 279     SendPartyResult(PARTY_OP_LEAVE, "", PARTY_RESULT_NOT_IN_YOUR_PARTY);
 280 }
 281
 282 void WorldSession::HandleGroupUninviteNameOpcode(WorldPacket & recv_data)
 283 {
 284     CHECK_PACKET_SIZE(recv_data,1);
 285
 286     std::string membername;
 287     recv_data >> membername;
 288
 289     // player not found
 290     if(!normalizePlayerName(membername))
 291         return;
 292
 293     // can't uninvite yourself
 294     if(GetPlayer()->GetName() == membername)
 295     {
 296         sLog.outError("WorldSession::HandleGroupUninviteNameOpcode: leader %s(%d) tried to uninvite himself from the group.", GetPlayer()->GetName(), GetPlayer()->GetGUIDLow());
 297         return;
 298     }
 299
 300     PartyResult res = GetPlayer()->CanUninviteFromGroup();
 301     if(res != PARTY_RESULT_OK)
 302     {
 303         SendPartyResult(PARTY_OP_LEAVE, "", res);
 304         return;
 305     }
 306
 307     Group* grp = GetPlayer()->GetGroup();
 308     if(!grp)
 309         return;
 310
 311     if(uint64 guid = grp->GetMemberGUID(membername))
 312     {
 313         Player::RemoveFromGroup(grp,guid);
 314         return;
 315     }
 316
 317     if(Player* plr = grp->GetInvited(membername))
 318     {
 319         plr->UninviteFromGroup();
 320         return;
 321     }
 322
 323     SendPartyResult(PARTY_OP_LEAVE, membername, PARTY_RESULT_NOT_IN_YOUR_PARTY);
 324 }
 325
 326 void WorldSession::HandleGroupSetLeaderOpcode( WorldPacket & recv_data )
 327 {
 328     CHECK_PACKET_SIZE(recv_data,8);
 329
 330     Group *group = GetPlayer()->GetGroup();
 331     if(!group)
 332         return;
 333
 334     uint64 guid;
 335     recv_data >> guid;
 336
 337     Player *player = objmgr.GetPlayer(guid);
 338
 339     /** error handling **/
 340     if (!player || !group->IsLeader(GetPlayer()->GetGUID()) || player->GetGroup() != group)
 341         return;
 342     /********************/
 343
 344     // everything's fine, do it
 345     group->ChangeLeader(guid);
 346 }
 347
 348 void WorldSession::HandleGroupLeaveOpcode( WorldPacket & /*recv_data*/ )
 349 {
 350     if(!GetPlayer()->GetGroup())
 351         return;
 352
 353     if(_player->InBattleGround())
 354     {
 355         SendPartyResult(PARTY_OP_INVITE, "", PARTY_RESULT_INVITE_RESTRICTED);
 356         return;
 357     }
 358
 359     /** error handling **/
 360     /********************/
 361
 362     // everything's fine, do it
 363     SendPartyResult(PARTY_OP_LEAVE, GetPlayer()->GetName(), PARTY_RESULT_OK);
 364
 365     GetPlayer()->RemoveFromGroup();
 366 }
 367
 368 void WorldSession::HandleLootMethodOpcode( WorldPacket & recv_data )
 369 {
 370     CHECK_PACKET_SIZE(recv_data,4+8+4);
 371
 372     Group *group = GetPlayer()->GetGroup();
 373     if(!group)
 374         return;
 375
 376     uint32 lootMethod;
 377     uint64 lootMaster;
 378     uint32 lootThreshold;
 379     recv_data >> lootMethod >> lootMaster >> lootThreshold;
 380
 381     /** error handling **/
 382     if(!group->IsLeader(GetPlayer()->GetGUID()))
 383         return;
 384     /********************/
 385
 386     // everything's fine, do it
 387     group->SetLootMethod((LootMethod)lootMethod);
 388     group->SetLooterGuid(lootMaster);
 389     group->SetLootThreshold((ItemQualities)lootThreshold);
 390     group->SendUpdate();
 391 }
 392
 393 void WorldSession::HandleLootRoll( WorldPacket &recv_data )
 394 {
 395     CHECK_PACKET_SIZE(recv_data,8+4+1);
 396
 397     if(!GetPlayer()->GetGroup())
 398         return;
 399
 400     uint64 Guid;
 401     uint32 NumberOfPlayers;
 402     uint8  Choise;
 403     recv_data >> Guid;                                      //guid of the item rolled
 404     recv_data >> NumberOfPlayers;
 405     recv_data >> Choise;                                    //0: pass, 1: need, 2: greed
 406
 407     //sLog.outDebug("WORLD RECIEVE CMSG_LOOT_ROLL, From:%u, Numberofplayers:%u, Choise:%u", (uint32)Guid, NumberOfPlayers, Choise);
 408
 409     Group* group = GetPlayer()->GetGroup();
 410     if(!group)
 411         return;
 412
 413     // everything's fine, do it
 414     group->CountRollVote(GetPlayer()->GetGUID(), Guid, NumberOfPlayers, Choise);
 415 }
 416
 417 void WorldSession::HandleMinimapPingOpcode(WorldPacket& recv_data)
 418 {
 419     CHECK_PACKET_SIZE(recv_data,4+4);
 420
 421     if(!GetPlayer()->GetGroup())
 422         return;
 423
 424     float x, y;
 425     recv_data >> x;
 426     recv_data >> y;
 427
 428     //sLog.outDebug("Received opcode MSG_MINIMAP_PING X: %f, Y: %f", x, y);
 429
 430     /** error handling **/
 431     /********************/
 432
 433     // everything's fine, do it
 434     WorldPacket data(MSG_MINIMAP_PING, (8+4+4));
 435     data << GetPlayer()->GetGUID();
 436     data << x;
 437     data << y;
 438     GetPlayer()->GetGroup()->BroadcastPacket(&data, -1, GetPlayer()->GetGUID());
 439 }
 440
 441 void WorldSession::HandleRandomRollOpcode(WorldPacket& recv_data)
 442 {
 443     CHECK_PACKET_SIZE(recv_data,4+4);
 444
 445     uint32 minimum, maximum, roll;
 446     recv_data >> minimum;
 447     recv_data >> maximum;
 448
 449     /** error handling **/
 450     if(minimum > maximum || maximum > 10000)                // < 32768 for urand call
 451         return;
 452     /********************/
 453
 454     // everything's fine, do it
 455     roll = urand(minimum, maximum);
 456
 457     //sLog.outDebug("ROLL: MIN: %u, MAX: %u, ROLL: %u", minimum, maximum, roll);
 458
 459     WorldPacket data(MSG_RANDOM_ROLL, 4+4+4+8);
 460     data << minimum;
 461     data << maximum;
 462     data << roll;
 463     data << GetPlayer()->GetGUID();
 464     if(GetPlayer()->GetGroup())
 465         GetPlayer()->GetGroup()->BroadcastPacket(&data);
 466     else
 467         SendPacket(&data);
 468 }
 469
 470 void WorldSession::HandleRaidIconTargetOpcode( WorldPacket & recv_data )
 471 {
 472     CHECK_PACKET_SIZE(recv_data,1);
 473
 474     Group *group = GetPlayer()->GetGroup();
 475     if(!group)
 476         return;
 477
 478     uint8  x;
 479     recv_data >> x;
 480
 481     /** error handling **/
 482     /********************/
 483
 484     // everything's fine, do it
 485     if(x == 0xFF)                                           // target icon request
 486     {
 487         group->SendTargetIconList(this);
 488     }
 489     else                                                    // target icon update
 490     {
 491         // recheck
 492         CHECK_PACKET_SIZE(recv_data,1+8);
 493
 494         if(!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
 495             return;
 496
 497         uint64 guid;
 498         recv_data >> guid;
 499         group->SetTargetIcon(x, guid);
 500     }
 501 }
 502
 503 void WorldSession::HandleRaidConvertOpcode( WorldPacket & /*recv_data*/ )
 504 {
 505     Group *group = GetPlayer()->GetGroup();
 506     if(!group)
 507         return;
 508
 509     if(_player->InBattleGround())
 510         return;
 511
 512     /** error handling **/
 513     if(!group->IsLeader(GetPlayer()->GetGUID()) || group->GetMembersCount() < 2)
 514         return;
 515     /********************/
 516
 517     // everything's fine, do it (is it 0 (PARTY_OP_INVITE) correct code)
 518     SendPartyResult(PARTY_OP_INVITE, "", PARTY_RESULT_OK);
 519     group->ConvertToRaid();
 520 }
 521
 522 void WorldSession::HandleGroupChangeSubGroupOpcode( WorldPacket & recv_data )
 523 {
 524     CHECK_PACKET_SIZE(recv_data,1+1);
 525
 526     Group *group = GetPlayer()->GetGroup();
 527     if(!group)
 528         return;
 529
 530     std::string name;
 531     uint8 groupNr;
 532     recv_data >> name;
 533
 534     // recheck
 535     CHECK_PACKET_SIZE(recv_data,(name.size()+1)+1);
 536
 537     recv_data >> groupNr;
 538
 539     /** error handling **/
 540     if(!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
 541         return;
 542
 543     if (!group->HasFreeSlotSubGroup(groupNr))
 544         return;
 545     /********************/
 546
 547     // everything's fine, do it
 548     group->ChangeMembersGroup(objmgr.GetPlayer(name.c_str()), groupNr);
 549 }
 550
 551 void WorldSession::HandleGroupAssistantOpcode( WorldPacket & recv_data )
 552 {
 553     CHECK_PACKET_SIZE(recv_data,8+1);
 554
 555     Group *group = GetPlayer()->GetGroup();
 556     if(!group)
 557         return;
 558
 559     uint64 guid;
 560     uint8 flag;
 561     recv_data >> guid;
 562     recv_data >> flag;
 563
 564     /** error handling **/
 565     if(!group->IsLeader(GetPlayer()->GetGUID()))
 566         return;
 567     /********************/
 568
 569     // everything's fine, do it
 570     group->SetAssistant(guid, (flag==0?false:true));
 571 }
 572
 573 void WorldSession::HandleGroupPromoteOpcode( WorldPacket & recv_data )
 574 {
 575     CHECK_PACKET_SIZE(recv_data, 1+1+8);
 576
 577     Group *group = GetPlayer()->GetGroup();
 578     if(!group)
 579         return;
 580
 581     uint8 flag1, flag2;
 582     uint64 guid;
 583     recv_data >> flag1 >> flag2;
 584     recv_data >> guid;
 585     // if(flag1) Main Assist
 586     //     0x4
 587     // if(flag2) Main Tank
 588     //     0x2
 589
 590     /** error handling **/
 591     if(!group->IsLeader(GetPlayer()->GetGUID()))
 592         return;
 593     /********************/
 594
 595     // everything's fine, do it
 596     if(flag1 == 1)
 597         group->SetMainAssistant(guid);
 598     if(flag2 == 1)
 599         group->SetMainTank(guid);
 600 }
 601
 602 void WorldSession::HandleRaidReadyCheckOpcode( WorldPacket & recv_data )
 603 {
 604     Group *group = GetPlayer()->GetGroup();
 605     if(!group)
 606         return;
 607
 608     if(recv_data.empty())                                   // request
 609     {
 610         /** error handling **/
 611         if(!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
 612             return;
 613         /********************/
 614
 615         // everything's fine, do it
 616         WorldPacket data(MSG_RAID_READY_CHECK, 8);
 617         data << GetPlayer()->GetGUID();
 618         group->BroadcastPacket(&data, -1);
 619
 620         group->OfflineReadyCheck();
 621     }
 622     else                                                    // answer
 623     {
 624         uint8 state;
 625         recv_data >> state;
 626
 627         // everything's fine, do it
 628         WorldPacket data(MSG_RAID_READY_CHECK_CONFIRM, 9);
 629         data << GetPlayer()->GetGUID();
 630         data << state;
 631         group->BroadcastReadyCheck(&data);
 632     }
 633 }
 634
 635 void WorldSession::HandleRaidReadyCheckFinishOpcode( WorldPacket & /*recv_data*/ )
 636 {
 637     //Group* group = GetPlayer()->GetGroup();
 638     //if(!group)
 639     //    return;
 640
 641     //if(!group->IsLeader(GetPlayer()->GetGUID()) && !group->IsAssistant(GetPlayer()->GetGUID()))
 642     //    return;
 643
 644     // Is any reaction need?
 645 }
 646
 647 void WorldSession::BuildPartyMemberStatsChangedPacket(Player *player, WorldPacket *data)
 648 {
 649     uint32 mask = player->GetGroupUpdateFlag();
 650
 651     if (mask == GROUP_UPDATE_FLAG_NONE)
 652         return;
 653
 654     if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)                // if update power type, update current/max power also
 655         mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
 656
 657     if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)            // same for pets
 658         mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
 659
 660     uint32 byteCount = 0;
 661     for (int i = 1; i < GROUP_UPDATE_FLAGS_COUNT; ++i)
 662         if (mask & (1 << i))
 663             byteCount += GroupUpdateLength[i];
 664
 665     data->Initialize(SMSG_PARTY_MEMBER_STATS, 8 + 4 + byteCount);
 666     data->append(player->GetPackGUID());
 667     *data << (uint32) mask;
 668
 669     if (mask & GROUP_UPDATE_FLAG_STATUS)
 670     {
 671         if (player)
 672         {
 673             if (player->IsPvP())
 674                 *data << (uint16) (MEMBER_STATUS_ONLINE | MEMBER_STATUS_PVP);
 675             else
 676                 *data << (uint16) MEMBER_STATUS_ONLINE;
 677         }
 678         else
 679             *data << (uint16) MEMBER_STATUS_OFFLINE;
 680     }
 681
 682     if (mask & GROUP_UPDATE_FLAG_CUR_HP)
 683         *data << (uint16) player->GetHealth();
 684
 685     if (mask & GROUP_UPDATE_FLAG_MAX_HP)
 686         *data << (uint16) player->GetMaxHealth();
 687
 688     Powers powerType = player->getPowerType();
 689     if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
 690         *data << (uint8) powerType;
 691
 692     if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
 693         *data << (uint16) player->GetPower(powerType);
 694
 695     if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
 696         *data << (uint16) player->GetMaxPower(powerType);
 697
 698     if (mask & GROUP_UPDATE_FLAG_LEVEL)
 699         *data << (uint16) player->getLevel();
 700
 701     if (mask & GROUP_UPDATE_FLAG_ZONE)
 702         *data << (uint16) player->GetZoneId();
 703
 704     if (mask & GROUP_UPDATE_FLAG_POSITION)
 705         *data << (uint16) player->GetPositionX() << (uint16) player->GetPositionY();
 706
 707     if (mask & GROUP_UPDATE_FLAG_AURAS)
 708     {
 709         uint64 auramask = player->GetAuraUpdateMask();
 710         *data << uint64(auramask);
 711         for(uint32 i = 0; i < MAX_AURAS; ++i)
 712         {
 713             if(auramask & (uint64(1) << i))
 714             {
 715                 *data << uint16(player->GetUInt32Value(UNIT_FIELD_AURA + i));
 716                 *data << uint8(1);
 717             }
 718         }
 719     }
 720
 721     Pet *pet = player->GetPet();
 722     if (mask & GROUP_UPDATE_FLAG_PET_GUID)
 723     {
 724         if(pet)
 725             *data << (uint64) pet->GetGUID();
 726         else
 727             *data << (uint64) 0;
 728     }
 729
 730     if (mask & GROUP_UPDATE_FLAG_PET_NAME)
 731     {
 732         if(pet)
 733             *data << pet->GetName();
 734         else
 735             *data << (uint8)  0;
 736     }
 737
 738     if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
 739     {
 740         if(pet)
 741             *data << (uint16) pet->GetDisplayId();
 742         else
 743             *data << (uint16) 0;
 744     }
 745
 746     if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
 747     {
 748         if(pet)
 749             *data << (uint16) pet->GetHealth();
 750         else
 751             *data << (uint16) 0;
 752     }
 753
 754     if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
 755     {
 756         if(pet)
 757             *data << (uint16) pet->GetMaxHealth();
 758         else
 759             *data << (uint16) 0;
 760     }
 761
 762     if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
 763     {
 764         if(pet)
 765             *data << (uint8)  pet->getPowerType();
 766         else
 767             *data << (uint8)  0;
 768     }
 769
 770     if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
 771     {
 772         if(pet)
 773             *data << (uint16) pet->GetPower(pet->getPowerType());
 774         else
 775             *data << (uint16) 0;
 776     }
 777
 778     if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
 779     {
 780         if(pet)
 781             *data << (uint16) pet->GetMaxPower(pet->getPowerType());
 782         else
 783             *data << (uint16) 0;
 784     }
 785
 786     if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
 787     {
 788         if(pet)
 789         {
 790             uint64 auramask = pet->GetAuraUpdateMask();
 791             *data << uint64(auramask);
 792             for(uint32 i = 0; i < MAX_AURAS; ++i)
 793             {
 794                 if(auramask & (uint64(1) << i))
 795                 {
 796                     *data << uint16(pet->GetUInt32Value(UNIT_FIELD_AURA + i));
 797                     *data << uint8(1);
 798                 }
 799             }
 800         }
 801         else
 802             *data << (uint64) 0;
 803     }
 804 }
 805
 806 /*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
 807 void WorldSession::HandleRequestPartyMemberStatsOpcode( WorldPacket &recv_data )
 808 {
 809     CHECK_PACKET_SIZE(recv_data, 8);
 810
 811     sLog.outDebug("WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
 812     uint64 Guid;
 813     recv_data >> Guid;
 814
 815     Player *player = objmgr.GetPlayer(Guid);
 816     if(!player)
 817     {
 818         WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2);
 819         data.appendPackGUID(Guid);
 820         data << (uint32) GROUP_UPDATE_FLAG_STATUS;
 821         data << (uint16) MEMBER_STATUS_OFFLINE;
 822         SendPacket(&data);
 823         return;
 824     }
 825
 826     Pet *pet = player->GetPet();
 827
 828     WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 4+2+2+2+1+2*6+8+1+8);
 829     data.append(player->GetPackGUID());
 830
 831     uint32 mask1 = 0x00040BFF;                              // common mask, real flags used 0x000040BFF
 832     if(pet)
 833         mask1 = 0x7FFFFFFF;                                 // for hunters and other classes with pets
 834
 835     Powers powerType = player->getPowerType();
 836     data << (uint32) mask1;                                 // group update mask
 837     data << (uint16) MEMBER_STATUS_ONLINE;                  // member's online status
 838     data << (uint16) player->GetHealth();                   // GROUP_UPDATE_FLAG_CUR_HP
 839     data << (uint16) player->GetMaxHealth();                // GROUP_UPDATE_FLAG_MAX_HP
 840     data << (uint8)  powerType;                             // GROUP_UPDATE_FLAG_POWER_TYPE
 841     data << (uint16) player->GetPower(powerType);           // GROUP_UPDATE_FLAG_CUR_POWER
 842     data << (uint16) player->GetMaxPower(powerType);        // GROUP_UPDATE_FLAG_MAX_POWER
 843     data << (uint16) player->getLevel();                    // GROUP_UPDATE_FLAG_LEVEL
 844     data << (uint16) player->GetZoneId();                   // GROUP_UPDATE_FLAG_ZONE
 845     data << (uint16) player->GetPositionX();                // GROUP_UPDATE_FLAG_POSITION
 846     data << (uint16) player->GetPositionY();                // GROUP_UPDATE_FLAG_POSITION
 847
 848     uint64 auramask = 0;
 849     size_t maskPos = data.wpos();
 850     data << (uint64) auramask;                              // placeholder
 851     for(uint8 i = 0; i < MAX_AURAS; ++i)
 852     {
 853         if(uint32 aura = player->GetUInt32Value(UNIT_FIELD_AURA + i))
 854         {
 855             auramask |= (uint64(1) << i);
 856             data << uint16(aura);
 857             data << uint8(1);
 858         }
 859     }
 860     data.put<uint64>(maskPos,auramask);                     // GROUP_UPDATE_FLAG_AURAS
 861
 862     if(pet)
 863     {
 864         Powers petpowertype = pet->getPowerType();
 865         data << (uint64) pet->GetGUID();                    // GROUP_UPDATE_FLAG_PET_GUID
 866         data << pet->GetName();                             // GROUP_UPDATE_FLAG_PET_NAME
 867         data << (uint16) pet->GetDisplayId();               // GROUP_UPDATE_FLAG_PET_MODEL_ID
 868         data << (uint16) pet->GetHealth();                  // GROUP_UPDATE_FLAG_PET_CUR_HP
 869         data << (uint16) pet->GetMaxHealth();               // GROUP_UPDATE_FLAG_PET_MAX_HP
 870         data << (uint8)  petpowertype;                      // GROUP_UPDATE_FLAG_PET_POWER_TYPE
 871         data << (uint16) pet->GetPower(petpowertype);       // GROUP_UPDATE_FLAG_PET_CUR_POWER
 872         data << (uint16) pet->GetMaxPower(petpowertype);    // GROUP_UPDATE_FLAG_PET_MAX_POWER
 873
 874         uint64 petauramask = 0;
 875         size_t petMaskPos = data.wpos();
 876         data << (uint64) petauramask;                       // placeholder
 877         for(uint8 i = 0; i < MAX_AURAS; ++i)
 878         {
 879             if(uint32 petaura = pet->GetUInt32Value(UNIT_FIELD_AURA + i))
 880             {
 881                 petauramask |= (uint64(1) << i);
 882                 data << (uint16) petaura;
 883                 data << (uint8)  1;
 884             }
 885         }
 886         data.put<uint64>(petMaskPos,petauramask);           // GROUP_UPDATE_FLAG_PET_AURAS
 887     }
 888     else
 889     {
 890         data << (uint8)  0;                                 // GROUP_UPDATE_FLAG_PET_NAME
 891         data << (uint64) 0;                                 // GROUP_UPDATE_FLAG_PET_AURAS
 892     }
 893
 894     SendPacket(&data);
 895 }
 896
 897 /*!*/void WorldSession::HandleRequestRaidInfoOpcode( WorldPacket & /*recv_data*/ )
 898 {
 899     // every time the player checks the character screen
 900     _player->SendRaidInfo();
 901 }
 902
 903 /*void WorldSession::HandleGroupCancelOpcode( WorldPacket & recv_data )
 904 {
 905     sLog.outDebug( "WORLD: got CMSG_GROUP_CANCEL." );
 906 }*/
 907
 908 void WorldSession::HandleGroupPassOnLootOpcode( WorldPacket & recv_data )
 909 {
 910     CHECK_PACKET_SIZE(recv_data, 4);
 911
 912     sLog.outDebug("WORLD: Received CMSG_GROUP_PASS_ON_LOOT");
 913
 914     uint32 unkn;
 915     recv_data >> unkn;
 916
 917     // ignore if player not loaded
 918     if(!GetPlayer())                                        // needed because STATUS_AUTHED
 919     {
 920         if(unkn!=0)
 921             sLog.outError("CMSG_GROUP_PASS_ON_LOOT value<>0 for not-loaded character!");
 922         return;
 923     }
 924
 925     if(unkn!=0)
 926         sLog.outError("CMSG_GROUP_PASS_ON_LOOT: activation not implemented!");
 927 }