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

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

[svn] * Proper SVN structure

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