root/trunk/src/game/GuildHandler.cpp @ 131

Revision 102, 55.1 kB (checked in by yumileroy, 17 years ago)

[svn] Fixed copyright notices to comply with GPL.

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