src/game/ItemHandler.cpp

   1 /*
   2  * Copyright (C) 2005,2006 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 "Opcodes.h"
  24 #include "Log.h"
  25 #include "ObjectMgr.h"
  26 #include "Player.h"
  27 #include "Chat.h"
  28 #include "Item.h"
  29 #include "UpdateData.h"
  30 #include "ObjectAccessor.h"
  31
  32 void WorldSession::HandleSplitItemOpcode( WorldPacket & recv_data )
  33 {
  34     sLog.outDebug("WORLD: CMSG_SPLIT_ITEM");
  35     uint8 srcBag, srcSlot, dstBag, dstSlot, count;
  36
  37     recv_data >> srcBag >> srcSlot >> dstBag >> dstSlot >> count;
  38
  39     sLog.outDetail("ITEM: Split item, srcBag = %d, srcSlot = %d, dstBag = %d, dstSlot = %d, count = %d",srcBag, srcSlot, dstBag, dstSlot, count);
  40
  41     GetPlayer()->SplitItem(srcBag, srcSlot, dstBag, dstSlot, count);
  42 }
  43
  44 void WorldSession::HandleSwapInvItemOpcode( WorldPacket & recv_data )
  45 {
  46     sLog.outDebug("WORLD: CMSG_SWAP_INV_ITEM");
  47     WorldPacket data;
  48     UpdateData upd;
  49     uint8 srcSlot, dstSlot;
  50
  51     recv_data >> srcSlot >> dstSlot;
  52
  53     sLog.outDetail("ITEM: Swap inventory, srcSlot = %u, dstSlot = %u", (uint32)srcSlot, (uint32)dstSlot);
  54
  55     GetPlayer()->SwapItem(0, dstSlot, 0, srcSlot);
  56 }
  57
  58 void WorldSession::HandleSwapItem( WorldPacket & recv_data )
  59 {
  60     sLog.outDebug("WORLD: CMSG_SWAP_ITEM");
  61     WorldPacket data;
  62     uint8 dstBag, dstSlot, srcBag, srcSlot;
  63
  64     recv_data >> dstBag >> dstSlot >> srcBag >> srcSlot ;
  65     sLog.outDetail("ITEM: Swap, srcBag = %d, srcSlot = %d, dstBag = %d, dstSlot = %d", srcBag, srcSlot, dstBag, dstSlot);
  66
  67     GetPlayer()->SwapItem(dstBag, dstSlot, srcBag, srcSlot);
  68 }
  69
  70 void WorldSession::HandleAutoEquipItemOpcode( WorldPacket & recv_data )
  71 {
  72     sLog.outDebug("WORLD: CMSG_AUTOEQUIP_ITEM");
  73     WorldPacket data;
  74     uint8 srcBag, srcSlot, dstSlot, error_msg = 0;
  75
  76     recv_data >> srcBag >> srcSlot;
  77     sLog.outDetail("ITEM: Auto equip, srcBag = %d, srcSlot = %d", srcBag, srcSlot);
  78
  79     Item *item  = GetPlayer()->GetItemBySlot(srcBag, srcSlot);
  80
  81     if (!item) error_msg = EQUIP_ERR_ITEM_NOT_FOUND;
  82
  83     if (!error_msg)
  84     {
  85         dstSlot = GetPlayer()->FindEquipSlot(item->GetProto()->InventoryType);
  86         if (dstSlot == INVENTORY_SLOT_ITEM_END) error_msg = EQUIP_ERR_ITEM_CANT_BE_EQUIPPED;
  87     }
  88
  89     if (error_msg)
  90     {
  91         data.Initialize(SMSG_INVENTORY_CHANGE_FAILURE);
  92         data << error_msg;
  93         data << (item ? item->GetGUID() : uint64(0));
  94         data << uint64(0);
  95         data << uint8(0);
  96         SendPacket( &data );
  97         return;
  98     }
  99
 100     GetPlayer()->SwapItem(CLIENT_SLOT_BACK,dstSlot,srcBag,srcSlot);
 101 }
 102
 103 void WorldSession::HandleDestroyItemOpcode( WorldPacket & recv_data )
 104 {
 105     sLog.outDebug("WORLD: CMSG_DESTROYITEM");
 106     WorldPacket data;
 107     uint8 bagIndex, slot, count, data1, data2, data3;
 108
 109     recv_data >> bagIndex >> slot >> count >> data1 >> data2 >> data3;
 110
 111     sLog.outDetail("ITEM: Destroy, bagIndex = %d, slot = %d, count = %d (Uknown data: %d %d %d)", bagIndex, slot, count, data1, data2, data3);
 112
 113     Item *item = GetPlayer()->GetItemBySlot(bagIndex,slot);
 114
 115     if (!item)
 116     {
 117         sLog.outDetail("ITEM: Tried to destroy a non-existant item");
 118         return;
 119     }
 120
 121     if ((!count) || (count >= item->GetCount()))
 122     {
 123         GetPlayer()->RemoveItemFromSlot(bagIndex,slot);
 124         item->DeleteFromDB();
 125         delete item;
 126     }
 127     else
 128     {
 129         item->SetCount(item->GetCount() - count);
 130     }
 131     //GetPlayer()->_SaveInventory();
 132 }
 133
 134 extern void CheckItemDamageValues ( ItemPrototype *itemProto );
 135
 136 void WorldSession::HandleItemQuerySingleOpcode( WorldPacket & recv_data )
 137 {
 138     sLog.outDebug("WORLD: CMSG_ITEM_QUERY_SINGLE");
 139     WorldPacket data;
 140
 141     uint32 itemId, guidLow, guidHigh;
 142     recv_data >> itemId >> guidLow >> guidHigh;
 143
 144     ItemPrototype *itemProto = objmgr.GetItemPrototype(itemId);
 145
 146     if (!itemProto)
 147     {
 148         sLog.outError("ITEM: Unknown item, itemId = %u", itemId);
 149         data.Initialize( SMSG_ITEM_QUERY_SINGLE_RESPONSE );
 150         data << itemId;
 151         for(int a=0;a<11;a++)
 152             data << uint64(0);
 153         SendPacket( &data );
 154         return;
 155     }
 156
 157     sLog.outDetail("ITEM: Item query, itemId = %d, guidLow = %d, guidHigh = %d", itemId, guidLow, guidHigh);
 158
 159     data.Initialize( SMSG_ITEM_QUERY_SINGLE_RESPONSE );
 160     data << itemProto->ItemId;
 161     data << itemProto->Class;
 162     data << itemProto->SubClass;
 163     data << itemProto->Name1;
 164     data << itemProto->Name2;
 165     data << itemProto->Name3;
 166     data << itemProto->Name4;
 167
 168     data.append((const char*)&itemProto->DisplayInfoID,30*4+sizeof(itemProto->ItemStat)+sizeof(itemProto->Damage)+sizeof(itemProto->Spells));
 169
 170     data << itemProto->Description;
 171     data.append((const char*)&itemProto->PageText,12*4);
 172     SendPacket(&data);
 173 }
 174
 175 extern char *fmtstring( char *format, ... );
 176
 177 extern char *GetInventoryImageFilefromObjectClass(uint32 classNum, uint32 subclassNum, uint32 type, uint32 DisplayID);
 178
 179 void WorldSession::HandleReadItem( WorldPacket & recv_data )
 180 {
 181     sLog.outDebug( "WORLD: CMSG_READ_ITEM");
 182     uint8 bagIndex, slot;
 183     WorldPacket data;
 184     recv_data >> bagIndex >> slot;
 185
 186     sLog.outDetail("ITEM: Read, bagIndex = %d, slot = %d", bagIndex, slot);
 187     Item *pItem = GetPlayer()->GetItemBySlot(bagIndex, slot);
 188
 189     if (pItem)
 190     {
 191         if ((!pItem->GetProto()->PageText) || (GetPlayer()->inCombat) || (GetPlayer()->isDead()))
 192         {
 193             data.Initialize( SMSG_READ_ITEM_FAILED );
 194             sLog.outDetail("ITEM: Unable to read item");
 195         }
 196         else
 197         {
 198             data.Initialize (SMSG_READ_ITEM_OK);
 199             sLog.outDetail("ITEM: Item page sent");
 200         }
 201         data << pItem->GetGUID();
 202         SendPacket(&data);
 203     }
 204 }
 205
 206 void WorldSession::HandlePageQuerySkippedOpcode( WorldPacket & recv_data )
 207 {
 208     sLog.outDetail( "WORLD: Received CMSG_PAGE_TEXT_QUERY" );
 209
 210     WorldPacket data;
 211     uint32 itemid, guidlow, guidhigh;
 212
 213     recv_data >> itemid >> guidlow >> guidhigh;
 214
 215     sLog.outDetail( "Packet Info: itemid: %d guidlow: %d guidhigh: %d", itemid, guidlow, guidhigh );
 216 }
 217
 218 void WorldSession::HandleSellItemOpcode( WorldPacket & recv_data )
 219 {
 220     sLog.outDetail( "WORLD: Received CMSG_SELL_ITEM" );
 221
 222     WorldPacket data;
 223     uint64 vendorguid, itemguid;
 224     uint8 amount;
 225     uint32 newmoney;
 226     //uint8 slot = 0xFF;
 227     int check = 0;
 228
 229     recv_data >> vendorguid;
 230     recv_data >> itemguid;
 231     recv_data >> amount;
 232
 233     if (itemguid == 0)
 234     {
 235         data.Initialize( SMSG_SELL_ITEM );
 236         data << vendorguid << itemguid << uint8(0x01);
 237         WPAssert(data.size() == 17);
 238         SendPacket( &data );
 239         return;
 240     }
 241
 242     Creature *unit = ObjectAccessor::Instance().GetCreature(*_player, vendorguid);
 243
 244     if (unit == NULL)
 245     {
 246         data.Initialize( SMSG_SELL_ITEM );
 247         data << vendorguid << itemguid << uint8(0x03);
 248         WPAssert(data.size() == 17);
 249         SendPacket( &data );
 250         return;
 251     }
 252
 253     Item *item=NULL;
 254     uint8 bag,slot;
 255     if (GetPlayer()->GetSlotByItemGUID(itemguid,bag,slot))
 256     {
 257         item = GetPlayer()->GetItemBySlot(bag,slot);
 258         if (item)
 259         {
 260             if(item->GetProto()->SellPrice !=0)
 261             {
 262                 data.Initialize( SMSG_SELL_ITEM );
 263                 data << vendorguid << itemguid << uint8(0x0);
 264                 WPAssert(data.size() == 17);
 265                 SendPacket( &data );
 266
 267                 //if (amount == 0) amount = 1;
 268                 newmoney = ((GetPlayer()->GetUInt32Value(PLAYER_FIELD_COINAGE)) + (item->GetProto()->SellPrice) * item->GetCount());
 269                 GetPlayer()->SetUInt32Value( PLAYER_FIELD_COINAGE , newmoney);
 270
 271                 uint32 buyBackslot=GetPlayer()->GetCurrentBuybackSlot();
 272                 GetPlayer()->AddItemToBuyBackSlot(buyBackslot,item);
 273                 GetPlayer()->SetCurrentBuybackSlot(buyBackslot+1);
 274                 GetPlayer()->RemoveItemFromSlot(bag,slot,false);
 275             }
 276             else
 277             {
 278                 data.Initialize( SMSG_SELL_ITEM );
 279                 data << vendorguid << itemguid << uint8(0x02);
 280                 WPAssert(data.size() == 17);
 281                 SendPacket( &data );
 282             }
 283         }
 284     }
 285     else
 286     {
 287         data.Initialize( SMSG_SELL_ITEM );
 288         data << vendorguid << itemguid << uint8(0x01);
 289         WPAssert(data.size() == 17);
 290         SendPacket( &data );
 291         return;
 292     }
 293     sLog.outDetail( "WORLD: Sent SMSG_SELL_ITEM" );
 294 }
 295
 296 void WorldSession::HandleBuybackItem(WorldPacket & recv_data)
 297 {
 298     sLog.outDetail( "WORLD: Received CMSG_BUYBACK_ITEM" );
 299     uint64 vendorguid;
 300     uint32 buybackslot;
 301     WorldPacket data;
 302
 303     recv_data >> vendorguid;
 304     recv_data >> buybackslot;                               //start slot is (69 0x45) end slot is 0x45+12
 305
 306     //sLog.outDetail( "Packet Info: vendorguid: %u buybackslot: %u ", vendorguid, buybackslot);
 307     Item *buybackItem=NULL;
 308     uint32 slot=buybackslot-0x45;
 309     buybackItem = GetPlayer()->GetItemFromBuyBackSlot(slot);
 310     if (buybackItem)
 311     {
 312         int32 newmoney;
 313         newmoney = ((GetPlayer()->GetUInt32Value(PLAYER_FIELD_COINAGE)) - (GetPlayer()->GetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1+slot)));
 314         if(newmoney < 0 )
 315         {
 316             data.Initialize( SMSG_BUY_FAILED );
 317             data << uint64(buybackItem->GetGUID());
 318             data << uint32(buybackItem->GetEntry());
 319             data << uint8(2);
 320             SendPacket( &data );
 321             return;
 322         }
 323         if(GetPlayer()->AddItemToInventory(0, NULL_SLOT, buybackItem, false, false, false))
 324         {
 325             GetPlayer()->SetUInt32Value( PLAYER_FIELD_COINAGE , newmoney);
 326             GetPlayer()->RemoveItemFromBuyBackSlot(slot);
 327         }
 328     }
 329 }
 330
 331 void WorldSession::HandleBuyItemInSlotOpcode( WorldPacket & recv_data )
 332 {
 333     sLog.outDetail( "WORLD: Received CMSG_BUY_ITEM_IN_SLOT" );
 334
 335     WorldPacket data;
 336     uint64 srcguid, dstguid;
 337     uint32 itemid;
 338     uint8 slot, amount;
 339     int vendorslot = -1;
 340     int32 newmoney;
 341     Bag *bag;
 342     uint8 slotType=0;
 343     bool buyOk = false;
 344     UpdateData upd;
 345     WorldPacket packet;
 346
 347     /*
 348     SMSG_BUY_FAILED error
 349     0: cant find item
 350     1: item already selled
 351     2: not enought money
 352     4: seller dont like u
 353     5: distance too far
 354     8: cant carry more
 355     11: level require
 356     12: reputation require
 357     */
 358
 359     recv_data >> srcguid >> itemid >> dstguid >> slot >> amount;
 360
 361     Creature *unit = ObjectAccessor::Instance().GetCreature(*_player, srcguid);
 362     Player *player = GetPlayer();
 363
 364     if (unit == NULL)
 365         return;
 366
 367     if(dstguid == GetPlayer()->GetGUID())
 368     {
 369         slotType=CLIENT_SLOT_BACK;
 370     }
 371     else
 372     {
 373         for (uint8 i=CLIENT_SLOT_01;i<=CLIENT_SLOT_04;i++)
 374         {
 375             bag=GetPlayer()->GetBagBySlot(i);
 376             if(bag)
 377             {
 378                 if( dstguid == bag->GetGUID() )
 379                 {
 380                     slotType = i;
 381                     break;
 382                 }
 383             }
 384         }
 385     }
 386
 387     ItemPrototype *ItemPro = objmgr.GetItemPrototype(itemid);
 388     if(ItemPro)
 389     {
 390         //check money
 391         if( slotType>0 )
 392         {
 393             newmoney = ((GetPlayer()->GetUInt32Value(PLAYER_FIELD_COINAGE)) - (ItemPro->BuyPrice));
 394             if(newmoney < 0 )
 395             {
 396                 data.Initialize( SMSG_BUY_FAILED );
 397                 data << uint64(srcguid);
 398                 data << uint32(itemid);
 399                 data << uint8(2);
 400                 SendPacket( &data );
 401                 return;
 402             }
 403             //check level
 404             if(ItemPro->RequiredLevel> GetPlayer()->getLevel())
 405             {
 406                 data.Initialize( SMSG_BUY_FAILED );
 407                 data << uint64(srcguid);
 408                 data << uint32(itemid);
 409                 data << uint8(11);
 410                 SendPacket( &data );
 411                 return;
 412             }
 413             // Check if item is usable
 414             if( (slot < EQUIPMENT_SLOT_END) && (slotType==CLIENT_SLOT_BACK) )
 415             {
 416                 uint8 error =0;
 417                 //                  uint8 error = GetPlayer()->CanEquipItem(ItemPro);
 418                 if (error)
 419                 {
 420                     data.Initialize( SMSG_INVENTORY_CHANGE_FAILURE );
 421                     data << uint8(error);
 422                     if (error == EQUIP_ERR_YOU_MUST_REACH_LEVEL_N)
 423                     {
 424                         data << (uint32)ItemPro->RequiredLevel;
 425                         data << uint64(srcguid);
 426                         data << uint64(0);
 427                         data << uint8(0);
 428                         SendPacket( &data );
 429                         return;
 430                     }
 431                 }
 432             }
 433             //}
 434             //check seller
 435             for(uint8 i = 0; i < unit->getItemCount(); i++)
 436             {
 437                 if (unit->getItemId(i) == itemid)
 438                 {
 439                     vendorslot = i;
 440                     break;
 441                 }
 442             }
 443             if(( vendorslot == -1 )||((amount > unit->getItemAmount(vendorslot)) &&
 444                 (unit->getItemAmount(vendorslot)>=0)))
 445             {
 446                 data.Initialize( SMSG_BUY_FAILED );
 447                 data << uint64(srcguid);
 448                 data << uint32(itemid);
 449                 data << uint8(1);
 450                 SendPacket( &data );
 451                 return;
 452             }
 453             //add to slot
 454             if(GetPlayer()->AddNewItem (slotType,slot,itemid,amount,false,false))
 455             {
 456                 GetPlayer()->SetUInt32Value( PLAYER_FIELD_COINAGE , newmoney);
 457                 data.Initialize( SMSG_BUY_ITEM );
 458                 data << uint64(srcguid);
 459                 data << uint32(itemid) << uint32(amount);
 460                 SendPacket( &data );
 461                 sLog.outDetail( "WORLD: Sent SMSG_BUY_ITEM" );
 462             }
 463             else
 464             {
 465                 data.Initialize( SMSG_BUY_FAILED );
 466                 data << uint64(srcguid);
 467                 data<< uint32(itemid);
 468                 data << uint8(8);
 469                 SendPacket( &data );
 470             }
 471         }
 472     }                                                       //if(!ItemPro)
 473     else
 474     {
 475         data.Initialize( SMSG_BUY_FAILED );
 476         data << uint64(srcguid);
 477         data<< uint32(itemid);
 478         data << uint8(0);
 479         SendPacket( &data );
 480     }
 481 }
 482
 483 void WorldSession::HandleBuyItemOpcode( WorldPacket & recv_data )
 484 {
 485     sLog.outDetail( "WORLD: Received CMSG_BUY_ITEM" );
 486
 487     WorldPacket data;
 488     uint64 srcguid;
 489     uint32 itemid;
 490     uint8 amount, slot;
 491     uint8 playerslot = 0;
 492     int vendorslot = -1;
 493     int32 newmoney;
 494
 495     recv_data >> srcguid >> itemid;
 496     recv_data >> amount >> slot;
 497
 498     Creature *unit = ObjectAccessor::Instance().GetCreature(*_player, srcguid);
 499
 500     if (unit == NULL)
 501         return;
 502     ItemPrototype *ItemPro = objmgr.GetItemPrototype(itemid);
 503     if(ItemPro)
 504     {
 505         for(uint8 i = 0; i < unit->getItemCount(); i++)
 506         {
 507             if (unit->getItemId(i) == itemid)
 508             {
 509                 vendorslot = i;
 510                 break;
 511             }
 512         }
 513
 514         if(( vendorslot == -1 )||((amount > unit->getItemAmount(vendorslot)) &&
 515             (unit->getItemAmount(vendorslot)>=0)))
 516         {
 517             data.Initialize( SMSG_BUY_FAILED );
 518             data << uint64(srcguid);
 519             data << uint32(itemid);
 520             data << uint8(1);
 521             SendPacket( &data );
 522             return;
 523         }
 524
 525         newmoney = ((GetPlayer()->GetUInt32Value(PLAYER_FIELD_COINAGE)) - (objmgr.GetItemPrototype(itemid)->BuyPrice));
 526         if(newmoney < 0 )
 527         {
 528             data.Initialize( SMSG_BUY_FAILED );
 529             data << uint64(srcguid);
 530             data << uint32(itemid);
 531             data << uint8(2);
 532             SendPacket( &data );
 533             return;
 534         }
 535
 536         if (GetPlayer()->AddNewItem(0,NULL_SLOT,itemid,amount,false,false))
 537         {
 538             GetPlayer()->SetUInt32Value( PLAYER_FIELD_COINAGE , newmoney);
 539             data.Initialize( SMSG_BUY_ITEM );
 540             data << uint64(srcguid);
 541             data << uint32(itemid) << uint32(amount);
 542             SendPacket( &data );
 543             sLog.outDetail( "WORLD: Sent SMSG_BUY_ITEM" );
 544             return;
 545         }
 546         else
 547         {
 548             data.Initialize( SMSG_BUY_FAILED );
 549             data << uint64(srcguid);
 550             data<< uint32(itemid);
 551             data << uint8(8);
 552             SendPacket( &data );
 553         }
 554     }
 555     else
 556     {
 557         data.Initialize( SMSG_BUY_FAILED );
 558         data << uint64(srcguid);
 559         data<< uint32(itemid);
 560         data << uint8(0);
 561         SendPacket( &data );
 562     }
 563 }
 564
 565 void WorldSession::HandleListInventoryOpcode( WorldPacket & recv_data )
 566 {
 567
 568     WorldPacket data;
 569     uint64 guid;
 570
 571     recv_data >> guid;
 572     sLog.outDetail( "WORLD: Recvd CMSG_LIST_INVENTORY %u", guid );
 573     Creature *unit = ObjectAccessor::Instance().GetCreature(*_player, guid);
 574
 575     if (unit == NULL)
 576         return;
 577
 578     uint8 numitems = (uint8)unit->getItemCount();
 579     uint8 actualnumitems = 0;
 580     uint8 i = 0;
 581
 582     for(i = 0; i < numitems; i ++ )
 583     {
 584         if(unit->getItemId(i) != 0) actualnumitems++;
 585     }
 586     uint32 guidlow = GUID_LOPART(guid);
 587
 588     data.Initialize( SMSG_LIST_INVENTORY );
 589     data << guid;
 590     data << uint8( actualnumitems );
 591
 592     ItemPrototype * curItem;
 593     for(i = 0; i < numitems; i++ )
 594     {
 595         if(unit->getItemId(i) != 0)
 596         {
 597             curItem = unit->getProtoByslot(i);
 598
 599             if( !curItem )
 600             {
 601                 sLog.outError( "Unit %i has nonexistant item %i! the item will be removed next time", guid, unit->getItemId(i) );
 602                 for( int a = 0; a < 7; a ++ )
 603                     data << uint32( 0 );
 604
 605                 // That should be OR or AND ?
 606                 sDatabase.PExecute("DELETE * FROM `vendor` WHERE `entry` = '%u' AND `itemguid` = '%u'", unit->GetEntry(),unit->getItemId(i));
 607
 608                 unit->setItemAmount(i,0);
 609                 unit->setItemId(i,0);
 610
 611             }
 612             else
 613             {
 614                 data << uint32( i + 1 );
 615
 616                 data << uint32( unit->getItemId(i) );
 617
 618                 data << uint32( curItem->DisplayInfoID );
 619
 620                 data << uint32( unit->getItemAmount(i) );
 621
 622                 data << uint32( curItem->BuyPrice );
 623                 data << uint32( 0 );
 624                 data << uint32( 0 );
 625             }
 626         }
 627     }
 628
 629     if (!(data.size() == 8 + 1 + ((actualnumitems * 7) * 4)))
 630         return;
 631
 632     WPAssert(data.size() == 8 + 1 + ((actualnumitems * 7) * 4));
 633     SendPacket( &data );
 634     sLog.outDetail( "WORLD: Sent SMSG_LIST_INVENTORY" );
 635 }
 636
 637 void WorldSession::SendListInventory( uint64 guid )
 638 {
 639     WorldPacket data;
 640
 641     Creature *unit = ObjectAccessor::Instance().GetCreature(*_player, guid);
 642
 643     if (unit == NULL)
 644         return;
 645
 646     uint8 numitems = (uint8)unit->getItemCount();
 647     uint8 actualnumitems = 0;
 648     uint8 i = 0;
 649
 650     for(i = 0; i < numitems; i ++ )
 651     {
 652         if(unit->getItemId(i) != 0) actualnumitems++;
 653     }
 654     uint32 guidlow = GUID_LOPART(guid);
 655
 656     data.Initialize( SMSG_LIST_INVENTORY );
 657     data << guid;
 658     data << uint8( actualnumitems );
 659
 660     ItemPrototype * curItem;
 661     for(i = 0; i < numitems; i++ )
 662     {
 663         if(unit->getItemId(i) != 0)
 664         {
 665             curItem = unit->getProtoByslot(i);
 666             if( !curItem )
 667             {
 668                 sLog.outError( "Unit %i has nonexistant item %i! the item will be removed next time", guid, unit->getItemId(i) );
 669                 for( int a = 0; a < 7; a ++ )
 670                     data << uint32( 0 );
 671
 672                 sDatabase.PExecute("DELETE * FROM `vendor` WHERE `entry` = '%u' AND `itemguid` = '%u'", unit->GetEntry(),unit->getItemId(i));
 673
 674                 unit->setItemAmount(i,0);
 675                 unit->setItemId(i,0);
 676             }
 677             else
 678             {
 679                 data << uint32( i + 1 );
 680
 681                 data << uint32( unit->getItemId(i) );
 682
 683                 data << uint32( curItem->DisplayInfoID );
 684
 685                 data << uint32( unit->getItemAmount(i) );
 686
 687                 data << uint32( curItem->BuyPrice );
 688                 data << uint32( 0 );
 689                 data << uint32( 0 );
 690             }
 691         }
 692     }
 693
 694     if (!(data.size() == 8 + 1 + ((actualnumitems * 7) * 4)))
 695         return;
 696
 697     WPAssert(data.size() == 8 + 1 + ((actualnumitems * 7) * 4));
 698     SendPacket( &data );
 699     sLog.outDetail( "WORLD: Sent SMSG_LIST_INVENTORY" );
 700 }
 701
 702 void WorldSession::HandleAutoStoreBagItemOpcode( WorldPacket & recv_data )
 703 {
 704     sLog.outDebug("WORLD: CMSG_AUTOSTORE_BAG_ITEM");
 705     WorldPacket data;
 706     uint8 srcBag, srcSlot, dstBag, result;
 707
 708     recv_data >> srcBag >> srcSlot >> dstBag;
 709
 710     sLog.outDetail("ITEM: Autostore item, srcBag = %d, srcSlot = %d, dstBag = %d", srcBag, srcSlot, dstBag);
 711
 712     Item *pItem = GetPlayer()->GetItemBySlot(srcBag, srcSlot);
 713
 714     if (!pItem)
 715     {
 716         sLog.outDetail("ITEM: The item doesn't exist");
 717         return;
 718     }
 719
 720     result = GetPlayer()->AddItemToBag(dstBag, pItem, true, true, false);
 721
 722     if (!result)
 723     {
 724         data.Initialize(SMSG_INVENTORY_CHANGE_FAILURE);
 725         data << uint8(EQUIP_ERR_BAG_FULL);
 726         data << (pItem ? pItem->GetGUID() : uint64(0));
 727         data << uint64(0);
 728         data << uint8(0);
 729         SendPacket(&data);
 730         return;
 731     }
 732
 733     GetPlayer()->RemoveItemFromSlot(srcBag, srcSlot);
 734     GetPlayer()->AddItemToBag(dstBag, pItem, true, false, true);
 735     if (result == 2)
 736     {
 737         pItem->DeleteFromDB();
 738         delete pItem;
 739     }
 740     //GetPlayer()->_SaveInventory();
 741 }
 742
 743 void WorldSession::HandleBuyBankSlotOpcode(WorldPacket& recvPacket)
 744 {
 745     sLog.outDebug("WORLD: CMSG_BUY_BANK_SLOT");
 746     uint32 bank, result, price, playerGold;
 747
 748     bank = GetPlayer()->GetUInt32Value(PLAYER_BYTES_2);
 749     result = (bank & 0x70000) >> 16;
 750
 751     sLog.outDetail("PLAYER: Buy bank bag slot, slot number = %d", result);
 752
 753     // Prices Hardcoded
 754     switch (result)
 755     {
 756         case 0:
 757             price = 1000;
 758             break;
 759         case 1:
 760             price = 10000;
 761             break;
 762         case 2:
 763             price = 100000;
 764             break;
 765         case 3:
 766             price = 250000;
 767             break;
 768         case 4:
 769             price = 500000;
 770             break;
 771         case 5:
 772             price = 1000000;
 773             break;
 774         default:
 775             return;
 776     }
 777
 778     if (result < 6)
 779     {
 780         result++;
 781     }
 782     else
 783     {
 784         return;
 785     }
 786     bank = (bank & ~0x70000) + (result << 16);
 787     playerGold = GetPlayer()->GetUInt32Value(PLAYER_FIELD_COINAGE);
 788     if (playerGold >= price)
 789     {
 790         GetPlayer()->SetUInt32Value(PLAYER_BYTES_2, bank);
 791         GetPlayer()->SetUInt32Value(PLAYER_FIELD_COINAGE, playerGold - price);
 792     }
 793 }
 794
 795 void WorldSession::HandleAutoBankItemOpcode(WorldPacket& recvPacket)
 796 {
 797     sLog.outDebug("WORLD: CMSG_AUTOBANK_ITEM");
 798     WorldPacket data;
 799     uint8 bagIndex, slot, result;
 800     Item *pItem;
 801
 802     recvPacket >> bagIndex >> slot;
 803
 804     pItem = GetPlayer()->GetItemBySlot(bagIndex, slot);
 805
 806     if (!pItem)
 807     {
 808         sLog.outDetail("ITEM: Unknown item");
 809         return;
 810     }
 811
 812     result = GetPlayer()->AddItemToBank(0, NULL_SLOT, pItem, true, true, true);
 813
 814     if (!result)
 815     {
 816         data.Initialize(SMSG_INVENTORY_CHANGE_FAILURE);
 817         data << uint8(EQUIP_ERR_BANK_FULL);
 818         data << (pItem ? pItem->GetGUID() : uint64(0));
 819         data << uint64(0);
 820         data << uint8(0);
 821         SendPacket(&data);
 822         return;
 823     }
 824
 825     GetPlayer()->RemoveItemFromSlot(bagIndex, slot);
 826     GetPlayer()->AddItemToBank(0, NULL_SLOT, pItem, true, false, false);
 827     if (result == 2)
 828     {
 829         pItem->DeleteFromDB();
 830         delete pItem;
 831     }
 832     //GetPlayer()->_SaveInventory();
 833 }
 834
 835 void WorldSession::HandleAutoStoreBankItemOpcode(WorldPacket& recvPacket)
 836 {
 837     sLog.outDebug("WORLD: CMSG_AUTOSTORE_BANK_ITEM");
 838     WorldPacket data;
 839     uint8 bagIndex, slot, result;
 840     Item *pItem;
 841
 842     recvPacket >> bagIndex >> slot;
 843
 844     pItem = GetPlayer()->GetItemBySlot(bagIndex, slot);
 845
 846     if (!pItem)
 847     {
 848         sLog.outDetail("ITEM: Unknown item");
 849         return;
 850     }
 851
 852     result = GetPlayer()->AddItemToInventory(0, NULL_SLOT, pItem, true, true, true);
 853
 854     if (!result)
 855     {
 856         data.Initialize(SMSG_INVENTORY_CHANGE_FAILURE);
 857         data << uint8(EQUIP_ERR_INVENTORY_FULL);
 858         data << (pItem ? pItem->GetGUID() : uint64(0));
 859         data << uint64(0);
 860         data << uint8(0);
 861         SendPacket(&data);
 862         return;
 863     }
 864
 865     GetPlayer()->RemoveItemFromSlot(bagIndex, slot);
 866     GetPlayer()->AddItemToInventory(0, NULL_SLOT, pItem, true, false, false);
 867     if (result == 2)
 868     {
 869         pItem->DeleteFromDB();
 870         delete pItem;
 871     }
 872     //GetPlayer()->_SaveInventory();
 873 }