src/game/GuildHandler.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 "WorldSession.h"
  22 #include "World.h"
  23 #include "ObjectMgr.h"
  24 #include "Log.h"
  25 #include "Opcodes.h"
  26 #include "Guild.h"
  27 #include "GossipDef.h"
  28 #include "SocialMgr.h"
  29
  30 void WorldSession::HandleGuildQueryOpcode(WorldPacket& recvPacket)
  31 {
  32     CHECK_PACKET_SIZE(recvPacket, 4);
  33
  34     uint32 guildId;
  35     Guild *guild;
  36
  37     //sLog.outDebug("WORLD: Received CMSG_GUILD_QUERY");
  38
  39     recvPacket >> guildId;
  40
  41     guild = objmgr.GetGuildById(guildId);
  42     if(!guild)
  43     {
  44         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
  45         return;
  46     }
  47
  48     guild->Query(this);
  49 }
  50
  51 void WorldSession::HandleGuildCreateOpcode(WorldPacket& recvPacket)
  52 {
  53     CHECK_PACKET_SIZE(recvPacket, 1);
  54
  55     std::string gname;
  56
  57     //sLog.outDebug("WORLD: Received CMSG_GUILD_CREATE");
  58
  59     recvPacket >> gname;
  60
  61     if(GetPlayer()->GetGuildId())
  62         return;
  63
  64     Guild *guild = new Guild;
  65     if(!guild->create(GetPlayer(),gname))
  66     {
  67         delete guild;
  68         return;
  69     }
  70
  71     objmgr.AddGuild(guild);
  72 }
  73
  74 void WorldSession::HandleGuildInviteOpcode(WorldPacket& recvPacket)
  75 {
  76     CHECK_PACKET_SIZE(recvPacket, 1);
  77
  78     std::string Invitedname, plname;
  79
  80     //sLog.outDebug("WORLD: Received CMSG_GUILD_INVITE");
  81
  82     Player * player = NULL;
  83
  84     recvPacket >> Invitedname;
  85
  86     if(normalizePlayerName(Invitedname))
  87         player = ObjectAccessor::Instance().FindPlayerByName(Invitedname.c_str());
  88
  89     if(!player)
  90     {
  91         SendGuildCommandResult(GUILD_INVITE_S, Invitedname, GUILD_PLAYER_NOT_FOUND);
  92         return;
  93     }
  94
  95     Guild *guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
  96     if(!guild)
  97     {
  98         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
  99         return;
 100     }
 101
 102     // OK result but not send invite
 103     if(player->GetSocial()->HasIgnore(GetPlayer()->GetGUIDLow()))
 104         return;
 105
 106     // not let enemies sign guild charter
 107     if (!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && player->GetTeam() != GetPlayer()->GetTeam())
 108     {
 109         SendGuildCommandResult(GUILD_INVITE_S, Invitedname, GUILD_NOT_ALLIED);
 110         return;
 111     }
 112
 113     if(player->GetGuildId())
 114     {
 115         plname = player->GetName();
 116         SendGuildCommandResult(GUILD_INVITE_S, plname, ALREADY_IN_GUILD);
 117         return;
 118     }
 119
 120     if(player->GetGuildIdInvited())
 121     {
 122         plname = player->GetName();
 123         SendGuildCommandResult(GUILD_INVITE_S, plname, ALREADY_INVITED_TO_GUILD);
 124         return;
 125     }
 126
 127     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_INVITE))
 128     {
 129         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 130         return;
 131     }
 132
 133     sLog.outDebug("Player %s Invited %s to Join his Guild", GetPlayer()->GetName(), Invitedname.c_str());
 134
 135     player->SetGuildIdInvited(GetPlayer()->GetGuildId());
 136     // Put record into guildlog
 137     guild->LogGuildEvent(GUILD_EVENT_LOG_INVITE_PLAYER, GetPlayer()->GetGUIDLow(), player->GetGUIDLow(), 0);
 138
 139     WorldPacket data(SMSG_GUILD_INVITE, (8+10));            // guess size
 140     data << GetPlayer()->GetName();
 141     data << guild->GetName();
 142     player->GetSession()->SendPacket(&data);
 143
 144     //sLog.outDebug("WORLD: Sent (SMSG_GUILD_INVITE)");
 145 }
 146
 147 void WorldSession::HandleGuildRemoveOpcode(WorldPacket& recvPacket)
 148 {
 149     CHECK_PACKET_SIZE(recvPacket, 1);
 150
 151     std::string plName;
 152
 153     //sLog.outDebug("WORLD: Received CMSG_GUILD_REMOVE");
 154
 155     recvPacket >> plName;
 156
 157     if(!normalizePlayerName(plName))
 158         return;
 159
 160     Guild* guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 161     if(!guild)
 162     {
 163         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 164         return;
 165     }
 166
 167     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_REMOVE))
 168     {
 169         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 170         return;
 171     }
 172
 173     uint64 plGuid;
 174     MemberSlot* slot = guild->GetMemberSlot(plName, plGuid);
 175     if(!slot)
 176     {
 177         SendGuildCommandResult(GUILD_INVITE_S, plName, GUILD_PLAYER_NOT_IN_GUILD_S);
 178         return;
 179     }
 180
 181     if(slot->RankId == GR_GUILDMASTER)
 182     {
 183         SendGuildCommandResult(GUILD_QUIT_S, "", GUILD_LEADER_LEAVE);
 184         return;
 185     }
 186
 187     guild->DelMember(plGuid);
 188     // Put record into guildlog
 189     guild->LogGuildEvent(GUILD_EVENT_LOG_UNINVITE_PLAYER, GetPlayer()->GetGUIDLow(), GUID_LOPART(plGuid), 0);
 190
 191     WorldPacket data(SMSG_GUILD_EVENT, (2+20));             // guess size
 192     data << (uint8)GE_REMOVED;
 193     data << (uint8)2;                                       // strings count
 194     data << plName;
 195     data << GetPlayer()->GetName();
 196     guild->BroadcastPacket(&data);
 197 }
 198
 199 void WorldSession::HandleGuildAcceptOpcode(WorldPacket& /*recvPacket*/)
 200 {
 201     Guild *guild;
 202     Player *player = GetPlayer();
 203
 204     //sLog.outDebug("WORLD: Received CMSG_GUILD_ACCEPT");
 205
 206     guild = objmgr.GetGuildById(player->GetGuildIdInvited());
 207     if(!guild || player->GetGuildId())
 208         return;
 209
 210     // not let enemies sign guild charter
 211     if (!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && player->GetTeam() != objmgr.GetPlayerTeamByGUID(guild->GetLeader()))
 212         return;
 213
 214     if(!guild->AddMember(GetPlayer()->GetGUID(),guild->GetLowestRank()))
 215         return;
 216     // Put record into guildlog
 217     guild->LogGuildEvent(GUILD_EVENT_LOG_JOIN_GUILD, GetPlayer()->GetGUIDLow(), 0, 0);
 218
 219     WorldPacket data(SMSG_GUILD_EVENT, (2+10));             // guess size
 220     data << (uint8)GE_JOINED;
 221     data << (uint8)1;
 222     data << player->GetName();
 223     guild->BroadcastPacket(&data);
 224
 225     //sLog.outDebug("WORLD: Sent (SMSG_GUILD_EVENT)");
 226 }
 227
 228 void WorldSession::HandleGuildDeclineOpcode(WorldPacket& /*recvPacket*/)
 229 {
 230     //sLog.outDebug("WORLD: Received CMSG_GUILD_DECLINE");
 231
 232     GetPlayer()->SetGuildIdInvited(0);
 233     GetPlayer()->SetInGuild(0);
 234 }
 235
 236 void WorldSession::HandleGuildInfoOpcode(WorldPacket& /*recvPacket*/)
 237 {
 238     Guild *guild;
 239     //sLog.outDebug("WORLD: Received CMSG_GUILD_INFO");
 240
 241     guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 242     if(!guild)
 243     {
 244         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 245         return;
 246     }
 247
 248     WorldPacket data(SMSG_GUILD_INFO, (5*4 + guild->GetName().size() + 1));
 249     data << guild->GetName();
 250     data << guild->GetCreatedDay();
 251     data << guild->GetCreatedMonth();
 252     data << guild->GetCreatedYear();
 253     data << guild->GetMemberSize();
 254     data << guild->GetMemberSize();
 255
 256     SendPacket(&data);
 257 }
 258
 259 void WorldSession::HandleGuildRosterOpcode(WorldPacket& /*recvPacket*/)
 260 {
 261     //sLog.outDebug("WORLD: Received CMSG_GUILD_ROSTER");
 262
 263     Guild* guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 264     if(!guild)
 265         return;
 266
 267     guild->Roster(this);
 268 }
 269
 270 void WorldSession::HandleGuildPromoteOpcode(WorldPacket& recvPacket)
 271 {
 272     CHECK_PACKET_SIZE(recvPacket, 1);
 273
 274     std::string plName;
 275
 276     //sLog.outDebug("WORLD: Received CMSG_GUILD_PROMOTE");
 277
 278     recvPacket >> plName;
 279
 280     if(!normalizePlayerName(plName))
 281         return;
 282
 283     Guild* guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 284     if(!guild)
 285     {
 286         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 287         return;
 288     }
 289     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_PROMOTE))
 290     {
 291         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 292         return;
 293     }
 294
 295     uint64 plGuid;
 296     MemberSlot* slot = guild->GetMemberSlot(plName, plGuid);
 297
 298     if(!slot)
 299     {
 300         SendGuildCommandResult(GUILD_INVITE_S, plName, GUILD_PLAYER_NOT_IN_GUILD_S);
 301         return;
 302     }
 303
 304     if(plGuid == GetPlayer()->GetGUID())
 305     {
 306         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_NAME_INVALID);
 307         return;
 308     }
 309
 310     if(slot->RankId < 2 || (slot->RankId-1) < GetPlayer()->GetRank())
 311         return;
 312
 313     uint32 newRankId = slot->RankId < guild->GetNrRanks() ? slot->RankId-1 : guild->GetNrRanks()-1;
 314
 315     guild->ChangeRank(plGuid, newRankId);
 316     // Put record into guildlog
 317     guild->LogGuildEvent(GUILD_EVENT_LOG_PROMOTE_PLAYER, GetPlayer()->GetGUIDLow(), GUID_LOPART(plGuid), newRankId);
 318
 319     WorldPacket data(SMSG_GUILD_EVENT, (2+30));             // guess size
 320     data << (uint8)GE_PROMOTION;
 321     data << (uint8)3;
 322     data << GetPlayer()->GetName();
 323     data << plName;
 324     data << guild->GetRankName(newRankId);
 325     guild->BroadcastPacket(&data);
 326 }
 327
 328 void WorldSession::HandleGuildDemoteOpcode(WorldPacket& recvPacket)
 329 {
 330     CHECK_PACKET_SIZE(recvPacket, 1);
 331
 332     std::string plName;
 333
 334     //sLog.outDebug("WORLD: Received CMSG_GUILD_DEMOTE");
 335
 336     recvPacket >> plName;
 337
 338     if(!normalizePlayerName(plName))
 339         return;
 340
 341     Guild* guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 342
 343     if(!guild)
 344     {
 345         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 346         return;
 347     }
 348
 349     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_DEMOTE))
 350     {
 351         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 352         return;
 353     }
 354
 355     uint64 plGuid;
 356     MemberSlot* slot = guild->GetMemberSlot(plName, plGuid);
 357
 358     if (!slot)
 359     {
 360         SendGuildCommandResult(GUILD_INVITE_S, plName, GUILD_PLAYER_NOT_IN_GUILD_S);
 361         return;
 362     }
 363
 364     if(plGuid == GetPlayer()->GetGUID())
 365     {
 366         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_NAME_INVALID);
 367         return;
 368     }
 369
 370     if((slot->RankId+1) >= guild->GetNrRanks() || slot->RankId <= GetPlayer()->GetRank())
 371         return;
 372
 373     guild->ChangeRank(plGuid, (slot->RankId+1));
 374     // Put record into guildlog
 375     guild->LogGuildEvent(GUILD_EVENT_LOG_DEMOTE_PLAYER, GetPlayer()->GetGUIDLow(), GUID_LOPART(plGuid), slot->RankId);
 376
 377     WorldPacket data(SMSG_GUILD_EVENT, (2+30));             // guess size
 378     data << (uint8)GE_DEMOTION;
 379     data << (uint8)3;
 380     data << GetPlayer()->GetName();
 381     data << plName;
 382     data << guild->GetRankName(slot->RankId);
 383     guild->BroadcastPacket(&data);
 384 }
 385
 386 void WorldSession::HandleGuildLeaveOpcode(WorldPacket& /*recvPacket*/)
 387 {
 388     std::string plName;
 389     Guild *guild;
 390
 391     //sLog.outDebug("WORLD: Received CMSG_GUILD_LEAVE");
 392
 393     guild = objmgr.GetGuildById(_player->GetGuildId());
 394     if(!guild)
 395     {
 396         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 397         return;
 398     }
 399     if(_player->GetGUID() == guild->GetLeader() && guild->GetMemberSize() > 1)
 400     {
 401         SendGuildCommandResult(GUILD_QUIT_S, "", GUILD_LEADER_LEAVE);
 402         return;
 403     }
 404
 405     if(_player->GetGUID() == guild->GetLeader())
 406     {
 407         guild->Disband();
 408         return;
 409     }
 410
 411     plName = _player->GetName();
 412
 413     guild->DelMember(_player->GetGUID());
 414     // Put record into guildlog
 415     guild->LogGuildEvent(GUILD_EVENT_LOG_LEAVE_GUILD, _player->GetGUIDLow(), 0, 0);
 416
 417     WorldPacket data(SMSG_GUILD_EVENT, (2+10));             // guess size
 418     data << (uint8)GE_LEFT;
 419     data << (uint8)1;
 420     data << plName;
 421     guild->BroadcastPacket(&data);
 422
 423     //sLog.outDebug("WORLD: Sent (SMSG_GUILD_EVENT)");
 424
 425     SendGuildCommandResult(GUILD_QUIT_S, guild->GetName(), GUILD_PLAYER_NO_MORE_IN_GUILD);
 426 }
 427
 428 void WorldSession::HandleGuildDisbandOpcode(WorldPacket& /*recvPacket*/)
 429 {
 430     std::string name;
 431     Guild *guild;
 432
 433     //sLog.outDebug("WORLD: Received CMSG_GUILD_DISBAND");
 434
 435     guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 436     if(!guild)
 437     {
 438         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 439         return;
 440     }
 441     if(GetPlayer()->GetGUID() != guild->GetLeader())
 442     {
 443         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 444         return;
 445     }
 446
 447     guild->Disband();
 448
 449     //sLog.outDebug("WORLD: Guild Sucefully Disbanded");
 450 }
 451
 452 void WorldSession::HandleGuildLeaderOpcode(WorldPacket& recvPacket)
 453 {
 454     CHECK_PACKET_SIZE(recvPacket, 1);
 455
 456     std::string name;
 457     Player *oldLeader = GetPlayer();
 458     Guild *guild;
 459
 460     //sLog.outDebug("WORLD: Received CMSG_GUILD_LEADER");
 461
 462     recvPacket >> name;
 463
 464     if(!normalizePlayerName(name))
 465         return;
 466
 467     guild = objmgr.GetGuildById(oldLeader->GetGuildId());
 468
 469     if (!guild)
 470     {
 471         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 472         return;
 473     }
 474
 475     if (oldLeader->GetGUID() != guild->GetLeader())
 476     {
 477         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 478         return;
 479     }
 480
 481     uint64 newLeaderGUID;
 482     MemberSlot* slot = guild->GetMemberSlot(name, newLeaderGUID);
 483
 484     if (!slot)
 485     {
 486         SendGuildCommandResult(GUILD_INVITE_S, name, GUILD_PLAYER_NOT_IN_GUILD_S);
 487         return;
 488     }
 489
 490     guild->SetLeader(newLeaderGUID);
 491     guild->ChangeRank(oldLeader->GetGUID(), GR_OFFICER);
 492
 493     WorldPacket data(SMSG_GUILD_EVENT, (2+20));             // guess size
 494     data << (uint8)GE_LEADER_CHANGED;
 495     data << (uint8)2;
 496     data << oldLeader->GetName();
 497     data << name.c_str();
 498     guild->BroadcastPacket(&data);
 499
 500     //sLog.outDebug("WORLD: Sent (SMSG_GUILD_EVENT)");
 501 }
 502
 503 void WorldSession::HandleGuildMOTDOpcode(WorldPacket& recvPacket)
 504 {
 505     Guild *guild;
 506     std::string MOTD;
 507
 508     //sLog.outDebug("WORLD: Received CMSG_GUILD_MOTD");
 509
 510     guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 511     if(!guild)
 512     {
 513         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 514         return;
 515     }
 516     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_SETMOTD))
 517     {
 518         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 519         return;
 520     }
 521
 522     if(!recvPacket.empty())
 523         recvPacket >> MOTD;
 524     else
 525         MOTD = "";
 526
 527     guild->SetMOTD(MOTD);
 528
 529     WorldPacket data(SMSG_GUILD_EVENT, (2+MOTD.size()+1));
 530     data << (uint8)GE_MOTD;
 531     data << (uint8)1;
 532     data << MOTD;
 533     guild->BroadcastPacket(&data);
 534
 535     //sLog.outDebug("WORLD: Sent (SMSG_GUILD_EVENT)");
 536 }
 537
 538 void WorldSession::HandleGuildSetPublicNoteOpcode(WorldPacket& recvPacket)
 539 {
 540     CHECK_PACKET_SIZE(recvPacket, 1);
 541
 542     std::string name,PNOTE;
 543
 544     //sLog.outDebug("WORLD: Received CMSG_GUILD_SET_PUBLIC_NOTE");
 545
 546     recvPacket >> name;
 547
 548     if(!normalizePlayerName(name))
 549         return;
 550
 551     Guild* guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 552
 553     if (!guild)
 554     {
 555         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 556         return;
 557     }
 558
 559     if (!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_EPNOTE))
 560     {
 561         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 562         return;
 563     }
 564
 565     uint64 plGuid;
 566     MemberSlot* slot = guild->GetMemberSlot(name, plGuid);
 567
 568     if (!slot)
 569     {
 570         SendGuildCommandResult(GUILD_INVITE_S, name, GUILD_PLAYER_NOT_IN_GUILD_S);
 571         return;
 572     }
 573
 574     recvPacket >> PNOTE;
 575     guild->SetPNOTE(plGuid, PNOTE);
 576
 577     guild->Roster(this);
 578 }
 579
 580 void WorldSession::HandleGuildSetOfficerNoteOpcode(WorldPacket& recvPacket)
 581 {
 582     CHECK_PACKET_SIZE(recvPacket, 1);
 583
 584     std::string plName, OFFNOTE;
 585
 586     //sLog.outDebug("WORLD: Received CMSG_GUILD_SET_OFFICER_NOTE");
 587
 588     recvPacket >> plName;
 589
 590     if (!normalizePlayerName(plName))
 591         return;
 592
 593     Guild* guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 594
 595     if (!guild)
 596     {
 597         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 598         return;
 599     }
 600     if (!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_EOFFNOTE))
 601     {
 602         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 603         return;
 604     }
 605
 606     uint64 plGuid;
 607     MemberSlot* slot = guild->GetMemberSlot(plName, plGuid);
 608
 609     if (!slot)
 610     {
 611         SendGuildCommandResult(GUILD_INVITE_S, plName, GUILD_PLAYER_NOT_IN_GUILD_S);
 612         return;
 613     }
 614
 615     recvPacket >> OFFNOTE;
 616     guild->SetOFFNOTE(plGuid, OFFNOTE);
 617
 618     guild->Roster(this);
 619 }
 620
 621 void WorldSession::HandleGuildRankOpcode(WorldPacket& recvPacket)
 622 {
 623     CHECK_PACKET_SIZE(recvPacket, 4+4+1+4*13);
 624     //recvPacket.hexlike();
 625
 626     Guild *guild;
 627     std::string rankname;
 628     uint32 rankId;
 629     uint32 rights, MoneyPerDay;
 630     uint32 BankRights;
 631     uint32 BankSlotPerDay;
 632
 633     //sLog.outDebug("WORLD: Received CMSG_GUILD_RANK");
 634
 635     guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 636     if(!guild)
 637     {
 638         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 639         return;
 640     }
 641
 642     else if(GetPlayer()->GetGUID() != guild->GetLeader())
 643     {
 644         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 645         return;
 646     }
 647
 648     recvPacket >> rankId;
 649     recvPacket >> rights;
 650     recvPacket >> rankname;
 651     recvPacket >> MoneyPerDay;
 652
 653     for (int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
 654     {
 655         recvPacket >> BankRights;
 656         recvPacket >> BankSlotPerDay;
 657         guild->SetBankRightsAndSlots(rankId, uint8(i), uint16(BankRights & 0xFF), uint16(BankSlotPerDay), true);
 658     }
 659     sLog.outDebug("WORLD: Changed RankName to %s , Rights to 0x%.4X", rankname.c_str(), rights);
 660
 661     guild->SetBankMoneyPerDay(rankId, MoneyPerDay);
 662     guild->SetRankName(rankId, rankname);
 663
 664     if(rankId==GR_GUILDMASTER)                              // prevent loss leader rights
 665         rights = GR_RIGHT_ALL;
 666
 667     guild->SetRankRights(rankId, rights);
 668
 669     guild->Query(this);
 670     guild->Roster(this);
 671 }
 672
 673 void WorldSession::HandleGuildAddRankOpcode(WorldPacket& recvPacket)
 674 {
 675     CHECK_PACKET_SIZE(recvPacket, 1);
 676
 677     Guild *guild;
 678     std::string rankname;
 679
 680     //sLog.outDebug("WORLD: Received CMSG_GUILD_ADD_RANK");
 681
 682     guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 683     if(!guild)
 684     {
 685         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 686         return;
 687     }
 688
 689     if(GetPlayer()->GetGUID() != guild->GetLeader())
 690     {
 691         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 692         return;
 693     }
 694
 695     if(guild->GetNrRanks() >= GUILD_MAX_RANKS)              // client not let create more 10 than ranks
 696         return;
 697
 698     recvPacket >> rankname;
 699
 700     guild->CreateRank(rankname, GR_RIGHT_GCHATLISTEN | GR_RIGHT_GCHATSPEAK);
 701
 702     guild->Query(this);
 703     guild->Roster(this);
 704 }
 705
 706 void WorldSession::HandleGuildDelRankOpcode(WorldPacket& /*recvPacket*/)
 707 {
 708     Guild *guild;
 709     std::string rankname;
 710
 711     //sLog.outDebug("WORLD: Received CMSG_GUILD_DEL_RANK");
 712
 713     guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 714     if(!guild)
 715     {
 716         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 717         return;
 718     }
 719
 720     else if(GetPlayer()->GetGUID() != guild->GetLeader())
 721     {
 722         SendGuildCommandResult(GUILD_INVITE_S, "", GUILD_PERMISSIONS);
 723         return;
 724     }
 725
 726     guild->DelRank();
 727
 728     guild->Query(this);
 729     guild->Roster(this);
 730 }
 731
 732 void WorldSession::SendGuildCommandResult(uint32 typecmd, const std::string& str,uint32 cmdresult)
 733 {
 734     WorldPacket data(SMSG_GUILD_COMMAND_RESULT, (8+str.size()+1));
 735     data << typecmd;
 736     data << str;
 737     data << cmdresult;
 738     SendPacket(&data);
 739
 740     //sLog.outDebug("WORLD: Sent (SMSG_GUILD_COMMAND_RESULT)");
 741 }
 742
 743 void WorldSession::HandleGuildChangeInfoOpcode(WorldPacket& recvPacket)
 744 {
 745     CHECK_PACKET_SIZE(recvPacket, 1);
 746
 747     //sLog.outDebug("WORLD: Received CMSG_GUILD_INFO_TEXT");
 748
 749     std::string GINFO;
 750
 751     recvPacket >> GINFO;
 752
 753     Guild *guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 754     if(!guild)
 755     {
 756         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 757         return;
 758     }
 759
 760     if(!guild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_MODIFY_GUILD_INFO))
 761     {
 762         SendGuildCommandResult(GUILD_CREATE_S, "", GUILD_PERMISSIONS);
 763         return;
 764     }
 765
 766     guild->SetGINFO(GINFO);
 767 }
 768
 769 void WorldSession::HandleGuildSaveEmblemOpcode(WorldPacket& recvPacket)
 770 {
 771     CHECK_PACKET_SIZE(recvPacket, 8+4+4+4+4+4);
 772
 773     //sLog.outDebug("WORLD: Received MSG_SAVE_GUILD_EMBLEM");
 774
 775     uint64 vendorGuid;
 776
 777     uint32 EmblemStyle;
 778     uint32 EmblemColor;
 779     uint32 BorderStyle;
 780     uint32 BorderColor;
 781     uint32 BackgroundColor;
 782
 783     recvPacket >> vendorGuid;
 784
 785     Creature *pCreature = ObjectAccessor::GetNPCIfCanInteractWith(*_player, vendorGuid,UNIT_NPC_FLAG_TABARDDESIGNER);
 786     if (!pCreature)
 787     {
 788         //"That's not an emblem vendor!"
 789         SendSaveGuildEmblem(ERR_GUILDEMBLEM_INVALIDVENDOR);
 790         sLog.outDebug("WORLD: HandleGuildSaveEmblemOpcode - Unit (GUID: %u) not found or you can't interact with him.", GUID_LOPART(vendorGuid));
 791         return;
 792     }
 793
 794     // remove fake death
 795     if(GetPlayer()->hasUnitState(UNIT_STAT_DIED))
 796         GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
 797
 798     recvPacket >> EmblemStyle;
 799     recvPacket >> EmblemColor;
 800     recvPacket >> BorderStyle;
 801     recvPacket >> BorderColor;
 802     recvPacket >> BackgroundColor;
 803
 804     Guild *guild = objmgr.GetGuildById(GetPlayer()->GetGuildId());
 805     if(!guild)
 806     {
 807         //"You are not part of a guild!";
 808         SendSaveGuildEmblem(ERR_GUILDEMBLEM_NOGUILD);
 809         return;
 810     }
 811
 812     if (guild->GetLeader() != GetPlayer()->GetGUID())
 813     {
 814         //"Only guild leaders can create emblems."
 815         SendSaveGuildEmblem(ERR_GUILDEMBLEM_NOTGUILDMASTER);
 816         return;
 817     }
 818
 819     if(GetPlayer()->GetMoney() < 10*GOLD)
 820     {
 821         //"You can't afford to do that."
 822         SendSaveGuildEmblem(ERR_GUILDEMBLEM_NOTENOUGHMONEY);
 823         return;
 824     }
 825
 826     GetPlayer()->ModifyMoney(-10*GOLD);
 827     guild->SetEmblem(EmblemStyle, EmblemColor, BorderStyle, BorderColor, BackgroundColor);
 828
 829     //"Guild Emblem saved."
 830     SendSaveGuildEmblem(ERR_GUILDEMBLEM_SUCCESS);
 831
 832     guild->Query(this);
 833 }
 834
 835 void WorldSession::HandleGuildEventLogOpcode(WorldPacket& /* recvPacket */)
 836 {
 837                                                             // empty
 838     sLog.outDebug("WORLD: Received (MSG_GUILD_EVENT_LOG_QUERY)");
 839     //recvPacket.hexlike();
 840
 841     uint32 GuildId = GetPlayer()->GetGuildId();
 842     if (GuildId == 0)
 843         return;
 844
 845     Guild *pGuild = objmgr.GetGuildById(GuildId);
 846     if(!pGuild)
 847         return;
 848
 849     pGuild->DisplayGuildEventlog(this);
 850 }
 851
 852 /******  GUILD BANK  *******/
 853
 854 void WorldSession::HandleGuildBankGetMoneyAmount( WorldPacket & /* recv_data */ )
 855 {
 856     sLog.outDebug("WORLD: Received (MSG_GUILD_BANK_MONEY_WITHDRAWN)");
 857     //recv_data.hexlike();
 858
 859     uint32 GuildId = GetPlayer()->GetGuildId();
 860     if (GuildId == 0)
 861         return;
 862
 863     Guild *pGuild = objmgr.GetGuildById(GuildId);
 864     if(!pGuild)
 865         return;
 866
 867     pGuild->SendMoneyInfo(this, GetPlayer()->GetGUIDLow());
 868 }
 869
 870 void WorldSession::HandleGuildBankGetRights( WorldPacket& /* recv_data */ )
 871 {
 872     sLog.outDebug("WORLD: Received (MSG_GUILD_PERMISSIONS)");
 873
 874     uint32 GuildId = GetPlayer()->GetGuildId();
 875     if (GuildId == 0)
 876         return;
 877
 878     Guild *pGuild = objmgr.GetGuildById(GuildId);
 879     if(!pGuild)
 880         return;
 881
 882     uint32 rankId = GetPlayer()->GetRank();
 883
 884     WorldPacket data(MSG_GUILD_PERMISSIONS, 4*15+1);
 885     data << uint32(rankId);                                 // guild rank id
 886     data << uint32(pGuild->GetRankRights(rankId));          // rank rights
 887                                                             // money per day left
 888     data << uint32(pGuild->GetMemberMoneyWithdrawRem(GetPlayer()->GetGUIDLow()));
 889     data << uint8(pGuild->GetPurchasedTabs());              // tabs count
 890     for(int i = 0; i < GUILD_BANK_MAX_TABS; ++i)
 891     {
 892         data << uint32(pGuild->GetBankRights(rankId, uint8(i)));
 893         data << uint32(pGuild->GetMemberSlotWithdrawRem(GetPlayer()->GetGUIDLow(), uint8(i)));
 894     }
 895     SendPacket(&data);
 896     sLog.outDebug("WORLD: Sent (MSG_GUILD_PERMISSIONS)");
 897 }
 898
 899 /* Called when clicking on Guild bank gameobject */
 900 void WorldSession::HandleGuildBankQuery( WorldPacket & recv_data )
 901 {
 902     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANKER_ACTIVATE)");
 903     CHECK_PACKET_SIZE(recv_data,8+1);
 904     uint64 GoGuid;
 905     uint8  unk;
 906     recv_data >> GoGuid >> unk;
 907
 908     if (!objmgr.IsGuildVaultGameObject(_player, GoGuid))
 909         return;
 910
 911     if (uint32 GuildId = GetPlayer()->GetGuildId())
 912     {
 913         if(Guild *pGuild = objmgr.GetGuildById(GuildId))
 914         {
 915             pGuild->DisplayGuildBankTabsInfo(this);
 916             return;
 917         }
 918     }
 919
 920     SendGuildCommandResult(GUILD_BANK_S, "", GUILD_PLAYER_NOT_IN_GUILD);
 921 }
 922
 923 /* Called when opening guild bank tab only (first one) */
 924 void WorldSession::HandleGuildBankTabColon( WorldPacket & recv_data )
 925 {
 926     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_QUERY_TAB)");
 927     CHECK_PACKET_SIZE(recv_data,8+1+1);
 928     uint64 GoGuid;
 929     uint8 TabId,unk1;
 930     recv_data >> GoGuid >> TabId >> unk1;
 931
 932     if (!objmgr.IsGuildVaultGameObject(_player, GoGuid))
 933         return;
 934
 935     uint32 GuildId = GetPlayer()->GetGuildId();
 936     if (GuildId == 0)
 937         return;
 938
 939     Guild *pGuild = objmgr.GetGuildById(GuildId);
 940     if(!pGuild)
 941         return;
 942
 943     // Let's update the amount of gold the player can withdraw before displaying the content
 944     // This is usefull if money withdraw right has changed
 945     pGuild->SendMoneyInfo(this, GetPlayer()->GetGUIDLow());
 946
 947     pGuild->DisplayGuildBankContent(this, TabId);
 948 }
 949
 950 void WorldSession::HandleGuildBankDeposit( WorldPacket & recv_data )
 951 {
 952     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_DEPOSIT_MONEY)");
 953     CHECK_PACKET_SIZE(recv_data,8+4);
 954     uint64 GoGuid;
 955     uint32 money;
 956     recv_data >> GoGuid >> money;
 957
 958     if (!money)
 959         return;
 960
 961     if (!objmgr.IsGuildVaultGameObject(_player, GoGuid))
 962         return;
 963
 964     uint32 GuildId = GetPlayer()->GetGuildId();
 965     if (GuildId == 0)
 966         return;
 967
 968     Guild *pGuild = objmgr.GetGuildById(GuildId);
 969     if(!pGuild)
 970         return;
 971
 972     if (GetPlayer()->GetMoney() < money)
 973         return;
 974
 975     CharacterDatabase.BeginTransaction();
 976
 977     pGuild->SetBankMoney(pGuild->GetGuildBankMoney()+money);
 978     GetPlayer()->ModifyMoney(-int(money));
 979     GetPlayer()->SaveDataFieldToDB();                       //contains money
 980
 981     CharacterDatabase.CommitTransaction();
 982
 983     // logging money
 984     if(_player->GetSession()->GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE))
 985     {
 986         sLog.outCommand(_player->GetSession()->GetAccountId(),"GM %s (Account: %u) deposit money (Amount: %u) to guild bank (Guild ID %u)",
 987             _player->GetName(),_player->GetSession()->GetAccountId(),money,GuildId);
 988     }
 989
 990     // log
 991     pGuild->LogBankEvent(GUILD_BANK_LOG_DEPOSIT_MONEY, uint8(0), GetPlayer()->GetGUIDLow(), money);
 992
 993     pGuild->DisplayGuildBankTabsInfo(this);
 994     pGuild->DisplayGuildBankContent(this, 0);
 995     pGuild->DisplayGuildBankMoneyUpdate();
 996 }
 997
 998 void WorldSession::HandleGuildBankWithdraw( WorldPacket & recv_data )
 999 {
1000     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_WITHDRAW_MONEY)");
1001     CHECK_PACKET_SIZE(recv_data,8+4);
1002     uint64 GoGuid;
1003     uint32 money;
1004     recv_data >> GoGuid >> money;
1005
1006     if (!money)
1007         return;
1008
1009     if (!objmgr.IsGuildVaultGameObject(_player, GoGuid))
1010         return;
1011
1012     uint32 GuildId = GetPlayer()->GetGuildId();
1013     if (GuildId == 0)
1014         return;
1015
1016     Guild *pGuild = objmgr.GetGuildById(GuildId);
1017     if(!pGuild)
1018         return;
1019
1020     if (pGuild->GetGuildBankMoney()<money)                  // not enough money in bank
1021         return;
1022
1023     if (!pGuild->HasRankRight(GetPlayer()->GetRank(), GR_RIGHT_WITHDRAW_GOLD))
1024         return;
1025
1026     CharacterDatabase.BeginTransaction();
1027
1028     if (!pGuild->MemberMoneyWithdraw(money, GetPlayer()->GetGUIDLow()))
1029     {
1030         CharacterDatabase.RollbackTransaction();
1031         return;
1032     }
1033
1034     GetPlayer()->ModifyMoney(money);
1035     GetPlayer()->SaveDataFieldToDB();                       // contains money
1036
1037     CharacterDatabase.CommitTransaction();
1038
1039     // Log
1040     pGuild->LogBankEvent(GUILD_BANK_LOG_WITHDRAW_MONEY, uint8(0), GetPlayer()->GetGUIDLow(), money);
1041
1042     pGuild->SendMoneyInfo(this, GetPlayer()->GetGUIDLow());
1043     pGuild->DisplayGuildBankTabsInfo(this);
1044     pGuild->DisplayGuildBankContent(this, 0);
1045     pGuild->DisplayGuildBankMoneyUpdate();
1046 }
1047
1048 void WorldSession::HandleGuildBankDepositItem( WorldPacket & recv_data )
1049 {
1050     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_SWAP_ITEMS)");
1051     //recv_data.hexlike();
1052
1053     uint64 GoGuid;
1054     uint8 BankToBank;
1055
1056     uint8 BankTab, BankTabSlot, AutoStore, AutoStoreCount, PlayerSlot, PlayerBag, SplitedAmount = 0;
1057     uint8 BankTabDst, BankTabSlotDst, unk2, ToChar = 1;
1058     uint32 ItemEntry, unk1;
1059
1060     CHECK_PACKET_SIZE(recv_data,8+1);
1061     recv_data >> GoGuid >> BankToBank;
1062     if (BankToBank)
1063     {
1064         // recheck
1065         CHECK_PACKET_SIZE(recv_data, recv_data.rpos()+1+1+4+1+1+4+1+1);
1066         recv_data >> BankTabDst;
1067         recv_data >> BankTabSlotDst;
1068         recv_data >> unk1;                                  // always 0
1069         recv_data >> BankTab;
1070         recv_data >> BankTabSlot;
1071         recv_data >> ItemEntry;
1072         recv_data >> unk2;                                  // always 0
1073         recv_data >> SplitedAmount;
1074
1075         if (BankTabSlotDst >= GUILD_BANK_MAX_SLOTS)
1076             return;
1077         if (BankTabDst == BankTab && BankTabSlotDst == BankTabSlot)
1078             return;
1079     }
1080     else
1081     {
1082         // recheck
1083         CHECK_PACKET_SIZE(recv_data, recv_data.rpos()+1+1+4+1);
1084         recv_data >> BankTab;
1085         recv_data >> BankTabSlot;
1086         recv_data >> ItemEntry;
1087         recv_data >> AutoStore;
1088         if (AutoStore)
1089         {
1090             // recheck
1091             CHECK_PACKET_SIZE(recv_data, recv_data.rpos()+1);
1092             recv_data >> AutoStoreCount;
1093         }
1094         // recheck
1095         CHECK_PACKET_SIZE(recv_data, recv_data.rpos()+1+1);
1096         recv_data >> PlayerBag;
1097         recv_data >> PlayerSlot;
1098         if (!AutoStore)
1099         {
1100             // recheck
1101             CHECK_PACKET_SIZE(recv_data, recv_data.rpos()+1+1);
1102             recv_data >> ToChar;
1103             recv_data >> SplitedAmount;
1104         }
1105
1106         if (BankTabSlot >= GUILD_BANK_MAX_SLOTS && BankTabSlot != 0xFF)
1107             return;
1108     }
1109
1110     if (!objmgr.IsGuildVaultGameObject(_player, GoGuid))
1111         return;
1112
1113     uint32 GuildId = GetPlayer()->GetGuildId();
1114     if (GuildId == 0)
1115         return;
1116
1117     Guild *pGuild = objmgr.GetGuildById(GuildId);
1118     if(!pGuild)
1119         return;
1120
1121     Player *pl = GetPlayer();
1122
1123     // Bank <-> Bank
1124     if (BankToBank)
1125     {
1126         // empty operation
1127         if(BankTab==BankTabDst && BankTabSlot==BankTabSlotDst)
1128             return;
1129
1130         Item *pItemSrc = pGuild->GetItem(BankTab, BankTabSlot);
1131         if (!pItemSrc)                                      // may prevent crash
1132             return;
1133
1134         if(SplitedAmount > pItemSrc->GetCount())
1135             return;                                         // cheating?
1136         else if(SplitedAmount == pItemSrc->GetCount())
1137             SplitedAmount = 0;                              // no split
1138
1139         Item *pItemDst = pGuild->GetItem(BankTabDst, BankTabSlotDst);
1140
1141         if(BankTab!=BankTabDst)
1142         {
1143             // check dest pos rights (if different tabs)
1144             if(!pGuild->IsMemberHaveRights(pl->GetGUIDLow(), BankTabDst, GUILD_BANK_RIGHT_DEPOSIT_ITEM))
1145                 return;
1146
1147             // check source pos rights (if different tabs)
1148             uint32 remRight = pGuild->GetMemberSlotWithdrawRem(pl->GetGUIDLow(), BankTab);
1149             if(remRight <= 0)
1150                 return;
1151         }
1152
1153         if (SplitedAmount)
1154         {                                                   // Bank -> Bank item split (in empty or non empty slot
1155             GuildItemPosCountVec dest;
1156             uint8 msg = pGuild->CanStoreItem(BankTabDst,BankTabSlotDst,dest,SplitedAmount,pItemSrc,false);
1157             if( msg != EQUIP_ERR_OK )
1158             {
1159                 pl->SendEquipError( msg, pItemSrc, NULL );
1160                 return;
1161             }
1162
1163             Item *pNewItem = pItemSrc->CloneItem( SplitedAmount );
1164             if( !pNewItem )
1165             {
1166                 pl->SendEquipError( EQUIP_ERR_ITEM_NOT_FOUND, pItemSrc, NULL );
1167                 return;
1168             }
1169
1170             CharacterDatabase.BeginTransaction();
1171             pGuild->LogBankEvent(GUILD_BANK_LOG_MOVE_ITEM, BankTab, pl->GetGUIDLow(), pItemSrc->GetEntry(), SplitedAmount, BankTabDst);
1172
1173             pl->ItemRemovedQuestCheck( pItemSrc->GetEntry(), SplitedAmount );
1174             pItemSrc->SetCount( pItemSrc->GetCount() - SplitedAmount );
1175             pItemSrc->FSetState(ITEM_CHANGED);
1176             pItemSrc->SaveToDB();                           // not in inventory and can be save standalone
1177             pGuild->StoreItem(BankTabDst,dest,pNewItem);
1178             CharacterDatabase.CommitTransaction();
1179         }
1180         else                                                // non split
1181         {
1182             GuildItemPosCountVec gDest;
1183             uint8 msg = pGuild->CanStoreItem(BankTabDst,BankTabSlotDst,gDest,pItemSrc->GetCount(),pItemSrc,false);
1184             if( msg == EQUIP_ERR_OK )                       // merge to
1185             {
1186                 CharacterDatabase.BeginTransaction();
1187                 pGuild->LogBankEvent(GUILD_BANK_LOG_MOVE_ITEM, BankTab,    pl->GetGUIDLow(), pItemSrc->GetEntry(), pItemSrc->GetCount(), BankTabDst);
1188
1189                 pGuild->RemoveItem(BankTab, BankTabSlot);
1190                 pGuild->StoreItem(BankTabDst, gDest, pItemSrc);
1191                 CharacterDatabase.CommitTransaction();
1192             }
1193             else                                            // swap
1194             {
1195                 gDest.clear();
1196                 uint8 msg = pGuild->CanStoreItem(BankTabDst,BankTabSlotDst,gDest,pItemSrc->GetCount(),pItemSrc,true);
1197                 if( msg != EQUIP_ERR_OK )
1198                 {
1199                     pl->SendEquipError( msg, pItemSrc, NULL );
1200                     return;
1201                 }
1202
1203                 GuildItemPosCountVec gSrc;
1204                 msg = pGuild->CanStoreItem(BankTab,BankTabSlot,gSrc,pItemDst->GetCount(),pItemDst,true);
1205                 if( msg != EQUIP_ERR_OK )
1206                 {
1207                     pl->SendEquipError( msg, pItemDst, NULL );
1208                     return;
1209                 }
1210
1211                 if(BankTab!=BankTabDst)
1212                 {
1213                     // check source pos rights (item swapped to src)
1214                     if(!pGuild->IsMemberHaveRights(pl->GetGUIDLow(), BankTab, GUILD_BANK_RIGHT_DEPOSIT_ITEM))
1215                         return;
1216
1217                     // check dest pos rights (item swapped to src)
1218                     uint32 remRightDst = pGuild->GetMemberSlotWithdrawRem(pl->GetGUIDLow(), BankTabDst);
1219                     if(remRightDst <= 0)
1220                         return;
1221                 }
1222
1223                 CharacterDatabase.BeginTransaction();
1224                 pGuild->LogBankEvent(GUILD_BANK_LOG_MOVE_ITEM, BankTab,    pl->GetGUIDLow(), pItemSrc->GetEntry(), pItemSrc->GetCount(), BankTabDst);
1225                 pGuild->LogBankEvent(GUILD_BANK_LOG_MOVE_ITEM, BankTabDst, pl->GetGUIDLow(), pItemDst->GetEntry(), pItemDst->GetCount(), BankTab);
1226
1227                 pGuild->RemoveItem(BankTab, BankTabSlot);
1228                 pGuild->RemoveItem(BankTabDst, BankTabSlotDst);
1229                 pGuild->StoreItem(BankTab, gSrc, pItemDst);
1230                 pGuild->StoreItem(BankTabDst, gDest, pItemSrc);
1231                 CharacterDatabase.CommitTransaction();
1232             }
1233         }
1234         pGuild->DisplayGuildBankContentUpdate(BankTab,BankTabSlot,BankTab==BankTabDst ? BankTabSlotDst : -1);
1235         if(BankTab!=BankTabDst)
1236             pGuild->DisplayGuildBankContentUpdate(BankTabDst,BankTabSlotDst);
1237         return;
1238     }
1239
1240     // Player <-> Bank
1241
1242     // char->bank autostore click return BankTabSlot = 255 = NULL_SLOT
1243     // do similar for bank->char
1244     if(AutoStore && ToChar)
1245     {
1246         PlayerBag = NULL_BAG;
1247         PlayerSlot = NULL_SLOT;
1248     }
1249
1250     // allow work with inventory only
1251     if(!Player::IsInventoryPos(PlayerBag,PlayerSlot) && !(PlayerBag == NULL_BAG && PlayerSlot == NULL_SLOT) )
1252     {
1253         _player->SendEquipError( EQUIP_ERR_NONE, NULL, NULL );
1254         return;
1255     }
1256
1257     Item *pItemBank = pGuild->GetItem(BankTab, BankTabSlot);
1258     Item *pItemChar = GetPlayer()->GetItemByPos(PlayerBag, PlayerSlot);
1259     if (!pItemChar && !pItemBank)                           // Nothing to do
1260         return;
1261
1262     if (!pItemChar && !ToChar)                              // Problem to get item from player
1263         return;
1264
1265     if (!pItemBank && ToChar)                               // Problem to get bank item
1266         return;
1267
1268     // BankToChar swap or char to bank remaining
1269
1270     if (ToChar)                                             // Bank -> Char cases
1271     {
1272         if(SplitedAmount > pItemBank->GetCount())
1273             return;                                         // cheating?
1274         else if(SplitedAmount == pItemBank->GetCount())
1275             SplitedAmount = 0;                              // no split
1276
1277         if (SplitedAmount)
1278         {                                                   // Bank -> Char split to slot (patly move)
1279             Item *pNewItem = pItemBank->CloneItem( SplitedAmount );
1280             if( !pNewItem )
1281             {
1282                 pl->SendEquipError( EQUIP_ERR_ITEM_NOT_FOUND, pItemBank, NULL );
1283                 return;
1284             }
1285
1286             ItemPosCountVec dest;
1287             uint8 msg = pl->CanStoreItem(PlayerBag, PlayerSlot, dest, pNewItem, false);
1288             if( msg != EQUIP_ERR_OK )
1289             {
1290                 pl->SendEquipError( msg, pNewItem, NULL );
1291                 delete pNewItem;
1292                 return;
1293             }
1294
1295             // check source pos rights (item moved to inventory)
1296             uint32 remRight = pGuild->GetMemberSlotWithdrawRem(pl->GetGUIDLow(), BankTab);
1297             if(remRight <= 0)
1298             {
1299                 delete pNewItem;
1300                 return;
1301             }
1302
1303             CharacterDatabase.BeginTransaction();
1304             pGuild->LogBankEvent(GUILD_BANK_LOG_WITHDRAW_ITEM, BankTab, pl->GetGUIDLow(), pItemBank->GetEntry(), SplitedAmount);
1305
1306             pItemBank->SetCount(pItemBank->GetCount()-SplitedAmount);
1307             pItemBank->FSetState(ITEM_CHANGED);
1308             pItemBank->SaveToDB();                          // not in inventory and can be save standalone
1309             pl->MoveItemToInventory(dest,pNewItem,true);
1310             pl->SaveInventoryAndGoldToDB();
1311
1312             pGuild->MemberItemWithdraw(BankTab, pl->GetGUIDLow());
1313             CharacterDatabase.CommitTransaction();
1314         }
1315         else                                                // Bank -> Char swap with slot (move)
1316         {
1317             ItemPosCountVec dest;
1318             uint8 msg = pl->CanStoreItem(PlayerBag, PlayerSlot, dest, pItemBank, false);
1319             if( msg == EQUIP_ERR_OK )                       // merge case
1320             {
1321                 // check source pos rights (item moved to inventory)
1322                 uint32 remRight = pGuild->GetMemberSlotWithdrawRem(pl->GetGUIDLow(), BankTab);
1323                 if(remRight <= 0)
1324                     return;
1325
1326                 CharacterDatabase.BeginTransaction();
1327                 pGuild->LogBankEvent(GUILD_BANK_LOG_WITHDRAW_ITEM, BankTab, pl->GetGUIDLow(), pItemBank->GetEntry(), pItemBank->GetCount());
1328
1329                 pGuild->RemoveItem(BankTab, BankTabSlot);
1330                 pl->MoveItemToInventory(dest,pItemBank,true);
1331                 pl->SaveInventoryAndGoldToDB();
1332
1333                 pGuild->MemberItemWithdraw(BankTab, pl->GetGUIDLow());
1334                 CharacterDatabase.CommitTransaction();
1335             }
1336             else                                            // Bank <-> Char swap items
1337             {
1338                 // check source pos rights (item swapped to bank)
1339                 if(!pGuild->IsMemberHaveRights(pl->GetGUIDLow(), BankTab, GUILD_BANK_RIGHT_DEPOSIT_ITEM))
1340                     return;
1341
1342                 if(pItemChar)
1343                 {
1344                     if(!pItemChar->CanBeTraded())
1345                     {
1346                         _player->SendEquipError( EQUIP_ERR_ITEMS_CANT_BE_SWAPPED, pItemChar, NULL );
1347                         return;
1348                     }
1349                 }
1350
1351                 ItemPosCountVec iDest;
1352                 msg = pl->CanStoreItem(PlayerBag, PlayerSlot, iDest, pItemBank, true);
1353                 if( msg != EQUIP_ERR_OK )
1354                 {
1355                     pl->SendEquipError( msg, pItemBank, NULL );
1356                     return;
1357                 }
1358
1359                 GuildItemPosCountVec gDest;
1360                 if(pItemChar)
1361                 {
1362                     msg = pGuild->CanStoreItem(BankTab,BankTabSlot,gDest,pItemChar->GetCount(),pItemChar,true);
1363                     if( msg != EQUIP_ERR_OK )
1364                     {
1365                         pl->SendEquipError( msg, pItemChar, NULL );
1366                         return;
1367                     }
1368                 }
1369
1370                 // check source pos rights (item moved to inventory)
1371                 uint32 remRight = pGuild->GetMemberSlotWithdrawRem(pl->GetGUIDLow(), BankTab);
1372                 if(remRight <= 0)
1373                     return;
1374
1375                 if(pItemChar)
1376                 {
1377                     // logging item move to bank
1378                     if(_player->GetSession()->GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE))
1379                     {
1380                         sLog.outCommand(_player->GetSession()->GetAccountId(),"GM %s (Account: %u) deposit item: %s (Entry: %d Count: %u) to guild bank (Guild ID: %u )",
1381                             _player->GetName(),_player->GetSession()->GetAccountId(),
1382                             pItemChar->GetProto()->Name1,pItemChar->GetEntry(),pItemChar->GetCount(),
1383                             GuildId);
1384                     }
1385                 }
1386
1387                 CharacterDatabase.BeginTransaction();
1388                 pGuild->LogBankEvent(GUILD_BANK_LOG_WITHDRAW_ITEM, BankTab, pl->GetGUIDLow(), pItemBank->GetEntry(), pItemBank->GetCount());
1389                 if(pItemChar)
1390                     pGuild->LogBankEvent(GUILD_BANK_LOG_DEPOSIT_ITEM, BankTab, pl->GetGUIDLow(), pItemChar->GetEntry(), pItemChar->GetCount());
1391
1392                 pGuild->RemoveItem(BankTab, BankTabSlot);
1393                 if(pItemChar)
1394                 {
1395                     pl->MoveItemFromInventory(PlayerBag, PlayerSlot, true);
1396                     pItemChar->DeleteFromInventoryDB();
1397                 }
1398
1399                 if(pItemChar)
1400                     pGuild->StoreItem(BankTab, gDest, pItemChar);
1401                 pl->MoveItemToInventory(iDest,pItemBank,true);
1402                 pl->SaveInventoryAndGoldToDB();
1403
1404                 pGuild->MemberItemWithdraw(BankTab, pl->GetGUIDLow());
1405                 CharacterDatabase.CommitTransaction();
1406             }
1407         }
1408         pGuild->DisplayGuildBankContentUpdate(BankTab,BankTabSlot);
1409         return;
1410     }                                                       // End "To char" part
1411
1412     // Char -> Bank cases
1413
1414     if(!pItemChar->CanBeTraded())
1415     {
1416         _player->SendEquipError( EQUIP_ERR_ITEMS_CANT_BE_SWAPPED, pItemChar, NULL );
1417         return;
1418     }
1419
1420     // check source pos rights (item moved to bank)
1421     if(!pGuild->IsMemberHaveRights(pl->GetGUIDLow(), BankTab, GUILD_BANK_RIGHT_DEPOSIT_ITEM))
1422         return;
1423
1424     if(SplitedAmount > pItemChar->GetCount())
1425         return;                                             // cheating?
1426     else if(SplitedAmount == pItemChar->GetCount())
1427         SplitedAmount = 0;                                  // no split
1428
1429     if (SplitedAmount)
1430     {                                                       // Char -> Bank split to empty or non-empty slot (partly move)
1431         GuildItemPosCountVec dest;
1432         uint8 msg = pGuild->CanStoreItem(BankTab,BankTabSlot,dest,SplitedAmount,pItemChar,false);
1433         if( msg != EQUIP_ERR_OK )
1434         {
1435             pl->SendEquipError( msg, pItemChar, NULL );
1436             return;
1437         }
1438
1439         Item *pNewItem = pItemChar->CloneItem( SplitedAmount );
1440         if( !pNewItem )
1441         {
1442             pl->SendEquipError( EQUIP_ERR_ITEM_NOT_FOUND, pItemChar, NULL );
1443             return;
1444         }
1445
1446         // logging item move to bank (before items merge
1447         if(_player->GetSession()->GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE))
1448         {
1449             sLog.outCommand(_player->GetSession()->GetAccountId(),"GM %s (Account: %u) deposit item: %s (Entry: %d Count: %u) to guild bank (Guild ID: %u )",
1450                 _player->GetName(),_player->GetSession()->GetAccountId(),
1451                 pItemChar->GetProto()->Name1,pItemChar->GetEntry(),SplitedAmount,GuildId);
1452         }
1453
1454         CharacterDatabase.BeginTransaction();
1455         pGuild->LogBankEvent(GUILD_BANK_LOG_DEPOSIT_ITEM, BankTab, pl->GetGUIDLow(), pItemChar->GetEntry(), SplitedAmount);
1456
1457         pl->ItemRemovedQuestCheck( pItemChar->GetEntry(), SplitedAmount );
1458         pItemChar->SetCount(pItemChar->GetCount()-SplitedAmount);
1459         pItemChar->SetState(ITEM_CHANGED);
1460         pl->SaveInventoryAndGoldToDB();
1461         pGuild->StoreItem(BankTab, dest, pNewItem);
1462         CharacterDatabase.CommitTransaction();
1463
1464         pGuild->DisplayGuildBankContentUpdate(BankTab,dest);
1465     }
1466     else                                                    // Char -> Bank swap with empty or non-empty (move)
1467     {
1468         GuildItemPosCountVec dest;
1469         uint8 msg = pGuild->CanStoreItem(BankTab,BankTabSlot,dest,pItemChar->GetCount(),pItemChar,false);
1470         if( msg == EQUIP_ERR_OK )                           // merge
1471         {
1472             // logging item move to bank
1473             if(_player->GetSession()->GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE))
1474             {
1475                 sLog.outCommand(_player->GetSession()->GetAccountId(),"GM %s (Account: %u) deposit item: %s (Entry: %d Count: %u) to guild bank (Guild ID: %u )",
1476                     _player->GetName(),_player->GetSession()->GetAccountId(),
1477                     pItemChar->GetProto()->Name1,pItemChar->GetEntry(),pItemChar->GetCount(),
1478                     GuildId);
1479             }
1480
1481             CharacterDatabase.BeginTransaction();
1482             pGuild->LogBankEvent(GUILD_BANK_LOG_DEPOSIT_ITEM, BankTab, pl->GetGUIDLow(), pItemChar->GetEntry(), pItemChar->GetCount());
1483
1484             pl->MoveItemFromInventory(PlayerBag, PlayerSlot, true);
1485             pItemChar->DeleteFromInventoryDB();
1486
1487             pGuild->StoreItem(BankTab,dest,pItemChar);
1488             pl->SaveInventoryAndGoldToDB();
1489             CharacterDatabase.CommitTransaction();
1490
1491             pGuild->DisplayGuildBankContentUpdate(BankTab,dest);
1492         }
1493         else                                                // Char <-> Bank swap items (posible NULL bank item)
1494         {
1495             ItemPosCountVec iDest;
1496             if(pItemBank)
1497             {
1498                 msg = pl->CanStoreItem(PlayerBag, PlayerSlot, iDest, pItemBank, true);
1499                 if( msg != EQUIP_ERR_OK )
1500                 {
1501                     pl->SendEquipError( msg, pItemBank, NULL );
1502                     return;
1503                 }
1504             }
1505
1506             GuildItemPosCountVec gDest;
1507             msg = pGuild->CanStoreItem(BankTab,BankTabSlot,gDest,pItemChar->GetCount(),pItemChar,true);
1508             if( msg != EQUIP_ERR_OK )
1509             {
1510                 pl->SendEquipError( msg, pItemChar, NULL );
1511                 return;
1512             }
1513
1514             if(pItemBank)
1515             {
1516                 // check bank pos rights (item swapped with inventory)
1517                 uint32 remRight = pGuild->GetMemberSlotWithdrawRem(pl->GetGUIDLow(), BankTab);
1518                 if(remRight <= 0)
1519                     return;
1520             }
1521
1522             // logging item move to bank
1523             if(_player->GetSession()->GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE))
1524             {
1525                 sLog.outCommand(_player->GetSession()->GetAccountId(),"GM %s (Account: %u) deposit item: %s (Entry: %d Count: %u) to guild bank (Guild ID: %u )",
1526                     _player->GetName(),_player->GetSession()->GetAccountId(),
1527                     pItemChar->GetProto()->Name1,pItemChar->GetEntry(),pItemChar->GetCount(),
1528                     GuildId);
1529             }
1530
1531             CharacterDatabase.BeginTransaction();
1532             if(pItemBank)
1533                 pGuild->LogBankEvent(GUILD_BANK_LOG_WITHDRAW_ITEM, BankTab, pl->GetGUIDLow(), pItemBank->GetEntry(), pItemBank->GetCount());
1534             pGuild->LogBankEvent(GUILD_BANK_LOG_DEPOSIT_ITEM, BankTab, pl->GetGUIDLow(), pItemChar->GetEntry(), pItemChar->GetCount());
1535
1536             pl->MoveItemFromInventory(PlayerBag, PlayerSlot, true);
1537             pItemChar->DeleteFromInventoryDB();
1538             if(pItemBank)
1539                 pGuild->RemoveItem(BankTab, BankTabSlot);
1540
1541             pGuild->StoreItem(BankTab,gDest,pItemChar);
1542             if(pItemBank)
1543                 pl->MoveItemToInventory(iDest,pItemBank,true);
1544             pl->SaveInventoryAndGoldToDB();
1545             if(pItemBank)
1546                 pGuild->MemberItemWithdraw(BankTab, pl->GetGUIDLow());
1547             CharacterDatabase.CommitTransaction();
1548
1549             pGuild->DisplayGuildBankContentUpdate(BankTab,gDest);
1550         }
1551     }
1552 }
1553
1554 void WorldSession::HandleGuildBankBuyTab( WorldPacket & recv_data )
1555 {
1556     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_BUY_TAB)");
1557     CHECK_PACKET_SIZE(recv_data, 8+1);
1558     //recv_data.hexlike();
1559     uint64 GoGuid;
1560     uint8 TabId;
1561
1562     recv_data >> GoGuid;
1563     recv_data >> TabId;
1564
1565     if (!objmgr.IsGuildVaultGameObject(_player, GoGuid))
1566         return;
1567
1568     uint32 GuildId = GetPlayer()->GetGuildId();
1569     if (GuildId==0)
1570         return;
1571
1572     Guild *pGuild = objmgr.GetGuildById(GuildId);
1573     if(!pGuild)
1574         return;
1575
1576     uint32 TabCost = objmgr.GetGuildBankTabPrice(TabId) * GOLD;
1577     if (!TabCost)
1578         return;
1579
1580     if (pGuild->GetPurchasedTabs() >= GUILD_BANK_MAX_TABS)
1581         return;
1582
1583     if (TabId != pGuild->GetPurchasedTabs())                // purchased_tabs = 0 when buying Tab 0, that is why this check can be made
1584     {
1585         sLog.outError("Error: trying to buy a tab non contigous to owned ones");
1586         return;
1587     }
1588
1589     if (GetPlayer()->GetMoney() < TabCost)                  // Should not happen, this is checked by client
1590         return;
1591
1592     // Go on with creating tab
1593     pGuild->CreateNewBankTab();
1594     GetPlayer()->ModifyMoney(-int(TabCost));
1595     pGuild->SetBankMoneyPerDay(GetPlayer()->GetRank(), WITHDRAW_MONEY_UNLIMITED);
1596     pGuild->SetBankRightsAndSlots(GetPlayer()->GetRank(), TabId, GUILD_BANK_RIGHT_FULL, WITHDRAW_SLOT_UNLIMITED, true);
1597     pGuild->Roster(this);
1598     pGuild->DisplayGuildBankTabsInfo(this);
1599 }
1600
1601 void WorldSession::HandleGuildBankModifyTab( WorldPacket & recv_data )
1602 {
1603     sLog.outDebug("WORLD: Received (CMSG_GUILD_BANK_UPDATE_TAB)");
1604     //recv_data.hexlike();
1605     CHECK_PACKET_SIZE(recv_data, 8+1+1+1);
1606     uint64 GoGuid;
1607     uint8 TabId;
1608     std::string Name;
1609     std::string IconIndex;
1610
1611     recv_data >> GoGuid;
1612     recv_data >> TabId;
1613     recv_data >> Name;
1614     recv_data >> IconIndex;
1615
1616     if(Name.empty())
1617         return;
1618
1619     if(IconIndex.empty())
1620         return;
1621
1622     if (!objmgr.IsGuildVaultGameObject(_player, GoGuid))
1623         return;
1624
1625     uint32 GuildId = GetPlayer()->GetGuildId();
1626     if (GuildId==0)
1627         return;
1628
1629     Guild *pGuild = objmgr.GetGuildById(GuildId);
1630     if(!pGuild)
1631         return;
1632
1633     pGuild->SetGuildBankTabInfo(TabId, Name, IconIndex);
1634     pGuild->DisplayGuildBankTabsInfo(this);
1635     pGuild->DisplayGuildBankContent(this, TabId);
1636 }
1637
1638 void WorldSession::HandleGuildBankLog( WorldPacket & recv_data )
1639 {
1640     sLog.outDebug("WORLD: Received (MSG_GUILD_BANK_LOG_QUERY)");
1641     CHECK_PACKET_SIZE(recv_data, 1);
1642
1643     uint32 GuildId = GetPlayer()->GetGuildId();
1644     if (GuildId == 0)
1645         return;
1646
1647     Guild *pGuild = objmgr.GetGuildById(GuildId);
1648     if(!pGuild)
1649         return;
1650
1651     uint8 TabId;
1652     recv_data >> TabId;
1653
1654     pGuild->DisplayGuildBankLogs(this, TabId);
1655 }
1656
1657 void WorldSession::HandleGuildBankTabText(WorldPacket &recv_data)
1658 {
1659     sLog.outDebug("WORLD: Received MSG_QUERY_GUILD_BANK_TEXT");
1660     CHECK_PACKET_SIZE(recv_data, 1);
1661
1662     uint32 GuildId = GetPlayer()->GetGuildId();
1663     if (GuildId == 0)
1664         return;
1665
1666     Guild *pGuild = objmgr.GetGuildById(GuildId);
1667     if(!pGuild)
1668         return;
1669
1670     uint8 TabId;
1671     recv_data >> TabId;
1672
1673     pGuild->SendGuildBankTabText(this, TabId);
1674 }
1675
1676 void WorldSession::HandleGuildBankSetTabText(WorldPacket &recv_data)
1677 {
1678     sLog.outDebug("WORLD: Received CMSG_SET_GUILD_BANK_TEXT");
1679     CHECK_PACKET_SIZE(recv_data, 1+1);
1680
1681     uint32 GuildId = GetPlayer()->GetGuildId();
1682     if (GuildId == 0)
1683         return;
1684
1685     Guild *pGuild = objmgr.GetGuildById(GuildId);
1686     if(!pGuild)
1687         return;
1688
1689     uint8 TabId;
1690     std::string Text;
1691     recv_data >> TabId;
1692     recv_data >> Text;
1693
1694     pGuild->SetGuildBankTabText(TabId, Text);
1695 }
1696
1697 void WorldSession::SendSaveGuildEmblem( uint32 msg )
1698 {
1699     WorldPacket data(MSG_SAVE_GUILD_EMBLEM, 4);
1700     data << uint32(msg);                                    // not part of guild
1701     SendPacket( &data );
1702 }