src/game/Mail.cpp

   1 /*
   2  * Copyright (C) 2005-2010 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Mail.h"
  20 #include "WorldPacket.h"
  21 #include "WorldSession.h"
  22 #include "Opcodes.h"
  23 #include "Log.h"
  24 #include "World.h"
  25 #include "ObjectMgr.h"
  26 #include "ObjectDefines.h"
  27 #include "Player.h"
  28 #include "UpdateMask.h"
  29 #include "Unit.h"
  30 #include "Language.h"
  31 #include "DBCStores.h"
  32 #include "BattleGroundMgr.h"
  33 #include "Item.h"
  34 #include "AuctionHouseMgr.h"
  35
  36 enum MailShowFlags
  37 {
  38     MAIL_SHOW_UNK0    = 0x0001,
  39     MAIL_SHOW_DELETE  = 0x0002,                             // forced show delete button instead return button
  40     MAIL_SHOW_AUCTION = 0x0004,                             // from old comment
  41     MAIL_SHOW_UNK2    = 0x0008,                             // unknown, COD will be shown even without that flag
  42     MAIL_SHOW_RETURN  = 0x0010,
  43 };
  44
  45 void WorldSession::HandleSendMail(WorldPacket & recv_data )
  46 {
  47     uint64 mailbox, unk3;
  48     std::string receiver, subject, body;
  49     uint32 unk1, unk2, money, COD;
  50     uint8 unk4;
  51     recv_data >> mailbox;
  52     recv_data >> receiver;
  53
  54     recv_data >> subject;
  55
  56     recv_data >> body;
  57
  58     recv_data >> unk1;                                      // stationery?
  59     recv_data >> unk2;                                      // 0x00000000
  60
  61     uint8 items_count;
  62     recv_data >> items_count;                               // attached items count
  63
  64     if (items_count > MAX_MAIL_ITEMS)                       // client limit
  65     {
  66         GetPlayer()->SendMailResult(0, MAIL_SEND, MAIL_ERR_TOO_MANY_ATTACHMENTS);
  67         recv_data.rpos(recv_data.wpos());                   // set to end to avoid warnings spam
  68         return;
  69     }
  70
  71     uint64 itemGUIDs[MAX_MAIL_ITEMS];
  72
  73     for(uint8 i = 0; i < items_count; ++i)
  74     {
  75         recv_data.read_skip<uint8>();                       // item slot in mail, not used
  76         recv_data >> itemGUIDs[i];
  77     }
  78
  79     recv_data >> money >> COD;                              // money and cod
  80     recv_data >> unk3;                                      // const 0
  81     recv_data >> unk4;                                      // const 0
  82
  83     // packet read complete, now do check
  84
  85     if (!GetPlayer()->GetGameObjectIfCanInteractWith(mailbox, GAMEOBJECT_TYPE_MAILBOX))
  86         return;
  87
  88     if (receiver.empty())
  89         return;
  90
  91     Player* pl = _player;
  92
  93     uint64 rc = 0;
  94     if (normalizePlayerName(receiver))
  95         rc = sObjectMgr.GetPlayerGUIDByName(receiver);
  96
  97     if (!rc)
  98     {
  99         sLog.outDetail("Player %u is sending mail to %s (GUID: not existed!) with subject %s and body %s includes %u items, %u copper and %u COD copper with unk1 = %u, unk2 = %u",
 100             pl->GetGUIDLow(), receiver.c_str(), subject.c_str(), body.c_str(), items_count, money, COD, unk1, unk2);
 101         pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_RECIPIENT_NOT_FOUND);
 102         return;
 103     }
 104
 105     sLog.outDetail("Player %u is sending mail to %s (GUID: %u) with subject %s and body %s includes %u items, %u copper and %u COD copper with unk1 = %u, unk2 = %u", pl->GetGUIDLow(), receiver.c_str(), GUID_LOPART(rc), subject.c_str(), body.c_str(), items_count, money, COD, unk1, unk2);
 106
 107     if (pl->GetGUID() == rc)
 108     {
 109         pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_CANNOT_SEND_TO_SELF);
 110         return;
 111     }
 112
 113     uint32 cost = items_count ? 30 * items_count : 30;      // price hardcoded in client
 114
 115     uint32 reqmoney = cost + money;
 116
 117     if (pl->GetMoney() < reqmoney)
 118     {
 119         pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_NOT_ENOUGH_MONEY);
 120         return;
 121     }
 122
 123     Player *receive = sObjectMgr.GetPlayer(rc);
 124
 125     uint32 rc_team = 0;
 126     uint8 mails_count = 0;                                  // do not allow to send to one player more than 100 mails
 127
 128     if (receive)
 129     {
 130         rc_team = receive->GetTeam();
 131         mails_count = receive->GetMailSize();
 132     }
 133     else
 134     {
 135         rc_team = sObjectMgr.GetPlayerTeamByGUID(rc);
 136         if (QueryResult* result = CharacterDatabase.PQuery("SELECT COUNT(*) FROM mail WHERE receiver = '%u'", GUID_LOPART(rc)))
 137         {
 138             Field *fields = result->Fetch();
 139             mails_count = fields[0].GetUInt32();
 140             delete result;
 141         }
 142     }
 143
 144     //do not allow to have more than 100 mails in mailbox.. mails count is in opcode uint8!!! - so max can be 255..
 145     if (mails_count > 100)
 146     {
 147         pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_RECIPIENT_CAP_REACHED);
 148         return;
 149     }
 150
 151     // check the receiver's Faction...
 152     if (!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_MAIL) && pl->GetTeam() != rc_team && GetSecurity() == SEC_PLAYER)
 153     {
 154         pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_NOT_YOUR_TEAM);
 155         return;
 156     }
 157
 158     uint32 rc_account = receive
 159         ? receive->GetSession()->GetAccountId()
 160         : sObjectMgr.GetPlayerAccountIdByGUID(rc);
 161
 162     Item* items[MAX_MAIL_ITEMS];
 163
 164     for(uint8 i = 0; i < items_count; ++i)
 165     {
 166         if (!itemGUIDs[i])
 167         {
 168             pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_MAIL_ATTACHMENT_INVALID);
 169             return;
 170         }
 171
 172         Item* item = pl->GetItemByGuid(itemGUIDs[i]);
 173
 174         // prevent sending bag with items (cheat: can be placed in bag after adding equipped empty bag to mail)
 175         if(!item)
 176         {
 177             pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_MAIL_ATTACHMENT_INVALID);
 178             return;
 179         }
 180
 181         if (!item->CanBeTraded(true))
 182         {
 183             pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_MAIL_BOUND_ITEM);
 184             return;
 185         }
 186
 187         if (item->IsBoundAccountWide() && item->IsSoulBound() && pl->GetSession()->GetAccountId() != rc_account)
 188         {
 189             pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_ARTEFACTS_ONLY_FOR_OWN_CHARACTERS);
 190             return;
 191         }
 192
 193         if (item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_CONJURED) || item->GetUInt32Value(ITEM_FIELD_DURATION))
 194         {
 195             pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_EQUIP_ERROR, EQUIP_ERR_MAIL_BOUND_ITEM);
 196             return;
 197         }
 198
 199         if (COD && item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_WRAPPED))
 200         {
 201             pl->SendMailResult(0, MAIL_SEND, MAIL_ERR_CANT_SEND_WRAPPED_COD);
 202             return;
 203         }
 204
 205         items[i] = item;
 206     }
 207
 208     pl->SendMailResult(0, MAIL_SEND, MAIL_OK);
 209
 210     uint32 itemTextId = !body.empty() ? sObjectMgr.CreateItemText( body ) : 0;
 211
 212     pl->ModifyMoney( -int32(reqmoney) );
 213     pl->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL, cost);
 214
 215     bool needItemDelay = false;
 216
 217     MailDraft draft(subject, itemTextId);
 218
 219     if (items_count > 0 || money > 0)
 220     {
 221         if (items_count > 0)
 222         {
 223             for(uint8 i = 0; i < items_count; ++i)
 224             {
 225                 Item* item = items[i];
 226                 if (GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE))
 227                 {
 228                     sLog.outCommand(GetAccountId(), "GM %s (Account: %u) mail item: %s (Entry: %u Count: %u) to player: %s (Account: %u)",
 229                         GetPlayerName(), GetAccountId(), item->GetProto()->Name1, item->GetEntry(), item->GetCount(), receiver.c_str(), rc_account);
 230                 }
 231
 232                 pl->MoveItemFromInventory(items[i]->GetBagSlot(), item->GetSlot(), true);
 233                 CharacterDatabase.BeginTransaction();
 234                 item->DeleteFromInventoryDB();     // deletes item from character's inventory
 235                 item->SaveToDB();                  // recursive and not have transaction guard into self, item not in inventory and can be save standalone
 236                 // owner in data will set at mail receive and item extracting
 237                 CharacterDatabase.PExecute("UPDATE item_instance SET owner_guid = '%u' WHERE guid='%u'", GUID_LOPART(rc), item->GetGUIDLow());
 238                 CharacterDatabase.CommitTransaction();
 239
 240                 draft.AddItem(item);
 241             }
 242
 243             // if item send to character at another account, then apply item delivery delay
 244             needItemDelay = pl->GetSession()->GetAccountId() != rc_account;
 245         }
 246
 247         if (money > 0 &&  GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE))
 248         {
 249             sLog.outCommand(GetAccountId(),"GM %s (Account: %u) mail money: %u to player: %s (Account: %u)",
 250                 GetPlayerName(), GetAccountId(), money, receiver.c_str(), rc_account);
 251         }
 252     }
 253
 254     // If theres is an item, there is a one hour delivery delay if sent to another account's character.
 255     uint32 deliver_delay = needItemDelay ? sWorld.getConfig(CONFIG_MAIL_DELIVERY_DELAY) : 0;
 256
 257     // will delete item or place to receiver mail list
 258     draft
 259         .AddMoney(money)
 260         .AddCOD(COD)
 261         .SendMailTo(MailReceiver(receive, GUID_LOPART(rc)), pl, MAIL_CHECK_MASK_NONE, deliver_delay);
 262
 263     CharacterDatabase.BeginTransaction();
 264     pl->SaveInventoryAndGoldToDB();
 265     CharacterDatabase.CommitTransaction();
 266 }
 267
 268 //called when mail is read
 269 void WorldSession::HandleMailMarkAsRead(WorldPacket & recv_data )
 270 {
 271     uint64 mailbox;
 272     uint32 mailId;
 273     recv_data >> mailbox;
 274     recv_data >> mailId;
 275
 276     if (!GetPlayer()->GetGameObjectIfCanInteractWith(mailbox, GAMEOBJECT_TYPE_MAILBOX))
 277         return;
 278
 279     Player *pl = _player;
 280     Mail *m = pl->GetMail(mailId);
 281     if (m)
 282     {
 283         if (pl->unReadMails)
 284             --pl->unReadMails;
 285         m->checked = m->checked | MAIL_CHECK_MASK_READ;
 286         // m->expire_time = time(NULL) + (30 * DAY);        // Expire time do not change at reading mail
 287         pl->m_mailsUpdated = true;
 288         m->state = MAIL_STATE_CHANGED;
 289     }
 290 }
 291
 292 //called when client deletes mail
 293 void WorldSession::HandleMailDelete(WorldPacket & recv_data )
 294 {
 295     uint64 mailbox;
 296     uint32 mailId;
 297     recv_data >> mailbox;
 298     recv_data >> mailId;
 299     recv_data.read_skip<uint32>();                          // mailTemplateId
 300
 301     if (!GetPlayer()->GetGameObjectIfCanInteractWith(mailbox, GAMEOBJECT_TYPE_MAILBOX))
 302         return;
 303
 304     Player* pl = _player;
 305     pl->m_mailsUpdated = true;
 306     Mail *m = pl->GetMail(mailId);
 307     if(m)
 308     {
 309         // delete shouldn't show up for COD mails
 310         if (m->COD)
 311         {
 312             pl->SendMailResult(mailId, MAIL_DELETED, MAIL_ERR_INTERNAL_ERROR);
 313             return;
 314         }
 315
 316         m->state = MAIL_STATE_DELETED;
 317     }
 318     pl->SendMailResult(mailId, MAIL_DELETED, MAIL_OK);
 319 }
 320
 321 void WorldSession::HandleMailReturnToSender(WorldPacket & recv_data )
 322 {
 323     uint64 mailbox;
 324     uint32 mailId;
 325     recv_data >> mailbox;
 326     recv_data >> mailId;
 327     recv_data.read_skip<uint64>();                          // original sender GUID for return to, not used
 328
 329     if (!GetPlayer()->GetGameObjectIfCanInteractWith(mailbox, GAMEOBJECT_TYPE_MAILBOX))
 330         return;
 331
 332     Player *pl = _player;
 333     Mail *m = pl->GetMail(mailId);
 334     if(!m || m->state == MAIL_STATE_DELETED || m->deliver_time > time(NULL))
 335     {
 336         pl->SendMailResult(mailId, MAIL_RETURNED_TO_SENDER, MAIL_ERR_INTERNAL_ERROR);
 337         return;
 338     }
 339     //we can return mail now
 340     //so firstly delete the old one
 341     CharacterDatabase.BeginTransaction();
 342     CharacterDatabase.PExecute("DELETE FROM mail WHERE id = '%u'", mailId);
 343                                                             // needed?
 344     CharacterDatabase.PExecute("DELETE FROM mail_items WHERE mail_id = '%u'", mailId);
 345     CharacterDatabase.CommitTransaction();
 346     pl->RemoveMail(mailId);
 347
 348     // send back only to players and simple drop for other cases
 349     if (m->messageType == MAIL_NORMAL)
 350     {
 351         MailDraft draft(m->subject, m->itemTextId);
 352         if (m->mailTemplateId)
 353             draft = MailDraft(m->mailTemplateId,false);     // items already included
 354
 355         if(m->HasItems())
 356         {
 357             for(std::vector<MailItemInfo>::iterator itr2 = m->items.begin(); itr2 != m->items.end(); ++itr2)
 358             {
 359                 Item *item = pl->GetMItem(itr2->item_guid);
 360                 if(item)
 361                     draft.AddItem(item);
 362                 else
 363                 {
 364                     //WTF?
 365                 }
 366
 367                 pl->RemoveMItem(itr2->item_guid);
 368             }
 369         }
 370
 371         draft.AddMoney(m->money).SendReturnToSender(GetAccountId(), m->receiver, m->sender);
 372     }
 373
 374     delete m;                                               // we can deallocate old mail
 375     pl->SendMailResult(mailId, MAIL_RETURNED_TO_SENDER, MAIL_OK);
 376 }
 377
 378 //called when player takes item attached in mail
 379 void WorldSession::HandleMailTakeItem(WorldPacket & recv_data )
 380 {
 381     uint64 mailbox;
 382     uint32 mailId;
 383     uint32 itemId;
 384     recv_data >> mailbox;
 385     recv_data >> mailId;
 386     recv_data >> itemId;                                    // item guid low
 387
 388     if (!GetPlayer()->GetGameObjectIfCanInteractWith(mailbox, GAMEOBJECT_TYPE_MAILBOX))
 389         return;
 390
 391     Player* pl = _player;
 392
 393     Mail* m = pl->GetMail(mailId);
 394     if(!m || m->state == MAIL_STATE_DELETED || m->deliver_time > time(NULL))
 395     {
 396         pl->SendMailResult(mailId, MAIL_ITEM_TAKEN, MAIL_ERR_INTERNAL_ERROR);
 397         return;
 398     }
 399
 400     // prevent cheating with skip client money check
 401     if(pl->GetMoney() < m->COD)
 402     {
 403         pl->SendMailResult(mailId, MAIL_ITEM_TAKEN, MAIL_ERR_NOT_ENOUGH_MONEY);
 404         return;
 405     }
 406
 407     Item *it = pl->GetMItem(itemId);
 408
 409     ItemPosCountVec dest;
 410     uint8 msg = _player->CanStoreItem( NULL_BAG, NULL_SLOT, dest, it, false );
 411     if( msg == EQUIP_ERR_OK )
 412     {
 413         m->RemoveItem(itemId);
 414         m->removedItems.push_back(itemId);
 415
 416         if (m->COD > 0)                                     // if there is COD, take COD money from player and send them to sender by mail
 417         {
 418             uint64 sender_guid = MAKE_NEW_GUID(m->sender, 0, HIGHGUID_PLAYER);
 419             Player *receive = sObjectMgr.GetPlayer(sender_guid);
 420
 421             uint32 sender_accId = 0;
 422
 423             if( GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE) )
 424             {
 425                 std::string sender_name;
 426                 if(receive)
 427                 {
 428                     sender_accId = receive->GetSession()->GetAccountId();
 429                     sender_name = receive->GetName();
 430                 }
 431                 else
 432                 {
 433                     // can be calculated early
 434                     sender_accId = sObjectMgr.GetPlayerAccountIdByGUID(sender_guid);
 435
 436                     if(!sObjectMgr.GetPlayerNameByGUID(sender_guid, sender_name))
 437                         sender_name = sObjectMgr.GetMangosStringForDBCLocale(LANG_UNKNOWN);
 438                 }
 439                 sLog.outCommand(GetAccountId(), "GM %s (Account: %u) receive mail item: %s (Entry: %u Count: %u) and send COD money: %u to player: %s (Account: %u)",
 440                     GetPlayerName(), GetAccountId(), it->GetProto()->Name1, it->GetEntry(), it->GetCount(), m->COD, sender_name.c_str(), sender_accId);
 441             }
 442             else if(!receive)
 443                 sender_accId = sObjectMgr.GetPlayerAccountIdByGUID(sender_guid);
 444
 445             // check player existence
 446             if(receive || sender_accId)
 447             {
 448                 MailDraft(m->subject)
 449                     .AddMoney(m->COD)
 450                     .SendMailTo(MailReceiver(receive,m->sender),MailSender(MAIL_NORMAL,m->receiver), MAIL_CHECK_MASK_COD_PAYMENT);
 451             }
 452
 453             pl->ModifyMoney( -int32(m->COD) );
 454         }
 455         m->COD = 0;
 456         m->state = MAIL_STATE_CHANGED;
 457         pl->m_mailsUpdated = true;
 458         pl->RemoveMItem(it->GetGUIDLow());
 459
 460         uint32 count = it->GetCount();                      // save counts before store and possible merge with deleting
 461         pl->MoveItemToInventory(dest, it, true);
 462
 463         CharacterDatabase.BeginTransaction();
 464         pl->SaveInventoryAndGoldToDB();
 465         pl->_SaveMail();
 466         CharacterDatabase.CommitTransaction();
 467
 468         pl->SendMailResult(mailId, MAIL_ITEM_TAKEN, MAIL_OK, 0, itemId, count);
 469     }
 470     else
 471         pl->SendMailResult(mailId, MAIL_ITEM_TAKEN, MAIL_ERR_EQUIP_ERROR, msg);
 472 }
 473
 474 void WorldSession::HandleMailTakeMoney(WorldPacket & recv_data )
 475 {
 476     uint64 mailbox;
 477     uint32 mailId;
 478     recv_data >> mailbox;
 479     recv_data >> mailId;
 480
 481     if (!GetPlayer()->GetGameObjectIfCanInteractWith(mailbox, GAMEOBJECT_TYPE_MAILBOX))
 482         return;
 483
 484     Player *pl = _player;
 485
 486     Mail* m = pl->GetMail(mailId);
 487     if(!m || m->state == MAIL_STATE_DELETED || m->deliver_time > time(NULL))
 488     {
 489         pl->SendMailResult(mailId, MAIL_MONEY_TAKEN, MAIL_ERR_INTERNAL_ERROR);
 490         return;
 491     }
 492
 493     pl->SendMailResult(mailId, MAIL_MONEY_TAKEN, MAIL_OK);
 494
 495     pl->ModifyMoney(m->money);
 496     m->money = 0;
 497     m->state = MAIL_STATE_CHANGED;
 498     pl->m_mailsUpdated = true;
 499
 500     // save money and mail to prevent cheating
 501     CharacterDatabase.BeginTransaction();
 502     pl->SaveGoldToDB();
 503     pl->_SaveMail();
 504     CharacterDatabase.CommitTransaction();
 505 }
 506
 507 //called when player lists his received mails
 508 void WorldSession::HandleGetMailList(WorldPacket & recv_data )
 509 {
 510     uint64 mailbox;
 511     recv_data >> mailbox;
 512
 513     if (!GetPlayer()->GetGameObjectIfCanInteractWith(mailbox, GAMEOBJECT_TYPE_MAILBOX))
 514         return;
 515
 516     // client can't work with packets > max int16 value
 517     const uint32 maxPacketSize = 32767;
 518
 519     uint32 mailsCount = 0;                                  // send to client mails amount
 520     uint32 realCount = 0;                                   // real mails amount
 521
 522     WorldPacket data(SMSG_MAIL_LIST_RESULT, 200);           // guess size
 523     data << uint32(0);                                      // real mail's count
 524     data << uint8(0);                                       // mail's count
 525     time_t cur_time = time(NULL);
 526
 527     for(PlayerMails::iterator itr = _player->GetMailBegin(); itr != _player->GetMailEnd(); ++itr)
 528     {
 529         // packet send mail count as uint8, prevent overflow
 530         if(mailsCount >= 254)
 531         {
 532             realCount += 1;
 533             continue;
 534         }
 535
 536         // skip deleted or not delivered (deliver delay not expired) mails
 537         if ((*itr)->state == MAIL_STATE_DELETED || cur_time < (*itr)->deliver_time)
 538             continue;
 539
 540         uint8 item_count = (*itr)->items.size();            // max count is MAX_MAIL_ITEMS (12)
 541
 542         size_t next_mail_size = 2+4+1+((*itr)->messageType == MAIL_NORMAL ? 8 : 4)+4*8+((*itr)->subject.size()+1)+1+item_count*(1+4+4+7*3*4+4+4+4+4+4+4+1);
 543
 544         if(data.wpos()+next_mail_size > maxPacketSize)
 545         {
 546             realCount += 1;
 547             continue;
 548         }
 549
 550         uint32 show_flags = 0;
 551         if ((*itr)->messageType != MAIL_NORMAL)
 552             show_flags |= MAIL_SHOW_DELETE;
 553         if ((*itr)->messageType == MAIL_AUCTION)
 554             show_flags |= MAIL_SHOW_AUCTION;
 555         if ((*itr)->HasItems() && (*itr)->messageType == MAIL_NORMAL)
 556             show_flags |= MAIL_SHOW_RETURN;
 557
 558         data << uint16(next_mail_size);                     // Message size
 559         data << uint32((*itr)->messageID);                  // Message ID
 560         data << uint8((*itr)->messageType);                 // Message Type
 561
 562         switch((*itr)->messageType)
 563         {
 564             case MAIL_NORMAL:                               // sender guid
 565                 data << uint64(MAKE_NEW_GUID((*itr)->sender, 0, HIGHGUID_PLAYER));
 566                 break;
 567             case MAIL_CREATURE:
 568             case MAIL_GAMEOBJECT:
 569             case MAIL_AUCTION:
 570                 data << uint32((*itr)->sender);             // creature/gameobject entry, auction id
 571                 break;
 572             case MAIL_ITEM:                                 // item entry (?) sender = "Unknown", NYI
 573                 data << uint32(0);                          // item entry
 574                 break;
 575         }
 576
 577         data << uint32((*itr)->COD);                        // COD
 578         data << uint32((*itr)->itemTextId);                 // sure about this
 579         data << uint32(0);                                  // unknown
 580         data << uint32((*itr)->stationery);                 // stationery (Stationery.dbc)
 581         data << uint32((*itr)->money);                      // Gold
 582         data << uint32(show_flags);                         // unknown, 0x4 - auction, 0x10 - normal
 583         data << float(((*itr)->expire_time-time(NULL))/DAY);// Time
 584         data << uint32((*itr)->mailTemplateId);             // mail template (MailTemplate.dbc)
 585         data << (*itr)->subject;                            // Subject string - once 00, when mail type = 3
 586
 587         data << uint8(item_count);                          // client limit is 0x10
 588
 589         for(uint8 i = 0; i < item_count; ++i)
 590         {
 591             Item *item = _player->GetMItem((*itr)->items[i].item_guid);
 592             // item index (0-6?)
 593             data << uint8(i);
 594             // item guid low?
 595             data << uint32(item ? item->GetGUIDLow() : 0);
 596             // entry
 597             data << uint32(item ? item->GetEntry() : 0);
 598             for(uint8 j = 0; j < MAX_INSPECTED_ENCHANTMENT_SLOT; ++j)
 599             {
 600                 // unsure
 601                 data << uint32(item ? item->GetEnchantmentCharges((EnchantmentSlot)j) : 0);
 602                 // unsure
 603                 data << uint32(item ? item->GetEnchantmentDuration((EnchantmentSlot)j) : 0);
 604                 // unsure
 605                 data << uint32(item ? item->GetEnchantmentId((EnchantmentSlot)j) : 0);
 606             }
 607             // can be negative
 608             data << uint32(item ? item->GetItemRandomPropertyId() : 0);
 609             // unk
 610             data << uint32(item ? item->GetItemSuffixFactor() : 0);
 611             // stack count
 612             data << uint32(item ? item->GetCount() : 0);
 613             // charges
 614             data << uint32(item ? item->GetSpellCharges() : 0);
 615             // durability
 616             data << uint32(item ? item->GetUInt32Value(ITEM_FIELD_MAXDURABILITY) : 0);
 617             // durability
 618             data << uint32(item ? item->GetUInt32Value(ITEM_FIELD_DURABILITY) : 0);
 619             // unknown wotlk
 620             data << uint8(0);
 621         }
 622
 623         mailsCount += 1;
 624         realCount += 1;
 625     }
 626
 627     data.put<uint32>(0, realCount);                         // this will display warning about undelivered mail to player if realCount > mailsCount
 628     data.put<uint8>(4, mailsCount);                         // set real send mails to client
 629     SendPacket(&data);
 630
 631     // recalculate m_nextMailDelivereTime and unReadMails
 632     _player->UpdateNextMailTimeAndUnreads();
 633 }
 634
 635 ///this function is called when client needs mail message body, or when player clicks on item which has ITEM_FIELD_ITEM_TEXT_ID > 0
 636 void WorldSession::HandleItemTextQuery(WorldPacket & recv_data )
 637 {
 638     uint32 itemTextId;
 639     uint32 mailId;                                          // this value can be item id in bag, but it is also mail id
 640     uint32 unk;                                             // maybe something like state - 0x70000000
 641
 642     recv_data >> itemTextId >> mailId >> unk;
 643
 644     //some check needed, if player has item with guid mailId, or has mail with id mailId
 645
 646     sLog.outDebug("CMSG_ITEM_TEXT_QUERY itemguid: %u, mailId: %u, unk: %u", itemTextId, mailId, unk);
 647
 648     WorldPacket data(SMSG_ITEM_TEXT_QUERY_RESPONSE, (4+10));// guess size
 649     data << itemTextId;
 650     data << sObjectMgr.GetItemText( itemTextId );
 651     SendPacket(&data);
 652 }
 653
 654 //used when player copies mail body to his inventory
 655 void WorldSession::HandleMailCreateTextItem(WorldPacket & recv_data )
 656 {
 657     uint64 mailbox;
 658     uint32 mailId;
 659
 660     recv_data >> mailbox;
 661     recv_data >> mailId;
 662     recv_data.read_skip<uint32>();                          // mailTemplateId, non need, Mail store own 100% correct value anyway
 663
 664     if (!GetPlayer()->GetGameObjectIfCanInteractWith(mailbox, GAMEOBJECT_TYPE_MAILBOX))
 665         return;
 666
 667     Player *pl = _player;
 668
 669     Mail* m = pl->GetMail(mailId);
 670     if (!m || (!m->itemTextId && !m->mailTemplateId) || m->state == MAIL_STATE_DELETED || m->deliver_time > time(NULL))
 671     {
 672         pl->SendMailResult(mailId, MAIL_MADE_PERMANENT, MAIL_ERR_INTERNAL_ERROR);
 673         return;
 674     }
 675
 676     uint32 itemTextId = m->itemTextId;
 677
 678     // in mail template case we need create new text id
 679     if(!itemTextId)
 680     {
 681         MailTemplateEntry const* mailTemplateEntry = sMailTemplateStore.LookupEntry(m->mailTemplateId);
 682         if(!mailTemplateEntry)
 683         {
 684             pl->SendMailResult(mailId, MAIL_MADE_PERMANENT, MAIL_ERR_INTERNAL_ERROR);
 685             return;
 686         }
 687
 688         itemTextId = sObjectMgr.CreateItemText(mailTemplateEntry->content[GetSessionDbcLocale()]);
 689     }
 690
 691     Item *bodyItem = new Item;                              // This is not bag and then can be used new Item.
 692     if(!bodyItem->Create(sObjectMgr.GenerateLowGuid(HIGHGUID_ITEM), MAIL_BODY_ITEM_TEMPLATE, pl))
 693     {
 694         delete bodyItem;
 695         return;
 696     }
 697
 698     bodyItem->SetUInt32Value( ITEM_FIELD_ITEM_TEXT_ID, itemTextId );
 699     bodyItem->SetUInt32Value( ITEM_FIELD_CREATOR, m->sender);
 700
 701     sLog.outDetail("HandleMailCreateTextItem mailid=%u",mailId);
 702
 703     ItemPosCountVec dest;
 704     uint8 msg = _player->CanStoreItem( NULL_BAG, NULL_SLOT, dest, bodyItem, false );
 705     if( msg == EQUIP_ERR_OK )
 706     {
 707         m->itemTextId = 0;
 708         m->state = MAIL_STATE_CHANGED;
 709         pl->m_mailsUpdated = true;
 710
 711         pl->StoreItem(dest, bodyItem, true);
 712         //bodyItem->SetState(ITEM_NEW, pl); is set automatically
 713         pl->SendMailResult(mailId, MAIL_MADE_PERMANENT, MAIL_OK);
 714     }
 715     else
 716     {
 717         pl->SendMailResult(mailId, MAIL_MADE_PERMANENT, MAIL_ERR_EQUIP_ERROR, msg);
 718         delete bodyItem;
 719     }
 720 }
 721
 722 //TODO Fix me! ... this void has probably bad condition, but good data are sent
 723 void WorldSession::HandleQueryNextMailTime(WorldPacket & /*recv_data*/ )
 724 {
 725     WorldPacket data(MSG_QUERY_NEXT_MAIL_TIME, 8);
 726
 727     if( _player->unReadMails > 0 )
 728     {
 729         data << uint32(0);                                  // float
 730         data << uint32(0);                                  // count
 731
 732         uint32 count = 0;
 733         time_t now = time(NULL);
 734         for(PlayerMails::iterator itr = _player->GetMailBegin(); itr != _player->GetMailEnd(); ++itr)
 735         {
 736             Mail *m = (*itr);
 737             // must be not checked yet
 738             if(m->checked & MAIL_CHECK_MASK_READ)
 739                 continue;
 740
 741             // and already delivered
 742             if(now < m->deliver_time)
 743                 continue;
 744
 745             data << uint64(m->sender);                      // sender guid
 746
 747             switch(m->messageType)
 748             {
 749                 case MAIL_AUCTION:
 750                     data << uint32(2);
 751                     data << uint32(2);
 752                     data << uint32(m->stationery);
 753                     break;
 754                 default:
 755                     data << uint32(0);
 756                     data << uint32(0);
 757                     data << uint32(m->stationery);
 758                     break;
 759             }
 760
 761             data << uint32(0xC6000000);                     // float unk, time or something
 762
 763             ++count;
 764             if(count == 2)                                  // do not display more than 2 mails
 765                 break;
 766         }
 767         data.put<uint32>(4, count);
 768     }
 769     else
 770     {
 771         data << uint32(0xC7A8C000);
 772         data << uint32(0x00000000);
 773     }
 774     SendPacket(&data);
 775 }
 776
 777 MailSender::MailSender( Object* sender, MailStationery stationery ) : m_stationery(stationery)
 778 {
 779     switch(sender->GetTypeId())
 780     {
 781         case TYPEID_UNIT:
 782             m_messageType = MAIL_CREATURE;
 783             m_senderId = sender->GetEntry();
 784             break;
 785         case TYPEID_GAMEOBJECT:
 786             m_messageType = MAIL_GAMEOBJECT;
 787             m_senderId = sender->GetEntry();
 788             break;
 789         case TYPEID_ITEM:
 790             m_messageType = MAIL_ITEM;
 791             m_senderId = sender->GetEntry();
 792             break;
 793         case TYPEID_PLAYER:
 794             m_messageType = MAIL_NORMAL;
 795             m_senderId = sender->GetGUIDLow();
 796             break;
 797         default:
 798             m_messageType = MAIL_NORMAL;
 799             m_senderId = 0;                                 // will show mail from not existed player
 800             sLog.outError( "MailSender::MailSender - Mail have unexpected sender typeid (%u)", sender->GetTypeId());
 801             break;
 802     }
 803 }
 804
 805 MailSender::MailSender( AuctionEntry* sender )
 806     : m_messageType(MAIL_AUCTION), m_senderId(sender->GetHouseId()), m_stationery(MAIL_STATIONERY_AUCTION)
 807 {
 808 }
 809
 810
 811 MailReceiver::MailReceiver( Player* receiver ) : m_receiver(receiver), m_receiver_lowguid(receiver->GetGUIDLow())
 812 {
 813 }
 814
 815 MailReceiver::MailReceiver( Player* receiver,uint32 receiver_lowguid ) : m_receiver(receiver), m_receiver_lowguid(receiver_lowguid)
 816 {
 817     ASSERT(!receiver || receiver->GetGUIDLow() == receiver_lowguid);
 818 }
 819
 820 MailDraft& MailDraft::AddItem( Item* item )
 821 {
 822     m_items[item->GetGUIDLow()] = item; return *this;
 823 }
 824
 825 void MailDraft::prepareItems(Player* receiver)
 826 {
 827     if (!m_mailTemplateId || !m_mailTemplateItemsNeed)
 828         return;
 829
 830     m_mailTemplateItemsNeed = false;
 831
 832     Loot mailLoot;
 833
 834     // can be empty
 835     mailLoot.FillLoot(m_mailTemplateId, LootTemplates_Mail, receiver, true, true);
 836
 837     uint32 max_slot = mailLoot.GetMaxSlotInLootFor(receiver);
 838     for(uint32 i = 0; m_items.size() < MAX_MAIL_ITEMS && i < max_slot; ++i)
 839     {
 840         if (LootItem* lootitem = mailLoot.LootItemInSlot(i,receiver))
 841         {
 842             if (Item* item = Item::CreateItem(lootitem->itemid,lootitem->count,receiver))
 843             {
 844                 item->SaveToDB();                           // save for prevent lost at next mail load, if send fail then item will deleted
 845                 AddItem(item);
 846             }
 847         }
 848     }
 849 }
 850
 851 void MailDraft::deleteIncludedItems( bool inDB /*= false*/ )
 852 {
 853     for(MailItemMap::iterator mailItemIter = m_items.begin(); mailItemIter != m_items.end(); ++mailItemIter)
 854     {
 855         Item* item = mailItemIter->second;
 856
 857         if(inDB)
 858             CharacterDatabase.PExecute("DELETE FROM item_instance WHERE guid='%u'", item->GetGUIDLow());
 859
 860         delete item;
 861     }
 862
 863     m_items.clear();
 864 }
 865
 866 void MailDraft::SendReturnToSender(uint32 sender_acc, uint32 sender_guid, uint32 receiver_guid )
 867 {
 868     Player *receiver = sObjectMgr.GetPlayer(MAKE_NEW_GUID(receiver_guid, 0, HIGHGUID_PLAYER));
 869
 870     uint32 rc_account = 0;
 871     if(!receiver)
 872         rc_account = sObjectMgr.GetPlayerAccountIdByGUID(MAKE_NEW_GUID(receiver_guid, 0, HIGHGUID_PLAYER));
 873
 874     if(!receiver && !rc_account)                            // sender not exist
 875     {
 876         deleteIncludedItems(true);
 877         return;
 878     }
 879
 880     // prepare mail and send in other case
 881     bool needItemDelay = false;
 882
 883     if(!m_items.empty())
 884     {
 885         // if item send to character at another account, then apply item delivery delay
 886         needItemDelay = sender_acc != rc_account;
 887
 888         // set owner to new receiver (to prevent delete item with sender char deleting)
 889         CharacterDatabase.BeginTransaction();
 890         for(MailItemMap::iterator mailItemIter = m_items.begin(); mailItemIter != m_items.end(); ++mailItemIter)
 891         {
 892             Item* item = mailItemIter->second;
 893             item->SaveToDB();                      // item not in inventory and can be save standalone
 894             // owner in data will set at mail receive and item extracting
 895             CharacterDatabase.PExecute("UPDATE item_instance SET owner_guid = '%u' WHERE guid='%u'", receiver_guid, item->GetGUIDLow());
 896         }
 897         CharacterDatabase.CommitTransaction();
 898     }
 899
 900     // If theres is an item, there is a one hour delivery delay.
 901     uint32 deliver_delay = needItemDelay ? sWorld.getConfig(CONFIG_MAIL_DELIVERY_DELAY) : 0;
 902
 903     // will delete item or place to receiver mail list
 904     SendMailTo(MailReceiver(receiver,receiver_guid), MailSender(MAIL_NORMAL, sender_guid), MAIL_CHECK_MASK_RETURNED, deliver_delay);
 905 }
 906
 907 void MailDraft::SendMailTo(MailReceiver const& receiver, MailSender const& sender, MailCheckMask checked, uint32 deliver_delay)
 908 {
 909     Player* pReceiver = receiver.GetPlayer();               // can be NULL
 910
 911     if (pReceiver)
 912         prepareItems(pReceiver);                            // generate mail template items
 913
 914
 915     uint32 mailId = sObjectMgr.GenerateMailID();
 916
 917     time_t deliver_time = time(NULL) + deliver_delay;
 918
 919     uint32 expire_delay;
 920     // auction mail without any items and money (auction sale note) pending 1 hour
 921     if (sender.GetMailMessageType() == MAIL_AUCTION && m_items.empty() && !m_money)
 922         expire_delay = HOUR;
 923     // mail from battlemaster (rewardmarks) should last only one day
 924     else if (sender.GetMailMessageType() == MAIL_CREATURE && sBattleGroundMgr.GetBattleMasterBG(sender.GetSenderId()) != BATTLEGROUND_TYPE_NONE)
 925         expire_delay = DAY;
 926     // default case: expire time if COD 3 days, if no COD 30 days
 927     else
 928         expire_delay = (m_COD > 0) ? 3 * DAY : 30 * DAY;
 929
 930     time_t expire_time = deliver_time + expire_delay;
 931
 932     // Add to DB
 933     std::string safe_subject = GetSubject();
 934
 935     CharacterDatabase.BeginTransaction();
 936     CharacterDatabase.escape_string(safe_subject);
 937     CharacterDatabase.PExecute("INSERT INTO mail (id,messageType,stationery,mailTemplateId,sender,receiver,subject,itemTextId,has_items,expire_time,deliver_time,money,cod,checked) "
 938         "VALUES ('%u', '%u', '%u', '%u', '%u', '%u', '%s', '%u', '%u', '" UI64FMTD "','" UI64FMTD "', '%u', '%u', '%d')",
 939         mailId, sender.GetMailMessageType(), sender.GetStationery(), GetMailTemplateId(), sender.GetSenderId(), receiver.GetPlayerGUIDLow(), safe_subject.c_str(), GetBodyId(), (m_items.empty() ? 0 : 1), (uint64)expire_time, (uint64)deliver_time, m_money, m_COD, checked);
 940
 941     for(MailItemMap::const_iterator mailItemIter = m_items.begin(); mailItemIter != m_items.end(); ++mailItemIter)
 942     {
 943         Item* item = mailItemIter->second;
 944         CharacterDatabase.PExecute("INSERT INTO mail_items (mail_id,item_guid,item_template,receiver) VALUES ('%u', '%u', '%u','%u')", mailId, item->GetGUIDLow(), item->GetEntry(), receiver.GetPlayerGUIDLow());
 945     }
 946     CharacterDatabase.CommitTransaction();
 947
 948     // For online receiver update in game mail status and data
 949     if (pReceiver)
 950     {
 951         pReceiver->AddNewMailDeliverTime(deliver_time);
 952
 953         Mail *m = new Mail;
 954         m->messageID = mailId;
 955         m->mailTemplateId = GetMailTemplateId();
 956         m->subject = GetSubject();
 957         m->itemTextId = GetBodyId();
 958         m->money = GetMoney();
 959         m->COD = GetCOD();
 960
 961         for(MailItemMap::const_iterator mailItemIter = m_items.begin(); mailItemIter != m_items.end(); ++mailItemIter)
 962         {
 963             Item* item = mailItemIter->second;
 964             m->AddItem(item->GetGUIDLow(), item->GetEntry());
 965         }
 966
 967         m->messageType = sender.GetMailMessageType();
 968         m->stationery = sender.GetStationery();
 969         m->sender = sender.GetSenderId();
 970         m->receiver = receiver.GetPlayerGUIDLow();
 971         m->expire_time = expire_time;
 972         m->deliver_time = deliver_time;
 973         m->checked = checked;
 974         m->state = MAIL_STATE_UNCHANGED;
 975
 976         pReceiver->AddMail(m);                           // to insert new mail to beginning of maillist
 977
 978         if (!m_items.empty())
 979         {
 980             for(MailItemMap::iterator mailItemIter = m_items.begin(); mailItemIter != m_items.end(); ++mailItemIter)
 981                 pReceiver->AddMItem(mailItemIter->second);
 982         }
 983     }
 984     else if (!m_items.empty())
 985         deleteIncludedItems();
 986 }